int w= 1;

@D 
//#version 420
@@

// Parameters from our host
// x: Scene
// y: Zeit
// z: Quadratzeit mit Faktor
// w: Aspect ratio
in vec2 Y,Z;

// All data of our world
float L, cFac, CurTime, CurStep, pi= acos(-1.0);
vec2 CurNormal;
varying out vec3 cRes;
vec3 CurColor,p,FogColor= vec3( 0.9, 0.9, 1.0 );

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 z-a;
}

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 base(vec3 z)
{
	vec3 y=z;
	y.y+=0.8+sin(CurTime);
		return min(
		(y.y < 0.0 ? length(y):length(y.xz))-0.6,
		max(
		-length(z.xz)+0.8,
		min(
		-z.y,
		max(
		length(z.xz)-1.0,
		-0.2-z.y))));
}*/

float f0(vec3 p)
{
	return 250.0;
}
float f1(vec3 p)
{
	float d= 999.0;
	float a= atan(p.x,p.z)+CurTime;
	p.x= length(p.xz) - 94.0;
	for( float b= 0.0; b < 3.0; b++ )
	{
		vec3 o=p;
		o.x+= 5.0*sin( (a+b*2.0*pi)*16.0/3.0 );
		o.y+= 5.0*sin( (a+b*2.0*pi)*8.0/3.0 );
		d= min( d, length(o.xy) - 2.0 );
	}
	return d;
}


float f2(vec3 p)
{
	repeatr( p.zx, 96.0, pi/90.0);
	repeatr( p.yz, 11.0, pi/9.0);
	return max(
		-length(p.xz)+0.8,
		min(
		-p.y,
		max(
			length(p.xz)-1.0,
			-0.2-p.y)));

}

float f3(vec3 p)
{
	float b= repeatr( p.zx, 96.0, pi/90.0);
	float a= repeatr( p.yz, 11.0, pi/9.0);
	p.y+= 0.5*plasm(	2.0*CurTime*pi, 
			b,
			a,
			1.3);
	return (p.y < 0.0 ? length(p):length(p.xz))-0.6;
}

float f4(vec3 p)
{
	float s= plasm(
		0.2*p.y,
		row(p.x, 8.0),
		row(p.z, 8.0),
		1.0);
	repeat(p.x, 8.0 );
	repeat(p.z, 8.0 );
	
	
	vec2 y= abs(abs(rotate(p.xz,s)) - 0.4);
	repeat(p.y,0.5);
	return max( max(y.x,y.y)-0.3, 0.1 - max( abs(p.y),min(y.x,y.y)));
}

float f5(vec3 p)
{
	float s= plasm(
		2.0*CurTime*pi,
		row(p.x, 8.0),
		row(p.z, 8.0),
		1.0);
	repeate(p.x, 8.0, 16.0 );
	repeate(p.z, 8.0, 48.0 );
	vec3 o= p;
	p.y-=s;
	repeat(p.y, 12.0 );
	
	p.y= abs(p.y) - 4.0;
	repeat(o.y, 5.0);
	return min(torus(p, 2.0)-0.5, max( length( o ) - 1.5, abs( o.y ) - 0.5 ));

}

float f6(vec3 p)
{
	float s= plasm(
		2.0*CurTime*pi,
		row(p.x, 8.0),
		row(p.z, 8.0),
		1.0);
	repeate(p.x, 8.0, 16.0 );
	repeate(p.z, 8.0, 48.0 );
	vec3 o= p;
	p.y-=s;
	repeat(p.y, 12.0 );
	
	float f= max( abs(p.y)-4.0, abs(2.0-length(p.xz))-0.25);
	repeat( p.y, 1.0 );
	return max( f,-abs(p.y) + 0.4 );
}

float f7(vec3 p )
{
	return 18.0 + p.y;
}

float f8(vec3 p)
{
	repeatr( p.zx, 8.0, pi/8.0);
	repeat(p.y, 7.0 );
	float s= length( p ) - 9.0;
	repeate(p.y, 2.2, 2.2 );
	p.x= abs( p.x ) - 2.0;
	return max( s,(p.x > 0.0 ? length(p.xy):abs(p.y))-1.0 );
}

float f9(vec3 p)
{
	repeatr( p.zx, 8.0, pi/8.0);
	return  p.z-8.0;
}

float f10(vec3 p)
{
	p.x= abs( p.x );
	repeat( p.z, 6.0 );
	float s= min( 28.5 - p.x, max( 24.0 - p.x, abs(p.z) - 2.0 ));
	p.yz= rotate( p.yz, pi/4.0);
	repeat( p.x, 3.0 );
	repeat( p.y, 3.0 );
	repeat( p.z, 3.0 );
	return max( s, 1.0 - length( p ) );
}

