slang_120_core.gc

Mesa is an open-source implementation of the OpenGL specification - a system for rendering interacti

   __retVal.y = dot(v, m[1]);
   __retVal.z = dot(v, m[2]);
   __retVal.w = dot(v, m[3]);
}

vec2 __operator * (const vec3 v, const mat2x3 m)
{
   __retVal.x = dot(v, m[0]);
   __retVal.y = dot(v, m[1]);
}

vec4 __operator * (const vec3 v, const mat4x3 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]);
}

vec2 __operator * (const vec4 v, const mat2x4 m)
{
   __retVal.x = dot(v, m[0]);
   __retVal.y = dot(v, m[1]);
}

vec3 __operator * (const vec4 v, const mat3x4 m)
{
   __retVal.x = dot(v, m[0]);
   __retVal.y = dot(v, m[1]);
   __retVal.z = dot(v, m[2]);
}


void __operator += (inout mat2x3 m, const float a) {
    m[0] += a;
    m[1] += a;
}

void __operator += (inout mat2x4 m, const float a) {
    m[0] += a;
    m[1] += a;
}

void __operator += (inout mat3x2 m, const float a) {
    m[0] += a;
    m[1] += a;
    m[2] += a;
}

void __operator += (inout mat3x4 m, const float a) {
    m[0] += a;
    m[1] += a;
    m[2] += a;
}

void __operator += (inout mat4x2 m, const float a) {
    m[0] += a;
    m[1] += a;
    m[2] += a;
    m[3] += a;
}

void __operator += (inout mat4x3 m, const float a) {
    m[0] += a;
    m[1] += a;
    m[2] += a;
    m[3] += a;
}


void __operator -= (inout mat2x3 m, const float a) {
    m[0] -= a;
    m[1] -= a;
}

void __operator -= (inout mat2x4 m, const float a) {
    m[0] -= a;
    m[1] -= a;
}

void __operator -= (inout mat3x2 m, const float a) {
    m[0] -= a;
    m[1] -= a;
    m[2] -= a;
}

void __operator -= (inout mat3x4 m, const float a) {
    m[0] -= a;
    m[1] -= a;
    m[2] -= a;
}

void __operator -= (inout mat4x2 m, const float a) {
    m[0] -= a;
    m[1] -= a;
    m[2] -= a;
    m[3] -= a;
}

void __operator -= (inout mat4x3 m, const float a) {
    m[0] -= a;
    m[1] -= a;
    m[2] -= a;
    m[3] -= a;
}


void __operator *= (inout mat2x3 m, const float a) {
    m[0] *= a;
    m[1] *= a;
}

void __operator *= (inout mat2x4 m, const float a) {
    m[0] *= a;
    m[1] *= a;
}

void __operator *= (inout mat3x2 m, const float a) {
    m[0] *= a;
    m[1] *= a;
    m[2] *= a;
}

void __operator *= (inout mat3x4 m, const float a) {
    m[0] *= a;
    m[1] *= a;
    m[2] *= a;
}

void __operator *= (inout mat4x2 m, const float a) {
    m[0] *= a;
    m[1] *= a;
    m[2] *= a;
    m[3] *= a;
}

void __operator *= (inout mat4x3 m, const float a) {
    m[0] *= a;
    m[1] *= a;
    m[2] *= a;
    m[3] *= a;
}


void __operator /= (inout mat2x3 m, const float a) {
    m[0] /= a;
    m[1] /= a;
}

void __operator /= (inout mat2x4 m, const float a) {
    m[0] /= a;
    m[1] /= a;
}

void __operator /= (inout mat3x2 m, const float a) {
    m[0] /= a;
    m[1] /= a;
    m[2] /= a;
}

void __operator /= (inout mat3x4 m, const float a) {
    m[0] /= a;
    m[1] /= a;
    m[2] /= a;
}

void __operator /= (inout mat4x2 m, const float a) {
    m[0] /= a;
    m[1] /= a;
    m[2] /= a;
    m[3] /= a;
}

