API reference
HandGrabInteractor Class
Extends PointerInteractor< HandGrabInteractor, HandGrabInteractable >, IHandGrabInteractor, IRigidbodyRef
Enables hand grab for objects within arm's reach that have a GrabInteractable.
When grabbing an object, the hands visually snap to any HandPose you've provided. To enable grab for controllers, use GrabInteractor.
Properties
IHand Hand[Get]
Implementation of IHandGrabInteractor.Hand; for details, please refer to the related documentation provided for that interface.
bool HoverOnZeroStrength[Get]
When enabled, nearby HandGrabInteractables can become candidates even if the finger strength is 0.
"Strength" in this context is a measure of of how similar/different the finger's state is to what the system considers "grabbing"; for a more detailed overview, see the documentation for IHand
IThrowVelocityCalculator VelocityCalculator[Get]
Obsolete: this was used to get and set the interactor's IThrowVelocityCalculator, which is deprecated.
Velocity calculation capabilities are now a feature of Grabbable and should be controlled from there.
IMovement Movement[Get]
The IMovement generated as a result of interacting with an interactable.
This is created by the interactable's DistanceHandGrabInteractable
bool MovementFinished[Get]
Indicates whether or not the current Movement has finished.
HandGrabTarget HandGrabTarget[Get]
The HandGrab.HandGrabTarget used by this interactor when grabbing.
Transform WristPoint[Get]
Implementation of IHandGrabInteractor.WristPoint; for details, please refer to the related documentation provided for that interface.
Transform PinchPoint[Get]
Implementation of IHandGrabInteractor.PinchPoint; for details, please refer to the related documentation provided for that interface.
Transform PalmPoint[Get]
Implementation of IHandGrabInteractor.PalmPoint; for details, please refer to the related documentation provided for that interface.
HandGrabAPI HandGrabApi[Get]
Implementation of IHandGrabInteractor.HandGrabApi; for details, please refer to the related documentation provided for that interface.
GrabTypeFlags SupportedGrabTypes[Get]
Implementation of IHandGrabInteractor.SupportedGrabTypes; for details, please refer to the related documentation provided for that interface.
IHandGrabInteractable TargetInteractable[Get]
Implementation of IHandGrabInteractor.TargetInteractable; for details, please refer to the related documentation provided for that interface.
bool IsGrabbing[Get]
Implementation of IHandGrabState.IsGrabbing; for details, please refer to the related documentation provided for that interface.
float FingersStrength[Get]
Implementation of IHandGrabState.FingersStrength; for details, please refer to the related documentation provided for that interface.
float WristStrength[Get]
Implementation of IHandGrabState.WristStrength; for details, please refer to the related documentation provided for that interface.
Pose WristToGrabPoseOffset[Get]
Implementation of IHandGrabState.WristToGrabPoseOffset; for details, please refer to the related documentation provided for that interface.
Rigidbody Rigidbody[Get]
Implementation of IRigidbodyRef.Rigidbody; for details, please refer to the related documentation provided for that interface.
Member Functions
HandFingerFlags GrabbingFingers ( )
Implementation of IHandGrabState.GrabbingFingers; for details, please refer to the related documentation provided for that interface.
override bool CanSelect
( HandGrabInteractable interactable )
Overrides Interactor<TInteractor, TInteractable>.CanSelect(TInteractable), augmenting the behavior of that base method with an additional call to HandGrabInteraction
Parameters
interactable
The interactable
Returns
True if it is possible for this interactable to select interactable , false otherwise
void ForceSelect
( HandGrabInteractable interactable,
bool allowManualRelease )
Forces the interactor to select the passed HandGrabInteractable, which will be grabbed in the next interaction iteration.
Parameters
interactable
The interactable to grab.
allowManualRelease
If false, the interactable can only be released by calling ForceRelease.
void ForceRelease ( )
Forces the interactor to deselect the currently grabbed HandGrabInteractable (if any).
override void SetComputeCandidateOverride
( Func< HandGrabInteractable > computeCandidate,
bool shouldClearOverrideOnSelect )
Overrides the interactor's ComputeCandidate() method with a new method.
This method itself is an override Interactor<TInteractor, TInteractable>
Parameters
computeCandidate
The method used instead of the interactable's existing ComputeCandidate() method.
shouldClearOverrideOnSelect
If true, clear the computeCandidate function once you select an interactable.
override void Unselect ( )
Overrides Interactor<TInteractor, TInteractable>.Unselect, augmenting the base behavior to ensure correct handling of overrides set with Interactor<TInteractor, TInteractable>
void InjectAllHandGrabInteractor
( HandGrabAPI handGrabApi,
Transform grabOrigin,
IHand hand,
Rigidbody rigidbody,
GrabTypeFlags supportedGrabTypes )
Convenience method combining InjectHandGrabApi(HandGrabAPI), InjectDistantCandidateComputer(DistantCandidateComputer<DistanceHandGrabInteractor,
This method exists to support Interaction SDK's dependency injection pattern and is not needed for typical Unity Editor-based usage.
void InjectHandGrabApi
( HandGrabAPI handGrabAPI )
Adds a HandGrabAPI to a dynamically instantiated GameObject.
This method exists to support Interaction SDK's dependency injection pattern and is not needed for typical Unity Editor-based usage.
void InjectHand
( IHand hand )
Adds an IHand to a dynamically instantiated GameObject.
This method exists to support Interaction SDK's dependency injection pattern and is not needed for typical Unity Editor-based usage.
void InjectRigidbody
( Rigidbody rigidbody )
Adds a Unity Rigidbody to a dynamically instantiated GameObject.
This method exists to support Interaction SDK's dependency injection pattern and is not needed for typical Unity Editor-based usage.
void InjectSupportedGrabTypes
( GrabTypeFlags supportedGrabTypes )
Adds a list of supported grabs to a dynamically instantiated GameObject.
This method exists to support Interaction SDK's dependency injection pattern and is not needed for typical Unity Editor-based usage.
void InjectGrabOrigin
( Transform grabOrigin )
Adds a grab origin to a dynamically instantiated GameObject.
This method exists to support Interaction SDK's dependency injection pattern and is not needed for typical Unity Editor-based usage.
void InjectOptionalGripPoint
( Transform gripPoint )
Adds a grip point to a dynamically instantiated GameObject.
This method exists to support Interaction SDK's dependency injection pattern and is not needed for typical Unity Editor-based usage.
void InjectOptionalGripCollider
( Collider gripCollider )
Adds a grip collider to a dynamically instantiated GameObject.
This method exists to support Interaction SDK's dependency injection pattern and is not needed for typical Unity Editor-based usage.
void InjectOptionalPinchPoint
( Transform pinchPoint )
Adds a pinch point to a dynamically instantiated GameObject.
This method exists to support Interaction SDK's dependency injection pattern and is not needed for typical Unity Editor-based usage.
void InjectOptionalPinchCollider
( Collider pinchCollider )
Adds a pinch collider to a dynamically instantiated GameObject.
This method exists to support Interaction SDK's dependency injection pattern and is not needed for typical Unity Editor-based usage.
void InjectOptionalVelocityCalculator
( IThrowVelocityCalculator velocityCalculator )
Obsolete: adds a IThrowVelocityCalculator to a dynamically instantiated GameObject.
This method exists to support Interaction SDK's dependency injection pattern and is not needed for typical Unity Editor-based usage. Velocity calculation is now a feature of Grabbable and is no longer required by HandGrabInteractor.
Protected Functions
virtual void Reset ( )
override void Awake ( )
override void Start ( )
override void DoHoverUpdate ( )
Each call while the interactor is hovering, it checks whether there is an interaction being hovered and sets the target snap pose to it.
In the HandToObject snapping behaviors this is relevant as the hand can approach the object progressively even before a true grab starts.
override void InteractableSet
( HandGrabInteractable interactable )
override void InteractableUnset
( HandGrabInteractable interactable )
override void DoSelectUpdate ( )
Each call while the hand is selecting/grabbing an interactable, it moves the item to the new position while also attracting it towards the hand if the snapping mode requires it.
In some cases the parameter can be null, for example if the selection was interrupted by another hand grabbing the object. In those cases it will come out of the release state once the grabbing gesture properly finishes.
override void InteractableSelected
( HandGrabInteractable interactable )
When a new interactable is selected, start the grab at the ideal point.
When snapping is involved that can be a point in the interactable offset from the hand which will be stored to progressively reduced it in the next updates, effectively attracting the object towards the hand. When no snapping is involved the point will be the grip point of the hand directly. Note: ideally this code would be in InteractableSelected but it needs to be called before the object is marked as active.
Parameters
interactable
The selected interactable
override void InteractableUnselected
( HandGrabInteractable interactable )
When releasing an active interactable, calculate the releasing point in similar fashion to InteractableSelected.
Parameters
interactable
The released interactable
virtual override void HandlePointerEventRaised
( PointerEvent evt )
virtual override Pose ComputePointerPose ( )
override bool ComputeShouldSelect ( )
override bool ComputeShouldUnselect ( )
override HandGrabInteractable ComputeCandidate ( )
Compute the best interactable to snap to.
In order to do it the method measures the score from the current grip pose to the closes pose in the surfaces of each one of the interactables in the registry. Even though it returns the best interactable, it also saves the entire Snap pose to it in which the exact pose within the surface is already recorded to avoid recalculations within the same frame.
Returns
The best interactable to snap the hand to.
Did you find this page helpful?
Virtual reality / Meta Horizon
Support and legal
Virtual reality / Meta Horizon
Support and legal
Virtual reality / Meta Horizon
Support and legal
English (US)
© 2025 Meta