Over the map _j

let easycam;

let terrain = [];

let rows, cols;

let scl = 25;

let w = 500;

let h = 500;

let octaves = 23;

let persistence = 0.5;

let lacunarity = 0.2;

let currentRow = 0;

let currentParticle = 0;

let displaySpeed = 0.5;

let particles = [];

let partSize = 33;

let partSizeB = 5;

let partSizeC = 7;

​

let colorScale = chroma.scale(["#EED", "#3d295a", "#752536", "#b56576", "#eaac8b"],).domain([-100, 100]);

let colorScale1 = chroma.scale(['#44444a', '#bae8e8', "#81b29a", "#A9B7CF", "#fff"]).domain([-100, 100]);

let colorScale2 = chroma.scale(['#4F7098', '#74C3D8', '#7C99CB', '#76A3E7', '#FFFFFF']).domain([-50, 50]);

let colorScale3 = chroma.scale(['#EED', "#780000", "#c1121f", "#fdf0d5", "#003049", "#669bbc"]).domain([-50, 50]);

let colorScale4 = chroma.scale(["#F8F4E3", "#FFD275", "#FE938C", "#25283D"]).domain([-50, 50]);

let colorScale5 = chroma.scale(["#E4D6CA", "#241717", "#152548", "#322927", "#6A353F"]).domain([-50, 50]);

let colorScale6 = chroma.scale(["#FCF6E9", "#241302", "#984E35", "#C89F83", "#746B70"]).domain([-50, 50]);

​

​

function setup() {

  createCanvas(windowWidth, windowHeight, WEBGL);

  setAttributes('antialias', true);

  //console.log(Dw.EasyCam.INFO);

  //easycam = createEasyCam({distance: 1000, center: [0,-300,0],rotation: [QUARTER_PI*0.8,-QUARTER_PI,PI/12,PI/12]});

  easycam = createEasyCam({distance: 900, center: [0,0,0],rotation: [0.4,-0.75,0,0]});

  rows = h / scl;

  cols = w / scl;

  //randomSeed(56789);

  for (let x = 0; x < cols; x++) {

    terrain[x] = [];

  }

​

  centerX = cols / 2;

  centerY = rows / 2;

  radius = Math.min(rows, cols) / 2;

​

  generateTerrain();

  createParticles();

  ambientLight(60);

  pointLight(255,255,255,0,0,200);

}

​

function draw() {

  background(colorScale3(0.3).hex());

  translate(-w / 2, -h / 2);

​

  updateParticles();

  drawParticles();

  drawParticlesB();

  drawParticlesC();

}

​

function createHatchPatternA(color) {

  let pattern = createGraphics(20, 20);

  pattern.stroke(color);

  pattern.strokeWeight(1);

  pattern.line(0, 0, 20, 20);

  pattern.line(20, 0, 0, 20);

  pattern.circle(10,10,10);

  pattern.line(10,10,20,20);

  pattern.line(20,10,20,20);

  return pattern;

}

​

function generateTerrain() {

  let yoff = 0;

  for (let y = 0; y < rows; y++) {

    let xoff = 0;

    for (let x = 0; x < cols; x++) {

      terrain[x][y] = map(fBm(xoff, yoff), 0, 1, -100, 100);

      xoff += 0.1;

    }

    yoff += 0.1;

  }

}

​

function fBm(x, y) {

  let sum = 0;

  let amplitude = 1;

  let frequency = 1;

  let maxValue = 0;

​

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

    sum += amplitude * noise(x * frequency, y * frequency);

    maxValue += amplitude;

    amplitude *= persistence;

    frequency *= lacunarity;

  }

​

  return sum / maxValue;

}

​

function createParticles() {

  for (let y = 0; y < rows; y++) {

    for (let x = 0; x < cols; x++) {

      let particle = {

        x: x * scl * random(0.97, 1.03),

        y: y * scl,

        z: -300,

        targetZ: terrain[x][y],

        hatchPattern: createHatchPatternA(colorScale1(terrain[x][y]).hex())

      };

      particles.push(particle);

    }

  }

}

​

​

function updateParticles() {

  for (let i = 0; i < particles.length; i++) {

    let x = particles[i].x / scl;

    let y = particles[i].y / scl;

​

    let updateRange = 1; 

    let lowerBound = (currentRow - updateRange + rows) % rows;

    let upperBound = (currentRow + updateRange) % rows;

​

    if (lowerBound <= upperBound) {

      if (y >= lowerBound && y <= upperBound) {

        particles[i].z = lerp(particles[i].z, particles[i].targetZ, 0.1);

      }

    } else {

      if (y >= lowerBound || y <= upperBound) {

        particles[i].z = lerp(particles[i].z, particles[i].targetZ, 0.1);

      }

    }

  }

​

  currentRow = (currentRow + displaySpeed) % rows;

}

​

​

