glamour 0.18.0

Strongly typed linear algebra with glam
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
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184

use glamour::prelude::*;

#[test]
fn vec_macros() {
    let a: Vector2<f32> = vec2!(1.0, 2.0);
    let b: Vector2<f32> = vec2![1.0, 2.0];
    let c: Vector2<f32> = vec2!(2.0);
    assert_eq!(a.x, 1.0);
    assert_eq!(a.y, 2.0);
    assert_eq!(b.x, 1.0);
    assert_eq!(b.y, 2.0);
    assert_eq!(c.x, 2.0);
    assert_eq!(c.y, 2.0);

    let a: Vector3<f32> = vec3!(1.0, 2.0, 3.0);
    let b: Vector3<f32> = vec3![1.0, 2.0, 3.0];
    let c: Vector3<f32> = vec3!(2.0);
    assert_eq!(a.x, 1.0);
    assert_eq!(a.y, 2.0);
    assert_eq!(a.z, 3.0);
    assert_eq!(b.x, 1.0);
    assert_eq!(b.y, 2.0);
    assert_eq!(b.z, 3.0);
    assert_eq!(c.x, 2.0);
    assert_eq!(c.y, 2.0);
    assert_eq!(c.z, 2.0);

    let a: Vector4<f32> = vec4!(1.0, 2.0, 3.0, 4.0);
    let b: Vector4<f32> = vec4![1.0, 2.0, 3.0, 4.0];
    let c: Vector4<f32> = vec4!(2.0);
    assert_eq!(a.x, 1.0);
    assert_eq!(a.y, 2.0);
    assert_eq!(a.z, 3.0);
    assert_eq!(a.w, 4.0);
    assert_eq!(b.x, 1.0);
    assert_eq!(b.y, 2.0);
    assert_eq!(b.z, 3.0);
    assert_eq!(b.w, 4.0);
    assert_eq!(c.x, 2.0);
    assert_eq!(c.y, 2.0);
    assert_eq!(c.z, 2.0);
    assert_eq!(c.w, 2.0);

    let a: Vector2<f32> = vector!(1.0, 2.0);
    let b: Vector3<f32> = vector!(1.0, 2.0, 3.0);
    let c: Vector4<f32> = vector!(1.0, 2.0, 3.0, 4.0);
    assert_eq!(a.x, 1.0);
    assert_eq!(a.y, 2.0);
    assert_eq!(b.x, 1.0);
    assert_eq!(b.y, 2.0);
    assert_eq!(b.z, 3.0);
    assert_eq!(c.x, 1.0);
    assert_eq!(c.y, 2.0);
    assert_eq!(c.z, 3.0);
    assert_eq!(c.w, 4.0);

    let a: Vector2<f32> = vector!([2.0; 2]);
    let b: Vector3<f32> = vector!([3.0; 3]);
    let c: Vector4<f32> = vector!([4.0; 4]);
    assert_eq!(a.x, 2.0);
    assert_eq!(a.y, 2.0);
    assert_eq!(b.x, 3.0);
    assert_eq!(b.y, 3.0);
    assert_eq!(b.z, 3.0);
    assert_eq!(c.x, 4.0);
    assert_eq!(c.y, 4.0);
    assert_eq!(c.z, 4.0);
    assert_eq!(c.w, 4.0);
}

