/*{
  "DESCRIPTION": "Solar Iris Reliquary — a clean-room Superflow-inspired recursive harmonic hero object. Three phased cyan, magenta, and amber layers guard a contained solar nucleus in a seamless 10 second loop. CC0.",
  "INPUTS": [
    { "NAME": "glow", "TYPE": "float", "DEFAULT": 1.0, "MIN": 0.5, "MAX": 1.5 }
  ]
}*/

/*
  CANONICAL LINEAGE / ENGINE LOWERING
  preset: solar-iris-tunnel
  build_identity: superflow:1.0.0:solar-iris-tunnel:3e6a8774046d
  manifest_sha256: 3e6a8774046d892281d8cb77a9e07b7f16e6d35ffa37df27776d8cbfb229111e
  schema_version: 1.0.0
  composition_locus: procedural_transform_led
  seed: null
  seed_policy: not_applicable
  fidelity: unverified_engine_lowering (ISF / GLSL ES 1.00, clean-room)
  motion: fixed camera; outer +1, middle -2, inner +3 turns per 10 second loop
*/

#define PI 3.14159265359
#define TAU 6.28318530718
#define PERIOD 10.0

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

float smin(float a, float b, float k){
  float h=clamp(0.5+0.5*(b-a)/k,0.0,1.0);
  return mix(b,a,h)-k*h*(1.0-h);
}

float sdSphere(vec3 p, float r){ return length(p)-r; }

float sdCapsule(vec3 p, vec3 a, vec3 b, float r){
  vec3 pa=p-a, ba=b-a;
  float h=clamp(dot(pa,ba)/dot(ba,ba),0.0,1.0);
  return length(pa-ba*h)-r;
}

float sdTorus(vec3 p, vec2 t){
  return length(vec2(length(p.xy)-t.x,p.z))-t.y;
}

float sdEllipsoid(vec3 p, vec3 r){
  float k0=length(p/r);
  float k1=length(p/(r*r));
  return k0*(k0-1.0)/max(k1,0.0001);
}

float repeatedBead(vec3 p, float radius, float count, vec3 size, float phase){
  float a=atan(p.y,p.x)+phase;
  float cell=TAU/count;
  float idx=floor((a+PI)/cell);
  a=mod(a+0.5*cell,cell)-0.5*cell;
  float swell=0.82+0.18*sin(idx*2.17+0.7);
  float lift=0.035*sin(idx*1.37+1.2);
  vec3 q=vec3(length(p.xy)-radius-lift,a*radius,p.z);
  return sdEllipsoid(q,size*vec3(swell,1.0/swell,0.88+0.12*swell));
}

float repeatedRib(vec3 p, float count, float phase, vec3 a, vec3 b, float radius){
  float ang=atan(p.y,p.x)+phase;
  float cell=TAU/count;
  ang=mod(ang+0.5*cell,cell)-0.5*cell;
  float rr=length(p.xy);
  vec3 q=vec3(rr*cos(ang),rr*sin(ang),p.z);
  return sdCapsule(q,a,b,radius);
}

float repeatedPetal(vec3 p,float radius,float count,vec3 size,float phase,
                    float zStagger,float lobe,float twist){
  float raw=atan(p.y,p.x)+phase;
  float cell=TAU/count;
  float idx=floor((raw+PI)/cell);
  float a=mod(raw+0.5*cell,cell)-0.5*cell;
  float swell=0.84+0.16*sin(idx*2.17+0.7);
  float rr=radius+lobe*sin(3.0*raw+0.45)+0.025*sin(idx*1.37);
  vec3 q=vec3(length(p.xy)-rr,a*radius,p.z-zStagger*sin(idx*1.61+0.3));
  q.xy=rot(twist+0.24*sin(idx*1.23))*q.xy;
  vec3 n=abs(q)/(size*vec3(swell,1.0/swell,0.92+0.08*swell));
  float f=pow(n.x,1.28)+n.y*n.y+n.z*n.z-1.0;
  return f*min(size.x,min(size.y,size.z))*0.48;
}

