dpi,

    DeviceEvent,

    ElementState,

    MouseButton,

    MouseScrollDelta,

    WindowedContext,

    GlRequest,

    GlProfile,

    ContextTrait,

fn init(event_loop: &EventsLoop, size: dpi::LogicalSize) -> WindowedContext {

    let cxt = ContextBuilder::new()

        .with_gl(GlRequest::Latest)

        .with_gl_profile(GlProfile::Core)

        .build_windowed(window, &event_loop).ok().unwrap();

    unsafe {

        cxt.make_current().unwrap();

        gl::load_with(|ptr| cxt.get_proc_address(ptr) as *const _);

        if let Some(sz) = cxt.get_inner_size() {

            let phys = sz.to_physical(cxt.get_hidpi_factor());

            gl::Viewport(0, 0, phys.width as i32, phys.height as i32);

        }

    }

    cxt

    let (w, h) = (1024.0, 768.0);

    let window = init(&event_loop, dpi::LogicalSize::new(w, h));

    let mut engine = EngineInstance::new();

    // dirty dirty code follows; DO NOT USE

    let mut zoom = 1f32;

    let mut dragging = false;

    let mut x = 0f32;

    let mut y = 0f32;

    use std::time::Instant;

    let mut now = Instant::now();

        let curr = Instant::now();

        let delta = curr - now;

        now = curr;

        let ms = delta.as_secs() as f64 * 1000.0 + delta.subsec_millis() as f64;

        window.set_title(&format!("hwengine {:.3}ms", ms));

                    WindowEvent::MouseInput { button, state, .. } => {

                        if let MouseButton::Right = button {

                            if let ElementState::Pressed = state {

                                dragging = true;

                            } else {

                                dragging = false;

                            }

                        }

                    }

                    WindowEvent::MouseWheel { delta, .. } => {

                        match delta {

                            MouseScrollDelta::LineDelta(x, y) => {

                                zoom += y as f32 * 0.1f32;

                            }

                            MouseScrollDelta::PixelDelta(delta) => {

                                let physical = delta.to_physical(window.get_hidpi_factor());

                                zoom += physical.y as f32 * 0.1f32;

                            }

                        }

                    }

                Event::DeviceEvent { event, .. } => match event {

                    DeviceEvent::MouseMotion { delta } => {

                        if dragging {

                            x -= delta.0 as f32;

                            y -= delta.1 as f32;

                        }

                    }

                    _ => {}

                }

        unsafe { window.make_current().unwrap() };

        // temporary params.. dont actually handle input here

        engine.render(x, y, w as f32 * zoom, h as f32 * zoom);