uniform vec2 u_resolution;
uniform float u_time;
uniform sampler2D texture_sampler;
uniform sampler2D texts;

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

// Exponential smoothing
float smin( float a, float b, float k )
{
    k *= 1.0;
    float r = exp2(-a/k) + exp2(-b/k);
    return -k*log2(r);
}

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.0-2.0*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+999., 0.2) + 0.5*noise(10.*(p.xy+2.0)-u_time+999., 0.2);
}

/////////////////
//   GEOMETRY  //
/////////////////

float sdCylinder(vec3 p, vec3 a, vec3 b, float r)
{
    vec3  ba = b - a;
    vec3  pa = p - a;
    float baba = dot(ba,ba);
    float paba = dot(pa,ba);
    float x = length(pa*baba-ba*paba) - r*baba;
    float y = abs(paba-baba*0.5)-baba*0.5;
    float x2 = x*x;
    float y2 = y*y*baba;
    
    float d = (max(x,y)<0.0)?-min(x2,y2):(((x>0.0)?x2:0.0)+((y>0.0)?y2:0.0));
    
    return sign(d)*sqrt(abs(d))/baba;
}

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

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

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

float sdTriPrism( vec3 p, vec2 h, float rot )
{
    p.xy *= rot2D(rot);
    const float k = sqrt(3.0);
    h.x *= 0.5*k;
    p.xy /= h.x;
    p.x = abs(p.x) - 1.0;
    p.y = p.y + 1.0/k;
    if( p.x+k*p.y>0.0 ) p.xy=vec2(p.x-k*p.y,-k*p.x-p.y)/2.0;
    p.x -= clamp( p.x, -2.0, 0.0 );
    float d1 = length(p.xy)*sign(-p.y)*h.x;
    float d2 = abs(p.z)-h.y;

    return length(max(vec2(d1,d2),0.0)) + min(max(d1,d2), 0.);
}


//////////////////
//   ANIMATION  //
//////////////////
const float TWOPI = 6.28318530718;

// POSITIONS
vec3 lookAtPoint = vec3(0, -0.5, 0.);
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.0;
const float glyphPhase = 2.0;

// COLORS
    vec3 glyphColor = vec3(0.95, 0.35, 0.06);   // glyph color
    vec3 color1 = vec3(0.44, 0.29, 0.46);       // fog color1
    vec3 color2 = vec3(0.75, 0.45, 0.23);       // fog color2
    vec3 color3 = vec3(0.29, 0.17, 0.35);       // indirect light color
    vec3 color4 = vec3(0.7, 0.27, 0.09);        // sky color1
    vec3 color5 = vec3(0.09, 0.05, 0.66);       // sky color2
        
    vec3 light1Color = vec3(0.91, 0.57, 0.73);
    vec3 light2Color = vec3(0.83, 0.71, 0.54);

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

float calcFactor (float startTime)
{
    float factor = 9.0 + 9.0*clamp(sin(timedSine(1.5, startTime, 4.0) * 0.06), -0.9, 0.9);
    return factor;
}

// Animate ring movements
vec3 ringAnim( in vec3 p) {
    for (float i = 0.0; i<7.0; i++) {
        float rotateDelay = STARTDELAY + (i * glyphPhase);
        if(u_time > rotateDelay) {
            if(mod(i,2.0) >= 1.0) {
                p.xy = rot2D(calcFactor(rotateDelay) * -1.0) * p.xy;
            } else {
                p.xy = rot2D(calcFactor(rotateDelay)) * p.xy;
            }
        }
    }
    return p;
}

