Slang internal include file defining constructors and operators

for built-in data types.

1 files changed, 1654 insertions, 0 deletions

diff --git a/src/mesa/shader/slang_core.gc b/src/mesa/shader/slang_core.gc
new file mode 100755
index 0000000000..d8b795fb60
--- /dev/null
+++ b/src/mesa/shader/slang_core.gc
@@ -0,0 +1,1654 @@
+

+// 

+// This file defines nearly all constructors and operators for built-in data types, using

+// extended language syntax. In general, compiler treats constructors and operators as

+// ordinary functions with some exceptions. For example, the language does not allow

+// functions to be called in constant expressions - here the exception is made to allow it.

+// 

+// Each implementation provides its own version of this file. Each implementation can define

+// the required set of operators and constructors in its own fashion.

+// 

+// The extended language syntax is only present when compiling this file. It is implicitly

+// included at the very beginning of the compiled shader, so no built-in functions can be

+// used.

+// 

+// To communicate with the implementation, a special extended "__asm" keyword is used, followed

+// by an instruction name (any valid identifier), a destination variable identifier and a

+// a list of zero or more source variable identifiers. A variable identifier is a variable name

+// declared earlier in the code (as a function parameter, local or global variable).

+// An instruction name designates an instruction that must be exported by the implementation.

+// Each instruction receives data from destination and source variable identifiers and returns

+// data in the destination variable identifier.

+// 

+// It is up to the implementation how to define a particular operator or constructor. If it is

+// expected to being used rarely, it can be defined in terms of other operators and constructors,

+// for example:

+// 

+// ivec2 operator + (const ivec2 x, const ivec2 y) {

+//    return ivec2 (x[0] + y[0], x[1] + y[1]);

+// }

+// 

+// If a particular operator or constructor is expected to be used very often or is an atomic

+// operation (that is, an operation that cannot be expressed in terms of other operations or

+// would create a dependency cycle) it must be defined using one or more __asm constructs.

+// 

+// Each implementation must define constructors for all scalar types (bool, float, int).

+// There are 9 scalar-to-scalar constructors (including identity constructors). However,

+// since the language introduces special constructors (like matrix constructor with a single

+// scalar value), implementations must also implement these cases.

+// The compiler provides the following algorithm when resolving a constructor:

+// - try to find a constructor with a prototype matching ours,

+// - if no constructor is found and this is a scalar-to-scalar constructor, raise an error,

+// - if a constructor is found, execute it and return,

+// - count the size of the constructor parameter list - if it is less than the size of

+//   our constructor's type, raise an error,

+// - for each parameter in the list do a recursive constructor matching for appropriate

+//   scalar fields in the constructed variable,

+// 

+// Each implementation must also define a set of operators that deal with built-in data types.

+// There are four kinds of operators:

+// 1) Operators that are implemented only by the compiler: "()" (function call), "," (sequence)

+//    and "?:" (selection).

+// 2) Operators that are implemented by the compiler by expressing it in terms of other operators:

+//    - "." (field selection) - translated to subscript access,

+//    - "&&" (logical and) - translated to "<left_expr> ? <right_expr> : false",

+//    - "||" (logical or) - translated to "<left_expr> ? true : <right_expr>",

+// 3) Operators that can be defined by the implementation and if the required prototype is not

+//    found, standard behaviour is used:

+//    - "==", "!=", "=" (equality, assignment) - compare or assign matching fields one-by-one;

+//      note that at least operators for scalar data types must be defined by the implementation

+//      to get it work,

+// 4) All other operators not mentioned above. If no required prototype is found, an error is

+//    raised. An implementation must follow the language specification to provide all valid

+//    operator prototypes.

+// 

+

+// 

+// TODO:

+//   - do something with [] operator: leave it in compiler or move it here,

+//   - emulate bools and ints with floats (this should simplify target implementation),

+//   - are vec*mat and mat*vec definitions correct? is the list complete?

+// 

+

+// 

+// From Shader Spec, ver. 1.051

+// 

+

+// 

+// 5.4.1 Conversion and Scalar Constructors

+// 

+

+// 

+// When constructors are used to convert a float to an int, the fractional part of the

+// floating-point value is dropped.

+// 

+

+int constructor (const float _f) {

+    int _i;

+    __asm float_to_int _i, _f;

+    return _i;

+}

+

+// 

+// When a constructor is used to convert an int or a float to bool, 0 and 0.0 are converted to

+// false, and nonzero values are converted to true.

+// 

+

+bool constructor (const int _i) {

+    return _i != 0;

+}

+

+bool constructor (const float _f) {

+    return _f != 0.0;

+}

+

+// 

+// When a constructor is used to convert a bool to an int or float, false is converted to 0 or

+// 0.0, and true is converted to 1 or 1.0.

+// 

+

+int constructor (const bool _b) {

+    return _b ? 1 : 0;

+}

+

+float constructor (const bool _b) {

+    return _b ? 1.0 : 0.0;

+}

+

+// 

+// Int to float constructor.

+// 

+

+float constructor (const int _i) {

+    float _f;

+    __asm int_to_float _f, _i;

+    return _f;

+}

+

+// 

+// Identity constructors, like float(float) are also legal, but of little use.

+// 

+

+bool constructor (const bool _b) {

+    return _b;

+}

+

+int constructor (const int _i) {

+    return _i;

+}

+

+float constructor (const float _f) {

+    return _f;

+}

+

+// 

+// Scalar constructors with non-scalar parameters can be used to take the first element from

+// a non-scalar. For example, the constructor float(vec3) will select the first component of the

+// vec3 parameter.

+// 

+

+// [These scalar conversions will be handled internally by the compiler.]

+

+// 

+// 5.4.2 Vector and Matrix Constructors

+// 

+// Constructors can be used to create vectors or matrices from a set of scalars, vectors,

+// or matrices. This includes the ability to shorten vectors or matrices.

+// 

+

+// 

+// If there is a single scalar parameter to a vector constructor, it is used to initialize all

+// components of the constructed vector to that scalar’s value.

+// 

+// If the basic type (bool, int, or float) of a parameter to a constructor does not match the basic

+// type of the object being constructed, the scalar construction rules (above) are used to convert

+// the parameters.

+// 

+

+vec2 constructor (const float _f) {

+    return vec2 (_f, _f);

+}

+

+vec2 constructor (const int _i) {

+    return vec2 (_i, _i);

+}

+

+vec2 constructor (const bool _b) {

+    return vec2 (_b, _b);

+}

+

+vec3 constructor (const float _f) {

+    return vec3 (_f, _f, _f);

+}

+

+vec3 constructor (const int _i) {

+    return vec3 (_i, _i, _i);

+}

+

+vec3 constructor (const bool _b) {

+    return vec3 (_b, _b, _b);

+}

