rust/hwrunner/src/main.rs
changeset 14704 12db7e435ea6
parent 14702 29dbe9ce8b7d
child 14705 19122a329774
equal deleted inserted replaced
14703:81030dcbd2d8 14704:12db7e435ea6
    11     GlRequest,
    11     GlRequest,
    12     GlProfile,
    12     GlProfile,
    13     ContextTrait,
    13     ContextTrait,
    14 };
    14 };
    15 
    15 
    16 use hedgewars_engine::instance::EngineInstance;
    16 use hedgewars_engine::{
       
    17     instance::EngineInstance,
       
    18 };
       
    19 
       
    20 use integral_geometry::Point;
    17 
    21 
    18 fn init(event_loop: &EventsLoop, size: dpi::LogicalSize) -> WindowedContext {
    22 fn init(event_loop: &EventsLoop, size: dpi::LogicalSize) -> WindowedContext {
    19     use glutin::{
    23     use glutin::{
    20         ContextBuilder,
    24         ContextBuilder,
    21         WindowBuilder
    25         WindowBuilder
    49     let (w, h) = (1024.0, 768.0);
    53     let (w, h) = (1024.0, 768.0);
    50     let window = init(&event_loop, dpi::LogicalSize::new(w, h));
    54     let window = init(&event_loop, dpi::LogicalSize::new(w, h));
    51 
    55 
    52     let mut engine = EngineInstance::new();
    56     let mut engine = EngineInstance::new();
    53 
    57 
    54     // dirty dirty code follows; DO NOT USE
       
    55     let mut zoom = 1f32;
       
    56     let mut dragging = false;
    58     let mut dragging = false;
    57     let mut x = 0f32;
       
    58     let mut y = 0f32;
       
    59 
    59 
    60     use std::time::Instant;
    60     use std::time::Instant;
    61 
    61 
    62     let mut now = Instant::now();
    62     let mut now = Instant::now();
    63     
    63     
    83                                 dragging = false;
    83                                 dragging = false;
    84                             }
    84                             }
    85                         }
    85                         }
    86                     }
    86                     }
    87                     WindowEvent::MouseWheel { delta, .. } => {
    87                     WindowEvent::MouseWheel { delta, .. } => {
    88                         match delta {
    88                         let zoom_change = match delta {
    89                             MouseScrollDelta::LineDelta(x, y) => {
    89                             MouseScrollDelta::LineDelta(x, y) => {
    90                                 zoom += y as f32 * 0.1f32;
    90                                 y as f32 * 0.1f32
    91                             }
    91                             }
    92                             MouseScrollDelta::PixelDelta(delta) => {
    92                             MouseScrollDelta::PixelDelta(delta) => {
    93                                 let physical = delta.to_physical(window.get_hidpi_factor());
    93                                 let physical = delta.to_physical(window.get_hidpi_factor());
    94                                 zoom += physical.y as f32 * 0.1f32;
    94                                 physical.y as f32 * 0.1f32
    95                             }
    95                             }
    96                         }
    96                         };
       
    97                         engine.world.move_camera(Point::ZERO, zoom_change);
    97                     }
    98                     }
    98                     _ => ()
    99                     _ => ()
    99                 },
   100                 },
   100                 Event::DeviceEvent { event, .. } => match event {
   101                 Event::DeviceEvent { event, .. } => match event {
   101                     DeviceEvent::MouseMotion { delta } => {
   102                     DeviceEvent::MouseMotion { delta } => {
   102                         if dragging {
   103                         if dragging {
   103                             x -= delta.0 as f32;
   104                             engine.world.move_camera(
   104                             y -= delta.1 as f32;
   105                                 Point::new(delta.0 as i32, delta.1 as i32), 0.0
       
   106                             )
   105                         }
   107                         }
   106                     }
   108                     }
   107                     _ => {}
   109                     _ => {}
   108                 }
   110                 }
   109                 _ => ()
   111                 _ => ()
   110             }
   112             }
   111         });
   113         });
   112 
   114 
   113         unsafe { window.make_current().unwrap() };
   115         unsafe { window.make_current().unwrap() };
   114 
   116 
   115         // temporary params.. dont actually handle input here
   117         engine.render();
   116         engine.render(x, y, w as f32 * zoom, h as f32 * zoom);
       
   117 
   118 
   118         window.swap_buffers().unwrap();
   119         window.swap_buffers().unwrap();
   119     }
   120     }
   120 }
   121 }