update

src/main.rs

@@ -14,7 +14,6 @@ use crate::console::*;
 
 use bevy::{prelude::*, window::PresentMode, render::camera::CameraProjectionPlugin};
 use offaxis::{offaxis_camera_setup, OffAxisProjection};
-use tracker::setup_tracker;
 
 mod offaxis;
 mod scene;
@@ -56,7 +55,8 @@ fn main() {
         .add_startup_system(setup_threaded_tracker)
         
         .add_plugin(CameraProjectionPlugin::<OffAxisProjection>::default())
-        .add_system(simulate_viewer)
+        // .add_system(simulate_viewer)
+        .add_system(simulate_viewer_with_keyboard)
         .add_system(apply_viewer_to_projections)
         .add_system(toggle_fullscreeen)
         .run();

src/offaxis.rs

@@ -48,7 +48,7 @@ pub fn offaxis_camera_setup(mut commands: Commands) {
     // let projection = PerspectiveProjection::default();
 
     // position the camera like bevy would do by default for 2D:
-    let transform = Transform::from_xyz(0.0, 0.0, projection.far - 0.1);
+    let transform = Transform::from_xyz(0.0, 0.0, 0.1);
     
     // frustum construction code copied from Bevy
     let view_projection = projection.get_projection_matrix() * transform.compute_matrix().inverse();

src/tracker.rs

@@ -13,6 +13,8 @@ use std::{
     net::{SocketAddr, TcpStream},
 };
 
+use std::sync::mpsc::{Receiver,channel};
+
 use vrpn::{
     codec::peek_u32,
     constants::MAGIC_DATA,
@@ -21,12 +23,77 @@ use vrpn::{
     message::MessageSize,
     sync_io::{read_cookie, write_cookie, EndpointSyncTcp},
     tracker::PoseReport,
-    unbuffer, CookieData, Message, Result, SequencedGenericMessage, TypeDispatcher, Unbuffer,
+    unbuffer, CookieData, Message, Result, SequencedGenericMessage, TypeDispatcher, Unbuffer, TypedBodylessHandler,
 };
 
-#[derive(Debug)]
+
-struct TrackerHandler {}
+struct TrackerProxy;
-impl TypedHandler for TrackerHandler {
+
+
+#[derive(Resource,Debug)]
+struct Tracker;
+
+impl Tracker {
+
+    pub fn start_tracker(&self) {
+
+        std::thread::spawn(move || {
+
+            let (sender, receiver): (_, Receiver<PoseReport>) = channel();
+
+
+            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();
+    
+            let _ = dispatcher.add_typed_handler(Box::new( Tracker {} ), None).unwrap();
+
+            
+            // setup a channel
+            // let (tx, rx) = mpsc::channel();
+    
+            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);
+                })
+    
+                // dispatcher.han
+    
+            }
+        });
+
+        
+
+
+    }
+    
+}
+
+// impl TypedBodylessHandler for Tracker {
+//     type Item = PoseReport;
+//     fn handle_typed_bodyless(&mut self, header: &vrpn::MessageHeader) -> Result<HandlerCode> {
+
+//         Ok(HandlerCode::ContinueProcessing)
+//     }
+// }
+
+impl TypedHandler for Tracker {
     type Item = PoseReport;
     fn handle_typed(&mut self, msg: &Message<PoseReport>) -> Result<HandlerCode> {
         println!("{:?}\n   {:?}", msg.header, msg.body);
@@ -34,111 +101,41 @@ impl TypedHandler for TrackerHandler {
     }
 }
 
-#[derive(Component)]
+impl FromWorld for Tracker {
-pub struct Tracker {
+    fn from_world(world: &mut World) -> Self {
-    stream: TcpStream, // endpoint: EndpointSyncTcp,
+        Self {} 
-                       // dispatcher: TypeDispatcher
-                       // stream: ConnectionIpStream,
-                       // connection: Arc<ConnectionIp>
-}
-
-// #[derive(Debug)]
-// struct TrackerHandler {}
-
-// impl TypedHandler for TrackerHandler {
-//     type Item = PoseReport;
-//     fn handle_typed(&mut self, msg: &Message<PoseReport>) -> Result<HandlerCode> {
-//         info!("{:?}\n   {:?}", msg.header, msg.body);
-//         Ok(HandlerCode::ContinueProcessing)
-//     }
-// }
-
-impl Tracker {
-    pub fn from_info(server_ip: &str, port: u16) -> Self {
-        // let server = format!("tcp://{}:{}", server_ip, port)
-        //     .parse::<ServerInfo>()
-        //     .unwrap();
-
-        // let connection = ConnectionIp::new_client(server, None, None).expect("msg");
-
-        // let sender = connection
-        //     .register_sender(StaticSenderName(b"Tracker0"))
-        //     .expect("should be able to register sender");
-
-        // let ping_client = ping::Client::new(sender, Arc::clone(&connection))
-        //     .expect("should be able to create ping client");
-
-        let addr: SocketAddr = format!("{}:{}", server_ip.to_string(), port)
-            .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();
-
-        Tracker { stream }
-    }
-
-    pub fn update(&mut self) -> vrpn::Result<()> {
-        let mut buf = BytesMut::new();
-
-        // Read the message header and padding
-        buf.resize(24, 0);
-        self.stream.read_exact(buf.as_mut())?;
-
-        // Peek the size field, to compute the MessageSize.
-
-        // let buf = buf.freeze();
-
-        let total_len = peek_u32(&buf.clone().freeze())?.unwrap();
-        // let total_len = peek_u32(&buf)?.unwrap();
-        let size = MessageSize::from_length_field(total_len);
-
-        // Read the body of the message
-        let mut body_buf = BytesMut::new();
-        body_buf.resize(size.padded_body_size(), 0);
-        self.stream.read_exact(body_buf.as_mut())?;
-
-        // Combine the body with the header
-        buf.extend_from_slice(&body_buf[..]);
-        let mut buf = buf.clone().freeze();
-
-        // eprintln!("{:?}", Message::from(unbuffered));
-        // info!("{:?}", Message::from(unbuffered));
-
-        let pose = PoseReport::unbuffer_ref(&mut body_buf.clone().freeze())?;
-        info!("{:?}", pose);
-
-        // Unbuffer the message.
-        // let unbuffered = SequencedGenericMessage::unbuffer_ref(&mut buf)?;
-
-        // let message = Message::from(unbuffered);
-        // info!("{:?}",message.header);
-
-        Ok(())
     }
 }
 
-pub fn setup_tracker(mut commands: Commands) {
-    // commands.spawn(Tracker::from_info("127.0.0.1", 3883));
-    commands.spawn(Tracker::from_info("212.201.64.122", 3883));
-}
 
-pub fn update_tracker(mut query: Query<&mut Tracker>) {
-    for mut tracker in query.iter_mut() {
-        tracker.update();
 
-        // tracker.connection.poll_endpoints();
+
-        // tracker
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+#[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)
     }
 }
 
@@ -158,10 +155,14 @@ pub fn setup_threaded_tracker(mut commands: Commands) {
             .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();
 
+        
+        // setup a channel
+        // let (tx, rx) = mpsc::channel();
+
         loop {
 
             // vrpn implementation is rather verbose - we need to see what specific errors 
@@ -169,6 +170,9 @@ pub fn setup_threaded_tracker(mut commands: Commands) {
             endpoint.poll_endpoint(&mut dispatcher).unwrap_or_else(|err| {
                 info!("error from tracker thread {:?}",err);
             })
+
+            // dispatcher.han
+
         }
     });
 }

src/viewer.rs

@@ -1,6 +1,8 @@
-use bevy::{prelude::*, transform, math::Vec4Swizzles};
+use bevy::{math::Vec4Swizzles, prelude::*, transform};
 
-use crate::{screeninfo::ScreenInfo, offaxis::OffAxisProjection, projection::create_offaxis_matrices};
+use crate::{
+    offaxis::OffAxisProjection, projection::create_offaxis_matrices, screeninfo::ScreenInfo,
+};
 
 #[derive(Component, Default)]
 pub struct Viewer {
@@ -28,38 +30,34 @@ impl Viewer {
     }
 }
 
-
+pub fn apply_viewer_to_projections(
-pub fn apply_viewer_to_projections(mut query: Query<(&Viewer,&ScreenInfo,&mut OffAxisProjection,&mut Transform)>)
+    mut query: Query<(&Viewer, &ScreenInfo, &mut OffAxisProjection, &mut Transform)>,
-{
+) {
-    query.for_each_mut(|(viewer,screen_info,mut offaxis, mut transform)| {
+    query.for_each_mut(|(viewer, screen_info, mut offaxis, mut transform)| {
-
         let eye = viewer.position;
 
-
+        let (lower_left, lower_right, upper_left, _) = screen_info.corner_points();
-        let (lower_left,lower_right,upper_left,_) = screen_info.corner_points();
 
         // let lower_left = Vec3::new(screen_info.center.x - screen_info.width / 2.0,screen_info.center.y - screen_info.height / 2.0,screen_info.center.z);
         // let upper_left = Vec3::new(screen_info.center.x - screen_info.width / 2.0,screen_info.center.y + screen_info.height / 2.0,screen_info.center.z);
 
         // let lower_right = Vec3::new(screen_info.center.x + screen_info.width / 2.0,screen_info.center.y - screen_info.height / 2.0,screen_info.center.z);
 
-
+        let (view, projection) =
-        let (view, projection) = create_offaxis_matrices(lower_left, lower_right, upper_left, eye, 1000.0f32);
+            create_offaxis_matrices(lower_left, lower_right, upper_left, eye, 1000.0f32);
 
         offaxis.projection_matrix = projection;
 
         *transform = Transform::from_matrix(view.inverse());
 
-        // *transform = Transform::from_translation(eye).looking_at(Vec3::ZERO, Vec3::Y);
+        info!("Viewer {:?}", viewer.position);
 
+        // *transform = Transform::from_translation(eye).looking_at(Vec3::ZERO, Vec3::Y);
     });
 }
 
-
+pub fn simulate_viewer(mut query: Query<&mut Viewer>, time: Res<Time>) {
-
-pub fn simulate_viewer(mut query: Query<&mut Viewer>,time: Res<Time>) {
     for mut v in query.iter_mut() {
-        
         //v.position += Vec3::Y * 0.005;
         v.alpha += 1.5 * time.delta_seconds();
 
@@ -73,6 +71,23 @@ pub fn simulate_viewer(mut query: Query<&mut Viewer>,time: Res<Time>) {
             z_distance + v.alpha.sin(),
         );
 
-        info!("Viewer {:?}",v.position);
+        // info!("Viewer {:?}", v.position);
     }
 }
+
+pub fn simulate_viewer_with_keyboard(
+    mut query: Query<&mut Viewer>,
+    input: Res<Input<KeyCode>>,
+    time: Res<Time>,
+) {
+    for mut viewer in query.iter_mut() {
+        if input.pressed(KeyCode::W) {
+            viewer.position += Vec3::Z * time.delta_seconds();
+        } else if (input.pressed(KeyCode::S)) {
+            viewer.position -= Vec3::Z * time.delta_seconds();
+        }
+    }
+
+
+
+}