float f11(vec3 p)
{
	p.x+= 29.0;
	//p.x+= 32.0 * (CurTime+1.0)*(cos(4.0*row(p.y, 20.0)));
	p.xz= rotate( p.xz, (CurTime+1.0)*(cos(4.0*row(p.y, 20.0))));
	repeat( p.y, 20.0 );
	repeatr( p.xz, .0, pi/5.0);
	
	return max( length( length( p.xz )-51.0)-0.25, max( length(p.y)-5.0, length(p.z)-10.0 ));
	
	/*p.x+= 20.0;
	//p.x+= 32.0 * (CurTime+1.0)*(cos(4.0*row(p.y, 20.0)));
	p.xz= rotate( p.xz, (CurTime+1.0)*(cos(4.0*row(p.y, 20.0))));
	repeat( p.y, 20.0 );
	repeatr( p.xz, 40.0, pi/5.0);
	vec3 v= abs(p)-vec3(0.25,5.0,10.0);
	return max( v.x, max( v.y, v.z ));*/


    /*p.z+= 32.0 * (CurTime+1.0)*(cos(4.0*row(p.y, 20.0)));
    repeat( p.y, 20.0 );
    repeat( p.z, 28.0 );
	p.x-=21.0;
	vec3 v= abs(p)-vec3(0.25,5.0,10.0);
	return max( v.z, max( v.y, v.x ));*/
//	repeate( p.x, 4.0, 8.0 );
//	return min( torus(p.xzy, 1.5) - 0.4, max( v.x, max( v.y, v.z )));
}

float f12(vec3 p)
{
	float l= sin( 999.0*repeatr( p.xz, 61.0, pi/32.0) );
	p.y+=64.0*l*CurTime;
	l= l + 2.0;
	repeat( p.y, l*2.0+5.0);
	l= max( length(p.x)-0.5 ,max(length(p.y)-l, length(p.z )-1.0 ) );

    p.yz= rotate( p.yz, pi/4.0);
    p.x+= 0.5;
	repeat( p.y, 0.5 );
	repeat( p.z, 0.5 );
    return max( l, 0.2 - length( p ) );
	
    //return 36.0 - length( length( p.xz ) - 40.0 );
}

float f13(vec3 p)
{
	float l= sin( (999.0* repeatr( p.xz, 64.0, pi/22.0)) );
	p.y+=32.0*l*CurTime;
	l= l + 6.0;
	repeat( p.y, l*2.0+1.0);
	l= max( -p.x ,max(length(p.y)-l, length(p.z )-4.0 ) );

    p.yz= rotate( p.yz, pi/4.0);
	repeat( p.y, 3.0 );
	repeat( p.z, 3.0 );
    return min( 5.0-p.x, max( l, 1.0 - length( p ) ) );
}

float f14(vec3 p)
{
	p.y-= CurTime * 260.0;
	p.xz= rotate( p.xz, CurTime*2.0);
	repeatr( p.zx, 39.0, pi/6.0);
	repeat( p.y, 260.0 );
	p.yz= rotate( p.yz, 0.5);
	return max( max(length(p.y)- 36.0, length(p.x )-5.0 ), p.z);
}

float f15(vec3 p)
{
	p.y-= CurTime * 260.0;
	p.xz= rotate( p.xz, CurTime*2.0);
	repeatr( p.zx, 40.0, pi/6.0);
	repeat( p.y, 260.0 );
	p.yz= rotate( p.yz, 0.5);
	return max( max(length(p.y)- 35.0, length(p.x )-4.0 ), p.z);

}

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


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

