External Serialize Context for spawning

This change makes it possible to provide a Serialize Context for spawning entities from spawnables. This also removes the need for the Serialize Context to be retrieved multiple times per frame.
2021-05-27 09:56:11 -07:00
parent c009e7d50b
commit 1bf8c599e3
4 changed files with 139 additions and 98 deletions
@@ -21,6 +21,7 @@
 namespace AZ
 {
    class Entity;
+    class SerializeContext;
 }

 namespace AzFramework
@@ -171,6 +172,34 @@ namespace AzFramework
    using ClaimEntitiesCallback = AZStd::function<void(EntitySpawnTicket::Id, SpawnableEntityContainerView)>;
    using BarrierCallback = AZStd::function<void(EntitySpawnTicket::Id)>;

+    struct SpawnEntitiesOptionalArgs
+    {
+        //! Callback that's called after instances of entities have been created, but before they're spawned into the world. This
+        //!     gives the opportunity to modify the entities if needed such as injecting additional components or modifying components.
+        EntityPreInsertionCallback m_preInsertionCallback;
+        //! Callback that's called when spawning entities has completed. This can be called from a different thread than the one that
+        //!     made the function call. The returned list of entities contains all the newly created entities.
+        EntitySpawnCallback m_completionCallback;
+        //! The Serialize Context used to clone entities with. If this is not provided the global Serialize Contetx will be used.
+        AZ::SerializeContext* m_serializeContext { nullptr };
+    };
+
+    struct DespawnAllEntitiesOptionalArgs
+    {
+        //! Callback that's called when spawning entities has completed. This can be called from a different thread than the one that
+        //!     made the function call. The returned list of entities contains all the newly created entities.
+        EntityDespawnCallback m_completionCallback;
+    };
+
+    struct ReloadSpawnableOptionalArgs
+    {
+        //! Callback that's called when spawning entities has completed. This can be called from a different thread than the one that
+        //!     made the function call. The returned list of entities contains all the newly created entities.
+        ReloadSpawnableCallback m_completionCallback;
+        //! The Serialize Context used to clone entities with. If this is not provided the global Serialize Contetx will be used.
+        AZ::SerializeContext* m_serializeContext { nullptr };
+    };
+
    //! Interface definition to (de)spawn entities from a spawnable into the game world.
    //! 
    //! While the callbacks of the individual calls are being processed they will block processing any other request. Callbacks can be
@@ -197,40 +226,31 @@ namespace AzFramework
        //! Spawn instances of all entities in the spawnable.
        //! @param ticket Stores the results of the call. Use this ticket to spawn additional entities or to despawn them.
        //! @param priority The priority at which this call will be executed.
-        //! @param completionCallback Optional callback that's called when spawning entities has completed. This can be called from
-        //!     a different thread than the one that made the function call. The returned list of entities contains all the newly
-        //!     created entities.
+        //! @param optionalArgs Optional additional arguments, see SpawnAllEntitiesOptionalArgs
        virtual void SpawnAllEntities(
-            EntitySpawnTicket& ticket, SpawnablePriority priority, EntityPreInsertionCallback preInsertionCallback = {},
-            EntitySpawnCallback completionCallback = {}) = 0;
+            EntitySpawnTicket& ticket, SpawnablePriority priority, SpawnEntitiesOptionalArgs optionalArgs = {}) = 0;
        //! Spawn instances of some entities in the spawnable.
        //! @param ticket Stores the results of the call. Use this ticket to spawn additional entities or to despawn them.
        //! @param priority The priority at which this call will be executed.
        //! @param entityIndices The indices into the template entities stored in the spawnable that will be used to spawn entities from.
-        //! @param completionCallback Optional callback that's called when spawning entities has completed. This can be called from
-        //!     a different thread than the one that made this function call. The returned list of entities contains all the newly
-        //!     created entities.
+        //! @param optionalArgs Optional additional arguments, see SpawnAllEntitiesOptionalArgs
        virtual void SpawnEntities(
            EntitySpawnTicket& ticket, SpawnablePriority priority, AZStd::vector<size_t> entityIndices,
-            EntityPreInsertionCallback preInsertionCallback = {}, EntitySpawnCallback completionCallback = {}) = 0;
+            SpawnEntitiesOptionalArgs optionalArgs = {}) = 0;
        //! Removes all entities in the provided list from the environment.
        //! @param ticket The ticket previously used to spawn entities with.
        //! @param priority The priority at which this call will be executed.
