// Mondrian 3D (mon3drian) automatic generator
// (c) 2011 Bruno Bellamy - http://bellaminettes.com/goodies/mon3drian/
// Written with Processing - http://processing.org/
// As this program will obviously be extremely useful to all mankind,
// I release it under the GPL :)

// Maximum values
int windowSize = 480;
int boxNumMax = 65;
int maxBoxSize = 100;
int timerReset = 1000;
int maxCol = 6;
float minThickness = 0.6;
float maxThickness = 8;

// Boxes data tables
float[] boxCenterX = new float[boxNumMax];
float[] boxCenterY = new float[boxNumMax];
float[] boxCenterZ = new float[boxNumMax];

float[] boxMinX = new float[boxNumMax];
float[] boxMaxX = new float[boxNumMax];
float[] boxMinY = new float[boxNumMax];
float[] boxMaxY = new float[boxNumMax];
float[] boxMinZ = new float[boxNumMax];
float[] boxMaxZ = new float[boxNumMax];

boolean[] x0Comp = new boolean[boxNumMax];
boolean[] x1Comp = new boolean[boxNumMax];
boolean[] y0Comp = new boolean[boxNumMax];
boolean[] y1Comp = new boolean[boxNumMax];
boolean[] z0Comp = new boolean[boxNumMax];
boolean[] z1Comp = new boolean[boxNumMax];

boolean[] boxComp = new boolean[boxNumMax];

float[] boxGrowStep = new float[boxNumMax];

int[] boxRed = new int[boxNumMax];
int[] boxGreen = new int[boxNumMax];
int[] boxBlue = new int[boxNumMax];

// Initialising some global values
boolean move = true;
boolean wire = false;
boolean faceFill = true;
boolean keep = false;
boolean bevel = false;
float rx,ry;
float growStep = 4;
float bevelSize = 0.5;
int boxNum;
int boxAlpha;
int timer = 0;
int boxCounter;

// Colors palette
int[] rCol = new int[maxCol];
int[] vCol = new int[maxCol];
int[] bCol = new int[maxCol];

void setup(){
  size(640,640 ,P3D);

  rCol[0] = 0; vCol[0] = 0; bCol[0] = 0;        // Black
  rCol[1] = 255; vCol[1] = 0; bCol[1] = 0;      // Red
  rCol[2] = 255; vCol[2] = 255; bCol[2] = 0;    // Yellow
  rCol[3] = 0; vCol[3] = 0; bCol[3] = 255;      // Blue
  rCol[4] = 255; vCol[4] = 255; bCol[4] = 255;  // White
  // Other white (so that white has twice as many
  // chances as other colors to appear) :
  rCol[5] = 255; vCol[5] = 255; bCol[5] = 255;

  createMon3drian();
}

void draw(){
  if(move){
    int i=0;
    background(64,64,70);
    ambientLight(128,128,128);
    directionalLight(160,180,255,1,1,-1);
    
    camera(0.0, 0.0, 360.0, // eyeX, eyeY, eyeZ
           0.0, 0.0, 0.0, // centerX, centerY, centerZ
           0.0, 1.0, 0.0); // upX, upY, upZ
  
    pushMatrix();
        rotateX(rx);
        rotateY(ry);
        if (wire) spaceDisplay();
        for (i=0; i<boxNum; i++){
          growBox(i);
          if (boxComp[i]==false) i=boxNum;
        }
    popMatrix();
    rx+=.005;
    ry+=.008;
  
    // This increases opacity once all the boxes are done growing up
    if ((boxComp[boxNum-1]==true)&&(boxAlpha<255)) {
      boxAlpha++;
    }
    
    // This waits a while once growing up and full opacity are done
    // before creating a new mon3drian
    if (!keep) {  // ...if the 'keep' flag is off (which is the default case)
      if ((boxAlpha==255)&&(timer<timerReset)) {
        timer++;
        if (timer == timerReset){
          createMon3drian();
          timer = 0;
        }
      }
    }
  }
}

