@forgeax/engine-render 0.1.3 → 0.1.6

package/src/{urp-pipeline.ts → pipeline/standard-forward-lane.ts}

@@ -4,28 +4,18 @@ import type {
   RenderGraphError,
 } from '@forgeax/engine-render-graph';
 import { ok, type Result } from '@forgeax/engine-types';
-import { addTypedDebugOverlayPass } from './debug-draw-glue';
-import {
-  addEnvironmentCompositionPass,
-  addEnvironmentProducerPasses,
-  environmentGenerationEnabled,
-} from './environment/graph';
-import {
-  addSceneTemporalRasterPass,
-  createSceneTemporalDepthTarget,
-  createSceneTemporalTarget,
-} from './features/scene-temporal';
+import { addTypedDebugOverlayPass } from '../debug-draw-glue';
 import type {
   RenderPipeline,
   RenderPipelineBuildContext,
   RenderPipelineFrame,
   RenderPipelineTopology,
-} from './render-pipeline';
+} from '../render-pipeline';
 import {
   createRenderPipelineTarget,
   importRenderPipelineSurface,
   type RenderPipelineTarget,
-} from './render-pipeline-target';
+} from '../render-pipeline';
 import {
   addTypedBloomPasses,
   addTypedCompositePostEffects,
@@ -34,10 +24,8 @@ import {
   addTypedScenePass,
   addTypedSkyboxPass,
   addTypedTonemapPass,
-} from './typed-render-graph-primitives';
-import { addTypedShadowPasses } from './typed-shadow-passes';
-
-export const URP_PIPELINE_ID: 'forgeax::urp' = 'forgeax::urp';
+} from '../typed-render-graph-primitives';
+import { addTypedShadowPasses } from '../typed-shadow-passes';
 
 function target(
   graph: RenderGraphBuilder<RenderPipelineFrame>,
@@ -58,8 +46,7 @@ function buildUrp(
   const msaa = topology.camera.antialias === 'msaa' && topology.lane.multisample;
   const hdr = topology.camera.tonemap !== 'none';
   const fxaa = topology.camera.antialias === 'fxaa';
-  const taa = topology.camera.antialias === 'taa';
-  const linearLdr = !hdr && (topology.lane.storageBuffer || taa);
+  const linearLdr = !hdr && topology.lane.storageBuffer;
   const sceneFormat = hdr || linearLdr ? 'rgba16float' : topology.surface.storageFormat;
 
   const depth = target(graph, 'scene-depth', {
@@ -68,6 +55,7 @@ function buildUrp(
     sampleCount: msaa ? 4 : 1,
   });
   if (!depth.ok) return depth;
+
   const sceneResolved =
     hdr || fxaa || linearLdr || msaa
       ? target(graph, 'scene-color', {
@@ -93,83 +81,17 @@ function buildUrp(
       })
     : sceneResolved;
   if (!scene.ok) return scene;
-  const temporal = taa ? createSceneTemporalTarget(graph) : ok(undefined);
-  if (!temporal.ok) return temporal;
-  const temporalDepth = taa ? createSceneTemporalDepthTarget(graph) : ok(undefined);
-  if (!temporalDepth.ok) return temporalDepth;
 
+  const shadows = addTypedShadowPasses(graph, topology);
+  if (!shadows.ok) return shadows;
+
+  const skybox = addTypedSkyboxPass(graph, scene.value);
+  if (!skybox.ok) return skybox;
   const gpuDriven = context.projectGpuDriven({
     format: scene.value.format,
     sampleCount: scene.value.sampleCount,
   });
   if (!gpuDriven.ok) return gpuDriven;
-  // GPU visibility must be declared before the directional shadow raster
-  // passes so the graph establishes compute -> depth ordering for the same
-  // four-view indirect contract. The main scene pass consumes the projection
-  // returned here below; calling the context a second time would otherwise
-  // hide the projection behind its once-per-build guard.
-  const shadows = addTypedShadowPasses(graph, topology, gpuDriven.value?.shadow);
-  if (!shadows.ok) return shadows;
-  if (topology.environment?.dirty === true) {
-    const environmentProducer = addEnvironmentProducerPasses(
-      graph,
-      scene.value,
-      'urp',
-      () => true,
-      context.environment?.targets,
-    );
-    if (!environmentProducer.ok) return environmentProducer;
-  }
-  if (topology.environment?.enabled === true) {
-    const environmentDepthClear = graph.addRasterPass('urp.environment-depth-clear', {
-      accesses: [{ resource: depth.value.view, usage: 'depth-stencil-write' }],
-      colorAttachments: [],
-      depthStencilAttachment: {
-        view: depth.value.view,
-        depthClearValue: 1,
-        depthLoadOp: 'clear',
-        depthStoreOp: 'store',
-        stencilClearValue: 0,
-        stencilLoadOp: 'clear',
-        stencilStoreOp: 'store',
-      },
-      executeIf: environmentGenerationEnabled,
-      encode: () => undefined,
-    });
-    if (!environmentDepthClear.ok) return environmentDepthClear;
-    const environmentBackground = addEnvironmentCompositionPass(
-      graph,
-      scene.value,
-      'urp.environment-background',
-      environmentGenerationEnabled,
-      {
-        clear: true,
-        sampled: context.environment?.sampledSky,
-        depth: depth.value.view,
-        sunDisc: false,
-      },
-    );
-    if (!environmentBackground.ok) return environmentBackground;
-    const sunDisc = addEnvironmentCompositionPass(
-      graph,
-      scene.value,
-      'urp.sun-disc',
-      environmentGenerationEnabled,
-      { sampled: context.environment?.sampledSky, depth: depth.value.view, sunDisc: true },
-    );
-    if (!sunDisc.ok) return sunDisc;
-  }
-  // Analytic environment owns the scene background. The legacy skybox pass
-  // clears the same target before its optional draw, so keeping it in this
-  // lane would erase the generated atmosphere on every frame.
-  if (topology.environment?.enabled !== true) {
-    const skybox = addTypedSkyboxPass(graph, scene.value);
-    if (!skybox.ok) return skybox;
-  }
-  // scene-radiance-fog-opaque-fragment: the existing Forward scene raster
-  // writes linear HDR and each built-in fragment producer applies the shared
-  // forgeax_view::fog module exactly once. This is an in-fragment operation,
-  // not a graph pass, target, resource, or history owner.
   const main = addTypedScenePass(graph, {
     name: 'main',
     color: scene.value,
@@ -188,68 +110,35 @@ function buildUrp(
   });
   if (!main.ok) return main;
 
-  const sceneFeatureTarget = {
-    kind: 'scene-color' as const,
-    texture: scene.value.texture,
-    view: scene.value.view,
-    ...(msaa ? { resolveTarget: sceneResolved.value.view } : {}),
-    format: scene.value.format,
-    sampleCount: scene.value.sampleCount,
-  };
-  const depthFeatureTarget = {
-    kind: 'scene-depth' as const,
-    texture: depth.value.texture,
-    view: depth.value.view,
-    format: depth.value.format,
-    sampleCount: depth.value.sampleCount,
-  };
-  const temporalFeatureTarget =
-    temporal.value === undefined
-      ? undefined
-      : {
-          kind: 'scene-temporal' as const,
-          texture: temporal.value.texture,
-          view: temporal.value.view,
-          format: temporal.value.format,
-          sampleCount: 1 as const,
-        };
-  if (temporal.value !== undefined && temporalDepth.value !== undefined) {
-    const temporalRaster = addSceneTemporalRasterPass(graph, {
-      target: temporal.value,
-      depth: temporalDepth.value,
-      sampled: [
-        shadows.value.directional,
-        shadows.value.spot,
-        ...(shadows.value.point === undefined ? [] : [shadows.value.point]),
-      ],
-      directionalShadow: shadows.value.directional,
-      spotShadow: shadows.value.spot,
-    });
-    if (!temporalRaster.ok) return temporalRaster;
-  }
   const features = context.contributeFeatures([
-    sceneFeatureTarget,
-    depthFeatureTarget,
-    ...(temporalFeatureTarget === undefined ? [] : [temporalFeatureTarget]),
-  ]);
-  if (!features.ok) return features;
-  const temporalResolve = context.resolveTemporal({
-    sceneColor: {
+    {
       kind: 'scene-color',
-      ...sceneResolved.value,
+      texture: scene.value.texture,
+      view: scene.value.view,
+      ...(msaa ? { resolveTarget: sceneResolved.value.view } : {}),
+      format: scene.value.format,
+      sampleCount: scene.value.sampleCount,
     },
-    sceneDepth: depthFeatureTarget,
-    ...(temporalFeatureTarget === undefined ? {} : { sceneTemporal: temporalFeatureTarget }),
-  });
-  if (!temporalResolve.ok) return temporalResolve;
-  const resolvedScene = temporalResolve.value?.resolvedColor ?? sceneResolved.value;
+    {
+      kind: 'scene-depth',
+      texture: depth.value.texture,
+      view: depth.value.view,
+      format: depth.value.format,
+      sampleCount: depth.value.sampleCount,
+    },
+  ]);
+  if (!features.ok) return features;
 
   if (hdr || linearLdr) {
-    const observation = addTypedFrameObservationPass(graph, resolvedScene, URP_PIPELINE_ID);
+    const observation = addTypedFrameObservationPass(
+      graph,
+      sceneResolved.value,
+      'forgeax::standard',
+    );
     if (!observation.ok) return observation;
   }
 
-  let postInput = resolvedScene;
+  let postInput = sceneResolved.value;
   if (hdr) {
     const composited = target(graph, 'bloom-composited', {
       format: 'rgba16float',
@@ -272,14 +161,14 @@ function buildUrp(
     });
     if (!blurV.ok) return blurV;
     const bloom = addTypedBloomPasses(graph, {
-      scene: resolvedScene,
+      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 : resolvedScene;
+    postInput = topology.camera.bloom === 'on' ? composited.value : sceneResolved.value;
   }
 
   if (hdr) {
@@ -309,12 +198,12 @@ function buildUrp(
     const aa = addTypedFullscreenPass(graph, {
       name: 'fxaa',
       shader: 'fxaa',
-      input: resolvedScene,
+      input: sceneResolved.value,
       output: surface.value.storage,
     });
     if (!aa.ok) return aa;
   } else if (linearLdr) {
-    const output = addTypedTonemapPass(graph, resolvedScene, surface.value.storage, true);
+    const output = addTypedTonemapPass(graph, sceneResolved.value, surface.value.storage, true);
     if (!output.ok) return output;
   }
 
@@ -337,4 +226,4 @@ function buildUrp(
   return ok(undefined);
 }
 
-export const urpPipeline: RenderPipeline = { build: buildUrp };
+export const buildStandardForwardLane = buildUrp;