3.1.0

A utility library implementing 2D, 3D, and 4D vector functionality.

This is a library for vector math in 3D space. It contains most of the vector operations one would usually expect out of such a library and offers them both in non-modifying and modifying versions where applicable. It also tries to be efficient where plausible. Each vector is made up of `float`s, which by default are `single-float`s, as they do not require value boxing on most modern systems and compilers. Despite the name of this library, 2D and 4D vectors are supported as well.

How To

Load it through ASDF or Quicklisp

``````(ql:quickload :3d-vectors)
(use-package :3d-vectors)
``````

Create a vector:

``````(vec 0 0 0)
``````

Vectors always use `float`s. Where sensible, operations should accept `real` numbers for convenience. All vector operations are prefixed with a `v` to allow importing the package without conflicts.

``````(v+ (vec 1 2 3) 4 5 6)
``````

3d-vectors implements pretty much all vector operations you might need, including comparators, dot and cross product, and rotation. There's also modifying variants of all operators, which have the same name, except they are prefixed by an `n`.

``````(let ((v (vec 0 0 0)))
(nv* (nv+ v (vec 1 2 3)) 3)
v)
``````

`vec`s are dumpable, meaning you can insert them as literals into your code and they will be properly saved to and restored from a FASL.

The type `vec` includes all three subtypes `vec2`, `vec3`, and `vec4`. Each of the three also has its own accessors that are suffixed with the dimension number. While the standard `vx`, `vy`, `vz`, and `vw` will result in the lower-level variants through an `etypecase`, it is usually a good idea to use `vx2` etc if the type is already known to avoid unnecessary dispatch or branch elimination.

While most of the operations work on all three variants, you cannot intermix them. For example, `(v+ (vec 1 2) (vec 1 2 3))` will signal an error. This is because it is often ambiguous and thus likely confusing as to what might happen in such a case. Should the result be upgraded to a `vec3` or downgraded to a `vec2`? In order to avoid this ambiguity, it is simply left up to you to ensure proper types.

One convenient way to switch around between the types and generally flip around the vector fields is swizzling: similar to the single-field accessors, there's multi-field readers that construct a new vector from the specified fields of the necessary length.

``````(vxy (vec 1 2 3))    ; => (vec2 1 2)
(vxy_ (vec 1 2))     ; => (vec3 1 2 0)
(vwwx (vec 1 2 3 4)) ; => (vec3 4 4 1)
``````

The `_` can be used anywhere within swizzle operators in order to pad the vector with a zero. You can also use the swizzle operators as accessors to set multiple fields of a vector at once.

If you require higher precision than `single-float`s ensure, you can add `:3d-vectors-double-floats` to `*features*` and recompile the library `(asdf:compile-system :3d-vectors :force T)`. Similarly, if you want to switch back to `single-float`s, you can remove the feature and recompile. Both at the same time is not supported as it would increase complexity in the library massively and make certain operations much slower.

Also See

• 3d-matrices for Matrix operations in conjunction with this library.

Package Index

• 3D-VECTORS(ORG.SHIRAKUMO.FLARE.VECTOR)

• constant

`+VW4+`

`Constant vector for the 4D unit in W direction.`
• constant

`+VX+`

`Constant vector for the 3D unit in X direction.`
• constant

`+VX2+`

`Constant vector for the 2D unit in X direction.`
• constant

`+VX3+`

`Constant vector for the 3D unit in X direction.`
• constant

`+VX4+`

`Constant vector for the 4D unit in X direction.`
• constant

`+VY+`

`Constant vector for the 3D unit in Y direction.`
• constant

`+VY2+`

`Constant vector for the 2D unit in Y direction.`
• constant

`+VY3+`

`Constant vector for the 3D unit in Y direction.`
• constant

`+VY4+`

`Constant vector for the 4D unit in Y direction.`
• constant

`+VZ+`

`Constant vector for the 3D unit in Z direction.`
• constant

`+VZ3+`

`Constant vector for the 3D unit in Z direction.`
• constant

`+VZ4+`

`Constant vector for the 4D unit in Z direction.`
• class

`VEC2`

`A two-dimensional vector with X and Y fields.`
• class

`VEC3`

`A three-dimensional vector with X, Y, and Z fields.`
• class

`VEC4`

`A four-dimensional vector with X, Y, Z, and W fields.`
• type

`VEC`

`Either a vec2, vec3, or vec4.`
• accessor `(`

`VWW`

`VEC``)`
```Swizzles the vector into a 2D one, filling its fields with the W and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VWWW`

`VEC``)`
```Swizzles the vector into a 3D one, filling its fields with the W, W, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, W, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VWWWW`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the W, W, W, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, W, W, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VWWWX`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the W, W, W, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, W, W, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VWWWY`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the W, W, W, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, W, W, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VWWWZ`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the W, W, W, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, W, W, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VWWW_`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the W, W, W, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, W, W, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VWWX`

`VEC``)`
```Swizzles the vector into a 3D one, filling its fields with the W, W, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, W, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VWWXW`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the W, W, X, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, W, X, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VWWXX`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the W, W, X, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, W, X, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VWWXY`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the W, W, X, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, W, X, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VWWXZ`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the W, W, X, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, W, X, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VWWX_`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the W, W, X, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, W, X, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VWWY`

`VEC``)`
```Swizzles the vector into a 3D one, filling its fields with the W, W, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, W, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VWWYW`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the W, W, Y, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, W, Y, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VWWYX`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the W, W, Y, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, W, Y, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VWWYY`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the W, W, Y, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, W, Y, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VWWYZ`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the W, W, Y, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, W, Y, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VWWY_`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the W, W, Y, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, W, Y, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VWWZ`

`VEC``)`
```Swizzles the vector into a 3D one, filling its fields with the W, W, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, W, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VWWZW`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the W, W, Z, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, W, Z, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VWWZX`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the W, W, Z, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, W, Z, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VWWZY`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the W, W, Z, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, W, Z, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VWWZZ`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the W, W, Z, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, W, Z, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VWWZ_`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the W, W, Z, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, W, Z, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VWW_`

`VEC``)`
```Swizzles the vector into a 3D one, filling its fields with the W, W, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, W, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VWW_W`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the W, W, _, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, W, _, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VWW_X`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the W, W, _, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, W, _, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VWW_Y`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the W, W, _, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, W, _, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VWW_Z`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the W, W, _, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, W, _, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VWW__`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the W, W, _, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, W, _, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VWX`

`VEC``)`
```Swizzles the vector into a 2D one, filling its fields with the W and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VWXW`

`VEC``)`
```Swizzles the vector into a 3D one, filling its fields with the W, X, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, X, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VWXWW`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the W, X, W, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, X, W, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VWXWX`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the W, X, W, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, X, W, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VWXWY`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the W, X, W, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, X, W, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VWXWZ`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the W, X, W, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, X, W, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VWXW_`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the W, X, W, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, X, W, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VWXX`

`VEC``)`
```Swizzles the vector into a 3D one, filling its fields with the W, X, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, X, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VWXXW`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the W, X, X, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, X, X, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VWXXX`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the W, X, X, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, X, X, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VWXXY`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the W, X, X, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, X, X, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VWXXZ`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the W, X, X, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, X, X, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VWXX_`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the W, X, X, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, X, X, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VWXY`

`VEC``)`
```Swizzles the vector into a 3D one, filling its fields with the W, X, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, X, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VWXYW`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the W, X, Y, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, X, Y, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VWXYX`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the W, X, Y, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, X, Y, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VWXYY`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the W, X, Y, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, X, Y, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VWXYZ`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the W, X, Y, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, X, Y, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VWXY_`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the W, X, Y, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, X, Y, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VWXZ`

`VEC``)`
```Swizzles the vector into a 3D one, filling its fields with the W, X, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, X, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VWXZW`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the W, X, Z, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, X, Z, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VWXZX`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the W, X, Z, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, X, Z, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VWXZY`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the W, X, Z, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, X, Z, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VWXZZ`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the W, X, Z, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, X, Z, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VWXZ_`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the W, X, Z, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, X, Z, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VWX_`

`VEC``)`
```Swizzles the vector into a 3D one, filling its fields with the W, X, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, X, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VWX_W`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the W, X, _, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, X, _, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VWX_X`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the W, X, _, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, X, _, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VWX_Y`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the W, X, _, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, X, _, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VWX_Z`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the W, X, _, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, X, _, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VWX__`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the W, X, _, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, X, _, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VWY`

`VEC``)`
```Swizzles the vector into a 2D one, filling its fields with the W and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VWYW`

