#version 130










const int shader= 3;



// Parameters from our host
// x: Scene.Zeit
// y: Base drum envelope
// z: Snare drum envelope
// w: undefinded
in vec4 Y; 

// Position of the fragment
in vec2 Z; 

// All data of our world
float L, CurScene, CurTime, CurAnim, cFac, CurStep, VolLight, pi2= 6.28319, LightHeight = 50.0;
int m;
vec3 cRes, CurColor, RayStep;

vec2 rotate(vec2 v,float y)
{
	return cos(y)*v+sin(y)*vec2(-v.y,v.x);
}

//repeat around y axis w times
//void rp(inout vec3 p, float trans, float w) 
float repeatr(inout vec2 v,float x, float y) 
{
    float a= atan(v.y,v.x);
	float z=mod(a,y)-y*.5;
	v=(length(v))*vec2(cos(z),sin(z));
	v.x-=x;
    return a-z;
}
 
void repeat( inout float w, float y )
{
	w= mod( w - y*.5, y ) - y*.5;
}

void repeate( inout float w, float y, float z )
{
	w= max( abs(w)-z, mod( w - y*.5, y ) - y*.5);
}

float CBox( in vec3 p, in vec3 box, float rad )
{
    return length( max( abs(p) - box + vec3(rad), 0.0 ) ) - rad;
}


float plasm(float x, float a, float b,float c)
{
	return sin(x+a+c*sin(x+b));
}

vec3 shad2move()
{
	return vec3( CurTime*19.0, 24.0 - cos(CurAnim*9.0) * 8.0, cos(CurAnim*5.0) * 24.0);
}

void schad3transform( inout vec3 p )
{
	p.xz = rotate(p.xz, 0.2 * cos( pow(abs(p.x),0.4 - CurTime * 0.1)) );
	p.yx = rotate(p.yx, 0.2 * cos( pow(abs(p.x),0.3 + CurTime * 0.1)) );
}

float f0(vec3 p)
{
	if( shader == 0 )
	{
		schad3transform(p);
		repeat(p.x, 0.5);
		return max( length(p.x) - 0.1, CBox( p, vec3(1000.,1.4,1.4), .5));
	}
	if( shader == 1 )
	{
		p -= shad2move();
		//p.y = rotate(p.yz, 50. *CurAnim );
		p.x = length (p.xz)+4*Y.y - 12.5;
		repeat (p.x, 24.0);
		return length( max( abs(p.xy) - vec2(3., .2), 0.0 ) ) - 0.2;
	}
	if( shader == 2 )
	{
		float d = p.x;
		repeat(p.x, pi2);
		p.y -= 0.3 * cos(  (p.z + d - p.x)*.5);
		p.z += 128.0 * CurTime * cos(0.7 * (d-p.x) );
		repeat(p.z, 2.4);
		return CBox( p, vec3(1.0, 0.1, 1.0), 0.1); 
	}
	if( shader == 3 )
	{
		p.x -= 128. * CurAnim;
		repeat(p.x, 64.);
		p.x = length( p.x ) - 11.;
		return (p.x < 0.0 ? length( p.yz ): length( p )) -  5.0 ;
	}
}

float f1(vec3 p)
{
	if( shader == 0 )
	{
		float d = p.y - 5.;
        p.x *= 1.0;
		repeat(p.x, 20.);
		repeatr(p.yz, 28.0, pi2 / 9.0);
		return max( d,  CBox( p, vec3(10.,2.0,10.), 3.));
	}
	if( shader == 1 )
	{
		vec3 o= p;
		repeat(p.x, 8.0);
		repeat(p.z, 8.0);
		o -= shad2move();
		p.xz = rotate(p.xz, atan(o.x, o.z) );
		p.yz = rotate(p.yz, atan(length(o.xz), 48.0) );
		float d = CBox( p, vec3(2.5 , 2.0, 2.5), 0.8); 
		p.y += 12.;
		return max(d,  length(p)- 12.);
	}
	if( shader == 2 )
	{
		float d = p.z;
		repeat(p.z, pi2);
		p.y += 0.3 * cos( (p.x + d - p.z)*.5);
		return CBox( p, vec3(1000.0, 0.1, 2.0), 0.1); 
	}
	if( shader == 3 )
	{
		p.z = length(p.z) + 15.;
		float d = length(p.y) - 15.;
		repeat(p.x, 100.);
		//repeat(p.y, 9.);
		repeatr(p.zy, 85.0, pi2 / 40.0);
		repeatr(p.zx, 58.0, pi2 / 50.0);
		return max( d, CBox( p, vec3(4.,3.,1.), 1.)); //max( length(p) - 64.,  CBox( p, vec3(4.,4.,80.), 1.));
	}
}

