Swizzle generation

swizzle_gen.py

from xml.sax import saxutils


T = "xyzw"


def gen_1(text: str, t, file):
    for t0 in t:
        ts = "".join((t0,))
        file.add(text.format(lower=ts, upper=ts.upper(), t0=t0))


def gen_2(text: str, t, file):
    for t0 in t:
        for t1 in t:
            ts = "".join((t0, t1))
            file.add(
                text.format(lower=ts, upper=ts.upper(), t0=t0, t1=t1),
            )


def gen_3(text: str, t, file):
    for t0 in t:
        for t1 in t:
            for t2 in t:
                ts = "".join((t0, t1, t2))
                file.add(
                    text.format(lower=ts, upper=ts.upper(), t0=t0, t1=t1, t2=t2),
                )


def gen_4(text: str, t, file):
    for t0 in t:
        for t1 in t:
            for t2 in t:
                for t3 in t:
                    ts = "".join((t0, t1, t2, t3))
                    file.add(
                        text.format(
                            lower=ts, upper=ts.upper(), t0=t0, t1=t1, t2=t2, t3=t3
                        ),
                    )


gen_2_swizzle = "#define {upper}(v) ((struct vec2) {{v.{t0}, v.{t1} }})"
gen_3_swizzle = "#define {upper}(v) ((struct vec3) {{v.{t0}, v.{t1}, v.{t2} }})"
gen_4_swizzle = "#define {upper}(v) ((struct vec4) {{v.{t0}, v.{t1}, v.{t2}, v.{t3} }})"


class OrderedSet:
    def __init__(self, **kwargs):
        self._items = dict()
        for item in kwargs:
            self._items[item] = True

    def add(self, item):
        self._items[item] = True

    def __iter__(self):
        return iter(self._items.keys())

with open("include/vul/vul_math_swizzle.h", "w", encoding="utf-8") as header:
    s = OrderedSet()

    gen_2(gen_2_swizzle, "xy", file=s)
    gen_2(gen_2_swizzle, "xyz", file=s)
    gen_2(gen_2_swizzle, "xyzw", file=s)
    gen_3(gen_3_swizzle, "xy", file=s)
    gen_3(gen_3_swizzle, "xyz", file=s)
    gen_3(gen_3_swizzle, "xyzw", file=s)
    gen_4(gen_4_swizzle, "xy", file=s)
    gen_4(gen_4_swizzle, "xyz", file=s)
    gen_4(gen_4_swizzle, "xyzw", file=s)

    header.write("\n".join(s))
    header.write("\n")

Full output:

