// MESHY by Golan Levin
// Originally developed in October 1998 (C++)
// Processing version November 2006
// golan at flong dot com

import processing.opengl.*;
boolean bUseOpenGL = true;

int nPaths;
int nActual;
int nFilledPaths;
int currentPathIndex;
float currentSample;
int framesSinceMouseUp;
final int mult = 4;
final int meshElementSpacing = 5*mult;
final int nBezSamples        = 75*mult;
final float diamondScale     = 0.003625f * mult;

final int nResamples = 75;
final int nFadeoutFrames = 80;
boolean prevMouseDownState;
boolean mouseIsDown;
float prevMillis = 0;
float splineStrength = 10.0F;
final float bias = 6.0F;

Vector pathArray[];
Vector pathBezArray[];
Vec3f drawArray[][];

float bt[];
float bt2[];
float bt3[];
float onemt[];
float onemt2[];
float onemt3[];
float bto2[];
float bt2o[];

PFont fonty;
boolean begun = false;
boolean showInfo = false;
long begunTime;

//---------------------------------------------------------
void setup(){
  if (bUseOpenGL){
    size(720, 480, OPENGL);
  }
  else{
    size(720, 480, P3D);
  }
  fonty = loadFont("Garamond-Italic-24.vlw");  
  textFont(fonty, 24); 
  textAlign (CENTER); 
  handleInit();
}

void handleInit(){
  mouseIsDown = prevMouseDownState = false;
  currentPathIndex = 0;
  nFilledPaths = 0;
  nPaths = 2;
  nActual = 6;
  currentSample = 0;
  framesSinceMouseUp = 0;

  pathArray = new Vector[nActual];
  pathBezArray = new Vector[nActual];
  drawArray = new Vec3f[nActual][nResamples];
  precomputeBezierArrays();
  for(int i = 0; i < nActual; i++){
    pathArray[i] = new Vector(100);
    pathBezArray[i] = new Vector(500);
    for(int p =0; p<nResamples; p++)
    {
      drawArray[i][p] = new Vec3f();
    }
  }

  createStarter();
}

void precomputeBezierArrays(){
  bt     = new float[nBezSamples];
  bt2    = new float[nBezSamples];
  bt3    = new float[nBezSamples];
  onemt  = new float[nBezSamples];
  onemt2 = new float[nBezSamples];
  onemt3 = new float[nBezSamples];
  bto2   = new float[nBezSamples];
  bt2o   = new float[nBezSamples];
  for(int p = 0; p<nBezSamples; p++){
    bt[p] = (float)p / (float)(nBezSamples-1);
    bt2[p] = bt[p] * bt[p];
    bt3[p] = bt[p] * bt2[p];
    onemt[p] = 1.0f - bt[p];
    onemt2[p] = onemt[p] * onemt[p];
    onemt3[p] = onemt[p] * onemt2[p];
    bto2[p] = 3.0F * bt[p] * onemt2[p];
    bt2o[p] = 3.0F * bt2[p] * onemt[p];
  }
}

//----------------------------------------------------------
void draw(){
  background(0);
  simulate();

  drawIntro();
  drawMeshy();
  drawFades();
}

//----------------------------------------------------------
void simulate() {
  currentSample++;
  prevMouseDownState = mouseIsDown;
  framesSinceMouseUp++;
  blurGesture();
}

//----------------------------------------------------------
void keyPressed(){
  showInfo = true;
  begun = false;
  framesSinceMouseUp = 0;
}

void blurGesture(){
  if (mousePressed){
    float A = 0.025;
    float B = 1.0- 2.0*A;
    Vector path = pathArray[currentPathIndex];
    int ps = path.size();
    int psm1 = ps-1;
    if (ps>3){
      for (int i=1; i<psm1; i++){
        Vec3f v0 = (Vec3f) path.elementAt(i-1);
        Vec3f v1 = (Vec3f) path.elementAt(i  );
        Vec3f v2 = (Vec3f) path.elementAt(i+1);

        float px = A*v0.x + B*v1.x + A*v2.x; 
        float py = A*v0.y + B*v1.y + A*v2.y; 
        float pz = A*v0.z + B*v1.z + A*v2.z; 
        ((Vec3f)path.elementAt(i)).set(px,py,pz); 

      }
      Vector bPath = pathBezArray[currentPathIndex];
      Vec3f resamplePath[] = drawArray[currentPathIndex];
      calculateBezierPath(currentPathIndex);
      resampleVector(bPath, resamplePath);
    }
  }
}


