@forgeax/engine-render 0.1.32 → 0.1.34

package/src/__tests__/standard-pbr-artifact-assembly.unit.test.ts

@@ -160,6 +160,48 @@ describe('Standard PBR artifact assembly', () => {
     expect(custom?.receipt).toEqual(colored);
   });
 
+  it('resolves a topology projection against the producer complete variant key', () => {
+    const receipt = createStandardPbrArtifactReceipt();
+    const shader = {
+      findMaterialArtifact: () => ({
+        ok: true as const,
+        value: { source: 'boot-direct', paramSchema: [], receipt },
+      }),
+      materialShaderManifestEntries: () => [
+        {
+          identifier: 'forgeax::default-standard-pbr',
+          sourcePath: 'default-standard-pbr.wgsl',
+          composedWgsl: 'boot-direct',
+          paramSchema: '[]',
+          variants: [
+            {
+              definesKey:
+                'CLUSTER_FORWARD_AVAILABLE=false+GPU_DRIVEN_SCENE_INDEX_AVAILABLE=true+PROBE_BLEND_AVAILABLE=false+STORAGE_BUFFER_AVAILABLE=true+VERTEX_COLOR_AVAILABLE=false',
+              defines: {
+                CLUSTER_FORWARD_AVAILABLE: false,
+                GPU_DRIVEN_SCENE_INDEX_AVAILABLE: true,
+                PROBE_BLEND_AVAILABLE: false,
+                STORAGE_BUFFER_AVAILABLE: true,
+                VERTEX_COLOR_AVAILABLE: false,
+              },
+              composedWgsl: 'scene-index',
+              receipt,
+            },
+          ],
+        },
+      ],
+    } as unknown as Parameters<typeof resolveMaterialShaderArtifact>[1];
+    const artifact = resolveMaterialShaderArtifact('forgeax::default-standard-pbr', shader, {
+      address: 'scene-index',
+      pass: 'forward',
+      vertexColorAvailable: false,
+      variantSet:
+        'CLUSTER_FORWARD_AVAILABLE=false+STORAGE_BUFFER_AVAILABLE=true+VERTEX_COLOR_AVAILABLE=false',
+    });
+    expect(artifact?.wgsl).toBe('scene-index');
+    expect(artifact?.receipt).toEqual(receipt);
+  });
+
   it('routes built-in Standard shadow requests through the shadow-caster artifact', () => {
     const rigidPlain = createStandardPbrArtifactReceipt();
     const rigidColor = createStandardPbrArtifactReceipt(false, true);
@@ -251,7 +293,10 @@ describe('Standard PBR artifact assembly', () => {
     };
     const registry = {
       findMaterialArtifact: () => ({ ok: true, value: entry }),
-      materialShaderManifestEntries: () => [manifest].values(),
+      *materialShaderManifestEntries() {
+        yield manifest;
+        throw new Error('manifest search must stop at the first matching publication');
+      },
     } as unknown as Parameters<typeof resolveMaterialShaderArtifact>[1];
     const resolve = () =>
       resolveMaterialShaderArtifact('game::surface', registry, { address: 'scene-index' });

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

@@ -31,7 +31,7 @@ function topology(): RenderPipelineTopology {
       storageFormat: 'bgra8unorm',
       viewFormat: 'bgra8unorm-srgb',
     },
-    camera: { tonemap: 'aces-filmic', antialias: 'fxaa', bloom: 'on' },
+    camera: { tonemap: 'aces-filmic', antialias: 'fxaa', bloom: 'on', bloomIntensity: 1 },
     shadow: {
       directional: { mapSize: 64, cascadeCount: 1 },
       spotMapSize: 64,

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',
@@ -35,10 +37,15 @@ const dualViewProfile: SurfaceProfile = {
   hasDisplayEndpoint: true,
 };
 
+type TopologyOverrides = Omit<Partial<RenderPipelineTopology>, 'camera'> & {
+  readonly camera?: Partial<RenderPipelineTopology['camera']>;
+};
+
 function topology(
   profile: StandardProfile,
-  overrides: Partial<RenderPipelineTopology> = {},
+  overrides: TopologyOverrides = {},
 ): RenderPipelineTopology {
+  const { camera: cameraOverride, ...rest } = overrides;
   return {
     pipelineId: STANDARD_PIPELINE_ID,
     standardProfile: profile,
@@ -49,7 +56,13 @@ function topology(
       storageFormat: 'bgra8unorm',
       viewFormat: 'bgra8unorm-srgb',
     },
-    camera: { tonemap: 'aces-filmic', antialias: 'fxaa', bloom: 'on' },
+    camera: {
+      tonemap: 'aces-filmic',
+      antialias: 'fxaa',
+      bloom: 'on',
+      bloomIntensity: 1,
+      ...cameraOverride,
+    },
     shadow: {
       directional: { mapSize: 64, cascadeCount: 1 },
       spotMapSize: 64,
@@ -65,7 +78,7 @@ function topology(
     },
     featureTopologySignature: 'none',
     gpuDrivenTopologySignature: '',
-    ...overrides,
+    ...rest,
   };
 }
 
@@ -109,7 +122,7 @@ function standardLightingFor(resolvedTopology: RenderPipelineTopology) {
   return standardLighting;
 }
 
-async function build(profile: StandardProfile, overrides?: Partial<RenderPipelineTopology>) {
+async function build(profile: StandardProfile, overrides?: TopologyOverrides) {
   const graph = new RenderGraphBuilder<RenderPipelineFrame>();
   const resolvedTopology = topology(profile, overrides);
   const histogram = graph.createBuffer('standard-auto-exposure-histogram', { size: 1024 });
@@ -191,7 +204,30 @@ async function build(profile: StandardProfile, overrides?: Partial<RenderPipelin
       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,
   );
@@ -232,7 +268,7 @@ function importedTaaHistory(graph: RenderGraphBuilder<RenderPipelineFrame>) {
   };
 }
 
-async function buildTaa(profile: StandardProfile, overrides?: Partial<RenderPipelineTopology>) {
+async function buildTaa(profile: StandardProfile, overrides?: TopologyOverrides) {
   const graph = new RenderGraphBuilder<RenderPipelineFrame>();
   const history = importedTaaHistory(graph);
   const resolvedTopology = topology(profile, overrides);
@@ -416,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;
@@ -542,9 +602,8 @@ describe('forgeax::standard graph', () => {
     expect(result.ok).toBe(true);
     if (!result.ok) return;
     const names = result.value.inspect().passes.map((pass) => pass.name);
-    expect(names).not.toContain('bloom-bright');
-    expect(names).not.toContain('bloom-blur-h');
-    expect(names).not.toContain('bloom-blur-v');
+    expect(names.some((name) => name.startsWith('bloom-downsample-'))).toBe(false);
+    expect(names.some((name) => name.startsWith('bloom-upsample-'))).toBe(false);
     expect(names).not.toContain('bloom-composite');
     expect(names).toContain('taa-resolve');
     expect(names).toContain('output-transform');
@@ -926,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' },