@forgeax/engine-render 0.1.7 → 0.1.20

package/src/pbr-pipeline.ts

@@ -65,7 +65,7 @@ export interface PbrPipelineLayoutBundle {
   readonly viewBgl: BindGroupLayout;
   /**
    * PBR material BindGroupLayout (slot 1) -- derived user-region entries plus
-   * Skylight and lightmap injection.
+   * Skylight and transmission injection.
    */
   readonly materialBgl: BindGroupLayout;
   /** Per-entity mesh BindGroupLayout (slot 2). */
@@ -89,7 +89,7 @@ export interface PbrPipelineLayoutBundle {
 /**
  * The built-in standard-PBR material paramSchema's texture/user-region shape,
  * used as the fallback when the material BGL is built without a registry
- * (the caps-driven `buildPbrPipelineLayouts` seam). Declares the 3 standard
+ * (the caps-driven `buildPbrPipelineLayouts` seam). Declares the 8 Standard
  * user-region textures + a numeric UBO run; `derive()` collapses the numerics
  * into binding 0 and emits sampler/texture pairs at 1..6 — byte-equivalent to
  * the legacy fixed base-7. The shared PBR parameter contract comes from the
@@ -99,13 +99,13 @@ export interface PbrPipelineLayoutBundle {
  * Build the PBR material BGL **user-region** from a paramSchema via the
  * `derive()` SSOT (D-1). The user-region is binding 0 (the run-merged material
  * UBO) followed by one sampler/texture pair per declared texture. Engine
- * injection (IBL + lightmap) is appended AFTER this region by the caller via
+ * injection (IBL + transmission) is appended AFTER this region by the caller via
  * `appendInjection`, with start binding = `userRegion.length` — so a 4-texture
  * custom schema (e.g. parallax + heightTexture) shifts the injection region by
  * one sampler/texture pair automatically.
  *
- * The built-in `default-standard-pbr` paramSchema declares exactly 4 textures,
- * so this derives to binding 0 UBO + 4 pairs = 9 entries. Injection is appended
+ * The built-in `default-standard-pbr` paramSchema declares exactly 8 textures,
+ * so this derives to binding 0 UBO + 8 pairs = 17 entries. Injection is appended
  * after that derived region.
  *
  * One material-UBO convention is layered on top of the pure `derive()` output:
@@ -140,7 +140,7 @@ export function buildPbrMaterialUserRegionEntries(
   // material-UBO contract. derive() emits binding 0 as the first numeric run's
   // merged UBO; an empty schema has no binding-0 UBO and needs no patch.
   const ubo = entries[0];
-  if (ubo !== undefined && ubo.binding === 0 && ubo.buffer !== undefined) {
+  if (ubo !== undefined && ubo.binding === 0 && ubo.buffer?.type === 'uniform') {
     entries[0] = {
       binding: 0,
       visibility: GPU_SHADER_STAGE_VERTEX | GPU_SHADER_STAGE_FRAGMENT,
@@ -178,11 +178,16 @@ export function buildPbrMaterialUserRegionEntries(
 //                keep that meaning under the generic 'lightmap' label
 //                (per-surface secondary-lighting injection) so future
 //                lightmap support lands without renaming the kind.
+//   - 'transmission' the engine-owned sampler + backdrop texture pair. The
+//                record stage supplies a real backdrop only for the active
+//                transmission pass; all other variants bind layout-safe
+//                placeholders because their shaders do not read these slots.
 export type InjectionKind = keyof typeof INJECTION_KIND_LENGTHS;
 
 const IBL_INJECTION_LENGTH = 7;
 const LIGHTMAP_INJECTION_LENGTH = 4;
 const SHADOW_INJECTION_LENGTH = 2;
+const TRANSMISSION_INJECTION_LENGTH = 2;
 
 /**
  * Append the engine-injection BGL entries for the given `kind` after the
@@ -289,6 +294,19 @@ export function appendInjection(
           texture: { sampleType: 'depth', viewDimension: '2d' },
         },
       ];
+    case 'transmission':
+      return [
+        {
+          binding: start,
+          visibility: GPU_SHADER_STAGE_FRAGMENT,
+          sampler: { type: 'filtering' },
+        },
+        {
+          binding: start + 1,
+          visibility: GPU_SHADER_STAGE_FRAGMENT,
+          texture: { sampleType: 'float', viewDimension: '2d' },
+        },
+      ];
   }
 }
 
@@ -297,6 +315,7 @@ export const INJECTION_KIND_LENGTHS = {
   shadow: SHADOW_INJECTION_LENGTH,
   ibl: IBL_INJECTION_LENGTH,
   lightmap: LIGHTMAP_INJECTION_LENGTH,
+  transmission: TRANSMISSION_INJECTION_LENGTH,
 };
 
 /**
@@ -306,6 +325,8 @@ export const INJECTION_KIND_LENGTHS = {
  */
 export interface PbrCaps {
   readonly storageBuffer: boolean;
+  /** Whether the device can carry the optional SpotLight projector texture. */
+  readonly projectorAvailable?: boolean;
 }
 
 /**
@@ -357,7 +378,7 @@ export interface PbrCaps {
  */
 export function buildPbrViewBglEntries(caps: PbrCaps): GPUBindGroupLayoutEntry[] {
   const lightBufType: GPUBufferBindingType = caps.storageBuffer ? 'read-only-storage' : 'uniform';
-  return [
+  const entries: GPUBindGroupLayoutEntry[] = [
     {
       binding: 0,
       visibility: GPU_SHADER_STAGE_VERTEX | GPU_SHADER_STAGE_FRAGMENT,
@@ -450,12 +471,32 @@ export function buildPbrViewBglEntries(caps: PbrCaps): GPUBindGroupLayoutEntry[]
       visibility: GPU_SHADER_STAGE_FRAGMENT,
       texture: { sampleType: 'depth', viewDimension: '2d' },
     },
-    {
-      binding: 10,
-      visibility: GPU_SHADER_STAGE_VERTEX,
-      buffer: { type: 'uniform', hasDynamicOffset: true },
-    },
   ];
+  // The projector is optional, but when present it is a sampled texture in
+  // the fragment stage. Keep it out of the low-limit view layout so the
+  // remaining HDRP PBR ABI stays within WebGPU's minimum 16 sampled textures.
+  // The corresponding PROJECTOR_AVAILABLE shader variant is selected from
+  // the same device capability bit and returns a white modulation.
+  if (caps.projectorAvailable !== false) {
+    entries.push(
+      {
+        binding: 11,
+        visibility: GPU_SHADER_STAGE_FRAGMENT,
+        texture: { sampleType: 'float', viewDimension: '2d' },
+      },
+      {
+        binding: 12,
+        visibility: GPU_SHADER_STAGE_FRAGMENT,
+        sampler: { type: 'filtering' },
+      },
+    );
+  }
+  entries.push({
+    binding: 10,
+    visibility: GPU_SHADER_STAGE_VERTEX,
+    buffer: { type: 'uniform', hasDynamicOffset: true },
+  });
+  return entries;
 }
 
 // ─── PBR pipeline layout factory ────────────────────────────────────────────
@@ -479,17 +520,16 @@ export function buildPbrPipelineLayouts(
   // D-13 round-2: 4 BGLs route through buildBindGroupLayoutDescriptor.
   // The dispatcher reads kind + caps; spec content is unused without a
   // registry (no shader-axis reflection at this seam — the 4 BGLs are
-  // caps-driven literals + the deterministic Skylight + lightmap merge
+  // caps-driven literals + the deterministic Skylight + transmission merge
   // sequence that has no dependency on shader.id).
   const viewBglRes = device.createBindGroupLayout(
     buildBindGroupLayoutDescriptor(BGL_ONLY_SPEC_STUB, { kind: 'pbr-view', caps }),
   );
   if (!viewBglRes.ok) throw viewBglRes.error;
 
-  // Material BGL: derived user region + Skylight + lightmap injection.
-  // feat-20260613 fix-issue-5: drop the buildPbrMaterialEmissiveAoEntries
-  // shim. The lightmap injection start binding is computed from the post-
-  // skylight BGL length (= 14) directly inside appendInjection.
+  // Material BGL: derived user region + Skylight + transmission injection.
+  // The transmission start binding is computed from the post-Skylight BGL
+  // length (= 24 for the built-in Standard schema) by appendInjection.
   const materialBglRes = device.createBindGroupLayout(
     buildBindGroupLayoutDescriptor(BGL_ONLY_SPEC_STUB, { kind: 'pbr-material-merged' }),
   );
@@ -542,6 +582,23 @@ export function buildPbrPipelineLayouts(
  * `LayoutKind = 'pbr-skin'` upstream.
  */
 export const SKIN_MATERIAL_SHADER_ID = 'forgeax::pbr-skin' as const;
+export const SHADOW_CASTER_SHADER_ID = 'forgeax::default-shadow-caster' as const;
+
+export function shadowCasterVariantSet(storageBuffer: boolean, skinned: boolean): string {
+  const skinningDisabled = !skinned;
+  if (storageBuffer && skinningDisabled) return '';
+  return `SKINNING_DISABLED=${String(skinningDisabled)}+STORAGE_BUFFER_AVAILABLE=${String(storageBuffer)}`;
+}
+
+export function isSkinnedShadowCasterVariant(
+  materialShaderId: string | undefined,
+  variantSet: string | undefined,
+): boolean {
+  return (
+    materialShaderId === SHADOW_CASTER_SHADER_ID &&
+    variantSet?.includes('SKINNING_DISABLED=false') === true
+  );
+}
 
 /** Returns true for the engine-shipped standard-PBR material shader family. */
 export function isStandardPbrMaterialShader(shaderId: string | undefined): boolean {
@@ -745,13 +802,14 @@ export const SPRITE_PASS_PER_INSTANCE_REGION_VARIANT_SET = '';
  *
  * Three groups by derivation source:
  * 1. Shader-derived (paramSchema reflection + injection chain):
- *    - `'pbr-material-merged'` — derived user region + Skylight 7 + lightmap 4
+ *    - `'pbr-material-merged'` — derived user region + Skylight 7 + transmission 2
  *    - `'unlit-material'` — 7 entries: base PBR material only (no inject)
  *    - `'hdrp-7-slot'` — 7 entries (binding 0 + 3..8): HDRP cluster + SSAO group(2) BGL
  * 2. Caps-driven literal shapes (no shader):
- *    - `'pbr-view'` — 10 entries: view UBO + lights + 6 shadow bindings
- *      (directional 3/4, point 5/6, cascade 7, spot atlas 8, spot
- *      lightViewProj matrices 9 — feat-20260625)
+ *    - `'pbr-view'` — 12 entries: view UBO + lights + shadow bindings,
+ *      projector texture/sampler (11/12), and the Points/Lines UBO (10)
+ *      (directional 3/4, point 5/6, cascade 7, spot atlas 8; the former
+ *      spot lightViewProj matrices moved into the View UBO)
  *    - `'pbr-mesh-array'` — 1 entry: per-entity mesh SSBO (dynamic-offset)
  *    - `'pbr-instances'` — 1 entry: per-instance SSBO (no dynamic-offset)
  *    - `'pbr-skin-mesh-array'` — 2 entries: meshes + skin palette
@@ -852,7 +910,7 @@ export function createHdrpBindGroupLayoutDescriptor(
  * Shader-derived kinds (`'pbr-material-merged'` / `'unlit-material'` /
  * `'hdrp-7-slot'`) require `options.registry` to look up the shader entry
  * and reflect its `paramSchema` via {@link deriveBglShapeFromShader}; they
- * compose the per-entry injection chain (Skylight + lightmap for material;
+ * compose the per-entry injection chain (Skylight + transmission for material;
  * HDRP variantSet for cluster-forward).
  *
  * Caps-driven kinds (`'pbr-view'` / `'pbr-mesh-array'` / `'pbr-instances'` /
@@ -951,7 +1009,11 @@ export function buildBindGroupLayoutDescriptor(
         entries: [
           {
             binding: 0,
-            visibility: GPU_SHADER_STAGE_VERTEX,
+            // Standard transmission reads the same per-instance transform in
+            // fs_main to convert glTF unit-space thickness into world metres.
+            // Keep one shared instances BGL and widen its visibility instead
+            // of introducing a second transform upload or six new varyings.
+            visibility: GPU_SHADER_STAGE_VERTEX | GPU_SHADER_STAGE_FRAGMENT,
             buffer: { type: meshBufType, hasDynamicOffset: false },
           },
         ],
@@ -980,24 +1042,24 @@ export function buildBindGroupLayoutDescriptor(
     }
     case 'pbr-material-merged': {
       // Material BGL: per-shader user-region (derive(paramSchema).bglEntries)
-      // + IBL injection (7) + lightmap injection (4). The user-region size is
-      // the only variable; injection start = userRegion.length so a 4-texture
-      // custom schema shifts IBL/lightmap by one sampler/texture pair (D-1).
-      // For the built-in 4-texture standard-PBR schema this is 9 + 7 + 4 = 20.
+      // + IBL injection (7) + transmission injection (2). The user-region
+      // size is the only variable; injection start = userRegion.length so a
+      // custom schema shifts IBL/transmission by its sampler/texture pairs.
+      // The built-in 8-texture standard-PBR schema is 17 + 7 + 2 = 26 entries.
       //
       // Schema source priority (D-1): explicit materialParamSchema option >
       // registry lookup of spec.shader.id > built-in standard-PBR fallback.
       const resolvedSchema = resolveMaterialParamSchema(spec, options);
       const userRegion = buildPbrMaterialUserRegionEntries(resolvedSchema);
       const afterIbl = [...userRegion, ...appendInjection(userRegion, 'ibl')];
-      const merged = [...afterIbl, ...appendInjection(afterIbl, 'lightmap')];
+      const merged = [...afterIbl, ...appendInjection(afterIbl, 'transmission')];
       return {
         label: 'pbr-material-skylight-bgl',
         entries: merged,
       };
     }
     case 'unlit-material': {
-      // Unlit material BGL: per-shader user-region only. No IBL/lightmap
+      // Unlit material BGL: per-shader user-region only. No IBL/transmission
       // injection (D-5 round-4: unlit demos do not pay for IBL state).
       const resolvedSchema = resolveMaterialParamSchema(spec, options);
       return {

package/src/pipeline/standard-forward-lane.ts

@@ -3,8 +3,8 @@ import type {
   RenderGraphBuilder,
   RenderGraphError,
 } from '@forgeax/engine-render-graph';
-import { ok, type Result } from '@forgeax/engine-types';
-import { addTypedDebugOverlayPass } from '../debug-draw-glue';
+import { err, ok, type Result } from '@forgeax/engine-types';
+import { SceneDataUnavailableError } from '../errors/render';
 import type {
   RenderPipeline,
   RenderPipelineBuildContext,
@@ -17,15 +17,25 @@ import {
   type RenderPipelineTarget,
 } from '../render-pipeline';
 import {
-  addTypedBloomPasses,
-  addTypedCompositePostEffects,
+  addStandardSceneDataPass,
+  aggregateTemporalDemand,
+  createStandardSceneDataTarget,
+  standardTemporalLaneAdmission,
+} from '../temporal/standard-scene-data';
+import {
+  addTransmissionBackdropPasses,
+  addTransmissionBackdropTemporalPass,
+  resolveTransmissionBackdropTopology,
+  transmissionDemandForTopology,
+} from '../transmission/backdrop';
+import {
   addTypedFrameObservationPass,
-  addTypedFullscreenPass,
   addTypedScenePass,
   addTypedSkyboxPass,
-  addTypedTonemapPass,
 } from '../typed-render-graph-primitives';
 import { addTypedShadowPasses } from '../typed-shadow-passes';
+import { addAuthoredVolumetricFogPasses } from '../volume/passes';
+import { addStandardPost } from './standard-post';
 
 function target(
   graph: RenderGraphBuilder<RenderPipelineFrame>,
@@ -43,11 +53,32 @@ function buildUrp(
   const surface = importRenderPipelineSurface(graph, topology);
   if (!surface.ok) return surface;
 
-  const msaa = topology.camera.antialias === 'msaa' && topology.lane.multisample;
-  const hdr = topology.camera.tonemap !== 'none';
-  const fxaa = topology.camera.antialias === 'fxaa';
-  const linearLdr = !hdr && topology.lane.storageBuffer;
-  const sceneFormat = hdr || linearLdr ? 'rgba16float' : topology.surface.storageFormat;
+  const clearOnly = topology.clearOnly === true;
+  const msaa = !clearOnly && topology.camera.antialias === 'msaa' && topology.lane.multisample;
+  const hdr =
+    !clearOnly && (topology.camera.tonemap !== 'none' || topology.camera.antialias === 'taa');
+  const fxaa = !clearOnly && topology.camera.antialias === 'fxaa';
+  const taa = !clearOnly && topology.camera.antialias === 'taa';
+  const rawOnly = !clearOnly && topology.surface.profile?.kind === 'raw-only';
+  // A direct no-tone/no-FXAA lane writes the final display view directly;
+  // keeping a linear-LDR intermediate would add a redundant fullscreen pass.
+  // FXAA samples the scene before the Output Transform, so its input must
+  // remain float even when tone mapping is disabled. This prevents an
+  // eight-bit quantization before the OETF/display-encoded boundary.
+  // MSAA resolves into a separate linear target before presentation. Treat
+  // that resolved target like linear LDR so the shared Output Transform owns
+  // its write into the surface storage view; without this, the resolve is
+  // never presented and MSAA is indistinguishable from the no-AA path.
+  const linearLdr = !clearOnly && ((!hdr && topology.lane.storageBuffer) || fxaa || msaa);
+  const temporalDemand = aggregateTemporalDemand({
+    taa,
+    motionBlur: !clearOnly && topology.temporal?.motionBlur === true,
+  });
+  const needsTemporalIntermediate = temporalDemand.targetCount === 1;
+  const sceneFormat =
+    hdr || linearLdr || rawOnly || needsTemporalIntermediate
+      ? 'rgba16float'
+      : topology.surface.storageFormat;
 
   const depth = target(graph, 'scene-depth', {
     format: 'depth24plus-stencil8',
@@ -56,24 +87,34 @@ function buildUrp(
   });
   if (!depth.ok) return depth;
 
-  const sceneResolved =
-    hdr || fxaa || linearLdr || msaa
+  const sceneResolved = clearOnly
+    ? ok(surface.value.display ?? surface.value.storage)
+    : hdr || fxaa || linearLdr || msaa || rawOnly || needsTemporalIntermediate
       ? target(graph, 'scene-color', {
           format: sceneFormat,
           size: 'surface',
           sampleCount: 1,
+          domain: 'linear-ldr',
           ...(sceneFormat === topology.surface.storageFormat &&
           topology.surface.storageFormat !== topology.surface.viewFormat
             ? { viewFormats: [topology.surface.viewFormat] }
             : {}),
         })
-      : ok(surface.value.display);
+      : surface.value.display === undefined
+        ? target(graph, 'scene-color', {
+            format: topology.surface.storageFormat,
+            size: 'surface',
+            sampleCount: 1,
+            domain: 'display-encoded',
+          })
+        : ok(surface.value.display);
   if (!sceneResolved.ok) return sceneResolved;
   const scene = msaa
     ? target(graph, 'scene-color-msaa', {
         format: sceneFormat,
         size: 'surface',
         sampleCount: 4,
+        domain: 'linear-ldr',
         ...(sceneFormat === topology.surface.storageFormat &&
         topology.surface.storageFormat !== topology.surface.viewFormat
           ? { viewFormats: [topology.surface.viewFormat] }
@@ -92,6 +133,11 @@ function buildUrp(
     sampleCount: scene.value.sampleCount,
   });
   if (!gpuDriven.ok) return gpuDriven;
+  const transmissionDemand = transmissionDemandForTopology(topology);
+  const transmissionActive = resolveTransmissionBackdropTopology({
+    demand: transmissionDemand,
+    sourceSampleCount: scene.value.sampleCount,
+  }).active;
   const main = addTypedScenePass(graph, {
     name: 'main',
     color: scene.value,
@@ -106,12 +152,121 @@ function buildUrp(
     spotShadow: shadows.value.spot,
     selector: { LightMode: ['Forward'] },
     colorLoadOp: 'load',
+    ...(transmissionActive ? { recordMode: 'opaque' as const } : {}),
     ...(gpuDriven.value === undefined ? {} : { gpuDriven: gpuDriven.value }),
   });
   if (!main.ok) return main;
 
+  const temporalLane = topology.lane.compute
+    ? (topology.standardProfile?.lighting ?? 'direct')
+    : 'cpu-webgl2';
+  const temporalAdmission = standardTemporalLaneAdmission({
+    lane: temporalLane,
+    demand: temporalDemand,
+    capabilities: {
+      compute: topology.lane.compute,
+      storageBuffer: topology.lane.storageBuffer,
+      // Capability probes are the sole authority. A surface/storage format is
+      // not evidence that rgba16float render targets are actually renderable.
+      rgba16floatRenderable: context.capabilities?.rgba16floatRenderable ?? false,
+    },
+  });
+  if (temporalAdmission.status === 'unavailable' && temporalAdmission.reason !== 'no-demand') {
+    return err(
+      new SceneDataUnavailableError({
+        featureIdentity: 'forgeax::standard',
+        schema: 'forgeax::scene-data::temporal-v1',
+        lane: temporalLane,
+        reason: temporalAdmission.reason,
+        missingContributorIds: [],
+        omittedMissingContributorCount: 0,
+        recovery: 'enable-capability',
+      }),
+    );
+  }
+  const temporal =
+    temporalDemand.targetCount === 1 ? createStandardSceneDataTarget(graph) : ok(undefined);
+  if (!temporal.ok) return temporal;
+  if (temporal.value !== undefined) {
+    const producer = addStandardSceneDataPass(graph, temporal.value.temporal, depth.value);
+    if (!producer.ok) return producer;
+  }
+  const transmission = addTransmissionBackdropPasses({
+    graph,
+    source: sceneResolved.value,
+    demand: transmissionDemand,
+    copySize: { width: topology.surface.width, height: topology.surface.height },
+    encodeRoughMip: context.encodeTransmissionMip,
+    includeConsumerPasses: false,
+  });
+  if (!transmission.ok) return transmission;
+  if (transmission.value.topology.active) {
+    const transmissionPass = addTypedScenePass(graph, {
+      name: 'transmission-forward',
+      color: scene.value,
+      depth: depth.value,
+      ...(msaa ? { resolve: sceneResolved.value } : {}),
+      sampled: [
+        shadows.value.directional,
+        shadows.value.spot,
+        ...(shadows.value.point === undefined ? [] : [shadows.value.point]),
+      ],
+      directionalShadow: shadows.value.directional,
+      spotShadow: shadows.value.spot,
+      selector: { LightMode: ['Forward'] },
+      colorLoadOp: 'load',
+      depthLoadOp: 'load',
+      recordMode: 'transmission',
+      // Inject the complete backdrop view so the Standard shader can select
+      // the producer's optional roughness mip level. mipViews[0] is only the
+      // copy destination view and intentionally exposes one level.
+      transmissionBackdrop: transmission.value.backdrop?.view,
+    });
+    if (!transmissionPass.ok) return transmissionPass;
+
+    const transparentPass = addTypedScenePass(graph, {
+      name: 'transparent',
+      color: scene.value,
+      depth: depth.value,
+      ...(msaa ? { resolve: sceneResolved.value } : {}),
+      sampled: [
+        shadows.value.directional,
+        shadows.value.spot,
+        ...(shadows.value.point === undefined ? [] : [shadows.value.point]),
+      ],
+      directionalShadow: shadows.value.directional,
+      spotShadow: shadows.value.spot,
+      selector: { LightMode: ['Forward'] },
+      colorLoadOp: 'load',
+      depthLoadOp: 'load',
+      recordMode: 'transparent',
+    });
+    if (!transparentPass.ok) return transparentPass;
+    const temporal = addTransmissionBackdropTemporalPass(graph, sceneResolved.value);
+    if (!temporal.ok) return temporal;
+  }
+
+  if (topology.volumetricFog?.enabled === true) {
+    const depthSample = graph.view(depth.value.texture, {
+      label: 'scene-depth.sample',
+      dimension: '2d',
+      aspect: 'depth-only',
+    });
+    if (!depthSample.ok) return depthSample;
+    const volume = addAuthoredVolumetricFogPasses(
+      graph,
+      topology,
+      sceneResolved.value,
+      depthSample.value,
+      shadows.value.directional.view,
+      shadows.value.spot.view,
+    );
+    if (!volume.ok) return volume;
+  }
+
   const features = context.contributeFeatures([
     {
+      name: 'linear-hdr',
       kind: 'scene-color',
       texture: scene.value.texture,
       view: scene.value.view,
@@ -129,7 +284,7 @@ function buildUrp(
   ]);
   if (!features.ok) return features;
 
-  if (hdr || linearLdr) {
+  if (hdr || linearLdr || rawOnly) {
     const observation = addTypedFrameObservationPass(
       graph,
       sceneResolved.value,
@@ -138,92 +293,14 @@ function buildUrp(
     if (!observation.ok) return observation;
   }
 
-  let postInput = sceneResolved.value;
-  if (hdr) {
-    const composited = target(graph, 'bloom-composited', {
-      format: 'rgba16float',
-      size: 'surface',
-    });
-    if (!composited.ok) return composited;
-    const bright = target(graph, 'bloom-bright', {
-      format: 'rgba16float',
-      size: 'half-surface',
-    });
-    if (!bright.ok) return bright;
-    const blurH = target(graph, 'bloom-blur-h', {
-      format: 'rgba16float',
-      size: 'half-surface',
-    });
-    if (!blurH.ok) return blurH;
-    const blurV = target(graph, 'bloom-blur-v', {
-      format: 'rgba16float',
-      size: 'half-surface',
-    });
-    if (!blurV.ok) return blurV;
-    const bloom = addTypedBloomPasses(graph, {
-      scene: sceneResolved.value,
-      composited: composited.value,
-      bright: bright.value,
-      blurH: blurH.value,
-      blurV: blurV.value,
-    });
-    if (!bloom.ok) return bloom;
-    postInput = topology.camera.bloom === 'on' ? composited.value : sceneResolved.value;
-  }
-
-  if (hdr) {
-    if (fxaa) {
-      const ldr = target(graph, 'ldr-color', {
-        format: topology.surface.storageFormat,
-        size: 'surface',
-        ...(topology.surface.storageFormat === topology.surface.viewFormat
-          ? {}
-          : { viewFormats: [topology.surface.viewFormat] }),
-      });
-      if (!ldr.ok) return ldr;
-      const tonemap = addTypedTonemapPass(graph, postInput, ldr.value);
-      if (!tonemap.ok) return tonemap;
-      const aa = addTypedFullscreenPass(graph, {
-        name: 'fxaa',
-        shader: 'fxaa',
-        input: ldr.value,
-        output: surface.value.storage,
-      });
-      if (!aa.ok) return aa;
-    } else {
-      const tonemap = addTypedTonemapPass(graph, postInput, surface.value.display);
-      if (!tonemap.ok) return tonemap;
-    }
-  } else if (fxaa) {
-    const aa = addTypedFullscreenPass(graph, {
-      name: 'fxaa',
-      shader: 'fxaa',
-      input: sceneResolved.value,
-      output: surface.value.storage,
-    });
-    if (!aa.ok) return aa;
-  } else if (linearLdr) {
-    const output = addTypedTonemapPass(graph, sceneResolved.value, surface.value.storage, true);
-    if (!output.ok) return output;
-  }
-
-  const postEffects = topology.config?.postEffects ?? [];
-  if (topology.lane.storageBuffer && postEffects.length > 0) {
-    const effects = addTypedCompositePostEffects(
-      graph,
-      postEffects,
-      surface.value.display,
-      surface.value.storage,
-      depth.value,
-      topology.surface,
-    );
-    if (!effects.ok) return effects;
-  }
-
-  const debug = addTypedDebugOverlayPass(graph, surface.value.display);
-  if (!debug.ok) return debug;
-
-  return ok(undefined);
+  return addStandardPost(
+    context,
+    topology,
+    sceneResolved.value,
+    depth.value,
+    surface.value,
+    temporal.value?.temporal,
+  );
 }
 
 export const buildStandardForwardLane = buildUrp;