@forgeax/engine-runtime 0.1.28 → 0.1.29

package/src/__tests__/dawn/material-cooked-fixture.dawn.test.ts

@@ -1,6 +1,15 @@
 import { readFileSync } from 'node:fs';
+import { stdout } from 'node:process';
 import { fileURLToPath } from 'node:url';
+import { World } from '@forgeax/engine-ecs';
+import { createBoxGeometry } from '@forgeax/engine-geometry';
+import { AssetGuid } from '@forgeax/engine-pack';
+import { Camera, MeshFilter, MeshRenderer } from '@forgeax/engine-render';
+import { Transform } from '@forgeax/engine-scene';
+import type { MaterialAsset } from '@forgeax/engine-types';
+import { buildEngineShaderManifest } from '@forgeax/engine-vite-plugin-shader';
 import { describe, expect, it } from 'vitest';
+import { constructRuntimeRendererHost } from '../../renderer-host';
 
 type CookedRecord = {
   readonly specializationKey: string;
@@ -44,6 +53,13 @@ const fixture = JSON.parse(
   ),
 ) as { readonly assets: readonly MaterialRow[] };
 
+const authoredShaderPackage = fileURLToPath(
+  new URL(
+    '../../../../../apps/hello/custom-shader/src/pulse-material.shader.pack.json',
+    import.meta.url,
+  ),
+);
+
 const materialRows = fixture.assets.filter((asset) => asset.kind === 'material');
 const root = materialRows.find((asset) => asset.payload.parent === undefined);
 const derived = materialRows.find((asset) => asset.payload.parent === root?.guid);
@@ -98,8 +114,188 @@ describe('custom-shader cooked MaterialAsset fixture', () => {
     });
   });
 