+

+vec4 constructor (const float _f) {

+    return vec4 (_f, _f, _f, _f);

+}

+

+vec4 constructor (const int _i) {

+    return vec4 (_i, _i, _i, _i);

+}

+

+vec4 constructor (const bool _b) {

+    return vec4 (_b, _b, _b, _b);

+}

+

+ivec2 constructor (const int _i) {

+    return ivec2 (_i, _i);

+}

+

+ivec2 constructor (const float _f) {

+    return ivec2 (_f, _f);

+}

+

+ivec2 constructor (const bool _b) {

+    return ivec2 (_b, _b);

+}

+

+ivec3 constructor (const int _i) {

+    return ivec3 (_i, _i, _i);

+}

+

+ivec3 constructor (const float _f) {

+    return ivec3 (_f, _f, _f);

+}

+

+ivec3 constructor (const bool _b) {

+    return ivec3 (_b, _b, _b);

+}

+

+ivec4 constructor (const int _i) {

+    return ivec4 (_i, _i, _i, _i);

+}

+

+ivec4 constructor (const float _f) {

+    return ivec4 (_f, _f, _f, _f);

+}

+

+ivec4 constructor (const bool _b) {

+    return ivec4 (_b, _b, _b, _b);

+}

+

+bvec2 constructor (const bool _b) {

+    return bvec2 (_b, _b);

+}

+

+bvec2 constructor (const float _f) {

+    return bvec2 (_f, _f);

+}

+

+bvec2 constructor (const int _i) {

+    return bvec2 (_i, _i);

+}

+

+bvec3 constructor (const bool _b) {

+    return bvec3 (_b, _b, _b);

+}

+

+bvec3 constructor (const float _f) {

+    return bvec3 (_f, _f, _f);

+}

+

+bvec3 constructor (const int _i) {

+    return bvec3 (_i, _i, _i);

+}

+

+bvec4 constructor (const bool _b) {

+    return bvec4 (_b, _b, _b, _b);

+}

+

+bvec4 constructor (const float _f) {

+    return bvec4 (_f, _f, _f, _f);

+}

+

+bvec4 constructor (const int _i) {

+    return bvec4 (_i, _i, _i, _i);

+}

+

+// 

+// If there is a single scalar parameter to a matrix constructor, it is used to initialize all the

+// components on the matrix’s diagonal, with the remaining components initialized to 0.0.

+// (...) Matrices will be constructed in column major order.

+// 

+// If the basic type (bool, int, or float) of a parameter to a constructor does not match the basic

+// type of the object being constructed, the scalar construction rules (above) are used to convert

+// the parameters.

+// 

+

+mat2 constructor (const float _f) {

+    return mat2 (

+        _f, .0,

+        .0, _f

+    );

+}

+

+mat2 constructor (const int _i) {

+    return mat2 (

+        _i, .0,

+        .0, _i

+    );

+}

+

+mat2 constructor (const bool _b) {

+    return mat2 (

+        _b, .0,

+        .0, _b

+    );

+}

+

+mat3 constructor (const float _f) {

+    return mat3 (

+        _f, .0, .0,

+        .0, _f, .0,

+        .0, .0, _f

+    );

+}

+

+mat3 constructor (const int _i) {

+    return mat3 (

+        _i, .0, .0,

+        .0, _i, .0,

+        .0, .0, _i

+    );

+}

+

+mat3 constructor (const bool _b) {

+    return mat3 (

+        _b, .0, .0,

+        .0, _b, .0,

+        .0, .0, _b

+    );

+}

+

+mat4 constructor (const float _f) {

+    return mat4 (

+        _f, .0, .0, .0,

+        .0, _f, .0, .0,

+        .0, .0, _f, .0,

+        .0, .0, .0, _f

+    );

+}

+

+mat4 constructor (const int _i) {

+    return mat4 (

+        _i, .0, .0, .0,

+        .0, _i, .0, .0,

+        .0, .0, _i, .0,

+        .0, .0, .0, _i

+    );

+}

+

+mat4 constructor (const bool _b) {

+    return mat4 (

+        _b, .0, .0, .0,

+        .0, _b, .0, .0,

+        .0, .0, _b, .0,

+        .0, .0, .0, _b

+    );

+}

+

+// 

+// 5.8 Assignments

+// 

+// Assignments of values to variable names are done with the assignment operator ( = ), like

+// 

+//   lvalue = expression

+// 

+// The assignment operator stores the value of expression into lvalue. It will compile only if

+// expression and lvalue have the same type. All desired type-conversions must be specified

+// explicitly via a constructor. Lvalues must be writable. Variables that are built-in types,

+// entire structures, structure fields, l-values with the field selector ( . ) applied to select

+// components or swizzles without repeated fields, and l-values dereferenced with the array

+// subscript operator ( [ ] ) are all possible l-values. Other binary or unary expressions,

+// non-dereferenced arrays, function names, swizzles with repeated fields, and constants cannot

+// be l-values.

+// 

+// Expressions on the left of an assignment are evaluated before expressions on the right of the

+// assignment.

+// 

+

+void operator = (inout float a, const float b) {

+	__asm float_copy a, b;

+}

+

+void operator = (inout int a, const int b) {

+	__asm int_copy a, b;

+}

+

+void operator = (inout bool a, const bool b) {

+	__asm bool_copy a, b;

+}

+

+void operator = (inout vec2 v, const vec2 u) {

+	v.x = u.x, v.y = u.y;

+}

+

+void operator = (inout vec3 v, const vec3 u) {

+	v.x = u.x, v.y = u.y, v.z = u.z;

+}

+

+void operator = (inout vec4 v, const vec4 u) {

+	v.x = u.x, v.y = u.y, v.z = u.z, v.w = u.w;

+}

+

+void operator = (inout ivec2 v, const ivec2 u) {

+	v.x = u.x, v.y = u.y;

+}

+

+void operator = (inout ivec3 v, const ivec3 u) {

+	v.x = u.x, v.y = u.y, v.z = u.z;

+}

+

+void operator = (inout ivec4 v, const ivec4 u) {

+	v.x = u.x, v.y = u.y, v.z = u.z, v.w = u.w;

+}

+

+void operator = (inout bvec2 v, const bvec2 u) {

+	v.x = u.x, v.y = u.y;

+}

+

+void operator = (inout bvec3 v, const bvec3 u) {

+	v.x = u.x, v.y = u.y, v.z = u.z;

+}

+

+void operator = (inout bvec4 v, const bvec4 u) {

+	v.x = u.x, v.y = u.y, v.z = u.z, v.w = u.w;

+}

+

+void operator = (inout mat2 m, const mat2 n) {

+	m[0] = n[0], m[1] = n[1];

+}

