Merge pull request #4253 from aws-lumberyard-dev/MigrationFixup

Migration fixup

Code/Framework/AzCore/AzCore/Component/ComponentApplication.cpp

@@ -1367,9 +1367,6 @@ namespace AZ
 #endif
     }
 
-    //=========================================================================
-    // Tick
-    //=========================================================================
     void ComponentApplication::Tick(float deltaOverride /*= -1.f*/)
     {
         {
@@ -1397,9 +1394,6 @@ namespace AZ
         }
     }
 
-    //=========================================================================
-    // Tick
-    //=========================================================================
     void ComponentApplication::TickSystem()
     {
         AZ_PROFILE_SCOPE(System, "Component application tick");
@@ -1547,5 +1541,4 @@ namespace AZ
             AZ::SettingsRegistryScriptUtils::ReflectSettingsRegistryToBehaviorContext(*behaviorContext);
         }
     }
-
 } // namespace AZ

Code/Framework/AzCore/AzCore/Component/ComponentApplication.h

@@ -5,6 +5,7 @@
  * SPDX-License-Identifier: Apache-2.0 OR MIT
  *
  */
+
 #pragma once
 
 #include <AzCore/Component/ComponentApplicationBus.h>

Code/Framework/AzCore/AzCore/Math/Aabb.h

@@ -5,7 +5,6 @@
  * SPDX-License-Identifier: Apache-2.0 OR MIT
  *
  */
-
 #pragma once
 
 #include <AzCore/base.h>

Code/Framework/AzCore/AzCore/Time/ITime.h

@@ -13,14 +13,26 @@
 #include <AzCore/RTTI/RTTI.h>
 #include <AzCore/RTTI/TypeSafeIntegral.h>
 #include <AzCore/std/time.h>
+#include <AzCore/std/chrono/chrono.h>
 
 namespace AZ
 {
     //! This is a strong typedef for representing a millisecond value since application start.
     AZ_TYPE_SAFE_INTEGRAL(TimeMs, int64_t);
 
+    //! This is a strong typedef for representing a microsecond value since application start.
+    //! Using int64_t as the underlying type, this is good to represent approximately 292,471 years
+    AZ_TYPE_SAFE_INTEGRAL(TimeUs, int64_t);
+
     //! @class ITime
     //! @brief This is an AZ::Interface<> for managing time related operations.
+    //! AZ::ITime and associated types may not operate in realtime. These abstractions are to allow our application
+    //! simulation to operate both slower and faster than realtime in a well defined and user controllable manner
+    //! The rate at which time passes for AZ::ITime is controlled by the cvar t_scale
+    //!     t_scale == 0 means simulation time should halt
+    //! 0 < t_scale <  1 will cause time to pass slower than realtime, with t_scale 0.1 being roughly 1/10th realtime
+    //!     t_scale == 1 will cause time to pass at roughly realtime
+    //!     t_scale >  1 will cause time to pass faster than normal, with t_scale 10 being roughly 10x realtime
     class ITime
     {
     public:
@@ -33,6 +45,10 @@ namespace AZ
         //! @return the number of milliseconds that have elapsed since application start
         virtual TimeMs GetElapsedTimeMs() const = 0;
 
+        //! Returns the number of microseconds since application start.
+        //! @return the number of microseconds that have elapsed since application start
+        virtual TimeUs GetElapsedTimeUs() const = 0;
+
         AZ_DISABLE_COPY_MOVE(ITime);
     };
 
@@ -51,6 +67,53 @@ namespace AZ
     {
         return AZ::Interface<ITime>::Get()->GetElapsedTimeMs();
     }
-}
+
+    //! This is a simple convenience wrapper
+    inline TimeUs GetElapsedTimeUs()
+    {
+        return AZ::Interface<ITime>::Get()->GetElapsedTimeUs();
+    }
+
+    //! Converts from milliseconds to microseconds
+    inline TimeUs TimeMsToUs(TimeMs value)
+    {
+        return static_cast<TimeUs>(value * static_cast<TimeMs>(1000));
+    }
+
+    //! Converts from microseconds to milliseconds
+    inline TimeMs TimeUsToMs(TimeUs value)
+    {
+        return static_cast<TimeMs>(value / static_cast<TimeUs>(1000));
+    }
+
+    //! Converts from milliseconds to seconds
+    inline float TimeMsToSeconds(TimeMs value)
+    {
+        return static_cast<float>(value) / 1000.0f;
+    }
+
+    //! Converts from microseconds to seconds
+    inline float TimeUsToSeconds(TimeUs value)
+    {
+        return static_cast<float>(value) / 1000000.0f;
+    }
+
+    //! Converts from milliseconds to AZStd::chrono::time_point
+    inline auto TimeMsToChrono(TimeMs value)
+    {
+        auto epoch = AZStd::chrono::time_point<AZStd::chrono::high_resolution_clock>();
+        auto chronoValue = AZStd::chrono::milliseconds(aznumeric_cast<int64_t>(value));
+        return epoch + chronoValue;
+    }
+
+    //! Converts from microseconds to AZStd::chrono::time_point
+    inline auto TimeUsToChrono(TimeUs value)
+    {
+        auto epoch = AZStd::chrono::time_point<AZStd::chrono::high_resolution_clock>();
+        auto chronoValue = AZStd::chrono::microseconds(aznumeric_cast<int64_t>(value));
+        return epoch + chronoValue;
+    }
+} // namespace AZ
 
 AZ_TYPE_SAFE_INTEGRAL_SERIALIZEBINDING(AZ::TimeMs);
