@forgeax/engine-render 0.1.4 → 0.1.6

package/src/__tests__/analytic-sky-falsify.test.ts

@@ -1,94 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import {
-  beginEnvironmentGeneration,
-  createEnvironmentGenerationState,
-  publishEnvironmentGeneration,
-} from '../environment/generation';
-import {
-  createEnvironmentProducerGraph,
-  executeEnvironmentProducerTransaction,
-} from '../environment/graph';
-import { deriveEnvironmentBundleDescriptors } from '../environment/signature';
-
-type ConsumerFacts = {
-  readonly directSunDirection: readonly [number, number, number];
-  readonly skySunDirection: readonly [number, number, number];
-  readonly iblIncludesSunDisc: boolean;
-  readonly activeGeneration: number;
-  readonly csmGeneration: number;
-  readonly sunDiscGeneration: number;
-  readonly passCount: number;
-  readonly steadyPassCount: number;
-};
-
-function assertAnalyticSkyContract(facts: ConsumerFacts): void {
-  if (facts.directSunDirection.some((value, index) => value !== facts.skySunDirection[index]))
-    throw new Error('direction-unlink');
-  if (facts.iblIncludesSunDisc) throw new Error('ibl-disc-injection');
-  if (
-    facts.activeGeneration !== facts.csmGeneration ||
-    facts.activeGeneration !== facts.sunDiscGeneration
-  )
-    throw new Error('partial-publish');
-  if (facts.passCount !== facts.steadyPassCount) throw new Error('steady-rebuild');
-}
-
-const baseline = (): ConsumerFacts => ({
-  directSunDirection: [0.35, -0.88, -0.2],
-  skySunDirection: [0.35, -0.88, -0.2],
-  iblIncludesSunDisc: false,
-  activeGeneration: 7,
-  csmGeneration: 7,
-  sunDiscGeneration: 7,
-  passCount: 0,
-  steadyPassCount: 0,
-});
-
-describe('analytic sky internal FALSIFY carriers', () => {
-  it.each([
-    [
-      'direction unlink',
-      (facts: ConsumerFacts) => ({ ...facts, directSunDirection: [0, -1, 0] as const }),
-    ],
-    ['IBL Sun disc injection', (facts: ConsumerFacts) => ({ ...facts, iblIncludesSunDisc: true })],
-    ['partial publish', (facts: ConsumerFacts) => ({ ...facts, csmGeneration: 6 })],
-    ['steady rebuild', (facts: ConsumerFacts) => ({ ...facts, passCount: 42 })],
-  ])('%s is red, then baseline recovery is green', (_name, sabotage) => {
-    expect(() => assertAnalyticSkyContract(sabotage(baseline()))).toThrow();
-    expect(() => assertAnalyticSkyContract(baseline())).not.toThrow();
-  });
-
-  it('drives the production generation transaction before evaluating carriers', () => {
-    const state = createEnvironmentGenerationState('falsify-device');
-    const descriptors = deriveEnvironmentBundleDescriptors(
-      { skySize: 8, irradianceSize: 4, prefilterMips: 2 },
-      'rgba16float',
-    );
-    const graph = createEnvironmentProducerGraph({ descriptors, generation: 1, dirty: true });
-    const generation = beginEnvironmentGeneration(state, {
-      signature: 'falsify-signature',
-      bytes: descriptors.logicalBytes,
-    });
-    const candidate = generation.complete('production-test-bundle');
-    let published = false;
-    const trace = executeEnvironmentProducerTransaction({
-      graph,
-      dirty: true,
-      environment: {
-        abort: (stage) => generation.fail(stage),
-        publish: () => {
-          publishEnvironmentGeneration(state, candidate);
-          published = true;
-        },
-      },
-      temporal: { abort: () => undefined, publish: () => undefined },
-      execute: () => true,
-      finish: () => true,
-      submit: () => true,
-    });
-    expect(trace.abortedStage).toBeUndefined();
-    expect(trace.published).toBe(true);
-    expect(published).toBe(true);
-    expect(state.active?.generation).toBe(candidate.generation);
-  });
-});

package/src/__tests__/assets-runtime-handoff.integration.test.ts

