collisions 0.1.3

2d collision detection.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167

extern crate nalgebra;

use nalgebra::{Vector1, Vector2, Rotation2, Rotate};

use std::f32::consts;

use util::{calc_normx, calc_normy};

#[derive(Copy, Clone, Debug)]
pub enum CollidableShape
{
    Circle,
    Polygon,
}

#[derive(Clone, Debug)]
pub struct Collidable
{
	pub collidable_type: u8,
    pub collidable_shape: CollidableShape,
	pub collidable_id: usize,

	// CIRCLE
	pub centrex: f32,
	pub centrey: f32,
	pub radius: f32,

	// POLYGON
	pub nvert: usize,
	pub vertx: Vec<f32>,
	pub verty: Vec<f32>,
	pub normx: Vec<f32>,
	pub normy: Vec<f32>,
}

impl Collidable
{
	pub fn new_circle(t: u8, i: usize, cx: f32, cy: f32, r: f32) -> Collidable
	{
		Collidable
		{
			collidable_type: t,
            collidable_shape: CollidableShape::Circle,
			collidable_id: i,

			centrex: cx,
			centrey: cy,
			radius: r,

			nvert: 0,
			vertx: vec![],
			verty: vec![],
			normx: vec![],
			normy: vec![],
		}
	}

    pub fn new_arc(t: u8, id: usize, cx: f32, cy: f32, r: f32, dirx: f32, diry: f32, rad: f32) -> Collidable
    {
        let centre = Vector2::new(cx, cy);

        let minor_arc = 2.*consts::PI/16.;
        let nvert = (rad / minor_arc).floor() as usize + 2;

        let mut vertx = Vec::with_capacity(nvert);
        let mut verty = Vec::with_capacity(nvert);

        vertx.push(centre.x);
        verty.push(centre.y);

        let mut dir = Rotation2::new(Vector1::new(-rad/2.)).rotate(&nalgebra::normalize(&Vector2::new(dirx, diry))) * r;
        let mut p = centre + dir;

        for _ in 0..nvert-2
        {
            vertx.push(p.x);
            verty.push(p.y);
            dir = Rotation2::new(Vector1::new(minor_arc)).rotate(&dir);
            p = centre + dir;
        }
        dir = Rotation2::new(Vector1::new(rad/2.)).rotate(&nalgebra::normalize(&Vector2::new(dirx, diry))) * r;
        p = centre + dir;
        vertx.push(p.x);
        verty.push(p.y);

        let normx = calc_normx(nvert, &verty);
        let normy = calc_normy(nvert, &vertx);

        Collidable
        {
            collidable_type: t,
            collidable_shape: CollidableShape::Polygon,
            collidable_id: id,

            centrex: cx,
            centrey: cy,
            radius: r,

            nvert: nvert,
            vertx: vertx,
            verty: verty,
            normx: normx,
            normy: normy,
        }
    }

	pub fn new_poly(t: u8, i: usize, nvert: usize, vertx: Vec<f32>, verty: Vec<f32>) -> Collidable
	{
		let normx = calc_normx(nvert, &verty);
		let normy = calc_normy(nvert, &vertx);
		Collidable
		{
			collidable_type: t,
            collidable_shape: CollidableShape::Polygon,
			collidable_id: i,

			centrex: 0.,
			centrey: 0.,
			radius: 0.,

			nvert: nvert,
			vertx: vertx,
			verty: verty,
			normx: normx,
			normy: normy,
		}
	}

	pub fn new_square(t: u8, i: usize, x: f32, y: f32, w: f32, h: f32) -> Collidable
	{
		let nvert: usize = 4;
	    let mut vertx = Vec::with_capacity(nvert);
	    vertx.push(x);
	    vertx.push(x + w);
	    vertx.push(x + w);
	    vertx.push(x);
		let mut verty = Vec::with_capacity(nvert);
		verty.push(y);
		verty.push(y);
		verty.push(y + h);
		verty.push(y + h);
		let normx = calc_normx(nvert, &verty);
		let normy = calc_normy(nvert, &vertx);
		Collidable
		{
			collidable_type: t,
            collidable_shape: CollidableShape::Polygon,
			collidable_id: i,

			centrex: 0.,
			centrey: 0.,
			radius: 0.,

			nvert: nvert,
			vertx: vertx,
			verty: verty,
			normx: normx,
			normy: normy,
		}
	}

	pub fn update_normals(&mut self)
	{
		self.normx = calc_normx(self.nvert, &self.verty);
		self.normy = calc_normy(self.nvert, &self.vertx);
	}
}