Free open-source image editor for the browser
Add brush masks, gradient tools, proxy rendering, and a Color effect (#32)
Rodrigo Belfiore7fc06bed97af
diff --git a/AGENTS.md b/AGENTS.mdindex 38cd901..e261e67 100644--- a/AGENTS.md+++ b/AGENTS.md@@ -29,7 +29,7 @@ Dependencies between layers point downward. Features do not import each other; `Keep ordinary feature changes in the feature, its tests, and explicit app composition. Change shared primitives when a concrete requirement needs a new capability. Features need neither identical file layouts nor a universal plugin interface. Keep the histogram in its feature.-`src/` holds entrypoints, ambient types, and global styles. Use `@/` across folders and relative imports within a folder. `src/main.tsx` mounts the runtime and providers. `app/editor/modes.tsx` composes modes: a `Panel` uses the shared canvas; a `View` supplies its own viewport.+`src/` holds entrypoints, ambient types, and global styles. Use `@/` across folders and relative imports within a folder. `src/main.tsx` mounts the runtime and providers. `app/editor/tools.tsx` composes the rail: a tool brings a `Canvas` overlay and optional `Options` for the bar over the image while the sidebar always shows the selected layer's controls; a `View` supplies its own viewport. The mask overlay has one writer, `app/editor/mask-overlay.tsx`, which derives it from the selection.## Engine and React@@ -53,6 +53,7 @@ Keep Tailwind classes inline. Reuse presentation through components or repeat cl- The working space is linear Rec.2020 in `rgba16float`. Decoders convert into it; display converts out. Processing outputs preserve the input format and primaries unless the operation explicitly converts them.- The adjustment shader's parameters use UI units. Its fitted constants are calibration data; preserve them when reorganizing code.- Layers process the source in stack order; the image layer's adjustments and tone curve run last, on the composite, so a local exposure sees the light a global exposure would compress.+- Strokes are scene content; the renderer owns their rasterized coverage as a cache and stamps only appended dabs. Open history groups render a reduced proxy; every render image carries `scale`, its source pixels per texel, and shaders that take document coordinates or radii must apply it.- Preserve HDR headroom through exposure, curves, and vibrance. Exposure clips negatives and applies one luminance gain to all channels. `display()` in `core/image/color.wgsl` maps out-of-gamut colors toward their luminance.- TIFF and camera RAW use `raw-webgpu`. OpenLight adapts package resources to document ownership; codec implementation and coverage belong to the package.diff --git a/API.md b/API.mdindex a305458..a974e44 100644--- a/API.md+++ b/API.md@@ -53,6 +53,8 @@ Commands take explicit layer IDs rather than using UI selection. Without an ID,`setVignette({ intensity, softness }, id?)` updates a vignette layer. Values are finite numbers from 0 to 100; defaults are intensity 0 and softness 50. Without an ID, it updates the first vignette or creates one, which starts at intensity 50 unless the change sets it. Intensity 0 bypasses the effect; increasing softness spreads the transition toward the center. The falloff stays centered on the source image before crop and rotation, independently of viewport zoom and pan. Its position among the effect layers determines processing order. It multiplies linear RGB equally and preserves alpha and HDR headroom.+`setFill({ color, blend }, id?)` updates a Color layer: `color` is `#rrggbb` sRGB and `blend` is `normal`, `multiply`, `screen`, `overlay`, `soft-light`, `color`, or `luminosity`. The layer paints that color over the image below it, blended as Photoshop does on encoded values, so inside a brush or gradient mask it paints the mask's coverage; the layer's opacity sets the strength. Without an ID it updates the first Color layer or creates one, which starts at `#f0763c` in Normal.+For RAW sources, `setWhiteBalance({ temperature, tint })` sets absolute Kelvin and DNG tint, preserving unspecified values. Temperature accepts 2000–25000 K and tint accepts -150–150, extending either range to include the file's As Shot value. `setWhiteBalance()` restores that value (the decoder's daylight fallback if camera multipliers are unavailable). Non-RAW sources and invalid values throw. Incremental temperature/tint remain separate RGB adjustments.Edits update the scene and history synchronously. Rendering may finish later, particularly RAW development. Tests should wait for visible results; `exportImage()` renders and waits for its captured scene independently of the preview.@@ -69,11 +71,11 @@ Direct mask children of another mask modify coverage instead of processing image| Method | Behavior || --- | --- |-| `addLayer(kind, placement?)` | Adds `"exposure"`, `"color-mixer"`, `"details"`, `"vignette"`, or `"mask"`; selects and returns its ID. `{ inside: id }` appends a child to a processing layer; `{ above: id }` inserts directly above that layer among its siblings; without a placement, the layer goes on top of the root stack. Exposure starts at +1 EV, Vignette at intensity 50; Color Mixer, Details, and masks start neutral. |+| `addLayer(kind, placement?)` | Adds `"exposure"`, `"color-mixer"`, `"details"`, `"vignette"`, `"fill"`, or `"mask"`; selects and returns its ID. `{ inside: id }` appends a child to a processing layer; `{ above: id }` inserts directly above that layer among its siblings; without a placement, the layer goes on top of the root stack. Exposure starts at +1 EV, Vignette at intensity 50; Color Mixer, Details, and masks start neutral. || `selectLayer(id)` | Selects any layer. || `setLayer(id, change)` | Updates processing-layer `name`, `visible`, or `opacity` (0–1). || `setExposure(id, value)` | Sets an Exposure layer to -5…5 EV. |-| `setLayerMask(id, mask)` | Replaces a mask layer's gradient: `{ kind: "linear", start, end }` or `{ kind: "radial", center, radius, angle, feather }`. Geometry uses source pixels; radial angle is degrees and feather is 0–1. |+| `setLayerMask(id, mask)` | Replaces a mask layer's mask: `{ kind: "linear", start, end }`, `{ kind: "radial", center, radius, angle, feather }`, or `{ kind: "brush", strokes }`. Geometry uses source pixels; radial angle is degrees and feather is 0–1. || `setMaskOperation(id, operation)` | Sets `"add"` or `"subtract"`; used when this mask is inside another mask. || `duplicateLayer(id)` | Copies a processing layer and its children above itself with independent IDs; selects and returns the new ID. || `moveLayer(id, index, parentId?)` | Moves to a final sibling index, bottom to top. Omit the parent for the root stack, where index 0 is reserved for the image. Image parents, cycles, and third-level nesting are rejected. |@@ -81,11 +83,15 @@ Direct mask children of another mask modify coverage instead of processing imageA linear gradient has full coverage at `start`, zero at `end`; its points must be finite and distinct. A radial gradient covers the ellipse inside `radius`, with positive radii and a feathered falloff toward its edge. Crop, rotation, and viewport navigation do not move it within the document.-The sidebar keeps four sections in every mode: output histogram, layers, controls, and footer. Layers and controls scroll independently; the histogram and footer stay fixed. **L** draws a linear mask; **R** draws a radial mask. Selected masks stay editable: drag the center to move, guides to resize or rotate, and the radial inner handle or Feather slider to soften its edge. Shift constrains drawing; Escape cancels the gesture; Delete/Backspace removes the selected mask. Each gesture is one undo. A new mask shows a red overlay of its coverage until Enter keeps it, Escape removes it, or its first adjustment; **O** and the Overlay button toggle the overlay for any selected mask, and it also shows while drawing or dragging a guide. Add/Subtract menus accept either gradient shape. **+** adds an effect, inside a selected top-level mask or above the selected sibling. Eye buttons toggle visibility; the inspector edits opacity. Drag a layer name to reorder (insertion line) or nest (highlighted row); the base stays locked and nesting is limited to two levels. Double-click a name to rename; the row menu also duplicates, deletes, reorders, or reparents. Image import still replaces the document; multiple image layers and additional blend modes are not implemented.+A brush mask is a list of strokes. Each stroke has `mode` (`"paint"` or `"erase"`), `size` (diameter in source pixels), `feather` and `flow` (0–1), and `points`, each `[x, y, pressure]` in source pixels with pressure 0–1. Dabs land every quarter diameter along the points; a paint stroke adds `flow × pressure` of the remaining coverage under each dab, and an erase stroke removes that share of the existing coverage. The renderer rasterizes strokes into a cached coverage texture at source resolution and only stamps new points, so appending to the last stroke is cheap and undo replays the rest. A brush inside another mask keeps its own coverage, paint and erase strokes alike, which the mask adds or subtracts scaled by the brush layer's opacity. A mask with no painted coverage and nothing added to it is bypassed.++The sidebar always shows the output histogram, the selected layer's controls, and the layer stack; layers and controls scroll independently. The rail holds tools: **A** Adjust, **B** Brush, **L** Linear gradient, **R** Radial gradient, and **C** Crop; **E** opens Export from the header. A selected mask is *active*: the sidebar shows its adjustments and the bar its opacity. It is *edited* only while a shape tool is on the rail, which shows its guides or brush and the overlay; Adjust leaves the canvas to pan and zoom. Selecting a mask in the stack arms the tool of its shape; selecting the image or an effect returns to Adjust. **Enter**, or **Escape** with no drag in progress, leaves one level at a time: a shape tool returns to Adjust with the mask still selected, so its sliders stay at hand without guides over the image, and in Adjust the selection climbs to the parent mask, then to the image with its global controls. The shape's key or the mask's row enters editing again. Enter on a focused button stays its click. The bar over the image edits the active tool and the selected layer: the tool's options, then the layer's opacity, Overlay, and a radial mask's Feather or a child mask's operation. It never wraps: when the canvas is narrow it drops the slider bars, then moves the layer options and finally everything into a menu at its end. Dragging with a gradient tool draws a new mask above the selection; the tool stays active, and **Alt** while starting the drag subtracts the gradient from the selected mask instead. Choosing the Brush tool creates an empty brush mask above the selection at once, so adjustments made before the first stroke belong to it; leaving the tool while that mask has no strokes and nothing else changed removes it together with its history entry. A brush stroke paints into the selected brush mask, or starts a new brush mask. Creating inside a mask happens in the layer stack: each root mask row has Add and Subtract menus that choose a shape and nest the next mask inside it, and **Delete** removes the selected layer with any tool. The brush bar sets size, feather, flow, and paint or erase; **[** and **]** resize, holding **Alt** erases and shows Erase pressed, and **Escape** cancels the stroke. The brush cursor previews the dab's feather. Creating the mask and each stroke are separate undo steps.++The red overlay shows a mask being edited that does not change the image yet: a gradient being drawn, or the selected mask while its adjustments and curve are default and its effects are off. Once the mask applies an effect, the image itself shows it, so painting continues without the tint. The Overlay button shows whether the overlay is visible; it and **O** show or hide the overlay for the selected mask in any tool, until another layer is selected. The tint follows the layer's opacity, which scales the mask's coverage. The curve's input histogram weighs pixels by that coverage, so it describes what the curve affects; it ignores opacity and stays available while the layer is hidden or at zero opacity. Selected masks stay editable: drag the center to move, guides to resize or rotate, and the radial inner handle or Feather slider to soften its edge. Shift constrains drawing; Escape cancels the gesture; Delete/Backspace removes the selected mask. Each gesture is one undo. A new mask shows a red overlay of its coverage until Enter leaves editing or its first adjustment; the overlay also shows while drawing or dragging a guide. Add/Subtract menus accept either gradient shape. **+** adds an effect, inside a selected top-level mask or above the selected sibling. Eye buttons toggle visibility; the inspector edits opacity. Drag a layer name to reorder (insertion line) or nest (highlighted row); the base stays locked and nesting is limited to two levels. Double-click a name to rename; the row menu also duplicates, deletes, reorders, or reparents. Image import still replaces the document; multiple image layers and additional blend modes are not implemented.## History-Each content change creates an undo step unless a group is open. No-op edits add no history. Preview changes stay outside history. Groups do not nest.+Each content change creates an undo step unless a group is open. No-op edits add no history. Preview changes stay outside history. Groups do not nest. While a group is open, the preview renders a reduced proxy of the image at the display's scale; committing or cancelling renders the full image again.| Method | Behavior || --- | --- |@@ -134,6 +140,6 @@ The image renders at the document dimensions and downsamples to `longEdge` with## State-`getState()` returns a detached snapshot containing `file`, `documentId`, `scene`, `selectedLayerId`, `size`, `frame`, `adjustments`, `whiteBalance`, `details`, `toneCurve`, `colorMixer`, `vignette`, `preview`, and `history`. `scene` contains `frame` and the layer tree. The top-level adjustment, tone-curve, and white-balance values come from `scene.layers[0]`; details, color-mixer, and vignette values describe the first matching root layer from the bottom, or its defaults. `colorMixer` contains eight-value `hue`, `saturation`, and `luminance` arrays in the color order above, defaulting to zero. `whiteBalance` contains absolute temperature/tint for RAW sources and is undefined for other sources. `file` is the filename, and `history` contains `undoCount` and `redoCount`.+`getState()` returns a detached snapshot containing `file`, `documentId`, `scene`, `selectedLayerId`, `size`, `frame`, `adjustments`, `whiteBalance`, `details`, `toneCurve`, `colorMixer`, `vignette`, `preview`, and `history`. `scene` contains `frame` and the layer tree. The top-level adjustment, tone-curve, and white-balance values come from `scene.layers[0]`; details, color-mixer, and vignette values describe the first matching root layer from the bottom, or its defaults. `colorMixer` contains eight-value `hue`, `saturation`, and `luminance` arrays in the color order above, defaulting to zero. `whiteBalance` contains absolute temperature/tint for RAW sources and is undefined for other sources. `file` is the filename, and `history` contains `undoCount`, `redoCount`, and `editing`, which is true while a group is open.Without a document, `documentId`, `size`, `frame`, and `preview` are undefined. Adjustments, details, and the tone curve use their defaults, and history counts are zero. Mutating the snapshot does not edit the document.diff --git a/CONTEXT.md b/CONTEXT.mdindex f1241ba..f309d50 100644--- a/CONTEXT.md+++ b/CONTEXT.md@@ -6,10 +6,11 @@ OpenLight edits documents containing image content and adjustments.| --- | --- || **Document** | An independent editing session with its own canvas, history, and resources. Opening an image creates a document containing that image. || **Scene** | The document's serializable content: canvas geometry, image-source references, and adjustments. Files and GPU resources live outside it. |-| **Layer** | A source, effect, or mask in the composition. Image layers own basic adjustments; effects process the image below; masks scope their basic adjustments and child effects. Linear and radial child masks add or subtract coverage. Layers compose render nodes without owning textures. |+| **Layer** | A source, effect, or mask in the composition. Image layers own basic adjustments; effects process the image below; masks scope their basic adjustments and child effects. Linear, radial, and brush child masks add or subtract coverage. Layers compose render nodes without owning textures. |+| **Stroke** | One brush drag on a brush mask: paint or erase, size, feather, flow, and points with pressure in source pixels. Strokes are content; the renderer rasterizes them into a cached coverage texture. || **Image source** | An image used as input to the document's composition. It is content within a document. || **Edit** | One reversible content change. A continuous slider or curve drag is one edit, as is importing a set of adjustments. || **Workspace** | The open-document session. It currently holds at most one document, replaced when another image is opened. |-| **Mode** | An editor task area: Adjust, Crop, or Export. Switching modes changes tools and panels, not the document. |+| **Tool** | What a drag on the canvas does: Brush paints, Linear and Radial gradient draw masks and edit the selected gradient's guides, Adjust leaves the canvas to pan and zoom. Crop and Export bring their own view. Switching tools never changes the sidebar; Brush creates its mask on entry and removes it again if it leaves untouched. A selected mask is *active*; it is *edited* only while a shape tool is on. |Use these names consistently in code, UI text, and documentation.diff --git a/PERFORMANCE.md b/PERFORMANCE.mdindex cdcbe6c..65f7194 100644--- a/PERFORMANCE.md+++ b/PERFORMANCE.md@@ -27,6 +27,10 @@ The graph executes each reachable node once and reuses compatible targets afterLayer composition builds subgraphs without allocating textures for containers. `mixAdjustment` combines an effect with its input using opacity and optional analytical gradients in document coordinates; Add/Subtract child masks use a small storage buffer in that same pass, without mask textures; it preserves input alpha. Node names include stable layer IDs. The display pass tints the previewed mask from the same analytical coverage, so the overlay adds no processing pass. Removed layers release their graph-owned instance handles and storage buffers through `release(prefix)`; bypassed layers keep their instances. vgpu's internal pipeline and uniform caches remain GPU-owned until GPU disposal.+A mask that paints with a brush is rasterized instead: [`createMaskRaster`](src/core/renderer/mask/index.ts) keeps one `r8unorm` texture per brush with strokes at source resolution, outside the graph, whether the brush is a mask of its own or a child of one. Stroke dabs stamp in scissored chunks of 64, one frame each so buffer writes stay ordered; when a scene only appends strokes or points to a brush, only the new dabs stamp, and any earlier change replays that brush's strokes. A mask shaped by children combines its own gradient or brush with theirs, in stored order and scaled by their opacity, into a second texture named `<id>/group` in `inspect()`, rebuilt with one pass per part whenever any of them changes; a brush without children samples its own texture directly. The mix pass then samples the combined texture under the name `layer/<id>/raster` rather than `layer/<id>/mix`, the display overlay samples a row's own or combined texture, and thumbnails do the same. `inspect()` reports `stamped` dabs and the live `rasters`. A mask with no coverage is bypassed without a texture.++Interactive edits render a proxy. While a history group is open, the renderer's `update(scene, inputId, interactive)` reduces the source by an integer factor chosen from `setDisplayScale`, the device pixels shown per source pixel, so the composition runs at about display resolution; the reduced source is cached until the source, factor, or RAW development changes. Every `RenderImage` carries `scale`, its source pixels per texel, which the mix pass, unsharp masking, and the transform pass use to keep gradients, radii, and crops in document units. Committing or cancelling the group renders the full image, and export always renders in full. Measure interactive workloads with the proxy factor stated, since a factor of 4 cuts processed pixels sixteenfold.+For GPU timing, enable the optional `timestamp-query` device feature, create a vgpu `timer(gpu)`, and pass it to the graph or `createEditorRenderer`. The graph instruments every node centrally. Results arrive asynchronously through `timer.onResults`; the caller disposes the timer. `gpu.settled()` covers timing readbacks in isolated runs or teardown. Do not wait after individual nodes during interactive editing. See the [vgpu guide](https://github.com/vercel-labs/vgpu/blob/main/docs/topics/performance-playbook.docs.md#13-time-passes-before-optimizing-timer).The [benchmark](tests/rendering-benchmark.ts) measures uninstrumented repeated rendering, then profiles nodes in a separate run. Report bypasses and missing samples explicitly. Sum a feature's pass durations only when every pass was measured. The graph works without React and without profiling support; it currently accepts programmatically composed nodes, not user-editable or serialized graphs.@@ -41,6 +45,6 @@ After [browser setup](CONTRIBUTING.md#browser-setup), run `bun run test:browserResults and rendered PNGs are written under `test-results/benchmarks`; keep generated artifacts out of Git. JSON includes environment details, samples, median/p95, setup, first render, completed-render latency, intermediate texture storage, and per-node GPU timestamps when supported. Timestamp profiling runs separately from the latency comparison. Decoding, display, readback, and image encoding run outside the measured loop. Software-adapter results describe that backend only. A hardware measurement requires a browser configuration that does not force SwiftShader; record the adapter actually used.-Compare `pipeline` with `pipeline-input` to measure the curve input histogram: the latter retains the image entering the base curve and computes its histogram. Completed latency includes histogram compute and its buffer copy; per-node timestamps cover only image processing.+Compare `pipeline` with `pipeline-input` to measure the curve input histogram: the latter retains the image entering the base curve and computes its histogram. Completed latency includes histogram compute and its buffer copy; per-node timestamps cover only image processing. Inspecting a mask adds one pass, `layer/<id>/input` or `layer/<id>/raster-input`, which copies the curve's input with the mask's coverage as alpha; the histogram weighs votes by alpha. A hidden or zero-opacity layer keeps that pass while inspected and drops its mix pass.For revision comparisons, use identical fixtures, settings, sampling, and browser configuration in both checkouts. The benchmark is opt-in and excluded from the regular test suite; correctness remains covered by GPU pixel tests and the editing session.diff --git a/README.md b/README.mdindex d1c5c0d..1d49943 100644--- a/README.md+++ b/README.md@@ -19,10 +19,17 @@ Image processing runs on your own GPU with WebGPU. Photos never leave your devic**Layers and masks**-- Draggable effect layers: Details, Exposure, Color Mixer, and Vignette.+- Draggable effect layers: Details, Exposure, Color Mixer, Vignette, and Color, which paints one color with Photoshop blend modes.- Linear and radial masks with their own adjustments and child effects.- Add and Subtract submasks to shape a mask's coverage.+**Tools**++- Brush, linear, and radial gradient tools on the rail draw masks; their options sit in the bar over the image.+- Brush masks with size, feather, flow, pen pressure, and Alt to erase.+- The mask overlay shows until a mask changes the image, then the image shows the mask; the Overlay button shows or hides it.+- Edits preview at a reduced resolution while you drag, then render in full.+**Compose**- Crop with aspect presets, rotate, straighten, and flip.diff --git a/public/og.png b/public/og.pngindex 07b024b..2d29411 100644Binary files a/public/og.png and b/public/og.png differdiff --git a/src/app/controls.ts b/src/app/controls.tsindex 7cbee36..6360d92 100644--- a/src/app/controls.ts+++ b/src/app/controls.ts@@ -9,7 +9,8 @@ import { createLoaderRegistry } from "@/app/loaders/registry";import type {Adjustments,Details,- Gradient,+ Fill,+ Mask,Preview,ProcessingLayer,ToneCurve,@@ -27,6 +28,7 @@ import {} from "@/features/color-mixer/model";import { setDetails } from "@/features/details/edits";import { defaultDetails } from "@/features/details/model";+import { setFill } from "@/features/fill/edits";import {addLayer,deleteLayer,@@ -99,6 +101,10 @@ export function createControls(gpu: Gpu, workspace: Workspace) {setVignette(document, change, id),);},+ setFill(change: Partial<Fill>, id?: string) {+ const document = workspace.getDocument();+ editEffect(document, "fill", id, (id) => setFill(document, change, id));+ },addLayer(kind: ProcessingLayer["kind"], placement?: LayerPlacement) {const document = workspace.getDocument();if (kind !== "mask") {@@ -114,7 +120,7 @@ export function createControls(gpu: Gpu, workspace: Workspace) {setLayer(workspace.getDocument(), id, change),setExposure: (id: string, exposure: number) =>setExposure(workspace.getDocument(), id, exposure),- setLayerMask: (id: string, mask: Gradient) =>+ setLayerMask: (id: string, mask: Mask) =>setLayerMask(workspace.getDocument(), id, mask),setMaskOperation: (id: string, operation: "add" | "subtract") =>setMaskOperation(workspace.getDocument(), id, operation),diff --git a/src/app/editor/adjust/index.tsx b/src/app/editor/adjust/index.tsxindex b42e5c0..399ab0f 100644--- a/src/app/editor/adjust/index.tsx+++ b/src/app/editor/adjust/index.tsx@@ -9,6 +9,7 @@ import { adjustmentTarget, type Layer, type ToneCurve } from "@/core/document";import { AdjustmentControls } from "@/features/adjustments/controls";import { ColorMixerControls } from "@/features/color-mixer/controls";import { DetailsControls } from "@/features/details/controls";+import { FillControls } from "@/features/fill/controls";import { Histogram } from "@/features/histogram";import { createHistogram } from "@/features/histogram/histogram";import { setExposure } from "@/features/layers/edits";@@ -78,6 +79,8 @@ function SelectedControls({ layer }: { layer: Layer }) {return <ColorMixerControls id={layer.id} mixer={layer.colorMixer} />;case "vignette":return <VignetteControls id={layer.id} vignette={layer.vignette} />;+ case "fill":+ return <FillControls id={layer.id} fill={layer.fill} />;case "exposure":return (<section className="p-3">diff --git a/src/app/editor/canvas.tsx b/src/app/editor/canvas.tsxindex 9915902..d7e38d6 100644--- a/src/app/editor/canvas.tsx+++ b/src/app/editor/canvas.tsx@@ -1,17 +1,19 @@+import type { ReactNode } from "react";import { Image } from "@/components/editor/image";import { useScene } from "@/components/editor/session";import { EditorViewport } from "@/components/editor/viewport";-import { GradientOverlay } from "@/features/layers/gradient-overlay";-import { useGradientTool } from "@/features/layers/gradient-tool";-import { LayerToolbar } from "@/features/layers/toolbar";+import { CanvasToolbar } from "@/features/layers/toolbar";import { ComparisonDivider } from "./comparison-divider";+import { MaskOverlaySync } from "./mask-overlay";-export function EditorCanvas() {- const tool = useGradientTool();- let gradientKey = "selection";- if (tool.target) {- gradientKey = `new/${tool.target.shape}/${tool.target.parentId ?? "root"}/${tool.target.operation}`;- }+/** The shared canvas; the active tool supplies the overlay on it and the options in the bar above it. */+export function EditorCanvas({+ tools,+ options,+}: {+ tools: ReactNode;+ options?: ReactNode;+}) {const size = useScene((scene) => scene.frame.size);return (<EditorViewport@@ -19,10 +21,11 @@ export function EditorCanvas() {overlay={<><ComparisonDivider />- <LayerToolbar />+ <CanvasToolbar>{options}</CanvasToolbar>+ <MaskOverlaySync /></>}- tools={<GradientOverlay key={gradientKey} />}+ tools={tools}><Image original="originalImage" /></EditorViewport>diff --git a/src/app/editor/empty.tsx b/src/app/editor/empty.tsxindex d1838f8..3134b10 100644--- a/src/app/editor/empty.tsx+++ b/src/app/editor/empty.tsx@@ -9,15 +9,15 @@ import { createDocument, createResources } from "@/core/document";import { createImageSource } from "@/core/image";import { accept } from "@/core/image/decode";import { imageFrame } from "@/core/image/frame";-import { GradientProvider } from "@/features/layers/gradient-tool";+import { MaskToolProvider } from "@/features/layers/mask-tool";import { AdjustPanel } from "./adjust";import Backdrop from "./backdrop";import { EditorHeader } from "./header";import { createImageLayer } from "./layers";-import { ModeTabList } from "./mode-rail";-import { modes } from "./modes";import { createEditorRenderer } from "./renderer";import { EditorSidebar } from "./sidebar";+import { ToolTabList } from "./tool-rail";+import { tools } from "./tools";type OpenProps = { onOpen: (files: File[]) => void };@@ -30,7 +30,7 @@ function OpenImage({ onOpen }: OpenProps) {<buttontype="button"onClick={() => input.current?.click()}- className="cursor-pointer text-neutral-200 underline decoration-neutral-600 underline-offset-4 transition-colors hover:decoration-neutral-200 focus-visible:outline-2 focus-visible:outline-offset-3 focus-visible:outline-neutral-400"+ className="cursor-pointer text-neutral-200 underline decoration-neutral-600 underline-offset-4 transition-colors hover:decoration-neutral-200 focus-visible:outline-1 focus-visible:outline-offset-2 focus-visible:outline-neutral-400/80">choose a file</button>@@ -105,10 +105,10 @@ export function EmptyEditor({return (<DocumentProvider value={document}><RendererProvider createRenderer={createEditorRenderer}>- <GradientProvider onCreate={() => {}}>+ <MaskToolProvider onCreate={() => {}}><EditorHeader file={state.file} /><div className="flex min-h-0 flex-1 flex-col md:flex-row">- <ModeTabList selected={modes[0]} />+ <ToolTabList selected={tools[0]} /><div className="relative isolate grid min-h-0 min-w-0 flex-1 place-content-center justify-items-center gap-3 overflow-hidden bg-[radial-gradient(circle,#292929,#131313_55%)] p-6"><Backdrop /><Status state={state} onOpen={onOpen} />@@ -117,7 +117,7 @@ export function EmptyEditor({<AdjustPanel /></EditorSidebar></div>- </GradientProvider>+ </MaskToolProvider></RendererProvider></DocumentProvider>);diff --git a/src/app/editor/export/index.tsx b/src/app/editor/export/index.tsxindex e1f7a48..7c2ecf9 100644--- a/src/app/editor/export/index.tsx+++ b/src/app/editor/export/index.tsx@@ -6,8 +6,8 @@ import { EditorPanel, PanelHeader } from "@/components/editor/panel";import { useDocument, useScene } from "@/components/editor/session";import { EditorViewport } from "@/components/editor/viewport";import Button from "@/components/ui/button";-import { Field } from "@/components/ui/field";import { ScrubInput } from "@/components/ui/scrub-input";+import { Select } from "@/components/ui/select";import { Slider } from "@/components/ui/slider";import Spinner from "@/components/ui/spinner";import type { Point } from "@/core/image/frame";@@ -70,25 +70,23 @@ function FormatSelect({}) {return (<div className="space-y-2">- <label className="flex items-center justify-between text-neutral-400">+ <div className="flex items-center justify-between text-neutral-400">Format- <Field className="relative w-28">- <select- aria-label="Format"- value={value.id}- className="w-full cursor-pointer bg-transparent px-1 text-neutral-100 outline-none [color-scheme:dark]"- onChange={(event) =>- onChange(formats[event.currentTarget.selectedIndex])- }- >- {formats.map((format) => (- <option key={format.id} value={format.id}>- {format.label}- </option>- ))}- </select>- </Field>- </label>+ <Select+ aria-label="Format"+ value={value.id}+ className="w-28"+ onChange={(event) =>+ onChange(formats[event.currentTarget.selectedIndex])+ }+ >+ {formats.map((format) => (+ <option key={format.id} value={format.id}>+ {format.label}+ </option>+ ))}+ </Select>+ </div><p className="text-neutral-500">{value.description}</p></div>);diff --git a/src/app/editor/index.tsx b/src/app/editor/index.tsxindex 444e09b..dd7bdaa 100644--- a/src/app/editor/index.tsx+++ b/src/app/editor/index.tsx@@ -1,109 +1,131 @@+import type { ReactNode } from "react";import type { Workspace } from "@/app/workspace";import { RendererProvider } from "@/components/editor/pipeline";import { DocumentProvider, useDocument } from "@/components/editor/session";import Button from "@/components/ui/button";-import type { Gradient } from "@/core/document";-import { findLayer } from "@/core/document";+import type { Mask } from "@/core/document";+import { findLayer, locateLayer } from "@/core/document";+import { BrushProvider } from "@/features/layers/brush-tool";import { addLayer } from "@/features/layers/edits";-import {- GradientProvider,- useGradientTool,-} from "@/features/layers/gradient-tool";+import { MaskToolProvider, type Nesting } from "@/features/layers/mask-tool";import { useShortcuts } from "@/hooks/use-shortcuts";+import { AdjustPanel } from "./adjust";import { EditorCanvas } from "./canvas";import { ComparisonControl } from "./comparison-control";import { EmptyEditor } from "./empty";import { EditorHeader } from "./header";import { HistoryControls } from "./history";import { createMask } from "./layers";-import { ModeRail } from "./mode-rail";-import { type Mode, ModeProvider, modes, useMode } from "./modes";import { createEditorRenderer } from "./renderer";import { EditorSidebar } from "./sidebar";+import { ToolRail } from "./tool-rail";+import { exportTool, ToolProvider, tools, useTool } from "./tools";-/** A View replaces the canvas and sidebar; a Panel fills the sidebar beside the canvas. */-function ModeView() {- const { mode, setMode } = useMode();- const tool = useGradientTool();- useShortcuts({- l: () => {- setMode(modes[0]);- tool.draw();- },- r: () => {- setMode(modes[0]);- tool.draw("radial");- },- });+/** A View replaces the canvas and sidebar; otherwise the tool's Canvas and Options join the shared canvas. */+function ToolView() {+ const { tool, setTool } = useTool();+ const document = useDocument();+ // Enter and Escape leave one level: shape tools return to Adjust, where the selection climbs to the image.+ function up() {+ const layers = document.scene.getState().layers;+ const parent =+ locateLayer(layers, document.selection.getState().layerId)?.parent ??+ layers[0];+ document.selectLayer(parent.id);+ }+ useShortcuts(+ "Canvas" in tool || "View" in tool ? {} : { enter: up, escape: up },+ );function close() {- setMode(modes[0]);+ setTool(tools[0]);if (window.document.activeElement instanceof HTMLElement) {window.document.activeElement.blur();}}- if ("View" in mode) {- return <mode.View onClose={close} />;+ if ("View" in tool) {+ return <tool.View onClose={close} />;}return (<>- <EditorCanvas />+ <EditorCanvas+ tools={"Canvas" in tool ? <tool.Canvas key={tool.id} /> : undefined}+ options={"Options" in tool ? <tool.Options /> : undefined}+ /><EditorSidebar>- <mode.Panel />+ <AdjustPanel /></EditorSidebar></>);}function ExportButton() {- const { mode, setMode } = useMode();- const target: Mode = mode.id === "export" ? modes[0] : modes[2];+ const { tool, setTool } = useTool();+ const exporting = tool === exportTool;return (<Button- aria-pressed={mode.id === "export"}+ aria-pressed={exporting}title="Export (E)"className="ml-1 aria-pressed:bg-neutral-600"- onClick={() => setMode(target)}+ onClick={() => setTool(exporting ? tools[0] : exportTool)}>Export</Button>);}-function DocumentEditor({ file }: { file: string }) {+/** Mask creation and the tool that draws a shape are wired here, where features meet the rail. */+function MaskTools({ children }: { children: ReactNode }) {const document = useDocument();- function addMask(- mask: Gradient,- target: { parentId?: string; operation: "add" | "subtract" },- ) {+ const { setTool } = useTool();+ function addMask(mask: Mask, nesting: Nesting) {const scene = document.scene.getState();const selected = document.selection.getState().layerId;// A new top-level mask goes above the selection's root ancestor.const root =scene.layers.find((item) => findLayer([item], selected)) ??scene.layers[0];- const placement = target.parentId- ? { inside: target.parentId }+ const placement = nesting.parentId+ ? { inside: nesting.parentId }: { above: root.id };- addLayer(document, createMask(mask, target.operation), placement);+ addLayer(document, createMask(mask, nesting.operation), placement);}return (- <GradientProvider onCreate={addMask}>- <ModeProvider>- <EditorHeader file={file}>- <HistoryControls />- <hr- aria-orientation="vertical"- className="mx-1 h-4 w-px border-0 bg-neutral-600"- />- <ComparisonControl />- <ExportButton />- </EditorHeader>- <div className="flex min-h-0 flex-1 flex-col md:flex-row">- <ModeRail />- <ModeView />- </div>- </ModeProvider>- </GradientProvider>+ <MaskToolProvider+ onCreate={addMask}+ onTool={(shape) => {+ const tool = tools.find((entry) => entry.id === shape);+ if (tool) {+ setTool(tool);+ }+ }}+ onDone={() => setTool(tools[0])}+ >+ {children}+ </MaskToolProvider>+ );+}++function DocumentEditor({ file }: { file: string }) {+ return (+ <ToolProvider>+ <MaskTools>+ <BrushProvider>+ <EditorHeader file={file}>+ <HistoryControls />+ <hr+ aria-orientation="vertical"+ className="mx-1 h-4 w-px border-0 bg-neutral-600"+ />+ <ComparisonControl />+ <ExportButton />+ </EditorHeader>+ <div className="flex min-h-0 flex-1 flex-col md:flex-row">+ <ToolRail />+ <ToolView />+ </div>+ </BrushProvider>+ </MaskTools>+ </ToolProvider>);}diff --git a/src/app/editor/layers.ts b/src/app/editor/layers.tsindex c3baf68..0574049 100644--- a/src/app/editor/layers.ts+++ b/src/app/editor/layers.ts@@ -1,15 +1,17 @@import type {EditorDocument,EffectLayer,- Gradient,ImageLayer,Layer,+ Mask,MaskLayer,+ ProcessingLayer,} from "@/core/document";import type { WhiteBalance } from "@/core/image";import { defaultAdjustments } from "@/features/adjustments/model";-import { defaultMixer } from "@/features/color-mixer/model";+import { defaultMixer, isNeutral } from "@/features/color-mixer/model";import { defaultDetails } from "@/features/details/model";+import { defaultFill } from "@/features/fill/model";import { defaultCurve } from "@/features/tone-curves/curve";function baseLayer() {@@ -52,19 +54,27 @@ export function createLayer(kind: EffectLayer["kind"]): EffectLayer {};case "color-mixer":return { ...base, kind, name: "Color Mixer", colorMixer: defaultMixer };+ case "fill":+ return { ...base, kind, name: "Color", fill: { ...defaultFill } };default:throw Error("Unknown layer kind.");}}+const maskNames: Record<Mask["kind"], string> = {+ linear: "Linear Gradient",+ radial: "Radial Gradient",+ brush: "Brush",+};+export function createMask(- mask: Gradient,+ mask: Mask,operation: MaskLayer["operation"] = "add",): MaskLayer {return {...baseLayer(),kind: "mask",- name: mask.kind === "radial" ? "Radial Gradient" : "Linear Gradient",+ name: maskNames[mask.kind],operation,adjustments: { ...defaultAdjustments },toneCurve: defaultCurve,@@ -72,6 +82,37 @@ export function createMask(};}+function effectNeutral(layer: ProcessingLayer): boolean {+ if (!layer.visible || layer.opacity === 0) {+ return true;+ }+ switch (layer.kind) {+ case "details":+ return layer.details.clarity === 0 && layer.details.sharpening === 0;+ case "exposure":+ return layer.exposure === 0;+ case "vignette":+ return layer.vignette.intensity === 0;+ case "color-mixer":+ return isNeutral(layer.colorMixer);+ case "fill":+ return false;+ case "mask":+ return true;+ }+}++/** A mask that changes nothing yet: default adjustments and curve, and no active child effect. */+export function maskNeutral(layer: MaskLayer) {+ return (+ Object.entries(defaultAdjustments).every(+ ([key, value]) => Reflect.get(layer.adjustments, key) === value,+ ) &&+ layer.toneCurve.every((point) => point.x === point.y) &&+ layer.children.every(effectNeutral)+ );+}+/** The first root effect of a kind. */export function findEffect<K extends EffectLayer["kind"]>(layers: readonly Layer[],diff --git a/src/app/editor/mask-overlay.tsx b/src/app/editor/mask-overlay.tsxnew file mode 100644index 0000000..5c7e451--- /dev/null+++ b/src/app/editor/mask-overlay.tsx@@ -0,0 +1,80 @@+import { useEffect } from "react";+import { useDocument } from "@/components/editor/session";+import { useViewport } from "@/components/editor/viewport";+import {+ locateLayer,+ type MaskModifier,+ maskModifiers,+ type Preview,+} from "@/core/document";+import { useMaskTool } from "@/features/layers/mask-tool";+import { maskNeutral } from "./layers";+import { useTool } from "./tools";++function sameModifiers(a: readonly MaskModifier[], b: readonly MaskModifier[]) {+ return a.length === b.length && a.every((item, i) => item === b[i]);+}++/**+ * The one writer of the preview's mask overlay: a gradient being drawn, or the selected mask while+ * it is being edited and changes nothing yet, so the image itself shows the mask once an effect is applied.+ * The Overlay button shows or hides it for the selected mask, and panning hides it.+ */+export function MaskOverlaySync() {+ const document = useDocument();+ const { overlay, draft } = useMaskTool();+ const { panMode } = useViewport();+ const editing = "Canvas" in useTool().tool;+ useEffect(() => {+ function sync() {+ let next: Preview["maskOverlay"];+ const drawn = draft.getState();+ const location = locateLayer(+ document.scene.getState().layers,+ document.selection.getState().layerId,+ );+ const layer = location?.layer;+ if (drawn) {+ next = { mask: drawn, modifiers: [] };+ } else if (layer?.kind === "mask" && !panMode) {+ // A mask inside a mask has no effects of its own; its group decides.+ const group =+ location?.parent?.kind === "mask" ? location.parent : layer;+ if (+ overlay === "shown" ||+ (overlay === "auto" && editing && maskNeutral(group))+ ) {+ next = {+ mask: layer.mask,+ modifiers: maskModifiers(layer),+ layerId: layer.id,+ opacity: layer.opacity,+ };+ }+ }+ const current = document.preview.getState().maskOverlay;+ if (+ current?.mask === next?.mask &&+ current?.layerId === next?.layerId &&+ current?.opacity === next?.opacity &&+ sameModifiers(current?.modifiers ?? [], next?.modifiers ?? [])+ ) {+ return;+ }+ document.preview.setState({ maskOverlay: next });+ }+ const unsubscribe = [+ document.scene.subscribe(sync),+ document.selection.subscribe(sync),+ draft.subscribe(sync),+ ];+ sync();+ return () => {+ for (const stop of unsubscribe) {+ stop();+ }+ document.preview.setState({ maskOverlay: undefined });+ };+ }, [document, draft, overlay, editing, panMode]);+ return null;+}diff --git a/src/app/editor/modes.tsx b/src/app/editor/modes.tsxdeleted file mode 100644index 7b442a1..0000000--- a/src/app/editor/modes.tsx+++ /dev/null@@ -1,66 +0,0 @@-import { createContext, type ReactNode, useContext, useState } from "react";-import { AdjustIcon } from "@/components/icons/adjust";-import { CropIcon } from "@/components/icons/crop";-import { ExportIcon } from "@/components/icons/export";-import { CropEditor } from "@/features/crop/view";-import { useGradientTool } from "@/features/layers/gradient-tool";-import { AdjustPanel } from "./adjust";-import { ExportMode } from "./export";--const ModeContext = createContext<{- mode: Mode;- setMode: (mode: Mode) => void;-} | null>(null);--export function useMode() {- const context = useContext(ModeContext);- if (!context) {- throw new Error("A mode provider is required.");- }- return context;-}--const adjust = {- id: "adjust",- label: "Adjust",- key: "a",- Icon: AdjustIcon,- group: "edit",- Panel: AdjustPanel,-} as const;--/**- * A mode edits over the shared canvas through a Panel, or brings its own View with a viewport and panel.- * The output mode opens from the header rather than the rail.- */-export const modes = [- adjust,- {- id: "crop",- label: "Crop",- key: "c",- Icon: CropIcon,- group: "edit",- View: CropEditor,- },- {- id: "export",- label: "Export",- key: "e",- Icon: ExportIcon,- group: "output",- View: ExportMode,- },-] as const;--export type Mode = (typeof modes)[number];--export function ModeProvider({ children }: { children: ReactNode }) {- const [mode, updateMode] = useState<Mode>(adjust);- const tool = useGradientTool();- function setMode(mode: Mode) {- tool.close();- updateMode(mode);- }- return <ModeContext value={{ mode, setMode }}>{children}</ModeContext>;-}diff --git a/src/app/editor/renderer.ts b/src/app/editor/renderer.tsindex 94a2ee1..818e99a 100644--- a/src/app/editor/renderer.ts+++ b/src/app/editor/renderer.ts@@ -2,8 +2,10 @@ import type { Gpu, Timer } from "vgpu";import { maskModifiers, type ProcessingLayer } from "@/core/document";import type { ImageSource } from "@/core/image";import {+ type Composition,createRenderer,input,+ maskInput,mixAdjustment,pipeline,type RenderImage,@@ -13,10 +15,11 @@ import { exposure } from "@/features/adjustments/exposure";import { adjustments } from "@/features/adjustments/pass";import { colorMixer } from "@/features/color-mixer/pass";import { unsharpMask } from "@/features/details/unsharp-mask";+import { fill } from "@/features/fill/pass";import { toneCurves } from "@/features/tone-curves/pass";import { vignette } from "@/features/vignette/pass";-type Composition = {+type Branch = {image: RenderImage;input?: RenderImage;};@@ -24,12 +27,17 @@ type Composition = {function composeLayer(below: RenderImage,layer: ProcessingLayer,- inputId?: string,-): Composition {- if (!layer.visible || layer.opacity === 0) {+ composition: Composition,+): Branch {+ // A hidden or transparent layer still shows what its curve receives while it is inspected.+ const bypassed = !layer.visible || layer.opacity === 0;+ if (bypassed && layer.id !== composition.inputId) {return { image: below };}const name = `layer/${layer.id}`;+ const masks = layer.kind === "mask" ? maskModifiers(layer) : [];+ const coverage =+ layer.kind === "mask" ? composition.coverage(layer) : undefined;let input: RenderImage | undefined;let edited = below;switch (layer.kind) {@@ -45,8 +53,8 @@ function composeLayer(break;case "mask": {const adjusted = pipeline(below, [adjustments(layer.adjustments, name)]);- if (layer.id === inputId) {- input = adjusted;+ if (layer.id === composition.inputId) {+ input = maskInput(name, adjusted, layer.mask, masks, coverage);}edited = pipeline(adjusted, [toneCurves(layer.toneCurve, `${name}/curves`),@@ -64,22 +72,25 @@ function composeLayer(colorMixer(layer.colorMixer, `${name}/color-mixer`),]);break;+ case "fill":+ edited = pipeline(below, [fill(layer.fill, `${name}/fill`)]);+ break;}// Child masks of a mask shape its coverage; every other child processes the image.- const masks = layer.kind === "mask" ? maskModifiers(layer) : [];const effects =layer.kind === "mask"? layer.children.filter((child) => child.kind !== "mask"): layer.children;- const children = composeLayers(edited, effects, inputId);+ const children = composeLayers(edited, effects, composition);return {image: mixAdjustment(- `${name}/mix`,+ name,below,children.image,- layer.opacity,+ bypassed ? 0 : layer.opacity,layer.kind === "mask" ? layer.mask : undefined,masks,+ coverage,),input: input ?? children.input,};@@ -88,14 +99,14 @@ function composeLayer(function composeLayers(below: RenderImage,layers: readonly ProcessingLayer[],- inputId?: string,-): Composition {+ composition: Composition,+): Branch {let image = below;let input: RenderImage | undefined;for (const layer of layers) {- const composition = composeLayer(image, layer, inputId);- image = composition.image;- input ??= composition.input;+ const branch = composeLayer(image, layer, composition);+ image = branch.image;+ input ??= branch.input;}return { image, input };}@@ -113,12 +124,12 @@ export function createEditorRenderer(return createRenderer(gpu,source,- (image, scene, inputId) => {+ (image, scene, composition) => {const [sourceLayer, ...layers] = scene.layers;const name = `layer/${sourceLayer.id}`;- const children = composeLayers(image, sourceLayer.children, inputId);- const composition = composeLayers(children.image, layers, inputId);- const adjusted = pipeline(composition.image, [+ const children = composeLayers(image, sourceLayer.children, composition);+ const composite = composeLayers(children.image, layers, composition);+ const adjusted = pipeline(composite.image, [adjustments(sourceLayer.adjustments, name),]);const full = pipeline(adjusted, [@@ -133,9 +144,9 @@ export function createEditorRenderer(full,output,input:- inputId === sourceLayer.id+ composition.inputId === sourceLayer.id? adjusted- : (children.input ?? composition.input),+ : (children.input ?? composite.input),};},timer,diff --git a/src/app/editor/mode-rail.tsx b/src/app/editor/tool-rail.tsxsimilarity index 76%rename from src/app/editor/mode-rail.tsxrename to src/app/editor/tool-rail.tsxindex 0488ec4..3ab7d34 100644--- a/src/app/editor/mode-rail.tsx+++ b/src/app/editor/tool-rail.tsx@@ -1,20 +1,20 @@import { GithubIcon } from "@/components/icons/github";import { Tab, TabList } from "@/components/ui/tabs";import { useShortcuts } from "@/hooks/use-shortcuts";-import { type Mode, modes, useMode } from "./modes";+import { type Tool, tools, useTool } from "./tools";/** Icon tabs in a column at the window's left edge on desktop, a bar above the canvas on mobile; titles carry the label and shortcut. Without a handler the tabs are inert. */-export function ModeTabList({+export function ToolTabList({selected,onSelect,}: {- selected: Mode;- onSelect?: (mode: Mode) => void;+ selected: Tool;+ onSelect?: (tool: Tool) => void;}) {- const editing = modes.filter((entry) => entry.group === "edit");+ const editing = tools.filter((entry) => entry.group === "edit");return (<div className="flex shrink-0 gap-1 overflow-auto border-black border-b bg-panel p-1.5 md:w-11 md:flex-col md:border-r md:border-b-0">- <TabList aria-label="Editor mode" className="md:flex-col">+ <TabList aria-label="Tools" className="md:flex-col">{editing.map((entry) => (<Tabkey={entry.id}@@ -44,12 +44,12 @@ export function ModeTabList({);}-export function ModeRail() {- const { mode, setMode } = useMode();+export function ToolRail() {+ const { tool, setTool } = useTool();useShortcuts(Object.fromEntries(- modes.map((entry) => [entry.key, () => setMode(entry)] as const),+ tools.map((entry) => [entry.key, () => setTool(entry)] as const),),);- return <ModeTabList selected={mode} onSelect={setMode} />;+ return <ToolTabList selected={tool} onSelect={setTool} />;}diff --git a/src/app/editor/tools.tsx b/src/app/editor/tools.tsxnew file mode 100644index 0000000..5bd3d9e--- /dev/null+++ b/src/app/editor/tools.tsx@@ -0,0 +1,109 @@+import {+ createContext,+ type Dispatch,+ type ReactNode,+ type SetStateAction,+ useContext,+ useState,+} from "react";+import { AdjustIcon } from "@/components/icons/adjust";+import { BrushIcon } from "@/components/icons/brush";+import { CropIcon } from "@/components/icons/crop";+import { ExportIcon } from "@/components/icons/export";+import { LinearGradientIcon } from "@/components/icons/linear-gradient";+import { RadialGradientIcon } from "@/components/icons/radial-gradient";+import { CropEditor } from "@/features/crop/view";+import { BrushOptions } from "@/features/layers/brush-options";+import { BrushOverlay } from "@/features/layers/brush-overlay";+import { GradientOverlay } from "@/features/layers/gradient-overlay";+import { ExportMode } from "./export";++const ToolContext = createContext<{+ tool: Tool;+ setTool: Dispatch<SetStateAction<Tool>>;+} | null>(null);++export function useTool() {+ const context = useContext(ToolContext);+ if (!context) {+ throw new Error("A tool provider is required.");+ }+ return context;+}++function LinearCanvas() {+ return <GradientOverlay shape="linear" />;+}++function RadialCanvas() {+ return <GradientOverlay shape="radial" />;+}++/** No mask canvas: the selected layer is active for its sliders, but not being edited on the image. */+const adjust = {+ id: "adjust",+ label: "Adjust",+ key: "a",+ Icon: AdjustIcon,+ group: "edit",+} as const;++export const exportTool = {+ id: "export",+ label: "Export",+ key: "e",+ Icon: ExportIcon,+ group: "output",+ View: ExportMode,+} as const;++/**+ * Tools edit masks over the shared canvas: a shape tool brings its Canvas overlay and optional Options for+ * the bar above the image, while the sidebar always shows the selected layer's controls. Adjust has no+ * canvas, so a selected mask is active without being edited. A View replaces both. The output tool opens+ * from the header rather than the rail.+ */+export const tools = [+ adjust,+ {+ id: "brush",+ label: "Brush",+ key: "b",+ Icon: BrushIcon,+ group: "edit",+ Canvas: BrushOverlay,+ Options: BrushOptions,+ },+ {+ id: "linear",+ label: "Linear gradient",+ key: "l",+ Icon: LinearGradientIcon,+ group: "edit",+ Canvas: LinearCanvas,+ },+ {+ id: "radial",+ label: "Radial gradient",+ key: "r",+ Icon: RadialGradientIcon,+ group: "edit",+ Canvas: RadialCanvas,+ },+ {+ id: "crop",+ label: "Crop",+ key: "c",+ Icon: CropIcon,+ group: "edit",+ View: CropEditor,+ },+ exportTool,+] as const;++export type Tool = (typeof tools)[number];++export function ToolProvider({ children }: { children: ReactNode }) {+ const [tool, setTool] = useState<Tool>(adjust);+ return <ToolContext value={{ tool, setTool }}>{children}</ToolContext>;+}diff --git a/src/components/editor/image.tsx b/src/components/editor/image.tsxindex 9d1593f..87b1126 100644--- a/src/components/editor/image.tsx+++ b/src/components/editor/image.tsx@@ -39,11 +39,21 @@ export function Image({const target = typeof image === "string" ? renderer[image]() : image;const source =preview.comparison === "original" && before ? before : target;- const size = geometry?.size ?? source.size;+ // A proxy output is smaller than the frame it stands for; zoom follows the frame.+ const size =+ geometry?.size ??+ (typeof image === "string" ? sceneFrame.size : source.size);const view = {...camera.view,zoom: camera.scale / (fitScale(size, camera.viewport) || 1),};+ if (typeof image === "string") {+ // The main canvas tells the renderer how many device pixels a source pixel gets.+ renderer.setDisplayScale(+ (camera.scale * devicePixelRatio) / Math.abs(sceneFrame.scale[0]),+ );+ }+ const overlay = preview.maskOverlay;display(frame, canvas, source, {view,viewport: camera.viewport,@@ -51,10 +61,13 @@ export function Image({original: before,split: preview.comparison === "split" ? preview.split : -1,clipping: preview,- overlay: preview.maskOverlay && {- ...preview.maskOverlay,+ overlay: overlay && {+ ...overlay,frame: sceneFrame,sourceSize,+ coverage: overlay.layerId+ ? renderer.coverage(overlay.layerId)+ : undefined,},});});diff --git a/src/components/editor/mapping.ts b/src/components/editor/mapping.tsnew file mode 100644index 0000000..ac43e0c--- /dev/null+++ b/src/components/editor/mapping.ts@@ -0,0 +1,42 @@+import { useMemo } from "react";+import { outputOffset, type Point, sourceOffset } from "@/core/image/frame";+import { useScene } from "./session";+import { useViewport } from "./viewport";++/** Converts between viewport pixels and source-pixel document positions through the displayed frame. */+export function useDocumentMapping() {+ const camera = useViewport();+ const frame = useScene((scene) => scene.frame);+ const { view, scale, viewport } = camera;+ return useMemo(+ () => ({+ /** Source pixels per viewport pixel along the frame's axes. */+ pixelsPerViewportPixel: Math.abs(frame.scale[0]) / scale,+ /** The document position under client coordinates, given the viewport bounds. */+ toDocument(clientX: number, clientY: number, box?: DOMRect): Point {+ if (!box) {+ return frame.center;+ }+ const offset = sourceOffset(+ frame,+ (clientX - box.left - box.width / 2 - view.pan[0]) / scale,+ (clientY - box.top - box.height / 2 - view.pan[1]) / scale,+ );+ return [frame.center[0] + offset[0], frame.center[1] + offset[1]];+ },+ /** Viewport pixels, relative to the viewport's top-left corner, of a document position. */+ toScreen(point: Point): Point {+ const [x, y] = outputOffset(+ frame,+ point[0] - frame.center[0],+ point[1] - frame.center[1],+ );+ return [+ viewport[0] / 2 + view.pan[0] + x * scale,+ viewport[1] / 2 + view.pan[1] + y * scale,+ ];+ },+ }),+ [frame, view, scale, viewport],+ );+}diff --git a/src/components/editor/pipeline.tsx b/src/components/editor/pipeline.tsxindex 7ba0c95..7781a58 100644--- a/src/components/editor/pipeline.tsx+++ b/src/components/editor/pipeline.tsx@@ -62,6 +62,7 @@ export function RendererProvider({let active = true;let requestedScene: ReturnType<typeof document.scene.getState> | undefined;let requestedInput: string | undefined;+ let requestedInteractive = false;const render = () => {const scene = document.scene.getState();const target = adjustmentTarget(@@ -69,14 +70,21 @@ export function RendererProvider({document.selection.getState().layerId,);const input = target && "toneCurve" in target ? target.id : undefined;+ // An open gesture renders a proxy; its end renders the same scene in full.+ const interactive = document.history.status.getState().editing;// A dropped input can stay live; only a new one needs a render.- if (scene === requestedScene && (input === requestedInput || !input)) {+ if (+ scene === requestedScene &&+ (input === requestedInput || !input) &&+ interactive === requestedInteractive+ ) {return;}requestedScene = scene;requestedInput = input;+ requestedInteractive = interactive;setError(undefined);- renderer.update(scene, input).catch((error) => {+ renderer.update(scene, input, interactive).catch((error) => {if (active) {setError(String(error));}@@ -84,11 +92,13 @@ export function RendererProvider({};const unsubscribeScene = document.scene.subscribe(render);const unsubscribeSelection = document.selection.subscribe(render);+ const unsubscribeHistory = document.history.status.subscribe(render);render();return () => {active = false;unsubscribeScene();unsubscribeSelection();+ unsubscribeHistory();renderer.dispose();};}, [renderer, document]);diff --git a/src/components/icons/brush.tsx b/src/components/icons/brush.tsxnew file mode 100644index 0000000..d7c80c6--- /dev/null+++ b/src/components/icons/brush.tsx@@ -0,0 +1,9 @@+import { Icon, type IconProps } from "./icon";++export function BrushIcon(props: IconProps) {+ return (+ <Icon viewBox="0 0 20 20" {...props}>+ <path d="m11 12 6.5-6.5a1.5 1.5 0 0 0-2-2L9 10M11 12l-2-2M11 12c0 3-2 5-5 5-1.5 0-3-.5-3-.5s2-1 2-2.5c0-2 1.5-3 3-3" />+ </Icon>+ );+}diff --git a/src/components/icons/linear-gradient.tsx b/src/components/icons/linear-gradient.tsxnew file mode 100644index 0000000..3347a73--- /dev/null+++ b/src/components/icons/linear-gradient.tsx@@ -0,0 +1,27 @@+import { useId } from "react";+import { Icon, type IconProps } from "./icon";++/** An outlined square with the gradient inset a pixel, so the fill reads apart from the frame. */+export function LinearGradientIcon(props: IconProps) {+ const id = useId();+ return (+ <Icon viewBox="0 0 20 20" {...props}>+ <defs>+ <linearGradient id={id} x1="0" y1="0" x2="1" y2="1">+ <stop offset="0" stopColor="currentColor" />+ <stop offset="1" stopColor="currentColor" stopOpacity="0" />+ </linearGradient>+ </defs>+ <rect x="3" y="3" width="14" height="14" rx="2" />+ <rect+ x="5"+ y="5"+ width="10"+ height="10"+ rx="1"+ fill={`url(#${id})`}+ stroke="none"+ />+ </Icon>+ );+}diff --git a/src/components/icons/radial-gradient.tsx b/src/components/icons/radial-gradient.tsxnew file mode 100644index 0000000..e668234--- /dev/null+++ b/src/components/icons/radial-gradient.tsx@@ -0,0 +1,20 @@+import { useId } from "react";+import { Icon, type IconProps } from "./icon";++/** An outlined circle with the gradient inset a pixel, so the fill reads apart from the frame. */+export function RadialGradientIcon(props: IconProps) {+ const id = useId();+ return (+ <Icon viewBox="0 0 20 20" {...props}>+ <defs>+ <radialGradient id={id} cx="0.5" cy="0.5" r="0.5">+ <stop offset="0" stopColor="currentColor" />+ <stop offset="0.45" stopColor="currentColor" stopOpacity="0.85" />+ <stop offset="1" stopColor="currentColor" stopOpacity="0" />+ </radialGradient>+ </defs>+ <circle cx="10" cy="10" r="7" />+ <circle cx="10" cy="10" r="5" fill={`url(#${id})`} stroke="none" />+ </Icon>+ );+}diff --git a/src/components/ui/button.tsx b/src/components/ui/button.tsxindex 8874f00..71db322 100644--- a/src/components/ui/button.tsx+++ b/src/components/ui/button.tsx@@ -3,7 +3,7 @@ import { cn } from "cn";import type { ComponentProps } from "react";const button = cva(- "cursor-pointer rounded-md transition-colors focus-visible:outline-2 focus-visible:outline-offset-3 focus-visible:outline-neutral-400",+ "cursor-pointer rounded-md transition-colors focus-visible:outline-1 focus-visible:outline-offset-1 focus-visible:outline-neutral-400/80",{variants: {variant: {diff --git a/src/components/ui/field.tsx b/src/components/ui/field.tsxindex 59417f5..73514b6 100644--- a/src/components/ui/field.tsx+++ b/src/components/ui/field.tsx@@ -3,21 +3,22 @@ import { cn } from "cn";import type { ComponentProps } from "react";type FieldProps = ComponentProps<"span"> & {- /** "box" always shows the chrome; "text" reads as plain text until focused. */- variant?: "box" | "text";+ /**+ * "box" always shows the chrome; "text" reads as plain text until focused, then sinks a little;+ * "pill" sinks the same way at the height and roundness of the bar over the canvas.+ */+ variant?: "box" | "text" | "pill";};-const chrome = cva(- "rounded border px-1 py-0.5 focus-within:ring-1 focus-within:ring-neutral-400/30",- {- variants: {- variant: {- box: "border-black bg-neutral-900 shadow-groove",- text: "border-transparent focus-within:border-black focus-within:bg-neutral-900 focus-within:shadow-groove",- },+const chrome = cva("focus-within:ring-1 focus-within:ring-white/10", {+ variants: {+ variant: {+ box: "rounded border border-black bg-neutral-900 px-1 py-0.5 shadow-groove",+ text: "rounded border border-transparent px-1 py-0.5 focus-within:bg-black/25 focus-within:shadow-groove",+ pill: "h-7 rounded-full px-2.5 focus-within:bg-black/25 focus-within:shadow-groove pointer-coarse:h-9",},},-);+});/*** Sunken chrome around a bare form control (input, select, textarea).diff --git a/src/components/ui/menu.tsx b/src/components/ui/menu.tsxnew file mode 100644index 0000000..dab6c4b--- /dev/null+++ b/src/components/ui/menu.tsx@@ -0,0 +1,63 @@+import { cva } from "class-variance-authority";+import { type ReactNode, useId, useRef, useState } from "react";++const trigger = cva(+ "grid shrink-0 place-items-center text-neutral-400 hover:text-neutral-100",+ {+ variants: {+ variant: {+ row: "size-7 rounded-md hover:bg-white/8 pointer-coarse:size-10",+ pill: "h-7 rounded-full px-2.5 hover:bg-white/10 pointer-coarse:h-9",+ },+ },+ },+);++/**+ * A button that floats a menu below itself. Submit buttons inside close it; other controls keep it open,+ * so it can hold settings as well as commands. Its children mount only while it is open.+ */+export function Menu({+ label,+ children,+ icon,+ variant = "row",+}: {+ label: string;+ children: ReactNode;+ icon: ReactNode;+ variant?: "row" | "pill";+}) {+ const id = useId();+ const popover = useRef<HTMLDivElement>(null);+ const [open, setOpen] = useState(false);+ return (+ <>+ <button+ type="button"+ aria-label={label}+ title={label}+ popoverTarget={id}+ className={trigger({ variant })}+ >+ {icon}+ </button>+ <div+ id={id}+ ref={popover}+ popover="auto"+ onBeforeToggle={(event) => setOpen(event.newState === "open")}+ className="fixed inset-auto z-50 m-0 mt-1 max-h-[calc(100dvh-1rem)] min-w-40 overflow-y-auto rounded-lg border border-black/60 bg-neutral-800 p-1 text-neutral-200 shadow-float [position-area:bottom_span-left] [position-try-fallbacks:flip-block] [&_button]:block [&_button]:w-full [&_button]:rounded-md [&_button]:px-2.5 [&_button]:py-1.5 [&_button]:text-left [&_button:disabled]:text-neutral-600 [&_button:disabled:hover]:bg-transparent [&_button:hover]:bg-white/8"+ >+ <form+ onSubmit={(event) => {+ event.preventDefault();+ popover.current?.hidePopover();+ }}+ >+ {open && children}+ </form>+ </div>+ </>+ );+}diff --git a/src/components/ui/scrub-input.tsx b/src/components/ui/scrub-input.tsxindex f57d2a5..df98867 100644--- a/src/components/ui/scrub-input.tsx+++ b/src/components/ui/scrub-input.tsx@@ -19,17 +19,23 @@ type ScrubInputProps = Omit<min: number;max: number;step?: number;- /** "box" always shows the field chrome; "text" reads as plain text until edited. */- variant?: "box" | "text";+ /** Follows the number after a hair of space, in a quieter color. */+ unit?: string;+ /**+ * "box" always shows the field chrome; "text" reads as plain text until edited and hugs its digits;+ * "pill" is "text" shaped like the other controls in the bar over the canvas.+ */+ variant?: "box" | "text" | "pill";};const input = cva(- "w-full cursor-ew-resize bg-transparent text-neutral-100 tabular-nums outline-none focus:cursor-text",+ "cursor-ew-resize bg-transparent text-neutral-100 tabular-nums outline-none selection:bg-white/20 focus:cursor-text",{variants: {variant: {- box: "text-center",- text: "text-right focus:text-center",+ box: "w-full text-center",+ text: "text-right",+ pill: "text-right",},},},@@ -45,6 +51,7 @@ export function ScrubInput({min,max,step = 1,+ unit,variant = "box",className,...props@@ -52,6 +59,11 @@ export function ScrubInput({const decimals = `${step}`.split(".")[1]?.length ?? 0;const [draft, setDraft] = useState<string>();const drag = useRef<Drag | undefined>(undefined);+ // Room for the longest value in range, so the field neither clips nor floats in empty space.+ const chars = Math.max(+ 2,+ ...[min, max].map((bound) => bound.toFixed(decimals).length),+ );const clamp = (next: number) =>Math.min(max, Math.max(min, Number(next.toFixed(decimals))));@@ -100,13 +112,20 @@ export function ScrubInput({return (<label- className={cn("flex items-center gap-2 text-neutral-400", className)}+ className={cn("flex items-center gap-1.5 text-neutral-400", className)}>{label}- <Field className="w-16 max-w-full" variant={variant}>+ <Field+ className={cn(+ "inline-flex items-center gap-0.5",+ variant === "box" && "w-16 max-w-full",+ )}+ variant={variant}+ ><input{...props}className={input({ variant })}+ style={variant === "box" ? undefined : { width: `${chars}ch` }}inputMode="decimal"onBlur={commit}onChange={(event) => setDraft(event.currentTarget.value)}@@ -119,6 +138,7 @@ export function ScrubInput({type="text"value={draft ?? value.toFixed(decimals)}/>+ {unit && <span className="text-neutral-500">{unit}</span>}</Field></label>);diff --git a/src/components/ui/select.tsx b/src/components/ui/select.tsxnew file mode 100644index 0000000..424292f--- /dev/null+++ b/src/components/ui/select.tsx@@ -0,0 +1,49 @@+import { cva } from "class-variance-authority";+import { cn } from "cn";+import type { ComponentProps } from "react";+import { Icon } from "@/components/icons/icon";++type SelectProps = ComponentProps<"select"> & {+ /** "field" sinks into panel chrome; "pill" sits in the bar over the canvas. */+ variant?: "field" | "pill";+};++const frame = cva("relative inline-flex items-center", {+ variants: {+ variant: {+ field:+ "rounded border border-black bg-neutral-900 shadow-groove focus-within:ring-1 focus-within:ring-white/10",+ pill: "h-7 rounded-full bg-white/10 hover:bg-white/15 pointer-coarse:h-9",+ },+ },+});+const control = cva(+ "w-full cursor-pointer appearance-none bg-transparent outline-none [color-scheme:dark]",+ {+ variants: {+ variant: {+ field: "py-0.5 pr-6 pl-1 text-neutral-100",+ pill: "h-full pr-7 pl-3 text-neutral-200",+ },+ },+ },+);++/** A native select with the app's chrome and chevron; options come as children. */+export function Select({+ variant = "field",+ className,+ children,+ ...props+}: SelectProps) {+ return (+ <span className={cn(frame({ variant }), className)}>+ <select {...props} className={control({ variant })}>+ {children}+ </select>+ <Icon className="pointer-events-none absolute top-1/2 right-2 size-3 -translate-y-1/2 text-neutral-400">+ <path d="m6 9 6 6 6-6" />+ </Icon>+ </span>+ );+}diff --git a/src/components/ui/slider.tsx b/src/components/ui/slider.tsxindex e843a47..3c22f8c 100644--- a/src/components/ui/slider.tsx+++ b/src/components/ui/slider.tsx@@ -13,32 +13,36 @@ type SliderProps = {/** CSS color stops painting the bar left to right, e.g. ["#46f", "#fc3"]. */stops?: string[];unit?: string;- /** "panel" stacks the bar under its label; "toolbar" keeps one row and drops the bar in a narrow container. */- variant?: "panel" | "toolbar";+ /** "panel" stacks the bar under its label; "toolbar" keeps one row; "compact" is that row without the bar. */+ variant?: "panel" | "toolbar" | "compact";};+// In the bar, the label is inset like the text of the pills around it.const root = cva("items-center text-neutral-400", {variants: {variant: {panel: "grid grid-cols-[1fr_auto] gap-y-0.5",- toolbar: "flex gap-2",+ toolbar: "flex gap-1.5 pl-2.5",+ compact: "flex gap-1.5 pl-2.5",},},});-const field = cva("relative z-10 flex items-center gap-1", {- variants: { variant: { panel: "", toolbar: "order-last" } },+const field = cva("relative z-10 flex items-center", {+ variants: {+ variant: { panel: "", toolbar: "order-last", compact: "order-last" },+ },});const track = cva("relative h-1 min-w-11 rounded-full bg-neutral-900 shadow-groove",{variants: {- variant: { panel: "col-span-2 my-1", toolbar: "w-20 @max-2xl:hidden" },+ variant: { panel: "col-span-2 my-1", toolbar: "w-16", compact: "hidden" },},},);const range = cva("absolute top-1/2 w-full -translate-y-1/2 touch-pan-y appearance-none bg-transparent outline-none [&:focus-visible::-webkit-slider-thumb]:ring-2 [&:focus-visible::-webkit-slider-thumb]:ring-sky-300 [&:focus-visible::-moz-range-thumb]:ring-2 [&:focus-visible::-moz-range-thumb]:ring-sky-300 [&::-webkit-slider-runnable-track]:bg-transparent [&::-webkit-slider-thumb]:appearance-none [&::-webkit-slider-thumb]:size-3 [&::-webkit-slider-thumb]:rounded-full [&::-webkit-slider-thumb]:bg-neutral-100 [&::-webkit-slider-thumb]:ring-1 [&::-webkit-slider-thumb]:ring-neutral-800 [&::-moz-range-track]:bg-transparent [&::-moz-range-thumb]:size-2.5 [&::-moz-range-thumb]:rounded-full [&::-moz-range-thumb]:border-0 [&::-moz-range-thumb]:bg-neutral-100 [&::-moz-range-thumb]:ring-1 [&::-moz-range-thumb]:ring-neutral-800",- { variants: { variant: { panel: "h-11", toolbar: "h-7" } } },+ { variants: { variant: { panel: "h-11", toolbar: "h-7", compact: "h-7" } } },);/** Labeled slider paired with a scrubbable numeric field. */@@ -65,15 +69,14 @@ export function Slider({<div className={field({ variant })}><ScrubInputaria-label={label}- className={variant === "toolbar" ? "w-9" : undefined}max={max}min={min}onChange={onChange}step={step}+ unit={unit}value={value}- variant="text"+ variant={variant === "panel" ? "text" : "pill"}/>- {unit && <span className="text-neutral-500">{unit}</span>}</div><div className={track({ variant })} style={gradient}><inputdiff --git a/src/core/document/history.ts b/src/core/document/history.tsindex a6c8547..39d2a61 100644--- a/src/core/document/history.ts+++ b/src/core/document/history.ts@@ -7,12 +7,21 @@ export function createHistory<T extends object>(limit = 100,onChange?: (retained: readonly T[]) => void,) {- const status = createStore(() => ({ undoCount: 0, redoCount: 0 }));+ const status = createStore(() => ({+ undoCount: 0,+ redoCount: 0,+ /** A gesture group is open, so the scene is mid-change. */+ editing: false,+ }));const past: T[] = [];const future: T[] = [];let group: T | undefined;function publish() {- status.setState({ undoCount: past.length, redoCount: future.length });+ status.setState({+ undoCount: past.length,+ redoCount: future.length,+ editing: group !== undefined,+ });onChange?.([...past,...future,@@ -77,12 +86,26 @@ export function createHistory<T extends object>(begin() {const opened = group === undefined;group ??= state.getState();+ if (opened) {+ status.setState({ editing: true });+ }return opened;},commit,cancel,undo: () => travel(past, future),redo: () => travel(future, past),+ /** Removes the latest entry when `before` is its snapshot, leaving no redo; an open group is cancelled first. */+ drop(before: T) {+ cancel();+ if (past.at(-1) !== before) {+ return;+ }+ past.pop();+ state.setState(before, true);+ future.length = 0;+ publish();+ },clear() {group = undefined;past.length = future.length = 0;diff --git a/src/core/document/index.ts b/src/core/document/index.tsindex b0a6224..7a2f16a 100644--- a/src/core/document/index.ts+++ b/src/core/document/index.ts@@ -2,24 +2,30 @@ import { createStore } from "zustand/vanilla";import { validateFrame } from "@/core/image/frame";import { createHistory } from "./history";import { createResources } from "./resources";-import type { Gradient, MaskModifier, Scene } from "./scene";+import type { Mask, MaskModifier, Scene } from "./scene";import { findLayer } from "./tree";export type {Adjustments,+ Blend,+ BrushMask,+ BrushStroke,ColorMixer,CurvePoint,Details,EffectLayer,+ Fill,Gradient,ImageLayer,Layer,LinearGradient,+ Mask,MaskLayer,MaskModifier,ProcessingLayer,RadialGradient,Scene,+ StrokePoint,ToneCurve,Vignette,} from "./scene";@@ -39,10 +45,13 @@ export type Preview = {split: number;shadows: boolean;highlights: boolean;- /** The mask whose coverage the display tints red. */+ /** The mask whose coverage the display tints red; a layer ID lets the display use its rasterized coverage. */maskOverlay?: {- readonly mask: Gradient;+ readonly mask: Mask;readonly modifiers: readonly MaskModifier[];+ readonly layerId?: string;+ /** The layer's opacity, which scales the tint like it scales the effect. */+ readonly opacity?: number;};};diff --git a/src/core/document/scene.ts b/src/core/document/scene.tsindex 1cd021e..3d05151 100644--- a/src/core/document/scene.ts+++ b/src/core/document/scene.ts@@ -36,6 +36,20 @@ export type Vignette = {readonly softness: number;};+export type Blend =+ | "normal"+ | "multiply"+ | "screen"+ | "overlay"+ | "soft-light"+ | "color"+ | "luminosity";+/** One color painted over the image, as `#rrggbb` sRGB, blended like Photoshop. */+export type Fill = {+ readonly color: string;+ readonly blend: Blend;+};+export type ImageLayer = {readonly kind: "image";readonly id: string;@@ -61,6 +75,24 @@ export type RadialGradient = {readonly feather: number;};export type Gradient = LinearGradient | RadialGradient;+/** A source-pixel position with the pen pressure that scales flow, 1 for a mouse. */+export type StrokePoint = readonly [number, number, number];+/** One brush drag; paint accumulates coverage by flow and erase removes it. */+export type BrushStroke = {+ readonly mode: "paint" | "erase";+ /** Diameter in source pixels. */+ readonly size: number;+ /** Soft edge as a fraction of the radius, 0 to 1. */+ readonly feather: number;+ readonly flow: number;+ readonly points: readonly StrokePoint[];+};+/** Coverage painted with strokes; the renderer rasterizes them into a cached texture. */+export type BrushMask = {+ readonly kind: "brush";+ readonly strokes: readonly BrushStroke[];+};+export type Mask = Gradient | BrushMask;export type ProcessingLayer = {readonly id: string;readonly name: string;@@ -72,17 +104,21 @@ export type ProcessingLayer = {| { readonly kind: "exposure"; readonly exposure: number }| { readonly kind: "vignette"; readonly vignette: Vignette }| { readonly kind: "color-mixer"; readonly colorMixer: ColorMixer }+ | { readonly kind: "fill"; readonly fill: Fill }| {readonly kind: "mask";readonly operation: "add" | "subtract";- readonly mask: Gradient;+ readonly mask: Mask;readonly adjustments: Readonly<Adjustments>;readonly toneCurve: ToneCurve;});export type MaskLayer = Extract<ProcessingLayer, { kind: "mask" }>;/** A child mask that adds to or subtracts from its parent's coverage. */-export type MaskModifier = Pick<MaskLayer, "mask" | "operation" | "opacity">;+export type MaskModifier = Pick<+ MaskLayer,+ "id" | "mask" | "operation" | "opacity"+>;export type EffectLayer = Exclude<ProcessingLayer, MaskLayer>;export type Layer = ImageLayer | ProcessingLayer;diff --git a/src/core/renderer/blend/index.ts b/src/core/renderer/blend/index.tsindex 0aab2ac..e8f6717 100644--- a/src/core/renderer/blend/index.ts+++ b/src/core/renderer/blend/index.ts@@ -1,11 +1,17 @@-import type { Gradient, MaskModifier } from "@/core/document";-import { merge, node, type RenderImage } from "@/core/renderer/node";+import type { Mask, MaskModifier } from "@/core/document";+import {+ merge,+ node,+ type RenderImage,+ type RenderInput,+} from "@/core/renderer/node";import shader from "./mix.wgsl";+import rasterShader from "./raster.wgsl";const emptyModifiers = new Float32Array(8);-/** Uniform fields for one gradient; kind 0 means full coverage. */-export function gradientParams(mask?: Gradient) {+/** Uniform fields for one gradient; kind 0 means full coverage. Brush masks have no analytical form. */+export function gradientParams(mask?: Mask) {if (mask?.kind === "radial") {return {kind: 2,@@ -16,21 +22,27 @@ export function gradientParams(mask?: Gradient) {};}return {- kind: Number(!!mask),- first: mask?.start ?? [0, 0],- second: mask?.end ?? [1, 0],+ kind: Number(mask?.kind === "linear"),+ first: mask?.kind === "linear" ? mask.start : [0, 0],+ second: mask?.kind === "linear" ? mask.end : [1, 0],feather: 0,angle: 0,};}-/** Two vec4 per modifier: geometry, then signed strength, kind, feather, and angle. */+/** The modifiers with an analytical form; brush children only exist inside a raster. */+export function gradientModifiers(modifiers: readonly MaskModifier[]) {+ return modifiers.filter(({ mask }) => mask.kind !== "brush");+}++/** Two vec4 per gradient modifier: geometry, then signed strength, kind, feather, and angle. */export function modifierData(modifiers: readonly MaskModifier[]) {- if (!modifiers.length) {+ const gradients = gradientModifiers(modifiers);+ if (!gradients.length) {return emptyModifiers;}- const data = new Float32Array(modifiers.length * 8);- modifiers.forEach(({ mask, opacity, operation }, index) => {+ const data = new Float32Array(gradients.length * 8);+ gradients.forEach(({ mask, opacity, operation }, index) => {const { first, second, kind, feather, angle } = gradientParams(mask);data.set([@@ -47,14 +59,18 @@ export function modifierData(modifiers: readonly MaskModifier[]) {return data;}-/** Interpolates an adjustment result without changing image coverage or HDR headroom. */+/**+ * Interpolates an adjustment result without changing image coverage or HDR headroom.+ * Rasterized coverage replaces the analytical gradients when a brush is involved.+ */export function mixAdjustment(name: string,original: RenderImage,edited: RenderImage,opacity: number,- mask?: Gradient,+ mask?: Mask,modifiers: readonly MaskModifier[] = [],+ coverage?: RenderInput,) {if (original === edited || opacity === 0) {return original;@@ -62,15 +78,75 @@ export function mixAdjustment(if (opacity === 1 && !mask) {return edited;}+ if (coverage) {+ return merge(+ { original, edited, coverage },+ node(`${name}/raster`, rasterShader, {+ samplers: {+ coverageSampler: { minFilter: "linear", magFilter: "linear" },+ },+ set: { params: { opacity, mode: 0 } },+ }),+ );+ }+ if (mask?.kind === "brush") {+ return original;+ }+ const gradients = gradientModifiers(modifiers);return merge({ original, edited },- node(name, shader, {- storage: { modifiers: modifierData(modifiers) },+ node(`${name}/mix`, shader, {+ storage: { modifiers: modifierData(gradients) },set: {params: {opacity,...gradientParams(mask),- modifierCount: modifiers.length,+ modifierCount: gradients.length,+ scale: original.scale,+ mode: 0,+ },+ },+ }),+ );+}++/**+ * The image a mask's curve receives, with the mask's coverage as alpha, so a histogram of it+ * weighs the pixels the curve affects. Layer opacity is left out: it scales the effect, not the region.+ */+export function maskInput(+ name: string,+ image: RenderImage,+ mask: Mask,+ modifiers: readonly MaskModifier[] = [],+ coverage?: RenderInput,+) {+ if (coverage) {+ return merge(+ { original: image, edited: image, coverage },+ node(`${name}/raster-input`, rasterShader, {+ samplers: {+ coverageSampler: { minFilter: "linear", magFilter: "linear" },+ },+ set: { params: { opacity: 1, mode: 1 } },+ }),+ );+ }+ if (mask.kind === "brush") {+ return image;+ }+ const gradients = gradientModifiers(modifiers);+ return merge(+ { original: image, edited: image },+ node(`${name}/input`, shader, {+ storage: { modifiers: modifierData(gradients) },+ set: {+ params: {+ opacity: 1,+ ...gradientParams(mask),+ modifierCount: gradients.length,+ scale: image.scale,+ mode: 1,},},}),diff --git a/src/core/renderer/blend/mix.wgsl b/src/core/renderer/blend/mix.wgslindex 5a18758..d8383b7 100644--- a/src/core/renderer/blend/mix.wgsl+++ b/src/core/renderer/blend/mix.wgsl@@ -8,6 +8,10 @@ struct Params {feather: f32,angle: f32,modifierCount: u32,+ // Source pixels per texel, so a reduced proxy evaluates gradients at the same document positions.+ scale: vec2f,+ // 1 returns the edited image with coverage as alpha, for measuring what a mask affects.+ mode: u32,}@group(0) @binding(0) var original: texture_2d<f32>;@group(0) @binding(1) var edited: texture_2d<f32>;@@ -19,13 +23,17 @@ struct Params {let after = textureLoad(edited, vec2i(position.xy), 0);var coverage = 1.0;if (params.kind != 0u) {- coverage = gradientCoverage(position.xy, params.first, params.second, params.kind, params.feather, params.angle);+ let at = position.xy * params.scale;+ coverage = gradientCoverage(at, params.first, params.second, params.kind, params.feather, params.angle);for (var i = 0u; i < params.modifierCount; i++) {let points = modifiers[i * 2u];let settings = modifiers[i * 2u + 1u];- coverage = clamp(coverage + gradientCoverage(position.xy, points.xy, points.zw, u32(settings.y), settings.z, settings.w) * settings.x, 0.0, 1.0);+ coverage = clamp(coverage + gradientCoverage(at, points.xy, points.zw, u32(settings.y), settings.z, settings.w) * settings.x, 0.0, 1.0);}}+ if (params.mode == 1u) {+ return vec4f(after.rgb, before.a * coverage);+ }coverage *= params.opacity;return vec4f(mix(before.rgb, after.rgb, coverage), before.a);}diff --git a/src/core/renderer/blend/raster.wgsl b/src/core/renderer/blend/raster.wgslnew file mode 100644index 0000000..3613e14--- /dev/null+++ b/src/core/renderer/blend/raster.wgsl@@ -0,0 +1,22 @@+// Blends an adjustment through rasterized coverage, sampled by position so any proxy resolution reads the same mask.+struct Params {+ opacity: f32,+ // 1 returns the edited image with coverage as alpha, for measuring what a mask affects.+ mode: u32,+}+@group(0) @binding(0) var original: texture_2d<f32>;+@group(0) @binding(1) var edited: texture_2d<f32>;+@group(0) @binding(2) var coverage: texture_2d<f32>;+@group(0) @binding(3) var coverageSampler: sampler;+@group(0) @binding(4) var<uniform> params: Params;++@fragment fn fs_main(@builtin(position) position: vec4f) -> @location(0) vec4f {+ let before = textureLoad(original, vec2i(position.xy), 0);+ let after = textureLoad(edited, vec2i(position.xy), 0);+ let uv = position.xy / vec2f(textureDimensions(original));+ let covered = textureSampleLevel(coverage, coverageSampler, uv, 0.0).r;+ if (params.mode == 1u) {+ return vec4f(after.rgb, before.a * covered);+ }+ return vec4f(mix(before.rgb, after.rgb, covered * params.opacity), before.a);+}diff --git a/src/core/renderer/display/coverage.wgsl b/src/core/renderer/display/coverage.wgslnew file mode 100644index 0000000..f71e5b2--- /dev/null+++ b/src/core/renderer/display/coverage.wgsl@@ -0,0 +1,18 @@+// Box-averages a coverage raster into a small gray preview: near black where nothing is covered, white where all is.+@group(0) @binding(0) var coverage: texture_2d<f32>;+@group(0) @binding(1) var<uniform> size: vec2f;++@fragment fn fs_main(@location(0) uv: vec2f) -> @location(0) vec4f {+ let source = vec2f(textureDimensions(coverage));+ let block = max(vec2i(ceil(source / size)), vec2i(1));+ let origin = vec2i(floor(uv * source - vec2f(block) * 0.5));+ let limit = vec2i(source) - 1;+ var total = 0.0;+ for (var y = 0; y < block.y; y++) {+ for (var x = 0; x < block.x; x++) {+ total += textureLoad(coverage, clamp(origin + vec2i(x, y), vec2i(0), limit), 0).r;+ }+ }+ let value = total / f32(block.x * block.y);+ return vec4f(mix(vec3f(0.039), vec3f(1.0), value), 1.0);+}diff --git a/src/core/renderer/display/image.wgsl b/src/core/renderer/display/image.wgslindex fa00313..c70aa7a 100644--- a/src/core/renderer/display/image.wgsl+++ b/src/core/renderer/display/image.wgsl@@ -10,6 +10,8 @@ struct MaskOverlay {angle: f32,modifierCount: u32,sourceSize: vec2f,+ // The layer's opacity scales coverage in the mix pass, so the tint follows it.+ opacity: f32,}@group(0) @binding(0) var<uniform> view: View;@@ -21,17 +23,22 @@ struct MaskOverlay {@group(0) @binding(6) var<uniform> maskTransform: Transform;@group(0) @binding(7) var<uniform> overlay: MaskOverlay;@group(0) @binding(8) var<storage, read> modifiers: array<vec4f>;+@group(0) @binding(9) var coverage: texture_2d<f32>;-// The same analytical coverage the mix pass applies, evaluated in source pixels.+// The same coverage the mix pass applies: kind 3 reads a rasterized mask, the rest evaluate gradients in source pixels.fn overlayCoverage(uv: vec2f) -> f32 {- let position = sourcePoint(maskTransform, uv) * overlay.sourceSize;+ let point = sourcePoint(maskTransform, uv);+ if (overlay.kind == 3u) {+ return textureSampleLevel(coverage, sourceSampler, point, 0.0).r * overlay.opacity;+ }+ let position = point * overlay.sourceSize;var coverage = gradientCoverage(position, overlay.first, overlay.second, overlay.kind, overlay.feather, overlay.angle);for (var i = 0u; i < overlay.modifierCount; i++) {let points = modifiers[i * 2u];let settings = modifiers[i * 2u + 1u];coverage = clamp(coverage + gradientCoverage(position, points.xy, points.zw, u32(settings.y), settings.z, settings.w) * settings.x, 0.0, 1.0);}- return coverage;+ return coverage * overlay.opacity;}@fragment fn fs_main(@location(0) uv: vec2f) -> @location(0) vec4f {diff --git a/src/core/renderer/display/index.ts b/src/core/renderer/display/index.tsindex 9c82b62..77cef69 100644--- a/src/core/renderer/display/index.ts+++ b/src/core/renderer/display/index.ts@@ -1,5 +1,6 @@import {type Buffer,+ type Effect,effect,type Frame,frame,@@ -7,25 +8,34 @@ import {sampler,surface,type Target,+ target,} from "vgpu";-import type { Gradient, MaskModifier } from "@/core/document";+import type { Mask, MaskModifier } from "@/core/document";import {frameTransform,type ImageFrame,imageFrame,type Point,} from "@/core/image/frame";-import { gradientParams, modifierData } from "@/core/renderer/blend";+import {+ gradientModifiers,+ gradientParams,+ modifierData,+} from "@/core/renderer/blend";+import coverageShader from "./coverage.wgsl";import shader from "./image.wgsl";export type View = { zoom: number; pan: readonly [number, number] };export type Clipping = { shadows: boolean; highlights: boolean };-/** A mask to tint over the displayed image; its geometry lives in source pixels. */+/** A mask to tint over the displayed image; its geometry lives in source pixels, or in a rasterized coverage texture. */export type MaskOverlay = {- mask: Gradient;+ mask: Mask;modifiers: readonly MaskModifier[];frame: ImageFrame;sourceSize: readonly number[];+ coverage?: Target;+ /** The layer's opacity, which scales its coverage. */+ opacity?: number;};type DisplayOptions = {view: View;@@ -39,9 +49,12 @@ type DisplayOptions = {/** Display any transformed image with optional comparison, clipping indicators, and mask overlay. */export function createDisplay(gpu: Gpu) {+ // Stands in for the coverage binding when no rasterized mask is shown.+ const blank = target(gpu, { size: [1, 1], format: "r8unorm" });const draw = effect(gpu, shader, {set: {sourceSampler: sampler(gpu, { magFilter: "linear", minFilter: "linear" }),+ coverage: blank.color,},});let modifiers: Buffer | undefined;@@ -90,10 +103,15 @@ export function createDisplay(gpu: Gpu) {overlay?.frame ?? geometry,overlay?.sourceSize ?? image.size,),+ coverage: (overlay?.coverage ?? blank).color,overlay: {...gradientParams(overlay?.mask),- modifierCount: overlay?.modifiers.length ?? 0,+ ...(overlay?.coverage ? { kind: 3 } : {}),+ modifierCount: overlay+ ? gradientModifiers(overlay.modifiers).length+ : 0,sourceSize: overlay?.sourceSize ?? image.size,+ opacity: overlay?.opacity ?? 1,},}),);@@ -102,11 +120,33 @@ export function createDisplay(gpu: Gpu) {dispose() {modifiers?.dispose();modifiers = undefined;+ blank.color.dispose();},});}const displays = new WeakMap<Gpu, ReturnType<typeof createDisplay>>();+const previews = new WeakMap<Gpu, Effect>();++/** Draws a coverage raster as a gray preview of `size` and takes its pixels; no texture outlives the call. */+export async function renderCoverage(gpu: Gpu, coverage: Target, size: Point) {+ let preview = previews.get(gpu);+ if (!preview) {+ preview = effect(gpu, coverageShader);+ previews.set(gpu, preview);+ }+ const canvas = new OffscreenCanvas(size[0], size[1]);+ const output = surface(gpu, canvas, { size, dpr: 1 });+ try {+ frame(gpu, (frame) =>+ frame.pass(output, preview.set({ coverage: coverage.color, size })),+ );+ await gpu.gpu.queue.onSubmittedWorkDone();+ return canvas.transferToImageBitmap();+ } finally {+ output.dispose();+ }+}/** Draws an image into an off-screen canvas of `size` and takes its pixels; one display serves each GPU. */export async function renderBitmap(gpu: Gpu, image: Target, size: Point) {diff --git a/src/core/renderer/index.ts b/src/core/renderer/index.tsindex 4c45617..465315a 100644--- a/src/core/renderer/index.ts+++ b/src/core/renderer/index.ts@@ -1,15 +1,23 @@import type { Gpu, Target, Timer } from "vgpu";-import { type Scene, walkLayers } from "@/core/document";+import {+ type Layer,+ type MaskLayer,+ type Scene,+ walkLayers,+} from "@/core/document";import type { ImageSource, WhiteBalance } from "@/core/image";import { createRenderGraph } from "./graph";-import { input, type RenderImage } from "./node";+import { createMaskRaster } from "./mask";+import { input, type RenderImage, type RenderInput } from "./node";+import { createProxy } from "./proxy";-export { mixAdjustment } from "./blend";+export { maskInput, mixAdjustment } from "./blend";export {type Clipping,createDisplay,type MaskOverlay,renderBitmap,+ renderCoverage,type View,} from "./display";export {@@ -22,16 +30,24 @@ export {type RenderInput,type RenderNode,type RenderStep,+ type Scale,+ sourceSize,split,} from "./node";export { transformImages } from "./transform";export { createRenderGraph };+export type Composition = {+ inputId?: string;+ /** Rasterized coverage of a mask that paints with brushes, prepared before composition. */+ coverage: (layer: MaskLayer) => RenderInput | undefined;+};+/** App composition describes requested outputs; the engine owns their storage. */export type SceneProcessing = (source: RenderImage,scene: Scene,- inputId?: string,+ composition: Composition,) => {original: RenderImage;full: RenderImage;@@ -42,13 +58,15 @@ export type SceneProcessing = (type RenderRequest = {scene: Scene;inputId?: string;+ /** Source pixels per texel of the composition's source; above 1 renders a reduced proxy. */+ factor: number;};function sameBalance(a: WhiteBalance | undefined, b: WhiteBalance | undefined) {return a?.temperature === b?.temperature && a?.tint === b?.tint;}-/** Owns scene passes and intermediate textures for one decoded source. */+/** Owns scene passes, mask rasters, the proxy, and intermediate textures for one decoded source. */export function createRenderer(gpu: Gpu,resource: ImageSource,@@ -57,6 +75,8 @@ export function createRenderer() {const source = resource.image;const graph = createRenderGraph(gpu, timer);+ const raster = createMaskRaster(gpu);+ const proxy = createProxy(gpu);const release = resource.retain();const raw = resource.raw?.createPass();let original = source;@@ -66,11 +86,24 @@ export function createRenderer(let output = source;let inspected: { id: string; image: Target } | undefined;let balance = resource.raw?.asShot;+ /** Counts developments, so the proxy follows white-balance changes. */+ let version = 0;+ let displayScale = 1;+ let last: RenderRequest | undefined;let next: RenderRequest | undefined;let pending: Promise<void> | undefined;let disposed = false;let instances = new Set<string>();- function render({ scene, inputId }: RenderRequest) {+ function render(request: RenderRequest) {+ const { scene, inputId, factor } = request;+ if (+ last &&+ last.scene === scene &&+ last.inputId === inputId &&+ last.factor === factor+ ) {+ return;+ }const active = new Set(walkLayers(scene.layers).map((layer) => layer.id));for (const id of instances) {if (!active.has(id)) {@@ -78,7 +111,26 @@ export function createRenderer(}}instances = active;- const images = compose(input(raw?.render() ?? source), scene, inputId);+ const developed = raw?.render() ?? source;+ // A mask updates its rasters with those of the masks inside it, which only shape its coverage.+ function prepare(layer: Layer, parent?: Layer) {+ if (layer.kind === "mask" && parent?.kind !== "mask") {+ raster.update(layer, developed.size);+ }+ for (const child of layer.children) {+ prepare(child, layer);+ }+ }+ for (const layer of scene.layers) {+ prepare(layer);+ }+ raster.sweep();+ const image =+ factor > 1 ? proxy.render(developed, factor, version) : input(developed);+ const images = compose(image, scene, {+ inputId,+ coverage: (layer) => raster.get(layer.id),+ });const targets = graph.render([images.original,images.full,@@ -89,6 +141,7 @@ export function createRenderer(inspected =inputId && targets[3] ? { id: inputId, image: targets[3] } : undefined;rendered = true;+ last = request;for (const listener of listeners) {listener();}@@ -106,21 +159,28 @@ export function createRenderer(return;}balance = selected;+ version++;}if (!next) {render(request);}}}- async function update(scene: Scene, inputId?: string): Promise<void> {+ /** Interactive updates render at a proxy resolution matched to the display scale. */+ async function update(+ scene: Scene,+ inputId?: string,+ interactive = false,+ ): Promise<void> {if (disposed) {throw Error("Renderer is closed.");}+ const factor = interactive ? Math.max(1, Math.floor(1 / displayScale)) : 1;if (!resource.raw) {- render({ scene, inputId });+ render({ scene, inputId, factor });return;}- next = { scene, inputId };+ next = { scene, inputId, factor };pending ??= develop().catch((error) => {if (!next) {@@ -130,7 +190,7 @@ export function createRenderer(.finally(() => {pending = undefined;if (next && !disposed) {- return update(next.scene, next.inputId);+ return update(next.scene, next.inputId, next.factor > 1);}});return pending;@@ -142,7 +202,15 @@ export function createRenderer(outputImage: () => output,inputImage: (id: string) =>inspected?.id === id ? inspected.image : undefined,- inspect: graph.inspect,+ /** The rasterized coverage of a mask layer, for the display overlay. */+ coverage: (id: string) => raster.get(id)?.target,+ /** Device pixels shown per source pixel; interactive renders reduce the source to about this density. */+ setDisplayScale(scale: number) {+ if (Number.isFinite(scale) && scale > 0) {+ displayScale = scale;+ }+ },+ inspect: () => ({ ...graph.inspect(), ...raster.inspect() }),subscribe(listener: () => void) {listeners.add(listener);if (rendered) {@@ -160,6 +228,8 @@ export function createRenderer(disposed = true;listeners.clear();graph.dispose();+ raster.dispose();+ proxy.dispose();raw?.dispose();release();},diff --git a/src/core/renderer/mask/brush.wgsl b/src/core/renderer/mask/brush.wgslnew file mode 100644index 0000000..520bd6b--- /dev/null+++ b/src/core/renderer/mask/brush.wgsl@@ -0,0 +1,11 @@+// One brush's rasterized coverage scaled by its strength; the pass blend adds or subtracts it from its group.+struct Params {+ opacity: f32,+}+@group(0) @binding(0) var coverage: texture_2d<f32>;+@group(0) @binding(1) var<uniform> params: Params;++@fragment fn fs_main(@builtin(position) position: vec4f) -> @location(0) vec4f {+ let value = textureLoad(coverage, vec2i(position.xy), 0).r;+ return vec4f(value * params.opacity, 0.0, 0.0, 1.0);+}diff --git a/src/core/renderer/mask/dabs.ts b/src/core/renderer/mask/dabs.tsnew file mode 100644index 0000000..3c5c6ee--- /dev/null+++ b/src/core/renderer/mask/dabs.ts@@ -0,0 +1,38 @@+import type { BrushStroke } from "@/core/document";++/** Dab center with its radius and alpha: x, y, radius, alpha. */+export type Dab = readonly [number, number, number, number];++/** Dabs every quarter diameter along the stroke, starting at its first point; a fixed walk keeps replays identical. */+export function strokeDabs(stroke: BrushStroke): Dab[] {+ const radius = stroke.size / 2;+ const spacing = Math.max(1, stroke.size / 4);+ const dabs: Dab[] = [];+ const [first] = stroke.points;+ if (!first) {+ return dabs;+ }+ const dab = (x: number, y: number, pressure: number): Dab => [+ x,+ y,+ radius,+ stroke.flow * pressure,+ ];+ dabs.push(dab(first[0], first[1], first[2]));+ let travelled = 0;+ let next = spacing;+ for (let i = 1; i < stroke.points.length; i++) {+ const [ax, ay, ap] = stroke.points[i - 1];+ const [bx, by, bp] = stroke.points[i];+ const length = Math.hypot(bx - ax, by - ay);+ while (length > 0 && next <= travelled + length) {+ const t = (next - travelled) / length;+ dabs.push(+ dab(ax + (bx - ax) * t, ay + (by - ay) * t, ap + (bp - ap) * t),+ );+ next += spacing;+ }+ travelled += length;+ }+ return dabs;+}diff --git a/src/core/renderer/mask/gradient.wgsl b/src/core/renderer/mask/gradient.wgslnew file mode 100644index 0000000..b300dff--- /dev/null+++ b/src/core/renderer/mask/gradient.wgsl@@ -0,0 +1,17 @@+import { gradientCoverage } from "../blend/coverage.wgsl";++// One gradient's coverage at source resolution, scaled by its strength; the pass blend adds or subtracts it.+struct Params {+ kind: u32,+ first: vec2f,+ second: vec2f,+ feather: f32,+ angle: f32,+ opacity: f32,+}+@group(0) @binding(0) var<uniform> params: Params;++@fragment fn fs_main(@builtin(position) position: vec4f) -> @location(0) vec4f {+ let coverage = gradientCoverage(position.xy, params.first, params.second, params.kind, params.feather, params.angle);+ return vec4f(coverage * params.opacity, 0.0, 0.0, 1.0);+}diff --git a/src/core/renderer/mask/index.ts b/src/core/renderer/mask/index.tsnew file mode 100644index 0000000..ab4f3f9--- /dev/null+++ b/src/core/renderer/mask/index.ts@@ -0,0 +1,357 @@+import {+ type BlendOptions,+ type Buffer,+ effect,+ frame,+ type Gpu,+ type Target,+ target,+} from "vgpu";+import {+ type BrushStroke,+ type MaskLayer,+ type MaskModifier,+ maskModifiers,+} from "@/core/document";+import { gradientParams } from "@/core/renderer/blend";+import { input, type RenderInput } from "@/core/renderer/node";+import brushShader from "./brush.wgsl";+import { type Dab, strokeDabs } from "./dabs";+import gradientShader from "./gradient.wgsl";+import strokeShader from "./strokes.wgsl";++/** Dabs per pass: every fragment in the chunk's bounds loops over them. */+const chunk = 64;++type Size = readonly [number, number];+/** One brush's own coverage, stamped as its strokes grow. */+type Brush = {+ target: Target;+ strokes: readonly BrushStroke[];+ /** Dabs already stamped from the last stroke. */+ dabs: number;+};+/** A mask's own coverage combined with the children that shape it. */+type Group = {+ target: Target;+ ops: readonly MaskModifier[];+};++/** A mask's own coverage followed by the children that shape it, in stored order. */+export function maskOps(layer: MaskLayer): readonly MaskModifier[] {+ return [+ { id: layer.id, mask: layer.mask, operation: "add", opacity: 1 },+ ...maskModifiers(layer),+ ];+}++/** Whether an op can cover pixels: a gradient always does, a brush once it has strokes. */+function covers(op: MaskModifier) {+ return op.mask.kind !== "brush" || op.mask.strokes.length > 0;+}++function sameStroke(a: BrushStroke, b: BrushStroke) {+ return (+ a.mode === b.mode &&+ a.size === b.size &&+ a.feather === b.feather &&+ a.flow === b.flow+ );+}++/** Whether `next` only appends points to `previous`, sharing every earlier point. */+function extendsStroke(previous: BrushStroke, next: BrushStroke) {+ return (+ previous === next ||+ (sameStroke(previous, next) &&+ next.points.length >= previous.points.length &&+ previous.points.every((point, i) => point === next.points[i]))+ );+}++/** Whether `after` only appends strokes or points to `before`. */+function extendsStrokes(+ before: readonly BrushStroke[],+ after: readonly BrushStroke[],+) {+ return (+ after.length >= before.length &&+ before.every((stroke, i) =>+ i === before.length - 1+ ? extendsStroke(stroke, after[i])+ : stroke === after[i],+ )+ );+}++function sameOps(a: readonly MaskModifier[], b: readonly MaskModifier[]) {+ return (+ a.length === b.length &&+ a.every(+ (op, i) =>+ op.mask === b[i].mask &&+ op.operation === b[i].operation &&+ op.opacity === b[i].opacity,+ )+ );+}++const over: BlendOptions = { color: { src: "one", dst: "one-minus-src" } };+const out: BlendOptions = { color: { src: "zero", dst: "one-minus-src" } };+const add: BlendOptions = { color: { src: "one", dst: "one" } };+const subtract: BlendOptions = {+ color: { src: "one", dst: "one", op: "reverse-subtract" },+};++/**+ * Rasterizes brush coverage into r8unorm textures at source resolution. Each brush owns the+ * coverage of its strokes, stamped incrementally as they grow and replayed when earlier content+ * changes; a mask shaped by children combines its own coverage with theirs in a second texture,+ * rebuilt whenever any of them changes. Strokes stay the document's truth; textures are caches.+ */+export function createMaskRaster(gpu: Gpu) {+ const brushes = new Map<string, Brush>();+ const groups = new Map<string, Group>();+ const used = new Set<Brush | Group>();+ const dabs: Buffer = gpu.device.createBuffer({+ size: chunk * 16,+ usage: ["storage", "copy_dst"],+ });+ const paint = effect(gpu, strokeShader, { blend: over, set: { dabs } });+ const erase = effect(gpu, strokeShader, { blend: out, set: { dabs } });+ const gradientAdd = effect(gpu, gradientShader, { blend: add });+ const gradientSubtract = effect(gpu, gradientShader, { blend: subtract });+ const brushAdd = effect(gpu, brushShader, { blend: add });+ const brushSubtract = effect(gpu, brushShader, { blend: subtract });+ let stamped = 0;++ function clear(target: Target) {+ frame(gpu, (frame) => frame.pass({ target, clear: true }, () => {}));+ }++ function stampDabs(+ target: Target,+ dabList: readonly Dab[],+ feather: number,+ mode: BrushStroke["mode"],+ ) {+ const [width, height] = target.size;+ for (let start = 0; start < dabList.length; start += chunk) {+ const batch = dabList.slice(start, start + chunk);+ let left = width;+ let top = height;+ let right = 0;+ let bottom = 0;+ const data = new Float32Array(batch.length * 4);+ batch.forEach((dab, i) => {+ data.set(dab, i * 4);+ left = Math.min(left, dab[0] - dab[2]);+ top = Math.min(top, dab[1] - dab[2]);+ right = Math.max(right, dab[0] + dab[2]);+ bottom = Math.max(bottom, dab[1] + dab[2]);+ });+ const x = Math.max(0, Math.floor(left) - 1);+ const y = Math.max(0, Math.floor(top) - 1);+ const w = Math.min(width, Math.ceil(right) + 1) - x;+ const h = Math.min(height, Math.ceil(bottom) + 1) - y;+ if (w <= 0 || h <= 0) {+ continue;+ }+ dabs.write(data);+ const pass = mode === "paint" ? paint : erase;+ pass.set({ params: { count: batch.length, feather } });+ // One frame per chunk: buffer and uniform writes land in queue order, before the pass that reads them.+ frame(gpu, (frame) =>+ frame.pass({ target, clear: false, scissor: [x, y, w, h] }, pass),+ );+ stamped += batch.length;+ }+ }++ /** Stamps strokes from `fromStroke` on, skipping `skipDabs` of that first one; returns the last stroke's dab count. */+ function stampStrokes(+ target: Target,+ strokes: readonly BrushStroke[],+ fromStroke = 0,+ skipDabs = 0,+ ) {+ let count = 0;+ strokes.forEach((stroke, i) => {+ if (i < fromStroke) {+ return;+ }+ const all = strokeDabs(stroke);+ count = all.length;+ stampDabs(+ target,+ i === fromStroke ? all.slice(skipDabs) : all,+ stroke.feather,+ stroke.mode,+ );+ });+ return count;+ }++ /** The entry for `id` at `size`, created or resized as needed, and marked as in use. */+ function reserve<E extends Brush | Group>(+ map: Map<string, E>,+ id: string,+ size: Size,+ create: (target: Target) => E,+ ) {+ let entry = map.get(id);+ if (+ entry &&+ (entry.target.size[0] !== size[0] || entry.target.size[1] !== size[1])+ ) {+ entry.target.color.dispose();+ entry = undefined;+ }+ if (!entry) {+ entry = create(target(gpu, { size: [...size], format: "r8unorm" }));+ map.set(id, entry);+ }+ used.add(entry);+ return entry;+ }++ /** Brings one brush's coverage up to date: appended points stamp, any other change replays every stroke. */+ function updateBrush(+ id: string,+ strokes: readonly BrushStroke[],+ size: Size,+ ) {+ const brush = reserve(brushes, id, size, (target) => ({+ target,+ strokes: [],+ dabs: 0,+ }));+ const applied = brush.strokes;+ if (applied === strokes) {+ return;+ }+ if (applied.length && extendsStrokes(applied, strokes)) {+ brush.dabs = stampStrokes(+ brush.target,+ strokes,+ applied.length - 1,+ brush.dabs,+ );+ } else {+ clear(brush.target);+ brush.dabs = stampStrokes(brush.target, strokes);+ }+ brush.strokes = strokes;+ }++ /** The pass that adds or subtracts one op's coverage, or nothing for a brush without strokes. */+ function opPass(op: MaskModifier) {+ if (op.mask.kind !== "brush") {+ const pass = op.operation === "add" ? gradientAdd : gradientSubtract;+ return pass.set({+ params: { ...gradientParams(op.mask), opacity: op.opacity },+ });+ }+ const brush = covers(op) ? brushes.get(op.id) : undefined;+ if (!brush) {+ return undefined;+ }+ const pass = op.operation === "add" ? brushAdd : brushSubtract;+ return pass.set({+ coverage: brush.target.color,+ params: { opacity: op.opacity },+ });+ }++ /** Combines a mask's own coverage with its children's in stored order, once any of them changed. */+ function updateGroup(id: string, ops: readonly MaskModifier[], size: Size) {+ const group = reserve(groups, id, size, (target) => ({ target, ops: [] }));+ if (sameOps(group.ops, ops)) {+ return group;+ }+ clear(group.target);+ for (const op of ops) {+ const pass = opPass(op);+ if (pass) {+ // One frame per pass: uniform writes land in queue order, before the pass that reads them.+ frame(gpu, (frame) =>+ frame.pass({ target: group.target, clear: false }, pass),+ );+ }+ }+ group.ops = ops;+ return group;+ }++ function release<E extends Brush | Group>(map: Map<string, E>) {+ for (const [id, entry] of map) {+ if (!used.has(entry)) {+ entry.target.color.dispose();+ map.delete(id);+ }+ }+ }++ return {+ /** Brings the layer's rasters up to date and returns the coverage its composition samples, if any. */+ update(layer: MaskLayer, size: Size): RenderInput | undefined {+ const [own, ...children] = maskOps(layer);+ const active = children.filter(covers);+ const ops = [own, ...active];+ for (const op of ops) {+ if (op.mask.kind === "brush" && covers(op)) {+ updateBrush(op.id, op.mask.strokes, size);+ }+ }+ if (own.mask.kind !== "brush") {+ // Gradient children combine in the mix pass; a painted brush child needs a raster.+ return active.some((op) => op.mask.kind === "brush")+ ? input(updateGroup(layer.id, ops, size).target)+ : undefined;+ }+ if (active.length === 0) {+ // Nothing shapes the brush, so its own coverage is the mask's; without strokes the layer is bypassed.+ const brush = covers(own) ? brushes.get(own.id) : undefined;+ return brush && input(brush.target);+ }+ if (!covers(own) && !active.some((op) => op.operation === "add")) {+ return undefined;+ }+ return input(updateGroup(layer.id, ops, size).target);+ },+ /** A mask's combined coverage, or a brush's own. */+ get(id: string): RenderInput | undefined {+ const raster = groups.get(id) ?? brushes.get(id);+ return raster && input(raster.target);+ },+ /** Releases the rasters that no update used since the previous sweep. */+ sweep() {+ release(brushes);+ release(groups);+ used.clear();+ },+ inspect() {+ return {+ stamped,+ rasters: [+ ...[...brushes].map(([id, { target }]) => ({+ id,+ size: [...target.size],+ })),+ ...[...groups].map(([id, { target }]) => ({+ id: `${id}/group`,+ size: [...target.size],+ })),+ ],+ };+ },+ dispose() {+ for (const { target } of [...brushes.values(), ...groups.values()]) {+ target.color.dispose();+ }+ brushes.clear();+ groups.clear();+ dabs.dispose();+ },+ };+}diff --git a/src/core/renderer/mask/strokes.wgsl b/src/core/renderer/mask/strokes.wgslnew file mode 100644index 0000000..f329939--- /dev/null+++ b/src/core/renderer/mask/strokes.wgsl@@ -0,0 +1,21 @@+// Accumulates a chunk of dabs like successive layers of paint: each dab covers its share of what is left.+// The pass blends the result into the mask, so chunks and strokes compose exactly.+struct Params {+ count: u32,+ feather: f32,+}+@group(0) @binding(0) var<storage, read> dabs: array<vec4f>;+@group(0) @binding(1) var<uniform> params: Params;++@fragment fn fs_main(@builtin(position) position: vec4f) -> @location(0) vec4f {+ var remaining = 1.0;+ for (var i = 0u; i < params.count; i++) {+ let dab = dabs[i];+ let radius = max(dab.z, 0.5);+ // At least a half-pixel transition keeps hard brushes from aliasing.+ let inner = min(radius * (1.0 - params.feather), radius - 0.5);+ let weight = 1.0 - smoothstep(inner, radius, length(position.xy - dab.xy));+ remaining *= 1.0 - dab.w * weight;+ }+ return vec4f(1.0 - remaining, 0.0, 0.0, 1.0);+}diff --git a/src/core/renderer/node.ts b/src/core/renderer/node.tsindex b3e680e..c6e5b03 100644--- a/src/core/renderer/node.ts+++ b/src/core/renderer/node.ts@@ -11,15 +11,19 @@ export type NodeDefinition = NodeOptions & {readonly name: string;readonly shader: string | ShaderSource;};+/** Source pixels per texel on each axis; a proxy is reduced, so its geometry scales up. */+export type Scale = readonly [number, number];export type RenderInput = {readonly target: Target;readonly size: readonly [number, number];readonly format: GPUTextureFormat;+ readonly scale: Scale;};export type RenderNode = NodeDefinition & {readonly inputs: Readonly<Record<string, RenderImage>>;readonly size: readonly [number, number];readonly format: GPUTextureFormat;+ readonly scale: Scale;};export type RenderImage = RenderInput | RenderNode;export type RenderStep =@@ -28,8 +32,16 @@ export type RenderStep =| undefined;/** Imports a caller-owned texture without copying or allocating GPU resources. */-export function input(target: Target): RenderInput {- return { target, size: target.size, format: target.format };+export function input(target: Target, scale: Scale = [1, 1]): RenderInput {+ return { target, size: target.size, format: target.format, scale };+}++/** The source dimensions an image stands for, whatever its texel count. */+export function sourceSize(image: RenderImage): [number, number] {+ return [+ Math.round(image.size[0] * image.scale[0]),+ Math.round(image.size[1] * image.scale[1]),+ ];}export function node(@@ -54,6 +66,7 @@ export function merge(inputs,size: definition.size ?? first.size,format: definition.format ?? first.format,+ scale: first.scale,};}diff --git a/src/core/renderer/proxy/index.ts b/src/core/renderer/proxy/index.tsnew file mode 100644index 0000000..23ac3aa--- /dev/null+++ b/src/core/renderer/proxy/index.ts@@ -0,0 +1,52 @@+import { effect, frame, type Gpu, type Target, target } from "vgpu";+import { input, type RenderInput } from "@/core/renderer/node";+import shader from "./proxy.wgsl";++type Cached = {+ source: Target;+ factor: number;+ version: number;+ output: Target;+};++/** A reduced copy of the source for interactive rendering, kept until the source, factor, or version changes. */+export function createProxy(gpu: Gpu) {+ const reduce = effect(gpu, shader);+ let cached: Cached | undefined;+ return {+ render(source: Target, factor: number, version = 0): RenderInput {+ const size: [number, number] = [+ Math.max(1, Math.ceil(source.size[0] / factor)),+ Math.max(1, Math.ceil(source.size[1] / factor)),+ ];+ if (+ !cached ||+ cached.source !== source ||+ cached.factor !== factor ||+ cached.version !== version+ ) {+ let output = cached?.output;+ if (+ !output ||+ output.size[0] !== size[0] ||+ output.size[1] !== size[1] ||+ output.format !== source.format+ ) {+ output?.color.dispose();+ output = target(gpu, { size, format: source.format });+ }+ reduce.set({ source: source.color, factor });+ frame(gpu, (frame) => frame.pass(output, reduce));+ cached = { source, factor, version, output };+ }+ return input(cached.output, [+ source.size[0] / size[0],+ source.size[1] / size[1],+ ]);+ },+ dispose() {+ cached?.output.color.dispose();+ cached = undefined;+ },+ };+}diff --git a/src/core/renderer/proxy/proxy.wgsl b/src/core/renderer/proxy/proxy.wgslnew file mode 100644index 0000000..0983b9c--- /dev/null+++ b/src/core/renderer/proxy/proxy.wgsl@@ -0,0 +1,15 @@+// Box-filters factor × factor source texels into one; edge blocks repeat the last texel.+@group(0) @binding(0) var source: texture_2d<f32>;+@group(0) @binding(1) var<uniform> factor: i32;++@fragment fn fs_main(@builtin(position) position: vec4f) -> @location(0) vec4f {+ let origin = vec2i(position.xy) * factor;+ let limit = vec2i(textureDimensions(source)) - 1;+ var total = vec4f(0.0);+ for (var y = 0; y < factor; y++) {+ for (var x = 0; x < factor; x++) {+ total += textureLoad(source, min(origin + vec2i(x, y), limit), 0);+ }+ }+ return total / f32(factor * factor);+}diff --git a/src/core/renderer/transform/index.ts b/src/core/renderer/transform/index.tsindex 026d0d6..2eb42d3 100644--- a/src/core/renderer/transform/index.ts+++ b/src/core/renderer/transform/index.ts@@ -4,15 +4,20 @@ import {type ImageFrame,imageFrame,} from "@/core/image/frame";-import { merge, node, type RenderImage } from "@/core/renderer/node";+import {+ merge,+ node,+ type RenderImage,+ sourceSize,+} from "@/core/renderer/node";import shader from "./frame.wgsl";-/** Equal inputs share a transform node; identity geometry preserves the input. */+/** Equal inputs share a transform node; identity geometry preserves the input. A proxy keeps its reduction. */export function transformImages(sources: readonly RenderImage[],geometry: ImageFrame,) {- const initial = frameValues(imageFrame(sources[0].size));+ const initial = frameValues(imageFrame(sourceSize(sources[0])));if (frameValues(geometry).every((value, i) => value === initial[i])) {return sources;}@@ -25,11 +30,14 @@ export function transformImages(const output = merge({ source: input },node(`transform/${i}`, shader, {- set: { transform: frameTransform(geometry, input.size) },+ set: { transform: frameTransform(geometry, sourceSize(input)) },samplers: {sourceSampler: { magFilter: "linear", minFilter: "linear" },},- size: [Math.round(geometry.size[0]), Math.round(geometry.size[1])],+ size: [+ Math.max(1, Math.round(geometry.size[0] / input.scale[0])),+ Math.max(1, Math.round(geometry.size[1] / input.scale[1])),+ ],}),);outputs.set(input, output);diff --git a/src/features/crop/view.tsx b/src/features/crop/view.tsxindex 46219d1..35eae99 100644--- a/src/features/crop/view.tsx+++ b/src/features/crop/view.tsx@@ -6,7 +6,7 @@ import { EditorViewport } from "@/components/editor/viewport";import { FlipIcon } from "@/components/icons/flip";import { RotateIcon } from "@/components/icons/rotate";import Button from "@/components/ui/button";-import { Field } from "@/components/ui/field";+import { Select } from "@/components/ui/select";import { Slider } from "@/components/ui/slider";import { imageFrame, type Point } from "@/core/image/frame";import { useShortcuts } from "@/hooks/use-shortcuts";@@ -111,25 +111,23 @@ export function CropEditor({ onClose }: { onClose: () => void }) {}><section aria-label="Crop tool" className="space-y-5 p-4">- <label className="flex items-center justify-between text-neutral-400">+ <div className="flex items-center justify-between text-neutral-400">Aspect ratio- <Field className="relative w-24">- <select- aria-label="Aspect ratio"- value={ratio ?? "free"}- className="w-full cursor-pointer bg-transparent px-1 text-neutral-100 outline-none [color-scheme:dark]"- onChange={(event) => changeRatio(event.currentTarget.value)}- >- <option value="free">Free</option>- {custom && <option value={ratio}>Current</option>}- {Object.entries(ratios).map(([label, value]) => (- <option key={label} value={value}>- {label}- </option>- ))}- </select>- </Field>- </label>+ <Select+ aria-label="Aspect ratio"+ value={ratio ?? "free"}+ className="w-24"+ onChange={(event) => changeRatio(event.currentTarget.value)}+ >+ <option value="free">Free</option>+ {custom && <option value={ratio}>Current</option>}+ {Object.entries(ratios).map(([label, value]) => (+ <option key={label} value={value}>+ {label}+ </option>+ ))}+ </Select>+ </div><sectionaria-label="Rotate and flip image"className="grid grid-cols-4 items-center gap-2"diff --git a/src/features/details/unsharp-mask.ts b/src/features/details/unsharp-mask.tsindex df5dc79..d8786fd 100644--- a/src/features/details/unsharp-mask.ts+++ b/src/features/details/unsharp-mask.ts@@ -1,7 +1,7 @@import { merge, node, type RenderImage, split } from "@/core/renderer";import shader from "./unsharp-mask.wgsl";-/** Builds a separable luminance blur and combines it with the unchanged input. */+/** Builds a separable luminance blur and combines it with the unchanged input; the radius is in source pixels. */export function unsharpMask(name: string,amount: number,@@ -19,7 +19,11 @@ export function unsharpMask(const samplers = {linearSampler: { minFilter: "linear", magFilter: "linear" },} as const;- const params = { reduction, amount, sigma: radius / reduction };+ const params = {+ reduction,+ amount,+ sigma: radius / (reduction * image.scale[0]),+ };function blur(label: string, mode: number) {const pass = node(`${name}/${label}`, shader, {size,diff --git a/src/features/fill/controls.tsx b/src/features/fill/controls.tsxnew file mode 100644index 0000000..8b08eae--- /dev/null+++ b/src/features/fill/controls.tsx@@ -0,0 +1,63 @@+import { useEffect, useRef } from "react";+import { useDocument } from "@/components/editor/session";+import { Select } from "@/components/ui/select";+import type { Fill } from "@/core/document";+import { setFill } from "./edits";+import { blends } from "./model";++export function FillControls({ id, fill }: { id: string; fill: Fill }) {+ const document = useDocument();+ const picker = useRef<HTMLInputElement>(null);+ // The picker streams input events while dragging; its native change event closes the gesture.+ useEffect(() => {+ const input = picker.current;+ const commit = () => document.history.commit();+ input?.addEventListener("change", commit);+ return () => input?.removeEventListener("change", commit);+ }, [document]);+ return (+ <section className="flex flex-col gap-3 p-3">+ <label className="flex items-center justify-between text-neutral-400">+ Color+ <span className="flex items-center gap-2">+ <span className="text-neutral-100 uppercase tabular-nums">+ {fill.color}+ </span>+ <input+ ref={picker}+ type="color"+ aria-label="Color"+ value={fill.color}+ className="h-6 w-9 cursor-pointer rounded border border-black bg-transparent p-0.5"+ onChange={(event) => {+ document.history.begin();+ setFill(document, { color: event.currentTarget.value }, id);+ }}+ />+ </span>+ </label>+ <div className="flex items-center justify-between text-neutral-400">+ Blend+ <Select+ aria-label="Blend"+ value={fill.blend}+ className="w-28"+ onChange={(event) => {+ const blend = blends.find(+ ([blend]) => blend === event.currentTarget.value,+ );+ if (blend) {+ setFill(document, { blend: blend[0] }, id);+ }+ }}+ >+ {blends.map(([blend, label]) => (+ <option key={blend} value={blend}>+ {label}+ </option>+ ))}+ </Select>+ </div>+ </section>+ );+}diff --git a/src/features/fill/edits.ts b/src/features/fill/edits.tsnew file mode 100644index 0000000..15f9511--- /dev/null+++ b/src/features/fill/edits.ts@@ -0,0 +1,23 @@+import { type EditorDocument, editLayer, type Fill } from "@/core/document";+import { validateFill } from "./model";++export function setFill(+ document: EditorDocument,+ change: Partial<Fill>,+ id: string,+) {+ validateFill(change);+ editLayer(document, id, (layer) => {+ if (layer.kind !== "fill") {+ throw Error("Select a color layer.");+ }+ return {+ ...layer,+ fill: {+ ...layer.fill,+ ...change,+ ...(change.color ? { color: change.color.toLowerCase() } : {}),+ },+ };+ });+}diff --git a/src/features/fill/fill.wgsl b/src/features/fill/fill.wgslnew file mode 100644index 0000000..9c4df34--- /dev/null+++ b/src/features/fill/fill.wgsl@@ -0,0 +1,64 @@+import { linearToSrgb3, srgbToLinear3 } from "@vgpu/wgsl-std/color";+import { srgbToRec2020 } from "../../core/image/color.wgsl";++// Photoshop's blend formulas on encoded values: the working RGB and the sRGB color both take the+// sRGB transfer first, so Multiply, Overlay and the rest look as they do in Photoshop. HDR input+// is clamped where the fill applies.+struct Params {+ color: vec3f,+ blend: u32,+}+@group(0) @binding(0) var source: texture_2d<f32>;+@group(0) @binding(1) var<uniform> params: Params;++fn lum(color: vec3f) -> f32 {+ return dot(color, vec3f(0.3, 0.59, 0.11));+}++fn clipColor(color: vec3f) -> vec3f {+ let l = lum(color);+ let low = min(color.r, min(color.g, color.b));+ let high = max(color.r, max(color.g, color.b));+ var result = color;+ if (low < 0.0) {+ result = l + (result - l) * l / (l - low);+ }+ if (high > 1.0) {+ result = l + (result - l) * (1.0 - l) / (high - l);+ }+ return result;+}++fn setLum(color: vec3f, l: f32) -> vec3f {+ return clipColor(color + (l - lum(color)));+}++fn softLight(base: vec3f, blend: vec3f) -> vec3f {+ let d = select(sqrt(base), ((16.0 * base - 12.0) * base + 4.0) * base, base <= vec3f(0.25));+ return select(+ base + (2.0 * blend - 1.0) * (d - base),+ base - (1.0 - 2.0 * blend) * base * (1.0 - base),+ blend <= vec3f(0.5),+ );+}++fn blend(base: vec3f, blend: vec3f) -> vec3f {+ switch (params.blend) {+ case 1u: { return base * blend; }+ case 2u: { return base + blend - base * blend; }+ case 3u: {+ return select(1.0 - 2.0 * (1.0 - base) * (1.0 - blend), 2.0 * base * blend, base <= vec3f(0.5));+ }+ case 4u: { return softLight(base, blend); }+ case 5u: { return setLum(blend, lum(base)); }+ case 6u: { return setLum(base, lum(blend)); }+ default: { return blend; }+ }+}++@fragment fn fs_main(@builtin(position) position: vec4f) -> @location(0) vec4f {+ let input = textureLoad(source, vec2i(position.xy), 0);+ let base = linearToSrgb3(clamp(input.rgb, vec3f(0.0), vec3f(1.0)));+ let paint = linearToSrgb3(clamp(srgbToRec2020 * srgbToLinear3(params.color), vec3f(0.0), vec3f(1.0)));+ return vec4f(srgbToLinear3(clamp(blend(base, paint), vec3f(0.0), vec3f(1.0))), input.a);+}diff --git a/src/features/fill/model.ts b/src/features/fill/model.tsnew file mode 100644index 0000000..1c4ae8a--- /dev/null+++ b/src/features/fill/model.ts@@ -0,0 +1,35 @@+import type { Blend, Fill } from "@/core/document";++export const blends: readonly (readonly [Blend, string])[] = [+ ["normal", "Normal"],+ ["multiply", "Multiply"],+ ["screen", "Screen"],+ ["overlay", "Overlay"],+ ["soft-light", "Soft Light"],+ ["color", "Color"],+ ["luminosity", "Luminosity"],+];++export const defaultFill: Readonly<Fill> = {+ color: "#f0763c",+ blend: "normal",+};++export function validateFill(change: Partial<Fill>) {+ for (const [name, value] of Object.entries(change)) {+ const valid =+ name === "color"+ ? typeof value === "string" && /^#[0-9a-f]{6}$/i.test(value)+ : name === "blend" && blends.some(([blend]) => blend === value);+ if (!valid) {+ throw new Error(`Invalid fill setting: ${name}.`);+ }+ }+}++/** The sRGB channels of a `#rrggbb` color, 0 to 1. */+export function parseColor(color: string): [number, number, number] {+ return [1, 3, 5].map(+ (offset) => Number.parseInt(color.slice(offset, offset + 2), 16) / 255,+ ) as [number, number, number];+}diff --git a/src/features/fill/pass.ts b/src/features/fill/pass.tsnew file mode 100644index 0000000..9af2568--- /dev/null+++ b/src/features/fill/pass.ts@@ -0,0 +1,15 @@+import type { Fill } from "@/core/document";+import { node } from "@/core/renderer";+import shader from "./fill.wgsl";+import { blends, parseColor } from "./model";++export function fill(settings: Fill, name = "fill") {+ return node(name, shader, {+ set: {+ params: {+ color: parseColor(settings.color),+ blend: blends.findIndex(([blend]) => blend === settings.blend),+ },+ },+ });+}diff --git a/src/features/histogram/histogram.wgsl b/src/features/histogram/histogram.wgslindex be21c3b..f450de5 100644--- a/src/features/histogram/histogram.wgsl+++ b/src/features/histogram/histogram.wgsl@@ -16,27 +16,32 @@ const samples = vec2u(512, 320);const weight = 1024u;// Splits one texel's vote between its two nearest bins instead of flooring into a single one.-fn softBin(channel: u32, position: f32) {+fn softBin(channel: u32, position: f32, vote: u32) {let clamped = clamp(position, 0.0, 255.0);let lo = u32(floor(clamped));let hi = min(lo + 1u, 255u);- let hiWeight = u32(round((clamped - f32(lo)) * f32(weight)));- atomicAdd(&bins[channel * 256u + lo], weight - hiWeight);+ let hiWeight = u32(round((clamped - f32(lo)) * f32(vote)));+ atomicAdd(&bins[channel * 256u + lo], vote - hiWeight);atomicAdd(&bins[channel * 256u + hi], hiWeight);}+// Alpha weighs each vote: transparent pixels, or those outside a mask's coverage, do not count.@compute @workgroup_size(16, 16) fn count(@builtin(global_invocation_id) id: vec3u) {if (any(id.xy >= samples)) {return;}- let texel = textureLoad(source, id.xy * textureDimensions(source) / samples, 0).rgb;- var encoded = display(texel);+ let texel = textureLoad(source, id.xy * textureDimensions(source) / samples, 0);+ let vote = u32(round(clamp(texel.a, 0.0, 1.0) * f32(weight)));+ if (vote == 0u) {+ return;+ }+ var encoded = display(texel.rgb);if (params.working != 0u) {- encoded = linearToSrgb3(clamp(texel, vec3f(0.0), vec3f(1.0)));+ encoded = linearToSrgb3(clamp(texel.rgb, vec3f(0.0), vec3f(1.0)));}- softBin(0u, encoded.r * 255.0);- softBin(1u, encoded.g * 255.0);- softBin(2u, encoded.b * 255.0);+ softBin(0u, encoded.r * 255.0, vote);+ softBin(1u, encoded.g * 255.0, vote);+ softBin(2u, encoded.b * 255.0, vote);}var<workgroup> peaks: array<f32, 256>;diff --git a/src/features/layers/brush-options.tsx b/src/features/layers/brush-options.tsxnew file mode 100644index 0000000..1fa6324--- /dev/null+++ b/src/features/layers/brush-options.tsx@@ -0,0 +1,64 @@+import { Slider } from "@/components/ui/slider";+import { useBrushTool } from "./brush-tool";+import { barSlider, useBarDensity } from "./toolbar";++const modes = [+ ["paint", "Paint", "Add coverage"],+ ["erase", "Erase", "Remove coverage (Alt while painting)"],+] as const;++/** The next stroke's mode, size, edge, and flow, in the bar over the canvas. Alt shows on the Erase chip. */+export function BrushOptions() {+ const { settings, erase, maxSize, update } = useBrushTool();+ const variant = barSlider(useBarDensity());+ return (+ <>+ <fieldset+ aria-label="Brush mode"+ className="flex gap-0.5 rounded-full bg-white/5 p-0.5"+ >+ {modes.map(([mode, label, title]) => (+ <button+ key={mode}+ type="button"+ aria-pressed={erase === (mode === "erase")}+ title={title}+ onClick={() => update({ erase: mode === "erase" })}+ className="h-6 rounded-full px-2.5 text-neutral-400 hover:bg-white/10 hover:text-neutral-100 aria-pressed:bg-white/15 aria-pressed:text-neutral-100 pointer-coarse:h-8"+ >+ {label}+ </button>+ ))}+ </fieldset>+ <Slider+ label="Size"+ value={settings.size}+ min={1}+ max={maxSize}+ unit="px"+ variant={variant}+ onChange={(size) => update({ size: Math.round(size) })}+ />+ <Slider+ label="Feather"+ value={Math.round(settings.feather * 100)}+ min={0}+ max={100}+ defaultValue={50}+ unit="%"+ variant={variant}+ onChange={(value) => update({ feather: value / 100 })}+ />+ <Slider+ label="Flow"+ value={Math.round(settings.flow * 100)}+ min={1}+ max={100}+ defaultValue={100}+ unit="%"+ variant={variant}+ onChange={(value) => update({ flow: value / 100 })}+ />+ </>+ );+}diff --git a/src/features/layers/brush-overlay.tsx b/src/features/layers/brush-overlay.tsxnew file mode 100644index 0000000..dddcfdd--- /dev/null+++ b/src/features/layers/brush-overlay.tsx@@ -0,0 +1,235 @@+import { type PointerEvent, useEffect, useId, useRef, useState } from "react";+import { useDocumentMapping } from "@/components/editor/mapping";+import { useDocument } from "@/components/editor/session";+import { useViewport } from "@/components/editor/viewport";+import { findLayer, type StrokePoint } from "@/core/document";+import type { Point } from "@/core/image/frame";+import { useShortcuts } from "@/hooks/use-shortcuts";+import { useBrushTool } from "./brush-tool";+import { extendStroke, paintStroke } from "./edits";+import { useMaskTool } from "./mask-tool";++type Stroke = {+ pointer: number;+ /** The viewport bounds measured once; pointer capture keeps them valid for the drag. */+ box: DOMRect | undefined;+ id: string;+ pending: StrokePoint[];+ frame?: number;+};++type PointerLike = {+ clientX: number;+ clientY: number;+ pressure: number;+ pointerType: string;+};++/**+ * Paints into the selected brush mask, which the tool keeps selected: choosing the tool creates that+ * mask at once, so adjustments before the first stroke belong to it, and leaving with it untouched+ * removes it and its history entry. Once the selection is no longer a brush mask, the tool leaves.+ */+export function BrushOverlay() {+ const document = useDocument();+ const tool = useMaskTool();+ const brush = useBrushTool();+ const camera = useViewport();+ const mapping = useDocumentMapping();+ const stroke = useRef<Stroke | null>(null);+ const [pointer, setPointer] = useState<Point | null>(null);+ const { erase } = brush;+ const gradient = useId();+ function selectedBrush() {+ const layer = findLayer(+ document.scene.getState().layers,+ document.selection.getState().layerId,+ );+ return layer?.kind === "mask" && layer.mask.kind === "brush"+ ? layer.id+ : undefined;+ }+ function point(event: PointerLike, box: DOMRect | undefined): StrokePoint {+ const [x, y] = mapping.toDocument(event.clientX, event.clientY, box);+ return [x, y, event.pointerType === "pen" ? event.pressure : 1];+ }+ /** Ends the stroke; a cancelled stroke restores the scene. */+ function finish(commit: boolean) {+ const current = stroke.current;+ if (!current) {+ return;+ }+ stroke.current = null;+ if (current.frame !== undefined) {+ cancelAnimationFrame(current.frame);+ }+ if (commit) {+ flush(current);+ document.history.commit();+ return;+ }+ document.history.cancel();+ }+ function flush(current: Stroke) {+ current.frame = undefined;+ if (!current.pending.length) {+ return;+ }+ const points = current.pending;+ current.pending = [];+ try {+ extendStroke(document, current.id, points);+ } catch {+ finish(false);+ }+ }+ useEffect(() => () => finish(false), []);+ useEffect(() => {+ // A chosen nesting starts a new brush even over a selected one.+ const before =+ tool.pending?.shape === "brush" || !selectedBrush()+ ? document.scene.getState()+ : undefined;+ if (before) {+ tool.create({ kind: "brush", strokes: [] });+ }+ const unsubscribe = document.selection.subscribe(() => {+ if (!selectedBrush()) {+ tool.edit();+ }+ });+ return () => {+ unsubscribe();+ // The new mask leaves with the tool unless anything happened after its creation.+ if (before) {+ document.history.drop(before);+ }+ };+ }, []);+ useShortcuts({+ escape: () => (stroke.current ? finish(false) : tool.edit()),+ enter: () => {+ if (!stroke.current) {+ tool.edit();+ }+ },+ "[": () => brush.update({ size: Math.round(brush.settings.size / 1.25) }),+ "]": () => brush.update({ size: Math.round(brush.settings.size * 1.25) }),+ });+ function start(event: PointerEvent<HTMLDivElement>) {+ if (event.button !== 0 || !event.isPrimary || camera.panMode) {+ return;+ }+ const id = selectedBrush();+ if (!id) {+ return;+ }+ const box = camera.ref.current?.getBoundingClientRect();+ document.history.begin();+ paintStroke(document, id, {+ mode: erase ? "erase" : "paint",+ size: brush.settings.size,+ feather: brush.settings.feather,+ flow: brush.settings.flow,+ points: [point(event, box)],+ });+ stroke.current = { pointer: event.pointerId, box, id, pending: [] };+ // The viewport below would otherwise capture the pointer to pan.+ event.preventDefault();+ event.stopPropagation();+ event.currentTarget.setPointerCapture(event.pointerId);+ if (window.document.activeElement instanceof HTMLElement) {+ window.document.activeElement.blur();+ }+ }+ function move(event: PointerEvent<HTMLDivElement>) {+ const bounds = event.currentTarget.getBoundingClientRect();+ setPointer([event.clientX - bounds.left, event.clientY - bounds.top]);+ const current = stroke.current;+ if (!current || current.pointer !== event.pointerId) {+ return;+ }+ const native = event.nativeEvent;+ const events = native.getCoalescedEvents?.() ?? [];+ for (const item of events.length ? events : [native]) {+ current.pending.push(point(item, current.box));+ }+ // One edit per frame keeps the queue from outrunning the display.+ current.frame ??= requestAnimationFrame(() => flush(current));+ }+ function end(event: PointerEvent<HTMLDivElement>) {+ const current = stroke.current;+ if (!current || current.pointer !== event.pointerId) {+ return;+ }+ finish(true);+ event.currentTarget.releasePointerCapture(event.pointerId);+ }+ const radius = brush.settings.size / 2 / mapping.pixelsPerViewportPixel;+ return (+ <div+ role="application"+ aria-label="Brush canvas"+ className="absolute inset-0 cursor-none touch-none data-[pan=true]:pointer-events-none"+ data-pan={camera.panMode}+ onDoubleClick={(event) => event.stopPropagation()}+ onPointerDown={start}+ onPointerMove={move}+ onPointerUp={end}+ onPointerLeave={() => setPointer(null)}+ onPointerCancel={() => finish(false)}+ onLostPointerCapture={() => finish(false)}+ >+ {pointer && !camera.panMode && (+ <svg+ aria-hidden="true"+ className="pointer-events-none absolute inset-0 size-full overflow-visible"+ >+ <defs>+ {/* The fill previews the dab: solid inside the feather, fading to the edge. */}+ <radialGradient id={gradient} cx="0.5" cy="0.5" r="0.5">+ <stop+ offset="0"+ stopColor={erase ? "black" : "white"}+ stopOpacity="0.3"+ />+ <stop+ offset={1 - brush.settings.feather}+ stopColor={erase ? "black" : "white"}+ stopOpacity="0.3"+ />+ <stop+ offset="1"+ stopColor={erase ? "black" : "white"}+ stopOpacity="0"+ />+ </radialGradient>+ </defs>+ <circle+ cx={pointer[0]}+ cy={pointer[1]}+ r={Math.max(2, radius)}+ fill={`url(#${gradient})`}+ stroke="white"+ strokeOpacity="0.9"+ strokeDasharray={erase ? "4 3" : undefined}+ />+ <circle+ cx={pointer[0]}+ cy={pointer[1]}+ r={Math.max(2, radius)}+ fill="none"+ stroke="black"+ strokeOpacity="0.5"+ strokeWidth="3"+ strokeDasharray={erase ? "4 3" : undefined}+ style={{ paintOrder: "stroke" }}+ />+ </svg>+ )}+ <p className="pointer-events-none absolute bottom-3 left-3 rounded-full bg-neutral-800/80 px-3 py-1.5 text-white backdrop-blur-sm">+ Drag to paint · Alt erases · [ ] resize · Enter when done+ </p>+ </div>+ );+}diff --git a/src/features/layers/brush-tool.tsx b/src/features/layers/brush-tool.tsxnew file mode 100644index 0000000..1e68f87--- /dev/null+++ b/src/features/layers/brush-tool.tsx@@ -0,0 +1,73 @@+import {+ createContext,+ type ReactNode,+ useContext,+ useEffect,+ useState,+} from "react";+import { useDocument, useScene } from "@/components/editor/session";+import { clamp } from "@/lib/math";++export type BrushSettings = {+ /** Diameter in source pixels. */+ size: number;+ /** Soft edge as a fraction of the radius, 0 to 1. */+ feather: number;+ flow: number;+ erase: boolean;+};++const BrushTool = createContext<{+ settings: BrushSettings;+ /** The mode the next stroke uses: the setting, inverted while Alt is held. */+ erase: boolean;+ /** The largest useful diameter: half the image's long edge. */+ maxSize: number;+ update: (change: Partial<BrushSettings>) => void;+} | null>(null);++export function useBrushTool() {+ const tool = useContext(BrushTool);+ if (!tool) {+ throw new Error("A brush tool provider is required.");+ }+ return tool;+}++/** Brush settings outlive strokes and tool switches; they start relative to the image size. */+export function BrushProvider({ children }: { children: ReactNode }) {+ const document = useDocument();+ const sourceId = useScene((scene) => scene.layers[0].source);+ const size = document.resources.get(sourceId).image.size;+ const maxSize = Math.max(1, Math.round(Math.max(size[0], size[1]) / 2));+ const [settings, setSettings] = useState<BrushSettings>({+ size: Math.max(1, Math.round(maxSize / 10)),+ feather: 0.5,+ flow: 1,+ erase: false,+ });+ const [alt, setAlt] = useState(false);+ useEffect(() => {+ const controller = new AbortController();+ const { signal } = controller;+ const track = (event: KeyboardEvent) => setAlt(event.altKey);+ window.addEventListener("keydown", track, { signal });+ window.addEventListener("keyup", track, { signal });+ window.addEventListener("blur", () => setAlt(false), { signal });+ return () => controller.abort();+ }, []);+ function update(change: Partial<BrushSettings>) {+ setSettings((settings) => ({+ ...settings,+ ...change,+ size: clamp(change.size ?? settings.size, 1, maxSize),+ }));+ }+ return (+ <BrushTool+ value={{ settings, erase: settings.erase !== alt, maxSize, update }}+ >+ {children}+ </BrushTool>+ );+}diff --git a/src/features/layers/controls.tsx b/src/features/layers/controls.tsxindex 1ae7b07..0803ea9 100644--- a/src/features/layers/controls.tsx+++ b/src/features/layers/controls.tsx@@ -9,6 +9,7 @@ import { useStore } from "zustand";import { PanelHeader } from "@/components/editor/panel";import { useDocument, useScene } from "@/components/editor/session";import { Icon } from "@/components/icons/icon";+import { Menu } from "@/components/ui/menu";import { ScrollArea } from "@/components/ui/scroll-area";import {TreeDrag,@@ -21,10 +22,11 @@ import {type Layer,type ProcessingLayer,} from "@/core/document";+import { useShortcuts } from "@/hooks/use-shortcuts";import { layerDrop } from "./drop";-import { moveLayer, setLayer } from "./edits";-import { useGradientTool } from "./gradient-tool";-import { LayerActions, LayerMenu } from "./menu";+import { deleteLayer, moveLayer, setLayer } from "./edits";+import { useMaskTool } from "./mask-tool";+import { LayerActions, MaskNesting } from "./menu";import { ImageThumbnail, MaskThumbnail } from "./thumbnails";function EffectSymbol({ kind }: { kind: ProcessingLayer["kind"] }) {@@ -61,7 +63,17 @@ function LayerThumbnail({ layer }: { layer: Layer }) {return <ImageThumbnail />;}if (layer.kind === "mask") {- return <MaskThumbnail mask={layer.mask} />;+ return <MaskThumbnail layer={layer} />;+ }+ if (layer.kind === "fill") {+ return (+ <span+ role="img"+ aria-label="Color thumbnail"+ className="block size-8 shrink-0 rounded-sm border border-neutral-600"+ style={{ background: layer.fill.color }}+ />+ );}return (<span className="grid size-8 shrink-0 place-items-center rounded border border-black/50 bg-neutral-950/40 text-neutral-400">@@ -235,6 +247,7 @@ const LayerRow = memo(function LayerRow({</Icon></span>)}+ {layer.kind === "mask" && !parent && <MaskNesting layer={layer} />}{layer.kind !== "image" && (<LayerActions layer={layer} onSelect={onSelect} />)}@@ -262,15 +275,24 @@ export function LayersControls({}) {const document = useDocument();const layers = useScene((scene) => scene.layers);- const tool = useGradientTool();- const { close } = tool;+ const tool = useMaskTool();+ // Choosing a mask edits it with the tool of its shape; anything else leaves editing.const select = useCallback((id: string) => {- close();document.selectLayer(id);+ const layer = findLayer(document.scene.getState().layers, id);+ tool.edit(layer?.kind === "mask" ? layer.mask.kind : undefined);},- [close, document],+ [document, tool.edit],);+ // The stack owns deletion, so it works with any tool on the canvas.+ function remove() {+ const id = document.selection.getState().layerId;+ if (findLayer(layers, id)?.kind !== "image") {+ deleteLayer(document, id);+ }+ }+ useShortcuts({ delete: remove, backspace: remove });function drop(target: TreeDrop) {const position = layerDrop(document.scene.getState(), target);if (position) {@@ -285,31 +307,7 @@ export function LayersControls({className="grid max-h-1/2 min-h-36 shrink-0 grid-rows-[auto_minmax(0,1fr)] border-t border-black bg-panel"><PanelHeader title="Layers">- <button- type="button"- aria-label="Add linear mask"- title="Draw a linear mask (L)"- onClick={() => tool.draw()}- className="grid size-7 place-items-center rounded-md text-neutral-400 hover:bg-neutral-700 hover:text-neutral-100 pointer-coarse:size-10"- >- <Icon className="size-4">- <rect x="4" y="4" width="16" height="16" rx="2" />- <circle cx="12" cy="12" r="4" fill="currentColor" stroke="none" />- </Icon>- </button>- <button- type="button"- aria-label="Add radial mask"- title="Draw a radial mask (R)"- onClick={() => tool.draw("radial")}- className="grid size-7 place-items-center rounded-md text-neutral-400 hover:bg-neutral-700 hover:text-neutral-100 pointer-coarse:size-10"- >- <Icon className="size-4">- <ellipse cx="12" cy="12" rx="9" ry="6" />- <circle cx="12" cy="12" r="2" fill="currentColor" stroke="none" />- </Icon>- </button>- <LayerMenu+ <Menulabel="Add effect"icon={<Icon className="size-4">@@ -329,7 +327,10 @@ export function LayersControls({<button type="submit" onClick={() => onAdd("vignette")}>Vignette</button>- </LayerMenu>+ <button type="submit" onClick={() => onAdd("fill")}>+ Color+ </button>+ </Menu></PanelHeader><ScrollArea fade><TreeDragdiff --git a/src/features/layers/edits.ts b/src/features/layers/edits.tsindex 82b8f24..33e4a56 100644--- a/src/features/layers/edits.ts+++ b/src/features/layers/edits.ts@@ -1,17 +1,60 @@import {+ type BrushStroke,type EditorDocument,editLayer,findLayer,- type Gradient,type Layer,locateLayer,+ type Mask,type ProcessingLayer,type Scene,+ type StrokePoint,updateLayer,walkLayers,} from "@/core/document";-function validateMask(mask: Gradient) {+function validPoints(points: readonly StrokePoint[]) {+ return (+ Array.isArray(points) &&+ points.length > 0 &&+ points.every(+ (point) =>+ Array.isArray(point) &&+ point.length === 3 &&+ point.every(Number.isFinite) &&+ point[2] >= 0 &&+ point[2] <= 1,+ )+ );+}++function validateStroke(stroke: BrushStroke) {+ if (+ (stroke.mode !== "paint" && stroke.mode !== "erase") ||+ !Number.isFinite(stroke.size) ||+ stroke.size <= 0 ||+ !Number.isFinite(stroke.feather) ||+ stroke.feather < 0 ||+ stroke.feather > 1 ||+ !Number.isFinite(stroke.flow) ||+ stroke.flow < 0 ||+ stroke.flow > 1 ||+ !validPoints(stroke.points)+ ) {+ throw Error(+ "A stroke needs a paint or erase mode, a positive size, feather and flow from 0 to 1, and finite points with pressure from 0 to 1.",+ );+ }+}++function validateMask(mask: Mask) {+ if (mask.kind === "brush") {+ if (!Array.isArray(mask.strokes)) {+ throw Error("A brush mask needs a list of strokes.");+ }+ mask.strokes.forEach(validateStroke);+ return;+ }if (mask.kind === "radial") {if (mask.center.length !== 2 ||@@ -167,11 +210,7 @@ export function setExposure(});}-export function setLayerMask(- document: EditorDocument,- id: string,- mask: Gradient,-) {+export function setLayerMask(document: EditorDocument, id: string, mask: Mask) {validateMask(mask);editLayer(document, id, (layer) => {if (layer.kind !== "mask") {@@ -181,6 +220,54 @@ export function setLayerMask(});}+function brushLayer(layer: Layer) {+ if (layer.kind !== "mask" || layer.mask.kind !== "brush") {+ throw Error("Select a brush mask.");+ }+ return { layer, strokes: layer.mask.strokes };+}++/** Starts a stroke on a brush mask; group it with the points that follow. */+export function paintStroke(+ document: EditorDocument,+ id: string,+ stroke: BrushStroke,+) {+ validateStroke(stroke);+ editLayer(document, id, (item) => {+ const { layer, strokes } = brushLayer(item);+ return {+ ...layer,+ mask: { kind: "brush", strokes: [...strokes, structuredClone(stroke)] },+ };+ });+}++/** Appends points to the mask's last stroke, keeping earlier points so rendering only stamps the new ones. */+export function extendStroke(+ document: EditorDocument,+ id: string,+ points: readonly StrokePoint[],+) {+ if (!validPoints(points)) {+ throw Error(+ "Stroke points need finite coordinates and pressure from 0 to 1.",+ );+ }+ editLayer(document, id, (item) => {+ const { layer, strokes } = brushLayer(item);+ const last = strokes.at(-1);+ if (!last) {+ throw Error("Start a stroke before extending it.");+ }+ const stroke = { ...last, points: [...last.points, ...points] };+ return {+ ...layer,+ mask: { kind: "brush", strokes: [...strokes.slice(0, -1), stroke] },+ };+ });+}+export function setMaskOperation(document: EditorDocument,id: string,diff --git a/src/features/layers/gradient-overlay.tsx b/src/features/layers/gradient-overlay.tsxindex 84cb871..d3ba3f7 100644--- a/src/features/layers/gradient-overlay.tsx+++ b/src/features/layers/gradient-overlay.tsx@@ -1,16 +1,12 @@-import { type PointerEvent, useEffect, useMemo, useRef, useState } from "react";+import { type PointerEvent, useEffect, useRef, useState } from "react";import { useStore } from "zustand";+import { useDocumentMapping } from "@/components/editor/mapping";import { useDocument, useScene } from "@/components/editor/session";import { useViewport } from "@/components/editor/viewport";-import {- type EditorDocument,- findLayer,- type Gradient,- maskModifiers,-} from "@/core/document";-import { outputOffset, type Point, sourceOffset } from "@/core/image/frame";+import { findLayer, type Gradient, locateLayer } from "@/core/document";+import type { Point } from "@/core/image/frame";import { useShortcuts } from "@/hooks/use-shortcuts";-import { deleteLayer, setLayerMask } from "./edits";+import { setLayerMask } from "./edits";import {drawGradient,type GradientHandle,@@ -18,7 +14,7 @@ import {moveGradient,} from "./gradient";import { GradientGuides } from "./gradient-guides";-import { useGradientTool } from "./gradient-tool";+import { type Nesting, useMaskTool } from "./mask-tool";type Drag = {pointer: number;@@ -29,25 +25,23 @@ type Drag = {mask: Gradient;handle: GradientHandle | "new";id: string;+ /** Alt while starting a drag subtracts the new gradient from the selected mask. */+ nesting?: Nesting;};-function hideOverlay(document: EditorDocument) {- if (document.preview.getState().maskOverlay) {- document.preview.setState({ maskOverlay: undefined });- }-}--export function GradientOverlay() {+/** Draws masks of one shape and edits the selected gradient's guides; Enter or Escape leaves. */+export function GradientOverlay({ shape }: { shape: Gradient["kind"] }) {const document = useDocument();- const tool = useGradientTool();+ const tool = useMaskTool();const camera = useViewport();- const frame = useScene((scene) => scene.frame);+ const mapping = useDocumentMapping();const selected = useStore(document.selection, (state) => state.layerId);const layer = useScene((scene) => {const item = findLayer(scene.layers, selected);return item?.kind === "mask" ? item : undefined;});- const mask = layer?.mask;+ /** Only gradients have guides; a brush mask keeps the deletion shortcuts. */+ const mask = layer?.mask.kind === "brush" ? undefined : layer?.mask;const [draft, setDraft] = useState<Gradient | null>(null);const dragging = useRef<Drag | null>(null);const [dragCursor, setDragCursor] = useState<string>();@@ -58,65 +52,28 @@ export function GradientOverlay() {}dragging.current = null;setDraft(null);+ tool.draft.setState(null);setDragCursor(undefined);- tool.close();}useEffect(() => () => {if (dragging.current && dragging.current.handle !== "new") {document.history.cancel();}+ tool.draft.setState(null);},- [document],+ [document, tool.draft],);- function remove() {- reset();- if (mask) {- deleteLayer(document, selected);- }- }- function dismiss() {- if (dragging.current || tool.target) {- reset();- return;- }- if (tool.overlay === "new" && mask) {- deleteLayer(document, selected);- }- tool.setOverlay("hidden");- }useShortcuts({- escape: dismiss,- ...(tool.overlay === "hidden"- ? {}- : { enter: () => tool.setOverlay("hidden") }),- ...(mask- ? { o: tool.toggleOverlay, delete: remove, backspace: remove }- : {}),+ escape: () => (dragging.current ? reset() : tool.edit()),+ enter: () => {+ if (!dragging.current) {+ tool.edit();+ }+ },});function documentPoint(event: PointerEvent, box: DOMRect | undefined): Point {- if (!box) {- return frame.center;- }- const offset = sourceOffset(- frame,- (event.clientX - box.left - box.width / 2 - camera.view.pan[0]) /- camera.scale,- (event.clientY - box.top - box.height / 2 - camera.view.pan[1]) /- camera.scale,- );- return [frame.center[0] + offset[0], frame.center[1] + offset[1]];- }- function screenPoint(point: Point): Point {- const [x, y] = outputOffset(- frame,- point[0] - frame.center[0],- point[1] - frame.center[1],- );- return [- camera.viewport[0] / 2 + camera.view.pan[0] + x * camera.scale,- camera.viewport[1] / 2 + camera.view.pan[1] + y * camera.scale,- ];+ return mapping.toDocument(event.clientX, event.clientY, box);}function start(event: PointerEvent<HTMLDivElement>) {if (event.button !== 0 || !event.isPrimary || camera.panMode) {@@ -129,20 +86,26 @@ export function GradientOverlay() {?.getAttribute("data-gradient-handle"): null;const handle = gradientHandles.find((handle) => handle === target);- if (!tool.target && (!mask || !handle)) {- return;- }+ // Guides win over drawing, unless a chosen nesting is waiting for this shape.+ const drawing = !handle || !mask || tool.pending?.shape === shape;const box = camera.ref.current?.getBoundingClientRect();const from = documentPoint(event, box);- if (tool.target) {+ if (drawing) {+ const location = locateLayer(document.scene.getState().layers, selected);+ const group =+ location?.parent?.kind === "mask" ? location.parent : location?.layer;dragging.current = {pointer: event.pointerId,box,from,to: from,- mask: drawGradient(tool.target.shape, from, from),+ mask: drawGradient(shape, from, from),handle: "new",id: selected,+ nesting:+ event.altKey && group?.kind === "mask"+ ? { parentId: group.id, operation: "subtract" }+ : undefined,};setDraft(dragging.current.mask);} else if (mask && handle) {@@ -163,7 +126,7 @@ export function GradientOverlay() {? getComputedStyle(event.target).cursor: "grab";const activeCursor = cursor === "grab" ? "grabbing" : cursor;- setDragCursor(tool.target ? "crosshair" : activeCursor);+ setDragCursor(drawing ? "crosshair" : activeCursor);event.preventDefault();event.stopPropagation();event.currentTarget.setPointerCapture(event.pointerId);@@ -188,6 +151,7 @@ export function GradientOverlay() {);drag.mask = next;setDraft(next);+ tool.draft.setState(next);} else {setLayerMask(document,@@ -207,8 +171,8 @@ export function GradientOverlay() {const distance =Math.hypot(point[0] - drag.from[0], point[1] - drag.from[1]) *camera.scale;- if (distance >= 3 && tool.target) {- tool.create(drag.mask, tool.target);+ if (distance >= 3) {+ tool.create(drag.mask, drag.nesting);}} else {document.history.commit();@@ -217,31 +181,16 @@ export function GradientOverlay() {event.currentTarget.releasePointerCapture(event.pointerId);}const visible = draft ?? mask;- const preview =- !!draft || dragCursor !== undefined || tool.overlay !== "hidden";- const modifiers = useMemo(- () => (draft || !layer ? [] : maskModifiers(layer)),- [draft, layer],- );- const shown = visible && preview && !camera.panMode;- useEffect(() => {- if (shown) {- document.preview.setState({ maskOverlay: { mask: visible, modifiers } });- return;- }- hideOverlay(document);- }, [document, shown, visible, modifiers]);- useEffect(() => () => hideOverlay(document), [document]);- const cursor = dragCursor ?? (tool.target ? "crosshair" : undefined);- const pointerEvents =- (tool.target || dragCursor) && !camera.panMode ? "auto" : "none";+ // The empty canvas draws, so it shows a crosshair; guides keep their own cursors until a drag starts.+ const cursor = dragCursor ?? "crosshair";return (<divrole="application"aria-label="Gradient mask canvas"- className="absolute inset-0 touch-none data-[cursor=true]:[&_*]:cursor-[inherit]!"- data-cursor={!!cursor}- style={{ pointerEvents, cursor }}+ className="absolute inset-0 touch-none data-[cursor=true]:[&_*]:cursor-[inherit]! data-[pan=true]:pointer-events-none"+ data-cursor={!!dragCursor}+ data-pan={camera.panMode}+ style={{ cursor }}onDoubleClick={(event) => event.stopPropagation()}onPointerDown={start}onPointerMove={move}@@ -256,20 +205,14 @@ export function GradientOverlay() {{visible && !camera.panMode && (<GradientGuidesmask={visible}- screen={screenPoint}+ screen={mapping.toScreen}extent={Math.hypot(...camera.viewport)}/>)}- {tool.overlay === "new" && !tool.target && (- <p className="pointer-events-none absolute bottom-3 left-3 rounded-full bg-neutral-800/80 px-3 py-1.5 text-white backdrop-blur-sm">- Adjust the mask · Enter to keep · Esc to remove · O toggles overlay- </p>- )}- {tool.target && (- <p className="pointer-events-none absolute bottom-3 left-3 rounded-full bg-neutral-800/80 px-3 py-1.5 text-white backdrop-blur-sm">- Drag to draw · Shift to constrain · Esc to cancel- </p>- )}+ <p className="pointer-events-none absolute bottom-3 left-3 rounded-full bg-neutral-800/80 px-3 py-1.5 text-white backdrop-blur-sm">+ Drag to draw · Shift constrains · Alt subtracts from the selected mask ·+ Enter when done+ </p></div>);}diff --git a/src/features/layers/gradient-tool.tsx b/src/features/layers/gradient-tool.tsxdeleted file mode 100644index 4444559..0000000--- a/src/features/layers/gradient-tool.tsx+++ /dev/null@@ -1,110 +0,0 @@-import {- createContext,- type ReactNode,- useCallback,- useContext,- useEffect,- useState,-} from "react";-import { useDocument } from "@/components/editor/session";-import { findLayer, type Gradient, type MaskLayer } from "@/core/document";--type NewMask = {- shape: Gradient["kind"];- parentId?: string;- operation: "add" | "subtract";-};--/** "new" previews a just-drawn mask until Enter, Escape, or its first adjustment. */-type Overlay = "hidden" | "shown" | "new";--const GradientTool = createContext<{- target: NewMask | null;- overlay: Overlay;- draw: (shape?: Gradient["kind"]) => void;- add: (- parentId: string,- operation: "add" | "subtract",- shape: Gradient["kind"],- ) => void;- close: () => void;- create: (mask: Gradient, target: NewMask) => void;- setOverlay: (overlay: Overlay) => void;- toggleOverlay: () => void;-} | null>(null);--export function useGradientTool() {- const tool = useContext(GradientTool);- if (!tool) {- throw new Error("A gradient tool provider is required.");- }- return tool;-}--/** Geometry edits keep the preview; effect edits end it. */-function adjusted(before: MaskLayer, after: MaskLayer) {- return (- before.adjustments !== after.adjustments ||- before.toneCurve !== after.toneCurve ||- before.children !== after.children ||- before.opacity !== after.opacity- );-}--export function GradientProvider({- children,- onCreate,-}: {- children: ReactNode;- onCreate: (mask: Gradient, target: NewMask) => void;-}) {- const [target, setTarget] = useState<NewMask | null>(null);- const [overlay, setOverlay] = useState<Overlay>("hidden");- const close = useCallback(() => setTarget(null), []);- const document = useDocument();- useEffect(- () =>- document.selection.subscribe(() => {- setTarget(null);- setOverlay("hidden");- }),- [document],- );- useEffect(- () =>- document.scene.subscribe((scene, previous) => {- const id = document.selection.getState().layerId;- const before = findLayer(previous.layers, id);- const after = findLayer(scene.layers, id);- if (- before?.kind === "mask" &&- after?.kind === "mask" &&- adjusted(before, after)- ) {- setOverlay("hidden");- }- }),- [document],- );- return (- <GradientTool- value={{- target,- overlay,- draw: (shape = "linear") => setTarget({ shape, operation: "add" }),- add: (parentId, operation, shape) =>- setTarget({ shape, parentId, operation }),- close,- create: (mask, target) => {- onCreate(mask, target);- setOverlay("new");- },- setOverlay,- toggleOverlay: () =>- setOverlay((overlay) => (overlay === "hidden" ? "shown" : "hidden")),- }}- >- {children}- </GradientTool>- );-}diff --git a/src/features/layers/mask-tool.tsx b/src/features/layers/mask-tool.tsxnew file mode 100644index 0000000..96f689a--- /dev/null+++ b/src/features/layers/mask-tool.tsx@@ -0,0 +1,108 @@+import {+ createContext,+ type ReactNode,+ useContext,+ useEffect,+ useMemo,+ useState,+} from "react";+import { createStore, type StoreApi } from "zustand/vanilla";+import { useDocument } from "@/components/editor/session";+import type { Gradient, Mask } from "@/core/document";++/** Where a new mask goes: inside a mask group, adding or subtracting coverage. */+export type Nesting = {+ parentId?: string;+ operation: "add" | "subtract";+};+type Pending = Nesting & { shape: Mask["kind"] };+type OverlayChoice = "auto" | "shown" | "hidden";++const MaskTool = createContext<{+ /** Chosen from a mask's Add or Subtract menu; the next mask of that shape goes there. */+ pending: Pending | null;+ add: (+ parentId: string,+ operation: Nesting["operation"],+ shape: Mask["kind"],+ ) => void;+ /** Adds the mask where `nesting` says, else where a pending choice says, else on top. */+ create: (mask: Mask, nesting?: Nesting) => void;+ /** The choice for the selected mask's overlay; auto shows it while the mask changes nothing yet. */+ overlay: OverlayChoice;+ showOverlay: (shown: boolean) => void;+ /** A gradient being drawn, not yet in the scene, tinted like a mask. */+ draft: StoreApi<Gradient | null>;+ /** Enters editing with the tool of a shape, or leaves it: the layer stays selected, its guides go. */+ edit: (shape?: Mask["kind"]) => void;+} | null>(null);++export function useMaskTool() {+ const tool = useContext(MaskTool);+ if (!tool) {+ throw new Error("A mask tool provider is required.");+ }+ return tool;+}++export function MaskToolProvider({+ children,+ onCreate,+ onTool,+ onDone,+}: {+ children: ReactNode;+ onCreate: (mask: Mask, nesting: Nesting) => void;+ /** Activates the tool that draws the shape. */+ onTool?: (shape: Mask["kind"]) => void;+ /** Returns to the tool without a mask canvas. */+ onDone?: () => void;+}) {+ const [pending, setPending] = useState<Pending | null>(null);+ const [overlay, setOverlay] = useState<OverlayChoice>("auto");+ const draft = useMemo(() => createStore<Gradient | null>(() => null), []);+ const document = useDocument();+ // A nesting and an overlay choice belong to the selection that made them.+ useEffect(+ () =>+ document.selection.subscribe(() => {+ setPending(null);+ setOverlay("auto");+ }),+ [document],+ );+ return (+ <MaskTool+ value={{+ pending,+ add: (parentId, operation, shape) => {+ setPending({ parentId, operation, shape });+ onTool?.(shape);+ },+ create: (mask, nesting) => {+ const chosen: Nesting =+ pending?.shape === mask.kind ? pending : { operation: "add" };+ setPending(null);+ onCreate(mask, nesting ?? chosen);+ },+ overlay,+ showOverlay: (shown) => setOverlay(shown ? "shown" : "hidden"),+ draft,+ edit: (shape) => {+ setPending(null);+ // Keys after entering or leaving belong to the canvas, not to the row or tab that asked.+ if (window.document.activeElement instanceof HTMLElement) {+ window.document.activeElement.blur();+ }+ if (shape) {+ onTool?.(shape);+ } else {+ onDone?.();+ }+ },+ }}+ >+ {children}+ </MaskTool>+ );+}diff --git a/src/features/layers/menu.tsx b/src/features/layers/menu.tsxindex 91b5565..0bcd496 100644--- a/src/features/layers/menu.tsx+++ b/src/features/layers/menu.tsx@@ -1,66 +1,15 @@-import { cva } from "class-variance-authority";-import { type ReactNode, useId, useRef, useState } from "react";import { useDocument, useScene } from "@/components/editor/session";import { Icon } from "@/components/icons/icon";-import { findLayer, locateLayer, type ProcessingLayer } from "@/core/document";+import { Menu } from "@/components/ui/menu";+import { Select } from "@/components/ui/select";+import {+ findLayer,+ locateLayer,+ type MaskLayer,+ type ProcessingLayer,+} from "@/core/document";import { deleteLayer, duplicateLayer, moveLayer } from "./edits";--const trigger = cva(- "grid shrink-0 place-items-center text-neutral-400 hover:text-neutral-100",- {- variants: {- variant: {- row: "size-7 rounded hover:bg-neutral-600/40 pointer-coarse:size-10",- pill: "h-7 rounded-full px-2.5 hover:bg-white/10 pointer-coarse:h-9",- },- },- },-);--export function LayerMenu({- label,- children,- icon,- variant = "row",-}: {- label: string;- children: ReactNode;- icon: ReactNode;- variant?: "row" | "pill";-}) {- const id = useId();- const popover = useRef<HTMLDivElement>(null);- const [open, setOpen] = useState(false);- return (- <>- <button- type="button"- aria-label={label}- title={label}- popoverTarget={id}- className={trigger({ variant })}- >- {icon}- </button>- <div- id={id}- ref={popover}- popover="auto"- onBeforeToggle={(event) => setOpen(event.newState === "open")}- className="fixed inset-auto z-50 m-0 [position-area:bottom_span-left] max-h-[calc(100dvh-1rem)] min-w-40 overflow-y-auto rounded-md [position-try-fallbacks:flip-block] border border-neutral-600 bg-neutral-800 p-1 text-neutral-200 shadow-xl [&_button]:block [&_button]:w-full [&_button]:rounded [&_button]:px-2 [&_button]:py-1.5 [&_button]:text-left [&_button:hover]:bg-neutral-700 [&_button:disabled]:text-neutral-600"- >- <form- onSubmit={(event) => {- event.preventDefault();- popover.current?.hidePopover();- }}- >- {open && children}- </form>- </div>- </>- );-}+import { useMaskTool } from "./mask-tool";/** Mounted only while the menu is open, so rows do not track siblings and containers. */function LayerActionItems({@@ -111,12 +60,12 @@ function LayerActionItems({</button>)}{containers.length > 0 && (- <label className="flex items-center justify-between gap-3 px-2 py-1.5">+ <div className="flex items-center justify-between gap-3 px-2.5 py-1.5">Move into- <select+ <Selectaria-label={`Move ${layer.name} into`}value=""- className="min-w-0 max-w-32 bg-neutral-800"+ className="max-w-32"onChange={(event) => {const target = findLayer(layers, event.target.value);if (target) {@@ -137,10 +86,10 @@ function LayerActionItems({{item.name}</option>))}- </select>- </label>+ </Select>+ </div>)}- <div className="my-1 border-t border-neutral-700" />+ <div className="my-1 border-t border-white/10" /><buttontype="submit"onClick={() => onSelect(duplicateLayer(document, layer.id))}@@ -154,12 +103,53 @@ function LayerActionItems({);}+const shapes = [+ ["linear", "Linear gradient"],+ ["radial", "Radial gradient"],+ ["brush", "Brush"],+] as const;+const nestings = [+ ["add", "Add to", "M12 8.5v7M8.5 12h7"],+ ["subtract", "Subtract from", "M8.5 12h7"],+] as const;++/** Chooses the shape of the next mask and nests it inside this one, adding or subtracting coverage. */+export function MaskNesting({ layer }: { layer: MaskLayer }) {+ const document = useDocument();+ const tool = useMaskTool();+ return nestings.map(([operation, verb, glyph]) => (+ <Menu+ key={operation}+ label={`${verb} ${layer.name}`}+ icon={+ <Icon className="size-4">+ <circle cx="12" cy="12" r="8" />+ <path d={glyph} />+ </Icon>+ }+ >+ {shapes.map(([shape, name]) => (+ <button+ key={shape}+ type="submit"+ onClick={() => {+ document.selectLayer(layer.id);+ tool.add(layer.id, operation, shape);+ }}+ >+ {name}+ </button>+ ))}+ </Menu>+ ));+}+export function LayerActions(props: {layer: ProcessingLayer;onSelect: (id: string) => void;}) {return (- <LayerMenu+ <Menulabel={`${props.layer.name} actions`}icon={<Icon className="size-4">@@ -172,6 +162,6 @@ export function LayerActions(props: {}><LayerActionItems {...props} />- </LayerMenu>+ </Menu>);}diff --git a/src/features/layers/thumbnails.tsx b/src/features/layers/thumbnails.tsxindex 92eb8cc..e980db5 100644--- a/src/features/layers/thumbnails.tsx+++ b/src/features/layers/thumbnails.tsx@@ -1,10 +1,15 @@import { useEffect, useId, useRef, useState } from "react";import { useGpu } from "vgpu-react";+import { useRenderer } from "@/components/editor/pipeline";import { useDocument, useScene } from "@/components/editor/session";-import type { Gradient } from "@/core/document";-import { renderBitmap } from "@/core/renderer";+import { Icon } from "@/components/icons/icon";+import type { MaskLayer } from "@/core/document";+import { renderBitmap, renderCoverage } from "@/core/renderer";import { MaskFill } from "./mask-fill";+const frame =+ "size-8 shrink-0 rounded-sm border border-neutral-600 bg-neutral-950";+/** A small original-image snapshot, rendered once when the source changes. */export function ImageThumbnail() {const gpu = useGpu();@@ -45,25 +50,94 @@ export function ImageThumbnail() {height={64}aria-label="Original image thumbnail"title={error ?? "Original image"}- className="size-8 shrink-0 rounded-sm border border-neutral-600 bg-neutral-950"+ className={frame}/>);}-export function MaskThumbnail({ mask }: { mask: Gradient }) {+/**+ * A mask's coverage: the renderer's raster when the mask has one, drawn again after each committed+ * change, else the gradient itself. An unpainted brush shows its tool.+ */+export function MaskThumbnail({ layer }: { layer: MaskLayer }) {const id = useId();+ const gpu = useGpu();const document = useDocument();+ const renderer = useRenderer();const sourceId = useScene((scene) => scene.layers[0].source);const size = document.resources.get(sourceId).image.size;+ const canvas = useRef<HTMLCanvasElement>(null);+ const [raster, setRaster] = useState(false);+ // The layer version whose raster is ready: strokes in progress wait for their gesture to end.+ const [ready, setReady] = useState<MaskLayer>();+ useEffect(() => {+ function check() {+ const coverage = renderer.coverage(layer.id);+ setRaster(coverage !== undefined);+ if (coverage && !document.history.status.getState().editing) {+ setReady(layer);+ }+ }+ // A gesture's end renders nothing new when the scene already rendered in full.+ const unsubscribe = document.history.status.subscribe(check);+ const detach = renderer.subscribe(check);+ return () => {+ unsubscribe();+ detach();+ };+ }, [renderer, document, layer]);+ useEffect(() => {+ const coverage = ready && renderer.coverage(ready.id);+ if (!coverage) {+ return;+ }+ let active = true;+ renderCoverage(gpu, coverage, [64, 64])+ .then((bitmap) => {+ const context = canvas.current?.getContext("2d");+ if (active && context) {+ context.drawImage(bitmap, 0, 0);+ }+ bitmap.close();+ })+ .catch(() => {});+ return () => {+ active = false;+ };+ }, [gpu, renderer, ready]);+ if (raster) {+ return (+ <canvas+ ref={canvas}+ width={64}+ height={64}+ aria-label="Mask thumbnail"+ className={frame}+ />+ );+ }+ if (layer.mask.kind === "brush") {+ return (+ <span+ role="img"+ aria-label="Empty brush thumbnail"+ className={`grid place-items-center text-neutral-400 ${frame}`}+ >+ <Icon className="size-4">+ <path d="M10 14a3 3 0 0 1-3 3c-1.5 0-3-1-3-1s2-1 2-2.5c0-1.5 1-2.5 2.5-2.5M11 13l7-7a1.4 1.4 0 0 0-2-2l-7 7" />+ </Icon>+ </span>+ );+ }return (<svgaria-label="Gradient mask thumbnail"role="img"viewBox={`0 0 ${size[0]} ${size[1]}`}- className="size-8 shrink-0 rounded-sm border border-neutral-600 bg-neutral-950"+ className={frame}><defs>- <MaskFill id={id} mask={mask} />+ <MaskFill id={id} mask={layer.mask} /></defs><rect width={size[0]} height={size[1]} fill={`url(#${id})`} /></svg>diff --git a/src/features/layers/toolbar.tsx b/src/features/layers/toolbar.tsxindex 8200246..1313fb7 100644--- a/src/features/layers/toolbar.tsx+++ b/src/features/layers/toolbar.tsx@@ -1,35 +1,68 @@+import {+ createContext,+ type ReactNode,+ useContext,+ useLayoutEffect,+ useRef,+ useState,+} from "react";import { useStore } from "zustand";import { useDocument, useScene } from "@/components/editor/session";+import { Icon } from "@/components/icons/icon";+import { Menu } from "@/components/ui/menu";+import { Select } from "@/components/ui/select";import { Slider } from "@/components/ui/slider";-import { findLayer, locateLayer, type MaskLayer } from "@/core/document";+import {+ findLayer,+ locateLayer,+ type MaskLayer,+ type ProcessingLayer,+} from "@/core/document";import { useEditGesture } from "@/hooks/use-edit-gesture";+import { useShortcuts } from "@/hooks/use-shortcuts";import { setLayer, setLayerMask, setMaskOperation } from "./edits";-import { useGradientTool } from "./gradient-tool";-import { LayerMenu } from "./menu";+import { useMaskTool } from "./mask-tool";-const maskOperations = [- ["add", "Add", "Add to mask"],- ["subtract", "Subtract", "Subtract from mask"],-] as const;+/** How much room the bar has: sliders with bars, fields only, or a column inside the overflow menu. */+export type BarDensity = "full" | "compact" | "menu";+const Density = createContext<BarDensity>("full");+export function useBarDensity() {+ return useContext(Density);+}+export function barSlider(density: BarDensity) {+ if (density === "menu") {+ return "panel";+ }+ return density === "full" ? "toolbar" : "compact";+}function MaskOptions({ layer }: { layer: MaskLayer }) {const document = useDocument();- const tool = useGradientTool();+ const tool = useMaskTool();+ const density = useBarDensity();const parent = useScene((scene) => locateLayer(scene.layers, layer.id)?.parent,);- const isSubmask = parent?.kind === "mask";+ // The button reports what the canvas shows, whether by choice or by default.+ const shown = useStore(+ document.preview,+ (preview) => preview.maskOverlay !== undefined,+ );+ const toggleOverlay = () => tool.showOverlay(!shown);+ useShortcuts({ o: toggleOverlay });return (<>- <hr- aria-orientation="vertical"- className="h-4 w-px border-0 bg-white/15"- />+ {density !== "menu" && (+ <hr+ aria-orientation="vertical"+ className="h-4 w-px border-0 bg-white/15"+ />+ )}<buttontype="button"- aria-pressed={tool.overlay !== "hidden"}- title="Show mask overlay (O)"- onClick={tool.toggleOverlay}+ aria-pressed={shown}+ title="Show the mask overlay (O)"+ onClick={toggleOverlay}className="h-7 rounded-full px-2.5 text-neutral-400 hover:bg-white/10 hover:text-neutral-100 aria-pressed:bg-white/15 aria-pressed:text-neutral-100 pointer-coarse:h-9">Overlay@@ -42,7 +75,7 @@ function MaskOptions({ layer }: { layer: MaskLayer }) {max={100}defaultValue={50}unit="%"- variant="toolbar"+ variant={barSlider(density)}onChange={(value) => {if (layer.mask.kind === "radial") {setLayerMask(document, layer.id, {@@ -53,12 +86,12 @@ function MaskOptions({ layer }: { layer: MaskLayer }) {}}/>)}- {isSubmask && (- <select+ {parent?.kind === "mask" && (+ <Select+ variant="pill"aria-label="Mask operation"title="Combine with the parent mask"value={layer.operation}- className="h-7 rounded-full bg-white/10 px-2.5 text-neutral-200 hover:bg-white/15"onChange={(event) => {const operation = event.target.value;if (operation === "add" || operation === "subtract") {@@ -68,50 +101,17 @@ function MaskOptions({ layer }: { layer: MaskLayer }) {><option value="add">Add</option><option value="subtract">Subtract</option>- </select>+ </Select>)}- {!parent &&- maskOperations.map(([operation, text, label]) => (- <LayerMenu- variant="pill"- key={operation}- label={label}- icon={<span>{text}</span>}- >- <button- type="submit"- onClick={() => tool.add(layer.id, operation, "linear")}- >- Linear gradient- </button>- <button- type="submit"- onClick={() => tool.add(layer.id, operation, "radial")}- >- Radial gradient- </button>- </LayerMenu>- ))}</>);}-export function LayerToolbar() {+function LayerOptions({ layer }: { layer: ProcessingLayer }) {const document = useDocument();- const gesture = useEditGesture(document.history);- const selected = useStore(document.selection, (state) => state.layerId);- const layer = useScene(- (scene) => findLayer(scene.layers, selected) ?? scene.layers[0],- );- if (layer.kind === "image") {- return null;- }+ const density = useBarDensity();return (- <fieldset- aria-label="Layer options"- {...gesture}- className="absolute top-3 left-3 flex max-w-[calc(100%-1.5rem)] flex-wrap items-center gap-x-3 gap-y-1 rounded-full bg-neutral-800/80 p-1 pl-2.5 backdrop-blur-sm"- >+ <><Sliderlabel="Opacity"value={layer.opacity * 100}@@ -119,12 +119,96 @@ export function LayerToolbar() {max={100}defaultValue={100}unit="%"- variant="toolbar"+ variant={barSlider(density)}onChange={(value) =>setLayer(document, layer.id, { opacity: value / 100 })}/>{layer.kind === "mask" && <MaskOptions layer={layer} />}+ </>+ );+}++/** Steps of compression: bars, fields only, layer options in the menu, everything in the menu. */+const steps = 4;++/**+ * The bar over the canvas edits the active tool and the selected layer; creating layers happens in+ * the stack. It never wraps: when the content overflows, it compresses one step at a time until it fits.+ */+export function CanvasToolbar({ children }: { children?: ReactNode }) {+ const document = useDocument();+ const gesture = useEditGesture(document.history);+ const selected = useStore(document.selection, (state) => state.layerId);+ const layer = useScene(+ (scene) => findLayer(scene.layers, selected) ?? scene.layers[0],+ );+ const bar = useRef<HTMLFieldSetElement>(null);+ const [step, setStep] = useState(0);+ const hasLayer = layer.kind !== "image";+ const shown = Boolean(children) || hasLayer;+ const content = `${Boolean(children)}/${layer.kind}/${layer.kind === "mask" ? layer.mask.kind : ""}`;+ // New content or a resized canvas starts again from the roomiest layout.+ useLayoutEffect(() => setStep(0), [content]);+ useLayoutEffect(() => {+ const canvas = bar.current?.parentElement;+ if (!shown || !canvas) {+ return;+ }+ const observer = new ResizeObserver(() => setStep(0));+ observer.observe(canvas);+ return () => observer.disconnect();+ }, [shown]);+ useLayoutEffect(() => {+ const element = bar.current;+ if (+ element &&+ element.scrollWidth > element.clientWidth &&+ step < steps - 1+ ) {+ setStep(step + 1);+ }+ });+ if (!shown) {+ return null;+ }+ const inlineTool = step < 3 ? children : null;+ const inlineLayer = step < 2 && hasLayer;+ const menuTool = step >= 3 ? children : null;+ const menuLayer = step >= 2 && hasLayer;+ return (+ <fieldset+ ref={bar}+ aria-label="Layer options"+ {...gesture}+ className="absolute top-3 left-3 flex min-w-0 max-w-[calc(100%-1.5rem)] items-center gap-x-2.5 overflow-hidden rounded-full bg-neutral-800/80 p-1.5 backdrop-blur-sm"+ >+ <Density value={step === 0 ? "full" : "compact"}>+ {inlineTool}+ {inlineLayer && <LayerOptions layer={layer} />}+ </Density>+ {(menuTool || menuLayer) && (+ <Menu+ variant="pill"+ label="More options"+ icon={+ <Icon className="size-4">+ <path+ d="M12 5h.01M12 12h.01M12 19h.01"+ strokeWidth="3"+ strokeLinecap="round"+ />+ </Icon>+ }+ >+ <Density value="menu">+ <div className="flex w-56 flex-col gap-3 p-2">+ {menuTool}+ {menuLayer && <LayerOptions layer={layer} />}+ </div>+ </Density>+ </Menu>+ )}</fieldset>);}diff --git a/src/hooks/use-shortcuts.ts b/src/hooks/use-shortcuts.tsindex 7892b75..61e40cb 100644--- a/src/hooks/use-shortcuts.ts+++ b/src/hooks/use-shortcuts.ts@@ -15,13 +15,14 @@ export function useShortcuts(if (window.document.querySelector(":popover-open")) {return;}+ const typing =+ 'input:not([type="range"]), textarea, select, dialog, [role="dialog"]';+ // Enter on a focused button or link is its activation, not a shortcut.+ const owned = event.key === "Enter" ? `${typing}, button, a` : typing;if (!inputs &&target instanceof HTMLElement &&- (target.isContentEditable ||- target.closest(- 'input:not([type="range"]), textarea, select, dialog, [role="dialog"]',- ))+ (target.isContentEditable || target.closest(owned))) {return;}diff --git a/src/index.css b/src/index.cssindex a5af2c4..ff2b40c 100644--- a/src/index.css+++ b/src/index.css@@ -42,6 +42,17 @@var(--tw-shadow);}+/* A floating surface: the ridge highlight over a soft drop, so menus read like raised controls. */+@utility shadow-float {+ --tw-shadow:+ inset 0 1px 0 rgb(255 255 255 / 0.07), 0 2px 6px rgb(0 0 0 / 0.3),+ 0 16px 32px -8px rgb(0 0 0 / 0.5);+ box-shadow:+ var(--tw-inset-shadow, 0 0 #0000), var(--tw-inset-ring-shadow, 0 0 #0000),+ var(--tw-ring-offset-shadow, 0 0 #0000), var(--tw-ring-shadow, 0 0 #0000),+ var(--tw-shadow);+}+/* Composes through --tw-shadow so it stacks with ring utilities. */@utility shadow-groove {--tw-shadow:diff --git a/tests/brush.e2e.ts b/tests/brush.e2e.tsnew file mode 100644index 0000000..4d8b46b--- /dev/null+++ b/tests/brush.e2e.ts@@ -0,0 +1,265 @@+import type { Page } from "@playwright/test";+import { expect, test } from "./fixtures";+import { readImage, readPreview } from "./images";+import { box, drag } from "./pointer";++/** Export pixels inside the stroke and far above it. */+async function samples(page: Page) {+ const { samples } = await readImage(page, undefined, [+ [600, 400],+ [600, 100],+ ]);+ return samples ?? [];+}++test("paint a brush mask, adjust it in the sidebar, erase, and undo", async ({+ page,+}, info) => {+ test.setTimeout(90_000);+ await page.setViewportSize({ width: 1440, height: 1000 });+ const state = () => page.evaluate(() => window.openlight.getState());+ async function setField(name: string, value: string) {+ const field = page.getByRole("textbox", { name, exact: true });+ await field.fill(value);+ await field.press("Enter");+ }+ async function tinted() {+ const { center } = await readPreview(page);+ return center[0] > center[1] + 30;+ }+ await page.goto("/");+ await page+ .locator('input[type="file"]')+ .setInputFiles("tests/fixtures/photo.svg");+ await expect(+ page.getByRole("textbox", { name: "Exposure", exact: true }),+ ).toHaveValue("0.00");+ const original = await samples(page);+ await page.getByRole("tab", { name: "Brush", exact: true }).click();+ const canvas = page.getByLabel("Brush canvas", { exact: true });+ await expect(canvas).toBeVisible();+ // Choosing the tool creates its mask at once, so the sidebar already edits it.+ expect((await state()).scene?.layers).toHaveLength(2);+ // Tool options sit over the canvas; the sidebar keeps the selected layer's adjustments.+ const options = page.getByRole("group", { name: "Layer options" });+ const overlayButton = options.getByRole("button", {+ name: "Overlay",+ exact: true,+ });+ await expect(+ options.getByRole("textbox", { name: "Size", exact: true }),+ ).toBeVisible();+ await expect(+ page.getByRole("heading", { name: "Adjustments", exact: true }),+ ).toBeVisible();+ const bounds = await box(canvas);+ const scale = Math.min(bounds.width / 1200, bounds.height / 800, 2);+ const center = [bounds.x + bounds.width / 2, bounds.y + bounds.height / 2];+ const from = [center[0] - 150 * scale, center[1]];+ const to = [center[0] + 150 * scale, center[1]];+ await setField("Size", "200");+ await test.step("a drag paints the new brush mask, which shows its overlay", async () => {+ await drag(page, from, to, 16);+ const layers = (await state()).scene?.layers;+ expect(layers).toHaveLength(2);+ const mask = layers?.[1];+ expect(mask).toMatchObject({ kind: "mask", name: "Brush" });+ if (mask?.kind === "mask" && mask.mask.kind === "brush") {+ expect(mask.mask.strokes).toHaveLength(1);+ expect(mask.mask.strokes[0].size).toBe(200);+ expect(mask.mask.strokes[0].points.length).toBeGreaterThan(2);+ }+ expect((await state()).selectedLayerId).toBe(mask?.id);+ expect(await samples(page)).toEqual(original);+ await page.mouse.move(bounds.x + 20, bounds.y + 20);+ await expect.poll(tinted).toBe(true);+ await expect(overlayButton).toHaveAttribute("aria-pressed", "true");+ // The row's thumbnail shows the stroke through the middle once it is committed.+ const thumbnail = page+ .getByRole("region", { name: "Layers", exact: true })+ .getByLabel("Mask thumbnail", { exact: true });+ await expect+ .poll(() =>+ thumbnail.evaluate((element) => {+ const context = (element as HTMLCanvasElement).getContext("2d");+ const inside = context?.getImageData(32, 32, 1, 1).data[0] ?? 0;+ const corner = context?.getImageData(4, 4, 1, 1).data[0] ?? 0;+ return { lit: inside > 200, dark: corner < 30 };+ }),+ )+ .toEqual({ lit: true, dark: true });+ });+ await test.step("Enter leaves one level at a time; selecting the mask returns", async () => {+ const selected = (await state()).selectedLayerId;+ await page.keyboard.press("Enter");+ await expect(+ page.getByRole("tab", { name: "Adjust", exact: true }),+ ).toHaveAttribute("aria-selected", "true");+ await expect(canvas).toHaveCount(0);+ expect((await state()).selectedLayerId).toBe(selected);+ await expect.poll(tinted).toBe(false);+ await expect(overlayButton).toHaveAttribute("aria-pressed", "false");+ // The next Enter selects the image and its global controls.+ await page.keyboard.press("Enter");+ const state2 = await state();+ expect(state2.selectedLayerId).toBe(state2.scene?.layers[0].id);+ await expect(overlayButton).toHaveCount(0);+ await page+ .getByRole("button", { name: "Select Brush", exact: true })+ .click();+ await expect(+ page.getByRole("tab", { name: "Brush", exact: true }),+ ).toHaveAttribute("aria-selected", "true");+ await expect(canvas).toBeVisible();+ await page.mouse.move(bounds.x + 20, bounds.y + 20);+ await expect.poll(tinted).toBe(true);+ });+ await test.step("an adjustment replaces the overlay with its own effect", async () => {+ await setField("Exposure", "2");+ const [inside, above] = await samples(page);+ expect(inside[0]).toBeGreaterThan(original[0][0] + 40);+ expect(above).toEqual(original[1]);+ await expect.poll(tinted).toBe(false);+ await page.keyboard.press("o");+ await expect.poll(tinted).toBe(true);+ await expect(overlayButton).toHaveAttribute("aria-pressed", "true");+ await page.keyboard.press("o");+ await expect.poll(tinted).toBe(false);+ await page.screenshot({ path: info.outputPath("brush-ui.png") });+ });+ await test.step("Alt erases and each stroke is one undo step", async () => {+ const painted = await samples(page);+ const before = (await state()).history.undoCount;+ await page.keyboard.down("Alt");+ await drag(page, from, to, 16);+ await page.keyboard.up("Alt");+ expect((await state()).history.undoCount).toBe(before + 1);+ expect((await samples(page))[0]).toEqual(original[0]);+ await page.keyboard.press("ControlOrMeta+z");+ expect(await samples(page)).toEqual(painted);+ await page.keyboard.press("ControlOrMeta+z");+ expect(await samples(page)).toEqual(original);+ await page.keyboard.press("ControlOrMeta+z");+ await page.keyboard.press("ControlOrMeta+z");+ expect((await state()).scene?.layers).toHaveLength(1);+ });+ await test.step("an untouched new brush mask leaves no trace; an adjusted one stays", async () => {+ const before = (await state()).history.undoCount;+ await page.keyboard.press("b");+ await expect(canvas).toBeVisible();+ expect((await state()).scene?.layers[1]).toMatchObject({+ kind: "mask",+ name: "Brush",+ mask: { kind: "brush", strokes: [] },+ });+ // Escape cancels the stroke and keeps the empty mask; Escape again leaves the tool.+ await page.mouse.move(from[0], from[1]);+ await page.mouse.down();+ await page.mouse.move(to[0], to[1], { steps: 8 });+ await page.keyboard.press("Escape");+ await page.mouse.up();+ expect((await state()).scene?.layers).toHaveLength(2);+ await page.keyboard.press("Escape");+ await expect(canvas).toHaveCount(0);+ expect((await state()).scene?.layers).toHaveLength(1);+ expect((await state()).history).toMatchObject({+ undoCount: before,+ redoCount: 0,+ });+ // An adjustment before the first stroke belongs to the new mask and keeps it.+ await page.keyboard.press("b");+ await setField("Exposure", "1");+ expect(await samples(page)).toEqual(original);+ await drag(page, from, to, 16);+ expect((await samples(page))[0][0]).toBeGreaterThan(original[0][0] + 20);+ await page.keyboard.press("Enter");+ expect((await state()).scene?.layers).toHaveLength(2);+ for (let i = 0; i < 3; i++) {+ await page.keyboard.press("ControlOrMeta+z");+ }+ expect((await state()).scene?.layers).toHaveLength(1);+ });+ await test.step("Subtract adds a brush inside the selected gradient", async () => {+ await page.keyboard.press("l");+ await drag(+ page,+ [center[0], center[1] - 200 * scale],+ [center[0], center[1] + 200 * scale],+ );+ await setField("Exposure", "1");+ const lit = await samples(page);+ expect(lit[1][0]).toBeGreaterThan(original[1][0] + 20);+ await page+ .getByRole("button", {+ name: "Subtract from Linear Gradient",+ exact: true,+ })+ .click();+ await page+ .locator("[popover]:popover-open")+ .getByRole("button", { name: "Brush", exact: true })+ .click();+ await expect(+ page.getByRole("tab", { name: "Brush", exact: true }),+ ).toHaveAttribute("aria-selected", "true");+ await drag(+ page,+ [center[0], center[1] - 300 * scale],+ [center[0], center[1] - 300 * scale + 1],+ 2,+ );+ const layers = (await state()).scene?.layers;+ expect(layers?.[1].children).toHaveLength(1);+ expect(layers?.[1].children[0]).toMatchObject({+ kind: "mask",+ operation: "subtract",+ mask: { kind: "brush" },+ });+ expect((await samples(page))[1]).toEqual(original[1]);+ // The child row previews its own coverage, and erasing in it restores the gradient's.+ const thumbnails = page+ .getByRole("region", { name: "Layers", exact: true })+ .getByLabel("Mask thumbnail", { exact: true });+ await expect(thumbnails).toHaveCount(2);+ await expect+ .poll(() =>+ thumbnails.nth(1).evaluate((element) => {+ const context = (element as HTMLCanvasElement).getContext("2d");+ return context?.getImageData(32, 8, 1, 1).data[0] ?? 0;+ }),+ )+ .toBeGreaterThan(200);+ await page.keyboard.down("Alt");+ await drag(+ page,+ [center[0], center[1] - 300 * scale],+ [center[0], center[1] - 300 * scale + 1],+ 2,+ );+ await page.keyboard.up("Alt");+ expect((await samples(page))[1]).toEqual(lit[1]);+ });+ await test.step("Escape climbs from the child mask to its parent and the image; Enter on a button is its click", async () => {+ const initial = await state();+ const gradient = initial.scene?.layers[1];+ const child = gradient?.children[0];+ expect(initial.selectedLayerId).toBe(child?.id);+ await page.keyboard.press("Escape");+ await expect(+ page.getByRole("tab", { name: "Adjust", exact: true }),+ ).toHaveAttribute("aria-selected", "true");+ expect((await state()).selectedLayerId).toBe(child?.id);+ await page.keyboard.press("Escape");+ expect((await state()).selectedLayerId).toBe(gradient?.id);+ await overlayButton.click();+ await expect(overlayButton).toHaveAttribute("aria-pressed", "true");+ await overlayButton.press("Enter");+ await expect(overlayButton).toHaveAttribute("aria-pressed", "false");+ expect((await state()).selectedLayerId).toBe(gradient?.id);+ await page.keyboard.press("Escape");+ expect((await state()).selectedLayerId).toBe(initial.scene?.layers[0].id);+ await expect(overlayButton).toHaveCount(0);+ await page.keyboard.press("Escape");+ expect((await state()).selectedLayerId).toBe(initial.scene?.layers[0].id);+ });+});diff --git a/tests/brush.test.ts b/tests/brush.test.tsnew file mode 100644index 0000000..5e35888--- /dev/null+++ b/tests/brush.test.ts@@ -0,0 +1,185 @@+import { expect, mock, test } from "bun:test";+import { init, target } from "vgpu/mock";+import { createImageLayer, createMask } from "@/app/editor/layers";+import { createEditorRenderer } from "@/app/editor/renderer";+import type { BrushStroke } from "@/core/document";+import { createDocument, createResources, findLayer } from "@/core/document";+import { createImageSource } from "@/core/image";+import { imageFrame } from "@/core/image/frame";+import { strokeDabs } from "@/core/renderer/mask/dabs";+import { setAdjustments } from "@/features/adjustments/edits";+import {+ addLayer,+ deleteLayer,+ extendStroke,+ paintStroke,+ setLayer,+ setLayerMask,+} 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 at a quarter diameter with interpolated pressure", () => {+ expect(strokeDabs(stroke)).toEqual([[10, 10, 4, 0.5]]);+ const line = strokeDabs({+ ...stroke,+ points: [+ [10, 10, 1],+ [20, 10, 0.5],+ [30, 10, 0],+ ],+ });+ expect(line).toHaveLength(11);+ expect(line[0]).toEqual([10, 10, 4, 0.5]);+ expect(line[5]).toEqual([20, 10, 4, 0.25]);+ expect(line[10][0]).toBeCloseTo(30);+ expect(line[10][3]).toBeCloseTo(0);+ expect(strokeDabs({ ...stroke, points: [] })).toEqual([]);+});++test("brush strokes stamp incrementally, replay after undo, and render a proxy during gestures", 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"), id: "base" }],+ },+ resources,+ );+ const renderer = createEditorRenderer(gpu, source);+ const notify = mock(() => {});+ renderer.subscribe(notify);+ const render = (interactive = false) =>+ renderer.update(document.scene.getState(), undefined, interactive);+ try {+ 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(renderer.inspect()).toMatchObject({+ passes: [],+ stamped: 0,+ rasters: [],+ });+ expect(document.history.status.getState().editing).toBe(false);+ expect(document.history.begin()).toBe(true);+ expect(document.history.status.getState().editing).toBe(true);+ paintStroke(document, mask, stroke);+ await render(true);+ expect(renderer.inspect()).toMatchObject({+ passes: [`layer/${mask}/exposure`, `layer/${mask}/raster`],+ stamped: 1,+ rasters: [{ id: mask, size: [64, 32] }],+ });+ expect(renderer.coverage(mask)?.size).toEqual([64, 32]);+ // A 20 px extension adds ten dabs; earlier ones are not stamped again.+ extendStroke(document, mask, [[30, 10, 1]]);+ await render(true);+ expect(renderer.inspect().stamped).toBe(11);+ expect(renderer.outputImage().size).toEqual([64, 32]);+ // The display scale sets the proxy: a quarter of a device pixel per source pixel means a quarter-size render.+ renderer.setDisplayScale(0.25);+ await render(true);+ expect(renderer.outputImage().size).toEqual([16, 8]);+ expect(renderer.inspect().stamped).toBe(11);+ document.history.commit();+ expect(document.history.status.getState().editing).toBe(false);+ await render();+ expect(renderer.outputImage().size).toEqual([64, 32]);+ const rendered = notify.mock.calls.length;+ await render();+ expect(notify).toHaveBeenCalledTimes(rendered);+ paintStroke(document, mask, { ...stroke, mode: "erase" });+ await render();+ expect(renderer.inspect().stamped).toBe(12);+ // Undo removes the last stroke, which rebuilds the raster from the remaining one.+ document.history.undo();+ await render();+ expect(renderer.inspect().stamped).toBe(23);+ const layer = findLayer(document.scene.getState().layers, mask);+ expect(layer?.kind === "mask" && layer.mask.kind === "brush").toBe(true);+ if (layer?.kind === "mask" && layer.mask.kind === "brush") {+ expect(layer.mask.strokes).toHaveLength(1);+ expect(layer.mask.strokes[0].points).toHaveLength(2);+ }+ // A brush subtracting from a gradient turns the whole mask into a raster.+ const gradient = addLayer(document, createMask(defaultGradient([64, 32])));+ setAdjustments(document, { exposure: -1 }, gradient);+ await render();+ expect(renderer.inspect().passes).toContain(`layer/${gradient}/mix`);+ // Inspecting the mask copies its curve input with coverage as alpha, even at zero opacity.+ await renderer.update(document.scene.getState(), gradient);+ expect(renderer.inputImage(gradient)).toBeDefined();+ expect(renderer.inspect().passes).toContain(`layer/${gradient}/input`);+ setLayer(document, gradient, { opacity: 0 });+ await renderer.update(document.scene.getState(), gradient);+ expect(renderer.inputImage(gradient)).toBeDefined();+ expect(renderer.inspect().passes).toEqual([+ `layer/${mask}/exposure`,+ `layer/${mask}/raster`,+ `layer/${gradient}/exposure`,+ `layer/${gradient}/input`,+ ]);+ setLayer(document, gradient, { opacity: 1 });+ const child = addLayer(+ document,+ createMask({ kind: "brush", strokes: [stroke] }, "subtract"),+ { inside: gradient },+ );+ await render();+ expect(renderer.inspect().passes).toContain(`layer/${gradient}/raster`);+ expect(renderer.inspect().passes).not.toContain(`layer/${gradient}/mix`);+ await renderer.update(document.scene.getState(), gradient);+ expect(renderer.inspect().passes).toContain(+ `layer/${gradient}/raster-input`,+ );+ // The child keeps its own coverage for its preview; the gradient combines it into a second texture.+ expect(renderer.inspect().rasters.map((raster) => raster.id)).toEqual([+ mask,+ child,+ `${gradient}/group`,+ ]);+ expect(renderer.coverage(child)?.size).toEqual([64, 32]);+ // Erasing inside the child stamps its own raster only, and the group recombines.+ const stampedBefore = renderer.inspect().stamped;+ paintStroke(document, child, { ...stroke, mode: "erase" });+ await render();+ expect(renderer.inspect().stamped).toBe(stampedBefore + 1);+ deleteLayer(document, child);+ deleteLayer(document, mask);+ await render();+ expect(renderer.inspect().rasters).toEqual([]);+ expect(renderer.inspect().passes).toContain(`layer/${gradient}/mix`);+ for (const invalid of [+ { ...stroke, size: 0 },+ { ...stroke, feather: 2 },+ { ...stroke, flow: -1 },+ { ...stroke, mode: "smudge" as BrushStroke["mode"] },+ { ...stroke, points: [] },+ { ...stroke, points: [[1, 2, 3]] as BrushStroke["points"] },+ ]) {+ expect(() =>+ setLayerMask(document, gradient, { kind: "brush", strokes: [invalid] }),+ ).toThrow();+ }+ expect(() => extendStroke(document, gradient, [[1, 1, 1]])).toThrow(+ "brush",+ );+ } finally {+ renderer.dispose();+ document.dispose();+ gpu.dispose();+ }+});diff --git a/tests/documents.test.ts b/tests/documents.test.tsindex f5ec023..eff6114 100644--- a/tests/documents.test.ts+++ b/tests/documents.test.ts@@ -17,6 +17,34 @@ function document() {});}+test("drop removes the latest entry only after its snapshot, leaving no redo, and cancels an open group", () => {+ const doc = document();+ const start = doc.scene.getState();+ setAdjustments(doc, { exposure: 1 });+ const adjusted = doc.scene.getState();+ setAdjustments(doc, { exposure: 2 });+ doc.history.undo();+ doc.history.drop(adjusted);+ expect(doc.scene.getState()).toBe(adjusted);+ expect(doc.history.status.getState()).toEqual({+ undoCount: 1,+ redoCount: 1,+ editing: false,+ });+ doc.history.drop(start);+ expect(doc.scene.getState()).toBe(start);+ expect(doc.history.status.getState()).toEqual({+ undoCount: 0,+ redoCount: 0,+ editing: false,+ });+ doc.history.begin();+ setAdjustments(doc, { exposure: 3 });+ doc.history.drop(start);+ expect(doc.scene.getState()).toBe(start);+ expect(doc.history.status.getState().undoCount).toBe(0);+});+test("documents edit independently without React, retain bounded history, and reject edits after replacement", async () => {const first = document();const second = document();@@ -94,11 +122,13 @@ test("documents edit independently without React, retain bounded history, and reexpect(first.history.status.getState()).toEqual({undoCount: 0,redoCount: 100,+ editing: false,});setAdjustments(first, { contrast: 10 });expect(first.history.status.getState()).toEqual({undoCount: 1,redoCount: 0,+ editing: false,});const workspace = createWorkspace();await workspace.open("first", async () => first);diff --git a/tests/editing.e2e.ts b/tests/editing.e2e.tsindex 214f4fe..f482c8d 100644--- a/tests/editing.e2e.ts+++ b/tests/editing.e2e.ts@@ -436,22 +436,30 @@ test("edit a photo, inspect the preview and histograms, undo changes, and export});await page.getByRole("button", { name: "photo.svg", exact: true }).click();- await test.step("a mask's curve input clears while the mask is hidden and returns on undo", async () => {+ await test.step("a mask's curve input weighs its coverage and stays while the mask is hidden", async () => {+ const plot = page+ .getByLabel("curve input histogram", { exact: true })+ .locator("polyline");+ await expect(plot).toHaveAttribute("points", /,\d{1,2}\./);+ const whole = await plot.getAttribute("points");await page.evaluate(() => {const api = window.openlight;const mask = api.addLayer("mask");api.setLayer(mask, { name: "Curve input mask" });- api.setAdjustments({ exposure: 1 }, mask);});- const plot = page- .getByLabel("curve input histogram", { exact: true })- .locator("polyline");+ // A neutral mask receives the same pixels, counted only where it covers them.+ await expect(plot).toHaveAttribute("points", /,\d{1,2}\./);+ await expect(plot).not.toHaveAttribute("points", whole ?? "");+ await page.evaluate(() => {+ const api = window.openlight;+ api.setAdjustments({ exposure: 1 }, api.getState().selectedLayerId);+ });await expect(plot).toHaveAttribute("points", /,\d{1,2}\./);const points = await plot.getAttribute("points");await page.getByRole("button", { name: "Show Curve input mask", exact: true }).click();- await expect(plot).toHaveAttribute("points", "");+ await expect(plot).toHaveAttribute("points", points ?? "");await page.getByRole("button", { name: "Undo", exact: true }).click();await expect(plot).toHaveAttribute("points", points ?? "");await page.evaluate(() => {@@ -463,7 +471,7 @@ test("edit a photo, inspect the preview and histograms, undo changes, and export});await page.getByRole("button", { name: "photo.svg", exact: true }).click();await test.step("mode bar switches panels by click, arrow keys, and letters", async () => {- const modes = page.getByRole("tablist", { name: "Editor mode" });+ const modes = page.getByRole("tablist", { name: "Tools" });const selected = modes.getByRole("tab", { selected: true });await expect(selected).toHaveAccessibleName("Adjust");const exportButton = page.getByRole("button", {@@ -486,6 +494,13 @@ test("edit a photo, inspect the preview and histograms, undo changes, and exportawait modes.getByRole("tab", { name: "Crop" }).click();await expect(selected).toHaveAccessibleName("Crop");await page.keyboard.press("ArrowLeft");+ await expect(selected).toHaveAccessibleName("Radial gradient");+ await expect(+ page.getByRole("heading", { name: "Adjustments", exact: true }),+ ).toBeVisible();+ await page.keyboard.press("ArrowLeft");+ await page.keyboard.press("ArrowLeft");+ await page.keyboard.press("ArrowLeft");await expect(selected).toHaveAccessibleName("Adjust");await expect(selected).toBeFocused();await page.keyboard.press("e");diff --git a/tests/fill.e2e.ts b/tests/fill.e2e.tsnew file mode 100644index 0000000..7ad0fd1--- /dev/null+++ b/tests/fill.e2e.ts@@ -0,0 +1,75 @@+import { expect, test } from "./fixtures";+import { readImage } from "./images";+import { box, drag } from "./pointer";++test("a color layer paints the image or a brush stroke with Photoshop blends", async ({+ page,+}, info) => {+ await page.setViewportSize({ width: 1440, height: 1000 });+ const state = () => page.evaluate(() => window.openlight.getState());+ async function addColor() {+ await page.getByRole("button", { name: "Add effect", exact: true }).click();+ await page+ .locator("[popover]:popover-open")+ .getByRole("button", { name: "Color", exact: true })+ .click();+ }+ await page.goto("/");+ await page+ .locator('input[type="file"]')+ .setInputFiles("tests/fixtures/photo.svg");+ await expect(+ page.getByRole("textbox", { name: "Exposure", exact: true }),+ ).toHaveValue("0.00");+ expect((await readImage(page)).center).toEqual([128, 128, 128, 255]);+ await test.step("Normal paints the color; Multiply darkens by it", async () => {+ await addColor();+ await expect(page.getByRole("combobox", { name: "Blend" })).toHaveValue(+ "normal",+ );+ const painted = (await readImage(page)).center;+ for (const [channel, expected] of [240, 118, 60].entries()) {+ expect(Math.abs(painted[channel] - expected)).toBeLessThanOrEqual(2);+ }+ await page+ .getByRole("combobox", { name: "Blend" })+ .selectOption("multiply");+ const multiplied = (await readImage(page)).center;+ expect(multiplied[0]).toBeLessThan(128);+ expect(multiplied[0]).toBeGreaterThan(multiplied[2] + 40);+ await page.evaluate(() => window.openlight.setFill({ color: "#ffffff" }));+ expect((await readImage(page)).center).toEqual([128, 128, 128, 255]);+ await page.keyboard.press("ControlOrMeta+z");+ await page.keyboard.press("ControlOrMeta+z");+ expect((await readImage(page)).center).toEqual(painted);+ await page.keyboard.press("ControlOrMeta+z");+ expect((await readImage(page)).center).toEqual([128, 128, 128, 255]);+ expect((await state()).scene?.layers).toHaveLength(1);+ });+ await test.step("inside a brush mask the color follows the stroke", async () => {+ await page.getByRole("tab", { name: "Brush", exact: true }).click();+ const canvas = page.getByLabel("Brush canvas", { exact: true });+ const bounds = await box(canvas);+ const scale = Math.min(bounds.width / 1200, bounds.height / 800, 2);+ const center = [bounds.x + bounds.width / 2, bounds.y + bounds.height / 2];+ await page.getByRole("textbox", { name: "Size", exact: true }).fill("200");+ await page+ .getByRole("textbox", { name: "Size", exact: true })+ .press("Enter");+ await drag(+ page,+ [center[0] - 150 * scale, center[1]],+ [center[0] + 150 * scale, center[1]],+ 16,+ );+ await addColor();+ const { samples } = await readImage(page, undefined, [+ [600, 400],+ [600, 100],+ ]);+ expect(samples?.[0][0]).toBeGreaterThan(200);+ expect(samples?.[0][2]).toBeLessThan(100);+ expect(samples?.[1]).toEqual([128, 128, 128, 255]);+ await page.screenshot({ path: info.outputPath("fill-ui.png") });+ });+});diff --git a/tests/fill.test.ts b/tests/fill.test.tsnew file mode 100644index 0000000..024a6bd--- /dev/null+++ b/tests/fill.test.ts@@ -0,0 +1,76 @@+import { expect, test } from "bun:test";+import { init, target } from "vgpu/mock";+import {+ createImageLayer,+ createLayer,+ createMask,+ maskNeutral,+} from "@/app/editor/layers";+import { createEditorRenderer } from "@/app/editor/renderer";+import { createDocument, createResources, findLayer } from "@/core/document";+import { createImageSource } from "@/core/image";+import { imageFrame } from "@/core/image/frame";+import { setAdjustments } from "@/features/adjustments/edits";+import { setFill } from "@/features/fill/edits";+import { parseColor } from "@/features/fill/model";+import { addLayer, setLayer } from "@/features/layers/edits";+import { defaultGradient } from "@/features/layers/gradient";++test("a color layer renders its fill, validates its settings, and keeps a mask from looking neutral", async () => {+ const gpu = await init();+ const source = createImageSource(+ target(gpu, { size: [16, 8], 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"), id: "base" }],+ },+ resources,+ );+ const renderer = createEditorRenderer(gpu, source);+ try {+ expect(parseColor("#ff8000")).toEqual([1, 128 / 255, 0]);+ const mask = addLayer(document, createMask(defaultGradient([16, 8])));+ const layer = () => {+ const item = findLayer(document.scene.getState().layers, mask);+ if (item?.kind !== "mask") {+ throw Error("Mask is missing.");+ }+ return item;+ };+ expect(maskNeutral(layer())).toBe(true);+ const fill = addLayer(document, createLayer("fill"), { inside: mask });+ expect(maskNeutral(layer())).toBe(false);+ await renderer.update(document.scene.getState());+ expect(renderer.inspect().passes).toEqual([+ `layer/${fill}/fill`,+ `layer/${mask}/mix`,+ ]);+ setFill(document, { color: "#00FF00", blend: "multiply" }, fill);+ expect(findLayer(document.scene.getState().layers, fill)).toMatchObject({+ fill: { color: "#00ff00", blend: "multiply" },+ });+ for (const change of [+ { color: "red" },+ { color: "#12345" },+ { blend: "darken" as "normal" },+ ]) {+ expect(() => setFill(document, change, fill)).toThrow("Invalid fill");+ }+ expect(() => setFill(document, { color: "#000000" }, mask)).toThrow(+ "color layer",+ );+ // A hidden fill leaves the mask neutral; an adjustment does not.+ setLayer(document, fill, { visible: false });+ expect(maskNeutral(layer())).toBe(true);+ setAdjustments(document, { contrast: 5 }, mask);+ expect(maskNeutral(layer())).toBe(false);+ } finally {+ renderer.dispose();+ document.dispose();+ gpu.dispose();+ }+});diff --git a/tests/layers.e2e.ts b/tests/layers.e2e.tsindex a17cfd6..3f66362 100644--- a/tests/layers.e2e.ts+++ b/tests/layers.e2e.ts@@ -119,16 +119,14 @@ test("draw a mask, edit its child effects, reorder layers and undo", async ({});await page.screenshot({ path: info.outputPath("layers-before-ui.png") });await saveExport("layers-before-export.png");- await page- .getByRole("button", { name: "Add linear mask", exact: true })- .click();+ await page.getByRole("tab", { name: "Linear gradient", exact: true }).click();const overlay = page.getByLabel("Gradient mask canvas", { exact: true });const bounds = await box(overlay);const scale = Math.min(bounds.width / 1200, bounds.height / 800, 2);const center = [bounds.x + bounds.width / 2, bounds.y + bounds.height / 2];const from = [center[0], center[1] - 200 * scale];const to = [center[0], center[1] + 200 * scale];- await test.step("cancellation is empty; drawing creates a mask with its own adjustments", async () => {+ await test.step("cancellation is empty; a new mask shows its overlay until it changes the image", async () => {await page.mouse.move(from[0], from[1]);await page.mouse.down();await page.mouse.move(to[0], to[1]);@@ -143,19 +141,14 @@ test("draw a mask, edit its child effects, reorder layers and undo", async ({tinted: center[0] > center[1] + 30,};}- await page.keyboard.press("l");await drag(page, from, to);await expect.poll(maskPreview).toEqual({ shown: true, tinted: true });- await page.keyboard.press("Escape");+ await page.keyboard.press("ControlOrMeta+z");expect((await state()).scene?.layers).toHaveLength(1);await expect.poll(maskPreview).toEqual({ shown: false, tinted: false });await page.keyboard.press("l");await drag(page, from, to);await expect.poll(maskPreview).toEqual({ shown: true, tinted: true });- await page.keyboard.press("Enter");- await expect.poll(maskPreview).toEqual({ shown: false, tinted: false });- await page.keyboard.press("o");- await expect.poll(maskPreview).toEqual({ shown: true, tinted: true });const layers = (await state()).scene?.layers;expect(layers).toHaveLength(2);expect(layers?.[1]).toMatchObject({@@ -164,6 +157,10 @@ test("draw a mask, edit its child effects, reorder layers and undo", async ({});await setField("Exposure", "1");await expect.poll(maskPreview).toEqual({ shown: false, tinted: false });+ await page.keyboard.press("o");+ await expect.poll(maskPreview).toEqual({ shown: true, tinted: true });+ await page.keyboard.press("o");+ await expect.poll(maskPreview).toEqual({ shown: false, tinted: false });const [top, bottom] = await samples(page);expect(top[0]).toBeGreaterThan(170);expect(bottom).toEqual([128, 128, 128, 255]);@@ -215,8 +212,24 @@ test("draw a mask, edit its child effects, reorder layers and undo", async ({.dblclick();await setField("Layer name", "Sky");const masked = await samples(page);+ // The overlay tint scales with opacity, like the mask's coverage does.+ const tint = async () => {+ const { center } = await readPreview(page, [0, -100 * scale]);+ return center[0] - center[1];+ };+ await page.keyboard.press("o");+ await expect.poll(tint).toBeGreaterThan(30);+ const full = await tint();+ await setField("Opacity", "50");+ await expect.poll(tint).toBeLessThan(full - 10);+ await page.keyboard.press("o");+ await page.getByRole("button", { name: "Undo", exact: true }).click();await setField("Opacity", "0");expect(await samples(page)).toEqual(original);+ // The curve still shows what it would affect.+ await expect(+ page.getByLabel("curve input histogram").locator("polyline"),+ ).toHaveAttribute("points", /,\d{1,2}\./);await page.getByRole("button", { name: "Undo", exact: true }).click();expect(await samples(page)).toEqual(masked);await page.getByRole("button", { name: "Show Sky", exact: true }).click();@@ -227,7 +240,7 @@ test("draw a mask, edit its child effects, reorder layers and undo", async ({await test.step("a subtracting child changes coverage and Add restores the masked region", async () => {const masked = await samples(page);await page- .getByRole("button", { name: "Subtract from mask", exact: true })+ .getByRole("button", { name: "Subtract from Sky", exact: true }).click();await page.locator("[popover]:popover-open")@@ -289,10 +302,12 @@ test("draw a mask, edit its child effects, reorder layers and undo", async ({await test.step("radial masks edit locally, resize, feather, rotate, subtract and undo", async () => {const before = await readImage(page);const beforeSamples = await samples(page);+ // Guides win over drawing, so the drag starts below Sky's rotation guide.+ const origin = [center[0], center[1] + 60 * scale];await page.keyboard.press("r");- await drag(page, center, [- center[0] + 220 * scale,- center[1] + 120 * scale,+ await drag(page, origin, [+ origin[0] + 220 * scale,+ origin[1] + 120 * scale,]);await setField("Exposure", "1");expect((await readImage(page)).center[0]).toBeGreaterThan(@@ -302,13 +317,13 @@ test("draw a mask, edit its child effects, reorder layers and undo", async ({await page.screenshot({ path: info.outputPath("radial-ui.png") });await saveExport("radial-export.png");const edited = await state();- await page.mouse.move(center[0] + 40, center[1] + 30);+ await page.mouse.move(origin[0] + 40, origin[1] + 30);await expect(page.getByLabel("Move radial gradient", { exact: true }),).toHaveCSS("cursor", "grab");await page.mouse.down();await expect(overlay).toHaveCSS("cursor", "grabbing");- await page.mouse.move(center[0] + 40 + 300 * scale, center[1] + 30, {+ await page.mouse.move(origin[0] + 40 + 300 * scale, origin[1] + 30, {steps: 8,});const preview = (await state()).scene;@@ -364,7 +379,7 @@ test("draw a mask, edit its child effects, reorder layers and undo", async ({await drag(page,[rotation.x + rotation.width / 2, rotation.y + rotation.height / 2],- [center[0] + 150 * scale, center[1]],+ [origin[0] + 150 * scale, origin[1]],);const rotated = (await state()).scene?.layers.at(-1);expect(@@ -374,15 +389,18 @@ test("draw a mask, edit its child effects, reorder layers and undo", async ({).toBe(true);await page.keyboard.press("ControlOrMeta+z");await page- .getByRole("button", { name: "Subtract from mask", exact: true })+ .getByRole("button", {+ name: "Subtract from Radial Gradient",+ exact: true,+ }).click();await page.locator("[popover]:popover-open").getByRole("button", { name: "Radial gradient", exact: true }).click();- await drag(page, center, [- center[0] + 220 * scale,- center[1] + 120 * scale,+ await drag(page, origin, [+ origin[0] + 220 * scale,+ origin[1] + 120 * scale,]);expect((await readImage(page)).center).toEqual(before.center);await page.keyboard.press("Delete");diff --git a/tests/layers.test.ts b/tests/layers.test.tsindex 1d8ea05..ec46861 100644--- a/tests/layers.test.ts+++ b/tests/layers.test.ts@@ -53,6 +53,7 @@ test("nested layers compose in order, move atomically, and duplicate with indepeexpect(document.history.status.getState()).toEqual({undoCount: 0,redoCount: 0,+ editing: false,});expect(document.selection.getState().layerId).toBe("base");controls.setVignette({ softness: 75 });diff --git a/tests/loaders.e2e.ts b/tests/loaders.e2e.tsindex 10dd001..19aa204 100644--- a/tests/loaders.e2e.ts+++ b/tests/loaders.e2e.ts@@ -87,6 +87,10 @@ test("decode an image, apply XMP, recover from failure, and replace a document dawait expect(page.getByRole("region", { name: "Crop tool" })).toBeHidden();expect(replaced.frame?.size).toEqual([32, 32]);expect(replaced.documentId).not.toBe(before.documentId);- expect(replaced.history).toEqual({ undoCount: 0, redoCount: 0 });+ expect(replaced.history).toEqual({+ undoCount: 0,+ redoCount: 0,+ editing: false,+ });expect(replaced.adjustments.exposure).toBe(0);});diff --git a/tests/loaders.test.ts b/tests/loaders.test.tsindex 42a6787..2c336ec 100644--- a/tests/loaders.test.ts+++ b/tests/loaders.test.ts@@ -93,6 +93,7 @@ test("file batches preserve ordering, group imports, recover from failures, andexpect(document.history.status.getState()).toEqual({undoCount: 5,redoCount: 0,+ editing: false,});expect(document.scene.getState().layers[0].adjustments).toMatchObject({highlights: 0,diff --git a/tests/renderer.test.ts b/tests/renderer.test.tsindex ca53da2..12ba7f5 100644--- a/tests/renderer.test.ts+++ b/tests/renderer.test.ts@@ -231,6 +231,7 @@ test("rendering follows grouped edits and undo, reuses pipelines, and releases oexpect(document.history.status.getState()).toEqual({undoCount: 1,redoCount: 0,+ editing: false,});draw();const calls = getMockGPUDeviceInstrumentation(gpu.gpu).calls;diff --git a/tests/rendering-benchmark.ts b/tests/rendering-benchmark.tsindex 2505f15..7669a83 100644--- a/tests/rendering-benchmark.ts+++ b/tests/rendering-benchmark.ts@@ -1,8 +1,14 @@-import { effect, frame, init, target, timer } from "vgpu";+import { effect, frame, init, type Timer, target, timer } from "vgpu";import { encodeImage } from "@/app/editor/export/export-image";import { createImageLayer } from "@/app/editor/layers";import { createEditorRenderer } from "@/app/editor/renderer";-import type { Gradient, ProcessingLayer, Scene } from "@/core/document";+import type {+ BrushStroke,+ Mask,+ ProcessingLayer,+ Scene,+ StrokePoint,+} from "@/core/document";import { createImageSource } from "@/core/image";import { imageFrame } from "@/core/image/frame";import { defaultAdjustments } from "@/features/adjustments/model";@@ -18,7 +24,10 @@ export type Workload =| "pipeline-input"| "masked-exposure"| "radial-exposure"- | "layer-stack";+ | "brush-exposure"+ | "layer-stack"+ | "fill"+ | "pipeline-proxy";function summarize(values: number[]) {const sorted = values.toSorted((a, b) => a - b);@@ -32,6 +41,40 @@ function summarize(values: number[]) {};}+/** Wavy strokes across the image, three painted and one erased, dabbed every quarter diameter. */+function brushStrokes(size: [number, number]): BrushStroke[] {+ return [0.25, 0.45, 0.65, 0.45].map((row, index) => ({+ mode: index === 3 ? "erase" : "paint",+ size: index === 3 ? 120 : 240,+ feather: 0.5,+ flow: 0.6,+ points: Array.from({ length: 61 }, (_, n): StrokePoint => {+ const x = (size[0] * n) / 60;+ return [x, size[1] * row + 120 * Math.sin(x / 200), 1];+ }),+ }));+}++function benchmarkMask(workload: Workload, size: [number, number]): Mask {+ if (workload === "radial-exposure") {+ return {+ kind: "radial",+ center: [size[0] / 2, size[1] / 2],+ radius: [size[0] * 0.3, size[1] * 0.35],+ angle: 20,+ feather: 0.5,+ };+ }+ if (workload === "brush-exposure") {+ return { kind: "brush", strokes: brushStrokes(size) };+ }+ return {+ kind: "linear",+ start: [0, size[1] * 0.2],+ end: [0, size[1] * 0.8],+ };+}+/** Repeated processing of a resident texture; decoding, display, and export are outside timings. */export async function benchmarkRendering(workload: Workload,@@ -60,7 +103,11 @@ export async function benchmarkRendering(});const inputId = workload === "pipeline-input" ? "benchmark-image" : undefined;const histogram = inputId ? createHistogram(gpu) : undefined;- const combined = workload === "pipeline" || workload === "pipeline-input";+ const combined =+ workload === "pipeline" ||+ workload === "pipeline-input" ||+ workload === "pipeline-proxy";+ const proxy = workload === "pipeline-proxy";const detail = combined || workload === "detail";const effects: ProcessingLayer[] = [];const common = { visible: true, opacity: 1, children: [] };@@ -89,22 +136,9 @@ export async function benchmarkRendering(if (workload === "masked-exposure" ||workload === "radial-exposure" ||+ workload === "brush-exposure" ||workload === "layer-stack") {- const mask: Gradient =- workload === "radial-exposure"- ? {- kind: "radial",- center: [size[0] / 2, size[1] / 2],- radius: [size[0] * 0.3, size[1] * 0.35],- angle: 20,- feather: 0.5,- }- : {- kind: "linear",- start: [0, size[1] * 0.2],- end: [0, size[1] * 0.8],- };effects.push({...common,id: "benchmark-gradient",@@ -114,7 +148,7 @@ export async function benchmarkRendering(adjustments: defaultAdjustments,toneCurve: defaultCurve,opacity: 0.75,- mask,+ mask: benchmarkMask(workload, size),children: [{...common,@@ -136,6 +170,16 @@ export async function benchmarkRendering(vignette: { intensity: 80, softness: 60 },});}+ if (workload === "fill") {+ effects.push({+ ...common,+ id: "benchmark-fill",+ name: "Color",+ kind: "fill",+ opacity: 0.6,+ fill: { color: "#f0763c", blend: "soft-light" },+ });+ }const scene: Scene = {frame: imageFrame(size),layers: [@@ -158,8 +202,14 @@ export async function benchmarkRendering(...effects,],};+ function create(clock?: Timer) {+ const renderer = createEditorRenderer(gpu, source, clock);+ // Half a device pixel per source pixel, as a fitted view of a large photo, renders at a factor of 2.+ renderer.setDisplayScale(proxy ? 0.5 : 1);+ return renderer;+ }const setupStart = performance.now();- let renderer = createEditorRenderer(gpu, source);+ let renderer = create();const rendererSetupMs = performance.now() - setupStart;async function measure() {const encoding: number[] = [];@@ -168,7 +218,8 @@ export async function benchmarkRendering(const nodes: Record<string, number[]> = {};for (let i = 0; i < warmup + samples; i++) {const start = performance.now();- await renderer.update(scene, inputId);+ // A new scene object forces the render; the renderer skips a request equal to its last.+ await renderer.update({ ...scene }, inputId, proxy);const inspected = inputId && renderer.inputImage(inputId);if (inputId && !inspected) {throw Error("Missing benchmark curve input.");@@ -221,7 +272,7 @@ export async function benchmarkRendering(frame(gpu, (f) => f.pass(input, fill));await gpu.gpu.queue.onSubmittedWorkDone();const start = performance.now();- await renderer.update(scene, inputId);+ await renderer.update({ ...scene }, inputId, proxy);await gpu.gpu.queue.onSubmittedWorkDone();await gpu.settled();const firstRenderMs = performance.now() - start;@@ -239,7 +290,7 @@ export async function benchmarkRendering(});// Profile separately so timestamp queries/readback do not affect the latency comparison.renderer.dispose();- renderer = createEditorRenderer(gpu, source, clock);+ renderer = create(clock);const profile = clock ? await measure() : null;return {workload,@@ -266,6 +317,11 @@ export async function benchmarkRendering((sum, { size }) => sum + size[0] * size[1] * 8,0,),+ // Brush rasters are r8unorm at source resolution, outside the graph.+ rasterBytes: storage.rasters.reduce(+ (sum, { size }) => sum + size[0] * size[1],+ 0,+ ),image: [...new Uint8Array(await blob.arrayBuffer())],};} finally {diff --git a/tests/rendering.bench.ts b/tests/rendering.bench.tsindex 33e1115..f9ad577 100644--- a/tests/rendering.bench.ts+++ b/tests/rendering.bench.ts@@ -13,7 +13,10 @@ for (const workload of ["pipeline-input","masked-exposure","radial-exposure",+ "brush-exposure","layer-stack",+ "fill",+ "pipeline-proxy",] as const) {test(`rendering ${workload}`, async ({ page, browser }, info) => {await page.goto("/tests/gpu.html");@@ -65,6 +68,7 @@ for (const workload of [completedMs: report.rendering.completedMs.median,gpuMs: report.profile?.gpuMs?.median ?? null,intermediateBytes: report.intermediateBytes,+ rasterBytes: report.rasterBytes,}),);});