// Persistence of Vision Ray Tracer Scene Description File
// File: partix.pov
// Vers: 3.5
// Desc: All parameters that may be used for the PartixGen-Particle System
// Date: 12.10.02 (dd.mm.yy)
// Auth: Tim Nikias Wenclawiak
// Last Update: 12.10.02 (dd.mm.yy)

//Required files:
// "partixgen.inc" - The Particle-System (includes a whole bunch of other files)

//Description:

//Homepage:
// www.digitaltwilight.de/no_lights
//Email:
// Tim.Nikias@gmx.de

global_settings{max_trace_level 50 assumed_gamma 1}

#default { finish{ambient 0}}

light_source{<10,10,-10> rgb 1
 spotlight point_at <0,1,0> radius 5 falloff 12
 area_light x*5,y*5,25,25 orient circular adaptive 2
 }
camera{location <0,5,-10> look_at <0,0,0>}

//A plain plane
plane{y,0
 pigment{rgb .2}
 finish{
  reflection{.3,1 falloff 3}
  }
 }
//Object that "spits" the particles
union{
 cone{0,.6,y,.4 open}
 cone{0,.5,y,.3 open}
 torus{.35,.05 translate y}
 pigment{rgb <.3,.3,.9>}
 finish{
  reflection{0,1 falloff 2 metallic}
  specular 1 roughness .001
  }
 }

//The animation variable...
#declare Internal_POV_Clock = clock;

//Here begins the interesting stuff
#declare Partix_Seed = 1;
#declare Particle_Amount = 50;

//Global Settings
#declare Gravity_Direction = <0,-1,0>; //The "Pull"-Direction of Gravity (physics assumes -y)
#declare Gravity_Value = 5; //the distance an object will fall in first second of free fall

#declare Wind_Direction = <1,0,0>; //Direction wind blows towards
#declare Wind_Value = 0; //the speed wind has (in meters/sec)


//Output-Options
#declare Info_File = off;
#declare Info_Name = "calc.txt"
#declare Output_Type = off;
#declare Output_Name = "Parts.inc"
#declare Extra_Data = off;
#declare Extra_Data_Name = "par_data.inc"

//Animation-Settings
#declare Ani_Loop_Type = "population" //off, steadyflow, population
#declare Ani_Sec_Amount = 5;
#declare Ani_Start_Sec = 0;
#declare Ani_End_Sec = 2;

/******Birth Field******/
//Following parameters set the size and
//position of the emitting object
//
//Note: To animate the size/position,
//      use BF-Transformation and
//      BF-Animation

#declare Birth_Field = "disc"
//BF-Initial Transform (don't animate!)
#declare BF_1_Scale = <1,1,1>;
#declare BF_2_Rotate = <0,0,0>;
#declare BF_3_Translate = <0,0,0>;
//Interior setting
#declare BF_Hollow_P = 0; //This moves Particles away from the center of the object
#declare BF_Center_Type="default" //default, tubular
//Algorithm spread
#declare BF_Spread = 0; //If algorithm allows it, particles will be spread equally among the birth-field

//Disc
#declare BF_Disc_Radius = .1;
#declare BF_Disc_Center = <0,.1,0>;
#declare BF_Disc_Normal = <0,1,0>;
//Sphere
#declare BF_Sphere_Center = <0,0,0>;
#declare BF_Sphere_Radius = 1;
//Box
#declare BF_Box_Corner_1 = <-1,-1,-1>;
#declare BF_Box_Corner_2 = < 1, 1, 1>;
//Cylinder
#declare BF_Cylinder_Radius = 1;
#declare BF_Cylinder_Base = <0,1,0>;
#declare BF_Cylinder_Cap = <0,-1,0>;
//Cone
#declare BF_Cone_Base_Radius = 1;
#declare BF_Cone_Base_Point = <0,0,0>;
#declare BF_Cone_Cap_Radius = 0;
#declare BF_Cone_Cap_Point  = <0,1,0>;
//Torus
#declare BF_Torus_Major = 1;
#declare BF_Torus_Minor = .25;
#declare BF_Torus_Center = <0,0,0>;
//Spline
#declare BF_Bezier_Node = array[4]
 {<-2,0,0><0,1,0><2,0,0><0,-1,0>}
#declare BF_Bezier_Radius=0;
//Linear(-Interpolation)
#declare BF_Linear_Node = array[2]
 {<-2,0,0><2,0,0>}
#declare BF_Linear_Radius = 0;
//Array
#declare BF_Array_Node=array[6]
 {x,-x,y,-y,z,-z}
