@forgeax/engine-render 0.1.28 → 0.1.30

package/src/features/prepared-graphics-store.ts

@@ -11,10 +11,17 @@ import type {
   RenderFeaturePreparedRef,
   RenderFeatureVertexDataDescriptor,
 } from './prepared-graphics';
+import { RENDER_FEATURE_VERTEX_LAYOUTS } from './prepared-graphics';
 import type { RenderFeatureTargetHandle } from './targets';
 
 export type PreparedGraphicsKind = Exclude<PreparedKind, 'attachment'>;
 
+const PARTICLE_MATERIAL_INPUT_LAYOUTS: ReadonlySet<string> = new Set([
+  RENDER_FEATURE_VERTEX_LAYOUTS.billboardMaterialInputInstance,
+  RENDER_FEATURE_VERTEX_LAYOUTS.topologySegmentMaterialInputInstance,
+  RENDER_FEATURE_VERTEX_LAYOUTS.meshGeometryMaterialInputInstance,
+]);
+
 export type PreparedGraphicsRequestByKind = {
   pipeline: RenderFeaturePipelineDescriptor;
   bindings: RenderFeatureBindingsDescriptor;
@@ -185,6 +192,9 @@ function normalizeDescriptor(
         kind,
         shader: pipeline.shader,
         vertexLayout: pipeline.vertexLayout,
+        ...(pipeline.particleInputLanes === undefined
+          ? {}
+          : { particleInputLanes: pipeline.particleInputLanes }),
         colorFormats: Object.freeze([...pipeline.colorFormats]),
         ...(pipeline.depthFormat === undefined ? {} : { depthFormat: pipeline.depthFormat }),
         ...(pipeline.sampleCount === undefined ? {} : { sampleCount: pipeline.sampleCount }),
@@ -263,6 +273,27 @@ class PreparedGraphicsTransactionImpl implements PreparedGraphicsTransaction {
     name: string,
     request: PreparedGraphicsRequestByKind[Kind] | PreparedGraphicsSignature,
   ): Result<RenderFeaturePreparedRef<Kind>, RenderError> {
+    if (kind === 'pipeline' && !('signature' in request)) {
+      const pipeline = request as RenderFeaturePipelineDescriptor;
+      const lanes = pipeline.particleInputLanes;
+      const usesParticleMaterialInputs = PARTICLE_MATERIAL_INPUT_LAYOUTS.has(pipeline.vertexLayout);
+      const validLanes =
+        typeof lanes === 'number' && Number.isInteger(lanes) && lanes >= 1 && lanes <= 4;
+      if (
+        (usesParticleMaterialInputs && !validLanes) ||
+        (!usesParticleMaterialInputs && lanes !== undefined)
+      ) {
+        return err(
+          preparationFailure(
+            this.featureIdentity,
+            this.generation,
+            kind,
+            name,
+            'particle-input-lanes-require-material-input-layout-and-1-through-4-lanes',
+          ),
+        );
+      }
+    }
     const normalized = normalizeDescriptor(kind, request);
     if (this.aborted || this.committed || name.length === 0 || normalized.signature.length === 0) {
       return err(

package/src/features/prepared-graphics.ts

@@ -31,8 +31,11 @@ export type { PreparedKind } from './vocabulary';
 export const RENDER_FEATURE_VERTEX_LAYOUTS = Object.freeze({
   positionSizeColorInstance: 'position-size-color-instance',
   billboardMaterialInstance: 'billboard-material-instance',
+  billboardMaterialInputInstance: 'billboard-material-input-instance',
   topologySegmentInstance: 'topology-segment-instance',
+  topologySegmentMaterialInputInstance: 'topology-segment-material-input-instance',
   meshGeometryMaterialInstance: 'mesh-geometry-material-instance',
+  meshGeometryMaterialInputInstance: 'mesh-geometry-material-input-instance',
 } as const);
 
 /**
@@ -51,6 +54,8 @@ export interface RenderFeaturePreparedRef<Kind extends PreparedKind = PreparedKi
 export interface RenderFeaturePipelineDescriptor {
   readonly shader: string;
   readonly vertexLayout: string;
+  /** Number of vec4 lanes in the material-input instance layout (1 through 4). */
+  readonly particleInputLanes?: number;
   readonly colorFormats: readonly TextureFormat[];
   readonly depthFormat?: TextureFormat;
   /** Sample count of the target this pipeline will draw into. */

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

@@ -3,17 +3,23 @@ import type {
   RenderGraphError,
   RenderGraphFrame,
 } from '@forgeax/engine-render-graph';
-import type { Result } from '@forgeax/engine-types';
-import { type RenderError, RenderFeatureDrawRecordingFailedError } from '../errors/render';
+import { err, type Result } from '@forgeax/engine-types';
+import {
+  type RenderError,
+  RenderFeatureDrawRecordingFailedError,
+  RenderFeatureStageFailedError,
+} from '../errors/render';
 import {
   encodeRenderFeatureGpuComputePass,
   type RenderFeatureResolvedGpuComputePass,
 } from './prepared-gpu-work';
+import type { RenderFeatureGraphTargetResolver } from './render-graph-raster';
 import {
   createRenderFeatureGraphBufferState,
   importRenderFeatureGraphBuffer,
   type RenderFeatureGraphBufferState,
 } from './render-graph-resources';
+import type { RenderFeatureTargetHandle } from './targets';
 
 export class RenderFeatureComputeGraphProjection<FrameCtx extends RenderGraphFrame> {
   private readonly resources: RenderFeatureGraphBufferState;
@@ -22,6 +28,7 @@ export class RenderFeatureComputeGraphProjection<FrameCtx extends RenderGraphFra
     private readonly builder: RenderGraphBuilder<FrameCtx>,
     resources?: RenderFeatureGraphBufferState,
     private readonly reportError?: (error: RenderError) => void,
+    private readonly resolveTarget?: RenderFeatureGraphTargetResolver,
   ) {
     this.resources = resources ?? createRenderFeatureGraphBufferState();
   }
@@ -31,8 +38,26 @@ export class RenderFeatureComputeGraphProjection<FrameCtx extends RenderGraphFra
     featureIdentity: string,
     order: number,
     work: RenderFeatureResolvedGpuComputePass,
-  ): Result<void, RenderGraphError> {
+  ): Result<void, RenderGraphError | RenderError> {
     const accesses = [];
+    const targets = new Map<
+      RenderFeatureTargetHandle,
+      NonNullable<ReturnType<RenderFeatureGraphTargetResolver>>
+    >();
+    for (const handle of work.sampledTargets ?? []) {
+      let target = this.resolveTarget?.(handle);
+      if (target === undefined)
+        return err(
+          new RenderFeatureStageFailedError(featureIdentity, order, 'record', 'renderer-recover'),
+        );
+      if (handle.kind === 'scene-depth') {
+        const view = this.builder.view(target.texture, { aspect: 'depth-only' });
+        if (!view.ok) return view;
+        target = { ...target, view: view.value };
+      }
+      targets.set(handle, target);
+      accesses.push({ resource: target.view, usage: 'sampled-read' as const });
+    }
     for (const resource of work.buffers) {
       const imported = importRenderFeatureGraphBuffer(
         this.builder,
@@ -45,11 +70,17 @@ export class RenderFeatureComputeGraphProjection<FrameCtx extends RenderGraphFra
     }
     return this.builder.addComputePass(name, {
       accesses,
-      encode: ({ pass }) => {
+      encode: ({ pass, resources }) => {
         try {
-          encodeRenderFeatureGpuComputePass(pass, work);
+          encodeRenderFeatureGpuComputePass(pass, work, (name) => {
+            const target = targets.get(name);
+            if (target === undefined) throw new Error(`Missing sampled graph target: ${name}`);
+            const view = resources.textureView(target.view);
+            if (!view.ok) throw view.error;
+            return view.value;
+          });
         } catch (failure) {
-          this.reportError?.(
+          const error =
             failure instanceof Error && typeof (failure as Partial<RenderError>).code === 'string'
               ? (failure as RenderError)
               : new RenderFeatureDrawRecordingFailedError(
@@ -60,8 +91,10 @@ export class RenderFeatureComputeGraphProjection<FrameCtx extends RenderGraphFra
                   'backend-recording-failed',
                   failure instanceof Error ? failure.message : String(failure),
                   'renderer-recover',
-                ),
-          );
+                );
+          this.reportError?.(error);
+          // A partially encoded intent is not a submitted transaction.
+          throw error;
         }
       },
     });

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

@@ -1,19 +1,136 @@
 import type {
+  GraphAccess,
+  GraphBufferAccess,
   RenderGraphBuilder,
   RenderGraphError,
   RenderGraphFrame,
 } from '@forgeax/engine-render-graph';
+import type { Buffer } from '@forgeax/engine-rhi';
 import { err, ok, type Result } from '@forgeax/engine-types';
 import { type RenderError, RenderFeatureStageFailedError } from '../errors/render';
-import type { RenderFeaturePlanExecution } from './host';
+import type { RenderFeaturePlanExecution, RenderFeaturePlanExecutionPass } from './host';
 import { RenderFeatureComputeGraphProjection } from './render-graph-compute';
 import {
   type RenderFeatureGraphBindingsResolver,
   type RenderFeatureGraphTargetResolver,
+  type RenderFeatureLightingResolver,
   RenderFeatureRasterGraphProjection,
+  type RenderFeatureShadowDraws,
+  resolveRenderFeatureDrawBuffers,
 } from './render-graph-raster';
 import { createRenderFeatureGraphBufferState } from './render-graph-resources';
 
+export function createRenderFeatureProjectionState() {
+  return {
+    buffers: createRenderFeatureGraphBufferState(),
+    projected: new Set<RenderFeaturePlanExecutionPass>(),
+  };
+}
+
+function writesBuffer(access: GraphBufferAccess): boolean {
+  switch (access) {
+    case 'storage-write':
+    case 'storage-read-write':
+    case 'copy-dst':
+      return true;
+    case 'uniform-read':
+    case 'storage-read':
+    case 'indirect-read':
+    case 'vertex-read':
+    case 'index-read':
+    case 'copy-src':
+      return false;
+  }
+}
+
+export function projectRenderFeatureShadows<FrameCtx extends RenderGraphFrame>(
+  builder: RenderGraphBuilder<FrameCtx>,
+  executions: readonly RenderFeaturePlanExecution[],
+  state: ReturnType<typeof createRenderFeatureProjectionState>,
+): Result<RenderFeatureShadowDraws<FrameCtx> | undefined, RenderGraphError | RenderError> {
+  if (!executions.some((execution) => execution.passes.some((pass) => pass.shadowCaster)))
+    return ok(undefined);
+  const compute = new RenderFeatureComputeGraphProjection(builder, state.buffers);
+  const raster = new RenderFeatureRasterGraphProjection(
+    builder,
+    () => undefined,
+    undefined,
+    state.buffers,
+  );
+  const draws: RenderFeatureShadowDraws<FrameCtx>[] = [];
+  // Hoist only work that can cross earlier deferred work without changing its
+  // buffer observations. Physical identity catches aliases across features too.
+  const deferredAccesses = new Set<Buffer>();
+  const deferredWrites = new Set<Buffer>();
+  for (const execution of executions) {
+    for (const pass of execution.passes) {
+      if (pass.graphics !== undefined && pass.resolvedGraphics !== undefined) {
+        const inputs = resolveRenderFeatureDrawBuffers(
+          execution.featureIdentity,
+          execution.order,
+          pass.graphics,
+          pass.resolvedGraphics,
+        );
+        if (!inputs.ok) return inputs;
+        for (const group of Object.values(inputs.value)) {
+          for (const resource of group.values()) deferredAccesses.add(resource.buffer);
+        }
+      }
+      if (pass.shadowCaster) {
+        if (
+          pass.graphics === undefined ||
+          pass.graphicsState === undefined ||
+          pass.resolvedGraphics === undefined
+        )
+          return err(
+            new RenderFeatureStageFailedError(
+              execution.featureIdentity,
+              execution.order,
+              'plan',
+              'next-frame',
+            ),
+          );
+        const prepared = raster.prepareShadowDraws(
+          pass.name,
+          execution.featureIdentity,
+          execution.order,
+          pass.graphics,
+          pass.graphicsState,
+          pass.resolvedGraphics,
+        );
+        if (!prepared.ok) return prepared;
+        draws.push(prepared.value);
+        state.projected.add(pass);
+        continue;
+      }
+      const work = pass.resolvedGpuCompute;
+      if (work === undefined) continue;
+      const canRunEarly =
+        (work.sampledTargets?.length ?? 0) === 0 &&
+        work.buffers.every(
+          ({ buffer, access }) =>
+            !deferredWrites.has(buffer) && (!writesBuffer(access) || !deferredAccesses.has(buffer)),
+        );
+      if (canRunEarly) {
+        const added = compute.addPass(pass.name, execution.featureIdentity, execution.order, work);
+        if (!added.ok) return added;
+        state.projected.add(pass);
+      } else {
+        for (const { buffer, access } of work.buffers) {
+          deferredAccesses.add(buffer);
+          if (writesBuffer(access)) deferredWrites.add(buffer);
+        }
+      }
+    }
+  }
+  return ok({
+    accesses: draws.flatMap((draw) => [...draw.accesses]),
+    encode: (pass, frame, resources, view) => {
+      for (const draw of draws) draw.encode(pass, frame, resources, view);
+    },
+  });
+}
+
 /** Project the host-owned plan execution directly into the one typed graph. */
 export function projectRenderFeaturePlans<FrameCtx extends RenderGraphFrame>(
   builder: RenderGraphBuilder<FrameCtx>,
@@ -22,19 +139,40 @@ export function projectRenderFeaturePlans<FrameCtx extends RenderGraphFrame>(
     readonly resolveTarget: RenderFeatureGraphTargetResolver;
     readonly resolveBindings?: RenderFeatureGraphBindingsResolver<FrameCtx> | undefined;
     readonly reportError?: ((error: RenderError) => void) | undefined;
+    readonly resolveStandardLighting?: RenderFeatureLightingResolver<FrameCtx> | undefined;
+    readonly standardSurfaceAccesses?: readonly GraphAccess[] | undefined;
+    readonly state?: ReturnType<typeof createRenderFeatureProjectionState>;
   },
 ): Result<void, RenderGraphError | RenderError> {
-  const buffers = createRenderFeatureGraphBufferState();
-  const compute = new RenderFeatureComputeGraphProjection(builder, buffers, options.reportError);
+  const state = options.state ?? createRenderFeatureProjectionState();
+  const buffers = state.buffers;
+  const compute = new RenderFeatureComputeGraphProjection(
+    builder,
+    buffers,
+    options.reportError,
+    options.resolveTarget,
+  );
   const raster = new RenderFeatureRasterGraphProjection(
     builder,
     options.resolveTarget,
     options.resolveBindings,
     buffers,
     options.reportError,
+    options.resolveStandardLighting,
+    options.standardSurfaceAccesses,
   );
   for (const execution of executions) {
     for (const pass of execution.passes) {
+      if (state.projected.has(pass)) continue;
+      if (pass.shadowCaster)
+        return err(
+          new RenderFeatureStageFailedError(
+            execution.featureIdentity,
+            execution.order,
+            'plan',
+            'next-frame',
+          ),
+        );
       if (pass.resolvedGpuCompute !== undefined) {
         const added = compute.addPass(
           pass.name,

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

@@ -1,4 +1,5 @@
 import type {
+  GraphAccess,
   GraphBuffer,
   GraphResourceResolver,
   GraphTexture,
@@ -8,7 +9,7 @@ import type {
   RenderGraphError,
   RenderGraphFrame,
 } from '@forgeax/engine-render-graph';
-import type { BindGroup, RhiRenderPassEncoder } from '@forgeax/engine-rhi';
+import type { BindGroup, RenderPipeline, RhiRenderPassEncoder } from '@forgeax/engine-rhi';
 import { err, ok, type Result } from '@forgeax/engine-types';
 import {
   type RenderError,
@@ -58,6 +59,22 @@ export type RenderFeatureGraphBindingsResolver<FrameCtx extends RenderGraphFrame
   readonly resolveTarget: RenderFeatureGraphTargetResolver;
 }) => RenderFeatureGraphBindingsResolution | undefined;
 
+export type RenderFeatureLightingResolver<FrameCtx extends RenderGraphFrame> = (
+  frame: FrameCtx,
+  pipeline: RenderPipeline,
+) => BindGroup | undefined;
+
+/** Prepared draws embedded by the owning pipeline into its light-view passes. */
+export interface RenderFeatureShadowDraws<FrameCtx extends RenderGraphFrame> {
+  readonly accesses: readonly GraphAccess[];
+  encode(
+    pass: RhiRenderPassEncoder,
+    frame: FrameCtx,
+    resources: GraphResourceResolver,
+    view: BindGroup,
+  ): void;
+}
+
 interface ResolvedDrawBuffers {
   readonly vertex: ReadonlyMap<object, GraphBuffer>;
   readonly index: ReadonlyMap<object, GraphBuffer>;
@@ -75,6 +92,51 @@ function resolved(
   return snapshot.resolve(reference);
 }
 
+/** Physical draw inputs shared by readiness ordering and graph imports. */
+export function resolveRenderFeatureDrawBuffers(
+  featureIdentity: string,
+  order: number,
+  descriptor: RenderFeatureGraphicsPassDescriptor,
+  snapshot: PreparedGraphicsResolvedSnapshot,
+): Result<
+  {
+    vertex: Map<object, RenderFeatureResolvedGpuBuffer>;
+    index: Map<object, RenderFeatureResolvedGpuBuffer>;
+    indirect: Map<object, RenderFeatureResolvedGpuBuffer>;
+  },
+  RenderError
+> {
+  const vertex = new Map<object, RenderFeatureResolvedGpuBuffer>();
+  const index = new Map<object, RenderFeatureResolvedGpuBuffer>();
+  const indirect = new Map<object, RenderFeatureResolvedGpuBuffer>();
+  for (const draw of descriptor.draws) {
+    for (const binding of draw.vertexData) {
+      const resource = resolved(snapshot, binding.resource);
+      if (resource?.kind !== 'vertex-data') return err(missing(featureIdentity, order));
+      vertex.set(binding.resource, {
+        buffer: resource.handle,
+        size: resource.size,
+        physicalUsage: resource.physicalUsage,
+      });
+    }
+    if (draw.indexData !== undefined) {
+      const resource = resolved(snapshot, draw.indexData.resource);
+      if (resource?.kind !== 'index-data') return err(missing(featureIdentity, order));
+      index.set(draw.indexData.resource, {
+        buffer: resource.handle,
+        size: resource.size,
+        physicalUsage: resource.physicalUsage,
+      });
+    }
+    if (draw.kind === 'draw-indirect' || draw.kind === 'draw-indexed-indirect') {
+      const resource = snapshot.resolveGpuBuffer?.(draw.command.buffer);
+      if (resource === undefined) return err(missing(featureIdentity, order));
+      indirect.set(draw.command.buffer, resource);
+    }
+  }
+  return ok({ vertex, index, indirect });
+}
+
 export class RenderFeatureRasterGraphProjection<FrameCtx extends RenderGraphFrame> {
   private readonly buffers: RenderFeatureGraphBufferState;
 
@@ -84,10 +146,55 @@ export class RenderFeatureRasterGraphProjection<FrameCtx extends RenderGraphFram
     private readonly resolveBindings?: RenderFeatureGraphBindingsResolver<FrameCtx>,
     buffers?: RenderFeatureGraphBufferState,
     private readonly reportError?: (error: RenderError) => void,
+    private readonly resolveStandardLighting?: RenderFeatureLightingResolver<FrameCtx>,
+    private readonly standardSurfaceAccesses: readonly GraphAccess[] = [],
   ) {
     this.buffers = buffers ?? createRenderFeatureGraphBufferState();
   }
 
+  prepareShadowDraws(
+    name: string,
+    featureIdentity: string,
+    order: number,
+    descriptor: RenderFeatureGraphicsPassDescriptor,
+    state: RenderFeaturePreparedGraphicsState,
+    snapshot: PreparedGraphicsResolvedSnapshot,
+  ): Result<RenderFeatureShadowDraws<FrameCtx>, RenderGraphError | RenderError> {
+    const validated = validateRenderFeatureGraphicsPass(featureIdentity, descriptor, state);
+    if (!validated.ok) return validated;
+    const imported = this.importDrawBuffers(name, featureIdentity, order, descriptor, snapshot);
+    if (!imported.ok) return imported;
+    const accesses: GraphAccess[] = [
+      ...[...imported.value.vertex.values()].map((resource) => ({
+        resource,
+        usage: 'vertex-read' as const,
+      })),
+      ...[...imported.value.index.values()].map((resource) => ({
+        resource,
+        usage: 'index-read' as const,
+      })),
+      ...[...imported.value.indirect.values()].map((resource) => ({
+        resource,
+        usage: 'indirect-read' as const,
+      })),
+    ];
+    return ok({
+      accesses,
+      encode: (pass, frame, resources, view) =>
+        this.encode(
+          featureIdentity,
+          order,
+          descriptor,
+          snapshot,
+          imported.value,
+          pass,
+          frame,
+          resources,
+          view,
+        ),
+    });
+  }
+
   addPass(
     name: string,
     featureIdentity: string,
@@ -100,11 +207,21 @@ export class RenderFeatureRasterGraphProjection<FrameCtx extends RenderGraphFram
     if (!validated.ok) return validated;
 
     const accesses = [];
+    if (
+      descriptor.draws.some((draw) => {
+        const pipeline = resolved(snapshot, draw.pipeline);
+        return pipeline?.kind === 'pipeline' && pipeline.standardLighting === true;
+      })
+    )
+      accesses.push(...this.standardSurfaceAccesses);
     const colors = [];
     for (const attachment of descriptor.attachments.colors) {
       const target = this.resolveTarget(attachment.resource);
       if (target === undefined) return err(missing(featureIdentity, order));
       accesses.push({ resource: target.view, usage: 'color-attachment' } as const);
+      if (target.resolveTarget !== undefined) {
+        accesses.push({ resource: target.resolveTarget, usage: 'color-attachment' } as const);
+      }
       colors.push({
         view: target.view,
         ...(target.resolveTarget === undefined ? {} : { resolveTarget: target.resolveTarget }),
@@ -175,7 +292,7 @@ export class RenderFeatureRasterGraphProjection<FrameCtx extends RenderGraphFram
             resources,
           );
         } catch (failure) {
-          this.reportError?.(
+          const error =
             failure instanceof Error && typeof (failure as Partial<RenderError>).code === 'string'
               ? (failure as RenderError)
               : new RenderFeatureDrawRecordingFailedError(
@@ -186,8 +303,10 @@ export class RenderFeatureRasterGraphProjection<FrameCtx extends RenderGraphFram
                   'backend-recording-failed',
                   failure instanceof Error ? failure.message : String(failure),
                   'renderer-recover',
-                ),
-          );
+                );
+          this.reportError?.(error);
+          // A partially encoded intent is not a submitted transaction.
+          throw error;
         }
       },
     });
@@ -215,31 +334,15 @@ export class RenderFeatureRasterGraphProjection<FrameCtx extends RenderGraphFram
       return ok(undefined);
     };
 
-    for (const draw of descriptor.draws) {
-      for (const binding of draw.vertexData) {
-        const resource = resolved(snapshot, binding.resource);
-        if (resource?.kind !== 'vertex-data') return err(missing(featureIdentity, order));
-        const added = add(vertex, binding.resource as object, {
-          buffer: resource.handle,
-          size: resource.size,
-          physicalUsage: resource.physicalUsage,
-        });
-        if (!added.ok) return added;
-      }
-      if (draw.indexData !== undefined) {
-        const resource = resolved(snapshot, draw.indexData.resource);
-        if (resource?.kind !== 'index-data') return err(missing(featureIdentity, order));
-        const added = add(index, draw.indexData.resource as object, {
-          buffer: resource.handle,
-          size: resource.size,
-          physicalUsage: resource.physicalUsage,
-        });
-        if (!added.ok) return added;
-      }
-      if (draw.kind === 'draw-indirect' || draw.kind === 'draw-indexed-indirect') {
-        const resource = snapshot.resolveGpuBuffer?.(draw.command.buffer);
-        if (resource === undefined) return err(missing(featureIdentity, order));
-        const added = add(indirect, draw.command.buffer as object, resource);
+    const inputs = resolveRenderFeatureDrawBuffers(featureIdentity, order, descriptor, snapshot);
+    if (!inputs.ok) return inputs;
+    for (const [source, destination] of [
+      [inputs.value.vertex, vertex],
+      [inputs.value.index, index],
+      [inputs.value.indirect, indirect],
+    ] as const) {
+      for (const [key, resource] of source) {
+        const added = add(destination, key, resource);
         if (!added.ok) return added;
       }
     }
@@ -255,14 +358,25 @@ export class RenderFeatureRasterGraphProjection<FrameCtx extends RenderGraphFram
     pass: RhiRenderPassEncoder,
     frame: FrameCtx,
     resources: GraphResourceResolver,
+    shadowView?: BindGroup,
   ): void {
     for (const draw of descriptor.draws) {
       const pipeline = resolved(snapshot, draw.pipeline);
       if (pipeline?.kind !== 'pipeline') throw missing(featureIdentity, order);
       pass.setPipeline(pipeline.handle);
+      if (pipeline.standardLighting === true) {
+        const lighting = this.resolveStandardLighting?.(frame, pipeline.handle);
+        if (lighting === undefined) throw missing(featureIdentity, order);
+        pass.setBindGroup(2, lighting);
+      }
       for (const [group, reference] of draw.bindings.entries()) {
         const binding = resolved(snapshot, reference);
         if (binding?.kind !== 'bindings') throw missing(featureIdentity, order);
+        const targetGroup = binding.descriptor?.values.group ?? group;
+        if (shadowView !== undefined && targetGroup === 0) {
+          pass.setBindGroup(0, shadowView, [0, 0]);
+          continue;
+        }
         const resolvedBindings =
           binding.handle ??
           this.resolveBindings?.({ frame, binding, resources, resolveTarget: this.resolveTarget });
@@ -273,7 +387,6 @@ export class RenderFeatureRasterGraphProjection<FrameCtx extends RenderGraphFram
             ? resolvedBindings.handle
             : resolvedBindings;
         if (handle === undefined) throw missing(featureIdentity, order);
-        const targetGroup = binding.descriptor?.values.group ?? group;
         const dynamicOffsets =
           resolvedBindings !== undefined &&
           typeof resolvedBindings === 'object' &&

package/src/features/types.ts

@@ -110,6 +110,17 @@ export interface RenderFeature<FrameData> {
   }[];
   extract(context: RenderFeatureExtractContext): Result<FrameData, RenderError>;
   plan(data: FrameData, context: RenderFeaturePlanContext): Result<RenderFeaturePlan, RenderError>;
+  /**
+   * Consume frame-owned producer state only after the compiled graph reached
+   * queue submission.  The host invokes this callback at most once for the
+   * extracted frame and never during declarative planning.
+   */
+  onFrameSubmitted?(data: FrameData): void;
+  /**
+   * Discard frame-owned producer state when graph admission or submission is
+   * rejected.  This is the symmetric recovery path for onFrameSubmitted.
+   */
+  onFrameAborted?(data: FrameData): void;
 }
 
 export interface RenderFeatureRecoverInput {

package/src/fullscreen-post-process-pass.ts

@@ -81,6 +81,8 @@ export type PostProcessReadSampleType = 'depth';
 export interface PostProcessShaderEntry {
   /** Composed WGSL source for the fragment stage (post-naga_oil). */
   readonly source: string;
+  /** Fragment entry point selected by the typed graph; defaults to `fs_main`. */
+  readonly fragmentEntryPoint?: string | undefined;
   /**
    * Params UBO schema. When undefined, the generic shader has no uniform buffer
    * and the BGL degrades to 2 entries (texture@0 + sampler@1). When present, the
@@ -134,6 +136,7 @@ export function postProcessShaderModuleLabel(identity: string, source: string):
 export function postProcessShaderEntrySignature(entry: PostProcessShaderEntry): string {
   return JSON.stringify({
     source: entry.source,
+    fragmentEntryPoint: entry.fragmentEntryPoint,
     params:
       entry.params === undefined
         ? undefined