Why is My Code Working on PC But Not With VR?

Hello. I've been using SteamVR to program a Oculus Rift Simulation.
So I made a script that states: If I grab an object (considering it has an animation that makes it aim, and in the last bone/joint there is a "burst" as child (A particle system for the water spraying)), the code identifies if It is a fire extinguisher or not. If it is, it animates (Aim the stuff right) and if the burst is not stored, look for it and stores, after that, by pressing B or the Oculus Touch Controller Trigger it Sprays (Activates/unhide/toggle visibility the burst object) so It sprays.

It works perfectly... On the Computer using Keyboard... but with the Oculus using the touch controls It doens't, I can grab it, but it does not animate nor burst at all.

After that I modified the StteamVR default "hand" class to call the now implemented functions "ForceBurst ()" and "ForceStop" to try to fix (I imagined that for some reason the normal methods weren't being called through the VR). Still works on the pc but not on VR, same Stuff.

This is the code to burst and identify the extinguisher:

Code (CSharp):

1. using System.Collections;
2. using System.Collections.Generic;
3. using UnityEngine;
4. using Valve.VR.InteractionSystem;
5.  
6. public class ExtinguisherJet : MonoBehaviour
7. {
8.     private Hand hand;
9.     [SerializeField] GameObject hnd;
10.     private SteamVR_Controller.Device controller;
11.     //-----------------------------------------//
12.     private Transform heldObj;
13.     private GameObject jet;
14.     private Animator anim;
15.     [SerializeField] private GameObject[] extrs;
16.     [SerializeField] private Transform fbHand;
17.     GameObject[] bursts;
18.     private string lasMessage;
19.     private bool lookForExtinguisher ()
20.     {
21.         bool isThere = false;
22.  
23.         try
24.         {
25.             heldObj = fbHand.transform.GetChild(2);
26.             isThere = true;
27.         }
28.         catch (System.Exception e)
29.         {
30.             heldObj = null;
31.             isThere = false;
32.         }
33.         return isThere;
34.     }
35.     //--------------------------------------------//
36.  
37.     void Start()
38.     {
39.         hand = hnd.GetComponent<Hand> ();
40.  
41.         bursts = new GameObject[extrs.Length];
42.         lasMessage = "";
43.         jet = null;
44.         anim = null;
45.     }
46.        
47.     private void CheckHand ()
48.     {
49.         if (lookForExtinguisher () && lasMessage != heldObj.name)  // lasMessage is Just to Keep the console from printing the same stuff over and over
50.         {
51.             print ("Yo, check It out, I got some" + " " + heldObj.name);
52.  
53.             if (heldObj.name == "Extinguisher")
54.             {
55.                 jet = heldObj.gameObject;
56.                 for (int i = 1; i < 20; i++)
57.                     jet = jet.transform.GetChild(0).gameObject;
58.  
59.                 print ("Found " + jet.name + " in " + heldObj.name);
60.                 anim = heldObj.GetComponent <Animator>();
61.                 anim.SetBool ("willAim", true);
62.             }
63.  
64.             lasMessage = heldObj.name;
65.  
66.         } else if (!lookForExtinguisher () && lasMessage != "nothing") {
67.             print ("Ma boey! Derr's nothin' on yo hands!");
68.             lasMessage = "nothing";
69.  
70.             if (anim != null)
71.                 anim.SetBool("willAim", false);
72.         }
73.     }
74.  
75.     private void Bursting ()
76.     {
77.         if (lookForExtinguisher ())
78.         {
79.             if (heldObj.name == "Extinguisher" && Input.GetKey(KeyCode.B))
80.             {
81.                 print ("I'm Bursting");
82.                 jet.SetActive (true);
83.             }
84.             else if (heldObj.name == "Extinguisher" && hand.controller != null && controller.GetHairTriggerDown())
85.             {
86.                 print ("I'm Bursting");
87.                 jet.SetActive(true);
88.             }
89.             else if (jet != null)
90.             {
91.                 jet.SetActive(false);
92.             }
93.         }
94.     }
95.  
96.     public void ForceBurst ()
97.     {
98.         if (lookForExtinguisher ())
99.         {
100.             if (heldObj.name == "Extinguisher")
101.             {
102.                 print ("I'm Bursting");
103.                 jet.SetActive (true);
104.             }
105.             else if (jet != null)
106.             {
107.                 jet.SetActive(false);
108.             }
109.         }
110.     }
111.  
112.     public void ForceStop()
113.     {
114.         SearchforBursting ();
115.     }
116.  
117.     private void SearchforBursting ()
118.     {
119.         GameObject tempObj = null;
120.         GameObject tempJt = null;
121.         int i = 0;
122.         int j = 0;
123.         for (i = 0; i < extrs.Length; i++) //Runs through the Extinguishers' list
124.         {
125.             tempObj = extrs[i];
126.  
127.             if (bursts[i] == null) //Finds The Burst and stores it, if it isn't stored
128.             {
129.                 tempJt = tempObj;
130.                 for (j = 1; j < 20; j++)
131.                     tempJt = tempJt.transform.GetChild(0).gameObject;
132.                 bursts [i] = tempJt;
133.                 print ("A burst has been stored");
134.             }
135.             if (bursts[i].activeSelf && heldObj != tempObj.transform)  //Deactivate them if they are activated if they're not being held
136.             {
137.                 bursts[i].SetActive(false);
138.                 print ("Deactivated");
139.                 print (heldObj + ", " + tempObj);
140.             }
141.         }
142.     }
143.  
144.     void Update ()
145.     {
146.         if (hand.controller != null)
147.         {
148.             controller = SteamVR_Controller.Input((int) hand.controller.index);
149.         }
150.  
151.         CheckHand ();
152.         Bursting ();
153.         SearchforBursting ();
154.     }
155. }

And this is the Default Hand SteamVR class (note that I also modified the Grab object key from the Trigger to the Grip button, minor change, made previously, this works, but the bursting in the other hand does not) with the call to the ForceBurst() and ForceStop().

Code (CSharp):

1. //======= Copyright (c) Valve Corporation, All rights reserved. ===============
2. //
3. // Purpose: The hands used by the player in the vr interaction system
4. //
5. //=============================================================================
6.  
7. using UnityEngine;
8. using System;
9. using System.Collections;
10. using System.Collections.Generic;
11. using System.Collections.ObjectModel;
12.  
13. namespace Valve.VR.InteractionSystem
14. {
15.     //-------------------------------------------------------------------------
16.     // Links with an appropriate SteamVR controller and facilitates
17.     // interactions with objects in the virtual world.
18.     //-------------------------------------------------------------------------
19.     public class Hand : MonoBehaviour
20.     {
21.         public enum HandType
22.         {
23.             Left,
24.             Right,
25.             Any
26.         };
27.  
28.         // The flags used to determine how an object is attached to the hand.
29.         [Flags]
30.         public enum AttachmentFlags
31.         {
32.             SnapOnAttach = 1 << 0, // The object should snap to the position of the specified attachment point on the hand.
33.             DetachOthers = 1 << 1, // Other objects attached to this hand will be detached.
34.             DetachFromOtherHand = 1 << 2, // This object will be detached from the other hand.
35.             ParentToHand = 1 << 3, // The object will be parented to the hand.
36.         };
37.  
38.         public const AttachmentFlags defaultAttachmentFlags = AttachmentFlags.ParentToHand |
39.                                                               AttachmentFlags.DetachOthers |
40.                                                               AttachmentFlags.DetachFromOtherHand |
41.                                                               AttachmentFlags.SnapOnAttach;
42.  
43.         public Hand otherHand;
44.         public HandType startingHandType;
45.  
46.         public ExtinguisherJet exjet; //Let's use the Extinguisher class I made, shall we.
47.  
48.         public Transform hoverSphereTransform;
49.         public float hoverSphereRadius = 0.05f;
50.         public LayerMask hoverLayerMask = -1;
51.         public float hoverUpdateInterval = 0.1f;
52.  
53.         public Camera noSteamVRFallbackCamera;
54.         public float noSteamVRFallbackMaxDistanceNoItem = 10.0f;
55.         public float noSteamVRFallbackMaxDistanceWithItem = 0.5f;
56.         private float noSteamVRFallbackInteractorDistance = -1.0f;
57.  
58.         public SteamVR_Controller.Device controller;
59.  
60.         public GameObject controllerPrefab;
61.         private GameObject controllerObject = null;
62.  
63.         public bool showDebugText = false;
64.         public bool spewDebugText = false;
65.  
66.         public struct AttachedObject
67.         {
68.             public GameObject attachedObject;
69.             public GameObject originalParent;
70.             public bool isParentedToHand;
71.         }
72.  
73.         private List<AttachedObject> attachedObjects = new List<AttachedObject>();
74.  
75.         public ReadOnlyCollection<AttachedObject> AttachedObjects
76.         {
77.             get { return attachedObjects.AsReadOnly(); }
78.         }
79.  
80.         public bool hoverLocked { get; private set; }
81.  
82.         private Interactable _hoveringInteractable;
83.  
84.         private TextMesh debugText;
85.         private int prevOverlappingColliders = 0;
86.  
87.         private const int ColliderArraySize = 16;
88.         private Collider[] overlappingColliders;
89.  
90.         private Player playerInstance;
91.  
92.         private GameObject applicationLostFocusObject;
93.  
94.         SteamVR_Events.Action inputFocusAction;
95.  
96.  
97.         //-------------------------------------------------
98.         // The Interactable object this Hand is currently hovering over
99.         //-------------------------------------------------
100.         public Interactable hoveringInteractable
101.         {
102.             get { return _hoveringInteractable; }
103.             set
104.             {
105.                 if ( _hoveringInteractable != value )
106.                 {
107.                     if ( _hoveringInteractable != null )
108.                     {
109.                         HandDebugLog( "HoverEnd " + _hoveringInteractable.gameObject );
110.                         _hoveringInteractable.SendMessage( "OnHandHoverEnd", this, SendMessageOptions.DontRequireReceiver );
111.  
112.                         //Note: The _hoveringInteractable can change after sending the OnHandHoverEnd message so we need to check it again before broadcasting this message
113.                         if ( _hoveringInteractable != null )
114.                         {
115.                             this.BroadcastMessage( "OnParentHandHoverEnd", _hoveringInteractable, SendMessageOptions.DontRequireReceiver ); // let objects attached to the hand know that a hover has ended
116.                         }
117.                     }
118.  
119.                     _hoveringInteractable = value;
120.  
121.                     if ( _hoveringInteractable != null )
122.                     {
123.                         HandDebugLog( "HoverBegin " + _hoveringInteractable.gameObject );
124.                         _hoveringInteractable.SendMessage( "OnHandHoverBegin", this, SendMessageOptions.DontRequireReceiver );
125.  
126.                         //Note: The _hoveringInteractable can change after sending the OnHandHoverBegin message so we need to check it again before broadcasting this message
127.                         if ( _hoveringInteractable != null )
128.                         {
129.                             this.BroadcastMessage( "OnParentHandHoverBegin", _hoveringInteractable, SendMessageOptions.DontRequireReceiver ); // let objects attached to the hand know that a hover has begun
130.                         }
131.                     }
132.                 }
133.             }
134.         }
135.  
136.  
137.         //-------------------------------------------------
138.         // Active GameObject attached to this Hand
139.         //-------------------------------------------------
140.         public GameObject currentAttachedObject
141.         {
142.             get
143.             {
144.                 CleanUpAttachedObjectStack();
145.  
146.                 if ( attachedObjects.Count > 0 )
147.                 {
148.                     return attachedObjects[attachedObjects.Count - 1].attachedObject;
149.                 }
150.  
151.                 return null;
152.             }
153.         }
154.  
155.  
156.         //-------------------------------------------------
157.         public Transform GetAttachmentTransform( string attachmentPoint = "" )
158.         {
159.             Transform attachmentTransform = null;
160.  
161.             if ( !string.IsNullOrEmpty( attachmentPoint ) )
162.             {
163.                 attachmentTransform = transform.Find( attachmentPoint );
164.             }
165.  
166.             if ( !attachmentTransform )
167.             {
168.                 attachmentTransform = this.transform;
169.             }
170.  
171.             return attachmentTransform;
172.         }
173.  
174.  
175.         //-------------------------------------------------
176.         // Guess the type of this Hand
177.         //
178.         // If startingHandType is Hand.Left or Hand.Right, returns startingHandType.
179.         // If otherHand is non-null and both Hands are linked to controllers, returns
180.         // Hand.Left if this Hand is leftmost relative to the HMD, otherwise Hand.Right.
181.         // Otherwise, returns Hand.Any
182.         //-------------------------------------------------
183.         public HandType GuessCurrentHandType()
184.         {
185.             if ( startingHandType == HandType.Left || startingHandType == HandType.Right )
186.             {
187.                 return startingHandType;
188.             }
189.  
190.             if ( startingHandType == HandType.Any && otherHand != null && otherHand.controller == null )
191.             {
192.                 return HandType.Right;
193.             }
194.  
195.             if ( controller == null || otherHand == null || otherHand.controller == null )
196.             {
197.                 return startingHandType;
198.             }
199.  
200.             if ( controller.index == SteamVR_Controller.GetDeviceIndex( SteamVR_Controller.DeviceRelation.Leftmost ) )
201.             {
202.                 return HandType.Left;
203.             }
204.  
205.             return HandType.Right;
206.         }
207.  
208.  
209.         //-------------------------------------------------
210.         // Attach a GameObject to this GameObject
211.         //
212.         // objectToAttach - The GameObject to attach
213.         // flags - The flags to use for attaching the object
214.         // attachmentPoint - Name of the GameObject in the hierarchy of this Hand which should act as the attachment point for this GameObject
215.         //-------------------------------------------------
216.         public void AttachObject( GameObject objectToAttach, AttachmentFlags flags = defaultAttachmentFlags, string attachmentPoint = "" )
217.         {
218.             if ( flags == 0 )
219.             {
220.                 flags = defaultAttachmentFlags;
221.             }
222.  
223.             //Make sure top object on stack is non-null
224.             CleanUpAttachedObjectStack();
225.  
226.             //Detach the object if it is already attached so that it can get re-attached at the top of the stack
227.             DetachObject( objectToAttach );
228.  
229.             //Detach from the other hand if requested
230.             if ( ( ( flags & AttachmentFlags.DetachFromOtherHand ) == AttachmentFlags.DetachFromOtherHand ) && otherHand )
231.             {
232.                 otherHand.DetachObject( objectToAttach );
233.             }
234.  
235.             if ( ( flags & AttachmentFlags.DetachOthers ) == AttachmentFlags.DetachOthers )
236.             {
237.                 //Detach all the objects from the stack
238.                 while ( attachedObjects.Count > 0 )
239.                 {
240.                     DetachObject( attachedObjects[0].attachedObject );
241.                 }
242.             }
243.  
244.             if ( currentAttachedObject )
245.             {
246.                 currentAttachedObject.SendMessage( "OnHandFocusLost", this, SendMessageOptions.DontRequireReceiver );
247.             }
248.  
249.             AttachedObject attachedObject = new AttachedObject();
250.             attachedObject.attachedObject = objectToAttach;
251.             attachedObject.originalParent = objectToAttach.transform.parent != null ? objectToAttach.transform.parent.gameObject : null;
252.             if ( ( flags & AttachmentFlags.ParentToHand ) == AttachmentFlags.ParentToHand )
253.             {
254.                 //Parent the object to the hand
255.                 objectToAttach.transform.parent = GetAttachmentTransform( attachmentPoint );
256.                 attachedObject.isParentedToHand = true;
257.             }
258.             else
259.             {
260.                 attachedObject.isParentedToHand = false;
261.             }
262.             attachedObjects.Add( attachedObject );
263.  
264.             if ( ( flags & AttachmentFlags.SnapOnAttach ) == AttachmentFlags.SnapOnAttach )
265.             {
266.                 objectToAttach.transform.localPosition = Vector3.zero;
267.                 objectToAttach.transform.localRotation = Quaternion.identity;
268.             }
269.  
270.             HandDebugLog( "AttachObject " + objectToAttach );
271.             objectToAttach.SendMessage( "OnAttachedToHand", this, SendMessageOptions.DontRequireReceiver );
272.  
273.             UpdateHovering();
274.         }
275.  
276.  
277.         //-------------------------------------------------
278.         // Detach this GameObject from the attached object stack of this Hand
279.         //
280.         // objectToDetach - The GameObject to detach from this Hand
281.         //-------------------------------------------------
282.         public void DetachObject( GameObject objectToDetach, bool restoreOriginalParent = true )
283.         {
284.             int index = attachedObjects.FindIndex( l => l.attachedObject == objectToDetach );
285.             if ( index != -1 )
286.             {
287.                 HandDebugLog( "DetachObject " + objectToDetach );
288.  
289.                 GameObject prevTopObject = currentAttachedObject;
290.  
291.                 Transform parentTransform = null;
292.                 if ( attachedObjects[index].isParentedToHand )
293.                 {
294.                     if ( restoreOriginalParent && ( attachedObjects[index].originalParent != null ) )
295.                     {
296.                         parentTransform = attachedObjects[index].originalParent.transform;
297.                     }
298.                     attachedObjects[index].attachedObject.transform.parent = parentTransform;
299.                 }
300.  
301.                 attachedObjects[index].attachedObject.SetActive( true );
302.                 attachedObjects[index].attachedObject.SendMessage( "OnDetachedFromHand", this, SendMessageOptions.DontRequireReceiver );
303.                 attachedObjects.RemoveAt( index );
304.  
305.                 GameObject newTopObject = currentAttachedObject;
306.  
307.                 //Give focus to the top most object on the stack if it changed
308.                 if ( newTopObject != null && newTopObject != prevTopObject )
309.                 {
310.                     newTopObject.SetActive( true );
311.                     newTopObject.SendMessage( "OnHandFocusAcquired", this, SendMessageOptions.DontRequireReceiver );
312.                 }
313.             }
314.  
315.             CleanUpAttachedObjectStack();
316.         }
317.  
318.  
319.         //-------------------------------------------------
320.         // Get the world velocity of the VR Hand.
321.         // Note: controller velocity value only updates on controller events (Button but and down) so good for throwing
322.         //-------------------------------------------------
323.         public Vector3 GetTrackedObjectVelocity()
324.         {
325.             if ( controller != null )
326.             {
327.                 return transform.parent.TransformVector( controller.velocity );
328.             }
329.  
330.             return Vector3.zero;
331.         }
332.  
333.  
334.         //-------------------------------------------------
335.         // Get the world angular velocity of the VR Hand.
336.         // Note: controller velocity value only updates on controller events (Button but and down) so good for throwing
337.         //-------------------------------------------------
338.         public Vector3 GetTrackedObjectAngularVelocity()
339.         {
340.             if ( controller != null )
341.             {
342.                 return transform.parent.TransformVector( controller.angularVelocity );
343.             }
344.  
345.             return Vector3.zero;
346.         }
347.  
348.  
349.         //-------------------------------------------------
350.         private void CleanUpAttachedObjectStack()
351.         {
352.             attachedObjects.RemoveAll( l => l.attachedObject == null );
353.         }
354.  
355.  
356.         //-------------------------------------------------
357.         void Awake()
358.         {
359.             inputFocusAction = SteamVR_Events.InputFocusAction( OnInputFocus );
360.  
361.             if ( hoverSphereTransform == null )
362.             {
363.                 hoverSphereTransform = this.transform;
364.             }
365.  
366.             applicationLostFocusObject = new GameObject( "_application_lost_focus" );
367.             applicationLostFocusObject.transform.parent = transform;
368.             applicationLostFocusObject.SetActive( false );
369.         }
370.  
371.  
372.         //-------------------------------------------------
373.         IEnumerator Start()
374.         {
375.             // save off player instance
376.             playerInstance = Player.instance;
377.             if ( !playerInstance )
378.             {
379.                 Debug.LogError( "No player instance found in Hand Start()" );
380.             }
381.  
382.             // allocate array for colliders
383.             overlappingColliders = new Collider[ColliderArraySize];
384.  
385.             // We are a "no SteamVR fallback hand" if we have this camera set
386.             // we'll use the right mouse to look around and left mouse to interact
387.             // - don't need to find the device
388.             if ( noSteamVRFallbackCamera )
389.             {
390.                 yield break;
391.             }
392.  
393.             //Debug.Log( "Hand - initializing connection routine" );
394.  
395.             // Acquire the correct device index for the hand we want to be
396.             // Also for the other hand if we get there first
397.             while ( true )
398.             {
399.                 // Don't need to run this every frame
400.                 yield return new WaitForSeconds( 1.0f );
401.  
402.                 // We have a controller now, break out of the loop!
403.                 if ( controller != null )
404.                     break;
405.  
406.                 //Debug.Log( "Hand - checking controllers..." );
407.  
408.                 // Initialize both hands simultaneously
409.                 if ( startingHandType == HandType.Left || startingHandType == HandType.Right )
410.                 {
411.                     // Left/right relationship.
412.                     // Wait until we have a clear unique left-right relationship to initialize.
413.                     int leftIndex = SteamVR_Controller.GetDeviceIndex( SteamVR_Controller.DeviceRelation.Leftmost );
414.                     int rightIndex = SteamVR_Controller.GetDeviceIndex( SteamVR_Controller.DeviceRelation.Rightmost );
415.                     if ( leftIndex == -1 || rightIndex == -1 || leftIndex == rightIndex )
416.                     {
417.                         //Debug.Log( string.Format( "...Left/right hand relationship not yet established: leftIndex={0}, rightIndex={1}", leftIndex, rightIndex ) );
418.                         continue;
419.                     }
420.  
421.                     int myIndex = ( startingHandType == HandType.Right ) ? rightIndex : leftIndex;
422.                     int otherIndex = ( startingHandType == HandType.Right ) ? leftIndex : rightIndex;
423.  
424.                     InitController( myIndex );
425.                     if ( otherHand )
426.                     {
427.                         otherHand.InitController( otherIndex );
428.                     }
429.                 }
430.                 else
431.                 {
432.                     // No left/right relationship. Just wait for a connection
433.  
434.                     var vr = SteamVR.instance;
435.                     for ( int i = 0; i < Valve.VR.OpenVR.k_unMaxTrackedDeviceCount; i++ )
436.                     {
437.                         if ( vr.hmd.GetTrackedDeviceClass( (uint)i ) != Valve.VR.ETrackedDeviceClass.Controller )
438.                         {
439.                             //Debug.Log( string.Format( "Hand - device {0} is not a controller", i ) );
440.                             continue;
441.                         }
442.  
443.                         var device = SteamVR_Controller.Input( i );
444.                         if ( !device.valid )
445.                         {
446.                             //Debug.Log( string.Format( "Hand - device {0} is not valid", i ) );
447.                             continue;
448.                         }
449.  
450.                         if ( ( otherHand != null ) && ( otherHand.controller != null ) )
451.                         {
452.                             // Other hand is using this index, so we cannot use it.
453.                             if ( i == (int)otherHand.controller.index )
454.                             {
455.                                 //Debug.Log( string.Format( "Hand - device {0} is owned by the other hand", i ) );
456.                                 continue;
457.                             }
458.                         }
459.  
460.                         InitController( i );
461.                     }
462.                 }
463.             }
464.         }
465.  
466.  
467.         //-------------------------------------------------
468.         private void UpdateHovering()
469.         {
470.             if ( ( noSteamVRFallbackCamera == null ) && ( controller == null ) )
471.             {
472.                 return;
473.             }
474.  
475.             if ( hoverLocked )
476.                 return;
477.  
478.             if ( applicationLostFocusObject.activeSelf )
479.                 return;
480.  
481.             float closestDistance = float.MaxValue;
482.             Interactable closestInteractable = null;
483.  
484.             // Pick the closest hovering
485.             float flHoverRadiusScale = playerInstance.transform.lossyScale.x;
486.             float flScaledSphereRadius = hoverSphereRadius * flHoverRadiusScale;
487.  
488.             // if we're close to the floor, increase the radius to make things easier to pick up
489.             float handDiff = Mathf.Abs( transform.position.y - playerInstance.trackingOriginTransform.position.y );
490.             float boxMult = Util.RemapNumberClamped( handDiff, 0.0f, 0.5f * flHoverRadiusScale, 5.0f, 1.0f ) * flHoverRadiusScale;
491.  
492.             // null out old vals
493.             for ( int i = 0; i < overlappingColliders.Length; ++i )
494.             {
495.                 overlappingColliders[i] = null;
496.             }
497.  
498.             Physics.OverlapBoxNonAlloc(
499.                 hoverSphereTransform.position - new Vector3( 0, flScaledSphereRadius * boxMult - flScaledSphereRadius, 0 ),
500.                 new Vector3( flScaledSphereRadius, flScaledSphereRadius * boxMult * 2.0f, flScaledSphereRadius ),
501.                 overlappingColliders,
502.                 Quaternion.identity,
503.                 hoverLayerMask.value
504.             );
505.  
506.             // DebugVar
507.             int iActualColliderCount = 0;
508.  
509.             foreach ( Collider collider in overlappingColliders )
510.             {
511.                 if ( collider == null )
512.                     continue;
513.  
514.                 Interactable contacting = collider.GetComponentInParent<Interactable>();
515.  
516.                 // Yeah, it's null, skip
517.                 if ( contacting == null )
518.                     continue;
519.  
520.                 // Ignore this collider for hovering
521.                 IgnoreHovering ignore = collider.GetComponent<IgnoreHovering>();
522.                 if ( ignore != null )
523.                 {
524.                     if ( ignore.onlyIgnoreHand == null || ignore.onlyIgnoreHand == this )
525.                     {
526.                         continue;
527.                     }
528.                 }
529.  
530.                 // Can't hover over the object if it's attached
531.                 if ( attachedObjects.FindIndex( l => l.attachedObject == contacting.gameObject ) != -1 )
532.                     continue;
533.  
534.                 // Occupied by another hand, so we can't touch it
535.                 if ( otherHand && otherHand.hoveringInteractable == contacting )
536.                     continue;
537.  
538.                 // Best candidate so far...
539.                 float distance = Vector3.Distance( contacting.transform.position, hoverSphereTransform.position );
540.                 if ( distance < closestDistance )
541.                 {
542.                     closestDistance = distance;
543.                     closestInteractable = contacting;
544.                 }
545.                 iActualColliderCount++;
546.             }
547.  
548.             // Hover on this one
549.             hoveringInteractable = closestInteractable;
550.  
551.             if ( iActualColliderCount > 0 && iActualColliderCount != prevOverlappingColliders )
552.             {
553.                 prevOverlappingColliders = iActualColliderCount;
554.                 HandDebugLog( "Found " + iActualColliderCount + " overlapping colliders." );
555.             }
556.         }
557.  
558.  
559.         //-------------------------------------------------
560.         private void UpdateNoSteamVRFallback()
561.         {
562.             if ( noSteamVRFallbackCamera )
563.             {
564.                 Ray ray = noSteamVRFallbackCamera.ScreenPointToRay( Input.mousePosition );
565.  
566.                 if ( attachedObjects.Count > 0 )
567.                 {
568.                     // Holding down the mouse:
569.                     // move around a fixed distance from the camera
570.                     transform.position = ray.origin + noSteamVRFallbackInteractorDistance * ray.direction;
571.                 }
572.                 else
573.                 {
574.                     // Not holding down the mouse:
575.                     // cast out a ray to see what we should mouse over
576.  
577.                     // Don't want to hit the hand and anything underneath it
578.                     // So move it back behind the camera when we do the raycast
579.                     Vector3 oldPosition = transform.position;
580.                     transform.position = noSteamVRFallbackCamera.transform.forward * ( -1000.0f );
581.  
582.                     RaycastHit raycastHit;
583.                     if ( Physics.Raycast( ray, out raycastHit, noSteamVRFallbackMaxDistanceNoItem ) )
584.                     {
585.                         transform.position = raycastHit.point;
586.  
587.                         // Remember this distance in case we click and drag the mouse
588.                         noSteamVRFallbackInteractorDistance = Mathf.Min( noSteamVRFallbackMaxDistanceNoItem, raycastHit.distance );
589.                     }
590.                     else if ( noSteamVRFallbackInteractorDistance > 0.0f )
591.                     {
592.                         // Move it around at the distance we last had a hit
593.                         transform.position = ray.origin + Mathf.Min( noSteamVRFallbackMaxDistanceNoItem, noSteamVRFallbackInteractorDistance ) * ray.direction;
594.                     }
595.                     else
596.                     {
597.                         // Didn't hit, just leave it where it was
598.                         transform.position = oldPosition;
599.                     }
600.                 }
601.             }
602.         }
603.  
604.  
605.         //-------------------------------------------------
606.         private void UpdateDebugText()
607.         {
608.             if ( showDebugText )
609.             {
610.                 if ( debugText == null )
611.                 {
612.                     debugText = new GameObject( "_debug_text" ).AddComponent<TextMesh>();
613.                     debugText.fontSize = 120;
614.                     debugText.characterSize = 0.001f;
615.                     debugText.transform.parent = transform;
616.  
617.                     debugText.transform.localRotation = Quaternion.Euler( 90.0f, 0.0f, 0.0f );
618.                 }
619.  
620.                 if ( GuessCurrentHandType() == HandType.Right )
621.                 {
622.                     debugText.transform.localPosition = new Vector3( -0.05f, 0.0f, 0.0f );
623.                     debugText.alignment = TextAlignment.Right;
624.                     debugText.anchor = TextAnchor.UpperRight;
625.                 }
626.                 else
627.                 {
628.                     debugText.transform.localPosition = new Vector3( 0.05f, 0.0f, 0.0f );
629.                     debugText.alignment = TextAlignment.Left;
630.                     debugText.anchor = TextAnchor.UpperLeft;
631.                 }
632.  
633.                 debugText.text = string.Format(
634.                     "Hovering: {0}\n" +
635.                     "Hover Lock: {1}\n" +
636.                     "Attached: {2}\n" +
637.                     "Total Attached: {3}\n" +
638.                     "Type: {4}\n",
639.                     ( hoveringInteractable ? hoveringInteractable.gameObject.name : "null" ),
640.                     hoverLocked,
641.                     ( currentAttachedObject ? currentAttachedObject.name : "null" ),
642.                     attachedObjects.Count,
643.                     GuessCurrentHandType().ToString() );
644.             }
645.             else
646.             {
647.                 if ( debugText != null )
648.                 {
649.                     Destroy( debugText.gameObject );
650.                 }
651.             }
652.         }
653.  
654.  
655.         //-------------------------------------------------
656.         void OnEnable()
657.         {
658.             inputFocusAction.enabled = true;
659.  
660.             // Stagger updates between hands
661.             float hoverUpdateBegin = ( ( otherHand != null ) && ( otherHand.GetInstanceID() < GetInstanceID() ) ) ? ( 0.5f * hoverUpdateInterval ) : ( 0.0f );
662.             InvokeRepeating( "UpdateHovering", hoverUpdateBegin, hoverUpdateInterval );
663.             InvokeRepeating( "UpdateDebugText", hoverUpdateBegin, hoverUpdateInterval );
664.         }
665.  
666.  
667.         //-------------------------------------------------
668.         void OnDisable()
669.         {
670.             inputFocusAction.enabled = false;
671.  
672.             CancelInvoke();
673.         }
674.  
675.  
676.         //-------------------------------------------------
677.         void Update()
678.         {
679.             UpdateNoSteamVRFallback();
680.  
681.             GameObject attached = currentAttachedObject;
682.             if ( attached )
683.             {
684.                 attached.SendMessage( "HandAttachedUpdate", this, SendMessageOptions.DontRequireReceiver );
685.             }
686.  
687.             if ( hoveringInteractable )
688.             {
689.                 hoveringInteractable.SendMessage( "HandHoverUpdate", this, SendMessageOptions.DontRequireReceiver );
690.             }
691.         }
692.  
693.  
694.         //-------------------------------------------------
695.         void LateUpdate()
696.         {
697.             //Re-attach the controller if nothing else is attached to the hand
698.             if ( controllerObject != null && attachedObjects.Count == 0 )
699.             {
700.                 AttachObject( controllerObject );
701.             }
702.         }
703.  
704.  
705.         //-------------------------------------------------
706.         private void OnInputFocus( bool hasFocus )
707.         {
708.             if ( hasFocus )
709.             {
710.                 DetachObject( applicationLostFocusObject, true );
711.                 applicationLostFocusObject.SetActive( false );
712.                 UpdateHandPoses();
713.                 UpdateHovering();
714.                 BroadcastMessage( "OnParentHandInputFocusAcquired", SendMessageOptions.DontRequireReceiver );
715.             }
716.             else
717.             {
718.                 applicationLostFocusObject.SetActive( true );
719.                 AttachObject( applicationLostFocusObject, AttachmentFlags.ParentToHand );
720.                 BroadcastMessage( "OnParentHandInputFocusLost", SendMessageOptions.DontRequireReceiver );
721.             }
722.         }
723.  
724.  
725.         //-------------------------------------------------
726.         void FixedUpdate()
727.         {
728.             UpdateHandPoses();
729.         }
730.  
731.  
732.         //-------------------------------------------------
733.         void OnDrawGizmos()
734.         {
735.             Gizmos.color = new Color( 0.5f, 1.0f, 0.5f, 0.9f );
736.             Transform sphereTransform = hoverSphereTransform ? hoverSphereTransform : this.transform;
737.             Gizmos.DrawWireSphere( sphereTransform.position, hoverSphereRadius );
738.         }
739.  
740.  
741.         //-------------------------------------------------
742.         private void HandDebugLog( string msg )
743.         {
744.             if ( spewDebugText )
745.             {
746.                 Debug.Log( "Hand (" + this.name + "): " + msg );
747.             }
748.         }
749.  
750.  
751.         //-------------------------------------------------
752.         private void UpdateHandPoses()
753.         {
754.             if ( controller != null )
755.             {
756.                 SteamVR vr = SteamVR.instance;
757.                 if ( vr != null )
758.                 {
759.                     var pose = new Valve.VR.TrackedDevicePose_t();
760.                     var gamePose = new Valve.VR.TrackedDevicePose_t();
761.                     var err = vr.compositor.GetLastPoseForTrackedDeviceIndex( controller.index, ref pose, ref gamePose );
762.                     if ( err == Valve.VR.EVRCompositorError.None )
763.                     {
764.                         var t = new SteamVR_Utils.RigidTransform( gamePose.mDeviceToAbsoluteTracking );
765.                         transform.localPosition = t.pos;
766.                         transform.localRotation = t.rot;
767.                     }
768.                 }
769.             }
770.         }
771.  
772.  
773.         //-------------------------------------------------
774.         // Continue to hover over this object indefinitely, whether or not the Hand moves out of its interaction trigger volume.
775.         //
776.         // interactable - The Interactable to hover over indefinitely.
777.         //-------------------------------------------------
778.         public void HoverLock( Interactable interactable )
779.         {
780.             HandDebugLog( "HoverLock " + interactable );
781.             hoverLocked = true;
782.             hoveringInteractable = interactable;
783.         }
784.  
785.  
786.         //-------------------------------------------------
787.         // Stop hovering over this object indefinitely.
788.         //
789.         // interactable - The hover-locked Interactable to stop hovering over indefinitely.
790.         //-------------------------------------------------
791.         public void HoverUnlock( Interactable interactable )
792.         {
793.             HandDebugLog( "HoverUnlock " + interactable );
794.             if ( hoveringInteractable == interactable )
795.             {
796.                 hoverLocked = false;
797.             }
798.         }
799.  
800.         //-------------------------------------------------
801.         // Was the standard interaction button just pressed? In VR, this is a trigger press. In 2D fallback, this is a mouse left-click.
802.         //-------------------------------------------------
803.         public bool GetStandardInteractionButtonDown()
804.         {
805.             if ( noSteamVRFallbackCamera )
806.             {
807.                 return Input.GetMouseButtonDown( 0 );
808.             }
809.             else if ( controller != null )
810.             {
811.                 //return controller.GetHairTriggerDown(); //Default grab controllers (With index Trigger)
812.                 return controller.GetPressDown(SteamVR_Controller.ButtonMask.Grip); //Inplemented Grip Grab control.
813.                 exjet.ForceBurst (); //Force Burst Method call;
814.             }
815.  
816.             return false;
817.         }
818.  
819.  
820.         //-------------------------------------------------
821.         // Was the standard interaction button just released? In VR, this is a trigger press. In 2D fallback, this is a mouse left-click.
822.         //-------------------------------------------------
823.         public bool GetStandardInteractionButtonUp()
824.         {
825.             if ( noSteamVRFallbackCamera )
826.             {
827.                 return Input.GetMouseButtonUp( 0 );
828.             }
829.             else if ( controller != null )
830.             {
831.                 //return controller.GetHairTriggerUp(); //Default grab controllers (With index Trigger)
832.                 return controller.GetPressUp(SteamVR_Controller.ButtonMask.Grip);  //Inplemented Grip Grab control.
833.                 exjet.ForceStop (); //Force Stop Method call;
834.             }
835.  
836.             return false;
837.         }
838.  
839.  
840.         //-------------------------------------------------
841.         // Is the standard interaction button being pressed? In VR, this is a trigger press. In 2D fallback, this is a mouse left-click.
842.         //-------------------------------------------------
843.         public bool GetStandardInteractionButton()
844.         {
845.             if ( noSteamVRFallbackCamera )
846.             {
847.                 return Input.GetMouseButton( 0 );
848.             }
849.             else if ( controller != null )
850.             {
851.                 //return controller.GetHairTrigger(); //Default grab controllers (With index Trigger)
852.                 return controller.GetPress(SteamVR_Controller.ButtonMask.Grip); //Inplemented Grip Grab control.
853.                 exjet.ForceBurst (); //Force Burst Method call;
854.             }
855.  
856.             return false;
857.         }
858.  
859.  
860.         //-------------------------------------------------
861.         private void InitController( int index )
862.         {
863.             if ( controller == null )
864.             {
865.                 controller = SteamVR_Controller.Input( index );
866.  
867.                 HandDebugLog( "Hand " + name + " connected with device index " + controller.index );
868.  
869.                 controllerObject = GameObject.Instantiate( controllerPrefab );
870.                 controllerObject.SetActive( true );
871.                 controllerObject.name = controllerPrefab.name + "_" + this.name;
872.                 controllerObject.layer = gameObject.layer;
873.                 controllerObject.tag = gameObject.tag;
874.                 AttachObject( controllerObject );
875.                 controller.TriggerHapticPulse( 800 );
876.  
877.                 // If the player's scale has been changed the object to attach will be the wrong size.
878.                 // To fix this we change the object's scale back to its original, pre-attach scale.
879.                 controllerObject.transform.localScale = controllerPrefab.transform.localScale;
880.  
881.                 this.BroadcastMessage( "OnHandInitialized", index, SendMessageOptions.DontRequireReceiver ); // let child objects know we've initialized
882.             }
883.         }
884.     }
885.  
886. #if UNITY_EDITOR
887.     //-------------------------------------------------------------------------
888.     [UnityEditor.CustomEditor( typeof( Hand ) )]
889.     public class HandEditor : UnityEditor.Editor
890.     {
891.         //-------------------------------------------------
892.         // Custom Inspector GUI allows us to click from within the UI
893.         //-------------------------------------------------
894.         public override void OnInspectorGUI()
895.         {
896.             DrawDefaultInspector();
897.  
898.             Hand hand = (Hand)target;
899.  
900.             if ( hand.otherHand )
901.             {
902.                 if ( hand.otherHand.otherHand != hand )
903.                 {
904.                     UnityEditor.EditorGUILayout.HelpBox( "The otherHand of this Hand's otherHand is not this Hand.", UnityEditor.MessageType.Warning );
905.                 }
906.  
907.                 if ( hand.startingHandType == Hand.HandType.Left && hand.otherHand.startingHandType != Hand.HandType.Right )
908.                 {
909.                     UnityEditor.EditorGUILayout.HelpBox( "This is a left Hand but otherHand is not a right Hand.", UnityEditor.MessageType.Warning );
910.                 }
911.  
912.                 if ( hand.startingHandType == Hand.HandType.Right && hand.otherHand.startingHandType != Hand.HandType.Left )
913.                 {
914.                     UnityEditor.EditorGUILayout.HelpBox( "This is a right Hand but otherHand is not a left Hand.", UnityEditor.MessageType.Warning );
915.                 }
916.  
917.                 if ( hand.startingHandType == Hand.HandType.Any && hand.otherHand.startingHandType != Hand.HandType.Any )
918.                 {
919.                     UnityEditor.EditorGUILayout.HelpBox( "This is an any-handed Hand but otherHand is not an any-handed Hand.", UnityEditor.MessageType.Warning );
920.                 }
921.             }
922.         }
923.     }
924. #endif
925. }
926.  

Thanks;
Arthur

 

just out of curiosity,

Code (CSharp):

1. hand.controller != null && controller.GetHairTriggerDown()

you check controller on your hand reference isn't null but then go and call boolean method on separate controller reference (I'm not familiar with the steam vr api), does it automatically provide reference to controller? because it doesn't look like anywhere in your code you're assigning the controller reference.

Code (CSharp):

1. private SteamVR_Controller.Device controller;

wouldn't it be better to get rid of it and use

Code (CSharp):

1. hand.controller != null && hand.controller.GetHairTriggerDown()