@volter/blender-engine 0.1.148 → 0.1.150

package/browser/frame-transfer.mts

@@ -1,19 +0,0 @@
-/** Buffers at every depth of a frame move to the presenter exactly once. */
-export function frameTransferBuffers(frame: unknown): ArrayBuffer[] {
-  const buffers = new Set<ArrayBuffer>();
-  const visited = new Set<object>();
-  const walk = (value: unknown): void => {
-    if (value === null || typeof value !== 'object' || visited.has(value)) return;
-    visited.add(value);
-    if (value instanceof ArrayBuffer) {
-      buffers.add(value);
-    } else if (ArrayBuffer.isView(value)) {
-      // Shared Wasm memory cannot be transferred; arena readers make owned copies.
-      if (value.buffer instanceof ArrayBuffer) buffers.add(value.buffer);
-    } else {
-      for (const child of Object.values(value)) walk(child);
-    }
-  };
-  walk(frame);
-  return [...buffers];
-}

package/browser/three/blender-agx.ts

@@ -1,235 +0,0 @@
-import { encodeDisplayFrame, sampleDisplayLut } from './blender-display-lut';
-
-/**
- * Blender's AgX view transform, transcribed from the pinned OCIO config.
- *
- * WHY THIS EXISTS AND `THREE.AgXToneMapping` DOES NOT DO. three's AgX is
- * Filament's approximation: it allocates log2 to `AgxMaxEv = 4.026069` where
- * Blender's config allocates to `+12.5260688117`, and it substitutes a
- * 6th-order polynomial for the config's curve. MEASURED on flat grey, it is
- * 23 to 48 levels of 255 away from Blender -- 42 of them at middle grey, where
- * Blender answers 0.4456 and three answers 0.6060. Every render this lane
- * produced carried that.
- *
- * THE CHAIN IS THE CONFIG'S, step for step (`AgX Base Rec.1886` on display
- * `sRGB`):
- *
- *   scene linear Rec.709 -> CIE XYZ D65 -> Linear FilmLight E-Gamut
- *   -> lg2 allocation over [-12.47393, +12.5260688117]
- *   -> AgX_Base_sRGB.cube, 57^3, TETRAHEDRAL
- *   -> Rec.1886 -> sRGB  (the Rec.709 matrices cancel: `srgb(x^2.4)`)
- *
- * VERIFIED THREE WAYS, all agreeing to the digit: this code, Blender's own
- * `image.save_render()` on a known float buffer, and the `PyOpenColorIO` 2.5.0
- * that ships inside the oracle.
- *
- *     scene linear   here        save_render    OCIO
- *      0.01337859    0.008866    0.00886492     --
- *      0.15904408    0.158059    0.15805990     --
- *      1.01823460    0.559880    0.55986845     --
- *            0.18    0.461326    --             0.46132022   (sRGB encoded)
- *
- * A render of a flat emission plane is NOT the instrument -- Cycles' film does
- * not hand the view transform exactly the colour the emission node was set to,
- * and chasing that cost a wrong "unexplained residual" once.
- *
- * THE LUT IS DATA, not a curve: `agx-base-srgb.lut` is the config's own
- * `AgX_Base_sRGB.cube` as little-endian uint16 over [0,1], red varying fastest,
- * 185,193 RGB triples. One part in 65,535 is 0.004 of a 255-level step, far
- * under anything measurable here, and it halves what a project carries.
- * Source sha256 e707a36f3e90ee79bc342332febf91334c02ce3974cac700ece00ca9d4507491.
- *
- * NOT WIRED INTO THE VIEW YET, and the reason is named rather than left to be
- * discovered: `renderer.toneMapping` applies per fragment inside every
- * material's shader, and that seam takes an enum, not a 3D texture. Reaching
- * it means the photograph rendering to a float target and this chain running
- * as a full-screen pass. Until then the capture still uses three's curve and
- * the AgX LOOKS are still refused by name in `bpy/_render_three.py` -- which
- * is the honest state, not a degrade. The LOOKS also need a SECOND pinned LUT
- * (`luminance_compensation_bt2020.cube`, 37^3): their process space is `AgX
- * Log`, which is not this chain's E-Gamut path.
- */
-
-/** The LUT's edge length; `AgX_Base_sRGB.cube` says `LUT_3D_SIZE 57`. */
-export const AGX_LUT_SIZE = 57;
-
-/** `AllocationTransform {allocation: lg2, vars: [-12.47393, 12.5260688117]}`.
- *  The ends are `log2(2^-10 * 0.18)` and `log2(2^15 * 0.18)`: ten stops under
- *  middle grey to fifteen over, which is why middle grey lands on exactly
- *  0.4 of the domain. */
-const LOG2_MIN = -12.47393;
-const LOG2_MAX = 12.5260688117;
-
-/** Linear Rec.709 -> CIE XYZ D65, the inverse of the config's own
- *  `Linear Rec.709` matrix. */
-const RGB_TO_XYZ = [
-  [0.4123908, 0.3575843, 0.1804808],
-  [0.212639, 0.7151687, 0.0721923],
-  [0.0193308, 0.1191948, 0.9505322],
-] as const;
-
-/** CIE XYZ D65 -> Linear FilmLight E-Gamut, verbatim from the config. */
-const XYZ_TO_EGAMUT = [
-  [1.5250528, -0.3159135, -0.1226583],
-  [-0.5091526, 1.3333274, 0.1382844],
-  [0.0957153, 0.0508974, 0.7879558],
-] as const;
-
-/** In place, into `out`. A frame is 1.3M pixels, so nothing on this path
- *  allocates -- see `blender-display-lut.ts`'s header. */
-function transform(
-  m: readonly (readonly number[])[],
-  v: ArrayLike<number>,
-  out: Float64Array,
-): void {
-  const a = v[0]!;
-  const b = v[1]!;
-  const c = v[2]!;
-  out[0] = m[0]![0]! * a + m[0]![1]! * b + m[0]![2]! * c;
-  out[1] = m[1]![0]! * a + m[1]![1]! * b + m[1]![2]! * c;
-  out[2] = m[2]![0]! * a + m[2]![1]! * b + m[2]![2]! * c;
-}
-
-/** Scratch for the two matrix stages and the display answer. */
-const stageA = new Float64Array(3);
-const stageB = new Float64Array(3);
-const display: [number, number, number] = [0, 0, 0];
-
-/** The sRGB display colourspace's own encode -- piecewise, not a pure 2.2. */
-function srgbEncode(value: number): number {
-  const v = Math.min(1, Math.max(0, value));
-  return v <= 0.0031308 ? 12.92 * v : 1.055 * v ** (1 / 2.4) - 0.055;
-}
-
-/**
- * The 57^3 LUT, sampled TETRAHEDRALLY -- which is what the config asks for by
- * name (`interpolation: tetrahedral`).
- *
- * On the neutral diagonal every barycentric weight collapses to the same `t`,
- * so a grey input is a straight lerp between the two diagonal corners; that is
- * the case the verification above exercises, and rendering at inputs that land
- * exactly ON a grid point exercises the table itself with no interpolation at
- * all.
- */
-/** The returned triple is SCRATCH -- the next call overwrites it. */
-export function sampleAgxLut(
-  lut: Uint16Array,
-  r: number,
-  g: number,
-  b: number,
-): [number, number, number] {
-  return sampleDisplayLut(lut, AGX_LUT_SIZE, r, g, b);
-}
-
-/** One scene-linear Rec.709 colour through Blender's AgX, to sRGB display.
- *  THE RETURNED TRIPLE IS SCRATCH -- the next call overwrites it. */
-export function agxDisplay(lut: Uint16Array, rgb: ArrayLike<number>): [number, number, number] {
-  transform(RGB_TO_XYZ, rgb, stageB);
-  transform(XYZ_TO_EGAMUT, stageB, stageA);
-  const span = LOG2_MAX - LOG2_MIN;
-  const formed = sampleAgxLut(
-    lut,
-    (Math.log2(Math.max(stageA[0]!, 1e-10)) - LOG2_MIN) / span,
-    (Math.log2(Math.max(stageA[1]!, 1e-10)) - LOG2_MIN) / span,
-    (Math.log2(Math.max(stageA[2]!, 1e-10)) - LOG2_MIN) / span,
-  );
-  // The view ends at Rec.1886 and the display is sRGB; both are Rec.709
-  // primaries, so the matrices cancel and only the two curves remain.
-  display[0] = srgbEncode(Math.max(0, formed[0]) ** 2.4);
-  display[1] = srgbEncode(Math.max(0, formed[1]) ** 2.4);
-  display[2] = srgbEncode(Math.max(0, formed[2]) ** 2.4);
-  return display;
-}
-
-/**
- * THE LOOKS, as the config's own composed transform.
- *
- * A look is not a curve that can be applied after the fact. OCIO converts to
- * the look's process space (`AgX Log` -- luminance-compensated Rec.2020 through
- * a SECOND 37^3 LUT, an inset matrix and the lg2 allocation), grades there,
- * converts back, and only then runs the display view. Two of those steps invert
- * a 3D LUT, which is not something to do per pixel in a browser.
- *
- * SO THE COMPOSED look+view IS SAMPLED, by OCIO itself, on the display LUT's
- * own lg2 grid -- `2^(x*(MAX-MIN)+MIN)` at every 57^3 corner, through the
- * `sRGB`/`AgX` display view with the look overridden. The table that comes out
- * is a drop-in for the base one: allocate, sample, done -- its values ARE the
- * sRGB display answer, so no `Rec.1886` step follows it.
- *
- * MEASURED against OCIO's direct answer for ten colours off the grid: WORST 3
- * LEVELS of 255 (`AgX - Medium High Contrast`) and 1 (`AgX - Punchy`). That
- * residual is resampling a curve that already contains an interpolated LUT,
- * and it lands on an artifact that is a DECLARED difference -- a three.js
- * raster is never compared to a Cycles path trace for equality.
- *
- * TWO OTHER REPRESENTATIONS WERE TRIED AND MEASURED WORSE. Baking the look
- * alone as a scene-to-scene map and re-log-encoding it scored 19 levels,
- * because a saturation grade produces NEGATIVE linear values and a log
- * encoding collapses every one of them onto its floor -- which is exactly why
- * the config's own `AgX Log` carries a luminance-compensation LUT to remove
- * the negatives before the grade. Carrying the log span alongside the table
- * did not help, because the loss is the floor, not the clamp.
- *
- * A LOOK WITH NO TABLE HERE IS REFUSED BY NAME in `bpy/_render_three.py`.
- * There is no generic path: `AgX - Base Contrast` is the identity and already
- * accepted, these two are baked, and the rest say so.
- */
-export const AGX_LOOK_TABLES = {
-  'AgX - Medium High Contrast': 'agx-look-medium-high-contrast.lut',
-  'AgX - Punchy': 'agx-look-punchy.lut',
-} as const;
-
-/** One scene-linear Rec.709 colour through a composed look+view table.
- *  The returned triple is SCRATCH, as in `agxDisplay`. */
-export function agxDisplayWithLook(
-  lookLut: Uint16Array,
-  rgb: ArrayLike<number>,
-): [number, number, number] {
-  // The composed table is sampled in the SCENE's own channels: OCIO was handed
-  // `2^(x*(MAX-MIN)+MIN)` per axis, so the grid axis IS the allocated scene
-  // value and no matrix runs before the lookup.
-  const span = LOG2_MAX - LOG2_MIN;
-  return sampleAgxLut(
-    lookLut,
-    (Math.log2(Math.max(rgb[0]!, 1e-10)) - LOG2_MIN) / span,
-    (Math.log2(Math.max(rgb[1]!, 1e-10)) - LOG2_MIN) / span,
-    (Math.log2(Math.max(rgb[2]!, 1e-10)) - LOG2_MIN) / span,
-  );
-}
-
-/** One IEEE half (uint16 bits) as a JS number. `readRenderTargetPixels` on a
- *  `HalfFloatType` target hands back exactly these. */
-export { decodeHalf } from './blender-display-lut';
-
-/**
- * A captured HDR frame through Blender's AgX, as the RGBA bytes a PNG wants.
- *
- * THE FRAME IS ALREADY THERE. `Object3DDocumentSession.captureImage` renders
- * into a `HalfFloatType` target to keep lit surfaces off the byte clip, and
- * only then resolves through the viewport's output pass into the bytes it
- * reads back. That half-float target is scene-referred linear -- which is the
- * one thing an AgX LOOK, an EXR write and this transform all need and an
- * 8-bit canvas cannot give. `readRenderTargetPixels` accepts it: three's
- * `textureTypeReadable` passes `HalfFloatType` whenever
- * `EXT_color_buffer_half_float` or `EXT_color_buffer_float` is present, and
- * WebGL2 has both.
- *
- * ALPHA IS CARRIED, NOT TRANSFORMED. Blender treats alpha as data, not colour,
- * everywhere else in this lane (`Image.save`'s encode does the same), so it is
- * scaled to a byte and nothing more.
- */
-export function agxEncodeFrame(
-  lut: Uint16Array,
-  halfPixels: Uint16Array,
-  pixelCount: number,
-  options: { readonly exposure?: number; readonly composedLook?: boolean } = {},
-): Uint8ClampedArray {
-  // BLENDER'S EXPOSURE IS A LINEAR MULTIPLIER APPLIED BEFORE THE VIEW
-  // TRANSFORM (`view_settings.exposure` in stops, which the session already turns
-  // into `2 ** stops`), which is the same place `toneMappingExposure` sat.
-  const exposure = options.exposure ?? 1;
-  // A composed look table IS the display answer; the base table still has the
-  // matrices and the `Rec.1886 -> sRGB` tail after it.
-  const through = options.composedLook === true ? agxDisplayWithLook : agxDisplay;
-  return encodeDisplayFrame(halfPixels, pixelCount, exposure, (rgb) => through(lut, rgb));
-}

