< Summary

Class:DCL.Rendering.CullingObjectsTracker
Assembly:CullingController
File(s):/tmp/workspace/unity-renderer/unity-renderer/Assets/Rendering/Culling/CullingObjectsTracker.cs
Covered lines:76
Uncovered lines:4
Coverable lines:80
Total lines:169
Line coverage:95% (76 of 80)
Covered branches:0
Total branches:0
Covered methods:15
Total methods:15
Method coverage:100% (15 of 15)

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%440100%
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    {
 12712        private List<Renderer> usingRenderers = new List<Renderer>();
 13        private SkinnedMeshRenderer[] detectedSkinnedRenderers;
 12714        private List<SkinnedMeshRenderer> usingSkinnedRenderers = new List<SkinnedMeshRenderer>();
 15        private Animation[] usingAnimations;
 16
 17        private int ignoredLayersMask;
 12718        private bool dirty = true;
 19
 20
 12721        public CullingObjectsTracker()
 22        {
 12723            PoolManager.i.OnGet += MarkDirty;
 12724        }
 25
 26        /// <summary> Sets a layer mask to be ignored, only one layer mask can be ingored at a given time. </summary>
 28627        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        {
 12832            detectedSkinnedRenderers = Object.FindObjectsOfType<SkinnedMeshRenderer>();
 33
 12834            ForceCalculateRenderers();
 12835            ForceCalculateSkinnedRenderers();
 12836            usingAnimations = Object.FindObjectsOfType<Animation>();
 37
 12838            dirty = false;
 12839        }
 40
 41        /// <summary> If the dirty flag is true, this coroutine will re-populate all the tracked objects. </summary>
 42        public IEnumerator PopulateRenderersList()
 43        {
 1444            if (!dirty)
 145                yield break;
 46
 1347            detectedSkinnedRenderers = Object.FindObjectsOfType<SkinnedMeshRenderer>();
 48
 1349            yield return null;
 1050            yield return CalculateRenderers();
 951            yield return null;
 852            yield return CalculateSkinnedRenderers();
 653            yield return null;
 654            usingAnimations = Object.FindObjectsOfType<Animation>();
 655            yield return null;
 56
 657            dirty = false;
 658        }
 59
 60        public void Dispose()
 61        {
 12562            dirty = true;
 12563            usingRenderers = null;
 12564            usingSkinnedRenderers = null;
 12565            detectedSkinnedRenderers = null;
 12566            usingAnimations = null;
 12567            PoolManager.i.OnGet -= MarkDirty;
 12568        }
 69
 70        /// <summary> Sets the dirty flag to true to make PopulateRenderersList retrieve all the scene objects on its ne
 90571        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>
 13377        public IReadOnlyList<Renderer> GetRenderers() => usingRenderers;
 78
 79        /// <summary> Returns the skinned renderers list. </summary>
 13280        public IReadOnlyList<SkinnedMeshRenderer> GetSkinnedRenderers() => usingSkinnedRenderers;
 81
 82        /// <summary> Returns the animations list. </summary>
 13083        public Animation[] GetAnimations() => usingAnimations;
 84
 85
 86        private void ForceCalculateRenderers()
 87        {
 12888            usingRenderers = new List<Renderer>();
 27689            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            }
 128100        }
 101
 102        private void ForceCalculateSkinnedRenderers()
 103        {
 128104            usingSkinnedRenderers = new List<SkinnedMeshRenderer>(detectedSkinnedRenderers);
 392105            foreach (SkinnedMeshRenderer skinnedRenderer in detectedSkinnedRenderers)
 106            {
 68107                if (skinnedRenderer != null && ShouldNotBeIgnored(skinnedRenderer))
 68108                    usingSkinnedRenderers.Add(skinnedRenderer);
 109            }
 128110        }
 111
 89112        private bool ShouldNotBeIgnored(Renderer renderer) => ((1 << renderer.gameObject.layer) & ignoredLayersMask) == 
 113
 114
 115        private IEnumerator CalculateRenderers()
 116        {
 10117            float currentStartTime = Time.realtimeSinceStartup;
 10118            usingRenderers.Clear();
 34119            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            }
 10145        }
 146
 147        private IEnumerator CalculateSkinnedRenderers()
 148        {
 8149            float currentStartTime = Time.realtimeSinceStartup;
 8150            List<SkinnedMeshRenderer> checkingSkinnedRenderers = new List<SkinnedMeshRenderer>(detectedSkinnedRenderers)
 8151            usingSkinnedRenderers = new List<SkinnedMeshRenderer>();
 30152            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            }
 8167        }
 168    }
 169}
Generated by: ReportGenerator 5.0.4.0
01/24/2025 - 17:50:20
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()