Vector ops

[madmann91]

This branch introduces a simple set of operations on small vector types, in the spirit of GLSL.

The following types are introduced:

vec2[T]
vec3[T]
vec4[T]
mat2x2[T]
mat2x3[T]
mat2x4[T]
mat3x2[T]
mat3x3[T]
mat3x4[T]
mat4x2[T]
mat4x3[T]
mat4x4[T]

where T is a primitive type (e.g. f32, i32, i8, f16, ...), or a SIMD type (e.g. simd[f32 * 4]).

Vectors can be constructed with the following syntactic forms:

• vec2(x), vec3(x), vec4(x), which initializes all the components with the same value,
• vec2(x, y), vec3(x, y, z), vec4(x, y, z, w), which initializes the components one by one with the given values,
• A concatenation syntax, which is simply vecn(v1, v2, ...) where n is 1, 2, or 3 and v1, v2 are scalar or vectors. In this case, the vector is initialized by concatenating the values provided in the order they are given, as in GLSL. The total number of elements provided must be equal to the vector size.

Matrices can be constructed with the following syntax forms:

• mat2(x), mat3(x), vec4(x), which initializes the diagonal with the same value, and fill the rest with zeros,
• A column constructor form matn(v1, v2, ...), which takes exactly one vector per column; each vector must be of the same size as the number of rows in the matrix,
• A scalar constructor form matn(m00, m01, ...), which initializes each component one by one, in column major order.

The following operations are supported:

• +, -, / allowed only between two vectors or two matrices, the operation is per-component,
• * between two vectors, the operation is per-component; otherwise, the operator performs a matrix multiplication,
• % for integer vectors,
• inverse(m) for floating point square matrices,
• determinant(m) for floating point square matrices,
• dot(v, v) for vectors,
• cross(v, v) for vectors of dimension 3.
• Vector swizzle, with the operator . followed by a swizzling sequence of at most 4 symbols from the set: x, y, z, w.