`VEC``)`
```Swizzles the vector into a 3D one, filling its fields with the W, Y, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, Y, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VWYWW`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the W, Y, W, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, Y, W, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VWYWX`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the W, Y, W, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, Y, W, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VWYWY`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the W, Y, W, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, Y, W, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VWYWZ`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the W, Y, W, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, Y, W, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VWYW_`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the W, Y, W, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, Y, W, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VWYX`

`VEC``)`
```Swizzles the vector into a 3D one, filling its fields with the W, Y, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, Y, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VWYXW`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the W, Y, X, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, Y, X, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VWYXX`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the W, Y, X, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, Y, X, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VWYXY`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the W, Y, X, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, Y, X, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VWYXZ`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the W, Y, X, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, Y, X, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VWYX_`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the W, Y, X, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, Y, X, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VWYY`

`VEC``)`
```Swizzles the vector into a 3D one, filling its fields with the W, Y, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, Y, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VWYYW`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the W, Y, Y, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, Y, Y, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VWYYX`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the W, Y, Y, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, Y, Y, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VWYYY`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the W, Y, Y, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, Y, Y, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VWYYZ`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the W, Y, Y, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, Y, Y, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VWYY_`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the W, Y, Y, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, Y, Y, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VWYZ`

`VEC``)`
```Swizzles the vector into a 3D one, filling its fields with the W, Y, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, Y, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VWYZW`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the W, Y, Z, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, Y, Z, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VWYZX`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the W, Y, Z, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, Y, Z, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VWYZY`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the W, Y, Z, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, Y, Z, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VWYZZ`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the W, Y, Z, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, Y, Z, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VWYZ_`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the W, Y, Z, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, Y, Z, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VWY_`

`VEC``)`
```Swizzles the vector into a 3D one, filling its fields with the W, Y, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, Y, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VWY_W`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the W, Y, _, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, Y, _, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VWY_X`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the W, Y, _, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, Y, _, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VWY_Y`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the W, Y, _, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, Y, _, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VWY_Z`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the W, Y, _, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, Y, _, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VWY__`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the W, Y, _, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, Y, _, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VWZ`

`VEC``)`
```Swizzles the vector into a 2D one, filling its fields with the W and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VWZW`

`VEC``)`
```Swizzles the vector into a 3D one, filling its fields with the W, Z, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, Z, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VWZWW`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the W, Z, W, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, Z, W, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VWZWX`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the W, Z, W, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, Z, W, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VWZWY`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the W, Z, W, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, Z, W, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VWZWZ`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the W, Z, W, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, Z, W, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VWZW_`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the W, Z, W, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, Z, W, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VWZX`

`VEC``)`
```Swizzles the vector into a 3D one, filling its fields with the W, Z, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, Z, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VWZXW`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the W, Z, X, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, Z, X, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VWZXX`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the W, Z, X, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, Z, X, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VWZXY`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the W, Z, X, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, Z, X, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VWZXZ`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the W, Z, X, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, Z, X, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VWZX_`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the W, Z, X, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, Z, X, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VWZY`

`VEC``)`
```Swizzles the vector into a 3D one, filling its fields with the W, Z, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, Z, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VWZYW`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the W, Z, Y, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, Z, Y, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VWZYX`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the W, Z, Y, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, Z, Y, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VWZYY`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the W, Z, Y, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, Z, Y, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VWZYZ`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the W, Z, Y, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, Z, Y, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VWZY_`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the W, Z, Y, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, Z, Y, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VWZZ`

`VEC``)`
```Swizzles the vector into a 3D one, filling its fields with the W, Z, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, Z, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VWZZW`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the W, Z, Z, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, Z, Z, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VWZZX`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the W, Z, Z, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, Z, Z, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VWZZY`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the W, Z, Z, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, Z, Z, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VWZZZ`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the W, Z, Z, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, Z, Z, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VWZZ_`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the W, Z, Z, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, Z, Z, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VWZ_`

`VEC``)`
```Swizzles the vector into a 3D one, filling its fields with the W, Z, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, Z, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VWZ_W`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the W, Z, _, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, Z, _, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VWZ_X`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the W, Z, _, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, Z, _, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VWZ_Y`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the W, Z, _, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, Z, _, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VWZ_Z`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the W, Z, _, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, Z, _, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VWZ__`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the W, Z, _, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, Z, _, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VW_`

`VEC``)`
```Swizzles the vector into a 2D one, filling its fields with the W and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VW_W`

`VEC``)`
```Swizzles the vector into a 3D one, filling its fields with the W, _, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, _, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VW_WW`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the W, _, W, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, _, W, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VW_WX`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the W, _, W, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, _, W, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VW_WY`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the W, _, W, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, _, W, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VW_WZ`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the W, _, W, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, _, W, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VW_W_`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the W, _, W, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, _, W, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VW_X`

`VEC``)`
```Swizzles the vector into a 3D one, filling its fields with the W, _, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, _, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VW_XW`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the W, _, X, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, _, X, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VW_XX`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the W, _, X, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, _, X, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VW_XY`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the W, _, X, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, _, X, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VW_XZ`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the W, _, X, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, _, X, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VW_X_`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the W, _, X, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, _, X, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VW_Y`

`VEC``)`
```Swizzles the vector into a 3D one, filling its fields with the W, _, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, _, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VW_YW`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the W, _, Y, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, _, Y, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VW_YX`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the W, _, Y, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, _, Y, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VW_YY`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the W, _, Y, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, _, Y, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VW_YZ`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the W, _, Y, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, _, Y, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VW_Y_`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the W, _, Y, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, _, Y, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VW_Z`

`VEC``)`
```Swizzles the vector into a 3D one, filling its fields with the W, _, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, _, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VW_ZW`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the W, _, Z, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, _, Z, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VW_ZX`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the W, _, Z, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, _, Z, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VW_ZY`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the W, _, Z, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, _, Z, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VW_ZZ`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the W, _, Z, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, _, Z, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VW_Z_`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the W, _, Z, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, _, Z, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VW__`

`VEC``)`
```Swizzles the vector into a 3D one, filling its fields with the W, _, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, _, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VW__W`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the W, _, _, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, _, _, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VW__X`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the W, _, _, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, _, _, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VW__Y`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the W, _, _, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, _, _, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VW__Z`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the W, _, _, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, _, _, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VW___`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the W, _, _, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the W, _, _, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VXW`

`VEC``)`
```Swizzles the vector into a 2D one, filling its fields with the X and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VXWW`

`VEC``)`
```Swizzles the vector into a 3D one, filling its fields with the X, W, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, W, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VXWWW`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the X, W, W, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, W, W, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VXWWX`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the X, W, W, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, W, W, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VXWWY`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the X, W, W, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, W, W, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VXWWZ`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the X, W, W, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, W, W, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VXWW_`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the X, W, W, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, W, W, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VXWX`

`VEC``)`
```Swizzles the vector into a 3D one, filling its fields with the X, W, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, W, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VXWXW`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the X, W, X, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, W, X, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VXWXX`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the X, W, X, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, W, X, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VXWXY`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the X, W, X, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, W, X, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VXWXZ`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the X, W, X, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, W, X, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VXWX_`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the X, W, X, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, W, X, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VXWY`

`VEC``)`
```Swizzles the vector into a 3D one, filling its fields with the X, W, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, W, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VXWYW`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the X, W, Y, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, W, Y, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VXWYX`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the X, W, Y, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, W, Y, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VXWYY`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the X, W, Y, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, W, Y, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VXWYZ`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the X, W, Y, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, W, Y, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VXWY_`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the X, W, Y, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, W, Y, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VXWZ`

`VEC``)`
```Swizzles the vector into a 3D one, filling its fields with the X, W, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, W, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VXWZW`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the X, W, Z, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, W, Z, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VXWZX`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the X, W, Z, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, W, Z, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VXWZY`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the X, W, Z, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, W, Z, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VXWZZ`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the X, W, Z, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, W, Z, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VXWZ_`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the X, W, Z, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, W, Z, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VXW_`

`VEC``)`
```Swizzles the vector into a 3D one, filling its fields with the X, W, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, W, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VXW_W`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the X, W, _, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, W, _, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VXW_X`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the X, W, _, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, W, _, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VXW_Y`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the X, W, _, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, W, _, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VXW_Z`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the X, W, _, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, W, _, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VXW__`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the X, W, _, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, W, _, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VXX`

`VEC``)`
```Swizzles the vector into a 2D one, filling its fields with the X and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VXXW`

