Skip to content

Free open-source image editor for the browser

11.0 KB
Raw Blame
import { expect, mock, test } from "bun:test";
import { init, target } from "vgpu/mock";
import { createImageLayer, createLayer, createMask } from "@/app/editor/layers";
import { createEditorRenderer } from "@/app/editor/renderer";
import type { BrushStroke, StrokePoint } from "@/core/document";
import { createDocument, createResources, findLayer } from "@/core/document";
import { createImageSource } from "@/core/image";
import { imageFrame } from "@/core/image/frame";
import { type Dab, type DabWalk, walkDabs } from "@/core/renderer/strokes/dabs";
import { setAdjustments } from "@/features/adjustments/edits";
import {
  addLayer,
  deleteLayer,
  extendStroke,
  moveLayer,
  paintStroke,
  setLayer,
  setLayerMask,
  setMaskOperation,
} from "@/features/layers/edits";
import { defaultGradient } from "@/features/layers/gradient";

const stroke: BrushStroke = {
  mode: "paint",
  size: 8,
  feather: 0.5,
  flow: 0.5,
  points: [[10, 10, 1]],
};

test("dabs follow the stroke sixteen times per diameter with interpolated pressure, laying what one every quarter would", () => {
  const wide = { ...stroke, size: 32 };
  // Four dabs stand for one a quarter diameter apart, together leaving as much uncovered.
  const laid = (flow: number) => 1 - (1 - flow) ** (1 / 4);
  expect(walkDabs(wide).dabs).toEqual([[10, 10, 16, laid(0.5)]]);
  const line = walkDabs({
    ...wide,
    points: [
      [10, 10, 1],
      [20, 10, 0.5],
      [30, 10, 0],
    ],
  }).dabs;
  expect(line).toHaveLength(11);
  expect(line[0]).toEqual([10, 10, 16, laid(0.5)]);
  expect(line[5]).toEqual([20, 10, 16, laid(0.25)]);
  expect(line[10][0]).toBeCloseTo(30);
  expect(line[10][3]).toBeCloseTo(0);
  // Small brushes keep a dab per pixel, each laying a share to match.
  const small = walkDabs({
    ...stroke,
    points: [
      [10, 10, 1],
      [20, 10, 1],
    ],
  }).dabs;
  expect(small).toHaveLength(11);
  expect(small[0][3]).toBeCloseTo(1 - 0.5 ** 0.5);
  expect(walkDabs({ ...stroke, points: [] }).dabs).toEqual([]);
});

test("a walk goes on where it stopped as a stroke grows, landing the dabs a whole walk would", () => {
  const points: StrokePoint[] = [
    [10, 10, 1],
    [23, 14, 0.8],
    [31, 30, 0.4],
    [50, 31, 0.9],
    [52, 60, 0.2],
  ];
  const whole = walkDabs({ ...stroke, size: 20, points }).dabs;
  const walked: Dab[] = [];
  let walk: DabWalk | undefined;
  for (let end = 1; end <= points.length; end++) {
    const step = walkDabs(
      { ...stroke, size: 20, points: points.slice(0, end) },
      walk,
    );
    walked.push(...step.dabs);
    walk = step.walk;
  }
  expect(walked).toEqual(whole);
});