float f2(vec3 p)
{
	if( shader == 0 )
	{
		schad3transform(p);
		p.x += 256.0 * CurAnim;
		repeat(p.x, 32.0);
		return length(vec2(length(p.yz) - 3.0,p.x)) - 1.- Y.y;
	}
	if( shader == 1 )
	{
		return length(p-shad2move()) - 12.0;
	}
	if( shader == 2 )
	{
		p.y -= 8.;

		float d = p.x;
		repeat(p.x, 32.0);

		p.yz = rotate(p.yz, plasm(d-p.x, 2., CurAnim, 1.0)- Y.z );
		p.xz = rotate(p.xz, plasm(d-p.x, 1., CurAnim, 2.0) );

		return CBox( p, vec3(8.0), 6. - CurAnim);
	}
	if( shader == 3 )
	{
		p.yz = rotate(p.yz, plasm(round(p.x / 8.0), 1., 4.0*CurTime, 2.0) );
		repeat(p.x, 8.0);
		repeatr(p.yz, 0.0, pi2 / 10.0);
		return max( abs(length(p.yz) - 6.0)-.2, abs(length(p.xz) - 2.+0.5*Y.y)-.3);
	}
}

float f3(vec3 p)
{
	if( shader == 0 )
	{
		schad3transform(p);
		return CBox( p, vec3(1000.,1.,1.), .1);
	}
	if( shader == 1 )
	{
		p.y += 20.;
		repeat( p.x, 6.3);
		repeat( p.z, 1.3);
		//repeatr(p.xz, .0, pi2 / 4.0);
		return CBox( p, vec3(3.0, 15.0, 0.5), 0.4);
	}
	if( shader == 2 )
	{
		p.y -= 20.;
		repeat( p.x, 20.0);
		repeat( p.z, 20.0);
		repeatr(p.xz, .0, pi2 / 4.0);
		return CBox( p, vec3(1000.0, 1.0, 1.0), 0.2);
	}
	if( shader == 3 )
	{
		repeat(p.z, 6.);
		repeat(p.x, 5.5);
		repeatr(p.xz, 2.0, pi2 / 6.0);
		return max( abs(1.-length(p.xz))-0.1,abs(length(p.y)-15.0)-0.1);
	}

}


float f(vec3 p)
{
	return (Y.y * 0.003+0.001) * plasm(p.x+Y.y*9., p.y, p.z,  1.0-Y.y) + min( min( min( f0(p), f1(p) ), f2(p) ), f3(p) );
}

float l(vec2 p)
{
    float d = floor(0.5 - p.y/32.0) + floor(0.5 - p.x/70.0) * 3.;
    if( shader == 1 || shader == 2 )
	{
		d= plasm( 33.0 * floor(0.5 - p.y/20.0), 17.0 * floor(0.5 - p.x/20.0), floor(CurTime * 8.0), 1.0);
		repeate( p.x, 20.0, 60.0 );
		repeat( p.y, 20.0);
		L = length( max( abs(p) - vec2(3.0), 0.0 ) ) + 2.0;// max( length(p.x), length(p.y));
        if (d > 0.5)
			L /= 1.0 - 0.5 * Y.y;
        else
            L /= 1.0 - 0.5 * Y.z;
        //float sync = shader == 1 ? Y.z : Y.y;
		//repeate( p.x, 20.0, 60.0 );
		//repeate( p.y, 20.0, 100.0 );
        //vec2 q = p;
        //q.y += 10;
        //repeat (q.y, 40.0);
		//repeat( p.y, 20.0);
		//repeat( p.x, 20.0);
		//L = length( max( abs(p) - vec2(3.0), 0.0 ) ) + 1.0;// max( length(p.x), length(p.y));
        //L = L * step(q.y, 0) + L * step(0, q.y) / (1.0 - 0.3 * sync);
        //L /= (1.0 - Y.y) * (step(0, q.y));
	}
	else
	{
		repeate( p.y, 32.0, 32.0 );
		repeat( p.x, 70.0 );
		p.x = length(p.x) - 25.0;
		L =  2.0 + (p.x < 0. ? length(p.y) : length(p));
        L *= 1.0 - 0.5 * Y.z;
	}
    if( CurScene == 0 )
	    return max(0., 4.0 * smoothstep(10.,-pow(sin(d+CurTime*15.0*CurTime*220.0)+CurTime*15.0-4.0,.2),L));

    return 4.0 * smoothstep(10.,0.0,L);
}

