@forgeax/engine-render 0.1.4 → 0.1.6

package/src/features/morph/morph-bounds.ts

@@ -1,123 +0,0 @@
-export const MORPH_MAX_TARGETS = 8;
-
-export type MorphVec3 = readonly [number, number, number];
-
-export interface MorphBounds {
-  readonly min: MorphVec3;
-  readonly max: MorphVec3;
-}
-
-export interface MorphTargetBounds {
-  readonly min: MorphVec3;
-  readonly max: MorphVec3;
-}
-
-export interface MorphCullInput {
-  readonly weights?: ArrayLike<number>;
-  readonly expectedWeightCount: number;
-  readonly baseAabbIntersectsFrustum: boolean;
-}
-
-export type MorphCullDecision = 'draw' | 'cull';
-
-function finiteVec3(value: MorphVec3): boolean {
-  return value.every((component) => Number.isFinite(component));
-}
-
-function validWeights(weights: ArrayLike<number> | undefined, expected: number): boolean {
-  if (weights === undefined || weights.length !== expected) return false;
-  for (let index = 0; index < weights.length; index++) {
-    if (!Number.isFinite(weights[index] ?? Number.NaN)) return false;
-  }
-  return true;
-}
-
-/** Compute a conservative AABB from base bounds and target delta bounds. */
-export function deriveMorphBounds(
-  base: MorphBounds,
-  targets: readonly MorphTargetBounds[],
-  weights: ArrayLike<number>,
-): MorphBounds {
-  if (
-    !finiteVec3(base.min) ||
-    !finiteVec3(base.max) ||
-    targets.length > MORPH_MAX_TARGETS ||
-    !validWeights(weights, targets.length)
-  ) {
-    return base;
-  }
-
-  const min = [base.min[0], base.min[1], base.min[2]];
-  const max = [base.max[0], base.max[1], base.max[2]];
-  for (let targetIndex = 0; targetIndex < targets.length; targetIndex++) {
-    const target = targets[targetIndex];
-    const weight = weights[targetIndex] ?? 0;
-    if (target === undefined || !finiteVec3(target.min) || !finiteVec3(target.max)) return base;
-    for (let axis = 0; axis < 3; axis++) {
-      const low = (weight >= 0 ? target.min[axis] : target.max[axis]) ?? 0;
-      const high = (weight >= 0 ? target.max[axis] : target.min[axis]) ?? 0;
-      min[axis] = (min[axis] ?? 0) + weight * low;
-      max[axis] = (max[axis] ?? 0) + weight * high;
-    }
-  }
-  return {
-    min: [min[0] ?? 0, min[1] ?? 0, min[2] ?? 0],
-    max: [max[0] ?? 0, max[1] ?? 0, max[2] ?? 0],
-  };
-}
-
-/** Keep non-zero valid morphs drawable even when their base AABB is outside. */
-export function morphCullDecision(input: MorphCullInput): MorphCullDecision {
-  if (!Number.isInteger(input.expectedWeightCount) || input.expectedWeightCount < 0) return 'cull';
-  if (!validWeights(input.weights, input.expectedWeightCount)) {
-    return 'cull';
-  }
-  for (let index = 0; index < input.expectedWeightCount; index++) {
-    if ((input.weights?.[index] ?? 0) !== 0) return 'draw';
-  }
-  return input.baseAabbIntersectsFrustum ? 'draw' : 'cull';
-}
-
-export interface MorphReentryState {
-  seen: boolean;
-  visible: boolean;
-  generation: number;
-  weights: Float32Array | undefined;
-}
-
-export interface MorphReentryInput {
-  readonly frameNumber: number;
-  readonly visible: boolean;
-  readonly generation: number;
-  readonly weights: ArrayLike<number>;
-}
-
-export interface MorphReentryResult {
-  readonly frameNumber: number;
-  readonly reentered: boolean;
-  readonly clearStale: boolean;
-  readonly weights: readonly number[];
-}
-
-export function createMorphReentryState(): MorphReentryState {
-  return { seen: false, visible: false, generation: -1, weights: undefined };
-}
-
-/** Track visibility transitions so a re-entry always rewrites the current weights. */
-export function stepMorphReentry(
-  state: MorphReentryState,
-  input: MorphReentryInput,
-): MorphReentryResult {
-  const reentered =
-    state.seen && input.visible && (!state.visible || state.generation !== input.generation);
-  const clearStale = reentered && state.weights !== undefined;
-  const weights = Array.from(
-    { length: input.weights.length },
-    (_, index) => input.weights[index] ?? 0,
-  );
-  state.seen = true;
-  state.visible = input.visible;
-  state.generation = input.generation;
-  state.weights = new Float32Array(weights);
-  return { frameNumber: input.frameNumber, reentered, clearStale, weights };
-}