test("brush strokes stamp incrementally, replay after undo, and render a proxy during gestures", async () => {
  const gpu = await init();
  const image = target(gpu, { size: [64, 32], format: "rgba16float" });
  const source = createImageSource(image);
  const layers = [createImageLayer("photo", "Photo")] as const;
  const document = createDocument({ frame: imageFrame(image.size), layers });
  const renderer = createEditorRenderer(gpu, source);
  const notify = mock(() => {});
  renderer.subscribe(notify);
  const render = (inputId?: string, interactive = false, density = 1) =>
    renderer.update(
      document.scene.getState(),
      inputId,
      interactive,
      undefined,
      density,
    );
  const inspect = () => renderer.inspect();
  const mask = addLayer(document, createMask({ kind: "brush", strokes: [] }));
  setAdjustments(document, { exposure: 1 }, mask);
  await render();
  // An empty brush covers nothing, so the layer is bypassed without a raster.
  expect(inspect()).toMatchObject({ passes: [], stamped: 0, rasters: [] });
  document.history.begin();
  paintStroke(document, mask, stroke);
  await render(undefined, true);
  expect(inspect()).toMatchObject({
    passes: [`layer/${mask}/mask-raster`],
    stamped: 1,
    // The open stroke waits in the stroke buffer, and the mask reads it laid over its raster in the view.
    rasters: [
      { id: mask, size: [32, 16], format: "r8unorm" },
      { id: "stroke view", size: [32, 16], format: "r8unorm" },
      { id: "stroke buffer", size: [32, 16], format: "r16float" },
    ],
  });
  expect(renderer.coverage(mask)?.target.size).toEqual([32, 16]);
  // A 20 px extension adds twenty dabs; earlier ones are not stamped again.
  extendStroke(document, mask, [[30, 10, 1]]);
  await render(undefined, true);
  expect(inspect().stamped).toBe(21);
  // A quarter of a device pixel per source pixel means a quarter-size render.
  await render(undefined, true, 0.25);
  expect(renderer.outputImage().size).toEqual([16, 8]);
  expect(inspect().stamped).toBe(21);
  document.history.commit();
  // The view shows every source pixel again, so the render returns to full size.
  await render();
  const rendered = notify.mock.calls.length;
  await render();
  expect(notify).toHaveBeenCalledTimes(rendered);
  paintStroke(document, mask, { ...stroke, mode: "erase" });
  await render();
  expect(inspect().stamped).toBe(22);
  // Undo removes the last stroke, which rebuilds the raster from the remaining one.
  document.history.undo();
  await render();
  expect(inspect().stamped).toBe(43);
  expect(findLayer(document.scene.getState().layers, mask)).toMatchObject({
    mask: { strokes: [{ points: [stroke.points[0], [30, 10, 1]] }] },
  });
  document.history.undo();
  await render();
  expect(renderer.coverage(mask)).toBeUndefined();
  expect(renderer.inspect().rasters.some((raster) => raster.id === mask)).toBe(
    true,
  );
  document.history.redo();
  await render();
  expect(renderer.coverage(mask)).toBeDefined();
  const gradient = addLayer(document, createMask(defaultGradient([64, 32])));
  setAdjustments(document, { exposure: -1 }, gradient);
  // Inspecting the mask copies its curve input with coverage as alpha, even at zero opacity.
  setLayer(document, gradient, { opacity: 0 });
  await render(gradient);
  expect(renderer.inputImage(gradient)).toBeDefined();
  expect(inspect().passes).toEqual([
    `layer/${mask}/mask-raster`,
    `layer/${gradient}/exposure`,
    `layer/${gradient}/input`,
  ]);
  setLayer(document, gradient, { opacity: 1 });
  // A brush subtracting from a gradient turns the whole mask into a raster.
  const child = addLayer(
    document,
    createMask({ kind: "brush", strokes: [stroke] }, "subtract"),
    { inside: gradient },
  );
  await render();
  expect(inspect().passes).toContain(`layer/${gradient}/mask-raster`);
  expect(inspect().passes).not.toContain(`layer/${gradient}/mask`);
  await render(gradient);
  expect(inspect().passes).toContain(`layer/${gradient}/raster-input`);
  // The child keeps its own coverage for its preview; the graph folds it into the gradient's.
  expect(renderer.inspect().rasters.map((raster) => raster.id)).toEqual([
    mask,
    child,
    "stroke view",
    "stroke buffer",
  ]);
  expect(renderer.inspect().passes).toEqual(
    expect.arrayContaining([
      `mask/${gradient}/gradient`,
      `mask/${child}/combine`,
    ]),
  );
  expect(renderer.coverage(child)?.target.size).toEqual([32, 16]);
  expect(renderer.coverage(gradient)?.target.size).toEqual([32, 16]);
  setLayer(document, child, { visible: false });
  await render();
  expect(renderer.coverage(child)?.target.size).toEqual([32, 16]);
  expect(renderer.inspect().passes).not.toContain(`mask/${child}/combine`);
  setLayer(document, child, { visible: true, opacity: 0 });
  await render();
  expect(renderer.coverage(child)?.target.size).toEqual([32, 16]);
  setLayerMask(document, child, { kind: "brush", strokes: [] });
  await render();
  expect(renderer.coverage(child)).toBeUndefined();
  document.history.undo();
  setLayer(document, child, { opacity: 1 });
  // Hiding a group bypasses its effect, but preserves the combined coverage shown in its row.
  setLayer(document, gradient, { visible: false });
  await render();
  expect(renderer.coverage(gradient)?.target.size).toEqual([32, 16]);
  expect(renderer.inspect().passes).toContain(`mask/${child}/combine`);
  expect(renderer.inspect().passes).not.toContain(
    `layer/${gradient}/mask-raster`,
  );
  setLayer(document, gradient, { visible: true });
  // Erasing inside the child stamps its own raster only, and the group recombines.
  const stamped = inspect().stamped;
  paintStroke(document, child, { ...stroke, mode: "erase" });
  await render();
  expect(inspect().stamped).toBe(stamped + 1);
  deleteLayer(document, child);
  deleteLayer(document, mask);
  await render();
  expect(inspect().rasters).toEqual([]);
  expect(inspect().passes).toContain(`layer/${gradient}/mask`);
  const invalid = { ...stroke, flow: 2 };
  expect(() =>
    setLayerMask(document, gradient, { kind: "brush", strokes: [invalid] }),
  ).toThrow();
  expect(() => extendStroke(document, gradient, [[1, 1, 1]])).toThrow("brush");
  renderer.dispose();
  document.dispose();
  source.dispose();
  gpu.dispose();
});

