Blacklist XR_EXT_hand_interaction for HTC so the runtime can't switch
/user/hand/* to ext/hand_interaction_ext mid-session, which drops
controller button input whenever that profile is briefly active.
Point the Focus3 squeeze/touch binding at XRT_INPUT_FRAME_SQUEEZE_TOUCH,
the name the device actually exposes for that slot, instead of a name
that's never set active.
interpolate(before, after, t) expects t = 0 at the before sample and
t = 1 at the after sample (see hand_joints_list.cpp: radius = a.radius
* (1 - t) + b.radius * t, and monado's m_space_relation_interpolate
which lerps from the predecessor with the elapsed fraction).
The factor was computed as (after - now) / (after - before), which is
1 - t: querying at the before timestamp returned the after sample,
querying at the after timestamp returned the before sample, and
queries in between returned the pose mirrored about the segment
midpoint.
Compute t from the before sample so hand and body skeleton queries
between two tracking samples interpolate along the motion instead of
against it.
In case of discarded frames (no end frame or no layers) we don't get
called on mark_gpu_done, so times don't get updated. If the game
continues to call waitFrame, we advance the predicted display time, but
may enter the immediate return, accumulating delay.
The angular velocity was worked out with the wrong formula. It used
dq * q, but it should be dq * q^-1 (the inverse of q, which is just
its conjugate here because q is normalized).
Using q instead of its inverse pointed the angular velocity the wrong
way. Games read this value when you let go of a controller, so thrown
objects came out spinning wrong.
Mirror the gamepad forwarded from the headset to a uinput device with the standard Xbox layout, so applications that do not read it through OpenXR, such as SDL and Steam Input, pick it up. This extends the existing hid-forwarding uinput path, which already covered keyboard and mouse.
The headset chooses which devices to forward (keyboard, mouse, gamepad), off by default. The hid-forwarding server option gates the uinput mirror only; the OpenXR gamepad is always exposed. The mirror needs the uinput module and write access to /dev/uinput.
Gamepad rumble written to the uinput device is read back and forwarded to the headset as OpenXR haptics.
Forward a gamepad paired to the headset to the server. Useful when the controller is in range of the headset but not the server, such as a DualSense paired to a Quest over Bluetooth.
The headset reads the gamepad through the OpenXR microsoft/xbox_controller profile and forwards it on the existing input rails: gamepad device ids in the inputs packet, plus a gamepad entry in the interaction profile array that signals connection and disconnection from the tracking thread.
The server exposes a native OpenXR gamepad at /user/gamepad, connected while the headset reports a gamepad interaction profile. This needs no permission and is always available.
Rumble is sent back to the headset and applied through OpenXR haptics.
Optional server profiling built on the Perfetto SDK. Adds CPU spans
(compositor, encoder, network), GPU encode/copy slices from Vulkan timestamp
queries (Vulkan/NVENC/VAAPI), and headset feedback markers from dump_time.
WIVRN_TRACING enables tracing and selects the backend (system, inprocess, or
both); WIVRN_USE_PERFETTO gates it at build time and compiles it out otherwise.
WIVRN_TRACE_MONADO additionally drives Monado's percetto tracing from the same
switch so WiVRn and Monado land on one timeline.
Tooling: server-tracing[-monado] presets and a CI build, two Perfetto configs
(WiVRn-only and full-system), a wivrn_capture.py capture wrapper, a pftrace
summary script, and docs/profiling.md.