precision highp float;
uniform vec2 resolution;
uniform vec2 mouse;
uniform float time;
uniform sampler2D backbuffer;
out vec4 outColor;

#define PI 3.1415926535897932384626433832795
#define TAU 6.283185307179586476925286766559

#define tv_ID 1
#define tumami_ID 2
#define screen_ID 3    
#define floor_ID 4
#define light_ID 5

//Scene Time
float worldTime = 0.0;
float TIME = 0.0,SAM = 0.0;
int ID = -1;
#define S(a) TIME=max(TIME,step(worldTime,SAM+a-0.01)*(worldTime-SAM));ID+=int(step(SAM,worldTime));SAM+=a;

//main_camera
vec3 mainCameraP = vec3(0.0);
vec3 mainCameraD = vec3(0.0);
vec2 mainCameraUV = vec2(0.0);

//main_object 
vec3 mainObjectP = vec3(0.0);
int objID = 0;

//sub object
vec3 subObjectP = vec3(-10.0);

//Debug
float debugfactor = 0.0;

//-------------------------------
//Debug
//--------------------------------

//-------------------------------
//Math
//-------------------------------

//Rotate
vec2 rotate(vec2 v, float a) {
    float s = sin(a);
    float c = cos(a);
    mat2 m = mat2(c, -s, s, c);
    return m * v;
}

//point simetric
vec2 point_symmetric(vec2 p) {
    vec2 n = normalize(vec2(-1, 1));
    return (p.x + p.y > 0.0) ? p : p - 2.0 * n * dot(p,n);
}

//tangent space
void tangentSpaceBasis(vec3 normal,inout vec3 t,inout vec3 b){
    if (abs(normal.y) < 0.9)
    {
        t = cross(normal, vec3(0, 1, 0));
    }
    else
    {
        t = cross(normal, vec3(0, 0, -1));
    }
    t = normalize(t);
    b = cross(t, normal);
    b = normalize(b);
}
//basis transformation
vec3 worldtoLoacal(vec3 v,vec3 lx, vec3 ly,vec3 lz){
    return vec3(v.x * lx.x + v.y* lx.y + v.z * lx.z,
                 v.x * ly.x + v.y * ly.y + v.z * ly.z,
                 v.x * lz.x + v.y * lz.y + v.z * lz.z);
}

vec3 localToWorld(const vec3 v, const vec3 lx, const vec3 ly,
                   const vec3 lz)
{
    return vec3(v.x * lx.x + v.y * ly.x + v.z * lz.x,
                 v.x * lx.y + v.y * ly.y + v.z * lz.y,
                 v.x * lx.z + v.y * ly.z + v.z * lz.z);
}

bool is_inside(float t, float a, float b){
    return (t >= a && t <= b);
}

vec2 kaleido_pmod(vec2 p, float r)
{
    float a = atan(-p.x, -p.y) + PI;

    float n = TAU / r;
    float ID = floor(a / n);

    p.x *= (int(ID) % 2 == 0) ? 1.0 : -1.0;
    float b = atan(-p.x, -p.y) + PI;
    ID = floor(b/n);
    b = ID*n;

    return rotate(p,-b);
}

float saturate(float t){
  return clamp(t,0.0,1.0);
}

//--------------------------------
//Hash
//--------------------------------

//Blue Noise
#define hash(p)  fract(sin(mod(dot(p, vec2(12.9898, 78.233)),6.283)) * 43758.5453)

//hash
float hash11(float s) {
    return fract(sin(s) * 43758.5453123);
}

float hash21(vec2 s) {
    return fract(sin(dot(s, vec2(12.9898, 78.233))) * 43758.5453123);
}

float hash31(vec3 s) {
    return fract(sin(dot(s, vec3(12.9898, 78.233, 45.164))) * 43758.5453123);
}

vec2 hash12(float s) {
    return fract(sin(vec2(s * 194.2, s * 293.2)) * 43758.5453123);
}

vec2 hash22(vec2 s) {
    return fract(sin(vec2(dot(s, vec2(12.9898, 78.233)), dot(s, vec2(45.164, 39.645)))) * 43758.5453123);
}

vec2 hash32(vec3 s) {
    return fract(sin(vec2(dot(s, vec3(12.9898, 78.233, 45.164)), dot(s, vec3(39.645, 45.164, 12.9898)))) * 43758.5453123);
}

vec3 hash13(float s) {
    return fract(sin(vec3(s * 194.2, s * 293.2, s * 394.2)) * 43758.5453123);
}

vec3 hash23(vec2 s) {
    return fract(sin(vec3(dot(s, vec2(12.9898, 78.233)), dot(s, vec2(45.164, 39.645)), dot(s, vec2(39.645, 45.164)))) * 43758.5453123);
}

vec3 hash33(vec3 s) {
    return fract(sin(vec3(dot(s, vec3(12.9898, 78.233, 45.164)), dot(s, vec3(39.645, 45.164, 12.9898)), dot(s, vec3(45.164, 12.9898, 78.233)))) * 43758.5453123);
}


//-------------------------------
//Font
//-------------------------------

#define FontWidth 8
#define FontHeight 8
#define LineMaxLength 40
#define FontSize 37.0

ivec2 font_data[37] = ivec2[](
    ivec2(0x00000000,0x00000000), //space
    ivec2(0x7e91897e,0x00000000), //0
    ivec2(0x01ff4121,0x00000000), //1
    ivec2(0x71898543,0x00000000), //2
    ivec2(0x6e919142,0x00000000), //3
    ivec2(0x08ff4838,0x00000000), //4
    ivec2(0x8e9191f2,0x00000000), //5
    ivec2(0x0e91916e,0x00000000), //6
    ivec2(0xc0b08f80,0x00000000), //7
    ivec2(0x6e91916e,0x00000000), //8
    ivec2(0x6e919162,0x00000000), //9
    ivec2(0x7f88887f,0x00000000), //A
    ivec2(0x6e9191ff,0x00000000), //B
    ivec2(0x4281817e,0x00000000), //C
    ivec2(0x7e8181ff,0x00000000), //D
    ivec2(0x919191ff,0x00000000), //E
    ivec2(0x909090ff,0x00000000), //F
    ivec2(0x4685817e,0x00000000), //G
    ivec2(0xff1010ff,0x00000000), //H
    ivec2(0x0081ff81,0x00000000), //I
    ivec2(0x80fe8182,0x00000000), //J
    ivec2(0x413608ff,0x00000000), //K
    ivec2(0x010101ff,0x00000000), //L
    ivec2(0x601060ff,0x000000ff), //M
    ivec2(0x0c1060ff,0x000000ff), //N
    ivec2(0x7e81817e,0x00000000), //O
    ivec2(0x609090ff,0x00000000), //P
    ivec2(0x7f83817e,0x00000001), //Q
    ivec2(0x619698ff,0x00000000), //R
    ivec2(0x4e919162,0x00000000), //S
    ivec2(0x80ff8080,0x00000080), //T
    ivec2(0xfe0101fe,0x00000000), //U
    ivec2(0x0e010ef0,0x000000f0), //V
    ivec2(0x031c03fc,0x000000fc), //W
    ivec2(0x340834c3,0x000000c3), //X
    ivec2(0x300f30c0,0x000000c0), //Y
    ivec2(0xe1918d83,0x00000081) //Z
);

