import processing.opengl.*;

  Point[] pointArray;
  int numPoints = 601;//must be divisible by 3, plus 
  Bezier mainCurve;
  float animT = 0;
  int frame = 0;
  public void setup (){
    background(0);
    smooth();
    println("Setup");
    size(800,500,OPENGL);
    createPoints(); 
  }
  void createPoints(){
    println("createPoints()");
    pointArray = new Point[numPoints];
    
    
    //compute first segment
    float angle = (float)Math.random()*TWO_PI;
    float maxDist = 1000;
    float dist = 500;
    pointArray[0] = new Point(width+20,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()*HALF_PI/2;
      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);
    PFont f = loadFont("GillSansMT-48.vlw");
    textFont(f,48);
    frame = 0;

  }

public void draw(){
  if(mousePressed){
   setup(); 
  }
  background(0);
  animT+=0.005;
  char[] textStr = new String(" If you are reading this then this warning is for you. Every word you read of this useless fine print is another second off your life. Don't you have other things to do? Is your life so empty that you honestly can't think of a better way to spend these moments? Or are you so impressed with authority that you give respect and credence to all who claim it? Do you read everything you're supposed to read? Do you think everything you're supposed to think? Buy what you're told you should want? Get out of your apartment. Meet a member of the opposite sex. Stop the excessive shopping and masturbation. Quit your job. Start a fight. Prove you're alive. If you don't claim your humanity you will become a statistic.").toCharArray();
  fill(255);
    text(textStr[0],width/2,height/2);
  int j=0;
  for(float i=0;i<mainCurve.maxT-animT;i+=0.05){
    //float textPoint = i+textWidth(textStr[j]);
    //println(textPoint);
    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);
      float dx = p1.x-p0.x;
      float dy = p1.y-p0.y;
      float angle = atan2(dy,dx);
      pushMatrix();
      char ch = textStr[j%textStr.length];
      translate(p0.x, p0.y+24, dx*10);
      rotate(angle);

     // println(ch);

      text(ch,0, 0);
      popMatrix();
      j++;
    }
    
 if (animT > mainCurve.maxT-animT){
   animT = 0;
 }
    saveFrame("textCurves-"+nf(frame,4)+".tif");
    frame +=1;
}


/*
*    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;
	}
}