fix: improved SnapZones for interactables with multiple collider

Innoactive · Sep 14, 2020 · d27f160 · d27f160
1 parent a06dc86
commit d27f160
Show file tree

Hide file tree

Showing 2 changed files with 76 additions and 19 deletions.
diff --git a/Runtime/Interaction/InteractableObject.cs b/Runtime/Interaction/InteractableObject.cs
@@ -87,11 +87,29 @@ public bool IsUsable
         protected override void Reset()
         {
             base.Reset();
-            
+
             // Sets the 'interactionLayerMask' to Default in order to not interact with Teleportation or UI rays.
             interactionLayerMask = 1;
         }
 
+        internal void OnTriggerEnter(Collider other)
+        {
+            SnapZone target = other.gameObject.GetComponent<SnapZone>();            
+            if (target != null && target.enabled && !IsInSocket)
+            {
+                target.AddHoveredInteractable(this);
+            }
+        }
+
+        internal void OnTriggerExit(Collider other)
+        {
+            SnapZone target = other.gameObject.GetComponent<SnapZone>();            
+            if (target != null && target.enabled)
+            {
+                target.RemoveHoveredInteractable(this);
+            }
+        }
+
         /// <summary>
         /// Determines if this <see cref="InteractableObject"/> can be hovered by a given interactor.
         /// </summary>

diff --git a/Runtime/Interaction/SnapZone.cs b/Runtime/Interaction/SnapZone.cs
@@ -156,8 +156,11 @@ public Mesh PreviewMesh
         private Transform initialParent;
         private Material activeMaterial;
         private Vector3 tmpCenterOfMass;
+
         private List<Validator> validators = new List<Validator>();
 
+        private List<XRBaseInteractable> hoverTargets = new List<XRBaseInteractable>();
+
         protected override void Awake()
         {
             base.Awake();
@@ -187,10 +190,25 @@ protected override void Awake()
             }
         }
 
+        internal void AddHoveredInteractable(XRBaseInteractable interactable)
+        {  
+            if (interactable != null)
+            {
+                hoverTargets.Add(interactable);
+            }
+        }
+
+        internal void RemoveHoveredInteractable(XRBaseInteractable interactable)
+        {
+            hoverTargets.Remove(interactable);
+        }
+
         protected override void OnEnable()
         {
             base.OnEnable();
-
+
+            hoverTargets.Clear();
+
             onSelectEnter.AddListener(OnAttach);
             onSelectExit.AddListener(OnDetach);
         }
@@ -199,20 +217,22 @@ protected override void OnDisable()
         {
             base.OnDisable();
 
+            hoverTargets.Clear();
+
             onSelectEnter.RemoveListener(OnAttach);
             onSelectExit.RemoveListener(OnDetach);
         }
 
-        private void OnAttach(XRBaseInteractable snappable)
+        private void OnAttach(XRBaseInteractable interactable)
         {
-            Rigidbody rigid = snappable.gameObject.GetComponent<Rigidbody>();
+            Rigidbody rigid = interactable.gameObject.GetComponent<Rigidbody>();
             tmpCenterOfMass = rigid.centerOfMass;
             rigid.centerOfMass = Vector3.zero;
         }
 
-        private void OnDetach(XRBaseInteractable snappable)
+        private void OnDetach(XRBaseInteractable interactable)
         {
-            Rigidbody rigid = snappable.gameObject.GetComponent<Rigidbody>();
+            Rigidbody rigid = interactable.gameObject.GetComponent<Rigidbody>();
             rigid.centerOfMass = tmpCenterOfMass;
         }
 
@@ -328,27 +348,46 @@ public override void ProcessInteractor(XRInteractionUpdateOrder.UpdatePhase upda
             {
                 base.ProcessInteractor(updatePhase);
             }
-
+            
             if (socketActive)
             {
-                if (m_HoverTargets.Count == 0 && ShowHighlightObject)
+                hoverTargets.RemoveAll(target => target == null || target.enabled == false);
+
+                CheckForReleasedHoverTargets();
+
+                ShowHighlight();
+            }
+        }
+
+        private void CheckForReleasedHoverTargets()
+        {
+            foreach (XRBaseInteractable target in hoverTargets)
+            {
+                if (m_HoverTargets.Contains(target) || target.isSelected || selectTarget != null)
                 {
-                    activeMaterial = HighlightMeshMaterial;
-                } 
-                else if (m_HoverTargets.Count > 0 && showInteractableHoverMeshes)
+                    continue;
+                }
+
+                if (CanSelect(target))
                 {
-                    if (m_HoverTargets.All(CanSelect))
-                    {
-                        activeMaterial = ValidationMaterial;
-                    }
-                    else
-                    {
-                        activeMaterial = InvalidMaterial;
-                    }
+                    ForceSelect(target);
+                    return;
                 }
             }
         }
 
+        private void ShowHighlight()
+        {
+            if (hoverTargets.Count == 0 && ShowHighlightObject)
+            {
+                activeMaterial = HighlightMeshMaterial;
+            }
+            else if (hoverTargets.Count > 0 && showInteractableHoverMeshes)
+            {
+                activeMaterial = hoverTargets.Any(CanSelect) ? ValidationMaterial : InvalidMaterial;
+            }
+        }
+
         /// <summary>
         /// Draws a highlight mesh.
         /// </summary>