//precision mediump float;    
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.4) + 0.5*noise(10.*(p.xz+2.0)-u_time+999., 0.4);
}

/////////////////
//   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;

// Rotate ring with duration d and startTime s
float ringRotateFunc(float d, float s, float timeFact) {
    float maxCycles = d;
    float startTime = s;
    float phase = ((u_time * timeFact) - startTime) / TWOPI;
    phase = min(phase, maxCycles);
    return TWOPI * phase;
}

// Animate ring movements
vec3 ringAnim( in vec3 p) {
    const float STARTDELAY = 9.0; 

    float factor = 9.0+9.0*clamp(sin(ringRotateFunc(2.0, 0.0, 1.0) * 0.05), -0.9, 0.9);
    // delay start
    if( u_time >= STARTDELAY ) {        
        p.xy = rot2D(factor) * p.xy;
    }

    if(u_time >= 14.0) {
        factor = 9.0+9.0*clamp(sin(ringRotateFunc(2.0, 14.0, 1.0) * 0.05), -0.9, 0.9);
        p.xy = rot2D(factor * -1.0) * p.xy;
    }

    return p;
}

// Animate prism movements
float prismAnim(in float x, in float delay) {
    if(u_time >= delay) {
        x += (0.045*clamp(sin((ringRotateFunc(2.4, delay*10.0, 10.0) * 0.4)),-0.9, 0.9));
    }
    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;
        }

       // float prismSector = floor(atan(p.y,p.x)/(rotationIncrement) + 0.5);
        q.xy = rot2D(rotationIncrement) * q.xy;

        // We can now call each prism by it's index
        // draw all except the middle bottom prism
        if (i > 0) {        
            q.x -= 1.95;                    
            q.x = prismAnim(q.x, float(i)*1.);            
        
            float d4 = sdTriPrism(vec3(q.x, q.y - 0.0 , q.z - 0.0), vec2(0.2,0.2), 0.5) - 0.02;
            d = min(d, d4);
            if (d==d4) {
                mat = 4.;
            }
        }

        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 water = 1000.;
    if (u_time > 2.0){
        float cylinder1 = sdCylinder ( p, vec3(0.,0.,0.0), vec3(0.,0.,-0.01), 1.6);
        float cylinder2 = sdCylinder ( p, vec3(0.,0.,0.), vec3(0.,0.,-1), (2. - (u_time*2.0 - 2.0*13.0)));
        float cylinder3 = sdCylinder ( p, vec3(0.,0.,1.), vec3(0.,0.,-1.), 1.6);
        float disp = 0.;
        if (u_time > 2.0){
            disp = displacement(p)*min(((u_time-14.0)*0.5), 0.25);
        }
        cylinder1 = cylinder1 + disp;
        water = max(-cylinder2+disp, cylinder1);
        //water = max(water, cylinder3);
        d = min(d, water);
    }

   float sand = (p.y + 4.25) + noise((p.xz*0.04)+100., 9.);
    d = min(d,sand);

    if (d==water)
    {
        mat = 1.0;
    }
    else if (d==min(steps, 0.1))
    {
        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 < 200; i++) {
        vec3 p = ro + rd * t; // "cast" rays
        d = map(p).x; // Get distance to objects
        t += d; // "march" the ray
        if (abs(d) < .001 || t > 800.) 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( vec3(0.2667, 0.2941, 0.3451), // blue
                           vec3(0.302, 0.3176, 0.3725), // 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) {             
    // float random = noise(gl_FragCoord.xy, 0.01+u_time);
    //  float random2 = noise(gl_FragCoord.xy, .2+u_time);    
    //col += 0.075*clamp(vec3(0.5*random, 0.5*random2, 0.5*random), 0.02, 1.); // dither

    // 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
    
    // fade in at the beginning
    //col*=vec3(clamp((u_time-1.8)*0.5,0., 1.));
    
    // fade out at the end
    // col*=vec3(clamp((120.-u_time)*.35, 0., 1.));
    
    return col;
}

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

    vec3 ro = vec3(0, 2, 6);
    ro.yz *= rot2D(sin(u_time)*0.5);
    ro.xz *= rot2D(cos(u_time)*0.5);

    //vec3 ro = vec3(0,0,-3); // ray origin

    vec3 rd = getCameraRayDir(uv, ro, vec3(0, -1., 0.), 1.);   // 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 * vec3(0.502, 0.2824, 0.102));
            
            dif = getLight(p,  vec3( 3, -2, 5), 0.75, .8);
            // Color for light 2
            col += vec3(dif * vec3(0.2784, 0.3647, 0.6588));
            
            vec3 n = getNormal(p);               
            vec3 dir = vec3(1. , 10., 1.);
            float ind = clamp( dot( n, normalize(dir )), 0.0, 1.0 );
            col += vec3(0.1216, 0.1216, 0.1137) * ind; 

            if(mat==0.){
                col *= vec3(.3,0.3,0.3);
            }
            else if(mat==1.){
                col *= (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)) + vec3(0.,0.,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.yz*1000., 0.1) + noise(p.xy*1000., 0.1);
            }
            else if(mat==4.){
                col *= vec3(.1,0.1,0.1);
            }

            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 = vec3(0.1529, 0.1765, 0.3922) + rd.y * 0.4;
        }
            
        gl_FragColor = vec4(postProcess(col), 1);
        
}