< Summary

Class:DCL.Rendering.CullingObjectsTracker
Assembly:CullingController
File(s):/tmp/workspace/unity-renderer/unity-renderer/Assets/Rendering/Culling/CullingObjectsTracker.cs
Covered lines:49
Uncovered lines:3
Coverable lines:52
Total lines:144
Line coverage:94.2% (49 of 52)
Covered branches:0
Total branches:0

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity NPath complexity Sequence coverage
CullingObjectsTracker()0%110100%
PopulateRenderersList()0%12.0712092.31%
ForcePopulateRenderersList(...)0%5.015092.31%
SetIgnoredLayersMask(...)0%110100%
MarkDirty()0%110100%
IsDirty()0%110100%
GetRenderers()0%110100%
GetSkinnedRenderers()0%110100%
GetAnimations()0%110100%
Dispose()0%110100%

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 Object = UnityEngine.Object;
 5
 6namespace DCL.Rendering
 7{
 8    /// <summary>
 9    /// This class is used for tracking all the renderers, skinnedMeshRenderers and Animations of the world.
 10    ///
 11    /// It currently uses a very lazy FindObjectsOfType approach, but is enough for its purposes as its used
 12    /// to optimize a bigger bottleneck.
 13    /// </summary>
 14    public class CullingObjectsTracker : ICullingObjectsTracker
 15    {
 16        private ICollection<Renderer> renderers;
 17        private ICollection<SkinnedMeshRenderer> skinnedRenderers;
 18        private Animation[] animations;
 19
 20        private int ignoredLayersMask;
 11021        private bool dirty = true;
 22
 23
 11024        public CullingObjectsTracker()
 25        {
 11026            PoolManager.i.OnGet -= MarkDirty;
 11027            PoolManager.i.OnGet += MarkDirty;
 11028        }
 29
 30        /// <summary>
 31        /// If the dirty flag is true, this coroutine will re-populate all the tracked objects.
 32        /// </summary>
 33        public IEnumerator PopulateRenderersList()
 34        {
 1735            if (!dirty)
 136                yield break;
 37
 1638            List<Renderer> renderersList = new List<Renderer>();
 1639            List<SkinnedMeshRenderer> skinnedRenderersList = new List<SkinnedMeshRenderer>();
 1640            Renderer[] allRenderers = Object.FindObjectsOfType<Renderer>();
 41
 42            // TODO new task, avoid FindGameObjectsOfType and use:
 43            // SceneManager.GetActiveScene().GetRootGameObjects(), calculate from there.
 44
 1645            yield return null;
 46
 1247            int amount = 0;
 9048            foreach (Renderer renderer in allRenderers)
 49            {
 3350                if (renderer == null)
 51                    continue;
 52
 3353                if (amount >= CullingControllerSettings.MAX_POPULATING_ELEMENTS_PER_FRAME)
 54                {
 055                    yield return null;
 056                    amount = 0;
 57                }
 3358                amount++;
 59
 3360                if ((((1 << renderer.gameObject.layer) & ignoredLayersMask) == 0)
 61                    && !(renderer is ParticleSystemRenderer))
 62                {
 3163                    if (renderer is SkinnedMeshRenderer)
 664                        skinnedRenderersList.Add((SkinnedMeshRenderer)renderer);
 65                    else
 2566                        renderersList.Add(renderer);
 67                }
 3368            }
 1269            renderers = renderersList;
 1270            skinnedRenderers = skinnedRenderersList;
 71
 1272            yield return null;
 73
 1174            animations = Object.FindObjectsOfType<Animation>();
 75
 1176            dirty = false;
 1177        }
 78
 79        /// <summary>
 80        ///  This will re-populate all the tracked objects in a sync way.
 81        /// </summary>
 82        /// <param name="includeInactives">True for add inactive objects to the tracked list.</param>
 83        public void ForcePopulateRenderersList(bool includeInactives)
 84        {
 10485            List<Renderer> renderersList = new List<Renderer>();
 10486            List<SkinnedMeshRenderer> skinnedRenderersList = new List<SkinnedMeshRenderer>();
 10487            Renderer[] allRenderers = Object.FindObjectsOfType<Renderer>(includeInactives);
 88
 116289            foreach (Renderer renderer in allRenderers)
 90            {
 47791                if ((((1 << renderer.gameObject.layer) & ignoredLayersMask) == 0)
 92                    && !(renderer is ParticleSystemRenderer))
 93                {
 41394                    if (renderer is SkinnedMeshRenderer)
 095                        skinnedRenderersList.Add((SkinnedMeshRenderer)renderer);
 96                    else
 41397                        renderersList.Add(renderer);
 98                }
 99            }
 104100            renderers = renderersList;
 104101            skinnedRenderers = skinnedRenderersList;
 104102        }
 103
 250104        public void SetIgnoredLayersMask(int ignoredLayersMask) { this.ignoredLayersMask = ignoredLayersMask; }
 105
 106        /// <summary>
 107        /// Sets the dirty flag to true to make PopulateRenderersList retrieve all the scene objects on its next call.
 108        /// </summary>
 3444109        public void MarkDirty() { dirty = true; }
 110
 111        /// <summary>
 112        /// Returns true if dirty.
 113        /// </summary>
 114        /// <returns>True if dirty.</returns>
 3115        public bool IsDirty() { return dirty; }
 116
 117        /// <summary>
 118        /// Returns the renderers list.
 119        /// </summary>
 120        /// <returns>An ICollection with all the tracked renderers.</returns>
 119121        public ICollection<Renderer> GetRenderers() { return renderers; }
 122
 123        /// <summary>
 124        /// Returns the skinned renderers list.
 125        /// </summary>
 126        /// <returns>An ICollection with all the tracked skinned renderers.</returns>
 117127        public ICollection<SkinnedMeshRenderer> GetSkinnedRenderers() { return skinnedRenderers; }
 128
 129        /// <summary>
 130        /// Returns the animations list.
 131        /// </summary>
 132        /// <returns>An array with all the tracked animations.</returns>
 109133        public Animation[] GetAnimations() { return animations; }
 134
 135        public void Dispose()
 136        {
 106137            dirty = true;
 106138            renderers = null;
 106139            animations = null;
 106140            skinnedRenderers = null;
 106141            PoolManager.i.OnGet -= MarkDirty;
 106142        }
 143    }
 144}
Generated by: ReportGenerator 4.8.9.0
12/19/2022 - 14:22:56
GitHub | www.palmmedia.de

Methods/Properties

CullingObjectsTracker()
PopulateRenderersList()
ForcePopulateRenderersList(System.Boolean)
SetIgnoredLayersMask(System.Int32)
MarkDirty()
IsDirty()
GetRenderers()
GetSkinnedRenderers()
GetAnimations()
Dispose()