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


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

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

// Rotate ring with duration d and startTime s
float ringRotateFunc(float d, float s, float timeFact) {
    const float TWOPI = 6.28318530718;
    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 = 2.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 ) {
    factor = 9.0+9.0*clamp(sin(ringRotateFunc(2.0, 0.0, 1.0) * 0.05), -0.9, 0.9);
    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)
{
    // Stargate

    // Ring boxes
    const float an = 6.283185/24.0;
    float sector = round(atan(p.y,p.x)/an);
    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++ ) {
    
        //vec3 p2 = prismAnim(p);
    
        float secDist = 6.283185 / 8.0; // sector distance
        float angle = ((24.67 / 6.283185 )); // 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 = round(atan(p.y,p.x)/(rotationIncrement));
        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 = q.x - 1.95;
        
            if(i == 1) {
            q.x = prismAnim(q.x, 13.0);
            }
            
            if(i == 2) {
            q.x = prismAnim(q.x, 26.0);
            }
        
            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);
        }

        index += 1.0;
    }
    
    //Rotating glyphs
    vec3 p2 = ringAnim(p);
    float an2 = (6.283185/32.0);
    float sector2 = round((atan(p2.y,p2.x)/an2) );
    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);
    

    // Gate Base
    const float stepHeight = 0.1;
    float stepDist = 1.5;
    const float stepWidth = 2.0;

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

    return vec2( d );
}

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

float rayMarch(vec3 ro, vec3 rd) {

    float t = 0.; // total distance travelled
    float d;
    // Raymarching
    for (int i = 0; i < 80; 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>100.) 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 GetRayDir(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;
}

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, 3);
    //ro.yz *= rot2D(-m.y*3.14+1.);
    //ro.xz *= rot2D(-m.x*6.2831);

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

    vec3 rd = GetRayDir(uv, ro, vec3(0, 0., 0.), 1.);   // ray direction
    vec3 col = vec3(0);     // color

    if(u_time > 0.0)
    {
        float d = rayMarch(ro, rd);

        if (d < 1000.)
        {
            // Lighting
            vec3 p = ro + rd * d;

            float mat = map(p).y;
            // Light 1
            // Light 1 Position
            vec3 lightPos1 = vec3( 3, 5, 4);
            // Light 1 Arguments
            // 1: Ray starting point
            // 2: Light position
            // 3: Light intensity
            // 4: Shadow intensity
            float dif = getLight(p, lightPos1, 0.75, 0.2);
            // Color for light 1
            col = vec3(dif * vec3(1));

            // Light 2
            vec3 lightPos2 = vec3( -3, 5, -4);
            dif = getLight(p, lightPos2, 0.75, 0.1);
            // Color for light 2
            col += vec3(dif * vec3(0.5,0.2,0.1));

            if(mat==0.){
                col *= vec3(0,0,1);
            }
            else if(mat==1.){
                col *= vec3(0,1,0);
            }
            else if(mat==2.){
                col *= vec3(1,0,0);
            }
        }
        gl_FragColor = vec4(col, 1);
    }

    else {

    // ************* post-process pass ******************
    // Uncomment this to try a post-processing "effect"

    vec4 c = texture2D(texture_sampler, (gl_FragCoord.xy / u_resolution )),
        c1 = texture2D(texture_sampler, ((gl_FragCoord.xy + vec2(1.0, 0.0)) / u_resolution) ),
        c2 = texture2D(texture_sampler, ((gl_FragCoord.xy + vec2(0.0, 1.0)) / u_resolution) ),
        c3 = texture2D(texture_sampler, ((gl_FragCoord.xy + vec2(1.0, 1.0)) / u_resolution) ),
        c4 = texture2D(texture_sampler, ((gl_FragCoord.xy + vec2(-1.0, 1.0)) / u_resolution) ),
        c5 = texture2D(texture_sampler, ((gl_FragCoord.xy + vec2(-1.0, 0.0)) / u_resolution) ),
        c6 = texture2D(texture_sampler, ((gl_FragCoord.xy + vec2(-1.0, -1.0)) / u_resolution) ),
        c7 = texture2D(texture_sampler, ((gl_FragCoord.xy + vec2(0.0, -1.0)) / u_resolution) ),
        c8 = texture2D(texture_sampler, ((gl_FragCoord.xy + vec2(1.0, -1.0)) / u_resolution) )
        ;

        // weird emboss effect
        //  gl_FragColor = (c - c1 - c2 - c3 - c4 + c5 + c6 + c7 + c8) / 2.0;


        // some sort of gamma correction with smoothing
            gl_FragColor = sqrt(c * 2.0 + c1 + c2 + c3 + c4 + c5 + c6 + c7 + c8) / 3.0;

    }
}