Spectral reflection

function setup() {

  createCanvas(windowWidth, windowHeight);

  background(0);

  colorMode(HSB, 360, 100, 100);

​

  const bezierFunc = createBezierFromPoints([

        [0,0.1], [0.4, 0.1],[0.2, 0.8], 

        [0.6, 0.9], [0.7, 0.925], [0.8, 0.9], 

        [1.0, 1.0]]);

const range = [-10, 250];

  const rangeW = range[1] - range[0];

  const colorBarH = windowHeight / 4;

  const graphH = (windowHeight - colorBarH) * 0.8;

  const graphStepW = windowWidth / rangeW + 1;

  const y = windowHeight - colorBarH;

  noStroke();

​

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

    const x = windowWidth / rangeW * i;

    fill(range[1] - i, 100, 100);

    rect(x, y, graphStepW, colorBarH);

  }

​

  const bx = windowWidth / rangeW * (range[1] - 240);

  stroke(240, 100, 100);

  line(bx, 0, bx, windowHeight);

  const gx = windowWidth / rangeW * (range[1] - 120);

  stroke(120, 100, 100);

  line(gx, 0, gx, windowHeight);

  const rx = windowWidth / rangeW * (range[1] - 0);

  stroke(0, 100, 100);

  line(rx, 0, rx, windowHeight);

  const substance = [], light = [], reflection = [];

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

    light.push(noise(i / rangeW) + 0.25);

    substance.push(bezierFunc(i / rangeW));

    reflection.push(light[i] * substance[i]);

  }

  colorMode(RGB);

  drawGraph(light, [255, 255, 128], 1);

  drawGraph(substance, [255, 128, 255], 1);

  drawGraph(reflection, [256, 256, 256], 4);

  function drawGraph(data, color, w) {

    noFill();

    stroke(...color); strokeWeight(w);

    beginShape();

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

      const x = windowWidth * i / data.length;

      const py = y - data[i] * graphH;

      vertex(x, py);

    }

    endShape();

  }

}

​

​

function createBezierFromPoints(pts, resolution = 240) {

  let buff = [];

​

  let pi = 0;

  let n = 0;

  let i = 0;

​

  for (let pi = 0; pi < pts.length / 4; pi++) {

    for (let ti = 0; ti <= resolution * 10; ti++) {

      const t = ti / (resolution * 10);

      const x = pow(1 - t, 3) * pts[pi * 3][0] + 3 * pow(1 - t, 2) * t * pts[pi * 3 + 1][0] +

        3 * (1 - t) * pow(t, 2) * pts[pi * 3 + 2][0] + pow(t, 3) * pts[pi * 3 + 3][0];

      const y = pow(1 - t, 3) * pts[pi * 3][1] + 3 * pow(1 - t, 2) * t * pts[pi * 3 + 1][1] +

        3 * (1 - t) * pow(t, 2) * pts[pi * 3 + 2][1] + pow(t, 3) * pts[pi * 3 + 3][1];

      if (x >= i / resolution) {

        buff.push(y);

        i++;

      }

    }

  }

​

  return (t) => {

    t = max(0, min(t, 1));

    let ti = floor(t * buff.length);

    let tr = t * buff.length - ti;

​

    if (ti >= buff.length - 1) {

      return buff[buff.length - 1];

    } else {

      return buff[ti] * (1 - tr) + buff[ti + 1] * tr;

    }

​

    return 1;

  }

}