fix(Interaction): ensure controllers preserve the correct visibility

The Interact Object Appearance script was incorrectly hiding controller
visibility when both controllers would touch the object.

This was because the cached object state was only for the last object
that interacted, however an existing interacting controller could
be overridden by a new interacting controller which would then prevent
the previous controller from regaining the correct visibility state.

The fix is to ensure the object state is cached accordingly.

Another issue was how it was storing the coroutines for each
interaction event as it was storing them per interaction not per
object that was interacting. This would mean that if both controllers
touched the same object at the same time, then one would cancel the
coroutine of the other. This has been fixed by grouping the
coroutines with the object they are to affect.

Author: thestonefox

Assets/VRTK/Scripts/Interactions/VRTK_InteractObjectAppearance.cs

@@ -3,6 +3,7 @@ namespace VRTK
 {
     using UnityEngine;
     using System.Collections;
+    using System.Collections.Generic;
 
     /// <summary>
     /// Event Payload
@@ -146,15 +147,10 @@ public enum ValidInteractingObject
         /// </summary>
         public event InteractObjectAppearanceEventHandler RenderersDisabled;
 
-        protected GameObject touchAffectedObject;
-        protected GameObject grabAffectedObject;
-        protected GameObject useAffectedObject;
-        protected Coroutine touchRoutine;
-        protected Coroutine grabRoutine;
-        protected Coroutine useRoutine;
-        protected bool currentRenderState;
-        protected bool currentGameObjectState;
-        protected bool currentStatesSet;
+        protected Dictionary<GameObject, bool> currentRenderStates = new Dictionary<GameObject, bool>();
+        protected Dictionary<GameObject, bool> currentGameObjectStates = new Dictionary<GameObject, bool>();
+        protected Dictionary<GameObject, Coroutine> affectingRoutines = new Dictionary<GameObject, Coroutine>();
+        protected List<GameObject> touchingObjects = new List<GameObject>();
 
         public virtual void OnGameObjectEnabled(InteractObjectAppearanceEventArgs e)
         {
@@ -190,7 +186,10 @@ public virtual void OnRenderersDisabled(InteractObjectAppearanceEventArgs e)
 
         protected virtual void OnEnable()
         {
-            currentStatesSet = false;
+            currentRenderStates.Clear();
+            currentGameObjectStates.Clear();
+            affectingRoutines.Clear();
+            touchingObjects.Clear();
             objectToMonitor = (objectToMonitor == null ? GetComponentInParent<VRTK_InteractableObject>() : objectToMonitor);
 
             if (objectToMonitor != null)
@@ -227,7 +226,7 @@ protected virtual void OnDisable()
                 objectToMonitor.InteractableObjectUsed -= InteractableObjectUsed;
                 objectToMonitor.InteractableObjectUnused -= InteractableObjectUnused;
             }
-            CancelAllRoutines();
+            CancelRoutines();
         }
 
         protected virtual InteractObjectAppearanceEventArgs SetPayload(GameObject affectingObject, InteractionType interactionType)
@@ -244,7 +243,10 @@ protected virtual void RestoreDefaults()
         {
             if (objectToMonitor != null && objectToMonitor.IsTouched())
             {
-                ToggleState(touchAffectedObject, gameObjectActiveByDefault, rendererVisibleByDefault, InteractionType.None);
+                for (int i = 0; i < touchingObjects.Count; i++)
+                {
+                    ToggleState(touchingObjects[i], gameObjectActiveByDefault, rendererVisibleByDefault, InteractionType.None);
+                }
             }
         }
 
@@ -281,21 +283,20 @@ protected virtual void ToggleState(GameObject objectToToggle, bool gameObjectSho
         {
             if (objectToToggle != null)
             {
-                if (!currentStatesSet || currentRenderState != rendererShow)
+                if (!currentRenderStates.ContainsKey(objectToToggle) || currentRenderStates[objectToToggle] != rendererShow)
                 {
                     VRTK_ObjectAppearance.ToggleRenderer(rendererShow, objectToToggle, ObjectToIgnore());
                     EmitRenderEvent(objectToToggle, rendererShow, interactionType);
                 }
 
-                if (!currentStatesSet || currentGameObjectState != gameObjectShow)
+                if (!currentGameObjectStates.ContainsKey(objectToToggle) || currentGameObjectStates[objectToToggle] != gameObjectShow)
                 {
                     objectToToggle.SetActive(gameObjectShow);
                     EmitGameObjectEvent(objectToToggle, gameObjectShow, interactionType);
                 }
 
-                currentRenderState = rendererShow;
-                currentGameObjectState = gameObjectShow;
-                currentStatesSet = true;
+                currentRenderStates[objectToToggle] = rendererShow;
+                currentGameObjectStates[objectToToggle] = gameObjectShow;
             }
         }
 
@@ -305,37 +306,24 @@ protected virtual IEnumerator ToggleStateAfterTime(GameObject objectToToggle, bo
             ToggleState(objectToToggle, gameObjectShow, rendererShow, interactionType);
         }
 
-        protected virtual void CancelAllRoutines()
-        {
-            CancelTouchRoutine();
-            CancelGrabRoutine();
-            CancelUseRoutine();
-        }
-
-        protected virtual void CancelTouchRoutine()
+        protected virtual void CancelRoutines(GameObject currentAffectingObject = null)
         {
-            if (touchRoutine != null)
+            if (currentAffectingObject != null)
             {
-                StopCoroutine(touchRoutine);
-                touchRoutine = null;
-            }
-        }
-
-        protected virtual void CancelGrabRoutine()
-        {
-            if (grabRoutine != null)
-            {
-                StopCoroutine(grabRoutine);
-                grabRoutine = null;
+                if (affectingRoutines.ContainsKey(currentAffectingObject) && affectingRoutines[currentAffectingObject] != null)
+                {
+                    StopCoroutine(affectingRoutines[currentAffectingObject]);
+                }
             }
-        }
-
-        protected virtual void CancelUseRoutine()
-        {
-            if (useRoutine != null)
+            else
             {
-                StopCoroutine(useRoutine);
-                useRoutine = null;
+                foreach (KeyValuePair<GameObject, Coroutine> affectingRouting in affectingRoutines)
+                {
+                    if (currentAffectingObject == affectingRouting.Key && affectingRouting.Value != null)
+                    {
+                        StopCoroutine(affectingRouting.Value);
+                    }
+                }
             }
         }
 
@@ -386,81 +374,89 @@ protected virtual void InteractableObjectTouched(object sender, InteractableObje
         {
             if (IsValidInteractingObject(e.interactingObject, validTouchInteractingObject))
             {
-                CancelAllRoutines();
-                touchAffectedObject = (objectToAffect == null ? GetActualController(e.interactingObject) : objectToAffect);
-                touchRoutine = StartCoroutine(ToggleStateAfterTime(touchAffectedObject, gameObjectActiveOnTouch, rendererVisibleOnTouch, touchAppearanceDelay, InteractionType.Touch));
+                GameObject touchAffectedObject = (objectToAffect == null ? GetActualController(e.interactingObject) : objectToAffect);
+                CancelRoutines(touchAffectedObject);
+                if (!touchingObjects.Contains(touchAffectedObject))
+                {
+                    touchingObjects.Add(touchAffectedObject);
+                }
+                affectingRoutines[touchAffectedObject] = StartCoroutine(ToggleStateAfterTime(touchAffectedObject, gameObjectActiveOnTouch, rendererVisibleOnTouch, touchAppearanceDelay, InteractionType.Touch));
             }
         }
 
         protected virtual void InteractableObjectUntouched(object sender, InteractableObjectEventArgs e)
         {
             if (IsValidInteractingObject(e.interactingObject, validTouchInteractingObject))
             {
-                CancelAllRoutines();
-                touchRoutine = StartCoroutine(ToggleStateAfterTime(touchAffectedObject, gameObjectActiveByDefault, rendererVisibleByDefault, untouchAppearanceDelay, InteractionType.Untouch));
-                touchAffectedObject = null;
+                GameObject touchAffectedObject = (objectToAffect == null ? GetActualController(e.interactingObject) : objectToAffect);
+                CancelRoutines(touchAffectedObject);
+                if (touchingObjects.Contains(touchAffectedObject))
+                {
+                    touchingObjects.Remove(touchAffectedObject);
+                }
+                affectingRoutines[touchAffectedObject] = StartCoroutine(ToggleStateAfterTime(touchAffectedObject, gameObjectActiveByDefault, rendererVisibleByDefault, untouchAppearanceDelay, InteractionType.Untouch));
             }
         }
 
         protected virtual void InteractableObjectGrabbed(object sender, InteractableObjectEventArgs e)
         {
             if (IsValidInteractingObject(e.interactingObject, validGrabInteractingObject))
             {
-                CancelAllRoutines();
-                grabAffectedObject = (objectToAffect == null ? GetActualController(e.interactingObject) : objectToAffect);
-                grabRoutine = StartCoroutine(ToggleStateAfterTime(grabAffectedObject, gameObjectActiveOnGrab, rendererVisibleOnGrab, grabAppearanceDelay, InteractionType.Grab));
+                GameObject grabAffectedObject = (objectToAffect == null ? GetActualController(e.interactingObject) : objectToAffect);
+                CancelRoutines(grabAffectedObject);
+                affectingRoutines[grabAffectedObject] = StartCoroutine(ToggleStateAfterTime(grabAffectedObject, gameObjectActiveOnGrab, rendererVisibleOnGrab, grabAppearanceDelay, InteractionType.Grab));
             }
         }
 
         protected virtual void InteractableObjectUngrabbed(object sender, InteractableObjectEventArgs e)
         {
             if (IsValidInteractingObject(e.interactingObject, validGrabInteractingObject))
             {
-                CancelAllRoutines();
+                GameObject grabAffectedObject = (objectToAffect == null ? GetActualController(e.interactingObject) : objectToAffect);
+                CancelRoutines(grabAffectedObject);
                 if (objectToMonitor.IsUsing())
                 {
-                    grabRoutine = StartCoroutine(ToggleStateAfterTime(grabAffectedObject, gameObjectActiveOnUse, rendererVisibleOnUse, ungrabAppearanceDelay, InteractionType.Ungrab));
+                    affectingRoutines[grabAffectedObject] = StartCoroutine(ToggleStateAfterTime(grabAffectedObject, gameObjectActiveOnUse, rendererVisibleOnUse, ungrabAppearanceDelay, InteractionType.Ungrab));
                 }
                 else if (objectToMonitor.IsTouched())
                 {
-                    grabRoutine = StartCoroutine(ToggleStateAfterTime(grabAffectedObject, gameObjectActiveOnTouch, rendererVisibleOnTouch, ungrabAppearanceDelay, InteractionType.Ungrab));
+                    affectingRoutines[grabAffectedObject] = StartCoroutine(ToggleStateAfterTime(grabAffectedObject, gameObjectActiveOnTouch, rendererVisibleOnTouch, ungrabAppearanceDelay, InteractionType.Ungrab));
                 }
                 else
                 {
-                    grabRoutine = StartCoroutine(ToggleStateAfterTime(grabAffectedObject, gameObjectActiveByDefault, rendererVisibleByDefault, ungrabAppearanceDelay, InteractionType.Ungrab));
+                    affectingRoutines[grabAffectedObject] = StartCoroutine(ToggleStateAfterTime(grabAffectedObject, gameObjectActiveByDefault, rendererVisibleByDefault, ungrabAppearanceDelay, InteractionType.Ungrab));
                 }
-                grabAffectedObject = null;
             }
         }
 
         protected virtual void InteractableObjectUsed(object sender, InteractableObjectEventArgs e)
         {
             if (IsValidInteractingObject(e.interactingObject, validUseInteractingObject))
             {
-                CancelAllRoutines();
-                useAffectedObject = (objectToAffect == null ? GetActualController(e.interactingObject) : objectToAffect);
-                useRoutine = StartCoroutine(ToggleStateAfterTime(useAffectedObject, gameObjectActiveOnUse, rendererVisibleOnUse, useAppearanceDelay, InteractionType.Use));
+                GameObject useAffectedObject = (objectToAffect == null ? GetActualController(e.interactingObject) : objectToAffect);
+                CancelRoutines(useAffectedObject);
+                affectingRoutines[useAffectedObject] = StartCoroutine(ToggleStateAfterTime(useAffectedObject, gameObjectActiveOnUse, rendererVisibleOnUse, useAppearanceDelay, InteractionType.Use));
             }
         }
 
         protected virtual void InteractableObjectUnused(object sender, InteractableObjectEventArgs e)
         {
             if (IsValidInteractingObject(e.interactingObject, validUseInteractingObject))
             {
-                CancelAllRoutines();
+                GameObject useAffectedObject = (objectToAffect == null ? GetActualController(e.interactingObject) : objectToAffect);
+                CancelRoutines(useAffectedObject);
                 if (objectToMonitor.IsGrabbed())
                 {
-                    useRoutine = StartCoroutine(ToggleStateAfterTime(useAffectedObject, gameObjectActiveOnGrab, rendererVisibleOnGrab, unuseAppearanceDelay, InteractionType.Unuse));
+                    affectingRoutines[useAffectedObject] = StartCoroutine(ToggleStateAfterTime(useAffectedObject, gameObjectActiveOnGrab, rendererVisibleOnGrab, unuseAppearanceDelay, InteractionType.Unuse));
                 }
                 else if (objectToMonitor.IsTouched())
                 {
-                    useRoutine = StartCoroutine(ToggleStateAfterTime(useAffectedObject, gameObjectActiveOnTouch, rendererVisibleOnTouch, unuseAppearanceDelay, InteractionType.Unuse));
+                    affectingRoutines[useAffectedObject] = StartCoroutine(ToggleStateAfterTime(useAffectedObject, gameObjectActiveOnTouch, rendererVisibleOnTouch, unuseAppearanceDelay, InteractionType.Unuse));
                 }
                 else
                 {
-                    useRoutine = StartCoroutine(ToggleStateAfterTime(useAffectedObject, gameObjectActiveByDefault, rendererVisibleByDefault, unuseAppearanceDelay, InteractionType.Unuse));
+                    affectingRoutines[useAffectedObject] = StartCoroutine(ToggleStateAfterTime(useAffectedObject, gameObjectActiveByDefault, rendererVisibleByDefault, unuseAppearanceDelay, InteractionType.Unuse));
                 }
-                useAffectedObject = null;
             }
         }
     }