/*           oooo               oooo     oo    oo
            ooooooo   oooo    ooooooo     oo  oo
           ooo  oooo ooooooo oooo  ooo     ooooo
           oo    oooooo  ooooooo    oo      ooo
           ooo   ooooo     oooooo  ooo      ooooo
            ooooooooooo   ooo ooooooo      oo  oooo
              oooooo ooooooo   oooo    o   oo    oo
                 ooo   oooo
  --( Guillaume  ooo  LaBelle )--       goo.x@gmx.de
          oo     oo
          ooo   ooo
          oooooooo
            oooo

------------------------------------------------------------
------------------------------------------------------------
--( TakyScreen )--
------------------------------------------------------------
  GRCAO - Université de Montréal [UDM]
  Laboratoire de Recherche Nxi Gestatio-HEXAGRAM [UQAM]
  Architecture et Robotique - Québec - CANADA [2003]

*/

int Seq = 10;
int aSeq = 0; //Sequence actuelle
BImage[] a = new BImage[Seq];
int w = 29;      //WIDTH of Bitmap
int h = 9;       //HEIGHT of Bitmap
int[][][] aPixels = new int[w][h][Seq];
pixSpring[][] pix = new pixSpring[w][h];

int bmpScale=10;
int bmpCadre=50;
float pixScale=0.8;
HScrollbar hsPixScale = new HScrollbar(bmpCadre, (h+1)*bmpScale+bmpCadre*2-15, (w+1)*bmpScale+bmpCadre*2-2*bmpCadre, 5, 3*5+1, pixScale, 0,2);
HScrollbar hsSpeed = new HScrollbar(bmpCadre, (h+1)*bmpScale+bmpCadre*2-5, (w+1)*bmpScale+bmpCadre*2-2*bmpCadre, 5, 3*5+1, 100, 1,200);

int global = 200;

void loadBMP()
{
  String[] fileName = new String[3];
  fileName[0] = "PanoBmp";
  fileName[2] = "b.gif";

  for (int i=0; i<Seq; i++)
  {
    fileName[1] = nf(i, 2);
    String loadBMP = join(fileName,"");
    a[i] = loadImage(loadBMP);
  }
}

void setup()
{
  size((w+1)*bmpScale+bmpCadre*2, (h+1)*bmpScale+bmpCadre*2);
  fill(global);

  ellipseMode(CENTER_DIAMETER);
  framerate(30);
  //smooth();

  loadBMP();
  initTabloid();
  swapTabloid();
}

void loop()
{
  background(255);
  
  hsPixScale.update();
  hsPixScale.draw();
  pixScale = hsPixScale.getPos();
 
  hsSpeed.update();
  hsSpeed.draw(); 
  stateNorm = int(hsSpeed.getPos());
 
  //drawLines ();
  drawPix(); 
  State();
}


int stateNorm = 100;
int state = stateNorm;

void State()
{
  if (state>0) state--;  else {state=int(random(stateNorm));
                               if (aSeq++==Seq-1) aSeq=0; swapTabloid();
                               }
}

void initTabloid()
{
  for(int i=0; i<h; i++) {
    for(int j=0; j<w; j++) {
      pix[j][i] = new pixSpring(j,i);
    }
  }
}

void swapTabloid()
{
  for(int i=0; i<h; i++) {
    for(int j=0; j<w; j++) {
      pix[j][i].pixValue = brightness(a[aSeq].pixels[i*w+j]);
    }
  }
}

void drawLines ()
{
  stroke(global);
  noSmooth();
  for(int i=0; i<h; i++)
  line(  0,
         i*bmpScale+bmpScale+bmpCadre,
         (w+1)*bmpScale+bmpCadre*2,
         i*bmpScale+bmpScale+bmpCadre);
}

void drawPix()
{
  noStroke();
  fill(global);
  smooth();
  for(int i=0; i<h; i++) {
    for(int j=0; j<w; j++) {
      pix[j][i].update();
      pix[j][i].draw();
    }
  }
}

