basic_example/
basic_example.rs

1use std::str;
2use std::thread::sleep;
3use std::time::Duration;
4use std::process::exit;
5
6#[macro_use]
7extern crate log;
8extern crate env_logger;
9
10extern crate rocket_sync;
11extern crate rocket_client;
12
13use rocket_sync::{SyncDevice, SyncTrack};
14use rocket_client::SyncClient;
15
16fn main() {
17    env_logger::init().unwrap();
18    info!("main: started");
19
20    // Connect to the Rocket Editor (server process)
21    let mut rocket: SyncClient = match SyncClient::new("localhost:1338") {
22        Ok(x) => { info!("Connected to Rocket"); x },
23        Err(_) => { println!("Couldn't connect to Rocket"); exit(2); },
24    };
25
26    let track_names = vec![
27        "group0#track0".to_owned(),
28        "group0#track1".to_owned(),
29        "group0#track2".to_owned(),
30        "group1#track0".to_owned(),
31        "group1#track1".to_owned(),
32        "group1#track2".to_owned(),
33    ];
34
35    rocket.send_track_names(&track_names).unwrap();
36
37    let mut sync_device: SyncDevice = SyncDevice::new(125.0, 8);
38    sync_device.is_paused = true;
39
40    // add empty tracks
41    for _ in track_names.iter() {
42        sync_device.tracks.push(SyncTrack::new());
43    }
44
45    loop {
46        // talk to Rocket
47        match rocket.update(&mut sync_device) {
48            Ok(_) => {},
49            Err(err) => {
50                // It's a Box<Error>, so we can't restore the original type.
51                // Let's parse the debug string for now.
52                let msg: &str = &format!("{:?}", err);
53                if msg.contains("kind: UnexpectedEof") {
54                    println!("Rocket disconnected. Exiting.");
55                    exit(2);
56                } else {
57                    error!("{}", msg);
58                }
59            },
60        }
61
62        if !sync_device.is_paused {
63            match rocket.send_row(&mut sync_device) {
64                Ok(_) => {},
65                Err(e) => warn!("{:?}", e),
66            }
67        }
68
69        // calculate track values and print
70        println!("Row: {}, Time: {}", sync_device.row, sync_device.time);
71
72        for (idx, track) in sync_device.tracks.iter().enumerate() {
73            println!("Track {} : {:>10.5}", track_names[idx], track.value_at(sync_device.row));
74        }
75
76        // update time
77        if !sync_device.is_paused {
78            sync_device.time += 16;// 1s / 60 frames
79            sync_device.set_row_from_time();
80        }
81
82        // sleep a bit
83        sleep(Duration::from_millis(16));
84
85    }
86
87}
88
89