const int shader= 0;

@D
//#version 430
@@

// Parameters from our host
// x: Scene
// y: Zeit
// z: Breite
// w: Hoehe
uniform vec4 Y; 

// Position of the fragment
//vec2 Z; 

// All data of our world
float cFac, CurTime, CurTime2, CurScene, CurStep, pi2= 6.28319;
int m;
vec2 CurNormal;
vec3 cRes, CurColor = vec3(0.), RayStep = vec3(0.);
vec3 LightColor= vec3( 8., 4., 2.0);
vec3 BackColor= vec3( 0.7, 1.0, 1.2);
vec4 HitMaterial;


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 row( float w, float y)
{
	return floor( ( w - y*.5 )/ y );
}

//radius of the torus/ radius of the ring
float torus(vec3 p,float f) 
{
	return length(vec2(length(p.xz) - f,p.y));
}

/*float signedDistToBox( vec3 p, vec3 b )
{
    vec3 di = abs(p) - b;
    float mc = maxcomp(di);
    return mc<0.0 ? mc : length(max(di,0.0));
}*/

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

/*float EndlessBar( vec2 p, float y, float z )
{
    return length( max( abs(p) - vec2(y) + vec2(z), 0.0 ) ) - z;
}*/

/*float noise3D( vec3 p )
{
	return fract( sin( p.x * 151.0 + p.y * 33.0 + p.z ) * 11.0 );
}

float smoothnoise(vec3 p) 
{
	vec2 e = vec2(1.0, 0.0);
	vec3 o= smoothstep(0.0,1.0,fract( p ));
	p= floor( p );

	vec4 n= mix(
		vec4(
			noise3D( p+e.yyy),//n000, 
			noise3D( p+e.xyy),//n100, 
			noise3D( p+e.yxy),//n010, 
			noise3D( p+e.xxy)),//n110),
		vec4(
			noise3D( p+e.yyx),//n001, 
			noise3D( p+e.xyx),//n101, 
			noise3D( p+e.yxx),//n011, 
			noise3D( p+e.xxx)),//n111),
		o.z);
	e = mix(n.xy, n.zw, o.y);
	return mix(e.x, e.y, o.x);	
}*/

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

float smin( float a, float b, float k )
{
    float h = clamp( 0.5+0.5*(b-a)/k, 0.0, 1.0 );
    return mix( b, a, h ) - k*h*(1.0-h);
}

float f0(vec3 p)
{
	if( shader == 0 )
	{
		float d = length(p) - 24.0 - plasm(0.3 * p.x, 8.0 * CurTime, 0.3 * p.y, sin(0.3 *p.z));
		if (CurScene == 2.)
		{
			return 999.;
		}
        else if (CurScene < 4.)
		{
			return d;
		}
        else
        {
		    p.x += sin(4.0 * CurTime2 + 0.2 * p.y);
		    p.z += sin(0.3 * p.y);
		    return 0.8 * smin (max(p.y, length (p.xz) - 4.0 - plasm(0.0, 0. + 0.2 * p.y, 0.5 * p.x, 0.3 * p.z) + 11.0 * smoothstep(11.0,-11.0, p.y + 222.0 * CurTime2)),
				d,
				11.0);
        }
	}
	else if( shader == 1 )
	{
		vec3 o = p;
		o.x += sin(4.0 * CurTime + 0.2 * o.y);
		o.z += sin(0.3 * o.y);

		p.y -= 11. - 6.0 * smoothstep( -22.0, 0.0, p.x);
 		repeat(p.y, 88.);
		float d = p.x;
		p.x -= 77.0 * CurTime;
		p.yz = rotate(p.yz, cos((0.3 * d )) + 4.0 * CurTime * cos(77.0 * row(p.x, 6.)));
		repeat(p.x, 6.);
		p.y -= 1.0;
		
		return smin( max( length(p) - 1.0, d),
						length (o.xz) - 6.0 - plasm(0.0, 0. + 0.2 * o.y, 0.5 * o.x, 0.3 * o.z),
						4.0); 
	}
	else
	{
		float d = p.x;
		p.x -= 77. * smoothstep( 0.0, 0.6 , CurTime2);
		d = plasm(16.0 * CurTime, 0.3 * p.y, 0.3 * p.z, sin(0.3 *p.x)) * smoothstep( 34.0, 33.0, d);
		if( plasm(16.0, 0.3, row(p.z, 99.), row(p.x, 77.) - (CurTime-CurTime2)) > 0.8)
		{
			d += 8.0;
		}
		repeat(p.z, 99.);
		repeat(p.x, 77.);
		return torus(p, 22.0) - 6.0 + d;
	}
}

