feat: portable experiences

Explorer/Assets/DCL/CommunicationData/URLHelpers/ENS.cs

@@ -0,0 +1,24 @@
+using DCL.CommunicationData.URLHelpers;
+using System;
+
+namespace CommunicationData.URLHelpers
+{
+    public readonly struct ENS
+    {
+        private readonly string ens;
+
+        public ENS(string ens)
+        {
+            this.ens = ens;
+        }
+
+        public bool IsValid => !string.IsNullOrEmpty(ens) && ens.IsEns();
+
+        public bool Equals (ENS other) => Equals(other.ens);
+
+        public bool Equals(string other) =>
+            string.Equals(ens, other, StringComparison.OrdinalIgnoreCase);
+
+        public override string ToString() => ens;
+    }
+}

Explorer/Assets/DCL/CommunicationData/URLHelpers/EnsExtensions.cs

@@ -6,11 +6,15 @@ namespace DCL.CommunicationData.URLHelpers
     public static class EnsExtensions
     {
         private static readonly Regex REGEX = new (@"^[a-zA-Z0-9.]+\.eth$");
+        private const string WORLD_URL = "https://worlds-content-server.decentraland.org/world/";
 
         public static bool IsEns(this string str) =>
             REGEX.Match(str).Success;
 
         public static bool IsEns(this URLDomain domain) =>
             REGEX.Match(domain.Value).Success;
+
+        public static string ConvertEnsToWorldUrl(this ENS ens) =>
+            WORLD_URL + ens.ToString().ToLower();
     }
 }

Explorer/Assets/DCL/FeatureFlags/FeatureFlagsConfiguration.cs

