2 use common::{Nanoseconds, Point2D, Rect};
3 use core::controller::ControllerManager;
4 use point; // defined in common, but loaded from main...
6 use sdl2::event::{Event, WindowEvent};
7 use sdl2::gfx::primitives::DrawRenderer;
8 use sdl2::keyboard::Keycode;
9 use sdl2::pixels::Color;
10 use sdl2::rect::Rect as SDLRect;
11 use sdl2::render::{BlendMode, Canvas};
12 use sdl2::video::{FullscreenType, SwapInterval, Window};
13 use sdl2::{EventPump, VideoSubsystem};
14 use sprites::SpriteManager;
15 use std::f32::consts::PI;
16 use time::PreciseTime;
19 const NS_PER_FRAME: u32 = 1_000_000_000 / FPS;
22 pub struct AppBuilder {
23 resolution: Rect<u16>,
24 state: Option<Box<dyn AppState>>,
25 title: Option<String>,
29 pub fn with_resolution(mut self, width: u16, height: u16) -> Self {
30 self.resolution = Rect { width, height };
34 pub fn with_state(mut self, state: Box<dyn AppState>) -> Self {
35 self.state = Some(state);
39 pub fn with_title(mut self, title: &str) -> Self {
40 self.title = Some(title.to_string());
44 pub fn build(self) -> Result<App, String> {
45 let context = sdl2::init().unwrap();
46 sdl2::image::init(sdl2::image::InitFlag::PNG)?;
47 let video = context.video()?;
48 //self.print_video_display_modes(&video);
53 self.resolution.width.into(),
54 self.resolution.height.into(),
58 // .fullscreen_desktop()
62 context.mouse().show_cursor(false);
64 let mut canvas = window.into_canvas().build().unwrap();
65 canvas.set_blend_mode(BlendMode::Add);
66 canvas.set_draw_color(Color::RGB(0, 0, 0));
70 video.gl_set_swap_interval(SwapInterval::VSync)?;
72 let event_pump = context.event_pump()?;
73 let sprites = SpriteManager::new(canvas.texture_creator());
74 let screen = canvas.output_size().unwrap();
80 state: self.state.unwrap_or_else(|| Box::new(ActiveState::new(screen))),
81 ctrl_man: ControllerManager::new(context.joystick()?, context.haptic()?),
86 fn print_video_display_modes(&self, video: &VideoSubsystem) {
87 println!("video subsystem: {:?}", video);
88 println!("current_video_driver: {:?}", video.current_video_driver());
89 for display in 0..video.num_video_displays().unwrap() {
91 "=== display {} - {} ===",
93 video.display_name(display).unwrap()
96 " display_bounds: {:?}",
97 video.display_bounds(display).unwrap()
100 " num_display_modes: {:?}",
101 video.num_display_modes(display).unwrap()
104 " desktop_display_mode: {:?}",
105 video.desktop_display_mode(display).unwrap()
107 let current = video.current_display_mode(display).unwrap();
109 " current_display_mode: {:?}",
112 for idx in 0..video.num_display_modes(display).unwrap() {
113 let mode = video.display_mode(display, idx).unwrap();
116 if mode == current { "*" } else { " " },
122 println!("swap interval: {:?}", video.gl_get_swap_interval());
127 canvas: Canvas<Window>,
128 event_pump: EventPump,
129 sprites: SpriteManager,
130 state: Box<dyn AppState>,
131 pub ctrl_man: ControllerManager,
135 #[allow(clippy::new_ret_no_self)]
136 pub fn new() -> AppBuilder {
140 pub fn load_sprites(&mut self, sprites: &[(&str, &str)]) {
141 for (name, file) in sprites {
142 self.sprites.load(name, file);
146 pub fn start(&mut self) {
147 // let mut frame_count: u64 = 0;
148 // let mut fps_time = PreciseTime::now();
149 let mut last_time = PreciseTime::now();
151 self.state.enter(&mut self.ctrl_man);
154 if let Err(_) = self.handle_events() {
159 last_time.to(PreciseTime::now()).num_nanoseconds().unwrap() as Nanoseconds;
160 last_time = PreciseTime::now();
161 self.ctrl_man.update(duration);
162 self.state.update(duration);
167 // if frame_count == FPS as u64 {
168 // let duration = fps_time.to(PreciseTime::now()).num_nanoseconds().unwrap() as f64
169 // / 1_000_000_000.0;
170 // // println!("fps: {}", frame_count as f64 / duration);
172 // fps_time = PreciseTime::now();
179 fn handle_events(&mut self) -> Result<(), ()> {
180 for event in self.event_pump.poll_iter() {
181 self.ctrl_man.handle_event(&event);
185 keycode: Some(Keycode::Escape),
191 keycode: Some(Keycode::F11),
194 match self.canvas.window().fullscreen_state() {
195 FullscreenType::Off => self
198 .set_fullscreen(FullscreenType::Desktop),
199 _ => self.canvas.window_mut().set_fullscreen(FullscreenType::Off),
204 win_event: WindowEvent::Resized(x, y),
207 println!("window resized({}, {})", x, y)
210 win_event: WindowEvent::Maximized,
213 println!("window maximized")
216 win_event: WindowEvent::Restored,
219 println!("window restored")
222 win_event: WindowEvent::Enter,
225 println!("window enter")
228 win_event: WindowEvent::Leave,
231 println!("window leave")
234 win_event: WindowEvent::FocusGained,
237 println!("window focus gained")
240 win_event: WindowEvent::FocusLost,
243 println!("window focus lost")
245 _ => self.state.handle_event(event),
251 fn render(&mut self) {
252 self.canvas.set_draw_color(Color::RGB(0, 0, 0));
254 self.state.render(&mut self.canvas, &mut self.sprites);
255 self.canvas.present();
260 fn enter(&mut self, ctrl_man: &mut ControllerManager);
262 fn update(&mut self, dt: Nanoseconds);
263 fn render(&mut self, canvas: &mut Canvas<Window>, sprites: &mut SpriteManager);
264 fn handle_event(&mut self, event: Event);
267 type Bollar = Vec<Box<dyn Boll>>;
270 pub struct ActiveState {
278 pub fn new(screen: (u32, u32)) -> ActiveState {
280 bolls: Bollar::new(),
282 screen: Rect::from(screen),
287 fn change_boll_count(&mut self, delta: i32) {
288 #[allow(clippy::comparison_chain)]
293 } else if delta < 0 {
294 for _i in 0..(-delta) {
300 fn add_boll(&mut self) {
301 let mut rng = rand::thread_rng();
302 self.bolls.push(Box::new(SquareBoll {
304 rng.gen_range(0, self.screen.width) as f64,
305 rng.gen_range(0, self.screen.height) as f64
307 vel: point!(rng.gen_range(-2.0, 2.0), rng.gen_range(-2.0, 2.0)),
312 impl AppState for ActiveState {
313 fn enter(&mut self, ctrl_man: &mut ControllerManager) {}
315 fn update(&mut self, dt: Nanoseconds) {
316 for b in &mut self.bolls {
321 ns if ns < (NS_PER_FRAME - 90_0000) as u64 => self.change_boll_count(100),
322 ns if ns > (NS_PER_FRAME + 90_0000) as u64 => self.change_boll_count(-100),
327 fn render(&mut self, canvas: &mut Canvas<Window>, sprites: &mut SpriteManager) {
328 /* draw square of blocks */ {
332 (self.screen.width as i32 - (blocks + 1) * size) / 2,
333 (self.screen.height as i32 - (blocks + 1) * size) / 2
335 let block = sprites.get("block");
341 SDLRect::new((i) * size + offset.x, offset.y, size as u32, size as u32),
349 (blocks - i) * size + offset.x,
350 (blocks) * size + offset.y,
362 (blocks - i) * size + offset.y,
373 (blocks) * size + offset.x,
374 (i) * size + offset.y,
386 (self.screen.width as i32 - size) / 2,
387 (self.screen.height as i32 - size) / 2
389 let radius = 110.0 + size as f32 * 0.5;
390 let angle = (self.mario_angle as f32 - 90.0) * PI / 180.0;
391 let offset2 = point!((angle.cos() * radius) as i32, (angle.sin() * radius) as i32);
394 sprites.get("mario"),
397 offset.x + offset2.x,
398 offset.y + offset2.y,
403 sdl2::rect::Point::new(size / 2, size / 2),
408 self.mario_angle = (self.mario_angle + 1.0) % 360.0;
411 /* draw circles and ellipses*/ {
412 let p = point!((self.screen.width / 2) as i16, (self.screen.height / 2) as i16);
414 .circle(p.x, p.y, 100, Color::RGB(255, 255, 255))
417 .aa_circle(p.x, p.y, 110, Color::RGB(255, 255, 255))
420 .ellipse(p.x, p.y, 50, 100, Color::RGB(255, 255, 255))
423 .aa_ellipse(p.x, p.y, 110, 55, Color::RGB(255, 255, 255))
427 for b in &self.bolls {
428 b.draw(canvas, self.boll_size);
432 fn leave(&mut self) {
433 println!("number of bolls: {}", self.bolls.len());
436 fn handle_event(&mut self, event: Event) {
439 keycode: Some(Keycode::KpPlus),
441 } => self.boll_size = std::cmp::min(self.boll_size + 1, 32),
443 keycode: Some(Keycode::KpMinus),
445 } => self.boll_size = std::cmp::max(self.boll_size - 1, 1),
446 Event::MouseMotion { x, y, .. } => self.bolls.push(Box::new(CircleBoll::new(
447 point!(x as f64, y as f64),