//precision mediump float;
uniform vec2 u_resolution;
uniform float u_time;
const float PI = 22./7.;

// Rotate
mat2 rot2D(float angle) {
    float s = sin(angle);
    float c = cos(angle);
    return mat2(c, -s, s, c);
}

float smax( float a, float b, float k )
{
    float h = max(k-abs(a-b),0.0);
    return max(a, b) + h*h*0.25/k;
}

float hash(vec2 p)
{
    p  = 50.*fract( p*0.3183099);
    return fract( p.x*p.y*(p.x+p.y) );
}

float noise( in vec2 p, float scale )
{
    vec2 i = floor( p );
    vec2 f = fract( p );
	vec2 u = f*f*(3.-2.*f);
    return -scale+scale*mix( mix( hash( i + vec2(0.0,0.0) ), 
                              hash( i + vec2(1.0,0.0) ), u.x),
                         mix( hash( i + vec2(0.0,1.0) ), 
                              hash( i + vec2(1.0,1.0) ), u.x), u.y);
}

float displacement( vec3 p )
{
    return noise(10.*p.xy+u_time+1e3, 0.2) + 0.5*noise(10.*(p.xy+2.0)-u_time+1e3, .2);
}

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

float sdCappedCylinder( vec3 p, float h, float r )
{
  vec2 d = abs(vec2(length(p.xy),p.z)) - vec2(r,h);
  return min(max(d.x,d.y),0.0) + length(max(d,0.0));
}

float sdBox( in vec2 p, in vec2 r )
{
    return length( max(abs(p)-r,0.) );
}

float sdBox2(vec3 p, vec3 b) {
    vec3 q = abs(p) - b;
    return length(max(q,0.)) + min(max(q.x,max(q.y,q.z)),0.);
}

float sdTriPrism( vec3 p, vec2 h, float rot )
{
    p.xy *= rot2D(rot);
    vec3 q = abs(p);    
    return max(q.z-h.y,max(q.x*.866025+p.y*.5,-p.y)-h.x*.5);
}


//////////////////
//   ANIMATION  //
//////////////////

// POSITIONS
/*
const vec3 glyph1Pos = vec3(1.7,-1.1,0.0);
const vec3 glyph2Pos = vec3(2.0,0.0,0.0);
const vec3 glyph3Pos = vec3(1.5,1.4,0.0);
const vec3 glyph4Pos = vec3(0.0,2.0,0.0);
const vec3 glyph5Pos = vec3(1.5,1.4,0.0);
const vec3 glyph6Pos = vec3(1.5 * -1.,1.4,0.0);
const vec3 glyph7Pos = vec3(1.7 * -1.,-1.1,0.0);
*/

// DELAYS
const float STARTDELAY = 9.;
const float glyphPhase = 2.;

// COLORS    
vec3 fogColor1 = vec3(.4, .2, .4);       // fog color1
vec3 fogColor2 = vec3(.7, .4, .2);       // fog color2
vec3 indirColor = vec3(.2, .1, .3);       // indirect light color
vec3 light1Color = vec3(.9, .5, .7);
vec3 light2Color = vec3(.8, .7, .5);
vec3 chevronColor = vec3(.9, .3, 0.);

//  with duration d, startTime s and speed up with timeFact
float timedSine(float maxCycles, float startTime, float timeFact) {    
    startTime *= timeFact;
    float phase = ((u_time * timeFact) - startTime) / PI;    
    return PI * min(phase, maxCycles);
}

float calcFactor (float startTime)
{
    float factor = 9. + 9.*clamp(sin(timedSine(1.5, startTime, 4.) * 0.06), -.9, .9);
    return factor;
}

// Animate ring movements
vec3 ringAnim( in vec3 p) {
    for (float i = 0.; i < 7.; i++) {
        float rotateDelay = STARTDELAY + (i * glyphPhase);
        if(u_time > rotateDelay) {
            float o = 1.;
            if(mod(i,2.) >= 1.) {                
                o = -1.;
            }            
            p.xy *= rot2D(calcFactor(rotateDelay)*o);            
        }
    }
    return p;
}

// Animate prism movements
float prismAnim(in float x, in float delay) {
    if(u_time >= delay) {
        x += (.045*clamp(sin((timedSine(3., delay, 40.) * .4)),-.8, .8));
    }
    return x;
}

