Pandora's Fur

// ╔═════════════╦════════════════╗
// ║ Marco Gomez ║ https://mgz.me ║
// ╚═════════════╩════════════════╝
precision highp float;

uniform sampler2D prgm4Texture;
uniform sampler2D prgm5Texture;
uniform sampler2D prgm6Texture;
uniform vec2 resolution;
uniform float time;
uniform float fftNormalized;

float osc(float s, float e, float t, float ts) {
  return (e - s) / 2.0 + s + sin(t * ts) * (e - s) * 0.5;
}

void main(void) {
  vec2 uv = gl_FragCoord.xy / resolution.xy;
  vec4 prgm4 = texture2D(prgm4Texture, uv);
  vec4 prgm5 = texture2D(prgm5Texture, uv);
  vec4 prgm6 = texture2D(prgm6Texture, uv);
  gl_FragColor = mix(
    mix(prgm4, prgm5, osc(0.1, 0.6, time, 1.0) + fftNormalized * 0.4),
    prgm6,
    osc(0.1, 0.6, time, 0.5)
  );
}

// ╔═════════════╦════════════════╗
// ║ Marco Gomez ║ https://mgz.me ║
// ╚═════════════╩════════════════╝
precision highp float;

uniform sampler2D prgm2Texture;
uniform sampler2D noiseTexture;
uniform vec2 resolution;
uniform float time;
uniform int frame;
uniform float fftNormalized;

const float PI = acos(-1.0);
const float TAU = PI * 2.0;
const float hashScale = 0.1031;
const float bgWaveSpeed = 1.0;
const float xDistMag = 0.021;
const float yDistMag = 0.012;
const float xSineCycles = TAU;
const float ySineCycles = TAU;


float hash13(vec3 p3) {
  p3  = fract(p3 * hashScale);
  p3 += dot(p3, p3.yzx + 19.19);
  return fract((p3.x + p3.y) * p3.z);
}

float osc(float s, float e, float t, float ts) {
  return (e - s) / 2.0 + s + sin(t * ts) * (e - s) * 0.5;
}

mat2 rot(float a) {
  return mat2(cos(a), -sin(a), sin(a), cos(a));
}

void main(void) {
  vec2 uv = gl_FragCoord.xy / resolution.xy;
  float minRes = min(resolution.x, resolution.y);
  vec2 fc = gl_FragCoord.xy / minRes;
  float wt = time * bgWaveSpeed;
  float xAngle = wt + fc.y * ySineCycles;
  float yAngle = wt + fc.x * xSineCycles;
  bool bxHalf, byHalf;
  vec2 distortOffset = vec2(sin(xAngle), sin(yAngle)) * vec2(xDistMag, yDistMag);
  vec2 p = texture2D(prgm2Texture, uv).xy;
  float hash = hash13(vec3(gl_FragCoord.xy + float(frame), float(frame)));
  if (p == vec2(0.0)) {
    float h = hash;
    if (h > 2e-4) { return; }
    p = gl_FragCoord.xy + hash - 0.5;
  }
  float oA = osc(0.15, 0.65, time, 0.25) + fftNormalized * 0.3;
  float oB = osc(17.0, 30.0, time, 0.21);
  vec2 v = 2.0 * texture2D(noiseTexture, 0.03 * (uv * rot(distortOffset.y * oB)) + distortOffset * oA).xy - 1.0;
  gl_FragColor = vec4(clamp(p + v, 0.0, max(resolution.x, resolution.y)), 0.0, 1.0);
}

// ╔═════════════╦════════════════╗
// ║ Marco Gomez ║ https://mgz.me ║
// ╚═════════════╩════════════════╝
precision highp float;

uniform sampler2D prgm1Texture;
uniform vec2 resolution;
uniform float time;
uniform int frame;

void main(void) {
  gl_FragColor = vec4(0.0);
  for (int i = -1; i <= 1; i++) {
    for(int j = -1; j <= 1; j++) {
      vec4 c = texture2D(prgm1Texture, (gl_FragCoord.xy + vec2(i, j)) / resolution.xy);
      if (abs(c.x - gl_FragCoord.x) < 0.5 && abs(c.y - gl_FragCoord.y) < 0.5) {
        gl_FragColor = c;
        return;
      }
    }
  }
}

// ╔═════════════╦════════════════╗
// ║ Marco Gomez ║ https://mgz.me ║
// ╚═════════════╩════════════════╝
precision highp float;

uniform sampler2D prgm2Texture;
uniform sampler2D prgm3Texture;
uniform sampler2D noiseTexture;
uniform vec2 resolution;
uniform float time;
uniform int frame;

void main(void) {
  vec2 uv = gl_FragCoord.xy / resolution.xy;
  vec2 v = 2.0 * texture2D(noiseTexture, 0.03 * uv).xy - 1.0;
  float r = 0.96 * texture2D(prgm3Texture, uv).x;
  if (texture2D(prgm2Texture, uv).x > 0.0) { r = 1.0; }
  gl_FragColor = vec4(r, r * v.x, r * v.y, 1.0);
}

// ╔═════════════╦════════════════╗
// ║ Marco Gomez ║ https://mgz.me ║
// ╚═════════════╩════════════════╝
precision highp float;

uniform sampler2D prgm1Texture;
uniform sampler2D prgm3Texture;
uniform vec2 resolution;
uniform float time;
uniform int frame;

float osc(float s, float e, float t, float ts) {
  return (e - s) / 2.0 + s + sin(t * ts) * (e - s) * 0.5;
}

vec3 hue(vec3 col, float a) {
  const vec3 k = vec3(0.57735, 0.57735, 0.57735);
  float c = cos(a);
  return col * c + cross(k, col) * sin(a) + k * dot(k, col) * (1.0 - c);
}