test("a brush yet to paint takes no part in its group", async () => {
  const gpu = await init();
  const source = createImageSource(
    target(gpu, { size: [64, 32], format: "rgba16float" }),
  );
  const resources = createResources();
  const sourceId = resources.add(new File([], "photo.png"), source);
  const document = createDocument(
    {
      frame: imageFrame(source.image.size),
      layers: [createImageLayer(sourceId, "Photo")],
    },
    resources,
  );
  const renderer = createEditorRenderer(gpu, source);
  const passes = async () => {
    await renderer.update(document.scene.getState());
    return renderer.inspect().passes;
  };
  try {
    const brush = addLayer(
      document,
      createMask({ kind: "brush", strokes: [] }),
    );
    setAdjustments(document, { exposure: 1 }, brush);
    const gradient = addLayer(
      document,
      createMask(defaultGradient([64, 32]), "subtract"),
      { inside: brush },
    );
    // Taking away from nothing leaves nothing, so the mask is bypassed.
    expect(await passes()).toEqual([]);
    // Adding to it starts from nothing covered.
    setMaskOperation(document, gradient, "add");
    expect(await passes()).toEqual(
      expect.arrayContaining([
        `mask/${brush}/empty`,
        `mask/${gradient}/combine`,
        `layer/${brush}/mask-raster`,
      ]),
    );
    // Intersecting a gradient, it leaves the gradient whole until it paints.
    const shaped = addLayer(document, createMask(defaultGradient([64, 32])));
    setAdjustments(document, { exposure: 1 }, shaped);
    const child = addLayer(
      document,
      createMask({ kind: "brush", strokes: [] }, "intersect"),
      { inside: shaped },
    );
    expect(await passes()).toContain(`layer/${shaped}/mask`);
    paintStroke(document, child, stroke);
    expect(await passes()).toEqual(
      expect.arrayContaining([
        `mask/${shaped}/gradient`,
        `mask/${child}/combine`,
        `layer/${shaped}/mask-raster`,
      ]),
    );
    const effect = addLayer(document, createLayer("exposure"));
    moveLayer(document, child, 0, effect);
    setLayer(document, effect, { visible: false });
    await passes();
    expect(renderer.coverage(child)?.target.size).toEqual([32, 16]);
  } finally {
    renderer.dispose();
    document.dispose();
    gpu.dispose();
  }
});