@forgeax/engine-runtime 0.1.3 → 0.1.6

package/src/__tests__/fog-producer-manifest.ts

@@ -1,162 +0,0 @@
-export type FogProducerCase = {
-  readonly id: string;
-  readonly sourceFile: string;
-  readonly entryPoint: string;
-  readonly domain:
-    | 'urp-scene'
-    | 'hdrp-deferred'
-    | 'hdrp-forward'
-    | 'skybox'
-    | 'sprite'
-    | 'text'
-    | 'vfx';
-  readonly rayPolicy:
-    | 'perspective-world'
-    | 'orthographic-plane'
-    | 'inverse-view-projection'
-    | 'camera-far';
-  readonly alphaPolicy: 'preserve';
-};
-
-export const FOG_PRODUCER_MANIFEST_VERSION = 1 as const;
-
-export const FOG_PRODUCER_MANIFEST = [
-  {
-    id: 'urp-pbr-opaque',
-    sourceFile: 'default-standard-pbr.wgsl',
-    entryPoint: 'fs_main',
-    domain: 'urp-scene',
-    rayPolicy: 'perspective-world',
-    alphaPolicy: 'preserve',
-  },
-  {
-    id: 'urp-pbr-masked',
-    sourceFile: 'default-standard-pbr.wgsl',
-    entryPoint: 'fs_main',
-    domain: 'urp-scene',
-    rayPolicy: 'perspective-world',
-    alphaPolicy: 'preserve',
-  },
-  {
-    id: 'urp-pbr-skin',
-    sourceFile: 'default-standard-pbr-skin.wgsl',
-    entryPoint: 'fs_main',
-    domain: 'urp-scene',
-    rayPolicy: 'perspective-world',
-    alphaPolicy: 'preserve',
-  },
-  {
-    id: 'urp-pbr-morph',
-    sourceFile: 'default-standard-pbr.wgsl',
-    entryPoint: 'fs_main',
-    domain: 'urp-scene',
-    rayPolicy: 'perspective-world',
-    alphaPolicy: 'preserve',
-  },
-  {
-    id: 'urp-pbr-instances',
-    sourceFile: 'default-standard-pbr.wgsl',
-    entryPoint: 'fs_main',
-    domain: 'urp-scene',
-    rayPolicy: 'perspective-world',
-    alphaPolicy: 'preserve',
-  },
-  {
-    id: 'urp-unlit',
-    sourceFile: 'unlit.wgsl',
-    entryPoint: 'fs_main',
-    domain: 'urp-scene',
-    rayPolicy: 'perspective-world',
-    alphaPolicy: 'preserve',
-  },
-  {
-    id: 'hdrp-deferred',
-    sourceFile: 'hdrp-deferred-lighting.wgsl',
-    entryPoint: 'fs_lighting',
-    domain: 'hdrp-deferred',
-    rayPolicy: 'inverse-view-projection',
-    alphaPolicy: 'preserve',
-  },
-  {
-    id: 'hdrp-forward',
-    sourceFile: 'default-standard-pbr.wgsl',
-    entryPoint: 'fs_main',
-    domain: 'hdrp-forward',
-    rayPolicy: 'perspective-world',
-    alphaPolicy: 'preserve',
-  },
-  {
-    id: 'transparent',
-    sourceFile: 'default-standard-pbr.wgsl',
-    entryPoint: 'fs_main',
-    domain: 'hdrp-forward',
-    rayPolicy: 'perspective-world',
-    alphaPolicy: 'preserve',
-  },
-  {
-    id: 'sprite',
-    sourceFile: 'sprite.wgsl',
-    entryPoint: 'fs_main',
-    domain: 'sprite',
-    rayPolicy: 'perspective-world',
-    alphaPolicy: 'preserve',
-  },
-  {
-    id: 'text',
-    sourceFile: 'msdf-text.wgsl',
-    entryPoint: 'fs_main',
-    domain: 'text',
-    rayPolicy: 'perspective-world',
-    alphaPolicy: 'preserve',
-  },
-  {
-    id: 'skybox',
-    sourceFile: 'skybox.wgsl',
-    entryPoint: 'skybox_fs',
-    domain: 'skybox',
-    rayPolicy: 'camera-far',
-    alphaPolicy: 'preserve',
-  },
-  {
-    id: 'vfx-billboard',
-    sourceFile: 'vfx-render/billboard.wgsl',
-    entryPoint: 'fs_main',
-    domain: 'vfx',
-    rayPolicy: 'perspective-world',
-    alphaPolicy: 'preserve',
-  },
-  {
-    id: 'vfx-mesh',
-    sourceFile: 'vfx-render/mesh.wgsl',
-    entryPoint: 'fs_main',
-    domain: 'vfx',
-    rayPolicy: 'perspective-world',
-    alphaPolicy: 'preserve',
-  },
-  {
-    id: 'vfx-ribbon',
-    sourceFile: 'vfx-render/ribbon.wgsl',
-    entryPoint: 'fs_main',
-    domain: 'vfx',
-    rayPolicy: 'perspective-world',
-    alphaPolicy: 'preserve',
-  },
-  {
-    id: 'vfx-trail',
-    sourceFile: 'vfx-render/trail.wgsl',
-    entryPoint: 'fs_main',
-    domain: 'vfx',
-    rayPolicy: 'perspective-world',
-    alphaPolicy: 'preserve',
-  },
-  {
-    id: 'vfx-beam',
-    sourceFile: 'vfx-render/beam.wgsl',
-    entryPoint: 'fs_main',
-    domain: 'vfx',
-    rayPolicy: 'perspective-world',
-    alphaPolicy: 'preserve',
-  },
-] as const satisfies readonly FogProducerCase[];
-
-export const FOG_PRODUCER_IDS = FOG_PRODUCER_MANIFEST.map((producer) => producer.id);

