@forgeax/engine-render 0.1.28 → 0.1.30

package/src/features/host.ts

@@ -1,5 +1,5 @@
 import type { EntityHandle } from '@forgeax/engine-ecs';
-import type { RhiCaps, TextureFormat } from '@forgeax/engine-rhi';
+import type { Buffer, RhiCaps, Sampler, TextureFormat, TextureView } from '@forgeax/engine-rhi';
 import { err, ok, type Result } from '@forgeax/engine-types';
 import type { DeviceScope, LifecycleResourceSpec } from '../device/device-scope';
 import {
@@ -10,6 +10,7 @@ import {
   RenderFeatureStageFailedError,
 } from '../errors/render';
 import type { PostProcessShaderEntry } from '../fullscreen-post-process-pass';
+import type { RenderFeatureHostInspection } from '../inspection-types';
 import type {
   PreparedGraphicsReference,
   PreparedGraphicsResolvedSnapshot,
@@ -19,19 +20,26 @@ import type {
 import type { SceneDataTarget } from '../temporal/scene-data';
 import { createSceneDataCatalog, type SceneDataCatalog } from '../temporal/scene-data-catalog';
 import {
+  cloneRenderFeaturePlanSignatureSnapshot,
   freezeRenderFeaturePlan,
   type RenderFeatureLogicalTarget,
   type RenderFeatureMaterialShaderBindingContract,
   type RenderFeaturePassDeclaration,
   type RenderFeaturePlan,
+  type RenderFeaturePlanContext,
   type RenderFeaturePlannedFrame,
+  type RenderFeaturePlanSignatureMetrics,
+  type RenderFeaturePlanSignatureSnapshot,
   type RenderFeatureResourceDeclaration,
+  rememberRenderFeaturePlanSignature,
   renderFeaturePlanSignature,
+  renderFeaturePlanSignatureSnapshotEquals,
 } from './plan';
 import type {
   RenderFeatureGpuBindingsRef,
   RenderFeatureGpuBufferRef,
   RenderFeatureGpuComputePassDescriptor,
+  RenderFeatureGpuPreparedResourceRef,
   RenderFeatureGpuPrepareSession,
   RenderFeatureGpuProgramRef,
   RenderFeatureGpuWorkOwner,
@@ -48,6 +56,7 @@ import {
   type PreparedGraphicsStore,
   type PreparedGraphicsTransaction,
 } from './prepared-graphics-store';
+import { isRenderFeatureTargetHandle } from './targets';
 import type {
   RenderFeature,
   RenderFeatureCapabilityKey,
@@ -68,7 +77,29 @@ const planExecutionProjections = new WeakMap<
   RenderFeaturePlanExecution
 >();
 
+const submissionAcknowledgments = new WeakMap<RenderFeaturePlannedFrame, () => void>();
+const submissionSensitivePlans = new WeakSet<RenderFeaturePlannedFrame>();
+
+/** A cached command graph must not replay a producer's already-consumed intents. */
+export function hasSubmissionSensitiveFeatures(
+  plans: readonly RenderFeaturePlannedFrame[],
+): boolean {
+  return plans.some((plan) => submissionSensitivePlans.has(plan));
+}
+
+/** Acknowledge only plans in the submitted graph, once, including a retained graph. */
+export function acknowledgeRenderFeatureSubmission(
+  plans: readonly RenderFeaturePlannedFrame[],
+): void {
+  for (const plan of plans) {
+    const acknowledge = submissionAcknowledgments.get(plan);
+    submissionAcknowledgments.delete(plan);
+    acknowledge?.();
+  }
+}
+
 export interface RenderFeaturePlanExecutionPass {
+  readonly shadowCaster?: true;
   readonly featureIdentity: string;
   readonly order: number;
   readonly name: string;
@@ -115,6 +146,8 @@ export interface RenderFeatureFrameInput {
   readonly materialShaderBindingContract?: (
     materialShaderId: string,
   ) => RenderFeatureMaterialShaderBindingContract;
+  /** Renderer-owned prepared camera/depth/noise resources for feature plans. */
+  readonly preparedDataInterfaces?: RenderFeaturePlanContext['preparedDataInterfaces'];
   readonly createPreparedGraphicsResolver?: (
     input: RenderFeaturePreparedGraphicsResolverInput,
   ) => PreparedGraphicsResolver;
@@ -141,7 +174,17 @@ export interface RenderFeatureFrameResult {
   readonly plans: readonly RenderFeaturePlannedFrame[];
   readonly fullscreenEffects: ReadonlyMap<string, PostProcessShaderEntry>;
   readonly preparedResourceBatches: readonly RenderFeaturePreparedResourceBatch[];
+  /**
+   * True only when the current graph resolves a transient graphics lease.
+   * Retired GPU-work leases are kept alive until queue completion but are not
+   * referenced by this candidate and therefore do not require a new graph.
+   */
+  readonly requiresPreparedResourceKey: boolean;
   readonly hiddenEntityReports: readonly RenderFeatureHiddenEntityReport[];
+  /** Invoke producer consumption after the frame reaches queue submission. */
+  readonly onSubmitted: () => void;
+  /** Discard producer frame state after graph admission/submission failure. */
+  readonly onAborted: () => void;
 }
 
 export interface RenderFeatureHost {
@@ -180,6 +223,10 @@ export interface RenderFeatureHost {
   diagnostics(): readonly RenderFeatureDiagnostics[];
   /** Subscribe to lifecycle projection changes; unchanged active frames are silent. */
   subscribeDiagnostics(listener: () => void): () => void;
+  /** Detached signature and prepared-resource accounting for diagnostics. */
+  readonly inspection?: () => RenderFeatureHostInspection;
+  /** Host-owned signature entry point so accounting remains per feature. */
+  readonly recordPlanSignature?: (identity: string, plan: RenderFeaturePlan) => string;
   dispose(): Result<void, RenderError>;
 }
 
@@ -454,6 +501,7 @@ interface PreparedPlanResources {
   readonly computePrograms: ReadonlyMap<string, RenderFeatureGpuProgramRef>;
   readonly graphicsPrograms: ReadonlyMap<string, RenderFeaturePreparedRef<'pipeline'>>;
   readonly buffers: ReadonlyMap<string, RenderFeatureGpuBufferRef>;
+  readonly preparedGpuResources: ReadonlyMap<string, RenderFeatureGpuPreparedResourceRef>;
   readonly computeBindings: ReadonlyMap<string, RenderFeatureGpuBindingsRef>;
   readonly graphicsBindings: ReadonlyMap<string, RenderFeaturePreparedRef<'bindings'>>;
   readonly vertexData: ReadonlyMap<string, RenderFeaturePreparedRef<'vertex-data'>>;
@@ -498,6 +546,7 @@ function preparePlanResources(
   const computePrograms = new Map<string, RenderFeatureGpuProgramRef>();
   const graphicsPrograms = new Map<string, RenderFeaturePreparedRef<'pipeline'>>();
   const buffers = new Map<string, RenderFeatureGpuBufferRef>();
+  const preparedGpuResources = new Map<string, RenderFeatureGpuPreparedResourceRef>();
   const computeBindings = new Map<string, RenderFeatureGpuBindingsRef>();
   const graphicsBindings = new Map<string, RenderFeaturePreparedRef<'bindings'>>();
   const vertexData = new Map<string, RenderFeaturePreparedRef<'vertex-data'>>();
@@ -511,7 +560,9 @@ function preparePlanResources(
   if (
     gpu === undefined &&
     plan.resources.some((resource) =>
-      ['compute-program', 'buffer', 'compute-bindings'].includes(resource.kind),
+      ['compute-program', 'buffer', 'prepared-gpu-resource', 'compute-bindings'].includes(
+        resource.kind,
+      ),
     )
   ) {
     return err(planFailure(slot));
@@ -537,21 +588,60 @@ function preparePlanResources(
     if (!prepared.ok) return prepared;
     buffers.set(resource.name, prepared.value);
   }
+  for (const resource of byKind('prepared-gpu-resource')) {
+    if (gpu === undefined) return err(planFailure(slot));
+    if (resource.resource.kind === 'buffer') {
+      const prepared = gpu.prepareBufferResource(resource.name, resource.resource.value as Buffer, {
+        size: resource.resource.size,
+        usage: resource.resource.usage ?? ['uniform'],
+      });
+      if (!prepared.ok) return prepared;
+      preparedGpuResources.set(resource.name, { kind: 'buffer', reference: prepared.value });
+      continue;
+    }
+    if (resource.resource.kind === 'texture-view') {
+      const logical =
+        resource.logicalTarget === undefined
+          ? undefined
+          : targetHandle(resource.logicalTarget, targets);
+      if (
+        resource.logicalTarget !== undefined &&
+        (logical === undefined || !isRenderFeatureTargetHandle(logical))
+      ) {
+        return err(planFailure(slot));
+      }
+      const prepared = gpu.prepareTextureView(
+        resource.name,
+        resource.resource.value as TextureView,
+        logical === undefined || !isRenderFeatureTargetHandle(logical) ? undefined : logical,
+      );
+      if (!prepared.ok) return prepared;
+      preparedGpuResources.set(resource.name, {
+        kind: 'texture-view',
+        reference: prepared.value,
+      });
+      continue;
+    }
+    const prepared = gpu.prepareSampler(resource.name, resource.resource.value as Sampler);
+    if (!prepared.ok) return prepared;
+    preparedGpuResources.set(resource.name, { kind: 'sampler', reference: prepared.value });
+  }
   for (const resource of byKind('compute-bindings')) {
     const program = computePrograms.get(resource.program);
-    const entries = resource.entries.map((entry) => ({
-      binding: entry.binding,
-      buffer: buffers.get(entry.resource),
-    }));
-    if (program === undefined || entries.some((entry) => entry.buffer === undefined)) {
+    const entries = resource.entries.map((entry) => {
+      const buffer = buffers.get(entry.resource);
+      if (buffer !== undefined) return { binding: entry.binding, buffer } as const;
+      const prepared = preparedGpuResources.get(entry.resource);
+      return prepared === undefined
+        ? undefined
+        : ({ binding: entry.binding, resource: prepared } as const);
+    });
+    if (program === undefined || entries.some((entry) => entry === undefined)) {
       return err(planFailure(slot));
     }
     const prepared = gpu?.prepareBindings(resource.name, {
       program,
-      entries: entries.map((entry) => ({
-        binding: entry.binding,
-        buffer: entry.buffer as RenderFeatureGpuBufferRef,
-      })),
+      entries: entries as NonNullable<(typeof entries)[number]>[],
     });
     if (prepared === undefined) return err(planFailure(slot));
     if (!prepared.ok) return prepared;
@@ -600,6 +690,7 @@ function preparePlanResources(
     computePrograms,
     graphicsPrograms,
     buffers,
+    preparedGpuResources,
     computeBindings,
     graphicsBindings,
     vertexData,
@@ -802,14 +893,14 @@ function projectPlanPasses(
         ? declaration.program.colorFormats[0]
         : undefined;
     })();
-    const colors = pass.colorAttachments.map((attachment) => ({
+    const colors = (pass.kind === 'raster' ? pass.colorAttachments : []).map((attachment) => ({
       resource: targetHandle(attachment.target, targets),
       format: targetFormat(attachment.target, logical, fallbackFormat),
       loadOp: attachment.loadOp,
       storeOp: attachment.storeOp,
     }));
     const depth =
-      pass.depthStencilAttachment === undefined
+      pass.kind !== 'raster' || pass.depthStencilAttachment === undefined
         ? undefined
         : {
             resource: targetHandle(pass.depthStencilAttachment.target, targets),
@@ -817,7 +908,9 @@ function projectPlanPasses(
             depthLoadOp: pass.depthStencilAttachment.depthLoadOp,
             depthStoreOp: pass.depthStencilAttachment.depthStoreOp,
           };
-    const sampledTargets = (pass.sampledTargets ?? []).map((name) => targetHandle(name, targets));
+    const sampledTargets = (pass.kind === 'raster' ? (pass.sampledTargets ?? []) : []).map((name) =>
+      targetHandle(name, targets),
+    );
     if (
       colors.some(
         (attachment) => attachment.resource === undefined || attachment.format === undefined,
@@ -862,6 +955,7 @@ function projectPlanPasses(
       order: slot.order,
       name: pass.name,
       graphics: descriptor,
+      ...(pass.kind === 'shadow-caster' ? { shadowCaster: true as const } : {}),
       graphicsState: graphicsState.value,
       ...(resolved?.ok === true ? { resolvedGraphics: resolved.value } : {}),
     });
@@ -898,6 +992,22 @@ class FeatureHostImpl implements RenderFeatureHost {
   private generation = 0;
   private lastRecoveryFrame: number | undefined;
   private readonly diagnosticsListeners = new Set<() => void>();
+  private readonly signatureByFeature = new Map<
+    string,
+    RenderFeatureHostInspection['signatures'][number]
+  >();
+  private readonly signatureCacheByFeature = new Map<
+    string,
+    { readonly signature: string; readonly snapshot: RenderFeaturePlanSignatureSnapshot }
+  >();
+  /** Monotonic compact identity for a changed feature-plan snapshot. */
+  private signatureRevision = 0;
+  private readonly preparedInspection = {
+    retained: 0,
+    submitted: 0,
+    released: 0,
+    releaseFailures: 0,
+  };
   private readonly preparedBatchStates = new WeakMap<
     RenderFeaturePreparedResourceBatch,
     'unsubmitted' | 'submitted'
@@ -917,6 +1027,77 @@ class FeatureHostImpl implements RenderFeatureHost {
     return this.slots.map((slot) => slot.feature);
   }
 
+  recordPlanSignature(identity: string, plan: RenderFeaturePlan): string {
+    const now = (): number => (typeof performance === 'undefined' ? Date.now() : performance.now());
+    const started = now();
+    const previous = this.signatureCacheByFeature.get(identity);
+    if (
+      previous !== undefined &&
+      renderFeaturePlanSignatureSnapshotEquals(plan, previous.snapshot)
+    ) {
+      const elapsed = now() - started;
+      const priorInspection = this.signatureByFeature.get(identity);
+      this.signatureByFeature.set(identity, {
+        featureIdentity: identity,
+        calls: priorInspection?.calls ?? 0,
+        typedArrayBytes: priorInspection?.typedArrayBytes ?? 0,
+        outputChars: priorInspection?.outputChars ?? 0,
+        cpuMs: (priorInspection?.cpuMs ?? 0) + elapsed,
+        cacheHits: (priorInspection?.cacheHits ?? 0) + 1,
+        cacheMisses: priorInspection?.cacheMisses ?? 0,
+      });
+      // The graph validator receives a fresh plan object every frame. Reuse
+      // is safe only because it will perform the same exact structural check
+      // against this detached snapshot.
+      rememberRenderFeaturePlanSignature(plan, previous.signature, previous.snapshot);
+      return previous.signature;
+    }
+    // A changed plan usually mutates a small VFX membership/pass leaf.  Keep
+    // the previous detached evidence as a sharing source so unchanged
+    // resource/program subtrees remain immutable and allocation-free; the
+    // candidate snapshot is still a fresh root and is revalidated by graph
+    // admission exactly as before.
+    const snapshot = cloneRenderFeaturePlanSignatureSnapshot(plan, previous?.snapshot);
+    // Keep one canonical spelling for the initial diagnostic/API observation.
+    // Subsequent changes only need a compact monotonic identity: the detached
+    // snapshot remains the exact structural proof and avoids rebuilding
+    // megabytes of text for every VFX plan revision.
+    const metrics: RenderFeaturePlanSignatureMetrics = {
+      calls: 0,
+      typedArrayBytes: 0,
+      outputChars: 0,
+    };
+    const signature =
+      previous === undefined
+        ? renderFeaturePlanSignature(plan, metrics)
+        : `revision-${++this.signatureRevision}`;
+    this.signatureCacheByFeature.set(identity, { signature, snapshot });
+    rememberRenderFeaturePlanSignature(plan, signature, snapshot);
+    const elapsed = now() - started;
+    const priorInspection = this.signatureByFeature.get(identity);
+    this.signatureByFeature.set(identity, {
+      featureIdentity: identity,
+      calls: (priorInspection?.calls ?? 0) + metrics.calls,
+      typedArrayBytes: (priorInspection?.typedArrayBytes ?? 0) + metrics.typedArrayBytes,
+      outputChars: (priorInspection?.outputChars ?? 0) + metrics.outputChars,
+      cpuMs: (priorInspection?.cpuMs ?? 0) + elapsed,
+      cacheHits: priorInspection?.cacheHits ?? 0,
+      cacheMisses: (priorInspection?.cacheMisses ?? 0) + 1,
+    });
+    return signature;
+  }
+
+  inspection(): RenderFeatureHostInspection {
+    return Object.freeze({
+      signatures: Object.freeze(
+        [...this.signatureByFeature.values()]
+          .sort((left, right) => left.featureIdentity.localeCompare(right.featureIdentity))
+          .map((entry) => Object.freeze({ ...entry })),
+      ),
+      prepared: Object.freeze({ ...this.preparedInspection }),
+    });
+  }
+
   createRecoveryRoot(scope: DeviceScope): LifecycleResourceSpec<unknown> {
     return {
       kind: 'feature',
@@ -978,6 +1159,8 @@ class FeatureHostImpl implements RenderFeatureHost {
     }
     slot.status = 'disposed';
     this.slots.splice(index, 1);
+    this.signatureByFeature.delete(feature.identity);
+    this.signatureCacheByFeature.delete(feature.identity);
     for (const [order, remaining] of this.slots.entries()) remaining.order = order;
     this.publishDiagnosticsChanged();
     return firstError === undefined ? ok(undefined) : err(firstError);
@@ -1055,11 +1238,14 @@ class FeatureHostImpl implements RenderFeatureHost {
           const result = lease.release();
           if (!result.ok && firstError === undefined) firstError = result.error;
         }
+        this.preparedInspection.released += 1;
+        if (firstError !== undefined) this.preparedInspection.releaseFailures += 1;
         return firstError === undefined ? ok(undefined) : err(firstError);
       },
     };
     this.preparedBatchStates.set(batch, 'unsubmitted');
     slot.preparedResourceBatches.add(batch);
+    this.preparedInspection.retained += 1;
     return ok(batch);
   }
 
@@ -1067,6 +1253,7 @@ class FeatureHostImpl implements RenderFeatureHost {
     for (const batch of batches) {
       if (this.preparedBatchStates.get(batch) === 'unsubmitted') {
         this.preparedBatchStates.set(batch, 'submitted');
+        this.preparedInspection.submitted += 1;
       }
     }
   }
@@ -1166,9 +1353,11 @@ export function runRenderFeatureFrame(
   const plans: RenderFeaturePlannedFrame[] = [];
   const fullscreenEffects = new Map<string, PostProcessShaderEntry>();
   const preparedResourceBatches: RenderFeaturePreparedResourceBatch[] = [];
+  let requiresPreparedResourceKey = false;
   const hiddenEntityReports: RenderFeatureHiddenEntityReport[] = [
     ...(input.hiddenEntityReports ?? []),
   ];
+  const abortedCallbacks: (() => void)[] = [];
 
   const diagnostics = host.diagnostics();
   for (const [order, feature] of host.features.entries()) {
@@ -1247,6 +1436,9 @@ export function runRenderFeatureFrame(
           ...(input.materialShaderBindingContract === undefined
             ? {}
             : { materialShaderBindingContract: input.materialShaderBindingContract }),
+          ...(input.preparedDataInterfaces === undefined
+            ? {}
+            : { preparedDataInterfaces: input.preparedDataInterfaces }),
         }),
       stageEvents,
       errors,
@@ -1266,7 +1458,9 @@ export function runRenderFeatureFrame(
     const plannedFrame: RenderFeaturePlannedFrame = Object.freeze({
       featureIdentity: identity,
       generation: transaction.generation,
-      signature: renderFeaturePlanSignature(frozen.value),
+      signature:
+        host.recordPlanSignature?.(identity, frozen.value) ??
+        renderFeaturePlanSignature(frozen.value),
       plan: frozen.value,
     });
     for (const resource of frozen.value.resources) {
@@ -1335,10 +1529,11 @@ export function runRenderFeatureFrame(
       host.setStatus(identity, 'failed', slot.latestError);
       continue;
     }
-    const leases = [
-      ...new Set(projected.value.passes.flatMap((pass) => pass.resolvedGraphics?.leases ?? [])),
-      ...(gpu?.retireUntouched() ?? []),
-    ];
+    const graphicsLeases = projected.value.passes.flatMap(
+      (pass) => pass.resolvedGraphics?.leases ?? [],
+    );
+    if (graphicsLeases.length > 0) requiresPreparedResourceKey = true;
+    const leases = [...new Set(graphicsLeases), ...(gpu?.retireUntouched() ?? [])];
     const retained = host.retainPreparedGraphics(identity, leases);
     if (!retained.ok) {
       recordFailure(slot, 'plan', retained.error, errors);
@@ -1347,19 +1542,42 @@ export function runRenderFeatureFrame(
       continue;
     }
     planExecutionProjections.set(plannedFrame, projected.value);
+    if (feature.onFrameSubmitted !== undefined) {
+      submissionSensitivePlans.add(plannedFrame);
+      submissionAcknowledgments.set(plannedFrame, () =>
+        feature.onFrameSubmitted?.(extracted.value),
+      );
+    }
     plans.push(plannedFrame);
+    if (feature.onFrameAborted !== undefined) {
+      abortedCallbacks.push(() => feature.onFrameAborted?.(extracted.value));
+    }
     if (leases.length > 0) preparedResourceBatches.push(retained.value);
     hiddenEntityReports.push(...featureHiddenEntityReports);
     host.setStatus(identity, 'active');
   }
 
+  let submitted = false;
+  let aborted = false;
   return {
     stageEvents,
     errors,
     plans,
     fullscreenEffects,
     preparedResourceBatches,
+    requiresPreparedResourceKey,
     hiddenEntityReports: mergeHiddenEntityReports(hiddenEntityReports),
+    onSubmitted: () => {
+      if (submitted || aborted) return;
+      submitted = true;
+      acknowledgeRenderFeatureSubmission(plans);
+    },
+    onAborted: () => {
+      if (submitted || aborted) return;
+      aborted = true;
+      for (const plan of plans) submissionAcknowledgments.delete(plan);
+      for (const callback of abortedCallbacks) callback();
+    },
   };
 }
 

package/src/features/noise-texture.ts

@@ -0,0 +1,91 @@
+import type { RhiDevice, RhiError, Texture, TextureView } from '@forgeax/engine-rhi';
+import { ok, type Result } from '@forgeax/engine-types';
+import type { DeviceScope } from '../device/device-scope';
+import {
+  GPU_TEXTURE_USAGE_COPY_DST,
+  GPU_TEXTURE_USAGE_TEXTURE_BINDING,
+} from '../gpu-texture-usage';
+
+/** A reproducible, filterable RGBA noise field; each channel has an independent sample. */
+export function createFeatureNoisePixels(): Uint8Array {
+  const pixels = new Uint8Array(64 * 64 * 4);
+  let state = 0x6d2b79f5;
+  for (let index = 0; index < pixels.length; index++) {
+    state ^= state << 13;
+    state ^= state >>> 17;
+    state ^= state << 5;
+    pixels[index] = state >>> 24;
+  }
+  return pixels;
+}
+
+/** The caller's device scope owns the texture, like the other built-in material inputs. */
+export function createFeatureNoiseTexture(
+  device: RhiDevice,
+): Result<{ readonly texture: Texture; readonly view: TextureView }, RhiError> {
+  const texture = device.createTexture({
+    label: 'feature-noise-64x64',
+    size: { width: 64, height: 64 },
+    format: 'rgba8unorm',
+    usage: GPU_TEXTURE_USAGE_COPY_DST | GPU_TEXTURE_USAGE_TEXTURE_BINDING,
+    textureBindingViewDimension: undefined,
+  });
+  if (!texture.ok) return texture;
+  const uploaded = device.queue.writeTexture(
+    { texture: texture.value },
+    createFeatureNoisePixels(),
+    { bytesPerRow: 256, rowsPerImage: 64 },
+    { width: 64, height: 64 },
+  );
+  if (!uploaded.ok) {
+    device.destroyTexture(texture.value);
+    return uploaded;
+  }
+  const view = device.createTextureView(texture.value, {
+    label: 'feature-noise-view',
+    dimension: '2d',
+  });
+  if (!view.ok) {
+    device.destroyTexture(texture.value);
+    return view;
+  }
+  return ok({ texture: texture.value, view: view.value });
+}
+
+/** Lazily provisions one generation-owned noise view for feature preparation. */
+export function createFeatureNoiseResolver(input: {
+  readonly scope: DeviceScope;
+  readonly getDevice: () => RhiDevice;
+  readonly onError: (error: RhiError) => void;
+}): (frameNumber: number) => TextureView | undefined {
+  let current:
+    | { readonly device: RhiDevice; readonly generation: number; readonly view: TextureView }
+    | undefined;
+  let attempt:
+    | { readonly device: RhiDevice; readonly generation: number; readonly frameNumber: number }
+    | undefined;
+  return (frameNumber) => {
+    const device = input.getDevice();
+    const generation = input.scope.generation;
+    if (current?.device === device && current.generation === generation) return current.view;
+    if (
+      attempt?.device === device &&
+      attempt.generation === generation &&
+      attempt.frameNumber === frameNumber
+    ) {
+      return undefined;
+    }
+    current = undefined;
+    attempt = { device, generation, frameNumber };
+    const created = createFeatureNoiseTexture(device);
+    if (!created.ok) {
+      input.onError(created.error);
+      return undefined;
+    }
+    input.scope._adopt('texture', created.value.texture, (value) => {
+      device.destroyTexture(value);
+    });
+    current = { device, generation, view: created.value.view };
+    return current.view;
+  };
+}