very late init

src/bin/3-2-0-angular-motion.rs

@@ -0,0 +1,163 @@
+extern crate sdl2;
+
+use sdl2::pixels::Color;
+use sdl2::event::Event;
+use sdl2::keyboard::Keycode;
+use sdl2::rect::{Point, Rect};
+use sdl2::render::WindowCanvas;
+use std::time::Duration;
+
+
+struct PointG{
+    x: f64,
+    y: f64,
+    start_x: f64,
+    start_y: f64,
+    mx: f64,
+    my: f64,
+}
+impl PointG{
+    fn new(x: f64, y: f64) -> Self {
+        Self{
+            x: x,
+            y: y,
+            start_x: x,
+            start_y: y,
+            mx: 0.0,
+            my: 0.0,
+        }
+    }
+
+    fn set_angle(&mut self, angle: &f64){
+        let angle = angle % (3.14192 * 2.0);
+        let cos_theta = angle.cos();
+        let sin_theta = angle.sin();
+
+        let x = self.start_x * cos_theta - self.start_y * sin_theta;
+        let y = self.start_x * sin_theta + self.start_y * cos_theta;
+
+        self.x = x;
+        self.y = y;
+    }
+}
+
+struct ObjectG{
+    pos: PointG,
+    screen_size: PointG,
+    ang: f64,
+    a_vel: f64,
+    a_acc: f64,
+}
+
+impl ObjectG{
+    fn new(x: f64, y: f64, sw: f64, sh: f64) -> Self{
+        Self {
+            pos: PointG::new(x,y),
+            screen_size: PointG::new(sw,sh),
+            ang: 0.0,
+            a_vel: 0.0,
+            a_acc: 0.001,
+        }
+    }
+
+    fn update(&mut self){
+        let map = ((self.pos.mx / self.screen_size.x) - 0.5) / 0.5 / 10.0;
+        if self.a_vel > 0.2 { self.a_vel = 0.2 }
+        if self.a_vel < -0.2 { self.a_vel = -0.2 }
+        self.a_acc = map;
+        self.ang = self.ang + self.a_vel;
+        self.a_vel = self.a_vel + self.a_acc;
+
+        self.pos.set_angle(&self.ang);
+    }
+}
+
+fn draw_line(canvas: &mut WindowCanvas, obj_arr: &mut Vec<ObjectG>, a: &usize, b: &usize){
+    let pos = PointG::new(obj_arr[*a].pos.x + obj_arr[*a].screen_size.x / 2.0, obj_arr[*a].pos.y + obj_arr[*a].screen_size.y / 2.0);
+    let pos2 = PointG::new(obj_arr[*b].pos.x + obj_arr[*b].screen_size.x / 2.0, obj_arr[*b].pos.y + obj_arr[*b].screen_size.y / 2.0);
+    canvas.set_draw_color(Color::RGB(150,50,255));
+    canvas.draw_line(Point::new(pos.x as i32,pos.y as i32), Point::new(pos2.x as i32,pos2.y as i32)).err();
+}
+
+fn draw(canvas: &mut WindowCanvas, obj_arr: &mut Vec<ObjectG>){
+    canvas.set_draw_color(Color::RGBA(0,0,0,80));
+    canvas.fill_rect(Rect::new(0,0,800,800)).err();
+    canvas.clear();
+
+    draw_line(canvas, obj_arr, &0, &1);
+    draw_line(canvas, obj_arr, &1, &2);
+    draw_line(canvas, obj_arr, &2, &3);
+    draw_line(canvas, obj_arr, &3, &0);
+
+
+    for obj in obj_arr{
+        obj.update();
+    }
+
+
+    canvas.present();
+}
+
+
+
+fn main() {
+    let sdl2_context = sdl2::init().unwrap();
+    let video_subsystem = sdl2_context.video().unwrap();
+
+
+    let width: u32=400;
+    let height: u32=400;
+
+    let window = video_subsystem.window("angular-motion", width, height)
+        .position_centered()
+        .build()
+        .unwrap();
+
+    let mut canvas = window.into_canvas().build().unwrap();
+    canvas.default_pixel_format();
+    canvas.set_blend_mode(sdl2::render::BlendMode::Blend);
+
+    let mut obj_arr: Vec<ObjectG> = Vec::new();
+
+    let obj = ObjectG::new(128.0,64.0,width as f64, height as f64);
+    obj_arr.push(obj);
+
+    let obj = ObjectG::new(-128.0,64.0,width as f64, height as f64);
+    obj_arr.push(obj);
+
+    let obj = ObjectG::new(-128.0,-64.0,width as f64, height as f64);
+    obj_arr.push(obj);
+
+    let obj = ObjectG::new(128.0,-64.0,width as f64, height as f64);
+    obj_arr.push(obj);
+
+    canvas.set_draw_color(Color::RGB(0,0,0));
+    canvas.clear();
+
+    let mut event_pump = sdl2_context.event_pump().unwrap();
+    draw(&mut canvas, &mut obj_arr);
+    'running: loop {
+        draw(&mut canvas, &mut obj_arr);
+        let state = event_pump.mouse_state();
+        for obj in &mut obj_arr{
+            obj.pos.mx=state.x() as f64;
+            obj.pos.my=state.y() as f64;
+        }
+        //draw(&mut canvas, &mut obj, &state.x(), &state.y());
+        for event in event_pump.poll_iter() {
+            match event {
+                Event::Quit {..} |
+                Event::KeyDown { keycode: Some(Keycode::Escape), .. } => {
+                    break 'running
+                },
+                _ => {}
+            }
+        }
+
+        ::std::thread::sleep(Duration::new(0, 1_000_000_000u32 / 30));
+    }
+}
+
+// *~challenges
+// when you click you grab the rect and then rotate it
+// releasing it at a velocity will maintain its velocity