@forgeax/engine-rhi-webgpu 0.1.2

package/src/__tests__/queue-write-range.browser.test.ts

@@ -0,0 +1,60 @@
+import type { RhiDevice } from '@forgeax/engine-rhi';
+import { describe, expect, it } from 'vitest';
+import { rhi } from '../index';
+
+async function requestRhiDevice(): Promise<RhiDevice | undefined> {
+  if (typeof navigator === 'undefined' || navigator.gpu === undefined) return undefined;
+  const adapter = await rhi.requestAdapter();
+  expect(adapter.ok).toBe(true);
+  if (!adapter.ok) return undefined;
+  const device = await adapter.value.requestDevice();
+  expect(device.ok).toBe(true);
+  if (!device.ok) return undefined;
+  return device.value;
+}
+
+describe('browser WebGPU queue.writeBuffer typed range', () => {
+  it('round-trips the exact selected typed-array elements', async () => {
+    const device = await requestRhiDevice();
+    if (device === undefined) return;
+    const target = device.createBuffer({
+      label: 'browser-write-range-target',
+      size: 32,
+      usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.COPY_SRC,
+    });
+    const readback = device.createBuffer({
+      label: 'browser-write-range-readback',
+      size: 32,
+      usage: GPUBufferUsage.MAP_READ | GPUBufferUsage.COPY_DST,
+    });
+    expect(target.ok && readback.ok).toBe(true);
+    if (!target.ok || !readback.ok) return;
+
+    const write = device.queue.writeBuffer(
+      target.value,
+      0,
+      new Float32Array([10, 20, 30, 40]),
+      1,
+      2,
+    );
+    expect(write.ok).toBe(true);
+    if (!write.ok) return;
+    const encoder = device.createCommandEncoder({ label: 'browser-write-range-copy' });
+    expect(encoder.ok).toBe(true);
+    if (!encoder.ok) return;
+    encoder.value.copyBufferToBuffer(target.value, 0, readback.value, 0, 32);
+    const finish = encoder.value.finish();
+    expect(finish.ok).toBe(true);
+    if (!finish.ok) return;
+    expect(device.queue.submit([finish.value]).ok).toBe(true);
+    await device.queue.onSubmittedWorkDone();
+    const mapped = await readback.value.mapAsync(GPUMapMode.READ);
+    expect(mapped.ok).toBe(true);
+    if (!mapped.ok) return;
+    const range = mapped.value.getMappedRange();
+    expect(range.ok).toBe(true);
+    if (!range.ok) return;
+    expect(Array.from(new Float32Array(range.value.slice(0)))).toEqual([20, 30, 0, 0, 0, 0, 0, 0]);
+    mapped.value.unmap();
+  });
+});

package/src/__tests__/rgba16float-live-probe.browser.test.ts

@@ -0,0 +1,13 @@
+import { describe, expect, it } from 'vitest';
+import { runRgba16floatLiveProbe } from './rgba16float-live-probe';
+
+describe('browser rgba16float live render/readback/recovery probe', () => {
+  it('reads the packed render target on the initial and fresh recovery device', async () => {
+    const evidence = await runRgba16floatLiveProbe();
+    expect(evidence.backend).toBe('webgpu');
+    expect(evidence.initial.pixel).toEqual([0.25, 0.5, 0.75, 1]);
+    expect(evidence.loss.reason).toBe('destroyed');
+    expect(evidence.recovered.pixel).toEqual(evidence.initial.pixel);
+    expect(typeof evidence.initial.timestampQuery).toBe('boolean');
+  });
+});

package/src/__tests__/rgba16float-live-probe.dawn.test.ts

@@ -0,0 +1,15 @@
+import { describe, expect, it } from 'vitest';
+import { runRgba16floatLiveProbe } from './rgba16float-live-probe';
+
+describe('Dawn rgba16float live render/readback/recovery probe', () => {
+  it('reads the packed render target on the initial and fresh recovery device', async () => {
+    const evidence = await runRgba16floatLiveProbe();
+    expect(evidence.backend).toBe('webgpu');
+    expect(evidence.initial.pixel).toEqual([0.25, 0.5, 0.75, 1]);
+    expect(evidence.loss.reason).toBe('destroyed');
+    expect(evidence.recovered.pixel).toEqual(evidence.initial.pixel);
+    expect(typeof evidence.initial.timestampQuery).toBe('boolean');
+    // biome-ignore lint/suspicious/noConsole: emitted as live Dawn admission evidence
+    console.log(JSON.stringify({ kind: 'rgba16float-live-probe', ...evidence }));
+  });
+});

package/src/__tests__/rgba16float-live-probe.ts

@@ -0,0 +1,44 @@
+import type { RhiDevice } from '@forgeax/engine-rhi';
+import {
+  probeRgba16floatRenderTarget,
+  type Rgba16floatRenderTargetProbe,
+} from '@forgeax/engine-rhi';
+import { _internal_getRawDevice, rhi } from '../index';
+
+export interface Rgba16floatLiveProbeEvidence {
+  readonly backend: string;
+  readonly initial: Rgba16floatRenderTargetProbe;
+  readonly loss: { readonly reason: 'destroyed' | 'unknown'; readonly message: string };
+  readonly recovered: Rgba16floatRenderTargetProbe;
+}
+
+async function probeFreshDevice(): Promise<{
+  readonly backend: string;
+  readonly device: RhiDevice;
+  readonly report: Rgba16floatRenderTargetProbe;
+}> {
+  const adapter = await rhi.requestAdapter();
+  if (!adapter.ok) throw adapter.error;
+  const device = await adapter.value.requestDevice();
+  if (!device.ok) throw device.error;
+  const probed = await probeRgba16floatRenderTarget(device.value);
+  if (!probed.ok) throw probed.error;
+  return { backend: device.value.caps.backendKind, device: device.value, report: probed.value };
+}
+
+export async function runRgba16floatLiveProbe(): Promise<Rgba16floatLiveProbeEvidence> {
+  const initial = await probeFreshDevice();
+  const rawDevice = _internal_getRawDevice(initial.device);
+  if (rawDevice === undefined)
+    throw new Error('live WebGPU probe requires its backend-owned device');
+  const lost = initial.device.lost;
+  rawDevice.destroy();
+  const loss = await lost;
+  const recovered = await probeFreshDevice();
+  return {
+    backend: initial.backend,
+    initial: initial.report,
+    loss,
+    recovered: recovered.report,
+  };
+}