@forgeax/engine-render 0.1.4 → 0.1.7

package/src/assets/__tests__/asset-decoders.unit.test.ts

@@ -1,92 +0,0 @@
-import type { AssetEnvelopeV2, MaterialAsset } from '@forgeax/engine-types';
-import { describe, expect, it } from 'vitest';
-import { materialContribution } from '../asset-decoders';
-
-function envelope(payload: MaterialAsset, refs: readonly string[]): AssetEnvelopeV2<MaterialAsset> {
-  return {
-    guid: '00000000-0000-7000-8000-000000000031',
-    kind: 'material',
-    payload,
-    refs,
-    artifacts: {},
-  };
-}
-
-describe('material asset decoder', () => {
-  it('projects shorthand texture and parent refs from Pack wire indices to GUIDs', async () => {
-    const result = await materialContribution.decoder.decode({
-      envelope: envelope(
-        {
-          kind: 'material',
-          parent: 1 as never,
-          values: { baseColorTexture: 0, roughness: 0.5 },
-        },
-        ['00000000-0000-7000-8000-000000000041', '00000000-0000-7000-8000-000000000042'],
-      ),
-      artifacts: undefined as never,
-      signal: new AbortController().signal,
-    });
-
-    expect(result).toEqual({
-      ok: true,
-      value: {
-        kind: 'material',
-        parent: '00000000-0000-7000-8000-000000000042',
-        values: {
-          baseColorTexture: '00000000-0000-7000-8000-000000000041',
-          roughness: 0.5,
-        },
-      },
-    });
-  });
-
-  it('projects texture and sampler refs from Pack wire indices to GUIDs', async () => {
-    const material: MaterialAsset = {
-      kind: 'material',
-      values: {
-        baseColorTexture: { texture: 0, sampler: 1 },
-      },
-    };
-
-    const result = await materialContribution.decoder.decode({
-      envelope: envelope(material, [
-        '00000000-0000-7000-8000-000000000041',
-        '00000000-0000-7000-8000-000000000042',
-      ]),
-      artifacts: undefined as never,
-      signal: new AbortController().signal,
-    });
-
-    expect(result).toEqual({
-      ok: true,
-      value: {
-        ...material,
-        values: {
-          baseColorTexture: {
-            texture: '00000000-0000-7000-8000-000000000041',
-            sampler: '00000000-0000-7000-8000-000000000042',
-          },
-        },
-      },
-    });
-  });
-
-  it('rejects a material wire ref that is not present in refs[]', async () => {
-    const result = await materialContribution.decoder.decode({
-      envelope: envelope(
-        {
-          kind: 'material',
-          values: { baseColorTexture: { texture: 1 } },
-        },
-        ['00000000-0000-7000-8000-000000000041'],
-      ),
-      artifacts: undefined as never,
-      signal: new AbortController().signal,
-    });
-
-    expect(result).toMatchObject({
-      ok: false,
-      error: { code: 'asset-package-invalid' },
-    });
-  });
-});

package/src/assets/__tests__/mipmap-generator.unit.test.ts

@@ -1,52 +0,0 @@
-import { ok } from '@forgeax/engine-rhi';
-import { describe, expect, it } from 'vitest';
-import {
-  getOrCreateMipmapPipeline,
-  type MipmapDevice,
-  type MipmapShaderModuleFactory,
-  mipmapCacheSize,
-  numMipLevels,
-} from '../../mipmap-generator';
-
-let nextResourceId = 0;
-
-function makeStubDevice(): MipmapDevice {
-  return {
-    createSampler: () => ok({ tag: `sampler-${nextResourceId++}` }),
-    createBindGroupLayout: () => ok({ tag: `bgl-${nextResourceId++}` }),
-    createPipelineLayout: () => ok({ tag: `layout-${nextResourceId++}` }),
-    createRenderPipeline: (desc: { fragment?: { targets?: Array<{ format?: string }> } }) =>
-      ok({ tag: `pipeline-${nextResourceId++}`, format: desc.fragment?.targets?.[0]?.format }),
-  } as unknown as MipmapDevice;
-}
-
-const shaderFactory: MipmapShaderModuleFactory = async () => ok({ tag: 'shader' });
-
-describe('render mipmap owner', () => {
-  it('derives the full mip chain from the largest dimension', () => {
-    expect(numMipLevels({ width: 1, height: 1 })).toBe(1);
-    expect(numMipLevels({ width: 300, height: 200 })).toBe(9);
-  });
-
-  it('caches pipelines by device and format', async () => {
-    const device = makeStubDevice();
-    const first = await getOrCreateMipmapPipeline(device, 'rgba8unorm', shaderFactory);
-    const second = await getOrCreateMipmapPipeline(device, 'rgba8unorm', shaderFactory);
-    const srgb = await getOrCreateMipmapPipeline(device, 'rgba8unorm-srgb', shaderFactory);
-
-    expect(first.ok && second.ok && first.value).toBe(second.ok && second.value);
-    expect(srgb.ok).toBe(true);
-    expect(mipmapCacheSize(device)).toBe(2);
-  });
-
-  it('isolates caches across devices', async () => {
-    const deviceA = makeStubDevice();
-    const deviceB = makeStubDevice();
-    const fromA = await getOrCreateMipmapPipeline(deviceA, 'rgba8unorm', shaderFactory);
-    const fromB = await getOrCreateMipmapPipeline(deviceB, 'rgba8unorm', shaderFactory);
-
-    expect(fromA.ok && fromB.ok && fromA.value).not.toBe(fromB.ok && fromB.value);
-    expect(mipmapCacheSize(deviceA)).toBe(1);
-    expect(mipmapCacheSize(deviceB)).toBe(1);
-  });
-});