float sdOctahedron(vec3 p,float s){
  p=abs(p);
  return (p.x+p.y+p.z-s)*0.57735027;
}

vec2 opU(vec2 a, vec2 b){ return (a.x<b.x)?a:b; }

vec3 objectSpace(vec3 p){
  p.xz=rot(-0.46)*p.xz;
  p.yz=rot(0.56)*p.yz;
  return p;
}

vec2 mapScene(vec3 world, float th){
  vec3 p=objectSpace(world);
  vec2 res=vec2(1e5,0.0);

  // Outer cyan reliquary: articulated petal chain with integrated radial ribs.
  vec3 q1=p; q1.xy=rot(th)*q1.xy;
  q1.z+=0.15*sin(atan(q1.y,q1.x)+0.5);
  float outerPetals=repeatedPetal(q1,1.16,19.0,vec3(0.116,0.155,0.092),
                                  0.0,0.180,0.090,0.48);
  float outerRibs=repeatedRib(q1,19.0,0.0,
    vec3(1.03,-0.030,-0.020),vec3(1.18,0.035,0.030),0.030);
  float outer=smin(outerPetals,outerRibs,0.028);
  res=opU(res,vec2(outer,1.0));

  // Middle magenta dot-field: denser, counter-rotating, visibly recessed.
  vec3 q2=p; q2.xy=rot(-2.0*th+0.38)*q2.xy; q2.z+=0.13;
  q2.z+=0.105*sin(atan(q2.y,q2.x)-0.8);
  float midPetals=repeatedPetal(q2,0.87,23.0,vec3(0.098,0.112,0.075),
                                0.0,0.125,0.052,-0.34);
  float midRibs=repeatedRib(q2,23.0,0.0,
    vec3(0.78,0.025,-0.015),vec3(0.89,-0.032,0.022),0.022);
  float middle=smin(midPetals,midRibs,0.022);
  res=opU(res,vec2(middle,2.0));

  // Inner amber rib band: smallest primary hierarchy around the aperture.
  vec3 q3=p; q3.xy=rot(3.0*th-0.43)*q3.xy; q3.z+=0.22;
  q3.z+=0.075*sin(atan(q3.y,q3.x)+1.7);
  float innerPetals=repeatedPetal(q3,0.59,17.0,vec3(0.077,0.082,0.060),
                                  0.0,0.090,0.035,0.30);
  float irisRibs=repeatedRib(q3,17.0,0.0,
    vec3(0.52,-0.020,-0.010),vec3(0.60,0.025,0.016),0.017);
  float inner=smin(innerPetals,irisRibs,0.017);
  res=opU(res,vec2(inner,3.0));

  // Micro hierarchy: a fine amber bead collar, deliberately discontinuous.
  vec3 q4=p; q4.xy=rot(-3.0*th+0.61)*q4.xy; q4.z+=0.28;
  float micro=repeatedBead(q4,0.39,31.0,vec3(0.038,0.022,0.034),0.0);
  res=opU(res,vec2(micro,3.0));

  // Recessed faceted solar jewel with a sparse micro-corona; black remains around it.
  vec3 c=p-vec3(0.0,0.0,-0.43);
  c.xy=rot(0.33+th)*c.xy;
  c.xz=rot(0.28*sin(th))*c.xz;
  vec3 cj=c/vec3(1.28,0.72,1.0);
  float jewel=sdOctahedron(cj,0.255)*0.72;
  vec3 qc=c; qc.z+=0.025;
  float corona=repeatedBead(qc,0.270,9.0,vec3(0.030,0.020,0.026),0.0);
  res=opU(res,vec2(min(jewel,corona),4.0));

  // Dark metallic aperture lip physically houses the recessed jewel.
  vec3 lip=p; lip.z+=0.31;
  float apertureLip=sdTorus(lip,vec2(0.345,0.060));
  res=opU(res,vec2(apertureLip,6.0));
  return res;
}