float f1(vec3 p)
{
	if( shader == 0 )
	{
		if (CurScene < 2.)
		{
			return 999.;
		}
		p.xz = rotate(p.xz, 2.0 * CurTime2);
		repeatr(p.xz, 44.0, pi2 / 5.0);
		p.y += 77. - CurTime2 * 22.0;
		p.xy = rotate(p.xy, -CurTime2);
		vec3 o = p;
		o.y-= 17.0;
		o.x-= 38.0;
		o.xy = rotate(o.xy, 0.4);
		float d = -o.y;
		o.y += 83.0;
		return max( d, length(o) - 88.);
	}
	else if( shader == 1 )
	{
		p.xz = rotate(p.xz, 11.0 * sin(99.0 *row(p.y, 22.)) + 4.0 * CurTime * cos(66.0 * row(p.y, 22.)));
		repeat(p.y, 22.);
		float e = length(p.xz) - 22.0;
		p.z -= 44.0;
		float d = length( max(vec2(abs(p.y)- 2.7, 58.0 - length(p.xz)), 0.0)) - 2.0;
		return max(d, e);
	}
	else
	{
		repeat(p.z, 99.);
		p.x -= 77. * smoothstep( 0.0, 0.6, CurTime2) - 77. * smoothstep( 0.6, 0.9, CurTime2);
		p.y -= 22. * smoothstep( 0.5, 0.7, CurTime2) - 22. * smoothstep( 0.9, 1.0, CurTime2);
		//repeat(p.x, 77.);
		p.y -= 4.0;
		float d = CBox(p, vec3(33.0, 7.0, 33.0), 3.0);
		repeatr(p.zx, 11.0, pi2 / 2.0);
		p.y -= 11.0;
		return smin( d, CBox(p, vec3(22.0, 22.0, 8.0), 8.), 8.0);
	}
}

float f2(vec3 p)
{ 
	//p.xz = rotate(p.xz, p.y/8. );
	//repeatr(p.xz, 8.0, pi2 / 3.0);
	if( shader == 0 )
	{
		if (CurScene < 2.)
		{
			return 999.;
		}
		p.xz = rotate(p.xz, 2.0 * CurTime2);
		repeatr(p.xz, 44.0, pi2 / 5.0);
		p.y += 77. - CurTime2 * 22.0;
		p.xy = rotate(p.xy, -CurTime2);
		vec3 o = p;
		o.y-= 17.0;
		o.x-= 38.0;
		o.xy = rotate(o.xy, 0.4);
		float d = max(max(o.y, length(o) - 31.0), min(abs(o.z), (-o.y)) - 2.0);
		p.z = abs(p.z) - 8.0;
		return min( d, CBox( p, vec3(33.,8.0 - 0.1 * p.x ,4.), 2.));
	}
	else if( shader == 1 )
	{
		p.xz = rotate(p.xz, 11.0 * sin(99.0 *row(p.y, 22.)) + 4.0 * CurTime * cos(66.0 * row(p.y, 22.)));
		repeat(p.y, 22.);
		float d = length(p.xz) - 22.0;
		p.z -= 12.0;
		float e = length(p.xz) - 28.0;
		repeatr(p.xz, 0.0, pi2 / 22.0);
		return	0.6 * max( length(p.y) - 5.0, 
				smin( 
					smin( length(d) - 0.5, length(e) - 0.5, 4.0),
					max( length(p.yz) - 0.5, max(e + 2.0, 2.0 - d)),
					4.0));
	}
	else
	{
		repeat(p.z, 99.);
		float f = p.x;

		p.x -= 77. * smoothstep( 0.0, 0.6, CurTime2) - 77. * smoothstep( 0.6, 0.9, CurTime2);
		vec3 o = p;
		p.y -= 22. * smoothstep( 0.5, 0.7, CurTime2) - 22. * smoothstep( 0.9, 1.0, CurTime2);
		p.y -= 55.0;
		o.y -= 99.0;
		p.z = 11.0 - length(p.z);
		float d = CBox(o, vec3(22.0, 11.0, 33.0), 2.);
		o.z = 22.0 - length(o.z);
		float e = CBox(o, vec3(999.0, 4.0, 7.0), 2.);
		o.x = f;
		repeat(o.x, 11.);
		return min( max( e, -length(o.xz) + 4.0 ),
					smin( CBox(p, vec3(6.0, 44.0, 6.0), 2.), d, 8.0));
	}
}

