// applet size variables
int xSize           = 600;
int ySize           = 300;
int xMid            = xSize/2;
int yMid            = ySize/2;


// camera variables
float xMouse, yMouse;
float rotationVar;
float elevation, azimuth, twist;
float cd = 400;        // camera distance
float cdDest = 400.0;  // destination camera distance
float cp = 60.0;       // camera perspective
float cpDest = 60.0;   // destination camera perspective

int counter = 0;
int ribbonLength = 200;
int ribbonSpeed = 5;
int ribbonWidth = 4;
float segmentWidth;
int ribbonRibs = 128;
float degrade = .99;
float signalDegrade = .99;

// SONIA ADD ONS
int fBands = 128;
float spectrumArray[][];
float signalArray[][];

BImage myField;
boolean autoRotate;
color bgColor;
float bgRed, bgGreen, bgBlue = 0.0;
float bgr,bgg,bgb;

int audioType = 0;
int audioSymmetry = 2;

void setup(){
  size(xSize, ySize);
  //lights();
  //smooth();
  background(0);
  colorMode(RGB,255);
  framerate(30);
  ellipseMode(CENTER_RADIUS);
  
  elevation = radians(15.0f);
  azimuth = radians(0.0f);
  cdDest = 450;

  Sonia.start(this);
  LiveInput.start(fBands);
  LiveInput.useEqualizer(true);
  LiveInput.useEnvelope(true,1.5);
  spectrumArray = new float[ribbonLength*2+1][fBands];
  signalArray = new float[ribbonLength*2+1][fBands];
  
  bgColor = color(75,0,0);
  myField = loadImage("field.gif");
  brightToAlpha(myField);
}

void loop(){
  bgr -= (bgr - bgRed) * .2;
  bgg -= (bgg - bgGreen) * .2;
  bgb -= (bgb - bgBlue) * .2;
  
  background(bgr,bgg,bgb);
  
  if (audioSymmetry == 1){
    processAudioSingle();
  } else if (audioSymmetry == 2){
    processAudioSymmetry();
  }
  
  doCamera();
  if (audioType == 1){
    rippleTentacles();
  } else if (audioType == 2){
    rippleDish();
  } else if (audioType == 3){
    fuzzySphere();
  } else if (audioType == 4){
    fuzzySphere2();
  } else if (audioType == 5){
    fuzzyRings();
  } else if (audioType == 6){
    tube();
  } else if (audioType == 7){
    spirograph();
  } else if (audioType == 8){
    test();
  }
  
  //saveFrame("screenGrabs/ribbon_1_####.tif");
  counter ++;
}

void keyPressed(){
  if (key == '='){
    ribbonWidth ++;
  } else if (key == '-' && ribbonWidth > 1){
    ribbonWidth --;
  } else if (key == 'a' || key == 'A'){
    if (autoRotate){
      autoRotate = false;
    } else {
      autoRotate = true;
    }
  } else if (key == 's' || key == 'S'){
    audioSymmetry = 1;
  } else if (key == 'd' || key == 'D'){
    audioSymmetry = 2;
  } else if (key == '1'){  // rippleTentacles
    bgRed = 25.0;
    bgGreen = 0.0;
    bgBlue = 0.0;

    cpDest = 95.0;
    cdDest = 415;
    ribbonWidth = 2;
    audioType = 1;
    audioSymmetry = 1;
    signalDegrade = .94;
    
    ribbonRibs = 128;
    fBands = 128;
  } else if (key == '2'){  // rippleDish
    bgRed = 255.0;
    bgGreen = 255.0;
    bgBlue = 255.0;
    
    cpDest = 60.0;
    cdDest = 405;
    ribbonWidth = 4;
    audioType = 2;
    audioSymmetry = 2;
    signalDegrade = .94;
    
    ribbonRibs = 64;
    fBands = 64;
  } else if (key == '3'){  // fuzzySphere
    bgRed = 0.0;
    bgGreen = 0.0;
    bgBlue = 25.0;
    
    cpDest = 85.0;
    cdDest = 300;
    ribbonWidth = 4;
    audioType = 3;
    audioSymmetry = 2;
    signalDegrade = .96;
    
    ribbonRibs = 128;
    fBands = 128;
  } else if (key == '4'){  // fuzzySphere2
    bgRed = 0.0;
    bgGreen = 50.0;
    bgBlue = 75.0;
    
    cpDest = 85.0;
    cdDest = 300;
    ribbonWidth = 4;
    audioType = 4;
    audioSymmetry = 2;
    signalDegrade = .96;
    
    ribbonRibs = 128;
    fBands = 128;
  } else if (key == '5'){  // fuzzyRings
    bgRed = 255.0;
    bgGreen = 255.0;
    bgBlue = 100.0;
    
    cpDest = 45.0;
    cdDest = 250;
    ribbonWidth = 4;
    audioType = 5;
    audioSymmetry = 2;
    signalDegrade = .65;
    
    ribbonRibs = 128;
    fBands = 128;
  } else if (key == '6'){  // tube
    bgRed = 150.0;
    bgGreen = 255.0;
    bgBlue = 255.0;
    
    cpDest = 45.0;
    cdDest = 300;
    ribbonWidth = 3;
    audioType = 6;
    audioSymmetry = 2;
    signalDegrade = .75;
    ribbonSpeed = 5;
    
    ribbonRibs = 64;
    fBands = 64;
  } else if (key == '7'){  // spirograph
    bgRed = 51.0;
    bgGreen = 51.0;
    bgBlue = 51.0;
    
    cpDest = 45.0;
    cdDest = 300;
    ribbonWidth = 6;
    audioType = 7;
    audioSymmetry = 1;
    signalDegrade = .96;
    ribbonSpeed = 5;
    
    ribbonRibs = 64;
    fBands = 64;
  } else if (key == '8'){  // test
    bgRed = 51.0;
    bgGreen = 51.0;
    bgBlue = 51.0;
    
    cpDest = 45.0;
    cdDest = 300;
    ribbonWidth = 6;
    audioType = 8;
    audioSymmetry = 1;
    signalDegrade = .96;
    ribbonSpeed = 5;
    
    ribbonRibs = 128;
    fBands = 128;
  }
}