void __operator /= (inout mat4x3 m, const float a) {
    m[0] /= a;
    m[1] /= a;
    m[2] /= a;
    m[3] /= a;
}


mat2x3 __operator + (const mat2x3 m, const mat2x3 n) {
    return mat2x3 (m[0] + n[0], m[1] + n[1]);
}

mat2x4 __operator + (const mat2x4 m, const mat2x4 n) {
    return mat2x4 (m[0] + n[0], m[1] + n[1]);
}

mat3x2 __operator + (const mat3x2 m, const mat3x2 n) {
    return mat3x2 (m[0] + n[0], m[1] + n[1], m[2] + n[2]);
}

mat3x4 __operator + (const mat3x4 m, const mat3x4 n) {
    return mat3x4 (m[0] + n[0], m[1] + n[1], m[2] + n[2]);
}

mat4x2 __operator + (const mat4x2 m, const mat4x2 n) {
    return mat4x2 (m[0] + n[0], m[1] + n[1], m[2] + n[2], m[3] + n[3]);
}

mat4x3 __operator + (const mat4x3 m, const mat4x3 n) {
    return mat4x3 (m[0] + n[0], m[1] + n[1], m[2] + n[2], m[3] + n[3]);
}


mat2x3 __operator - (const mat2x3 m, const mat2x3 n) {
    return mat2x3 (m[0] - n[0], m[1] - n[1]);
}

mat2x4 __operator - (const mat2x4 m, const mat2x4 n) {
    return mat2x4 (m[0] - n[0], m[1] - n[1]);
}

mat3x2 __operator - (const mat3x2 m, const mat3x2 n) {
    return mat3x2 (m[0] - n[0], m[1] - n[1], m[2] - n[2]);
}

mat3x4 __operator - (const mat3x4 m, const mat3x4 n) {
    return mat3x4 (m[0] - n[0], m[1] - n[1], m[2] - n[2]);
}

mat4x2 __operator - (const mat4x2 m, const mat4x2 n) {
    return mat4x2 (m[0] - n[0], m[1] - n[1], m[2] - n[2], m[3] - n[3]);
}

mat4x3 __operator - (const mat4x3 m, const mat4x3 n) {
    return mat4x3 (m[0] - n[0], m[1] - n[1], m[2] - n[2], m[3] - n[3]);
}


mat2x3 __operator / (const mat2x3 m, const mat2x3 n) {
    return mat2x3 (m[0] / n[0], m[1] / n[1]);
}

mat2x4 __operator / (const mat2x4 m, const mat2x4 n) {
    return mat2x4 (m[0] / n[0], m[1] / n[1]);
}

mat3x2 __operator / (const mat3x2 m, const mat3x2 n) {
    return mat3x2 (m[0] / n[0], m[1] / n[1], m[2] / n[2]);
}

mat3x4 __operator / (const mat3x4 m, const mat3x4 n) {
    return mat3x4 (m[0] / n[0], m[1] / n[1], m[2] / n[2]);
}

mat4x2 __operator / (const mat4x2 m, const mat4x2 n) {
    return mat4x2 (m[0] / n[0], m[1] / n[1], m[2] / n[2], m[3] / n[3]);
}

mat4x3 __operator / (const mat4x3 m, const mat4x3 n) {
    return mat4x3 (m[0] / n[0], m[1] / n[1], m[2] / n[2], m[3] / n[3]);
}


mat2x3 __operator + (const float a, const mat2x3 n) {
    return mat2x3 (a + n[0], a + n[1]);
}

mat2x3 __operator + (const mat2x3 m, const float b) {
    return mat2x3 (m[0] + b, m[1] + b);
}

mat2x4 __operator + (const float a, const mat2x4 n) {
    return mat2x4 (a + n[0], a + n[1]);
}

mat2x4 __operator + (const mat2x4 m, const float b) {
    return mat2x4 (m[0] + b, m[1] + b);
}

mat3x2 __operator + (const float a, const mat3x2 n) {
    return mat3x2 (a + n[0], a + n[1], a + n[2]);
}

