Hartmut/PixSpace
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity

update

Browse source
This commit is contained in:
Hartmut Seichter 2022-12-14 22:55:26 +01:00
parent d98c0a87fa
commit 714be06192
4 changed files with 147 additions and 128 deletions
Download patch file Download diff file Expand all files Collapse all files

4
src/main.rs
View file

@ -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();

2
src/offaxis.rs
View file

@ -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();

214
src/tracker.rs
View file

@ -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 {}
impl TypedHandler for TrackerHandler {
struct TrackerProxy;
#[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)]
pub struct Tracker {
stream: TcpStream, // endpoint: EndpointSyncTcp,
// 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(())
impl FromWorld for Tracker {
fn from_world(world: &mut World) -> Self {
Self {}
}
}
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
}
});
}

43
src/viewer.rs
View file

@ -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,14 +30,12 @@ impl Viewer {
}
}
pub fn apply_viewer_to_projections(mut query: Query<(&Viewer,&ScreenInfo,&mut OffAxisProjection,&mut Transform)>)
{
pub fn apply_viewer_to_projections(
mut query: Query<(&Viewer, &ScreenInfo, &mut OffAxisProjection, &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 = Vec3::new(screen_info.center.x - screen_info.width / 2.0,screen_info.center.y - screen_info.height / 2.0,screen_info.center.z);
@ -43,23 +43,21 @@ pub fn apply_viewer_to_projections(mut query: Query<(&Viewer,&ScreenInfo,&mut Of
// 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) = create_offaxis_matrices(lower_left, lower_right, upper_left, eye, 1000.0f32);
let (view, projection) =
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>) {
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();
}
}
}