//----------------------------------------------------------
void drawMeshy(){
  if(nFilledPaths > 0){
    int fromIndex = 0;
    int toIndex = 0;
    int otherIndex = 0;
    int offset = -1;
    if(mouseIsDown){
      offset = 0;
    }
    fromIndex = ((currentPathIndex - 1) + offset + nPaths) % nPaths;
    toIndex = (currentPathIndex + offset + nPaths) % nPaths;
    drawStem(pathBezArray[toIndex]);
    if(toIndex % 2 == 1) {
      drawStem(pathBezArray[fromIndex]);
    }
    if(nFilledPaths != 1 || currentPathIndex != 1) {
      int num = nPaths - 1;
      if(nFilledPaths < nPaths){
        num = currentPathIndex;
      }
      for(int i=0; i<=num; i++) {
        fromIndex = ((i - 1) + offset + nPaths) % nPaths;
        toIndex = (i + offset + nPaths) % nPaths;
        if(toIndex % 2 == 1){
          Vec3f fromArray[] = drawArray[fromIndex];
          Vec3f toArray[] = drawArray[toIndex];
          if(nPaths == 2 || currentPathIndex != (fromIndex - offset) % nPaths) {
            drawMesh(fromArray, toArray);
          }
        }
      }
    }
  }
  else {
    for (int p = 0; p <= nFilledPaths; p++) {
      drawStem(pathBezArray[p]);
    }
  }  
}


//----------------------------------------------------------
void drawFades(){

  if (bUseOpenGL){
    noStroke();
    noSmooth();
    float wf = width*0.075;
    float hf = height*0.0333;
    beginShape(QUADS);

    fill(0,0,0, 255);
    vertex(0,0);
    vertex(0,height);
    fill(0,0,0, 0);
    vertex(wf,height-hf);
    vertex(wf,hf);

    fill(0,0,0, 255);
    vertex(0,0);
    vertex(width,0);
    fill(0,0,0, 0);
    vertex(width-wf,hf);
    vertex(wf,hf);

    fill(0,0,0, 255);
    vertex(width,0);
    vertex(width,height);
    fill(0,0,0, 0); 
    vertex(width-wf,height);
    vertex(width-wf,0);

    fill(0,0,0, 255);
    vertex(0,height);
    vertex(width,height);
    fill(0,0,0, 0);
    vertex(width-wf,height-hf);
    vertex(wf,height-hf);

    endShape(); 
  }
}

//---------------------------------------------
void drawIntro(){
  float py = height*(1-0.618);
  if (!begun){
    fill(255); 
    if (showInfo){
      text("Meshy by Golan Levin, 1998-2006", width/2, height/2 ); 
    } 
    else {
      text("Meshy by Golan Levin, 1998-2006", width/2, py - 30); 
      text("Draw two marks to begin", width/2, py); 
    }
    noFill();
  } 
  else {
    float dur = 1000;
    float dif = (float)(millis() - begunTime);
    if (dif < dur){
      float c = 1.0 - dif/dur;
      fill(c*255); 
      if (showInfo){
        text("Meshy by Golan Levin, 1998-2006", width/2, height/2); 
      } 
      else {
        text("Meshy by Golan Levin, 1998-2006", width/2, py - 30); 
        text("Draw two marks to begin", width/2, py); 
      }
      noFill();
    }
  }
}



//------------------------------------------------------------
void mouseMoved (){
  mouseIsDown = false;
}

