Repository: bitshifter/glam-rs
Pull request #94 (2020-11-13 02:56:24)

Expose names fields for non SIMD vectors and use Deref to emulate named fields for SIMD vectors


Patch:
diff --git a/benches/vec3a.rs b/benches/vec3a.rs
index de1c0b7..779c131 100644
--- a/benches/vec3a.rs
+++ b/benches/vec3a.rs
@@ -30,6 +30,11 @@ fn vec3a_to_rgb_op(v: Vec3A) -> u32 {
     ((red as u32) << 16 | (green as u32) << 8 | (blue as u32)).into()
 }
 
+#[inline]
+fn vec3a_deref(v: Vec3A) -> [f32; 3] {
+    [v.x, v.y, v.z]
+}
+
 #[inline]
 fn vec3a_accessors(v: Vec3A) -> [f32; 3] {
     [v.x(), v.y(), v.z()]
@@ -64,6 +69,13 @@ op => vec3a_to_rgb_op,
 from => random_vec3a
 );
 
+bench_func!(
+vec3a_to_array_deref,
+"vec3a into array deref",
+op => vec3a_deref,
+from => random_vec3a
+);
+
 bench_func!(
 vec3a_to_array_accessors,
 "vec3a into array slow",
@@ -103,6 +115,7 @@ criterion_group!(
     vec3a_euler,
     vec3a_to_rgb,
     vec3a_to_array_accessors,
+    vec3a_to_array_deref,
     vec3a_to_array_into,
     vec3a_to_tuple_into,
     vec3a_to_vec3,
diff --git a/build_all.sh b/build_all.sh
new file mode 100755
index 0000000..89f6051
--- /dev/null
+++ b/build_all.sh
@@ -0,0 +1,5 @@
+#!/bin/sh
+
+cargo test --features "bytemuck mint rand serde debug-glam-assert transform-types" && \
+cargo test --features "scalar-math bytemuck mint rand serde debug-glam-assert transform-types" && \
+cargo test --no-default-features --features "libm scalar-math bytemuck mint rand serde debug-glam-assert transform-types"
diff --git a/src/f32/funcs.rs b/src/f32/funcs.rs
index a5518d5..1d660f8 100644
--- a/src/f32/funcs.rs
+++ b/src/f32/funcs.rs
@@ -477,10 +477,10 @@ fn test_sse2_m128_sin() {
         let v = unsafe { Vec4(sse2::m128_sin(v.0)) };
         let a_sin = a.sin();
         // dbg!((a, a_sin, v));
-        assert_approx_eq!(v.x(), a_sin, 1e-6);
-        assert_approx_eq!(v.z(), a_sin, 1e-6);
-        assert_approx_eq!(v.y(), a_sin, 1e-6);
-        assert_approx_eq!(v.w(), a_sin, 1e-6);
+        assert_approx_eq!(v.x, a_sin, 1e-6);
+        assert_approx_eq!(v.z, a_sin, 1e-6);
+        assert_approx_eq!(v.y, a_sin, 1e-6);
+        assert_approx_eq!(v.w, a_sin, 1e-6);
     }
 
     let mut a = -PI;
diff --git a/src/f32/mat2.rs b/src/f32/mat2.rs
index 6f24d6c..d5d9d51 100644
--- a/src/f32/mat2.rs
+++ b/src/f32/mat2.rs
@@ -381,4 +381,4 @@ impl<'a> Product<&'a Self> for Mat2 {
     {
         iter.fold(IDENTITY, |a, &b| Self::mul(a, b))
     }
-}
\ No newline at end of file
+}
diff --git a/src/f32/mat3.rs b/src/f32/mat3.rs
index 56211b7..86f889f 100644
--- a/src/f32/mat3.rs
+++ b/src/f32/mat3.rs
@@ -332,9 +332,21 @@ impl Mat3 {
         // #[cfg(vec3a_f32)]
         {
             Self {
-                x_axis: Vec3::new(self.x_axis.0, self.y_axis.0, self.z_axis.0),
-                y_axis: Vec3::new(self.x_axis.1, self.y_axis.1, self.z_axis.1),
-                z_axis: Vec3::new(self.x_axis.2, self.y_axis.2, self.z_axis.2),
+                x_axis: Vec3 {
+                    x: self.x_axis.x,
+                    y: self.y_axis.x,
+                    z: self.z_axis.x,
+                },
+                y_axis: Vec3 {
+                    x: self.x_axis.y,
+                    y: self.y_axis.y,
+                    z: self.z_axis.y,
+                },
+                z_axis: Vec3 {
+                    x: self.x_axis.z,
+                    y: self.y_axis.z,
+                    z: self.z_axis.z,
+                },
             }
         }
     }
@@ -542,4 +554,4 @@ impl<'a> Product<&'a Self> for Mat3 {
     {
         iter.fold(IDENTITY, |a, &b| Self::mul(a, b))
     }
-}
\ No newline at end of file
+}
diff --git a/src/f32/mat4.rs b/src/f32/mat4.rs
index dd45ffc..c4f424c 100644
--- a/src/f32/mat4.rs
+++ b/src/f32/mat4.rs
@@ -715,14 +715,14 @@ impl Mat4 {
             };
 
             let col0 = Vec4::new(
-                inverse.x_axis.x(),
-                inverse.y_axis.x(),
-                inverse.z_axis.x(),
-                inverse.w_axis.x(),
+                inverse.x_axis.x,
+                inverse.y_axis.x,
+                inverse.z_axis.x,
+                inverse.w_axis.x,
             );
 
             let dot0 = self.x_axis * col0;
-            let dot1 = dot0.x() + dot0.y() + dot0.z() + dot0.w();
+            let dot1 = dot0.x + dot0.y + dot0.z + dot0.w;
 
             glam_assert!(dot1 != 0.0);
 
@@ -1154,4 +1154,4 @@ impl<'a> Product<&'a Self> for Mat4 {
     {
         iter.fold(IDENTITY, |a, &b| Self::mul(a, b))
     }
-}
\ No newline at end of file
+}
diff --git a/src/f32/mod.rs b/src/f32/mod.rs
index 104b5f6..56a0c32 100644
--- a/src/f32/mod.rs
+++ b/src/f32/mod.rs
@@ -40,6 +40,23 @@ pub use vec4::*;
 pub use vec4_mask::*;
 pub use vec4_swizzle::*;
 
+#[derive(Clone, Copy, Default, PartialEq, PartialOrd)]
+#[repr(C)]
+pub struct XYZW {
+    pub x: f32,
+    pub y: f32,
+    pub z: f32,
+    pub w: f32,
+}
+
+#[derive(Clone, Copy, Default, PartialEq, PartialOrd)]
+#[repr(C)]
+pub struct XYZ {
+    pub x: f32,
+    pub y: f32,
+    pub z: f32,
+}
+
 #[cfg(feature = "bytemuck")]
 mod glam_bytemuck;
 #[cfg(feature = "bytemuck")]
diff --git a/src/f32/quat.rs b/src/f32/quat.rs
index 1212572..b28db23 100644
--- a/src/f32/quat.rs
+++ b/src/f32/quat.rs
@@ -6,12 +6,13 @@ use core::arch::x86_64::*;
 use core::{
     cmp::Ordering,
     fmt,
-    ops::{Add, Div, Mul, MulAssign, Neg, Sub},
+    ops::{Add, Deref, DerefMut, Div, Mul, MulAssign, Neg, Sub},
 };
 
 #[cfg(feature = "std")]
 use std::iter::{Product, Sum};
 
+#[cfg(feature = "std")]
 const ZERO: Quat = const_quat!([0.0, 0.0, 0.0, 0.0]);
 const IDENTITY: Quat = const_quat!([0.0, 0.0, 0.0, 1.0]);
 
@@ -229,7 +230,7 @@ impl Quat {
 
         #[cfg(vec4_f32)]
         {
-            Self::from_xyzw(-(self.0).0, -(self.0).1, -(self.0).2, (self.0).3)
+            Self::from_xyzw(-self.0.x, -self.0.y, -self.0.z, self.0.w)
         }
     }
 
@@ -303,7 +304,7 @@ impl Quat {
         // If the quat.w is close to -1.0, the angle will be near 2*PI which is close to
         // a negative 0 rotation. By forcing quat.w to be positive, we'll end up with
         // the shortest path.
-        let positive_w_angle = scalar_acos(self.0.w().abs()) * 2.0;
+        let positive_w_angle = scalar_acos(self.0.w.abs()) * 2.0;
         positive_w_angle < THRESHOLD_ANGLE
     }
 
@@ -438,7 +439,7 @@ impl Quat {
         #[cfg(vec4_f32)]
         {
             let other = Vec3::from(other);
-            let w = self.0.w();
+            let w = self.0.w;
             let b = Vec3::from(self.0);
             let b2 = b.dot(b);
             Vec3A::from(
@@ -730,6 +731,21 @@ impl From<__m128> for Quat {
     }
 }
 
+impl Deref for Quat {
+    type Target = super::XYZW;
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        unsafe { &*(self as *const Self as *const Self::Target) }
+    }
+}
+
+impl DerefMut for Quat {
+    #[inline(always)]
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        unsafe { &mut *(self as *mut Self as *mut Self::Target) }
+    }
+}
+
 #[cfg(feature = "std")]
 impl<'a> Sum<&'a Self> for Quat {
     fn sum<I>(iter: I) -> Self
@@ -748,4 +764,4 @@ impl<'a> Product<&'a Self> for Quat {
     {
         iter.fold(IDENTITY, |a, &b| Self::mul(a, b))
     }
-}
\ No newline at end of file
+}
diff --git a/src/f32/vec2.rs b/src/f32/vec2.rs
index 76f91ed..559062f 100644
--- a/src/f32/vec2.rs
+++ b/src/f32/vec2.rs
@@ -10,14 +10,17 @@ const X_AXIS: Vec2 = const_vec2!([1.0, 0.0]);
 const Y_AXIS: Vec2 = const_vec2!([0.0, 1.0]);
 
 /// A 2-dimensional vector.
-#[derive(Clone, Copy, PartialEq, PartialOrd, Debug, Default)]
+#[derive(Clone, Copy, PartialEq, PartialOrd, Default)]
 #[repr(C)]
