lesson 6 -- simpler than expected

lesson06/Cargo.toml

@@ -0,0 +1,10 @@
+[package]
+name = "lesson06"
+version = "0.1.0"
+authors = ["jmelesky <code@phaedrusdeinus.org>"]
+
+[dependencies.sdl2]
+version = "0.30.0"
+default-features = false
+features = ["image"]
+

lesson06/src/main.rs

@@ -0,0 +1,123 @@
+
+extern crate sdl2;
+
+use sdl2::Sdl;
+use sdl2::video::{Window};
+
+use sdl2::image::{LoadTexture};
+
+use sdl2::event::Event;
+use sdl2::keyboard::Keycode;
+
+use std::path::Path;
+
+
+
+// using a different window size than lazyfoo, due to high-density screen
+const WIDTH:u32  = 1280;
+const HEIGHT:u32 =  960;
+
+
+// need the window (blit settings) as well as the canvas
+// and still the context for the event pump
+//
+// splitting canvas out for now due to compilation reasons
+fn init() -> (Sdl, Window) {
+    let context = match sdl2::init() {
+        Ok(context) => context,
+        Err(err)    => panic!("Could not initialize SDL2. Error: {}", err),
+    };
+
+    let video = match context.video() {
+        Ok(video) => video,
+        Err(err)  => panic!("Could not gain access to the SDL2 video subsystem. Error: {}", err),
+    };
+
+    let window = match video.window("SDL Tutorial, lesson 06", WIDTH, HEIGHT)
+        .position_centered()
+        .opengl()
+        .build() {
+            Ok(window) => window,
+            Err(err)   => panic!("Could not create window. Error: {}", err),
+        };
+
+    // This seemed to be needed, based on the other rust lazyfoo conversion, 
+    // but it seems like in this version of rust-sdl2, texturecreators can
+    // load PNGs (and presumably JPGs) without explicitly initializing this
+    // subsystem
+    
+    // let image = match sdl2::image::init(INIT_PNG | INIT_JPG) {
+    //     Ok(image) => image,
+    //     Err(err)  => panic!("Could not initialize image subsystem. Error: {}", err),
+    // };
+
+    return (context, window)
+}
+
+
+// PNGs get loaded by the texturecreator, afaict, directly into textures.
+// therefore, deleting a few functions
+
+
+fn main() {
+
+    let mut running: bool = true;
+
+    let (context, window) = init();
+
+    // getting rid of all the texture optimization bits, since those
+    // operate on surfaces, which we're skipping for the png load
+
+    let mut canvas = match window.into_canvas()
+        .build() {
+            Ok(canvas) => canvas,
+            Err(err)   => panic!("Could not create canvas from window. Error: {}", err),
+        };
+    let tc = canvas.texture_creator();
+    let texture = match tc.load_texture(Path::new("../assets/loaded.png")) {
+        Ok(texture) => texture,
+        Err(err)    => panic!("Could not load png: {}", err)
+    };
+
+
+    let mut pump = match context.event_pump() {
+        Ok(pump) => pump,
+        Err(err) => panic!("Could not start pumping: {}", err)
+    };
+
+
+    while running {
+        // pull all pending events
+        for event in pump.poll_iter() {
+            match event {
+                // apparently '{..}' means "with whatever fields"
+                Event::Quit {..} => {
+                    running = false
+                },
+
+                Event::KeyDown { keycode: k, .. } => match k {
+                    Some(Keycode::Escape) | Some(Keycode::Q) => {
+                        running = false
+                    },
+                    Some(_) => {},
+                    None => {}
+                },
+
+                _ => {}
+            }
+        }
+
+
+        //canvas.clear();
+        match canvas.copy(&texture, None, None) {
+            Ok(())   => (), // no return value == success
+            Err(err) => panic!("Could not render texture: {}", err),
+        };
+
+        canvas.present();
+
+    }
+
+}
+
+