//////////////
//   SCENE  //
//////////////

vec2 map(in vec3 p)
{
    float mat = 0.;
    // Stargate

    // Ring boxes
    float an = PI/12.;    
    float anRot = floor(atan(p.y,p.x)/an + .5)*an;
    vec3 q = p;
    q.xy = mat2(cos(anRot),-sin(anRot),
                sin(anRot), cos(anRot))*q.xy;
    float d = sdBox( q.xy - vec2(1.8,0.), vec2(0.24,0.14) ) - .02;

    // Main ring
    float d2 = abs(length(p.xy) - 1.8) - .2;
    d = min(d,d2);

    // Inner ring
    d2 = abs(length(p.xy) - 1.75) - .08;
    d2 = smax( d2, abs(p.z - .1)-.04, .005 );
    d = max(-d2,d);

    // Depth slice rings
    d = smax( d, abs(p.z)-.1, .02 );

    // Prisms    
    for(float i = 0.; i < 8.; i++ ) {        
        an = 24.67 / (PI * 2.); // sector size
        q = p;
        anRot = an + (i+1.) * PI / 4.;

        // Nudge first and the last prism out of the ground
        if (i == 1.) anRot += .2;        
        if (i == 7.) anRot -= .2;        
        q.xy = rot2D(anRot) * q.xy;

        float rotateDelay = STARTDELAY + (i - 1.) * glyphPhase + 1.5;
        // We can now call each prism by it's index
        // draw all except the middle bottom prism
        if (i > 0.) {        
            q.x -= 1.95;
            vec3 q2 = q; // new point for movable parts
            if(u_time > rotateDelay) q2.x = prismAnim(q2.x, rotateDelay);                                    
            float prismTop = sdTriPrism(vec3(q.x - .06, q.y, q.z), vec2(.1,.15), .5)-.01;
            d2 = max(- sdTriPrism(vec3(q2.x - .14, q2.y - 0. , q2.z), vec2(.22,.22), .5) - .01 , sdTriPrism(vec3(q2.x, q2.y, q2.z ), vec2(.2,.12), .5) - .02);
            d2 = min(d2, prismTop);
            d = min(d, d2);            
            // glyph locking thing material
            if (d == d2) mat = 4.;
            // glyph locking prism material
            if( d == prismTop && u_time > rotateDelay + .2) mat = 5.;                         
        }       
    }   
     
    //Rotating glyphs
    vec3 p2 = ringAnim(p);    
    vec3 q2 = p2;
    an = PI/16.;
    q2.xy = rot2D(floor((atan(p2.y,p2.x)/an) + .5)*an)*q2.xy;
    d2 = sdBox2( q2.xyz - vec3(1.75,0.,0.), vec3(.04, .14, .05) ) - .02;
    d = min(d, d2);
    if (d==d2) mat = 4.;
     
    // Gate Base    
    d2 = 1e3;
    float stepDist = 1.5; 
    for(int i = 0; i < 4; i++) {
        float step = sdBox2(vec3(p.x,p.y+stepDist,p.z), vec3(2., .1,stepDist)) - .05;
        d2 = min(d2, step);
        d = min(d, step);
        stepDist += .2;
    }
    if (d==d2) mat = 2.0;

    d2 = (p.y + 4.25) + 1.5*noise((vec2((p.x*.04),(p.z-40.)*.04))+100., 15.);
    d = min(d,d2);
    if (d==d2) mat = 3.0;

    d2 = 1e3;    
    d2 = max(-sdCappedCylinder(p, 2.0, clamp((2.0 - (u_time*2.0 - 2.0*23.0)),0.,2.0)), sdCappedCylinder(p, .025, 1.6)+ displacement(p)*clamp(((u_time-24.0)*0.5), 0., 0.25));
    d2 = max(d2, sdCappedCylinder ( p, 0.3, 1.6));
    d = min(d, d2);
    if (d==d2) mat = 1.0;    
    return vec2( d, mat );
}

////////////////
//   DRAWING  //
////////////////

