//sweep by Ichitaro Masuda<masuda@imgsrc.co.jp>

import processing.opengl.*;

int capacity = 200;
PaintMethod paint;
PaintMethod paint2;
PaintMethod paint3;
PaintMethod paint4;
boolean showGrid = false;

void setup()
{
  size(400, 800, P3D);
  background(255);
  paint = new PaintMethod();
  paint2 = new PaintMethod();
  paint3 = new PaintMethod();
  paint4 = new PaintMethod();
}

void draw(){
  background(43,29,23);
 
  paint.update(mouseX, mouseY);
  paint2.update(paint.vmx, paint.vmy);
  paint3.update(paint2.vmx, paint2.vmy);
  paint4.update(paint3.vmx, paint3.vmy);
  
  pointLight(255, 255, 255, width/2, height/2, 0); 
  shininess(5.0); 
 
  paint.draw(92,69,52);
  paint2.draw(71,52,38);
  paint3.draw(59,43,31);
  paint4.draw(53,35,27);
  
  if(showGrid)grid();
}

void keyPressed(){
  switch(key){
    case ' ':
      showGrid = !showGrid;
  }
}

void grid(){
  translate(width/2, height/2, 0);
  applyMatrix(paint.rotMatrix.m11, paint.rotMatrix.m12, paint.rotMatrix.m13, 0,
              paint.rotMatrix.m21, paint.rotMatrix.m22, paint.rotMatrix.m23, 0,
              paint.rotMatrix.m31, paint.rotMatrix.m32, paint.rotMatrix.m33, 0,
              0,           0,           0,           1);
  
  stroke(160); noFill();
  for(int i=0; i<3; i++){
    for(int j=0; j<8; j++){
      for(int k=2; k<15; k++){
        float r = i*(width/2-40)/2;
        float theta = (j+1)*(TWO_PI/8);
        point(r*cos(theta), k*50-height/2, r*sin(theta));
      }
    }
  }
}

void polyline(Vector3[] himo,int end) {
  if(end >= 2){
    beginShape(QUAD_STRIP);
    for(int i=0; i<end; i++) {
      //Vector3 z = new Vector3(((himo[0].add(himo[end-1])).div(2.0f)).sub(himo[i]));
      Vector3 z = new Vector3(himo[i].mul(-1));
      z.normalize();
      Vector3 t = new Vector3();
      if(i==0){
        t = himo[1].sub(himo[0]);
      }else if(i!=end-1){
        t = himo[i+1].sub(himo[i-1]);
      }else{
        t = himo[end-1].sub(himo[end-2]);
      }
      t.normalize();
      //float r = 8;
      float r = 2*abs((float)i/(float)end-0.5);
      r = r*r;
      r = 12*(1-r);
      Vector3 g = new Vector3();
      Vector3 f = new Vector3();
      Vector3 temp = (t.cross(z)).mul(r);
      g = himo[i].add(temp);
      f = himo[i].sub(temp);
      vertex(g.x, g.y, g.z);
      vertex(f.x, f.y, f.z);
    }
    endShape();
  }
}

class PaintMethod{
  Vector3[] path;
  Vector3 rotAxis;
  Matrix33 rotMatrix;
  int current = 0;
  float scl = 0.0008;
  float theta;
  float vmx, vmy;
  int r,g,b;
  PaintMethod(){
    path = new Vector3[capacity];
    rotAxis = new Vector3(0,1,0);
    vmx = width/2;
    vmy = height/2;
  }
  void update(float xmouse, float ymouse){
    vmx += (constrain(xmouse, 40, width-40)-vmx)/10;
    vmy += (constrain(ymouse, 120, height-120)-vmy)/10;
    float mx = width/2-vmx;
    float my = height/2-vmy;
    theta += my*scl;
    rotMatrix = rotationAxis(rotAxis, theta);
  
    for(int i=capacity-1; i>0; i--){
      path[i] = path[i-1];
    }
    if(current>0){
      path[0] = get3d_pos(mx, my, rotAxis, theta);
    }else{
      path[0] = get3d_pos(mx, my, rotAxis, theta);
    }
    if(current >= capacity)current = capacity;
    else current++;
  }
  