#[test]
fn point_macros() {
    let a: Point2<f32> = point2!(1.0, 2.0);
    let b: Point2<f32> = point2![1.0, 2.0];
    let c: Point2<f32> = point2!(2.0);
    assert_eq!(a.x, 1.0);
    assert_eq!(a.y, 2.0);
    assert_eq!(b.x, 1.0);
    assert_eq!(b.y, 2.0);
    assert_eq!(c.x, 2.0);
    assert_eq!(c.y, 2.0);

    let a: Point3<f32> = point3!(1.0, 2.0, 3.0);
    let b: Point3<f32> = point3![1.0, 2.0, 3.0];
    let c: Point3<f32> = point3!(2.0);
    assert_eq!(a.x, 1.0);
    assert_eq!(a.y, 2.0);
    assert_eq!(a.z, 3.0);
    assert_eq!(b.x, 1.0);
    assert_eq!(b.y, 2.0);
    assert_eq!(b.z, 3.0);
    assert_eq!(c.x, 2.0);
    assert_eq!(c.y, 2.0);
    assert_eq!(c.z, 2.0);

    let a: Point4<f32> = point4!(1.0, 2.0, 3.0, 4.0);
    let b: Point4<f32> = point4![1.0, 2.0, 3.0, 4.0];
    let c: Point4<f32> = point4!(2.0);
    assert_eq!(a.x, 1.0);
    assert_eq!(a.y, 2.0);
    assert_eq!(a.z, 3.0);
    assert_eq!(a.w, 4.0);
    assert_eq!(b.x, 1.0);
    assert_eq!(b.y, 2.0);
    assert_eq!(b.z, 3.0);
    assert_eq!(b.w, 4.0);
    assert_eq!(c.x, 2.0);
    assert_eq!(c.y, 2.0);
    assert_eq!(c.z, 2.0);
    assert_eq!(c.w, 2.0);

    let a: Point2<f32> = point!(1.0, 2.0);
    let b: Point3<f32> = point!(1.0, 2.0, 3.0);
    let c: Point4<f32> = point!(1.0, 2.0, 3.0, 4.0);
    assert_eq!(a.x, 1.0);
    assert_eq!(a.y, 2.0);
    assert_eq!(b.x, 1.0);
    assert_eq!(b.y, 2.0);
    assert_eq!(b.z, 3.0);
    assert_eq!(c.x, 1.0);
    assert_eq!(c.y, 2.0);
    assert_eq!(c.z, 3.0);
    assert_eq!(c.w, 4.0);

    let a: Point2<f32> = point!([2.0; 2]);
    let b: Point3<f32> = point!([3.0; 3]);
    let c: Point4<f32> = point!([4.0; 4]);
    assert_eq!(a.x, 2.0);
    assert_eq!(a.y, 2.0);
    assert_eq!(b.x, 3.0);
    assert_eq!(b.y, 3.0);
    assert_eq!(b.z, 3.0);
    assert_eq!(c.x, 4.0);
    assert_eq!(c.y, 4.0);
    assert_eq!(c.z, 4.0);
    assert_eq!(c.w, 4.0);
}

#[test]
fn size_macros() {
    let a: Size2<f32> = size2!(1.0, 2.0);
    let b: Size2<f32> = size2![1.0, 2.0];
    let c: Size2<f32> = size2!(2.0);
    assert_eq!(a.width, 1.0);
    assert_eq!(a.height, 2.0);
    assert_eq!(b.width, 1.0);
    assert_eq!(b.height, 2.0);
    assert_eq!(c.width, 2.0);
    assert_eq!(c.height, 2.0);

    let a: Size3<f32> = size3!(1.0, 2.0, 3.0);
    let b: Size3<f32> = size3![1.0, 2.0, 3.0];
    let c: Size3<f32> = size3!(2.0);
    assert_eq!(a.width, 1.0);
    assert_eq!(a.height, 2.0);
    assert_eq!(a.depth, 3.0);
    assert_eq!(b.width, 1.0);
    assert_eq!(b.height, 2.0);
    assert_eq!(b.depth, 3.0);
    assert_eq!(c.width, 2.0);
    assert_eq!(c.height, 2.0);
    assert_eq!(c.depth, 2.0);

    let a: Size2<f32> = size!(1.0, 2.0);
    let b: Size3<f32> = size!(1.0, 2.0, 3.0);
    assert_eq!(a.width, 1.0);
    assert_eq!(a.height, 2.0);
    assert_eq!(b.width, 1.0);
    assert_eq!(b.height, 2.0);
    assert_eq!(b.depth, 3.0);

    let a: Size2<f32> = size!([2.0; 2]);
    let b: Size3<f32> = size!([3.0; 3]);
    assert_eq!(a.width, 2.0);
    assert_eq!(a.height, 2.0);
    assert_eq!(b.width, 3.0);
    assert_eq!(b.height, 3.0);
    assert_eq!(b.depth, 3.0);
}

// Verify that the macros can be used in a const context.
const _CONST_TEST_VEC: Vector4<f32> = vector!(1.0, 2.0, 3.0, 4.0);
const _CONST_TEST_POINT: Point4<f32> = point!(1.0, 2.0, 3.0, 4.0);
const _CONST_TEST_SIZE: Size3<f32> = size!(1.0, 2.0, 3.0);