Feedback Manager

• Event-driven: Listens for interaction events (Hover/Unhover/Select/Unselect/Move/Cancel; also UIHover/UISelect) emitted by interactable objects and UI pointers.
• Rule-based: A FeedbackConfig asset holds an ordered list of rules (first-match wins). Rules can filter by interaction type, Unity Tag, and InteractorKind (Poke, Ray, Grab, HandGrab, and so on).
• Hierarchical overrides: A per-object FeedbackSettings component can suppress feedback or override global rules.
• Modular actions: Each rule runs one or more FeedbackAction ScriptableObjects (for example, haptic clip, sound, VFX).
• Haptics integration: Works with the Haptics SDK for Unity if you want authored clips or controller impulses.

• Set Up Unity for XR development to create a project with the necessary dependencies
• Set up your device to configure and test your project on a headset
• Interaction SDK v81 or later installed.

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

1. In the Hierarchy panel, expand your interaction rig and select an interactor.
2. In the Inspector, verify that the InteractorControllerDecorator component is present. If the component is missing, add it by selecting Add Component > InteractorControllerDecorator.

1. In the Project panel, right-click in your Assets folder and select Create > Interaction SDK > Feedback Config.
2. Name your asset (for example, “MyFeedbackConfig”).
3. Select the asset in the Project panel to view it in the Inspector.
4. In the Rules list, click the + button to add a new rule.
5. Configure each rule with the following properties:
   • Interaction Type: Event type that triggers this rule (for example, HoverStart, SelectEnd, UISelectStart)
   • Tag (optional): Tag name that matches all GameObjects that contain that name
   • Interactor Kind: Interaction type that matches all interaction methods of the same type such as Any, Poke, Ray, Grab, and HandGrab
   • Actions: List of FeedbackAction assets to execute when this rule matches
6. Arrange rules from most specific (tagged, specific interactor kinds) to most general (any tag, any interactor kind). For guidance on rule ordering, see the Best practices section.
7. In the Hierarchy, select the FeedbackManager GameObject.
8. In the Inspector, assign your new FeedbackConfig asset to the Config field.

1. In the Hierarchy, select an interactable GameObject such as a button or grabbable object.
2. In the Inspector, click Add Component and search for FeedbackSettings.
3. Select a Mode:
   • Default: Uses the global rules from the FeedbackConfig
   • Suppress: Blocks all feedback for this object
   • Override: Uses custom feedback actions per interaction type and blocks any global rules for that object.
4. If you selected Override, expand the Overrides section and configure feedback actions for specific interaction types.

public override void Execute(int identifier, GameObject source, FeedbackManager manager) { ... }

using Oculus.Interaction.Feedback;
using UnityEngine;

namespace YourNamespace
{
    [CreateAssetMenu(menuName = "Your Project/Feedback/Audio Feedback")]
    public class AudioFeedbackAction : FeedbackActionSO
    {
        [SerializeField]
        private AudioClip _audioClip;

        [SerializeField, Range(0f, 1f)]
        private float _volume = 0.8f;

        public override void Execute(int identifier, GameObject source, FeedbackManager manager)
        {
            if (_audioClip != null && source != null)
            {
                AudioSource.PlayClipAtPoint(_audioClip, source.transform.position, _volume);
            }
        }
    }
}

1. Right-click in the Project panel and select Create > Your Project > Feedback > Audio Feedback.
2. Assign an AudioClip and adjust the volume.
3. Add the created asset to a rule’s Actions list in your FeedbackConfig.

• static FeedbackManager Instance – Singleton instance of the FeedbackManager
• static bool Exists – Returns true if a FeedbackManager instance exists in the scene
• FeedbackConfig Config – The currently active FeedbackConfig asset
• void PlayHaptics(int sourceId, in HapticPattern pattern) – Plays a haptic pattern on the controller associated with the source ID
• void StopHaptics(int sourceId) – Stops haptic playback on the controller associated with the source ID

• Rule FindRule(InteractionType type, GameObject src, IInteractorView view, int pointerId) – Finds the first matching rule for the given parameters
• static InteractorKind KindOf(IInteractorView view, int pointerId) – Determines the InteractorKind from an interactor view

• FeedbackMode Mode – The feedback mode (Default, Suppress, or Override)
• bool TryGetOverrideActions(InteractionType type, out IReadOnlyList<FeedbackActionSO> actions) – Gets the override actions for a specific interaction type

• Order rules from specific to general. Place rules with specific tags and interactor kinds first, then add broader fallback rules. This ensures precise matching for special cases while providing default behavior for everything else. For example:
  • Rule 1: Tag=”Button”, InteractorKind=Poke, SelectStart → Strong haptic pulse
  • Rule 2: Tag=”Button”, InteractorKind=Any, SelectStart → Medium haptic pulse
  • Rule 3: Tag=Any, InteractorKind=Any, SelectStart → Light haptic pulse
• Reuse FeedbackAction assets across multiple rules. Instead of creating duplicate assets, reference the same FeedbackAction from multiple rules to maintain consistency and reduce asset management overhead.
• Use Unity Tags to categorize interactables. Assign tags like “Button”, “Lever”, or “Door” to express semantic categories, then write rules that target those tags. This makes it easy to apply consistent feedback to entire classes of objects.
• Minimize allocations in Execute() methods. Keep your custom FeedbackAction implementations efficient by avoiding frequent allocations. Consider using object pooling for VFX and audio sources.
• Combine with Event Wrappers for flexibility. If designers prefer inspector-based wiring for specific objects, use the Event Wrapper pattern on individual interactables while maintaining the Feedback Manager for global consistency.

1. Ensure the FeedbackManager GameObject is active in your scene.
2. Check that your FeedbackConfig has a rule matching the interaction type, interactor kind, and object tag.
3. Select the interactor in the Hierarchy and verify that an InteractorControllerDecorator component is attached.
4. If using a custom FeedbackAction, add debug logging to the Execute() method to confirm it’s being called.

1. Review the rule order in your FeedbackConfig. Remember that the first matching rule executes.
2. Select the interactable object in the Hierarchy and verify it contains a matching Unity tag in the Inspector.
3. Temporarily add a DebugLogAction to your rules to see which rule is matching.

1. Use object pooling for particle effects and audio sources to avoid instantiation overhead.
2. Limit the number of simultaneous audio sources playing.
3. Profile your custom Execute() methods using Unity’s Profiler to identify performance bottlenecks.