added mac support

example/Cargo.toml

@@ -9,6 +9,14 @@ authors = ["Matthew Michelotti <matthew@matthewmichelotti.com>"]
 
 [dependencies]
 gate = { path = "../gate" }
+gl = "0.10.0"
 
 [build-dependencies]
 gate_build = { path = "../gate_build" }
+
+#Could also add "bundled", "static-link"
+[dependencies.sdl2]
+version = "0.31.0"
+default-features = false
+features = ["use_mac_framework","image","mixer"]
+

example/build.rs

@@ -29,6 +29,10 @@ fn main() {
     packer.sprites(Path::new("src_assets/sprites"));
     packer.music(Path::new("src_assets/music"));
     packer.sounds(Path::new("src_assets/sounds"));
-    if is_wasm { packer.gen_javascript_and_html(); }
+    if is_wasm { 
+        packer.gen_javascript_and_html(); 
+    } else {
+        println!("cargo:rustc-link-search=framework=/Library/Frameworks"); 
+    }
     packer.gen_asset_id_code(&gen_code_path);
 }

gate/Cargo.toml

@@ -15,4 +15,4 @@ byteorder = "1.3.2"
 
 [target.'cfg(not(target_arch = "wasm32"))'.dependencies]
 gl = "0.6.1"
-sdl2 = { version = "0.29", default-features = false, features = ["image", "mixer"] }
+sdl2 = { version = "0.31.0", default-features = false, features = ["image", "mixer", "unsafe_textures"] }

gate/src/core/sdl/mod.rs

@@ -23,12 +23,12 @@ use std::path::Path;
 use std::fs::File;
 use std::io::BufReader;
 
-use sdl2::{self, VideoSubsystem};
+use sdl2::{self};
 use sdl2::video::{FullscreenType, GLProfile};
 use sdl2::video::gl_attr::GLAttr;
 use sdl2::image::LoadTexture;
 use sdl2::mixer::{Sdl2MixerContext, INIT_OGG, DEFAULT_CHANNELS, AUDIO_S16LSB};
-use sdl2::render::{Renderer as SdlRenderer};
+use sdl2::render::{TextureCreator};
 
 use gl;
 use gl::types::*;
