// This is a template for creating a looping animation in Processing. 
// When you press a key, this program will export a series of images
// into an "output" directory located in its sketch folder. 
// These can then be combined into an animated GIF. 
// Prof. Golan Levin, January 2014 - CMU IACD
 
//===================================================
// Global variables. 
 
int     nFramesInLoop = 10; // for lenticular export, change this to 10!
int     nElapsedFrames;
boolean bRecording;
int bulbColor = 255;
int baseColor = 50;//120; //fill of bulb base
int bkgd = 50;
int sze = 1500;
String  myName = "chanamon";
int j = 0;
 
//cycling through images derived from http://www.openprocessing.org/sketch/96680
int maxImages = 10; // Total # of images == nframesinloop
int imageIndex = 0; // Initial image to be displayed is the first
PImage[] glow_images = new PImage[maxImages]; //for glow sequence images
 
//===================================================
void setup() {
  size (sze, sze);
 
  for (int i = 0; i < glow_images.length; i++){
    glow_images[i] = loadImage("glows" +  nf(i,2)  + ".png");
  }
 
  bRecording = false;
  nElapsedFrames = 0;
  frameRate (nFramesInLoop); 
}
//===================================================
void keyPressed() { 
  // Press a key to export frames to the output folder
  bRecording = true;
  nElapsedFrames = 0;
}
 
//===================================================
void draw() {
 
  // Compute a percentage (0...1) representing where we are in the loop.
  float percentCompleteFraction = 0; 
  if (bRecording) {
    percentCompleteFraction = (float) nElapsedFrames / (float)nFramesInLoop;
  } 
  else {
    float modFrame = (float) (frameCount % nFramesInLoop);
    percentCompleteFraction = modFrame / (float)nFramesInLoop;
  }
 
  // Render the design, based on that percentage. 
  renderInner (percentCompleteFraction);
 
  // If we're recording the output, save the frame to a file. 
  if (bRecording) {
    saveFrame("output/"+ myName + "-loop-" + nf(nElapsedFrames, 4) + ".png");
    nElapsedFrames++; 
    if (nElapsedFrames == nFramesInLoop) {
      bRecording = false;
    }
  }
 
  //change current
  j+=2;
  if (j == nFramesInLoop){
    j = 0;
  }
}
 
//===================================================
void renderInner (float percent) {
  background(bkgd);
  int r = sze/5; //radius
  int d = r*2; //diameter
  int sx = sze/2 - r; //mock origin x
  int sy = 65*3; //mock origin y
 
  imageMode(CENTER);
  image(glow_images[imageIndex],750,750);
  imageIndex = (imageIndex + 1) % glow_images.length;
 
  //bulb
  noFill();
  smooth();
  stroke(bulbColor);
  strokeWeight(15);
  bezier(sx,sy+r, sx,sy+r, sx,sy, sx+r,sy); //left top of circle
  bezier(sx+r,sy, sx+r,sy, sx+d,sy, sx+d,sy+r); //right top of circle
  bezier(sx,sy+r, sx,sy+1.8*r, sx+r/2,sy+1.6*r, sx+.6*r,sy+2.7*r); //bottom left of circle
  bezier(sx+d,sy+r, sx+d,sy+1.8*r, sx+.75*d,sy+1.6*r, sx+d-.6*r,sy+2.7*r); //bottom right circle
  bezier(sx+.6*r,sy+2.7*r, sx+.6*r,sy+2.7*r, sx+.6*r,sy+2.9*r, sx+.8*r,sy+2.9*r); //bottom left curve
  bezier(sx+d-.6*r,sy+2.7*r, sx+d-.6*r,sy+2.7*r, sx+d-.6*r,sy+2.9*r, sx+d-.8*r,sy+2.9*r); //bottom right curve
 
  //threading
  strokeWeight(12);
  fill(baseColor);
  rect(sx+.75*r, sy+3.2*r, r/2, r/2, 95); //bottom round
  rect(sx+.6*r,sy+2.9*r, .8*r, r/3, 25); //first block
  rect(sx+.65*r,sy+3.24*r, .7*r, r/8, 7); //second block
  rect(sx+.7*r,sy+3.37*r, .6*r, r/8, 7); //third block
 
  //wires
  strokeWeight(3.5*3);
  noFill();
  smooth();
  bezier(sx+.9*r,sy+2.9*r, sx+r,sy+1.4*r, sx+r/2,sy+1.8*r, sx+r/2,sy+1.3*r); //left wire
  bezier(sx+d-.9*r,sy+2.9*r, sx+d-r,sy+1.4*r, sx+d-r/2,sy+1.8*r, sx+d-r/2,sy+1.3*r); //right wire
  strokeWeight(8);
  ellipse(sx+r/2,sy+1.3*r, r/10, r/10);
  ellipse(sx+d-r/2,sy+1.3*r, r/10, r/10);
 
  //electricity
  strokeWeight(2.5*3);
  int l = 10*3; //length of electricity segments
  for (int i=0; i < 10; i++){
    line(sx+r/2+(i*l),sy+1.3*r, sx+r/2+(i+1)*l,sy+1.3*r-l);
    line(sx+r/2+(i+1)*l,sy+1.3*r-l, sx+r/2+(i+2)*l, sy+1.3*r);
    i++;
  }
 
  //current - changes with time
  strokeWeight(15);
  stroke(252,210,65);
  line(sx+r/2+(j*l),sy+1.3*r, sx+r/2+(j+1)*l,sy+1.3*r-l);
  line(sx+r/2+(j+1)*l,sy+1.3*r-l, sx+r/2+(j+2)*l, sy+1.3*r);
 
}