feat: 6849 loading screen by data

Explorer/Assets/DCL/Infrastructure/ECS/SceneLifeCycle/Systems/GatherGltfAssetsSystem.cs

@@ -7,6 +7,7 @@
 using ECS.Abstract;
 using ECS.Groups;
 using ECS.SceneLifeCycle.Reporting;
+using ECS.StreamableLoading.Common.Components;
 using ECS.Unity.GLTFContainer.Components;
 using ECS.Unity.Transforms.Components;
 using SceneRunner.Scene;
@@ -43,6 +44,13 @@ public partial class GatherGltfAssetsSystem : BaseUnityLoopSystem
         private readonly ILoadingStatus loadingStatus;
         private readonly Entity sceneContainerEntity;
 
+        // Byte-weighted progress tracking
+        private Dictionary<Entity, long>? contentLengthCache;
+        private long completedBytes;
+        private long totalBytesExpected;
+        private int entitiesWithKnownSize;
+        private float maxReportedProgress;
+
         internal GatherGltfAssetsSystem(World world, ISceneReadinessReportQueue readinessReportQueue,
             ISceneData sceneData, EntityEventBuffer<GltfContainerComponent> eventsBuffer,
             ISceneStateProvider sceneStateProvider, MemoryBudget memoryBudget,
@@ -63,6 +71,7 @@ internal GatherGltfAssetsSystem(World world, ISceneReadinessReportQueue readines
         public override void Initialize()
         {
             entitiesUnderObservation = HashSetPool<Entity>.Get();
+            contentLengthCache = DictionaryPool<Entity, long>.Get();
             startTime = Time.time;
         }
 
@@ -73,6 +82,13 @@ protected override void OnDispose()
                 HashSetPool<Entity>.Release(entitiesUnderObservation);
                 entitiesUnderObservation = null;
             }
+
+            if (contentLengthCache != null)
+            {
+                DictionaryPool<Entity, long>.Release(contentLengthCache);
+                contentLengthCache = null;
+            }
+
             sceneData.SceneLoadingConcluded = true;
         }
 
@@ -96,6 +112,8 @@ protected override void Update(float t)
                 concluded = true;
 
                 List<Entity> toDelete = ListPool<Entity>.Get();
+                long inProgressWeightedBytes = 0;
+                float unknownInProgressWeightedProgress = 0f;
 
                 // iterate over entities
 
@@ -111,22 +129,50 @@ protected override void Update(float t)
                         continue;
                     }
 
+                    // Cache ContentLength from the promise's StreamableLoadingState while it's alive
+                    CacheContentLength(entityRef, in gltfContainerComponent);
+
                     // if Gltf Container Component has finished loading at least once (it can be reconfigured, we don't care)
                     if (gltfContainerComponent.State == LoadingState.Loading)
+                    {
                         // if at least one entity is still loading, we are not done.
                         concluded = false;
+
+                        // Accumulate in-progress weighted bytes
+                        if (contentLengthCache!.TryGetValue(entityRef, out long cachedLength) && cachedLength > 0)
+                            inProgressWeightedBytes += (long)(GetEntityProgress(entityRef, in gltfContainerComponent) * cachedLength);
+                        else
+                            unknownInProgressWeightedProgress += GetEntityProgress(entityRef, in gltfContainerComponent);
+                    }
                     else
+                    {
                         // remove entity from list - it's loaded, we don't need to check it anymore
                         toDelete.Add(entityRef);
+                    }
+                }
+
+                // Accumulate completed bytes from resolved entities
+                for (var i = 0; i < toDelete.Count; i++)
+                {
+                    Entity entity = toDelete[i];
+
+                    if (contentLengthCache!.TryGetValue(entity, out long len))
+                    {
+                        if (len > 0)
+                            completedBytes += len;
+
+                        contentLengthCache.Remove(entity);
+                    }
                 }
 
                 assetsResolved += toDelete.Count;
-                float progress = totalAssetsToResolve != 0 ? assetsResolved / (float)totalAssetsToResolve : 1;
+                float progress = ComputeProgress(inProgressWeightedBytes, unknownInProgressWeightedProgress);
+                maxReportedProgress = Mathf.Max(maxReportedProgress, progress);
 
                 for (var i = 0; i < reports!.Value.Count; i++)
                 {
                     AsyncLoadProcessReport report = reports.Value[i];
-                    report.SetProgress(progress);
+                    report.SetProgress(maxReportedProgress);
                 }
 
                 entitiesUnderObservation.ExceptWith(toDelete);
