new workspace

wlx-overlay-s/src/backend/openvr/helpers.rs

@@ -0,0 +1,188 @@
+use std::ffi::CStr;
+
+use glam::Affine3A;
+use ovr_overlay::{pose::Matrix3x4, settings::SettingsManager, sys::HmdMatrix34_t};
+use thiserror::Error;
+
+use crate::backend::{common::BackendError, task::ColorChannel};
+
+pub trait Affine3AConvert {
+    fn from_affine(affine: &Affine3A) -> Self;
+    fn to_affine(&self) -> Affine3A;
+}
+
+impl Affine3AConvert for Matrix3x4 {
+    fn from_affine(affine: &Affine3A) -> Self {
+        Self([
+            [
+                affine.matrix3.x_axis.x,
+                affine.matrix3.y_axis.x,
+                affine.matrix3.z_axis.x,
+                affine.translation.x,
+            ],
+            [
+                affine.matrix3.x_axis.y,
+                affine.matrix3.y_axis.y,
+                affine.matrix3.z_axis.y,
+                affine.translation.y,
+            ],
+            [
+                affine.matrix3.x_axis.z,
+                affine.matrix3.y_axis.z,
+                affine.matrix3.z_axis.z,
+                affine.translation.z,
+            ],
+        ])
+    }
+
+    fn to_affine(&self) -> Affine3A {
+        Affine3A::from_cols_array_2d(&[
+            [self.0[0][0], self.0[1][0], self.0[2][0]],
+            [self.0[0][1], self.0[1][1], self.0[2][1]],
+            [self.0[0][2], self.0[1][2], self.0[2][2]],
+            [self.0[0][3], self.0[1][3], self.0[2][3]],
+        ])
+    }
+}
+
+impl Affine3AConvert for HmdMatrix34_t {
+    fn from_affine(affine: &Affine3A) -> Self {
+        Self {
+            m: [
+                [
+                    affine.matrix3.x_axis.x,
+                    affine.matrix3.y_axis.x,
+                    affine.matrix3.z_axis.x,
+                    affine.translation.x,
+                ],
+                [
+                    affine.matrix3.x_axis.y,
+                    affine.matrix3.y_axis.y,
+                    affine.matrix3.z_axis.y,
+                    affine.translation.y,
+                ],
+                [
+                    affine.matrix3.x_axis.z,
+                    affine.matrix3.y_axis.z,
+                    affine.matrix3.z_axis.z,
+                    affine.translation.z,
+                ],
+            ],
+        }
+    }
+
+    fn to_affine(&self) -> Affine3A {
+        Affine3A::from_cols_array_2d(&[
+            [self.m[0][0], self.m[1][0], self.m[2][0]],
+            [self.m[0][1], self.m[1][1], self.m[2][1]],
+            [self.m[0][2], self.m[1][2], self.m[2][2]],
+            [self.m[0][3], self.m[1][3], self.m[2][3]],
+        ])
+    }
+}
+
+#[derive(Error, Debug)]
+pub(super) enum OVRError {
+    #[error("ovr input error: {0}")]
+    InputError(&'static str),
+}
+
+impl From<ovr_overlay::errors::EVRInputError> for OVRError {
+    fn from(e: ovr_overlay::errors::EVRInputError) -> Self {
+        Self::InputError(e.description())
+    }
+}
+
+impl From<OVRError> for BackendError {
+    fn from(e: OVRError) -> Self {
+        Self::Fatal(anyhow::Error::new(e))
+    }
+}
+
+const STEAMVR_SECTION: &CStr = c"steamvr";
+const COLOR_GAIN_CSTR: [&CStr; 3] = [
+    c"hmdDisplayColorGainR",
+    c"hmdDisplayColorGainG",
+    c"hmdDisplayColorGainB",
+];
+
+pub(super) fn adjust_gain(
+    settings: &mut SettingsManager,
+    ch: ColorChannel,
+    delta: f32,
+) -> Option<()> {
+    let current = [
+        settings
+            .get_float(STEAMVR_SECTION, COLOR_GAIN_CSTR[0])
+            .ok()?,
+        settings
+            .get_float(STEAMVR_SECTION, COLOR_GAIN_CSTR[1])
+            .ok()?,
+        settings
+            .get_float(STEAMVR_SECTION, COLOR_GAIN_CSTR[2])
+            .ok()?,
+    ];
+
+    // prevent user from turning everything black
+    let mut min = if current[0] + current[1] + current[2] < 0.11 {
+        0.1
+    } else {
+        0.0
+    };
+
+    match ch {
+        ColorChannel::R => {
+            settings
+                .set_float(
+                    STEAMVR_SECTION,
+                    COLOR_GAIN_CSTR[0],
+                    (current[0] + delta).clamp(min, 1.0),
+                )
+                .ok()?;
+        }
+        ColorChannel::G => {
+            settings
+                .set_float(
+                    STEAMVR_SECTION,
+                    COLOR_GAIN_CSTR[1],
+                    (current[1] + delta).clamp(min, 1.0),
+                )
+                .ok()?;
+        }
+        ColorChannel::B => {
+            settings
+                .set_float(
+                    STEAMVR_SECTION,
+                    COLOR_GAIN_CSTR[2],
+                    (current[2] + delta).clamp(min, 1.0),
+                )
+                .ok()?;
+        }
+        ColorChannel::All => {
+            min *= 0.3333;
+            settings
+                .set_float(
+                    STEAMVR_SECTION,
+                    COLOR_GAIN_CSTR[0],
+                    (current[0] + delta).clamp(min, 1.0),
+                )
+                .ok()?;
+            settings
+                .set_float(
+                    STEAMVR_SECTION,
+                    COLOR_GAIN_CSTR[1],
+                    (current[1] + delta).clamp(min, 1.0),
+                )
+                .ok()?;
+            settings
+                .set_float(
+                    STEAMVR_SECTION,
+                    COLOR_GAIN_CSTR[2],
+                    (current[2] + delta).clamp(min, 1.0),
+                )
+                .ok()?;
+        }
+    }
+
+    Some(())
+}

wlx-overlay-s/src/backend/openvr/input.rs

@@ -0,0 +1,360 @@
+use std::{array, fs::File, io::Write, time::Duration};
+
+use anyhow::bail;
+use ovr_overlay::{
+    input::{ActionHandle, ActionSetHandle, ActiveActionSet, InputManager, InputValueHandle},
+    sys::{
+        ETrackedControllerRole, ETrackedDeviceClass, ETrackedDeviceProperty,
+        ETrackingUniverseOrigin,
+    },
+    system::SystemManager,
+    TrackedDeviceIndex,
+};
+
+use crate::{
+    backend::input::{Haptics, TrackedDevice, TrackedDeviceRole},
+    config_io,
+    state::AppState,
+};
+
+use super::helpers::{Affine3AConvert, OVRError};
+
+const SET_DEFAULT: &str = "/actions/default";
+const INPUT_SOURCES: [&str; 2] = ["/user/hand/left", "/user/hand/right"];
+const PATH_POSES: [&str; 2] = [
+    "/actions/default/in/LeftHand",
+    "/actions/default/in/RightHand",
+];
+const PATH_HAPTICS: [&str; 2] = [
+    "/actions/default/out/HapticsLeft",
+    "/actions/default/out/HapticsRight",
+];
+
+const PATH_ALT_CLICK: &str = "/actions/default/in/AltClick";
+const PATH_CLICK_MODIFIER_MIDDLE: &str = "/actions/default/in/ClickModifierMiddle";
+const PATH_CLICK_MODIFIER_RIGHT: &str = "/actions/default/in/ClickModifierRight";
+const PATH_CLICK: &str = "/actions/default/in/Click";
+const PATH_GRAB: &str = "/actions/default/in/Grab";
+const PATH_MOVE_MOUSE: &str = "/actions/default/in/MoveMouse";
+const PATH_SCROLL: &str = "/actions/default/in/Scroll";
+const PATH_SHOW_HIDE: &str = "/actions/default/in/ShowHide";
+const PATH_SPACE_DRAG: &str = "/actions/default/in/SpaceDrag";
+const PATH_SPACE_ROTATE: &str = "/actions/default/in/SpaceRotate";
+const PATH_TOGGLE_DASHBOARD: &str = "/actions/default/in/ToggleDashboard";
+
+const INPUT_ANY: InputValueHandle = InputValueHandle(ovr_overlay::sys::k_ulInvalidInputValueHandle);
+
+pub(super) struct OpenVrInputSource {
+    hands: [OpenVrHandSource; 2],
+    set_hnd: ActionSetHandle,
+    click_hnd: ActionHandle,
+    grab_hnd: ActionHandle,
+    scroll_hnd: ActionHandle,
+    alt_click_hnd: ActionHandle,
+    show_hide_hnd: ActionHandle,
+    toggle_dashboard_hnd: ActionHandle,
+    space_drag_hnd: ActionHandle,
+    space_rotate_hnd: ActionHandle,
+    click_modifier_right_hnd: ActionHandle,
+    click_modifier_middle_hnd: ActionHandle,
+    move_mouse_hnd: ActionHandle,
+}
+
+pub(super) struct OpenVrHandSource {
+    has_pose: bool,
+    device: Option<TrackedDeviceIndex>,
+    input_hnd: InputValueHandle,
+    pose_hnd: ActionHandle,
+    haptics_hnd: ActionHandle,
+}
+
+impl OpenVrInputSource {
+    pub fn new(input: &mut InputManager) -> Result<Self, OVRError> {
+        let set_hnd = input.get_action_set_handle(SET_DEFAULT)?;
+
+        let click_hnd = input.get_action_handle(PATH_CLICK)?;
+        let grab_hnd = input.get_action_handle(PATH_GRAB)?;
+        let scroll_hnd = input.get_action_handle(PATH_SCROLL)?;
+        let alt_click_hnd = input.get_action_handle(PATH_ALT_CLICK)?;
+        let show_hide_hnd = input.get_action_handle(PATH_SHOW_HIDE)?;
+        let toggle_dashboard_hnd = input.get_action_handle(PATH_TOGGLE_DASHBOARD)?;
+        let space_drag_hnd = input.get_action_handle(PATH_SPACE_DRAG)?;
+        let space_rotate_hnd = input.get_action_handle(PATH_SPACE_ROTATE)?;
+        let click_modifier_right_hnd = input.get_action_handle(PATH_CLICK_MODIFIER_RIGHT)?;
+        let click_modifier_middle_hnd = input.get_action_handle(PATH_CLICK_MODIFIER_MIDDLE)?;
+        let move_mouse_hnd = input.get_action_handle(PATH_MOVE_MOUSE)?;
+
+        let input_hnd: Vec<InputValueHandle> = INPUT_SOURCES
+            .iter()
+            .map(|path| Ok((input.get_input_source_handle(path))?))
+            .collect::<Result<_, OVRError>>()?;
+
+        let pose_hnd: Vec<ActionHandle> = PATH_POSES
+            .iter()
+            .map(|path| Ok((input.get_action_handle(path))?))
+            .collect::<Result<_, OVRError>>()?;
+
+        let haptics_hnd: Vec<ActionHandle> = PATH_HAPTICS
+            .iter()
+            .map(|path| Ok((input.get_action_handle(path))?))
+            .collect::<Result<_, OVRError>>()?;
+
+        let hands: [OpenVrHandSource; 2] = array::from_fn(|i| OpenVrHandSource {
+            has_pose: false,
+            device: None,
+            input_hnd: input_hnd[i],
+            pose_hnd: pose_hnd[i],
+            haptics_hnd: haptics_hnd[i],
+        });
+
+        Ok(Self {
+            hands,
+            set_hnd,
+            click_hnd,
+            grab_hnd,
+            scroll_hnd,
+            alt_click_hnd,
+            show_hide_hnd,
+            toggle_dashboard_hnd,
+            space_drag_hnd,
+            space_rotate_hnd,
+            click_modifier_right_hnd,
+            click_modifier_middle_hnd,
+            move_mouse_hnd,
+        })
+    }
+
+    pub fn haptics(&mut self, input: &mut InputManager, hand: usize, haptics: &Haptics) {
+        let action_handle = self.hands[hand].haptics_hnd;
+        let _ = input.trigger_haptic_vibration_action(
+            action_handle,
+            0.0,
+            Duration::from_secs_f32(haptics.duration),
+            haptics.frequency,
+            haptics.intensity,
+            INPUT_ANY,
+        );
+    }
+
+    pub fn update(
+        &mut self,
+        universe: ETrackingUniverseOrigin,
+        input: &mut InputManager,
+        system: &mut SystemManager,
+        app: &mut AppState,
+    ) {
+        let aas = ActiveActionSet(ovr_overlay::sys::VRActiveActionSet_t {
+            ulActionSet: self.set_hnd.0,
+            ulRestrictedToDevice: 0,
+            ulSecondaryActionSet: 0,
+            unPadding: 0,
+            nPriority: 0,
+        });
+
+        let _ = input.update_actions(&mut [aas]);
+
+        let devices = system.get_device_to_absolute_tracking_pose(universe.clone(), 0.005);
+        app.input_state.hmd = devices[0].mDeviceToAbsoluteTracking.to_affine();
+
+        for i in 0..2 {
+            let hand = &mut self.hands[i];
+            let app_hand = &mut app.input_state.pointers[i];
+
+            if let Some(device) = hand.device {
+                app_hand.raw_pose = devices[device.0 as usize]
+                    .mDeviceToAbsoluteTracking
+                    .to_affine();
+            }
+
+            hand.has_pose = false;
+
+            let _ = input
+                .get_pose_action_data_relative_to_now(
+                    hand.pose_hnd,
+                    universe.clone(),
+                    0.005,
+                    INPUT_ANY,
+                )
+                .map(|pose| {
+                    app_hand.pose = pose.0.pose.mDeviceToAbsoluteTracking.to_affine();
+                    hand.has_pose = true;
+                });
+
+            app_hand.now.click = input
+                .get_digital_action_data(self.click_hnd, hand.input_hnd)
+                .map(|x| x.0.bState)
+                .unwrap_or(false);
+
+            app_hand.now.grab = input
+                .get_digital_action_data(self.grab_hnd, hand.input_hnd)
+                .map(|x| x.0.bState)
+                .unwrap_or(false);
+
+            app_hand.now.alt_click = input
+                .get_digital_action_data(self.alt_click_hnd, hand.input_hnd)
+                .map(|x| x.0.bState)
+                .unwrap_or(false);
+
+            app_hand.now.show_hide = input
+                .get_digital_action_data(self.show_hide_hnd, hand.input_hnd)
+                .map(|x| x.0.bState)
+                .unwrap_or(false);
+
+            app_hand.now.toggle_dashboard = input
+                .get_digital_action_data(self.toggle_dashboard_hnd, hand.input_hnd)
+                .map(|x| x.0.bState)
+                .unwrap_or(false);
+
+            app_hand.now.space_drag = input
+                .get_digital_action_data(self.space_drag_hnd, hand.input_hnd)
+                .map(|x| x.0.bState)
+                .unwrap_or(false);
+
+            app_hand.now.space_rotate = input
+                .get_digital_action_data(self.space_rotate_hnd, hand.input_hnd)
+                .map(|x| x.0.bState)
+                .unwrap_or(false);
+
+            app_hand.now.click_modifier_right = input
+                .get_digital_action_data(self.click_modifier_right_hnd, hand.input_hnd)
+                .map(|x| x.0.bState)
+                .unwrap_or(false);
+
+            app_hand.now.click_modifier_middle = input
+                .get_digital_action_data(self.click_modifier_middle_hnd, hand.input_hnd)
+                .map(|x| x.0.bState)
+                .unwrap_or(false);
+
+            app_hand.now.move_mouse = input
+                .get_digital_action_data(self.move_mouse_hnd, hand.input_hnd)
+                .map(|x| x.0.bState)
+                .unwrap_or(false);
+
+            let scroll = input
+                .get_analog_action_data(self.scroll_hnd, hand.input_hnd)
+                .map(|x| (x.0.x, x.0.y))
+                .unwrap_or((0.0, 0.0));
+            app_hand.now.scroll_x = scroll.0;
+            app_hand.now.scroll_y = scroll.1;
+        }
+    }
+
+    pub fn update_devices(&mut self, system: &mut SystemManager, app: &mut AppState) {
+        app.input_state.devices.clear();
+        for idx in 0..TrackedDeviceIndex::MAX {
+            let device = TrackedDeviceIndex::new(idx as _).unwrap(); // safe
+            if !system.is_tracked_device_connected(device) {
+                continue;
+            }
+
+            let class = system.get_tracked_device_class(device);
+
+            let role = match class {
+                ETrackedDeviceClass::TrackedDeviceClass_HMD => TrackedDeviceRole::Hmd,
+                ETrackedDeviceClass::TrackedDeviceClass_Controller => {
+                    let role = system.get_controller_role_for_tracked_device_index(device);
+                    match role {
+                        ETrackedControllerRole::TrackedControllerRole_LeftHand => {
+                            self.hands[0].device = Some(device);
+                            TrackedDeviceRole::LeftHand
+                        }
+                        ETrackedControllerRole::TrackedControllerRole_RightHand => {
+                            self.hands[1].device = Some(device);
+                            TrackedDeviceRole::RightHand
+                        }
+                        _ => continue,
+                    }
+                }
+                ETrackedDeviceClass::TrackedDeviceClass_GenericTracker => {
+                    TrackedDeviceRole::Tracker
+                }
+                _ => continue,
+            };
+
+            if let Some(device) = get_tracked_device(system, device, role) {
+                app.input_state.devices.push(device);
+            }
+        }
+
+        app.input_state.devices.sort_by(|a, b| {
+            u8::from(a.soc.is_none())
+                .cmp(&u8::from(b.soc.is_none()))
+                .then((a.role as u8).cmp(&(b.role as u8)))
+                .then(a.soc.unwrap_or(999.).total_cmp(&b.soc.unwrap_or(999.)))
+        });
+    }
+}
+
+fn get_tracked_device(
+    system: &mut SystemManager,
+    index: TrackedDeviceIndex,
+    role: TrackedDeviceRole,
+) -> Option<TrackedDevice> {
+    let soc = system
+        .get_tracked_device_property(
+            index,
+            ETrackedDeviceProperty::Prop_DeviceBatteryPercentage_Float,
+        )
+        .ok();
+
+    let charging = if soc.is_some() {
+        system
+            .get_tracked_device_property(index, ETrackedDeviceProperty::Prop_DeviceIsCharging_Bool)
+            .unwrap_or(false)
+    } else {
+        false
+    };
+
+    // TODO: cache this
+    let is_alvr = system
+        .get_tracked_device_property(
+            index,
+            ETrackedDeviceProperty::Prop_TrackingSystemName_String,
+        )
+        .map(|x: String| x.contains("ALVR"))
+        .unwrap_or(false);
+
+    if is_alvr {
+        // don't show ALVR's fake trackers on battery panel
+        return None;
+    }
+
+    Some(TrackedDevice {
+        soc,
+        charging,
+        role,
+    })
+}
+
+pub fn set_action_manifest(input: &mut InputManager) -> anyhow::Result<()> {
+    let action_path = config_io::get_config_root().join("actions.json");
+
+    if let Err(e) = File::create(&action_path)
+        .and_then(|mut f| f.write_all(include_bytes!("../../res/actions.json")))
+    {
+        log::warn!("Could not write action manifest: {e}");
+    }
+
+    let binding_path = config_io::get_config_root().join("actions_binding_knuckles.json");
+    if !binding_path.is_file() {
+        File::create(&binding_path)?
+            .write_all(include_bytes!("../../res/actions_binding_knuckles.json"))?;
+    }
+
+    let binding_path = config_io::get_config_root().join("actions_binding_vive.json");
+    if !binding_path.is_file() {
+        File::create(&binding_path)?
+            .write_all(include_bytes!("../../res/actions_binding_vive.json"))?;
+    }
+
+    let binding_path = config_io::get_config_root().join("actions_binding_oculus.json");
+    if !binding_path.is_file() {
+        File::create(&binding_path)?
+            .write_all(include_bytes!("../../res/actions_binding_oculus.json"))?;
+    }
+
+    if let Err(e) = input.set_action_manifest(action_path.as_path()) {
+        bail!("Failed to set action manifest: {}", e);
+    }
+    Ok(())
+}

wlx-overlay-s/src/backend/openvr/lines.rs

@@ -0,0 +1,264 @@
+use std::f32::consts::PI;
+use std::sync::atomic::{AtomicUsize, Ordering};
+use std::sync::Arc;
+
+use ash::vk::SubmitInfo;
+use glam::{Affine3A, Vec3, Vec3A, Vec4};
+use idmap::IdMap;
+use ovr_overlay::overlay::OverlayManager;
+use ovr_overlay::sys::ETrackingUniverseOrigin;
+use vulkano::{
+    command_buffer::{
+        CommandBufferBeginInfo, CommandBufferLevel, CommandBufferUsage, RecordingCommandBuffer,
+    },
+    format::Format,
+    image::view::ImageView,
+    image::{Image, ImageLayout},
+    sync::{
+        fence::{Fence, FenceCreateInfo},
+        AccessFlags, DependencyInfo, ImageMemoryBarrier, PipelineStages,
+    },
+    VulkanObject,
+};
+use wgui::gfx::WGfx;
+
+use crate::backend::overlay::{
+    FrameMeta, OverlayData, OverlayRenderer, OverlayState, ShouldRender, SplitOverlayBackend,
+    Z_ORDER_LINES,
+};
+use crate::graphics::CommandBuffers;
+use crate::state::AppState;
+
+use super::overlay::OpenVrOverlayData;
+
+static LINE_AUTO_INCREMENT: AtomicUsize = AtomicUsize::new(1);
+
+pub(super) struct LinePool {
+    lines: IdMap<usize, OverlayData<OpenVrOverlayData>>,
+    view: Arc<ImageView>,
+    colors: [Vec4; 5],
+}
+
+impl LinePool {
+    pub fn new(graphics: Arc<WGfx>) -> anyhow::Result<Self> {
+        let mut command_buffer =
+            graphics.create_xfer_command_buffer(CommandBufferUsage::OneTimeSubmit)?;
+
+        let buf = vec![255; 16];
+
+        let texture = command_buffer.upload_image(2, 2, Format::R8G8B8A8_UNORM, &buf)?;
+        command_buffer.build_and_execute_now()?;
+
+        transition_layout(
+            &graphics,
+            texture.clone(),
+            ImageLayout::ShaderReadOnlyOptimal,
+            ImageLayout::TransferSrcOptimal,
+        )?
+        .wait(None)?;
+
+        let view = ImageView::new_default(texture)?;
+
+        Ok(Self {
+            lines: IdMap::new(),
+            view,
+            colors: [
+                Vec4::new(1., 1., 1., 1.),
+                Vec4::new(0., 0.375, 0.5, 1.),
+                Vec4::new(0.69, 0.188, 0., 1.),
+                Vec4::new(0.375, 0., 0.5, 1.),
+                Vec4::new(1., 0., 0., 1.),
+            ],
+        })
+    }
+
+    pub fn allocate(&mut self) -> usize {
+        let id = LINE_AUTO_INCREMENT.fetch_add(1, Ordering::Relaxed);
+
+        let mut data = OverlayData::<OpenVrOverlayData> {
+            state: OverlayState {
+                name: Arc::from(format!("wlx-line{id}")),
+                show_hide: true,
+                ..Default::default()
+            },
+            backend: Box::new(SplitOverlayBackend {
+                renderer: Box::new(StaticRenderer {
+                    view: self.view.clone(),
+                }),
+                ..Default::default()
+            }),
+            data: OpenVrOverlayData {
+                width: 0.002,
+                override_width: true,
+                image_view: Some(self.view.clone()),
+                image_dirty: true,
+                ..Default::default()
+            },
+            ..Default::default()
+        };
+        data.state.z_order = Z_ORDER_LINES;
+        data.state.dirty = true;
+
+        self.lines.insert(id, data);
+        id
+    }
+
+    pub fn draw_from(
+        &mut self,
+        id: usize,
+        mut from: Affine3A,
+        len: f32,
+        color: usize,
+        hmd: &Affine3A,
+    ) {
+        let rotation = Affine3A::from_axis_angle(Vec3::X, -PI * 0.5);
+
+        from.translation += from.transform_vector3a(Vec3A::NEG_Z) * (len * 0.5);
+        let mut transform = from * rotation * Affine3A::from_scale(Vec3::new(1., len / 0.002, 1.));
+
+        let to_hmd = hmd.translation - from.translation;
+        let sides = [Vec3A::Z, Vec3A::X, Vec3A::NEG_Z, Vec3A::NEG_X];
+        let rotations = [
+            Affine3A::IDENTITY,
+            Affine3A::from_axis_angle(Vec3::Y, PI * 0.5),
+            Affine3A::from_axis_angle(Vec3::Y, PI * 1.0),
+            Affine3A::from_axis_angle(Vec3::Y, PI * 1.5),
+        ];
+        let mut closest = (0, 0.0);
+        for (i, &side) in sides.iter().enumerate() {
+            let dot = to_hmd.dot(transform.transform_vector3a(side));
+            if i == 0 || dot > closest.1 {
+                closest = (i, dot);
+            }
+        }
+
+        transform *= rotations[closest.0];
+
+        debug_assert!(color < self.colors.len());
+
+        self.draw_transform(id, transform, self.colors[color]);
+    }
+
+    fn draw_transform(&mut self, id: usize, transform: Affine3A, color: Vec4) {
+        if let Some(data) = self.lines.get_mut(id) {
+            data.state.want_visible = true;
+            data.state.transform = transform;
+            data.data.color = color;
+        } else {
+            log::warn!("Line {id} does not exist");
+        }
+    }
+
+    pub fn update(
+        &mut self,
+        universe: ETrackingUniverseOrigin,
+        overlay: &mut OverlayManager,
+        app: &mut AppState,
+    ) -> anyhow::Result<()> {
+        for data in self.lines.values_mut() {
+            data.after_input(overlay, app)?;
+            if data.state.want_visible {
+                if data.state.dirty {
+                    data.upload_texture(overlay, &app.gfx);
+                    data.state.dirty = false;
+                }
+
+                data.upload_transform(universe.clone(), overlay);
+                data.upload_color(overlay);
+            }
+        }
+        Ok(())
+    }
+
+    pub fn mark_dirty(&mut self) {
+        for data in self.lines.values_mut() {
+            data.state.dirty = true;
+        }
+    }
+}
+
+struct StaticRenderer {
+    view: Arc<ImageView>,
+}
+
+impl OverlayRenderer for StaticRenderer {
+    fn init(&mut self, _app: &mut AppState) -> anyhow::Result<()> {
+        Ok(())
+    }
+    fn pause(&mut self, _app: &mut AppState) -> anyhow::Result<()> {
+        Ok(())
+    }
+    fn resume(&mut self, _app: &mut AppState) -> anyhow::Result<()> {
+        Ok(())
+    }
+    fn should_render(&mut self, _app: &mut AppState) -> anyhow::Result<ShouldRender> {
+        Ok(ShouldRender::Unable)
+    }
+    fn render(
+        &mut self,
+        _app: &mut AppState,
+        _tgt: Arc<ImageView>,
+        _buf: &mut CommandBuffers,
+        _alpha: f32,
+    ) -> anyhow::Result<bool> {
+        Ok(false)
+    }
+    fn frame_meta(&mut self) -> Option<FrameMeta> {
+        Some(FrameMeta {
+            extent: self.view.image().extent(),
+            ..Default::default()
+        })
+    }
+}
+
+pub fn transition_layout(
+    gfx: &WGfx,
+    image: Arc<Image>,
+    old_layout: ImageLayout,
+    new_layout: ImageLayout,
+) -> anyhow::Result<Fence> {
+    let barrier = ImageMemoryBarrier {
+        src_stages: PipelineStages::ALL_TRANSFER,
+        src_access: AccessFlags::TRANSFER_WRITE,
+        dst_stages: PipelineStages::ALL_TRANSFER,
+        dst_access: AccessFlags::TRANSFER_READ,
+        old_layout,
+        new_layout,
+        subresource_range: image.subresource_range(),
+        ..ImageMemoryBarrier::image(image)
+    };
+
+    let command_buffer = unsafe {
+        let mut builder = RecordingCommandBuffer::new(
+            gfx.command_buffer_allocator.clone(),
+            gfx.queue_gfx.queue_family_index(),
+            CommandBufferLevel::Primary,
+            CommandBufferBeginInfo {
+                usage: CommandBufferUsage::OneTimeSubmit,
+                inheritance_info: None,
+                ..Default::default()
+            },
+        )?;
+
+        builder.pipeline_barrier(&DependencyInfo {
+            image_memory_barriers: smallvec::smallvec![barrier],
+            ..Default::default()
+        })?;
+        builder.end()?
+    };
+
+    let fence = Fence::new(gfx.device.clone(), FenceCreateInfo::default())?;
+
+    let fns = gfx.device.fns();
+    unsafe {
+        (fns.v1_0.queue_submit)(
+            gfx.queue_gfx.handle(),
+            1,
+            [SubmitInfo::default().command_buffers(&[command_buffer.handle()])].as_ptr(),
+            fence.handle(),
+        )
+    }
+    .result()?;
+
+    Ok(fence)
+}

wlx-overlay-s/src/backend/openvr/manifest.rs

@@ -0,0 +1,88 @@
+use std::{fs::File, io::Read};
+
+use anyhow::bail;
+use json::{array, object};
+use ovr_overlay::applications::ApplicationsManager;
+
+use crate::config_io;
+
+const APP_KEY: &str = "galister.wlxoverlay-s";
+
+pub(super) fn install_manifest(app_mgr: &mut ApplicationsManager) -> anyhow::Result<()> {
+    let manifest_path = config_io::get_config_root().join("wlx-overlay-s.vrmanifest");
+
+    let appimage_path = std::env::var("APPIMAGE");
+    let executable_pathbuf = std::env::current_exe()?;
+
+    let executable_path = match appimage_path {
+        Ok(ref path) => path,
+        Err(_) => executable_pathbuf
+            .to_str()
+            .ok_or_else(|| anyhow::anyhow!("Invalid executable path"))?,
+    };
+
+    if app_mgr.is_application_installed(APP_KEY) == Ok(true) {
+        if let Ok(mut file) = File::open(&manifest_path) {
+            let mut buf = String::new();
+            if file.read_to_string(&mut buf).is_ok() {
+                let manifest: json::JsonValue = json::parse(&buf)?;
+                if manifest["applications"][0]["binary_path_linux"] == executable_path {
+                    log::info!("Manifest already up to date");
+                    return Ok(());
+                }
+            }
+        }
+    }
+
+    let manifest = object! {
+        source: "builtin",
+        applications: array![
+            object! {
+                app_key: APP_KEY,
+                launch_type: "binary",
+                binary_path_linux: executable_path,
+                is_dashboard_overlay: true,
+                strings: object!{
+                    "en_us": object!{
+                        name: "WlxOverlay-S",
+                        description: "A lightweight Wayland desktop overlay for OpenVR/OpenXR",
+                    },
+                },
+            },
+        ],
+    };
+
+    let Ok(mut file) = File::create(&manifest_path) else {
+        bail!("Failed to create manifest file at {:?}", manifest_path);
+    };
+
+    if let Err(e) = manifest.write(&mut file) {
+        bail!(
+            "Failed to write manifest file at {:?}: {:?}",
+            manifest_path,
+            e
+        );
+    }
+
+    if let Err(e) = app_mgr.add_application_manifest(&manifest_path, false) {
+        bail!("Failed to add manifest to OpenVR: {}", e.description());
+    }
+
+    if let Err(e) = app_mgr.set_application_auto_launch(APP_KEY, true) {
+        bail!("Failed to set auto launch: {}", e.description());
+    }
+
+    Ok(())
+}
+
+pub(super) fn uninstall_manifest(app_mgr: &mut ApplicationsManager) -> anyhow::Result<()> {
+    let manifest_path = config_io::get_config_root().join("wlx-overlay-s.vrmanifest");
+
+    if app_mgr.is_application_installed(APP_KEY) == Ok(true) {
+        if let Err(e) = app_mgr.remove_application_manifest(&manifest_path) {
+            bail!("Failed to remove manifest from OpenVR: {}", e.description());
+        }
+        log::info!("Uninstalled manifest");
+    }
+    Ok(())
+}

wlx-overlay-s/src/backend/openvr/mod.rs

@@ -0,0 +1,389 @@
+use std::{
+    collections::VecDeque,
+    ops::Add,
+    sync::{
+        atomic::{AtomicBool, AtomicUsize, Ordering},
+        Arc,
+    },
+    time::{Duration, Instant},
+};
+
+use anyhow::{anyhow, Result};
+use ovr_overlay::{
+    sys::{ETrackedDeviceProperty, EVRApplicationType, EVREventType},
+    TrackedDeviceIndex,
+};
+use vulkano::{device::physical::PhysicalDevice, Handle, VulkanObject};
+
+use crate::{
+    backend::{
+        common::{BackendError, OverlayContainer},
+        input::interact,
+        notifications::NotificationManager,
+        openvr::{
+            helpers::adjust_gain,
+            input::{set_action_manifest, OpenVrInputSource},
+            lines::LinePool,
+            manifest::{install_manifest, uninstall_manifest},
+            overlay::OpenVrOverlayData,
+        },
+        overlay::{OverlayData, ShouldRender},
+        task::{SystemTask, TaskType},
+    },
+    graphics::{init_openvr_graphics, CommandBuffers},
+    overlays::{
+        toast::{Toast, ToastTopic},
+        watch::{watch_fade, WATCH_NAME},
+    },
+    state::AppState,
+};
+
+#[cfg(feature = "wayvr")]
+use crate::{backend::wayvr::WayVRAction, overlays::wayvr::wayvr_action};
+
+pub mod helpers;
+pub mod input;
+pub mod lines;
+pub mod manifest;
+pub mod overlay;
+pub mod playspace;
+
+static FRAME_COUNTER: AtomicUsize = AtomicUsize::new(0);
+
+pub fn openvr_uninstall() {
+    let app_type = EVRApplicationType::VRApplication_Overlay;
+    let Ok(context) = ovr_overlay::Context::init(app_type) else {
+        log::error!("Uninstall failed: could not reach OpenVR");
+        return;
+    };
+
+    let mut app_mgr = context.applications_mngr();
+    let _ = uninstall_manifest(&mut app_mgr);
+}
+
+#[allow(clippy::too_many_lines, clippy::cognitive_complexity)]
+pub fn openvr_run(
+    running: Arc<AtomicBool>,
+    show_by_default: bool,
+    headless: bool,
+) -> Result<(), BackendError> {
+    let app_type = EVRApplicationType::VRApplication_Overlay;
+    let Ok(context) = ovr_overlay::Context::init(app_type) else {
+        log::warn!("Will not use OpenVR: Context init failed");
+        return Err(BackendError::NotSupported);
+    };
+
+    log::info!("Using OpenVR runtime");
+
+    let mut app_mgr = context.applications_mngr();
+    let mut input_mgr = context.input_mngr();
+    let mut system_mgr = context.system_mngr();
+    let mut overlay_mgr = context.overlay_mngr();
+    let mut settings_mgr = context.settings_mngr();
+    let mut chaperone_mgr = context.chaperone_setup_mngr();
+    let mut compositor_mgr = context.compositor_mngr();
+
+    let device_extensions_fn = |device: &PhysicalDevice| {
+        let names = compositor_mgr.get_vulkan_device_extensions_required(device.handle().as_raw());
+        names.iter().map(std::string::String::as_str).collect()
+    };
+
+    let mut compositor_mgr = context.compositor_mngr();
+    let instance_extensions = {
+        let names = compositor_mgr.get_vulkan_instance_extensions_required();
+        names.iter().map(std::string::String::as_str).collect()
+    };
+
+    let mut state = {
+        let (gfx, gfx_extras) = init_openvr_graphics(instance_extensions, device_extensions_fn)?;
+        AppState::from_graphics(gfx, gfx_extras)?
+    };
+
+    if show_by_default {
+        state.tasks.enqueue_at(
+            TaskType::System(SystemTask::ShowHide),
+            Instant::now().add(Duration::from_secs(1)),
+        );
+    }
+
+    if let Ok(ipd) = system_mgr.get_tracked_device_property::<f32>(
+        TrackedDeviceIndex::HMD,
+        ETrackedDeviceProperty::Prop_UserIpdMeters_Float,
+    ) {
+        state.input_state.ipd = (ipd * 10000.0).round() * 0.1;
+        log::info!("IPD: {:.1} mm", state.input_state.ipd);
+    }
+
+    let _ = install_manifest(&mut app_mgr);
+
+    let mut overlays = OverlayContainer::<OpenVrOverlayData>::new(&mut state, headless)?;
+    let mut notifications = NotificationManager::new();
+    notifications.run_dbus();
+    notifications.run_udp();
+
+    let mut playspace = playspace::PlayspaceMover::new();
+    playspace.playspace_changed(&mut compositor_mgr, &mut chaperone_mgr);
+
+    set_action_manifest(&mut input_mgr)?;
+
+    let mut input_source = OpenVrInputSource::new(&mut input_mgr)?;
+
+    let Ok(refresh_rate) = system_mgr.get_tracked_device_property::<f32>(
+        TrackedDeviceIndex::HMD,
+        ETrackedDeviceProperty::Prop_DisplayFrequency_Float,
+    ) else {
+        return Err(BackendError::Fatal(anyhow!(
+            "Failed to get HMD refresh rate"
+        )));
+    };
+
+    log::info!("HMD running @ {refresh_rate} Hz");
+
+    let watch_id = overlays.get_by_name(WATCH_NAME).unwrap().state.id; // want panic
+
+    // want at least half refresh rate
+    let frame_timeout = 2 * (1000.0 / refresh_rate).floor() as u32;
+
+    let mut next_device_update = Instant::now();
+    let mut due_tasks = VecDeque::with_capacity(4);
+
+    let mut lines = LinePool::new(state.gfx.clone())?;
+    let pointer_lines = [lines.allocate(), lines.allocate()];
+
+    'main_loop: loop {
+        let _ = overlay_mgr.wait_frame_sync(frame_timeout);
+
+        if !running.load(Ordering::Relaxed) {
+            log::warn!("Received shutdown signal.");
+            break 'main_loop;
+        }
+
+        let cur_frame = FRAME_COUNTER.fetch_add(1, Ordering::Relaxed);
+
+        while let Some(event) = system_mgr.poll_next_event() {
+            match event.event_type {
+                EVREventType::VREvent_Quit => {
+                    log::warn!("Received quit event, shutting down.");
+                    break 'main_loop;
+                }
+                EVREventType::VREvent_TrackedDeviceActivated
+                | EVREventType::VREvent_TrackedDeviceDeactivated
+                | EVREventType::VREvent_TrackedDeviceUpdated => {
+                    next_device_update = Instant::now();
+                }
+                EVREventType::VREvent_SeatedZeroPoseReset
+                | EVREventType::VREvent_StandingZeroPoseReset
+                | EVREventType::VREvent_ChaperoneUniverseHasChanged
+                | EVREventType::VREvent_SceneApplicationChanged => {
+                    playspace.playspace_changed(&mut compositor_mgr, &mut chaperone_mgr);
+                }
+                EVREventType::VREvent_IpdChanged => {
+                    if let Ok(ipd) = system_mgr.get_tracked_device_property::<f32>(
+                        TrackedDeviceIndex::HMD,
+                        ETrackedDeviceProperty::Prop_UserIpdMeters_Float,
+                    ) {
+                        let ipd = (ipd * 10000.0).round() * 0.1;
+                        if (ipd - state.input_state.ipd).abs() > 0.05 {
+                            log::info!("IPD: {:.1} mm -> {:.1} mm", state.input_state.ipd, ipd);
+                            Toast::new(
+                                ToastTopic::IpdChange,
+                                "IPD".into(),
+                                format!("{ipd:.1} mm").into(),
+                            )
+                            .submit(&mut state);
+                        }
+                        state.input_state.ipd = ipd;
+                    }
+                }
+                _ => {}
+            }
+        }
+
+        if next_device_update <= Instant::now() {
+            input_source.update_devices(&mut system_mgr, &mut state);
+            next_device_update = Instant::now() + Duration::from_secs(30);
+        }
+
+        notifications.submit_pending(&mut state);
+
+        state.tasks.retrieve_due(&mut due_tasks);
+
+        let mut removed_overlays = overlays.update(&mut state)?;
+        for o in &mut removed_overlays {
+            o.destroy(&mut overlay_mgr);
+        }
+
+        while let Some(task) = due_tasks.pop_front() {
+            match task {
+                TaskType::Overlay(sel, f) => {
+                    if let Some(o) = overlays.mut_by_selector(&sel) {
+                        f(&mut state, &mut o.state);
+                    } else {
+                        log::warn!("Overlay not found for task: {sel:?}");
+                    }
+                }
+                TaskType::CreateOverlay(sel, f) => {
+                    let None = overlays.mut_by_selector(&sel) else {
+                        continue;
+                    };
+
+                    let Some((mut state, backend)) = f(&mut state) else {
+                        continue;
+                    };
+                    state.birthframe = cur_frame;
+
+                    overlays.add(OverlayData {
+                        state,
+                        backend,
+                        ..Default::default()
+                    });
+                }
+                TaskType::DropOverlay(sel) => {
+                    if let Some(o) = overlays.mut_by_selector(&sel) {
+                        if o.state.birthframe < cur_frame {
+                            o.destroy(&mut overlay_mgr);
+                            overlays.remove_by_selector(&sel);
+                        }
+                    }
+                }
+                TaskType::System(task) => match task {
+                    SystemTask::ColorGain(channel, value) => {
+                        let _ = adjust_gain(&mut settings_mgr, channel, value);
+                    }
+                    SystemTask::FixFloor => {
+                        playspace.fix_floor(&mut chaperone_mgr, &state.input_state);
+                    }
+                    SystemTask::ResetPlayspace => {
+                        playspace.reset_offset(&mut chaperone_mgr, &state.input_state);
+                    }
+                    SystemTask::ShowHide => {
+                        overlays.show_hide(&mut state);
+                    }
+                },
+                #[cfg(feature = "wayvr")]
+                TaskType::WayVR(action) => {
+                    wayvr_action(&mut state, &mut overlays, &action);
+                }
+            }
+        }
+
+        let universe = playspace.get_universe();
+
+        state.input_state.pre_update();
+        input_source.update(
+            universe.clone(),
+            &mut input_mgr,
+            &mut system_mgr,
+            &mut state,
+        );
+        state.input_state.post_update(&state.session);
+
+        if state
+            .input_state
+            .pointers
+            .iter()
+            .any(|p| p.now.show_hide && !p.before.show_hide)
+        {
+            lines.mark_dirty(); // workaround to prevent lines from not showing
+            overlays.show_hide(&mut state);
+        }
+
+        #[cfg(feature = "wayvr")]
+        if state
+            .input_state
+            .pointers
+            .iter()
+            .any(|p| p.now.toggle_dashboard && !p.before.toggle_dashboard)
+        {
+            wayvr_action(&mut state, &mut overlays, &WayVRAction::ToggleDashboard);
+        }
+
+        overlays
+            .iter_mut()
+            .for_each(|o| o.state.auto_movement(&mut state));
+
+        watch_fade(&mut state, overlays.mut_by_id(watch_id).unwrap()); // want panic
+        playspace.update(&mut chaperone_mgr, &mut overlays, &state);
+
+        let lengths_haptics = interact(&mut overlays, &mut state);
+        for (idx, (len, haptics)) in lengths_haptics.iter().enumerate() {
+            lines.draw_from(
+                pointer_lines[idx],
+                state.input_state.pointers[idx].pose,
+                *len,
+                state.input_state.pointers[idx].interaction.mode as usize + 1,
+                &state.input_state.hmd,
+            );
+            if let Some(haptics) = haptics {
+                input_source.haptics(&mut input_mgr, idx, haptics);
+            }
+        }
+
+        state.hid_provider.commit();
+        let mut buffers = CommandBuffers::default();
+
+        lines.update(universe.clone(), &mut overlay_mgr, &mut state)?;
+
+        for o in overlays.iter_mut() {
+            o.after_input(&mut overlay_mgr, &mut state)?;
+        }
+
+        #[cfg(feature = "osc")]
+        if let Some(ref mut sender) = state.osc_sender {
+            let _ = sender.send_params(&overlays, &state.input_state.devices);
+        }
+
+        #[cfg(feature = "wayvr")]
+        if let Err(e) =
+            crate::overlays::wayvr::tick_events::<OpenVrOverlayData>(&mut state, &mut overlays)
+        {
+            log::error!("WayVR tick_events failed: {e:?}");
+        }
+
+        log::trace!("Rendering frame");
+
+        for o in overlays.iter_mut() {
+            if o.state.want_visible {
+                let ShouldRender::Should = o.should_render(&mut state)? else {
+                    continue;
+                };
+                if !o.ensure_image_allocated(&mut state)? {
+                    continue;
+                }
+                o.data.image_dirty = o.render(
+                    &mut state,
+                    o.data.image_view.as_ref().unwrap().clone(),
+                    &mut buffers,
+                    1.0, // alpha is instead set using OVR API
+                )?;
+            }
+        }
+
+        log::trace!("Rendering overlays");
+
+        if let Some(mut future) = buffers.execute_now(state.gfx.queue_gfx.clone())? {
+            if let Err(e) = future.flush() {
+                return Err(BackendError::Fatal(e.into()));
+            }
+            future.cleanup_finished();
+        }
+
+        overlays
+            .iter_mut()
+            .for_each(|o| o.after_render(universe.clone(), &mut overlay_mgr, &state.gfx));
+
+        #[cfg(feature = "wayvr")]
+        if let Some(wayvr) = &state.wayvr {
+            wayvr.borrow_mut().data.tick_finish()?;
+        }
+
+        // chaperone
+
+        // close font handles?
+    }
+
+    log::warn!("OpenVR shutdown");
+    // context.shutdown() called by Drop
+
+    Ok(())
+}

