/**
CurveLathe.pde
http://www.davebollinger.com

The technique intended to be illustrated here is how to use
Processing's transforms along with modelXYZ to get around
having to know much about the math going on underneath.

drag to rotate
right-click to generate next shape
*/
//import processing.opengl.*;

// simple storage class for a 3d point
class P3 {
  float x, y, z;
  P3() { this(0,0,0); }
  P3(float _x, float _y, float _z) { x=_x; y=_y; z=_z; }
  void draw() { vertex(x,y,z); }
}

// how many points "around" the mesh
int usteps = 8;
// how many points "along" the mesh
int vsteps = 50;
// the u-shape points to be lathed along a curve
// ("+1" for convenience to dup first point and close the curve)
P3 [] shape = new P3[usteps+1];
// these values will determine an L-system type iterated curve:
float drotx, droty, drotz, dtran;
// the resulting mesh by lathing "shape" along the curve
P3 [][] mesh = new P3[vsteps][usteps+1];
// camera rotation
float rotx, roty;

void setup() {
  size(500,500,P3D);
  //size(500,500,OPENGL);
  build();
}

void build() {
  //
  // define the u-shape on a specific plane
  // x-z plane is used here, then lathed along y
  // but you could use other combinations.
  // this makes regular polygons (approximating circles)
  // but you could use any topologically valid shape:
  //
  float r = 5f;
  for (int u=0; u<=usteps; u++) {
    float theta = float(u) / float(usteps) * TWO_PI;
    shape[u] = new P3(r*cos(theta), 0, r*sin(theta));
  }
  //
  // now define the "curve", here we're using an L-system,
  // for a standard "straight along the axis" lathe, use:
  // drotx = droty = drotz = 0f;
  // otherwise...
  //
  drotx = random(-0.3,0.3);
  droty = random(-0.3,0.3);
  drotz = random(-0.3,0.3);
  dtran = random(5,10);
  //
  // now iterate the L-system and build the mesh along the curve
  //
  camera(); // to reset transforms
  for (int v=0; v<vsteps; v++) {
    for (int u=0; u<=usteps; u++) {
      P3 p = shape[u];
      float mx = modelX(p.x, p.y, p.z);
      float my = modelY(p.x, p.y, p.z);
      float mz = modelZ(p.x, p.y, p.z);
      mesh[v][u] = new P3(mx, my, mz);
    }
    // here's the curve definition, feel free to try others:
    rotateX(drotx);
    rotateY(droty);
    rotateZ(drotz);
    translate(0,dtran,0);
  }
  //
  // that's it!
  //
}

void draw() {
  background(255);
  translate(width/2f, height/2f);
  rotateX(rotx);
  rotateY(roty);
  // draw the axes
  strokeWeight(2);
  stroke(255,0,0);
  line(-100,0,0, 100,0,0);
  stroke(0,255,0);
  line(0,-100,0, 0,100,0);
  stroke(0,0,255);
  line(0,0,-100, 0,0,100);
  // draw the lathe mesh
  lights();
  stroke(64);
  strokeWeight(1);
  fill(192);
  for (int v=0; v<vsteps-1; v++) {
    beginShape(QUAD_STRIP);
    for (int u=0; u<=usteps; u++) {
      mesh[v][u].draw();
      mesh[v+1][u].draw();
    }
    endShape();
  }
  // optionally you could draw triangle fans to cap the lathe
}

void mousePressed() {
  if (mouseButton==RIGHT)
    build();
}

void mouseDragged() {
  if (mouseButton==LEFT) {
    float dx = mouseX-pmouseX;
    float dy = mouseY-pmouseY;
    rotx += -dy * 0.01;
    roty += dx * 0.01;
  }
}