class pixSpring
{
  // Screen values
  int x, y;
  int xpos, ypos;
  float    pixValue=0;
  float aPixValue=0;
  float sizeCell;

  // Spring simulation constants
  float mass = 2;     // Mass
  float k = 0.2;      // Spring constant
  float damp = 0.92;  // Damping

  // Spring simulation variables
  //float pos = 20.0; // Position
  float vel = 0.0;   // Y Velocity
  float accel = 0;    // Acceleration
  float force = 0;    // Force

  // Constructor
  pixSpring(int xx, int yy)
  {
    x = xx;
    y = yy;
  }

  void update()
  {
    over();
    force = -k * (aPixValue - pixValue);        // f=-ky
    accel = force / mass;                       // Set the acceleration, f=ma == a=f/m
    vel = damp * (vel + accel);               // Set the velocity
    aPixValue = aPixValue + vel;               // Updated position
 
    xpos = x*bmpScale+bmpScale+bmpCadre;
    ypos = y*bmpScale+bmpScale+bmpCadre;
    sizeCell = bmpScale*pixScale*(1-aPixValue/255);
  }

  void draw()
  {
    
    if (sizeCell>0.1)
    {
      ellipse(xpos,
              ypos,
              sizeCell,
              sizeCell );  
    }
  }

  // Test to see if mouse is over this spring
  void over() {
    float disX = xpos - mouseX;
    float disY = ypos - mouseY;
    if(sqrt(sq(disX) + sq(disY)) < sizeCell )
      {aPixValue=500; vel=0.0; force=0; accel=0;}
  }
}


class HScrollbar
{
  int swidth, sheight;    // width and height of bar
  int xpos, ypos;         // x and y position of bar
  float spos, newspos;    // x position of slider
  int sposMin, sposMax;   // max and min values of slider
  int loose;              // how loose/heavy
  boolean over;           // is the mouse over the slider?
  boolean locked;
  float ratio;
  float value;
  float valueMAX;
  float valueMIN;

  HScrollbar (int xp, int yp, int sw, int sh, int l, float v, float MIN, float MAX) {
    swidth = sw;
    sheight = sh;
    int widthtoheight = sw - sh;
    ratio = (float)sw / (float)widthtoheight;
    xpos = xp;
    ypos = yp-sheight/2;
    //spos = xpos + swidth/2 - sheight/2;
    spos = (swidth*v)/(MAX-MIN);
    newspos = spos;
    sposMin = xpos;
    sposMax = xpos + swidth - sheight;
    loose = l;
    value = v;
    valueMAX = MAX;
    valueMIN = MIN;
  }

  void update() {
    if(over()) {
      over = true;
    } else {
      over = false;
    }
    if(mousePressed && over) {
      locked = true;
    }
    if(!mousePressed) {
      locked = false;
    }
    if(locked) {
      newspos = constrain(mouseX-sheight/2, sposMin, sposMax);
    }
    if(abs(newspos - spos) > 1) {
      spos = spos + (newspos-spos)/loose;
    }
  }

  int constrain(int val, int minv, int maxv) {
    return min(max(val, minv), maxv);
  }

  boolean over() {
    if(mouseX > xpos && mouseX < xpos+swidth &&
    mouseY > ypos && mouseY < ypos+sheight) {
      return true;
    } else {
      return false;
    }
  }

  void draw() {
    //fill(255);
    //rect(xpos, ypos, swidth, sheight);
    /*if(over || locked) {
      fill(153, 102, 0);
    } else {
      fill(102, 102, 102);
    }*/
    stroke(240);
    line(xpos, ypos+sheight/2, xpos+swidth, ypos+sheight/2);
    rect(spos, ypos, sheight, sheight);
  }

  float getPos() {
    // convert spos to be values between
    // 0 and the total width of the scrollbar
    return ((valueMAX-valueMIN)*(spos * ratio))/swidth;
  }
}