#declare BF_Array_Radius = 0;
//Triangles
#declare BF_Triangles=array[1][3] //First Value: Amount of Triangles,Second leave untouched (3=corners of triangles)
 {
  {<-1,0,0><1,0,0><0,1,0>}
  }
//BF_Macro
//Refer to the Help-HTML for details on this macro
  #macro BF_Macro(Position,Random_Value,Hollowness,Center_Switch)
   #local Rand=seed(Random_Value*1000);
   #if (Center_Switch=0) //Position in field
    #declare Position=vnormalize(<rand(Rand)*2-1,rand(Rand)*2-1,rand(Rand)*2-1>)*(.01+rand(Rand));
   #end
   #if (Center_Switch=1) //Center for the particle
    #declare Position=<0,0,0>;
   #end
   #if (Center_Switch=2) //Total Center
    #declare Position=<0,0,0>;
   #end
  #end

/******Birth Field Transformations******/
//Following parameters shoudl be used to animate
//scale and rotation of the emitter
#declare BF_Transformation = off;
#declare BFT_Inertia=off; //Add inertia from scale-/rotation-change?
#declare BFT_Inertia_Effect=100; //Power of inertia from scale-/rotation-change
 //Easy-Approach
 #declare BFT_Scale_1 = <1,1,1>; //Scale from here...
 #declare BFT_Scale_2 = <1,1,1>; //...to here
 #declare BFT_Rotate = <0,0,0>; //Rotate with this during emitting time
 //Macro-Approach
 #declare BFT_Use_Macro = 0; //0=off, 1= 1.Scale,2.Rotate, 2= 1.Rotate,2.Scale
 //X=Value that runs from 0 to 1 during emitting time
 #macro BFT_Macro(X,Selection_Switch,Return_Vector)
  #if (Selection_Switch=0) //For scale
   #declare Return_Vector=<1,1,1>;
  #end
  #if (Selection_Switch=1) //For Rotation
   #declare Return_Vector=<0,0,0>;
  #end
 #end

//Following parameter has simple background: When
//setting an object, it is common to first build it
//on center, then scale and rotate it, and finally
//put it on the correct spot. This parameter is used
//for that "final-spot-putting".
#declare BFT_Translate = <0,0,0>;

/******Birth Field Animation******/
//Following parameters should be used to
//animate the position of the emitter
#declare BF_Animation = off;
#declare BFA_Type = "vector" //vector, rotate, bezier, linear, macro
#declare BFA_Orients_BF = 0; //0=off, 1=just orient, 2=adjust and orient
#declare BFA_Dir_Affect = "none" //none, inertia, [(-)centrifuge]
#declare BFA_Inertia_Effect=100;
 //Translation
 #declare BFA_Vector_1 = <0,0,0>; //From here...
 #declare BFA_Vector_2 = <0,1,0>; //...to here
 //Rotation
 #declare BFA_Rot_Translate = <0,0,0>; //Translates prior to rotates are common
 #declare BFA_Rot_Origin = <0,0,0>; //Origin for rotation
 #declare BFA_Rot_Rotate_1 = <0,0,0>; //First these...
 #declare BFA_Rot_Rotate_2 = <0,0,0>; //...then these (makes all but zyx-rotation possible)
 //BSpline
 #declare BFA_Bezier_Node = array[4]
          {<-1,0,0>,<0,1,0>,<1,0,0>,<0,-1,0>}
 //Linear-Interpolation
 #declare BFA_Linear_Node = array[2]
          {<-1,0,0><1,0,0>}
 //Macro
 #macro BFA_Macro(X) <sin(radians(360*X)),sin(radians(360*X)),0> #end

/******Particle Life-Setup******/
#declare Par_Handling = "lifetime" //lifetime, always, no_death, no_birth 
#declare Par_Lifetime = 5; //seconds
#declare Par_Birth_Type = "random" // random, zero, macro, (-)spread, (-)size_turb
//Determines the vector passed to the macro to generate birth-time
#declare Par_B_Vector="position" //random, birth-position, spread
 #macro Par_B_Macro(Vector) Vector.y #end