-        //! @param completionCallback Optional callback that's called when despawning entities has completed. This can be called from
-        //!     a different thread than the one that made this function call.
+        //! @param optionalArgs Optional additional arguments, see SpawnAllEntitiesOptionalArgs
        virtual void DespawnAllEntities(
-            EntitySpawnTicket& ticket, SpawnablePriority priority, EntityDespawnCallback completionCallback = {}) = 0;
-
+            EntitySpawnTicket& ticket, SpawnablePriority priority, DespawnAllEntitiesOptionalArgs optionalArgs = {}) = 0;
        //! Removes all entities in the provided list from the environment and reconstructs the entities from the provided spawnable.
        //! @param ticket Holds the information on the entities to reload.
        //! @param priority The priority at which this call will be executed.
        //! @param spawnable The spawnable that will replace the existing spawnable. Both need to have the same asset id.
-        //! @param completionCallback Optional callback that's called when the entities have been reloaded. This can be called from
-        //!     a different thread than the one that made this function call. The returned list of entities contains all the replacement
-        //!     entities.
+        //! @param optionalArgs Optional additional arguments, see SpawnAllEntitiesOptionalArgs
        virtual void ReloadSpawnable(
            EntitySpawnTicket& ticket, SpawnablePriority priority, AZ::Data::Asset<Spawnable> spawnable,
-            ReloadSpawnableCallback completionCallback = {}) = 0;
+            ReloadSpawnableOptionalArgs optionalArgs = {}) = 0;

        //! List all entities that are spawned using this ticket.
        //! @param ticket Only the entities associated with this ticket will be listed.