`VEC``)`
```Swizzles the vector into a 3D one, filling its fields with the X, X, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, X, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VXXWW`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the X, X, W, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, X, W, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VXXWX`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the X, X, W, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, X, W, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VXXWY`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the X, X, W, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, X, W, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VXXWZ`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the X, X, W, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, X, W, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VXXW_`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the X, X, W, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, X, W, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VXXX`

`VEC``)`
```Swizzles the vector into a 3D one, filling its fields with the X, X, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, X, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VXXXW`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the X, X, X, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, X, X, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VXXXX`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the X, X, X, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, X, X, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VXXXY`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the X, X, X, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, X, X, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VXXXZ`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the X, X, X, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, X, X, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VXXX_`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the X, X, X, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, X, X, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VXXY`

`VEC``)`
```Swizzles the vector into a 3D one, filling its fields with the X, X, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, X, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VXXYW`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the X, X, Y, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, X, Y, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VXXYX`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the X, X, Y, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, X, Y, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VXXYY`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the X, X, Y, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, X, Y, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VXXYZ`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the X, X, Y, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, X, Y, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VXXY_`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the X, X, Y, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, X, Y, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VXXZ`

`VEC``)`
```Swizzles the vector into a 3D one, filling its fields with the X, X, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, X, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VXXZW`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the X, X, Z, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, X, Z, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VXXZX`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the X, X, Z, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, X, Z, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VXXZY`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the X, X, Z, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, X, Z, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VXXZZ`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the X, X, Z, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, X, Z, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VXXZ_`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the X, X, Z, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, X, Z, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VXX_`

`VEC``)`
```Swizzles the vector into a 3D one, filling its fields with the X, X, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, X, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VXX_W`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the X, X, _, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, X, _, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VXX_X`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the X, X, _, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, X, _, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VXX_Y`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the X, X, _, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, X, _, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VXX_Z`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the X, X, _, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, X, _, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VXX__`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the X, X, _, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, X, _, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VXY`

`VEC``)`
```Swizzles the vector into a 2D one, filling its fields with the X and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VXYW`

`VEC``)`
```Swizzles the vector into a 3D one, filling its fields with the X, Y, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, Y, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VXYWW`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the X, Y, W, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, Y, W, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VXYWX`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the X, Y, W, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, Y, W, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VXYWY`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the X, Y, W, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, Y, W, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VXYWZ`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the X, Y, W, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, Y, W, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VXYW_`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the X, Y, W, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, Y, W, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VXYX`

`VEC``)`
```Swizzles the vector into a 3D one, filling its fields with the X, Y, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, Y, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VXYXW`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the X, Y, X, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, Y, X, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VXYXX`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the X, Y, X, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, Y, X, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VXYXY`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the X, Y, X, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, Y, X, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VXYXZ`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the X, Y, X, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, Y, X, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VXYX_`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the X, Y, X, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, Y, X, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VXYY`

`VEC``)`
```Swizzles the vector into a 3D one, filling its fields with the X, Y, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, Y, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VXYYW`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the X, Y, Y, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, Y, Y, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VXYYX`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the X, Y, Y, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, Y, Y, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VXYYY`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the X, Y, Y, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, Y, Y, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VXYYZ`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the X, Y, Y, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, Y, Y, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VXYY_`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the X, Y, Y, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, Y, Y, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VXYZ`

`VEC``)`
```Swizzles the vector into a 3D one, filling its fields with the X, Y, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, Y, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VXYZW`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the X, Y, Z, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, Y, Z, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VXYZX`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the X, Y, Z, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, Y, Z, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VXYZY`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the X, Y, Z, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, Y, Z, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VXYZZ`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the X, Y, Z, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, Y, Z, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VXYZ_`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the X, Y, Z, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, Y, Z, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VXY_`

`VEC``)`
```Swizzles the vector into a 3D one, filling its fields with the X, Y, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, Y, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VXY_W`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the X, Y, _, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, Y, _, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VXY_X`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the X, Y, _, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, Y, _, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VXY_Y`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the X, Y, _, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, Y, _, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VXY_Z`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the X, Y, _, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, Y, _, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VXY__`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the X, Y, _, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, Y, _, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VXZ`

`VEC``)`
```Swizzles the vector into a 2D one, filling its fields with the X and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VXZW`

`VEC``)`
```Swizzles the vector into a 3D one, filling its fields with the X, Z, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, Z, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VXZWW`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the X, Z, W, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, Z, W, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VXZWX`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the X, Z, W, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, Z, W, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VXZWY`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the X, Z, W, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, Z, W, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VXZWZ`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the X, Z, W, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, Z, W, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VXZW_`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the X, Z, W, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, Z, W, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VXZX`

`VEC``)`
```Swizzles the vector into a 3D one, filling its fields with the X, Z, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, Z, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VXZXW`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the X, Z, X, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, Z, X, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VXZXX`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the X, Z, X, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, Z, X, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VXZXY`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the X, Z, X, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, Z, X, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VXZXZ`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the X, Z, X, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, Z, X, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VXZX_`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the X, Z, X, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, Z, X, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VXZY`

`VEC``)`
```Swizzles the vector into a 3D one, filling its fields with the X, Z, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, Z, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VXZYW`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the X, Z, Y, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, Z, Y, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VXZYX`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the X, Z, Y, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, Z, Y, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VXZYY`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the X, Z, Y, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, Z, Y, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VXZYZ`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the X, Z, Y, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, Z, Y, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VXZY_`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the X, Z, Y, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, Z, Y, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VXZZ`

`VEC``)`
```Swizzles the vector into a 3D one, filling its fields with the X, Z, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, Z, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VXZZW`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the X, Z, Z, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, Z, Z, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VXZZX`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the X, Z, Z, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, Z, Z, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VXZZY`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the X, Z, Z, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, Z, Z, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VXZZZ`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the X, Z, Z, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, Z, Z, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VXZZ_`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the X, Z, Z, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, Z, Z, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VXZ_`

`VEC``)`
```Swizzles the vector into a 3D one, filling its fields with the X, Z, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, Z, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VXZ_W`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the X, Z, _, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, Z, _, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VXZ_X`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the X, Z, _, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, Z, _, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VXZ_Y`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the X, Z, _, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, Z, _, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VXZ_Z`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the X, Z, _, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, Z, _, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VXZ__`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the X, Z, _, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, Z, _, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VX_`

`VEC``)`
```Swizzles the vector into a 2D one, filling its fields with the X and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VX_W`

`VEC``)`
```Swizzles the vector into a 3D one, filling its fields with the X, _, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, _, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VX_WW`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the X, _, W, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, _, W, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VX_WX`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the X, _, W, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, _, W, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VX_WY`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the X, _, W, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, _, W, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VX_WZ`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the X, _, W, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, _, W, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VX_W_`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the X, _, W, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, _, W, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VX_X`

`VEC``)`
```Swizzles the vector into a 3D one, filling its fields with the X, _, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, _, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VX_XW`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the X, _, X, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, _, X, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VX_XX`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the X, _, X, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, _, X, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VX_XY`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the X, _, X, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, _, X, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VX_XZ`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the X, _, X, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, _, X, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VX_X_`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the X, _, X, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, _, X, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VX_Y`

`VEC``)`
```Swizzles the vector into a 3D one, filling its fields with the X, _, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, _, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VX_YW`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the X, _, Y, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, _, Y, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VX_YX`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the X, _, Y, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, _, Y, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VX_YY`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the X, _, Y, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, _, Y, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VX_YZ`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the X, _, Y, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, _, Y, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VX_Y_`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the X, _, Y, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, _, Y, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VX_Z`

`VEC``)`
```Swizzles the vector into a 3D one, filling its fields with the X, _, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, _, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VX_ZW`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the X, _, Z, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, _, Z, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VX_ZX`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the X, _, Z, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, _, Z, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VX_ZY`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the X, _, Z, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, _, Z, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VX_ZZ`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the X, _, Z, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, _, Z, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VX_Z_`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the X, _, Z, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, _, Z, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VX__`

`VEC``)`
```Swizzles the vector into a 3D one, filling its fields with the X, _, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, _, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VX__W`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the X, _, _, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, _, _, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VX__X`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the X, _, _, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, _, _, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VX__Y`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the X, _, _, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, _, _, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VX__Z`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the X, _, _, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, _, _, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VX___`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the X, _, _, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the X, _, _, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VYW`

`VEC``)`
```Swizzles the vector into a 2D one, filling its fields with the Y and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VYWW`

`VEC``)`
```Swizzles the vector into a 3D one, filling its fields with the Y, W, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, W, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VYWWW`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Y, W, W, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, W, W, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VYWWX`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Y, W, W, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, W, W, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VYWWY`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Y, W, W, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, W, W, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VYWWZ`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Y, W, W, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, W, W, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VYWW_`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Y, W, W, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, W, W, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VYWX`

`VEC``)`
```Swizzles the vector into a 3D one, filling its fields with the Y, W, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, W, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VYWXW`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Y, W, X, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, W, X, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VYWXX`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Y, W, X, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, W, X, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VYWXY`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Y, W, X, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, W, X, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VYWXZ`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Y, W, X, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, W, X, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VYWX_`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Y, W, X, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, W, X, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VYWY`