package/src/__tests__/fog-producer-pixel-probe.ts

@@ -1,263 +0,0 @@
-import type { FogProducerCase } from './fog-producer-manifest';
-
-type ManifestEntry = {
-  readonly hash?: string;
-  readonly wgsl?: string;
-};
-
-type MaterialManifestEntry = {
-  readonly identifier: string;
-  readonly composedWgsl: string;
-  readonly variants?: readonly { readonly composedWgsl: string }[];
-};
-
-export type FogProbeManifest = {
-  readonly entries: readonly ManifestEntry[];
-  readonly materialShaders: readonly MaterialManifestEntry[];
-};
-
-export type FogPixel = readonly [number, number, number, number];
-
-export type FogRaySample = {
-  readonly origin: readonly [number, number, number];
-  readonly direction: readonly [number, number, number];
-  readonly distance: number;
-};
-
-export type FogProducerPixelCapture = (producer: FogProducerCase) => Promise<{
-  readonly disabled: FogPixel;
-  readonly enabled: FogPixel;
-  readonly ray: FogRaySample;
-}>;
-
-export type FogProducerPixelEvidence = {
-  readonly producerId: string;
-  readonly shaderIdentifier: string;
-  readonly shaderHash: string;
-  readonly disabled: FogPixel;
-  readonly enabled: FogPixel;
-  readonly expected: FogPixel;
-  readonly delta: FogPixel;
-  readonly alphaPreserved: boolean;
-  readonly verdict: 'pass' | 'fail';
-};
-
-const FOG_COLOR = [0.6, 0.45, 0.8] as const;
-const FOG_DENSITY = 0.08;
-const FOG_HEIGHT_FALLOFF = 0.1;
-const FOG_MAX_OPACITY = 0.9;
-const CHANNEL_TOLERANCE = 0.03;
-
-const MATERIAL_IDENTIFIERS: Readonly<Record<string, string>> = {
-  'default-standard-pbr.wgsl': 'forgeax::default-standard-pbr',
-  'default-standard-pbr-skin.wgsl': 'forgeax::pbr-skin',
-  'unlit.wgsl': 'forgeax::default-unlit',
-  'sprite.wgsl': 'forgeax::sprite',
-  'msdf-text.wgsl': 'forgeax::msdf-text',
-  'vfx-render/beam.wgsl': 'forgeax::vfx-render.particles.beam',
-  'vfx-render/billboard.wgsl': 'forgeax::vfx-render.particles.billboard',
-  'vfx-render/mesh.wgsl': 'forgeax::vfx-render.particles.mesh',
-  'vfx-render/ribbon.wgsl': 'forgeax::vfx-render.particles.ribbon',
-  'vfx-render/trail.wgsl': 'forgeax::vfx-render.particles.trail',
-};
-
-function shaderSourceForProducer(
-  producer: FogProducerCase,
-  manifest: FogProbeManifest,
-): { readonly identifier: string; readonly hash: string; readonly source: string } {
-  if (producer.id === 'hdrp-deferred') {
-    const entry = manifest.entries.find((candidate) => candidate.wgsl?.includes('fn fs_lighting'));
-    if (entry?.wgsl === undefined || entry.hash === undefined) {
-      throw new Error(
-        'Fog producer manifest does not contain composed hdrp-deferred-lighting.wgsl',
-      );
-    }
-    return { identifier: 'forgeax::hdrp-deferred-lighting', hash: entry.hash, source: entry.wgsl };
-  }
-  if (producer.sourceFile === 'skybox.wgsl') {
-    const entry = manifest.entries.find((candidate) => candidate.wgsl?.includes('fn skybox_fs'));
-    if (entry?.wgsl === undefined || entry.hash === undefined) {
-      throw new Error('Fog producer manifest does not contain composed skybox.wgsl');
-    }
-    return { identifier: 'forgeax::skybox', hash: entry.hash, source: entry.wgsl };
-  }
-  const identifier = MATERIAL_IDENTIFIERS[producer.sourceFile];
-  if (identifier === undefined)
-    throw new Error(`Fog producer has no shader identifier: ${producer.sourceFile}`);
-  const material = manifest.materialShaders.find(
-    (candidate) => candidate.identifier === identifier,
-  );
-  if (material === undefined)
-    throw new Error(`Fog producer shader is missing from manifest: ${identifier}`);
-  const source = material.composedWgsl;
-  if (source.startsWith('./')) {
-    throw new Error(`Fog producer manifest needs resolved composed WGSL: ${identifier}`);
-  }
-  if (!source.includes(`fn ${producer.entryPoint}`)) {
-    throw new Error(
-      `Fog producer ${producer.id} is missing the owning entry point ${producer.entryPoint}`,
-    );
-  }
-  if (!source.includes('apply_fog')) {
-    throw new Error(`Fog producer ${producer.id} is missing the shared apply_fog call`);
-  }
-  const entry = manifest.entries.find((candidate) => candidate.wgsl === source);
-  return { identifier, hash: entry?.hash ?? identifier, source };
-}
-
-function fogColor(params: {
-  readonly density: number;
-  readonly heightFalloff: number;
-  readonly maxOpacity: number;
-  readonly ray: FogRaySample;
-}): number {
-  const rho0 = params.density * Math.exp(-params.heightFalloff * params.ray.origin[1]);
-  const q = params.heightFalloff * params.ray.direction[1];
-  const tau =
-    Math.abs(q) < 1e-6
-      ? rho0 * params.ray.distance
-      : (rho0 * (1 - Math.exp(-q * params.ray.distance))) / q;
-  return params.maxOpacity * (1 - Math.exp(-Math.max(tau, 0)));
-}
-
-function srgbToLinear(value: number): number {
-  return value <= 0.04045 ? value / 12.92 : ((value + 0.055) / 1.055) ** 2.4;
-}
-
-function linearToSrgb(value: number): number {
-  const clamped = Math.min(Math.max(value, 0), 1);
-  return clamped <= 0.0031308 ? clamped * 12.92 : 1.055 * clamped ** (1 / 2.4) - 0.055;
-}
-
-function expectedEnabled(
-  producer: FogProducerCase,
-  disabled: FogPixel,
-  ray: FogRaySample,
-): FogPixel {
-  const opacity = fogColor({
-    density: FOG_DENSITY,
-    heightFalloff: FOG_HEIGHT_FALLOFF,
-    maxOpacity: FOG_MAX_OPACITY,
-    ray,
-  });
-  if (producer.domain === 'sprite') {
-    // Native URP frames route the sprite pass to fs_main_hdr when its
-    // transparent attachment is the graph-owned rgba16float target. The
-    // observation is therefore linear premultiplied RGB, not the LDR entry's
-    // sRGB-encoded premultiplied RGB.
-    const alpha = Math.max(disabled[3], 1e-6);
-    const source: readonly [number, number, number] = [
-      disabled[0] / alpha,
-      disabled[1] / alpha,
-      disabled[2] / alpha,
-    ];
-    return [
-      (source[0] * (1 - opacity) + FOG_COLOR[0] * opacity) * alpha,
-      (source[1] * (1 - opacity) + FOG_COLOR[1] * opacity) * alpha,
-      (source[2] * (1 - opacity) + FOG_COLOR[2] * opacity) * alpha,
-      disabled[3],
-    ];
-  }
-  if (producer.domain === 'text') {
-    const alpha = Math.max(disabled[3], 1e-6);
-    const source: readonly [number, number, number] = [
-      srgbToLinear(disabled[0]) / alpha,
-      srgbToLinear(disabled[1]) / alpha,
-      srgbToLinear(disabled[2]) / alpha,
-    ];
-    return [
-      linearToSrgb((source[0] * (1 - opacity) + FOG_COLOR[0] * opacity) * alpha),
-      linearToSrgb((source[1] * (1 - opacity) + FOG_COLOR[1] * opacity) * alpha),
-      linearToSrgb((source[2] * (1 - opacity) + FOG_COLOR[2] * opacity) * alpha),
-      disabled[3],
-    ];
-  }
-  return [
-    disabled[0] * (1 - opacity) + FOG_COLOR[0] * opacity,
-    disabled[1] * (1 - opacity) + FOG_COLOR[1] * opacity,
-    disabled[2] * (1 - opacity) + FOG_COLOR[2] * opacity,
-    disabled[3],
-  ];
-}
-
-export async function runFogProducerPixelProbe(
-  producers: readonly FogProducerCase[],
-  manifest: FogProbeManifest,
-  capture: FogProducerPixelCapture,
-): Promise<readonly FogProducerPixelEvidence[]> {
-  const rows: FogProducerPixelEvidence[] = [];
-  for (const producer of producers) {
-    const shader = shaderSourceForProducer(producer, manifest);
-    const result = await capture(producer);
-    const expected = expectedEnabled(producer, result.disabled, result.ray);
-    const delta: FogPixel = [
-      Math.abs(result.enabled[0] - expected[0]),
-      Math.abs(result.enabled[1] - expected[1]),
-      Math.abs(result.enabled[2] - expected[2]),
-      Math.abs(result.enabled[3] - expected[3]),
-    ];
-    const alphaPreserved = Math.abs(result.enabled[3] - result.disabled[3]) <= CHANNEL_TOLERANCE;
-    const activeSignal = Math.max(
-      Math.abs(result.enabled[0] - result.disabled[0]),
-      Math.abs(result.enabled[1] - result.disabled[1]),
-      Math.abs(result.enabled[2] - result.disabled[2]),
-    );
-    const verdict =
-      Math.max(...delta) <= CHANNEL_TOLERANCE && alphaPreserved && activeSignal > 0.01
-        ? 'pass'
-        : 'fail';
-    rows.push({
-      producerId: producer.id,
-      shaderIdentifier: shader.identifier,
-      shaderHash: shader.hash,
-      disabled: result.disabled,
-      enabled: result.enabled,
-      expected,
-      delta,
-      alphaPreserved,
-      verdict,
-    });
-  }
-  return rows;
-}
-
-export async function loadBrowserFogProbeManifest(): Promise<FogProbeManifest> {
-  const response = await fetch('/shaders/manifest.json');
-  if (!response.ok) throw new Error(`Fog Browser shader manifest unavailable: ${response.status}`);
-  const payload = (await response.json()) as FogProbeManifest;
-  const materialShaders: MaterialManifestEntry[] = [];
-  for (const material of payload.materialShaders) {
-    const resolveSource = async (value: string): Promise<string> => {
-      if (!value.startsWith('./')) return value;
-      const sourceResponse = await fetch(`/shaders/${value.slice(2)}`);
-      if (!sourceResponse.ok) throw new Error(`Fog Browser composed shader unavailable: ${value}`);
-      return sourceResponse.text();
-    };
-    materialShaders.push({
-      identifier: material.identifier,
-      composedWgsl: await resolveSource(material.composedWgsl),
-      ...(material.variants === undefined
-        ? {}
-        : {
-            variants: await Promise.all(
-              material.variants.map(async (variant) => ({
-                composedWgsl: await resolveSource(variant.composedWgsl),
-              })),
-            ),
-          }),
-    });
-  }
-  const entries = await Promise.all(
-    payload.entries.map(async (entry) => ({
-      ...(entry.hash === undefined ? {} : { hash: entry.hash }),
-      ...(entry.wgsl === undefined
-        ? {}
-        : {
-            wgsl: !entry.wgsl.startsWith('./')
-              ? entry.wgsl
-              : await (await fetch(`/shaders/${entry.wgsl.slice(2)}`)).text(),
-          }),
-    })),
-  );
-  return { entries, materialShaders };
-}

