feat(engine): make windowing & work queue threads namedHEADmaster

3 files changed, 39 insertions, 33 deletions

diff --git a/engine/src/asset.rs b/engine/src/asset.rs
index 95ccb04..9b11317 100644
--- a/engine/src/asset.rs
+++ b/engine/src/asset.rs
@@ -152,7 +152,7 @@ impl Assets
             asset_lookup: RefCell::new(HashMap::with_capacity(capacity)),
             importers: Vec::new(),
             importer_lookup: HashMap::new(),
-            import_work_queue: WorkQueue::new(),
+            import_work_queue: WorkQueue::new("asset_importing_work_queue"),
             import_work_msg_receiver,
             import_work_msg_sender,
             events: Events::default(),
diff --git a/engine/src/windowing.rs b/engine/src/windowing.rs
index 03e0ff8..a10b7c1 100644
--- a/engine/src/windowing.rs
+++ b/engine/src/windowing.rs
@@ -1,6 +1,6 @@
 use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::{Arc, Weak};
-use std::thread::{JoinHandle as ThreadJoinHandle, spawn};
+use std::thread::{Builder as ThreadBuilder, JoinHandle as ThreadJoinHandle};
 
 use crossbeam_channel::{
     Receiver as ChannelReceiver,
@@ -361,30 +361,33 @@ impl Default for Context
             bounded_channel::<MessageToApp>(MESSAGE_TO_APP_CHANNEL_CAP);
 
         Self {
-            _thread: spawn(move || {
-                let mut app = App {
-                    message_from_app_sender,
-                    message_from_app_receiver: message_from_app_receiver_b,
-                    message_to_app_receiver,
-                    is_dropped: is_dropped_b,
-                    windows: MapVec::default(),
-                    focused_window_id: None,
-                };
+            _thread: ThreadBuilder::new()
+                .name("windowing".to_string())
+                .spawn(move || {
+                    let mut app = App {
+                        message_from_app_sender,
+                        message_from_app_receiver: message_from_app_receiver_b,
+                        message_to_app_receiver,
+                        is_dropped: is_dropped_b,
+                        windows: MapVec::default(),
+                        focused_window_id: None,
+                    };
 
-                let event_loop = match create_event_loop() {
-                    Ok(event_loop) => event_loop,
-                    Err(err) => {
-                        tracing::error!("Failed to create event loop: {err}");
-                        return;
-                    }
-                };
+                    let event_loop = match create_event_loop() {
+                        Ok(event_loop) => event_loop,
+                        Err(err) => {
+                            tracing::error!("Failed to create event loop: {err}");
+                            return;
+                        }
+                    };
 
-                event_loop.set_control_flow(EventLoopControlFlow::Poll);
+                    event_loop.set_control_flow(EventLoopControlFlow::Poll);
 
-                if let Err(err) = event_loop.run_app(&mut app) {
-                    tracing::error!("Event loop error occurred: {err}");
-                }
-            }),
+                    if let Err(err) = event_loop.run_app(&mut app) {
+                        tracing::error!("Event loop error occurred: {err}");
+                    }
+                })
+                .expect("Failed to create windowing thread"),
             is_dropped,
             message_from_app_receiver,
             message_to_app_sender,
diff --git a/engine/src/work_queue.rs b/engine/src/work_queue.rs
index 7226c7d..48cb2ff 100644
--- a/engine/src/work_queue.rs
+++ b/engine/src/work_queue.rs
@@ -1,6 +1,6 @@
 use std::marker::PhantomData;
-use std::sync::mpsc::{channel as mpsc_channel, Sender as MpscSender};
-use std::thread::JoinHandle as ThreadHandle;
+use std::sync::mpsc::{Sender as MpscSender, channel as mpsc_channel};
+use std::thread::{Builder as ThreadBuilder, JoinHandle as ThreadJoinHandle};
 
 pub struct Work<UserData: Send + Sync + 'static>
 {
@@ -12,25 +12,28 @@ pub struct Work<UserData: Send + Sync + 'static>
 pub struct WorkQueue<UserData: Send + Sync + 'static>
 {
     work_sender: MpscSender<Work<UserData>>,
-    _thread: ThreadHandle<()>,
+    _thread: ThreadJoinHandle<()>,
     _pd: PhantomData<UserData>,
 }
 
 impl<UserData: Send + Sync + 'static> WorkQueue<UserData>
 {
-    pub fn new() -> Self
+    pub fn new(name: &str) -> Self
     {
         let (work_sender, work_receiver) = mpsc_channel::<Work<UserData>>();
 
         Self {
             work_sender,
-            _thread: std::thread::spawn(move || {
-                let work_receiver = work_receiver;
+            _thread: ThreadBuilder::new()
+                .name(name.to_string())
+                .spawn(move || {
+                    let work_receiver = work_receiver;
 
-                while let Ok(work) = work_receiver.recv() {
-                    (work.func)(work.user_data);
-                }
-            }),
+                    while let Ok(work) = work_receiver.recv() {
+                        (work.func)(work.user_data);
+                    }
+                })
+                .expect("Failed to create work queue thread"),
             _pd: PhantomData,
         }
     }