use boll::*;
-use common::{Nanoseconds, Point2D, Rect};
+use common::{Point2D, Rect};
use core::controller::ControllerManager;
+use core::render::Renderer;
use point; // defined in common, but loaded from main...
use rand::Rng;
use sdl2::event::{Event, WindowEvent};
-use sdl2::gfx::primitives::DrawRenderer;
use sdl2::keyboard::Keycode;
-use sdl2::pixels::Color;
use sdl2::rect::Rect as SDLRect;
-use sdl2::render::{BlendMode, Canvas};
-use sdl2::video::{FullscreenType, SwapInterval, Window};
+use sdl2::video::SwapInterval;
use sdl2::{EventPump, VideoSubsystem};
use sprites::SpriteManager;
use std::f32::consts::PI;
-use time::PreciseTime;
+use time::{Duration, Instant, prelude::*};
const FPS: u32 = 60;
const NS_PER_FRAME: u32 = 1_000_000_000 / FPS;
.unwrap();
context.mouse().show_cursor(false);
- let mut canvas = window.into_canvas().build().unwrap();
- canvas.set_blend_mode(BlendMode::Add);
- canvas.set_draw_color(Color::RGB(0, 0, 0));
- canvas.clear();
- canvas.present();
+ let canvas = window.into_canvas().build().unwrap();
+ let sprites = SpriteManager::new(canvas.texture_creator());
+ let screen = canvas.output_size().unwrap();
+ let renderer = Renderer::new(canvas);
video.gl_set_swap_interval(SwapInterval::VSync)?;
let event_pump = context.event_pump()?;
- let sprites = SpriteManager::new(canvas.texture_creator());
- let screen = canvas.output_size().unwrap();
Ok(App {
- canvas,
+ renderer,
event_pump,
sprites,
state: self.state.unwrap_or_else(|| Box::new(ActiveState::new(screen))),
}
pub struct App {
- canvas: Canvas<Window>,
+ renderer: Renderer,
event_pump: EventPump,
sprites: SpriteManager,
state: Box<dyn AppState>,
}
pub fn start(&mut self) {
- // let mut frame_count: u64 = 0;
- // let mut fps_time = PreciseTime::now();
- let mut last_time = PreciseTime::now();
+ let mut last_time = Instant::now();
self.state.enter(&mut self.ctrl_man);
break 'running;
}
- let duration =
- last_time.to(PreciseTime::now()).num_nanoseconds().unwrap() as Nanoseconds;
- last_time = PreciseTime::now();
+ let duration = Instant::now() - last_time;
+ last_time = Instant::now();
+
self.ctrl_man.update(duration);
self.state.update(duration);
self.render();
-
- // frame_count += 1;
- // if frame_count == FPS as u64 {
- // let duration = fps_time.to(PreciseTime::now()).num_nanoseconds().unwrap() as f64
- // / 1_000_000_000.0;
- // // println!("fps: {}", frame_count as f64 / duration);
- // frame_count = 0;
- // fps_time = PreciseTime::now();
- // }
}
self.state.leave();
keycode: Some(Keycode::F11),
..
} => {
- match self.canvas.window().fullscreen_state() {
- FullscreenType::Off => self
- .canvas
- .window_mut()
- .set_fullscreen(FullscreenType::Desktop),
- _ => self.canvas.window_mut().set_fullscreen(FullscreenType::Off),
- }
- .unwrap();
+ self.renderer.toggle_fullscreen();
}
Event::Window {
win_event: WindowEvent::Resized(x, y),
}
fn render(&mut self) {
- self.canvas.set_draw_color(Color::RGB(0, 0, 0));
- self.canvas.clear();
- self.state.render(&mut self.canvas, &mut self.sprites);
- self.canvas.present();
+ self.renderer.clear();
+ self.state.render(&mut self.renderer, &mut self.sprites);
+ self.renderer.present();
}
}
pub trait AppState {
- fn enter(&mut self, ctrl_man: &mut ControllerManager);
+ fn enter(&mut self, ctrl_man: &ControllerManager);
fn leave(&mut self);
- fn update(&mut self, dt: Nanoseconds);
- fn render(&mut self, canvas: &mut Canvas<Window>, sprites: &mut SpriteManager);
+ fn update(&mut self, dt: Duration);
+ fn render(&mut self, renderer: &mut Renderer, sprites: &SpriteManager);
fn handle_event(&mut self, event: Event);
}
}
impl AppState for ActiveState {
- fn enter(&mut self, ctrl_man: &mut ControllerManager) {}
+ fn enter(&mut self, _ctrl_man: &ControllerManager) {}
- fn update(&mut self, dt: Nanoseconds) {
+ fn update(&mut self, dt: Duration) {
for b in &mut self.bolls {
b.update();
}
match dt {
- ns if ns < (NS_PER_FRAME - 90_0000) as u64 => self.change_boll_count(100),
- ns if ns > (NS_PER_FRAME + 90_0000) as u64 => self.change_boll_count(-100),
+ ns if ns < (NS_PER_FRAME - 90_0000).nanoseconds() => self.change_boll_count(100),
+ ns if ns > (NS_PER_FRAME + 90_0000).nanoseconds() => self.change_boll_count(-100),
_ => {}
}
}
- fn render(&mut self, canvas: &mut Canvas<Window>, sprites: &mut SpriteManager) {
+ fn render(&mut self, renderer: &mut Renderer, sprites: &SpriteManager) {
/* draw square of blocks */ {
let blocks = 20;
let size = 32;
);
let block = sprites.get("block");
for i in 0..blocks {
- canvas
- .copy(
+ renderer
+ .blit(
block,
None,
SDLRect::new((i) * size + offset.x, offset.y, size as u32, size as u32),
- )
- .unwrap();
- canvas
- .copy(
+ );
+ renderer
+ .blit(
block,
None,
SDLRect::new(
size as u32,
size as u32,
),
- )
- .unwrap();
- canvas
- .copy(
+ );
+ renderer
+ .blit(
block,
None,
SDLRect::new(
size as u32,
size as u32,
),
- )
- .unwrap();
- canvas
- .copy(
+ );
+ renderer
+ .blit(
block,
None,
SDLRect::new(
size as u32,
size as u32,
),
- )
- .unwrap();
+ );
}
}
let radius = 110.0 + size as f32 * 0.5;
let angle = (self.mario_angle as f32 - 90.0) * PI / 180.0;
let offset2 = point!((angle.cos() * radius) as i32, (angle.sin() * radius) as i32);
- canvas
- .copy_ex(
+ renderer
+ .blit_ex(
sprites.get("mario"),
None,
SDLRect::new(
sdl2::rect::Point::new(size / 2, size / 2),
false,
false,
- )
- .unwrap();
+ );
self.mario_angle = (self.mario_angle + 1.0) % 360.0;
}
/* draw circles and ellipses*/ {
let p = point!((self.screen.width / 2) as i16, (self.screen.height / 2) as i16);
- canvas
- .circle(p.x, p.y, 100, Color::RGB(255, 255, 255))
- .unwrap();
- canvas
- .aa_circle(p.x, p.y, 110, Color::RGB(255, 255, 255))
- .unwrap();
- canvas
- .ellipse(p.x, p.y, 50, 100, Color::RGB(255, 255, 255))
- .unwrap();
- canvas
- .aa_ellipse(p.x, p.y, 110, 55, Color::RGB(255, 255, 255))
- .unwrap();
+ renderer.circle(p, 100, (255, 255, 255));
+ renderer.circle(p, 110, (255, 255, 255));
+ renderer.ellipse(p, (50, 100), (255, 255, 255));
+ renderer.ellipse(p, (110, 55), (255, 255, 255));
}
for b in &self.bolls {
- b.draw(canvas, self.boll_size);
+ b.draw(renderer, self.boll_size);
}
}