@@ -1,36 +0,0 @@
-// @perf-budget-skip: intentional repository gate subprocess and export snapshot.
-import { spawnSync } from 'node:child_process';
-import { readFileSync } from 'node:fs';
-import { fileURLToPath } from 'node:url';
-import { createBuiltinMaterialAsset } from '@forgeax/engine-shader';
-import { describe, expect, it } from 'vitest';
-import { assembleMaterialProjection } from '../renderer/renderer-factory';
-
-const ROOT = fileURLToPath(new URL('../../../../', import.meta.url));
-
-describe('Material/Render sibling handoff', () => {
-  it('freezes the actual sibling ancestry and export snapshot', () => {
-    const gate = spawnSync('node', ['scripts/forgeax/check-assets-runtime-sibling-gate.mjs'], {
-      cwd: ROOT,
-      encoding: 'utf8',
-    });
-
-    expect(gate.status).toBe(0);
-    expect(`${gate.stdout}\n${gate.stderr}`).toContain('"baselineMatches": true');
-    expect(`${gate.stdout}\n${gate.stderr}`).toContain('"current":');
-  });
-
-  it('hands a concrete MaterialAsset to the render projection owner', () => {
-    const material = createBuiltinMaterialAsset('standard');
-    const source = readFileSync(
-      fileURLToPath(new URL('../renderer/material/assembly.ts', import.meta.url)),
-      'utf8',
-    );
-
-    expect(material.kind).toBe('material');
-    expect(material.passes?.[0]?.program.module).toBe('forgeax_material::standard');
-    expect(source).toContain('CookedMaterialRecord');
-    expect(source).not.toContain('LoaderRegistry');
-    expect(assembleMaterialProjection).toBeTypeOf('function');
-  });
-});

package/src/__tests__/backend-selection.integration.test.ts

@@ -1,11 +0,0 @@
-import { rhi } from '@forgeax/engine-rhi-null';
-import { describe, expect, it } from 'vitest';
-import { loadBackendPack } from '../renderer/backend-selection';
-
-describe('backend selection', () => {
-  it('uses an explicitly injected backend without probing global state', async () => {
-    const result = await loadBackendPack({ rhi });
-    expect(result.ok).toBe(true);
-    if (result.ok) expect(result.value.rhi).toBe(rhi);
-  });
-});

package/src/__tests__/camera-temporal.test-d.ts

@@ -1,8 +0,0 @@
-import type { Antialias } from '../components/camera';
-
-const allModes = ['none', 'fxaa', 'msaa', 'taa'] as const satisfies readonly Antialias[];
-void allModes;
-
-// @ts-expect-error antialias remains a closed union
-const unknownMode: Antialias = 'smaa';
-void unknownMode;

package/src/__tests__/camera-temporal.test.ts