+AZ_TYPE_SAFE_INTEGRAL_SERIALIZEBINDING(AZ::TimeUs);

Code/Framework/AzCore/AzCore/Time/TimeSystemComponent.cpp

@@ -35,7 +35,7 @@ namespace AZ
 
     TimeSystemComponent::TimeSystemComponent()
     {
-        m_lastInvokedTimeMs = static_cast<TimeMs>(AZStd::GetTimeNowMicroSecond() / 1000);
+        m_lastInvokedTimeUs = static_cast<TimeUs>(AZStd::GetTimeNowMicroSecond());
         AZ::Interface<ITime>::Register(this);
         ITimeRequestBus::Handler::BusConnect();
     }
@@ -58,18 +58,23 @@ namespace AZ
 
     TimeMs TimeSystemComponent::GetElapsedTimeMs() const
     {
-        TimeMs currentTime = static_cast<TimeMs>(AZStd::GetTimeNowMicroSecond() / 1000);
-        TimeMs deltaTime = currentTime - m_lastInvokedTimeMs;
+        return TimeUsToMs(GetElapsedTimeUs());
+    }
+
+    TimeUs TimeSystemComponent::GetElapsedTimeUs() const
+    {
+        TimeUs currentTime = static_cast<TimeUs>(AZStd::GetTimeNowMicroSecond());
+        TimeUs deltaTime = currentTime - m_lastInvokedTimeUs;
 
         if (t_scale != 1.0f)
         {
             float floatDelta = static_cast<float>(deltaTime) * t_scale;
-            deltaTime = static_cast<TimeMs>(static_cast<int64_t>(floatDelta));
+            deltaTime = static_cast<TimeUs>(static_cast<int64_t>(floatDelta));
         }
 
-        m_accumulatedTimeMs += deltaTime;
-        m_lastInvokedTimeMs = currentTime;
+        m_accumulatedTimeUs += deltaTime;
+        m_lastInvokedTimeUs = currentTime;
 
-        return m_accumulatedTimeMs;
+        return m_accumulatedTimeUs;
     }
 }

Code/Framework/AzCore/AzCore/Time/TimeSystemComponent.h

@@ -39,11 +39,12 @@ namespace AZ
         //! ITime overrides.
         //! @{
         TimeMs GetElapsedTimeMs() const override;
+        TimeUs GetElapsedTimeUs() const override;
         //! @}
 
     private:
 
-        mutable TimeMs m_lastInvokedTimeMs = TimeMs{0};
-        mutable TimeMs m_accumulatedTimeMs = TimeMs{0};
+        mutable TimeUs m_lastInvokedTimeUs = TimeUs{0};
+        mutable TimeUs m_accumulatedTimeUs = TimeUs{0};
     };
 }

Code/Framework/AzCore/Tests/Time/TimeTests.cpp

