@forgeax/engine-render 0.1.28 → 0.1.30

package/src/pipeline/standard-output/graph.ts

@@ -0,0 +1,139 @@
+import { err, ok, type Result } from '@forgeax/engine-types';
+import { DISPLAY_ENCODED_DOMAIN, LINEAR_HDR_DOMAIN, LINEAR_LDR_DOMAIN } from './color-transform';
+import type {
+  StandardOutputLogicalStage,
+  StandardOutputPhysicalStage,
+  StandardOutputPlan,
+  StandardOutputRequest,
+} from './types';
+
+export class StandardOutputPlanError extends Error {
+  readonly code = 'standard-output-plan-invalid' as const;
+  readonly expected: string;
+  readonly hint: string;
+  readonly detail: { readonly field: string; readonly actual: string };
+
+  constructor(field: string, actual: string, expected: string) {
+    super(`standard-output-plan-invalid: ${field} ${actual}; expected ${expected}`);
+    this.name = 'StandardOutputPlanError';
+    this.expected = expected;
+    this.hint = `repair the ${field} projection before recording the Standard graph`;
+    this.detail = { field, actual };
+  }
+}
+
+function requestedStages(input: StandardOutputRequest): StandardOutputLogicalStage[] {
+  const stages: StandardOutputLogicalStage[] = [];
+  if (input.temporal) stages.push('temporal');
+  if (input.meter) stages.push('meter');
+  if (input.bloom) stages.push('bloom');
+  if (input.exposure || input.whiteBalance) stages.push('exposure-white-balance');
+  stages.push('tone');
+  if (input.lut) stages.push('lut');
+  if (input.fxaa) stages.push('fxaa');
+  stages.push('output-encoding');
+  return stages;
+}
+
+function physicalStages(
+  logicalStages: readonly StandardOutputLogicalStage[],
+): StandardOutputPhysicalStage[] {
+  return logicalStages.map((name) => {
+    switch (name) {
+      case 'temporal':
+      case 'meter':
+      case 'bloom':
+      case 'exposure-white-balance':
+        return { name, input: LINEAR_HDR_DOMAIN, output: LINEAR_HDR_DOMAIN };
+      case 'tone':
+        return { name, input: LINEAR_HDR_DOMAIN, output: LINEAR_LDR_DOMAIN };
+      case 'lut':
+      case 'fxaa':
+        return { name, input: LINEAR_LDR_DOMAIN, output: LINEAR_LDR_DOMAIN };
+      case 'output-encoding':
+        return { name, input: LINEAR_LDR_DOMAIN, output: DISPLAY_ENCODED_DOMAIN };
+      default:
+        throw new Error(`Unknown Standard output stage: ${name}`);
+    }
+  });
+}
+
+export function createStandardOutputPlan(input: StandardOutputRequest): StandardOutputPlan {
+  const logicalStages = requestedStages(input);
+  const incrementalResources = input.lut ? ['standard-color-lut'] : [];
+  const incrementalBindings = input.lut ? 2 : 0;
+  return {
+    lane: input.lane,
+    features: {
+      temporal: input.temporal,
+      meter: input.meter,
+      bloom: input.bloom,
+      exposure: input.exposure,
+      whiteBalance: input.whiteBalance,
+      lut: input.lut,
+      fxaa: input.fxaa,
+    },
+    outputEncoding: input.outputEncoding,
+    logicalStages,
+    physicalStages: physicalStages(logicalStages),
+    finalWriterCount: 1,
+    outputEncodingCount: 1,
+    incrementalResources,
+    incrementalBindings,
+    incrementalTimestamps: 0,
+  };
+}
+
+function invalid(
+  field: string,
+  actual: string,
+  expected: string,
+): Result<never, StandardOutputPlanError> {
+  return err(new StandardOutputPlanError(field, actual, expected));
+}
+
+export function validateStandardOutputPlan(
+  plan: StandardOutputPlan,
+): Result<StandardOutputPlan, StandardOutputPlanError> {
+  const expected = requestedStages({
+    lane: plan.lane,
+    ...plan.features,
+    outputEncoding: plan.outputEncoding,
+  });
+  if (
+    plan.logicalStages.length !== expected.length ||
+    plan.logicalStages.some((stage, index) => stage !== expected[index])
+  ) {
+    return invalid('logicalStages', plan.logicalStages.join(','), expected.join(','));
+  }
+  if (plan.finalWriterCount !== 1)
+    return invalid('finalWriterCount', String(plan.finalWriterCount), '1');
+  if (plan.outputEncodingCount !== 1)
+    return invalid('outputEncodingCount', String(plan.outputEncodingCount), '1');
+  if (plan.physicalStages.length !== plan.logicalStages.length) {
+    return invalid(
+      'physicalStages',
+      String(plan.physicalStages.length),
+      String(plan.logicalStages.length),
+    );
+  }
+  const expectedPhysical = physicalStages(expected);
+  for (let index = 0; index < expectedPhysical.length; index += 1) {
+    const actual = plan.physicalStages[index];
+    const wanted = expectedPhysical[index];
+    if (
+      actual?.name !== wanted?.name ||
+      actual?.input !== wanted?.input ||
+      actual?.output !== wanted?.output
+    ) {
+      return invalid(`physicalStages[${index}]`, JSON.stringify(actual), JSON.stringify(wanted));
+    }
+  }
+  if (
+    plan.outputEncoding === 'explicit-oetf' &&
+    plan.physicalStages.at(-1)?.output !== DISPLAY_ENCODED_DOMAIN
+  ) {
+    return invalid('outputEncoding', plan.outputEncoding, 'one final display-encoded writer');
+  }
+  return ok(plan);
+}