package/src/assets/__tests__/render-asset-port.unit.test.ts

@@ -1,54 +0,0 @@
-import type { ShaderRegistry } from '@forgeax/engine-shader';
-import type { MaterialAsset } from '@forgeax/engine-types';
-import { describe, expect, it } from 'vitest';
-import { createRenderAssetPort } from '../render-asset-port';
-
-function shaderRegistry(): ShaderRegistry {
-  return {
-    findMaterialArtifact: () => ({ ok: false, error: new Error('not registered') }),
-  } as unknown as ShaderRegistry;
-}
-
-function material(module: string): MaterialAsset {
-  return {
-    kind: 'material',
-    passes: [
-      {
-        name: 'Forward',
-        program: { module },
-        renderState: { tags: { LightMode: 'Forward' }, queue: 2000 },
-      },
-    ],
-  };
-}
-
-describe('render asset port', () => {
-  it('publishes typed payloads with stable GUID lookup and mutation epochs', () => {
-    const payloads = new Map<string, MaterialAsset>();
-    let epoch = 0;
-    const port = createRenderAssetPort(shaderRegistry(), {
-      get epoch() {
-        return epoch;
-      },
-      lookup: <T>(guid: string) => payloads.get(guid.toLowerCase()) as T | undefined,
-      guidOf: (asset) => [...payloads.entries()].find(([, payload]) => payload === asset)?.[0],
-    });
-    const first = material('first');
-    const replacement = material('replacement');
-
-    expect(port.epoch).toBe(0);
-    payloads.set('abc', first);
-    epoch += 1;
-    expect(port.epoch).toBe(1);
-    expect(port.lookup<MaterialAsset>('abc')).toBe(first);
-    expect(port.guidOf(first)).toBe('abc');
-
-    epoch += 0;
-    expect(port.epoch).toBe(1);
-    payloads.set('abc', replacement);
-    epoch += 1;
-    expect(port.epoch).toBe(2);
-    expect(port.lookup<MaterialAsset>('ABC')).toBe(replacement);
-    expect(port.guidOf(first)).toBeUndefined();
-  });
-});

package/src/assets/__tests__/resolve-render-asset.unit.test.ts

@@ -1,47 +0,0 @@
-import { World } from '@forgeax/engine-ecs';
-import { createPrimitiveMesh } from '@forgeax/engine-geometry';
-import type { Asset } from '@forgeax/engine-types';
-import { BUILTIN_BASE, handleSlot } from '@forgeax/engine-types';
-import { describe, expect, it } from 'vitest';
-import { resolveRenderAsset } from '../resolve-render-asset';
-
-describe('render handle resolution', () => {
-  it('resolves World-owned primitive meshes', () => {
-    const world = new World();
-    const cubeHandle = world.internSharedRef('MeshAsset', createPrimitiveMesh('cube').unwrap());
-    const triangleHandle = world.internSharedRef(
-      'MeshAsset',
-      createPrimitiveMesh('triangle').unwrap(),
-    );
-
-    const cube = resolveRenderAsset(world, cubeHandle);
-    const triangle = resolveRenderAsset(world, triangleHandle);
-
-    expect(cube.ok && cube.value.kind).toBe('mesh');
-    expect(triangle.ok && triangle.value.kind).toBe('mesh');
-    expect(handleSlot(cubeHandle)).toBe(BUILTIN_BASE);
-  });
-
-  it('resolves user handles from the owning World shared-ref store', () => {
-    const world = new World();
-    const payload = createPrimitiveMesh('cube').unwrap();
-    const handle = world.allocSharedRef('MeshAsset', payload);
-
-    const resolved = resolveRenderAsset<Asset>(world, handle);
-
-    expect(resolved).toEqual({ ok: true, value: payload });
-  });
-
-  it('returns a closed error for a handle owned by another World', () => {
-    const world = new World();
-    const foreignWorld = new World();
-    const foreignHandle = foreignWorld.allocSharedRef(
-      'MeshAsset',
-      createPrimitiveMesh('cube').unwrap(),
-    );
-    const resolved = resolveRenderAsset(world, foreignHandle);
-
-    expect(resolved.ok).toBe(false);
-    if (!resolved.ok) expect(resolved.error.code).toBe('shared-ref-released');
-  });
-});