function drawParticles() {

  for (let i = 0; i < particles.length; i++) {

    push();

    randomSeed(HALF_PI*i*10);

    fill(colorScale5(particles[i].targetZ).hex());

    stroke(colorScale6(particles[i].targetZ).hex());

    translate(particles[i].x*random(0.95,1.05), particles[i].y*random(0.95,1.05), particles[i].z);

    rotateX(HALF_PI);

    //noStroke();

    //rotateY(millis() / 2000);

    box(partSize,partSize*random(1,5), Math.floor(randomGaussian(8,12)));

    pop();

  }

}

​

​

function drawParticlesB() {

  for (let i = 0; i < particles.length; i++) {

    push();

    randomSeed(PI*i*21);

    texture(particles[i].hatchPattern);

    //fill(colorScale3(particles[i].targetZ).hex());

    stroke(colorScale4(particles[i].targetZ).hex());

    translate(particles[i].x * random(0.1,0.4), particles[i].y * 0.3, particles[i].z * 3);

    translate(350,300,-100);

    noStroke();

    //strokeWeight(0.5);

    sphere(partSizeB);

    pop();

  }

}

​

function drawParticlesC() {

  let particleIndex = 0;

  for (let y = 0; y < rows; y++) {

    for (let x = 0; x < cols; x++) {

      let dx = x - centerX;

      let dy = y - centerY;

      //let distance = Math.sqrt(dx * dx + dy * dy);

      //let distance = Math.sqrt((dx * dx) * (dy * dy));

      let distance = Math.sqrt((dx * cos(PI / 7 * x * y)) + (dy * sin(TWO_PI * y + x)));

​

      if (distance < radius) {

        push();

          //texture(particles[particleIndex].hatchPattern);

          //fill(colorScale2(particles[particleIndex].targetZ).hex());

          //translate(particles[particleIndex].x, particles[particleIndex].y, particles[particleIndex].z * 1.2);

          //noStroke();

          //stroke(colorScale3(particles[particleIndex].targetZ).hex());

          //strokeWeight(0.3);

          //stroke(255);

        //rotateX(random(20,60));

          //translate(-50,-50,-20);

          //rotateX(HALF_PI);

          //rotateZ(QUARTER_PI*random(0,2));

          //randomSeed(PI*x*y);

          //rotateY(millis() / random(500,3000));

          //cylinder(partSizeC, partSizeC*random(4,24), (Math.floor(random() * 20)));

          //x1, y1, z1, x2, y2, z2, x3, y3, z3, x4, y4, z4

          //bezier(partSizeC/2,partSizeC/2, partSizeC/4,partSizeC/4, partSizeC*1.5,partSizeC*1.5, partSizeC*2,partSizeC*2);

        pop();

        push();

          randomSeed(PI*x*y);

          translate(-150,-150,0);

          fill(colorScale1(particles[particleIndex].targetZ).hex());

          translate(particles[particleIndex].x * 1.5, particles[particleIndex].y * 1.5, particles[particleIndex].z / 1.5);

          line(partSizeC,partSizeC*random(4,24), Math.floor(Math.random(12,24)), Math.floor(Math.random(4,16)));

          rotateY(random(5,15));

          line(partSizeC,partSizeC*random(4,24), Math.floor(Math.random(12,24)), Math.floor(Math.random(4,16)));

          rotateY(random(-15,-32));

          line(partSizeC,partSizeC*random(4,24), Math.floor(Math.random(12,24)), Math.floor(Math.random(4,16)));

          line(partSizeC,partSizeC*random(2,38), Math.floor(Math.random(6,4)), Math.floor(Math.random(3,2)));

          rotateY(random(15,25));

          line(partSizeC,partSizeC*random(4,24), Math.floor(Math.random(12,24)), Math.floor(Math.random(4,16)));

          rotateY(random(-35,-52));

          line(partSizeC,partSizeC*random(4,24), Math.floor(Math.random(12,24)), Math.floor(Math.random(4,16)));

        pop();

        push();

          randomSeed(PI*x*y);

        noStroke();

          translate(-150,-150,0);

          fill(colorScale2(particles[particleIndex].targetZ).hex());

          translate(particles[particleIndex].x * 1.5, particles[particleIndex].y * 1.5, particles[particleIndex].z / 1.2);

          sphere(partSizeC*random(0.3,0.7));

          translate(15,15,0);

          sphere(partSizeC*random(0.3,0.7));

          translate(15,15,0);

          sphere(partSizeC*random(0.3,0.7));

          translate(10,15,0);

          sphere(partSizeC*random(0.3,0.7));

          translate(15,10,0);

          sphere(partSizeC*random(0.3,0.7));

          translate(15,15,0);

          sphere(partSizeC*random(0.3,0.7));

          translate(-20,-20,0);

          sphere(partSizeC*random(0.3,0.7));

          translate(-20,-25,0);

          sphere(partSizeC*random(0.3,0.7));

          translate(-25,-20,0);

          sphere(partSizeC*random(0.3,0.7));

​

        pop();

      }

      particleIndex++;

    }

  }

}

​

​