Free open-source image editor for the browser
Render at the display's density and keep half as much of a photo on the GPU (#87)
Rodrigo Belfioree6d355b9270d
diff --git a/API.md b/API.mdindex c98cb5c..7542027 100644--- a/API.md+++ b/API.md@@ -120,7 +120,7 @@ Creative LUTs expect and return display-referred, sRGB-encoded color. The layer## 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. 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.+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. The preview renders a reduced proxy of the image, by the largest whole factor that still gives every device pixel a source pixel, in a group or not, so the full image renders once the display shows more than half a device pixel per source pixel; outside a group, a Remove patch still waiting for its field is synthesized in full apart. Exports always render in full.| Method | Behavior || --- | --- |@@ -155,7 +155,7 @@ try {| `shadows` | Show shadow clipping | `false` || `highlights` | Show highlight clipping | `false` |-The editor also manages `maskOverlay` for the selected mask and `rangeSource` for the mask group being sampled. These transient fields are visible in `getState().preview`; leave them to the active tool.+The editor also manages `maskOverlay` for the selected mask, `rangeSource` for the mask group being sampled, and `density`, the device pixels the canvas shows per source pixel, which renders reduce the source to about. These transient fields are visible in `getState().preview`; leave them to the active tool and the canvas.## Exportdiff --git a/ARCHITECTURE.md b/ARCHITECTURE.mdindex 7a247b9..03fe88e 100644--- a/ARCHITECTURE.md+++ b/ARCHITECTURE.md@@ -29,6 +29,7 @@ Where the code lives and the rules that keep it in place. Keep this file true: w| `app/editor/brush.tsx` | The Brush tool: one canvas that sends color or mask strokes to the feature edits its mode picks, and its options. || `app/editor/dock.tsx` | The mobile dock's tabs and what it shows: the layer stack, a tool's options, or the selected layer's dials. || `app/editor/renderer.ts` | Composes feature passes into the preview and export pipelines. |+| `app/editor/mask-pass.ts` | A mask's adjustments, curve, and mix in one pass, fusing two features' shaders, which only the app may; `backdrop.wgsl` is the other shader the app owns. || `app/editor/mask-overlay.tsx` | The only writer of the mask overlay, derived from the selection. || `app/editor/layers.ts` | The effect kinds the app offers and their layer factories. || `app/editor/export` | The export view. |@@ -74,11 +75,11 @@ Dependencies point downward. Features do not import each other; `app/` connects## Rendering-- `core/renderer` defines passes as nodes (`node`, `pipeline`, `split`, `merge`); the graph owns intermediate textures and timing. Features declare passes; `app/editor/renderer.ts` connects them.+- `core/renderer` defines passes as nodes (`node`, `pipeline`, `split`, `merge`); the graph owns intermediate textures and timing. Features declare passes; `app/editor/renderer.ts` connects them, and `app/editor/mask-pass.ts` fuses two features' into one.- Hidden layers retain their composition instances, including descendant layers and Healing patches.-- The graph keeps intermediate textures for the last two sets of sizes it rendered, so interactive proxy renders and full renders alternate without reallocating full-size textures, which a phone's GPU memory cannot absorb gesture after gesture.+- The renderer keeps the proxy and the intermediate textures of the four reductions it rendered at last, each a quarter of the photo at most, so a zoom in and out allocates and frees nothing, which Safari penalizes; the photo-size set, which a zoom to every source pixel needs, goes once a reduction renders, so a phone's GPU memory holds the display's sizes, not the photo's.- Use `vgpu` for GPU work and `vgpu-react` for bindings. Create pipelines once per engine and reuse them. Keep `.wgsl` beside its owner.-- The working space is linear Rec.2020 in `rgba16float`. Decoders convert into it and display converts out; passes preserve format and primaries unless they explicitly convert.+- The working space is linear Rec.2020 in `rgba16float`. RAW and TIFF decode into it. An 8-bit source with the sRGB transfer stays as it came, encoded in a texture format that decodes to linear when read, in its own primaries, half the memory of the working format: the image layer's adjustments pass converts it, or its proxy, into the working space, and the display converts the source itself for the comparison. A source with another transfer, such as a 16-bit PNG or an HDR photo, converts at import into the working format. Passes preserve format and primaries unless they explicitly convert.- A LUT layer converts explicitly: its table expects display-referred sRGB, so it receives the working color as the display shows it, headroom above white clipped, and its output returns to linear Rec.2020.- A node's storage arrays upload when the array changes; passing the same array, such as a LUT's table, keeps its buffer.- The image layer's adjustments and tone curve develop the photo first; its children and the layers above process that result in stack order. Paint colors therefore follow the photo's adjustments. Working textures stay floating-point through composition; display and export encode the final result.@@ -89,7 +90,8 @@ Dependencies point downward. Features do not import each other; `app/` connects- Remove patches store hard paint/erase strokes without a donor offset. `features/heal/inpaint` synthesizes a field of each hole texel's offset to its donor with a local, multiscale PatchMatch graph, entirely on the GPU: exclusion mask, preserved texture descriptors, nearest valid donor initialization, parallel propagation/random search, and overlap voting. Matching is bounded to 512 texels along the long side; the output samples donors at full source resolution. The Heal compositor applies the patch's coverage, feather, and opacity.- A Remove field is synthesized once per stroke version and kept. Each edit that changes a Remove patch's strokes, adding, erasing, or moving them, reserves a new field in the document's resources, and the patch names it, so every scene with those strokes, in history, drafts, scene files, and exports, shows one fill however late it arrives; filling it never changes the scene or history. The renderer keeps fields by ID: it synthesizes a waiting one once, at full resolution, for the patch's whole shape, from the image below, and reads it back for the document at once, rendering nothing meanwhile. Patches that share a field, such as duplicates, share its synthesis. The layers below, a proxy, hiding, undo, export, and a reopened scene all use that field and never solve again; a version never shown synthesizes when it first shows. Export, scene files, and drafts complete their snapshot with the fields the editor shows that the document still waits for, and fail when that readback fails. Composition samples donor color from the current image below, so the patch follows changes under it, such as exposure. A stroke added over part of an object the first stroke missed therefore leaves none of it, since the whole shape synthesizes from context without it. Synthesis needs no React. See [the solver](src/features/heal/inpaint/algorithm.md) for its constraints and standalone benchmarks.- A brush mask paints coverage as a Paint layer paints color: both are a painting, the latest strokes over settled pixels, in one raster module (r8 for coverage, rgba8 for color), which also owns the open stroke coverage view. At 100 strokes, once no gesture is open, the renderer reads a painting's raster band by band through one mapped buffer, and the pixels, deflated, become a document resource the layer names in place of its strokes, without a history step. Rendering waits until both the scene and cached raster accept the settled pixels. History scenes name the pixels they drew over, so undo reaches past a settle: the renderer loads those pixels, inflating them band by band through a staging texture, and draws the strokes again. Resources go once no retained scene names them.-- A mask that only gradients shape needs no texture: the mix pass computes it, children included. A mask with a painted brush or a range combines in the render graph: each child's coverage, a brush's cached raster, a gradient drawn by a node, or a range read from the image below the mask, folds into the group's in stored order through one combine pass, and the mix pass shares its add, subtract, and intersect. The group takes the image's resolution when a range takes part, since a range follows the photo's edges, and the brushes' otherwise. The renderer gives it out, with each range's own coverage, for the overlay and thumbnails. While a color is picked, renders also keep the image below the mask group, which the picker reads through one GPU pass and 16 bytes of readback per pick.-- Open history groups render a reduced proxy. Every render image carries `scale`, its source pixels per texel; shaders that take document coordinates or radii apply it.-- The scene's frame maps output to source in one homogeneous transform, `frameTransform` in `core/image/frame.ts`: crop, rotation, flips, and scale, then the perspective correction about the source's center. Layers, paint, masks, and patches stay in source pixels, so correcting perspective leaves them in place; `transformImages` resamples the composite and the original once, the display and mask overlay use the same transform, and a frame that changes nothing adds no pass. The proxy follows the frame's strongest magnification, perspective's included. `lib/projective.ts` holds the plane projective geometry the frame, the Crop tool's coverage, and the canvas mapping share.-- TIFF and camera RAW decode through `raw-webgpu`; OpenLight adapts its resources to document ownership.+- A selected layer's curve input, with the mask's coverage as alpha, renders at the few texels its histogram samples, never at full size.+- A mask without child effects renders its adjustments, curve, and mix in one pass over the image below, so no full-size texture holds its edited image; while it is inspected, its curve input reads the adjusted image, so the three render separately. A mask that only gradients shape needs no texture: the mix pass computes it, children included. A mask with a painted brush or a range combines in the render graph: each child's coverage, a brush's cached raster, a gradient drawn by a node, or a range read from the image below the mask, folds into the group's in stored order through one combine pass, and the mix pass shares its add, subtract, and intersect. The group takes the image's resolution when a range takes part, since a range follows the photo's edges, and the brushes' otherwise. The renderer gives it out, with each range's own coverage, for the overlay and thumbnails. While a color is picked, renders also keep the image below the mask group, which the picker reads through one GPU pass and 16 bytes of readback per pick.+- Renders reduce the source by the largest whole factor that still gives every device pixel a texel, a proxy, in gestures or not, so the photo's own size renders once the display shows more than half a device pixel per source pixel; the main canvas writes that density into the preview state, and the provider renders again when it changes. A proxy that lacks a Remove patch's field synthesizes it apart, outside a gesture: the layers below the patch render in full for the field alone, and the proxy composes again with it, so the display never shows a full render for it. The export view renders its own full snapshot, which its preview and the saved file both encode. Every render image carries `scale`, its source pixels per texel; shaders that take document coordinates or radii apply it.+- The scene's frame maps output to source in one homogeneous transform, `frameTransform` in `core/image/frame.ts`: crop, rotation, flips, and scale, then the perspective correction about the source's center. Layers, paint, masks, and patches stay in source pixels, so correcting perspective leaves them in place; `transformImage` resamples the composite once, the display draws the comparison and the mask overlay from the source through the same transform, and a frame that changes nothing adds no pass. The proxy follows the frame's strongest magnification, perspective's included. `lib/projective.ts` holds the plane projective geometry the frame, the Crop tool's coverage, and the canvas mapping share.+- TIFF and camera RAW decode through `raw-webgpu`; OpenLight adapts its resources to document ownership. A RAW source keeps its as-shot development, which a renderer shows as long as that balance is selected; another balance develops into the renderer's own texture.diff --git a/src/app/editor/export/export-image.ts b/src/app/editor/export/export-image.tsindex 2a0f5f3..f0873df 100644--- a/src/app/editor/export/export-image.ts+++ b/src/app/editor/export/export-image.ts@@ -79,57 +79,144 @@ export async function encodeImage(return blob;}-/** The scene with its source and the stored pixels and Remove fields its renderer loads, taken together. */-function snapshotRender(document: EditorDocument) {+/** The current edits rendered in full, which encodes any number of times until it is disposed. */+export type ExportRender = {+ output: Target;+ /** The source file's name without its extension. */+ name: string;+ dispose: () => void;+};++/**+ * Renders a snapshot of the current edits. Taken now, since another photo may close the document+ * meanwhile; its Remove fields complete after, read back from the editor when the document still waits.+ */+export async function renderExport(+ gpu: Gpu,+ document: EditorDocument,+): Promise<ExportRender> {const scene = document.scene.getState();+ const source = document.resources.get(scene.layers[0].source);+ const pixels = settledPixels(document, scene);+ const release = source.retain();+ let renderer: ReturnType<typeof createEditorRenderer> | undefined;+ try {+ const fields = await completeFields(document, sceneFields(document, scene));+ renderer = createEditorRenderer(gpu, source, {+ paintPixels: (id) => {+ const blob = pixels.get(id);+ if (!blob) {+ throw Error("Settled paint is unavailable.");+ }+ return blob;+ },+ field: (id) => fields.get(id),+ });+ await renderer.update(scene);+ } catch (error) {+ renderer?.dispose();+ release();+ throw error;+ }+ const rendered = renderer;return {- scene,- source: document.resources.get(scene.layers[0].source),- pixels: settledPixels(document, scene),- fields: sceneFields(document, scene),+ output: rendered.outputImage(),+ name: source.file.name.replace(/\.[^.]*$/, "") || "export",+ dispose() {+ rendered.dispose();+ release();+ },};}-async function renderSnapshot(+/** Encodes a render as a file named after its source. */+export async function encodeExport(gpu: Gpu,- { scene, source, pixels, fields }: ReturnType<typeof snapshotRender>,- options: ExportOptions,+ { output, name }: ExportRender,+ options: ExportOptions = {},) {- const renderer = createEditorRenderer(gpu, source, {- paintPixels: (id) => {- const blob = pixels.get(id);- if (!blob) {- throw Error("Settled paint is unavailable.");- }- return blob;- },- field: (id) => fields.get(id),- });- try {- await renderer.update(scene);- // The renderer retains the source until encoding finishes.- const blob = await encodeImage(gpu, renderer.outputImage(), options);- const name = source.file.name.replace(/\.[^.]*$/, "") || "export";- const { extension } = encodings[options.format ?? "png"];- return new File([blob], `${name}.${extension}`, { type: blob.type });- } finally {- renderer.dispose();+ const blob = await encodeImage(gpu, output, options);+ const { extension } = encodings[options.format ?? "png"];+ return new File([blob], `${name}.${extension}`, { type: blob.type });+}++/**+ * The current edits rendered in full while an export view is open. `refresh` renders them as they+ * are now in place of the last render, which goes first, so the session holds one; `encode` makes a+ * file from the latest render. Renders, encodes, and releases run one at a time in order, so nothing+ * reads an image after it goes, and a change during one waits for it. Listeners hear each refresh's+ * outcome: nothing, or why it failed.+ */+export function createExportSession(gpu: Gpu, document: EditorDocument) {+ let render: ExportRender | undefined;+ let queue: Promise<unknown> = Promise.resolve();+ const listeners = new Set<(failure?: string) => void>();+ let disposed = false;+ function chain<T>(step: () => Promise<T>) {+ const result = queue.then(step);+ queue = result.then(+ () => undefined,+ () => undefined,+ );+ return result;}+ return {+ refresh: () =>+ chain(async () => {+ if (disposed) {+ return;+ }+ render?.dispose();+ render = undefined;+ let failure: string | undefined;+ try {+ const next = await renderExport(gpu, document);+ if (disposed) {+ next.dispose();+ return;+ }+ render = next;+ } catch (error) {+ failure = error instanceof Error ? error.message : "Couldn't render.";+ }+ for (const listener of listeners) {+ listener(failure);+ }+ }),+ encode: (options: ExportOptions) =>+ chain(() => {+ if (!render) {+ throw Error("The photo is still rendering.");+ }+ return encodeExport(gpu, render, options);+ }),+ subscribe(listener: (failure?: string) => void) {+ listeners.add(listener);+ return () => {+ listeners.delete(listener);+ };+ },+ dispose() {+ disposed = true;+ listeners.clear();+ void chain(async () => {+ render?.dispose();+ render = undefined;+ });+ },+ };}-/** Renders a snapshot of the current edits, named after the source file. */+/** Renders a snapshot of the current edits and encodes it, named after the source file. */export async function exportImage(gpu: Gpu,document: EditorDocument,options: ExportOptions = {},) {- // Taken now, since another photo may close the document meanwhile; its Remove fields complete after.- const snapshot = snapshotRender(document);- const release = snapshot.source.retain();+ const render = await renderExport(gpu, document);try {- const fields = await completeFields(document, snapshot.fields);- return await renderSnapshot(gpu, { ...snapshot, fields }, options);+ return await encodeExport(gpu, render, options);} finally {- release();+ render.dispose();}}diff --git a/src/app/editor/export/index.tsx b/src/app/editor/export/index.tsxindex e580813..f4370ac 100644--- a/src/app/editor/export/index.tsx+++ b/src/app/editor/export/index.tsx@@ -5,7 +5,6 @@ import { Slider } from "@roprgm/ui/slider";import { Spinner } from "@roprgm/ui/spinner";import { cn } from "cn";import { type ReactNode, useMemo, useRef, useState } from "react";-import { useGpu } from "vgpu-react";import { writeSceneFile } from "@/app/loaders/scene";import { Image } from "@/components/editor/image";import { EditorLayout } from "@/components/editor/layout";@@ -14,8 +13,8 @@ import { useDocument, useScene } from "@/components/editor/session";import { EditorViewport, ViewportStage } from "@/components/editor/viewport";import type { Point } from "@/core/image/frame";import { useShortcuts } from "@/hooks/use-shortcuts";-import { type ExportFormat, exportImage, exportSize } from "./export-image";-import { useEncodedPreview } from "./preview";+import { type ExportFormat, exportSize } from "./export-image";+import { useExportPreview } from "./preview";type Format = {id: ExportFormat;@@ -210,8 +209,6 @@ function LoadingOverlay() {/** Shows the encoded file on the canvas; a spinner marks results from earlier settings as loading. */export function ExportMode({ onClose }: { onClose: () => void }) {- const gpu = useGpu();- const editorDocument = useDocument();const size = useScene((scene) => scene.frame.size);const maxEdge = Math.max(...exportSize(size));const [format, setFormat] = useState(formats[0]);@@ -223,7 +220,12 @@ export function ExportMode({ onClose }: { onClose: () => void }) {const edge = Math.min(longEdge, maxEdge);const options = { format: format.id, quality, longEdge: edge };const output = useMemo(() => exportSize(size, edge), [size, edge]);- const { encoded, pending } = useEncodedPreview(options);+ const {+ encoded,+ pending,+ encode,+ error: rendering,+ } = useExportPreview(options);useShortcuts({ escape: onClose });const save = async () => {if (exporting.current) {@@ -232,7 +234,7 @@ export function ExportMode({ onClose }: { onClose: () => void }) {exporting.current = true;setError("");try {- download(await exportImage(gpu, editorDocument, options));+ download(await encode(options));} catch (error) {setError(error instanceof Error ? error.message : "Couldn't export image.",@@ -245,9 +247,7 @@ export function ExportMode({ onClose }: { onClose: () => void }) {<EditorLayoutcanvas={<EditorViewport size={encoded?.image.size ?? output}>- <ViewportStage>- {encoded && <Image image={encoded.image} />}- </ViewportStage>+ <ViewportStage>{encoded && <Image image={encoded} />}</ViewportStage>{pending && <LoadingOverlay />}</EditorViewport>}@@ -283,9 +283,9 @@ export function ExportMode({ onClose }: { onClose: () => void }) {<Button size="lg" className="w-full" onClick={save}>Save image</Button>- {error && (+ {(error || rendering) && (<p className="text-danger" role="alert">- {error}+ {error || rendering}</p>)}</section>diff --git a/src/app/editor/export/preview.tsx b/src/app/editor/export/preview.tsxindex 1834402..94e31b7 100644--- a/src/app/editor/export/preview.tsx+++ b/src/app/editor/export/preview.tsx@@ -1,66 +1,76 @@-import { useEffect, useRef, useState } from "react";-import type { Target } from "vgpu";+import { useEffect, useState } from "react";import { useGpu } from "vgpu-react";-import { useRenderer } from "@/components/editor/pipeline";-import { linearize } from "@/core/image/decode/linearize";-import { type ExportOptions, encodeImage } from "./export-image";+import { useDocument } from "@/components/editor/session";+import type { EncodedImage } from "@/core/image";+import { uploadDecoded } from "@/core/image/decode/upload";+import { useDisposable } from "@/hooks/use-disposable";+import { createExportSession, type ExportOptions } from "./export-image";/** Quiet time after a change before encoding; typical encodes take tens of milliseconds. */const settleDelay = 150;-type Encoded = { key: string; bytes: number; image: Target };+type Encoded = EncodedImage & { key: string; bytes: number };/**- * Encodes the preview output once settings settle and decodes the file back into a target.- * Encodes run one at a time: a change during one waits for it and runs once more.- * The last result stays available while the current settings are still pending.+ * An export session for the view's lifetime, rendered again when the edits change, and its latest+ * render encoded once settings settle; `encode` makes the file to save from the same render. The+ * last encoded result stays available while the current settings are still pending.*/-export function useEncodedPreview({- format,- quality,- longEdge,-}: ExportOptions) {+export function useExportPreview({ format, quality, longEdge }: ExportOptions) {const gpu = useGpu();- const renderer = useRenderer();- const [revision, setRevision] = useState(0);- useEffect(- () => renderer.subscribe(() => setRevision((count) => count + 1)),- [renderer],+ const document = useDocument();+ const session = useDisposable(+ () => createExportSession(gpu, document),+ [gpu, document],);+ const [revision, setRevision] = useState(0);+ const [error, setError] = useState<string>();+ useEffect(() => {+ const unsubscribe = session.subscribe((failure) => {+ setError(failure);+ if (!failure) {+ setRevision((count) => count + 1);+ }+ });+ void session.refresh();+ const stop = document.scene.subscribe(() => void session.refresh());+ return () => {+ unsubscribe();+ stop();+ };+ }, [session, document]);const key = `${format} ${quality} ${longEdge} ${revision}`;const [encoded, setEncoded] = useState<Encoded>();- const queue = useRef(Promise.resolve());useEffect(() => {+ if (!revision) {+ return;+ }let active = true;- const timer = setTimeout(() => {- queue.current = queue.current.then(async () => {+ const timer = setTimeout(async () => {+ try {+ const file = await session.encode({ format, quality, longEdge });+ const bitmap = await createImageBitmap(file);if (!active) {+ bitmap.close();return;}- try {- const blob = await encodeImage(gpu, renderer.outputImage(), {- format,- quality,- longEdge,- });- const bitmap = await createImageBitmap(blob);- if (!active) {- bitmap.close();- return;- }- setEncoded({ key, bytes: blob.size, image: linearize(gpu, bitmap) });- } catch {- if (active) {- setEncoded(undefined);- }+ setEncoded({ key, bytes: file.size, ...uploadDecoded(gpu, bitmap) });+ } catch {+ if (active) {+ setEncoded(undefined);}- });+ }}, settleDelay);return () => {active = false;clearTimeout(timer);};- }, [gpu, renderer, key, format, quality, longEdge]);+ }, [gpu, session, key, revision, format, quality, longEdge]);useEffect(() => () => encoded?.image.color.dispose(), [encoded]);- return { encoded, pending: encoded?.key !== key };+ return {+ encoded,+ pending: encoded?.key !== key,+ encode: session.encode,+ error,+ };}diff --git a/src/app/editor/index.tsx b/src/app/editor/index.tsxindex d78ad72..15d6e22 100644--- a/src/app/editor/index.tsx+++ b/src/app/editor/index.tsx@@ -89,7 +89,7 @@ function ToolView() {canvas={<EditorViewport size={size}><ViewportStage>- <Image original="originalImage" />+ <Image comparable />{"Canvas" in tool && <tool.Canvas key={tool.id} />}</ViewportStage><ComparisonDivider />diff --git a/src/app/editor/mask-pass-raster.wgsl b/src/app/editor/mask-pass-raster.wgslnew file mode 100644index 0000000..1d4bb66--- /dev/null+++ b/src/app/editor/mask-pass-raster.wgsl@@ -0,0 +1,32 @@+import { adjustLayer } from "../../features/adjustments/adjust.wgsl";+import { Adjustments } from "../../features/adjustments/prepare.wgsl";+import { tone, toneSamples } from "../../features/tone-curves/tone.wgsl";++// A mask's adjustments and curve, mixed into the image below through rasterized coverage, sampled by+// position so any proxy resolution reads the same mask.+struct Params {+ exposureOnly: u32,+ // 0 for an identity curve, which the separate curve pass skips.+ curved: u32,+ opacity: f32,+}+@group(0) @binding(0) var below: texture_2d<f32>;+@group(0) @binding(1) var coverage: texture_2d<f32>;+@group(0) @binding(2) var coverageSampler: sampler;+@group(0) @binding(3) var<uniform> adjustments: Adjustments;+@group(0) @binding(4) var<uniform> params: Params;+@group(0) @binding(5) var<storage, read> curve: array<f32>;++@fragment fn fs_main(@builtin(position) position: vec4f) -> @location(0) vec4f {+ let before = textureLoad(below, vec2i(position.xy), 0);+ // Rounded to half floats where the separate passes' textures round, so inspecting the mask changes nothing.+ var after = quantizeToF16(adjustLayer(before.rgb, adjustments, params.exposureOnly != 0u));+ if (params.curved != 0u) {+ let size = arrayLength(&curve);+ let at = toneSamples(after, size);+ after = quantizeToF16(tone(after, vec4f(curve[at.x], curve[at.y], curve[at.z], curve[at.w]), size));+ }+ let uv = position.xy / vec2f(textureDimensions(below));+ let covered = textureSampleLevel(coverage, coverageSampler, uv, 0.0).r;+ return vec4f(mix(before.rgb, after, covered * params.opacity), before.a);+}diff --git a/src/app/editor/mask-pass.ts b/src/app/editor/mask-pass.tsnew file mode 100644index 0000000..c333319--- /dev/null+++ b/src/app/editor/mask-pass.ts@@ -0,0 +1,78 @@+import type { MaskLayer, MaskModifier } from "@/core/document";+import { primariesIndex } from "@/core/image";+import {+ gradientModifiers,+ gradientParams,+ isGradient,+ merge,+ modifierData,+ node,+ type RenderImage,+} from "@/core/renderer";+import { isExposureOnly } from "@/features/adjustments/pass";+import { curveTable } from "@/features/tone-curves/pass";+import shader from "./mask-pass.wgsl";+import rasterShader from "./mask-pass-raster.wgsl";++/** Bound in place of an identity curve's table, which the shaders skip. */+const identity = new Float32Array(1);++/**+ * A mask layer's adjustments, curve, and mix in one pass over the image below, so no full-size+ * intermediate holds the edited image. It matches the separate passes, coverage included: without+ * a raster, a mask that is not a gradient covers nothing yet.+ */+export function maskPass(+ name: string,+ below: RenderImage,+ layer: MaskLayer,+ modifiers: readonly MaskModifier[],+ coverage?: RenderImage,+) {+ const table = curveTable(layer.toneCurve);+ const exposureOnly = isExposureOnly(layer.adjustments);+ if (!table && exposureOnly && layer.adjustments.exposure === 0) {+ return below;+ }+ const adjustments = {+ primaries: primariesIndex.rec2020,+ ...layer.adjustments,+ };+ const edit = {+ exposureOnly: Number(exposureOnly),+ curved: Number(Boolean(table)),+ opacity: layer.opacity,+ };+ const curve = table ?? identity;+ if (coverage) {+ return merge(+ { below, coverage },+ node(`${name}/mask-raster`, rasterShader, {+ samplers: {+ coverageSampler: { minFilter: "linear", magFilter: "linear" },+ },+ storage: { curve },+ set: { adjustments, params: edit },+ }),+ );+ }+ if (!isGradient(layer.mask)) {+ return below;+ }+ const gradients = gradientModifiers(modifiers);+ return merge(+ { below },+ node(`${name}/mask`, shader, {+ storage: { curve, modifiers: modifierData(gradients) },+ set: {+ adjustments,+ params: {+ ...edit,+ ...gradientParams(layer.mask),+ modifierCount: gradients.length,+ scale: below.scale,+ },+ },+ }),+ );+}diff --git a/src/app/editor/mask-pass.wgsl b/src/app/editor/mask-pass.wgslnew file mode 100644index 0000000..6e9838b--- /dev/null+++ b/src/app/editor/mask-pass.wgsl@@ -0,0 +1,42 @@+import { gradientCoverage, modifierCoverage } from "../../core/renderer/blend/coverage.wgsl";+import { adjustLayer } from "../../features/adjustments/adjust.wgsl";+import { Adjustments } from "../../features/adjustments/prepare.wgsl";+import { tone, toneSamples } from "../../features/tone-curves/tone.wgsl";++// A mask's adjustments and curve, mixed into the image below through gradient coverage.+struct Params {+ exposureOnly: u32,+ // 0 for an identity curve, which the separate curve pass skips.+ curved: u32,+ opacity: f32,+ kind: u32,+ first: vec2f,+ second: vec2f,+ feather: f32,+ angle: f32,+ modifierCount: u32,+ // Source pixels per texel, so a reduced proxy evaluates gradients at the same document positions.+ scale: vec2f,+}+@group(0) @binding(0) var below: texture_2d<f32>;+@group(0) @binding(1) var<uniform> adjustments: Adjustments;+@group(0) @binding(2) var<uniform> params: Params;+@group(0) @binding(3) var<storage, read> curve: array<f32>;+@group(0) @binding(4) var<storage, read> modifiers: array<vec4f>;++@fragment fn fs_main(@builtin(position) position: vec4f) -> @location(0) vec4f {+ let before = textureLoad(below, vec2i(position.xy), 0);+ // Rounded to half floats where the separate passes' textures round, so inspecting the mask changes nothing.+ var after = quantizeToF16(adjustLayer(before.rgb, adjustments, params.exposureOnly != 0u));+ if (params.curved != 0u) {+ let size = arrayLength(&curve);+ let at = toneSamples(after, size);+ after = quantizeToF16(tone(after, vec4f(curve[at.x], curve[at.y], curve[at.z], curve[at.w]), size));+ }+ let at = position.xy * params.scale;+ var coverage = gradientCoverage(at, params.first, params.second, params.kind, params.feather, params.angle);+ for (var i = 0u; i < params.modifierCount; i++) {+coverage = modifierCoverage(coverage, at, modifiers[i * 3u], modifiers[i * 3u + 1u], modifiers[i * 3u + 2u]);+ }+ return vec4f(mix(before.rgb, after, coverage * params.opacity), before.a);+}diff --git a/src/app/editor/renderer.ts b/src/app/editor/renderer.tsindex 8e427d3..bf6ccdb 100644--- a/src/app/editor/renderer.ts+++ b/src/app/editor/renderer.ts@@ -8,13 +8,12 @@ import type { ImageSource } from "@/core/image";import {type Composition,createRenderer,- input,- maskInput,+ curveInput,mixAdjustment,pipeline,type RendererOptions,type RenderImage,- transformImages,+ transformImage,} from "@/core/renderer";import { exposure } from "@/features/adjustments/exposure";import { adjustments } from "@/features/adjustments/pass";@@ -23,10 +22,12 @@ import { unsharpMask } from "@/features/details/unsharp-mask";import { fill } from "@/features/fill/pass";import { grain } from "@/features/grain/pass";import { heal, retainHealPatches } from "@/features/heal/pass";+import { histogramGrid } from "@/features/histogram/histogram";import { lut } from "@/features/lut/pass";import { paint } from "@/features/paint/pass";import { toneCurves } from "@/features/tone-curves/pass";import { vignette } from "@/features/vignette/pass";+import { maskPass } from "./mask-pass";type Branch = {image: RenderImage;@@ -67,6 +68,18 @@ function composeLayer(}return { image: below, rangeSource };}+ // Child masks of a mask shape its coverage; every other child processes the image.+ const effects =+ layer.kind === "mask"+ ? layer.children.filter((child) => child.kind !== "mask")+ : layer.children;+ // An inspected mask's curve reads the adjusted image, which only the separate passes produce.+ if (layer.kind === "mask" && !inspected && !effects.length) {+ return {+ image: maskPass(name, below, layer, masks, coverage),+ rangeSource,+ };+ }let input: RenderImage | undefined;let edited = below;switch (layer.kind) {@@ -83,7 +96,14 @@ function composeLayer(case "mask": {const adjusted = pipeline(below, [adjustments(layer.adjustments, name)]);if (layer.id === composition.inputId) {- input = maskInput(name, adjusted, layer.mask, masks, coverage);+ input = curveInput(+ name,+ adjusted,+ histogramGrid,+ layer.mask,+ masks,+ coverage,+ );}edited = pipeline(adjusted, [toneCurves(layer.toneCurve, `${name}/curves`),@@ -125,11 +145,6 @@ function composeLayer(break;}}- // Child masks of a mask shape its coverage; every other child processes the image.- const effects =- layer.kind === "mask"- ? layer.children.filter((child) => child.kind !== "mask")- : layer.children;const children = composeLayers(edited, effects, composition);const image = mixAdjustment(name,@@ -181,8 +196,9 @@ export function createEditorRenderer(const [sourceLayer, ...layers] = scene.layers;const name = `layer/${sourceLayer.id}`;composition.retain(name);+ // The photo's first pass converts an 8-bit source into the working space.const adjusted = pipeline(image, [- adjustments(sourceLayer.adjustments, name),+ adjustments(sourceLayer.adjustments, name, source.primaries),]);const developed = pipeline(adjusted, [toneCurves(sourceLayer.toneCurve, `${name}/curves`),@@ -194,17 +210,12 @@ export function createEditorRenderer();const composite = composeLayers(children.image, layers, composition);const full = composite.image;- const [original, output] = transformImages(- [input(source.image), full],- scene.frame,- );return {- original,full,- output,+ output: transformImage(full, scene.frame),input:composition.inputId === sourceLayer.id- ? adjusted+ ? curveInput(name, adjusted, histogramGrid): (children.input ?? composite.input),rangeSource: children.rangeSource ?? composite.rangeSource,};diff --git a/src/components/editor/image.tsx b/src/components/editor/image.tsxindex aad97f4..da298a7 100644--- a/src/components/editor/image.tsx+++ b/src/components/editor/image.tsx@@ -1,8 +1,13 @@import { useEffect, useMemo } from "react";-import type { Target } from "vgpu";import { useCanvas, useFrame, useGpu } from "vgpu-react";import { useStore } from "zustand";-import { correctionStretch, type ImageFrame } from "@/core/image/frame";+import type { Preview } from "@/core/document";+import type { EncodedImage } from "@/core/image";+import {+ correctionStretch,+ type ImageFrame,+ imageFrame,+} from "@/core/image/frame";import { createDisplay } from "@/core/renderer";import { useDisposable } from "@/hooks/use-disposable";import { fitScale } from "@/hooks/use-pan-zoom";@@ -10,18 +15,30 @@ import { useRenderer } from "./pipeline";import { useDocument, useScene } from "./session";import { useViewport } from "./viewport";-type Output = "fullImage" | "outputImage" | "originalImage";+type Output = "fullImage" | "outputImage";++/** How much of the width shows the source photo: none, all, or up to the divider. */+function comparedShare({ comparison, split }: Preview) {+ if (comparison === "original") {+ return 1;+ }+ if (comparison === "split") {+ return split;+ }+ return -1;+}/** Mount a pipeline output or any target; a supplied frame places the full source behind it. */export function Image({image = "outputImage",geometry,- original,+ comparable = false,}: {- /** A renderer output, or a target such as an export preview. */- image?: Output | Target;+ /** A renderer output, or a target to show as it is, such as an export preview. */+ image?: Output | EncodedImage;geometry?: ImageFrame;- original?: Output;+ /** Whether the source photo is at hand: the comparison shows it, and the mask overlay is drawn over it. */+ comparable?: boolean;}) {const gpu = useGpu();const canvas = useCanvas();@@ -29,48 +46,59 @@ export function Image({const document = useDocument();const preview = useStore(document.preview);const sceneFrame = useScene((scene) => scene.frame);- const sourceSize = document.resources.get(+ const source = document.resources.get(useScene((scene) => scene.layers[0].source),- ).image.size;+ );+ const sourceSize = source.image.size;const renderer = useRenderer();+ // The frame that places the shown image over the source: a crop's draft, or the scene's.+ const placing = geometry ?? sceneFrame;const stretch = useMemo(- () => correctionStretch(sceneFrame, sourceSize),- [sceneFrame, sourceSize],+ () => correctionStretch(placing, sourceSize),+ [placing, sourceSize],);const display = useDisposable(() => createDisplay(gpu), [gpu]);+ // A renderer output tells the preview how many device pixels a source pixel gets where perspective+ // enlarges the photo most, which renders reduce the source to about.+ const density =+ (camera.scale * devicePixelRatio * stretch) / Math.abs(placing.scale[0]);+ useEffect(() => {+ if (typeof image === "string") {+ document.preview.setState({ density });+ }+ }, [document, image, density]);+ // A proxy output is smaller than what it stands for: the source, or the frame cut from it; the+ // source's own frame places the former over the source, and the scene's the latter.+ const represented = { fullImage: sourceSize, outputImage: sceneFrame.size };+ const placed = { fullImage: imageFrame(sourceSize), outputImage: sceneFrame };const render = useFrame((frame) => {- const before = original && renderer[original]();- const target = typeof image === "string" ? renderer[image]() : image;- const source =- preview.comparison === "original" && before ? before : target;- // 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 target = typeof image === "string" ? renderer[image]() : image.image;+ const imageSize =+ typeof image === "string" ? represented[image] : target.size;+ const size = geometry?.size ?? imageSize;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 where- // perspective enlarges the photo most.- renderer.setDisplayScale(- (camera.scale * devicePixelRatio * stretch) /- Math.abs(sceneFrame.scale[0]),- );- }const overlay = preview.maskOverlay;- display(frame, canvas, source, {+ display(frame, canvas, target, {view,viewport: camera.viewport,frame: geometry,- original: before,- split: preview.comparison === "split" ? preview.split : -1,+ imageSize,+ primaries: typeof image === "string" ? undefined : image.primaries,+ source:+ comparable && typeof image === "string"+ ? {+ image: source.image,+ frame: placed[image],+ primaries: source.primaries,+ }+ : undefined,+ split: comparable ? comparedShare(preview) : -1,clipping: preview,overlay: overlay && {...overlay,- frame: sceneFrame,- sourceSize,coverage: overlay.layerId? renderer.coverage(overlay.layerId)?.target: undefined,@@ -80,7 +108,7 @@ export function Image({useEffect(() => renderer.subscribe(render), [renderer, render]);useEffect(() => render(),- [render, camera, preview, geometry, image, sceneFrame, sourceSize],+ [render, camera, preview, geometry, image, sceneFrame, source],);return null;}diff --git a/src/components/editor/pipeline.tsx b/src/components/editor/pipeline.tsxindex 4e6b355..10744ae 100644--- a/src/components/editor/pipeline.tsx+++ b/src/components/editor/pipeline.tsx@@ -74,6 +74,7 @@ export function RendererProvider({let requestedInput: string | undefined;let requestedSource: string | undefined;let requestedInteractive = false;+ let requestedDensity: number | undefined;const render = () => {const scene = document.scene.getState();const target = adjustmentTarget(@@ -81,28 +82,32 @@ export function RendererProvider({document.selection.getState().layerId,);const input = target && "toneCurve" in target ? target.id : undefined;- const source = document.preview.getState().rangeSource;- // An open gesture renders a proxy; its end renders the same scene in full.+ const { rangeSource, density } = document.preview.getState();+ // An open gesture shows a Remove patch unfilled rather than synthesizing its field.const interactive = document.history.status.getState().editing;// A dropped input or source can stay live; only a new one needs a render.if (scene === requestedScene &&(input === requestedInput || !input) &&- (source === requestedSource || !source) &&- interactive === requestedInteractive+ (rangeSource === requestedSource || !rangeSource) &&+ interactive === requestedInteractive &&+ density === requestedDensity) {return;}requestedScene = scene;requestedInput = input;- requestedSource = source;+ requestedSource = rangeSource;requestedInteractive = interactive;+ requestedDensity = density;setError(undefined);- renderer.update(scene, input, interactive, source).catch((error) => {- if (active) {- setError(String(error));- }- });+ renderer+ .update(scene, input, interactive, rangeSource, density)+ .catch((error) => {+ if (active) {+ setError(String(error));+ }+ });};const unsubscribeScene = document.scene.subscribe(render);const unsubscribeSelection = document.selection.subscribe(render);diff --git a/src/core/document/index.ts b/src/core/document/index.tsindex 04eb0b3..2aeda16 100644--- a/src/core/document/index.ts+++ b/src/core/document/index.ts@@ -71,6 +71,8 @@ export type Preview = {};/** The mask whose ranges' image, the one below it, renders keep while a color is picked from it. */rangeSource?: string;+ /** Device pixels the canvas shows per source pixel, which renders reduce the source to about. */+ density: number;};/** Scenes contain only plain values; unchanged branches keep their identity. */@@ -206,6 +208,7 @@ export function createDocument(initial: Scene, resources = createResources()) {split: 0.5,shadows: false,highlights: false,+ density: 1,})),history,resources,diff --git a/src/core/image/color.wgsl b/src/core/image/color.wgslindex 3b2c2b2..022d150 100644--- a/src/core/image/color.wgsl+++ b/src/core/image/color.wgsl@@ -17,6 +17,15 @@ export const p3ToRec2020 = mat3x3f(0.0476, 0.0125, 0.9836,);+/** A color in the primaries `primaries` numbers, 0 the working space's, 1 sRGB, 2 Display P3, in the working space. */+export fn toWorking(rgb: vec3f, primaries: u32) -> vec3f {+ switch (primaries) {+ case 1u: { return srgbToRec2020 * rgb; }+ case 2u: { return p3ToRec2020 * rgb; }+ default: { return rgb; }+ }+}+export const rec2020ToSrgb = mat3x3f(1.6605, -0.1246, -0.0182,-0.5876, 1.1329, -0.1006,diff --git a/src/core/image/decode/index.ts b/src/core/image/decode/index.tsindex 52f2aea..072abfd 100644--- a/src/core/image/decode/index.ts+++ b/src/core/image/decode/index.ts@@ -1,7 +1,7 @@import type { Gpu, Target } from "vgpu";import { createImageSource, type ImageSource } from "@/core/image";-import { linearize } from "./linearize";import type { Decoder } from "./types";+import { uploadDecoded } from "./upload";export type { Target };@@ -11,12 +11,13 @@ type Format = {decode: (gpu: Gpu, file: File) => Promise<ImageSource>;};-/** A format whose decoder yields pixels needing the GPU leg into the working space. */+/** A format whose decoder yields 8-bit sRGB-encoded pixels, kept as such on the GPU. */function pixelFormat(load: () => Promise<Decoder>) {return async (gpu: Gpu, file: File) => {const decoder = await load();const decoded = await decoder(file);- return createImageSource(linearize(gpu, decoded));+ const { image, primaries } = uploadDecoded(gpu, decoded);+ return createImageSource(image, { primaries });};}@@ -96,7 +97,7 @@ export const accept = formatsexport const canDecode = (file: File) => formatOf(file) !== undefined;-/** Decodes the file into a linear rgba16float target: the format's decoder, then its GPU leg. */+/** Decodes the file into a GPU target: 8-bit sRGB-encoded in its own primaries, or the working format for RAW and TIFF. */export async function decode(gpu: Gpu, file: File): Promise<ImageSource> {const format = formatOf(file);if (!format) {diff --git a/src/core/image/decode/linearize.ts b/src/core/image/decode/linearize.tsdeleted file mode 100644index 19c2e2e..0000000--- a/src/core/image/decode/linearize.ts+++ /dev/null@@ -1,94 +0,0 @@-import { effect, frame, type Gpu, type Target, target } from "vgpu";-import { weakMemo } from "@/lib/weak-memo";-import shader from "./linearize.wgsl";-import type { Decoded } from "./types";--type Size = [number, number];--/** Display P3 primaries, which TypeScript's VideoColorPrimaries doesn't list yet. */-const isP3 = (frame?: VideoFrame) =>- `${frame?.colorSpace.primaries}` === "smpte432";--/** A texture whose format decodes sRGB-encoded bytes to linear when read. */-function staging(gpu: Gpu, size: Size) {- return gpu.device.createTexture({- size,- format: "rgba8unorm-srgb",- usage: ["texture_binding", "copy_dst", "render_attachment"],- });-}--/** Uploads the decoded image into a staging texture, tiles laid out on their grid. */-function stage(gpu: Gpu, decoded: Decoded) {- const queue = gpu.gpu.queue;- const size: Size = [decoded.width, decoded.height];- if (decoded instanceof ImageBitmap) {- const texture = staging(gpu, size);- queue.copyExternalImageToTexture(- { source: decoded },- { texture: texture.gpu },- size,- );- decoded.close();- return texture;- }- if ("tiles" in decoded) {- const { tiles, columns } = decoded;- const tile: Size = [- tiles[0]?.displayWidth ?? 0,- tiles[0]?.displayHeight ?? 0,- ];- const rows = Math.ceil(tiles.length / columns);- const texture = staging(gpu, [columns * tile[0], rows * tile[1]]);- tiles.forEach((frame, i) => {- const origin = [- (i % columns) * tile[0],- Math.floor(i / columns) * tile[1],- ];- const colorSpace = isP3(frame) ? "display-p3" : "srgb";- queue.copyExternalImageToTexture(- { source: frame },- { texture: texture.gpu, origin, colorSpace },- tile,- );- frame.close();- });- return texture;- }- const texture = staging(gpu, size);- queue.writeTexture(- { texture: texture.gpu },- decoded.data,- { bytesPerRow: decoded.width * 4 },- size,- );- return texture;-}--/** One conversion pass per GPU, released with its device. */-const conversion = weakMemo((gpu: Gpu) => effect(gpu, shader));--/** GPU leg for sRGB-encoded decoders: renders the decoded image into a linear Rec.2020 rgba16float target. */-export function linearize(gpu: Gpu, decoded: Decoded) {- const frames = "tiles" in decoded ? decoded : undefined;- const rotation = frames?.rotation ?? 0;- const p3 = Number(isP3(frames?.tiles[0]));- const size: Size = [decoded.width, decoded.height];- const source = stage(gpu, decoded);- let image: Target | undefined;- try {- const output = target(gpu, {- size: rotation % 2 ? [size[1], size[0]] : size,- format: "rgba16float",- });- image = output;- const params = { size, rotation, p3 };- frame(gpu, (f) => f.pass(output, conversion(gpu).set({ source, params })));- return output;- } catch (error) {- image?.color.dispose();- throw error;- } finally {- source.dispose();- }-}diff --git a/src/core/image/decode/raw.ts b/src/core/image/decode/raw.tsindex ccb90f0..6348be4 100644--- a/src/core/image/decode/raw.ts+++ b/src/core/image/decode/raw.ts@@ -1,6 +1,6 @@import { createRawDecoder } from "raw-webgpu";import { type Gpu, type Target, target } from "vgpu";-import { createImageSource } from "@/core/image";+import { createImageSource, type RawDevelopment } from "@/core/image";import { weakMemo } from "@/lib/weak-memo";/** One decoder per GPU, released with its device. */@@ -21,22 +21,36 @@ export async function decodeRaw(gpu: Gpu, file: File) {} finally {initial.dispose();}- return createImageSource(original, {- asShot: source.asShot,+ const { asShot } = source;+ const developed = original;+ const raw: RawDevelopment = {+ asShot,createPass() {- const output = target(gpu, {- size: source.size,- format: "rgba16float",- });+ // The as-shot development is the image the source keeps; another balance gets its own.+ let output: Target | undefined;const pass = source.createDevelopPass();let calibration = source.calibration;let dirty = true;return {async prepare(balance) {- calibration = await source.calibrate(balance);+ const shot =+ balance.temperature === asShot.temperature &&+ balance.tint === asShot.tint;+ calibration = shot+ ? source.calibration+ : await source.calibrate(balance);dirty = true;},render() {+ if (calibration === source.calibration) {+ output?.color.dispose();+ output = undefined;+ return developed;+ }+ output ??= target(gpu, {+ size: source.size,+ format: "rgba16float",+ });if (dirty) {pass.render({ destination: output.color.gpu, calibration });dirty = false;@@ -45,12 +59,13 @@ export async function decodeRaw(gpu: Gpu, file: File) {},dispose() {pass.dispose();- output.color.dispose();+ output?.color.dispose();},};},dispose: source.dispose,- });+ };+ return createImageSource(original, { raw });} catch (error) {original?.color.dispose();source.dispose();diff --git a/src/core/image/decode/upload.ts b/src/core/image/decode/upload.tsnew file mode 100644index 0000000..7edf49f--- /dev/null+++ b/src/core/image/decode/upload.ts@@ -0,0 +1,106 @@+import { effect, frame, type Gpu, type Target, target } from "vgpu";+import type { EncodedImage } from "@/core/image";+import { weakMemo } from "@/lib/weak-memo";+import type { Decoded } from "./types";+import shader from "./upload.wgsl";++type Size = [number, number];++/** Display P3 primaries, which TypeScript's VideoColorPrimaries doesn't list yet. */+const isP3 = (frame?: VideoFrame) =>+ `${frame?.colorSpace.primaries}` === "smpte432";++/** A texture of sRGB-encoded bytes, which the GPU decodes to linear when it reads them. */+function encoded(gpu: Gpu, size: Size) {+ return gpu.device.createTexture({+ size,+ format: "rgba8unorm-srgb",+ usage: ["texture_binding", "copy_dst", "render_attachment"],+ });+}++/** Uploads the decoded image into a staging texture, tiles laid out on their grid. */+function stage(gpu: Gpu, decoded: Decoded) {+ const queue = gpu.gpu.queue;+ const size: Size = [decoded.width, decoded.height];+ if (decoded instanceof ImageBitmap) {+ try {+ const texture = encoded(gpu, size);+ queue.copyExternalImageToTexture(+ { source: decoded },+ { texture: texture.gpu },+ size,+ );+ return texture;+ } finally {+ decoded.close();+ }+ }+ if ("tiles" in decoded) {+ const { tiles, columns } = decoded;+ const tile: Size = [+ tiles[0]?.displayWidth ?? 0,+ tiles[0]?.displayHeight ?? 0,+ ];+ const rows = Math.ceil(tiles.length / columns);+ try {+ const texture = encoded(gpu, [columns * tile[0], rows * tile[1]]);+ tiles.forEach((frame, i) => {+ const origin = [+ (i % columns) * tile[0],+ Math.floor(i / columns) * tile[1],+ ];+ const colorSpace = isP3(frame) ? "display-p3" : "srgb";+ queue.copyExternalImageToTexture(+ { source: frame },+ { texture: texture.gpu, origin, colorSpace },+ tile,+ );+ });+ return texture;+ } finally {+ for (const frame of tiles) {+ frame.close();+ }+ }+ }+ const texture = encoded(gpu, size);+ queue.writeTexture(+ { texture: texture.gpu },+ decoded.data,+ { bytesPerRow: decoded.width * 4 },+ size,+ );+ return texture;+}++/** One layout pass per GPU, released with its device. */+const layout = weakMemo((gpu: Gpu) => effect(gpu, shader));++/**+ * GPU leg for sRGB-encoded decoders: the decoded image as an 8-bit sRGB-encoded target, half the+ * memory of the working format, in the primaries it came in. The renderer converts what it reads.+ */+export function uploadDecoded(gpu: Gpu, decoded: Decoded): EncodedImage {+ const frames = "tiles" in decoded ? decoded : undefined;+ const rotation = frames?.rotation ?? 0;+ const primaries = isP3(frames?.tiles[0]) ? "display-p3" : "srgb";+ const size: Size = [decoded.width, decoded.height];+ const source = stage(gpu, decoded);+ let image: Target | undefined;+ try {+ const output = target(gpu, {+ size: rotation % 2 ? [size[1], size[0]] : size,+ format: "rgba8unorm-srgb",+ });+ image = output;+ const params = { size, rotation };+ frame(gpu, (f) => f.pass(output, layout(gpu).set({ source, params })));+ return { image: output, primaries };+ } catch (error) {+ image?.color.dispose();+ throw error;+ } finally {+ source.dispose();+ }+}diff --git a/src/core/image/decode/linearize.wgsl b/src/core/image/decode/upload.wgslsimilarity index 53%rename from src/core/image/decode/linearize.wgslrename to src/core/image/decode/upload.wgslindex 7bb7ebc..c95c5b2 100644--- a/src/core/image/decode/linearize.wgsl+++ b/src/core/image/decode/upload.wgsl@@ -1,15 +1,12 @@-import { p3ToRec2020, srgbToRec2020 } from "../color.wgsl";-struct Params {size: vec2f,rotation: u32,- p3: u32,}@group(0) @binding(0) var<uniform> params: Params;@group(0) @binding(1) var source: texture_2d<f32>;+// Lays the staged image out: cropped to its size, undoing `rotation` counter-clockwise quarter turns.@fragment fn fs_main(@location(0) uv: vec2f) -> @location(0) vec4f {- // Undo `rotation` counter-clockwise quarter turns: where this output pixel sits in the source.var p = uv;switch (params.rotation) {case 1u: { p = vec2f(1.0 - uv.y, uv.x); }@@ -17,7 +14,5 @@ struct Params {case 3u: { p = vec2f(uv.y, 1.0 - uv.x); }default: {}}- let texel = textureLoad(source, vec2i(p * params.size), 0);- let color = select(srgbToRec2020 * texel.rgb, p3ToRec2020 * texel.rgb, params.p3 == 1u);- return vec4f(color, texel.a);+ return textureLoad(source, vec2i(p * params.size), 0);}diff --git a/src/core/image/index.ts b/src/core/image/index.tsindex 20a4d95..02026ed 100644--- a/src/core/image/index.ts+++ b/src/core/image/index.ts@@ -11,8 +11,33 @@ export type RawDevelopment = {dispose(): void;};+/**+ * The primaries an image's texels are in: the working space's, or the sRGB or Display P3 ones an+ * 8-bit source keeps, encoded in a texture format that decodes to linear when read.+ */+export type Primaries = "rec2020" | "srgb" | "display-p3";++/** The primaries as the shaders number them. */+export const primariesIndex: Record<Primaries, number> = {+ rec2020: 0,+ srgb: 1,+ "display-p3": 2,+};++/** A texture with the primaries its texels are in, which whoever reads it converts. */+export type EncodedImage = { image: Target; primaries: Primaries };++type SourceOptions = {+ raw?: RawDevelopment;+ /** The working space's unless said. */+ primaries?: Primaries;+};+/** Document content retained while a preview or export still uses it. */-export function createImageSource(image: Target, raw?: RawDevelopment) {+export function createImageSource(+ image: Target,+ { raw, primaries = "rec2020" }: SourceOptions = {},+) {let references = 1;function release() {let active = true;@@ -30,6 +55,7 @@ export function createImageSource(image: Target, raw?: RawDevelopment) {return {image,raw,+ primaries,retain() {if (!references) {throw Error("Image source is closed.");diff --git a/src/core/renderer/blend/coverage.wgsl b/src/core/renderer/blend/coverage.wgslindex 993c27b..c25c8ef 100644--- a/src/core/renderer/blend/coverage.wgsl+++ b/src/core/renderer/blend/coverage.wgsl@@ -19,3 +19,10 @@ export fn combineCoverage(group: f32, child: f32, operation: u32, opacity: f32)let sign = select(1.0, -1.0, operation == 1u);return clamp(group + sign * opacity * child, 0.0, 1.0);}++// A gradient modifier applied to the group's coverage at `at`, from its three entries as modifierData+// lays them out: its geometry; opacity, kind, feather, and angle; then its operation.+export fn modifierCoverage(group: f32, at: vec2f, points: vec4f, settings: vec4f, operation: vec4f) -> f32 {+ let child = gradientCoverage(at, points.xy, points.zw, u32(settings.y), settings.z, settings.w);+ return combineCoverage(group, child, u32(operation.x), settings.x);+}diff --git a/src/core/renderer/blend/index.ts b/src/core/renderer/blend/index.tsindex bf0279b..18acd7a 100644--- a/src/core/renderer/blend/index.ts+++ b/src/core/renderer/blend/index.ts@@ -1,7 +1,14 @@import type { Gradient, Mask, MaskLayer, MaskModifier } from "@/core/document";-import { merge, node, type RenderImage } from "@/core/renderer/node";+import {+ merge,+ node,+ type RenderImage,+ sourceSize,+} from "@/core/renderer/node";+import inputShader from "./input.wgsl";import shader from "./mix.wgsl";import rasterShader from "./raster.wgsl";+import rasterInputShader from "./raster-input.wgsl";const emptyModifiers = new Float32Array(12);@@ -97,7 +104,7 @@ export function mixAdjustment(samplers: {coverageSampler: { minFilter: "linear", magFilter: "linear" },},- set: { params: { opacity, mode: 0 } },+ set: { params: { opacity } },}),);}@@ -115,50 +122,65 @@ export function mixAdjustment(...gradientParams(mask),modifierCount: gradients.length,scale: original.scale,- mode: 0,},},}),);}+/** An image of `image`'s kind at the histogram's grid, standing for the same source pixels. */+function inputOutput(image: RenderImage, grid: readonly [number, number]) {+ const [width, height] = sourceSize(image);+ return {+ size: grid,+ format: image.format,+ scale: [width / grid[0], height / grid[1]] as const,+ };+}++const linear: GPUSamplerDescriptor = {+ minFilter: "linear",+ magFilter: "linear",+};+/**- * 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.+ * The image a layer's curve receives, with the mask's coverage as alpha, so a histogram of it weighs+ * the pixels the curve affects. It is drawn on `grid`, the texels the histogram counts, each the very+ * image texel the histogram would read at full size, so inspecting a layer costs no full-size+ * texture. Layer opacity is left out: it scales the effect, not the region.*/-export function maskInput(+export function curveInput(name: string,image: RenderImage,- mask: Mask,+ grid: readonly [number, number],+ mask?: Mask,modifiers: readonly MaskModifier[] = [],coverage?: RenderImage,) {+ const output = inputOutput(image, grid);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 } },+ { image, coverage },+ node(`${name}/raster-input`, rasterInputShader, {+ ...output,+ samplers: { coverageSampler: linear },+ set: { params: { grid } },}),);}- if (!isGradient(mask)) {- return image;- }- const gradients = gradientModifiers(modifiers);+ const gradient = mask && isGradient(mask) ? mask : undefined;+ const gradients = gradient ? gradientModifiers(modifiers) : [];return merge(- { original: image, edited: image },- node(`${name}/input`, shader, {+ { image },+ node(`${name}/input`, inputShader, {+ ...output,storage: { modifiers: modifierData(gradients) },set: {params: {- opacity: 1,- ...gradientParams(mask),+ ...gradientParams(gradient),modifierCount: gradients.length,- scale: image.scale,- mode: 1,+ grid,+ imageScale: image.scale,},},}),diff --git a/src/core/renderer/blend/input.wgsl b/src/core/renderer/blend/input.wgslnew file mode 100644index 0000000..8c0e766--- /dev/null+++ b/src/core/renderer/blend/input.wgsl@@ -0,0 +1,32 @@+import { gradientCoverage, modifierCoverage } from "./coverage.wgsl";++// The image a curve receives, with gradient coverage as alpha, drawn on the histogram's grid: each+// texel reads the image texel the histogram would read there at full size.+struct Params {+ kind: u32,+ first: vec2f,+ second: vec2f,+ feather: f32,+ angle: f32,+ modifierCount: u32,+ // The grid's size, and source pixels per image texel.+ grid: vec2u,+ imageScale: vec2f,+}+@group(0) @binding(0) var image: texture_2d<f32>;+@group(0) @binding(1) var<uniform> params: Params;+@group(0) @binding(2) var<storage, read> modifiers: array<vec4f>;++@fragment fn fs_main(@builtin(position) position: vec4f) -> @location(0) vec4f {+ let read = vec2u(position.xy) * textureDimensions(image) / params.grid;+ let color = textureLoad(image, read, 0);+ var coverage = 1.0;+ if (params.kind != 0u) {+ let at = (vec2f(read) + 0.5) * params.imageScale;+ coverage = gradientCoverage(at, params.first, params.second, params.kind, params.feather, params.angle);+ for (var i = 0u; i < params.modifierCount; i++) {+ coverage = modifierCoverage(coverage, at, modifiers[i * 3u], modifiers[i * 3u + 1u], modifiers[i * 3u + 2u]);+ }+ }+ return vec4f(color.rgb, color.a * coverage);+}diff --git a/src/core/renderer/blend/mix.wgsl b/src/core/renderer/blend/mix.wgslindex f109396..47c2262 100644--- a/src/core/renderer/blend/mix.wgsl+++ b/src/core/renderer/blend/mix.wgsl@@ -1,4 +1,4 @@-import { combineCoverage, gradientCoverage } from "./coverage.wgsl";+import { gradientCoverage, modifierCoverage } from "./coverage.wgsl";struct Params {opacity: f32,@@ -10,8 +10,6 @@ struct Params {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>;@@ -26,15 +24,9 @@ struct Params {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 * 3u];- let settings = modifiers[i * 3u + 1u];- let child = gradientCoverage(at, points.xy, points.zw, u32(settings.y), settings.z, settings.w);- coverage = combineCoverage(coverage, child, u32(modifiers[i * 3u + 2u].x), settings.x);+ coverage = modifierCoverage(coverage, at, modifiers[i * 3u], modifiers[i * 3u + 1u], modifiers[i * 3u + 2u]);}}- 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-input.wgsl b/src/core/renderer/blend/raster-input.wgslnew file mode 100644index 0000000..2e5ee13--- /dev/null+++ b/src/core/renderer/blend/raster-input.wgsl@@ -0,0 +1,17 @@+// The image a curve receives, with rasterized coverage as alpha, drawn on the histogram's grid: each+// texel reads the image texel the histogram would read there at full size.+struct Params {+ grid: vec2u,+}+@group(0) @binding(0) var image: texture_2d<f32>;+@group(0) @binding(1) var coverage: texture_2d<f32>;+@group(0) @binding(2) var coverageSampler: sampler;+@group(0) @binding(3) var<uniform> params: Params;++@fragment fn fs_main(@builtin(position) position: vec4f) -> @location(0) vec4f {+ let read = vec2u(position.xy) * textureDimensions(image) / params.grid;+ let color = textureLoad(image, read, 0);+ let uv = (vec2f(read) + 0.5) / vec2f(textureDimensions(image));+ let covered = textureSampleLevel(coverage, coverageSampler, uv, 0.0).r;+ return vec4f(color.rgb, color.a * covered);+}diff --git a/src/core/renderer/blend/raster.wgsl b/src/core/renderer/blend/raster.wgslindex 3613e14..87b1182 100644--- a/src/core/renderer/blend/raster.wgsl+++ b/src/core/renderer/blend/raster.wgsl@@ -1,8 +1,6 @@// 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>;@@ -15,8 +13,5 @@ struct Params {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/image.wgsl b/src/core/renderer/display/image.wgslindex 9555520..9d52a6b 100644--- a/src/core/renderer/display/image.wgsl+++ b/src/core/renderer/display/image.wgsl@@ -1,6 +1,7 @@import { View, imagePoint, previewColor, background, maskTint } from "./display.wgsl";import { Transform, sourcePoint } from "../transform/transform.wgsl";-import { combineCoverage, gradientCoverage } from "../blend/coverage.wgsl";+import { gradientCoverage, modifierCoverage } from "../blend/coverage.wgsl";+import { toWorking } from "../../image/color.wgsl";struct MaskOverlay {kind: u32,@@ -13,6 +14,11 @@ struct MaskOverlay {// The layer's opacity scales coverage in the mix pass, so the tint follows it.opacity: f32,}+// The primaries the image's and the original's texels are in, as toWorking numbers them.+struct Primaries {+ image: u32,+ original: u32,+}@group(0) @binding(0) var<uniform> view: View;@group(0) @binding(1) var source: texture_2d<f32>;@@ -20,35 +26,40 @@ struct MaskOverlay {@group(0) @binding(3) var<uniform> transform: Transform;@group(0) @binding(4) var original: texture_2d<f32>;@group(0) @binding(5) var<uniform> split: f32;-@group(0) @binding(6) var<uniform> maskTransform: Transform;+// Where a point of the image sits in the source, which the original and the mask overlay are drawn from.+@group(0) @binding(6) var<uniform> sourceTransform: 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>;+@group(0) @binding(10) var<uniform> primaries: Primaries;// 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 point = sourcePoint(maskTransform, uv);+fn overlayCoverage(point: vec2f) -> f32 {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 * 3u];- let settings = modifiers[i * 3u + 1u];- let child = gradientCoverage(position, points.xy, points.zw, u32(settings.y), settings.z, settings.w);- coverage = combineCoverage(coverage, child, u32(modifiers[i * 3u + 2u].x), settings.x);+ coverage = modifierCoverage(coverage, position, modifiers[i * 3u], modifiers[i * 3u + 1u], modifiers[i * 3u + 2u]);}return coverage * overlay.opacity;}@fragment fn fs_main(@location(0) uv: vec2f) -> @location(0) vec4f {let p = sourcePoint(transform, imagePoint(view, uv));- let edited = textureSampleLevel(source, sourceSampler, p, 0.0);- let before = textureSampleLevel(original, sourceSampler, p, 0.0);- var color = previewColor(select(edited, before, uv.x < split), view);+ let point = sourcePoint(sourceTransform, p);+ var sample = textureSampleLevel(source, sourceSampler, p, 0.0);+ sample = vec4f(toWorking(sample.rgb, primaries.image), sample.a);+ if (uv.x < split) {+ // The source shows only where the frame reaches it, as the transform pass leaves the image.+ let reached = all(point >= vec2f(0.0)) && all(point <= vec2f(1.0));+ sample = select(vec4f(0.0), textureSampleLevel(original, sourceSampler, point, 0.0), reached);+ sample = vec4f(toWorking(sample.rgb, primaries.original), sample.a);+ }+ var color = previewColor(sample, view);if (overlay.kind != 0u) {- color = maskTint(color, overlayCoverage(p));+ color = maskTint(color, overlayCoverage(point));}let inside = all(p >= vec2f(0.0)) && all(p <= vec2f(1.0));return vec4f(select(background, color, inside), 1.0);diff --git a/src/core/renderer/display/index.ts b/src/core/renderer/display/index.tsindex 2387667..71fe20c 100644--- a/src/core/renderer/display/index.ts+++ b/src/core/renderer/display/index.ts@@ -10,6 +10,11 @@ import {target,} from "vgpu";import type { Mask, MaskModifier } from "@/core/document";+import {+ type EncodedImage,+ type Primaries,+ primariesIndex,+} from "@/core/image";import {frameTransform,type ImageFrame,@@ -31,17 +36,22 @@ export type Clipping = { shadows: boolean; highlights: boolean };export type MaskOverlay = {mask: Mask;modifiers: readonly MaskModifier[];- frame: ImageFrame;- sourceSize: readonly number[];coverage?: Target;/** The layer's opacity, which scales its coverage. */opacity?: number;};+/** The photo's source as decoded, in its own primaries, and the frame that places the image over it. */+export type DisplaySource = EncodedImage & { frame: ImageFrame };type DisplayOptions = {view: View;viewport?: readonly number[];frame?: ImageFrame;- original?: Target;+ /** The primaries the image's texels are in; the working space's unless said. */+ primaries?: Primaries;+ /** The pixels `image` stands for when a proxy reduces it; its own size unless said. */+ imageSize?: Point;+ /** Shown left of `split` in place of the image, and where the mask overlay is drawn; the image itself without one. */+ source?: DisplaySource;split?: number;clipping?: Clipping;overlay?: MaskOverlay;@@ -78,17 +88,23 @@ export function createDisplay(gpu: Gpu) {image: Target,options: DisplayOptions,) {- const geometry = options.frame ?? imageFrame(image.size);+ const represented = options.imageSize ?? image.size;+ const geometry = options.frame ?? imageFrame(represented);const viewport =options.viewport ?? canvas.size.map((value) => value / canvas.dpr);const overlay = options.overlay;+ const source = options.source;writeModifiers(overlay);frame.pass(canvas,draw.set({source: image.color,- original: (options.original ?? image).color,- transform: frameTransform(geometry, image.size),+ original: (source?.image ?? image).color,+ primaries: {+ image: primariesIndex[options.primaries ?? "rec2020"],+ original: primariesIndex[source?.primaries ?? "rec2020"],+ },+ transform: frameTransform(geometry, represented),split: options.split ?? -1,view: {size: canvas.size,@@ -99,9 +115,9 @@ export function createDisplay(gpu: Gpu) {shadows: Number(options.clipping?.shadows ?? false),highlights: Number(options.clipping?.highlights ?? false),},- maskTransform: frameTransform(- overlay?.frame ?? geometry,- overlay?.sourceSize ?? image.size,+ sourceTransform: frameTransform(+ source?.frame ?? imageFrame(represented),+ source?.image.size ?? represented,),coverage: (overlay?.coverage ?? blank).color,overlay: {@@ -110,7 +126,7 @@ export function createDisplay(gpu: Gpu) {modifierCount: overlay? gradientModifiers(overlay.modifiers).length: 0,- sourceSize: overlay?.sourceSize ?? image.size,+ sourceSize: source?.image.size ?? represented,opacity: overlay?.opacity ?? 1,},}),@@ -158,14 +174,25 @@ export async function renderCoverage(}}-/** 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) {+/**+ * Draws an image, in the working space's primaries unless said, 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,+ primaries?: Primaries,+) {const display = bitmapDisplay(gpu);const canvas = new OffscreenCanvas(size[0], size[1]);const output = surface(gpu, canvas, { size, dpr: 1 });try {frame(gpu, (frame) =>- display(frame, output, image, { view: { zoom: 1, pan: [0, 0] } }),+ display(frame, output, image, {+ view: { zoom: 1, pan: [0, 0] },+ primaries,+ }),);// Finish the draw before the 2D canvas reads it; otherwise Chrome waits a full second for the sync.await gpu.gpu.queue.onSubmittedWorkDone();diff --git a/src/core/renderer/graph.ts b/src/core/renderer/graph.tsindex f4559df..96a6569 100644--- a/src/core/renderer/graph.ts+++ b/src/core/renderer/graph.ts@@ -48,15 +48,23 @@ function plan(outputs: readonly RenderImage[]) {const sizeKey = (image: { size: readonly number[]; format: string }) =>`${image.size[0]}x${image.size[1]} ${image.format}`;+/**+ * Which set of sizes a render belongs to, named by the caller, so its sizes replace the ones that+ * set used before, and the sets whose idle targets stay for the next render in them.+ */+export type Retention = {+ set: number;+ kept: readonly number[];+};+/** Owns effects, storage buffers, and transient targets for one renderer. */export function createRenderGraph(gpu: Gpu, timer?: Timer) {const pool: Target[] = [];/**- * How many targets of each size the last two distinct sets of sizes used, most recent first. An- * interactive proxy and the full image alternate between two such sets, and keeping both saves- * reallocating full-size targets on every gesture, which a phone's GPU memory can't absorb.+ * How many targets of each size the latest render in each set used: the current set's and the kept+ * ones', so a zoom that returns to a kept set allocates nothing, which Safari penalizes.*/- let recent: Map<string, number>[] = [];+ const recent = new Map<number, Map<string, number>>();const effects = new Map<string, Pass>();let passes: string[] = [];let disposed = false;@@ -129,7 +137,7 @@ export function createRenderGraph(gpu: Gpu, timer?: Timer) {}}},- render(outputs: readonly RenderImage[]) {+ render(outputs: readonly RenderImage[], { set, kept }: Retention) {if (disposed) {throw Error("Render graph is closed.");}@@ -176,21 +184,19 @@ export function createRenderGraph(gpu: Gpu, timer?: Timer) {for (const image of written) {used.set(sizeKey(image), (used.get(sizeKey(image)) ?? 0) + 1);}- // Sizes that one set contains of the other are the same mode with more or fewer effects: the new- // counts replace the old, so the peak of an effect since turned off is let go.- const contains = (a: Map<string, number>, b: Map<string, number>) =>- [...b.keys()].every((key) => a.has(key));- const sameMode = (counts: Map<string, number>) =>- contains(counts, used) || contains(used, counts);- recent = [used, ...recent.filter((counts) => !sameMode(counts))].slice(- 0,- 2,- );- // Past these counts, an idle target is an old crop size or an old peak.- const kept = new Map<string, number>();+ // The new counts replace the set's old ones, so an old crop size or the peak of an effect since+ // turned off is let go, and so is every set no longer kept.+ recent.set(set, used);+ for (const other of recent.keys()) {+ if (other !== set && !kept.includes(other)) {+ recent.delete(other);+ }+ }+ // Past these counts, an idle target is an old size or an old peak.+ const counted = new Map<string, number>();for (const image of pool) {if (written.has(image) || live.has(image)) {- kept.set(sizeKey(image), (kept.get(sizeKey(image)) ?? 0) + 1);+ counted.set(sizeKey(image), (counted.get(sizeKey(image)) ?? 0) + 1);}}for (let i = pool.length - 1; i >= 0; i--) {@@ -200,11 +206,11 @@ export function createRenderGraph(gpu: Gpu, timer?: Timer) {}const key = sizeKey(image);const allowed = Math.max(- ...recent.map((counts) => counts.get(key) ?? 0),+ ...[...recent.values()].map((counts) => counts.get(key) ?? 0),);- const count = kept.get(key) ?? 0;+ const count = counted.get(key) ?? 0;if (count < allowed) {- kept.set(key, count + 1);+ counted.set(key, count + 1);continue;}image.color.dispose();@@ -235,7 +241,7 @@ export function createRenderGraph(gpu: Gpu, timer?: Timer) {image.color.dispose();}pool.length = 0;- recent = [];+ recent.clear();},};}diff --git a/src/core/renderer/index.ts b/src/core/renderer/index.tsindex 701b875..db3722f 100644--- a/src/core/renderer/index.ts+++ b/src/core/renderer/index.ts@@ -26,7 +26,14 @@ import {import { createProxy } from "./proxy";import { createStrokes } from "./strokes";-export { maskInput, mixAdjustment } from "./blend";+export {+ curveInput,+ gradientModifiers,+ gradientParams,+ isGradient,+ mixAdjustment,+ modifierData,+} from "./blend";export {type Clipping,type CoverageRegion,@@ -53,7 +60,7 @@ export {split,} from "./node";export type { PaintInput } from "./paint";-export { transformImages } from "./transform";+export { transformImage } from "./transform";export { createRenderGraph };export type Composition = {@@ -90,7 +97,6 @@ export type SceneProcessing = (scene: Scene,composition: Composition,) => {- original: RenderImage;full: RenderImage;output: RenderImage;input?: RenderImage;@@ -101,10 +107,28 @@ type RenderRequest = {scene: Scene;inputId?: string;rangeSourceId?: string;+ /** Device pixels shown per source pixel, which the render reduces the source to about. */+ density: number;/** Source pixels per texel of the composition's source; above 1 renders a reduced proxy. */factor: number;+ /** An open gesture, which shows a Remove patch unfilled rather than synthesizing its field. */+ interactive: boolean;};+/** A Remove field a render synthesized, to keep. */+type Synthesis = { id: string; lattice: FieldLattice; texels: RenderImage };++/** The largest whole reduction that still gives every device pixel a texel. */+function reductionFor(density: number) {+ if (!Number.isFinite(density) || density <= 0) {+ return 1;+ }+ return Math.max(1, Math.floor(1 / density));+}++/** How many reductions keep their proxy and intermediates, each a quarter of the photo at most. */+const keptReductions = 4;+function sameBalance(a: WhiteBalance | undefined, b: WhiteBalance | undefined) {return a?.temperature === b?.temperature && a?.tint === b?.tint;}@@ -148,7 +172,6 @@ export function createRenderer(const proxy = createProxy(gpu);const release = resource.retain();const raw = resource.raw?.createPass();- let original = source;let full = source;const listeners = new Set<() => void>();let rendered = false;@@ -160,8 +183,16 @@ export function createRenderer(let balance = resource.raw?.asShot;/** Counts developments, so the proxy follows white-balance changes. */let version = 0;- let displayScale = 1;let last: RenderRequest | undefined;+ /** Whether the last render, a gesture's proxy, showed a Remove patch unfilled. */+ let lacked = false;+ /** The passes the last render's synthesis ran apart, before its own. */+ let synthesized: string[] = [];+ /**+ * The reductions rendered at last, latest first, whose proxies and intermediates stay: a zoom+ * returns to them, and Safari penalizes textures made and freed. The photo's own size never stays.+ */+ let reductions: number[] = [];let next: RenderRequest | undefined;let pending: Promise<void> | undefined;/** A raster being read back, a painting to settle or a Remove field to save; nothing renders meanwhile. */@@ -170,34 +201,16 @@ export function createRenderer(const capturing = new Map<string, Promise<RemoveField | undefined>>();let disposed = false;let instances = new Set<string>();- function render(request: RenderRequest) {- const { scene, inputId, rangeSourceId, factor } = request;- if (- last &&- last.scene === scene &&- last.inputId === inputId &&- last.rangeSourceId === rangeSourceId &&- last.factor === factor- ) {- return;- }+ /**+ * Composes the scene over `image`, at one reduction: what the composition yields, the Remove fields+ * it synthesizes, the brush coverage to show, the instances it keeps, and whether it lacked a field.+ */+ function composeAt(+ { scene, inputId, rangeSourceId }: RenderRequest,+ image: RenderImage,+ developed: Target,+ ) {const active = new Set<string>();- const developed = raw?.render() ?? source;- // Every brush and paint layer updates once, bypassed or not, so hidden layers keep their rasters.- for (const { layer } of walkLayers(scene.layers)) {- if (layer.kind === "mask" && layer.mask.kind === "brush") {- brushes.draw(layer.id, layer.mask, developed.size);- }- if (layer.kind === "paint") {- paints.draw(layer.id, layer, developed.size);- }- }- // Remove fields stay while their patches do, shown or not.- for (const { patch } of removePatches(scene.layers)) {- fields.retain(patch.field);- }- const image =- factor > 1 ? proxy.render(developed, factor, version) : input(developed);const covered = new Map<string, RenderImage>();// Read brush views after every raster has updated, including inactive submasks.for (const { layer } of walkLayers(scene.layers)) {@@ -210,11 +223,8 @@ export function createRenderer(if (coverage) covered.set(layer.id, coverage);}}- const syntheses: {- id: string;- lattice: FieldLattice;- texels: RenderImage;- }[] = [];+ const syntheses: Synthesis[] = [];+ let lacking = false;const images = compose(image, scene, {inputId,rangeSourceId,@@ -227,12 +237,78 @@ export function createRenderer(paint: (layer) => paints.input(layer),patch: (id, strokes) => patches.patch(id, strokes, developed.size),// Patches that share a field, such as duplicates, show the one this render synthesizes.- field: (patch) =>- syntheses.find(({ id }) => id === patch.field) ??- fields.get(patch.field),+ field: (patch) => {+ const held =+ syntheses.find(({ id }) => id === patch.field) ??+ fields.get(patch.field);+ lacking ||= !held;+ return held;+ },keepField: (patch, lattice, texels) =>syntheses.push({ id: patch.field, lattice, texels }),});+ return { images, syntheses, covered, active, lacking };+ }+ /** Keeps the fields a render synthesized and reads them back for the document. */+ function keepSyntheses(syntheses: readonly Synthesis[], targets: Target[]) {+ for (const [i, { id, lattice }] of syntheses.entries()) {+ fields.keep(id, lattice, targets[i]);+ }+ if (saveField && syntheses.length) {+ capture(syntheses.map(({ id }) => id));+ }+ }+ function render(request: RenderRequest): void {+ const { scene, inputId, rangeSourceId, factor } = request;+ const unchanged =+ last &&+ last.scene === scene &&+ last.inputId === inputId &&+ last.rangeSourceId === rangeSourceId &&+ last.factor === factor;+ // A gesture's proxy shows a patch unfilled; the gesture's end renders it again to synthesize.+ if (unchanged && !(lacked && !request.interactive)) {+ return;+ }+ const developed = raw?.render() ?? source;+ // Every brush and paint layer updates once, bypassed or not, so hidden layers keep their rasters.+ for (const { layer } of walkLayers(scene.layers)) {+ if (layer.kind === "mask" && layer.mask.kind === "brush") {+ brushes.draw(layer.id, layer.mask, developed.size);+ }+ if (layer.kind === "paint") {+ paints.draw(layer.id, layer, developed.size);+ }+ }+ // Remove fields stay while their patches do, shown or not.+ for (const { patch } of removePatches(scene.layers)) {+ fields.retain(patch.field);+ }+ const image =+ factor > 1 ? proxy.render(developed, factor, version) : input(developed);+ let composed = composeAt(request, image, developed);+ synthesized = [];+ // Only a full render synthesizes a field. A proxy that lacks one has it synthesized apart, from+ // the layers below the patch alone, at full size, and composes again with it; a gesture shows the+ // patch unfilled instead.+ if (composed.lacking && factor > 1 && !request.interactive) {+ const { syntheses } = composeAt(+ { ...request, factor: 1 },+ input(developed),+ developed,+ );+ if (syntheses.length) {+ const texels = graph.render(+ syntheses.map(({ texels }) => texels),+ { set: 1, kept: reductions },+ );+ keepSyntheses(syntheses, texels);+ synthesized = graph.inspect().passes;+ }+ composed = composeAt(request, image, developed);+ }+ const { images, syntheses, covered, active } = composed;+ lacked = composed.lacking && factor > 1;for (const id of instances) {if (!active.has(id)) graph.release(`${id}/`);}@@ -242,33 +318,35 @@ export function createRenderer(patches.sweep();paints.sweep();strokes.sweep();- // Every render shows three images; the inspected input, the range source, and coverage follow.+ // The inspected input goes first, so the image it reads is let go once the composition is done+ // with it; the two images every render shows, the range source, and coverage follow.const inputs = images.input ? [images.input] : [];const sources = images.rangeSource ? [images.rangeSource] : [];- const targets = graph.render([- images.original,- images.full,- images.output,- ...inputs,- ...sources,- ...covered.values(),- ...syntheses.map(({ texels }) => texels),- ]);- [original, full, output] = targets;- const [inputTarget] = targets.slice(3, 3 + inputs.length);- const [sourceTarget] = targets.slice(3 + inputs.length);+ if (factor > 1) {+ reductions = [factor, ...reductions.filter((kept) => kept !== factor)];+ reductions.length = Math.min(reductions.length, keptReductions);+ }+ const targets = graph.render(+ [+ ...inputs,+ images.full,+ images.output,+ ...sources,+ ...covered.values(),+ ...syntheses.map(({ texels }) => texels),+ ],+ { set: factor, kept: reductions },+ );+ proxy.sweep(reductions);+ const [inputTarget] = targets;+ [full, output] = targets.slice(inputs.length);+ const [sourceTarget] = targets.slice(inputs.length + 2);const coverages = targets.slice(- 3 + inputs.length + sources.length,- 3 + inputs.length + sources.length + covered.size,+ inputs.length + 2 + sources.length,+ inputs.length + 2 + sources.length + covered.size,);- const synthesized = targets.slice(targets.length - syntheses.length);- for (const [i, { id, lattice }] of syntheses.entries()) {- fields.keep(id, lattice, synthesized[i]);- }+ keepSyntheses(syntheses, targets.slice(targets.length - syntheses.length));fields.sweep();- if (saveField && syntheses.length) {- capture(syntheses.map(({ id }) => id));- }inspected =inputId && images.input ? { id: inputId, image: inputTarget } : undefined;kept =@@ -377,20 +455,28 @@ export function createRenderer(}}/**- * Interactive updates render at a proxy resolution matched to the display scale. `inputId` keeps a- * layer's curve input, and `rangeSourceId` a mask's range source, for reading them.+ * Renders reduce the source to about `density`, device pixels shown per source pixel, a proxy; one+ * that lacks a Remove patch's field synthesizes it apart in full, outside a gesture. `inputId` keeps+ * a layer's curve input, and `rangeSourceId` a mask's range source, for reading them.*/async function update(scene: Scene,inputId?: string,interactive = false,rangeSourceId?: string,+ density = 1,): Promise<void> {if (disposed) {throw Error("Renderer is closed.");}- const factor = interactive ? Math.max(1, Math.floor(1 / displayScale)) : 1;- const request = { scene, inputId, rangeSourceId, factor };+ const request = {+ scene,+ inputId,+ rangeSourceId,+ density,+ factor: reductionFor(density),+ interactive,+ };// Renders wait, in order, for a settle, a RAW development, or settled paint and fields to load.if (!raw &&@@ -412,8 +498,8 @@ export function createRenderer(.finally(() => {pending = undefined;if (next && !disposed) {- const { scene, inputId, factor, rangeSourceId } = next;- return update(scene, inputId, factor > 1, rangeSourceId);+ const { scene, inputId, interactive, rangeSourceId, density } = next;+ return update(scene, inputId, interactive, rangeSourceId, density);}});return pending;@@ -447,7 +533,6 @@ export function createRenderer(}return {- originalImage: () => original,fullImage: () => full,outputImage: () => output,inputImage: (id: string) =>@@ -462,14 +547,9 @@ export function createRenderer(const target = shown.get(id) ?? paints.get(id);return target ? { target, origin: [0, 0] } : patches.raster(id);},- /** 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(),+ passes: [...synthesized, ...graph.inspect().passes],stamped: strokes.stamped(),rasters: [...masks.inspect(),diff --git a/src/core/renderer/node.ts b/src/core/renderer/node.tsindex fc25571..f8fe337 100644--- a/src/core/renderer/node.ts+++ b/src/core/renderer/node.ts@@ -9,6 +9,8 @@ type NodeOptions = {readonly storage?: Readonly<Record<string, Float32Array<ArrayBuffer>>>;readonly size?: readonly [number, number];readonly format?: GPUTextureFormat;+ /** With `size`, when the node's texels stand for other source pixels than its first input's. */+ readonly scale?: Scale;};export type NodeDefinition = NodeOptions & {readonly name: string;@@ -77,7 +79,7 @@ export function merge(inputs,size: definition.size ?? first.size,format: definition.format ?? first.format,- scale: first.scale,+ scale: definition.scale ?? first.scale,};}diff --git a/src/core/renderer/proxy/index.ts b/src/core/renderer/proxy/index.tsindex 23ac3aa..73864fc 100644--- a/src/core/renderer/proxy/index.ts+++ b/src/core/renderer/proxy/index.ts@@ -4,49 +4,56 @@ import shader from "./proxy.wgsl";type Cached = {source: Target;- factor: number;version: number;- output: Target;+ /** The reduced copy at each factor rendered, so a zoom that returns to a factor allocates nothing. */+ outputs: Map<number, Target>;};-/** A reduced copy of the source for interactive rendering, kept until the source, factor, or version changes. */+/** Reduced copies of the source, which renders at the display's density read, kept until swept or until the source 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] = [+ function clear() {+ for (const output of cached?.outputs.values() ?? []) {+ output.color.dispose();+ }+ cached = undefined;+ }+ /** A reduced copy of `source` at `factor`, rendered now. */+ function reduceTo(source: Target, factor: number) {+ const output = target(gpu, {+ size: [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 };+ ],+ format: source.format,+ });+ reduce.set({ source: source.color, factor });+ frame(gpu, (frame) => frame.pass(output, reduce));+ return output;+ }+ return {+ render(source: Target, factor: number, version = 0): RenderInput {+ if (cached?.source !== source || cached.version !== version) {+ clear();+ cached = { source, version, outputs: new Map() };}- return input(cached.output, [- source.size[0] / size[0],- source.size[1] / size[1],+ const output = cached.outputs.get(factor) ?? reduceTo(source, factor);+ cached.outputs.set(factor, output);+ return input(output, [+ source.size[0] / output.size[0],+ source.size[1] / output.size[1],]);},- dispose() {- cached?.output.color.dispose();- cached = undefined;+ /** Lets go of the copies at every factor but `kept`. */+ sweep(kept: readonly number[]) {+ for (const [factor, output] of cached?.outputs ?? []) {+ if (!kept.includes(factor)) {+ output.color.dispose();+ cached?.outputs.delete(factor);+ }+ }},+ dispose: clear,};}diff --git a/src/core/renderer/transform/index.ts b/src/core/renderer/transform/index.tsindex 2eb42d3..66df051 100644--- a/src/core/renderer/transform/index.ts+++ b/src/core/renderer/transform/index.ts@@ -12,35 +12,23 @@ import {} from "@/core/renderer/node";import shader from "./frame.wgsl";-/** 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(sourceSize(sources[0])));+/** The image placed by the frame; identity geometry preserves the input. A proxy keeps its reduction. */+export function transformImage(source: RenderImage, geometry: ImageFrame) {+ const initial = frameValues(imageFrame(sourceSize(source)));if (frameValues(geometry).every((value, i) => value === initial[i])) {- return sources;+ return source;}- const outputs = new Map<RenderImage, RenderImage>();- return sources.map((input, i) => {- const existing = outputs.get(input);- if (existing) {- return existing;- }- const output = merge(- { source: input },- node(`transform/${i}`, shader, {- set: { transform: frameTransform(geometry, sourceSize(input)) },- samplers: {- sourceSampler: { magFilter: "linear", minFilter: "linear" },- },- 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);- return output;- });+ return merge(+ { source },+ node("transform", shader, {+ set: { transform: frameTransform(geometry, sourceSize(source)) },+ samplers: {+ sourceSampler: { magFilter: "linear", minFilter: "linear" },+ },+ size: [+ Math.max(1, Math.round(geometry.size[0] / source.scale[0])),+ Math.max(1, Math.round(geometry.size[1] / source.scale[1])),+ ],+ }),+ );}diff --git a/src/features/adjustments/adjust.wgsl b/src/features/adjustments/adjust.wgslnew file mode 100644index 0000000..6beeeb4--- /dev/null+++ b/src/features/adjustments/adjust.wgsl@@ -0,0 +1,50 @@+import { luminance, toWorking } from "../../core/image/color.wgsl";+import { adjustBlacks } from "./blacks.wgsl";+import { adjustHighlights } from "./highlights.wgsl";+import { adjustShadows } from "./shadows.wgsl";+import { adjustWhites } from "./whites.wgsl";+import { Adjustments, adjustExposure, prepareColor } from "./prepare.wgsl";++fn interpolateGain(amount: f32, half: vec3f, full: vec3f) -> vec3f {+ let strength = 2.0 * abs(amount);+ return mix(half * min(strength, 1.0), full, max(strength - 1.0, 0.0));+}++fn adjustContrast(color: vec3f, amount: f32) -> vec3f {+ let positive = interpolateGain(amount - 1.0, vec3f(0.32, 1.48, 0.0), vec3f(0.59, 2.77, 0.0)).xy;+ let gain = select(positive, vec2f(-0.43, -2.51) * (1.0 - amount), amount < 1.0);+ let bounded = min(color, vec3f(1.0));+ return color + bounded * (1.0 - bounded) * (gain.x + gain.y * (bounded - 0.5));+}++fn adjustSaturation(color: vec3f, amount: f32) -> vec3f {+ let gray = vec3f(luminance(color));+ return gray + (color - gray) * amount;+}++fn adjustVibrance(color: vec3f, amount: f32) -> vec3f {+ let high = max(max(color.r, color.g), color.b);+ let low = max(0.0, min(min(color.r, color.g), color.b));+ let saturation = 1.0 - sqrt(low / max(high, 0.000001));+ let scale = 1.0 + amount * select(0.63, 0.23, amount < 0.0) * (1.0 - sign(amount) * saturation);+ return max(vec3f(high) + (color - vec3f(high)) * scale, vec3f(0.0));+}++export fn adjustColor(input: vec3f, adjustments: Adjustments) -> vec3f {+ let prepared = prepareColor(input, adjustments);+ var color = adjustHighlights(prepared, adjustments.highlights);+ color = adjustShadows(color, adjustments.shadows);+ color = adjustWhites(color, adjustments.whites);+ color = adjustBlacks(color, adjustments.blacks);+ color = adjustContrast(color, 1.0 + adjustments.contrast / 100.0);+ color = adjustVibrance(color, adjustments.vibrance / 100.0);+ return adjustSaturation(color, 1.0 + adjustments.saturation / 100.0);+}++// Exposure alone takes only its own step, as the lighter exposure pass does: the full chain rounds even neutral values.+export fn adjustLayer(color: vec3f, adjustments: Adjustments, exposureOnly: bool) -> vec3f {+ if (exposureOnly) {+ return adjustExposure(toWorking(color, adjustments.primaries), adjustments.exposure);+ }+ return adjustColor(color, adjustments);+}diff --git a/src/features/adjustments/adjustments.wgsl b/src/features/adjustments/adjustments.wgslindex cd7eaad..362a15c 100644--- a/src/features/adjustments/adjustments.wgsl+++ b/src/features/adjustments/adjustments.wgsl@@ -1,49 +1,12 @@-import { luminance } from "../../core/image/color.wgsl";-import { adjustBlacks } from "./blacks.wgsl";-import { adjustHighlights } from "./highlights.wgsl";-import { adjustShadows } from "./shadows.wgsl";-import { adjustWhites } from "./whites.wgsl";-import { Adjustments, prepareColor } from "./prepare.wgsl";+import { adjustColor } from "./adjust.wgsl";+import { Adjustments } from "./prepare.wgsl";@group(0) @binding(0) var source: texture_2d<f32>;@group(0) @binding(1) var sourceSampler: sampler;@group(0) @binding(2) var<uniform> adjustments: Adjustments;-fn interpolateGain(amount: f32, half: vec3f, full: vec3f) -> vec3f {- let strength = 2.0 * abs(amount);- return mix(half * min(strength, 1.0), full, max(strength - 1.0, 0.0));-}--fn adjustContrast(color: vec3f, amount: f32) -> vec3f {- let positive = interpolateGain(amount - 1.0, vec3f(0.32, 1.48, 0.0), vec3f(0.59, 2.77, 0.0)).xy;- let gain = select(positive, vec2f(-0.43, -2.51) * (1.0 - amount), amount < 1.0);- let bounded = min(color, vec3f(1.0));- return color + bounded * (1.0 - bounded) * (gain.x + gain.y * (bounded - 0.5));-}--fn adjustSaturation(color: vec3f, amount: f32) -> vec3f {- let gray = vec3f(luminance(color));- return gray + (color - gray) * amount;-}--fn adjustVibrance(color: vec3f, amount: f32) -> vec3f {- let high = max(max(color.r, color.g), color.b);- let low = max(0.0, min(min(color.r, color.g), color.b));- let saturation = 1.0 - sqrt(low / max(high, 0.000001));- let scale = 1.0 + amount * select(0.63, 0.23, amount < 0.0) * (1.0 - sign(amount) * saturation);- return max(vec3f(high) + (color - vec3f(high)) * scale, vec3f(0.0));-}-@fragmentfn fs_main(@location(0) uv: vec2f) -> @location(0) vec4f {let input = textureSample(source, sourceSampler, uv);- let prepared = prepareColor(input.rgb, adjustments);- var color = adjustHighlights(prepared, adjustments.highlights);- color = adjustShadows(color, adjustments.shadows);- color = adjustWhites(color, adjustments.whites);- color = adjustBlacks(color, adjustments.blacks);- color = adjustContrast(color, 1.0 + adjustments.contrast / 100.0);- color = adjustVibrance(color, adjustments.vibrance / 100.0);- color = adjustSaturation(color, 1.0 + adjustments.saturation / 100.0);- return vec4f(color, input.a);+ return vec4f(adjustColor(input.rgb, adjustments), input.a);}diff --git a/src/features/adjustments/exposure.ts b/src/features/adjustments/exposure.tsindex c0e50b0..0a4b29d 100644--- a/src/features/adjustments/exposure.ts+++ b/src/features/adjustments/exposure.ts@@ -1,9 +1,18 @@+import { type Primaries, primariesIndex } from "@/core/image";import { node } from "@/core/renderer";import shader from "./exposure.wgsl";-export function exposure(name: string, value: number) {- if (value === 0) {+/** Exposure in stops; the pass also converts an input in other `primaries` into the working space. */+export function exposure(+ name: string,+ value: number,+ primaries: Primaries = "rec2020",+) {+ if (value === 0 && primaries === "rec2020") {return;}- return node(name, shader, { set: { exposure: value } });+ return node(name, shader, {+ format: "rgba16float",+ set: { params: { primaries: primariesIndex[primaries], exposure: value } },+ });}diff --git a/src/features/adjustments/exposure.wgsl b/src/features/adjustments/exposure.wgslindex 9f6a2c0..a81de1d 100644--- a/src/features/adjustments/exposure.wgsl+++ b/src/features/adjustments/exposure.wgsl@@ -1,7 +1,15 @@+import { toWorking } from "../../core/image/color.wgsl";import { adjustExposure } from "./prepare.wgsl";++struct Params {+ // The primaries the input is in, as toWorking numbers them: the image layer's pass converts an 8-bit source.+ primaries: u32,+ exposure: f32,+}@group(0) @binding(0) var source: texture_2d<f32>;-@group(0) @binding(1) var<uniform> exposure: f32;+@group(0) @binding(1) var<uniform> params: Params;@fragment fn fs_main(@builtin(position) position: vec4f) -> @location(0) vec4f {let pixel = textureLoad(source, vec2i(position.xy), 0);- return vec4f(adjustExposure(pixel.rgb, exposure), pixel.a);+ let working = toWorking(pixel.rgb, params.primaries);+ return vec4f(adjustExposure(working, params.exposure), pixel.a);}diff --git a/src/features/adjustments/pass.ts b/src/features/adjustments/pass.tsindex b7dc846..c6d0b09 100644--- a/src/features/adjustments/pass.ts+++ b/src/features/adjustments/pass.ts@@ -1,20 +1,36 @@import type { Adjustments } from "@/core/document";+import { type Primaries, primariesIndex } from "@/core/image";import { node } from "@/core/renderer";import shader from "./adjustments.wgsl";import { exposure } from "./exposure";import { defaultAdjustments } from "./model";-/** Exposure alone takes the lighter pass; the full shader runs under its own name once another value moves. */-export function adjustments(values: Adjustments, name = "layer") {- const exposureOnly = Object.entries(values).every(+/** Whether exposure is the only value moved from its default, which the lighter exposure pass covers. */+export function isExposureOnly(values: Adjustments) {+ return Object.entries(values).every(([key, value]) =>key === "exposure" || value === Reflect.get(defaultAdjustments, key),);- if (exposureOnly) {- return exposure(`${name}/exposure`, values.exposure);+}++/**+ * Exposure alone takes the lighter pass; the full shader runs under its own name once another value+ * moves. Either converts an input in other `primaries` into the working space, so an 8-bit source+ * costs no pass of its own.+ */+export function adjustments(+ values: Adjustments,+ name = "layer",+ primaries: Primaries = "rec2020",+) {+ if (isExposureOnly(values)) {+ return exposure(`${name}/exposure`, values.exposure, primaries);}return node(`${name}/adjustments`, shader, {- set: { adjustments: values },+ format: "rgba16float",+ set: {+ adjustments: { primaries: primariesIndex[primaries], ...values },+ },samplers: { sourceSampler: { minFilter: "linear", magFilter: "linear" } },});}diff --git a/src/features/adjustments/prepare.wgsl b/src/features/adjustments/prepare.wgslindex de93cb2..3bc27e5 100644--- a/src/features/adjustments/prepare.wgsl+++ b/src/features/adjustments/prepare.wgsl@@ -1,4 +1,8 @@+import { toWorking } from "../../core/image/color.wgsl";+export struct Adjustments {+ // The primaries the input is in, as toWorking numbers them: the image layer's pass converts an 8-bit source.+ primaries: u32,exposure: f32,incrementalTemperature: f32,incrementalTint: f32,@@ -27,6 +31,7 @@ fn adjustWhiteBalance(color: vec3f, temperature: f32, tint: f32) -> vec3f {}export fn prepareColor(color: vec3f, adjustments: Adjustments) -> vec3f {- return adjustWhiteBalance(adjustExposure(color, adjustments.exposure),+ let working = toWorking(color, adjustments.primaries);+ return adjustWhiteBalance(adjustExposure(working, adjustments.exposure),adjustments.incrementalTemperature / 100.0, adjustments.incrementalTint / 100.0);}diff --git a/src/features/heal/overlay.tsx b/src/features/heal/overlay.tsxindex 83b0799..f5c3728 100644--- a/src/features/heal/overlay.tsx+++ b/src/features/heal/overlay.tsx@@ -101,7 +101,13 @@ export function HealOverlay({const scene = document.scene.getState();const patch = findHealPatch(scene, current.layer, current.patch);if (!patch) return;- await renderer.update(scene, current.patch, true);+ await renderer.update(+ scene,+ current.patch,+ true,+ undefined,+ document.preview.getState().density,+ );if (signal.aborted) return;const image = renderer.inputImage(current.patch);if (!image) throw Error("Heal input is unavailable.");diff --git a/src/features/heal/source.ts b/src/features/heal/source.tsindex 3aca6ec..b12edcc 100644--- a/src/features/heal/source.ts+++ b/src/features/heal/source.ts@@ -106,18 +106,21 @@ export function createHealSearch(gpu: Gpu) {Math.max(1, Math.round(image.size[0] * ratio)),Math.max(1, Math.round(image.size[1] * ratio)),];- const [thumbnail] = graph.render([- merge(- { source: input(image) },- node("heal/search-thumbnail", shader, {- size,- set: { params: { size } },- samplers: {- linearSampler: { minFilter: "linear", magFilter: "linear" },- },- }),- ),- ]);+ const [thumbnail] = graph.render(+ [+ merge(+ { source: input(image) },+ node("heal/search-thumbnail", shader, {+ size,+ set: { params: { size } },+ samplers: {+ linearSampler: { minFilter: "linear", magFilter: "linear" },+ },+ }),+ ),+ ],+ { set: 1, kept: [] },+ );return matchSource(await thumbnail.readFloats(),size,diff --git a/src/features/histogram/histogram.ts b/src/features/histogram/histogram.tsindex f764c5c..531d91d 100644--- a/src/features/histogram/histogram.ts+++ b/src/features/histogram/histogram.ts@@ -9,6 +9,9 @@ type Passes = {/** `GPUMapMode.READ`, which the page's WebGPU types leave out. */const mapRead = 1;+/** The grid of texels the histogram counts, whatever the image's size: one vote per grid point, 16 × 16 per workgroup, and the size of a curve's input, so its texels are the votes. */+export const histogramGrid: readonly [number, number] = [512, 320];+/** The counting passes, compiled once per GPU and shared, since a histogram mounts with each curve shown. */const shared = new WeakMap<Gpu, Passes>();@@ -54,10 +57,12 @@ export function createHistogram(gpu: Gpu) {if (!source) {return undefined;}- const params = { working: Number(working), channels };+ const params = { working: Number(working), channels, grid: histogramGrid };const bytes = channels * 1024;bins.write(empty);- count.set({ source: source.color, bins, params }).dispatch(32, 20);+ count+ .set({ source: source.color, bins, params })+ .dispatch(histogramGrid[0] / 16, histogramGrid[1] / 16);finish.set({ bins, heights, params }).dispatch(1);const encoder = gpu.gpu.createCommandEncoder();encoder.copyBufferToBuffer(heights.gpu, 0, staging.gpu, 0, bytes);diff --git a/src/features/histogram/histogram.wgsl b/src/features/histogram/histogram.wgslindex f450de5..681e08e 100644--- a/src/features/histogram/histogram.wgsl+++ b/src/features/histogram/histogram.wgsl@@ -4,6 +4,8 @@ import { linearToSrgb3 } from "@vgpu/wgsl-std/color";struct Params {working: u32,channels: u32,+ // The grid of texels counted, one vote each, whatever the image's size.+ grid: vec2u,}@group(0) @binding(0) var source: texture_2d<f32>;@@ -11,7 +13,6 @@ struct Params {@group(0) @binding(2) var<uniform> params: Params;@group(0) @binding(3) var<storage, read_write> heights: array<f32>;-const samples = vec2u(512, 320);// Soft-binning weight spread across a bin pair; kept as a fixed-point scale so atomics stay integer.const weight = 1024u;@@ -27,10 +28,10 @@ fn softBin(channel: u32, position: f32, vote: u32) {// 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)) {+ if (any(id.xy >= params.grid)) {return;}- let texel = textureLoad(source, id.xy * textureDimensions(source) / samples, 0);+ let texel = textureLoad(source, id.xy * textureDimensions(source) / params.grid, 0);let vote = u32(round(clamp(texel.a, 0.0, 1.0) * f32(weight)));if (vote == 0u) {return;diff --git a/src/features/layers/gradient-guides.tsx b/src/features/layers/gradient-guides.tsxindex 31d626a..6b21a77 100644--- a/src/features/layers/gradient-guides.tsx+++ b/src/features/layers/gradient-guides.tsx@@ -208,7 +208,7 @@ function RadialGuides({stroke="none"data-gradient-handle="move"aria-label="Move radial gradient"- className="pointer-events-auto cursor-grab hover:fill-hover"+ className="pointer-events-auto cursor-grab"/><MappedShapeshape={edge}diff --git a/src/features/layers/thumbnails.tsx b/src/features/layers/thumbnails.tsxindex 8c3a451..c36bf10 100644--- a/src/features/layers/thumbnails.tsx+++ b/src/features/layers/thumbnails.tsx@@ -29,7 +29,12 @@ export function ImageThumbnail() {let active = true;async function draw() {try {- const bitmap = await renderBitmap(gpu, source.image, [64, 64]);+ const bitmap = await renderBitmap(+ gpu,+ source.image,+ [64, 64],+ source.primaries,+ );const context = canvas.current?.getContext("2d");if (active && !context) {throw Error("Cannot draw image thumbnail.");diff --git a/src/features/tone-curves/curves.wgsl b/src/features/tone-curves/curves.wgslindex 113650c..55206a7 100644--- a/src/features/tone-curves/curves.wgsl+++ b/src/features/tone-curves/curves.wgsl@@ -1,31 +1,12 @@-import { linearToSrgb, srgbToLinear } from "@vgpu/wgsl-std/color";+import { tone, toneSamples } from "./tone.wgsl";@group(0) @binding(0) var source: texture_2d<f32>;@group(0) @binding(1) var<storage, read> curve: array<f32>;-// The graph uses sRGB transfer; input and output remain linear working RGB.-// Headroom above 1.0 rides on the curve's white endpoint.-fn lookup(linear: f32) -> f32 {- let last = arrayLength(&curve) - 1u;- let bounded = clamp(linear, 0.0, 1.0);- let position = linearToSrgb(bounded) * f32(last);- let lo = u32(position);- return srgbToLinear(mix(curve[lo], curve[min(lo + 1u, last)], fract(position))) + max(linear - 1.0, 0.0);-}--// Film-like tone mapping: interpolate the middle channel between mapped extremes in linear RGB.-fn tone(color: vec3f) -> vec3f {- let low = min(color.r, min(color.g, color.b));- let high = max(color.r, max(color.g, color.b));- let mappedLow = lookup(low);- if (high == low) {- return vec3f(mappedLow);- }- let mappedHigh = lookup(high);- return vec3f(mappedLow) + (color - low) * (mappedHigh - mappedLow) / (high - low);-}-@fragment fn fs_main(@builtin(position) position: vec4f) -> @location(0) vec4f {let input = textureLoad(source, vec2i(position.xy), 0);- return vec4f(tone(input.rgb), input.a);+ let size = arrayLength(&curve);+ let at = toneSamples(input.rgb, size);+ let samples = vec4f(curve[at.x], curve[at.y], curve[at.z], curve[at.w]);+ return vec4f(tone(input.rgb, samples, size), input.a);}diff --git a/src/features/tone-curves/pass.ts b/src/features/tone-curves/pass.tsindex 20e9586..512c89d 100644--- a/src/features/tone-curves/pass.ts+++ b/src/features/tone-curves/pass.ts@@ -3,11 +3,18 @@ import { node } from "@/core/renderer";import { sampleCurve } from "./curve";import shader from "./curves.wgsl";-export function toneCurves(points: ToneCurve, name = "curves") {+/** The table the curve shaders read, or none for an identity curve, which changes nothing. */+export function curveTable(points: ToneCurve) {if (points.every((point) => point.x === point.y)) {return;}- return node(name, shader, {- storage: { curve: sampleCurve(points, 1024) },- });+ return sampleCurve(points, 1024);+}++export function toneCurves(points: ToneCurve, name = "curves") {+ const curve = curveTable(points);+ if (!curve) {+ return;+ }+ return node(name, shader, { storage: { curve } });}diff --git a/src/features/tone-curves/tone.wgsl b/src/features/tone-curves/tone.wgslnew file mode 100644index 0000000..1d3ab8b--- /dev/null+++ b/src/features/tone-curves/tone.wgsl@@ -0,0 +1,37 @@+import { linearToSrgb, srgbToLinear } from "@vgpu/wgsl-std/color";++// A curve is a table of `size` samples over sRGB-encoded 0..1; input and output remain linear working RGB.+// A module cannot declare the table's binding, so each shader reads the entries `toneSamples` names.++fn position(linear: f32, size: u32) -> f32 {+ return linearToSrgb(clamp(linear, 0.0, 1.0)) * f32(size - 1u);+}++fn neighbors(linear: f32, size: u32) -> vec2u {+ let low = u32(position(linear, size));+ return vec2u(low, min(low + 1u, size - 1u));+}++// Headroom above 1.0 rides on the curve's white endpoint.+fn lookup(linear: f32, samples: vec2f, size: u32) -> f32 {+ return srgbToLinear(mix(samples.x, samples.y, fract(position(linear, size)))) + max(linear - 1.0, 0.0);+}++// The entries `tone` reads: two around the color's lowest channel, then two around its highest.+export fn toneSamples(color: vec3f, size: u32) -> vec4u {+ let low = min(color.r, min(color.g, color.b));+ let high = max(color.r, max(color.g, color.b));+ return vec4u(neighbors(low, size), neighbors(high, size));+}++// Film-like tone mapping: interpolate the middle channel between mapped extremes in linear RGB.+export fn tone(color: vec3f, samples: vec4f, size: u32) -> vec3f {+ let low = min(color.r, min(color.g, color.b));+ let high = max(color.r, max(color.g, color.b));+ let mappedLow = lookup(low, samples.xy, size);+ if (high == low) {+ return vec3f(mappedLow);+ }+ let mappedHigh = lookup(high, samples.zw, size);+ return vec3f(mappedLow) + (color - low) * (mappedHigh - mappedLow) / (high - low);+}diff --git a/src/features/white-balance/auto.ts b/src/features/white-balance/auto.tsindex 661c5cc..f222660 100644--- a/src/features/white-balance/auto.ts+++ b/src/features/white-balance/auto.ts@@ -42,7 +42,7 @@ function moved([r, g, b]: Rgb, level: Rgb) {export async function autoWhiteBalance(document: EditorDocument, gpu: Gpu) {const image = document.scene.getState().layers[0];const source = document.resources.get(image.source);- const light = await measureLight(gpu, source.image);+ const light = await measureLight(gpu, source);if (!light || document.closed) {return;}diff --git a/src/features/white-balance/cast.ts b/src/features/white-balance/cast.tsindex cf99f51..0e140ff 100644--- a/src/features/white-balance/cast.ts+++ b/src/features/white-balance/cast.ts@@ -1,4 +1,5 @@-import { compute, type Gpu, type Target } from "vgpu";+import { compute, type Gpu } from "vgpu";+import { type EncodedImage, primariesIndex } from "@/core/image";import { weakMemo } from "@/lib/weak-memo";import shader from "./cast.wgsl";@@ -15,16 +16,21 @@ const measure = weakMemo((gpu: Gpu) =>);/**- * Reduces `image` on the GPU to the light's color in stops and each channel's level where the edges- * are; nothing for an image without usable pixels.+ * Reduces the source on the GPU to the light's color in stops and each channel's level where the+ * edges are, in the working space; nothing for an image without usable pixels.*/-export async function measureLight(gpu: Gpu, image: Target) {+export async function measureLight(+ gpu: Gpu,+ { image, primaries }: EncodedImage,+) {const light = gpu.device.createBuffer({size: 32,usage: ["storage", "copy_src"],});try {- measure(gpu).set({ source: image.color, light }).dispatch(1);+ measure(gpu)+ .set({ source: image.color, primaries: primariesIndex[primaries], light })+ .dispatch(1);const [r, g, b, , lr, lg, lb] = new Float32Array(await light.read(32));const stops: Rgb = [r, g, b];const level: Rgb = [lr, lg, lb];diff --git a/src/features/white-balance/cast.wgsl b/src/features/white-balance/cast.wgslindex eb59e61..5e84c2e 100644--- a/src/features/white-balance/cast.wgsl+++ b/src/features/white-balance/cast.wgsl@@ -1,4 +1,4 @@-import { luminance } from "../../core/image/color.wgsl";+import { luminance, toWorking } from "../../core/image/color.wgsl";// Gray edge (van de Weijer, Gevers, and Gijsenij, 2007): differences between neighboring surfaces// average to the light's color, so a large colored area counts only at its edges. One workgroup walks@@ -16,7 +16,9 @@ struct Light {}@group(0) @binding(0) var source: texture_2d<f32>;-@group(0) @binding(1) var<storage, read_write> light: Light;+// The primaries the source's texels are in, as toWorking numbers them.+@group(0) @binding(1) var<uniform> primaries: u32;+@group(0) @binding(2) var<storage, read_write> light: Light;var<workgroup> edges: array<vec3f, threads>;var<workgroup> levels: array<vec3f, threads>;@@ -24,7 +26,8 @@ var<workgroup> levels: array<vec3f, threads>;var<workgroup> colors: array<vec4f, threads>;fn sample(point: vec2u) -> vec4f {- return textureLoad(source, point * textureDimensions(source) / samples, 0);+ let texel = textureLoad(source, point * textureDimensions(source) / samples, 0);+ return vec4f(toWorking(texel.rgb, primaries), texel.a);}// Opaque, bright enough that noise doesn't decide its color, and short of highlights, which clip ordiff --git a/tests/brush.test.ts b/tests/brush.test.tsindex faf5d58..f4ac353 100644--- a/tests/brush.test.ts+++ b/tests/brush.test.ts@@ -90,8 +90,14 @@ test("brush strokes stamp incrementally, replay after undo, and render a proxy dconst renderer = createEditorRenderer(gpu, source);const notify = mock(() => {});renderer.subscribe(notify);- const render = (inputId?: string, interactive = false) =>- renderer.update(document.scene.getState(), inputId, interactive);+ const render = (inputId?: string, interactive = false, density = 1) =>+ renderer.update(+ document.scene.getState(),+ inputId,+ interactive,+ undefined,+ density,+ );const inspect = () => renderer.inspect();const mask = addLayer(document, createMask({ kind: "brush", strokes: [] }));setAdjustments(document, { exposure: 1 }, mask);@@ -102,7 +108,7 @@ test("brush strokes stamp incrementally, replay after undo, and render a proxy dpaintStroke(document, mask, stroke);await render(undefined, true);expect(inspect()).toMatchObject({- passes: [`layer/${mask}/exposure`, `layer/${mask}/raster`],+ passes: [`layer/${mask}/mask-raster`],stamped: 1,// The open stroke waits in the stroke buffer, and the mask reads it laid over its raster in the view.rasters: [@@ -117,11 +123,11 @@ test("brush strokes stamp incrementally, replay after undo, and render a proxy dawait render(undefined, true);expect(inspect().stamped).toBe(21);// A quarter of a device pixel per source pixel means a quarter-size render.- renderer.setDisplayScale(0.25);- await render(undefined, true);+ await render(undefined, true, 0.25);expect(renderer.outputImage().size).toEqual([16, 8]);expect(inspect().stamped).toBe(21);document.history.commit();+ // The view shows every source pixel again, so the render returns to full size.await render();const rendered = notify.mock.calls.length;await render();@@ -152,8 +158,7 @@ test("brush strokes stamp incrementally, replay after undo, and render a proxy dawait render(gradient);expect(renderer.inputImage(gradient)).toBeDefined();expect(inspect().passes).toEqual([- `layer/${mask}/exposure`,- `layer/${mask}/raster`,+ `layer/${mask}/mask-raster`,`layer/${gradient}/exposure`,`layer/${gradient}/input`,]);@@ -165,8 +170,8 @@ test("brush strokes stamp incrementally, replay after undo, and render a proxy d{ inside: gradient },);await render();- expect(inspect().passes).toContain(`layer/${gradient}/raster`);- expect(inspect().passes).not.toContain(`layer/${gradient}/mix`);+ expect(inspect().passes).toContain(`layer/${gradient}/mask-raster`);+ expect(inspect().passes).not.toContain(`layer/${gradient}/mask`);await render(gradient);expect(inspect().passes).toContain(`layer/${gradient}/raster-input`);// The child keeps its own coverage for its preview; the graph folds it into the gradient's.@@ -201,7 +206,9 @@ test("brush strokes stamp incrementally, replay after undo, and render a proxy dawait render();expect(renderer.coverage(gradient)?.target.size).toEqual([32, 16]);expect(renderer.inspect().passes).toContain(`mask/${child}/combine`);- expect(renderer.inspect().passes).not.toContain(`layer/${gradient}/raster`);+ expect(renderer.inspect().passes).not.toContain(+ `layer/${gradient}/mask-raster`,+ );setLayer(document, gradient, { visible: true });// Erasing inside the child stamps its own raster only, and the group recombines.const stamped = inspect().stamped;@@ -212,7 +219,7 @@ test("brush strokes stamp incrementally, replay after undo, and render a proxy ddeleteLayer(document, mask);await render();expect(inspect().rasters).toEqual([]);- expect(inspect().passes).toContain(`layer/${gradient}/mix`);+ expect(inspect().passes).toContain(`layer/${gradient}/mask`);const invalid = { ...stroke, flow: 2 };expect(() =>setLayerMask(document, gradient, { kind: "brush", strokes: [invalid] }),@@ -262,7 +269,7 @@ test("a brush yet to paint takes no part in its group", async () => {expect.arrayContaining([`mask/${brush}/empty`,`mask/${gradient}/combine`,- `layer/${brush}/raster`,+ `layer/${brush}/mask-raster`,]),);// Intersecting a gradient, it leaves the gradient whole until it paints.@@ -273,13 +280,13 @@ test("a brush yet to paint takes no part in its group", async () => {createMask({ kind: "brush", strokes: [] }, "intersect"),{ inside: shaped },);- expect(await passes()).toContain(`layer/${shaped}/mix`);+ expect(await passes()).toContain(`layer/${shaped}/mask`);paintStroke(document, child, stroke);expect(await passes()).toEqual(expect.arrayContaining([`mask/${shaped}/gradient`,`mask/${child}/combine`,- `layer/${shaped}/raster`,+ `layer/${shaped}/mask-raster`,]),);const effect = addLayer(document, createLayer("exposure"));diff --git a/tests/color-mixer-gpu.ts b/tests/color-mixer-gpu.tsindex ab64e63..0e1e6e1 100644--- a/tests/color-mixer-gpu.ts+++ b/tests/color-mixer-gpu.ts@@ -90,9 +90,10 @@ export async function probeColorMixer() {mix("saturation", -100, 5),mix("hue", 100, 0),]) {- const [output] = graph.render([- pipeline(inputNode(input), [colorMixer(settings, "color-mixer")]),- ]);+ const [output] = graph.render(+ [pipeline(inputNode(input), [colorMixer(settings, "color-mixer")])],+ { set: 1, kept: [] },+ );outputs.push([...(await output.readFloats())]);}return { original, outputs, sampleCount: samples.length };diff --git a/tests/export.test.ts b/tests/export.test.tsnew file mode 100644index 0000000..33620ad--- /dev/null+++ b/tests/export.test.ts@@ -0,0 +1,37 @@+import { expect, test } from "bun:test";+import { init, target } from "vgpu/mock";+import { createExportSession } from "@/app/editor/export/export-image";+import { createImageLayer } from "@/app/editor/layers";+import { createDocument, createResources } from "@/core/document";+import { createImageSource } from "@/core/image";+import { imageFrame } from "@/core/image/frame";+import { setAdjustments } from "@/features/adjustments/edits";++test("an export session renders each refresh in order, encodes nothing before the first, and holds nothing once disposed", async () => {+ const gpu = await init();+ const image = target(gpu, { size: [32, 16], format: "rgba16float" });+ const source = createImageSource(image);+ const resources = createResources();+ const id = resources.add(new File([], "photo.png"), source);+ const document = createDocument(+ { frame: imageFrame(image.size), layers: [createImageLayer(id, "Photo")] },+ resources,+ );+ const session = createExportSession(gpu, document);+ const outcomes: (string | undefined)[] = [];+ session.subscribe((failure) => outcomes.push(failure));+ try {+ await expect(session.encode({})).rejects.toThrow("still rendering");+ await session.refresh();+ setAdjustments(document, { exposure: 1 });+ await Promise.all([session.refresh(), session.refresh()]);+ expect(outcomes).toEqual([undefined, undefined, undefined]);+ session.dispose();+ await session.refresh();+ expect(outcomes).toHaveLength(3);+ await expect(session.encode({})).rejects.toThrow("still rendering");+ } finally {+ document.dispose();+ gpu.dispose();+ }+});diff --git a/tests/gpu-stats.e2e.ts b/tests/gpu-stats.e2e.tsindex 8a136de..e80dd7a 100644--- a/tests/gpu-stats.e2e.ts+++ b/tests/gpu-stats.e2e.ts@@ -17,9 +17,14 @@ test("?stats counts the GPU's textures and buffers, and Reset starts a workflowawait expect(value("GPU")).toHaveText(/^\d+\.\d MB · peak/);await stats.getByRole("button", { name: "Reset" }).click();await expect(value("Textures")).toHaveText(/ · 0 made · 0 freed/);- // A new adjustment pass renders into a texture of its own.- await exposure.fill("1");- await exposure.press("Enter");+ // A tone curve adds a pass, which renders into a texture of its own.+ await page.evaluate(() =>+ window.openlight.setToneCurve([+ { x: 0, y: 0 },+ { x: 0.5, y: 0.6 },+ { x: 1, y: 1 },+ ]),+ );await expect(value("Textures")).toHaveText(/ · [1-9]\d* made/);// Changing values only rewrites uniforms: every render, histograms included, reuses what it has.await stats.getByRole("button", { name: "Reset" }).click();diff --git a/tests/heal-gpu.ts b/tests/heal-gpu.tsindex 8415dee..8986d51 100644--- a/tests/heal-gpu.ts+++ b/tests/heal-gpu.ts@@ -76,8 +76,7 @@ export async function renderHealReference({],};for (const proxy of [false, true]) {- renderer.setDisplayScale(0.25);- await renderer.update(renderScene, "spot", proxy);+ await renderer.update(renderScene, "spot", proxy, undefined, 0.25);const output = renderer.fullImage();const pixels = await output.readFloats();const input = renderer.inputImage("spot");diff --git a/tests/heal.test.ts b/tests/heal.test.tsindex 1a3869b..b7362b0 100644--- a/tests/heal.test.ts+++ b/tests/heal.test.ts@@ -58,14 +58,17 @@ test("Remove passes never overwrite distinct uniforms before their frame submitsconst uploads = spyOn(gpu.gpu.queue, "writeBuffer");const lattice = { origin: [0, 0], scale: 1, size: source.size } as const;try {- graph.render([- inpaintField(- input(source),- { coverage: input(coverage), origin: [0, 0] },- lattice,- "remove",- ),- ]);+ graph.render(+ [+ inpaintField(+ input(source),+ { coverage: input(coverage), origin: [0, 0] },+ lattice,+ "remove",+ ),+ ],+ { set: 1, kept: [] },+ );const uniforms = new Map<GPUBuffer, Uint8Array>();for (const [buffer, , data] of uploads.mock.calls) {const bytes = ArrayBuffer.isView(data)@@ -202,8 +205,14 @@ test("a nested Remove synthesizes once for its strokes, whatever changes below o...dab,points: [[64, 48, 1]],});- const render = (interactive = false) =>- renderer.update(document.scene.getState(), undefined, interactive);+ const render = (interactive = false, density = 1) =>+ renderer.update(+ document.scene.getState(),+ undefined,+ interactive,+ undefined,+ density,+ );const solves = () =>renderer.inspect().passes.some((name) => name.includes("/inpaint/"));const fields = () =>@@ -241,8 +250,7 @@ test("a nested Remove synthesizes once for its strokes, whatever changes below osetAdjustments(document, { exposure: 1 }, mask);await render();expect(solves()).toBe(false);- renderer.setDisplayScale(0.5);- await render(true);+ await render(true, 0.5);expect(solves()).toBe(false);for (const mode of ["paint", "erase"] as const) {const before = own();@@ -255,8 +263,8 @@ test("a nested Remove synthesizes once for its strokes, whatever changes below o// A new stroke takes a new field, to synthesize for the whole new shape.expect(own()).not.toBe(before);expect(document.resources.field(own())).toBeUndefined();- // A proxy keeps the field it holds; only full resolution synthesizes the new stroke.- await render(true);+ // A gesture's proxy shows the new stroke unfilled; its end synthesizes it in full.+ await render(true, 0.5);expect(solves()).toBe(false);await render();expect(solves()).toBe(true);@@ -289,6 +297,63 @@ test("a nested Remove synthesizes once for its strokes, whatever changes below o}});+test("renders follow the display's density, except that a proxy lacking a Remove patch's field renders in full once", async () => {+ const gpu = await init();+ const source = createImageSource(+ target(gpu, { size: [128, 96], format: "rgba16float" }),+ );+ const { document } = healFixture([128, 96]);+ const renderer = createEditorRenderer(gpu, source, {+ field: (id) => document.resources.field(id),+ });+ const render = (interactive = false, density = 0.5) =>+ renderer.update(+ document.scene.getState(),+ undefined,+ interactive,+ undefined,+ density,+ );+ const size = () => renderer.outputImage().size;+ const fields = () =>+ renderer.inspect().rasters.filter(({ id }) => id.endsWith("/field"));+ try {+ await render();+ expect(size()).toEqual([64, 48]);+ const layer = addLayer(document, createLayer("heal"));+ addRemovePatch(document, layer, { ...dab, points: [[64, 48, 1]] });+ // A gesture shows the patch unfilled; its end synthesizes the field in full apart, and shows the proxy.+ await render(true);+ expect(size()).toEqual([64, 48]);+ expect(fields()).toHaveLength(0);+ await render();+ expect(size()).toEqual([64, 48]);+ expect(fields()).toHaveLength(1);+ expect(renderer.inspect().passes).toContain(+ `layer/${layer}/${patchesOf(document, layer)[0].id}/blend`,+ );+ // The full-size textures the synthesis used go with the proxy's render; the proxy's stay.+ expect(renderer.inspect().textures.every(({ size }) => size[0] <= 64)).toBe(+ true,+ );+ setAdjustments(document, { exposure: 1 });+ await render();+ expect(size()).toEqual([64, 48]);+ // A finer display renders in full; returning to a reduction already rendered allocates nothing,+ // since its proxy and intermediates stayed.+ await render(false, 1);+ expect(size()).toEqual([128, 96]);+ const made = spyOn(gpu.gpu, "createTexture");+ await render(false, 0.5);+ expect(size()).toEqual([64, 48]);+ expect(made).not.toHaveBeenCalled();+ } finally {+ renderer.dispose();+ document.dispose();+ gpu.dispose();+ }+});+test("a snapshot taken while a Remove field is read back keeps it once its photo closes", async () => {const gpu = await init();const source = createImageSource(@@ -387,18 +452,18 @@ test("heal patches reuse brush rasters, scale with the proxy, undo, and releasecreated?.kind === "heal" &&created.patches.find((item) => item.id === patch),).toMatchObject({ feather: 0.4, strokes: [{ size: 30, feather: 0 }] });- renderer.setDisplayScale(0.25);- await renderer.update(document.scene.getState(), id, true);+ await renderer.update(document.scene.getState(), id, true, undefined, 0.25);expect(renderer.fullImage().size).toEqual([64, 48]);expect(renderer.inspect().rasters).toEqual([{ id: `layer/${id}/${patch}`, size: [256, 192], format: "r8unorm" },]);const stamped = renderer.inspect().stamped;extendHealPatch(document, id, [[120, 80, 1]]);- await renderer.update(document.scene.getState(), id, true);+ await renderer.update(document.scene.getState(), id, true, undefined, 0.25);expect(renderer.inspect().stamped).toBeGreaterThan(stamped);const extended = renderer.inspect().stamped;document.history.commit();+ // The view shows every source pixel again, so the render returns to full size.await renderer.update(document.scene.getState());expect(renderer.fullImage().size).toEqual([256, 192]);expect(renderer.inspect().stamped).toBe(extended);diff --git a/tests/inpaint-benchmark.ts b/tests/inpaint-benchmark.tsindex 208dc5c..f4a516b 100644--- a/tests/inpaint-benchmark.ts+++ b/tests/inpaint-benchmark.ts@@ -91,14 +91,17 @@ export async function benchmarkInpaint(async render(index: number) {const stroke = strokeAt(index);const coverage = raster.patch("spot", [stroke], size);- graph.render([- inpaint(- input(image),- coverage,- patchBounds([stroke], size, 240),- "inpaint",- ),- ]);+ graph.render(+ [+ inpaint(+ input(image),+ coverage,+ patchBounds([stroke], size, 240),+ "inpaint",+ ),+ ],+ { set: 1, kept: [] },+ );},inspect: graph.inspect,dispose() {diff --git a/tests/inpaint-gpu.ts b/tests/inpaint-gpu.tsindex 7e5c594..bea8264 100644--- a/tests/inpaint-gpu.ts+++ b/tests/inpaint-gpu.ts@@ -84,14 +84,14 @@ export async function renderInpaintReference(f.pass(clean, shader(false));});await gpu.gpu.queue.onSubmittedWorkDone();- renderer.setDisplayScale(0.5);+ const density = proxy ? 0.5 : 1;const start = performance.now();- // Only full resolution synthesizes; a proxy then shows the field it keeps.- await renderer.update(scene);+ // A patch waiting for its field synthesizes in full whatever the display; a proxy then shows the field it keeps.+ await renderer.update(scene, undefined, false, undefined, density);await gpu.gpu.queue.onSubmittedWorkDone();const completedMs = performance.now() - start;const solved = renderer.inspect();- await renderer.update(scene, undefined, proxy);+ await renderer.update(scene, undefined, proxy, undefined, density);const result = renderer.fullImage();const actual = await result.readFloats();const before = await image.readFloats();@@ -137,12 +137,14 @@ export async function renderInpaintReference({ ...scene, layers: [scene.layers[0], { ...healing, visible: false }] },undefined,proxy,+ undefined,+ density,);const fields = () =>renderer.inspect().rasters.filter(({ id }) => id.endsWith("/field")).length;const hiddenFields = fields();- await renderer.update(scene, undefined, proxy);+ await renderer.update(scene, undefined, proxy, undefined, density);const shown = renderer.inspect();const visible = await renderer.fullImage().readFloats();const visibilityError = visible.reduce(@@ -160,6 +162,8 @@ export async function renderInpaintReference(},undefined,proxy,+ undefined,+ density,);const cached = renderer.inspect();await renderer.update(@@ -175,6 +179,8 @@ export async function renderInpaintReference(},undefined,proxy,+ undefined,+ density,);const exposed = renderer.inspect();// The patch keeps its donors, whose colors follow the exposure below it.@@ -206,8 +212,10 @@ export async function renderInpaintReference(},undefined,proxy,+ undefined,+ density,);- await renderer.update(scene, undefined, proxy);+ await renderer.update(scene, undefined, proxy, undefined, density);const restored = await renderer.fullImage().readFloats();const restoredError = restored.reduce((maximum, value, index) =>diff --git a/tests/perspective-gpu.ts b/tests/perspective-gpu.tsindex 7f96b92..d31b2d2 100644--- a/tests/perspective-gpu.ts+++ b/tests/perspective-gpu.ts@@ -37,8 +37,7 @@ export async function perspectiveProxy() {try {await renderer.update(scene);const full = await renderer.outputImage().readFloats();- renderer.setDisplayScale(0.5);- await renderer.update({ ...scene }, undefined, true);+ await renderer.update({ ...scene }, undefined, true, undefined, 0.5);const reduced = renderer.outputImage();const proxy = await reduced.readFloats();let stray = 0;diff --git a/tests/render-graph.test.ts b/tests/render-graph.test.tsindex 780e33e..a8acb7e 100644--- a/tests/render-graph.test.ts+++ b/tests/render-graph.test.ts@@ -2,6 +2,7 @@ import { expect, spyOn, test } from "bun:test";import { getMockGPUDeviceInstrumentation, init, target } from "vgpu/mock";import {createRenderGraph,+ curveInput,input,merge,node,@@ -72,7 +73,7 @@ test("a shared branch renders once and reuses effects, buffers, and temporary stnode("join", shader, options),);const uploads = spyOn(gpu.gpu.queue, "writeBuffer");- const [saved, output] = graph.render([shared, joined]);+ const [saved, output] = graph.render([shared, joined], { set: 1, kept: [] });expect(output).not.toBe(saved);expect(uploads).toHaveBeenCalledTimes(4);expect(graph.inspect().passes).toEqual([@@ -85,7 +86,7 @@ test("a shared branch renders once and reuses effects, buffers, and temporary stconst calls = getMockGPUDeviceInstrumentation(gpu.gpu).calls;const buffers = calls.createBuffer;const pipelines = calls.createRenderPipeline;- expect(graph.render([joined, shared, joined])).toEqual([+ expect(graph.render([joined, shared, joined], { set: 1, kept: [] })).toEqual([output,saved,output,@@ -95,37 +96,65 @@ test("a shared branch renders once and reuses effects, buffers, and temporary st// A storage array uploads once while passes keep receiving it.expect(uploads).toHaveBeenCalledTimes(4);// Bypassing releases scratch storage.- expect(graph.render([shared])[0]).toBe(saved);+ expect(graph.render([shared], { set: 1, kept: [] })[0]).toBe(saved);expect(graph.inspect().textures).toHaveLength(1);expect(() => output.color.view).toThrow("destroyed");- // A proxy size and the full size alternate without reallocating; a third size lets the oldest go.+ // Kept reductions keep their targets whichever way the zoom goes; a reduction not kept, the+ // photo's own size, goes once another renders, and a reduction's new sizes replace its old ones.const sized = (size: number) =>mixed(source, "shared", { size: [size, size] });- const [proxy] = graph.render([sized(4)]);+ const [proxy] = graph.render([sized(4)], { set: 2, kept: [2] });expect(proxy.size).toEqual([4, 4]);- expect(graph.render([shared])[0]).toBe(saved);- expect(graph.render([sized(4)])[0]).toBe(proxy);- graph.render([sized(2)]);- expect(graph.inspect().textures).toHaveLength(2);expect(() => saved.color.view).toThrow("destroyed");+ const [small] = graph.render([sized(2)], { set: 4, kept: [4, 2] });+ expect(graph.render([sized(4)], { set: 2, kept: [2, 4] })[0]).toBe(proxy);+ const [full] = graph.render([shared], { set: 1, kept: [2, 4] });+ expect(graph.inspect().textures).toHaveLength(3);+ expect(graph.render([sized(2)], { set: 4, kept: [4, 2] })[0]).toBe(small);+ expect(() => full.color.view).toThrow("destroyed");+ const [cropped] = graph.render([sized(3)], { set: 2, kept: [2, 4] });+ expect(() => proxy.color.view).toThrow("destroyed");+ expect(graph.render([sized(2)], { set: 4, kept: [4] })[0]).toBe(small);+ expect(() => cropped.color.view).toThrow("destroyed");+ expect(graph.inspect().textures).toHaveLength(1);// Removing a composition retires its cached effect so its name can be reused.graph.release("shared");const replacement = merge({ source, base: source },node("shared", shader.replace("weights[0]", "1.0 - weights[0]"), options),);- expect(() => graph.render([replacement])).not.toThrow();+ expect(() => graph.render([replacement], { set: 1, kept: [] })).not.toThrow();// Passes with identical uniforms share one prepared binding state.const { effects } = graph.inspect();const first = mixed(source, "first", { instance: "twin" });- graph.render([mixed(first, "second", { instance: "twin" })]);+ graph.render([mixed(first, "second", { instance: "twin" })], {+ set: 1,+ kept: [],+ });expect(graph.inspect()).toMatchObject({passes: ["first", "second"],effects: effects + 1,});graph.dispose();expect(() => image.color.view).not.toThrow();- expect(() => graph.render([shared])).toThrow("closed");+ expect(() => graph.render([shared], { set: 1, kept: [] })).toThrow("closed");image.color.dispose();gpu.dispose();});++test("a curve's input is drawn on the histogram's grid, standing for the whole photo", async () => {+ const gpu = await init();+ const grid = [512, 320] as const;+ const image = input(+ target(gpu, { size: [2048, 1536], format: "rgba16float" }),+ );+ const whole = curveInput("layer", image, grid);+ expect(whole.size).toEqual([512, 320]);+ expect(whole.scale).toEqual([4, 4.8]);+ const coverage = input(target(gpu, { size: [1024, 768], format: "r8unorm" }));+ const painted = curveInput("mask", image, grid, undefined, [], coverage);+ expect(painted.size).toEqual([512, 320]);+ // A smaller photo fills the grid too, its texels repeated as the histogram repeats them.+ const small = input(target(gpu, { size: [300, 200], format: "rgba16float" }));+ expect(curveInput("small", small, grid).size).toEqual([512, 320]);+});diff --git a/tests/renderer.test.ts b/tests/renderer.test.tsindex 795ed17..9327cf9 100644--- a/tests/renderer.test.ts+++ b/tests/renderer.test.ts@@ -6,7 +6,7 @@ import {init,target,} from "vgpu/mock";-import { createImageLayer, createLayer } from "@/app/editor/layers";+import { createImageLayer, createLayer, createMask } from "@/app/editor/layers";import { createEditorRenderer as createRenderer } from "@/app/editor/renderer";import { createDocument, createResources } from "@/core/document";import { createImageSource } from "@/core/image";@@ -20,6 +20,8 @@ import {import { setAdjustments } from "@/features/adjustments/edits";import { defaultAdjustments } from "@/features/adjustments/model";import { unsharpMask } from "@/features/details/unsharp-mask";+import { addLayer } from "@/features/layers/edits";+import { defaultGradient } from "@/features/layers/gradient";import { setToneCurve } from "@/features/tone-curves/edits";import { setWhiteBalance } from "@/features/white-balance/edits";@@ -37,18 +39,20 @@ test("RAW edits coalesce, recover from failure, and retain an exporting source areturn requests[requests.length - 1].promise;});const source = createImageSource(image, {- asShot,- createPass() {- const output = target(gpu, { size: image.size, format: image.format });- outputs.push(output);- return {- prepare: ({ temperature }) =>- temperature === asShot.temperature ? Promise.resolve() : develop(),- render: () => output,- dispose: () => output.color.dispose(),- };+ raw: {+ asShot,+ createPass() {+ const output = target(gpu, { size: image.size, format: image.format });+ outputs.push(output);+ return {+ prepare: ({ temperature }) =>+ temperature === asShot.temperature ? Promise.resolve() : develop(),+ render: () => output,+ dispose: () => output.color.dispose(),+ };+ },+ dispose: close,},- dispose: close,});const resources = createResources();const id = resources.add(new File([], "photo.nef"), source);@@ -116,11 +120,14 @@ test.each([1, 16])(const calls = getMockGPUDeviceInstrumentation(gpu.gpu).calls;const radius = reduction === 1 ? 1 : 64;const render = (amount: number) =>- graph.render([- pipeline(input(source), [- unsharpMask("detail", amount / 200, radius, reduction),- ]),- ])[0];+ graph.render(+ [+ pipeline(input(source), [+ unsharpMask("detail", amount / 200, radius, reduction),+ ]),+ ],+ { set: 1, kept: [] },+ )[0];expect(render(0)).toBe(source);expect(calls.createRenderPipeline ?? 0).toBe(0);const filtered = render(100);@@ -206,7 +213,13 @@ test("rendering follows grouped edits and undo, reuses pipelines, and releases oawait renderer.update(document.scene.getState(), "base");expect(renderer.inputImage("base")).toBeDefined();expect(renderer.inputImage("base")).not.toBe(renderer.outputImage());- expect(passes()).toEqual([...curves, "layer/exposure/exposure"]);+ // The curve's input is planned first, so the image it reads is let go once the curve has read it.+ expect(passes()).toEqual([+ "layer/base/exposure",+ "layer/base/input",+ "layer/base/curves",+ "layer/exposure/exposure",+ ]);document.edit(beforeInput);expect(renderer.inputImage("base")).toBeUndefined();const scene = document.scene.getState();@@ -235,3 +248,48 @@ test("rendering follows grouped edits and undo, reuses pipelines, and releases odisplay.dispose();gpu.dispose();});++test("a mask without effects of its own adjusts, curves, and mixes in one pass unless inspected", async () => {+ const gpu = await init();+ const source = createImageSource(+ target(gpu, { size: [32, 16], format: "rgba16float" }),+ );+ const layers = [createImageLayer("photo", "Photo")] as const;+ const document = createDocument({ frame: imageFrame([32, 16]), layers });+ const renderer = createRenderer(gpu, source);+ const passes = async (inputId?: string) => {+ await renderer.update(document.scene.getState(), inputId);+ return renderer.inspect().passes;+ };+ const mask = addLayer(document, createMask(defaultGradient([32, 16])));+ expect(await passes()).toEqual([]);+ setAdjustments(document, { exposure: 1 }, mask);+ expect(await passes()).toEqual([`layer/${mask}/mask`]);+ const curve = [+ { x: 0, y: 0 },+ { x: 0.5, y: 0.7 },+ { x: 1, y: 1 },+ ];+ setToneCurve(document, curve, mask);+ expect(await passes()).toEqual([`layer/${mask}/mask`]);+ // Its curve's input reads the adjusted image, which only the separate passes render.+ expect(await passes(mask)).toEqual([+ `layer/${mask}/exposure`,+ `layer/${mask}/input`,+ `layer/${mask}/curves`,+ `layer/${mask}/mix`,+ ]);+ const vignette = addLayer(document, createLayer("vignette"), {+ inside: mask,+ });+ expect(await passes()).toEqual([+ `layer/${mask}/exposure`,+ `layer/${mask}/curves`,+ `layer/${vignette}/vignette`,+ `layer/${mask}/mix`,+ ]);+ renderer.dispose();+ document.dispose();+ source.dispose();+ gpu.dispose();+});diff --git a/tests/rendering-benchmark.ts b/tests/rendering-benchmark.tsindex ce14463..30a2180 100644--- a/tests/rendering-benchmark.ts+++ b/tests/rendering-benchmark.ts@@ -341,11 +341,10 @@ export async function benchmarkRendering(...effects,],};+ // Half a device pixel per source pixel, as a fitted view of a large photo, renders at a factor of 2.+ const density = proxy ? 0.5 : 1;function create(clock?: Timer) {- const renderer = createEditorRenderer(gpu, source, { timer: 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;+ return createEditorRenderer(gpu, source, { timer: clock });}const setupStart = performance.now();let renderer = create();@@ -358,7 +357,7 @@ export async function benchmarkRendering(for (let i = 0; i < warmup + samples; i++) {const start = performance.now();// A new scene object forces the render; the renderer skips a request equal to its last.- await renderer.update({ ...scene }, inputId, proxy);+ await renderer.update({ ...scene }, inputId, proxy, undefined, density);const inspected = inputId && renderer.inputImage(inputId);if (inputId && !inspected) {throw Error("Missing benchmark curve input.");@@ -411,7 +410,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, proxy);+ await renderer.update({ ...scene }, inputId, proxy, undefined, density);await gpu.gpu.queue.onSubmittedWorkDone();await gpu.settled();const firstRenderMs = performance.now() - start;diff --git a/tests/scene-file.test.ts b/tests/scene-file.test.tsindex 1a07167..93e9478 100644--- a/tests/scene-file.test.ts+++ b/tests/scene-file.test.ts@@ -32,7 +32,7 @@ test("scene files reopen the photo with every layer for further editing", asyncdispose() {},};const image = target(gpu, { size, format: "rgba16float" });- return Promise.resolve(createImageSource(image, raw));+ return Promise.resolve(createImageSource(image, { raw }));};const nef = new File([bytes], "photo.nef", { type: "image/x-nikon-nef" });const resources = createResources();