+

+void operator = (inout mat3 m, const mat3 n) {

+	m[0] = n[0], m[1] = n[1], m[2] = n[2];

+}

+

+void operator = (inout mat4 m, const mat4 n) {

+	m[0] = n[0], m[1] = n[1], m[2] = n[2], m[3] = n[3];

+}

+

+// 

+// • The arithmetic assignments add into (+=), subtract from (-=), multiply into (*=), and divide

+//   into (/=). The variable and expression must be the same floating-point or integer type, ...

+// 

+

+void operator += (inout float a, const float b) {

+    __asm float_add a, b;

+}

+

+void operator -= (inout float a, const float b) {

+    a += -b;

+}

+

+void operator *= (inout float a, const float b) {

+    __asm float_multiply a, b;

+}

+

+void operator /= (inout float a, const float b) {

+    __asm float_divide a, b;

+}

+

+void operator += (inout int x, const int y) {

+    __asm int_add x, y;

+}

+

+void operator -= (inout int x, const int y) {

+    x += -y;

+}

+

+void operator *= (inout int x, const int y) {

+    __asm int_multiply x, y;

+}

+

+void operator /= (inout int x, const int y) {

+    __asm int_divide x, y;

+}

+

+void operator += (inout vec2 v, const vec2 u) {

+    v.x += u.x, v.y += u.y;

+}

+

+void operator -= (inout vec2 v, const vec2 u) {

+    v.x -= u.x, v.y -= u.y;

+}

+

+void operator *= (inout vec2 v, const vec2 u) {

+    v.x *= u.x, v.y *= u.y;

+}

+

+void operator /= (inout vec2 v, const vec2 u) {

+    v.x /= u.x, v.y /= u.y;

+}

+

+void operator += (inout vec3 v, const vec3 u) {

+    v.x += u.x, v.y += u.y, v.z += u.z;

+}

+

+void operator -= (inout vec3 v, const vec3 u) {

+    v.x -= u.x, v.y -= u.y, v.z -= u.z;

+}

+

+void operator *= (inout vec3 v, const vec3 u) {

+    v.x *= u.x, v.y *= u.y, v.z *= u.z;

+}

+

+void operator /= (inout vec3 v, const vec3 u) {

+    v.x /= u.x, v.y /= u.y, v.z /= u.z;

+}

+

+void operator += (inout vec4 v, const vec4 u) {

+    v.x += u.x, v.y += u.y, v.z += u.z, v.w += u.w;

+}

+

+void operator -= (inout vec4 v, const vec4 u) {

+    v.x -= u.x, v.y -= u.y, v.z -= u.z, v.w -= u.w;

+}

+

+void operator *= (inout vec4 v, const vec4 u) {

+    v.x *= u.x, v.y *= u.y, v.z *= u.z, v.w *= u.w;

+}

+

+void operator /= (inout vec4 v, const vec4 u) {

+    v.x /= u.x, v.y /= u.y, v.z /= u.z, v.w /= u.w;

+}

+

+void operator += (inout ivec2 v, const ivec2 u) {

+    v.x += u.x, v.y += u.y;

+}

+

+void operator -= (inout ivec2 v, const ivec2 u) {

+    v.x -= u.x, v.y -= u.y;

+}

+

+void operator *= (inout ivec2 v, const ivec2 u) {

+    v.x *= u.x, v.y *= u.y;

+}

+

+void operator /= (inout ivec2 v, const ivec2 u) {

+    v.x /= u.x, v.y /= u.y;

+}

+

+void operator += (inout ivec3 v, const ivec3 u) {

+    v.x += u.x, v.y += u.y, v.z += u.z;

+}

+

+void operator -= (inout ivec3 v, const ivec3 u) {

+    v.x -= u.x, v.y -= u.y, v.z -= u.z;

+}

+

+void operator *= (inout ivec3 v, const ivec3 u) {

+    v.x *= u.x, v.y *= u.y, v.z *= u.z;

+}

+

+void operator /= (inout ivec3 v, const ivec3 u) {

+    v.x /= u.x, v.y /= u.y, v.z /= u.z;

+}

+

+void operator += (inout ivec4 v, const ivec4 u) {

+    v.x += u.x, v.y += u.y, v.z += u.z, v.w += u.w;

+}

+

+void operator -= (inout ivec4 v, const ivec4 u) {

+    v.x -= u.x, v.y -= u.y, v.z -= u.z, v.w -= u.w;

+}

+

+void operator *= (inout ivec4 v, const ivec4 u) {

+    v.x *= u.x, v.y *= u.y, v.z *= u.z, v.w *= u.w;

+}

+

+void operator /= (inout ivec4 v, const ivec4 u) {

+    v.x /= u.x, v.y /= u.y, v.z /= u.z, v.w /= u.w;

+}

+

+void operator += (inout mat2 m, const mat2 n) {

+    m[0] += n[0], m[1] += n[1];

+}

+

+void operator -= (inout mat2 v, const mat2 n) {

+    m[0] -= n[0], m[1] -= n[1];

+}

+

+void operator *= (inout mat2 m, const mat2 n) {

+    m = m * n;

+}

+

+void operator /= (inout mat2 m, const mat2 n) {

+    m[0] /= n[0], m[1] /= n[1];

+}

+

+void operator += (inout mat3 m, const mat3 n) {

+    m[0] += n[0], m[1] += n[1], m[2] += n[2];

+}

+

+void operator -= (inout mat3 m, const mat3 n) {

+    m[0] -= n[0], m[1] -= n[1], m[2] -= n[2];

+}

+

+void operator *= (inout mat3 m, const mat3 n) {

+    m = m * n;

+}

+

+void operator /= (inout mat3 m, const mat3 n) {

+    m[0] /= n[0], m[1] /= n[1], m[2] /= n[2];

+}

+

+void operator += (inout mat4 m, const mat4 n) {

+    m[0] += n[0], m[1] += n[1], m[2] += n[2], m[3] += n[3];

+}

+

+void operator -= (inout mat4 m, const mat4 n) {

+    m[0] -= n[0], m[1] -= n[1], m[2] -= n[2], m[3] -= n[3];

+}

+

+void operator *= (inout mat4 m, const mat4 n) {

+    m = m * n;

+}

+

+void operator /= (inout mat4 m, const mat4 n) {

+    m[0] /= n[0], m[1] /= n[1], m[2] /= n[2], m[3] /= n[3];

+}

+

+// 

+//   ... or if the expression is a float, then the variable can be floating-point, a vector, or

+//   a matrix, ...

+// 

+

+void operator += (inout vec2 v, const float a) {

+    v.x += a, v.y += a;

+}

+

+void operator -= (inout vec2 v, const float a) {

+    v.x -= a, v.y -= a;

+}