`VEC``)`
```Swizzles the vector into a 3D one, filling its fields with the Y, W, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, W, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VYWYW`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Y, W, Y, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, W, Y, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VYWYX`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Y, W, Y, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, W, Y, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VYWYY`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Y, W, Y, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, W, Y, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VYWYZ`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Y, W, Y, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, W, Y, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VYWY_`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Y, W, Y, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, W, Y, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VYWZ`

`VEC``)`
```Swizzles the vector into a 3D one, filling its fields with the Y, W, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, W, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VYWZW`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Y, W, Z, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, W, Z, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VYWZX`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Y, W, Z, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, W, Z, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VYWZY`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Y, W, Z, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, W, Z, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VYWZZ`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Y, W, Z, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, W, Z, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VYWZ_`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Y, W, Z, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, W, Z, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VYW_`

`VEC``)`
```Swizzles the vector into a 3D one, filling its fields with the Y, W, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, W, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VYW_W`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Y, W, _, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, W, _, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VYW_X`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Y, W, _, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, W, _, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VYW_Y`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Y, W, _, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, W, _, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VYW_Z`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Y, W, _, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, W, _, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VYW__`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Y, W, _, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, W, _, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VYX`

`VEC``)`
```Swizzles the vector into a 2D one, filling its fields with the Y and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VYXW`

`VEC``)`
```Swizzles the vector into a 3D one, filling its fields with the Y, X, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, X, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VYXWW`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Y, X, W, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, X, W, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VYXWX`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Y, X, W, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, X, W, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VYXWY`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Y, X, W, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, X, W, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VYXWZ`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Y, X, W, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, X, W, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VYXW_`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Y, X, W, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, X, W, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VYXX`

`VEC``)`
```Swizzles the vector into a 3D one, filling its fields with the Y, X, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, X, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VYXXW`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Y, X, X, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, X, X, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VYXXX`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Y, X, X, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, X, X, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VYXXY`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Y, X, X, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, X, X, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VYXXZ`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Y, X, X, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, X, X, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VYXX_`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Y, X, X, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, X, X, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VYXY`

`VEC``)`
```Swizzles the vector into a 3D one, filling its fields with the Y, X, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, X, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VYXYW`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Y, X, Y, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, X, Y, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VYXYX`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Y, X, Y, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, X, Y, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VYXYY`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Y, X, Y, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, X, Y, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VYXYZ`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Y, X, Y, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, X, Y, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VYXY_`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Y, X, Y, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, X, Y, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VYXZ`

`VEC``)`
```Swizzles the vector into a 3D one, filling its fields with the Y, X, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, X, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VYXZW`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Y, X, Z, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, X, Z, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VYXZX`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Y, X, Z, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, X, Z, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VYXZY`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Y, X, Z, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, X, Z, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VYXZZ`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Y, X, Z, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, X, Z, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VYXZ_`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Y, X, Z, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, X, Z, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VYX_`

`VEC``)`
```Swizzles the vector into a 3D one, filling its fields with the Y, X, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, X, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VYX_W`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Y, X, _, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, X, _, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VYX_X`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Y, X, _, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, X, _, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VYX_Y`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Y, X, _, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, X, _, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VYX_Z`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Y, X, _, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, X, _, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VYX__`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Y, X, _, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, X, _, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VYY`

`VEC``)`
```Swizzles the vector into a 2D one, filling its fields with the Y and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VYYW`

`VEC``)`
```Swizzles the vector into a 3D one, filling its fields with the Y, Y, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, Y, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VYYWW`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Y, Y, W, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, Y, W, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VYYWX`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Y, Y, W, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, Y, W, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VYYWY`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Y, Y, W, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, Y, W, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VYYWZ`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Y, Y, W, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, Y, W, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VYYW_`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Y, Y, W, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, Y, W, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VYYX`

`VEC``)`
```Swizzles the vector into a 3D one, filling its fields with the Y, Y, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, Y, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VYYXW`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Y, Y, X, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, Y, X, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VYYXX`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Y, Y, X, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, Y, X, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VYYXY`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Y, Y, X, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, Y, X, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VYYXZ`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Y, Y, X, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, Y, X, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VYYX_`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Y, Y, X, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, Y, X, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VYYY`

`VEC``)`
```Swizzles the vector into a 3D one, filling its fields with the Y, Y, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, Y, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VYYYW`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Y, Y, Y, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, Y, Y, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VYYYX`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Y, Y, Y, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, Y, Y, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VYYYY`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Y, Y, Y, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, Y, Y, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VYYYZ`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Y, Y, Y, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, Y, Y, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VYYY_`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Y, Y, Y, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, Y, Y, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VYYZ`

`VEC``)`
```Swizzles the vector into a 3D one, filling its fields with the Y, Y, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, Y, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VYYZW`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Y, Y, Z, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, Y, Z, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VYYZX`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Y, Y, Z, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, Y, Z, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VYYZY`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Y, Y, Z, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, Y, Z, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VYYZZ`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Y, Y, Z, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, Y, Z, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VYYZ_`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Y, Y, Z, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, Y, Z, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VYY_`

`VEC``)`
```Swizzles the vector into a 3D one, filling its fields with the Y, Y, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, Y, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VYY_W`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Y, Y, _, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, Y, _, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VYY_X`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Y, Y, _, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, Y, _, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VYY_Y`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Y, Y, _, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, Y, _, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VYY_Z`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Y, Y, _, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, Y, _, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VYY__`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Y, Y, _, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, Y, _, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VYZ`

`VEC``)`
```Swizzles the vector into a 2D one, filling its fields with the Y and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VYZW`

`VEC``)`
```Swizzles the vector into a 3D one, filling its fields with the Y, Z, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, Z, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VYZWW`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Y, Z, W, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, Z, W, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VYZWX`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Y, Z, W, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, Z, W, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VYZWY`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Y, Z, W, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, Z, W, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VYZWZ`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Y, Z, W, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, Z, W, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VYZW_`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Y, Z, W, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, Z, W, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VYZX`

`VEC``)`
```Swizzles the vector into a 3D one, filling its fields with the Y, Z, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, Z, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VYZXW`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Y, Z, X, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, Z, X, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VYZXX`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Y, Z, X, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, Z, X, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VYZXY`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Y, Z, X, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, Z, X, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VYZXZ`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Y, Z, X, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, Z, X, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VYZX_`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Y, Z, X, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, Z, X, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VYZY`

`VEC``)`
```Swizzles the vector into a 3D one, filling its fields with the Y, Z, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, Z, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VYZYW`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Y, Z, Y, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, Z, Y, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VYZYX`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Y, Z, Y, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, Z, Y, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VYZYY`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Y, Z, Y, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, Z, Y, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VYZYZ`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Y, Z, Y, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, Z, Y, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VYZY_`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Y, Z, Y, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, Z, Y, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VYZZ`

`VEC``)`
```Swizzles the vector into a 3D one, filling its fields with the Y, Z, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, Z, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VYZZW`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Y, Z, Z, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, Z, Z, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VYZZX`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Y, Z, Z, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, Z, Z, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VYZZY`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Y, Z, Z, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, Z, Z, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VYZZZ`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Y, Z, Z, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, Z, Z, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VYZZ_`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Y, Z, Z, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, Z, Z, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VYZ_`

`VEC``)`
```Swizzles the vector into a 3D one, filling its fields with the Y, Z, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, Z, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VYZ_W`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Y, Z, _, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, Z, _, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VYZ_X`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Y, Z, _, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, Z, _, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VYZ_Y`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Y, Z, _, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, Z, _, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VYZ_Z`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Y, Z, _, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, Z, _, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VYZ__`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Y, Z, _, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, Z, _, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VY_`

`VEC``)`
```Swizzles the vector into a 2D one, filling its fields with the Y and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VY_W`

`VEC``)`
```Swizzles the vector into a 3D one, filling its fields with the Y, _, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, _, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VY_WW`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Y, _, W, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, _, W, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VY_WX`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Y, _, W, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, _, W, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VY_WY`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Y, _, W, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, _, W, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VY_WZ`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Y, _, W, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, _, W, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VY_W_`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Y, _, W, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, _, W, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VY_X`

`VEC``)`
```Swizzles the vector into a 3D one, filling its fields with the Y, _, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, _, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VY_XW`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Y, _, X, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, _, X, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VY_XX`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Y, _, X, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, _, X, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VY_XY`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Y, _, X, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, _, X, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VY_XZ`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Y, _, X, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, _, X, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VY_X_`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Y, _, X, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, _, X, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VY_Y`

