Vec3D points[],curvePoints[];
int line[][];
int ptCnt,lineCnt;
float rot=0,scaleFactor=1.5;
float rad=0,rotX=0,rotY=0;
ArcBall arcball;
boolean renderBoxes=false,doSaveFrame=false,autoRotate=true;

void setup() {
  size(400,400);
  background(200);
  points=new Vec3D[10000];
  curvePoints=new Vec3D[1000];
  line=new int[1000][2];
  ptCnt=0;
  lineCnt=0;
  createCurve();
  arcball=new ArcBall(width/2,height/2, height*0.5);
  arcball.mousePressed();
  
  smooth();
  noLights();
}

void loop() {
  background(175);
  translate(width/2,height/2);
  if(autoRotate) rot+=0.1;
  arcball.run(); 
  scale(scaleFactor);
  rotateY(radians(100+rot*1.375));
  rotateZ(radians(10+rot*2.25));

  noFill();
  for(int j=0; j<36; j++) {
    for(int i=0; i<ptCnt; i++) {
      if(renderBoxes) {
        fill(255,120,0);
      stroke(40);
        push();
        translate(curvePoints[i].x-150,curvePoints[i].y);
        box(curvePoints[i].z);
        pop();
      }
      else {
        stroke(255);
        if(i<ptCnt-1) line(curvePoints[i].x-150,curvePoints[i].y,
        curvePoints[i+1].x-150,curvePoints[i+1].y);
        push();
        stroke(40);
        translate(curvePoints[i].x-150,curvePoints[i].y);
        rad=curvePoints[i].z/2;
        line(0,-rad, 0,rad);
        line(-rad,0, rad,0);      
        rotateY(radians(90));
        line(rad,0, -rad,0);
        pop();
      }
    }
    rotateX(radians(10));
  }
  if(!online() && doSaveFrame) saveFrame();
  doSaveFrame=false;
  
}

void createCurve() {
  float bez[][];
  int numSegments,numPointsPerSegment;
  float xD,tD,maxY,yOffs;
  int index=0,cnt=0;
  
// Set up randomized bezier segments  
// Only numSegments*3+1 points are needed
  numSegments=(int)(random(5)+2);
  numPointsPerSegment=12;
  bez=new float[numSegments*3+1][3];
  xD=300.0/(float)(numSegments*3);
  maxY=100;
  
  for(int i=0; i<numSegments*3+1; i++) {    
    bez[i][0]=(float)i*xD;
    if(i==0) bez[i][1]=random(maxY*0.15)+maxY*0.1;
    else if(i%3==0) {
      if(i==numSegments*3) bez[i][1]=random(maxY*0.25)+maxY*0.25;
      else bez[i][1]=random(maxY*0.75)+maxY*0.25;
      yOffs=random(maxY*0.6)-maxY*0.3;
      bez[i-1][1]=bez[i][1]-yOffs;
      if(i!=numSegments*3) bez[i+1][1]=bez[i][1]+yOffs;
    }
    if(random(100)<80) bez[i][2]=random(6)+1; // Radius
    else bez[i][2]=random(8)+8;
  }
  
// Calculate X and Y values of the bezier segments  
  tD=1.0/(float)(numPointsPerSegment-1);
  for(int i=0; i<numSegments; i++) {
    if(i==0) index=0;
    else index=i*3;
    for(int j=0; j<numPointsPerSegment; j++) {
      curvePoints[cnt]=new Vec3D(
        bezierPoint(
          bez[index][0],
          bez[index+1][0],
          bez[index+2][0],
          bez[index+3][0], tD*(float)j),
        bezierPoint(
          bez[index][1],
          bez[index+1][1],
          bez[index+2][1],
          bez[index+3][1], tD*(float)j),
        bezierPoint(
          bez[index][2],
          bez[index+1][2],
          bez[index+2][2],
          bez[index+3][2], tD*(float)j));
      cnt++;
//      println(cnt+" -- "+(numSegments*numPointsPerSegment));
    }
  }
  ptCnt=cnt;    
}