@@ -0,0 +1,56 @@
+/*
+ * 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
+ *
+ */
+
+#include <AzCore/Time/TimeSystemComponent.h>
+#include <AzCore/UnitTest/TestTypes.h>
+
+namespace UnitTest
+{
+    class TimeTests
+        : public AllocatorsFixture
+    {
+    public:
+        void SetUp() override
+        {
+            SetupAllocator();
+            m_timeComponent = new AZ::TimeSystemComponent;
+        }
+
+        void TearDown() override
+        {
+            delete m_timeComponent;
+            TeardownAllocator();
+        }
+
+        AZ::TimeSystemComponent* m_timeComponent = nullptr;
+    };
+
+    TEST_F(TimeTests, TestConversionUsToMs)
+    {
+        AZ::TimeUs timeUs = AZ::TimeUs{ 1000 };
+        AZ::TimeMs timeMs = AZ::TimeUsToMs(timeUs);
+        EXPECT_EQ(timeMs, AZ::TimeMs{ 1 });
+    }
+
+    TEST_F(TimeTests, TestConversionMsToUs)
+    {
+        AZ::TimeMs timeMs = AZ::TimeMs{ 1000 };
+        AZ::TimeUs timeUs = AZ::TimeMsToUs(timeMs);
+        EXPECT_EQ(timeUs, AZ::TimeUs{ 1000000 });
+    }
+
+    TEST_F(TimeTests, TestClocks)
+    {
+        AZ::TimeUs timeUs = AZ::GetElapsedTimeUs();
+        AZ::TimeMs timeMs = AZ::GetElapsedTimeMs();
+
+        AZ::TimeMs timeUsToMs = AZ::TimeUsToMs(timeUs);
+        int64_t delta = static_cast<int64_t>(timeMs) - static_cast<int64_t>(timeUsToMs);
+        EXPECT_LT(abs(delta), 1);
+    }
+}

Code/Framework/AzCore/Tests/azcoretests_files.cmake

@@ -127,6 +127,7 @@ set(FILES
     Serialization/Json/UnorderedSetSerializerTests.cpp
     Serialization/Json/UnsupportedTypesSerializerTests.cpp
     Serialization/Json/UuidSerializerTests.cpp
+    Time/TimeTests.cpp
     Math/AabbTests.cpp
     Math/ColorTests.cpp
     Math/CrcTests.cpp

Code/Framework/AzFramework/AzFramework/Visibility/EntityBoundsUnionBus.h

@@ -28,9 +28,12 @@ namespace AzFramework
         //! @note This is used to drive event driven updates to the visibility system.
         virtual void RefreshEntityLocalBoundsUnion(AZ::EntityId entityId) = 0;
 
-        //! Returns the cached union of all component Aabbs.
+        //! Returns the cached union of all component Aabbs in local entity space.
         virtual AZ::Aabb GetEntityLocalBoundsUnion(AZ::EntityId entityId) const = 0;
 
+        //! Returns the cached union of all component Aabbs in world space.
+        virtual AZ::Aabb GetEntityWorldBoundsUnion(AZ::EntityId entityId) const = 0;
+
         //! Writes the current changes made to all entities (transforms and bounds) to the visibility system.
         //! @note During normal operation this is called every frame in OnTick but can
         //! also be called explicitly (e.g. For testing purposes).

Code/Framework/AzFramework/AzFramework/Visibility/EntityVisibilityBoundsUnionSystem.cpp

@@ -128,6 +128,24 @@ namespace AzFramework
         return AZ::Aabb::CreateNull();
     }
 
