updated implementation for VRPN based tracking into a thread, next we should not implement this through a component but through a resource

src/main.rs

@@ -34,7 +34,7 @@ fn main() {
                 width: 1280.0,
                 height: 720.0,
                 present_mode: PresentMode::AutoVsync,
-                mode: WindowMode::BorderlessFullscreen,
+                // mode: WindowMode::BorderlessFullscreen,
                 ..default()
             },
             ..default()
@@ -53,6 +53,7 @@ fn main() {
         .add_startup_system(offaxis_camera_setup)
         // .add_startup_system(setup_tracker)
         // .add_system(update_tracker)
+        .add_startup_system(setup_threaded_tracker)
         
         .add_plugin(CameraProjectionPlugin::<OffAxisProjection>::default())
         .add_system(simulate_viewer)

src/tracker.rs

@@ -3,6 +3,10 @@ use bevy::prelude::*;
 extern crate bytes;
 extern crate vrpn;
 
+// use futures_lite::future;
+use rand::Rng;
+use std::time::{Duration, Instant};
+
 use bytes::{Bytes, BytesMut};
 use std::{
     io::{self, Read},
@@ -13,12 +17,23 @@ use vrpn::{
     codec::peek_u32,
     constants::MAGIC_DATA,
     cookie::check_ver_nonfile_compatible,
+    handler::{HandlerCode, TypedHandler},
     message::MessageSize,
-    sync_io::{read_cookie, write_cookie},
+    sync_io::{read_cookie, write_cookie, EndpointSyncTcp},
     tracker::PoseReport,
-    unbuffer, CookieData, Message, Result, SequencedGenericMessage, Unbuffer,
+    unbuffer, CookieData, Message, Result, SequencedGenericMessage, TypeDispatcher, Unbuffer,
 };
 
+#[derive(Debug)]
+struct TrackerHandler {}
+impl TypedHandler for TrackerHandler {
+    type Item = PoseReport;
+    fn handle_typed(&mut self, msg: &Message<PoseReport>) -> Result<HandlerCode> {
+        println!("{:?}\n   {:?}", msg.header, msg.body);
+        Ok(HandlerCode::ContinueProcessing)
+    }
+}
+
 #[derive(Component)]
 pub struct Tracker {
     stream: TcpStream, // endpoint: EndpointSyncTcp,
@@ -68,8 +83,7 @@ impl Tracker {
 
         CookieData::unbuffer_ref(&mut cookie_buf)
             .and_then(|msg| check_ver_nonfile_compatible(msg.version))
-                .unwrap();
-
+            .unwrap();
 
         Tracker { stream }
     }
@@ -121,10 +135,40 @@ pub fn setup_tracker(mut commands: Commands) {
 
 pub fn update_tracker(mut query: Query<&mut Tracker>) {
     for mut tracker in query.iter_mut() {
-        
         tracker.update();
 
         // tracker.connection.poll_endpoints();
         // tracker
     }
 }
+
+pub fn setup_threaded_tracker(mut commands: Commands) {
+    // let (tx, rx) = bounded::<u32>(10);
+    std::thread::spawn(move || {
+        let addr: SocketAddr = "127.0.0.1:3883".parse().unwrap();
+        let mut stream = TcpStream::connect(addr).unwrap();
+        stream.set_nodelay(true).unwrap();
+
+        // We first write our cookie, then read and check the server's cookie, before the loop.
+        write_cookie(&mut stream, CookieData::from(MAGIC_DATA)).unwrap();
+        let cookie_buf = read_cookie(&mut stream).unwrap();
+        let mut cookie_buf = Bytes::from(&cookie_buf[..]);
+
+        CookieData::unbuffer_ref(&mut cookie_buf)
+            .and_then(|msg| check_ver_nonfile_compatible(msg.version)).unwrap();
+
+        let mut endpoint = EndpointSyncTcp::new(stream);
+
+        let mut dispatcher = TypeDispatcher::new();
+        let _ = dispatcher.add_typed_handler(Box::new(TrackerHandler {}), None).unwrap();
+
+        loop {
+
+            // vrpn implementation is rather verbose - we need to see what specific errors 
+            // should be handled properly!
+            endpoint.poll_endpoint(&mut dispatcher).unwrap_or_else(|err| {
+                info!("error from tracker thread {:?}",err);
+            })
+        }
+    });
+}