package/src/components/__tests__/atmosphere-red.test.ts

@@ -1,51 +0,0 @@
-import { World } from '@forgeax/engine-ecs';
-import { describe, expect, it } from 'vitest';
-import * as render from '../../index';
-
-type RenderSurface = Record<string, unknown>;
-
-const atmosphereToken = (render as RenderSurface).Atmosphere as
-  | {
-      readonly fields?: Record<string, { readonly default?: number }>;
-    }
-  | undefined;
-const selectEnvironmentSource = (render as RenderSurface).selectEnvironmentSource as
-  | ((input: { readonly resourceOwner: World }) => {
-      readonly ok: boolean;
-      readonly error?: { readonly code: string };
-    })
-  | undefined;
-
-describe('Atmosphere authoring contract (red gate)', () => {
-  it('requires the five-field schema; cardinality is renderer-owned', () => {
-    expect(atmosphereToken).toBeDefined();
-    expect(Object.keys(atmosphereToken?.fields ?? {})).toEqual([
-      'turbidity',
-      'rayleigh',
-      'mieCoefficient',
-      'mieDirectionalG',
-      'sunAngularRadius',
-    ]);
-  });
-
-  it('requires an Atmosphere source to be co-located with DirectionalLight', () => {
-    expect(atmosphereToken).toBeDefined();
-    expect(selectEnvironmentSource).toBeDefined();
-    const world = new World();
-    world.spawn({ component: atmosphereToken as never, data: {} }).unwrap();
-    const result = selectEnvironmentSource?.({ resourceOwner: world });
-    expect(result?.ok).toBe(false);
-    if (result && !result.ok) expect(result.error?.code).toBe('atmosphere-sun-missing');
-  });
-
-  it('rejects multiple Atmosphere sources in the resource World', () => {
-    expect(atmosphereToken).toBeDefined();
-    expect(selectEnvironmentSource).toBeDefined();
-    const world = new World();
-    world.spawn({ component: atmosphereToken as never, data: {} }).unwrap();
-    world.spawn({ component: atmosphereToken as never, data: {} }).unwrap();
-    const result = selectEnvironmentSource?.({ resourceOwner: world });
-    expect(result?.ok).toBe(false);
-    if (result && !result.ok) expect(result.error?.code).toBe('atmosphere-cardinality-invalid');
-  });
-});

package/src/components/__tests__/atmosphere.test.ts

