Jayden/wayvr
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

switch to using libmonado-rs

Browse Source
This commit is contained in:
galister
2024-07-31 05:28:34 +09:00
parent dcc2cd0575
commit 3d0611052f
6 changed files with 175 additions and 387 deletions
Download Patch File Download Diff File Expand all files Collapse all files

55
src/backend/openxr/helpers.rs
View File

@@ -1,9 +1,6 @@
use std::path::PathBuf;
use anyhow::{bail, ensure};
use glam::{Affine3A, Quat, Vec3, Vec3A};
use openxr as xr;
use sysinfo::Process;
use xr::OverlaySessionCreateFlagsEXTX;
pub(super) fn init_xr() -> Result<(xr::Instance, xr::SystemId), anyhow::Error> {
@@ -35,6 +32,12 @@ pub(super) fn init_xr() -> Result<(xr::Instance, xr::SystemId), anyhow::Error> {
} else {
log::warn!("Missing EXT_hp_mixed_reality_controller extension.");
}
if available_extensions.khr_composition_layer_cylinder {
enabled_extensions.khr_composition_layer_cylinder = true;
} else {
log::warn!("Missing EXT_composition_layer_cylinder extension.");
}
if available_extensions.khr_composition_layer_equirect2 {
enabled_extensions.khr_composition_layer_equirect2 = true;
} else {
@@ -178,49 +181,3 @@ pub(super) fn transform_to_posef(transform: &Affine3A) -> xr::Posef {
let rotation = transform_to_norm_quat(transform);
translation_rotation_to_posef(translation, rotation)
}
pub(super) fn find_libmonado() -> anyhow::Result<libloading::Library> {
//check env var first
if let Ok(path) = std::env::var("LIBMONADO_PATH") {
let path = PathBuf::from(path);
if path.exists() {
return Ok(unsafe { libloading::Library::new(path)? });
} else {
bail!("LIBMONADO_PATH points to a non-existing file.");
}
}
const PROC_NAMES: [&str; 2] = ["monado-service", "wivrn-server"];
let mut system = sysinfo::System::new();
system.refresh_processes();
for p in system.processes().values() {
for proc_name in PROC_NAMES.iter() {
if p.name().contains(proc_name) {
if let Some(lib) = proc_load_libmonado(p) {
return Ok(lib);
}
}
}
}
bail!("Could not find libmonado.");
}
fn proc_load_libmonado(proc: &Process) -> Option<libloading::Library> {
// relative to folder containing binary
const SEARCH_PATHS: [&str; 3] = [
"../lib/libmonado.so",
"../libmonado/libmonado.so",
"../_deps/monado-build/src/xrt/targets/libmonado/libmonado.so",
];
for &p in SEARCH_PATHS.iter() {
let path = proc.exe()?.parent()?.join(p);
if path.exists() {
return Some(unsafe { libloading::Library::new(path).ok()? });
}
}
None
}

149
src/backend/openxr/libmonado.rs
View File

@@ -1,149 +0,0 @@
use std::{env, ffi::c_void, fs};
use anyhow::bail;
use libloading::{Library, Symbol};
use serde::Deserialize;
#[repr(C)]
#[derive(Default, Debug)]
struct MndPose {
orientation: [f32; 4],
position: [f32; 3],
}
const MND_REFERENCE_TYPE_STAGE: i32 = 3;
const MND_SUCCESS: i32 = 0;
const MND_ERROR_BAD_SPACE_TYPE: i32 = -7;
type GetDeviceCount = extern "C" fn(*mut c_void, *mut u32) -> i32;
type GetDeviceInfo = extern "C" fn(*mut c_void, u32, *mut u32, *mut *const char) -> i32;
type GetDeviceFromRole = extern "C" fn(*mut c_void, *const std::os::raw::c_char, *mut i32) -> i32;
type GetDeviceBatteryStatus =
extern "C" fn(*mut c_void, u32, *mut bool, *mut bool, *mut f32) -> i32;
type PlaySpaceMove = extern "C" fn(*mut c_void, f32, f32, f32) -> i32;
type ApplyStageOffset = extern "C" fn(*mut c_void, *const MndPose) -> i32;
// New implementation
type GetReferenceSpaceOffset = extern "C" fn(*mut c_void, i32, *mut MndPose) -> i32;
type SetReferenceSpaceOffset = extern "C" fn(*mut c_void, i32, *const MndPose) -> i32;
// TODO: Clean up after merge into upstream Monado
enum MoverImpl {
None,
PlaySpaceMove(PlaySpaceMove),
ApplyStageOffset(ApplyStageOffset),
SpaceOffsetApi {
get_reference: GetReferenceSpaceOffset,
set_reference: SetReferenceSpaceOffset,
},
}
pub struct LibMonado {
libmonado: Library,
mnd_root: *mut c_void,
mover: MoverImpl,
}
impl Drop for LibMonado {
fn drop(&mut self) {
unsafe {
type RootDestroy = extern "C" fn(*mut *mut c_void) -> i32;
let Ok(root_destroy) = self.libmonado.get::<RootDestroy>(b"mnd_root_destroy\0") else {
return;
};
root_destroy(&mut self.mnd_root);
}
}
}
impl LibMonado {
pub fn new() -> anyhow::Result<Self> {
let lib_path = if let Ok(path) = env::var("LIBMONADO_PATH") {
path
} else if let Some(path) = xr_runtime_manifest()
.map(|manifest| manifest.runtime.mnd_libmonado_path)
.ok()
.flatten()
{
path
} else {
bail!("Monado: libmonado not found. Update your Monado/WiVRn or set LIBMONADO_PATH to point at your libmonado.so");
};
let (libmonado, mnd_root) = unsafe {
let libmonado = libloading::Library::new(lib_path)?;
let root_create: Symbol<extern "C" fn(*mut *mut c_void) -> i32> =
libmonado.get(b"mnd_root_create\0")?;
let mut root: *mut c_void = std::ptr::null_mut();
let ret = root_create(&mut root);
if ret != 0 {
anyhow::bail!("Failed to create libmonado root, code: {}", ret);
}
(libmonado, root)
};
let space_api = unsafe {
if let (Ok(get_reference), Ok(set_reference)) = (
libmonado.get(b"mnd_root_get_reference_space_offset\0"),
libmonado.get(b"mnd_root_set_reference_space_offset\0"),
) {
log::info!("Monado: using space offset API");
let get_reference: GetReferenceSpaceOffset = *get_reference;
let set_reference: SetReferenceSpaceOffset = *set_reference;
MoverImpl::SpaceOffsetApi {
get_reference,
set_reference,
}
} else if let Ok(playspace_move) = libmonado.get(b"mnd_root_playspace_move\0") {
log::warn!("Monado: using playspace_move, which is obsolete. Consider updating.");
MoverImpl::PlaySpaceMove(*playspace_move)
} else if let Ok(apply_stage_offset) = libmonado.get(b"mnd_root_apply_stage_offset\0") {
log::warn!(
"Monado: using apply_stage_offset, which is obsolete. Consider updating."
);
MoverImpl::ApplyStageOffset(*apply_stage_offset)
} else {
MoverImpl::None
}
};
Ok(Self {
libmonado,
mnd_root,
mover: space_api,
})
}
pub fn mover_supported(&self) -> bool {
!matches!(self.mover, MoverImpl::None)
}
}
#[derive(Deserialize)]
struct XrRuntimeManifestRuntime {
name: String,
library_path: String,
mnd_libmonado_path: Option<String>,
}
#[derive(Deserialize)]
struct XrRuntimeManifest {
file_format_version: String,
runtime: XrRuntimeManifestRuntime,
}
fn xr_runtime_manifest() -> anyhow::Result<XrRuntimeManifest> {
let xdg_dirs = xdg::BaseDirectories::new()?; // only fails if $HOME unset
let mut file = xdg_dirs.get_config_home();
file.push("openxr/1/active_runtime.json");
let json = fs::read_to_string(file)?;
let manifest = serde_json::from_str(&json)?;
Ok(manifest)
}

18
src/backend/openxr/mod.rs
View File

@@ -9,6 +9,7 @@ use std::{
};
use glam::{Affine3A, Vec3};
use libmonado_rs::Monado;
use openxr as xr;
use skybox::create_skybox;
use vulkano::{command_buffer::CommandBufferUsage, Handle, VulkanObject};
@@ -84,10 +85,17 @@ pub fn openxr_run(running: Arc<AtomicBool>, show_by_default: bool) -> Result<(),
notifications.run_udp();
let mut delete_queue = vec![];
let mut playspace = playspace::PlayspaceMover::try_new()
.map_err(|e| log::warn!("Will not use Monado playspace mover: {}", e))
let mut monado = Monado::auto_connect()
.map_err(|e| log::warn!("Will not use libmonado: {}", e))
.ok();
let mut playspace = monado.as_mut().and_then(|m| {
playspace::PlayspaceMover::new(m)
.map_err(|e| log::warn!("Will not use Monado playspace mover: {}", e))
.ok()
});
#[cfg(feature = "osc")]
let mut osc_sender =
crate::backend::osc::OscSender::new(app_state.session.config.osc_out_port).ok();
@@ -236,7 +244,7 @@ pub fn openxr_run(running: Arc<AtomicBool>, show_by_default: bool) -> Result<(),
watch_fade(&mut app_state, overlays.mut_by_id(watch_id).unwrap()); // want panic
if let Some(ref mut space_mover) = playspace {
space_mover.update(&mut overlays, &app_state);
space_mover.update(&mut overlays, &app_state, monado.as_mut().unwrap());
}
for o in overlays.iter_mut() {
@@ -416,12 +424,12 @@ pub fn openxr_run(running: Arc<AtomicBool>, show_by_default: bool) -> Result<(),
TaskType::System(task) => match task {
SystemTask::FixFloor => {
if let Some(ref mut playspace) = playspace {
playspace.fix_floor(&app_state.input_state);
playspace.fix_floor(&app_state.input_state, monado.as_mut().unwrap());
}
}
SystemTask::ResetPlayspace => {
if let Some(ref mut playspace) = playspace {
playspace.reset_offset();
playspace.reset_offset(monado.as_mut().unwrap());
}
}
SystemTask::ShowHide => {

167
src/backend/openxr/playspace.rs
View File

@@ -1,13 +1,12 @@
use glam::{Affine3A, Quat, Vec3, Vec3A};
use libloading::{Library, Symbol};
use std::ffi::c_void;
use glam::{Affine3A, Quat, Vec3A};
use libmonado_rs::{Monado, Pose, ReferenceSpaceType};
use crate::{
backend::{common::OverlayContainer, input::InputState},
state::AppState,
};
use super::{helpers, overlay::OpenXrOverlayData};
use super::overlay::OpenXrOverlayData;
#[repr(C)]
#[derive(Default, Debug)]
@@ -16,116 +15,46 @@ struct XrtPose {
position: [f32; 3],
}
const XRT_REFERENCE_TYPE_STAGE: i32 = 3;
const MND_SUCCESS: i32 = 0;
const MND_ERROR_BAD_SPACE_TYPE: i32 = -7;
struct MoverData<T> {
pose: Affine3A,
hand: usize,
hand_pose: T,
}
// Legacy implementations
type PlaySpaceMove = extern "C" fn(*mut c_void, f32, f32, f32) -> i32;
type ApplyStageOffset = extern "C" fn(*mut c_void, *const XrtPose) -> i32;
// New implementation
type GetReferenceSpaceOffset = extern "C" fn(*mut c_void, i32, *mut XrtPose) -> i32;
type SetReferenceSpaceOffset = extern "C" fn(*mut c_void, i32, *const XrtPose) -> i32;
// TODO: Clean up after merge into upstream Monado
enum ApiImpl {
None,
PlaySpaceMove(PlaySpaceMove),
ApplyStageOffset(ApplyStageOffset),
SpaceOffsetApi {
get_reference: GetReferenceSpaceOffset,
set_reference: SetReferenceSpaceOffset,
},
}
pub(super) struct PlayspaceMover {
last_transform: Affine3A,
drag: Option<MoverData<Vec3A>>,
rotate: Option<MoverData<Quat>>,
libmonado: Library,
mnd_root: *mut c_void,
api_impl: ApiImpl,
}
impl PlayspaceMover {
pub fn try_new() -> anyhow::Result<Self> {
unsafe {
let libmonado = helpers::find_libmonado()?;
pub fn new(monado: &mut Monado) -> anyhow::Result<Self> {
log::info!("Monado: using space offset API");
let root_create: Symbol<extern "C" fn(*mut *mut c_void) -> i32> =
libmonado.get(b"mnd_root_create\0")?;
let Ok(stage) = monado.get_reference_space_offset(ReferenceSpaceType::Stage) else {
anyhow::bail!("Space offsets not supported.");
};
let mut root: *mut c_void = std::ptr::null_mut();
let ret = root_create(&mut root);
if ret != 0 {
anyhow::bail!("Failed to create root, code: {}", ret);
}
log::debug!("STAGE is at {:?}, {:?}", stage.position, stage.orientation);
let mut api_impl = ApiImpl::None;
let mut initial_offset = Affine3A::IDENTITY;
// initial offset
let last_transform =
Affine3A::from_rotation_translation(stage.orientation.into(), stage.position.into());
if let (Ok(get_reference), Ok(set_reference)) = (
libmonado.get(b"mnd_root_get_reference_space_offset\0"),
libmonado.get(b"mnd_root_set_reference_space_offset\0"),
) {
log::info!("Monado: using space offset API");
Ok(Self {
last_transform,
let get_reference: GetReferenceSpaceOffset = *get_reference;
let set_reference: SetReferenceSpaceOffset = *set_reference;
let mut stage = XrtPose::default();
match (get_reference)(root, XRT_REFERENCE_TYPE_STAGE, &mut stage) {
MND_SUCCESS => {
log::debug!("STAGE is at {:?}, {:?}", stage.position, stage.orientation);
initial_offset = Affine3A::from_rotation_translation(
Quat::from_slice(&stage.orientation),
Vec3::from_slice(&stage.position),
);
}
_ => anyhow::bail!("Space offsets not supported."),
};
api_impl = ApiImpl::SpaceOffsetApi {
get_reference,
set_reference,
};
} else if let Ok(playspace_move) = libmonado.get(b"mnd_root_playspace_move\0") {
log::warn!("Monado: using playspace_move, which is obsolete. Consider updating.");
api_impl = ApiImpl::PlaySpaceMove(*playspace_move);
} else if let Ok(apply_stage_offset) = libmonado.get(b"mnd_root_apply_stage_offset\0") {
log::warn!(
"Monado: using apply_stage_offset, which is obsolete. Consider updating."
);
api_impl = ApiImpl::ApplyStageOffset(*apply_stage_offset);
}
if let ApiImpl::None = api_impl {
anyhow::bail!("Monado does not support playspace mover.");
}
Ok(Self {
last_transform: initial_offset,
drag: None,
rotate: None,
libmonado,
mnd_root: root,
api_impl,
})
}
drag: None,
rotate: None,
})
}
pub fn update(&mut self, overlays: &mut OverlayContainer<OpenXrOverlayData>, state: &AppState) {
pub fn update(
&mut self,
overlays: &mut OverlayContainer<OpenXrOverlayData>,
state: &AppState,
monado: &mut Monado,
) {
if let Some(mut data) = self.rotate.take() {
let pointer = &state.input_state.pointers[data.hand];
if !pointer.now.space_rotate {
@@ -164,7 +93,7 @@ impl PlayspaceMover {
data.pose *= space_transform;
data.hand_pose = new_hand;
self.apply_offset(data.pose);
self.apply_offset(data.pose, monado);
self.rotate = Some(data);
} else {
for (i, pointer) in state.input_state.pointers.iter().enumerate() {
@@ -213,7 +142,7 @@ impl PlayspaceMover {
data.pose.translation += relative_pos;
data.hand_pose = new_hand;
self.apply_offset(data.pose);
self.apply_offset(data.pose, monado);
self.drag = Some(data);
} else {
for (i, pointer) in state.input_state.pointers.iter().enumerate() {
@@ -233,7 +162,7 @@ impl PlayspaceMover {
}
}
pub fn reset_offset(&mut self) {
pub fn reset_offset(&mut self, monado: &mut Monado) {
if self.drag.is_some() {
log::info!("Space drag interrupted by manual reset");
self.drag = None;
@@ -244,10 +173,10 @@ impl PlayspaceMover {
}
self.last_transform = Affine3A::IDENTITY;
self.apply_offset(self.last_transform);
self.apply_offset(self.last_transform, monado);
}
pub fn fix_floor(&mut self, input: &InputState) {
pub fn fix_floor(&mut self, input: &InputState, monado: &mut Monado) {
if self.drag.is_some() {
log::info!("Space drag interrupted by fix floor");
self.drag = None;
@@ -261,40 +190,14 @@ impl PlayspaceMover {
let y2 = input.pointers[1].pose.translation.y;
let delta = y1.min(y2) - 0.03;
self.last_transform.translation.y += delta;
self.apply_offset(self.last_transform);
self.apply_offset(self.last_transform, monado);
}
fn apply_offset(&self, transform: Affine3A) {
match self.api_impl {
ApiImpl::PlaySpaceMove(playspace_move) => {
(playspace_move)(
self.mnd_root,
transform.translation.x,
transform.translation.y,
transform.translation.z,
);
}
ApiImpl::ApplyStageOffset(apply_stage_offset) => {
let xrt_pose = XrtPose {
orientation: Quat::from_affine3(&transform).into(),
position: transform.translation.into(),
};
(apply_stage_offset)(self.mnd_root, &xrt_pose);
}
ApiImpl::SpaceOffsetApi { set_reference, .. } => {
let xrt_pose = XrtPose {
orientation: Quat::from_affine3(&transform).into(),
position: transform.translation.into(),
};
let mnd_result =
(set_reference)(self.mnd_root, XRT_REFERENCE_TYPE_STAGE, &xrt_pose);
//let mnd_result = (set_offset)(self.mnd_root, 0, &xrt_pose);
if mnd_result != MND_SUCCESS {
log::warn!("Cannot move playspace: MND result code {}", mnd_result);
}
}
ApiImpl::None => {}
}
fn apply_offset(&self, transform: Affine3A, monado: &mut Monado) {
let pose = Pose {
position: transform.translation.into(),
orientation: Quat::from_affine3(&transform).into(),
};
let _ = monado.set_reference_space_offset(ReferenceSpaceType::Stage, pose);
}
}