`VEC``)`
```Swizzles the vector into a 3D one, filling its fields with the Y, _, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, _, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VY_YW`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Y, _, Y, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, _, Y, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VY_YX`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Y, _, Y, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, _, Y, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VY_YY`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Y, _, Y, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, _, Y, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VY_YZ`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Y, _, Y, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, _, Y, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VY_Y_`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Y, _, Y, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, _, Y, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VY_Z`

`VEC``)`
```Swizzles the vector into a 3D one, filling its fields with the Y, _, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, _, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VY_ZW`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Y, _, Z, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, _, Z, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VY_ZX`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Y, _, Z, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, _, Z, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VY_ZY`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Y, _, Z, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, _, Z, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VY_ZZ`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Y, _, Z, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, _, Z, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VY_Z_`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Y, _, Z, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, _, Z, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VY__`

`VEC``)`
```Swizzles the vector into a 3D one, filling its fields with the Y, _, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, _, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VY__W`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Y, _, _, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, _, _, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VY__X`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Y, _, _, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, _, _, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VY__Y`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Y, _, _, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, _, _, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VY__Z`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Y, _, _, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, _, _, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VY___`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Y, _, _, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Y, _, _, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZW`

`VEC``)`
```Swizzles the vector into a 2D one, filling its fields with the Z and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZWW`

`VEC``)`
```Swizzles the vector into a 3D one, filling its fields with the Z, W, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, W, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZWWW`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Z, W, W, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, W, W, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZWWX`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Z, W, W, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, W, W, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZWWY`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Z, W, W, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, W, W, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZWWZ`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Z, W, W, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, W, W, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZWW_`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Z, W, W, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, W, W, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZWX`

`VEC``)`
```Swizzles the vector into a 3D one, filling its fields with the Z, W, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, W, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZWXW`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Z, W, X, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, W, X, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZWXX`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Z, W, X, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, W, X, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZWXY`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Z, W, X, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, W, X, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZWXZ`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Z, W, X, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, W, X, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZWX_`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Z, W, X, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, W, X, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZWY`

`VEC``)`
```Swizzles the vector into a 3D one, filling its fields with the Z, W, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, W, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZWYW`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Z, W, Y, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, W, Y, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZWYX`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Z, W, Y, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, W, Y, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZWYY`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Z, W, Y, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, W, Y, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZWYZ`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Z, W, Y, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, W, Y, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZWY_`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Z, W, Y, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, W, Y, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZWZ`

`VEC``)`
```Swizzles the vector into a 3D one, filling its fields with the Z, W, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, W, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZWZW`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Z, W, Z, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, W, Z, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZWZX`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Z, W, Z, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, W, Z, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZWZY`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Z, W, Z, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, W, Z, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZWZZ`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Z, W, Z, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, W, Z, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZWZ_`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Z, W, Z, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, W, Z, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZW_`

`VEC``)`
```Swizzles the vector into a 3D one, filling its fields with the Z, W, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, W, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZW_W`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Z, W, _, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, W, _, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZW_X`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Z, W, _, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, W, _, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZW_Y`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Z, W, _, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, W, _, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZW_Z`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Z, W, _, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, W, _, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZW__`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Z, W, _, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, W, _, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZX`

`VEC``)`
```Swizzles the vector into a 2D one, filling its fields with the Z and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZXW`

`VEC``)`
```Swizzles the vector into a 3D one, filling its fields with the Z, X, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, X, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZXWW`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Z, X, W, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, X, W, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZXWX`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Z, X, W, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, X, W, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZXWY`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Z, X, W, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, X, W, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZXWZ`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Z, X, W, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, X, W, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZXW_`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Z, X, W, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, X, W, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZXX`

`VEC``)`
```Swizzles the vector into a 3D one, filling its fields with the Z, X, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, X, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZXXW`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Z, X, X, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, X, X, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZXXX`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Z, X, X, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, X, X, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZXXY`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Z, X, X, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, X, X, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZXXZ`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Z, X, X, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, X, X, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZXX_`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Z, X, X, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, X, X, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZXY`

`VEC``)`
```Swizzles the vector into a 3D one, filling its fields with the Z, X, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, X, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZXYW`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Z, X, Y, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, X, Y, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZXYX`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Z, X, Y, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, X, Y, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZXYY`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Z, X, Y, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, X, Y, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZXYZ`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Z, X, Y, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, X, Y, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZXY_`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Z, X, Y, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, X, Y, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZXZ`

`VEC``)`
```Swizzles the vector into a 3D one, filling its fields with the Z, X, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, X, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZXZW`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Z, X, Z, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, X, Z, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZXZX`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Z, X, Z, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, X, Z, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZXZY`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Z, X, Z, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, X, Z, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZXZZ`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Z, X, Z, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, X, Z, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZXZ_`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Z, X, Z, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, X, Z, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZX_`

`VEC``)`
```Swizzles the vector into a 3D one, filling its fields with the Z, X, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, X, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZX_W`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Z, X, _, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, X, _, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZX_X`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Z, X, _, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, X, _, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZX_Y`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Z, X, _, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, X, _, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZX_Z`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Z, X, _, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, X, _, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZX__`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Z, X, _, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, X, _, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZY`

`VEC``)`
```Swizzles the vector into a 2D one, filling its fields with the Z and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZYW`

`VEC``)`
```Swizzles the vector into a 3D one, filling its fields with the Z, Y, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, Y, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZYWW`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Z, Y, W, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, Y, W, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZYWX`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Z, Y, W, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, Y, W, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZYWY`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Z, Y, W, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, Y, W, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZYWZ`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Z, Y, W, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, Y, W, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZYW_`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Z, Y, W, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, Y, W, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZYX`

`VEC``)`
```Swizzles the vector into a 3D one, filling its fields with the Z, Y, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, Y, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZYXW`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Z, Y, X, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, Y, X, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZYXX`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Z, Y, X, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, Y, X, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZYXY`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Z, Y, X, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, Y, X, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZYXZ`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Z, Y, X, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, Y, X, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZYX_`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Z, Y, X, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, Y, X, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZYY`

`VEC``)`
```Swizzles the vector into a 3D one, filling its fields with the Z, Y, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, Y, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZYYW`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Z, Y, Y, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, Y, Y, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZYYX`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Z, Y, Y, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, Y, Y, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZYYY`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Z, Y, Y, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, Y, Y, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZYYZ`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Z, Y, Y, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, Y, Y, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZYY_`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Z, Y, Y, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, Y, Y, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZYZ`

`VEC``)`
```Swizzles the vector into a 3D one, filling its fields with the Z, Y, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, Y, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZYZW`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Z, Y, Z, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, Y, Z, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZYZX`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Z, Y, Z, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, Y, Z, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZYZY`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Z, Y, Z, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, Y, Z, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZYZZ`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Z, Y, Z, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, Y, Z, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZYZ_`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Z, Y, Z, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, Y, Z, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZY_`

`VEC``)`
```Swizzles the vector into a 3D one, filling its fields with the Z, Y, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, Y, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZY_W`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Z, Y, _, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, Y, _, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZY_X`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Z, Y, _, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, Y, _, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZY_Y`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Z, Y, _, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, Y, _, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZY_Z`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Z, Y, _, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, Y, _, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZY__`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Z, Y, _, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, Y, _, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZZ`

`VEC``)`
```Swizzles the vector into a 2D one, filling its fields with the Z and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZZW`

`VEC``)`
```Swizzles the vector into a 3D one, filling its fields with the Z, Z, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, Z, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZZWW`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Z, Z, W, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, Z, W, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZZWX`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Z, Z, W, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, Z, W, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZZWY`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Z, Z, W, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, Z, W, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZZWZ`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Z, Z, W, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, Z, W, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZZW_`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Z, Z, W, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, Z, W, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZZX`

`VEC``)`
```Swizzles the vector into a 3D one, filling its fields with the Z, Z, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, Z, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZZXW`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Z, Z, X, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, Z, X, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZZXX`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Z, Z, X, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, Z, X, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZZXY`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Z, Z, X, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, Z, X, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZZXZ`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Z, Z, X, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, Z, X, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZZX_`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Z, Z, X, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, Z, X, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZZY`

