@forgeax/engine-runtime 0.1.4 → 0.1.7

package/src/__tests__/post-process-register-roundtrip.dawn.test.ts

@@ -1,230 +0,0 @@
-// post-process-register-roundtrip.dawn.test.ts - feat-20260604-resource-owning
-// -render-graph-and-fullscreen-postpr M3 / F-2 fix-up.
-//
-// PIPE-NEUTRAL: this file exercises fullscreen post-process passes via
-// addFullscreenPass, which bypasses material-pass selection. The URP
-// tag convention (tags: { LightMode: 'Forward' }) is not applicable
-// here — no passes:[] material literal exists in this file.
-//
-// Round-trip dawn integration test for the postProcess.register channel +
-// addFullscreenPass dispatcher (F-2 / F-7 wiring):
-//   (a) register(id, entry) is callable through the public renderer.postProcess
-//       surface (re-runs through createRenderer to a real Renderer instance).
-//   (b) registering the SAME id twice throws PostProcessError with code
-//       'post-process-already-registered' (programmer-error fail-fast).
-//   (c) addFullscreenPass referencing an unregistered id throws PostProcessError
-//       with code 'post-process-not-found' through the dispatcher's lookup +
-//       throw branch (the load-bearing AC-08 path: F-2 verified by exercising
-//       the runtime.lookupPostProcess plumbing on a real Renderer).
-//
-// Distinct from fullscreen-post-process-pass.dawn.test.ts (which exercises the
-// FXAA built-in path via antialias='fxaa' + camera) — this test exercises the
-// AI-user register/lookup channel directly, ensuring an unregistered id never
-// silently no-ops (charter P3) and ensuring the registry survives a real
-// renderer.draw cycle.
-
-import type { RenderPipelineContext } from '@forgeax/engine-render/internal';
-import { addFullscreenPass } from '@forgeax/engine-render/internal';
-import { RenderGraph } from '@forgeax/engine-render-graph';
-import { describe, expect, it } from 'vitest';
-import { createRenderer } from '../createRenderer';
-
-const WIDTH = 256;
-const HEIGHT = 256;
-
-const ENGINE_MANIFEST = await (async () => {
-  const { buildEngineShaderManifest } = await import('@forgeax/engine-vite-plugin-shader');
-  return buildEngineShaderManifest();
-})();
-const ENGINE_MANIFEST_URL = `data:application/json,${encodeURIComponent(
-  JSON.stringify(ENGINE_MANIFEST),
-)}`;
-
-async function setupRenderer(): Promise<Awaited<ReturnType<typeof createRenderer>>> {
-  if (typeof globalThis.navigator?.gpu?.requestAdapter !== 'function') {
-    throw new Error('dawn-node navigator.gpu not injected; vitest.setup-webgpu.ts regressed');
-  }
-  let renderTarget: GPUTexture | undefined;
-  let sharedDevice: GPUDevice | undefined;
-  const original = globalThis.navigator.gpu.requestAdapter.bind(globalThis.navigator.gpu);
-  globalThis.navigator.gpu.requestAdapter = async (opts) => {
-    const a = await original(opts);
-    if (a === null) return a;
-    const od = a.requestDevice.bind(a);
-    a.requestDevice = async (desc) => {
-      const d = await od(desc);
-      if (sharedDevice === undefined) sharedDevice = d;
-      return d;
-    };
-    return a;
-  };
-  const mockCanvas = {
-    width: WIDTH,
-    height: HEIGHT,
-    getContext(kind: string) {
-      if (kind !== 'webgpu') return null;
-      return {
-        configure() {},
-        unconfigure() {},
-        getCurrentTexture(): GPUTexture {
-          if (sharedDevice === undefined)
-            throw new Error('render target requested before device captured');
-          if (renderTarget === undefined) {
-            renderTarget = sharedDevice.createTexture({
-              size: { width: WIDTH, height: HEIGHT, depthOrArrayLayers: 1 },
-              format: 'rgba8unorm',
-              usage: 0x10 | 0x01,
-              viewFormats: ['rgba8unorm-srgb'],
-            });
-          }
-          return renderTarget;
-        },
-      };
-    },
-    addEventListener() {},
-    removeEventListener() {},
-  } as unknown as HTMLCanvasElement;
-  try {
-    const r = await createRenderer(mockCanvas, undefined, {
-      shaderManifestUrl: ENGINE_MANIFEST_URL,
-    });
-    const ready = await r.ready;
-    if (!ready.ok) throw new Error('renderer.ready failed');
-    return r;
-  } finally {
-    globalThis.navigator.gpu.requestAdapter = original;
-  }
-}
-
-describe('feat-20260604 M3 F-2 fix-up: postProcess.register + addFullscreenPass dispatcher', () => {
-  it('renderer.postProcess.register accepts a new id (round-trip success)', async () => {
-    const r = await setupRenderer();
-    // The first register MUST succeed (no throw). entry.source is a placeholder
-    // WGSL string — the dispatcher does not compile it on this path; only the
-    // BGL/sampler/bind-group helpers run on the AI-user execute closure.
-    expect(() =>
-      r.postProcess.register('test::roundtrip-A', {
-        source: 'fn main() {}',
-      }),
-    ).not.toThrow();
-  });
-
-  it('renderer.postProcess.register throws on same-id duplicate (programmer-error fail-fast)', async () => {
-    const r = await setupRenderer();
-    r.postProcess.register('test::roundtrip-B', { source: 'fn main() {}' });
-    let caught: unknown = null;
-    try {
-      r.postProcess.register('test::roundtrip-B', { source: 'fn main() {}' });
-    } catch (e) {
-      caught = e;
-    }
-    expect(caught).not.toBeNull();
-    const err = caught as { code?: string; detail?: { id?: string } };
-    expect(err.code).toBe('post-process-already-registered');
-    expect(err.detail?.id).toBe('test::roundtrip-B');
-  });
-
-  it('unregisters a realm-owned entry so a later realm can reuse the id', async () => {
-    const r = await setupRenderer();
-    const unregister = r.postProcess.register('test::realm-owned', { source: 'fn main() {}' });
-    unregister();
-    expect(() =>
-      r.postProcess.register('test::realm-owned', { source: 'fn main() {}' }),
-    ).not.toThrow();
-  });
-
-  it('renderer.postProcess.register throws params-size-mismatch when params.byteSize < 16 (live fail-fast)', async () => {
-    // feat-20260621 AC-A3: the eager params-UBO guard must fire on the REAL
-    // register() path (not just on a hand-constructed PostProcessError). byteSize
-    // below the 16B std140 minimum is a programmer error caught at register time,
-    // before any frame draws.
-    const r = await setupRenderer();
-    let caught: unknown = null;
-    try {
-      r.postProcess.register('test::roundtrip-params-too-small', {
-        source: 'fn main() {}',
-        params: { byteSize: 8, defaultValue: new Uint8Array(8) },
-      });
-    } catch (e) {
-      caught = e;
-    }
-    expect(caught, 'register with byteSize < 16 must throw').not.toBeNull();
-    const err = caught as { code?: string; detail?: { byteSize?: number; actualLength?: number } };
-    expect(err.code).toBe('params-size-mismatch');
-    expect(err.detail?.byteSize).toBe(8);
-  });
-
-  it('renderer.postProcess.register throws params-size-mismatch when defaultValue.length !== byteSize (live fail-fast)', async () => {
-    // Same guard, second branch: declared byteSize and the seed defaultValue
-    // disagree — the eager UBO write would corrupt; register() must reject.
-    const r = await setupRenderer();
-    let caught: unknown = null;
-    try {
-      r.postProcess.register('test::roundtrip-params-length-mismatch', {
-        source: 'fn main() {}',
-        params: { byteSize: 16, defaultValue: new Uint8Array(12) },
-      });
-    } catch (e) {
-      caught = e;
-    }
-    expect(caught, 'register with mismatched defaultValue length must throw').not.toBeNull();
-    const err = caught as { code?: string; detail?: { byteSize?: number; actualLength?: number } };
-    expect(err.code).toBe('params-size-mismatch');
-    expect(err.detail?.byteSize).toBe(16);
-    expect(err.detail?.actualLength).toBe(12);
-  });
-
-  it('addFullscreenPass referencing unregistered id throws post-process-not-found via dispatcher', async () => {
-    // The dispatcher's lookup-and-throw branch is the load-bearing AC-08 path.
-    // Build a minimal RenderGraph with a single fullscreen pass referencing an
-    // id that was never registered; running its execute closure must throw a
-    // PostProcessError with code 'post-process-not-found'.
-    //
-    // We synthesise a stub ctx that satisfies the closure's read paths
-    // (runtime.lookupPostProcess returns undefined, ctx.view is non-null).
-    // The dispatcher's only consumed surface on this path is
-    // ctx.runtime.lookupPostProcess; the throw fires before any device call.
-    const r = await setupRenderer();
-    void r;
-
-    const stubCtx = {
-      runtime: {
-        lookupPostProcess: (_id: string) => undefined,
-      },
-      view: {} as unknown,
-    } as unknown as RenderPipelineContext;
-
-    const graph = new RenderGraph<RenderPipelineContext>();
-    graph.addColorTarget('rt', {
-      format: 'rgba8unorm',
-      size: { w: WIDTH, h: HEIGHT },
-    });
-    addFullscreenPass(graph, 'pp', { shader: 'never::registered', color: 'rt' });
-
-    // Reach into the registry to recover the descriptor.execute. listPasses
-    // surfaces only name/reads/writes; the executor lives on the PassEntry
-    // accessible via the private passes registry. The cast is test-internal
-    // (mirrors how render-system-record reaches into the registry to invoke
-    // pass.descriptor.execute on the per-frame topology).
-    const passes = (
-      graph as unknown as {
-        passes: {
-          list(): readonly { name: string; descriptor: { execute?: (c: unknown) => void } }[];
-        };
-      }
-    ).passes.list();
-    const pp = passes.find((p) => p.name === 'pp');
-    expect(pp, 'pass "pp" must be registered').toBeDefined();
-    if (!pp || pp.descriptor.execute === undefined) return;
-    let caught: unknown = null;
-    try {
-      pp.descriptor.execute(stubCtx);
-    } catch (e) {
-      caught = e;
-    }
-    expect(caught, 'addFullscreenPass with unregistered id must throw').not.toBeNull();
-    const err = caught as { code?: string; detail?: { id?: string } };
-    expect(err.code).toBe('post-process-not-found');
-    expect(err.detail?.id).toBe('never::registered');
-  });
-});