void mouseReleased(){
  Vector path = pathArray[currentPathIndex];
  Vector bPath = pathBezArray[currentPathIndex];
  addPointToVector(path, mouseX, mouseY);
  Vec3f resamplePath[] = drawArray[currentPathIndex];
  calculateBezierPath(currentPathIndex);
  resampleVector(bPath, resamplePath);
  nFilledPaths++;
  currentPathIndex = nFilledPaths % nPaths;
  framesSinceMouseUp = 0;
  mouseIsDown = false;
}

//=======================================================
void createStarter(){
  float rads[] = {
    0.08, 0.11             };

  for (int c=0; c<2; c++){
    Vector path = pathArray[currentPathIndex];
    Vector bPath = pathBezArray[currentPathIndex];
    float cx = width  * 0.5;
    float cy = height * 0.618;
    float r =  height * rads[c];

    float rotang = c*0.1;
    float fullRound = TWO_PI * (float)(nResamples+1)/(float)nResamples;
    for (int i=0; i<nResamples; i++){
      float t = (float)i/(float)(nResamples-1) * fullRound;
      float x = (cx + r * cos(t + rotang));
      float y = (cy + r * sin(t + rotang));
      addPointToVector(path, x, y);
    }

    Vec3f resamplePath[] = drawArray[currentPathIndex];
    calculateBezierPath(currentPathIndex);
    resampleVector(bPath, resamplePath);
    nFilledPaths++;
    currentPathIndex = nFilledPaths % nPaths;
  }
  framesSinceMouseUp = nFadeoutFrames;
}

void mouseDragged(){
  begun = true;
  Vector path = pathArray[currentPathIndex];
  Vector bPath = pathBezArray[currentPathIndex];
  addPointToVector(path, mouseX, mouseY);
  framesSinceMouseUp = 0;
  mouseIsDown = true;
  Vec3f resamplePath[] = drawArray[currentPathIndex];
  calculateBezierPath(currentPathIndex);
  resampleVector(bPath, resamplePath);
}

void mousePressed(){
  if (begun==false){
    begunTime = millis();
    pathArray[0].removeAllElements();
    pathBezArray[0].removeAllElements();
    pathArray[1].removeAllElements();
    pathBezArray[1].removeAllElements();
    currentPathIndex = 0;
    nFilledPaths = 0;
  }
  currentPathIndex = nFilledPaths % nPaths;
  Vector path = pathArray[currentPathIndex];
  Vector bPath = pathBezArray[currentPathIndex];
  path.removeAllElements();
  bPath.removeAllElements();
  addPointToVector(path, mouseX,     mouseY);
  addPointToVector(path, mouseX + 1, mouseY + 1);
  framesSinceMouseUp = 0;
  calculateBezierPath(currentPathIndex);
  Vec3f resamplePath[] = drawArray[currentPathIndex];
  resampleVector(bPath, resamplePath);
  mouseIsDown = true;
}



//------------------------------------------------------------
float getPathLength(Vector path){
  float pathLength = 0.0F;
  int nPathPoints = path.size();
  for(int i = 0; i < nPathPoints - 1; i++){
    Vec3f lower = (Vec3f)path.elementAt(i);
    Vec3f upper = (Vec3f)path.elementAt(i + 1);
    float Dx = upper.x - lower.x;
    float Dy = upper.y - lower.y;
    float segLength = (float)Math.sqrt(Dx * Dx + Dy * Dy);
    pathLength += segLength;
  }
  return pathLength;
}

