Interaction Broadcaster

• InteractionEventChannel.OnEventRaised (shared ScriptableObject asset, raised only when a channel asset is assigned)
• InteractionBroadcaster.OnEventRaised (C# static event)

1. The interactable object, such as a button or grabbable item, detects an interaction event, such as hover, grab, or poke.
2. A handler processes the interaction event, determining the event type.
3. The broadcaster raises the event on the static C# event, and, if a channel asset is assigned, on the InteractionEventChannel as well.
4. All scripts, components, and systems that subscribed receive the event and can respond.

1. In the Project panel, navigate to Packages > Meta XR Interaction SDK Essentials > Runtime > Prefabs > Feedback.
2. Drag FeedbackManager.prefab into the root of your scene Hierarchy.

1. In the Project panel, navigate to Packages > Meta XR Interaction SDK Essentials > Runtime > Prefabs > Feedback.
2. Drag InteractionBroadcaster.prefab into the root of your scene Hierarchy.

1. In the Hierarchy panel, right-click an empty area and select Create Empty.
2. Name the GameObject “InteractionBroadcaster”.
3. In the Inspector, click Add Component and search for InteractionBroadcaster.
4. Assign an InteractionEventChannel ScriptableObject asset to the Event Channel field, or leave it null to use only the static C# event. Interaction SDK ships a default asset in the Project panel at Packages > Meta XR Interaction SDK Essentials > Runtime > DefaultSettings. To make your own, select Assets > Create > Meta > Interaction SDK > Feedback > Interaction Event Channel.

• ScriptableObject channel to share one event source across systems without referencing each other. Assign the same channel asset in the Inspector and subscribe to OnEventRaised in code.
• Static C# event for low-overhead subscription.

• InteractionType, such as HoverStart or UISelectEnd. For the complete list of values, see InteractionType.
• Source GameObject, to watch a single object.
• Interactor, matched on InteractorView, or on _pointerId for pointer-based interactions.

using Oculus.Interaction.Feedback;
using UnityEngine;

public class SelectionLogger : MonoBehaviour
{
    private void OnEnable() => InteractionBroadcaster.OnEventRaised += HandleInteraction;
    private void OnDisable() => InteractionBroadcaster.OnEventRaised -= HandleInteraction;

    private void HandleInteraction(InteractionEvent evt)
    {
        bool isSelectStart = evt._type == InteractionType.SelectStart
            || evt._type == InteractionType.UISelectStart;

        if (!isSelectStart || evt._source == null)
        {
            return;
        }

        // InteractorView is null for UI-origin events.
        Debug.Log($"Selected {evt._source.name}, from UI: {evt.InteractorView == null}");
    }
}

• Always unsubscribe in OnDisable to prevent memory leaks and handle domain reloads, as shown in the SelectionLogger example.
• Use a ScriptableObject channel when you need designer-configurable event routing. Use static events for performance-critical code paths.
• Always null-check _source or InteractorView before accessing.
• For systems that monitor interactions, such as tutorials, analytics, and achievements, subscribe to the centralized broadcaster and filter events rather than attaching listeners to individual interactable objects.

• static InteractionBroadcaster Instance { get; } – Singleton instance of the InteractionBroadcaster
• static event Action<InteractionEvent> OnEventRaised – Static C# event fired when any registered interaction occurs
• static void RegisterCustomInteractionType<TInteractor, TInteractable>() – Registers a custom interactor-interactable pair for automatic event broadcasting
• static void UnregisterCustomInteractionType<TInteractor, TInteractable>() – Stops monitoring a custom interactor-interactable pair
• void RegisterInteractionType<TInteractor, TInteractable>() – Instance method to register a custom interaction type
• void UnregisterInteractionType<TInteractor, TInteractable>() – Instance method to stop monitoring an interaction type

• event Action<InteractionEvent> OnEventRaised – C# event raised by Raise. Subscribe in code. The channel asset itself is assignable in the Inspector, which is how systems share one channel without referencing each other.
• void Raise(in InteractionEvent interactionEvent) – Manually raises an interaction event

• InteractionType _type – The type of interaction. See InteractionType for the complete list of values.
• IInteractorView InteractorView – The interactor that triggered the event. This is null for UI-origin events.
• GameObject _source – The source GameObject that was interacted with. This can be null.
• int _pointerId – Identifier for pointer-based interactions. Defaults to -1 when not applicable.

1. Delete the obsolete MicrogestureScrollProvider component, along with the MicrogestureScrollProvider prefab instance if you used it.
2. Delete any MicrogestureScrollSettings components. These components are obsolete. Any per-ScrollRect overrides they set are ignored.
3. In the Project panel, navigate to Packages > Meta XR Interaction SDK > Runtime > Prefabs > Microgestures and drag MicrogestureScroll.prefab into your Hierarchy. The prefab is a single GameObject carrying DiscreteScrollInputProvider, OVRMicrogestureEventSource, and MicroGestureUnityEventWrapper, with the four swipe events already bound to ScrollUp, ScrollDown, ScrollLeft, and ScrollRight.
4. Assign the interactor that drives scrolling to the Interactor field on DiscreteScrollInputProvider, and your scene’s OVRHand to the Hand field on OVRMicrogestureEventSource. Both ship unset. DiscreteScrollInputProvider asserts at Start() if Interactor is empty.

1. Ensure the InteractionBroadcaster component is active in your scene.
2. Check that Auto Register Interaction Types is enabled on the InteractionBroadcaster component in the Inspector.
   Note: The tooltip reads “If true, standard interaction types (Grab, Poke, Ray) will be automatically registered on enable.” That names a representative subset. For the full set of registered pairs, see How it works.
3. If using custom interactor types, verify you called RegisterCustomInteractionType<TInteractor, TInteractable>() after the broadcaster starts.
4. Add a debug listener to confirm events are firing:

    InteractionBroadcaster.OnEventRaised += (evt) => Debug.Log($"Event: {evt._type}");
   

1. Ensure you call RegisterCustomInteractionType<TInteractor, TInteractable>() in your script’s Start() method, after the broadcaster has initialized.
2. Verify that your custom interactor derives from Interactor<TInteractor, TInteractable> and your custom interactable derives from Interactable<TInteractor, TInteractable>. RegisterCustomInteractionType constrains both type parameters to these base classes, so a type that only implements IInteractor or IInteractable will not compile.

1. On the InteractionBroadcaster component, confirm Auto Register Interaction Types is enabled. The UI pointer hooks are registered alongside the standard interaction types, so no UI events broadcast while this option is off.
2. Select the EventSystem GameObject in the Hierarchy and confirm it has a PointableCanvasModule component. PointableCanvasModule is a Unity PointerInputModule subclass, so exactly one instance must exist in the scene and it belongs on the EventSystem GameObject rather than on a Canvas. If it is missing, click Add Component and search for PointableCanvasModule.
3. If a PointableCanvasModule is also present on a Canvas, remove it. Only one instance can exist in the scene, and it belongs on the EventSystem GameObject.
4. On the EventSystem GameObject, make sure PointableCanvasModule is first in the component list or has Exclusive Mode enabled. Otherwise, you can run into input conflicts.
5. Select your Canvas in the Hierarchy and confirm it has both a PointableCanvas component and a GraphicRaycaster component. PointableCanvas requires that its Canvas has a GraphicRaycaster.
6. If you route Canvas events to UnityEvents, confirm the Canvas also has a PointableCanvasUnityEventWrapper component and that it references the Canvas PointableCanvas.

• To set up Unity Canvas for pointer input, see Unity Canvas Integration.
• To learn about the Feedback Manager, see Feedback Manager.
• To learn about the pointer lifecycle, see Pointer Lifecycle and Pointer Events.
• To learn about Interactors, see Interactor.
• To learn about Interactables, see Interactable.
• To see the broadcaster used in a sample UI, see Creating UIs with UISet.