toss piston, switch to sdl2. good render performance

Cargo.toml

@@ -7,7 +7,5 @@ edition = "2018"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-piston = "0.52.0"
-piston2d-graphics = "0.39.0"
-pistoncore-glutin_window = "0.67.0"
-piston2d-opengl_graphics = "0.76.0"
+sdl2 = { versoion = "0.34.3", features = ["bundled", "static-link"]}
+gl = "0.14.0"

src/main.rs

@@ -1,20 +1,18 @@
-extern crate glutin_window;
-extern crate graphics;
-extern crate opengl_graphics;
-extern crate piston;
 
-use glutin_window::GlutinWindow as Window;
-use opengl_graphics::{GlGraphics, OpenGL};
-use piston::event_loop::{EventSettings, Events};
-use piston::input::{RenderArgs, RenderEvent, UpdateArgs, UpdateEvent};
-use piston::window::WindowSettings;
-use graphics::Rectangle;
+use sdl2::render::Canvas;
+use sdl2::pixels::Color;
+use sdl2::video::Window;
+use sdl2::rect::Rect;
+
 
 use std::cmp;
+use std::{thread, time};
+use std::time::{Duration, SystemTime};
 
 pub const SCREEN_SIZE: u32 = 800;
-pub const BLACK: [f32; 4] = [0.0, 0.0, 0.0, 1.0];
-pub const WHITE: [f32; 4] = [1.0, 1.0, 1.0, 1.0];
+pub const PX_SIZE: u32 = 2;
+pub const BLACK: Color =  Color::RGB(0, 0, 0);
+pub const WHITE: Color =  Color::RGB(255, 255, 255);
 
 pub trait Cell {
     fn color(&self) -> [f32; 4];
@@ -22,7 +20,7 @@ pub trait Cell {
 
 #[derive(Clone)]
 pub struct ConwayCell {
-    color: [f32; 4],
+    color: Color,
     alive: bool,
 }
 
@@ -34,28 +32,23 @@ impl Cell {
 }*/
 
 pub struct App {
-    gl: GlGraphics,
-    steps_per_sec: f64,
-    px_size: u32,
-    dt_last: f64,
+    steps_per_sec: u64,
+    px_size: i32,
     grid: Vec<Vec<ConwayCell>>,
+    canvas: Canvas<Window>,
 }
 
 impl App {
-    fn render (&mut self, args: &RenderArgs) {
-        use graphics::*;
+    fn render (&mut self) {
 
-        let grid = &self.grid;
-        let px_size = self.px_size;
+        self.canvas.set_draw_color(Color::RGB(0, 0, 0));
+        self.canvas.clear();
 
-        self.gl.draw(args.viewport(), |c, gl| {
-            // Clear the screen.
-            clear(BLACK, gl);
-
-            for y in 0..grid.len() {
-                for x in 0..grid[y].len() {
-                    if grid[y][x].alive {
-                        rectangle(grid[y][x].color, rectangle::square((x as u32 * px_size) as f64, (y as u32 * px_size) as f64, px_size as f64), c.transform, gl)
+        for y in 0..self.grid.len() {
+            for x in 0..self.grid[y].len() {
+                if self.grid[y][x].alive {
+                    self.canvas.set_draw_color(self.grid[y][x].color);
+                    self.canvas.fill_rect(Rect::new(x as i32 * self.px_size , y as i32 * self.px_size, self.px_size as u32, self.px_size as u32));
                 }
             }
         }
@@ -66,20 +59,11 @@ impl App {
                   rectangle( cell.color, rectangle::square((x as u32 * px_size) as f64, (y as u32 * px_size) as f64, px_size as f64), c.transform, gl)
               }
           }*/
-        });
+
+
+        self.canvas.present();
     }
 
-    fn update(&mut self, args: &UpdateArgs) {
-        //println!("update and update.dt: {} with self.dt_last: {}", args.dt, self.dt_last);
-        if args.dt + self.dt_last > (1.0 / self.steps_per_sec) {
-            self.dt_last = 0.0;
-            print!(">");
-            self.evolve();
-        } else {
-            print!(".");
-            self.dt_last += args.dt;
-        }
-    }
 
     fn evolve(&mut self) {
         let mut new_grid = vec![vec![ConwayCell{color: BLACK, alive: false}; self.grid.len()]; self.grid.len()];
@@ -125,21 +109,17 @@ impl App {
 }
 
 fn main() {
-    // Change this to OpenGL::V2_1 if not working.
-    let opengl = OpenGL::V3_2;
+    let sdl_context = sdl2::init().unwrap();
+    let video_subsystem = sdl_context.video().unwrap();
+    let window = video_subsystem.window("Microworlds", SCREEN_SIZE, SCREEN_SIZE).build().unwrap();
 
-    // Create an Glutin window.
-    let mut window: Window = WindowSettings::new("spinning-square", [SCREEN_SIZE, SCREEN_SIZE])
-        .graphics_api(opengl)
-        .exit_on_esc(true)
-        .build()
-        .unwrap();
 
-    let px_size = 2;
-    let size: usize = (SCREEN_SIZE/px_size) as usize;
+
+    let size: usize = (SCREEN_SIZE/PX_SIZE) as usize;
     let mut grid = vec![vec![ConwayCell{color: BLACK, alive: false}; size]; size];
+    println!("size:{}", size);
+
     // r pemento
-    println!("size:{} size/2:{}", size, size/2);
     let centery = size/2;
     let centerx = size/2;
     println!("centery:{} centerx:{}", centery, centerx);
@@ -150,25 +130,42 @@ fn main() {
     grid[centery-1][centerx-1] = ConwayCell{color: WHITE, alive: true};
     grid[centery][centerx+1] = ConwayCell{color: WHITE, alive: true};
 
+    // 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 app = App {
-        gl: GlGraphics::new(opengl),
-        steps_per_sec: 30.0,
-        px_size: px_size,
-        dt_last: 0.0,
+        steps_per_sec: 32,
+        px_size: PX_SIZE as i32,
         grid: grid,
+        canvas: canvas,
     };
 
-    println!("{:?}", EventSettings::new());
 
-    let mut events = Events::new(EventSettings::new());
-    while let Some(e) = events.next(&mut window) {
-        if let Some(args) = e.render_args() {
-            app.render(&args);
-        }
+    let mut frame = 0;
 
-        if let Some(args) = e.update_args() {
-            app.update(&args);
+    let mut event_pump = sdl_context.event_pump().unwrap();
+    'main: loop {
+        for event in event_pump.poll_iter() {
+            match event {
+                sdl2::event::Event::Quit {..} => break 'main,
+                _ => {},
             }
         }
 
+        let start_rend = SystemTime::now();
+        app.render();
+        let render_time = start_rend.elapsed().unwrap();
+        let start_evo = SystemTime::now();
+        app.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);
+
+        thread::sleep(time::Duration::from_millis(1000 / app.steps_per_sec));
+    }
+
 }