Off Hand Grab Stopped Working Please Help[SOLVED]

unity 2019.2.3
oculus integration 13 or 14
I have a Mac and use the oculus quest

The OffHand Grab stopped working.
I can't even begin to guess whats wrong it worked one day and not the next.
I was working with external scripts that accessed the grabble but it worked even then. distance grabbable and grabbable both aren't working. I can grab with each controller. Just can't off hand grab. which is how you grab object out of other hand thats holding the object right?


I tested to see if the allow off hand grab bool changed to false when I grabbed an object and it doesn't.
I reimported the grabber, grabbable and distance grabbable still not working.

Here are my scripts.

Grabbable.cs

Code (CSharp):

1. using System;
2. using UnityEngine;
3.  
4. /// <summary>
5. /// An object that can be grabbed and thrown by OVRGrabber.
6. /// </summary>
7. public class OVRGrabbable : MonoBehaviour
8. {
9.     [SerializeField]
10.     protected bool m_allowOffhandGrab = true;
11.     [SerializeField]
12.     protected bool m_snapPosition = false;
13.     [SerializeField]
14.     protected bool m_snapOrientation = false;
15.     [SerializeField]
16.     protected Transform m_snapOffset;
17.     [SerializeField]
18.     protected Collider[] m_grabPoints = null;
19.  
20.     protected bool m_grabbedKinematic = false;
21.     protected Collider m_grabbedCollider = null;
22.     protected OVRGrabber m_grabbedBy = null;
23.  
24.     /// <summary>
25.     /// If true, the object can currently be grabbed.
26.     /// </summary>
27.     public bool allowOffhandGrab
28.     {
29.         get { return m_allowOffhandGrab; }
30.     }
31.  
32.     /// <summary>
33.     /// If true, the object is currently grabbed.
34.     /// </summary>
35.     public bool isGrabbed
36.     {
37.         get { return m_grabbedBy != null; }
38.     }
39.  
40.     /// <summary>
41.     /// If true, the object's position will snap to match snapOffset when grabbed.
42.     /// </summary>
43.     public bool snapPosition
44.     {
45.         get { return m_snapPosition; }
46.     }
47.  
48.     /// <summary>
49.     /// If true, the object's orientation will snap to match snapOffset when grabbed.
50.     /// </summary>
51.     public bool snapOrientation
52.     {
53.         get { return m_snapOrientation; }
54.     }
55.  
56.     /// <summary>
57.     /// An offset relative to the OVRGrabber where this object can snap when grabbed.
58.     /// </summary>
59.     public Transform snapOffset
60.     {
61.         get { return m_snapOffset; }
62.     }
63.  
64.     /// <summary>
65.     /// Returns the OVRGrabber currently grabbing this object.
66.     /// </summary>
67.     public OVRGrabber grabbedBy
68.     {
69.         get { return m_grabbedBy; }
70.     }
71.  
72.     /// <summary>
73.     /// The transform at which this object was grabbed.
74.     /// </summary>
75.     public Transform grabbedTransform
76.     {
77.         get { return m_grabbedCollider.transform; }
78.     }
79.  
80.     /// <summary>
81.     /// The Rigidbody of the collider that was used to grab this object.
82.     /// </summary>
83.     public Rigidbody grabbedRigidbody
84.     {
85.         get { return m_grabbedCollider.attachedRigidbody; }
86.     }
87.  
88.     /// <summary>
89.     /// The contact point(s) where the object was grabbed.
90.     /// </summary>
91.     public Collider[] grabPoints
92.     {
93.         get { return m_grabPoints; }
94.     }
95.  
96.     /// <summary>
97.     /// Notifies the object that it has been grabbed.
98.     /// </summary>
99.     virtual public void GrabBegin(OVRGrabber hand, Collider grabPoint)
100.     {
101.         m_grabbedBy = hand;
102.         m_grabbedCollider = grabPoint;
103.         gameObject.GetComponent<Rigidbody>().isKinematic = true;
104.     }
105.  
106.     /// <summary>
107.     /// Notifies the object that it has been released.
108.     /// </summary>
109.     virtual public void GrabEnd(Vector3 linearVelocity, Vector3 angularVelocity)
110.     {
111.         Rigidbody rb = gameObject.GetComponent<Rigidbody>();
112.         rb.isKinematic = m_grabbedKinematic;
113.         rb.velocity = linearVelocity;
114.         rb.angularVelocity = angularVelocity;
115.         m_grabbedBy = null;
116.         m_grabbedCollider = null;
117.     }
118.  
119.     void Awake()
120.     {
121.         if (m_grabPoints.Length == 0)
122.         {
123.             // Get the collider from the grabbable
124.             Collider collider = this.GetComponent<Collider>();
125.             if (collider == null)
126.             {
127.                 throw new ArgumentException("Grabbables cannot have zero grab points and no collider -- please add a grab point or collider.");
128.             }
129.  
130.             // Create a default grab point
131.             m_grabPoints = new Collider[1] { collider };
132.         }
133.     }
134.  
135.     protected virtual void Start()
136.     {
137.         m_grabbedKinematic = GetComponent<Rigidbody>().isKinematic;
138.     }
139.  
140.     void OnDestroy()
141.     {
142.         if (m_grabbedBy != null)
143.         {
144.             // Notify the hand to release destroyed grabbables
145.             m_grabbedBy.ForceRelease(this);
146.         }
147.     }
148. }