wlx-overlay-s/src/backend/openvr/overlay.rs

@@ -0,0 +1,299 @@
+use core::f32;
+use std::sync::Arc;
+
+use glam::Vec4;
+use ovr_overlay::{
+    overlay::{OverlayHandle, OverlayManager},
+    pose::Matrix3x4,
+    sys::{ETrackingUniverseOrigin, VRVulkanTextureData_t},
+};
+use vulkano::{
+    image::{view::ImageView, ImageUsage},
+    Handle, VulkanObject,
+};
+use wgui::gfx::WGfx;
+
+use crate::{backend::overlay::OverlayData, state::AppState};
+
+use super::helpers::Affine3AConvert;
+
+#[derive(Default)]
+pub(super) struct OpenVrOverlayData {
+    pub(super) handle: Option<OverlayHandle>,
+    pub(super) visible: bool,
+    pub(super) color: Vec4,
+    pub(crate) width: f32,
+    pub(super) override_width: bool,
+    pub(super) image_view: Option<Arc<ImageView>>,
+    pub(super) image_dirty: bool,
+}
+
+impl OverlayData<OpenVrOverlayData> {
+    pub(super) fn initialize(
+        &mut self,
+        overlay: &mut OverlayManager,
+        app: &mut AppState,
+    ) -> anyhow::Result<OverlayHandle> {
+        let key = format!("wlx-{}", self.state.name);
+        log::debug!("Create overlay with key: {}", &key);
+        let handle = match overlay.create_overlay(&key, &key) {
+            Ok(handle) => handle,
+            Err(e) => {
+                panic!("Failed to create overlay: {e}");
+            }
+        };
+        log::debug!("{}: initialize", self.state.name);
+
+        self.data.handle = Some(handle);
+        self.data.color = Vec4::ONE;
+
+        self.init(app)?;
+
+        if self.data.width < f32::EPSILON {
+            self.data.width = 1.0;
+        }
+
+        self.upload_width(overlay);
+        self.upload_color(overlay);
+        self.upload_alpha(overlay);
+        self.upload_curvature(overlay);
+        self.upload_sort_order(overlay);
+
+        Ok(handle)
+    }
+
+    pub(super) fn ensure_image_allocated(&mut self, app: &mut AppState) -> anyhow::Result<bool> {
+        if self.data.image_view.is_some() {
+            return Ok(true);
+        }
+        let Some(meta) = self.backend.frame_meta() else {
+            return Ok(false);
+        };
+        let image = app.gfx.new_image(
+            meta.extent[0],
+            meta.extent[1],
+            app.gfx.surface_format,
+            ImageUsage::TRANSFER_SRC | ImageUsage::COLOR_ATTACHMENT | ImageUsage::SAMPLED,
+        )?;
+        self.data.image_view = Some(ImageView::new_default(image)?);
+        Ok(true)
+    }
+
+    pub(super) fn after_input(
+        &mut self,
+        overlay: &mut OverlayManager,
+        app: &mut AppState,
+    ) -> anyhow::Result<()> {
+        if self.state.want_visible && !self.data.visible {
+            self.show_internal(overlay, app)?;
+        } else if !self.state.want_visible && self.data.visible {
+            self.hide_internal(overlay, app)?;
+        }
+        Ok(())
+    }
+
+    pub(super) fn after_render(
+        &mut self,
+        universe: ETrackingUniverseOrigin,
+        overlay: &mut OverlayManager,
+        graphics: &WGfx,
+    ) {
+        if self.data.visible {
+            if self.state.dirty {
+                self.upload_curvature(overlay);
+
+                self.upload_transform(universe, overlay);
+                self.upload_alpha(overlay);
+                self.state.dirty = false;
+            }
+            self.upload_texture(overlay, graphics);
+        }
+    }
+
+    fn show_internal(
+        &mut self,
+        overlay: &mut OverlayManager,
+        app: &mut AppState,
+    ) -> anyhow::Result<()> {
+        let handle = match self.data.handle {
+            Some(handle) => handle,
+            None => self.initialize(overlay, app)?,
+        };
+        log::debug!("{}: show", self.state.name);
+        if let Err(e) = overlay.set_visibility(handle, true) {
+            log::error!("{}: Failed to show overlay: {}", self.state.name, e);
+        }
+        self.data.visible = true;
+        self.backend.resume(app)
+    }
+
+    fn hide_internal(
+        &mut self,
+        overlay: &mut OverlayManager,
+        app: &mut AppState,
+    ) -> anyhow::Result<()> {
+        let Some(handle) = self.data.handle else {
+            return Ok(());
+        };
+        log::debug!("{}: hide", self.state.name);
+        if let Err(e) = overlay.set_visibility(handle, false) {
+            log::error!("{}: Failed to hide overlay: {}", self.state.name, e);
+        }
+        self.data.visible = false;
+        self.backend.pause(app)
+    }
+
+    pub(super) fn upload_alpha(&self, overlay: &mut OverlayManager) {
+        let Some(handle) = self.data.handle else {
+            log::debug!("{}: No overlay handle", self.state.name);
+            return;
+        };
+        if let Err(e) = overlay.set_opacity(handle, self.state.alpha) {
+            log::error!("{}: Failed to set overlay alpha: {}", self.state.name, e);
+        }
+    }
+
+    pub(super) fn upload_color(&self, overlay: &mut OverlayManager) {
+        let Some(handle) = self.data.handle else {
+            log::debug!("{}: No overlay handle", self.state.name);
+            return;
+        };
+        if let Err(e) = overlay.set_tint(
+            handle,
+            ovr_overlay::ColorTint {
+                r: self.data.color.x,
+                g: self.data.color.y,
+                b: self.data.color.z,
+                a: self.data.color.w,
+            },
+        ) {
+            log::error!("{}: Failed to set overlay tint: {}", self.state.name, e);
+        }
+    }
+
+    fn upload_width(&self, overlay: &mut OverlayManager) {
+        let Some(handle) = self.data.handle else {
+            log::debug!("{}: No overlay handle", self.state.name);
+            return;
+        };
+        if let Err(e) = overlay.set_width(handle, self.data.width) {
+            log::error!("{}: Failed to set overlay width: {}", self.state.name, e);
+        }
+    }
+
+    fn upload_curvature(&self, overlay: &mut OverlayManager) {
+        let Some(handle) = self.data.handle else {
+            log::debug!("{}: No overlay handle", self.state.name);
+            return;
+        };
+        if let Err(e) = overlay.set_curvature(handle, self.state.curvature.unwrap_or(0.0)) {
+            log::error!(
+                "{}: Failed to set overlay curvature: {}",
+                self.state.name,
+                e
+            );
+        }
+    }
+
+    fn upload_sort_order(&self, overlay: &mut OverlayManager) {
+        let Some(handle) = self.data.handle else {
+            log::debug!("{}: No overlay handle", self.state.name);
+            return;
+        };
+        if let Err(e) = overlay.set_sort_order(handle, self.state.z_order) {
+            log::error!("{}: Failed to set overlay z order: {}", self.state.name, e);
+        }
+    }
+
+    pub(super) fn upload_transform(
+        &mut self,
+        universe: ETrackingUniverseOrigin,
+        overlay: &mut OverlayManager,
+    ) {
+        let Some(handle) = self.data.handle else {
+            log::debug!("{}: No overlay handle", self.state.name);
+            return;
+        };
+
+        let effective = self.state.transform
+            * self
+                .backend
+                .frame_meta()
+                .map(|f| f.transform)
+                .unwrap_or_default();
+
+        let transform = Matrix3x4::from_affine(&effective);
+
+        if let Err(e) = overlay.set_transform_absolute(handle, universe, &transform) {
+            log::error!(
+                "{}: Failed to set overlay transform: {}",
+                self.state.name,
+                e
+            );
+        }
+    }
+
+    pub(super) fn upload_texture(&mut self, overlay: &mut OverlayManager, graphics: &WGfx) {
+        let Some(handle) = self.data.handle else {
+            log::debug!("{}: No overlay handle", self.state.name);
+            return;
+        };
+
+        let Some(view) = self.data.image_view.as_ref() else {
+            log::debug!("{}: Not rendered", self.state.name);
+            return;
+        };
+
+        if !self.data.image_dirty {
+            return;
+        }
+        self.data.image_dirty = false;
+
+        let image = view.image().clone();
+        let dimensions = image.extent();
+        if !self.data.override_width {
+            let new_width = ((dimensions[0] as f32) / (dimensions[1] as f32)).min(1.0);
+            if (new_width - self.data.width).abs() > f32::EPSILON {
+                log::info!("{}: New width {}", self.state.name, new_width);
+                self.data.width = new_width;
+                self.upload_width(overlay);
+            }
+        }
+
+        let raw_image = image.handle().as_raw();
+        let format = image.format();
+
+        let mut texture = VRVulkanTextureData_t {
+            m_nImage: raw_image,
+            m_nFormat: format as _,
+            m_nWidth: dimensions[0],
+            m_nHeight: dimensions[1],
+            m_nSampleCount: image.samples() as u32,
+            m_pDevice: graphics.device.handle().as_raw() as *mut _,
+            m_pPhysicalDevice: graphics.device.physical_device().handle().as_raw() as *mut _,
+            m_pInstance: graphics.instance.handle().as_raw() as *mut _,
+            m_pQueue: graphics.queue_gfx.handle().as_raw() as *mut _,
+            m_nQueueFamilyIndex: graphics.queue_gfx.queue_family_index(),
+        };
+        log::trace!(
+            "{}: UploadTex {:?}, {}x{}, {:?}",
+            self.state.name,
+            format,
+            texture.m_nWidth,
+            texture.m_nHeight,
+            image.usage()
+        );
+        if let Err(e) = overlay.set_image_vulkan(handle, &mut texture) {
+            log::error!("{}: Failed to set overlay texture: {}", self.state.name, e);
+        }
+    }
+
+    pub(super) fn destroy(&mut self, overlay: &mut OverlayManager) {
+        if let Some(handle) = self.data.handle {
+            log::debug!("{}: destroy", self.state.name);
+            if let Err(e) = overlay.destroy_overlay(handle) {
+                log::error!("{}: Failed to destroy overlay: {}", self.state.name, e);
+            }
+        }
+    }
+}