package/src/__tests__/fog-producer-pixel.browser.test.ts

@@ -1,26 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { FOG_PRODUCER_MANIFEST } from './fog-producer-manifest';
-import { loadBrowserFogProbeManifest, runFogProducerPixelProbe } from './fog-producer-pixel-probe';
-import { createFogProducerPixelCapture } from './fog-producer-real-fixture';
-
-const browserReady = typeof navigator !== 'undefined' && navigator.gpu !== undefined;
-
-describe.skipIf(!browserReady)('Fog composed producer Browser pixel evidence', () => {
-  it('runs every manifest producer through its composed WGSL Fog function', async () => {
-    const manifest = await loadBrowserFogProbeManifest();
-    const rows = await runFogProducerPixelProbe(
-      FOG_PRODUCER_MANIFEST,
-      manifest,
-      createFogProducerPixelCapture(manifest),
-    );
-
-    expect(rows).toHaveLength(FOG_PRODUCER_MANIFEST.length);
-    expect(rows.map((row) => row.producerId)).toEqual(
-      FOG_PRODUCER_MANIFEST.map((producer) => producer.id),
-    );
-    const failures = rows.filter((row) => row.verdict !== 'pass');
-    expect(failures, JSON.stringify(failures)).toEqual([]);
-    expect(rows.every((row) => row.alphaPreserved)).toBe(true);
-    expect(rows.every((row) => Math.max(...row.delta) <= 0.03)).toBe(true);
-  }, 120_000);
-});