And this is the Grabber.cs

Code (CSharp):

1. using System.Collections;
2. using System.Collections.Generic;
3. using UnityEngine;
4. using UnityEngine.UI;
5.  
6. /// <summary>
7. /// Allows grabbing and throwing of objects with the OVRGrabbable component on them.
8. /// </summary>
9. [RequireComponent(typeof(Rigidbody))]
10. public class OVRGrabber : MonoBehaviour
11. {
12.  
13.     [HideInInspector] public bool inhand;
14.     // Grip trigger thresholds for picking up objects, with some hysteresis.
15.     public float grabBegin = 0.55f;
16.     public float grabEnd = 0.35f;
17.  
18.     bool alreadyUpdated = false;
19.  
20.     // Demonstrates parenting the held object to the hand's transform when grabbed.
21.     // When false, the grabbed object is moved every FixedUpdate using MovePosition.
22.     // Note that MovePosition is required for proper physics simulation. If you set this to true, you can
23.     // easily observe broken physics simulation by, for example, moving the bottom cube of a stacked
24.     // tower and noting a complete loss of friction.
25.     [SerializeField]
26.     protected bool m_parentHeldObject = false;
27.  
28.     // If true, will move the hand to the transform specified by m_parentTransform, using MovePosition in
29.     // FixedUpdate. This allows correct physics behavior, at the cost of some latency.
30.     // (If false, the hand can simply be attached to the hand anchor, which updates position in LateUpdate,
31.     // gaining us a few ms of reduced latency.)
32.     [SerializeField]
33.     protected bool m_moveHandPosition = false;
34.  
35.     // Child/attached transforms of the grabber, indicating where to snap held objects to (if you snap them).
36.     // Also used for ranking grab targets in case of multiple candidates.
37.     [SerializeField]
38.     protected Transform m_gripTransform = null;
39.     // Child/attached Colliders to detect candidate grabbable objects.
40.     [SerializeField]
41.     protected Collider[] m_grabVolumes = null;
42.  
43.     // Should be OVRInput.Controller.LTouch or OVRInput.Controller.RTouch.
44.     [SerializeField]
45.     protected OVRInput.Controller m_controller;
46.  
47.     public OVRInput.Controller GetController()
48.     {
49.         return m_controller;
50.     }
51.  
52.     [SerializeField]
53.     protected Transform m_parentTransform;
54.  
55.     [SerializeField]
56.     protected GameObject m_player;
57.  
58.     protected bool m_grabVolumeEnabled = true;
59.     protected Vector3 m_lastPos;
60.     protected Quaternion m_lastRot;
61.     protected Quaternion m_anchorOffsetRotation;
62.     protected Vector3 m_anchorOffsetPosition;
63.     protected float m_prevFlex;
64.     protected OVRGrabbable m_grabbedObj = null;
65.     protected Vector3 m_grabbedObjectPosOff;
66.     protected Quaternion m_grabbedObjectRotOff;
67.     protected Dictionary<OVRGrabbable, int> m_grabCandidates = new Dictionary<OVRGrabbable, int>();
68.     protected bool m_operatingWithoutOVRCameraRig = true;
69.  
70.     /// <summary>
71.     /// The currently grabbed object.
72.     /// </summary>
73.     public OVRGrabbable grabbedObject
74.     {
75.         get { return m_grabbedObj; }
76.     }
77.  
78.     public void ForceRelease(OVRGrabbable grabbable)
79.     {
80.         bool canRelease = (
81.             (m_grabbedObj != null) &&
82.             (m_grabbedObj == grabbable)
83.         );
84.         if (canRelease)
85.         {
86.             GrabEnd();
87.         }
88.     }
89.  
90.     protected virtual void Awake()
91.     {
92.         m_anchorOffsetPosition = transform.localPosition;
93.         m_anchorOffsetRotation = transform.localRotation;
94.  
95.         if(!m_moveHandPosition)
96.         {
97.             // If we are being used with an OVRCameraRig, let it drive input updates, which may come from Update or FixedUpdate.
98.             OVRCameraRig rig = transform.GetComponentInParent<OVRCameraRig>();
99.             if (rig != null)
100.             {
101.                 rig.UpdatedAnchors += (r) => {OnUpdatedAnchors();};
102.                 m_operatingWithoutOVRCameraRig = false;
103.             }
104.         }
105.     }
106.  
107.     protected virtual void Start()
108.     {
109.         m_lastPos = transform.position;
110.         m_lastRot = transform.rotation;
111.         if(m_parentTransform == null)
112.         {
113.             if(gameObject.transform.parent != null)
114.             {
115.                 m_parentTransform = gameObject.transform.parent.transform;
116.             }
117.             else
118.             {
119.                 m_parentTransform = new GameObject().transform;
120.                 m_parentTransform.position = Vector3.zero;
121.                 m_parentTransform.rotation = Quaternion.identity;
122.             }
123.         }
124.         // We're going to setup the player collision to ignore the hand collision.
125.         SetPlayerIgnoreCollision(gameObject, true);
126.     }
127.  
128.     virtual public void Update()
129.     {
130.         alreadyUpdated = false;
131.  
132.     }
133.  
134.     virtual public void FixedUpdate()
135.     {
136.         if (m_operatingWithoutOVRCameraRig)
137.         {
138.             OnUpdatedAnchors();
139.         }
140.     }
141.  
142.     // Hands follow the touch anchors by calling MovePosition each frame to reach the anchor.
143.     // This is done instead of parenting to achieve workable physics. If you don't require physics on
144.     // your hands or held objects, you may wish to switch to parenting.
145.     void OnUpdatedAnchors()
146.     {
147.         // Don't want to MovePosition multiple times in a frame, as it causes high judder in conjunction
148.         // with the hand position prediction in the runtime.
149.         if (alreadyUpdated) return;
150.         alreadyUpdated = true;
151.  
152.         Vector3 destPos = m_parentTransform.TransformPoint(m_anchorOffsetPosition);
153.         Quaternion destRot = m_parentTransform.rotation * m_anchorOffsetRotation;
154.  
155.         if (m_moveHandPosition)
156.         {
157.             GetComponent<Rigidbody>().MovePosition(destPos);
158.             GetComponent<Rigidbody>().MoveRotation(destRot);
159.         }
160.  
161.         if (!m_parentHeldObject)
162.         {
163.             MoveGrabbedObject(destPos, destRot);
164.         }
165.  
166.         m_lastPos = transform.position;
167.         m_lastRot = transform.rotation;
168.  
169.         float prevFlex = m_prevFlex;
170.         // Update values from inputs
171.         m_prevFlex = OVRInput.Get(OVRInput.Axis1D.PrimaryHandTrigger, m_controller);
172.  
173.         CheckForGrabOrRelease(prevFlex);
174.     }
175.  
176.     void OnDestroy()
177.     {
178.         if (m_grabbedObj != null)
179.         {
180.             GrabEnd();
181.         }
182.     }
183.  
184.     void OnTriggerEnter(Collider otherCollider)
185.     {
186.         // Get the grab trigger
187.         OVRGrabbable grabbable = otherCollider.GetComponent<OVRGrabbable>() ?? otherCollider.GetComponentInParent<OVRGrabbable>();
188.         if (grabbable == null) return;
189.  
190.         // Add the grabbable
191.         int refCount = 0;
192.         m_grabCandidates.TryGetValue(grabbable, out refCount);
193.         m_grabCandidates[grabbable] = refCount + 1;
194.     }
195.  
196.     void OnTriggerExit(Collider otherCollider)
197.     {
198.         OVRGrabbable grabbable = otherCollider.GetComponent<OVRGrabbable>() ?? otherCollider.GetComponentInParent<OVRGrabbable>();
199.         if (grabbable == null) return;
200.  
201.         // Remove the grabbable
202.         int refCount = 0;
203.         bool found = m_grabCandidates.TryGetValue(grabbable, out refCount);
204.         if (!found)
205.         {
206.             return;
207.         }
208.  
209.         if (refCount > 1)
210.         {
211.             m_grabCandidates[grabbable] = refCount - 1;
212.         }
213.         else
214.         {
215.             m_grabCandidates.Remove(grabbable);
216.         }
217.     }
218.  
219.     protected void CheckForGrabOrRelease(float prevFlex)
220.     {
221.         if ((m_prevFlex >= grabBegin) && (prevFlex < grabBegin))
222.         {
223.             GrabBegin();
224.         }
225.         else if ((m_prevFlex <= grabEnd) && (prevFlex > grabEnd))
226.         {
227.             GrabEnd();
228.         }
229.     }
230.  
231.     protected virtual void GrabBegin()
232.     {
233.    
234.         float closestMagSq = float.MaxValue;
235.         OVRGrabbable closestGrabbable = null;
236.         Collider closestGrabbableCollider = null;
237.  
238.         // Iterate grab candidates and find the closest grabbable candidate
239.         foreach (OVRGrabbable grabbable in m_grabCandidates.Keys)
240.         {
241.             bool canGrab = !(grabbable.isGrabbed && !grabbable.allowOffhandGrab);
242.             if (!canGrab)
243.             {
244.                 continue;
245.             }
246.  
247.             for (int j = 0; j < grabbable.grabPoints.Length; ++j)
248.             {
249.                 Collider grabbableCollider = grabbable.grabPoints[j];
250.                 // Store the closest grabbable
251.                 Vector3 closestPointOnBounds = grabbableCollider.ClosestPointOnBounds(m_gripTransform.position);
252.                 float grabbableMagSq = (m_gripTransform.position - closestPointOnBounds).sqrMagnitude;
253.                 if (grabbableMagSq < closestMagSq)
254.                 {
255.                     closestMagSq = grabbableMagSq;
256.                     closestGrabbable = grabbable;
257.                     closestGrabbableCollider = grabbableCollider;
258.                 }
259.             }
260.         }
261.  
262.         // Disable grab volumes to prevent overlaps
263.         GrabVolumeEnable(false);
264.  
265.         if (closestGrabbable != null)
266.         {
267.             if (closestGrabbable.isGrabbed)
268.             {
269.                 closestGrabbable.grabbedBy.OffhandGrabbed(closestGrabbable);
270.             }
271.  
272.             m_grabbedObj = closestGrabbable;
273.             m_grabbedObj.GrabBegin(this, closestGrabbableCollider);
274.  
275.             m_lastPos = transform.position;
276.             m_lastRot = transform.rotation;
277.  
278.             // Set up offsets for grabbed object desired position relative to hand.
279.             if(m_grabbedObj.snapPosition)
280.             {
281.                 m_grabbedObjectPosOff = m_gripTransform.localPosition;
282.                 if(m_grabbedObj.snapOffset)
283.                 {
284.                     Vector3 snapOffset = m_grabbedObj.snapOffset.position;
285.                     if (m_controller == OVRInput.Controller.LTouch) snapOffset.x = -snapOffset.x;
286.                     m_grabbedObjectPosOff += snapOffset;
287.                 }
288.             }
289.             else
290.             {
291.                 Vector3 relPos = m_grabbedObj.transform.position - transform.position;
292.                 relPos = Quaternion.Inverse(transform.rotation) * relPos;
293.                 m_grabbedObjectPosOff = relPos;
294.             }
295.  
296.             if (m_grabbedObj.snapOrientation)
297.             {
298.                 m_grabbedObjectRotOff = m_gripTransform.localRotation;
299.                 if(m_grabbedObj.snapOffset)
300.                 {
301.                     m_grabbedObjectRotOff = m_grabbedObj.snapOffset.rotation * m_grabbedObjectRotOff;
302.                 }
303.             }
304.             else
305.             {
306.                 Quaternion relOri = Quaternion.Inverse(transform.rotation) * m_grabbedObj.transform.rotation;
307.                 m_grabbedObjectRotOff = relOri;
308.             }
309.  
310.             // Note: force teleport on grab, to avoid high-speed travel to dest which hits a lot of other objects at high
311.             // speed and sends them flying. The grabbed object may still teleport inside of other objects, but fixing that
312.             // is beyond the scope of this demo.
313.             MoveGrabbedObject(m_lastPos, m_lastRot, true);
314.             SetPlayerIgnoreCollision(m_grabbedObj.gameObject, true);
315.             if (m_parentHeldObject)
316.             {
317.                 m_grabbedObj.transform.parent = transform;
318.                 inhand = true;
319.  
320.             }
321.         }
322.     }
323.  
324.     protected virtual void MoveGrabbedObject(Vector3 pos, Quaternion rot, bool forceTeleport = false)
325.     {
326.         if (m_grabbedObj == null)
327.         {
328.             return;
329.         }
330.  
331.         Rigidbody grabbedRigidbody = m_grabbedObj.grabbedRigidbody;
332.         Vector3 grabbablePosition = pos + rot * m_grabbedObjectPosOff;
333.         Quaternion grabbableRotation = rot * m_grabbedObjectRotOff;
334.  
335.         if (forceTeleport)
336.         {
337.             grabbedRigidbody.transform.position = grabbablePosition;
338.             grabbedRigidbody.transform.rotation = grabbableRotation;
339.         }
340.         else
341.         {
342.             grabbedRigidbody.MovePosition(grabbablePosition);
343.             grabbedRigidbody.MoveRotation(grabbableRotation);
344.         }
345.     }
346.  
347.     protected void GrabEnd()
348.     {
349.  
350.         if (m_grabbedObj != null)
351.  
352.         {
353.  
354.             OVRPose localPose = new OVRPose { position = OVRInput.GetLocalControllerPosition(m_controller), orientation = OVRInput.GetLocalControllerRotation(m_controller) };
355.             OVRPose offsetPose = new OVRPose { position = m_anchorOffsetPosition, orientation = m_anchorOffsetRotation };
356.             localPose = localPose * offsetPose;
357.  
358.             OVRPose trackingSpace = transform.ToOVRPose() * localPose.Inverse();
359.             Vector3 linearVelocity = trackingSpace.orientation * OVRInput.GetLocalControllerVelocity(m_controller);
360.             Vector3 angularVelocity = trackingSpace.orientation * OVRInput.GetLocalControllerAngularVelocity(m_controller);
361.  
362.             GrabbableRelease(linearVelocity, angularVelocity);
363.         }
364.  
365.         // Re-enable grab volumes to allow overlap events
366.         GrabVolumeEnable(true);
367.     }
368.  
369.     protected void GrabbableRelease(Vector3 linearVelocity, Vector3 angularVelocity)
370.     {
371.         m_grabbedObj.GrabEnd(linearVelocity, angularVelocity);
372.         if(m_parentHeldObject && m_grabbedObj.tag != "Inventory")
373.          m_grabbedObj.transform.parent = null;
374.         SetPlayerIgnoreCollision(m_grabbedObj.gameObject, false);
375.         m_grabbedObj = null;
376.         inhand = false;
377.     }
378.  
379.     protected virtual void GrabVolumeEnable(bool enabled)
380.     {
381.         if (m_grabVolumeEnabled == enabled)
382.         {
383.             return;
384.         }
385.  
386.         m_grabVolumeEnabled = enabled;
387.         for (int i = 0; i < m_grabVolumes.Length; ++i)
388.         {
389.             Collider grabVolume = m_grabVolumes[i];
390.             grabVolume.enabled = m_grabVolumeEnabled;
391.         }
392.  
393.         if (!m_grabVolumeEnabled)
394.         {
395.             m_grabCandidates.Clear();
396.         }
397.     }
398.  
399.     protected virtual void OffhandGrabbed(OVRGrabbable grabbable)
400.     {
401.         if (m_grabbedObj == grabbable)
402.         {
403.             GrabbableRelease(Vector3.zero, Vector3.zero);
404.         }
405.     }
406.  
407.     protected void SetPlayerIgnoreCollision(GameObject grabbable, bool ignore)
408.     {
409.         if (m_player != null)
410.         {
411.             Collider[] playerColliders = m_player.GetComponentsInChildren<Collider>();
412.             foreach (Collider pc in playerColliders)
413.             {
414.                 Collider[] colliders = grabbable.GetComponentsInChildren<Collider>();
415.                 foreach (Collider c in colliders)
416.                 {
417.                     Physics.IgnoreCollision(c, pc, ignore);
418.                 }
419.             }
420.         }
421.     }
422. }
423.  