-pub struct Vec2(pub(crate) f32, pub(crate) f32);
+pub struct Vec2 {
+    pub x: f32,
+    pub y: f32,
+}
 
 /// Creates a `Vec2`.
 #[inline]
 pub fn vec2(x: f32, y: f32) -> Vec2 {
-    Vec2(x, y)
+    Vec2 { x, y }
 }
 
 impl Vec2 {
@@ -26,7 +29,7 @@ impl Vec2 {
     /// In other words, this computes `[x.is_nan(), y.is_nan()]`.
     #[inline]
     pub fn is_nan(self) -> Vec2Mask {
-        Vec2Mask::new(self.0.is_nan(), self.1.is_nan())
+        Vec2Mask::new(self.x.is_nan(), self.y.is_nan())
     }
 
     #[deprecated(since = "0.9.5", note = "please use `Vec2::signum` instead")]
@@ -42,7 +45,10 @@ impl Vec2 {
     /// - `NAN` if the number is `NAN`
     #[inline]
     pub fn signum(self) -> Self {
-        Self(self.0.signum(), self.1.signum())
+        Self {
+            x: self.x.signum(),
+            y: self.y.signum(),
+        }
     }
 
     #[deprecated(since = "0.9.5", note = "please use `Vec2::recip` instead")]
@@ -54,7 +60,10 @@ impl Vec2 {
     /// Returns a `Vec2` containing the reciprocal `1.0/n` of each element of `self`.
     #[inline]
     pub fn recip(self) -> Self {
-        Self(self.0.recip(), self.1.recip())
+        Self {
+            x: self.x.recip(),
+            y: self.y.recip(),
+        }
     }
 
     /// Performs a linear interpolation between `self` and `other` based on
@@ -92,7 +101,7 @@ impl Vec2 {
     /// Creates a new `Vec2`.
     #[inline]
     pub fn new(x: f32, y: f32) -> Vec2 {
-        Vec2(x, y)
+        Vec2 { x, y }
     }
 
     /// Creates a `Vec2` with all elements set to `0.0`.
@@ -122,55 +131,55 @@ impl Vec2 {
     /// Creates a `Vec2` with all elements set to `v`.
     #[inline]
     pub fn splat(v: f32) -> Vec2 {
-        Vec2(v, v)
+        Self { x: v, y: v }
     }
 
     /// Creates a `Vec3` from `self` and the given `z` value.
     #[inline]
     pub fn extend(self, z: f32) -> Vec3 {
-        Vec3::new(self.0, self.1, z)
+        Vec3::new(self.x, self.y, z)
     }
 
     /// Returns element `x`.
     #[inline]
     pub fn x(self) -> f32 {
-        self.0
+        self.x
     }
 
     /// Returns element `y`.
     #[inline]
     pub fn y(self) -> f32 {
-        self.1
+        self.y
     }
 
     /// Returns a mutable reference to element `x`.
     #[inline]
     pub fn x_mut(&mut self) -> &mut f32 {
-        &mut self.0
+        &mut self.x
     }
 
     /// Returns a mutable reference to element `y`.
     #[inline]
     pub fn y_mut(&mut self) -> &mut f32 {
-        &mut self.1
+        &mut self.y
     }
 
     /// Sets element `x`.
     #[inline]
     pub fn set_x(&mut self, x: f32) {
-        self.0 = x;
+        self.x = x;
     }
 
     /// Sets element `y`.
     #[inline]
     pub fn set_y(&mut self, y: f32) {
-        self.1 = y;
+        self.y = y;
     }
 
     /// Computes the dot product of `self` and `other`.
     #[inline]
     pub fn dot(self, other: Vec2) -> f32 {
-        (self.0 * other.0) + (self.1 * other.1)
+        (self.x * other.x) + (self.y * other.y)
     }
 
     /// Computes the length of `self`.
@@ -229,7 +238,10 @@ impl Vec2 {
     /// taking the minimum of each element individually.
     #[inline]
     pub fn min(self, other: Vec2) -> Vec2 {
-        Vec2(self.0.min(other.0), self.1.min(other.1))
+        Self {
+            x: self.x.min(other.x),
+            y: self.y.min(other.y),
+        }
     }
 
     /// Returns the vertical maximum of `self` and `other`.
@@ -239,7 +251,10 @@ impl Vec2 {
     /// taking the maximum of each element individually.
     #[inline]
     pub fn max(self, other: Vec2) -> Vec2 {
-        Vec2(self.0.max(other.0), self.1.max(other.1))
+        Self {
+            x: self.x.max(other.x),
+            y: self.y.max(other.y),
+        }
     }
 
     /// Returns the horizontal minimum of `self`'s elements.
@@ -247,7 +262,7 @@ impl Vec2 {
     /// In other words, this computes `min(x, y)`.
     #[inline]
     pub fn min_element(self) -> f32 {
-        self.0.min(self.1)
+        self.x.min(self.y)
     }
 
     /// Returns the horizontal maximum of `self`'s elements.
@@ -255,7 +270,7 @@ impl Vec2 {
     /// In other words, this computes `max(x, y)`.
     #[inline]
     pub fn max_element(self) -> f32 {
-        self.0.max(self.1)
+        self.x.max(self.y)
     }
 
     /// Performs a vertical `==` comparison between `self` and `other`,
@@ -264,7 +279,7 @@ impl Vec2 {
     /// In other words, this computes `[x1 == x2, y1 == y2]`.
     #[inline]
     pub fn cmpeq(self, other: Vec2) -> Vec2Mask {
-        Vec2Mask::new(self.0.eq(&other.0), self.1.eq(&other.1))
+        Vec2Mask::new(self.x.eq(&other.x), self.y.eq(&other.y))
     }
 
     /// Performs a vertical `!=` comparison between `self` and `other`,
@@ -273,7 +288,7 @@ impl Vec2 {
     /// In other words, this computes `[x1 != x2, y1 != y2]`.
     #[inline]
     pub fn cmpne(self, other: Vec2) -> Vec2Mask {
-        Vec2Mask::new(self.0.ne(&other.0), self.1.ne(&other.1))
+        Vec2Mask::new(self.x.ne(&other.x), self.y.ne(&other.y))
     }
 
     /// Performs a vertical `>=` comparison between `self` and `other`,
@@ -282,7 +297,7 @@ impl Vec2 {
     /// In other words, this computes `[x1 >= x2, y1 >= y2]`.
     #[inline]
     pub fn cmpge(self, other: Vec2) -> Vec2Mask {
-        Vec2Mask::new(self.0.ge(&other.0), self.1.ge(&other.1))
+        Vec2Mask::new(self.x.ge(&other.x), self.y.ge(&other.y))
     }
 
     /// Performs a vertical `>` comparison between `self` and `other`,
@@ -291,7 +306,7 @@ impl Vec2 {
     /// In other words, this computes `[x1 > x2, y1 > y2]`.
     #[inline]
     pub fn cmpgt(self, other: Vec2) -> Vec2Mask {
-        Vec2Mask::new(self.0.gt(&other.0), self.1.gt(&other.1))
+        Vec2Mask::new(self.x.gt(&other.x), self.y.gt(&other.y))
     }
 
     /// Performs a vertical `<=` comparison between `self` and `other`,
@@ -300,7 +315,7 @@ impl Vec2 {
     /// In other words, this computes `[x1 <= x2, y1 <= y2]`.
     #[inline]
     pub fn cmple(self, other: Vec2) -> Vec2Mask {
-        Vec2Mask::new(self.0.le(&other.0), self.1.le(&other.1))
+        Vec2Mask::new(self.x.le(&other.x), self.y.le(&other.y))
     }
 
     /// Performs a vertical `<` comparison between `self` and `other`,
@@ -309,7 +324,7 @@ impl Vec2 {
     /// In other words, this computes `[x1 < x2, y1 < y2]`.
     #[inline]
     pub fn cmplt(self, other: Vec2) -> Vec2Mask {
-        Vec2Mask::new(self.0.lt(&other.0), self.1.lt(&other.1))
+        Vec2Mask::new(self.x.lt(&other.x), self.y.lt(&other.y))
     }
 
     /// Creates a `Vec2` from the first two values in `slice`.
@@ -319,7 +334,10 @@ impl Vec2 {
     /// Panics if `slice` is less than two elements long.
     #[inline]
     pub fn from_slice_unaligned(slice: &[f32]) -> Self {
-        Self(slice[0], slice[1])
+        Self {
+            x: slice[0],
+            y: slice[1],
+        }
     }
 
     /// Writes the elements of `self` to the first two elements in `slice`.
@@ -329,41 +347,53 @@ impl Vec2 {
     /// Panics if `slice` is less than two elements long.
     #[inline]
     pub fn write_to_slice_unaligned(self, slice: &mut [f32]) {
-        slice[0] = self.0;
-        slice[1] = self.1;
+        slice[0] = self.x;
+        slice[1] = self.y;
     }
 
     /// Returns a `Vec2` containing the absolute value of each element of `self`.
     #[inline]
     pub fn abs(self) -> Self {
-        Self(self.0.abs(), self.1.abs())
+        Self {
+            x: self.x.abs(),
+            y: self.y.abs(),
+        }
     }
 
     /// Returns a `Vec2` containing the nearest integer to a number for each element of `self`.
     /// Round half-way cases away from 0.0.
     #[inline]
     pub fn round(self) -> Self {
-        Self(self.0.round(), self.1.round())
+        Self {
+            x: self.x.round(),
+            y: self.y.round(),
+        }
     }
 
     /// Returns a `Vec2` containing the largest integer less than or equal to a number for each
     /// element of `self`.
     #[inline]
     pub fn floor(self) -> Self {
-        Self(self.0.floor(), self.1.floor())
+        Self {
+            x: self.x.floor(),
+            y: self.y.floor(),
+        }
     }
 
     /// Returns a `Vec2` containing the smallest integer greater than or equal to a number for each
     /// element of `self`.
     #[inline]
     pub fn ceil(self) -> Self {
-        Self(self.0.ceil(), self.1.ceil())
+        Self {
+            x: self.x.ceil(),
+            y: self.y.ceil(),
+        }
     }
 
     /// The perpendicular dot product of the vector and `other`.
     #[inline]
     pub fn perp_dot(self, other: Vec2) -> f32 {
-        (self.0 * other.1) - (self.1 * other.0)
+        (self.x * other.y) - (self.y * other.x)
     }
 
     /// Returns the angle between two vectors, in radians.
@@ -386,7 +416,7 @@ impl Vec2 {
 
 impl fmt::Display for Vec2 {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "[{}, {}]", self.0, self.1)
+        write!(f, "[{}, {}]", self.x, self.y)
     }
 }
 
@@ -394,15 +424,18 @@ impl Div<Vec2> for Vec2 {
     type Output = Self;
     #[inline]
     fn div(self, other: Vec2) -> Self {
-        Self(self.0 / other.0, self.1 / other.1)
+        Self {
+            x: self.x / other.x,
+            y: self.y / other.y,
+        }
     }
 }
 
 impl DivAssign<Vec2> for Vec2 {
     #[inline]
     fn div_assign(&mut self, other: Vec2) {
-        self.0 /= other.0;
-        self.1 /= other.1;
+        self.x /= other.x;
+        self.y /= other.y;
     }
 }
 
@@ -410,15 +443,18 @@ impl Div<f32> for Vec2 {
     type Output = Self;
     #[inline]
     fn div(self, other: f32) -> Self {
-        Self(self.0 / other, self.1 / other)
+        Self {
+            x: self.x / other,
+            y: self.y / other,
+        }
     }
 }
 
 impl DivAssign<f32> for Vec2 {
     #[inline]
     fn div_assign(&mut self, other: f32) {
-        self.0 /= other;
-        self.1 /= other;
+        self.x /= other;
+        self.y /= other;
     }
 }
 
@@ -426,7 +462,10 @@ impl Div<Vec2> for f32 {
     type Output = Vec2;
     #[inline]
     fn div(self, other: Vec2) -> Vec2 {
-        Vec2(self / other.0, self / other.1)
+        Vec2 {
+            x: self / other.x,
+            y: self / other.y,
+        }
     }
 }
 
@@ -434,15 +473,18 @@ impl Mul<Vec2> for Vec2 {
     type Output = Self;
     #[inline]
     fn mul(self, other: Vec2) -> Self {
-        Self(self.0 * other.0, self.1 * other.1)
+        Self {
+            x: self.x * other.x,
+            y: self.y * other.y,
+        }
     }
 }
 
 impl MulAssign<Vec2> for Vec2 {
     #[inline]
     fn mul_assign(&mut self, other: Vec2) {
-        self.0 *= other.0;
-        self.1 *= other.1;
+        self.x *= other.x;
+        self.y *= other.y;
     }
 }
 
@@ -450,15 +492,18 @@ impl Mul<f32> for Vec2 {
     type Output = Self;
     #[inline]
     fn mul(self, other: f32) -> Self {
-        Self(self.0 * other, self.1 * other)
+        Self {
+            x: self.x * other,
+            y: self.y * other,
+        }
     }
 }
 
 impl MulAssign<f32> for Vec2 {
     #[inline]
     fn mul_assign(&mut self, other: f32) {
-        self.0 *= other;
-        self.1 *= other;
+        self.x *= other;
+        self.y *= other;
     }
 }
 
@@ -466,7 +511,10 @@ impl Mul<Vec2> for f32 {
     type Output = Vec2;
     #[inline]
     fn mul(self, other: Vec2) -> Vec2 {
-        Vec2(self * other.0, self * other.1)
+        Vec2 {
+            x: self * other.x,
+            y: self * other.y,
+        }
     }
 }
 
@@ -474,15 +522,18 @@ impl Add for Vec2 {
     type Output = Self;
     #[inline]
     fn add(self, other: Self) -> Self {
-        Self(self.0 + other.0, self.1 + other.1)
+        Self {
+            x: self.x + other.x,
+            y: self.y + other.y,
+        }
     }
 }
 
 impl AddAssign for Vec2 {
     #[inline]
     fn add_assign(&mut self, other: Self) {
-        self.0 += other.0;
-        self.1 += other.1;
+        self.x += other.x;
+        self.y += other.y;
     }
 }
 
@@ -490,15 +541,18 @@ impl Sub for Vec2 {
     type Output = Self;
     #[inline]
     fn sub(self, other: Vec2) -> Self {
-        Self(self.0 - other.0, self.1 - other.1)
+        Self {
+            x: self.x - other.x,
+            y: self.y - other.y,
+        }
     }
 }
 
 impl SubAssign for Vec2 {
     #[inline]
     fn sub_assign(&mut self, other: Vec2) {
-        self.0 -= other.0;
-        self.1 -= other.1;
+        self.x -= other.x;
+        self.y -= other.y;
     }
 }
 
@@ -506,7 +560,10 @@ impl Neg for Vec2 {
     type Output = Self;
     #[inline]
     fn neg(self) -> Self {
-        Self(-self.0, -self.1)
+        Self {
+            x: -self.x,
+            y: -self.y,
+        }
     }
 }
 
@@ -524,6 +581,15 @@ impl AsMut<[f32; 2]> for Vec2 {
     }
 }
 
+impl fmt::Debug for Vec2 {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        fmt.debug_tuple("Vec2")
+            .field(&self.x)
+            .field(&self.y)
+            .finish()
+    }
+}
+
 impl Index<usize> for Vec2 {
     type Output = f32;
     #[inline]
@@ -542,28 +608,28 @@ impl IndexMut<usize> for Vec2 {
 impl From<(f32, f32)> for Vec2 {
     #[inline]
     fn from(t: (f32, f32)) -> Self {
-        Self(t.0, t.1)
+        Self { x: t.0, y: t.1 }
     }
 }
 
 impl From<Vec2> for (f32, f32) {
     #[inline]
     fn from(v: Vec2) -> Self {
-        (v.0, v.1)
+        (v.x, v.y)
     }
 }
 
 impl From<[f32; 2]> for Vec2 {
     #[inline]
     fn from(a: [f32; 2]) -> Self {
-        Self(a[0], a[1])
+        Self { x: a[0], y: a[1] }
     }
 }
 
 impl From<Vec2> for [f32; 2] {
     #[inline]
     fn from(v: Vec2) -> Self {
-        [v.0, v.1]
+        [v.x, v.y]
     }
 }
 
diff --git a/src/f32/vec2_mask.rs b/src/f32/vec2_mask.rs
index fccf8e2..b393ee2 100644
--- a/src/f32/vec2_mask.rs
+++ b/src/f32/vec2_mask.rs
@@ -50,10 +50,10 @@ impl Vec2Mask {
     /// the element from `if_false`.
     #[inline]
     pub fn select(self, if_true: Vec2, if_false: Vec2) -> Vec2 {
-        Vec2(
-            if self.0 != 0 { if_true.0 } else { if_false.0 },
-            if self.1 != 0 { if_true.1 } else { if_false.1 },
-        )
+        Vec2 {
+            x: if self.0 != 0 { if_true.x } else { if_false.x },
+            y: if self.1 != 0 { if_true.y } else { if_false.y },
+        }
     }
 }
 
diff --git a/src/f32/vec2_swizzle.rs b/src/f32/vec2_swizzle.rs
index d237e73..2bee198 100644
--- a/src/f32/vec2_swizzle.rs
+++ b/src/f32/vec2_swizzle.rs
@@ -35,110 +35,151 @@ pub trait Vec2Swizzles {
 impl Vec2Swizzles for Vec2 {
     #[inline]
     fn xxxx(self) -> Vec4 {
-        Vec4::new(self.0, self.0, self.0, self.0)
+        Vec4::new(self.x, self.x, self.x, self.x)
     }
     #[inline]
     fn xxxy(self) -> Vec4 {
-        Vec4::new(self.0, self.0, self.0, self.1)
+        Vec4::new(self.x, self.x, self.x, self.y)
     }
     #[inline]
     fn xxyx(self) -> Vec4 {
-        Vec4::new(self.0, self.0, self.1, self.0)
+        Vec4::new(self.x, self.x, self.y, self.x)
     }
     #[inline]
     fn xxyy(self) -> Vec4 {
-        Vec4::new(self.0, self.0, self.1, self.1)
+        Vec4::new(self.x, self.x, self.y, self.y)
     }
     #[inline]
     fn xyxx(self) -> Vec4 {
-        Vec4::new(self.0, self.1, self.0, self.0)
+        Vec4::new(self.x, self.y, self.x, self.x)
     }
     #[inline]
     fn xyxy(self) -> Vec4 {
-        Vec4::new(self.0, self.1, self.0, self.1)
+        Vec4::new(self.x, self.y, self.x, self.y)
     }
     #[inline]
     fn xyyx(self) -> Vec4 {
-        Vec4::new(self.0, self.1, self.1, self.0)
+        Vec4::new(self.x, self.y, self.y, self.x)
     }
     #[inline]
     fn xyyy(self) -> Vec4 {
-        Vec4::new(self.0, self.1, self.1, self.1)
+        Vec4::new(self.x, self.y, self.y, self.y)
     }
     #[inline]
     fn yxxx(self) -> Vec4 {
-        Vec4::new(self.1, self.0, self.0, self.0)
+        Vec4::new(self.y, self.x, self.x, self.x)
     }
     #[inline]
     fn yxxy(self) -> Vec4 {
-        Vec4::new(self.1, self.0, self.0, self.1)
+        Vec4::new(self.y, self.x, self.x, self.y)
     }
     #[inline]
     fn yxyx(self) -> Vec4 {
-        Vec4::new(self.1, self.0, self.1, self.0)
+        Vec4::new(self.y, self.x, self.y, self.x)
     }
     #[inline]
     fn yxyy(self) -> Vec4 {
-        Vec4::new(self.1, self.0, self.1, self.1)
+        Vec4::new(self.y, self.x, self.y, self.y)
     }
     #[inline]
     fn yyxx(self) -> Vec4 {
-        Vec4::new(self.1, self.1, self.0, self.0)
+        Vec4::new(self.y, self.y, self.x, self.x)
     }
     #[inline]
     fn yyxy(self) -> Vec4 {
-        Vec4::new(self.1, self.1, self.0, self.1)
+        Vec4::new(self.y, self.y, self.x, self.y)
     }
     #[inline]
     fn yyyx(self) -> Vec4 {
-        Vec4::new(self.1, self.1, self.1, self.0)
+        Vec4::new(self.y, self.y, self.y, self.x)
     }
     #[inline]
     fn yyyy(self) -> Vec4 {
-        Vec4::new(self.1, self.1, self.1, self.1)
+        Vec4::new(self.y, self.y, self.y, self.y)
     }
     #[inline]
     fn xxx(self) -> Vec3 {
-        Vec3(self.0, self.0, self.0)
+        Vec3 {
+            x: self.x,
+            y: self.x,
+            z: self.x,
+        }
     }
     #[inline]
     fn xxy(self) -> Vec3 {
-        Vec3(self.0, self.0, self.1)
+        Vec3 {
+            x: self.x,
+            y: self.x,
+            z: self.y,
+        }
     }
     #[inline]
     fn xyx(self) -> Vec3 {
-        Vec3(self.0, self.1, self.0)
+        Vec3 {
+            x: self.x,
+            y: self.y,
+            z: self.x,
+        }
     }
     #[inline]
     fn xyy(self) -> Vec3 {
-        Vec3(self.0, self.1, self.1)
+        Vec3 {
+            x: self.x,
+            y: self.y,
+            z: self.y,
+        }
     }
     #[inline]
     fn yxx(self) -> Vec3 {
-        Vec3(self.1, self.0, self.0)
+        Vec3 {
+            x: self.y,
+            y: self.x,
+            z: self.x,
+        }
     }
     #[inline]
     fn yxy(self) -> Vec3 {
-        Vec3(self.1, self.0, self.1)
+        Vec3 {
+            x: self.y,
+            y: self.x,
+            z: self.y,
+        }
     }
     #[inline]
     fn yyx(self) -> Vec3 {
-        Vec3(self.1, self.1, self.0)
+        Vec3 {
+            x: self.y,
+            y: self.y,
+            z: self.x,
+        }
     }
     #[inline]
     fn yyy(self) -> Vec3 {
-        Vec3(self.1, self.1, self.1)
+        Vec3 {
+            x: self.y,
+            y: self.y,
+            z: self.y,
+        }
     }
     #[inline]
     fn xx(self) -> Vec2 {
-        Vec2(self.0, self.0)
+        Vec2 {
+            x: self.x,
+            y: self.x,
+        }
     }
     #[inline]
     fn yx(self) -> Vec2 {
-        Vec2(self.1, self.0)
+        Vec2 {
+            x: self.y,
+            y: self.x,
+        }
     }
     #[inline]
     fn yy(self) -> Vec2 {
-        Vec2(self.1, self.1)
+        Vec2 {
+            x: self.y,
+            y: self.y,
+        }
     }
 }
diff --git a/src/f32/vec3.rs b/src/f32/vec3.rs
index 3fe2411..8b639ac 100644
--- a/src/f32/vec3.rs
+++ b/src/f32/vec3.rs
@@ -11,9 +11,13 @@ const Y_AXIS: Vec3 = const_vec3!([0.0, 1.0, 0.0]);
 const Z_AXIS: Vec3 = const_vec3!([0.0, 0.0, 1.0]);
 
 /// A 3-dimensional vector without SIMD support.
-#[derive(Clone, Copy, PartialEq, PartialOrd, Debug, Default)]
+#[derive(Clone, Copy, PartialEq, PartialOrd, Default)]
 #[repr(C)]
-pub struct Vec3(pub(crate) f32, pub(crate) f32, pub(crate) f32);
+pub struct Vec3 {
+    pub x: f32,
+    pub y: f32,
+    pub z: f32,
+}
 
 /// Creates a `Vec3`.
 #[inline]
@@ -25,7 +29,7 @@ impl Vec3 {
     /// Creates a new `Vec3`.
     #[inline]
     pub fn new(x: f32, y: f32, z: f32) -> Self {
-        Self(x, y, z)
+        Self { x, y, z }
     }
 
     /// Creates a `Vec3` with all elements set to `0.0`.
@@ -61,13 +65,13 @@ impl Vec3 {
     /// Creates a `Vec3` with all elements set to `v`.
     #[inline]
     pub fn splat(v: f32) -> Self {
-        Self(v, v, v)
+        Self { x: v, y: v, z: v }
     }
 
     /// Creates a `Vec4` from `self` and the given `w` value.
     #[inline]
     pub fn extend(self, w: f32) -> Vec4 {
-        Vec4::new(self.0, self.1, self.2, w)
+        Vec4::new(self.x, self.y, self.z, w)
     }
 
     /// Creates a `Vec2` from the `x` and `y` elements of `self`, discarding `z`.
@@ -75,67 +79,67 @@ impl Vec3 {
     /// Truncation may also be performed by using `self.xy()` or `Vec2::from()`.
     #[inline]
     pub fn truncate(self) -> Vec2 {
-        Vec2::new(self.0, self.1)
+        Vec2::new(self.x, self.y)
     }
 
     /// Returns element `x`.
     #[inline]
     pub fn x(self) -> f32 {
-        self.0
+        self.x
     }
 
     /// Returns element `y`.
     #[inline]
     pub fn y(self) -> f32 {
-        self.1
+        self.y
     }
 
     /// Returns element `z`.
     #[inline]
     pub fn z(self) -> f32 {
-        self.2
+        self.z
     }
 
     /// Returns a mutable reference to element `x`.
     #[inline]
     pub fn x_mut(&mut self) -> &mut f32 {
-        &mut self.0
+        &mut self.x
     }
 
     /// Returns a mutable reference to element `y`.
     #[inline]
     pub fn y_mut(&mut self) -> &mut f32 {
-        &mut self.1
+        &mut self.y
     }
 
     /// Returns a mutable reference to element `z`.
     #[inline]
     pub fn z_mut(&mut self) -> &mut f32 {
-        &mut self.2
+        &mut self.z
     }
 
     /// Sets element `x`.
     #[inline]
     pub fn set_x(&mut self, x: f32) {
-        self.0 = x;
+        self.x = x;
     }
 
     /// Sets element `y`.
     #[inline]
     pub fn set_y(&mut self, y: f32) {
-        self.1 = y;
+        self.y = y;
     }
 
     /// Sets element `z`.
     #[inline]
     pub fn set_z(&mut self, z: f32) {
-        self.2 = z;
+        self.z = z;
     }
 
     /// Computes the dot product of `self` and `other`.
     #[inline]
     pub fn dot(self, other: Self) -> f32 {
-        (self.0 * other.0) + (self.1 * other.1) + (self.2 * other.2)
+        (self.x * other.x) + (self.y * other.y) + (self.z * other.z)
     }
 
     /// Returns Vec3 dot in all lanes of Vec3
@@ -149,11 +153,11 @@ impl Vec3 {
     /// Computes the cross product of `self` and `other`.
     #[inline]
     pub fn cross(self, other: Self) -> Self {
-        Self(
-            self.1 * other.2 - other.1 * self.2,
-            self.2 * other.0 - other.2 * self.0,
-            self.0 * other.1 - other.0 * self.1,
-        )
+        Self {
+            x: self.y * other.z - other.y * self.z,
+            y: self.z * other.x - other.z * self.x,
+            z: self.x * other.y - other.x * self.y,
+        }
     }
 
     /// Computes the length of `self`.
@@ -212,11 +216,11 @@ impl Vec3 {
     /// taking the minimum of each element individually.
     #[inline]
     pub fn min(self, other: Self) -> Self {
-        Self(
-            self.0.min(other.0),
-            self.1.min(other.1),
-            self.2.min(other.2),
-        )
+        Self {
+            x: self.x.min(other.x),
+            y: self.y.min(other.y),
+            z: self.z.min(other.z),
+        }
     }
 
     /// Returns the vertical maximum of `self` and `other`.
@@ -226,11 +230,11 @@ impl Vec3 {
     /// taking the maximum of each element individually.
     #[inline]
     pub fn max(self, other: Self) -> Self {
-        Self(
-            self.0.max(other.0),
-            self.1.max(other.1),
-            self.2.max(other.2),
-        )
+        Self {
+            x: self.x.max(other.x),
+            y: self.y.max(other.y),
+            z: self.z.max(other.z),
+        }
     }
 
     /// Returns the horizontal minimum of `self`'s elements.
@@ -238,7 +242,7 @@ impl Vec3 {
     /// In other words, this computes `min(x, y, z)`.
     #[inline]
     pub fn min_element(self) -> f32 {
-        self.0.min(self.1.min(self.2))
+        self.x.min(self.y.min(self.z))
     }
 
     /// Returns the horizontal maximum of `self`'s elements.
@@ -246,7 +250,7 @@ impl Vec3 {
     /// In other words, this computes `max(x, y, z)`.
     #[inline]
     pub fn max_element(self) -> f32 {
-        self.0.max(self.1.max(self.2))
+        self.x.max(self.y.max(self.z))
     }
 
     /// Performs a vertical `==` comparison between `self` and `other`,
@@ -256,9 +260,9 @@ impl Vec3 {
     #[inline]
     pub fn cmpeq(self, other: Self) -> Vec3Mask {
         Vec3Mask::new(
-            self.0.eq(&other.0),
-            self.1.eq(&other.1),
-            self.2.eq(&other.2),
+            self.x.eq(&other.x),
+            self.y.eq(&other.y),
+            self.z.eq(&other.z),
         )
     }
 
@@ -269,9 +273,9 @@ impl Vec3 {
     #[inline]
     pub fn cmpne(self, other: Self) -> Vec3Mask {
         Vec3Mask::new(
-            self.0.ne(&other.0),
-            self.1.ne(&other.1),
-            self.2.ne(&other.2),
+            self.x.ne(&other.x),
+            self.y.ne(&other.y),
+            self.z.ne(&other.z),
         )
     }
 
@@ -282,9 +286,9 @@ impl Vec3 {
     #[inline]
     pub fn cmpge(self, other: Self) -> Vec3Mask {
         Vec3Mask::new(
-            self.0.ge(&other.0),
-            self.1.ge(&other.1),
-            self.2.ge(&other.2),
+            self.x.ge(&other.x),
+            self.y.ge(&other.y),
+            self.z.ge(&other.z),
         )
     }
 
@@ -295,9 +299,9 @@ impl Vec3 {
     #[inline]
     pub fn cmpgt(self, other: Self) -> Vec3Mask {
         Vec3Mask::new(
-            self.0.gt(&other.0),
-            self.1.gt(&other.1),
-            self.2.gt(&other.2),
+            self.x.gt(&other.x),
+            self.y.gt(&other.y),
+            self.z.gt(&other.z),
         )
     }
 
@@ -308,9 +312,9 @@ impl Vec3 {
     #[inline]
     pub fn cmple(self, other: Self) -> Vec3Mask {
         Vec3Mask::new(
-            self.0.le(&other.0),
-            self.1.le(&other.1),
-            self.2.le(&other.2),
+            self.x.le(&other.x),
+            self.y.le(&other.y),
+            self.z.le(&other.z),
         )
     }
 
@@ -321,9 +325,9 @@ impl Vec3 {
     #[inline]
     pub fn cmplt(self, other: Self) -> Vec3Mask {
         Vec3Mask::new(
-            self.0.lt(&other.0),
-            self.1.lt(&other.1),
-            self.2.lt(&other.2),
+            self.x.lt(&other.x),
+            self.y.lt(&other.y),
+            self.z.lt(&other.z),
         )
     }
 
@@ -354,38 +358,54 @@ impl Vec3 {
     #[inline]
     #[allow(dead_code)]
     pub(crate) fn mul_add(self, a: Self, b: Self) -> Self {
-        Self(
-            (self.0 * a.0) + b.0,
-            (self.1 * a.1) + b.1,
-            (self.2 * a.2) + b.2,
-        )
+        Self {
+            x: (self.x * a.x) + b.x,
+            y: (self.y * a.y) + b.y,
+            z: (self.z * a.z) + b.z,
+        }
     }
 
     /// Returns a `Vec3` containing the absolute value of each element of `self`.
     #[inline]
     pub fn abs(self) -> Self {
-        Self(self.0.abs(), self.1.abs(), self.2.abs())
+        Self {
+            x: self.x.abs(),
+            y: self.y.abs(),
+            z: self.z.abs(),
+        }
     }
 
     /// Returns a `Vec3` containing the nearest integer to a number for each element of `self`.
     /// Round half-way cases away from 0.0.
     #[inline]
     pub fn round(self) -> Self {
-        Self(self.0.round(), self.1.round(), self.2.round())
+        Self {
+            x: self.x.round(),
+            y: self.y.round(),
+            z: self.z.round(),
+        }
     }
 
     /// Returns a `Vec3` containing the largest integer less than or equal to a number for each
     /// element of `self`.
     #[inline]
     pub fn floor(self) -> Self {
-        Self(self.0.floor(), self.1.floor(), self.2.floor())
+        Self {
+            x: self.x.floor(),
+            y: self.y.floor(),
+            z: self.z.floor(),
+        }
     }
 
     /// Returns a `Vec3` containing the smallest integer greater than or equal to a number for each
     /// element of `self`.
     #[inline]
     pub fn ceil(self) -> Self {
-        Self(self.0.ceil(), self.1.ceil(), self.2.ceil())
+        Self {
+            x: self.x.ceil(),
+            y: self.y.ceil(),
+            z: self.z.ceil(),
+        }
     }
 
     /// Performs `is_nan()` on each element of self, returning a `Vec3Mask` of the results.
@@ -393,7 +413,7 @@ impl Vec3 {
     /// In other words, this computes `[x.is_nan(), y.is_nan(), z.is_nan()]`.
     #[inline]
     pub fn is_nan(self) -> Vec3Mask {
-        Vec3Mask::new(self.0.is_nan(), self.1.is_nan(), self.2.is_nan())
+        Vec3Mask::new(self.x.is_nan(), self.y.is_nan(), self.z.is_nan())
     }
 
     #[deprecated(since = "0.9.5", note = "please use `Vec3::signum` instead")]
@@ -409,7 +429,11 @@ impl Vec3 {
     /// - `NAN` if the number is `NAN`
     #[inline]
     pub fn signum(self) -> Self {
-        Self(self.0.signum(), self.1.signum(), self.2.signum())
+        Self {
+            x: self.x.signum(),
+            y: self.y.signum(),
+            z: self.z.signum(),
+        }
     }
 
     #[deprecated(since = "0.9.5", note = "please use `Vec3::recip` instead")]
@@ -421,7 +445,11 @@ impl Vec3 {
     /// Returns a `Vec3` containing the reciprocal `1.0/n` of each element of `self`.
     #[inline]
     pub fn recip(self) -> Self {
-        Self(self.0.recip(), self.1.recip(), self.2.recip())
+        Self {
+            x: self.x.recip(),
+            y: self.y.recip(),
+            z: self.z.recip(),
+        }
     }
 
     /// Performs a linear interpolation between `self` and `other` based on
@@ -480,9 +508,19 @@ impl AsMut<[f32; 3]> for Vec3 {
     }
 }
 
+impl fmt::Debug for Vec3 {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        fmt.debug_tuple("Vec3")
+            .field(&self.x)
+            .field(&self.y)
+            .field(&self.z)
+            .finish()
+    }
+}
+
 impl fmt::Display for Vec3 {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "[{}, {}, {}]", self.0, self.1, self.2)
+        write!(f, "[{}, {}, {}]", self.x, self.y, self.z)
     }
 }
 
@@ -490,16 +528,20 @@ impl Div<Vec3> for Vec3 {
     type Output = Self;
     #[inline]
     fn div(self, other: Self) -> Self {
-        Self(self.0 / other.0, self.1 / other.1, self.2 / other.2)
+        Self {
+            x: self.x / other.x,
+            y: self.y / other.y,
+            z: self.z / other.z,
+        }
     }
 }
 
 impl DivAssign<Vec3> for Vec3 {
     #[inline]
     fn div_assign(&mut self, other: Self) {
-        self.0 /= other.0;
-        self.1 /= other.1;
-        self.2 /= other.2;
+        self.x /= other.x;
+        self.y /= other.y;
+        self.z /= other.z;
     }
 }
 
@@ -507,16 +549,20 @@ impl Div<f32> for Vec3 {
     type Output = Self;
     #[inline]
     fn div(self, other: f32) -> Self {
-        Self(self.0 / other, self.1 / other, self.2 / other)
+        Self {
+            x: self.x / other,
+            y: self.y / other,
+            z: self.z / other,
+        }
     }
 }
 
 impl DivAssign<f32> for Vec3 {
     #[inline]
     fn div_assign(&mut self, other: f32) {
-        self.0 /= other;
-        self.1 /= other;
-        self.2 /= other;
+        self.x /= other;
+        self.y /= other;
+        self.z /= other;
     }
 }
 
@@ -524,7 +570,11 @@ impl Div<Vec3> for f32 {
     type Output = Vec3;
     #[inline]
     fn div(self, other: Vec3) -> Vec3 {
-        Vec3(self / other.0, self / other.1, self / other.2)
+        Vec3 {
+            x: self / other.x,
+            y: self / other.y,
+            z: self / other.z,
+        }
     }
 }
 
@@ -532,16 +582,20 @@ impl Mul<Vec3> for Vec3 {
     type Output = Self;
     #[inline]
     fn mul(self, other: Self) -> Self {
-        Self(self.0 * other.0, self.1 * other.1, self.2 * other.2)
+        Self {
+            x: self.x * other.x,
+            y: self.y * other.y,
+            z: self.z * other.z,
+        }
     }
 }
 
 impl MulAssign<Vec3> for Vec3 {
     #[inline]
     fn mul_assign(&mut self, other: Self) {
-        self.0 *= other.0;
-        self.1 *= other.1;
-        self.2 *= other.2;
+        self.x *= other.x;
+        self.y *= other.y;
+        self.z *= other.z;
     }
 }
 
@@ -549,16 +603,20 @@ impl Mul<f32> for Vec3 {
     type Output = Self;
     #[inline]
     fn mul(self, other: f32) -> Self {
-        Self(self.0 * other, self.1 * other, self.2 * other)
+        Self {
+            x: self.x * other,
+            y: self.y * other,
+            z: self.z * other,
+        }
     }
 }
 
 impl MulAssign<f32> for Vec3 {
     #[inline]
     fn mul_assign(&mut self, other: f32) {
-        self.0 *= other;
-        self.1 *= other;
-        self.2 *= other;
+        self.x *= other;
+        self.y *= other;
+        self.z *= other;
     }
 }
 
@@ -566,7 +624,11 @@ impl Mul<Vec3> for f32 {
     type Output = Vec3;
     #[inline]
     fn mul(self, other: Vec3) -> Vec3 {
-        Vec3(self * other.0, self * other.1, self * other.2)
+        Vec3 {
+            x: self * other.x,
+            y: self * other.y,
+            z: self * other.z,
+        }
     }
 }
 
@@ -574,16 +636,20 @@ impl Add for Vec3 {
     type Output = Self;
     #[inline]
     fn add(self, other: Self) -> Self {
-        Self(self.0 + other.0, self.1 + other.1, self.2 + other.2)
+        Self {
+            x: self.x + other.x,
+            y: self.y + other.y,
+            z: self.z + other.z,
+        }
     }
 }
 
 impl AddAssign for Vec3 {
     #[inline]
     fn add_assign(&mut self, other: Self) {
-        self.0 += other.0;
-        self.1 += other.1;
-        self.2 += other.2;
+        self.x += other.x;
+        self.y += other.y;
+        self.z += other.z;
     }
 }
 
@@ -591,16 +657,20 @@ impl Sub for Vec3 {
     type Output = Self;
     #[inline]
     fn sub(self, other: Self) -> Self {
-        Self(self.0 - other.0, self.1 - other.1, self.2 - other.2)
+        Self {
+            x: self.x - other.x,
+            y: self.y - other.y,
+            z: self.z - other.z,
+        }
     }
 }
 
 impl SubAssign for Vec3 {
     #[inline]
     fn sub_assign(&mut self, other: Self) {
-        self.0 -= other.0;
-        self.1 -= other.1;
-        self.2 -= other.2;
+        self.x -= other.x;
+        self.y -= other.y;
+        self.z -= other.z;
     }
 }
 
@@ -608,7 +678,11 @@ impl Neg for Vec3 {
     type Output = Self;
     #[inline]
     fn neg(self) -> Self {
-        Self(-self.0, -self.1, -self.2)
+        Self {
+            x: -self.x,
+            y: -self.y,
+            z: -self.z,
+        }
     }
 }
 
@@ -637,7 +711,7 @@ impl From<(f32, f32, f32)> for Vec3 {
 impl From<Vec3> for (f32, f32, f32) {
     #[inline]
     fn from(v: Vec3) -> Self {
-        (v.0, v.1, v.2)
+        (v.x, v.y, v.z)
     }
 }
 
@@ -651,7 +725,7 @@ impl From<[f32; 3]> for Vec3 {
 impl From<Vec3> for [f32; 3] {
     #[inline]
     fn from(v: Vec3) -> Self {
-        [v.0, v.1, v.2]
+        [v.x, v.y, v.z]
     }
 }
 
@@ -661,7 +735,7 @@ impl From<Vec3A> for Vec3 {
         #[cfg(vec3a_sse2)]
         {
             let (x, y, z) = v.into();
-            Self(x, y, z)
+            Self { x, y, z }
         }
 
         #[cfg(vec3a_f32)]
@@ -675,7 +749,7 @@ impl From<Vec3> for Vec2 {
     /// Creates a `Vec2` from the `x` and `y` elements of the `Vec3`, discarding `z`.
     #[inline]
     fn from(v: Vec3) -> Self {
-        Vec2(v.0, v.1)
+        Vec2 { x: v.x, y: v.y }
     }
 }
 
@@ -705,4 +779,4 @@ impl<'a> Product<&'a Self> for Vec3 {
     {
         iter.fold(ONE, |a, &b| Self::mul(a, b))
     }
-}
\ No newline at end of file
+}
diff --git a/src/f32/vec3_mask.rs b/src/f32/vec3_mask.rs
index fafe4e2..7ce5aa6 100644
--- a/src/f32/vec3_mask.rs
+++ b/src/f32/vec3_mask.rs
@@ -53,11 +53,11 @@ impl Vec3Mask {
     pub fn select(self, if_true: Vec3, if_false: Vec3) -> Vec3 {
         // We are assuming that the mask values are either 0 or 0xff_ff_ff_ff for the SSE2 and f32
         // to behave the same here.
-        Vec3(
-            if self.0 != 0 { if_true.0 } else { if_false.0 },
-            if self.1 != 0 { if_true.1 } else { if_false.1 },
-            if self.2 != 0 { if_true.2 } else { if_false.2 },
-        )
+        Vec3 {
+            x: if self.0 != 0 { if_true.x } else { if_false.x },
+            y: if self.1 != 0 { if_true.y } else { if_false.y },
+            z: if self.2 != 0 { if_true.z } else { if_false.z },
+        }
     }
 }
 
diff --git a/src/f32/vec3_swizzle.rs b/src/f32/vec3_swizzle.rs
index 6312226..06cba0f 100644
--- a/src/f32/vec3_swizzle.rs
+++ b/src/f32/vec3_swizzle.rs
@@ -124,466 +124,597 @@ pub trait Vec3Swizzles {
 impl Vec3Swizzles for Vec3 {
     #[inline]
     fn xxxx(self) -> Vec4 {
-        Vec4::new(self.0, self.0, self.0, self.0)
+        Vec4::new(self.x, self.x, self.x, self.x)
     }
     #[inline]
     fn xxxy(self) -> Vec4 {
-        Vec4::new(self.0, self.0, self.0, self.1)
+        Vec4::new(self.x, self.x, self.x, self.y)
     }
     #[inline]
     fn xxxz(self) -> Vec4 {
-        Vec4::new(self.0, self.0, self.0, self.2)
+        Vec4::new(self.x, self.x, self.x, self.z)
     }
     #[inline]
     fn xxyx(self) -> Vec4 {
-        Vec4::new(self.0, self.0, self.1, self.0)
+        Vec4::new(self.x, self.x, self.y, self.x)
     }
     #[inline]
     fn xxyy(self) -> Vec4 {
-        Vec4::new(self.0, self.0, self.1, self.1)
+        Vec4::new(self.x, self.x, self.y, self.y)
     }
     #[inline]
     fn xxyz(self) -> Vec4 {
-        Vec4::new(self.0, self.0, self.1, self.2)
+        Vec4::new(self.x, self.x, self.y, self.z)
     }
     #[inline]
     fn xxzx(self) -> Vec4 {
-        Vec4::new(self.0, self.0, self.2, self.0)
+        Vec4::new(self.x, self.x, self.z, self.x)
     }
     #[inline]
     fn xxzy(self) -> Vec4 {
-        Vec4::new(self.0, self.0, self.2, self.1)
+        Vec4::new(self.x, self.x, self.z, self.y)
     }
     #[inline]
     fn xxzz(self) -> Vec4 {
-        Vec4::new(self.0, self.0, self.2, self.2)
+        Vec4::new(self.x, self.x, self.z, self.z)
     }
     #[inline]
     fn xyxx(self) -> Vec4 {
-        Vec4::new(self.0, self.1, self.0, self.0)
+        Vec4::new(self.x, self.y, self.x, self.x)
     }
     #[inline]
     fn xyxy(self) -> Vec4 {
-        Vec4::new(self.0, self.1, self.0, self.1)
+        Vec4::new(self.x, self.y, self.x, self.y)
     }
     #[inline]
     fn xyxz(self) -> Vec4 {
-        Vec4::new(self.0, self.1, self.0, self.2)
+        Vec4::new(self.x, self.y, self.x, self.z)
     }
     #[inline]
     fn xyyx(self) -> Vec4 {
-        Vec4::new(self.0, self.1, self.1, self.0)
+        Vec4::new(self.x, self.y, self.y, self.x)
     }
     #[inline]
     fn xyyy(self) -> Vec4 {
-        Vec4::new(self.0, self.1, self.1, self.1)
+        Vec4::new(self.x, self.y, self.y, self.y)
     }
     #[inline]
     fn xyyz(self) -> Vec4 {
-        Vec4::new(self.0, self.1, self.1, self.2)
+        Vec4::new(self.x, self.y, self.y, self.z)
     }
     #[inline]
     fn xyzx(self) -> Vec4 {
-        Vec4::new(self.0, self.1, self.2, self.0)
+        Vec4::new(self.x, self.y, self.z, self.x)
     }
     #[inline]
     fn xyzy(self) -> Vec4 {
-        Vec4::new(self.0, self.1, self.2, self.1)
+        Vec4::new(self.x, self.y, self.z, self.y)
     }
     #[inline]
     fn xyzz(self) -> Vec4 {
-        Vec4::new(self.0, self.1, self.2, self.2)
+        Vec4::new(self.x, self.y, self.z, self.z)
     }
     #[inline]
     fn xzxx(self) -> Vec4 {
-        Vec4::new(self.0, self.2, self.0, self.0)
+        Vec4::new(self.x, self.z, self.x, self.x)
     }
     #[inline]
     fn xzxy(self) -> Vec4 {
-        Vec4::new(self.0, self.2, self.0, self.1)
+        Vec4::new(self.x, self.z, self.x, self.y)
     }
     #[inline]
     fn xzxz(self) -> Vec4 {
-        Vec4::new(self.0, self.2, self.0, self.2)
+        Vec4::new(self.x, self.z, self.x, self.z)
     }
     #[inline]
     fn xzyx(self) -> Vec4 {
-        Vec4::new(self.0, self.2, self.1, self.0)
+        Vec4::new(self.x, self.z, self.y, self.x)
     }
     #[inline]
     fn xzyy(self) -> Vec4 {
-        Vec4::new(self.0, self.2, self.1, self.1)
+        Vec4::new(self.x, self.z, self.y, self.y)
     }
     #[inline]
     fn xzyz(self) -> Vec4 {
-        Vec4::new(self.0, self.2, self.1, self.2)
+        Vec4::new(self.x, self.z, self.y, self.z)
     }
     #[inline]
     fn xzzx(self) -> Vec4 {
-        Vec4::new(self.0, self.2, self.2, self.0)
+        Vec4::new(self.x, self.z, self.z, self.x)
     }
     #[inline]
     fn xzzy(self) -> Vec4 {
-        Vec4::new(self.0, self.2, self.2, self.1)
+        Vec4::new(self.x, self.z, self.z, self.y)
     }
     #[inline]
     fn xzzz(self) -> Vec4 {
-        Vec4::new(self.0, self.2, self.2, self.2)
+        Vec4::new(self.x, self.z, self.z, self.z)
     }
     #[inline]
     fn yxxx(self) -> Vec4 {
-        Vec4::new(self.1, self.0, self.0, self.0)
+        Vec4::new(self.y, self.x, self.x, self.x)
     }
     #[inline]
     fn yxxy(self) -> Vec4 {
-        Vec4::new(self.1, self.0, self.0, self.1)
+        Vec4::new(self.y, self.x, self.x, self.y)
     }
     #[inline]
     fn yxxz(self) -> Vec4 {
-        Vec4::new(self.1, self.0, self.0, self.2)
+        Vec4::new(self.y, self.x, self.x, self.z)
     }
     #[inline]
     fn yxyx(self) -> Vec4 {
-        Vec4::new(self.1, self.0, self.1, self.0)
+        Vec4::new(self.y, self.x, self.y, self.x)
     }
     #[inline]
     fn yxyy(self) -> Vec4 {
-        Vec4::new(self.1, self.0, self.1, self.1)
+        Vec4::new(self.y, self.x, self.y, self.y)
     }
     #[inline]
     fn yxyz(self) -> Vec4 {
-        Vec4::new(self.1, self.0, self.1, self.2)
+        Vec4::new(self.y, self.x, self.y, self.z)
     }
     #[inline]
     fn yxzx(self) -> Vec4 {
-        Vec4::new(self.1, self.0, self.2, self.0)
+        Vec4::new(self.y, self.x, self.z, self.x)
     }
     #[inline]
     fn yxzy(self) -> Vec4 {
-        Vec4::new(self.1, self.0, self.2, self.1)
+        Vec4::new(self.y, self.x, self.z, self.y)
     }
     #[inline]
     fn yxzz(self) -> Vec4 {
-        Vec4::new(self.1, self.0, self.2, self.2)
+        Vec4::new(self.y, self.x, self.z, self.z)
     }
     #[inline]
     fn yyxx(self) -> Vec4 {
-        Vec4::new(self.1, self.1, self.0, self.0)
+        Vec4::new(self.y, self.y, self.x, self.x)
     }
     #[inline]
     fn yyxy(self) -> Vec4 {
-        Vec4::new(self.1, self.1, self.0, self.1)
+        Vec4::new(self.y, self.y, self.x, self.y)
     }
     #[inline]
     fn yyxz(self) -> Vec4 {
-        Vec4::new(self.1, self.1, self.0, self.2)
+        Vec4::new(self.y, self.y, self.x, self.z)
     }
     #[inline]
     fn yyyx(self) -> Vec4 {
-        Vec4::new(self.1, self.1, self.1, self.0)
+        Vec4::new(self.y, self.y, self.y, self.x)
     }
     #[inline]
     fn yyyy(self) -> Vec4 {
-        Vec4::new(self.1, self.1, self.1, self.1)
+        Vec4::new(self.y, self.y, self.y, self.y)
     }
     #[inline]
     fn yyyz(self) -> Vec4 {
-        Vec4::new(self.1, self.1, self.1, self.2)
+        Vec4::new(self.y, self.y, self.y, self.z)
     }
     #[inline]
     fn yyzx(self) -> Vec4 {
-        Vec4::new(self.1, self.1, self.2, self.0)
+        Vec4::new(self.y, self.y, self.z, self.x)
     }
     #[inline]
     fn yyzy(self) -> Vec4 {
-        Vec4::new(self.1, self.1, self.2, self.1)
+        Vec4::new(self.y, self.y, self.z, self.y)
     }
     #[inline]
     fn yyzz(self) -> Vec4 {
-        Vec4::new(self.1, self.1, self.2, self.2)
+        Vec4::new(self.y, self.y, self.z, self.z)
     }
     #[inline]
     fn yzxx(self) -> Vec4 {
-        Vec4::new(self.1, self.2, self.0, self.0)
+        Vec4::new(self.y, self.z, self.x, self.x)
     }
     #[inline]
     fn yzxy(self) -> Vec4 {
-        Vec4::new(self.1, self.2, self.0, self.1)
+        Vec4::new(self.y, self.z, self.x, self.y)
     }
     #[inline]
     fn yzxz(self) -> Vec4 {
-        Vec4::new(self.1, self.2, self.0, self.2)
+        Vec4::new(self.y, self.z, self.x, self.z)
     }
     #[inline]
     fn yzyx(self) -> Vec4 {
-        Vec4::new(self.1, self.2, self.1, self.0)
+        Vec4::new(self.y, self.z, self.y, self.x)
     }
     #[inline]
     fn yzyy(self) -> Vec4 {
-        Vec4::new(self.1, self.2, self.1, self.1)
+        Vec4::new(self.y, self.z, self.y, self.y)
     }
     #[inline]
     fn yzyz(self) -> Vec4 {
-        Vec4::new(self.1, self.2, self.1, self.2)
+        Vec4::new(self.y, self.z, self.y, self.z)
     }
     #[inline]
     fn yzzx(self) -> Vec4 {
-        Vec4::new(self.1, self.2, self.2, self.0)
+        Vec4::new(self.y, self.z, self.z, self.x)
     }
     #[inline]
     fn yzzy(self) -> Vec4 {
-        Vec4::new(self.1, self.2, self.2, self.1)
+        Vec4::new(self.y, self.z, self.z, self.y)
     }
     #[inline]
     fn yzzz(self) -> Vec4 {
-        Vec4::new(self.1, self.2, self.2, self.2)
+        Vec4::new(self.y, self.z, self.z, self.z)
     }
     #[inline]
     fn zxxx(self) -> Vec4 {
-        Vec4::new(self.2, self.0, self.0, self.0)
+        Vec4::new(self.z, self.x, self.x, self.x)
     }
     #[inline]
     fn zxxy(self) -> Vec4 {
-        Vec4::new(self.2, self.0, self.0, self.1)
+        Vec4::new(self.z, self.x, self.x, self.y)
     }
     #[inline]
     fn zxxz(self) -> Vec4 {
-        Vec4::new(self.2, self.0, self.0, self.2)
+        Vec4::new(self.z, self.x, self.x, self.z)
     }
     #[inline]
     fn zxyx(self) -> Vec4 {
-        Vec4::new(self.2, self.0, self.1, self.0)
+        Vec4::new(self.z, self.x, self.y, self.x)
     }
     #[inline]
     fn zxyy(self) -> Vec4 {
-        Vec4::new(self.2, self.0, self.1, self.1)
+        Vec4::new(self.z, self.x, self.y, self.y)
     }
     #[inline]
     fn zxyz(self) -> Vec4 {
-        Vec4::new(self.2, self.0, self.1, self.2)
+        Vec4::new(self.z, self.x, self.y, self.z)
     }
     #[inline]
     fn zxzx(self) -> Vec4 {
-        Vec4::new(self.2, self.0, self.2, self.0)
+        Vec4::new(self.z, self.x, self.z, self.x)
     }
     #[inline]
     fn zxzy(self) -> Vec4 {
-        Vec4::new(self.2, self.0, self.2, self.1)
+        Vec4::new(self.z, self.x, self.z, self.y)
     }
     #[inline]
     fn zxzz(self) -> Vec4 {
-        Vec4::new(self.2, self.0, self.2, self.2)
+        Vec4::new(self.z, self.x, self.z, self.z)
     }
     #[inline]
     fn zyxx(self) -> Vec4 {
-        Vec4::new(self.2, self.1, self.0, self.0)
+        Vec4::new(self.z, self.y, self.x, self.x)
     }
     #[inline]
     fn zyxy(self) -> Vec4 {
-        Vec4::new(self.2, self.1, self.0, self.1)
+        Vec4::new(self.z, self.y, self.x, self.y)
     }
     #[inline]
     fn zyxz(self) -> Vec4 {
-        Vec4::new(self.2, self.1, self.0, self.2)
+        Vec4::new(self.z, self.y, self.x, self.z)
     }
     #[inline]
     fn zyyx(self) -> Vec4 {
-        Vec4::new(self.2, self.1, self.1, self.0)
+        Vec4::new(self.z, self.y, self.y, self.x)
     }
     #[inline]
     fn zyyy(self) -> Vec4 {
-        Vec4::new(self.2, self.1, self.1, self.1)
+        Vec4::new(self.z, self.y, self.y, self.y)
     }
     #[inline]
     fn zyyz(self) -> Vec4 {
-        Vec4::new(self.2, self.1, self.1, self.2)
+        Vec4::new(self.z, self.y, self.y, self.z)
     }
     #[inline]
     fn zyzx(self) -> Vec4 {
-        Vec4::new(self.2, self.1, self.2, self.0)
+        Vec4::new(self.z, self.y, self.z, self.x)
     }
     #[inline]
     fn zyzy(self) -> Vec4 {
-        Vec4::new(self.2, self.1, self.2, self.1)
+        Vec4::new(self.z, self.y, self.z, self.y)
     }
     #[inline]
     fn zyzz(self) -> Vec4 {
-        Vec4::new(self.2, self.1, self.2, self.2)
+        Vec4::new(self.z, self.y, self.z, self.z)
     }
     #[inline]
     fn zzxx(self) -> Vec4 {
-        Vec4::new(self.2, self.2, self.0, self.0)
+        Vec4::new(self.z, self.z, self.x, self.x)
     }
     #[inline]
     fn zzxy(self) -> Vec4 {
-        Vec4::new(self.2, self.2, self.0, self.1)
+        Vec4::new(self.z, self.z, self.x, self.y)
     }
     #[inline]
     fn zzxz(self) -> Vec4 {
-        Vec4::new(self.2, self.2, self.0, self.2)
+        Vec4::new(self.z, self.z, self.x, self.z)
     }
     #[inline]
     fn zzyx(self) -> Vec4 {
-        Vec4::new(self.2, self.2, self.1, self.0)
+        Vec4::new(self.z, self.z, self.y, self.x)
     }
     #[inline]
     fn zzyy(self) -> Vec4 {
-        Vec4::new(self.2, self.2, self.1, self.1)
+        Vec4::new(self.z, self.z, self.y, self.y)
     }
     #[inline]
     fn zzyz(self) -> Vec4 {
-        Vec4::new(self.2, self.2, self.1, self.2)
+        Vec4::new(self.z, self.z, self.y, self.z)
     }
     #[inline]
     fn zzzx(self) -> Vec4 {
-        Vec4::new(self.2, self.2, self.2, self.0)
+        Vec4::new(self.z, self.z, self.z, self.x)
     }
     #[inline]
     fn zzzy(self) -> Vec4 {
-        Vec4::new(self.2, self.2, self.2, self.1)
+        Vec4::new(self.z, self.z, self.z, self.y)
     }
     #[inline]
     fn zzzz(self) -> Vec4 {
-        Vec4::new(self.2, self.2, self.2, self.2)
+        Vec4::new(self.z, self.z, self.z, self.z)
     }
     #[inline]
     fn xxx(self) -> Vec3 {
-        Vec3(self.0, self.0, self.0)
+        Vec3 {
+            x: self.x,
+            y: self.x,
+            z: self.x,
+        }
     }
     #[inline]
     fn xxy(self) -> Vec3 {
-        Vec3(self.0, self.0, self.1)
+        Vec3 {
+            x: self.x,
+            y: self.x,
+            z: self.y,
+        }
     }
     #[inline]
     fn xxz(self) -> Vec3 {
-        Vec3(self.0, self.0, self.2)
+        Vec3 {
+            x: self.x,
+            y: self.x,
+            z: self.z,
+        }
     }
     #[inline]
     fn xyx(self) -> Vec3 {
-        Vec3(self.0, self.1, self.0)
+        Vec3 {
+            x: self.x,
+            y: self.y,
+            z: self.x,
+        }
     }
     #[inline]
     fn xyy(self) -> Vec3 {
-        Vec3(self.0, self.1, self.1)
+        Vec3 {
+            x: self.x,
+            y: self.y,
+            z: self.y,
+        }
     }
     #[inline]
     fn xzx(self) -> Vec3 {
-        Vec3(self.0, self.2, self.0)
+        Vec3 {
+            x: self.x,
+            y: self.z,
+            z: self.x,
+        }
     }
     #[inline]
     fn xzy(self) -> Vec3 {
-        Vec3(self.0, self.2, self.1)
+        Vec3 {
+            x: self.x,
+            y: self.z,
+            z: self.y,
+        }
     }
     #[inline]
     fn xzz(self) -> Vec3 {
-        Vec3(self.0, self.2, self.2)
+        Vec3 {
+            x: self.x,
+            y: self.z,
+            z: self.z,
+        }
     }
     #[inline]
     fn yxx(self) -> Vec3 {
-        Vec3(self.1, self.0, self.0)
+        Vec3 {
+            x: self.y,
+            y: self.x,
+            z: self.x,
+        }
     }
     #[inline]
     fn yxy(self) -> Vec3 {
-        Vec3(self.1, self.0, self.1)
+        Vec3 {
+            x: self.y,
+            y: self.x,
+            z: self.y,
+        }
     }
     #[inline]
     fn yxz(self) -> Vec3 {
-        Vec3(self.1, self.0, self.2)
+        Vec3 {
+            x: self.y,
+            y: self.x,
+            z: self.z,
+        }
     }
     #[inline]
     fn yyx(self) -> Vec3 {
-        Vec3(self.1, self.1, self.0)
+        Vec3 {
+            x: self.y,
+            y: self.y,
+            z: self.x,
+        }
     }
     #[inline]
     fn yyy(self) -> Vec3 {
-        Vec3(self.1, self.1, self.1)
+        Vec3 {
+            x: self.y,
+            y: self.y,
+            z: self.y,
+        }
     }
     #[inline]
     fn yyz(self) -> Vec3 {
-        Vec3(self.1, self.1, self.2)
+        Vec3 {
+            x: self.y,
+            y: self.y,
+            z: self.z,
+        }
     }
     #[inline]
     fn yzx(self) -> Vec3 {
-        Vec3(self.1, self.2, self.0)
+        Vec3 {
+            x: self.y,
+            y: self.z,
+            z: self.x,
+        }
     }
     #[inline]
     fn yzy(self) -> Vec3 {
-        Vec3(self.1, self.2, self.1)
+        Vec3 {
+            x: self.y,
+            y: self.z,
+            z: self.y,
+        }
     }
     #[inline]
     fn yzz(self) -> Vec3 {
-        Vec3(self.1, self.2, self.2)
+        Vec3 {
+            x: self.y,
+            y: self.z,
+            z: self.z,
+        }
     }
     #[inline]
     fn zxx(self) -> Vec3 {
-        Vec3(self.2, self.0, self.0)
+        Vec3 {
+            x: self.z,
+            y: self.x,
+            z: self.x,
+        }
     }
     #[inline]
     fn zxy(self) -> Vec3 {
-        Vec3(self.2, self.0, self.1)
+        Vec3 {
+            x: self.z,
+            y: self.x,
+            z: self.y,
+        }
     }
     #[inline]
     fn zxz(self) -> Vec3 {
-        Vec3(self.2, self.0, self.2)
+        Vec3 {
+            x: self.z,
+            y: self.x,
+            z: self.z,
+        }
     }
     #[inline]
     fn zyx(self) -> Vec3 {
-        Vec3(self.2, self.1, self.0)
+        Vec3 {
+            x: self.z,
+            y: self.y,
+            z: self.x,
+        }
     }
     #[inline]
     fn zyy(self) -> Vec3 {
-        Vec3(self.2, self.1, self.1)
+        Vec3 {
+            x: self.z,
+            y: self.y,
+            z: self.y,
+        }
     }
     #[inline]
     fn zyz(self) -> Vec3 {
-        Vec3(self.2, self.1, self.2)
+        Vec3 {
+            x: self.z,
+            y: self.y,
+            z: self.z,
+        }
     }
     #[inline]
     fn zzx(self) -> Vec3 {
-        Vec3(self.2, self.2, self.0)
+        Vec3 {
+            x: self.z,
+            y: self.z,
+            z: self.x,
+        }
     }
     #[inline]
     fn zzy(self) -> Vec3 {
-        Vec3(self.2, self.2, self.1)
+        Vec3 {
+            x: self.z,
+            y: self.z,
+            z: self.y,
+        }
     }
     #[inline]
     fn zzz(self) -> Vec3 {
-        Vec3(self.2, self.2, self.2)
+        Vec3 {
+            x: self.z,
+            y: self.z,
+            z: self.z,
+        }
     }
     #[inline]
     fn xx(self) -> Vec2 {
-        Vec2(self.0, self.0)
+        Vec2 {
+            x: self.x,
+            y: self.x,
+        }
     }
     #[inline]
     fn xy(self) -> Vec2 {
-        Vec2(self.0, self.1)
+        Vec2 {
+            x: self.x,
+            y: self.y,
+        }
     }
     #[inline]
     fn xz(self) -> Vec2 {
-        Vec2(self.0, self.2)
+        Vec2 {
+            x: self.x,
+            y: self.z,
+        }
     }
     #[inline]
     fn yx(self) -> Vec2 {
-        Vec2(self.1, self.0)
+        Vec2 {
+            x: self.y,
+            y: self.x,
+        }
     }
     #[inline]
     fn yy(self) -> Vec2 {
-        Vec2(self.1, self.1)
+        Vec2 {
+            x: self.y,
+            y: self.y,
+        }
     }
     #[inline]
     fn yz(self) -> Vec2 {
-        Vec2(self.1, self.2)
+        Vec2 {
+            x: self.y,
+            y: self.z,
+        }
     }
     #[inline]
     fn zx(self) -> Vec2 {
-        Vec2(self.2, self.0)
+        Vec2 {
+            x: self.z,
+            y: self.x,
+        }
     }
     #[inline]
     fn zy(self) -> Vec2 {
-        Vec2(self.2, self.1)
+        Vec2 {
+            x: self.z,
+            y: self.y,
+        }
     }
     #[inline]
     fn zz(self) -> Vec2 {
-        Vec2(self.2, self.2)
+        Vec2 {
+            x: self.z,
+            y: self.z,
+        }
     }
 }
diff --git a/src/f32/vec3a.rs b/src/f32/vec3a.rs
index 5b6ef6f..0282ba9 100644
--- a/src/f32/vec3a.rs
+++ b/src/f32/vec3a.rs
@@ -163,7 +163,7 @@ impl Vec3A {
         #[cfg(vec3a_sse2)]
         {
             let mut temp: Vec4 = self.0.into();
-            temp.set_w(w);
+            temp.w = w;
             temp
         }
 
@@ -1175,7 +1175,7 @@ impl From<Vec3A> for [f32; 3] {
 impl From<Vec3> for Vec3A {
     #[inline]
     fn from(v: Vec3) -> Self {
-        Vec3A::new(v.0, v.1, v.2)
+        Vec3A::new(v.x, v.y, v.z)
     }
 }
 
@@ -1200,6 +1200,21 @@ impl From<Vec3A> for Vec2 {
     }
 }
 
+impl Deref for Vec3A {
+    type Target = super::XYZ;
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        unsafe { &*(self as *const Self as *const Self::Target) }
+    }
+}
+
+impl DerefMut for Vec3A {
+    #[inline(always)]
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        unsafe { &mut *(self as *mut Self as *mut Self::Target) }
+    }
+}
+
 #[cfg(feature = "std")]
 impl<'a> Sum<&'a Self> for Vec3A {
     fn sum<I>(iter: I) -> Self
diff --git a/src/f32/vec3a_swizzle.rs b/src/f32/vec3a_swizzle.rs
index 02ef679..69d1d0a 100644
--- a/src/f32/vec3a_swizzle.rs
+++ b/src/f32/vec3a_swizzle.rs
@@ -140,7 +140,7 @@ impl Vec3ASwizzles for Vec3A {
 
         #[cfg(vec3a_f32)]
         {
-            Vec4((self.0).0, (self.0).0, (self.0).0, (self.0).0)
+            Vec4 { x: self.0.x(), y: self.0.x(), z: self.0.x(), w: self.0.x() }
         }
     }
     #[inline]
@@ -152,7 +152,7 @@ impl Vec3ASwizzles for Vec3A {
 
         #[cfg(vec3a_f32)]
         {
-            Vec4((self.0).0, (self.0).0, (self.0).0, (self.0).1)
+            Vec4 { x: self.0.x(), y: self.0.x(), z: self.0.x(), w: self.0.y() }
         }
     }
     #[inline]
@@ -164,7 +164,7 @@ impl Vec3ASwizzles for Vec3A {
 
         #[cfg(vec3a_f32)]
         {
-            Vec4((self.0).0, (self.0).0, (self.0).0, (self.0).2)
+            Vec4 { x: self.0.x(), y: self.0.x(), z: self.0.x(), w: self.0.z() }
         }
     }
     #[inline]
@@ -176,7 +176,7 @@ impl Vec3ASwizzles for Vec3A {
 
         #[cfg(vec3a_f32)]
         {
-            Vec4((self.0).0, (self.0).0, (self.0).1, (self.0).0)
+            Vec4 { x: self.0.x(), y: self.0.x(), z: self.0.y(), w: self.0.x() }
         }
     }
     #[inline]
@@ -188,7 +188,7 @@ impl Vec3ASwizzles for Vec3A {
 
         #[cfg(vec3a_f32)]
         {
-            Vec4((self.0).0, (self.0).0, (self.0).1, (self.0).1)
+            Vec4 { x: self.0.x(), y: self.0.x(), z: self.0.y(), w: self.0.y() }
         }
     }
     #[inline]
@@ -200,7 +200,7 @@ impl Vec3ASwizzles for Vec3A {
 
         #[cfg(vec3a_f32)]
         {
-            Vec4((self.0).0, (self.0).0, (self.0).1, (self.0).2)
+            Vec4 { x: self.0.x(), y: self.0.x(), z: self.0.y(), w: self.0.z() }
         }
     }
     #[inline]
@@ -212,7 +212,7 @@ impl Vec3ASwizzles for Vec3A {
 
         #[cfg(vec3a_f32)]
         {
-            Vec4((self.0).0, (self.0).0, (self.0).2, (self.0).0)
+            Vec4 { x: self.0.x(), y: self.0.x(), z: self.0.z(), w: self.0.x() }
         }
     }
     #[inline]
@@ -224,7 +224,7 @@ impl Vec3ASwizzles for Vec3A {
 
         #[cfg(vec3a_f32)]
         {
-            Vec4((self.0).0, (self.0).0, (self.0).2, (self.0).1)
+            Vec4 { x: self.0.x(), y: self.0.x(), z: self.0.z(), w: self.0.y() }
         }
     }
     #[inline]
@@ -236,7 +236,7 @@ impl Vec3ASwizzles for Vec3A {
 
         #[cfg(vec3a_f32)]
         {
-            Vec4((self.0).0, (self.0).0, (self.0).2, (self.0).2)
+            Vec4 { x: self.0.x(), y: self.0.x(), z: self.0.z(), w: self.0.z() }
         }
     }
     #[inline]
@@ -248,7 +248,7 @@ impl Vec3ASwizzles for Vec3A {
 
         #[cfg(vec3a_f32)]
         {
-            Vec4((self.0).0, (self.0).1, (self.0).0, (self.0).0)
+            Vec4 { x: self.0.x(), y: self.0.y(), z: self.0.x(), w: self.0.x() }
         }
     }
     #[inline]
@@ -260,7 +260,7 @@ impl Vec3ASwizzles for Vec3A {
 
         #[cfg(vec3a_f32)]
         {
-            Vec4((self.0).0, (self.0).1, (self.0).0, (self.0).1)
+            Vec4 { x: self.0.x(), y: self.0.y(), z: self.0.x(), w: self.0.y() }
         }
     }
     #[inline]
@@ -272,7 +272,7 @@ impl Vec3ASwizzles for Vec3A {
 
         #[cfg(vec3a_f32)]
         {
-            Vec4((self.0).0, (self.0).1, (self.0).0, (self.0).2)
+            Vec4 { x: self.0.x(), y: self.0.y(), z: self.0.x(), w: self.0.z() }
         }
     }
     #[inline]
@@ -284,7 +284,7 @@ impl Vec3ASwizzles for Vec3A {
 
         #[cfg(vec3a_f32)]
         {
-            Vec4((self.0).0, (self.0).1, (self.0).1, (self.0).0)
+            Vec4 { x: self.0.x(), y: self.0.y(), z: self.0.y(), w: self.0.x() }
         }
     }
     #[inline]
@@ -296,7 +296,7 @@ impl Vec3ASwizzles for Vec3A {
 
         #[cfg(vec3a_f32)]
         {
-            Vec4((self.0).0, (self.0).1, (self.0).1, (self.0).1)
+            Vec4 { x: self.0.x(), y: self.0.y(), z: self.0.y(), w: self.0.y() }
         }
     }
     #[inline]
@@ -308,7 +308,7 @@ impl Vec3ASwizzles for Vec3A {
 
         #[cfg(vec3a_f32)]
         {
-            Vec4((self.0).0, (self.0).1, (self.0).1, (self.0).2)
+            Vec4 { x: self.0.x(), y: self.0.y(), z: self.0.y(), w: self.0.z() }
         }
     }
     #[inline]
@@ -320,7 +320,7 @@ impl Vec3ASwizzles for Vec3A {
 
         #[cfg(vec3a_f32)]
         {
-            Vec4((self.0).0, (self.0).1, (self.0).2, (self.0).0)
+            Vec4 { x: self.0.x(), y: self.0.y(), z: self.0.z(), w: self.0.x() }
         }
     }
     #[inline]
@@ -332,7 +332,7 @@ impl Vec3ASwizzles for Vec3A {
 
         #[cfg(vec3a_f32)]
         {
-            Vec4((self.0).0, (self.0).1, (self.0).2, (self.0).1)
+            Vec4 { x: self.0.x(), y: self.0.y(), z: self.0.z(), w: self.0.y() }
         }
     }
     #[inline]
@@ -344,7 +344,7 @@ impl Vec3ASwizzles for Vec3A {
 
         #[cfg(vec3a_f32)]
         {
-            Vec4((self.0).0, (self.0).1, (self.0).2, (self.0).2)
+            Vec4 { x: self.0.x(), y: self.0.y(), z: self.0.z(), w: self.0.z() }
         }
     }
     #[inline]
@@ -356,7 +356,7 @@ impl Vec3ASwizzles for Vec3A {
 
         #[cfg(vec3a_f32)]
         {
-            Vec4((self.0).0, (self.0).2, (self.0).0, (self.0).0)
+            Vec4 { x: self.0.x(), y: self.0.z(), z: self.0.x(), w: self.0.x() }
         }
     }
     #[inline]
@@ -368,7 +368,7 @@ impl Vec3ASwizzles for Vec3A {
 
         #[cfg(vec3a_f32)]
         {
-            Vec4((self.0).0, (self.0).2, (self.0).0, (self.0).1)
+            Vec4 { x: self.0.x(), y: self.0.z(), z: self.0.x(), w: self.0.y() }
         }
     }
     #[inline]
@@ -380,7 +380,7 @@ impl Vec3ASwizzles for Vec3A {
 
         #[cfg(vec3a_f32)]
         {
-            Vec4((self.0).0, (self.0).2, (self.0).0, (self.0).2)
+            Vec4 { x: self.0.x(), y: self.0.z(), z: self.0.x(), w: self.0.z() }
         }
     }
     #[inline]
@@ -392,7 +392,7 @@ impl Vec3ASwizzles for Vec3A {
 
         #[cfg(vec3a_f32)]
         {
-            Vec4((self.0).0, (self.0).2, (self.0).1, (self.0).0)
+            Vec4 { x: self.0.x(), y: self.0.z(), z: self.0.y(), w: self.0.x() }
         }
     }
     #[inline]
@@ -404,7 +404,7 @@ impl Vec3ASwizzles for Vec3A {
 
         #[cfg(vec3a_f32)]
         {
-            Vec4((self.0).0, (self.0).2, (self.0).1, (self.0).1)
+            Vec4 { x: self.0.x(), y: self.0.z(), z: self.0.y(), w: self.0.y() }
         }
     }
     #[inline]
@@ -416,7 +416,7 @@ impl Vec3ASwizzles for Vec3A {
 
         #[cfg(vec3a_f32)]
         {
-            Vec4((self.0).0, (self.0).2, (self.0).1, (self.0).2)
+            Vec4 { x: self.0.x(), y: self.0.z(), z: self.0.y(), w: self.0.z() }
         }
     }
     #[inline]
@@ -428,7 +428,7 @@ impl Vec3ASwizzles for Vec3A {
 
         #[cfg(vec3a_f32)]
         {
-            Vec4((self.0).0, (self.0).2, (self.0).2, (self.0).0)
+            Vec4 { x: self.0.x(), y: self.0.z(), z: self.0.z(), w: self.0.x() }
         }
     }
     #[inline]
@@ -440,7 +440,7 @@ impl Vec3ASwizzles for Vec3A {
 
         #[cfg(vec3a_f32)]
         {
-            Vec4((self.0).0, (self.0).2, (self.0).2, (self.0).1)
+            Vec4 { x: self.0.x(), y: self.0.z(), z: self.0.z(), w: self.0.y() }
         }
     }
     #[inline]
@@ -452,7 +452,7 @@ impl Vec3ASwizzles for Vec3A {
 
         #[cfg(vec3a_f32)]
         {
-            Vec4((self.0).0, (self.0).2, (self.0).2, (self.0).2)
+            Vec4 { x: self.0.x(), y: self.0.z(), z: self.0.z(), w: self.0.z() }
         }
     }
     #[inline]
@@ -464,7 +464,7 @@ impl Vec3ASwizzles for Vec3A {
 
         #[cfg(vec3a_f32)]
         {
-            Vec4((self.0).1, (self.0).0, (self.0).0, (self.0).0)
+            Vec4 { x: self.0.y(), y: self.0.x(), z: self.0.x(), w: self.0.x() }
         }
     }
     #[inline]
@@ -476,7 +476,7 @@ impl Vec3ASwizzles for Vec3A {
 
         #[cfg(vec3a_f32)]
         {
-            Vec4((self.0).1, (self.0).0, (self.0).0, (self.0).1)
+            Vec4 { x: self.0.y(), y: self.0.x(), z: self.0.x(), w: self.0.y() }
         }
     }
     #[inline]
@@ -488,7 +488,7 @@ impl Vec3ASwizzles for Vec3A {
 
         #[cfg(vec3a_f32)]
         {
-            Vec4((self.0).1, (self.0).0, (self.0).0, (self.0).2)
+            Vec4 { x: self.0.y(), y: self.0.x(), z: self.0.x(), w: self.0.z() }
         }
     }
     #[inline]
@@ -500,7 +500,7 @@ impl Vec3ASwizzles for Vec3A {
 
         #[cfg(vec3a_f32)]
         {
-            Vec4((self.0).1, (self.0).0, (self.0).1, (self.0).0)
+            Vec4 { x: self.0.y(), y: self.0.x(), z: self.0.y(), w: self.0.x() }
         }
     }
     #[inline]
@@ -512,7 +512,7 @@ impl Vec3ASwizzles for Vec3A {
 
         #[cfg(vec3a_f32)]
         {
-            Vec4((self.0).1, (self.0).0, (self.0).1, (self.0).1)
+            Vec4 { x: self.0.y(), y: self.0.x(), z: self.0.y(), w: self.0.y() }
         }
     }
     #[inline]
@@ -524,7 +524,7 @@ impl Vec3ASwizzles for Vec3A {
 
         #[cfg(vec3a_f32)]
         {
-            Vec4((self.0).1, (self.0).0, (self.0).1, (self.0).2)
+            Vec4 { x: self.0.y(), y: self.0.x(), z: self.0.y(), w: self.0.z() }
         }
     }
     #[inline]
@@ -536,7 +536,7 @@ impl Vec3ASwizzles for Vec3A {
 
         #[cfg(vec3a_f32)]
         {
-            Vec4((self.0).1, (self.0).0, (self.0).2, (self.0).0)
+            Vec4 { x: self.0.y(), y: self.0.x(), z: self.0.z(), w: self.0.x() }
         }
     }
     #[inline]
@@ -548,7 +548,7 @@ impl Vec3ASwizzles for Vec3A {
 
         #[cfg(vec3a_f32)]
         {
-            Vec4((self.0).1, (self.0).0, (self.0).2, (self.0).1)
+            Vec4 { x: self.0.y(), y: self.0.x(), z: self.0.z(), w: self.0.y() }
         }
     }
     #[inline]
@@ -560,7 +560,7 @@ impl Vec3ASwizzles for Vec3A {
 
         #[cfg(vec3a_f32)]
         {
-            Vec4((self.0).1, (self.0).0, (self.0).2, (self.0).2)
+            Vec4 { x: self.0.y(), y: self.0.x(), z: self.0.z(), w: self.0.z() }
         }
     }
     #[inline]
@@ -572,7 +572,7 @@ impl Vec3ASwizzles for Vec3A {
 
         #[cfg(vec3a_f32)]
         {
-            Vec4((self.0).1, (self.0).1, (self.0).0, (self.0).0)
+            Vec4 { x: self.0.y(), y: self.0.y(), z: self.0.x(), w: self.0.x() }
         }
     }
     #[inline]
@@ -584,7 +584,7 @@ impl Vec3ASwizzles for Vec3A {
 
         #[cfg(vec3a_f32)]
         {
-            Vec4((self.0).1, (self.0).1, (self.0).0, (self.0).1)
+            Vec4 { x: self.0.y(), y: self.0.y(), z: self.0.x(), w: self.0.y() }
         }
     }
     #[inline]
@@ -596,7 +596,7 @@ impl Vec3ASwizzles for Vec3A {
 
         #[cfg(vec3a_f32)]
         {
-            Vec4((self.0).1, (self.0).1, (self.0).0, (self.0).2)
+            Vec4 { x: self.0.y(), y: self.0.y(), z: self.0.x(), w: self.0.z() }
         }
     }
     #[inline]
@@ -608,7 +608,7 @@ impl Vec3ASwizzles for Vec3A {
 
         #[cfg(vec3a_f32)]
         {
-            Vec4((self.0).1, (self.0).1, (self.0).1, (self.0).0)
+            Vec4 { x: self.0.y(), y: self.0.y(), z: self.0.y(), w: self.0.x() }
         }
     }
     #[inline]
@@ -620,7 +620,7 @@ impl Vec3ASwizzles for Vec3A {
 
         #[cfg(vec3a_f32)]
         {
-            Vec4((self.0).1, (self.0).1, (self.0).1, (self.0).1)
+            Vec4 { x: self.0.y(), y: self.0.y(), z: self.0.y(), w: self.0.y() }
         }
     }
     #[inline]
@@ -632,7 +632,7 @@ impl Vec3ASwizzles for Vec3A {
 
         #[cfg(vec3a_f32)]
         {
-            Vec4((self.0).1, (self.0).1, (self.0).1, (self.0).2)
+            Vec4 { x: self.0.y(), y: self.0.y(), z: self.0.y(), w: self.0.z() }
         }
     }
     #[inline]
@@ -644,7 +644,7 @@ impl Vec3ASwizzles for Vec3A {
 
         #[cfg(vec3a_f32)]
         {
-            Vec4((self.0).1, (self.0).1, (self.0).2, (self.0).0)
+            Vec4 { x: self.0.y(), y: self.0.y(), z: self.0.z(), w: self.0.x() }
         }
     }
     #[inline]
@@ -656,7 +656,7 @@ impl Vec3ASwizzles for Vec3A {
 
         #[cfg(vec3a_f32)]
         {
-            Vec4((self.0).1, (self.0).1, (self.0).2, (self.0).1)
+            Vec4 { x: self.0.y(), y: self.0.y(), z: self.0.z(), w: self.0.y() }
         }
     }
     #[inline]
@@ -668,7 +668,7 @@ impl Vec3ASwizzles for Vec3A {
 
         #[cfg(vec3a_f32)]
         {
-            Vec4((self.0).1, (self.0).1, (self.0).2, (self.0).2)
+            Vec4 { x: self.0.y(), y: self.0.y(), z: self.0.z(), w: self.0.z() }
         }
     }
     #[inline]
@@ -680,7 +680,7 @@ impl Vec3ASwizzles for Vec3A {
 
         #[cfg(vec3a_f32)]
         {
-            Vec4((self.0).1, (self.0).2, (self.0).0, (self.0).0)
+            Vec4 { x: self.0.y(), y: self.0.z(), z: self.0.x(), w: self.0.x() }
         }
     }
     #[inline]
@@ -692,7 +692,7 @@ impl Vec3ASwizzles for Vec3A {
 
         #[cfg(vec3a_f32)]
         {
-            Vec4((self.0).1, (self.0).2, (self.0).0, (self.0).1)
+            Vec4 { x: self.0.y(), y: self.0.z(), z: self.0.x(), w: self.0.y() }
         }
     }
     #[inline]
@@ -704,7 +704,7 @@ impl Vec3ASwizzles for Vec3A {
 
         #[cfg(vec3a_f32)]
         {
-            Vec4((self.0).1, (self.0).2, (self.0).0, (self.0).2)
+            Vec4 { x: self.0.y(), y: self.0.z(), z: self.0.x(), w: self.0.z() }
         }
     }
     #[inline]
@@ -716,7 +716,7 @@ impl Vec3ASwizzles for Vec3A {
 
         #[cfg(vec3a_f32)]
         {
-            Vec4((self.0).1, (self.0).2, (self.0).1, (self.0).0)
+            Vec4 { x: self.0.y(), y: self.0.z(), z: self.0.y(), w: self.0.x() }
         }
     }
     #[inline]
@@ -728,7 +728,7 @@ impl Vec3ASwizzles for Vec3A {
 
         #[cfg(vec3a_f32)]
         {
-            Vec4((self.0).1, (self.0).2, (self.0).1, (self.0).1)
+            Vec4 { x: self.0.y(), y: self.0.z(), z: self.0.y(), w: self.0.y() }
         }
     }
     #[inline]
@@ -740,7 +740,7 @@ impl Vec3ASwizzles for Vec3A {
 
         #[cfg(vec3a_f32)]
         {
-            Vec4((self.0).1, (self.0).2, (self.0).1, (self.0).2)
+            Vec4 { x: self.0.y(), y: self.0.z(), z: self.0.y(), w: self.0.z() }
         }
     }
     #[inline]
@@ -752,7 +752,7 @@ impl Vec3ASwizzles for Vec3A {
 
         #[cfg(vec3a_f32)]
         {
-            Vec4((self.0).1, (self.0).2, (self.0).2, (self.0).0)
+            Vec4 { x: self.0.y(), y: self.0.z(), z: self.0.z(), w: self.0.x() }
         }
     }
     #[inline]
@@ -764,7 +764,7 @@ impl Vec3ASwizzles for Vec3A {
 
         #[cfg(vec3a_f32)]
         {
-            Vec4((self.0).1, (self.0).2, (self.0).2, (self.0).1)
+            Vec4 { x: self.0.y(), y: self.0.z(), z: self.0.z(), w: self.0.y() }
         }
     }
     #[inline]
@@ -776,7 +776,7 @@ impl Vec3ASwizzles for Vec3A {
 
         #[cfg(vec3a_f32)]
         {
-            Vec4((self.0).1, (self.0).2, (self.0).2, (self.0).2)
+            Vec4 { x: self.0.y(), y: self.0.z(), z: self.0.z(), w: self.0.z() }
         }
     }
     #[inline]
@@ -788,7 +788,7 @@ impl Vec3ASwizzles for Vec3A {
 
         #[cfg(vec3a_f32)]
         {
-            Vec4((self.0).2, (self.0).0, (self.0).0, (self.0).0)
+            Vec4 { x: self.0.z(), y: self.0.x(), z: self.0.x(), w: self.0.x() }
         }
     }
     #[inline]
@@ -800,7 +800,7 @@ impl Vec3ASwizzles for Vec3A {
 
         #[cfg(vec3a_f32)]
         {
-            Vec4((self.0).2, (self.0).0, (self.0).0, (self.0).1)
+            Vec4 { x: self.0.z(), y: self.0.x(), z: self.0.x(), w: self.0.y() }
         }
     }
     #[inline]
@@ -812,7 +812,7 @@ impl Vec3ASwizzles for Vec3A {
 
         #[cfg(vec3a_f32)]
         {
-            Vec4((self.0).2, (self.0).0, (self.0).0, (self.0).2)
+            Vec4 { x: self.0.z(), y: self.0.x(), z: self.0.x(), w: self.0.z() }
         }
     }
     #[inline]
@@ -824,7 +824,7 @@ impl Vec3ASwizzles for Vec3A {
 
         #[cfg(vec3a_f32)]
         {
-            Vec4((self.0).2, (self.0).0, (self.0).1, (self.0).0)
+            Vec4 { x: self.0.z(), y: self.0.x(), z: self.0.y(), w: self.0.x() }
         }
     }
     #[inline]
@@ -836,7 +836,7 @@ impl Vec3ASwizzles for Vec3A {
 
         #[cfg(vec3a_f32)]
         {
-            Vec4((self.0).2, (self.0).0, (self.0).1, (self.0).1)
+            Vec4 { x: self.0.z(), y: self.0.x(), z: self.0.y(), w: self.0.y() }
         }
     }
     #[inline]
@@ -848,7 +848,7 @@ impl Vec3ASwizzles for Vec3A {
 
         #[cfg(vec3a_f32)]
         {
-            Vec4((self.0).2, (self.0).0, (self.0).1, (self.0).2)
+            Vec4 { x: self.0.z(), y: self.0.x(), z: self.0.y(), w: self.0.z() }
         }
     }
     #[inline]
@@ -860,7 +860,7 @@ impl Vec3ASwizzles for Vec3A {
 
         #[cfg(vec3a_f32)]
         {
-            Vec4((self.0).2, (self.0).0, (self.0).2, (self.0).0)
+            Vec4 { x: self.0.z(), y: self.0.x(), z: self.0.z(), w: self.0.x() }
         }
     }
     #[inline]
@@ -872,7 +872,7 @@ impl Vec3ASwizzles for Vec3A {
 
         #[cfg(vec3a_f32)]
         {
-            Vec4((self.0).2, (self.0).0, (self.0).2, (self.0).1)
+            Vec4 { x: self.0.z(), y: self.0.x(), z: self.0.z(), w: self.0.y() }
         }
     }
     #[inline]
@@ -884,7 +884,7 @@ impl Vec3ASwizzles for Vec3A {
 
         #[cfg(vec3a_f32)]
         {
-            Vec4((self.0).2, (self.0).0, (self.0).2, (self.0).2)
+            Vec4 { x: self.0.z(), y: self.0.x(), z: self.0.z(), w: self.0.z() }
         }
     }
     #[inline]
@@ -896,7 +896,7 @@ impl Vec3ASwizzles for Vec3A {
 
         #[cfg(vec3a_f32)]
         {
-            Vec4((self.0).2, (self.0).1, (self.0).0, (self.0).0)
+            Vec4 { x: self.0.z(), y: self.0.y(), z: self.0.x(), w: self.0.x() }
         }
     }
     #[inline]
@@ -908,7 +908,7 @@ impl Vec3ASwizzles for Vec3A {
 
         #[cfg(vec3a_f32)]
         {
-            Vec4((self.0).2, (self.0).1, (self.0).0, (self.0).1)
+            Vec4 { x: self.0.z(), y: self.0.y(), z: self.0.x(), w: self.0.y() }
         }
     }
     #[inline]
@@ -920,7 +920,7 @@ impl Vec3ASwizzles for Vec3A {
 
         #[cfg(vec3a_f32)]
         {
-            Vec4((self.0).2, (self.0).1, (self.0).0, (self.0).2)
+            Vec4 { x: self.0.z(), y: self.0.y(), z: self.0.x(), w: self.0.z() }
         }
     }
     #[inline]
@@ -932,7 +932,7 @@ impl Vec3ASwizzles for Vec3A {
 
         #[cfg(vec3a_f32)]
         {
-            Vec4((self.0).2, (self.0).1, (self.0).1, (self.0).0)
+            Vec4 { x: self.0.z(), y: self.0.y(), z: self.0.y(), w: self.0.x() }
         }
     }
     #[inline]
@@ -944,7 +944,7 @@ impl Vec3ASwizzles for Vec3A {
 
         #[cfg(vec3a_f32)]
         {
-            Vec4((self.0).2, (self.0).1, (self.0).1, (self.0).1)
+            Vec4 { x: self.0.z(), y: self.0.y(), z: self.0.y(), w: self.0.y() }
         }
     }
     #[inline]
@@ -956,7 +956,7 @@ impl Vec3ASwizzles for Vec3A {
 
         #[cfg(vec3a_f32)]
         {
-            Vec4((self.0).2, (self.0).1, (self.0).1, (self.0).2)
+            Vec4 { x: self.0.z(), y: self.0.y(), z: self.0.y(), w: self.0.z() }
         }
     }
     #[inline]
@@ -968,7 +968,7 @@ impl Vec3ASwizzles for Vec3A {
 
         #[cfg(vec3a_f32)]
         {
-            Vec4((self.0).2, (self.0).1, (self.0).2, (self.0).0)
+            Vec4 { x: self.0.z(), y: self.0.y(), z: self.0.z(), w: self.0.x() }
         }
     }
     #[inline]
@@ -980,7 +980,7 @@ impl Vec3ASwizzles for Vec3A {
 
         #[cfg(vec3a_f32)]
         {
-            Vec4((self.0).2, (self.0).1, (self.0).2, (self.0).1)
+            Vec4 { x: self.0.z(), y: self.0.y(), z: self.0.z(), w: self.0.y() }
         }
     }
     #[inline]
@@ -992,7 +992,7 @@ impl Vec3ASwizzles for Vec3A {
 
         #[cfg(vec3a_f32)]
         {
-            Vec4((self.0).2, (self.0).1, (self.0).2, (self.0).2)
+            Vec4 { x: self.0.z(), y: self.0.y(), z: self.0.z(), w: self.0.z() }
         }
     }
     #[inline]
@@ -1004,7 +1004,7 @@ impl Vec3ASwizzles for Vec3A {
 
         #[cfg(vec3a_f32)]
         {
-            Vec4((self.0).2, (self.0).2, (self.0).0, (self.0).0)
+            Vec4 { x: self.0.z(), y: self.0.z(), z: self.0.x(), w: self.0.x() }
         }
     }
     #[inline]
@@ -1016,7 +1016,7 @@ impl Vec3ASwizzles for Vec3A {
 
         #[cfg(vec3a_f32)]
         {
-            Vec4((self.0).2, (self.0).2, (self.0).0, (self.0).1)
+            Vec4 { x: self.0.z(), y: self.0.z(), z: self.0.x(), w: self.0.y() }
         }
     }
     #[inline]
@@ -1028,7 +1028,7 @@ impl Vec3ASwizzles for Vec3A {
 
         #[cfg(vec3a_f32)]
         {
-            Vec4((self.0).2, (self.0).2, (self.0).0, (self.0).2)
+            Vec4 { x: self.0.z(), y: self.0.z(), z: self.0.x(), w: self.0.z() }
         }
     }
     #[inline]
@@ -1040,7 +1040,7 @@ impl Vec3ASwizzles for Vec3A {
 
         #[cfg(vec3a_f32)]
         {
-            Vec4((self.0).2, (self.0).2, (self.0).1, (self.0).0)
+            Vec4 { x: self.0.z(), y: self.0.z(), z: self.0.y(), w: self.0.x() }
         }
     }
     #[inline]
@@ -1052,7 +1052,7 @@ impl Vec3ASwizzles for Vec3A {
 
         #[cfg(vec3a_f32)]
         {
-            Vec4((self.0).2, (self.0).2, (self.0).1, (self.0).1)
+            Vec4 { x: self.0.z(), y: self.0.z(), z: self.0.y(), w: self.0.y() }
         }
     }
     #[inline]
@@ -1064,7 +1064,7 @@ impl Vec3ASwizzles for Vec3A {
 
         #[cfg(vec3a_f32)]
         {
-            Vec4((self.0).2, (self.0).2, (self.0).1, (self.0).2)
+            Vec4 { x: self.0.z(), y: self.0.z(), z: self.0.y(), w: self.0.z() }
         }
     }
     #[inline]
@@ -1076,7 +1076,7 @@ impl Vec3ASwizzles for Vec3A {
 
         #[cfg(vec3a_f32)]
         {
-            Vec4((self.0).2, (self.0).2, (self.0).2, (self.0).0)
+            Vec4 { x: self.0.z(), y: self.0.z(), z: self.0.z(), w: self.0.x() }
         }
     }
     #[inline]
@@ -1088,7 +1088,7 @@ impl Vec3ASwizzles for Vec3A {
 
         #[cfg(vec3a_f32)]
         {
-            Vec4((self.0).2, (self.0).2, (self.0).2, (self.0).1)
+            Vec4 { x: self.0.z(), y: self.0.z(), z: self.0.z(), w: self.0.y() }
         }
     }
     #[inline]
@@ -1100,7 +1100,7 @@ impl Vec3ASwizzles for Vec3A {
 
         #[cfg(vec3a_f32)]
         {
-            Vec4((self.0).2, (self.0).2, (self.0).2, (self.0).2)
+            Vec4 { x: self.0.z(), y: self.0.z(), z: self.0.z(), w: self.0.z() }
         }
     }
     #[inline]
@@ -1112,7 +1112,7 @@ impl Vec3ASwizzles for Vec3A {
 
         #[cfg(vec3a_f32)]
         {
-            Vec3A(Vec3((self.0).0, (self.0).0, (self.0).0))
+            Vec3A(Vec3 { x: self.0.x(), y: self.0.x(), z: self.0.x() })
         }
     }
     #[inline]
@@ -1124,7 +1124,7 @@ impl Vec3ASwizzles for Vec3A {
 
         #[cfg(vec3a_f32)]
         {
-            Vec3A(Vec3((self.0).0, (self.0).0, (self.0).1))
+            Vec3A(Vec3 { x: self.0.x(), y: self.0.x(), z: self.0.y() })
         }
     }
     #[inline]
@@ -1136,7 +1136,7 @@ impl Vec3ASwizzles for Vec3A {
 
         #[cfg(vec3a_f32)]
         {
-            Vec3A(Vec3((self.0).0, (self.0).0, (self.0).2))
+            Vec3A(Vec3 { x: self.0.x(), y: self.0.x(), z: self.0.z() })
         }
     }
     #[inline]
@@ -1148,7 +1148,7 @@ impl Vec3ASwizzles for Vec3A {
 
         #[cfg(vec3a_f32)]
         {
-            Vec3A(Vec3((self.0).0, (self.0).1, (self.0).0))
+            Vec3A(Vec3 { x: self.0.x(), y: self.0.y(), z: self.0.x() })
         }
     }
     #[inline]
@@ -1160,7 +1160,7 @@ impl Vec3ASwizzles for Vec3A {
 
         #[cfg(vec3a_f32)]
         {
-            Vec3A(Vec3((self.0).0, (self.0).1, (self.0).1))
+            Vec3A(Vec3 { x: self.0.x(), y: self.0.y(), z: self.0.y() })
         }
     }
     #[inline]
@@ -1172,7 +1172,7 @@ impl Vec3ASwizzles for Vec3A {
 
         #[cfg(vec3a_f32)]
         {
-            Vec3A(Vec3((self.0).0, (self.0).2, (self.0).0))
+            Vec3A(Vec3 { x: self.0.x(), y: self.0.z(), z: self.0.x() })
         }
     }
     #[inline]
@@ -1184,7 +1184,7 @@ impl Vec3ASwizzles for Vec3A {
 
         #[cfg(vec3a_f32)]
         {
-            Vec3A(Vec3((self.0).0, (self.0).2, (self.0).1))
+            Vec3A(Vec3 { x: self.0.x(), y: self.0.z(), z: self.0.y() })
         }
     }
     #[inline]
@@ -1196,7 +1196,7 @@ impl Vec3ASwizzles for Vec3A {
 
         #[cfg(vec3a_f32)]
         {
-            Vec3A(Vec3((self.0).0, (self.0).2, (self.0).2))
+            Vec3A(Vec3 { x: self.0.x(), y: self.0.z(), z: self.0.z() })
         }
     }
     #[inline]
@@ -1208,7 +1208,7 @@ impl Vec3ASwizzles for Vec3A {
 
         #[cfg(vec3a_f32)]
         {
-            Vec3A(Vec3((self.0).1, (self.0).0, (self.0).0))
+            Vec3A(Vec3 { x: self.0.y(), y: self.0.x(), z: self.0.x() })
         }
     }
     #[inline]
@@ -1220,7 +1220,7 @@ impl Vec3ASwizzles for Vec3A {
 
         #[cfg(vec3a_f32)]
         {
-            Vec3A(Vec3((self.0).1, (self.0).0, (self.0).1))
+            Vec3A(Vec3 { x: self.0.y(), y: self.0.x(), z: self.0.y() })
         }
     }
     #[inline]
@@ -1232,7 +1232,7 @@ impl Vec3ASwizzles for Vec3A {
 
         #[cfg(vec3a_f32)]
         {
-            Vec3A(Vec3((self.0).1, (self.0).0, (self.0).2))
+            Vec3A(Vec3 { x: self.0.y(), y: self.0.x(), z: self.0.z() })
         }
     }
     #[inline]
@@ -1244,7 +1244,7 @@ impl Vec3ASwizzles for Vec3A {
 
         #[cfg(vec3a_f32)]
         {
-            Vec3A(Vec3((self.0).1, (self.0).1, (self.0).0))
+            Vec3A(Vec3 { x: self.0.y(), y: self.0.y(), z: self.0.x() })
         }
     }
     #[inline]
@@ -1256,7 +1256,7 @@ impl Vec3ASwizzles for Vec3A {
 
         #[cfg(vec3a_f32)]
         {
-            Vec3A(Vec3((self.0).1, (self.0).1, (self.0).1))
+            Vec3A(Vec3 { x: self.0.y(), y: self.0.y(), z: self.0.y() })
         }
     }
     #[inline]
@@ -1268,7 +1268,7 @@ impl Vec3ASwizzles for Vec3A {
 
         #[cfg(vec3a_f32)]
         {
-            Vec3A(Vec3((self.0).1, (self.0).1, (self.0).2))
+            Vec3A(Vec3 { x: self.0.y(), y: self.0.y(), z: self.0.z() })
         }
     }
     #[inline]
@@ -1280,7 +1280,7 @@ impl Vec3ASwizzles for Vec3A {
 
         #[cfg(vec3a_f32)]
         {
-            Vec3A(Vec3((self.0).1, (self.0).2, (self.0).0))
+            Vec3A(Vec3 { x: self.0.y(), y: self.0.z(), z: self.0.x() })
         }
     }
     #[inline]
@@ -1292,7 +1292,7 @@ impl Vec3ASwizzles for Vec3A {
 
         #[cfg(vec3a_f32)]
         {
-            Vec3A(Vec3((self.0).1, (self.0).2, (self.0).1))
+            Vec3A(Vec3 { x: self.0.y(), y: self.0.z(), z: self.0.y() })
         }
     }
     #[inline]
@@ -1304,7 +1304,7 @@ impl Vec3ASwizzles for Vec3A {
 
         #[cfg(vec3a_f32)]
         {
-            Vec3A(Vec3((self.0).1, (self.0).2, (self.0).2))
+            Vec3A(Vec3 { x: self.0.y(), y: self.0.z(), z: self.0.z() })
         }
     }
     #[inline]
@@ -1316,7 +1316,7 @@ impl Vec3ASwizzles for Vec3A {
 
         #[cfg(vec3a_f32)]
         {
-            Vec3A(Vec3((self.0).2, (self.0).0, (self.0).0))
+            Vec3A(Vec3 { x: self.0.z(), y: self.0.x(), z: self.0.x() })
         }
     }
     #[inline]
@@ -1328,7 +1328,7 @@ impl Vec3ASwizzles for Vec3A {
 
         #[cfg(vec3a_f32)]
         {
-            Vec3A(Vec3((self.0).2, (self.0).0, (self.0).1))
+            Vec3A(Vec3 { x: self.0.z(), y: self.0.x(), z: self.0.y() })
         }
     }
     #[inline]
@@ -1340,7 +1340,7 @@ impl Vec3ASwizzles for Vec3A {
 
         #[cfg(vec3a_f32)]
         {
-            Vec3A(Vec3((self.0).2, (self.0).0, (self.0).2))
+            Vec3A(Vec3 { x: self.0.z(), y: self.0.x(), z: self.0.z() })
         }
     }
     #[inline]
@@ -1352,7 +1352,7 @@ impl Vec3ASwizzles for Vec3A {
 
         #[cfg(vec3a_f32)]
         {
-            Vec3A(Vec3((self.0).2, (self.0).1, (self.0).0))
+            Vec3A(Vec3 { x: self.0.z(), y: self.0.y(), z: self.0.x() })
         }
     }
     #[inline]
@@ -1364,7 +1364,7 @@ impl Vec3ASwizzles for Vec3A {
 
         #[cfg(vec3a_f32)]
         {
-            Vec3A(Vec3((self.0).2, (self.0).1, (self.0).1))
+            Vec3A(Vec3 { x: self.0.z(), y: self.0.y(), z: self.0.y() })
         }
     }
     #[inline]
@@ -1376,7 +1376,7 @@ impl Vec3ASwizzles for Vec3A {
 
         #[cfg(vec3a_f32)]
         {
-            Vec3A(Vec3((self.0).2, (self.0).1, (self.0).2))
+            Vec3A(Vec3 { x: self.0.z(), y: self.0.y(), z: self.0.z() })
         }
     }
     #[inline]
@@ -1388,7 +1388,7 @@ impl Vec3ASwizzles for Vec3A {
 
         #[cfg(vec3a_f32)]
         {
-            Vec3A(Vec3((self.0).2, (self.0).2, (self.0).0))
+            Vec3A(Vec3 { x: self.0.z(), y: self.0.z(), z: self.0.x() })
         }
     }
     #[inline]
@@ -1400,7 +1400,7 @@ impl Vec3ASwizzles for Vec3A {
 
         #[cfg(vec3a_f32)]
         {
-            Vec3A(Vec3((self.0).2, (self.0).2, (self.0).1))
+            Vec3A(Vec3 { x: self.0.z(), y: self.0.z(), z: self.0.y() })
         }
     }
     #[inline]
@@ -1412,7 +1412,7 @@ impl Vec3ASwizzles for Vec3A {
 
         #[cfg(vec3a_f32)]
         {
-            Vec3A(Vec3((self.0).2, (self.0).2, (self.0).2))
+            Vec3A(Vec3 { x: self.0.z(), y: self.0.z(), z: self.0.z() })
         }
     }
     #[inline]
@@ -1424,7 +1424,7 @@ impl Vec3ASwizzles for Vec3A {
 
         #[cfg(vec3a_f32)]
         {
-            Vec2((self.0).0, (self.0).0)
+            Vec2 { x: self.0.x, y: self.0.x }
         }
     }
     #[inline]
@@ -1436,7 +1436,7 @@ impl Vec3ASwizzles for Vec3A {
 
         #[cfg(vec3a_f32)]
         {
-            Vec2((self.0).0, (self.0).1)
+            Vec2 { x: self.0.x, y: self.0.y }
         }
     }
     #[inline]
@@ -1448,7 +1448,7 @@ impl Vec3ASwizzles for Vec3A {
 
         #[cfg(vec3a_f32)]
         {
-            Vec2((self.0).0, (self.0).2)
+            Vec2 { x: self.0.x, y: self.0.z }
         }
     }
     #[inline]
@@ -1460,7 +1460,7 @@ impl Vec3ASwizzles for Vec3A {
 
         #[cfg(vec3a_f32)]
         {
-            Vec2((self.0).1, (self.0).0)
+            Vec2 { x: self.0.y, y: self.0.x }
         }
     }
     #[inline]
@@ -1472,7 +1472,7 @@ impl Vec3ASwizzles for Vec3A {
 
         #[cfg(vec3a_f32)]
         {
-            Vec2((self.0).1, (self.0).1)
+            Vec2 { x: self.0.y, y: self.0.y }
         }
     }
     #[inline]
@@ -1484,7 +1484,7 @@ impl Vec3ASwizzles for Vec3A {
 
         #[cfg(vec3a_f32)]
         {
-            Vec2((self.0).1, (self.0).2)
+            Vec2 { x: self.0.y, y: self.0.z }
         }
     }
     #[inline]
@@ -1496,7 +1496,7 @@ impl Vec3ASwizzles for Vec3A {
 
         #[cfg(vec3a_f32)]
         {
-            Vec2((self.0).2, (self.0).0)
+            Vec2 { x: self.0.z, y: self.0.x }
         }
     }
     #[inline]
@@ -1508,7 +1508,7 @@ impl Vec3ASwizzles for Vec3A {
 
         #[cfg(vec3a_f32)]
         {
-            Vec2((self.0).2, (self.0).1)
+            Vec2 { x: self.0.z, y: self.0.y }
         }
     }
     #[inline]
@@ -1520,7 +1520,7 @@ impl Vec3ASwizzles for Vec3A {
 
         #[cfg(vec3a_f32)]
         {
-            Vec2((self.0).2, (self.0).2)
+            Vec2 { x: self.0.z, y: self.0.z }
         }
     }
 }
diff --git a/src/f32/vec4.rs b/src/f32/vec4.rs
index 1bcb3d8..8a4d2f0 100644
--- a/src/f32/vec4.rs
+++ b/src/f32/vec4.rs
@@ -33,16 +33,16 @@ pub struct Vec4(pub(crate) __m128);
 ///
 /// This type is 16 byte aligned unless the `scalar-math` feature is enabed.
 #[cfg(vec4_f32)]
-#[derive(Clone, Copy, PartialEq, PartialOrd, Debug, Default)]
+#[derive(Clone, Copy, PartialEq, PartialOrd, Default)]
 // if compiling with simd enabled assume alignment needs to match the simd type
 #[cfg_attr(vec4_f32_align16, repr(align(16)))]
 #[repr(C)]
-pub struct Vec4(
-    pub(crate) f32,
-    pub(crate) f32,
-    pub(crate) f32,
-    pub(crate) f32,
-);
+pub struct Vec4 {
+    pub x: f32,
+    pub y: f32,
+    pub z: f32,
+    pub w: f32,
+}
 
 #[cfg(vec4_sse2)]
 impl Default for Vec4 {
@@ -101,7 +101,7 @@ impl Vec4 {
         }
         #[cfg(vec4_f32)]
         {
-            Self(x, y, z, w)
+            Self { x, y, z, w }
         }
     }
 
@@ -151,7 +151,12 @@ impl Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Self(v, v, v, v)
+            Self {
+                x: v,
+                y: v,
+                z: v,
+                w: v,
+            }
         }
     }
 
@@ -175,7 +180,7 @@ impl Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            self.0
+            self.x
         }
     }
 
@@ -189,7 +194,7 @@ impl Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            self.1
+            self.y
         }
     }
 
@@ -203,7 +208,7 @@ impl Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            self.2
+            self.z
         }
     }
 
@@ -217,7 +222,7 @@ impl Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            self.3
+            self.w
         }
     }
 
@@ -231,7 +236,7 @@ impl Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            &mut self.0
+            &mut self.x
         }
     }
 
@@ -245,7 +250,7 @@ impl Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            &mut self.1
+            &mut self.y
         }
     }
 
@@ -259,7 +264,7 @@ impl Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            &mut self.2
+            &mut self.z
         }
     }
 
@@ -273,7 +278,7 @@ impl Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            &mut self.3
+            &mut self.w
         }
     }
 
@@ -287,7 +292,7 @@ impl Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            self.0 = x;
+            self.x = x;
         }
     }
 
@@ -303,7 +308,7 @@ impl Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            self.1 = y;
+            self.y = y;
         }
     }
 
@@ -319,7 +324,7 @@ impl Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            self.2 = z;
+            self.z = z;
         }
     }
 
@@ -335,7 +340,7 @@ impl Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            self.3 = w;
+            self.w = w;
         }
     }
 
@@ -370,7 +375,7 @@ impl Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            (self.0 * other.0) + (self.1 * other.1) + (self.2 * other.2) + (self.3 * other.3)
+            (self.x * other.x) + (self.y * other.y) + (self.z * other.z) + (self.w * other.w)
         }
     }
 
@@ -467,12 +472,12 @@ impl Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Self(
-                self.0.min(other.0),
-                self.1.min(other.1),
-                self.2.min(other.2),
-                self.3.min(other.3),
-            )
+            Self {
+                x: self.x.min(other.x),
+                y: self.y.min(other.y),
+                z: self.z.min(other.z),
+                w: self.w.min(other.w),
+            }
         }
     }
 
@@ -490,12 +495,12 @@ impl Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Self(
-                self.0.max(other.0),
-                self.1.max(other.1),
-                self.2.max(other.2),
-                self.3.max(other.3),
-            )
+            Self {
+                x: self.x.max(other.x),
+                y: self.y.max(other.y),
+                z: self.z.max(other.z),
+                w: self.w.max(other.w),
+            }
         }
     }
 
@@ -514,7 +519,7 @@ impl Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            self.0.min(self.1.min(self.2.min(self.3)))
+            self.x.min(self.y.min(self.z.min(self.w)))
         }
     }
 