package/src/pipeline/standard-output/lut-admission.ts

@@ -0,0 +1,121 @@
+import type { SamplerDescriptor } from '@forgeax/engine-rhi';
+import type { TextureAsset } from '@forgeax/engine-types';
+import { err, ok, type Result } from '@forgeax/engine-types';
+
+export type StandardLutAdmissionErrorCode =
+  | 'standard-lut-shape-invalid'
+  | 'standard-lut-limit-exceeded'
+  | 'standard-lut-filter-unavailable'
+  | 'standard-lut-bind-failed';
+
+export type StandardLutAdmissionError = {
+  readonly code: StandardLutAdmissionErrorCode;
+  readonly expected: string;
+  readonly hint: string;
+  readonly detail: Readonly<Record<string, number | string | boolean>>;
+};
+
+export interface StandardColorLutAdmissionInput {
+  readonly texture: TextureAsset;
+  readonly maxTextureDimension3D: number;
+  readonly rgba16floatFilterable: boolean;
+  readonly bind: () => boolean;
+}
+
+export interface StandardColorLutAdmission {
+  readonly viewDimension: '3d';
+  readonly extent: Readonly<{ width: number; height: number; depth: number }>;
+  readonly sampler: SamplerDescriptor;
+}
+
+export function createStandardLutSamplerDescriptor(): SamplerDescriptor {
+  return {
+    addressModeU: 'clamp-to-edge',
+    addressModeV: 'clamp-to-edge',
+    addressModeW: 'clamp-to-edge',
+    magFilter: 'linear',
+    minFilter: 'linear',
+    mipmapFilter: 'nearest',
+  };
+}
+
+export function lutTexelCenter(index: number, size: number): number {
+  return (index + 0.5) / size;
+}
+
+function failure(
+  code: StandardLutAdmissionErrorCode,
+  expected: string,
+  hint: string,
+  detail: Readonly<Record<string, number | string | boolean>>,
+): Result<never, StandardLutAdmissionError> {
+  return err({ code, expected, hint, detail });
+}
+
+export function admitStandardColorLut(
+  input: StandardColorLutAdmissionInput,
+): Result<StandardColorLutAdmission, StandardLutAdmissionError> {
+  const { texture } = input;
+  if (
+    texture.shape.viewDimension !== '3d' ||
+    texture.format !== 'rgba16float' ||
+    texture.colorSpace !== 'linear' ||
+    texture.mips.kind === 'generate' ||
+    (texture.mips.kind === 'packed' && texture.mips.levelCount !== 1)
+  ) {
+    return failure(
+      'standard-lut-shape-invalid',
+      'a linear rgba16float 3D texture with one resident mip level',
+      're-import the LUT as an ordinary linear 3D TextureAsset without generated mips',
+      {
+        viewDimension: texture.shape.viewDimension,
+        format: texture.format,
+        colorSpace: texture.colorSpace,
+        mipPolicy: texture.mips.kind,
+      },
+    );
+  }
+
+  const extent = texture.shape.extent;
+  if (extent.width !== extent.height || extent.width !== extent.depth) {
+    return failure(
+      'standard-lut-shape-invalid',
+      'LUT width, height, and depth must be equal',
+      'produce a cubic 3D LUT',
+      { width: extent.width, height: extent.height, depth: extent.depth },
+    );
+  }
+  if (
+    !Number.isInteger(input.maxTextureDimension3D) ||
+    input.maxTextureDimension3D <= 0 ||
+    extent.width > input.maxTextureDimension3D
+  ) {
+    return failure(
+      'standard-lut-limit-exceeded',
+      'the LUT extent must fit the live maxTextureDimension3D limit',
+      'use a smaller LUT or select a device with a larger 3D texture limit',
+      { size: extent.width, maxTextureDimension3D: input.maxTextureDimension3D },
+    );
+  }
+  if (!input.rgba16floatFilterable) {
+    return failure(
+      'standard-lut-filter-unavailable',
+      'rgba16float 3D sampling must be filterable on the live device',
+      'disable the LUT or use a device that exposes rgba16float filtering',
+      { format: texture.format, rgba16floatFilterable: false },
+    );
+  }
+  if (!input.bind()) {
+    return failure(
+      'standard-lut-bind-failed',
+      'the LUT view and sampler must bind on the live device',
+      'disable the LUT and retain the last known good output',
+      { size: extent.width },
+    );
+  }
+  return ok({
+    viewDimension: '3d',
+    extent: { width: extent.width, height: extent.height, depth: extent.depth },
+    sampler: createStandardLutSamplerDescriptor(),
+  });
+}

