Simpler default

Cargo.toml

@@ -2,6 +2,8 @@
 name = "laserspace"
 version = "0.1.0"
 edition = "2024"
+authors = ["Ruben van de Ven <git@rubenvandeven.com>"]
+default-run = "laserspace"
 
 [dependencies]
 bevy = "0.15.3"
@@ -35,5 +37,5 @@ geo = "0.30.0"
 opt-level = 3
 
 [[bin]]
-name="renderer"
+name="laserspace"
 path="src/main.rs"

README.md

@@ -32,5 +32,5 @@ By using ZMQ as input, the mapping of the lines is decoupled from the generation
 ## Usage
 
 ```bash
-cargo run --bin render_lines_gui
+cargo run ZMQ_QUEUE_ADDRESS
 ```

examples/bevy_gui.rs

@@ -0,0 +1,217 @@
+use bevy::prelude::*;
+
+use bevy_nannou::prelude::*;
+use bevy_nannou::NannouPlugin;
+
+use nannou_laser::point::Rgb;
+
+use trap::laser::apply_homography_matrix;
+use trap::laser::python_cv_h_into_mat3;
+use trap::laser::LaserApi;
+use trap::laser::LaserModel;
+use trap::laser::LaserTimer;
+use trap::laser::TMP_PYTHON_LASER_H;
+use trap::shapes::PositionAndIntensity;
+use trap::tracks::LaserPoints;
+use trap::tracks::RenderableLines;
+use trap::tracks::SpawnedTime;
+use trap::tracks::Track;
+use trap::zmqplugin::ZmqPlugin;
+// use iyes_perf_ui::PerfUiPlugin;
+
+use nannou_laser as laser;
+use trap::zmqplugin::ZmqReceiveTarget;
+
+use std::time::Duration;
+
+
+pub mod trap;
+
+fn main() {
+    let mut app = App::new();
+    // app.add_plugins((DefaultPlugins, NannouPlugin))
+    app.add_plugins((DefaultPlugins, NannouPlugin))
+        // .add_plugins(bevy::diagnostic::FrameTimeDiagnosticsPlugin)
+        // .add_plugins(bevy::diagnostic::EntityCountDiagnosticsPlugin)
+        // .add_plugins(bevy::diagnostic::SystemInformationDiagnosticsPlugin)
+        // .add_plugins(PerfUiPlugin)
+        .add_systems(Startup, setup)
+        .add_systems(Startup, setup_laser)
+        // .add_systems(Update, update)
+        .add_systems(Update, exit_system)
+
+
+        .add_plugins(ZmqPlugin { 
+            // url: "tcp://localhost:5558".to_string(),
+            url: "tcp://100.109.175.82:99174".to_string(),
+            // url: "tcp://127.0.0.1:99173".to_string(),
+            filter: "".to_string(),
+            target: ZmqReceiveTarget::LINES
+        })
+
+        
+        .run();
+}
+
+
+// Because of world.insert_non_send_resource, this is an exclusive system
+// see: https://bevy-cheatbook.github.io/programming/exclusive.html
+fn setup_laser(mut commands: Commands) {
+
+    // laser works on non-exclusive system (like the normal setup()), _but_ world
+    // is needed in the laser callback
+    
+    // Initialise the state that we want to live on the laser thread and spawn the stream.
+    let laser_model = LaserModel::new();
+    let _laser_api = laser::Api::new();
+    // let detected_dacs = _laser_api.detect_dacs(DacVariant::DacVariantHelios);
+    
+    // while let Ok(res) = detected_dacs {
+    //     if let laser::DetectDacs::Helios { previous_dac } = res {
+    //         info!("DACS: {:?}", previous_dac);
+    //     }
+    // }
+
+    let laser_stream = _laser_api
+        .new_frame_stream(laser_model, laser_frame_producer)
+        // .detected_dac(dac)
+        .build()
+        .unwrap();
+
+
+    let api = LaserApi {
+        _laser_api,
+        laser_stream,
+        // current_points: Vec::new(),
+    };
+    commands.spawn((api, LaserTimer {
+        // create the non-repeating fuse timer
+        timer: Timer::new(Duration::from_millis(1000), TimerMode::Repeating),
+    }));
+}
+
+fn setup(mut commands: Commands) {
+    // Spawn a camera for our main window
+    // TODO: look into https://docs.rs/visioncortex/latest/visioncortex/struct.PerspectiveTransform.html
+
+    commands.spawn(render::NannouCamera);
+
+}
+
+
+fn text2points_with_color(position_and_intensity: PositionAndIntensity, color: Rgb) -> laser::Point{
+    let used_color = color.map(|v| v * position_and_intensity[2]);
+    let p  = [position_and_intensity[0], -position_and_intensity[1]];
+    laser::Point::new(p, color)
+}
+
+fn text2points(position_and_intensity: PositionAndIntensity) -> laser::Point{
+    let color = match position_and_intensity[2] {
+        1.0 => [1.0; 3],
+        0.0 => [0.0; 3],
+        _ => [1.0; 3] // TODO add provided color
+    };
+    let p  = [position_and_intensity[0], -position_and_intensity[1]];
+    laser::Point::new(p, color)
+}
+
+// impl Into<Mat3> for [[f32;3]; 3] {
+//     fn from(m) -> Self{
+
+//     }
+// }
+
+const LASER_H: Mat3 = python_cv_h_into_mat3(TMP_PYTHON_LASER_H);
+// const LASER_H: Mat3 = python_cv_h_into_mat3(TMP_PYTHON_LASER_H_FOR_NANNOU);
+
+fn laser_frame_producer(model: &mut LaserModel, frame: &mut laser::Frame){
+    
+    // let dt = model.t.elapsed().as_millis();
+    // let use_second = (dt % 1000) > 500;
+
+    // let positions = match use_second {
+    //     true => trap::shapes::YOUR_FUTURE,
+    //     false => trap::shapes::ARE_YOU_SURE,
+    // };
+    
+    let points = model.current_points.clone();
+
+    let mut new_points = Vec::new();
+    for point in points.into_iter() {
+        let p = point.position;
+        let new_position = apply_homography_matrix(LASER_H, &p);
+        // let s = 1.;  // when using TMP_PYTHON_LASER_H_FOR_NANNOU -- doesn't work?
+        let s = 0xFFF as f32; // when using TMP_PYTHON_LASER_H
+
+        let new_point = laser::Point {
+            position: [new_position[0]/s, new_position[1]/s],
+            .. point
+        };
+        new_points.push(new_point);
+    }
+
+    info!("Points {}", new_points.len());
+    // println!("{:?}", new_points);
+    frame.add_lines(new_points);
+}
+
+
+fn get_laser_lines(use_second: bool) -> Vec<nannou_laser::Point>{
+    let positions = match use_second {
+        true => trap::shapes::YOUR_FUTURE,
+        false => trap::shapes::ARE_YOU_SURE,
+    };
+    let points = positions.iter().cloned().map(text2points).collect();
+    return points
+
+}
+
+
+
+
+
+fn exit_system(keys: Res<ButtonInput<KeyCode>>, mut exit: EventWriter<AppExit>) {
+    if keys.just_pressed(KeyCode::KeyQ) {
+        info!("Sending exit command");
+        exit.send(AppExit::Success);
+    }
+}
+
+fn update(
+    // mut commands: Commands,
+    // keys: Res<ButtonInput<KeyCode>>,
+    draws: Query<&Draw>,
+    mut lasers: Query<(&mut LaserApi, &mut LaserTimer)>,
+    tracks: Query<(&Track, &SpawnedTime)>,
+    time: Res<Time>,
+) {
+    let mut lines = RenderableLines::new();
+    for (track, created_at) in tracks.iter() {
+        // println!("{} {}, history: {}", track.track_id.to_string(), created_at.instant.elapsed().as_millis(), track.history.len());
+        let rl = RenderableLines::from(track);
+        lines.lines.extend(rl.lines);
+    }
+   
+    for (laser_api, mut laser_timer) in lasers.iter_mut() {
+        
+        laser_timer.timer.tick(time.delta());
+        
+        let version = laser_timer.timer.elapsed().as_millis() > 500;
+        debug!("{} {}", version, laser_timer.timer.elapsed().as_millis());
+        // let lines = get_laser_lines(version);
+        let points: LaserPoints = (&lines).into();
+        laser_api.laser_stream.send(|laser|  {
+            let laserpoints: LaserPoints = points;
+            // TODO: homography
+            laser.current_points = laserpoints; 
+        }).unwrap();
+    }
+
+    for draw in draws.iter() {
+        draw.background().color(DIM_GRAY);
+
+        draw.ellipse().color(LIGHT_GRAY).w_h(100.0, 100.0);
+
+    }
+
+}