package/src/__tests__/fog-producer-pixel.dawn.test.ts

@@ -1,55 +0,0 @@
-import { mkdirSync, writeFileSync } from 'node:fs';
-import { fileURLToPath } from 'node:url';
-import { buildEngineShaderManifest } from '@forgeax/engine-vite-plugin-shader';
-import { describe, expect, it } from 'vitest';
-import { FOG_PRODUCER_MANIFEST, FOG_PRODUCER_MANIFEST_VERSION } from './fog-producer-manifest';
-import { runFogProducerPixelProbe } from './fog-producer-pixel-probe';
-import { createFogProducerPixelCapture } from './fog-producer-real-fixture';
-
-const FEATURE_DIR = fileURLToPath(
-  new URL(
-    '../../../../.forgeax-harness/forgeax-loop/feat-20260823-scene-fog-height-aerial-perspective-v1/',
-    import.meta.url,
-  ),
-);
-const FEATURE_ID = 'feat-20260823-scene-fog-height-aerial-perspective-v1';
-
-describe('Fog composed producer Dawn pixel evidence', () => {
-  it('runs every manifest producer through its composed WGSL Fog function', async () => {
-    const manifest = await buildEngineShaderManifest();
-    const rows = await runFogProducerPixelProbe(
-      FOG_PRODUCER_MANIFEST,
-      manifest,
-      createFogProducerPixelCapture(manifest),
-    );
-
-    expect(FOG_PRODUCER_MANIFEST_VERSION).toBe(1);
-    expect(rows).toHaveLength(FOG_PRODUCER_MANIFEST.length);
-    expect(rows.every((row) => row.verdict === 'pass')).toBe(true);
-    expect(rows.every((row) => row.alphaPreserved)).toBe(true);
-    expect(rows.every((row) => Math.max(...row.delta) <= 0.03)).toBe(true);
-
-    const evidenceDir = `${FEATURE_DIR}evidence`;
-    mkdirSync(evidenceDir, { recursive: true });
-    writeFileSync(
-      `${evidenceDir}/dawn-producer-pixels.json`,
-      `${JSON.stringify(
-        {
-          schemaVersion: 2,
-          featureId: FEATURE_ID,
-          engineRevision: process.env.FORGEAX_ENGINE_REVISION ?? 'unknown',
-          command:
-            'pnpm exec vitest run --project=@forgeax/engine-runtime src/__tests__/fog-producer-pixel.dawn.test.ts --reporter=verbose',
-          backend: 'dawn',
-          manifestVersion: FOG_PRODUCER_MANIFEST_VERSION,
-          producerCount: rows.length,
-          rows,
-          verdict: rows.every((row) => row.verdict === 'pass') ? 'pass' : 'fail',
-        },
-        null,
-        2,
-      )}\n`,
-      'utf8',
-    );
-  }, 120_000);
-});