@forgeax/engine-render 0.1.7 → 0.1.20

package/src/pipeline/standard-pipeline.ts

@@ -6,8 +6,8 @@ import type {
   RenderGraphError,
 } from '@forgeax/engine-render-graph';
 import { err, ok, type Result } from '@forgeax/engine-types';
-import { addTypedDebugOverlayPass } from '../debug-draw-glue';
-import { HdrpDeferredCapsInsufficientError } from '../errors/render';
+import { HdrpDeferredCapsInsufficientError, SceneDataUnavailableError } from '../errors/render';
+import type { FramePlan } from '../extract/environment';
 import {
   GPU_BUFFER_USAGE_COPY_DST,
   GPU_BUFFER_USAGE_STORAGE,
@@ -28,19 +28,29 @@ 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,
   addTypedSsaoPasses,
-  addTypedTonemapPass,
   typedFrameClearColor,
 } from '../typed-render-graph-primitives';
 import { addTypedShadowPasses } from '../typed-shadow-passes';
+import { addAuthoredVolumetricFogPasses } from '../volume/passes';
 
 import { buildStandardForwardLane } from './standard-forward-lane';
+import { addStandardPost } from './standard-post';
 import {
   CLUSTER_GRID_STRIDE_U32,
   DEFAULT_CLUSTER_GRID,
@@ -291,6 +301,35 @@ function buildHdrp(
   if (!gbuffer2.ok) return gbuffer2;
   const scene = target(graph, 'hdrp-scene-color', { format: 'rgba16float', size: 'surface' });
   if (!scene.ok) return scene;
+  const temporalDemand = aggregateTemporalDemand({
+    taa: topology.camera.antialias === 'taa',
+    motionBlur: topology.temporal?.motionBlur === true,
+  });
+  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,
+      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 gbuffer = addTypedScenePass(graph, {
     name: 'g-buffer',
@@ -359,6 +398,27 @@ function buildHdrp(
   const skybox = addTypedSkyboxPass(graph, scene.value);
   if (!skybox.ok) return skybox;
 
+  const transmissionDemand = transmissionDemandForTopology(topology);
+  const transmissionActive = resolveTransmissionBackdropTopology({
+    demand: transmissionDemand,
+    sourceSampleCount: scene.value.sampleCount,
+  }).active;
+  const forwardExtraAccesses: GraphAccess[] = [
+    {
+      resource: buffers.value.lightData,
+      usage: topology.lane.storageBuffer ? 'storage-read' : 'uniform-read',
+    },
+    {
+      resource: buffers.value.clusterGrid,
+      usage: topology.lane.storageBuffer ? 'storage-read' : 'uniform-read',
+    },
+    {
+      resource: buffers.value.lightIndexList,
+      usage: topology.lane.storageBuffer ? 'storage-read' : 'uniform-read',
+    },
+    { resource: buffers.value.clusterUniform, usage: 'uniform-read' },
+  ];
+
   const forward = addTypedScenePass(graph, {
     name: 'forward',
     color: scene.value,
@@ -379,26 +439,106 @@ function buildHdrp(
     spotShadow: shadows.value.spot,
     ...(ssao === undefined ? {} : { ssao }),
     passKind: 'forward',
-    extraAccesses: [
-      {
-        resource: buffers.value.lightData,
-        usage: topology.lane.storageBuffer ? 'storage-read' : 'uniform-read',
-      },
-      {
-        resource: buffers.value.clusterGrid,
-        usage: topology.lane.storageBuffer ? 'storage-read' : 'uniform-read',
-      },
-      {
-        resource: buffers.value.lightIndexList,
-        usage: topology.lane.storageBuffer ? 'storage-read' : 'uniform-read',
-      },
-      { resource: buffers.value.clusterUniform, usage: 'uniform-read' },
-    ],
+    ...(transmissionActive ? { recordMode: 'opaque' as const } : {}),
+    extraAccesses: forwardExtraAccesses,
   });
   if (!forward.ok) return forward;
 
+  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: scene.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,
+      selector: { LightMode: ['Forward'] },
+      colorLoadOp: 'load',
+      depthLoadOp: 'load',
+      sampled: [
+        gbuffer0.value,
+        gbuffer1.value,
+        gbuffer2.value,
+        shadows.value.directional,
+        shadows.value.spot,
+        ...(shadows.value.point === undefined ? [] : [shadows.value.point]),
+        ...(ssao === undefined ? [] : [ssao]),
+      ],
+      directionalShadow: shadows.value.directional,
+      spotShadow: shadows.value.spot,
+      ...(ssao === undefined ? {} : { ssao }),
+      passKind: 'forward',
+      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,
+      extraAccesses: forwardExtraAccesses,
+    });
+    if (!transmissionPass.ok) return transmissionPass;
+
+    const transparentPass = addTypedScenePass(graph, {
+      name: 'transparent',
+      color: scene.value,
+      depth: depth.value,
+      selector: { LightMode: ['Forward'] },
+      colorLoadOp: 'load',
+      depthLoadOp: 'load',
+      sampled: [
+        gbuffer0.value,
+        gbuffer1.value,
+        gbuffer2.value,
+        shadows.value.directional,
+        shadows.value.spot,
+        ...(shadows.value.point === undefined ? [] : [shadows.value.point]),
+        ...(ssao === undefined ? [] : [ssao]),
+      ],
+      directionalShadow: shadows.value.directional,
+      spotShadow: shadows.value.spot,
+      ...(ssao === undefined ? {} : { ssao }),
+      passKind: 'forward',
+      recordMode: 'transparent',
+      extraAccesses: forwardExtraAccesses,
+    });
+    if (!transparentPass.ok) return transparentPass;
+    const temporal = addTransmissionBackdropTemporalPass(graph, scene.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,
+      scene.value,
+      depthSample.value,
+      shadows.value.directional.view,
+      shadows.value.spot.view,
+    );
+    if (!volume.ok) return volume;
+  }
+  // The volume-composite pass remains in linear HDR before tone mapping.
+
   const features = context.contributeFeatures([
     {
+      name: 'linear-hdr',
       kind: 'scene-color',
       texture: scene.value.texture,
       view: scene.value.view,
@@ -417,90 +557,14 @@ function buildHdrp(
   const observation = addTypedFrameObservationPass(graph, scene.value, 'forgeax::standard');
   if (!observation.ok) return observation;
 
-  const hdr = topology.camera.tonemap !== 'none';
-  const fxaa = topology.camera.antialias === 'fxaa';
-  let postInput = scene.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: scene.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 : scene.value;
-  }
-
-  if (hdr && 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 if (hdr) {
-    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: scene.value,
-      output: surface.value.storage,
-    });
-    if (!aa.ok) return aa;
-  } else {
-    const output = addTypedTonemapPass(graph, scene.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,
+    scene.value,
+    depth.value,
+    surface.value,
+    temporal.value?.temporal,
+  );
 }
 const buildStandardClusteredLane = buildHdrp;
 
@@ -508,6 +572,9 @@ export interface StandardPipeline extends RenderPipeline {
   readonly identity: typeof STANDARD_PIPELINE_ID;
 }
 
+/** Standard graph inputs are derived once from the immutable frame plan. */
+export type StandardFramePlan = FramePlan;
+
 function profileFor(topology: RenderPipelineTopology): StandardProfile {
   return topology.standardProfile ?? DEFAULT_STANDARD_PROFILE;
 }
@@ -543,6 +610,10 @@ function buildStandard(
     storageBuffer: topology.lane.storageBuffer,
   });
   const effective = standardTopology(topology, profile);
+  // A missing Camera is an intentional clear-only frame.  Keep it on the
+  // direct raster lane so clustered/HDRP resources cannot introduce work or
+  // a post-process lookup into this minimal submit contract.
+  if (effective.clearOnly === true) return buildStandardForwardLane(context, effective);
   if (lane === 'clustered') return buildStandardClusteredLane(context, effective);
   return buildStandardForwardLane(context, effective);
 }