`VEC``)`
```Swizzles the vector into a 3D one, filling its fields with the Z, Z, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, Z, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZZYW`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Z, Z, Y, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, Z, Y, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZZYX`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Z, Z, Y, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, Z, Y, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZZYY`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Z, Z, Y, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, Z, Y, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZZYZ`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Z, Z, Y, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, Z, Y, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZZY_`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Z, Z, Y, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, Z, Y, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZZZ`

`VEC``)`
```Swizzles the vector into a 3D one, filling its fields with the Z, Z, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, Z, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZZZW`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Z, Z, Z, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, Z, Z, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZZZX`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Z, Z, Z, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, Z, Z, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZZZY`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Z, Z, Z, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, Z, Z, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZZZZ`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Z, Z, Z, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, Z, Z, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZZZ_`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Z, Z, Z, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, Z, Z, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZZ_`

`VEC``)`
```Swizzles the vector into a 3D one, filling its fields with the Z, Z, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, Z, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZZ_W`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Z, Z, _, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, Z, _, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZZ_X`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Z, Z, _, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, Z, _, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZZ_Y`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Z, Z, _, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, Z, _, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZZ_Z`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Z, Z, _, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, Z, _, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZZ__`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Z, Z, _, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, Z, _, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZ_`

`VEC``)`
```Swizzles the vector into a 2D one, filling its fields with the Z and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZ_W`

`VEC``)`
```Swizzles the vector into a 3D one, filling its fields with the Z, _, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, _, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZ_WW`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Z, _, W, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, _, W, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZ_WX`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Z, _, W, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, _, W, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZ_WY`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Z, _, W, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, _, W, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZ_WZ`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Z, _, W, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, _, W, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZ_W_`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Z, _, W, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, _, W, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZ_X`

`VEC``)`
```Swizzles the vector into a 3D one, filling its fields with the Z, _, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, _, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZ_XW`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Z, _, X, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, _, X, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZ_XX`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Z, _, X, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, _, X, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZ_XY`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Z, _, X, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, _, X, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZ_XZ`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Z, _, X, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, _, X, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZ_X_`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Z, _, X, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, _, X, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZ_Y`

`VEC``)`
```Swizzles the vector into a 3D one, filling its fields with the Z, _, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, _, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZ_YW`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Z, _, Y, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, _, Y, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZ_YX`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Z, _, Y, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, _, Y, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZ_YY`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Z, _, Y, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, _, Y, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZ_YZ`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Z, _, Y, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, _, Y, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZ_Y_`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Z, _, Y, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, _, Y, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZ_Z`

`VEC``)`
```Swizzles the vector into a 3D one, filling its fields with the Z, _, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, _, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZ_ZW`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Z, _, Z, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, _, Z, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZ_ZX`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Z, _, Z, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, _, Z, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZ_ZY`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Z, _, Z, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, _, Z, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZ_ZZ`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Z, _, Z, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, _, Z, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZ_Z_`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Z, _, Z, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, _, Z, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZ__`

`VEC``)`
```Swizzles the vector into a 3D one, filling its fields with the Z, _, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, _, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZ__W`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Z, _, _, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, _, _, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZ__X`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Z, _, _, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, _, _, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZ__Y`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Z, _, _, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, _, _, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZ__Z`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Z, _, _, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, _, _, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`VZ___`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the Z, _, _, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the Z, _, _, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V_W`

`VEC``)`
```Swizzles the vector into a 2D one, filling its fields with the _ and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _ and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V_WW`

`VEC``)`
```Swizzles the vector into a 3D one, filling its fields with the _, W, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, W, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V_WWW`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the _, W, W, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, W, W, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V_WWX`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the _, W, W, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, W, W, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V_WWY`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the _, W, W, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, W, W, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V_WWZ`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the _, W, W, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, W, W, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V_WW_`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the _, W, W, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, W, W, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V_WX`

`VEC``)`
```Swizzles the vector into a 3D one, filling its fields with the _, W, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, W, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V_WXW`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the _, W, X, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, W, X, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V_WXX`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the _, W, X, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, W, X, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V_WXY`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the _, W, X, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, W, X, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V_WXZ`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the _, W, X, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, W, X, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V_WX_`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the _, W, X, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, W, X, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V_WY`

`VEC``)`
```Swizzles the vector into a 3D one, filling its fields with the _, W, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, W, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V_WYW`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the _, W, Y, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, W, Y, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V_WYX`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the _, W, Y, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, W, Y, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V_WYY`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the _, W, Y, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, W, Y, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V_WYZ`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the _, W, Y, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, W, Y, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V_WY_`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the _, W, Y, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, W, Y, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V_WZ`

`VEC``)`
```Swizzles the vector into a 3D one, filling its fields with the _, W, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, W, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V_WZW`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the _, W, Z, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, W, Z, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V_WZX`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the _, W, Z, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, W, Z, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V_WZY`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the _, W, Z, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, W, Z, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V_WZZ`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the _, W, Z, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, W, Z, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V_WZ_`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the _, W, Z, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, W, Z, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V_W_`

`VEC``)`
```Swizzles the vector into a 3D one, filling its fields with the _, W, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, W, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V_W_W`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the _, W, _, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, W, _, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V_W_X`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the _, W, _, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, W, _, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V_W_Y`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the _, W, _, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, W, _, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V_W_Z`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the _, W, _, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, W, _, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V_W__`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the _, W, _, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, W, _, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V_X`

`VEC``)`
```Swizzles the vector into a 2D one, filling its fields with the _ and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _ and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V_XW`

`VEC``)`
```Swizzles the vector into a 3D one, filling its fields with the _, X, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, X, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V_XWW`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the _, X, W, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, X, W, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V_XWX`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the _, X, W, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, X, W, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V_XWY`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the _, X, W, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, X, W, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V_XWZ`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the _, X, W, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, X, W, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V_XW_`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the _, X, W, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, X, W, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V_XX`

`VEC``)`
```Swizzles the vector into a 3D one, filling its fields with the _, X, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, X, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V_XXW`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the _, X, X, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, X, X, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V_XXX`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the _, X, X, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, X, X, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V_XXY`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the _, X, X, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, X, X, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V_XXZ`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the _, X, X, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, X, X, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V_XX_`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the _, X, X, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, X, X, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V_XY`

`VEC``)`
```Swizzles the vector into a 3D one, filling its fields with the _, X, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, X, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V_XYW`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the _, X, Y, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, X, Y, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V_XYX`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the _, X, Y, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, X, Y, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V_XYY`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the _, X, Y, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, X, Y, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V_XYZ`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the _, X, Y, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, X, Y, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V_XY_`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the _, X, Y, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, X, Y, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V_XZ`

`VEC``)`
```Swizzles the vector into a 3D one, filling its fields with the _, X, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, X, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V_XZW`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the _, X, Z, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, X, Z, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V_XZX`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the _, X, Z, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, X, Z, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V_XZY`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the _, X, Z, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, X, Z, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V_XZZ`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the _, X, Z, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, X, Z, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V_XZ_`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the _, X, Z, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, X, Z, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V_X_`

`VEC``)`
```Swizzles the vector into a 3D one, filling its fields with the _, X, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, X, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V_X_W`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the _, X, _, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, X, _, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V_X_X`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the _, X, _, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, X, _, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V_X_Y`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the _, X, _, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, X, _, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V_X_Z`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the _, X, _, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, X, _, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V_X__`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the _, X, _, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, X, _, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V_Y`

`VEC``)`
```Swizzles the vector into a 2D one, filling its fields with the _ and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _ and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V_YW`

`VEC``)`
```Swizzles the vector into a 3D one, filling its fields with the _, Y, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, Y, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V_YWW`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the _, Y, W, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, Y, W, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V_YWX`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the _, Y, W, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, Y, W, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V_YWY`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the _, Y, W, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, Y, W, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V_YWZ`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the _, Y, W, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, Y, W, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V_YW_`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the _, Y, W, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, Y, W, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V_YX`

`VEC``)`
```Swizzles the vector into a 3D one, filling its fields with the _, Y, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, Y, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V_YXW`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the _, Y, X, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, Y, X, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V_YXX`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the _, Y, X, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, Y, X, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V_YXY`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the _, Y, X, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, Y, X, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V_YXZ`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the _, Y, X, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, Y, X, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V_YX_`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the _, Y, X, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, Y, X, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V_YY`

`VEC``)`
```Swizzles the vector into a 3D one, filling its fields with the _, Y, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, Y, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V_YYW`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the _, Y, Y, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, Y, Y, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V_YYX`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the _, Y, Y, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, Y, Y, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V_YYY`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the _, Y, Y, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, Y, Y, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V_YYZ`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the _, Y, Y, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, Y, Y, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V_YY_`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the _, Y, Y, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, Y, Y, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V_YZ`