void keyPressed() {
  if(key==' ') renderBoxes=!renderBoxes;
  else if(key=='r') autoRotate=!autoRotate;
  else if(key=='s') doSaveFrame=true;
  if(renderBoxes) {
    noSmooth();
    lights();
  }
  else {
    smooth();
    noLights();
  }

}

void mouseMoved() {
  arcball.mouseDragged();
}

void mouseDragged() {
  scaleFactor=-(float)(mouseY-height/2)/(float)(height/2);
  scaleFactor=max(0.1,min(2,scaleFactor*1.+2));
  
  println(scaleFactor);
}

void mousePressed() {
  createCurve();
}


// Vec3D - simple 3D vector class
// processing.unlekker.net

class Vec3D {
  float x,y,z;

  Vec3D(float _x,float _y,float _z) {
    x=_x;
    y=_y;
    z=_z;
  }

  Vec3D(Vec3D v) {
    x=v.x;
    y=v.y;
    z=v.z;
  }

  void set(float _x,float _y,float _z) {
    x=_x;
    y=_y;
    z=_z;
  }

  void set(Vec3D v) {
    x=v.x;
    y=v.y;
    z=v.z;
  }

  void add(float _x,float _y,float _z) {
    x+=_x;
    y+=_y;
    z+=_z;
  }

  void add(Vec3D v) {
    x+=v.x;
    y+=v.y;
    z+=v.z;
  }

  void sub(float _x,float _y,float _z) {
    x-=_x;
    y-=_y;
    z-=_z;
  }

  void sub(Vec3D v) {
    x-=v.x;
    y-=v.y;
    z-=v.z;
  }

  void mult(float m) {
    x*=m;
    y*=m;
    z*=m;
  }

  void div(float m) {
    x/=m;
    y/=m;
    z/=m;
  }

  float length() {
    return sqrt(x*x+y*y+z*z);
  }

  void normalise() {
    float l=length();
    if(l!=0) {
      x/=l;
      y/=l;
      z/=l;
    }
  }

  void rotateX(float val) {
    // Floats are not precise enough, so doubles are used for the calculations
    double cosval=Math.cos(val);
    double sinval=Math.sin(val);
    double tmp1=y*cosval - z*sinval;
    double tmp2=y*sinval + z*cosval;

    y=(float)tmp1;
    z=(float)tmp2;
  }

  void rotateY(float val) {
    // Floats are not precise enough, so doubles are used for the calculations
    double cosval=Math.cos(val);
    double sinval=Math.sin(val);
    double tmp1=x*cosval - z*sinval;
    double tmp2=x*sinval + z*cosval;

    x=(float)tmp1;
    z=(float)tmp2;
  }

  void rotateZ(float val) {
    // Floats are not precise enough, so doubles are used for the calculations
    double cosval=Math.cos(val);
    double sinval=Math.sin(val);
    double tmp1=x*cosval - y*sinval;
    double tmp2=x*sinval + y*cosval;

    x=(float)tmp1;
    y=(float)tmp2;
  }
}


// --- ArcBall by Ariel Malka - http://www.chronotext.org/

class ArcBall
{
  float center_x, center_y, radius;
  Vec3 v_down, v_drag;
  Quat q_now, q_down, q_drag;
  Vec3[] axisSet;
  int axis;

  ArcBall(float center_x, float center_y, float radius)
  {
    this.center_x = center_x;
    this.center_y = center_y;
    this.radius = radius;

    v_down = new Vec3();
    v_drag = new Vec3();

    q_now = new Quat();
    q_down = new Quat();
    q_drag = new Quat();

    axisSet = new Vec3[] {new Vec3(1.0f, 0.0f, 0.0f), new Vec3(0.0f, 1.0f, 0.0f), new Vec3(0.0f, 0.0f, 1.0f)};
    axis = -1;  // no constraints...
  }

  void mousePressed()
  {
    v_down = mouse_to_sphere(mouseX, mouseY);
    q_down.set(q_now);
    q_drag.reset();
  }

  void mouseDragged()
  {
    v_drag = mouse_to_sphere(mouseX, mouseY);
    q_drag.set(Vec3.dot(v_down, v_drag), Vec3.cross(v_down, v_drag));
  }

