@agent-native/toolkit 0.201.1 → 0.202.0-nightly-20261006033736

package/src/app/shared/ocean/renderer.spec.ts

@@ -0,0 +1,100 @@
+import { frame, init, target } from "vgpu/mock";
+import { describe, expect, it } from "vitest";
+
+import type { OceanColors } from "./ocean-colors.js";
+import { createIfftStageTable, OCEAN_RESOLUTION } from "./ocean-graph.js";
+import {
+  bloomSizes,
+  createGraph,
+  destroyGraph,
+  renderGraph,
+  setPresentColors,
+} from "./renderer.js";
+
+const DARK: OceanColors = { fg: [0.68, 0.68, 0.67], bg: [0.04, 0.04, 0.04] };
+const LIGHT: OceanColors = { fg: [0.24, 0.24, 0.24], bg: [0.98, 0.98, 0.96] };
+
+async function mockOutput(size: readonly [number, number] = [320, 180]) {
+  const gpu = await init();
+  const output = target(gpu, { size, format: "rgba8unorm", label: "test-out" });
+  return { gpu, output };
+}
+
+describe("ocean IFFT stage table", () => {
+  it("describes a full 18-pass Stockham transform over both axes", () => {
+    const stages = createIfftStageTable();
+    expect(stages).toHaveLength(18);
+    expect(stages.filter((s) => s.horizontal)).toHaveLength(9);
+    expect(2 ** 9).toBe(OCEAN_RESOLUTION);
+  });
+
+  it("never reads and writes the same target within a stage", () => {
+    for (const stage of createIfftStageTable()) {
+      expect(stage.input).not.toBe(stage.output);
+    }
+  });
+
+  it("doubles the subtransform size on each axis stage", () => {
+    const horizontal = createIfftStageTable().filter((s) => s.horizontal);
+    expect(horizontal.map((s) => s.subtransformSize)).toEqual([
+      2, 4, 8, 16, 32, 64, 128, 256, 512,
+    ]);
+  });
+});
+
+describe("bloom pyramid sizing", () => {
+  it("halves each level and never collapses to zero", () => {
+    for (const size of bloomSizes([320, 180])) {
+      expect(size[0]).toBeGreaterThan(0);
+      expect(size[1]).toBeGreaterThan(0);
+    }
+  });
+
+  it("stays above zero for a degenerate one-pixel output", () => {
+    for (const size of bloomSizes([1, 1])) {
+      expect(size[0]).toBeGreaterThan(0);
+      expect(size[1]).toBeGreaterThan(0);
+    }
+  });
+});
+
+describe("ocean graph", () => {
+  it("builds and renders every pass without throwing", async () => {
+    const { gpu, output } = await mockOutput();
+    const graph = await createGraph(gpu, output, "test", DARK);
+    await frame(gpu, (current) => renderGraph(current, graph, output));
+    destroyGraph(graph);
+    gpu.dispose();
+  });
+
+  it("retunes present colours in place without rebuilding the graph", async () => {
+    const { gpu, output } = await mockOutput();
+    const graph = await createGraph(gpu, output, "test", DARK);
+    const before = graph.simulation.spectrum;
+
+    setPresentColors(graph, LIGHT);
+    await frame(gpu, (current) => renderGraph(current, graph, output));
+
+    expect(graph.simulation.spectrum).toBe(before);
+    destroyGraph(graph);
+    gpu.dispose();
+  });
+
+  it("renders when foreground and background are identical", async () => {
+    const { gpu, output } = await mockOutput();
+    const flat: OceanColors = { fg: [0.5, 0.5, 0.5], bg: [0.5, 0.5, 0.5] };
+    const graph = await createGraph(gpu, output, "test", flat);
+    await frame(gpu, (current) => renderGraph(current, graph, output));
+    destroyGraph(graph);
+    gpu.dispose();
+  });
+
+  it("rejects rather than returning a half-built graph when a pass cannot compile", async () => {
+    const { gpu, output } = await mockOutput();
+    const unrenderable = { ...output, format: "depth24plus" } as never;
+    await expect(
+      createGraph(gpu, unrenderable, "test", DARK),
+    ).rejects.toBeDefined();
+    gpu.dispose();
+  });
+});