package/browser/three/blender-display-lut.ts

@@ -1,145 +0,0 @@
-/**
- * Tetrahedral sampling of normalized, red-fastest RGB display tables.
- *
- * THIS FILE IS THE FRAME LOOP, so it allocates NOTHING per pixel. Measured at
- * 1440x900: the previous shape returned a fresh array for each of the four
- * tetrahedron corners and built its result with `.map`, and `encodeDisplayFrame`
- * built a fresh `[r, g, b]` per pixel -- roughly ten allocations per pixel, 13M
- * per frame, and about half the wall clock. Every buffer below is module-level
- * scratch instead, which is why the returned triples are documented as SCRATCH:
- * a caller reads or copies the result before the next call, and the frame loop
- * does exactly that.
- */
-
-/** Scratch: c000, second, third and c111 as four RGB triples. */
-const corner = new Float64Array(12);
-const sampled: [number, number, number] = [0, 0, 0];
-const frac = new Float64Array(3);
-const frameInput = new Float64Array(3);
-
-/** THE SIX TETRAHEDRA of a cube cell, one row each: the second corner's
- *  offsets, the third corner's offsets, then which of `[fr, fg, fb]` supplies
- *  w1, w2 and w3. The same walk the branch chain did -- a flat table keeps the
- *  choice out of the sampler's own nesting. */
-// biome-ignore format: one tetrahedron per row is the whole point of the table
-const TETRA = new Int8Array([
-  1, 0, 0,   1, 1, 0,   0, 1, 2,
-  1, 0, 0,   1, 0, 1,   0, 2, 1,
-  0, 0, 1,   1, 0, 1,   2, 0, 1,
-  0, 0, 1,   0, 1, 1,   2, 1, 0,
-  0, 1, 0,   0, 1, 1,   1, 2, 0,
-  0, 1, 0,   1, 1, 0,   1, 0, 2,
-]);
-
-/** Which of the six the fractional position falls in -- the three fractions
- *  ordered largest first, as tetrahedral interpolation is defined. */
-function tetraCase(fr: number, fg: number, fb: number): number {
-  if (fr > fg) {
-    if (fg > fb) return 0;
-    return fr > fb ? 1 : 2;
-  }
-  if (fb > fg) return 3;
-  if (fb > fr) return 4;
-  return 5;
-}
-
-/** Tetrahedral sampling of normalized, red-fastest RGB display tables.
- *  THE RETURNED TRIPLE IS SCRATCH -- the next call overwrites it. */
-export function sampleDisplayLut(
-  lut: Uint16Array,
-  n: number,
-  r: number,
-  g: number,
-  b: number,
-): [number, number, number] {
-  const plane = n * n;
-  const x = Math.min(1, Math.max(0, r)) * (n - 1);
-  const y = Math.min(1, Math.max(0, g)) * (n - 1);
-  const z = Math.min(1, Math.max(0, b)) * (n - 1);
-  const ir = Math.min(Math.floor(x), n - 2);
-  const ig = Math.min(Math.floor(y), n - 2);
-  const ib = Math.min(Math.floor(z), n - 2);
-  const fr = x - ir;
-  const fg = y - ig;
-  const fb = z - ib;
-  const read = (slot: number, dr: number, dg: number, db: number): void => {
-    const at = (ir + dr + (ig + dg) * n + (ib + db) * plane) * 3;
-    corner[slot] = lut[at]! / 65535;
-    corner[slot + 1] = lut[at + 1]! / 65535;
-    corner[slot + 2] = lut[at + 2]! / 65535;
-  };
-  read(0, 0, 0, 0);
-  read(9, 1, 1, 1);
-  frac[0] = fr;
-  frac[1] = fg;
-  frac[2] = fb;
-  const t = tetraCase(fr, fg, fb) * 9;
-  read(3, TETRA[t]!, TETRA[t + 1]!, TETRA[t + 2]!);
-  read(6, TETRA[t + 3]!, TETRA[t + 4]!, TETRA[t + 5]!);
-  const w1 = frac[TETRA[t + 6]!]!;
-  const w2 = frac[TETRA[t + 7]!]!;
-  const w3 = frac[TETRA[t + 8]!]!;
-  for (let k = 0; k < 3; k++) {
-    const c000 = corner[k]!;
-    sampled[k] =
-      c000 +
-      w1 * (corner[3 + k]! - c000) +
-      w2 * (corner[6 + k]! - corner[3 + k]!) +
-      w3 * (corner[9 + k]! - corner[6 + k]!);
-  }
-  return sampled;
-}
-
-export function decodeHalf(bits: number): number {
-  const sign = bits & 0x8000 ? -1 : 1;
-  const exponent = (bits >> 10) & 0x1f;
-  const fraction = bits & 0x3ff;
-  if (exponent === 0) return sign * 2 ** -24 * fraction;
-  if (exponent === 31) return fraction ? Number.NaN : sign * Number.POSITIVE_INFINITY;
-  return sign * 2 ** (exponent - 15) * (1 + fraction / 1024);
-}
-
-/** Transform associated scene-linear half-float RGBA to straight display RGBA.
- *  Unassociate before the nonlinear view transform; keep the input frame intact
- *  for the compositor and EXR. Alpha remains ungraded data.
- *  `through` is handed a REUSED triple -- it must read its three values before
- *  returning, which every display chain here does. */
-export function encodeDisplayFrame(
-  halfPixels: Uint16Array,
-  pixelCount: number,
-  exposure: number,
-  through: (rgb: ArrayLike<number>) => readonly [number, number, number],
-): Uint8ClampedArray {
-  const out = new Uint8ClampedArray(pixelCount * 4);
-  for (let i = 0; i < pixelCount; i++) {
-    const at = i * 4;
-    const alpha = decodeHalf(halfPixels[at + 3]!);
-    const scale = alpha === 0 ? exposure : exposure / alpha;
-    frameInput[0] = decodeHalf(halfPixels[at]!) * scale;
-    frameInput[1] = decodeHalf(halfPixels[at + 1]!) * scale;
-    frameInput[2] = decodeHalf(halfPixels[at + 2]!) * scale;
-    const display = through(frameInput);
-    out[at] = Math.round(display[0] * 255);
-    out[at + 1] = Math.round(display[1] * 255);
-    out[at + 2] = Math.round(display[2] * 255);
-    out[at + 3] = Math.round(Math.min(1, Math.max(0, alpha)) * 255);
-  }
-  return out;
-}
-
-/**
- * Where a display table lives: beside this module, wherever this module is
- * served from.
- *
- * THE `.lut` SUFFIX IS SPELLED IN THE TEMPLATE, NOT IN THE ARGUMENT, and that
- * is the difference between a four-file glob and a whole-directory one. A
- * bundler cannot see the value of `file`, so it resolves
- * `new URL(`./${x}`, import.meta.url)` by globbing EVERY sibling -- measured
- * 2026-09-20 on the release build: every `.ts` in this directory came out
- * inlined as a base64 data URL beside the tables, 6.4 MB of module. With the
- * suffix in the template the glob is `./*.lut` and only the four tables are
- * reachable, which is the whole truth of what this function can return.
- */
-export function displayTableUrl(file: string): URL {
-  return new URL(`./${file.replace(/\.lut$/, '')}.lut`, import.meta.url);
-}