/******Particle******/
#declare Par_Type = "object" //object, macro, blob-all, blob-single, array
 //Object
 #declare Particle =
  sphere{0,.2
   pigment{rgb x}
   finish{
    specular .8 roughness .01
    brilliance 4
    }
   }
 //Macro
 #macro Par_Macro (Scale, Rotate, Position, Lifetime, Direction, Random)
  sphere{0,.2 pigment{rgb x} scale Scale rotate Rotate translate Position}
 #end
 //Array
 #declare Particles = array[5]
 { 
  box{-1,1 pigment{rgb 1}},
  sphere{0,1 pigment{rgb 1}},
  torus{1,.1 pigment{rgb 1}},
  cylinder{0,y,1 pigment{rgb 1}},
  cone{0,1,y,0 pigment{rgb 1}}
  }
 //Blob (both types)
 #declare Par_Blob_Threshold = .8;
 #declare Par_Blob_Size = .5;
 #declare Par_Blob_Size_Turb_P = 0; //Turbulence in Blob-Size
 #declare Par_Blob_Strength = 1; //Strength of particles
 #declare Par_Blob_Hollow = off; //is blob hollow?
 #declare Par_Blob_Rotate = off; //are blob-components to be rotated?
 #declare Par_Blob_Texture_Type = "complex" //simple, complex
  //Simple-Blob-Texturing
  #declare Par_BS_Texture = texture{pigment{rgb 1} finish{phong .2}}
  #declare Par_BS_Interior = interior{caustics 0}
  //Complex-Blob-Texturing (every component gets own texture based on color-type)
  #declare Par_BC_Color_Type = "birth" //birth, lifetime, random, spread, size_turb
  #declare Par_BC_RGB_Array = array[4] {<1,1,0><1,0,0><0,0,0><0,0,0>}
  #declare Par_BC_Transmit = 0;
  #declare Par_BC_Filter = 0;
  #declare Par_BC_Normal = normal{waves 0}
  #declare Par_BC_Finish = finish{}
  #declare Par_BC_Interior = interior{caustics 0}

#declare Par_Grav_Power = 1; //1=gravity, .5=half gravity, -1=inverse gravity
#declare Par_Max_Gravity = 0; //max units of gravity per sec
#declare Par_Size_Turb_P = 0; //Turbulence in size (a +- value)
#declare Par_Scale_1 = <1,1,1>; //Scale at birth
#declare Par_Scale_2 = <1,1,1>*0; //Scale at death
#declare Par_Scale_Morph = 0; //Time (sec's) until Particle actually scales from initial scale to animated one
#declare Par_Rotate = <0,0,0,0>; //Rotation during appearance (t-value => 0-none, 1-random based on xyz, !=1-total random)
#declare Par_Face_Heading = off; //Particle faces Direction

#declare Par_Properties=off; //Macro for access to main INITIAL particle-settings
#macro Par_Prop_Macro(Lifetime,Scale,Rotate,Speed,Birth,Random) //Warning: Misuse result in problems here!
 #declare Scale=Scale; //May be changed using lifetime, random and birth
 #declare Rotate=Rotate; //May be changed using lifetime, random and birth
 #declare Speed=Speed; //May be changed using ONLY random and birth
 #end

/******Speed******/
#declare Par_Speed = 5; //initial Speed
#declare Par_Speed_Differ_P = 0; //percentage of random differences in speed
#declare Par_Speed_Type = "constant" //constant, macro, [fit_heading]
#declare Par_Fit_Secs = Par_Lifetime;
#declare Par_Speed_Vector = "birth" //birth, birth-position, direction, random, spread
 #macro Par_Speed_Macro(Vector) Vector.x #end
 //General Velocity-Based-Stretching
 #declare Vel_Stretching = on;
 #declare Vel_Speed_Min = 0; //Min-Speed for stretch
 #declare Vel_Speed_Max = 3; //Max-Speed for stretch
 #declare Vel_Stretch = <.8,.8,2>; //Maximum  rescalement due to speed

/******Direction******/
#declare Direction_Type = "vector" //vector, in/outward_center, random, array, macro
                                   //t-bezier, t-linear, t-array (a "-" in front inverses)
                                   //[(-)centrifuge=only bezier-birth-field]
 //Direction-modifiers
 #declare Dir_Differ_P = 5; //Percentage of "unalignment" to original Direction
 #declare Direction_Add = <0,1,0>; //Direction to add to the calculated one
 #declare Direction_Add_Power_P = 0; //Percentage of mix between calculated and added direction
 #declare Direction_Spin = off; //use macro-modifier for the initial direction?
 #macro Dir_Spin_Macro(The_Direction,The_Initial_Position,The_Birthtime)
  #declare The_Direction=The_Direction;
  #end
 //Base directions
 #declare Direction = <0,1,0>;
 #declare Direction_Array = array[6]
         {x,-x,y,-y,z,-z}
 #declare Dir_Macro_Type = "birth" //birth, position, spread, random
 #macro Dir_Macro(Some_Vector,The_Direction)
  #declare The_Direction = vrotate(-z,y*360*Some_Vector.x);
  #end
 //bezier- or linear-heading
 #declare Head_Trajectory=off;
 #declare Head_BL_Rotation = <0,0,0>; //Rotates the Heading-spline/linear-i
 #declare Head_BL_Scalement = <1,1,1>; //Scales it
 #declare Head_BL_Translate = <0,0,0>; //Translates it
 #declare Head_BL_Radius = 0;
 #declare Head_Bezier_Node = array[6]
         {<-1,-1,-3><0,1,-1><1,0,-3><0,-1,1> <0,-2,0><-2,1,2>}
 #declare Head_Linear_Node = array[3]
         {<-1,-1,-3><1,0,-3><0,-2,0>}
 #declare Head_Array = array[6]
         {<-1,0,0><1,0,0><0,1,0><0,-1,0><0,0,1><0,0,-1>}

