glsl_layout/vec.rs
1use crate::align::{Align16, Align32, Align8};
2use crate::array::MapArray;
3use crate::scalar::{boolean, double, float, int, uint};
4use crate::uniform::{Std140, Uniform};
5
6macro_rules! implement_vec {
7 ($vec:ident => [$type:ty; $size:tt]: $align:tt) => {
8 impl<T> From<[T; $size]> for $vec
9 where
10 T: Into<$type>,
11 {
12 fn from(values: [T; $size]) -> Self {
13 $vec(MapArray::map_array(values, T::into))
14 }
15 }
16
17 impl AsRef<[$type; $size]> for $vec {
18 fn as_ref(&self) -> &[$type; $size] {
19 &self.0
20 }
21 }
22
23 impl AsMut<[$type; $size]> for $vec {
24 fn as_mut(&mut self) -> &mut [$type; $size] {
25 &mut self.0
26 }
27 }
28
29 impl AsRef<[$type]> for $vec {
30 fn as_ref(&self) -> &[$type] {
31 &self.0
32 }
33 }
34
35 impl AsMut<[$type]> for $vec {
36 fn as_mut(&mut self) -> &mut [$type] {
37 &mut self.0
38 }
39 }
40
41 unsafe impl Std140 for $vec {}
42
43 impl Uniform for $vec {
44 type Align = $align;
45 type Std140 = $vec;
46
47 fn std140(&self) -> $vec {
48 *self
49 }
50 }
51 };
52}
53
54/// Vector of 2 `boolean` values.
55/// `foo: bvec2` is equivalent to glsl's `bvec2 foo;`
56///
57/// # Examples
58///
59/// ```rust
60/// # #[macro_use] extern crate glsl_layout;
61/// # use glsl_layout::{boolean, bvec2};
62/// # fn main() {
63/// let x: bvec2 = [boolean::from(true); 2].into();
64/// # }
65/// ```
66///
67#[derive(Clone, Copy, Debug, Default, PartialOrd, PartialEq, Ord, Eq, Hash)]
68pub struct bvec2([boolean; 2]);
69implement_vec!(bvec2 => [boolean; 2] : Align8);
70
71/// Vector of 3 `boolean` values.
72/// `foo: bvec3` is equivalent to glsl's `bvec3 foo;`
73///
74/// # Examples
75///
76/// ```rust
77/// # #[macro_use] extern crate glsl_layout;
78/// # use glsl_layout::{boolean, bvec3};
79/// # fn main() {
80/// let x: bvec3 = [boolean::from(true); 3].into();
81/// # }
82/// ```
83///
84#[derive(Clone, Copy, Debug, Default, PartialOrd, PartialEq, Ord, Eq, Hash)]
85pub struct bvec3([boolean; 3]);
86implement_vec!(bvec3 => [boolean; 3] : Align16);
87
88/// Vector of 4 `boolean` values.
89/// `foo: bvec4` is equivalent to glsl's `bvec4 foo;`
90///
91/// # Examples
92///
93/// ```rust
94/// # #[macro_use] extern crate glsl_layout;
95/// # use glsl_layout::{boolean, bvec4};
96/// # fn main() {
97/// let x: bvec4 = [boolean::from(true); 4].into();
98/// # }
99/// ```
100///
101#[derive(Clone, Copy, Debug, Default, PartialOrd, PartialEq, Ord, Eq, Hash)]
102pub struct bvec4([boolean; 4]);
103implement_vec!(bvec4 => [boolean; 4] : Align16);
104
105/// Vector of 2 `int` values.
106/// `foo: ivec2` is equivalent to glsl's `ivec2 foo;`
107///
108/// # Examples
109///
110/// ```rust
111/// # #[macro_use] extern crate glsl_layout;
112/// # use glsl_layout::ivec2;
113/// # fn main() {
114/// let x: ivec2 = [1i32; 2].into();
115/// # }
116/// ```
117///
118#[derive(Clone, Copy, Debug, Default, PartialOrd, PartialEq, Ord, Eq, Hash)]
119pub struct ivec2([int; 2]);
120implement_vec!(ivec2 => [int; 2] : Align8);
121
122/// Vector of 3 `int` values.
123/// `foo: ivec3` is equivalent to glsl's `ivec3 foo;`
124///
125/// # Examples
126///
127/// ```rust
128/// # #[macro_use] extern crate glsl_layout;
129/// # use glsl_layout::ivec3;
130/// # fn main() {
131/// let x: ivec3 = [1i32; 3].into();
132/// # }
133/// ```
134///
135#[derive(Clone, Copy, Debug, Default, PartialOrd, PartialEq, Ord, Eq, Hash)]
136pub struct ivec3([int; 3]);
137implement_vec!(ivec3 => [int; 3] : Align16);
138
139/// Vector of 4 `int` values.
140/// `foo: ivec4` is equivalent to glsl's `ivec4 foo;`
141///
142/// # Examples
143///
144/// ```rust
145/// # #[macro_use] extern crate glsl_layout;
146/// # use glsl_layout::ivec4;
147/// # fn main() {
148/// let x: ivec4 = [1i32; 4].into();
149/// # }
150/// ```
151///
152#[derive(Clone, Copy, Debug, Default, PartialOrd, PartialEq, Ord, Eq, Hash)]
153pub struct ivec4([int; 4]);
154implement_vec!(ivec4 => [int; 4] : Align16);
155
156/// Vector of 2 `uint` values.
157/// `foo: uvec2` is equivalent to glsl's `uvec2 foo;`
158///
159/// # Examples
160///
161/// ```rust
162/// # #[macro_use] extern crate glsl_layout;
163/// # use glsl_layout::uvec2;
164/// # fn main() {
165/// let x: uvec2 = [1u32; 2].into();
166/// # }
167/// ```
168///
169#[derive(Clone, Copy, Debug, Default, PartialOrd, PartialEq, Ord, Eq, Hash)]
170pub struct uvec2([uint; 2]);
171implement_vec!(uvec2 => [uint; 2] : Align8);
172
173/// Vector of 3 `uint` values.
174/// `foo: uvec3` is equivalent to glsl's `uvec3 foo;`
175///
176/// # Examples
177///
178/// ```rust
179/// # #[macro_use] extern crate glsl_layout;
180/// # use glsl_layout::uvec3;
181/// # fn main() {
182/// let x: uvec3 = [1u32; 3].into();
183/// # }
184/// ```
185///
186#[derive(Clone, Copy, Debug, Default, PartialOrd, PartialEq, Ord, Eq, Hash)]
187pub struct uvec3([uint; 3]);
188implement_vec!(uvec3 => [uint; 3] : Align16);
189
190/// Vector of 4 `uint` values.
191/// `foo: uvec4` is equivalent to glsl's `uvec4 foo;`
192///
193/// # Examples
194///
195/// ```rust
196/// # #[macro_use] extern crate glsl_layout;
197/// # use glsl_layout::uvec4;
198/// # fn main() {
199/// let x: uvec4 = [1u32; 4].into();
200/// # }
201/// ```
202///
203#[derive(Clone, Copy, Debug, Default, PartialOrd, PartialEq, Ord, Eq, Hash)]
204pub struct uvec4([uint; 4]);
205implement_vec!(uvec4 => [uint; 4] : Align16);
206
207/// Vector of 2 `float` values.
208/// `foo: vec2` is equivalent to glsl's `vec2 foo;`
209///
210/// # Examples
211///
212/// ```rust
213/// # #[macro_use] extern crate glsl_layout;
214/// # use glsl_layout::vec2;
215/// # fn main() {
216/// let x: vec2 = [1f32; 2].into();
217/// # }
218/// ```
219///
220#[derive(Clone, Copy, Debug, Default, PartialOrd, PartialEq)]
221pub struct vec2([float; 2]);
222implement_vec!(vec2 => [float; 2] : Align8);
223
224/// Vector of 3 `float` values.
225/// `foo: vec3` is equivalent to glsl's `vec3 foo;`
226///
227/// # Examples
228///
229/// ```rust
230/// # #[macro_use] extern crate glsl_layout;
231/// # use glsl_layout::vec3;
232/// # fn main() {
233/// let x: vec3 = [1f32; 3].into();
234/// # }
235/// ```
236///
237#[derive(Clone, Copy, Debug, Default, PartialOrd, PartialEq)]
238pub struct vec3([float; 3]);
239implement_vec!(vec3 => [float; 3] : Align16);
240
241/// Vector of 4 `float` values.
242/// `foo: vec4` is equivalent to glsl's `vec4 foo;`
243///
244/// # Examples
245///
246/// ```rust
247/// # #[macro_use] extern crate glsl_layout;
248/// # use glsl_layout::vec4;
249/// # fn main() {
250/// let x: vec4 = [1f32; 4].into();
251/// # }
252/// ```
253///
254#[derive(Clone, Copy, Debug, Default, PartialOrd, PartialEq)]
255pub struct vec4([float; 4]);
256implement_vec!(vec4 => [float; 4] : Align16);
257
258/// Vector of 2 `double` value.
259/// `foo: dvec2` is equivalent to glsl's `dvec2 foo;`
260///
261/// # Examples
262///
263/// ```rust
264/// # #[macro_use] extern crate glsl_layout;
265/// # use glsl_layout::dvec2;
266/// # fn main() {
267/// let x: dvec2 = [1f32; 2].into();
268/// # }
269/// ```
270///
271#[derive(Clone, Copy, Debug, Default, PartialOrd, PartialEq)]
272pub struct dvec2([double; 2]);
273implement_vec!(dvec2 => [double; 2] : Align16);
274
275/// Vector of 3 `double` value.
276/// `foo: dvec3` is equivalent to glsl's `dvec3 foo;`
277///
278/// # Examples
279///
280/// ```rust
281/// # #[macro_use] extern crate glsl_layout;
282/// # use glsl_layout::dvec3;
283/// # fn main() {
284/// let x: dvec3 = [1f32; 3].into();
285/// # }
286/// ```
287///
288#[derive(Clone, Copy, Debug, Default, PartialOrd, PartialEq)]
289pub struct dvec3([double; 3]);
290implement_vec!(dvec3 => [double; 3] : Align32);
291
292/// Vector of 4 `double` value.
293/// `foo: dvec4` is equivalent to glsl's `dvec4 foo;`
294///
295/// # Examples
296///
297/// ```rust
298/// # #[macro_use] extern crate glsl_layout;
299/// # use glsl_layout::dvec4;
300/// # fn main() {
301/// let x: dvec4 = [1f32; 4].into();
302/// # }
303/// ```
304///
305#[derive(Clone, Copy, Debug, Default, PartialOrd, PartialEq)]
306pub struct dvec4([double; 4]);
307implement_vec!(dvec4 => [double; 4] : Align32);