First Commit

Assets/Scripts/RenderPasses/Outline/Outline2.cs

@@ -0,0 +1,348 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using Golems.Attributes;
+using RogueUtils.Data;
+#if UNITY_EDITOR
+using UnityEditor;
+#endif
+using UnityEngine;
+using UnityEngine.Serialization;
+using Golems;
+
+    [DisallowMultipleComponent]
+    //This was used over outline entity due to it already being on the objects
+    public partial class Outline2 : MonoBehaviour
+    {
+
+        [Header("HighEndOutlineSettingsBelow ==================")]
+        /// <summary>
+        /// Renderer's attached to this GameObject
+        /// </summary>
+        /// 
+        [OnValueChanged("UpdateRendererBundle")]
+        [SerializeField]
+        private Renderer[] m_Renderers;
+
+        public Renderer[] Renderers
+        {
+            get => m_Renderers;
+            set => m_Renderers = value;
+        }
+
+        /// <summary>
+        /// Outline Colour
+        /// </summary>
+        [FormerlySerializedAs("outlineColor")]
+        [SerializeField]
+        private Color m_OutlineColor = Color.white;
+
+        [Header("The color variable will override local color if it exists")]
+        public ColorVariable OutlineColorVariable;
+
+        [SerializeField]
+        [Range(0, 10)]
+        private float m_BlurRadius = 2.5f;
+
+        public float BlurRadius
+        {
+            get => m_BlurRadius;
+            set => m_BlurRadius = value;
+        }
+
+        [SerializeField]
+        [Range(0, 1)]
+        private float m_Alpha = 1;
+
+        public float Alpha
+        {
+            get => m_Alpha;
+            set => m_Alpha = value;
+        }
+
+        [SerializeField] private float m_FadeSpeed = 7.0f;
+
+        /// <summary>
+        /// Returns True if Outline is currently active (m_Alpha >=1).
+        /// Otherwise, returns False.
+        /// </summary>
+        public bool IsOutlining => m_Alpha >= 1.0f;
+
+        /// <summary>
+        /// The current active Fade Coroutine
+        /// </summary>
+        private Coroutine m_FadeCoroutine = default;
+
+        /// <summary>
+        /// WaitForSeconds used before Fade in/out begins
+        /// </summary>
+        private WaitForSeconds m_FadeDelay = new WaitForSeconds(.1f);
+
+        [Header("OutlineTypeToggle ==================")]
+        [SerializeField]
+        private bool m_UseLowEndOutline = false;
+
+        private void Awake()
+        {
+#if UNITY_SWITCH
+            m_UseLowEndOutline = true;
+#endif
+            //if (GolemsGameManager.IsPlayerXR())
+            if (false)
+            {
+                m_UseLowEndOutline = true;
+            }
+
+            if (m_UseLowEndOutline)
+            {
+                
+            }
+            else
+            {
+                HighEndAwake();
+            }
+        }
+
+        private void HighEndAwake()
+        {
+            if (m_Renderers.Length == 0)
+            {
+                Debug.LogWarning("No renderers setup for outline in editor on " + gameObject.name +
+                                 ". Grabbing them through code");
+
+                var renderers = new List<Renderer>();
+
+                //
+                // Check OutlineEntity for Renderer
+                //
+                if (TryGetComponent<Renderer>(out var r))
+                {
+                    renderers.Add(r);
+                }
+
+                SetRenderers(renderers);
+            }
+
+            OutlineCollection.AddRenderer(this);
+            Alpha = 0;
+        }
+
+        void OnEnable()
+        {
+
+            if (m_UseLowEndOutline)
+            {
+                
+            }
+            else
+            {
+                HighEndOnEnable();
+            }
+        }
+
+        private void HighEndOnEnable()
+        {
+
+        }
+
+        private void OnValidate()
+        {
+            if (m_UseLowEndOutline)
+            {
+               
+            }
+            else
+            {
+
+            }
+        }
+
+        private void Update()
+        {
+            if (m_UseLowEndOutline)
+            {
+                
+            }
+            else
+            {
+
+            }
+        }
+
+
+        private void OnDisable()
+        {
+            Debug.Log("Disabling Outline");
+            Alpha = 0;
+            
+        }
+
+        private void OnDestroy()
+        {
+            if (m_UseLowEndOutline)
+            {
+                
+            }
+            else
+            {
+                HighEndOnDestroy();
+            }
+        }
+
+        private void HighEndOnDestroy()
+        {
+
+            OutlineCollection.RemoveRenderer(this);
+            Alpha = 0;
+
+        }
+
+
+        public void ToggleOutlining()
+        {
+            if (m_Alpha > 0)
+            {
+                StopOutlining();
+            }
+            else
+            {
+                StartOutlining();
+            }
+        }
+
+        /// <summary>
+        /// Activates/Deactivates the Outline,
+        /// depending on the given true or false value.
+        /// </summary>
+        /// <param name="active"> Activate or deactivate the Outline,
+        /// where true activates the Outline and false deactivates the Outline.</param>
+        public void SetOutlineActive(bool active)
+        {
+            if (active)
+            {
+                StartOutlining();
+            }
+            else
+            {
+                StopOutlining();
+            }
+        }
+
+        [Button]
+        public void StartOutlining()
+        {
+            if (m_UseLowEndOutline)
+            {
+                Debug.Log("Start Outlining");
+                
+            }
+            else
+            {
+                StartHighEndOutlining();
+            }
+        }
+
+        public void StartHighEndOutlining()
+        {
+            //Debug.Log("StartOutlining");
+            if (m_FadeCoroutine != null)
+            {
+                StopCoroutine(m_FadeCoroutine);
+                m_FadeCoroutine = null;
+            }
+
+            //
+            // protect against running on disabled game objects
+            //
+            if (gameObject.activeInHierarchy)
+            {
+                m_FadeCoroutine = StartCoroutine(Fade(1));
+            }
+        }
+
+
+        [Button]
+        public void StopOutlining()
+        {
+
+            if (m_UseLowEndOutline)
+            {
+                Debug.Log("Stop Outlining");
+                
+            }
+            else
+            {
+                StopHighEndOutlining();
+            }
+        }
+
+        public void StopHighEndOutlining()
+        {
+
+            if (m_FadeCoroutine != null)
+            {
+                StopCoroutine(m_FadeCoroutine);
+                m_FadeCoroutine = null;
+            }
+
+            //
+            // protect against running on disabled game objects
+            //
+            if (gameObject.activeInHierarchy)
+            {
+                m_FadeCoroutine = StartCoroutine(Fade(-1));
+            }
+
+        }
+
+        private IEnumerator Fade(int dir)
+        {
+            yield return new WaitForSeconds(0.1f);
+            bool faded = false;
+            while (!faded)
+            {
+                var alpha = Alpha;
+                alpha += (dir * m_FadeSpeed) * Time.deltaTime;
+                alpha = Mathf.Clamp01(alpha);
+                Alpha = alpha;
+                faded = dir < 0 ? alpha <= 0.0f : alpha >= 1.0f;
+                yield return null;
+            }
+
+            m_FadeCoroutine = null;
+        }
+        [ContextMenu("Force Stop Outlining")]
+        /// <summary>
+        /// Forces alpha to 0 to avoid showing if moved immediately
+        /// </summary>
+        public void ForceStopOutlining()
+        {
+            if (m_UseLowEndOutline)
+            {
+                
+            }
+            else
+            {
+                Alpha = 0;
+            }
+        }
+
+        public void SetRenderers(List<Renderer> renderers)
+        {
+            m_Renderers = renderers.ToArray();
+        }
+
+        /// <summary>
+        /// Get the current Color for this Outline instance.
+        /// If the Outline has a OutlineColorVariable the value
+        /// of the passed Color variable will be set to the scriptable
+        /// variable value. Otherwise, it will be set to this Outlines m_OutlineColor.
+        /// </summary>
+        /// <param name="colour">Color variable to store this instances current outline colour</param>
+        public void GetColour(out Color colour)
+        {
+            colour = OutlineColorVariable == null ? m_OutlineColor : OutlineColorVariable.Value;
+        }
+    }
+