@forgeax/engine-render 0.1.28 → 0.1.30

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

@@ -5,15 +5,19 @@ import type {
   Buffer,
   ComputePipeline,
   PipelineLayout,
+  RhiBindingResource,
   RhiComputePassEncoder,
   RhiComputePipelineOps,
   RhiDevice,
+  Sampler,
   ShaderModule,
+  TextureView,
 } from '@forgeax/engine-rhi';
 import { type BindGroupLayoutDescriptor, err, ok, type Result } from '@forgeax/engine-types';
 import type { DeviceScope, LifecycleResourceSpec } from '../device/device-scope';
 import { type RenderError, RenderFeaturePreparationFailedError } from '../errors/render';
 import type { PipelineBuilderShaderModuleFactory } from '../pipeline-builder';
+import type { RenderFeatureTargetHandle } from './targets';
 import type { RenderFeatureShaderModuleMode } from './types';
 
 declare const RenderFeatureGpuProgramBrand: unique symbol;
@@ -29,6 +33,25 @@ export interface RenderFeatureGpuBufferRef {
   readonly generation: number;
 }
 
+declare const RenderFeatureGpuTextureViewBrand: unique symbol;
+export interface RenderFeatureGpuTextureViewRef {
+  readonly [RenderFeatureGpuTextureViewBrand]: void;
+  readonly name: string;
+  readonly generation: number;
+}
+
+declare const RenderFeatureGpuSamplerBrand: unique symbol;
+export interface RenderFeatureGpuSamplerRef {
+  readonly [RenderFeatureGpuSamplerBrand]: void;
+  readonly name: string;
+  readonly generation: number;
+}
+
+export type RenderFeatureGpuPreparedResourceRef =
+  | { readonly kind: 'buffer'; readonly reference: RenderFeatureGpuBufferRef }
+  | { readonly kind: 'texture-view'; readonly reference: RenderFeatureGpuTextureViewRef }
+  | { readonly kind: 'sampler'; readonly reference: RenderFeatureGpuSamplerRef };
+
 declare const RenderFeatureGpuBindingsBrand: unique symbol;
 export interface RenderFeatureGpuBindingsRef {
   readonly [RenderFeatureGpuBindingsBrand]: void;
@@ -57,10 +80,10 @@ export interface RenderFeatureGpuBufferDescriptor {
 
 export interface RenderFeatureGpuBindingsDescriptor {
   readonly program: RenderFeatureGpuProgramRef;
-  readonly entries: readonly {
-    readonly binding: number;
-    readonly buffer: RenderFeatureGpuBufferRef;
-  }[];
+  readonly entries: readonly (
+    | { readonly binding: number; readonly buffer: RenderFeatureGpuBufferRef }
+    | { readonly binding: number; readonly resource: RenderFeatureGpuPreparedResourceRef }
+  )[];
 }
 
 export interface RenderFeatureGpuPrepare {
@@ -73,6 +96,18 @@ export interface RenderFeatureGpuPrepare {
     name: string,
     descriptor: RenderFeatureGpuBufferDescriptor,
   ): Result<RenderFeatureGpuBufferRef, RenderError>;
+  /** Adopt a provider-owned resident buffer without taking destruction ownership. */
+  prepareBufferResource(
+    name: string,
+    resource: Buffer,
+    descriptor: Pick<RenderFeatureGpuBufferDescriptor, 'size' | 'usage'>,
+  ): Result<RenderFeatureGpuBufferRef, RenderError>;
+  prepareTextureView(
+    name: string,
+    resource: TextureView,
+    logicalTarget?: RenderFeatureTargetHandle,
+  ): Result<RenderFeatureGpuTextureViewRef, RenderError>;
+  prepareSampler(name: string, resource: Sampler): Result<RenderFeatureGpuSamplerRef, RenderError>;
   prepareBindings(
     name: string,
     descriptor: RenderFeatureGpuBindingsDescriptor,
@@ -106,6 +141,7 @@ export interface RenderFeatureGpuComputePassDescriptor {
 }
 
 export interface RenderFeatureResolvedGpuComputePass {
+  readonly sampledTargets?: readonly RenderFeatureTargetHandle[];
   readonly buffers: readonly {
     readonly name: string;
     readonly buffer: Buffer;
@@ -117,11 +153,17 @@ export interface RenderFeatureResolvedGpuComputePass {
     | {
         readonly pipeline: ComputePipeline;
         readonly bindGroup: BindGroup;
+        readonly resolveBindGroup?: (
+          resolve: (target: RenderFeatureTargetHandle) => TextureView,
+        ) => BindGroup;
         readonly workgroups: readonly [number, number, number];
       }
     | {
         readonly pipeline: ComputePipeline;
         readonly bindGroup: BindGroup;
+        readonly resolveBindGroup?: (
+          resolve: (target: RenderFeatureTargetHandle) => TextureView,
+        ) => BindGroup;
         readonly indirectBuffer: Buffer;
         readonly indirectOffset: number;
       }
@@ -137,10 +179,19 @@ export interface RenderFeatureResolvedGpuBuffer {
 export function encodeRenderFeatureGpuComputePass(
   pass: RhiComputePassEncoder,
   work: RenderFeatureResolvedGpuComputePass,
+  resolveTarget?: (target: RenderFeatureTargetHandle) => TextureView,
 ): void {
   for (const dispatch of work.dispatches) {
     pass.setPipeline(dispatch.pipeline);
-    pass.setBindGroup(0, dispatch.bindGroup);
+    if (dispatch.resolveBindGroup !== undefined && resolveTarget === undefined) {
+      throw new Error('Graph texture resolver required for sampled compute work');
+    }
+    pass.setBindGroup(
+      0,
+      dispatch.resolveBindGroup !== undefined && resolveTarget !== undefined
+        ? dispatch.resolveBindGroup(resolveTarget)
+        : dispatch.bindGroup,
+    );
     if ('workgroups' in dispatch) pass.dispatchWorkgroups(...dispatch.workgroups);
     else pass.dispatchWorkgroupsIndirect(dispatch.indirectBuffer, dispatch.indirectOffset);
   }
@@ -163,7 +214,8 @@ export interface PreparedGraphicsResourceLease {
 
 interface ProgramItem {
   readonly name: string;
-  readonly signature: string;
+  /** Detached descriptor used for exact warm-frame equality checks. */
+  readonly descriptor: RenderFeatureGpuProgramDescriptor;
   readonly reference: RenderFeatureGpuProgramRef;
   readonly module: ShaderModule;
   readonly pipelines: ReadonlyMap<string, ComputePipeline>;
@@ -178,6 +230,28 @@ interface BufferItem {
   readonly buffer: Buffer;
   readonly size: number;
   readonly physicalUsage: number;
+  readonly owned: boolean;
+}
+
+interface TextureViewItem {
+  readonly logicalTarget?: RenderFeatureTargetHandle;
+  readonly name: string;
+  readonly resource: TextureView;
+  readonly reference: RenderFeatureGpuTextureViewRef;
+}
+
+interface SamplerItem {
+  readonly name: string;
+  readonly resource: Sampler;
+  readonly reference: RenderFeatureGpuSamplerRef;
+}
+
+interface BindingResourceItem {
+  readonly binding: number;
+  readonly resource: RhiBindingResource;
+  readonly buffer?: BufferItem;
+  readonly textureView?: TextureViewItem;
+  readonly sampler?: SamplerItem;
 }
 
 interface BindingsItem {
@@ -185,10 +259,22 @@ interface BindingsItem {
   readonly signature: string;
   readonly reference: RenderFeatureGpuBindingsRef;
   readonly program: ProgramItem;
+  readonly entries: readonly BindingResourceItem[];
   readonly buffers: readonly { readonly binding: number; readonly item: BufferItem }[];
   readonly bindGroup: BindGroup;
 }
 
+/**
+ * VFX fixed-tick queues can briefly shrink when the host consumes one tick
+ * earlier than the next one is published. Keep those named allocations warm
+ * for a bounded window so a q-slot oscillation does not create/destroy a GPU
+ * buffer on every frame. The parking policy is deliberately scoped to the
+ * native VFX feature; generic feature resources retain the old immediate
+ * retirement contract until they publish the same lifetime proof.
+ */
+const VFX_PARKED_RESOURCE_FRAME_LIMIT = 8;
+const VFX_PARKED_RESOURCE_LIMIT = 256;
+
 const BUFFER_USAGE = {
   storage: 0x0080,
   uniform: 0x0040,
@@ -241,13 +327,85 @@ function stable(value: unknown): string {
   if (Array.isArray(value)) return `[${value.map(stable).join(',')}]`;
   if (value !== null && typeof value === 'object') {
     return `{${Object.entries(value as Record<string, unknown>)
-      .sort(([left], [right]) => left.localeCompare(right))
+      // Descriptor keys are canonicalized by code unit, not locale.  These
+      // descriptors are generated every frame; avoiding locale collation
+      // keeps the stable spelling deterministic and removes a per-call
+      // ICU-backed comparator from the prepared-resource hot path.
+      .sort(([left], [right]) => (left < right ? -1 : left > right ? 1 : 0))
       .map(([key, child]) => `${key}:${stable(child)}`)
       .join(',')}}`;
   }
   return JSON.stringify(value);
 }
 
+/**
+ * Compare prepared-program declarations without reserializing the WGSL and
+ * bind-group layout on every warm frame.  This is intentionally a structural
+ * comparison: callers may reuse and mutate their declaration objects, so an
+ * object-identity fast path would make a stale pipeline appear valid.
+ */
+function equalDescriptorValue(left: unknown, right: unknown): boolean {
+  if (Object.is(left, right)) return true;
+  if (typeof left !== typeof right || left === null || right === null) return false;
+  if (ArrayBuffer.isView(left) || ArrayBuffer.isView(right)) {
+    if (!ArrayBuffer.isView(left) || !ArrayBuffer.isView(right)) return false;
+    if (left.byteLength !== right.byteLength) return false;
+    const leftBytes = new Uint8Array(left.buffer, left.byteOffset, left.byteLength);
+    const rightBytes = new Uint8Array(right.buffer, right.byteOffset, right.byteLength);
+    for (let index = 0; index < leftBytes.length; index += 1) {
+      if (leftBytes[index] !== rightBytes[index]) return false;
+    }
+    return true;
+  }
+  if (Array.isArray(left) || Array.isArray(right)) {
+    if (!Array.isArray(left) || !Array.isArray(right) || left.length !== right.length) return false;
+    for (let index = 0; index < left.length; index += 1) {
+      if (!equalDescriptorValue(left[index], right[index])) return false;
+    }
+    return true;
+  }
+  if (typeof left === 'object' && typeof right === 'object') {
+    const leftRecord = left as Record<string, unknown>;
+    const rightRecord = right as Record<string, unknown>;
+    const leftKeys = Object.keys(leftRecord);
+    const rightKeys = Object.keys(rightRecord);
+    if (leftKeys.length !== rightKeys.length) return false;
+    for (const key of leftKeys) {
+      if (!Object.hasOwn(rightRecord, key)) return false;
+      if (!equalDescriptorValue(leftRecord[key], rightRecord[key])) return false;
+    }
+    return true;
+  }
+  return false;
+}
+
+function cloneDescriptorValue(value: unknown): unknown {
+  if (Array.isArray(value)) {
+    return Object.freeze(value.map((child) => cloneDescriptorValue(child)));
+  }
+  if (value !== null && typeof value === 'object' && !ArrayBuffer.isView(value)) {
+    return Object.freeze(
+      Object.fromEntries(
+        Object.entries(value as Record<string, unknown>).map(([key, child]) => [
+          key,
+          cloneDescriptorValue(child),
+        ]),
+      ),
+    );
+  }
+  if (ArrayBuffer.isView(value)) {
+    const source = new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+    return new Uint8Array(source);
+  }
+  return value;
+}
+
+function cloneProgramDescriptor(
+  descriptor: RenderFeatureGpuProgramDescriptor,
+): RenderFeatureGpuProgramDescriptor {
+  return cloneDescriptorValue(descriptor) as RenderFeatureGpuProgramDescriptor;
+}
+
 function rhiReason(error: {
   readonly code: string;
   readonly hint: string;
@@ -264,14 +422,54 @@ function createRenderFeatureGpuWorkSession(input: {
   readonly featureIdentity: string;
 }): RenderFeatureGpuPrepareSession {
   const programs = new Map<string, ProgramItem>();
+  const parkedPrograms = new Map<string, { readonly item: ProgramItem; readonly frame: number }>();
   const programRefs = new Map<object, ProgramItem>();
   const buffers = new Map<string, BufferItem>();
+  const parkedBuffers = new Map<string, { readonly item: BufferItem; readonly frame: number }>();
   const bufferRefs = new Map<object, BufferItem>();
+  const textureViews = new Map<string, TextureViewItem>();
+  const textureViewRefs = new Map<object, TextureViewItem>();
+  const samplers = new Map<string, SamplerItem>();
+  const samplerRefs = new Map<object, SamplerItem>();
   const bindings = new Map<string, BindingsItem>();
+  const parkedBindings = new Map<string, { readonly item: BindingsItem; readonly frame: number }>();
   const bindingRefs = new Map<object, BindingsItem>();
   const touchedPrograms = new Set<ProgramItem>();
   const touchedBuffers = new Set<BufferItem>();
+  const touchedTextureViews = new Set<TextureViewItem>();
+  const touchedSamplers = new Set<SamplerItem>();
   const touchedBindings = new Set<BindingsItem>();
+  const parksUntouched = input.featureIdentity === 'forgeax.vfx-render.gpu-particles';
+  let frameSerial = 0;
+
+  // A parked bind group must not retain a borrowed view, sampler, or buffer
+  // whose producer may replace the underlying handle while this feature is
+  // dormant. Owned buffers are generation-local and can safely be revived.
+  const canParkBinding = (item: BindingsItem): boolean =>
+    item.entries.every(
+      (entry) =>
+        entry.textureView === undefined &&
+        entry.sampler === undefined &&
+        (entry.buffer === undefined || entry.buffer.owned),
+    );
+
+  const activateProgram = (item: ProgramItem): void => {
+    const parked = parkedPrograms.get(item.name);
+    if (parked?.item === item) parkedPrograms.delete(item.name);
+    programs.set(item.name, item);
+  };
+  const activateBuffer = (item: BufferItem): void => {
+    const parked = parkedBuffers.get(item.name);
+    if (parked?.item === item) parkedBuffers.delete(item.name);
+    buffers.set(item.name, item);
+  };
+  const activateBindings = (item: BindingsItem): void => {
+    const parked = parkedBindings.get(item.name);
+    if (parked?.item === item) parkedBindings.delete(item.name);
+    bindings.set(item.name, item);
+    activateProgram(item.program);
+    for (const entry of item.buffers) activateBuffer(entry.item);
+  };
 
   const touchProgram = (item: ProgramItem): void => {
     touchedPrograms.add(item);
@@ -279,18 +477,28 @@ function createRenderFeatureGpuWorkSession(input: {
   const touchBuffer = (item: BufferItem): void => {
     touchedBuffers.add(item);
   };
+  const touchTextureView = (item: TextureViewItem): void => {
+    touchedTextureViews.add(item);
+  };
+  const touchSampler = (item: SamplerItem): void => {
+    touchedSamplers.add(item);
+  };
   const touchBindings = (item: BindingsItem): void => {
     touchedBindings.add(item);
     touchProgram(item.program);
-    for (const entry of item.buffers) touchBuffer(entry.item);
+    for (const entry of item.entries) {
+      if (entry.buffer !== undefined) touchBuffer(entry.buffer);
+      if (entry.textureView !== undefined) touchTextureView(entry.textureView);
+      if (entry.sampler !== undefined) touchSampler(entry.sampler);
+    }
   };
 
   const prepareProgram: RenderFeatureGpuPrepare['prepareProgram'] = (name, descriptor) => {
-    const signature = stable(descriptor);
-    const prior = programs.get(name);
+    const prior = programs.get(name) ?? parkedPrograms.get(name)?.item;
     if (prior !== undefined) {
+      activateProgram(prior);
       touchProgram(prior);
-      return prior.signature === signature
+      return equalDescriptorValue(prior.descriptor, descriptor)
         ? ok(prior.reference)
         : err(
             failure(
@@ -417,7 +625,7 @@ function createRenderFeatureGpuWorkSession(input: {
     const reference = Object.freeze({ generation: input.generation }) as RenderFeatureGpuProgramRef;
     const item = {
       name,
-      signature,
+      descriptor: cloneProgramDescriptor(descriptor),
       reference,
       module: module.value,
       pipelines: pipelineMap,
@@ -453,7 +661,7 @@ function createRenderFeatureGpuWorkSession(input: {
       );
     }
     const signature = stable({ size: descriptor.size, usage: [...descriptor.usage].sort() });
-    let item = buffers.get(name);
+    let item = buffers.get(name) ?? parkedBuffers.get(name)?.item;
     if (item !== undefined && item.signature !== signature) {
       return err(
         failure(
@@ -494,10 +702,12 @@ function createRenderFeatureGpuWorkSession(input: {
         buffer: created.value,
         size: alignedSize(descriptor.size),
         physicalUsage: usage,
+        owned: true,
       };
       buffers.set(name, item);
       bufferRefs.set(reference, item);
     }
+    activateBuffer(item);
     touchBuffer(item);
     if (descriptor.data !== undefined) {
       if (descriptor.data.byteLength > descriptor.size) {
@@ -527,43 +737,267 @@ function createRenderFeatureGpuWorkSession(input: {
     return ok(item.reference);
   };
 
-  const prepareBindings: RenderFeatureGpuPrepare['prepareBindings'] = (name, descriptor) => {
-    const program = programRefs.get(descriptor.program as object);
-    if (program === undefined || descriptor.program.generation !== input.generation) {
+  const prepareBufferResource: RenderFeatureGpuPrepare['prepareBufferResource'] = (
+    name,
+    resource,
+    descriptor,
+  ) => {
+    if (
+      name.length === 0 ||
+      !Number.isInteger(descriptor.size) ||
+      descriptor.size <= 0 ||
+      descriptor.usage.length === 0
+    ) {
       return err(
         failure(
           input.featureIdentity,
-          'prepare-gpu-bindings',
-          'bindings',
+          'prepare-gpu-buffer-resource',
+          'uniform-data',
           name,
-          'program-unavailable',
+          'descriptor-invalid',
         ),
       );
     }
-    const entryItems = descriptor.entries.map((entry) => ({
-      binding: entry.binding,
-      item: bufferRefs.get(entry.buffer as object),
-    }));
-    if (entryItems.some((entry) => entry.item === undefined)) {
+    const size = alignedSize(descriptor.size);
+    const usage = descriptor.usage.reduce((bits, key) => bits | BUFFER_USAGE[key], COPY_DST);
+    const prior = buffers.get(name);
+    if (prior !== undefined) {
+      touchBuffer(prior);
+      return prior.buffer === resource &&
+        prior.size === size &&
+        prior.physicalUsage === usage &&
+        !prior.owned
+        ? ok(prior.reference)
+        : err(
+            failure(
+              input.featureIdentity,
+              'prepare-gpu-buffer-resource',
+              'uniform-data',
+              name,
+              'signature-mismatch',
+            ),
+          );
+    }
+    const reference = Object.freeze({
+      name,
+      generation: input.generation,
+    }) as RenderFeatureGpuBufferRef;
+    const item: BufferItem = {
+      name,
+      signature: stable({ external: true, size, usage: [...descriptor.usage].sort() }),
+      reference,
+      buffer: resource,
+      size,
+      physicalUsage: usage,
+      owned: false,
+    };
+    buffers.set(name, item);
+    bufferRefs.set(reference, item);
+    touchBuffer(item);
+    return ok(reference);
+  };
+
+  const prepareTextureView: RenderFeatureGpuPrepare['prepareTextureView'] = (
+    name,
+    resource,
+    logicalTarget,
+  ) => {
+    if (name.length === 0) {
+      return err(
+        failure(
+          input.featureIdentity,
+          'prepare-gpu-texture-view',
+          'texture-view',
+          name,
+          'descriptor-invalid',
+        ),
+      );
+    }
+    const prior = textureViews.get(name);
+    if (prior !== undefined) {
+      touchTextureView(prior);
+      return prior.resource === resource && stable(prior.logicalTarget) === stable(logicalTarget)
+        ? ok(prior.reference)
+        : err(
+            failure(
+              input.featureIdentity,
+              'prepare-gpu-texture-view',
+              'texture-view',
+              name,
+              'signature-mismatch',
+            ),
+          );
+    }
+    const reference = Object.freeze({
+      name,
+      generation: input.generation,
+    }) as RenderFeatureGpuTextureViewRef;
+    const item = {
+      name,
+      resource,
+      reference,
+      ...(logicalTarget === undefined ? {} : { logicalTarget }),
+    };
+    textureViews.set(name, item);
+    textureViewRefs.set(reference, item);
+    touchTextureView(item);
+    return ok(reference);
+  };
+
+  const prepareSampler: RenderFeatureGpuPrepare['prepareSampler'] = (name, resource) => {
+    if (name.length === 0) {
+      return err(
+        failure(
+          input.featureIdentity,
+          'prepare-gpu-sampler',
+          'sampler',
+          name,
+          'descriptor-invalid',
+        ),
+      );
+    }
+    const prior = samplers.get(name);
+    if (prior !== undefined) {
+      touchSampler(prior);
+      return prior.resource === resource
+        ? ok(prior.reference)
+        : err(
+            failure(
+              input.featureIdentity,
+              'prepare-gpu-sampler',
+              'sampler',
+              name,
+              'signature-mismatch',
+            ),
+          );
+    }
+    const reference = Object.freeze({
+      name,
+      generation: input.generation,
+    }) as RenderFeatureGpuSamplerRef;
+    const item = { name, resource, reference };
+    samplers.set(name, item);
+    samplerRefs.set(reference, item);
+    touchSampler(item);
+    return ok(reference);
+  };
+
+  const prepareBindings: RenderFeatureGpuPrepare['prepareBindings'] = (name, descriptor) => {
+    const program = programRefs.get(descriptor.program as object);
+    if (program === undefined || descriptor.program.generation !== input.generation) {
       return err(
         failure(
           input.featureIdentity,
           'prepare-gpu-bindings',
           'bindings',
           name,
-          'buffer-unavailable',
+          'program-unavailable',
         ),
       );
     }
-    const availableEntries = entryItems.flatMap((entry) =>
-      entry.item === undefined ? [] : [{ binding: entry.binding, item: entry.item }],
-    );
+    const entryItems: BindingResourceItem[] = [];
+    for (const entry of descriptor.entries) {
+      if ('buffer' in entry) {
+        const item = bufferRefs.get(entry.buffer as object);
+        if (item === undefined || entry.buffer.generation !== input.generation) {
+          return err(
+            failure(
+              input.featureIdentity,
+              'prepare-gpu-bindings',
+              'bindings',
+              name,
+              'buffer-unavailable',
+            ),
+          );
+        }
+        entryItems.push({
+          binding: entry.binding,
+          resource: { kind: 'buffer', value: { buffer: item.buffer } },
+          buffer: item,
+        });
+        continue;
+      }
+      const prepared = entry.resource;
+      if (prepared.reference.generation !== input.generation) {
+        return err(
+          failure(
+            input.featureIdentity,
+            'prepare-gpu-bindings',
+            'bindings',
+            name,
+            'resource-generation-mismatch',
+          ),
+        );
+      }
+      if (prepared.kind === 'buffer') {
+        const item = bufferRefs.get(prepared.reference as object);
+        if (item === undefined) {
+          return err(
+            failure(
+              input.featureIdentity,
+              'prepare-gpu-bindings',
+              'bindings',
+              name,
+              'buffer-unavailable',
+            ),
+          );
+        }
+        entryItems.push({
+          binding: entry.binding,
+          resource: { kind: 'buffer', value: { buffer: item.buffer } },
+          buffer: item,
+        });
+        continue;
+      }
+      if (prepared.kind === 'texture-view') {
+        const item = textureViewRefs.get(prepared.reference as object);
+        if (item === undefined) {
+          return err(
+            failure(
+              input.featureIdentity,
+              'prepare-gpu-bindings',
+              'bindings',
+              name,
+              'texture-view-unavailable',
+            ),
+          );
+        }
+        entryItems.push({
+          binding: entry.binding,
+          resource: { kind: 'textureView', value: item.resource },
+          textureView: item,
+        });
+        continue;
+      }
+      const item = samplerRefs.get(prepared.reference as object);
+      if (item === undefined) {
+        return err(
+          failure(
+            input.featureIdentity,
+            'prepare-gpu-bindings',
+            'bindings',
+            name,
+            'sampler-unavailable',
+          ),
+        );
+      }
+      entryItems.push({
+        binding: entry.binding,
+        resource: { kind: 'sampler', value: item.resource },
+        sampler: item,
+      });
+    }
     const signature = stable({
       program: program.name,
-      entries: availableEntries.map((entry) => [entry.binding, entry.item.name]),
+      entries: entryItems.map((entry) => [
+        entry.binding,
+        entry.buffer?.name ?? entry.textureView?.name ?? entry.sampler?.name,
+        entry.resource.kind,
+      ]),
     });
-    const prior = bindings.get(name);
+    const prior = bindings.get(name) ?? parkedBindings.get(name)?.item;
     if (prior !== undefined) {
+      activateBindings(prior);
       touchBindings(prior);
       return prior.signature === signature
         ? ok(prior.reference)
@@ -595,12 +1029,9 @@ function createRenderFeatureGpuWorkSession(input: {
     const created = input.device.createBindGroup({
       label: name,
       layout,
-      entries: availableEntries.map((entry) => ({
+      entries: entryItems.map((entry) => ({
         binding: entry.binding,
-        resource: {
-          kind: 'buffer' as const,
-          value: { buffer: entry.item.buffer },
-        },
+        resource: entry.resource,
       })),
     });
     if (!created.ok) {
@@ -622,7 +1053,10 @@ function createRenderFeatureGpuWorkSession(input: {
       signature,
       reference,
       program,
-      buffers: availableEntries,
+      entries: entryItems,
+      buffers: entryItems.flatMap((entry) =>
+        entry.buffer === undefined ? [] : [{ binding: entry.binding, item: entry.buffer }],
+      ),
       bindGroup: created.value,
     };
     bindings.set(name, item);
@@ -633,8 +1067,11 @@ function createRenderFeatureGpuWorkSession(input: {
 
   return {
     beginFrame: () => {
+      frameSerial += 1;
       touchedPrograms.clear();
       touchedBuffers.clear();
+      touchedTextureViews.clear();
+      touchedSamplers.clear();
       touchedBindings.clear();
     },
     retainBindings: (references) => {
@@ -651,12 +1088,16 @@ function createRenderFeatureGpuWorkSession(input: {
             ),
           );
         }
+        activateBindings(item);
         touchBindings(item);
       }
       return ok(undefined);
     },
     prepareProgram,
     prepareBuffer,
+    prepareBufferResource,
+    prepareTextureView,
+    prepareSampler,
     prepareBindings,
     resolveComputePass: (featureIdentity, descriptor) => {
       const program = programRefs.get(descriptor.program as object);
@@ -743,10 +1184,39 @@ function createRenderFeatureGpuWorkSession(input: {
         const pipeline = program.pipelines.get(dispatch.entryPoint);
         const dispatchBinding = dispatchBindings[index];
         if (pipeline === undefined || dispatchBinding === undefined) continue;
+        const lateBindings = dispatchBinding.entries.some(
+          (entry) => entry.textureView?.logicalTarget !== undefined,
+        )
+          ? {
+              resolveBindGroup: (resolve: (target: RenderFeatureTargetHandle) => TextureView) => {
+                const layout =
+                  program.bindGroupLayout ??
+                  (pipeline as ComputePipeline & RhiComputePipelineOps).getBindGroupLayout(0);
+                const created = input.device.createBindGroup({
+                  label: dispatchBinding.name,
+                  layout,
+                  entries: dispatchBinding.entries.map((entry) => ({
+                    binding: entry.binding,
+                    resource:
+                      entry.textureView?.logicalTarget === undefined
+                        ? entry.resource
+                        : {
+                            kind: 'textureView' as const,
+                            value: resolve(entry.textureView.logicalTarget),
+                          },
+                  })),
+                });
+                if (!created.ok) throw created.error;
+                return created.value;
+              },
+            }
+          : {};
+
         if (dispatch.workgroups !== undefined) {
           resolvedDispatches.push({
             pipeline,
             bindGroup: dispatchBinding.bindGroup,
+            ...lateBindings,
             workgroups: [
               dispatch.workgroups[0],
               dispatch.workgroups[1] ?? 1,
@@ -760,6 +1230,7 @@ function createRenderFeatureGpuWorkSession(input: {
         resolvedDispatches.push({
           pipeline,
           bindGroup: dispatchBinding.bindGroup,
+          ...lateBindings,
           indirectBuffer: indirectItem.buffer,
           indirectOffset: dispatch.indirect.offset,
         });
@@ -819,6 +1290,18 @@ function createRenderFeatureGpuWorkSession(input: {
         resolvedBuffers.set(item, accesses);
       }
       return ok({
+        sampledTargets: [
+          ...new Set(
+            dispatchBindings.flatMap(
+              (item) =>
+                item?.entries.flatMap((entry) =>
+                  entry.textureView?.logicalTarget === undefined
+                    ? []
+                    : [entry.textureView.logicalTarget],
+                ) ?? [],
+            ),
+          ),
+        ],
         buffers: [...resolvedBuffers].flatMap(([item, accesses]) =>
           [...accesses].map((access) => ({
             name: item.name,
@@ -833,28 +1316,111 @@ function createRenderFeatureGpuWorkSession(input: {
     },
     resolveBuffer: (reference) => {
       const item = bufferRefs.get(reference as object);
-      if (item !== undefined) touchBuffer(item);
+      if (item !== undefined) {
+        activateBuffer(item);
+        touchBuffer(item);
+      }
       return item === undefined
         ? undefined
         : { buffer: item.buffer, size: item.size, physicalUsage: item.physicalUsage };
     },
     retireUntouched: () => {
+      const retired: BufferItem[] = [];
+      const park = <T extends { readonly name: string }>(
+        active: Map<string, T>,
+        parked: Map<string, { readonly item: T; readonly frame: number }>,
+        touched: Set<T>,
+        retire: (item: T) => void,
+      ): void => {
+        for (const [name, item] of active) {
+          if (touched.has(item)) continue;
+          active.delete(name);
+          if (parksUntouched) parked.set(name, { item, frame: frameSerial });
+          else retire(item);
+        }
+      };
       for (const [name, item] of bindings) {
         if (touchedBindings.has(item)) continue;
         bindings.delete(name);
-        bindingRefs.delete(item.reference as object);
+        if (parksUntouched && canParkBinding(item)) {
+          parkedBindings.set(name, { item, frame: frameSerial });
+        } else {
+          bindingRefs.delete(item.reference as object);
+        }
       }
-      for (const [name, item] of programs) {
-        if (touchedPrograms.has(item)) continue;
-        programs.delete(name);
+      park(programs, parkedPrograms, touchedPrograms, (item) => {
         programRefs.delete(item.reference as object);
-      }
-      const retired: BufferItem[] = [];
-      for (const [name, item] of buffers) {
-        if (touchedBuffers.has(item)) continue;
-        buffers.delete(name);
-        bufferRefs.delete(item.reference as object);
-        retired.push(item);
+      });
+      if (parksUntouched) {
+        for (const [name, item] of buffers) {
+          if (touchedBuffers.has(item)) continue;
+          buffers.delete(name);
+          if (item.owned) parkedBuffers.set(name, { item, frame: frameSerial });
+          else bufferRefs.delete(item.reference as object);
+        }
+        for (const [name, item] of textureViews) {
+          if (touchedTextureViews.has(item)) continue;
+          textureViews.delete(name);
+          textureViewRefs.delete(item.reference as object);
+        }
+        for (const [name, item] of samplers) {
+          if (touchedSamplers.has(item)) continue;
+          samplers.delete(name);
+          samplerRefs.delete(item.reference as object);
+        }
+        const evictBefore = frameSerial - VFX_PARKED_RESOURCE_FRAME_LIMIT;
+        const evictBuffers = (): void => {
+          for (const [name, parked] of parkedBuffers) {
+            if (parked.frame > evictBefore && parkedBuffers.size <= VFX_PARKED_RESOURCE_LIMIT)
+              break;
+            parkedBuffers.delete(name);
+            bufferRefs.delete(parked.item.reference as object);
+            for (const [bindingName, binding] of parkedBindings) {
+              if (binding.item.buffers.some((entry) => entry.item === parked.item)) {
+                parkedBindings.delete(bindingName);
+                bindingRefs.delete(binding.item.reference as object);
+              }
+            }
+            retired.push(parked.item);
+          }
+        };
+        evictBuffers();
+        for (const [name, parked] of parkedPrograms) {
+          if (parked.frame > evictBefore && parkedPrograms.size <= VFX_PARKED_RESOURCE_LIMIT) {
+            break;
+          }
+          parkedPrograms.delete(name);
+          programRefs.delete(parked.item.reference as object);
+          for (const [bindingName, binding] of parkedBindings) {
+            if (binding.item.program !== parked.item) continue;
+            parkedBindings.delete(bindingName);
+            bindingRefs.delete(binding.item.reference as object);
+          }
+        }
+        for (const [name, parked] of parkedBindings) {
+          if (parked.frame > evictBefore && parkedBindings.size <= VFX_PARKED_RESOURCE_LIMIT) {
+            break;
+          }
+          parkedBindings.delete(name);
+          bindingRefs.delete(parked.item.reference as object);
+        }
+      } else {
+        for (const [name, item] of buffers) {
+          if (touchedBuffers.has(item)) continue;
+          buffers.delete(name);
+          bufferRefs.delete(item.reference as object);
+          retired.push(item);
+        }
+        for (const [name, item] of textureViews) {
+          if (touchedTextureViews.has(item)) continue;
+          textureViews.delete(name);
+          textureViewRefs.delete(item.reference as object);
+        }
+        for (const [name, item] of samplers) {
+          if (touchedSamplers.has(item)) continue;
+          samplers.delete(name);
+          samplerRefs.delete(item.reference as object);
+        }
       }
       if (retired.length === 0) return [];
       let released = false;
@@ -865,6 +1431,7 @@ function createRenderFeatureGpuWorkSession(input: {
             released = true;
             let first: RenderError | undefined;
             for (const item of retired) {
+              if (!item.owned) continue;
               const destroyed = input.device.destroyBuffer(item.buffer);
               if (!destroyed.ok && first === undefined) {
                 first = failure(
@@ -883,7 +1450,12 @@ function createRenderFeatureGpuWorkSession(input: {
     },
     dispose: () => {
       let first: RenderError | undefined;
-      for (const item of buffers.values()) {
+      const allBuffers = new Set<BufferItem>([
+        ...buffers.values(),
+        ...Array.from(parkedBuffers.values(), ({ item }) => item),
+      ]);
+      for (const item of allBuffers) {
+        if (!item.owned) continue;
         const destroyed = input.device.destroyBuffer(item.buffer);
         if (!destroyed.ok && first === undefined) {
           first = failure(
@@ -896,8 +1468,18 @@ function createRenderFeatureGpuWorkSession(input: {
         }
       }
       programs.clear();
+      parkedPrograms.clear();
       buffers.clear();
+      parkedBuffers.clear();
       bindings.clear();
+      parkedBindings.clear();
+      textureViews.clear();
+      textureViewRefs.clear();
+      samplers.clear();
+      samplerRefs.clear();
+      bufferRefs.clear();
+      programRefs.clear();
+      bindingRefs.clear();
       return first === undefined ? ok(undefined) : err(first);
     },
   };