+

+void operator *= (inout vec2 v, const float a) {

+    v.x *= a, v.y *= a;

+}

+

+void operator /= (inout vec2 v, const float a) {

+    v.x /= a, v.y /= a;

+}

+

+void operator += (inout vec3 v, const float a) {

+    v.x += a, v.y += a, v.z += a;

+}

+

+void operator -= (inout vec3 v, const float a) {

+    v.x -= a, v.y -= a, v.z -= a;

+}

+

+void operator *= (inout vec3 v, const float a) {

+    v.x *= a, v.y *= a, v.z *= a;

+}

+

+void operator /= (inout vec3 v, const float a) {

+    v.x /= a, v.y /= a, v.z /= a;

+}

+

+void operator += (inout vec4 v, const float a) {

+    v.x += a, v.y += a, v.z += a, v.w += a;

+}

+

+void operator -= (inout vec4 v, const float a) {

+    v.x -= a, v.y -= a, v.z -= a, v.w -= a;

+}

+

+void operator *= (inout vec4 v, const float a) {

+    v.x *= a, v.y *= a, v.z *= a, v.w *= a;

+}

+

+void operator /= (inout vec4 v, const float a) {

+    v.x /= a, v.y /= a, v.z /= a, v.w /= a;

+}

+

+void operator += (inout mat2 m, const float a) {

+    m[0] += a, m[1] += a;

+}

+

+void operator -= (inout mat2 m, const float a) {

+    m[0] -= a, m[1] -= a;

+}

+

+void operator *= (inout mat2 m, const float a) {

+    m[0] *= a, m[1] *= a;

+}

+

+void operator /= (inout mat2 m, const float a) {

+    m[0] /= a, m[1] /= a;

+}

+

+void operator += (inout mat3 m, const float a) {

+    m[0] += a, m[1] += a, m[2] += a;

+}

+

+void operator -= (inout mat3 m, const float a) {

+    m[0] -= a, m[1] -= a, m[2] -= a;

+}

+

+void operator *= (inout mat3 m, const float a) {

+    m[0] *= a, m[1] *= a, m[2] *= a;

+}

+

+void operator /= (inout mat3 m, const float a) {

+    m[0] /= a, m[1] /= a, m[2] /= a;

+}

+

+void operator += (inout mat4 m, const float a) {

+    m[0] += a, m[1] += a, m[2] += a, m[3] += a;

+}

+

+void operator -= (inout mat4 m, const float a) {

+    m[0] -= a, m[1] -= a, m[2] -= a, m[3] -= a;

+}

+

+void operator *= (inout mat4 m, const float a) {

+    m[0] *= a, m[1] *= a, m[2] *= a, m[3] *= a;

+}

+

+void operator /= (inout mat4 m, const float a) {

+    m[0] /= a, m[1] /= a, m[2] /= a, m[3] /= a;

+}

+

+// 

+//   ... or if the operation is multiply into (*=), then the variable can be a vector and the

+//   expression can be a matrix of matching size.

+// 

+

+void operator *= (inout vec2 v, const mat2 m) {

+    v = v * m;

+}

+

+void operator *= (inout vec3 v, const mat3 m) {

+    v = v * m;

+}

+

+void operator *= (inout vec4 v, const mat4 m) {

+    v = v * m;

+}

+

+// 

+// 5.9 Expressions

+// 

+// Expressions in the shading language include the following:

+// 

+

+// 

+// • The arithmetic binary operators add (+), subtract (-), multiply (*), and divide (/), that

+//   operate on integer and floating-point typed expressions (including vectors and matrices).

+//   The two operands must be the same type, ...

+// 

+

+float operator + (const float a, const float b) {

+    float c = a;

+    return c += b;

+}

+

+float operator - (const float a, const float b) {

+    return a + -b;

+}

+

+float operator * (const float a, const float b) {

+    float c = a;

+    return c *= b;

+}

+

+float operator / (const float a, const float b) {

+    float c = a;

+    return c /= b;

+}

+

+int operator + (const int a, const int b) {

+    int c = a;

+    return c += b;

+}

+

+int operator - (const int x, const int y) {

+    return x + -y;

+}

+

+int operator * (const int x, const int y) {

+    int z = x;

+    return z *= y;

+}

+

+int operator / (const int x, const int y) {

+    int z = x;

+    return z /= y;

+}

+

+vec2 operator + (const vec2 v, const vec2 u) {

+    return vec2 (v.x + u.x, v.y + u.y);

+}

+

+vec2 operator - (const vec2 v, const vec2 u) {

+    return vec2 (v.x - u.x, v.y - u.y);

+}

+

+vec3 operator + (const vec3 v, const vec3 u) {

+    return vec3 (v.x + u.x, v.y + u.y, v.z + u.z);

+}

+

+vec3 operator - (const vec3 v, const vec3 u) {

+    return vec3 (v.x - u.x, v.y - u.y, v.z - u.z);

+}

+

+vec4 operator + (const vec4 v, const vec4 u) {

+    return vec4 (v.x + u.x, v.y + u.y, v.z + u.z, v.w + u.w);

+}

+

+vec4 operator - (const vec4 v, const vec4 u) {

+    return vec4 (v.x - u.x, v.y - u.y, v.z - u.z, v.w - u.w);

+}

+

+ivec2 operator + (const ivec2 v, const ivec2 u) {

+    return ivec2 (v.x + u.x, v.y + u.y);

+}

+

+ivec2 operator - (const ivec2 v, const ivec2 u) {

+    return ivec2 (v.x - u.x, v.y - u.y);

+}

+

+ivec3 operator + (const ivec3 v, const ivec3 u) {

+    return ivec3 (v.x + u.x, v.y + u.y, v.z + u.z);

+}

+

+ivec3 operator - (const ivec3 v, const ivec3 u) {

+    return ivec3 (v.x - u.x, v.y - u.y, v.z - u.z);

+}

+

+ivec4 operator + (const ivec4 v, const ivec4 u) {

+    return ivec4 (v.x + u.x, v.y + u.y, v.z + u.z, v.w + u.w);

+}

+

+ivec4 operator - (const ivec4 v, const ivec4 u) {

+    return ivec4 (v.x - u.x, v.y - u.y, v.z - u.z, v.w - u.w);

+}

+

+mat2 operator + (const mat2 m, const mat2 n) {

+    return mat2 (m[0] + n[0], m[1] + n[1]);

+}

+

+mat2 operator - (const mat2 m, const mat2 n) {

+    return mat2 (m[0] - n[0], m[1] - n[1]);

+}

+

+mat3 operator + (const mat3 m, const mat3 n) {

+    return mat3 (m[0] + n[0], m[1] + n[1], m[2] + n[2]);

+}

+