void processAudioSingle(){
  LiveInput.getSpectrum(false);
  
  for(int i = ribbonLength*2 - ribbonSpeed; i >= ribbonSpeed; i -= ribbonSpeed){
    for(int j = 0; j < fBands; j ++){
      spectrumArray[i+ribbonSpeed][j] -= (spectrumArray[i+ribbonSpeed][j] - (spectrumArray[i][j] * degrade)) * signalDegrade;
    } 
  }

  for(int j = 0; j < fBands; j ++){
    spectrumArray[ribbonSpeed][j] = LiveInput.spectrum[j]/3.0;
  }
  
  
  for(int i = ribbonLength*2 - ribbonSpeed; i >= ribbonSpeed; i -= ribbonSpeed){
    for(int j = 0; j < fBands; j ++){
      signalArray[i+ribbonSpeed][j] -= (signalArray[i+ribbonSpeed][j] - (signalArray[i][j] * degrade)) * signalDegrade;
    } 
  }

  for(int j = 0; j < fBands; j ++){
    signalArray[ribbonSpeed][j] = LiveInput.signal[j]/4.0;
  }
}



void processAudioSymmetry(){
  LiveInput.getSpectrum(false);
  
  for(int i = ribbonSpeed; i <= ribbonLength; i += ribbonSpeed){
    for(int j = 0; j < fBands; j ++){
      spectrumArray[i-ribbonSpeed][j] -= (spectrumArray[i-ribbonSpeed][j] - (spectrumArray[i][j] * degrade)) * signalDegrade;
    } 
  }
  for(int i = ribbonLength*2 - ribbonSpeed; i >= ribbonLength; i -= ribbonSpeed){
    for(int j = 0; j < fBands; j ++){
      spectrumArray[i+ribbonSpeed][j] -= (spectrumArray[i+ribbonSpeed][j] - (spectrumArray[i][j] * degrade)) * signalDegrade;
    } 
  }
  for(int j = 0; j < fBands; j ++){
    spectrumArray[ribbonLength][j] = constrain(LiveInput.spectrum[j]/1.0,0,300);
  }
  
  
  for(int i = ribbonSpeed; i <= ribbonLength; i += ribbonSpeed){
    for(int j = 0; j < fBands; j ++){
      signalArray[i-ribbonSpeed][j] -= (signalArray[i-ribbonSpeed][j] - (signalArray[i][j] * degrade)) * signalDegrade;
    } 
  }
  for(int i = ribbonLength*2 - ribbonSpeed; i >= ribbonLength; i -= ribbonSpeed){
    for(int j = 0; j < fBands; j ++){
      signalArray[i+ribbonSpeed][j] -= (signalArray[i+ribbonSpeed][j] - (signalArray[i][j] * degrade)) * signalDegrade;
    } 
  }
  for(int j = 0; j < fBands; j ++){
    signalArray[ribbonLength][j] = constrain(LiveInput.signal[j]/5.0,0,300);
  }
}


