@forgeax/engine-render 0.1.7 → 0.1.20

package/src/__tests__/shader-manifest-fixture.ts

@@ -0,0 +1,111 @@
+import {
+  DEFAULT_STANDARD_PBR_PARAM_SCHEMA,
+  DEFAULT_UNLIT_PARAM_SCHEMA,
+} from '@forgeax/engine-shader';
+
+type FixtureEntry = {
+  readonly hash: string;
+  readonly wgsl: string;
+  readonly glsl: string;
+  readonly bindings: string;
+};
+
+const pbrWgsl = '// fixture marker: f_schlick\n';
+const unlitWgsl = '// fixture marker: default-unlit\n';
+
+const entries: readonly FixtureEntry[] = [
+  { hash: 'fixture-pbr', wgsl: pbrWgsl, glsl: '', bindings: '[]' },
+  { hash: 'fixture-unlit', wgsl: unlitWgsl, glsl: '', bindings: '[]' },
+  {
+    hash: 'fixture-tonemap',
+    wgsl: '// fixture marker: TonemapParams\n',
+    glsl: '',
+    bindings: '[]',
+  },
+  {
+    hash: 'fixture-taa',
+    wgsl: '// fixture marker: fs_taa_resolve\n',
+    glsl: '',
+    bindings: '[]',
+  },
+  {
+    hash: 'fixture-fxaa',
+    wgsl: '// fixture marker: rgb2luma\n',
+    glsl: '',
+    bindings: '[]',
+  },
+  {
+    hash: 'fixture-bloom-bright',
+    wgsl: '// fixture marker: BloomBrightParams\n',
+    glsl: '',
+    bindings: '[]',
+  },
+  {
+    hash: 'fixture-bloom-blur',
+    wgsl: '// fixture marker: BloomBlurParams\n',
+    glsl: '',
+    bindings: '[]',
+  },
+  {
+    hash: 'fixture-bloom-composite',
+    wgsl: '// fixture marker: BloomCompositeParams\n',
+    glsl: '',
+    bindings: '[]',
+  },
+];
+
+const standardPbrVariants = (() => {
+  const variants = [];
+  for (const cluster of [false, true]) {
+    for (const storage of [false, true]) {
+      for (const transmission of [false, true]) {
+        for (const vertexColor of [false, true]) {
+          const defines = {
+            CLUSTER_FORWARD_AVAILABLE: cluster,
+            STORAGE_BUFFER_AVAILABLE: storage,
+            TRANSMISSION_AVAILABLE: transmission,
+            VERTEX_COLOR_AVAILABLE: vertexColor,
+          };
+          const sortedDefines = Object.entries(defines).sort(([left], [right]) =>
+            left < right ? -1 : left > right ? 1 : 0,
+          );
+          const definesKey = sortedDefines.every(([, value]) => value)
+            ? ''
+            : sortedDefines.map(([key, value]) => `${key}=${value}`).join('+');
+          variants.push({ definesKey, defines, composedWgsl: pbrWgsl });
+        }
+      }
+    }
+  }
+  return variants;
+})();
+
+const materialShaders = [
+  {
+    identifier: 'forgeax::default-standard-pbr',
+    sourcePath: 'fixture://forgeax/default-standard-pbr.wgsl',
+    composedWgsl: pbrWgsl,
+    paramSchema: JSON.stringify(DEFAULT_STANDARD_PBR_PARAM_SCHEMA),
+    variants: standardPbrVariants,
+    uvSetCount: 8,
+  },
+  {
+    identifier: 'forgeax::default-unlit',
+    sourcePath: 'fixture://forgeax/default-unlit.wgsl',
+    composedWgsl: unlitWgsl,
+    paramSchema: JSON.stringify(DEFAULT_UNLIT_PARAM_SCHEMA),
+    variants: [],
+    uvSetCount: 1,
+  },
+] as const;
+
+/**
+ * Build the smallest manifest that exercises renderer post-process assembly.
+ * The fixture is intentionally self-contained so package tests do not depend
+ * on a generated app dist directory or on the caller's working directory.
+ */
+export function renderLifecycleManifestUrl(): string {
+  return `data:application/json,${encodeURIComponent(
+    JSON.stringify({ entries, materialShaders }),
+  )}`;
+}

package/src/__tests__/skinned-shadow-caster.test.ts

