Native done

1 files changed, 174 insertions, 153 deletions

diff --git a/src/lib.rs b/src/lib.rs
index b89b27e..d0fdfc0 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -35,113 +35,123 @@ where
     }
 }
 
-pub fn event_loop_body<G>(event: winit::event::Event<()>, elwt: &winit::event_loop::EventLoopWindowTarget<()>)
-    where G: state::Game + 'static,
+#[cfg(not(target_arch = "wasm32"))]
+pub async fn run<'a, F, G, Fut>(title: &str, gnew: F)
+where
+    Fut: std::future::Future<Output = G>,
+    G: state::Game + 'static,
+    F: (Fn(&'a context::Context) -> Fut),
 {
-    contextualize(|ctx, st, game: &mut G| {
-        match &event {
-            winit::event::Event::WindowEvent {
-                event: wev,
-                window_id,
-                ..
-            } => match wev {
-                winit::event::WindowEvent::CloseRequested
-                    if *window_id == ctx.window.id() => elwt.exit(),
-                winit::event::WindowEvent::Resized{..} => {
-                    #[cfg(target_arch = "wasm32")]
-                    ctx.maximize_canvas();
+    env_logger::Builder::new()
+        .filter(None, log::LevelFilter::Info)
+        .init();
+
+    log::info!("hello computer, starting up...");
+
+    let (sdl, window, gl, mut event_loop, _gl_context) = {
+        let sdl = sdl2::init().expect("failed to initialize SDL2");
+        let video = sdl.video().expect("failed to initialize SDL2 video");
+        // let gl_attr = video.gl_attr();
+        // gl_attr.set_context_profile(sdl2::video::GLProfile::Core);
+        // gl_attr.set_context_version(3, 0);
+        let window = video
+            .window(title, 640, 360)
+            .opengl()
+            // .fullscreen_desktop()
+            .resizable()
+            .build()
+            .unwrap();
+        let gl_context = window.gl_create_context().unwrap();
+        let gl = unsafe {
+            glow::Context::from_loader_function(|s| video.gl_get_proc_address(s) as *const _)
+        };
+        let event_loop = sdl.event_pump().unwrap();
+        (sdl, window, gl, event_loop, gl_context)
+    };
+
+    let ctx = Box::leak(Box::new(context::Context::new(sdl, window, gl)));
+    let game = Box::leak(Box::new(gnew(ctx).await));
+    let st = Box::leak(Box::new(state::State::new(&ctx)));
+
+    unsafe {
+        CTX = Some(ctx as _);
+        ST = Some(st as _);
+        G = Some(game as *mut G as *mut std::ffi::c_void);
+    }
+
+    'running: loop {
+        for event in event_loop.poll_iter() {
+            match event {
+                sdl2::event::Event::Quit {..} => {
+                    log::info!("bye!");
+                    break 'running;
+                },
+                sdl2::event::Event::Window { win_event: sdl2::event::WindowEvent::Resized(_, _), .. } => {
                     st.handle_resize(&ctx);
                 },
-                winit::event::WindowEvent::Focused(false) => {
+                sdl2::event::Event::Window { win_event: sdl2::event::WindowEvent::FocusLost, .. } => {
                     st.keys = state::Keys::new();
                 },
-                winit::event::WindowEvent::CursorMoved { position, ..} => {
-                    st.mouse_moved(&ctx, position.x as f32, position.y as f32, game);
+                sdl2::event::Event::MouseMotion { x, y, .. } => {
+                    st.mouse_moved(&ctx, x as f32, y as f32, game);
+                },
+                sdl2::event::Event::MouseButtonDown {..} => {
+                    st.mouse_pressed(&ctx, game)
+                },
+                sdl2::event::Event::MouseButtonUp {..} => {
+                    st.mouse_released(&ctx)
+                },
+                sdl2::event::Event::KeyDown { keycode: Some(key), repeat: false, .. } => {
+                    st.key_pressed(&ctx, key)
+                },
+                sdl2::event::Event::KeyUp { keycode: Some(key), repeat: false, .. } => {
+                    st.key_released(&ctx, key)
                 },
-                winit::event::WindowEvent::MouseInput {
-                    button,
-                    state,
-                    ..
-                } => match state {
-                    winit::event::ElementState::Pressed => {
-                        st.mouse_pressed(&ctx, *button, game)
-                    },
-                    winit::event::ElementState::Released => {
-                        st.mouse_released(&ctx, *button)
-                    },
-                }
-                winit::event::WindowEvent::KeyboardInput {
-                    event: winit::event::KeyEvent {
-                        physical_key: winit::keyboard::PhysicalKey::Code(key),
-                        state,
-                        repeat: false,
-                        ..
-                    },
-                    ..
-                } => match state {
-                    winit::event::ElementState::Pressed => {
-                        st.key_pressed(&ctx, *key)
-                    },
-                    winit::event::ElementState::Released => {
-                        st.key_released(&ctx, *key)
-                    },
-                }
                 _ => {},
-            },
-            
-            winit::event::Event::AboutToWait => {
-                if ctx.resize_necessary() {
-                    #[cfg(target_arch = "wasm32")]
-                    ctx.maximize_canvas();
-                    st.handle_resize(&ctx);
-                }
-                if let Some(f) = &mut st.request {
-                    match std::future::Future::poll(f.as_mut(), &mut st.waker_ctx) {
-                        std::task::Poll::Pending => {},
-                        std::task::Poll::Ready(res) => {
-                            st.request = None;
-                            match res {
-                                Ok(r) => st.request_returned(&ctx, game, r),
-                                Err(e) => log::warn!("error during HTTP request: {}", e),
-                            }
-                        },
+            }
+        }
+        if ctx.resize_necessary() {
+            st.handle_resize(&ctx);
+        }
+        if let Some(f) = &mut st.request {
+            match std::future::Future::poll(f.as_mut(), &mut st.waker_ctx) {
+                std::task::Poll::Pending => {},
+                std::task::Poll::Ready(res) => {
+                    st.request = None;
+                    match res {
+                        Ok(r) => st.request_returned(&ctx, game, r),
+                        Err(e) => log::warn!("error during HTTP request: {}", e),
                     }
-                    // f.poll();
-                }
-                st.run_update(&ctx, game);
-                st.run_render(&ctx, game);
-                ctx.window.request_redraw();
-            },
-
-            _ => {},
+                },
+            }
         }
-    });
+        st.run_update(&ctx, game);
+        st.run_render(&ctx, game);
+        ctx.window.gl_swap_window();
+    }
+
+    // event_loop.set_control_flow(winit::event_loop::ControlFlow::Poll);
+    // event_loop.run(|event, elwt| {
+    //     event_loop_body::<G>(event, elwt);
+    // }).expect("window closed");
 }
 
+#[cfg(target_arch = "wasm32")]
 pub async fn run<'a, F, G, Fut>(gnew: F)
 where
     Fut: std::future::Future<Output = G>,
     G: state::Game + 'static,
     F: (Fn(&'a context::Context) -> Fut),
 {
-    #[cfg(target_arch = "wasm32")]
-    {
-        console_log::init_with_level(log::Level::Debug).unwrap();
-        console_error_panic_hook::set_once();
-        tracing_wasm::set_as_global_default();
-    }
-    #[cfg(not(target_arch = "wasm32"))]
-    {
-        env_logger::Builder::new()
-            .filter(None, log::LevelFilter::Info)
-            .init();
-    }
+    console_log::init_with_level(log::Level::Debug).unwrap();
+    console_error_panic_hook::set_once();
+    tracing_wasm::set_as_global_default();
+
     log::info!("hello computer, starting up...");
 
     let event_loop = winit::event_loop::EventLoop::new()
         .expect("failed to initialize event loop");
 
-    #[cfg(target_arch = "wasm32")]
     let (window, gl) = {
         let window = winit::window::WindowBuilder::new()
             .with_maximized(true)
@@ -163,63 +173,10 @@ where
         (window, gl)
     };
 
-    #[cfg(not(target_arch = "wasm32"))]
-    let (window, gl) = {
-        use glutin::config::GlConfig;
-        use glutin::context::NotCurrentGlContext;
-        use glutin::display::{GlDisplay, GetGlDisplay};
-        use glutin::surface::GlSurface;
-        use raw_window_handle::HasRawWindowHandle;
-        use glutin_winit::GlWindow;
-        let window_builder = winit::window::WindowBuilder::new()
-            .with_title("teleia")
-            .with_maximized(true)
-            .with_decorations(false);
-        let template = glutin::config::ConfigTemplateBuilder::new();
-        let display_builder = glutin_winit::DisplayBuilder::new().with_window_builder(Some(window_builder));
-        let (window, gl_config) = display_builder
-            .build(&event_loop, template, |configs| {
-                configs.reduce(|a, c| {
-                    if c.num_samples() > a.num_samples() { c } else { a }
-                }).expect("failed to obtain select configuration")
-            }).expect("failed to obtain opengl display");
-        let window = window.expect("failed to create window");
-        let raw_window_handle = window.raw_window_handle();
-        let gl_display = gl_config.display();
-        let context_attributes = glutin::context::ContextAttributesBuilder::new()
-            // .with_context_api(glutin::context::ContextApi::OpenGl(Some(glutin::context::Version {
-            //     major: 3,
-            //     minor: 3,
-            // })))
-            .build(Some(raw_window_handle));
-        unsafe {
-            let not_current_gl_context = gl_display.create_context(&gl_config, &context_attributes)
-                .expect("failed to obtain opengl context");
-            let attrs = window.build_surface_attributes(Default::default());
-            let gl_surface = gl_display.create_window_surface(&gl_config, &attrs)
-                .expect("failed to create opengl surface");
-            let gl_context = not_current_gl_context.make_current(&gl_surface)
-                .expect("failed to set openglt context");
-            let gl = glow::Context::from_loader_function_cstr(|s| gl_display.get_proc_address(s));
-            gl_surface
-                .set_swap_interval(&gl_context, glutin::surface::SwapInterval::Wait(std::num::NonZeroU32::new(1).unwrap()))
-                .expect("failed to set swap interval");
-            (window, gl)
-        }
-    };
-
     let ctx = Box::leak(Box::new(context::Context::new(window, gl)));
-
-    #[cfg(target_arch = "wasm32")]
-    {
-        ctx.maximize_canvas();
-    }
-
+    ctx.maximize_canvas();
     let game = Box::leak(Box::new(gnew(ctx).await));
     let st = Box::leak(Box::new(state::State::new(&ctx)));
-    // request = Some(Box::new(async {
-    //     "foo".to_owned()
-    // }));
 
     unsafe {
         CTX = Some(ctx as _);
@@ -227,20 +184,84 @@ where
         G = Some(game as *mut G as *mut std::ffi::c_void);
     }
 
+    event_loop.set_control_flow(winit::event_loop::ControlFlow::Wait);
+    event_loop.spawn(|event, elwt| {
+        contextualize(|ctx, st, game: &mut G| {
+            match &event {
+                winit::event::Event::WindowEvent {
+                    event: wev,
+                    window_id,
+                    ..
+                } => match wev {
+                    winit::event::WindowEvent::CloseRequested
+                        if *window_id == ctx.window.id() => elwt.exit(),
+                    winit::event::WindowEvent::Resized{..} => {
+                        #[cfg(target_arch = "wasm32")]
+                        ctx.maximize_canvas();
+                        st.handle_resize(&ctx);
+                    },
+                    winit::event::WindowEvent::Focused(false) => {
+                        st.keys = state::Keys::new();
+                    },
+                    winit::event::WindowEvent::CursorMoved { position, ..} => {
+                        st.mouse_moved(&ctx, position.x as f32, position.y as f32, game);
+                    },
+                    winit::event::WindowEvent::MouseInput {
+                        state,
+                        ..
+                    } => match state {
+                        winit::event::ElementState::Pressed => {
+                            st.mouse_pressed(&ctx, game)
+                        },
+                        winit::event::ElementState::Released => {
+                            st.mouse_released(&ctx)
+                        },
+                    }
+                    winit::event::WindowEvent::KeyboardInput {
+                        event: winit::event::KeyEvent {
+                            physical_key: winit::keyboard::PhysicalKey::Code(key),
+                            state,
+                            repeat: false,
+                            ..
+                        },
+                        ..
+                    } => match state {
+                        winit::event::ElementState::Pressed => {
+                            st.key_pressed(&ctx, *key)
+                        },
+                        winit::event::ElementState::Released => {
+                            st.key_released(&ctx, *key)
+                        },
+                    }
+                    _ => {},
+                },
+                
+                winit::event::Event::AboutToWait => {
+                    if ctx.resize_necessary() {
+                        #[cfg(target_arch = "wasm32")]
+                        ctx.maximize_canvas();
+                        st.handle_resize(&ctx);
+                    }
+                    if let Some(f) = &mut st.request {
+                        match std::future::Future::poll(f.as_mut(), &mut st.waker_ctx) {
+                            std::task::Poll::Pending => {},
+                            std::task::Poll::Ready(res) => {
+                                st.request = None;
+                                match res {
+                                    Ok(r) => st.request_returned(&ctx, game, r),
+                                    Err(e) => log::warn!("error during HTTP request: {}", e),
+                                }
+                            },
+                        }
+                        // f.poll();
+                    }
+                    st.run_update(&ctx, game);
+                    st.run_render(&ctx, game);
+                    ctx.window.request_redraw();
+                },
 
-    #[cfg(target_arch = "wasm32")]
-    {
-        event_loop.set_control_flow(winit::event_loop::ControlFlow::Wait);
-        event_loop.spawn(|event, elwt| {
-            event_loop_body::<G>(event, elwt);
+                _ => {},
+            }
         });
-    }
-
-    #[cfg(not(target_arch = "wasm32"))]
-    {
-        event_loop.set_control_flow(winit::event_loop::ControlFlow::Poll);
-        event_loop.run(|event, elwt| {
-            event_loop_body::<G>(event, elwt);
-        }).expect("window closed");
-    }
+    });
 }