@@ -1,79 +0,0 @@
-import { World } from '@forgeax/engine-ecs';
-import { describe, expect, it } from 'vitest';
-import { Atmosphere, validateAtmosphereData } from '../atmosphere';
-
-describe('Atmosphere schema', () => {
-  it('exposes exactly five finite medium fields with canonical defaults', () => {
-    expect(Object.keys(Atmosphere.fields)).toEqual([
-      'turbidity',
-      'rayleigh',
-      'mieCoefficient',
-      'mieDirectionalG',
-      'sunAngularRadius',
-    ]);
-    expect(
-      Object.fromEntries(
-        Object.entries(Atmosphere.fields).map(([name, field]) => [name, field.default]),
-      ),
-    ).toEqual({
-      turbidity: 2,
-      rayleigh: 1,
-      mieCoefficient: 0.005,
-      mieDirectionalG: 0.8,
-      sunAngularRadius: 0.004675,
-    });
-  });
-
-  it('accepts every inclusive boundary and the open sun radius lower bound', () => {
-    const cases = [
-      ['turbidity', 1],
-      ['turbidity', 20],
-      ['rayleigh', 0],
-      ['rayleigh', 4],
-      ['mieCoefficient', 0],
-      ['mieCoefficient', 0.1],
-      ['mieDirectionalG', 0],
-      ['mieDirectionalG', 0.999],
-      ['sunAngularRadius', 0.000001],
-      ['sunAngularRadius', 0.02],
-    ] as const;
-    for (const [field, value] of cases) {
-      const result = validateAtmosphereData({ [field]: value });
-      expect(result.ok, `${field}=${value}`).toBe(true);
-    }
-  });
-
-  it('rejects non-finite and out-of-range values with structured detail', () => {
-    const cases = [
-      ['turbidity', Number.NaN],
-      ['turbidity', Number.POSITIVE_INFINITY],
-      ['rayleigh', Number.NEGATIVE_INFINITY],
-      ['rayleigh', -0.001],
-      ['mieCoefficient', 0.101],
-      ['mieDirectionalG', 1],
-      ['sunAngularRadius', 0],
-      ['sunAngularRadius', 0.020001],
-    ] as const;
-    for (const [field, value] of cases) {
-      const result = validateAtmosphereData({ [field]: value });
-      expect(result.ok, `${field}=${value}`).toBe(false);
-      if (!result.ok) {
-        const error = result.error as unknown as {
-          readonly code: string;
-          readonly detail: { readonly field: string; readonly value: number };
-        };
-        expect(error.code).toBe('atmosphere-parameter-invalid');
-        expect(error.detail.field).toBe(field);
-        expect(Object.is(error.detail.value, value)).toBe(true);
-      }
-    }
-  });
-
-  it('keeps component storage independent across Worlds', () => {
-    const worldA = new World();
-    const worldB = new World();
-    expect(worldA.spawn({ component: Atmosphere, data: {} }).ok).toBe(true);
-    expect(worldA.spawn({ component: Atmosphere, data: {} }).ok).toBe(true);
-    expect(worldB.spawn({ component: Atmosphere, data: {} }).ok).toBe(true);
-  });
-});

package/src/components/__tests__/fog.test-d.ts

@@ -1,49 +0,0 @@
-import { World } from '@forgeax/engine-ecs';
-import { componentSchema } from '@forgeax/engine-ecs/internal';
-import { expectTypeOf } from 'vitest';
-import { Fog } from '../environment';
-
-const world = new World();
-
-world.spawn({
-  component: Fog,
-  data: {
-    color: [0.18, 0.22, 0.28],
-    density: 0.035,
-    heightFalloff: 0.28,
-    maxOpacity: 0.92,
-  },
-});
-
-// Legacy profile and split-range concepts are intentionally not part of the
-// single Fog authoring surface.
-world.spawn({
-  component: Fog,
-  // @ts-expect-error Fog has no mode discriminator.
-  data: { mode: 'height' },
-});
-world.spawn({
-  component: Fog,
-  // @ts-expect-error Fog has no baseHeight field.
-  data: { baseHeight: 0 },
-});
-world.spawn({
-  component: Fog,
-  // @ts-expect-error Fog has no start field.
-  data: { start: 1 },
-});
-world.spawn({
-  component: Fog,
-  // @ts-expect-error Fog has no end field.
-  data: { end: 10 },
-});
-world.spawn({
-  component: Fog,
-  // @ts-expect-error color must be a three-component numeric array.
-  data: { color: 'gray' },
-});
-
-expectTypeOf(componentSchema(Fog).color).toEqualTypeOf<'array<f32, 3>'>();
-expectTypeOf(componentSchema(Fog).density).toEqualTypeOf<'f32'>();
-expectTypeOf(componentSchema(Fog).heightFalloff).toEqualTypeOf<'f32'>();
-expectTypeOf(componentSchema(Fog).maxOpacity).toEqualTypeOf<'f32'>();

package/src/components/__tests__/fog.test.ts

