feat: font_src on TextShape, UiText, UiInput and UiDropdown

Explorer/Assets/AddressableAssetsData/AssetGroups/UI.asset

@@ -580,6 +580,11 @@ MonoBehaviour:
     m_ReadOnly: 0
     m_SerializedLabels: []
     FlaggedDuringContentUpdateRestriction: 0
+  - m_GUID: 96ae0a2159a39234f858ea23bdcc74ad
+    m_Address: Assets/TextMesh Pro/Fonts & Materials/Inter-SemiBold SDF.asset
+    m_ReadOnly: 0
+    m_SerializedLabels: []
+    FlaggedDuringContentUpdateRestriction: 0
   - m_GUID: 989cf1173881645c598573447b2b56d8
     m_Address: HidesRow
     m_ReadOnly: 0

Explorer/Assets/DCL/Infrastructure/ECS/ComponentsPooling/Systems/ReleaseReferenceComponentsSystem.cs

@@ -29,20 +29,18 @@ public ReleaseReferenceComponentsSystem(World world, IComponentPoolsRegistry com
         protected override void Update(float _)
         {
             Query query = World.Query(in queryDescription);
-            ReleaseComponentsToPool(in query);
+            ReleaseComponentsToPool(in query, componentPoolsRegistry, respectDeferredDeletion: true);
         }
 
         public void FinalizeComponents(in Query query)
         {
-            ReleaseComponentsToPool(in query);
+            ReleaseComponentsToPool(in query, componentPoolsRegistry);
         }
 
-        private void ReleaseComponentsToPool(in Query query)
-        {
-            ReleaseComponentsToPool(query, componentPoolsRegistry);
-        }
+        public static void ReleaseComponentsToPool(in Query query, IComponentPoolsRegistry componentPoolsRegistry) =>
+            ReleaseComponentsToPool(in query, componentPoolsRegistry, respectDeferredDeletion: false);
 
-        public static void ReleaseComponentsToPool(in Query query, IComponentPoolsRegistry componentPoolsRegistry)
+        private static void ReleaseComponentsToPool(in Query query, IComponentPoolsRegistry componentPoolsRegistry, bool respectDeferredDeletion)
         {
             // Profiling required, O(N^4)
             foreach (ref Chunk chunk in query.GetChunkIterator())
@@ -52,6 +50,9 @@ public static void ReleaseComponentsToPool(in Query query, IComponentPoolsRegist
 
                 foreach (int entityIndex in chunk)
                 {
+                    if (respectDeferredDeletion && chunk.Get<DeleteEntityIntention>(entityIndex).DeferDeletion)
+                        continue;
+
                     for (var i = 0; i < array2D.Length; i++)
                     {
                         // if it is called on a value type it will cause an allocation

Explorer/Assets/DCL/Infrastructure/ECS/TestSuite/ECS.TestSuite.asmdef

@@ -13,7 +13,8 @@
         "GUID:3c7b57a14671040bd8c549056adc04f5",
         "GUID:fa7b3fdbb04d67549916da7bd2af58ab",
         "GUID:e25ef972de004615a22937e739de2def",
-        "GUID:0f4c0f120707fb74497f5d581b9858f8"
+        "GUID:0f4c0f120707fb74497f5d581b9858f8",
+        "GUID:6055be8ebefd69e48b49212b09b47b2f"
     ],
     "includePlatforms": [
         "Editor"

Explorer/Assets/DCL/Infrastructure/ECS/TestSuite/TestFonts.cs

@@ -0,0 +1,23 @@
+using System.IO;
+using TMPro;
+using UnityEngine;
+using UnityEngine.TextCore.LowLevel;
+using UnityEngine.TextCore.Text;
+
+namespace ECS.TestSuite
+{
+    public static class TestFonts
+    {
+        public static readonly string PATH = Path.Combine(Application.dataPath, "DCL/SDKComponents/Fonts/LiberationSans-Regular.ttf");
+
+        private const int SAMPLING_POINT_SIZE = 90;
+        private const int ATLAS_PADDING = 9;
+        private const int ATLAS_SIZE = 1024;
+
+        public static TMP_FontAsset CreateTextMeshProFont() =>
+            TMP_FontAsset.CreateFontAsset(PATH, 0, SAMPLING_POINT_SIZE, ATLAS_PADDING, GlyphRenderMode.SDFAA, ATLAS_SIZE, ATLAS_SIZE);
+
+        public static FontAsset CreateUIToolkitFont() =>
+            FontAsset.CreateFontAsset(PATH, 0, SAMPLING_POINT_SIZE, ATLAS_PADDING, GlyphRenderMode.SDFAA, ATLAS_SIZE, ATLAS_SIZE);
+    }
+}

Explorer/Assets/DCL/Infrastructure/ECS/Unity/StreamableLoading/Common/Components/CommonLoadingArguments.cs

@@ -53,9 +53,16 @@ public CommonLoadingArguments(string url, URLSubdirectory customEmbeddedSubDirec
             int attempts = StreamableLoadingDefaults.ATTEMPTS_COUNT,
             AssetSource permittedSources = AssetSource.Web,
             AssetSource currentSource = AssetSource.Web,
-            CancellationTokenSource cancellationTokenSource = null) :
+            CancellationTokenSource? cancellationTokenSource = null) :
             this(URLAddress.FromString(url), customEmbeddedSubDirectory, timeout, attempts, permittedSources, currentSource, cancellationTokenSource) { }
 
+        public CommonLoadingArguments WithURL(URLAddress url)
+        {
+            CommonLoadingArguments copy = this;
+            copy.URL = url;
+            return copy;
+        }
+
         // Always override attempts count for streamable assets as repetitions are handled in LoadSystemBase
         public static implicit operator CommonArguments(in CommonLoadingArguments commonLoadingArguments) =>
             new (commonLoadingArguments.URL, RetryPolicy.WithRetries(1), timeout: commonLoadingArguments.Timeout);

Explorer/Assets/DCL/Infrastructure/ECS/Unity/StreamableLoading/DeferredLoading/AssetsDeferredLoadingSystem.cs

@@ -4,6 +4,7 @@
 using ECS.Groups;
 using ECS.StreamableLoading.AssetBundles;
 using ECS.StreamableLoading.AudioClips;
+using ECS.StreamableLoading.Fonts;
 using ECS.StreamableLoading.GLTF;
 using ECS.StreamableLoading.NFTShapes;
 using ECS.StreamableLoading.Textures;
@@ -29,6 +30,7 @@ static AssetsDeferredLoadingSystem()
                 CreateQuery<GetTextureIntention, TextureData>(),
                 CreateQuery<GetNFTTypeIntention, NftTypeResult>(),
                 CreateQuery<GetAudioClipIntention, AudioClipData>(),
+                CreateQuery<GetFontIntention, FontData>(),
             };
         }
 

Explorer/Assets/DCL/Infrastructure/ECS/Unity/StreamableLoading/DeferredLoading/Tests/DeferredLoadingSystemShould.cs

@@ -2,6 +2,7 @@
 using DCL.Optimization.PerformanceBudgeting;
 using ECS.Prioritization.Components;
 using ECS.StreamableLoading.Common.Components;
+using ECS.StreamableLoading.Fonts;
 using ECS.StreamableLoading.Textures;
 using ECS.TestSuite;
 using NSubstitute;
@@ -123,5 +124,26 @@ public void IntentionsAllowedWhenBudgetIsReleased()
                 Assert.AreEqual(i < 8,
                     world.Get<StreamableLoadingState>(entities[i]).Value == StreamableLoadingState.Status.Allowed);
         }
+
+        [Test]
+        public void AllowFontIntentions()
+        {
+            Entity entity = world.Create(
+                new GetFontIntention
+                {
+                    Src = "fonts/Roboto.ttf",
+                    CommonArguments = new CommonLoadingArguments(""),
+                },
+                (IPartitionComponent)new PartitionComponent
+                {
+                    Bucket = 0,
+                    IsBehind = false,
+                    IsDirty = true,
+                }, new StreamableLoadingState());
+
+            system.Update(0);
+
+            Assert.That(world.Get<StreamableLoadingState>(entity).Value, Is.EqualTo(StreamableLoadingState.Status.Allowed));
+        }
     }
 }

