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

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