#define XY(v) ((struct vec2) {v.x, v.y })
#define YX(v) ((struct vec2) {v.y, v.x })
#define YY(v) ((struct vec2) {v.y, v.y })
#define XZ(v) ((struct vec2) {v.x, v.z })
#define YZ(v) ((struct vec2) {v.y, v.z })
#define ZX(v) ((struct vec2) {v.z, v.x })
#define ZY(v) ((struct vec2) {v.z, v.y })
#define ZZ(v) ((struct vec2) {v.z, v.z })
#define XW(v) ((struct vec2) {v.x, v.w })
#define YW(v) ((struct vec2) {v.y, v.w })
#define ZW(v) ((struct vec2) {v.z, v.w })
#define WX(v) ((struct vec2) {v.w, v.x })
#define WY(v) ((struct vec2) {v.w, v.y })
#define WZ(v) ((struct vec2) {v.w, v.z })
#define WW(v) ((struct vec2) {v.w, v.w })
#define XXX(v) ((struct vec3) {v.x, v.x, v.x })
#define XXY(v) ((struct vec3) {v.x, v.x, v.y })
#define XYX(v) ((struct vec3) {v.x, v.y, v.x })
#define XYY(v) ((struct vec3) {v.x, v.y, v.y })
#define YXX(v) ((struct vec3) {v.y, v.x, v.x })
#define YXY(v) ((struct vec3) {v.y, v.x, v.y })
#define YYX(v) ((struct vec3) {v.y, v.y, v.x })
#define YYY(v) ((struct vec3) {v.y, v.y, v.y })
#define XXZ(v) ((struct vec3) {v.x, v.x, v.z })
#define XYZ(v) ((struct vec3) {v.x, v.y, v.z })
#define XZX(v) ((struct vec3) {v.x, v.z, v.x })
#define XZY(v) ((struct vec3) {v.x, v.z, v.y })
#define XZZ(v) ((struct vec3) {v.x, v.z, v.z })
#define YXZ(v) ((struct vec3) {v.y, v.x, v.z })
#define YYZ(v) ((struct vec3) {v.y, v.y, v.z })
#define YZX(v) ((struct vec3) {v.y, v.z, v.x })
#define YZY(v) ((struct vec3) {v.y, v.z, v.y })
#define YZZ(v) ((struct vec3) {v.y, v.z, v.z })
#define ZXX(v) ((struct vec3) {v.z, v.x, v.x })
#define ZXY(v) ((struct vec3) {v.z, v.x, v.y })
#define ZXZ(v) ((struct vec3) {v.z, v.x, v.z })
#define ZYX(v) ((struct vec3) {v.z, v.y, v.x })
#define ZYY(v) ((struct vec3) {v.z, v.y, v.y })
#define ZYZ(v) ((struct vec3) {v.z, v.y, v.z })
#define ZZX(v) ((struct vec3) {v.z, v.z, v.x })
#define ZZY(v) ((struct vec3) {v.z, v.z, v.y })
#define ZZZ(v) ((struct vec3) {v.z, v.z, v.z })
#define XXW(v) ((struct vec3) {v.x, v.x, v.w })
#define XYW(v) ((struct vec3) {v.x, v.y, v.w })
#define XZW(v) ((struct vec3) {v.x, v.z, v.w })
#define XWX(v) ((struct vec3) {v.x, v.w, v.x })
#define XWY(v) ((struct vec3) {v.x, v.w, v.y })
#define XWZ(v) ((struct vec3) {v.x, v.w, v.z })
#define XWW(v) ((struct vec3) {v.x, v.w, v.w })
#define YXW(v) ((struct vec3) {v.y, v.x, v.w })
#define YYW(v) ((struct vec3) {v.y, v.y, v.w })
#define YZW(v) ((struct vec3) {v.y, v.z, v.w })
#define YWX(v) ((struct vec3) {v.y, v.w, v.x })
#define YWY(v) ((struct vec3) {v.y, v.w, v.y })
#define YWZ(v) ((struct vec3) {v.y, v.w, v.z })
#define YWW(v) ((struct vec3) {v.y, v.w, v.w })
#define ZXW(v) ((struct vec3) {v.z, v.x, v.w })
#define ZYW(v) ((struct vec3) {v.z, v.y, v.w })
#define ZZW(v) ((struct vec3) {v.z, v.z, v.w })
#define ZWX(v) ((struct vec3) {v.z, v.w, v.x })
#define ZWY(v) ((struct vec3) {v.z, v.w, v.y })
#define ZWZ(v) ((struct vec3) {v.z, v.w, v.z })
#define ZWW(v) ((struct vec3) {v.z, v.w, v.w })
#define WXX(v) ((struct vec3) {v.w, v.x, v.x })
#define WXY(v) ((struct vec3) {v.w, v.x, v.y })
#define WXZ(v) ((struct vec3) {v.w, v.x, v.z })
#define WXW(v) ((struct vec3) {v.w, v.x, v.w })
#define WYX(v) ((struct vec3) {v.w, v.y, v.x })
#define WYY(v) ((struct vec3) {v.w, v.y, v.y })
#define WYZ(v) ((struct vec3) {v.w, v.y, v.z })
#define WYW(v) ((struct vec3) {v.w, v.y, v.w })
#define WZX(v) ((struct vec3) {v.w, v.z, v.x })
#define WZY(v) ((struct vec3) {v.w, v.z, v.y })
#define WZZ(v) ((struct vec3) {v.w, v.z, v.z })
#define WZW(v) ((struct vec3) {v.w, v.z, v.w })
#define WWX(v) ((struct vec3) {v.w, v.w, v.x })
#define WWY(v) ((struct vec3) {v.w, v.w, v.y })
#define WWZ(v) ((struct vec3) {v.w, v.w, v.z })
#define WWW(v) ((struct vec3) {v.w, v.w, v.w })
#define XXXX(v) ((struct vec4) {v.x, v.x, v.x, v.x })
#define XXXY(v) ((struct vec4) {v.x, v.x, v.x, v.y })
#define XXYX(v) ((struct vec4) {v.x, v.x, v.y, v.x })
#define XXYY(v) ((struct vec4) {v.x, v.x, v.y, v.y })
#define XYXX(v) ((struct vec4) {v.x, v.y, v.x, v.x })
#define XYXY(v) ((struct vec4) {v.x, v.y, v.x, v.y })
#define XYYX(v) ((struct vec4) {v.x, v.y, v.y, v.x })
#define XYYY(v) ((struct vec4) {v.x, v.y, v.y, v.y })
#define YXXX(v) ((struct vec4) {v.y, v.x, v.x, v.x })
#define YXXY(v) ((struct vec4) {v.y, v.x, v.x, v.y })
#define YXYX(v) ((struct vec4) {v.y, v.x, v.y, v.x })
#define YXYY(v) ((struct vec4) {v.y, v.x, v.y, v.y })
#define YYXX(v) ((struct vec4) {v.y, v.y, v.x, v.x })
#define YYXY(v) ((struct vec4) {v.y, v.y, v.x, v.y })
#define YYYX(v) ((struct vec4) {v.y, v.y, v.y, v.x })
#define YYYY(v) ((struct vec4) {v.y, v.y, v.y, v.y })
#define XXXZ(v) ((struct vec4) {v.x, v.x, v.x, v.z })
#define XXYZ(v) ((struct vec4) {v.x, v.x, v.y, v.z })
#define XXZX(v) ((struct vec4) {v.x, v.x, v.z, v.x })
#define XXZY(v) ((struct vec4) {v.x, v.x, v.z, v.y })
#define XXZZ(v) ((struct vec4) {v.x, v.x, v.z, v.z })
#define XYXZ(v) ((struct vec4) {v.x, v.y, v.x, v.z })
#define XYYZ(v) ((struct vec4) {v.x, v.y, v.y, v.z })
#define XYZX(v) ((struct vec4) {v.x, v.y, v.z, v.x })
#define XYZY(v) ((struct vec4) {v.x, v.y, v.z, v.y })
#define XYZZ(v) ((struct vec4) {v.x, v.y, v.z, v.z })
#define XZXX(v) ((struct vec4) {v.x, v.z, v.x, v.x })
#define XZXY(v) ((struct vec4) {v.x, v.z, v.x, v.y })
#define XZXZ(v) ((struct vec4) {v.x, v.z, v.x, v.z })
#define XZYX(v) ((struct vec4) {v.x, v.z, v.y, v.x })
#define XZYY(v) ((struct vec4) {v.x, v.z, v.y, v.y })
#define XZYZ(v) ((struct vec4) {v.x, v.z, v.y, v.z })
#define XZZX(v) ((struct vec4) {v.x, v.z, v.z, v.x })
#define XZZY(v) ((struct vec4) {v.x, v.z, v.z, v.y })
#define XZZZ(v) ((struct vec4) {v.x, v.z, v.z, v.z })
#define YXXZ(v) ((struct vec4) {v.y, v.x, v.x, v.z })
#define YXYZ(v) ((struct vec4) {v.y, v.x, v.y, v.z })
#define YXZX(v) ((struct vec4) {v.y, v.x, v.z, v.x })
#define YXZY(v) ((struct vec4) {v.y, v.x, v.z, v.y })
#define YXZZ(v) ((struct vec4) {v.y, v.x, v.z, v.z })
#define YYXZ(v) ((struct vec4) {v.y, v.y, v.x, v.z })
#define YYYZ(v) ((struct vec4) {v.y, v.y, v.y, v.z })
#define YYZX(v) ((struct vec4) {v.y, v.y, v.z, v.x })
#define YYZY(v) ((struct vec4) {v.y, v.y, v.z, v.y })
#define YYZZ(v) ((struct vec4) {v.y, v.y, v.z, v.z })
#define YZXX(v) ((struct vec4) {v.y, v.z, v.x, v.x })
#define YZXY(v) ((struct vec4) {v.y, v.z, v.x, v.y })
#define YZXZ(v) ((struct vec4) {v.y, v.z, v.x, v.z })
#define YZYX(v) ((struct vec4) {v.y, v.z, v.y, v.x })
#define YZYY(v) ((struct vec4) {v.y, v.z, v.y, v.y })
#define YZYZ(v) ((struct vec4) {v.y, v.z, v.y, v.z })
#define YZZX(v) ((struct vec4) {v.y, v.z, v.z, v.x })
#define YZZY(v) ((struct vec4) {v.y, v.z, v.z, v.y })
#define YZZZ(v) ((struct vec4) {v.y, v.z, v.z, v.z })
#define ZXXX(v) ((struct vec4) {v.z, v.x, v.x, v.x })
#define ZXXY(v) ((struct vec4) {v.z, v.x, v.x, v.y })
#define ZXXZ(v) ((struct vec4) {v.z, v.x, v.x, v.z })
#define ZXYX(v) ((struct vec4) {v.z, v.x, v.y, v.x })
#define ZXYY(v) ((struct vec4) {v.z, v.x, v.y, v.y })
#define ZXYZ(v) ((struct vec4) {v.z, v.x, v.y, v.z })
#define ZXZX(v) ((struct vec4) {v.z, v.x, v.z, v.x })
#define ZXZY(v) ((struct vec4) {v.z, v.x, v.z, v.y })
#define ZXZZ(v) ((struct vec4) {v.z, v.x, v.z, v.z })
#define ZYXX(v) ((struct vec4) {v.z, v.y, v.x, v.x })
#define ZYXY(v) ((struct vec4) {v.z, v.y, v.x, v.y })
#define ZYXZ(v) ((struct vec4) {v.z, v.y, v.x, v.z })
#define ZYYX(v) ((struct vec4) {v.z, v.y, v.y, v.x })
#define ZYYY(v) ((struct vec4) {v.z, v.y, v.y, v.y })
#define ZYYZ(v) ((struct vec4) {v.z, v.y, v.y, v.z })
#define ZYZX(v) ((struct vec4) {v.z, v.y, v.z, v.x })
#define ZYZY(v) ((struct vec4) {v.z, v.y, v.z, v.y })
#define ZYZZ(v) ((struct vec4) {v.z, v.y, v.z, v.z })
#define ZZXX(v) ((struct vec4) {v.z, v.z, v.x, v.x })
#define ZZXY(v) ((struct vec4) {v.z, v.z, v.x, v.y })
#define ZZXZ(v) ((struct vec4) {v.z, v.z, v.x, v.z })
#define ZZYX(v) ((struct vec4) {v.z, v.z, v.y, v.x })
#define ZZYY(v) ((struct vec4) {v.z, v.z, v.y, v.y })
#define ZZYZ(v) ((struct vec4) {v.z, v.z, v.y, v.z })
#define ZZZX(v) ((struct vec4) {v.z, v.z, v.z, v.x })
#define ZZZY(v) ((struct vec4) {v.z, v.z, v.z, v.y })
#define ZZZZ(v) ((struct vec4) {v.z, v.z, v.z, v.z })
#define XXXW(v) ((struct vec4) {v.x, v.x, v.x, v.w })
#define XXYW(v) ((struct vec4) {v.x, v.x, v.y, v.w })
#define XXZW(v) ((struct vec4) {v.x, v.x, v.z, v.w })
#define XXWX(v) ((struct vec4) {v.x, v.x, v.w, v.x })
#define XXWY(v) ((struct vec4) {v.x, v.x, v.w, v.y })
#define XXWZ(v) ((struct vec4) {v.x, v.x, v.w, v.z })
#define XXWW(v) ((struct vec4) {v.x, v.x, v.w, v.w })
#define XYXW(v) ((struct vec4) {v.x, v.y, v.x, v.w })
#define XYYW(v) ((struct vec4) {v.x, v.y, v.y, v.w })
#define XYZW(v) ((struct vec4) {v.x, v.y, v.z, v.w })
#define XYWX(v) ((struct vec4) {v.x, v.y, v.w, v.x })
#define XYWY(v) ((struct vec4) {v.x, v.y, v.w, v.y })
#define XYWZ(v) ((struct vec4) {v.x, v.y, v.w, v.z })
#define XYWW(v) ((struct vec4) {v.x, v.y, v.w, v.w })
#define XZXW(v) ((struct vec4) {v.x, v.z, v.x, v.w })
#define XZYW(v) ((struct vec4) {v.x, v.z, v.y, v.w })
#define XZZW(v) ((struct vec4) {v.x, v.z, v.z, v.w })
#define XZWX(v) ((struct vec4) {v.x, v.z, v.w, v.x })
#define XZWY(v) ((struct vec4) {v.x, v.z, v.w, v.y })
#define XZWZ(v) ((struct vec4) {v.x, v.z, v.w, v.z })
#define XZWW(v) ((struct vec4) {v.x, v.z, v.w, v.w })
#define XWXX(v) ((struct vec4) {v.x, v.w, v.x, v.x })
#define XWXY(v) ((struct vec4) {v.x, v.w, v.x, v.y })
#define XWXZ(v) ((struct vec4) {v.x, v.w, v.x, v.z })
#define XWXW(v) ((struct vec4) {v.x, v.w, v.x, v.w })
#define XWYX(v) ((struct vec4) {v.x, v.w, v.y, v.x })
#define XWYY(v) ((struct vec4) {v.x, v.w, v.y, v.y })
#define XWYZ(v) ((struct vec4) {v.x, v.w, v.y, v.z })
#define XWYW(v) ((struct vec4) {v.x, v.w, v.y, v.w })
#define XWZX(v) ((struct vec4) {v.x, v.w, v.z, v.x })
#define XWZY(v) ((struct vec4) {v.x, v.w, v.z, v.y })
#define XWZZ(v) ((struct vec4) {v.x, v.w, v.z, v.z })
#define XWZW(v) ((struct vec4) {v.x, v.w, v.z, v.w })
#define XWWX(v) ((struct vec4) {v.x, v.w, v.w, v.x })
#define XWWY(v) ((struct vec4) {v.x, v.w, v.w, v.y })
#define XWWZ(v) ((struct vec4) {v.x, v.w, v.w, v.z })
#define XWWW(v) ((struct vec4) {v.x, v.w, v.w, v.w })
#define YXXW(v) ((struct vec4) {v.y, v.x, v.x, v.w })
#define YXYW(v) ((struct vec4) {v.y, v.x, v.y, v.w })
#define YXZW(v) ((struct vec4) {v.y, v.x, v.z, v.w })
#define YXWX(v) ((struct vec4) {v.y, v.x, v.w, v.x })
#define YXWY(v) ((struct vec4) {v.y, v.x, v.w, v.y })
#define YXWZ(v) ((struct vec4) {v.y, v.x, v.w, v.z })
#define YXWW(v) ((struct vec4) {v.y, v.x, v.w, v.w })
#define YYXW(v) ((struct vec4) {v.y, v.y, v.x, v.w })
#define YYYW(v) ((struct vec4) {v.y, v.y, v.y, v.w })
#define YYZW(v) ((struct vec4) {v.y, v.y, v.z, v.w })
#define YYWX(v) ((struct vec4) {v.y, v.y, v.w, v.x })
#define YYWY(v) ((struct vec4) {v.y, v.y, v.w, v.y })
#define YYWZ(v) ((struct vec4) {v.y, v.y, v.w, v.z })
#define YYWW(v) ((struct vec4) {v.y, v.y, v.w, v.w })
#define YZXW(v) ((struct vec4) {v.y, v.z, v.x, v.w })
#define YZYW(v) ((struct vec4) {v.y, v.z, v.y, v.w })
#define YZZW(v) ((struct vec4) {v.y, v.z, v.z, v.w })
#define YZWX(v) ((struct vec4) {v.y, v.z, v.w, v.x })
#define YZWY(v) ((struct vec4) {v.y, v.z, v.w, v.y })
#define YZWZ(v) ((struct vec4) {v.y, v.z, v.w, v.z })
#define YZWW(v) ((struct vec4) {v.y, v.z, v.w, v.w })
#define YWXX(v) ((struct vec4) {v.y, v.w, v.x, v.x })
#define YWXY(v) ((struct vec4) {v.y, v.w, v.x, v.y })
#define YWXZ(v) ((struct vec4) {v.y, v.w, v.x, v.z })
#define YWXW(v) ((struct vec4) {v.y, v.w, v.x, v.w })
#define YWYX(v) ((struct vec4) {v.y, v.w, v.y, v.x })
#define YWYY(v) ((struct vec4) {v.y, v.w, v.y, v.y })
#define YWYZ(v) ((struct vec4) {v.y, v.w, v.y, v.z })
#define YWYW(v) ((struct vec4) {v.y, v.w, v.y, v.w })
#define YWZX(v) ((struct vec4) {v.y, v.w, v.z, v.x })
#define YWZY(v) ((struct vec4) {v.y, v.w, v.z, v.y })
#define YWZZ(v) ((struct vec4) {v.y, v.w, v.z, v.z })
#define YWZW(v) ((struct vec4) {v.y, v.w, v.z, v.w })
#define YWWX(v) ((struct vec4) {v.y, v.w, v.w, v.x })
#define YWWY(v) ((struct vec4) {v.y, v.w, v.w, v.y })
#define YWWZ(v) ((struct vec4) {v.y, v.w, v.w, v.z })
#define YWWW(v) ((struct vec4) {v.y, v.w, v.w, v.w })
#define ZXXW(v) ((struct vec4) {v.z, v.x, v.x, v.w })
#define ZXYW(v) ((struct vec4) {v.z, v.x, v.y, v.w })
#define ZXZW(v) ((struct vec4) {v.z, v.x, v.z, v.w })
#define ZXWX(v) ((struct vec4) {v.z, v.x, v.w, v.x })
#define ZXWY(v) ((struct vec4) {v.z, v.x, v.w, v.y })
#define ZXWZ(v) ((struct vec4) {v.z, v.x, v.w, v.z })
#define ZXWW(v) ((struct vec4) {v.z, v.x, v.w, v.w })
#define ZYXW(v) ((struct vec4) {v.z, v.y, v.x, v.w })
#define ZYYW(v) ((struct vec4) {v.z, v.y, v.y, v.w })
#define ZYZW(v) ((struct vec4) {v.z, v.y, v.z, v.w })
#define ZYWX(v) ((struct vec4) {v.z, v.y, v.w, v.x })
#define ZYWY(v) ((struct vec4) {v.z, v.y, v.w, v.y })
#define ZYWZ(v) ((struct vec4) {v.z, v.y, v.w, v.z })
#define ZYWW(v) ((struct vec4) {v.z, v.y, v.w, v.w })
#define ZZXW(v) ((struct vec4) {v.z, v.z, v.x, v.w })
#define ZZYW(v) ((struct vec4) {v.z, v.z, v.y, v.w })
#define ZZZW(v) ((struct vec4) {v.z, v.z, v.z, v.w })
#define ZZWX(v) ((struct vec4) {v.z, v.z, v.w, v.x })
#define ZZWY(v) ((struct vec4) {v.z, v.z, v.w, v.y })
#define ZZWZ(v) ((struct vec4) {v.z, v.z, v.w, v.z })
#define ZZWW(v) ((struct vec4) {v.z, v.z, v.w, v.w })
#define ZWXX(v) ((struct vec4) {v.z, v.w, v.x, v.x })
#define ZWXY(v) ((struct vec4) {v.z, v.w, v.x, v.y })
#define ZWXZ(v) ((struct vec4) {v.z, v.w, v.x, v.z })
#define ZWXW(v) ((struct vec4) {v.z, v.w, v.x, v.w })
#define ZWYX(v) ((struct vec4) {v.z, v.w, v.y, v.x })
#define ZWYY(v) ((struct vec4) {v.z, v.w, v.y, v.y })
#define ZWYZ(v) ((struct vec4) {v.z, v.w, v.y, v.z })
#define ZWYW(v) ((struct vec4) {v.z, v.w, v.y, v.w })
#define ZWZX(v) ((struct vec4) {v.z, v.w, v.z, v.x })
#define ZWZY(v) ((struct vec4) {v.z, v.w, v.z, v.y })
#define ZWZZ(v) ((struct vec4) {v.z, v.w, v.z, v.z })
#define ZWZW(v) ((struct vec4) {v.z, v.w, v.z, v.w })
#define ZWWX(v) ((struct vec4) {v.z, v.w, v.w, v.x })
#define ZWWY(v) ((struct vec4) {v.z, v.w, v.w, v.y })
#define ZWWZ(v) ((struct vec4) {v.z, v.w, v.w, v.z })
#define ZWWW(v) ((struct vec4) {v.z, v.w, v.w, v.w })
#define WXXX(v) ((struct vec4) {v.w, v.x, v.x, v.x })
#define WXXY(v) ((struct vec4) {v.w, v.x, v.x, v.y })
#define WXXZ(v) ((struct vec4) {v.w, v.x, v.x, v.z })
#define WXXW(v) ((struct vec4) {v.w, v.x, v.x, v.w })
#define WXYX(v) ((struct vec4) {v.w, v.x, v.y, v.x })
#define WXYY(v) ((struct vec4) {v.w, v.x, v.y, v.y })
#define WXYZ(v) ((struct vec4) {v.w, v.x, v.y, v.z })
#define WXYW(v) ((struct vec4) {v.w, v.x, v.y, v.w })
#define WXZX(v) ((struct vec4) {v.w, v.x, v.z, v.x })
#define WXZY(v) ((struct vec4) {v.w, v.x, v.z, v.y })
#define WXZZ(v) ((struct vec4) {v.w, v.x, v.z, v.z })
#define WXZW(v) ((struct vec4) {v.w, v.x, v.z, v.w })
#define WXWX(v) ((struct vec4) {v.w, v.x, v.w, v.x })
#define WXWY(v) ((struct vec4) {v.w, v.x, v.w, v.y })
#define WXWZ(v) ((struct vec4) {v.w, v.x, v.w, v.z })
#define WXWW(v) ((struct vec4) {v.w, v.x, v.w, v.w })
#define WYXX(v) ((struct vec4) {v.w, v.y, v.x, v.x })
#define WYXY(v) ((struct vec4) {v.w, v.y, v.x, v.y })
#define WYXZ(v) ((struct vec4) {v.w, v.y, v.x, v.z })
#define WYXW(v) ((struct vec4) {v.w, v.y, v.x, v.w })
#define WYYX(v) ((struct vec4) {v.w, v.y, v.y, v.x })
#define WYYY(v) ((struct vec4) {v.w, v.y, v.y, v.y })
#define WYYZ(v) ((struct vec4) {v.w, v.y, v.y, v.z })
#define WYYW(v) ((struct vec4) {v.w, v.y, v.y, v.w })
#define WYZX(v) ((struct vec4) {v.w, v.y, v.z, v.x })
#define WYZY(v) ((struct vec4) {v.w, v.y, v.z, v.y })
#define WYZZ(v) ((struct vec4) {v.w, v.y, v.z, v.z })
#define WYZW(v) ((struct vec4) {v.w, v.y, v.z, v.w })
#define WYWX(v) ((struct vec4) {v.w, v.y, v.w, v.x })
#define WYWY(v) ((struct vec4) {v.w, v.y, v.w, v.y })
#define WYWZ(v) ((struct vec4) {v.w, v.y, v.w, v.z })
#define WYWW(v) ((struct vec4) {v.w, v.y, v.w, v.w })
#define WZXX(v) ((struct vec4) {v.w, v.z, v.x, v.x })
#define WZXY(v) ((struct vec4) {v.w, v.z, v.x, v.y })
#define WZXZ(v) ((struct vec4) {v.w, v.z, v.x, v.z })
#define WZXW(v) ((struct vec4) {v.w, v.z, v.x, v.w })
#define WZYX(v) ((struct vec4) {v.w, v.z, v.y, v.x })
#define WZYY(v) ((struct vec4) {v.w, v.z, v.y, v.y })
#define WZYZ(v) ((struct vec4) {v.w, v.z, v.y, v.z })
#define WZYW(v) ((struct vec4) {v.w, v.z, v.y, v.w })
#define WZZX(v) ((struct vec4) {v.w, v.z, v.z, v.x })
#define WZZY(v) ((struct vec4) {v.w, v.z, v.z, v.y })
#define WZZZ(v) ((struct vec4) {v.w, v.z, v.z, v.z })
#define WZZW(v) ((struct vec4) {v.w, v.z, v.z, v.w })
#define WZWX(v) ((struct vec4) {v.w, v.z, v.w, v.x })
#define WZWY(v) ((struct vec4) {v.w, v.z, v.w, v.y })
#define WZWZ(v) ((struct vec4) {v.w, v.z, v.w, v.z })
#define WZWW(v) ((struct vec4) {v.w, v.z, v.w, v.w })
#define WWXX(v) ((struct vec4) {v.w, v.w, v.x, v.x })
#define WWXY(v) ((struct vec4) {v.w, v.w, v.x, v.y })
#define WWXZ(v) ((struct vec4) {v.w, v.w, v.x, v.z })
#define WWXW(v) ((struct vec4) {v.w, v.w, v.x, v.w })
#define WWYX(v) ((struct vec4) {v.w, v.w, v.y, v.x })
#define WWYY(v) ((struct vec4) {v.w, v.w, v.y, v.y })
#define WWYZ(v) ((struct vec4) {v.w, v.w, v.y, v.z })
#define WWYW(v) ((struct vec4) {v.w, v.w, v.y, v.w })
#define WWZX(v) ((struct vec4) {v.w, v.w, v.z, v.x })
#define WWZY(v) ((struct vec4) {v.w, v.w, v.z, v.y })
#define WWZZ(v) ((struct vec4) {v.w, v.w, v.z, v.z })
#define WWZW(v) ((struct vec4) {v.w, v.w, v.z, v.w })
#define WWWX(v) ((struct vec4) {v.w, v.w, v.w, v.x })
#define WWWY(v) ((struct vec4) {v.w, v.w, v.w, v.y })
#define WWWZ(v) ((struct vec4) {v.w, v.w, v.w, v.z })
#define WWWW(v) ((struct vec4) {v.w, v.w, v.w, v.w })