server refactoring (5): haptics + other refactor

alvr/server/src/c_api.rs

@@ -2,13 +2,14 @@
 
 use crate::{logging_backend, ServerCoreContext, ServerCoreEvent};
 use alvr_common::{log, once_cell::sync::Lazy, parking_lot::Mutex, OptLazy};
+use alvr_packets::Haptics;
 use std::{
     collections::HashMap,
     ffi::{c_char, CStr},
     time::{Duration, Instant},
 };
 
-static mut SERVER_CORE_CONTEXT: OptLazy<ServerCoreContext> = alvr_common::lazy_mut_none();
+static SERVER_CORE_CONTEXT: OptLazy<ServerCoreContext> = alvr_common::lazy_mut_none();
 
 #[repr(C)]
 #[derive(Clone, Copy)]
@@ -88,16 +89,6 @@ pub struct AlvrInput {
     pub value: AlvrInputValue,
 }
 
-#[repr(u8)]
-#[derive(Clone, Copy)]
-pub enum AlvrOutput {
-    Haptics {
-        frequency: f32,
-        amplitude: f32,
-        duration_ns: u64,
-    },
-}
-
 #[repr(C)]
 #[derive(Clone, Copy)]
 pub struct AlvrBatteryValue {
@@ -199,33 +190,48 @@ pub unsafe extern "C" fn alvr_initialize(out_target_config: *mut AlvrTargetConfi
 
 #[no_mangle]
 pub unsafe extern "C" fn alvr_start_connection() {
-    SERVER_CORE_CONTEXT
-        .lock()
-        .as_ref()
-        .unwrap()
-        .start_connection();
+    if let Some(context) = &*SERVER_CORE_CONTEXT.lock() {
+        context.start_connection();
+    }
 }
 
 #[no_mangle]
 pub unsafe extern "C" fn alvr_poll_event(out_event: *mut AlvrEvent) -> bool {
-    SERVER_CORE_CONTEXT
-        .lock()
-        .as_ref()
-        .unwrap()
-        .poll_event()
-        .map(|event| {
+    if let Some(context) = &*SERVER_CORE_CONTEXT.lock() {
+        if let Some(event) = context.poll_event() {
             match event {
                 ServerCoreEvent::RestartPending => {
                     *out_event = AlvrEvent::RestartPending;
                 }
                 ServerCoreEvent::ShutdownPending => {
-                    *out_event = AlvrEvent::RestartPending;
+                    *out_event = AlvrEvent::ShutdownPending;
                 }
             }
 
             true
-        })
-        .unwrap_or(false)
+        } else {
+            false
+        }
+    } else {
+        false
+    }
+}
+
+#[no_mangle]
+pub extern "C" fn alvr_send_haptics(
+    device_id: u64,
+    duration_s: f32,
+    frequency: f32,
+    amplitude: f32,
+) {
+    if let Some(context) = &*SERVER_CORE_CONTEXT.lock() {
+        context.send_haptics(Haptics {
+            device_id,
+            duration: Duration::from_secs_f32(f32::max(duration_s, 0.0)),
+            frequency,
+            amplitude,
+        });
+    }
 }
 
 #[no_mangle]
@@ -284,12 +290,6 @@ pub unsafe extern "C" fn alvr_get_hand_tracking(
     todo!()
 }
 
-// Currently only haptics is supported
-#[no_mangle]
-pub unsafe extern "C" fn alvr_set_output(output_id: u64, value: *const AlvrOutput) {
-    todo!()
-}
-
 #[no_mangle]
 pub unsafe extern "C" fn alvr_view_poses(
     out_head_relation: *mut AlvrSpaceRelation,

alvr/server/src/connection.rs

@@ -3,7 +3,6 @@ use crate::{
     body_tracking::BodyTrackingSink,
     face_tracking::FaceTrackingSink,
     hand_gestures::{trigger_hand_gesture_actions, HandGestureManager, HAND_GESTURE_BUTTON_SET},
-    haptics,
     input_mapping::ButtonMappingManager,
     sockets::WelcomeSocket,
     statistics::StatisticsManager,
@@ -23,7 +22,7 @@ use alvr_common::{
     BUTTON_INFO, CONTROLLER_PROFILE_INFO, DEVICE_ID_TO_PATH, HAND_LEFT_ID, HAND_RIGHT_ID, HEAD_ID,
     QUEST_CONTROLLER_PROFILE_PATH,
 };
-use alvr_events::{ButtonEvent, EventType, HapticsEvent, TrackingEvent};
+use alvr_events::{ButtonEvent, EventType, TrackingEvent};
 use alvr_packets::{
     ClientConnectionResult, ClientControlPacket, ClientListAction, ClientStatistics, Haptics,
     NegotiatedStreamingConfig, ReservedClientControlPacket, ServerControlPacket, Tracking,
@@ -64,8 +63,8 @@ pub struct VideoPacket {
 }
 
 static VIDEO_CHANNEL_SENDER: OptLazy<SyncSender<VideoPacket>> = alvr_common::lazy_mut_none();
-static HAPTICS_SENDER: OptLazy<StreamSender<Haptics>> = alvr_common::lazy_mut_none();
 static CONNECTION_THREADS: Lazy<Mutex<Vec<JoinHandle<()>>>> = Lazy::new(|| Mutex::new(vec![]));
+pub static HAPTICS_SENDER: OptLazy<StreamSender<Haptics>> = alvr_common::lazy_mut_none();
 pub static CLIENTS_TO_BE_REMOVED: Lazy<Mutex<HashSet<String>>> =
     Lazy::new(|| Mutex::new(HashSet::new()));
 
@@ -1465,44 +1464,6 @@ pub extern "C" fn send_video(timestamp_ns: u64, buffer_ptr: *mut u8, len: i32, i
     }
 }
 
-pub extern "C" fn send_haptics(device_id: u64, duration_s: f32, frequency: f32, amplitude: f32) {
-    let haptics = Haptics {
-        device_id,
-        duration: Duration::from_secs_f32(f32::max(duration_s, 0.0)),
-        frequency,
-        amplitude,
-    };
-
-    let haptics_config = {
-        let data_manager_lock = SERVER_DATA_MANAGER.read();
-
-        if data_manager_lock.settings().extra.logging.log_haptics {
-            alvr_events::send_event(EventType::Haptics(HapticsEvent {
-                path: DEVICE_ID_TO_PATH
-                    .get(&haptics.device_id)
-                    .map(|p| (*p).to_owned())
-                    .unwrap_or_else(|| format!("Unknown (ID: {:#16x})", haptics.device_id)),
-                duration: haptics.duration,
-                frequency: haptics.frequency,
-                amplitude: haptics.amplitude,
-            }))
-        }
-
-        data_manager_lock
-            .settings()
-            .headset
-            .controllers
-            .as_option()
-            .and_then(|c| c.haptics.as_option().cloned())
-    };
-
-    if let (Some(config), Some(sender)) = (haptics_config, &mut *HAPTICS_SENDER.lock()) {
-        sender
-            .send_header(&haptics::map_haptics(&config, haptics))
-            .ok();
-    }
-}
-
 #[cfg(target_os = "linux")]
 fn detect_desync(game_latency: &Duration, last_resync: &mut Instant) {
     if game_latency.as_secs_f32() > 0.25 {

alvr/server/src/graphics.rs

@@ -0,0 +1,39 @@
+static FRAME_RENDER_VS_CSO: &[u8] = include_bytes!("../cpp/platform/win32/FrameRenderVS.cso");
+static FRAME_RENDER_PS_CSO: &[u8] = include_bytes!("../cpp/platform/win32/FrameRenderPS.cso");
+static QUAD_SHADER_CSO: &[u8] = include_bytes!("../cpp/platform/win32/QuadVertexShader.cso");
+static COMPRESS_AXIS_ALIGNED_CSO: &[u8] =
+    include_bytes!("../cpp/platform/win32/CompressAxisAlignedPixelShader.cso");
+static COLOR_CORRECTION_CSO: &[u8] =
+    include_bytes!("../cpp/platform/win32/ColorCorrectionPixelShader.cso");
+static RGBTOYUV420_CSO: &[u8] = include_bytes!("../cpp/platform/win32/rgbtoyuv420.cso");
+
+static QUAD_SHADER_COMP_SPV: &[u8] = include_bytes!("../cpp/platform/linux/shader/quad.comp.spv");
+static COLOR_SHADER_COMP_SPV: &[u8] = include_bytes!("../cpp/platform/linux/shader/color.comp.spv");
+static FFR_SHADER_COMP_SPV: &[u8] = include_bytes!("../cpp/platform/linux/shader/ffr.comp.spv");
+static RGBTOYUV420_SHADER_COMP_SPV: &[u8] =
+    include_bytes!("../cpp/platform/linux/shader/rgbtoyuv420.comp.spv");
+
+pub fn initialize_shaders() {
+    unsafe {
+        crate::FRAME_RENDER_VS_CSO_PTR = FRAME_RENDER_VS_CSO.as_ptr();
+        crate::FRAME_RENDER_VS_CSO_LEN = FRAME_RENDER_VS_CSO.len() as _;
+        crate::FRAME_RENDER_PS_CSO_PTR = FRAME_RENDER_PS_CSO.as_ptr();
+        crate::FRAME_RENDER_PS_CSO_LEN = FRAME_RENDER_PS_CSO.len() as _;
+        crate::QUAD_SHADER_CSO_PTR = QUAD_SHADER_CSO.as_ptr();
+        crate::QUAD_SHADER_CSO_LEN = QUAD_SHADER_CSO.len() as _;
+        crate::COMPRESS_AXIS_ALIGNED_CSO_PTR = COMPRESS_AXIS_ALIGNED_CSO.as_ptr();
+        crate::COMPRESS_AXIS_ALIGNED_CSO_LEN = COMPRESS_AXIS_ALIGNED_CSO.len() as _;
+        crate::COLOR_CORRECTION_CSO_PTR = COLOR_CORRECTION_CSO.as_ptr();
+        crate::COLOR_CORRECTION_CSO_LEN = COLOR_CORRECTION_CSO.len() as _;
+        crate::RGBTOYUV420_CSO_PTR = RGBTOYUV420_CSO.as_ptr();
+        crate::RGBTOYUV420_CSO_LEN = RGBTOYUV420_CSO.len() as _;
+        crate::QUAD_SHADER_COMP_SPV_PTR = QUAD_SHADER_COMP_SPV.as_ptr();
+        crate::QUAD_SHADER_COMP_SPV_LEN = QUAD_SHADER_COMP_SPV.len() as _;
+        crate::COLOR_SHADER_COMP_SPV_PTR = COLOR_SHADER_COMP_SPV.as_ptr();
+        crate::COLOR_SHADER_COMP_SPV_LEN = COLOR_SHADER_COMP_SPV.len() as _;
+        crate::FFR_SHADER_COMP_SPV_PTR = FFR_SHADER_COMP_SPV.as_ptr();
+        crate::FFR_SHADER_COMP_SPV_LEN = FFR_SHADER_COMP_SPV.len() as _;
+        crate::RGBTOYUV420_SHADER_COMP_SPV_PTR = RGBTOYUV420_SHADER_COMP_SPV.as_ptr();
+        crate::RGBTOYUV420_SHADER_COMP_SPV_LEN = RGBTOYUV420_SHADER_COMP_SPV.len() as _;
+    }
+}