dump_glsl.comp

#version 410
out vec4 fragColor;

uniform mat4 uIdentityM;
uniform mat4 uMatA;
uniform mat4 uMatB;
uniform mat4 uScaleM;
uniform mat4 uTranslateM;
uniform mat4 uRotateXM;
uniform mat4 uRotateYM;
uniform mat4 uRotateZM;
uniform mat4 uAxisMat;
uniform mat4 uHardMat;
uniform vec3 uVecA;
uniform vec4 uVecB;
uniform mat2 uMat2A;
uniform mat2 uMat2B;
uniform mat3 uMat3A;
uniform mat3 uMat3B;
uniform vec2 uVec2A;
uniform vec2 uVec2B;
uniform vec3 uVec3C;

const float angleA = radians(37.0);
const float angleB = radians(-23.0);
const float angleC = radians(71.0);
const float axisAngle = radians(48.0);
const float rotAngle2D = radians(45.0);

mat4 identityM() {
  return uIdentityM;
}

mat4 matA() {
  return uMatA;
}

mat4 matB() {
  return uMatB;
}

vec3 vecA() {
  return uVecA;
}

vec4 vecB() {
  return uVecB;
}

mat2 mat2A() {
  return uMat2A;
}

mat2 mat2B() {
  return uMat2B;
}

mat3 mat3A() {
  return uMat3A;
}

mat3 mat3B() {
  return uMat3B;
}

vec2 vec2A() {
  return uVec2A;
}

vec2 vec2B() {
  return uVec2B;
}

vec3 vec3C() {
  return uVec3C;
}

mat4 scaleM() {
  return uScaleM;
}

mat4 translateM() {
  return uTranslateM;
}

mat4 rotateXM() {
  return uRotateXM;
}

mat4 rotateYM() {
  return uRotateYM;
}

mat4 rotateZM() {
  return uRotateZM;
}

mat4 pureRotationM() {
  return rotateZM() * rotateYM() * rotateXM();
}

vec3 axisNormalized() {
  return normalize(vec3(1.0, 2.0, -3.0));
}

vec4 quatIdentity() {
  return vec4(0.0, 0.0, 0.0, 1.0);
}

vec4 quatAxisAngle(vec3 axis, float angle) {
  vec3 a = normalize(axis);
  float s = sin(angle * 0.5);
  return vec4(a * s, cos(angle * 0.5));
}

vec4 quatX() {
  return quatAxisAngle(vec3(1.0, 0.0, 0.0), angleA);
}

vec4 quatY() {
  return quatAxisAngle(vec3(0.0, 1.0, 0.0), angleB);
}

vec4 quatZ() {
  return quatAxisAngle(vec3(0.0, 0.0, 1.0), angleC);
}

vec4 axisQuat() {
  return quatAxisAngle(axisNormalized(), axisAngle);
}

vec4 quatMultiply(vec4 a, vec4 b) {
  return vec4(
    a.w * b.x + a.x * b.w + a.y * b.z - a.z * b.y,
    a.w * b.y + a.y * b.w + a.z * b.x - a.x * b.z,
    a.w * b.z + a.z * b.w + a.x * b.y - a.y * b.x,
    a.w * b.w - a.x * b.x - a.y * b.y - a.z * b.z
  );
}

vec3 quatRotate(vec4 q, vec3 v) {
  vec3 uv = cross(q.xyz, v);
  vec3 uuv = cross(q.xyz, uv);
  return v + ((uv * q.w) + uuv) * 2.0;
}

mat4 quatMat4(vec4 q) {
  float xx = q.x * q.x;
  float xy = q.x * q.y;
  float xz = q.x * q.z;
  float xw = q.x * q.w;
  float yy = q.y * q.y;
  float yz = q.y * q.z;
  float yw = q.y * q.w;
  float zz = q.z * q.z;
  float zw = q.z * q.w;

  return mat4(
    vec4(1.0 - 2.0 * (yy + zz), 2.0 * (xy + zw), 2.0 * (xz - yw), 0.0),
    vec4(2.0 * (xy - zw), 1.0 - 2.0 * (xx + zz), 2.0 * (yz + xw), 0.0),
    vec4(2.0 * (xz + yw), 2.0 * (yz - xw), 1.0 - 2.0 * (xx + yy), 0.0),
    vec4(0.0, 0.0, 0.0, 1.0)
  );
}

