float xmag, ymag = 0;
float newXmag, newYmag = 0; 

int counter = 0;

int spacing = 10;
int xMax = 40;
int yMax = 40;
int zMax = 40;
int totalDots = xMax*yMax*zMax;

Dot[] dot;
Meanderer meanderer;
Meanderer rotateMeander;

void setup(){ 
  size(400, 400); 
  background(35);
  meanderer = new Meanderer();
  rotateMeander = new Meanderer();

  dot = new Dot[totalDots];
  for (int z=0; z<zMax; z++){
    for (int y=0; y<yMax; y++){
      for (int x=0; x<xMax; x++){
        dot[(x*1600) + (y*40) + z] = new Dot(x,y,z);
      }
    }
  }
} 
 
void loop(){
  
  push();
  translate(width/2, height/2, 50); 
  
  newXmag = mouseX/float(width) * TWO_PI;
  newYmag = mouseY/float(height) * TWO_PI;
  
  float diff = xmag-newXmag;
  if (abs(diff) >  0.01) { xmag -= diff/4.0; }
  
  diff = ymag-newYmag;
  if (abs(diff) >  0.01) { ymag -= diff/4.0; }
  
  rotateX(-ymag); 
  rotateY(-xmag);

  fill(100,100,70);
  noStroke();
  //box(75);
  
  meanderer.move();
  rotateMeander.move();
  
  for (int z=0; z<zMax; z++){
    for (int y=0; y<yMax; y++){
      for (int x=0; x<xMax; x++){
        dot[(x*1600) + (y*40) + z].render();
      }
    }
  }
  pop();
}


class Dot{
  int xIndex, yIndex, zIndex;
  float xPos, yPos, zPos;
  float xDelta, yDelta, zDelta;
  float xyDist, distance;
  float boxSize, oldBoxSize;
  float colorVar, colorVar2;
  int identity;

  Dot(int xVar, int yVar, int zVar){
    xIndex = xVar;
    yIndex = yVar;
    zIndex = zVar;
  }

  void render(){    
    xPos = (xIndex - (xMax/2) + 0.5f) * spacing;
    yPos = (yIndex - (yMax/2) + 0.5f) * spacing;
    zPos = (zIndex - (zMax/2) + 0.5f) * spacing;
    
    findDistance(xPos, yPos, zPos);
    
    boxSize = (20 - (distance/2));
    if (boxSize > oldBoxSize){
      push();
      translate(xPos, yPos, zPos);
      colorVar = 255 - (boxSize * 5);
      colorVar2 = 255 - (boxSize * 7);
      if (boxSize < 3){
        fill(255,255,100);
        box(boxSize);
      } else if (boxSize > 13){

      } else {
        fill(colorVar, colorVar2, colorVar2 * 0.5f);
        box(boxSize);
      }
      
      pop();
      oldBoxSize = boxSize;
    } else if (oldBoxSize > 1){
      push();
      translate(xPos, yPos, zPos);
      colorVar -= 3;
      colorVar2 -= 6;
      if (oldBoxSize > 13){
        fill(0);
      } else {
        fill(colorVar, colorVar2, colorVar2 * 0.5f);
        box(oldBoxSize);
      }
      
      pop();
      oldBoxSize -= 0.3f;
    } else {
      oldBoxSize = 0;
      boxSize = 0;
    }
  }
  float newX, newY;
  
  void findDistance(float x, float y, float z){
    newX -= (newX - mouseX) * 0.2f;
    newY -= (newY - mouseY) * 0.2f;
    
    xDelta = x - meanderer.x;
    yDelta = y - meanderer.y;
    zDelta = z - meanderer.z;
    
    xyDist = sqrt(sq(xDelta) + sq(yDelta));
    distance = sqrt(sq(xyDist) + sq(zDelta));
  }
}


class Meanderer
{
  float x = 0;
  float y = 0;
  float z = 0;

  float xVel = random(-4.0f, 4.0f);
  float yVel = random(-4.0f, 4.0f);
  float zVel = random(-4.0f, 4.0f);

  float left, right, top, bottom, back, front;
  float xDelta, yDelta, zDelta;
  float dimension = spacing * 8;
  
  float xMax = 6;
  float yMax = 6;
  float zMax = 6;
  
  float boundary = 50;
  int identity;

  Meanderer(){}

  void move(){
    left = -dimension;
    right = dimension;
    top = -dimension;
    bottom = dimension;
    back = -dimension;
    front = dimension;

    findXLimits(x, left, right);
    findYLimits(y, top, bottom);
    findZLimits(z, back, front);
    
    x += xVel;
    y += yVel;
    z += zVel;
  }
  
  void findXLimits(float xPos, float lower, float upper){
    if (xPos < lower){
      xDelta = random(0.0f, 1.0f);
    } else if (xPos > upper){
      xDelta = random(-1.0f, 0.0f);
    } else {
      xDelta = random(0.0f, 1.0f) - random(0.0f, 1.0f);
    }
    
    xVel += xDelta;
    xVel = constrain(xVel, -xMax, xMax);
  }
  
  void findYLimits(float yPos, float lower, float upper){
    if (yPos < lower){
      yDelta = random(0.0f, 1.0f);
    } else if (yPos > upper){
      yDelta = random(-1.0f, 0.0f);
    } else {
      yDelta = random(0.0f, 1.0f) - random(0.0f, 1.0f);
    }

    yVel += yDelta;
    yVel = constrain(yVel, -yMax, yMax);
  }
  
  void findZLimits(float zPos, float lower, float upper){
    if (zPos < lower){
      zDelta = random(0.0f, 1.0f);
    } else if (zPos > upper){
      zDelta = random(-1.0f, 0.0f);
    } else {
      zDelta = random(0.0f, 1.0f) - random(0.0f, 1.0f);
    }

    zVel += zDelta;
    zVel = constrain(zVel, -zMax, zMax);
  }


  float zVar;
}