@forgeax/engine-render 0.1.32 → 0.1.34

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

@@ -4,12 +4,21 @@ export interface MotionBlurParams {
   readonly shutterAngle: number;
   readonly maxRadiusPixels: number;
   readonly sampleCount: number;
+  /** Target presentation rate used to convert frame displacement to exposure. 0 follows frame time. */
+  readonly targetFps: number;
 }
 
+/** WGSL uniform size for the renderer-owned Motion Blur parameter block. */
+export const MOTION_BLUR_PARAMS_BYTE_SIZE = 32;
+
+/** The only quality tiers the shader is allowed to execute. */
+export type MotionBlurSampleTier = 0 | 4 | 8 | 16;
+
 export const DEFAULT_MOTION_BLUR_PARAMS: MotionBlurParams = Object.freeze({
   shutterAngle: 180,
   maxRadiusPixels: 32,
   sampleCount: 8,
+  targetFps: 60,
 });
 
 export interface MotionBlurInvalidParamsDetail {
@@ -68,17 +77,76 @@ export function validateMotionBlurParams(
   const shutterAngle = value.shutterAngle ?? DEFAULT_MOTION_BLUR_PARAMS.shutterAngle;
   const maxRadiusPixels = value.maxRadiusPixels ?? DEFAULT_MOTION_BLUR_PARAMS.maxRadiusPixels;
   const sampleCount = value.sampleCount ?? DEFAULT_MOTION_BLUR_PARAMS.sampleCount;
+  const targetFps = value.targetFps ?? DEFAULT_MOTION_BLUR_PARAMS.targetFps;
   const shutterError = validateField('shutterAngle', shutterAngle, 0, 360);
   if (shutterError !== undefined) return err(shutterError);
   const radiusError = validateField('maxRadiusPixels', maxRadiusPixels, 0, 64);
   if (radiusError !== undefined) return err(radiusError);
   const sampleError = validateField('sampleCount', sampleCount, 4, 16, true);
   if (sampleError !== undefined) return err(sampleError);
-  return ok(Object.freeze({ shutterAngle, maxRadiusPixels, sampleCount }));
+  const targetFpsError = validateField('targetFps', targetFps, 0, 240, true);
+  if (targetFpsError !== undefined) return err(targetFpsError);
+  return ok(Object.freeze({ shutterAngle, maxRadiusPixels, sampleCount, targetFps }));
 }
 
 export function motionBlurTemporalDemand(params: MotionBlurParams | undefined): boolean {
-  return params !== undefined && params.shutterAngle > 0;
+  return params !== undefined && params.shutterAngle > 0 && params.maxRadiusPixels > 0;
+}
+
+/** Round authored work down to the bounded shader tiers without changing exposure length. */
+export function effectiveMotionBlurSampleCount(sampleCount: number): MotionBlurSampleTier {
+  if (!Number.isFinite(sampleCount) || sampleCount < 4) return 0;
+  if (sampleCount < 8) return 4;
+  if (sampleCount < 16) return 8;
+  return 16;
+}
+
+/** Reject a frame interval that cannot represent a stable temporal pair. */
+export function isMotionBlurIntervalValid(frameDeltaSeconds: number): boolean {
+  return Number.isFinite(frameDeltaSeconds) && frameDeltaSeconds > 0 && frameDeltaSeconds <= 0.1;
+}
+
+/**
+ * Convert current-to-previous frame displacement into the authored target-rate exposure.
+ * Invalid intervals return zero so callers can commit a fresh baseline without blurring it.
+ */
+export function motionBlurExposureScale(frameDeltaSeconds: number, targetFps: number): number {
+  if (!isMotionBlurIntervalValid(frameDeltaSeconds)) return 0;
+  if (
+    !Number.isFinite(targetFps) ||
+    targetFps < 0 ||
+    targetFps > 240 ||
+    !Number.isInteger(targetFps)
+  ) {
+    return 0;
+  }
+  if (targetFps === 0) return 1;
+  return 1 / (targetFps * frameDeltaSeconds);
+}
+
+/**
+ * Derive a render interval from the host sample clock before ECS time policy
+ * clamps it. A finite raw pair is never clamped here, so a hitch remains
+ * visible to temporal admission.
+ */
+export function motionBlurSampleDelta(
+  sampleTimeSeconds: number | undefined,
+  previousSampleTimeSeconds: number | undefined,
+  fallbackDeltaSeconds: number,
+): number {
+  // An explicitly supplied non-finite sample is a temporal discontinuity. Do
+  // not silently replace it with ECS delta: that would turn a corrupt host or
+  // replay clock into an apparently valid blur interval.
+  if (
+    (sampleTimeSeconds !== undefined && !Number.isFinite(sampleTimeSeconds)) ||
+    (previousSampleTimeSeconds !== undefined && !Number.isFinite(previousSampleTimeSeconds))
+  ) {
+    return Number.NaN;
+  }
+  if (Number.isFinite(sampleTimeSeconds) && Number.isFinite(previousSampleTimeSeconds)) {
+    return (sampleTimeSeconds as number) - (previousSampleTimeSeconds as number);
+  }
+  return fallbackDeltaSeconds;
 }
 
 export function resolveMotionBlurParams(

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

@@ -0,0 +1,176 @@
+import type { MotionBlurExecutionReceipt, MotionBlurInspection } from '../../inspection-types';
+import type { CameraSnapshot } from '../../render-contract';
+import type { TemporalFrameTransactionInspection } from '../../temporal/frame';
+import type { TemporalView } from '../../temporal/view';
+import type { MotionBlurFeatureInput } from './motion-blur-feature';
+import {
+  DEFAULT_MOTION_BLUR_PARAMS,
+  effectiveMotionBlurSampleCount,
+  isMotionBlurIntervalValid,
+  type MotionBlurValidationError,
+  motionBlurSampleDelta,
+  motionBlurTemporalDemand,
+} from './motion-blur-params';
+
+export interface MotionBlurRuntimeCapabilities {
+  readonly compute: boolean;
+  readonly storageBuffer: boolean;
+  readonly storageTexture: boolean;
+  readonly rgba16floatRenderable: boolean;
+}
+
+export interface MotionBlurFramePlan {
+  readonly rawSampleDelta: number;
+  readonly demanded: boolean;
+  readonly featureInput: MotionBlurFeatureInput | undefined;
+}
+
+export interface MotionBlurDrawOptions {
+  readonly sampleTimeSeconds?: number;
+  readonly temporalReset?: true;
+}
+
+export function motionBlurDrawOptions(input: {
+  readonly sampleTimeSeconds?: number;
+  readonly temporalReset?: boolean;
+}): MotionBlurDrawOptions {
+  return {
+    ...(input.sampleTimeSeconds === undefined
+      ? {}
+      : { sampleTimeSeconds: input.sampleTimeSeconds }),
+    ...(input.temporalReset === true ? { temporalReset: true as const } : {}),
+  };
+}
+
+/** Derive one motion-blur temporal plan before the record transaction starts. */
+export function planMotionBlurFrame(input: {
+  readonly params: CameraSnapshot['motionBlur'];
+  readonly sampleTimeSeconds: number | undefined;
+  readonly acceptedSampleTimeSeconds: number | undefined;
+  readonly fallbackDeltaSeconds: number;
+  readonly acceptedTemporal: TemporalView | undefined;
+  readonly temporalReset: boolean;
+  readonly width: number;
+  readonly height: number;
+  readonly cameraViewIdentity: string;
+  readonly historyVersion: number;
+  readonly environmentSignature: string;
+  readonly fogSignature: string;
+  readonly deviceGeneration: number;
+}): MotionBlurFramePlan {
+  const rawSampleDelta = motionBlurSampleDelta(
+    input.sampleTimeSeconds,
+    input.acceptedSampleTimeSeconds,
+    input.fallbackDeltaSeconds,
+  );
+  const accepted = input.acceptedTemporal;
+  const reset =
+    input.temporalReset ||
+    accepted === undefined ||
+    (accepted.historyValid === false && accepted.resetReason === undefined) ||
+    !isMotionBlurIntervalValid(rawSampleDelta) ||
+    accepted.input.width !== input.width ||
+    accepted.input.height !== input.height ||
+    accepted.input.viewIdentity !== input.cameraViewIdentity ||
+    accepted.input.historyVersion !== input.historyVersion ||
+    accepted.input.environmentSignature !== input.environmentSignature ||
+    accepted.input.fogSignature !== input.fogSignature ||
+    accepted.input.deviceGeneration !== input.deviceGeneration;
+  const params =
+    input.params === undefined
+      ? undefined
+      : { ...input.params, targetFps: input.params.targetFps ?? 60 };
+  const demanded = motionBlurTemporalDemand(params);
+  return {
+    rawSampleDelta,
+    demanded,
+    featureInput:
+      params === undefined
+        ? undefined
+        : {
+            params,
+            frameDeltaSeconds: rawSampleDelta,
+            reset: demanded && reset,
+          },
+  };
+}
+
+/** Project the bounded inspection record without exposing renderer internals. */
+export function projectMotionBlurInspection(input: {
+  readonly camera: CameraSnapshot | undefined;
+  readonly invalidParams: MotionBlurValidationError | undefined;
+  readonly capabilities: MotionBlurRuntimeCapabilities;
+  readonly acceptedTemporal: TemporalView | undefined;
+  readonly transaction: TemporalFrameTransactionInspection;
+  readonly execution: MotionBlurExecutionReceipt | undefined;
+  readonly temporalFrameId: number | undefined;
+  readonly deviceGeneration: number;
+  readonly graphGeneration: number;
+}): MotionBlurInspection | undefined {
+  if (input.camera?.motionBlur === undefined && input.invalidParams === undefined) {
+    return undefined;
+  }
+  const motionBlur =
+    input.camera?.motionBlur === undefined
+      ? DEFAULT_MOTION_BLUR_PARAMS
+      : { ...input.camera.motionBlur, targetFps: input.camera.motionBlur.targetFps ?? 60 };
+  const demanded = motionBlurTemporalDemand(motionBlur);
+  const unavailable = demanded && !input.capabilities.rgba16floatRenderable;
+  const lane =
+    input.capabilities.compute &&
+    input.capabilities.storageBuffer &&
+    input.capabilities.storageTexture &&
+    input.capabilities.rgba16floatRenderable
+      ? ('compute' as const)
+      : ('raster-limited' as const);
+  const accepted = input.acceptedTemporal;
+  const submitFailure =
+    input.transaction.lastFailure === 'queue-submit-failed' ||
+    accepted?.resetReason === 'submit-failure';
+  const execution = input.execution;
+  const executionAccepted =
+    execution !== undefined &&
+    input.temporalFrameId === execution.frameId &&
+    execution.deviceGeneration === input.deviceGeneration &&
+    execution.graphGeneration === input.graphGeneration;
+  const active =
+    demanded &&
+    !unavailable &&
+    lane === 'compute' &&
+    executionAccepted &&
+    accepted?.historyValid === true &&
+    accepted.resetReason === undefined;
+  return {
+    enabled: demanded,
+    status:
+      input.invalidParams !== undefined
+        ? 'invalid'
+        : !demanded
+          ? 'off'
+          : active
+            ? 'active'
+            : !unavailable && lane === 'raster-limited'
+              ? 'limited'
+              : 'reset',
+    lane,
+    shutterAngle: motionBlur.shutterAngle,
+    maxRadiusPixels: motionBlur.maxRadiusPixels,
+    sampleCount: motionBlur.sampleCount,
+    targetFps: motionBlur.targetFps ?? 60,
+    effectiveSampleCount: !demanded ? 0 : effectiveMotionBlurSampleCount(motionBlur.sampleCount),
+    temporalDemand: demanded ? 'scene-data-temporal-v1' : 'none',
+    passName: 'motion-blur',
+    historyWrites: 0,
+    passCount: !demanded ? 0 : executionAccepted ? 2 : lane === 'raster-limited' ? 1 : 0,
+    tapBudget: !demanded ? 0 : effectiveMotionBlurSampleCount(motionBlur.sampleCount),
+    ...(executionAccepted ? { execution } : {}),
+    ...(accepted?.resetReason === undefined ? {} : { resetReason: accepted.resetReason }),
+    ...(input.invalidParams !== undefined
+      ? { lastFailure: 'invalid-params' as const }
+      : unavailable
+        ? { lastFailure: 'scene-data-unavailable' as const }
+        : submitFailure
+          ? { lastFailure: 'submit-failure' as const }
+          : {}),
+  };
+}

package/src/features/plan.ts

@@ -2,7 +2,7 @@ import type { GraphBufferAccess, GraphTextureAccess } from '@forgeax/engine-rend
 import type { RhiCaps, TextureFormat } from '@forgeax/engine-rhi';
 import { err, ok, type Result } from '@forgeax/engine-types';
 import type { RenderError } from '../errors/render';
-import type { SceneDataTarget } from '../temporal/scene-data';
+import { isSceneDataTarget, type SceneDataTarget } from '../temporal/scene-data';
 import type {
   RenderFeatureGpuBufferUsage,
   RenderFeatureGpuProgramDescriptor,
@@ -51,7 +51,13 @@ export interface RenderFeatureFullscreenProgramDeclaration {
   readonly kind: 'fullscreen-program';
   readonly name: string;
   readonly source: string;
+  /** Optional fragment entry point when one WGSL module owns multiple passes. */
+  readonly fragmentEntryPoint?: string;
   readonly reads?: readonly RenderFeatureFullscreenRead[];
+  /** Bind the renderer-owned View group at group(0) for camera reconstruction. */
+  readonly usesView?: boolean;
+  /** Read-only storage buffers appended after the regular color/depth reads. */
+  readonly storageBindings?: readonly number[];
   readonly params?: {
     readonly byteSize: number;
     readonly defaultValue: Uint8Array;
@@ -100,8 +106,8 @@ export type RenderFeatureResourceDeclaration =
           }
         | { readonly kind: 'texture-view'; readonly value: unknown }
         | { readonly kind: 'sampler'; readonly value: unknown };
-      /** Optional graph target that backs a resident sampled resource. */
-      readonly logicalTarget?: string;
+      /** Optional graph target or semantic scene-data target backing the resource. */
+      readonly logicalTarget?: RenderFeatureSampledTarget;
     }
   | {
       readonly kind: 'compute-bindings';
@@ -244,7 +250,12 @@ export interface RenderFeatureLogicalTarget {
 
 export interface RenderFeaturePlanContext {
   readonly caps: Readonly<RhiCaps>;
-  readonly frame: { readonly frameNumber: number };
+  readonly frame: {
+    readonly frameNumber: number;
+    /** Physical render extent used for bounded compute dispatch sizing. */
+    readonly width?: number;
+    readonly height?: number;
+  };
   readonly generation: number;
   readonly targets: readonly RenderFeatureLogicalTarget[];
   /** Read-only semantic scene-data resolver bound to this plan generation. */
@@ -270,10 +281,12 @@ export interface RenderFeaturePlannedFrame {
   readonly generation: number;
   readonly signature: string;
   readonly plan: RenderFeaturePlan;
+  /** Placement selected by the installed feature; omitted means the legacy post stage. */
+  readonly placement?: import('./types').RenderFeaturePlacement;
 }
 
 export interface RenderFeatureDerivedAccess {
-  readonly resource: string;
+  readonly resource: string | SceneDataTarget;
   readonly usage: RenderFeatureResourceUsage;
 }
 
@@ -821,7 +834,16 @@ export function deriveRenderFeaturePassAccess(
           declaration?.kind === 'prepared-gpu-resource' &&
           declaration.logicalTarget !== undefined
         ) {
-          accesses.push({ resource: declaration.logicalTarget, usage: 'sampled-read' });
+          const layout = layoutEntries.find((candidate) => candidate.binding === entry.binding);
+          const usage =
+            layout?.storageTexture?.access === 'write-only'
+              ? 'storage-write'
+              : layout?.storageTexture?.access === 'read-only'
+                ? 'storage-read'
+                : layout?.storageTexture?.access === 'read-write'
+                  ? 'sampled-storage-read-write'
+                  : 'sampled-read';
+          accesses.push({ resource: declaration.logicalTarget, usage });
         }
       }
     }
@@ -895,7 +917,9 @@ export function freezeRenderFeaturePlan(
     if (
       resource.kind === 'prepared-gpu-resource' &&
       resource.logicalTarget !== undefined &&
-      !targets.has(resource.logicalTarget)
+      !(typeof resource.logicalTarget === 'string'
+        ? targets.has(resource.logicalTarget)
+        : isSceneDataTarget(resource.logicalTarget))
     ) {
       return err(stageFailure(identity));
     }
@@ -926,7 +950,8 @@ export function freezeRenderFeaturePlan(
         const validPrepared =
           resource?.kind === 'prepared-gpu-resource' &&
           ((resource.resource.kind === 'buffer' && layout?.buffer !== undefined) ||
-            (resource.resource.kind === 'texture-view' && layout?.texture !== undefined) ||
+            (resource.resource.kind === 'texture-view' &&
+              (layout?.texture !== undefined || layout?.storageTexture !== undefined)) ||
             (resource.resource.kind === 'sampler' && layout?.sampler !== undefined));
         if (!validBuffer && !validPrepared) {
           return err(stageFailure(identity));

package/src/features/prepared-gpu-work.ts

@@ -17,9 +17,13 @@ import { type BindGroupLayoutDescriptor, err, ok, type Result } from '@forgeax/e
 import type { DeviceScope, LifecycleResourceSpec } from '../device/device-scope';
 import { type RenderError, RenderFeaturePreparationFailedError } from '../errors/render';
 import type { PipelineBuilderShaderModuleFactory } from '../pipeline-builder';
+import type { SceneDataTarget } from '../temporal/scene-data';
 import type { RenderFeatureTargetHandle } from './targets';
 import type { RenderFeatureShaderModuleMode } from './types';
 
+/** A graph target that can be late-bound at encode time. */
+export type RenderFeatureComputeTarget = string | RenderFeatureTargetHandle | SceneDataTarget;
+
 declare const RenderFeatureGpuProgramBrand: unique symbol;
 export interface RenderFeatureGpuProgramRef {
   readonly [RenderFeatureGpuProgramBrand]: void;
@@ -104,8 +108,8 @@ export interface RenderFeatureGpuPrepare {
   ): Result<RenderFeatureGpuBufferRef, RenderError>;
   prepareTextureView(
     name: string,
-    resource: TextureView,
-    logicalTarget?: RenderFeatureTargetHandle,
+    resource: TextureView | undefined,
+    logicalTarget?: RenderFeatureComputeTarget,
   ): Result<RenderFeatureGpuTextureViewRef, RenderError>;
   prepareSampler(name: string, resource: Sampler): Result<RenderFeatureGpuSamplerRef, RenderError>;
   prepareBindings(
@@ -141,7 +145,8 @@ export interface RenderFeatureGpuComputePassDescriptor {
 }
 
 export interface RenderFeatureResolvedGpuComputePass {
-  readonly sampledTargets?: readonly RenderFeatureTargetHandle[];
+  readonly sampledTargets?: readonly RenderFeatureComputeTarget[];
+  readonly storageTargets?: readonly RenderFeatureComputeTarget[];
   readonly buffers: readonly {
     readonly name: string;
     readonly buffer: Buffer;
@@ -154,7 +159,7 @@ export interface RenderFeatureResolvedGpuComputePass {
         readonly pipeline: ComputePipeline;
         readonly bindGroup: BindGroup;
         readonly resolveBindGroup?: (
-          resolve: (target: RenderFeatureTargetHandle) => TextureView,
+          resolve: (target: RenderFeatureComputeTarget) => TextureView,
         ) => BindGroup;
         readonly workgroups: readonly [number, number, number];
       }
@@ -162,7 +167,7 @@ export interface RenderFeatureResolvedGpuComputePass {
         readonly pipeline: ComputePipeline;
         readonly bindGroup: BindGroup;
         readonly resolveBindGroup?: (
-          resolve: (target: RenderFeatureTargetHandle) => TextureView,
+          resolve: (target: RenderFeatureComputeTarget) => TextureView,
         ) => BindGroup;
         readonly indirectBuffer: Buffer;
         readonly indirectOffset: number;
@@ -179,7 +184,7 @@ export interface RenderFeatureResolvedGpuBuffer {
 export function encodeRenderFeatureGpuComputePass(
   pass: RhiComputePassEncoder,
   work: RenderFeatureResolvedGpuComputePass,
-  resolveTarget?: (target: RenderFeatureTargetHandle) => TextureView,
+  resolveTarget?: (target: RenderFeatureComputeTarget) => TextureView,
 ): void {
   for (const dispatch of work.dispatches) {
     pass.setPipeline(dispatch.pipeline);
@@ -221,6 +226,10 @@ interface ProgramItem {
   readonly pipelines: ReadonlyMap<string, ComputePipeline>;
   readonly bindGroupLayout?: BindGroupLayout;
   readonly bindingLayouts: ReadonlyMap<number, GPUBufferBindingType>;
+  readonly textureBindings: ReadonlyMap<
+    number,
+    'sampled' | 'storage-write' | 'storage-read' | 'storage-read-write'
+  >;
 }
 
 interface BufferItem {
@@ -234,9 +243,9 @@ interface BufferItem {
 }
 
 interface TextureViewItem {
-  readonly logicalTarget?: RenderFeatureTargetHandle;
+  readonly logicalTarget?: RenderFeatureComputeTarget;
   readonly name: string;
-  readonly resource: TextureView;
+  readonly resource: TextureView | undefined;
   readonly reference: RenderFeatureGpuTextureViewRef;
 }
 
@@ -248,7 +257,7 @@ interface SamplerItem {
 
 interface BindingResourceItem {
   readonly binding: number;
-  readonly resource: RhiBindingResource;
+  readonly resource?: RhiBindingResource;
   readonly buffer?: BufferItem;
   readonly textureView?: TextureViewItem;
   readonly sampler?: SamplerItem;
@@ -623,6 +632,24 @@ function createRenderFeatureGpuWorkSession(input: {
       pipelineMap.set(entryPoint, pipeline.value);
     }
     const reference = Object.freeze({ generation: input.generation }) as RenderFeatureGpuProgramRef;
+    const textureBindings = new Map<
+      number,
+      'sampled' | 'storage-write' | 'storage-read' | 'storage-read-write'
+    >();
+    for (const entry of descriptor.bindings?.[0]?.entries ?? []) {
+      if (entry.texture !== undefined) {
+        textureBindings.set(entry.binding, 'sampled');
+      } else if (entry.storageTexture !== undefined) {
+        textureBindings.set(
+          entry.binding,
+          entry.storageTexture.access === 'write-only'
+            ? 'storage-write'
+            : entry.storageTexture.access === 'read-only'
+              ? 'storage-read'
+              : 'storage-read-write',
+        );
+      }
+    }
     const item = {
       name,
       descriptor: cloneProgramDescriptor(descriptor),
@@ -636,6 +663,7 @@ function createRenderFeatureGpuWorkSession(input: {
             : [[entry.binding, entry.buffer.type ?? 'uniform'] as const],
         ),
       ),
+      textureBindings,
       ...(bindGroupLayout === undefined ? {} : { bindGroupLayout }),
     };
     programs.set(name, item);
@@ -964,7 +992,9 @@ function createRenderFeatureGpuWorkSession(input: {
         }
         entryItems.push({
           binding: entry.binding,
-          resource: { kind: 'textureView', value: item.resource },
+          ...(item.resource === undefined
+            ? {}
+            : { resource: { kind: 'textureView' as const, value: item.resource } }),
           textureView: item,
         });
         continue;
@@ -992,7 +1022,7 @@ function createRenderFeatureGpuWorkSession(input: {
       entries: entryItems.map((entry) => [
         entry.binding,
         entry.buffer?.name ?? entry.textureView?.name ?? entry.sampler?.name,
-        entry.resource.kind,
+        entry.resource?.kind ?? 'late-texture',
       ]),
     });
     const prior = bindings.get(name) ?? parkedBindings.get(name)?.item;
@@ -1026,15 +1056,32 @@ function createRenderFeatureGpuWorkSession(input: {
         ),
       );
     }
-    const created = input.device.createBindGroup({
-      label: name,
-      layout,
-      entries: entryItems.map((entry) => ({
-        binding: entry.binding,
-        resource: entry.resource,
-      })),
-    });
-    if (!created.ok) {
+    const hasLateTextures = entryItems.some(
+      (entry) => entry.textureView?.logicalTarget !== undefined,
+    );
+    const hasMissingResource = entryItems.some((entry) => entry.resource === undefined);
+    if (hasMissingResource && !hasLateTextures) {
+      return err(
+        failure(
+          input.featureIdentity,
+          'prepare-gpu-bindings',
+          'bindings',
+          name,
+          'texture-view-unavailable',
+        ),
+      );
+    }
+    const created = hasLateTextures
+      ? undefined
+      : input.device.createBindGroup({
+          label: name,
+          layout,
+          entries: entryItems.map((entry) => ({
+            binding: entry.binding,
+            resource: entry.resource as RhiBindingResource,
+          })),
+        });
+    if (created !== undefined && !created.ok) {
       return err(
         failure(
           input.featureIdentity,
@@ -1057,7 +1104,10 @@ function createRenderFeatureGpuWorkSession(input: {
       buffers: entryItems.flatMap((entry) =>
         entry.buffer === undefined ? [] : [{ binding: entry.binding, item: entry.buffer }],
       ),
-      bindGroup: created.value,
+      // A bind group with semantic targets is created once the graph resolves
+      // the current generation's physical views. The placeholder is never
+      // encoded because resolveComputePass installs resolveBindGroup.
+      bindGroup: created?.value as BindGroup,
     };
     bindings.set(name, item);
     bindingRefs.set(reference, item);
@@ -1188,7 +1238,7 @@ function createRenderFeatureGpuWorkSession(input: {
           (entry) => entry.textureView?.logicalTarget !== undefined,
         )
           ? {
-              resolveBindGroup: (resolve: (target: RenderFeatureTargetHandle) => TextureView) => {
+              resolveBindGroup: (resolve: (target: RenderFeatureComputeTarget) => TextureView) => {
                 const layout =
                   program.bindGroupLayout ??
                   (pipeline as ComputePipeline & RhiComputePipelineOps).getBindGroupLayout(0);
@@ -1199,7 +1249,7 @@ function createRenderFeatureGpuWorkSession(input: {
                     binding: entry.binding,
                     resource:
                       entry.textureView?.logicalTarget === undefined
-                        ? entry.resource
+                        ? (entry.resource as RhiBindingResource)
                         : {
                             kind: 'textureView' as const,
                             value: resolve(entry.textureView.logicalTarget),
@@ -1289,19 +1339,20 @@ function createRenderFeatureGpuWorkSession(input: {
         accesses.add('indirect-read');
         resolvedBuffers.set(item, accesses);
       }
+      const sampledTargets = new Set<RenderFeatureComputeTarget>();
+      const storageTargets = new Set<RenderFeatureComputeTarget>();
+      for (const item of dispatchBindings) {
+        for (const entry of item?.entries ?? []) {
+          const target = entry.textureView?.logicalTarget;
+          if (target === undefined) continue;
+          const role = program.textureBindings.get(entry.binding) ?? 'sampled';
+          if (role === 'sampled') sampledTargets.add(target);
+          else storageTargets.add(target);
+        }
+      }
       return ok({
-        sampledTargets: [
-          ...new Set(
-            dispatchBindings.flatMap(
-              (item) =>
-                item?.entries.flatMap((entry) =>
-                  entry.textureView?.logicalTarget === undefined
-                    ? []
-                    : [entry.textureView.logicalTarget],
-                ) ?? [],
-            ),
-          ),
-        ],
+        sampledTargets: [...sampledTargets],
+        storageTargets: [...storageTargets],
         buffers: [...resolvedBuffers].flatMap(([item, accesses]) =>
           [...accesses].map((access) => ({
             name: item.name,

package/src/features/render-graph-compute.ts

@@ -9,6 +9,7 @@ import {
   RenderFeatureDrawRecordingFailedError,
   RenderFeatureStageFailedError,
 } from '../errors/render';
+import type { RenderFeatureComputeTarget } from './prepared-gpu-work';
 import {
   encodeRenderFeatureGpuComputePass,
   type RenderFeatureResolvedGpuComputePass,
@@ -19,7 +20,6 @@ import {
   importRenderFeatureGraphBuffer,
   type RenderFeatureGraphBufferState,
 } from './render-graph-resources';
-import type { RenderFeatureTargetHandle } from './targets';
 
 export class RenderFeatureComputeGraphProjection<FrameCtx extends RenderGraphFrame> {
   private readonly resources: RenderFeatureGraphBufferState;
@@ -41,22 +41,30 @@ export class RenderFeatureComputeGraphProjection<FrameCtx extends RenderGraphFra
   ): Result<void, RenderGraphError | RenderError> {
     const accesses = [];
     const targets = new Map<
-      RenderFeatureTargetHandle,
+      RenderFeatureComputeTarget,
       NonNullable<ReturnType<RenderFeatureGraphTargetResolver>>
     >();
-    for (const handle of work.sampledTargets ?? []) {
+    const sampledTargets = new Set(work.sampledTargets ?? []);
+    const storageTargets = new Set(work.storageTargets ?? []);
+    for (const handle of [...sampledTargets, ...storageTargets]) {
       let target = this.resolveTarget?.(handle);
       if (target === undefined)
         return err(
           new RenderFeatureStageFailedError(featureIdentity, order, 'record', 'renderer-recover'),
         );
-      if (handle.kind === 'scene-depth') {
+      if (typeof handle !== 'string' && handle.kind === 'scene-depth') {
         const view = this.builder.view(target.texture, { aspect: 'depth-only' });
         if (!view.ok) return view;
         target = { ...target, view: view.value };
       }
       targets.set(handle, target);
-      accesses.push({ resource: target.view, usage: 'sampled-read' as const });
+      if (sampledTargets.has(handle) && storageTargets.has(handle)) {
+        accesses.push({ resource: target.view, usage: 'sampled-storage-read-write' as const });
+      } else if (storageTargets.has(handle)) {
+        accesses.push({ resource: target.view, usage: 'storage-write' as const });
+      } else {
+        accesses.push({ resource: target.view, usage: 'sampled-read' as const });
+      }
     }
     for (const resource of work.buffers) {
       const imported = importRenderFeatureGraphBuffer(