< Summary

Class:DCL.Controllers.ParcelScene
Assembly:DCL.Runtime
File(s):/tmp/workspace/unity-renderer/unity-renderer/Assets/Scripts/MainScripts/DCL/WorldRuntime/ParcelScene.cs
Covered lines:237
Uncovered lines:45
Coverable lines:282
Total lines:631
Line coverage:84% (237 of 282)
Covered branches:0
Total branches:0

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity NPath complexity Sequence coverage
ParcelScene()0%110100%
Awake()0%110100%
OnDestroy()0%3.143075%
OnDisable()0%220100%
Update()0%330100%
SetData(...)0%220100%
SetupPositionAndParcels()0%220100%
OnWorldReposition(...)0%110100%
SetUpdateData(...)0%110100%
InitializeDebugPlane()0%440100%
RemoveDebugPlane()0%6200%
Cleanup(...)0%7.117086.96%
ToString()0%12300%
GetSceneName()0%6200%
IsInsideSceneBoundaries(...)0%330100%
IsInsideSceneBoundaries(...)0%3.333066.67%
IsInsideSceneBoundaries(...)0%8.338082.76%
IsInsideSceneOuterBoundaries(...)0%220100%
IsInsideSceneOuterBoundaries(...)0%110100%
OnDrawGizmosSelected()0%6200%
GetEntityById(...)0%2100%
GetSceneTransform()0%110100%
CreateEntity(...)0%440100%
OnEntityShapeUpdated(...)0%110100%
RemoveEntity(...)0%4.014090.91%
CleanUpEntityRecursively(...)0%550100%
RemoveAllEntities(...)0%770100%
RemoveAllEntitiesImmediate()0%110100%
SetEntityParent(...)0%15.7615085%
SendMetricsEvent()0%220100%
GetEntityById(...)0%4.594066.67%
GetStateString()0%13.048057.14%
RefreshLoadingState()0%2.032080%
GetWaitingComponentsDebugInfo()0%6200%
CalculateSceneLoadingState()0%4.134080%

File(s)

/tmp/workspace/unity-renderer/unity-renderer/Assets/Scripts/MainScripts/DCL/WorldRuntime/ParcelScene.cs

