Merge pull request #1160 from StephenHodgson/MRTK-Singletion

Singleton changes.

Author: StephenHodgson

Assets/HoloToolkit/Input/Scripts/Utilities/SetGlobalListener.cs

@@ -13,35 +13,23 @@ public class SetGlobalListener : MonoBehaviour
     {
         private void OnEnable()
         {
-            StartCoroutine(AddGlobalListener());
+            InputManager.Instance.AddGlobalListener(gameObject);
         }
 
         private void OnDisable()
         {
-            if (InputManager.IsInitialized)
+            if (InputManager.Instance != null)
             {
                 InputManager.Instance.RemoveGlobalListener(gameObject);
             }
         }
 
         private void OnDestroy()
         {
-            if (InputManager.IsInitialized)
+            if (InputManager.Instance != null)
             {
                 InputManager.Instance.RemoveGlobalListener(gameObject);
             }
         }
-
-        private IEnumerator AddGlobalListener()
-        {
-            while (!InputManager.IsInitialized)
-            {
-                yield return null;
-            }
-
-            InputManager.AssertIsInitialized();
-
-            InputManager.Instance.AddGlobalListener(gameObject);
-        }
     }
 }

Assets/HoloToolkit/Utilities/Scripts/Singleton.cs

@@ -8,28 +8,41 @@ namespace HoloToolkit.Unity
     /// <summary>
     /// Singleton behaviour class, used for components that should only have one instance
     /// </summary>
-    /// <typeparam name="T"></typeparam>
+    /// <typeparam name="T">The Singleton Type</typeparam>
     public class Singleton<T> : MonoBehaviour where T : Singleton<T>
     {
         private static T instance;
+
+        /// <summary>
+        /// Returns the Singleton instance of the classes type.
+        /// If no instance is found, then we search for an instance
+        /// in the scene.
+        /// If more than one instance is found, we throw an error and
+        /// no instance is returned.
+        /// </summary>
         public static T Instance
         {
             get
             {
-                if (instance == null)
+                if (instance == null && searchForInstance)
                 {
-                    Debug.LogErrorFormat(
-                        "The {0} singleton instance is being accessed while it's null. Make sure it's included in"
-                            + " the scene, and your initialization/deinitialization sequence is compatible with"
-                            + " singletons.",
-                        typeof(T).Name
-                        );
+                    searchForInstance = false;
+                    T[] objects = FindObjectsOfType<T>();
+                    if (objects.Length == 1)
+                    {
+                        instance = objects[0];
+                    }
+                    else if (objects.Length > 1)
+                    {
+                        Debug.LogErrorFormat("Expected exactly 1 {0} but found {1}.", typeof(T).ToString(), objects.Length);
+                    }
                 }
-
                 return instance;
             }
         }
 
+        private static bool searchForInstance = true;
+
         public static void AssertIsInitialized()
         {
             Debug.Assert(IsInitialized, string.Format("The {0} singleton has not been initialized.", typeof(T).Name));
@@ -47,25 +60,44 @@ public static bool IsInitialized
         }
 
         /// <summary>
-        /// Base awake method that sets the singleton's unique instance.
+        /// Base Awake method that sets the Singleton's unique instance.
+        /// Called by Unity when initializing a MonoBehaviour.
+        /// Scripts that extend Singleton should be sure to call base.Awake() to ensure the
+        /// static Instance reference is properly created.
         /// </summary>
         protected virtual void Awake()
         {
-            if (instance != null)
+            if (IsInitialized && instance != this)
             {
-                Debug.LogErrorFormat("Trying to instantiate a second instance of singleton class {0}", GetType().Name);
+                if (Application.isEditor)
+                {
+                    DestroyImmediate(this);
+                }
+                else
+                {
+                    Destroy(this);
+                }
+
+                Debug.LogErrorFormat("Trying to instantiate a second instance of singleton class {0}. Additional Instance was destroyed", GetType().Name);
             }
-            else
+            else if (!IsInitialized)
             {
                 instance = (T)this;
             }
         }
 
+        /// <summary>
+        /// Base OnDestroy method that destroys the Singleton's unique instance.
+        /// Called by Unity when destroying a MonoBehaviour. Scripts that extend
+        /// Singleton should be sure to call base.OnDestroy() to ensure the
+        /// underlying static Instance reference is properly cleaned up.
+        /// </summary>
         protected virtual void OnDestroy()
         {
             if (instance == this)
             {
                 instance = null;
+                searchForInstance = true;
             }
         }
     }