@@ -38,6 +38,10 @@ namespace AzFramework

    SpawnableEntitiesManager::SpawnableEntitiesManager()
    {
+        AZ::ComponentApplicationBus::BroadcastResult(m_defaultSerializeContext, &AZ::ComponentApplicationBus::Events::GetSerializeContext);
+        AZ_Assert(
+            m_defaultSerializeContext, "Failed to retrieve serialization context during construction of the Spawnable Entities Manager.");
+
        if (auto settingsRegistry = AZ::SettingsRegistry::Get(); settingsRegistry != nullptr)
        {
            AZ::u64 value = aznumeric_caster(m_highPriorityThreshold);
@@ -47,53 +51,57 @@ namespace AzFramework
    }

    void SpawnableEntitiesManager::SpawnAllEntities(
-        EntitySpawnTicket& ticket, SpawnablePriority priority, EntityPreInsertionCallback preInsertionCallback,
-        EntitySpawnCallback completionCallback)
+        EntitySpawnTicket& ticket, SpawnablePriority priority, SpawnEntitiesOptionalArgs optionalArgs)
    {
        AZ_Assert(ticket.IsValid(), "Ticket provided to SpawnAllEntities hasn't been initialized.");

        SpawnAllEntitiesCommand queueEntry;
        queueEntry.m_ticketId = ticket.GetId();
-        queueEntry.m_completionCallback = AZStd::move(completionCallback);
-        queueEntry.m_preInsertionCallback = AZStd::move(preInsertionCallback);
+        queueEntry.m_serializeContext =
+            optionalArgs.m_serializeContext == nullptr ? m_defaultSerializeContext : optionalArgs.m_serializeContext;
+        queueEntry.m_completionCallback = AZStd::move(optionalArgs.m_completionCallback);
+        queueEntry.m_preInsertionCallback = AZStd::move(optionalArgs.m_preInsertionCallback);
        QueueRequest(ticket, priority, AZStd::move(queueEntry));
    }

    void SpawnableEntitiesManager::SpawnEntities(
-        EntitySpawnTicket& ticket, SpawnablePriority priority, AZStd::vector<size_t> entityIndices,
-        EntityPreInsertionCallback preInsertionCallback, EntitySpawnCallback completionCallback)
+        EntitySpawnTicket& ticket, SpawnablePriority priority, AZStd::vector<size_t> entityIndices, SpawnEntitiesOptionalArgs optionalArgs)
    {
        AZ_Assert(ticket.IsValid(), "Ticket provided to SpawnEntities hasn't been initialized.");

        SpawnEntitiesCommand queueEntry;
        queueEntry.m_ticketId = ticket.GetId();
        queueEntry.m_entityIndices = AZStd::move(entityIndices);
-        queueEntry.m_completionCallback = AZStd::move(completionCallback);
-        queueEntry.m_preInsertionCallback = AZStd::move(preInsertionCallback);
+        queueEntry.m_serializeContext =
+            optionalArgs.m_serializeContext == nullptr ? m_defaultSerializeContext : optionalArgs.m_serializeContext;
+        queueEntry.m_completionCallback = AZStd::move(optionalArgs.m_completionCallback);
+        queueEntry.m_preInsertionCallback = AZStd::move(optionalArgs.m_preInsertionCallback);
        QueueRequest(ticket, priority, AZStd::move(queueEntry));
    }

    void SpawnableEntitiesManager::DespawnAllEntities(
-        EntitySpawnTicket& ticket, SpawnablePriority priority, EntityDespawnCallback completionCallback)
+        EntitySpawnTicket& ticket, SpawnablePriority priority, DespawnAllEntitiesOptionalArgs optionalArgs)
    {
        AZ_Assert(ticket.IsValid(), "Ticket provided to DespawnAllEntities hasn't been initialized.");

        DespawnAllEntitiesCommand queueEntry;
        queueEntry.m_ticketId = ticket.GetId();
-        queueEntry.m_completionCallback = AZStd::move(completionCallback);
+        queueEntry.m_completionCallback = AZStd::move(optionalArgs.m_completionCallback);
        QueueRequest(ticket, priority, AZStd::move(queueEntry));
    }

    void SpawnableEntitiesManager::ReloadSpawnable(
        EntitySpawnTicket& ticket, SpawnablePriority priority, AZ::Data::Asset<Spawnable> spawnable,
-        ReloadSpawnableCallback completionCallback)
+        ReloadSpawnableOptionalArgs optionalArgs)
    {
        AZ_Assert(ticket.IsValid(), "Ticket provided to ReloadSpawnable hasn't been initialized.");

        ReloadSpawnableCommand queueEntry;
        queueEntry.m_ticketId = ticket.GetId();
        queueEntry.m_spawnable = AZStd::move(spawnable);
-        queueEntry.m_completionCallback = AZStd::move(completionCallback);
+        queueEntry.m_serializeContext =
+            optionalArgs.m_serializeContext == nullptr ? m_defaultSerializeContext : optionalArgs.m_serializeContext;
+        queueEntry.m_completionCallback = AZStd::move(optionalArgs.m_completionCallback);
        QueueRequest(ticket, priority, AZStd::move(queueEntry));
    }

