float xmag, ymag = 0;
float newXmag, newYmag = 0; 
 
int spacing = 25;
int xMax = 10;
int yMax = 10;
int zMax = 10;
int totalDots = xMax*yMax*zMax;

Dot[] dot;
Meanderer meanderer;

void setup(){ 
  size(400, 400); 
  background(51);
  meanderer = 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*100) + (y*10) + z] = new Dot(x,y,z);
      }
    }
  }
} 
 
void loop(){
  
  push();
  translate(width/2, height/2, 0); 

  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); 
  meanderer.move();
  for (int z=0; z<zMax; z++){
    for (int y=0; y<yMax; y++){
      for (int x=0; x<xMax; x++){
        dot[(x*100) + (y*10) + z].render();
      }
    }
  }
  pop(); 

}


class Dot{
  int xIndex, yIndex, zIndex;
  float xPos, yPos, zPos;
  float xDelta, yDelta, zDelta;
  float xyDist, yzDist;
  
  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);
    
    if (yzDist < (spacing * 3)){
      noStroke();
      fill(255 - (yzDist * 10));
      push();
      translate(xPos, yPos, zPos);
      box((spacing * 3) - (yzDist));
      pop();
    } else {
      stroke(0);
      point(xPos, yPos, zPos);
    }
  }
  
  void findDistance(float x, float y, float z){
    xDelta = x - meanderer.x;
    yDelta = y - meanderer.y;
    zDelta = z - meanderer.z;
    
    xyDist = sqrt(sq(xDelta) + sq(yDelta));
    yzDist = sqrt(sq(xyDist) + sq(zDelta));
  }
}


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

  float xVel, yVel, zVel;

  float left, right, top, bottom, back, front;
  float xDelta, yDelta, zDelta;
  float dimension = spacing * 4;
  
  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;
}