let particles;

​

let windowScale;

function preload() {

  img = loadImage("readmore.jpg");

}

​

function setup() {

  img.resize(3000, 0);

  createCanvas(img.width, img.height);

​

  windowScale = img.width / 1000;

​

  image(img, 0, 0);

  strokeWeight(1.0 * windowScale);

​

  // loadPixels();

  img.loadPixels();

​

  let numparticles = img.width * 0.5;

  particles = [];

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

    let p = {

      x: random(1, img.width - 1),

      y: 0, //img.height - 1,

      vx: 0,

      vy: random(0.5, 1.5) * windowScale,

    };

    let life = int(random(50, 500)); //img.height / 4, img.height / 8));

    p.life = life;

    p.olife = life;

    p.col = img.get(p.x, p.y);

​

    particles.push(p);

  }

}

​

function drawPoint(x, y) {

  point(x, y);

  if (random() > 0.7) {

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

      point(x + random(-2, 2) * windowScale, y + random(-2, 2) * windowScale);

    }

  }

}

function draw() {

  // background(220);

  /*

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

    let p = particles[i];

​

    let a = map(p.life, p.olife, 0, 80, 10);

    let c = color(p.col);

    c.setAlpha(a);

    stroke(c);

    drawPoint(p.x, p.y);

​

    p.x += p.vx;

    p.y += p.vy;

​

    if (random() > 0.9) {

      p.vx = random(-1, 1) * windowScale;

    }

    if (random() > 0.9) {

      p.vy = random(0.5, 1.5) * windowScale;

    }

    if (random() > 0.5) {

      p.col = img.get(p.x, p.y);

    }

​

    if (p.x < 1 || p.x > width-1) p.vx *= random(-1.0, -0.1);

​

    p.life--;

    if (p.y >= img.height || p.life <= 0) {

      // fill(color(img.get(p.x, p.y)));

      // noStroke();

      // circle(p.x, p.y, random(2.0, 10.0) * windowScale);

      particles.splice(i, 1);

    }

  }

  if (particles.length === 0) {*/

  dither(null);

  console.log("done");

​

  let offset = img.width * 0.01;

  let trypsize_w = img.width / 3 - 2 * offset;

  let trypsize_h = img.height - 2 * offset;

​

  let img1 = createImage(trypsize_w, trypsize_h);

  let img2 = createImage(trypsize_w, trypsize_h);

​

  drawShadow(0,0,10*windowScale,color(20), null);

  img1.copy(

    img,

    offset,

    offset,

    trypsize_w,

    trypsize_h,

    0,

    0,

    img1.width,

    img1.height

  );

  img2.copy(

    img,

    img.width - offset - trypsize_w,

    offset,

    trypsize_w,

    trypsize_h,

    0,

    0,

    img2.width,

    img2.height

  );

​

  // background(0);

  // image(img, 0, 0);

  push();

  tint(0, 153, 204, 126);

  image(img1, offset, offset);

  pop();

  image(img2, width - offset - trypsize_w, offset);

​

  noLoop();

  // }

}

​

function index(g, x, y) {

  if (g == null) return (x + y * width) * 4;

  else return (x + y * g.width) * 4;

}

​

function DivideBy255(value) {

  return (value + 1 + (value >> 8)) >> 8;

}