wlx-overlay-s/src/backend/openvr/playspace.rs

@@ -0,0 +1,302 @@
+use glam::{Affine3A, Quat, Vec3, Vec3A};
+use ovr_overlay::{
+    chaperone_setup::ChaperoneSetupManager,
+    compositor::CompositorManager,
+    sys::{EChaperoneConfigFile, ETrackingUniverseOrigin, HmdMatrix34_t},
+};
+
+use crate::{
+    backend::{common::OverlayContainer, input::InputState},
+    state::AppState,
+};
+
+use super::{helpers::Affine3AConvert, overlay::OpenVrOverlayData};
+
+struct MoverData<T> {
+    pose: Affine3A,
+    hand: usize,
+    hand_pose: T,
+}
+
+pub(super) struct PlayspaceMover {
+    universe: ETrackingUniverseOrigin,
+    drag: Option<MoverData<Vec3A>>,
+    rotate: Option<MoverData<Quat>>,
+}
+
+impl PlayspaceMover {
+    pub const fn new() -> Self {
+        Self {
+            universe: ETrackingUniverseOrigin::TrackingUniverseRawAndUncalibrated,
+            drag: None,
+            rotate: None,
+        }
+    }
+
+    #[allow(clippy::too_many_lines, clippy::cognitive_complexity)]
+    pub fn update(
+        &mut self,
+        chaperone_mgr: &mut ChaperoneSetupManager,
+        overlays: &mut OverlayContainer<OpenVrOverlayData>,
+        state: &AppState,
+    ) {
+        let universe = self.universe.clone();
+
+        if let Some(data) = self.rotate.as_mut() {
+            let pointer = &state.input_state.pointers[data.hand];
+            if !pointer.now.space_rotate {
+                self.rotate = None;
+                log::info!("End space rotate");
+                return;
+            }
+
+            let new_hand =
+                Quat::from_affine3(&(data.pose * state.input_state.pointers[data.hand].raw_pose));
+
+            let dq = new_hand * data.hand_pose.conjugate();
+            let rel_y = f32::atan2(
+                2.0 * dq.y.mul_add(dq.w, dq.x * dq.z),
+                2.0f32.mul_add(dq.w.mul_add(dq.w, dq.x * dq.x), -1.0),
+            );
+
+            let mut space_transform = Affine3A::from_rotation_y(rel_y);
+            let offset = (space_transform.transform_vector3a(state.input_state.hmd.translation)
+                - state.input_state.hmd.translation)
+                * -1.0;
+            let mut overlay_transform = Affine3A::from_rotation_y(-rel_y);
+
+            overlay_transform.translation = offset;
+            space_transform.translation = offset;
+
+            overlays.iter_mut().for_each(|overlay| {
+                if overlay.state.grabbable {
+                    overlay.state.dirty = true;
+                    overlay.state.transform.translation =
+                        overlay_transform.transform_point3a(overlay.state.transform.translation);
+                }
+            });
+
+            data.pose *= space_transform;
+            data.hand_pose = new_hand;
+
+            if self.universe == ETrackingUniverseOrigin::TrackingUniverseStanding {
+                apply_chaperone_transform(space_transform.inverse(), chaperone_mgr);
+            }
+            set_working_copy(&universe, chaperone_mgr, &data.pose);
+            chaperone_mgr.commit_working_copy(EChaperoneConfigFile::EChaperoneConfigFile_Live);
+        } else {
+            for (i, pointer) in state.input_state.pointers.iter().enumerate() {
+                if pointer.now.space_rotate {
+                    let Some(mat) = get_working_copy(&universe, chaperone_mgr) else {
+                        log::warn!("Can't space rotate - failed to get zero pose");
+                        return;
+                    };
+                    let hand_pose = Quat::from_affine3(&(mat * pointer.raw_pose));
+                    self.rotate = Some(MoverData {
+                        pose: mat,
+                        hand: i,
+                        hand_pose,
+                    });
+                    self.drag = None;
+                    log::info!("Start space rotate");
+                    return;
+                }
+            }
+        }
+
+        if let Some(data) = self.drag.as_mut() {
+            let pointer = &state.input_state.pointers[data.hand];
+            if !pointer.now.space_drag {
+                self.drag = None;
+                log::info!("End space drag");
+                return;
+            }
+
+            let new_hand = data
+                .pose
+                .transform_point3a(state.input_state.pointers[data.hand].raw_pose.translation);
+            let relative_pos =
+                (new_hand - data.hand_pose) * state.session.config.space_drag_multiplier;
+
+            if relative_pos.length_squared() > 1000.0 {
+                log::warn!("Space drag too fast, ignoring");
+                return;
+            }
+
+            let overlay_offset = data.pose.inverse().transform_vector3a(relative_pos) * -1.0;
+
+            overlays.iter_mut().for_each(|overlay| {
+                if overlay.state.grabbable {
+                    overlay.state.dirty = true;
+                    overlay.state.transform.translation += overlay_offset;
+                }
+            });
+
+            data.pose.translation += relative_pos;
+            data.hand_pose = new_hand;
+
+            if self.universe == ETrackingUniverseOrigin::TrackingUniverseStanding {
+                apply_chaperone_offset(overlay_offset, chaperone_mgr);
+            }
+            set_working_copy(&universe, chaperone_mgr, &data.pose);
+            chaperone_mgr.commit_working_copy(EChaperoneConfigFile::EChaperoneConfigFile_Live);
+        } else {
+            for (i, pointer) in state.input_state.pointers.iter().enumerate() {
+                if pointer.now.space_drag {
+                    let Some(mat) = get_working_copy(&universe, chaperone_mgr) else {
+                        log::warn!("Can't space drag - failed to get zero pose");
+                        return;
+                    };
+                    let hand_pos = mat.transform_point3a(pointer.raw_pose.translation);
+                    self.drag = Some(MoverData {
+                        pose: mat,
+                        hand: i,
+                        hand_pose: hand_pos,
+                    });
+                    self.rotate = None;
+                    log::info!("Start space drag");
+                    return;
+                }
+            }
+        }
+    }
+
+    pub fn reset_offset(&mut self, chaperone_mgr: &mut ChaperoneSetupManager, input: &InputState) {
+        let mut height = 1.6;
+        if let Some(mat) = get_working_copy(&self.universe, chaperone_mgr) {
+            height = input.hmd.translation.y - mat.translation.y;
+            if self.universe == ETrackingUniverseOrigin::TrackingUniverseStanding {
+                apply_chaperone_transform(mat, chaperone_mgr);
+            }
+        }
+
+        let xform = if self.universe == ETrackingUniverseOrigin::TrackingUniverseSeated {
+            Affine3A::from_translation(Vec3::NEG_Y * height)
+        } else {
+            Affine3A::IDENTITY
+        };
+
+        set_working_copy(&self.universe, chaperone_mgr, &xform);
+        chaperone_mgr.commit_working_copy(EChaperoneConfigFile::EChaperoneConfigFile_Live);
+
+        if self.drag.is_some() {
+            log::info!("Space drag interrupted by manual reset");
+            self.drag = None;
+        }
+        if self.rotate.is_some() {
+            log::info!("Space rotate interrupted by manual reset");
+            self.rotate = None;
+        }
+    }
+
+    pub fn fix_floor(&mut self, chaperone_mgr: &mut ChaperoneSetupManager, input: &InputState) {
+        let y1 = input.pointers[0].pose.translation.y;
+        let y2 = input.pointers[1].pose.translation.y;
+        let Some(mut mat) = get_working_copy(&self.universe, chaperone_mgr) else {
+            log::warn!("Can't fix floor - failed to get zero pose");
+            return;
+        };
+        let offset = y1.min(y2) - 0.03;
+        mat.translation.y += offset;
+
+        set_working_copy(&self.universe, chaperone_mgr, &mat);
+        chaperone_mgr.commit_working_copy(EChaperoneConfigFile::EChaperoneConfigFile_Live);
+
+        if self.drag.is_some() {
+            log::info!("Space drag interrupted by fix floor");
+            self.drag = None;
+        }
+        if self.rotate.is_some() {
+            log::info!("Space rotate interrupted by fix floor");
+            self.rotate = None;
+        }
+    }
+
+    pub fn playspace_changed(
+        &mut self,
+        compositor_mgr: &mut CompositorManager,
+        _chaperone_mgr: &mut ChaperoneSetupManager,
+    ) {
+        let new_universe = compositor_mgr.get_tracking_space();
+        if new_universe != self.universe {
+            log::info!(
+                "Playspace changed: {} -> {}",
+                universe_str(&self.universe),
+                universe_str(&new_universe)
+            );
+            self.universe = new_universe;
+        }
+
+        if self.drag.is_some() {
+            log::info!("Space drag interrupted by external change");
+            self.drag = None;
+        }
+        if self.rotate.is_some() {
+            log::info!("Space rotate interrupted by external change");
+            self.rotate = None;
+        }
+    }
+
+    pub fn get_universe(&self) -> ETrackingUniverseOrigin {
+        self.universe.clone()
+    }
+}
+
+const fn universe_str(universe: &ETrackingUniverseOrigin) -> &'static str {
+    match universe {
+        ETrackingUniverseOrigin::TrackingUniverseSeated => "Seated",
+        ETrackingUniverseOrigin::TrackingUniverseStanding => "Standing",
+        ETrackingUniverseOrigin::TrackingUniverseRawAndUncalibrated => "Raw",
+    }
+}
+
+fn get_working_copy(
+    universe: &ETrackingUniverseOrigin,
+    chaperone_mgr: &mut ChaperoneSetupManager,
+) -> Option<Affine3A> {
+    chaperone_mgr.revert_working_copy();
+    let mat = match universe {
+        ETrackingUniverseOrigin::TrackingUniverseStanding => {
+            chaperone_mgr.get_working_standing_zero_pose_to_raw_tracking_pose()
+        }
+        _ => chaperone_mgr.get_working_seated_zero_pose_to_raw_tracking_pose(),
+    };
+    mat.map(|m| m.to_affine())
+}
+
+fn set_working_copy(
+    universe: &ETrackingUniverseOrigin,
+    chaperone_mgr: &mut ChaperoneSetupManager,
+    mat: &Affine3A,
+) {
+    let mat = HmdMatrix34_t::from_affine(mat);
+    match universe {
+        ETrackingUniverseOrigin::TrackingUniverseStanding => {
+            chaperone_mgr.set_working_standing_zero_pose_to_raw_tracking_pose(&mat);
+        }
+        _ => chaperone_mgr.set_working_seated_zero_pose_to_raw_tracking_pose(&mat),
+    }
+}
+
+fn apply_chaperone_offset(offset: Vec3A, chaperone_mgr: &mut ChaperoneSetupManager) {
+    let mut quads = chaperone_mgr.get_live_collision_bounds_info();
+    for quad in &mut quads {
+        quad.vCorners.iter_mut().for_each(|corner| {
+            corner.v[0] += offset.x;
+            corner.v[2] += offset.z;
+        });
+    }
+    chaperone_mgr.set_working_collision_bounds_info(quads.as_mut_slice());
+}
+
+fn apply_chaperone_transform(transform: Affine3A, chaperone_mgr: &mut ChaperoneSetupManager) {
+    let mut quads = chaperone_mgr.get_live_collision_bounds_info();
+    for quad in &mut quads {
+        quad.vCorners.iter_mut().for_each(|corner| {
+            let coord = transform.transform_point3a(Vec3A::from_slice(&corner.v));
+            corner.v[0] = coord.x;
+            corner.v[2] = coord.z;
+        });
+    }
+    chaperone_mgr.set_working_collision_bounds_info(quads.as_mut_slice());
+}