  void run()
  {
    q_now = Quat.mul(q_drag, q_down);
    applyQuat2Matrix(q_now);
  }

  Vec3 mouse_to_sphere(float x, float y)
  {
    Vec3 v = new Vec3();
    v.x = (x - center_x) / radius;
    v.y = (y - center_y) / radius;

    float mag = v.x * v.x + v.y * v.y;
    if (mag > 1.0f)
    {
      v.normalize();
    }
    else
    {
      v.z = sqrt(1.0f - mag);
    }

    return (axis == -1) ? v : constrain_vector(v, axisSet[axis]);
  }

  Vec3 constrain_vector(Vec3 vector, Vec3 axis)
  {
    Vec3 res = new Vec3();
    res.sub(vector, Vec3.mul(axis, Vec3.dot(axis, vector)));
    res.normalize();
    return res;
  }

  void applyQuat2Matrix(Quat q)
  {
    // instead of transforming q into a matrix and applying it...

    float[] aa = q.getValue();
    rotate(aa[0], aa[1], aa[2], aa[3]);
  }
}

static class Vec3
{
  float x, y, z;

  Vec3()
  {
  }

  Vec3(float x, float y, float z)
  {
    this.x = x;
    this.y = y;
    this.z = z;
  }

  void normalize()
  {
    float length = length();
    x /= length;
    y /= length;
    z /= length;
  }

  float length()
  {
    return (float) Math.sqrt(x * x + y * y + z * z);
  }

  static Vec3 cross(Vec3 v1, Vec3 v2)
  {
    Vec3 res = new Vec3();
    res.x = v1.y * v2.z - v1.z * v2.y;
    res.y = v1.z * v2.x - v1.x * v2.z;
    res.z = v1.x * v2.y - v1.y * v2.x;
    return res;
  }

  static float dot(Vec3 v1, Vec3 v2)
  {
    return v1.x * v2.x + v1.y * v2.y + v1.z * v2.z;
  }
  
  static Vec3 mul(Vec3 v, float d)
  {
    Vec3 res = new Vec3();
    res.x = v.x * d;
    res.y = v.y * d;
    res.z = v.z * d;
    return res;
  }

  void sub(Vec3 v1, Vec3 v2)
  {
    x = v1.x - v2.x;
    y = v1.y - v2.y;
    z = v1.z - v2.z;
  }
}

static class Quat
{
  float w, x, y, z;

  Quat()
  {
    reset();
  }

  Quat(float w, float x, float y, float z)
  {
    this.w = w;
    this.x = x;
    this.y = y;
    this.z = z;
  }

  void reset()
  {
    w = 1.0f;
    x = 0.0f;
    y = 0.0f;
    z = 0.0f;
  }

  void set(float w, Vec3 v)
  {
    this.w = w;
    x = v.x;
    y = v.y;
    z = v.z;
  }

  void set(Quat q)
  {
    w = q.w;
    x = q.x;
    y = q.y;
    z = q.z;
  }

  static Quat mul(Quat q1, Quat q2)
  {
    Quat res = new Quat();
    res.w = q1.w * q2.w - q1.x * q2.x - q1.y * q2.y - q1.z * q2.z;
    res.x = q1.w * q2.x + q1.x * q2.w + q1.y * q2.z - q1.z * q2.y;
    res.y = q1.w * q2.y + q1.y * q2.w + q1.z * q2.x - q1.x * q2.z;
    res.z = q1.w * q2.z + q1.z * q2.w + q1.x * q2.y - q1.y * q2.x;
    return res;
  }
  
  float[] getValue()
  {
    // transforming this quat into an angle and an axis vector...

    float[] res = new float[4];

    float sa = (float) Math.sqrt(1.0f - w * w);
    if (sa < EPSILON)
    {
      sa = 1.0f;
    }

    res[0] = (float) Math.acos(w) * 2.0f;
    res[1] = x / sa;
    res[2] = y / sa;
    res[3] = z / sa;

    return res;
  }
}