// by Greg M. Johnson   http://members.xoom.com/gregjohn/animation.html.

#declare num=100 ;                    // number of actors
#declare framenum=375;                // number of frames+1 (put number of frames +0 in povray.ini and read file)
               
#declare RRR=seed(2022) ;             // We'll be using random numbers!
#declare UMAX=40 ;                    // maximum initial postion       
#declare VMAX=7 ;                     // maximum initial velocity
                                         
#declare actorp= array[num+1]         // position of each actor       
#declare actorv= array[num+1]         // instantaneous velocity of each actor
#declare actoravoid= array[num+1]     // vector for best path to avoid collision with peers

// WARNING! 
// This line declares the name of the file which contains the positions and velocities
// of all your particles. MAKE SURE to correct the format of the
// file name to include a proper drive and subdirectory for your computer!
// When working with multiple tweaks, it is often helpful to change this filename frequently. 
#fopen MyFile2 "c:\pov31g\include\boid17awrite04.inc" write   
                        
                        
#write(MyFile2,"#declare Position=array[", framenum-1, "][", num, "][6] {\n")
 
//initialize    the three vectors for each actor.
#declare n=0    ;
#while (n<num)
 
// change this actorp[n] equation to anything you like, but be sure to space the actors apart from each other.
// this equation has the actors start in a circle, but with random y placement.
#declare actorp[n]= 20*<cos(2*pi*n/(num)),(1-rand(RRR)-rand(RRR))*10,sin(2*pi*n/(num))>;


#declare actorv[n]=<0,0.001,0>; 

// this is the vector which tells each actor how to avoid collisions with nearest neighbor; set to 0 for now.
#declare actoravoid[n]=<0,0,0>;                                                    
#declare n=n+1   ;
#end                                    
        
                            
#declare tt=1;      // tt is the "time" element.

#while(tt<framenum)  // only make this last as long as number of frames.
                    
#write(MyFile2,"{ ")

#write(MyFile2,"\n","// tt is ",tt,"\n")    

//#debug "tt", str(tt,2,2)                     

#declare n=0    ;
#while (n<num)
#declare actoravoid[n]=<0,0,0>;
#declare n=n+1   ;
#end                                      
                    

// here we compute the actoravoid. Basically, it is a vector pointing away from every other actor, divided by distance squared.                                 
#declare i=0    ;  
#while (i<num)

#declare j=i+1    ;
#while (j<num)

#declare actoravoid[j]=actoravoid[j]+vnormalize(actorp[i]-actorp[j])/pow(vlength(actorp[j]-actorp[i]),2); //was ,3)
#declare actoravoid[i]=actoravoid[i]+vnormalize(actorp[j]-actorp[i])/pow(vlength(actorp[i]-actorp[j]),2); //was ,3)

#declare j=j+1;
#end  

#declare i=i+1;
#end        


       

#declare n=0    ;
#while (n<num)

// actave is the variable that tells each particle where it ought to be.
// actave can be a stationary point or move wrt/ a function of tt, n, anything you want!

#declare actave=20*<cos(2*pi*(n/num+tt/framenum*4)),-0,sin(2*pi*(n/num+tt/framenum*4))>;             
//you could also try:
//#declare actave=<0,0,0>;
//#declare actave=30*<cos(tt/framenum*8*pi*(-1+2*mod(n,2))),0,sin(tt/framenum*8*pi*(-1+2*mod(n,2)))>;
//#declare actave=<0,30*cos(tt/framenum*8*pi),0>;
//#declare actave=20*<cos(2*pi*(n/num+tt/framenum*1)),-0,sin(2*pi*(n/num+tt/framenum*1))>;             
//#declare actave=actorp[mod(n+1,num)];  // chase one friend...


// Since actorv[n] is instantaneous velocity, particle only moves a fraction of actorv per time frame.                                                
#declare actorp[n]=actorp[n]+.125*actorv[n]; 

// a1 is the acceleration. 
// to play around with distance between actors, change the constant *(-actoravoid[n]) .
// to play around with responsiveness to actave, change the constant *(-actorp[n]+actave) .
#declare a1=10.*(-actoravoid[n])+0.1*(-actorp[n]+actave);

// For a smoother, less responsive group, increase the constant * actorv[n] to a1.
// For a jerkier, more responsive group, decrease the constant * actorv[n] to a1.
#declare actorv[n]=.4*actorv[n]+a1;
                                                                   

#declare n=n+1   ;
#end                                    


// IN THIS FILE,  THERE IS NO NEED TO TOUCH ANYTHING BELOW THIS LINE!

#declare n=0    ;
#while (n<num)

#write (MyFile2,"{",actorp[n].x,",",actorp[n].y,",",actorp[n].z,",",actorv[n].x,",",actorv[n].y,",",actorv[n].z,"}",",","\n")                          

 
#declare n=n+1   ;
#end                                    

#write(MyFile2,"}, ")                          

#debug "            "
#debug str(tt,2,2) 
#debug "\n"

#declare tt=tt+1   ;

#end                              

#write(MyFile2,"} ")                          

#fclose Myfile2 

                            
camera {               
  location <0, -65,-0>
  look_at  <0, 0, 0>
  angle 30
}                               

light_source{<10,200,-50>rgb 1.2}
light_source{<10,-200,50>rgb .2}
    
fog { fog_type 1 distance 2000 rgb <.2,.3,.7>}