void keyPressed() {
  // if (keyPressed) {
    switch(key) {
      case ' ':  // Press SPACE to freeze (or restart) the mon3drian rotation
        move = ! move;
        break;
      case 'b':  // Press B to switch on/off bevel
        bevel = ! bevel;
        break;
      case 'f':  // Press F to switch on/off the hidden faces display
        faceFill = ! faceFill;
        if (!faceFill) bevel = false;
        break;
      case 'k':  // Press K to switch on/off new mon3drian creation after a while
        keep = ! keep;
        break;
      case 'n':  // Press N to generate a new mon3drian
        createMon3drian();
        break;
      case 'w':  // Press W to switch on/off the wireframe display
        wire = ! wire;
        if (wire) bevel = false;
        break;
    }
  // }
}

void createMon3drian() {
  // The generator part
  int i;
  createBoxZero();
  
  int subMax;
  subMax = int(random(1,(boxNumMax-1)/2));
  boxNum = (2*subMax)+1;
  boxAlpha = 32;
  boxCounter = 1;
  
  for (i=0; i<subMax; i++){
    boxDivide(i, boxCounter, boxCounter+1, int(random(0,3)), int(random(1,maxCol)), int(random(1,maxCol)));
  }
}

void createBoxZero() {
  // Mon3drian space boundaries
  boxCenterX[0] = 0;
  boxCenterY[0] = 0;
  boxCenterZ[0] = 0;
  boxMinX[0] = -maxBoxSize;
  boxMaxX[0] = maxBoxSize;
  boxMinY[0] = -maxBoxSize;
  boxMaxY[0] = maxBoxSize;
  boxMinZ[0] = -maxBoxSize;
  boxMaxZ[0] = maxBoxSize;
}

void boxDivide(int a, int b, int c, int dDim, int bColor, int cColor) {
  float subRange;
  float subVal;
  float t;
  float margin;
  
  t = random(minThickness, maxThickness);  // Black separator thickness
  margin = t * 2.5;

  switch (dDim){
    case 0:  // X subdivision
      subRange = boxMaxX[a] - boxMinX[a];
      if (subRange > (t*6)) {
        subVal = random(boxMinX[a]+margin,boxMaxX[a]-margin);
        boxMinX[b] = boxMinX[a];
        boxMaxX[b] = subVal-t;
        boxMinY[b] = boxMinY[a];
        boxMaxY[b] = boxMaxY[a];
        boxMinZ[b] = boxMinZ[a];
        boxMaxZ[b] = boxMaxZ[a];
        boxMinX[c] = subVal+t;
        boxMaxX[c] = boxMaxX[a];
        boxMinY[c] = boxMinY[a];
        boxMaxY[c] = boxMaxY[a];
        boxMinZ[c] = boxMinZ[a];
        boxMaxZ[c] = boxMaxZ[a];
        boxMinX[a] = subVal-t;
        boxMaxX[a] = subVal+t;
        initCenterCompCol(a, 0);
        initCenterCompCol(b, bColor);
        initCenterCompCol(c, cColor);
        boxCounter += 2;
      } else {
        initCenterCompCol(b, bColor);
        boxNum -= 2;
      }
      break;
    case 1:  // Y subdivision
      subRange = boxMaxY[a] - boxMinY[a];
      if (subRange > (t*6)) {
        subVal = random(boxMinY[a]+margin,boxMaxY[a]-margin);
        boxMinX[b] = boxMinX[a];
        boxMaxX[b] = boxMaxX[a];
        boxMinY[b] = boxMinY[a];
        boxMaxY[b] = subVal-t;
        boxMinZ[b] = boxMinZ[a];
        boxMaxZ[b] = boxMaxZ[a];
        boxMinX[c] = boxMinX[a];
        boxMaxX[c] = boxMaxX[a];
        boxMinY[c] = subVal+t;
        boxMaxY[c] = boxMaxY[a];
        boxMinZ[c] = boxMinZ[a];
        boxMaxZ[c] = boxMaxZ[a];
        boxMinY[a] = subVal-t;
        boxMaxY[a] = subVal+t;      
        initCenterCompCol(a, 0);
        initCenterCompCol(b, bColor);
        initCenterCompCol(c, cColor);
        boxCounter += 2;
      } else {
        initCenterCompCol(b, bColor);
        boxNum -= 2;
      }
      break;
    case 2:  // Z subdivision
      subRange = boxMaxZ[a] - boxMinZ[a];
      if (subRange > (t*6)) {
        subVal = random(boxMinZ[a]+margin,boxMaxZ[a]-margin);
        boxMinX[b] = boxMinX[a];
        boxMaxX[b] = boxMaxX[a];
        boxMinY[b] = boxMinY[a];
        boxMaxY[b] = boxMaxY[a];
        boxMinZ[b] = boxMinZ[a];
        boxMaxZ[b] = subVal-t;
        boxMinX[c] = boxMinX[a];
        boxMaxX[c] = boxMaxX[a];
        boxMinY[c] = boxMinY[a];
        boxMaxY[c] = boxMaxY[a];
        boxMinZ[c] = subVal+t;
        boxMaxZ[c] = boxMaxZ[a];
        boxMinZ[a] = subVal-t;
        boxMaxZ[a] = subVal+t;
        initCenterCompCol(a, 0);
        initCenterCompCol(b, bColor);
        initCenterCompCol(c, cColor);
        boxCounter += 2;
      } else {
        initCenterCompCol(b, bColor);
        boxNum -= 2;
      }
      break;
  }
}

