orbclient 0.3.5

The Orbital Client Library
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

use collections::Vec;

/// point type (is the point a new position or a connection point)
pub enum PointType {
    Move,
    Connect,
    None,
}

/// graphic path with similar functions like html canvas
pub struct GraphicsPath {
    x: i32,
    y: i32,
    pub points: Vec<(i32, i32, PointType)>,
}

impl GraphicsPath {

    pub fn new() -> GraphicsPath {
        GraphicsPath {
            x : 0,
            y : 0,
            points: Vec::new(),
        }
    }

    /// move to position
    pub fn move_to(&mut self, x: i32, y: i32){
        self.points.push((x,y,PointType::Move));
        self.x = x;
        self.y = y;
    }

    /// create a line between the last and new point
    pub fn line_to(&mut self, x: i32, y: i32) {
        self.points.push((x,y,PointType::Connect));
        self.x = x;
        self.y = y;
    }

    /// quadratic bezier curve
    pub fn quadratic_curve_to(&mut self, argx1: i32, argy1: i32, argx2: i32, argy2: i32){
        let mut t:f32 = 0.0;
        let mut u:f32;
        let mut tt:f32;
        let mut uu:f32;
        let mut x:f32;
        let mut y:f32;

        while t < 1.0 {
            u = 1.0 - t;
            uu = u * u;
            tt = t * t;

            x = (self.x as f32) * uu;
            y = (self.y as f32) * uu;

            x +=  2.0 * u * t * (argx1 as f32);
            y +=  2.0 * u * t * (argy1 as f32);

            x += tt * (argx2 as f32);
            y += tt * (argy2 as f32);

            t = t+0.01;
            self.points.push((x as i32, y as i32, PointType::Connect));
        }

        self.x = argx2;
        self.y = argy2;
    }

    /// cubic bezier curve
    pub fn bezier_curve_to(&mut self, argx1: i32, argy1: i32, argx2: i32, argy2: i32, argx3: i32, argy3: i32){
        let mut t:f32 = 0.0;
        let mut u:f32;
        let mut tt:f32;
        let mut uu:f32;
        let mut uuu:f32;
        let mut ttt:f32;
        let mut x:f32;
        let mut y:f32;

        while t < 1.0 {
            u = 1.0 - t;
            tt = t * t;
            uu = u * u;
            uuu = uu * u;
            ttt = tt * t;

            x = (self.x as f32) * uuu;
            y = (self.y as f32) * uuu;

            x += 3.0 * uu * t * (argx1 as f32);
            y += 3.0 * uu * t * (argy1 as f32);

            x += 3.0 * u * tt * (argx2 as f32);
            y += 3.0 * u * tt * (argy2 as f32);

            x += ttt * (argx3 as f32);
            y += ttt * (argy3 as f32);

            t = t+0.01;
            self.points.push((x as i32, y as i32, PointType::Connect));
        }

        self.x = argx3;
        self.y = argy3;
    }
}