package/browser/three/blender-filmic.ts

@@ -1,49 +0,0 @@
-import { encodeDisplayFrame, sampleDisplayLut } from './blender-display-lut';
-
-/** Blender 5.2 fbe6228777e7 OCIO Filmic/sRGB: log allocation, highlight
- * desaturation, then the display curve. filmic-srgb.lut contains the pinned
- * filmic_desat_33.cube followed by its 4096-entry display curve, normalized
- * to little-endian uint16. The table output is already display-encoded sRGB.
- */
-const SIZE = 33;
-const CUBE_VALUES = SIZE ** 3 * 3;
-const CURVE_SIZE = 4096;
-const LOG_MIN = -12.473931188;
-const LOG_SPAN = 25;
-
-function curve(lut: Uint16Array, value: number): number {
-  const position = Math.min(1, Math.max(0, value)) * (CURVE_SIZE - 1);
-  const index = Math.min(Math.floor(position), CURVE_SIZE - 2);
-  const t = position - index;
-  return ((1 - t) * lut[CUBE_VALUES + index]! + t * lut[CUBE_VALUES + index + 1]!) / 65535;
-}
-
-/** Scratch, as everything on the frame path is -- see `blender-display-lut.ts`. */
-const display: [number, number, number] = [0, 0, 0];
-
-/** One scene-linear colour through Filmic, to sRGB display.
- *  THE RETURNED TRIPLE IS SCRATCH -- the next call overwrites it. */
-export function filmicDisplay(lut: Uint16Array, rgb: ArrayLike<number>): [number, number, number] {
-  const desaturated = sampleDisplayLut(
-    lut,
-    SIZE,
-    (Math.log2(Math.max(rgb[0]!, 1e-10)) - LOG_MIN) / LOG_SPAN,
-    (Math.log2(Math.max(rgb[1]!, 1e-10)) - LOG_MIN) / LOG_SPAN,
-    (Math.log2(Math.max(rgb[2]!, 1e-10)) - LOG_MIN) / LOG_SPAN,
-  );
-  display[0] = curve(lut, desaturated[0] / 0.66);
-  display[1] = curve(lut, desaturated[1] / 0.66);
-  display[2] = curve(lut, desaturated[2] / 0.66);
-  return display;
-}
-
-export function filmicEncodeFrame(
-  lut: Uint16Array,
-  pixels: Uint16Array,
-  count: number,
-  exposure: number,
-): Uint8ClampedArray {
-  if (lut.length !== CUBE_VALUES + CURVE_SIZE)
-    throw new Error('Invalid Blender Filmic display table');
-  return encodeDisplayFrame(pixels, count, exposure, (rgb) => filmicDisplay(lut, rgb));
-}