void doCamera(){
  if (autoRotate){
    xMouse = cos(counter/75.0) * 65.0;
    yMouse = sin(counter/100.0) * 100.0;
    //azimuth = sin(counter/50.0) * 7.0;
  } else {
    xMouse       -= (xMouse - (xMid - mouseX)) * .2f;
    yMouse       -= (yMouse - (yMid - mouseY)) * .2f;
  }

  beginCamera();
  cp -= (cp - cpDest) * .2;
  cd -= (cd - cdDest) * .2;
  perspective(cp, (float)xSize / (float)ySize, 1.0f, 500);
  translate(0, 0, -cd);
  twist         = radians(xMouse);
  elevation     = radians(yMouse);
  
  rotateY(-twist);
  rotateX(elevation);
  rotateZ(-azimuth);
  endCamera();
}


void rippleTentacles(){

  bgr = spectrumArray[ribbonSpeed][2] * 3.0;
  for (int j=0; j<ribbonRibs; j++){
    push();
    
    rotateX(j*sin(ribbonRibs));
    rotateZ(j*(TWO_PI/ribbonRibs));
    rotateY(j*cos(ribbonRibs)*1.25);
    
    
    beginShape(QUAD_STRIP);
    for (int i=0; i<ribbonLength*2 - ribbonSpeed; i+=ribbonSpeed){
      noStroke();
      float fillColor = (spectrumArray[i][2] - spectrumArray[i+ribbonSpeed][2])*(i/75.0);
      fill(fillColor);
      if ((i/ribbonSpeed)%2 == 0){
        vertex(-ribbonWidth, spectrumArray[i][2], i);
        vertex(ribbonWidth, spectrumArray[i][2], i);
      } else {
        vertex(ribbonWidth, spectrumArray[i][2], i);
        vertex(-ribbonWidth, spectrumArray[i][2], i);
      }
    }
    endShape();
    pop();
  }
}


void rippleDish(){
  for (int j=0; j<ribbonRibs; j++){
    push();
    rotateY(j*(TWO_PI/ribbonRibs));
    beginShape(QUAD_STRIP);
    for (int i=0; i<ribbonLength*2 - ribbonSpeed; i+=ribbonSpeed){
      noStroke();
      float fillColor = 100 - (signalArray[i][j] - signalArray[i+ribbonSpeed][j])*3.0;
      fill(fillColor);
      if ((i/ribbonSpeed)%2 == 0){
        vertex(-ribbonWidth, signalArray[i][j], i);
        vertex(ribbonWidth, signalArray[i][j], i);
      } else {
        vertex(ribbonWidth, signalArray[i][j], i);
        vertex(-ribbonWidth, signalArray[i][j], i);
      }
    }
    endShape();
    pop();
  }
}

   
void fuzzySphere(){
  for (int j=0; j<ribbonRibs; j++){
    push();

    rotateX(j*sin(ribbonRibs));
    rotateZ(j*(TWO_PI/ribbonRibs));
    rotateY(j*cos(ribbonRibs)*1.25);
    
    beginShape(LINE_STRIP);
    for (int i=0; i<ribbonLength*2 - ribbonSpeed; i+=ribbonSpeed){
      float fillColor = spectrumArray[i][2] * 2.0;
      stroke(0,fillColor/2.0,fillColor);
      point(0, spectrumArray[i][2], i*1.0 - 200);
      if(i == ribbonLength){
        point(0, spectrumArray[i][2] * 2.0, i*1.0 - 200);
        point(0, spectrumArray[i][2] * 3.0, i*1.0 - 200);
        point(0, spectrumArray[i][2] * 5.0, i*1.0 - 200);
        point(0, spectrumArray[i][2] * 8.0, i*1.0 - 200);
        point(0, spectrumArray[i][2] * 13.0, i*1.0 - 200);
        
      }
      //vertex(0, spectrumArray[i][2], i*2.0 - 200);
    }
    endShape();

    pop();
  }
  float mySize = spectrumArray[ribbonLength][2] * 1.0;
  image(myField,xSize/2 - (mySize/2.0), ySize/2 - (mySize/2.0), mySize, mySize);
}

  
void fuzzySphere2(){
  for (int j=0; j<ribbonRibs; j++){
    push();
    //rotateZ(j*(PI/(ribbonRibs*.5)));
    
    rotateX(j*sin(ribbonRibs));
    rotateZ(j*(TWO_PI/ribbonRibs));
    rotateY(j*cos(ribbonRibs)*1.25);
    
    beginShape(LINE_STRIP);
    for (int i=0; i<ribbonLength*2 - ribbonSpeed; i+=ribbonSpeed){
      float fillColor = signalArray[i][j] * 2.0;
      stroke(fillColor);
      point(0, signalArray[i][j], i*1.0 - 200);
      if(i == ribbonLength){
        point(0, signalArray[i][j] * 2.0, i*1.0 - 200);
        point(0, signalArray[i][j] * 3.0, i*1.0 - 200);
        point(0, signalArray[i][j] * 5.0, i*1.0 - 200);
        point(0, signalArray[i][j] * 8.0, i*1.0 - 200);
        point(0, signalArray[i][j] * 13.0, i*1.0 - 200);
        stroke(fillColor,0,0);
        line(0, signalArray[i][j] * 1.0, 0, 0, signalArray[i][j] * 0.2, 0);
      }
      //vertex(0, spectrumArray[i][2], i*2.0 - 200);
    }
    endShape();

    pop();
  }
}