vec3 calcNormal(vec3 p,float th){
  float e=0.0015;
  vec2 h=vec2(1.0,-1.0)*0.5773;
  return normalize(h.xyy*mapScene(p+h.xyy*e,th).x+
                   h.yyx*mapScene(p+h.yyx*e,th).x+
                   h.yxy*mapScene(p+h.yxy*e,th).x+
                   h.xxx*mapScene(p+h.xxx*e,th).x);
}

float softShadow(vec3 ro,vec3 rd,float mint,float maxt,float th){
  float shade=1.0,t=mint;
  for(int i=0;i<36;i++){
    float h=mapScene(ro+rd*t,th).x;
    shade=min(shade,14.0*h/t);
    t+=clamp(h,0.015,0.16);
    if(h<0.0007||t>maxt) break;
  }
  return clamp(shade,0.0,1.0);
}

float ambientOcclusion(vec3 p,vec3 n,float th){
  float occ=0.0,sca=1.0;
  for(int i=0;i<5;i++){
    float h=0.025+0.075*float(i);
    float d=mapScene(p+n*h,th).x;
    occ+=(h-d)*sca;
    sca*=0.63;
  }
  return clamp(1.0-2.15*occ,0.0,1.0);
}

vec3 materialColor(float id){
  if(id<1.5) return vec3(0.012,0.36,0.43);
  if(id<2.5) return vec3(0.48,0.012,0.27);
  if(id<3.5) return vec3(0.62,0.15,0.012);
  if(id<4.5) return vec3(0.74,0.23,0.018);
  if(id<5.5) return vec3(0.10,0.52,0.58);
  return vec3(0.018,0.030,0.065);
}

vec3 fresnelSchlick(float cosTheta,vec3 f0){
  return f0+(1.0-f0)*pow(1.0-clamp(cosTheta,0.0,1.0),5.0);
}

float distributionGGX(float noH,float rough){
  float a=rough*rough;
  float a2=a*a;
  float d=noH*noH*(a2-1.0)+1.0;
  return a2/max(PI*d*d,0.0001);
}

float geometrySchlickGGX(float noX,float rough){
  float k=(rough+1.0); k=k*k*0.125;
  return noX/max(noX*(1.0-k)+k,0.0001);
}

vec3 directBRDF(vec3 base,vec3 f0,float metal,float rough,
                vec3 n,vec3 v,vec3 l,vec3 radiance){
  vec3 h=normalize(v+l);
  float noL=max(dot(n,l),0.0);
  float noV=max(dot(n,v),0.001);
  float noH=max(dot(n,h),0.0);
  float voH=max(dot(v,h),0.0);
  vec3 F=fresnelSchlick(voH,f0);
  float D=distributionGGX(noH,rough);
  float G=geometrySchlickGGX(noV,rough)*geometrySchlickGGX(noL,rough);
  vec3 spec=D*G*F/max(4.0*noV*noL,0.001);
  vec3 kd=(1.0-F)*(1.0-metal);
  return (kd*base/PI+spec)*radiance*noL;
}