@@ -0,0 +1,123 @@
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { describe, expect, it } from 'vitest';
+import { resolveMaterialShaderVariantSet } from '../assembly/factory';
+import {
+  isSkinnedShadowCasterVariant,
+  SHADOW_CASTER_SHADER_ID,
+  shadowCasterVariantSet,
+} from '../pbr-pipeline.js';
+
+describe('skinned shadow caster', () => {
+  it('derives closed capability variants without changing the shader identity', () => {
+    expect(shadowCasterVariantSet(true, false)).toBe('');
+    expect(shadowCasterVariantSet(false, true)).toBe(
+      'SKINNING_DISABLED=false+STORAGE_BUFFER_AVAILABLE=false',
+    );
+    expect(shadowCasterVariantSet(true, true)).toBe(
+      'SKINNING_DISABLED=false+STORAGE_BUFFER_AVAILABLE=true',
+    );
+    expect(isSkinnedShadowCasterVariant(SHADOW_CASTER_SHADER_ID, '')).toBe(false);
+    expect(
+      isSkinnedShadowCasterVariant(
+        SHADOW_CASTER_SHADER_ID,
+        'SKINNING_DISABLED=false+STORAGE_BUFFER_AVAILABLE=false',
+      ),
+    ).toBe(true);
+    expect(
+      isSkinnedShadowCasterVariant(
+        SHADOW_CASTER_SHADER_ID,
+        'SKINNING_DISABLED=true+STORAGE_BUFFER_AVAILABLE=false',
+      ),
+    ).toBe(false);
+  });
+
+  it('uses the animated palette in WGSL and binds the same slice in the shadow pass', () => {
+    const shader = readFileSync(
+      fileURLToPath(new URL('../../../shader/src/shadow_caster.wgsl', import.meta.url)),
+      'utf8',
+    );
+    const record = readFileSync(
+      fileURLToPath(new URL('../record/shadow-pass.ts', import.meta.url)),
+      'utf8',
+    );
+    const builder = readFileSync(
+      fileURLToPath(new URL('../pipeline-builder.ts', import.meta.url)),
+      'utf8',
+    );
+    expect(shader).toContain('#pragma variant_axis SKINNING_DISABLED');
+    expect(shader).toContain('@group(2) @binding(1)');
+    expect(shader).toContain('let skinMatrix = palette[');
+    expect(record).toContain('entry.source.skin.byteOffset');
+    expect(record).toContain("'shadow-pbr-skin-mesh'");
+    expect(builder).toContain("ctx.layoutKind === 'pbr-skin'");
+    expect(builder).toContain('? [...ctx.vertexBuffers]');
+  });
+
+  it('keeps mixed static and skinned shadow draws on matching variants and bindings', () => {
+    const recordSource = readFileSync(
+      fileURLToPath(new URL('../record/shadow-pass.ts', import.meta.url)),
+      'utf8',
+    );
+    const variants = [
+      {
+        defines: {
+          SKINNING_DISABLED: true,
+          STORAGE_BUFFER_AVAILABLE: false,
+        },
+      },
+      {
+        defines: {
+          SKINNING_DISABLED: false,
+          STORAGE_BUFFER_AVAILABLE: false,
+        },
+      },
+    ];
+    const staticVariant = resolveMaterialShaderVariantSet(
+      shadowCasterVariantSet(false, false),
+      variants,
+      'wgpu-webgl2',
+      false,
+    );
+    const skinnedVariant = resolveMaterialShaderVariantSet(
+      shadowCasterVariantSet(false, true),
+      variants,
+      'wgpu-webgl2',
+      false,
+    );
+
+    expect(staticVariant).toBe('SKINNING_DISABLED=true+STORAGE_BUFFER_AVAILABLE=false');
+    expect(skinnedVariant).toBe('SKINNING_DISABLED=false+STORAGE_BUFFER_AVAILABLE=false');
+    expect(isSkinnedShadowCasterVariant(SHADOW_CASTER_SHADER_ID, staticVariant)).toBe(false);
+    expect(isSkinnedShadowCasterVariant(SHADOW_CASTER_SHADER_ID, skinnedVariant)).toBe(true);
+    expect(recordSource).toContain(
+      'shadowCasterVariantSet(c.runtime.device.caps.storageBuffer, false)',
+    );
+    expect(recordSource).toContain(
+      "'shadow-caster',\n      undefined,\n      undefined,\n      undefined,\n      undefined,\n      undefined,\n      undefined,\n      undefined,\n      undefined,\n      'pbr'",
+    );
+    expect(recordSource).toContain('shadowPass.setBindGroup(2, skinMeshBindGroup, [');
+    expect(recordSource).toContain('entry.source.skin.byteOffset');
+  });
+
+  it('keeps low-limit shadow view bindings paired with the optional projector layout', () => {
+    const recordSource = readFileSync(
+      fileURLToPath(new URL('../record/shadow-pass.ts', import.meta.url)),
+      'utf8',
+    );
+
+    // A 16-sampled-texture device removes bindings 11/12 from pbr-view-bgl.
+    // The shadow-view helper must use the same capability bit as the main
+    // view helper or it recreates the browser-only bind-group mismatch.
+    expect(recordSource).toContain(
+      'const projectorAvailable = pipelineState.projectorAvailable !== false;',
+    );
+    expect(recordSource).toContain(
+      '...(projectorAvailable\n          ? [pipelineState.defaultWhiteTextureView, pipelineState.defaultSampler]',
+    );
+    expect(recordSource).toContain(
+      '...(projectorAvailable\n              ? [\n                  {\n                    binding: 11,',
+    );
+    expect(recordSource).toContain('binding: 12');
+  });
+});

