add an openxr backend

Author: matthewjberger

Cargo.lock

@@ -11,6 +11,7 @@ name = "app_core"
 
 [dependencies]
 bytemuck = { version = "1.24.0", features = ["derive"] }
+clap = { version = "4.5", features = ["derive"] }
 egui = "0.33.0"
 egui-wgpu = { version = "0.33.0", features = ["winit"] }
 futures = "0.3.31"
@@ -19,14 +20,18 @@ nalgebra-glm = { version = "0.20.0", features = [
     "convert-bytemuck",
     "serde-serialize",
 ] }
+openxr = { version = "0.19", features = ["static", "loaded"], optional = true }
 web-time = "1.1.0"
 wgpu = { version = "27.0.1", default-features = false }
 winit = "0.30.12"
 
 [target.'cfg(not(target_arch = "wasm32"))'.dependencies]
+ash = { version = "0.38", optional = true }
 env_logger = "0.11.8"
 egui-winit = "0.33.0"
+gpu-allocator = { version = "0.27", optional = true }
 pollster = "0.4.0"
+wgpu-hal = { version = "27.0.4", optional = true }
 
 [target.'cfg(target_arch = "wasm32")'.dependencies]
 console_error_panic_hook = "0.1.7"
@@ -37,5 +42,6 @@ wasm-bindgen-futures = "0.4.55"
 
 [features]
 default = ["wgpu/default"]
+openxr = ["dep:openxr", "dep:ash", "dep:wgpu-hal", "dep:gpu-allocator"]
 webgl = ["wgpu/webgl"]
 webgpu = ["wgpu/webgpu"]

Cargo.toml

@@ -41,6 +41,10 @@ lint:
 run:
     cargo run -r
 
+# Run the desktop app in OpenXR mode
+run-openxr:
+    cargo run -r --features openxr -- --openxr
+
 # Build the app with wgpu + WebGL
 build-webgl:
     trunk build --features webgl

justfile

@@ -2,6 +2,12 @@
 use wasm_bindgen::prelude::*;
 use wgpu::InstanceDescriptor;
 
+#[cfg(all(not(target_arch = "wasm32"), feature = "openxr"))]
+pub mod xr;
+
+#[cfg(all(not(target_arch = "wasm32"), feature = "openxr"))]
+pub use xr::run_xr;
+
 use std::sync::Arc;
 use web_time::{Duration, Instant};
 use winit::{
@@ -563,9 +569,72 @@ impl Gpu {
             surface_format,
         }
     }
+
+    #[cfg(not(target_arch = "wasm32"))]
+    pub async fn new_async_headless() -> Self {
+        let instance = wgpu::Instance::new(&InstanceDescriptor::default());
+
+        let adapter = instance
+            .request_adapter(&wgpu::RequestAdapterOptions {
+                power_preference: wgpu::PowerPreference::default(),
+                compatible_surface: None,
+                force_fallback_adapter: false,
+            })
+            .await
+            .expect("Failed to request adapter!");
+
+        let (device, queue) = {
+            log::info!("WGPU Adapter Features: {:#?}", adapter.features());
+            adapter
+                .request_device(&wgpu::DeviceDescriptor {
+                    label: Some("WGPU Device"),
+                    memory_hints: wgpu::MemoryHints::default(),
+                    required_features: wgpu::Features::default(),
+                    required_limits: wgpu::Limits::default().using_resolution(adapter.limits()),
+                    experimental_features: wgpu::ExperimentalFeatures::disabled(),
+                    trace: wgpu::Trace::Off,
+                })
+                .await
+                .expect("Failed to request a device!")
+        };
+
+        let surface_format = wgpu::TextureFormat::Rgba8UnormSrgb;
+        let surface_config = wgpu::SurfaceConfiguration {
+            usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
+            format: surface_format,
+            width: 1,
+            height: 1,
+            present_mode: wgpu::PresentMode::Fifo,
+            alpha_mode: wgpu::CompositeAlphaMode::Opaque,
+            view_formats: vec![],
+            desired_maximum_frame_latency: 2,
+        };
+
+        let dummy_surface = unsafe {
+            let handle =
+                wgpu::rwh::RawDisplayHandle::Windows(wgpu::rwh::WindowsDisplayHandle::new());
+            let window_handle = wgpu::rwh::RawWindowHandle::Win32(
+                wgpu::rwh::Win32WindowHandle::new(std::num::NonZeroIsize::new(1).unwrap()),
+            );
+            instance
+                .create_surface_unsafe(wgpu::SurfaceTargetUnsafe::RawHandle {
+                    raw_display_handle: handle,
+                    raw_window_handle: window_handle,
+                })
+                .unwrap()
+        };
+
+        Self {
+            surface: dummy_surface,
+            device,
+            queue,
+            surface_config,
+            surface_format,
+        }
+    }
 }
 
-struct Scene {
+pub struct Scene {
     pub model: nalgebra_glm::Mat4,
     pub vertex_buffer: wgpu::Buffer,
     pub index_buffer: wgpu::Buffer,
@@ -723,7 +792,7 @@ struct UniformBuffer {
     mvp: nalgebra_glm::Mat4,
 }
 
-struct UniformBinding {
+pub struct UniformBinding {
     pub buffer: wgpu::Buffer,
     pub bind_group: wgpu::BindGroup,
     pub bind_group_layout: wgpu::BindGroupLayout,

src/lib.rs

@@ -1,6 +1,22 @@
-// #![windows_subsystem = "windows"] // uncomment this to suppress terminal on windows
+use clap::Parser;
+
+#[derive(Parser)]
+#[command(author, version, about, long_about = None)]
+struct Args {
+    #[cfg(feature = "openxr")]
+    #[arg(long)]
+    openxr: bool,
+}
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let args = Args::parse();
+
+    #[cfg(feature = "openxr")]
+    if args.openxr {
+        app_core::run_xr()?;
+        return Ok(());
+    }
 
-fn main() -> Result<(), winit::error::EventLoopError> {
     let event_loop = winit::event_loop::EventLoop::builder().build()?;
     event_loop.set_control_flow(winit::event_loop::ControlFlow::Poll);
     let mut app = app_core::App::default();