vec3 font(vec2 uv,int id){
    vec2 uv1 = uv;
    uv = uv * 8.0;
    ivec2 texel = ivec2(uv);
    int bit_offset = texel.x * FontWidth + texel.y;

    int s,t;
    s = font_data[id].x;
    t = font_data[id].y;

    int tex = 0;
    
    if(bit_offset <= 31){
        s = s >> bit_offset;
        s = s & 0x00000001;
        tex = s;
    }
    else{
        t = t >> (bit_offset - 32);
        t = t & 0x00000001;
        tex = t;
    }

    tex = (abs(uv1.x - 0.5) < 0.5 && abs(uv1.y - 0.5) < 0.5) ? tex : 0;
    return vec3(tex); 
}

//-------------------------------
//SDF
//-------------------------------

float sdf_union(float d1, float d2) {
    return min(d1, d2);
}

float sdf_substract(float d1, float d2) {
    return max(-d1, d2);
}

float sdf_intersect(float d1, float d2) {
    return max(d1, d2);
}

//box
float sdf_box(vec3 p, vec3 b) {
    vec3 d = abs(p) - b;
    return min(max(d.x, max(d.y, d.z)), 0.0) + length(max(d, 0.0));
}

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

//cylinder
float sdf_cylinder(vec3 p, float h, float r) {
    vec2 d = abs(vec2(length(p.xz), p.y)) - vec2(r, h);
    return min(max(d.x, d.y), 0.0) + length(max(d, 0.0));
}

//ellipsoid
float sdf_ellipsoid(vec3 p, vec3 r) {
    float k1 = length(p / r);
    float k2 = length(p / (r * r));
    return k1 * (k1 - 1.0) / k2;
}

//plane
float sdf_plane(vec3 p, vec3 n, float h) {
    return dot(p, n) + h;
}

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

float sdf_cylinder_ana(vec3 p, float h,float r,float thin){
    float d1 = sdf_cylinder(p,h,r);
    float d2 = sdf_cylinder(p,h + 1.0,r - thin);

    return sdf_substract(d2,d1);
}

//--------------------------------
//2D SDF
//--------------------------------
float d2_sdf_box(vec2 p, vec2 b) {
    vec2 d = abs(p) - b;
    return min(max(d.x, d.y), 0.0) + length(max(d, 0.0));
}

float d2_sdf_sphere(vec2 p, float r) {
    return length(p) - r;
}

float d2_sdf_arc(vec2 p,vec2 sc,float ra, float rb )
{
    p.x = abs(p.x);
    return ((sc.y*p.x>sc.x*p.y) ? length(p-sc*ra) : 
                                  abs(length(p)-ra)) - rb;
}

float ndot(vec2 a, vec2 b ) { return a.x*b.x - a.y*b.y; }

float d2_sdf_rhombus( in vec2 p, in vec2 b ) 
{
    p = abs(p);
    float h = clamp( ndot(b-2.0*p,b)/dot(b,b), -1.0, 1.0 );
    float d = length( p-0.5*b*vec2(1.0-h,1.0+h) );
    return d * sign( p.x*b.y + p.y*b.x - b.x*b.y );
}

float d2_sdf_EquilateralTriangle( in vec2 p )
{
    const float k = sqrt(3.0);
    p.x = abs(p.x) - 1.0;
    p.y = p.y + 1.0/k;
    if( p.x+k*p.y>0.0 ) p = vec2(p.x-k*p.y,-k*p.x-p.y)/2.0;
    p.x -= clamp( p.x, -2.0, 0.0 );
    return -length(p)*sign(p.y);
}



//-------------------------------
//Struct
//-------------------------------
struct material_data {
    int id;
    vec2 uv;
    vec3 pos;
    vec3 normal;

    vec3 c_pos;
    vec3 c_dir;
    float d;

    vec2 screen_uv;

    vec3 light_col;
    float light_dist;
};

//-------------------------------
//easing
//-------------------------------
float beat(float t, float e){
    float s = sin(t * PI * 2.0 / e);
    return pow(s,8.0);
}

float easeInSine(float t){
    t = saturate(t);
    return 1.0 - cos(t * PI * 0.5);
}

float easeOutSine(float t){
    t = saturate(t);
    return sin(t * PI * 0.5);
}

float easeInOutSine(float t){
    t = saturate(t);
    return -(cos(PI * t) - 1.0) / 2.0;
}

float easeInQuad(float t){
    t = saturate(t);
    return t*t;
}

float easeOutQuad(float t){
    t = saturate(t);
    return 1.0 - (1.0 - t)*(1.0 - t);
}

float easeInOutQuad(float t){
    t = saturate(t);
    return (t < 0.5) ? 2.0*t*t : 1.0 - pow(-2.0*t + 2.0, 2.0) / 2.0;
}

float easeOutCubic(float t){
    t = saturate(t);
    return 1.0 - pow(1.0 - t, 3.0);
}
float easeOutBounce(float t){
    const float n1 = 7.5625;
    const float d1 = 2.75;
    t = saturate(t);

    if (t < 1.0/d1) {
        return n1*t*t;
    } else if (t < 2.0/d1) {
        return n1*(t-=(1.5/d1))*t + 0.75;
    } else if (t < 2.5/d1) {
        return n1*(t-=(2.25/d1))*t + 0.9375;
    } else {
        return n1*(t-=(2.625/d1))*t + 0.984375;
    }
}

float easeOutBack(float t){
    const float c1 = 1.70158;
    const float c3 = c1 + 1.0;
    t = saturate(t);
    return 1.0 + c3 * pow(t - 1.0, 3.0) + c1 * pow(t - 1.0, 2.0);
}

float easeInOutJump(float t){
    t = saturate(t);
    return (t - t * t) / 0.25;
}

float easeInBack(float t){
    t = saturate(t);
    const float c1 = 1.70158;
    const float c3 = c1 + 1.0;

    return c3 * t * t * t  - c1 * t * t;
}

//--------------------------------
//Texture
//--------------------------------

float voronoi3d(vec3 p,inout float d1,inout float d2){
    vec3 sr_i = floor(p);
    vec3 sr_f = fract(p);

    d1 = 2.0;
    d2 = 2.0;
    for(int i = -1; i <= 1; i++){
        for(int j = -1; j <= 1; j++){
            for(int k = -1; k <= 1; k++){
                vec3 cell_idx = vec3(i,j,k);
                vec3 cell_offset = cell_idx + hash33(cell_idx + sr_i);
                vec3 point_dist = abs(sr_f - cell_offset);
                float dist = max(max(point_dist.x,point_dist.y),point_dist.z);

                if(dist < d1){
                    d2 = d1;
                    d1 = dist;
                }
                else if(dist < d2){
                    d2 = dist;
                }
            }
        }
    }

    return d1;
}