@@ -1,60 +0,0 @@
-import { World } from '@forgeax/engine-ecs';
-import { componentSchema } from '@forgeax/engine-ecs/internal';
-import { describe, expect, it } from 'vitest';
-import { Fog } from '../environment';
-
-const DEFAULT_COLOR = [0.5, 0.5, 0.5];
-
-describe('Fog schema contract', () => {
-  it('exposes one environment token with exactly four reflected fields', () => {
-    expect(Object.keys(Fog.fields)).toEqual(['color', 'density', 'heightFalloff', 'maxOpacity']);
-    expect(Fog.fields.color.type).toBe('array<f32, 3>');
-    expect(Fog.fields.density.type).toBe('f32');
-    expect(Fog.fields.heightFalloff.type).toBe('f32');
-    expect(Fog.fields.maxOpacity.type).toBe('f32');
-    expect(componentSchema(Fog)).toEqual({
-      color: 'array<f32, 3>',
-      density: 'f32',
-      heightFalloff: 'f32',
-      maxOpacity: 'f32',
-    });
-    expect('mode' in componentSchema(Fog)).toBe(false);
-    expect('baseHeight' in componentSchema(Fog)).toBe(false);
-    expect('start' in componentSchema(Fog)).toBe(false);
-    expect('end' in componentSchema(Fog)).toBe(false);
-    expect('profile' in componentSchema(Fog)).toBe(false);
-  });
-
-  it('uses the canonical defaults and gives each entity an independent color array', () => {
-    expect(Fog.fields.color.default).toEqual(new Float32Array(DEFAULT_COLOR));
-    expect(Fog.fields.density.default).toBe(0.01);
-    expect(Fog.fields.heightFalloff.default).toBe(0);
-    expect(Fog.fields.maxOpacity.default).toBe(1);
-
-    const world = new World();
-    const first = world.spawn({ component: Fog, data: {} }).unwrap();
-    const second = world.spawn({ component: Fog, data: {} }).unwrap();
-    const firstColor = world.get(first, Fog).unwrap().color;
-    const secondColor = world.get(second, Fog).unwrap().color;
-
-    expect(firstColor).toEqual(new Float32Array(DEFAULT_COLOR));
-    expect(secondColor).toEqual(new Float32Array(DEFAULT_COLOR));
-    expect(firstColor).not.toBe(secondColor);
-    firstColor[0] = 9;
-    expect(secondColor[0]).toBe(DEFAULT_COLOR[0]);
-    expect((Fog.fields.color.default as Float32Array)[0]).toBe(DEFAULT_COLOR[0]);
-  });
-
-  it('stores authoring values for render-owner validation', () => {
-    const result = new World().spawn({
-      component: Fog,
-      data: {
-        color: [2, 0.25, 0],
-        density: 0,
-        heightFalloff: 0.75,
-        maxOpacity: 1,
-      },
-    });
-    expect(result.ok).toBe(true);
-  });
-});

package/src/components/atmosphere.ts

@@ -1,64 +0,0 @@
-import { defineComponent } from '@forgeax/engine-ecs';
-import { err, ok, type Result } from '@forgeax/engine-types';
-import { type AtmosphereField, AtmosphereParameterInvalidError } from '../errors/render';
-
-/**
- * Analytic atmosphere medium parameters. Sun direction, color, and
- * illuminance belong to a co-located DirectionalLight, never to this token.
- * The renderer-owned environment selector enforces one Atmosphere source per
- * resource World; ECS component schemas do not carry cardinality policy.
- */
-export const Atmosphere = defineComponent('Atmosphere', {
-  turbidity: { type: 'f32', default: 2 },
-  rayleigh: { type: 'f32', default: 1 },
-  mieCoefficient: { type: 'f32', default: 0.005 },
-  mieDirectionalG: { type: 'f32', default: 0.8 },
-  sunAngularRadius: { type: 'f32', default: 0.004675 },
-});
-
-const ATMOSPHERE_CHECKS: readonly {
-  readonly field: AtmosphereField;
-  readonly min: number;
-  readonly max: number;
-  readonly minExclusive?: boolean;
-}[] = [
-  { field: 'turbidity', min: 1, max: 20 },
-  { field: 'rayleigh', min: 0, max: 4 },
-  { field: 'mieCoefficient', min: 0, max: 0.1 },
-  { field: 'mieDirectionalG', min: 0, max: 0.999 },
-  { field: 'sunAngularRadius', min: 0, max: 0.02, minExclusive: true },
-];
-
-/** Validate Atmosphere payloads at the renderer owner boundary. */
-export function validateAtmosphereData(
-  data: Readonly<Record<string, unknown>>,
-): Result<void, AtmosphereParameterInvalidError> {
-  for (const check of ATMOSPHERE_CHECKS) {
-    const reflectedDefault = Atmosphere.fields[check.field]?.default;
-    const rawValue = data[check.field] ?? reflectedDefault;
-    const value = typeof rawValue === 'number' ? rawValue : Number.NaN;
-    if (!Number.isFinite(value)) {
-      return err(
-        new AtmosphereParameterInvalidError(
-          check.field,
-          value,
-          check.min,
-          check.max,
-          check.minExclusive ?? false,
-        ),
-      );
-    }
-    if ((check.minExclusive ? value <= check.min : value < check.min) || value > check.max) {
-      return err(
-        new AtmosphereParameterInvalidError(
-          check.field,
-          value,
-          check.min,
-          check.max,
-          check.minExclusive ?? false,
-        ),
-      );
-    }
-  }
-  return ok(undefined);
-}