vec3 shadeSurface(vec3 p,vec3 rd,vec3 n,float id,float th){
  vec3 base=materialColor(id);
  // Fixed, sub-pixel world-space normal variation: material grain without shimmer.
  vec3 grain=sin(vec3(dot(p,vec3(31.0,17.0,11.0)),
                      dot(p,vec3(-13.0,29.0,19.0)),
                      dot(p,vec3(23.0,-7.0,37.0))));
  n=normalize(n+grain*0.014);
  vec3 v=-rd;
  float metal=(id<1.5)?0.58:((id<2.5)?0.46:((id<3.5)?0.72:((id<4.5)?0.78:0.62)));
  float rough=(id<1.5)?0.19:((id<2.5)?0.27:((id<3.5)?0.21:((id<4.5)?0.14:0.18)));
  vec3 f0=mix(vec3(0.035),base,metal);
  vec3 keyDir=normalize(vec3(-0.52,0.68,0.74));
  vec3 fillDir=normalize(vec3(0.72,0.18,0.67));
  vec3 warmDir=normalize(vec3(-0.58,-0.48,0.66));
  float ao=ambientOcclusion(p,n,th);
  float keyShadow=softShadow(p+n*0.004,keyDir,0.025,4.0,th);
  vec3 col=base*vec3(0.075,0.085,0.105)*ao;
  col+=directBRDF(base,f0,metal,rough,n,v,keyDir,vec3(2.70,2.42,2.12))*mix(0.34,1.0,keyShadow);
  col+=directBRDF(base,f0,metal,rough,n,v,fillDir,vec3(0.18,0.78,1.08))*0.82;
  col+=directBRDF(base,f0,metal,rough,n,v,warmDir,vec3(1.38,0.38,0.12))*0.62;
  float fres=pow(1.0-max(dot(n,v),0.0),4.0);
  col+=vec3(0.025,0.34,0.55)*fres*(0.22+0.42*(id<1.5?1.0:0.0));
  vec3 refl=reflect(rd,n);
  vec3 env=mix(vec3(0.022,0.030,0.060),vec3(0.20,0.34,0.44),
               clamp(refl.y*0.5+0.5,0.0,1.0));
  col+=env*fresnelSchlick(max(dot(n,v),0.0),f0)*(0.30+0.34*(1.0-rough));
  col*=0.82+0.18*ao;
  if(id>3.5&&id<4.5){
    float caustic=pow(max(0.0,0.5+0.5*sin(19.0*p.x-13.0*p.y+th*3.0)),7.0);
    float corePulse=0.80+0.20*cos(th*3.0);
    col=mix(col,vec3(0.36,0.025,0.12),0.34*fres);
    col+=vec3(1.55,0.32,0.025)*(0.24+0.76*caustic)*corePulse*glow;
  }
  if(id>2.5&&id<3.5){
    vec3 op=objectSpace(p);
    float crest=pow(max(0.0,0.5+0.5*cos(atan(op.y,op.x)-th*3.0)),14.0);
    col+=base*(0.04+0.38*crest)*glow;
  }
  return col;
}

vec3 toneMap(vec3 x){
  x=max(x,0.0);
  return (x*(2.51*x+0.03))/(x*(2.43*x+0.59)+0.14);
}

void main(){
  vec2 uv=(gl_FragCoord.xy-0.5*RENDERSIZE.xy)/RENDERSIZE.y;
  float ph=fract(TIME/PERIOD);
  float th=TAU*ph;

  vec3 ro=vec3(0.0,0.0,4.55);
  vec3 ta=vec3(0.0,0.0,0.0);
  vec3 ww=normalize(ta-ro);
  vec3 uu=normalize(cross(ww,vec3(0.0,1.0,0.0)));
  vec3 vv=cross(uu,ww);
  vec3 rd=normalize(uu*uv.x+vv*uv.y+ww*1.30);

  float t=0.0,mat=0.0,hit=-1.0;
  for(int i=0;i<118;i++){
    vec2 h=mapScene(ro+rd*t,th);
    if(h.x<0.00045*max(t,1.0)){ hit=t; mat=h.y; break; }
    t+=max(h.x*0.72,0.003);
    if(t>10.0) break;
  }

  vec3 col=vec3(0.0008,0.0012,0.0030);
  if(hit>0.0){
    vec3 pos=ro+rd*hit;
    vec3 nor=calcNormal(pos,th);
    col=shadeSurface(pos,rd,nor,mat,th);
    col*=exp(-0.022*hit*hit);
  }

  // Restrained local bloom around the solar aperture, never a global wash.
  vec3 bgRay=objectSpace(ro+rd*5.0);
  float coreGlow=exp(-15.0*length(bgRay.xy))*0.18*glow;
  col+=vec3(1.0,0.17,0.025)*coreGlow;
  col=toneMap(col*1.18);
  col=pow(clamp(col,0.0,1.0),vec3(0.82));
  float vignette=smoothstep(0.82,0.28,length(uv));
  col*=0.78+0.22*vignette;
  gl_FragColor=vec4(col,1.0);
}