  void draw(int r, int g, int b){
    noStroke();
    fill(r,g,b);
    pushMatrix();
    translate(width/2, height/2, 0);
    applyMatrix(rotMatrix.m11, rotMatrix.m12, rotMatrix.m13, 0,
                rotMatrix.m21, rotMatrix.m22, rotMatrix.m23, 0,
                rotMatrix.m31, rotMatrix.m32, rotMatrix.m33, 0,
                0,           0,           0,           1);
    polyline(path, current);
    popMatrix();   
  }
  
  Vector3 get3d_pos(float mx, float my, Vector3 ra, float theta){
    Vector3 pos = new Vector3(-mx, -my, 0);
    Matrix33 rotMatrix = rotationAxis(ra, theta);
    return(rotMatrix.trans(pos));
  }
}
/////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////

class Vector3{
  float x,y,z;
  float p;
  Vector3(){
    x = 0.0f;
    y = 0.0f; 
    z = 0.0f;
  }
  Vector3(float xIn, float yIn, float zIn){
    x = xIn;
    y = yIn;
    z = zIn;
  }
  Vector3(Vector3 v){
    x = v.x;
    y = v.y;
    z = v.z;
  }
  void set(float xIn, float yIn, float zIn){
    x = xIn;
    y = yIn;
    z = zIn;
  }
  boolean eq(Vector3 v){
    return ((x == v.x) && (y == v.y) && (z == v.z));
  }
  boolean notEq(Vector3 v){
    return ((x != v.x) || (y != v.y) || (z != v.z));
  }
  Vector3 add(Vector3 v){
    return new Vector3(x+v.x,
                       y+v.y,
                       z+v.z);
  }
  Vector3 sub(Vector3 v){
    return new Vector3(x-v.x,
                       y-v.y,
                       z-v.z);
  }
  Vector3 mul(float f){
    return new Vector3(x*f,
                       y*f,
                       z*f);
  }
  Vector3 div(float f){
    return new Vector3(x/f,
                       y/f,
                       z/f);
  }
  float dot(Vector3 v){
    return (x*v.x + y*v.y + z*v.z);
  }
  Vector3 cross(Vector3 v){
    return new Vector3(y*v.z - z*v.y,
                       z*v.x - x*v.z,
                       x*v.y - y*v.x);
  }
  float length(){
    return sqrt(x*x + y*y + z*z);
  }
  float lengthSq(){
    return (x*x + y*y + z*z);
  }
  Vector3 normalize(){
    float m = length();
    if(m > 0.0f)m = 1.0f/m;
    else m = 0.0f;
    x *= m;
    y *= m;
    z *= m;
    return this;
  }
  Vector3 normalized(){
    Vector3 ret = new Vector3(this);
    return ret.normalize();
  }
  void trace(){
    println(x+", "+y+", "+z);
  }
}