+mat3 operator - (const mat3 m, const mat3 n) {

+    return mat3 (m[0] - n[0], m[1] - n[1], m[2] - n[2]);

+}

+

+mat4 operator + (const mat4 m, const mat4 n) {

+    return mat4 (m[0] + n[0], m[1] + n[1], m[2] + n[2], m[3] + n[3]);

+}

+

+mat4 operator - (const mat4 m, const mat4 n) {

+    return mat4 (m[0] - n[0], m[1] - n[1], m[2] - n[2], m[3] - n[3]);

+}

+

+// 

+//   ... or one must be a scalar float and the other a vector or matrix, ...

+// 

+

+vec2 operator + (const float a, const vec2 u) {

+    return vec2 (a + u.x, a + u.y);

+}

+

+vec2 operator + (const vec2 v, const float b) {

+    return vec2 (v.x + b, v.y + b);

+}

+

+vec2 operator - (const float a, const vec2 u) {

+    return vec2 (a - u.x, a - u.y);

+}

+

+vec2 operator - (const vec2 v, const float b) {

+    return vec2 (v.x - b, v.y - b);

+}

+

+vec2 operator * (const float a, const vec2 u) {

+    return vec2 (a * u.x, a * u.y);

+}

+

+vec2 operator * (const vec2 v, const float b) {

+    return vec2 (v.x * b, v.y * b);

+}

+

+vec2 operator / (const float a, const vec2 u) {

+    return vec2 (a / u.x, a / u.y);

+}

+

+vec2 operator / (const vec2 v, const float b) {

+    return vec2 (v.x / b, v.y / b);

+}

+

+vec3 operator + (const float a, const vec3 u) {

+    return vec3 (a + u.x, a + u.y, a + u.z);

+}

+

+vec3 operator + (const vec3 v, const float b) {

+    return vec3 (v.x + b, v.y + b, v.z + b);

+}

+

+vec3 operator - (const float a, const vec3 u) {

+    return vec3 (a - u.x, a - u.y, a - u.z);

+}

+

+vec3 operator - (const vec3 v, const float b) {

+    return vec3 (v.x - b, v.y - b, v.z - b);

+}

+

+vec3 operator * (const float a, const vec3 u) {

+    return vec3 (a * u.x, a * u.y, a * u.z);

+}

+

+vec3 operator * (const vec3 v, const float b) {

+    return vec3 (v.x * b, v.y * b, v.z * b);

+}

+

+vec3 operator / (const float a, const vec3 u) {

+    return vec3 (a / u.x, a / u.y, a / u.z);

+}

+

+vec3 operator / (const vec3 v, const float b) {

+    return vec3 (v.x / b, v.y / b, v.z / b);

+}

+

+vec4 operator + (const float a, const vec4 u) {

+    return vec4 (a + u.x, a + u.y, a + u.z, a + u.w);

+}

+

+vec4 operator + (const vec4 v, const float b) {

+    return vec4 (v.x + b, v.y + b, v.z + b, v.w + b);

+}

+

+vec4 operator - (const float a, const vec4 u) {

+    return vec4 (a - u.x, a - u.y, a - u.z, a - u.w);

+}

+

+vec4 operator - (const vec4 v, const float b) {

+    return vec4 (v.x - b, v.y - b, v.z - b, v.w - b);

+}

+

+vec4 operator * (const float a, const vec4 u) {

+    return vec4 (a * u.x, a * u.y, a * u.z, a * u.w);

+}

+

+vec4 operator * (const vec4 v, const float b) {

+    return vec4 (v.x * b, v.y * b, v.z * b, v.w * b);

+}

+

+vec4 operator / (const float a, const vec4 u) {

+    return vec4 (a / u.x, a / u.y, a / u.z, a / u.w);

+}

+

+vec4 operator / (const vec4 v, const float b) {

+    return vec4 (v.x / b, v.y / b, v.z / b, v.w / b);

+}

+

+mat2 operator + (const float a, const mat2 n) {

+    return mat2 (a + n[0], a + n[1]);

+}

+

+mat2 operator + (const mat2 m, const float b) {

+    return mat2 (m[0] + b, m[1] + b);

+}

+

+mat2 operator - (const float a, const mat2 n) {

+    return mat2 (a - n[0], a - n[1]);

+}

+

+mat2 operator - (const mat2 m, const float b) {

+    return mat2 (m[0] - b, m[1] - b);

+}

+

+mat2 operator * (const float a, const mat2 n) {

+    return mat2 (a * n[0], a * n[1]);

+}

+

+mat2 operator * (const mat2 m, const float b) {

+    return mat2 (m[0] * b, m[1] * b);

+}

+

+mat2 operator / (const float a, const mat2 n) {

+    return mat2 (a / n[0], a / n[1]);

+}

+

+mat2 operator / (const mat2 m, const float b) {

+    return mat2 (m[0] / b, m[1] / b);

+}

+

+mat3 operator + (const float a, const mat3 n) {

+    return mat3 (a + n[0], a + n[1], a + n[2]);

+}

+

+mat3 operator + (const mat3 m, const float b) {

+    return mat3 (m[0] + b, m[1] + b, m[2] + b);

+}

+

+mat3 operator - (const float a, const mat3 n) {

+    return mat3 (a - n[0], a - n[1], a - n[2]);

+}

+

+mat3 operator - (const mat3 m, const float b) {

+    return mat3 (m[0] - b, m[1] - b, m[2] - b);

+}

+

+mat3 operator * (const float a, const mat3 n) {

+    return mat3 (a * n[0], a * n[1], a * n[2]);

+}

+

+mat3 operator * (const mat3 m, const float b) {

+    return mat3 (m[0] * b, m[1] * b, m[2] * b);

+}

+

+mat3 operator / (const float a, const mat3 n) {

+    return mat3 (a / n[0], a / n[1], a / n[2]);

+}

+

+mat3 operator / (const mat3 m, const float b) {

+    return mat3 (m[0] / b, m[1] / b, m[2] / b);

+}

+

+mat4 operator + (const float a, const mat4 n) {

+    return mat4 (a + n[0], a + n[1], a + n[2], a + n[3]);

+}

+

+mat4 operator + (const mat4 m, const float b) {

+    return mat4 (m[0] + b, m[1] + b, m[2] + b, m[3] + b);

+}

+

+mat4 operator - (const float a, const mat4 n) {

+    return mat4 (a - n[0], a - n[1], a - n[2], a - n[3]);

+}

+

+mat4 operator - (const mat4 m, const float b) {

+    return mat4 (m[0] - b, m[1] - b, m[2] - b, m[3] - b);

+}

+

+mat4 operator * (const float a, const mat4 n) {

+    return mat4 (a * n[0], a * n[1], a * n[2], a * n[3]);

+}

