import processing.opengl.*;

  Point[] pointArray;
  int numPoints = 601;//must be divisible by 3, plus 
  Bezier mainCurve;
  float animT = 0;
  public void setup (){
    background(0);
    smooth();
    println("Setup");
    size(450,450,OPENGL);
    createPoints(); 
  }
  void createPoints(){
    println("createPoints()");
    pointArray = new Point[numPoints];
    
    
    //compute first segment
    float angle = (float)Math.random()*TWO_PI;
    float maxDist = 500;
    float dist = 100;
    pointArray[0] = new Point(width/2,height/2);
    pointArray[1] = new Point(pointArray[0].x+cos(angle-HALF_PI)*dist/2,pointArray[0].y+sin(angle-HALF_PI)*dist/2);
    float rand = (float)Math.random();
    pointArray[2] = new Point(pointArray[0].x+cos(angle+HALF_PI)*dist*rand,pointArray[0].y+sin(angle+HALF_PI)*dist*rand);
    pointArray[3] = new Point(pointArray[0].x+cos(angle-HALF_PI)*dist*rand,pointArray[0].y+sin(angle-HALF_PI)*dist*rand);
    
    fill(0);
    ellipse(pointArray[0].x,pointArray[0].y,5,5);
    ellipse(pointArray[1].x,pointArray[1].y,5,5);
    ellipse(pointArray[2].x,pointArray[2].y,5,5);
    ellipse(pointArray[3].x,pointArray[3].y,5,5);
    
    
    //compute the rest of the segments
    for (int i=4;i<numPoints;i+=3){
      Point pp = pointArray[i-1];//previous point
      //println("pp.x="+pp.x+" pp.y="+pp.y);
      angle += (float)Math.random()*PI - HALF_PI;
      dist = (float)Math.random()*maxDist;
      Point cp = pointArray[i-2];//previous control point
      

      Point p0 = new Point(pp.x - (cp.x - pp.x), pp.y - (cp.y - pp.y));//control point, perpendicular to second point on previous segment



      Point p2 = new Point(pp.x + cos(angle)*dist/2,pp.y + sin(angle)*dist/2);//start point
      Point p1 = new Point(p2.x - cos(angle - HALF_PI)*dist/2, p2.y - sin(angle+HALF_PI)*dist/2);//control point 2
      
      //stop from going offscreeen
      
      if (p1.x > width){
        p1.x = width;
      }
      if (p1.x < 0){
        p1.x =0;
      }
      if (p1.y <0 ){
        p1.y=0; 
      }
      if (p1.y > height){
        p1.y = height; 
      }
      
      if (p2.x > width){
        p2.x = width;
      }
      if (p2.x < 0){
        p2.x =0;
      }
      if (p2.y <0 ){
        p2.y=0; 
      }
      if (p2.y > height){
        p2.y = height; 
      }
      
      //assign to array
      
      pointArray[i] = p0;
      pointArray[i+1] = p1;
      pointArray[i+2] = p2;

      //println("p0.x="+p0.x+", p0.y="+p0.y);
      // println("p1.x="+p1.x+", p1.y="+p1.y);
      // println("p2.x="+p2.x+", p2.y="+p2.y);
      
      boolean showPoints = false;//show the points which make up the curve
      
      if (showPoints){
        stroke(0);
        fill(66);
        line(pp.x,pp.y,pointArray[i].x,pointArray[i].y);
        ellipse(pointArray[i].x,pointArray[i].y,5,5);
        line(pointArray[i].x,pointArray[i].y,pointArray[i+1].x,pointArray[i+1].y);
        fill(99);
        ellipse(pointArray[i+1].x,pointArray[i+1].y,5,5);
        line(pointArray[i+1].x,pointArray[i+1].y,pointArray[i+2].x,pointArray[i+2].y);
        fill(33);
        ellipse(pointArray[i+2].x,pointArray[i+2].y,5,5);
        
        noFill();

        
      }
        stroke(255);      
      //bezier(pp.x,pp.y,pointArray[i].x,pointArray[i].y,pointArray[i+1].x,pointArray[i+1].y,pointArray[i+2].x,pointArray[i+2].y);
    }
    
    mainCurve = new Bezier(pointArray);
   
   
  }

public void draw(){
  background(0);
  animT+=0.005;
  for(float i=animT;i<mainCurve.maxT-animT;i+=0.2){
    Point p0 = mainCurve.pointOnBezier(i+animT-0.05);  
    Point p1 = mainCurve.pointOnBezier(i+(animT));
      line(p0.x,p0.y,p1.x,p1.y);
      rect(p1.x-2.5,p1.y-2.5,5,5);
    }
    
 if (animT > mainCurve.maxT){
   animT = 0;
 }
 
 if(frameCount == 1000){
   saveFrame("partilces.tif");
 }
}


/*
*    This is the simple point datatype. There's probably something similar in Processing, but I wanted to be in control of everything.
*/
class Point{
  float x;
  float y;
  Point (float x, float y){
   this.x = x;
   this.y = y; 
  }
}


/*
*    This is a bezier segment - this is set of 4 points, which make up:
*   
*   s0 - Endpoint 1
*   s1 - control point 1
*   s2 - control point 2
*   s3 - Endpoint 2
*
*    All the intermediate points can be found via linear interpolation.
*/
class Segment{
  Point s0;
  Point s1;
  Point s2;
  Point s3;
  Segment(Point s0, Point s1, Point s2, Point s3){
     this.s0 = s0; 
     this.s1 = s1;
     this.s2 = s2;
     this.s3 = s3;           
  }
}


/*
*   Bezier class - creates a bezier curve from an array of points. 
*/
class Bezier{
	Point[] points;
	Segment[] segments;
	int maxT;
        Bezier(Point[] points) {
		this.points = points;
		parseSegments();
	}
	
	private void parseSegments(){
		this.segments = new Segment[((int)points.length/3) + 1];
                println(this.segments.length);
		for (int i = 0; i< segments.length-1; i++){
                       int j=i*3;
			segments[i] = new Segment(points[j], points[j+1], points[j+2], points[j+3]);
		}
                maxT = segments.length-1;
	}
	

        /*
        *    This returns a point on a bezier curve of n segments, from an input variable of t, which can be between 0 and n. 
        *    The method will automatically fetch the correct segment and give the exact value at t. Useful for complex curves.
        */
	public Point pointOnBezier(float t) {
		if (t<0){
			return new Point(-100,-100);
		}
	   int seg = (int) Math.floor(t);

	   Segment cp = segments[seg];
	   t -= seg;
	   float ax, bx, cx;
	   float ay, by, cy;
	   float tSquared, tCubed;
	   Point cPoint = new Point(0,0);
	
	    /* calculate the polynomial coefficients */
	
	    cx = 3.0 * (cp.s1.x - cp.s0.x);
	    bx = 3.0 * (cp.s2.x - cp.s1.x) - cx;
	    ax = cp.s3.x - cp.s0.x - cx - bx;
	        
	    cy = 3.0 * (cp.s1.y - cp.s0.y);
	    by = 3.0 * (cp.s2.y - cp.s1.y) - cy;
	    ay = cp.s3.y - cp.s0.y - cy - by;
	        
	    /* calculate the curve point at parameter value t */
	    
	    tSquared = t * t;
	    tCubed = tSquared * t;
	    
	    cPoint.x = (ax * tCubed) + (bx * tSquared) + (cx * t) + cp.s0.x;
	    cPoint.y = (ay * tCubed) + (by * tSquared) + (cy * t) + cp.s0.y;
	    
	    return cPoint;
	}
}