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
use draw;
use draw::properties::spatial::{dimension, orientation, position};
use draw::properties::{
spatial, ColorScalar, Draw, Drawn, IntoDrawn, Primitive, Rgba, SetColor, SetDimensions,
SetOrientation, SetPosition,
};
use geom::{self, Point2, Vector2};
use math::BaseFloat;
use std::{iter, slice};
#[derive(Clone, Debug)]
pub struct Rect<S = geom::scalar::Default> {
spatial: spatial::Properties<S>,
color: Option<Rgba>,
}
impl<S> IntoDrawn<S> for Rect<S>
where
S: BaseFloat,
{
type Vertices = draw::mesh::vertex::IterFromPoint2s<geom::quad::Vertices<Point2<S>>, S>;
type Indices = iter::Cloned<slice::Iter<'static, usize>>;
fn into_drawn(self, draw: Draw<S>) -> Drawn<S, Self::Vertices, Self::Indices> {
let Rect { spatial, color } = self;
let (maybe_x, maybe_y, maybe_z) = spatial.dimensions.to_scalars(&draw);
assert!(
maybe_z.is_none(),
"z dimension support for rect is unimplemented"
);
let default_w = || S::from(100.0).unwrap();
let default_h = || S::from(100.0).unwrap();
let w = maybe_x.unwrap_or_else(default_w);
let h = maybe_y.unwrap_or_else(default_h);
let rect = geom::Rect::from_wh(Vector2 { x: w, y: h });
let color = color
.or_else(|| {
draw.theme(|theme| {
theme
.color
.primitive
.get(&draw::theme::Primitive::Rect)
.map(|&c| c)
})
})
.unwrap_or(draw.theme(|t| t.color.default));
let points = rect.corners().vertices();
let vertices = draw::mesh::vertex::IterFromPoint2s::new(points, color);
let indices = geom::quad::TRIANGLE_INDICES.iter().cloned();
(spatial, vertices, indices)
}
}
impl<S> From<geom::Rect<S>> for Rect<S>
where
S: BaseFloat,
{
fn from(r: geom::Rect<S>) -> Self {
let spatial = <_>::default();
let color = <_>::default();
let (x, y, w, h) = r.x_y_w_h();
Rect { spatial, color }.x_y(x, y).w_h(w, h)
}
}
impl<S> Default for Rect<S>
where
S: BaseFloat,
{
fn default() -> Self {
let spatial = <_>::default();
let color = <_>::default();
Rect { spatial, color }
}
}
impl<S> SetOrientation<S> for Rect<S> {
fn properties(&mut self) -> &mut orientation::Properties<S> {
SetOrientation::properties(&mut self.spatial)
}
}
impl<S> SetPosition<S> for Rect<S> {
fn properties(&mut self) -> &mut position::Properties<S> {
SetPosition::properties(&mut self.spatial)
}
}
impl<S> SetDimensions<S> for Rect<S> {
fn properties(&mut self) -> &mut dimension::Properties<S> {
SetDimensions::properties(&mut self.spatial)
}
}
impl<S> SetColor<ColorScalar> for Rect<S> {
fn rgba_mut(&mut self) -> &mut Option<Rgba> {
SetColor::rgba_mut(&mut self.color)
}
}
impl<S> From<Rect<S>> for Primitive<S> {
fn from(prim: Rect<S>) -> Self {
Primitive::Rect(prim)
}
}
impl<S> Into<Option<Rect<S>>> for Primitive<S> {
fn into(self) -> Option<Rect<S>> {
match self {
Primitive::Rect(prim) => Some(prim),
_ => None,
}
}
}