// BoxFitter class
// David Bollinger, July 2006
// http://www.davebollinger.com
// for Processing 0115 beta
//

class BoxFitter {
  int wid, hei;
  int cols, rows;
  int col, row;
  int divx, divy;
  int maxsizer;
  int seed;
  // cells store the box fit pattern, contents are byte encoded as:
  // (cell >> 16) & 0xff == work to do
  // (cell) & 0xffff == size of allocated area
  int [][] cells;
  // the types of work that may occur in a cell
  static final int WORK_NONE = 0;
  static final int WORK_DONE = 1;
  BoxFitter(int _wid, int _hei, int _divx, int _divy, int _maxsizer) {
    wid = _wid;
    hei = _hei;
    // width AND height should be evenly divisible by divx/y
    divx = _divx;
    divy = _divy;
    maxsizer = _maxsizer; // largest box is (maxsizer * max(divx,divy)) pixels
    cols = wid / divx;
    rows = hei / divy;
    // sanity checks
    if (maxsizer*divx > wid) maxsizer = wid/divx;
    if (maxsizer*divy > hei) maxsizer = hei/divy;
    // further sanity check? hopefully not necessary:
    // if ((rows>0xffff)||(cols>0xffff)) then too big for current encoding
    // allocate
    cells = new int[rows][cols];
  }
  // reset the pattern grid
  void wipe() {
    for (int r=0; r<rows; r++)
      for (int c=0; c<cols; c++)
        cells[r][c] = 0; 
    col = row = 0;
  }
  // determines if cells already contain defined area(s)
  boolean isOccupied(int col, int row, int w, int h) {
    for (int r=row; r<row+h; r++) {
      for (int c=col; c<col+w; c++) {
        if (cells[r][c] != 0) {
          return true;
        }
      }
    }
    return false;
  }
  // marks cells as containing an area
  void doOccupy(int col, int row, int w, int h, int value) {
    for (int r=row; r<row+h; r++) {
      for (int c=col; c<col+w; c++) {
        cells[r][c] = value;
      }
    }
  }  
  // define the pattern grid
  void make(int s) {
    seed = s;
    randomSeed(seed);
    wipe();
    for (int r=0; r<rows; r++) {
      for (int c=0; c<cols; c++) {
        int cell = cells[r][c];
        if (cell != 0) continue;
        // figure out the size of area to occupy
        int sizer, limit;
        do {
          limit = min(cols-c, rows-r);
          limit = min(limit, maxsizer);
          sizer = int(random(limit))+1;
        } while(isOccupied(c,r,sizer,sizer));
        // flag all cells as occupied by width x height area
        doOccupy(c,r,sizer,sizer,sizer);
        // indicate work to perform in upper-left cell
        int work = WORK_DONE;
        cells[r][c] |= (work<<16);
      } // for c
    } // for r
  }
  // is cursor at 0,0
  boolean at00() {
    return ((col==0) && (row==0));
  }
  // step the cursor forward
  void advance(int advcol) {
    col += advcol;
    if (col >= cols) {
      col = 0;
      row++;
      if (row >= rows) {
        row = 0;
      }
    }
  }
  // this would typically be overridden
  void render(int x1, int y1, int w, int h) {
    float area = w * h;
    float maxarea = (maxsizer*divx) * (maxsizer*divy);
    float gray = 64.0 + (area / maxarea) * 128.0;
    fill(color(gray,gray,gray));
    rect(x1,y1,w,h);
  }
  // advance through the pattern and draw the next box
  void drawone() {
    boolean drawn = false;
    do {
      int cell = cells[row][col];
      int work = (cell>>16) & 0xff;
      int sizer = (cell) & 0xffff;
      if (work != WORK_NONE) {
        int y1 = row*divy;
        int x1 = col*divx;
        int w = sizer * divx;
        int h = sizer * divy;
        render(x1,y1,w,h);
        drawn = true;
      }
      advance(sizer);
      if (at00()) return;
    } while (!drawn);
  }
}