float rayMarch(vec3 ro, vec3 rd) {
    float t = 0.; // total distance travelled
    float d;
    // Raymarching
    for (int i = 0; i < 90; i++) {
        vec3 p = ro + rd * t; // "cast" rays
        d = map(p).x; // Get distance to objects
        t += d; // "march" the ray
        if (abs(d) < .002 || t > 400.) break;
    }
    return t;
}
vec3 getNormal(vec3 p) {
    float d = map(p).x;
    vec2 e = vec2(.01, 0.);
    vec3 n = d - vec3(
        map(p-e.xyy).x,
        map(p-e.yxy).x,
        map(p-e.yyx).x);
    return normalize(n);
}

float getLight(vec3 p, vec3 lightPos, float intensity, float shadow) {
    vec3 l = normalize(lightPos - p);
    vec3 n = getNormal(p);
    float dif = clamp(dot(n, l), 0., intensity);
    // Shadows
    float d = rayMarch(p+n*.0025, l);
    if(abs(d)<length(lightPos-p)) dif *= shadow;
    return dif;
}

vec3 applyFog(vec3 col, float t, vec3 rd, vec3  lightDir, float b ) {
  float sunAmount = max( dot(rd, lightDir), 0. );
    vec3  fogColor  = mix( fogColor1, // blue
                           fogColor2, // yellow
                           pow(sunAmount,8.));
    return mix( col, fogColor, 1.0 - exp(-t*b) );
}

vec3 getCameraRayDir(vec2 uv, vec3 p, vec3 l, float z)
{
    vec3 f = normalize(l-p),
        r = normalize(cross(vec3(0.,1.,0.), f)),
        u = cross(f,r),
        c = f*z,
        i = c + uv.x*r + uv.y*u,
        d = normalize(i);
    return d;
}

vec3 postProcess(vec3 col) {             
    // Vignette
    float radius = .9;    
    col *=  smoothstep(radius, radius-.4, length(gl_FragCoord.xy/u_resolution.xy-vec2(.5)));    
    // Colour mapping
    col *= vec3(.9, 0.8, 0.7);
    // gamma   
    col = pow( col, vec3(.4545) );      
    // Contrast = a
    col = smoothstep(0., 1., col);    
    return col;
}

vec3 cameraPos()
{
    // first zoom in to the gate
    vec3 cPos = vec3(0., clamp(6.-u_time,2.,6.), clamp((75.-u_time*8.),6.,75.));
    if (u_time > 7.5) cPos += vec3(0., clamp(7.5-u_time,-1.,0.), 0.);    

    // close up shot for 1st glyph lock
    if (u_time > 10.5) cPos = vec3(2.,-1.,1.);
        //zoom away for 2nd glyph animation
    if (u_time > 12.) cPos = vec3(-1., -1., 4.);
    
    //close up shot for the 2nd glyph lock
    // !NOTE: disabled by petri due takes alot of space and has small visual impact on the scene
    /* 
    float delay = 11.2;
    if(u_time > delay) cPos.z += (0.25 - smoothstep(-0.7,0.5,sin((timedSine(1.5, delay, 35.0))))) * 0.1;
    */
    
    return cPos;
}

vec3 cameraPointAt() {
    vec3 p = vec3(0., -.5, 0.);
    // look at 1st glyph
    if (u_time > 10.5) p = vec3(1.7,-1.1,0.);
    // look gate at distance
    if(u_time > 12.) p = vec3(.0,.1,0.);
    return p;
}

// flash screen with glyph color when it is locked
vec3 colorFlashesAnim(in vec3 col) {
    float delay = 10.75;
    if(u_time > delay) {
        float x = smoothstep(-1.,.8,sin((timedSine(.8, delay, 8.)*2.)));
        col = mix(col, chevronColor * (x * 1.4), x *.76);
    }
    return col;
}