vec3 circuit(vec3 pos,vec3 circuit_color){
    float d1,d2,d3,d4;
    vec3 offset = vec3(1) + vec3(0,worldTime * 2.0,0);
    vec3 scale = vec3(1);
    voronoi3d(pos,d1,d2);
    voronoi3d(pos * scale+offset ,d3,d4);

    float clack_1 = d2 - d1;
    float clack_2 = d4 - d3;

    float line_width = 0.04;

     vec3 col = vec3(0);
    
    col = (clack_2 < line_width && clack_1 < 0.01) ?  circuit_color : col;
    col = (abs(clack_1 - 0.02) < 0.005) ? circuit_color : col; 

    return col;
}

//-------------------------------
//sequence
//--------------------------------

float time_normalize(float time, float a ,float b){
    return saturate((time - a) / (b - a));
}

void counter(float t,float a,inout int ID){
    ID += (t > a) ? 1 : 0;
}

//-------------------------------
//Map
//-------------------------------

float brownTV(vec3 p, inout material_data mat) {
    vec2 screen_size = vec2(0.9, 0.8);
    vec3 screen_offset = vec3(0.0, -0.2, 1.5);

    vec3 p1 = p;
    float scale = 1.0 + 0.2 * abs(p.z + 1.0);
    p1.xy *= scale;
    float d1 = sdf_box(p1, vec3(1.0, 1.0, 0.8)) / scale;

    vec3 p2 = p + vec3(0, 0, 1.0);
    float d2 = sdf_box(p2, vec3(1.0, 1.0, 0.4));

    //screen_box
    vec3 p3 = p + screen_offset;
    float d3 = sdf_box(p3, vec3(screen_size, 0.4));

    //tumami
    vec3 tumami_p = p;
    tumami_p += vec3(-0.7, 0.75, 1.37);
    tumami_p.yz = rotate(tumami_p.yz, PI * 0.5);
    float tumami_d1 = sdf_cylinder(tumami_p, 0.1, 0.1);
    float tumami_d2 = sdf_cylinder(tumami_p + vec3(0.4, 0.0, 0.0), 0.1, 0.1);

    float tumami_d = sdf_union(tumami_d1, tumami_d2);

    //screen
    vec3 p5 = p + vec3(0.0, -screen_offset.y, 0.9);
    float d5 = sdf_ellipsoid(p5, vec3(2.0, 2.0, 0.5));
    float screen_d = sdf_intersect(d5, d3); 

    //material ID
    int tv_id = tv_ID;
    int tumami_id = tumami_ID;
    int screen_id = screen_ID;    

    //uv
    float r_m = max(screen_size.x, screen_size.y);
    vec2 r_of = p.xy + screen_offset.xy;

    mat.uv = r_of / r_m;

    float d = sdf_union(d1, d2);
    d = sdf_substract(d3, d);
    mat.id = tv_id;

    mat.id = (tumami_d < d) ? tumami_id : mat.id;
    d = sdf_union(tumami_d, d);

    mat.id = (screen_d < d) ? screen_id : mat.id;
    d = sdf_union(screen_d, d);

    d -= 0.02;
    return d;
}

float point_box(vec3 p,float s1,float s2,vec2 b,float rot){
    float dif = s1 - s2;
    vec3 p1 = p - vec3(0,dif + s2,0.);
    p1.xz = rotate(p1.xz,p.y * rot);
    float d = sdf_box(p1,vec3(b.x,dif,b.y));
    return d;
}

float ifs_box(vec3 p,float time){
    float d = 1000.0;
    vec3 p1 = p;
    p1 -= vec3(0.0,0.0,0.0);
    p1.xy = rotate(p1.xy,time);
    p1.yz = rotate(p1.yz,time);
    
    p1 = abs(p1) - vec3(1.0,0.0,0.1);
    p1.xy = rotate(p1.xy,time);
    p1.yz = rotate(p1.yz,time * 2.0 + 2.1);

    for(int i = 0; i < 4; i++){
        float dt = sdf_box(p1,vec3(0.2,2.0,0.5));
        p1 = abs(p1) - vec3(1.0,0.0,0.1);
        p1.xy = rotate(p1.xy,time);
        p1.yz = rotate(p1.yz,time * 2.0 + 2.1);

        d = min(dt,d);
    } 
    return d;
}

float convergence(float x,float a){
    float x1 = x - a;
    return (step(0.0,x1) * ( - exp(-x1) + 1.0) + step(x1,0.0) * x1) + a;
}