@@ -1,188 +0,0 @@
-import { World } from '@forgeax/engine-ecs';
-import { mat4, vec3 } from '@forgeax/engine-math';
-import { Transform } from '@forgeax/engine-scene';
-import { pack } from '@forgeax/engine-types';
-import { describe, expect, it } from 'vitest';
-import {
-  ANTIALIAS_FXAA,
-  ANTIALIAS_MSAA,
-  ANTIALIAS_NONE,
-  ANTIALIAS_TAA,
-  antialiasFromF32,
-  Camera,
-  orthographic,
-  perspective,
-} from '../components/camera';
-import { type CameraSnapshot, extractCameraSnapshots } from '../render-system-extract';
-import {
-  projectTemporalView,
-  snapshotSubmittedTemporalView,
-  temporalJitterSample,
-  temporalViewId,
-} from '../temporal-view';
-
-const encodeEntity = (index: number, generation: number): number => pack(index, generation);
-
-function cameraSnapshot(overrides: Partial<CameraSnapshot> = {}): CameraSnapshot {
-  return {
-    worldId: 7,
-    entityKey: encodeEntity(11, 2) as number,
-    position: vec3.create(),
-    world: mat4.identity(mat4.create()),
-    fov: Math.PI / 3,
-    aspect: 16 / 9,
-    near: 0.1,
-    far: 100,
-    projection: 'perspective',
-    orthoLeft: -2,
-    orthoRight: 2,
-    orthoBottom: -1,
-    orthoTop: 1,
-    tonemap: 'none',
-    exposure: 1,
-    whitePoint: 4,
-    antialias: 'taa',
-    historyVersion: 0,
-    bloom: 'off',
-    bloomThreshold: 1,
-    bloomIntensity: 1,
-    bloomBlurRadius: 4,
-    clearColor: [0, 0, 0, 0],
-    ...overrides,
-  };
-}
-
-function project(
-  camera: CameraSnapshot,
-  temporalFrameIndex = 0,
-  lastSubmitted?: ReturnType<typeof snapshotSubmittedTemporalView>,
-) {
-  return projectTemporalView({
-    camera,
-    temporalFrameIndex,
-    surfaceWidth: 1920,
-    surfaceHeight: 1080,
-    ...(lastSubmitted === undefined ? {} : { lastSubmitted }),
-  });
-}
-
-describe('Camera temporal contract', () => {
-  it('round-trips the closed antialias encoding and rejects unknown values', () => {
-    expect(
-      [ANTIALIAS_NONE, ANTIALIAS_FXAA, ANTIALIAS_MSAA, ANTIALIAS_TAA].map(antialiasFromF32),
-    ).toEqual(['none', 'fxaa', 'msaa', 'taa']);
-    expect(() => antialiasFromF32(4)).toThrow(/Invalid antialias value: 4/);
-  });
-
-  it('keeps historyVersion in the Camera schema, factories, World.set, and extract snapshot', () => {
-    expect(perspective({ fov: 1, aspect: 1 }).historyVersion).toBe(0);
-    expect(orthographic({ left: -1, right: 1, bottom: -1, top: 1 }).historyVersion).toBe(0);
-
-    const world = new World();
-    const entity = world
-      .spawn(
-        { component: Transform, data: {} },
-        { component: Camera, data: perspective({ fov: 1, aspect: 1 }) },
-      )
-      .unwrap();
-    world.set(entity, Camera, { historyVersion: 23 }).unwrap();
-
-    expect(world.get(entity, Camera).unwrap().historyVersion).toBe(23);
-    expect(extractCameraSnapshots(world)[0]).toMatchObject({
-      worldId: 0,
-      entityKey: entity,
-      historyVersion: 23,
-    });
-  });
-});
-
-describe('TemporalView', () => {
-  it('derives stable identity from renderer World id, entity slot, and generation', () => {
-    expect(temporalViewId(5, encodeEntity(9, 3) as number)).toBe('5:9:3');
-    expect(temporalViewId(6, encodeEntity(9, 3) as number)).not.toBe(
-      temporalViewId(5, encodeEntity(9, 3) as number),
-    );
-    expect(temporalViewId(5, encodeEntity(9, 4) as number)).not.toBe(
-      temporalViewId(5, encodeEntity(9, 3) as number),
-    );
-  });
-
-  it('uses the fixed centered eight-sample Halton(2,3) sequence', () => {
-    const expected = [
-      [0, -1 / 6],
-      [-1 / 4, 1 / 6],
-      [1 / 4, -7 / 18],
-      [-3 / 8, -1 / 18],
-      [1 / 8, 5 / 18],
-      [-1 / 8, -5 / 18],
-      [3 / 8, 1 / 18],
-      [-7 / 16, 7 / 18],
-    ];
-    for (let index = 0; index < expected.length; index += 1) {
-      const observed = temporalJitterSample(index);
-      expect(observed[0]).toBeCloseTo(expected[index]?.[0] ?? Number.NaN);
-      expect(observed[1]).toBeCloseTo(expected[index]?.[1] ?? Number.NaN);
-    }
-    expect(temporalJitterSample(8)).toEqual(temporalJitterSample(0));
-  });
-
-  it.each([
-    'perspective',
-    'orthographic',
-  ] as const)('separates jittered raster from unjittered %s facts', (projection) => {
-    const camera = cameraSnapshot({ projection });
-    const first = project(camera, 1);
-    const submitted = snapshotSubmittedTemporalView(first);
-    const second = project(camera, 2, submitted);
-
-    expect(first.currentJitteredViewProjection).not.toEqual(first.currentUnjitteredViewProjection);
-    const clipDelta = (matrix: Float32Array, component: 0 | 1): number => {
-      const z = -1;
-      const clip = (matrix[8 + component] ?? 0) * z + (matrix[12 + component] ?? 0);
-      const w = (matrix[11] ?? 0) * z + (matrix[15] ?? 0);
-      return clip / w;
-    };
-    expect(
-      clipDelta(first.currentJitteredViewProjection, 0) -
-        clipDelta(first.currentUnjitteredViewProjection, 0),
-    ).toBeCloseTo(first.currentJitterUv[0] * 2);
-    expect(
-      clipDelta(first.currentJitteredViewProjection, 1) -
-        clipDelta(first.currentUnjitteredViewProjection, 1),
-    ).toBeCloseTo(first.currentJitterUv[1] * -2);
-    expect(second.previousUnjitteredViewProjection).toEqual(first.currentUnjitteredViewProjection);
-    expect(second.currentUnjitteredViewProjection).toEqual(first.currentUnjitteredViewProjection);
-    expect(second.historyValid).toBe(true);
-  });
-
-  it('reports deterministic reset identity for camera and projection discontinuities', () => {
-    const camera = cameraSnapshot();
-    const first = project(camera);
-    expect(first.resetReason).toBe('first-frame');
-    const submitted = snapshotSubmittedTemporalView(first);
-
-    expect(project(camera, 1, submitted).resetReason).toBeUndefined();
-    expect(project(cameraSnapshot({ worldId: 8 }), 1, submitted).resetReason).toBe('camera-switch');
-    expect(project(cameraSnapshot({ historyVersion: 1 }), 1, submitted).resetReason).toBe(
-      'history-version-changed',
-    );
-    expect(project(cameraSnapshot({ projection: 'orthographic' }), 1, submitted).resetReason).toBe(
-      'projection-kind-changed',
-    );
-    expect(project(cameraSnapshot({ far: 200 }), 1, submitted).resetReason).toBe(
-      'projection-range-changed',
-    );
-  });
-
-  it('reuses the same index and sample when a failed submission is retried', () => {
-    const camera = cameraSnapshot();
-    const submitted = snapshotSubmittedTemporalView(project(camera, 0));
-    const attempted = project(camera, 3, submitted);
-    const retried = project(camera, 3, submitted);
-    const nextSuccessfulIndex = project(camera, 4, submitted);
-
-    expect(retried.currentJitterUv).toEqual(attempted.currentJitterUv);
-    expect(retried.currentJitteredViewProjection).toEqual(attempted.currentJitteredViewProjection);
-    expect(nextSuccessfulIndex.currentJitterUv).not.toEqual(attempted.currentJitterUv);
-  });
-});