void calculateBezierPath(int pathIndex){
  Vector path = pathArray[currentPathIndex];
  Vector bPath = pathBezArray[currentPathIndex];
  bPath.removeAllElements();
  int nSourcePts = path.size();
  int nspm1 = nSourcePts - 1;
  int nBez = 10;
  Vec3f p0 = new Vec3f();
  Vec3f p1 = new Vec3f();
  Vec3f p2 = new Vec3f();
  Vec3f p3 = new Vec3f();
  Vec3f last_pt = new Vec3f();
  Vec3f next_pt = new Vec3f();
  if(nSourcePts < 5) {
    for(int g = 0; g < nSourcePts; g++) {
      Vec3f pt = new Vec3f();
      Vec3f src = (Vec3f)path.elementAt(g);
      float ptx = src.x;
      float pty = src.y;
      pt.set(ptx, pty, 0.0F);
      bPath.addElement(pt);
    }
  }
  else{
    for(int i = 0; i < nSourcePts; i++) {
      if(i == 1) {
        p3 = (Vec3f)path.elementAt(1);
        p0 = (Vec3f)path.elementAt(0);
        next_pt = (Vec3f)path.elementAt(2);
        last_pt.set(p0.x - (p3.x - p0.x) / 4.0F, p0.y - (p3.y - p0.y) / 4.0F, 0.0F);
      }
      else
        if(i == 0){
          next_pt = (Vec3f)path.elementAt(1);
          p3 = (Vec3f)path.elementAt(0);
          p0.set(p3.x - (next_pt.x - p3.x) / 4.0F, p3.y - (next_pt.y - p3.y) / 4.0F, 0.0F);
          last_pt.set(p3.x - (next_pt.x - p3.x) / 2.0F, p3.y - (next_pt.y - p3.y) / 2.0F, 0.0F);
        }
        else
          if(i == nSourcePts - 1)
          {
            p3 = (Vec3f)path.elementAt(i);
            p0 = (Vec3f)path.elementAt(i - 1);
            last_pt = (Vec3f)path.elementAt(i - 2);
            next_pt = p3;
          }
          else
          {
            p3 = (Vec3f)path.elementAt(i);
            p0 = (Vec3f)path.elementAt(i - 1);
            last_pt = (Vec3f)path.elementAt(i - 2);
            next_pt = (Vec3f)path.elementAt(i + 1);
          }
      float dx0 = p0.x - last_pt.x;
      float dy0 = p0.y - last_pt.y;
      float d0 = (float)Math.sqrt(dx0 * dx0 + dy0 * dy0);
      float dx1 = p3.x - p0.x;
      float dy1 = p3.y - p0.y;
      float d1 = (float)Math.sqrt(dx1 * dx1 + dy1 * dy1);
      float dx2 = next_pt.x - p3.x;
      float dy2 = next_pt.y - p3.y;
      float d2 = (float)Math.sqrt(dx2 * dx2 + dy2 * dy2);
      float dAtp0 = (d0 + d1) / 2.0F;
      float dAtp3 = (d1 + d2) / 2.0F;
      p0.set(p0.x, p0.y, dAtp0);
      p3.set(p3.x, p3.y, dAtp3);
      float tan_inx = (p3.x - last_pt.x) / bias;
      float tan_iny = (p3.y - last_pt.y) / bias;
      float tan_inz = (p3.z - d0) / bias;
      float tan_outx = (next_pt.x - p0.x) / bias;
      float tan_outy = (next_pt.y - p0.y) / bias;
      float tan_outz = (d2 - p0.z) / bias;
      float p1x = p0.x + tan_inx;
      float p1y = p0.y + tan_iny;
      float p1z = p0.z + tan_inz;
      float p2x = p3.x - tan_outx;
      float p2y = p3.y - tan_outy;
      float p2z = p3.z - tan_outz;
      p1.set(p1x, p1y, p1z);
      p2.set(p2x, p2y, p2z);
      for(int j = 0; j < nBez; j++){
        float t = (float)j / (float)nBez;
        Vec3f pt = calculatePureBezierVec3f(t, p0, p1, p2, p3);
        bPath.addElement(pt);
      }
    }
  }
}


void addPointToVector(Vector path, float x, float y){
  Vec3f pt = mouseToGeometry(x, y);
  path.addElement(pt);
}