float light_sdf(vec3 p,inout vec3 light_col){
    float d = 100.0;
    vec3 p1;

    vec3 centralP = p - mainObjectP;    
    light_col = vec3(1.0);

    float beat_ = beat(worldTime,1.0) * 0.5 + 0.5;

    if(ID == 0){
        p1 = centralP;
        d = sdf_sphere(p1,1.0);
        return d;
    }
    else if(ID == 1){
        p1 = centralP;
        d = sdf_sphere(p1,1.0);
        return d;
    }
    else if(ID == 2){
        p1 = centralP;
        d = sdf_sphere(p1,1.0);
        return d;
    }
    else if(ID == 3){
        vec3 mainObj_light1 = vec3(1.0,1.0,1.0);
        //--------------------------------
        float normal_time31 = time_normalize(TIME,13.0,14.5);
        float normal_time32 = time_normalize(TIME,14.0,15.5);
        float size31 = (1.0 + beat(worldTime,1.0) * 0.1) / (1.001 - easeInQuad(normal_time31));
        float size32 = (1.0 + beat(worldTime,1.0) * 0.1) / (easeInQuad(normal_time32) + 0.001);
        
        size31 = (1.0 + beat(worldTime,1.0) * 0.1);

        centralP.y -= -4.0 * (easeInQuad(time_normalize(TIME,39.0,40.0)));
        centralP.xy = rotate(centralP.xy,PI + TIME);
        centralP.yz = rotate(centralP.yz,PI + TIME);
        vec3 p311 = centralP;
        p311 *= size31;

        vec3 p312 = centralP;
        p312 *= size32;

        float main_d31 = sdf_sphere(p311,1.0) / size31; 
        float main_d32 = sdf_box(p312,vec3(1.0)) / size32;

        float main_d311;


        if(objID == 0){
            mainObj_light1 = vec3(1.0);
            main_d311 = sdf_sphere(p311,1.0) / size31;
        }
        else if(objID == 1){
            mainObj_light1 = vec3(0.1,0.1,1.0);
            main_d311 = sdf_boxframe(p311,vec3(1.0),0.1) / size31;
        }
        else{
            mainObj_light1 = vec3(0.1,0.1,1.0);
            float d331 = sdf_box(p311,vec3(1.0)) / size31;
            float d332 = sdf_box(abs(p311) - 0.7,vec3(0.6)) / size31;

            mainObj_light1 = (d331 > d332) ? vec3(0.0) : mainObj_light1;
            main_d311 = min(d331,d332);
        }

        d = main_d311;
        light_col = mainObj_light1;
        //--------------------------------
        
        //Pole
        vec3 p32 = p;
        p32.x = mod(p32.x, 12.0) - 6.0;
        p32.z += 10.0;

        float cycle31 = 4.0;
        float localTime31 = time_normalize(mod(TIME, cycle31),1.0,2.0);
        float count_cycle31 = float(int(floor((TIME / cycle31))) % 2);

        float s31 = mix(-3.0,10.0,easeInOutQuad(time_normalize(mod(TIME, cycle31),1.0,2.0)));
        float s32 = mix(-3.0,10.0,easeInOutQuad(time_normalize(mod(TIME - 0.5, cycle31),1.0,2.0)));

        float move_box = point_box(p32,s31,s32,vec2(1.0,1.0),count_cycle31);
        
        //Sphere
        float offset_mask = float(is_inside(TIME,20.0,40.0));
        float offset_mask1 = float(is_inside(TIME,18.5,20.0) || bool(offset_mask));
        float ring_mask = float(is_inside(TIME,19.0,40.0));

        float local_time3 = mod(TIME,2.0);
        float local_time31 = time_normalize(local_time3,0.0,1.0);
        float ease31 = easeInOutJump(local_time31);
        float offset31 = ease31 * 2.5;
        offset31 -= 3.0;
        
        float size_offset31 = 0.1 * easeInOutJump(time_normalize(local_time3,1.0,2.0));
        vec3 size331 = vec3(0.5) + vec3(size_offset31,-size_offset31,size_offset31) * offset_mask1;

        vec3 p33 = p - subObjectP;

        //Loop
        {
            p33.y -= offset31 * offset_mask1;
            p33.y -= size331.y * offset_mask1;
            p33.x -= easeInOutQuad(local_time31)* 4.0 * offset_mask;
        }

        vec3 ring_p3 = p - subObjectP;
        float ring_dis;
        {
            float local_time33 = mod(TIME-1.0,2.0);
            float ease_33 = easeOutCubic(local_time33 * 2.0);
            
            float radius = 3.0 * ease_33;
            float thin = 0.2 * (1.0 - ease_33);
            float fade = ease_33 * 0.3;
       
            ring_p3.x = mod(ring_p3.x,4.0) - 2.0;
            ring_p3.y -= -4.0;

            ring_p3.y += fade;
            
            float ring_d1 = sdf_cylinder_ana(ring_p3,1.0,radius,thin);
            float ring_d2 = sdf_cylinder_ana(ring_p3 - vec3(4.0,0.0,0.0),1.0,radius,thin);
            float ring_d3 = sdf_cylinder_ana(ring_p3 + vec3(4.0,0.0,0.0),1.0,radius,thin);

            ring_dis = min(ring_d1,ring_d2);
            ring_dis = min(ring_dis,ring_d3);
        }

        p33.x = mod(p33.x, 4.0) - 2.0;

        {
        p33.xy = rotate(p33.xy,-PI * 4.0 * easeInOutQuad(local_time31) * offset_mask);
        }

        vec3 p331 = p33 * size31; 
        vec3 p332 = p33 * size32;
        
        float subObj_d;
        vec3 subObj_col;
        if(objID == 0){
            subObj_col = vec3(1.0);
            subObj_d = sdf_sphere(p331,0.5) / size31;
        }
        else if(objID == 1){
            subObj_col = vec3(0.1,0.1,1.0);
            subObj_d = sdf_box(size331,size331) / size32;
        }
        else{
            subObj_col = vec3(1.0);
            subObj_d = sdf_box(p331,size331) / size32;
        }

        light_col = (move_box < d) ? vec3(0.0,0.0,0.0) : light_col;
        d = sdf_union(d,move_box);

        light_col = (subObj_d < d) ? subObj_col : light_col;
        d = sdf_union(d,subObj_d);

        d = bool(ring_mask) ? sdf_union(d,ring_dis) : d;
        
        light_col *= beat_;

        return d;
    }
    else if(ID == 4){
        float frequent = 4.0;
        float local_time41 = mod(TIME,4.0);

        vec3 p41 = centralP;
        vec3 p42 = p;

        float mask_pole1 = float(is_inside(local_time41,2.0,3.0));
        float mask_pole2 = float(is_inside(local_time41,3.0,4.0));
        float mask_light = float(is_inside(local_time41,1.0,2.0));
        
        vec3 object_light = vec3(1.0) * mask_light;
        vec3 pole_light1 = vec3(0.2,0.2,0.8) * mask_light;
        vec3 pole_light2 = vec3(0.8,0.2,0.2) * mask_light;

        //Main Object
        {
            float d4_obj = 1000.0;
            float size1 = 1.0 + beat(worldTime,1.0) * 0.1;
            p41 *=size1;

            //lastOffset
        
            d4_obj = ifs_box(p41,TIME);
            light_col = (d < d4_obj) ? vec3(1.0) : light_col;
            d = min(d,d4_obj / size1);
        }

        vec3 pole_color = vec3(1.0);
        float pole_dist = 10000.0;
        //pole
        {
            float local_pole_time =  time_normalize(mod(local_time41,1.0),0.0,1.0);


            p42.x -= 1.0;
            p42.x = mod(p42.x, 14.0) - 7.0;
            p42.z += 2.0 * mask_pole1;
            p42.z = mod(p42.z, 4.0) - 2.0;

            float y_up = 10.0;
            float y_down = -8.0;

            float ease_1 = easeInOutQuad(local_pole_time);

            float point_y1;
            float point_y2;

            point_y1 = (bool(mask_pole1)) ? y_down + ease_1 * (y_up - y_down) : y_up;
            point_y2 = (bool(mask_pole1)) ? y_down : y_up + ease_1 * (y_down - y_up) ;
            float d4_pole = point_box(p42,point_y1,point_y2,vec2(0.3,0.3),0.0);

            pole_dist =(is_inside(local_time41,2.0,4.0)) ?  d4_pole : pole_dist;
            pole_color = mask_pole1 * pole_light1 + mask_pole2 * pole_light2;
        }        

        light_col = (pole_dist < d) ? pole_color : object_light;
        d = sdf_union(d,pole_dist);

        light_col *= beat_;

        return d;
    }
    else if(ID == 5){
        float local_time51 = convergence(TIME,5.0);
        float local_time52 = time_normalize(TIME,8.0,8.0);
        float local_time53 = time_normalize(TIME,8.0,12.0);
        

        vec3 p51 = centralP;
        float size51 = 1.0 + beat(local_time51,1.0) * 0.1;

        p51.z -= 30.0 * easeInBack(local_time53);
        float offset51 = -20.0;
        float x5 = p51.z - offset51;
        size51 += 1.0 / (1.001 - local_time53) - 1.0;

        p51.xy = rotate(p51.xy,p51.z * local_time53 * PI);
        p51.xy *=size51;
        

        float main_d51 = ifs_box(p51,local_time51);

        light_col = vec3(1.0);

        d = main_d51;
        return d;
    }

}