package/src/__tests__/directional-shadow-probe-atlas-layout.unit.test.ts

@@ -1,18 +0,0 @@
-import { readFileSync } from 'node:fs';
-import { describe, expect, it } from 'vitest';
-
-const rendererFactorySource = readFileSync(
-  new URL('../renderer/renderer-factory.ts', import.meta.url),
-  'utf8',
-);
-
-describe('directional shadow probe atlas layout', () => {
-  it('matches the compact host atlas rows instead of assuming a square atlas', () => {
-    expect(rendererFactorySource).toMatch(/let rows : u32 = \(count \+ columns - 1u\) \/ columns;/);
-    expect(rendererFactorySource).toMatch(
-      /let tileScale = vec2<f32>\(1\.0\) \/ vec2<f32>\(grid\);/,
-    );
-    expect(rendererFactorySource).toMatch(/let uv = tileUv \* tileScale \+ tileOrigin;/);
-    expect(rendererFactorySource).not.toMatch(/let uv = tileUv \* inv \+ tileOrigin;/);
-  });
-});

package/src/__tests__/environment-inspection.test.ts

@@ -1,45 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import {
-  beginEnvironmentGeneration,
-  createEnvironmentGenerationState,
-} from '../environment/generation';
-import { inspectEnvironmentGeneration, projectFogEnvironment } from '../environment/inspection';
-
-describe('environment inspection', () => {
-  it('projects bounded lifecycle, source, cost, failure, and TAA facts', () => {
-    const state = createEnvironmentGenerationState('device-a');
-    const attempt = beginEnvironmentGeneration(state, { signature: 'desired', bytes: 128 });
-    const inspection = inspectEnvironmentGeneration(state, {
-      sourceWorldId: 3,
-      sourceEntity: 4,
-      rebuild: { passCount: 42, timeMs: 2 },
-      taa: {
-        activeSignature: undefined,
-        publishCount: 0,
-        resetCount: 0,
-        lastResetReason: undefined,
-      },
-    });
-    expect(inspection).toMatchObject({
-      state: 'building',
-      source: { worldId: 3, entity: 4 },
-      desiredSignature: 'desired',
-      deviceGeneration: 'device-a',
-      rebuild: { passCount: 42, timeMs: 2 },
-      taa: { publishCount: 0, resetCount: 0 },
-    });
-    expect(Object.keys(inspection)).not.toEqual(expect.arrayContaining(['handle', 'cache']));
-    attempt.fail('build');
-    expect(inspectEnvironmentGeneration(state).state).toBe('failed');
-  });
-
-  it('keeps the future Fog seam readonly and source-derived', () => {
-    const projection = projectFogEnvironment({
-      activeSignature: 'active',
-      sunDirection: [0, 0, -1],
-      illuminance: 10,
-    });
-    expect(Object.isFrozen(projection)).toBe(true);
-    expect(projection.activeSignature).toBe('active');
-  });
-});