// Animate prism movements
float prismAnim(in float x, in float delay) {
    if(u_time >= delay) {
        x += (0.045*clamp(sin((timedSine(3.0, delay, 40.0) * 0.4)),-0.8, 0.8));
    }
    return x;
}

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

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

    // Ring boxes
    const float an = TWOPI/24.0;
    float sector = floor(atan(p.y,p.x)/an + 0.5);
    float angrot = sector*an;
    vec3 q = p;
    q.xy = mat2(cos(angrot),-sin(angrot),
                sin(angrot), cos(angrot))*q.xy;
    float d = sdBox( q.xy - vec2(1.8,0.0), vec2(0.24,0.14) ) - 0.02;

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

    // Inner ring
    float d3 = abs(length(p.xy) - 1.75) - 0.08;
    d3 = smax( d3, abs(p.z - 0.1)-0.04, 0.005 );
    d = max(-d3,d);

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

    // Prisms
    float index = 1.0;
    for(int i=0; i<8; i++ ) {

        float secDist = TWOPI / 8.0; // sector distance
        float angle = ((24.67 / TWOPI )); // sector size
        vec3 q = p;
        float rotationIncrement = angle + (index * secDist);

        // Nudge first and the last prism out of the ground
        if (i == 1) {
            rotationIncrement = rotationIncrement + 0.2;
        }
        if (i == 7) {
            rotationIncrement = rotationIncrement - 0.2;
        }

        q.xy = rot2D(rotationIncrement) * q.xy;

        float rotateDelay = STARTDELAY + ((index - 2.0) * 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 prismOut = sdTriPrism(vec3(q2.x - 0.14, q2.y - 0.0 , q2.z), vec2(0.22,0.22), 0.5) - 0.01;
            float prismIn = sdTriPrism(vec3(q2.x, q2.y, q2.z ), vec2(0.2,0.12), 0.5) - 0.02;
            float prismTop = sdTriPrism(vec3(q.x - 0.06, q.y, q.z), vec2(0.10,0.15), 0.5) - 0.01;
            float d4 = max(-prismOut, prismIn);
            d4 = min(d4, prismTop);
            d = min(d, d4);
            
            // glyph locking thing material
            if (d == d4) {
                mat = 4.;
            }

            // glyph locking prism material
            if(d == prismTop) {
                if(u_time > rotateDelay + 0.2) {
                    mat = 5.;
                }
            }
        }

        index += 1.0;
    }   
     
    //Rotating glyphs
    vec3 p2 = ringAnim(p);
    float an2 = (TWOPI/32.0);
    float sector2 = floor((atan(p2.y,p2.x)/an2) + 0.5 );
    float angrot2 = sector2*an2;
    vec3 q2 = p2;
    q2.xy = rot2D(angrot2)*q2.xy;
    float d5 = sdBox2( q2.xyz - vec3(1.75,0.0,0.0), vec3(0.04, 0.14, 0.05) ) - 0.02;
    d = min(d, d5);
    if (d==d5) {
        mat = 4.;
    }
 
    // Gate Base
    const float stepHeight = 0.1;
    float stepDist = 1.5;
    const float stepWidth = 2.0;
    float steps = 1000.;

    for(int i = 0; i < 4; i++) {
        float step = sdBox2(vec3(p.x,p.y+stepDist,p.z), vec3(stepWidth,stepHeight,stepDist)) - 0.05;
        steps = min(steps, step);
        d = min(d, step);
        stepDist += stepHeight * 2.0;
    }

    float sand = (p.y + 4.25) + 1.5*noise((vec2((p.x*0.04),(p.z-40.0)*0.04))+100., 15.);
    sand += noise(p.yz, .25);
    sand += 0.025*noise(p.xz*50.+100., .05);
    d = min(d,sand);

    float water = 1000.;
    float cylinder1 = sdCylinder ( p, vec3(0.,0.,0.0), vec3(0.,0.,-0.01), 1.6);
    float cylinder2 = sdCylinder ( p, vec3(0.,0.,1.), vec3(0.,0.,-1), clamp((2.0 - (u_time*2.0 - 2.0*23.0)),0.,2.0));
    float cylinder3 = sdCylinder ( p, vec3(0.,0.,1.), vec3(0.,0.,-1.), 1.6);
    float disp = 0.;
    disp = displacement(p)*clamp(((u_time-24.0)*0.5), 0., 0.25);
    cylinder1 = cylinder1 + disp;
    water = max(-cylinder2, cylinder1);
    water = max(water, cylinder3);
    d = min(d, water);

    if (d==water)
    {
        mat = 1.0;
    }
    else if (d==steps)
    {
        mat = 2.0;
    }
    else if (d==sand) {
        mat = 3.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 < 100; i++) {
        vec3 p = ro + rd * t; // "cast" rays
        d = map(p).x; // Get distance to objects
        t += d; // "march" the ray
        if (d < .001 || t > 500.) 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(d<length(lightPos-p)) dif *= shadow;
    return dif;
}

vec3 applyFog(vec3 col, float t, vec3 rd, vec3  lightDir, float b ) {
    float fogAmount = 1.0 - exp(-t*b);
    float sunAmount = max( dot(rd, lightDir), 0.0 );
    vec3  fogColor  = mix( color1, // blue
                           color2, // yellow
                           pow(sunAmount,8.0) );
    return mix( col, fogColor, fogAmount );
}


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) {             

    // Normalized pixel coordinates (from 0 to 1)
    vec2 screenCoord = gl_FragCoord.xy/u_resolution.xy;

    // Vignette
    //float radius = 0.9;
    //float d = smoothstep(radius, radius-0.4, length(screenCoord-vec2(0.5)));
    //col = mix(col, col * d, .9);
    
    // Contrast = a
    col = mix(col, smoothstep(0.0, 1.0, col), 0.9);

    // Colour mapping
    col *= vec3(1.0, 1.0, 1.0);
    col = pow( col, vec3(1.0/2.2) ); // gamma
    
    return col;
}