float map(vec3 p, inout material_data mat) {
    float d;

    vec3 tvp = p;
    float loop = 2.0;
    tvp.xy = mod(tvp.xy, loop) - loop * 0.5;
    d = brownTV(tvp, mat);

    vec3 plane_p = p;
    float p_d1 = sdf_plane(plane_p, vec3(0, 1, 0), 2.0);
    float p_d2 = sdf_plane(plane_p, vec3(0, -1, 0), 6.0);

    mat.id = (p_d1 < d) ? floor_ID : mat.id;
    mat.id = (p_d2 < d) ? floor_ID : mat.id;
    d = sdf_union(d, p_d1);
    d = sdf_union(d, p_d2);

    vec3 light_col = vec3(0.0);
    float light_d = light_sdf(p,light_col);
    mat.id = (light_d < d) ? light_ID : mat.id;
    mat.light_col = light_col;
    mat.light_dist = light_d;
    d = sdf_union(d, light_d);

    return d;
}


float screen2_map(vec3 p, inout material_data mat) {
    return sdf_sphere(p - mainObjectP, 0.85);
}

vec3 get_normal(vec3 p) {
    vec2 epsiron = vec2(0.001, 0.0);
    material_data dammy;
    return normalize(vec3(map(p + epsiron.xyy, dammy) - map(p - epsiron.xyy, dammy), map(p + epsiron.yxy, dammy) - map(p - epsiron.yxy, dammy), map(p + epsiron.yyx, dammy) - map(p - epsiron.yyx, dammy)));
}

vec3 get_normal2(vec3 p) {
    vec2 epsiron = vec2(0.001, 0.0);
    material_data dammy;
    return normalize(vec3(screen2_map(p + epsiron.xyy, dammy) - screen2_map(p - epsiron.xyy, dammy), screen2_map(p + epsiron.yxy, dammy) - screen2_map(p - epsiron.yxy, dammy), screen2_map(p + epsiron.yyx, dammy) - screen2_map(p - epsiron.yyx, dammy)));
}

//--------------------------------
//Screens
//--------------------------------

vec3 white_noise(vec2 uv, float offset) {
    return vec3(hash21(uv + TIME + offset * 10.0));
}

vec3 screen_sphere(vec2 uv, float offset) {
    vec3 col = vec3(0.0);

    vec3 ro = mainCameraP;
    vec3 rd = normalize(vec3(mainCameraUV, 2.0));

    float t;
    float d = 0.0;
    material_data dammy;

    for(int i = 0; i < 20; i++) {
        t = screen2_map(ro + rd * d, dammy);
        d += t;
        if(i < -1) break;
    }

    if(t < 0.01) {
        vec3 normal = get_normal2(ro + rd * d);
        col = normal * 0.5 + 0.5;
    }

    return col;
}

vec3 screen_hacking(vec2 uv, float offset) {
    uv = uv * 0.5 + 0.5;
    vec2 uv1 = uv * 40.0;
    
    uv1.y -= floor(TIME) * 1.2;

    ivec2 index = ivec2(uv1 / vec2(0.8,1.2));
    uv1.x = mod(uv1.x,0.8);
    uv1.y = mod(uv1.y,1.2);
    
    int isLine = 10 - int(floor(worldTime)) + int((hash11(offset) - 0.5) * 3.0);
    bool line_mask = (float(LineMaxLength) * fract(TIME) > float(index.x)) ? true : false;

    vec2 rnd_index = vec2(hash11(float(index.y) + offset),hash21(vec2(index) + offset));
    int max_char = int(rnd_index.x * float(LineMaxLength));

    int char_index = int(rnd_index.y * 37.0);
    //int char_index = int(rnd_index.y * 100.0); //Bug

    char_index = (index.x < max_char) ? char_index : 0;

    vec3 col = vec3(font(uv1,char_index)); 

    if(isLine == index.y) 
    {
        col *= float(line_mask);
    }
    else{
        col *= float(index.x < LineMaxLength);
        col *= float(index.y > isLine);
    }

    return col * vec3(0.1,1.0,0.1);
}

vec3 palette( in float t, in vec3 a, in vec3 b, in vec3 c, in vec3 d )
{
    return a + b*cos( 6.28318*(c*t+d) );
}

vec3 screen_kaleidoscope(vec2 uv){
    uv *= 10.0;

    uv = kaleido_pmod(uv,8.0);
    uv += vec2(1.0) * sin(TIME);
    uv = rotate(uv,PI*0.25 * TIME);

    float sum_size = 1.0;
    float size =1.1;
    float d = 100.0;
    float sum = 0.0;

    for(float i = 0.; i < 9.0; i++){

        float td = d2_sdf_rhombus(uv,vec2(0.1 / sum_size,1.0 * sum_size)) / sum_size;
        float td1 = d2_sdf_box(mod(uv,5.0) - 2.5,vec2(0.03 / sum_size,1.0 * sum_size)) / sum_size;
        td = min(td,td1);

        uv = abs(uv) - vec2(1.0,1.0 + 0.7 * sin(floor(TIME)));
        uv = kaleido_pmod(uv,2.0);
        d = min(td,d);

        uv = rotate(uv,PI*0.25 * floor(TIME));

        uv *= size;
        sum_size *= size;

        sum += (1.0 - d) / 10.0;
    }

    vec3 col = palette(sum,vec3(0.5),vec3(0.5),vec3(1.0),vec3(0.0,0.1,0.2));
    return col;
}

vec3 start_stop(vec2 p,int id){
    float d_start = d2_sdf_EquilateralTriangle(rotate(p * 2.5,PI * 1.5)) / 2.5 - 0.01;

    vec2 p1 = abs(p) - vec2(0.15,0.0);
    float d_stop = d2_sdf_box(p1,vec2(0.05,0.3));

    p.x *= -1.0;
    float d1 = d2_sdf_EquilateralTriangle(rotate((p-vec2(0.3,0.0)) * 2.5,PI * 1.5)) / 2.5;
    float d2 = d2_sdf_EquilateralTriangle(rotate((p+vec2(0.3,0.0)) * 2.5,PI * 1.5)) / 2.5;
    
    float d_hayaokuri = sdf_union(d1,d2);

    int ID_test = id;
    float d = d_start;
    d = (ID_test == 1) ? d_stop : d;
    d = (ID_test == 2) ? d_hayaokuri : d;
    
    return (d < 0.01) ? vec3(1.0) : vec3(0.0);
}

//color bar
vec3 color_bar(vec2 uv){
    vec3 col = vec3(1.0);
    uv = uv * 0.5 + 0.5;

    int index = int(floor(uv.x * 6.0));

    uv.x = (floor(uv.y * 3.0) >= 1.0 ) ?  uv.x : ((int(floor(uv.x * 8.0)) % 2 == 0) ? 0.95 : - uv.x);

    float R = (int(floor(uv.x * 4.0)) % 2 == 0) ? 0.8 : 0.0;
    float G = (int(floor(uv.x * 2.0)) % 2 == 0) ? 0.8 : 0.0;
    float B = (int(floor(uv.x * 8.0)) % 2 == 0) ? 0.8 : 0.0;

    vec3 col1 = vec3(0.0);
    col1 = (index == 1) ? vec3(0.8) : vec3(0.0);
    col1 = (index == 0) ? vec3(0.002,0.012,0.05) : col1;
    col1 = (index == 2) ? vec3(0.025,0.00,0.107) : col1;

    col = (floor(uv.y * 12.0) >= 3.0 ) ? vec3(R,G,B): col1;

    return col;
}

