int nrOfWindVectors, maxWindVectors; 
WindVector[] v;
int nrOfParticles; 
Particle[] p;
color white, black, blau, rot; // colors

void setup() {
  size(400,400,P3D); 
  background(white); 
  noFill(); 
  ellipseMode(CENTER_RADIUS);
  white=color(255,255,255); 
  black=color(0,0,0); 
  blau=color(0,0,255); 
  rot=color(255,0,0);

  nrOfWindVectors=0; 
  maxWindVectors=500;
  v=new WindVector[maxWindVectors];
  float td = 50;
  for (float x=0;x<width;x+=td) {
    for (float y=0;y<height;y+=td) {
      if (random(1.0)<0.2) {
        float s=random(td);
        float rd=random(TWO_PI);
        float xo=s*cos(rd);
        float yo=s*sin(rd);
        v[nrOfWindVectors] = new WindVector(x+td/2.0,y+td/2.0,x+td/2.0+xo,y+td/2.0+yo);
        nrOfWindVectors++;
      }
    }
  }
  //for (int i=0;i<maxWindVectors;i++) v[i]=new WindVector(0,0,0,0);

  // initialize particles
  nrOfParticles=1000;
  p=new Particle[nrOfParticles];
  for (int i=0;i<nrOfParticles;i++) {
    p[i]=new Particle();
    float s=1;
    float rd=random(TWO_PI);
    float xo=s*cos(rd);
    float yo=s*sin(rd);
    p[i].mov.x=xo;
    p[i].mov.y=yo;
  }
}

void keyPressed() {
  if (key==' ') setup();
  if (key=='r') {
    for (int i=0;i<nrOfParticles;i++) {
      p[i].pos.x=random(width);
      p[i].pos.y=random(height);
    }
  }
}

void draw() {
  background(white);
  for (int i=0;i<nrOfParticles;i++) {
    p[i].update();
  }
  if (nrOfWindVectors>0) {
    for (int i=0; i<nrOfWindVectors;i++) {
      v[i].update();
    }
  }
  updateDrawLine();
}


// DRAW A LINE IF MOUSEDOWN AND CREATE A NEW VECTOR ON MOUSE UP:
// -------------------------------------------------------------
boolean lineDraw;
int downX, downY;

void updateDrawLine() {
  if (lineDraw) {
    stroke(rot);
    line(downX,downY,mouseX,mouseY);
  }
}

void mousePressed() {
  if (nrOfWindVectors<maxWindVectors) {
    lineDraw=true;
    downX=mouseX; 
    downY=mouseY;
  }
}

void mouseReleased() {
  if (nrOfWindVectors<maxWindVectors) {
    lineDraw=false;
    v[nrOfWindVectors]=new WindVector(downX,downY,mouseX,mouseY);
    nrOfWindVectors++;
  }
}
// -------------------------------------------------------------


class Particle {
  float influDistance=60;
  //  float maxSpeed=5;
  float slowDown=0.98;
  Vec pos, mov;
  Particle() {
    pos=new Vec(random(width),random(height));
    mov=new Vec(0,0);
  }

  void update() {
    boolean inrange=false;
    for (int i=0;i<nrOfWindVectors;i++) {
      if (!v[i].zero) {
        float D=distPointToLine(pos,v[i].B,v[i].M);
        if (D<influDistance) {
          inrange=true;
          mov=VecAdd(mov,VecMul(abs(influDistance-D)/influDistance*0.09,v[i].Mnorm));
        }
      }
    }
    if (inrange) {
      stroke(rot);
      //slowDown=0.95;//1-(0.1*VecLen(mov)/maxSpeed);    // veclen 0..maxspeed -> 0..1 -> 1..0.9
    } 
    else {
      stroke(blau);
      //slowDown=1;
    }
    mov=VecMul(slowDown,mov);      // xmov*=slowDown; ymov*=slowDown;
    pos=VecAdd(pos,mov);           // x+=xmov; y+=ymov;
    if (pos.x<=0) {
      pos.x=-pos.x;
      mov.x*=-1;
    }
    if (pos.x>width) {
      pos.x=2*width-pos.x;
      mov.x*=-1;
    }
    if (pos.y<=0) {
      pos.y=-pos.y;
      mov.y*=-1;
    }
    if (pos.y>height) {
      pos.y=2*height-pos.y;
      mov.y*=-1;
    }

    //pos=VecInScreen(pos);
    point(pos.x,pos.y);
    ellipse(pos.x,pos.y,2,2);
  }
}


class WindVector {
  float xs,ys,xe,ye;
  boolean zero;
  Vec B, M, Mnorm;
  WindVector(float x1,float y1,float x2,float y2) {
    if (x1==x2&&y1==y2) {
      zero=true;
    } 
    else {
      zero=false;
      xs=x1; 
      ys=y1; 
      xe=x2; 
      ye=y2;
      B=new Vec(xs,ys);
      M=new Vec(xe-xs,ye-ys);
      Mnorm=VecMul(1/dist(xs,ys,xe,ye),M);
    }
  }

  void update() {
    stroke(black);
    if (!zero) {
      ellipse(xs,ys,5,5);
      line(xs,ys,xe,ye);
    }
  }
}




float distPointToLine(Vec P,Vec B, Vec M) { 
  // SEE DOCUMENTATION: http://www.magic-software.com/Documentation/DistancePointLine.pdf
  float t0=VecSkalar(M,VecSub(P,B))/VecSkalar(M,M);
  float D;
  if (t0<=0) {
    D=VecLen(VecSub(P,B));
  } 
  else if (t0<1) {
    D=VecLen(VecSub(P,VecAdd(B,VecMul(t0,M))));
  } 
  else {
    D=VecLen(VecSub(P,VecAdd(B,M)));
  }
  return D;
}

// VECTOR MATHEMATICS:
// -------------------

class Vec {
  float x,y;
  Vec(float x,float y) {
    this.x=x; 
    this.y=y;
  }
}

Vec VecAdd(Vec a, Vec b) {
  Vec z=new Vec(0,0);
  z.x=a.x+b.x; 
  z.y=a.y+b.y;
  return z;
}

Vec VecSub(Vec a, Vec b) {
  Vec z=new Vec(0,0);
  z.x=a.x-b.x; 
  z.y=a.y-b.y;
  return z;
}

Vec VecMul(float a, Vec b) {
  Vec z=new Vec(0,0);
  z.x=a*b.x; 
  z.y=a*b.y;
  return z;
}

float VecSkalar(Vec a, Vec b) { // (len(a)*len(b)*cos(angle between a and b)
  float z;
  z=a.x*b.x+a.y*b.y;
  return z;
}

float VecLen(Vec a) {
  float z=sqrt(a.x*a.x+a.y*a.y);
  return z;
}

Vec VecInScreen(Vec a) {
  Vec z=a;
  while (z.x>width) {
    z.x-=width;
  } 
  while (z.x<1) {
    z.x+=width;
  }
  while (z.y>height) {
    z.y-=height;
  } 
  while (z.y<1) {
    z.y+=height;
  }
  return z;
}