@@ -533,7 +538,7 @@ impl Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            self.0.max(self.1.max(self.2.min(self.3)))
+            self.x.max(self.y.max(self.z.min(self.w)))
         }
     }
 
@@ -551,10 +556,10 @@ impl Vec4 {
         #[cfg(vec4_f32)]
         {
             Vec4Mask::new(
-                self.0.eq(&other.0),
-                self.1.eq(&other.1),
-                self.2.eq(&other.2),
-                self.3.eq(&other.3),
+                self.x.eq(&other.x),
+                self.y.eq(&other.y),
+                self.z.eq(&other.z),
+                self.w.eq(&other.w),
             )
         }
     }
@@ -573,10 +578,10 @@ impl Vec4 {
         #[cfg(vec4_f32)]
         {
             Vec4Mask::new(
-                self.0.ne(&other.0),
-                self.1.ne(&other.1),
-                self.2.ne(&other.2),
-                self.3.ne(&other.3),
+                self.x.ne(&other.x),
+                self.y.ne(&other.y),
+                self.z.ne(&other.z),
+                self.w.ne(&other.w),
             )
         }
     }
@@ -595,10 +600,10 @@ impl Vec4 {
         #[cfg(vec4_f32)]
         {
             Vec4Mask::new(
-                self.0.ge(&other.0),
-                self.1.ge(&other.1),
-                self.2.ge(&other.2),
-                self.3.ge(&other.3),
+                self.x.ge(&other.x),
+                self.y.ge(&other.y),
+                self.z.ge(&other.z),
+                self.w.ge(&other.w),
             )
         }
     }
