private void ManageVisibility()

in Assets/MRTK/SDK/Features/UX/Scripts/ScrollingObjectCollection/ScrollingObjectCollection.cs [1668:1818]
121 lines of code
38 McCabe index (conditional complexity)

        private void ManageVisibility(bool isRestoringVisibility = false)
        {
            if (!MaskEnabled && !isRestoringVisibility)
            {
                return;
            }

            ClippingBoundsCollider.enabled = true;
            Bounds clippingThresholdBounds = ClippingBoundsCollider.bounds;

            Renderer[] contentRenderers = ScrollContainer.GetComponentsInChildren<Renderer>(true);
            List<Renderer> clippedRenderers = ClipBox.GetRenderersCopy().ToList();

            // Remove all renderers from clipping primitive that are not part of scroll content
            foreach (var clippedRenderer in clippedRenderers)
            {
                if (clippedRenderer != null && !clippedRenderer.transform.IsChildOf(ScrollContainer.transform))
                {
                    if (disableClippedGameObjects)
                    {
                        if (!clippedRenderer.gameObject.activeSelf)
                        {
                            clippedRenderer.gameObject.SetActive(true);
                        }
                    }
                    if (disableClippedRenderers)
                    {
                        if (!clippedRenderer.enabled)
                        {
                            clippedRenderer.enabled = true;
                        }
                    }

                    renderersToUnclip.Add(clippedRenderer);
                }
            }

            // Check render visibility
            foreach (var renderer in contentRenderers)
            {
                // All content renderers should be added to clipping primitive
                if (!isRestoringVisibility && MaskEnabled && !clippedRenderers.Contains(renderer))
                {
                    renderersToClip.Add(renderer);
                }

                // Complete or partially visible renders should be clipped and its game object should be active
                if (isRestoringVisibility
                    || clippingThresholdBounds.ContainsBounds(renderer.bounds) 
                    || clippingThresholdBounds.Intersects(renderer.bounds)) 
                {
                    if (disableClippedGameObjects)
                    {
                        if (!renderer.gameObject.activeSelf)
                        {
                            renderer.gameObject.SetActive(true);
                        }
                    }
                    if (disableClippedRenderers)
                    {
                        if (!renderer.enabled)
                        {
                            renderer.enabled = true;
                        }
                    }
                }

                // Hidden renderer game objects should be inactive
                else
                {
                    if (disableClippedGameObjects)
                    {
                        if (renderer.gameObject.activeSelf)
                        {
                            renderer.gameObject.SetActive(false);
                        }
                    }
                    if (disableClippedRenderers)
                    {
                        if (renderer.enabled)
                        {
                            renderer.enabled = false;
                        }
                    }
                }
            }

            // Check collider visibility
            if (Application.isPlaying)
            {
                // Outer clipping bounds is used to ensure collider has minimum visibility to stay enabled
                Bounds outerClippingThresholdBounds = ClippingBoundsCollider.bounds;
                outerClippingThresholdBounds.size *= contentVisibilityThresholdRatio;

                var colliders = ScrollContainer.GetComponentsInChildren<Collider>(true);
                foreach (var collider in colliders)
                {
                    // Disabling content colliders during drag to stop interaction even if game object is inactive
                    if (!isRestoringVisibility && IsDragging)
                    {
                        if (collider.enabled)
                        {
                            collider.enabled = false;
                        }

                        continue;
                    }

                    // No need to manage collider visibility in case game object is inactive and no pointer is dragging the scroll
                    if (!isRestoringVisibility && !collider.gameObject.activeSelf)
                    {
                        continue;
                    }

                    // Temporary activating for getting bounds
                    var wasColliderEnabled = collider.enabled;

                    if (!wasColliderEnabled)
                    {
                        collider.enabled = true;
                    }

                    // Completely or partially visible colliders should be enabled if scroll is not drag engaged
                    if (isRestoringVisibility || outerClippingThresholdBounds.ContainsBounds(collider.bounds))
                    {
                        if (!wasColliderEnabled)
                        {
                            wasColliderEnabled = true;
                        }
                    }
                    // Hidden colliders should be disabled
                    else
                    {
                        if (wasColliderEnabled)
                        {
                            wasColliderEnabled = false;
                        }
                    }

                    // Update collider state or revert to previous state
                    collider.enabled = wasColliderEnabled;
                }
            }

            ClippingBoundsCollider.enabled = false;

            if (!isRestoringVisibility)
            {
                ReconcileClippingContent();
            }
        }