initial commit

src/backend/openvr/mod.rs

@@ -1,4 +1,5 @@
 use std::{
+    collections::VecDeque,
     path::Path,
     time::{Duration, Instant},
 };
@@ -8,45 +9,73 @@ use ovr_overlay::{
     sys::{ETrackedDeviceProperty, EVRApplicationType, EVREventType},
     TrackedDeviceIndex,
 };
+use vulkano::{
+    device::{physical::PhysicalDevice, DeviceExtensions},
+    instance::InstanceExtensions,
+    Handle, VulkanObject,
+};
 
-use super::common::InputState;
+use crate::state::AppState;
+
+use self::{input::action_manifest_path, overlay::OpenVrOverlayData};
+
+use super::{
+    common::{OverlayContainer, TaskType},
+    input::InputState,
+};
 
 pub mod input;
 pub mod overlay;
 
-fn openvr_run() {
+pub fn openvr_run() {
     let app_type = EVRApplicationType::VRApplication_Overlay;
     let Ok(context) = ovr_overlay::Context::init(app_type) else {
             error!("Failed to initialize OpenVR");
             return;
         };
 
-    let mut overlay = context.overlay_mngr();
-    let mut settings = context.settings_mngr();
-    let mut input = context.input_mngr();
-    let mut system = context.system_mngr();
-    let mut compositor = context.compositor_mngr();
+    let mut overlay_mngr = context.overlay_mngr();
+    //let mut settings_mngr = context.settings_mngr();
+    let mut input_mngr = context.input_mngr();
+    let mut system_mngr = context.system_mngr();
+    let mut compositor_mngr = context.compositor_mngr();
 
-    let Ok(_) = input.set_action_manifest(Path::new("resources/actions.json")) else {
-        error!("Failed to set action manifest");
+    let device_extensions_fn = |device: &PhysicalDevice| {
+        let names = compositor_mngr.get_vulkan_device_extensions_required(device.handle().as_raw());
+        let ext = DeviceExtensions::from_iter(names.iter().map(|s| s.as_str()));
+        ext
+    };
+
+    let mut compositor_mngr = context.compositor_mngr();
+    let instance_extensions = {
+        let names = compositor_mngr.get_vulkan_instance_extensions_required();
+        InstanceExtensions::from_iter(names.iter().map(|s| s.as_str()))
+    };
+
+    let mut state = AppState::new(instance_extensions, device_extensions_fn);
+    let mut overlays = OverlayContainer::<OpenVrOverlayData>::new(&mut state);
+
+    if let Err(e) = input_mngr.set_action_manifest(action_manifest_path()) {
+        error!("Failed to set action manifest: {}", e.description());
         return;
     };
 
-    let Ok(mut input_state) = InputState::new(&mut input) else {
+    let Ok(mut input) = InputState::new(&mut input_mngr) else {
         error!("Failed to initialize input");
         return;
     };
 
-    let Ok(refresh_rate) = system.get_tracked_device_property::<f32>(TrackedDeviceIndex::HMD, ETrackedDeviceProperty::Prop_DisplayFrequency_Float) else {
+    let Ok(refresh_rate) = system_mngr.get_tracked_device_property::<f32>(TrackedDeviceIndex::HMD, ETrackedDeviceProperty::Prop_DisplayFrequency_Float) else {
         error!("Failed to get display refresh rate");
         return;
     };
 
     let frame_time = (1000.0 / refresh_rate).floor() * 0.001;
     let mut next_device_update = Instant::now();
+    let mut due_tasks = VecDeque::with_capacity(4);
 
     loop {
-        while let Some(event) = system.poll_next_event() {
+        while let Some(event) = system_mngr.poll_next_event() {
             match event.event_type {
                 EVREventType::VREvent_Quit => {
                     info!("Received quit event, shutting down.");
@@ -61,35 +90,57 @@ fn openvr_run() {
             }
 
             if next_device_update <= Instant::now() {
-                input_state.update_devices(&mut system);
+                input.update_devices(&mut system_mngr);
                 next_device_update = Instant::now() + Duration::from_secs(30);
             }
 
-            input_state.pre_update();
-            input_state.update(&mut input, &mut system);
-            input_state.post_update();
+            state.tasks.retrieve_due(&mut due_tasks);
+            while let Some(task) = due_tasks.pop_front() {
+                match task {
+                    TaskType::Global(f) => f(&mut state),
+                    TaskType::Overlay(sel, f) => {
+                        if let Some(o) = overlays.mut_by_selector(&sel) {
+                            f(&mut state, &mut o.state);
+                        }
+                    }
+                }
+            }
 
-            // task scheduler
+            input.pre_update();
+            input.update(&mut input_mngr, &mut system_mngr);
+            input.post_update();
 
-            // after input
+            input
+                .pointers
+                .iter_mut()
+                .for_each(|p| p.interact(&mut overlays, &mut state));
 
-            // interactions
+            overlays
+                .iter_mut()
+                .for_each(|o| o.after_input(&mut overlay_mngr, &mut state));
 
-            // show overlays
+            log::debug!("Rendering frame");
+
+            overlays
+                .iter_mut()
+                .filter(|o| o.state.want_visible)
+                .for_each(|o| o.render(&mut state));
+
+            log::debug!("Rendering overlays");
+
+            overlays
+                .iter_mut()
+                .for_each(|o| o.after_render(&mut overlay_mngr, &state.graphics));
 
             // chaperone
 
-            // render overlays
-
-            // hide overlays
-
-            // close font handles
+            // close font handles?
 
             // playspace moved end frame
 
             let mut seconds_since_vsync = 0f32;
             std::thread::sleep(Duration::from_secs_f32(
-                if system.get_time_since_last_vsync(&mut seconds_since_vsync, &mut 0u64) {
+                if system_mngr.get_time_since_last_vsync(&mut seconds_since_vsync, &mut 0u64) {
                     frame_time - seconds_since_vsync
                 } else {
                     0.011