@@ -174,58 +182,57 @@ namespace AzFramework

    auto SpawnableEntitiesManager::ProcessQueue(Queue& queue) -> CommandQueueStatus
    {
-        AZStd::queue<Requests> pendingRequestQueue;
+        // Process delayed requests first.
+        // Only process the requests that are currently in this queue, not the ones that could be re-added if they still can't complete.
+        size_t delayedSize = queue.m_delayed.size();
+        for (size_t i = 0; i < delayedSize; ++i)
        {
-            AZStd::scoped_lock queueLock(queue.m_pendingRequestMutex);
-            queue.m_pendingRequest.swap(pendingRequestQueue);
+            Requests& request = queue.m_delayed.front();
+            bool result = AZStd::visit(
+                [this](auto&& args) -> bool
+                {
+                    return ProcessRequest(args);
+                },
+                request);
+            if (!result)
+            {
+                queue.m_delayed.emplace_back(AZStd::move(request));
+            }
+            queue.m_delayed.pop_front();
        }

-        if (!pendingRequestQueue.empty() || !queue.m_delayed.empty())
+        // Process newly added requests.
+        while (true)
        {
-            AZ::SerializeContext* serializeContext = nullptr;
-            AZ::ComponentApplicationBus::BroadcastResult(serializeContext, &AZ::ComponentApplicationBus::Events::GetSerializeContext);
-            AZ_Assert(serializeContext, "Failed to retrieve serialization context.");
-
-            // Only process the requests that are currently in this queue, not the ones that could be re-added if they still can't complete.
-            size_t delayedSize = queue.m_delayed.size();
-            for (size_t i = 0; i < delayedSize; ++i)
+            AZStd::queue<Requests> pendingRequestQueue;
            {
-                Requests& request = queue.m_delayed.front();
-                bool result = AZStd::visit([this, serializeContext](auto&& args) -> bool
-                    {
-                        return ProcessRequest(args, *serializeContext);
-                    }, request);
-                if (!result)
-                {
-                    queue.m_delayed.emplace_back(AZStd::move(request));
-                }
-                queue.m_delayed.pop_front();
+                AZStd::scoped_lock queueLock(queue.m_pendingRequestMutex);
+                queue.m_pendingRequest.swap(pendingRequestQueue);
            }

-            do
+            if (!pendingRequestQueue.empty())
            {
                while (!pendingRequestQueue.empty())
                {
                    Requests& request = pendingRequestQueue.front();
-                    bool result = AZStd::visit([this, serializeContext](auto&& args) -> bool
+                    bool result = AZStd::visit(
+                        [this](auto&& args) -> bool
                        {
-                            return ProcessRequest(args, *serializeContext);
-                        }, request);
+                            return ProcessRequest(args);
+                        },
+                        request);
                    if (!result)
                    {
                        queue.m_delayed.emplace_back(AZStd::move(request));
                    }
                    pendingRequestQueue.pop();
                }
-
-                // Spawning entities can result in more entities being queued to spawn. Repeat spawning until the queue is
-                // empty to avoid a chain of entity spawning getting dragged out over multiple frames.
-                {
-                    AZStd::scoped_lock queueLock(queue.m_pendingRequestMutex);
-                    queue.m_pendingRequest.swap(pendingRequestQueue);
-                }
-            } while (!pendingRequestQueue.empty());
-        }
+            }
+            else
+            {
+                break;
+            }
+        };

        return queue.m_delayed.empty() ? CommandQueueStatus::NoCommandsLeft : CommandQueueStatus::HasCommandsLeft;
    }
@@ -267,7 +274,7 @@ namespace AzFramework
                &entityTemplate, templateToCloneEntityIdMap, &serializeContext);
    }

-    bool SpawnableEntitiesManager::ProcessRequest(SpawnAllEntitiesCommand& request, AZ::SerializeContext& serializeContext)
+    bool SpawnableEntitiesManager::ProcessRequest(SpawnAllEntitiesCommand& request)
    {
        Ticket& ticket = *request.m_ticket;
        if (ticket.m_spawnable.IsReady() && request.m_requestId == ticket.m_currentRequestId)
@@ -296,7 +303,7 @@ namespace AzFramework
            {
                const AZ::Entity& entityTemplate = *entitiesToSpawn[i];

-                AZ::Entity* clone = CloneSingleEntity(entityTemplate, templateToCloneEntityIdMap, serializeContext);
+                AZ::Entity* clone = CloneSingleEntity(entityTemplate, templateToCloneEntityIdMap, *request.m_serializeContext);

                AZ_Assert(clone != nullptr, "Failed to clone spawnable entity.");

@@ -347,7 +354,7 @@ namespace AzFramework
        }
    }

-    bool SpawnableEntitiesManager::ProcessRequest(SpawnEntitiesCommand& request, AZ::SerializeContext& serializeContext)
+    bool SpawnableEntitiesManager::ProcessRequest(SpawnEntitiesCommand& request)
    {
        Ticket& ticket = *request.m_ticket;
        if (ticket.m_spawnable.IsReady() && request.m_requestId == ticket.m_currentRequestId)
@@ -371,7 +378,7 @@ namespace AzFramework
                {
                    const AZ::Entity& entityTemplate = *entitiesToSpawn[index];

-                    AZ::Entity* clone = serializeContext.CloneObject(&entityTemplate);
+                    AZ::Entity* clone = request.m_serializeContext->CloneObject(&entityTemplate);
                    AZ_Assert(clone != nullptr, "Failed to clone spawnable entity.");
                    clone->SetId(AZ::Entity::MakeId());

@@ -413,8 +420,7 @@ namespace AzFramework
        }
    }