+    AZ::Aabb EntityVisibilityBoundsUnionSystem::GetEntityWorldBoundsUnion(const AZ::EntityId entityId) const
+    {
+        AZ::Entity* entity = AZ::Interface<AZ::ComponentApplicationRequests>::Get()->FindEntity(entityId);
+        if (entity != nullptr)
+        {
+            // if the entity is not found in the mapping then return a null Aabb, this is to mimic 
+            // as closely as possible the behavior of an individual GetLocalBounds call to an Entity that
+            // had been deleted (there would be no response, leaving the default value assigned)
+            if (auto instance_it = m_entityVisibilityBoundsUnionInstanceMapping.find(entity);
+                instance_it != m_entityVisibilityBoundsUnionInstanceMapping.end())
+            {
+                return instance_it->second.m_localEntityBoundsUnion.GetTranslated(entity->GetTransform()->GetWorldTranslation());
+            }
+        }
+
+        return AZ::Aabb::CreateNull();
+    }
+
     void EntityVisibilityBoundsUnionSystem::ProcessEntityBoundsUnionRequests()
     {
         AZ_PROFILE_FUNCTION(AzFramework);

Code/Framework/AzFramework/AzFramework/Visibility/EntityVisibilityBoundsUnionSystem.h

@@ -31,6 +31,7 @@ namespace AzFramework
         // EntityBoundsUnionRequestBus overrides ...
         void RefreshEntityLocalBoundsUnion(AZ::EntityId entityId) override;
         AZ::Aabb GetEntityLocalBoundsUnion(AZ::EntityId entityId) const override;
+        AZ::Aabb GetEntityWorldBoundsUnion(AZ::EntityId entityId) const override;
         void ProcessEntityBoundsUnionRequests() override;
         void OnTransformUpdated(AZ::Entity* entity) override;
 

Code/Framework/AzNetworking/AzNetworking/DataStructures/TimeoutQueue.h

@@ -94,6 +94,7 @@ namespace AzNetworking
     class ITimeoutHandler
     {
     public:
+        virtual ~ITimeoutHandler() = default;
 
         //! Handler callback for timed out items.
         //! @param item containing registered timeout details

Code/Framework/AzNetworking/AzNetworking/Framework/INetworkInterface.h

@@ -103,13 +103,13 @@ namespace AzNetworking
         //! @return boolean true on success
         virtual bool Disconnect(ConnectionId connectionId, DisconnectReason reason) = 0;
 
-        //! Sets whether this connection interface can disconnect by virtue of a timeout
-        //! @param timeoutEnabled If this connection interface will automatically disconnect due to a timeout
-        virtual void SetTimeoutEnabled(bool timeoutEnabled) = 0;
+        //! Sets the timeout time in milliseconds, 0 ms means timeouts are disabled.
+        //! @param timeoutMs the number of milliseconds with no traffic before we timeout and close a connection
+        virtual void SetTimeoutMs(AZ::TimeMs timeoutMs) = 0;
 
-        //! Whether this connection interface will disconnect by virtue of a time out (does not account for cvars affecting all connections)
-        //! @return boolean true if this connection will not disconnect on timeout (does not account for cvars affecting all connections)
-        virtual bool IsTimeoutEnabled() const = 0;
+        //! Retrieves the timeout time in milliseconds for this network interface, 0 ms means timeouts are disabled.
+        //! @return the timeout time in milliseconds for this network interface, 0 ms means timeouts are disabled
+        virtual AZ::TimeMs GetTimeoutMs() const = 0;
 
         //! Const access to the metrics tracked by this network interface.
         //! @return const reference to the metrics tracked by this network interface

Code/Framework/AzNetworking/AzNetworking/Serialization/AzContainerSerializers.h

@@ -321,4 +321,19 @@ namespace AzNetworking
             return serializer.IsValid();
         }
     };
+
+    template <>
+    struct SerializeObjectHelper<AZ::Aabb>
+    {
+        static bool SerializeObject(ISerializer& serializer, AZ::Aabb& value)
+        {
+            AZ::Vector3 minValue = value.GetMin();
+            AZ::Vector3 maxValue = value.GetMax();
+            serializer.Serialize(minValue, "minValue");
+            serializer.Serialize(maxValue, "maxValue");
+            value.SetMin(minValue);
+            value.SetMax(maxValue);
+            return serializer.IsValid();
+        }
+    };
 }

Code/Framework/AzNetworking/AzNetworking/TcpTransport/TcpNetworkInterface.cpp

@@ -22,14 +22,15 @@ namespace AzNetworking
 #endif
 
     AZ_CVAR(bool, net_TcpTimeoutConnections, true, nullptr, AZ::ConsoleFunctorFlags::DontReplicate, "Boolean value on whether we should timeout Tcp connections");