Would this script I wrote effect it in anyway? It just repositions the grabbed object that the scripts attached to no other object thats grabbable. But the off hand grab was working when I had this script too.

Code (CSharp):

1. using System.Collections;
2. using System.Collections.Generic;
3. using UnityEngine;
4. using UnityEngine.UI;
5.  
6. public class ReleasedObjects : OVRGrabbable
7. {
8.  
9.  
10.  
11.  
12.     public Transform handler;
13.     public GameObject parentObject;
14.     [HideInInspector] public bool check;
15.  
16.  
17.  
18.  
19.  
20.  
21.  
22.  
23.  
24.     public void OnTriggerStay(Collider store)
25.     {
26.         if(store.gameObject.tag == "Sheath")
27.         {
28.             check = true;
29.  
30.  
31.         }
32.         }
33.  
34.  
35.  
36.     public override void GrabEnd(Vector3 linearVelocity, Vector3 angularVelocity)
37.     {
38.         if (check == true)
39.         {
40.  
41.  
42.             base.GrabEnd(Vector3.zero, Vector3.zero);
43.             transform.position = handler.transform.position;
44.             transform.rotation = handler.transform.rotation;
45.             gameObject.transform.parent = parentObject.transform;
46.             gameObject.GetComponent<Rigidbody>().isKinematic = true;
47.  
48.         }
49.         else
50.         {
51.             gameObject.GetComponent<Rigidbody>().isKinematic = false;
52.             gameObject.transform.parent = null;
53.         }
54.     }
55.  
56.     public void OnTriggerExit(Collider hand)
57.     {
58.         check = false;
59.      
60.  
61.  
62.     }
63.  
64.  
65.  
66. }
67.  

 

I thank you and I figured it out. the distance grabber doesn't allow offhand grab which is dumb. I had to add the grabber component under the distance grabber component and transfer over what I could from the distance grabber to the ovr grabber component. But all of that worked on the distance grabber scene. I just gotta figure out why its not working in my scene or I need o transfer everything over from one to the other scene.