-use boll::*;
-use common::{Nanoseconds, Point2D, Rect};
use core::controller::ControllerManager;
-use point; // defined in common, but loaded from main...
-use rand::Rng;
+use core::render::Renderer;
+use geometry::{Dimension};
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;
-
-const FPS: u32 = 60;
-const NS_PER_FRAME: u32 = 1_000_000_000 / FPS;
+use time::{Duration, Instant};
#[derive(Default)]
pub struct AppBuilder {
- resolution: Rect<u16>,
+ resolution: Dimension<u16>,
state: Option<Box<dyn AppState>>,
title: Option<String>,
}
impl AppBuilder {
pub fn with_resolution(mut self, width: u16, height: u16) -> Self {
- self.resolution = Rect { width, height };
+ self.resolution = Dimension { width, height };
self
}
.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 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))),
- ctrl_man: ControllerManager::new(context.joystick()?, context.haptic()?),
+ states: vec!(self.state.unwrap()),
+ ctrl_man: ControllerManager::new(context.game_controller()?, context.haptic()?),
})
}
}
pub struct App {
- canvas: Canvas<Window>,
+ renderer: Renderer,
event_pump: EventPump,
sprites: SpriteManager,
- state: Box<dyn AppState>,
+ states: Vec<Box<dyn AppState>>,
pub ctrl_man: ControllerManager,
}
}
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);
+ self.states[0].enter(&self.ctrl_man);
- 'running: loop {
- if let Err(_) = self.handle_events() {
- break 'running;
+ loop {
+ if let Some(change) = self.handle_events() {
+ self.handle_state_change(change);
}
- 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();
+ if let Some(state) = self.states.last_mut() {
+ if let Some(change) = state.update(duration) {
+ self.handle_state_change(change);
+ }
+ } else {
+ break;
+ }
- // 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.render();
}
+ }
- self.state.leave();
+ fn handle_state_change(&mut self, change: StateChange) {
+ match change {
+ StateChange::Push(mut state) => {
+ // if let Some(s) = self.states.last_mut() {
+ // s.pause();
+ // }
+ state.enter(&self.ctrl_man);
+ self.states.push(state);
+ }
+ StateChange::Pop => {
+ if let Some(mut s) = self.states.pop() {
+ s.leave();
+ }
+ }
+ StateChange::Exit => {
+ while let Some(mut s) = self.states.pop() {
+ s.leave();
+ }
+ }
+ }
}
- fn handle_events(&mut self) -> Result<(), ()> {
+ fn handle_events(&mut self) -> Option<StateChange> {
for event in self.event_pump.poll_iter() {
self.ctrl_man.handle_event(&event);
match event {
keycode: Some(Keycode::Escape),
..
} => {
- return Err(())
+ return Some(StateChange::Pop)
}
Event::KeyDown {
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),
} => {
println!("window focus lost")
}
- _ => self.state.handle_event(event),
+ _ => {
+ if let Some(state) = self.states.last_mut() {
+ if let Some(change) = state.handle_event(event) {
+ return Some(change);
+ }
+ } else {
+ return Some(StateChange::Exit)
+ }
+ },
}
}
- Ok(())
+ None
}
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.states.last_mut().unwrap().render(&mut self.renderer, &self.sprites);
+ self.renderer.present();
}
}
-pub trait AppState {
- fn enter(&mut self, ctrl_man: &mut ControllerManager);
- fn leave(&mut self);
- fn update(&mut self, dt: Nanoseconds);
- fn render(&mut self, canvas: &mut Canvas<Window>, sprites: &mut SpriteManager);
- fn handle_event(&mut self, event: Event);
-}
-
-type Bollar = Vec<Box<dyn Boll>>;
-
-#[derive(Default)]
-pub struct ActiveState {
- screen: Rect<u32>,
- bolls: Bollar,
- boll_size: u32,
- mario_angle: f64,
-}
-
-impl ActiveState {
- pub fn new(screen: (u32, u32)) -> ActiveState {
- ActiveState {
- bolls: Bollar::new(),
- boll_size: 1,
- screen: Rect::from(screen),
- ..Default::default()
- }
- }
-
- fn change_boll_count(&mut self, delta: i32) {
- #[allow(clippy::comparison_chain)]
- if delta > 0 {
- for _i in 0..delta {
- self.add_boll();
- }
- } else if delta < 0 {
- for _i in 0..(-delta) {
- self.bolls.pop();
- }
- }
- }
-
- fn add_boll(&mut self) {
- let mut rng = rand::thread_rng();
- self.bolls.push(Box::new(SquareBoll {
- pos: point!(
- rng.gen_range(0, self.screen.width) as f64,
- rng.gen_range(0, self.screen.height) as f64
- ),
- vel: point!(rng.gen_range(-2.0, 2.0), rng.gen_range(-2.0, 2.0)),
- }));
- }
+pub enum StateChange {
+ Push(Box<dyn AppState>),
+ Pop,
+ Exit,
}
-impl AppState for ActiveState {
- fn enter(&mut self, ctrl_man: &mut ControllerManager) {}
-
- fn update(&mut self, dt: Nanoseconds) {
- 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),
- _ => {}
- }
- }
-
- fn render(&mut self, canvas: &mut Canvas<Window>, sprites: &mut SpriteManager) {
- /* draw square of blocks */ {
- let blocks = 20;
- let size = 32;
- let offset = point!(
- (self.screen.width as i32 - (blocks + 1) * size) / 2,
- (self.screen.height as i32 - (blocks + 1) * size) / 2
- );
- let block = sprites.get("block");
- for i in 0..blocks {
- canvas
- .copy(
- block,
- None,
- SDLRect::new((i) * size + offset.x, offset.y, size as u32, size as u32),
- )
- .unwrap();
- canvas
- .copy(
- block,
- None,
- SDLRect::new(
- (blocks - i) * size + offset.x,
- (blocks) * size + offset.y,
- size as u32,
- size as u32,
- ),
- )
- .unwrap();
- canvas
- .copy(
- block,
- None,
- SDLRect::new(
- offset.x,
- (blocks - i) * size + offset.y,
- size as u32,
- size as u32,
- ),
- )
- .unwrap();
- canvas
- .copy(
- block,
- None,
- SDLRect::new(
- (blocks) * size + offset.x,
- (i) * size + offset.y,
- size as u32,
- size as u32,
- ),
- )
- .unwrap();
- }
- }
-
- /* draw mario */ {
- let size = 64;
- let offset = point!(
- (self.screen.width as i32 - size) / 2,
- (self.screen.height as i32 - size) / 2
- );
- 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(
- sprites.get("mario"),
- None,
- SDLRect::new(
- offset.x + offset2.x,
- offset.y + offset2.y,
- size as u32,
- size as u32,
- ),
- self.mario_angle,
- 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();
- }
-
- for b in &self.bolls {
- b.draw(canvas, self.boll_size);
- }
- }
-
- fn leave(&mut self) {
- println!("number of bolls: {}", self.bolls.len());
- }
-
- fn handle_event(&mut self, event: Event) {
- match event {
- Event::KeyDown {
- keycode: Some(Keycode::KpPlus),
- ..
- } => self.boll_size = std::cmp::min(self.boll_size + 1, 32),
- Event::KeyDown {
- keycode: Some(Keycode::KpMinus),
- ..
- } => self.boll_size = std::cmp::max(self.boll_size - 1, 1),
- Event::MouseMotion { x, y, .. } => self.bolls.push(Box::new(CircleBoll::new(
- point!(x as f64, y as f64),
- point!(0.0, 0.0),
- ))),
- _ => {}
- }
- }
+pub trait AppState {
+ fn enter(&mut self, ctrl_man: &ControllerManager);
+ fn leave(&mut self);
+ fn update(&mut self, dt: Duration) -> Option<StateChange>;
+ fn render(&mut self, renderer: &mut Renderer, sprites: &SpriteManager);
+ fn handle_event(&mut self, event: Event) -> Option<StateChange>;
}
Dolda2000 GitWeb / kaka / rust-sdl-test.git / blobdiff