class Matrix33{
  float m11,m12,m13,
        m21,m22,m23,
        m31,m32,m33;
  Matrix33(){
    m11 = 1.0f; m12 = 0.0f; m13 = 0.0f;
    m21 = 0.0f; m22 = 1.0f; m23 = 0.0f;
    m31 = 0.0f; m32 = 0.0f; m33 = 1.0f;
  }
  Matrix33(float i11, float i12, float i13,
           float i21, float i22, float i23,
           float i31, float i32, float i33)
  {
    m11 = i11; m12 = i12; m13 = i13;
    m21 = i21; m22 = i22; m23 = i23;
    m31 = i31; m32 = i32; m33 = i33;
  }
  Matrix33(Matrix33 m)
  {
    m11 = m.m11; m12 = m.m12; m13 = m.m13;
    m21 = m.m21; m22 = m.m22; m23 = m.m23;
    m31 = m.m31; m32 = m.m32; m33 = m.m33;
  }
  void set(float i11, float i12, float i13,
           float i21, float i22, float i23,
           float i31, float i32, float i33)
  {
    m11 = i11; m12 = i12; m13 = i13;
    m21 = i21; m22 = i22; m23 = i23;
    m31 = i31; m32 = i32; m33 = i33;
  }
  Matrix33 add(Matrix33 m){
    return new Matrix33(m11+m.m11, m12+m.m12, m13+m.m13,
                        m21+m.m21, m22+m.m22, m23+m.m23,
                        m31+m.m31, m32+m.m32, m33+m.m33);
  }
  Matrix33 sub(Matrix33 m){
    return new Matrix33(m11-m.m11, m12-m.m12, m13-m.m13,
                        m21-m.m21, m22-m.m22, m23-m.m23,
                        m31-m.m31, m32-m.m32, m33-m.m33);
  }
  Matrix33 comp(Matrix33 m){
    return new Matrix33(m11*m.m11, m12*m.m21, m13*m.m31,
                        m21*m.m12, m22*m.m22, m23*m.m32,
                        m31*m.m13, m32*m.m23, m33*m.m33);
  }
  Matrix33 mul(float f){
    return new Matrix33(m11*f, m12*f, m13*f,
                        m21*f, m22*f, m23*f,
                        m31*f, m32*f, m33*f);
  }
  Matrix33 div(float f){
    return new Matrix33(m11/f, m12/f, m13/f,
                        m21/f, m22/f, m23/f,
                        m31/f, m32/f, m33/f);
  }
  Vector3 trans(Vector3 v){
    Vector3 ret = new Vector3();
    ret.x = v.x * m11 + v.y * m21 + v.z * m31;
    ret.y = v.x * m12 + v.y * m22 + v.z * m32;
    ret.z = v.x * m13 + v.y * m23 + v.z * m33;
    return ret;
  }
  Matrix33 identity(){
    m11 = 1; m12 = 0; m13 = 0;
    m21 = 0; m22 = 1; m23 = 0;
    m31 = 0; m32 = 0; m33 = 1;
    return this;
  }
  Matrix33 transpose(){
    float t = m12;
    m12 = m21;
    m21 = t;
    t = m13;
    m13 = m31;
    m31 = t;
    t = m23;
    m23 = m32;
    m32 = t;
    return this;
  }
  float det(){
    return m11*(m22*m33-m23*m32) - m12*(m21*m33-m23*m31) + m13*(m21*m32-m22*m31);
  }
  Matrix33 invert(){
    float invDet = 1.0f/det();
    Matrix33 invMat = new Matrix33();
    invMat.m11 = invDet*(m22*m33-m23*m32); invMat.m12 = invDet*(m13*m32-m12*m33); invMat.m13 = invDet*(m12*m23-m13*m22);
    invMat.m21 = invDet*(m23*m31-m21*m33); invMat.m22 = invDet*(m11*m33-m13*m31); invMat.m23 = invDet*(m13*m21-m11*m23);
    invMat.m31 = invDet*(m21*m32-m22*m31); invMat.m32 = invDet*(m12*m31-m11*m32); invMat.m33 = invDet*(m11*m22-m12*m21);
    return invMat;
  }
  void trace(){
    println(m11+", "+m12+", "+m13);
    println(m21+", "+m22+", "+m23);
    println(m31+", "+m32+", "+m33);
  }
}

Matrix33 rotationAxis(Vector3 rotAxis, float theta){
  float c = cos(theta);
  float s = sin(theta);
  return new Matrix33(c+rotAxis.x*rotAxis.x*(1-c), rotAxis.x*rotAxis.y*(1-c), rotAxis.y*s,
                      rotAxis.x*rotAxis.y*(1-c), c+rotAxis.y*rotAxis.y*(1-c), -rotAxis.x*s,
                      -rotAxis.y*s, rotAxis.x*s, c);
}