mat3x2 __operator + (const mat3x2 m, const float b) {
    return mat3x2 (m[0] + b, m[1] + b, m[2] + b);
}

mat3x4 __operator + (const float a, const mat3x4 n) {
    return mat3x4 (a + n[0], a + n[1], a + n[2]);
}

mat3x4 __operator + (const mat3x4 m, const float b) {
    return mat3x4 (m[0] + b, m[1] + b, m[2] + b);
}

mat4x2 __operator + (const mat4x2 m, const float b) {
    return mat4x2 (m[0] + b, m[1] + b, m[2] + b, m[3] + b);
}

mat4x2 __operator + (const float a, const mat4x2 n) {
    return mat4x2 (a + n[0], a + n[1], a + n[2], a + n[3]);
}

mat4x3 __operator + (const mat4x3 m, const float b) {
    return mat4x3 (m[0] + b, m[1] + b, m[2] + b, m[3] + b);
}

mat4x3 __operator + (const float a, const mat4x3 n) {
    return mat4x3 (a + n[0], a + n[1], a + n[2], a + n[3]);
}


mat2x3 __operator - (const float a, const mat2x3 n) {
    return mat2x3 (a - n[0], a - n[1]);
}

mat2x3 __operator - (const mat2x3 m, const float b) {
    return mat2x3 (m[0] - b, m[1] - b);
}

mat2x4 __operator - (const float a, const mat2x4 n) {
    return mat2x4 (a - n[0], a - n[1]);
}

mat2x4 __operator - (const mat2x4 m, const float b) {
    return mat2x4 (m[0] - b, m[1] - b);
}

mat3x2 __operator - (const float a, const mat3x2 n) {
    return mat3x2 (a - n[0], a - n[1], a - n[2]);
}

mat3x2 __operator - (const mat3x2 m, const float b) {
    return mat3x2 (m[0] - b, m[1] - b, m[2] - b);
}

mat3x4 __operator - (const float a, const mat3x4 n) {
    return mat3x4 (a - n[0], a - n[1], a - n[2]);
}

mat3x4 __operator - (const mat3x4 m, const float b) {
    return mat3x4 (m[0] - b, m[1] - b, m[2] - b);
}

mat4x2 __operator - (const mat4x2 m, const float b) {
    return mat4x2 (m[0] - b, m[1] - b, m[2] - b, m[3] - b);
}

mat4x2 __operator - (const float a, const mat4x2 n) {
    return mat4x2 (a - n[0], a - n[1], a - n[2], a - n[3]);
}

mat4x3 __operator - (const mat4x3 m, const float b) {
    return mat4x3 (m[0] - b, m[1] - b, m[2] - b, m[3] - b);
}

mat4x3 __operator - (const float a, const mat4x3 n) {
    return mat4x3 (a - n[0], a - n[1], a - n[2], a - n[3]);
}


mat2x3 __operator * (const float a, const mat2x3 n)
{
   //return mat2x3 (a * n[0], a * n[1]);
   __retVal[0] = a * n[0];
   __retVal[1] = a * n[1];
}

mat2x3 __operator * (const mat2x3 m, const float b)
{
   //return mat2x3 (m[0] * b, m[1] * b);
   __retVal[0] = m[0] * b;
   __retVal[1] = m[1] * b;
}

mat2x4 __operator * (const float a, const mat2x4 n)
{
   //return mat2x4 (a * n[0], a * n[1]);
   __retVal[0] = a * n[0];
   __retVal[1] = a * n[1];
}

mat2x4 __operator * (const mat2x4 m, const float b)
{
   //return mat2x4 (m[0] * b, m[1] * b);
   __retVal[0] = m[0] * b;
   __retVal[1] = m[1] * b;
}

mat3x2 __operator * (const float a, const mat3x2 n)
{
   //return mat3x2 (a * n[0], a * n[1], a * n[2]);
   __retVal[0] = a * n[0];
   __retVal[1] = a * n[1];
   __retVal[2] = a * n[2];
}

