uniform vec3 cam;
//uniform vec4 trans[20];
uniform int sdf_type[101];
uniform vec3 sdf_place[300];
uniform vec3 sdf_size[300];
uniform float sdf_value[101];
uniform float edge[101];

uniform vec3 light[300];
uniform vec3 l_color[300];
uniform float specular[101];
uniform float tonality[101];

varying vec2 v_vTexcoord;
varying vec3 v_vPosition;
//////////////Functions//////////////
mat4 Axis( vec3 v, float angle )
{
    float ss = sin( angle );
    float c = cos( angle );
    float ic = 1.0 - c;
    return mat4( v.x*v.x*ic + c,     v.y*v.x*ic - ss*v.z, v.z*v.x*ic + ss*v.y, 0.0,
                 v.x*v.y*ic + ss*v.z, v.y*v.y*ic + c,     v.z*v.y*ic - ss*v.x, 0.0,
                 v.x*v.z*ic - ss*v.y, v.y*v.z*ic + ss*v.x, v.z*v.z*ic + c,     0.0,
              0.0,                0.0,                0.0,                1.0 );
}
mat4 trans = Axis(vec3(0.,0.,0.),0.0);
////////Shapes//////////
float ellipsoid( vec3 pp, vec3 ss )
{
    float k0 = length(pp/ss);
    return k0*(k0-1.0)/length(pp/(ss*ss));
}
float box(vec3 pp, vec3 ss)
{
    return length(max(abs(pp)-ss / 2.,0.));
}
float cylinder( vec3 pp, vec3 ss )
{
    vec2 d = abs(vec2(length(vec2(pp.x,pp.z)),pp.y)) - ss.xy;
    return min(max(d.x,d.y),0.0) + length(max(d,0.0));
}
float cone( vec3 pp, vec3 ss )
{
    vec2 qq = vec2( length(vec2(pp.x,pp.z)), pp.y );
    vec2 k1 = vec2(ss.z,ss.xy);
    vec2 k2 = vec2(ss.z,2.0*ss.xy);
    vec2 ca = vec2(qq.x-min(qq.x,(qq.y < 0.0)?0.0:ss.z), abs(qq.y)-ss.y);
    vec2 cb = qq - k1 + k2*clamp(dot(k1-qq,k2)/dot(k2,k2), 0.0, 1.0 );
    float fs = (cb.x < 0.0 && ca.y < 0.0) ? -1.0 : 1.0;
    return fs*sqrt( min(dot(ca,ca),dot(cb,cb)) );
}
///////////Tools//////////////
float sdf_blend(float d1, float d2, float k)
{
 return k * d1 + (1. - k) * d2;
}
float sdf_round( float pp, float h )
{
    return pp - h;
}
float sdf_union( float d1, float d2, float k )
{
    float h = clamp( 0.5 + 0.5*(d2-d1)/k, 0.0, 1.0 );
    return mix( d2, d1, h ) - k*h*(1.0-h);
}
float subtract( float d1, float d2, float k )
{
    float h = clamp( 0.5 - 0.5*(d2+d1)/k, 0.0, 1.0 );
    return mix( d2, -d1, h ) + k*h*(1.0-h);
}
float intersect( float d1, float d2, float k )
{
    float h = clamp( 0.5 - 0.5*(d2-d1)/k, 0.0, 1.0 );
    return mix( d2, d1, h ) + k*h*(1.0-h);
}
float displace( float d1, vec3 pp, vec3 ss )
{
    float d2 = sin(ss.x*pp.x)*sin(ss.y*pp.y)*sin(ss.z*pp.z);
    return d1+d2;
}
vec3 twist( vec3 pp )
{
    const float k = 1.0; // or some other amount
    float c = cos(k*pp.y);
    float ss = sin(k*pp.y);
    mat3 m = mat3(c,-ss,0.,ss,c,0., 0.,0.,1.);
    return vec3((m*vec3(pp.x,pp.z,0.)).xy,pp.y);
}
vec3 bend( vec3 pp )
{
    const float k = 0.1; // or some other amount
    float c = cos(k*pp.x);
    float ss = sin(k*pp.x);
    mat3 m = mat3(c,-ss,0.,ss,c,0., 0.,0.,1.);
    return vec3((m*vec3(pp.xy,0.)).xy,pp.z);
}
////////////Lighting//////////////
float sdf_shape (int tt, float dd, vec3 pp, vec3 ss, float vv, float ee)
{
    float place_e = ee;
    float place_d = dd; ///in case dd is not used at all
    float place_v = clamp(vv,0.00000001,1000000.0); ///in case vv is not used at all
    //vec3 qq = mod(pp,c)-0.5*c;///repetition
    if (tt==0){return sdf_round(box(pp,ss),ee);}
    if (tt==1){return sdf_round(cylinder(pp,ss),ee);}
    if (tt==2){return sdf_round(cone(pp,ss),ee);}
    if (tt==3){return sdf_round(ellipsoid(pp,ss),ee);}
    //4
    if (tt==5){return sdf_blend(place_d,sdf_round(box(pp,ss),ee),place_v);}
    if (tt==6){return sdf_blend(place_d,sdf_round(cylinder(pp,ss),ee),place_v);}
    if (tt==7){return sdf_blend(place_d,sdf_round(cone(pp,ss),ee),place_v);}
    if (tt==8){return sdf_blend(place_d,ellipsoid(pp,ss),place_v);}
    //9
    if (tt==10){return sdf_union(place_d,sdf_round(box(pp,ss),ee),place_v);}
    if (tt==11){return sdf_union(place_d,sdf_round(cylinder(pp,ss),ee),place_v);}
    if (tt==12){return sdf_union(place_d,sdf_round(cone(pp,ss),ee),place_v);}
    if (tt==13){return sdf_union(place_d,ellipsoid(pp,ss),place_v);}
    return 100000000.;
}
vec3 sdf_normal (vec3 m)///apply normal values to shapes
{
 const float eps = .01;
 const int max_input = 2;
 vec3 p1 = m + vec3(eps,0.,0.);
 vec3 p2 = m - vec3(eps,0.,0.);
 vec3 p3 = m + vec3(0.,eps,0.);
 vec3 p4 = m - vec3(0.,eps,0.);
 vec3 p5 = m + vec3(0.,0.,eps);
 vec3 p6 = m - vec3(0.,0.,eps);
 float d1 = sdf_shape(sdf_type[0],0.,(trans*vec4(p1+sdf_place[0],1.)).xyz,sdf_size[0],sdf_value[0],edge[0]);
 float d2 = sdf_shape(sdf_type[0],0.,(trans*vec4(p2+sdf_place[0],1.)).xyz,sdf_size[0],sdf_value[0],edge[0]);
 float d3 = sdf_shape(sdf_type[0],0.,(trans*vec4(p3+sdf_place[0],1.)).xyz,sdf_size[0],sdf_value[0],edge[0]);
 float d4 = sdf_shape(sdf_type[0],0.,(trans*vec4(p4+sdf_place[0],1.)).xyz,sdf_size[0],sdf_value[0],edge[0]);
 float d5 = sdf_shape(sdf_type[0],0.,(trans*vec4(p5+sdf_place[0],1.)).xyz,sdf_size[0],sdf_value[0],edge[0]);
 float d6 = sdf_shape(sdf_type[0],0.,(trans*vec4(p6+sdf_place[0],1.)).xyz,sdf_size[0],sdf_value[0],edge[0]);
 for(int i = 0; i < max_input; i++)
 {
    if (i > 0)
    {
        d1 = sdf_shape(sdf_type[i],d1,p1+sdf_place[i],sdf_size[i],sdf_value[i],edge[i]);
        d2 = sdf_shape(sdf_type[i],d2,p2+sdf_place[i],sdf_size[i],sdf_value[i],edge[i]);
        d3 = sdf_shape(sdf_type[i],d3,p3+sdf_place[i],sdf_size[i],sdf_value[i],edge[i]);
        d4 = sdf_shape(sdf_type[i],d4,p4+sdf_place[i],sdf_size[i],sdf_value[i],edge[i]);
        d5 = sdf_shape(sdf_type[i],d5,p5+sdf_place[i],sdf_size[i],sdf_value[i],edge[i]);
        d6 = sdf_shape(sdf_type[i],d6,p6+sdf_place[i],sdf_size[i],sdf_value[i],edge[i]);
    }
 }
 return normalize(vec3(d1-d2,d3-d4,d5-d6));
}
vec4 simpleLambert (vec3 normal, vec3 look) ///light and shade to shapes
{
 vec3 lightDir = light[0]; // Light direction
 vec3 lightCol = l_color[0]; // Light color

 float NdotL = max(dot(normal, lightDir),0.);
 vec3 h = (lightDir - look) / 2.;
 float spec = pow( dot(normal, h), tonality[0]) * specular[0];//

 return vec4(lightCol * vec3(0.4,0.7,1.) + spec * NdotL, 1.);// ;
}
vec4 renderSurface(vec3 l, vec3 look)//////render shape, with lighting and everything
{
 vec3 n = sdf_normal(l);
 return simpleLambert(n, look);
}
/////
vec4 raymarch (vec3 pp, vec3 direction)
{
 const int max_input = 2;
 for (int i = 0; i < 64; i++)///<---64/32/16
 {
 float d1 = sdf_shape(sdf_type[0],0.,(trans*vec4(pp+sdf_place[0],1.)).xyz,sdf_size[0],sdf_value[0],edge[0]);
 for(int i = 0; i < max_input; i++)
 {
    if (i > 0)
    {
        d1 = sdf_shape(sdf_type[i],d1,pp+sdf_place[i],sdf_size[i],sdf_value[i],edge[i]);
    }
 }
  //float d2 = sdf_shape(10,d1,pp+sdf_place[1],sdf_size[1],sdf_value[1]);
  float dist = d1;
  if (dist < 0.002)
  {
    float res = 1.0;
    for( float tt=0.; tt < 6.; tt+=0.)/// mint = a[0]; maxt = a[1];
    {
        vec3 h = pp + (light[0]*tt);
        float q1 = sdf_shape(sdf_type[0],0.,(trans*vec4(h+sdf_place[0],1.)).xyz,sdf_size[0],sdf_value[0],edge[0]);
        for(int e = 0; e < max_input; e++)
        {
            if (e > 0)
            {
                q1 = sdf_shape(sdf_type[e],q1,h+sdf_place[e],sdf_size[e],sdf_value[e],edge[e]);
            }
        }
        if( q1<0.0000005 ) {res = 0.0; tt = 100000.;}///apply darkness
        res = min( res, 2.*q1/tt );
        tt += q1;
    }
    vec4 img = renderSurface(pp, direction);
    float ao = 1. - float(i) / (64.-1.);
    float amb = 0.5;
    res = (amb + res) * (1.-amb);
    //img.rgb += vec3(0.5,0.5,0.5);
    img.rgb *= (ao * res);

    return img;
  }
  pp += dist * direction;
 }
 return vec4(1.,0.,0.,0.);
}
///////////////MAIN/////////////////
void main()
{
    gl_FragColor = raymarch(v_vPosition, normalize(v_vPosition - cam));
}