@forgeax/engine-runtime 0.1.19 → 0.1.21

package/src/__tests__/gpu-resource-cow-survivor.test.ts

@@ -144,12 +144,11 @@ function configuredStore(probe: CowProbe): GpuResidencyCache {
 function texturePod(w = 2, h = 2): TextureAsset {
   return {
     kind: 'texture',
-    width: w,
-    height: h,
+    shape: { viewDimension: '2d', extent: { width: w, height: h } },
     format: 'rgba8unorm-srgb',
     data: new Uint8Array(w * h * 4).fill(188),
     colorSpace: 'srgb',
-    mipmap: false,
+    mips: { kind: 'none' },
   };
 }
 

package/src/__tests__/helpers/tilemap-assets.ts

@@ -6,12 +6,11 @@ export const TEST_ATLAS_GUID = 'test/atlas';
 export function makeTestTexture(seed = 0): TextureAsset {
   return {
     kind: 'texture',
-    width: 32,
-    height: 32,
-    format: 'rgba8unorm',
+    shape: { viewDimension: '2d', extent: { width: 32, height: 32 } },
+    format: 'rgba8unorm-srgb',
     data: new Uint8Array(32 * 32 * 4).fill(seed),
     colorSpace: 'srgb',
-    mipmap: false,
+    mips: { kind: 'none' },
   };
 }
 

package/src/__tests__/light-gpu-byte-neutral.unit.test.ts

@@ -57,13 +57,14 @@ const emptyLights: ExtractedLights = {
   directionalCount: 0,
   point: [],
   spot: [],
+  directionalShadowError: undefined,
   lightViewProj: undefined,
   splitPlanes: undefined,
   cascadeCount: undefined,
   cascadeBlend: undefined,
   depthBias: undefined,
   normalBias: undefined,
-  pcfKernelSize: undefined,
+  directionalShadowQuality: undefined,
 } as unknown as ExtractedLights;
 
 /** Capture the single writeViewUbo payload as a Float32Array. */
@@ -117,7 +118,7 @@ describe('w7 -- light GPU pack byte-neutral (AC-11)', () => {
     expect(out[6]).toBeCloseTo(0.6, 6);
   });
 
-  it('packSpotLight writes color slots 4..6 + direction slots 8..10 byte-for-byte (64 B)', () => {
+  it('packSpotLight writes color slots 4..6 + direction slots 8..10 byte-for-byte (80 B)', () => {
     const snap: SpotLightSnapshot = {
       kind: 'spot',
       position: vec3.create(0, 5, 0),
@@ -135,7 +136,9 @@ describe('w7 -- light GPU pack byte-neutral (AC-11)', () => {
       shadowAtlasTile: -1,
     };
     const out = packSpotLight(snap);
-    expect(out.byteLength).toBe(64);
+    // SpotLight carries projector receiver controls and the shadow intensity
+    // tail in the current std430 payload.
+    expect(out.byteLength).toBe(80);
     expect(out[4]).toBeCloseTo(0.3, 6);
     expect(out[5]).toBeCloseTo(0.4, 6);
     expect(out[6]).toBeCloseTo(0.5, 6);

package/src/__tests__/light-snapshot.test-d.ts

@@ -21,6 +21,8 @@
 // covers any .test-d.ts file in any package).
 
 import { expectTypeOf, test } from 'vitest';
+import type { DirectionalShadowQuality } from '../../../render/src/components/directional-shadow-filter';
+import type { LightValidationError } from '../../../render/src/components/light-helpers';
 import type {
   DirectionalLightSnapshot,
   ExtractedLights,
@@ -81,4 +83,10 @@ test('ExtractedLights three-bucket shape', () => {
   expectTypeOf<ExtractedLights['directionalCount']>().toEqualTypeOf<number>();
   expectTypeOf<ExtractedLights['point']>().toEqualTypeOf<readonly PointLightSnapshot[]>();
   expectTypeOf<ExtractedLights['spot']>().toEqualTypeOf<readonly SpotLightSnapshot[]>();
+  expectTypeOf<ExtractedLights['directionalShadowQuality']>().toEqualTypeOf<
+    DirectionalShadowQuality | undefined
+  >();
+  expectTypeOf<ExtractedLights['directionalShadowError']>().toEqualTypeOf<
+    LightValidationError | undefined
+  >();
 });

package/src/__tests__/lights-preservation.fixup.test.ts

@@ -0,0 +1,127 @@
+import { World } from '@forgeax/engine-ecs';
+import { vec3 } from '@forgeax/engine-math';
+import { Camera, PointLight, SpotLight } from '@forgeax/engine-render';
+import { Transform } from '@forgeax/engine-scene';
+import { describe, expect, it } from 'vitest';
+import {
+  computeInvRangeSquared,
+  degToCos,
+  validatePointLightShadowData,
+  validateSpotLightData,
+} from '../../../render/src/components/light-helpers';
+import {
+  packLightSlot,
+  packPointLight,
+  packSpotLight,
+} from '../../../render/src/light-buffer-layout';
+import { buildPbrViewBglEntries } from '../../../render/src/pbr-pipeline';
+import type {
+  PointLightSnapshot,
+  SpotLightSnapshot,
+} from '../../../render/src/render-system-extract';
+import { extractFrame, prepareExtractContext } from '../../../render/src/render-system-extract';
+
+function pointSnapshot(): PointLightSnapshot {
+  return {
+    kind: 'point',
+    position: vec3.create(1, 2, 3),
+    color: vec3.create(2, 1, 0.5),
+    intensity: 2,
+    invRangeSquared: 0.25,
+  };
+}
+
+function spotSnapshot(): SpotLightSnapshot {
+  return {
+    kind: 'spot',
+    position: vec3.create(1, 2, 3),
+    direction: vec3.create(0, -1, 0),
+    color: vec3.create(2, 1, 0.5),
+    intensity: 2,
+    invRangeSquared: 0.25,
+    cosInner: degToCos(15),
+    cosOuter: degToCos(30),
+    castShadow: false,
+    lightViewProj: undefined,
+    mapSize: 512,
+    nearPlane: 0.1,
+    farPlane: 25,
+    shadowAtlasTile: -1,
+  };
+}
+
+describe('Point/Spot and shared-light regression guard', () => {
+  it('keeps extract facts for point range and spot cone in the shared light path', () => {
+    const world = new World();
+    const pointSpawn = world.spawn(
+      { component: Transform, data: { pos: [1, 2, 3] } },
+      { component: PointLight, data: { range: 2 } },
+    );
+    const spotSpawn = world.spawn(
+      { component: Transform, data: { pos: [4, 5, 6] } },
+      {
+        component: SpotLight,
+        data: { direction: [0, -1, 0], range: 4, innerConeDeg: 15, outerConeDeg: 30 },
+      },
+    );
+    world.spawn(
+      { component: Transform, data: {} },
+      { component: Camera, data: { fov: Math.PI / 4, aspect: 1, near: 0.1, far: 100 } },
+    );
+    expect(pointSpawn.ok, JSON.stringify(pointSpawn)).toBe(true);
+    expect(spotSpawn.ok, JSON.stringify(spotSpawn)).toBe(true);
+
+    const lights = extractFrame(world, prepareExtractContext(world)).lights;
+    expect(lights.point).toHaveLength(1);
+    expect(lights.point[0]?.invRangeSquared).toBeCloseTo(0.25, 6);
+    expect(lights.spot).toHaveLength(1);
+    expect(lights.spot[0]?.cosInner).toBeCloseTo(degToCos(15), 6);
+    expect(lights.spot[0]?.cosOuter).toBeCloseTo(degToCos(30), 6);
+  });
+
+  it('keeps attenuation and cone helpers as finite, shared semantic owners', () => {
+    expect(computeInvRangeSquared(2)).toBeCloseTo(0.25, 8);
+    expect(computeInvRangeSquared(0)).toBe(1e8);
+    expect(computeInvRangeSquared(Number.POSITIVE_INFINITY)).toBe(0);
+    expect(degToCos(0)).toBeCloseTo(1, 8);
+    expect(degToCos(60)).toBeCloseTo(0.5, 8);
+  });
+
+  it('keeps Point/Spot packing and the shared LightSlot discriminant intact', () => {
+    const point = pointSnapshot();
+    const spot = spotSnapshot();
+    const pointPacked = packPointLight(point);
+    const spotPacked = packSpotLight(spot);
+    const pointSlot = packLightSlot(point, { shadowAtlasLayer: 2, near: 0.1, far: 20 });
+    const spotSlot = packLightSlot(spot);
+
+    expect(pointPacked.byteLength).toBe(32);
+    expect(spotPacked.byteLength).toBe(80);
+    expect(new Uint32Array(pointSlot.buffer)[12]).toBe(0);
+    expect(new Int32Array(pointSlot.buffer)[13]).toBe(2);
+    expect(new Uint32Array(spotSlot.buffer)[12]).toBe(1);
+    expect(new Int32Array(spotSlot.buffer)[13]).toBe(-1);
+  });
+
+  it('keeps shared PBR view bindings for both storage and uniform light routes', () => {
+    const storageBindings = buildPbrViewBglEntries({ storageBuffer: true });
+    const uniformBindings = buildPbrViewBglEntries({ storageBuffer: false });
+    expect(storageBindings.map((entry) => entry.binding)).toEqual(
+      uniformBindings.map((entry) => entry.binding),
+    );
+    expect(storageBindings[1]?.buffer?.type).toBe('read-only-storage');
+    expect(storageBindings[2]?.buffer?.type).toBe('read-only-storage');
+    expect(uniformBindings[1]?.buffer?.type).toBe('uniform');
+    expect(uniformBindings[2]?.buffer?.type).toBe('uniform');
+  });
+
+  it('keeps Point/Spot pcfKernelSize validation independent of Directional quality', () => {
+    expect(
+      validatePointLightShadowData({ mapSize: 512, nearPlane: 0.1, farPlane: 20, pcfKernelSize: 5 })
+        .ok,
+    ).toBe(true);
+    expect(validateSpotLightData({ direction: [0, -1, 0], pcfKernelSize: 3 }).ok).toBe(true);
+    expect(validatePointLightShadowData({ pcfKernelSize: 2 }).ok).toBe(false);
+    expect(validateSpotLightData({ direction: [0, -1, 0], pcfKernelSize: 2 }).ok).toBe(false);
+  });
+});