+

+mat4 operator * (const mat4 m, const float b) {

+    return mat4 (m[0] * b, m[1] * b, m[2] * b, m[3] * b);

+}

+

+mat4 operator / (const float a, const mat4 n) {

+    return mat4 (a / n[0], a / n[1], a / n[2], a / n[3]);

+}

+

+mat4 operator / (const mat4 m, const float b) {

+    return mat4 (m[0] / b, m[1] / b, m[2] / b, m[3] / b);

+}

+

+// 

+//   ... or for multiply (*) one can be a vector and the other a matrix with the same dimensional

+//   size of the vector.

+// 

+// [When:]

+// • the left argument is a floating-point vector and the right is a matrix with a compatible

+//   dimension in which case the * operator will do a row vector matrix multiplication.

+// • the left argument is a matrix and the right is a floating-point vector with a compatible

+//   dimension in which case the * operator will do a column vector matrix multiplication.

+// 

+

+vec2 operator * (const mat2 m, const vec2 v) {

+    return vec2 (

+        v.x * m[0].x + v.y * m[1].x,

+        v.x * m[0].y + v.y * m[1].y

+    );

+}

+

+vec2 operator * (const vec2 v, const mat2 m) {

+    return vec2 (

+        v.x * m[0].x + v.y * m[0].y,

+        v.x * m[1].x + v.y * m[1].y

+    );

+}

+

+vec3 operator * (const mat3 m, const vec3 v) {

+    return vec3 (

+        v.x * m[0].x + v.y * m[1].x + v.z * m[2].x,

+        v.x * m[0].y + v.y * m[1].y + v.z * m[2].y,

+        v.x * m[0].z + v.y * m[1].z + v.z * m[2].z

+    );

+}

+

+vec3 operator * (const vec3 v, const mat3 m) {

+    return vec3 (

+        v.x * m[0].x + v.y * m[0].y + v.z * m[0].z,

+        v.x * m[1].x + v.y * m[1].y + v.z * m[1].z,

+        v.x * m[2].x + v.y * m[2].y + v.z * m[2].z

+    );

+}

+

+vec4 operator * (const mat4 m, const vec4 v) {

+    return vec4 (

+        v.x * m[0].x + v.y * m[1].x + v.z * m[2].x + v.w * m[3].x,

+        v.x * m[0].y + v.y * m[1].y + v.z * m[2].y + v.w * m[3].y,

+        v.x * m[0].z + v.y * m[1].z + v.z * m[2].z + v.w * m[3].z,

+        v.x * m[0].w + v.y * m[1].w + v.z * m[2].w + v.w * m[3].w

+    );

+}

+

+vec4 operator * (const vec4 v, const mat4 m) {

+    return vec4 (

+        v.x * m[0].x + v.y * m[0].y + v.z * m[0].z + v.w * m[0].w,

+        v.x * m[1].x + v.y * m[1].y + v.z * m[1].z + v.w * m[1].w,

+        v.x * m[2].x + v.y * m[2].y + v.z * m[2].z + v.w * m[2].w,

+        v.x * m[3].x + v.y * m[3].y + v.z * m[3].z + v.w * m[3].w

+    );

+}

+

+// 

+//   Multiply (*) applied to two vectors yields a component-wise multiply.

+// 

+

+vec2 operator * (const vec2 v, const vec2 u) {

+    return vec2 (v.x * u.x, v.y * u.y);

+}

+

+vec3 operator * (const vec3 v, const vec3 u) {

+    return vec3 (v.x * u.x, v.y * u.y, v.z * u.z);

+}

+

+vec4 operator * (const vec4 v, const vec4 u) {

+    return vec4 (v.x * u.x, v.y * u.y, v.z * u.z, v.w * u.w);

+}

+

+ivec2 operator * (const ivec2 v, const ivec2 u) {

+    return ivec2 (v.x * u.x, v.y * u.y);

+}

+

+ivec3 operator * (const ivec3 v, const ivec3 u) {

+    return ivec3 (v.x * u.x, v.y * u.y, v.z * u.z);

+}

+

+ivec4 operator * (const ivec4 v, const ivec4 u) {

+    return ivec4 (v.x * u.x, v.y * u.y, v.z * u.z, v.w * u.w);

+}

+

+// 

+//   Dividing by zero does not cause an exception but does result in an unspecified value.

+// 

+

+vec2 operator / (const vec2 v, const vec2 u) {

+    return vec2 (v.x / u.x, v.y / u.y);

+}

+

+vec3 operator / (const vec3 v, const vec3 u) {

+    return vec3 (v.x / u.x, v.y / u.y, v.z / u.z);

+}

+

+vec4 operator / (const vec4 v, const vec4 u) {

+    return vec4 (v.x / u.x, v.y / u.y, v.z / u.z, v.w / u.w);

+}

+

+ivec2 operator / (const ivec2 v, const ivec2 u) {

+    return ivec2 (v.x / u.x, v.y / u.y);

+}

+

+ivec3 operator / (const ivec3 v, const ivec3 u) {

+    return ivec3 (v.x / u.x, v.y / u.y, v.z / u.z);

+}

+

+ivec4 operator / (const ivec4 v, const ivec4 u) {

+    return ivec4 (v.x / u.x, v.y / u.y, v.z / u.z, v.w / u.w);

+}

+

+mat2 operator / (const mat2 m, const mat2 n) {

+    return mat2 (m[0] / n[0], m[1] / n[1]);

+}

+

+mat3 operator / (const mat3 m, const mat3 n) {

+    return mat3 (m[0] / n[0], m[1] / n[1], m[2] / n[2]);

+}

+

+mat4 operator / (const mat4 m, const mat4 n) {

+    return mat4 (m[0] / n[0], m[1] / n[1], m[2] / n[2], m[3] / n[3]);

+}

+

+// 

+//   Multiply (*) applied to two matrices yields a linear algebraic matrix multiply, not

+//   a component-wise multiply.

+// 

+

+mat2 operator * (const mat2 m, const mat2 n) {

+    return mat2 (m * n[0], m * n[1]);

+}

+

+mat3 operator * (const mat3 m, const mat3 n) {

+    return mat3 (m * n[0], m * n[1], m * n[2]);

+}

+

+mat4 operator * (const mat4 m, const mat4 n) {

+    return mat4 (m * n[0], m * n[1], m * n[2], m * n[3]);

+}

+

+// 

+// • The arithmetic unary operators negate (-), post- and pre-increment and decrement (-- and

+//   ++) that operate on integer or floating-point values (including vectors and matrices). These

+//   result with the same type they operated on. For post- and pre-increment and decrement, the

+//   expression must be one that could be assigned to (an l-value). Pre-increment and predecrement

