// Pass 2: clean ice. Refraction, chromatic shear, absorption by true path length.
// Nothing is added to empty space, so the gaps between sheets stay black.
precision highp float;
uniform vec2 u_res;
uniform float u_time;
uniform vec2 u_mouse; // normalized, bottom-left origin
uniform sampler2D u_scene;
uniform vec2 u_tile_res;

const float EXTENT = 3.8;                 // must match the plasma pass
const float FRONT  = -2.0;                // ice surface, camera at the origin looking down -z
const vec3  SIGMA  = vec3(0.66, 0.26, 0.11); // absorption per unit: red dies first, so depth turns blue
const float IOR    = 1.31;

float hash(vec2 p) { return fract(sin(dot(p, vec2(127.1, 311.7))) * 43758.5453); }
float noise(vec2 p) {
  vec2 i = floor(p), f = fract(p);
  f = f*f*(3.0-2.0*f);
  return mix(mix(hash(i), hash(i+vec2(1.0,0.0)), f.x),
             mix(hash(i+vec2(0.0,1.0)), hash(i+vec2(1.0,1.0)), f.x), f.y);
}
float fbm(vec2 p) {
  float sum = 0.0, amp = 0.5;
  for (int i = 0; i < 3; i++) { sum += amp * noise(p); p = mat2(1.62, 1.17, -1.17, 1.62) * p; amp *= 0.5; }
  return sum;
}
vec2 atlasUV(vec2 world, float layer) {
  vec2 uv = world / (2.0 * EXTENT) + 0.5;
  uv = clamp(uv, 0.5 / u_tile_res, 1.0 - 0.5 / u_tile_res); // keep bilinear taps inside the tile
  return (vec2(mod(layer, 4.0), floor(layer / 4.0)) + uv) / vec2(4.0, 2.0);
}
// Smooth frozen surface: two octaves, no bubbles, no grain.
float height(vec2 x) {
  return 0.15 * fbm(x * 1.3 + 2.0) + 0.05 * fbm(x * 3.7 - 5.0);
}
void main() {
  vec2 screen = gl_FragCoord.xy / u_res;
  vec2 p = (gl_FragCoord.xy - 0.5 * u_res) / u_res.y;
  vec2 look = clamp(u_mouse - 0.5, -0.35, 0.35); // orbiting the slab centre
  vec3 ray = normalize(vec3(p - look * 2.2, -1.6));

  // Front surface along the view ray; two fixed-point steps settle on the swell.
  float t = FRONT / ray.z;
  for (int i = 0; i < 2; i++) t = (FRONT + height(ray.xy * t)) / ray.z;
  vec3 hit = ray * t;

  float e = 0.02;
  vec2 slope = vec2(height(hit.xy + vec2(e, 0.0)) - height(hit.xy - vec2(e, 0.0)),
                    height(hit.xy + vec2(0.0, e)) - height(hit.xy - vec2(0.0, e))) / (2.0 * e);
  float bevel = smoothstep(0.14, 0.0, min(min(screen.x, 1.0 - screen.x), min(screen.y, 1.0 - screen.y)));
  slope += bevel * (screen - 0.5) * 0.55; // the slab turns away at the frame edge
  vec3 normal = normalize(vec3(-slope, 1.0));
  float facing = max(dot(-ray, normal), 0.0);

  // Refracted ray; red and blue bend a little differently, which is what makes ice ring.
  vec3 inside = refract(ray, normal, 1.0 / IOR);
  vec2 shearR = (refract(ray, normal, 1.0 / (IOR - 0.012)) - inside).xy;
  vec2 shearB = (refract(ray, normal, 1.0 / (IOR + 0.016)) - inside).xy;
  inside = normalize(inside);
  if (inside.z > -0.05) inside = vec3(0.0, 0.0, -1.0);

  // Recentre the parallax on the middle of the sheet stack: near and far sheets
  // then slide past each other at different rates as the pointer moves.
  vec2 par = look * 4.54;

  vec3 acc = vec3(0.0);
  float trans = 1.0;
  for (int i = 0; i < 8; i++) {
    float layer = float(i);
    float depth = texture2D(u_scene, atlasUV(hit.xy + par, layer)).a * 2.6; // depth buffer from pass 1
    float path = (hit.z - (FRONT - depth)) / -inside.z;                     // ice crossed to reach this sheet
    vec2 at = (hit + inside * path).xy + par;
    vec3 plasma;
    plasma.r = texture2D(u_scene, atlasUV(at + shearR * path, layer)).r;
    plasma.g = texture2D(u_scene, atlasUV(at, layer)).g;
    plasma.b = texture2D(u_scene, atlasUV(at + shearB * path, layer)).b;
    vec3 c = plasma * exp(-SIGMA * path);
    // Near plumes are nearly opaque, so the sheets behind them show through the gaps
    // instead of averaging into a wash. That is what makes the stack read as depth.
    float alpha = clamp(max(max(c.r, c.g), c.b) * 1.8, 0.0, 0.80);
    acc += trans * c;
    trans *= 1.0 - alpha;
  }

  // Gentle shoulder: overlapping glow stays coloured instead of clipping to white.
  vec3 col = vec3(1.0) - exp(-acc * 1.5);

  // Glass: reflection and a rim only where the surface turns away. Empty space stays dark.
  float fresnel = pow(1.0 - facing, 5.0);
  vec3 sky = mix(vec3(0.004, 0.016, 0.030), vec3(0.075, 0.220, 0.320), normal.y * 0.5 + 0.5);
  col += sky * (fresnel * 1.2 + bevel * 0.03);

  gl_FragColor = vec4(pow(clamp(col, 0.0, 1.0), vec3(0.4545)), 1.0);
}