@forgeax/engine-render 0.1.7 → 0.1.20

package/src/__tests__/urp-pipeline-targets.unit.test.ts

@@ -16,7 +16,7 @@ function targets(
 }
 
 describe('urp render feature targets', () => {
-  it('publishes the linear-LDR target used by native no-tonemap frames', () => {
+  it('keeps the storage-buffer no-tonemap no-FXAA path in a linear target', () => {
     expect(targets('none', 'none', true)?.[0]).toMatchObject({
       kind: 'scene-color',
       format: 'rgba16float',
@@ -24,6 +24,14 @@ describe('urp render feature targets', () => {
     });
   });
 
+  it('publishes a float target for no-tonemap FXAA before the OETF boundary', () => {
+    expect(targets('none', 'fxaa', true)?.[0]).toMatchObject({
+      kind: 'scene-color',
+      format: 'rgba16float',
+      sampleCount: 1,
+    });
+  });
+
   it('publishes the MSAA linear-LDR target with the graph sample count', () => {
     expect(targets('none', 'msaa', true)?.[0]).toMatchObject({
       kind: 'scene-color',
@@ -39,4 +47,20 @@ describe('urp render feature targets', () => {
       sampleCount: 1,
     });
   });
+
+  it('keeps a linear target when MSAA is unavailable on a storage-buffer lane', () => {
+    expect(
+      resolveStandardRenderFeatureTargets({
+        tonemap: 'none',
+        antialias: 'msaa',
+        colorAttachmentFormat: 'bgra8unorm-srgb',
+        storageBuffer: true,
+        multisample: false,
+      })[0],
+    ).toMatchObject({
+      kind: 'scene-color',
+      format: 'rgba16float',
+      sampleCount: 1,
+    });
+  });
 });

package/src/__tests__/urp-pipeline.unit.test.ts

@@ -6,9 +6,10 @@ describe('Standard forward post color-domain order', () => {
     expect(resolvePostColorDomainContract('linear-ldr')).toEqual([
       ['transparent-blend', 'linear-ldr', 'linear-ldr'],
       ['bloom', 'linear-hdr', 'linear-hdr'],
-      ['tone', 'linear-hdr', 'linear-ldr'],
-      ['fxaa', 'linear-ldr', 'linear-ldr'],
-      ['output', 'linear-ldr', 'display-encoded'],
+      ['output-transform', 'linear-ldr', 'display-encoded'],
+      ['fxaa', 'display-encoded', 'display-encoded'],
+      ['post-effect', 'display-encoded', 'display-encoded'],
+      ['present', 'display-encoded', 'display-encoded'],
     ]);
   });
 });

package/src/__tests__/visibility-extract.integration.test.ts

@@ -1,6 +1,7 @@
 import { World } from '@forgeax/engine-ecs';
 import { ChildOf, registerPropagateTransforms, Transform } from '@forgeax/engine-scene';
-import { describe, expect, it } from 'vitest';
+import { describe, expect, it, vi } from 'vitest';
+import { Fog } from '../components/fog';
 import { Visibility, VisibilityStateValue } from '../components/visibility';
 import { extractFrame, extractFrames, prepareExtractContext } from '../render-system-extract';
 
@@ -32,6 +33,31 @@ function makeWorld() {
 }
 
 describe('visibility extract orchestration', () => {
+  it('selects Fog once at the resource-owner frame boundary', () => {
+    const cameraWorld = new World();
+    const resourceWorld = new World();
+    resourceWorld
+      .spawn({
+        component: Fog,
+        data: { color: [0.1, 0.2, 0.3], density: 0.02, heightFalloff: 0.4, maxOpacity: 0.8 },
+      })
+      .unwrap();
+
+    const cameraQuery = vi.spyOn(cameraWorld, 'query');
+    const resourceQuery = vi.spyOn(resourceWorld, 'query');
+    extractFrames([cameraWorld, resourceWorld], { cameraOwner: 0, resourceOwner: 1 });
+
+    const readsFog = (calls: readonly unknown[][]) =>
+      calls.filter(([spec]) => {
+        if (typeof spec !== 'object' || spec === null || !('read' in spec)) return false;
+        const read = (spec as { readonly read?: readonly unknown[] }).read;
+        return read?.includes(Fog) ?? false;
+      });
+
+    expect(readsFog(cameraQuery.mock.calls)).toHaveLength(0);
+    expect(readsFog(resourceQuery.mock.calls)).toHaveLength(1);
+  });
+
   it('refreshes hierarchy and visibility from the final World state', () => {
     const { world, parent, child } = makeWorld();
     world.set(parent, Visibility, { state: VisibilityStateValue.visible }).unwrap();

package/src/__tests__/visibility-producer-matrix.integration.test.ts

@@ -12,6 +12,7 @@ import { TileLayer } from '../components/tile-layer';
 import { Tilemap } from '../components/tilemap';
 import { Visibility, VisibilityStateValue } from '../components/visibility';
 import { extractFrames } from '../render-system-extract';
+import { classifySceneDataCoverage } from '../temporal/coverage';
 import { tilemapChunkExtractSystem } from '../tilemap-chunk-extract-system';
 
 const IDENTITY = new Float32Array([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]);
@@ -120,6 +121,15 @@ const PRODUCERS: readonly ProducerCase[] = [
 ];
 
 describe('visibility built-in producer matrix', () => {
+  it('records visibility reentry as a bounded reactive contributor', () => {
+    const coverage = classifySceneDataCoverage({
+      contributors: [{ id: 'visibility-reentry', kind: 'reactive' }],
+      requiredContributorIds: ['visibility-reentry'],
+    });
+    expect(coverage.complete).toBe(true);
+    expect(coverage.reactiveContributorIds).toEqual(['visibility-reentry']);
+  });
+
   it.each(PRODUCERS)('$name is hidden, visible, then restorable', ({ setup }) => {
     const world = new World();
     const entity = setup(world);

package/src/__tests__/volume-optics-oracle.unit.test.ts

@@ -0,0 +1,85 @@
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { describe, expect, it } from 'vitest';
+
+const integrateShader = readFileSync(
+  fileURLToPath(new URL('../../../shader/src/volume/volume-integrate.wgsl', import.meta.url)),
+  'utf8',
+);
+
+const EPSILON = 1e-6;
+
+function clampExponent(value: number): number {
+  return Math.min(Math.max(value, -80), 80);
+}
+
+function beerLambert(extinction: number, distance: number, density: number): number {
+  const opticalDepth = Math.max(extinction * Math.max(distance, 0) * Math.max(density, 0), 0);
+  return Math.exp(-Math.min(opticalDepth, 80));
+}
+
+function henyeyGreenstein(cosTheta: number, anisotropy: number): number {
+  const g = Math.min(Math.max(anisotropy, -0.999), 0.999);
+  const denominator = Math.max(1 + g * g - 2 * g * cosTheta, EPSILON);
+  return (1 - g * g) / (4 * Math.PI * denominator ** 1.5);
+}
+
+describe('volumetric optics CPU oracle', () => {
+  it('requires the true volume integration shader owner', () => {
+    expect(integrateShader).toContain('fn hg');
+    expect(integrateShader).toContain('FOUR_PI');
+    expect(integrateShader).toContain('textureStore(resolved');
+    expect(integrateShader).not.toContain('apply_fog');
+  });
+
+  it('does not apply density twice to single-scatter radiance', () => {
+    expect(integrateShader).not.toContain('phase * sample.g * sample.r * (1.0 - transmittance)');
+    expect(integrateShader).toContain(
+      'let local_scatter = radiance * volume_params.albedo.xyz * phase *',
+    );
+    expect(integrateShader).toContain('VOLUME_LIGHT_PHASE_SCALE * (1.0 - local_transmittance) +');
+  });
+
+  it('converts the shared integrated-light basis once before normalized HG', () => {
+    expect(integrateShader).toContain('const VOLUME_LIGHT_PHASE_SCALE : f32 = FOUR_PI;');
+    expect(integrateShader).toContain('phase *\n        VOLUME_LIGHT_PHASE_SCALE *');
+  });
+
+  it('keeps empty density at identity transmittance', () => {
+    expect(beerLambert(2, 100, 0)).toBeCloseTo(1, 6);
+    expect(beerLambert(0, 100, 4)).toBeCloseTo(1, 6);
+  });
+
+  it('makes transmittance monotonic for increasing density', () => {
+    const samples = [0, 0.1, 0.5, 1, 4].map((density) => beerLambert(1.2, 3, density));
+    for (let index = 1; index < samples.length; index += 1) {
+      expect(samples[index]).toBeLessThanOrEqual((samples[index - 1] ?? 0) + EPSILON);
+    }
+    expect(samples.every(Number.isFinite)).toBe(true);
+    expect(samples.every((value) => value >= 0 && value <= 1)).toBe(true);
+  });
+
+  it('keeps phase finite and distinguishes forward and backward scattering', () => {
+    const isotropic = henyeyGreenstein(0, 0);
+    const forward = henyeyGreenstein(1, 0.7);
+    const backward = henyeyGreenstein(-1, 0.7);
+    expect(isotropic).toBeCloseTo(1 / (4 * Math.PI), 6);
+    expect(forward).toBeGreaterThan(backward);
+    expect([isotropic, forward, backward].every(Number.isFinite)).toBe(true);
+  });
+
+  it('clamps exponent input without producing NaN or Infinity', () => {
+    const values = [-Infinity, -120, 0, 120, Infinity].map((value) =>
+      Math.exp(clampExponent(value)),
+    );
+    expect(values.every(Number.isFinite)).toBe(true);
+    expect(values.every((value) => value > 0)).toBe(true);
+  });
+
+  it('cuts integration at the nearer depth or authored distance', () => {
+    const depthDistance = 4;
+    const maxDistance = 2;
+    expect(Math.min(depthDistance, maxDistance)).toBe(2);
+    expect(beerLambert(1, Math.min(depthDistance, maxDistance), 1)).toBeCloseTo(Math.exp(-2), 6);
+  });
+});