+//   add or subtract 1 or 1.0 to the contents of the expression they operate on, and the

+//   value of the pre-increment or pre-decrement expression is the resulting value of that

+//   modification. Post-increment and post-decrement expressions add or subtract 1 or 1.0 to

+//   the contents of the expression they operate on, but the resulting expression has the

+//   expression’s value before the post-increment or post-decrement was executed.

+// 

+// [NOTE: postfix increment and decrement operators take additional dummy int parameter to

+//        distinguish their prototypes from prefix ones.]

+// 

+

+float operator - (const float a) {

+    float c = a;

+    __asm float_negate c;

+    return c;

+}

+

+int operator - (const int a) {

+    int c = a;

+    __asm int_negate c;

+    return c;

+}

+

+vec2 operator - (const vec2 v) {

+    return vec2 (-v.x, -v.y);

+}

+

+vec3 operator - (const vec3 v) {

+    return vec3 (-v.x, -v.y, -v.z);

+}

+

+vec4 operator - (const vec4 v) {

+    return vec4 (-v.x, -v.y, -v.z, -v.w);

+}

+

+ivec2 operator - (const ivec2 v) {

+    return ivec2 (-v.x, -v.y);

+}

+

+ivec3 operator - (const ivec3 v) {

+    return ivec3 (-v.x, -v.y, -v.z);

+}

+

+ivec4 operator - (const ivec4 v) {

+    return ivec4 (-v.x, -v.y, -v.z, -v.w);

+}

+

+mat2 operator - (const mat2 m) {

+    return mat2 (-m[0], -m[1]);

+}

+

+mat3 operator - (const mat3 m) {

+    return mat3 (-m[0], -m[1], -m[2]);

+}

+

+mat4 operator - (const mat4 m) {

+    return mat4 (-m[0], -m[1], -m[2], -m[3]);

+}

+

+void operator -- (inout float a) {

+    a -= 1.0;

+}

+

+void operator -- (inout int a) {

+    a -= 1;

+}

+

+void operator -- (inout vec2 v) {

+    --v.x, --v.y;

+}

+

+void operator -- (inout vec3 v) {

+    --v.x, --v.y, --v.z;

+}

+

+void operator -- (inout vec4 v) {

+    --v.x, --v.y, --v.z, --v.w;

+}

+

+void operator -- (inout ivec2 v) {

+    --v.x, --v.y;

+}

+

+void operator -- (inout ivec3 v) {

+    --v.x, --v.y, --v.z;

+}

+

+void operator -- (inout ivec4 v) {

+    --v.x, --v.y, --v.z, --v.w;

+}

+

+void operator -- (inout mat2 m) {

+    --m[0], --m[1];

+}

+

+void operator -- (inout mat3 m) {

+    --m[0], --m[1], --m[2];

+}

+

+void operator -- (inout mat4 m) {

+    --m[0], --m[1], --m[2], --m[3];

+}

+

+void operator ++ (inout float a) {

+    a += 1.0;

+}

+

+void operator ++ (inout int a) {

+    a += 1;

+}

+

+void operator ++ (inout vec2 v) {

+    ++v.x, ++v.y;

+}

+

+void operator ++ (inout vec3 v) {

+    ++v.x, ++v.y, ++v.z;

+}

+

+void operator ++ (inout vec4 v) {

+    ++v.x, ++v.y, ++v.z, ++v.w;

+}

+

+void operator ++ (inout ivec2 v) {

+    ++v.x, ++v.y;

+}

+

+void operator ++ (inout ivec3 v) {

+    ++v.x, ++v.y, ++v.z;

+}

+

+void operator ++ (inout ivec4 v) {

+    ++v.x, ++v.y, ++v.z, ++v.w;

+}

+

+void operator ++ (inout mat2 m) {

+    ++m[0], ++m[1];

+}

+

+void operator ++ (inout mat3 m) {

+    ++m[0], ++m[1], ++m[2];

+}

+

+void operator ++ (inout mat4 m) {

+    ++m[0], ++m[1], ++m[2], ++m[3];

+}

+

+float operator -- (inout float a, const int) {

+    const float c = a;

+    --a;

+    return c;

+}

+

+int operator -- (inout int a, const int) {

+    const int c = a;

+    --a;

+    return c;

+}

+

+vec2 operator -- (inout vec2 v, const int) {

+    return vec2 (v.x--, v.y--);

+}

+

+vec3 operator -- (inout vec3 v, const int) {

+    return vec3 (v.x--, v.y--, v.z--);

+}

+

+vec4 operator -- (inout vec4 v, const int) {

+    return vec4 (v.x--, v.y--, v.z--, v.w--);

+}

+

+ivec2 operator -- (inout ivec2 v, const int) {

+    return ivec2 (v.x--, v.y--);

+}

+

+ivec3 operator -- (inout ivec3 v, const int) {

+    return ivec3 (v.x--, v.y--, v.z--);

+}

+

+ivec4 operator -- (inout ivec4 v, const int) {

+    return ivec4 (v.x--, v.y--, v.z--, v.w--);

+}

+

+mat2 operator -- (inout mat2 m, const int) {

+    return mat2 (m[0]--, m[1]--);

+}

+

+mat3 operator -- (inout mat3 m, const int) {

+    return mat3 (m[0]--, m[1]--, m[2]--);

+}

+

+mat4 operator -- (inout mat4 m, const int) {

+    return mat4 (m[0]--, m[1]--, m[2]--, m[3]--);

+}

+

+float operator ++ (inout float a, const int) {

+    const float c = a;

+    ++a;

+    return c;

+}

+

+int operator ++ (inout int a, const int) {

+    const int c = a;

+    ++a;

+    return c;

+}

+

+vec2 operator ++ (inout vec2 v, const int) {

+    return vec2 (v.x++, v.y++);

+}

+

+vec3 operator ++ (inout vec3 v, const int) {

+    return vec3 (v.x++, v.y++, v.z++);

+}

+

+vec4 operator ++ (inout vec4 v, const int) {

+    return vec4 (v.x++, v.y++, v.z++, v.w++);

+}

+

+ivec2 operator ++ (inout ivec2 v, const int) {

+    return ivec2 (v.x++, v.y++);

+}

+

+ivec3 operator ++ (inout ivec3 v, const int) {

+    return ivec3 (v.x++, v.y++, v.z++);

+}

+

+ivec4 operator ++ (inout ivec4 v, const int) {

+    return ivec4 (v.x++, v.y++, v.z++, v.w++);

+}

+

+mat2 operator ++ (inout mat2 m, const int) {

+    return mat2 (m[0]++, m[1]++);

+}

+

+mat3 operator ++ (inout mat3 m, const int) {

+    return mat3 (m[0]++, m[1]++, m[2]++);

+}

+