vec4 mat4Quat(mat4 m) {
  float m00 = m[0][0];
  float m11 = m[1][1];
  float m22 = m[2][2];

  float fourXSquaredMinus1 = m00 - m11 - m22;
  float fourYSquaredMinus1 = m11 - m00 - m22;
  float fourZSquaredMinus1 = m22 - m00 - m11;
  float fourWSquaredMinus1 = m00 + m11 + m22;

  int biggestIndex = 0;
  float fourBiggestSquaredMinus1 = fourWSquaredMinus1;
  if (fourXSquaredMinus1 > fourBiggestSquaredMinus1) {
    fourBiggestSquaredMinus1 = fourXSquaredMinus1;
    biggestIndex = 1;
  }
  if (fourYSquaredMinus1 > fourBiggestSquaredMinus1) {
    fourBiggestSquaredMinus1 = fourYSquaredMinus1;
    biggestIndex = 2;
  }
  if (fourZSquaredMinus1 > fourBiggestSquaredMinus1) {
    fourBiggestSquaredMinus1 = fourZSquaredMinus1;
    biggestIndex = 3;
  }

  float biggestVal = sqrt(fourBiggestSquaredMinus1 + 1.0) * 0.5;
  float mult = 0.25 / biggestVal;
  vec4 q = vec4(0.0);

  if (biggestIndex == 0) {
    q.w = biggestVal;
    q.x = (m[1][2] - m[2][1]) * mult;
    q.y = (m[2][0] - m[0][2]) * mult;
    q.z = (m[0][1] - m[1][0]) * mult;
  } else if (biggestIndex == 1) {
    q.w = (m[1][2] - m[2][1]) * mult;
    q.x = biggestVal;
    q.y = (m[0][1] + m[1][0]) * mult;
    q.z = (m[2][0] + m[0][2]) * mult;
  } else if (biggestIndex == 2) {
    q.w = (m[2][0] - m[0][2]) * mult;
    q.x = (m[0][1] + m[1][0]) * mult;
    q.y = biggestVal;
    q.z = (m[1][2] + m[2][1]) * mult;
  } else {
    q.w = (m[0][1] - m[1][0]) * mult;
    q.x = (m[2][0] + m[0][2]) * mult;
    q.y = (m[1][2] + m[2][1]) * mult;
    q.z = biggestVal;
  }

  return q;
}

mat4 axisMat() {
  return uAxisMat;
}

mat4 transformM() {
  return translateM() * rotateZM() * rotateYM() * rotateXM() * scaleM();
}

mat4 rotationOnly(mat4 m) {
  m[3] = vec4(0.0, 0.0, 0.0, 1.0);
  return m;
}

vec3 hardAxis() {
  return normalize(vec3(1.0, -2.0, 3.0));
}

vec4 hardQuat() {
  return quatAxisAngle(hardAxis(), radians(170.0));
}

mat4 hardMat() {
  return uHardMat;
}

mat4 frustumM(float left, float right, float bottom, float top, float nearV, float farV) {
  float rl = right - left;
  float tb = top - bottom;
  float fn = farV - nearV;
  return mat4(
    vec4((nearV * 2.0) / rl, 0.0, 0.0, 0.0),
    vec4(0.0, (nearV * 2.0) / tb, 0.0, 0.0),
    vec4((right + left) / rl, (top + bottom) / tb, -(farV + nearV) / fn, -1.0),
    vec4(0.0, 0.0, -(farV * nearV * 2.0) / fn, 0.0)
  );
}

mat4 perspectiveM(float fovyDeg, float aspect, float nearV, float farV) {
  float top = nearV * tan(fovyDeg * 3.14159265359 / 360.0);
  float right = top * aspect;
  return frustumM(-right, right, -top, top, nearV, farV);
}

mat4 orthoM(float left, float right, float bottom, float top, float nearV, float farV) {
  float rl = right - left;
  float tb = top - bottom;
  float fn = farV - nearV;
  return mat4(
    vec4(2.0 / rl, 0.0, 0.0, 0.0),
    vec4(0.0, 2.0 / tb, 0.0, 0.0),
    vec4(0.0, 0.0, -2.0 / fn, 0.0),
    vec4(-(left + right) / rl, -(top + bottom) / tb, -(farV + nearV) / fn, 1.0)
  );
}

