2 use common::{Point2D, Rect};
3 use point; // defined in common, but loaded from main...
5 use sdl2::event::Event;
6 use sdl2::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;
12 use sdl2::render::Canvas;
13 use sdl2::video::FullscreenType;
14 use sdl2::video::{SwapInterval, Window};
15 use sdl2::{EventPump, VideoSubsystem};
16 use sprites::SpriteManager;
17 use std::f32::consts::PI;
18 use time::PreciseTime;
20 pub type Nanoseconds = u64;
23 const NS_PER_FRAME: u32 = 1_000_000_000 / FPS;
26 pub struct AppBuilder {
27 resolution: Rect<u16>,
28 state: Option<Box<dyn AppState>>,
29 title: Option<String>,
33 pub fn with_resolution(mut self, width: u16, height: u16) -> Self {
34 self.resolution = Rect { width, height };
38 pub fn with_state(mut self, state: Box<dyn AppState>) -> Self {
39 self.state = Some(state);
43 pub fn with_title(mut self, title: &str) -> Self {
44 self.title = Some(title.to_string());
48 pub fn build(self) -> Result<App, String> {
49 let context = sdl2::init().unwrap();
50 sdl2::image::init(sdl2::image::InitFlag::PNG)?;
51 let video = context.video()?;
53 self.print_video_display_modes(&video);
58 self.resolution.width.into(),
59 self.resolution.height.into(),
63 // .fullscreen_desktop()
67 context.mouse().show_cursor(false);
69 let mut canvas = window.into_canvas().build().unwrap();
70 canvas.set_blend_mode(BlendMode::Add);
71 canvas.set_draw_color(Color::RGB(0, 0, 0));
75 video.gl_set_swap_interval(SwapInterval::VSync)?;
77 let event_pump = context.event_pump()?;
78 let sprites = SpriteManager::new(canvas.texture_creator());
79 let screen = canvas.output_size().unwrap();
85 state: self.state.unwrap_or_else(|| Box::new(ActiveState::new(screen))),
89 fn print_video_display_modes(&self, video: &VideoSubsystem) {
90 println!("video subsystem: {:?}", video);
91 println!("current_video_driver: {:?}", video.current_video_driver());
92 for display in 0..video.num_video_displays().unwrap() {
94 "=== display {} - {} ===",
96 video.display_name(display).unwrap()
99 " display_bounds: {:?}",
100 video.display_bounds(display).unwrap()
103 " num_display_modes: {:?}",
104 video.num_display_modes(display).unwrap()
107 " desktop_display_mode: {:?}",
108 video.desktop_display_mode(display).unwrap()
111 " current_display_mode: {:?}",
112 video.current_display_mode(display).unwrap()
114 for mode in 0..video.num_display_modes(display).unwrap() {
118 video.display_mode(display, mode).unwrap()
122 println!("swap interval: {:?}", video.gl_get_swap_interval());
127 pub canvas: Canvas<Window>,
128 pub event_pump: EventPump,
129 pub sprites: SpriteManager,
130 pub state: Box<dyn AppState>,
134 #[allow(clippy::new_ret_no_self)]
135 pub fn new() -> AppBuilder {
139 pub fn load_sprites(&mut self, sprites: &[(&str, &str)]) {
140 for (name, file) in sprites {
141 self.sprites.load(name, file);
145 pub fn start(&mut self) {
146 let mut frame_count: u64 = 0;
147 let mut fps_time = PreciseTime::now();
148 let mut last_time = PreciseTime::now();
149 let screen = self.canvas.output_size().unwrap();
150 let screen = Rect::from((screen.0 as i32, screen.1 as i32));
152 let mut mario_angle = 0.0;
155 self.canvas.set_draw_color(Color::RGB(0, 0, 0));
161 (screen.width - (blocks + 1) * size) / 2,
162 (screen.height - (blocks + 1) * size) / 2
164 let block = self.sprites.get("block");
170 SDLRect::new((i) * size + offset.x, offset.y, size as u32, size as u32),
178 (blocks - i) * size + offset.x,
179 (blocks) * size + offset.y,
191 (blocks - i) * size + offset.y,
202 (blocks) * size + offset.x,
203 (i) * size + offset.y,
214 (screen.width - size) / 2,
215 (screen.height - size) / 2
217 let radius = 110.0 + size as f32 * 0.5;
218 let angle = (mario_angle as f32 - 90.0) * PI / 180.0;
219 let offset2 = point!((angle.cos() * radius) as i32, (angle.sin() * radius) as i32);
222 self.sprites.get("mario"),
225 offset.x + offset2.x,
226 offset.y + offset2.y,
231 sdl2::rect::Point::new(size / 2, size / 2),
237 if mario_angle >= 360.0 {
242 let p = point!((screen.width / 2) as i16, (screen.height / 2) as i16);
244 .circle(p.x, p.y, 100, Color::RGB(255, 255, 255))
247 .aa_circle(p.x, p.y, 110, Color::RGB(255, 255, 255))
250 .ellipse(p.x, p.y, 50, 100, Color::RGB(255, 255, 255))
253 .aa_ellipse(p.x, p.y, 110, 55, Color::RGB(255, 255, 255))
257 // window.gl_swap_window();
258 for event in self.event_pump.poll_iter() {
262 keycode: Some(Keycode::Escape),
268 keycode: Some(Keycode::F11),
271 match self.canvas.window().fullscreen_state() {
272 FullscreenType::Off => self
275 .set_fullscreen(FullscreenType::Desktop),
276 _ => self.canvas.window_mut().set_fullscreen(FullscreenType::Off),
281 win_event: WindowEvent::Resized(x, y),
284 println!("window resized({}, {})", x, y)
287 win_event: WindowEvent::Maximized,
290 println!("window maximized")
293 win_event: WindowEvent::Restored,
296 println!("window restored")
299 win_event: WindowEvent::Enter,
302 println!("window enter")
305 win_event: WindowEvent::Leave,
308 println!("window leave")
311 win_event: WindowEvent::FocusGained,
314 println!("window focus gained")
317 win_event: WindowEvent::FocusLost,
320 println!("window focus lost")
322 _ => self.state.on_event(event),
327 last_time.to(PreciseTime::now()).num_nanoseconds().unwrap() as Nanoseconds;
328 last_time = PreciseTime::now();
329 self.state.update(duration);
330 self.state.render(&mut self.canvas);
331 self.canvas.present();
334 if frame_count == FPS as u64 {
335 let duration = fps_time.to(PreciseTime::now()).num_nanoseconds().unwrap() as f64
337 println!("fps: {}", frame_count as f64 / duration);
339 fps_time = PreciseTime::now();
348 fn update(&mut self, dt: Nanoseconds);
349 fn render(&self, canvas: &mut Canvas<Window>);
351 fn on_event(&mut self, event: Event);
354 type Bollar = Vec<Box<dyn Boll>>;
356 pub struct ActiveState {
363 pub fn new(screen: (u32, u32)) -> ActiveState {
365 bolls: Bollar::new(),
367 screen: Rect::from(screen),
371 fn change_boll_count(&mut self, delta: i32) {
372 #[allow(clippy::comparison_chain)]
377 } else if delta < 0 {
378 for _i in 0..(-delta) {
384 fn add_boll(&mut self) {
385 let mut rng = rand::thread_rng();
386 self.bolls.push(Box::new(SquareBoll {
388 rng.gen_range(0, self.screen.width) as f64,
389 rng.gen_range(0, self.screen.height) as f64
391 vel: point!(rng.gen_range(-2.0, 2.0), rng.gen_range(-2.0, 2.0)),
396 impl AppState for ActiveState {
397 fn update(&mut self, dt: Nanoseconds) {
398 for b in &mut self.bolls {
403 ns if ns < (NS_PER_FRAME - 90_0000) as u64 => self.change_boll_count(100),
404 ns if ns > (NS_PER_FRAME + 90_0000) as u64 => self.change_boll_count(-100),
409 fn render(&self, canvas: &mut Canvas<Window>) {
410 for b in &self.bolls {
411 b.draw(canvas, self.boll_size);
416 println!("number of bolls: {}", self.bolls.len());
419 fn on_event(&mut self, event: Event) {
422 keycode: Some(Keycode::KpPlus),
424 } => self.boll_size = std::cmp::min(self.boll_size + 1, 32),
426 keycode: Some(Keycode::KpMinus),
428 } => self.boll_size = std::cmp::max(self.boll_size - 1, 1),
429 Event::MouseMotion { x, y, .. } => self.bolls.push(Box::new(CircleBoll::new(
430 point!(x as f64, y as f64),