Develop

Event Wrappers

Updated: Aug 26, 2026

Event wrappers bridge Interaction SDK events to Unity events. You wire them in the Inspector, so a hover, a grab, or a release drives your scene without code.

How event wrappers work

Each wrapper is a component you add to a GameObject. It has one target field. You set that field to the Interaction SDK component you want to listen to. The wrapper then exposes that component’s events as Unity event slots.

A slot holds a list of calls. Each call names a GameObject, a component on it, and a public method. When the event fires, the wrapper runs the calls. Nothing here needs a script.

Each event is a UnityEvent field named in camel case, such as _whenSelect. The Inspector shows the label in title case, so _whenSelect reads as When Select. Use the labels when you wire in the editor. Use the property names when you subscribe from code.

To learn how an interaction moves between the hover and select states, see Interactor Interactable Lifecycle.

Choose a wrapper

Wrapper	Set its target to	Use it for
`PointableUnityEventWrapper`	An `IPointable`, such as a `Grabbable` or a `PokeInteractable`	Grab, throw, and poke feedback. Each event carries a `PointerEvent`.
`InteractableUnityEventWrapper`	An `IInteractableView`, such as a `PokeInteractable`	Press feedback that follows the state of one interactable.
`InteractorUnityEventWrapper`	An `IInteractorView`, such as a `HandGrabInteractor`	Reacting to a hand or controller instead of to an object.
`ActiveStateUnityEventWrapper`	An `IActiveState`	Turning objects on and off when a state flips.
`PointableCanvasUnityEventWrapper`	A `PointableCanvas`	Selection and highlight events across a Unity UI canvas.

Play a sound when an object is grabbed

This is the no-code path for grab audio. Nine sample props ship this event wiring. It pairs a PointableUnityEventWrapper with the Audio Trigger component described in Audio Trigger.

Point the wrapper at the object’s Grabbable, not at a grab interactable. A prop can carry both a GrabInteractable and a HandGrabInteractable, and both feed the same Grabbable. One wrapper on the Grabbable covers hand grab and controller grab together.

Select your grabbable object. Confirm it has a Grabbable component.
Add a child GameObject and name it Audio.
Add a child of Audio for the grab sound. Add an Audio Source component to it, then add an Audio Trigger component.
In Audio Trigger, fill Audio Clips with one or more clips. Leave Audio Source empty. The component finds the Audio Source on its own GameObject.
Repeat steps 3 and 4 for the release sound. Give it its own clips.
Select the Audio GameObject and add a PointableUnityEventWrapper component.
Drag the Grabbable into the Pointable field.
Under When Select, choose +. Drag in the grab sound GameObject. Pick AudioTrigger, then PlayAudio ().
Under When Unselect, choose +. Drag in the release sound GameObject. Pick the same two entries.

Enter play mode and grab the object. The grab clip plays on select. The release clip plays on unselect.

The finished hierarchy looks like this.

MyProp                             GameObject
├── Grabbable                      component, the Pointable target
├── HandGrabInteractable           child GameObject
├── GrabInteractable               child GameObject
└── Audio                          child GameObject
    ├── PointableUnityEventWrapper component
    │     When Select   -> GrabSound.AudioTrigger.PlayAudio ()
    │     When Unselect -> ReleaseSound.AudioTrigger.PlayAudio ()
    ├── GrabSound                  child GameObject: AudioSource + AudioTrigger
    └── ReleaseSound               child GameObject: AudioSource + AudioTrigger

Five of the nine sample props use a separate Audio child like this. The other four put the wrapper on the prop root. Pointable is an object reference, so the wrapper works from either place.

Four details decide whether this works.

Wire the release sound to When Unselect, not to When Release. When Release fires only when the pointer still hovers the object as the selection ends, so a release away from the object leaves it silent. When Unselect fires on every unselect.
Give each slot its own Audio Trigger. The sample props use one trigger for the grab and a second for the release, because each trigger holds one set of clips.
Pick PlayAudio () from the lower group in the method dropdown. That group drops the PointerEvent argument, which is what lets a method with no parameters receive the call.
Audio Trigger starts playback and nothing else. It has no stop method. To halt a looping clip, wire Stop on the Audio Source component instead.

For working versions, open Box.prefab under the Interaction SDK samples, or the HandGrabExamples scene.

Add a cue for distance grab

Distance grab supports one more cue. Set Pointable to the DistanceHandGrabInteractable and wire When Hover to a hover clip, then wire When Select to a pull clip. The DistanceGrabExamples scene ships this pattern on three props.

Bind to a single interactable like this when you want a sound that belongs to one grab type. Bind to the Grabbable when one sound covers every grab type.

Pointable events

PointableUnityEventWrapper wraps any IPointable. Set Pointable to the target. Every event here carries a PointerEvent payload.

