Skip to content

Free open-source image editor for the browser

Build a rendering core with composable nodes (#27)

Rodrigo Belfiore729b3aa44ce9
diff --git a/AGENTS.md b/AGENTS.md
index 025380d..f8db122 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -19,13 +19,13 @@ Write committed code, comments, documentation, and UI text in English. Use [CONT
| Layer | Owns |
| --- | --- |
| 0 — `lib/` | Low-level code independent of OpenLight: math and utilities that could be standalone libraries. Keep it here when maintaining the small implementation is cheaper than a dependency, or when it is a candidate for extraction. |
-| 1 — shared primitives | Infrastructure generic within OpenLight: engine contracts, document and resource management, reusable `components/` and `hooks/`. Engine code works without React; React bindings depend on it. |
+| 1 — shared primitives | `core/` owns document, image, and renderer infrastructure without React. Reusable `components/` and `hooks/` provide UI primitives and React bindings above it. |
| 2 — `features/` | Removable product capabilities. A feature owns its processing, shaders, parameters, commands, components, and hooks as needed. Most product behavior belongs here. |
| 3 — `app/` | Application shell, user entry points, and explicit composition of features and shared primitives. |
Dependencies between layers point downward. Features do not import each other; `app/` connects them. Shared primitives must not import concrete features. Being reusable within OpenLight or independent of React does not qualify code for `lib/`.
-The current layout predates these boundaries: `lib/editor` contains shared engine code, and some feature processing still lives in `lib/`. Follow ownership for new code and migrate existing code when the task needs that boundary; do not turn an unrelated change into a directory reorganization.
+`core/document` owns the serializable scene contract, history, and document resources; features own their defaults, validation, edits, and processing. `core/image` owns image sources, decoding, geometry, and the working color space. `core/renderer` exposes node composition, execution, transforms, and display through its module entry point. Keep module internals private unless a caller needs them; do not add an application-wide barrel.
Keep ordinary feature changes in the feature, its tests, and explicit app composition. Change shared primitives when a concrete requirement needs a new capability. Features need neither identical file layouts nor a universal plugin interface. Keep the histogram in its feature.
@@ -48,15 +48,16 @@ Keep Tailwind classes inline. Reuse presentation through components or repeat cl
## GPU invariants
- Use `vgpu-react` for React bindings and `vgpu` for GPU operations. Create pipelines once per engine instance and reuse them.
+- Processing uses the [render node contract](PERFORMANCE.md#instrumentation). Features declare passes and inputs; the graph owns intermediate textures and timing. Connect nodes in app composition, keeping the engine independent of concrete features.
- Keep `.wgsl` beside its owner. The Vite loader and ambient types are configured.
- The working space is linear Rec.2020 in `rgba16float`. Decoders convert into it; display converts out. Processing outputs preserve the input format and primaries unless the operation explicitly converts them.
- The adjustment shader's parameters use UI units. Its fitted constants are calibration data; preserve them when reorganizing code.
-- Preserve HDR headroom through exposure, curves, and vibrance. Exposure clips negatives and applies one luminance gain to all channels. `display()` in `lib/color.wgsl` maps out-of-gamut colors toward their luminance.
+- Preserve HDR headroom through exposure, curves, and vibrance. Exposure clips negatives and applies one luminance gain to all channels. `display()` in `core/image/color.wgsl` maps out-of-gamut colors toward their luminance.
- TIFF and camera RAW use `raw-webgpu`. OpenLight adapts package resources to document ownership; codec implementation and coverage belong to the package.
## Tests and completion
-Prefer a few broad integration tests. Use Bun and real application modules with `vgpu/mock` for document, history, loader, and renderer orchestration. The mock does not execute shaders. Use Playwright for GPU pixels, browser interaction, and real format fixtures.
+Prefer a few broad integration tests for features. Core algorithms also merit focused unit tests, especially rendering order, branch/merge connections, and resource reuse. Use Bun and real application modules with `vgpu/mock` for document, history, loader, and renderer orchestration. The mock does not execute shaders. Use Playwright for GPU pixels, browser interaction, and real format fixtures.
Extend the main editing session with named steps for controls, preview, histogram, undo/redo, and export. Steps may live in separate modules. Keep independent rendering and loading checks separate. Assert known pixel values with appropriate tolerances; changed state or screenshots alone do not establish rendering correctness.
diff --git a/API.md b/API.md
index 154ebb5..509fdfd 100644
--- a/API.md
+++ b/API.md
@@ -55,7 +55,7 @@ For RAW sources, `setWhiteBalance({ temperature, tint })` sets absolute Kelvin a
Edits update the scene and history synchronously. Rendering may finish later, particularly RAW development. Tests should wait for visible results; `exportImage()` renders and waits for its captured scene independently of the preview.
-`editScene(change)` shallowly merges a partial [Scene](src/lib/editor/scene.ts) as an undoable edit. Supply complete nested values such as `frame`. This low-level command validates frame geometry only; prefer the adjustment, curve, color-mixer, and white-balance commands for their validation.
+`editScene(change)` shallowly merges a partial [Scene](src/core/document/scene.ts) as an undoable edit. Supply complete nested values such as `frame`. This low-level command validates frame geometry only; prefer the adjustment, curve, color-mixer, and white-balance commands for their validation.
## History
diff --git a/PERFORMANCE.md b/PERFORMANCE.md
index e89faa7..ea88d53 100644
--- a/PERFORMANCE.md
+++ b/PERFORMANCE.md
@@ -19,9 +19,15 @@ Keep unrelated work off the queue during isolated measurements. Label software a
## Instrumentation
-**Current:** the renderer composes passes directly. vgpu provides `timer(gpu)`, `timer.span(name)`, and `FramePassOptions.timer` for render-pass timing. The optional `timestamp-query` feature must be supported and enabled when creating the device. Results arrive asynchronously via `timer.onResults`; `gpu.settled()` covers pending timing readbacks in isolated runs or teardown. See the [vgpu guide](https://github.com/vercel-labs/vgpu/blob/main/docs/topics/performance-playbook.docs.md#13-time-passes-before-optimizing-timer).
+Import rendering primitives from `@/core/renderer`. [`node`](src/core/renderer/node.ts) defines a pass without a GPU: a stable instance name, shader, and optional vgpu `set` values, sampler descriptors, float storage data, or output size/format. `input` imports a caller-owned texture. `pipeline` connects a list of definitions through the shader's `source` binding; an omitted definition bypasses the effect. A multi-pass feature can supply an image-to-image function instead. `split` builds branches sharing their input, without copying textures. `merge` connects named inputs to a definition; its shader performs the combination. Output geometry defaults to the first input. See [unsharp masking](src/features/adjustments/unsharp-mask.ts) for branches and [app composition](src/app/editor/renderer.ts) for preview/export ordering.
-**Planned node contract:** a node is a processing operation that may execute several GPU passes. Shared, opt-in instrumentation must work without React, identify each node instance and its passes, and collect timing centrally. Nodes declare work; they do not implement their own timing framework. Report bypasses and missing coverage explicitly, and sum a node's GPU durations only when all its passes were measured. Keep interactive timing readback asynchronous, without a queue wait after every node. The node engine and shared profiler are not implemented yet.
+[`createRenderGraph(gpu, timer?)`](src/core/renderer/graph.ts) initializes one vgpu effect per node name on first use, keeps it through bypasses, updates bindings, and owns storage buffers. A name identifies one shader and sampler configuration for the graph's lifetime; distinct passes need distinct names even when they use the same shader. Disposal releases buffers and intermediate targets; vgpu owns its internal effect resources and sampler cache.
+
+The graph executes each reachable node once and reuses compatible targets after their last consumer. Multiple inputs and requested outputs are supported. Requested outputs remain valid until the next render or disposal; imported targets remain owned by the caller. Unneeded targets are released after rendering. `inspect()` reports executed pass names and retained intermediate texture dimensions/formats, excluding source, display, decoder, buffers, and driver allocations. There is no cross-frame result cache or shader fusion.
+
+For GPU timing, enable the optional `timestamp-query` device feature, create a vgpu `timer(gpu)`, and pass it to the graph or `createEditorRenderer`. The graph instruments every node centrally. Results arrive asynchronously through `timer.onResults`; the caller disposes the timer. `gpu.settled()` covers timing readbacks in isolated runs or teardown. Do not wait after individual nodes during interactive editing. See the [vgpu guide](https://github.com/vercel-labs/vgpu/blob/main/docs/topics/performance-playbook.docs.md#13-time-passes-before-optimizing-timer).
+
+The [benchmark](tests/rendering-benchmark.ts) measures uninstrumented repeated rendering, then profiles nodes in a separate run. Report bypasses and missing samples explicitly. Sum a feature's pass durations only when every pass was measured. The graph works without React and without profiling support; it currently accepts programmatically composed nodes, not user-editable or serialized graphs.
Fused shader operations share a pass duration; they are not individually timed. Compute dispatches and opaque package operations need supported instrumentation before claiming GPU timing coverage. Editing must work when profiling is unavailable.
diff --git a/README.md b/README.md
index 1b1c8a7..e3458a1 100644
--- a/README.md
+++ b/README.md
@@ -44,7 +44,7 @@ If the environment blocks local ports or browser processes, use its permitted ex
| --- | --- |
| `bun run check` | Format and lint; writes fixes. |
| `bun run build` | Type-check and production build. |
-| `bun run test` | Browser-free integration tests using real modules and `vgpu/mock`. |
+| `bun run test` | Browser-free integration and core unit tests using real modules and `vgpu/mock`. |
| `bun run test:browser` | GPU pixels, UI, and codec integration in Chromium. |
Run all four after changes and before committing. [CI](.github/workflows/ci.yml) currently checks formatting/lint, Bun tests, and the build; it does not run browser tests.
@@ -60,13 +60,11 @@ One browser worker reduces CPU contention with SwiftShader. The mock does not ex
### Rendering benchmarks
-After [browser setup](#browser-setup), run `bun run test:browser --config playwright.bench.config.ts` separately from other GPU/browser work. It measures the renderer without the mixer, with neutral settings, and with all eight ranges active (hue 20, saturation 25, luminance 10). The fixture is a deterministic 2400×1600 linear Rec.2020 gradient containing neutrals, saturated colors, and HDR values; exposure is 0.25 and contrast is 10. Each workload uses 8 warmups and 40 measured samples.
+After [browser setup](#browser-setup), run `bun run test:browser --config playwright.bench.config.ts` separately from other GPU/browser work. Workloads cover neutral effects, color mixing, vignette, detail filters, and the combined pipeline. The fixture is a deterministic 2400×1600 linear Rec.2020 gradient containing neutrals, saturated colors, and HDR values; exposure is 0.25 and contrast is 10. Each workload uses 8 warmups and 40 measured samples. Settings live in [the benchmark](tests/rendering-benchmark.ts); select a workload with e.g. `--grep 'rendering vignette'`.
-Results and rendered PNGs are written under `test-results/benchmarks`. JSON includes environment details, individual samples, median/p95, renderer setup, first render, completed-render latency, and isolated mixer GPU timestamps when supported. Display, readback, and image encoding run outside the measured rendering loop. Software-adapter results describe that backend only. A hardware measurement requires a browser configuration that does not force SwiftShader; record the adapter actually used.
+Results and rendered PNGs are written under `test-results/benchmarks`; keep generated artifacts out of Git. JSON includes environment details, samples, median/p95, setup, first render, completed-render latency, intermediate texture storage, and per-node GPU timestamps when supported. Timestamp profiling runs separately from the latency comparison. Decoding, display, readback, and image encoding run outside the measured loop. Software-adapter results describe that backend only. A hardware measurement requires a browser configuration that does not force SwiftShader; record the adapter actually used.
-For vignette measurements, select `--grep "rendering vignette-"`: the editor renderer runs with intensity 0 or 80 and softness 60, with neutral color mixing. The active workload also measures the isolated vignette pass.
-
-For revision comparisons, run the same benchmark files and browser configuration in both checkouts. Revisions predating the mixer can run `--grep 'rendering baseline'`. The benchmark is opt-in and excluded from the regular test suite; correctness remains covered by the GPU pixel test and editing session. See [PERFORMANCE.md](PERFORMANCE.md) for measurement scope and interpretation.
+For revision comparisons, use identical fixtures, settings, sampling, and browser configuration in both checkouts. The benchmark is opt-in and excluded from the regular test suite; correctness remains covered by GPU pixel tests and the editing session. See [PERFORMANCE.md](PERFORMANCE.md) for the node contract, measurement scope, and interpretation.
## Scripting
@@ -77,7 +75,7 @@ For revision comparisons, run the same benchmark files and browser configuration
- [AGENTS.md](AGENTS.md): architecture, ownership, coding rules, and completion requirements.
- [CONTEXT.md](CONTEXT.md): domain vocabulary.
- [REVIEW.md](REVIEW.md): review questions and actionable findings.
-- [PERFORMANCE.md](PERFORMANCE.md): rendering measurements and the planned node instrumentation contract.
+- [PERFORMANCE.md](PERFORMANCE.md): render nodes and performance measurements.
Code PRs include visual evidence: UI additions or changes require screenshots of the actual interface for visual review. GPU changes also need a reproducible performance comparison. Use the [PR template](.github/pull_request_template.md) and the evidence rules in [AGENTS.md](AGENTS.md#tests-and-completion).
diff --git a/src/app/controls.ts b/src/app/controls.ts
index e038eb0..1f66331 100644
--- a/src/app/controls.ts
+++ b/src/app/controls.ts
@@ -6,26 +6,28 @@ import {
import { createCameraRawXmpLoader } from "@/app/loaders/camera-raw-xmp";
import { createImageLoader } from "@/app/loaders/image";
import { createLoaderRegistry } from "@/app/loaders/registry";
-import type { Workspace } from "@/app/workspace";
+import type {
+ Adjustments,
+ Preview,
+ Scene,
+ ToneCurve,
+ Vignette,
+} from "@/core/document";
+import type { WhiteBalance } from "@/core/image";
+import { setAdjustments } from "@/features/adjustments/edits";
+import { defaultAdjustments } from "@/features/adjustments/model";
import { resetColorMixer, setColorMixer } from "@/features/color-mixer/edits";
import {
defaultMixer,
type MixerChange,
type MixerColor,
} from "@/features/color-mixer/model";
+import { defaultCurve } from "@/features/tone-curves/curve";
+import { setToneCurve } from "@/features/tone-curves/edits";
import { setVignette } from "@/features/vignette/edits";
import { defaultVignette } from "@/features/vignette/model";
import { setWhiteBalance } from "@/features/white-balance/edits";
-import type { Preview } from "@/lib/editor/document";
-import { setAdjustments, setToneCurve } from "@/lib/editor/document/edits";
-import {
- type Adjustments,
- defaultAdjustments,
- type Scene,
- type Vignette,
-} from "@/lib/editor/scene";
-import type { WhiteBalance } from "@/lib/image-source";
-import { defaultCurve, type ToneCurve } from "@/lib/tone-curves/curve";
+import type { Workspace } from "./workspace";
/** Imperative commands bound to an explicit workspace, usable without React. */
export function createControls(gpu: Gpu, workspace: Workspace) {
diff --git a/src/app/editor/adjust/index.tsx b/src/app/editor/adjust/index.tsx
index d742c10..8d8cddd 100644
--- a/src/app/editor/adjust/index.tsx
+++ b/src/app/editor/adjust/index.tsx
@@ -7,19 +7,32 @@ import {
useDocument,
useScene,
} from "@/components/editor/session";
+import {
+ AdjustmentControls,
+ TemperatureControls,
+} from "@/features/adjustments/controls";
import { ColorMixerControls } from "@/features/color-mixer/controls";
import { Histogram } from "@/features/histogram";
import { createHistogram } from "@/features/histogram/histogram";
+import { setToneCurve } from "@/features/tone-curves/edits";
import { ToneCurves } from "@/features/tone-curves/tone-curves";
import { VignetteControls } from "@/features/vignette/controls";
+import { WhiteBalanceControls } from "@/features/white-balance/controls";
import { useEditGesture } from "@/hooks/use-edit-gesture";
-import { setToneCurve } from "@/lib/editor/document/edits";
-import AdjustmentControls from "./adjustment-controls";
import { ClippingControls } from "./clipping-controls";
const histogramColors = ["#f25445", "#6bd175", "#5c8ffa"] as const;
const curveHistogramColors = ["#a3a3a3"] as const;
+function ColorTemperatureControls() {
+ const document = useDocument();
+ const source = useScene((scene) => scene.source);
+ if (document.resources.get(source).raw) {
+ return <WhiteBalanceControls />;
+ }
+ return <TemperatureControls />;
+}
+
function ToneCurvesPanel({
histogram,
}: {
@@ -76,6 +89,7 @@ export function AdjustPanel() {
<AdjustmentControls
curves={<ToneCurvesPanel histogram={histogram} />}
colorMixer={<ColorMixerControls />}
+ temperature={<ColorTemperatureControls />}
/>
<VignetteControls />
</div>
diff --git a/src/app/editor/comparison-control.tsx b/src/app/editor/comparison-control.tsx
index 60b607c..b7fdcfc 100644
--- a/src/app/editor/comparison-control.tsx
+++ b/src/app/editor/comparison-control.tsx
@@ -2,7 +2,7 @@ import { useEffect } from "react";
import { useStore } from "zustand";
import { useDocument } from "@/components/editor/session";
import Button from "@/components/ui/button";
-import type { Preview } from "@/lib/editor/document";
+import type { Preview } from "@/core/document";
export function ComparisonControl() {
const { preview } = useDocument();
diff --git a/src/app/editor/export/export-image.ts b/src/app/editor/export/export-image.ts
index b289096..0b413ff 100644
--- a/src/app/editor/export/export-image.ts
+++ b/src/app/editor/export/export-image.ts
@@ -1,8 +1,8 @@
import { frame, type Gpu, surface, type Target } from "vgpu";
import { createEditorRenderer } from "@/app/editor/renderer";
-import type { EditorDocument } from "@/lib/editor/document";
-import { createDisplay } from "@/lib/image-display";
-import type { Point } from "@/lib/image-frame/geometry";
+import type { EditorDocument } from "@/core/document";
+import type { Point } from "@/core/image/frame";
+import { createDisplay } from "@/core/renderer";
const encodings = {
png: { type: "image/png", extension: "png" },
diff --git a/src/app/editor/export/index.tsx b/src/app/editor/export/index.tsx
index 5d4e0cc..fa9f8f2 100644
--- a/src/app/editor/export/index.tsx
+++ b/src/app/editor/export/index.tsx
@@ -13,7 +13,7 @@ import { Field } from "@/components/ui/field";
import { ScrubInput } from "@/components/ui/scrub-input";
import { Slider } from "@/components/ui/slider";
import Spinner from "@/components/ui/spinner";
-import type { Point } from "@/lib/image-frame/geometry";
+import type { Point } from "@/core/image/frame";
import { type ExportFormat, exportImage, exportSize } from "./export-image";
import { useEncodedPreview } from "./preview";
diff --git a/src/app/editor/export/preview.tsx b/src/app/editor/export/preview.tsx
index f88b70e..9021142 100644
--- a/src/app/editor/export/preview.tsx
+++ b/src/app/editor/export/preview.tsx
@@ -2,7 +2,7 @@ import { useEffect, useRef, useState } from "react";
import type { Target } from "vgpu";
import { useGpu } from "vgpu-react";
import { useRenderer } from "@/components/editor/pipeline";
-import linearize from "@/lib/decode/linearize";
+import linearize from "@/core/image/decode/linearize";
import { type ExportOptions, encodeImage } from "./export-image";
/** Quiet time after a change before encoding; typical encodes take tens of milliseconds. */
diff --git a/src/app/editor/renderer.ts b/src/app/editor/renderer.ts
index 4fa2d38..5b07cb8 100644
--- a/src/app/editor/renderer.ts
+++ b/src/app/editor/renderer.ts
@@ -1,25 +1,45 @@
-import type { Gpu, Target } from "vgpu";
-import { createColorMixer } from "@/features/color-mixer/pass";
-import { createVignette } from "@/features/vignette/pass";
-import { createRenderer, type SceneEffect } from "@/lib/editor/renderer";
-import type { ImageSource } from "@/lib/image-source";
+import type { Gpu, Timer } from "vgpu";
+import type { ImageSource } from "@/core/image";
+import {
+ createRenderer,
+ input,
+ pipeline,
+ transformImages,
+} from "@/core/renderer";
+import { adjustments } from "@/features/adjustments/pass";
+import { unsharpMask } from "@/features/adjustments/unsharp-mask";
+import { colorMixer } from "@/features/color-mixer/pass";
+import { toneCurves } from "@/features/tone-curves/pass";
+import { vignette } from "@/features/vignette/pass";
-function createEffects(gpu: Gpu, source: Target): SceneEffect {
- const mixer = createColorMixer(gpu, source);
- const vignette = createVignette(gpu, source);
- return {
- render(frame, input, scene) {
- const colored = mixer.render(frame, input, scene);
- return vignette.render(frame, colored, scene);
+/** The same graph composition powers the editing preview and export. */
+export function createEditorRenderer(
+ gpu: Gpu,
+ source: ImageSource,
+ timer?: Timer,
+) {
+ return createRenderer(
+ gpu,
+ source,
+ (image, scene) => {
+ const adjusted = pipeline(image, [adjustments(scene.adjustments)]);
+ const full = pipeline(adjusted, [
+ toneCurves(scene.toneCurve),
+ colorMixer(scene.colorMixer),
+ vignette(scene.vignette),
+ unsharpMask("clarity", scene.adjustments.clarity / 200, 64, 16),
+ unsharpMask(
+ "sharpen",
+ scene.adjustments.sharpening / 50,
+ scene.adjustments.sharpenRadius,
+ ),
+ ]);
+ const [original, beforeCurves, output] = transformImages(
+ [input(source.image), adjusted, full],
+ scene.frame,
+ );
+ return { original, input: beforeCurves, full, output };
},
- dispose() {
- mixer.dispose();
- vignette.dispose();
- },
- };
-}
-
-/** The same feature composition powers the editing preview and export. */
-export function createEditorRenderer(gpu: Gpu, source: ImageSource) {
- return createRenderer(gpu, source, createEffects);
+ timer,
+ );
}
diff --git a/src/app/index.tsx b/src/app/index.tsx
index b037ae7..7da122f 100644
--- a/src/app/index.tsx
+++ b/src/app/index.tsx
@@ -1,8 +1,8 @@
import { useStore } from "zustand";
+import Editor from "@/app/editor";
+import Landing from "@/app/landing";
+import { useWorkspace } from "@/app/workspace/use-workspace";
import { useFileDrop } from "@/hooks/use-file-drop";
-import Editor from "./editor";
-import Landing from "./landing";
-import { useWorkspace } from "./workspace/use-workspace";
export default function App() {
const { workspace, controls } = useWorkspace();
diff --git a/src/app/landing/index.tsx b/src/app/landing/index.tsx
index 462998c..30414a2 100644
--- a/src/app/landing/index.tsx
+++ b/src/app/landing/index.tsx
@@ -1,6 +1,6 @@
import { useRef } from "react";
import Button from "@/components/ui/button";
-import { accept } from "@/lib/decode";
+import { accept } from "@/core/image/decode";
import Backdrop from "./backdrop";
type OpenProps = { onOpen: (files: File[]) => void };
diff --git a/src/app/loaders/camera-raw-xmp.ts b/src/app/loaders/camera-raw-xmp.ts
index dfd03ae..bd9de6e 100644
--- a/src/app/loaders/camera-raw-xmp.ts
+++ b/src/app/loaders/camera-raw-xmp.ts
@@ -1,11 +1,11 @@
import type { Workspace } from "@/app/workspace";
+import type { Adjustments } from "@/core/document";
+import { setAdjustments } from "@/features/adjustments/edits";
import {
type CameraRawXmp,
isCameraRawXmp,
readCameraRawXmp,
} from "@/features/camera-raw-xmp/xmp";
-import { setAdjustments } from "@/lib/editor/document/edits";
-import type { Adjustments } from "@/lib/editor/scene";
import type { FileLoader } from "./registry";
function toAdjustments(xmp: CameraRawXmp): Partial<Adjustments> {
diff --git a/src/app/loaders/image.ts b/src/app/loaders/image.ts
index 293fb24..bd4e871 100644
--- a/src/app/loaders/image.ts
+++ b/src/app/loaders/image.ts
@@ -1,11 +1,10 @@
import type { Gpu } from "vgpu";
import type { Workspace } from "@/app/workspace";
-import decode, { canDecode } from "@/lib/decode";
-import { createDocument } from "@/lib/editor/document";
-import { createResources } from "@/lib/editor/document/resources";
-import { defaultAdjustments } from "@/lib/editor/scene";
-import { imageFrame } from "@/lib/image-frame/geometry";
-import { defaultCurve } from "@/lib/tone-curves/curve";
+import { createDocument, createResources } from "@/core/document";
+import decode, { canDecode } from "@/core/image/decode";
+import { imageFrame } from "@/core/image/frame";
+import { defaultAdjustments } from "@/features/adjustments/model";
+import { defaultCurve } from "@/features/tone-curves/curve";
import type { FileLoader } from "./registry";
export function createImageLoader(gpu: Gpu, workspace: Workspace): FileLoader {
diff --git a/src/app/workspace/index.ts b/src/app/workspace/index.ts
index c2c88c1..2fc6a25 100644
--- a/src/app/workspace/index.ts
+++ b/src/app/workspace/index.ts
@@ -1,5 +1,5 @@
import { createStore } from "zustand/vanilla";
-import type { EditorDocument } from "@/lib/editor/document";
+import type { EditorDocument } from "@/core/document";
type WorkspaceState =
| { status: "empty"; file?: undefined; document?: undefined }
diff --git a/src/app/workspace/use-workspace.ts b/src/app/workspace/use-workspace.ts
index 9a70e78..cc4f346 100644
--- a/src/app/workspace/use-workspace.ts
+++ b/src/app/workspace/use-workspace.ts
@@ -1,7 +1,7 @@
import { useEffect, useMemo } from "react";
import { useGpu } from "vgpu-react";
import { createControls } from "@/app/controls";
-import { createWorkspace } from "./index";
+import { createWorkspace } from ".";
/** Connects an imperative workspace and its browser commands to the app lifetime. */
export function useWorkspace() {
diff --git a/src/components/editor/image.tsx b/src/components/editor/image.tsx
index 8eb7498..4b4fe55 100644
--- a/src/components/editor/image.tsx
+++ b/src/components/editor/image.tsx
@@ -2,9 +2,9 @@ import { useEffect, useMemo } from "react";
import type { Target } from "vgpu";
import { useCanvas, useFrame, useGpu } from "vgpu-react";
import { useStore } from "zustand";
+import type { ImageFrame } from "@/core/image/frame";
+import { createDisplay } from "@/core/renderer";
import { fitScale } from "@/hooks/use-pan-zoom";
-import { createDisplay } from "@/lib/image-display";
-import type { ImageFrame } from "@/lib/image-frame/geometry";
import { useRenderer } from "./pipeline";
import { useDocument } from "./session";
import { useViewport } from "./viewport";
diff --git a/src/components/editor/pipeline.tsx b/src/components/editor/pipeline.tsx
index 037e7bf..8dc4a44 100644
--- a/src/components/editor/pipeline.tsx
+++ b/src/components/editor/pipeline.tsx
@@ -6,9 +6,11 @@ import {
useMemo,
useState,
} from "react";
+import type { Gpu } from "vgpu";
import { useGpu } from "vgpu-react";
-import { useDocument, useScene } from "@/components/editor/session";
-import type { createRenderer } from "@/lib/editor/renderer";
+import type { ImageSource } from "@/core/image";
+import type { createRenderer } from "@/core/renderer";
+import { useDocument, useScene } from "./session";
const RendererContext = createContext<ReturnType<typeof createRenderer> | null>(
null,
@@ -35,7 +37,10 @@ function RendererError({ message }: { message: string }) {
type RendererProviderProps = {
children: ReactNode;
- createRenderer: typeof createRenderer;
+ createRenderer: (
+ gpu: Gpu,
+ source: ImageSource,
+ ) => ReturnType<typeof createRenderer>;
};
export function RendererProvider({
diff --git a/src/components/editor/session.tsx b/src/components/editor/session.tsx
index cff4161..1721e5b 100644
--- a/src/components/editor/session.tsx
+++ b/src/components/editor/session.tsx
@@ -8,9 +8,8 @@ import {
import { createPortal } from "react-dom";
import { useStore } from "zustand";
import ResizablePanel from "@/components/ui/resizable-panel";
+import type { EditorDocument, Scene } from "@/core/document";
import { createCamera } from "@/hooks/use-pan-zoom";
-import type { EditorDocument } from "@/lib/editor/document";
-import type { Scene } from "@/lib/editor/scene";
const Session = createContext<{
document: EditorDocument;
diff --git a/src/components/editor/viewport.tsx b/src/components/editor/viewport.tsx
index c469e6f..f7f752a 100644
--- a/src/components/editor/viewport.tsx
+++ b/src/components/editor/viewport.tsx
@@ -2,8 +2,8 @@ import { createContext, type ReactNode, useContext } from "react";
import { Canvas } from "vgpu-react";
import { Icon } from "@/components/icons/icon";
import Button from "@/components/ui/button";
+import type { Point } from "@/core/image/frame";
import { usePanZoom } from "@/hooks/use-pan-zoom";
-import type { Point } from "@/lib/image-frame/geometry";
import { useEditorSession } from "./session";
const Viewport = createContext<ReturnType<typeof usePanZoom> | null>(null);
diff --git a/src/lib/history.ts b/src/core/document/history.ts
similarity index 100%
rename from src/lib/history.ts
rename to src/core/document/history.ts
diff --git a/src/lib/editor/document/index.ts b/src/core/document/index.ts
similarity index 86%
rename from src/lib/editor/document/index.ts
rename to src/core/document/index.ts
index 343e273..6ee85d5 100644
--- a/src/lib/editor/document/index.ts
+++ b/src/core/document/index.ts
@@ -1,9 +1,19 @@
import { createStore } from "zustand/vanilla";
import { shallow } from "zustand/vanilla/shallow";
-import type { Scene } from "@/lib/editor/scene";
-import { createHistory } from "@/lib/history";
-import { frameValues, validateFrame } from "@/lib/image-frame/geometry";
+import { frameValues, validateFrame } from "@/core/image/frame";
+import { createHistory } from "./history";
import { createResources } from "./resources";
+import type { Scene } from "./scene";
+
+export type {
+ Adjustments,
+ ColorMixer,
+ CurvePoint,
+ Scene,
+ ToneCurve,
+ Vignette,
+} from "./scene";
+export { createResources };
export type Preview = {
comparison: "edited" | "original" | "split";
diff --git a/src/lib/editor/document/resources.ts b/src/core/document/resources.ts
similarity index 94%
rename from src/lib/editor/document/resources.ts
rename to src/core/document/resources.ts
index c7fed59..f3175f0 100644
--- a/src/lib/editor/document/resources.ts
+++ b/src/core/document/resources.ts
@@ -1,4 +1,4 @@
-import type { ImageSource } from "@/lib/image-source";
+import type { ImageSource } from "@/core/image";
/** Owns the document's image files and GPU targets, outside scene history. */
export function createResources() {
diff --git a/src/core/document/scene.ts b/src/core/document/scene.ts
new file mode 100644
index 0000000..0b29e87
--- /dev/null
+++ b/src/core/document/scene.ts
@@ -0,0 +1,45 @@
+import type { WhiteBalance } from "@/core/image";
+import type { ImageFrame } from "@/core/image/frame";
+
+export type Adjustments = {
+ exposure: number;
+ incrementalTemperature: number;
+ incrementalTint: number;
+ contrast: number;
+ highlights: number;
+ shadows: number;
+ whites: number;
+ blacks: number;
+ vibrance: number;
+ saturation: number;
+ clarity: number;
+ sharpening: number;
+ sharpenRadius: number;
+};
+
+export type CurvePoint = { readonly x: number; readonly y: number };
+export type ToneCurve = readonly CurvePoint[];
+
+/** Eight color ranges, ordered red through magenta; values use -100..100 UI units. */
+export type ColorMixer = {
+ readonly hue: readonly number[];
+ readonly saturation: readonly number[];
+ readonly luminance: readonly number[];
+};
+
+/** Source-centered darkening in 0..100 UI units. */
+export type Vignette = {
+ readonly intensity: number;
+ readonly softness: number;
+};
+
+/** Serializable document content. Image bytes and GPU resources live elsewhere. */
+export type Scene = {
+ readonly frame: ImageFrame;
+ readonly source: string;
+ readonly whiteBalance?: Readonly<WhiteBalance>;
+ readonly adjustments: Readonly<Adjustments>;
+ readonly toneCurve: ToneCurve;
+ readonly colorMixer?: ColorMixer;
+ readonly vignette?: Vignette;
+};
diff --git a/src/lib/color.wgsl b/src/core/image/color.wgsl
similarity index 100%
rename from src/lib/color.wgsl
rename to src/core/image/color.wgsl
diff --git a/src/lib/decode/heic.ts b/src/core/image/decode/heic.ts
similarity index 98%
rename from src/lib/decode/heic.ts
rename to src/core/image/decode/heic.ts
index 4939e02..3a0fc86 100644
--- a/src/lib/decode/heic.ts
+++ b/src/core/image/decode/heic.ts
@@ -64,7 +64,12 @@ class Reader {
const head = this.at;
const size = this.uint(4);
const type = this.fourcc();
- const length = size === 1 ? this.uint(8) : size === 0 ? end - head : size;
+ let length = size;
+ if (size === 1) {
+ length = this.uint(8);
+ } else if (size === 0) {
+ length = end - head;
+ }
check(length >= this.at - head && length <= end - head);
list.push({ type, start: this.at, end: head + length });
this.at = head + length;
diff --git a/src/lib/decode/index.ts b/src/core/image/decode/index.ts
similarity index 95%
rename from src/lib/decode/index.ts
rename to src/core/image/decode/index.ts
index 799e708..966ab5d 100644
--- a/src/lib/decode/index.ts
+++ b/src/core/image/decode/index.ts
@@ -1,5 +1,5 @@
import type { Gpu, Target } from "vgpu";
-import { createImageSource, type ImageSource } from "@/lib/image-source";
+import { createImageSource, type ImageSource } from "@/core/image";
import { decodeHeic } from "./heic";
import linearize from "./linearize";
import decodeSvg from "./svg";
@@ -28,7 +28,7 @@ const heic = pixelFormat(async () => decodeHeic);
const tiff = async (gpu: Gpu, file: File) =>
(await import("./tiff")).decodeTiff(gpu, file);
const raw = async (gpu: Gpu, file: File) =>
- (await import("@/lib/raw")).decodeRaw(gpu, file);
+ (await import("./raw")).decodeRaw(gpu, file);
const formats: Format[] = [
{
diff --git a/src/lib/decode/linearize.ts b/src/core/image/decode/linearize.ts
similarity index 100%
rename from src/lib/decode/linearize.ts
rename to src/core/image/decode/linearize.ts
diff --git a/src/lib/decode/linearize.wgsl b/src/core/image/decode/linearize.wgsl
similarity index 100%
rename from src/lib/decode/linearize.wgsl
rename to src/core/image/decode/linearize.wgsl
diff --git a/src/lib/raw/index.ts b/src/core/image/decode/raw.ts
similarity index 96%
rename from src/lib/raw/index.ts
rename to src/core/image/decode/raw.ts
index 35b2207..9cacd06 100644
--- a/src/lib/raw/index.ts
+++ b/src/core/image/decode/raw.ts
@@ -1,6 +1,6 @@
import { createRawDecoder, type RawDecoder } from "raw-webgpu";
import { type Gpu, type Target, target } from "vgpu";
-import { createImageSource } from "@/lib/image-source";
+import { createImageSource } from "@/core/image";
const decoders = new WeakMap<Gpu, RawDecoder>();
diff --git a/src/lib/decode/svg.ts b/src/core/image/decode/svg.ts
similarity index 100%
rename from src/lib/decode/svg.ts
rename to src/core/image/decode/svg.ts
diff --git a/src/lib/decode/tiff.ts b/src/core/image/decode/tiff.ts
similarity index 94%
rename from src/lib/decode/tiff.ts
rename to src/core/image/decode/tiff.ts
index c9dc177..1d70a4e 100644
--- a/src/lib/decode/tiff.ts
+++ b/src/core/image/decode/tiff.ts
@@ -6,7 +6,7 @@ import {
type Target,
target,
} from "vgpu";
-import { createImageSource } from "@/lib/image-source";
+import { createImageSource } from "@/core/image";
import shader from "./tiff.wgsl";
const transfers = new WeakMap<Gpu, Effect>();
diff --git a/src/lib/decode/tiff.wgsl b/src/core/image/decode/tiff.wgsl
similarity index 100%
rename from src/lib/decode/tiff.wgsl
rename to src/core/image/decode/tiff.wgsl
diff --git a/src/lib/decode/types.ts b/src/core/image/decode/types.ts
similarity index 100%
rename from src/lib/decode/types.ts
rename to src/core/image/decode/types.ts
diff --git a/src/lib/image-frame/geometry.ts b/src/core/image/frame.ts
similarity index 100%
rename from src/lib/image-frame/geometry.ts
rename to src/core/image/frame.ts
diff --git a/src/lib/image-source.ts b/src/core/image/index.ts
similarity index 100%
rename from src/lib/image-source.ts
rename to src/core/image/index.ts
diff --git a/src/lib/image-display/display.wgsl b/src/core/renderer/display/display.wgsl
similarity index 92%
rename from src/lib/image-display/display.wgsl
rename to src/core/renderer/display/display.wgsl
index 853e89c..ae30079 100644
--- a/src/lib/image-display/display.wgsl
+++ b/src/core/renderer/display/display.wgsl
@@ -1,4 +1,4 @@
-import { display, rec2020ToSrgb } from "../color.wgsl";
+import { display, rec2020ToSrgb } from "../../image/color.wgsl";
export struct View {
size: vec2f,
diff --git a/src/lib/image-display/image.wgsl b/src/core/renderer/display/image.wgsl
similarity index 92%
rename from src/lib/image-display/image.wgsl
rename to src/core/renderer/display/image.wgsl
index 7e81e70..ae95c09 100644
--- a/src/lib/image-display/image.wgsl
+++ b/src/core/renderer/display/image.wgsl
@@ -1,5 +1,5 @@
import { View, imagePoint, previewColor, background } from "./display.wgsl";
-import { Transform, sourcePoint } from "../image-frame/transform.wgsl";
+import { Transform, sourcePoint } from "../transform/transform.wgsl";
@group(0) @binding(0) var<uniform> view: View;
@group(0) @binding(1) var source: texture_2d<f32>;
diff --git a/src/lib/image-display/index.ts b/src/core/renderer/display/index.ts
similarity index 97%
rename from src/lib/image-display/index.ts
rename to src/core/renderer/display/index.ts
index 9d498be..7d6d56b 100644
--- a/src/lib/image-display/index.ts
+++ b/src/core/renderer/display/index.ts
@@ -3,7 +3,7 @@ import {
frameTransform,
type ImageFrame,
imageFrame,
-} from "@/lib/image-frame/geometry";
+} from "@/core/image/frame";
import shader from "./image.wgsl";
export type View = { zoom: number; pan: readonly [number, number] };
diff --git a/src/core/renderer/graph.ts b/src/core/renderer/graph.ts
new file mode 100644
index 0000000..b783d0d
--- /dev/null
+++ b/src/core/renderer/graph.ts
@@ -0,0 +1,195 @@
+import {
+ type Buffer,
+ type Effect,
+ effect,
+ frame,
+ type Gpu,
+ sampler,
+ type Target,
+ type Timer,
+ target,
+} from "vgpu";
+import type { RenderImage, RenderNode } from "./node";
+
+type Pass = {
+ shader: RenderNode["shader"];
+ effect: Effect;
+ buffers: Map<string, Buffer>;
+};
+
+function plan(outputs: readonly RenderImage[]) {
+ const uses = new Map<RenderImage, number>();
+ const order: RenderNode[] = [];
+ const live = new Set<Target>();
+ const names = new Set<string>();
+ function visit(image: RenderImage) {
+ const count = uses.get(image) ?? 0;
+ uses.set(image, count + 1);
+ if (count) {
+ return;
+ }
+ if (!("inputs" in image)) {
+ live.add(image.target);
+ return;
+ }
+ if (names.has(image.name)) {
+ throw Error(`Duplicate render node: ${image.name}.`);
+ }
+ names.add(image.name);
+ Object.values(image.inputs).forEach(visit);
+ order.push(image);
+ }
+ // Requested outputs count as consumers, keeping their targets live.
+ outputs.forEach(visit);
+ return { order, uses, live };
+}
+
+/** Owns effects, storage buffers, and transient targets for one renderer. */
+export function createRenderGraph(gpu: Gpu, timer?: Timer) {
+ const pool: Target[] = [];
+ const effects = new Map<string, Pass>();
+ let passes: string[] = [];
+ let disposed = false;
+ function prepare(node: RenderNode) {
+ let pass = effects.get(node.name);
+ if (!pass) {
+ const bindings = Object.fromEntries(
+ Object.entries(node.samplers ?? {}).map(([name, descriptor]) => [
+ name,
+ sampler(gpu, descriptor),
+ ]),
+ );
+ pass = {
+ shader: node.shader,
+ effect: effect(gpu, node.shader, {
+ label: node.name,
+ set: bindings,
+ }),
+ buffers: new Map(),
+ };
+ effects.set(node.name, pass);
+ }
+ if (pass.shader !== node.shader) {
+ throw Error(`Render node ${node.name} changed shader; use a new name.`);
+ }
+ for (const [name, data] of Object.entries(node.storage ?? {})) {
+ let buffer = pass.buffers.get(name);
+ if (!buffer || buffer.options.size !== data.byteLength) {
+ buffer?.dispose();
+ buffer = gpu.device.createBuffer({
+ size: data.byteLength,
+ usage: ["storage", "copy_dst"],
+ });
+ pass.buffers.set(name, buffer);
+ pass.effect.set({ [name]: buffer });
+ }
+ buffer.write(data);
+ }
+ return pass.effect;
+ }
+ function acquire(
+ node: RenderNode,
+ live: ReadonlySet<Target>,
+ written: ReadonlySet<Target>,
+ ) {
+ const exact = pool.find(
+ (image) =>
+ !live.has(image) &&
+ image.format === node.format &&
+ image.size[0] === node.size[0] &&
+ image.size[1] === node.size[1],
+ );
+ if (exact) {
+ return exact;
+ }
+ // Resize only targets not referenced by commands in this frame.
+ const spare = pool.find(
+ (image) =>
+ !live.has(image) && !written.has(image) && image.format === node.format,
+ );
+ if (spare) {
+ spare.resize(node.size);
+ return spare;
+ }
+ const image = target(gpu, { size: node.size, format: node.format });
+ pool.push(image);
+ return image;
+ }
+ return {
+ render(outputs: readonly RenderImage[]) {
+ if (disposed) {
+ throw Error("Render graph is closed.");
+ }
+ const { order, uses, live } = plan(outputs);
+ const results = new Map<RenderNode, Target>();
+ function resolve(image: RenderImage): Target {
+ if (!("inputs" in image)) {
+ return image.target;
+ }
+ const result = results.get(image);
+ if (!result) {
+ throw Error(`Unrendered node: ${image.name}.`);
+ }
+ return result;
+ }
+ const written = new Set<Target>();
+ frame(gpu, (frame) => {
+ for (const node of order) {
+ const pass = prepare(node);
+ pass.set({
+ ...node.set,
+ ...Object.fromEntries(
+ Object.entries(node.inputs).map(([name, image]) => [
+ name,
+ resolve(image).color,
+ ]),
+ ),
+ });
+ const output = acquire(node, live, written);
+ live.add(output);
+ written.add(output);
+ frame.pass({ target: output, timer: timer?.span(node.name) }, pass);
+ results.set(node, output);
+ for (const input of Object.values(node.inputs)) {
+ const remaining = (uses.get(input) ?? 0) - 1;
+ uses.set(input, remaining);
+ if (!remaining && "inputs" in input) {
+ live.delete(resolve(input));
+ }
+ }
+ }
+ });
+ // Avoid retaining old crop sizes or the peak of a previously active effect.
+ for (let i = pool.length - 1; i >= 0; i--) {
+ if (!written.has(pool[i]) && !live.has(pool[i])) {
+ pool[i].color.dispose();
+ pool.splice(i, 1);
+ }
+ }
+ passes = order.map((node) => node.name);
+ return outputs.map(resolve);
+ },
+ inspect() {
+ return {
+ passes: [...passes],
+ textures: pool.map(({ size, format }) => ({
+ size: [...size],
+ format,
+ })),
+ };
+ },
+ dispose() {
+ disposed = true;
+ for (const pass of effects.values()) {
+ for (const buffer of pass.buffers.values()) {
+ buffer.dispose();
+ }
+ }
+ effects.clear();
+ for (const image of pool) {
+ image.color.dispose();
+ }
+ pool.length = 0;
+ },
+ };
+}
diff --git a/src/lib/editor/renderer.ts b/src/core/renderer/index.ts
similarity index 51%
rename from src/lib/editor/renderer.ts
rename to src/core/renderer/index.ts
index 3acbdb3..affccca 100644
--- a/src/lib/editor/renderer.ts
+++ b/src/core/renderer/index.ts
@@ -1,15 +1,34 @@
-import { type Frame, frame, type Gpu, type Target } from "vgpu";
-import { createAdjustments } from "@/lib/adjustments";
-import type { Scene } from "@/lib/editor/scene";
-import { createImageFrame } from "@/lib/image-frame";
-import type { ImageSource, WhiteBalance } from "@/lib/image-source";
-import { createToneCurves } from "@/lib/tone-curves";
-import { createUnsharpMask } from "@/lib/unsharp-mask";
+import type { Gpu, Timer } from "vgpu";
+import type { Scene } from "@/core/document";
+import type { ImageSource, WhiteBalance } from "@/core/image";
+import { createRenderGraph } from "./graph";
+import { input, type RenderImage } from "./node";
-/** An optional document effect, composed after curves and before detail filtering. */
-export type SceneEffect = {
- render(frame: Frame, input: Target, scene: Scene): Target;
- dispose(): void;
+export { type Clipping, createDisplay, type View } from "./display";
+export {
+ input,
+ merge,
+ type NodeDefinition,
+ node,
+ pipeline,
+ type RenderImage,
+ type RenderInput,
+ type RenderNode,
+ type RenderStep,
+ split,
+} from "./node";
+export { transformImages } from "./transform";
+export { createRenderGraph };
+
+/** App composition describes requested outputs; the engine owns their storage. */
+export type SceneProcessing = (
+ source: RenderImage,
+ scene: Scene,
+) => {
+ original: RenderImage;
+ input: RenderImage;
+ full: RenderImage;
+ output: RenderImage;
};
function sameBalance(a: WhiteBalance | undefined, b: WhiteBalance | undefined) {
@@ -20,49 +39,31 @@ function sameBalance(a: WhiteBalance | undefined, b: WhiteBalance | undefined) {
export function createRenderer(
gpu: Gpu,
resource: ImageSource,
- createEffect?: (gpu: Gpu, source: Target) => SceneEffect,
+ compose: SceneProcessing,
+ timer?: Timer,
) {
const source = resource.image;
- const adjust = createAdjustments(gpu, source);
- const adjusted = adjust.output;
- const toneCurves = createToneCurves(gpu, adjusted);
- const clarity = createUnsharpMask(gpu, source, 16);
- const sharpen = createUnsharpMask(gpu, source);
- const effect = createEffect?.(gpu, source);
-
- const transform = createImageFrame(gpu);
+ const graph = createRenderGraph(gpu, timer);
const release = resource.retain();
const raw = resource.raw?.createPass();
let original = source;
- let input = adjusted;
- let fullImage = adjusted;
+ let previewInput = source;
+ let full = source;
const listeners = new Set<() => void>();
let rendered = false;
- let output = adjusted;
+ let output = source;
let balance = resource.raw?.asShot;
let next: Scene | undefined;
let pending: Promise<void> | undefined;
let disposed = false;
function render(scene: Scene) {
- frame(gpu, (frame) => {
- const developed = raw?.render() ?? source;
- adjust.render(frame, scene.adjustments, developed);
- const curved = toneCurves.render(frame, scene.toneCurve);
- const colored = effect?.render(frame, curved, scene) ?? curved;
- const { clarity: amount, sharpening, sharpenRadius } = scene.adjustments;
- const clarified = clarity.render(frame, colored, amount / 200, 64);
- fullImage = sharpen.render(
- frame,
- clarified,
- sharpening / 50,
- sharpenRadius,
- );
- [original, input, output] = transform.render(
- frame,
- [source, adjusted, fullImage],
- scene.frame,
- );
- });
+ const images = compose(input(raw?.render() ?? source), scene);
+ [original, previewInput, full, output] = graph.render([
+ images.original,
+ images.input,
+ images.full,
+ images.output,
+ ]);
rendered = true;
for (const listener of listeners) {
listener();
@@ -112,9 +113,10 @@ export function createRenderer(
return {
originalImage: () => original,
- inputImage: () => input,
- fullImage: () => fullImage,
+ inputImage: () => previewInput,
+ fullImage: () => full,
outputImage: () => output,
+ inspect: graph.inspect,
subscribe(listener: () => void) {
listeners.add(listener);
if (rendered) {
@@ -131,12 +133,7 @@ export function createRenderer(
}
disposed = true;
listeners.clear();
- adjust.dispose();
- toneCurves.dispose();
- clarity.dispose();
- sharpen.dispose();
- effect?.dispose();
- transform.dispose();
+ graph.dispose();
raw?.dispose();
release();
},
diff --git a/src/core/renderer/node.ts b/src/core/renderer/node.ts
new file mode 100644
index 0000000..6490a48
--- /dev/null
+++ b/src/core/renderer/node.ts
@@ -0,0 +1,82 @@
+import type { EffectOptions, ShaderSource, Target } from "vgpu";
+
+type NodeOptions = {
+ readonly set?: EffectOptions["set"];
+ readonly samplers?: Readonly<Record<string, GPUSamplerDescriptor>>;
+ readonly storage?: Readonly<Record<string, Float32Array<ArrayBuffer>>>;
+ readonly size?: readonly [number, number];
+ readonly format?: GPUTextureFormat;
+};
+export type NodeDefinition = NodeOptions & {
+ readonly name: string;
+ readonly shader: string | ShaderSource;
+};
+export type RenderInput = {
+ readonly target: Target;
+ readonly size: readonly [number, number];
+ readonly format: GPUTextureFormat;
+};
+export type RenderNode = NodeDefinition & {
+ readonly inputs: Readonly<Record<string, RenderImage>>;
+ readonly size: readonly [number, number];
+ readonly format: GPUTextureFormat;
+};
+export type RenderImage = RenderInput | RenderNode;
+export type RenderStep =
+ | NodeDefinition
+ | ((image: RenderImage) => RenderImage)
+ | undefined;
+
+/** Imports a caller-owned texture without copying or allocating GPU resources. */
+export function input(target: Target): RenderInput {
+ return { target, size: target.size, format: target.format };
+}
+
+export function node(
+ name: string,
+ shader: NodeDefinition["shader"],
+ options: NodeOptions = {},
+): NodeDefinition {
+ return { ...options, name, shader };
+}
+
+/** Connects named shader inputs; the shader defines how to combine them. */
+export function merge(
+ inputs: RenderNode["inputs"],
+ definition: NodeDefinition,
+): RenderNode {
+ const first = Object.values(inputs)[0];
+ if (!first) {
+ throw Error(`Render node ${definition.name} needs an input.`);
+ }
+ return {
+ ...definition,
+ inputs,
+ size: definition.size ?? first.size,
+ format: definition.format ?? first.format,
+ };
+}
+
+/** Connects source → output in order; an omitted step is a bypass. */
+export function pipeline(
+ source: RenderImage,
+ steps: readonly RenderStep[],
+): RenderImage {
+ return steps.reduce<RenderImage>((image, step) => {
+ if (!step) {
+ return image;
+ }
+ if (typeof step === "function") {
+ return step(image);
+ }
+ return merge({ source: image }, step);
+ }, source);
+}
+
+/** Branches share their input; this does not copy textures. */
+export function split(
+ source: RenderImage,
+ branches: readonly (readonly RenderStep[])[],
+) {
+ return branches.map((steps) => pipeline(source, steps));
+}
diff --git a/src/lib/image-frame/frame.wgsl b/src/core/renderer/transform/frame.wgsl
similarity index 100%
rename from src/lib/image-frame/frame.wgsl
rename to src/core/renderer/transform/frame.wgsl
diff --git a/src/core/renderer/transform/index.ts b/src/core/renderer/transform/index.ts
new file mode 100644
index 0000000..995b6c5
--- /dev/null
+++ b/src/core/renderer/transform/index.ts
@@ -0,0 +1,38 @@
+import {
+ frameTransform,
+ frameValues,
+ type ImageFrame,
+ imageFrame,
+} from "@/core/image/frame";
+import { merge, node, type RenderImage } from "@/core/renderer/node";
+import shader from "./frame.wgsl";
+
+/** Equal inputs share a transform node; identity geometry preserves the input. */
+export function transformImages(
+ sources: readonly RenderImage[],
+ geometry: ImageFrame,
+) {
+ const initial = frameValues(imageFrame(sources[0].size));
+ if (frameValues(geometry).every((value, i) => value === initial[i])) {
+ return sources;
+ }
+ 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, input.size) },
+ samplers: {
+ sourceSampler: { magFilter: "linear", minFilter: "linear" },
+ },
+ size: [Math.round(geometry.size[0]), Math.round(geometry.size[1])],
+ }),
+ );
+ outputs.set(input, output);
+ return output;
+ });
+}
diff --git a/src/lib/image-frame/transform.wgsl b/src/core/renderer/transform/transform.wgsl
similarity index 100%
rename from src/lib/image-frame/transform.wgsl
rename to src/core/renderer/transform/transform.wgsl
diff --git a/src/lib/adjustments/adjustments.wgsl b/src/features/adjustments/adjustments.wgsl
similarity index 97%
rename from src/lib/adjustments/adjustments.wgsl
rename to src/features/adjustments/adjustments.wgsl
index f370c37..cd7eaad 100644
--- a/src/lib/adjustments/adjustments.wgsl
+++ b/src/features/adjustments/adjustments.wgsl
@@ -1,4 +1,4 @@
-import { luminance } from "../color.wgsl";
+import { luminance } from "../../core/image/color.wgsl";
import { adjustBlacks } from "./blacks.wgsl";
import { adjustHighlights } from "./highlights.wgsl";
import { adjustShadows } from "./shadows.wgsl";
diff --git a/src/lib/adjustments/blacks.wgsl b/src/features/adjustments/blacks.wgsl
similarity index 90%
rename from src/lib/adjustments/blacks.wgsl
rename to src/features/adjustments/blacks.wgsl
index 391d1d1..b860920 100644
--- a/src/lib/adjustments/blacks.wgsl
+++ b/src/features/adjustments/blacks.wgsl
@@ -1,5 +1,5 @@
import { linearToSrgb, srgbToLinear } from "@vgpu/wgsl-std/color";
-import { luminance } from "../color.wgsl";
+import { luminance } from "../../core/image/color.wgsl";
import { endpointCurve, remapLuminance } from "./endpoint.wgsl";
// Shift the endpoint by up to 0.1 in perceptual space; amount is -100..100.
diff --git a/src/app/editor/adjust/adjustment-controls.tsx b/src/features/adjustments/controls.tsx
similarity index 84%
rename from src/app/editor/adjust/adjustment-controls.tsx
rename to src/features/adjustments/controls.tsx
index 948d289..7ea0840 100644
--- a/src/app/editor/adjust/adjustment-controls.tsx
+++ b/src/features/adjustments/controls.tsx
@@ -2,14 +2,13 @@ import type { ComponentProps, ReactNode } from "react";
import { useDocument, useScene } from "@/components/editor/session";
import { Collapsible } from "@/components/ui/collapsible";
import { Slider } from "@/components/ui/slider";
-import { WhiteBalanceControls } from "@/features/white-balance/controls";
-import { setAdjustments } from "@/lib/editor/document/edits";
+import type { Adjustments } from "@/core/document";
+import { setAdjustments } from "./edits";
import {
- type Adjustments,
adjustmentLimits,
adjustmentMinimums,
defaultAdjustments,
-} from "@/lib/editor/scene";
+} from "./model";
const stops = {
incrementalTemperature: ["#4a6fc3", "#c3b84a"],
@@ -45,12 +44,7 @@ function AdjustmentSlider({ name, ...props }: AdjustmentSliderProps) {
);
}
-function ColorTemperatureControls() {
- const document = useDocument();
- const source = useScene((scene) => scene.source);
- if (document.resources.get(source).raw) {
- return <WhiteBalanceControls />;
- }
+export function TemperatureControls() {
return (
<>
<AdjustmentSlider
@@ -67,12 +61,14 @@ function ColorTemperatureControls() {
);
}
-export default function AdjustmentControls({
+export function AdjustmentControls({
curves,
colorMixer,
+ temperature,
}: {
curves: ReactNode;
colorMixer: ReactNode;
+ temperature: ReactNode;
}) {
return (
<>
@@ -89,7 +85,7 @@ export default function AdjustmentControls({
</Collapsible>
<Collapsible title="Color">
<div className="flex flex-col gap-2">
- <ColorTemperatureControls />
+ {temperature}
<AdjustmentSlider
name="vibrance"
label="Vibrance"
diff --git a/src/lib/editor/document/edits.ts b/src/features/adjustments/edits.ts
similarity index 55%
rename from src/lib/editor/document/edits.ts
rename to src/features/adjustments/edits.ts
index a10d32d..bc1ffd2 100644
--- a/src/lib/editor/document/edits.ts
+++ b/src/features/adjustments/edits.ts
@@ -1,14 +1,5 @@
-import {
- type Adjustments,
- adjustmentLimits,
- adjustmentMinimums,
-} from "@/lib/editor/scene";
-import {
- defaultCurve,
- type ToneCurve,
- validateCurve,
-} from "@/lib/tone-curves/curve";
-import type { EditorDocument } from "./index";
+import type { Adjustments, EditorDocument } from "@/core/document";
+import { adjustmentLimits, adjustmentMinimums } from "./model";
export function setAdjustments(
document: EditorDocument,
@@ -29,14 +20,3 @@ export function setAdjustments(
const scene = document.scene.getState();
document.edit({ ...scene, adjustments: { ...scene.adjustments, ...change } });
}
-
-export function setToneCurve(
- document: EditorDocument,
- points: ToneCurve = defaultCurve,
-) {
- validateCurve(points);
- document.edit({
- ...document.scene.getState(),
- toneCurve: points.map((point) => ({ ...point })),
- });
-}
diff --git a/src/lib/adjustments/endpoint.wgsl b/src/features/adjustments/endpoint.wgsl
similarity index 93%
rename from src/lib/adjustments/endpoint.wgsl
rename to src/features/adjustments/endpoint.wgsl
index 3d2d304..a030115 100644
--- a/src/lib/adjustments/endpoint.wgsl
+++ b/src/features/adjustments/endpoint.wgsl
@@ -1,4 +1,4 @@
-import { luminance } from "../color.wgsl";
+import { luminance } from "../../core/image/color.wgsl";
// In perceptual 0..1: move the black endpoint horizontally or vertically,
// joining the identity at 0.5 with slope 1. Whites use the mirrored curve.
diff --git a/src/lib/adjustments/highlights.wgsl b/src/features/adjustments/highlights.wgsl
similarity index 95%
rename from src/lib/adjustments/highlights.wgsl
rename to src/features/adjustments/highlights.wgsl
index 5788790..6c012b6 100644
--- a/src/lib/adjustments/highlights.wgsl
+++ b/src/features/adjustments/highlights.wgsl
@@ -1,5 +1,5 @@
import { linearToSrgb } from "@vgpu/wgsl-std/color";
-import { luminance } from "../color.wgsl";
+import { luminance } from "../../core/image/color.wgsl";
fn highlightCompression(tone: f32) -> f32 {
let mask = smoothstep(0.0, 0.25, tone);
diff --git a/src/features/adjustments/model.ts b/src/features/adjustments/model.ts
new file mode 100644
index 0000000..6a5ad37
--- /dev/null
+++ b/src/features/adjustments/model.ts
@@ -0,0 +1,38 @@
+import type { Adjustments } from "@/core/document";
+
+export const defaultAdjustments: Adjustments = {
+ exposure: 0,
+ incrementalTemperature: 0,
+ incrementalTint: 0,
+ contrast: 0,
+ highlights: 0,
+ shadows: 0,
+ whites: 0,
+ blacks: 0,
+ vibrance: 0,
+ saturation: 0,
+ clarity: 0,
+ sharpening: 0,
+ sharpenRadius: 1,
+};
+
+export const adjustmentLimits: Adjustments = {
+ exposure: 5,
+ incrementalTemperature: 100,
+ incrementalTint: 100,
+ contrast: 100,
+ highlights: 100,
+ shadows: 100,
+ whites: 100,
+ blacks: 100,
+ vibrance: 100,
+ saturation: 100,
+ clarity: 100,
+ sharpening: 150,
+ sharpenRadius: 3,
+};
+
+export const adjustmentMinimums: Partial<Adjustments> = {
+ sharpening: 0,
+ sharpenRadius: 0.5,
+};
diff --git a/src/features/adjustments/pass.ts b/src/features/adjustments/pass.ts
new file mode 100644
index 0000000..b9d06f0
--- /dev/null
+++ b/src/features/adjustments/pass.ts
@@ -0,0 +1,10 @@
+import type { Adjustments } from "@/core/document";
+import { node } from "@/core/renderer";
+import shader from "./adjustments.wgsl";
+
+export function adjustments(values: Adjustments) {
+ return node("adjustments", shader, {
+ set: { adjustments: values },
+ samplers: { sourceSampler: { minFilter: "linear", magFilter: "linear" } },
+ });
+}
diff --git a/src/lib/adjustments/prepare.wgsl b/src/features/adjustments/prepare.wgsl
similarity index 97%
rename from src/lib/adjustments/prepare.wgsl
rename to src/features/adjustments/prepare.wgsl
index c15dabb..3a58444 100644
--- a/src/lib/adjustments/prepare.wgsl
+++ b/src/features/adjustments/prepare.wgsl
@@ -1,4 +1,4 @@
-import { luminance } from "../color.wgsl";
+import { luminance } from "../../core/image/color.wgsl";
export struct Adjustments {
exposure: f32,
diff --git a/src/lib/adjustments/shadows.wgsl b/src/features/adjustments/shadows.wgsl
similarity index 94%
rename from src/lib/adjustments/shadows.wgsl
rename to src/features/adjustments/shadows.wgsl
index 33f16ce..96e21d4 100644
--- a/src/lib/adjustments/shadows.wgsl
+++ b/src/features/adjustments/shadows.wgsl
@@ -1,5 +1,5 @@
import { linearToSrgb, srgbToLinear } from "@vgpu/wgsl-std/color";
-import { luminance } from "../color.wgsl";
+import { luminance } from "../../core/image/color.wgsl";
fn liftedShadow(tone: f32) -> f32 {
let inverse = 1.0 - tone;
diff --git a/src/features/adjustments/unsharp-mask.ts b/src/features/adjustments/unsharp-mask.ts
new file mode 100644
index 0000000..f6b7888
--- /dev/null
+++ b/src/features/adjustments/unsharp-mask.ts
@@ -0,0 +1,47 @@
+import { merge, node, type RenderImage, split } from "@/core/renderer";
+import shader from "./unsharp-mask.wgsl";
+
+/** Builds a separable luminance blur and combines it with the unchanged input. */
+export function unsharpMask(
+ name: string,
+ amount: number,
+ radius: number,
+ reduction = 1,
+) {
+ if (amount === 0) {
+ return;
+ }
+ return (image: RenderImage) => {
+ const size: [number, number] = [
+ Math.ceil(image.size[0] / reduction),
+ Math.ceil(image.size[1] / reduction),
+ ];
+ const samplers = {
+ linearSampler: { minFilter: "linear", magFilter: "linear" },
+ } as const;
+ const params = { reduction, amount, sigma: radius / reduction };
+ function blur(label: string, mode: number) {
+ const pass = node(`${name}/${label}`, shader, {
+ size,
+ samplers,
+ set: { params: { ...params, mode } },
+ });
+ return (source: RenderImage) => merge({ source, base: source }, pass);
+ }
+ const [original, blurred] = split(image, [
+ [],
+ [
+ reduction === 1 ? undefined : blur("reduce", 0),
+ blur("horizontal", 1),
+ blur("vertical", 2),
+ ],
+ ]);
+ return merge(
+ { source: original, base: blurred },
+ node(name, shader, {
+ samplers,
+ set: { params: { ...params, mode: 3 } },
+ }),
+ );
+ };
+}
diff --git a/src/lib/unsharp-mask/unsharp-mask.wgsl b/src/features/adjustments/unsharp-mask.wgsl
similarity index 97%
rename from src/lib/unsharp-mask/unsharp-mask.wgsl
rename to src/features/adjustments/unsharp-mask.wgsl
index 6819965..06d9fb1 100644
--- a/src/lib/unsharp-mask/unsharp-mask.wgsl
+++ b/src/features/adjustments/unsharp-mask.wgsl
@@ -1,5 +1,5 @@
import { linearToSrgb, srgbToLinear } from "@vgpu/wgsl-std/color";
-import { luminance } from "../color.wgsl";
+import { luminance } from "../../core/image/color.wgsl";
struct Params { mode: u32, reduction: i32, amount: f32, sigma: f32 }
@group(0) @binding(0) var source: texture_2d<f32>;
diff --git a/src/lib/adjustments/whites.wgsl b/src/features/adjustments/whites.wgsl
similarity index 90%
rename from src/lib/adjustments/whites.wgsl
rename to src/features/adjustments/whites.wgsl
index 7fde08d..4e79b1d 100644
--- a/src/lib/adjustments/whites.wgsl
+++ b/src/features/adjustments/whites.wgsl
@@ -1,5 +1,5 @@
import { linearToSrgb, srgbToLinear } from "@vgpu/wgsl-std/color";
-import { luminance } from "../color.wgsl";
+import { luminance } from "../../core/image/color.wgsl";
import { endpointCurve, remapLuminance } from "./endpoint.wgsl";
// Shift the endpoint by up to 0.1 in perceptual space; amount is -100..100.
diff --git a/src/features/color-mixer/edits.ts b/src/features/color-mixer/edits.ts
index 6c4ca1f..7d447b7 100644
--- a/src/features/color-mixer/edits.ts
+++ b/src/features/color-mixer/edits.ts
@@ -1,4 +1,4 @@
-import type { EditorDocument } from "@/lib/editor/document";
+import type { EditorDocument } from "@/core/document";
import {
channels,
colors,
diff --git a/src/features/color-mixer/mixer.wgsl b/src/features/color-mixer/mixer.wgsl
index 4085862..0422f5c 100644
--- a/src/features/color-mixer/mixer.wgsl
+++ b/src/features/color-mixer/mixer.wgsl
@@ -1,4 +1,4 @@
-import { luminance, rec2020ToSrgb, srgbToRec2020 } from "../../lib/color.wgsl";
+import { luminance, rec2020ToSrgb, srgbToRec2020 } from "../../core/image/color.wgsl";
// Selective color in Oklab: at +/-100 a range turns hue 30 degrees, scales chroma 0..2x or moves luminance one stop.
// The import above is relative because the shader loader does not resolve the `@/` alias.
diff --git a/src/features/color-mixer/model.ts b/src/features/color-mixer/model.ts
index 050daa9..55e8484 100644
--- a/src/features/color-mixer/model.ts
+++ b/src/features/color-mixer/model.ts
@@ -1,4 +1,4 @@
-import type { ColorMixer } from "@/lib/editor/scene";
+import type { ColorMixer } from "@/core/document";
// Oklab angles of the eight full-saturation sRGB colors, for circular interpolation.
export const colors = [
diff --git a/src/features/color-mixer/pass.ts b/src/features/color-mixer/pass.ts
index a0dc925..4297639 100644
--- a/src/features/color-mixer/pass.ts
+++ b/src/features/color-mixer/pass.ts
@@ -1,39 +1,22 @@
-import { effect, type Gpu, type Target, target } from "vgpu";
-import type { SceneEffect } from "@/lib/editor/renderer";
+import type { ColorMixer } from "@/core/document";
+import { node } from "@/core/renderer";
import shader from "./mixer.wgsl";
import { colors, isNeutral } from "./model";
-/** Each renderer owns its output and reuses the same mixer pipeline. */
-export function createColorMixer(gpu: Gpu, source: Target): SceneEffect {
- let output: Target | undefined;
- const settings = gpu.device.createBuffer({
- size: colors.length * 4 * Float32Array.BYTES_PER_ELEMENT,
- usage: ["storage", "copy_dst"],
- });
- const apply = effect(gpu, shader, { set: { settings } });
- return {
- render(frame, input, scene) {
- const mixer = scene.colorMixer;
- if (!mixer || isNeutral(mixer)) {
- return input;
- }
- output ??= target(gpu, { size: source.size, format: source.format });
- settings.write(
- new Float32Array(
- colors.flatMap(({ angle }, index) => [
- mixer.hue[index],
- mixer.saturation[index],
- mixer.luminance[index],
- angle,
- ]),
- ),
- );
- frame.pass(output, apply.set({ source: input.color }));
- return output;
- },
- dispose() {
- output?.color.dispose();
- settings.dispose();
+export function colorMixer(mixer?: ColorMixer) {
+ if (!mixer || isNeutral(mixer)) {
+ return;
+ }
+ return node("color-mixer", shader, {
+ storage: {
+ settings: new Float32Array(
+ colors.flatMap(({ angle }, index) => [
+ mixer.hue[index],
+ mixer.saturation[index],
+ mixer.luminance[index],
+ angle,
+ ]),
+ ),
},
- };
+ });
}
diff --git a/src/features/crop/geometry.ts b/src/features/crop/geometry.ts
index 42145fe..df04fd9 100644
--- a/src/features/crop/geometry.ts
+++ b/src/features/crop/geometry.ts
@@ -1,8 +1,4 @@
-import {
- type ImageFrame,
- type Point,
- sourceOffset,
-} from "@/lib/image-frame/geometry";
+import { type ImageFrame, type Point, sourceOffset } from "@/core/image/frame";
import { clamp } from "@/lib/math";
function radius(frame: ImageFrame): Point {
diff --git a/src/features/crop/overlay.tsx b/src/features/crop/overlay.tsx
index ab32f2c..a6baa36 100644
--- a/src/features/crop/overlay.tsx
+++ b/src/features/crop/overlay.tsx
@@ -1,7 +1,7 @@
import { type PointerEvent, useRef } from "react";
import { useViewport } from "@/components/editor/viewport";
import rotateCursor from "@/components/icons/rotate-cursor.svg?raw";
-import type { ImageFrame, Point } from "@/lib/image-frame/geometry";
+import type { ImageFrame, Point } from "@/core/image/frame";
import { clamp } from "@/lib/math";
import { move, resize, rotate } from "./geometry";
diff --git a/src/features/crop/view.tsx b/src/features/crop/view.tsx
index 3325198..f5757af 100644
--- a/src/features/crop/view.tsx
+++ b/src/features/crop/view.tsx
@@ -11,8 +11,8 @@ import { RotateIcon } from "@/components/icons/rotate";
import Button from "@/components/ui/button";
import { Field } from "@/components/ui/field";
import { Slider } from "@/components/ui/slider";
+import { imageFrame, type Point } from "@/core/image/frame";
import { useShortcuts } from "@/hooks/use-shortcuts";
-import { imageFrame, type Point } from "@/lib/image-frame/geometry";
import { fitRatio, flip, rotate, turn } from "./geometry";
import { CropOverlay } from "./overlay";
diff --git a/src/features/histogram/histogram.wgsl b/src/features/histogram/histogram.wgsl
index d59e375..be21c3b 100644
--- a/src/features/histogram/histogram.wgsl
+++ b/src/features/histogram/histogram.wgsl
@@ -1,4 +1,4 @@
-import { display } from "../../lib/color.wgsl";
+import { display } from "../../core/image/color.wgsl";
import { linearToSrgb3 } from "@vgpu/wgsl-std/color";
struct Params {
diff --git a/src/lib/tone-curves/curve.ts b/src/features/tone-curves/curve.ts
similarity index 95%
rename from src/lib/tone-curves/curve.ts
rename to src/features/tone-curves/curve.ts
index 7befe1e..5736416 100644
--- a/src/lib/tone-curves/curve.ts
+++ b/src/features/tone-curves/curve.ts
@@ -1,8 +1,6 @@
+import type { CurvePoint, ToneCurve } from "@/core/document";
import { clamp, interpolatePchip } from "@/lib/math";
-export type CurvePoint = { readonly x: number; readonly y: number };
-export type ToneCurve = readonly CurvePoint[];
-
export const defaultCurve: ToneCurve = [
{ x: 0, y: 0 },
{ x: 1, y: 1 },
diff --git a/src/lib/tone-curves/curves.wgsl b/src/features/tone-curves/curves.wgsl
similarity index 100%
rename from src/lib/tone-curves/curves.wgsl
rename to src/features/tone-curves/curves.wgsl
diff --git a/src/features/tone-curves/edits.ts b/src/features/tone-curves/edits.ts
new file mode 100644
index 0000000..c68860a
--- /dev/null
+++ b/src/features/tone-curves/edits.ts
@@ -0,0 +1,13 @@
+import type { EditorDocument, ToneCurve } from "@/core/document";
+import { defaultCurve, validateCurve } from "./curve";
+
+export function setToneCurve(
+ document: EditorDocument,
+ points: ToneCurve = defaultCurve,
+) {
+ validateCurve(points);
+ document.edit({
+ ...document.scene.getState(),
+ toneCurve: points.map((point) => ({ ...point })),
+ });
+}
diff --git a/src/features/tone-curves/graph.tsx b/src/features/tone-curves/graph.tsx
index 4ced426..21b80c6 100644
--- a/src/features/tone-curves/graph.tsx
+++ b/src/features/tone-curves/graph.tsx
@@ -4,15 +4,14 @@ import {
type PointerEvent,
useState,
} from "react";
+import type { CurvePoint, ToneCurve } from "@/core/document";
import { clamp } from "@/lib/math";
import {
- type CurvePoint,
insertCurvePoint,
moveCurvePoint,
removeCurvePoint,
sampleCurve,
- type ToneCurve,
-} from "@/lib/tone-curves/curve";
+} from "./curve";
function gridLines(spacing: number) {
return Array.from({ length: 256 / spacing - 1 }, (_, index) => {
diff --git a/src/features/tone-curves/pass.ts b/src/features/tone-curves/pass.ts
new file mode 100644
index 0000000..19005f3
--- /dev/null
+++ b/src/features/tone-curves/pass.ts
@@ -0,0 +1,13 @@
+import type { ToneCurve } from "@/core/document";
+import { node } from "@/core/renderer";
+import { sampleCurve } from "./curve";
+import shader from "./curves.wgsl";
+
+export function toneCurves(points: ToneCurve) {
+ if (points.every((point) => point.x === point.y)) {
+ return;
+ }
+ return node("curves", shader, {
+ storage: { curve: sampleCurve(points, 1024) },
+ });
+}
diff --git a/src/features/tone-curves/tone-curves.tsx b/src/features/tone-curves/tone-curves.tsx
index 2dc22ad..7075024 100644
--- a/src/features/tone-curves/tone-curves.tsx
+++ b/src/features/tone-curves/tone-curves.tsx
@@ -1,6 +1,7 @@
import type { ReactNode } from "react";
import Button from "@/components/ui/button";
-import { defaultCurve, type ToneCurve } from "@/lib/tone-curves/curve";
+import type { ToneCurve } from "@/core/document";
+import { defaultCurve } from "./curve";
import { Graph } from "./graph";
type ToneCurvesProps = {
diff --git a/src/features/vignette/edits.ts b/src/features/vignette/edits.ts
index b0fc4c1..cadb98e 100644
--- a/src/features/vignette/edits.ts
+++ b/src/features/vignette/edits.ts
@@ -1,5 +1,4 @@
-import type { EditorDocument } from "@/lib/editor/document";
-import type { Vignette } from "@/lib/editor/scene";
+import type { EditorDocument, Vignette } from "@/core/document";
import { defaultVignette } from "./model";
export function setVignette(
diff --git a/src/features/vignette/model.ts b/src/features/vignette/model.ts
index 841d4c0..106f980 100644
--- a/src/features/vignette/model.ts
+++ b/src/features/vignette/model.ts
@@ -1,4 +1,4 @@
-import type { Vignette } from "@/lib/editor/scene";
+import type { Vignette } from "@/core/document";
export const defaultVignette: Readonly<Vignette> = {
intensity: 0,
diff --git a/src/features/vignette/pass.ts b/src/features/vignette/pass.ts
index bda44c5..fe4b8c2 100644
--- a/src/features/vignette/pass.ts
+++ b/src/features/vignette/pass.ts
@@ -1,22 +1,12 @@
-import { effect, type Gpu, type Target, target } from "vgpu";
-import type { SceneEffect } from "@/lib/editor/renderer";
+import type { Vignette } from "@/core/document";
+import { node } from "@/core/renderer";
import shader from "./vignette.wgsl";
-export function createVignette(gpu: Gpu, source: Target): SceneEffect {
- const apply = effect(gpu, shader);
- let output: Target | undefined;
- return {
- render(frame, input, scene) {
- const vignette = scene.vignette;
- if (!vignette || vignette.intensity === 0) {
- return input;
- }
- output ??= target(gpu, { size: source.size, format: source.format });
- frame.pass(output, apply.set({ source: input.color, params: vignette }));
- return output;
- },
- dispose() {
- output?.color.dispose();
- },
- };
+export function vignette(settings?: Vignette) {
+ if (!settings || settings.intensity === 0) {
+ return;
+ }
+ return node("vignette", shader, {
+ set: { params: settings },
+ });
}
diff --git a/src/features/white-balance/edits.ts b/src/features/white-balance/edits.ts
index 357ce97..a256b32 100644
--- a/src/features/white-balance/edits.ts
+++ b/src/features/white-balance/edits.ts
@@ -1,5 +1,5 @@
-import type { EditorDocument } from "@/lib/editor/document";
-import type { WhiteBalance } from "@/lib/image-source";
+import type { EditorDocument } from "@/core/document";
+import type { WhiteBalance } from "@/core/image";
export function whiteBalanceLimits(asShot: WhiteBalance) {
return {
diff --git a/src/hooks/use-pan-zoom.ts b/src/hooks/use-pan-zoom.ts
index 48d1aec..d011df8 100644
--- a/src/hooks/use-pan-zoom.ts
+++ b/src/hooks/use-pan-zoom.ts
@@ -9,7 +9,7 @@ import {
import { useStore } from "zustand";
import { createStore } from "zustand/vanilla";
-import type { View } from "@/lib/image-display";
+import type { View } from "@/core/renderer";
type Size = readonly [number, number, ...unknown[]];
type Point = readonly [number, number];
diff --git a/src/lib/adjustments/index.ts b/src/lib/adjustments/index.ts
deleted file mode 100644
index 64d1274..0000000
--- a/src/lib/adjustments/index.ts
+++ /dev/null
@@ -1,46 +0,0 @@
-import {
- effect,
- type Frame,
- type Gpu,
- sampler,
- type Target,
- target,
-} from "vgpu";
-import shader from "./adjustments.wgsl";
-
-/** UI units: exposure in stops, every other adjustment in -100..100. */
-export type Adjustments = {
- exposure: number;
- incrementalTemperature: number;
- incrementalTint: number;
- contrast: number;
- highlights: number;
- shadows: number;
- whites: number;
- blacks: number;
- vibrance: number;
- saturation: number;
-};
-
-/** Owns the adjustment pass and output for one source. */
-export function createAdjustments(gpu: Gpu, source: Target) {
- const output = target(gpu, { size: source.size, format: source.format });
- const apply = effect(gpu, shader, {
- set: {
- source: source.color,
- sourceSampler: sampler(gpu, {
- minFilter: "linear",
- magFilter: "linear",
- }),
- },
- });
- return {
- output,
- render(frame: Frame, adjustments: Adjustments, input = source) {
- frame.pass(output, apply.set({ adjustments, source: input.color }));
- },
- dispose() {
- output.color.dispose();
- },
- };
-}
diff --git a/src/lib/editor/scene.ts b/src/lib/editor/scene.ts
deleted file mode 100644
index 1312eda..0000000
--- a/src/lib/editor/scene.ts
+++ /dev/null
@@ -1,71 +0,0 @@
-import type { Adjustments as ToneAdjustments } from "@/lib/adjustments";
-import type { ImageFrame } from "@/lib/image-frame/geometry";
-import type { WhiteBalance } from "@/lib/image-source";
-import type { ToneCurve } from "@/lib/tone-curves/curve";
-
-export type Adjustments = ToneAdjustments & {
- clarity: number;
- sharpening: number;
- sharpenRadius: number;
-};
-
-export const defaultAdjustments: Adjustments = {
- exposure: 0,
- incrementalTemperature: 0,
- incrementalTint: 0,
- contrast: 0,
- highlights: 0,
- shadows: 0,
- whites: 0,
- blacks: 0,
- vibrance: 0,
- saturation: 0,
- clarity: 0,
- sharpening: 0,
- sharpenRadius: 1,
-};
-
-export const adjustmentLimits: Adjustments = {
- exposure: 5,
- incrementalTemperature: 100,
- incrementalTint: 100,
- contrast: 100,
- highlights: 100,
- shadows: 100,
- whites: 100,
- blacks: 100,
- vibrance: 100,
- saturation: 100,
- clarity: 100,
- sharpening: 150,
- sharpenRadius: 3,
-};
-
-export const adjustmentMinimums: Partial<Adjustments> = {
- sharpening: 0,
- sharpenRadius: 0.5,
-};
-
-/** Eight color ranges, ordered red through magenta; values use -100..100 UI units. */
-export type ColorMixer = {
- readonly hue: readonly number[];
- readonly saturation: readonly number[];
- readonly luminance: readonly number[];
-};
-
-/** Source-centered darkening in 0..100 UI units. */
-export type Vignette = {
- readonly intensity: number;
- readonly softness: number;
-};
-
-/** Serializable document content. Image bytes and GPU resources live elsewhere. */
-export type Scene = {
- readonly frame: ImageFrame;
- readonly source: string;
- readonly whiteBalance?: Readonly<WhiteBalance>;
- readonly adjustments: Readonly<Adjustments>;
- readonly toneCurve: ToneCurve;
- readonly colorMixer?: ColorMixer;
- readonly vignette?: Vignette;
-};
diff --git a/src/lib/image-frame/index.ts b/src/lib/image-frame/index.ts
deleted file mode 100644
index d80c3f6..0000000
--- a/src/lib/image-frame/index.ts
+++ /dev/null
@@ -1,63 +0,0 @@
-import {
- effect,
- type Frame,
- type Gpu,
- sampler,
- type Target,
- target,
-} from "vgpu";
-import shader from "./frame.wgsl";
-import {
- frameTransform,
- frameValues,
- type ImageFrame,
- imageFrame,
-} from "./geometry";
-
-/** Transforms image outputs; equal inputs share a target and identity preserves the source. */
-export function createImageFrame(gpu: Gpu) {
- const apply = effect(gpu, shader, {
- set: {
- sourceSampler: sampler(gpu, { magFilter: "linear", minFilter: "linear" }),
- },
- });
- const outputs = new Map<Target, Target>();
- return {
- render(frame: Frame, sources: Target[], geometry: ImageFrame) {
- const initial = frameValues(imageFrame(sources[0].size));
- if (frameValues(geometry).every((value, i) => value === initial[i])) {
- return sources;
- }
- const rendered = new Set<Target>();
- return sources.map((source) => {
- const size: [number, number] = [
- Math.round(geometry.size[0]),
- Math.round(geometry.size[1]),
- ];
- let output = outputs.get(source);
- if (!output) {
- output = target(gpu, { size, format: source.format });
- outputs.set(source, output);
- }
- output.resize(size);
- if (!rendered.has(source)) {
- frame.pass(
- output,
- apply.set({
- source: source.color,
- transform: frameTransform(geometry, source.size),
- }),
- );
- }
- rendered.add(source);
- return output;
- });
- },
- dispose() {
- for (const output of outputs.values()) {
- output.color.dispose();
- }
- outputs.clear();
- },
- };
-}
diff --git a/src/lib/tone-curves/index.ts b/src/lib/tone-curves/index.ts
deleted file mode 100644
index 0df3d00..0000000
--- a/src/lib/tone-curves/index.ts
+++ /dev/null
@@ -1,28 +0,0 @@
-import { effect, type Frame, type Gpu, type Target, target } from "vgpu";
-import { sampleCurve, type ToneCurve } from "./curve";
-import shader from "./curves.wgsl";
-
-const curveSize = 1024;
-
-export function createToneCurves(gpu: Gpu, source: Target) {
- const output = target(gpu, { size: source.size, format: source.format });
- const curve = gpu.device.createBuffer({
- size: curveSize * Float32Array.BYTES_PER_ELEMENT,
- usage: ["storage", "copy_dst"],
- });
- const apply = effect(gpu, shader, { set: { source: source.color, curve } });
- return {
- render(frame: Frame, points: ToneCurve) {
- if (points.every((point) => point.x === point.y)) {
- return source;
- }
- curve.write(sampleCurve(points, curveSize));
- frame.pass(output, apply);
- return output;
- },
- dispose() {
- output.color.dispose();
- curve.dispose();
- },
- };
-}
diff --git a/src/lib/unsharp-mask/index.ts b/src/lib/unsharp-mask/index.ts
deleted file mode 100644
index 96709ef..0000000
--- a/src/lib/unsharp-mask/index.ts
+++ /dev/null
@@ -1,63 +0,0 @@
-import {
- effect,
- type Frame,
- type Gpu,
- sampler,
- type Target,
- target,
-} from "vgpu";
-import shader from "./unsharp-mask.wgsl";
-
-/** Owns a separable luminance blur and unsharp-mask output. Radius is Gaussian sigma in source pixels. */
-export function createUnsharpMask(gpu: Gpu, source: Target, reduction = 1) {
- const size: [number, number] = [
- Math.ceil(source.size[0] / reduction),
- Math.ceil(source.size[1] / reduction),
- ];
- const modes = reduction === 1 ? [1, 2] : [0, 1, 2];
- const temporary = Array.from({ length: modes.length }, () =>
- target(gpu, { size, format: "rgba16float" }),
- );
- const output = target(gpu, { size: source.size, format: source.format });
- const linearSampler = sampler(gpu, {
- minFilter: "linear",
- magFilter: "linear",
- });
- // Reduce, blur horizontally, blur vertically, reconstruct. Each pass owns its uniforms.
- const passes = Array.from({ length: 4 }, (_, mode) =>
- effect(gpu, shader, {
- set: {
- base: source.color,
- linearSampler,
- params: { mode, reduction, amount: 0, sigma: 1 },
- },
- }),
- );
- return {
- render(frame: Frame, input: Target, amount: number, radius: number) {
- if (amount === 0) return input;
- const params = { reduction, amount, sigma: radius / reduction };
- for (const [i, image] of temporary.entries()) {
- frame.pass(
- image,
- passes[modes[i]].set({
- params: { ...params, mode: modes[i] },
- source: i === 0 ? input.color : temporary[i - 1].color,
- }),
- );
- }
- frame.pass(
- output,
- passes[3].set({
- source: input.color,
- base: temporary[temporary.length - 1].color,
- params: { ...params, mode: 3 },
- }),
- );
- return output;
- },
- dispose() {
- for (const image of [...temporary, output]) image.color.dispose();
- },
- };
-}
diff --git a/src/main.tsx b/src/main.tsx
index 001bd81..6170fee 100644
--- a/src/main.tsx
+++ b/src/main.tsx
@@ -3,7 +3,7 @@ import { SpeedInsights } from "@vercel/speed-insights/react";
import { createRoot } from "react-dom/client";
import { GpuProvider } from "vgpu-react";
-import App from "./app";
+import App from "@/app";
import "./index.css";
const root = document.getElementById("root");
diff --git a/tests/color-mixer-gpu.ts b/tests/color-mixer-gpu.ts
index b435762..474df04 100644
--- a/tests/color-mixer-gpu.ts
+++ b/tests/color-mixer-gpu.ts
@@ -1,9 +1,12 @@
import { effect, frame, init, target } from "vgpu";
+import type { ColorMixer } from "@/core/document";
+import {
+ createRenderGraph,
+ input as inputNode,
+ pipeline,
+} from "@/core/renderer";
import { colors, defaultMixer } from "@/features/color-mixer/model";
-import { createColorMixer } from "@/features/color-mixer/pass";
-import { type ColorMixer, defaultAdjustments } from "@/lib/editor/scene";
-import { imageFrame } from "@/lib/image-frame/geometry";
-import { defaultCurve } from "@/lib/tone-curves/curve";
+import { colorMixer } from "@/features/color-mixer/pass";
function working(rgb: number[], scale = 1) {
const [r, g, b] = rgb.map((value) =>
@@ -64,13 +67,7 @@ export async function probeColorMixer() {
`,
{ set: { samples: data } },
);
- const mixer = createColorMixer(gpu, input);
- const scene = {
- source: "probe",
- frame: imageFrame(input.size),
- adjustments: defaultAdjustments,
- toneCurve: defaultCurve,
- };
+ const graph = createRenderGraph(gpu);
const uniform = (channel: keyof ColorMixer, value: number): ColorMixer => ({
...defaultMixer,
[channel]: colors.map(() => value),
@@ -88,7 +85,7 @@ export async function probeColorMixer() {
await gpu.gpu.queue.onSubmittedWorkDone();
const original = [...(await input.readFloats())];
const outputs = [];
- for (const colorMixer of [
+ for (const settings of [
defaultMixer,
uniform("hue", 100),
uniform("hue", -100),
@@ -98,15 +95,14 @@ export async function probeColorMixer() {
selected(5, "saturation", -100),
selected(0, "hue", 100),
]) {
- let output = input;
- frame(gpu, (f) => {
- output = mixer.render(f, input, { ...scene, colorMixer });
- });
+ const [output] = graph.render([
+ pipeline(inputNode(input), [colorMixer(settings)]),
+ ]);
outputs.push([...(await output.readFloats())]);
}
return { original, outputs, sampleCount: samples.length };
} finally {
- mixer.dispose();
+ graph.dispose();
input.color.dispose();
data.dispose();
gpu.dispose();
diff --git a/tests/color-mixer.test.ts b/tests/color-mixer.test.ts
index 3900fe6..3ed5df2 100644
--- a/tests/color-mixer.test.ts
+++ b/tests/color-mixer.test.ts
@@ -1,12 +1,12 @@
import { expect, test } from "bun:test";
import { getMockGPUDeviceInstrumentation, init, target } from "vgpu/mock";
import { createEditorRenderer } from "@/app/editor/renderer";
+import { createDocument } from "@/core/document";
+import { createImageSource } from "@/core/image";
+import { imageFrame } from "@/core/image/frame";
+import { defaultAdjustments } from "@/features/adjustments/model";
import { resetColorMixer, setColorMixer } from "@/features/color-mixer/edits";
-import { createDocument } from "@/lib/editor/document";
-import { defaultAdjustments } from "@/lib/editor/scene";
-import { imageFrame } from "@/lib/image-frame/geometry";
-import { createImageSource } from "@/lib/image-source";
-import { defaultCurve } from "@/lib/tone-curves/curve";
+import { defaultCurve } from "@/features/tone-curves/curve";
test("color edits validate, group, cancel and reset while renderers reuse and release their outputs", async () => {
const gpu = await init();
@@ -50,7 +50,7 @@ test("color edits validate, group, cancel and reset while renderers reuse and re
expect(renderer.outputImage()).toBe(original);
document.history.redo();
await renderer.update(document.scene.getState());
- expect(renderer.outputImage()).toBe(edited);
+ expect(renderer.inspect().passes).toEqual(["adjustments", "color-mixer"]);
expect(calls.createRenderPipeline).toBe(pipelines);
for (const value of [NaN, Infinity, -101, 101]) {
expect(() => setColorMixer(document, "red", { hue: value })).toThrow(
diff --git a/tests/crop.test.ts b/tests/crop.test.ts
index b2f6785..b19e4cd 100644
--- a/tests/crop.test.ts
+++ b/tests/crop.test.ts
@@ -1,4 +1,11 @@
import { expect, test } from "bun:test";
+import {
+ frameTransform,
+ type ImageFrame,
+ imageFrame,
+ type Point,
+ validateFrame,
+} from "@/core/image/frame";
import {
fitRatio,
flip,
@@ -7,13 +14,6 @@ import {
rotate,
turn,
} from "@/features/crop/geometry";
-import {
- frameTransform,
- type ImageFrame,
- imageFrame,
- type Point,
- validateFrame,
-} from "@/lib/image-frame/geometry";
const source: Point = [1200, 800];
function sample(frame: ImageFrame, x: number, y: number) {
diff --git a/tests/curves.test.ts b/tests/curves.test.ts
index bbdd5a9..e924842 100644
--- a/tests/curves.test.ts
+++ b/tests/curves.test.ts
@@ -1,6 +1,6 @@
import { expect, test } from "bun:test";
+import { sampleCurve } from "@/features/tone-curves/curve";
import { interpolatePchip } from "@/lib/math";
-import { sampleCurve } from "@/lib/tone-curves/curve";
test("curves interpolate smoothly through their handles without overshoot", () => {
const identity = [
diff --git a/tests/documents.test.ts b/tests/documents.test.ts
index 3fb5039..6c2c7ed 100644
--- a/tests/documents.test.ts
+++ b/tests/documents.test.ts
@@ -1,13 +1,13 @@
import { expect, test } from "bun:test";
import { init, target } from "vgpu/mock";
import { createWorkspace } from "@/app/workspace";
-import { createDocument } from "@/lib/editor/document";
-import { setAdjustments, setToneCurve } from "@/lib/editor/document/edits";
-import { createResources } from "@/lib/editor/document/resources";
-import { defaultAdjustments } from "@/lib/editor/scene";
-import { imageFrame } from "@/lib/image-frame/geometry";
-import { createImageSource } from "@/lib/image-source";
-import { defaultCurve } from "@/lib/tone-curves/curve";
+import { createDocument, createResources } from "@/core/document";
+import { createImageSource } from "@/core/image";
+import { imageFrame } from "@/core/image/frame";
+import { setAdjustments } from "@/features/adjustments/edits";
+import { defaultAdjustments } from "@/features/adjustments/model";
+import { defaultCurve } from "@/features/tone-curves/curve";
+import { setToneCurve } from "@/features/tone-curves/edits";
function document() {
return createDocument({
diff --git a/tests/editing.e2e.ts b/tests/editing.e2e.ts
index 55ab96d..3fb3e7d 100644
--- a/tests/editing.e2e.ts
+++ b/tests/editing.e2e.ts
@@ -1,6 +1,6 @@
import { readFile } from "node:fs/promises";
import type { Page } from "@playwright/test";
-import { type ImageFrame, imageFrame } from "@/lib/image-frame/geometry";
+import { type ImageFrame, imageFrame } from "@/core/image/frame";
import { interpolatePchip } from "@/lib/math";
import { colorMixerEditing } from "./color-mixer-editing";
import { expect, test } from "./fixtures";
diff --git a/tests/loaders.test.ts b/tests/loaders.test.ts
index 706e620..bc1a244 100644
--- a/tests/loaders.test.ts
+++ b/tests/loaders.test.ts
@@ -2,12 +2,12 @@ import { expect, test } from "bun:test";
import { createCameraRawXmpLoader } from "@/app/loaders/camera-raw-xmp";
import { createLoaderRegistry, type FileLoader } from "@/app/loaders/registry";
import { createWorkspace } from "@/app/workspace";
-import { canDecode } from "@/lib/decode";
-import { createDocument } from "@/lib/editor/document";
-import { setAdjustments } from "@/lib/editor/document/edits";
-import { defaultAdjustments } from "@/lib/editor/scene";
-import { imageFrame } from "@/lib/image-frame/geometry";
-import { defaultCurve } from "@/lib/tone-curves/curve";
+import { createDocument } from "@/core/document";
+import { canDecode } from "@/core/image/decode";
+import { imageFrame } from "@/core/image/frame";
+import { setAdjustments } from "@/features/adjustments/edits";
+import { defaultAdjustments } from "@/features/adjustments/model";
+import { defaultCurve } from "@/features/tone-curves/curve";
function settings(attributes: string, name = "photo.xmp") {
return new File(
diff --git a/tests/render-graph.test.ts b/tests/render-graph.test.ts
new file mode 100644
index 0000000..a86caba
--- /dev/null
+++ b/tests/render-graph.test.ts
@@ -0,0 +1,122 @@
+import { expect, test } from "bun:test";
+import { getMockGPUDeviceInstrumentation, init, target } from "vgpu/mock";
+import {
+ createRenderGraph,
+ input,
+ merge,
+ node,
+ pipeline,
+ split,
+} from "@/core/renderer";
+
+const shader = `
+@group(0) @binding(0) var source: texture_2d<f32>;
+@group(0) @binding(1) var base: texture_2d<f32>;
+@group(0) @binding(2) var<storage, read> weights: array<f32>;
+@fragment fn fs_main(@builtin(position) p: vec4f) -> @location(0) vec4f {
+ return mix(textureLoad(source, vec2i(p.xy), 0), textureLoad(base, vec2i(p.xy), 0), weights[0]);
+}`;
+const options = { storage: { weights: new Float32Array([0.5]) } };
+
+test("pipeline and split preserve order, bypasses, and named merge inputs", async () => {
+ const gpu = await init();
+ const image = target(gpu, { size: [8, 4], format: "rgba16float" });
+ const source = input(image);
+ try {
+ const first = node("first", shader);
+ const last = node("last", shader);
+ const result = pipeline(source, [
+ first,
+ undefined,
+ (image) => pipeline(image, [last]),
+ ]);
+ expect(result).toMatchObject({
+ name: "last",
+ inputs: { source: { name: "first", inputs: { source } } },
+ });
+ expect(pipeline(source, [undefined])).toBe(source);
+ const [unchanged, small] = split(result, [
+ [],
+ [node("small", shader, { size: [2, 1] })],
+ ]);
+ expect(unchanged).toBe(result);
+ expect(small).toMatchObject({ inputs: { source: result }, size: [2, 1] });
+ const joined = merge({ base: source, source: small }, node("join", shader));
+ expect(joined.inputs.base).toBe(source);
+ expect(joined.inputs.source).toBe(small);
+ expect(joined.size).toEqual([8, 4]);
+ expect(joined.format).toBe("rgba16float");
+ expect(
+ getMockGPUDeviceInstrumentation(gpu.gpu).calls.createRenderPipeline ?? 0,
+ ).toBe(0);
+ } finally {
+ image.color.dispose();
+ gpu.dispose();
+ }
+});
+
+test("a shared branch renders once and reuses effects, buffers, and temporary storage", async () => {
+ const gpu = await init();
+ const image = target(gpu, { size: [8, 8], format: "rgba16float" });
+ const source = input(image);
+ const graph = createRenderGraph(gpu);
+ const shared = merge(
+ { source, base: source },
+ node("shared", shader, options),
+ );
+ const middle = merge(
+ { source: shared, base: shared },
+ node("middle", shader, options),
+ );
+ const branch = merge(
+ { source: middle, base: middle },
+ node("branch", shader, options),
+ );
+ const joined = merge(
+ { source: shared, base: branch },
+ node("join", shader, options),
+ );
+ try {
+ const [saved, output] = graph.render([shared, joined]);
+ expect(output).not.toBe(saved);
+ expect(graph.inspect().passes).toEqual([
+ "shared",
+ "middle",
+ "branch",
+ "join",
+ ]);
+ expect(graph.inspect().textures).toHaveLength(3);
+ const calls = getMockGPUDeviceInstrumentation(gpu.gpu).calls;
+ const buffers = calls.createBuffer;
+ const pipelines = calls.createRenderPipeline;
+ expect(graph.render([shared, joined])).toEqual([saved, output]);
+ expect(graph.render([joined, shared, joined])).toEqual([
+ output,
+ saved,
+ output,
+ ]);
+ expect(calls.createBuffer).toBe(buffers);
+ expect(calls.createRenderPipeline).toBe(pipelines);
+ // Bypassing releases scratch storage; a changed output size reuses the remaining target.
+ expect(graph.render([shared])[0]).toBe(saved);
+ expect(graph.inspect().textures).toHaveLength(1);
+ expect(() => output.color.view).toThrow("destroyed");
+ const small = merge(
+ { source, base: source },
+ node("shared", shader, {
+ ...options,
+ size: [4, 4],
+ }),
+ );
+ expect(graph.render([small])[0].size).toEqual([4, 4]);
+ expect(graph.inspect().textures).toHaveLength(1);
+ graph.dispose();
+ expect(() => saved.color.view).toThrow("destroyed");
+ expect(() => image.color.view).not.toThrow();
+ expect(() => graph.render([shared])).toThrow("closed");
+ } finally {
+ graph.dispose();
+ image.color.dispose();
+ gpu.dispose();
+ }
+});
diff --git a/tests/renderer.test.ts b/tests/renderer.test.ts
index b9eec12..f8682d2 100644
--- a/tests/renderer.test.ts
+++ b/tests/renderer.test.ts
@@ -6,17 +6,22 @@ import {
init,
target,
} from "vgpu/mock";
+import { createEditorRenderer as createRenderer } from "@/app/editor/renderer";
+import { createDocument, createResources } from "@/core/document";
+import { createImageSource } from "@/core/image";
+import { imageFrame } from "@/core/image/frame";
+import {
+ createDisplay,
+ createRenderGraph,
+ input,
+ pipeline,
+} from "@/core/renderer";
+import { setAdjustments } from "@/features/adjustments/edits";
+import { defaultAdjustments } from "@/features/adjustments/model";
+import { unsharpMask } from "@/features/adjustments/unsharp-mask";
+import { defaultCurve } from "@/features/tone-curves/curve";
+import { setToneCurve } from "@/features/tone-curves/edits";
import { setWhiteBalance } from "@/features/white-balance/edits";
-import { createDocument } from "@/lib/editor/document";
-import { setAdjustments, setToneCurve } from "@/lib/editor/document/edits";
-import { createResources } from "@/lib/editor/document/resources";
-import { createRenderer } from "@/lib/editor/renderer";
-import { defaultAdjustments } from "@/lib/editor/scene";
-import { createDisplay } from "@/lib/image-display";
-import { imageFrame } from "@/lib/image-frame/geometry";
-import { createImageSource } from "@/lib/image-source";
-import { defaultCurve } from "@/lib/tone-curves/curve";
-import { createUnsharpMask } from "@/lib/unsharp-mask";
test("RAW edits coalesce, recover from failure, and retain an exporting source after document replacement", async () => {
const gpu = await init();
@@ -121,21 +126,24 @@ test("RAW edits coalesce, recover from failure, and retain an exporting source a
});
test.each([1, 16])(
- "unsharp mask at reduction %s bypasses zero, reuses pipelines, and owns its outputs",
+ "unsharp mask at reduction %s bypasses zero and shares graph storage",
async (reduction) => {
const gpu = await init();
const source = target(gpu, { size: [127, 65], format: "rgba16float" });
- const clarity = createUnsharpMask(gpu, source, reduction);
+ const graph = createRenderGraph(gpu);
let output = source;
- const render = (amount: number) =>
- frame(gpu, (f) => {
- output = clarity.render(
- f,
- source,
- amount / 200,
- reduction === 1 ? 1 : 64,
- );
- });
+ const render = (amount: number) => {
+ [output] = graph.render([
+ pipeline(input(source), [
+ unsharpMask(
+ "detail",
+ amount / 200,
+ reduction === 1 ? 1 : 64,
+ reduction,
+ ),
+ ]),
+ ]);
+ };
try {
render(0);
expect(output).toBe(source);
@@ -146,6 +154,7 @@ test.each([1, 16])(
expect(filtered).not.toBe(source);
expect(filtered.size).toEqual(source.size);
const pipelines = calls.createRenderPipeline;
+ expect(graph.inspect().textures).toHaveLength(reduction === 1 ? 2 : 3);
for (const amount of [-100, -50, 25, 75]) {
render(amount);
expect(output).toBe(filtered);
@@ -153,11 +162,12 @@ test.each([1, 16])(
expect(calls.createRenderPipeline).toBe(pipelines);
render(0);
expect(output).toBe(source);
- clarity.dispose();
+ expect(graph.inspect().textures).toHaveLength(0);
+ graph.dispose();
expect(() => filtered.color.view).toThrow("destroyed");
expect(() => source.color.view).not.toThrow();
} finally {
- clarity.dispose();
+ graph.dispose();
source.color.dispose();
gpu.dispose();
}
@@ -230,12 +240,12 @@ test("rendering follows grouped edits and undo, reuses pipelines, and releases o
expect(renderer.outputImage()).toBe(adjusted);
expect(document.scene.getState().adjustments.exposure).toBe(0);
document.history.redo();
- expect(renderer.outputImage()).toBe(curved);
+ expect(renderer.inspect().passes).toEqual(["adjustments", "curves"]);
document.history.begin();
setToneCurve(document);
expect(renderer.outputImage()).toBe(adjusted);
document.history.cancel();
- expect(renderer.outputImage()).toBe(curved);
+ expect(renderer.inspect().passes).toEqual(["adjustments", "curves"]);
draw();
expect(calls.createRenderPipeline).toBe(pipelines);
expect(notify).toHaveBeenCalledTimes(8);
diff --git a/tests/rendering-benchmark.ts b/tests/rendering-benchmark.ts
index 8b747e7..0df63e3 100644
--- a/tests/rendering-benchmark.ts
+++ b/tests/rendering-benchmark.ts
@@ -1,17 +1,18 @@
-import { effect, type Frame, frame, init, target, timer } from "vgpu";
+import { effect, frame, init, target, timer } from "vgpu";
import { encodeImage } from "@/app/editor/export/export-image";
-import { createRenderer } from "@/lib/editor/renderer";
-import { defaultAdjustments, type Scene } from "@/lib/editor/scene";
-import { imageFrame } from "@/lib/image-frame/geometry";
-import { createImageSource } from "@/lib/image-source";
-import { defaultCurve } from "@/lib/tone-curves/curve";
+import { createEditorRenderer } from "@/app/editor/renderer";
+import type { Scene } from "@/core/document";
+import { createImageSource } from "@/core/image";
+import { imageFrame } from "@/core/image/frame";
+import { defaultAdjustments } from "@/features/adjustments/model";
+import { defaultCurve } from "@/features/tone-curves/curve";
export type Workload =
- | "baseline"
| "neutral"
- | "active"
- | "vignette-neutral"
- | "vignette-active";
+ | "color-mixer"
+ | "vignette"
+ | "detail"
+ | "pipeline";
function summarize(values: number[]) {
const sorted = values.toSorted((a, b) => a - b);
@@ -25,7 +26,7 @@ function summarize(values: number[]) {
};
}
-/** Runs the production passes offscreen; React, display, and export encoding are outside timings. */
+/** Repeated processing of a resident texture; decoding, display, and export are outside timings. */
export async function benchmarkRendering(
workload: Workload,
size: [number, number],
@@ -38,9 +39,6 @@ export async function benchmarkRendering(
"No WebGPU adapter. Use the project's Playwright configuration.",
);
}
- const isVignette = workload.startsWith("vignette-");
- const active = workload === "active" || workload === "vignette-active";
- const passName = isVignette ? "vignette" : "color-mixer";
const timestamps = adapter.features.has("timestamp-query");
const gpu = await init({
requiredFeatures: timestamps ? ["timestamp-query"] : [],
@@ -50,19 +48,35 @@ export async function benchmarkRendering(
const input = target(gpu, { size, format: "rgba16float" });
const source = createImageSource(input);
const clock = timestamps ? timer(gpu) : undefined;
- let passMs: number | undefined;
- clock?.onResults((spans) => {
- passMs = spans[passName];
+ const measurements: Record<string, number>[] = [];
+ clock?.onResults((results) => {
+ measurements.push(results);
});
- const intensity = active ? 80 : 0;
+ const combined = workload === "pipeline";
+ const detail = combined || workload === "detail";
const scene: Scene = {
source: "benchmark",
frame: imageFrame(size),
- adjustments: { ...defaultAdjustments, exposure: 0.25, contrast: 10 },
- toneCurve: defaultCurve,
- vignette: isVignette ? { intensity, softness: 60 } : undefined,
+ adjustments: {
+ ...defaultAdjustments,
+ exposure: 0.25,
+ contrast: 10,
+ clarity: detail ? 50 : 0,
+ sharpening: detail ? 75 : 0,
+ },
+ toneCurve: combined
+ ? [
+ { x: 0, y: 0 },
+ { x: 0.5, y: 0.6 },
+ { x: 1, y: 1 },
+ ]
+ : defaultCurve,
+ vignette:
+ combined || workload === "vignette"
+ ? { intensity: 80, softness: 60 }
+ : undefined,
colorMixer:
- workload === "active"
+ combined || workload === "color-mixer"
? {
hue: new Array<number>(8).fill(20),
saturation: new Array<number>(8).fill(25),
@@ -70,67 +84,47 @@ export async function benchmarkRendering(
}
: undefined,
};
- // The baseline also runs against revisions predating the mixer.
- const path = "/src/features/color-mixer/pass.ts";
- const createMixer =
- workload === "baseline"
- ? undefined
- : (
- (await import(
- /* @vite-ignore */ path
- )) as typeof import("@/features/color-mixer/pass")
- ).createColorMixer;
- const vignettePath = "/src/features/vignette/pass.ts";
- const createVignette = isVignette
- ? (
- (await import(
- /* @vite-ignore */ vignettePath
- )) as typeof import("@/features/vignette/pass")
- ).createVignette
- : undefined;
- const editorPath = "/src/app/editor/renderer.ts";
- const createEditorRenderer = isVignette
- ? (
- (await import(
- /* @vite-ignore */ editorPath
- )) as typeof import("@/app/editor/renderer")
- ).createEditorRenderer
- : undefined;
const setupStart = performance.now();
- const renderer = createEditorRenderer
- ? createEditorRenderer(gpu, source)
- : createRenderer(gpu, source, createMixer);
+ let renderer = createEditorRenderer(gpu, source);
const rendererSetupMs = performance.now() - setupStart;
- const isolatedEffect = (createVignette ?? createMixer)?.(gpu, input);
- async function measure(render: () => void | Promise<void>, timed: boolean) {
+ async function measure() {
const encoding: number[] = [];
const completed: number[] = [];
- const durations: number[] = [];
+ const totals: number[] = [];
+ const nodes: Record<string, number[]> = {};
for (let i = 0; i < warmup + samples; i++) {
- passMs = undefined;
const start = performance.now();
- await render();
+ await renderer.update(scene);
const encoded = performance.now();
await gpu.gpu.queue.onSubmittedWorkDone();
const end = performance.now();
await gpu.settled();
+ const spans = measurements.pop();
if (errors.length) {
throw errors[0];
}
if (i >= warmup) {
encoding.push(encoded - start);
completed.push(end - start);
- if (passMs !== undefined) {
- durations.push(passMs);
+ if (spans) {
+ totals.push(Object.values(spans).reduce((sum, ms) => sum + ms, 0));
+ for (const [name, ms] of Object.entries(spans)) {
+ nodes[name] ??= [];
+ nodes[name].push(ms);
+ }
}
}
}
return {
cpuEncodeMs: summarize(encoding),
completedMs: summarize(completed),
- gpuMs: timed && durations.length ? summarize(durations) : null,
- missingGpuSamples:
- timed && timestamps ? samples - durations.length : null,
+ gpuMs: totals.length ? summarize(totals) : null,
+ nodes: Object.fromEntries(
+ Object.entries(nodes).map(([name, values]) => [
+ name,
+ summarize(values),
+ ]),
+ ),
};
}
try {
@@ -151,32 +145,22 @@ export async function benchmarkRendering(
await gpu.gpu.queue.onSubmittedWorkDone();
await gpu.settled();
const firstRenderMs = performance.now() - start;
- const rendering = await measure(() => renderer.update(scene), false);
- const renderEffect = (f: Frame) => {
- // Instrument this owned frame only; execute the feature's actual pass unchanged.
- const pass = f.pass.bind(f);
- f.pass = (options, body) =>
- pass(
- {
- ...("target" in options ? options : { target: options }),
- timer: clock?.span(passName),
- },
- body,
- );
- isolatedEffect?.render(f, input, scene);
- };
- const isolated = isolatedEffect
- ? await measure(() => {
- frame(gpu, renderEffect);
- }, active)
- : null;
+ const rendering = await measure();
+ const storage = renderer.inspect();
const pixels = await renderer.outputImage().readFloats();
if (!pixels.every(Number.isFinite)) {
throw new Error("Benchmark output contains non-finite pixels.");
}
+ const pixelHash = new Uint8Array(
+ await crypto.subtle.digest("SHA-256", pixels.slice()),
+ );
const blob = await encodeImage(gpu, renderer.outputImage(), {
longEdge: 960,
});
+ // Profile separately so timestamp queries/readback do not affect the latency comparison.
+ renderer.dispose();
+ renderer = createEditorRenderer(gpu, source, clock);
+ const profile = clock ? await measure() : null;
return {
workload,
size,
@@ -192,12 +176,19 @@ export async function benchmarkRendering(
rendererSetupMs,
firstRenderMs,
rendering,
- isolated,
- outputBytes: active ? size[0] * size[1] * 8 : 0,
+ profile,
+ storage,
+ pixelHash: [...pixelHash]
+ .map((value) => value.toString(16).padStart(2, "0"))
+ .join(""),
+ // All graph targets in these workloads are rgba16float. Source and driver memory excluded.
+ intermediateBytes: storage.textures.reduce(
+ (sum, { size }) => sum + size[0] * size[1] * 8,
+ 0,
+ ),
image: [...new Uint8Array(await blob.arrayBuffer())],
};
} finally {
- isolatedEffect?.dispose();
renderer.dispose();
source.dispose();
clock?.dispose();
diff --git a/tests/rendering.bench.ts b/tests/rendering.bench.ts
index 6e2cefd..3306bce 100644
--- a/tests/rendering.bench.ts
+++ b/tests/rendering.bench.ts
@@ -5,11 +5,11 @@ import { expect, test } from "./fixtures";
import type { Workload } from "./rendering-benchmark";
for (const workload of [
- "baseline",
"neutral",
- "active",
- "vignette-neutral",
- "vignette-active",
+ "color-mixer",
+ "vignette",
+ "detail",
+ "pipeline",
] as const) {
test(`rendering ${workload}`, async ({ page, browser }, info) => {
await page.goto("/tests/gpu.html");
@@ -38,11 +38,12 @@ for (const workload of [
...timings,
};
expect(report.rendering.completedMs.samples).toHaveLength(report.samples);
- if (
- (workload === "active" || workload === "vignette-active") &&
- report.timestamps
- ) {
- expect(report.isolated?.missingGpuSamples).toBe(0);
+ if (report.timestamps) {
+ for (const name of report.storage.passes) {
+ expect(report.profile?.nodes[name]?.samples).toHaveLength(
+ report.samples,
+ );
+ }
}
await writeFile(
info.outputPath("timings.json"),
@@ -58,7 +59,8 @@ for (const workload of [
workload,
firstRenderMs: report.firstRenderMs,
completedMs: report.rendering.completedMs.median,
- isolatedGpuMs: report.isolated?.gpuMs?.median ?? null,
+ gpuMs: report.profile?.gpuMs?.median ?? null,
+ intermediateBytes: report.intermediateBytes,
}),
);
});
diff --git a/tests/tiff.test.ts b/tests/tiff.test.ts
index b030559..296ccc3 100644
--- a/tests/tiff.test.ts
+++ b/tests/tiff.test.ts
@@ -1,6 +1,6 @@
import { expect, mock, spyOn, test } from "bun:test";
import { init, target } from "vgpu/mock";
-import { decodeTiff } from "@/lib/decode/tiff";
+import { decodeTiff } from "@/core/image/decode/tiff";
const decode = mock();
mock.module("raw-webgpu", () => ({ decodeTiff: decode }));