API reference

HandGrabInteractor Class

Extends PointerInteractor< HandGrabInteractor, HandGrabInteractable >
Implements 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

FingersStrength : float
[Get]
Implementation of IHandGrabState.FingersStrength; for details, please refer to the related documentation provided for that interface.
Signature 
float FingersStrength
Hand : IHand
[Get]
Implementation of IHandGrabInteractor.Hand; for details, please refer to the related documentation provided for that interface.
Signature 
IHand Hand
HandGrabApi : HandGrabAPI
[Get]
Implementation of IHandGrabInteractor.HandGrabApi; for details, please refer to the related documentation provided for that interface.
Signature 
HandGrabAPI HandGrabApi
HandGrabTarget : HandGrabTarget
[Get]
The HandGrab.HandGrabTarget used by this interactor when grabbing.
Signature 
HandGrabTarget HandGrabTarget
HoverOnZeroStrength : bool
[Get][Set]
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.GetFingerPinchStrength(HandFinger).
Signature 
bool HoverOnZeroStrength
IsGrabbing : bool
[Get]
Implementation of IHandGrabState.IsGrabbing; for details, please refer to the related documentation provided for that interface.
Signature 
virtual bool IsGrabbing
Movement : IMovement
[Get][Set]
The IMovement generated as a result of interacting with an interactable.
This is created by the interactable's DistanceHandGrabInteractable.MovementProvider.
Signature 
IMovement Movement
MovementFinished : bool
[Get][Set]
Indicates whether or not the current Movement has finished.
Signature 
bool MovementFinished
PalmPoint : Transform
[Get]
Implementation of IHandGrabInteractor.PalmPoint; for details, please refer to the related documentation provided for that interface.
Signature 
Transform PalmPoint
PinchPoint : Transform
[Get]
Implementation of IHandGrabInteractor.PinchPoint; for details, please refer to the related documentation provided for that interface.
Signature 
Transform PinchPoint
Rigidbody : Rigidbody
[Get]
Implementation of IRigidbodyRef.Rigidbody; for details, please refer to the related documentation provided for that interface.
Signature 
Rigidbody Rigidbody
SupportedGrabTypes : GrabTypeFlags
[Get]
Implementation of IHandGrabInteractor.SupportedGrabTypes; for details, please refer to the related documentation provided for that interface.
Signature 
GrabTypeFlags SupportedGrabTypes
TargetInteractable : IHandGrabInteractable
[Get]
Implementation of IHandGrabInteractor.TargetInteractable; for details, please refer to the related documentation provided for that interface.
Signature 
IHandGrabInteractable TargetInteractable
VelocityCalculator : IThrowVelocityCalculator
[Get][Set]
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.
Signature 
IThrowVelocityCalculator VelocityCalculator
WristPoint : Transform
[Get]
Implementation of IHandGrabInteractor.WristPoint; for details, please refer to the related documentation provided for that interface.
Signature 
Transform WristPoint
WristStrength : float
[Get]
Implementation of IHandGrabState.WristStrength; for details, please refer to the related documentation provided for that interface.
Signature 
float WristStrength
WristToGrabPoseOffset : Pose
[Get]
Implementation of IHandGrabState.WristToGrabPoseOffset; for details, please refer to the related documentation provided for that interface.
Signature 
Pose WristToGrabPoseOffset

Protected Methods