#LineLine coverage
 1using DCL.Configuration;
 2using DCL.Helpers;
 3using DCL.Models;
 4using DCL.Controllers.ParcelSceneDebug;
 5using System.Collections.Generic;
 6using DCL.CRDT;
 7using DCL.Interface;
 8using UnityEngine;
 9using UnityEngine.Assertions;
 10
 11namespace DCL.Controllers
 12{
 13    public class ParcelScene : MonoBehaviour, IParcelScene
 14    {
 15        [Header("Debug")]
 16        [SerializeField]
 57317        private bool renderOuterBoundsGizmo = true;
 18
 93819        public Dictionary<long, IDCLEntity> entities { get; private set; } = new Dictionary<long, IDCLEntity>();
 324120        public IECSComponentsManagerLegacy componentsManagerLegacy { get; private set; }
 305121        public LoadParcelScenesMessage.UnityParcelScene sceneData { get; protected set; }
 22
 57323        public HashSet<Vector2Int> parcels = new HashSet<Vector2Int>();
 4924        public ISceneMetricsCounter metricsCounter { get; set; }
 25        public event System.Action<IDCLEntity> OnEntityAdded;
 26        public event System.Action<IDCLEntity> OnEntityRemoved;
 27        public event System.Action<LoadParcelScenesMessage.UnityParcelScene> OnSetData;
 28        public event System.Action<float> OnLoadingStateUpdated;
 29
 15330        public ContentProvider contentProvider { get; set; }
 31
 032        public bool isTestScene { get; set; } = false;
 59033        public bool isPersistent { get; set; } = false;
 034        public float loadingProgress { get; private set; }
 35
 36        [System.NonSerialized]
 37        public string sceneName;
 38
 39        [System.NonSerialized]
 57340        public bool unloadWithDistance = true;
 41
 42        SceneDebugPlane sceneDebugPlane = null;
 43
 44        public SceneLifecycleHandler sceneLifecycleHandler;
 45
 046        public ICRDTExecutor crdtExecutor { get; set; }
 47
 048        public bool isReleased { get; private set; }
 49
 50        private Bounds outerBounds = new Bounds();
 51
 52        public void Awake()
 53        {
 57354            CommonScriptableObjects.worldOffset.OnChange += OnWorldReposition;
 57355            componentsManagerLegacy = new ECSComponentsManagerLegacy(this);
 57356            sceneLifecycleHandler = new SceneLifecycleHandler(this);
 57357            metricsCounter = new SceneMetricsCounter(DataStore.i.sceneWorldObjects);
 57358        }
 59
 60        private void OnDestroy()
 61        {
 57362            CommonScriptableObjects.worldOffset.OnChange -= OnWorldReposition;
 57363            metricsCounter?.Dispose();
 57364            crdtExecutor?.Dispose();
 065        }
 66
 115467        void OnDisable() { metricsCounter?.Disable(); }
 68
 69        private void Update()
 70        {
 1528871            if (sceneLifecycleHandler.state == SceneLifecycleHandler.State.READY
 72                && CommonScriptableObjects.rendererState.Get())
 1463873                SendMetricsEvent();
 1528874        }
 75
 110076        protected virtual string prettyName => sceneData.basePosition.ToString();
 77
 78        public virtual void SetData(LoadParcelScenesMessage.UnityParcelScene data)
 79        {
 56680            Assert.IsTrue( !string.IsNullOrEmpty(data.id), "Scene must have an ID!" );
 81
 56682            this.sceneData = data;
 83
 56684            contentProvider = new ContentProvider();
 56685            contentProvider.baseUrl = data.baseUrl;
 56686            contentProvider.contents = data.contents;
 56687            contentProvider.BakeHashes();
 88
 56689            SetupPositionAndParcels();
 90
 56691            DataStore.i.sceneWorldObjects.AddScene(sceneData.id);
 92
 56693            metricsCounter.Configure(sceneData.id, sceneData.basePosition, sceneData.parcels.Length);
 56694            metricsCounter.Enable();
 95
 56696            OnSetData?.Invoke(data);
 56697        }
 98
 99        void SetupPositionAndParcels()
 100        {
 566101            gameObject.transform.position = PositionUtils.WorldToUnityPosition(Utils.GridToWorldPosition(sceneData.baseP
 102
 566103            parcels.Clear();
 104
 105            // The scene's gameobject position should already be in 'unityposition'
 566106            Vector3 baseParcelWorldPos = gameObject.transform.position;
 107
 566108            outerBounds.SetMinMax(new Vector3(baseParcelWorldPos.x, 0f, baseParcelWorldPos.z),
 109                new Vector3(baseParcelWorldPos.x + ParcelSettings.PARCEL_SIZE, 0f, baseParcelWorldPos.z + ParcelSettings
 110
 2296111            for (int i = 0; i < sceneData.parcels.Length; i++)
 112            {
 113                // 1. Update outer bounds with parcel's size
 582114                var parcel = sceneData.parcels[i];
 115
 582116                Vector3 parcelWorldPos = PositionUtils.WorldToUnityPosition(Utils.GridToWorldPosition(parcel.x, parcel.y
 582117                outerBounds.Encapsulate(new Vector3(parcelWorldPos.x, 0, parcelWorldPos.z));
 582118                outerBounds.Encapsulate(new Vector3(parcelWorldPos.x + ParcelSettings.PARCEL_SIZE, 0, parcelWorldPos.z +
 119
 120                // 2. add parcel to collection
 582121                parcels.Add(parcel);
 122            }
 123
 124            // Apply outer bounds extra threshold
 566125            outerBounds.SetMinMax(new Vector3(outerBounds.min.x - ParcelSettings.PARCEL_BOUNDARIES_THRESHOLD, 0f, outerB
 126                new Vector3(outerBounds.max.x + ParcelSettings.PARCEL_BOUNDARIES_THRESHOLD, 0f, outerBounds.max.z + Parc
 566127        }
 128
 129        void OnWorldReposition(Vector3 current, Vector3 previous)
 130        {
 2131            Vector3 currentSceneWorldPos = Utils.GridToWorldPosition(sceneData.basePosition.x, sceneData.basePosition.y)
 2132            Vector3 oldSceneUnityPos = gameObject.transform.position;
 2133            Vector3 newSceneUnityPos = PositionUtils.WorldToUnityPosition(currentSceneWorldPos);
 134
 2135            gameObject.transform.position = newSceneUnityPos;
 2136            outerBounds.center += newSceneUnityPos - oldSceneUnityPos;
 2137        }
 138
 139        public virtual void SetUpdateData(LoadParcelScenesMessage.UnityParcelScene data)
 140        {
 15141            contentProvider = new ContentProvider();
 15142            contentProvider.baseUrl = data.baseUrl;
 15143            contentProvider.contents = data.contents;
 15144            contentProvider.BakeHashes();
 15145        }
 146
 147        public void InitializeDebugPlane()
 148        {
 410149            if (EnvironmentSettings.DEBUG && sceneData.parcels != null && sceneDebugPlane == null)
 150            {
 408151                sceneDebugPlane = new SceneDebugPlane(sceneData, gameObject.transform);
 152            }
 410153        }
 154
 155        public void RemoveDebugPlane()
 156        {
 0157            if (sceneDebugPlane != null)
 158            {
 0159                sceneDebugPlane.Dispose();
 0160                sceneDebugPlane = null;
 161            }
 0162        }
 163
 164        public void Cleanup(bool immediate)
 165        {
 465166            if (isReleased || gameObject == null)
 0167                return;
 168
 465169            if (sceneDebugPlane != null)
 170            {
 408171                sceneDebugPlane.Dispose();
 408172                sceneDebugPlane = null;
 173            }
 174
 465175            componentsManagerLegacy.DisposeAllSceneComponents();
 176
 465177            if (crdtExecutor != null)
 178            {
 0179                crdtExecutor.Dispose();
 0180                crdtExecutor = null;
 181            }
 182
 465183            if (immediate) //!CommonScriptableObjects.rendererState.Get())
 184            {
 427185                RemoveAllEntitiesImmediate();
 427186                PoolManager.i.Cleanup(true, true);
 427187                DataStore.i.sceneWorldObjects.RemoveScene(sceneData.id);
 427188            }
 189            else
 190            {
 38191                if (entities.Count > 0)
 192                {
 20193                    this.gameObject.transform.position = EnvironmentSettings.MORDOR;
 20194                    this.gameObject.SetActive(false);
 195
 20196                    RemoveAllEntities();
 20197                }
 198                else
 199                {
 18200                    Destroy(this.gameObject);
 18201                    DataStore.i.sceneWorldObjects.RemoveScene(sceneData.id);
 202
 203                }
 204            }
 205
 465206            isReleased = true;
 465207        }
 208
 0209        public override string ToString() { return "Parcel Scene: " + base.ToString() + "\n" + sceneData; }
 210
 211        public string GetSceneName()
 212        {
 0213            return string.IsNullOrEmpty(sceneName) ? "Unnamed" : sceneName;
 214        }
 215
 216        public bool IsInsideSceneBoundaries(Bounds objectBounds)
 217        {
 110218            if (!IsInsideSceneBoundaries(objectBounds.min + CommonScriptableObjects.worldOffset, objectBounds.max.y))
 78219                return false;
 32220            if (!IsInsideSceneBoundaries(objectBounds.max + CommonScriptableObjects.worldOffset, objectBounds.max.y))
 1221                return false;
 222
 31223            return true;
 224        }
 225
 226        public virtual bool IsInsideSceneBoundaries(Vector2Int gridPosition, float height = 0f)
 227        {
 153228            if (parcels.Count == 0)
 0229                return false;
 230
 153231            float heightLimit = metricsCounter.maxCount.sceneHeight;
 232
 153233            if (height > heightLimit)
 0234                return false;
 235
 153236            return parcels.Contains(gridPosition);
 237        }
 238
 239        public virtual bool IsInsideSceneBoundaries(Vector3 worldPosition, float height = 0f)
 240        {
 189241            if (parcels.Count == 0)
 0242                return false;
 243
 189244            float heightLimit = metricsCounter.maxCount.sceneHeight;
 189245            if (height > heightLimit)
 14246                return false;
 247
 175248            int noThresholdZCoordinate = Mathf.FloorToInt(worldPosition.z / ParcelSettings.PARCEL_SIZE);
 175249            int noThresholdXCoordinate = Mathf.FloorToInt(worldPosition.x / ParcelSettings.PARCEL_SIZE);
 250
 251            // We check the target world position
 175252            Vector2Int targetCoordinate = new Vector2Int(noThresholdXCoordinate, noThresholdZCoordinate);
 175253            if (parcels.Contains(targetCoordinate))
 93254                return true;
 255
 256            // We need to check using a threshold from the target point, in order to cover correctly the parcel "border/
 82257            Vector2Int coordinateMin = new Vector2Int();
 82258            coordinateMin.x = Mathf.FloorToInt((worldPosition.x - ParcelSettings.PARCEL_BOUNDARIES_THRESHOLD) / ParcelSe
 82259            coordinateMin.y = Mathf.FloorToInt((worldPosition.z - ParcelSettings.PARCEL_BOUNDARIES_THRESHOLD) / ParcelSe
 260
 82261            Vector2Int coordinateMax = new Vector2Int();
 82262            coordinateMax.x = Mathf.FloorToInt((worldPosition.x + ParcelSettings.PARCEL_BOUNDARIES_THRESHOLD) / ParcelSe
 82263            coordinateMax.y = Mathf.FloorToInt((worldPosition.z + ParcelSettings.PARCEL_BOUNDARIES_THRESHOLD) / ParcelSe
 264
 265            // We check the east/north-threshold position
 82266            targetCoordinate.Set(coordinateMax.x, coordinateMax.y);
 82267            if (parcels.Contains(targetCoordinate))
 0268                return true;
 269
 270            // We check the east/south-threshold position
 82271            targetCoordinate.Set(coordinateMax.x, coordinateMin.y);
 82272            if (parcels.Contains(targetCoordinate))
 0273                return true;
 274
 275            // We check the west/north-threshold position
 82276            targetCoordinate.Set(coordinateMin.x, coordinateMax.y);
 82277            if (parcels.Contains(targetCoordinate))
 0278                return true;
 279
 280            // We check the west/south-threshold position
 82281            targetCoordinate.Set(coordinateMin.x, coordinateMin.y);
 82282            if (parcels.Contains(targetCoordinate))
 0283                return true;
 284
 82285            return false;
 286        }
 287
 288        public bool IsInsideSceneOuterBoundaries(Bounds objectBounds)
 289        {
 313290            Vector3 objectBoundsMin = new Vector3(objectBounds.min.x, 0f, objectBounds.min.z);
 313291            Vector3 objectBoundsMax = new Vector3(objectBounds.max.x, 0f, objectBounds.max.z);
 313292            bool isInsideOuterBoundaries = outerBounds.Contains(objectBoundsMin) && outerBounds.Contains(objectBoundsMax
 293
 172294            return isInsideOuterBoundaries;
 295        }
 296
 297        public bool IsInsideSceneOuterBoundaries(Vector3 objectUnityPosition)
 298        {
 640299            objectUnityPosition.y = 0f;
 640300            return outerBounds.Contains(objectUnityPosition);
 301        }
 302
 303        private void OnDrawGizmosSelected()
 304        {
 0305            if(!renderOuterBoundsGizmo) return;
 306
 0307            Gizmos.color = new Color(Color.yellow.r, Color.yellow.g, Color.yellow.b, 0.5f);
 0308            Gizmos.DrawCube(outerBounds.center, outerBounds.size + Vector3.up);
 0309        }
 310
 0311        public IDCLEntity GetEntityById(string entityId) { throw new System.NotImplementedException(); }
 58312        public Transform GetSceneTransform() { return transform; }
 313
 314        public IDCLEntity CreateEntity(long id)
 315        {
 604316            if (entities.ContainsKey(id))
 317            {
 2318                return entities[id];
 319            }
 320
 602321            var newEntity = new DecentralandEntity();
 602322            newEntity.entityId = id;
 323
 602324            PoolManagerFactory.EnsureEntityPool(false);
 325
 326            // As we know that the pool already exists, we just get one gameobject from it
 602327            PoolableObject po = PoolManager.i.Get(PoolManagerFactory.EMPTY_GO_POOL_NAME);
 328
 602329            newEntity.meshesInfo.innerGameObject = po.gameObject;
 602330            newEntity.gameObject = po.gameObject;
 331
 332#if UNITY_EDITOR
 602333            newEntity.gameObject.name = "ENTITY_" + id;
 334#endif
 602335            newEntity.gameObject.transform.SetParent(gameObject.transform, false);
 602336            newEntity.gameObject.SetActive(true);
 602337            newEntity.scene = this;
 338
 602339            newEntity.OnCleanupEvent += po.OnCleanup;
 340
 602341            if (Environment.i.world.sceneBoundsChecker.enabled)
 449342                newEntity.OnShapeUpdated += OnEntityShapeUpdated;
 343
 602344            entities.Add(id, newEntity);
 345
 602346            DataStore.i.sceneWorldObjects.sceneData[sceneData.id].owners.Add(id);
 347
 602348            OnEntityAdded?.Invoke(newEntity);
 349
 602350            Environment.i.world.sceneBoundsChecker.AddEntityToBeChecked(newEntity, runPreliminaryEvaluation: true);
 351
 602352            return newEntity;
 353        }
 354
 355        void OnEntityShapeUpdated(IDCLEntity entity)
 356        {
 222357            Environment.i.world.sceneBoundsChecker.AddEntityToBeChecked(entity, runPreliminaryEvaluation: true);
 222358        }
 359
 360        public void RemoveEntity(long id, bool removeImmediatelyFromEntitiesList = true)
 361        {
 522362            if (entities.ContainsKey(id))
 363            {
 522364                IDCLEntity entity = entities[id];
 365
 522366                if (!entity.markedForCleanup)
 367                {
 368                    // This will also cleanup its children
 522369                    CleanUpEntityRecursively(entity, removeImmediatelyFromEntitiesList);
 370                }
 371
 522372                entities.Remove(id);
 373
 522374                var data = DataStore.i.sceneWorldObjects.sceneData;
 375
 522376                if (data.ContainsKey(sceneData.id))
 377                {
 68378                    data[sceneData.id].owners.Remove(id);
 379                }
 68380            }
 381#if UNITY_EDITOR || DEVELOPMENT_BUILD
 382            else
 383            {
 0384                Debug.LogWarning($"Couldn't remove entity with ID: {id} as it doesn't exist.");
 385            }
 386#endif
 454387        }
 388
 389        void CleanUpEntityRecursively(IDCLEntity entity, bool removeImmediatelyFromEntitiesList)
 390        {
 531391            using (var iterator = entity.children.GetEnumerator())
 392            {
 540393                while (iterator.MoveNext())
 394                {
 9395                    CleanUpEntityRecursively(iterator.Current.Value, removeImmediatelyFromEntitiesList);
 396                }
 531397            }
 398
 531399            OnEntityRemoved?.Invoke(entity);
 400
 531401            if (Environment.i.world.sceneBoundsChecker.enabled)
 402            {
 446403                entity.OnShapeUpdated -= OnEntityShapeUpdated;
 446404                Environment.i.world.sceneBoundsChecker.RemoveEntity(entity, removeIfPersistent: true, resetState: true);
 405            }
 406
 531407            if (removeImmediatelyFromEntitiesList)
 408            {
 409                // Every entity ends up being removed through here
 530410                entity.Cleanup();
 530411                entities.Remove(entity.entityId);
 530412            }
 413            else
 414            {
 1415                Environment.i.platform.parcelScenesCleaner.MarkForCleanup(entity);
 416            }
 1417        }
 418
 419        void RemoveAllEntities(bool instant = false)
 420        {
 421            //NOTE(Brian): We need to remove only the rootEntities.
 422            //             If we don't, duplicated entities will get removed when destroying
 423            //             recursively, making this more complicated than it should.
 447424            List<IDCLEntity> rootEntities = new List<IDCLEntity>();
 425
 447426            using (var iterator = entities.GetEnumerator())
 427            {
 965428                while (iterator.MoveNext())
 429                {
 518430                    if (iterator.Current.Value.parent == null)
 431                    {
 510432                        if (instant)
 490433                            rootEntities.Add(iterator.Current.Value);
 434                        else
 20435                            Environment.i.platform.parcelScenesCleaner.MarkRootEntityForCleanup(this, iterator.Current.V
 436                    }
 437                }
 447438            }
 439
 447440            if (instant)
 441            {
 427442                int rootEntitiesCount = rootEntities.Count;
 1834443                for (int i = 0; i < rootEntitiesCount; i++)
 444                {
 490445                    IDCLEntity entity = rootEntities[i];
 490446                    RemoveEntity(entity.entityId, instant);
 447                }
 448
 427449                entities.Clear();
 450
 451                // TODO: Does it make sense that 'RemoveAllEntities()' destroys the whole scene GameObject?
 427452                if (gameObject != null)
 427453                    Destroy(gameObject);
 454            }
 447455        }
 456
 854457        private void RemoveAllEntitiesImmediate() { RemoveAllEntities(instant: true); }
 458
 459        public void SetEntityParent(long entityId, long parentId)
 460        {
 17461            if (entityId == parentId)
 462            {
 0463                return;
 464            }
 465
 17466            IDCLEntity me = GetEntityById(entityId);
 467
 17468            if (me == null)
 0469                return;
 470
 17471            Environment.i.platform.cullingController.MarkDirty();
 17472            Environment.i.platform.physicsSyncController.MarkDirty();
 473
 17474            DataStore_World worldData = DataStore.i.Get<DataStore_World>();
 17475            Transform avatarTransform = worldData.avatarTransform.Get();
 17476            Transform firstPersonCameraTransform = worldData.fpsTransform.Get();
 477
 478            // CONST_THIRD_PERSON_CAMERA_ENTITY_REFERENCE is for compatibility purposes
 17479            if (parentId == (long) SpecialEntityId.FIRST_PERSON_CAMERA_ENTITY_REFERENCE ||
 480                parentId == (long) SpecialEntityId.THIRD_PERSON_CAMERA_ENTITY_REFERENCE)
 481            {
 1482                if (firstPersonCameraTransform == null)
 483                {
 0484                    Debug.LogError("FPS transform is null when trying to set parent! " + sceneData.id);
 0485                    return;
 486                }
 487
 488                // In this case, the entity will attached to the first person camera
 489                // On first person mode, the entity will rotate with the camera. On third person mode, the entity will r
 1490                me.SetParent(null);
 1491                me.gameObject.transform.SetParent(firstPersonCameraTransform, false);
 1492                Environment.i.world.sceneBoundsChecker.RemoveEntity(me, removeIfPersistent: true, resetState: true);
 1493                Environment.i.world.sceneBoundsChecker.AddEntityToBeChecked(me, isPersistent: true, runPreliminaryEvalua
 1494                return;
 495            }
 496
 16497            if (parentId == (long) SpecialEntityId.AVATAR_ENTITY_REFERENCE ||
 498                parentId == (long) SpecialEntityId
 499                    .AVATAR_POSITION_REFERENCE) // AvatarPositionEntityReference is for compatibility purposes
 500            {
 1501                if (avatarTransform == null)
 502                {
 0503                    Debug.LogError("Avatar transform is null when trying to set parent! " + sceneData.id);
 0504                    return;
 505                }
 506
 507                // In this case, the entity will be attached to the avatar
 508                // It will simply rotate with the avatar, regardless of where the camera is pointing
 1509                me.SetParent(null);
 1510                me.gameObject.transform.SetParent(avatarTransform, false);
 1511                Environment.i.world.sceneBoundsChecker.RemoveEntity(me, removeIfPersistent: true, resetState: true);
 1512                Environment.i.world.sceneBoundsChecker.AddEntityToBeChecked(me, isPersistent: true, runPreliminaryEvalua
 1513                return;
 514            }
 515
 516            // Remove from persistent checks if it was formerly added as child of avatarTransform or fpsTransform
 15517            if (me.gameObject.transform.parent == avatarTransform ||
 518                me.gameObject.transform.parent == firstPersonCameraTransform)
 519            {
 2520                if (Environment.i.world.sceneBoundsChecker.WasAddedAsPersistent(me))
 2521                    Environment.i.world.sceneBoundsChecker.RemoveEntity(me, removeIfPersistent: true);
 522            }
 523
 15524            if (parentId == (long) SpecialEntityId.SCENE_ROOT_ENTITY)
 525            {
 526                // The entity will be child of the scene directly
 2527                me.SetParent(null);
 2528                me.gameObject.transform.SetParent(gameObject.transform, false);
 2529            }
 530            else
 531            {
 13532                IDCLEntity myParent = GetEntityById(parentId);
 533
 13534                if (myParent != null)
 535                {
 13536                    me.SetParent(myParent);
 537                }
 538            }
 539
 540            // After reparenting the Entity may end up outside the scene boundaries
 15541            Environment.i.world.sceneBoundsChecker?.AddEntityToBeChecked(me, runPreliminaryEvaluation: true);
 15542        }
 543
 544        protected virtual void SendMetricsEvent()
 545        {
 14638546            if (Time.frameCount % 10 == 0)
 1428547                metricsCounter.SendEvent();
 14638548        }
 549
 550        public IDCLEntity GetEntityById(long entityId)
 551        {
 951552            if (!entities.TryGetValue(entityId, out IDCLEntity entity))
 553            {
 2554                return null;
 555            }
 556
 557            //NOTE(Brian): This is for removing stray null references? This should never happen.
 558            //             Maybe move to a different 'clean-up' method to make this method have a single responsibility?
 949559            if (entity == null || entity.gameObject == null)
 560            {
 0561                entities.Remove(entityId);
 0562                return null;
 563            }
 564
 949565            return entity;
 566        }
 567
 568        public string GetStateString()
 569        {
 1100570            string baseState = isPersistent ? "global-scene" : "scene";
 1100571            switch (sceneLifecycleHandler.state)
 572            {
 573                case SceneLifecycleHandler.State.NOT_READY:
 0574                    return $"{baseState}:{prettyName} - not ready...";
 575                case SceneLifecycleHandler.State.WAITING_FOR_INIT_MESSAGES:
 566576                    return $"{baseState}:{prettyName} - waiting for init messages...";
 577                case SceneLifecycleHandler.State.WAITING_FOR_COMPONENTS:
 0578                    return $"{baseState}:{prettyName} - {sceneLifecycleHandler.sceneResourcesLoadTracker.GetStateString(
 579                case SceneLifecycleHandler.State.READY:
 534580                    return $"{baseState}:{prettyName} - ready!";
 581            }
 582
 0583            return $"scene:{prettyName} - no state?";
 584        }
 585
 586        public void RefreshLoadingState()
 587        {
 588#if UNITY_STANDALONE || UNITY_EDITOR
 1100589            if (DataStore.i.common.isApplicationQuitting.Get())
 0590                return;
 591#endif
 592
 1100593            CalculateSceneLoadingState();
 594
 595#if UNITY_EDITOR
 1100596            gameObject.name = GetStateString();
 597#endif
 1100598        }
 599
 600        [ContextMenu("Get Waiting Components Debug Info")]
 601        public void GetWaitingComponentsDebugInfo()
 602        {
 0603            switch (sceneLifecycleHandler.state)
 604            {
 605                case SceneLifecycleHandler.State.WAITING_FOR_COMPONENTS:
 0606                    sceneLifecycleHandler.sceneResourcesLoadTracker.PrintWaitingResourcesDebugInfo();
 0607                    break;
 608
 609                default:
 0610                    Debug.Log($"The scene {sceneData.id} is not waiting for any components. Its current state is " + sce
 611                    break;
 612            }
 0613        }
 614
 615        /// <summary>
 616        /// Calculates the current loading progress of the scene and raise the event OnLoadingStateUpdated with the perc
 617        /// </summary>
 618        public void CalculateSceneLoadingState()
 619        {
 1100620            loadingProgress = 0f;
 621
 1100622            if (sceneLifecycleHandler.state == SceneLifecycleHandler.State.WAITING_FOR_COMPONENTS ||
 623                sceneLifecycleHandler.state == SceneLifecycleHandler.State.READY)
 624            {
 534625                loadingProgress = sceneLifecycleHandler.loadingProgress;
 626            }
 627
 1100628            OnLoadingStateUpdated?.Invoke(loadingProgress);
 0629        }
 630    }
 631}
Generated by: ReportGenerator 4.8.9.0
08/26/2022 - 09:02:05
GitHub | www.palmmedia.de

Methods/Properties

ParcelScene()
entities()
entities(System.Collections.Generic.Dictionary[Int64,IDCLEntity])
componentsManagerLegacy()
componentsManagerLegacy(DCL.IECSComponentsManagerLegacy)
sceneData()
sceneData(DCL.Models.LoadParcelScenesMessage/UnityParcelScene)
metricsCounter()
metricsCounter(DCL.ISceneMetricsCounter)
contentProvider()
contentProvider(DCL.ContentProvider)
isTestScene()
isTestScene(System.Boolean)
isPersistent()
isPersistent(System.Boolean)
loadingProgress()
loadingProgress(System.Single)
crdtExecutor()
crdtExecutor(DCL.CRDT.ICRDTExecutor)
isReleased()
isReleased(System.Boolean)
Awake()
OnDestroy()
OnDisable()
Update()
prettyName()
SetData(DCL.Models.LoadParcelScenesMessage/UnityParcelScene)
SetupPositionAndParcels()
OnWorldReposition(UnityEngine.Vector3, UnityEngine.Vector3)
SetUpdateData(DCL.Models.LoadParcelScenesMessage/UnityParcelScene)
InitializeDebugPlane()
RemoveDebugPlane()
Cleanup(System.Boolean)
ToString()
GetSceneName()
IsInsideSceneBoundaries(UnityEngine.Bounds)
IsInsideSceneBoundaries(UnityEngine.Vector2Int, System.Single)
IsInsideSceneBoundaries(UnityEngine.Vector3, System.Single)
IsInsideSceneOuterBoundaries(UnityEngine.Bounds)
IsInsideSceneOuterBoundaries(UnityEngine.Vector3)
OnDrawGizmosSelected()
GetEntityById(System.String)
GetSceneTransform()
CreateEntity(System.Int64)
OnEntityShapeUpdated(DCL.Models.IDCLEntity)
RemoveEntity(System.Int64, System.Boolean)
CleanUpEntityRecursively(DCL.Models.IDCLEntity, System.Boolean)
RemoveAllEntities(System.Boolean)
RemoveAllEntitiesImmediate()
SetEntityParent(System.Int64, System.Int64)
SendMetricsEvent()
GetEntityById(System.Int64)
GetStateString()
RefreshLoadingState()
GetWaitingComponentsDebugInfo()
CalculateSceneLoadingState()