mat3x2 __operator * (const mat3x2 m, const float b)
{
   //return mat3x2 (m[0] * b, m[1] * b, m[2] * b);
   __retVal[0] = m[0] * b;
   __retVal[1] = m[1] * b;
   __retVal[2] = m[2] * b;
}

mat3x4 __operator * (const float a, const mat3x4 n)
{
   //return mat3x4 (a * n[0], a * n[1], a * n[2]);
   __retVal[0] = a * n[0];
   __retVal[1] = a * n[1];
   __retVal[2] = a * n[2];
}

mat3x4 __operator * (const mat3x4 m, const float b)
{
   //return mat3x4 (m[0] * b, m[1] * b, m[2] * b);
   __retVal[0] = m[0] * b;
   __retVal[1] = m[1] * b;
   __retVal[2] = m[2] * b;
}

mat4x2 __operator * (const mat4x2 m, const float b)
{
   //return mat4x2 (m[0] * b, m[1] * b, m[2] * b, m[3] * b);
   __retVal[0] = m[0] * b;
   __retVal[1] = m[1] * b;
   __retVal[2] = m[2] * b;
   __retVal[3] = m[3] * b;
}

mat4x2 __operator * (const float a, const mat4x2 n)
{
   //return mat4x2 (a * n[0], a * n[1], a * n[2], a * n[3]);
   __retVal[0] = a * n[0];
   __retVal[1] = a * n[1];
   __retVal[2] = a * n[2];
   __retVal[3] = a * n[3];
}

mat4x3 __operator * (const mat4x3 m, const float b)
{
   //return mat4x3 (m[0] * b, m[1] * b, m[2] * b, m[3] * b);
   __retVal[0] = m[0] * b;
   __retVal[1] = m[1] * b;
   __retVal[2] = m[2] * b;
   __retVal[3] = m[3] * b;
}

mat4x3 __operator * (const float a, const mat4x3 n)
{
   //return mat4x3 (a * n[0], a * n[1], a * n[2], a * n[3]);
   __retVal[0] = a * n[0];
   __retVal[1] = a * n[1];
   __retVal[2] = a * n[2];
   __retVal[3] = a * n[3];
}


mat2x3 __operator / (const float a, const mat2x3 n)
{
   //return mat2x3 (a / n[0], a / n[1]);
   const float inv = 1.0 / a;
   __retVal[0] = inv * n[0];
   __retVal[1] = inv * n[1];
}

mat2x3 __operator / (const mat2x3 m, const float b)
{
   //return mat2x3 (m[0] / b, m[1] / b);
   const float inv = 1.0 / b;
   __retVal[0] = m[0] * inv;
   __retVal[1] = m[1] * inv;
}

mat2x4 __operator / (const float a, const mat2x4 n)
{
   //return mat2x4 (a / n[0], a / n[1]);
   const float inv = 1.0 / a;
   __retVal[0] = inv * n[0];
   __retVal[1] = inv * n[1];
}

mat2x4 __operator / (const mat2x4 m, const float b)
{
   //return mat2x4 (m[0] / b, m[1] / b);
   const float inv = 1.0 / b;
   __retVal[0] = m[0] * inv;
   __retVal[1] = m[1] * inv;
}

mat3x2 __operator / (const float a, const mat3x2 n)
{
   //return mat3x2 (a / n[0], a / n[1], a / n[2]);
   const float inv = 1.0 / a;
   __retVal[0] = inv * n[0];
   __retVal[1] = inv * n[1];
   __retVal[2] = inv * n[2];
}

mat3x2 __operator / (const mat3x2 m, const float b)
{
   //return mat3x2 (m[0] / b, m[1] / b, m[2] / b);
   const float inv = 1.0 / b;
   __retVal[0] = m[0] * inv;
   __retVal[1] = m[1] * inv;
   __retVal[2] = m[2] * inv;
}

mat3x4 __operator / (const float a, const mat3x4 n)
{
   //return mat3x4 (a / n[0], a / n[1], a / n[2]);
   const float inv = 1.0 / a;
   __retVal[0] = inv * n[0];
   __retVal[1] = inv * n[1];
   __retVal[2] = inv * n[2];
}

