@forgeax/engine-render 0.1.3 → 0.1.6

package/src/{hdrp-pipeline.ts → pipeline/standard-pipeline.ts}

@@ -6,52 +6,115 @@ import type {
   RenderGraphError,
 } from '@forgeax/engine-render-graph';
 import { err, ok, type Result } from '@forgeax/engine-types';
-import { addTypedDebugOverlayPass } from './debug-draw-glue';
-import { encodeDeferredLightingPass } from './deferred-lighting';
-import {
-  addEnvironmentCompositionPass,
-  addEnvironmentProducerPasses,
-  environmentClearColor,
-  environmentGenerationEnabled,
-} from './environment/graph';
-import { HdrpDeferredCapsInsufficientError } from './errors/render';
-import {
-  addSceneTemporalRasterPass,
-  createSceneTemporalDepthTarget,
-  createSceneTemporalTarget,
-} from './features/scene-temporal';
+import { addTypedDebugOverlayPass } from '../debug-draw-glue';
+import { HdrpDeferredCapsInsufficientError } from '../errors/render';
 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';
+} 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,
   RenderPipelineFrame,
   RenderPipelineTopology,
-} from './render-pipeline';
-import type { _InternalRenderPipelineContext } from './render-pipeline-context';
+} from '../render-pipeline';
 import {
   createRenderPipelineTarget,
   importRenderPipelineSurface,
   type RenderPipelineTarget,
-} from './render-pipeline-target';
-import { resolveSsaoParameters } from './ssao-config';
+} from '../render-pipeline';
 import {
   addTypedBloomPasses,
+  addTypedCompositePostEffects,
   addTypedFrameObservationPass,
+  addTypedFullscreenPass,
   addTypedScenePass,
+  addTypedSkyboxPass,
   addTypedSsaoPasses,
   addTypedTonemapPass,
   typedFrameClearColor,
-} from './typed-render-graph-primitives';
-import { addTypedShadowPasses } from './typed-shadow-passes';
+} from '../typed-render-graph-primitives';
+import { addTypedShadowPasses } from '../typed-shadow-passes';
+
+import { buildStandardForwardLane } from './standard-forward-lane';
+import {
+  CLUSTER_GRID_STRIDE_U32,
+  DEFAULT_CLUSTER_GRID,
+  DEFAULT_STANDARD_PROFILE,
+  LIGHT_INDEX_LIST_CAPACITY,
+  MAX_LIGHTS,
+  resolveStandardLane,
+  STANDARD_PIPELINE_ID,
+  type StandardProfile,
+} from './standard-profile';
+
+/** WGSL owner for the Standard clustered membership producer. */
+export const STANDARD_CLUSTER_MEMBERSHIP_WGSL = /* wgsl */ `
+struct ClusterUniform {
+  grid : vec4<u32>,
+  near_far_log : vec4<f32>,
+};
+
+@group(0) @binding(0) var<storage, read> cluster_grid : array<u32>;
+@group(0) @binding(1) var<storage, read_write> light_index_list : array<u32>;
+@group(0) @binding(2) var<uniform> cluster_uniform : ClusterUniform;
+@group(0) @binding(3) var<storage, read> light_bounds : array<i32>;
+
+@compute @workgroup_size(64)
+fn cs_cluster_membership(@builtin(global_invocation_id) global_id : vec3<u32>) {
+  let cluster_index = global_id.x;
+  let grid_x = cluster_uniform.grid.x;
+  let grid_y = cluster_uniform.grid.y;
+  let grid_z = cluster_uniform.grid.z;
+  let cluster_count = grid_x * grid_y * grid_z;
+  if (cluster_index >= cluster_count) {
+    return;
+  }
 
-export const HDRP_PIPELINE_ID = 'forgeax::hdrp';
+  let cluster_x = cluster_index % grid_x;
+  let cluster_yz = cluster_index / grid_x;
+  let cluster_y = cluster_yz % grid_y;
+  let cluster_z = cluster_yz / grid_y;
+  let grid_offset = cluster_index * 2u;
+  let output_offset = cluster_grid[grid_offset];
+  let output_count = cluster_grid[grid_offset + 1u];
+  let cluster_x_i = i32(cluster_x);
+  let cluster_y_i = i32(cluster_y);
+  let cluster_z_i = i32(cluster_z);
+  var output_index = output_offset;
 
+  var light_index = 0u;
+  loop {
+    if (light_index >= cluster_uniform.grid.w || light_index >= 256u) {
+      break;
+    }
+    let bounds_offset = light_index * 6u;
+    let min_x = light_bounds[bounds_offset];
+    if (min_x >= 0) {
+      let min_y = light_bounds[bounds_offset + 1u];
+      let min_z = light_bounds[bounds_offset + 2u];
+      let max_x = light_bounds[bounds_offset + 3u];
+      let max_y = light_bounds[bounds_offset + 4u];
+      let max_z = light_bounds[bounds_offset + 5u];
+      if (
+        cluster_x_i >= min_x && cluster_x_i <= max_x &&
+        cluster_y_i >= min_y && cluster_y_i <= max_y &&
+        cluster_z_i >= min_z && cluster_z_i <= max_z
+      ) {
+        if (output_index < output_offset + output_count) {
+          light_index_list[output_index] = light_index;
+          output_index += 1u;
+        }
+      }
+    }
+    light_index += 1u;
+  }
+}
+`;
 export class HdrpInstallError extends Error {
   readonly code = 'hdrp-grid-invalid' as const;
   readonly expected = 'clusterGrid.{x,y,z} each integer in [1, 64]';
@@ -86,19 +149,6 @@ export function validateClusterGrid(grid: {
     : err(new HdrpInstallError(x, y, z));
 }
 
-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 function isGpuMembershipProducerAvailable(
-  caps: { readonly compute?: boolean } | null | undefined,
-  pipeline: unknown,
-  bindGroup: unknown,
-): boolean {
-  return caps?.compute === true && pipeline != null && bindGroup != null;
-}
-
 function target(
   graph: RenderGraphBuilder<RenderPipelineFrame>,
   label: string,
@@ -125,7 +175,8 @@ function importBuffers(
   const usage =
     (storage ? GPU_BUFFER_USAGE_STORAGE : GPU_BUFFER_USAGE_UNIFORM) | GPU_BUFFER_USAGE_COPY_DST;
   const resolve = (frame: RenderPipelineFrame): HdrpBuffers => {
-    const buffers = getOrCreateHdrpBuffers(frame.runtime, grid);
+    const internal = frame as _InternalRenderPipelineContext;
+    const buffers = getOrCreateHdrpBuffers(internal.runtime, grid);
     if (buffers === null) throw new Error('HDRP persistent buffer allocation failed');
     return buffers;
   };
@@ -181,22 +232,23 @@ function addMembershipPass(
       { resource: buffers.lightBounds, usage: 'storage-read' },
       { resource: buffers.lightIndexList, usage: 'storage-write' },
     ],
-    executeIf: (frame) =>
-      frame.pipelineState.hdrpClusterMembershipPipeline !== null &&
-      (frame as _InternalRenderPipelineContext).hdrpClusterMembershipBindGroup !== null,
-    begin: (frame) => frame.runtime.membershipTiming?.beforeMembership() ?? {},
-    onBeginError: (frame, cause) =>
-      frame.runtime.membershipTiming?.markTimestampPassFailed(String(cause)),
+    executeIf: (frame) => {
+      const internal = frame as _InternalRenderPipelineContext;
+      return (
+        internal.pipelineState.hdrpClusterMembershipPipeline !== null &&
+        internal.hdrpClusterMembershipBindGroup !== null
+      );
+    },
     encode: ({ pass, frame }) => {
-      const pipeline = frame.pipelineState.hdrpClusterMembershipPipeline;
-      const bindings = (frame as _InternalRenderPipelineContext).hdrpClusterMembershipBindGroup;
+      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));
     },
-    after: (frame) => frame.runtime.membershipTiming?.afterMembership(frame.encoder),
   });
 }
 
@@ -239,23 +291,6 @@ function buildHdrp(
   if (!gbuffer2.ok) return gbuffer2;
   const scene = target(graph, 'hdrp-scene-color', { format: 'rgba16float', size: 'surface' });
   if (!scene.ok) return scene;
-  const temporal =
-    topology.camera.antialias === 'taa' ? createSceneTemporalTarget(graph) : ok(undefined);
-  if (!temporal.ok) return temporal;
-  const temporalDepth =
-    topology.camera.antialias === 'taa' ? createSceneTemporalDepthTarget(graph) : ok(undefined);
-  if (!temporalDepth.ok) return temporalDepth;
-
-  if (topology.environment?.dirty === true) {
-    const environmentProducer = addEnvironmentProducerPasses(
-      graph,
-      gbuffer0.value,
-      'hdrp',
-      () => true,
-      context.environment?.targets,
-    );
-    if (!environmentProducer.ok) return environmentProducer;
-  }
 
   const gbuffer = addTypedScenePass(graph, {
     name: 'g-buffer',
@@ -270,8 +305,6 @@ function buildHdrp(
 
   let ssao: RenderPipelineTarget | undefined;
   if (topology.config?.ssao?.enabled === true) {
-    const parameters = resolveSsaoParameters(topology.config.ssao);
-    if (!parameters.ok) return parameters;
     const raw = target(graph, 'ssao-raw', { format: 'r8unorm', size: 'half-surface' });
     if (!raw.ok) return raw;
     const blurred = target(graph, 'ssao-blurred', { format: 'r8unorm', size: 'half-surface' });
@@ -281,7 +314,6 @@ function buildHdrp(
       depth: depth.value,
       raw: raw.value,
       blurred: blurred.value,
-      parameters: parameters.value,
     });
     if (!passes.ok) return passes;
     ssao = blurred.value;
@@ -292,7 +324,6 @@ 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: depth.value.view, usage: 'sampled-read' },
     {
       resource: buffers.value.lightData,
       usage: topology.lane.storageBuffer ? 'storage-read' : 'uniform-read',
@@ -312,60 +343,22 @@ function buildHdrp(
     { resource: scene.value.view, usage: 'color-attachment' },
   ];
   const lighting = graph.addRasterPass('lighting', {
-    // scene-radiance-fog-deferred-output: deferred scene radiance is fogged
-    // by the lighting output producer before the existing temporal boundary.
-    // The G-buffer remains a material fact source and is never fogged.
     accesses: lightingAccesses,
     colorAttachments: [
       {
         view: scene.value.view,
         loadOp: 'clear',
         storeOp: 'store',
-        clearValue:
-          topology.environment?.enabled === true ? environmentClearColor : typedFrameClearColor,
+        clearValue: typedFrameClearColor,
       },
     ],
-    encode: ({ pass, frame, resources }) => {
-      // WebGL2 cannot create the deferred post-process pipeline with a raw
-      // depth texture read. Keep the baseline lighting clear on that fallback
-      // backend; forward/transparent producers still apply fog there.
-      if (frame.runtime.device.caps.backendKind === 'wgpu-webgl2') return;
-      encodeDeferredLightingPass(frame, pass, resources, {
-        albedo: gbuffer1.value,
-        normal: gbuffer0.value,
-        emissive: gbuffer2.value,
-        depth: depth.value,
-        output: scene.value,
-      });
-    },
+    encode: () => undefined,
   });
   if (!lighting.ok) return lighting;
 
-  if (topology.environment?.enabled === true) {
-    const environmentBackground = addEnvironmentCompositionPass(
-      graph,
-      scene.value,
-      'hdrp.environment-background-depth-aware',
-      environmentGenerationEnabled,
-      {
-        sampled: context.environment?.sampledSky,
-        depth: depth.value.view,
-        sunDisc: false,
-      },
-    );
-    if (!environmentBackground.ok) return environmentBackground;
-    const sunDisc = addEnvironmentCompositionPass(
-      graph,
-      scene.value,
-      'hdrp.sun-disc',
-      environmentGenerationEnabled,
-      { sampled: context.environment?.sampledSky, depth: depth.value.view, sunDisc: true },
-    );
-    if (!sunDisc.ok) return sunDisc;
-  }
-  // scene-radiance-fog-forward-fragment: transparent and forward materials
-  // apply the shared fog module in their fragment output. No extra raster or
-  // fullscreen pass is introduced for the forward lane.
+  const skybox = addTypedSkyboxPass(graph, scene.value);
+  if (!skybox.ok) return skybox;
+
   const forward = addTypedScenePass(graph, {
     name: 'forward',
     color: scene.value,
@@ -404,122 +397,159 @@ function buildHdrp(
   });
   if (!forward.ok) return forward;
 
-  const sceneFeatureTarget = {
-    kind: 'scene-color' as const,
-    texture: scene.value.texture,
-    view: scene.value.view,
-    format: scene.value.format,
-    sampleCount: 1 as const,
-  };
-  const depthFeatureTarget = {
-    kind: 'scene-depth' as const,
-    texture: depth.value.texture,
-    view: depth.value.view,
-    format: depth.value.format,
-    sampleCount: 1 as const,
-  };
-  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: [
-        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 }),
-      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' },
-      ],
-    });
-    if (!temporalRaster.ok) return temporalRaster;
-  }
   const features = context.contributeFeatures([
-    sceneFeatureTarget,
-    depthFeatureTarget,
-    ...(temporalFeatureTarget === undefined ? [] : [temporalFeatureTarget]),
+    {
+      kind: 'scene-color',
+      texture: scene.value.texture,
+      view: scene.value.view,
+      format: scene.value.format,
+      sampleCount: 1,
+    },
+    {
+      kind: 'scene-depth',
+      texture: depth.value.texture,
+      view: depth.value.view,
+      format: depth.value.format,
+      sampleCount: 1,
+    },
   ]);
   if (!features.ok) return features;
-  const temporalResolve = context.resolveTemporal({
-    sceneColor: sceneFeatureTarget,
-    sceneDepth: depthFeatureTarget,
-    ...(temporalFeatureTarget === undefined ? {} : { sceneTemporal: temporalFeatureTarget }),
-  });
-  if (!temporalResolve.ok) return temporalResolve;
-  const resolvedScene = temporalResolve.value?.resolvedColor ?? scene.value;
-  const observation = addTypedFrameObservationPass(graph, resolvedScene, HDRP_PIPELINE_ID);
+  const observation = addTypedFrameObservationPass(graph, scene.value, 'forgeax::standard');
   if (!observation.ok) return observation;
 
-  let postInput = resolvedScene;
-  if (topology.camera.bloom === 'on') {
-    const composited = target(graph, 'hdrp-bloom-composited', {
+  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, 'hdrp-bloom-bright', {
+    const bright = target(graph, 'bloom-bright', {
       format: 'rgba16float',
       size: 'half-surface',
     });
     if (!bright.ok) return bright;
-    const blurH = target(graph, 'hdrp-bloom-blur-h', {
+    const blurH = target(graph, 'bloom-blur-h', {
       format: 'rgba16float',
       size: 'half-surface',
     });
     if (!blurH.ok) return blurH;
-    const blurV = target(graph, 'hdrp-bloom-blur-v', {
+    const blurV = target(graph, 'bloom-blur-v', {
       format: 'rgba16float',
       size: 'half-surface',
     });
     if (!blurV.ok) return blurV;
     const bloom = addTypedBloomPasses(graph, {
-      scene: resolvedScene,
+      scene: scene.value,
       composited: composited.value,
       bright: bright.value,
       blurH: blurH.value,
       blurV: blurV.value,
     });
     if (!bloom.ok) return bloom;
-    postInput = composited.value;
+    postInput = topology.camera.bloom === 'on' ? composited.value : scene.value;
   }
-  if (topology.camera.tonemap !== 'none') {
+
+  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, postInput, surface.value.display, true);
+    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);
 }
+const buildStandardClusteredLane = buildHdrp;
+
+export interface StandardPipeline extends RenderPipeline {
+  readonly identity: typeof STANDARD_PIPELINE_ID;
+}
+
+function profileFor(topology: RenderPipelineTopology): StandardProfile {
+  return topology.standardProfile ?? DEFAULT_STANDARD_PROFILE;
+}
+
+function standardTopology(
+  topology: RenderPipelineTopology,
+  profile: StandardProfile,
+): RenderPipelineTopology {
+  const config = {
+    ...(topology.config ?? {}),
+    ssao: { enabled: profile.ssao },
+  };
+  return {
+    ...topology,
+    pipelineId: STANDARD_PIPELINE_ID,
+    standardProfile: profile,
+    config,
+  };
+}
+
+/**
+ * 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.
+ */
+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,
+  });
+  const effective = standardTopology(topology, profile);
+  if (lane === 'clustered') return buildStandardClusteredLane(context, effective);
+  return buildStandardForwardLane(context, effective);
+}
+
+export const standardPipeline: StandardPipeline = Object.freeze({
+  identity: STANDARD_PIPELINE_ID,
+  build: buildStandard,
+});
 
-export const hdrpPipeline: RenderPipeline = { build: buildHdrp };
+export { DEFAULT_STANDARD_PROFILE, STANDARD_PIPELINE_ID } from './standard-profile';

package/src/pipeline/standard-profile.ts

@@ -0,0 +1,65 @@
+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 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 StandardPostStage = 'transparent-blend' | 'bloom' | 'tone' | 'fxaa' | 'output';
+
+export interface StandardProfile {
+  readonly pipelineId: typeof STANDARD_PIPELINE_ID;
+  readonly lightCount: StandardLightCount;
+  readonly lighting: StandardLightingLane;
+  readonly shadows: StandardShadowMode;
+  readonly pbr: boolean;
+  readonly ibl: boolean;
+  readonly ssao: boolean;
+  readonly bloom: boolean;
+  readonly tone: StandardTone;
+  readonly antialias: StandardAntialias;
+  readonly sky: boolean;
+  readonly fallback: StandardFallbackLane;
+  readonly postStages: readonly ['transparent-blend', 'bloom', 'tone', 'fxaa', 'output'];
+}
+
+export const DEFAULT_STANDARD_PROFILE: StandardProfile = Object.freeze({
+  pipelineId: STANDARD_PIPELINE_ID,
+  lightCount: 32,
+  lighting: 'direct',
+  shadows: 'filtered',
+  pbr: true,
+  ibl: true,
+  ssao: false,
+  bloom: true,
+  tone: 'aces-filmic',
+  antialias: 'fxaa',
+  sky: true,
+  fallback: 'native',
+  postStages: ['transparent-blend', 'bloom', 'tone', 'fxaa', 'output'] as const,
+});
+
+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;
+}