@forgeax/engine-render 0.1.6 → 0.1.19

package/src/extract/environment.ts

@@ -0,0 +1,171 @@
+import type { World } from '@forgeax/engine-ecs';
+import { err, ok, type Result } from '@forgeax/engine-types';
+import { environmentFactSignatures } from '../environment/signature';
+import {
+  AtmosphereInvalidParameterError,
+  type AtmosphereParameterRange,
+  EnvironmentSourceConflictError,
+  FogCardinalityError,
+  type RenderError,
+} from '../errors/render';
+import type { TemporalView } from '../temporal/view';
+
+/** The retained projection's environment extraction owner. */
+export interface EnvironmentExtractionContext {
+  readonly resourceOwner: number;
+  readonly world: World;
+}
+
+/** Keep environment reads at the resource-owner frame boundary. */
+export function createEnvironmentExtractionContext(
+  world: World,
+  resourceOwner: number,
+): EnvironmentExtractionContext {
+  return Object.freeze({ world, resourceOwner });
+}
+
+export type EnvironmentCandidate =
+  | { readonly kind: 'image'; readonly entityKey: number; readonly sourceKey: string }
+  | {
+      readonly kind: 'atmosphere';
+      readonly entityKey: number;
+      readonly sourceKey: string;
+      readonly atmosphere: AtmosphereParameters;
+    };
+
+export interface AtmosphereParameters {
+  readonly turbidity: number;
+  readonly rayleigh: number;
+  readonly mieCoefficient: number;
+  readonly mieDirectionalG: number;
+  readonly sunAngularRadius: number;
+}
+
+/** Shared CPU contract for values accepted by the atmosphere shaders. */
+export const ATMOSPHERE_PARAMETER_RANGES: Readonly<
+  Record<keyof AtmosphereParameters, AtmosphereParameterRange>
+> = Object.freeze({
+  turbidity: Object.freeze({ min: 1, max: 20 }),
+  rayleigh: Object.freeze({ min: 0, max: Number.POSITIVE_INFINITY }),
+  mieCoefficient: Object.freeze({ min: 0, max: Number.POSITIVE_INFINITY }),
+  mieDirectionalG: Object.freeze({ min: 0, max: 0.999 }),
+  sunAngularRadius: Object.freeze({ min: 0, max: Number.POSITIVE_INFINITY }),
+});
+
+export interface FogCandidate {
+  readonly entityKey: number;
+  readonly color: readonly [number, number, number];
+  readonly density: number;
+  readonly heightFalloff: number;
+  readonly maxOpacity: number;
+}
+
+export type EnvironmentSource =
+  | { readonly kind: 'none' }
+  | {
+      readonly kind: 'image';
+      readonly entityKey: number;
+      readonly sourceKey: string;
+    }
+  | {
+      readonly kind: 'atmosphere';
+      readonly entityKey: number;
+      readonly sourceKey: string;
+      readonly atmosphere: AtmosphereParameters;
+    };
+
+export interface FogFrame extends FogCandidate {}
+
+export interface EnvironmentFrame {
+  readonly source: EnvironmentSource;
+  /** Descriptor of the real environment resource adopted for this frame. */
+  readonly resourceDescriptor?: Readonly<{
+    readonly width: number;
+    readonly height: number;
+    readonly bytesPerPixel: number;
+  }>;
+  readonly fog: FogFrame | undefined;
+  readonly environmentSignature: string;
+  readonly fogSignature: string;
+  readonly signature: string;
+  readonly revision: number;
+}
+
+export interface FramePlan {
+  readonly environment: EnvironmentFrame;
+  readonly temporal: TemporalView;
+}
+
+function freezeFog(candidate: FogCandidate): FogFrame {
+  return Object.freeze({
+    ...candidate,
+    color: Object.freeze([...candidate.color] as unknown as FogFrame['color']),
+  });
+}
+
+function freezeAtmosphere(parameters: AtmosphereParameters): AtmosphereParameters {
+  return Object.freeze({ ...parameters });
+}
+
+/** Return the first invalid analytic atmosphere field at the extraction boundary. */
+export function validateAtmosphereParameters(
+  parameters: AtmosphereParameters,
+): AtmosphereInvalidParameterError | undefined {
+  for (const field of Object.keys(ATMOSPHERE_PARAMETER_RANGES) as (keyof AtmosphereParameters)[]) {
+    const value = parameters[field];
+    const range = ATMOSPHERE_PARAMETER_RANGES[field];
+    if (!Number.isFinite(value) || value < range.min || value > range.max) {
+      return new AtmosphereInvalidParameterError(field, value, range);
+    }
+  }
+  return undefined;
+}
+
+/** Select immutable environment and independent Fog facts at the frame boundary. */
+export function selectEnvironmentFrame(
+  candidates: readonly EnvironmentCandidate[],
+  fogCandidates: readonly FogCandidate[],
+): Result<EnvironmentFrame, RenderError> {
+  if (candidates.length > 1) {
+    return err(
+      new EnvironmentSourceConflictError(
+        candidates.map(({ kind, entityKey, sourceKey }) => ({ kind, entityKey, sourceKey })),
+      ),
+    );
+  }
+  if (fogCandidates.length > 1) return err(new FogCardinalityError(fogCandidates.length));
+  const candidate = candidates[0];
+  if (candidate?.kind === 'atmosphere') {
+    const invalid = validateAtmosphereParameters(candidate.atmosphere);
+    if (invalid !== undefined) return err(invalid);
+  }
+  const source: EnvironmentSource =
+    candidate === undefined
+      ? { kind: 'none' }
+      : candidate.kind === 'atmosphere'
+        ? {
+            kind: 'atmosphere',
+            entityKey: candidate.entityKey,
+            sourceKey: candidate.sourceKey,
+            atmosphere: freezeAtmosphere(candidate.atmosphere),
+          }
+        : {
+            kind: 'image',
+            entityKey: candidate.entityKey,
+            sourceKey: candidate.sourceKey,
+          };
+  const fog = fogCandidates[0] === undefined ? undefined : freezeFog(fogCandidates[0]);
+  const signatures = environmentFactSignatures({
+    environments: candidate === undefined ? [] : [candidate],
+    fogs: fogCandidates,
+    suns: [],
+  });
+  return ok(
+    Object.freeze({
+      source: Object.freeze(source),
+      fog,
+      ...signatures,
+      revision: 0,
+    }),
+  );
+}