package/src/features/scene-temporal.ts

@@ -1,274 +0,0 @@
-import type {
-  GraphAccess,
-  RenderGraphBuilder,
-  RenderGraphError,
-} from '@forgeax/engine-render-graph';
-import { ok, RenderQueue, type Result } from '@forgeax/engine-types';
-import type { RenderPipelineFrame } from '../render-pipeline';
-import { createRenderPipelineTarget, type RenderPipelineTarget } from '../render-pipeline-target';
-import type { DispatchEntry, RenderableSnapshot } from '../render-system-extract';
-import {
-  summarizeTemporalCoverage,
-  type TemporalCoverageContribution,
-  type TemporalCoverageSummary,
-  type TemporalProducerLane,
-  type TemporalReactiveReason,
-} from '../temporal-coverage';
-import { addTypedScenePass } from '../typed-render-graph-primitives';
-import type { RenderFeatureGraphContribution } from './graph-contribution';
-import { isRenderFeatureTargetHandle } from './targets';
-
-export const SCENE_TEMPORAL_TARGET_FORMAT = 'rgba16float' as const;
-export const SCENE_TEMPORAL_TARGET_SAMPLE_COUNT = 1 as const;
-export const SCENE_TEMPORAL_CLEAR_VALUE = Object.freeze({ r: 0, g: 0, b: -1, a: 1 });
-export const SCENE_TEMPORAL_PACKED_ABI = Object.freeze({
-  x: 'unjittered-currentUv-minus-previousUv-x',
-  y: 'unjittered-currentUv-minus-previousUv-y',
-  z: 'monotonic-view-depth',
-  w: 'reactive-0-to-1',
-});
-
-const REACTIVE_REVISION_IDENTITY = 'scene:temporal-reactive-revision';
-
-/** Add one existing current-only signal without creating a second temporal owner. */
-export function markSceneReactiveRevision(
-  coverage: TemporalCoverageSummary,
-  changed: boolean,
-): TemporalCoverageSummary {
-  if (
-    !changed ||
-    coverage.contributors.some(({ identity }) => identity === REACTIVE_REVISION_IDENTITY)
-  ) {
-    return coverage;
-  }
-  return summarizeTemporalCoverage([
-    ...coverage.contributors,
-    {
-      identity: REACTIVE_REVISION_IDENTITY,
-      lane: 'render-feature',
-      coverage: 'reactive',
-      reason: 'producer-reactive-fallback',
-    },
-  ]);
-}
-
-/** Allocate and initialize the TAA-only packed temporal target. */
-export function createSceneTemporalTarget(
-  graph: RenderGraphBuilder<RenderPipelineFrame>,
-): Result<RenderPipelineTarget, RenderGraphError> {
-  const target = createRenderPipelineTarget(graph, 'scene-temporal', {
-    format: SCENE_TEMPORAL_TARGET_FORMAT,
-    size: 'surface',
-    sampleCount: SCENE_TEMPORAL_TARGET_SAMPLE_COUNT,
-  });
-  if (!target.ok) return target;
-  const clear = graph.addRasterPass('scene-temporal-clear', {
-    accesses: [{ resource: target.value.view, usage: 'color-attachment' }],
-    colorAttachments: [
-      {
-        view: target.value.view,
-        loadOp: 'clear',
-        storeOp: 'store',
-        clearValue: SCENE_TEMPORAL_CLEAR_VALUE,
-      },
-    ],
-    encode: () => undefined,
-  });
-  return clear.ok ? ok(target.value) : clear;
-}
-
-/** Allocate the unjittered visibility authority consumed only by temporal replay. */
-export function createSceneTemporalDepthTarget(
-  graph: RenderGraphBuilder<RenderPipelineFrame>,
-): Result<RenderPipelineTarget, RenderGraphError> {
-  return createRenderPipelineTarget(graph, 'scene-temporal-depth', {
-    format: 'depth24plus-stencil8',
-    size: 'surface',
-    sampleCount: 1,
-  });
-}
-
-export interface SceneTemporalRasterOptions {
-  readonly target: RenderPipelineTarget;
-  readonly depth: RenderPipelineTarget;
-  readonly sampled?: readonly RenderPipelineTarget[] | undefined;
-  readonly directionalShadow?: RenderPipelineTarget | undefined;
-  readonly spotShadow?: RenderPipelineTarget | undefined;
-  readonly ssao?: RenderPipelineTarget | undefined;
-  readonly extraAccesses?: readonly GraphAccess[] | undefined;
-}
-
-/** Replay visible scene geometry once into the packed temporal attachment. */
-export function addSceneTemporalRasterPass(
-  graph: RenderGraphBuilder<RenderPipelineFrame>,
-  options: SceneTemporalRasterOptions,
-): Result<void, RenderGraphError> {
-  return addTypedScenePass(graph, {
-    name: 'scene-temporal',
-    color: options.target,
-    depth: options.depth,
-    selector: { LightMode: ['Forward'] },
-    passKind: 'temporal',
-    colorLoadOp: 'load',
-    depthLoadOp: 'clear',
-    ...(options.sampled === undefined ? {} : { sampled: options.sampled }),
-    ...(options.directionalShadow === undefined
-      ? {}
-      : { directionalShadow: options.directionalShadow }),
-    ...(options.spotShadow === undefined ? {} : { spotShadow: options.spotShadow }),
-    ...(options.ssao === undefined ? {} : { ssao: options.ssao }),
-    ...(options.extraAccesses === undefined ? {} : { extraAccesses: options.extraAccesses }),
-  });
-}
-
-function materialReactiveReason(snapshot: RenderableSnapshot): TemporalReactiveReason | undefined {
-  const reasons = snapshot.temporal?.reactiveReasons;
-  if (reasons?.includes('material-revision')) return 'material-revision';
-  if (reasons?.includes('geometry-revision')) return 'geometry-revision';
-  if (reasons?.includes('generation-reuse')) return 'generation-reuse';
-  if (reasons?.includes('reentered')) return 'visibility-reentry';
-  if (reasons?.includes('new-slot')) return 'first-observation';
-  return undefined;
-}
-
-function producerLane(snapshot: RenderableSnapshot, dispatch: DispatchEntry): TemporalProducerLane {
-  const shader = dispatch.materialShaderId ?? snapshot.material.materialShaderId;
-  if (shader === 'forgeax::sprite' || shader === 'forgeax::sprite-lit') return 'sprite';
-  if (dispatch.renderState?.blend !== undefined || dispatch.queue >= RenderQueue.Transparent) {
-    return 'transparent';
-  }
-  if (shader !== undefined && !shader.startsWith('forgeax::')) return 'custom-deformation';
-  if (dispatch.vertexEntry !== undefined && dispatch.vertexEntry !== 'vs_main') {
-    return 'custom-deformation';
-  }
-  if (snapshot.skin !== undefined) return 'skinning';
-  if (snapshot.morphWeights !== undefined) return 'morph';
-  if (snapshot.instances !== undefined) return 'instances';
-  const alphaCutoff = dispatch.paramSnapshot?.alphaCutoff;
-  if (
-    dispatch.queue === RenderQueue.AlphaTest ||
-    (typeof alphaCutoff === 'number' && alphaCutoff > 0)
-  ) {
-    return 'alpha-cutout';
-  }
-  return 'rigid';
-}
-
-function standardContribution(
-  snapshot: RenderableSnapshot,
-  dispatch: DispatchEntry,
-): TemporalCoverageContribution {
-  const identity = `scene:${snapshot.worldId}:${snapshot.entityKey}:${dispatch.passIndex}:${dispatch.materialHandle}`;
-  const lane = producerLane(snapshot, dispatch);
-  if (snapshot.temporal === undefined) {
-    return { identity, lane, coverage: 'missing', reason: 'previous-state-unavailable' };
-  }
-  if (lane === 'transparent' || lane === 'sprite' || lane === 'custom-deformation') {
-    return { identity, lane, coverage: 'reactive', reason: 'producer-reactive-fallback' };
-  }
-  if (
-    lane === 'skinning' &&
-    (snapshot.skin?.jointMatrices === undefined ||
-      (snapshot.temporal.previousSource === 'last-submitted' &&
-        snapshot.temporal.previousSkin?.jointMatrices === undefined))
-  ) {
-    return { identity, lane, coverage: 'missing', reason: 'previous-state-unavailable' };
-  }
-  const reactive = materialReactiveReason(snapshot);
-  if (reactive !== undefined) return { identity, lane, coverage: 'reactive', reason: reactive };
-  return {
-    identity,
-    lane,
-    coverage: 'exact',
-    previous: snapshot.temporal.previousSource,
-  };
-}
-
-function featureContributions(
-  contributions: readonly RenderFeatureGraphContribution[],
-): TemporalCoverageContribution[] {
-  const coverage: TemporalCoverageContribution[] = [];
-  for (const contribution of contributions) {
-    for (const pass of contribution.passes) {
-      const graphics = pass.graphics;
-      if (graphics === undefined || graphics.draws.length === 0) continue;
-      const writesScene = graphics.attachments.colors.some((attachment) => {
-        const resource = attachment.resource;
-        return (
-          resource === 'swapchain' ||
-          (isRenderFeatureTargetHandle(resource) && resource.kind === 'scene-color')
-        );
-      });
-      if (!writesScene) continue;
-      const identity = `feature:${contribution.featureIdentity}:${pass.name}`;
-      const writesTemporal = graphics.attachments.colors.some(
-        (attachment) =>
-          isRenderFeatureTargetHandle(attachment.resource) &&
-          attachment.resource.kind === 'scene-temporal',
-      );
-      if (graphics.temporalCoverage === 'reactive') {
-        coverage.push({
-          identity,
-          lane: contribution.featureIdentity.includes('vfx') ? 'vfx' : 'render-feature',
-          coverage: 'reactive',
-          reason: 'producer-reactive-fallback',
-        });
-      } else if (graphics.temporalCoverage === 'exact' && writesTemporal) {
-        coverage.push({
-          identity,
-          lane: 'render-feature',
-          coverage: 'exact',
-          previous: 'last-submitted',
-        });
-      } else {
-        coverage.push({
-          identity,
-          lane: 'render-feature',
-          coverage: 'missing',
-          reason:
-            graphics.temporalCoverage === 'exact'
-              ? 'exact-target-unwritten'
-              : 'feature-coverage-undeclared',
-        });
-      }
-    }
-  }
-  return coverage;
-}
-
-/** Classify every standard draw and visible feature pass exactly once. */
-export function sceneTemporalCoverage(input: {
-  readonly renderables: readonly RenderableSnapshot[];
-  readonly dispatch: readonly DispatchEntry[];
-  readonly features: readonly RenderFeatureGraphContribution[];
-}): TemporalCoverageSummary {
-  const contributions: TemporalCoverageContribution[] = [];
-  const dispatched = new Set<number>();
-  for (const entry of input.dispatch) {
-    const snapshot = input.renderables[entry.renderableIndex];
-    if (snapshot === undefined) continue;
-    dispatched.add(entry.renderableIndex);
-    contributions.push(standardContribution(snapshot, entry));
-  }
-  for (let index = 0; index < input.renderables.length; index += 1) {
-    if (dispatched.has(index)) continue;
-    const snapshot = input.renderables[index];
-    if (snapshot === undefined) continue;
-    contributions.push({
-      identity: `scene:${snapshot.worldId}:${snapshot.entityKey}:undispatched`,
-      lane: 'rigid',
-      coverage: 'missing',
-      reason: 'dispatch-unavailable',
-    });
-  }
-  contributions.push(...featureContributions(input.features));
-  const priority = { exact: 0, reactive: 1, missing: 2 } as const;
-  const byIdentity = new Map<string, TemporalCoverageContribution>();
-  for (const contribution of contributions) {
-    const current = byIdentity.get(contribution.identity);
-    if (current === undefined || priority[contribution.coverage] > priority[current.coverage]) {
-      byIdentity.set(contribution.identity, contribution);
-    }
-  }
-  return summarizeTemporalCoverage([...byIdentity.values()]);
-}

