@forgeax/engine-render 0.1.2

package/src/hdrp-cluster-membership.ts

@@ -0,0 +1,70 @@
+// @forgeax/engine-runtime - WebGPU HDRP cluster membership producer.
+//
+// The CPU binner remains the owner of bounds, occupancy, ordering, and
+// overflow validation. This compute entry only materializes the already
+// reserved ordered list on storage-buffer devices. Keeping the source here
+// makes the producer boot-time compiled and avoids adding a material shader
+// artifact or a second manifest identity.
+
+export const HDRP_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;
+  }
+
+  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;
+  }
+}
+`;

package/src/hdrp-pipeline.ts

@@ -0,0 +1,525 @@
+import type {
+  GraphAccess,
+  GraphBuffer,
+  GraphTextureDescriptor,
+  RenderGraphBuilder,
+  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 {
+  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 {
+  RenderPipeline,
+  RenderPipelineBuildContext,
+  RenderPipelineFrame,
+  RenderPipelineTopology,
+} from './render-pipeline';
+import type { _InternalRenderPipelineContext } from './render-pipeline-context';
+import {
+  createRenderPipelineTarget,
+  importRenderPipelineSurface,
+  type RenderPipelineTarget,
+} from './render-pipeline-target';
+import { resolveSsaoParameters } from './ssao-config';
+import {
+  addTypedBloomPasses,
+  addTypedFrameObservationPass,
+  addTypedScenePass,
+  addTypedSsaoPasses,
+  addTypedTonemapPass,
+  typedFrameClearColor,
+} from './typed-render-graph-primitives';
+import { addTypedShadowPasses } from './typed-shadow-passes';
+
+export const HDRP_PIPELINE_ID = 'forgeax::hdrp';
+
+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> {
+  const { x, y, z } = grid;
+  return Number.isInteger(x) &&
+    Number.isInteger(y) &&
+    Number.isInteger(z) &&
+    x >= 1 &&
+    x <= 64 &&
+    y >= 1 &&
+    y <= 64 &&
+    z >= 1 &&
+    z <= 64
+    ? ok({ x, y, z })
+    : 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,
+  descriptor: GraphTextureDescriptor,
+): Result<RenderPipelineTarget, RenderGraphError> {
+  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 buffers = getOrCreateHdrpBuffers(frame.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) =>
+      frame.pipelineState.hdrpClusterMembershipPipeline !== null &&
+      (frame as _InternalRenderPipelineContext).hdrpClusterMembershipBindGroup !== null,
+    begin: (frame) => frame.runtime.membershipTiming?.beforeMembership() ?? {},
+    onBeginError: (frame, cause) =>
+      frame.runtime.membershipTiming?.markTimestampPassFailed(String(cause)),
+    encode: ({ pass, frame }) => {
+      const pipeline = frame.pipelineState.hdrpClusterMembershipPipeline;
+      const bindings = (frame as _InternalRenderPipelineContext).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),
+  });
+}
+
+function buildHdrp(
+  context: RenderPipelineBuildContext<RenderPipelineFrame>,
+  topology: RenderPipelineTopology,
+): 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);
+  if (!buffers.ok) return buffers;
+  const membership = addMembershipPass(graph, topology, buffers.value);
+  if (!membership.ok) return membership;
+  const shadows = addTypedShadowPasses(graph, topology);
+  if (!shadows.ok) return shadows;
+
+  const depth = target(graph, 'hdrp-depth', {
+    format: 'depth24plus-stencil8',
+    size: 'surface',
+  });
+  if (!depth.ok) return depth;
+  const gbuffer0 = target(graph, 'gbuffer-normal-roughness', {
+    format: DEFERRED_COLOR_FORMATS[0] ?? 'rgba16float',
+    size: 'surface',
+  });
+  if (!gbuffer0.ok) return gbuffer0;
+  const gbuffer1 = target(graph, 'gbuffer-albedo-metallic', {
+    format: DEFERRED_COLOR_FORMATS[1] ?? 'rgba8unorm',
+    size: 'surface',
+  });
+  if (!gbuffer1.ok) return gbuffer1;
+  const gbuffer2 = target(graph, 'gbuffer-emissive-ao', {
+    format: DEFERRED_COLOR_FORMATS[2] ?? 'rgba16float',
+    size: 'surface',
+  });
+  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',
+    color: gbuffer0.value,
+    colorTargets: [gbuffer0.value, gbuffer1.value, gbuffer2.value],
+    depth: depth.value,
+    selector: { LightMode: ['Deferred'] },
+    passKind: 'deferred',
+    clearColor: [0, 0, 0, 0],
+  });
+  if (!gbuffer.ok) return gbuffer;
+
+  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' });
+    if (!blurred.ok) return blurred;
+    const passes = addTypedSsaoPasses(graph, {
+      normal: gbuffer0.value,
+      depth: depth.value,
+      raw: raw.value,
+      blurred: blurred.value,
+      parameters: parameters.value,
+    });
+    if (!passes.ok) return passes;
+    ssao = blurred.value;
+  }
+
+  const lightingAccesses: GraphAccess[] = [
+    { resource: gbuffer0.value.view, usage: 'sampled-read' },
+    { 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',
+    },
+    {
+      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' },
+    ...(ssao === undefined
+      ? []
+      : ([{ resource: ssao.view, usage: 'sampled-read' }] satisfies GraphAccess[])),
+    { 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,
+      },
+    ],
+    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,
+      });
+    },
+  });
+  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 forward = addTypedScenePass(graph, {
+    name: 'forward',
+    color: scene.value,
+    depth: depth.value,
+    selector: { LightMode: ['Forward'] },
+    colorLoadOp: 'load',
+    depthLoadOp: 'clear',
+    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',
+    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 (!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]),
+  ]);
+  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);
+  if (!observation.ok) return observation;
+
+  let postInput = resolvedScene;
+  if (topology.camera.bloom === 'on') {
+    const composited = target(graph, 'hdrp-bloom-composited', {
+      format: 'rgba16float',
+      size: 'surface',
+    });
+    if (!composited.ok) return composited;
+    const bright = target(graph, 'hdrp-bloom-bright', {
+      format: 'rgba16float',
+      size: 'half-surface',
+    });
+    if (!bright.ok) return bright;
+    const blurH = target(graph, 'hdrp-bloom-blur-h', {
+      format: 'rgba16float',
+      size: 'half-surface',
+    });
+    if (!blurH.ok) return blurH;
+    const blurV = target(graph, 'hdrp-bloom-blur-v', {
+      format: 'rgba16float',
+      size: 'half-surface',
+    });
+    if (!blurV.ok) return blurV;
+    const bloom = addTypedBloomPasses(graph, {
+      scene: resolvedScene,
+      composited: composited.value,
+      bright: bright.value,
+      blurH: blurH.value,
+      blurV: blurV.value,
+    });
+    if (!bloom.ok) return bloom;
+    postInput = composited.value;
+  }
+  if (topology.camera.tonemap !== 'none') {
+    const tonemap = addTypedTonemapPass(graph, postInput, surface.value.display);
+    if (!tonemap.ok) return tonemap;
+  } else {
+    const output = addTypedTonemapPass(graph, postInput, surface.value.display, true);
+    if (!output.ok) return output;
+  }
+  const debug = addTypedDebugOverlayPass(graph, surface.value.display);
+  if (!debug.ok) return debug;
+  return ok(undefined);
+}
+
+export const hdrpPipeline: RenderPipeline = { build: buildHdrp };