void initCenterCompCol(int n, int c) {
  // Default initialisation of values
  // useful to animate box growth from its center
  boxCenterX[n] = boxMinX[n]+((boxMaxX[n]-boxMinX[n])/2);
  boxCenterY[n] = boxMinY[n]+((boxMaxY[n]-boxMinY[n])/2);
  boxCenterZ[n] = boxMinZ[n]+((boxMaxZ[n]-boxMinZ[n])/2);
  boxGrowStep[n]=0;
  x0Comp[n] = false;
  x1Comp[n] = false;
  y0Comp[n] = false;
  y1Comp[n] = false;
  z0Comp[n] = false;
  z1Comp[n] = false;
  boxComp[n] = false;

  // ...and its color :
  boxRed[n] = rCol[c];
  boxGreen[n] = vCol[c];
  boxBlue[n] = bCol[c];
}

void drawBox(float x0, float y0, float z0, float x1, float y1, float z1, int r, int v, int b, int a){
  if (!bevel) { // If bevel OFF (default)
    // If we want to have hidden faces or not (default is YES)
    if (faceFill) {
      fill(r,v,b,a);
    } else {
      noFill();
      wire = true;  // If not, then wireframe is forced to on
    }
  
    // If we want to have wireframe outline or not (default is NO)
    if (wire) {
      stroke(r,v,b);
    } else {
      noStroke();
    }
    
    beginShape(QUADS);
      vertex(x0, y0, z0);
      vertex(x1, y0, z0);
      vertex(x1, y1, z0);
      vertex(x0, y1, z0);
  
      vertex(x0, y0, z1);
      vertex(x1, y0, z1);
      vertex(x1, y1, z1);
      vertex(x0, y1, z1);
  
      vertex(x0, y0, z0);
      vertex(x1, y0, z0);
      vertex(x1, y0, z1);
      vertex(x0, y0, z1);
      
      vertex(x0, y1, z0);
      vertex(x1, y1, z0);
      vertex(x1, y1, z1);
      vertex(x0, y1, z1);
      
      vertex(x0, y0, z0);
      vertex(x0, y1, z0);
      vertex(x0, y1, z1);
      vertex(x0, y0, z1);
  
      vertex(x1, y0, z0);
      vertex(x1, y1, z0);
      vertex(x1, y1, z1);
      vertex(x1, y0, z1);
    endShape();
  } else { // If bevel ON
    noStroke();
    fill(r,v,b,a);
    
    float bev = bevelSize;
    
    x0 += bev;
    x1 -= bev;
    y0 += bev;
    y1 -= bev;
    z0 += bev;
    z1 -= bev;

    beginShape(QUADS);
      vertex(x0+bev,y0+bev,z0-bev);
      vertex(x1-bev,y0+bev,z0-bev);
      vertex(x1-bev,y1-bev,z0-bev);
      vertex(x0+bev,y1-bev,z0-bev);

      vertex(x0+bev,y0+bev,z1+bev);
      vertex(x1-bev,y0+bev,z1+bev);
      vertex(x1-bev,y1-bev,z1+bev);
      vertex(x0+bev,y1-bev,z1+bev);

      vertex(x0+bev,y0-bev,z0+bev);
      vertex(x1-bev,y0-bev,z0+bev);
      vertex(x1-bev,y0-bev,z1-bev);
      vertex(x0+bev,y0-bev,z1-bev);

      vertex(x0+bev,y1+bev,z0+bev);
      vertex(x1-bev,y1+bev,z0+bev);
      vertex(x1-bev,y1+bev,z1-bev);
      vertex(x0+bev,y1+bev,z1-bev);

      vertex(x0-bev,y0+bev,z0+bev);
      vertex(x0-bev,y1-bev,z0+bev);
      vertex(x0-bev,y1-bev,z1-bev);
      vertex(x0-bev,y0+bev,z1-bev);

      vertex(x1+bev,y0+bev,z0+bev);
      vertex(x1+bev,y1-bev,z0+bev);
      vertex(x1+bev,y1-bev,z1-bev);
      vertex(x1+bev,y0+bev,z1-bev);
    endShape();
    
    beginShape(QUADS);
      vertex(x0+bev,y0+bev,z0-bev);
      vertex(x1-bev,y0+bev,z0-bev);
      vertex(x1-bev,y0-bev,z0+bev);
      vertex(x0+bev,y0-bev,z0+bev);

      vertex(x0+bev,y1-bev,z0-bev);
      vertex(x1-bev,y1-bev,z0-bev);
      vertex(x1-bev,y1+bev,z0+bev);
      vertex(x0+bev,y1+bev,z0+bev);

      vertex(x0+bev,y0-bev,z1-bev);
      vertex(x1-bev,y0-bev,z1-bev);
      vertex(x1-bev,y0+bev,z1+bev);
      vertex(x0+bev,y0+bev,z1+bev);

      vertex(x0+bev,y1-bev,z1+bev);
      vertex(x1-bev,y1-bev,z1+bev);
      vertex(x1-bev,y1+bev,z1-bev);
      vertex(x0+bev,y1+bev,z1-bev);

      vertex(x0+bev,y0-bev,z0+bev);
      vertex(x0-bev,y0+bev,z0+bev);
      vertex(x0-bev,y0+bev,z1-bev);
      vertex(x0+bev,y0-bev,z1-bev);

      vertex(x0+bev,y1+bev,z0+bev);
      vertex(x0-bev,y1-bev,z0+bev);
      vertex(x0-bev,y1-bev,z1-bev);
      vertex(x0+bev,y1+bev,z1-bev);

      vertex(x1-bev,y0-bev,z0+bev);
      vertex(x1+bev,y0+bev,z0+bev);
      vertex(x1+bev,y0+bev,z1-bev);
      vertex(x1-bev,y0-bev,z1-bev);

      vertex(x1-bev,y1+bev,z0+bev);
      vertex(x1+bev,y1-bev,z0+bev);
      vertex(x1+bev,y1-bev,z1-bev);
      vertex(x1-bev,y1+bev,z1-bev);

      vertex(x0+bev,y0+bev,z0-bev);
      vertex(x0+bev,y1-bev,z0-bev);
      vertex(x0-bev,y1-bev,z0+bev);
      vertex(x0-bev,y0+bev,z0+bev);

      vertex(x1-bev,y0+bev,z0-bev);
      vertex(x1-bev,y1-bev,z0-bev);
      vertex(x1+bev,y1-bev,z0+bev);
      vertex(x1+bev,y0+bev,z0+bev);

      vertex(x0+bev,y0+bev,z1+bev);
      vertex(x0+bev,y1-bev,z1+bev);
      vertex(x0-bev,y1-bev,z1-bev);
      vertex(x0-bev,y0+bev,z1-bev);

      vertex(x1-bev,y0+bev,z1+bev);
      vertex(x1-bev,y1-bev,z1+bev);
      vertex(x1+bev,y1-bev,z1-bev);
      vertex(x1+bev,y0+bev,z1-bev);
    endShape();

    beginShape(TRIANGLES);
      vertex(x0+bev,y0+bev,z0-bev);
      vertex(x0-bev,y0+bev,z0+bev);
      vertex(x0+bev,y0-bev,z0+bev);

      vertex(x1-bev,y0+bev,z0-bev);
      vertex(x1+bev,y0+bev,z0+bev);
      vertex(x1-bev,y0-bev,z0+bev);

      vertex(x0+bev,y1-bev,z0-bev);
      vertex(x0-bev,y1-bev,z0+bev);
      vertex(x0+bev,y1+bev,z0+bev);

      vertex(x1-bev,y1-bev,z0-bev);
      vertex(x1+bev,y1-bev,z0+bev);
      vertex(x1-bev,y1+bev,z0+bev);

      vertex(x0+bev,y0-bev,z1-bev);
      vertex(x0+bev,y0+bev,z1+bev);
      vertex(x0-bev,y0+bev,z1-bev);

      vertex(x1-bev,y0-bev,z1-bev);
      vertex(x1-bev,y0+bev,z1+bev);
      vertex(x1+bev,y0+bev,z1-bev);

      vertex(x0+bev,y1+bev,z1-bev);
      vertex(x0+bev,y1-bev,z1+bev);
      vertex(x0-bev,y1-bev,z1-bev);

      vertex(x1-bev,y1+bev,z1-bev);
      vertex(x1-bev,y1-bev,z1+bev);
      vertex(x1+bev,y1-bev,z1-bev);
    endShape();
  }
}

