Do rendering via a renderer instead of sdl

[kaka/rust-sdl-test.git] / src / core / app.rs

diff --git a/src/core/app.rs b/src/core/app.rs
index cac2a37..99b24ac 100644 (file)
--- a/src/core/app.rs
+++ b/src/core/app.rs
@@ -1,15 +1,13 @@
 use boll::*;
 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;
@@ -61,20 +59,17 @@ impl AppBuilder {
             .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))),
@@ -124,7 +119,7 @@ impl AppBuilder {
 }
 
 pub struct App {
-    canvas: Canvas<Window>,
+    renderer: Renderer,
     event_pump: EventPump,
     sprites: SpriteManager,
     state: Box<dyn AppState>,
@@ -180,14 +175,7 @@ impl App {
                     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),
@@ -238,10 +226,9 @@ impl App {
     }
 
     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();
     }
 }
 
@@ -249,7 +236,7 @@ pub trait AppState {
     fn enter(&mut self, ctrl_man: &ControllerManager);
     fn leave(&mut self);
     fn update(&mut self, dt: Duration);
-    fn render(&mut self, canvas: &mut Canvas<Window>, sprites: &SpriteManager);
+    fn render(&mut self, renderer: &mut Renderer, sprites: &SpriteManager);
     fn handle_event(&mut self, event: Event);
 }
 
@@ -313,7 +300,7 @@ impl AppState for ActiveState {
         }
     }
 
-    fn render(&mut self, canvas: &mut Canvas<Window>, sprites: &SpriteManager) {
+    fn render(&mut self, renderer: &mut Renderer, sprites: &SpriteManager) {
         /* draw square of blocks */ {
             let blocks = 20;
             let size = 32;
@@ -323,15 +310,14 @@ impl AppState for ActiveState {
             );
             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(
@@ -340,10 +326,9 @@ impl AppState for ActiveState {
                             size as u32,
                             size as u32,
                         ),
-                    )
-                    .unwrap();
-                canvas
-                    .copy(
+                    );
+                renderer
+                    .blit(
                         block,
                         None,
                         SDLRect::new(
@@ -352,10 +337,9 @@ impl AppState for ActiveState {
                             size as u32,
                             size as u32,
                         ),
-                    )
-                    .unwrap();
-                canvas
-                    .copy(
+                    );
+                renderer
+                    .blit(
                         block,
                         None,
                         SDLRect::new(
@@ -364,8 +348,7 @@ impl AppState for ActiveState {
                             size as u32,
                             size as u32,
                         ),
-                    )
-                    .unwrap();
+                    );
             }
         }
 
@@ -378,8 +361,8 @@ impl AppState for ActiveState {
             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(
@@ -392,29 +375,20 @@ impl AppState for ActiveState {
                     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);
         }
     }