@@ -150,6 +196,12 @@ protected override void Update(float t)
 
                 if (concluded)
                 {
+                    for (var i = 0; i < reports!.Value.Count; i++)
+                    {
+                        AsyncLoadProcessReport report = reports.Value[i];
+                        report.SetProgress(1);
+                    }
+
                     reports.Value.Dispose();
                     reports = null;
                     Conclude();
@@ -168,6 +220,60 @@ void Conclude()
             }
         }
 
+        private void CacheContentLength(Entity entityRef, in GltfContainerComponent gltfContainerComponent)
+        {
+            Entity promiseEntity = gltfContainerComponent.Promise.Entity;
+
+            if (!World.IsAlive(promiseEntity)
+                || !World.TryGet(promiseEntity, out StreamableLoadingState loadingState))
+                return;
+
+            if (loadingState.ContentLength <= 0)
+                return;
+
+            if (!contentLengthCache!.ContainsKey(entityRef))
+            {
+                contentLengthCache[entityRef] = loadingState.ContentLength;
+                totalBytesExpected += loadingState.ContentLength;
+                entitiesWithKnownSize++;
+            }
+        }
+
+        private float GetEntityProgress(Entity entityRef, in GltfContainerComponent gltfContainerComponent)
+        {
+            Entity promiseEntity = gltfContainerComponent.Promise.Entity;
+
+            if (!World.IsAlive(promiseEntity)
+                || !World.TryGet(promiseEntity, out StreamableLoadingState loadingState))
+                return 0f;
+
+            return loadingState.Progress;
+        }
+
+        private float ComputeProgress(long inProgressWeightedBytes, float unknownInProgressWeightedProgress)
+        {
+            // Fallback: count-based progress when no byte data is available
+            if (entitiesWithKnownSize <= 0 || totalBytesExpected <= 0)
+                return totalAssetsToResolve != 0 ? assetsResolved / (float)totalAssetsToResolve : 1f;
+
+            // Estimate unknown assets using average size of known assets
+            long avgSize = totalBytesExpected / entitiesWithKnownSize;
+            int unknownCount = totalAssetsToResolve - entitiesWithKnownSize;
+            long effectiveTotal = totalBytesExpected + avgSize * Math.Max(0, unknownCount);
+
+            // Account for completed unknown-size entities using the average estimate
+            int completedKnownCount = entitiesWithKnownSize - contentLengthCache!.Count;
+            int completedUnknownCount = Math.Max(0, assetsResolved - completedKnownCount);
+            long estimatedCompletedUnknownBytes = avgSize * completedUnknownCount;
+
+            // Account for in-progress unknown-size entities using their per-entity progress * average size
+            long estimatedUnknownInProgressBytes = (long)(unknownInProgressWeightedProgress * avgSize);
+
+            return effectiveTotal > 0
+                ? Mathf.Clamp01((float)(completedBytes + estimatedCompletedUnknownBytes + inProgressWeightedBytes + estimatedUnknownInProgressBytes) / effectiveTotal)
+                : 0f;
+        }
+
         private void GatherEntities(Entity entity, GltfContainerComponent component)
         {
             // No matter to which state component has changed

Explorer/Assets/DCL/Infrastructure/ECS/StreamableLoading/AssetBundles/LoadAssetBundleSystem.cs

@@ -61,8 +61,14 @@ private async UniTask<AssetBundleData[]> LoadDependenciesAsync(GetAssetBundleInt
 
         protected override async UniTask<StreamableLoadingResult<AssetBundleData>> FlowInternalAsync(GetAssetBundleIntention intention, StreamableLoadingState state, IPartitionComponent partition, CancellationToken ct)
         {
-            AssetBundleLoadingResult assetBundleResult = await webRequestController
-               .GetAssetBundleAsync(intention.CommonArguments, new GetAssetBundleArguments(loadingMutex, intention.cacheHash), ct, GetReportCategory(),
+            state.SetProgress(0);
+            state.SetContentLength(-1);
+            AssetBundleLoadingResult assetBundleResult = await webRequestController.GetAssetBundleAsync(
+                    intention.CommonArguments,
+                    new GetAssetBundleArguments(loadingMutex, intention.cacheHash),
+                    ct,
+                    GetReportCategory(),
+                    progressHandler: state,
                     suppressErrors: true); // Suppress errors because here we have our own error handling
 
             AssetBundle? assetBundle = assetBundleResult.AssetBundle;

Explorer/Assets/DCL/Infrastructure/ECS/StreamableLoading/Common/Components/StreamableLoadingState.cs

@@ -1,5 +1,6 @@
 using DCL.Optimization.PerformanceBudgeting;
 using DCL.Optimization.Pools;
+using DCL.WebRequests;
 using ECS.StreamableLoading.Cache.Disk;
 using System;
 using System.Runtime.CompilerServices;
@@ -11,7 +12,7 @@ namespace ECS.StreamableLoading.Common.Components
     /// <summary>
     ///     Common state for all streamable types
     /// </summary>
-    public class StreamableLoadingState
+    public class StreamableLoadingState : IStreamableLoadingProgressHandler, IStreamableLoadingProgress
     {
         public enum Status : byte
         {
@@ -46,6 +47,8 @@ public enum Status : byte
             {
                 state.disposed = false;
                 state.Value = Status.NotStarted;
+                state.Progress = 0f;
+                state.ContentLength = 0;
             },
             actionOnRelease: state =>
             {
@@ -76,6 +79,9 @@ internal StreamableLoadingState() { }
         /// </summary>
         public PartialLoadingState? PartialDownloadingData { get; internal set; }
 
+        public float Progress { get; private set; }
+        public long ContentLength { get; private set; }
+
         public ReadOnlyMemory<byte> GetFullyDownloadedData()
         {
             Assert.IsTrue(PartialDownloadingData is { FullyDownloaded: true });
@@ -167,5 +173,8 @@ public void Dispose()
 
             POOL.Release(this);
         }
+
+        public void SetProgress(float progress) => Progress = progress;
+        public void SetContentLength(long length) => ContentLength = length;
     }
 }

Explorer/Assets/DCL/WebRequests/ArtificialDelayWebRequestController.cs

@@ -17,7 +17,8 @@ public ArtificialDelayWebRequestController(IWebRequestController origin, IReadOn
 
         public async UniTask<TResult?> SendAsync<TWebRequest, TWebRequestArgs, TWebRequestOp, TResult>(
             RequestEnvelope<TWebRequest, TWebRequestArgs> envelope,
-            TWebRequestOp op
+            TWebRequestOp op,
+            IStreamableLoadingProgressHandler? progressHandler = null
         )
             where TWebRequest: struct, ITypedWebRequest
             where TWebRequestArgs: struct
@@ -28,7 +29,7 @@ TWebRequestOp op
             if (useDelay)
                 await UniTask.Delay(TimeSpan.FromSeconds(delaySeconds));
 
-            return await origin.SendAsync<TWebRequest, TWebRequestArgs, TWebRequestOp, TResult>(envelope, op);
+            return await origin.SendAsync<TWebRequest, TWebRequestArgs, TWebRequestOp, TResult>(envelope, op, progressHandler);
         }
 
         IRequestHub IWebRequestController.RequestHub => origin.RequestHub;

Explorer/Assets/DCL/WebRequests/DebugMetricsWebRequestController.cs

@@ -20,12 +20,12 @@ public DebugMetricsWebRequestController(IWebRequestController origin,
         }
 
         public async UniTask<TResult?> SendAsync<TWebRequest, TWebRequestArgs, TWebRequestOp, TResult>(
-            RequestEnvelope<TWebRequest, TWebRequestArgs> envelope, TWebRequestOp op)
+            RequestEnvelope<TWebRequest, TWebRequestArgs> envelope, TWebRequestOp op, IStreamableLoadingProgressHandler? progressHandler = null)
             where TWebRequest: struct, ITypedWebRequest
             where TWebRequestArgs: struct
             where TWebRequestOp: IWebRequestOp<TWebRequest, TResult>
         {
-            try { return await origin.SendAsync<TWebRequest, TWebRequestArgs, TWebRequestOp, TResult>(envelope, op); }
+            try { return await origin.SendAsync<TWebRequest, TWebRequestArgs, TWebRequestOp, TResult>(envelope, op, progressHandler); }
             catch (Exception e) when (e is not OperationCanceledException)
             {
                 if (e.Message.Contains(WebRequestUtils.CANNOT_CONNECT_ERROR))

Explorer/Assets/DCL/WebRequests/IStreamableLoadingProgress.cs

@@ -0,0 +1,14 @@
+namespace DCL.WebRequests
+{
+    public interface IStreamableLoadingProgress
+    {
+        float Progress { get; }
+        long ContentLength { get; }
+    }
+
+    public interface IStreamableLoadingProgressHandler : IStreamableLoadingProgress
+    {
+        void SetProgress (float progress);
+        void SetContentLength (long length);
+    }
+}

Explorer/Assets/DCL/WebRequests/ITypedWebRequest.cs

@@ -1,6 +1,7 @@
-using Cysharp.Threading.Tasks;
+using Cysharp.Threading.Tasks;
 using System;
 using System.Threading;
+using UnityEngine;
 using UnityEngine.Networking;
 
 namespace DCL.WebRequests
@@ -20,7 +21,71 @@ public interface ITypedWebRequest
 
     public static class TypedWebRequestExtensions
     {
-        public static UniTask SendRequest<T>(this T typedWebRequest, CancellationToken token) where T: ITypedWebRequest =>
-            typedWebRequest.UnityWebRequest.SendWebRequest()!.WithCancellation(token);
+        public static async UniTask SendRequest<T>(this T typedWebRequest, CancellationToken token, IStreamableLoadingProgressHandler? progressHandler = null) where T: ITypedWebRequest
+        {
+            if (progressHandler == null)
+            {
+                await typedWebRequest.UnityWebRequest.SendWebRequest().WithCancellation(token);
+                return;
+            }
+
+            using var headTimeoutCts = CancellationTokenSource.CreateLinkedTokenSource(token);
+            headTimeoutCts.CancelAfter(500);
+            var contentLength = await FetchContentLengthAsync(typedWebRequest.UnityWebRequest.url, headTimeoutCts.Token);
+
+            progressHandler.SetContentLength(contentLength);
+            UnityWebRequestAsyncOperation op = typedWebRequest.UnityWebRequest.SendWebRequest();
+
+            while (!op.isDone)
+            {
+                if (token.IsCancellationRequested)
+                {
+                    return;
+                }
+
+                if (contentLength != -1)
+                    progressHandler.SetProgress(op.webRequest.downloadedBytes / (float)contentLength);
+                else
+                    progressHandler.SetProgress(op.progress); // Unreliable for on-the-fly compressed responses, but best-effort fallback
+
+                await UniTask.Yield();
+            }
+
+            progressHandler.SetProgress(1f);
+
+            UnityWebRequest request = typedWebRequest.UnityWebRequest;
+
+            if (request.result != UnityWebRequest.Result.Success) // This is really important. Other systems react to this exception being triggered.
+                throw new UnityWebRequestException(request);
+        }
+
+        private static async UniTask<long> FetchContentLengthAsync(string url, CancellationToken ct)
+        {
+            const string DECOMPRESSED_CONTENT_LENGTH_HEADER = "x-decompressed-content-length";
+
+            if (url.StartsWith("file://"))
+                return -1;
+
+            using var headRequest = UnityWebRequest.Head(url);
+
+            try
+            {
+                await headRequest.SendWebRequest().WithCancellation(ct);
+
+                if (headRequest.result != UnityWebRequest.Result.Success)
+                    return -1;
+
+                string header = headRequest.GetResponseHeader(DECOMPRESSED_CONTENT_LENGTH_HEADER);
+
+                if (header != null && long.TryParse(header, out long contentLength))
+                    return contentLength;
+            }
+            catch (OperationCanceledException)
+            {
+                // Timeout expired — proceed without content length
+            }
+
+            return -1;
+        }
     }
 }

Explorer/Assets/DCL/WebRequests/IWebRequestController.cs

@@ -16,7 +16,10 @@ public interface IWebRequestController
 
         public IRequestHub RequestHub { get; }
 
-        public UniTask<TResult?> SendAsync<TWebRequest, TWebRequestArgs, TWebRequestOp, TResult>(RequestEnvelope<TWebRequest, TWebRequestArgs> envelope, TWebRequestOp op)
+        public UniTask<TResult?> SendAsync<TWebRequest, TWebRequestArgs, TWebRequestOp, TResult>(
+            RequestEnvelope<TWebRequest, TWebRequestArgs> envelope,
+            TWebRequestOp op,
+            IStreamableLoadingProgressHandler? progressHandler = null)
             where TWebRequestArgs: struct
             where TWebRequest: struct, ITypedWebRequest
             where TWebRequestOp: IWebRequestOp<TWebRequest, TResult>;