@@ -617,10 +622,10 @@ impl Vec4 {
         #[cfg(vec4_f32)]
         {
             Vec4Mask::new(
-                self.0.gt(&other.0),
-                self.1.gt(&other.1),
-                self.2.gt(&other.2),
-                self.3.gt(&other.3),
+                self.x.gt(&other.x),
+                self.y.gt(&other.y),
+                self.z.gt(&other.z),
+                self.w.gt(&other.w),
             )
         }
     }
@@ -639,10 +644,10 @@ impl Vec4 {
         #[cfg(vec4_f32)]
         {
             Vec4Mask::new(
-                self.0.le(&other.0),
-                self.1.le(&other.1),
-                self.2.le(&other.2),
-                self.3.le(&other.3),
+                self.x.le(&other.x),
+                self.y.le(&other.y),
+                self.z.le(&other.z),
+                self.w.le(&other.w),
             )
         }
     }
@@ -661,10 +666,10 @@ impl Vec4 {
         #[cfg(vec4_f32)]
         {
             Vec4Mask::new(
-                self.0.lt(&other.0),
-                self.1.lt(&other.1),
-                self.2.lt(&other.2),
-                self.3.lt(&other.3),
+                self.x.lt(&other.x),
+                self.y.lt(&other.y),
+                self.z.lt(&other.z),
+                self.w.lt(&other.w),
             )
         }
     }