-    bool SpawnableEntitiesManager::ProcessRequest(DespawnAllEntitiesCommand& request,
-        [[maybe_unused]] AZ::SerializeContext& serializeContext)
+    bool SpawnableEntitiesManager::ProcessRequest(DespawnAllEntitiesCommand& request)
    {
        Ticket& ticket = *request.m_ticket;
        if (request.m_requestId == ticket.m_currentRequestId)
@@ -447,7 +453,7 @@ namespace AzFramework
        }
    }

-    bool SpawnableEntitiesManager::ProcessRequest(ReloadSpawnableCommand& request, AZ::SerializeContext& serializeContext)
+    bool SpawnableEntitiesManager::ProcessRequest(ReloadSpawnableCommand& request)
    {
        Ticket& ticket = *request.m_ticket;
        AZ_Assert(ticket.m_spawnable.GetId() == request.m_spawnable.GetId(),
@@ -488,7 +494,7 @@ namespace AzFramework
                {
                    const AZ::Entity& entityTemplate = *entities[i];

-                    AZ::Entity* clone = CloneSingleEntity(entityTemplate, templateToCloneEntityIdMap, serializeContext);
+                    AZ::Entity* clone = CloneSingleEntity(entityTemplate, templateToCloneEntityIdMap, *request.m_serializeContext);

                    AZ_Assert(clone != nullptr, "Failed to clone spawnable entity.");

@@ -502,7 +508,7 @@ namespace AzFramework
                for (size_t index : ticket.m_spawnedEntityIndices)
                {
                    ticket.m_spawnedEntities.push_back(
-                        index < entitiesSize ? SpawnSingleEntity(*entities[index], serializeContext) : nullptr);
+                        index < entitiesSize ? SpawnSingleEntity(*entities[index], *request.m_serializeContext) : nullptr);
                }
            }
            ticket.m_spawnable = AZStd::move(request.m_spawnable);
@@ -525,7 +531,7 @@ namespace AzFramework
        }
    }

-    bool SpawnableEntitiesManager::ProcessRequest(ListEntitiesCommand& request, [[maybe_unused]] AZ::SerializeContext& serializeContext)
+    bool SpawnableEntitiesManager::ProcessRequest(ListEntitiesCommand& request)
    {
        Ticket& ticket = *request.m_ticket;
        if (request.m_requestId == ticket.m_currentRequestId)
@@ -541,7 +547,7 @@ namespace AzFramework
        }
    }

-    bool SpawnableEntitiesManager::ProcessRequest(ListIndicesEntitiesCommand& request, [[maybe_unused]] AZ::SerializeContext& serializeContext)
+    bool SpawnableEntitiesManager::ProcessRequest(ListIndicesEntitiesCommand& request)
    {
        Ticket& ticket = *request.m_ticket;
        if (request.m_requestId == ticket.m_currentRequestId)
@@ -560,7 +566,7 @@ namespace AzFramework
        }
    }

-    bool SpawnableEntitiesManager::ProcessRequest(ClaimEntitiesCommand& request, [[maybe_unused]] AZ::SerializeContext& serializeContext)
+    bool SpawnableEntitiesManager::ProcessRequest(ClaimEntitiesCommand& request)
    {
        Ticket& ticket = *request.m_ticket;
        if (request.m_requestId == ticket.m_currentRequestId)
@@ -580,7 +586,7 @@ namespace AzFramework
        }
    }

-    bool SpawnableEntitiesManager::ProcessRequest(BarrierCommand& request, [[maybe_unused]] AZ::SerializeContext& serializeContext)
+    bool SpawnableEntitiesManager::ProcessRequest(BarrierCommand& request)
    {
        Ticket& ticket = *request.m_ticket;
        if (request.m_requestId == ticket.m_currentRequestId)
@@ -599,7 +605,7 @@ namespace AzFramework
        }
    }

