constructor(_x, _y, _mag, _color, _fun = "linear") {

    this.pos = createVector(_x, _y);

    this.mag = _mag;

    this.color = _color;

    if (_fun == "in") {

      this.getfun = this._quadin;

    } else if (_fun == "out") {

      this.getfun = this._quadout;

    } else if (_fun == "inout") {

      this.getfun = this._quadinout;

    } else if (_fun == "expin") {

      this.getfun = this._expin;

    } else if (_fun == "expout") {

      this.getfun = this._expout;

    } else {

      this.getfun = this._linear;

    }

  }

​

  set(_x, _y) {

    this.pos.set(_x, _y);

  }

​

  get(_x, _y, _rgb = [0, 0, 0]) {

    let d = dist(_x, _y, this.pos.x, this.pos.y);

    let t = map(d, 0, this.mag, 0.0, 1.0, true);

    let tt = this.getfun(t);

    let c = lerpColor(this.color, color(0), tt).levels;

    return [

      min(_rgb[0] + c[0], 255),

      min(_rgb[1] + c[1], 255),

      min(_rgb[2] + c[2], 255),

    ];

  }

​

  _linear(_t) {

    return _t;

  }

​

  _quadin(_t) {

    return _t ** 2;

  }

​

  _quadout(_t) {

    return 1 - (1 - _t) ** 2;

  }

​

  _quadinout(_t) {

    let _in = 2 * _t ** 2;

    let _out = 1 - (-2 * _t + 2) ** 2 / 2;

    return _t < 0.5 ? _in : _out;

  }

​

  _expin(_t) {

    return _t === 0 ? 0 : 2 ** (10 * _t - 10);

  }

​

  _expout(_t) {

    return _t === 1 ? 1 : 1 - 2 ** (-10 * _t);

  }

}

​

let squaresPerRow = 50;

let spacing;

​

let mPoints;

​

function setup() {

  createCanvas(windowWidth, windowHeight);

  noStroke();

  spacing = width / squaresPerRow;

​

  mPoints = [

    new PointLight(

      0 * width,

      0 * height,

      width / 2,

      color(220, 20, 120),

      "inout"

    ),

    new PointLight(

      (1.5 * width) / 3,

      height / 4,

      width / 2,

      color(20, 220, 20),

      "inout"

    ),

    new PointLight(

      (2 * width) / 3,

      (1.5 * height) / 3,

      width / 2,

      color(20, 20, 220),

      "inout"

    ),

  ];

}

​

function draw() {

  background(0);

​

  const rad = radians(frameCount);

  let r = width / 2;

  for (let p = 0; p < mPoints.length; p++) {

    let a = (3 * p + 3) * rad;

    let x = r * cos(a);

    let y = r * sin(a);

​

    let pr = (width / 1.2) * noise(x / 800, y / 800, 3 * p + 3);

    let px = pr * cos(a);

    let py = pr * sin(a);

​

    mPoints[p].set(width / 2 + px, height / 2 + py);

  }

​

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

    for (let x = 0; x < width; x += spacing) {

      let c = [0, 0, 0];

      for (let p = 0; p < mPoints.length; p++) {

        c = mPoints[p].get(x, y, c);

      }

      fill(c);

      rect(x, y, spacing + 1);

    }

  }

}

​