Skip to content

Instantly share code, notes, and snippets.

@edhebi

edhebi/swizzle.hpp

Created August 13, 2020 22:11
Show Gist options
  • Save edhebi/e3bba587744025da1abcf4de4aa83cc4 to your computer and use it in GitHub Desktop.
Save edhebi/e3bba587744025da1abcf4de4aa83cc4 to your computer and use it in GitHub Desktop.
Download ZIP
Raw
swizzle.hpp
#ifndef NEON_MATH_SWIZZLE_HPP
#define NEON_MATH_SWIZZLE_HPP
#include <neon/math/vec.hpp>
namespace neon::math
{
template <std::size_t N, typename T> constexpr auto x(vec_t<N, T> v) noexcept { return v.x; }
template <std::size_t N, typename T> constexpr auto y(vec_t<N, T> v) noexcept { return v.y; }
template <std::size_t N, typename T> constexpr auto z(vec_t<N, T> v) noexcept { return v.z; }
template <std::size_t N, typename T> constexpr auto w(vec_t<N, T> v) noexcept { return v.w; }
template <std::size_t N, typename T> constexpr auto xx(vec_t<N, T> v) noexcept { return vec2_t(v.x, v.x); }
template <std::size_t N, typename T> constexpr auto xy(vec_t<N, T> v) noexcept { return vec2_t(v.x, v.y); }
template <std::size_t N, typename T> constexpr auto xz(vec_t<N, T> v) noexcept { return vec2_t(v.x, v.z); }
template <std::size_t N, typename T> constexpr auto xw(vec_t<N, T> v) noexcept { return vec2_t(v.x, v.w); }
template <std::size_t N, typename T> constexpr auto yx(vec_t<N, T> v) noexcept { return vec2_t(v.y, v.x); }
template <std::size_t N, typename T> constexpr auto yy(vec_t<N, T> v) noexcept { return vec2_t(v.y, v.y); }
template <std::size_t N, typename T> constexpr auto yz(vec_t<N, T> v) noexcept { return vec2_t(v.y, v.z); }
template <std::size_t N, typename T> constexpr auto yw(vec_t<N, T> v) noexcept { return vec2_t(v.y, v.w); }
template <std::size_t N, typename T> constexpr auto zx(vec_t<N, T> v) noexcept { return vec2_t(v.z, v.x); }
template <std::size_t N, typename T> constexpr auto zy(vec_t<N, T> v) noexcept { return vec2_t(v.z, v.y); }
template <std::size_t N, typename T> constexpr auto zz(vec_t<N, T> v) noexcept { return vec2_t(v.z, v.z); }
template <std::size_t N, typename T> constexpr auto zw(vec_t<N, T> v) noexcept { return vec2_t(v.z, v.w); }
template <std::size_t N, typename T> constexpr auto wx(vec_t<N, T> v) noexcept { return vec2_t(v.w, v.x); }
template <std::size_t N, typename T> constexpr auto wy(vec_t<N, T> v) noexcept { return vec2_t(v.w, v.y); }
template <std::size_t N, typename T> constexpr auto wz(vec_t<N, T> v) noexcept { return vec2_t(v.w, v.z); }
template <std::size_t N, typename T> constexpr auto ww(vec_t<N, T> v) noexcept { return vec2_t(v.w, v.w); }
template <std::size_t N, typename T> constexpr auto xxx(vec_t<N, T> v) noexcept { return vec3_t(v.x, v.x, v.x); }
template <std::size_t N, typename T> constexpr auto xxy(vec_t<N, T> v) noexcept { return vec3_t(v.x, v.x, v.y); }
template <std::size_t N, typename T> constexpr auto xxz(vec_t<N, T> v) noexcept { return vec3_t(v.x, v.x, v.z); }
template <std::size_t N, typename T> constexpr auto xxw(vec_t<N, T> v) noexcept { return vec3_t(v.x, v.x, v.w); }
template <std::size_t N, typename T> constexpr auto xyx(vec_t<N, T> v) noexcept { return vec3_t(v.x, v.y, v.x); }
template <std::size_t N, typename T> constexpr auto xyy(vec_t<N, T> v) noexcept { return vec3_t(v.x, v.y, v.y); }
template <std::size_t N, typename T> constexpr auto xyz(vec_t<N, T> v) noexcept { return vec3_t(v.x, v.y, v.z); }
template <std::size_t N, typename T> constexpr auto xyw(vec_t<N, T> v) noexcept { return vec3_t(v.x, v.y, v.w); }
template <std::size_t N, typename T> constexpr auto xzx(vec_t<N, T> v) noexcept { return vec3_t(v.x, v.z, v.x); }
template <std::size_t N, typename T> constexpr auto xzy(vec_t<N, T> v) noexcept { return vec3_t(v.x, v.z, v.y); }
template <std::size_t N, typename T> constexpr auto xzz(vec_t<N, T> v) noexcept { return vec3_t(v.x, v.z, v.z); }
template <std::size_t N, typename T> constexpr auto xzw(vec_t<N, T> v) noexcept { return vec3_t(v.x, v.z, v.w); }
template <std::size_t N, typename T> constexpr auto xwx(vec_t<N, T> v) noexcept { return vec3_t(v.x, v.w, v.x); }
template <std::size_t N, typename T> constexpr auto xwy(vec_t<N, T> v) noexcept { return vec3_t(v.x, v.w, v.y); }
template <std::size_t N, typename T> constexpr auto xwz(vec_t<N, T> v) noexcept { return vec3_t(v.x, v.w, v.z); }
template <std::size_t N, typename T> constexpr auto xww(vec_t<N, T> v) noexcept { return vec3_t(v.x, v.w, v.w); }
template <std::size_t N, typename T> constexpr auto yxx(vec_t<N, T> v) noexcept { return vec3_t(v.y, v.x, v.x); }
template <std::size_t N, typename T> constexpr auto yxy(vec_t<N, T> v) noexcept { return vec3_t(v.y, v.x, v.y); }
template <std::size_t N, typename T> constexpr auto yxz(vec_t<N, T> v) noexcept { return vec3_t(v.y, v.x, v.z); }
template <std::size_t N, typename T> constexpr auto yxw(vec_t<N, T> v) noexcept { return vec3_t(v.y, v.x, v.w); }
template <std::size_t N, typename T> constexpr auto yyx(vec_t<N, T> v) noexcept { return vec3_t(v.y, v.y, v.x); }
template <std::size_t N, typename T> constexpr auto yyy(vec_t<N, T> v) noexcept { return vec3_t(v.y, v.y, v.y); }
template <std::size_t N, typename T> constexpr auto yyz(vec_t<N, T> v) noexcept { return vec3_t(v.y, v.y, v.z); }
template <std::size_t N, typename T> constexpr auto yyw(vec_t<N, T> v) noexcept { return vec3_t(v.y, v.y, v.w); }
template <std::size_t N, typename T> constexpr auto yzx(vec_t<N, T> v) noexcept { return vec3_t(v.y, v.z, v.x); }
template <std::size_t N, typename T> constexpr auto yzy(vec_t<N, T> v) noexcept { return vec3_t(v.y, v.z, v.y); }
template <std::size_t N, typename T> constexpr auto yzz(vec_t<N, T> v) noexcept { return vec3_t(v.y, v.z, v.z); }
template <std::size_t N, typename T> constexpr auto yzw(vec_t<N, T> v) noexcept { return vec3_t(v.y, v.z, v.w); }
template <std::size_t N, typename T> constexpr auto ywx(vec_t<N, T> v) noexcept { return vec3_t(v.y, v.w, v.x); }
template <std::size_t N, typename T> constexpr auto ywy(vec_t<N, T> v) noexcept { return vec3_t(v.y, v.w, v.y); }
template <std::size_t N, typename T> constexpr auto ywz(vec_t<N, T> v) noexcept { return vec3_t(v.y, v.w, v.z); }
template <std::size_t N, typename T> constexpr auto yww(vec_t<N, T> v) noexcept { return vec3_t(v.y, v.w, v.w); }
template <std::size_t N, typename T> constexpr auto zxx(vec_t<N, T> v) noexcept { return vec3_t(v.z, v.x, v.x); }
template <std::size_t N, typename T> constexpr auto zxy(vec_t<N, T> v) noexcept { return vec3_t(v.z, v.x, v.y); }
template <std::size_t N, typename T> constexpr auto zxz(vec_t<N, T> v) noexcept { return vec3_t(v.z, v.x, v.z); }
template <std::size_t N, typename T> constexpr auto zxw(vec_t<N, T> v) noexcept { return vec3_t(v.z, v.x, v.w); }
template <std::size_t N, typename T> constexpr auto zyx(vec_t<N, T> v) noexcept { return vec3_t(v.z, v.y, v.x); }
template <std::size_t N, typename T> constexpr auto zyy(vec_t<N, T> v) noexcept { return vec3_t(v.z, v.y, v.y); }
template <std::size_t N, typename T> constexpr auto zyz(vec_t<N, T> v) noexcept { return vec3_t(v.z, v.y, v.z); }
template <std::size_t N, typename T> constexpr auto zyw(vec_t<N, T> v) noexcept { return vec3_t(v.z, v.y, v.w); }
template <std::size_t N, typename T> constexpr auto zzx(vec_t<N, T> v) noexcept { return vec3_t(v.z, v.z, v.x); }
template <std::size_t N, typename T> constexpr auto zzy(vec_t<N, T> v) noexcept { return vec3_t(v.z, v.z, v.y); }
template <std::size_t N, typename T> constexpr auto zzz(vec_t<N, T> v) noexcept { return vec3_t(v.z, v.z, v.z); }
template <std::size_t N, typename T> constexpr auto zzw(vec_t<N, T> v) noexcept { return vec3_t(v.z, v.z, v.w); }
template <std::size_t N, typename T> constexpr auto zwx(vec_t<N, T> v) noexcept { return vec3_t(v.z, v.w, v.x); }
template <std::size_t N, typename T> constexpr auto zwy(vec_t<N, T> v) noexcept { return vec3_t(v.z, v.w, v.y); }
template <std::size_t N, typename T> constexpr auto zwz(vec_t<N, T> v) noexcept { return vec3_t(v.z, v.w, v.z); }
template <std::size_t N, typename T> constexpr auto zww(vec_t<N, T> v) noexcept { return vec3_t(v.z, v.w, v.w); }
template <std::size_t N, typename T> constexpr auto wxx(vec_t<N, T> v) noexcept { return vec3_t(v.w, v.x, v.x); }
template <std::size_t N, typename T> constexpr auto wxy(vec_t<N, T> v) noexcept { return vec3_t(v.w, v.x, v.y); }
template <std::size_t N, typename T> constexpr auto wxz(vec_t<N, T> v) noexcept { return vec3_t(v.w, v.x, v.z); }
template <std::size_t N, typename T> constexpr auto wxw(vec_t<N, T> v) noexcept { return vec3_t(v.w, v.x, v.w); }
template <std::size_t N, typename T> constexpr auto wyx(vec_t<N, T> v) noexcept { return vec3_t(v.w, v.y, v.x); }
template <std::size_t N, typename T> constexpr auto wyy(vec_t<N, T> v) noexcept { return vec3_t(v.w, v.y, v.y); }
template <std::size_t N, typename T> constexpr auto wyz(vec_t<N, T> v) noexcept { return vec3_t(v.w, v.y, v.z); }
template <std::size_t N, typename T> constexpr auto wyw(vec_t<N, T> v) noexcept { return vec3_t(v.w, v.y, v.w); }
template <std::size_t N, typename T> constexpr auto wzx(vec_t<N, T> v) noexcept { return vec3_t(v.w, v.z, v.x); }
template <std::size_t N, typename T> constexpr auto wzy(vec_t<N, T> v) noexcept { return vec3_t(v.w, v.z, v.y); }
template <std::size_t N, typename T> constexpr auto wzz(vec_t<N, T> v) noexcept { return vec3_t(v.w, v.z, v.z); }
template <std::size_t N, typename T> constexpr auto wzw(vec_t<N, T> v) noexcept { return vec3_t(v.w, v.z, v.w); }
template <std::size_t N, typename T> constexpr auto wwx(vec_t<N, T> v) noexcept { return vec3_t(v.w, v.w, v.x); }
template <std::size_t N, typename T> constexpr auto wwy(vec_t<N, T> v) noexcept { return vec3_t(v.w, v.w, v.y); }
template <std::size_t N, typename T> constexpr auto wwz(vec_t<N, T> v) noexcept { return vec3_t(v.w, v.w, v.z); }
template <std::size_t N, typename T> constexpr auto www(vec_t<N, T> v) noexcept { return vec3_t(v.w, v.w, v.w); }
template <std::size_t N, typename T> constexpr auto xxxx(vec_t<N, T> v) noexcept { return vec4_t(v.x, v.x, v.x, v.x); }
template <std::size_t N, typename T> constexpr auto xxxy(vec_t<N, T> v) noexcept { return vec4_t(v.x, v.x, v.x, v.y); }
template <std::size_t N, typename T> constexpr auto xxxz(vec_t<N, T> v) noexcept { return vec4_t(v.x, v.x, v.x, v.z); }
template <std::size_t N, typename T> constexpr auto xxxw(vec_t<N, T> v) noexcept { return vec4_t(v.x, v.x, v.x, v.w); }
template <std::size_t N, typename T> constexpr auto xxyx(vec_t<N, T> v) noexcept { return vec4_t(v.x, v.x, v.y, v.x); }
template <std::size_t N, typename T> constexpr auto xxyy(vec_t<N, T> v) noexcept { return vec4_t(v.x, v.x, v.y, v.y); }
template <std::size_t N, typename T> constexpr auto xxyz(vec_t<N, T> v) noexcept { return vec4_t(v.x, v.x, v.y, v.z); }
template <std::size_t N, typename T> constexpr auto xxyw(vec_t<N, T> v) noexcept { return vec4_t(v.x, v.x, v.y, v.w); }
template <std::size_t N, typename T> constexpr auto xxzx(vec_t<N, T> v) noexcept { return vec4_t(v.x, v.x, v.z, v.x); }
template <std::size_t N, typename T> constexpr auto xxzy(vec_t<N, T> v) noexcept { return vec4_t(v.x, v.x, v.z, v.y); }
template <std::size_t N, typename T> constexpr auto xxzz(vec_t<N, T> v) noexcept { return vec4_t(v.x, v.x, v.z, v.z); }
template <std::size_t N, typename T> constexpr auto xxzw(vec_t<N, T> v) noexcept { return vec4_t(v.x, v.x, v.z, v.w); }
template <std::size_t N, typename T> constexpr auto xxwx(vec_t<N, T> v) noexcept { return vec4_t(v.x, v.x, v.w, v.x); }
template <std::size_t N, typename T> constexpr auto xxwy(vec_t<N, T> v) noexcept { return vec4_t(v.x, v.x, v.w, v.y); }
template <std::size_t N, typename T> constexpr auto xxwz(vec_t<N, T> v) noexcept { return vec4_t(v.x, v.x, v.w, v.z); }
template <std::size_t N, typename T> constexpr auto xxww(vec_t<N, T> v) noexcept { return vec4_t(v.x, v.x, v.w, v.w); }
template <std::size_t N, typename T> constexpr auto xyxx(vec_t<N, T> v) noexcept { return vec4_t(v.x, v.y, v.x, v.x); }
template <std::size_t N, typename T> constexpr auto xyxy(vec_t<N, T> v) noexcept { return vec4_t(v.x, v.y, v.x, v.y); }
template <std::size_t N, typename T> constexpr auto xyxz(vec_t<N, T> v) noexcept { return vec4_t(v.x, v.y, v.x, v.z); }
template <std::size_t N, typename T> constexpr auto xyxw(vec_t<N, T> v) noexcept { return vec4_t(v.x, v.y, v.x, v.w); }
template <std::size_t N, typename T> constexpr auto xyyx(vec_t<N, T> v) noexcept { return vec4_t(v.x, v.y, v.y, v.x); }
template <std::size_t N, typename T> constexpr auto xyyy(vec_t<N, T> v) noexcept { return vec4_t(v.x, v.y, v.y, v.y); }
template <std::size_t N, typename T> constexpr auto xyyz(vec_t<N, T> v) noexcept { return vec4_t(v.x, v.y, v.y, v.z); }
template <std::size_t N, typename T> constexpr auto xyyw(vec_t<N, T> v) noexcept { return vec4_t(v.x, v.y, v.y, v.w); }
template <std::size_t N, typename T> constexpr auto xyzx(vec_t<N, T> v) noexcept { return vec4_t(v.x, v.y, v.z, v.x); }
template <std::size_t N, typename T> constexpr auto xyzy(vec_t<N, T> v) noexcept { return vec4_t(v.x, v.y, v.z, v.y); }
template <std::size_t N, typename T> constexpr auto xyzz(vec_t<N, T> v) noexcept { return vec4_t(v.x, v.y, v.z, v.z); }
template <std::size_t N, typename T> constexpr auto xyzw(vec_t<N, T> v) noexcept { return vec4_t(v.x, v.y, v.z, v.w); }
template <std::size_t N, typename T> constexpr auto xywx(vec_t<N, T> v) noexcept { return vec4_t(v.x, v.y, v.w, v.x); }
template <std::size_t N, typename T> constexpr auto xywy(vec_t<N, T> v) noexcept { return vec4_t(v.x, v.y, v.w, v.y); }
template <std::size_t N, typename T> constexpr auto xywz(vec_t<N, T> v) noexcept { return vec4_t(v.x, v.y, v.w, v.z); }
template <std::size_t N, typename T> constexpr auto xyww(vec_t<N, T> v) noexcept { return vec4_t(v.x, v.y, v.w, v.w); }
template <std::size_t N, typename T> constexpr auto xzxx(vec_t<N, T> v) noexcept { return vec4_t(v.x, v.z, v.x, v.x); }
template <std::size_t N, typename T> constexpr auto xzxy(vec_t<N, T> v) noexcept { return vec4_t(v.x, v.z, v.x, v.y); }
template <std::size_t N, typename T> constexpr auto xzxz(vec_t<N, T> v) noexcept { return vec4_t(v.x, v.z, v.x, v.z); }
template <std::size_t N, typename T> constexpr auto xzxw(vec_t<N, T> v) noexcept { return vec4_t(v.x, v.z, v.x, v.w); }
template <std::size_t N, typename T> constexpr auto xzyx(vec_t<N, T> v) noexcept { return vec4_t(v.x, v.z, v.y, v.x); }
template <std::size_t N, typename T> constexpr auto xzyy(vec_t<N, T> v) noexcept { return vec4_t(v.x, v.z, v.y, v.y); }
template <std::size_t N, typename T> constexpr auto xzyz(vec_t<N, T> v) noexcept { return vec4_t(v.x, v.z, v.y, v.z); }
template <std::size_t N, typename T> constexpr auto xzyw(vec_t<N, T> v) noexcept { return vec4_t(v.x, v.z, v.y, v.w); }
template <std::size_t N, typename T> constexpr auto xzzx(vec_t<N, T> v) noexcept { return vec4_t(v.x, v.z, v.z, v.x); }
template <std::size_t N, typename T> constexpr auto xzzy(vec_t<N, T> v) noexcept { return vec4_t(v.x, v.z, v.z, v.y); }
template <std::size_t N, typename T> constexpr auto xzzz(vec_t<N, T> v) noexcept { return vec4_t(v.x, v.z, v.z, v.z); }
template <std::size_t N, typename T> constexpr auto xzzw(vec_t<N, T> v) noexcept { return vec4_t(v.x, v.z, v.z, v.w); }
template <std::size_t N, typename T> constexpr auto xzwx(vec_t<N, T> v) noexcept { return vec4_t(v.x, v.z, v.w, v.x); }
template <std::size_t N, typename T> constexpr auto xzwy(vec_t<N, T> v) noexcept { return vec4_t(v.x, v.z, v.w, v.y); }
template <std::size_t N, typename T> constexpr auto xzwz(vec_t<N, T> v) noexcept { return vec4_t(v.x, v.z, v.w, v.z); }
template <std::size_t N, typename T> constexpr auto xzww(vec_t<N, T> v) noexcept { return vec4_t(v.x, v.z, v.w, v.w); }
template <std::size_t N, typename T> constexpr auto xwxx(vec_t<N, T> v) noexcept { return vec4_t(v.x, v.w, v.x, v.x); }
template <std::size_t N, typename T> constexpr auto xwxy(vec_t<N, T> v) noexcept { return vec4_t(v.x, v.w, v.x, v.y); }
template <std::size_t N, typename T> constexpr auto xwxz(vec_t<N, T> v) noexcept { return vec4_t(v.x, v.w, v.x, v.z); }
template <std::size_t N, typename T> constexpr auto xwxw(vec_t<N, T> v) noexcept { return vec4_t(v.x, v.w, v.x, v.w); }
template <std::size_t N, typename T> constexpr auto xwyx(vec_t<N, T> v) noexcept { return vec4_t(v.x, v.w, v.y, v.x); }
template <std::size_t N, typename T> constexpr auto xwyy(vec_t<N, T> v) noexcept { return vec4_t(v.x, v.w, v.y, v.y); }
template <std::size_t N, typename T> constexpr auto xwyz(vec_t<N, T> v) noexcept { return vec4_t(v.x, v.w, v.y, v.z); }
template <std::size_t N, typename T> constexpr auto xwyw(vec_t<N, T> v) noexcept { return vec4_t(v.x, v.w, v.y, v.w); }
template <std::size_t N, typename T> constexpr auto xwzx(vec_t<N, T> v) noexcept { return vec4_t(v.x, v.w, v.z, v.x); }
template <std::size_t N, typename T> constexpr auto xwzy(vec_t<N, T> v) noexcept { return vec4_t(v.x, v.w, v.z, v.y); }
template <std::size_t N, typename T> constexpr auto xwzz(vec_t<N, T> v) noexcept { return vec4_t(v.x, v.w, v.z, v.z); }
template <std::size_t N, typename T> constexpr auto xwzw(vec_t<N, T> v) noexcept { return vec4_t(v.x, v.w, v.z, v.w); }
template <std::size_t N, typename T> constexpr auto xwwx(vec_t<N, T> v) noexcept { return vec4_t(v.x, v.w, v.w, v.x); }
template <std::size_t N, typename T> constexpr auto xwwy(vec_t<N, T> v) noexcept { return vec4_t(v.x, v.w, v.w, v.y); }
template <std::size_t N, typename T> constexpr auto xwwz(vec_t<N, T> v) noexcept { return vec4_t(v.x, v.w, v.w, v.z); }
template <std::size_t N, typename T> constexpr auto xwww(vec_t<N, T> v) noexcept { return vec4_t(v.x, v.w, v.w, v.w); }
template <std::size_t N, typename T> constexpr auto yxxx(vec_t<N, T> v) noexcept { return vec4_t(v.y, v.x, v.x, v.x); }
template <std::size_t N, typename T> constexpr auto yxxy(vec_t<N, T> v) noexcept { return vec4_t(v.y, v.x, v.x, v.y); }
template <std::size_t N, typename T> constexpr auto yxxz(vec_t<N, T> v) noexcept { return vec4_t(v.y, v.x, v.x, v.z); }
template <std::size_t N, typename T> constexpr auto yxxw(vec_t<N, T> v) noexcept { return vec4_t(v.y, v.x, v.x, v.w); }
template <std::size_t N, typename T> constexpr auto yxyx(vec_t<N, T> v) noexcept { return vec4_t(v.y, v.x, v.y, v.x); }
template <std::size_t N, typename T> constexpr auto yxyy(vec_t<N, T> v) noexcept { return vec4_t(v.y, v.x, v.y, v.y); }
template <std::size_t N, typename T> constexpr auto yxyz(vec_t<N, T> v) noexcept { return vec4_t(v.y, v.x, v.y, v.z); }
template <std::size_t N, typename T> constexpr auto yxyw(vec_t<N, T> v) noexcept { return vec4_t(v.y, v.x, v.y, v.w); }
template <std::size_t N, typename T> constexpr auto yxzx(vec_t<N, T> v) noexcept { return vec4_t(v.y, v.x, v.z, v.x); }
template <std::size_t N, typename T> constexpr auto yxzy(vec_t<N, T> v) noexcept { return vec4_t(v.y, v.x, v.z, v.y); }
template <std::size_t N, typename T> constexpr auto yxzz(vec_t<N, T> v) noexcept { return vec4_t(v.y, v.x, v.z, v.z); }
template <std::size_t N, typename T> constexpr auto yxzw(vec_t<N, T> v) noexcept { return vec4_t(v.y, v.x, v.z, v.w); }
template <std::size_t N, typename T> constexpr auto yxwx(vec_t<N, T> v) noexcept { return vec4_t(v.y, v.x, v.w, v.x); }
template <std::size_t N, typename T> constexpr auto yxwy(vec_t<N, T> v) noexcept { return vec4_t(v.y, v.x, v.w, v.y); }
template <std::size_t N, typename T> constexpr auto yxwz(vec_t<N, T> v) noexcept { return vec4_t(v.y, v.x, v.w, v.z); }
template <std::size_t N, typename T> constexpr auto yxww(vec_t<N, T> v) noexcept { return vec4_t(v.y, v.x, v.w, v.w); }
template <std::size_t N, typename T> constexpr auto yyxx(vec_t<N, T> v) noexcept { return vec4_t(v.y, v.y, v.x, v.x); }
template <std::size_t N, typename T> constexpr auto yyxy(vec_t<N, T> v) noexcept { return vec4_t(v.y, v.y, v.x, v.y); }
template <std::size_t N, typename T> constexpr auto yyxz(vec_t<N, T> v) noexcept { return vec4_t(v.y, v.y, v.x, v.z); }
template <std::size_t N, typename T> constexpr auto yyxw(vec_t<N, T> v) noexcept { return vec4_t(v.y, v.y, v.x, v.w); }
template <std::size_t N, typename T> constexpr auto yyyx(vec_t<N, T> v) noexcept { return vec4_t(v.y, v.y, v.y, v.x); }
template <std::size_t N, typename T> constexpr auto yyyy(vec_t<N, T> v) noexcept { return vec4_t(v.y, v.y, v.y, v.y); }
template <std::size_t N, typename T> constexpr auto yyyz(vec_t<N, T> v) noexcept { return vec4_t(v.y, v.y, v.y, v.z); }
template <std::size_t N, typename T> constexpr auto yyyw(vec_t<N, T> v) noexcept { return vec4_t(v.y, v.y, v.y, v.w); }
template <std::size_t N, typename T> constexpr auto yyzx(vec_t<N, T> v) noexcept { return vec4_t(v.y, v.y, v.z, v.x); }
template <std::size_t N, typename T> constexpr auto yyzy(vec_t<N, T> v) noexcept { return vec4_t(v.y, v.y, v.z, v.y); }
template <std::size_t N, typename T> constexpr auto yyzz(vec_t<N, T> v) noexcept { return vec4_t(v.y, v.y, v.z, v.z); }
template <std::size_t N, typename T> constexpr auto yyzw(vec_t<N, T> v) noexcept { return vec4_t(v.y, v.y, v.z, v.w); }
template <std::size_t N, typename T> constexpr auto yywx(vec_t<N, T> v) noexcept { return vec4_t(v.y, v.y, v.w, v.x); }
template <std::size_t N, typename T> constexpr auto yywy(vec_t<N, T> v) noexcept { return vec4_t(v.y, v.y, v.w, v.y); }
template <std::size_t N, typename T> constexpr auto yywz(vec_t<N, T> v) noexcept { return vec4_t(v.y, v.y, v.w, v.z); }
template <std::size_t N, typename T> constexpr auto yyww(vec_t<N, T> v) noexcept { return vec4_t(v.y, v.y, v.w, v.w); }
template <std::size_t N, typename T> constexpr auto yzxx(vec_t<N, T> v) noexcept { return vec4_t(v.y, v.z, v.x, v.x); }
template <std::size_t N, typename T> constexpr auto yzxy(vec_t<N, T> v) noexcept { return vec4_t(v.y, v.z, v.x, v.y); }
template <std::size_t N, typename T> constexpr auto yzxz(vec_t<N, T> v) noexcept { return vec4_t(v.y, v.z, v.x, v.z); }
template <std::size_t N, typename T> constexpr auto yzxw(vec_t<N, T> v) noexcept { return vec4_t(v.y, v.z, v.x, v.w); }
template <std::size_t N, typename T> constexpr auto yzyx(vec_t<N, T> v) noexcept { return vec4_t(v.y, v.z, v.y, v.x); }
template <std::size_t N, typename T> constexpr auto yzyy(vec_t<N, T> v) noexcept { return vec4_t(v.y, v.z, v.y, v.y); }
template <std::size_t N, typename T> constexpr auto yzyz(vec_t<N, T> v) noexcept { return vec4_t(v.y, v.z, v.y, v.z); }
template <std::size_t N, typename T> constexpr auto yzyw(vec_t<N, T> v) noexcept { return vec4_t(v.y, v.z, v.y, v.w); }
template <std::size_t N, typename T> constexpr auto yzzx(vec_t<N, T> v) noexcept { return vec4_t(v.y, v.z, v.z, v.x); }
template <std::size_t N, typename T> constexpr auto yzzy(vec_t<N, T> v) noexcept { return vec4_t(v.y, v.z, v.z, v.y); }
template <std::size_t N, typename T> constexpr auto yzzz(vec_t<N, T> v) noexcept { return vec4_t(v.y, v.z, v.z, v.z); }
template <std::size_t N, typename T> constexpr auto yzzw(vec_t<N, T> v) noexcept { return vec4_t(v.y, v.z, v.z, v.w); }
template <std::size_t N, typename T> constexpr auto yzwx(vec_t<N, T> v) noexcept { return vec4_t(v.y, v.z, v.w, v.x); }
template <std::size_t N, typename T> constexpr auto yzwy(vec_t<N, T> v) noexcept { return vec4_t(v.y, v.z, v.w, v.y); }
template <std::size_t N, typename T> constexpr auto yzwz(vec_t<N, T> v) noexcept { return vec4_t(v.y, v.z, v.w, v.z); }
template <std::size_t N, typename T> constexpr auto yzww(vec_t<N, T> v) noexcept { return vec4_t(v.y, v.z, v.w, v.w); }
template <std::size_t N, typename T> constexpr auto ywxx(vec_t<N, T> v) noexcept { return vec4_t(v.y, v.w, v.x, v.x); }
template <std::size_t N, typename T> constexpr auto ywxy(vec_t<N, T> v) noexcept { return vec4_t(v.y, v.w, v.x, v.y); }
template <std::size_t N, typename T> constexpr auto ywxz(vec_t<N, T> v) noexcept { return vec4_t(v.y, v.w, v.x, v.z); }
template <std::size_t N, typename T> constexpr auto ywxw(vec_t<N, T> v) noexcept { return vec4_t(v.y, v.w, v.x, v.w); }
template <std::size_t N, typename T> constexpr auto ywyx(vec_t<N, T> v) noexcept { return vec4_t(v.y, v.w, v.y, v.x); }
template <std::size_t N, typename T> constexpr auto ywyy(vec_t<N, T> v) noexcept { return vec4_t(v.y, v.w, v.y, v.y); }
template <std::size_t N, typename T> constexpr auto ywyz(vec_t<N, T> v) noexcept { return vec4_t(v.y, v.w, v.y, v.z); }
template <std::size_t N, typename T> constexpr auto ywyw(vec_t<N, T> v) noexcept { return vec4_t(v.y, v.w, v.y, v.w); }
template <std::size_t N, typename T> constexpr auto ywzx(vec_t<N, T> v) noexcept { return vec4_t(v.y, v.w, v.z, v.x); }
template <std::size_t N, typename T> constexpr auto ywzy(vec_t<N, T> v) noexcept { return vec4_t(v.y, v.w, v.z, v.y); }
template <std::size_t N, typename T> constexpr auto ywzz(vec_t<N, T> v) noexcept { return vec4_t(v.y, v.w, v.z, v.z); }
template <std::size_t N, typename T> constexpr auto ywzw(vec_t<N, T> v) noexcept { return vec4_t(v.y, v.w, v.z, v.w); }
template <std::size_t N, typename T> constexpr auto ywwx(vec_t<N, T> v) noexcept { return vec4_t(v.y, v.w, v.w, v.x); }
template <std::size_t N, typename T> constexpr auto ywwy(vec_t<N, T> v) noexcept { return vec4_t(v.y, v.w, v.w, v.y); }
template <std::size_t N, typename T> constexpr auto ywwz(vec_t<N, T> v) noexcept { return vec4_t(v.y, v.w, v.w, v.z); }
template <std::size_t N, typename T> constexpr auto ywww(vec_t<N, T> v) noexcept { return vec4_t(v.y, v.w, v.w, v.w); }
template <std::size_t N, typename T> constexpr auto zxxx(vec_t<N, T> v) noexcept { return vec4_t(v.z, v.x, v.x, v.x); }
template <std::size_t N, typename T> constexpr auto zxxy(vec_t<N, T> v) noexcept { return vec4_t(v.z, v.x, v.x, v.y); }
template <std::size_t N, typename T> constexpr auto zxxz(vec_t<N, T> v) noexcept { return vec4_t(v.z, v.x, v.x, v.z); }
template <std::size_t N, typename T> constexpr auto zxxw(vec_t<N, T> v) noexcept { return vec4_t(v.z, v.x, v.x, v.w); }
template <std::size_t N, typename T> constexpr auto zxyx(vec_t<N, T> v) noexcept { return vec4_t(v.z, v.x, v.y, v.x); }
template <std::size_t N, typename T> constexpr auto zxyy(vec_t<N, T> v) noexcept { return vec4_t(v.z, v.x, v.y, v.y); }
template <std::size_t N, typename T> constexpr auto zxyz(vec_t<N, T> v) noexcept { return vec4_t(v.z, v.x, v.y, v.z); }
template <std::size_t N, typename T> constexpr auto zxyw(vec_t<N, T> v) noexcept { return vec4_t(v.z, v.x, v.y, v.w); }
template <std::size_t N, typename T> constexpr auto zxzx(vec_t<N, T> v) noexcept { return vec4_t(v.z, v.x, v.z, v.x); }
template <std::size_t N, typename T> constexpr auto zxzy(vec_t<N, T> v) noexcept { return vec4_t(v.z, v.x, v.z, v.y); }
template <std::size_t N, typename T> constexpr auto zxzz(vec_t<N, T> v) noexcept { return vec4_t(v.z, v.x, v.z, v.z); }
template <std::size_t N, typename T> constexpr auto zxzw(vec_t<N, T> v) noexcept { return vec4_t(v.z, v.x, v.z, v.w); }
template <std::size_t N, typename T> constexpr auto zxwx(vec_t<N, T> v) noexcept { return vec4_t(v.z, v.x, v.w, v.x); }
template <std::size_t N, typename T> constexpr auto zxwy(vec_t<N, T> v) noexcept { return vec4_t(v.z, v.x, v.w, v.y); }
template <std::size_t N, typename T> constexpr auto zxwz(vec_t<N, T> v) noexcept { return vec4_t(v.z, v.x, v.w, v.z); }
template <std::size_t N, typename T> constexpr auto zxww(vec_t<N, T> v) noexcept { return vec4_t(v.z, v.x, v.w, v.w); }
template <std::size_t N, typename T> constexpr auto zyxx(vec_t<N, T> v) noexcept { return vec4_t(v.z, v.y, v.x, v.x); }
template <std::size_t N, typename T> constexpr auto zyxy(vec_t<N, T> v) noexcept { return vec4_t(v.z, v.y, v.x, v.y); }
template <std::size_t N, typename T> constexpr auto zyxz(vec_t<N, T> v) noexcept { return vec4_t(v.z, v.y, v.x, v.z); }
template <std::size_t N, typename T> constexpr auto zyxw(vec_t<N, T> v) noexcept { return vec4_t(v.z, v.y, v.x, v.w); }
template <std::size_t N, typename T> constexpr auto zyyx(vec_t<N, T> v) noexcept { return vec4_t(v.z, v.y, v.y, v.x); }
template <std::size_t N, typename T> constexpr auto zyyy(vec_t<N, T> v) noexcept { return vec4_t(v.z, v.y, v.y, v.y); }
template <std::size_t N, typename T> constexpr auto zyyz(vec_t<N, T> v) noexcept { return vec4_t(v.z, v.y, v.y, v.z); }
template <std::size_t N, typename T> constexpr auto zyyw(vec_t<N, T> v) noexcept { return vec4_t(v.z, v.y, v.y, v.w); }
template <std::size_t N, typename T> constexpr auto zyzx(vec_t<N, T> v) noexcept { return vec4_t(v.z, v.y, v.z, v.x); }
template <std::size_t N, typename T> constexpr auto zyzy(vec_t<N, T> v) noexcept { return vec4_t(v.z, v.y, v.z, v.y); }
template <std::size_t N, typename T> constexpr auto zyzz(vec_t<N, T> v) noexcept { return vec4_t(v.z, v.y, v.z, v.z); }
template <std::size_t N, typename T> constexpr auto zyzw(vec_t<N, T> v) noexcept { return vec4_t(v.z, v.y, v.z, v.w); }
template <std::size_t N, typename T> constexpr auto zywx(vec_t<N, T> v) noexcept { return vec4_t(v.z, v.y, v.w, v.x); }
template <std::size_t N, typename T> constexpr auto zywy(vec_t<N, T> v) noexcept { return vec4_t(v.z, v.y, v.w, v.y); }
template <std::size_t N, typename T> constexpr auto zywz(vec_t<N, T> v) noexcept { return vec4_t(v.z, v.y, v.w, v.z); }
template <std::size_t N, typename T> constexpr auto zyww(vec_t<N, T> v) noexcept { return vec4_t(v.z, v.y, v.w, v.w); }
template <std::size_t N, typename T> constexpr auto zzxx(vec_t<N, T> v) noexcept { return vec4_t(v.z, v.z, v.x, v.x); }
template <std::size_t N, typename T> constexpr auto zzxy(vec_t<N, T> v) noexcept { return vec4_t(v.z, v.z, v.x, v.y); }
template <std::size_t N, typename T> constexpr auto zzxz(vec_t<N, T> v) noexcept { return vec4_t(v.z, v.z, v.x, v.z); }
template <std::size_t N, typename T> constexpr auto zzxw(vec_t<N, T> v) noexcept { return vec4_t(v.z, v.z, v.x, v.w); }
template <std::size_t N, typename T> constexpr auto zzyx(vec_t<N, T> v) noexcept { return vec4_t(v.z, v.z, v.y, v.x); }
template <std::size_t N, typename T> constexpr auto zzyy(vec_t<N, T> v) noexcept { return vec4_t(v.z, v.z, v.y, v.y); }
template <std::size_t N, typename T> constexpr auto zzyz(vec_t<N, T> v) noexcept { return vec4_t(v.z, v.z, v.y, v.z); }
template <std::size_t N, typename T> constexpr auto zzyw(vec_t<N, T> v) noexcept { return vec4_t(v.z, v.z, v.y, v.w); }
template <std::size_t N, typename T> constexpr auto zzzx(vec_t<N, T> v) noexcept { return vec4_t(v.z, v.z, v.z, v.x); }
template <std::size_t N, typename T> constexpr auto zzzy(vec_t<N, T> v) noexcept { return vec4_t(v.z, v.z, v.z, v.y); }
template <std::size_t N, typename T> constexpr auto zzzz(vec_t<N, T> v) noexcept { return vec4_t(v.z, v.z, v.z, v.z); }
template <std::size_t N, typename T> constexpr auto zzzw(vec_t<N, T> v) noexcept { return vec4_t(v.z, v.z, v.z, v.w); }
template <std::size_t N, typename T> constexpr auto zzwx(vec_t<N, T> v) noexcept { return vec4_t(v.z, v.z, v.w, v.x); }
template <std::size_t N, typename T> constexpr auto zzwy(vec_t<N, T> v) noexcept { return vec4_t(v.z, v.z, v.w, v.y); }
template <std::size_t N, typename T> constexpr auto zzwz(vec_t<N, T> v) noexcept { return vec4_t(v.z, v.z, v.w, v.z); }
template <std::size_t N, typename T> constexpr auto zzww(vec_t<N, T> v) noexcept { return vec4_t(v.z, v.z, v.w, v.w); }
template <std::size_t N, typename T> constexpr auto zwxx(vec_t<N, T> v) noexcept { return vec4_t(v.z, v.w, v.x, v.x); }
template <std::size_t N, typename T> constexpr auto zwxy(vec_t<N, T> v) noexcept { return vec4_t(v.z, v.w, v.x, v.y); }
template <std::size_t N, typename T> constexpr auto zwxz(vec_t<N, T> v) noexcept { return vec4_t(v.z, v.w, v.x, v.z); }
template <std::size_t N, typename T> constexpr auto zwxw(vec_t<N, T> v) noexcept { return vec4_t(v.z, v.w, v.x, v.w); }
template <std::size_t N, typename T> constexpr auto zwyx(vec_t<N, T> v) noexcept { return vec4_t(v.z, v.w, v.y, v.x); }
template <std::size_t N, typename T> constexpr auto zwyy(vec_t<N, T> v) noexcept { return vec4_t(v.z, v.w, v.y, v.y); }
template <std::size_t N, typename T> constexpr auto zwyz(vec_t<N, T> v) noexcept { return vec4_t(v.z, v.w, v.y, v.z); }
template <std::size_t N, typename T> constexpr auto zwyw(vec_t<N, T> v) noexcept { return vec4_t(v.z, v.w, v.y, v.w); }
template <std::size_t N, typename T> constexpr auto zwzx(vec_t<N, T> v) noexcept { return vec4_t(v.z, v.w, v.z, v.x); }
template <std::size_t N, typename T> constexpr auto zwzy(vec_t<N, T> v) noexcept { return vec4_t(v.z, v.w, v.z, v.y); }
template <std::size_t N, typename T> constexpr auto zwzz(vec_t<N, T> v) noexcept { return vec4_t(v.z, v.w, v.z, v.z); }
template <std::size_t N, typename T> constexpr auto zwzw(vec_t<N, T> v) noexcept { return vec4_t(v.z, v.w, v.z, v.w); }
template <std::size_t N, typename T> constexpr auto zwwx(vec_t<N, T> v) noexcept { return vec4_t(v.z, v.w, v.w, v.x); }
template <std::size_t N, typename T> constexpr auto zwwy(vec_t<N, T> v) noexcept { return vec4_t(v.z, v.w, v.w, v.y); }
template <std::size_t N, typename T> constexpr auto zwwz(vec_t<N, T> v) noexcept { return vec4_t(v.z, v.w, v.w, v.z); }
template <std::size_t N, typename T> constexpr auto zwww(vec_t<N, T> v) noexcept { return vec4_t(v.z, v.w, v.w, v.w); }
template <std::size_t N, typename T> constexpr auto wxxx(vec_t<N, T> v) noexcept { return vec4_t(v.w, v.x, v.x, v.x); }
template <std::size_t N, typename T> constexpr auto wxxy(vec_t<N, T> v) noexcept { return vec4_t(v.w, v.x, v.x, v.y); }
template <std::size_t N, typename T> constexpr auto wxxz(vec_t<N, T> v) noexcept { return vec4_t(v.w, v.x, v.x, v.z); }
template <std::size_t N, typename T> constexpr auto wxxw(vec_t<N, T> v) noexcept { return vec4_t(v.w, v.x, v.x, v.w); }
template <std::size_t N, typename T> constexpr auto wxyx(vec_t<N, T> v) noexcept { return vec4_t(v.w, v.x, v.y, v.x); }
template <std::size_t N, typename T> constexpr auto wxyy(vec_t<N, T> v) noexcept { return vec4_t(v.w, v.x, v.y, v.y); }
template <std::size_t N, typename T> constexpr auto wxyz(vec_t<N, T> v) noexcept { return vec4_t(v.w, v.x, v.y, v.z); }
template <std::size_t N, typename T> constexpr auto wxyw(vec_t<N, T> v) noexcept { return vec4_t(v.w, v.x, v.y, v.w); }
template <std::size_t N, typename T> constexpr auto wxzx(vec_t<N, T> v) noexcept { return vec4_t(v.w, v.x, v.z, v.x); }
template <std::size_t N, typename T> constexpr auto wxzy(vec_t<N, T> v) noexcept { return vec4_t(v.w, v.x, v.z, v.y); }
template <std::size_t N, typename T> constexpr auto wxzz(vec_t<N, T> v) noexcept { return vec4_t(v.w, v.x, v.z, v.z); }
template <std::size_t N, typename T> constexpr auto wxzw(vec_t<N, T> v) noexcept { return vec4_t(v.w, v.x, v.z, v.w); }
template <std::size_t N, typename T> constexpr auto wxwx(vec_t<N, T> v) noexcept { return vec4_t(v.w, v.x, v.w, v.x); }
template <std::size_t N, typename T> constexpr auto wxwy(vec_t<N, T> v) noexcept { return vec4_t(v.w, v.x, v.w, v.y); }
template <std::size_t N, typename T> constexpr auto wxwz(vec_t<N, T> v) noexcept { return vec4_t(v.w, v.x, v.w, v.z); }
template <std::size_t N, typename T> constexpr auto wxww(vec_t<N, T> v) noexcept { return vec4_t(v.w, v.x, v.w, v.w); }
template <std::size_t N, typename T> constexpr auto wyxx(vec_t<N, T> v) noexcept { return vec4_t(v.w, v.y, v.x, v.x); }
template <std::size_t N, typename T> constexpr auto wyxy(vec_t<N, T> v) noexcept { return vec4_t(v.w, v.y, v.x, v.y); }
template <std::size_t N, typename T> constexpr auto wyxz(vec_t<N, T> v) noexcept { return vec4_t(v.w, v.y, v.x, v.z); }
template <std::size_t N, typename T> constexpr auto wyxw(vec_t<N, T> v) noexcept { return vec4_t(v.w, v.y, v.x, v.w); }
template <std::size_t N, typename T> constexpr auto wyyx(vec_t<N, T> v) noexcept { return vec4_t(v.w, v.y, v.y, v.x); }
template <std::size_t N, typename T> constexpr auto wyyy(vec_t<N, T> v) noexcept { return vec4_t(v.w, v.y, v.y, v.y); }
template <std::size_t N, typename T> constexpr auto wyyz(vec_t<N, T> v) noexcept { return vec4_t(v.w, v.y, v.y, v.z); }
template <std::size_t N, typename T> constexpr auto wyyw(vec_t<N, T> v) noexcept { return vec4_t(v.w, v.y, v.y, v.w); }
template <std::size_t N, typename T> constexpr auto wyzx(vec_t<N, T> v) noexcept { return vec4_t(v.w, v.y, v.z, v.x); }
template <std::size_t N, typename T> constexpr auto wyzy(vec_t<N, T> v) noexcept { return vec4_t(v.w, v.y, v.z, v.y); }
template <std::size_t N, typename T> constexpr auto wyzz(vec_t<N, T> v) noexcept { return vec4_t(v.w, v.y, v.z, v.z); }
template <std::size_t N, typename T> constexpr auto wyzw(vec_t<N, T> v) noexcept { return vec4_t(v.w, v.y, v.z, v.w); }
template <std::size_t N, typename T> constexpr auto wywx(vec_t<N, T> v) noexcept { return vec4_t(v.w, v.y, v.w, v.x); }
template <std::size_t N, typename T> constexpr auto wywy(vec_t<N, T> v) noexcept { return vec4_t(v.w, v.y, v.w, v.y); }
template <std::size_t N, typename T> constexpr auto wywz(vec_t<N, T> v) noexcept { return vec4_t(v.w, v.y, v.w, v.z); }
template <std::size_t N, typename T> constexpr auto wyww(vec_t<N, T> v) noexcept { return vec4_t(v.w, v.y, v.w, v.w); }
template <std::size_t N, typename T> constexpr auto wzxx(vec_t<N, T> v) noexcept { return vec4_t(v.w, v.z, v.x, v.x); }
template <std::size_t N, typename T> constexpr auto wzxy(vec_t<N, T> v) noexcept { return vec4_t(v.w, v.z, v.x, v.y); }
template <std::size_t N, typename T> constexpr auto wzxz(vec_t<N, T> v) noexcept { return vec4_t(v.w, v.z, v.x, v.z); }
template <std::size_t N, typename T> constexpr auto wzxw(vec_t<N, T> v) noexcept { return vec4_t(v.w, v.z, v.x, v.w); }
template <std::size_t N, typename T> constexpr auto wzyx(vec_t<N, T> v) noexcept { return vec4_t(v.w, v.z, v.y, v.x); }
template <std::size_t N, typename T> constexpr auto wzyy(vec_t<N, T> v) noexcept { return vec4_t(v.w, v.z, v.y, v.y); }
template <std::size_t N, typename T> constexpr auto wzyz(vec_t<N, T> v) noexcept { return vec4_t(v.w, v.z, v.y, v.z); }
template <std::size_t N, typename T> constexpr auto wzyw(vec_t<N, T> v) noexcept { return vec4_t(v.w, v.z, v.y, v.w); }
template <std::size_t N, typename T> constexpr auto wzzx(vec_t<N, T> v) noexcept { return vec4_t(v.w, v.z, v.z, v.x); }
template <std::size_t N, typename T> constexpr auto wzzy(vec_t<N, T> v) noexcept { return vec4_t(v.w, v.z, v.z, v.y); }
template <std::size_t N, typename T> constexpr auto wzzz(vec_t<N, T> v) noexcept { return vec4_t(v.w, v.z, v.z, v.z); }
template <std::size_t N, typename T> constexpr auto wzzw(vec_t<N, T> v) noexcept { return vec4_t(v.w, v.z, v.z, v.w); }
template <std::size_t N, typename T> constexpr auto wzwx(vec_t<N, T> v) noexcept { return vec4_t(v.w, v.z, v.w, v.x); }
template <std::size_t N, typename T> constexpr auto wzwy(vec_t<N, T> v) noexcept { return vec4_t(v.w, v.z, v.w, v.y); }
template <std::size_t N, typename T> constexpr auto wzwz(vec_t<N, T> v) noexcept { return vec4_t(v.w, v.z, v.w, v.z); }
template <std::size_t N, typename T> constexpr auto wzww(vec_t<N, T> v) noexcept { return vec4_t(v.w, v.z, v.w, v.w); }
template <std::size_t N, typename T> constexpr auto wwxx(vec_t<N, T> v) noexcept { return vec4_t(v.w, v.w, v.x, v.x); }
template <std::size_t N, typename T> constexpr auto wwxy(vec_t<N, T> v) noexcept { return vec4_t(v.w, v.w, v.x, v.y); }
template <std::size_t N, typename T> constexpr auto wwxz(vec_t<N, T> v) noexcept { return vec4_t(v.w, v.w, v.x, v.z); }
template <std::size_t N, typename T> constexpr auto wwxw(vec_t<N, T> v) noexcept { return vec4_t(v.w, v.w, v.x, v.w); }
template <std::size_t N, typename T> constexpr auto wwyx(vec_t<N, T> v) noexcept { return vec4_t(v.w, v.w, v.y, v.x); }
template <std::size_t N, typename T> constexpr auto wwyy(vec_t<N, T> v) noexcept { return vec4_t(v.w, v.w, v.y, v.y); }
template <std::size_t N, typename T> constexpr auto wwyz(vec_t<N, T> v) noexcept { return vec4_t(v.w, v.w, v.y, v.z); }
template <std::size_t N, typename T> constexpr auto wwyw(vec_t<N, T> v) noexcept { return vec4_t(v.w, v.w, v.y, v.w); }
template <std::size_t N, typename T> constexpr auto wwzx(vec_t<N, T> v) noexcept { return vec4_t(v.w, v.w, v.z, v.x); }
template <std::size_t N, typename T> constexpr auto wwzy(vec_t<N, T> v) noexcept { return vec4_t(v.w, v.w, v.z, v.y); }
template <std::size_t N, typename T> constexpr auto wwzz(vec_t<N, T> v) noexcept { return vec4_t(v.w, v.w, v.z, v.z); }
template <std::size_t N, typename T> constexpr auto wwzw(vec_t<N, T> v) noexcept { return vec4_t(v.w, v.w, v.z, v.w); }
template <std::size_t N, typename T> constexpr auto wwwx(vec_t<N, T> v) noexcept { return vec4_t(v.w, v.w, v.w, v.x); }
template <std::size_t N, typename T> constexpr auto wwwy(vec_t<N, T> v) noexcept { return vec4_t(v.w, v.w, v.w, v.y); }
template <std::size_t N, typename T> constexpr auto wwwz(vec_t<N, T> v) noexcept { return vec4_t(v.w, v.w, v.w, v.z); }
template <std::size_t N, typename T> constexpr auto wwww(vec_t<N, T> v) noexcept { return vec4_t(v.w, v.w, v.w, v.w); }
}
#endif
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment