Several updates to complete rewind support and remove unneeded functionality

Gems/Multiplayer/Code/Source/NetworkTime/NetworkTime.cpp

@@ -13,10 +13,15 @@
 #include <Source/NetworkTime/NetworkTime.h>
 #include <Multiplayer/IMultiplayer.h>
 #include <Multiplayer/Components/NetBindComponent.h>
+#include <Multiplayer/Components/NetworkTransformComponent.h>
+#include <AzCore/Math/ShapeIntersection.h>
 #include <AzFramework/Visibility/IVisibilitySystem.h>
+#include <AzFramework/Visibility/EntityBoundsUnionBus.h>
 
 namespace Multiplayer
 {
+    AZ_CVAR(float, sv_RewindVolumeExtrudeDistance, 50.0f, nullptr, AZ::ConsoleFunctorFlags::Null, "The amount to increase rewind volume checks to account for fast moving entities");
+
     NetworkTime::NetworkTime()
     {
         AZ::Interface<INetworkTime>::Register(this);
@@ -73,35 +78,59 @@ namespace Multiplayer
 
     void NetworkTime::SyncEntitiesToRewindState(const AZ::Aabb& rewindVolume)
     {
-        // TODO: extrude rewind volume for initial gather
-        AZStd::vector<AzFramework::VisibilityEntry*> gatheredEntries;
-        AZ::Interface<AzFramework::IVisibilitySystem>::Get()->GetDefaultVisibilityScene()->Enumerate(rewindVolume, [&gatheredEntries](const AzFramework::IVisibilityScene::NodeData& nodeData)
+        // Since the vis system doesn't support rewound queries, first query with an expanded volume to catch any fast moving entities
+        const AZ::Aabb expandedVolume = rewindVolume.GetExpanded(AZ::Vector3(sv_RewindVolumeExtrudeDistance));
+
+        AzFramework::IEntityBoundsUnion* entityBoundsUnion = AZ::Interface<AzFramework::IEntityBoundsUnion>::Get();
+        AZStd::vector<NetBindComponent*> gatheredEntities;
+        AZ::Interface<AzFramework::IVisibilitySystem>::Get()->GetDefaultVisibilityScene()->Enumerate(expandedVolume,
+            [entityBoundsUnion, rewindVolume, &gatheredEntities](const AzFramework::IVisibilityScene::NodeData& nodeData)
         {
-            gatheredEntries.reserve(gatheredEntries.size() + nodeData.m_entries.size());
+            gatheredEntities.reserve(gatheredEntities.size() + nodeData.m_entries.size());
             for (AzFramework::VisibilityEntry* visEntry : nodeData.m_entries)
             {
                 if (visEntry->m_typeFlags & AzFramework::VisibilityEntry::TypeFlags::TYPE_Entity)
                 {
-                    // TODO: offset aabb for exact rewound position and check against the non-extruded rewind volume
-                    gatheredEntries.push_back(visEntry);
+                    AZ::Entity* entity = static_cast<AZ::Entity*>(visEntry->m_userData);
+                    const AZ::Aabb currentBounds = entityBoundsUnion->GetEntityLocalBoundsUnion(entity->GetId());
+                    const AZ::Vector3 currentCenter = currentBounds.GetCenter();
+
+                    NetworkTransformComponent* networkTransform = entity->template FindComponent<NetworkTransformComponent>();
+
+                    if (networkTransform != nullptr)
+                    {
+                        const AZ::Vector3 rewindCenter = networkTransform->GetTranslation(); // Get the rewound position
+                        const AZ::Vector3 rewindOffset = rewindCenter - currentCenter; // Compute offset between rewound and current positions
+                        const AZ::Aabb rewoundAabb = currentBounds.GetTranslated(rewindOffset); // Apply offset to the entity aabb
+
+                        if (AZ::ShapeIntersection::Overlaps(rewoundAabb, rewindVolume)) // Validate the rewound aabb intersects our rewind volume
+                        {
+                            // Due to component constraints, netBindComponent must exist if networkTransform exists
+                            NetBindComponent* netBindComponent = entity->template FindComponent<NetBindComponent>();
+                            gatheredEntities.push_back(netBindComponent);
+                        }
+                    }
                 }
             }
         });
 
-        for (AzFramework::VisibilityEntry* visEntry : gatheredEntries)
+        NetworkEntityTracker* networkEntityTracker = GetNetworkEntityTracker();
+        for (NetBindComponent* netBindComponent : gatheredEntities)
         {
-            AZ::Entity* entity = static_cast<AZ::Entity*>(visEntry->m_userData);
-            [[maybe_unused]] NetBindComponent* entryNetBindComponent = entity->template FindComponent<NetBindComponent>();
-            if (entryNetBindComponent != nullptr)
-            {
-                // TODO: invoke the sync to rewind event on the netBindComponent and add the entity to the rewound entity set
-            }
+            netBindComponent->NotifySyncRewindState();
+            m_rewoundEntities.push_back(NetworkEntityHandle(netBindComponent, networkEntityTracker));
         }
     }
 
     void NetworkTime::ClearRewoundEntities()
     {
         AZ_Assert(!IsTimeRewound(), "Cannot clear rewound entity state while still within scoped rewind");
-        // TODO: iterate all rewound entities, signal them to sync rewind state, and clear the rewound entity set
+
+        for (NetworkEntityHandle entityHandle : m_rewoundEntities)
+        {
+            NetBindComponent* netBindComponent = entityHandle.GetNetBindComponent();
+            netBindComponent->NotifySyncRewindState();
+        }
+        m_rewoundEntities.clear();
     }
 }

Gems/Multiplayer/Code/Source/NetworkTime/NetworkTime.h

@@ -13,6 +13,7 @@
 #pragma once
 
 #include <Multiplayer/NetworkTime/INetworkTime.h>
+#include <Multiplayer/NetworkEntity/NetworkEntityHandle.h>
 #include <AzCore/Component/Component.h>
 #include <AzCore/Console/IConsole.h>
 
@@ -42,6 +43,8 @@ namespace Multiplayer
 
     private:
 
+        AZStd::vector<NetworkEntityHandle> m_rewoundEntities;
+
         HostFrameId m_hostFrameId = HostFrameId{ 0 };
         HostFrameId m_unalteredFrameId = HostFrameId{ 0 };
         AZ::TimeMs m_hostTimeMs = AZ::TimeMs{ 0 };