/*
 Particle Wave 
 Ira Greenberg, December 5, 2005
 - hacked animated version 7/11/08
 */
 
/*lots of stuff to manipulate. I packed
 the arguments into arrays just to make the
 setParticles function argument/parameter
 lists less unwieldy*/
//particle style
float strokeWt = 1.5; // increase if you don’t see any output
float strokeCol= 255;
float[]strokeStyle = {  
  strokeWt, strokeCol};
 
//particle limits
int timeLimit = 1000;
int particleCount = 100;
int[]particleLimits = {  
  timeLimit, particleCount};
 
//particle dynamics
float amplitudeMin = .5;
float amplitudeMax = 4.0;
float frequencyMin = 4.0;
float frequencyMax = 40.0;
float materialMin = .25; // lead
float materialMax = .99; // rubber
float[]particleDynamics = {  
  amplitudeMin, amplitudeMax, frequencyMin,
  frequencyMax, materialMin, materialMax   };
 
// speed limits
float ySpeedMin = .002;
float ySpeedMax = .1;
float xSpeedMin = -2.0;
float xSpeedMax = 2.0;
float[]speedLimits = {  
  xSpeedMin, xSpeedMax, ySpeedMin, ySpeedMax   };
 
float gravity = .85;
//postion of particle emitter
float emitterX;
float emitterY = 0;
float[]world = new float[3];
 
float[]xSpeed;
float[]ySpeed;
float[]accel;
float[]x;
float[]y;
float[]amplitude;
float[]frequency;
float[]material;
float angle = 0;
 
// for increental update
float particleCounter = 0;
float particleFlow = .05;
float waveCounter = 0;
float waveFlow = 1.0;
 
 
 
void setup(){
  size(800, 400);
  background(0);
  frameRate(30);
  smooth();
  emitterX = width/2;
  world[0] = gravity;
  world[1] = emitterX;
  world[2] = emitterY;
 
  //start particle engine
  setParticles(strokeStyle, particleLimits, particleDynamics, speedLimits, world);
}
 
// main particle engine-fully parameterized
void setParticles(float[]strokeStyle, int[]particleLimits, float[]particleDynamics,
float[]speedLimits,  float[]world){
  //create arrays
  xSpeed = new float[particleLimits[1]];
  ySpeed = new float[particleLimits[1]];
  accel = new float[particleLimits[1]];
  x = new float[particleLimits[1]];
  y = new float[particleLimits[1]];
  amplitude = new float[particleLimits[1]];
  frequency = new float[particleLimits[1]];
  material = new float[particleLimits[1]];
 
  // particle style
  strokeWeight(strokeStyle[0]);
  stroke(strokeStyle[1]);
 
 
  //fill arrays
  for (int i = 0; i< particleLimits[1]; i++){
    xSpeed[i] = random(speedLimits[0], speedLimits[1]);
    ySpeed[i] = random(speedLimits[2], speedLimits[3]);
    amplitude[i] = random(particleDynamics[0], particleDynamics[1]);
    frequency[i] = random(particleDynamics[2], particleDynamics[3]);
    material[i] = random(particleDynamics[4], particleDynamics[5]);
    //emitter initial position
    x[i] = world[1];
    y[i] = world[2];
  }
}
 
//generate wave
float makeWaves(float x, float angle, float amplitude){
  x+=sin(radians(angle))*amplitude;
  return x;
}
 
// draw points
void plot(float[]pt){
  point(pt[0], pt[1]);
}
 
void draw(){
  fill(0, 20);
  rect(-1, -1, width+1, height+1);
 // println(particleCounter);
  // dynamics engine
  for (int i=0; i<waveCounter; i++){
    for (int j= 0; j<particleCounter; j++){
 x[i]+=xSpeed[i];
 // add waviness to call to makeWaves function
 x[i]=makeWaves(x[i], angle+=frequency[i], amplitude[i]);
 accel[i]+=ySpeed[i];
 y[i]+=accel[i];
 // plot function just calls point() method
 plot(new float[]{  
   x[i], y[i]          }
 );
 
 //ground detection
 if (y[i]>=height){
   accel[i]*=-1*material[i];
   accel[i]*=world[0];
   y[i] = height;
 }
 //wall detection
 if (x[i]>=width || x[i]<=0){
   xSpeed[i] *=-1;
 }
    }
 
  }
  if (waveCounter<particleLimits[1]-1){
    waveCounter+=waveFlow;
 
  }
  if (particleCounter<particleLimits[0]-1){
    particleCounter+=particleFlow;
 
  }
}