float f3(vec3 p)
{
	if( shader == 0 )
	{
		if (CurScene < 2.)
		{
			return 999.;
		}
		float d = p.y + 77.0;
		repeat(p.y, 11.0);
		return max( max( length(p.y) - 2.0, d), length(CBox(p, vec3(22.,22.,22.), 3.)) - 2.0);
		return max( max( abs( p.y - 2.0), d), length(CBox(p, vec3(22.,22.,22.), 3.)) - 2.0);
		return max(p.y + 12., 24.0 - length(p.z) );
	}
	else if( shader == 1 )
	{
		p.y -= 11.;
 		repeat(p.y, 88.);
		float d = p.x + 44.0;
		p.yz = rotate(p.yz, 11.0 * sin(99.0 *row(p.x, 18.)) + 4.0 * CurTime * cos(77.0 * row(p.x, 18.)));
		
		repeat(p.x, 18.0);
		return max( d, max(CBox(p, vec3(5.,22.,22.), 2.), -CBox(p, vec3(11.,11.,11.), 4.) ));
	}
	else 
	{
		repeat(p.z, 99.);
		p.x -= 77. * smoothstep( 0.0, 0.6 , CurTime2);
		repeat(p.x, 77.);
		float d = torus(p, 22.0) - 9.0;
		p.y -= 7.0;
		d = smin( CBox(p, vec3(33.0, 7.0, 33.0), 2.), d, 8.);
		p.y += 11.0;
		return min( p.y + 10.0 + length( 4. - mod(p.x, 8.)) / 4.0, max( CBox(p, vec3(37.0, 6.0, 37.0), 3.), -d));
	}
}


float f(vec3 p)
{
	//if( shader == 0 )
		return min( min( min( f0(p), f1(p) ), f2(p) ), f3(p) );
	//else if ( shader == 1 )
	//	return .0; //min(min(min(f4(p),f5(p)),f6(p)),f7(p));
	//else if ( shader == 2 )
	//	return .0; //min(min(min(f8(p),f9(p)),f10(p)),f11(p));
	//else if ( shader == 3 )
	//	return .0; //min( min(f12(p),f13(p)),f14(p));
}

void mat(vec3 p)
{
	float z= 0.5;

	if( z > f0(p) )
	{
		HitMaterial = vec4(-1.0, 0.4, 0., 1.6);
		CurColor = vec3(0.5,.0,.1 );
		CurStep= .3;
	}
	
	if( z > f1(p) )
	{
		z= f1(p);

		HitMaterial = vec4(-2.0, 0.8, 0., 4.);
		CurColor = vec3(0.4,0.1,0.0 );
		CurStep= .8;
	}
		
	if( z > f2(p) )
	{
		z= f3(p);

		HitMaterial = vec4(-2.0, 0.8, 0.5, 1.2);
		CurColor = vec3(1.1,0.8,0.7);
		CurStep= .1;
	}

	if( z > f3(p) )
	{
		z= f2(p);

		HitMaterial = vec4(-1.0, -.3, 0.5, 0.9);
		CurColor = vec3(.2,.2,.2);
		CurStep= .05;
		CurNormal.y= 0.;
		CurNormal.x= 0.;
		//m=2;
	}
}

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

vec3 lightSphere(vec3 normal, vec3 color, vec2 desc)
{
	return smoothstep(desc.x, desc.y, dot(vec3( 0.7, 0.7, 0.0),normal)) * color;
}