package/src/deferred-lighting.ts

@@ -1,92 +0,0 @@
-import type { GraphResourceResolver, ResolveContext } from '@forgeax/engine-render-graph';
-import type { RhiRenderPassEncoder, TextureView } from '@forgeax/engine-rhi';
-import { buildPerFrameBindGroups } from './record/frame-lighting';
-import { encodeFullscreenPass } from './render-graph-primitives';
-import type { RenderPipelineFrame } from './render-pipeline';
-import type { RenderPipelineTarget } from './render-pipeline-target';
-import type { RenderSystemInternals } from './render-system';
-
-export const HDRP_DEFERRED_LIGHTING_POST_PROCESS_ID = 'forgeax::hdrp-deferred-lighting';
-
-function resolveView(resources: GraphResourceResolver, target: RenderPipelineTarget): TextureView {
-  const result = resources.textureView(target.view);
-  if (!result.ok) throw result.error;
-  return result.value;
-}
-
-function resolveDepthView(
-  frame: RenderPipelineFrame,
-  resources: GraphResourceResolver,
-  target: RenderPipelineTarget,
-): TextureView {
-  const texture = resources.texture(target.texture);
-  if (!texture.ok) throw texture.error;
-  const view = frame.runtime.device.createTextureView(texture.value, {
-    label: 'hdrp-deferred-lighting-depth-only-view',
-    dimension: '2d',
-    aspect: 'depth-only',
-    baseMipLevel: 0,
-    mipLevelCount: 1,
-    baseArrayLayer: 0,
-    arrayLayerCount: 1,
-  });
-  if (!view.ok) throw view.error;
-  return view.value;
-}
-
-export function encodeDeferredLightingPass(
-  frame: RenderPipelineFrame,
-  pass: RhiRenderPassEncoder,
-  resources: GraphResourceResolver,
-  targets: {
-    readonly albedo: RenderPipelineTarget;
-    readonly normal: RenderPipelineTarget;
-    readonly emissive: RenderPipelineTarget;
-    readonly depth: RenderPipelineTarget;
-    readonly output: RenderPipelineTarget;
-  },
-): void {
-  const views: ResolveContext = {
-    resolve: (name) => {
-      switch (name) {
-        case 'gbuffer-albedo-metallic':
-          return resolveView(resources, targets.albedo);
-        case 'gbuffer-normal-roughness':
-          return resolveView(resources, targets.normal);
-        case 'gbuffer-emissive-ao':
-          return resolveView(resources, targets.emissive);
-        case 'depth':
-          return resolveView(resources, targets.depth);
-        case 'hdrp-scene-color':
-          return resolveView(resources, targets.output);
-        default:
-          return undefined;
-      }
-    },
-  };
-  // The deferred lighting shader owns a group(0) View UBO, but this pass is
-  // not a scene pass and therefore cannot inherit the main-pass context's
-  // bind group. Resolve the same graph-backed shadow views used by the main
-  // pass so the cache has one canonical view-main entry for the frame.
-  const viewBindGroup = buildPerFrameBindGroups(
-    frame.runtime as RenderSystemInternals,
-    frame.frameState,
-    frame.pipelineState,
-    true,
-    frame.bindGroupCounts,
-    {
-      directionalShadow: frame.frameState.currentDirectionalShadowView ?? undefined,
-      spotShadow: frame.frameState.currentSpotShadowView ?? undefined,
-    },
-  ).viewBindGroup;
-  if (viewBindGroup !== null) pass.setBindGroup(0, viewBindGroup);
-  encodeFullscreenPass(frame, pass, {
-    name: 'lighting',
-    shader: HDRP_DEFERRED_LIGHTING_POST_PROCESS_ID,
-    color: 'hdrp-scene-color',
-    reads: ['gbuffer-albedo-metallic', 'gbuffer-normal-roughness', 'gbuffer-emissive-ao', 'depth'],
-    resolve: views,
-    outputFormat: targets.output.format as GPUTextureFormat,
-    depthView: resolveDepthView(frame, resources, targets.depth),
-  });
-}