void main()
{
	CurTime= fract(Y.x);
	int CurScene= int(Y.x), m=2;
	// Get the look direction for the current pixel (always look forwards)
	vec3 rayDir = vec3((Z.xy - 0.5), 0.8);
	
	if(CurScene--==0)
	{
		p= vec3(2.0, 220.0*CurTime, 58.0);
		rayDir.yz= rotate( rayDir.yz, -1.0-CurTime );
	}
	else if(CurScene--==0)
	{
		p= vec3(0.0, 130.0*CurTime-90.0, 10.0);
		rayDir.yz= rotate( rayDir.yz, 1.0*CurTime );
		rayDir.xz= rotate( rayDir.xz, 2.0*CurTime );
	}
	else if(CurScene--==0)
	{
		p= vec3(0.0, 400.0*CurTime-30.0, -58.0);
		rayDir.yz= rotate( rayDir.yz, 1.0 );
	}
	else if(CurScene--==0)
	{
		p= vec3(0.0, 20.0, -62.0);
		rayDir.yz= rotate( rayDir.yz, -1.2*CurTime );
	}
	else if(CurScene--==0)
	{
		p= vec3( 0.0, -8.0, 90.0);
		rayDir.yz= rotate( rayDir.yz, -2.0*CurTime );
		rayDir.xz= rotate( rayDir.xz, 3.6 );
	}
	else if(CurScene--==0)
	{
		p= vec3( 90.0, -8.0, 0.0);
		rayDir.xz= rotate( rayDir.xz, -CurTime );
	}
	else if(CurScene--==0)
	{
		p= vec3( 105.0, 0.0, 0.0);
		rayDir.xz= rotate( rayDir.xz, CurTime );
	}
	else if(CurScene--==0)
	{
		p= vec3( 0.0, 0.0, 105.0);
		rayDir.xz= rotate( rayDir.xz, 3.6+CurTime );
	}
	else if(CurScene--==0)
	{
		p= vec3( 6.0, 5.0, 12.0 *CurTime);
	}
	else if(CurScene--==0)
	{
		p= vec3( 4.0, -16.0, -6.0 - CurTime * 22.0);
		rayDir.xz= rotate( rayDir.xz, 1.0 );
		rayDir.yz= rotate( rayDir.yz, -0.3  );
	}
	else if(CurScene--==0)
	{
		p= vec3( 3.0, -15.0+40.0*CurTime, 17.0 );
		rayDir.yz= rotate( rayDir.yz, 1.0-CurTime  );
		rayDir.xz= rotate( rayDir.xz, 2.0+CurTime );
	}
	else if(CurScene--==0)
	{
		p= vec3( -2.0, 7.0, 20.0);
		rayDir.xz= rotate( rayDir.xz, 2.2+CurTime );
	}
	else if(CurScene--==0)
	{
		p= vec3( 19.0, 140.0*CurTime-120.0, 0.0 );
		rayDir.yz= rotate( rayDir.yz, -1.5  );
		rayDir.xz= rotate( rayDir.xz, 1.0+1.0*CurTime );
	}
	else if(CurScene--==0)
	{
		p= vec3( -20.0, 20.0, -30.0 );
		rayDir.yz= rotate( rayDir.yz, -0.5 );
		rayDir.xz= rotate( rayDir.xz, -0.5-0.5*CurTime );
	}
	else if(CurScene--==0)
	{
		p= vec3(5.0, 15.0*CurTime+70.0, -30.0);
		rayDir.yz= rotate( rayDir.yz, 0.9 );
	}
	else
	{
		p= vec3(-12.0, 6.0, -55.0);
		rayDir.yz= rotate( rayDir.yz, -1.5*CurTime );
	}
	
@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.7);
		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=smoothnoise( rayDir*666.0 )*0.1,y,z;
	float t=0.0,nextT=0.0;
	while (m--==0&&t<250.0)
	{
		t= nextT;
		nextT=0.5;
		//bis zu einer Oberflaeche steppen
		//for (CurStep=1.0;t<250.0 && CurStep>t*.003;t+=0.01+max(0.0, CurStep) )
		for (CurStep=1.0;t<250.0 && CurStep>t*.002;t+=CurStep )
		{
			CurStep = f(p+rayDir*t);
		}
		
		//Startpunkt und Richtung fuer reflektierten Strahl;
		p+= rayDir*t;
		
		CurNormal = vec2(0.1, 0.0);
		vec3 n= 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) );
		n= normalize(n);
		
		//CurStep ab hier == Reflektion !!!
					
		//////////////////////////////////////
		///material Anfang
			
		CurColor = vec3(.1);
		CurStep= .8;
		CurNormal.y= 0.5;
		
		if( w == 1 )
		{
			L= f1(p);
			CurColor = vec3(0.0,0.6,0.7 );
			CurStep= 0.4;
			
			if( L > f0(p) )
			{
				L= f0(p);
				CurColor = vec3(0.6,0.9,1.25 );
				CurStep= .1;
				nextT=250.0;
			}
			if( L > f3(p) )
			{
				L= f3(p);
				CurColor = vec3(1.0,0.5,0.0 );
				CurStep= 0.1;
				nextT=250.0;
			}

			if( L > f2(p) )
			{
				L= f2(p);

				CurColor = vec3(1.0);
				CurStep= .0;
				nextT=250.0;
			}
		}
		else if( w == 2 )
		{
			CurNormal.y= 1.5;
			L= f5(p);

			if( L > f4(p) )
			{
				L= f4(p);
				CurColor = vec3(0.6,0.9,1.25 );
				CurStep= .1;
				nextT=250.0;
			}
			
			if( L > f6(p) )
			{
				L= f6(p);
				CurColor = vec3(1.0,0.5,0.0 );
				CurStep= 0.1;
				nextT=250.0;
			}
			
			if( L > f7(p) )
			{
				L= f7(p);

				CurColor = vec3(1.0);
				CurStep= .0;
				nextT=250.0;
			}
		}
		else if( w == 3 )
		{
			L= f8(p);


			if( L > f9(p) )
			{
				L= f9(p);
				CurColor = vec3(0.6,0.9,1.25 );//*0.8;
				CurStep= .0;
				nextT=250.0;
			}
					
			if( L > f11(p) )
			{
				L= f11(p);
				CurColor = vec3(1.0,0.5,0.0 );
				CurStep= 0.1;
				nextT=250.0;
			}
			if( L > f10(p) )
			{
				L= f10(p);

				CurColor = vec3(1.0);
				CurStep= .0;
				nextT=250.0;
			}
		}
		else if( w == 0 )
		{
			CurNormal.y= 0.02;
			L= f15(p);
			if( L > f14(p) )
			{
				L= f14(p);
				CurColor = vec3(0.6,0.9,1.25 );
				CurStep= .0;
				nextT=250.0;
			}
			if( L > f12(p) )
			{
				L= f12(p);
				CurColor = vec3(1.0,0.5,0.0 );
				CurStep= 0.1;
				nextT=250.0;
			}
			if( L > f13(p) )
			{
				L= f13(p);
				CurColor = vec3(1.0);
				CurStep= .0;
				nextT=250.0;
			}
		}
		
		///material Ende
		//////////////////////////////////////
		
		//n.x+= (smoothnoise( p * CurNormal.y ) + smoothnoise( p * CurNormal.y * 2.0 ) + smoothnoise( p * CurNormal.y * 4.0 )) * CurNormal.x;
		//n.y+= (smoothnoise( p * CurNormal.y ) + smoothnoise( p * CurNormal.y * 2.0 ) + smoothnoise( p * CurNormal.y * 4.0 )) * CurNormal.x;
		//n.z+= (smoothnoise( p * CurNormal.y ) + smoothnoise( p * CurNormal.y * 2.0 ) + smoothnoise( p * CurNormal.y * 4.0 )) * CurNormal.x;
		n+= (smoothnoise( p * CurNormal.y ) + smoothnoise( p * CurNormal.y * 2.0 ) + smoothnoise( p * CurNormal.y * 4.0 )) * CurNormal.x;
		n= normalize(n);

							
		float Ambient= 0.3;
		for( int i= 0; i < 4; ++i )
		{
			vec3 LightPos;
			
			if( w == 1 )
			{
				LightPos= vec3(0.0,4.3,102.3);
				LightPos.xz= rotate( LightPos.xz, i*0.2-2.0*CurTime );
			}
			else if( w == 2 )
			{
				LightPos= vec3(0.0,10.0*sin( i+2.0*CurTime),12.0);
				LightPos.xz= rotate( LightPos.xz, i*3.0 );
			}
			else if( w == 3 )
			{
				LightPos= vec3(0.0,250.0*CurTime-i*50.0,20.0);
				LightPos.xz= rotate( LightPos.xz, cos(i)*20.0*CurTime );
			}
			else if( w == 0 )
			{
				LightPos= vec3(0.0,200.0*sin( i+2.0*CurTime),58.0);
				LightPos.xz= rotate( LightPos.xz, cos(i)*20.0*CurTime );
			}

			vec3 LightDist= p-clamp(dot(p-LightPos,rayDir)/t,0.0,1.0)*rayDir*t;

			L= smoothstep(2.0, 0.0, length(LightDist-LightPos));
			ToRes(vec3(3.0, 2.5, 2.0)*L,1.0-L);
			
			LightPos-=p;
			Ambient+= 0.4 * ( dot(normalize(LightPos),n))*smoothstep(80.0, 0.0, length(LightPos));
		}
		L= smoothstep( 0.0,220.0*smoothstep(0.0,0.5,Y.x), t );
		ToRes(FogColor*L,1.0-L);

		rayDir= reflect( rayDir, n );

		CurColor*= Ambient;
		Ambient= 1.0;
		for (L= 6.0;L>0.;L--)
		{ 
			Ambient-=(L*.5-f(p+n*L*.5))/exp2(L);
		}
		CurColor*= Ambient;
		ToRes(CurColor,CurStep);
	}
	cRes*=smoothstep(16.0,15.65,Y.x);
	
	//gl_FragColor.xyz = cRes;// + cFac*FogColor;
	

//  z= 0.85;
	
//	rayDir.yz= rotate( rayDir.yz, 0.6 );
//	z+= rayDir.y * 0.2;

//	if( rayDir.y > 0.0 )
//	{
//		repeatr(rayDir.xz, 0.4, pi/8.0);
//		rayDir.x= abs( rayDir.x ) - .2;
//		z+= pow( smoothstep(.2, .0, mix( abs(rayDir.z),length(rayDir.xz), step(0.0, rayDir.x) ) ), 22.0 );
//	}
//	gl_FragColor.xyz = cRes + cFac*z;
}