void resampleVector(Vector path, Vec3f resampledPath[]) {
  int nResampledPoints = nResamples;
  int nPathPoints = path.size();
  float totalPathLength = getPathLength(path);
  float RSL = totalPathLength / (float)nResampledPoints;
  float prevRemainder = RSL;
  int p = 0;
  if(nPathPoints <= 1) {
    for(p = 0; p < nResampledPoints; p++){
      Vec3f lower = (Vec3f)path.elementAt(0);
      float px = lower.x + (float)p * 0.0001F;
      float py = lower.y + (float)p * 0.0001F;
      float pz = lower.z + (float)p * 0.0001F;
      resampledPath[p].set(px, py, pz);
    }
  }
  else {
    for(int i = 0; i < nPathPoints - 1; i++){
      Vec3f lower = (Vec3f)path.elementAt(i);
      Vec3f upper = (Vec3f)path.elementAt(i + 1);
      float Dx = upper.x - lower.x;
      float Dy = upper.y - lower.y;
      float Dz = upper.z - lower.z;
      float segLength = (float)Math.sqrt(Dx * Dx + Dy * Dy);
      float ASL = segLength;
      float dx = Dx / segLength;
      float dy = Dy / segLength;
      float RSLdx = dx * RSL;
      float RSLdy = dy * RSL;
      float neededSpace = RSL - prevRemainder;
      if(ASL >= neededSpace){
        float remainder = ASL;
        float px = lower.x + neededSpace * dx;
        float py = lower.y + neededSpace * dy;
        float pz = lower.z + Dz / 2.0F;
        if(p < nResampledPoints) {
          resampledPath[p].set(px, py, pz);
          remainder -= neededSpace;
          p++;
        }
        int nPtsToDo = (int)(remainder / RSL);
        for(int d = 0; d < nPtsToDo; d++) {
          px += RSLdx;
          py += RSLdy;
          if(p < nResampledPoints) {
            resampledPath[p].set(px, py, pz);
            remainder -= RSL;
            p++;
          }
        }

        prevRemainder = remainder;
      }
      else{
        prevRemainder += ASL;
      }
    }
  }
}



void drawStem(Vector path) {
  if(framesSinceMouseUp < nFadeoutFrames) {
    int nSegs = path.size();
    if(nSegs > 1){
      float col = (float)Math.max(0, nFadeoutFrames - framesSinceMouseUp) / (float)nFadeoutFrames;
      beginShape(LINES);
      for(int i = 0; i < (nSegs = path.size()); i++) {
        Vec3f pt = (Vec3f)path.elementAt(i);
        float c = ((float)i / (float)nSegs) * col;
        float x1 = pt.x;
        float y1 = pt.y;

        stroke(c*c*255.0f); 
        vertex(x1, y1);
        vertex(x1+1, y1+1);
      }
      endShape();
    }
  }
}