//Logos
float logo_sdf_S(vec2 p, float thin){
    vec3 col = vec3(0.0);
    float angle = 4.2;
    vec2 uv1 = p;
    uv1.y -= 0.2 + thin;
    uv1 = rotate(uv1,angle);
    float d1 = d2_sdf_arc(uv1,vec2(sin(angle),cos(angle)),0.3,thin);
    
    vec2 uv2 = p;
    uv2.y += 0.2 + thin;
    uv2 = rotate(uv2,angle + PI);
    float d2 = d2_sdf_arc(uv2,vec2(sin(angle),cos(angle)),0.3,thin);

    return min(d1,d2);
}

float logo_sdf_E(vec2 p,float thin){
    vec2 uv1 = vec2(p.x,abs(p.y));
    float d1 = d2_sdf_box(uv1,vec2(0.4,thin));
    uv1.y += -0.7 + thin;
    float d2 = d2_sdf_box(uv1,vec2(0.4,thin));

    float d = min(d1,d2);

    vec2 uv2 = p;
    float d3 = d2_sdf_box(uv2 + vec2(0.3,0.0),vec2(thin,0.7));
    
    d = min(d,d3);

    return d;
}


float logo_sdf_N(vec2 p,float thin){
    vec2 uv1 = abs(p);
    uv1 += vec2(-0.482,0.0);
    float d1 = d2_sdf_box(uv1,vec2(thin,0.7));

    vec2 uv2 = p;
    uv2 = rotate(uv2,PI * 0.2);
    float d2 = d2_sdf_box(uv2,vec2(thin,0.79));
    
    return min(d1,d2); 
}

float logo_sdf_I(vec2 p, float thin){
    return d2_sdf_box(p,vec2(thin,0.7)); 
}

float logo_sdf_O(vec2 p, float thin){
    vec2 uv1 = p;
    float d1 = d2_sdf_sphere(uv1,0.7);
    float d2 = d2_sdf_sphere(uv1,0.7 - thin * 2.0);
    return sdf_substract(d2,d1); 
}

float stripe_sdf_I(vec2 p,float thin){
    vec2 uv3 = p;
    float d3 = d2_sdf_box(uv3,vec2(thin,0.7));
    vec2 uv4 = p + 0.27;
    uv4 = rotate(uv4,PI * 0.75);
    uv4.y = mod(uv4.y,0.20) - 0.1;
    float d4 = d2_sdf_box(uv4,vec2(100.0,0.045));

    d3 = sdf_substract(d4,d3);
    return d3;
}

vec3 sessions_logo(vec2 uv){
    vec3 col = vec3(0.0);
    float thin = 0.1;

    float d1 = logo_sdf_S(uv - vec2(0.35,0.0),thin);
    float d2 = stripe_sdf_I(uv + vec2(0.35,0.0),thin);

    float d = min(d1,d2);

    col = (d < 0.0) ? vec3(1.0,1.0,1.0) : vec3(0.0);
    return col;
}

vec3 sessions_title(vec2 uv){
    vec3 col = vec3(0.0);
    float thin = 0.1;
    uv *= 10.0;
    uv.x += 3.0;

    float d1 = logo_sdf_S(uv + vec2(1.0,0.0),thin);
    float d2 = logo_sdf_E(uv,thin);
    float d3 = logo_sdf_S(uv + vec2(-1.0,0.0),thin);
    float d4 = logo_sdf_S(uv + vec2(-2.0,0.0),thin);
    float d5 = logo_sdf_I(uv + vec2(-2.85,0.0),thin);
    float d6 = logo_sdf_O(uv + vec2(-4.0,0.0),thin);
    float d7 = logo_sdf_N(uv + vec2(-5.5,0.0),thin);
    float d8 = logo_sdf_S(uv + vec2(-6.7,0.0),thin);

    float d = d1;
    d = min(d,d2);
    d = min(d,d3);
    d = min(d,d4);
    d = min(d,d5);
    d = min(d,d6);
    d = min(d,d7); 
    d = min(d,d8);
    
    col = (d < 0.01) ? vec3(1.0) : vec3(0.0);
    return col;
}

//-------------------------------
//Materialing
//-------------------------------

//blinn-phong inportance sampling
vec3 bp_IS(vec2 rnd,float n){
    float theta = acos(pow(1.0 - rnd.x,1.0 / (1.0 + n)));
    float phi = 2.0 * PI * rnd.y;

    return vec3(sin(theta) * cos(phi), cos(theta),sin(theta) * sin(phi));
}

vec3 screen_color(material_data mat){
    bool s = false;
    vec2 index = floor(mat.pos.xy * 0.5);
    vec2 uv = mat.uv;
    uv *= 1.0 + length(mat.uv)*length(mat.uv) * 0.05;
    vec3 screen_col = vec3(0.0);
    float offset = hash21(index);

    //White_Noise
    vec3 noise = white_noise(uv,offset);

    switch(ID){
        case 0:
            screen_col = color_bar(uv);

            break;
        case 1:
            vec3 logo = sessions_logo(uv);
            vec3 hacking = screen_hacking(uv,offset);

            float noise_mask = step(-sin((TIME - 0.0)* TIME),-0.2);
            bool logo_mask = TIME > 10.0;
            vec3 logo_col = mix(vec3(0.0),logo,TIME - 13.0);

            bool logo_mask2 = TIME < 15.0;

            screen_col = mix(hacking,noise,noise_mask);
            screen_col = (logo_mask) ? logo_col : screen_col;
            
            break;
        case 2:
            screen_col = noise;
            screen_col = (index.x == 0.0 && index.y == 0.0 && TIME < 10.0) ? screen_sphere(uv,offset) : screen_col;

            screen_col = (TIME < 2.0) ? noise : screen_col;
            break;
        
        case 3: 
            vec3 hacking_3 = screen_hacking(uv,offset);
            vec3 colorbar = color_bar(uv);
            float mask_31 = TIME * 10.0 - 30.0;
            bool mask_32 = is_inside(TIME,3.0,9.0);
            bool mask_sub = bool(int(index.x + 1.0)%2 == 0 && index.y == 0.0);

            screen_col = (index.x < mask_31) ?  hacking_3 : noise;
            screen_col = (mask_32 && mask_sub) ? colorbar : screen_col;
            
            break;
        
        case 4:
            float local_time4 = mod(TIME,4.0);
            vec3 kaleido_scope = screen_kaleidoscope((mat.pos.xy - vec2(1.0)) * 0.5 );

            screen_col = vec3(0.0);
            screen_col = (local_time4 > 2.0) ? kaleido_scope : screen_col;

            break;
        case 5:
            screen_col = vec3(0.0);
            screen_col = mix(screen_col,start_stop((mat.pos.xy - vec2(1.0,2.0) )* 0.2,1),step(4.0,TIME));
            screen_col = mix(screen_col,start_stop((mat.pos.xy - vec2(1.0,2.0)) * 0.2,2),step(6.0,TIME));
            screen_col = mix(screen_col,noise,step(13.0,TIME));
            screen_col = mix(screen_col,sessions_title(mainCameraUV * 0.33),step(15.0,TIME));
            break;

        default:
            screen_col = vec3(1.0);
            break;
        
    };

    return screen_col;
}