`VEC``)`
```Swizzles the vector into a 3D one, filling its fields with the _, Y, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, Y, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V_YZW`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the _, Y, Z, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, Y, Z, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V_YZX`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the _, Y, Z, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, Y, Z, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V_YZY`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the _, Y, Z, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, Y, Z, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V_YZZ`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the _, Y, Z, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, Y, Z, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V_YZ_`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the _, Y, Z, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, Y, Z, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V_Y_`

`VEC``)`
```Swizzles the vector into a 3D one, filling its fields with the _, Y, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, Y, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V_Y_W`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the _, Y, _, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, Y, _, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V_Y_X`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the _, Y, _, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, Y, _, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V_Y_Y`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the _, Y, _, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, Y, _, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V_Y_Z`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the _, Y, _, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, Y, _, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V_Y__`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the _, Y, _, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, Y, _, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V_Z`

`VEC``)`
```Swizzles the vector into a 2D one, filling its fields with the _ and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _ and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V_ZW`

`VEC``)`
```Swizzles the vector into a 3D one, filling its fields with the _, Z, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, Z, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V_ZWW`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the _, Z, W, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, Z, W, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V_ZWX`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the _, Z, W, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, Z, W, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V_ZWY`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the _, Z, W, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, Z, W, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V_ZWZ`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the _, Z, W, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, Z, W, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V_ZW_`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the _, Z, W, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, Z, W, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V_ZX`

`VEC``)`
```Swizzles the vector into a 3D one, filling its fields with the _, Z, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, Z, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V_ZXW`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the _, Z, X, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, Z, X, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V_ZXX`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the _, Z, X, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, Z, X, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V_ZXY`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the _, Z, X, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, Z, X, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V_ZXZ`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the _, Z, X, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, Z, X, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V_ZX_`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the _, Z, X, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, Z, X, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V_ZY`

`VEC``)`
```Swizzles the vector into a 3D one, filling its fields with the _, Z, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, Z, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V_ZYW`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the _, Z, Y, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, Z, Y, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V_ZYX`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the _, Z, Y, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, Z, Y, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V_ZYY`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the _, Z, Y, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, Z, Y, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V_ZYZ`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the _, Z, Y, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, Z, Y, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V_ZY_`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the _, Z, Y, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, Z, Y, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V_ZZ`

`VEC``)`
```Swizzles the vector into a 3D one, filling its fields with the _, Z, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, Z, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V_ZZW`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the _, Z, Z, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, Z, Z, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V_ZZX`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the _, Z, Z, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, Z, Z, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V_ZZY`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the _, Z, Z, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, Z, Z, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V_ZZZ`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the _, Z, Z, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, Z, Z, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V_ZZ_`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the _, Z, Z, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, Z, Z, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V_Z_`

`VEC``)`
```Swizzles the vector into a 3D one, filling its fields with the _, Z, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, Z, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V_Z_W`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the _, Z, _, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, Z, _, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V_Z_X`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the _, Z, _, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, Z, _, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V_Z_Y`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the _, Z, _, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, Z, _, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V_Z_Z`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the _, Z, _, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, Z, _, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V_Z__`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the _, Z, _, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, Z, _, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V__`

`VEC``)`
```Swizzles the vector into a 2D one, filling its fields with the _ and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _ and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V__W`

`VEC``)`
```Swizzles the vector into a 3D one, filling its fields with the _, _, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, _, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V__WW`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the _, _, W, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, _, W, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V__WX`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the _, _, W, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, _, W, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V__WY`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the _, _, W, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, _, W, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V__WZ`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the _, _, W, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, _, W, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V__W_`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the _, _, W, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, _, W, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V__X`

`VEC``)`
```Swizzles the vector into a 3D one, filling its fields with the _, _, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, _, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V__XW`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the _, _, X, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, _, X, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V__XX`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the _, _, X, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, _, X, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V__XY`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the _, _, X, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, _, X, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V__XZ`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the _, _, X, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, _, X, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V__X_`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the _, _, X, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, _, X, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V__Y`

`VEC``)`
```Swizzles the vector into a 3D one, filling its fields with the _, _, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, _, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V__YW`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the _, _, Y, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, _, Y, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V__YX`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the _, _, Y, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, _, Y, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V__YY`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the _, _, Y, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, _, Y, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V__YZ`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the _, _, Y, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, _, Y, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V__Y_`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the _, _, Y, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, _, Y, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V__Z`

`VEC``)`
```Swizzles the vector into a 3D one, filling its fields with the _, _, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, _, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V__ZW`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the _, _, Z, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, _, Z, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V__ZX`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the _, _, Z, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, _, Z, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V__ZY`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the _, _, Z, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, _, Z, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V__ZZ`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the _, _, Z, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, _, Z, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V__Z_`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the _, _, Z, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, _, Z, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V___`

`VEC``)`
```Swizzles the vector into a 3D one, filling its fields with the _, _, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, _, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V___W`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the _, _, _, and W components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, _, _, and W components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V___X`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the _, _, _, and X components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, _, _, and X components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V___Y`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the _, _, _, and Y components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, _, _, and Y components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V___Z`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the _, _, _, and Z components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, _, _, and Z components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• accessor `(`

`V____`

`VEC``)`
```Swizzles the vector into a 4D one, filling its fields with the _, _, _, and _ components of the given vector respectively.

When used as a writer sets the fields of the vector, replacing the _, _, _, and _ components with the XYZW of the value respectively in that order.
Note that, unlike usual SETF functions that return the value you set to, this returns the modified vector.```
• function `(`

`NV*`

`VAL &REST VALS``)`
`Same as *, but modifies the first vector. Accepts REALs or VECs as arguments, where REALs are used for each component of the vector.`
• function `(`

`NV+`

`VAL &REST VALS``)`
`Same as +, but modifies the first vector. Accepts REALs or VECs as arguments, where REALs are used for each component of the vector.`
• function `(`

`NV-`

`VAL &REST VALS``)`
`Same as -, but modifies the first vector. Accepts REALs or VECs as arguments, where REALs are used for each component of the vector.`
• function `(`

`NV/`

`VAL &REST VALS``)`
`Same as /, but modifies the first vector. Accepts REALs or VECs as arguments, where REALs are used for each component of the vector.`
• function `(`

`NVABS`

`VEC``)`
`Performs ABS on each component of the vector and stores back the results.`
• function `(`

`NVCLAMP`

`LOWER VEC UPPER``)`
`Clamps the vector such that each field is within [LOWER, UPPER]. Accepts REALs or VECs as limits, where REALs are used for each component of the vector.`
• function `(`

`NVLIMIT`

`VEC LIMIT``)`
`Limits the vector such that each field is within [-LIMIT, LIMIT]. Accepts a REAL or VEc for the limit, where a REAL is used for each component of the vector.`
• function `(`

`NVMOD`

`VEC DIVISOR``)`
`Performs MOD on each component of the vector and stores back the results.`
• function `(`

`NVORDER`

`V X &OPTIONAL Y Z W``)`
No docstring provided.
• function `(`

`NVROT`

`V AXIS PHI``)`
```Rotates the 3D vector around AXIS by PHI rads. The axis has to be a unit vector.
This operation does not work with 2D or 4D vectors.```
• function `(`

`NVROTV`

`A B``)`
```Rotates the 3D vector A around each axis by the amount in B. The rotations are performed in the order of X, Y, Z.
Note that rotation in 3D space is not commutative, so this function might not perform the rotation as you expected if you need the rotation to happen in a different order.
This operation does not work with 2D or 4D vectors.

See NVROT.```
• function `(`

`NVSCALE`

`VEC LENGTH``)`
`Scales the vector to be of the specified length.`
• function `(`

`NVUNIT`

`VEC``)`
`Normalizes the vector into its unit form by the 2-norm.`
• function `(`

`V*`

`VAL &REST VALS``)`
`Same as *, but always returns a vector. Accepts REALs or VECs as arguments, where REALs are used for each component of the vector.`
• function `(`

`V+`

`VAL &REST VALS``)`
`Same as +, but always returns a vector. Accepts REALs or VECs as arguments, where REALs are used for each component of the vector.`
• function `(`

`V-`

`VAL &REST VALS``)`
`Same as -, but always returns a vector. Accepts REALs or VECs as arguments, where REALs are used for each component of the vector.`
• function `(`

`V.`

`A B``)`
`Returns the dot product of the two vectors.`
• function `(`

`V/`

