/*{
  "DESCRIPTION": "Clifford Cage: the 24-cell — a regular 4-dimensional polytope with no 3D analog — drawn as a glowing wireframe. It tumbles by a true isoclinic (Clifford) double-rotation in 4-space and is perspective-projected to 3D, so edges swell and shrink as they swing toward and away through the 4th dimension. The rotation returns to start after one turn: a seamless 16s loop.",
  "CREDIT": "glslop agent (Claude)",
  "CATEGORIES": ["4D", "polytope", "wireframe", "neon", "geometry"],
  "INPUTS": [
    { "NAME": "speed", "TYPE": "float", "DEFAULT": 1.0,  "MIN": 0.0,  "MAX": 3.0 },
    { "NAME": "glow",  "TYPE": "float", "DEFAULT": 1.0,  "MIN": 0.3,  "MAX": 3.0 },
    { "NAME": "hue",   "TYPE": "float", "DEFAULT": 0.0,  "MIN": 0.0,  "MAX": 1.0 },
    { "NAME": "tube",  "TYPE": "float", "DEFAULT": 0.04, "MIN": 0.012,"MAX": 0.1  },
    { "NAME": "zoom",  "TYPE": "float", "DEFAULT": 1.0,  "MIN": 0.5,  "MAX": 2.0 }
  ]
}*/

#define PI  3.14159265359
#define TAU 6.28318530718
#define NV  24

const float PERIOD = 16.0;

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

vec3 pal(float t){
  return 0.5 + 0.5 * cos(TAU * (t + vec3(0.0, 0.33, 0.66)));
}

// the 24 vertices of the 24-cell: all permutations of (+-1,+-1,0,0)
vec4 vert24(int k){
  int pp = k / 4;
  int ss = k - pp * 4;
  float s0 = mod(float(ss), 2.0) * 2.0 - 1.0;
  float s1 = floor(float(ss) / 2.0) * 2.0 - 1.0;
  if (pp == 0) return vec4(s0, s1, 0.0, 0.0);
  if (pp == 1) return vec4(s0, 0.0, s1, 0.0);
  if (pp == 2) return vec4(s0, 0.0, 0.0, s1);
  if (pp == 3) return vec4(0.0, s0, s1, 0.0);
  if (pp == 4) return vec4(0.0, s0, 0.0, s1);
  return vec4(0.0, 0.0, s0, s1);
}

// min distance from ray (ro,rd unit) to segment [A,B]; returns dist, writes t along ray
float segDist(vec3 ro, vec3 rd, vec3 A, vec3 B, out float tray){
  vec3 d2 = B - A;
  vec3 r  = ro - A;
  float e = dot(d2, d2);
  float f = dot(d2, r);
  float b = dot(rd, d2);
  float c = dot(rd, r);
  float den = e - b * b;                       // a=dot(rd,rd)=1
  float s = (den > 1e-5) ? (b * f - c * e) / den : 0.0;
  s = max(s, 0.0);
  float u = clamp((b * s + f) / e, 0.0, 1.0);
  s = max(dot(A + d2 * u - ro, rd), 0.0);
  tray = s;
  vec3 pr = ro + rd * s;
  vec3 ps = A + d2 * u;
  return length(pr - ps);
}

void main(){
  vec2 uv = (gl_FragCoord.xy - 0.5 * RENDERSIZE.xy) / RENDERSIZE.y;

  float ph = fract(TIME * speed / PERIOD);
  float th = TAU * ph;

  // ---- build & transform the 24 vertices (rotate in 4D, project to 3D) ----
  vec4  base[NV];
  vec3  proj[NV];
  float rotw[NV];
  for (int k = 0; k < NV; k++){
    vec4 v = vert24(k);
    base[k] = v;
    // fixed tilt that mixes all four axes so the isoclinic spin is legible
    v.xz = rot(0.62) * v.xz;
    v.yw = rot(1.13) * v.yw;
    // isoclinic (Clifford) rotation: xy and zw turn by the SAME angle
    v.xy = rot(th) * v.xy;
    v.zw = rot(th) * v.zw;
    rotw[k] = v.w;                              // 4th-dim depth -> drives colour
    proj[k] = v.xyz / (2.6 - v.w);             // 4D perspective projection
  }

  // ---- camera ----
  vec3 ro = vec3(0.0, 0.0, 3.4 / zoom);
  vec3 ta = vec3(0.0);
  vec3 ww = normalize(ta - ro);
  vec3 uu = normalize(cross(vec3(0.0, 1.0, 0.0), ww));
  vec3 vv = cross(ww, uu);
  vec3 rd = normalize(uv.x * uu + uv.y * vv + 1.6 * ww);

  // ---- draw edges: pairs at 4D squared-distance 2 are connected ----
  float w0 = tube * tube;
  vec3 col = vec3(0.0);
  for (int i = 0; i < NV; i++){
    for (int j = 0; j < NV; j++){
      if (j <= i) continue;
      vec4 dv = base[i] - base[j];
      if (abs(dot(dv, dv) - 2.0) > 0.05) continue;   // not an edge
      float tray;
      float d = segDist(ro, rd, proj[i], proj[j], tray);
      float g = w0 / (d * d + w0);
      g = g * g;                                       // thin bright cores
      float fog = exp(-0.22 * max(tray - 2.0, 0.0));   // depth cue
      float wMid = 0.5 * (rotw[i] + rotw[j]);          // 4D depth of this edge
      col += pal(hue + ph + 0.30 * wMid) * g * fog * 0.9;
    }
  }

  col *= glow;
  col += vec3(0.85, 0.92, 1.0) * pow(max(max(col.r, col.g), col.b) * 0.45, 3.0);

  col = col / (1.0 + col);
  col = pow(col, vec3(0.82));
  col *= 1.0 - 0.16 * dot(uv, uv);

  gl_FragColor = vec4(col, 1.0);
}