gust-render 0.2.0

Gust is a simple 2D graphical library inspired by SFML.
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

//
//  Rust file | 2018
//  Author: Alexandre Fourcat
//  rect.rs
//  module:
//! Rectangle struct and all fonction

use nalgebra::Scalar;
use std::ops::{Add, Div, Mul, MulAssign, Sub};

/// Rect define a rectangle with down/left coord and width/height
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct Rect<T: Scalar> {
    pub top: T,
    pub left: T,
    pub width: T,
    pub height: T,
}

impl<T: Scalar + Add<Output = T>> Add<Rect<T>> for Rect<T> {
    type Output = Rect<T>;

    fn add(self, rhs: Rect<T>) -> Self::Output {
        Rect {
            top: self.top + rhs.top,
            left: self.left + rhs.left,
            height: self.width + rhs.width,
            width: self.height + rhs.height,
        }
    }
}

impl<T: Scalar + Div<Output = T>> Div<Rect<T>> for Rect<T> {
    type Output = Rect<T>;

    fn div(self, rhs: Rect<T>) -> Self::Output {
        Rect {
            top: self.top / rhs.top,
            left: self.left / rhs.left,
            height: self.width / rhs.width,
            width: self.height / rhs.height,
        }
    }
}

impl<T: Scalar + Sub<Output = T>> Sub<Rect<T>> for Rect<T> {
    type Output = Rect<T>;

    fn sub(self, rhs: Rect<T>) -> Self::Output {
        Rect {
            top: self.top - rhs.top,
            left: self.left - rhs.left,
            height: self.width - rhs.width,
            width: self.height - rhs.height,
        }
    }
}

impl<T: Scalar + Mul<Output = T>> Mul<Rect<T>> for Rect<T> {
    type Output = Rect<T>;

    fn mul(self, rhs: Rect<T>) -> Self::Output {
        Rect {
            top: self.top * rhs.top,
            left: self.left * rhs.left,
            height: self.width * rhs.width,
            width: self.height * rhs.height,
        }
    }
}

impl<T: Scalar + MulAssign<T>> MulAssign<Rect<T>> for Rect<T> {
    fn mul_assign(&mut self, rhs: Rect<T>) {
        self.left *= rhs.left;
        self.top *= rhs.top;
        self.width *= rhs.width;
        self.height *= rhs.height;
    }
}

//------------------
//
//              Rect impl
//
//------------------

impl<T> Rect<T>
where
    T: Scalar + Add<Output = T> + PartialOrd,
{
    pub fn new(left: T, top: T, width: T, height: T) -> Rect<T> {
        Rect {
            top,
            left,
            width,
            height,
        }
    }

    pub fn contain(&self, point: super::Point<T>) -> bool {
        point.x > self.left
            && point.x < self.left + self.width
            && point.y > self.top
            && point.y < self.top + self.height
    }
}

impl From<Rect<u32>> for Rect<f32> {
    fn from(this: Rect<u32>) -> Rect<f32> {
        Rect {
            top: this.top as f32,
            left: this.left as f32,
            width: this.width as f32,
            height: this.height as f32,
        }
    }
}

impl<T> Default for Rect<T>
where
    T: Default + Scalar,
{
    fn default() -> Rect<T> {
        Rect {
            top: T::default(),
            left: T::default(),
            width: T::default(),
            height: T::default(),
        }
    }
}