-  it('runs the real Dawn path for exactly 300 frames without unexpected RHI errors', () => {
-    expect(fixture.assets.length).toBeGreaterThanOrEqual(2);
-    expect(fixture.assets.every((asset) => asset.kind === 'material')).toBe(true);
-  });
+  it('loads the published material and draws 300 real Engine frames', async () => {
+    const manifest = await buildEngineShaderManifest({
+      materialPackages: [authoredShaderPackage],
+    });
+    const dataUrl = (value: unknown) =>
+      `data:application/json,${encodeURIComponent(JSON.stringify(value))}`;
+    const gpuErrors: string[] = [];
+    let device: GPUDevice | undefined;
+    let target: GPUTexture | undefined;
+    const canvas = {
+      width: 64,
+      height: 64,
+      getContext: () => ({
+        configure(descriptor: GPUCanvasConfiguration) {
+          device = descriptor.device;
+          device.addEventListener('uncapturederror', (event) =>
+            gpuErrors.push(event.error.message),
+          );
+          target = device.createTexture({
+            size: [64, 64],
+            format: descriptor.format,
+            viewFormats: [
+              descriptor.format === 'bgra8unorm' ? 'bgra8unorm-srgb' : 'rgba8unorm-srgb',
+            ],
+            usage: 0x10 | 0x01,
+          });
+        },
+        unconfigure() {},
+        getCurrentTexture: () => target,
+      }),
+      addEventListener() {},
+      removeEventListener() {},
+    };
+    const constructed = await constructRuntimeRendererHost(
+      canvas as never,
+      {},
+      { shaderManifestUrl: dataUrl(manifest) },
+    );
+    if (!constructed.ok) throw constructed.error;
+    const { renderer, assets } = constructed.value;
+    const errors: unknown[] = [];
+    renderer.subscribe((event) => {
+      if (event.kind === 'error') errors.push(event.error);
+    });
+    const world = new World();
+    try {
+      // The fixture's parent-less material is the publication root. Keep the
+      // runtime smoke on the same authority used by the contract assertions
+      // above; the pack payload does not carry a second `role` discriminator.
+      if (root === undefined) throw new Error('missing root publication');
+      const packUrl = dataUrl(fixture);
+      assets.configurePackIndex(
+        dataUrl(
+          fixture.assets.map((asset) => ({
+            guid: asset.guid,
+            kind: asset.kind,
+            packageUrl: packUrl,
+          })),
+        ),
+      );
+      for (const [guid, color] of [
+        ['01935b00-7d8c-7c4e-9f12-345678abcd11', [220, 100, 40, 255]],
+        ['01935b00-7d8c-7c4e-9f12-345678abcd12', [128, 128, 255, 255]],
+      ] as const) {
+        const parsed = AssetGuid.parse(guid);
+        if (!parsed.ok) throw parsed.error;
+        const cataloged = assets.catalog(parsed.value, {
+          kind: 'texture',
+          shape: { viewDimension: '2d', extent: { width: 1, height: 1 } },
+          format: 'rgba8unorm',
+          data: new Uint8Array(color),
+          colorSpace: 'linear',
+          mips: { kind: 'none' },
+        });
+        if (!cataloged.ok) throw cataloged.error;
+      }
+      const rootGuid = AssetGuid.parse(root.guid);
+      if (!rootGuid.ok) throw rootGuid.error;
+      const loaded = await assets.loadByGuid<MaterialAsset>(rootGuid.value);
+      if (!loaded.ok) throw loaded.error;
+      const readiness = assets.getMaterialReadiness(root.guid);
+      expect(readiness?.status).toBe('Ready');
+      if (readiness?.status !== 'Ready') throw new Error('material never became ready');
+      expect(readiness.artifactDigest).toBe(root.payload.cooked?.artifactDigest);
+      const module = loaded.value.passes?.[0]?.program.module;
+      if (module === undefined) throw new Error('material has no program');
+      const installed = assets.shaderRegistry.findMaterialArtifact(module);
+      if (!installed.ok) throw installed.error;
+      const program = readiness.programs.find((candidate) =>
+        candidate.selections.some((selection) => selection.pass === 'Forward'),
+      );
+      if (program === undefined) throw new Error('material has no forward program');
+      expect(installed.value.source).toBe(new TextDecoder().decode(program.artifact.bytes));
+      world
+        .spawn(
+          { component: Transform, data: { pos: [0, 0, 3], quat: [0, 0, 0, 1], scale: [1, 1, 1] } },
+          { component: Camera, data: { fov: Math.PI / 4, aspect: 1, near: 0.1, far: 100 } },
+        )
+        .unwrap();
+      const attached = renderer.attach(world);
+      if (!attached.ok) throw attached.error;
+      const lease = attached.value;
+      const frame = { leases: [lease], camera: { lease }, environment: { lease } };
+      const draw = () => {
+        world.update().unwrap();
+        const rendered = renderer.draw(frame);
+        if (!rendered.ok) throw rendered.error;
+      };
+      const readPixel = async () => {
+        if (device === undefined || target === undefined) throw new Error('missing GPU surface');
+        const readback = device.createBuffer({
+          size: 256,
+          usage: 0x08 | 0x01,
+        });
+        try {
+          const encoder = device.createCommandEncoder();
+          encoder.copyTextureToBuffer(
+            { texture: target, origin: [32, 32] },
+            { buffer: readback, bytesPerRow: 256 },
+            [1, 1],
+          );
+          device.queue.submit([encoder.finish()]);
+          await readback.mapAsync(0x01);
+          const pixel = [...new Uint8Array(readback.getMappedRange()).slice(0, 4)];
+          readback.unmap();
+          return pixel;
+        } finally {
+          readback.destroy();
+        }
+      };
+      draw();
+      const background = await readPixel();
+      const mesh = createBoxGeometry(1, 1, 1).unwrap();
+      const entity = world
+        .spawn(
+          { component: Transform, data: { pos: [0, 0, 0], quat: [0, 0, 0, 1], scale: [1, 1, 1] } },
+          { component: MeshFilter, data: { assetHandle: world.allocSharedRef('MeshAsset', mesh) } },
+          {
+            component: MeshRenderer,
+            data: { materials: [world.internSharedRef('MaterialAsset', loaded.value)] },
+          },
+        )
+        .unwrap();
+      for (let index = 0; index < 300; index++) {
+        draw();
+        // Match the host's frame boundary so queued shader/texture preparation runs.
+        await new Promise<void>((resolve) => setImmediate(resolve));
+      }
+      const pixel = await readPixel();
+      expect(errors).toEqual([]);
+      expect(gpuErrors).toEqual([]);
+      expect(
+        pixel
+          .slice(0, 3)
+          .reduce((delta, value, index) => delta + Math.abs(value - (background[index] ?? 0)), 0),
+      ).toBeGreaterThan(32);
+      world.despawn(entity).unwrap();
+      draw();
+      const removed = await readPixel();
+      expect(removed).toEqual(background);
+      expect(errors).toEqual([]);
+      expect(gpuErrors).toEqual([]);
+      if (process.env.FORGEAX_MATERIAL_SMOKE_EVIDENCE === '1') {
+        stdout.write(
+          `MATERIAL_DRAW_EVIDENCE=${JSON.stringify({
+            status: 'pass',
+            renderer: 'forgeax-runtime',
+            backend: 'dawn-webgpu',
+            frames: 300,
+            rootGuid: root.guid,
+            rootArtifactDigest: readiness.artifactDigest,
+            materialIdentity: { ...readiness.record.receipt.identity, materialGuid: root.guid },
+            pixel,
+            background,
+            removed,
+            observed: { enumerate: true, load: true, bind: true, draw: true, readback: true },
+          })}\n`,
+        );
+      }
+    } finally {
+      renderer.dispose();
+      target?.destroy();
+    }
+  }, 60000);
 });

