Refactor engine systems to use platform time seconds rather than date time

Source/Engine/Content/Storage/AssetHeader.h

@@ -6,6 +6,7 @@
 #include "Engine/Core/Types/Pair.h"
 #include "Engine/Core/Types/String.h"
 #if USE_EDITOR
+#include "Engine/Core/Types/DateTime.h"
 #include "Engine/Core/Collections/Array.h"
 #endif
 #include "FlaxChunk.h"

Source/Engine/Content/Storage/FlaxChunk.h

@@ -78,9 +78,9 @@ public:
     FlaxChunkFlags Flags = FlaxChunkFlags::None;
 
     /// <summary>
-    /// The last usage time (atomic, ticks of DateTime in UTC).
+    /// The last usage time.
     /// </summary>
-    int64 LastAccessTime = 0;
+    double LastAccessTime = 0.0;
 
     /// <summary>
     /// The chunk data.

Source/Engine/Content/Storage/FlaxStorage.cpp

@@ -27,7 +27,7 @@ String AssetHeader::ToString() const
 
 void FlaxChunk::RegisterUsage()
 {
-    Platform::AtomicStore(&LastAccessTime, DateTime::NowUTC().Ticks);
+    LastAccessTime = Platform::GetTimeSeconds();
 }
 
 const int32 FlaxStorage::MagicCode = 1180124739;
@@ -229,7 +229,9 @@ uint32 FlaxStorage::GetRefCount() const
 
 bool FlaxStorage::ShouldDispose() const
 {
-    return Platform::AtomicRead((int64*)&_refCount) == 0 && Platform::AtomicRead((int64*)&_chunksLock) == 0 && DateTime::NowUTC() - _lastRefLostTime >= TimeSpan::FromMilliseconds(500);
+    return Platform::AtomicRead((int64*)&_refCount) == 0 &&
+            Platform::AtomicRead((int64*)&_chunksLock) == 0 &&
+            Platform::GetTimeSeconds() - _lastRefLostTime >= 0.5; // TTL in seconds
 }
 
 uint32 FlaxStorage::GetMemoryUsage() const
@@ -1363,12 +1365,13 @@ void FlaxStorage::Tick()
     if (Platform::AtomicRead(&_chunksLock) != 0)
         return;
 
-    const auto now = DateTime::NowUTC();
+    const double now = Platform::GetTimeSeconds();
     bool wasAnyUsed = false;
