@forgeax/engine-render 0.1.28 → 0.1.30

package/src/temporal/view.ts

@@ -28,6 +28,9 @@ export interface TemporalViewInput {
   readonly antialias: Antialias;
   readonly width: number;
   readonly height: number;
+  /** Internal scene extent used to normalize TAA jitter for TAAU. */
+  readonly internalWidth?: number;
+  readonly internalHeight?: number;
   readonly frameIndex?: number;
   readonly historyVersion?: number;
   readonly viewIdentity?: string;
@@ -47,6 +50,9 @@ interface TemporalViewSnapshot {
   readonly antialias: Antialias;
   readonly width: number;
   readonly height: number;
+  /** Internal scene extent used for TAAU jitter normalization. */
+  readonly internalWidth: number;
+  readonly internalHeight: number;
   readonly frameIndex: number;
   readonly historyVersion: number;
   readonly viewIdentity: string;
@@ -93,6 +99,8 @@ function validDimension(value: number, field: string): number {
 export function createTemporalView(input: TemporalViewInput): TemporalView {
   const width = validDimension(input.width, 'width');
   const height = validDimension(input.height, 'height');
+  const internalWidth = validDimension(input.internalWidth ?? width, 'internalWidth');
+  const internalHeight = validDimension(input.internalHeight ?? height, 'internalHeight');
   const historyVersion = input.historyVersion ?? 0;
   const frameIndex = input.frameIndex ?? 0;
   const deviceGeneration = input.deviceGeneration ?? 0;
@@ -109,6 +117,8 @@ export function createTemporalView(input: TemporalViewInput): TemporalView {
     ...input,
     width,
     height,
+    internalWidth,
+    internalHeight,
     frameIndex,
     historyVersion,
     viewIdentity: input.viewIdentity ?? 'camera:default',
@@ -135,11 +145,11 @@ export function createTemporalView(input: TemporalViewInput): TemporalView {
     jitterCancellationUv:
       jitter === undefined
         ? undefined
-        : (Object.freeze([jitter[0] / width, jitter[1] / height]) as Jitter),
+        : (Object.freeze([jitter[0] / internalWidth, jitter[1] / internalHeight]) as Jitter),
     currentJitterUv:
       jitter === undefined
         ? undefined
-        : (Object.freeze([jitter[0] / width, jitter[1] / height]) as Jitter),
+        : (Object.freeze([jitter[0] / internalWidth, jitter[1] / internalHeight]) as Jitter),
     historyValid: normalized.historyValid,
     temporalFrameIndex: frameIndex,
     currentUnjitteredViewProjection: input.currentUnjitteredViewProjection,

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

@@ -20,6 +20,7 @@ import {
 import { constructRendererHost, type RhiBackendPack } from '../../construct-renderer';
 import { Materials } from '../../materials';
 import { DEFAULT_STANDARD_PROFILE } from '../../pipeline/standard-profile';
+import type { FrameReceipt } from '../../render-contract';
 
 const WIDTH = 32;
 const HEIGHT = 32;
@@ -30,6 +31,10 @@ const BUFFER_USAGE_COPY_DST = 0x0008;
 const GPU_MAP_MODE_READ = 0x0001;
 const TEST_REACTIVE = 0;
 const LIGHTWEIGHT_DAWN = process.env.FORGEAX_DAWN_LIGHTWEIGHT === '1';
+const ROSTER_SMOKE = process.env.FORGEAX_DAWN_ROSTER_SMOKE === '1';
+const requestedSmokeFrames = Number.parseInt(process.env.SMOKE_MIN_FRAMES ?? '300', 10);
+const ROSTER_SMOKE_FRAMES =
+  Number.isInteger(requestedSmokeFrames) && requestedSmokeFrames > 0 ? requestedSmokeFrames : 300;
 
 const ENGINE_MANIFEST = await (async () => {
   const { buildEngineShaderManifest } = await import('@forgeax/engine-vite-plugin-shader');
@@ -106,11 +111,15 @@ async function readCenter(
   ];
 }
 
-async function renderCase(testCase: TransmissionCase): Promise<{
+async function renderCase(
+  testCase: TransmissionCase,
+  frameCount = 1,
+): Promise<{
   readonly pixel: readonly [number, number, number, number];
   readonly passNames: readonly string[];
   readonly observation: boolean;
   readonly errors: readonly string[];
+  readonly framesObserved: number;
 }> {
   let device: GPUDevice | undefined;
   let configuredDevice: GPUDevice | undefined;
@@ -181,150 +190,169 @@ async function renderCase(testCase: TransmissionCase): Promise<{
   const unsubscribe = renderer.subscribe((event) => {
     if (event.kind === 'error') errors.push(event.error.code);
   });
-  const world = new World();
-  const lease = renderer.attach(world);
-  if (!lease.ok) throw lease.error;
-  const plane = createPlaneGeometry(2, 2);
-  if (!plane.ok) throw plane.error;
-  const mesh = world.allocSharedRef('MeshAsset', {
-    ...plane.value,
-    materialSlots: [{ slotName: 'Default' }],
-  });
-  const transmissionHandle =
-    testCase.transmissionTexture === undefined
-      ? undefined
-      : world.allocSharedRef('TextureAsset', textureAsset(testCase.transmissionTexture));
-  const thicknessHandle =
-    testCase.thicknessTexture === undefined
-      ? undefined
-      : world.allocSharedRef('TextureAsset', textureAsset(testCase.thicknessTexture));
-  const material = Materials.standard({
-    baseColor: [0.7, 0.8, 0.9, testCase.masked ? 0.35 : 1],
-    metallic: 0,
-    roughness: testCase.roughness,
-    transmission: testCase.transmission,
-    ior: testCase.ior,
-    thickness: testCase.thickness,
-    attenuationColor: testCase.attenuationColor,
-    castShadow: false,
-    ...(testCase.attenuationDistance === undefined
-      ? {}
-      : { attenuationDistance: testCase.attenuationDistance }),
-    ...(testCase.masked
-      ? {
-          queue: 2450,
-          alphaCutoff: 0.5,
-          baseColorTexture: {
-            texture: world.allocSharedRef('TextureAsset', {
-              kind: 'texture',
-              width: 2,
-              height: 2,
-              format: 'rgba8unorm',
-              data: Uint8Array.from([
-                255, 255, 255, 0, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 0,
-              ]),
-              colorSpace: 'linear',
-              mipmap: false,
-            }),
-          },
-        }
-      : { queue: 2000 }),
-    ...(testCase.surfaceQuat === undefined ? {} : { renderState: { cullMode: 'none' as const } }),
-    ...(transmissionHandle === undefined
-      ? {}
-      : { transmissionTexture: { texture: transmissionHandle as never } }),
-    ...(thicknessHandle === undefined
-      ? {}
-      : { thicknessTexture: { texture: thicknessHandle as never } }),
-  });
-  const materialHandle = world.allocSharedRef('MaterialAsset', material);
-  const meshEntity = world.spawn(
-    {
-      component: Transform,
-      data: testCase.surfaceQuat === undefined ? {} : { quat: testCase.surfaceQuat },
-    },
-    { component: MeshFilter, data: { assetHandle: mesh } },
-    { component: MeshRenderer, data: { materials: [materialHandle] } },
-  );
-  expect(meshEntity.ok, `${testCase.name}: mesh spawn must succeed`).toBe(true);
-  if (!meshEntity.ok) throw meshEntity.error;
-  if (testCase.overlap) {
-    const overlay = Materials.unlit([0.1, 0.9, 0.2, 0.35], {
+  try {
+    const world = new World();
+    const lease = renderer.attach(world);
+    if (!lease.ok) throw lease.error;
+    const plane = createPlaneGeometry(2, 2);
+    if (!plane.ok) throw plane.error;
+    const mesh = world.allocSharedRef('MeshAsset', {
+      ...plane.value,
+      materialSlots: [{ slotName: 'Default' }],
+    });
+    const transmissionHandle =
+      testCase.transmissionTexture === undefined
+        ? undefined
+        : world.allocSharedRef('TextureAsset', textureAsset(testCase.transmissionTexture));
+    const thicknessHandle =
+      testCase.thicknessTexture === undefined
+        ? undefined
+        : world.allocSharedRef('TextureAsset', textureAsset(testCase.thicknessTexture));
+    const material = Materials.standard({
+      baseColor: [0.7, 0.8, 0.9, testCase.masked ? 0.35 : 1],
+      metallic: 0,
+      roughness: testCase.roughness,
+      transmission: testCase.transmission,
+      ior: testCase.ior,
+      thickness: testCase.thickness,
+      attenuationColor: testCase.attenuationColor,
       castShadow: false,
-      queue: 3000,
-      renderState: {
-        cullMode: 'none',
-        depthWriteEnabled: false,
-        blend: {
-          color: { srcFactor: 'src-alpha', dstFactor: 'one-minus-src-alpha', operation: 'add' },
-          alpha: { srcFactor: 'one', dstFactor: 'one-minus-src-alpha', operation: 'add' },
-        },
-      },
+      ...(testCase.attenuationDistance === undefined
+        ? {}
+        : { attenuationDistance: testCase.attenuationDistance }),
+      ...(testCase.masked
+        ? {
+            queue: 2450,
+            alphaCutoff: 0.5,
+            baseColorTexture: {
+              texture: world.allocSharedRef('TextureAsset', {
+                kind: 'texture',
+                width: 2,
+                height: 2,
+                format: 'rgba8unorm',
+                data: Uint8Array.from([
+                  255, 255, 255, 0, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 0,
+                ]),
+                colorSpace: 'linear',
+                mipmap: false,
+              }),
+            },
+          }
+        : { queue: 2000 }),
+      ...(testCase.surfaceQuat === undefined ? {} : { renderState: { cullMode: 'none' as const } }),
+      ...(transmissionHandle === undefined
+        ? {}
+        : { transmissionTexture: { texture: transmissionHandle as never } }),
+      ...(thicknessHandle === undefined
+        ? {}
+        : { thicknessTexture: { texture: thicknessHandle as never } }),
     });
-    const overlayHandle = world.allocSharedRef('MaterialAsset', overlay);
-    const overlayEntity = world.spawn(
-      { component: Transform, data: { pos: [0, 0, -0.1] } },
+    const materialHandle = world.allocSharedRef('MaterialAsset', material);
+    const meshEntity = world.spawn(
+      {
+        component: Transform,
+        data: testCase.surfaceQuat === undefined ? {} : { quat: testCase.surfaceQuat },
+      },
       { component: MeshFilter, data: { assetHandle: mesh } },
-      { component: MeshRenderer, data: { materials: [overlayHandle] } },
+      { component: MeshRenderer, data: { materials: [materialHandle] } },
     );
-    expect(overlayEntity.ok, `${testCase.name}: overlay spawn must succeed`).toBe(true);
-    if (!overlayEntity.ok) throw overlayEntity.error;
-  }
-  const cameraEntity = world.spawn(
-    { component: Transform, data: { pos: [0, 0, 3] } },
-    {
-      component: Camera,
-      data: {
-        fov: Math.PI / 4,
-        aspect: 1,
-        near: 0.1,
-        far: 10,
-        tonemap: TONEMAP_LINEAR,
-        clearColor: [0.05, 0.1, 0.15, 1],
+    expect(meshEntity.ok, `${testCase.name}: mesh spawn must succeed`).toBe(true);
+    if (!meshEntity.ok) throw meshEntity.error;
+    if (testCase.overlap) {
+      const overlay = Materials.unlit([0.1, 0.9, 0.2, 0.35], {
+        castShadow: false,
+        queue: 3000,
+        renderState: {
+          cullMode: 'none',
+          depthWriteEnabled: false,
+          blend: {
+            color: { srcFactor: 'src-alpha', dstFactor: 'one-minus-src-alpha', operation: 'add' },
+            alpha: { srcFactor: 'one', dstFactor: 'one-minus-src-alpha', operation: 'add' },
+          },
+        },
+      });
+      const overlayHandle = world.allocSharedRef('MaterialAsset', overlay);
+      const overlayEntity = world.spawn(
+        { component: Transform, data: { pos: [0, 0, -0.1] } },
+        { component: MeshFilter, data: { assetHandle: mesh } },
+        { component: MeshRenderer, data: { materials: [overlayHandle] } },
+      );
+      expect(overlayEntity.ok, `${testCase.name}: overlay spawn must succeed`).toBe(true);
+      if (!overlayEntity.ok) throw overlayEntity.error;
+    }
+    const cameraEntity = world.spawn(
+      { component: Transform, data: { pos: [0, 0, 3] } },
+      {
+        component: Camera,
+        data: {
+          fov: Math.PI / 4,
+          aspect: 1,
+          near: 0.1,
+          far: 10,
+          tonemap: TONEMAP_LINEAR,
+          clearColor: [0.05, 0.1, 0.15, 1],
+        },
       },
-    },
-  );
-  expect(cameraEntity.ok, `${testCase.name}: camera spawn must succeed`).toBe(true);
-  if (!cameraEntity.ok) throw cameraEntity.error;
-  if (testCase.directionalLight !== false) {
-    const lightEntity = world.spawn({
-      component: DirectionalLight,
-      data: { direction: [0, 0, -1], color: [1, 1, 1], intensity: 1, castShadow: false },
-    });
-    expect(lightEntity.ok, `${testCase.name}: light spawn must succeed`).toBe(true);
-    if (!lightEntity.ok) throw lightEntity.error;
-  }
-  if (testCase.localLight === true) {
-    const localLightEntity = world.spawn(
-      { component: Transform, data: { pos: [0, 0, 1] } },
-      { component: PointLight, data: { intensity: 8, range: 10 } },
     );
-    expect(localLightEntity.ok, `${testCase.name}: local light spawn must succeed`).toBe(true);
-    if (!localLightEntity.ok) throw localLightEntity.error;
+    expect(cameraEntity.ok, `${testCase.name}: camera spawn must succeed`).toBe(true);
+    if (!cameraEntity.ok) throw cameraEntity.error;
+    if (testCase.directionalLight !== false) {
+      const lightEntity = world.spawn({
+        component: DirectionalLight,
+        data: { direction: [0, 0, -1], color: [1, 1, 1], intensity: 1, castShadow: false },
+      });
+      expect(lightEntity.ok, `${testCase.name}: light spawn must succeed`).toBe(true);
+      if (!lightEntity.ok) throw lightEntity.error;
+    }
+    if (testCase.localLight === true) {
+      const localLightEntity = world.spawn(
+        { component: Transform, data: { pos: [0, 0, 1] } },
+        { component: PointLight, data: { intensity: 8, range: 10 } },
+      );
+      expect(localLightEntity.ok, `${testCase.name}: local light spawn must succeed`).toBe(true);
+      if (!localLightEntity.ok) throw localLightEntity.error;
+    }
+    if (!Number.isSafeInteger(frameCount) || frameCount < 1)
+      throw new Error(`invalid transmission frame count: ${frameCount}`);
+    world.update().unwrap();
+    let lastDraw: FrameReceipt | undefined;
+    for (let frame = 0; frame < frameCount; frame += 1) {
+      if (frame > 0) world.update(1 / 60).unwrap();
+      const drawn = renderer.draw({
+        leases: [lease.value],
+        camera: { lease: lease.value },
+        environment: { lease: lease.value },
+      });
+      expect(drawn.ok, drawn.ok ? undefined : JSON.stringify(drawn.error)).toBe(true);
+      if (!drawn.ok) throw drawn.error;
+      const completed = await drawn.value.completed;
+      expect(completed.ok, completed.ok ? undefined : JSON.stringify(completed.error)).toBe(true);
+      if (!completed.ok) throw completed.error;
+      lastDraw = drawn.value;
+    }
+    if (lastDraw === undefined) throw new Error('transmission smoke did not submit a frame');
+    const observation = await renderer.observe(lastDraw, { include: ['draws', 'bindings'] });
+    expect(observation.ok).toBe(true);
+    await device.queue.onSubmittedWorkDone();
+    if (target === undefined) throw new Error('render target was not configured after draw');
+    const renderDevice = configuredDevice ?? device;
+    const passNames = renderer.inspect().perFramePassNames;
+    expect(renderer.inspect().renderScene.projectionRecords).toBeGreaterThanOrEqual(1);
+    return {
+      pixel: await readCenter(renderDevice, target),
+      passNames,
+      observation: observation.ok,
+      errors,
+      framesObserved: frameCount,
+    };
+  } finally {
+    unsubscribe();
+    await device.queue.onSubmittedWorkDone();
+    await renderer.dispose();
+    target?.destroy();
+    device.destroy();
+    expect((await device.lost).reason).toBe('destroyed');
   }
-  world.update().unwrap();
-  const drawn = renderer.draw({
-    leases: [lease.value],
-    camera: { lease: lease.value },
-    environment: { lease: lease.value },
-  });
-  expect(drawn.ok, drawn.ok ? undefined : JSON.stringify(drawn.error)).toBe(true);
-  if (!drawn.ok) throw drawn.error;
-  await drawn.value.completed;
-  const observation = await renderer.observe(drawn.value, { include: ['draws', 'bindings'] });
-  expect(observation.ok).toBe(true);
-  await device.queue.onSubmittedWorkDone();
-  if (target === undefined) throw new Error('render target was not configured after draw');
-  const renderDevice = configuredDevice ?? device;
-  const passNames = renderer.inspect().perFramePassNames;
-  expect(renderer.inspect().renderScene.projectionRecords).toBeGreaterThanOrEqual(1);
-  unsubscribe();
-  return {
-    pixel: await readCenter(renderDevice, target),
-    passNames,
-    observation: observation.ok,
-    errors,
-  };
 }
 
 function luma(pixel: readonly [number, number, number, number]): number {
@@ -332,6 +360,30 @@ function luma(pixel: readonly [number, number, number, number]): number {
 }
 
 describe('Standard transmission Dawn ROI', () => {
+  it('completes a 300-frame transmission stream without renderer errors', async () => {
+    const result = await renderCase(
+      {
+        name: 'sustained-transmission',
+        transmission: 1,
+        ior: 1.5,
+        thickness: 0.5,
+        roughness: 0.3,
+        attenuationColor: [0.7, 0.8, 0.9],
+        attenuationDistance: 2,
+        renderPath: 'forward',
+      },
+      300,
+    );
+    expect(result.framesObserved).toBe(300);
+    expect(result.errors).toEqual([]);
+    expect(result.observation).toBe(true);
+    expect(result.passNames).toContain('transmission-forward');
+    expect(result.pixel.every(Number.isFinite)).toBe(true);
+    process.stdout.write(
+      `[transmission-smoke-frames] ${JSON.stringify({ framesObserved: result.framesObserved })}\n`,
+    );
+  }, 120_000);
+
   it('uses linear HDR observation and responds to F0, Beer, texture, TIR, and fallback inputs', async () => {
     const baseline = await renderCase({
       name: 'baseline',
@@ -420,7 +472,10 @@ describe('Standard transmission Dawn ROI', () => {
     // Dawn lane keeps the low/high IOR and roughness boundaries, while the
     // full local/nightly lane retains the thickness case as well.
     const selectedCases = LIGHTWEIGHT_DAWN ? [fullCases[0], fullCases[1], fullCases[3]] : fullCases;
-    const cases = await Promise.all(selectedCases.map((testCase) => renderCase(testCase)));
+    // Each fixture temporarily owns navigator.gpu.requestAdapter. Run it to
+    // completion before installing the next hook or allocating its device.
+    const cases = [];
+    for (const testCase of selectedCases) cases.push(await renderCase(testCase));
     for (const result of cases) expect(result.pixel.every(Number.isFinite)).toBe(true);
     expect(cases[1]?.pixel).not.toEqual(cases[0]?.pixel);
     if (!LIGHTWEIGHT_DAWN) expect(cases[2]?.pixel).not.toEqual(cases[0]?.pixel);
@@ -480,4 +535,29 @@ describe('Standard transmission Dawn ROI', () => {
     expect(clustered.observation).toBe(true);
     expect(clustered.errors).toEqual([]);
   }, 120_000);
+
+  if (ROSTER_SMOKE) {
+    it('emits the canonical 300-frame Dawn roster receipt', async () => {
+      const result = await renderCase(
+        {
+          name: 'roster-stability',
+          transmission: 1,
+          ior: 1.5,
+          thickness: 0.5,
+          roughness: 0.4,
+          attenuationColor: [0.7, 0.8, 0.9],
+          attenuationDistance: 2,
+          renderPath: 'forward',
+        },
+        ROSTER_SMOKE_FRAMES,
+      );
+      expect(result.framesObserved).toBeGreaterThanOrEqual(300);
+      expect(result.observation).toBe(true);
+      expect(result.errors).toEqual([]);
+      process.stdout.write(`[smoke] frames observed=${result.framesObserved}\n`);
+      process.stdout.write(
+        `[smoke] PASS - transmission stability frames=${result.framesObserved}\n`,
+      );
+    }, 120_000);
+  }
 });