package/src/features/taa-resolve.ts

@@ -1,244 +0,0 @@
-import type { RenderGraphBuilder } from '@forgeax/engine-render-graph';
-import type {
-  BindGroup,
-  BindGroupLayout,
-  Buffer,
-  RenderPipeline,
-  RhiDevice,
-  RhiError,
-  Sampler,
-  ShaderModule,
-  TextureView,
-} from '@forgeax/engine-rhi';
-import { err, ok, type Result } from '@forgeax/engine-types';
-import { TemporalUnsupportedError } from '../errors/render';
-import { GPU_SHADER_STAGE_FRAGMENT } from '../gpu-stage';
-import { GPU_BUFFER_USAGE_COPY_DST, GPU_BUFFER_USAGE_UNIFORM } from '../gpu-usage';
-import type {
-  RenderPipelineBuildError,
-  RenderPipelineFeatureTarget,
-  RenderPipelineFrame,
-  RenderPipelineTemporalOutput,
-} from '../render-pipeline';
-import type { TaaHistoryGraphResources } from '../taa-history-store';
-
-export interface TaaResolvePipelineResources {
-  readonly pipeline: RenderPipeline;
-  readonly bindGroupLayout: BindGroupLayout;
-  readonly sampler: Sampler;
-}
-
-export function createTaaResolvePipelineResources(
-  device: RhiDevice,
-  module: ShaderModule,
-): Result<TaaResolvePipelineResources, RhiError> {
-  const bindGroupLayout = device.createBindGroupLayout({
-    label: 'taa-resolve-bgl',
-    entries: [
-      ...[0, 1, 2, 3].map((binding) => ({
-        binding,
-        visibility: GPU_SHADER_STAGE_FRAGMENT,
-        texture: { sampleType: 'float' as const, viewDimension: '2d' as const },
-      })),
-      {
-        binding: 4,
-        visibility: GPU_SHADER_STAGE_FRAGMENT,
-        sampler: { type: 'filtering' },
-      },
-      {
-        binding: 5,
-        visibility: GPU_SHADER_STAGE_FRAGMENT,
-        buffer: { type: 'uniform' },
-      },
-    ],
-  });
-  if (!bindGroupLayout.ok) return bindGroupLayout;
-  const pipelineLayout = device.createPipelineLayout({
-    label: 'taa-resolve-layout',
-    bindGroupLayouts: [bindGroupLayout.value],
-  });
-  if (!pipelineLayout.ok) return pipelineLayout;
-  const pipeline = device.createRenderPipeline({
-    label: 'taa-resolve',
-    layout: pipelineLayout.value as unknown as GPUPipelineLayout,
-    vertex: {
-      module: module as unknown as GPUShaderModule,
-      entryPoint: 'vs_taa_resolve',
-      buffers: [],
-    },
-    fragment: {
-      module: module as unknown as GPUShaderModule,
-      entryPoint: 'fs_taa_resolve',
-      targets: [{ format: 'rgba16float' }, { format: 'rgba16float' }],
-    },
-    primitive: { topology: 'triangle-list', cullMode: 'none' },
-  });
-  if (!pipeline.ok) return pipeline;
-  const sampler = device.createSampler({
-    label: 'taa-resolve-sampler',
-    magFilter: 'linear',
-    minFilter: 'linear',
-    mipmapFilter: 'nearest',
-    addressModeU: 'clamp-to-edge',
-    addressModeV: 'clamp-to-edge',
-  });
-  if (!sampler.ok) return sampler;
-  return ok({
-    pipeline: pipeline.value,
-    bindGroupLayout: bindGroupLayout.value,
-    sampler: sampler.value,
-  });
-}
-
-export function ensureTaaResolveParamsBuffer(
-  device: RhiDevice,
-  resources: { taaResolveParamsBuffer: Buffer | null },
-): Result<Buffer, RhiError> {
-  if (resources.taaResolveParamsBuffer !== null) return ok(resources.taaResolveParamsBuffer);
-  const created = device.createBuffer({
-    label: 'taa-resolve-params',
-    size: 16,
-    usage: GPU_BUFFER_USAGE_UNIFORM | GPU_BUFFER_USAGE_COPY_DST,
-    mappedAtCreation: false,
-  });
-  if (!created.ok) return created;
-  resources.taaResolveParamsBuffer = created.value;
-  return created;
-}
-
-function resolvedView(
-  resources: import('@forgeax/engine-render-graph').GraphResourceResolver,
-  view: import('@forgeax/engine-render-graph').GraphTextureView,
-): TextureView {
-  const resolved = resources.textureView(view);
-  if (!resolved.ok) throw resolved.error;
-  return resolved.value;
-}
-
-function createResolveBindGroup(
-  frame: RenderPipelineFrame,
-  views: readonly [TextureView, TextureView, TextureView, TextureView],
-): BindGroup {
-  const pass = frame.pipelineState.perPassResources;
-  const layout = pass.taaResolveBindGroupLayout;
-  const sampler = pass.taaResolveSampler;
-  const paramsBuffer = pass.taaResolveParamsBuffer;
-  if (layout === null || sampler === null || paramsBuffer === null) {
-    throw new TemporalUnsupportedError(
-      'resolve-resources-missing',
-      'renderer-owned TAA resolve resources',
-      'missing',
-    );
-  }
-  const created = frame.runtime.device.createBindGroup({
-    label: 'taa-resolve-bind-group',
-    layout,
-    entries: [
-      { binding: 0, resource: { kind: 'textureView', value: views[0] } },
-      { binding: 1, resource: { kind: 'textureView', value: views[1] } },
-      { binding: 2, resource: { kind: 'textureView', value: views[2] } },
-      { binding: 3, resource: { kind: 'textureView', value: views[3] } },
-      { binding: 4, resource: { kind: 'sampler', value: sampler } },
-      { binding: 5, resource: { kind: 'buffer', value: { buffer: paramsBuffer } } },
-    ],
-  });
-  if (!created.ok) throw created.error;
-  return created.value;
-}
-
-function writeResolveParams(frame: RenderPipelineFrame): void {
-  const temporalFrame = (
-    frame as RenderPipelineFrame & {
-      readonly temporalFrame?: import('../temporal-frame-transaction').TemporalFrameAttempt;
-    }
-  ).temporalFrame;
-  const view = temporalFrame?.view;
-  const buffer = frame.pipelineState.perPassResources.taaResolveParamsBuffer;
-  if (temporalFrame === undefined || view === undefined || buffer === null) {
-    throw new TemporalUnsupportedError(
-      'resolve-frame-missing',
-      'active TAA temporal view and params buffer',
-      'missing',
-    );
-  }
-  const bytes = new ArrayBuffer(16);
-  const floats = new Float32Array(bytes);
-  const integers = new Uint32Array(bytes);
-  floats[0] = view.currentJitterUv[0];
-  floats[1] = view.currentJitterUv[1];
-  integers[2] = temporalFrame.historyValid ? 1 : 0;
-  integers[3] = view.temporalFrameIndex;
-  const written = frame.runtime.device.queue.writeBuffer(buffer, 0, bytes);
-  if (!written.ok) throw written.error;
-}
-
-export function addTaaResolvePass(
-  graph: RenderGraphBuilder<RenderPipelineFrame>,
-  input: {
-    readonly sceneColor: RenderPipelineFeatureTarget;
-    readonly sceneTemporal: RenderPipelineFeatureTarget;
-    readonly history: TaaHistoryGraphResources | undefined;
-    readonly available: boolean;
-  },
-): Result<RenderPipelineTemporalOutput, RenderPipelineBuildError> {
-  if (!input.available || input.history === undefined) {
-    return err(
-      new TemporalUnsupportedError(
-        'resolve-resources-missing',
-        'renderer-owned TAA resolve resources and history generation',
-        'missing',
-      ),
-    );
-  }
-  const history = input.history;
-  const added = graph.addRasterPass('taa-resolve', {
-    accesses: [
-      { resource: input.sceneColor.view, usage: 'sampled-read' },
-      { resource: input.sceneTemporal.view, usage: 'sampled-read' },
-      { resource: history.colorRead.view, usage: 'sampled-read' },
-      { resource: history.temporalRead.view, usage: 'sampled-read' },
-      { resource: history.colorWrite.view, usage: 'color-attachment' },
-      { resource: history.temporalWrite.view, usage: 'color-attachment' },
-    ],
-    colorAttachments: [
-      { view: history.colorWrite.view, loadOp: 'clear', storeOp: 'store' },
-      {
-        view: history.temporalWrite.view,
-        loadOp: 'clear',
-        storeOp: 'store',
-        clearValue: { r: 0, g: 0, b: -1, a: 1 },
-      },
-    ],
-    encode: ({ pass, frame, resources }) => {
-      const pipeline = frame.pipelineState.perPassResources.taaResolvePipeline;
-      if (pipeline === null) {
-        throw new TemporalUnsupportedError(
-          'resolve-resources-missing',
-          'compiled renderer-owned TAA resolve pipeline',
-          'missing',
-        );
-      }
-      writeResolveParams(frame);
-      const bindGroup = createResolveBindGroup(frame, [
-        resolvedView(resources, input.sceneColor.view),
-        resolvedView(resources, input.sceneTemporal.view),
-        resolvedView(resources, history.colorRead.view),
-        resolvedView(resources, history.temporalRead.view),
-      ]);
-      pass.setPipeline(pipeline);
-      pass.setBindGroup(0, bindGroup);
-      pass.draw(3, 1, 0, 0);
-    },
-  });
-  return added.ok
-    ? ok({
-        resolvedColor: {
-          kind: 'scene-color',
-          texture: history.colorWrite.texture,
-          view: history.colorWrite.view,
-          format: 'rgba16float',
-          sampleCount: 1,
-        },
-      })
-    : added;
-}

package/src/frame-chain.ts

@@ -1,21 +0,0 @@
-import type { RenderResult } from './renderer';
-
-export interface ExtractedFrame {
-  readonly worlds: readonly unknown[];
-}
-export interface PreparedFrame {
-  readonly extracted: ExtractedFrame;
-  readonly resources: Map<unknown, unknown>;
-}
-export function buildFrameChain(worlds: readonly unknown[]): ExtractedFrame {
-  return { worlds };
-}
-export function prepareFrame(
-  extracted: ExtractedFrame,
-  options: { resources: Map<unknown, unknown> },
-): PreparedFrame {
-  return { extracted, resources: options.resources };
-}
-export function recordFrame(_frame: PreparedFrame): RenderResult<void, Error> {
-  return { ok: true, value: undefined };
-}