package/src/__tests__/standard-clustered-pipeline.unit.test.ts

@@ -7,15 +7,21 @@ const clusteredSource = readFileSync(
   'utf8',
 );
 const frameSource = readFileSync(new URL('../record/frame.ts', import.meta.url), 'utf8');
+const forwardSource = readFileSync(
+  new URL('../pipeline/standard-forward-lane.ts', import.meta.url),
+  'utf8',
+);
 
 describe('Standard clustered post color-domain order', () => {
   it('keeps transparent and bloom work in linear HDR before tone output', () => {
     const stages = resolvePostColorDomainContract('linear-hdr');
     expect(stages).toContainEqual(['transparent-blend', 'linear-hdr', 'linear-hdr']);
     expect(stages).toContainEqual(['bloom', 'linear-hdr', 'linear-hdr']);
-    expect(stages).toContainEqual(['tone', 'linear-hdr', 'linear-ldr']);
-    expect(stages).toContainEqual(['output', 'linear-ldr', 'display-encoded']);
-    expect(stages.findIndex(([name]) => name === 'tone')).toBeGreaterThan(
+    expect(stages).toContainEqual(['output-transform', 'linear-hdr', 'display-encoded']);
+    expect(stages).toContainEqual(['fxaa', 'display-encoded', 'display-encoded']);
+    expect(stages).toContainEqual(['post-effect', 'display-encoded', 'display-encoded']);
+    expect(stages).toContainEqual(['present', 'display-encoded', 'display-encoded']);
+    expect(stages.findIndex(([name]) => name === 'output-transform')).toBeGreaterThan(
       stages.findIndex(([name]) => name === 'bloom'),
     );
   });
@@ -25,4 +31,19 @@ describe('Standard clustered post color-domain order', () => {
     expect(frameSource).toContain('internals.device.caps?.compute === true,');
     expect(clusteredSource).toContain('pass.dispatchWorkgroups(');
   });
+
+  it('routes both Standard lanes through the one shared post-chain owner', () => {
+    expect(clusteredSource.match(/addStandardPost\(/g)).toHaveLength(1);
+    expect(forwardSource.match(/addStandardPost\(/g)).toHaveLength(1);
+    expect(clusteredSource).not.toContain("target(graph, 'ldr-color'");
+    expect(forwardSource).not.toContain("target(graph, 'ldr-color'");
+  });
+
+  it('retains clustered Spot shadow receiver and atlas dependencies', () => {
+    const result = resolvePostColorDomainContract('linear-hdr');
+    expect(result).toContainEqual(['bloom', 'linear-hdr', 'linear-hdr']);
+    expect(clusteredSource).toContain('spotShadow: shadows.value.spot');
+    expect(clusteredSource).toContain('shadows.value.spot,');
+    expect(clusteredSource).toContain("'hdrp-light-index-list'");
+  });
 });

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

@@ -3,6 +3,7 @@ import type { RhiDevice } from '@forgeax/engine-rhi';
 import { rhi } from '@forgeax/engine-rhi-webgpu';
 import { ok } from '@forgeax/engine-types';
 import { describe, expect, it } from 'vitest';
+import { createRenderSurfaceError } from '../errors/render';
 import { standardPipeline } from '../pipeline/standard-pipeline';
 import { DEFAULT_STANDARD_PROFILE, STANDARD_PIPELINE_ID } from '../pipeline/standard-profile';
 import type { RenderPipelineFrame, RenderPipelineTopology } from '../render-pipeline';
@@ -38,6 +39,20 @@ function topology(): RenderPipelineTopology {
 }
 
 describe('forgeax::standard graph on a real WebGPU device', () => {
+  it('reports float-chain failures without replacing the last-known-good surface', () => {
+    const error = createRenderSurfaceError('sampled-read', {
+      lane: 'clustered',
+      stage: 'fxaa',
+      target: 'standard-output-color',
+      format: 'rgba16float',
+      domain: 'display-encoded',
+      endpoint: 'surface.storage',
+      capability: 'float-sampled-read',
+    });
+    expect(error.code).toBe('surface-sampled-read-failed');
+    expect(error.detail.target).toBe('standard-output-color');
+  });
+
   it('compiles the clustered profile with real texture and binding formats', async () => {
     const adapter = (await rhi.requestAdapter()).unwrap();
     const device: RhiDevice = (await adapter.requestDevice()).unwrap();