@@ -54,6 +54,7 @@ macro_rules! gate_header {
 }
 
 pub fn run<AS: AppAssetId, AP: App<AS>>(info: AppInfo, mut app: AP) {
+
     mark_app_created_flag();
 
     #[cfg(target_os = "windows")]
@@ -73,19 +74,52 @@ pub fn run<AS: AppAssetId, AP: App<AS>>(info: AppInfo, mut app: AP) {
         .position_centered().opengl().resizable()
         .build().unwrap();
 
-    let mut sdl_renderer = window.renderer()
+    let mut canvas = window.into_canvas()
+        .index(find_sdl_gl_driver().unwrap())
+        .target_texture()
+        .present_vsync()
         .accelerated()
         .build().unwrap();
 
-    init_gl(&video);
 
-    let mut renderer = build_renderer(&info, &sdl_renderer);
+    gl::load_with(|name| video.gl_get_proc_address(name) as *const _);
+    canvas.window().gl_set_context_to_current().expect("OpenGL failed to start");   
+
+    unsafe {
+        gl::Enable(gl::BLEND);
+        gl::BlendFunc(gl::ONE, gl::ONE_MINUS_SRC_ALPHA);
+        gl::ClearColor(0.6, 0.0, 0.8, 1.0);
+        gl::Clear(gl::COLOR_BUFFER_BIT);
+    }
+
+    canvas.present();
+
+    if info.print_gl_info { 
+        print_gl_info(); 
+    }
+
+    let texture_creator : TextureCreator<_> = canvas.texture_creator();
+
+    //let mut renderer = build_renderer(&info, &mut canvas, &texture_creator);
+    let sprites_atlas = Atlas::new(BufReader::new(File::open("assets/sprites.atlas").unwrap())).unwrap();
+    let render_buffer = RenderBuffer::new(&info, info.window_pixels, sprites_atlas);
+
+    let mut sprites_tex = texture_creator.load_texture(Path::new("assets/sprites.png")).unwrap();
+    unsafe {
+        sprites_tex.gl_bind_texture();
+        gl::TexParameteri(gl::TEXTURE_2D, gl::TEXTURE_MAG_FILTER, gl::LINEAR as GLint);
+        gl::TexParameteri(gl::TEXTURE_2D, gl::TEXTURE_MIN_FILTER, gl::LINEAR as GLint);
+        sprites_tex.gl_unbind_texture();
+    }
+
+
+    // TODO need to ensure Nearest-neighbor sampling is used?
+    let core_renderer = CoreRenderer::new(sprites_tex);
 
-    gl_error_check();
+    let mut renderer = Renderer::<AS>::new(render_buffer, core_renderer);
 
     let mut ctx = AppContext::new(CoreAudio::new(AS::Sound::count()), renderer.app_dims(), renderer.native_px());
 
-    if info.print_gl_info { print_gl_info(); }
 
     app.start(&mut ctx);
 
@@ -97,25 +131,25 @@ pub fn run<AS: AppAssetId, AP: App<AS>>(info: AppInfo, mut app: AP) {
             gl::Clear(gl::COLOR_BUFFER_BIT);
         }
 
-        let screen_dims = sdl_renderer.window().unwrap().size();
+        let screen_dims = canvas.window().size();
         if screen_dims.0 > 0 && screen_dims.1 > 0 {
             renderer.set_screen_dims(screen_dims);
             ctx.set_dims(renderer.app_dims(), renderer.native_px());
             app.render(&mut renderer, &ctx);
             renderer.flush();
         }
-        sdl_renderer.present();
+        canvas.present();
         gl_error_check();
 
         let elapsed = clock.step();
 
         match (ctx.is_fullscreen(), ctx.desires_fullscreen()) {
             (false, true) => {
-                let success = sdl_renderer.window_mut().unwrap().set_fullscreen(FullscreenType::Desktop).is_ok();
+                let success = canvas.window_mut().set_fullscreen(FullscreenType::Desktop).is_ok();
                 ctx.set_is_fullscreen(success);
             },
             (true, false) => {
-                let success = sdl_renderer.window_mut().unwrap().set_fullscreen(FullscreenType::Off).is_ok();
+                let success = canvas.window_mut().set_fullscreen(FullscreenType::Off).is_ok();
                 ctx.set_is_fullscreen(!success);
             },
             (false, false) | (true, true) => {},
@@ -128,22 +162,6 @@ pub fn run<AS: AppAssetId, AP: App<AS>>(info: AppInfo, mut app: AP) {
     }
 }
 
-fn build_renderer<AS: AppAssetId>(info: &AppInfo, sdl_renderer: &SdlRenderer) -> Renderer<AS> {
-    let sprites_atlas = Atlas::new(BufReader::new(File::open("assets/sprites.atlas").unwrap())).unwrap();
-    let render_buffer = RenderBuffer::new(&info, info.window_pixels, sprites_atlas);
-
-    let mut sprites_tex = sdl_renderer.load_texture(Path::new("assets/sprites.png")).unwrap();
-    unsafe {
-        sprites_tex.gl_bind_texture();
-        gl::TexParameteri(gl::TEXTURE_2D, gl::TEXTURE_MAG_FILTER, gl::LINEAR as GLint);
-        gl::TexParameteri(gl::TEXTURE_2D, gl::TEXTURE_MIN_FILTER, gl::LINEAR as GLint);
-        sprites_tex.gl_unbind_texture();
-    }
-    // TODO need to ensure Nearest-neighbor sampling is used?
-    let core_renderer = CoreRenderer::new(sprites_tex);
-
-    Renderer::<AS>::new(render_buffer, core_renderer)
-}
 
 fn mixer_init() -> Sdl2MixerContext {
     match sdl2::mixer::init(INIT_OGG) {
@@ -167,13 +185,13 @@ fn gl_hints(gl_attr: GLAttr) {
     gl_attr.set_context_version(3, 0);
 }
 
-fn init_gl(video: &VideoSubsystem) {
-    gl::load_with(|name| video.gl_get_proc_address(name) as *const _);
-
-    unsafe {
-        gl::Enable(gl::BLEND);
-        gl::BlendFunc(gl::ONE, gl::ONE_MINUS_SRC_ALPHA);
+fn find_sdl_gl_driver() -> Option<u32> {
+    for (index, item) in sdl2::render::drivers().enumerate() {
+        if item.name == "opengl" {
+            return Some(index as u32);
+        }
     }
+    None
 }
 
 fn print_gl_info() {

gate/src/renderer/core_renderer/sdl/shader_util.rs

@@ -26,9 +26,9 @@ pub fn compile_shader(src: *const c_char, ty: GLenum) -> GLuint {
         gl::CompileShader(shader);
 
         let mut status = gl::FALSE as GLint;
-        gl::GetShaderiv(shader, gl::COMPILE_STATUS, &mut status);
+        gl::GetShaderiv(shader, gl::COMPILE_STATUS, &mut status);        
 
-        if status != (gl::TRUE as GLint) {
+        if status != (gl::TRUE as GLint) {            
             let mut len = 0;
             gl::GetShaderiv(shader, gl::INFO_LOG_LENGTH, &mut len);
             let mut buf = Vec::with_capacity(len as usize - 1);

gate/src/renderer/shaders/sprite.frag

@@ -1,4 +1,4 @@
-#version 100
+#version 120
 
 // Copyright 2017-2019 Matthew D. Michelotti
 //
@@ -14,8 +14,6 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-precision highp float;
-
 uniform sampler2D tex;
 uniform vec2 inv_tex_dims; // inverse of tex dimensions
 

gate/src/renderer/shaders/sprite.vert

@@ -1,4 +1,4 @@
-#version 100
+#version 120
 
 // Copyright 2017-2019 Matthew D. Michelotti
 //