//Anbient Occulusion 
vec3 randomSphereDir(vec2 rnd)
{
    float s = rnd.x*PI*2.;
    float t = rnd.y*2.-1.;
    return vec3(sin(s), cos(s), t) / sqrt(1.0 + t * t);
}

vec3 randomHemisphereDir(vec3 dir, float i)
{
    vec3 v = randomSphereDir( vec2(hash11(i+1.), hash11(i+2.)) );
    return v * sign(dot(v, dir));
}

float ambientOcclusion(vec3 p, vec3 n)
{
    float maxDist = 1.0;
    float falloff = 1.0;

    const int nbIte = 32;
    const float nbIteInv = 1./float(nbIte);
    const float rad = 1.-1.*nbIteInv; //Hemispherical factor (self occlusion correction)

    float ao = 0.0;

    for( int i=0; i<nbIte; i++ )
    {
        float l = hash11(float(i))*maxDist;
        vec3 rd = normalize(n+randomHemisphereDir(n, l )*rad)*l; // mix direction with the normal for self occlusion problems!

        material_data dammy;
        ao += (l - max(map( p + rd,dammy),0.)) / maxDist * falloff;

        if( ao < - 1.0) break;
    }


    return clamp( 1.-ao*nbIteInv, 0., 1.);
}

vec3 reflect_light(vec3 ro,vec3 rd,vec3 c_pos) {
    vec3 pos = ro;

    float t = 0.0;

    vec3 col = vec3(0.0);
    material_data mat;
    float d;
    for(int i = 0; i < 100; i++) {
        d = map(pos, mat);
        pos += rd * d;
        t += d;
        if(i < -1) break;
    }

    if(d < 0.001) {
        mat.pos = pos;
        mat.c_pos = ro;
        mat.d = t;
        mat.screen_uv = (pos - c_pos).xy;
        if(mat.id == screen_ID){
            col = screen_color(mat);
        }
        else if(mat.id == light_ID){
            col = mat.light_col;
        }
    }

    return col * 10.0;
}

float shlick_fresnel(float F0,float c){
    return F0 + (1.0 - F0) * pow(1.0 - c,5.0);
}


vec3 tvmat(material_data mat) {
    vec3 col = vec3(0);
    bool s = false;
    vec2 index = floor(mat.pos.xy * 0.5);
    vec2 uv = mat.uv;
    uv *= 1.0 + length(mat.uv)*length(mat.uv) * 0.05;

    float offset = hash21(index);

    vec3 screen_col = screen_color(mat);

    //--------
    //Effect
    //--------
    float viggnet_power = 0.6;
    float viggnet = 1.0 - length(uv) * viggnet_power;
    screen_col *= viggnet;

    float y_bar =float(mod(uv.y + worldTime + offset * 5.0,5.0) < 0.2);
    screen_col *= 1.0 - y_bar * 0.2;

    //--------
    //Lighting
    //--------
    vec3 col1 = mat.normal * 0.5 + 0.5;
    vec3 normal = mat.normal;
    vec3 t,b;
    tangentSpaceBasis(normal, t, b);

    //AO
    float ao = ambientOcclusion(mat.pos, normal);

    //reflection 
    float roughness = 10000.0;
    vec3 ref_col = vec3(0.0);
    
    vec3 hd =  bp_IS(hash32(mat.pos + worldTime), roughness);
    vec3 ref_h = localToWorld(hd, t, normal,b);
    
    vec3 ref_rd = reflect(mat.c_dir, ref_h);
    vec3 ref_ro = mat.pos + ref_rd * 0.01;

    vec3 r_col = reflect_light(ref_ro, ref_rd,mat.c_pos);
    
    float nfactor = 8.0 * PI /(roughness + 8.0); 
    float fresnel_factor = shlick_fresnel(0.04,dot(ref_rd,ref_h));
    ref_col +=  nfactor * r_col * 4.0 * dot(ref_h,ref_rd) * 2.0 * fresnel_factor * 10.0; 

    bool mask_circule = is_inside(worldTime,44.0,77.0);
    vec3 circuit_col = circuit(mat.pos * 0.5,vec3(0.3,0.3,1.0)) * beat(TIME,2.0) * fresnel_factor;

    col = ref_col ;
    col = (mat.id == screen_ID) ? screen_col : col;
    col = (mat.id == light_ID) ? mat.light_col * fresnel_factor + col + circuit_col : col;

    return col * ao; 
}

//-------------------------------
//Raymarching
//-------------------------------

vec3 Raymarching(vec3 ro, vec3 rd,vec2 uv) {
    vec3 pos = ro;

    float t = 0.0;

    vec3 col = vec3(0.0);
    material_data mat;
    mat.light_dist = 1000.0;
    vec3 bloom_col = vec3(0.0);
    float light_d = 1000.0;
    float d;
    for(int i = 0; i < 100; i++) {
        d = map(pos, mat);
        
        bloom_col += mat.light_col * exp(-mat.light_dist * 30.0);

        if(d < 0.001) break;

        pos += rd * d;
        t += d;
    }

    if(d < 0.001){
        mat.normal = get_normal(pos);
        mat.pos = pos;
        mat.c_pos = ro;
        mat.c_dir = rd;
        mat.d = t;
        mat.screen_uv = (mat.pos - mat.c_pos).xy;
        col = tvmat(mat) ; 
    }

    return col+ bloom_col;
}

//--------------------------------
//Color
//--------------------------------

vec3 gamma_correction(vec3 col){
    return pow(col,vec3(1.0/2.2));
}

//https://www.shadertoy.com/view/lslGzl
vec3 tone_mapping(vec3 col){
	col = max(vec3(0.), col - vec3(0.004));
	col = (col * (6.2 * col + .5)) / (col * (6.2 * col + 1.7) + 0.06);
	return col;
}

const vec4 LIFT = vec4( 0.02, -0.01, 0.09, 0.0 );
const vec4 GAMMA = vec4( -0.05, 0.02, -0.08, 0.0 );
const vec4 GAIN = vec4( 1.06, 0.96, 1.10, 1.0 );

const vec3 LUMA = vec3( 0.2126, 0.7152, 0.0722 );

vec3 liftGammaGain( vec3 rgb, vec4 lift, vec4 gamma, vec4 gain ) {
  vec4 liftt = 1.0 - pow( 1.0 - lift, log2( gain + 1.0 ) );

  vec4 gammat = gamma.rgba - vec4( 0.0, 0.0, 0.0, dot( LUMA, gamma.rgb ) );
  vec4 gammatTemp = 1.0 + 4.0 * abs( gammat );
  gammat = mix( gammatTemp, 1.0 / gammatTemp, step( 0.0, gammat ) );

  vec3 col = rgb;
  float luma = dot( LUMA, col );

  col = pow( col, gammat.rgb );
  col *= pow( gain.rgb, gammat.rgb );
  col = max( mix( 2.0 * liftt.rgb, vec3( 1.0 ), col ), 0.0 );

  luma = pow( luma, gammat.a );
  luma *= pow( gain.a, gammat.a );
  luma = max( mix( 2.0 * liftt.a, 1.0, luma ), 0.0 );

  col += luma - dot( LUMA, col );

  return col;
}

