shadermath/math/
float4.rs

1use core::fmt;
2use core::ops;
3
4use super::Float2;
5use super::Float3;
6
7/// Vector containing 4 floating point values.
8#[derive(Copy, Clone, Debug)]
9pub struct Float4 {
10    /// The x-component of the vector.
11    pub x: f32,
12    /// The y-component of the vector.
13    pub y: f32,
14    /// The z-component of the vector.
15    pub z: f32,
16    /// The w-component of the vector.
17    pub w: f32,
18}
19
20impl fmt::Display for Float4 {
21    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
22        write!(f, "Float4 ({}, {}, {}, {})", self.x, self.y, self.z, self.w)
23    }
24}
25
26impl ops::Add<Self> for Float4 {
27    type Output = Self;
28
29    fn add(self, rhs: Self) -> Self {
30        Self {
31            x: self.x + rhs.x,
32            y: self.y + rhs.y,
33            z: self.z + rhs.z,
34            w: self.w + rhs.w,
35        }
36    }
37}
38
39impl ops::Add<f32> for Float4 {
40    type Output = Self;
41
42    fn add(self, rhs: f32) -> Self {
43        Self {
44            x: self.x + rhs,
45            y: self.y + rhs,
46            z: self.z + rhs,
47            w: self.w + rhs,
48        }
49    }
50}
51
52impl ops::AddAssign<Self> for Float4 {
53    fn add_assign(&mut self, rhs: Self) {
54        self.x += rhs.x;
55        self.y += rhs.y;
56        self.z += rhs.z;
57        self.w += rhs.w;
58    }
59}
60
61impl ops::AddAssign<f32> for Float4 {
62    fn add_assign(&mut self, rhs: f32) {
63        self.x += rhs;
64        self.y += rhs;
65        self.z += rhs;
66        self.w += rhs;
67    }
68}
69
70impl ops::Sub<Self> for Float4 {
71    type Output = Self;
72
73    fn sub(self, rhs: Self) -> Self {
74        Self {
75            x: self.x - rhs.x,
76            y: self.y - rhs.y,
77            z: self.z - rhs.z,
78            w: self.w - rhs.w,
79        }
80    }
81}
82
83impl ops::Sub<f32> for Float4 {
84    type Output = Self;
85
86    fn sub(self, rhs: f32) -> Self {
87        Self {
88            x: self.x - rhs,
89            y: self.y - rhs,
90            z: self.z - rhs,
91            w: self.w - rhs,
92        }
93    }
94}
95
96impl ops::SubAssign<Self> for Float4 {
97    fn sub_assign(&mut self, rhs: Self) {
98        self.x -= rhs.x;
99        self.y -= rhs.y;
100        self.z -= rhs.z;
101        self.w -= rhs.w;
102    }
103}
104
105impl ops::SubAssign<f32> for Float4 {
106    fn sub_assign(&mut self, rhs: f32) {
107        self.x -= rhs;
108        self.y -= rhs;
109        self.z -= rhs;
110        self.w -= rhs;
111    }
112}
113
114impl ops::Mul<Self> for Float4 {
115    type Output = Self;
116
117    fn mul(self, rhs: Self) -> Self {
118        Self {
119            x: self.x * rhs.x,
120            y: self.y * rhs.y,
121            z: self.z * rhs.z,
122            w: self.w * rhs.w,
123        }
124    }
125}
126
127impl ops::Mul<f32> for Float4 {
128    type Output = Self;
129
130    fn mul(self, rhs: f32) -> Self {
131        Self {
132            x: self.x * rhs,
133            y: self.y * rhs,
134            z: self.z * rhs,
135            w: self.w * rhs,
136        }
137    }
138}
139
140impl ops::MulAssign<Self> for Float4 {
141    fn mul_assign(&mut self, rhs: Self) {
142        self.x *= rhs.x;
143        self.y *= rhs.y;
144        self.z *= rhs.z;
145        self.w *= rhs.w;
146    }
147}
148
149impl ops::MulAssign<f32> for Float4 {
150    fn mul_assign(&mut self, rhs: f32) {
151        self.x *= rhs;
152        self.y *= rhs;
153        self.z *= rhs;
154        self.w *= rhs;
155    }
156}
157
158impl ops::Div<Self> for Float4 {
159    type Output = Self;
160
161    fn div(self, rhs: Self) -> Self {
162        Self {
163            x: self.x / rhs.x,
164            y: self.y / rhs.y,
165            z: self.z / rhs.z,
166            w: self.w / rhs.w,
167        }
168    }
169}
170
171impl ops::Div<f32> for Float4 {
172    type Output = Self;
173
174    fn div(self, rhs: f32) -> Self {
175        Self {
176            x: self.x / rhs,
177            y: self.y / rhs,
178            z: self.z / rhs,
179            w: self.w / rhs,
180        }
181    }
182}
183
184impl ops::DivAssign<Self> for Float4 {
185    fn div_assign(&mut self, rhs: Self) {
186        self.x /= rhs.x;
187        self.y /= rhs.y;
188        self.z /= rhs.z;
189        self.w /= rhs.w;
190    }
191}
192
193impl ops::DivAssign<f32> for Float4 {
194    fn div_assign(&mut self, rhs: f32) {
195        self.x /= rhs;
196        self.y /= rhs;
197        self.z /= rhs;
198        self.w /= rhs;
199    }
200}
201
202impl ops::Neg for Float4 {
203    type Output = Self;
204
205    fn neg(self) -> Self {
206        Self {
207            x: -self.x,
208            y: -self.y,
209            z: -self.z,
210            w: -self.w,
211        }
212    }
213}
214
215impl PartialEq for Float4 {
216    fn eq(&self, rhs: &Self) -> bool {
217        self.x == rhs.x && self.y == rhs.y && self.z == rhs.z && self.w == rhs.w
218    }
219}
220
221impl From<f32> for Float4 {
222    fn from(lhs: f32) -> Self {
223        Self {
224            x: lhs,
225            y: lhs,
226            z: lhs,
227            w: lhs,
228        }
229    }
230}
231
232impl From<(f32, f32, f32, f32)> for Float4 {
233    fn from(lhs: (f32, f32, f32, f32)) -> Self {
234        Self {
235            x: lhs.0,
236            y: lhs.1,
237            z: lhs.2,
238            w: lhs.3,
239        }
240    }
241}
242
243impl Float4 {
244    /// Creates a vector from 4 floating point values.
245    pub fn new(x: f32, y: f32, z: f32, w: f32) -> Self {
246        Self { x, y, z, w }
247    }
248
249    /// Computes the per-component absolute numbers.
250    pub fn abs(&self) -> Self {
251        Self {
252            x: self.x.abs(),
253            y: self.y.abs(),
254            z: self.z.abs(),
255            w: self.w.abs(),
256        }
257    }
258
259    /// Computes the per-component arccosine numbers (in radians).
260    /// Each component should be a value within the range of -1 to 1.
261    /// Return values are in the range 0, pi or NaN if the number is outside the range -1 to 1.
262    pub fn acos(&self) -> Self {
263        Self {
264            x: self.x.acos(),
265            y: self.y.acos(),
266            z: self.z.acos(),
267            w: self.w.acos(),
268        }
269    }
270
271    /// Determines if all components of the vector are non-zero.
272    pub fn all(&self) -> bool {
273        self.x != 0.0 && self.y != 0.0 && self.z != 0.0 && self.w != 0.0
274    }
275
276    /// Determines if any components of the vector are non-zero.
277    pub fn any(&self) -> bool {
278        self.x != 0.0 || self.y != 0.0 || self.z != 0.0 || self.w != 0.0
279    }
280
281    /// Each component should be a value within the range of -1 to 1.
282    /// Return values are in the range -pi/2 to pi/2 or NaN if the number is outside the range -1 to 1.
283    pub fn asin(&self) -> Self {
284        Self {
285            x: self.x.asin(),
286            y: self.y.asin(),
287            z: self.z.asin(),
288            w: self.w.asin(),
289        }
290    }
291
292    /// Computes the per-component arctangent numbers (in radians).
293    /// Return values are in the range -pi/2 to pi/2.
294    pub fn atan(&self) -> Self {
295        Self {
296            x: self.x.atan(),
297            y: self.y.atan(),
298            z: self.z.atan(),
299            w: self.w.atan(),
300        }
301    }
302
303    /// Computes the per-component smallest integers greater than or equal to `self.x` and `self.y` and `self.z` and `self.w` respectively.
304    pub fn ceil(&self) -> Self {
305        Self {
306            x: self.x.ceil(),
307            y: self.y.ceil(),
308            z: self.z.ceil(),
309            w: self.w.ceil(),
310        }
311    }
312
313    /// Computes the per-component clamped numbers between `min` and `max`.
314    pub fn clamp(&self, min: f32, max: f32) -> Self {
315        Self {
316            x: self.x.clamp(min, max),
317            y: self.y.clamp(min, max),
318            z: self.z.clamp(min, max),
319            w: self.w.clamp(min, max),
320        }
321    }
322
323    /// Computes the per-component cosine numbers (in radians).
324    pub fn cos(&self) -> Self {
325        Self {
326            x: self.x.cos(),
327            y: self.y.cos(),
328            z: self.z.cos(),
329            w: self.w.cos(),
330        }
331    }
332
333    /// Computes the per-component hyperbolic cosine numbers.
334    pub fn cosh(&self) -> Self {
335        Self {
336            x: self.x.cosh(),
337            y: self.y.cosh(),
338            z: self.z.cosh(),
339            w: self.w.cosh(),
340        }
341    }
342
343    /// Converts the per-component numbers from radians to degrees.
344    pub fn degrees(&self) -> Self {
345        Self {
346            x: self.x.to_degrees(),
347            y: self.y.to_degrees(),
348            z: self.z.to_degrees(),
349            w: self.w.to_degrees(),
350        }
351    }
352
353    /// Computes the distance scalar between two vectors.
354    pub fn distance(&self, rhs: &Self) -> f32 {
355        let dx = self.x - rhs.x;
356        let dy = self.y - rhs.y;
357        let dz = self.z - rhs.z;
358        let dw = self.w - rhs.w;
359        (dx * dx + dy * dy + dz * dz + dw * dw).sqrt()
360    }
361
362    /// Computes the dot product of two vectors.
363    pub fn dot(&self, rhs: &Self) -> f32 {
364        self.x * rhs.x + self.y * rhs.y + self.z * rhs.z + self.w * rhs.w
365    }
366
367    /// Computes the per-component e^(self), the exponential function.
368    pub fn exp(&self) -> Self {
369        Self {
370            x: self.x.exp(),
371            y: self.y.exp(),
372            z: self.z.exp(),
373            w: self.w.exp(),
374        }
375    }
376
377    /// Computes the per-component 2^(self).
378    pub fn exp2(&self) -> Self {
379        Self {
380            x: self.x.exp2(),
381            y: self.y.exp2(),
382            z: self.z.exp2(),
383            w: self.w.exp2(),
384        }
385    }
386
387    /// Computes the per-component largest integers less than or equal to `self.x` and `self.y` and `self.z` and `self.w` respectively.
388    pub fn floor(&self) -> Self {
389        Self {
390            x: self.x.floor(),
391            y: self.y.floor(),
392            z: self.z.floor(),
393            w: self.w.floor(),
394        }
395    }
396
397    /// Computes the floating-point remainder of division for each component.
398    pub fn fmod(&self, rhs: &Self) -> Self {
399        Self {
400            x: self.x % rhs.x,
401            y: self.y % rhs.y,
402            z: self.z % rhs.z,
403            w: self.w % rhs.w,
404        }
405    }
406
407    /// Computes the fractional (or decimal) part of each component; which is greater than or equal to 0 and less than 1.
408    pub fn frac(&self) -> Self {
409        Self {
410            x: self.x.fract(),
411            y: self.y.fract(),
412            z: self.z.fract(),
413            w: self.w.fract(),
414        }
415    }
416
417    /// Computes `value * 2^exponent` for each component of the vector.
418    pub fn ldexp(&self, exponent: &Self) -> Self {
419        Self {
420            x: self.x * (2.0f32).powi(exponent.x as i32),
421            y: self.y * (2.0f32).powi(exponent.y as i32),
422            z: self.z * (2.0f32).powi(exponent.z as i32),
423            w: self.w * (2.0f32).powi(exponent.w as i32),
424        }
425    }
426
427    /// Computes the length scalar between two vectors.
428    pub fn length(&self) -> f32 {
429        (self.x * self.x + self.y * self.y + self.z * self.z + self.w * self.w).sqrt()
430    }
431
432    /// Computes a linear interpolation between two vectors.
433    pub fn lerp(&self, rhs: &Self, t: f32) -> Self {
434        Self {
435            x: self.x + t * (rhs.x - self.x),
436            y: self.y + t * (rhs.y - self.y),
437            z: self.z + t * (rhs.z - self.z),
438            w: self.w + t * (rhs.w - self.w),
439        }
440    }
441
442    /// Computes the natural logarithm (base e) of each component of the vector.
443    pub fn log(&self) -> Self {
444        Self {
445            x: self.x.ln(),
446            y: self.y.ln(),
447            z: self.z.ln(),
448            w: self.w.ln(),
449        }
450    }
451
452    /// Computes the natural logarithm (base 10) of each component of the vector.
453    pub fn log10(&self) -> Self {
454        Self {
455            x: self.x.log10(),
456            y: self.y.log10(),
457            z: self.z.log10(),
458            w: self.w.log10(),
459        }
460    }
461
462    /// Computes the natural logarithm (base 2) of each component of the vector.
463    pub fn log2(&self) -> Self {
464        Self {
465            x: self.x.log2(),
466            y: self.y.log2(),
467            z: self.z.log2(),
468            w: self.w.log2(),
469        }
470    }
471
472    /// Computes the multiply-add operation: (self * b) + c.
473    pub fn mad(&self, b: &Self, c: &Self) -> Self {
474        Self {
475            x: self.x * b.x + c.x,
476            y: self.y * b.y + c.y,
477            z: self.z * b.z + c.z,
478            w: self.w * b.w + c.w,
479        }
480    }
481
482    /// Computes the component-wise maximum of two vectors.
483    pub fn max(&self, rhs: &Self) -> Self {
484        Self {
485            x: self.x.max(rhs.x),
486            y: self.y.max(rhs.y),
487            z: self.z.max(rhs.z),
488            w: self.w.max(rhs.w),
489        }
490    }
491
492    /// Computes the component-wise minimum of two vectors.
493    pub fn min(&self, rhs: &Self) -> Self {
494        Self {
495            x: self.x.min(rhs.x),
496            y: self.y.min(rhs.y),
497            z: self.z.min(rhs.z),
498            w: self.w.min(rhs.w),
499        }
500    }
501
502    /// Computes the normalized vector (unit vector) of `self`.
503    pub fn normalize(&self) -> Self {
504        let length = self.length();
505        if length != 0.0 {
506            Self {
507                x: self.x / length,
508                y: self.y / length,
509                z: self.z / length,
510                w: self.w / length,
511            }
512        } else {
513            // return the zero vector if the input vector has zero length.
514            Self {
515                x: 0.0,
516                y: 0.0,
517                z: 0.0,
518                w: 0.0,
519            }
520        }
521    }
522
523    /// Computes the component-wise power: `self^exponent`.
524    pub fn pow(&self, exponent: f32) -> Self {
525        Self {
526            x: self.x.powf(exponent),
527            y: self.y.powf(exponent),
528            z: self.z.powf(exponent),
529            w: self.w.powf(exponent),
530        }
531    }
532
533    /// Converts the per-component numbers from degrees to radians.
534    pub fn radians(&self) -> Self {
535        Self {
536            x: self.x.to_radians(),
537            y: self.y.to_radians(),
538            z: self.z.to_radians(),
539            w: self.w.to_radians(),
540        }
541    }
542
543    /// Computes the reciprocal of each component of the vector.
544    /// Equivalent to `1 / self`.
545    pub fn rcp(&self) -> Self {
546        Self {
547            x: 1.0 / self.x,
548            y: 1.0 / self.y,
549            z: 1.0 / self.z,
550            w: 1.0 / self.w,
551        }
552    }
553
554    /// Computes the reciprocal of each component of the vector.
555    /// Equivalent to `1 / self` and returning 0 when self is 0.
556    pub fn rcp_safe(&self) -> Self {
557        Self {
558            x: if self.x != 0.0 { 1.0 / self.x } else { 0.0 },
559            y: if self.y != 0.0 { 1.0 / self.y } else { 0.0 },
560            z: if self.z != 0.0 { 1.0 / self.z } else { 0.0 },
561            w: if self.w != 0.0 { 1.0 / self.w } else { 0.0 },
562        }
563    }
564
565    /// Computes the reflection of an incident vector `self` about a normal vector `normal`.
566    pub fn reflect(&self, normal: &Self) -> Self {
567        let dot = self.dot(normal);
568        Self {
569            x: self.x - 2.0 * dot * normal.x,
570            y: self.y - 2.0 * dot * normal.y,
571            z: self.z - 2.0 * dot * normal.z,
572            w: self.w - 2.0 * dot * normal.w,
573        }
574    }
575
576    /// Computes the refraction vector for the given incident vector, normal, and refraction index.
577    pub fn refract(&self, normal: &Self, eta: f32) -> Self {
578        let dot_n_i = self.dot(normal);
579        let k = 1.0 - eta * eta * (1.0 - dot_n_i * dot_n_i);
580        if k < 0.0 {
581            Self {
582                x: 0.0,
583                y: 0.0,
584                z: 0.0,
585                w: 0.0,
586            }
587        } else {
588            let scale_i = eta;
589            let scale_n = eta * dot_n_i + k.sqrt();
590            Self {
591                x: scale_i * self.x - scale_n * normal.x,
592                y: scale_i * self.y - scale_n * normal.y,
593                z: scale_i * self.z - scale_n * normal.z,
594                w: scale_i * self.w - scale_n * normal.w,
595            }
596        }
597    }
598
599    /// Rounds each component of the vector to the nearest integer.
600    pub fn round(&self) -> Self {
601        Self {
602            x: self.x.round(),
603            y: self.y.round(),
604            z: self.z.round(),
605            w: self.w.round(),
606        }
607    }
608
609    /// Computes the reciprocal square root of each component of the vector.
610    pub fn rsqrt(&self) -> Self {
611        Self {
612            x: if self.x != 0.0 {
613                1.0 / self.x.sqrt()
614            } else {
615                f32::INFINITY
616            },
617            y: if self.y != 0.0 {
618                1.0 / self.y.sqrt()
619            } else {
620                f32::INFINITY
621            },
622            z: if self.z != 0.0 {
623                1.0 / self.z.sqrt()
624            } else {
625                f32::INFINITY
626            },
627            w: if self.w != 0.0 {
628                1.0 / self.w.sqrt()
629            } else {
630                f32::INFINITY
631            },
632        }
633    }
634
635    /// Clamps each component of the vector to the range [0, 1].
636    pub fn saturate(&self) -> Self {
637        Self {
638            x: self.x.clamp(0.0, 1.0),
639            y: self.y.clamp(0.0, 1.0),
640            z: self.z.clamp(0.0, 1.0),
641            w: self.w.clamp(0.0, 1.0),
642        }
643    }
644
645    /// Computes the sign of each component of the vector.
646    pub fn sign(&self) -> Self {
647        Self {
648            x: self.x.signum(),
649            y: self.y.signum(),
650            z: self.z.signum(),
651            w: self.w.signum(),
652        }
653    }
654
655    /// Computes the per-component sine numbers (in radians).
656    pub fn sin(&self) -> Self {
657        Self {
658            x: self.x.sin(),
659            y: self.y.sin(),
660            z: self.z.sin(),
661            w: self.w.sin(),
662        }
663    }
664
665    /// Computes the per-component hyperbolic sine numbers.
666    pub fn sinh(&self) -> Self {
667        Self {
668            x: self.x.sinh(),
669            y: self.y.sinh(),
670            z: self.z.sinh(),
671            w: self.w.sinh(),
672        }
673    }
674
675    /// Performs smoothstep interpolation on each component of the vector.
676    pub fn smoothstep(&self, min: &Self, max: &Self) -> Self {
677        fn smoothstep_component(min: f32, max: f32, value: f32) -> f32 {
678            if value <= min {
679                0.0
680            } else if value >= max {
681                1.0
682            } else {
683                let t = (value - min) / (max - min);
684                t * t * (3.0 - 2.0 * t)
685            }
686        }
687
688        Self {
689            x: smoothstep_component(min.x, max.x, self.x),
690            y: smoothstep_component(min.y, max.y, self.y),
691            z: smoothstep_component(min.z, max.z, self.z),
692            w: smoothstep_component(min.w, max.w, self.w),
693        }
694    }
695
696    /// Computes the square root of each component of the vector.
697    pub fn sqrt(&self) -> Self {
698        Self {
699            x: self.x.sqrt(),
700            y: self.y.sqrt(),
701            z: self.z.sqrt(),
702            w: self.w.sqrt(),
703        }
704    }
705
706    /// Computes the component-wise step function.
707    /// For each component: returns 0.0 if `self < edge`, else returns 1.0.
708    pub fn step(&self, edge: &Self) -> Self {
709        Self {
710            x: if self.x < edge.x { 0.0 } else { 1.0 },
711            y: if self.y < edge.y { 0.0 } else { 1.0 },
712            z: if self.z < edge.z { 0.0 } else { 1.0 },
713            w: if self.w < edge.w { 0.0 } else { 1.0 },
714        }
715    }
716
717    /// Computes the per-component tangent numbers (in radians).
718    pub fn tan(&self) -> Self {
719        Self {
720            x: self.x.tan(),
721            y: self.y.tan(),
722            z: self.z.tan(),
723            w: self.w.tan(),
724        }
725    }
726
727    /// Computes the per-component hyperbolic tangent numbers.
728    pub fn tanh(&self) -> Self {
729        Self {
730            x: self.x.tanh(),
731            y: self.y.tanh(),
732            z: self.z.tanh(),
733            w: self.w.tanh(),
734        }
735    }
736
737    /// Truncates each component of the vector to its integer portion.
738    pub fn trunc(&self) -> Self {
739        Self {
740            x: self.x.trunc(),
741            y: self.y.trunc(),
742            z: self.z.trunc(),
743            w: self.w.trunc(),
744        }
745    }
746
747    /// Returns a swizzled vector.
748    pub fn xx(&self) -> Float2 {
749        Float2 {
750            x: self.x,
751            y: self.x,
752        }
753    }
754
755    /// Returns a swizzled vector.
756    pub fn xy(&self) -> Float2 {
757        Float2 {
758            x: self.x,
759            y: self.y,
760        }
761    }
762
763    /// Returns a swizzled vector.
764    pub fn xz(&self) -> Float2 {
765        Float2 {
766            x: self.x,
767            y: self.z,
768        }
769    }
770
771    /// Returns a swizzled vector.
772    pub fn xw(&self) -> Float2 {
773        Float2 {
774            x: self.x,
775            y: self.w,
776        }
777    }
778
779    /// Returns a swizzled vector.
780    pub fn yx(&self) -> Float2 {
781        Float2 {
782            x: self.y,
783            y: self.x,
784        }
785    }
786
787    /// Returns a swizzled vector.
788    pub fn yy(&self) -> Float2 {
789        Float2 {
790            x: self.y,
791            y: self.y,
792        }
793    }
794
795    /// Returns a swizzled vector.
796    pub fn yz(&self) -> Float2 {
797        Float2 {
798            x: self.y,
799            y: self.z,
800        }
801    }
802
803    /// Returns a swizzled vector.
804    pub fn yw(&self) -> Float2 {
805        Float2 {
806            x: self.y,
807            y: self.w,
808        }
809    }
810
811    /// Returns a swizzled vector.
812    pub fn zx(&self) -> Float2 {
813        Float2 {
814            x: self.z,
815            y: self.x,
816        }
817    }
818
819    /// Returns a swizzled vector.
820    pub fn zy(&self) -> Float2 {
821        Float2 {
822            x: self.z,
823            y: self.y,
824        }
825    }
826
827    /// Returns a swizzled vector.
828    pub fn zz(&self) -> Float2 {
829        Float2 {
830            x: self.z,
831            y: self.z,
832        }
833    }
834
835    /// Returns a swizzled vector.
836    pub fn zw(&self) -> Float2 {
837        Float2 {
838            x: self.z,
839            y: self.w,
840        }
841    }
842
843    /// Returns a swizzled vector.
844    pub fn wx(&self) -> Float2 {
845        Float2 {
846            x: self.w,
847            y: self.x,
848        }
849    }
850
851    /// Returns a swizzled vector.
852    pub fn wy(&self) -> Float2 {
853        Float2 {
854            x: self.w,
855            y: self.y,
856        }
857    }
858
859    /// Returns a swizzled vector.
860    pub fn wz(&self) -> Float2 {
861        Float2 {
862            x: self.w,
863            y: self.z,
864        }
865    }
866
867    /// Returns a swizzled vector.
868    pub fn ww(&self) -> Float2 {
869        Float2 {
870            x: self.w,
871            y: self.w,
872        }
873    }
874
875    /// Returns a swizzled vector.
876    pub fn xxx(&self) -> Float3 {
877        Float3 {
878            x: self.x,
879            y: self.x,
880            z: self.x,
881        }
882    }
883
884    /// Returns a swizzled vector.
885    pub fn xxy(&self) -> Float3 {
886        Float3 {
887            x: self.x,
888            y: self.x,
889            z: self.y,
890        }
891    }
892
893    /// Returns a swizzled vector.
894    pub fn xxz(&self) -> Float3 {
895        Float3 {
896            x: self.x,
897            y: self.x,
898            z: self.z,
899        }
900    }
901
902    /// Returns a swizzled vector.
903    pub fn xxw(&self) -> Float3 {
904        Float3 {
905            x: self.x,
906            y: self.x,
907            z: self.w,
908        }
909    }
910
911    /// Returns a swizzled vector.
912    pub fn xyx(&self) -> Float3 {
913        Float3 {
914            x: self.x,
915            y: self.y,
916            z: self.x,
917        }
918    }
919
920    /// Returns a swizzled vector.
921    pub fn xyy(&self) -> Float3 {
922        Float3 {
923            x: self.x,
924            y: self.y,
925            z: self.y,
926        }
927    }
928
929    /// Returns a swizzled vector.
930    pub fn xyz(&self) -> Float3 {
931        Float3 {
932            x: self.x,
933            y: self.y,
934            z: self.z,
935        }
936    }
937
938    /// Returns a swizzled vector.
939    pub fn xyw(&self) -> Float3 {
940        Float3 {
941            x: self.x,
942            y: self.y,
943            z: self.w,
944        }
945    }
946
947    /// Returns a swizzled vector.
948    pub fn xzx(&self) -> Float3 {
949        Float3 {
950            x: self.x,
951            y: self.z,
952            z: self.x,
953        }
954    }
955
956    /// Returns a swizzled vector.
957    pub fn xzy(&self) -> Float3 {
958        Float3 {
959            x: self.x,
960            y: self.z,
961            z: self.y,
962        }
963    }
964
965    /// Returns a swizzled vector.
966    pub fn xzz(&self) -> Float3 {
967        Float3 {
968            x: self.x,
969            y: self.z,
970            z: self.z,
971        }
972    }
973
974    /// Returns a swizzled vector.
975    pub fn xzw(&self) -> Float3 {
976        Float3 {
977            x: self.x,
978            y: self.z,
979            z: self.w,
980        }
981    }
982
983    /// Returns a swizzled vector.
984    pub fn xwx(&self) -> Float3 {
985        Float3 {
986            x: self.x,
987            y: self.w,
988            z: self.x,
989        }
990    }
991
992    /// Returns a swizzled vector.
993    pub fn xwy(&self) -> Float3 {
994        Float3 {
995            x: self.x,
996            y: self.w,
997            z: self.y,
998        }
999    }
1000
1001    /// Returns a swizzled vector.
1002    pub fn xwz(&self) -> Float3 {
1003        Float3 {
1004            x: self.x,
1005            y: self.w,
1006            z: self.z,
1007        }
1008    }
1009
1010    /// Returns a swizzled vector.
1011    pub fn xww(&self) -> Float3 {
1012        Float3 {
1013            x: self.x,
1014            y: self.w,
1015            z: self.w,
1016        }
1017    }
1018
1019    /// Returns a swizzled vector.
1020    pub fn yxx(&self) -> Float3 {
1021        Float3 {
1022            x: self.y,
1023            y: self.x,
1024            z: self.x,
1025        }
1026    }
1027
1028    /// Returns a swizzled vector.
1029    pub fn yxy(&self) -> Float3 {
1030        Float3 {
1031            x: self.y,
1032            y: self.x,
1033            z: self.y,
1034        }
1035    }
1036
1037    /// Returns a swizzled vector.
1038    pub fn yxz(&self) -> Float3 {
1039        Float3 {
1040            x: self.y,
1041            y: self.x,
1042            z: self.z,
1043        }
1044    }
1045
1046    /// Returns a swizzled vector.
1047    pub fn yxw(&self) -> Float3 {
1048        Float3 {
1049            x: self.y,
1050            y: self.x,
1051            z: self.w,
1052        }
1053    }
1054
1055    /// Returns a swizzled vector.
1056    pub fn yyx(&self) -> Float3 {
1057        Float3 {
1058            x: self.y,
1059            y: self.y,
1060            z: self.x,
1061        }
1062    }
1063
1064    /// Returns a swizzled vector.
1065    pub fn yyy(&self) -> Float3 {
1066        Float3 {
1067            x: self.y,
1068            y: self.y,
1069            z: self.y,
1070        }
1071    }
1072
1073    /// Returns a swizzled vector.
1074    pub fn yyz(&self) -> Float3 {
1075        Float3 {
1076            x: self.y,
1077            y: self.y,
1078            z: self.z,
1079        }
1080    }
1081
1082    /// Returns a swizzled vector.
1083    pub fn yyw(&self) -> Float3 {
1084        Float3 {
1085            x: self.y,
1086            y: self.y,
1087            z: self.w,
1088        }
1089    }
1090
1091    /// Returns a swizzled vector.
1092    pub fn yzx(&self) -> Float3 {
1093        Float3 {
1094            x: self.y,
1095            y: self.z,
1096            z: self.x,
1097        }
1098    }
1099
1100    /// Returns a swizzled vector.
1101    pub fn yzy(&self) -> Float3 {
1102        Float3 {
1103            x: self.y,
1104            y: self.z,
1105            z: self.y,
1106        }
1107    }
1108
1109    /// Returns a swizzled vector.
1110    pub fn yzz(&self) -> Float3 {
1111        Float3 {
1112            x: self.y,
1113            y: self.z,
1114            z: self.z,
1115        }
1116    }
1117
1118    /// Returns a swizzled vector.
1119    pub fn yzw(&self) -> Float3 {
1120        Float3 {
1121            x: self.y,
1122            y: self.z,
1123            z: self.w,
1124        }
1125    }
1126
1127    /// Returns a swizzled vector.
1128    pub fn ywx(&self) -> Float3 {
1129        Float3 {
1130            x: self.y,
1131            y: self.w,
1132            z: self.x,
1133        }
1134    }
1135
1136    /// Returns a swizzled vector.
1137    pub fn ywy(&self) -> Float3 {
1138        Float3 {
1139            x: self.y,
1140            y: self.w,
1141            z: self.y,
1142        }
1143    }
1144
1145    /// Returns a swizzled vector.
1146    pub fn ywz(&self) -> Float3 {
1147        Float3 {
1148            x: self.y,
1149            y: self.w,
1150            z: self.z,
1151        }
1152    }
1153
1154    /// Returns a swizzled vector.
1155    pub fn yww(&self) -> Float3 {
1156        Float3 {
1157            x: self.y,
1158            y: self.w,
1159            z: self.w,
1160        }
1161    }
1162
1163    /// Returns a swizzled vector.
1164    pub fn zxx(&self) -> Float3 {
1165        Float3 {
1166            x: self.z,
1167            y: self.x,
1168            z: self.x,
1169        }
1170    }
1171
1172    /// Returns a swizzled vector.
1173    pub fn zxy(&self) -> Float3 {
1174        Float3 {
1175            x: self.z,
1176            y: self.x,
1177            z: self.y,
1178        }
1179    }
1180
1181    /// Returns a swizzled vector.
1182    pub fn zxz(&self) -> Float3 {
1183        Float3 {
1184            x: self.z,
1185            y: self.x,
1186            z: self.z,
1187        }
1188    }
1189
1190    /// Returns a swizzled vector.
1191    pub fn zxw(&self) -> Float3 {
1192        Float3 {
1193            x: self.z,
1194            y: self.x,
1195            z: self.w,
1196        }
1197    }
1198
1199    /// Returns a swizzled vector.
1200    pub fn zyx(&self) -> Float3 {
1201        Float3 {
1202            x: self.z,
1203            y: self.y,
1204            z: self.x,
1205        }
1206    }
1207
1208    /// Returns a swizzled vector.
1209    pub fn zyy(&self) -> Float3 {
1210        Float3 {
1211            x: self.z,
1212            y: self.y,
1213            z: self.y,
1214        }
1215    }
1216
1217    /// Returns a swizzled vector.
1218    pub fn zyz(&self) -> Float3 {
1219        Float3 {
1220            x: self.z,
1221            y: self.y,
1222            z: self.z,
1223        }
1224    }
1225
1226    /// Returns a swizzled vector.
1227    pub fn zyw(&self) -> Float3 {
1228        Float3 {
1229            x: self.z,
1230            y: self.y,
1231            z: self.w,
1232        }
1233    }
1234
1235    /// Returns a swizzled vector.
1236    pub fn zzx(&self) -> Float3 {
1237        Float3 {
1238            x: self.z,
1239            y: self.z,
1240            z: self.x,
1241        }
1242    }
1243
1244    /// Returns a swizzled vector.
1245    pub fn zzy(&self) -> Float3 {
1246        Float3 {
1247            x: self.z,
1248            y: self.z,
1249            z: self.y,
1250        }
1251    }
1252
1253    /// Returns a swizzled vector.
1254    pub fn zzz(&self) -> Float3 {
1255        Float3 {
1256            x: self.z,
1257            y: self.z,
1258            z: self.z,
1259        }
1260    }
1261
1262    /// Returns a swizzled vector.
1263    pub fn zzw(&self) -> Float3 {
1264        Float3 {
1265            x: self.z,
1266            y: self.z,
1267            z: self.w,
1268        }
1269    }
1270
1271    /// Returns a swizzled vector.
1272    pub fn zwx(&self) -> Float3 {
1273        Float3 {
1274            x: self.z,
1275            y: self.w,
1276            z: self.x,
1277        }
1278    }
1279
1280    /// Returns a swizzled vector.
1281    pub fn zwy(&self) -> Float3 {
1282        Float3 {
1283            x: self.z,
1284            y: self.w,
1285            z: self.y,
1286        }
1287    }
1288
1289    /// Returns a swizzled vector.
1290    pub fn zwz(&self) -> Float3 {
1291        Float3 {
1292            x: self.z,
1293            y: self.w,
1294            z: self.z,
1295        }
1296    }
1297
1298    /// Returns a swizzled vector.
1299    pub fn zww(&self) -> Float3 {
1300        Float3 {
1301            x: self.z,
1302            y: self.w,
1303            z: self.w,
1304        }
1305    }
1306
1307    /// Returns a swizzled vector.
1308    pub fn wxx(&self) -> Float3 {
1309        Float3 {
1310            x: self.w,
1311            y: self.x,
1312            z: self.x,
1313        }
1314    }
1315
1316    /// Returns a swizzled vector.
1317    pub fn wxy(&self) -> Float3 {
1318        Float3 {
1319            x: self.w,
1320            y: self.x,
1321            z: self.y,
1322        }
1323    }
1324
1325    /// Returns a swizzled vector.
1326    pub fn wxz(&self) -> Float3 {
1327        Float3 {
1328            x: self.w,
1329            y: self.x,
1330            z: self.z,
1331        }
1332    }
1333
1334    /// Returns a swizzled vector.
1335    pub fn wxw(&self) -> Float3 {
1336        Float3 {
1337            x: self.w,
1338            y: self.x,
1339            z: self.w,
1340        }
1341    }
1342
1343    /// Returns a swizzled vector.
1344    pub fn wyx(&self) -> Float3 {
1345        Float3 {
1346            x: self.w,
1347            y: self.y,
1348            z: self.x,
1349        }
1350    }
1351
1352    /// Returns a swizzled vector.
1353    pub fn wyy(&self) -> Float3 {
1354        Float3 {
1355            x: self.w,
1356            y: self.y,
1357            z: self.y,
1358        }
1359    }
1360
1361    /// Returns a swizzled vector.
1362    pub fn wyz(&self) -> Float3 {
1363        Float3 {
1364            x: self.w,
1365            y: self.y,
1366            z: self.z,
1367        }
1368    }
1369
1370    /// Returns a swizzled vector.
1371    pub fn wyw(&self) -> Float3 {
1372        Float3 {
1373            x: self.w,
1374            y: self.y,
1375            z: self.w,
1376        }
1377    }
1378
1379    /// Returns a swizzled vector.
1380    pub fn wzx(&self) -> Float3 {
1381        Float3 {
1382            x: self.w,
1383            y: self.z,
1384            z: self.x,
1385        }
1386    }
1387
1388    /// Returns a swizzled vector.
1389    pub fn wzy(&self) -> Float3 {
1390        Float3 {
1391            x: self.w,
1392            y: self.z,
1393            z: self.y,
1394        }
1395    }
1396
1397    /// Returns a swizzled vector.
1398    pub fn wzz(&self) -> Float3 {
1399        Float3 {
1400            x: self.w,
1401            y: self.z,
1402            z: self.z,
1403        }
1404    }
1405
1406    /// Returns a swizzled vector.
1407    pub fn wzw(&self) -> Float3 {
1408        Float3 {
1409            x: self.w,
1410            y: self.z,
1411            z: self.w,
1412        }
1413    }
1414
1415    /// Returns a swizzled vector.
1416    pub fn wwx(&self) -> Float3 {
1417        Float3 {
1418            x: self.w,
1419            y: self.w,
1420            z: self.x,
1421        }
1422    }
1423
1424    /// Returns a swizzled vector.
1425    pub fn wwy(&self) -> Float3 {
1426        Float3 {
1427            x: self.w,
1428            y: self.w,
1429            z: self.y,
1430        }
1431    }
1432
1433    /// Returns a swizzled vector.
1434    pub fn wwz(&self) -> Float3 {
1435        Float3 {
1436            x: self.w,
1437            y: self.w,
1438            z: self.z,
1439        }
1440    }
1441
1442    /// Returns a swizzled vector.
1443    pub fn www(&self) -> Float3 {
1444        Float3 {
1445            x: self.w,
1446            y: self.w,
1447            z: self.w,
1448        }
1449    }
1450
1451    /// Returns a swizzled vector.
1452    pub fn xxxx(&self) -> Float4 {
1453        Float4 {
1454            x: self.x,
1455            y: self.x,
1456            z: self.x,
1457            w: self.x,
1458        }
1459    }
1460
1461    /// Returns a swizzled vector.
1462    pub fn xxxy(&self) -> Float4 {
1463        Float4 {
1464            x: self.x,
1465            y: self.x,
1466            z: self.x,
1467            w: self.y,
1468        }
1469    }
1470
1471    /// Returns a swizzled vector.
1472    pub fn xxxz(&self) -> Float4 {
1473        Float4 {
1474            x: self.x,
1475            y: self.x,
1476            z: self.x,
1477            w: self.z,
1478        }
1479    }
1480
1481    /// Returns a swizzled vector.
1482    pub fn xxxw(&self) -> Float4 {
1483        Float4 {
1484            x: self.x,
1485            y: self.x,
1486            z: self.x,
1487            w: self.w,
1488        }
1489    }
1490
1491    /// Returns a swizzled vector.
1492    pub fn xxyx(&self) -> Float4 {
1493        Float4 {
1494            x: self.x,
1495            y: self.x,
1496            z: self.y,
1497            w: self.x,
1498        }
1499    }
1500
1501    /// Returns a swizzled vector.
1502    pub fn xxyy(&self) -> Float4 {
1503        Float4 {
1504            x: self.x,
1505            y: self.x,
1506            z: self.y,
1507            w: self.y,
1508        }
1509    }
1510
1511    /// Returns a swizzled vector.
1512    pub fn xxyz(&self) -> Float4 {
1513        Float4 {
1514            x: self.x,
1515            y: self.x,
1516            z: self.y,
1517            w: self.z,
1518        }
1519    }
1520
1521    /// Returns a swizzled vector.
1522    pub fn xxyw(&self) -> Float4 {
1523        Float4 {
1524            x: self.x,
1525            y: self.x,
1526            z: self.y,
1527            w: self.w,
1528        }
1529    }
1530
1531    /// Returns a swizzled vector.
1532    pub fn xxzx(&self) -> Float4 {
1533        Float4 {
1534            x: self.x,
1535            y: self.x,
1536            z: self.z,
1537            w: self.x,
1538        }
1539    }
1540
1541    /// Returns a swizzled vector.
1542    pub fn xxzy(&self) -> Float4 {
1543        Float4 {
1544            x: self.x,
1545            y: self.x,
1546            z: self.z,
1547            w: self.y,
1548        }
1549    }
1550
1551    /// Returns a swizzled vector.
1552    pub fn xxzz(&self) -> Float4 {
1553        Float4 {
1554            x: self.x,
1555            y: self.x,
1556            z: self.z,
1557            w: self.z,
1558        }
1559    }
1560
1561    /// Returns a swizzled vector.
1562    pub fn xxzw(&self) -> Float4 {
1563        Float4 {
1564            x: self.x,
1565            y: self.x,
1566            z: self.z,
1567            w: self.w,
1568        }
1569    }
1570
1571    /// Returns a swizzled vector.
1572    pub fn xxwx(&self) -> Float4 {
1573        Float4 {
1574            x: self.x,
1575            y: self.x,
1576            z: self.w,
1577            w: self.x,
1578        }
1579    }
1580
1581    /// Returns a swizzled vector.
1582    pub fn xxwy(&self) -> Float4 {
1583        Float4 {
1584            x: self.x,
1585            y: self.x,
1586            z: self.w,
1587            w: self.y,
1588        }
1589    }
1590
1591    /// Returns a swizzled vector.
1592    pub fn xxwz(&self) -> Float4 {
1593        Float4 {
1594            x: self.x,
1595            y: self.x,
1596            z: self.w,
1597            w: self.z,
1598        }
1599    }
1600
1601    /// Returns a swizzled vector.
1602    pub fn xxww(&self) -> Float4 {
1603        Float4 {
1604            x: self.x,
1605            y: self.x,
1606            z: self.w,
1607            w: self.w,
1608        }
1609    }
1610
1611    /// Returns a swizzled vector.
1612    pub fn xyxx(&self) -> Float4 {
1613        Float4 {
1614            x: self.x,
1615            y: self.y,
1616            z: self.x,
1617            w: self.x,
1618        }
1619    }
1620
1621    /// Returns a swizzled vector.
1622    pub fn xyxy(&self) -> Float4 {
1623        Float4 {
1624            x: self.x,
1625            y: self.y,
1626            z: self.x,
1627            w: self.y,
1628        }
1629    }
1630
1631    /// Returns a swizzled vector.
1632    pub fn xyxz(&self) -> Float4 {
1633        Float4 {
1634            x: self.x,
1635            y: self.y,
1636            z: self.x,
1637            w: self.z,
1638        }
1639    }
1640
1641    /// Returns a swizzled vector.
1642    pub fn xyxw(&self) -> Float4 {
1643        Float4 {
1644            x: self.x,
1645            y: self.y,
1646            z: self.x,
1647            w: self.w,
1648        }
1649    }
1650
1651    /// Returns a swizzled vector.
1652    pub fn xyyx(&self) -> Float4 {
1653        Float4 {
1654            x: self.x,
1655            y: self.y,
1656            z: self.y,
1657            w: self.x,
1658        }
1659    }
1660
1661    /// Returns a swizzled vector.
1662    pub fn xyyy(&self) -> Float4 {
1663        Float4 {
1664            x: self.x,
1665            y: self.y,
1666            z: self.y,
1667            w: self.y,
1668        }
1669    }
1670
1671    /// Returns a swizzled vector.
1672    pub fn xyyz(&self) -> Float4 {
1673        Float4 {
1674            x: self.x,
1675            y: self.y,
1676            z: self.y,
1677            w: self.z,
1678        }
1679    }
1680
1681    /// Returns a swizzled vector.
1682    pub fn xyyw(&self) -> Float4 {
1683        Float4 {
1684            x: self.x,
1685            y: self.y,
1686            z: self.y,
1687            w: self.w,
1688        }
1689    }
1690
1691    /// Returns a swizzled vector.
1692    pub fn xyzx(&self) -> Float4 {
1693        Float4 {
1694            x: self.x,
1695            y: self.y,
1696            z: self.z,
1697            w: self.x,
1698        }
1699    }
1700
1701    /// Returns a swizzled vector.
1702    pub fn xyzy(&self) -> Float4 {
1703        Float4 {
1704            x: self.x,
1705            y: self.y,
1706            z: self.z,
1707            w: self.y,
1708        }
1709    }
1710
1711    /// Returns a swizzled vector.
1712    pub fn xyzz(&self) -> Float4 {
1713        Float4 {
1714            x: self.x,
1715            y: self.y,
1716            z: self.z,
1717            w: self.z,
1718        }
1719    }
1720
1721    /// Returns a swizzled vector.
1722    pub fn xyzw(&self) -> Float4 {
1723        Float4 {
1724            x: self.x,
1725            y: self.y,
1726            z: self.z,
1727            w: self.w,
1728        }
1729    }
1730
1731    /// Returns a swizzled vector.
1732    pub fn xywx(&self) -> Float4 {
1733        Float4 {
1734            x: self.x,
1735            y: self.y,
1736            z: self.w,
1737            w: self.x,
1738        }
1739    }
1740
1741    /// Returns a swizzled vector.
1742    pub fn xywy(&self) -> Float4 {
1743        Float4 {
1744            x: self.x,
1745            y: self.y,
1746            z: self.w,
1747            w: self.y,
1748        }
1749    }
1750
1751    /// Returns a swizzled vector.
1752    pub fn xywz(&self) -> Float4 {
1753        Float4 {
1754            x: self.x,
1755            y: self.y,
1756            z: self.w,
1757            w: self.z,
1758        }
1759    }
1760
1761    /// Returns a swizzled vector.
1762    pub fn xyww(&self) -> Float4 {
1763        Float4 {
1764            x: self.x,
1765            y: self.y,
1766            z: self.w,
1767            w: self.w,
1768        }
1769    }
1770
1771    /// Returns a swizzled vector.
1772    pub fn xzxx(&self) -> Float4 {
1773        Float4 {
1774            x: self.x,
1775            y: self.z,
1776            z: self.x,
1777            w: self.x,
1778        }
1779    }
1780
1781    /// Returns a swizzled vector.
1782    pub fn xzxy(&self) -> Float4 {
1783        Float4 {
1784            x: self.x,
1785            y: self.z,
1786            z: self.x,
1787            w: self.y,
1788        }
1789    }
1790
1791    /// Returns a swizzled vector.
1792    pub fn xzxz(&self) -> Float4 {
1793        Float4 {
1794            x: self.x,
1795            y: self.z,
1796            z: self.x,
1797            w: self.z,
1798        }
1799    }
1800
1801    /// Returns a swizzled vector.
1802    pub fn xzxw(&self) -> Float4 {
1803        Float4 {
1804            x: self.x,
1805            y: self.z,
1806            z: self.x,
1807            w: self.w,
1808        }
1809    }
1810
1811    /// Returns a swizzled vector.
1812    pub fn xzyx(&self) -> Float4 {
1813        Float4 {
1814            x: self.x,
1815            y: self.z,
1816            z: self.y,
1817            w: self.x,
1818        }
1819    }
1820
1821    /// Returns a swizzled vector.
1822    pub fn xzyy(&self) -> Float4 {
1823        Float4 {
1824            x: self.x,
1825            y: self.z,
1826            z: self.y,
1827            w: self.y,
1828        }
1829    }
1830
1831    /// Returns a swizzled vector.
1832    pub fn xzyz(&self) -> Float4 {
1833        Float4 {
1834            x: self.x,
1835            y: self.z,
1836            z: self.y,
1837            w: self.z,
1838        }
1839    }
1840
1841    /// Returns a swizzled vector.
1842    pub fn xzyw(&self) -> Float4 {
1843        Float4 {
1844            x: self.x,
1845            y: self.z,
1846            z: self.y,
1847            w: self.w,
1848        }
1849    }
1850
1851    /// Returns a swizzled vector.
1852    pub fn xzzx(&self) -> Float4 {
1853        Float4 {
1854            x: self.x,
1855            y: self.z,
1856            z: self.z,
1857            w: self.x,
1858        }
1859    }
1860
1861    /// Returns a swizzled vector.
1862    pub fn xzzy(&self) -> Float4 {
1863        Float4 {
1864            x: self.x,
1865            y: self.z,
1866            z: self.z,
1867            w: self.y,
1868        }
1869    }
1870
1871    /// Returns a swizzled vector.
1872    pub fn xzzz(&self) -> Float4 {
1873        Float4 {
1874            x: self.x,
1875            y: self.z,
1876            z: self.z,
1877            w: self.z,
1878        }
1879    }
1880
1881    /// Returns a swizzled vector.
1882    pub fn xzzw(&self) -> Float4 {
1883        Float4 {
1884            x: self.x,
1885            y: self.z,
1886            z: self.z,
1887            w: self.w,
1888        }
1889    }
1890
1891    /// Returns a swizzled vector.
1892    pub fn xzwx(&self) -> Float4 {
1893        Float4 {
1894            x: self.x,
1895            y: self.z,
1896            z: self.w,
1897            w: self.x,
1898        }
1899    }
1900
1901    /// Returns a swizzled vector.
1902    pub fn xzwy(&self) -> Float4 {
1903        Float4 {
1904            x: self.x,
1905            y: self.z,
1906            z: self.w,
1907            w: self.y,
1908        }
1909    }
1910
1911    /// Returns a swizzled vector.
1912    pub fn xzwz(&self) -> Float4 {
1913        Float4 {
1914            x: self.x,
1915            y: self.z,
1916            z: self.w,
1917            w: self.z,
1918        }
1919    }
1920
1921    /// Returns a swizzled vector.
1922    pub fn xzww(&self) -> Float4 {
1923        Float4 {
1924            x: self.x,
1925            y: self.z,
1926            z: self.w,
1927            w: self.w,
1928        }
1929    }
1930
1931    /// Returns a swizzled vector.
1932    pub fn xwxx(&self) -> Float4 {
1933        Float4 {
1934            x: self.x,
1935            y: self.w,
1936            z: self.x,
1937            w: self.x,
1938        }
1939    }
1940
1941    /// Returns a swizzled vector.
1942    pub fn xwxy(&self) -> Float4 {
1943        Float4 {
1944            x: self.x,
1945            y: self.w,
1946            z: self.x,
1947            w: self.y,
1948        }
1949    }
1950
1951    /// Returns a swizzled vector.
1952    pub fn xwxz(&self) -> Float4 {
1953        Float4 {
1954            x: self.x,
1955            y: self.w,
1956            z: self.x,
1957            w: self.z,
1958        }
1959    }
1960
1961    /// Returns a swizzled vector.
1962    pub fn xwxw(&self) -> Float4 {
1963        Float4 {
1964            x: self.x,
1965            y: self.w,
1966            z: self.x,
1967            w: self.w,
1968        }
1969    }
1970
1971    /// Returns a swizzled vector.
1972    pub fn xwyx(&self) -> Float4 {
1973        Float4 {
1974            x: self.x,
1975            y: self.w,
1976            z: self.y,
1977            w: self.x,
1978        }
1979    }
1980
1981    /// Returns a swizzled vector.
1982    pub fn xwyy(&self) -> Float4 {
1983        Float4 {
1984            x: self.x,
1985            y: self.w,
1986            z: self.y,
1987            w: self.y,
1988        }
1989    }
1990
1991    /// Returns a swizzled vector.
1992    pub fn xwyz(&self) -> Float4 {
1993        Float4 {
1994            x: self.x,
1995            y: self.w,
1996            z: self.y,
1997            w: self.z,
1998        }
1999    }
2000
2001    /// Returns a swizzled vector.
2002    pub fn xwyw(&self) -> Float4 {
2003        Float4 {
2004            x: self.x,
2005            y: self.w,
2006            z: self.y,
2007            w: self.w,
2008        }
2009    }
2010
2011    /// Returns a swizzled vector.
2012    pub fn xwzx(&self) -> Float4 {
2013        Float4 {
2014            x: self.x,
2015            y: self.w,
2016            z: self.z,
2017            w: self.x,
2018        }
2019    }
2020
2021    /// Returns a swizzled vector.
2022    pub fn xwzy(&self) -> Float4 {
2023        Float4 {
2024            x: self.x,
2025            y: self.w,
2026            z: self.z,
2027            w: self.y,
2028        }
2029    }
2030
2031    /// Returns a swizzled vector.
2032    pub fn xwzz(&self) -> Float4 {
2033        Float4 {
2034            x: self.x,
2035            y: self.w,
2036            z: self.z,
2037            w: self.z,
2038        }
2039    }
2040
2041    /// Returns a swizzled vector.
2042    pub fn xwzw(&self) -> Float4 {
2043        Float4 {
2044            x: self.x,
2045            y: self.w,
2046            z: self.z,
2047            w: self.w,
2048        }
2049    }
2050
2051    /// Returns a swizzled vector.
2052    pub fn xwwx(&self) -> Float4 {
2053        Float4 {
2054            x: self.x,
2055            y: self.w,
2056            z: self.w,
2057            w: self.x,
2058        }
2059    }
2060
2061    /// Returns a swizzled vector.
2062    pub fn xwwy(&self) -> Float4 {
2063        Float4 {
2064            x: self.x,
2065            y: self.w,
2066            z: self.w,
2067            w: self.y,
2068        }
2069    }
2070
2071    /// Returns a swizzled vector.
2072    pub fn xwwz(&self) -> Float4 {
2073        Float4 {
2074            x: self.x,
2075            y: self.w,
2076            z: self.w,
2077            w: self.z,
2078        }
2079    }
2080
2081    /// Returns a swizzled vector.
2082    pub fn xwww(&self) -> Float4 {
2083        Float4 {
2084            x: self.x,
2085            y: self.w,
2086            z: self.w,
2087            w: self.w,
2088        }
2089    }
2090
2091    /// Returns a swizzled vector.
2092    pub fn yxxx(&self) -> Float4 {
2093        Float4 {
2094            x: self.y,
2095            y: self.x,
2096            z: self.x,
2097            w: self.x,
2098        }
2099    }
2100
2101    /// Returns a swizzled vector.
2102    pub fn yxxy(&self) -> Float4 {
2103        Float4 {
2104            x: self.y,
2105            y: self.x,
2106            z: self.x,
2107            w: self.y,
2108        }
2109    }
2110
2111    /// Returns a swizzled vector.
2112    pub fn yxxz(&self) -> Float4 {
2113        Float4 {
2114            x: self.y,
2115            y: self.x,
2116            z: self.x,
2117            w: self.z,
2118        }
2119    }
2120
2121    /// Returns a swizzled vector.
2122    pub fn yxxw(&self) -> Float4 {
2123        Float4 {
2124            x: self.y,
2125            y: self.x,
2126            z: self.x,
2127            w: self.w,
2128        }
2129    }
2130
2131    /// Returns a swizzled vector.
2132    pub fn yxyx(&self) -> Float4 {
2133        Float4 {
2134            x: self.y,
2135            y: self.x,
2136            z: self.y,
2137            w: self.x,
2138        }
2139    }
2140
2141    /// Returns a swizzled vector.
2142    pub fn yxyy(&self) -> Float4 {
2143        Float4 {
2144            x: self.y,
2145            y: self.x,
2146            z: self.y,
2147            w: self.y,
2148        }
2149    }
2150
2151    /// Returns a swizzled vector.
2152    pub fn yxyz(&self) -> Float4 {
2153        Float4 {
2154            x: self.y,
2155            y: self.x,
2156            z: self.y,
2157            w: self.z,
2158        }
2159    }
2160
2161    /// Returns a swizzled vector.
2162    pub fn yxyw(&self) -> Float4 {
2163        Float4 {
2164            x: self.y,
2165            y: self.x,
2166            z: self.y,
2167            w: self.w,
2168        }
2169    }
2170
2171    /// Returns a swizzled vector.
2172    pub fn yxzx(&self) -> Float4 {
2173        Float4 {
2174            x: self.y,
2175            y: self.x,
2176            z: self.z,
2177            w: self.x,
2178        }
2179    }
2180
2181    /// Returns a swizzled vector.
2182    pub fn yxzy(&self) -> Float4 {
2183        Float4 {
2184            x: self.y,
2185            y: self.x,
2186            z: self.z,
2187            w: self.y,
2188        }
2189    }
2190
2191    /// Returns a swizzled vector.
2192    pub fn yxzz(&self) -> Float4 {
2193        Float4 {
2194            x: self.y,
2195            y: self.x,
2196            z: self.z,
2197            w: self.z,
2198        }
2199    }
2200
2201    /// Returns a swizzled vector.
2202    pub fn yxzw(&self) -> Float4 {
2203        Float4 {
2204            x: self.y,
2205            y: self.x,
2206            z: self.z,
2207            w: self.w,
2208        }
2209    }
2210
2211    /// Returns a swizzled vector.
2212    pub fn yxwx(&self) -> Float4 {
2213        Float4 {
2214            x: self.y,
2215            y: self.x,
2216            z: self.w,
2217            w: self.x,
2218        }
2219    }
2220
2221    /// Returns a swizzled vector.
2222    pub fn yxwy(&self) -> Float4 {
2223        Float4 {
2224            x: self.y,
2225            y: self.x,
2226            z: self.w,
2227            w: self.y,
2228        }
2229    }
2230
2231    /// Returns a swizzled vector.
2232    pub fn yxwz(&self) -> Float4 {
2233        Float4 {
2234            x: self.y,
2235            y: self.x,
2236            z: self.w,
2237            w: self.z,
2238        }
2239    }
2240
2241    /// Returns a swizzled vector.
2242    pub fn yxww(&self) -> Float4 {
2243        Float4 {
2244            x: self.y,
2245            y: self.x,
2246            z: self.w,
2247            w: self.w,
2248        }
2249    }
2250
2251    /// Returns a swizzled vector.
2252    pub fn yyxx(&self) -> Float4 {
2253        Float4 {
2254            x: self.y,
2255            y: self.y,
2256            z: self.x,
2257            w: self.x,
2258        }
2259    }
2260
2261    /// Returns a swizzled vector.
2262    pub fn yyxy(&self) -> Float4 {
2263        Float4 {
2264            x: self.y,
2265            y: self.y,
2266            z: self.x,
2267            w: self.y,
2268        }
2269    }
2270
2271    /// Returns a swizzled vector.
2272    pub fn yyxz(&self) -> Float4 {
2273        Float4 {
2274            x: self.y,
2275            y: self.y,
2276            z: self.x,
2277            w: self.z,
2278        }
2279    }
2280
2281    /// Returns a swizzled vector.
2282    pub fn yyxw(&self) -> Float4 {
2283        Float4 {
2284            x: self.y,
2285            y: self.y,
2286            z: self.x,
2287            w: self.w,
2288        }
2289    }
2290
2291    /// Returns a swizzled vector.
2292    pub fn yyyx(&self) -> Float4 {
2293        Float4 {
2294            x: self.y,
2295            y: self.y,
2296            z: self.y,
2297            w: self.x,
2298        }
2299    }
2300
2301    /// Returns a swizzled vector.
2302    pub fn yyyy(&self) -> Float4 {
2303        Float4 {
2304            x: self.y,
2305            y: self.y,
2306            z: self.y,
2307            w: self.y,
2308        }
2309    }
2310
2311    /// Returns a swizzled vector.
2312    pub fn yyyz(&self) -> Float4 {
2313        Float4 {
2314            x: self.y,
2315            y: self.y,
2316            z: self.y,
2317            w: self.z,
2318        }
2319    }
2320
2321    /// Returns a swizzled vector.
2322    pub fn yyyw(&self) -> Float4 {
2323        Float4 {
2324            x: self.y,
2325            y: self.y,
2326            z: self.y,
2327            w: self.w,
2328        }
2329    }
2330
2331    /// Returns a swizzled vector.
2332    pub fn yyzx(&self) -> Float4 {
2333        Float4 {
2334            x: self.y,
2335            y: self.y,
2336            z: self.z,
2337            w: self.x,
2338        }
2339    }
2340
2341    /// Returns a swizzled vector.
2342    pub fn yyzy(&self) -> Float4 {
2343        Float4 {
2344            x: self.y,
2345            y: self.y,
2346            z: self.z,
2347            w: self.y,
2348        }
2349    }
2350
2351    /// Returns a swizzled vector.
2352    pub fn yyzz(&self) -> Float4 {
2353        Float4 {
2354            x: self.y,
2355            y: self.y,
2356            z: self.z,
2357            w: self.z,
2358        }
2359    }
2360
2361    /// Returns a swizzled vector.
2362    pub fn yyzw(&self) -> Float4 {
2363        Float4 {
2364            x: self.y,
2365            y: self.y,
2366            z: self.z,
2367            w: self.w,
2368        }
2369    }
2370
2371    /// Returns a swizzled vector.
2372    pub fn yywx(&self) -> Float4 {
2373        Float4 {
2374            x: self.y,
2375            y: self.y,
2376            z: self.w,
2377            w: self.x,
2378        }
2379    }
2380
2381    /// Returns a swizzled vector.
2382    pub fn yywy(&self) -> Float4 {
2383        Float4 {
2384            x: self.y,
2385            y: self.y,
2386            z: self.w,
2387            w: self.y,
2388        }
2389    }
2390
2391    /// Returns a swizzled vector.
2392    pub fn yywz(&self) -> Float4 {
2393        Float4 {
2394            x: self.y,
2395            y: self.y,
2396            z: self.w,
2397            w: self.z,
2398        }
2399    }
2400
2401    /// Returns a swizzled vector.
2402    pub fn yyww(&self) -> Float4 {
2403        Float4 {
2404            x: self.y,
2405            y: self.y,
2406            z: self.w,
2407            w: self.w,
2408        }
2409    }
2410
2411    /// Returns a swizzled vector.
2412    pub fn yzxx(&self) -> Float4 {
2413        Float4 {
2414            x: self.y,
2415            y: self.z,
2416            z: self.x,
2417            w: self.x,
2418        }
2419    }
2420
2421    /// Returns a swizzled vector.
2422    pub fn yzxy(&self) -> Float4 {
2423        Float4 {
2424            x: self.y,
2425            y: self.z,
2426            z: self.x,
2427            w: self.y,
2428        }
2429    }
2430
2431    /// Returns a swizzled vector.
2432    pub fn yzxz(&self) -> Float4 {
2433        Float4 {
2434            x: self.y,
2435            y: self.z,
2436            z: self.x,
2437            w: self.z,
2438        }
2439    }
2440
2441    /// Returns a swizzled vector.
2442    pub fn yzxw(&self) -> Float4 {
2443        Float4 {
2444            x: self.y,
2445            y: self.z,
2446            z: self.x,
2447            w: self.w,
2448        }
2449    }
2450
2451    /// Returns a swizzled vector.
2452    pub fn yzyx(&self) -> Float4 {
2453        Float4 {
2454            x: self.y,
2455            y: self.z,
2456            z: self.y,
2457            w: self.x,
2458        }
2459    }
2460
2461    /// Returns a swizzled vector.
2462    pub fn yzyy(&self) -> Float4 {
2463        Float4 {
2464            x: self.y,
2465            y: self.z,
2466            z: self.y,
2467            w: self.y,
2468        }
2469    }
2470
2471    /// Returns a swizzled vector.
2472    pub fn yzyz(&self) -> Float4 {
2473        Float4 {
2474            x: self.y,
2475            y: self.z,
2476            z: self.y,
2477            w: self.z,
2478        }
2479    }
2480
2481    /// Returns a swizzled vector.
2482    pub fn yzyw(&self) -> Float4 {
2483        Float4 {
2484            x: self.y,
2485            y: self.z,
2486            z: self.y,
2487            w: self.w,
2488        }
2489    }
2490
2491    /// Returns a swizzled vector.
2492    pub fn yzzx(&self) -> Float4 {
2493        Float4 {
2494            x: self.y,
2495            y: self.z,
2496            z: self.z,
2497            w: self.x,
2498        }
2499    }
2500
2501    /// Returns a swizzled vector.
2502    pub fn yzzy(&self) -> Float4 {
2503        Float4 {
2504            x: self.y,
2505            y: self.z,
2506            z: self.z,
2507            w: self.y,
2508        }
2509    }
2510
2511    /// Returns a swizzled vector.
2512    pub fn yzzz(&self) -> Float4 {
2513        Float4 {
2514            x: self.y,
2515            y: self.z,
2516            z: self.z,
2517            w: self.z,
2518        }
2519    }
2520
2521    /// Returns a swizzled vector.
2522    pub fn yzzw(&self) -> Float4 {
2523        Float4 {
2524            x: self.y,
2525            y: self.z,
2526            z: self.z,
2527            w: self.w,
2528        }
2529    }
2530
2531    /// Returns a swizzled vector.
2532    pub fn yzwx(&self) -> Float4 {
2533        Float4 {
2534            x: self.y,
2535            y: self.z,
2536            z: self.w,
2537            w: self.x,
2538        }
2539    }
2540
2541    /// Returns a swizzled vector.
2542    pub fn yzwy(&self) -> Float4 {
2543        Float4 {
2544            x: self.y,
2545            y: self.z,
2546            z: self.w,
2547            w: self.y,
2548        }
2549    }
2550
2551    /// Returns a swizzled vector.
2552    pub fn yzwz(&self) -> Float4 {
2553        Float4 {
2554            x: self.y,
2555            y: self.z,
2556            z: self.w,
2557            w: self.z,
2558        }
2559    }
2560
2561    /// Returns a swizzled vector.
2562    pub fn yzww(&self) -> Float4 {
2563        Float4 {
2564            x: self.y,
2565            y: self.z,
2566            z: self.w,
2567            w: self.w,
2568        }
2569    }
2570
2571    /// Returns a swizzled vector.
2572    pub fn ywxx(&self) -> Float4 {
2573        Float4 {
2574            x: self.y,
2575            y: self.w,
2576            z: self.x,
2577            w: self.x,
2578        }
2579    }
2580
2581    /// Returns a swizzled vector.
2582    pub fn ywxy(&self) -> Float4 {
2583        Float4 {
2584            x: self.y,
2585            y: self.w,
2586            z: self.x,
2587            w: self.y,
2588        }
2589    }
2590
2591    /// Returns a swizzled vector.
2592    pub fn ywxz(&self) -> Float4 {
2593        Float4 {
2594            x: self.y,
2595            y: self.w,
2596            z: self.x,
2597            w: self.z,
2598        }
2599    }
2600
2601    /// Returns a swizzled vector.
2602    pub fn ywxw(&self) -> Float4 {
2603        Float4 {
2604            x: self.y,
2605            y: self.w,
2606            z: self.x,
2607            w: self.w,
2608        }
2609    }
2610
2611    /// Returns a swizzled vector.
2612    pub fn ywyx(&self) -> Float4 {
2613        Float4 {
2614            x: self.y,
2615            y: self.w,
2616            z: self.y,
2617            w: self.x,
2618        }
2619    }
2620
2621    /// Returns a swizzled vector.
2622    pub fn ywyy(&self) -> Float4 {
2623        Float4 {
2624            x: self.y,
2625            y: self.w,
2626            z: self.y,
2627            w: self.y,
2628        }
2629    }
2630
2631    /// Returns a swizzled vector.
2632    pub fn ywyz(&self) -> Float4 {
2633        Float4 {
2634            x: self.y,
2635            y: self.w,
2636            z: self.y,
2637            w: self.z,
2638        }
2639    }
2640
2641    /// Returns a swizzled vector.
2642    pub fn ywyw(&self) -> Float4 {
2643        Float4 {
2644            x: self.y,
2645            y: self.w,
2646            z: self.y,
2647            w: self.w,
2648        }
2649    }
2650
2651    /// Returns a swizzled vector.
2652    pub fn ywzx(&self) -> Float4 {
2653        Float4 {
2654            x: self.y,
2655            y: self.w,
2656            z: self.z,
2657            w: self.x,
2658        }
2659    }
2660
2661    /// Returns a swizzled vector.
2662    pub fn ywzy(&self) -> Float4 {
2663        Float4 {
2664            x: self.y,
2665            y: self.w,
2666            z: self.z,
2667            w: self.y,
2668        }
2669    }
2670
2671    /// Returns a swizzled vector.
2672    pub fn ywzz(&self) -> Float4 {
2673        Float4 {
2674            x: self.y,
2675            y: self.w,
2676            z: self.z,
2677            w: self.z,
2678        }
2679    }
2680
2681    /// Returns a swizzled vector.
2682    pub fn ywzw(&self) -> Float4 {
2683        Float4 {
2684            x: self.y,
2685            y: self.w,
2686            z: self.z,
2687            w: self.w,
2688        }
2689    }
2690
2691    /// Returns a swizzled vector.
2692    pub fn ywwx(&self) -> Float4 {
2693        Float4 {
2694            x: self.y,
2695            y: self.w,
2696            z: self.w,
2697            w: self.x,
2698        }
2699    }
2700
2701    /// Returns a swizzled vector.
2702    pub fn ywwy(&self) -> Float4 {
2703        Float4 {
2704            x: self.y,
2705            y: self.w,
2706            z: self.w,
2707            w: self.y,
2708        }
2709    }
2710
2711    /// Returns a swizzled vector.
2712    pub fn ywwz(&self) -> Float4 {
2713        Float4 {
2714            x: self.y,
2715            y: self.w,
2716            z: self.w,
2717            w: self.z,
2718        }
2719    }
2720
2721    /// Returns a swizzled vector.
2722    pub fn ywww(&self) -> Float4 {
2723        Float4 {
2724            x: self.y,
2725            y: self.w,
2726            z: self.w,
2727            w: self.w,
2728        }
2729    }
2730
2731    /// Returns a swizzled vector.
2732    pub fn zxxx(&self) -> Float4 {
2733        Float4 {
2734            x: self.z,
2735            y: self.x,
2736            z: self.x,
2737            w: self.x,
2738        }
2739    }
2740
2741    /// Returns a swizzled vector.
2742    pub fn zxxy(&self) -> Float4 {
2743        Float4 {
2744            x: self.z,
2745            y: self.x,
2746            z: self.x,
2747            w: self.y,
2748        }
2749    }
2750
2751    /// Returns a swizzled vector.
2752    pub fn zxxz(&self) -> Float4 {
2753        Float4 {
2754            x: self.z,
2755            y: self.x,
2756            z: self.x,
2757            w: self.z,
2758        }
2759    }
2760
2761    /// Returns a swizzled vector.
2762    pub fn zxxw(&self) -> Float4 {
2763        Float4 {
2764            x: self.z,
2765            y: self.x,
2766            z: self.x,
2767            w: self.w,
2768        }
2769    }
2770
2771    /// Returns a swizzled vector.
2772    pub fn zxyx(&self) -> Float4 {
2773        Float4 {
2774            x: self.z,
2775            y: self.x,
2776            z: self.y,
2777            w: self.x,
2778        }
2779    }
2780
2781    /// Returns a swizzled vector.
2782    pub fn zxyy(&self) -> Float4 {
2783        Float4 {
2784            x: self.z,
2785            y: self.x,
2786            z: self.y,
2787            w: self.y,
2788        }
2789    }
2790
2791    /// Returns a swizzled vector.
2792    pub fn zxyz(&self) -> Float4 {
2793        Float4 {
2794            x: self.z,
2795            y: self.x,
2796            z: self.y,
2797            w: self.z,
2798        }
2799    }
2800
2801    /// Returns a swizzled vector.
2802    pub fn zxyw(&self) -> Float4 {
2803        Float4 {
2804            x: self.z,
2805            y: self.x,
2806            z: self.y,
2807            w: self.w,
2808        }
2809    }
2810
2811    /// Returns a swizzled vector.
2812    pub fn zxzx(&self) -> Float4 {
2813        Float4 {
2814            x: self.z,
2815            y: self.x,
2816            z: self.z,
2817            w: self.x,
2818        }
2819    }
2820
2821    /// Returns a swizzled vector.
2822    pub fn zxzy(&self) -> Float4 {
2823        Float4 {
2824            x: self.z,
2825            y: self.x,
2826            z: self.z,
2827            w: self.y,
2828        }
2829    }
2830
2831    /// Returns a swizzled vector.
2832    pub fn zxzz(&self) -> Float4 {
2833        Float4 {
2834            x: self.z,
2835            y: self.x,
2836            z: self.z,
2837            w: self.z,
2838        }
2839    }
2840
2841    /// Returns a swizzled vector.
2842    pub fn zxzw(&self) -> Float4 {
2843        Float4 {
2844            x: self.z,
2845            y: self.x,
2846            z: self.z,
2847            w: self.w,
2848        }
2849    }
2850
2851    /// Returns a swizzled vector.
2852    pub fn zxwx(&self) -> Float4 {
2853        Float4 {
2854            x: self.z,
2855            y: self.x,
2856            z: self.w,
2857            w: self.x,
2858        }
2859    }
2860
2861    /// Returns a swizzled vector.
2862    pub fn zxwy(&self) -> Float4 {
2863        Float4 {
2864            x: self.z,
2865            y: self.x,
2866            z: self.w,
2867            w: self.y,
2868        }
2869    }
2870
2871    /// Returns a swizzled vector.
2872    pub fn zxwz(&self) -> Float4 {
2873        Float4 {
2874            x: self.z,
2875            y: self.x,
2876            z: self.w,
2877            w: self.z,
2878        }
2879    }
2880
2881    /// Returns a swizzled vector.
2882    pub fn zxww(&self) -> Float4 {
2883        Float4 {
2884            x: self.z,
2885            y: self.x,
2886            z: self.w,
2887            w: self.w,
2888        }
2889    }
2890
2891    /// Returns a swizzled vector.
2892    pub fn zyxx(&self) -> Float4 {
2893        Float4 {
2894            x: self.z,
2895            y: self.y,
2896            z: self.x,
2897            w: self.x,
2898        }
2899    }
2900
2901    /// Returns a swizzled vector.
2902    pub fn zyxy(&self) -> Float4 {
2903        Float4 {
2904            x: self.z,
2905            y: self.y,
2906            z: self.x,
2907            w: self.y,
2908        }
2909    }
2910
2911    /// Returns a swizzled vector.
2912    pub fn zyxz(&self) -> Float4 {
2913        Float4 {
2914            x: self.z,
2915            y: self.y,
2916            z: self.x,
2917            w: self.z,
2918        }
2919    }
2920
2921    /// Returns a swizzled vector.
2922    pub fn zyxw(&self) -> Float4 {
2923        Float4 {
2924            x: self.z,
2925            y: self.y,
2926            z: self.x,
2927            w: self.w,
2928        }
2929    }
2930
2931    /// Returns a swizzled vector.
2932    pub fn zyyx(&self) -> Float4 {
2933        Float4 {
2934            x: self.z,
2935            y: self.y,
2936            z: self.y,
2937            w: self.x,
2938        }
2939    }
2940
2941    /// Returns a swizzled vector.
2942    pub fn zyyy(&self) -> Float4 {
2943        Float4 {
2944            x: self.z,
2945            y: self.y,
2946            z: self.y,
2947            w: self.y,
2948        }
2949    }
2950
2951    /// Returns a swizzled vector.
2952    pub fn zyyz(&self) -> Float4 {
2953        Float4 {
2954            x: self.z,
2955            y: self.y,
2956            z: self.y,
2957            w: self.z,
2958        }
2959    }
2960
2961    /// Returns a swizzled vector.
2962    pub fn zyyw(&self) -> Float4 {
2963        Float4 {
2964            x: self.z,
2965            y: self.y,
2966            z: self.y,
2967            w: self.w,
2968        }
2969    }
2970
2971    /// Returns a swizzled vector.
2972    pub fn zyzx(&self) -> Float4 {
2973        Float4 {
2974            x: self.z,
2975            y: self.y,
2976            z: self.z,
2977            w: self.x,
2978        }
2979    }
2980
2981    /// Returns a swizzled vector.
2982    pub fn zyzy(&self) -> Float4 {
2983        Float4 {
2984            x: self.z,
2985            y: self.y,
2986            z: self.z,
2987            w: self.y,
2988        }
2989    }
2990
2991    /// Returns a swizzled vector.
2992    pub fn zyzz(&self) -> Float4 {
2993        Float4 {
2994            x: self.z,
2995            y: self.y,
2996            z: self.z,
2997            w: self.z,
2998        }
2999    }
3000
3001    /// Returns a swizzled vector.
3002    pub fn zyzw(&self) -> Float4 {
3003        Float4 {
3004            x: self.z,
3005            y: self.y,
3006            z: self.z,
3007            w: self.w,
3008        }
3009    }
3010
3011    /// Returns a swizzled vector.
3012    pub fn zywx(&self) -> Float4 {
3013        Float4 {
3014            x: self.z,
3015            y: self.y,
3016            z: self.w,
3017            w: self.x,
3018        }
3019    }
3020
3021    /// Returns a swizzled vector.
3022    pub fn zywy(&self) -> Float4 {
3023        Float4 {
3024            x: self.z,
3025            y: self.y,
3026            z: self.w,
3027            w: self.y,
3028        }
3029    }
3030
3031    /// Returns a swizzled vector.
3032    pub fn zywz(&self) -> Float4 {
3033        Float4 {
3034            x: self.z,
3035            y: self.y,
3036            z: self.w,
3037            w: self.z,
3038        }
3039    }
3040
3041    /// Returns a swizzled vector.
3042    pub fn zyww(&self) -> Float4 {
3043        Float4 {
3044            x: self.z,
3045            y: self.y,
3046            z: self.w,
3047            w: self.w,
3048        }
3049    }
3050
3051    /// Returns a swizzled vector.
3052    pub fn zzxx(&self) -> Float4 {
3053        Float4 {
3054            x: self.z,
3055            y: self.z,
3056            z: self.x,
3057            w: self.x,
3058        }
3059    }
3060
3061    /// Returns a swizzled vector.
3062    pub fn zzxy(&self) -> Float4 {
3063        Float4 {
3064            x: self.z,
3065            y: self.z,
3066            z: self.x,
3067            w: self.y,
3068        }
3069    }
3070
3071    /// Returns a swizzled vector.
3072    pub fn zzxz(&self) -> Float4 {
3073        Float4 {
3074            x: self.z,
3075            y: self.z,
3076            z: self.x,
3077            w: self.z,
3078        }
3079    }
3080
3081    /// Returns a swizzled vector.
3082    pub fn zzxw(&self) -> Float4 {
3083        Float4 {
3084            x: self.z,
3085            y: self.z,
3086            z: self.x,
3087            w: self.w,
3088        }
3089    }
3090
3091    /// Returns a swizzled vector.
3092    pub fn zzyx(&self) -> Float4 {
3093        Float4 {
3094            x: self.z,
3095            y: self.z,
3096            z: self.y,
3097            w: self.x,
3098        }
3099    }
3100
3101    /// Returns a swizzled vector.
3102    pub fn zzyy(&self) -> Float4 {
3103        Float4 {
3104            x: self.z,
3105            y: self.z,
3106            z: self.y,
3107            w: self.y,
3108        }
3109    }
3110
3111    /// Returns a swizzled vector.
3112    pub fn zzyz(&self) -> Float4 {
3113        Float4 {
3114            x: self.z,
3115            y: self.z,
3116            z: self.y,
3117            w: self.z,
3118        }
3119    }
3120
3121    /// Returns a swizzled vector.
3122    pub fn zzyw(&self) -> Float4 {
3123        Float4 {
3124            x: self.z,
3125            y: self.z,
3126            z: self.y,
3127            w: self.w,
3128        }
3129    }
3130
3131    /// Returns a swizzled vector.
3132    pub fn zzzx(&self) -> Float4 {
3133        Float4 {
3134            x: self.z,
3135            y: self.z,
3136            z: self.z,
3137            w: self.x,
3138        }
3139    }
3140
3141    /// Returns a swizzled vector.
3142    pub fn zzzy(&self) -> Float4 {
3143        Float4 {
3144            x: self.z,
3145            y: self.z,
3146            z: self.z,
3147            w: self.y,
3148        }
3149    }
3150
3151    /// Returns a swizzled vector.
3152    pub fn zzzz(&self) -> Float4 {
3153        Float4 {
3154            x: self.z,
3155            y: self.z,
3156            z: self.z,
3157            w: self.z,
3158        }
3159    }
3160
3161    /// Returns a swizzled vector.
3162    pub fn zzzw(&self) -> Float4 {
3163        Float4 {
3164            x: self.z,
3165            y: self.z,
3166            z: self.z,
3167            w: self.w,
3168        }
3169    }
3170
3171    /// Returns a swizzled vector.
3172    pub fn zzwx(&self) -> Float4 {
3173        Float4 {
3174            x: self.z,
3175            y: self.z,
3176            z: self.w,
3177            w: self.x,
3178        }
3179    }
3180
3181    /// Returns a swizzled vector.
3182    pub fn zzwy(&self) -> Float4 {
3183        Float4 {
3184            x: self.z,
3185            y: self.z,
3186            z: self.w,
3187            w: self.y,
3188        }
3189    }
3190
3191    /// Returns a swizzled vector.
3192    pub fn zzwz(&self) -> Float4 {
3193        Float4 {
3194            x: self.z,
3195            y: self.z,
3196            z: self.w,
3197            w: self.z,
3198        }
3199    }
3200
3201    /// Returns a swizzled vector.
3202    pub fn zzww(&self) -> Float4 {
3203        Float4 {
3204            x: self.z,
3205            y: self.z,
3206            z: self.w,
3207            w: self.w,
3208        }
3209    }
3210
3211    /// Returns a swizzled vector.
3212    pub fn zwxx(&self) -> Float4 {
3213        Float4 {
3214            x: self.z,
3215            y: self.w,
3216            z: self.x,
3217            w: self.x,
3218        }
3219    }
3220
3221    /// Returns a swizzled vector.
3222    pub fn zwxy(&self) -> Float4 {
3223        Float4 {
3224            x: self.z,
3225            y: self.w,
3226            z: self.x,
3227            w: self.y,
3228        }
3229    }
3230
3231    /// Returns a swizzled vector.
3232    pub fn zwxz(&self) -> Float4 {
3233        Float4 {
3234            x: self.z,
3235            y: self.w,
3236            z: self.x,
3237            w: self.z,
3238        }
3239    }
3240
3241    /// Returns a swizzled vector.
3242    pub fn zwxw(&self) -> Float4 {
3243        Float4 {
3244            x: self.z,
3245            y: self.w,
3246            z: self.x,
3247            w: self.w,
3248        }
3249    }
3250
3251    /// Returns a swizzled vector.
3252    pub fn zwyx(&self) -> Float4 {
3253        Float4 {
3254            x: self.z,
3255            y: self.w,
3256            z: self.y,
3257            w: self.x,
3258        }
3259    }
3260
3261    /// Returns a swizzled vector.
3262    pub fn zwyy(&self) -> Float4 {
3263        Float4 {
3264            x: self.z,
3265            y: self.w,
3266            z: self.y,
3267            w: self.y,
3268        }
3269    }
3270
3271    /// Returns a swizzled vector.
3272    pub fn zwyz(&self) -> Float4 {
3273        Float4 {
3274            x: self.z,
3275            y: self.w,
3276            z: self.y,
3277            w: self.z,
3278        }
3279    }
3280
3281    /// Returns a swizzled vector.
3282    pub fn zwyw(&self) -> Float4 {
3283        Float4 {
3284            x: self.z,
3285            y: self.w,
3286            z: self.y,
3287            w: self.w,
3288        }
3289    }
3290
3291    /// Returns a swizzled vector.
3292    pub fn zwzx(&self) -> Float4 {
3293        Float4 {
3294            x: self.z,
3295            y: self.w,
3296            z: self.z,
3297            w: self.x,
3298        }
3299    }
3300
3301    /// Returns a swizzled vector.
3302    pub fn zwzy(&self) -> Float4 {
3303        Float4 {
3304            x: self.z,
3305            y: self.w,
3306            z: self.z,
3307            w: self.y,
3308        }
3309    }
3310
3311    /// Returns a swizzled vector.
3312    pub fn zwzz(&self) -> Float4 {
3313        Float4 {
3314            x: self.z,
3315            y: self.w,
3316            z: self.z,
3317            w: self.z,
3318        }
3319    }
3320
3321    /// Returns a swizzled vector.
3322    pub fn zwzw(&self) -> Float4 {
3323        Float4 {
3324            x: self.z,
3325            y: self.w,
3326            z: self.z,
3327            w: self.w,
3328        }
3329    }
3330
3331    /// Returns a swizzled vector.
3332    pub fn zwwx(&self) -> Float4 {
3333        Float4 {
3334            x: self.z,
3335            y: self.w,
3336            z: self.w,
3337            w: self.x,
3338        }
3339    }
3340
3341    /// Returns a swizzled vector.
3342    pub fn zwwy(&self) -> Float4 {
3343        Float4 {
3344            x: self.z,
3345            y: self.w,
3346            z: self.w,
3347            w: self.y,
3348        }
3349    }
3350
3351    /// Returns a swizzled vector.
3352    pub fn zwwz(&self) -> Float4 {
3353        Float4 {
3354            x: self.z,
3355            y: self.w,
3356            z: self.w,
3357            w: self.z,
3358        }
3359    }
3360
3361    /// Returns a swizzled vector.
3362    pub fn zwww(&self) -> Float4 {
3363        Float4 {
3364            x: self.z,
3365            y: self.w,
3366            z: self.w,
3367            w: self.w,
3368        }
3369    }
3370
3371    /// Returns a swizzled vector.
3372    pub fn wxxx(&self) -> Float4 {
3373        Float4 {
3374            x: self.w,
3375            y: self.x,
3376            z: self.x,
3377            w: self.x,
3378        }
3379    }
3380
3381    /// Returns a swizzled vector.
3382    pub fn wxxy(&self) -> Float4 {
3383        Float4 {
3384            x: self.w,
3385            y: self.x,
3386            z: self.x,
3387            w: self.y,
3388        }
3389    }
3390
3391    /// Returns a swizzled vector.
3392    pub fn wxxz(&self) -> Float4 {
3393        Float4 {
3394            x: self.w,
3395            y: self.x,
3396            z: self.x,
3397            w: self.z,
3398        }
3399    }
3400
3401    /// Returns a swizzled vector.
3402    pub fn wxxw(&self) -> Float4 {
3403        Float4 {
3404            x: self.w,
3405            y: self.x,
3406            z: self.x,
3407            w: self.w,
3408        }
3409    }
3410
3411    /// Returns a swizzled vector.
3412    pub fn wxyx(&self) -> Float4 {
3413        Float4 {
3414            x: self.w,
3415            y: self.x,
3416            z: self.y,
3417            w: self.x,
3418        }
3419    }
3420
3421    /// Returns a swizzled vector.
3422    pub fn wxyy(&self) -> Float4 {
3423        Float4 {
3424            x: self.w,
3425            y: self.x,
3426            z: self.y,
3427            w: self.y,
3428        }
3429    }
3430
3431    /// Returns a swizzled vector.
3432    pub fn wxyz(&self) -> Float4 {
3433        Float4 {
3434            x: self.w,
3435            y: self.x,
3436            z: self.y,
3437            w: self.z,
3438        }
3439    }
3440
3441    /// Returns a swizzled vector.
3442    pub fn wxyw(&self) -> Float4 {
3443        Float4 {
3444            x: self.w,
3445            y: self.x,
3446            z: self.y,
3447            w: self.w,
3448        }
3449    }
3450
3451    /// Returns a swizzled vector.
3452    pub fn wxzx(&self) -> Float4 {
3453        Float4 {
3454            x: self.w,
3455            y: self.x,
3456            z: self.z,
3457            w: self.x,
3458        }
3459    }
3460
3461    /// Returns a swizzled vector.
3462    pub fn wxzy(&self) -> Float4 {
3463        Float4 {
3464            x: self.w,
3465            y: self.x,
3466            z: self.z,
3467            w: self.y,
3468        }
3469    }
3470
3471    /// Returns a swizzled vector.
3472    pub fn wxzz(&self) -> Float4 {
3473        Float4 {
3474            x: self.w,
3475            y: self.x,
3476            z: self.z,
3477            w: self.z,
3478        }
3479    }
3480
3481    /// Returns a swizzled vector.
3482    pub fn wxzw(&self) -> Float4 {
3483        Float4 {
3484            x: self.w,
3485            y: self.x,
3486            z: self.z,
3487            w: self.w,
3488        }
3489    }
3490
3491    /// Returns a swizzled vector.
3492    pub fn wxwx(&self) -> Float4 {
3493        Float4 {
3494            x: self.w,
3495            y: self.x,
3496            z: self.w,
3497            w: self.x,
3498        }
3499    }
3500
3501    /// Returns a swizzled vector.
3502    pub fn wxwy(&self) -> Float4 {
3503        Float4 {
3504            x: self.w,
3505            y: self.x,
3506            z: self.w,
3507            w: self.y,
3508        }
3509    }
3510
3511    /// Returns a swizzled vector.
3512    pub fn wxwz(&self) -> Float4 {
3513        Float4 {
3514            x: self.w,
3515            y: self.x,
3516            z: self.w,
3517            w: self.z,
3518        }
3519    }
3520
3521    /// Returns a swizzled vector.
3522    pub fn wxww(&self) -> Float4 {
3523        Float4 {
3524            x: self.w,
3525            y: self.x,
3526            z: self.w,
3527            w: self.w,
3528        }
3529    }
3530
3531    /// Returns a swizzled vector.
3532    pub fn wyxx(&self) -> Float4 {
3533        Float4 {
3534            x: self.w,
3535            y: self.y,
3536            z: self.x,
3537            w: self.x,
3538        }
3539    }
3540
3541    /// Returns a swizzled vector.
3542    pub fn wyxy(&self) -> Float4 {
3543        Float4 {
3544            x: self.w,
3545            y: self.y,
3546            z: self.x,
3547            w: self.y,
3548        }
3549    }
3550
3551    /// Returns a swizzled vector.
3552    pub fn wyxz(&self) -> Float4 {
3553        Float4 {
3554            x: self.w,
3555            y: self.y,
3556            z: self.x,
3557            w: self.z,
3558        }
3559    }
3560
3561    /// Returns a swizzled vector.
3562    pub fn wyxw(&self) -> Float4 {
3563        Float4 {
3564            x: self.w,
3565            y: self.y,
3566            z: self.x,
3567            w: self.w,
3568        }
3569    }
3570
3571    /// Returns a swizzled vector.
3572    pub fn wyyx(&self) -> Float4 {
3573        Float4 {
3574            x: self.w,
3575            y: self.y,
3576            z: self.y,
3577            w: self.x,
3578        }
3579    }
3580
3581    /// Returns a swizzled vector.
3582    pub fn wyyy(&self) -> Float4 {
3583        Float4 {
3584            x: self.w,
3585            y: self.y,
3586            z: self.y,
3587            w: self.y,
3588        }
3589    }
3590
3591    /// Returns a swizzled vector.
3592    pub fn wyyz(&self) -> Float4 {
3593        Float4 {
3594            x: self.w,
3595            y: self.y,
3596            z: self.y,
3597            w: self.z,
3598        }
3599    }
3600
3601    /// Returns a swizzled vector.
3602    pub fn wyyw(&self) -> Float4 {
3603        Float4 {
3604            x: self.w,
3605            y: self.y,
3606            z: self.y,
3607            w: self.w,
3608        }
3609    }
3610
3611    /// Returns a swizzled vector.
3612    pub fn wyzx(&self) -> Float4 {
3613        Float4 {
3614            x: self.w,
3615            y: self.y,
3616            z: self.z,
3617            w: self.x,
3618        }
3619    }
3620
3621    /// Returns a swizzled vector.
3622    pub fn wyzy(&self) -> Float4 {
3623        Float4 {
3624            x: self.w,
3625            y: self.y,
3626            z: self.z,
3627            w: self.y,
3628        }
3629    }
3630
3631    /// Returns a swizzled vector.
3632    pub fn wyzz(&self) -> Float4 {
3633        Float4 {
3634            x: self.w,
3635            y: self.y,
3636            z: self.z,
3637            w: self.z,
3638        }
3639    }
3640
3641    /// Returns a swizzled vector.
3642    pub fn wyzw(&self) -> Float4 {
3643        Float4 {
3644            x: self.w,
3645            y: self.y,
3646            z: self.z,
3647            w: self.w,
3648        }
3649    }
3650
3651    /// Returns a swizzled vector.
3652    pub fn wywx(&self) -> Float4 {
3653        Float4 {
3654            x: self.w,
3655            y: self.y,
3656            z: self.w,
3657            w: self.x,
3658        }
3659    }
3660
3661    /// Returns a swizzled vector.
3662    pub fn wywy(&self) -> Float4 {
3663        Float4 {
3664            x: self.w,
3665            y: self.y,
3666            z: self.w,
3667            w: self.y,
3668        }
3669    }
3670
3671    /// Returns a swizzled vector.
3672    pub fn wywz(&self) -> Float4 {
3673        Float4 {
3674            x: self.w,
3675            y: self.y,
3676            z: self.w,
3677            w: self.z,
3678        }
3679    }
3680
3681    /// Returns a swizzled vector.
3682    pub fn wyww(&self) -> Float4 {
3683        Float4 {
3684            x: self.w,
3685            y: self.y,
3686            z: self.w,
3687            w: self.w,
3688        }
3689    }
3690
3691    /// Returns a swizzled vector.
3692    pub fn wzxx(&self) -> Float4 {
3693        Float4 {
3694            x: self.w,
3695            y: self.z,
3696            z: self.x,
3697            w: self.x,
3698        }
3699    }
3700
3701    /// Returns a swizzled vector.
3702    pub fn wzxy(&self) -> Float4 {
3703        Float4 {
3704            x: self.w,
3705            y: self.z,
3706            z: self.x,
3707            w: self.y,
3708        }
3709    }
3710
3711    /// Returns a swizzled vector.
3712    pub fn wzxz(&self) -> Float4 {
3713        Float4 {
3714            x: self.w,
3715            y: self.z,
3716            z: self.x,
3717            w: self.z,
3718        }
3719    }
3720
3721    /// Returns a swizzled vector.
3722    pub fn wzxw(&self) -> Float4 {
3723        Float4 {
3724            x: self.w,
3725            y: self.z,
3726            z: self.x,
3727            w: self.w,
3728        }
3729    }
3730
3731    /// Returns a swizzled vector.
3732    pub fn wzyx(&self) -> Float4 {
3733        Float4 {
3734            x: self.w,
3735            y: self.z,
3736            z: self.y,
3737            w: self.x,
3738        }
3739    }
3740
3741    /// Returns a swizzled vector.
3742    pub fn wzyy(&self) -> Float4 {
3743        Float4 {
3744            x: self.w,
3745            y: self.z,
3746            z: self.y,
3747            w: self.y,
3748        }
3749    }
3750
3751    /// Returns a swizzled vector.
3752    pub fn wzyz(&self) -> Float4 {
3753        Float4 {
3754            x: self.w,
3755            y: self.z,
3756            z: self.y,
3757            w: self.z,
3758        }
3759    }
3760
3761    /// Returns a swizzled vector.
3762    pub fn wzyw(&self) -> Float4 {
3763        Float4 {
3764            x: self.w,
3765            y: self.z,
3766            z: self.y,
3767            w: self.w,
3768        }
3769    }
3770
3771    /// Returns a swizzled vector.
3772    pub fn wzzx(&self) -> Float4 {
3773        Float4 {
3774            x: self.w,
3775            y: self.z,
3776            z: self.z,
3777            w: self.x,
3778        }
3779    }
3780
3781    /// Returns a swizzled vector.
3782    pub fn wzzy(&self) -> Float4 {
3783        Float4 {
3784            x: self.w,
3785            y: self.z,
3786            z: self.z,
3787            w: self.y,
3788        }
3789    }
3790
3791    /// Returns a swizzled vector.
3792    pub fn wzzz(&self) -> Float4 {
3793        Float4 {
3794            x: self.w,
3795            y: self.z,
3796            z: self.z,
3797            w: self.z,
3798        }
3799    }
3800
3801    /// Returns a swizzled vector.
3802    pub fn wzzw(&self) -> Float4 {
3803        Float4 {
3804            x: self.w,
3805            y: self.z,
3806            z: self.z,
3807            w: self.w,
3808        }
3809    }
3810
3811    /// Returns a swizzled vector.
3812    pub fn wzwx(&self) -> Float4 {
3813        Float4 {
3814            x: self.w,
3815            y: self.z,
3816            z: self.w,
3817            w: self.x,
3818        }
3819    }
3820
3821    /// Returns a swizzled vector.
3822    pub fn wzwy(&self) -> Float4 {
3823        Float4 {
3824            x: self.w,
3825            y: self.z,
3826            z: self.w,
3827            w: self.y,
3828        }
3829    }
3830
3831    /// Returns a swizzled vector.
3832    pub fn wzwz(&self) -> Float4 {
3833        Float4 {
3834            x: self.w,
3835            y: self.z,
3836            z: self.w,
3837            w: self.z,
3838        }
3839    }
3840
3841    /// Returns a swizzled vector.
3842    pub fn wzww(&self) -> Float4 {
3843        Float4 {
3844            x: self.w,
3845            y: self.z,
3846            z: self.w,
3847            w: self.w,
3848        }
3849    }
3850
3851    /// Returns a swizzled vector.
3852    pub fn wwxx(&self) -> Float4 {
3853        Float4 {
3854            x: self.w,
3855            y: self.w,
3856            z: self.x,
3857            w: self.x,
3858        }
3859    }
3860
3861    /// Returns a swizzled vector.
3862    pub fn wwxy(&self) -> Float4 {
3863        Float4 {
3864            x: self.w,
3865            y: self.w,
3866            z: self.x,
3867            w: self.y,
3868        }
3869    }
3870
3871    /// Returns a swizzled vector.
3872    pub fn wwxz(&self) -> Float4 {
3873        Float4 {
3874            x: self.w,
3875            y: self.w,
3876            z: self.x,
3877            w: self.z,
3878        }
3879    }
3880
3881    /// Returns a swizzled vector.
3882    pub fn wwxw(&self) -> Float4 {
3883        Float4 {
3884            x: self.w,
3885            y: self.w,
3886            z: self.x,
3887            w: self.w,
3888        }
3889    }
3890
3891    /// Returns a swizzled vector.
3892    pub fn wwyx(&self) -> Float4 {
3893        Float4 {
3894            x: self.w,
3895            y: self.w,
3896            z: self.y,
3897            w: self.x,
3898        }
3899    }
3900
3901    /// Returns a swizzled vector.
3902    pub fn wwyy(&self) -> Float4 {
3903        Float4 {
3904            x: self.w,
3905            y: self.w,
3906            z: self.y,
3907            w: self.y,
3908        }
3909    }
3910
3911    /// Returns a swizzled vector.
3912    pub fn wwyz(&self) -> Float4 {
3913        Float4 {
3914            x: self.w,
3915            y: self.w,
3916            z: self.y,
3917            w: self.z,
3918        }
3919    }
3920
3921    /// Returns a swizzled vector.
3922    pub fn wwyw(&self) -> Float4 {
3923        Float4 {
3924            x: self.w,
3925            y: self.w,
3926            z: self.y,
3927            w: self.w,
3928        }
3929    }
3930
3931    /// Returns a swizzled vector.
3932    pub fn wwzx(&self) -> Float4 {
3933        Float4 {
3934            x: self.w,
3935            y: self.w,
3936            z: self.z,
3937            w: self.x,
3938        }
3939    }
3940
3941    /// Returns a swizzled vector.
3942    pub fn wwzy(&self) -> Float4 {
3943        Float4 {
3944            x: self.w,
3945            y: self.w,
3946            z: self.z,
3947            w: self.y,
3948        }
3949    }
3950
3951    /// Returns a swizzled vector.
3952    pub fn wwzz(&self) -> Float4 {
3953        Float4 {
3954            x: self.w,
3955            y: self.w,
3956            z: self.z,
3957            w: self.z,
3958        }
3959    }
3960
3961    /// Returns a swizzled vector.
3962    pub fn wwzw(&self) -> Float4 {
3963        Float4 {
3964            x: self.w,
3965            y: self.w,
3966            z: self.z,
3967            w: self.w,
3968        }
3969    }
3970
3971    /// Returns a swizzled vector.
3972    pub fn wwwx(&self) -> Float4 {
3973        Float4 {
3974            x: self.w,
3975            y: self.w,
3976            z: self.w,
3977            w: self.x,
3978        }
3979    }
3980
3981    /// Returns a swizzled vector.
3982    pub fn wwwy(&self) -> Float4 {
3983        Float4 {
3984            x: self.w,
3985            y: self.w,
3986            z: self.w,
3987            w: self.y,
3988        }
3989    }
3990
3991    /// Returns a swizzled vector.
3992    pub fn wwwz(&self) -> Float4 {
3993        Float4 {
3994            x: self.w,
3995            y: self.w,
3996            z: self.w,
3997            w: self.z,
3998        }
3999    }
4000
4001    /// Returns a swizzled vector.
4002    pub fn wwww(&self) -> Float4 {
4003        Float4 {
4004            x: self.w,
4005            y: self.w,
4006            z: self.w,
4007            w: self.w,
4008        }
4009    }
4010}
shadermath/math/float4.rs

shadermath/math/
float4.rs
