/*
  \
  motion blur test.
    \
     */



#version Unofficial MegaPov 0.7;

#declare radio = on;

global_settings {
	max_trace_level 20
	ini_option "+QR"
	#if (radio)
		radiosity {
		}
/*		photons {
			count 200000
			autostop 0
		}*/
	#end
	motion_blur 5, 1.0
}

/*---------*\
| variables |
\*---------*/

#declare num_balls = 8; //20;
#declare ts = 1/25; //1/25th of a second
#declare acc = <0,-9.81,0>;
#declare decay = 1; //remove this amount of vel when collision occurs
#declare rad = 0.1;
#declare kill_rad = 2; //distance from y axis at which balls die
#declare create_pos = <0,1.5,0>;
#declare create_rad = 0.12;
#declare create_period = 8; //number of frames between creation of balls

#ifndef (block_init)
	#declare pos = array[num_balls] //{ <-0.3,0.8,0>, <0.3,0.6,0.3> }
	#declare vel = array[num_balls] //{ <0.7,0,0.2>, <-1,0,0> }
	#declare vcoll =  array[num_balls]
	#declare postemp =  array[num_balls]
	#declare last_ball = 0;
	#declare randomiser = 1;
	
	#declare block_init = on; //prevent initialisation on later frames.
#end

#declare rs = seed(randomiser);
#declare randomiser = randomiser + 1;


//move things
#declare loop = 0;
#while ( loop < last_ball )

	#declare vcoll[loop] = <0,0,0>;

	#declare vel[loop] = vel[loop] + acc*ts;
	#declare postemp[loop] = pos[loop] + vel[loop]*ts;
	
	#if ( abs(postemp[loop].x) > 1-rad )
		#declare vel[loop] = vel[loop] - vel[loop].x*2*x;
		#declare vcoll[loop] = <1,0,0>;
	#end

	#if ( postemp[loop].y < rad )
		#declare vel[loop] = vel[loop] - vel[loop].y*2*y;
		#declare vcoll[loop] = <0,1,0>;
	#end
	
	#if ( abs(postemp[loop].z) > 0.8-rad )
		#declare vel[loop] = vel[loop] - vel[loop].z*2*z;
		#declare vcoll[loop] = <0,0,1>;
	#end

	#declare loop = loop+1;
#end

//collision detection
#declare loop1 = 0;
#while ( loop1 < last_ball-1 )

	#declare loop2 = loop1+1;
	#while ( loop2 < last_ball )

		#declare vtemp = postemp[loop1] - postemp[loop2];
		
		#if ( vlength(vtemp) < rad*2 )
			#declare vtemp = vnormalize(vtemp);
			
			//reflect velocities in collision direction.
			#declare vcoll[loop1] = vtemp;
			#declare vel[loop1] = vel[loop1] - vdot(vel[loop1],vcoll[loop1])*2*vcoll[loop1];
			
			#declare vcoll[loop2] = -vtemp;
			#declare vel[loop2] = vel[loop2] - vdot(vel[loop2],vcoll[loop2])*2*vcoll[loop2];
		#end
	
		#declare loop2 = loop2+1;
	#end //loop2
	
	#declare loop1 = loop1+1;
#end //loop1

//accelerate
#declare loop = 0;
#while ( loop < last_ball )

	#if ( postemp[loop].y < rad ) // vlength(vcoll[loop]) > 0.5 )
			//decay velocity in collision direction
			//#declare vel[loop] = vel[loop] - (vdot(vel[loop],vcoll[loop]) * decay * vcoll[loop]);
			
			//fixed amount, not proportional
			#declare ftemp = vel[loop].y;//vdot(vel[loop],vcoll[loop]);
			#if ( abs(ftemp) < decay )
				#declare vel[loop] = vel[loop] - (ftemp * y);
			#else
				#if ( vel[loop].y > 0 )
					#declare vel[loop] = vel[loop] - (decay * y);
				#else
					#declare vel[loop] = vel[loop] + (decay * y);
				#end
			#end
	#end
	
	#declare ftemp = vdot(acc,vcoll[loop]) * vcoll[loop];

	#declare vel[loop] = vel[loop] + ftemp*ts;

	#declare pos[loop] = pos[loop] + vel[loop]*ts;
	
	//nasty hack:
	#if ( pos[loop].y < rad )
		#declare pos[loop] = <pos[loop].x,rad,pos[loop].z>;
	#end

	#declare loop = loop+1;
