SDK Architecture & API

How the HEXR Unity SDK is put together, how the glove connects, how interactions become haptics, and how to drive the glove from your own code.

Package structure

The package is a stack. Your scene talks to the top; the glove sits at the bottom. The two backend layers only compile when their XR SDK is installed, and the core never depends on them.

Backends register themselves with the core when they load. The collider visualizer, HexRUsable and the floating menu stay in the global namespace so older scenes keep working.

The HEXR scene

HexR → Create HexR Rig adds the first two. Your XR SDK provides the third.

The tracked hand

HexRTrackedHand.handRoot points at your SDK’s hand. HEXR finds the joints by name:

Each touch point is a small trigger collider, a kinematic Rigidbody (Unity needs one for trigger events) and a HapticFingerTrigger that says which hand and finger it is. HEXR has no hand of its own: since 0.9 the touch points sit on the tracked hand on every backend. An older project with a “ghost” hand can remove it with HexR → Migration → Remove Ghost Hand.

Connecting the glove

Your app opens the Bluetooth connection itself. No pairing in system settings, no companion app. Each glove has its own HaptGloveHandler.

• Only one hand scans at a time; the second glove waits for the first.
• On Android a failed attempt is retried with a growing delay for up to a minute, and a glove that drops out is reconnected. Press Connect again to cancel a retry.

Events

C# events on HaptGloveHandler; subscribe with +=. They are not UnityEvents, so they do not show in the Inspector.

How haptics fire

On Android, commands sent close together are grouped into one Bluetooth write about every 100 ms. Response time from command to sensation is under 20 ms.

The hand-near check

A Pressure Controller sends most haptics only while IsHandNear() is true. Any one of these makes it true:

If your call does nothing, check IsHandNear() first, or pass byPassHandCheck: true while testing.

Channels and parameters

Six channels: Haptics.Finger.Thumb, Index, Middle, Ring, Pinky, Palm. Each plays one mode at a time. Values outside a range are clamped.

Scene components

Most projects never call the API. These components fire haptics on their own.

C# API

Call these when you want haptics driven by your own logic.

PressureTrackerMain — on each Pressure Controller

HexRManager — HexRManager.Instance

HaptGloveHandler — one per glove, namespace HaptGlove

HexRTrackedHand and FingerUseTracking — on each hand

Scene changes and editor tools

Your SDK’s hands die with their scene; the rig lives on. So after every scene load the manager re-attaches:

Then the log says [HexR] Rebound Left hand … 6 haptic trigger(s): five fingertips and the palm.

Auto Setup does the same in the Editor so it is saved with the scene. It only adds what is missing and never moves a collider you tuned. Run it from Create HexR Rig, HexR → Troubleshoot → Re-run Auto Setup, or the manager’s Auto Set Up HexR button. Validate Scene Setup then reports anything still unwired.

Type index

Every public type in com.microtube.hexr, for looking a name up. Where a section above covers it, the link goes there.

Components

Enums and values

Backend plumbing, editor and internals

Python

Outside Unity, HaptGlovePython builds the same commands; you write them with bleak. Setup and examples are in the Python guide.

Example

Press the index finger while a fingertip is inside this zone. HapticFingerTrigger says which hand touched, so the command goes to the right Pressure Controller.

using UnityEngine;
using HaptGlove;
using HexR;

public class IndexPress : MonoBehaviour
{
    public PressureTrackerMain leftHand;    // Left Pressure Controller
    public PressureTrackerMain rightHand;   // Right Pressure Controller

    void OnTriggerEnter(Collider other)
    {
        PressureTrackerMain hand = HandOf(other);
        // finger, apply, intensity 0.1-1, ramp speed 0.1-1, bypass the hand-near check
        if (hand != null) hand.CustomSingleHaptics(Haptics.Finger.Index, true, 0.8f, 1f, true);
    }

    void OnTriggerExit(Collider other)
    {
        PressureTrackerMain hand = HandOf(other);
        if (hand != null) hand.CustomSingleHaptics(Haptics.Finger.Index, false, 0f, 1f, true);
    }

    PressureTrackerMain HandOf(Collider other)
    {
        HapticFingerTrigger finger = other.GetComponent();
        if (finger == null) return null;
        return finger.handType == HapticFingerTrigger.HandType.Left ? leftHand : rightHand;
    }
}

Where to go next

Integrating into an existing app? Start with HexRInteractableHaptics before the lower-level PressureTrackerMain or HaptGloveHandler.