More tracing + attempt to make mouse capturing more robust

Author: manpat

toybox-gfx/src/core.rs

@@ -73,6 +73,13 @@ impl Core {
 
 		log::info!("OpenGL {capabilities:#?}");
 
+		// TODO(pat.m): this doesn't really do much atm - but doesn't hurt lol
+		if capabilities.parallel_shader_compilation_supported {
+			unsafe {
+				gl.MaxShaderCompilerThreadsARB(2);
+			}
+		}
+
 		Core {
 			gl,
 			capabilities,

toybox-input/src/lib.rs

@@ -29,7 +29,12 @@ pub struct System {
 	pub mouse_sensitivity: f32,
 
 	window: Rc<Window>,
+
 	wants_capture: bool,
+	occluded: bool,
+	has_focus: bool,
+
+	is_mouse_captured: bool,
 
 	window_size: Vec2i,
 }
@@ -83,6 +88,16 @@ impl System {
 	pub fn set_capture_mouse(&mut self, capture: bool) {
 		self.wants_capture = capture;
 
+		let should_capture = self.should_capture();
+		if self.is_mouse_captured != should_capture {
+			self.try_capture_mouse_internal(should_capture);
+		}
+	}
+
+	#[instrument(skip_all, name="input System::try_capture_mouse_internal")]
+	fn try_capture_mouse_internal(&mut self, capture: bool) {
+		log::info!("try_capture_mouse_internal({capture})");
+
 		if capture {
 			if let Err(error) = self.window.set_cursor_grab(CursorGrabMode::Confined)
 				.inspect_err(|error| log::warn!("Failed to capture mouse with 'confined' mode - falling back to 'locked' mode. {error}"))
@@ -93,27 +108,39 @@ impl System {
 			}
 
 			self.window.set_cursor_visible(false);
+			self.is_mouse_captured = true;
 
 		} else {
 			if let Err(error) = self.window.set_cursor_grab(CursorGrabMode::None) {
 				log::error!("Failed to release cursor grab: {error}");
 			}
 
 			self.window.set_cursor_visible(true);
+			self.is_mouse_captured = false;
 		}
 	}
+
+	fn should_capture(&self) -> bool {
+		self.wants_capture && !self.occluded && self.has_focus
+	}
 }
 
 
 /// Internal. Will be called by core.
 impl System {
 	#[instrument(skip_all, name="input System::new")]
 	pub fn new(window: Rc<Window>) -> System {
+		let has_focus = window.has_focus();
+
 		System {
 			tracker: Tracker::default(),
 			// gil: gilrs::Gilrs::new().unwrap(),
 			window,
+
 			wants_capture: false,
+			occluded: false,
+			has_focus,
+			is_mouse_captured: false,
 
 			// Default half way between quake and source sdk defaults
 			// https://github.com/ValveSoftware/source-sdk-2013/blob/master/sp/src/game/client/in_mouse.cpp#L85
@@ -126,14 +153,23 @@ impl System {
 
 	// Clear any 'this frame' state in the tracker and prepare for recieving new inputs
 	pub fn reset_tracker(&mut self) {
+		if self.should_capture() != self.is_mouse_captured {
+			self.try_capture_mouse_internal(self.should_capture());
+		}
+		
+		self.window.set_cursor_visible(!self.is_mouse_captured);
+
 		self.tracker.reset();
 	}
 
 	/// Called when something (e.g., egui) changes its mind about whether or not it wants to claim input.
 	/// We're assuming that when we become _not_ occluded we can safely manage things without interference.
 	pub fn set_occluded(&mut self, occluded: bool) {
-		if !occluded {
-			self.set_capture_mouse(self.wants_capture);
+		self.occluded = occluded;
+
+		let should_capture = self.should_capture();
+		if self.is_mouse_captured != should_capture {
+			self.try_capture_mouse_internal(should_capture);
 		}
 	}
 
@@ -164,8 +200,19 @@ impl System {
 
 			WindowEvent::CursorLeft{..} => self.tracker.track_mouse_left(),
 
-			WindowEvent::Focused(false) => self.tracker.track_focus_lost(),
-			WindowEvent::Focused(true) => self.tracker.track_focus_gained(),
+			WindowEvent::Focused(false) => {
+				self.has_focus = false;
+				self.tracker.track_focus_lost();
+
+				self.try_capture_mouse_internal(self.should_capture());
+			}
+
+			WindowEvent::Focused(true) => {
+				self.has_focus = true;
+				self.tracker.track_focus_gained();
+
+				self.try_capture_mouse_internal(self.should_capture());
+			}
 
 			// TODO(pat.m): track dpi
 

toybox-vfs/src/lib.rs

@@ -12,12 +12,15 @@ pub struct Vfs {
 }
 
 impl Vfs {
+    #[instrument(name="vfs init")]
     pub fn new() -> anyhow::Result<Vfs> {
-        Ok(Vfs {
-            resource_root: find_resource_folder()
-                .context("Can't find resource directory")?
-                .into_boxed_path()
-        })
+        let resource_root = find_resource_folder()
+            .context("Can't find resource directory")?
+            .into_boxed_path();
+
+        log::info!("Resource Root Path: {}", resource_root.display());
+
+        Ok(Vfs { resource_root })
     }
 
     pub fn resource_root(&self) -> &Path {
@@ -130,7 +133,7 @@ fn find_resource_folder() -> anyhow::Result<PathBuf> {
 fn try_find_resource_folder_from(search_dir: &Path, dirs_scanned: &mut Vec<PathBuf>) -> anyhow::Result<Option<PathBuf>> {
     // Try scanning the current search dir first, and then one directory above.
     for search_dir in search_dir.ancestors().take(2) {
-        log::debug!("Trying to scan {}", search_dir.display());
+        log::trace!("Trying to scan {}", search_dir.display());
 
         let Ok(children) = search_dir.read_dir() else {
             continue
@@ -145,7 +148,7 @@ fn try_find_resource_folder_from(search_dir: &Path, dirs_scanned: &mut Vec<PathB
             {
                 let dir_path = dir_entry.path();
 
-                log::debug!("=== Testing {}", dir_path.display());
+                log::trace!("=== Testing {}", dir_path.display());
                 if dir_path.ends_with("resource") {
                     return Ok(Some(dir_path))
                 }
@@ -168,7 +171,7 @@ fn try_find_resource_folder_from(search_dir: &Path, dirs_scanned: &mut Vec<PathB
 fn try_find_resource_folder_in(search_dir: &Path, dirs_scanned: &mut Vec<PathBuf>) -> anyhow::Result<Option<PathBuf>> {
     let path = search_dir.join("resource");
     dirs_scanned.push(path.clone());
-    log::debug!("=== Testing {}", path.display());
+    log::trace!("=== Testing {}", path.display());
 
     if path.try_exists()? {
         return Ok(Some(path))

toybox/src/lib.rs

@@ -37,8 +37,6 @@ pub fn run_with_settings<F, A>(settings: host::Settings<'_>, start_app: F) -> an
 	let vfs = vfs::Vfs::new()
 		.context("Initialising Vfs")?;
 
-	log::info!("Resource Root Path: {}", vfs.resource_root().display());
-
 	let cfg = cfg::Config::for_app_name(app_name)?;
 	let audio = audio::init();