Skip to content

Unlock custom brushes, natural fill effects and intuitive hatching in p5.js

3.3 KB
Raw Blame
// =============================================================================
// Adapter: p5 Compositor Hooks
// =============================================================================

import {
  setCompositorRuntime,
  blitDefaultFramebufferSource,
} from "../../core/compositor_runtime.js";

function clearTarget(renderer, target, isFramebufferTarget) {
  if (!target) return;

  if (isFramebufferTarget(target)) {
    target.draw(() => renderer.clear());
    return;
  }

  const ctx = target.drawingContext;
  ctx.save();
  ctx.setTransform(1, 0, 0, 1, 0, 0);
  ctx.clearRect(0, 0, target.width, target.height);
  ctx.restore();
}

function ensureBlendShaderProgram(renderer, vertSrc, fragSrc) {
  if (!renderer.loaded) {
    renderer.shaderProgram ??= renderer.createShader(vertSrc, fragSrc);
    renderer.loaded = true;
  }
  return renderer.shaderProgram;
}

function ensureBlendSourceFramebuffer(
  renderer,
  currentFramebuffer,
  width,
  height,
  density,
) {
  if (currentFramebuffer?.remove) currentFramebuffer.remove();
  const fb = renderer.createFramebuffer({
    width,
    height,
    density,
    antialias: false,
    depth: false,
    stencil: false,
  });
  return fb;
}

const createFramebuffer = (renderer, options) =>
  renderer.createFramebuffer(options);

function runBlendShaderPass({
  renderer,
  shader,
  source,
  mask,
  color,
  isBrushMask,
  Cwidth,
  Cheight,
  dirtyRect,
  targetIsFramebuffer,
  withScissor,
}) {
  const gl = renderer.drawingContext;
  const hadDepthTest = gl.isEnabled(gl.DEPTH_TEST);

  renderer.push();
  try {
    gl.disable(gl.DEPTH_TEST);
    renderer.translate(0, 0);
    renderer.shader(shader);

    shader.setUniform("u_source", source);
    shader.setUniform("u_targetIsFramebuffer", targetIsFramebuffer);
    shader.setUniform("u_isBrush", isBrushMask);
    shader.setUniform("u_mask", mask);
    shader.setUniform("u_color", color);

    withScissor(
      gl,
      dirtyRect,
      () => {
        renderer.fill(0, 0, 0, 0);
        renderer.noStroke();
        renderer.rect(-Cwidth / 2, -Cheight / 2, Cwidth, Cheight);
      },
      !targetIsFramebuffer,
    );
  } finally {
    try {
      renderer.pop();
    } finally {
      renderer.resetShader();
      if (hadDepthTest) gl.enable(gl.DEPTH_TEST);
    }
  }
}

function blitSourceToFramebuffer(args) {
  if (args.isFramebufferTarget(args.sourceTarget)) {
    (args.sourceTarget.renderer ?? args.renderer)._renderer?.flushDraw?.();
    args.sourceFramebuffer.draw(() => {
      args.withScissor(
        args.renderer.drawingContext,
        args.dirtyRect,
        () => {
          args.renderer.clear();
          args.renderer.push();
          try {
            args.renderer.imageMode(args.renderer.CENTER);
            args.renderer.image(
              args.sourceTarget,
              0,
              0,
              args.Cwidth,
              args.Cheight,
            );
          } finally {
            args.renderer.pop();
          }
        },
        false,
      );
    });
    return args.sourceFramebuffer;
  }

  args.renderer._renderer?.flushDraw?.();
  return blitDefaultFramebufferSource(args);
}

export function initP5CompositorRuntime() {
  setCompositorRuntime({
    clearTarget,
    ensureBlendShaderProgram,
    ensureBlendSourceFramebuffer,
    createFramebuffer,
    runBlendShaderPass,
    blitSourceToFramebuffer,
  });
}