-    AZ_CVAR(AZ::TimeMs, net_TcpHearthbeatTimeMs, AZ::TimeMs{  2 * 1000 }, nullptr, AZ::ConsoleFunctorFlags::Null, "Tcp connection heartbeat frequency");
-    AZ_CVAR(AZ::TimeMs, net_TcpTimeoutTimeMs,    AZ::TimeMs{ 10 * 1000 }, nullptr, AZ::ConsoleFunctorFlags::Null, "Time in milliseconds before we timeout an idle Tcp connection");
+    AZ_CVAR(AZ::TimeMs, net_TcpHeartbeatTimeMs, AZ::TimeMs{  2 * 1000 }, nullptr, AZ::ConsoleFunctorFlags::Null, "Tcp connection heartbeat frequency");
+    AZ_CVAR(AZ::TimeMs, net_TcpDefaultTimeoutMs, AZ::TimeMs{ 10 * 1000 }, nullptr, AZ::ConsoleFunctorFlags::Null, "Time in milliseconds before we timeout an idle Tcp connection");
 
     TcpNetworkInterface::TcpNetworkInterface(AZ::Name name, IConnectionListener& connectionListener, TrustZone trustZone, TcpListenThread& listenThread)
         : m_name(name)
         , m_trustZone(trustZone)
         , m_connectionListener(connectionListener)
         , m_listenThread(listenThread)
+        , m_timeoutMs(net_TcpDefaultTimeoutMs)
     {
         ;
     }
@@ -97,7 +98,7 @@ namespace AzNetworking
         }
 
         AZLOG_INFO("Adding new socket %d", static_cast<int32_t>(tcpSocket->GetSocketFd()));
-        const TimeoutId newTimeoutId = m_connectionTimeoutQueue.RegisterItem(static_cast<uint64_t>(tcpSocket->GetSocketFd()), net_TcpHearthbeatTimeMs);
+        const TimeoutId newTimeoutId = m_connectionTimeoutQueue.RegisterItem(static_cast<uint64_t>(tcpSocket->GetSocketFd()), net_TcpHeartbeatTimeMs);
         connection->SetTimeoutId(newTimeoutId);
         connection->SendReliablePacket(CorePackets::InitiateConnectionPacket());
         m_connectionListener.OnConnect(connection.get());
@@ -174,14 +175,14 @@ namespace AzNetworking
         return connection->Disconnect(reason, TerminationEndpoint::Local);
     }
 
-    void TcpNetworkInterface::SetTimeoutEnabled(bool timeoutEnabled)
+    void TcpNetworkInterface::SetTimeoutMs(AZ::TimeMs timeoutMs)
     {
-        m_timeoutEnabled = timeoutEnabled;
+        m_timeoutMs = timeoutMs;
     }
 
-    bool TcpNetworkInterface::IsTimeoutEnabled() const
+    AZ::TimeMs TcpNetworkInterface::GetTimeoutMs() const
     {
-        return m_timeoutEnabled;
+        return m_timeoutMs;
     }
 
     void TcpNetworkInterface::QueueNewConnection(const PendingConnection& pendingConnection)
@@ -257,7 +258,7 @@ namespace AzNetworking
             return;
         }
         AZLOG(NET_TcpTraffic, "Adding new socket %d", static_cast<int32_t>(tcpSocket.GetSocketFd()));
-        const TimeoutId timeoutId = m_connectionTimeoutQueue.RegisterItem(static_cast<uint64_t>(tcpSocket.GetSocketFd()), net_TcpTimeoutTimeMs);
+        const TimeoutId timeoutId = m_connectionTimeoutQueue.RegisterItem(static_cast<uint64_t>(tcpSocket.GetSocketFd()), m_timeoutMs);
         AZStd::unique_ptr<TcpConnection> connection = AZStd::make_unique<TcpConnection>(connectionId, remoteAddress, *this, tcpSocket, timeoutId);
         AZ_Assert(connection->GetConnectionRole() == ConnectionRole::Acceptor, "Invalid role for connection");
         GetConnectionListener().OnConnect(connection.get());
@@ -316,7 +317,7 @@ namespace AzNetworking
         {
             tcpConnection->SendReliablePacket(CorePackets::HeartbeatPacket());
         }
