@forgeax/engine-vfx-render 0.1.27 → 0.1.29

package/src/feature/gpu-particle-feature.ts

@@ -1,11 +1,21 @@
 import type { EntityHandle, World } from '@forgeax/engine-ecs';
 import { frustum } from '@forgeax/engine-math';
-import type { RenderFeature, RenderFeaturePlan } from '@forgeax/engine-render';
+import type {
+  RenderFeature,
+  RenderFeaturePlan,
+  RenderFeaturePlanContext,
+} from '@forgeax/engine-render';
 import { GlobalTransform } from '@forgeax/engine-scene';
 import { err, type MaterialAsset, type MeshAsset, ok } from '@forgeax/engine-types';
-import type { ParticleRendererSource } from '@forgeax/engine-vfx';
+import type {
+  ParticleRendererSourceV3,
+  VfxDataInterfaceRequirement,
+  VfxDataInterfaceResource,
+} from '@forgeax/engine-vfx';
 import {
   VFX_GPU_RUNTIME_RESOURCE_KEY,
+  VFX_PARTICLE_CORE_STRIDE,
+  type VfxGpuEmitterSource,
   type VfxGpuRuntime,
   type VfxGpuTickIntent,
 } from '@forgeax/engine-vfx';
@@ -14,7 +24,7 @@ import { RENDER_FEATURE_VERTEX_LAYOUTS } from '../../../render/src/features/prep
 import type { VfxDataInterfaceRegistry } from '../host/data-interface-providers.js';
 import type { ParticleRenderCamera } from './camera.js';
 import {
-  encodeEventInputs,
+  encodeEventBuffer,
   eventCapacity,
   eventInputCapacity,
   VFX_EVENT_BYTES,
@@ -23,26 +33,28 @@ import {
 import {
   canonicalMeshVertices,
   createTopologyResourcePlan,
+  PARTICLE_INPUT_SHADER_IDENTIFIERS,
   PARTICLE_SHADER_IDENTIFIERS,
   particleMaterialPass,
   particleMaterialSceneDepthBinding,
   particleMaterialUsesBindings,
   particleRendererRenderState,
+  prepareParticleMaterialInputs,
 } from './particle-resources.js';
 import type { VfxStagePlanObservation, VfxValidatedStagePlan } from './stage-plan.js';
 import { validatedStagePlan } from './stage-plan.js';
 
 const IDENTITY = 'forgeax.vfx-render.gpu-particles';
 const WORKGROUP_SIZE = 256;
-const PARTICLE_BYTES = 80;
 const BILLBOARD_INSTANCE_BYTES = 31 * 4;
-const MESH_INSTANCE_BYTES = 28 * 4;
+const MESH_INSTANCE_BYTES = 18 * 4;
 const COUNTERS_BYTES = 24;
-const RUNTIME_BYTES = 72 * 4;
+const RUNTIME_BYTES = 76 * 4;
 const IDENTITY_MATRIX = new Float32Array([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]);
 
-type ParticleRendererKind = ParticleRendererSource['kind'];
-type ParticleTopologyRenderer = Extract<ParticleRendererSource, { readonly capacity: number }>;
+type ParticleRendererKind = ParticleRendererSourceV3['kind'];
+type ParticleRenderer = ParticleRendererSourceV3;
+type ParticleTopologyRenderer = Extract<ParticleRendererSourceV3, { readonly capacity: number }>;
 type ParticleTopologyKind = ParticleTopologyRenderer['kind'];
 type VfxStageOutput = VfxStagePlanObservation['stageOutput'];
 
@@ -95,7 +107,7 @@ export interface BillboardAdvancedSample {
 }
 
 export function resolveBillboardAdvancedState(
-  renderer: Extract<ParticleRendererSource, { readonly kind: 'billboard' }>,
+  renderer: Extract<ParticleRendererSourceV3, { readonly kind: 'billboard' }>,
   sample: BillboardAdvancedSample,
 ) {
   if (renderer.softParticle !== undefined && !sample.depthAvailable) {
@@ -129,7 +141,10 @@ export function resolveBillboardAdvancedState(
     frameIndex,
     pivot: renderer.pivot ?? ([0, 0] as const),
     softParticleFade,
-    sortingKey: renderer.sorting === 'back-to-front' ? sample.particleDepth : 0,
+    sortingKey:
+      renderer.sorting === 'view-depth' || renderer.sorting === 'view-distance'
+        ? sample.particleDepth
+        : 0,
   });
 }
 
@@ -161,6 +176,20 @@ interface ExtractedWorld {
   readonly runtime: VfxGpuRuntime;
   readonly camera: ParticleRenderCamera;
   readonly intents: readonly VfxGpuTickIntent[];
+  /**
+   * Last submitted emitter state kept drawable between fixed ticks.  The
+   * queue above is simulation work only; renderHz is allowed to exceed
+   * fixedHz, and a live emitter must keep its projection/raster lease warm.
+   */
+  readonly retained: readonly RetainedEmitter[];
+}
+
+interface RetainedEmitter {
+  readonly player: VfxGpuEmitterSource['player'];
+  readonly emitter: VfxGpuEmitterSource['emitter'];
+  readonly intent: VfxGpuTickIntent;
+  readonly localToWorld: Float32Array;
+  readonly visible: boolean;
 }
 
 interface ExtractedFrame {
@@ -172,6 +201,22 @@ function finite(value: unknown, fallback: number): number {
   return typeof value === 'number' && Number.isFinite(value) ? value : fallback;
 }
 
+function billboardSortingMode(renderer: ParticleRenderer | undefined): 0 | 1 | 2 | 3 | 4 | 5 {
+  if (renderer?.kind !== 'billboard') return 0;
+  switch (renderer.sorting) {
+    case 'view-depth':
+      return 2;
+    case 'view-distance':
+      return 5;
+    case 'custom-ascending':
+      return 3;
+    case 'custom-descending':
+      return 4;
+    default:
+      return 0;
+  }
+}
+
 function vector(value: unknown, fallback: readonly number[], size: number): readonly number[] {
   return Array.isArray(value)
     ? Array.from({ length: size }, (_, index) => finite(value[index], fallback[index] ?? 0))
@@ -183,8 +228,10 @@ function runtimeData(
   camera: ParticleRenderCamera,
   material: MaterialAsset | undefined,
   localToWorld: Float32Array,
-  renderer?: ParticleRendererSource,
+  renderer?: ParticleRenderer,
   rendererIndex = 0,
+  particleInputLanes = renderer?.materialInputs?.length ?? 0,
+  meshDraw?: { readonly count: number; readonly firstIndex: number },
 ): Uint8Array {
   const storage = new ArrayBuffer(RUNTIME_BYTES);
   const floats = new Float32Array(storage);
@@ -200,6 +247,7 @@ function runtimeData(
   floats.set(camera.viewProjection, 8);
   floats.set(camera.right, 24);
   floats.set(camera.up, 28);
+  floats.set(camera.position, 72);
   const values = material?.values ?? {};
   floats.set(vector(values.baseColor, [1, 1, 1, 1], 4), 32);
   const emissive = vector(values.emissive, [0, 0, 0], 3);
@@ -211,17 +259,19 @@ function runtimeData(
   floats[43] = finite(values.clearcoatRoughness, 0.5);
   floats.set(localToWorld, 44);
   words[60] = rendererIndex;
-  words[61] = renderer?.kind === 'trail' ? renderer.historyLength : 0;
+  words[61] =
+    renderer === undefined &&
+    ((intent.emitter.reflection.resources ?? []).includes('eventBuffer') ||
+      (intent.emitter.reflection.entryPoints ?? []).includes('forgeax_vfx_event_main'))
+      ? eventInputCapacity(intent.emitter)
+      : renderer?.kind === 'trail'
+        ? renderer.historyLength
+        : (meshDraw?.count ?? 0);
   words[62] =
     renderer?.kind === 'ribbon' || renderer?.kind === 'trail' || renderer?.kind === 'beam'
       ? renderer.capacity
       : intent.emitter.capacity;
-  words[63] =
-    renderer?.kind === 'billboard' && renderer.sorting === 'back-to-front'
-      ? 2
-      : renderer?.kind === 'billboard' && renderer.sorting === 'emitter'
-        ? 1
-        : 0;
+  words[63] = meshDraw?.firstIndex ?? billboardSortingMode(renderer);
   floats[64] =
     renderer?.kind === 'billboard'
       ? (renderer.pivot?.[0] ?? 0)
@@ -230,6 +280,9 @@ function runtimeData(
         : 0.1;
   floats[65] = renderer?.kind === 'billboard' ? (renderer.pivot?.[1] ?? 0) : 0;
   floats[66] = renderer?.kind === 'billboard' ? (renderer.softParticle?.fadeDistance ?? 0) : 0;
+  // The projection shader derives its instance stride from this reflected
+  // material-input lane count; undeclared inputs therefore allocate nothing.
+  floats[67] = particleInputLanes;
   const sheet = renderer?.kind === 'billboard' ? renderer.textureSheet : undefined;
   floats[68] = sheet?.columns ?? 1;
   floats[69] = sheet?.rows ?? 1;
@@ -245,11 +298,11 @@ function emitterTransform(world: World, intent: VfxGpuTickIntent): Float32Array
 }
 
 function emitterVisible(
-  intent: VfxGpuTickIntent,
+  emitter: VfxGpuTickIntent['emitter'],
   camera: ParticleRenderCamera,
   localToWorld: Float32Array,
 ): boolean {
-  const bounds = intent.emitter.bounds;
+  const bounds = emitter.bounds;
   const center =
     bounds.kind === 'sphere'
       ? bounds.center
@@ -291,6 +344,53 @@ function requiresSceneDepth(intent: VfxGpuTickIntent): boolean {
   );
 }
 
+function dataInterfacesExecutable(
+  intent: VfxGpuTickIntent,
+  registry: Pick<VfxDataInterfaceRegistry, 'resolve'> | undefined,
+): boolean {
+  const requirements = intent.emitter.reflection.dataInterfaces ?? [];
+  if (requirements.length === 0) return true;
+  const resolved = registry?.resolve(requirements, intent.instanceGeneration);
+  // Render can provide its prepared fallback resources. An unavailable
+  // provider is therefore deferred in plan, while an explicit hard failure
+  // remains fail-closed and observable.
+  if (resolved === undefined) return true;
+  if (!resolved.ok) {
+    const error = resolved.error;
+    if (error === undefined) return false;
+    return (
+      error.code === 'vfx-data-interface-missing' &&
+      (error.detail.providerId === undefined || error.expected.includes('resident'))
+    );
+  }
+  // Synthetic availability-only providers used by host probes intentionally
+  // omit the payload; concrete plan resources are still checked below.
+  if (resolved.value === undefined) return true;
+  return resolved.value.resources.every((resource) => resource.resource !== undefined);
+}
+
+function preparedDataInterfaceResources(
+  requirements: readonly VfxDataInterfaceRequirement[],
+  generation: number,
+  prepared: RenderFeaturePlanContext['preparedDataInterfaces'],
+): readonly VfxDataInterfaceResource[] | undefined {
+  if (prepared === undefined) return undefined;
+  const resources: VfxDataInterfaceResource[] = [];
+  for (const requirement of requirements) {
+    const value = prepared[requirement.kind];
+    if (value === undefined) return undefined;
+    resources.push({
+      token: requirement.token,
+      kind: requirement.kind,
+      bindingType: requirement.bindingType,
+      generation,
+      ...(requirement.sampleCount === undefined ? {} : { sampleCount: requirement.sampleCount }),
+      resource: value,
+    });
+  }
+  return resources;
+}
+
 function planFailure(): RenderFeatureStageFailedError {
   return new RenderFeatureStageFailedError(IDENTITY, -1, 'plan', 'next-frame');
 }
@@ -309,7 +409,13 @@ function computeBindingEntries(
 ): readonly { readonly binding: number; readonly resource: string }[] {
   const declared = new Set(
     (intent.emitter.reflection.bindings[0]?.entries ?? [])
-      .filter((entry) => entry.buffer !== undefined)
+      .filter(
+        (entry) =>
+          entry.buffer !== undefined ||
+          entry.texture !== undefined ||
+          entry.sampler !== undefined ||
+          entry.storageTexture !== undefined,
+      )
       .map((entry) => entry.binding),
   );
   return Object.entries(resources).flatMap(([binding, resource]) =>
@@ -322,6 +428,12 @@ function simulationDispatches(
   stages: VfxValidatedStagePlan,
 ): Extract<PlanPass, { readonly kind: 'compute' }>['dispatches'] {
   const groups = Math.max(1, Math.ceil(intent.emitter.capacity / WORKGROUP_SIZE));
+  const compact: Extract<PlanPass, { readonly kind: 'compute' }>['dispatches'] = [
+    { kind: 'direct', entryPoint: 'forgeax_vfx_scan_blocks_main', workgroups: [groups] },
+    { kind: 'direct', entryPoint: 'forgeax_vfx_scan_block_offsets_main', workgroups: [1] },
+    { kind: 'direct', entryPoint: 'forgeax_vfx_add_offsets_main', workgroups: [groups] },
+    { kind: 'direct', entryPoint: 'forgeax_vfx_compact_main', workgroups: [groups] },
+  ];
   return [
     { kind: 'direct', entryPoint: 'forgeax_vfx_spawn_main', workgroups: [groups] },
     { kind: 'direct', entryPoint: 'forgeax_vfx_update_main', workgroups: [groups] },
@@ -330,22 +442,83 @@ function simulationDispatches(
       entryPoint: stage.entryPoint,
       workgroups: [groups] as const,
     })),
-    { kind: 'direct', entryPoint: 'forgeax_vfx_scan_blocks_main', workgroups: [groups] },
-    { kind: 'direct', entryPoint: 'forgeax_vfx_scan_block_offsets_main', workgroups: [1] },
-    { kind: 'direct', entryPoint: 'forgeax_vfx_add_offsets_main', workgroups: [groups] },
-    { kind: 'direct', entryPoint: 'forgeax_vfx_compact_main', workgroups: [groups] },
-    {
-      kind: 'direct',
-      entryPoint: 'forgeax_vfx_event_main',
-      workgroups: [Math.max(1, Math.ceil(eventInputCapacity(intent.emitter) / 64))],
-    },
+    ...compact,
+    ...(intent.emitter.reflection.entryPoints.includes('forgeax_vfx_event_main')
+      ? [
+          {
+            kind: 'direct' as const,
+            entryPoint: 'forgeax_vfx_event_main',
+            workgroups: [1] as const,
+          },
+          ...compact,
+        ]
+      : []),
   ];
 }
 
 export function gpuParticleRenderFeature(
   options: GpuParticleFeatureOptions,
 ): RenderFeature<ExtractedFrame> {
-  return {
+  type IntentOutcomeState = 'dispatched' | 'skipped' | 'deferred';
+  interface PlannedIntent {
+    readonly intent: VfxGpuTickIntent;
+    readonly localToWorld: Float32Array;
+    readonly stagePlan: VfxValidatedStagePlan;
+    /** Camera projection is optional for `simulationWhenCulled: continue`. */
+    readonly visible: boolean;
+    /** Retained state has no fixed-tick simulation/history work this frame. */
+    readonly retained: boolean;
+  }
+  interface EmitterGroup {
+    readonly key: string;
+    readonly worldIndex: number;
+    readonly entry: ExtractedWorld;
+    readonly intents: PlannedIntent[];
+    readonly initialReset: boolean;
+  }
+  interface IntentOutcome {
+    readonly intent: VfxGpuTickIntent;
+    readonly state: IntentOutcomeState;
+    /** Stable reset epoch assigned once per intent, including retry plans. */
+    readonly resetEpoch?: number;
+  }
+  interface PendingEntry {
+    readonly world: World;
+    readonly runtime: VfxGpuRuntime;
+    readonly outcomes: readonly IntentOutcome[];
+  }
+  const pendingFrames = new Map<number, readonly PendingEntry[]>();
+  const worldIds = new WeakMap<World, number>();
+  const runtimeIds = new WeakMap<VfxGpuRuntime, number>();
+  const resetEpochByEmitter = new WeakMap<VfxGpuRuntime, Map<string, number>>();
+  // Sequences are local to a VfxGpuRuntime.  Scope reset reservations by the
+  // runtime instance so detach/reattach on the same World cannot borrow old
+  // epochs.  Reservations survive an aborted frame, but are only promoted to
+  // the emitter's committed epoch on submission.
+  const resetEpochByIntent = new WeakMap<
+    VfxGpuRuntime,
+    Map<
+      number,
+      { readonly generation: number; readonly emitterKey: string; readonly epoch: number }
+    >
+  >();
+  let nextWorldId = 0;
+  let nextRuntimeId = 0;
+  const worldId = (world: World): number => {
+    const prior = worldIds.get(world);
+    if (prior !== undefined) return prior;
+    const assigned = nextWorldId++;
+    worldIds.set(world, assigned);
+    return assigned;
+  };
+  const runtimeId = (runtime: VfxGpuRuntime): number => {
+    const prior = runtimeIds.get(runtime);
+    if (prior !== undefined) return prior;
+    const assigned = nextRuntimeId++;
+    runtimeIds.set(runtime, assigned);
+    return assigned;
+  };
+  const feature: RenderFeature<ExtractedFrame> = {
     identity: IDENTITY,
     requiredCapabilities: ['compute', 'indirectDrawing'],
     // Generated emitter programs are first-use assets. They must hand a
@@ -353,438 +526,1000 @@ export function gpuParticleRenderFeature(
     // diagnostic-only getCompilationInfo() round trip; pipeline creation still
     // validates the module before the pass is submitted.
     shaderModuleMode: 'immediate',
-    requiredMaterialShaders: Object.values(PARTICLE_SHADER_IDENTIFIERS),
+    requiredMaterialShaders: Object.freeze([
+      ...Object.values(PARTICLE_SHADER_IDENTIFIERS),
+      ...Object.values(PARTICLE_INPUT_SHADER_IDENTIFIERS),
+    ]),
     extract: (context) => {
+      // A rejected recovery candidate can outlive the frame that produced it.
+      // Keep the producer-owned submission ledger bounded even when a host
+      // disappears before it can call onFrameAborted.
+      for (const frameNumber of pendingFrames.keys()) {
+        if (frameNumber + 4 < context.frameNumber) pendingFrames.delete(frameNumber);
+      }
       const extracted: ExtractedWorld[] = [];
       for (const world of context.worlds) {
         if (!world.hasResource(VFX_GPU_RUNTIME_RESOURCE_KEY)) continue;
         const camera = options.camera.read(world);
         if (camera === undefined) continue;
         const runtime = world.getResource<VfxGpuRuntime>(VFX_GPU_RUNTIME_RESOURCE_KEY);
-        const intents = runtime.snapshot().filter((intent) => {
-          if (options.playerConsumption?.isEnabled(world, intent.player) === false) return false;
-          const requirements = intent.emitter.reflection.dataInterfaces ?? [];
-          return (
-            requirements.length === 0 ||
-            options.dataInterfaces?.resolve(requirements, intent.instanceGeneration).ok === true
-          );
+        const retained: RetainedEmitter[] = [];
+        // Refresh frustum state from live emitter sources even when a paused
+        // or restart-on-visible emitter has no queued tick.  Otherwise a
+        // camera move back into its bounds can never produce the next intent.
+        runtime.forEachEmitterSource(({ player, emitter }) => {
+          const sourceIntent = runtime.lastCommittedEmitter(player, emitter.id);
+          const localToWorld =
+            sourceIntent === undefined
+              ? emitter.space === 'world'
+                ? IDENTITY_MATRIX
+                : (() => {
+                    const transform = world.get(player, GlobalTransform);
+                    return transform.ok ? transform.value.world : IDENTITY_MATRIX;
+                  })()
+              : emitterTransform(world, sourceIntent);
+          const visible = emitterVisible(emitter, camera, localToWorld);
+          runtime.setEmitterCameraVisibility(player, emitter.id, visible);
+          const intent = runtime.lastCommittedEmitter(player, emitter.id);
+          if (intent !== undefined) {
+            retained.push({ player, emitter, intent, localToWorld, visible });
+          }
         });
-        extracted.push({ world, runtime, camera, intents });
+        // Keep every queued intent in the extracted frame.  Plan assigns each
+        // intent an explicit terminal state (dispatched/skipped/deferred), so a
+        // filtered head can never block an acknowledged tail or be silently
+        // removed by a later global commit.
+        const intents = runtime.snapshot();
+        extracted.push({ world, runtime, camera, intents, retained });
       }
       return ok({ worlds: extracted, frameNumber: context.frameNumber });
     },
     plan: (frame, context) => {
       const resources: PlanResource[] = [];
       const passes: PlanPass[] = [];
-      const dispatchedIntents = new Set<VfxGpuTickIntent>();
       const colorTarget =
         context.targets.find((candidate) => candidate.kind === 'color') ??
         context.targets.find((candidate) => candidate.kind === 'swapchain');
       const depthTarget = context.targets.find((candidate) => candidate.kind === 'depth');
+      const groups = new Map<string, EmitterGroup>();
+      const outcomesByEntry = new Map<ExtractedWorld, IntentOutcome[]>();
 
+      // First classify every queued intent.  A deferred intent is an ordered
+      // barrier: later intents in the same runtime cannot be dispatched until
+      // the provider/target is ready.  Session masks and paused consumption
+      // skip ordinary ticks, but a reset remains deferred so a new authored
+      // timeline cannot be mixed into the previous GPU state.
+      // The key is the stable player/emitter identity plus a reset epoch; queued
+      // ticks in one epoch deliberately share their particle/counter/history
+      // storage.
       for (const [worldIndex, entry] of frame.worlds.entries()) {
-        for (const [intentIndex, intent] of entry.intents.entries()) {
-          if (!entry.runtime.isEmitterSessionEnabled(intent.player, intent.emitter.id)) continue;
+        const outcomes: IntentOutcome[] = [];
+        outcomesByEntry.set(entry, outcomes);
+        const effectiveEpochByEmitter = new Map<string, number>();
+        const renderGeneration = entry.runtime.renderGeneration ?? 0;
+        const attachmentId = runtimeId(entry.runtime);
+        let emitterEpochs = resetEpochByEmitter.get(entry.runtime);
+        if (emitterEpochs === undefined) {
+          emitterEpochs = new Map();
+          resetEpochByEmitter.set(entry.runtime, emitterEpochs);
+        }
+        let reservations = resetEpochByIntent.get(entry.runtime);
+        if (reservations === undefined) {
+          reservations = new Map();
+          resetEpochByIntent.set(entry.runtime, reservations);
+        }
+        const liveResetSequences = new Set(
+          (entry.runtime.snapshot?.() ?? entry.intents)
+            .filter((intent) => intent.reset)
+            .map((intent) => intent.sequence),
+        );
+        for (const [sequence, reservation] of reservations) {
+          if (reservation.generation !== renderGeneration || !liveResetSequences.has(sequence)) {
+            reservations.delete(sequence);
+          }
+        }
+        // Ordering barriers belong to one player/emitter stream.  A paused
+        // reset or unavailable provider must not head-of-line block unrelated
+        // players that share the same VfxGpuRuntime/World.
+        const blockedEmitters = new Set<string>();
+        for (const intent of entry.intents) {
+          const baseKey =
+            `${worldId(entry.world)}:${renderGeneration}:` +
+            `${Number(intent.player)}:${intent.emitter.id}`;
+          let priorReservedEpoch: number | undefined;
+          let priorReservedSequence = -1;
+          let exactReservation:
+            | { readonly generation: number; readonly emitterKey: string; readonly epoch: number }
+            | undefined;
+          for (const [sequence, reservation] of reservations) {
+            if (reservation.generation === renderGeneration && reservation.emitterKey === baseKey) {
+              if (sequence === intent.sequence) {
+                exactReservation = reservation;
+              } else if (sequence < intent.sequence && sequence > priorReservedSequence) {
+                priorReservedEpoch = reservation.epoch;
+                priorReservedSequence = sequence;
+              }
+            }
+          }
+          const committedEpoch =
+            effectiveEpochByEmitter.get(baseKey) ??
+            Math.max(emitterEpochs.get(baseKey) ?? 0, priorReservedEpoch ?? 0);
+          let resetEpoch = committedEpoch;
+          if (intent.reset) {
+            resetEpoch =
+              exactReservation?.generation === renderGeneration &&
+              exactReservation.emitterKey === baseKey
+                ? exactReservation.epoch
+                : committedEpoch + 1;
+            reservations.set(intent.sequence, {
+              generation: renderGeneration,
+              emitterKey: baseKey,
+              epoch: resetEpoch,
+            });
+          }
+          if (blockedEmitters.has(baseKey)) {
+            outcomes.push({
+              intent,
+              state: 'deferred',
+              ...(intent.reset ? { resetEpoch } : {}),
+            });
+            continue;
+          }
+          if (
+            options.playerConsumption?.isEnabled(entry.world, intent.player) === false ||
+            !entry.runtime.isEmitterSessionEnabled(intent.player, intent.emitter.id)
+          ) {
+            const state = intent.reset ? ('deferred' as const) : ('skipped' as const);
+            outcomes.push({
+              intent,
+              state,
+              ...(intent.reset ? { resetEpoch } : {}),
+            });
+            if (intent.reset) blockedEmitters.add(baseKey);
+            continue;
+          }
           const localToWorld = emitterTransform(entry.world, intent);
-          const visible = emitterVisible(intent, entry.camera, localToWorld);
+          const visible = emitterVisible(intent.emitter, entry.camera, localToWorld);
           entry.runtime.setEmitterCameraVisibility(intent.player, intent.emitter.id, visible);
-          if (!visible) continue;
-          if (requiresSceneDepth(intent) && depthTarget === undefined) continue;
-
+          if (!visible && intent.emitter.simulationWhenCulled !== 'continue') {
+            const state = intent.reset ? ('deferred' as const) : ('skipped' as const);
+            outcomes.push({
+              intent,
+              state,
+              ...(intent.reset ? { resetEpoch } : {}),
+            });
+            if (intent.reset) blockedEmitters.add(baseKey);
+            continue;
+          }
+          if (
+            visible &&
+            requiresSceneDepth(intent) &&
+            (depthTarget === undefined || depthTarget.sampleCount !== 1)
+          ) {
+            outcomes.push({
+              intent,
+              state: 'deferred',
+              ...(intent.reset ? { resetEpoch } : {}),
+            });
+            blockedEmitters.add(baseKey);
+            continue;
+          }
+          const requirements = intent.emitter.reflection.dataInterfaces ?? [];
+          if (
+            requirements.length > 0 &&
+            !dataInterfacesExecutable(intent, options.dataInterfaces)
+          ) {
+            outcomes.push({
+              intent,
+              state: 'deferred',
+              ...(intent.reset ? { resetEpoch } : {}),
+            });
+            blockedEmitters.add(baseKey);
+            continue;
+          }
           const stagePlan = validatedStagePlan(
             intent.emitter.reflection.stages,
             intent.instanceGeneration,
           );
           if (!stagePlan.ok) return err(planFailure());
+          const entryPoints = new Set(intent.emitter.reflection.entryPoints);
+          const dispatches = simulationDispatches(intent, stagePlan.value).filter((dispatch) =>
+            entryPoints.has(dispatch.entryPoint),
+          );
+          if (dispatches.length === 0 && intent.emitter.renderers.length === 0) {
+            outcomes.push({
+              intent,
+              state: 'skipped',
+              ...(intent.reset ? { resetEpoch } : {}),
+            });
+            continue;
+          }
+          effectiveEpochByEmitter.set(baseKey, resetEpoch);
+          const key =
+            `vfx.w-${planName(worldId(entry.world).toString(36), 8)}.` +
+            `a-${planName(attachmentId.toString(36), 8)}.` +
+            `r-${entry.runtime.renderGeneration}.p-${planName(Number(intent.player).toString(36), 16)}.` +
+            `${planName(intent.emitter.id)}.g-${resetEpoch}`;
+          let group = groups.get(key);
+          if (group === undefined) {
+            group = {
+              key,
+              worldIndex,
+              entry,
+              intents: [],
+              // Reset data is a per-frame boundary, not a property of the
+              // epoch.  Once a reset-created group is warm, later ticks in
+              // the same epoch must retain its particle state.
+              initialReset: intent.reset,
+            };
+            groups.set(key, group);
+          } else if (
+            group.entry !== entry ||
+            group.intents[0]?.intent.emitter.wgsl !== intent.emitter.wgsl ||
+            group.intents[0]?.intent.emitter.capacity !== intent.emitter.capacity
+          ) {
+            return err(planFailure());
+          }
+          group.intents.push({
+            intent,
+            localToWorld,
+            stagePlan: stagePlan.value,
+            visible,
+            retained: false,
+          });
+          outcomes.push({
+            intent,
+            state: dispatches.length > 0 ? 'dispatched' : 'skipped',
+            ...(intent.reset ? { resetEpoch } : {}),
+          });
+          if (dispatches.length === 0) effectiveEpochByEmitter.delete(baseKey);
+        }
+      }
 
-          const prefix = `vfx.w-${worldIndex}.i-${intentIndex}.${planName(intent.emitter.id)}`;
-          const program = `${prefix}.compute-program`;
-          const particles = `${prefix}.particles`;
-          const runtime = `${prefix}.runtime`;
-          const aliveIndices = `${prefix}.alive-indices`;
-          const counters = `${prefix}.counters`;
-          const indirect = `${prefix}.indirect`;
-          const scratch = `${prefix}.scratch`;
-          const sharedInstances = `${prefix}.shared-instances`;
-          const eventInputs = `${prefix}.event-inputs`;
-          const events = `${prefix}.events`;
-          const bindings = `${prefix}.simulation-bindings`;
-          const capacity = intent.emitter.capacity;
-          const renderers = intent.emitter.renderers;
-          const meshes = renderers.map((renderer) =>
-            renderer.kind === 'mesh' ? options.mesh?.read(entry.world, renderer.mesh) : undefined,
+      // The fixed-tick queue is intentionally empty on most render frames.
+      // Keep the last submitted emitter state as a render-only group so its
+      // persistent particle/history buffers, projection and raster passes stay
+      // alive until the player is reset. A queued intent admitted above owns
+      // the frame; deferred/skipped work falls back to this retained lease.
+      for (const [worldIndex, entry] of frame.worlds.entries()) {
+        const renderGeneration = entry.runtime.renderGeneration ?? 0;
+        const attachmentId = runtimeId(entry.runtime);
+        let emitterEpochs = resetEpochByEmitter.get(entry.runtime);
+        if (emitterEpochs === undefined) {
+          emitterEpochs = new Map();
+          resetEpochByEmitter.set(entry.runtime, emitterEpochs);
+        }
+        for (const retained of entry.retained ?? []) {
+          const hasAdmittedGroup = [...groups.values()].some(
+            (group) =>
+              group.worldIndex === worldIndex &&
+              group.entry === entry &&
+              group.intents.some(
+                (planned) =>
+                  planned.intent.player === retained.player &&
+                  planned.intent.emitter.id === retained.emitter.id,
+              ),
+          );
+          if (hasAdmittedGroup) continue;
+          const stagePlan = validatedStagePlan(
+            retained.intent.emitter.reflection.stages,
+            retained.intent.instanceGeneration,
           );
-          const indirectWords = new Uint32Array(Math.max(1, renderers.length) * 5);
+          if (!stagePlan.ok) return err(planFailure());
+          const baseKey =
+            `${worldId(entry.world)}:${renderGeneration}:` +
+            `${Number(retained.player)}:${retained.emitter.id}`;
+          const resetEpoch = emitterEpochs.get(baseKey) ?? 0;
+          const key =
+            `vfx.w-${planName(worldId(entry.world).toString(36), 8)}.` +
+            `a-${planName(attachmentId.toString(36), 8)}.` +
+            `r-${renderGeneration}.p-${planName(Number(retained.player).toString(36), 16)}.` +
+            `${planName(retained.emitter.id)}.g-${resetEpoch}`;
+          const visible =
+            retained.visible &&
+            (options.playerConsumption?.isEnabled(entry.world, retained.player) ?? true) &&
+            entry.runtime.isEmitterSessionEnabled(retained.player, retained.emitter.id);
+          groups.set(key, {
+            key,
+            worldIndex,
+            entry,
+            intents: [
+              {
+                intent: retained.intent,
+                localToWorld: retained.localToWorld,
+                stagePlan: stagePlan.value,
+                visible,
+                retained: true,
+              },
+            ],
+            initialReset: false,
+          });
+        }
+      }
 
-          for (const [rendererIndex, renderer] of renderers.entries()) {
-            const mesh = meshes[rendererIndex];
-            const submesh =
-              renderer.kind === 'mesh' ? mesh?.submeshes[renderer.submesh ?? 0] : undefined;
-            if (renderer.kind === 'mesh' && submesh === undefined) return err(planFailure());
-            if (
-              (renderer.kind === 'ribbon' ||
-                renderer.kind === 'trail' ||
-                renderer.kind === 'beam') &&
-              !createTopologyResourcePlan(renderer).ok
-            ) {
-              return err(planFailure());
+      for (const group of groups.values()) {
+        const first = group.intents[0];
+        if (first === undefined) continue;
+        const firstIntent = first.intent;
+        const prefix = group.key;
+        const program = `${prefix}.compute-program`;
+        const particles = `${prefix}.particles`;
+        const aliveIndices = `${prefix}.alive-indices`;
+        const counters = `${prefix}.counters`;
+        const indirect = `${prefix}.indirect`;
+        const scratch = `${prefix}.scratch`;
+        const sharedInstances = `${prefix}.shared-instances`;
+        // Binding 8 is the cooked event ABI: input and output records share one
+        // storage buffer. Keep the stable projection name for bind-group reuse.
+        const projectionEventInputs = `${prefix}.projection-event-inputs`;
+        const capacity = firstIntent.emitter.capacity;
+        const renderers = firstIntent.emitter.renderers;
+        const layout = firstIntent.emitter.reflection.layout;
+        const parameterBytes = layout?.parameters.size ?? 0;
+        const customStride = layout?.customLayout?.stride ?? 0;
+        const hasEvents =
+          (firstIntent.emitter.reflection.resources ?? []).includes('eventBuffer') ||
+          (firstIntent.emitter.reflection.entryPoints ?? []).includes('forgeax_vfx_event_main') ||
+          (firstIntent.emitter.reflection.bindings[0]?.entries ?? []).some(
+            (entry) => entry.binding === 8,
+          );
+        const diBindings: Record<number, string> = {};
+        const diResources: PlanResource[] = [];
+        const reflectedBindings = new Set(
+          firstIntent.emitter.reflection.bindings.flatMap((group) =>
+            group.entries.map((entry) => entry.binding),
+          ),
+        );
+        const requirements = (firstIntent.emitter.reflection.dataInterfaces ?? []).filter(
+          (requirement) => reflectedBindings.has(requirement.binding),
+        );
+        if (requirements.length > 0) {
+          let resolved = options.dataInterfaces?.resolve(
+            requirements,
+            firstIntent.instanceGeneration,
+          );
+          if (
+            (resolved === undefined ||
+              (!resolved.ok &&
+                resolved.error.code === 'vfx-data-interface-missing' &&
+                (resolved.error.detail.providerId === undefined ||
+                  resolved.error.expected.includes('resident')))) &&
+            context.preparedDataInterfaces !== undefined
+          ) {
+            const fallback = preparedDataInterfaceResources(
+              requirements,
+              firstIntent.instanceGeneration,
+              context.preparedDataInterfaces,
+            );
+            if (fallback !== undefined) {
+              resolved = ok({
+                generation: firstIntent.instanceGeneration,
+                readiness: 'ready' as const,
+                resources: fallback,
+              });
             }
-            indirectWords[rendererIndex * 5] =
-              renderer.kind === 'mesh'
-                ? mesh?.indices === undefined
-                  ? (submesh?.vertexCount ?? 0)
-                  : (submesh?.indexCount ?? 0)
-                : 6;
-            indirectWords[rendererIndex * 5 + 2] =
-              renderer.kind === 'mesh' && mesh?.indices !== undefined
-                ? (submesh?.indexOffset ?? 0)
-                : 0;
           }
+          if (resolved === undefined || !resolved.ok) return err(planFailure());
+          for (const requirement of requirements) {
+            const resource = resolved.value.resources.find(
+              (candidate) => candidate.token === requirement.token,
+            );
+            const prepared = resource?.resource;
+            if (resource === undefined || prepared === undefined) return err(planFailure());
+            const name = `${prefix}.di-${planName(requirement.kind)}`;
+            if (prepared.kind === 'buffer') {
+              if (prepared.size === undefined || prepared.size <= 0) return err(planFailure());
+              diResources.push({
+                kind: 'prepared-gpu-resource',
+                name,
+                resource: {
+                  kind: 'buffer',
+                  value: prepared.value,
+                  size: prepared.size,
+                  usage: prepared.usage === 'storage' ? ['storage'] : ['uniform'],
+                },
+              });
+            } else {
+              const external =
+                prepared.kind === 'texture-view'
+                  ? { kind: 'texture-view' as const, value: prepared.value }
+                  : { kind: 'sampler' as const, value: prepared.value };
+              diResources.push({
+                kind: 'prepared-gpu-resource',
+                name,
+                resource: external,
+                ...(requirement.kind === 'scene-depth' && depthTarget !== undefined
+                  ? { logicalTarget: depthTarget.name }
+                  : {}),
+              });
+            }
+            diBindings[requirement.binding] = name;
+          }
+        }
+        const meshes = renderers.map((renderer) =>
+          renderer.kind === 'mesh'
+            ? options.mesh?.read(group.entry.world, renderer.mesh)
+            : undefined,
+        );
+        const indirectWords = new Uint32Array(Math.max(1, renderers.length) * 5);
+        for (const [rendererIndex, renderer] of renderers.entries()) {
+          const mesh = meshes[rendererIndex];
+          const submesh =
+            renderer.kind === 'mesh' ? mesh?.submeshes[renderer.submesh ?? 0] : undefined;
+          if (renderer.kind === 'mesh' && submesh === undefined) return err(planFailure());
+          if (
+            (renderer.kind === 'ribbon' || renderer.kind === 'trail' || renderer.kind === 'beam') &&
+            !createTopologyResourcePlan(renderer).ok
+          ) {
+            return err(planFailure());
+          }
+          indirectWords[rendererIndex * 5] =
+            renderer.kind === 'mesh'
+              ? mesh?.indices === undefined
+                ? (submesh?.vertexCount ?? 0)
+                : (submesh?.indexCount ?? 0)
+              : 6;
+          indirectWords[rendererIndex * 5 + 2] =
+            renderer.kind === 'mesh' && mesh?.indices !== undefined
+              ? (submesh?.indexOffset ?? 0)
+              : 0;
+        }
+        const scratchBytes = (capacity * 2 + Math.ceil(capacity / WORKGROUP_SIZE)) * 4;
+        const eventBufferBytes = Math.max(
+          4,
+          eventInputCapacity(firstIntent.emitter) * VFX_EVENT_INPUT_BYTES +
+            eventCapacity(firstIntent.emitter) * VFX_EVENT_BYTES,
+        );
+        const particleBytes = VFX_PARTICLE_CORE_STRIDE;
+        const maxParticleInputBytes = Math.max(
+          0,
+          ...renderers.map((renderer) => (renderer.materialInputs?.length ?? 0) * 16),
+        );
+        resources.push(
+          ...diResources,
+          {
+            kind: 'compute-program',
+            name: program,
+            program: {
+              wgsl: firstIntent.emitter.wgsl,
+              entryPoints: firstIntent.emitter.reflection.entryPoints,
+              bindings: firstIntent.emitter.reflection.bindings,
+            },
+          },
+          {
+            kind: 'buffer',
+            name: particles,
+            size: capacity * particleBytes,
+            usage: ['storage'],
+            ...(group.initialReset ? { data: resetData(capacity * particleBytes) } : {}),
+          },
+          ...(parameterBytes === 0
+            ? []
+            : [
+                {
+                  kind: 'buffer' as const,
+                  name: `${prefix}.parameters`,
+                  size: parameterBytes,
+                  usage: ['uniform'] as const,
+                  data: firstIntent.parameterBlock,
+                },
+              ]),
+          ...(customStride === 0
+            ? []
+            : [
+                {
+                  kind: 'buffer' as const,
+                  name: `${prefix}.custom`,
+                  size: capacity * customStride,
+                  usage: ['storage'] as const,
+                  ...(group.initialReset ? { data: resetData(capacity * customStride) } : {}),
+                },
+              ]),
+          { kind: 'buffer', name: aliveIndices, size: capacity * 4, usage: ['storage'] },
+          {
+            kind: 'buffer',
+            name: counters,
+            size: COUNTERS_BYTES,
+            usage: ['storage'],
+            ...(group.initialReset ? { data: resetData(COUNTERS_BYTES) } : {}),
+          },
+          {
+            kind: 'buffer',
+            name: indirect,
+            size: indirectWords.byteLength,
+            usage: ['storage', 'indirect'],
+            ...(group.initialReset ? { data: indirectWords } : {}),
+          },
+          {
+            kind: 'buffer',
+            name: scratch,
+            size: scratchBytes,
+            usage: ['storage'],
+            ...(group.initialReset ? { data: resetData(scratchBytes) } : {}),
+          },
+          {
+            kind: 'buffer',
+            name: sharedInstances,
+            size:
+              capacity *
+              (Math.max(BILLBOARD_INSTANCE_BYTES, MESH_INSTANCE_BYTES) + maxParticleInputBytes),
+            usage: ['storage', 'vertex'],
+          },
+          ...(hasEvents
+            ? [
+                {
+                  kind: 'buffer' as const,
+                  name: projectionEventInputs,
+                  size: eventBufferBytes,
+                  usage: ['storage'] as const,
+                  data: encodeEventBuffer(firstIntent),
+                },
+              ]
+            : []),
+        );
+        const entryPoints = new Set(firstIntent.emitter.reflection.entryPoints);
 
-          const scratchBytes = (capacity * 2 + Math.ceil(capacity / WORKGROUP_SIZE)) * 4;
-          const eventInputBytes = Math.max(
-            4,
-            eventInputCapacity(intent.emitter) * VFX_EVENT_INPUT_BYTES,
-          );
-          const eventBytes = Math.max(4, eventCapacity(intent.emitter) * VFX_EVENT_BYTES);
+        // Each fixed tick gets only its own immutable runtime/event input and
+        // bindings.  The particle/counter/scratch/event/history resources are
+        // shared, so dispatch order advances one emitter state rather than
+        // simulating independent q-0/q-1 copies.
+        for (const [tickIndex, planned] of group.intents.entries()) {
+          if (planned.retained) continue;
+          const tickPrefix = `${prefix}.tick-${tickIndex}`;
+          const tickRuntime = `${tickPrefix}.runtime`;
+          const tickEventInputs = `${tickPrefix}.event-inputs`;
+          const tickBindings = `${tickPrefix}.simulation-bindings`;
           resources.push(
-            {
-              kind: 'compute-program',
-              name: program,
-              program: {
-                wgsl: intent.emitter.wgsl,
-                entryPoints: intent.emitter.reflection.entryPoints,
-                bindings: intent.emitter.reflection.bindings,
-              },
-            },
             {
               kind: 'buffer',
-              name: particles,
-              size: capacity * PARTICLE_BYTES,
-              usage: ['storage'],
-              ...(intent.reset ? { data: resetData(capacity * PARTICLE_BYTES) } : {}),
-            },
-            { kind: 'buffer', name: aliveIndices, size: capacity * 4, usage: ['storage'] },
-            {
-              kind: 'buffer',
-              name: counters,
-              size: COUNTERS_BYTES,
-              usage: ['storage'],
-              ...(intent.reset ? { data: resetData(COUNTERS_BYTES) } : {}),
-            },
-            {
-              kind: 'buffer',
-              name: indirect,
-              size: indirectWords.byteLength,
-              usage: ['storage', 'indirect'],
-              data: indirectWords,
-            },
-            {
-              kind: 'buffer',
-              name: scratch,
-              size: scratchBytes,
-              usage: ['storage'],
-              ...(intent.reset ? { data: resetData(scratchBytes) } : {}),
-            },
-            {
-              kind: 'buffer',
-              name: sharedInstances,
-              size: capacity * Math.max(BILLBOARD_INSTANCE_BYTES, MESH_INSTANCE_BYTES),
-              usage: ['storage', 'vertex'],
-            },
-            {
-              kind: 'buffer',
-              name: eventInputs,
-              size: eventInputBytes,
-              usage: ['storage'],
-              data: encodeEventInputs(intent),
-            },
-            {
-              kind: 'buffer',
-              name: events,
-              size: eventBytes,
-              usage: ['storage'],
-              ...(intent.reset ? { data: resetData(eventBytes) } : {}),
-            },
-            {
-              kind: 'buffer',
-              name: runtime,
+              name: tickRuntime,
               size: RUNTIME_BYTES,
               usage: ['uniform'],
-              data: runtimeData(intent, entry.camera, undefined, localToWorld),
+              data: runtimeData(
+                planned.intent,
+                group.entry.camera,
+                undefined,
+                planned.localToWorld,
+              ),
             },
+            ...(hasEvents
+              ? [
+                  {
+                    kind: 'buffer' as const,
+                    name: tickEventInputs,
+                    size: eventBufferBytes,
+                    usage: ['storage'] as const,
+                    data: encodeEventBuffer(planned.intent),
+                  },
+                ]
+              : []),
+            ...(parameterBytes === 0
+              ? []
+              : [
+                  {
+                    kind: 'buffer' as const,
+                    name: `${tickPrefix}.parameters`,
+                    size: parameterBytes,
+                    usage: ['uniform'] as const,
+                    data: planned.intent.parameterBlock,
+                  },
+                ]),
             {
               kind: 'compute-bindings',
-              name: bindings,
+              name: tickBindings,
               program,
-              entries: computeBindingEntries(intent, {
+              entries: computeBindingEntries(planned.intent, {
                 0: particles,
-                1: runtime,
+                1: tickRuntime,
                 2: aliveIndices,
                 3: counters,
                 4: indirect,
                 5: scratch,
                 6: sharedInstances,
-                8: eventInputs,
-                9: events,
+                ...(hasEvents ? { 8: tickEventInputs } : {}),
+                ...(parameterBytes === 0 ? {} : { 10: `${tickPrefix}.parameters` }),
+                ...(customStride === 0 ? {} : { 11: `${prefix}.custom` }),
+                ...diBindings,
               }),
             },
           );
-
-          const entryPoints = new Set(intent.emitter.reflection.entryPoints);
-          const dispatches = simulationDispatches(intent, stagePlan.value).filter((dispatch) =>
-            entryPoints.has(dispatch.entryPoint),
+          const dispatches = simulationDispatches(planned.intent, planned.stagePlan).filter(
+            (dispatch) => entryPoints.has(dispatch.entryPoint),
           );
-          if (dispatches.length > 0) {
-            passes.push({
-              kind: 'compute',
-              name: `${prefix}.simulate`,
-              program,
-              bindings,
-              dispatches,
-            });
-            dispatchedIntents.add(intent);
-          }
+          if (dispatches.length === 0) continue;
+          passes.push({
+            kind: 'compute',
+            name: `${tickPrefix}.simulate`,
+            program,
+            bindings: tickBindings,
+            dispatches,
+          });
 
+          // Trail history is part of the fixed-step simulation state.  It must
+          // be written immediately after each tick, before the next tick can
+          // mutate particles; projecting history once after the whole batch
+          // would overwrite only the latest ring slot.
           for (const [rendererIndex, renderer] of renderers.entries()) {
+            if (renderer.enabled === false) continue;
+            if (renderer.kind !== 'trail') continue;
+            if (!entryPoints.has('forgeax_vfx_trail_history_main')) continue;
             const rendererPrefix = `${prefix}.renderer-${rendererIndex}`;
-            const isBillboard = renderer.kind === 'billboard';
-            const isTopology =
-              renderer.kind === 'ribbon' || renderer.kind === 'trail' || renderer.kind === 'beam';
-            const topologyPlan = isTopology ? createTopologyResourcePlan(renderer) : undefined;
-            if (topologyPlan !== undefined && !topologyPlan.ok) return err(planFailure());
-            const material = options.material?.read(entry.world, renderer.material);
-            const materialPass = particleMaterialPass(renderer.kind, material);
-            const mesh = meshes[rendererIndex];
-            const submesh =
-              renderer.kind === 'mesh' ? mesh?.submeshes[renderer.submesh ?? 0] : undefined;
-            const indexFormat = mesh?.indices instanceof Uint32Array ? 'uint32' : 'uint16';
-            const sceneDepthBinding = isBillboard
-              ? particleMaterialSceneDepthBinding(
-                  context.materialShaderBindingContract?.(materialPass.shader) ??
-                    (materialPass.shader === PARTICLE_SHADER_IDENTIFIERS.billboard
-                      ? 'view-and-scene-depth'
-                      : undefined),
-                )
-              : undefined;
-            const instances = `${rendererPrefix}.instances`;
             const history = `${rendererPrefix}.history`;
-            const projectionRuntime = `${rendererPrefix}.runtime`;
-            const projectionBindings = `${rendererPrefix}.compute-bindings`;
-            const vertexLayout = isBillboard
-              ? RENDER_FEATURE_VERTEX_LAYOUTS.billboardMaterialInstance
-              : isTopology
-                ? RENDER_FEATURE_VERTEX_LAYOUTS.topologySegmentInstance
-                : RENDER_FEATURE_VERTEX_LAYOUTS.meshGeometryMaterialInstance;
-            const instanceBytes = isTopology
-              ? (topologyPlan?.value.vertexBytes ?? 16)
-              : capacity * (isBillboard ? BILLBOARD_INSTANCE_BYTES : MESH_INSTANCE_BYTES);
-            const historyBytes =
-              renderer.kind === 'trail'
-                ? Math.max(16, renderer.capacity * renderer.historyLength * 16)
-                : 16;
-
+            const historyRuntime = `${tickPrefix}.renderer-${rendererIndex}.history-runtime`;
+            const historyBindings = `${tickPrefix}.renderer-${rendererIndex}.history-bindings`;
             resources.push(
               {
                 kind: 'buffer',
-                name: instances,
-                size: instanceBytes,
-                usage: ['storage', 'vertex'],
-              },
-              {
-                kind: 'buffer',
-                name: history,
-                size: historyBytes,
-                usage: ['storage'],
-                ...(intent.reset ? { data: resetData(historyBytes) } : {}),
-              },
-              {
-                kind: 'buffer',
-                name: projectionRuntime,
+                name: historyRuntime,
                 size: RUNTIME_BYTES,
                 usage: ['uniform'],
                 data: runtimeData(
-                  { ...intent, fixedDelta: 0, spawnCount: 0 },
-                  entry.camera,
-                  material,
-                  localToWorld,
+                  planned.intent,
+                  group.entry.camera,
+                  undefined,
+                  planned.localToWorld,
                   renderer,
                   rendererIndex,
                 ),
               },
               {
                 kind: 'compute-bindings',
-                name: projectionBindings,
+                name: historyBindings,
                 program,
-                entries: computeBindingEntries(intent, {
+                entries: computeBindingEntries(planned.intent, {
                   0: particles,
-                  1: projectionRuntime,
+                  1: historyRuntime,
                   2: aliveIndices,
                   3: counters,
                   4: indirect,
                   5: history,
-                  6: instances,
-                  8: eventInputs,
-                  9: events,
+                  6: sharedInstances,
+                  ...(hasEvents ? { 8: tickEventInputs } : {}),
+                  ...(parameterBytes === 0 ? {} : { 10: `${tickPrefix}.parameters` }),
+                  ...(customStride === 0 ? {} : { 11: `${prefix}.custom` }),
+                  ...diBindings,
                 }),
               },
             );
+            passes.push({
+              kind: 'compute',
+              name: `${historyBindings}.write`,
+              program,
+              bindings: historyBindings,
+              dispatches: [
+                {
+                  kind: 'direct',
+                  entryPoint: 'forgeax_vfx_trail_history_main',
+                  workgroups: [Math.max(1, Math.ceil(renderer.capacity / WORKGROUP_SIZE))],
+                },
+              ],
+            });
+          }
+        }
 
-            const projectionDispatches: Extract<
-              PlanPass,
-              { readonly kind: 'compute' }
-            >['dispatches'][number][] = [];
-            const pushProjection = (entryPoint: string, workgroups: number): void => {
-              if (!entryPoints.has(entryPoint)) return;
-              projectionDispatches.push({
-                kind: 'direct',
-                entryPoint,
-                workgroups: [Math.max(1, workgroups)],
-              });
-            };
-            if (isBillboard && renderer.sorting === 'back-to-front') {
-              pushProjection('forgeax_vfx_sort_main', 1);
-            }
-            if (renderer.kind === 'trail') {
-              pushProjection(
-                'forgeax_vfx_trail_history_main',
-                Math.ceil(renderer.capacity / WORKGROUP_SIZE),
-              );
-            }
-            const projectionCount =
-              renderer.kind === 'trail'
-                ? renderer.capacity * Math.max(1, renderer.historyLength - 1)
-                : isTopology
-                  ? renderer.capacity
-                  : capacity;
-            pushProjection(
-              renderer.kind === 'billboard'
-                ? 'forgeax_vfx_billboard_main'
-                : renderer.kind === 'mesh'
-                  ? 'forgeax_vfx_mesh_main'
-                  : `forgeax_vfx_${renderer.kind}_main`,
-              Math.ceil(projectionCount / WORKGROUP_SIZE),
-            );
-            if (projectionDispatches.length > 0) {
-              passes.push({
-                kind: 'compute',
-                name: `${rendererPrefix}.project`,
-                program,
-                bindings: projectionBindings,
-                dispatches: projectionDispatches,
-              });
-            }
+        const latest = group.intents.at(-1) ?? first;
+        for (const [rendererIndex, renderer] of renderers.entries()) {
+          // Disabled entries remain in the cooked renderer index space but do
+          // not acquire projection, graphics, or shadow resources.
+          if (renderer.enabled === false) continue;
+          const rendererPrefix = `${prefix}.renderer-${rendererIndex}`;
+          const isBillboard = renderer.kind === 'billboard';
+          const isTopology =
+            renderer.kind === 'ribbon' || renderer.kind === 'trail' || renderer.kind === 'beam';
+          const topologyPlan = isTopology ? createTopologyResourcePlan(renderer) : undefined;
+          if (topologyPlan !== undefined && !topologyPlan.ok) return err(planFailure());
+          const material = options.material?.read(group.entry.world, renderer.material);
+          const reflectedRenderer = firstIntent.emitter.reflection.renderers?.[rendererIndex];
+          const preparedInputs = prepareParticleMaterialInputs(
+            renderer,
+            material,
+            reflectedRenderer?.materialInputDefinitions,
+          );
+          if (!preparedInputs.ok) return err(planFailure());
+          const hasParticleInputs = preparedInputs.value.lanes > 0;
+          const materialPass = particleMaterialPass(renderer.kind, material, hasParticleInputs);
+          const mesh = meshes[rendererIndex];
+          const submesh =
+            renderer.kind === 'mesh' ? mesh?.submeshes[renderer.submesh ?? 0] : undefined;
+          const indexFormat = mesh?.indices instanceof Uint32Array ? 'uint32' : 'uint16';
+          const sceneDepthBinding = particleMaterialSceneDepthBinding(
+            context.materialShaderBindingContract?.(materialPass.shader) ??
+              (materialPass.shader === PARTICLE_SHADER_IDENTIFIERS.billboard
+                ? 'view-and-scene-depth'
+                : undefined),
+          );
+          const instances = `${rendererPrefix}.instances`;
+          const history = `${rendererPrefix}.history`;
+          const projectionRuntime = `${rendererPrefix}.runtime`;
+          const projectionBindings = `${rendererPrefix}.compute-bindings`;
+          const vertexLayout = isBillboard
+            ? hasParticleInputs
+              ? RENDER_FEATURE_VERTEX_LAYOUTS.billboardMaterialInputInstance
+              : RENDER_FEATURE_VERTEX_LAYOUTS.billboardMaterialInstance
+            : isTopology
+              ? hasParticleInputs
+                ? RENDER_FEATURE_VERTEX_LAYOUTS.topologySegmentMaterialInputInstance
+                : RENDER_FEATURE_VERTEX_LAYOUTS.topologySegmentInstance
+              : hasParticleInputs
+                ? RENDER_FEATURE_VERTEX_LAYOUTS.meshGeometryMaterialInputInstance
+                : RENDER_FEATURE_VERTEX_LAYOUTS.meshGeometryMaterialInstance;
+          const inputBytes = preparedInputs.value.stride;
+          const instanceBytes = isTopology
+            ? (() => {
+                const vertexCount = Math.max(
+                  1,
+                  Math.floor((topologyPlan?.value.vertexBytes ?? 16) / 48),
+                );
+                return vertexCount * (48 + inputBytes);
+              })()
+            : capacity *
+              ((isBillboard ? BILLBOARD_INSTANCE_BYTES : MESH_INSTANCE_BYTES) + inputBytes);
+          const historyBytes =
+            renderer.kind === 'trail'
+              ? capacity * (Math.max(2, renderer.historyLength) + 1) * 16
+              : 16;
+          resources.push(
+            {
+              kind: 'buffer',
+              name: instances,
+              size: instanceBytes,
+              usage: ['storage', 'vertex'],
+            },
+            {
+              kind: 'buffer',
+              name: history,
+              size: historyBytes,
+              usage: ['storage'],
+              ...(group.initialReset ? { data: resetData(historyBytes) } : {}),
+            },
+          );
+          // `simulationWhenCulled: continue` still owns persistent simulation
+          // and (for trails) history writes, but it must not project or draw
+          // hidden state.  Keep the two persistent storage declarations above;
+          // the remaining projection/raster resources are draw-only.
+          const castsShadow = renderer.kind === 'mesh' && renderer.castShadows;
+          if (!latest.visible && !castsShadow) continue;
+          resources.push(
+            {
+              kind: 'buffer',
+              name: projectionRuntime,
+              size: RUNTIME_BYTES,
+              usage: ['uniform'],
+              data: runtimeData(
+                { ...latest.intent, fixedDelta: 0, spawnCount: 0 },
+                group.entry.camera,
+                material,
+                latest.localToWorld,
+                renderer,
+                rendererIndex,
+                preparedInputs.value.lanes,
+                renderer.kind === 'mesh' && submesh !== undefined
+                  ? {
+                      count: mesh?.indices === undefined ? submesh.vertexCount : submesh.indexCount,
+                      firstIndex: mesh?.indices === undefined ? 0 : submesh.indexOffset,
+                    }
+                  : undefined,
+              ),
+            },
+            {
+              kind: 'compute-bindings',
+              name: projectionBindings,
+              program,
+              entries: computeBindingEntries(latest.intent, {
+                0: particles,
+                1: projectionRuntime,
+                2: aliveIndices,
+                3: counters,
+                4: indirect,
+                5: history,
+                6: instances,
+                ...(hasEvents ? { 8: projectionEventInputs } : {}),
+                ...(parameterBytes === 0 ? {} : { 10: `${prefix}.parameters` }),
+                ...(customStride === 0 ? {} : { 11: `${prefix}.custom` }),
+                ...diBindings,
+              }),
+            },
+          );
+          const projectionDispatches: Extract<
+            PlanPass,
+            { readonly kind: 'compute' }
+          >['dispatches'][number][] = [];
+          const pushProjection = (entryPoint: string, workgroups: number): void => {
+            if (!entryPoints.has(entryPoint)) return;
+            projectionDispatches.push({
+              kind: 'direct',
+              entryPoint,
+              workgroups: [Math.max(1, workgroups)],
+            });
+          };
+          if (
+            isBillboard &&
+            (renderer.sorting === 'view-depth' ||
+              renderer.sorting === 'view-distance' ||
+              renderer.sorting === 'custom-ascending' ||
+              renderer.sorting === 'custom-descending')
+          ) {
+            pushProjection('forgeax_vfx_sort_main', 1);
+          }
+          if (renderer.kind === 'trail') pushProjection('forgeax_vfx_trail_offsets_main', 1);
+          const projectionCount =
+            renderer.kind === 'trail'
+              ? renderer.capacity * Math.max(1, renderer.historyLength - 1)
+              : isTopology
+                ? renderer.capacity
+                : capacity;
+          pushProjection(
+            renderer.kind === 'billboard'
+              ? 'forgeax_vfx_billboard_main'
+              : renderer.kind === 'mesh'
+                ? 'forgeax_vfx_mesh_main'
+                : `forgeax_vfx_${renderer.kind}_main`,
+            Math.ceil(projectionCount / WORKGROUP_SIZE),
+          );
+          if (projectionDispatches.length > 0) {
+            passes.push({
+              kind: 'compute',
+              name: `${rendererPrefix}.project`,
+              program,
+              bindings: projectionBindings,
+              dispatches: projectionDispatches,
+            });
+          }
 
-            const graphicsProgram = `${rendererPrefix}.graphics-program`;
-            const graphicsBindings = `${rendererPrefix}.graphics-bindings`;
-            const vertexData = `${rendererPrefix}.vertex-data`;
-            const defaultRenderState = particleRendererRenderState(
-              renderer.kind,
-              renderer.kind === 'billboard' ? renderer.blend : undefined,
-              materialPass.renderState,
+          const graphicsProgram = `${rendererPrefix}.graphics-program`;
+          const graphicsBindings = `${rendererPrefix}.graphics-bindings`;
+          const vertexData = `${rendererPrefix}.vertex-data`;
+          const defaultRenderState = particleRendererRenderState(
+            renderer.kind,
+            renderer.kind === 'billboard' ? renderer.blend : undefined,
+            materialPass.renderState,
+          );
+          const renderState =
+            isBillboard && depthTarget !== undefined
+              ? { ...(defaultRenderState ?? {}), depthWriteEnabled: false }
+              : defaultRenderState;
+          resources.push(
+            {
+              kind: 'graphics-program',
+              name: graphicsProgram,
+              program: {
+                shader: materialPass.shader,
+                vertexLayout,
+                ...(hasParticleInputs ? { particleInputLanes: preparedInputs.value.lanes } : {}),
+                colorFormats: [colorTarget?.format ?? 'rgba8unorm-srgb'],
+                ...(depthTarget === undefined ? {} : { depthFormat: depthTarget.format }),
+                sampleCount: colorTarget?.sampleCount ?? 1,
+                topology: submesh?.topology ?? 'triangle-list',
+                ...(mesh?.indices === undefined ? {} : { indexFormat }),
+                ...(renderState === undefined ? {} : { renderState }),
+              },
+            },
+            {
+              kind: 'graphics-bindings',
+              name: graphicsBindings,
+              program: graphicsProgram,
+              values: {
+                group: 0,
+                runtime: projectionRuntime,
+                instances,
+                ...(sceneDepthBinding === undefined ? {} : { sceneDepthBinding }),
+              },
+              ...(sceneDepthBinding !== undefined && depthTarget !== undefined
+                ? { logicalTargets: { sceneDepth: depthTarget.name } }
+                : {}),
+            },
+            { kind: 'vertex-data', name: vertexData, layout: vertexLayout, buffer: instances },
+          );
+          const drawBindings = [graphicsBindings];
+          if (
+            particleMaterialUsesBindings(material) ||
+            materialPass.shader === PARTICLE_SHADER_IDENTIFIERS.mesh ||
+            materialPass.shader === PARTICLE_INPUT_SHADER_IDENTIFIERS.mesh
+          ) {
+            const materialBindings = `${rendererPrefix}.material-bindings.w-${group.worldIndex}`;
+            resources.push({
+              kind: 'graphics-bindings',
+              name: materialBindings,
+              program: graphicsProgram,
+              values: {
+                group: 1,
+                material: { world: group.worldIndex, guid: renderer.material },
+              },
+            });
+            drawBindings.push(materialBindings);
+          }
+          const vertexBindings: { readonly slot: number; readonly resource: string }[] = [];
+          let indexData:
+            | { readonly resource: string; readonly format: 'uint16' | 'uint32' }
+            | undefined;
+          if (renderer.kind === 'mesh') {
+            if (mesh === undefined) return err(planFailure());
+            const geometryBuffer = `${rendererPrefix}.geometry-buffer`;
+            const geometry = `${rendererPrefix}.geometry`;
+            const geometryData = canonicalMeshVertices(mesh);
+            resources.push(
+              {
+                kind: 'buffer',
+                name: geometryBuffer,
+                size: geometryData.byteLength,
+                usage: ['vertex'],
+                data: geometryData,
+              },
+              {
+                kind: 'vertex-data',
+                name: geometry,
+                layout: vertexLayout,
+                buffer: geometryBuffer,
+              },
             );
-            const renderState =
-              isBillboard && depthTarget !== undefined
-                ? { ...(defaultRenderState ?? {}), depthWriteEnabled: false }
-                : defaultRenderState;
+            vertexBindings.push({ slot: 0, resource: geometry }, { slot: 1, resource: vertexData });
+            if (mesh.indices !== undefined) {
+              const indexBuffer = `${rendererPrefix}.index-buffer`;
+              const indices = `${rendererPrefix}.indices`;
+              resources.push(
+                {
+                  kind: 'buffer',
+                  name: indexBuffer,
+                  size: mesh.indices.byteLength,
+                  usage: ['index'],
+                  data: mesh.indices,
+                },
+                {
+                  kind: 'index-data',
+                  name: indices,
+                  format: indexFormat,
+                  buffer: indexBuffer,
+                },
+              );
+              indexData = { resource: indices, format: indexFormat };
+            }
+          } else {
+            vertexBindings.push({ slot: 0, resource: vertexData });
+          }
+          if (castsShadow) {
+            const shadowProgram = `${rendererPrefix}.shadow-program`;
+            const shadowBindings = `${rendererPrefix}.shadow-bindings`;
             resources.push(
               {
                 kind: 'graphics-program',
-                name: graphicsProgram,
+                name: shadowProgram,
                 program: {
-                  shader: materialPass.shader,
+                  shader: 'forgeax::vfx-render.particles.mesh-shadow',
                   vertexLayout,
-                  colorFormats: [colorTarget?.format ?? 'rgba8unorm-srgb'],
-                  ...(depthTarget === undefined ? {} : { depthFormat: depthTarget.format }),
-                  sampleCount: colorTarget?.sampleCount ?? 1,
+                  ...(hasParticleInputs ? { particleInputLanes: preparedInputs.value.lanes } : {}),
+                  colorFormats: [],
+                  depthFormat: 'depth32float',
                   topology: submesh?.topology ?? 'triangle-list',
                   ...(mesh?.indices === undefined ? {} : { indexFormat }),
-                  ...(renderState === undefined ? {} : { renderState }),
+                  renderState: { depthWriteEnabled: true, cullMode: 'none' },
                 },
               },
               {
                 kind: 'graphics-bindings',
-                name: graphicsBindings,
-                program: graphicsProgram,
-                values: {
-                  group: 0,
-                  runtime: projectionRuntime,
-                  instances,
-                  ...(sceneDepthBinding === undefined ? {} : { sceneDepthBinding }),
-                },
-                ...(sceneDepthBinding !== undefined && depthTarget !== undefined
-                  ? { logicalTargets: { sceneDepth: depthTarget.name } }
-                  : {}),
+                name: shadowBindings,
+                program: shadowProgram,
+                values: { group: 0, runtime: projectionRuntime, instances },
               },
-              { kind: 'vertex-data', name: vertexData, layout: vertexLayout, buffer: instances },
             );
-            const drawBindings = [graphicsBindings];
-            if (particleMaterialUsesBindings(material)) {
-              const materialBindings = `${rendererPrefix}.material-bindings`;
-              resources.push({
-                kind: 'graphics-bindings',
-                name: materialBindings,
-                program: graphicsProgram,
-                values: {
-                  group: 1,
-                  material: { world: worldIndex, guid: renderer.material },
-                },
-              });
-              drawBindings.push(materialBindings);
-            }
-
-            const vertexBindings: { readonly slot: number; readonly resource: string }[] = [];
-            let indexData:
-              | { readonly resource: string; readonly format: 'uint16' | 'uint32' }
-              | undefined;
-            if (renderer.kind === 'mesh') {
-              if (mesh === undefined) return err(planFailure());
-              const geometryBuffer = `${rendererPrefix}.geometry-buffer`;
-              const geometry = `${rendererPrefix}.geometry`;
-              const geometryData = canonicalMeshVertices(mesh);
-              resources.push(
-                {
-                  kind: 'buffer',
-                  name: geometryBuffer,
-                  size: geometryData.byteLength,
-                  usage: ['vertex'],
-                  data: geometryData,
-                },
+            passes.push({
+              kind: 'shadow-caster',
+              name: `${rendererPrefix}.shadow`,
+              draws: [
                 {
-                  kind: 'vertex-data',
-                  name: geometry,
-                  layout: vertexLayout,
-                  buffer: geometryBuffer,
-                },
-              );
-              vertexBindings.push(
-                { slot: 0, resource: geometry },
-                { slot: 1, resource: vertexData },
-              );
-              if (mesh.indices !== undefined) {
-                const indexBuffer = `${rendererPrefix}.index-buffer`;
-                const indices = `${rendererPrefix}.indices`;
-                resources.push(
-                  {
-                    kind: 'buffer',
-                    name: indexBuffer,
-                    size: mesh.indices.byteLength,
-                    usage: ['index'],
-                    data: mesh.indices,
-                  },
-                  {
-                    kind: 'index-data',
-                    name: indices,
-                    format: indexFormat,
-                    buffer: indexBuffer,
+                  program: shadowProgram,
+                  bindings: [shadowBindings],
+                  vertexData: vertexBindings,
+                  ...(indexData === undefined ? {} : { indexData }),
+                  draw: {
+                    kind: indexData === undefined ? 'draw-indirect' : 'draw-indexed-indirect',
+                    resource: indirect,
+                    offset: rendererIndex * 20,
                   },
-                );
-                indexData = { resource: indices, format: indexFormat };
-              }
-            } else {
-              vertexBindings.push({ slot: 0, resource: vertexData });
-            }
-
+                },
+              ],
+            });
+          }
+          if (latest.visible)
             passes.push({
               kind: 'raster',
               name: `${rendererPrefix}.raster`,
@@ -821,19 +1556,61 @@ export function gpuParticleRenderFeature(
                 },
               ],
             });
-          }
         }
       }
-      for (const entry of frame.worlds) {
-        for (const intent of entry.intents) {
-          if (dispatchedIntents.has(intent)) {
-            entry.runtime.markEventDispatched(intent.player, intent.eventCounters);
+
+      pendingFrames.set(
+        frame.frameNumber,
+        frame.worlds.map((entry) => ({
+          world: entry.world,
+          runtime: entry.runtime,
+          outcomes:
+            outcomesByEntry.get(entry) ??
+            entry.intents.map((intent) => ({ intent, state: 'deferred' as const })),
+        })),
+      );
+      return ok<RenderFeaturePlan>({ resources, passes });
+    },
+    onFrameSubmitted: (frame) => {
+      const pending = pendingFrames.get(frame.frameNumber);
+      if (pending === undefined) return;
+      pendingFrames.delete(frame.frameNumber);
+      for (const entry of pending) {
+        // A deferred provider or target is an ordered barrier for its own
+        // player/emitter stream. Other streams may still have terminal work in
+        // this frame, so acknowledge those exact sequences without dropping
+        // the deferred intents that must retry later.
+        const acknowledgedSequences: number[] = [];
+        const publishedSequences: number[] = [];
+        for (const outcome of entry.outcomes) {
+          if (outcome.state === 'deferred') continue;
+          acknowledgedSequences.push(outcome.intent.sequence);
+          if (outcome.state === 'dispatched') {
+            publishedSequences.push(outcome.intent.sequence);
+            entry.runtime.markEventDispatched(outcome.intent.player, outcome.intent.eventCounters);
+            if (outcome.resetEpoch !== undefined) {
+              const baseKey =
+                `${worldId(entry.world)}:` +
+                `${entry.runtime.renderGeneration ?? 0}:` +
+                `${Number(outcome.intent.player)}:${outcome.intent.emitter.id}`;
+              resetEpochByEmitter.get(entry.runtime)?.set(baseKey, outcome.resetEpoch);
+              resetEpochByIntent.get(entry.runtime)?.delete(outcome.intent.sequence);
+            }
+          } else if (outcome.state === 'skipped' && outcome.resetEpoch !== undefined) {
+            // A skipped reset never touched GPU state.  Drop only its retry
+            // reservation; a future dispatched reset must allocate a new
+            // epoch from the last committed emitter state.
+            resetEpochByIntent.get(entry.runtime)?.delete(outcome.intent.sequence);
           }
         }
-        const lastIntent = entry.intents.at(-1);
-        if (lastIntent !== undefined) entry.runtime.commit(lastIntent.sequence);
+        if (acknowledgedSequences.length > 0) {
+          entry.runtime.commit(acknowledgedSequences, publishedSequences);
+        }
       }
-      return ok<RenderFeaturePlan>({ resources, passes });
+    },
+    onFrameAborted: (frame) => {
+      pendingFrames.delete(frame.frameNumber);
     },
   };
+  return feature;
 }