void main(void) {
  vec2 uv = gl_FragCoord.xy / resolution.xy;
  vec4 prgm1 = texture2D(prgm1Texture, uv);
  vec4 prgm3 = texture2D(prgm3Texture, uv);
  float prgm3x = prgm3.x;
  prgm3x = 0.9 - 0.8 * prgm3x;
  vec3 colA = vec3(prgm1.x * 0.75, 0.0, 1.0 - prgm3x);
  vec3 colB = vec3(0.0, 0.5 - prgm3x, prgm3.x * 0.25);
  float m = mix(prgm3.x, 0.5 - prgm3.y, clamp(osc(-1.0, 2.0, 1.0-prgm3.z, 1.0), 0.3, 0.7));
  vec3 col = clamp(mix(colA, colB, m * m * m) * 2.0, 0.03, 0.9);
  col = clamp(mix(col, hue(col, prgm3.y * 3.0), 0.75), 0.0, 1.0);
  col = clamp(mix(col, prgm3.xxx, 0.5), 0.0, 1.0);
  gl_FragColor = vec4(col, 1.0);
}

// ╔═════════════╦════════════════╗
// ║ Marco Gomez ║ https://mgz.me ║
// ╚═════════════╩════════════════╝
precision highp float;

uniform sampler2D prgm4Texture;
uniform vec2 resolution;
uniform float time;
uniform float fft;

const float amount = 1.0;
const float reinhardAmount = 1.0;
const float contrast = 0.9;
const float brightness = 1.7;
const float saturation = 1.0;
const vec2 vignetteSize = vec2(0.25, 0.25);
const float vignetteRoundness = 0.12;
const float vignetteMix = 1.0;
const float vignetteSmoothness = 0.42;
const float W = 1.2;
const float T = 7.5;

float filmicReinhardCurve(float x) {
  float q = (T * T + 1.0) * x * x;
  return q / (q + x + T * T);
}

vec3 filmicReinhard(vec3 c) {
  float w = filmicReinhardCurve(W);
  return vec3(
    filmicReinhardCurve(c.r),
    filmicReinhardCurve(c.g),
    filmicReinhardCurve(c.b)
  ) / w;
}

vec3 ContrastSaturationBrightness(vec3 color, float brt, float sat, float con) {
  const float AvgLumR = 0.5;
  const float AvgLumG = 0.5;
  const float AvgLumB = 0.5;
  const vec3 LumCoeff = vec3(0.2125, 0.7154, 0.0721);
  vec3 AvgLumin = vec3(AvgLumR, AvgLumG, AvgLumB);
  vec3 brtColor = color * brt;
  vec3 intensity = vec3(dot(brtColor, LumCoeff));
  vec3 satColor = mix(intensity, brtColor, sat);
  vec3 conColor = mix(AvgLumin, satColor, con);
  return conColor;
}

float sdSquare(vec2 point, float width) {
  vec2 d = abs(point) - width;
  return min(max(d.x, d.y), 0.0) + length(max(d, 0.0));
}

float vignette(vec2 uv, vec2 size, float roundness, float smoothness) {
  uv -= 0.5;
  float minWidth = min(size.x, size.y);
  uv.x = sign(uv.x) * clamp(abs(uv.x) - abs(minWidth - size.x), 0.0, 1.0);
  uv.y = sign(uv.y) * clamp(abs(uv.y) - abs(minWidth - size.y), 0.0, 1.0);
  float boxSize = minWidth * (1.0 - roundness);
  float dist = sdSquare(uv, boxSize) - (minWidth * roundness);
  return 1.0 - smoothstep(0.0, smoothness, dist);
}

void main(void) {
  vec2 uv = gl_FragCoord.xy / resolution.xy;
  vec4 prgm4 = texture2D(prgm4Texture, uv);
  vec3 reinhard = filmicReinhard(prgm4.rgb);
  vec3 color = prgm4.rgb;
  color = mix(prgm4.rgb, reinhard, reinhardAmount);
  color = ContrastSaturationBrightness(color, brightness, saturation, contrast);
  float v = vignette(uv, vignetteSize, vignetteRoundness, vignetteSmoothness);
  vec3 vig = color * v;
  color = mix(color, vig, vignetteMix);
  color = mix(prgm4.xyz, color, amount);
  color = clamp(color, 0.0, 1.0);
  gl_FragColor = vec4(color, 1.0);
}

// ╔═════════════╦════════════════╗
// ║ Marco Gomez ║ https://mgz.me ║
// ╚═════════════╩════════════════╝
precision highp float;

uniform sampler2D prgm2Texture;
uniform sampler2D prgm5Texture;
uniform vec2 resolution;

void main() {
  vec2 uv = gl_FragCoord.xy / resolution.xy;
  vec4 color = texture2D(prgm5Texture, uv);
  vec4 prgm2 = texture2D(prgm2Texture, uv);
  float pb = 0.4;
  vec4 lcdColor = vec4(pb, pb, pb, 1.0);
  int px = int(mod(gl_FragCoord.x, 3.0));
  if (px == 1) lcdColor.r = 1.0;
  else if (px == 2) lcdColor.g = 1.0;
  else lcdColor.b = 1.0;
  float sclV = 0.25;
  if (int(mod(gl_FragCoord.y - 0.5, 3.0)) == 0) lcdColor.rgb = vec3(sclV, sclV, sclV);
  if (
    int(mod(gl_FragCoord.y - 0.5, 2.0)) == 0 ||
    int(mod(gl_FragCoord.x - 0.5, 2.0)) == 0
  ) lcdColor = vec4((prgm2.xxx / (prgm2.yyy + 1e-3)), 1.0);
  gl_FragColor = mix(color, color * lcdColor, 0.5);
}