void mat(vec3 p)
{
	CurColor = vec3(1.,1.,0.);
	CurStep= .3;
	//CurNormal.y= 1.5;

	float z= f0(p);
	if( z > f1(p) )
	{
		z= f1(p);
		CurColor = vec3(0.1);
		CurStep= 0.85;
		//CurNormal.y= 0.15;
	}
		
	if( z > f2(p) )
	{
		z= f2(p);
		CurColor = vec3(0.6,0,0.15);
		CurStep= .2;
		//CurNormal.y= 0.0;
	}

	if( z > f3(p) )
	{
		//Wz= f3(p);

		CurColor = vec3(.25);// + animTex(p.zy / 10.0) * 0.6;
		CurStep= .1;
		m=2;
	}
}


void ToRes(vec3 Color, float Factor)
{
	cRes+= Color * cFac;
	cFac*= Factor;
}

void main()
{
	CurScene= floor(Y.x);
	CurTime= Y.x - CurScene;
	CurAnim= CurTime;

	// Get the look direction for the current pixel (always look forwards)
	vec3 rayDir = vec3( 0.6, (Z.yx - 0.5));
	
	//Kamera sitzt an dieser Position
	vec3 p;

	if( CurScene == 0.0 )
	{
		p= vec3(  CurTime * 120. - 120. , -24.0, .0);
		rayDir.xy= rotate( rayDir.xy, CurTime - 0.9  );
		//rayDir.xz= rotate( rayDir.xz, CurTime );
		//rayDir.yz= rotate( rayDir.yz, 0.9 - CurTime );
	}
	else if( CurScene == 1.0 )
	{
		p= vec3( 0., 5.0, -2.0);
		rayDir.xy= rotate( rayDir.xy, -0.4 );
		rayDir.xz= rotate( rayDir.xz, CurTime );
		CurAnim= CurTime*CurTime;
	}
	else if( CurScene == 2.0 )
	{
		p= vec3( -CurTime * 200. + 140, -2., 5.0);
		rayDir.xy= rotate( rayDir.xy, CurTime-0.8 );
		rayDir.xz= rotate( rayDir.xz, 3.14 );
	}
	else if( CurScene == 3.0 )
	{
		p= vec3( -25. , 0., CurTime * 20.0 - 19.0);
		rayDir.xy= rotate( rayDir.xy, -0.2 );
	}
	else if( CurScene == 4.0 )
	{
		p= vec3( 0., 40.0, CurTime *8.);
		rayDir.xy= rotate( rayDir.xy, -CurTime );
		CurAnim= 0;
	}
	else if( CurScene == 5.0 )
	{
		p= vec3( 0., 40.0, CurTime * -64. + 56.);
		rayDir.xy= rotate( rayDir.xy, -1.0 );
		CurAnim= 0.4*CurTime*CurTime;
	}
	else if( CurScene == 6.0 )
	{
		p= vec3( 0., 12.0, CurTime * -12.0);
		rayDir.xy= rotate( rayDir.xy, CurTime - 1.5);
		rayDir.xz= rotate( rayDir.xz, CurTime );
	}
	else if( CurScene == 7.0 )
	{
		p= vec3( -4., CurTime * 64. + 4.0,  0.);
		rayDir.xy= rotate( rayDir.xy, -1.0 );
		rayDir.xz= rotate( rayDir.xz, -CurTime );
	}
	else if( CurScene == 8.0 )
	{
		p= vec3( 8.0, 8.0, CurTime * 24. - 32.);
		rayDir.xy= rotate( rayDir.xy, -0.3 );
		rayDir.xz= rotate( rayDir.xz, CurTime );
		CurAnim= 0;
	}
	else if( CurScene == 9.0 )
	{
		p= vec3( CurTime * 14., 18.0, 0.);
		rayDir.xy= rotate( rayDir.xy, -CurTime-0.5 );
		CurAnim= CurTime*CurTime;
	}
	else if( CurScene == 10.0 )
	{
		p= vec3( 2.0, CurTime * 4. + 2.0, CurTime * 12.+ 7.);
		rayDir.xy= rotate( rayDir.xy, -0.2 );
		rayDir.xz= rotate( rayDir.xz, -CurTime );
	}
	else if( CurScene == 11.0 )
	{
		p= vec3( CurTime * 70. - 80., CurTime * -4. + 6.0, CurTime * 64.- 56.);
		rayDir.xy= rotate( rayDir.xy, -0.2 );
		rayDir.xz= rotate( rayDir.xz, CurTime );
		CurAnim= 4.*CurTime;
	}
	else if( CurScene == 12.0 )
	{
		p= vec3( 30.,-8.,-8.);
		rayDir.xy= rotate( rayDir.xy, 0.2 );
		rayDir.xz= rotate( rayDir.xz, -CurTime + 3.0 );
		CurAnim= 0.4*CurTime*CurTime;
	}
	else if( CurScene == 13.0 )
	{
		p= vec3( -60.,12.,0.);
		rayDir.xy= rotate( rayDir.xy, CurTime - 1.5 );
	}
	else if( CurScene == 14.0 )
	{
		p= vec3( -22.,0.,-8.);
		//rayDir.xy= rotate( rayDir.xy, 0.2 );
		rayDir.xz= rotate( rayDir.xz, -CurTime + 2.0 );
		//CurAnim= 0.4*Y.y;
	}
	else if( CurScene == 15.0 )
	{
		p= vec3( 80. * CurTime,  7. ,-0.);
		rayDir.xz= rotate( rayDir.xz, 3.*CurTime );
	}
	if( CurScene == 16.0 )
	{
		p.x = 43.0;
		rayDir.xz= rotate( rayDir.xz, pi2/2.);
		CurAnim= CurTime*CurTime;
	}
	

	/////////////////////////////////////////////////////////////////////
	//Debugzeug fuer Kamerasteuerung
	if( true )
	{
		p.x= gl_ModelViewMatrix[0][0];
		p.y= gl_ModelViewMatrix[0][1];
		p.z= gl_ModelViewMatrix[0][2];
	
		float a1= gl_ModelViewMatrix[1][1];
		float c1,s1;vec3 q1= vec3((Z.xy - 0.5), 0.8);
		c1 = cos(a1); s1 = sin(a1);
		rayDir.y = c1 * q1.y - s1 * q1.z;
		rayDir.x= q1.x;
		rayDir.z = s1 * q1.y + c1 * q1.z;

		a1= gl_ModelViewMatrix[1][0];
		q1=rayDir;
		c1 = cos(a1); s1 = sin(a1);
		rayDir.x = c1 * q1.x + s1 * q1.z;
		rayDir.z = -s1 * q1.x + c1 * q1.z;
	}
	//Ende Debugzeug fuer Kamerasteuerung
	/////////////////////////////////////////////////////////////////////

	
	rayDir = normalize(rayDir);

	cRes= vec3( .0 );
	cFac=1.0;
	
	float t=0.0,y,z;
  
	m=0;
	while (m++<2)
	{
		//bis zu einer Oberflaeche steppen
		//for (CurStep=1.0;t<220.0 && CurStep>t*.003;t+=0.01+max(0.0, CurStep),RayStep=rayDir*t )
		for (CurStep=1.0;t<220.0 && CurStep>t*.003;t+=CurStep,RayStep=rayDir*t )
			CurStep = f(p+RayStep);

		vec3 NextPos = p+RayStep;
		VolLight = 0.0;
		if( p.y < LightHeight && NextPos.y > LightHeight)
		{
			float f = (p.y - LightHeight) / (p.y - NextPos.y);
			p += RayStep*f;
			VolLight = l(p.xz) * smoothstep( 220.0,0.0, f * t );
		}
		
		//Startpunkt und Richtung fuer reflektierten Strahl;
		p= NextPos;
		
		vec3 n = vec3(0.04, 0.0, 0.0);
		n= normalize(vec3( f(p + n.xyy) - f(p - n.xyy), f(p + n.yxy) - f(p - n.yxy), f(p + n.yyx) - f(p - n.yyx) ));
		//n= normalize(n);
		//CurStep ab hier == Reflektion !!!
		mat(p);
		
		float Ambient= 0.45 + 0.4 * dot( n,vec3(0,1.0,0) );


		ToRes(vec3(0.7,1.0,0.9)*VolLight,1.0-VolLight);
		L= smoothstep( 0.,128., t );
		ToRes(vec3( 0.0, 0.0, 0.05 )*L,1.0-L); // FogColor
		
		if( t > 220.0 )
			break;
		
		rayDir= reflect( rayDir, n );

		//float ao(vec3 p, vec3 n, float d, float i) {
		y= 6.0;
		for (z=1.0;y>0.;y--)
			z-=(y*.5-f(p+n*y*.5))/exp2(y);
		CurColor*= z*Ambient;
		
		//CurColor*= .4 + .3 * ( dot(normalize(LightPos-p),n) );
    
		cRes+= cFac*CurColor;//*(1.0-Reflect);
		cFac*= CurStep;// Reflect * (1.0-t/tmax);
		t= 0.5;
		RayStep=rayDir*t;
	}
	
	
	gl_FragColor.xyz = cRes;// + Y.w;// + cFac*FogColor;
	
}