+    const float unusedDataChunksLifetime = ContentStorageManager::UnusedDataChunksLifetime.GetTotalSeconds();
     for (int32 i = 0; i < _chunks.Count(); i++)
     {
-        auto chunk = _chunks[i];
-        const bool wasUsed = (now - DateTime(Platform::AtomicRead(&chunk->LastAccessTime))) < ContentStorageManager::UnusedDataChunksLifetime;
+        auto chunk = _chunks.Get()[i];
+        const bool wasUsed = (now - chunk->LastAccessTime) < unusedDataChunksLifetime;
         if (!wasUsed && chunk->IsLoaded())
         {
             chunk->Unload();

Source/Engine/Content/Storage/FlaxStorage.h

@@ -5,7 +5,6 @@
 #include "Engine/Core/Object.h"
 #include "Engine/Core/Delegate.h"
 #include "Engine/Core/Types/String.h"
-#include "Engine/Core/Types/DateTime.h"
 #include "Engine/Core/Collections/Array.h"
 #include "Engine/Platform/CriticalSection.h"
 #include "Engine/Serialization/FileReadStream.h"
@@ -90,7 +89,7 @@ protected:
     // State
     int64 _refCount;
     int64 _chunksLock;
-    DateTime _lastRefLostTime;
+    double _lastRefLostTime;
     CriticalSection _loadLocker;
 
     // Storage
@@ -115,7 +114,7 @@ private:
         Platform::InterlockedDecrement(&_refCount);
         if (Platform::AtomicRead(&_refCount) == 0)
         {
-            _lastRefLostTime = DateTime::NowUTC();
+            _lastRefLostTime = Platform::GetTimeSeconds();
         }
     }
 

Source/Engine/Core/ObjectsRemovalService.cpp

@@ -17,7 +17,7 @@ Span<const Char*> Utilities::Private::HertzSizes(HertzSizesData, ARRAY_COUNT(Her
 namespace
 {
     CriticalSection PoolLocker;
-    DateTime LastUpdate;
+    double LastUpdate;
     float LastUpdateGameTime;
     Dictionary<Object*, float> Pool(8192);
     uint64 PoolCounter = 0;
@@ -114,7 +114,7 @@ void ObjectsRemovalService::Flush(float dt, float gameDelta)
 
 bool ObjectsRemoval::Init()
 {
-    LastUpdate = DateTime::NowUTC();
+    LastUpdate = Platform::GetTimeSeconds();
     LastUpdateGameTime = 0;
     return false;
 }
@@ -124,8 +124,8 @@ void ObjectsRemoval::LateUpdate()
     PROFILE_CPU();
 
     // Delete all objects
-    const auto now = DateTime::NowUTC();
-    const float dt = (now - LastUpdate).GetTotalSeconds();
+    const double now = Platform::GetTimeSeconds();
+    const float dt = (float)(now - LastUpdate);
     float gameDelta = Time::Update.DeltaTime.GetTotalSeconds();
     if (Time::GetGamePaused())
         gameDelta = 0;

Source/Engine/ShadowsOfMordor/Builder.h

@@ -4,6 +4,7 @@
 
 #include "Engine/Content/Assets/Model.h"
 #include "Engine/Content/Assets/Shader.h"
+#include "Engine/Core/Types/DateTime.h"
 #include "Engine/CSG/CSGMesh.h"
 #include "Builder.Config.h"
 

Source/Engine/Streaming/IStreamingHandler.h

@@ -13,19 +13,15 @@ class StreamableResource;
 class FLAXENGINE_API IStreamingHandler
 {
 public:
-
     virtual ~IStreamingHandler() = default;
 
-public:
-
     /// <summary>
     /// Calculates target quality level (0-1) for the given resource.
     /// </summary>
     /// <param name="resource">The resource.</param>
-    /// <param name="now">The current time and date.</param>
     /// <param name="currentTime">The current platform time (seconds).</param>
     /// <returns>Target quality (0-1).</returns>
-    virtual float CalculateTargetQuality(StreamableResource* resource, DateTime now, double currentTime) = 0;
+    virtual float CalculateTargetQuality(StreamableResource* resource, double currentTime) = 0;
 
     /// <summary>
     /// Calculates the residency level for a given resource and quality level.

Source/Engine/Streaming/StreamableResource.h

@@ -110,8 +110,8 @@ public:
 
     struct StreamingCache
     {
-        int64 LastUpdate = 0;
-        int64 TargetResidencyChange = 0;
+        double LastUpdateTime = 0.0;
+        double TargetResidencyChangeTime = 0;
         int32 TargetResidency = 0;
         bool Error = false;
         SamplesBuffer<float, 5> QualitySamples;

Source/Engine/Streaming/Streaming.cpp

@@ -81,14 +81,14 @@ StreamableResource::~StreamableResource()
 
 void StreamableResource::RequestStreamingUpdate()
 {
-    Streaming.LastUpdate = 0;
+    Streaming.LastUpdateTime = 0.0;
 }
 
 void StreamableResource::ResetStreaming(bool error)
 {
     Streaming.Error = error;
     Streaming.TargetResidency = 0;
-    Streaming.LastUpdate = DateTime::MaxValue().Ticks;
+    Streaming.LastUpdateTime = 3e+30f; // Very large number to skip any updates
 }
 
 void StreamableResource::StartStreaming(bool isDynamic)
@@ -115,7 +115,7 @@ void StreamableResource::StopStreaming()
     }
 }
 
-void UpdateResource(StreamableResource* resource, DateTime now, double currentTime)
+void UpdateResource(StreamableResource* resource, double currentTime)
 {
     ASSERT(resource && resource->CanBeUpdated());
 
@@ -127,7 +127,7 @@ void UpdateResource(StreamableResource* resource, DateTime now, double currentTi
     float targetQuality = 1.0f;
     if (resource->IsDynamic())
     {
-        targetQuality = handler->CalculateTargetQuality(resource, now, currentTime);
+        targetQuality = handler->CalculateTargetQuality(resource, currentTime);
         targetQuality = Math::Saturate(targetQuality);
     }
 
@@ -142,14 +142,14 @@ void UpdateResource(StreamableResource* resource, DateTime now, double currentTi
     auto allocatedResidency = resource->GetAllocatedResidency();
     auto targetResidency = handler->CalculateResidency(resource, targetQuality);
     ASSERT(allocatedResidency >= currentResidency && allocatedResidency >= 0);
-    resource->Streaming.LastUpdate = now.Ticks;
+    resource->Streaming.LastUpdateTime = currentTime;
 
     // Check if a target residency level has been changed
     if (targetResidency != resource->Streaming.TargetResidency)
     {
         // Register change
         resource->Streaming.TargetResidency = targetResidency;
-        resource->Streaming.TargetResidencyChange = now.Ticks;
+        resource->Streaming.TargetResidencyChangeTime = currentTime;
     }
 
     // Check if need to change resource current residency
@@ -224,15 +224,14 @@ void StreamingSystem::Job(int32 index)
     PROFILE_CPU_NAMED("Streaming.Job");
 
     // TODO: use streaming settings
-    TimeSpan ResourceUpdatesInterval = TimeSpan::FromMilliseconds(100);
+    const double ResourceUpdatesInterval = 0.1;
     int32 MaxResourcesPerUpdate = 50;
 
     // Start update
     ScopeLock lock(ResourcesLock);
-    auto now = DateTime::NowUTC();
     const int32 resourcesCount = Resources.Count();
     int32 resourcesUpdates = Math::Min(MaxResourcesPerUpdate, resourcesCount);
-    double currentTime = Platform::GetTimeSeconds();
+    const double currentTime = Platform::GetTimeSeconds();
 
     // Update high priority queue and then rest of the resources
     // Note: resources in the update queue are updated always, while others only between specified intervals
@@ -248,9 +247,9 @@ void StreamingSystem::Job(int32 index)
         const auto resource = Resources[LastUpdateResourcesIndex];
 
         // Try to update it
-        if (now - DateTime(resource->Streaming.LastUpdate) >= ResourceUpdatesInterval && resource->CanBeUpdated())
+        if (currentTime - resource->Streaming.LastUpdateTime >= ResourceUpdatesInterval && resource->CanBeUpdated())
         {
-            UpdateResource(resource, now, currentTime);
+            UpdateResource(resource, currentTime);
             resourcesUpdates--;
         }
     }

Source/Engine/Streaming/StreamingHandlers.cpp

@@ -11,7 +11,7 @@
 #include "Engine/Audio/Audio.h"
 #include "Engine/Audio/AudioSource.h"
 
-float TexturesStreamingHandler::CalculateTargetQuality(StreamableResource* resource, DateTime now, double currentTime)
+float TexturesStreamingHandler::CalculateTargetQuality(StreamableResource* resource, double currentTime)
 {
     ASSERT(resource);
     auto& texture = *(StreamingTexture*)resource;
@@ -93,7 +93,7 @@ int32 TexturesStreamingHandler::CalculateRequestedResidency(StreamableResource*
     return residency;
 }
 
-float ModelsStreamingHandler::CalculateTargetQuality(StreamableResource* resource, DateTime now, double currentTime)
+float ModelsStreamingHandler::CalculateTargetQuality(StreamableResource* resource, double currentTime)
 {
     // TODO: calculate a proper quality levels for models based on render time and streaming enable/disable options
     return 1.0f;
@@ -132,7 +132,7 @@ int32 ModelsStreamingHandler::CalculateRequestedResidency(StreamableResource* re
     return residency;
 }
 
-float SkinnedModelsStreamingHandler::CalculateTargetQuality(StreamableResource* resource, DateTime now, double currentTime)
+float SkinnedModelsStreamingHandler::CalculateTargetQuality(StreamableResource* resource, double currentTime)
 {
     // TODO: calculate a proper quality levels for models based on render time and streaming enable/disable options
     return 1.0f;
@@ -171,7 +171,7 @@ int32 SkinnedModelsStreamingHandler::CalculateRequestedResidency(StreamableResou
     return residency;
 }
 
-float AudioStreamingHandler::CalculateTargetQuality(StreamableResource* resource, DateTime now, double currentTime)
+float AudioStreamingHandler::CalculateTargetQuality(StreamableResource* resource, double currentTime)
 {
     // Audio clips don't use quality but only residency
     return 1.0f;

Source/Engine/Streaming/StreamingHandlers.h

@@ -11,7 +11,7 @@ class FLAXENGINE_API TexturesStreamingHandler : public IStreamingHandler
 {
 public:
     // [IStreamingHandler]
-    float CalculateTargetQuality(StreamableResource* resource, DateTime now, double currentTime) override;
+    float CalculateTargetQuality(StreamableResource* resource, double currentTime) override;
     int32 CalculateResidency(StreamableResource* resource, float quality) override;
     int32 CalculateRequestedResidency(StreamableResource* resource, int32 targetResidency) override;
 };
@@ -23,7 +23,7 @@ class FLAXENGINE_API ModelsStreamingHandler : public IStreamingHandler
 {
 public:
     // [IStreamingHandler]
-    float CalculateTargetQuality(StreamableResource* resource, DateTime now, double currentTime) override;
+    float CalculateTargetQuality(StreamableResource* resource, double currentTime) override;
     int32 CalculateResidency(StreamableResource* resource, float quality) override;
     int32 CalculateRequestedResidency(StreamableResource* resource, int32 targetResidency) override;
 };
@@ -35,7 +35,7 @@ class FLAXENGINE_API SkinnedModelsStreamingHandler : public IStreamingHandler
 {
 public:
     // [IStreamingHandler]
-    float CalculateTargetQuality(StreamableResource* resource, DateTime now, double currentTime) override;
+    float CalculateTargetQuality(StreamableResource* resource, double currentTime) override;
     int32 CalculateResidency(StreamableResource* resource, float quality) override;
     int32 CalculateRequestedResidency(StreamableResource* resource, int32 targetResidency) override;
 };
@@ -47,7 +47,7 @@ class FLAXENGINE_API AudioStreamingHandler : public IStreamingHandler
 {
 public:
     // [IStreamingHandler]
-    float CalculateTargetQuality(StreamableResource* resource, DateTime now, double currentTime) override;
+    float CalculateTargetQuality(StreamableResource* resource, double currentTime) override;
     int32 CalculateResidency(StreamableResource* resource, float quality) override;
     int32 CalculateRequestedResidency(StreamableResource* resource, int32 targetResidency) override;
     bool RequiresStreaming(StreamableResource* resource, int32 currentResidency, int32 targetResidency) override;

Source/Engine/Utilities/Screenshot.cpp

@@ -2,6 +2,7 @@
 
 #include "Screenshot.h"
 #include "Engine/Core/Log.h"
+#include "Engine/Core/Types/DateTime.h"
 #include "Engine/Core/Math/Math.h"
 #include "Engine/Graphics/RenderTask.h"
 #include "Engine/Platform/FileSystem.h"