Planet Maker

let _noise;

let _aryInitNoiseXYZ = [];

let _aryNoiseRangeXYZ = [];

let _aryNumNoise = [];

let _noiseStepT;

​

let _aryInitRot = [];

​

let _aryNumTile = [];

let _gridWidth;

let _aryCheck = [];

let _aryStep = [];

​

function setup() {

  let canvasSize;

  if (windowWidth <= windowHeight) {

    canvasSize = windowWidth;

  } else {

    canvasSize = windowHeight;

  }

  createCanvas(1112, 834, WEBGL);

  colorMode(HSB, 255);

  document.getElementsByTagName('main')[0].style.margin = 0;

  setAttributes('premultipliedAlpha', true);

  frameRate(30);

  noStroke();

  _noise = new OpenSimplexNoise();

​

  _aryNumTile[0] = 20;

  _aryNumTile[1] = 20;

  _aryNumTile[2] = 20;

  _gridWidth = width/1.5;

  for (let i = 0; i < 3; i++) {

    _aryStep[i] = _gridWidth / _aryNumTile[i];

  }

​

  for (let i = 0; i < 3; i++) {

    _aryInitRot[i] = [random(2*PI), random([-1, 1])];

  }

​

  _numNoise = 1;

  for (let i = 0; i < 4; i++) {

    _aryInitNoiseXYZ[i] = [];

    for (let j = 0; j < _numNoise; j++) {

      _aryInitNoiseXYZ[i][j] = random(100);

    }

  }

  _aryNoiseRangeXYZ[0] = 0.5*4;

  _aryNoiseRangeXYZ[1] = 0.5*4;

  _aryNoiseRangeXYZ[2] = 0.5*4;

  _noiseStepT = -0.03;

}

​

function draw() {

  translate(0, 0, -300);

  background(0);

  directionalLight(255, 255, 255, -1, 1, -1);

  ambientLight(200);

​

  rotateX(_aryInitRot[0][0] + frameCount/200 * _aryInitRot[0][1]);

  rotateY(_aryInitRot[1][0] + frameCount/100 * _aryInitRot[1][1]);

  rotateZ(_aryInitRot[2][0] + frameCount/150) * _aryInitRot[2][1];

​

  for (let x = 0; x <_aryNumTile[0]+1; x++) {

    for (let y = 0; y < _aryNumTile[1]+1; y++) {

      for (let z = 0; z < _aryNumTile[2]+1; z++) {

        let noiseVal = calculateOSNoise(x / _aryNumTile[0], y / _aryNumTile[1], z / _aryNumTile[2], 0);

        let threshold = 0.97;

        if (noiseVal > threshold) {

          let ratio = (noiseVal - threshold) / (1 - threshold)

          ambientMaterial(z*20%255, 230, 230);

          push();

          translate(-_gridWidth/2 + 1.3 * x * _aryStep[0], .8 * -_gridWidth/2 + y * _aryStep[1], -_gridWidth/2 + z * _aryStep[2]);

          sphere(width/100 * ratio);

          pop();

        }

      }

    }

  }

}

​

function deleteAry(ary, element) {

  for (let i = ary.length-1; i >= 0; i--) {

    if (ary[i] == element) { ary.splice(i, 1); }

  }

}

​

function tube(numTile, gridWidth, start_x, start_y, start_z, direction, r, col) {

  if (direction != 0) {

    let step = gridWidth/numTile;

    let startPosX = -gridWidth/2 + step * start_x;

    let startPosY = -gridWidth/2 + step * start_y;

    let startPosZ = -gridWidth/2 + step * start_z;

    let end_x = start_x;

    let end_y = start_y;

    let end_z = start_z;

    switch(direction) {

      case "x":

        end_x++;

        break;

      case "y":

        end_y++;

        break;

      case "z":

        end_z++;

        break;

    }

    let endPosX = -gridWidth/2 + step * end_x;

    let endPosY = -gridWidth/2 + step * end_y;

    let endPosZ = -gridWidth/2 + step * end_z;

    //ambientMaterial(col);

    push();

    translate(startPosX, startPosY, startPosZ);

    ambientMaterial(z*20%255, 230 * ratio**2, 230 * ratio**3);

​

    sphere(r);

    pop();

    push();

    translate(endPosX, endPosY, endPosZ);

    sphere(r);

    pop();

    push();

    let cylinderHeight;

    switch(direction) {

      case "x":

        rotateZ(PI/2);

        translate((startPosY + endPosY)/2, -(startPosX + endPosX)/2, (startPosZ + endPosZ)/2);

        cylinderHeight = endPosX - startPosX;

        break;

      case "y":

        translate((startPosX + endPosX)/2, (startPosY + endPosY)/2, (startPosZ + endPosZ)/2);

        ambientMaterial(z*20%255, 230 * ratio**2, 230 * ratio**3);

        cylinderHeight = endPosY - startPosY;

        break;

      case "z":

        rotateX(PI/2);

        translate((startPosX + endPosX)/2, (startPosZ + endPosZ)/2, -(startPosY + endPosY)/2);

        cylinderHeight = endPosZ - startPosZ;

        break;

    }

    cylinder(r, cylinderHeight);

    pop();

  }

}

​

function calculateOSNoise(x, y, z, i) { //OpenSimplexNoise = -1 < noiseValue < 1

  let freq = 1;

  let noiseVal = sin(2*PI*freq * _noise.noise3D(

    _aryInitNoiseXYZ[0][i] + _aryNoiseRangeXYZ[0] * x + frameCount * _noiseStepT,

    _aryInitNoiseXYZ[1][i]+ _aryNoiseRangeXYZ[1] * y + frameCount * _noiseStepT,

    _aryInitNoiseXYZ[2][i] + _aryNoiseRangeXYZ[2] * z + frameCount * _noiseStepT

  )) * 0.5 + 0.5;

  return noiseVal; // 0 < noiseVal < 1

}

​

let lapse = 0;    // mouse timer

function mousePressed(){

  // prevents mouse press from registering twice

  if (millis() - lapse > 400){

    save('pix.jpg');

    lapse = millis();

  }

}

​

function screenReset() {

  for (let i = 0; i < 3; i++) {

    _aryInitRot[i] = [random(2*PI), random([-1, 1])];

  }

​

  for (let i = 0; i < 4; i++) {

    _aryInitNoiseXYZ[i] = [];

    for (let j = 0; j < _numNoise; j++) {

      _aryInitNoiseXYZ[i][j] = random(100);

    }

  }

}