package/browser/three/blender-standard.ts

@@ -1,68 +0,0 @@
-/**
- * Blender's `Standard` view transform, off a scene-linear frame.
- *
- * THE CONFIG SAYS WHAT THIS IS. In the pinned colour configuration
- * (`release/datafiles/colormanagement/config.ocio`) the `Standard` view
- * resolves to the `sRGB` display colour space, whose `from_display_reference`
- * is a `ColorSpaceTransform` to `Linear Rec.709` followed by
- * `ExponentWithLinearTransform {gamma: 2.4, offset: 0.055, direction: inverse}`.
- * Blender's scene reference IS Linear Rec.709, so the colour-space leg is the
- * identity and the whole transform is that one curve — the sRGB compound
- * (piece-wise) encoding, with no LUT and nothing to load.
- *
- * THE CONSTANTS ARE DERIVED, NOT QUOTED. OCIO computes the break point and the
- * linear slope from `gamma` and `offset` by requiring the two pieces to meet
- * with a continuous derivative, which lands at 0.0030402 and 12.9232 — close
- * to, and deliberately not, IEC 61966-2-1's rounded 0.0031308 and 12.92.
- * Deriving them here keeps the two numbers honest against the two the config
- * actually states.
- *
- * WHERE IT IS USED, and where it is not: a COMPOSITED frame, whose pixels are
- * the compositor's scene-referred output and can no longer be photographed
- * through three's own output encoding. An ordinary Standard render is still
- * three's capture, unchanged — it is the same curve applied by the same
- * renderer that drew the frame, and moving it here would change bytes for no
- * reason.
- *
- * NEGATIVE INPUT: clamped. OCIO's default negative handling for this transform
- * mirrors the curve about zero, which lands below zero and clips to byte 0 in
- * `encodeDisplayFrame` — the same byte clamping to zero produces, so the two
- * readings are indistinguishable in the PNG this writes.
- */
-import { encodeDisplayFrame } from './blender-display-lut';
-
-const GAMMA = 2.4;
-const OFFSET = 0.055;
-/** The display-side break, where the power piece meets the linear one. */
-const BREAK = OFFSET / (GAMMA - 1);
-/** The linear piece's slope, from matching the power piece's derivative there. */
-const SLOPE = 1 / ((GAMMA / (1 + OFFSET)) * ((BREAK + OFFSET) / (1 + OFFSET)) ** (GAMMA - 1));
-/** The same break expressed on the scene-linear side. */
-const LINEAR_BREAK = ((BREAK + OFFSET) / (1 + OFFSET)) ** GAMMA;
-
-/** One scene-linear channel through the sRGB compound encoding. */
-export function standardChannel(value: number): number {
-  if (!(value > 0)) return 0;
-  if (value < LINEAR_BREAK) return value * SLOPE;
-  return (1 + OFFSET) * value ** (1 / GAMMA) - OFFSET;
-}
-
-/** Scratch, as everything on the frame path is — see `blender-display-lut.ts`. */
-const display: [number, number, number] = [0, 0, 0];
-
-/** One scene-linear colour through Standard, to sRGB display.
- *  THE RETURNED TRIPLE IS SCRATCH — the next call overwrites it. */
-export function standardDisplay(rgb: ArrayLike<number>): [number, number, number] {
-  display[0] = standardChannel(rgb[0]!);
-  display[1] = standardChannel(rgb[1]!);
-  display[2] = standardChannel(rgb[2]!);
-  return display;
-}
-
-export function standardEncodeFrame(
-  pixels: Uint16Array,
-  count: number,
-  exposure: number,
-): Uint8ClampedArray {
-  return encodeDisplayFrame(pixels, count, exposure, standardDisplay);
-}