-        else if (net_TcpTimeoutConnections && m_networkInterface.IsTimeoutEnabled())
+        else if (net_TcpTimeoutConnections && (m_networkInterface.GetTimeoutMs() > AZ::TimeMs{ 0 }))
         {
             tcpConnection->Disconnect(DisconnectReason::Timeout, TerminationEndpoint::Local);
             return TimeoutResult::Delete;

Code/Framework/AzNetworking/AzNetworking/TcpTransport/TcpNetworkInterface.h

@@ -99,8 +99,8 @@ namespace AzNetworking
         bool WasPacketAcked(ConnectionId connectionId, PacketId packetId) override;
         bool StopListening() override;
         bool Disconnect(ConnectionId connectionId, DisconnectReason reason) override;
-        void SetTimeoutEnabled(bool timeoutEnabled) override;
-        bool IsTimeoutEnabled() const override;
+        void SetTimeoutMs(AZ::TimeMs timeoutMs) override;
+        AZ::TimeMs GetTimeoutMs() const override;
         //! @}
 
         //! Queues a new incoming connection for this network interface.
@@ -156,7 +156,7 @@ namespace AzNetworking
         AZ::Name m_name;
         TrustZone m_trustZone;
         uint16_t m_port = 0;
-        bool m_timeoutEnabled = true;
+        AZ::TimeMs m_timeoutMs = AZ::TimeMs{ 0 };
         IConnectionListener& m_connectionListener;
         TcpConnectionSet m_connectionSet;
         TcpSocketManager m_tcpSocketManager;

Code/Framework/AzNetworking/AzNetworking/TcpTransport/TcpSocket.cpp

@@ -53,18 +53,11 @@ namespace AzNetworking
     {
         Close();
 
-        if (!SocketCreateInternal())
-        {
-            return false;
-        }
-
-        if (!BindSocketForListenInternal(port))
-        {
-            return false;
-        }
-
-        if (!(SetSocketNonBlocking(m_socketFd) && SetSocketNoDelay(m_socketFd)))
+        if (!SocketCreateInternal()
+         || !BindSocketForListenInternal(port)
+         || !(SetSocketNonBlocking(m_socketFd) && SetSocketNoDelay(m_socketFd)))
         {
+            Close();
             return false;
         }
 
@@ -75,18 +68,11 @@ namespace AzNetworking
     {
         Close();
 
-        if (!SocketCreateInternal())
-        {
-            return false;
-        }
-
-        if (!BindSocketForConnectInternal(address))
-        {
-            return false;
-        }
-
-        if (!(SetSocketNonBlocking(m_socketFd) && SetSocketNoDelay(m_socketFd)))
+        if (!SocketCreateInternal()
+         || !BindSocketForConnectInternal(address)
+         || !(SetSocketNonBlocking(m_socketFd) && SetSocketNoDelay(m_socketFd)))
         {
+            Close();
             return false;
         }
 

Code/Framework/AzNetworking/AzNetworking/UdpTransport/UdpNetworkInterface.cpp

@@ -31,8 +31,8 @@ namespace AzNetworking
 
     AZ_CVAR(bool, net_UdpTimeoutConnections, true, nullptr, AZ::ConsoleFunctorFlags::DontReplicate, "Boolean value on whether we should timeout Udp connections");
     AZ_CVAR(AZ::TimeMs, net_UdpPacketTimeSliceMs, AZ::TimeMs{ 8 }, nullptr, AZ::ConsoleFunctorFlags::DontReplicate, "The number of milliseconds to allow for packet processing");
-    AZ_CVAR(AZ::TimeMs, net_UdpHearthbeatTimeMs, AZ::TimeMs{ 2 * 1000 }, nullptr, AZ::ConsoleFunctorFlags::Null, "Udp connection heartbeat frequency");
-    AZ_CVAR(AZ::TimeMs, net_UdpTimeoutTimeMs, AZ::TimeMs{ 10 * 1000 }, nullptr, AZ::ConsoleFunctorFlags::Null, "Time in milliseconds before we timeout an idle Udp connection");
+    AZ_CVAR(AZ::TimeMs, net_UdpHeartbeatTimeMs, AZ::TimeMs{ 2 * 1000 }, nullptr, AZ::ConsoleFunctorFlags::Null, "Udp connection heartbeat frequency");
+    AZ_CVAR(AZ::TimeMs, net_UdpDefaultTimeoutMs, AZ::TimeMs{ 10 * 1000 }, nullptr, AZ::ConsoleFunctorFlags::Null, "Time in milliseconds before we timeout an idle Udp connection");
     AZ_CVAR(AZ::TimeMs, net_MinPacketTimeoutMs, AZ::TimeMs{ 200 }, nullptr, AZ::ConsoleFunctorFlags::DontReplicate, "Minimum time to wait before timing out an unacked packet");
     AZ_CVAR(int32_t, net_MaxTimeoutsPerFrame, 1000, nullptr, AZ::ConsoleFunctorFlags::DontReplicate, "Maximum number of packet timeouts to allow to process in a single frame");
     AZ_CVAR(float, net_RttFudgeScalar, 2.0f, nullptr, AZ::ConsoleFunctorFlags::DontReplicate, "Scalar value to multiply computed Rtt by to determine an optimal packet timeout threshold");
@@ -61,6 +61,7 @@ namespace AzNetworking
         , m_connectionListener(connectionListener)
         , m_socket(net_UdpUseEncryption ? new DtlsSocket() : new UdpSocket())
         , m_readerThread(readerThread)
+        , m_timeoutMs(net_UdpDefaultTimeoutMs)
     {
         const AZ::CVarFixedString compressor = static_cast<AZ::CVarFixedString>(net_UdpCompressor);
         const AZ::Name compressorName = AZ::Name(compressor);
@@ -138,7 +139,7 @@ namespace AzNetworking
         }
 
         const ConnectionId connectionId = m_connectionSet.GetNextConnectionId();
-        const TimeoutId timeoutId = m_connectionTimeoutQueue.RegisterItem(aznumeric_cast<uint64_t>(connectionId), net_UdpHearthbeatTimeMs);
+        const TimeoutId timeoutId = m_connectionTimeoutQueue.RegisterItem(aznumeric_cast<uint64_t>(connectionId), m_timeoutMs);
 
         AZStd::unique_ptr<UdpConnection> connection = AZStd::make_unique<UdpConnection>(connectionId, remoteAddress, *this, ConnectionRole::Connector);
         UdpPacketEncodingBuffer dtlsData;
@@ -403,14 +404,14 @@ namespace AzNetworking
         return connection->Disconnect(reason, TerminationEndpoint::Local);
     }
 
-    void UdpNetworkInterface::SetTimeoutEnabled(bool timeoutEnabled)
+    void UdpNetworkInterface::SetTimeoutMs(AZ::TimeMs timeoutMs)
     {
-        m_timeoutEnabled = timeoutEnabled;
+        m_timeoutMs = timeoutMs;
     }
 
-    bool UdpNetworkInterface::IsTimeoutEnabled() const
+    AZ::TimeMs UdpNetworkInterface::GetTimeoutMs() const
     {
-        return m_timeoutEnabled;
+        return m_timeoutMs;
     }
 
     bool UdpNetworkInterface::IsEncrypted() const
@@ -681,7 +682,7 @@ namespace AzNetworking
 
         // How long should we sit in the timeout queue before heartbeating or disconnecting
         const ConnectionId connectionId = m_connectionSet.GetNextConnectionId();
-        const TimeoutId    timeoutId = m_connectionTimeoutQueue.RegisterItem(aznumeric_cast<uint64_t>(connectionId), net_UdpTimeoutTimeMs);
+        const TimeoutId    timeoutId = m_connectionTimeoutQueue.RegisterItem(aznumeric_cast<uint64_t>(connectionId), m_timeoutMs);
 
         AZLOG(Debug_UdpConnect, "Accepted new Udp Connection");
         AZStd::unique_ptr<UdpConnection> connection = AZStd::make_unique<UdpConnection>(connectionId, connectPacket.m_address, *this, ConnectionRole::Acceptor);
@@ -745,7 +746,7 @@ namespace AzNetworking
         {
             udpConnection->SendUnreliablePacket(CorePackets::HeartbeatPacket());
         }
-        else if (net_UdpTimeoutConnections && m_networkInterface.IsTimeoutEnabled())
+        else if (net_UdpTimeoutConnections && (m_networkInterface.GetTimeoutMs() > AZ::TimeMs{ 0 }))
         {
             udpConnection->Disconnect(DisconnectReason::Timeout, TerminationEndpoint::Local);
             return TimeoutResult::Delete;

Code/Framework/AzNetworking/AzNetworking/UdpTransport/UdpNetworkInterface.h

@@ -104,8 +104,8 @@ namespace AzNetworking
         bool WasPacketAcked(ConnectionId connectionId, PacketId packetId) override;
         bool StopListening() override;
         bool Disconnect(ConnectionId connectionId, DisconnectReason reason) override;
-        void SetTimeoutEnabled(bool timeoutEnabled) override;
-        bool IsTimeoutEnabled() const override;
+        void SetTimeoutMs(AZ::TimeMs timeoutMs) override;
+        AZ::TimeMs GetTimeoutMs() const override;
         //! @}
 
         //! Returns true if this is an encrypted socket, false if not.
@@ -181,7 +181,7 @@ namespace AzNetworking
         TrustZone m_trustZone;
         uint16_t m_port = 0;
         bool m_allowIncomingConnections = false;
-        bool m_timeoutEnabled = true;
+        AZ::TimeMs m_timeoutMs = AZ::TimeMs{ 0 };
         IConnectionListener& m_connectionListener;
         UdpConnectionSet m_connectionSet;
         TimeoutQueue m_connectionTimeoutQueue;

Code/Framework/AzNetworking/AzNetworking/UdpTransport/UdpSocket.cpp

@@ -79,17 +79,15 @@ namespace AzNetworking
             {
                 const int32_t error = GetLastNetworkError();
                 AZLOG_ERROR("Failed to bind UDP socket to port %u (%d:%s)", uint32_t(port), error, GetNetworkErrorDesc(error));
+                Close();
                 return false;
             }
         }
 
-        if (!SetSocketBufferSizes(m_socketFd, net_UdpSendBufferSize, net_UdpRecvBufferSize))
-        {
-            return false;
-        }
-
-        if (!SetSocketNonBlocking(m_socketFd))
+        if (!SetSocketBufferSizes(m_socketFd, net_UdpSendBufferSize, net_UdpRecvBufferSize)
+         || !SetSocketNonBlocking(m_socketFd))
         {
+            Close();
             return false;
         }
 

Code/Framework/AzNetworking/Tests/TcpTransport/TcpTransportTests.cpp

@@ -149,8 +149,9 @@ namespace UnitTest
         EXPECT_EQ(testServer.m_serverNetworkInterface->GetConnectionSet().GetConnectionCount(), 1);
         EXPECT_EQ(testClient.m_clientNetworkInterface->GetConnectionSet().GetConnectionCount(), 1);
 
-        testClient.m_clientNetworkInterface->SetTimeoutEnabled(true);
-        EXPECT_TRUE(testClient.m_clientNetworkInterface->IsTimeoutEnabled());
+        const AZ::TimeMs timeoutMs = AZ::TimeMs{ 100 };
+        testClient.m_clientNetworkInterface->SetTimeoutMs(timeoutMs);
+        EXPECT_EQ(testClient.m_clientNetworkInterface->GetTimeoutMs(), timeoutMs);
 
         EXPECT_TRUE(testServer.m_serverNetworkInterface->StopListening());
     }

Code/Framework/AzNetworking/Tests/UdpTransport/UdpTransportTests.cpp

@@ -279,8 +279,9 @@ namespace UnitTest
         EXPECT_EQ(testServer.m_serverNetworkInterface->GetConnectionSet().GetConnectionCount(), 1);
         EXPECT_EQ(testClient.m_clientNetworkInterface->GetConnectionSet().GetConnectionCount(), 1);
 
-        testClient.m_clientNetworkInterface->SetTimeoutEnabled(true);
-        EXPECT_TRUE(testClient.m_clientNetworkInterface->IsTimeoutEnabled());
+        const AZ::TimeMs timeoutMs = AZ::TimeMs{ 100 };
+        testClient.m_clientNetworkInterface->SetTimeoutMs(timeoutMs);
+        EXPECT_EQ(testClient.m_clientNetworkInterface->GetTimeoutMs(), timeoutMs);
 
         EXPECT_FALSE(dynamic_cast<UdpNetworkInterface*>(testClient.m_clientNetworkInterface)->IsEncrypted());