net.dreditor.overlays 0.0.0-stage → 0.1.6

package/ColorParticleProgress.cs

@@ -0,0 +1,118 @@
+//Author: Benjamin "Sweden" Jillson : Discord: sweden_gaming For Project Eden's Garden
+using DREditor.EventObjects;
+using DREditor.LocalDialogues;
+using DREditor.Services;
+using UnityEngine;
+
+namespace DREditor.Overlays
+{
+    /// <summary>
+    ///
+    /// </summary>
+    /// <remarks>
+    ///
+    /// </remarks>
+    [ClassHeader(nameof(ParticleProgress) + ", " + nameof(GameplayOverlay) + ", " + 
+        nameof(IOverlayManager) + ", " + nameof(IToTitleScreen) + 
+        "\n\n")]
+    [DefaultExecutionOrder(1)]
+    public class ColorParticleProgress : ParticleProgress
+    {
+        /// <summary>
+        ///
+        /// </summary>
+        [Header("")]
+        [Divider]
+        [Tooltip("")]
+        [SerializeField] protected GameObject particlePrefab = null;
+
+
+        /// <summary>
+        ///
+        /// </summary>
+        [Header("")]
+        [Divider]
+        [Tooltip("")]
+        [SerializeField] protected Color allTriggeredColor = Color.blue;
+
+        /// <summary>
+        ///
+        /// </summary>
+        [Tooltip("")]
+        [SerializeField] protected Color untriggeredRequiredColor = Color.yellow;
+
+        /// <summary>
+        ///
+        /// </summary>
+        [Tooltip("")]
+        [SerializeField] protected Color untriggeredOptionalColor = Color.green;
+
+
+        /// <inheritdoc/>
+        protected override void ApplyParticleToObject(SelectableObject selectableObject)
+        {
+            if (selectableObject is not IDialogueProgression progressable)
+                return;
+
+            Color spawnColor = progressable.AllDialogueTriggered() ? allTriggeredColor :
+                progressable.HasUnTriggeredRequiredFlags() ? untriggeredRequiredColor :
+                untriggeredOptionalColor;
+
+            SpawnProgressParticle(selectableObject.gameObject, spawnColor);
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="targetObject"></param>
+        /// <param name="particleColor"></param>
+        protected virtual void SpawnProgressParticle(GameObject targetObject, Color particleColor)
+        {
+            GameObject particleGameObject = Instantiate(particlePrefab, targetObject.transform);
+
+            InitializeParticleDimensions(targetObject, particleGameObject);
+
+            ParticleSystem particleSystem = particleGameObject.GetComponent<ParticleSystem>();
+
+            var particleModule = particleSystem.main;
+
+            particleModule.startColor = particleColor;
+
+            particles.Add(particleSystem);
+
+            if (targetObject.GetComponent<ParticleProgressOffset>() is ParticleProgressOffset off)
+                off.ApplyOffsets(particleSystem);
+
+            particleSystem.Play();
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="targetObject"></param>
+        /// <param name="particleGameObject"></param>
+        protected virtual void InitializeParticleDimensions(GameObject targetObject, GameObject particleGameObject)
+        {
+            Transform parentTransform = targetObject.transform;
+
+            particleGameObject.transform.localPosition = Vector3.zero;
+
+            particleGameObject.transform.localEulerAngles = parentTransform.localEulerAngles;
+
+            if (parentTransform.TryGetComponent(out BoxCollider boxCollider))
+            {
+                particleGameObject.transform.localPosition = boxCollider.center;
+
+                particleGameObject.transform.localScale = boxCollider.size;
+            }
+            else if (parentTransform.TryGetComponent(out MeshCollider collider))
+            {
+                particleGameObject.transform.localPosition = collider.sharedMesh.bounds.center;
+
+                particleGameObject.transform.localScale = collider.sharedMesh.bounds.size;
+            }
+            else if (parentTransform.TryGetComponent(out MeshFilter parentRenderer))
+                particleGameObject.transform.localScale = parentRenderer.mesh.bounds.size;
+        }
+    }
+}

package/ColorParticleProgress.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 61358103496d72f4ca4b507227b23504
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/ControlOverlaysOnSceneEvent.cs

@@ -0,0 +1,59 @@
+//Author: Benjamin "Sweden" Jillson : Discord: sweden_gaming For Project Eden's Garden
+//Shader That made this possible + Idea by LeoTheDev
+using DREditor.EventObjects;
+using System.Linq;
+using UnityEngine;
+
+namespace DREditor.Overlays
+{
+    /// <summary>
+    ///
+    /// </summary>
+    [ClassHeader(nameof(SceneEventListener) +
+        "\n\n")]
+    public class ControlOverlaysOnSceneEvent : SceneEventListener
+    {
+        /// <summary>
+        ///
+        /// </summary>
+        [Space]
+
+        [Header("")]
+        [Divider]
+        [Tooltip("")]
+        [SerializeField] protected bool setStateTo = false;
+
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected override void OnEnable()
+        {
+            base.OnEnable();
+
+            Response.AddListener(OnEventInvoked);
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected override void OnDisable()
+        {
+            base.OnDisable();
+
+            Response.RemoveListener(OnEventInvoked);
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected virtual void OnEventInvoked()
+        {
+            var overlayManagers = FindObjectsByType<MonoBehaviour>().OfType<IOverlayManager>();
+
+            foreach (var overlay in overlayManagers)
+                if (overlay != null && overlay.IsOverlaying())
+                    overlay.SetOverlay(setStateTo);
+        }
+    }
+}

package/ControlOverlaysOnSceneEvent.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: aa87632c233eb81488ee34a4b91f75cb
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/DREditor.Overlays.asmdef

@@ -0,0 +1,22 @@
+{
+    "name": "DREditor.Overlays",
+    "rootNamespace": "",
+    "references": [
+        "Unity.RenderPipelines.Universal.Runtime",
+        "Unity.InputSystem",
+        "DREditor",
+        "DREditor.Controls",
+        "DREditor.Fading",
+        "DREditor.LocalDialogues",
+        "DREditor.UIHandling"
+    ],
+    "includePlatforms": [],
+    "excludePlatforms": [],
+    "allowUnsafeCode": false,
+    "overrideReferences": false,
+    "precompiledReferences": [],
+    "autoReferenced": true,
+    "defineConstraints": [],
+    "versionDefines": [],
+    "noEngineReferences": false
+}

package/DREditor.Overlays.asmdef.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 76eba6be95883e842aaf6b991c1471e6
+AssemblyDefinitionImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/GameplayOverlay.cs

@@ -0,0 +1,131 @@
+//Author: Benjamin "Sweden" Jillson : Discord: sweden_gaming For Project Eden's Garden
+using DREditor.Dialogues.Starting;
+using DREditor.EventObjects;
+using DREditor.Services;
+using DREditor.UIHandling;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using UnityEngine;
+using UnityEngine.InputSystem;
+using static UnityEngine.InputSystem.InputAction;
+
+namespace DREditor.Overlays
+{
+    /// <summary>
+    ///
+    /// </summary>
+    public abstract class GameplayOverlay : MonoBehaviour, IOverlayManager, IToTitleScreen
+    {
+        /// <summary>
+        ///
+        /// </summary>
+        [Tooltip("")]
+        [SerializeField] protected InputActionReference observeMode = null;
+
+
+        /// <summary>
+        ///
+        /// </summary>
+        [Header("")]
+        [Divider]
+        [Tooltip("")]
+        [SerializeField] protected SceneEventListener checkOverlay = null;
+
+        /// <summary>
+        ///
+        /// </summary>
+        [Tooltip("")]
+        [SerializeField] protected EvaluateCondition displayOverlayCondition = null;
+
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected IEnumerable<IDialoguePrepareEvent> dialoguePrepareEvents;
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected bool overlaying = false;
+
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected virtual void Awake()
+            => dialoguePrepareEvents ??= FindObjectsByType<MonoBehaviour>().OfType<IDialoguePrepareEvent>();
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected virtual void OnEnable()
+        {
+            checkOverlay.Response.AddListener(ClearOverlayOnActive);
+
+            foreach (var preparer in dialoguePrepareEvents)
+                if (preparer != null)
+                    preparer.OnDialoguePrepare += ClearOverlayOnActive;
+
+            observeMode.action.started += EvaluateOverlay;
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected virtual void OnDisable()
+        {
+            checkOverlay.Response.RemoveListener(ClearOverlayOnActive);
+
+            foreach (var preparer in dialoguePrepareEvents)
+                if (preparer != null)
+                    preparer.OnDialoguePrepare -= ClearOverlayOnActive;
+
+            observeMode.action.started -= EvaluateOverlay;
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="context"></param>
+        protected abstract void EvaluateOverlay(CallbackContext context);
+
+        /// <inheritdoc/>
+        public virtual bool IsOverlaying() => overlaying;
+
+        /// <inheritdoc/>
+        public virtual void SetOverlay(bool to) => overlaying = to;
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected abstract IEnumerator ToggleOverlay();
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected abstract void TurnOnOverlay();
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected abstract void TurnOffOverlay();
+
+
+        /// <inheritdoc/>
+        public virtual void ClearOverlayOnActive()
+        {
+            if (overlaying)
+                ClearOverlay();
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected virtual void ClearOverlay() => StartCoroutine(ToggleOverlay());
+
+
+        /// <inheritdoc/>
+        public virtual void ToTitleScreen() => TurnOffOverlay();
+    }
+}

package/GameplayOverlay.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: cce1181e876abbe4592d0ad345396779
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/IOverlayManager.cs

@@ -0,0 +1,27 @@
+//Author: Benjamin "Sweden" Jillson : Discord: sweden_gaming For Project Eden's Garden
+
+namespace DREditor.Overlays
+{
+    /// <summary>
+    ///
+    /// </summary>
+    public interface IOverlayManager
+    {
+        /// <summary>
+        ///
+        /// </summary>
+        /// <returns></returns>
+        bool IsOverlaying();
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="to"></param>
+        void SetOverlay(bool to);
+
+        /// <summary>
+        ///
+        /// </summary>
+        void ClearOverlayOnActive();
+    }
+}

package/IOverlayManager.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 26d2d77de0803954b8b10c95f3be25d3
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/ObserveManager.cs

@@ -0,0 +1,262 @@
+//Author: Benjamin "Sweden" Jillson : Discord: sweden_gaming For Project Eden's Garden
+//Shader That made this possible + Idea by LeoTheDev
+using DREditor.Dialogues.Events;
+using DREditor.Dialogues.Finishing;
+using DREditor.EventObjects;
+using DREditor.Fading;
+using DREditor.Services;
+using System.Collections;
+using System.Linq;
+using UnityEngine;
+using UnityEngine.Events;
+
+using UnityEngine.Rendering.Universal;
+using static UnityEngine.InputSystem.InputAction;
+using UnityEngine.InputSystem;
+
+
+#if UNITY_EDITOR
+using UnityEditor;
+#endif
+
+namespace DREditor.Overlays
+{
+    /// <summary>
+    ///
+    /// </summary>
+    /// <remarks>
+    ///
+    /// </remarks>
+    [ClassHeader(nameof(GameplayOverlay) + ", " + nameof(IOverlayManager) + ", " + nameof(IToTitleScreen) +
+        "\n\n")]
+    public class ObserveManager : GameplayOverlay
+    {
+        /// <summary>
+        ///
+        /// </summary>
+        [Tooltip("")]
+        [SerializeField] protected BoolWithEvent changingObserve = null;
+
+        /// <summary>
+        ///
+        /// </summary>
+        [Tooltip("")]
+        [SerializeField] protected BoolWithEvent reticleCanSelect = null;
+
+
+        /// <summary>
+        ///
+        /// </summary>
+        [Header("")]
+        [Divider]
+        [Tooltip("")]
+        [SerializeField] protected BoolWithEvent isLoadingFile = null;
+
+        /// <summary>
+        ///
+        /// </summary>
+        [Tooltip("")]
+        [SerializeField] protected BoolWithEvent inLeaveProcess = null;
+
+        /// <summary>
+        ///
+        /// </summary>
+        [Tooltip("")]
+        [SerializeField] protected BoolWithEvent inDialogue = null;
+
+
+        /// <summary>
+        ///
+        /// </summary>
+        [Header("")]
+        [Divider]
+        [Tooltip("")]
+        [SerializeField] protected string toggleCameraEvent = "ToggleCameraFlags";
+
+        /// <summary>
+        ///
+        /// </summary>
+        [Tooltip("")]
+        [SerializeField] protected RenderObjects renderObject = null;
+
+        /// <summary>
+        ///
+        /// </summary>
+        [Tooltip("")]
+        [SerializeField] protected UniversalRendererData rendererData = null;
+
+        /// <summary>
+        ///
+        /// </summary>
+        [Tooltip("")]
+        [SerializeField] protected float fadeToTime = 0.5f;
+
+        /// <summary>
+        ///
+        /// </summary>
+        [Tooltip("")]
+        [SerializeField] protected float fadeOutTime = 0.5f;
+
+        /// <summary>
+        ///
+        /// </summary>
+        [Tooltip("")]
+        [SerializeField] protected LayerMask layerMask = 131073; // Default + RaycastBlock
+
+
+        [Header("")]
+        [Divider]
+        [Header("")]
+        [SerializeField] protected UnityEvent OnPlaySFX = null;
+
+        [Header("")]
+        [SerializeField] protected UnityEvent OnStopSFX = null;
+
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected IEndDialogueEvent EndDialogueEvent;
+
+
+        /// <inheritdoc/>
+        protected override void Awake()
+        {
+            base.Awake();
+
+            EndDialogueEvent ??= FindObjectsByType<MonoBehaviour>().OfType<IEndDialogueEvent>().FirstOrDefault();
+        }
+
+        /// <inheritdoc/>
+        protected override void OnEnable()
+        {
+            base.OnEnable();
+
+#if UNITY_EDITOR
+            EditorApplication.playModeStateChanged += ModeChanged;
+#endif
+        }
+
+        /// <inheritdoc/>
+        protected override void OnDisable()
+        {
+            base.OnDisable();
+
+#if UNITY_EDITOR
+            EditorApplication.playModeStateChanged -= ModeChanged;
+#endif
+        }
+
+        
+        /// <inheritdoc/>
+        protected override void EvaluateOverlay(CallbackContext context)
+        {
+            if (!changingObserve.Value && displayOverlayCondition.Evaluate())
+            {
+                reticleCanSelect.SetValue(false);
+
+                StartCoroutine(ToggleOverlay());
+            }
+        }
+
+        /// <inheritdoc/>
+        protected override IEnumerator ToggleOverlay()
+        {
+            changingObserve.SetValue(true);
+
+            if (!isLoadingFile.Value)
+                yield return ServiceLocator.GetService<GlobalFade>().FadeToRoutine(fadeToTime);
+
+            SetOverlay(!overlaying);
+
+            DialogueEventSystem.TriggerEvent(toggleCameraEvent, overlaying);
+
+            if (!isLoadingFile.Value)
+                yield return ServiceLocator.GetService<GlobalFade>().FadeOutRoutine(fadeOutTime);
+
+            if (!inDialogue.Value)
+                reticleCanSelect.SetValue(true);
+
+            changingObserve.SetValue(false);
+        }
+
+
+        /// <inheritdoc/>
+        protected override void ClearOverlay()
+        {
+            base.ClearOverlay();
+
+            if (inLeaveProcess.Value)
+                EndDialogueEvent.OnDialogueEnd += FixReticleIssue;
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        protected virtual void FixReticleIssue()
+        {
+            EndDialogueEvent.OnDialogueEnd -= FixReticleIssue;
+
+            reticleCanSelect.SetValue(true);
+        }
+
+
+        /// <inheritdoc/>
+        public override void SetOverlay(bool to)
+        {
+            if (to)
+                TurnOnOverlay();
+            else
+                TurnOffOverlay();
+
+            base.SetOverlay(to);
+        }
+
+        /// <inheritdoc/>
+        protected override void TurnOnOverlay()
+        {
+            renderObject.SetActive(true);
+
+            rendererData.opaqueLayerMask &= ~layerMask;
+
+            OnPlaySFX?.Invoke();
+        }
+
+        /// <inheritdoc/>
+        protected override void TurnOffOverlay()
+        {
+            renderObject.SetActive(false);
+
+            rendererData.opaqueLayerMask |= layerMask;
+
+            OnStopSFX?.Invoke();
+        }
+
+
+        /// <inheritdoc/>
+        public override void ToTitleScreen()
+        {
+            EndDialogueEvent.OnDialogueEnd -= FixReticleIssue;
+
+            base.ToTitleScreen();
+        }
+
+
+#if UNITY_EDITOR
+        /// <summary>
+        ///
+        /// </summary>
+        /// <param name="change"></param>
+        protected virtual void ModeChanged(PlayModeStateChange change)
+        {
+            if (!EditorApplication.isPlayingOrWillChangePlaymode && EditorApplication.isPlaying)
+            {
+                if (renderObject.isActive)
+                    renderObject.SetActive(false);
+
+                rendererData.opaqueLayerMask |= layerMask;
+            }
+        }
+#endif
+    }
+}

package/ObserveManager.cs.meta

@@ -0,0 +1,15 @@
+fileFormatVersion: 2
+guid: aca01d2e60ac0df408a4bc20515be13b
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences:
+  - inDialogue: {fileID: 11400000, guid: b2839fc222ba4bc4eb8bcfee73b0c53d, type: 2}
+  - inTPFD: {fileID: 11400000, guid: 7f90df5202cae904292188e37c9076d3, type: 2}
+  - renderObject: {fileID: 4470810494987417559, guid: 2fd9deb72a9165242b37b8fcf5f00e49,
+      type: 2}
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: