@forgeax/engine-render 0.1.20 → 0.1.21

package/src/pipeline/standard-pipeline.ts

@@ -1,21 +1,13 @@
-import type {
-  GraphAccess,
-  GraphBuffer,
-  GraphTextureDescriptor,
-  RenderGraphBuilder,
+import {
+  type GraphAccess,
+  type GraphTextureDescriptor,
+  type RenderGraphBuilder,
   RenderGraphError,
 } from '@forgeax/engine-render-graph';
 import { err, ok, type Result } from '@forgeax/engine-types';
-import { HdrpDeferredCapsInsufficientError, SceneDataUnavailableError } from '../errors/render';
+import { SceneDataUnavailableError, StandardProfileInvalidError } from '../errors/render';
 import type { FramePlan } from '../extract/environment';
-import {
-  GPU_BUFFER_USAGE_COPY_DST,
-  GPU_BUFFER_USAGE_STORAGE,
-  GPU_BUFFER_USAGE_UNIFORM,
-} from '../gpu-usage';
-import { getOrCreateHdrpBuffers, type HdrpBuffers } from '../hdrp-buffers';
 import { DEFERRED_COLOR_FORMATS } from '../pipeline-spec';
-import type { _InternalRenderPipelineContext } from '../record/render-context';
 import type {
   RenderPipeline,
   RenderPipelineBuildContext,
@@ -48,16 +40,20 @@ import {
 } from '../typed-render-graph-primitives';
 import { addTypedShadowPasses } from '../typed-shadow-passes';
 import { addAuthoredVolumetricFogPasses } from '../volume/passes';
-
 import { buildStandardForwardLane } from './standard-forward-lane';
+import {
+  addStandardClusterMembershipPass,
+  importStandardClusterBuffers,
+  standardClusterReadAccesses,
+} from './standard-lighting/graph';
+import {
+  deriveStandardTopologyInput,
+  type StandardTopologyInputValue,
+} from './standard-lighting/topology';
 import { addStandardPost } from './standard-post';
 import {
-  CLUSTER_GRID_STRIDE_U32,
-  DEFAULT_CLUSTER_GRID,
   DEFAULT_STANDARD_PROFILE,
-  LIGHT_INDEX_LIST_CAPACITY,
-  MAX_LIGHTS,
-  resolveStandardLane,
+  STANDARD_LIGHT_COUNTS,
   STANDARD_PIPELINE_ID,
   type StandardProfile,
 } from './standard-profile';
@@ -125,26 +121,11 @@ fn cs_cluster_membership(@builtin(global_invocation_id) global_id : vec3<u32>) {
   }
 }
 `;
-export class HdrpInstallError extends Error {
-  readonly code = 'hdrp-grid-invalid' as const;
-  readonly expected = 'clusterGrid.{x,y,z} each integer in [1, 64]';
-  readonly hint: string;
-  readonly detail: { readonly x: number; readonly y: number; readonly z: number };
-
-  constructor(x: number, y: number, z: number) {
-    const hint = `clusterGrid {x:${x}, y:${y}, z:${z}} is invalid; set {x,y,z} to positive integers in [1, 64]`;
-    super(`hdrp-grid-invalid: ${hint}`);
-    this.name = 'HdrpInstallError';
-    this.hint = hint;
-    this.detail = { x, y, z };
-  }
-}
-
 export function validateClusterGrid(grid: {
   x: number;
   y: number;
   z: number;
-}): Result<{ x: number; y: number; z: number }, HdrpInstallError> {
+}): Result<{ x: number; y: number; z: number }, StandardProfileInvalidError> {
   const { x, y, z } = grid;
   return Number.isInteger(x) &&
     Number.isInteger(y) &&
@@ -156,7 +137,12 @@ export function validateClusterGrid(grid: {
     z >= 1 &&
     z <= 64
     ? ok({ x, y, z })
-    : err(new HdrpInstallError(x, y, z));
+    : err(
+        new StandardProfileInvalidError(
+          `clusterGrid {x:${x}, y:${y}, z:${z}} is invalid; set x, y, and z to positive integers in [1, 64]`,
+          { field: 'clusterGrid', actual: { x, y, z } },
+        ),
+      );
 }
 
 function target(
@@ -167,114 +153,20 @@ function target(
   return createRenderPipelineTarget(graph, label, descriptor);
 }
 
-interface HdrpGraphBuffers {
-  readonly lightData: GraphBuffer;
-  readonly clusterGrid: GraphBuffer;
-  readonly lightIndexList: GraphBuffer;
-  readonly clusterUniform: GraphBuffer;
-  readonly lightBounds: GraphBuffer;
-}
-
-function importBuffers(
-  graph: RenderGraphBuilder<RenderPipelineFrame>,
-  topology: RenderPipelineTopology,
-): Result<HdrpGraphBuffers, RenderGraphError> {
-  const grid = topology.config?.clusterGrid ?? DEFAULT_CLUSTER_GRID;
-  const cells = grid.x * grid.y * grid.z;
-  const storage = topology.lane.storageBuffer;
-  const usage =
-    (storage ? GPU_BUFFER_USAGE_STORAGE : GPU_BUFFER_USAGE_UNIFORM) | GPU_BUFFER_USAGE_COPY_DST;
-  const resolve = (frame: RenderPipelineFrame): HdrpBuffers => {
-    const internal = frame as _InternalRenderPipelineContext;
-    const buffers = getOrCreateHdrpBuffers(internal.runtime, grid);
-    if (buffers === null) throw new Error('HDRP persistent buffer allocation failed');
-    return buffers;
-  };
-  const lightData = graph.importBuffer(
-    'hdrp-light-data',
-    { size: (storage ? MAX_LIGHTS : 128) * 64, usage },
-    (frame) => resolve(frame).lightDataBuffer,
-  );
-  if (!lightData.ok) return lightData;
-  const clusterGrid = graph.importBuffer(
-    'hdrp-cluster-grid',
-    { size: storage ? cells * CLUSTER_GRID_STRIDE_U32 * 4 : 32, usage },
-    (frame) => resolve(frame).clusterGridBuffer,
-  );
-  if (!clusterGrid.ok) return clusterGrid;
-  const lightIndexList = graph.importBuffer(
-    'hdrp-light-index-list',
-    { size: storage ? LIGHT_INDEX_LIST_CAPACITY * 4 : 32, usage },
-    (frame) => resolve(frame).lightIndexListBuffer,
-  );
-  if (!lightIndexList.ok) return lightIndexList;
-  const clusterUniform = graph.importBuffer(
-    'hdrp-cluster-uniform',
-    { size: 32, usage: GPU_BUFFER_USAGE_UNIFORM | GPU_BUFFER_USAGE_COPY_DST },
-    (frame) => resolve(frame).clusterUniformBuffer,
-  );
-  if (!clusterUniform.ok) return clusterUniform;
-  const lightBounds = graph.importBuffer(
-    'hdrp-light-bounds',
-    { size: MAX_LIGHTS * 6 * 4, usage },
-    (frame) => resolve(frame).lightBoundsBuffer,
-  );
-  if (!lightBounds.ok) return lightBounds;
-  return ok({
-    lightData: lightData.value,
-    clusterGrid: clusterGrid.value,
-    lightIndexList: lightIndexList.value,
-    clusterUniform: clusterUniform.value,
-    lightBounds: lightBounds.value,
-  });
-}
-
-function addMembershipPass(
-  graph: RenderGraphBuilder<RenderPipelineFrame>,
-  topology: RenderPipelineTopology,
-  buffers: HdrpGraphBuffers,
-): Result<void, RenderGraphError> {
-  if (!topology.lane.compute || !topology.lane.storageBuffer) return ok(undefined);
-  return graph.addComputePass('cluster-membership-producer', {
-    accesses: [
-      { resource: buffers.clusterGrid, usage: 'storage-read' },
-      { resource: buffers.clusterUniform, usage: 'uniform-read' },
-      { resource: buffers.lightBounds, usage: 'storage-read' },
-      { resource: buffers.lightIndexList, usage: 'storage-write' },
-    ],
-    executeIf: (frame) => {
-      const internal = frame as _InternalRenderPipelineContext;
-      return (
-        internal.pipelineState.hdrpClusterMembershipPipeline !== null &&
-        internal.hdrpClusterMembershipBindGroup !== null
-      );
-    },
-    encode: ({ pass, frame }) => {
-      const internal = frame as _InternalRenderPipelineContext;
-      const pipeline = internal.pipelineState.hdrpClusterMembershipPipeline;
-      const bindings = internal.hdrpClusterMembershipBindGroup;
-      if (pipeline === null || bindings === null) return;
-      const grid = topology.config?.clusterGrid ?? DEFAULT_CLUSTER_GRID;
-      pass.setPipeline(pipeline);
-      pass.setBindGroup(0, bindings);
-      pass.dispatchWorkgroups(Math.ceil((grid.x * grid.y * grid.z) / 64));
-    },
-  });
-}
-
-function buildHdrp(
+function buildStandardDeferredLane(
   context: RenderPipelineBuildContext<RenderPipelineFrame>,
   topology: RenderPipelineTopology,
+  lighting: StandardTopologyInputValue,
 ): ReturnType<RenderPipeline['build']> {
-  if (topology.lane.maxColorAttachments < 4) {
-    return err(new HdrpDeferredCapsInsufficientError(topology.lane.maxColorAttachments));
-  }
   const graph = context.graph;
   const surface = importRenderPipelineSurface(graph, topology);
   if (!surface.ok) return surface;
-  const buffers = importBuffers(graph, topology);
+  const buffers = importStandardClusterBuffers(graph, lighting);
   if (!buffers.ok) return buffers;
-  const membership = addMembershipPass(graph, topology, buffers.value);
+  const membership =
+    buffers.value === null
+      ? ok(undefined)
+      : addStandardClusterMembershipPass(graph, lighting, buffers.value);
   if (!membership.ok) return membership;
   const shadows = addTypedShadowPasses(graph, topology);
   if (!shadows.ok) return shadows;
@@ -305,9 +197,7 @@ function buildHdrp(
     taa: topology.camera.antialias === 'taa',
     motionBlur: topology.temporal?.motionBlur === true,
   });
-  const temporalLane = topology.lane.compute
-    ? (topology.standardProfile?.lighting ?? 'direct')
-    : 'cpu-webgl2';
+  const temporalLane = topology.lane.compute ? 'clustered' : 'cpu-webgl2';
   const temporalAdmission = standardTemporalLaneAdmission({
     lane: temporalLane,
     demand: temporalDemand,
@@ -330,7 +220,11 @@ function buildHdrp(
       }),
     );
   }
-
+  const gpuDriven = context.projectGpuDriven({
+    format: scene.value.format,
+    sampleCount: scene.value.sampleCount,
+  });
+  if (!gpuDriven.ok) return gpuDriven;
   const gbuffer = addTypedScenePass(graph, {
     name: 'g-buffer',
     color: gbuffer0.value,
@@ -363,25 +257,13 @@ function buildHdrp(
     { resource: gbuffer1.value.view, usage: 'sampled-read' },
     { resource: gbuffer2.value.view, usage: 'sampled-read' },
     { resource: depth.value.view, usage: 'depth-stencil-read' },
-    {
-      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' },
+    ...(buffers.value === null ? [] : standardClusterReadAccesses(buffers.value)),
     ...(ssao === undefined
       ? []
       : ([{ resource: ssao.view, usage: 'sampled-read' }] satisfies GraphAccess[])),
     { resource: scene.value.view, usage: 'color-attachment' },
   ];
-  const lighting = graph.addRasterPass('lighting', {
+  const lightingPass = graph.addRasterPass('lighting', {
     accesses: lightingAccesses,
     colorAttachments: [
       {
@@ -393,7 +275,7 @@ function buildHdrp(
     ],
     encode: () => undefined,
   });
-  if (!lighting.ok) return lighting;
+  if (!lightingPass.ok) return lightingPass;
 
   const skybox = addTypedSkyboxPass(graph, scene.value);
   if (!skybox.ok) return skybox;
@@ -403,21 +285,8 @@ function buildHdrp(
     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 forwardExtraAccesses: GraphAccess[] =
+    buffers.value === null ? [] : [...standardClusterReadAccesses(buffers.value)];
 
   const forward = addTypedScenePass(graph, {
     name: 'forward',
@@ -430,14 +299,17 @@ function buildHdrp(
       gbuffer0.value,
       gbuffer1.value,
       gbuffer2.value,
-      shadows.value.directional,
+      ...(shadows.value.directional === undefined ? [] : [shadows.value.directional]),
       shadows.value.spot,
       ...(shadows.value.point === undefined ? [] : [shadows.value.point]),
       ...(ssao === undefined ? [] : [ssao]),
     ],
-    directionalShadow: shadows.value.directional,
+    ...(shadows.value.directional === undefined
+      ? {}
+      : { directionalShadow: shadows.value.directional }),
     spotShadow: shadows.value.spot,
     ...(ssao === undefined ? {} : { ssao }),
+    ...(gpuDriven.value === undefined ? {} : { gpuDriven: gpuDriven.value }),
     passKind: 'forward',
     ...(transmissionActive ? { recordMode: 'opaque' as const } : {}),
     extraAccesses: forwardExtraAccesses,
@@ -472,7 +344,7 @@ function buildHdrp(
         gbuffer0.value,
         gbuffer1.value,
         gbuffer2.value,
-        shadows.value.directional,
+        ...(shadows.value.directional === undefined ? [] : [shadows.value.directional]),
         shadows.value.spot,
         ...(shadows.value.point === undefined ? [] : [shadows.value.point]),
         ...(ssao === undefined ? [] : [ssao]),
@@ -501,7 +373,7 @@ function buildHdrp(
         gbuffer0.value,
         gbuffer1.value,
         gbuffer2.value,
-        shadows.value.directional,
+        ...(shadows.value.directional === undefined ? [] : [shadows.value.directional]),
         shadows.value.spot,
         ...(shadows.value.point === undefined ? [] : [shadows.value.point]),
         ...(ssao === undefined ? [] : [ssao]),
@@ -529,7 +401,7 @@ function buildHdrp(
       topology,
       scene.value,
       depthSample.value,
-      shadows.value.directional.view,
+      shadows.value.directional?.view,
       shadows.value.spot.view,
     );
     if (!volume.ok) return volume;
@@ -556,8 +428,7 @@ function buildHdrp(
   if (!features.ok) return features;
   const observation = addTypedFrameObservationPass(graph, scene.value, 'forgeax::standard');
   if (!observation.ok) return observation;
-
-  return addStandardPost(
+  const post = addStandardPost(
     context,
     topology,
     scene.value,
@@ -565,13 +436,19 @@ function buildHdrp(
     surface.value,
     temporal.value?.temporal,
   );
+  if (!post.ok) return post;
+  const cubeCaptures = context.contributeCubeCaptures?.();
+  if (cubeCaptures !== undefined && !cubeCaptures.ok) return cubeCaptures;
+  return ok(undefined);
 }
-const buildStandardClusteredLane = buildHdrp;
-
 export interface StandardPipeline extends RenderPipeline {
   readonly identity: typeof STANDARD_PIPELINE_ID;
 }
 
+export function standardProfileSupportsReflectionProbes(_profile: StandardProfile): boolean {
+  return true;
+}
+
 /** Standard graph inputs are derived once from the immutable frame plan. */
 export type StandardFramePlan = FramePlan;
 
@@ -579,6 +456,43 @@ function profileFor(topology: RenderPipelineTopology): StandardProfile {
   return topology.standardProfile ?? DEFAULT_STANDARD_PROFILE;
 }
 
+function resolveStandardTopologyInput(
+  context: RenderPipelineBuildContext<RenderPipelineFrame>,
+): Result<StandardTopologyInputValue, RenderGraphError> {
+  const supplied = context.standardLighting;
+  if (supplied !== undefined) {
+    const derived = deriveStandardTopologyInput(supplied);
+    if (derived.ok) return derived;
+    return err(
+      new RenderGraphError({
+        code: 'resource-descriptor-invalid',
+        expected: 'Forward/Deferred consume one prepared Standard topology input',
+        hint: derived.error.hint,
+        detail: {
+          resourceLabel: 'forgeax::standard',
+          field: `standardLighting.${derived.error.detail.field}`,
+          expected: derived.error.expected,
+          actual: 'invalid',
+        },
+      }),
+    );
+  }
+
+  return err(
+    new RenderGraphError({
+      code: 'resource-descriptor-invalid',
+      expected: 'RenderPipelineBuildContext.standardLighting from frame preparation',
+      hint: 'prepare Standard lighting once, select a proven Cluster transport, and pass it to both lanes',
+      detail: {
+        resourceLabel: 'forgeax::standard',
+        field: 'standardLighting',
+        expected: 'prepared Standard lighting topology input',
+        actual: 'invalid',
+      },
+    }),
+  );
+}
+
 function standardTopology(
   topology: RenderPipelineTopology,
   profile: StandardProfile,
@@ -596,26 +510,41 @@ function standardTopology(
 }
 
 /**
- * The sole built-in pipeline entry point. Direct and clustered lighting are
- * execution lanes selected from the same profile and graph owner; callers do
- * not install a second topology or submit authority.
+ * The sole built-in pipeline entry point. All local lights use the same
+ * prepared Cluster topology; the profile chooses only Forward or Deferred
+ * graph shape and never a second lighting authority.
  */
 function buildStandard(
   context: RenderPipelineBuildContext<RenderPipelineFrame>,
   topology: RenderPipelineTopology,
 ): ReturnType<RenderPipeline['build']> {
   const profile = profileFor(topology);
-  const lane = resolveStandardLane(profile, {
-    compute: topology.lane.compute,
-    storageBuffer: topology.lane.storageBuffer,
-  });
+  if (!STANDARD_LIGHT_COUNTS.some((count) => count === profile.lightCount)) {
+    return err(
+      new RenderGraphError({
+        code: 'resource-descriptor-invalid',
+        expected: 'StandardProfile.lightCount is one of 1, 32, or 256',
+        hint: 'set StandardProfile.lightCount to 1, 32, or 256',
+        detail: {
+          resourceLabel: 'forgeax::standard',
+          field: 'lightCount',
+          expected: '1 | 32 | 256',
+          actual: profile.lightCount,
+        },
+      }),
+    );
+  }
   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);
+  const lighting = resolveStandardTopologyInput(context);
+  if (!lighting.ok) return lighting;
+  // A missing Camera is an intentional clear-only frame. Keep it on the
+  // forward raster lane so clustered resources cannot introduce work.
+  if (effective.clearOnly === true) {
+    return buildStandardForwardLane(context, effective, lighting.value);
+  }
+  return profile.renderPath === 'forward'
+    ? buildStandardForwardLane(context, effective, lighting.value)
+    : buildStandardDeferredLane(context, effective, lighting.value);
 }
 
 export const standardPipeline: StandardPipeline = Object.freeze({

package/src/pipeline/standard-post.ts

@@ -11,7 +11,11 @@ import type {
   RenderPipelineFrame,
   RenderPipelineTopology,
 } from '../render-pipeline';
-import { createRenderPipelineTarget, type RenderPipelineTarget } from '../render-pipeline';
+import {
+  createRenderPipelineTarget,
+  type RenderPipelineTarget,
+  resolveOutputDither,
+} from '../render-pipeline';
 import {
   addTypedBloomPasses,
   addTypedCompositePostEffects,
@@ -134,7 +138,7 @@ function missingTemporalContributor(
   return new SceneDataUnavailableError({
     featureIdentity: 'forgeax::standard',
     schema: 'forgeax::scene-data::temporal-v1',
-    lane: topology.lane.compute ? (topology.standardProfile?.lighting ?? 'direct') : 'cpu-webgl2',
+    lane: topology.lane.compute ? 'clustered' : 'cpu-webgl2',
     reason: 'producer-missing',
     missingContributorIds: [contributorId],
     omittedMissingContributorCount: 0,
@@ -165,9 +169,13 @@ export function addStandardPost(
   // left clear and the following Output Transform presents a black frame.
   const bloomActive = hdr && topology.camera.bloom === 'on' && topology.camera.tonemap !== 'none';
   const fxaa = !clearOnly && topology.camera.antialias === 'fxaa';
-  const msaa = !clearOnly && topology.camera.antialias === 'msaa' && topology.lane.multisample;
-  const linearLdr = !clearOnly && ((!hdr && topology.lane.storageBuffer) || fxaa || msaa);
+  // All non-clear Standard frames use the graph-owned float scene target and
+  // the shared Output Transform, even when AA is disabled or the backend has
+  // no storage buffers.  This keeps the final dither at one owner-level
+  // surface boundary instead of making no-AA/WebGL2 a silent bypass.
+  const linearLdr = !clearOnly && !hdr;
   const rawOnly = !clearOnly && topology.surface.profile?.kind === 'raw-only';
+  const outputDither = resolveOutputDither(topology.config);
   const motionBlur = !clearOnly && topology.temporal?.motionBlur === true;
   const postEffects = clearOnly ? [] : (topology.config?.postEffects ?? []);
   const rawOnlyPostInput =
@@ -312,7 +320,11 @@ export function addStandardPost(
         domain: 'display-encoded',
       });
       if (!output.ok) return output;
-      const outputTransform = addTypedOutputTransformPass(context.graph, postInput, output.value);
+      // FXAA samples this display-encoded intermediate; leave dither to the
+      // final FXAA writer so the same pixel is not dithered twice.
+      const outputTransform = addTypedOutputTransformPass(context.graph, postInput, output.value, {
+        dither: false,
+      });
       if (!outputTransform.ok) return outputTransform;
       const aa = addTypedFullscreenPass(context.graph, {
         name: 'fxaa',
@@ -326,13 +338,20 @@ export function addStandardPost(
         context.graph,
         postInput,
         rawOnlyPostInput.value,
+        {
+          dither: outputDither && postEffects.length === 0,
+        },
       );
       if (!transformed.ok) return transformed;
     } else if (rawOnly || linearLdr) {
-      const transformed = addTypedOutputTransformPass(context.graph, postInput, finalPresent);
+      const transformed = addTypedOutputTransformPass(context.graph, postInput, finalPresent, {
+        dither: outputDither,
+      });
       if (!transformed.ok) return transformed;
     } else {
-      const outputTransform = addTypedOutputTransformPass(context.graph, postInput, finalPresent);
+      const outputTransform = addTypedOutputTransformPass(context.graph, postInput, finalPresent, {
+        dither: outputDither,
+      });
       if (!outputTransform.ok) return outputTransform;
     }
   }

package/src/pipeline/standard-profile.ts

@@ -1,25 +1,22 @@
 export const STANDARD_PIPELINE_ID = 'forgeax::standard' as const;
 export const STANDARD_LIGHT_COUNTS = [1, 32, 256] as const;
-/** Shared clustered-lighting facts consumed by pipeline, record, and buffers. */
-export const DEFAULT_CLUSTER_GRID = { x: 16, y: 9, z: 24 } as const;
-export const CLUSTER_GRID_STRIDE_U32 = 2;
-export const LIGHT_INDEX_LIST_CAPACITY = 1048576;
-export const MAX_LIGHTS = 256;
+export {
+  CLUSTER_GRID_STRIDE_U32,
+  DEFAULT_CLUSTER_GRID,
+  LIGHT_INDEX_LIST_CAPACITY,
+  MAX_LIGHTS,
+} from './standard-lighting/layout';
 
 export type StandardLightCount = (typeof STANDARD_LIGHT_COUNTS)[number];
-export type StandardLightingLane = 'direct' | 'clustered';
-export type StandardFallbackLane = 'native' | 'cpu-webgl2';
 export type StandardShadowMode = 'off' | 'hard' | 'filtered';
-export type StandardTone =
-  | 'none'
-  | 'aces-filmic'
-  | 'agx'
-  | 'cineon'
-  | 'linear'
-  | 'neutral'
-  | 'reinhard'
-  | 'reinhard-extended';
-export type StandardAntialias = 'none' | 'fxaa' | 'msaa';
+export type StandardVolumetricFogQuality = 'low' | 'high';
+
+export interface StandardVolumetricFogProfile {
+  readonly quality: StandardVolumetricFogQuality;
+  readonly depth: 48 | 64;
+  readonly tileSize: 4 | 16;
+}
+
 export const STANDARD_POST_STAGE_NAMES = [
   'transparent-blend',
   'bloom',
@@ -29,45 +26,28 @@ export const STANDARD_POST_STAGE_NAMES = [
   'present',
 ] as const;
 export type StandardPostStage = (typeof STANDARD_POST_STAGE_NAMES)[number];
-export type StandardVolumetricFogQuality = 'low' | 'high';
-
-export interface StandardVolumetricFogProfile {
-  readonly quality: StandardVolumetricFogQuality;
-  readonly depth: 48 | 64;
-  readonly tileSize: 4 | 16;
-}
-
 export interface StandardProfile {
   readonly pipelineId: typeof STANDARD_PIPELINE_ID;
   readonly lightCount: StandardLightCount;
-  readonly lighting: StandardLightingLane;
+  /** Graph topology selector; all local lights use the shared Cluster path. */
+  readonly renderPath: 'forward' | 'deferred';
   readonly shadows: StandardShadowMode;
   readonly pbr: boolean;
   readonly ibl: boolean;
   readonly ssao: boolean;
-  readonly bloom: boolean;
-  readonly tone: StandardTone;
-  readonly antialias: StandardAntialias;
-  readonly sky: boolean;
   /** Renderer-owned 1080p volume profile; tile width/height remain surface-derived. */
   readonly volumetricFog?: StandardVolumetricFogProfile | undefined;
-  readonly fallback: StandardFallbackLane;
   readonly postStages: typeof STANDARD_POST_STAGE_NAMES;
 }
 
 export const DEFAULT_STANDARD_PROFILE: StandardProfile = Object.freeze({
   pipelineId: STANDARD_PIPELINE_ID,
   lightCount: 32,
-  lighting: 'direct',
+  renderPath: 'forward',
   shadows: 'filtered',
   pbr: true,
   ibl: true,
   ssao: false,
-  bloom: true,
-  tone: 'aces-filmic',
-  antialias: 'fxaa',
-  sky: true,
-  fallback: 'native',
   postStages: STANDARD_POST_STAGE_NAMES,
 });
 
@@ -76,13 +56,3 @@ export function resolveVolumetricFogProfile(
 ): StandardVolumetricFogProfile {
   return profile.volumetricFog ?? { quality: 'high', depth: 64, tileSize: 4 };
 }
-
-export type StandardLane = StandardLightingLane | 'cpu-webgl2';
-
-export function resolveStandardLane(
-  profile: Pick<StandardProfile, 'lighting'>,
-  capabilities: { readonly compute: boolean; readonly storageBuffer: boolean },
-): StandardLane {
-  if (!capabilities.compute || !capabilities.storageBuffer) return 'cpu-webgl2';
-  return profile.lighting;
-}