Inspector label	Property	Fires when
When Release	`WhenRelease`	A pointer releases the selection while it still hovers the object.
When Hover	`WhenHover`	A pointer begins to hover.
When Unhover	`WhenUnhover`	A pointer stops hovering.
When Select	`WhenSelect`	A pointer selects the object.
When Unselect	`WhenUnselect`	A pointer releases the selection, even when it no longer hovers the object.
When Move	`WhenMove`	A pointer moves.
When Cancel	`WhenCancel`	The interaction is canceled.

Interactable events

InteractableUnityEventWrapper wraps any IInteractableView. Set Interactable View to the target. These events carry no payload.

The first four report the state of the interactable as a whole. They fire once per state change. A second interactor hovering an already hovered object adds no new When Hover.

Inspector label	Property	Fires when
When Hover	`WhenHover`	The interactable moves from normal to hover.
When Unhover	`WhenUnhover`	The interactable moves from hover to normal.
When Select	`WhenSelect`	The interactable moves from hover to select.
When Unselect	`WhenUnselect`	The interactable moves from select to hover.
When Interactor View Added	`WhenInteractorViewAdded`	Any interactor begins to hover, including a second one.
When Interactor View Removed	`WhenInteractorViewRemoved`	An interactor stops hovering.
When Selecting Interactor View Added	`WhenSelectingInteractorViewAdded`	Any interactor begins to select.
When Selecting Interactor View Removed	`WhenSelectingInteractorViewRemoved`	An interactor stops selecting.

The sample props that drive Audio Trigger through this wrapper are all poke buttons. For grab audio, reach for PointableUnityEventWrapper instead.

Interactor events

InteractorUnityEventWrapper wraps any IInteractorView. Set Interactor View to the target. These events carry no payload.

Inspector label	Property	Fires when
When Enabled	`WhenEnabled`	The interactor moves from disabled to normal.
When Disabled	`WhenDisabled`	The interactor enters the disabled state from any state.
When Hover	`WhenHover`	The interactor moves from normal to hover.
When Unhover	`WhenUnhover`	The interactor moves from hover to normal.
When Select	`WhenSelect`	The interactor moves from hover to select.
When Unselect	`WhenUnselect`	The interactor moves from select to hover.
When Preprocessed	`WhenPreprocessed`	The interactor completes its preprocessing pass, once per frame.
When Processed	`WhenProcessed`	The interactor completes a main processing pass. This runs more than once per frame on some interactors.
When Postprocessed	`WhenPostprocessed`	The interactor completes its postprocessing pass, once per frame.

Active state events

ActiveStateUnityEventWrapper wraps any IActiveState. Set Active State to the target. This wrapper reads the state each frame in Update() and fires on every change.

Inspector label	Property	Fires when
When Activated	`WhenActivated`	The state turns active.
When Deactivated	`WhenDeactivated`	The state turns inactive.

Emit On First Update is enabled by default. On its first update the wrapper treats the previous state as inactive, so it fires When Deactivated before it reads the live state. A state that is already active then fires When Activated in the same frame. Disable the option to react only to later changes.

Pointable canvas events

PointableCanvasUnityEventWrapper reports Unity UI activity for a whole canvas. Set Pointable Canvas to the target. One wrapper replaces per-Selectable wiring across that canvas.

This wrapper exposes no public properties. Wire its events in the Inspector.

Inspector label	Payload	Fires when
When Selected Empty	none	A select lands on the canvas with no `Selectable` hovered.
When Unselected Empty	none	An unselect lands with no `Selectable` hovered.
When Begin Highlight With Object	`GameObject`	A `Selectable` begins to be hovered.
When End Highlight With Object	`GameObject`	A `Selectable` stops being hovered.
When Selected Hovered With Object	`GameObject`	A hovered `Selectable` is selected.
When Unselected Hovered With Object	`GameObject`	A hovered `Selectable` is unselected.

Suppress While Dragging is enabled by default. Selection and highlight events stay quiet while a drag is in progress.

Four of the five wrappers on this page also expose each event as a get-only property. Call AddListener on the property. Assigning to the property does not compile.

// _wrapper is a serialized PointableUnityEventWrapper field.
private void OnEnable()
{
    _wrapper.WhenSelect.AddListener(HandleSelect);
}

private void OnDisable()
{
    _wrapper.WhenSelect.RemoveListener(HandleSelect);
}

private void HandleSelect(PointerEvent evt)
{
    Debug.Log("Grab started");
}

PointableCanvasUnityEventWrapper is the exception. Its events are private fields with no properties, so the Inspector is the only way to reach them.

Reference

For reference information about the components used by event wrappers, see the following links.

Learn more

To configure the clips, volume, and pitch that a wrapper triggers, see Audio Trigger.
To set up the grab interaction itself, see Hand Grab Interactions.
To review the interaction states behind these events, see Interactor Interactable Lifecycle.