@@ -684,7 +689,12 @@ impl Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Self(slice[0], slice[1], slice[2], slice[3])
+            Self {
+                x: slice[0],
+                y: slice[1],
+                z: slice[2],
+                w: slice[3],
+            }
         }
     }
 
@@ -703,10 +713,10 @@ impl Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            slice[0] = self.0;
-            slice[1] = self.1;
-            slice[2] = self.2;
-            slice[3] = self.3;
+            slice[0] = self.x;
+            slice[1] = self.y;
+            slice[2] = self.z;
+            slice[3] = self.w;
         }
     }
 
@@ -720,12 +730,12 @@ impl Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Self(
-                (self.0 * a.0) + b.0,
-                (self.1 * a.1) + b.1,
-                (self.2 * a.2) + b.2,
-                (self.3 * a.3) + b.3,
-            )
+            Self {
+                x: (self.x * a.x) + b.x,
+                y: (self.y * a.y) + b.y,
+                z: (self.z * a.z) + b.z,
+                w: (self.w * a.w) + b.w,
+            }
         }
     }
 
@@ -742,7 +752,12 @@ impl Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Self(self.0.abs(), self.1.abs(), self.2.abs(), self.3.abs())
+            Self {
+                x: self.x.abs(),
+                y: self.y.abs(),
+                z: self.z.abs(),
+                w: self.w.abs(),
+            }
         }
     }
 
@@ -758,12 +773,12 @@ impl Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Self(
-                self.0.round(),
-                self.1.round(),
-                self.2.round(),
-                self.3.round(),
-            )
+            Self {
+                x: self.x.round(),
+                y: self.y.round(),
+                z: self.z.round(),
+                w: self.w.round(),
+            }
         }
     }
 
@@ -779,12 +794,12 @@ impl Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Self(
-                self.0.floor(),
-                self.1.floor(),
-                self.2.floor(),
-                self.3.floor(),
-            )
+            Self {
+                x: self.x.floor(),
+                y: self.y.floor(),
+                z: self.z.floor(),
+                w: self.w.floor(),
+            }
         }
     }
 
@@ -800,7 +815,12 @@ impl Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Self(self.0.ceil(), self.1.ceil(), self.2.ceil(), self.3.ceil())
+            Self {
+                x: self.x.ceil(),
+                y: self.y.ceil(),
+                z: self.z.ceil(),
+                w: self.w.ceil(),
+            }
         }
     }
 
@@ -817,10 +837,10 @@ impl Vec4 {
         #[cfg(vec4_f32)]
         {
             Vec4Mask::new(
-                self.0.is_nan(),
-                self.1.is_nan(),
-                self.2.is_nan(),
-                self.3.is_nan(),
+                self.x.is_nan(),
+                self.y.is_nan(),
+                self.z.is_nan(),
+                self.w.is_nan(),
             )
         }
     }
@@ -848,12 +868,12 @@ impl Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(
-                self.0.signum(),
-                self.1.signum(),
-                self.2.signum(),
-                self.3.signum(),
-            )
+            Vec4 {
+                x: self.x.signum(),
+                y: self.y.signum(),
+                z: self.z.signum(),
+                w: self.w.signum(),
+            }
         }
     }
 
@@ -917,7 +937,6 @@ impl AsMut<[f32; 4]> for Vec4 {
     }
 }
 
-#[cfg(vec4_sse2)]
 impl fmt::Debug for Vec4 {
     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
         let a = self.as_ref();
@@ -948,12 +967,12 @@ impl Div<Vec4> for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Self(
-                self.0 / other.0,
-                self.1 / other.1,
-                self.2 / other.2,
-                self.3 / other.3,
-            )
+            Self {
+                x: self.x / other.x,
+                y: self.y / other.y,
+                z: self.z / other.z,
+                w: self.w / other.w,
+            }
         }
     }
 }
@@ -968,10 +987,10 @@ impl DivAssign<Vec4> for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            self.0 /= other.0;
-            self.1 /= other.1;
-            self.2 /= other.2;
-            self.3 /= other.3;
+            self.x /= other.x;
+            self.y /= other.y;
+            self.z /= other.z;
+            self.w /= other.w;
         }
     }
 }
@@ -987,12 +1006,12 @@ impl Div<f32> for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Self(
-                self.0 / other,
-                self.1 / other,
-                self.2 / other,
-                self.3 / other,
-            )
+            Self {
+                x: self.x / other,
+                y: self.y / other,
+                z: self.z / other,
+                w: self.w / other,
+            }
         }
     }
 }
@@ -1007,10 +1026,10 @@ impl DivAssign<f32> for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            self.0 /= other;
-            self.1 /= other;
-            self.2 /= other;
-            self.3 /= other;
+            self.x /= other;
+            self.y /= other;
+            self.z /= other;
+            self.w /= other;
         }
     }
 }
@@ -1026,12 +1045,12 @@ impl Div<Vec4> for f32 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(
-                self / other.0,
-                self / other.1,
-                self / other.2,
-                self / other.3,
-            )
+            Vec4 {
+                x: self / other.x,
+                y: self / other.y,
+                z: self / other.z,
+                w: self / other.w,
+            }
         }
     }
 }
@@ -1047,12 +1066,12 @@ impl Mul<Vec4> for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Self(
-                self.0 * other.0,
-                self.1 * other.1,
-                self.2 * other.2,
-                self.3 * other.3,
-            )
+            Self {
+                x: self.x * other.x,
+                y: self.y * other.y,
+                z: self.z * other.z,
+                w: self.w * other.w,
+            }
         }
     }
 }
@@ -1067,10 +1086,10 @@ impl MulAssign<Vec4> for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            self.0 *= other.0;
-            self.1 *= other.1;
-            self.2 *= other.2;
-            self.3 *= other.3;
+            self.x *= other.x;
+            self.y *= other.y;
+            self.z *= other.z;
+            self.w *= other.w;
         }
     }
 }
@@ -1086,12 +1105,12 @@ impl Mul<f32> for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Self(
-                self.0 * other,
-                self.1 * other,
-                self.2 * other,
-                self.3 * other,
-            )
+            Self {
+                x: self.x * other,
+                y: self.y * other,
+                z: self.z * other,
+                w: self.w * other,
+            }
         }
     }
 }
@@ -1106,10 +1125,10 @@ impl MulAssign<f32> for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            self.0 *= other;
-            self.1 *= other;
-            self.2 *= other;
-            self.3 *= other;
+            self.x *= other;
+            self.y *= other;
+            self.z *= other;
+            self.w *= other;
         }
     }
 }
@@ -1125,12 +1144,12 @@ impl Mul<Vec4> for f32 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(
-                self * other.0,
-                self * other.1,
-                self * other.2,
-                self * other.3,
-            )
+            Vec4 {
+                x: self * other.x,
+                y: self * other.y,
+                z: self * other.z,
+                w: self * other.w,
+            }
         }
     }
 }
@@ -1146,12 +1165,12 @@ impl Add for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Self(
-                self.0 + other.0,
-                self.1 + other.1,
-                self.2 + other.2,
-                self.3 + other.3,
-            )
+            Self {
+                x: self.x + other.x,
+                y: self.y + other.y,
+                z: self.z + other.z,
+                w: self.w + other.w,
+            }
         }
     }
 }
@@ -1166,10 +1185,10 @@ impl AddAssign for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            self.0 += other.0;
-            self.1 += other.1;
-            self.2 += other.2;
-            self.3 += other.3;
+            self.x += other.x;
+            self.y += other.y;
+            self.z += other.z;
+            self.w += other.w;
         }
     }
 }
@@ -1185,12 +1204,12 @@ impl Sub for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Self(
-                self.0 - other.0,
-                self.1 - other.1,
-                self.2 - other.2,
-                self.3 - other.3,
-            )
+            Self {
+                x: self.x - other.x,
+                y: self.y - other.y,
+                z: self.z - other.z,
+                w: self.w - other.w,
+            }
         }
     }
 }
@@ -1205,10 +1224,10 @@ impl SubAssign for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            self.0 -= other.0;
-            self.1 -= other.1;
-            self.2 -= other.2;
-            self.3 -= other.3;
+            self.x -= other.x;
+            self.y -= other.y;
+            self.z -= other.z;
+            self.w -= other.w;
         }
     }
 }
@@ -1224,7 +1243,12 @@ impl Neg for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Self(-self.0, -self.1, -self.2, -self.3)
+            Self {
+                x: -self.x,
+                y: -self.y,
+                z: -self.z,
+                w: -self.w,
+            }
         }
     }
 }
@@ -1265,7 +1289,7 @@ impl From<Vec4> for (f32, f32, f32, f32) {
 
         #[cfg(vec4_f32)]
         {
-            (v.0, v.1, v.2, v.3)
+            (v.x, v.y, v.z, v.w)
         }
     }
 }
@@ -1280,7 +1304,12 @@ impl From<[f32; 4]> for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Self(a[0], a[1], a[2], a[3])
+            Self {
+                x: a[0],
+                y: a[1],
+                z: a[2],
+                w: a[3],
+            }
         }
     }
 }
@@ -1299,7 +1328,7 @@ impl From<Vec4> for [f32; 4] {
 
         #[cfg(vec4_f32)]
         {
-            [v.0, v.1, v.2, v.3]
+            [v.x, v.y, v.z, v.w]
         }
     }
 }
@@ -1317,7 +1346,7 @@ impl From<Vec4> for Vec3A {
 
         #[cfg(vec4_f32)]
         {
-            Vec3A::new(v.0, v.1, v.2)
+            Vec3A::new(v.x, v.y, v.z)
         }
     }
 }
@@ -1337,7 +1366,11 @@ impl From<Vec4> for Vec3 {
 
         #[cfg(vec4_f32)]
         {
-            Vec3(v.0, v.1, v.2)
+            Vec3 {
+                x: v.x,
+                y: v.y,
+                z: v.z,
+            }
         }
     }
 }
@@ -1357,11 +1390,28 @@ impl From<Vec4> for Vec2 {
 
         #[cfg(vec4_f32)]
         {
-            Vec2(v.0, v.1)
+            Vec2 { x: v.x, y: v.y }
         }
     }
 }
 
+#[cfg(vec4_sse2)]
+impl Deref for Vec4 {
+    type Target = super::XYZW;
+    #[inline(always)]
+    fn deref(&self) -> &Self::Target {
+        unsafe { &*(self as *const Self as *const Self::Target) }
+    }
+}
+
+#[cfg(vec4_sse2)]
+impl DerefMut for Vec4 {
+    #[inline(always)]
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        unsafe { &mut *(self as *mut Self as *mut Self::Target) }
+    }
+}
+
 #[cfg(feature = "std")]
 impl<'a> Sum<&'a Self> for Vec4 {
     fn sum<I>(iter: I) -> Self
diff --git a/src/f32/vec4_mask.rs b/src/f32/vec4_mask.rs
index ecba536..008b0a8 100644
--- a/src/f32/vec4_mask.rs
+++ b/src/f32/vec4_mask.rs
@@ -168,12 +168,12 @@ impl Vec4Mask {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(
-                if self.0 != 0 { if_true.0 } else { if_false.0 },
-                if self.1 != 0 { if_true.1 } else { if_false.1 },
-                if self.2 != 0 { if_true.2 } else { if_false.2 },
-                if self.3 != 0 { if_true.3 } else { if_false.3 },
-            )
+            Vec4 {
+                x: if self.0 != 0 { if_true.x } else { if_false.x },
+                y: if self.1 != 0 { if_true.y } else { if_false.y },
+                z: if self.2 != 0 { if_true.z } else { if_false.z },
+                w: if self.3 != 0 { if_true.w } else { if_false.w },
+            }
         }
     }
 }
diff --git a/src/f32/vec4_swizzle.rs b/src/f32/vec4_swizzle.rs
index 2c6f976..57e003a 100644
--- a/src/f32/vec4_swizzle.rs
+++ b/src/f32/vec4_swizzle.rs
@@ -355,7 +355,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.0, self.0, self.0, self.0)
+            Vec4 {
+                x: self.x,
+                y: self.x,
+                z: self.x,
+                w: self.x,
+            }
         }
     }
     #[inline]
@@ -367,7 +372,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.0, self.0, self.0, self.1)
+            Vec4 {
+                x: self.x,
+                y: self.x,
+                z: self.x,
+                w: self.y,
+            }
         }
     }
     #[inline]
@@ -379,7 +389,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.0, self.0, self.0, self.2)
+            Vec4 {
+                x: self.x,
+                y: self.x,
+                z: self.x,
+                w: self.z,
+            }
         }
     }
     #[inline]
@@ -391,7 +406,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.0, self.0, self.0, self.3)
+            Vec4 {
+                x: self.x,
+                y: self.x,
+                z: self.x,
+                w: self.w,
+            }
         }
     }
     #[inline]
@@ -403,7 +423,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.0, self.0, self.1, self.0)
+            Vec4 {
+                x: self.x,
+                y: self.x,
+                z: self.y,
+                w: self.x,
+            }
         }
     }
     #[inline]
@@ -415,7 +440,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.0, self.0, self.1, self.1)
+            Vec4 {
+                x: self.x,
+                y: self.x,
+                z: self.y,
+                w: self.y,
+            }
         }
     }
     #[inline]
@@ -427,7 +457,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.0, self.0, self.1, self.2)
+            Vec4 {
+                x: self.x,
+                y: self.x,
+                z: self.y,
+                w: self.z,
+            }
         }
     }
     #[inline]
@@ -439,7 +474,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.0, self.0, self.1, self.3)
+            Vec4 {
+                x: self.x,
+                y: self.x,
+                z: self.y,
+                w: self.w,
+            }
         }
     }
     #[inline]
@@ -451,7 +491,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.0, self.0, self.2, self.0)
+            Vec4 {
+                x: self.x,
+                y: self.x,
+                z: self.z,
+                w: self.x,
+            }
         }
     }
     #[inline]
@@ -463,7 +508,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.0, self.0, self.2, self.1)
+            Vec4 {
+                x: self.x,
+                y: self.x,
+                z: self.z,
+                w: self.y,
+            }
         }
     }
     #[inline]
@@ -475,7 +525,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.0, self.0, self.2, self.2)
+            Vec4 {
+                x: self.x,
+                y: self.x,
+                z: self.z,
+                w: self.z,
+            }
         }
     }
     #[inline]
@@ -487,7 +542,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.0, self.0, self.2, self.3)
+            Vec4 {
+                x: self.x,
+                y: self.x,
+                z: self.z,
+                w: self.w,
+            }
         }
     }
     #[inline]
@@ -499,7 +559,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.0, self.0, self.3, self.0)
+            Vec4 {
+                x: self.x,
+                y: self.x,
+                z: self.w,
+                w: self.x,
+            }
         }
     }
     #[inline]
@@ -511,7 +576,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.0, self.0, self.3, self.1)
+            Vec4 {
+                x: self.x,
+                y: self.x,
+                z: self.w,
+                w: self.y,
+            }
         }
     }
     #[inline]
@@ -523,7 +593,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.0, self.0, self.3, self.2)
+            Vec4 {
+                x: self.x,
+                y: self.x,
+                z: self.w,
+                w: self.z,
+            }
         }
     }
     #[inline]
@@ -535,7 +610,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.0, self.0, self.3, self.3)
+            Vec4 {
+                x: self.x,
+                y: self.x,
+                z: self.w,
+                w: self.w,
+            }
         }
     }
     #[inline]
@@ -547,7 +627,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.0, self.1, self.0, self.0)
+            Vec4 {
+                x: self.x,
+                y: self.y,
+                z: self.x,
+                w: self.x,
+            }
         }
     }
     #[inline]
@@ -559,7 +644,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.0, self.1, self.0, self.1)
+            Vec4 {
+                x: self.x,
+                y: self.y,
+                z: self.x,
+                w: self.y,
+            }
         }
     }
     #[inline]
@@ -571,7 +661,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.0, self.1, self.0, self.2)
+            Vec4 {
+                x: self.x,
+                y: self.y,
+                z: self.x,
+                w: self.z,
+            }
         }
     }
     #[inline]
@@ -583,7 +678,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.0, self.1, self.0, self.3)
+            Vec4 {
+                x: self.x,
+                y: self.y,
+                z: self.x,
+                w: self.w,
+            }
         }
     }
     #[inline]
@@ -595,7 +695,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.0, self.1, self.1, self.0)
+            Vec4 {
+                x: self.x,
+                y: self.y,
+                z: self.y,
+                w: self.x,
+            }
         }
     }
     #[inline]
@@ -607,7 +712,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.0, self.1, self.1, self.1)
+            Vec4 {
+                x: self.x,
+                y: self.y,
+                z: self.y,
+                w: self.y,
+            }
         }
     }
     #[inline]
@@ -619,7 +729,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.0, self.1, self.1, self.2)
+            Vec4 {
+                x: self.x,
+                y: self.y,
+                z: self.y,
+                w: self.z,
+            }
         }
     }
     #[inline]
@@ -631,7 +746,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.0, self.1, self.1, self.3)
+            Vec4 {
+                x: self.x,
+                y: self.y,
+                z: self.y,
+                w: self.w,
+            }
         }
     }
     #[inline]
@@ -643,7 +763,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.0, self.1, self.2, self.0)
+            Vec4 {
+                x: self.x,
+                y: self.y,
+                z: self.z,
+                w: self.x,
+            }
         }
     }
     #[inline]
@@ -655,7 +780,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.0, self.1, self.2, self.1)
+            Vec4 {
+                x: self.x,
+                y: self.y,
+                z: self.z,
+                w: self.y,
+            }
         }
     }
     #[inline]
@@ -667,7 +797,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.0, self.1, self.2, self.2)
+            Vec4 {
+                x: self.x,
+                y: self.y,
+                z: self.z,
+                w: self.z,
+            }
         }
     }
     #[inline]
@@ -679,7 +814,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.0, self.1, self.3, self.0)
+            Vec4 {
+                x: self.x,
+                y: self.y,
+                z: self.w,
+                w: self.x,
+            }
         }
     }
     #[inline]
@@ -691,7 +831,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.0, self.1, self.3, self.1)
+            Vec4 {
+                x: self.x,
+                y: self.y,
+                z: self.w,
+                w: self.y,
+            }
         }
     }
     #[inline]
@@ -703,7 +848,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.0, self.1, self.3, self.2)
+            Vec4 {
+                x: self.x,
+                y: self.y,
+                z: self.w,
+                w: self.z,
+            }
         }
     }
     #[inline]
@@ -715,7 +865,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.0, self.1, self.3, self.3)
+            Vec4 {
+                x: self.x,
+                y: self.y,
+                z: self.w,
+                w: self.w,
+            }
         }
     }
     #[inline]
@@ -727,7 +882,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.0, self.2, self.0, self.0)
+            Vec4 {
+                x: self.x,
+                y: self.z,
+                z: self.x,
+                w: self.x,
+            }
         }
     }
     #[inline]
@@ -739,7 +899,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.0, self.2, self.0, self.1)
+            Vec4 {
+                x: self.x,
+                y: self.z,
+                z: self.x,
+                w: self.y,
+            }
         }
     }
     #[inline]
@@ -751,7 +916,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.0, self.2, self.0, self.2)
+            Vec4 {
+                x: self.x,
+                y: self.z,
+                z: self.x,
+                w: self.z,
+            }
         }
     }
     #[inline]
@@ -763,7 +933,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.0, self.2, self.0, self.3)
+            Vec4 {
+                x: self.x,
+                y: self.z,
+                z: self.x,
+                w: self.w,
+            }
         }
     }
     #[inline]
@@ -775,7 +950,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.0, self.2, self.1, self.0)
+            Vec4 {
+                x: self.x,
+                y: self.z,
+                z: self.y,
+                w: self.x,
+            }
         }
     }
     #[inline]
@@ -787,7 +967,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.0, self.2, self.1, self.1)
+            Vec4 {
+                x: self.x,
+                y: self.z,
+                z: self.y,
+                w: self.y,
+            }
         }
     }
     #[inline]
@@ -799,7 +984,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.0, self.2, self.1, self.2)
+            Vec4 {
+                x: self.x,
+                y: self.z,
+                z: self.y,
+                w: self.z,
+            }
         }
     }
     #[inline]
@@ -811,7 +1001,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.0, self.2, self.1, self.3)
+            Vec4 {
+                x: self.x,
+                y: self.z,
+                z: self.y,
+                w: self.w,
+            }
         }
     }
     #[inline]
@@ -823,7 +1018,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.0, self.2, self.2, self.0)
+            Vec4 {
+                x: self.x,
+                y: self.z,
+                z: self.z,
+                w: self.x,
+            }
         }
     }
     #[inline]
@@ -835,7 +1035,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.0, self.2, self.2, self.1)
+            Vec4 {
+                x: self.x,
+                y: self.z,
+                z: self.z,
+                w: self.y,
+            }
         }
     }
     #[inline]
