119 lines
3.8 KiB
Rust
119 lines
3.8 KiB
Rust
|
|
use clap::{App, Arg};
|
|
use sdl2::render::Canvas;
|
|
use sdl2::video::Window;
|
|
|
|
use std::{thread, time};
|
|
use std::time::{SystemTime};
|
|
|
|
use microworlds::Engine;
|
|
use microworlds::Grid;
|
|
|
|
pub const SCREEN_SIZE_DEFAULT: u32 = 800;
|
|
pub const PX_SIZE_DEFAULT: u32 = 2;
|
|
pub const STEPS_PER_SEC_DEFAULT: u64 = 8;
|
|
|
|
|
|
fn main() {
|
|
let matches = App::new("microworlds")
|
|
.version("0.1")
|
|
.arg(Arg::with_name("engine")
|
|
.long("--engine")
|
|
.short("-e")
|
|
.help("select the engine to run")
|
|
.possible_values(&["life", "simple"])
|
|
.takes_value(true)
|
|
.required(true))
|
|
.arg(Arg::with_name("size")
|
|
.long("--size")
|
|
.help("dimension of square in number of patches")
|
|
.takes_value(true)
|
|
.default_value("800"))
|
|
.arg(Arg::with_name("pixels")
|
|
.long("--pixels")
|
|
.takes_value(true)
|
|
.help("pixels per patch")
|
|
.default_value("2"))
|
|
.arg(Arg::with_name("steps")
|
|
.long("--steps")
|
|
.help("steps per second to max out at")
|
|
.takes_value(true)
|
|
.default_value("8"))
|
|
.get_matches();
|
|
|
|
|
|
let px_size = match matches.value_of("pixels") {
|
|
Some(arg) => arg.parse().expect("pixels requires a number"),
|
|
None => PX_SIZE_DEFAULT,
|
|
};
|
|
|
|
let num_patches: u32 = match matches.value_of("size") {
|
|
Some(arg) => arg.parse().expect("size requires a number"),
|
|
None => SCREEN_SIZE_DEFAULT,
|
|
};
|
|
|
|
let steps = match matches.value_of("steps") {
|
|
Some(arg) => arg.parse().expect("steps requires a number"),
|
|
None => STEPS_PER_SEC_DEFAULT,
|
|
};
|
|
|
|
let size: usize = (num_patches/px_size) as usize;
|
|
let mut engine;
|
|
|
|
match matches.value_of("engine") {
|
|
Some(arg) => match arg {
|
|
"life" => engine = microworlds::life::new(size),
|
|
_ => {
|
|
println!("Invalud engine selected: {}", arg);
|
|
return;
|
|
}
|
|
},
|
|
None => {
|
|
println!("Engine selection requires");
|
|
return;
|
|
}
|
|
}
|
|
|
|
let sdl_context = sdl2::init().unwrap();
|
|
let video_subsystem = sdl_context.video().unwrap();
|
|
let window = video_subsystem.window("Microworlds", num_patches, num_patches).build().unwrap();
|
|
println!("Window: {}x{} at {} px per cell", num_patches, num_patches, px_size);
|
|
let mut render_grid = Grid::new(microworlds::Cell{color: microworlds::BLACK}, size);
|
|
|
|
println!("cell grid: {}x{} ({} cells) - {} steps per sec", size, size, (size*size), steps);
|
|
|
|
|
|
// Let's create a Canvas which we will use to draw in our Window
|
|
let canvas : Canvas<Window> = window.into_canvas()
|
|
.present_vsync() //< this means the screen cannot
|
|
// render faster than your display rate (usually 60Hz or 144Hz)
|
|
.build().unwrap();
|
|
|
|
let mut renderer= microworlds::Observer::new(px_size as i32, canvas);
|
|
let mut frame = 0;
|
|
let mut event_pump = sdl_context.event_pump().unwrap();
|
|
let period = time::Duration::from_millis(1000 / steps);
|
|
'main: loop {
|
|
for event in event_pump.poll_iter() {
|
|
match event {
|
|
sdl2::event::Event::Quit {..} => break 'main,
|
|
_ => {},
|
|
}
|
|
}
|
|
|
|
let start_rend = SystemTime::now();
|
|
renderer.render(render_grid);
|
|
let render_time = start_rend.elapsed().unwrap();
|
|
let start_evo = SystemTime::now();
|
|
render_grid = engine.evolve();
|
|
let evo_time = start_evo.elapsed().unwrap();
|
|
let total_time = start_rend.elapsed().unwrap();
|
|
frame += 1;
|
|
println!("frame: {} - render time: {:?} | evolve time: {:?} | total time: {:?}", frame, render_time, evo_time, total_time);
|
|
|
|
if total_time < period {
|
|
thread::sleep(period - total_time);
|
|
}
|
|
}
|
|
}
|