Explorer/Assets/DCL/Infrastructure/ECS/Unity/StreamableLoading/Fonts/FontData.cs

@@ -0,0 +1,28 @@
+using Cysharp.Threading.Tasks;
+using DCL.Diagnostics;
+using DCL.Profiling;
+using Unity.Profiling;
+
+namespace ECS.StreamableLoading.Fonts
+{
+    public class FontData : StreamableRefCountData<FontFamilyAssets>
+    {
+        private readonly FontFileStore.Lease?[] files;
+
+        public FontData(FontFamilyAssets assets, params FontFileStore.Lease?[] files) : base(assets, ReportCategory.SDK_FONTS)
+        {
+            this.files = files;
+            ProfilingCounters.FontsAmount.Value++;
+        }
+
+        protected override ref ProfilerCounterValue<int> totalCount => ref ProfilingCounters.FontsAmount;
+
+        protected override ref ProfilerCounterValue<int> referencedCount => ref ProfilingCounters.FontsReferenced;
+
+        protected override void DestroyObject()
+        {
+            Asset.Destroy();
+            FontFileStore.ReleaseAfterDestructionAsync(files).Forget(e => ReportHub.LogException(e, ReportCategory.SDK_FONTS));
+        }
+    }
+}

Explorer/Assets/DCL/Infrastructure/ECS/Unity/StreamableLoading/Fonts/FontDownloadHandler.cs