//----------------------------------------------------------
void drawMesh(Vec3f fromArray[], Vec3f toArray[]){
  float sizef = 0.5F;
  float c = 0.0F;
  int spacing = meshElementSpacing;
  int nbsm1 = nBezSamples-1;
  int nrsm1 = nResamples-1;
  noFill();
  if (bUseOpenGL){
    smooth();
  }
  int roundSamp = round(currentSample);

  float pulse = 1;
  if (begun==false){
    pulse = 0.05 + 0.70*(0.5*(1.0 + cos(PI + millis()/1800.0)));
  }

  float nrsm1f = (float)nrsm1;
  float splBreath = 2.5*sin(millis()/6000.0); 

  beginShape(QUADS);
  for(int i=0; i<nrsm1; i++) {

    float splNoise = 1.0*(noise(i/nrsm1f + millis()/4000.0) - 0.5);
    splineStrength = 10.0 + splNoise + splBreath; 

    Vec3f p1a = fromArray[i];
    Vec3f p1b = fromArray[i + 1];
    Vec3f p4a = toArray[i];
    Vec3f p4b = toArray[i + 1];
    float p1x = (p1a.x + p1b.x) * 0.5F;
    float p1y = (p1a.y + p1b.y) * 0.5F;
    float p1z = (p1a.z + p1b.z) * 0.5F;
    float p4x = (p4a.x + p4b.x) * 0.5F;
    float p4y = (p4a.y + p4b.y) * 0.5F;
    float p4z = (p4a.z + p4b.z) * 0.5F;
    float p2x = p1x + (p1a.y - p1b.y) * splineStrength;
    float p2y = p1y + (p1b.x - p1a.x) * splineStrength;
    float p2z = p1z + (p1b.z - p1a.z) * splineStrength;
    float p3x = p4x - (p4a.y - p4b.y) * splineStrength;
    float p3y = p4y - (p4b.x - p4a.x) * splineStrength;
    float p3z = p4y - (p4b.z - p4a.z) * splineStrength;

    for(int s = 0; s <nbsm1; s++) {
      if(s % spacing == 0 && ((s + roundSamp + 1) % nBezSamples) != 0){
        int sa = (s + roundSamp)     % nBezSamples;
        int sb = (s + roundSamp + 1) % nBezSamples;
        float onemt3sa = onemt3[sa];
        float bto2sa = bto2[sa];
        float bt2osa = bt2o[sa];
        float bt3sa = bt3[sa];
        float onemt3sb = onemt3[sb];
        float bto2sb = bto2[sb];
        float bt2osb = bt2o[sb];
        float bt3sb = bt3[sb];
        float pax = onemt3sa * p1x + bto2sa * p2x + bt2osa * p3x + bt3sa * p4x;
        float pay = onemt3sa * p1y + bto2sa * p2y + bt2osa * p3y + bt3sa * p4y;
        float paz = onemt3sa * p1z + bto2sa * p2z + bt2osa * p3z + bt3sa * p4z;
        float pbx = onemt3sb * p1x + bto2sb * p2x + bt2osb * p3x + bt3sb * p4x;
        float pby = onemt3sb * p1y + bto2sb * p2y + bt2osb * p3y + bt3sb * p4y;
        float pbz = onemt3sb * p1z + bto2sb * p2z + bt2osb * p3z + bt3sb * p4z;

        sizef = (paz + pbz) * diamondScale;
        float pbmax = (pbx - pax) * sizef;
        float pbmay = (pby - pay) * sizef;
        float pamby = (pay - pby) * sizef;
        float b1x = (pax - pbmax * 2.0F);
        float b1y = (pay - pbmay * 2.0F);
        float b2x = (pbx + pbmax * 2.0F);
        float b2y = (pby + pbmay * 2.0F);
        c = (float)(1.0 - cos(((float)sa / (float)nBezSamples) * TWO_PI)) * 0.5F;
        stroke(255,255,255, c*255.0f*pulse);

        float avx = (pax + pbx) * 0.5F;
        float avy = (pay + pby) * 0.5F;
        float b4x = (avx + pamby);
        float b4y = (avy + pbmax);
        float b3x = (avx - pamby);
        float b3y = (avy - pbmax);

        vertex(b1x, b1y);
        vertex(b3x, b3y);
        vertex(b2x, b2y);
        vertex(b4x, b4y);
      }
    }
  }
  endShape();
}


Vec3f mouseToGeometry(float x, float y){
  Vec3f pt = new Vec3f();
  float fx = x;
  float fy = y;
  pt.set(fx, fy, 0.0F);
  return pt;
}

Vec3f calculatePureBezierVec3f(float t, Vec3f p1, Vec3f p2, Vec3f p3, Vec3f p4){
  float t2 = t * t;
  float t3 = t * t2;
  float onemt = 1.0F - t;
  float onemt2 = onemt * onemt;
  float onemt3 = onemt * onemt2;
  Vec3f pt = new Vec3f();
  float ptx = onemt3 * p1.x + 3.0F * t * onemt2 * p2.x + 3.0F * t2 * onemt * p3.x + t3 * p4.x;
  float pty = onemt3 * p1.y + 3.0F * t * onemt2 * p2.y + 3.0F * t2 * onemt * p3.y + t3 * p4.y;
  float ptz = onemt3 * p1.z + 3.0F * t * onemt2 * p2.z + 3.0F * t2 * onemt * p3.z + t3 * p4.z;
  pt.set(ptx, pty, ptz);
  return pt;
}


//=========================================================================
class Vec3f {
  void set(float X, float Y, float Z){
    x = X;
    y = Y;
    z = Z;
  }

  void set(float X, float Y) {
    x = X;
    y = Y;
  }

  Vec3f(float X, float Y, float Z){
    set(X, Y, Z);
  }

  Vec3f() {
    set(0.0F, 0.0F, 0.0F);
  }

  float x;
  float y;
  float z;
}