void main()
{
    //Z = (gl_FragCoord.xy / Y.zw) * vec2(Y.z/Y.w, 1);

	CurTime= Y.y;
	CurScene= Y.x;
	CurTime2= CurTime * CurTime;
	// Get the look direction for the current pixel (always look forwards)

	vec3 rayDir = vec3((gl_FragCoord.xy / Y.z - 0.5), 0.6);	
	rayDir.x -= Y.w;
    float vignette = 1.0 - length(rayDir.xy / vec2(2.6,2.));
	
	//Kamera sitzt an dieser Position
	vec3 p = vec3( 99.0, 55.0, 44.0) * (1.0 - CurTime * 0.3);

	if( CurScene-- < 1.0 )
	{
		//p= vec3( 99.0, 55.0, 44.0) * (1.0 - CurTime * 0.3);
		rayDir.yz= rotate( rayDir.yz, 0.4 );
		rayDir.xz= rotate( rayDir.xz, 2.6 );
	}
	else if( CurScene-- < 1.0 )
	{
		p= vec3( -33.0, -11.0, CurTime * 33.0);
		rayDir.yz= rotate( rayDir.yz, -0.4 );
		rayDir.xz= rotate( rayDir.xz, 4.5 );
	}
	else if( CurScene-- < 1.0 )
	{
		p= vec3( 11.0, -99.0 * (1.0 - CurTime * 1.2), -88.);
		rayDir.yz= rotate( rayDir.yz, 0.5 );
		//rayDir.xz= rotate( rayDir.xz, 4.5 );
		CurTime2 = 0.0;
	}
	else if( CurScene-- < 1.0 )
	{
		p= vec3( -33.0, 44.0 * (1.0 - CurTime * 0.4), -99.);
		rayDir.yz= rotate( rayDir.yz, 0.5 );
		//rayDir.xz= rotate( rayDir.xz, 4.5 );
		//CurTime2 = CurTime;
	}
	else if( CurScene-- < 1.0 )
	{
		p= vec3( 11.0, 66.* (1.0 - CurTime * 0.4), -33.);
		rayDir.yz= rotate( rayDir.yz, 1.2 );
		//rayDir.xz= rotate( rayDir.xz, 4.5 );
		//CurTime2 = CurTime;
	}
	else if( CurScene-- < 1.0 )
	{
		p= vec3( -66.0, -88.* (0.6 + CurTime * 0.3), 66.);
		rayDir.yz= rotate( rayDir.yz, -0.4 );
		rayDir.xz= rotate( rayDir.xz, 4.5 );
		//CurTime2 = 0.0;
	}
	else if( CurScene-- < 1.0 )
	{
		p= vec3( -33.0, -99.* (0.5 + CurTime), -33.);
		rayDir.yz= rotate( rayDir.yz, -0.3 );
		rayDir.xz= rotate( rayDir.xz, 5.3 );
		//CurTime2 = 0.0;
	}
	else if( CurScene-- < 1.0 )
	{
		p= vec3( 0.0, -99.* (0.5 + CurTime * 1.5), -6.);
		rayDir.yz= rotate( rayDir.yz, -1.0 );
		//CurTime2 = 0.0;
	}
	else if( CurScene-- < 1.0 )
	{
         //////////////  Shader 1
		p= vec3(-88.* (1. + CurTime * 1.), 10.0, -4.);
		rayDir.yz= rotate( rayDir.yz, -0.3 );
		rayDir.xz= rotate( rayDir.xz, 1. - CurTime );
	}
	else if( CurScene-- < 1.0 )
	{
		p= vec3(-88.* (1. - CurTime * 0.4), 13.0, 4.);
		rayDir.yz= rotate( rayDir.yz, 0.3 );
		rayDir.xz= rotate( rayDir.xz, 3. + CurTime );
	}
	else if( CurScene-- < 1.0 )
	{
		p= vec3(-33.* (1. - CurTime * 0.6), 103.0, -6.);
		rayDir.yz= rotate( rayDir.yz, 0.6 );
		rayDir.xz= rotate( rayDir.xz, 6. );
        CurTime2 *= 2.0;
	}
	else if( CurScene-- < 1.0 )
	{
		p= vec3( -8.0, -99.* (CurTime * 1.8), 6.);
		rayDir.yz= rotate( rayDir.yz, 0.6 + CurTime );
		rayDir.xz= rotate( rayDir.xz, 3. );
        CurTime2 *= 2.0;
	}
	else if( CurScene-- < 1.0 )
	{
        //////////////  Shader 2
		p= vec3( -88., 22.0, -99.0 * (1.0 - CurTime * 1.2));
		//rayDir.yz= rotate( rayDir.yz, 0.6 + CurTime );
		rayDir.xz= rotate( rayDir.xz, 5.5 );
		CurTime = CurTime * 8.0 + 0.6;
		CurTime2 = mod( CurTime, 1.0);
	}
	else if( CurScene-- < 1.0 )
	{
		p= vec3( 166.0, 44.0, 99.0 * (1.0 - CurTime * 3.3));
		rayDir.yz= rotate( rayDir.yz, 0.4 );
		rayDir.xz= rotate( rayDir.xz, 1.0 - CurTime );
		CurTime = CurTime * 8.0 + 0.6;
		CurTime2 = mod( CurTime, 1.0);
	}
	else if( CurScene-- < 1.0 )
	{
		p= vec3( -99.0 * (1.0 - CurTime * 3.3), 88.0, -44.0);
		rayDir.yz= rotate( rayDir.yz, 0.6 + CurTime );
		rayDir.xz= rotate( rayDir.xz, 2.5 );
		CurTime = CurTime * 8.0 + 0.6;
		CurTime2 = mod( CurTime, 1.0);
	}
	else if( CurScene-- < 1.0 )
	{
		p= vec3( -99.0 * (1.0 - CurTime * 0.8 ), 12.0, 99.0);
		//rayDir.yz= rotate( rayDir.yz, 0.6 + CurTime );
		rayDir.xz= rotate( rayDir.xz, 4.5 );
		CurTime = CurTime * 8.0 + 0.6;
		CurTime2 = mod( CurTime, 1.0);
	}
	
	CurScene= Y.x;

@D
	/////////////////////////////////////////////////////////////////////
	//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.6);

		float ScreenHeight = Y.w;
		float AspectOffset = 1280.0 / 720.0 * 0.5 - 0.5; //= 0.445;

		vec3 q1 = vec3((gl_FragCoord.xy / Y.z - 0.5), 0.6);
		q1.x -= Y.w;

		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,.0,.0 );
	cFac=1.0;
	
	//float t=smoothnoise( rayDir*666.0 )*0.1,y,z;
	//float t= 0.5 * plasm(999. * rayDir.x, 999. * rayDir.z, 999. * rayDir.y,999. *  rayDir.z),y,z;
	float t= 0.0,y,z;

	m=0;
    HitMaterial = vec4(-3.0, 8.0, 0.98, 1.0);
	while(m++<2)
	{
		//bis zu einer Oberflaeche steppen
		//for (CurStep=1.0;t<250.0 && CurStep>t*.003;t+=0.01+max(0.0, CurStep),RayStep=rayDir*t )
		for (CurStep=1.0;t<999.0 && CurStep>t*.0005;t+=CurStep,RayStep=rayDir*t )
		{
			CurStep = f(p+RayStep);
		}

		vec3 NextPos = p+RayStep;
		
		//Startpunkt und Richtung fuer reflektierten Strahl;
		p= NextPos;
		
		CurNormal = vec2(0.04, 0.0);
		vec3 n= normalize(vec3( f(p + CurNormal.xyy) - f(p - CurNormal.xyy), f(p + CurNormal.yxy) - f(p - CurNormal.yxy), f(p + CurNormal.yyx) - f(p - CurNormal.yyx) ));
		//CurStep ab hier == Reflektion !!!
		mat(p);
		
		if( t > 999.0 )
		{
			if( m < 2)
			{
				HitMaterial = vec4(-3.0, 8.0, 0.98, 1.0);
			}
			break;
		}
		
		rayDir= reflect( rayDir, n );

		//float ao(vec3 p, vec3 n, float d, float i) {
		y= 8.0;
		for (z=1.0;y>0.;y--)
		{ 
			z-=.5*(y-f(p+n*y))/exp2(y);
		}
		CurColor*= z * lightSphere(rayDir, BackColor, HitMaterial.xy);
    
		cRes+= cFac*CurColor;//*(1.0-Reflect);
		cFac*= CurStep;// Reflect * (1.0-t/tmax);
		t= 0.5;
		RayStep=rayDir*t;
	}
    
	gl_FragColor.xyz = smoothstep(15.8, 15.79, Y.x + Y.y) * vignette * 
        min(1.0,sin(Y.y * pi2 / 2.0)*15.8) //fade
         * (cRes + cFac*
		(	lightSphere(rayDir, LightColor, HitMaterial.zw) +
			lightSphere(rayDir, BackColor, HitMaterial.xy)));

}