@@ -847,7 +1052,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.0, self.2, self.2, self.2)
+            Vec4 {
+                x: self.x,
+                y: self.z,
+                z: self.z,
+                w: self.z,
+            }
         }
     }
     #[inline]
@@ -859,7 +1069,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.0, self.2, self.2, self.3)
+            Vec4 {
+                x: self.x,
+                y: self.z,
+                z: self.z,
+                w: self.w,
+            }
         }
     }
     #[inline]
@@ -871,7 +1086,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.0, self.2, self.3, self.0)
+            Vec4 {
+                x: self.x,
+                y: self.z,
+                z: self.w,
+                w: self.x,
+            }
         }
     }
     #[inline]
@@ -883,7 +1103,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.0, self.2, self.3, self.1)
+            Vec4 {
+                x: self.x,
+                y: self.z,
+                z: self.w,
+                w: self.y,
+            }
         }
     }
     #[inline]
@@ -895,7 +1120,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.0, self.2, self.3, self.2)
+            Vec4 {
+                x: self.x,
+                y: self.z,
+                z: self.w,
+                w: self.z,
+            }
         }
     }
     #[inline]
@@ -907,7 +1137,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.0, self.2, self.3, self.3)
+            Vec4 {
+                x: self.x,
+                y: self.z,
+                z: self.w,
+                w: self.w,
+            }
         }
     }
     #[inline]
@@ -919,7 +1154,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.0, self.3, self.0, self.0)
+            Vec4 {
+                x: self.x,
+                y: self.w,
+                z: self.x,
+                w: self.x,
+            }
         }
     }
     #[inline]
@@ -931,7 +1171,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.0, self.3, self.0, self.1)
+            Vec4 {
+                x: self.x,
+                y: self.w,
+                z: self.x,
+                w: self.y,
+            }
         }
     }
     #[inline]
@@ -943,7 +1188,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.0, self.3, self.0, self.2)
+            Vec4 {
+                x: self.x,
+                y: self.w,
+                z: self.x,
+                w: self.z,
+            }
         }
     }
     #[inline]
@@ -955,7 +1205,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.0, self.3, self.0, self.3)
+            Vec4 {
+                x: self.x,
+                y: self.w,
+                z: self.x,
+                w: self.w,
+            }
         }
     }
     #[inline]
@@ -967,7 +1222,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.0, self.3, self.1, self.0)
+            Vec4 {
+                x: self.x,
+                y: self.w,
+                z: self.y,
+                w: self.x,
+            }
         }
     }
     #[inline]
@@ -979,7 +1239,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.0, self.3, self.1, self.1)
+            Vec4 {
+                x: self.x,
+                y: self.w,
+                z: self.y,
+                w: self.y,
+            }
         }
     }
     #[inline]
@@ -991,7 +1256,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.0, self.3, self.1, self.2)
+            Vec4 {
+                x: self.x,
+                y: self.w,
+                z: self.y,
+                w: self.z,
+            }
         }
     }
     #[inline]
@@ -1003,7 +1273,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.0, self.3, self.1, self.3)
+            Vec4 {
+                x: self.x,
+                y: self.w,
+                z: self.y,
+                w: self.w,
+            }
         }
     }
     #[inline]
@@ -1015,7 +1290,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.0, self.3, self.2, self.0)
+            Vec4 {
+                x: self.x,
+                y: self.w,
+                z: self.z,
+                w: self.x,
+            }
         }
     }
     #[inline]
@@ -1027,7 +1307,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.0, self.3, self.2, self.1)
+            Vec4 {
+                x: self.x,
+                y: self.w,
+                z: self.z,
+                w: self.y,
+            }
         }
     }
     #[inline]
@@ -1039,7 +1324,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.0, self.3, self.2, self.2)
+            Vec4 {
+                x: self.x,
+                y: self.w,
+                z: self.z,
+                w: self.z,
+            }
         }
     }
     #[inline]
@@ -1051,7 +1341,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.0, self.3, self.2, self.3)
+            Vec4 {
+                x: self.x,
+                y: self.w,
+                z: self.z,
+                w: self.w,
+            }
         }
     }
     #[inline]
@@ -1063,7 +1358,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.0, self.3, self.3, self.0)
+            Vec4 {
+                x: self.x,
+                y: self.w,
+                z: self.w,
+                w: self.x,
+            }
         }
     }
     #[inline]
@@ -1075,7 +1375,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.0, self.3, self.3, self.1)
+            Vec4 {
+                x: self.x,
+                y: self.w,
+                z: self.w,
+                w: self.y,
+            }
         }
     }
     #[inline]
@@ -1087,7 +1392,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.0, self.3, self.3, self.2)
+            Vec4 {
+                x: self.x,
+                y: self.w,
+                z: self.w,
+                w: self.z,
+            }
         }
     }
     #[inline]
@@ -1099,7 +1409,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.0, self.3, self.3, self.3)
+            Vec4 {
+                x: self.x,
+                y: self.w,
+                z: self.w,
+                w: self.w,
+            }
         }
     }
     #[inline]
@@ -1111,7 +1426,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.1, self.0, self.0, self.0)
+            Vec4 {
+                x: self.y,
+                y: self.x,
+                z: self.x,
+                w: self.x,
+            }
         }
     }
     #[inline]
@@ -1123,7 +1443,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.1, self.0, self.0, self.1)
+            Vec4 {
+                x: self.y,
+                y: self.x,
+                z: self.x,
+                w: self.y,
+            }
         }
     }
     #[inline]
@@ -1135,7 +1460,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.1, self.0, self.0, self.2)
+            Vec4 {
+                x: self.y,
+                y: self.x,
+                z: self.x,
+                w: self.z,
+            }
         }
     }
     #[inline]
@@ -1147,7 +1477,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.1, self.0, self.0, self.3)
+            Vec4 {
+                x: self.y,
+                y: self.x,
+                z: self.x,
+                w: self.w,
+            }
         }
     }
     #[inline]
@@ -1159,7 +1494,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.1, self.0, self.1, self.0)
+            Vec4 {
+                x: self.y,
+                y: self.x,
+                z: self.y,
+                w: self.x,
+            }
         }
     }
     #[inline]
@@ -1171,7 +1511,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.1, self.0, self.1, self.1)
+            Vec4 {
+                x: self.y,
+                y: self.x,
+                z: self.y,
+                w: self.y,
+            }
         }
     }
     #[inline]
@@ -1183,7 +1528,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.1, self.0, self.1, self.2)
+            Vec4 {
+                x: self.y,
+                y: self.x,
+                z: self.y,
+                w: self.z,
+            }
         }
     }
     #[inline]
@@ -1195,7 +1545,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.1, self.0, self.1, self.3)
+            Vec4 {
+                x: self.y,
+                y: self.x,
+                z: self.y,
+                w: self.w,
+            }
         }
     }
     #[inline]
@@ -1207,7 +1562,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.1, self.0, self.2, self.0)
+            Vec4 {
+                x: self.y,
+                y: self.x,
+                z: self.z,
+                w: self.x,
+            }
         }
     }
     #[inline]
@@ -1219,7 +1579,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.1, self.0, self.2, self.1)
+            Vec4 {
+                x: self.y,
+                y: self.x,
+                z: self.z,
+                w: self.y,
+            }
         }
     }
     #[inline]
@@ -1231,7 +1596,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.1, self.0, self.2, self.2)
+            Vec4 {
+                x: self.y,
+                y: self.x,
+                z: self.z,
+                w: self.z,
+            }
         }
     }
     #[inline]
@@ -1243,7 +1613,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.1, self.0, self.2, self.3)
+            Vec4 {
+                x: self.y,
+                y: self.x,
+                z: self.z,
+                w: self.w,
+            }
         }
     }
     #[inline]
@@ -1255,7 +1630,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.1, self.0, self.3, self.0)
+            Vec4 {
+                x: self.y,
+                y: self.x,
+                z: self.w,
+                w: self.x,
+            }
         }
     }
     #[inline]
@@ -1267,7 +1647,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.1, self.0, self.3, self.1)
+            Vec4 {
+                x: self.y,
+                y: self.x,
+                z: self.w,
+                w: self.y,
+            }
         }
     }
     #[inline]
@@ -1279,7 +1664,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.1, self.0, self.3, self.2)
+            Vec4 {
+                x: self.y,
+                y: self.x,
+                z: self.w,
+                w: self.z,
+            }
         }
     }
     #[inline]
@@ -1291,7 +1681,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.1, self.0, self.3, self.3)
+            Vec4 {
+                x: self.y,
+                y: self.x,
+                z: self.w,
+                w: self.w,
+            }
         }
     }
     #[inline]
@@ -1303,7 +1698,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.1, self.1, self.0, self.0)
+            Vec4 {
+                x: self.y,
+                y: self.y,
+                z: self.x,
+                w: self.x,
+            }
         }
     }
     #[inline]
@@ -1315,7 +1715,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.1, self.1, self.0, self.1)
+            Vec4 {
+                x: self.y,
+                y: self.y,
+                z: self.x,
+                w: self.y,
+            }
         }
     }
     #[inline]
@@ -1327,7 +1732,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.1, self.1, self.0, self.2)
+            Vec4 {
+                x: self.y,
+                y: self.y,
+                z: self.x,
+                w: self.z,
+            }
         }
     }
     #[inline]
@@ -1339,7 +1749,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.1, self.1, self.0, self.3)
+            Vec4 {
+                x: self.y,
+                y: self.y,
+                z: self.x,
+                w: self.w,
+            }
         }
     }
     #[inline]
@@ -1351,7 +1766,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.1, self.1, self.1, self.0)
+            Vec4 {
+                x: self.y,
+                y: self.y,
+                z: self.y,
+                w: self.x,
+            }
         }
     }
     #[inline]
@@ -1363,7 +1783,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.1, self.1, self.1, self.1)
+            Vec4 {
+                x: self.y,
+                y: self.y,
+                z: self.y,
+                w: self.y,
+            }
         }
     }
     #[inline]
@@ -1375,7 +1800,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.1, self.1, self.1, self.2)
+            Vec4 {
+                x: self.y,
+                y: self.y,
+                z: self.y,
+                w: self.z,
+            }
         }
     }
     #[inline]
@@ -1387,7 +1817,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.1, self.1, self.1, self.3)
+            Vec4 {
+                x: self.y,
+                y: self.y,
+                z: self.y,
+                w: self.w,
+            }
         }
     }
     #[inline]
@@ -1399,7 +1834,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.1, self.1, self.2, self.0)
+            Vec4 {
+                x: self.y,
+                y: self.y,
+                z: self.z,
+                w: self.x,
+            }
         }
     }
     #[inline]
@@ -1411,7 +1851,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.1, self.1, self.2, self.1)
+            Vec4 {
+                x: self.y,
+                y: self.y,
+                z: self.z,
+                w: self.y,
+            }
         }
     }
     #[inline]
@@ -1423,7 +1868,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.1, self.1, self.2, self.2)
+            Vec4 {
+                x: self.y,
+                y: self.y,
+                z: self.z,
+                w: self.z,
+            }
         }
     }
     #[inline]
@@ -1435,7 +1885,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.1, self.1, self.2, self.3)
+            Vec4 {
+                x: self.y,
+                y: self.y,
+                z: self.z,
+                w: self.w,
+            }
         }
     }
     #[inline]
@@ -1447,7 +1902,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.1, self.1, self.3, self.0)
+            Vec4 {
+                x: self.y,
+                y: self.y,
+                z: self.w,
+                w: self.x,
+            }
         }
     }
     #[inline]
@@ -1459,7 +1919,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.1, self.1, self.3, self.1)
+            Vec4 {
+                x: self.y,
+                y: self.y,
+                z: self.w,
+                w: self.y,
+            }
         }
     }
     #[inline]
@@ -1471,7 +1936,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.1, self.1, self.3, self.2)
+            Vec4 {
+                x: self.y,
+                y: self.y,
+                z: self.w,
+                w: self.z,
+            }
         }
     }
     #[inline]
@@ -1483,7 +1953,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.1, self.1, self.3, self.3)
+            Vec4 {
+                x: self.y,
+                y: self.y,
+                z: self.w,
+                w: self.w,
+            }
         }
     }
     #[inline]
@@ -1495,7 +1970,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.1, self.2, self.0, self.0)
+            Vec4 {
+                x: self.y,
+                y: self.z,
+                z: self.x,
+                w: self.x,
+            }
         }
     }
     #[inline]
@@ -1507,7 +1987,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.1, self.2, self.0, self.1)
+            Vec4 {
+                x: self.y,
+                y: self.z,
+                z: self.x,
+                w: self.y,
+            }
         }
     }
     #[inline]
@@ -1519,7 +2004,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.1, self.2, self.0, self.2)
+            Vec4 {
+                x: self.y,
+                y: self.z,
+                z: self.x,
+                w: self.z,
+            }
         }
     }
     #[inline]
@@ -1531,7 +2021,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.1, self.2, self.0, self.3)
+            Vec4 {
+                x: self.y,
+                y: self.z,
+                z: self.x,
+                w: self.w,
+            }
         }
     }
     #[inline]
@@ -1543,7 +2038,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.1, self.2, self.1, self.0)
+            Vec4 {
+                x: self.y,
+                y: self.z,
+                z: self.y,
+                w: self.x,
+            }
         }
     }
     #[inline]
@@ -1555,7 +2055,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.1, self.2, self.1, self.1)
+            Vec4 {
+                x: self.y,
+                y: self.z,
+                z: self.y,
+                w: self.y,
+            }
         }
     }
     #[inline]
@@ -1567,7 +2072,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.1, self.2, self.1, self.2)
+            Vec4 {
+                x: self.y,
+                y: self.z,
+                z: self.y,
+                w: self.z,
+            }
         }
     }
     #[inline]
@@ -1579,7 +2089,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.1, self.2, self.1, self.3)
+            Vec4 {
+                x: self.y,
+                y: self.z,
+                z: self.y,
+                w: self.w,
+            }
         }
     }
     #[inline]
@@ -1591,7 +2106,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.1, self.2, self.2, self.0)
+            Vec4 {
+                x: self.y,
+                y: self.z,
+                z: self.z,
+                w: self.x,
+            }
         }
     }
     #[inline]
@@ -1603,7 +2123,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.1, self.2, self.2, self.1)
+            Vec4 {
+                x: self.y,
+                y: self.z,
+                z: self.z,
+                w: self.y,
+            }
         }
     }
     #[inline]
@@ -1615,7 +2140,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.1, self.2, self.2, self.2)
+            Vec4 {
+                x: self.y,
+                y: self.z,
+                z: self.z,
+                w: self.z,
+            }
         }
     }
     #[inline]
@@ -1627,7 +2157,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.1, self.2, self.2, self.3)
+            Vec4 {
+                x: self.y,
+                y: self.z,
+                z: self.z,
+                w: self.w,
+            }
         }
     }
     #[inline]
@@ -1639,7 +2174,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.1, self.2, self.3, self.0)
+            Vec4 {
+                x: self.y,
+                y: self.z,
+                z: self.w,
+                w: self.x,
+            }
         }
     }
     #[inline]
@@ -1651,7 +2191,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.1, self.2, self.3, self.1)
+            Vec4 {
+                x: self.y,
+                y: self.z,
+                z: self.w,
+                w: self.y,
+            }
         }
     }
     #[inline]
@@ -1663,7 +2208,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.1, self.2, self.3, self.2)
+            Vec4 {
+                x: self.y,
+                y: self.z,
+                z: self.w,
+                w: self.z,
+            }
         }
     }
     #[inline]
@@ -1675,7 +2225,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.1, self.2, self.3, self.3)
+            Vec4 {
+                x: self.y,
+                y: self.z,
+                z: self.w,
+                w: self.w,
+            }
         }
     }
     #[inline]
@@ -1687,7 +2242,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.1, self.3, self.0, self.0)
+            Vec4 {
+                x: self.y,
+                y: self.w,
+                z: self.x,
+                w: self.x,
+            }
         }
     }
     #[inline]
@@ -1699,7 +2259,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.1, self.3, self.0, self.1)
+            Vec4 {
+                x: self.y,
+                y: self.w,
+                z: self.x,
+                w: self.y,
+            }
         }
     }
     #[inline]
@@ -1711,7 +2276,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.1, self.3, self.0, self.2)
+            Vec4 {
+                x: self.y,
+                y: self.w,
+                z: self.x,
+                w: self.z,
+            }
         }
     }
     #[inline]
@@ -1723,7 +2293,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.1, self.3, self.0, self.3)
+            Vec4 {
+                x: self.y,
+                y: self.w,
+                z: self.x,
+                w: self.w,
+            }
         }
     }
     #[inline]
@@ -1735,7 +2310,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.1, self.3, self.1, self.0)
+            Vec4 {
+                x: self.y,
+                y: self.w,
+                z: self.y,
+                w: self.x,
+            }
         }
     }
     #[inline]
@@ -1747,7 +2327,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.1, self.3, self.1, self.1)
+            Vec4 {
+                x: self.y,
+                y: self.w,
+                z: self.y,
+                w: self.y,
+            }
         }
     }
     #[inline]
@@ -1759,7 +2344,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.1, self.3, self.1, self.2)
+            Vec4 {
+                x: self.y,
+                y: self.w,
+                z: self.y,
+                w: self.z,
+            }
         }
     }
     #[inline]
@@ -1771,7 +2361,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.1, self.3, self.1, self.3)
+            Vec4 {
+                x: self.y,
+                y: self.w,
+                z: self.y,
+                w: self.w,
+            }
         }
     }
     #[inline]
@@ -1783,7 +2378,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.1, self.3, self.2, self.0)
+            Vec4 {
+                x: self.y,
+                y: self.w,
+                z: self.z,
+                w: self.x,
+            }
         }
     }
     #[inline]
@@ -1795,7 +2395,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.1, self.3, self.2, self.1)
+            Vec4 {
+                x: self.y,
+                y: self.w,
+                z: self.z,
+                w: self.y,
+            }
         }
     }
     #[inline]
@@ -1807,7 +2412,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.1, self.3, self.2, self.2)
+            Vec4 {
+                x: self.y,
+                y: self.w,
+                z: self.z,
+                w: self.z,
+            }
         }
     }
     #[inline]
@@ -1819,7 +2429,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.1, self.3, self.2, self.3)
+            Vec4 {
+                x: self.y,
+                y: self.w,
+                z: self.z,
+                w: self.w,
+            }
         }
     }
     #[inline]
@@ -1831,7 +2446,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.1, self.3, self.3, self.0)
+            Vec4 {
+                x: self.y,
+                y: self.w,
+                z: self.w,
+                w: self.x,
+            }
         }
     }
     #[inline]
@@ -1843,7 +2463,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.1, self.3, self.3, self.1)
+            Vec4 {
+                x: self.y,
+                y: self.w,
+                z: self.w,
+                w: self.y,
+            }
         }
     }
     #[inline]
@@ -1855,7 +2480,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.1, self.3, self.3, self.2)
+            Vec4 {
+                x: self.y,
+                y: self.w,
+                z: self.w,
+                w: self.z,
+            }
         }
     }
     #[inline]
@@ -1867,7 +2497,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.1, self.3, self.3, self.3)
+            Vec4 {
+                x: self.y,
+                y: self.w,
+                z: self.w,
+                w: self.w,
+            }
         }
     }
     #[inline]
@@ -1879,7 +2514,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.2, self.0, self.0, self.0)
+            Vec4 {
+                x: self.z,
+                y: self.x,
+                z: self.x,
+                w: self.x,
+            }
         }
     }
     #[inline]
@@ -1891,7 +2531,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.2, self.0, self.0, self.1)
+            Vec4 {
+                x: self.z,
+                y: self.x,
+                z: self.x,
+                w: self.y,
+            }
         }
     }
     #[inline]
@@ -1903,7 +2548,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.2, self.0, self.0, self.2)
+            Vec4 {
+                x: self.z,
+                y: self.x,
+                z: self.x,
+                w: self.z,
+            }
         }
     }
     #[inline]
@@ -1915,7 +2565,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.2, self.0, self.0, self.3)
+            Vec4 {
+                x: self.z,
+                y: self.x,
+                z: self.x,
+                w: self.w,
+            }
         }
     }
     #[inline]
@@ -1927,7 +2582,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.2, self.0, self.1, self.0)
+            Vec4 {
+                x: self.z,
+                y: self.x,
+                z: self.y,
+                w: self.x,
+            }
         }
     }
     #[inline]
@@ -1939,7 +2599,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.2, self.0, self.1, self.1)
+            Vec4 {
+                x: self.z,
+                y: self.x,
+                z: self.y,
+                w: self.y,
+            }
         }
     }
     #[inline]
@@ -1951,7 +2616,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.2, self.0, self.1, self.2)
+            Vec4 {
+                x: self.z,
+                y: self.x,
+                z: self.y,
+                w: self.z,
+            }
         }
     }
     #[inline]
@@ -1963,7 +2633,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.2, self.0, self.1, self.3)
+            Vec4 {
+                x: self.z,
+                y: self.x,
+                z: self.y,
+                w: self.w,
+            }
         }
     }
     #[inline]
@@ -1975,7 +2650,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.2, self.0, self.2, self.0)
+            Vec4 {
+                x: self.z,
+                y: self.x,
+                z: self.z,
+                w: self.x,
+            }
         }
     }
     #[inline]
@@ -1987,7 +2667,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.2, self.0, self.2, self.1)
+            Vec4 {
+                x: self.z,
+                y: self.x,
+                z: self.z,
+                w: self.y,
+            }
         }
     }
     #[inline]
@@ -1999,7 +2684,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.2, self.0, self.2, self.2)
+            Vec4 {
+                x: self.z,
+                y: self.x,
+                z: self.z,
+                w: self.z,
+            }
         }
     }
     #[inline]
@@ -2011,7 +2701,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.2, self.0, self.2, self.3)
+            Vec4 {
+                x: self.z,
+                y: self.x,
+                z: self.z,
+                w: self.w,
+            }
         }
     }
     #[inline]
@@ -2023,7 +2718,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.2, self.0, self.3, self.0)
+            Vec4 {
+                x: self.z,
+                y: self.x,
+                z: self.w,
+                w: self.x,
+            }
         }
     }
     #[inline]
@@ -2035,7 +2735,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.2, self.0, self.3, self.1)
+            Vec4 {
+                x: self.z,
+                y: self.x,
+                z: self.w,
+                w: self.y,
+            }
         }
     }
     #[inline]
@@ -2047,7 +2752,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.2, self.0, self.3, self.2)
+            Vec4 {
+                x: self.z,
+                y: self.x,
+                z: self.w,
+                w: self.z,
+            }
         }
     }
     #[inline]
@@ -2059,7 +2769,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.2, self.0, self.3, self.3)
+            Vec4 {
+                x: self.z,
+                y: self.x,
+                z: self.w,
+                w: self.w,
+            }
         }
     }
     #[inline]
@@ -2071,7 +2786,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.2, self.1, self.0, self.0)
+            Vec4 {
+                x: self.z,
+                y: self.y,
+                z: self.x,
+                w: self.x,
+            }
         }
     }
     #[inline]
@@ -2083,7 +2803,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.2, self.1, self.0, self.1)
+            Vec4 {
+                x: self.z,
+                y: self.y,
+                z: self.x,
+                w: self.y,
+            }
         }
     }
     #[inline]
@@ -2095,7 +2820,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.2, self.1, self.0, self.2)
+            Vec4 {
+                x: self.z,
+                y: self.y,
+                z: self.x,
+                w: self.z,
+            }
         }
     }
     #[inline]
@@ -2107,7 +2837,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.2, self.1, self.0, self.3)
+            Vec4 {
+                x: self.z,
+                y: self.y,
+                z: self.x,
+                w: self.w,
+            }
         }
     }
     #[inline]
@@ -2119,7 +2854,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.2, self.1, self.1, self.0)
+            Vec4 {
+                x: self.z,
+                y: self.y,
+                z: self.y,
+                w: self.x,
+            }
         }
     }
     #[inline]
@@ -2131,7 +2871,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.2, self.1, self.1, self.1)
+            Vec4 {
+                x: self.z,
+                y: self.y,
+                z: self.y,
+                w: self.y,
+            }
         }
     }
     #[inline]
@@ -2143,7 +2888,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.2, self.1, self.1, self.2)
+            Vec4 {
+                x: self.z,
+                y: self.y,
+                z: self.y,
+                w: self.z,
+            }
         }
     }
     #[inline]
@@ -2155,7 +2905,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.2, self.1, self.1, self.3)
+            Vec4 {
+                x: self.z,
+                y: self.y,
+                z: self.y,
+                w: self.w,
+            }
         }
     }
     #[inline]
@@ -2167,7 +2922,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.2, self.1, self.2, self.0)
+            Vec4 {
+                x: self.z,
+                y: self.y,
+                z: self.z,
+                w: self.x,
+            }
         }
     }
     #[inline]
@@ -2179,7 +2939,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.2, self.1, self.2, self.1)
+            Vec4 {
+                x: self.z,
+                y: self.y,
+                z: self.z,
+                w: self.y,
+            }
         }
     }
     #[inline]
@@ -2191,7 +2956,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.2, self.1, self.2, self.2)
+            Vec4 {
+                x: self.z,
+                y: self.y,
+                z: self.z,
+                w: self.z,
+            }
         }
     }
     #[inline]
@@ -2203,7 +2973,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.2, self.1, self.2, self.3)
+            Vec4 {
+                x: self.z,
+                y: self.y,
+                z: self.z,
+                w: self.w,
+            }
         }
     }
     #[inline]
@@ -2215,7 +2990,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.2, self.1, self.3, self.0)
+            Vec4 {
+                x: self.z,
+                y: self.y,
+                z: self.w,
+                w: self.x,
+            }
         }
     }
     #[inline]
@@ -2227,7 +3007,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.2, self.1, self.3, self.1)
+            Vec4 {
+                x: self.z,
+                y: self.y,
+                z: self.w,
+                w: self.y,
+            }
         }
     }
     #[inline]
@@ -2239,7 +3024,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.2, self.1, self.3, self.2)
+            Vec4 {
+                x: self.z,
+                y: self.y,
+                z: self.w,
+                w: self.z,
+            }
         }
     }
     #[inline]
@@ -2251,7 +3041,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.2, self.1, self.3, self.3)
+            Vec4 {
+                x: self.z,
+                y: self.y,
+                z: self.w,
+                w: self.w,
+            }
         }
     }
     #[inline]
@@ -2263,7 +3058,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.2, self.2, self.0, self.0)
+            Vec4 {
+                x: self.z,
+                y: self.z,
+                z: self.x,
+                w: self.x,
+            }
         }
     }
     #[inline]
@@ -2275,7 +3075,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.2, self.2, self.0, self.1)
+            Vec4 {
+                x: self.z,
+                y: self.z,
+                z: self.x,
+                w: self.y,
+            }
         }
     }
     #[inline]
@@ -2287,7 +3092,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.2, self.2, self.0, self.2)
+            Vec4 {
+                x: self.z,
+                y: self.z,
+                z: self.x,
+                w: self.z,
+            }
         }
     }
     #[inline]
@@ -2299,7 +3109,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.2, self.2, self.0, self.3)
+            Vec4 {
+                x: self.z,
+                y: self.z,
+                z: self.x,
+                w: self.w,
+            }
         }
     }
     #[inline]
@@ -2311,7 +3126,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.2, self.2, self.1, self.0)
+            Vec4 {
+                x: self.z,
+                y: self.z,
+                z: self.y,
+                w: self.x,
+            }
         }
     }
     #[inline]
@@ -2323,7 +3143,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.2, self.2, self.1, self.1)
+            Vec4 {
+                x: self.z,
+                y: self.z,
+                z: self.y,
+                w: self.y,
+            }
         }
     }
     #[inline]
@@ -2335,7 +3160,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.2, self.2, self.1, self.2)
+            Vec4 {
+                x: self.z,
+                y: self.z,
+                z: self.y,
+                w: self.z,
+            }
         }
     }
     #[inline]
@@ -2347,7 +3177,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.2, self.2, self.1, self.3)
+            Vec4 {
+                x: self.z,
+                y: self.z,
+                z: self.y,
+                w: self.w,
+            }
         }
     }
     #[inline]
@@ -2359,7 +3194,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.2, self.2, self.2, self.0)
+            Vec4 {
+                x: self.z,
+                y: self.z,
+                z: self.z,
+                w: self.x,
+            }
         }
     }
     #[inline]
@@ -2371,7 +3211,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.2, self.2, self.2, self.1)
+            Vec4 {
+                x: self.z,
+                y: self.z,
+                z: self.z,
+                w: self.y,
+            }
         }
     }
     #[inline]
@@ -2383,7 +3228,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.2, self.2, self.2, self.2)
+            Vec4 {
+                x: self.z,
+                y: self.z,
+                z: self.z,
+                w: self.z,
+            }
         }
     }
     #[inline]
@@ -2395,7 +3245,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.2, self.2, self.2, self.3)
+            Vec4 {
+                x: self.z,
+                y: self.z,
+                z: self.z,
+                w: self.w,
+            }
         }
     }
     #[inline]
@@ -2407,7 +3262,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.2, self.2, self.3, self.0)
+            Vec4 {
+                x: self.z,
+                y: self.z,
+                z: self.w,
+                w: self.x,
+            }
         }
     }
     #[inline]
@@ -2419,7 +3279,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.2, self.2, self.3, self.1)
+            Vec4 {
+                x: self.z,
+                y: self.z,
+                z: self.w,
+                w: self.y,
+            }
         }
     }
     #[inline]
