chore: checkpoint current workspace changes

engine/src/Components/VolumeRendererComponent.cpp

@@ -1,6 +1,9 @@
 #include "Components/VolumeRendererComponent.h"
 
 #include "Core/Asset/ResourceManager.h"
+#include "Debug/Logger.h"
+
+#include <chrono>
 
 namespace XCEngine {
 namespace Components {
@@ -47,10 +50,24 @@ std::string MaterialPathFromHandle(const Resources::ResourceHandle<Resources::Ma
     return material.Get() != nullptr ? ToStdString(material->GetPath()) : std::string();
 }
 
+uint64_t GetVolumeTraceSteadyMs() {
+    using Clock = std::chrono::steady_clock;
+    static const Clock::time_point s_start = Clock::now();
+    return static_cast<uint64_t>(std::chrono::duration_cast<std::chrono::milliseconds>(
+        Clock::now() - s_start).count());
+}
+
+void LogVolumeTraceFileSystem(const std::string& message) {
+    Containers::String entry("[VolumeTrace] ");
+    entry += message.c_str();
+    Debug::Logger::Get().Info(Debug::LogCategory::FileSystem, entry);
+}
+
 } // namespace
 
 struct VolumeRendererComponent::PendingVolumeLoadState {
     Resources::LoadResult result;
+    uint64_t requestedAtMs = 0u;
     bool completed = false;
 };
 
@@ -311,12 +328,30 @@ void VolumeRendererComponent::BeginAsyncVolumeLoad(const std::string& volumeFiel
     m_asyncVolumeLoadRequested = true;
     m_volumeField.Reset();
     m_pendingVolumeLoad = std::make_shared<PendingVolumeLoadState>();
+    m_pendingVolumeLoad->requestedAtMs = GetVolumeTraceSteadyMs();
+    LogVolumeTraceFileSystem(
+        "BeginAsyncVolumeLoad path=" + volumeFieldPath +
+        " steady_ms=" + std::to_string(m_pendingVolumeLoad->requestedAtMs));
     std::weak_ptr<PendingVolumeLoadState> weakState = m_pendingVolumeLoad;
     Resources::ResourceManager::Get().LoadAsync(
         volumeFieldPath.c_str(),
         Resources::ResourceType::VolumeField,
-        [weakState](Resources::LoadResult result) {
+        [weakState, volumeFieldPath](Resources::LoadResult result) {
             if (std::shared_ptr<PendingVolumeLoadState> state = weakState.lock()) {
+                const uint64_t completedAtMs = GetVolumeTraceSteadyMs();
+                const bool succeeded = static_cast<bool>(result) && result.resource != nullptr;
+                size_t payloadBytes = 0u;
+                if (succeeded) {
+                    if (auto* volumeField = static_cast<Resources::VolumeField*>(result.resource)) {
+                        payloadBytes = volumeField->GetPayloadSize();
+                    }
+                }
+                LogVolumeTraceFileSystem(
+                    "AsyncVolumeLoadCompleted path=" + volumeFieldPath +
+                    " steady_ms=" + std::to_string(completedAtMs) +
+                    " elapsed_ms=" + std::to_string(completedAtMs - state->requestedAtMs) +
+                    " success=" + std::to_string(succeeded ? 1 : 0) +
+                    " payload_bytes=" + std::to_string(payloadBytes));
                 state->result = std::move(result);
                 state->completed = true;
             }
@@ -349,6 +384,13 @@ void VolumeRendererComponent::ResolvePendingVolumeField() {
         return;
     }
 
+    const uint64_t resolvedAtMs = GetVolumeTraceSteadyMs();
+    LogVolumeTraceFileSystem(
+        "ResolvePendingVolumeField path=" + VolumeFieldPathFromHandle(m_volumeField) +
+        " steady_ms=" + std::to_string(resolvedAtMs) +
+        " elapsed_ms=" + std::to_string(resolvedAtMs - completedLoad->requestedAtMs) +
+        " payload_bytes=" + std::to_string(m_volumeField->GetPayloadSize()));
+
     m_volumeFieldPath = VolumeFieldPathFromHandle(m_volumeField);
     if (!Resources::ResourceManager::Get().TryGetAssetRef(
             m_volumeFieldPath.c_str(),