# define IR iResolution
# define IT iTime
# define PI 3.1415916
# define AA 0

float INF = 100000.0;

//sdf
mat3 rotation_matrix(float x,float y,float z){
    return mat3(
        vec3(1.,0,0),
        vec3(0,cos(x),sin(x)),
        vec3(0,-sin(x),cos(x))
    ) * mat3(
        vec3(cos(y),0,-sin(y)),
        vec3(0,1.,0),
        vec3(sin(y),0,cos(y))
    ) * mat3(
        vec3(cos(z),sin(z),0),
        vec3(-sin(z),cos(z),0),
        vec3(0,0,1.)
    );
}

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

float sdf_sphere2(vec3 p){
    vec3 c = vec3(-4.,2.,2.);
    return length(p - c) - 2.;
}


float sdf_plane(vec3 p){
    return abs(p.z);
}

float sdf_torus( vec3 p, vec2 t )
{
  vec2 q = vec2(length(p.xz)-t.x,p.y);

  return length(q)-t.y;
}

float sdf(vec3 p){
    float minv = INF;

    float slow = IT/8. * PI, mid = IT/4. * PI, fast = IT/2. * PI;
    //mid = 0.;

    //center sphere
    float dist = sdf_sphere(p,vec3(-4.,0,0),.5);
    if(dist < minv){ minv = dist; }

    //torus
    dist = sdf_torus(inverse(rotation_matrix(2.25*PI/4. + mid,PI/4. + 0., PI/4. + mid)) * p,vec2(2.,.15));
    if(dist < minv) minv = dist;

    dist = sdf_torus(inverse(rotation_matrix(-2.25*PI/4. - mid,PI/4. + 0.,-PI/4. - mid)) * p,vec2(2.,.15));
    if(dist < minv) minv = dist;

    //surrounding sphere
    float _d = 2.1;
    vec3 centers[] = vec3[](vec3(-4.,0,_d),vec3(-4.,0,-_d),vec3(-4.,_d,0),vec3(-4.,-_d,0));
    for(int i = 0;i < 4;i ++){
        dist = sdf_sphere(p,centers[i],.35);
        if(dist < minv){
            minv = dist;
        }
    }

    return minv;
}

vec3 get_normal(vec3 p){
    float e = .00001;
    return normalize(vec3(
        sdf(vec3(p.x + e,p.y,p.z)) - sdf(vec3(p.x - e,p.y,p.z)),
        sdf(vec3(p.x,p.y + e,p.z)) - sdf(vec3(p.x,p.y - e,p.z)),
        sdf(vec3(p.x,p.y,p.z + e)) - sdf(vec3(p.x,p.y,p.z - e))
    ));
}

vec3 phong(vec3 ro,vec3 p){
    vec3 k_a = vec3(.2), k_d = vec3(.7,.2,.2), k_s = vec3(1.);
    vec3 i_a = vec3(.2), i_d = vec3(1.,0,0), i_s = vec3(1.,0,0);
    float alpha = 10.;

    vec3 res = i_a * k_a;

    vec3 light = vec3(10.);
    vec3 N = get_normal(p);
    vec3 L = normalize(light - p);
    vec3 R = -reflect(L,N);
    vec3 V = normalize(ro - p);

    res += k_d * (dot(L,N)) * i_d + k_s * pow(max(0.,dot(R,V)),alpha) * i_s;
    return res;
}

float ray_marching(vec3 ro, vec3 rd){
    float e = 0.0001;
    float depth = 0.;

    for(int i = 0;i<255;i++){
        float dist = sdf(depth * rd + ro);

        if (dist < e){
            return depth;
        }

        depth += dist;

        if (dist > 1000.){
            return -1.;
        }
    }
    return -1.;
}

//Camera
struct OrthoGraphicCamera {
    vec3 o;
    vec3 f;
    vec3 u;
    vec3 r;
    float scale;
}


OrthoGraphicCamera get_orthograpic_camera(vec3 lookAt,vec3 eye,vec3 up,float scale){
    return OrthoGraphicCamera(
        eye,
        normalize(lookAt - eye),
        normalize(up),
        normalize(cross(lookAt,up)),
        scale
    );
}

vec3 get_ray_origin_o(OrthoGraphicCamera camera,vec2 uv){
    return camera.o + (uv.x * camera.r + uv.y * camera.u) * camera.scale;
}

vec3 get_ray_direction_o(OrthoGraphicCamera camera){
    return camera.f;
}

struct PerspectiveCamera {
    vec3 o;
    vec3 f;
    vec3 u;
    vec3 r;
    float fov;// 0-180
    float aspect; // w/d
    float near;// 0.1
    float far;//2000
}

PerspectiveCamera get_perspective_camera(vec3 lookAt,vec3 eye,vec3 up,float fov,float aspect,float near,float far){
    return PerspectiveCamera(
        eye,
        normalize(lookAt - eye),
        normalize(up),
        normalize(cross(lookAt,up)),
        fov,
        aspect,
        near,
        far
    );
}

vec3 get_ray_origin_p(PerspectiveCamera camera,vec2 uv){
    return camera.o;
}

vec3_get_ray_direction_p(PerspectiveCamera camera,vec2 uv){
    float ybase = sin(camera.fov / 180. * PI) * camera.near;
    float xbase = ybase * camera.aspect;
    return normalize(camera.f * camera.near + camera.u * uv.y * ybase + camera.r * uv.x * xbase);
}

void mainImage( out vec4 fragColor, in vec2 fragCoord )
{
    vec2 uv = fragCoord/IR.xy;
    uv -= .5;
    uv.x *= IR.x / IR.y;
    vec3 eye = vec3(0);
    vec3 lookAt = vec3(-1.,0,0);
    vec3 up = vec3(0,0,1.);
    PerspectiveCamera camera = get_perspective_camera(lookAt,eye,up,50.,1.,0.1,2000.);

    vec3 tot = vec3(0);
    # if AA > 0
    for(int i = 0;i<AA;i++)
    for(int j = 0;j<AA;j++){
    # endif

    vec3 ro = get_ray_origin_p(camera,uv);
    vec3 rd = get_ray_direction_p(camera,uv);
    float depth = ray_marching(ro,rd);
    vec3 col = vec3(1.);
    if (depth != -1.){
        col = phong(ro,ro+depth*rd);
    }
    tot += col;
    # if AA > 0
    }
    tot /= AA * AA;
    # endif

    fragColor = vec4(tot,1.);
}