mat3x4 __operator / (const mat3x4 m, const float b)
{
   //return mat3x4 (m[0] / b, m[1] / b, m[2] / b);
   const float inv = 1.0 / b;
   __retVal[0] = m[0] * inv;
   __retVal[1] = m[1] * inv;
   __retVal[2] = m[2] * inv;
}

mat4x2 __operator / (const mat4x2 m, const float b)
{
   //return mat4x2 (m[0] / b, m[1] / b, m[2] / b, m[3] / b);
   const float inv = 1.0 / b;
   __retVal[0] = m[0] * inv;
   __retVal[1] = m[1] * inv;
   __retVal[2] = m[2] * inv;
   __retVal[3] = m[3] * inv;
}

mat4x2 __operator / (const float a, const mat4x2 n)
{
   //return mat4x2 (a / n[0], a / n[1], a / n[2], a / n[3]);
   const float inv = 1.0 / a;
   __retVal[0] = inv * n[0];
   __retVal[1] = inv * n[1];
   __retVal[2] = inv * n[2];
   __retVal[3] = inv * n[3];
}

mat4x3 __operator / (const mat4x3 m, const float b)
{
   //return mat4x3 (m[0] / b, m[1] / b, m[2] / b, m[3] / b);
   const float inv = 1.0 / b;
   __retVal[0] = m[0] * inv;
   __retVal[1] = m[1] * inv;
   __retVal[2] = m[2] * inv;
   __retVal[3] = m[3] * inv;
}

mat4x3 __operator / (const float a, const mat4x3 n)
{
   //return mat4x3 (a / n[0], a / n[1], a / n[2], a / n[3]);
   const float inv = 1.0 / a;
   __retVal[0] = inv * n[0];
   __retVal[1] = inv * n[1];
   __retVal[2] = inv * n[2];
   __retVal[3] = inv * n[3];
}


mat2x3 __operator - (const mat2x3 m) {
    return mat2x3 (-m[0], -m[1]);
}

mat2x4 __operator - (const mat2x4 m) {
    return mat2x4 (-m[0], -m[1]);
}

mat3x2 __operator - (const mat3x2 m) {
    return mat3x2 (-m[0], -m[1], -m[2]);
}

mat3x4 __operator - (const mat3x4 m) {
    return mat3x4 (-m[0], -m[1], -m[2]);
}

mat4x2 __operator - (const mat4x2 m) {
    return mat4x2 (-m[0], -m[1], -m[2], -m[3]);
}

mat4x3 __operator - (const mat4x3 m) {
    return mat4x3 (-m[0], -m[1], -m[2], -m[3]);
}


void __operator -- (inout mat2x3 m) {
    --m[0];
    --m[1];
}

void __operator -- (inout mat2x4 m) {
    --m[0];
    --m[1];
}

void __operator -- (inout mat3x2 m) {
    --m[0];
    --m[1];
    --m[2];
}

void __operator -- (inout mat3x4 m) {
    --m[0];
    --m[1];
    --m[2];
}

void __operator -- (inout mat4x2 m) {
    --m[0];
    --m[1];
    --m[2];
    --m[3];
}

void __operator -- (inout mat4x3 m) {
    --m[0];
    --m[1];
    --m[2];
    --m[3];
}


void __operator ++ (inout mat2x3 m) {
    ++m[0];
    ++m[1];
}

void __operator ++ (inout mat2x4 m) {
    ++m[0];
    ++m[1];
}

void __operator ++ (inout mat3x2 m) {
    ++m[0];
    ++m[1];
    ++m[2];
}

void __operator ++ (inout mat3x4 m) {
    ++m[0];
    ++m[1];
    ++m[2];
}

void __operator ++ (inout mat4x2 m) {
    ++m[0];
    ++m[1];
    ++m[2];
    ++m[3];
}

void __operator ++ (inout mat4x3 m) {
    ++m[0];
    ++m[1];
    ++m[2];
    ++m[3];
}