-    bool SpawnableEntitiesManager::ProcessRequest(DestroyTicketCommand& request, [[maybe_unused]] AZ::SerializeContext& serializeContext)
+    bool SpawnableEntitiesManager::ProcessRequest(DestroyTicketCommand& request)
    {
        if (request.m_requestId == request.m_ticket->m_currentRequestId)
        {
@@ -57,19 +57,16 @@ namespace AzFramework
        // The following functions are thread safe
        //

-        void SpawnAllEntities(
-            EntitySpawnTicket& ticket, SpawnablePriority priority, EntityPreInsertionCallback preInsertionCallback = {},
-            EntitySpawnCallback completionCallback = {}) override;
+        void SpawnAllEntities(EntitySpawnTicket& ticket, SpawnablePriority priority, SpawnEntitiesOptionalArgs optionalArgs = {}) override;
        void SpawnEntities(
            EntitySpawnTicket& ticket, SpawnablePriority priority, AZStd::vector<size_t> entityIndices,
-            EntityPreInsertionCallback preInsertionCallback = {},
-            EntitySpawnCallback completionCallback = {}) override;
+            SpawnEntitiesOptionalArgs optionalArgs = {}) override;
        void DespawnAllEntities(
-            EntitySpawnTicket& ticket, SpawnablePriority priority, EntityDespawnCallback completionCallback = {}) override;
+            EntitySpawnTicket& ticket, SpawnablePriority priority, DespawnAllEntitiesOptionalArgs optionalArgs = {}) override;

        void ReloadSpawnable(
            EntitySpawnTicket& ticket, SpawnablePriority priority, AZ::Data::Asset<Spawnable> spawnable,
-            ReloadSpawnableCallback completionCallback = {}) override;
+            ReloadSpawnableOptionalArgs optionalArgs = {}) override;

        void ListEntities(EntitySpawnTicket& ticket, SpawnablePriority priority, ListEntitiesCallback listCallback) override;
        void ListIndicesAndEntities(
@@ -105,6 +102,7 @@ namespace AzFramework
        {
            EntitySpawnCallback m_completionCallback;
            EntityPreInsertionCallback m_preInsertionCallback;
+            AZ::SerializeContext* m_serializeContext;
            Ticket* m_ticket;
            EntitySpawnTicket::Id m_ticketId;
            uint32_t m_requestId;
@@ -114,6 +112,7 @@ namespace AzFramework
            AZStd::vector<size_t> m_entityIndices;
            EntitySpawnCallback m_completionCallback;
            EntityPreInsertionCallback m_preInsertionCallback;
+            AZ::SerializeContext* m_serializeContext;
            Ticket* m_ticket;
            EntitySpawnTicket::Id m_ticketId;
            uint32_t m_requestId;
@@ -129,6 +128,7 @@ namespace AzFramework
        {
            AZ::Data::Asset<Spawnable> m_spawnable;
            ReloadSpawnableCallback m_completionCallback;
+            AZ::SerializeContext* m_serializeContext;
            Ticket* m_ticket;
            EntitySpawnTicket::Id m_ticketId;
            uint32_t m_requestId;
@@ -191,15 +191,15 @@ namespace AzFramework
        AZ::Entity* CloneSingleEntity(const AZ::Entity& entityTemplate,
            EntityIdMap& templateToCloneEntityIdMap, AZ::SerializeContext& serializeContext);

-        bool ProcessRequest(SpawnAllEntitiesCommand& request, AZ::SerializeContext& serializeContext);
-        bool ProcessRequest(SpawnEntitiesCommand& request, AZ::SerializeContext& serializeContext);
-        bool ProcessRequest(DespawnAllEntitiesCommand& request, AZ::SerializeContext& serializeContext);
-        bool ProcessRequest(ReloadSpawnableCommand& request, AZ::SerializeContext& serializeContext);
-        bool ProcessRequest(ListEntitiesCommand& request, AZ::SerializeContext& serializeContext);
-        bool ProcessRequest(ListIndicesEntitiesCommand& request, AZ::SerializeContext& serializeContext);
-        bool ProcessRequest(ClaimEntitiesCommand& request, AZ::SerializeContext& serializeContext);
-        bool ProcessRequest(BarrierCommand& request, AZ::SerializeContext& serializeContext);
-        bool ProcessRequest(DestroyTicketCommand& request, AZ::SerializeContext& serializeContext);
+        bool ProcessRequest(SpawnAllEntitiesCommand& request);
+        bool ProcessRequest(SpawnEntitiesCommand& request);
+        bool ProcessRequest(DespawnAllEntitiesCommand& request);
+        bool ProcessRequest(ReloadSpawnableCommand& request);
+        bool ProcessRequest(ListEntitiesCommand& request);
+        bool ProcessRequest(ListIndicesEntitiesCommand& request);
+        bool ProcessRequest(ClaimEntitiesCommand& request);
+        bool ProcessRequest(BarrierCommand& request);
+        bool ProcessRequest(DestroyTicketCommand& request);

        Queue m_highPriorityQueue;
        Queue m_regularPriorityQueue;
@@ -207,6 +207,7 @@ namespace AzFramework
        AZ::Event<AZ::Data::Asset<Spawnable>> m_onSpawnedEvent;
        AZ::Event<AZ::Data::Asset<Spawnable>> m_onDespawnedEvent;

+        AZ::SerializeContext* m_defaultSerializeContext { nullptr };
        //! The threshold used to determine if a request goes in the regular (if bigger than the value) or high priority queue (if smaller
        //! or equal to this value). The starting value of 64 is chosen as it's between default values SpawnablePriority_High and
        //! SpawnablePriority_Default which gives users a bit of room to fine tune the priorities as this value can be configured
@@ -104,7 +104,9 @@ namespace UnitTest
            {
                spawnedEntitiesCount += entities.size();
            };
-        m_manager->SpawnAllEntities(*m_ticket, AzFramework::SpawnablePriority_Default, {}, AZStd::move(callback));
+        AzFramework::SpawnEntitiesOptionalArgs optionalArgs;
+        optionalArgs.m_completionCallback = AZStd::move(callback);
+        m_manager->SpawnAllEntities(*m_ticket, AzFramework::SpawnablePriority_Default, AZStd::move(optionalArgs));
        m_manager->ProcessQueue(AzFramework::SpawnableEntitiesManager::CommandQueuePriority::Regular);

        EXPECT_EQ(NumEntities, spawnedEntitiesCount);
@@ -305,8 +307,14 @@ namespace UnitTest
                defaultPriorityCallId = callCounter++;
            };

-        m_manager->SpawnAllEntities(*m_ticket, AzFramework::SpawnablePriority_Default, {}, AZStd::move(defaultCallback));
-        m_manager->SpawnAllEntities(highPriorityTicket, AzFramework::SpawnablePriority_High, {}, AZStd::move(highCallback));
+        AzFramework::SpawnEntitiesOptionalArgs optionalArgs;
+        optionalArgs.m_completionCallback = AZStd::move(defaultCallback);
+        m_manager->SpawnAllEntities(*m_ticket, AzFramework::SpawnablePriority_Default, AZStd::move(optionalArgs));
+
+        AzFramework::SpawnEntitiesOptionalArgs highPriortyOptionalArgs;
+        highPriortyOptionalArgs.m_completionCallback = AZStd::move(highCallback);
+        m_manager->SpawnAllEntities(highPriorityTicket, AzFramework::SpawnablePriority_High, AZStd::move(highPriortyOptionalArgs));
+
        m_manager->ProcessQueue(
            AzFramework::SpawnableEntitiesManager::CommandQueuePriority::High |
            AzFramework::SpawnableEntitiesManager::CommandQueuePriority::Regular);
@@ -333,8 +341,14 @@ namespace UnitTest
                defaultPriorityCallId = callCounter++;
            };

-        m_manager->SpawnAllEntities(*m_ticket, AzFramework::SpawnablePriority_Default, {}, AZStd::move(defaultCallback));
-        m_manager->SpawnAllEntities(*m_ticket, AzFramework::SpawnablePriority_High, {}, AZStd::move(highCallback));
+        AzFramework::SpawnEntitiesOptionalArgs optionalArgs;
+        optionalArgs.m_completionCallback = AZStd::move(defaultCallback);
+        m_manager->SpawnAllEntities(*m_ticket, AzFramework::SpawnablePriority_Default, AZStd::move(optionalArgs));
+
+        AzFramework::SpawnEntitiesOptionalArgs highPriortyOptionalArgs;
+        highPriortyOptionalArgs.m_completionCallback = AZStd::move(highCallback);
+        m_manager->SpawnAllEntities(*m_ticket, AzFramework::SpawnablePriority_High, AZStd::move(highPriortyOptionalArgs));
+
        m_manager->ProcessQueue(
            AzFramework::SpawnableEntitiesManager::CommandQueuePriority::High |
            AzFramework::SpawnableEntitiesManager::CommandQueuePriority::Regular);