package/src/__tests__/render-feature-zero-feature.browser.test.ts

@@ -1,152 +0,0 @@
-import { World } from '@forgeax/engine-ecs';
-import { createPrimitiveMesh } from '@forgeax/engine-geometry';
-import {
-  ANTIALIAS_FXAA,
-  Camera,
-  DirectionalLight,
-  MeshFilter,
-  MeshRenderer,
-  TONEMAP_REINHARD_EXTENDED,
-} from '@forgeax/engine-render';
-import { Transform } from '@forgeax/engine-scene';
-import { afterEach, describe, expect, it } from 'vitest';
-import { Engine } from '../index';
-
-const browserReady = typeof navigator !== 'undefined' && navigator.gpu !== undefined;
-const CLEAR_COLOR: readonly [number, number, number] = [0.06, 0.06, 0.08];
-
-function distanceFromClear(pixels: Uint8Array): number {
-  let maximum = 0;
-  for (let i = 0; i < pixels.length; i += 4) {
-    const red = (pixels[i] ?? 0) / 255;
-    const green = (pixels[i + 1] ?? 0) / 255;
-    const blue = (pixels[i + 2] ?? 0) / 255;
-    const distance = Math.hypot(
-      red - CLEAR_COLOR[0],
-      green - CLEAR_COLOR[1],
-      blue - CLEAR_COLOR[2],
-    );
-    maximum = Math.max(maximum, distance);
-  }
-  return maximum;
-}
-
-function makeBaselineWorld(): World {
-  const world = new World();
-  const triangleHandle = world.internSharedRef(
-    'MeshAsset',
-    createPrimitiveMesh('triangle').unwrap(),
-  );
-  world
-    .spawn(
-      { component: Transform, data: {} },
-      { component: MeshFilter, data: { assetHandle: triangleHandle } },
-      { component: MeshRenderer, data: {} },
-    )
-    .unwrap();
-  world
-    .spawn(
-      { component: Transform, data: { pos: [0, 0, 3] } },
-      {
-        component: Camera,
-        data: {
-          fov: Math.PI / 4,
-          aspect: 1,
-          near: 0.1,
-          far: 100,
-          tonemap: TONEMAP_REINHARD_EXTENDED,
-          antialias: ANTIALIAS_FXAA,
-        },
-      },
-    )
-    .unwrap();
-  world.spawn({
-    component: DirectionalLight,
-    data: { direction: [-0.5, -1, -0.3], color: [1, 1, 1], intensity: 1 },
-  });
-  return world;
-}
-
-describe.skipIf(!browserReady)('zero-feature browser render baseline', () => {
-  let renderer: Awaited<ReturnType<typeof Engine.create>> | undefined;
-  let canvas: HTMLCanvasElement | undefined;
-
-  afterEach(() => {
-    // Browser Mode files share Chromium's GPU process. Do not dispose the
-    // renderer here: that destroys the shared device for the next file.
-    if (canvas?.parentNode !== null) canvas?.parentNode?.removeChild(canvas);
-    renderer = undefined;
-    canvas = undefined;
-  });
-
-  it('keeps the triangle visible with no registered render features', async () => {
-    canvas = document.createElement('canvas');
-    canvas.width = 200;
-    canvas.height = 150;
-    document.body.appendChild(canvas);
-
-    renderer = await Engine.create(canvas, {}, { shaderManifestUrl: '/shaders/manifest.json' });
-    const ready = await renderer.ready;
-    expect(ready.ok).toBe(true);
-
-    const errors: Array<{ code: string; hint: string }> = [];
-    renderer.onError((error) => errors.push({ code: error.code, hint: error.hint }));
-    const world = makeBaselineWorld();
-    expect(renderer.attachWorld(world).ok).toBe(true);
-    for (let frame = 0; frame < 8; frame += 1) {
-      world.update(1 / 60).unwrap();
-      expect(renderer.draw([world], { cameraOwner: 0, resourceOwner: 0 }).ok).toBe(true);
-      await new Promise<void>((resolve) => requestAnimationFrame(() => resolve()));
-    }
-
-    // Browser test isolation may retire a device after this renderer's frame
-    // work completes. That intentional teardown is already distinguished by
-    // the renderer's structured hint; every SUT-attributable error remains a
-    // hard failure here.
-    expect(
-      errors.filter(
-        (error) => !(error.code === 'device-lost' && error.hint.includes('reason: destroyed')),
-      ),
-    ).toEqual([]);
-    expect(renderer.renderFeatureDiagnostics()).toEqual([]);
-    const expectedPassNames = [
-      'gpu-driven.view-reset',
-      'gpu-driven.frustum-compact',
-      'gpu-driven.finalize-indirect',
-      'directional-shadow-reset',
-      'shadowCascade0',
-      'shadowCascade1',
-      'shadowCascade2',
-      'shadowCascade3',
-      'directional-shadow-observation',
-      'spot-shadow',
-      'skybox',
-      'main',
-      'linear-hdr-observation',
-      'bloom-bright',
-      'bloom-blur-h',
-      'bloom-blur-v',
-      'bloom-composite',
-      'tonemap',
-      'fxaa',
-      'debug-overlay',
-    ];
-    const passNames = renderer.perFramePassNames;
-    expect(passNames).toHaveLength(expectedPassNames.length);
-    expect(passNames).toEqual(expect.arrayContaining(expectedPassNames));
-    const passIndex = (name: string) => passNames.indexOf(name);
-    expect(passIndex('gpu-driven.view-reset')).toBeLessThan(passIndex('directional-shadow-reset'));
-    expect(passIndex('gpu-driven.frustum-compact')).toBeLessThan(
-      passIndex('directional-shadow-reset'),
-    );
-    expect(passIndex('gpu-driven.finalize-indirect')).toBeLessThan(
-      passIndex('directional-shadow-reset'),
-    );
-    expect(passIndex('directional-shadow-reset')).toBeLessThan(passIndex('shadowCascade0'));
-    expect(passIndex('shadowCascade3')).toBeLessThan(passIndex('directional-shadow-observation'));
-
-    const pixels = await renderer.readPixels();
-    expect(pixels.ok).toBe(true);
-    if (pixels.ok) expect(distanceFromClear(pixels.value)).toBeGreaterThan(0.05);
-  });
-});