`VAL &REST VALS``)`
`Same as /, but always returns a vector. Accepts REALs or VECs as arguments, where REALs are used for each component of the vector.`
• function `(`

`V/=`

`VAL &REST VALS``)`
`This is the same as /=, but testing all vector fields simultaneously.`
• function `(`

`V1+`

`V``)`
`Same as 1+, but returns a new vector with each component increased by 1.`
• function `(`

`V1-`

`V``)`
`Same as 1-, but returns a new vector with each component decreased by 1.`
• function `(`

`V1NORM`

`V``)`
`Returns the taxicab/1-norm of the vector.`
• function `(`

`V2NORM`

`V``)`
`Returns the euclidean/2-norm of the vector.`
• function `(`

`V<`

`VAL &REST VALS``)`
`This is the same as <, but testing all vector fields simultaneously.`
• function `(`

`V<=`

`VAL &REST VALS``)`
`This is the same as <=, but testing all vector fields simultaneously.`
• function `(`

`V=`

`VAL &REST VALS``)`
`This is the same as =, but testing all vector fields simultaneously.`
• function `(`

`V>`

`VAL &REST VALS``)`
`This is the same as >, but testing all vector fields simultaneously.`
• function `(`

`V>=`

`VAL &REST VALS``)`
`This is the same as >=, but testing all vector fields simultaneously.`
• function `(`

`VABS`

`VEC``)`
`Returns a vector with each component being the absolute value of the given vector's.`
• function `(`

`VANGLE`

`A B``)`
`Returns the angle between two vectors.`
• function `(`

`VC`

`A B``)`
```Returns the cross product of the two 3D vectors.
This operation does not work with 2D or 4D vectors.```
• function `(`

`VCLAMP`

`LOWER VEC UPPER``)`
`Returns a clamped vector where each field is within [LOWER, UPPER]. Accepts REALs or VECs as arguments, where REALs are used for each component of the vector.`
• function `(`

`VCOPY`

`VEC``)`
`Creates a copy of the vector.`
• function `(`

`VCOPY2`

`INSTANCE``)`
`Creates a copy of a 2D vector.`
• function `(`

`VCOPY3`

`INSTANCE``)`
`Creates a copy of a 3D vector.`
• function `(`

`VCOPY4`

`INSTANCE``)`
`Creates a copy of a 4D vector.`
• function `(`

`VDISTANCE`

`A B``)`
`Returns the distance from A to B.`
• function `(`

`VEC`

`X Y &OPTIONAL Z W``)`
`Creates a new vector of the appropriate size.`
• function `(`

`VEC-P`

`VEC``)`
`Returns T if the argument is a vector.`
• function `(`

`VEC2`

`X Y``)`
`Constructs a 2D vector.`
• function `(`

`VEC2-P`

`OBJECT``)`
`Returns T if the argument is of type vec2.`
• function `(`

`VEC2-RANDOM`

`LOWER UPPER``)`
`Constructs a 2D vector with random values according to the given bounds.`
• function `(`

`VEC3`

`X Y Z``)`
`Constructs a 3D vector.`
• function `(`

`VEC3-P`

`OBJECT``)`
`Returns T if the argument is of type vec3.`
• function `(`

`VEC3-RANDOM`

`LOWER UPPER``)`
`Constructs a 3D vector with random values according to the given bounds.`
• function `(`

`VEC4`

`X Y Z W``)`
`Constructs a 3D vector.`
• function `(`

`VEC4-P`

`OBJECT``)`
`Returns T if the argument is of type vec4.`
• function `(`

`VEC4-RANDOM`

`LOWER UPPER``)`
`Constructs a 4D vector with random values according to the given bounds.`
• function `(`

`VINORM`

`V``)`
`Returns the maximum-norm of the vector.`
• function `(`

`VLENGTH`

`V``)`
`Returns the euclidean norm of the vector.`
• function `(`

`VLERP`

`FROM TO N``)`
`Returns a vector where each field is linearly interpolated from the corresponding field in FROM to TO by N. Accepts a REAL or VEC for N, where REALs are used for each component of the vector.`
• function `(`

`VLIMIT`

`VEC LIMIT``)`
`Returns a limited vector where each field is within [-LIMIT, LIMIT]. Accepts REALs or VEcs as arguments, where REALs are used for each component of the vector.`
• function `(`

`VMAX`

`VAL &REST VALS``)`
`Same as MAX, but testing all vector fields simultaneously.`
• function `(`

`VMIN`

`VAL &REST VALS``)`
`Same as MIN, but testing all vector fields simultaneously.`
• function `(`

`VMOD`

`VEC DIVISOR``)`
`Returns a vector with each component being the modulus of the given vector's against the divisor.`
• function `(`

`VORDER`

`V X &OPTIONAL Y Z W``)`
```Allows you to handily modify a vector by reordering its components.
Each X/Y/Z argument can be one of 'X,'Y,'Z,'VX,'VY,'VZ,:X,:Y,:Z indicating the respective component, or NIL for 0.```
• function `(`

`VPNORM`

`V P``)`
`Returns the p-norm of the vector.`
• function `(`

`VROT`

`V AXIS PHI``)`
```Returns a 3D vector rotated around AXIS by PHI rads. The axis has to be a unit vector.
This operation does not work with 2D or 4D vectors.```
• function `(`

`VROTV`

`A B``)`
```Returns a 3D vector of A rotated around each axis by the amount in B. The rotations are performed in the order of X, Y, Z.
Note that rotation in 3D space is not commutative, so this function might not perform the rotation as you expected if you need the rotation to happen in a different order.
This operation does not work with 2D or 4D vectors.

See VROT.```
• function `(`

`VSCALE`

`A LENGTH``)`
`Returns a scaled vector of the specified length.`
• function `(`

`VUNIT`

`A``)`
`Returns the unit vector form of the given vector by the 2-norm.`
• function `(`

`VW`

`VEC``)`
`Returns the W component of the vector.`
• function `(`

`VW4`

`VEC``)`
`Returns the W component of a 4D vector.`
• function `(`

`VX`

`VEC``)`
`Returns the X component of the vector.`
• function `(`

`VX2`

`VEC``)`
`Returns the X component of a 2D vector.`
• function `(`

`VX3`

`VEC``)`
`Returns the X component of a 3D vector.`
• function `(`

`VX4`

`VEC``)`
`Returns the X component of a 4D vector.`
• function `(`

`VY`

`VEC``)`
`Returns the Y component of the vector.`
• function `(`

`VY2`

`VEC``)`
`Returns the Y component of a 2D vector.`
• function `(`

`VY3`

`VEC``)`
`Returns the Y component of a 3D vector.`
• function `(`

`VY4`

`VEC``)`
`Returns the Y component of a 4D vector.`
• function `(`

`VZ`

`VEC``)`
`Returns the Z component of the vector.`
• function `(`

`VZ3`

`VEC``)`
`Returns the Z component of a 3D vector.`
• function `(`

`VZ4`

`VEC``)`
`Returns the Z component of a 4D vector.`
• macro `(`

`VAPPLY`

`VEC OP &OPTIONAL X Y Z W``)`
`Applies OP to each applicable field of the vector plus the optional argument for each respective dimension, if given. Returns a new vector of the same type with the results in its fields.`
• macro `(`

`VAPPLYF`

`VEC OP &OPTIONAL X Y Z W``)`
`Applies OP to each applicable field of the vector plus the optional argument for each respective dimension, if given. Returns the same vector with the results stored in its fields.`
• macro `(`

`VDECF`

`V &OPTIONAL (DELTA 1)``)`
`Decreases each field in the vector by DELTA.`
• macro `(`

`VINCF`

`V &OPTIONAL (DELTA 1)``)`
`Increases each field in the vector by DELTA.`
• macro `(`

`VSETF`

`VEC X Y &OPTIONAL Z W``)`
`Similar to SETF, but requires as many values as the given vector has fields. Returns the modified vector.`
• macro `(`

`WITH-VEC`

`(X Y &OPTIONAL (Z) (W)) VAL &BODY BODY``)`
```Binds each component of the vector (or real) to the specified variable.
If the vector does not have a particular field, the variable is initialized to 0 in the proper float format.```
• macro `(`

`WITH-VEC2`

`(X Y) VAL &BODY BODY``)`
`Binds each component of the vector (or real) to the specified variable.`
• macro `(`

`WITH-VEC3`

`(X Y Z) VAL &BODY BODY``)`
`Binds each component of the vector (or real) to the specified variable.`
• macro `(`

`WITH-VEC4`

`(X Y Z W) VAL &BODY BODY``)`
`Binds each component of the vector (or real) to the specified variable.`