@@ -5,8 +5,33 @@
 
 namespace DCL.FeatureFlags
 {
+    public enum FeatureFlags
+    {
+        PORTABLE_EXPERIENCE,
+        GLOBAL_PORTABLE_EXPERIENCE,
+        PORTABLE_EXPERIENCE_CHAT_COMMANDS,
+        MAP_PINS
+    }
+
     public class FeatureFlagsConfiguration
     {
+        public static string GetFlag(FeatureFlags flags)
+        {
+            switch (flags)
+            {
+                case FeatureFlags.PORTABLE_EXPERIENCE:
+                    return "alfa-portable-experiences";
+                case FeatureFlags.GLOBAL_PORTABLE_EXPERIENCE:
+                    return "alfa-global-portable-experiences";
+                case FeatureFlags.PORTABLE_EXPERIENCE_CHAT_COMMANDS:
+                    return "alfa-portable-experiences-chat-commands";
+                case FeatureFlags.MAP_PINS:
+                    return "alfa-map-pins";
+                default:
+                    return flags.ToString();
+            }
+        }
+
         private readonly FeatureFlagsResultDto result;
 
         public FeatureFlagsConfiguration(FeatureFlagsResultDto result)

Explorer/Assets/DCL/Ipfs/SceneMetadata.cs

@@ -15,6 +15,7 @@ public class SceneMetadata : PreserveOriginalJson
         public List<string> allowedMediaHostnames;
         public List<string> requiredPermissions;
         public List<SpawnPoint>? spawnPoints;
+        public bool isPortableExperience;
 
         [Serializable]
         public struct SpawnPoint
@@ -38,7 +39,7 @@ public Vector3 ToVector3() =>
             }
 
             /// <summary>
-            /// Coordinates is either a single value or a list of values
+            ///     Coordinates is either a single value or a list of values
             /// </summary>
             [JsonConverter(typeof(SpawnPointCoordinateConverter))]
             public struct Coordinate

Explorer/Assets/DCL/LOD/Systems/ResolveVisualSceneStateSystem.cs

@@ -41,8 +41,8 @@ private void AddSceneVisualState(in Entity entity, ref PartitionComponent partit
             if (!partition.IsDirty) return;
 
             if (partition.OutOfRange) return;
-            
-            VisualSceneState visualSceneState = new VisualSceneState();
+
+            var visualSceneState = new VisualSceneState();
             visualSceneStateResolver.ResolveVisualSceneState(ref visualSceneState, partition, sceneDefinitionComponent, lodSettingsAsset, realmData);
             visualSceneState.IsDirty = false;
             World.Add(entity, visualSceneState);

Explorer/Assets/DCL/LOD/Systems/UpdateSceneLODInfoSystem.cs

@@ -5,6 +5,8 @@
 using DCL.Diagnostics;
 using DCL.LOD.Components;
 using DCL.Multiplayer.Connections.DecentralandUrls;
+using DCL.Optimization.PerformanceBudgeting;
+using DCL.PluginSystem.Global;
 using ECS.Abstract;
 using ECS.LifeCycle.Components;
 using ECS.Prioritization.Components;
@@ -46,7 +48,7 @@ protected override void Update(float t)
         }
 
         [Query]
-        [None(typeof(DeleteEntityIntention))]
+        [None(typeof(DeleteEntityIntention), typeof(PortableExperienceComponent))]
         private void UpdateLODLevel(ref SceneLODInfo sceneLODInfo, ref PartitionComponent partitionComponent, SceneDefinitionComponent sceneDefinitionComponent)
         {
             if (!partitionComponent.IsBehind) // Only want to load scene in our direction of travel
@@ -89,7 +91,7 @@ private byte GetLODLevelForPartition(ref PartitionComponent partitionComponent,
                     sceneLODCandidate = (byte)(i + 1);
             }
 
-            //LOD0 load distance may be very far away from its show distance depending on the object size. 
+            //LOD0 load distance may be very far away from its show distance depending on the object size.
             //So, we force it if it has not been loaded and we passed the show distance threshold
             if (sceneLODInfo.metadata.LODChangeRelativeDistance >= partitionComponent.Bucket * ParcelMathHelper.PARCEL_SIZE
                 && sceneLODCandidate == 1 && !sceneLODInfo.HasLOD(0))

Explorer/Assets/DCL/LOD/Systems/UpdateVisualSceneStateSystem.cs

@@ -3,12 +3,14 @@
 using DCL.Diagnostics;
 using DCL.LOD;
 using DCL.LOD.Components;
+using DCL.Optimization.PerformanceBudgeting;
 using ECS.Abstract;
 using ECS.LifeCycle.Components;
 using ECS.Prioritization.Components;
 using ECS.SceneLifeCycle.Components;
 using ECS.SceneLifeCycle.SceneDefinition;
 using ECS.StreamableLoading.Common;
+using SceneRunner;
 using SceneRunner.Scene;
 using System.Runtime.CompilerServices;
 
@@ -20,21 +22,20 @@ namespace ECS.SceneLifeCycle.Systems
     [LogCategory(ReportCategory.LOD)]
     public partial class UpdateVisualSceneStateSystem : BaseUnityLoopSystem
     {
+        /// <summary>
+        ///     Represents one of the methods in UpdateVisualSceneStateSystem, they should be converted to static ones to avoid closures
+        /// </summary>
+        private delegate void ContinuationMethod<T>(Entity entity, ref VisualSceneState visualSceneState, ref SceneDefinitionComponent sceneDefinitionComponent, ref PartitionComponent partitionComponent, ref T switchComponent);
+
         private readonly IRealmData realmData;
         private readonly IScenesCache scenesCache;
         private readonly ILODCache lodCache;
         private readonly ILODSettingsAsset lodSettingsAsset;
         private readonly SceneAssetLock sceneAssetLock;
-
         private static readonly QueryDescription VISUAL_STATE_SCENE_QUERY = new QueryDescription()
                                                                            .WithAll<VisualSceneState, PartitionComponent, SceneDefinitionComponent>()
                                                                            .WithAny<SceneLODInfo, ISceneFacade, AssetPromise<ISceneFacade, GetSceneFacadeIntention>>()
-                                                                           .WithNone<DeleteEntityIntention>();
-
-        /// <summary>
-        ///     Represents one of the methods in UpdateVisualSceneStateSystem, they should be converted to static ones to avoid closures
-        /// </summary>
-        private delegate void ContinuationMethod<T>(Entity entity, ref VisualSceneState visualSceneState, ref SceneDefinitionComponent sceneDefinitionComponent, ref PartitionComponent partitionComponent, ref T switchComponent);
+                                                                           .WithNone<DeleteEntityIntention, PortableExperienceComponent>();
 
         private readonly ContinuationMethod<ISceneFacade> sceneFacadeToLODContinuation;
         private readonly ContinuationMethod<AssetPromise<ISceneFacade, GetSceneFacadeIntention>> scenePromiseToLODContinuation;
@@ -98,9 +99,10 @@ private void IterateOverOneOf<T>(Archetype archetype, ContinuationMethod<T> cont
 
                 foreach (int entityIndex in chunk)
                 {
+                    ref SceneDefinitionComponent sceneDefinitionComponent = ref Unsafe.Add(ref scenedefinitioncomponentFirstElement, entityIndex);
                     ref readonly Entity entity = ref Unsafe.Add(ref entityFirstElement, entityIndex);
                     ref VisualSceneState visualSceneStateComponent = ref Unsafe.Add(ref visualscenestateFirstElement, entityIndex);
-                    ref SceneDefinitionComponent sceneDefinitionComponent = ref Unsafe.Add(ref scenedefinitioncomponentFirstElement, entityIndex);
+
                     ref T customComponent = ref Unsafe.Add(ref customComponentFirstElement, entityIndex);
                     ref PartitionComponent partitionComponent = ref Unsafe.Add(ref partitioncomponentFirstElement, entityIndex);
 
@@ -118,18 +120,17 @@ private void IterateOverOneOf<T>(Archetype archetype, ContinuationMethod<T> cont
 
         private void SwapScenePromiseToLOD(Entity entity, ref VisualSceneState visualSceneState, ref SceneDefinitionComponent sceneDefinitionComponent, ref PartitionComponent partitionComponent, ref AssetPromise<ISceneFacade, GetSceneFacadeIntention> switchcomponent)
         {
-            if (visualSceneState.CurrentVisualSceneState == VisualSceneStateEnum.SHOWING_LOD)
-            {
-                var sceneLODInfo = SceneLODInfo.Create();
+            if (visualSceneState.CurrentVisualSceneState != VisualSceneStateEnum.SHOWING_LOD) return;
 
-                //Dispose Promise
-                switchcomponent.ForgetLoading(World);
+            var sceneLODInfo = SceneLODInfo.Create();
 
-                visualSceneState.IsDirty = false;
+            //Dispose Promise
+            switchcomponent.ForgetLoading(World);
 
-                World.Add(entity, sceneLODInfo);
-                World.Remove<AssetPromise<ISceneFacade, GetSceneFacadeIntention>>(entity);
-            }
+            visualSceneState.IsDirty = false;
+
+            World.Add(entity, sceneLODInfo);
+            World.Remove<AssetPromise<ISceneFacade, GetSceneFacadeIntention>>(entity);
         }
 
         private void SwapLODToScenePromise(Entity entity, ref VisualSceneState visualSceneState, ref SceneDefinitionComponent sceneDefinitionComponent, ref PartitionComponent partitionComponent, ref SceneLODInfo switchComponent)
@@ -143,26 +144,26 @@ private void SwapLODToScenePromise(Entity entity, ref VisualSceneState visualSce
                 World.Add(entity, AssetPromise<ISceneFacade, GetSceneFacadeIntention>.Create(World,
                     new GetSceneFacadeIntention(realmData.Ipfs, sceneDefinitionComponent),
                     partitionComponent));
+
                 World.Remove<SceneLODInfo>(entity);
             }
         }
 
         private void SwapSceneFacadeToLOD(Entity entity, ref VisualSceneState visualSceneState, ref SceneDefinitionComponent sceneDefinitionComponent, ref PartitionComponent partitionComponent, ref ISceneFacade switchComponent)
-        {
-            if (visualSceneState.CurrentVisualSceneState == VisualSceneStateEnum.SHOWING_LOD)
             {
-                //Create LODInfo
-                var sceneLODInfo = SceneLODInfo.Create();
+                if (visualSceneState.CurrentVisualSceneState == VisualSceneStateEnum.SHOWING_LOD)
+                {
+                    //Create LODInfo
+                    var sceneLODInfo = SceneLODInfo.Create();
 
-                //Dispose scene
-                switchComponent.DisposeSceneFacadeAndRemoveFromCache(scenesCache, sceneDefinitionComponent.Parcels, sceneAssetLock);
+                    //Dispose scene
+                    switchComponent.DisposeSceneFacadeAndRemoveFromCache(scenesCache, sceneDefinitionComponent.Parcels, sceneAssetLock);
 
-                visualSceneState.IsDirty = false;
+                    visualSceneState.IsDirty = false;
 
-                World.Add(entity, sceneLODInfo);
-                World.Remove<ISceneFacade, AssetPromise<ISceneFacade, GetSceneFacadeIntention>>(entity);
+                    World.Add(entity, sceneLODInfo);
+                    World.Remove<ISceneFacade, AssetPromise<ISceneFacade, GetSceneFacadeIntention>>(entity);
+                }
             }
-        }
-
     }
 }

Explorer/Assets/DCL/LOD/Tests/EditMode/InitializeSceneLODInfoShould.cs

@@ -35,7 +35,7 @@ public void SetUp()
             cachedInfo = new LODCacheInfo(lodGroupPool.Get(), 2);
             cachedInfo.SuccessfullLODs = 1;
             lodCache = Substitute.For<ILODCache>();
-            
+
             lodCache.TryGet(fakeSceneIDCached, out Arg.Any<LODCacheInfo>()).Returns(call =>
             {
                 call[1] = cachedInfo;
@@ -55,7 +55,8 @@ public void SetUp()
                     }
                 }
             };
-            sceneDefinitionComponent = new SceneDefinitionComponent(sceneEntityDefinition, new IpfsPath());
+
+            sceneDefinitionComponent = SceneDefinitionComponentFactory.CreateFromDefinition(sceneEntityDefinition, new IpfsPath());
             partitionComponent = new PartitionComponent();
             system = new InitializeSceneLODInfoSystem(world, lodCache, LOD_LEVELS, lodGroupPool,
                 new GameObject().transform, Substitute.For<ISceneReadinessReportQueue>(),
@@ -99,4 +100,4 @@ public void GotNewSceneMetadataFromCache()
             Assert.AreEqual(sceneLODInfoRetrieved.metadata.FailedLODs, (byte)0);
         }
     }
-}
+}