import processing.opengl.*;

import toxi.geom.*;
import toxi.math.*;

int RESX=15;
int RESY=35;
int RESZ=15;

float noiseScaleX=3f/RESX;
float noiseScaleY=3f/RESY;
float noiseScaleZ=3f/RESZ;
int depth;
float tres;

Grid grid;
Grid newGrid;
Grid oldGrid;

int state;

float angleX,angleY;
int waitCounter;
int morphCounter;


void setup(){
  size(800,800,OPENGL);
  depth=width;
  background(255);
  hint(ENABLE_OPENGL_4X_SMOOTH);
  frameRate(20);
  angleX=angleY=0f;
  tres=0f;
  grid = populateGrid();
  oldGrid = grid.copy();
  newGrid = populateGrid();
  state=0;
}


void draw(){
  background(120);
  angleX=0.8f*angleX+0.2f*(mouseY-200)*HALF_PI/200;
  angleY=0.8f*angleY+0.2f*(mouseX-200)*HALF_PI/200;
  lights();
  translate(width/2f,height/2.2f,-.8f*depth);
  rotateY(angleY);
  //rotateX(angleX);
  noStroke();
  fill(255);
  grid.draw(width/RESX,1.4f*height/RESY,depth/RESZ,tres+0.1f);
  noFill();
  stroke(255,200,200,30);
  grid.draw(width/RESX,1.4f*height/RESY,depth/RESZ,0.1f);

  // shrinking
  if(state==0){
    tres+=0.005f;
    if (tres>=1.0f){
      state=1;
      tres=1.0f;
      waitCounter=0;       
    }
  }
  // wait
  if(state==1){
    waitCounter++;
    if(waitCounter==20){
      state=2;
      morphCounter=0;   
      oldGrid=grid.copy();
      newGrid=populateGrid();
    }
  }  
  // growing + morphing
  if(state==2){
    morphCounter++;
    for(int i=0;i<RESX+1;i++){
      for(int j=0;j<RESY+1;j++){
        for(int k=0;k<RESZ+1;k++){
          grid.values[i][j][k]=(1f-0.005f*morphCounter)*oldGrid.values[i][j][k]+0.005f*morphCounter*newGrid.values[i][j][k];
        }
      }
    }
    tres-=0.005f;
    if (morphCounter==200){
      state=3;
      waitCounter=0;
      tres=0f;
    }
  }  
  // wait
  if(state==3){
    waitCounter++;
    if(waitCounter==50){
      state=0;     
    }
  }
}

Grid populateGrid(){
  Grid grid = new Grid(RESX,RESY,RESZ);
  int rmax =15;
  noiseSeed((long)random(2147483647));       
  for(int i=0;i<RESX+1;i++){
    for(int j=0;j<RESY+1;j++){
      for(int k=0;k<RESZ+1;k++){      
        grid.values[i][j][k]=-1f;
        if(j==RESY) grid.values[i][j][k]=2f;
      }
    }
  }  
  for(int r=0;r<rmax;r++){  
    int pol=1;
    int li = constrain((int)random(RESX),1,RESX-3);
    int lj = constrain((int)random(RESY),1,RESY-3);
    int lk = constrain((int)random(RESZ),1,RESZ-3);
    int ui = constrain((int)random(3,RESX-1-li),3,RESX-1-li);
    int uj = constrain((int)random(3,RESY-1-lj),3,RESY-1-lj);
    int uk = constrain((int)random(3,RESZ-1-lk),3,RESZ-1-lk);
    for(int i=0;i<ui;i++){
      for(int j=0;j<uj;j++){
        for(int k=0;k<uk;k++){
          float v=noise((i+li)*noiseScaleX,(j+lj)*noiseScaleY,(k+lk)*noiseScaleZ);         
          //if((i==0)||(i==ui-1)||(j==0)||(j==uj-1)||(k==0)||(k==uk-1)) v=0f;
          grid.values[i+li][j+lj][k+lk]=pol*v;
        }
      }
    }
    pol*=-1;
  }
  


  return grid;
}



void keyPressed(){
  grid = populateGrid();
  tres=0f;
  state=0;
}

class Grid{
  float[][][] values;
  int RESX;
  int RESY;
  int RESZ;
  int HALFRESX;
  int HALFRESY;
  int HALFRESZ;

  Grid(int RESX, int RESY, int RESZ){
    values=new float[RESX+1][RESY+1][RESZ+1];
    this.RESX=RESX;
    this.RESY=RESY;
    this.RESZ=RESZ;
    this.HALFRESX=RESX/2;
    this.HALFRESY=RESY/2;
    this.HALFRESZ=RESZ/2;   
  }

  void draw(float sx, float sy, float sz,float tres){
    Cube cube;
    cube = new Cube();
    float v1,v2,v3,v4,v5,v6,v7,v8;
    for(int i=0;i<RESX;i++){
      for(int j=0;j<RESY;j++){
        for(int k=0;k<RESZ;k++){      
          v1=values[i][j][k];
          v2=values[i+1][j][k];
          v3=values[i+1][j][k+1];
          v4=values[i][j][k+1];
          v5=values[i][j+1][k];
          v6=values[i+1][j+1][k];
          v7=values[i+1][j+1][k+1];
          v8=values[i][j+1][k+1];
          cube.set(v1,v2,v3,v4,v5,v6,v7,v8,(i-HALFRESX)*sx,(j-HALFRESY)*sy,(k-HALFRESZ)*sz,sx,sy,sz,tres);
          cube.draw(true);  
        }
      }
    }
  }

  Grid copy(){
    Grid result = new Grid (RESX,RESY,RESZ);
    for(int i=0;i<RESX+1;i++){
      for(int j=0;j<RESY+1;j++){
        for(int k=0;k<RESZ+1;k++){      
          result.values[i][j][k]=values[i][j][k];

        }
      }
    }
    return result;
  }
}