@@ -2431,7 +3296,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.2, self.2, self.3, self.2)
+            Vec4 {
+                x: self.z,
+                y: self.z,
+                z: self.w,
+                w: self.z,
+            }
         }
     }
     #[inline]
@@ -2443,7 +3313,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.2, self.2, self.3, self.3)
+            Vec4 {
+                x: self.z,
+                y: self.z,
+                z: self.w,
+                w: self.w,
+            }
         }
     }
     #[inline]
@@ -2455,7 +3330,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.2, self.3, self.0, self.0)
+            Vec4 {
+                x: self.z,
+                y: self.w,
+                z: self.x,
+                w: self.x,
+            }
         }
     }
     #[inline]
@@ -2467,7 +3347,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.2, self.3, self.0, self.1)
+            Vec4 {
+                x: self.z,
+                y: self.w,
+                z: self.x,
+                w: self.y,
+            }
         }
     }
     #[inline]
@@ -2479,7 +3364,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.2, self.3, self.0, self.2)
+            Vec4 {
+                x: self.z,
+                y: self.w,
+                z: self.x,
+                w: self.z,
+            }
         }
     }
     #[inline]
@@ -2491,7 +3381,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.2, self.3, self.0, self.3)
+            Vec4 {
+                x: self.z,
+                y: self.w,
+                z: self.x,
+                w: self.w,
+            }
         }
     }
     #[inline]
@@ -2503,7 +3398,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.2, self.3, self.1, self.0)
+            Vec4 {
+                x: self.z,
+                y: self.w,
+                z: self.y,
+                w: self.x,
+            }
         }
     }
     #[inline]
@@ -2515,7 +3415,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.2, self.3, self.1, self.1)
+            Vec4 {
+                x: self.z,
+                y: self.w,
+                z: self.y,
+                w: self.y,
+            }
         }
     }
     #[inline]
@@ -2527,7 +3432,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.2, self.3, self.1, self.2)
+            Vec4 {
+                x: self.z,
+                y: self.w,
+                z: self.y,
+                w: self.z,
+            }
         }
     }
     #[inline]
@@ -2539,7 +3449,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.2, self.3, self.1, self.3)
+            Vec4 {
+                x: self.z,
+                y: self.w,
+                z: self.y,
+                w: self.w,
+            }
         }
     }
     #[inline]
@@ -2551,7 +3466,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.2, self.3, self.2, self.0)
+            Vec4 {
+                x: self.z,
+                y: self.w,
+                z: self.z,
+                w: self.x,
+            }
         }
     }
     #[inline]
@@ -2563,7 +3483,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.2, self.3, self.2, self.1)
+            Vec4 {
+                x: self.z,
+                y: self.w,
+                z: self.z,
+                w: self.y,
+            }
         }
     }
     #[inline]
@@ -2575,7 +3500,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.2, self.3, self.2, self.2)
+            Vec4 {
+                x: self.z,
+                y: self.w,
+                z: self.z,
+                w: self.z,
+            }
         }
     }
     #[inline]
@@ -2587,7 +3517,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.2, self.3, self.2, self.3)
+            Vec4 {
+                x: self.z,
+                y: self.w,
+                z: self.z,
+                w: self.w,
+            }
         }
     }
     #[inline]
@@ -2599,7 +3534,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.2, self.3, self.3, self.0)
+            Vec4 {
+                x: self.z,
+                y: self.w,
+                z: self.w,
+                w: self.x,
+            }
         }
     }
     #[inline]
@@ -2611,7 +3551,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.2, self.3, self.3, self.1)
+            Vec4 {
+                x: self.z,
+                y: self.w,
+                z: self.w,
+                w: self.y,
+            }
         }
     }
     #[inline]
@@ -2623,7 +3568,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.2, self.3, self.3, self.2)
+            Vec4 {
+                x: self.z,
+                y: self.w,
+                z: self.w,
+                w: self.z,
+            }
         }
     }
     #[inline]
@@ -2635,7 +3585,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.2, self.3, self.3, self.3)
+            Vec4 {
+                x: self.z,
+                y: self.w,
+                z: self.w,
+                w: self.w,
+            }
         }
     }
     #[inline]
@@ -2647,7 +3602,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.3, self.0, self.0, self.0)
+            Vec4 {
+                x: self.w,
+                y: self.x,
+                z: self.x,
+                w: self.x,
+            }
         }
     }
     #[inline]
@@ -2659,7 +3619,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.3, self.0, self.0, self.1)
+            Vec4 {
+                x: self.w,
+                y: self.x,
+                z: self.x,
+                w: self.y,
+            }
         }
     }
     #[inline]
@@ -2671,7 +3636,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.3, self.0, self.0, self.2)
+            Vec4 {
+                x: self.w,
+                y: self.x,
+                z: self.x,
+                w: self.z,
+            }
         }
     }
     #[inline]
@@ -2683,7 +3653,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.3, self.0, self.0, self.3)
+            Vec4 {
+                x: self.w,
+                y: self.x,
+                z: self.x,
+                w: self.w,
+            }
         }
     }
     #[inline]
@@ -2695,7 +3670,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.3, self.0, self.1, self.0)
+            Vec4 {
+                x: self.w,
+                y: self.x,
+                z: self.y,
+                w: self.x,
+            }
         }
     }
     #[inline]
@@ -2707,7 +3687,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.3, self.0, self.1, self.1)
+            Vec4 {
+                x: self.w,
+                y: self.x,
+                z: self.y,
+                w: self.y,
+            }
         }
     }
     #[inline]
@@ -2719,7 +3704,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.3, self.0, self.1, self.2)
+            Vec4 {
+                x: self.w,
+                y: self.x,
+                z: self.y,
+                w: self.z,
+            }
         }
     }
     #[inline]
@@ -2731,7 +3721,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.3, self.0, self.1, self.3)
+            Vec4 {
+                x: self.w,
+                y: self.x,
+                z: self.y,
+                w: self.w,
+            }
         }
     }
     #[inline]
@@ -2743,7 +3738,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.3, self.0, self.2, self.0)
+            Vec4 {
+                x: self.w,
+                y: self.x,
+                z: self.z,
+                w: self.x,
+            }
         }
     }
     #[inline]
@@ -2755,7 +3755,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.3, self.0, self.2, self.1)
+            Vec4 {
+                x: self.w,
+                y: self.x,
+                z: self.z,
+                w: self.y,
+            }
         }
     }
     #[inline]
@@ -2767,7 +3772,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.3, self.0, self.2, self.2)
+            Vec4 {
+                x: self.w,
+                y: self.x,
+                z: self.z,
+                w: self.z,
+            }
         }
     }
     #[inline]
@@ -2779,7 +3789,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.3, self.0, self.2, self.3)
+            Vec4 {
+                x: self.w,
+                y: self.x,
+                z: self.z,
+                w: self.w,
+            }
         }
     }
     #[inline]
@@ -2791,7 +3806,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.3, self.0, self.3, self.0)
+            Vec4 {
+                x: self.w,
+                y: self.x,
+                z: self.w,
+                w: self.x,
+            }
         }
     }
     #[inline]
@@ -2803,7 +3823,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.3, self.0, self.3, self.1)
+            Vec4 {
+                x: self.w,
+                y: self.x,
+                z: self.w,
+                w: self.y,
+            }
         }
     }
     #[inline]
@@ -2815,7 +3840,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.3, self.0, self.3, self.2)
+            Vec4 {
+                x: self.w,
+                y: self.x,
+                z: self.w,
+                w: self.z,
+            }
         }
     }
     #[inline]
@@ -2827,7 +3857,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.3, self.0, self.3, self.3)
+            Vec4 {
+                x: self.w,
+                y: self.x,
+                z: self.w,
+                w: self.w,
+            }
         }
     }
     #[inline]
@@ -2839,7 +3874,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.3, self.1, self.0, self.0)
+            Vec4 {
+                x: self.w,
+                y: self.y,
+                z: self.x,
+                w: self.x,
+            }
         }
     }
     #[inline]
@@ -2851,7 +3891,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.3, self.1, self.0, self.1)
+            Vec4 {
+                x: self.w,
+                y: self.y,
+                z: self.x,
+                w: self.y,
+            }
         }
     }
     #[inline]
@@ -2863,7 +3908,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.3, self.1, self.0, self.2)
+            Vec4 {
+                x: self.w,
+                y: self.y,
+                z: self.x,
+                w: self.z,
+            }
         }
     }
     #[inline]
@@ -2875,7 +3925,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.3, self.1, self.0, self.3)
+            Vec4 {
+                x: self.w,
+                y: self.y,
+                z: self.x,
+                w: self.w,
+            }
         }
     }
     #[inline]
@@ -2887,7 +3942,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.3, self.1, self.1, self.0)
+            Vec4 {
+                x: self.w,
+                y: self.y,
+                z: self.y,
+                w: self.x,
+            }
         }
     }
     #[inline]
@@ -2899,7 +3959,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.3, self.1, self.1, self.1)
+            Vec4 {
+                x: self.w,
+                y: self.y,
+                z: self.y,
+                w: self.y,
+            }
         }
     }
     #[inline]
@@ -2911,7 +3976,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.3, self.1, self.1, self.2)
+            Vec4 {
+                x: self.w,
+                y: self.y,
+                z: self.y,
+                w: self.z,
+            }
         }
     }
     #[inline]
@@ -2923,7 +3993,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.3, self.1, self.1, self.3)
+            Vec4 {
+                x: self.w,
+                y: self.y,
+                z: self.y,
+                w: self.w,
+            }
         }
     }
     #[inline]
@@ -2935,7 +4010,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.3, self.1, self.2, self.0)
+            Vec4 {
+                x: self.w,
+                y: self.y,
+                z: self.z,
+                w: self.x,
+            }
         }
     }
     #[inline]
@@ -2947,7 +4027,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.3, self.1, self.2, self.1)
+            Vec4 {
+                x: self.w,
+                y: self.y,
+                z: self.z,
+                w: self.y,
+            }
         }
     }
     #[inline]
@@ -2959,7 +4044,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.3, self.1, self.2, self.2)
+            Vec4 {
+                x: self.w,
+                y: self.y,
+                z: self.z,
+                w: self.z,
+            }
         }
     }
     #[inline]
@@ -2971,7 +4061,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.3, self.1, self.2, self.3)
+            Vec4 {
+                x: self.w,
+                y: self.y,
+                z: self.z,
+                w: self.w,
+            }
         }
     }
     #[inline]
@@ -2983,7 +4078,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.3, self.1, self.3, self.0)
+            Vec4 {
+                x: self.w,
+                y: self.y,
+                z: self.w,
+                w: self.x,
+            }
         }
     }
     #[inline]
@@ -2995,7 +4095,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.3, self.1, self.3, self.1)
+            Vec4 {
+                x: self.w,
+                y: self.y,
+                z: self.w,
+                w: self.y,
+            }
         }
     }
     #[inline]
@@ -3007,7 +4112,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.3, self.1, self.3, self.2)
+            Vec4 {
+                x: self.w,
+                y: self.y,
+                z: self.w,
+                w: self.z,
+            }
         }
     }
     #[inline]
@@ -3019,7 +4129,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.3, self.1, self.3, self.3)
+            Vec4 {
+                x: self.w,
+                y: self.y,
+                z: self.w,
+                w: self.w,
+            }
         }
     }
     #[inline]
@@ -3031,7 +4146,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.3, self.2, self.0, self.0)
+            Vec4 {
+                x: self.w,
+                y: self.z,
+                z: self.x,
+                w: self.x,
+            }
         }
     }
     #[inline]
@@ -3043,7 +4163,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.3, self.2, self.0, self.1)
+            Vec4 {
+                x: self.w,
+                y: self.z,
+                z: self.x,
+                w: self.y,
+            }
         }
     }
     #[inline]
@@ -3055,7 +4180,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.3, self.2, self.0, self.2)
+            Vec4 {
+                x: self.w,
+                y: self.z,
+                z: self.x,
+                w: self.z,
+            }
         }
     }
     #[inline]
@@ -3067,7 +4197,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.3, self.2, self.0, self.3)
+            Vec4 {
+                x: self.w,
+                y: self.z,
+                z: self.x,
+                w: self.w,
+            }
         }
     }
     #[inline]
@@ -3079,7 +4214,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.3, self.2, self.1, self.0)
+            Vec4 {
+                x: self.w,
+                y: self.z,
+                z: self.y,
+                w: self.x,
+            }
         }
     }
     #[inline]
@@ -3091,7 +4231,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.3, self.2, self.1, self.1)
+            Vec4 {
+                x: self.w,
+                y: self.z,
+                z: self.y,
+                w: self.y,
+            }
         }
     }
     #[inline]
@@ -3103,7 +4248,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.3, self.2, self.1, self.2)
+            Vec4 {
+                x: self.w,
+                y: self.z,
+                z: self.y,
+                w: self.z,
+            }
         }
     }
     #[inline]
@@ -3115,7 +4265,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.3, self.2, self.1, self.3)
+            Vec4 {
+                x: self.w,
+                y: self.z,
+                z: self.y,
+                w: self.w,
+            }
         }
     }
     #[inline]
@@ -3127,7 +4282,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.3, self.2, self.2, self.0)
+            Vec4 {
+                x: self.w,
+                y: self.z,
+                z: self.z,
+                w: self.x,
+            }
         }
     }
     #[inline]
@@ -3139,7 +4299,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.3, self.2, self.2, self.1)
+            Vec4 {
+                x: self.w,
+                y: self.z,
+                z: self.z,
+                w: self.y,
+            }
         }
     }
     #[inline]
@@ -3151,7 +4316,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.3, self.2, self.2, self.2)
+            Vec4 {
+                x: self.w,
+                y: self.z,
+                z: self.z,
+                w: self.z,
+            }
         }
     }
     #[inline]
@@ -3163,7 +4333,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.3, self.2, self.2, self.3)
+            Vec4 {
+                x: self.w,
+                y: self.z,
+                z: self.z,
+                w: self.w,
+            }
         }
     }
     #[inline]
@@ -3175,7 +4350,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.3, self.2, self.3, self.0)
+            Vec4 {
+                x: self.w,
+                y: self.z,
+                z: self.w,
+                w: self.x,
+            }
         }
     }
     #[inline]
@@ -3187,7 +4367,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.3, self.2, self.3, self.1)
+            Vec4 {
+                x: self.w,
+                y: self.z,
+                z: self.w,
+                w: self.y,
+            }
         }
     }
     #[inline]
@@ -3199,7 +4384,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.3, self.2, self.3, self.2)
+            Vec4 {
+                x: self.w,
+                y: self.z,
+                z: self.w,
+                w: self.z,
+            }
         }
     }
     #[inline]
@@ -3211,7 +4401,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.3, self.2, self.3, self.3)
+            Vec4 {
+                x: self.w,
+                y: self.z,
+                z: self.w,
+                w: self.w,
+            }
         }
     }
     #[inline]
@@ -3223,7 +4418,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.3, self.3, self.0, self.0)
+            Vec4 {
+                x: self.w,
+                y: self.w,
+                z: self.x,
+                w: self.x,
+            }
         }
     }
     #[inline]
@@ -3235,7 +4435,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.3, self.3, self.0, self.1)
+            Vec4 {
+                x: self.w,
+                y: self.w,
+                z: self.x,
+                w: self.y,
+            }
         }
     }
     #[inline]
@@ -3247,7 +4452,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.3, self.3, self.0, self.2)
+            Vec4 {
+                x: self.w,
+                y: self.w,
+                z: self.x,
+                w: self.z,
+            }
         }
     }
     #[inline]
@@ -3259,7 +4469,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.3, self.3, self.0, self.3)
+            Vec4 {
+                x: self.w,
+                y: self.w,
+                z: self.x,
+                w: self.w,
+            }
         }
     }
     #[inline]
@@ -3271,7 +4486,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.3, self.3, self.1, self.0)
+            Vec4 {
+                x: self.w,
+                y: self.w,
+                z: self.y,
+                w: self.x,
+            }
         }
     }
     #[inline]
@@ -3283,7 +4503,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.3, self.3, self.1, self.1)
+            Vec4 {
+                x: self.w,
+                y: self.w,
+                z: self.y,
+                w: self.y,
+            }
         }
     }
     #[inline]
@@ -3295,7 +4520,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.3, self.3, self.1, self.2)
+            Vec4 {
+                x: self.w,
+                y: self.w,
+                z: self.y,
+                w: self.z,
+            }
         }
     }
     #[inline]
@@ -3307,7 +4537,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.3, self.3, self.1, self.3)
+            Vec4 {
+                x: self.w,
+                y: self.w,
+                z: self.y,
+                w: self.w,
+            }
         }
     }
     #[inline]
@@ -3319,7 +4554,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.3, self.3, self.2, self.0)
+            Vec4 {
+                x: self.w,
+                y: self.w,
+                z: self.z,
+                w: self.x,
+            }
         }
     }
     #[inline]
@@ -3331,7 +4571,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.3, self.3, self.2, self.1)
+            Vec4 {
+                x: self.w,
+                y: self.w,
+                z: self.z,
+                w: self.y,
+            }
         }
     }
     #[inline]
@@ -3343,7 +4588,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.3, self.3, self.2, self.2)
+            Vec4 {
+                x: self.w,
+                y: self.w,
+                z: self.z,
+                w: self.z,
+            }
         }
     }
     #[inline]
@@ -3355,7 +4605,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.3, self.3, self.2, self.3)
+            Vec4 {
+                x: self.w,
+                y: self.w,
+                z: self.z,
+                w: self.w,
+            }
         }
     }
     #[inline]
@@ -3367,7 +4622,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.3, self.3, self.3, self.0)
+            Vec4 {
+                x: self.w,
+                y: self.w,
+                z: self.w,
+                w: self.x,
+            }
         }
     }
     #[inline]
@@ -3379,7 +4639,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.3, self.3, self.3, self.1)
+            Vec4 {
+                x: self.w,
+                y: self.w,
+                z: self.w,
+                w: self.y,
+            }
         }
     }
     #[inline]
@@ -3391,7 +4656,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.3, self.3, self.3, self.2)
+            Vec4 {
+                x: self.w,
+                y: self.w,
+                z: self.w,
+                w: self.z,
+            }
         }
     }
     #[inline]
@@ -3403,7 +4673,12 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec4(self.3, self.3, self.3, self.3)
+            Vec4 {
+                x: self.w,
+                y: self.w,
+                z: self.w,
+                w: self.w,
+            }
         }
     }
     #[inline]
@@ -3415,7 +4690,11 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec3(self.0, self.0, self.0)
+            Vec3 {
+                x: self.x,
+                y: self.x,
+                z: self.x,
+            }
         }
     }
     #[inline]
@@ -3427,7 +4706,11 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec3(self.0, self.0, self.1)
+            Vec3 {
+                x: self.x,
+                y: self.x,
+                z: self.y,
+            }
         }
     }
     #[inline]
@@ -3439,7 +4722,11 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec3(self.0, self.0, self.2)
+            Vec3 {
+                x: self.x,
+                y: self.x,
+                z: self.z,
+            }
         }
     }
     #[inline]
@@ -3451,7 +4738,11 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec3(self.0, self.0, self.3)
+            Vec3 {
+                x: self.x,
+                y: self.x,
+                z: self.w,
+            }
         }
     }
     #[inline]
@@ -3463,7 +4754,11 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec3(self.0, self.1, self.0)
+            Vec3 {
+                x: self.x,
+                y: self.y,
+                z: self.x,
+            }
         }
     }
     #[inline]
@@ -3475,7 +4770,11 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec3(self.0, self.1, self.1)
+            Vec3 {
+                x: self.x,
+                y: self.y,
+                z: self.y,
+            }
         }
     }
     #[inline]
@@ -3487,7 +4786,11 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec3(self.0, self.1, self.2)
+            Vec3 {
+                x: self.x,
+                y: self.y,
+                z: self.z,
+            }
         }
     }
     #[inline]
@@ -3499,7 +4802,11 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec3(self.0, self.1, self.3)
+            Vec3 {
+                x: self.x,
+                y: self.y,
+                z: self.w,
+            }
         }
     }
     #[inline]
@@ -3511,7 +4818,11 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec3(self.0, self.2, self.0)
+            Vec3 {
+                x: self.x,
+                y: self.z,
+                z: self.x,
+            }
         }
     }
     #[inline]
@@ -3523,7 +4834,11 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec3(self.0, self.2, self.1)
+            Vec3 {
+                x: self.x,
+                y: self.z,
+                z: self.y,
+            }
         }
     }
     #[inline]
@@ -3535,7 +4850,11 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec3(self.0, self.2, self.2)
+            Vec3 {
+                x: self.x,
+                y: self.z,
+                z: self.z,
+            }
         }
     }
     #[inline]
@@ -3547,7 +4866,11 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec3(self.0, self.2, self.3)
+            Vec3 {
+                x: self.x,
+                y: self.z,
+                z: self.w,
+            }
         }
     }
     #[inline]
@@ -3559,7 +4882,11 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec3(self.0, self.3, self.0)
+            Vec3 {
+                x: self.x,
+                y: self.w,
+                z: self.x,
+            }
         }
     }
     #[inline]
@@ -3571,7 +4898,11 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec3(self.0, self.3, self.1)
+            Vec3 {
+                x: self.x,
+                y: self.w,
+                z: self.y,
+            }
         }
     }
     #[inline]
@@ -3583,7 +4914,11 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec3(self.0, self.3, self.2)
+            Vec3 {
+                x: self.x,
+                y: self.w,
+                z: self.z,
+            }
         }
     }
     #[inline]
@@ -3595,7 +4930,11 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec3(self.0, self.3, self.3)
+            Vec3 {
+                x: self.x,
+                y: self.w,
+                z: self.w,
+            }
         }
     }
     #[inline]
@@ -3607,7 +4946,11 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec3(self.1, self.0, self.0)
+            Vec3 {
+                x: self.y,
+                y: self.x,
+                z: self.x,
+            }
         }
     }
     #[inline]
@@ -3619,7 +4962,11 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec3(self.1, self.0, self.1)
+            Vec3 {
+                x: self.y,
+                y: self.x,
+                z: self.y,
+            }
         }
     }
     #[inline]
@@ -3631,7 +4978,11 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec3(self.1, self.0, self.2)
+            Vec3 {
+                x: self.y,
+                y: self.x,
+                z: self.z,
+            }
         }
     }
     #[inline]
@@ -3643,7 +4994,11 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec3(self.1, self.0, self.3)
+            Vec3 {
+                x: self.y,
+                y: self.x,
+                z: self.w,
+            }
         }
     }
     #[inline]
@@ -3655,7 +5010,11 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec3(self.1, self.1, self.0)
+            Vec3 {
+                x: self.y,
+                y: self.y,
+                z: self.x,
+            }
         }
     }
     #[inline]
@@ -3667,7 +5026,11 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec3(self.1, self.1, self.1)
+            Vec3 {
+                x: self.y,
+                y: self.y,
+                z: self.y,
+            }
         }
     }
     #[inline]
@@ -3679,7 +5042,11 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec3(self.1, self.1, self.2)
+            Vec3 {
+                x: self.y,
+                y: self.y,
+                z: self.z,
+            }
         }
     }
     #[inline]
@@ -3691,7 +5058,11 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec3(self.1, self.1, self.3)
+            Vec3 {
+                x: self.y,
+                y: self.y,
+                z: self.w,
+            }
         }
     }
     #[inline]
@@ -3703,7 +5074,11 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec3(self.1, self.2, self.0)
+            Vec3 {
+                x: self.y,
+                y: self.z,
+                z: self.x,
+            }
         }
     }
     #[inline]
@@ -3715,7 +5090,11 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec3(self.1, self.2, self.1)
+            Vec3 {
+                x: self.y,
+                y: self.z,
+                z: self.y,
+            }
         }
     }
     #[inline]
@@ -3727,7 +5106,11 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec3(self.1, self.2, self.2)
+            Vec3 {
+                x: self.y,
+                y: self.z,
+                z: self.z,
+            }
         }
     }
     #[inline]
@@ -3739,7 +5122,11 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec3(self.1, self.2, self.3)
+            Vec3 {
+                x: self.y,
+                y: self.z,
+                z: self.w,
+            }
         }
     }
     #[inline]
@@ -3751,7 +5138,11 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec3(self.1, self.3, self.0)
+            Vec3 {
+                x: self.y,
+                y: self.w,
+                z: self.x,
+            }
         }
     }
     #[inline]
@@ -3763,7 +5154,11 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec3(self.1, self.3, self.1)
+            Vec3 {
+                x: self.y,
+                y: self.w,
+                z: self.y,
+            }
         }
     }
     #[inline]
@@ -3775,7 +5170,11 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec3(self.1, self.3, self.2)
+            Vec3 {
+                x: self.y,
+                y: self.w,
+                z: self.z,
+            }
         }
     }
     #[inline]
@@ -3787,7 +5186,11 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec3(self.1, self.3, self.3)
+            Vec3 {
+                x: self.y,
+                y: self.w,
+                z: self.w,
+            }
         }
     }
     #[inline]
@@ -3799,7 +5202,11 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec3(self.2, self.0, self.0)
+            Vec3 {
+                x: self.z,
+                y: self.x,
+                z: self.x,
+            }
         }
     }
     #[inline]
@@ -3811,7 +5218,11 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec3(self.2, self.0, self.1)
+            Vec3 {
+                x: self.z,
+                y: self.x,
+                z: self.y,
+            }
         }
     }
     #[inline]
@@ -3823,7 +5234,11 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec3(self.2, self.0, self.2)
+            Vec3 {
+                x: self.z,
+                y: self.x,
+                z: self.z,
+            }
         }
     }
     #[inline]
@@ -3835,7 +5250,11 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec3(self.2, self.0, self.3)
+            Vec3 {
+                x: self.z,
+                y: self.x,
+                z: self.w,
+            }
         }
     }
     #[inline]
@@ -3847,7 +5266,11 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec3(self.2, self.1, self.0)
+            Vec3 {
+                x: self.z,
+                y: self.y,
+                z: self.x,
+            }
         }
     }
     #[inline]
@@ -3859,7 +5282,11 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec3(self.2, self.1, self.1)
+            Vec3 {
+                x: self.z,
+                y: self.y,
+                z: self.y,
+            }
         }
     }
     #[inline]
@@ -3871,7 +5298,11 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec3(self.2, self.1, self.2)
+            Vec3 {
+                x: self.z,
+                y: self.y,
+                z: self.z,
+            }
         }
     }
     #[inline]
@@ -3883,7 +5314,11 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec3(self.2, self.1, self.3)
+            Vec3 {
+                x: self.z,
+                y: self.y,
+                z: self.w,
+            }
         }
     }
     #[inline]
@@ -3895,7 +5330,11 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec3(self.2, self.2, self.0)
+            Vec3 {
+                x: self.z,
+                y: self.z,
+                z: self.x,
+            }
         }
     }
     #[inline]
@@ -3907,7 +5346,11 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec3(self.2, self.2, self.1)
+            Vec3 {
+                x: self.z,
+                y: self.z,
+                z: self.y,
+            }
         }
     }
     #[inline]
@@ -3919,7 +5362,11 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec3(self.2, self.2, self.2)
+            Vec3 {
+                x: self.z,
+                y: self.z,
+                z: self.z,
+            }
         }
     }
     #[inline]
@@ -3931,7 +5378,11 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec3(self.2, self.2, self.3)
+            Vec3 {
+                x: self.z,
+                y: self.z,
+                z: self.w,
+            }
         }
     }
     #[inline]
@@ -3943,7 +5394,11 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec3(self.2, self.3, self.0)
+            Vec3 {
+                x: self.z,
+                y: self.w,
+                z: self.x,
+            }
         }
     }
     #[inline]
@@ -3955,7 +5410,11 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec3(self.2, self.3, self.1)
+            Vec3 {
+                x: self.z,
+                y: self.w,
+                z: self.y,
+            }
         }
     }
     #[inline]
@@ -3967,7 +5426,11 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec3(self.2, self.3, self.2)
+            Vec3 {
+                x: self.z,
+                y: self.w,
+                z: self.z,
+            }
         }
     }
     #[inline]
@@ -3979,7 +5442,11 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec3(self.2, self.3, self.3)
+            Vec3 {
+                x: self.z,
+                y: self.w,
+                z: self.w,
+            }
         }
     }
     #[inline]
@@ -3991,7 +5458,11 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec3(self.3, self.0, self.0)
+            Vec3 {
+                x: self.w,
+                y: self.x,
+                z: self.x,
+            }
         }
     }
     #[inline]
@@ -4003,7 +5474,11 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec3(self.3, self.0, self.1)
+            Vec3 {
+                x: self.w,
+                y: self.x,
+                z: self.y,
+            }
         }
     }
     #[inline]
@@ -4015,7 +5490,11 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec3(self.3, self.0, self.2)
+            Vec3 {
+                x: self.w,
+                y: self.x,
+                z: self.z,
+            }
         }
     }
     #[inline]
@@ -4027,7 +5506,11 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec3(self.3, self.0, self.3)
+            Vec3 {
+                x: self.w,
+                y: self.x,
+                z: self.w,
+            }
         }
     }
     #[inline]
@@ -4039,7 +5522,11 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec3(self.3, self.1, self.0)
+            Vec3 {
+                x: self.w,
+                y: self.y,
+                z: self.x,
+            }
         }
     }
     #[inline]