// zoom camera on glyph lock for extra oomph
float cameraZoomAnim(float o) {
    float delay = 10.7;

    if(u_time > delay) {
    o += (0.25 - smoothstep(-0.7,0.5,sin((timedSine(1.5, delay, 35.0))))) * 0.1;
    }

return o;
}

vec3 cameraPos()
{
    // first zoom in to the gate
    vec3 cPos = vec3(0, clamp(6.-u_time,2.,6.), clamp((75.-u_time*8.0),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.0,-1.0,1.0);
    }

    //zoom away for 2nd glyph animation
    if (u_time > 12.) {
        cPos = vec3(-1.0, -1.0, 4.0);
    }

    //close up shot for the 2nd glyph lock

    cPos.z = cameraZoomAnim(cPos.z);

    return cPos;
}

vec3 cameraPointAt(vec3 p) {

    // look at 1st glyph
    if(u_time > 10.5) {
        p = glyph1Pos;
    }

    if(u_time > 12.) {
        p = vec3(0.0,0.1,0.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.0,0.8,sin((timedSine(0.8, delay, 8.0)*2.0)));
        col = mix(col, glyphColor * (x * 1.4), x * 0.76);
    }
return col;
}

void main()
{
    // Initialization
    vec2 uv = (gl_FragCoord.xy * 2. - u_resolution.xy) / u_resolution.y;

    vec3 ro = cameraPos();

    vec3 rd = getCameraRayDir(uv, ro, cameraPointAt(lookAtPoint), 2.);   // ray direction
    vec3 col = vec3(0);     // color

    float d = rayMarch(ro, rd);



    if (d < 500.) {
        // 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
        float dif = 0.; //getLight(p, vec3( 2, 50, 2), .5, .2);
        // Color for light 1
        // col = vec3(dif * vec3(0.9216, 0.9294, 0.9412));







        // Light 2
        dif = getLight(p,  vec3( -3, 5, 5), 1., 0.2);
        // Color for light 2
        col += vec3(dif * light1Color);

        dif = getLight(p,  vec3( 3, -2, 5), 0.75, .8);
        // Color for light 2
        col += vec3(dif * light2Color);



        vec3 lightPosition = glyph1Pos;
        lightPosition.z = lightPosition.z + 0.3;
        // dif = getLight(p,  lightPosition, 3.75, 1.0);


        // float minLight = 0.01;
        // float radius = sqrt(1.0 / (lightPosition * minLight))
        vec3 ld = lightPosition-p;
        float len = length( ld ); // Distance from the light to the surface point.
	    ld /= len; // Normalizing the light-to-surface, aka light-direction, vector.
	    // float lightAtten = min( 1.0 / ( 0.25*len*len ), 1.0 ); // Keeps things between 0 and 1.

        // float att = clamp(1.0 - len/radius, 0.0, 1.0);

    
        float att = 8.0 / (1.0 + 8.1*len + 0.01*len*len);     // light attenuation

        if(u_time > 10.76) {
        col += vec3(dif * glyphColor * att);
        }





        vec3 n = getNormal(p);               
        vec3 dir = vec3(1. , 10., 1.);
        float ind = clamp( dot( n, normalize(dir )), 0.0, 1.0 );
        col += color3 * ind; 

        if(mat==0.){
            col *= vec3(.3,0.3,0.3);
        }
        else if(mat==1.){
            col *= vec3(0.,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(0.3608, 0.1765, 0.0471); // - 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(0.8471, 0.8549, 0.4667); // + noise(p.xz*1000.+5000., 0.1) + noise(p.xz*1000.+5000., 0.1);
        }
        else if(mat==4.){
            col *= vec3(.1,0.1,0.1);
        } else if(mat ==5.) {
            col *= glyphColor; // activated glyph color
        }

        float fogAmount = 0.02;
        col = col*exp(-d*fogAmount) + applyFog(col, d, rd, vec3(0., .3, -1.), fogAmount) * (1.0-exp(-d*fogAmount));

    } else {            
        col = mix(color4, color5, rd.y * 1.2);
    }

    col = colorFlashesAnim(col); // animated color flash
        
    gl_FragColor = vec4(postProcess(col), 1);
    
}