diff options
Diffstat (limited to 'src/mesa/slang/library/slang_core.gc')
| -rw-r--r-- | src/mesa/slang/library/slang_core.gc | 2619 |
1 files changed, 2619 insertions, 0 deletions
diff --git a/src/mesa/slang/library/slang_core.gc b/src/mesa/slang/library/slang_core.gc new file mode 100644 index 0000000000..0a0d15903b --- /dev/null +++ b/src/mesa/slang/library/slang_core.gc @@ -0,0 +1,2619 @@ +/* + * Mesa 3-D graphics library + * Version: 6.5 + * + * Copyright (C) 2006 Brian Paul All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN + * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + +// +// 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 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 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. +// + + + +//// Basic, scalar constructors/casts + +int __constructor(const float f) +{ + __asm vec4_to_ivec4 __retVal, f; +} + +int __constructor(const bool b) +{ + __retVal = b; +} + +int __constructor(const int i) +{ + __retVal = i; +} + +bool __constructor(const int i) +{ + __asm vec4_sne __retVal, i, 0.0; +} + +bool __constructor(const float f) +{ + __asm vec4_sne __retVal, f, 0.0; +} + +bool __constructor(const bool b) +{ + __retVal = b; +} + +float __constructor(const int i) +{ + __asm ivec4_to_vec4 __retVal, i; +} + +float __constructor(const bool b) +{ + __asm ivec4_to_vec4 __retVal, b; +} + +float __constructor(const float f) +{ + __retVal = f; +} + + +//// vec2 constructors + +vec2 __constructor(const float x, const float y) +{ + __retVal.x = x; + __retVal.y = y; +} + +vec2 __constructor(const float f) +{ + __asm vec4_move __retVal.xy, f; +} + +vec2 __constructor(const int i) +{ + __asm ivec4_to_vec4 __retVal.xy, i; +} + +vec2 __constructor(const bool b) +{ + __asm ivec4_to_vec4 __retVal.xy, b; +} + +vec2 __constructor(const bvec2 b) +{ +// __retVal = b; + __asm ivec4_to_vec4 __retVal.xy, b; +} + +vec2 __constructor(const vec3 v) +{ + __asm vec4_move __retVal.xy, v.xy; +} + +vec2 __constructor(const vec4 v) +{ + __asm vec4_move __retVal.xy, v.xy; +} + + +//// vec3 constructors + +vec3 __constructor(const float x, const float y, const float z) +{ + __retVal.x = x; + __retVal.y = y; + __retVal.z = z; +} + +vec3 __constructor(const float f) +{ + // Note: this could be "__retVal.xyz = f" but that's an illegal assignment + __asm vec4_move __retVal.xyz, f; +} + +vec3 __constructor(const int i) +{ + __asm ivec4_to_vec4 __retVal.xyz, i; +} + +vec3 __constructor(const bool b) +{ + __asm ivec4_to_vec4 __retVal.xyz, b; +} + +vec3 __constructor(const bvec3 b) +{ + __asm ivec4_to_vec4 __retVal.xyz, b; +} + +vec3 __constructor(const vec4 v) +{ + __asm vec4_move __retVal.xyz, v; +} + + +//// vec4 constructors + +vec4 __constructor(const float x, const float y, const float z, const float w) +{ + __retVal.x = x; + __retVal.y = y; + __retVal.z = z; + __retVal.w = w; +} + +vec4 __constructor(const float f) +{ + // Note: this could be "__retVal = f" but that's an illegal assignment + __asm vec4_move __retVal, f; +} + +vec4 __constructor(const int i) +{ + __asm ivec4_to_vec4 __retVal, i; +} + +vec4 __constructor(const bool b) +{ + __asm ivec4_to_vec4 __retVal, b; +} + +vec4 __constructor(const bvec4 b) +{ + __asm ivec4_to_vec4 __retVal, b; +} + +vec4 __constructor(const ivec4 i) +{ + __asm ivec4_to_vec4 __retVal, i; +} + +vec4 __constructor(const vec3 v3, const float f) +{ + // XXX this constructor shouldn't be needed anymore + __retVal.xyz = v3; + __retVal.w = f; +} + +vec4 __constructor(const vec2 v2, const float f1, const float f2) +{ + // XXX this constructor shouldn't be needed anymore + __retVal.xy = v2; + __retVal.z = f1; + __retVal.w = f2; +} + + +//// ivec2 constructors + +ivec2 __constructor(const int i, const int j) +{ + __retVal.x = i; + __retVal.y = j; +} + +ivec2 __constructor(const int i) +{ + __asm vec4_move __retVal.xy, i; +} + +ivec2 __constructor(const float f) +{ + __asm vec4_to_ivec4 __retVal.xy, f; +} + +ivec2 __constructor(const bool b) +{ + __asm vec4_to_ivec4 __retVal.xy, b; +} + + +//// ivec3 constructors + +ivec3 __constructor(const int i, const int j, const int k) +{ + __retVal.x = i; + __retVal.y = j; + __retVal.z = k; +} + +ivec3 __constructor(const int i) +{ + __asm vec4_move __retVal.xyz, i; +} + +ivec3 __constructor(const float f) +{ + __asm vec4_to_ivec4 __retVal.xyz, f; +} + +ivec3 __constructor(const bool b) +{ + __asm vec4_move __retVal.xyz, b; +} + + +//// ivec4 constructors + +ivec4 __constructor(const int x, const int y, const int z, const int w) +{ + __retVal.x = x; + __retVal.y = y; + __retVal.z = z; + __retVal.w = w; +} + +ivec4 __constructor(const int i) +{ + __asm vec4_move __retVal, i; +} + +ivec4 __constructor(const float f) +{ + __asm vec4_to_ivec4 __retVal, f; +} + +ivec4 __constructor(const bool b) +{ + __asm vec4_to_ivec4 __retVal, b; +} + + +//// bvec2 constructors + +bvec2 __constructor(const bool b1, const bool b2) +{ + __retVal.x = b1; + __retVal.y = b2; +} + +bvec2 __constructor(const int i1, const int i2) +{ + __asm vec4_sne __retVal.x, i1, 0.0; + __asm vec4_sne __retVal.y, i2, 0.0; +} + + +bvec2 __constructor(const bool b) +{ + __asm vec4_move __retVal.xy, b; +} + +bvec2 __constructor(const float f) +{ + __asm vec4_sne __retVal.xy, f, 0.0; +} + +bvec2 __constructor(const int i) +{ + __asm vec4_sne __retVal.xy, i, 0.0; +} + +bvec2 __constructor(const vec2 v) +{ + __asm vec4_sne __retVal.xy, v, 0.0; +} + +bvec2 __constructor(const ivec2 v) +{ + __asm vec4_sne __retVal.xy, v, 0.0; +} + + + +//// bvec3 constructors + +bvec3 __constructor(const bool b1, const bool b2, const bool b3) +{ + __retVal.x = b1; + __retVal.y = b2; + __retVal.z = b3; +} + +bvec3 __constructor(const float f1, const float f2, const float f3) +{ + __asm vec4_sne __retVal.x, f1, 0.0; + __asm vec4_sne __retVal.y, f2, 0.0; + __asm vec4_sne __retVal.z, f3, 0.0; +} + +bvec3 __constructor(const bool b) +{ + __asm vec4_move __retVal.xyz, b; +} + +bvec3 __constructor(const float f) +{ + __asm vec4_sne __retVal.xyz, f, 0.0; +} + +bvec3 __constructor(const int i) +{ + __asm vec4_sne __retVal.xyz, i, 0.0; +} + +bvec3 __constructor(const vec3 v) +{ + __asm vec4_sne __retVal.xyz, v, 0.0; +} + +bvec3 __constructor(const ivec3 v) +{ + __asm vec4_sne __retVal.xyz, v, 0.0; +} + + + +//// bvec4 constructors + +bvec4 __constructor(const bool b1, const bool b2, const bool b3, const bool b4) +{ + __retVal.x = b1; + __retVal.y = b2; + __retVal.z = b3; + __retVal.w = b4; +} + +bvec4 __constructor(const float f1, const float f2, const float f3, const float f4) +{ + const float zero = 0.0; + __asm vec4_sne __retVal.x, f1, zero; + __asm vec4_sne __retVal.y, f2, zero; + __asm vec4_sne __retVal.z, f3, zero; + __asm vec4_sne __retVal.w, f4, zero; +} + +bvec4 __constructor(const bool b) +{ + __asm vec4_move __retVal.xyzw, b; +} + +bvec4 __constructor(const float f) +{ + __asm vec4_sne __retVal.xyzw, f, 0.0; +} + +bvec4 __constructor(const int i) +{ + __asm vec4_sne __retVal.xyzw, i, 0.0; +} + +bvec4 __constructor(const vec4 v) +{ + __asm vec4_sne __retVal.xyzw, v, 0.0; +} + +bvec4 __constructor(const ivec4 v) +{ + __asm vec4_sne __retVal.xyzw, v, 0.0; +} + + + +//// mat2 constructors + +mat2 __constructor(const float m00, const float m10, + const float m01, const float m11) +{ + __retVal[0].x = m00; + __retVal[0].y = m10; + __retVal[1].x = m01; + __retVal[1].y = m11; +} + +mat2 __constructor(const float f) +{ + __retVal[0].x = f; + __retVal[0].y = 0.0; + __retVal[1].x = 0.0; + __retVal[1].y = f; +} + +mat2 __constructor(const int i) +{ + return mat2(float(i)); +} + +mat2 __constructor(const bool b) +{ + return mat2(float(b)); +} + +mat2 __constructor(const vec2 c0, const vec2 c1) +{ + __retVal[0] = c0; + __retVal[1] = c1; +} + + +//// mat3 constructors + +mat3 __constructor(const float m00, const float m10, const float m20, + const float m01, const float m11, const float m21, + const float m02, const float m12, const float m22) +{ + __retVal[0].x = m00; + __retVal[0].y = m10; + __retVal[0].z = m20; + __retVal[1].x = m01; + __retVal[1].y = m11; + __retVal[1].z = m21; + __retVal[2].x = m02; + __retVal[2].y = m12; + __retVal[2].z = m22; +} + +mat3 __constructor(const float f) +{ + vec2 v = vec2(f, 0.0); + __retVal[0] = v.xyy; + __retVal[1] = v.yxy; + __retVal[2] = v.yyx; +} + +mat3 __constructor(const int i) +{ + return mat3(float(i)); +} + +mat3 __constructor(const bool b) +{ + return mat3(float(b)); +} + +mat3 __constructor(const vec3 c0, const vec3 c1, const vec3 c2) +{ + __retVal[0] = c0; + __retVal[1] = c1; + __retVal[2] = c2; +} + + +//// mat4 constructors + +mat4 __constructor(const float m00, const float m10, const float m20, const float m30, + const float m01, const float m11, const float m21, const float m31, + const float m02, const float m12, const float m22, const float m32, + const float m03, const float m13, const float m23, const float m33) +{ + __retVal[0].x = m00; + __retVal[0].y = m10; + __retVal[0].z = m20; + __retVal[0].w = m30; + __retVal[1].x = m01; + __retVal[1].y = m11; + __retVal[1].z = m21; + __retVal[1].w = m31; + __retVal[2].x = m02; + __retVal[2].y = m12; + __retVal[2].z = m22; + __retVal[2].w = m32; + __retVal[3].x = m03; + __retVal[3].y = m13; + __retVal[3].z = m23; + __retVal[3].w = m33; +} + + +mat4 __constructor(const float f) +{ + vec2 v = vec2(f, 0.0); + __retVal[0] = v.xyyy; + __retVal[1] = v.yxyy; + __retVal[2] = v.yyxy; + __retVal[3] = v.yyyx; +} + +mat4 __constructor(const int i) +{ + return mat4(float(i)); +} + +mat4 __constructor(const bool b) +{ + return mat4(float(b)); +} + +mat4 __constructor(const vec4 c0, const vec4 c1, const vec4 c2, const vec4 c3) +{ + __retVal[0] = c0; + __retVal[1] = c1; + __retVal[2] = c2; + __retVal[3] = c3; +} + + + +//// Basic int operators + +int __operator + (const int a, const int b) +{ + __asm vec4_add __retVal, a, b; +} + +int __operator - (const int a, const int b) +{ + __asm vec4_subtract __retVal, a, b; +} + +int __operator * (const int a, const int b) +{ + __asm vec4_multiply __retVal, a, b; +} + +int __operator / (const int a, const int b) +{ + float bInv, x; + __asm float_rcp bInv, b; + __asm vec4_multiply x, a, bInv; + __asm vec4_to_ivec4 __retVal, x; +} + + +//// Basic ivec2 operators + +ivec2 __operator + (const ivec2 a, const ivec2 b) +{ + __asm vec4_add __retVal, a, b; +} + +ivec2 __operator - (const ivec2 a, const ivec2 b) +{ + __asm vec4_subtract __retVal, a, b; +} + +ivec2 __operator * (const ivec2 a, const ivec2 b) +{ + __asm vec4_multiply __retVal, a, b; +} + +ivec2 __operator / (const ivec2 a, const ivec2 b) +{ + vec2 bInv, x; + __asm float_rcp bInv.x, b.x; + __asm float_rcp bInv.y, b.y; + __asm vec4_multiply x, a, bInv; + __asm vec4_to_ivec4 __retVal, x; +} + + +//// Basic ivec3 operators + +ivec3 __operator + (const ivec3 a, const ivec3 b) +{ + __asm vec4_add __retVal, a, b; +} + +ivec3 __operator - (const ivec3 a, const ivec3 b) +{ + __asm vec4_subtract __retVal, a, b; +} + +ivec3 __operator * (const ivec3 a, const ivec3 b) +{ + __asm vec4_multiply __retVal, a, b; +} + +ivec3 __operator / (const ivec3 a, const ivec3 b) +{ + vec3 bInv, x; + __asm float_rcp bInv.x, b.x; + __asm float_rcp bInv.y, b.y; + __asm float_rcp bInv.z, b.z; + __asm vec4_multiply x, a, bInv; + __asm vec4_to_ivec4 __retVal, x; +} + + +//// Basic ivec4 operators + +ivec4 __operator + (const ivec4 a, const ivec4 b) +{ + __asm vec4_add __retVal, a, b; +} + +ivec4 __operator - (const ivec4 a, const ivec4 b) +{ + __asm vec4_subtract __retVal, a, b; +} + +ivec4 __operator * (const ivec4 a, const ivec4 b) +{ + __asm vec4_multiply __retVal, a, b; +} + +ivec4 __operator / (const ivec4 a, const ivec4 b) +{ + vec4 bInv, x; + __asm float_rcp bInv.x, b.x; + __asm float_rcp bInv.y, b.y; + __asm float_rcp bInv.z, b.z; + __asm float_rcp bInv.w, b.w; + __asm vec4_multiply x, a, bInv; + __asm vec4_to_ivec4 __retVal, x; +} + + +//// Basic float operators + +float __operator + (const float a, const float b) +{ + __asm vec4_add __retVal, a, b; +} + +float __operator - (const float a, const float b) +{ + __asm vec4_subtract __retVal, a, b; +} + +float __operator * (const float a, const float b) +{ + __asm vec4_multiply __retVal, a, b; +} + +float __operator / (const float a, const float b) +{ + float bInv; + __asm float_rcp bInv.x, b; + __asm vec4_multiply __retVal, a, bInv; +} + + +//// Basic vec2 operators + +vec2 __operator + (const vec2 v, const vec2 u) +{ + __asm vec4_add __retVal.xy, v, u; +} + +vec2 __operator - (const vec2 v, const vec2 u) +{ + __asm vec4_subtract __retVal.xy, v, u; +} + +vec2 __operator * (const vec2 v, const vec2 u) +{ + __asm vec4_multiply __retVal.xy, v, u; +} + +vec2 __operator / (const vec2 v, const vec2 u) +{ + vec2 w; // = 1 / u + __asm float_rcp w.x, u.x; + __asm float_rcp w.y, u.y; + __asm vec4_multiply __retVal.xy, v, w; +} + + +//// Basic vec3 operators + +vec3 __operator + (const vec3 v, const vec3 u) +{ + __asm vec4_add __retVal.xyz, v, u; +} + +vec3 __operator - (const vec3 v, const vec3 u) +{ + __asm vec4_subtract __retVal.xyz, v, u; +} + +vec3 __operator * (const vec3 v, const vec3 u) +{ + __asm vec4_multiply __retVal.xyz, v, u; +} + +vec3 __operator / (const vec3 v, const vec3 u) +{ + vec3 w; // = 1 / u + __asm float_rcp w.x, u.x; + __asm float_rcp w.y, u.y; + __asm float_rcp w.z, u.z; + __asm vec4_multiply __retVal.xyz, v, w; +} + + +//// Basic vec4 operators + +vec4 __operator + (const vec4 v, const vec4 u) +{ + __asm vec4_add __retVal, v, u; +} + +vec4 __operator - (const vec4 v, const vec4 u) +{ + __asm vec4_subtract __retVal, v, u; +} + +vec4 __operator * (const vec4 v, const vec4 u) +{ + __asm vec4_multiply __retVal, v, u; +} + +vec4 __operator / (const vec4 v, const vec4 u) +{ + vec4 w; // = 1 / u + __asm float_rcp w.x, u.x; + __asm float_rcp w.y, u.y; + __asm float_rcp w.z, u.z; + __asm float_rcp w.w, u.w; + __asm vec4_multiply __retVal, v, w; +} + + + + +//// Basic vec2/float operators + +vec2 __operator + (const float a, const vec2 u) +{ + __asm vec4_add __retVal.xy, a, u.xy; +} + +vec2 __operator + (const vec2 v, const float b) +{ + __asm vec4_add __retVal.xy, v.xy, b; +} + +vec2 __operator - (const float a, const vec2 u) +{ + __asm vec4_subtract __retVal.xy, a, u.xy; +} + +vec2 __operator - (const vec2 v, const float b) +{ + __asm vec4_subtract __retVal.xy, v.xy, b; +} + +vec2 __operator * (const float a, const vec2 u) +{ + __asm vec4_multiply __retVal.xy, a, u.xy; +} + +vec2 __operator * (const vec2 v, const float b) +{ + __asm vec4_multiply __retVal.xy, v.xy, b; +} + +vec2 __operator / (const float a, const vec2 u) +{ + vec2 invU; + __asm float_rcp invU.x, u.x; + __asm float_rcp invU.y, u.y; + __asm vec4_multiply __retVal.xy, a, invU.xy; +} + +vec2 __operator / (const vec2 v, const float b) +{ + float invB; + __asm float_rcp invB, b; + __asm vec4_multiply __retVal.xy, v.xy, invB; +} + + +//// Basic vec3/float operators + +vec3 __operator + (const float a, const vec3 u) +{ + __asm vec4_add __retVal.xyz, a, u.xyz; +} + +vec3 __operator + (const vec3 v, const float b) +{ + __asm vec4_add __retVal.xyz, v.xyz, b; +} + +vec3 __operator - (const float a, const vec3 u) +{ + __asm vec4_subtract __retVal.xyz, a, u.xyz; +} + +vec3 __operator - (const vec3 v, const float b) +{ + __asm vec4_subtract __retVal.xyz, v.xyz, b; +} + +vec3 __operator * (const float a, const vec3 u) +{ + __asm vec4_multiply __retVal.xyz, a, u.xyz; +} + +vec3 __operator * (const vec3 v, const float b) +{ + __asm vec4_multiply __retVal.xyz, v.xyz, b; +} + +vec3 __operator / (const float a, const vec3 u) +{ + vec3 invU; + __asm float_rcp invU.x, u.x; + __asm float_rcp invU.y, u.y; + __asm float_rcp invU.z, u.z; + __asm vec4_multiply __retVal.xyz, a, invU.xyz; +} + +vec3 __operator / (const vec3 v, const float b) +{ + float invB; + __asm float_rcp invB, b; + __asm vec4_multiply __retVal.xyz, v.xyz, invB; +} + + +//// Basic vec4/float operators + +vec4 __operator + (const float a, const vec4 u) +{ + __asm vec4_add __retVal, a, u; +} + +vec4 __operator + (const vec4 v, const float b) +{ + __asm vec4_add __retVal, v, b; +} + +vec4 __operator - (const float a, const vec4 u) +{ + __asm vec4_subtract __retVal, a, u; +} + +vec4 __operator - (const vec4 v, const float b) +{ + __asm vec4_subtract __retVal, v, b; +} + +vec4 __operator * (const float a, const vec4 u) +{ + __asm vec4_multiply __retVal, a, u; +} + +vec4 __operator * (const vec4 v, const float b) +{ + __asm vec4_multiply __retVal, v, b; +} + +vec4 __operator / (const float a, const vec4 u) +{ + vec4 invU; + __asm float_rcp invU.x, u.x; + __asm float_rcp invU.y, u.y; + __asm float_rcp invU.z, u.z; + __asm float_rcp invU.w, u.w; + __asm vec4_multiply __retVal, a, invU; +} + +vec4 __operator / (const vec4 v, const float b) +{ + float invB; + __asm float_rcp invB, b; + __asm vec4_multiply __retVal, v, invB; +} + + + +//// Basic ivec2/int operators + +ivec2 __operator + (const int a, const ivec2 u) +{ + __retVal = ivec2(a) + u; +} + +ivec2 __operator + (const ivec2 v, const int b) +{ + __retVal = v + ivec2(b); +} + +ivec2 __operator - (const int a, const ivec2 u) +{ + __retVal = ivec2(a) - u; +} + +ivec2 __operator - (const ivec2 v, const int b) +{ + __retVal = v - ivec2(b); +} + +ivec2 __operator * (const int a, const ivec2 u) +{ + __retVal = ivec2(a) * u; +} + +ivec2 __operator * (const ivec2 v, const int b) +{ + __retVal = v * ivec2(b); +} + +ivec2 __operator / (const int a, const ivec2 u) +{ + __retVal = ivec2(a) / u; +} + +ivec2 __operator / (const ivec2 v, const int b) +{ + __retVal = v / ivec2(b); +} + + +//// Basic ivec3/int operators + +ivec3 __operator + (const int a, const ivec3 u) +{ + __retVal = ivec3(a) + u; +} + +ivec3 __operator + (const ivec3 v, const int b) +{ + __retVal = v + ivec3(b); +} + +ivec3 __operator - (const int a, const ivec3 u) +{ + __retVal = ivec3(a) - u; +} + +ivec3 __operator - (const ivec3 v, const int b) +{ + __retVal = v - ivec3(b); +} + +ivec3 __operator * (const int a, const ivec3 u) +{ + __retVal = ivec3(a) * u; +} + +ivec3 __operator * (const ivec3 v, const int b) +{ + __retVal = v * ivec3(b); +} + +ivec3 __operator / (const int a, const ivec3 u) +{ + __retVal = ivec3(a) / u; +} + +ivec3 __operator / (const ivec3 v, const int b) +{ + __retVal = v / ivec3(b); +} + + +//// Basic ivec4/int operators + +ivec4 __operator + (const int a, const ivec4 u) +{ + __retVal = ivec4(a) + u; +} + +ivec4 __operator + (const ivec4 v, const int b) +{ + __retVal = v + ivec4(b); +} + +ivec4 __operator - (const int a, const ivec4 u) +{ + __retVal = ivec4(a) - u; +} + +ivec4 __operator - (const ivec4 v, const int b) +{ + __retVal = v - ivec4(b); +} + +ivec4 __operator * (const int a, const ivec4 u) +{ + __retVal = ivec4(a) * u; +} + +ivec4 __operator * (const ivec4 v, const int b) +{ + __retVal = v * ivec4(b); +} + +ivec4 __operator / (const int a, const ivec4 u) +{ + __retVal = ivec4(a) / u; +} + +ivec4 __operator / (const ivec4 v, const int b) +{ + __retVal = v / ivec4(b); +} + + + + +//// Unary negation operator + +int __operator - (const int a) +{ + __asm vec4_negate __retVal.x, a; +} + +ivec2 __operator - (const ivec2 v) +{ + __asm vec4_negate __retVal, v; +} + +ivec3 __operator - (const ivec3 v) +{ + __asm vec4_negate __retVal, v; +} + +ivec4 __operator - (const ivec4 v) +{ + __asm vec4_negate __retVal, v; +} + +float __operator - (const float a) +{ + __asm vec4_negate __retVal.x, a; +} + +vec2 __operator - (const vec2 v) +{ + __asm vec4_negate __retVal.xy, v.xy; +} + +vec3 __operator - (const vec3 v) +{ + __asm vec4_negate __retVal.xyz, v.xyz; +} + +vec4 __operator - (const vec4 v) +{ + __asm vec4_negate __retVal, v; +} + +mat2 __operator - (const mat2 m) +{ + __retVal[0] = -m[0]; + __retVal[1] = -m[1]; +} + +mat3 __operator - (const mat3 m) +{ + __retVal[0] = -m[0]; + __retVal[1] = -m[1]; + __retVal[2] = -m[2]; +} + +mat4 __operator - (const mat4 m) +{ + __retVal[0] = -m[0]; + __retVal[1] = -m[1]; + __retVal[2] = -m[2]; + __retVal[3] = -m[3]; +} + + + +//// dot product + +float dot(const float a, const float b) +{ + __retVal = a * b; +} + +float dot(const vec2 a, const vec2 b) +{ + __retVal = a.x * b.x + a.y * b.y; +} + +float dot(const vec3 a, const vec3 b) +{ + __asm vec3_dot __retVal, a, b; +} + +float dot(const vec4 a, const vec4 b) +{ + __asm vec4_dot __retVal, a, b; +} + + + +//// int assignment operators + +int __operator += (inout int a, const int b) +{ + a = a + b; + return a; +} + +int __operator -= (inout int a, const int b) +{ + a = a - b; + return a; +} + +int __operator *= (inout int a, const int b) +{ + a = a * b; + return a; +} + +int __operator /= (inout int a, const int b) +{ + a = a / b; + return a; +} + + +//// ivec2 assignment operators + +ivec2 __operator += (inout ivec2 v, const ivec2 u) +{ + v = v + u; + return v; +} + +ivec2 __operator -= (inout ivec2 v, const ivec2 u) +{ + v = v - u; + return v; +} + +ivec2 __operator *= (inout ivec2 v, const ivec2 u) +{ + v = v * u; + return v; +} + +ivec2 __operator /= (inout ivec2 v, const ivec2 u) +{ + v = v / u; + return v; +} + + +//// ivec3 assignment operators + +ivec3 __operator += (inout ivec3 v, const ivec3 u) +{ + v = v + u; + return v; +} + +ivec3 __operator -= (inout ivec3 v, const ivec3 u) +{ + v = v - u; + return v; +} + +ivec3 __operator *= (inout ivec3 v, const ivec3 u) +{ + v = v * u; + return v; +} + +ivec3 __operator /= (inout ivec3 v, const ivec3 u) +{ + v = v / u; + return v; +} + + +//// ivec4 assignment operators + +ivec4 __operator += (inout ivec4 v, const ivec4 u) +{ + v = v + u; + return v; +} + +ivec4 __operator -= (inout ivec4 v, const ivec4 u) +{ + v = v - u; + return v; +} + +ivec4 __operator *= (inout ivec4 v, const ivec4 u) +{ + v = v * u; + return v; +} + +ivec4 __operator /= (inout ivec4 v, const ivec4 u) +{ + v = v / u; + return v; +} + + +//// float assignment operators + +float __operator += (inout float a, const float b) +{ + a = a + b; + return a; +} + +float __operator -= (inout float a, const float b) +{ + a = a - b; + return a; +} + +float __operator *= (inout float a, const float b) +{ + a = a * b; + return a; +} + +float __operator /= (inout float a, const float b) +{ + a = a / b; + return a; +} + + +//// vec2 assignment operators + +vec2 __operator += (inout vec2 v, const vec2 u) +{ + v = v + u; + return v; +} + +vec2 __operator -= (inout vec2 v, const vec2 u) +{ + v = v - u; + return v; +} + +vec2 __operator *= (inout vec2 v, const vec2 u) +{ + v = v * u; + return v; +} + +vec2 __operator /= (inout vec2 v, const vec2 u) +{ + v = v / u; + return v; +} + + +//// vec3 assignment operators + +vec3 __operator += (inout vec3 v, const vec3 u) +{ + v = v + u; + return v; +} + +vec3 __operator -= (inout vec3 v, const vec3 u) +{ + v = v - u; + return v; +} + +vec3 __operator *= (inout vec3 v, const vec3 u) +{ + v = v * u; + return v; +} + +vec3 __operator /= (inout vec3 v, const vec3 u) +{ + v = v / u; + return v; +} + + +//// vec4 assignment operators + +vec4 __operator += (inout vec4 v, const vec4 u) +{ + v = v + u; + return v; +} + +vec4 __operator -= (inout vec4 v, const vec4 u) +{ + v = v - u; + return v; +} + +vec4 __operator *= (inout vec4 v, const vec4 u) +{ + v = v * u; + return v; +} + +vec4 __operator /= (inout vec4 v, const vec4 u) +{ + v = v / u; + return v; +} + + + +//// ivec2/int assignment operators + +ivec2 __operator += (inout ivec2 v, const int a) +{ + v = v + ivec2(a); + return v; +} + +ivec2 __operator -= (inout ivec2 v, const int a) +{ + v = v - ivec2(a); + return v; +} + +ivec2 __operator *= (inout ivec2 v, const int a) +{ + v = v * ivec2(a); + return v; +} + +ivec2 __operator /= (inout ivec2 v, const int a) +{ + v = v / ivec2(a); + return v; +} + + +//// ivec3/int assignment operators + +ivec3 __operator += (inout ivec3 v, const int a) +{ + v = v + ivec3(a); + return v; +} + +ivec3 __operator -= (inout ivec3 v, const int a) +{ + v = v - ivec3(a); + return v; +} + +ivec3 __operator *= (inout ivec3 v, const int a) +{ + v = v * ivec3(a); + return v; +} + +ivec4 __operator /= (inout ivec3 v, const int a) +{ + v = v / ivec3(a); + return v; +} + + +//// ivec4/int assignment operators + +ivec4 __operator += (inout ivec4 v, const int a) +{ + v = v + ivec4(a); + return v; +} + +ivec4 __operator -= (inout ivec4 v, const int a) +{ + v = v - ivec4(a); + return v; +} + +ivec4 __operator *= (inout ivec4 v, const int a) +{ + v = v * ivec4(a); + return v; +} + +ivec4 __operator /= (inout ivec4 v, const int a) +{ + v = v / ivec4(a); + return v; +} + + + +//// vec2/float assignment operators + +vec2 __operator += (inout vec2 v, const float a) +{ + v = v + vec2(a); + return v; +} + +vec2 __operator -= (inout vec2 v, const float a) +{ + v = v - vec2(a); + return v; +} + +vec2 __operator *= (inout vec2 v, const float a) +{ + v = v * vec2(a); + return v; +} + +vec2 __operator /= (inout vec2 v, const float a) +{ + v = v / vec2(a); + return v; +} + + +//// vec3/float assignment operators + +vec3 __operator += (inout vec3 v, const float a) +{ + v = v + vec3(a); + return v; +} + +vec3 __operator -= (inout vec3 v, const float a) +{ + v = v - vec3(a); + return v; +} + +vec3 __operator *= (inout vec3 v, const float a) +{ + v = v * vec3(a); + return v; +} + +vec3 __operator /= (inout vec3 v, const float a) +{ + v = v / vec3(a); + return v; +} + + +//// vec4/float assignment operators + +vec4 __operator += (inout vec4 v, const float a) +{ + v = v + vec4(a); + return v; +} + +vec4 __operator -= (inout vec4 v, const float a) +{ + v = v - vec4(a); + return v; +} + +vec4 __operator *= (inout vec4 v, const float a) +{ + v = v * vec4(a); + return v; +} + +vec4 __operator /= (inout vec4 v, const float a) +{ + v = v / vec4(a); + return v; +} + + + + + +//// Basic mat2 operations + +mat2 __operator + (const mat2 m, const mat2 n) +{ + __retVal[0] = m[0] + n[0]; + __retVal[1] = m[1] + n[1]; +} + +mat2 __operator - (const mat2 m, const mat2 n) +{ + __retVal[0] = m[0] - n[0]; + __retVal[1] = m[1] - n[1]; +} + +mat2 __operator * (const mat2 m, const mat2 n) +{ + __retVal[0] = m[0] * n[0].xx + m[1] * n[0].yy; + __retVal[1] = m[0] * n[1].xx + m[1] * n[1].yy; +} + +mat2 __operator / (const mat2 m, const mat2 n) +{ + __retVal[0] = m[0] / n[0]; + __retVal[1] = m[1] / n[1]; +} + + +//// Basic mat3 operations + +mat3 __operator + (const mat3 m, const mat3 n) +{ + __retVal[0] = m[0] + n[0]; + __retVal[1] = m[1] + n[1]; + __retVal[2] = m[2] + n[2]; +} + +mat3 __operator - (const mat3 m, const mat3 n) +{ + __retVal[0] = m[0] - n[0]; + __retVal[1] = m[1] - n[1]; + __retVal[2] = m[2] - n[2]; +} + +mat3 __operator * (const mat3 m, const mat3 n) +{ + __retVal[0] = m[0] * n[0].xxx + m[1] * n[0].yyy + m[2] * n[0].zzz; + __retVal[1] = m[0] * n[1].xxx + m[1] * n[1].yyy + m[2] * n[1].zzz; + __retVal[2] = m[0] * n[2].xxx + m[1] * n[2].yyy + m[2] * n[2].zzz; +} + +mat3 __operator / (const mat3 m, const mat3 n) +{ + __retVal[0] = m[0] / n[0]; + __retVal[1] = m[1] / n[1]; + __retVal[2] = m[2] / n[2]; +} + + +//// Basic mat4 operations + +mat4 __operator + (const mat4 m, const mat4 n) +{ + __retVal[0] = m[0] + n[0]; + __retVal[1] = m[1] + n[1]; + __retVal[2] = m[2] + n[2]; + __retVal[3] = m[3] + n[3]; +} + +mat4 __operator - (const mat4 m, const mat4 n) +{ + __retVal[0] = m[0] - n[0]; + __retVal[1] = m[1] - n[1]; + __retVal[2] = m[2] - n[2]; + __retVal[3] = m[3] - n[3]; +} + +mat4 __operator * (const mat4 m, const mat4 n) +{ + __retVal[0] = m[0] * n[0].xxxx + m[1] * n[0].yyyy + m[2] * n[0].zzzz + m[3] * n[0].wwww; + __retVal[1] = m[0] * n[1].xxxx + m[1] * n[1].yyyy + m[2] * n[1].zzzz + m[3] * n[1].wwww; + __retVal[2] = m[0] * n[2].xxxx + m[1] * n[2].yyyy + m[2] * n[2].zzzz + m[3] * n[2].wwww; + __retVal[3] = m[0] * n[3].xxxx + m[1] * n[3].yyyy + m[2] * n[3].zzzz + m[3] * n[3].wwww; +} + +mat4 __operator / (const mat4 m, const mat4 n) +{ + __retVal[0] = m[0] / n[0]; + __retVal[1] = m[1] / n[1]; + __retVal[2] = m[2] / n[2]; + __retVal[3] = m[3] / n[3]; +} + + +//// mat2/float operations + +mat2 __operator + (const float a, const mat2 n) +{ + __retVal[0] = a + n[0]; + __retVal[1] = a + n[1]; +} + +mat2 __operator + (const mat2 m, const float b) +{ + __retVal[0] = m[0] + b; + __retVal[1] = m[1] + b; +} + +mat2 __operator - (const float a, const mat2 n) +{ + __retVal[0] = a - n[0]; + __retVal[1] = a - n[1]; +} + +mat2 __operator - (const mat2 m, const float b) +{ + __retVal[0] = m[0] - b; + __retVal[1] = m[1] - b; +} + +mat2 __operator * (const float a, const mat2 n) +{ + __retVal[0] = a * n[0]; + __retVal[1] = a * n[1]; +} + +mat2 __operator * (const mat2 m, const float b) +{ + __retVal[0] = m[0] * b; + __retVal[1] = m[1] * b; +} + +mat2 __operator / (const float a, const mat2 n) +{ + __retVal[0] = a / n[0]; + __retVal[1] = a / n[1]; +} + +mat2 __operator / (const mat2 m, const float b) +{ + __retVal[0] = m[0] / b; + __retVal[1] = m[1] / b; +} + + +//// mat3/float operations + +mat3 __operator + (const float a, const mat3 n) +{ + __retVal[0] = a + n[0]; + __retVal[1] = a + n[1]; + __retVal[2] = a + n[2]; +} + +mat3 __operator + (const mat3 m, const float b) +{ + __retVal[0] = m[0] + b; + __retVal[1] = m[1] + b; + __retVal[2] = m[2] + b; +} + +mat3 __operator - (const float a, const mat3 n) +{ + __retVal[0] = a - n[0]; + __retVal[1] = a - n[1]; + __retVal[2] = a - n[2]; +} + +mat3 __operator - (const mat3 m, const float b) +{ + __retVal[0] = m[0] - b; + __retVal[1] = m[1] - b; + __retVal[2] = m[2] - b; +} + +mat3 __operator * (const float a, const mat3 n) +{ + __retVal[0] = a * n[0]; + __retVal[1] = a * n[1]; + __retVal[2] = a * n[2]; +} + +mat3 __operator * (const mat3 m, const float b) +{ + __retVal[0] = m[0] * b; + __retVal[1] = m[1] * b; + __retVal[2] = m[2] * b; +} + +mat3 __operator / (const float a, const mat3 n) +{ + __retVal[0] = a / n[0]; + __retVal[1] = a / n[1]; + __retVal[2] = a / n[2]; +} + +mat3 __operator / (const mat3 m, const float b) +{ + __retVal[0] = m[0] / b; + __retVal[1] = m[1] / b; + __retVal[2] = m[2] / b; +} + + +//// mat4/float operations + +mat4 __operator + (const float a, const mat4 n) +{ + __retVal[0] = a + n[0]; + __retVal[1] = a + n[1]; + __retVal[2] = a + n[2]; + __retVal[3] = a + n[3]; +} + +mat4 __operator + (const mat4 m, const float b) +{ + __retVal[0] = m[0] + b; + __retVal[1] = m[1] + b; + __retVal[2] = m[2] + b; + __retVal[3] = m[3] + b; +} + +mat4 __operator - (const float a, const mat4 n) +{ + __retVal[0] = a - n[0]; + __retVal[1] = a - n[1]; + __retVal[2] = a - n[2]; + __retVal[3] = a - n[3]; +} + +mat4 __operator - (const mat4 m, const float b) +{ + __retVal[0] = m[0] - b; + __retVal[1] = m[1] - b; + __retVal[2] = m[2] - b; + __retVal[3] = m[3] - b; +} + +mat4 __operator * (const float a, const mat4 n) +{ + __retVal[0] = a * n[0]; + __retVal[1] = a * n[1]; + __retVal[2] = a * n[2]; + __retVal[3] = a * n[3]; +} + +mat4 __operator * (const mat4 m, const float b) +{ + __retVal[0] = m[0] * b; + __retVal[1] = m[1] * b; + __retVal[2] = m[2] * b; + __retVal[3] = m[3] * b; +} + +mat4 __operator / (const float a, const mat4 n) +{ + __retVal[0] = a / n[0]; + __retVal[1] = a / n[1]; + __retVal[2] = a / n[2]; + __retVal[3] = a / n[3]; +} + +mat4 __operator / (const mat4 m, const float b) +{ + __retVal[0] = m[0] / b; + __retVal[1] = m[1] / b; + __retVal[2] = m[2] / b; + __retVal[3] = m[3] / b; +} + + + +//// matrix / vector products + +vec2 __operator * (const mat2 m, const vec2 v) +{ + __retVal = m[0] * v.xx + + m[1] * v.yy; +} + +vec2 __operator * (const vec2 v, const mat2 m) +{ + __retVal.x = dot(v, m[0]); + __retVal.y = dot(v, m[1]); +} + +vec3 __operator * (const mat3 m, const vec3 v) +{ + __retVal = m[0] * v.xxx + + m[1] * v.yyy + + m[2] * v.zzz; +} + +vec3 __operator * (const vec3 v, const mat3 m) +{ + __retVal.x = dot(v, m[0]); + __retVal.y = dot(v, m[1]); + __retVal.z = dot(v, m[2]); +} + +vec4 __operator * (const mat4 m, const vec4 v) +{ + __retVal = m[0] * v.xxxx + + m[1] * v.yyyy + + m[2] * v.zzzz + + m[3] * v.wwww; +} + +vec4 __operator * (const vec4 v, const mat4 m) +{ + __retVal.x = dot(v, m[0]); + __retVal.y = dot(v, m[1]); + __retVal.z = dot(v, m[2]); + __retVal.w = dot(v, m[3]); +} + + + +//// mat2 assignment operators + +mat2 __operator += (inout mat2 m, const mat2 n) +{ + m[0] = m[0] + n[0]; + m[1] = m[1] + n[1]; + return m; +} + +mat2 __operator -= (inout mat2 m, const mat2 n) +{ + m[0] = m[0] - n[0]; + m[1] = m[1] - n[1]; + return m; +} + +mat2 __operator *= (inout mat2 m, const mat2 n) +{ + m = m * n; + return m; +} + +mat2 __operator /= (inout mat2 m, const mat2 n) +{ + m[0] = m[0] / n[0]; + m[1] = m[1] / n[1]; + return m; +} + + +//// mat3 assignment operators + +mat3 __operator += (inout mat3 m, const mat3 n) +{ + m[0] = m[0] + n[0]; + m[1] = m[1] + n[1]; + m[2] = m[2] + n[2]; + return m; +} + +mat3 __operator -= (inout mat3 m, const mat3 n) +{ + m[0] = m[0] - n[0]; + m[1] = m[1] - n[1]; + m[2] = m[2] - n[2]; + return m; +} + +mat3 __operator *= (inout mat3 m, const mat3 n) +{ + m = m * n; + return m; +} + +mat3 __operator /= (inout mat3 m, const mat3 n) +{ + m[0] = m[0] / n[0]; + m[1] = m[1] / n[1]; + m[2] = m[2] / n[2]; + return m; +} + + +// mat4 assignment operators + +mat4 __operator += (inout mat4 m, const mat4 n) +{ + m[0] = m[0] + n[0]; + m[1] = m[1] + n[1]; + m[2] = m[2] + n[2]; + m[3] = m[3] + n[3]; + return m; +} + +mat4 __operator -= (inout mat4 m, const mat4 n) +{ + m[0] = m[0] - n[0]; + m[1] = m[1] - n[1]; + m[2] = m[2] - n[2]; + m[3] = m[3] - n[3]; + return m; +} + +mat4 __operator *= (inout mat4 m, const mat4 n) +{ + m = m * n; + return m; +} + +mat4 __operator /= (inout mat4 m, const mat4 n) +{ + m[0] = m[0] / n[0]; + m[1] = m[1] / n[1]; + m[2] = m[2] / n[2]; + m[3] = m[3] / n[3]; + return m; +} + + +//// mat2/float assignment operators + +mat2 __operator += (inout mat2 m, const float a) +{ + vec2 v = vec2(a); + m[0] = m[0] + v; + m[1] = m[1] + v; + return m; +} + +mat2 __operator -= (inout mat2 m, const float a) +{ + vec2 v = vec2(a); + m[0] = m[0] - v; + m[1] = m[1] - v; + return m; +} + +mat2 __operator *= (inout mat2 m, const float a) +{ + vec2 v = vec2(a); + m[0] = m[0] * v; + m[1] = m[1] * v; + return m; +} + +mat2 __operator /= (inout mat2 m, const float a) +{ + vec2 v = vec2(1.0 / a); + m[0] = m[0] * v; + m[1] = m[1] * v; + return m; +} + + +//// mat3/float assignment operators + +mat3 __operator += (inout mat3 m, const float a) +{ + vec3 v = vec3(a); + m[0] = m[0] + v; + m[1] = m[1] + v; + m[2] = m[2] + v; + return m; +} + +mat3 __operator -= (inout mat3 m, const float a) +{ + vec3 v = vec3(a); + m[0] = m[0] - v; + m[1] = m[1] - v; + m[2] = m[2] - v; + return m; +} + +mat3 __operator *= (inout mat3 m, const float a) +{ + vec3 v = vec3(a); + m[0] = m[0] * v; + m[1] = m[1] * v; + m[2] = m[2] * v; + return m; +} + +mat3 __operator /= (inout mat3 m, const float a) +{ + vec3 v = vec3(1.0 / a); + m[0] = m[0] * v; + m[1] = m[1] * v; + m[2] = m[2] * v; + return m; +} + + +//// mat4/float assignment operators + +mat4 __operator += (inout mat4 m, const float a) +{ + vec4 v = vec4(a); + m[0] = m[0] + v; + m[1] = m[1] + v; + m[2] = m[2] + v; + m[3] = m[3] + v; + return m; +} + +mat4 __operator -= (inout mat4 m, const float a) +{ + vec4 v = vec4(a); + m[0] = m[0] - v; + m[1] = m[1] - v; + m[2] = m[2] - v; + m[3] = m[3] - v; + return m; +} + +mat4 __operator *= (inout mat4 m, const float a) +{ + vec4 v = vec4(a); + m[0] = m[0] * v; + m[1] = m[1] * v; + m[2] = m[2] * v; + m[3] = m[3] * v; + return m; +} + +mat4 __operator /= (inout mat4 m, const float a) +{ + vec4 v = vec4(1.0 / a); + m[0] = m[0] * v; + m[1] = m[1] * v; + m[2] = m[2] * v; + m[3] = m[3] * v; + return m; +} + + + +//// vec/mat assignment operators + +vec2 __operator *= (inout vec2 v, const mat2 m) +{ + v = v * m; + return v; +} + +vec3 __operator *= (inout vec3 v, const mat3 m) +{ + v = v * m; + return v; +} + +vec4 __operator *= (inout vec4 v, const mat4 m) +{ + v = v * m; + return v; +} + + + +//// pre-decrement operators + +int __operator --(inout int a) +{ + a = a - 1; + __retVal = a; +} + +ivec2 __operator --(inout ivec2 v) +{ + v = v - ivec2(1); + __retVal = v; +} + +ivec3 __operator --(inout ivec3 v) +{ + v = v - ivec3(1); + __retVal = v; +} + +ivec4 __operator --(inout ivec4 v) +{ + v = v - ivec4(1); + __retVal = v; +} + + +float __operator --(inout float a) +{ + a = a - 1.0; + __retVal = a; +} + +vec2 __operator --(inout vec2 v) +{ + v = v - vec2(1.0); + __retVal = v; +} + +vec3 __operator --(inout vec3 v) +{ + v = v - vec3(1.0); + __retVal = v; +} + +vec4 __operator --(inout vec4 v) +{ + v = v - vec4(1.0); + __retVal = v; +} + + +mat2 __operator --(inout mat2 m) +{ + m[0] = m[0] - vec2(1.0); + m[1] = m[1] - vec2(1.0); + __retVal = m; +} + +mat3 __operator --(inout mat3 m) +{ + m[0] = m[0] - vec3(1.0); + m[1] = m[1] - vec3(1.0); + m[2] = m[2] - vec3(1.0); + __retVal = m; +} + +mat4 __operator --(inout mat4 m) +{ + m[0] = m[0] - vec4(1.0); + m[1] = m[1] - vec4(1.0); + m[2] = m[2] - vec4(1.0); + m[3] = m[3] - vec4(1.0); + __retVal = m; +} + + +//// pre-increment operators + +int __operator ++(inout int a) +{ + a = a + 1; + __retVal = a; +} + +ivec2 __operator ++(inout ivec2 v) +{ + v = v + ivec2(1); + __retVal = v; +} + +ivec3 __operator ++(inout ivec3 v) +{ + v = v + ivec3(1); + __retVal = v; +} + +ivec4 __operator ++(inout ivec4 v) +{ + v = v + ivec4(1); + __retVal = v; +} + + +float __operator ++(inout float a) +{ + a = a + 1.0; + __retVal = a; +} + +vec2 __operator ++(inout vec2 v) +{ + v = v + vec2(1.0); + __retVal = v; +} + +vec3 __operator ++(inout vec3 v) +{ + v = v + vec3(1.0); + __retVal = v; +} + +vec4 __operator ++(inout vec4 v) +{ + v = v + vec4(1.0); + __retVal = v; +} + + +mat2 __operator ++(inout mat2 m) +{ + m[0] = m[0] + vec2(1.0); + m[1] = m[1] + vec2(1.0); + __retVal = m; +} + +mat3 __operator ++(inout mat3 m) +{ + m[0] = m[0] + vec3(1.0); + m[1] = m[1] + vec3(1.0); + m[2] = m[2] + vec3(1.0); + __retVal = m; +} + +mat4 __operator ++(inout mat4 m) +{ + m[0] = m[0] + vec4(1.0); + m[1] = m[1] + vec4(1.0); + m[2] = m[2] + vec4(1.0); + m[3] = m[3] + vec4(1.0); + __retVal = m; +} + + + +//// post-decrement + +int __postDecr(inout int a) +{ + __retVal = a; + a = a - 1; +} + +ivec2 __postDecr(inout ivec2 v) +{ + __retVal = v; + v = v - ivec2(1); +} + +ivec3 __postDecr(inout ivec3 v) +{ + __retVal = v; + v = v - ivec3(1); +} + +ivec4 __postDecr(inout ivec4 v) +{ + __retVal = v; + v = v - ivec4(1); +} + + +float __postDecr(inout float a) +{ + __retVal = a; + a = a - 1.0; +} + +vec2 __postDecr(inout vec2 v) +{ + __retVal = v; + v = v - vec2(1.0); +} + +vec3 __postDecr(inout vec3 v) +{ + __retVal = v; + v = v - vec3(1.0); +} + +vec4 __postDecr(inout vec4 v) +{ + __retVal = v; + v = v - vec4(1.0); +} + + +mat2 __postDecr(inout mat2 m) +{ + __retVal = m; + m[0] = m[0] - vec2(1.0); + m[1] = m[1] - vec2(1.0); +} + +mat3 __postDecr(inout mat3 m) +{ + __retVal = m; + m[0] = m[0] - vec3(1.0); + m[1] = m[1] - vec3(1.0); + m[2] = m[2] - vec3(1.0); +} + +mat4 __postDecr(inout mat4 m) +{ + __retVal = m; + m[0] = m[0] - vec4(1.0); + m[1] = m[1] - vec4(1.0); + m[2] = m[2] - vec4(1.0); + m[3] = m[3] - vec4(1.0); +} + + +//// post-increment + +float __postIncr(inout float a) +{ + __retVal = a; + a = a + 1; +} + +vec2 __postIncr(inout vec2 v) +{ + __retVal = v; + v = v + vec2(1.0); +} + +vec3 __postIncr(inout vec3 v) +{ + __retVal = v; + v = v + vec3(1.0); +} + +vec4 __postIncr(inout vec4 v) +{ + __retVal = v; + v = v + vec4(1.0); +} + + +int __postIncr(inout int a) +{ + __retVal = a; + a = a + 1; +} + +ivec2 __postIncr(inout ivec2 v) +{ + __retVal = v; + v = v + ivec2(1); +} + +ivec3 __postIncr(inout ivec3 v) +{ + __retVal = v; + v = v + ivec3(1); +} + +ivec4 __postIncr(inout ivec4 v) +{ + __retVal = v; + v = v + ivec3(1); +} + + +mat2 __postIncr(inout mat2 m) +{ + mat2 n = m; + m[0] = m[0] + vec2(1.0); + m[1] = m[1] + vec2(1.0); + return n; +} + +mat3 __postIncr(inout mat3 m) +{ + mat3 n = m; + m[0] = m[0] + vec3(1.0); + m[1] = m[1] + vec3(1.0); + m[2] = m[2] + vec3(1.0); + return n; +} + +mat4 __postIncr(inout mat4 m) +{ + mat4 n = m; + m[0] = m[0] + vec4(1.0); + m[1] = m[1] + vec4(1.0); + m[2] = m[2] + vec4(1.0); + m[3] = m[3] + vec4(1.0); + return n; +} + + + +//// inequality operators + + +// XXX are the inequality operators for floats/ints really needed???? +bool __operator < (const float a, const float b) +{ + __asm vec4_sgt __retVal.x, b, a; +} + + +bool __operator < (const int a, const int b) { + return float (a) < float (b); +} + +bool __operator > (const float a, const float b) { + bool c; + __asm float_less c, b, a; + return c; +} + +bool __operator > (const int a, const int b) { + return float (a) > float (b); +} + +bool __operator >= (const float a, const float b) { + bool g, e; + __asm float_less g, b, a; + __asm float_equal e, a, b; + return g || e; +} + +bool __operator >= (const int a, const int b) { + return float (a) >= float (b); +} + +bool __operator <= (const float a, const float b) { + bool g, e; + __asm float_less g, a, b; + __asm float_equal e, a, b; + return g || e; +} + +bool __operator <= (const int a, const int b) { + return float (a) <= float (b); +} + + + +// +// MESA-specific extension functions. +// + +void printMESA (const float f) { + __asm float_print f; +} + +void printMESA (const int i) { + __asm int_print i; +} + +void printMESA (const bool b) { + __asm bool_print b; +} + +void printMESA (const vec2 v) { + printMESA (v.x); + printMESA (v.y); +} + +void printMESA (const vec3 v) { + printMESA (v.x); + printMESA (v.y); + printMESA (v.z); +} + +void printMESA (const vec4 v) { + printMESA (v.x); + printMESA (v.y); + printMESA (v.z); + printMESA (v.w); +} + +void printMESA (const ivec2 v) { + printMESA (v.x); + printMESA (v.y); +} + +void printMESA (const ivec3 v) { + printMESA (v.x); + printMESA (v.y); + printMESA (v.z); +} + +void printMESA (const ivec4 v) { + printMESA (v.x); + printMESA (v.y); + printMESA (v.z); + printMESA (v.w); +} + +void printMESA (const bvec2 v) { + printMESA (v.x); + printMESA (v.y); +} + +void printMESA (const bvec3 v) { + printMESA (v.x); + printMESA (v.y); + printMESA (v.z); +} + +void printMESA (const bvec4 v) { + printMESA (v.x); + printMESA (v.y); + printMESA (v.z); + printMESA (v.w); +} + +void printMESA (const mat2 m) { + printMESA (m[0]); + printMESA (m[1]); +} + +void printMESA (const mat3 m) { + printMESA (m[0]); + printMESA (m[1]); + printMESA (m[2]); +} + +void printMESA (const mat4 m) { + printMESA (m[0]); + printMESA (m[1]); + printMESA (m[2]); + printMESA (m[3]); +} + +void printMESA (const sampler1D e) { + __asm int_print e; +} + +void printMESA (const sampler2D e) { + __asm int_print e; +} + +void printMESA (const sampler3D e) { + __asm int_print e; +} + +void printMESA (const samplerCube e) { + __asm int_print e; +} + +void printMESA (const sampler1DShadow e) { + __asm int_print e; +} + +void printMESA (const sampler2DShadow e) { + __asm int_print e; +} + |