/******Path Calculation******/
#declare Direction_Path = "physics" //simple, physics, bezier, linear, macro
 //Simple
 #declare Par_Wind_Power = 2; //acceleration towards wind-speed
 #declare Turbulence_Wind=yes;
  #declare Wind_Angle = 10; //Angle of difference between original and turbulenced wind                                                                                                                                                                                                                        
         //{<0,0,0>,<0,1,-.5>,<0,2,.5>}
 //Macro
 #macro Dir_Path_Macro(Birth_Position,Direction,Speed,Lifetime,Birthtime,Moved_Position)
  #declare Moved_Position=Birth_Position+Direction*Speed*Lifetime; //return Moved_Position based on other variables
  #declare Wind_Turb = <7,.5,2>; //<Octaves,Omega,Lambda>
  #declare Wind_Scale = 1; //Larger values stretch areas with similiar directions
  #declare Wind_Pos=<2,0,0>; //Second float calculated with Position+Wind_Pos
  #declare Wind_Ani=<0,20,0>; //Shift the turbulence-field during an animation
  #declare Wind_Timer = 2; //Seconds until spread is accomplished
 //Physics
 #declare Dir_Physics_Size = .5; //Overridden with blob / recalculated if Par_Size_Turb_P is used
 #declare Dir_Physics_Min_Velocity = .1; //Below this speed, "lying" particles stop moving
 //bezier- or linear-modifier
 #declare Dir_Path_Type = "none" //none, direction, axis (both expect movement towards -z)
 //bezier-path (assume -z as correct direction if to be rotated using "direction" or "axis")
 #declare Dir_Bezier_Node = array[6]
         {<0,0,0><1,0,0><0,2,0><-1,0,0> <0,4,0><1,0,0>}
 //linear-path (assume same as above)
 #declare Dir_Linear_Node = array[3]
  #end

/******Boundaries******/
#declare Boundary_Box = on;
#declare BB_Corner_1 = <-20,0,-20>;
#declare BB_Corner_2 = <20,20,20>;
 //Only for none-"physics"
 #declare BB_Squish_Amount = <1,1,1>; //Scale-Change (not overall Particle-Scale)
 #declare BB_Squish_ReAmount = <1,1,1>; //Scale-Change (not overall Particle-Scale)
 #declare BB_Squish_Distance = .1; //POV-Units of distance between P. and Boundary-Box
 //Only for "physics"
 #declare BB_Stick_Axis = <0,0,0>; //1=Stick to positive side, -1=negative side, 2=both, 3=ignore pos, 4=ignore neg, 5=ignore both, 0=Rebounce
 #declare BB_Friction_1 = <1,1,1>*.8; //negative sides of BB
 #declare BB_Friction_2 = <1,1,1>*.8; //positive sides of BB
 #declare BB_Repel_Turb_P=0; //turbulences in reflection of particles
 #declare BB_Dir_Mod = <1,1,1>; //non-physical model of keeping speed, but altering the direction
 //Macro to create object/animation at position of rebounce (description of usage in Docs)
 #declare BB_HitEffect=off;
 #macro BB_HitEffect_Macro(Pos,Velocity,Dir,Wall_Normal,Seconds_Passed,Total_Hits,Particle_Lifetime,Particle_Value) #end
 //Macro for rescalement after each hit (description of usage in Docs)
 #declare BB_Hit_Rescale=on;
 #macro BB_HR_Macro(Rescale,Total_Hits,Particle_Lifetime) //declare the Rescale value (multiplier for actual scaling, MUST use float)
  #declare Rescale=Rescale;
 #end

#declare Boundary_Sphere = off;
#declare BS_Center = <0,0,0>;
#declare BS_Radius = 20;

//None-"physics" position-modifier
#declare Pos_Modifier = off;
#macro Pos_Mod(Position,Init_Direction,Scale,Rotation,Birth,Lifetime)
 //These may be altered
 #declare Position=Position;
 #declare Scale=Scale;
 #declare Rotation=Rotation;
 #end

//Commented out because package not yet released, to avoid
//confusion and anger when trying to run the file...
//#include "partixgen.inc"
//object{Partix}