Noisy Future

// radius, x, y, z, limit, colorCode, maxIdeal orbitRadius, starting offset

// colorcode refers to the color combinitions I've made in point class

core core1 = new core(80, 640, 400, 0, 800, 1, 40, 150, PI);

core core2 = new core(60, 640, 400, 0, 500, 2, 20, 300, 0);

  // camera variables

float eye_x, eye_y, eye_z, centerX, centerY, centerZ, upX, upY, upZ;

    void setup() {

    size(1280, 800, P3D);

  background(0);

  camera(0, 0, 400/tan(PI*30.0/180), 0, 0, 0, 0, 1, 0);

    stroke(255);

    for (int i = 0; i < 16; i++) {

    core1.addShell(int(random(1, core1.limit)), 0, 0, 0);

  }

    for (int i = 0; i < 8; i++) {

    core2.addShell(int(random(1, core2.limit)), 0, 0, 0);

  }

}

  void draw() {

    background(0);

    eye_x = (width/6)*cos(frameCount*0.0007);

  eye_y = (width/6)*sin(frameCount*0.0007);

  eye_z = 0;

  centerX = width/2;

  centerY = height/2;

  centerZ = 0;

  upX = 0;

  upY = 1;

  upZ = 0;

    camera(eye_x, eye_y, eye_z, centerX , centerY, centerZ, upX, upY, upZ);

    strokeWeight(2);

  stroke(255);

    core1.render();

  core1.update();

    core2.render();

  core2.update();

      if (makeVideo == true) {

    saveFrame("_vidframe_#####.tiff");

    videoStart++;

    if (videoStart == videoFrames) {

      makeVideo = false;

    }

  }

}

  class core {

  // radius of the core sphere

  float radius;

  float x, y, z;

  // used to limit growth of shells and determine their color

  float limit;

  float ideal;

  float ideal_change_lower = -0.05;

  float ideal_change_upper = 0.05;

  float idealNoise;

  int colorCode;

  int maxIdeal;

  ArrayList shells = new ArrayList();

  // float theta = random(TWO_PI);

  float theta;

  int orbitRadius;

  boolean clockwise;

      // constructor

  core(float radius, float x, float y, float z, float limit, int colorCode, int maxIdeal, int orbitRadius, float offset) {

    this.x = x;

    this.y = y;

    this.z = z;

    this.radius = radius;

    this.limit = limit;

      this.colorCode = colorCode;

    this.maxIdeal = maxIdeal;

    // initial ideal number of shells

    this.ideal = random(1, maxIdeal);

    this.orbitRadius = orbitRadius;

    this.theta = offset;

  }

      void addShell(int shellRadius, float x, float y, float z) {

    shell s = new shell(shellRadius, x, y, z);

    shells.add(shells.size(), s);

    s.parentCore = this;

  }

    float orbitx;

  float orbity;

  float orbitz;

  float orbit_velocity = .0010;

  float orbit_rotx = .5;

  float orbit_roty = .25;

    void orbit() {

    orbitx = cos(theta) * orbitRadius;

    orbity = sin(theta) * orbitRadius;

      theta += orbit_velocity;

    }

    void render() {

      // this push is an issue

    pushMatrix();

      translate(x, y, z);

  //    scale(mouseX*1.0f/width*TWO_PI);

//    rotateY(mouseX*1.0f/width*TWO_PI);

//    rotateX(mouseY*1.0f/height*TWO_PI);

      noStroke();

    fill(0);

  //rotateY(frameCount*0.0005);

        rotateX(orbit_rotx);

    rotateY(orbit_roty);

      pushMatrix();

    translate(orbitx, orbity, z);

    sphere(radius);

    popMatrix();

        for (int i = 0; i < (shells.size()); i++) {

      shell s = (shell) shells.get(i);

      s.render();

    }

        popMatrix();

  }

    void update() {

      // update orbit values

        if (clicked == false) {

    orbit();

    }

          // update all the shells

    for (int i = 0; i < (shells.size()); i++) {

      shell s = (shell) shells.get(i);

      s.update();

          // if the shell has hit the core limit, destory it

      if (s.radius >= limit) {

          shells.remove(shells.indexOf(s));

        // addShell(1);

          // chance of adding new shell on old shell destroy

        if (random(10) >= 2) {

            addShell(1, orbitx, orbity, orbitz);

        }

      }

    }

      // if there aren't enough shells, add one

    if (shells.size() < ideal) {

      addShell(1, orbitx, orbity, orbitz);

    }

        // for whatever reason, ideal trends to zero on it's own, so when ideal gets to be very small,

    // give it a boost upwards for awhile

      if (ideal <= 2) {

      ideal_change_upper = 0.07;

    }

    if (ideal >= (maxIdeal - 2)) {

      ideal_change_upper = 0.04;

    }

      // map the change so it's very small between updates

    ideal += map(noise(idealNoise), 0, 1, -0.05, ideal_change_upper);

      // keep number of shells in check on the low end

    if (ideal <= 0) {

      // don't let it shrink below zero

      ideal = 0;

    }

    // keep number of shells in check on the high end

    if (ideal >= maxIdeal) {

      // don't let it grow above...

      ideal = maxIdeal;

    }

    idealNoise += 0.01;

  }

}

  class shell {

  core parentCore;

  float radius;

  float x, y, z;

  float rotX, rotY, rotZ;

  float velocity;

  float scale;

  int zDepth;

  ArrayList shellPoints = new ArrayList();

      // constructor

  shell(float radius, float x, float y, float z) {

    this.x = x;

    this.y = y;

    this.z = z;

    this.radius = radius;

    rotX = random(TWO_PI);

    rotY = random(TWO_PI);

    rotZ = random(TWO_PI);

    scale = 0;

        velocity = random(0.0001, 0.02);

      // needs to start at a random point in the circle for rotateZ to work interestingly...probably. We'll see

    float theta = random(TWO_PI);

      //so it doesn't go ALL the way around - shells

    float endTheta = theta + random(HALF_PI) + HALF_PI;

      // makes it go all the way around

    // float endTheta = theta + TWO_PI;

           zDepth = int(random(1, 15));

            // start the rings so that the middle ring is at or near z = 0 on the z-axis;

    int zStart = 0 - floor(zDepth/2);

    for (int zCount = zStart; zCount < (zStart + zDepth); zCount++) {

      // spacing between rings

      z = zCount*4;

        // how noisy to make the lines

      float noiseFactor = 50;

        // only zCount+zDepth because I need a counter that stays above 0 the whole time and that's there

      float thetaNoise = map(noise((zCount+zDepth)/1.0), 0, 1, -2, 2);

        for (float currentTheta = (theta + thetaNoise); currentTheta <= (endTheta + thetaNoise); currentTheta += .05) {

          float currentNoise = map(noise(x/50, y/50, z/10), 0, 1, -1, 1)*noiseFactor;

          x = cos(currentTheta) * radius; // formerly had  + point_noise at the end, but redundant with point_noise

        y = sin(currentTheta) * radius; // in point class

          addshellPoint(x, y, z, currentTheta, currentNoise, zCount);

      }

    }

                   } // constructor

    void addshellPoint(float x, float y, float z, float theta, float point_noise, float ring) {

    shellPoint p = new shellPoint(x, y, z, theta, point_noise);

    p.parentShell = this;

    p.ring = ring;

      shellPoints.add(shellPoints.size(), p);

  }

        void render() {

    pushMatrix();

    translate(x, y, z);

      rotateX(rotX);

    rotateY(rotY);

    rotateZ(rotZ);

      // starting i at 1 instead of 0 seems to get rid of the rogue line problem

    for (int i = 1; i < (shellPoints.size() - 1); i++) {

      // if we're at the last point in the shell

      // make the next point the first one - TO DO - MAYBE ACTUALLY NOT

        shellPoint p = (shellPoint) shellPoints.get(i); 

      shellPoint q = (shellPoint) shellPoints.get(i+1);

        // stroke(255, alph);

      p.nextPoint = q;

      p.render();

    }

        popMatrix();

      }

    void pointOverlay(shellPoint thisPoint, shellPoint nextPoint) {

      //if they're in the same ring

    if (thisPoint.ring == nextPoint.ring) {

      line(thisPoint.x, thisPoint.y, thisPoint.z, nextPoint.x, nextPoint.y, nextPoint.z);

    } // if they're in the next ring

    else {

      //        float tempZ = thisPoint.z;

      //         line(thisPoint.x, thisPoint.y, thisPoint.z, nextPoint.x, nextPoint.y, tempZ);

    }

  }

    void update() {

      if (clicked == false) {

      radius += 1;

    }

      for (int i = 0; i < (shellPoints.size()); i++) {

      shellPoint p = (shellPoint) shellPoints.get(i);

      p.update();

    }

      }

}

  class shellPoint {

  shell parentShell;

  shellPoint nextPoint;

  float x, y, z;

  float theta;

  float point_noise;

  float ring;

  // float alpha;

  // float rotX, rotY, rotZ;

    shellPoint(float x, float y, float z, float theta, float point_noise) {

    this.x = x;

    this.y = y;

    this.z = z;

    this.theta = theta;

    this.point_noise = point_noise;

  }

    void render() {

        pushMatrix();

      //rotateY(frameCount*parentShell.velocity);

    rotateX(frameCount*parentShell.velocity);

      //translate(x, y, z);

        float useful1 = (map(parentShell.radius, 0, parentShell.parentCore.limit+10, 255, 0));

    float useful2 = (map(parentShell.radius, 0, parentShell.parentCore.limit+10, 255, 0));

        int this_color = parentShell.parentCore.colorCode;

      if (this_color == 1) {

    stroke(useful1, 0, 255, useful2);

    } else if (this_color == 2) {

          stroke(255, useful1, 0, useful2);

    }

          pushStyle();

    strokeWeight(3);

//    point(x, y, z);

    popStyle();

      parentShell.pointOverlay(this, nextPoint);

      popMatrix();

  }

      void update() {

    theta += 0.04;

      x = cos(theta) * parentShell.radius + point_noise;

    y = sin(theta) * parentShell.radius + point_noise;

    // z =  point_noise;

  }

}

  // controls