#end

//destroy old balls
#declare loop = last_ball-1;
#while ( loop >= 0 )

	#if ( (pos[loop].x * pos[loop].x) + (pos[loop].z * pos[loop].z) > kill_rad * kill_rad )
		//destroy      
		#declare loop2 = loop;
		#while ( loop2 < last_ball - 1 )
			#declare pos[loop2] = pos[loop2+1];
			#declare vel[loop2] = vel[loop2+1];
		
			#declare loop2 = loop2 + 1;
		#end

		#declare last_ball = last_ball - 1;
	#end

	#declare loop = loop - 1;
#end

//create new balls
#if ( last_ball < num_balls & mod(frame_number,create_period) = 0 )
	#declare pos[last_ball] = create_pos + <rand(rs)-.5,rand(rs)-.5,rand(rs)-.5>*2*create_rad;
	#declare vel[last_ball] = <0,0,0>;
	#declare last_ball = last_ball + 1;
#end


/*---------*\
|	materials |
\*---------*/

#macro difamb(dif,amb)
	#if (radio)
		diffuse dif+amb
		ambient 0
	#else
		diffuse dif
		ambient amb
	#end
#end

#declare black_stuff =
	texture {
		pigment { rgb <0.1,0.1,0.13> }
		finish {
			difamb(0.7,0.1)
			specular 1.2 roughness 0.01
		}
	}

#declare white_stuff =
	texture {
		pigment { rgb <0.92,0.906,0.9> }
		finish {
			difamb(0.7,0.1)
			specular 0.4 roughness 0.05
		}
	}


/*----------*\
|	components |
\*----------*/

#declare Box =
	difference {
		box { <-1.1,-0.1,-0.8>, <1.1,1,0.9> }
		box { <-1,0,-0.9>, <1,1.1,0.8> }
		texture { white_stuff }
		texture {
			pigment {
				bozo
				poly_wave 0.1
				scale 3*<1,0.05,0.05>
				rotate <45,45,0>
				warp {
					turbulence 0.3
				}
				colour_map {
					[0.0 rgbt <0.1,0.1,0.13,0>]
					[1.0 rgbt <0.1,0.1,0.13,1>]
				}
			}
			finish {
				difamb(0.7,0.1)
				specular 1.2 roughness 0.01
			}
		}
	}

#macro Ball(_pos)
	sphere {
		_pos, 0.1
		texture {
			pigment { rgb 0.7 }
			finish {
				difamb(0.2,0.1)
				reflection 0.6
				specular 1.0 roughness 0.002
			}
		}
	}
#end 


/*---------*\
| the scene |
\*---------*/

camera {
	right			x
	up				y*image_height/image_width
	direction	z
	
	location <0,1.5,-2>
	look_at <0,0.6,0>
}

light_source {
	<-1,1,-1>*20
	rgb 1
	area_light <-1,0,1>*1, <1,1,1>*1, 3, 3 jitter
}

sky_sphere {
	pigment {
		gradient y
		poly_wave 0.5
		scale 1/0.7
		translate <0,-(1/0.7 - 1),0>
		warp {
			turbulence 0.1
		}
		colour_map {
			[0.0 rgb <1.0,1.0,1.0>]
			[1.0 rgb <0.7,0.6,0.5>]//<0.5,0.6,1.0>]
		}
	}
	pigment {
		gradient y
		translate <0,-0.5,0>
		scale 2
		warp {
			turbulence 0.1
		}
		colour_map {
			[0.0 rgb <0.5,0.3,0.0>]
			[0.3 rgb <0.05,0.0,0.0>]
			[0.32 rgbt 1]
		}
	}
}

object { Box }

//draw balls (live ones only)
#declare loop = 0;
#while ( loop < last_ball )

	motion_blur {
		#declare dt = clock - frame_number; //for motion blur
		#declare dt = dt * ts;
		object { Ball(pos[loop] + vel[loop]*dt) }
	}

	#declare loop = loop+1;
#end