function dither(g) {

  // let referenceSize = img.width, hasMa

  if (g == null) {

    let _scale = windowScale; //Math.ceil(1, map(width, 0, referenceSize, 0, 1, hasMaxSize));

    loadPixels();

    for (let y = 0; y < height - _scale; y++) {

      for (let x = _scale; x < width - _scale; x++) {

        let oldr = pixels[index(g, x, y)];

        let oldg = pixels[index(g, x, y) + 1];

        let oldb = pixels[index(g, x, y) + 2];

​

        let newr = (DivideBy255(oldr) * 255) | 0;

        let newg = (DivideBy255(oldg) * 255) | 0;

        let newb = (DivideBy255(oldb) * 255) | 0;

​

        pixels[index(g, x, y)] = newr;

        pixels[index(g, x, y) + 1] = newg;

        pixels[index(g, x, y) + 2] = newb;

​

        for (let _y = 1; _y <= _scale; _y++) {

          for (let _x = 1; _x <= _scale; _x++) {

            pixels[index(g, x + _x, y)] += ((oldr - newr) * 7) >> 4;

            pixels[index(g, x + _x, y) + 1] += ((oldr - newr) * 7) >> 4;

            pixels[index(g, x + _x, y) + 2] += ((oldr - newr) * 7) >> 4;

​

            pixels[index(g, x - _x, y + _y)] += ((oldr - newr) * 3) >> 4;

            pixels[index(g, x - _x, y + _y) + 1] += ((oldr - newr) * 3) >> 4;

            pixels[index(g, x - _x, y + _y) + 2] += ((oldr - newr) * 3) >> 4;

​

            pixels[index(g, x, y + _y)] += ((oldr - newr) * 5) >> 4;

            pixels[index(g, x, y + _y) + 1] += ((oldr - newr) * 5) >> 4;

            pixels[index(g, x, y + _y) + 2] += ((oldr - newr) * 5) >> 4;

​

            pixels[index(g, x + _x, y + _y)] += ((oldr - newr) * 1) >> 4;

            pixels[index(g, x + _x, y + _y) + 1] += ((oldr - newr) * 1) >> 4;

            pixels[index(g, x + _x, y + _y) + 2] += ((oldr - newr) * 1) >> 4;

          }

        }

      }

    }

    updatePixels();

  } else {

    let _scale = windowScale; // Math.ceil(1, map(g.width, 0, referenceSize, 0, 1, hasMaxSize));

    g.loadPixels();

    for (let y = 0; y < g.height - _scale; y++) {

      for (let x = _scale; x < g.width - _scale; x++) {

        let oldr = g.pixels[index(g, x, y)];

        let oldg = g.pixels[index(g, x, y) + 1];

        let oldb = g.pixels[index(g, x, y) + 2];

​

        let newr = (DivideBy255(oldr) * 255) | 0;

        let newg = (DivideBy255(oldg) * 255) | 0;

        let newb = (DivideBy255(oldb) * 255) | 0;

​

        g.pixels[index(g, x, y)] = newr;

        g.pixels[index(g, x, y) + 1] = newg;

        g.pixels[index(g, x, y) + 2] = newb;

​

        for (let _y = 1; _y <= _scale; _y++) {

          for (let _x = 1; _x <= _scale; _x++) {

            g.pixels[index(g, x + _x, y)] += ((oldr - newr) * 7) >> 4;

            g.pixels[index(g, x + _x, y) + 1] += ((oldr - newr) * 7) >> 4;

            g.pixels[index(g, x + _x, y) + 2] += ((oldr - newr) * 7) >> 4;

​

            g.pixels[index(g, x - _x, y + _y)] += ((oldr - newr) * 3) >> 4;

            g.pixels[index(g, x - _x, y + _y) + 1] += ((oldr - newr) * 3) >> 4;

            g.pixels[index(g, x - _x, y + _y) + 2] += ((oldr - newr) * 3) >> 4;

​

            g.pixels[index(g, x, y + _y)] += ((oldr - newr) * 5) >> 4;

            g.pixels[index(g, x, y + _y) + 1] += ((oldr - newr) * 5) >> 4;

            g.pixels[index(g, x, y + _y) + 2] += ((oldr - newr) * 5) >> 4;

​

            g.pixels[index(g, x + _x, y + _y)] += ((oldr - newr) * 1) >> 4;

            g.pixels[index(g, x + _x, y + _y) + 1] += ((oldr - newr) * 1) >> 4;

            g.pixels[index(g, x + _x, y + _y) + 2] += ((oldr - newr) * 1) >> 4;

          }

        }

      }

    }

    g.updatePixels();

  }

}

​

// https://p5js.org/reference/#/p5/drawingContext

function drawShadow(x, y, b, c, g = null) {

  if (g == null) {

    drawingContext.shadowOffsetX = x;

    drawingContext.shadowOffsetY = y;

    drawingContext.shadowBlur = b;// * scale;

    drawingContext.shadowColor = c;

  } else {

    g.drawingContext.shadowOffsetX = x;

    g.drawingContext.shadowOffsetY = y;

    g.drawingContext.shadowBlur = b;// * scale;

    g.drawingContext.shadowColor = c;

  }

}