vec3 sceneGate(vec2 uv)
{
    // Initialization   
    vec3 ro = cameraPos();
    vec3 rd = getCameraRayDir(uv, ro, cameraPointAt(), 2.);   // ray direction
    vec3 col = vec3(0.);     // color
    float d = rayMarch(ro, rd);

    if (d < 150.) {
        // Lighting
        vec3 p = ro + rd * d;
        float mat = map(p).y;

        // Light 1 Arguments
        // 1: Ray starting point
        // 2: Light position
        // 3: Light intensity
        // 4: Shadow intensity

        // Light 2
        float dif = getLight(p,  vec3( 10., 15., 25.), 1., .2);
        col += dif * light1Color;

        dif = getLight(p,  vec3( 4., 2., -15.), 1., 1.);
        col += dif * light2Color;

        // indirect lightning -> vec3 in normalize is light direction        
        col += indirColor * clamp( dot( getNormal(p), normalize(vec3(0. , 1., 10.))), 0., 1.);

        if(mat==0.)
            col *= vec3(.3);        
        else if(mat==1.)
            col *= vec3(0.,0.,.5); // + (noise(5.*(p.xy+2.)+u_time, -1.0) * noise(50.*(p.xy+2.), -0.4) + 0.5*noise(20.*(p.xy+2.0)-u_time, -0.5) * noise(5.*(p.xy+2.0), -0.75))*smoothstep(0.,0.75,(u_time-5.0)*0.1) + vec3(0.,0.,0.5*noise(10.*(p.xy+4.0)-u_time, -0.5));        
        else if(mat==2.)
            col *= vec3(.3, .1, .0); // - 0.2*noise((vec2(100.*p.x+300.,75.*p.z+150.0)), -2.2) * noise((vec2(15.*p.x+2.0,3.*p.z+2.)), -1.) + noise((vec2(15.*p.x+2.4,3.*p.z+2.)), -0.25);        
        else if(mat==3.)
            col *= vec3(.8, .8, .5) + noise(p.xz*500.+100., .3); // + noise(p.xz*1000.+5000., 0.1) + noise(p.xz*1000.+5000., 0.1);        
        else if(mat==4.)
            col *= vec3(.1);
        else if(mat ==5.)       
            col *= chevronColor;  // activated glyph color 
    
    }
   float fogAmount = .01;    
   col = applyFog(col, d, rd, vec3(0., -.1, -1.), fogAmount);
   col = colorFlashesAnim(col); // animated color flash        
   return postProcess(col);
}

void pMod1(inout float p, float size) {
    float halfsize = size*0.5;	
	p = mod(p + halfsize, size) - halfsize;	
}

void getQ(inout vec3 q, float i, float speed, float radius) {   
    q.z -= .5;
    q.xy *= rot2D(sin(speed*u_time*.25)*PI);        
    q.x -= radius * sin(i / PI);
    q.y -= radius * cos(i / PI);
    q.z += i * .01;   
}

vec2 map2(vec3 pos) {    
    float d = 1e3;    
    float mat;
    pMod1(pos.z, 1.);        
    for (float i = 0.; i < 90.; i++) {                    
        vec3 q = pos;        
        getQ(q, i, -1., 3.);                
        float b = sdSphere(q, 0.05);
        d = min(d, b);
        if (d == b) mat = 0.;
        q = pos;        
        getQ(q, i, 1., .3);
        b = sdSphere(q, 0.01);
        d = min(d, b);
        if (d == b) mat = 1.;        
    }
    return vec2(d, mat);
}

vec3 palette(float t)  {
    vec3 a = vec3(0.5, 0.5, 0.5);
    vec3 b = vec3(1.0, 1.0, 1.0);
    vec3 c = vec3(1.0, 1.0, 1.0);
    vec3 d = vec3(0.0, 0.66, 0.33);
    return a + b * cos(6.3 * (c*t+d));
}
 
float rayMarch2(vec3 ro, vec3 rd) {
    float t = 0.;
    float d;
    for (int i = 0; i < 60; i++) {
        vec3 p = ro + rd * t;
        d = map2(p).x;
        t += d;     
        if (d < .002 || t > 20.) break;
    }
    return t;
}

vec3 sceneTunnel(vec2 uv) {    
    vec3 ro = vec3(0.,0.,u_time*2. );
    vec3 rd = normalize(vec3(uv, .7));       
    float d = rayMarch2(ro, rd);   
    vec3 p = ro + rd * d;
    float mat = map2(p).y;
    vec3 col = vec3(0., 0., .1);
    if (d < 10.) {
        if (mat == 0.) col = vec3( 0., .3, .6);
        if (mat == 1.) col = palette(1. - .4*d);                
    }
    return col;
}

void main() {
    vec2 uv = (gl_FragCoord.xy * 2. - u_resolution.xy) / u_resolution.y;    
    if (u_time < 29.) { 
        gl_FragColor = vec4(sceneGate(uv), 1.);
    } else {
        gl_FragColor = vec4(sceneTunnel(uv), 1.); 
    }  
}