void growBox(int b){
  float x0,y0,z0,x1,y1,z1;
  
  if (boxComp[b]==false) {
    boxGrowStep[b] += growStep;
  
    if (x0Comp[b]==false) {
      x0 = boxCenterX[b] - boxGrowStep[b];
      if (x0 < boxMinX[b]) {
        x0 = boxMinX[b];
        x0Comp[b] = true;
      }
    } else {
      x0 = boxMinX[b];
    }
    if (x1Comp[b]==false) {
      x1 = boxCenterX[b] + boxGrowStep[b];
      if (x1 > boxMaxX[b]) {
        x1 = boxMaxX[b];
        x1Comp[b] = true;
      }
    } else {
      x1 = boxMaxX[b];
    }
    if (y0Comp[b]==false) {
      y0 = boxCenterY[b] - boxGrowStep[b];
      if (y0 < boxMinY[b]) {
        y0 = boxMinY[b];
        y0Comp[b] = true;
      }
    } else {
      y0 = boxMinY[b];
    }
    if (y1Comp[b]==false) {
      y1 = boxCenterY[b] + boxGrowStep[b];
      if (y1 > boxMaxY[b]) {
        y1 = boxMaxY[b];
        y1Comp[b] = true;
      }
    } else {
      y1 = boxMaxY[b];
    }
    if (z0Comp[b]==false) {
      z0 = boxCenterZ[b] - boxGrowStep[b];
      if (z0 < boxMinZ[b]) {
        z0 = boxMinZ[b];
        z0Comp[b] = true;
      }
    } else {
      z0 = boxMinZ[b];
    }
    if (z1Comp[b]==false) {
      z1 = boxCenterZ[b] + boxGrowStep[b];
      if (z1 > boxMaxZ[b]) {
        z1 = boxMaxZ[b];
        z1Comp[b] = true;
      }
    } else {
      z1 = boxMaxZ[b];
    }
  
    if ((x0Comp[b]==true)&&(x1Comp[b]==true)&&(y0Comp[b]==true)&&(y1Comp[b]==true)&&(z0Comp[b]==true)&&(z1Comp[b]==true)) {
      boxComp[b]=true;
    }
  } else {
    x0=boxMinX[b];
    x1=boxMaxX[b];
    y0=boxMinY[b];
    y1=boxMaxY[b];
    z0=boxMinZ[b];
    z1=boxMaxZ[b];
  }
  drawBox(x0,y0,z0,x1,y1,z1,boxRed[b],boxGreen[b],boxBlue[b],boxAlpha);
}

void spaceDisplay() {
  // In case we want to see the
  // mon3drian space boundaries
  stroke(255,8);
  noFill();
  box(maxBoxSize*2);
  noStroke();
}