< Summary

Class:DCL.Rendering.CullingObjectsTracker
Assembly:CullingController
File(s):/tmp/workspace/unity-renderer/unity-renderer/Assets/Rendering/Culling/CullingObjectsTracker.cs
Covered lines:74
Uncovered lines:6
Coverable lines:80
Total lines:169
Line coverage:92.5% (74 of 80)
Covered branches:0
Total branches:0

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity NPath complexity Sequence coverage
CullingObjectsTracker()0%110100%
SetIgnoredLayersMask(...)0%110100%
ForcePopulateRenderersList()0%110100%
PopulateRenderersList()0%990100%
Dispose()0%110100%
MarkDirty()0%110100%
IsDirty()0%110100%
GetRenderers()0%110100%
GetSkinnedRenderers()0%110100%
GetAnimations()0%110100%
ForceCalculateRenderers()0%880100%
ForceCalculateSkinnedRenderers()0%5.264057.14%
ShouldNotBeIgnored(...)0%110100%
CalculateRenderers()0%12.0912091.3%
CalculateSkinnedRenderers()0%7.127086.67%

File(s)

/tmp/workspace/unity-renderer/unity-renderer/Assets/Rendering/Culling/CullingObjectsTracker.cs

#LineLine coverage
 1using System.Collections;
 2using System.Collections.Generic;
 3using UnityEngine;
 4using UnityEngine.Pool;
 5using static DCL.DataStore_WorldObjects;
 6
 7namespace DCL.Rendering
 8{
 9    /// <summary> This class is used for tracking all the renderers, skinnedMeshRenderers and Animations of the world. <
 10    public class CullingObjectsTracker : ICullingObjectsTracker
 11    {
 11412        private List<Renderer> usingRenderers = new List<Renderer>();
 13        private SkinnedMeshRenderer[] detectedSkinnedRenderers;
 11414        private List<SkinnedMeshRenderer> usingSkinnedRenderers = new List<SkinnedMeshRenderer>();
 15        private Animation[] usingAnimations;
 16
 17        private int ignoredLayersMask;
 11418        private bool dirty = true;
 19
 20
 11421        public CullingObjectsTracker()
 22        {
 11423            PoolManager.i.OnGet += MarkDirty;
 11424        }
 25
 26        /// <summary> Sets a layer mask to be ignored, only one layer mask can be ingored at a given time. </summary>
 26027        public void SetIgnoredLayersMask(int ignoredLayersMask) { this.ignoredLayersMask = ignoredLayersMask; }
 28
 29        /// <summary> This will re-populate all the tracked objects synchronously </summary>
 30        public void ForcePopulateRenderersList()
 31        {
 11532            detectedSkinnedRenderers = Object.FindObjectsOfType<SkinnedMeshRenderer>();
 33
 11534            ForceCalculateRenderers();
 11535            ForceCalculateSkinnedRenderers();
 11536            usingAnimations = Object.FindObjectsOfType<Animation>();
 37
 11538            dirty = false;
 11539        }
 40
 41        /// <summary> If the dirty flag is true, this coroutine will re-populate all the tracked objects. </summary>
 42        public IEnumerator PopulateRenderersList()
 43        {
 1744            if (!dirty)
 345                yield break;
 46
 1447            detectedSkinnedRenderers = Object.FindObjectsOfType<SkinnedMeshRenderer>();
 48
 1449            yield return null;
 1150            yield return CalculateRenderers();
 1051            yield return null;
 952            yield return CalculateSkinnedRenderers();
 753            yield return null;
 754            usingAnimations = Object.FindObjectsOfType<Animation>();
 755            yield return null;
 56
 757            dirty = false;
 758        }
 59
 60        public void Dispose()
 61        {
 11262            dirty = true;
 11263            usingRenderers = null;
 11264            usingSkinnedRenderers = null;
 11265            detectedSkinnedRenderers = null;
 11266            usingAnimations = null;
 11267            PoolManager.i.OnGet -= MarkDirty;
 11268        }
 69
 70        /// <summary> Sets the dirty flag to true to make PopulateRenderersList retrieve all the scene objects on its ne
 87971        public void MarkDirty() => dirty = true;
 72
 73        /// <summary> Returns true if dirty. </summary>
 274        public bool IsDirty() => dirty;
 75
 76        /// <summary> Returns the renderers list. </summary>
 12377        public IReadOnlyList<Renderer> GetRenderers() => usingRenderers;
 78
 79        /// <summary> Returns the skinned renderers list. </summary>
 12280        public IReadOnlyList<SkinnedMeshRenderer> GetSkinnedRenderers() => usingSkinnedRenderers;
 81
 82        /// <summary> Returns the animations list. </summary>
 11783        public Animation[] GetAnimations() => usingAnimations;
 84
 85
 86        private void ForceCalculateRenderers()
 87        {
 11588            usingRenderers = new List<Renderer>();
 25089            foreach (KeyValuePair<int, SceneData> entry in DataStore.i.sceneWorldObjects.sceneData)
 90            {
 3691                foreach (Renderer renderer in entry.Value.renderers.Get())
 92                {
 893                    if (renderer == null || !renderer.gameObject.activeInHierarchy)
 94                        continue;
 95
 896                    if (ShouldNotBeIgnored(renderer))
 897                        usingRenderers.Add(renderer);
 98                }
 99            }
 115100        }
 101
 102        private void ForceCalculateSkinnedRenderers()
 103        {
 115104            usingSkinnedRenderers = new List<SkinnedMeshRenderer>(detectedSkinnedRenderers);
 230105            foreach (SkinnedMeshRenderer skinnedRenderer in detectedSkinnedRenderers)
 106            {
 0107                if (skinnedRenderer != null && ShouldNotBeIgnored(skinnedRenderer))
 0108                    usingSkinnedRenderers.Add(skinnedRenderer);
 109            }
 115110        }
 111
 21112        private bool ShouldNotBeIgnored(Renderer renderer) => ((1 << renderer.gameObject.layer) & ignoredLayersMask) == 
 113
 114
 115        private IEnumerator CalculateRenderers()
 116        {
 11117            float currentStartTime = Time.realtimeSinceStartup;
 11118            usingRenderers.Clear();
 36119            foreach (SceneData sceneData in DataStore.i.sceneWorldObjects.sceneData.GetValues())
 120            {
 7121                if (sceneData == null)
 122                    continue;
 123
 7124                using (PooledObject<List<Renderer>> pooledObject = ListPool<Renderer>.Get(out List<Renderer> tempList))
 125                {
 26126                    foreach (Renderer renderer in sceneData.renderers.Get())
 6127                        tempList.Add(renderer);
 128
 26129                    foreach (Renderer renderer in tempList)
 130                    {
 6131                        if (renderer == null || !renderer.gameObject.activeInHierarchy)
 132                            continue;
 133
 6134                        if (Time.realtimeSinceStartup - currentStartTime >= CullingControllerSettings.MAX_TIME_BUDGET)
 135                        {
 0136                            yield return null;
 0137                            currentStartTime = Time.realtimeSinceStartup;
 138                        }
 139
 6140                        if (ShouldNotBeIgnored(renderer))
 5141                            usingRenderers.Add(renderer);
 6142                    }
 7143                }
 144            }
 11145        }
 146
 147        private IEnumerator CalculateSkinnedRenderers()
 148        {
 9149            float currentStartTime = Time.realtimeSinceStartup;
 9150            List<SkinnedMeshRenderer> checkingSkinnedRenderers = new List<SkinnedMeshRenderer>(detectedSkinnedRenderers)
 9151            usingSkinnedRenderers = new List<SkinnedMeshRenderer>();
 32152            for (int i = checkingSkinnedRenderers.Count - 1; i >= 0; i--)
 153            {
 7154                SkinnedMeshRenderer skinnedRenderer = checkingSkinnedRenderers[i];
 7155                if (skinnedRenderer == null)
 156                    continue;
 157
 7158                if (Time.realtimeSinceStartup - currentStartTime >= CullingControllerSettings.MAX_TIME_BUDGET)
 159                {
 0160                    yield return null;
 0161                    currentStartTime = Time.realtimeSinceStartup;
 162                }
 163
 7164                if (ShouldNotBeIgnored(skinnedRenderer))
 6165                    usingSkinnedRenderers.Add(skinnedRenderer);
 7166            }
 9167        }
 168    }
 169}
Generated by: ReportGenerator 4.8.9.0
02/03/2023 - 18:34:58
GitHub | www.palmmedia.de

Methods/Properties

CullingObjectsTracker()
SetIgnoredLayersMask(System.Int32)
ForcePopulateRenderersList()
PopulateRenderersList()
Dispose()
MarkDirty()
IsDirty()
GetRenderers()
GetSkinnedRenderers()
GetAnimations()
ForceCalculateRenderers()
ForceCalculateSkinnedRenderers()
ShouldNotBeIgnored(UnityEngine.Renderer)
CalculateRenderers()
CalculateSkinnedRenderers()