Awake ()
Signature 
override void Awake()
Returns
override void
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.
Signature 
override HandGrabInteractable ComputeCandidate()
Returns
override HandGrabInteractable  The best interactable to snap the hand to.
ComputePointerPose ()
Signature 
override Pose ComputePointerPose()
Returns
override Pose
ComputeShouldSelect ()
Signature 
override bool ComputeShouldSelect()
Returns
override bool
ComputeShouldUnselect ()
Signature 
override bool ComputeShouldUnselect()
Returns
override bool
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.
Signature 
override void DoHoverUpdate()
Returns
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.
Signature 
override void DoSelectUpdate()
Returns
override void
HandlePointerEventRaised ( evt )
Signature 
override void HandlePointerEventRaised(PointerEvent evt)
Parameters
evt: PointerEvent
Returns
override void
InteractableSelected ( 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.
Signature 
override void InteractableSelected(HandGrabInteractable interactable)
Parameters
interactable: HandGrabInteractable  The selected interactable
Returns
override void
InteractableSet ( interactable )
Signature 
override void InteractableSet(HandGrabInteractable interactable)
Parameters
interactable: HandGrabInteractable
Returns
override void
InteractableUnselected ( interactable )
When releasing an active interactable, calculate the releasing point in similar fashion to InteractableSelected.
Signature 
override void InteractableUnselected(HandGrabInteractable interactable)
Parameters
interactable: HandGrabInteractable  The released interactable
Returns
override void
InteractableUnset ( interactable )
Signature 
override void InteractableUnset(HandGrabInteractable interactable)
Parameters
interactable: HandGrabInteractable
Returns
override void
Reset ()
Signature 
virtual void Reset()
Returns
void
Start ()
Signature 
override void Start()
Returns
override void

Methods

CanSelect ( interactable )
Overrides Interactor<TInteractor, TInteractable>.CanSelect(TInteractable), augmenting the behavior of that base method with an additional call to HandGrabInteraction.CanInteractWith(IHandGrabInteractor, IHandGrabInteractable), which confirms the presence of hand-specific requirements for valid hand interaction.
Signature 
override bool CanSelect(HandGrabInteractable interactable)
Parameters
interactable: HandGrabInteractable  The interactable
Returns
override bool  True if it is possible for this interactable to select interactable , false otherwise
ForceRelease ()
Forces the interactor to deselect the currently grabbed HandGrabInteractable (if any).
Signature 
void ForceRelease()
Returns
void
ForceSelect ( interactable , allowManualRelease )
Forces the interactor to select the passed HandGrabInteractable, which will be grabbed in the next interaction iteration.
Signature 
void ForceSelect(HandGrabInteractable interactable, bool allowManualRelease=false)
Parameters
interactable: HandGrabInteractable  The interactable to grab.
allowManualRelease: bool  If false, the interactable can only be released by calling ForceRelease.
Returns
void
GrabbingFingers ()
Implementation of IHandGrabState.GrabbingFingers; for details, please refer to the related documentation provided for that interface.
Signature 
HandFingerFlags GrabbingFingers()
Returns
HandFingerFlags
InjectAllHandGrabInteractor ( handGrabApi , grabOrigin , hand , rigidbody , supportedGrabTypes )
Convenience method combining InjectHandGrabApi(HandGrabAPI), InjectDistantCandidateComputer(DistantCandidateComputer<DistanceHandGrabInteractor, DistanceHandGrabInteractable>), InjectGrabOrigin(Transform), /// InjectHand(IHand), and InjectSupportedGrabTypes(GrabTypeFlags).
This method exists to support Interaction SDK's dependency injection pattern and is not needed for typical Unity Editor-based usage.
Signature 
void InjectAllHandGrabInteractor(HandGrabAPI handGrabApi, Transform grabOrigin, IHand hand, Rigidbody rigidbody, GrabTypeFlags supportedGrabTypes)
Parameters
handGrabApi: HandGrabAPI
grabOrigin: Transform
hand: IHand
rigidbody: Rigidbody
supportedGrabTypes: GrabTypeFlags
Returns
void
InjectGrabOrigin ( 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.
Signature 
void InjectGrabOrigin(Transform grabOrigin)
Parameters
grabOrigin: Transform
Returns
void
InjectHand ( 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.
Signature 
void InjectHand(IHand hand)
Parameters
hand: IHand
Returns
void
InjectHandGrabApi ( 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.
Signature 
void InjectHandGrabApi(HandGrabAPI handGrabAPI)
Parameters
handGrabAPI: HandGrabAPI
Returns
void
InjectOptionalGripCollider ( 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.
Signature 
void InjectOptionalGripCollider(Collider gripCollider)
Parameters
gripCollider: Collider
Returns
void
InjectOptionalGripPoint ( 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.
Signature 
void InjectOptionalGripPoint(Transform gripPoint)
Parameters
gripPoint: Transform
Returns
void
InjectOptionalPinchCollider ( 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.
Signature 
void InjectOptionalPinchCollider(Collider pinchCollider)
Parameters
pinchCollider: Collider
Returns
void
InjectOptionalPinchPoint ( 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.
Signature 
void InjectOptionalPinchPoint(Transform pinchPoint)
Parameters
pinchPoint: Transform
Returns
void
InjectOptionalVelocityCalculator ( 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.
Signature 
void InjectOptionalVelocityCalculator(IThrowVelocityCalculator velocityCalculator)
Parameters
velocityCalculator: IThrowVelocityCalculator
Returns
void
InjectRigidbody ( 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.
Signature 
void InjectRigidbody(Rigidbody rigidbody)
Parameters
rigidbody: Rigidbody
Returns
void
InjectSupportedGrabTypes ( 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.
Signature 
void InjectSupportedGrabTypes(GrabTypeFlags supportedGrabTypes)
Parameters
supportedGrabTypes: GrabTypeFlags
Returns
void
SetComputeCandidateOverride ( computeCandidate , shouldClearOverrideOnSelect )
Overrides the interactor's ComputeCandidate() method with a new method.
This method itself is an override Interactor<TInteractor, TInteractable>.SetComputeCandidateOverride(Func<TInteractable>, bool), encapsulating the base behavior.
Signature 
override void SetComputeCandidateOverride(Func< HandGrabInteractable > computeCandidate, bool shouldClearOverrideOnSelect=true)
Parameters
computeCandidate: Func< HandGrabInteractable >  The method used instead of the interactable's existing ComputeCandidate() method.
shouldClearOverrideOnSelect: bool  If true, clear the computeCandidate function once you select an interactable.
Returns
override void
Unselect ()
Overrides Interactor<TInteractor, TInteractable>.Unselect, augmenting the base behavior to ensure correct handling of overrides set with Interactor<TInteractor, TInteractable>.SetComputeShouldUnselectOverride(Func<bool>, bool).
Signature 
override void Unselect()
Returns
override void
Nav Logo
Virtual reality / Meta Horizon
Virtual reality / Meta Horizon
Virtual reality / Meta Horizon
English (US)
© 2026 Meta