void fuzzyRings(){

  for (int j=0; j<ribbonRibs; j++){
    push();
    rotateZ(j*(TWO_PI/ribbonRibs));

    beginShape(LINE_STRIP);
    for (int i=0; i<ribbonLength*2 - ribbonSpeed; i+=ribbonSpeed){
      float fillColor = spectrumArray[i][2] * 2.0;
      stroke(0 + fillColor/10.0);
      point(0, spectrumArray[i][2]-10.0, i*1.0 - 200);
      if(i == ribbonLength){
        point(0, spectrumArray[i][2] * 2.0, i*1.0 - 200);
        point(0, spectrumArray[i][2] * 3.0, i*1.0 - 200);
        point(0, spectrumArray[i][2] * 5.0, i*1.0 - 200);
        point(0, spectrumArray[i][2] * 8.0, i*1.0 - 200);
        point(0, spectrumArray[i][2] * 13.0, i*1.0 - 200);
        stroke(fillColor,0,0);
        line(0, spectrumArray[i][2] * 0.8, 0, 0, spectrumArray[i][2] * 0.9, 0);
      }

    }
    endShape();

    pop();
  }
}



void tube(){

  for (int j=0; j<ribbonRibs; j++){
    push();
    rotateZ(j*(TWO_PI/ribbonRibs));
    beginShape(QUAD_STRIP);
    for (int i=0; i<ribbonLength*2 - ribbonSpeed; i+=ribbonSpeed){
      noStroke();
      float fillColor = constrain(100 + (spectrumArray[i][2] - spectrumArray[i+ribbonSpeed][2])*3.0,100,255);
      fill(fillColor*2.0,fillColor*1.5,0);
      segmentWidth = (spectrumArray[i][2] / 20.0);
      if ((i/ribbonSpeed)%2 == 0){
        vertex(-segmentWidth, spectrumArray[i][2], i-200);
        vertex(segmentWidth, spectrumArray[i][2], i-200);
      } else {
        vertex(segmentWidth, spectrumArray[i][2], i-200);
        vertex(-segmentWidth, spectrumArray[i][2], i-200);
      }
    }

    endShape();
    stroke(255,255,255);
    point(0, spectrumArray[0][2], 0 - 200);
    point(0, spectrumArray[(ribbonLength*2 - ribbonSpeed*2)][2], (ribbonLength*2 - ribbonSpeed*2) - 200);
    noStroke();
    pop();
  }
}


void spirograph(){

  for (int j=0; j<ribbonRibs; j++){
    push();
    rotateY(j*(TWO_PI/ribbonRibs));
    beginShape(LINE_STRIP);
    for (int i=0; i<ribbonLength*2 - ribbonSpeed; i+=ribbonSpeed){
      noStroke();
      float fillColor = constrain((signalArray[i][2] - signalArray[i+ribbonSpeed][2])*3.0,100,255);
      stroke(255 - i,fillColor,i);
      segmentWidth = (signalArray[i][2] / 1.0) + 1;
      if ((i/ribbonSpeed)%2 == 0){
        vertex(-segmentWidth, signalArray[i][2], i*.5);
        vertex(segmentWidth, signalArray[i][2], i*.5);
      } else {
        vertex(segmentWidth, signalArray[i][2], i*.5);
        vertex(-segmentWidth, signalArray[i][2], i*.5);
      }
    }

    endShape();
    pop();
  }
}


void test(){

}

// translates the brightness into an alpha channel (code by Ryan Alexander of Motion Theory)
void brightToAlpha(BImage b){
  b.format = RGBA;
  for(int i=0; i < b.pixels.length; i++) {
    b.pixels[i] = color(255,255,255,255 - brightness(b.pixels[i]));
  }
}


//