boolean makeVideo = false;

boolean audio = false;

int videoStart;

int videoFrames = 900;

  void keyReleased() {

  if (key == 'p') {

    noLoop();

  }

  if (key == 'r') {

    loop();

  }

  if (key == 's') {

    println("saved");

    saveFrame("combined_sphere_#####.tiff");

  }

    if (key == 'v') {

    makeVideo = true;

    videoStart = 0;

  }

}

    boolean clicked = false;

  void mouseClicked() {

  if (clicked == true) {

    clicked = false;

  }

  else {

    clicked = true;

  }

In keeping with the last posts the code isn't too bad.

// initial variable settings for the shape

float xstart = 7;

float ynoise = 5;

float zstart = 3;

float znoise = 2;

float xnoise = xstart;

float noiseIncrement = 0.03;

  // determines the magnitude of change between each draw

float startIncrement = 0.020;

  // used to keep track of how the previous shape was generated

float _xstart, _xnoise, _ynoise, _znoise, _zstart;

  void setup() {

  size(1280, 800, P3D);

  background(0);

  stroke(0, 200);

  strokeWeight(2);

  fill(255, 200);

    // by setting the camera to look at the origin, one less translatation

  // has to happen during ever draw() call

  camera(0, 0, 600, 0, 0, 0, 0, 1, 0);

}

    void draw() {

  background(0);

    // keep track of the start variables, before they're changed

  _xstart = xstart;

  _xnoise = xnoise;

  _ynoise = ynoise;

    pushMatrix();

      // the for loops are arbitrarily limited to producing limited numbers of points

  for (float y = -(175); y <= (175); y += random(8, 10) ) {

    // shift the noise value slightly

    ynoise += noiseIncrement;

    xnoise = xstart;

    for (float x = -(175); x <= (175); x += random(8, 10) ) {

      // shift the noise value slightly

      xnoise += noiseIncrement;

      znoise = zstart;

        for (float z =  -(175); z <= (175); z += random(8, 10) ) {

        znoise += noiseIncrement;

                // draw the current point

        drawPoint(x, y, z, noise(xnoise, ynoise, znoise));

      }

    }

  }

    // setup the start of the next shape, just slightly changed from the previous

  xstart = _xstart + startIncrement;

  zstart = _zstart + startIncrement;

  xnoise = _xnoise + startIncrement;

  ynoise = _ynoise + startIncrement;

  znoise = _znoise + startIncrement;

  }

  void drawPoint(float x, float y, float z, float noiseFactor) {

    float newX = x * noiseFactor * 3;

  float newY = y * noiseFactor * 3;

  float newZ = z * noiseFactor * 3;

    // determine how far point is from the center

  float value = dist(0, 0, 0, newX, newY, newZ);

    pushMatrix();

    // shift to where the point should be drawn

  translate(newX, newY, newZ);

      // use that value to determine the alpha & RGB levels for the point

  float redValue = map(value, 0, 400, 0, 255);

    // slight difference in mapping leads to better distribution of color

  float otherValue = map(value, 0, 500, 255, 0);

    strokeWeight(map(value, 0, 400, 1, 4));

  stroke(redValue, 0, otherValue, 100);

    // draw the point

  point(0, 0, 0);

    popMatrix();

Posting the code for this is probably long overdue. Be warned, it's longer and needs more commenting...but it's still very much in a fluid state at this point.

// radius, x, y, z, limit, colorCode, orbitRadius, starting offset

// colorcode refers to the color combinitions I've made in point class

core core1 = new core(50, 640, 400, 0, 600, 1, 50, 100, PI);

core core2 = new core(40, 640, 400, 0, 400, 2, 10, 200, 0);

    void setup() {

    size(1280, 800, P3D);

  background(0);

    stroke(255);

    for (int i = 0; i < 16; i++) {

    core1.addShell(int(random(1, core1.limit)), 0, 0, 0);

  }

    for (int i = 0; i < 8; i++) {

    core2.addShell(int(random(1, core2.limit)), 0, 0, 0);

  }

}

  void draw() {

    // new idea: build the loops from the pearson thing outwards around the black center, changing color

  // as they get further from it

    background(0);

    strokeWeight(2);

  stroke(255);

    core1.render();

  core1.update();

    core2.render();

  core2.update();

      if (makeVideo == true) {

    saveFrame("_vidframe_#####.tiff");

    videoStart++;

    if (videoStart == videoFrames) {

      makeVideo = false;

    }

  }

}

  class core {

  // radius of the core sphere

  float radius;

  float x, y, z;

  // used to limit growth of shells and determine their color

  float limit;

  float ideal;

  float ideal_change_lower = -0.05;

  float ideal_change_upper = 0.05;

  float idealNoise;

  int colorCode;

  int maxIdeal;

  ArrayList shells = new ArrayList();

  // float theta = random(TWO_PI);

  float theta;

  int orbitRadius;

  boolean clockwise;

      // constructor

  core(float radius, float x, float y, float z, float limit, int colorCode, int maxIdeal, int orbitRadius, float offset) {

    this.x = x;

    this.y = y;

    this.z = z;

    this.radius = radius;

    this.limit = limit;

      this.colorCode = colorCode;

    this.maxIdeal = maxIdeal;

    // initial ideal number of shells

    this.ideal = random(1, maxIdeal);

    this.orbitRadius = orbitRadius;

    this.theta = offset;

  }

      void addShell(int shellRadius, float x, float y, float z) {

    shell s = new shell(shellRadius, x, y, z);

    shells.add(shells.size(), s);

    s.parentCore = this;

  }

    float orbitx;

  float orbity;

  float orbitz;

  float orbit_velocity = .0020;

  float orbit_rotx = .5;

  float orbit_roty = .25;

    void orbit() {

    orbitx = cos(theta) * orbitRadius;

    orbity = sin(theta) * orbitRadius;

      theta += orbit_velocity;

  }

    void render() {

      // this push is an issue

    pushMatrix();

      translate(x, y, z);

      //scale(mouseX*1.0f/width*TWO_PI);

    // rotateY(mouseX*1.0f/width*TWO_PI);

    //rotateX(mouseY*1.0f/height*TWO_PI);

      noStroke();

    fill(0);

        pushMatrix();

    rotateX(orbit_rotx);

    rotateY(orbit_roty);

    translate(orbitx, orbity, 0);

    sphere(radius);

    popMatrix();

        for (int i = 0; i < (shells.size()); i++) {

      shell s = (shell) shells.get(i);

      s.render();

    }

        popMatrix();

  }

    void update() {

      // update orbit values

    orbit();

        // update all the shells

    for (int i = 0; i < (shells.size()); i++) {

      shell s = (shell) shells.get(i);

      s.update();

          // if the shell has hit the core limit, destory it

      if (s.radius >= limit) {

          shells.remove(shells.indexOf(s));

        // addShell(1);

          // chance of adding new shell on old shell destroy

        if (random(10) >= 2) {

            addShell(1, orbitx, orbity, orbitz);

        }

      }

    }

      // if there aren't enough shells, add one

    if (shells.size() < ideal) {

      addShell(1, orbitx, orbity, orbitz);

    }

        // for whatever reason, ideal trends to zero on it's own, so when ideal gets to be very small,

    // give it a boost upwards for awhile

    //println(ideal);

    if (ideal <= 2) {

      ideal_change_upper = 0.07;

    }

    if (ideal >= (maxIdeal - 2)) {

      ideal_change_upper = 0.04;

    }

      // map the change so it's very small between updates

    // println(map(noise(idealNoise), 0, 1, -0.05, ideal_change_upper));

    ideal += map(noise(idealNoise), 0, 1, -0.05, ideal_change_upper);

      // keep number of shells in check on the low end

    if (ideal <= 0) {

      // don't let it shrink below zero

      ideal = 0;

    }

    // keep number of shells in check on the high end

    if (ideal >= maxIdeal) {

      // don't let it grow above...

      ideal = maxIdeal;

    }

    idealNoise += 0.01;

    //  println( "ideal = " + ideal + "  upper = " + ideal_change_upper);

  }

}

  // idea, have an "ideal" number of shells, but that ideal changes using noise() over time, only adds

// shells if the current number of them is too low

  class shell {

  core parentCore;

  float radius;

  float x, y, z;

  float rotX, rotY, rotZ;

  float velocity;

  float scale;

  int zDepth;

  ArrayList shellPoints = new ArrayList();

      // constructor

  shell(float radius, float x, float y, float z) {

    this.x = x;

    this.y = y;

    this.z = z;

    this.radius = radius;

    rotX = random(TWO_PI);

    rotY = random(TWO_PI);

    rotZ = random(TWO_PI);

    scale = 0;

        velocity = random(0.0001, 0.02);

    // println(velocity);

        // needs to start at a random point in the circle for rotateZ to work interestingly...probably. We'll see

    float theta = random(TWO_PI);

      //so it doesn't go ALL the way around - shells

    float endTheta = theta + random(HALF_PI) + HALF_PI;

      // makes it go all the way around

    // float endTheta = theta + TWO_PI;

          zDepth = int(random(1, 15));

            // start the rings so that the middle ring is at or near z = 0 on the z-axis;

    int zStart = 0 - floor(zDepth/2);

    for (int zCount = zStart; zCount < (zStart + zDepth); zCount++) {

      // spacing between rings

      z = zCount*4;

        // how noisy to make the lines

      float noiseFactor = 50;

        // only zCount+zDepth because I need a counter that stays above 0 the whole time and that's there

      float thetaNoise = map(noise((zCount+zDepth)/1.0), 0, 1, -2, 2);

        for (float currentTheta = (theta + thetaNoise); currentTheta <= (endTheta + thetaNoise); currentTheta += .05) {

          float currentNoise = map(noise(x/50, y/50, z/10), 0, 1, -1, 1)*noiseFactor;

          x = cos(currentTheta) * radius; // formerly had  + point_noise at the end, but redundant with point_noise

        y = sin(currentTheta) * radius; // in point class

          addshellPoint(x, y, z, currentTheta, currentNoise, zCount);

      }

    }

                  } // constructor

    void addshellPoint(float x, float y, float z, float theta, float point_noise, float ring) {

    //println(x + " " + y + " " + z + " ");

    shellPoint p = new shellPoint(x, y, z, theta, point_noise);

    p.parentShell = this;

    p.ring = ring;

      shellPoints.add(shellPoints.size(), p);

  }

        void render() {

    pushMatrix();

    translate(x, y, z);

      rotateX(rotX);

    rotateY(rotY);

    rotateZ(rotZ);

      for (int i = 0; i < (shellPoints.size() - 1); i++) {

      // if we're at the last point in the shell

      // make the next point the first one - TO DO - MAYBE ACTUALLY NOT

        shellPoint p = (shellPoint) shellPoints.get(i); 

      shellPoint q = (shellPoint) shellPoints.get(i+1);

        // stroke(255, alph);

      p.nextPoint = q;

      p.render();

    }

    //println(scale);

    popMatrix();

      }

    void pointOverlay(shellPoint thisPoint, shellPoint nextPoint) {

      //if they're in the same ring

    if (thisPoint.ring == nextPoint.ring) {

      line(thisPoint.x, thisPoint.y, thisPoint.z, nextPoint.x, nextPoint.y, nextPoint.z);

    } // if they're in the next ring

    else {

      //        float tempZ = thisPoint.z;

      //         line(thisPoint.x, thisPoint.y, thisPoint.z, nextPoint.x, nextPoint.y, tempZ);

    }

  }

    void update() {

      if (clicked == false) {

      radius += 1;

      // radius *= 1.025;

    }

      for (int i = 0; i < (shellPoints.size()); i++) {

      shellPoint p = (shellPoint) shellPoints.get(i);

      p.update();

    }

    //    if (radius <= parentCore.limit/2) {

//    pn.setAmp(map(radius, 0, parentCore.limit/4, .2, 0));

//    }

      }

}

  class shellPoint {

  shell parentShell;

  shellPoint nextPoint;

  float x, y, z;

  float theta;

  float point_noise;

  float ring;

  // float alpha;

  // float rotX, rotY, rotZ;

    shellPoint(float x, float y, float z, float theta, float point_noise) {

    this.x = x;

    this.y = y;

    this.z = z;

    this.theta = theta;

    this.point_noise = point_noise;

  }

    void render() {

        pushMatrix();

      //rotateY(frameCount*parentShell.velocity);

    rotateX(frameCount*parentShell.velocity);

      //translate(x, y, z);

        float useful1 = (map(parentShell.radius, 0, parentShell.parentCore.limit, 255, 0));

    float useful2 = (map(parentShell.radius, 0, parentShell.parentCore.limit+2, 255, 0));

    int this_color = parentShell.parentCore.colorCode;

      if (this_color == 1) {

    stroke(useful1, 0, 255, useful2);

    } else if (this_color == 2) {

          stroke(255, useful1, 0, useful2);

    }

          pushStyle();

    strokeWeight(3);

    // point(x, y, z);

    popStyle();

      parentShell.pointOverlay(this, nextPoint);

      popMatrix();

  }

      void update() {

    // x *= 1.01;

    // y *= 1.01;

      //   theta += map(noise(point_noise), 0, 1, -.1, .1);

    theta += 0.04;

      x = cos(theta) * parentShell.radius + point_noise;

    y = sin(theta) * parentShell.radius + point_noise;

    // z =  point_noise;

  }

}

  boolean makeVideo = false;

boolean audio = false;

int videoStart;

int videoFrames = 900;

  void keyReleased() {

  if (key == 'p') {

    noLoop();

  }

  if (key == 'r') {

    loop();

  }

  if (key == 's') {

    println("saved");

    saveFrame("combined_sphere_#####.tiff");

  }

    if (key == 'v') {

    makeVideo = true;

    videoStart = 0;

  }

}

    boolean clicked = false;

  void mouseClicked() {

  if (clicked == true) {

    clicked = false;

  }

  else {

    clicked = true;

  }

Now basically the same underlying behavior is going on, but each little cube cares about all of the other cubes around it in a 3D space. So like before waves of color propagate through all the cubes, but with the addition of another axis to travel on. The cubes also grow and shrink as they change state.

I'm not done with this, but I'm not entirely sure at the moment where to go next. The emergent patterns are most clear when there's a LOT of little cubes, but it's really taxing as the total number of them pushes past a couple thousand (since each cube is now watching 26 other cubes instead of just 8). So I'm not sure how much more activity, either in moving the little cubes around or building a more complicated BIG shape than just a larger cube can be done without slowing everything to a jittery crawling mess. Ponder ponder.

Code below:

life_cube[][][] cube_array;

int num_x, num_y, num_z;

int cube_size = 15; // length of the sides of the little cubes

int meta_cube_size = 300; // how big should the BIG cube be, without spacing

int cube_spacing = 20; // how far apart the little cubes should be

// determine the total side length of the big cube, spacing of little cubes included

int total_side = (meta_cube_size/cube_size)*(cube_size + cube_spacing);

void setup() {

  size(1280, 800, P3D);

  num_x = ceil(meta_cube_size/cube_size); // at the moment only num_x matters

  num_y = num_x; // num_y & z are here for future additions

  num_z = num_x;

  camera(total_side, total_side, total_side/2, 0, 0, 0, 0, 1, 0); // move the camera to the center of the shape

  restart(); // set up all the cubes

}

void restart() {

  cube_array = new life_cube[num_x][num_y][num_z];

  // create all of the little cubes

  for (int x=0; x < num_x; x++) {

    for (int y=0; y < num_y; y++) {

      for (int z=0; z < num_z; z++) {

        life_cube new_cube = new life_cube(x, y, z);

        cube_array[x][y][z] = new_cube;

      }

    }

  }

  // set all of the little cubes' neighbors

  for (int x=0; x < num_x; x++) {

    for (int y=0; y < num_y; y++) {

      for (int z=0; z < num_z; z++) {

        int up = y - 1;

        int down = y + 1;

        int left = x - 1;

        int right = x + 1;

        int forward = z + 1;

        int backward = z - 1;

        // wrap code

        if (up < 0) {

          up = num_y - 1;

          //  up = num_z - 1; //go backwards

        }

        if (down == num_y) {

          // down = 0;

          down = num_z - 1;

        }

        if (left < 0) {

          left = num_x - 1;

        }

        if (right == num_x) {

          right = 0;

        }

        if (backward < 0) {

          backward = num_z - 1;

        }

        if (forward == num_z) {

          forward = 0;

        }

        // layer 1

        cube_array[x][y][z].add_neighbor(cube_array[left][up][forward]);

        cube_array[x][y][z].add_neighbor(cube_array[left][up][z]);

        cube_array[x][y][z].add_neighbor(cube_array[left][up][backward]);

        cube_array[x][y][z].add_neighbor(cube_array[left][y][forward]);

        cube_array[x][y][z].add_neighbor(cube_array[left][y][z]);

        cube_array[x][y][z].add_neighbor(cube_array[left][y][backward]);

        cube_array[x][y][z].add_neighbor(cube_array[left][down][forward]);

        cube_array[x][y][z].add_neighbor(cube_array[left][down][z]);

        cube_array[x][y][z].add_neighbor(cube_array[left][down][backward]);

        // layer 2

        cube_array[x][y][z].add_neighbor(cube_array[x][up][forward]);

        cube_array[x][y][z].add_neighbor(cube_array[x][up][z]);

        cube_array[x][y][z].add_neighbor(cube_array[x][up][backward]);

        cube_array[x][y][z].add_neighbor(cube_array[x][y][forward]);

        // cube_array[x][y][z].add_neighbor(cube_array[x][y][z]);

        cube_array[x][y][z].add_neighbor(cube_array[x][y][backward]);

        cube_array[x][y][z].add_neighbor(cube_array[x][down][forward]);

        cube_array[x][y][z].add_neighbor(cube_array[x][down][z]);

        cube_array[x][y][z].add_neighbor(cube_array[x][down][backward]);

        // layer 3

        cube_array[x][y][z].add_neighbor(cube_array[right][up][forward]);

        cube_array[x][y][z].add_neighbor(cube_array[right][up][z]);

        cube_array[x][y][z].add_neighbor(cube_array[right][up][backward]);

        cube_array[x][y][z].add_neighbor(cube_array[right][y][forward]);

        cube_array[x][y][z].add_neighbor(cube_array[right][y][z]);

        cube_array[x][y][z].add_neighbor(cube_array[right][y][backward]);

        cube_array[x][y][z].add_neighbor(cube_array[right][down][forward]);

        cube_array[x][y][z].add_neighbor(cube_array[right][down][z]);

        cube_array[x][y][z].add_neighbor(cube_array[right][down][backward]);

      }

    }

  }

} // end restart

void draw() {

  rotateY(frameCount*0.002);

  rotateX(frameCount*0.005);

  translate(-(total_side/2), -(total_side/2), -(total_side/2));

  background(255);

  // do the calculations for the state

  for (int x=0; x < num_x; x++) {

    for (int y=0; y < num_y; y++) {

      for (int z=0; z < num_z; z++) {

        cube_array[x][y][z].calc_next_state();

      }

    }

  }

  // draw the cubes

  for (int x=0; x < num_x; x++) {

    for (int y=0; y < num_y; y++) {

      for (int z=0; z < num_z; z++) {

        cube_array[x][y][z].draw_me();

      }

    }

  }

} // end draw

class life_cube {

  float x, y, z;

  float state, next_state;

  float last_state = 0;

  life_cube[] neighbors;

  life_cube(float x, float y, float z) {

    this.x = x;

    this.y = y;

    this.z = z;

    // initialize

    // next_state = ((x/width) + (y/height) + z) * cube_size;

    next_state = random(255); // this helps for non-start states where nothing happens

    state = next_state;

    neighbors = new life_cube[0];

  } 

  void add_neighbor(life_cube input_cube) {

    neighbors = (life_cube[])append(neighbors, input_cube);

  }

  void calc_next_state() {

    float total = 0;

    for (int i=0; i < neighbors.length; i++) {

      total += neighbors[i].state;

    } 

    float average = int(total/26);

    if (average <= 20) { // having this greater than 0 makes it more lively

      if ((random(4) > 2)) {

        next_state = 255;

      }

    } 

    else {

      next_state = state + average;

      if (last_state > 0) {

        next_state -= last_state;

      }

      if (next_state > 255) {

        next_state = 255; // keep it in bounds

      } 

      else if (next_state < 0) {

        next_state = 0; // keep it in bounds

      }

    }

    last_state = state;

  } // end calc_next_state

    void draw_me() {

    state = next_state;

    stroke(0);

    //noStroke();

    //  fill(state);

    fill(255, state, 100);

    pushMatrix();

    translate(x*(cube_size + cube_spacing), y*(cube_size + cube_spacing), z*(cube_size + cube_spacing));

    box(cube_size/2 + state/10); // grow or shrink depending on state

    popMatrix();

  } // end draw_me

} // end life_cube

void mousePressed() {

  restart();