package/src/__tests__/errors.unit.test.ts

@@ -401,6 +401,14 @@ type RuntimeLayerError = RenderError | AssetRuntimeError | SkinError;
       it('exhaustive switch covers all members without a default branch', () => {
         function exhaustive(code: RuntimeLayerErrorCode): string {
           switch (code) {
+            case 'auto-exposure-invalid-parameter':
+              return 'auto exposure invalid parameter';
+            case 'auto-exposure-capability-unavailable':
+              return 'auto exposure capability unavailable';
+            case 'auto-exposure-stale-generation':
+              return 'auto exposure stale generation';
+            case 'auto-exposure-stage-failed':
+              return 'auto exposure stage failed';
             case 'lifecycle-construction-failed':
               return 'lifecycle construction failed';
             case 'world-lease-invalid':
@@ -586,6 +594,11 @@ type RuntimeLayerError = RenderError | AssetRuntimeError | SkinError;
       it('exhaustive switch covers all 3 new members alongside existing members', () => {
         function exhaustive(code: RuntimeLayerErrorCode): string {
           switch (code) {
+            case 'auto-exposure-invalid-parameter':
+            case 'auto-exposure-capability-unavailable':
+            case 'auto-exposure-stale-generation':
+            case 'auto-exposure-stage-failed':
+              return 'ok';
             case 'lifecycle-construction-failed':
               return 'ok';
             case 'world-lease-invalid':

package/src/__tests__/feature-depth-material.dawn.test.ts

@@ -0,0 +1,23 @@
+import { it } from 'vitest';
+import { particleDepthLayouts, verifyFeatureDepthMaterial } from './feature-depth-material.fixture';
+
+it('samples depth written by a vertex-only prepared graphics pass', async () => {
+  await verifyFeatureDepthMaterial({
+    ...particleDepthLayouts[0],
+    view: false,
+    missing: 'none',
+    writeDepth: true,
+  });
+}, 120_000);
+
+it.each(
+  particleDepthLayouts.flatMap((layout) =>
+    [false, true].flatMap((view) =>
+      (['none', 'material', 'depth'] as const).map((missing) => ({ ...layout, view, missing })),
+    ),
+  ),
+)(
+  'combines depth/material/particle input: $name view=$view missing=$missing',
+  verifyFeatureDepthMaterial,
+  120_000,
+);