@@ -4051,7 +5538,11 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec3(self.3, self.1, self.1)
+            Vec3 {
+                x: self.w,
+                y: self.y,
+                z: self.y,
+            }
         }
     }
     #[inline]
@@ -4063,7 +5554,11 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec3(self.3, self.1, self.2)
+            Vec3 {
+                x: self.w,
+                y: self.y,
+                z: self.z,
+            }
         }
     }
     #[inline]
@@ -4075,7 +5570,11 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec3(self.3, self.1, self.3)
+            Vec3 {
+                x: self.w,
+                y: self.y,
+                z: self.w,
+            }
         }
     }
     #[inline]
@@ -4087,7 +5586,11 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec3(self.3, self.2, self.0)
+            Vec3 {
+                x: self.w,
+                y: self.z,
+                z: self.x,
+            }
         }
     }
     #[inline]
@@ -4099,7 +5602,11 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec3(self.3, self.2, self.1)
+            Vec3 {
+                x: self.w,
+                y: self.z,
+                z: self.y,
+            }
         }
     }
     #[inline]
@@ -4111,7 +5618,11 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec3(self.3, self.2, self.2)
+            Vec3 {
+                x: self.w,
+                y: self.z,
+                z: self.z,
+            }
         }
     }
     #[inline]
@@ -4123,7 +5634,11 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec3(self.3, self.2, self.3)
+            Vec3 {
+                x: self.w,
+                y: self.z,
+                z: self.w,
+            }
         }
     }
     #[inline]
@@ -4135,7 +5650,11 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec3(self.3, self.3, self.0)
+            Vec3 {
+                x: self.w,
+                y: self.w,
+                z: self.x,
+            }
         }
     }
     #[inline]
@@ -4147,7 +5666,11 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec3(self.3, self.3, self.1)
+            Vec3 {
+                x: self.w,
+                y: self.w,
+                z: self.y,
+            }
         }
     }
     #[inline]
@@ -4159,7 +5682,11 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec3(self.3, self.3, self.2)
+            Vec3 {
+                x: self.w,
+                y: self.w,
+                z: self.z,
+            }
         }
     }
     #[inline]
@@ -4171,7 +5698,11 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec3(self.3, self.3, self.3)
+            Vec3 {
+                x: self.w,
+                y: self.w,
+                z: self.w,
+            }
         }
     }
     #[inline]
@@ -4183,7 +5714,10 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec2(self.0, self.0)
+            Vec2 {
+                x: self.x,
+                y: self.x,
+            }
         }
     }
     #[inline]
@@ -4195,7 +5729,10 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec2(self.0, self.1)
+            Vec2 {
+                x: self.x,
+                y: self.y,
+            }
         }
     }
     #[inline]
@@ -4207,7 +5744,10 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec2(self.0, self.2)
+            Vec2 {
+                x: self.x,
+                y: self.z,
+            }
         }
     }
     #[inline]
@@ -4219,7 +5759,10 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec2(self.0, self.3)
+            Vec2 {
+                x: self.x,
+                y: self.w,
+            }
         }
     }
     #[inline]
@@ -4231,7 +5774,10 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec2(self.1, self.0)
+            Vec2 {
+                x: self.y,
+                y: self.x,
+            }
         }
     }
     #[inline]
@@ -4243,7 +5789,10 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec2(self.1, self.1)
+            Vec2 {
+                x: self.y,
+                y: self.y,
+            }
         }
     }
     #[inline]
@@ -4255,7 +5804,10 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec2(self.1, self.2)
+            Vec2 {
+                x: self.y,
+                y: self.z,
+            }
         }
     }
     #[inline]
@@ -4267,7 +5819,10 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec2(self.1, self.3)
+            Vec2 {
+                x: self.y,
+                y: self.w,
+            }
         }
     }
     #[inline]
@@ -4279,7 +5834,10 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec2(self.2, self.0)
+            Vec2 {
+                x: self.z,
+                y: self.x,
+            }
         }
     }
     #[inline]
@@ -4291,7 +5849,10 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec2(self.2, self.1)
+            Vec2 {
+                x: self.z,
+                y: self.y,
+            }
         }
     }
     #[inline]
@@ -4303,7 +5864,10 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec2(self.2, self.2)
+            Vec2 {
+                x: self.z,
+                y: self.z,
+            }
         }
     }
     #[inline]
@@ -4315,7 +5879,10 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec2(self.2, self.3)
+            Vec2 {
+                x: self.z,
+                y: self.w,
+            }
         }
     }
     #[inline]
@@ -4327,7 +5894,10 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec2(self.3, self.0)
+            Vec2 {
+                x: self.w,
+                y: self.x,
+            }
         }
     }
     #[inline]
@@ -4339,7 +5909,10 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec2(self.3, self.1)
+            Vec2 {
+                x: self.w,
+                y: self.y,
+            }
         }
     }
     #[inline]
@@ -4351,7 +5924,10 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec2(self.3, self.2)
+            Vec2 {
+                x: self.w,
+                y: self.z,
+            }
         }
     }
     #[inline]
@@ -4363,7 +5939,10 @@ impl Vec4Swizzles for Vec4 {
 
         #[cfg(vec4_f32)]
         {
-            Vec2(self.3, self.3)
+            Vec2 {
+                x: self.w,
+                y: self.w,
+            }
         }
     }
 }
diff --git a/src/lib.rs b/src/lib.rs
index e892625..81efdb6 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -46,33 +46,6 @@ All the main `glam` types are `#[repr(C)]`, so they are possible to expose as
 struct members to C interfaces if desired. Be mindful of Vec3A's extra padding
 though.
 
-## Accessing internal data
-
-The SIMD types that `glam` builds on are opaque and their contents are not
-directly accessible. Because of this all types use getter and setter methods
-instead of providing direct access, regardless of whether they are using scalar
-or SIMD storage.
-
-```
-use glam::Vec4;
-let mut v = Vec4::new(1.0, 2.0, 3.0, 4.0);
-assert_eq!(v.y(), 2.0);
-v.set_z(1.0);
-assert_eq!(v.z(), 1.0);
-*v.x_mut() = 2.0;
-assert_eq!(v.x(), 2.0);
-```
-
-If you need to access multiple elements it is easier to convert the type to a
-tuple or array:
-
-```
-use glam::Vec4;
-let v = Vec4::new(1.0, 2.0, 3.0, 4.0);
-let (x, y, z, w) = v.into();
-assert_eq!((x, y, z, w), (1.0, 2.0, 3.0, 4.0));
-```
-
 ## Vec3A
 
 `Vec3A` is a SIMD optimized version of the `Vec3` type, which due to 16 byte
@@ -204,17 +177,13 @@ pub mod f32;
 extern crate num_traits;
 
 pub use self::f32::{
-    mat2, mat3, mat4, quat, vec2, vec3, vec3a, vec4, Mat2, Mat3, Mat4, Quat, Vec2,
-    Vec2Mask, Vec3, Vec3A, Vec3AMask, Vec3Mask, Vec4, Vec4Mask,
+    mat2, mat3, mat4, quat, vec2, vec3, vec3a, vec4, Mat2, Mat3, Mat4, Quat, Vec2, Vec2Mask, Vec3,
+    Vec3A, Vec3AMask, Vec3Mask, Vec4, Vec4Mask,
 };
 pub mod swizzles {
-    pub use super::f32::{
-        Vec2Swizzles, Vec3ASwizzles, Vec3Swizzles, Vec4Swizzles,
-    };
+    pub use super::f32::{Vec2Swizzles, Vec3ASwizzles, Vec3Swizzles, Vec4Swizzles};
 }
-pub use swizzles::{
-    Vec2Swizzles, Vec3ASwizzles, Vec3Swizzles, Vec4Swizzles,
-};
+pub use swizzles::{Vec2Swizzles, Vec3ASwizzles, Vec3Swizzles, Vec4Swizzles};
 
 #[cfg(feature = "transform-types")]
 pub use self::f32::{TransformRT, TransformSRT};
diff --git a/swizzlegen/src/main.rs b/swizzlegen/src/main.rs
index 8ccfaf0..089100d 100644
--- a/swizzlegen/src/main.rs
+++ b/swizzlegen/src/main.rs
@@ -161,10 +161,15 @@ impl Vec4Swizzles for Vec4 {{"#
 
         #[cfg(vec4_f32)]
         {{
-            Vec4(self.{}, self.{}, self.{}, self.{})
+            Vec4 {{
+                x: self.{},
+                y: self.{},
+                z: self.{},
+                w: self.{},
+            }}
         }}
     }}"#,
-                E[e0], E[e1], E[e2], E[e3], B[e3], B[e2], B[e1], B[e0], e0, e1, e2, e3,
+                E[e0], E[e1], E[e2], E[e3], B[e3], B[e2], B[e1], B[e0], E[e0], E[e1], E[e2], E[e3],
             )
         },
         |out, e0, e1, e2| {
@@ -180,10 +185,14 @@ impl Vec4Swizzles for Vec4 {{"#
 
         #[cfg(vec4_f32)]
         {{
-            Vec3(self.{}, self.{}, self.{})
+            Vec3 {{
+                x: self.{},
+                y: self.{},
+                z: self.{},
+            }}
         }}
     }}"#,
-                E[e0], E[e1], E[e2], B[e2], B[e1], B[e0], e0, e1, e2
+                E[e0], E[e1], E[e2], B[e2], B[e1], B[e0], E[e0], E[e1], E[e2]
             )
         },
         |out, e0, e1| {
@@ -199,10 +208,13 @@ impl Vec4Swizzles for Vec4 {{"#
 
         #[cfg(vec4_f32)]
         {{
-            Vec2(self.{}, self.{})
+            Vec2 {{
+                x: self.{},
+                y: self.{},
+            }}
         }}
     }}"#,
-                E[e0], E[e1], B[e1], B[e0], e0, e1
+                E[e0], E[e1], B[e1], B[e0], E[e0], E[e1]
             )
         },
     )?;
@@ -255,10 +267,10 @@ impl Vec3ASwizzles for Vec3A {{"#
 
         #[cfg(vec3a_f32)]
         {{
-            Vec4((self.0).{}, (self.0).{}, (self.0).{}, (self.0).{})
+            Vec4 {{ x: self.0.{}(), y: self.0.{}(), z: self.0.{}(), w: self.0.{}() }}
         }}
     }}"#,
-                E[e0], E[e1], E[e2], E[e3], B[e3], B[e2], B[e1], B[e0], e0, e1, e2, e3,
+                E[e0], E[e1], E[e2], E[e3], B[e3], B[e2], B[e1], B[e0], E[e0], E[e1], E[e2], E[e3],
             )
         },
         |out, e0, e1, e2| {
@@ -274,10 +286,10 @@ impl Vec3ASwizzles for Vec3A {{"#
 
         #[cfg(vec3a_f32)]
         {{
-            Vec3A(Vec3((self.0).{}, (self.0).{}, (self.0).{}))
+            Vec3A(Vec3 {{ x: self.0.{}(), y: self.0.{}(), z: self.0.{}() }})
         }}
     }}"#,
-                E[e0], E[e1], E[e2], B[e2], B[e1], B[e0], e0, e1, e2
+                E[e0], E[e1], E[e2], B[e2], B[e1], B[e0], E[e0], E[e1], E[e2]
             )
         },
         |out, e0, e1| {
@@ -293,10 +305,10 @@ impl Vec3ASwizzles for Vec3A {{"#
 
         #[cfg(vec3a_f32)]
         {{
-            Vec2((self.0).{}, (self.0).{})
+            Vec2 {{ x: self.0.{}, y: self.0.{} }}
         }}
     }}"#,
-                E[e0], E[e1], B[e1], B[e0], e0, e1
+                E[e0], E[e1], B[e1], B[e0], E[e0], E[e1]
             )
         },
     )?;
@@ -335,7 +347,7 @@ impl Vec3Swizzles for Vec3 {{"#
     fn {}{}{}{}(self) -> Vec4 {{
         Vec4::new(self.{}, self.{}, self.{}, self.{})
     }}"#,
-                E[e0], E[e1], E[e2], E[e3], e0, e1, e2, e3,
+                E[e0], E[e1], E[e2], E[e3], E[e0], E[e1], E[e2], E[e3],
             )
         },
         |out, e0, e1, e2| {
@@ -344,9 +356,13 @@ impl Vec3Swizzles for Vec3 {{"#
                 r#"
     #[inline]
     fn {}{}{}(self) -> Vec3 {{
-        Vec3(self.{}, self.{}, self.{})
+        Vec3 {{
+            x: self.{},
+            y: self.{},
+            z: self.{},
+        }}
     }}"#,
-                E[e0], E[e1], E[e2], e0, e1, e2
+                E[e0], E[e1], E[e2], E[e0], E[e1], E[e2]
             )
         },
         |out, e0, e1| {
@@ -355,9 +371,12 @@ impl Vec3Swizzles for Vec3 {{"#
                 r#"
     #[inline]
     fn {}{}(self) -> Vec2 {{
-        Vec2(self.{}, self.{})
+        Vec2 {{
+            x: self.{},
+            y: self.{},
+        }}
     }}"#,
-                E[e0], E[e1], e0, e1
+                E[e0], E[e1], E[e0], E[e1]
             )
         },
     )?;
@@ -396,7 +415,7 @@ impl Vec2Swizzles for Vec2 {{"#
     fn {}{}{}{}(self) -> Vec4 {{
         Vec4::new(self.{}, self.{}, self.{}, self.{})
     }}"#,
-                E[e0], E[e1], E[e2], E[e3], e0, e1, e2, e3,
+                E[e0], E[e1], E[e2], E[e3], E[e0], E[e1], E[e2], E[e3],
             )
         },
         |out, e0, e1, e2| {
@@ -405,9 +424,13 @@ impl Vec2Swizzles for Vec2 {{"#
                 r#"
     #[inline]
     fn {}{}{}(self) -> Vec3 {{
-        Vec3(self.{}, self.{}, self.{})
+        Vec3 {{
+            x: self.{},
+            y: self.{},
+            z: self.{},
+        }}
     }}"#,
-                E[e0], E[e1], E[e2], e0, e1, e2
+                E[e0], E[e1], E[e2], E[e0], E[e1], E[e2]
             )
         },
         |out, e0, e1| {
@@ -416,9 +439,12 @@ impl Vec2Swizzles for Vec2 {{"#
                 r#"
     #[inline]
     fn {}{}(self) -> Vec2 {{
-        Vec2(self.{}, self.{})
+        Vec2 {{
+            x: self.{},
+            y: self.{},
+        }}
     }}"#,
-                E[e0], E[e1], e0, e1
+                E[e0], E[e1], E[e0], E[e1]
             )
         },
     )?;
@@ -452,7 +478,7 @@ fn write_test_head(out: &mut impl Write) -> Result<()> {
     write!(
         out,
         r#"// Generated by swizzles. Do not edit.
-use glam::{{vec2, vec3, vec3a, vec4, Vec2Swizzles, Vec3ASwizzles, Vec3Swizzles, Vec4Swizzles}};
+use glam::{{swizzles::*, vec2, vec3, vec3a, vec4}};
 "#
     )?;
     Ok(())


Test patch:
diff --git a/tests/mat2.rs b/tests/mat2.rs
index 1d8e4f0..565cd11 100644
--- a/tests/mat2.rs
+++ b/tests/mat2.rs
@@ -201,4 +201,4 @@ fn test_sum() {
 fn test_product() {
     let two = Mat2::identity() + Mat2::identity();
     assert_eq!(vec![two, two].iter().product::<Mat2>(), two * two);
-}
\ No newline at end of file
+}
diff --git a/tests/mat3.rs b/tests/mat3.rs
index 273a694..dc7bc87 100644
--- a/tests/mat3.rs
+++ b/tests/mat3.rs
@@ -267,4 +267,4 @@ fn test_sum() {
 fn test_product() {
     let two = Mat3::identity() + Mat3::identity();
     assert_eq!(vec![two, two].iter().product::<Mat3>(), two * two);
-}
\ No newline at end of file
+}
diff --git a/tests/mat4.rs b/tests/mat4.rs
index 6162183..e162c30 100644
--- a/tests/mat4.rs
+++ b/tests/mat4.rs
@@ -550,4 +550,4 @@ fn test_sum() {
 fn test_product() {
     let two = Mat4::identity() + Mat4::identity();
     assert_eq!(vec![two, two].iter().product::<Mat4>(), two * two);
-}
\ No newline at end of file
+}
diff --git a/tests/quat.rs b/tests/quat.rs
index 68b8833..fe370ed 100644
--- a/tests/quat.rs
+++ b/tests/quat.rs
@@ -324,6 +324,11 @@ fn test_quat_elements() {
     let w = 4.0;
 
     let a = Quat::from_xyzw(x, y, z, w);
+    assert!(a.x == x);
+    assert!(a.y == y);
+    assert!(a.z == z);
+    assert!(a.w == w);
+
     assert!(a.x() == x);
     assert!(a.y() == y);
     assert!(a.z() == z);
diff --git a/tests/vec2.rs b/tests/vec2.rs
index 9530d96..a9d67fc 100644
--- a/tests/vec2.rs
+++ b/tests/vec2.rs
@@ -16,6 +16,9 @@ fn test_vec2_align() {
 fn test_vec2_new() {
     let v = vec2(1.0, 2.0);
 
+    assert_eq!(v.x, 1.0);
+    assert_eq!(v.y, 2.0);
+
     assert_eq!(v.x(), 1.0);
     assert_eq!(v.y(), 2.0);
 
@@ -58,6 +61,13 @@ fn test_vec2_splat() {
 
 #[test]
 fn test_vec2_accessors() {
+    let mut a = Vec2::zero();
+    a.x = 1.0;
+    a.y = 2.0;
+    assert_eq!(1.0, a.x);
+    assert_eq!(2.0, a.y);
+    assert_eq!(Vec2::new(1.0, 2.0), a);
+
     let mut a = Vec2::zero();
     a.set_x(1.0);
     a.set_y(2.0);
@@ -398,18 +408,18 @@ fn test_vec2_abs() {
 
 #[test]
 fn test_vec2_round() {
-    assert_eq!(Vec2::new(1.35, 0.0).round().x(), 1.0);
-    assert_eq!(Vec2::new(0.0, 1.5).round().y(), 2.0);
-    assert_eq!(Vec2::new(0.0, -15.5).round().y(), -16.0);
-    assert_eq!(Vec2::new(0.0, 0.0).round().y(), 0.0);
-    assert_eq!(Vec2::new(0.0, 21.1).round().y(), 21.0);
-    assert_eq!(Vec2::new(0.0, 11.123).round().y(), 11.0);
-    assert_eq!(Vec2::new(0.0, 11.499).round().y(), 11.0);
+    assert_eq!(Vec2::new(1.35, 0.0).round().x, 1.0);
+    assert_eq!(Vec2::new(0.0, 1.5).round().y, 2.0);
+    assert_eq!(Vec2::new(0.0, -15.5).round().y, -16.0);
+    assert_eq!(Vec2::new(0.0, 0.0).round().y, 0.0);
+    assert_eq!(Vec2::new(0.0, 21.1).round().y, 21.0);
+    assert_eq!(Vec2::new(0.0, 11.123).round().y, 11.0);
+    assert_eq!(Vec2::new(0.0, 11.499).round().y, 11.0);
     assert_eq!(
         Vec2::new(f32::NEG_INFINITY, f32::INFINITY).round(),
         Vec2::new(f32::NEG_INFINITY, f32::INFINITY)
     );
-    assert!(Vec2::new(f32::NAN, 0.0).round().x().is_nan());
+    assert!(Vec2::new(f32::NAN, 0.0).round().x.is_nan());
 }
 
 #[test]
@@ -419,7 +429,7 @@ fn test_vec2_floor() {
         Vec2::new(f32::INFINITY, f32::NEG_INFINITY).floor(),
         Vec2::new(f32::INFINITY, f32::NEG_INFINITY)
     );
-    assert!(Vec2::new(f32::NAN, 0.0).floor().x().is_nan());
+    assert!(Vec2::new(f32::NAN, 0.0).floor().x.is_nan());
     assert_eq!(
         Vec2::new(-2000000.123, 10000000.123).floor(),
         Vec2::new(-2000001.0, 10000000.0)
@@ -433,7 +443,7 @@ fn test_vec2_ceil() {
         Vec2::new(f32::INFINITY, f32::NEG_INFINITY).ceil(),
         Vec2::new(f32::INFINITY, f32::NEG_INFINITY)
     );
-    assert!(Vec2::new(f32::NAN, 0.0).ceil().x().is_nan());
+    assert!(Vec2::new(f32::NAN, 0.0).ceil().x.is_nan());
     assert_eq!(
         Vec2::new(-2000000.123, 1000000.123).ceil(),
         Vec2::new(-2000000.0, 1000001.0)
diff --git a/tests/vec3.rs b/tests/vec3.rs
index 30e056d..67df4c0 100644
--- a/tests/vec3.rs
+++ b/tests/vec3.rs
@@ -16,6 +16,10 @@ fn test_vec3_align() {
 fn test_vec3_new() {
     let v = vec3(1.0, 2.0, 3.0);
 
+    assert_eq!(v.x, 1.0);
+    assert_eq!(v.y, 2.0);
+    assert_eq!(v.z, 3.0);
+
     assert_eq!(v.x(), 1.0);
     assert_eq!(v.y(), 2.0);
     assert_eq!(v.z(), 3.0);
@@ -60,6 +64,15 @@ fn test_vec3_splat() {
 
 #[test]
 fn test_vec3_accessors() {
+    let mut a = Vec3::zero();
+    a.x = 1.0;
+    a.y = 2.0;
+    a.z = 3.0;
+    assert_eq!(1.0, a.x);
+    assert_eq!(2.0, a.y);
+    assert_eq!(3.0, a.z);
+    assert_eq!((1.0, 2.0, 3.0), a.into());
+
     let mut a = Vec3::zero();
     a.set_x(1.0);
     a.set_y(2.0);
@@ -575,4 +588,3 @@ fn test_product() {
     let two = Vec3::new(2.0, 2.0, 2.0);
     assert_eq!(vec![two, two].iter().product::<Vec3>(), two * two);
 }
-
diff --git a/tests/vec3a.rs b/tests/vec3a.rs
index d278dce..ea5c795 100644
--- a/tests/vec3a.rs
+++ b/tests/vec3a.rs
@@ -16,6 +16,10 @@ fn test_vec3a_align() {
 fn test_vec3a_new() {
     let v = vec3a(1.0, 2.0, 3.0);
 
+    assert_eq!(v.x, 1.0);
+    assert_eq!(v.y, 2.0);
+    assert_eq!(v.z, 3.0);
+
     assert_eq!(v.x(), 1.0);
     assert_eq!(v.y(), 2.0);
     assert_eq!(v.z(), 3.0);
@@ -460,18 +464,18 @@ fn test_vec3a_abs() {
 
 #[test]
 fn test_vec3a_round() {
-    assert_eq!(Vec3A::new(1.35, 0.0, 0.0).round().x(), 1.0);
-    assert_eq!(Vec3A::new(0.0, 1.5, 0.0).round().y(), 2.0);
-    assert_eq!(Vec3A::new(0.0, 0.0, -15.5).round().z(), -16.0);
-    assert_eq!(Vec3A::new(0.0, 0.0, 0.0).round().z(), 0.0);
-    assert_eq!(Vec3A::new(0.0, 21.1, 0.0).round().y(), 21.0);
-    assert_eq!(Vec3A::new(0.0, 11.123, 0.0).round().y(), 11.0);
-    assert_eq!(Vec3A::new(0.0, 11.499, 0.0).round().y(), 11.0);
+    assert_eq!(Vec3A::new(1.35, 0.0, 0.0).round().x, 1.0);
+    assert_eq!(Vec3A::new(0.0, 1.5, 0.0).round().y, 2.0);
+    assert_eq!(Vec3A::new(0.0, 0.0, -15.5).round().z, -16.0);
+    assert_eq!(Vec3A::new(0.0, 0.0, 0.0).round().z, 0.0);
+    assert_eq!(Vec3A::new(0.0, 21.1, 0.0).round().y, 21.0);
+    assert_eq!(Vec3A::new(0.0, 11.123, 0.0).round().y, 11.0);
+    assert_eq!(Vec3A::new(0.0, 11.499, 0.0).round().y, 11.0);
     assert_eq!(
         Vec3A::new(f32::NEG_INFINITY, f32::INFINITY, 0.0).round(),
         Vec3A::new(f32::NEG_INFINITY, f32::INFINITY, 0.0)
     );
-    assert!(Vec3A::new(f32::NAN, 0.0, 0.0).round().x().is_nan());
+    assert!(Vec3A::new(f32::NAN, 0.0, 0.0).round().x.is_nan());
 }
 
 #[test]
@@ -484,7 +488,7 @@ fn test_vec3a_floor() {
         Vec3A::new(f32::INFINITY, f32::NEG_INFINITY, 0.0).floor(),
         Vec3A::new(f32::INFINITY, f32::NEG_INFINITY, 0.0)
     );
-    assert!(Vec3A::new(f32::NAN, 0.0, 0.0).floor().x().is_nan());
+    assert!(Vec3A::new(f32::NAN, 0.0, 0.0).floor().x.is_nan());
     assert_eq!(
         Vec3A::new(-2000000.123, 10000000.123, 1000.9).floor(),
         Vec3A::new(-2000001.0, 10000000.0, 1000.0)
@@ -501,7 +505,7 @@ fn test_vec3a_ceil() {
         Vec3A::new(f32::INFINITY, f32::NEG_INFINITY, 0.0).ceil(),
         Vec3A::new(f32::INFINITY, f32::NEG_INFINITY, 0.0)
     );
-    assert!(Vec3A::new(f32::NAN, 0.0, 0.0).ceil().x().is_nan());
+    assert!(Vec3A::new(f32::NAN, 0.0, 0.0).ceil().x.is_nan());
     assert_eq!(
         Vec3A::new(-2000000.123, 1000000.123, 1000.9).ceil(),
         Vec3A::new(-2000000.0, 1000001.0, 1001.0)
diff --git a/tests/vec4.rs b/tests/vec4.rs
index fdb63e2..bd39c87 100644
--- a/tests/vec4.rs
+++ b/tests/vec4.rs
@@ -21,6 +21,11 @@ fn test_vec4_align() {
 fn test_vec4_new() {
     let v = vec4(1.0, 2.0, 3.0, 4.0);
 
+    assert_eq!(v.x, 1.0);
+    assert_eq!(v.y, 2.0);
+    assert_eq!(v.z, 3.0);
+    assert_eq!(v.w, 4.0);
+
     assert_eq!(v.x(), 1.0);
     assert_eq!(v.y(), 2.0);
     assert_eq!(v.z(), 3.0);
@@ -70,6 +75,17 @@ fn test_vec4_splat() {
 
 #[test]
 fn test_vec4_accessors() {
+    let mut a = Vec4::zero();
+    a.x = 1.0;
+    a.y = 2.0;
+    a.z = 3.0;
+    a.w = 4.0;
+    assert_eq!(1.0, a.x);
+    assert_eq!(2.0, a.y);
+    assert_eq!(3.0, a.z);
+    assert_eq!(4.0, a.w);
+    assert_eq!((1.0, 2.0, 3.0, 4.0), a.into());
+
     let mut a = Vec4::zero();
     a.set_x(1.0);
     a.set_y(2.0);
@@ -506,18 +522,18 @@ fn test_vec4mask_hash() {
 
 #[test]
 fn test_vec4_round() {
-    assert_eq!(Vec4::new(1.35, 0.0, 0.0, 0.0).round().x(), 1.0);
-    assert_eq!(Vec4::new(0.0, 1.5, 0.0, 0.0).round().y(), 2.0);
-    assert_eq!(Vec4::new(0.0, 0.0, -15.5, 0.0).round().z(), -16.0);
-    assert_eq!(Vec4::new(0.0, 0.0, 0.0, 0.0).round().z(), 0.0);
-    assert_eq!(Vec4::new(0.0, 21.1, 0.0, 0.0).round().y(), 21.0);
-    assert_eq!(Vec4::new(0.0, 0.0, 0.0, 11.123).round().w(), 11.0);
-    assert_eq!(Vec4::new(0.0, 0.0, 11.501, 0.0).round().z(), 12.0);
+    assert_eq!(Vec4::new(1.35, 0.0, 0.0, 0.0).round().x, 1.0);
+    assert_eq!(Vec4::new(0.0, 1.5, 0.0, 0.0).round().y, 2.0);
+    assert_eq!(Vec4::new(0.0, 0.0, -15.5, 0.0).round().z, -16.0);
+    assert_eq!(Vec4::new(0.0, 0.0, 0.0, 0.0).round().z, 0.0);
+    assert_eq!(Vec4::new(0.0, 21.1, 0.0, 0.0).round().y, 21.0);
+    assert_eq!(Vec4::new(0.0, 0.0, 0.0, 11.123).round().w, 11.0);
+    assert_eq!(Vec4::new(0.0, 0.0, 11.501, 0.0).round().z, 12.0);
     assert_eq!(
         Vec4::new(f32::NEG_INFINITY, f32::INFINITY, 1.0, -1.0).round(),
         Vec4::new(f32::NEG_INFINITY, f32::INFINITY, 1.0, -1.0)
     );
-    assert!(Vec4::new(f32::NAN, 0.0, 0.0, 1.0).round().x().is_nan());
+    assert!(Vec4::new(f32::NAN, 0.0, 0.0, 1.0).round().x.is_nan());
 }
 
 #[test]