//------------------------------------

void main() {
    
    worldTime = mod(time,139.0); 
    S(10.0); //TV
    S(20.0); //SceneChange
    S(11.0); //s
    S(40.0); //
    
    S(32.0); //frash
    S(25.0); //End

    vec2 uv = ((gl_FragCoord.xy + 0.5 * hash21(gl_FragCoord.xy + worldTime))* 2.0 - resolution.xy) / resolution.y;
    vec2 suv = gl_FragCoord.xy / resolution.y;
    vec2 texuv = gl_FragCoord.xy / resolution;
    
    float viggnet = length(uv);

    float distort_power = 0.05;
    float distort_r = length(uv);
    uv *= 1.0 + distort_r * distort_r * distort_power;

    vec2 dx = vec2(2.0 / resolution.x, 0.0);
    vec2 dy = vec2(0.0, 2.0 / resolution.x);

    float floor_x = mod(gl_FragCoord.x * 10.0 / 3.0, 1.0);

    bvec3 isRGB = bvec3(floor_x <= 0.33, floor_x > 0.33 && floor_x < 0.66, floor_x > 0.66);

    vec3 ro = vec3(1., 1.5, -10.0);
    vec3 rd = normalize(vec3(uv, 2.0));
    
    float rtime = PI * 0.0;

    rd.xz = rotate(rd.xz, rtime);

    float debug_t = 0.0;
    
    //-------------------------------
    //MainObject and Camera Move
    {
        if(ID == 0){
            mainObjectP = vec3(0.0,0.0,0.0);
        }
        else if(ID == 1){
            mainObjectP = vec3(0.0,0.0,0.0);
        }
        else if(ID == 2){
            ro = vec3(1.0,1.0,-10.0);
            mainObjectP = vec3(1.0,1.0,10.0);
            float st[6] = float[](
                3.0,5.0,7.0,9.0,11.0,12.0
            );

            int shot_ID = 0;
            counter(TIME,st[0],shot_ID);
            counter(TIME,st[1],shot_ID);
            counter(TIME,st[2],shot_ID);
            counter(TIME,st[3],shot_ID);
            counter(TIME,st[4],shot_ID);

            vec3 offset = vec3(0.0);


            if(shot_ID == 1){
                float offset_bounce = easeOutBounce(time_normalize(TIME,st[0],st[1])) * 10.0;

                offset = vec3(0.0,0.0,-offset_bounce);
                mainObjectP += offset;
            }
            else if(shot_ID == 2){
                float offset_charge = (1.0 - smoothstep(0.0,1.0,time_normalize(TIME,st[1],st[2]))) * 10.0;
                offset = vec3(0.0,0.0,-offset_charge);
                mainObjectP += offset;
            }
            else if(shot_ID == 3){
                float n_time3 = time_normalize(TIME,st[2],st[3]);
                offset = (hash13(TIME) * 2.0 - 1.0) * 0.05;

                n_time3 = smoothstep(0.0,1.0,n_time3);
                ro.z += n_time3 * 0.4;
                rd = normalize(vec3(uv,2.0 + n_time3 * 0.5));

                mainObjectP += offset;
            }
            else if(shot_ID == 4){
                float n_time4 = time_normalize(TIME,st[3],st[4]);

                vec3 pos_end = vec3(1.0,1.0,-20.0);
                vec3 camera_end = vec3(1.0,1.0,-30.0);
                float offset_shot = mix(0.0,-20.0,easeOutBack(n_time4));

                mainObjectP = mix(mainObjectP,pos_end,easeOutBack(n_time4));
                ro = mix(ro,camera_end,easeOutBack(n_time4));
            }
        }
        else if(ID == 3){
            mainObjectP = vec3(1.0,1.0,-20.0);
            vec3 sub_basis3 = vec3(1.0,1.0,20.0);
            ro = vec3(1.0,1.0,-30);
            float st3[5] = float[](
                3.0,10.0,40.0,50.0,80.0
            );
            int shot_ID3 = 0;
            counter(TIME,st3[0],shot_ID3);
            counter(TIME,st3[1],shot_ID3);

            
            float time_offset = worldTime - 37.0;

            float local_time_31 = time_normalize(TIME - suv.y,16.0,18.0);
            objID = 0;
            objID = (local_time_31 > 0.33) ? 1 : objID;
            objID = (local_time_31 > 0.66) ? 2 : objID;
            debug_t = local_time_31;

            if(shot_ID3 == 0){
                mainObjectP.x += time_offset;
                ro = mainObjectP + vec3(0.0,0.0,-10.0);
            }
            else if(shot_ID3 == 1){
                mainObjectP.x += time_offset;
                ro = mainObjectP + vec3(0.0,0.0,-10.0);
                float n_time32 = time_normalize(TIME,st3[0],10.0);
                subObjectP = vec3(1.0,1.0,-smoothstep(0.0,1.0,n_time32) * 15.0);
            }
            else if(shot_ID3 == 2){
                mainObjectP.x += time_offset;
                ro = mainObjectP + vec3(0.0,0.0,-10.0);
                subObjectP = vec3(1.0,1.0,-15.0);
            }
        }
        else if(ID == 4){
            mainObjectP = vec3(1.0,1.0,-10.0);
            ro = vec3(1.0,1.0,-30.0);
        }
        else if(ID == 5){
            mainObjectP = vec3(1.0,1.0,-10.0);
            ro = vec3(1.0,1.0,-30.0);
            rd = normalize(vec3(uv,2.0));
        }
    }


    mainCameraP = ro;
    mainCameraD = rd;
    mainCameraUV = uv;

    vec3 col = Raymarching(ro, rd, uv);
    col = tone_mapping(col); 
    col = gamma_correction(col);
    col *= hash21(uv + TIME) * 0.2 + 0.8;
    
    float viggnet_power = 0.2;
    col *= 1.0 - viggnet * viggnet_power;

    col = liftGammaGain(col,LIFT,GAMMA,GAIN);
    texuv = texuv * 2.0 - 1.0;
    vec2 uvR = texuv * (1.0 + length(texuv) * 0.01);
    vec2 uvG = texuv * (1.0 + length(uvR) * 0.005);
    vec2 uvB = texuv * (1.0 + length(uvR) * 0.000);
    
    float R = texture(backbuffer,uvR * 0.5 + 0.5).x;
    float G = texture(backbuffer,uvG * 0.5 + 0.5).y;
    float B = texture(backbuffer,uvB * 0.5 + 0.5).z;
    
    col = mix(vec3(R,G,B),col,0.7);


    //FadeIn Out
    col = mix(vec3(0.0),col,time_normalize(worldTime,0.0,4.0));
    col = mix(col,sessions_title(mainCameraUV * 0.33),time_normalize(worldTime,134.0,137.0));
   
    outColor = vec4(col.xyz,1);
}