@@ -0,0 +1,53 @@
+using System;
+using System.Text;
+using UnityEngine.Networking;
+
+namespace ECS.StreamableLoading.Fonts
+{
+    public class FontDownloadHandler : DownloadHandlerScript
+    {
+        private const int CHUNK_BYTES = 64 * 1024;
+
+        private readonly int maxBytes;
+        private byte[] buffer = Array.Empty<byte>();
+        private int length;
+
+        public bool LimitExceeded { get; private set; }
+
+        public FontDownloadHandler(int maxBytes) : base(new byte[CHUNK_BYTES])
+        {
+            this.maxBytes = maxBytes;
+        }
+
+        protected override void ReceiveContentLengthHeader(ulong contentLength) =>
+            LimitExceeded |= contentLength > (ulong)maxBytes;
+
+        protected override bool ReceiveData(byte[] receivedData, int dataLength)
+        {
+            if (LimitExceeded || dataLength > maxBytes - length)
+            {
+                LimitExceeded = true;
+                return false;
+            }
+
+            int required = length + dataLength;
+
+            if (required > buffer.Length)
+                Array.Resize(ref buffer, Math.Min(maxBytes, Math.Max(required, Math.Max(CHUNK_BYTES, buffer.Length * 2))));
+
+            Buffer.BlockCopy(receivedData, 0, buffer, length, dataLength);
+            length = required;
+            return true;
+        }
+
+        protected override byte[] GetData()
+        {
+            var result = new byte[length];
+            Buffer.BlockCopy(buffer, 0, result, 0, length);
+            return result;
+        }
+
+        protected override string GetText() =>
+            Encoding.UTF8.GetString(buffer, 0, length);
+    }
+}

Explorer/Assets/DCL/Infrastructure/ECS/Unity/StreamableLoading/Fonts/FontFamilyAssets.cs

@@ -0,0 +1,43 @@
+using System.Collections.Generic;
+using TMPro;
+using UnityEngine.TextCore.Text;
+using Utility;
+
+namespace ECS.StreamableLoading.Fonts
+{
+    public class FontFamilyAssets
+    {
+        private readonly List<TMP_FontAsset> textMeshProAssets;
+        private readonly List<FontAsset> uiToolkitAssets;
+
+        public TMP_FontAsset TextMeshProFont { get; }
+
+        public FontAsset UIToolkitFont { get; }
+
+        public FontFamilyAssets(TMP_FontAsset textMeshProFont, FontAsset uiToolkitFont, List<TMP_FontAsset> textMeshProAssets, List<FontAsset> uiToolkitAssets)
+        {
+            TextMeshProFont = textMeshProFont;
+            UIToolkitFont = uiToolkitFont;
+            this.textMeshProAssets = textMeshProAssets;
+            this.uiToolkitAssets = uiToolkitAssets;
+        }
+
+        public void Destroy() =>
+            Destroy(textMeshProAssets, uiToolkitAssets);
+
+        public static void Destroy(List<TMP_FontAsset> textMeshProAssets, List<FontAsset> uiToolkitAssets)
+        {
+            foreach (TMP_FontAsset asset in textMeshProAssets)
+            {
+                TMP_ResourceManager.RemoveFontAsset(asset);
+                UnityObjectUtils.SafeDestroy(asset);
+            }
+
+            foreach (FontAsset asset in uiToolkitAssets)
+                UnityObjectUtils.SafeDestroy(asset);
+
+            textMeshProAssets.Clear();
+            uiToolkitAssets.Clear();
+        }
+    }
+}