mat4 lookAtM(vec3 eye, vec3 center, vec3 up) {
  if (all(equal(eye, center))) {
    return identityM();
  }

  vec3 z = normalize(eye - center);
  vec3 x = cross(up, z);
  if (length(x) == 0.0) {
    x = vec3(0.0);
  } else {
    x = normalize(x);
  }
  vec3 y = cross(z, x);

  return mat4(
    vec4(x.x, y.x, z.x, 0.0),
    vec4(x.y, y.y, z.y, 0.0),
    vec4(x.z, y.z, z.z, 0.0),
    vec4(-dot(x, eye), -dot(y, eye), -dot(z, eye), 1.0)
  );
}

vec4 quatInverse(vec4 q) {
  float d = dot(q, q);
  return vec4(-q.x / d, -q.y / d, -q.z / d, q.w / d);
}

vec3 orthogonalV(vec3 v) {
  vec3 av = abs(v);
  vec3 other;
  if (av.x < av.y) {
    other = av.x < av.z ? vec3(1.0, 0.0, 0.0) : vec3(0.0, 0.0, 1.0);
  } else {
    other = av.y < av.z ? vec3(0.0, 1.0, 0.0) : vec3(0.0, 0.0, 1.0);
  }
  return cross(av, other);
}

vec4 fromTwoVectorsQ(vec3 a, vec3 b) {
  vec3 u = normalize(b);
  vec3 v = normalize(a);
  if (all(equal(u, -v))) {
    vec3 q = normalize(orthogonalV(u));
    return vec4(q.x, q.y, q.z, 0.0);
  }
  vec3 halfV = normalize(u + v);
  vec3 q = cross(v, halfV);
  float w = dot(v, halfV);
  return vec4(q.x, q.y, q.z, w);
}

vec4 slerpQ(vec4 a, vec4 b, float t) {
  vec4 z = b;
  float cosTheta = dot(a, b);
  if (cosTheta < 0.0) {
    z = -b;
    cosTheta = -cosTheta;
  }
  if (cosTheta > 1.0 - 1e-6) {
    return vec4(
      a.x + (z.x - a.x) * t,
      a.y + (z.y - a.y) * t,
      a.z + (z.z - a.z) * t,
      a.w + (z.w - a.w) * t
    );
  } else {
    float angle = acos(cosTheta);
    return (sin((1.0 - t) * angle) * a + sin(t * angle) * z) / sin(angle);
  }
}

vec3 quatAxisOnly(vec4 q) {
  float cosAngle = q.w;
  float sinAngle = sqrt(max(0.0, 1.0 - cosAngle * cosAngle));
  if (abs(sinAngle) < 0.0005) {
    sinAngle = 1.0;
  }
  return vec3(q.x / sinAngle, q.y / sinAngle, q.z / sinAngle);
}

float quatAngleOnly(vec4 q) {
  return acos(q.w) * 2.0;
}

vec3 quatToAngles(vec4 q) {
  float x = q.x;
  float y = q.y;
  float z = q.z;
  float w = q.w;
  return vec3(
    atan(2.0 * (w * x + y * z), 1.0 - 2.0 * (x * x + y * y)),
    asin(2.0 * (w * y - z * x)),
    atan(2.0 * (w * z + x * y), 1.0 - 2.0 * (y * y + z * z))
  );
}

mat3 scale2D(vec2 s) {
  return mat3(
    vec3(s.x, 0.0, 0.0),
    vec3(0.0, s.y, 0.0),
    vec3(0.0, 0.0, 1.0)
  );
}

mat3 translate2D(vec2 t) {
  return mat3(
    vec3(1.0, 0.0, 0.0),
    vec3(0.0, 1.0, 0.0),
    vec3(t.x, t.y, 1.0)
  );
}

mat3 rotate2D(float angle) {
  float c = cos(angle);
  float s = sin(angle);
  return mat3(
    vec3(c, s, 0.0),
    vec3(-s, c, 0.0),
    vec3(0.0, 0.0, 1.0)
  );
}

void main() {
  __MAIN_BODY__
}