Tracking settings refactor

alvr/client_core/src/connection.rs

@@ -195,7 +195,7 @@ fn connection_pipeline(
     let settings = stream_config.settings;
     let negotiated_config = stream_config.negotiated_config;
 
-    *ctx.max_prediction.write() = Duration::from_millis(settings.headset.max_prediction_ms);
+    *ctx.max_prediction.write() = Duration::from_millis(settings.inputs.max_prediction_ms);
 
     *ctx.statistics_manager.lock() = Some(StatisticsManager::new(
         settings.connection.statistics_history_size,

alvr/client_openxr/src/interaction.rs

@@ -12,7 +12,7 @@ use alvr_common::{
 };
 use alvr_graphics::HandData;
 use alvr_packets::{ButtonEntry, ButtonValue, FaceData, FaceExpressions, StreamConfig};
-use alvr_session::{BodyTrackingBDConfig, BodyTrackingSourcesConfig, FaceTrackingSourcesConfig};
+use alvr_session::{BodyTrackingBDConfig, BodyTrackingSourcesConfig, FaceTrackingConfig};
 use openxr as xr;
 use std::{
     collections::{HashMap, HashSet},
@@ -138,7 +138,7 @@ pub enum BodyTracker {
 
 #[derive(Clone)]
 pub struct InteractionSourcesConfig {
-    pub face_tracking: Option<FaceTrackingSourcesConfig>,
+    pub face_tracking: Option<FaceTrackingConfig>,
     pub body_tracking: Option<BodyTrackingSourcesConfig>,
     pub prefers_multimodal_input: bool,
 }
@@ -148,19 +148,19 @@ impl InteractionSourcesConfig {
         Self {
             face_tracking: config
                 .settings
-                .headset
+                .inputs
                 .face_tracking
                 .as_option()
                 .map(|c| c.sources.clone()),
             body_tracking: config
                 .settings
-                .headset
+                .inputs
                 .body_tracking
                 .as_option()
                 .map(|c| c.sources.clone()),
             prefers_multimodal_input: config
                 .settings
-                .headset
+                .inputs
                 .multimodal_tracking
                 .as_option()
                 .is_some_and(|c| c.enabled),
@@ -523,7 +523,7 @@ impl InteractionContext {
 
         if let Some(config) = &config.face_tracking {
             if matches!(self.platform, Platform::QuestPro)
-                && matches!(config, FaceTrackingSourcesConfig::PreferFullFaceTracking)
+                && matches!(config, FaceTrackingConfig::PreferFullFaceTracking)
             {
                 #[cfg(target_os = "android")]
                 {
@@ -535,7 +535,7 @@ impl InteractionContext {
             if matches!(
                 self.platform,
                 Platform::PicoNeo3 | Platform::Pico4Pro | Platform::Pico4Enterprise
-            ) && matches!(config, FaceTrackingSourcesConfig::PreferFullFaceTracking)
+            ) && matches!(config, FaceTrackingConfig::PreferFullFaceTracking)
                 && extra_extensions::supports_eye_gaze_interaction(&self.xr_session, self.xr_system)
             {
                 #[cfg(target_os = "android")]
@@ -569,7 +569,7 @@ impl InteractionContext {
             self.face_sources.eyes_social =
                 check_ext_object("EyeTrackerSocial", EyeTrackerSocial::new(&self.xr_session));
 
-            if matches!(config, FaceTrackingSourcesConfig::PreferFullFaceTracking) {
+            if matches!(config, FaceTrackingConfig::PreferFullFaceTracking) {
                 if let Some(tracker) = check_ext_object(
                     "FaceTracker2FB",
                     FaceTracker2FB::new(self.xr_session.clone(), true, true),

alvr/server_core/src/connection.rs

@@ -71,7 +71,7 @@ pub fn contruct_openvr_config(session: &SessionConfig) -> OpenvrConfig {
     let mut controller_is_tracker = false;
     let mut controller_profile = 0;
     let mut use_separate_hand_trackers = false;
-    let controllers_enabled = if let Switch::Enabled(config) = &settings.headset.controllers {
+    let controllers_enabled = if let Switch::Enabled(config) = &settings.inputs.controllers {
         controller_is_tracker =
             matches!(config.emulation_mode, ControllersEmulationMode::ViveTracker);
         // These numbers don't mean anything, they're just for triggering SteamVR resets.
@@ -101,17 +101,17 @@ pub fn contruct_openvr_config(session: &SessionConfig) -> OpenvrConfig {
     };
 
     let body_tracking_vive_enabled =
-        if let Switch::Enabled(config) = &settings.headset.body_tracking {
+        if let Switch::Enabled(config) = &settings.inputs.body_tracking {
             matches!(config.sink, BodyTrackingSinkConfig::FakeViveTracker)
-        } else if let Switch::Enabled(config) = settings.headset.multimodal_tracking {
+        } else if let Switch::Enabled(config) = settings.inputs.multimodal_tracking {
             config.detached_controllers_steamvr_sink
         } else {
             false
         };
 
     // Should be true if using full body tracking
     let body_tracking_has_legs = settings
-        .headset
+        .inputs
         .body_tracking
         .as_option()
         .map(|c| c.sources.meta.prefer_full_body)
@@ -158,8 +158,8 @@ pub fn contruct_openvr_config(session: &SessionConfig) -> OpenvrConfig {
     let hdr_controls = settings.video.encoder_config.hdr;
 
     OpenvrConfig {
-        tracking_ref_only: settings.headset.tracking_ref_only,
-        enable_vive_tracker_proxy: settings.headset.enable_vive_tracker_proxy,
+        tracking_ref_only: settings.inputs.tracking_ref_only,
+        enable_vive_tracker_proxy: settings.inputs.enable_vive_tracker_proxy,
         minimum_idr_interval_ms: settings.connection.minimum_idr_interval_ms,
         adapter_index: settings.video.adapter_index,
         codec: settings.video.preferred_codec as _,
@@ -792,7 +792,7 @@ fn connection_pipeline(
     *ctx.statistics_manager.write() = Some(StatisticsManager::new(
         initial_settings.connection.statistics_history_size,
         Duration::from_secs_f32(1.0 / fps),
-        if let Switch::Enabled(config) = &initial_settings.headset.controllers {
+        if let Switch::Enabled(config) = &initial_settings.inputs.controllers {
             config.steamvr_pipeline_frames
         } else {
             0.0
@@ -1125,7 +1125,7 @@ fn connection_pipeline(
 
         let controllers_config = session_manager_lock
             .settings()
-            .headset
+            .inputs
             .controllers
             .as_option();
         let mut controller_button_mapping_manager = controllers_config.map(|config| {
@@ -1169,9 +1169,9 @@ fn connection_pipeline(
 
                 match packet {
                     ClientControlPacket::PlayspaceSync(packet) => {
-                        if !initial_settings.headset.tracking_ref_only {
+                        if !initial_settings.inputs.tracking_ref_only {
                             let session_manager_lock = SESSION_MANAGER.read();
-                            let config = &session_manager_lock.settings().headset;
+                            let config = &session_manager_lock.settings().inputs;
                             ctx.tracking_manager.write().recenter(
                                 config.position_recentering_mode,
                                 config.rotation_recentering_mode,
@@ -1258,7 +1258,7 @@ fn connection_pipeline(
                     }
                     ClientControlPacket::ActiveInteractionProfile { input_ids, .. } => {
                         controller_button_mapping_manager = if let Switch::Enabled(config) =
-                            &SESSION_MANAGER.read().settings().headset.controllers
+                            &SESSION_MANAGER.read().settings().inputs.controllers
                         {
                             if let Some(mappings) = &config.button_mappings {
                                 Some(ButtonMappingManager::new_manual(mappings))

alvr/server_core/src/lib.rs

@@ -155,7 +155,7 @@ pub fn settings() -> Settings {
 
 pub fn registered_button_set() -> HashSet<u64> {
     let session_manager = SESSION_MANAGER.read();
-    if let Switch::Enabled(input_mapping) = &session_manager.settings().headset.controllers {
+    if let Switch::Enabled(input_mapping) = &session_manager.settings().inputs.controllers {
         input_mapping::registered_button_set(&input_mapping.emulation_mode)
     } else {
         HashSet::new()
@@ -193,7 +193,7 @@ impl ServerCoreContext {
         let stats = StatisticsManager::new(
             initial_settings.connection.statistics_history_size,
             Duration::from_secs_f32(1.0 / 90.0),
-            if let Switch::Enabled(config) = &initial_settings.headset.controllers {
+            if let Switch::Enabled(config) = &initial_settings.inputs.controllers {
                 config.steamvr_pipeline_frames
             } else {
                 0.0
@@ -287,7 +287,7 @@ impl ServerCoreContext {
             .unwrap_or_default();
 
         let max_prediction =
-            Duration::from_millis(SESSION_MANAGER.read().settings().headset.max_prediction_ms);
+            Duration::from_millis(SESSION_MANAGER.read().settings().inputs.max_prediction_ms);
 
         if latency > max_prediction {
             warn!("Latency is too high. Clamping prediction");
@@ -329,7 +329,7 @@ impl ServerCoreContext {
 
             session_manager_lock
                 .settings()
-                .headset
+                .inputs
                 .controllers
                 .as_option()
                 .and_then(|c| c.haptics.as_option().cloned())

alvr/server_core/src/tracking/face.rs

@@ -1,6 +1,6 @@
 use alvr_common::{anyhow::Result, glam::EulerRot};
 use alvr_packets::{FaceData, FaceExpressions};
-use alvr_session::FaceTrackingSinkConfig;
+use alvr_session::FaceTrackingOscOutputConfig;
 use rosc::{OscMessage, OscPacket, OscType};
 use std::{f32::consts::PI, net::UdpSocket};
 
@@ -9,16 +9,16 @@ const RAD_TO_DEG: f32 = 180.0 / PI;
 const VRCFT_PORT: u16 = 0xA1F7;
 
 pub struct FaceTrackingSink {
-    config: FaceTrackingSinkConfig,
+    config: FaceTrackingOscOutputConfig,
     socket: UdpSocket,
     packet_buffer: Vec<u8>,
 }
 
 impl FaceTrackingSink {
-    pub fn new(config: FaceTrackingSinkConfig, local_osc_port: u16) -> Result<Self> {
+    pub fn new(config: FaceTrackingOscOutputConfig, local_osc_port: u16) -> Result<Self> {
         let port = match config {
-            FaceTrackingSinkConfig::VrchatEyeOsc { port } => port,
-            FaceTrackingSinkConfig::VrcFaceTracking => VRCFT_PORT,
+            FaceTrackingOscOutputConfig::VrchatEyes { port } => port,
+            FaceTrackingOscOutputConfig::VrcFaceTracking => VRCFT_PORT,
         };
 
         let socket = UdpSocket::bind(format!("127.0.0.1:{local_osc_port}"))?;
@@ -53,7 +53,7 @@ impl FaceTrackingSink {
 
     pub fn send_tracking(&mut self, face_data: &FaceData) {
         match self.config {
-            FaceTrackingSinkConfig::VrchatEyeOsc { .. } => {
+            FaceTrackingOscOutputConfig::VrchatEyes { .. } => {
                 if let [Some(left), Some(right)] = face_data.eyes_social {
                     let (left_pitch, left_yaw, _) = left.to_euler(EulerRot::XYZ);
                     let (right_pitch, right_yaw, _) = right.to_euler(EulerRot::XYZ);
@@ -100,7 +100,7 @@ impl FaceTrackingSink {
                     );
                 }
             }
-            FaceTrackingSinkConfig::VrcFaceTracking => {
+            FaceTrackingOscOutputConfig::VrcFaceTracking => {
                 self.packet_buffer.clear();
 
                 if let [Some(left_quat), Some(right_quat)] = face_data.eyes_social {

alvr/server_core/src/tracking/mod.rs

@@ -22,7 +22,7 @@ use alvr_common::{
 use alvr_events::{EventType, TrackingEvent};
 use alvr_packets::TrackingData;
 use alvr_session::{
-    BodyTrackingConfig, HeadsetConfig, PositionRecenteringMode, RotationRecenteringMode, Settings,
+    BodyTrackingConfig, InputsConfig, PositionRecenteringMode, RotationRecenteringMode, Settings,
     VMCConfig, settings_schema::Switch,
 };
 use alvr_sockets::StreamReceiver;
@@ -120,7 +120,7 @@ impl TrackingManager {
     // Performs all kinds of tracking transformations, driven by settings.
     pub fn report_device_motions(
         &mut self,
-        headset_config: &HeadsetConfig,
+        headset_config: &InputsConfig,
         timestamp: Duration,
         device_motions: &[(u64, DeviceMotion)],
     ) {
@@ -277,7 +277,7 @@ pub fn tracking_loop(
 ) {
     let mut gestures_button_mapping_manager =
         initial_settings
-            .headset
+            .inputs
             .controllers
             .as_option()
             .map(|config| {
@@ -289,23 +289,23 @@ pub fn tracking_loop(
             });
 
     let mut face_tracking_sink = initial_settings
-        .headset
+        .inputs
         .face_tracking
         .into_option()
         .and_then(|config| {
             FaceTrackingSink::new(config.sink, initial_settings.connection.osc_local_port).ok()
         });
 
     let mut body_tracking_sink = initial_settings
-        .headset
+        .inputs
         .body_tracking
         .into_option()
         .and_then(|config| {
             BodyTrackingSink::new(config.sink, initial_settings.connection.osc_local_port).ok()
         });
 
     let mut vmc_sink = initial_settings
-        .headset
+        .inputs
         .vmc
         .into_option()
         .and_then(|config| VMCSink::new(config).ok());
@@ -330,7 +330,7 @@ pub fn tracking_loop(
             let data_lock = SESSION_MANAGER.read();
             data_lock
                 .settings()
-                .headset
+                .inputs
                 .controllers
                 .clone()
                 .into_option()
@@ -339,7 +339,7 @@ pub fn tracking_loop(
         let device_motion_keys = {
             let mut tracking_manager_lock = ctx.tracking_manager.write();
             let session_manager_lock = SESSION_MANAGER.read();
-            let headset_config = &session_manager_lock.settings().headset;
+            let headset_config = &session_manager_lock.settings().inputs;
 
             tracking.device_motions.extend_from_slice(
                 &body::get_default_body_trackers_from_detached_controllers(
@@ -461,12 +461,12 @@ pub fn tracking_loop(
             .ok();
 
         let publish_vmc = matches!(
-            SESSION_MANAGER.read().settings().headset.vmc,
+            SESSION_MANAGER.read().settings().inputs.vmc,
             Switch::Enabled(VMCConfig { publish: true, .. })
         );
         if publish_vmc {
             let orientation_correction = matches!(
-                SESSION_MANAGER.read().settings().headset.vmc,
+                SESSION_MANAGER.read().settings().inputs.vmc,
                 Switch::Enabled(VMCConfig {
                     orientation_correction: true,
                     ..
@@ -498,7 +498,7 @@ pub fn tracking_loop(
         }
 
         let track_body = matches!(
-            SESSION_MANAGER.read().settings().headset.body_tracking,
+            SESSION_MANAGER.read().settings().inputs.body_tracking,
             Switch::Enabled(BodyTrackingConfig { tracked: true, .. })
         );
         if track_body && let Some(sink) = &mut body_tracking_sink {

alvr/server_openvr/src/lib.rs

@@ -83,7 +83,7 @@ fn event_loop(events_receiver: mpsc::Receiver<ServerCoreEvent>) {
                     SetLocalViewParams(ffi_params.as_ptr());
                 },
                 ServerCoreEvent::Tracking { poll_timestamp } => {
-                    let headset_config = &alvr_server_core::settings().headset;
+                    let headset_config = &alvr_server_core::settings().inputs;
 
                     let controllers_config = headset_config.controllers.clone().into_option();
                     let track_body = headset_config.body_tracking.enabled();