@forgeax/engine-render 0.1.33 → 0.1.34

package/src/__tests__/standard-pipeline.integration.test.ts

@@ -5,6 +5,7 @@ import { rhi } from '@forgeax/engine-rhi-null';
 import { ok } from '@forgeax/engine-types';
 import { beforeAll, describe, expect, it } from 'vitest';
 import { createRenderSurfaceError, type RenderSurfaceExpectedError } from '../errors/render';
+import { BARREL_DISTORTION_POST_PROCESS_ID } from '../features/barrel-distortion';
 import { prepareStandardLighting } from '../pipeline/standard-lighting/prepare';
 import { deriveStandardTopologyInput } from '../pipeline/standard-lighting/topology';
 import { selectStandardClusterTransport } from '../pipeline/standard-lighting/transport';
@@ -18,6 +19,7 @@ import {
 import type { RenderPipelineFrame, RenderPipelineTopology } from '../render-pipeline';
 import type { SurfaceProfile } from '../render-system';
 import { admitSsrSpatial } from '../ssr/admission';
+import { addTypedFullscreenPass } from '../typed-render-graph-primitives';
 
 const rawOnlyProfile: SurfaceProfile = {
   kind: 'raw-only',
@@ -202,7 +204,30 @@ async function build(profile: StandardProfile, overrides?: TopologyOverrides) {
       encodeTransmissionMip: ({ pass }) => pass.draw(3, 1, 0, 0),
       capabilities: { rgba16floatRenderable: true },
       projectGpuDriven: () => ok(undefined),
-      contributeFeatures: () => ok(undefined),
+      contributeFeatures: (
+        _targets,
+        _semanticTargets,
+        namedTargets = {},
+        _standardSurfaceAccesses,
+        featureSelection,
+      ) => {
+        if (
+          typeof featureSelection !== 'object' ||
+          featureSelection?.include?.includes(BARREL_DISTORTION_POST_PROCESS_ID) !== true
+        ) {
+          return ok(undefined);
+        }
+        const input = namedTargets['barrel-input'];
+        const output = namedTargets['barrel-output'];
+        if (input === undefined || output === undefined) return ok(undefined);
+        return addTypedFullscreenPass(graph, {
+          name: 'barrel-distortion',
+          shader: BARREL_DISTORTION_POST_PROCESS_ID,
+          input,
+          output,
+        });
+      },
+      hasFeature: (identity) => identity === BARREL_DISTORTION_POST_PROCESS_ID,
     },
     resolvedTopology,
   );
@@ -427,6 +452,30 @@ describe('forgeax::standard graph', () => {
     expect(lut.incrementalBindings).toBeGreaterThan(0);
   });
 
+  it('places barrel distortion in linear-LDR before FXAA and final encoding', async () => {
+    const result = await build(DEFAULT_STANDARD_PROFILE, {
+      camera: { tonemap: 'none', antialias: 'fxaa', bloom: 'off', barrelDistortion: true },
+      config: { postEffects: [BARREL_DISTORTION_POST_PROCESS_ID] },
+    });
+    expect(result.ok).toBe(true);
+    if (!result.ok) return;
+    const info = result.value.inspect();
+    const names = info.passes.map((pass) => pass.name);
+    const barrel = names.indexOf('barrel-distortion');
+    const fxaa = names.indexOf('fxaa');
+    const encoding = names.indexOf('standard-output-encoding');
+    const debug = names.indexOf('debug-overlay');
+    expect(barrel).toBeGreaterThan(-1);
+    expect(debug).toBeGreaterThan(-1);
+    expect(debug).toBeLessThan(barrel);
+    expect(barrel).toBeLessThan(fxaa);
+    expect(fxaa).toBeLessThan(encoding);
+    expect(names.filter((name) => name.startsWith('post-effect-'))).toHaveLength(0);
+    expect(info.resources.map((resource) => resource.label)).toContain(
+      'standard-barrel-distortion',
+    );
+  });
+
   it('keeps the last-known-good graph for each explicit surface failure', () => {
     let activeGraph = 'last-known-good';
     const failures = ['allocation', 'attachment', 'sampled-read', 'raw-endpoint'] as const;
@@ -936,6 +985,138 @@ describe('forgeax::standard graph', () => {
     }
   });
 
+  it('publishes the independent raw-depth producer before both Surface passes', async () => {
+    for (const renderPath of ['forward', 'deferred'] as const) {
+      const result = await build(
+        { ...DEFAULT_STANDARD_PROFILE, renderPath },
+        {
+          surface: {
+            width: 8,
+            height: 4,
+            storageFormat: 'bgra8unorm',
+            viewFormat: 'bgra8unorm-srgb',
+          },
+          singleLayerMedium: true,
+        },
+      );
+      expect(result.ok).toBe(true);
+      if (!result.ok) continue;
+      const info = result.value.inspect();
+      const names = info.passes.map((pass) => pass.name);
+      expect(names).toContain('single-layer-medium-raw-depth-producer');
+      expect(names).toContain('single-layer-medium-nearest-layer');
+      expect(names).toContain('single-layer-medium-color');
+      expect(names.indexOf('single-layer-medium-raw-depth-producer')).toBeLessThan(
+        names.indexOf('single-layer-medium-nearest-layer'),
+      );
+      expect(names.indexOf('single-layer-medium-nearest-layer')).toBeLessThan(
+        names.indexOf('single-layer-medium-color'),
+      );
+      const rawDepth = info.passes.find(
+        (pass) => pass.name === 'single-layer-medium-raw-depth-producer',
+      );
+      expect(rawDepth?.accesses).toContainEqual({
+        resource: 'single-layer-medium-raw-depth',
+        usage: 'color-attachment',
+      });
+      expect(rawDepth?.accesses.filter((access) => access.usage === 'sampled-read')).toHaveLength(
+        2,
+      );
+      const color = info.passes.find((pass) => pass.name === 'single-layer-medium-color');
+      expect(color?.accesses).toEqual(
+        expect.arrayContaining([
+          { resource: 'single-layer-medium-raw-depth', usage: 'sampled-read' },
+          { resource: 'single-layer-medium-nearest-layer', usage: 'sampled-read' },
+          { resource: 'single-layer-medium-nearest-depth-sampled', usage: 'sampled-read' },
+        ]),
+      );
+    }
+  });
+
+  it('pairs 4x opaque and nearest color with the depth sample selected for Surface', async () => {
+    const result = await build(
+      { ...DEFAULT_STANDARD_PROFILE, renderPath: 'forward' },
+      {
+        surface: {
+          width: 8,
+          height: 4,
+          storageFormat: 'bgra8unorm',
+          viewFormat: 'bgra8unorm-srgb',
+        },
+        camera: { tonemap: 'aces-filmic', antialias: 'msaa', bloom: 'off' },
+        lane: {
+          compute: true,
+          storageBuffer: true,
+          multisample: true,
+          maxColorAttachments: 8,
+        },
+        singleLayerMedium: true,
+      },
+    );
+    expect(result.ok).toBe(true);
+    if (!result.ok) return;
+    const info = result.value.inspect();
+    const names = info.passes.map((pass) => pass.name);
+    expect(names).toEqual(
+      expect.arrayContaining([
+        'single-layer-medium-opaque-resolve-color-producer',
+        'single-layer-medium-opaque-resolve-depth-producer',
+        'single-layer-medium-nearest-layer',
+        'single-layer-medium-nearest-resolve-color-producer',
+        'single-layer-medium-nearest-resolve-depth-producer',
+        'single-layer-medium-color',
+      ]),
+    );
+    expect(names.indexOf('single-layer-medium-opaque-resolve-depth-producer')).toBeLessThan(
+      names.indexOf('single-layer-medium-nearest-layer'),
+    );
+    expect(names.indexOf('single-layer-medium-nearest-resolve-depth-producer')).toBeLessThan(
+      names.indexOf('single-layer-medium-color'),
+    );
+    for (const label of [
+      'scene-color-msaa',
+      'scene-depth',
+      'single-layer-medium-nearest-layer',
+      'single-layer-medium-nearest-depth',
+    ]) {
+      expect(info.resources).toContainEqual(
+        expect.objectContaining({
+          label,
+          descriptor: expect.objectContaining({ sampleCount: 4 }),
+        }),
+      );
+    }
+    for (const label of [
+      'single-layer-medium-opaque-resolve-color',
+      'single-layer-medium-opaque-resolve-depth',
+      'single-layer-medium-nearest-resolve-color',
+      'single-layer-medium-nearest-resolve-depth',
+    ]) {
+      expect(info.resources).toContainEqual(
+        expect.objectContaining({
+          label,
+          descriptor: expect.objectContaining({ sampleCount: 1 }),
+        }),
+      );
+    }
+  });
+
+  it('adds one independent transparent graph lane without a backdrop split', async () => {
+    const result = await build(DEFAULT_STANDARD_PROFILE, {
+      surface: {
+        width: 8,
+        height: 4,
+        storageFormat: 'bgra8unorm',
+        viewFormat: 'bgra8unorm-srgb',
+      },
+    });
+    expect(result.ok).toBe(true);
+    if (!result.ok) return;
+    expect(
+      result.value.inspect().passes.filter((pass) => pass.name === 'transparent'),
+    ).toHaveLength(1);
+  });
+
   it('uses the resolved single-sample MSAA source for the shared backdrop', async () => {
     const result = await build(
       { ...DEFAULT_STANDARD_PROFILE, renderPath: 'forward' },