+mat4 operator ++ (inout mat4 m, const int) {

+    return mat4 (m[0]++, m[1]++, m[2]++, m[3]++);

+}

+

+// 

+// • The relational operators greater than (>), less than (<), greater than or equal (>=), and less

+//   than or equal (<=) operate only on scalar integer and scalar floating-point expressions. The

+//   result is scalar Boolean. The operands’ types must match. To do component-wise

+//   comparisons on vectors, use the built-in functions lessThan, lessThanEqual,

+//   greaterThan, and greaterThanEqual.

+// 

+

+bool operator < (const float a, const float b) {

+    bool c;

+    __asm float_less c, a, b;

+    return c;

+}

+

+bool operator < (const int a, const int b) {

+    bool c;

+    __asm int_less c, a, b;

+    return c;

+}

+

+bool operator > (const float a, const float b) {

+    return b < a;

+}

+

+bool operator > (const int a, const int b) {

+    return b < a;

+}

+

+bool operator >= (const float a, const float b) {

+    return a > b || a == b;

+}

+

+bool operator >= (const int a, const int b) {

+    return a > b || a == b;

+}

+

+bool operator <= (const float a, const float b) {

+    return a < b || a == b;

+}

+

+bool operator <= (const int a, const int b) {

+    return a < b || a == b;

+}

+

+// 

+// • The equality operators equal (==), and not equal (!=) operate on all types except arrays.

+//   They result in a scalar Boolean. For vectors, matrices, and structures, all components of the

+//   operands must be equal for the operands to be considered equal. To get component-wise

+//   equality results for vectors, use the built-in functions equal and notEqual.

+// 

+

+bool operator == (const float a, const float b) {

+	bool c;

+	__asm float_equal c, a, b;

+	return c;

+}

+

+bool operator == (const int a, const int b) {

+	bool c;

+	__asm int_equal c, a, b;

+	return c;

+}

+

+bool operator == (const bool a, const bool b) {

+	bool c;

+	__asm bool_equal c, a, b;

+	return c;

+}

+

+bool operator == (const vec2 v, const vec2 u) {

+	return v.x == u.x && v.y == u.y;

+}

+

+bool operator == (const vec3 v, const vec3 u) {

+	return v.x == u.x && v.y == u.y && v.z == u.z;

+}

+

+bool operator == (const vec4 v, const vec4 u) {

+	return v.x == u.x && v.y == u.y && v.z == u.z && v.w == u.w;

+}

+

+bool operator == (const ivec2 v, const ivec2 u) {

+	return v.x == u.x && v.y == u.y;

+}

+

+bool operator == (const ivec3 v, const ivec3 u) {

+	return v.x == u.x && v.y == u.y && v.z == u.z;

+}

+

+bool operator == (const ivec4 v, const ivec4 u) {

+	return v.x == u.x && v.y == u.y && v.z == u.z && v.w == u.w;

+}

+

+bool operator == (const bvec2 v, const bvec2 u) {

+	return v.x == u.x && v.y == u.y;

+}

+

+bool operator == (const bvec3 v, const bvec3 u) {

+	return v.x == u.x && v.y == u.y && v.z == u.z;

+}

+

+bool operator == (const bvec4 v, const bvec4 u) {

+	return v.x == u.x && v.y == u.y && v.z == u.z && v.w == u.w;

+}

+

+bool operator == (const mat2 m, const mat2 n) {

+	return m[0] == n[0] && m[1] == n[1];

+}

+

+bool operator == (const mat3 m, const mat3 n) {

+	return m[0] == n[0] && m[1] == n[1] && m[2] == n[2];

+}

+

+bool operator == (const mat4 m, const mat4 n) {

+	return m[0] == n[0] && m[1] == n[1] && m[2] == n[2] && m[3] == n[3];

+}

+

+bool operator != (const float a, const float b) {

+	return !(a == b);

+}

+

+bool operator != (const int a, const int b) {

+	return !(a == b);

+}

+

+bool operator != (const bool a, const bool b) {

+	return !(a == b);

+}

+

+bool operator != (const vec2 v, const vec2 u) {

+	return v.x != u.x || v.y != u.y;

+}

+

+bool operator != (const vec3 v, const vec3 u) {

+	return v.x != u.x || v.y != u.y || v.z != u.z;

+}

+

+bool operator != (const vec4 v, const vec4 u) {

+	return v.x != u.x || v.y != u.y || v.z != u.z || v.w != u.w;

+}

+

+bool operator != (const ivec2 v, const ivec2 u) {

+	return v.x != u.x || v.y != u.y;

+}

+

+bool operator != (const ivec3 v, const ivec3 u) {

+	return v.x != u.x || v.y != u.y || v.z != u.z;

+}

+

+bool operator != (const ivec4 v, const ivec4 u) {

+	return v.x != u.x || v.y != u.y || v.z != u.z || v.w != u.w;

+}

+

+bool operator != (const bvec2 v, const bvec2 u) {

+	return v.x != u.x || v.y != u.y;

+}

+

+bool operator != (const bvec3 v, const bvec3 u) {

+	return v.x != u.x || v.y != u.y || v.z != u.z;

+}

+

+bool operator != (const bvec4 v, const bvec4 u) {

+	return v.x != u.x || v.y != u.y || v.z != u.z || v.w != u.w;

+}

+

+bool operator != (const mat2 m, const mat2 n) {

+	return m[0] != n[0] || m[1] != n[1];

+}

+

+bool operator != (const mat3 m, const mat3 n) {

+	return m[0] != n[0] || m[1] != n[1] || m[2] != n[2];

+}

+

+bool operator != (const mat4 m, const mat4 n) {

+	return m[0] != n[0] || m[1] != n[1] || m[2] != n[2] || m[3] != n[3];

+}

+

+// 

+// • The logical binary operators and (&&), or ( | | ), and exclusive or (^^). They operate only

+//   on two Boolean expressions and result in a Boolean expression. And (&&) will only

+//   evaluate the right hand operand if the left hand operand evaluated to true. Or ( | | ) will

+//   only evaluate the right hand operand if the left hand operand evaluated to false. Exclusive or

+//   (^^) will always evaluate both operands.

+// 

+

+bool operator ^^ (const bool a, const bool b) {

+    return a != b;

+}

+

+// 

+// [These operators are handled internally by the compiler:]

+// 

+// bool operator && (bool a, bool b) {

+//     return a ? b : false;

+// }

+// bool operator || (bool a, bool b) {

+//     return a ? true : b;

+// }

+// 

+

+// 

+// • The logical unary operator not (!). It operates only on a Boolean expression and results in a

+//   Boolean expression. To operate on a vector, use the built-in function not.

+// 

+

+bool operator ! (const bool a) {

+    return a == false;

+}

+