let gsize;

let dim;

let gfxs;

let particles;

let cells;

​

const cc239 = ["#e0eff0", "#e3dd34", "#78496b", "#f0527f", "#a7e0e2"];

const mono = ["#202020", "#333333", "#666666", "#999999", "#cccccc"];

let palette;

​

let preserve;

let _scale;

function setup() {

  dim = 1000;

  _scale = dim / 1000;

  createCanvas(dim, dim);

  angleMode(RADIANS);

  noiseDetail(8, 0.25);

  // gsize = int(dim * 0.25);

  gsize = int(dim * 0.1);

  cells = int(dim / gsize);

​

  palette = mono;//random([cc239, mono]);

​

  gfxs = [];

  preserve = {};

  let x = 0;

  let y = 0;

​

  particles = [];

  grid = Array.from({ length: dim }, () =>

    Array.from({ length: dim }, () => 0.0)

  );

  // console.log(grid)

  for (let _ = 0; _ < cells; _++) {

    let maxy = y + gsize;

    for (let _2 = 0; _2 < cells; _2++) {

      let xzoom = random(0.01, 0.1);

      let yzoom = random(0.01, 0.1);

      let gmode = random(["flow", "edge", "straight"]);

      let col = random(palette);

​

      if (random() > 0.5) {

        preserve[`${_}:${_2}`] = true;

        preserve[`${_2}:${_}`] = true;

      } else {

        preserve[`${_}:${_2}`] = false;

        preserve[`${_2}:${_}`] = false;

      }

​

      let straight_a = random(0,TWO_PI);

      let maxx = x + gsize;

      for (let _y = y; _y < maxy; _y++) {

        for (let _x = x; _x < maxx; _x++) {

          let n = noise(_x * xzoom, _y * yzoom);

          grid[_y][_x] = {};

          grid[_y][_x].c = col;

          if (gmode == "flow") {

            grid[_y][_x].a = map(n, 0.0, 1.0, 0.0, TWO_PI);

            grid[_y][_x].t = "flow";

          } else if (gmode == "straight") {

            grid[_y][_x].a = straight_a;

            grid[_y][_x].t = "straight";

          } else {

            grid[_y][_x].a = Math.ceil(

              (map(n, 0.0, 1.0, 0.0, TWO_PI) * (PI / 4)) / (PI / 4)

            );

            grid[_y][_x].t = "edge";

          }

        }

      }

​

      x = maxx;

    }

    y = maxy;

    x = 0;

  }

  console.log(preserve)

​

  /*

  for (let _ = 0; _ < cells; _++) {

    for (let _2 = 0; _2 < cells; _2++) {

      let g = createGraphics(gsize, gsize);

      g.background(0);

      gfxs.push({ g: g, x: x, y: y });

      x += gsize;

    }

    x = 0;

    y += gsize;

  }*/

​

  /*

  let idx = 0;

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

    grid[y] = [];

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

      let gmode = gfxs[idx].type;

      let xzoom = gfxs[idx].xzoom;

      let yzoom = gfxs[idx].yzoom;

​

​

      if (x > 0 && y > 0 && (x % gsize == 0 || y % gsize == 0)) {

        idx++;

      }

    }

  }*/

​

  for (let _ = 0; _ < 5000; _++) {

    let l = int(random(dim * 0.1, dim));

    let s = 0.5;

    if (random() > 0.8) s = random(0.5, 2.5);

    s *= _scale;

    particles.push({

      x: int(random(dim)),

      y: int(random(dim)),

      c: random(palette),

      l: l,

      dir: random([true, false]),

      s: s,

    });

  }

  background(255);//0);

​

}

​

function drawShadow(b,c) {

  drawingContext.shadowOffsetX = 0;

  drawingContext.shadowOffsetY = 0;

  drawingContext.shadowBlur = b* _scale;

  drawingContext.shadowColor = c;

}

function draw() {

  for (let _ = 0; _ < 5; _++) {

    push();

  // drawShadow(10,color(212,252,255));

  // background(220);

  noFill();

  strokeWeight(1*_scale);

  stroke(color(212,252,255,10));//color(220, 220, 220, 80));

  let _r = 0;

  let _c = 0;

  for (let r = 0; r < dim; r += gsize) {

    for (let c = 0; c < dim; c += gsize) {

//       let idx = `${_r}:${_c}`;

//       if (random() > 0.99 && preserve[idx] === false) {

//         let _col = color(20);//random(palette));

//         _col.setAlpha(random(5, 30));

​

//         fill(_col);

//       } else noFill();

      rect(c, r, gsize, gsize);

      _c++;

    }

    _c = 0;

    _r++;

  }

​

  noStroke();

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

    let p = particles[i];

​

    // if (grid[int(p.y)][int(p.x)].t == "flow") stroke(color(255, 0, 255));

    // //strokeWeight(1);

    // else stroke(220); // strokeWeight(4);

    // stroke(color(p.c));

    // drawShadow(1,color(p.c));//212,252,255));

    fill(color(p.c));

    // ellipse(p.x+random(-2,2),p.y+random(-2,2),p.s+random(-2,2)*_scale,p.s+random(-2,2)*_scale)

    strokeWeight(p.s);

    stroke(color(p.c));

    point(p.x, p.y);

​

    let angle = grid[int(p.y)][int(p.x)].a;

    let xstep = cos(angle)*_scale;

    let ystep = sin(angle)*_scale;

​

    if (p.dir) {

      xstep *= -1;

      ystep *= -1;

    }

    p.x += xstep;

    p.y += ystep;

​

    p.l--;

    if (p.x < 0 || p.x > dim - 1 || p.y < 0 || p.y > dim - 1 || p.l <= 0)

      particles.splice(i, 1);

  }

​

  // for (let g of gfxs) {

  //   image(g.g, g.x, g.y);

  // }

​

  if (particles.length == 0) {

    noLoop();

    console.log("done");

    break;

  }

    pop();

  }

}

​