package/src/extract/visibility.ts

@@ -1,4 +1,4 @@
-import { Entity, type EntityHandle, type World } from '@forgeax/engine-ecs';
+import type { EntityHandle, World } from '@forgeax/engine-ecs';
 import {
   projectHierarchy,
   type SceneHierarchyDiagnostic,
@@ -45,34 +45,53 @@ export function resolveVisibility(
   world: World,
   hierarchy: SceneHierarchySnapshot = projectHierarchy(world),
 ): VisibilitySnapshot {
-  const query = world.query({ read: [Entity], optional: [Visibility] });
+  // Visibility is an opt-in component. Query only the owning archetypes
+  // instead of walking every Entity row with an optional column; the latter
+  // made a World with no visibility intents pay a full-scene scan on each
+  // extraction. QueryRow.entity is sourced from the essential Entity column,
+  // so the required Visibility read retains the same handle and intent
+  // semantics while keeping the hot path sparse.
+  const query = world.query({ read: [Visibility] });
+  const visitVisibilityRows = (visit: (entity: EntityHandle, rawState: number) => void): void => {
+    if (!query.ok) return;
+    // Dense component spans keep the per-frame summary on typed-array reads
+    // instead of allocating a QueryRow facade for every visibility-bearing
+    // entity. Keep the row path as a defensive fallback if a future storage
+    // mode cannot expose spans.
+    const spans = query.value.spans();
+    if (spans.ok) {
+      for (const span of spans.value) {
+        const states = span.get(Visibility).state;
+        for (let index = 0; index < span.length; index += 1) {
+          visit(span.entities[index] as EntityHandle, states[index] ?? 0);
+        }
+      }
+      return;
+    }
+    for (const row of query.value) {
+      visit(row.entity, row.get(Visibility).state);
+    }
+  };
   let intentCount = 0;
   let hasAnyHiddenIntent = false;
-  if (query.ok) {
-    for (const row of query.value) {
-      const visibility = row.get(Visibility);
-      if (visibility === undefined) continue;
-      intentCount += 1;
-      if (visibility.state === VisibilityStateValue.hidden) {
-        hasAnyHiddenIntent = true;
-      }
+  visitVisibilityRows((_entity, rawState) => {
+    intentCount += 1;
+    if (rawState === VisibilityStateValue.hidden) {
+      hasAnyHiddenIntent = true;
     }
-  }
+  });
 
   let resolveEntity: ((entity: EntityHandle) => ResolutionState | undefined) | undefined;
   let hasIntent: ((entity: EntityHandle) => boolean) | undefined;
   const ensureResolver = (): void => {
     if (resolveEntity !== undefined) return;
     const intentByEntity = new Map<EntityHandle, VisibilityState>();
-    if (query.ok) {
-      for (const row of query.value) {
-        const raw = row.get(Visibility);
-        const intent = raw === undefined ? undefined : visibilityStateFromU32(raw.state);
-        if (intent !== undefined) {
-          intentByEntity.set(row.entity, intent);
-        }
+    visitVisibilityRows((entity, rawState) => {
+      const intent = visibilityStateFromU32(rawState);
+      if (intent !== undefined) {
+        intentByEntity.set(entity, intent);
       }
-    }
+    });
     hasIntent = (entity: EntityHandle): boolean => intentByEntity.has(entity);
     const resolved = new Map<EntityHandle, ResolutionState>();
     const resolving = new Set<EntityHandle>();

package/src/features/host.ts

@@ -15,9 +15,12 @@ import type {
   PreparedGraphicsResolver,
   PreparedGraphicsResourceLease,
 } from '../prepare/prepared-graphics-resolver';
+import type { SceneDataTarget } from '../temporal/scene-data';
+import { createSceneDataCatalog, type SceneDataCatalog } from '../temporal/scene-data-catalog';
 import {
   freezeRenderFeaturePlan,
   type RenderFeatureLogicalTarget,
+  type RenderFeatureMaterialShaderBindingContract,
   type RenderFeaturePassDeclaration,
   type RenderFeaturePlan,
   type RenderFeaturePlannedFrame,
@@ -53,6 +56,7 @@ import type {
   RenderFeatureExtractContext,
   RenderFeatureHiddenEntityReport,
   RenderFeatureRecoverInput,
+  RenderFeatureShaderModuleMode,
   RenderFeatureStatus,
   RenderFeatureTargetHandle,
   RenderFeatureWorldVisibilitySnapshot,
@@ -102,8 +106,14 @@ export interface RenderFeatureFrameInput {
   readonly hiddenEntityReports?: readonly RenderFeatureHiddenEntityReport[];
   /** Active-pipeline logical targets available to producer-owned features. */
   readonly targets?: readonly RenderFeatureTargetHandle[];
+  /** Optional renderer-owned semantic catalog for the current plan generation. */
+  readonly sceneData?: SceneDataCatalog;
   readonly generation?: number;
   readonly caps: Readonly<RhiCaps>;
+  /** Renderer-owned material binding contract projection for producer plans. */
+  readonly materialShaderBindingContract?: (
+    materialShaderId: string,
+  ) => RenderFeatureMaterialShaderBindingContract;
   readonly createPreparedGraphicsResolver?: (
     input: RenderFeaturePreparedGraphicsResolverInput,
   ) => PreparedGraphicsResolver;
@@ -115,6 +125,8 @@ export interface RenderFeaturePreparedGraphicsResolverInput {
   readonly featureIdentity: string;
   readonly order: number;
   readonly generation: number;
+  /** Shader preparation policy selected by the owning feature. */
+  readonly shaderModuleMode?: RenderFeatureShaderModuleMode;
   readonly transaction: PreparedGraphicsTransaction;
   readonly fullscreenEffects: ReadonlyMap<string, PostProcessShaderEntry>;
   readonly lookup: (
@@ -428,7 +440,7 @@ function logicalTargets(
 ): readonly RenderFeatureLogicalTarget[] {
   return Object.freeze(
     targets.map((target) => ({
-      name: target.kind === 'scene-color' ? 'color' : 'depth',
+      name: target.name ?? (target.kind === 'scene-color' ? 'color' : 'depth'),
       kind: target.kind === 'scene-color' ? ('color' as const) : ('depth' as const),
       format: target.format,
       sampleCount: target.sampleCount,
@@ -451,14 +463,17 @@ function planFailure(slot: FeatureSlot): RenderFeatureStageFailedError {
 }
 
 function targetHandle(
-  name: string,
+  name: string | SceneDataTarget,
   targets: readonly RenderFeatureTargetHandle[],
-): string | RenderFeatureTargetHandle | undefined {
+): string | RenderFeatureTargetHandle | SceneDataTarget | undefined {
   if (name === 'swapchain') return 'swapchain';
+  if (typeof name !== 'string') return name;
   return targets.find(
     (target) =>
-      (name === 'color' && target.kind === 'scene-color') ||
-      (name === 'depth' && target.kind === 'scene-depth'),
+      target.name === name ||
+      (target.name === undefined &&
+        ((name === 'color' && target.kind === 'scene-color') ||
+          (name === 'depth' && target.kind === 'scene-depth'))),
   );
 }
 
@@ -1169,6 +1184,7 @@ export function runRenderFeatureFrame(
     const gpu: RenderFeatureGpuPrepareSession | undefined = input.gpuWork?.beginFeature(
       identity,
       input.generation ?? 0,
+      feature.shaderModuleMode,
     );
     const featureHiddenEntityReports: RenderFeatureHiddenEntityReport[] = [];
     const extractContext = {
@@ -1194,6 +1210,14 @@ export function runRenderFeatureFrame(
     }
 
     const targets = logicalTargets(input.targets ?? []);
+    const sceneData =
+      input.sceneData ??
+      createSceneDataCatalog({
+        featureIdentity: identity,
+        generation: transaction.generation,
+        planIdentity: `${identity}:${transaction.generation}`,
+        rgba16floatRenderable: input.caps.rgba16floatRenderable === true,
+      });
     const declared = invokeStage(
       slot,
       'plan',
@@ -1203,6 +1227,10 @@ export function runRenderFeatureFrame(
           frame: { frameNumber: input.frameNumber },
           generation: transaction.generation,
           targets,
+          sceneData,
+          ...(input.materialShaderBindingContract === undefined
+            ? {}
+            : { materialShaderBindingContract: input.materialShaderBindingContract }),
         }),
       stageEvents,
       errors,
@@ -1246,6 +1274,9 @@ export function runRenderFeatureFrame(
       featureIdentity: identity,
       order,
       generation: transaction.generation,
+      ...(feature.shaderModuleMode === undefined
+        ? {}
+        : { shaderModuleMode: feature.shaderModuleMode }),
       transaction,
       fullscreenEffects,
       lookup: (reference) =>

package/src/features/motion-blur/__tests__/motion-blur-feature.unit.test.ts

@@ -0,0 +1,67 @@
+import { describe, expect, it } from 'vitest';
+import { SCENE_DATA_TEMPORAL_V1_SCHEMA } from '../../../temporal/scene-data';
+import { createSceneDataCatalog } from '../../../temporal/scene-data-catalog';
+import { freezeRenderFeaturePlan } from '../../plan';
+import { planMotionBlur } from '../motion-blur-feature';
+import { DEFAULT_MOTION_BLUR_PARAMS } from '../motion-blur-params';
+
+const caps = {
+  rgba16floatRenderable: true,
+  compute: true,
+  storageBuffer: true,
+} as never;
+
+describe('Motion Blur feature plan', () => {
+  it('declares one projected fullscreen draw with semantic reads', () => {
+    const catalog = createSceneDataCatalog({
+      featureIdentity: 'forgeax.motion-blur',
+      generation: 4,
+      planIdentity: 'forgeax.motion-blur:4',
+      rgba16floatRenderable: true,
+    });
+    const planned = planMotionBlur(DEFAULT_MOTION_BLUR_PARAMS, {
+      caps,
+      frame: { frameNumber: 7 },
+      generation: 4,
+      targets: [
+        { name: 'motion-input', kind: 'color', format: 'rgba16float', sampleCount: 1 },
+        { name: 'motion-output', kind: 'color', format: 'rgba16float', sampleCount: 1 },
+      ],
+      sceneData: catalog,
+    });
+    expect(planned.ok).toBe(true);
+    if (!planned.ok) return;
+    const frozen = freezeRenderFeaturePlan('forgeax.motion-blur', planned.value, [
+      { name: 'motion-input', kind: 'color', format: 'rgba16float', sampleCount: 1 },
+      { name: 'motion-output', kind: 'color', format: 'rgba16float', sampleCount: 1 },
+    ]);
+    expect(frozen.ok).toBe(true);
+    if (!frozen.ok) return;
+    const bindings = frozen.value.resources.find(
+      (resource) => resource.kind === 'graphics-bindings',
+    );
+    expect(bindings?.kind).toBe('graphics-bindings');
+    const program = frozen.value.resources.find(
+      (resource) => resource.kind === 'fullscreen-program',
+    );
+    expect(program?.kind).toBe('fullscreen-program');
+    if (program?.kind === 'fullscreen-program') {
+      expect(program.reads).toEqual(['scene-color', 'scene-temporal']);
+      expect(program.reads).not.toContainEqual({ key: 'scene-depth', sampleType: 'depth' });
+    }
+    if (bindings?.kind === 'graphics-bindings') {
+      expect(bindings.values).not.toHaveProperty('depth');
+      expect(bindings.logicalTargets).toEqual({ input: 'motion-input' });
+    }
+    expect(frozen.value.passes).toHaveLength(1);
+    const pass = frozen.value.passes[0];
+    expect(pass?.kind).toBe('raster');
+    if (pass?.kind !== 'raster') return;
+    expect(pass.draws[0]?.vertexLayout).toBe('none');
+    expect(pass.sampledTargets).toEqual(
+      expect.arrayContaining(['motion-input', catalog.require(SCENE_DATA_TEMPORAL_V1_SCHEMA)]),
+    );
+    expect(pass.sampledTargets).not.toContain('motion-depth');
+    expect(catalog.schema).toBe(SCENE_DATA_TEMPORAL_V1_SCHEMA);
+  });
+});

package/src/features/motion-blur/__tests__/motion-blur-params.unit.test.ts

@@ -0,0 +1,53 @@
+import { describe, expect, it } from 'vitest';
+import {
+  DEFAULT_MOTION_BLUR_PARAMS,
+  motionBlurTemporalDemand,
+  validateMotionBlurParams,
+} from '../motion-blur-params';
+
+describe('Motion Blur parameter validation', () => {
+  it('applies the bounded defaults', () => {
+    expect(validateMotionBlurParams({})).toEqual({ ok: true, value: DEFAULT_MOTION_BLUR_PARAMS });
+    expect(DEFAULT_MOTION_BLUR_PARAMS).toEqual({
+      shutterAngle: 180,
+      maxRadiusPixels: 32,
+      sampleCount: 8,
+    });
+  });
+
+  it.each([
+    [{ shutterAngle: 0 }, 'identity shutter'],
+    [{ shutterAngle: 360, maxRadiusPixels: 0, sampleCount: 4 }, 'lower and upper bounds'],
+    [{ shutterAngle: 12, maxRadiusPixels: 64, sampleCount: 16 }, 'valid upper bounds'],
+  ] as const)('accepts %s (%s)', (input, _label) => {
+    const result = validateMotionBlurParams(input);
+    expect(result.ok).toBe(true);
+  });
+
+  it.each([
+    ['shutterAngle', -0.01],
+    ['shutterAngle', 360.01],
+    ['maxRadiusPixels', -0.01],
+    ['maxRadiusPixels', 64.01],
+    ['sampleCount', 3],
+    ['sampleCount', 17],
+    ['sampleCount', 8.5],
+  ] as const)('returns structured failure for %s=%s', (field, value) => {
+    const result = validateMotionBlurParams({ [field]: value });
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.error.code).toBe('motion-blur-invalid-params');
+      expect(result.error.detail.field).toBe(field);
+      expect(result.error.expected).toContain(field);
+      expect(result.error.hint).toContain(field);
+    }
+  });
+
+  it('does no temporal work when omitted or shutter is zero', () => {
+    expect(motionBlurTemporalDemand(undefined)).toBe(false);
+    expect(motionBlurTemporalDemand({ shutterAngle: 0, maxRadiusPixels: 32, sampleCount: 8 })).toBe(
+      false,
+    );
+    expect(motionBlurTemporalDemand(DEFAULT_MOTION_BLUR_PARAMS)).toBe(true);
+  });
+});

package/src/features/motion-blur/motion-blur-feature.ts

@@ -0,0 +1,119 @@
+import type { RenderGraphBuilder, RenderGraphError } from '@forgeax/engine-render-graph';
+import { err, ok, type Result } from '@forgeax/engine-types';
+import type { RenderError } from '../../errors/render';
+import type { RenderPipelineFrame, RenderPipelineTarget } from '../../render-pipeline';
+import { SCENE_DATA_TEMPORAL_V1_SCHEMA } from '../../temporal/scene-data';
+import { addTypedFullscreenPass } from '../../typed-render-graph-primitives';
+import type { RenderFeaturePlan, RenderFeaturePlanContext } from '../plan';
+import type { RenderFeature, RenderFeatureExtractContext } from '../types';
+import {
+  type MotionBlurParams,
+  motionBlurTemporalDemand,
+  validateMotionBlurParams,
+} from './motion-blur-params';
+
+export const MOTION_BLUR_FEATURE_IDENTITY = 'forgeax.motion-blur';
+
+export function addMotionBlurPass(
+  graph: RenderGraphBuilder<RenderPipelineFrame>,
+  input: RenderPipelineTarget,
+  temporal: RenderPipelineTarget,
+  output: RenderPipelineTarget,
+): Result<void, RenderGraphError> {
+  return addTypedFullscreenPass(graph, {
+    name: 'motion-blur',
+    shader: MOTION_BLUR_FEATURE_IDENTITY,
+    input,
+    additionalReads: [{ key: 'scene-temporal', target: temporal }],
+    output,
+  });
+}
+
+export interface MotionBlurFeatureFrame {
+  readonly params: MotionBlurParams | undefined;
+  readonly demanded: boolean;
+}
+
+export function planMotionBlur(
+  params: MotionBlurParams,
+  context: RenderFeaturePlanContext,
+): Result<RenderFeaturePlan, RenderError> {
+  if (!motionBlurTemporalDemand(params)) return ok({ resources: [], passes: [] });
+  try {
+    const temporal = context.sceneData.require(SCENE_DATA_TEMPORAL_V1_SCHEMA);
+    const outputFormat =
+      context.targets.find((target) => target.name === 'motion-output')?.format ?? 'rgba16float';
+    return ok({
+      resources: [
+        {
+          kind: 'fullscreen-program',
+          name: 'motion-blur',
+          source: 'forgeax::shader::motion-blur',
+          reads: ['scene-color', 'scene-temporal'],
+          params: { byteSize: 16, defaultValue: new Uint8Array(16) },
+        },
+        {
+          kind: 'graphics-program',
+          name: 'motion-blur-pipeline',
+          program: {
+            shader: MOTION_BLUR_FEATURE_IDENTITY,
+            vertexLayout: 'none',
+            colorFormats: [outputFormat],
+            sampleCount: 1,
+          },
+        },
+        {
+          kind: 'graphics-bindings',
+          name: 'motion-blur-bindings',
+          program: 'motion-blur-pipeline',
+          values: {
+            group: 1,
+            fullscreen: true,
+            shader: MOTION_BLUR_FEATURE_IDENTITY,
+            input: 'motion-input',
+            temporal,
+          },
+          logicalTargets: { input: 'motion-input' },
+        },
+      ],
+      passes: [
+        {
+          kind: 'raster',
+          name: 'motion-blur',
+          colorAttachments: [{ target: 'motion-output', loadOp: 'clear', storeOp: 'store' }],
+          sampledTargets: ['motion-input', temporal],
+          draws: [
+            {
+              program: 'motion-blur-pipeline',
+              bindings: ['motion-blur-bindings'],
+              vertexData: [],
+              vertexLayout: 'none',
+              draw: { kind: 'draw', vertexCount: 3, instanceCount: 1 },
+            },
+          ],
+        },
+      ],
+    });
+  } catch (cause) {
+    return err(cause as RenderError);
+  }
+}
+
+export function createMotionBlurFeature(
+  read: () => Partial<MotionBlurParams> | undefined,
+): RenderFeature<MotionBlurFeatureFrame> {
+  return Object.freeze({
+    identity: MOTION_BLUR_FEATURE_IDENTITY,
+    extract: (_context: RenderFeatureExtractContext) => {
+      const input = read();
+      const validated = validateMotionBlurParams(input);
+      if (!validated.ok) return err(validated.error as unknown as RenderError);
+      const params = input === undefined ? undefined : validated.value;
+      return ok({ params, demanded: motionBlurTemporalDemand(params) });
+    },
+    plan: (frame: MotionBlurFeatureFrame, context: RenderFeaturePlanContext) =>
+      frame.params === undefined
+        ? ok({ resources: [], passes: [] })
+        : planMotionBlur(frame.params, context),
+  });
+}