package/src/pipeline/standard-output/lut-gpu.ts

@@ -0,0 +1,399 @@
+import type { AssetRegistry } from '@forgeax/engine-assets-runtime';
+import { resolveAssetHandle } from '@forgeax/engine-assets-runtime';
+import type { World } from '@forgeax/engine-ecs';
+import type { RenderGraphBuilder, RenderGraphError } from '@forgeax/engine-render-graph';
+import type {
+  BindGroup,
+  BindGroupLayout,
+  RenderPipeline,
+  RhiDevice,
+  Sampler,
+  Texture,
+  TextureView,
+} from '@forgeax/engine-rhi';
+import { err, type Handle, ok, type Result, type TextureAsset } from '@forgeax/engine-types';
+import type { GpuResidencyCache, TextureGpuEntry } from '../../device/gpu-residency';
+import type { RenderPipelineFrame, RenderPipelineTarget } from '../../render-pipeline';
+import {
+  admitStandardColorLut,
+  createStandardLutSamplerDescriptor,
+  type StandardLutAdmissionError,
+  type StandardLutAdmissionErrorCode,
+} from './lut-admission';
+
+export interface StandardLutGpuResources {
+  readonly texture: Texture;
+  readonly view: TextureView;
+  readonly sampler: Sampler;
+  readonly sourceKey: string;
+  readonly size: number;
+  readonly strength: number;
+  readonly bindGroupLayout: BindGroupLayout;
+  readonly bindGroup: BindGroup;
+}
+
+export interface StandardLutGraphProjection {
+  readonly view: import('@forgeax/engine-render-graph').GraphTextureView;
+  readonly sampler: Sampler;
+  readonly strength: number;
+  readonly bindGroupLayout: BindGroupLayout;
+  readonly bindGroup: BindGroup;
+}
+
+export interface StandardLutGpuPreparationInput {
+  readonly world: World;
+  readonly handle: Handle<'TextureAsset', 'shared'>;
+  readonly strength: number;
+  readonly assets: AssetRegistry;
+  readonly gpuStore: GpuResidencyCache;
+  readonly device: RhiDevice;
+}
+
+interface CachedLutBinding {
+  readonly texture: Texture;
+  readonly view: TextureView;
+  readonly sampler: Sampler;
+  readonly bindGroupLayout: BindGroupLayout;
+  readonly bindGroup: BindGroup;
+  readonly size: number;
+}
+
+const lutBindingCache = new WeakMap<object, Map<string, CachedLutBinding>>();
+
+/** Release only the projection-owned LUT objects; texture residency is cache-owned. */
+export function retireStandardLutGpuResources(_resources: StandardLutGpuResources): void {
+  // RHI samplers and bind-group layouts are device-lifetime objects. The
+  // GpuResidencyCache remains the sole owner of the resident TextureAsset.
+}
+
+export type StandardLutGpuErrorCode =
+  | StandardLutAdmissionErrorCode
+  | 'standard-lut-strength-invalid'
+  | 'standard-lut-catalog-source-missing'
+  | 'standard-lut-residency-failed'
+  | 'standard-lut-not-resident'
+  | 'standard-lut-3d-view-unavailable'
+  | 'standard-lut-sampler-failed'
+  | 'standard-lut-bind-group-layout-failed'
+  | 'standard-lut-bind-failed';
+
+export interface StandardLutGpuError {
+  readonly code: StandardLutGpuErrorCode;
+  readonly expected: string;
+  readonly hint: string;
+  readonly detail: Readonly<Record<string, number | string | boolean>>;
+}
+
+export type StandardLutPreparationError = StandardLutAdmissionError | StandardLutGpuError;
+
+function failure(
+  code: StandardLutGpuErrorCode,
+  expected: string,
+  hint: string,
+  detail: Readonly<Record<string, number | string | boolean>> = {},
+): Result<never, StandardLutGpuError> {
+  return err({ code, expected, hint, detail });
+}
+
+function causeDetail(cause: unknown): Readonly<Record<string, number | string | boolean>> {
+  if (typeof cause !== 'object' || cause === null) return { cause: String(cause) };
+  const value = cause as {
+    readonly code?: unknown;
+    readonly expected?: unknown;
+    readonly hint?: unknown;
+  };
+  return {
+    ...(typeof value.code === 'string' ? { causeCode: value.code } : {}),
+    ...(typeof value.expected === 'string' ? { causeExpected: value.expected } : {}),
+    ...(typeof value.hint === 'string' ? { causeHint: value.hint } : {}),
+  };
+}
+
+/** Resolve, admit, make resident, and bind one ordinary TextureAsset LUT. */
+export function prepareStandardLutGpu(
+  input: StandardLutGpuPreparationInput,
+): Result<StandardLutGpuResources, StandardLutPreparationError> {
+  if (!Number.isFinite(input.strength) || input.strength <= 0) {
+    return failure(
+      'standard-lut-strength-invalid',
+      'the LUT blend strength must be finite and positive',
+      'set Camera.colorLutStrength to a value in (0, 1]',
+      { strength: String(input.strength) },
+    );
+  }
+  const asset = resolveAssetHandle<TextureAsset>(input.world, input.handle);
+  if (!asset.ok) {
+    return failure(
+      'standard-lut-residency-failed',
+      'the authored TextureAsset handle resolves in the active World',
+      'register or rebuild the TextureAsset, then retry the same camera generation',
+      causeDetail(asset.error),
+    );
+  }
+  const guid = input.assets.guidOf(asset.value);
+  const catalogEntry = input.assets.listCatalog().find((entry) => entry.guid === guid);
+  const sourceKey = catalogEntry?.sourceKey;
+  if (sourceKey === undefined) {
+    return failure(
+      'standard-lut-catalog-source-missing',
+      'the authoritative asset catalog provides a stable sourceKey for the LUT GUID',
+      'repair the producer-owned catalog entry and retry the same GUID/sourceKey',
+      { guid: String(guid) },
+    );
+  }
+  const resident = input.gpuStore.getTextureGpuView(input.handle, input.world);
+  let entry: TextureGpuEntry | undefined;
+  if (resident === undefined) {
+    const prepared = input.gpuStore.ensureResident(input.handle, asset.value, input.world);
+    if (!prepared.ok) {
+      return failure(
+        'standard-lut-residency-failed',
+        'the LUT TextureAsset becomes resident through the producer-owned GPU store',
+        'inspect the structured residency failure and rebuild the source asset before retrying',
+        causeDetail(prepared.error),
+      );
+    }
+    if (!('texture' in prepared.value)) {
+      return failure(
+        'standard-lut-residency-failed',
+        'the LUT handle resolves to a resident TextureAsset, not a mesh resource',
+        'repair the authored handle kind and retry the same source key',
+        { guid: String(guid) },
+      );
+    }
+    entry = prepared.value;
+  }
+  const view = resident ?? entry?.view;
+  const texture =
+    entry?.texture.handle ??
+    input.gpuStore._getTextureGpuTexture(input.handle, input.world)?.handle;
+  if (view === undefined || texture === undefined) {
+    return failure(
+      'standard-lut-not-resident',
+      'the LUT has a live GPU texture and view before graph admission',
+      'retain the current LKG and retry producer-owned residency for the same GUID/sourceKey',
+      { guid: String(guid), sourceKey },
+    );
+  }
+  const cache =
+    lutBindingCache.get(input.device) ??
+    (() => {
+      const created = new Map<string, CachedLutBinding>();
+      lutBindingCache.set(input.device, created);
+      return created;
+    })();
+  const cached = cache.get(sourceKey);
+  if (cached !== undefined && cached.texture === texture) {
+    return ok({
+      texture,
+      view: cached.view,
+      sampler: cached.sampler,
+      sourceKey,
+      size: cached.size,
+      strength: input.strength,
+      bindGroupLayout: cached.bindGroupLayout,
+      bindGroup: cached.bindGroup,
+    });
+  }
+  // Recreate the resident view with an explicit 3D descriptor.  This is a
+  // live capability check rather than a shape assertion: a device that
+  // rejects a 3D view cannot admit this LUT route.
+  const liveView = input.device.createTextureView(texture, { dimension: '3d' });
+  if (!liveView.ok) {
+    return failure(
+      'standard-lut-3d-view-unavailable',
+      'the resident texture creates a live 3D texture view',
+      'disable the LUT and retain the last known good output on this device',
+      causeDetail(liveView.error),
+    );
+  }
+  const sampler = input.device.createSampler(createStandardLutSamplerDescriptor());
+  if (!sampler.ok) {
+    return failure(
+      'standard-lut-sampler-failed',
+      'the live device creates the filtering sampler required by the LUT',
+      'disable the LUT and retain the last known good output',
+      causeDetail(sampler.error),
+    );
+  }
+  const bindGroupLayout = input.device.createBindGroupLayout({
+    entries: [
+      { binding: 0, visibility: 2, texture: { sampleType: 'float', viewDimension: '3d' } },
+      { binding: 1, visibility: 2, sampler: { type: 'filtering' } },
+    ],
+  });
+  if (!bindGroupLayout.ok) {
+    return failure(
+      'standard-lut-bind-group-layout-failed',
+      'the live device accepts a filtering float 3D LUT bind-group layout',
+      'disable the LUT and retain the last known good output',
+      causeDetail(bindGroupLayout.error),
+    );
+  }
+  let liveBindGroup: ReturnType<RhiDevice['createBindGroup']>;
+  try {
+    liveBindGroup = input.device.createBindGroup({
+      layout: bindGroupLayout.value,
+      entries: [
+        { binding: 0, resource: { kind: 'textureView', value: liveView.value } },
+        { binding: 1, resource: { kind: 'sampler', value: sampler.value } },
+      ],
+    });
+  } catch (cause) {
+    return failure(
+      'standard-lut-filter-unavailable',
+      'the live device binds the rgba16float 3D view with a filtering sampler',
+      'disable the LUT and retain the last known good output on this device',
+      { cause: String(cause) },
+    );
+  }
+  // The result of the real BGL/BG probe is the filterability fact passed to
+  // the pure shape admission. No device capability is inferred or forced.
+  const admission = admitStandardColorLut({
+    texture: asset.value,
+    maxTextureDimension3D: input.device.limits.maxTextureDimension3D,
+    rgba16floatFilterable: liveBindGroup.ok,
+    bind: () => liveBindGroup.ok,
+  });
+  if (!admission.ok) {
+    if (admission.error.code === 'standard-lut-filter-unavailable' && !liveBindGroup.ok) {
+      return err({
+        ...admission.error,
+        detail: Object.freeze({
+          ...admission.error.detail,
+          ...causeDetail(liveBindGroup.error),
+        }),
+      });
+    }
+    return admission;
+  }
+  if (!liveBindGroup.ok) {
+    return failure(
+      'standard-lut-bind-failed',
+      'the admitted LUT view and sampler bind successfully',
+      'disable the LUT and retain the last known good output',
+      causeDetail(liveBindGroup.error),
+    );
+  }
+  cache.set(sourceKey, {
+    texture,
+    view: liveView.value,
+    sampler: sampler.value,
+    bindGroupLayout: bindGroupLayout.value,
+    bindGroup: liveBindGroup.value,
+    size: admission.value.extent.width,
+  });
+  return ok({
+    texture,
+    view: liveView.value,
+    sampler: sampler.value,
+    sourceKey,
+    size: admission.value.extent.width,
+    strength: input.strength,
+    bindGroupLayout: bindGroupLayout.value,
+    bindGroup: liveBindGroup.value,
+  });
+}
+
+const LUT_FULLSCREEN_WGSL = /* wgsl */ `
+struct VertexOutput { @builtin(position) position: vec4<f32>, @location(0) uv: vec2<f32> };
+@vertex fn lut_vs(@builtin(vertex_index) index: u32) -> VertexOutput {
+  var positions = array<vec2<f32>, 3>(vec2<f32>(-1.0, -3.0), vec2<f32>(3.0, 1.0), vec2<f32>(-1.0, 1.0));
+  let p = positions[index];
+  return VertexOutput(vec4<f32>(p, 0.0, 1.0), vec2<f32>(p.x * 0.5 + 0.5, 0.5 - p.y * 0.5));
+}
+@group(0) @binding(0) var source: texture_2d<f32>;
+@group(0) @binding(1) var sourceSampler: sampler;
+@group(1) @binding(0) var lut: texture_3d<f32>;
+@group(1) @binding(1) var lutSampler: sampler;
+@fragment fn lut_fs(input: VertexOutput) -> @location(0) vec4<f32> {
+  let color = textureSampleLevel(source, sourceSampler, input.uv, 0.0);
+  let mapped = textureSampleLevel(lut, lutSampler, clamp(color.rgb, vec3<f32>(0.0), vec3<f32>(1.0)), 0.0);
+  return vec4<f32>(mix(color.rgb, mapped.rgb, LUT_STRENGTH), color.a);
+}`;
+
+/** Record a fullscreen 3D LUT sample into the same Standard graph. */
+export function addStandardColorLutPass(
+  graph: RenderGraphBuilder<RenderPipelineFrame>,
+  input: RenderPipelineTarget,
+  output: RenderPipelineTarget,
+  lut: StandardLutGraphProjection,
+): Result<void, RenderGraphError> {
+  let pipeline: RenderPipeline | undefined;
+  let layout: BindGroupLayout | undefined;
+  let sampler: Sampler | undefined;
+  const added = graph.addRasterPass('standard-color-lut', {
+    accesses: [
+      { resource: input.view, usage: 'sampled-read' },
+      { resource: lut.view, usage: 'sampled-read' },
+      { resource: output.view, usage: 'color-attachment' },
+    ],
+    colorAttachments: [
+      {
+        view: output.view,
+        loadOp: 'clear',
+        storeOp: 'store',
+        clearValue: { r: 0, g: 0, b: 0, a: 1 },
+      },
+    ],
+    encode: ({ pass, frame, resources }) => {
+      const factory =
+        frame.runtime.immediateShaderModuleFactory ?? frame.runtime.shaderModuleFactory;
+      if (factory === undefined) throw new Error('standard LUT shader factory unavailable');
+      const source = factory.createShaderModule({
+        code: LUT_FULLSCREEN_WGSL.replace('LUT_STRENGTH', String(lut.strength)),
+        label: 'standard-color-lut',
+      });
+      if (!source.ok) throw source.error;
+      if (layout === undefined) {
+        const created = frame.runtime.device.createBindGroupLayout({
+          label: 'standard-color-lut.bgl',
+          entries: [
+            { binding: 0, visibility: 2, texture: { sampleType: 'float', viewDimension: '2d' } },
+            { binding: 1, visibility: 2, sampler: { type: 'filtering' } },
+          ],
+        });
+        if (!created.ok) throw created.error;
+        layout = created.value;
+      }
+      sampler ??= frame.runtime.device
+        .createSampler({ minFilter: 'linear', magFilter: 'linear' })
+        .unwrap();
+      if (pipeline === undefined) {
+        const pipelineLayout = frame.runtime.device.createPipelineLayout({
+          label: 'standard-color-lut.layout',
+          bindGroupLayouts: [layout, lut.bindGroupLayout],
+        });
+        if (!pipelineLayout.ok) throw pipelineLayout.error;
+        const created = frame.runtime.device.createRenderPipeline({
+          label: 'standard-color-lut',
+          layout: pipelineLayout.value,
+          vertex: { module: source.value, entryPoint: 'lut_vs', buffers: [] },
+          fragment: {
+            module: source.value,
+            entryPoint: 'lut_fs',
+            targets: [{ format: output.format as GPUTextureFormat }],
+          },
+          primitive: { topology: 'triangle-list' },
+        });
+        if (!created.ok) throw created.error;
+        pipeline = created.value;
+      }
+      const inputView = resources.textureView(input.view);
+      if (!inputView.ok) throw inputView.error;
+      const bindings = frame.runtime.device.createBindGroup({
+        layout,
+        entries: [
+          { binding: 0, resource: { kind: 'textureView', value: inputView.value } },
+          { binding: 1, resource: { kind: 'sampler', value: sampler as Sampler } },
+        ],
+      });
+      if (!bindings.ok) throw bindings.error;
+      pass.setPipeline(pipeline as RenderPipeline);
+      pass.setBindGroup(0, bindings.value);
+      pass.setBindGroup(1, lut.bindGroup);
+      pass.draw(3, 1, 0, 0);
+    },
+  });
+  return added.ok ? ok(undefined) : added;
+}