@forgeax/engine-runtime 0.1.4 → 0.1.7

package/src/__tests__/lights.unit.test.ts

@@ -12,46 +12,39 @@
 //   - packages/runtime/src/__tests__/lightslot-layout.test.ts
 //   - packages/runtime/src/__tests__/point-light-defaults.test.ts
 //   - packages/runtime/src/__tests__/point-light-spawn-bounds.test.ts
-//   - packages/runtime/src/__tests__/render-multi-light-cap.test.ts
 //   - packages/runtime/src/__tests__/spot-light-defaults.test.ts
 //   - packages/runtime/src/__tests__/spot-light-spawn-bounds.test.ts
 //
 // Paradigm: each block-scoped describe('<source-filename>.test.ts', ...) preserves
 // source as ancestorTitles[0]. Top-level imports merged + deduped.
 
-import type { World as WorldType } from '@forgeax/engine-ecs';
 import { World } from '@forgeax/engine-ecs';
 import { componentDefinition, componentSchema } from '@forgeax/engine-ecs/internal';
 import { vec3 } from '@forgeax/engine-math';
-import type { Renderer as RendererType } from '@forgeax/engine-render';
-import type {
-  PointLightSnapshot,
-  ShadowInvalidConfigError,
-  SpotLightSnapshot,
-} from '@forgeax/engine-render/internal';
+import { Camera, DirectionalLight, PointLight, Skylight, SpotLight } from '@forgeax/engine-render';
+import { propagateTransforms, Transform } from '@forgeax/engine-scene';
+import { describe, expect, it } from 'vitest';
 import {
-  BYTES_PER_LIGHT_SLOT,
-  buildPbrViewBglEntries,
-  Camera,
   computeInvRangeSquared,
-  DirectionalLight,
   degToCos,
-  extractFrame,
+  validateDirectionalLightData,
+  validateSpotLightData,
+} from '../../../render/src/components/light-helpers';
+import type { ShadowInvalidConfigError } from '../../../render/src/errors/render';
+import {
+  BYTES_PER_LIGHT_SLOT,
   LIGHTSLOT_LAYOUT,
   LightSlotKind,
-  PointLight,
   packLightArrayHeader,
   packPointLight,
   packSpotLight,
-  prepareExtractContext,
-  Skylight,
-  SpotLight,
-  validateDirectionalLightData,
-  validateSpotLightData,
-} from '@forgeax/engine-render/internal';
-import { propagateTransforms, Transform } from '@forgeax/engine-scene';
-import type { Handle } from '@forgeax/engine-types';
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+} 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';
 
 type LightSpawnResult = ReturnType<World['spawn']>;
 
@@ -1310,7 +1303,6 @@ function spawnValidatedLight(
       function makeSnap(shadowAtlasTile: number): SpotLightSnapshot {
         return {
           kind: 'spot',
-          entity: 0,
           position: vec3.create(3.0, 4.0, 5.0),
           direction: vec3.create(0.0, -1.0, 0.0),
           color: vec3.create(0.8, 0.7, 0.6),
@@ -1681,482 +1673,6 @@ function spawnValidatedLight(
   });
 }
 
-{
-  // ─── from render-multi-light-cap.test.ts ───
-  describe('render-multi-light-cap.test.ts', () => {
-    const ENGINE = '../createRenderer';
-
-    interface MockGL2Context {
-      __mockTag: 'webgl2';
-      getExtension: () => null;
-      getParameter: () => number;
-      isContextLost: () => boolean;
-    }
-
-    function makeMockGL2(): MockGL2Context {
-      return {
-        __mockTag: 'webgl2',
-        getExtension: () => null,
-        getParameter: () => 1,
-        isContextLost: () => false,
-      };
-    }
-
-    interface CanvasOptions {
-      webgl2: 'context' | 'null';
-      webgpu?: 'context' | 'null';
-    }
-
-    function makeMockCanvas(opts: CanvasOptions): HTMLCanvasElement {
-      const canvas = {
-        width: 800,
-        height: 600,
-        getContext(kind: string): unknown {
-          if (kind === 'webgl2') {
-            return opts.webgl2 === 'context' ? makeMockGL2() : null;
-          }
-          if (kind === 'webgpu') {
-            if (opts.webgpu === 'context') {
-              return {
-                __mockTag: 'webgpu-canvas-context',
-                configure: () => undefined,
-                unconfigure: () => undefined,
-                getCurrentTexture: () => ({ createView: () => ({}) }),
-              };
-            }
-            return null;
-          }
-          return null;
-        },
-        addEventListener: () => undefined,
-        removeEventListener: () => undefined,
-      };
-      return canvas as Partial<HTMLCanvasElement> as HTMLCanvasElement;
-    }
-
-    interface DeviceCallLog {
-      encoderFinishCount: number;
-      drawIndexedCount: number;
-      setBindGroupCount: number;
-      beginRenderPassCount: number;
-      setPipelineCount: number;
-      queueSubmitCount: number;
-      writeBufferCount: number;
-    }
-
-    function makeMockGPUDevice(log: DeviceCallLog): { device: unknown } {
-      const lost = new Promise<unknown>(() => undefined);
-      const device = {
-        __mockTag: 'gpu-device',
-        lost,
-        features: new Set(),
-        limits: {},
-        queue: {
-          submit: () => {
-            log.queueSubmitCount++;
-          },
-          writeBuffer: () => {
-            log.writeBufferCount++;
-          },
-          writeTexture: () => undefined,
-        },
-        createShaderModule: () => ({ getCompilationInfo: async () => ({ messages: [] }) }),
-        createBindGroupLayout: () => ({}),
-        createPipelineLayout: () => ({}),
-        createRenderPipeline: () => ({}),
-        createBindGroup: () => ({}),
-        createBuffer: () => ({
-          getMappedRange: () => new ArrayBuffer(64),
-          unmap: () => undefined,
-        }),
-        createCommandEncoder: () => ({
-          beginRenderPass: () => {
-            log.beginRenderPassCount++;
-            return {
-              setPipeline: () => {
-                log.setPipelineCount++;
-              },
-              setVertexBuffer: () => undefined,
-              setIndexBuffer: () => undefined,
-              setBindGroup: () => {
-                log.setBindGroupCount++;
-              },
-              draw: () => undefined,
-              drawIndexed: () => {
-                log.drawIndexedCount++;
-              },
-              end: () => undefined,
-            };
-          },
-          finish: () => {
-            log.encoderFinishCount++;
-            return {};
-          },
-        }),
-        createTexture: () => ({ createView: () => ({}) }),
-        createSampler: () => ({}),
-        destroy: () => undefined,
-      };
-      return { device };
-    }
-
-    function makeMockGPU(deviceObj: unknown): unknown {
-      return {
-        requestAdapter: async () => ({
-          requestDevice: async () => deviceObj,
-        }),
-        getPreferredCanvasFormat: () => 'bgra8unorm',
-      };
-    }
-
-    const baseNavigator: Navigator = {
-      userAgent: 'mock-engine-test',
-    } as Partial<Navigator> as Navigator;
-
-    function buildManifestDataUrl(): string {
-      const manifest = {
-        schemaVersion: '1.0.0',
-        entries: [
-          { hash: 'pbr00000', wgsl: '/* pbr stub - calls f_schlick( */', glsl: '', bindings: '' },
-          { hash: 'unlit000', wgsl: '/* unlit stub */', glsl: '', bindings: '' },
-          {
-            hash: 'tonemap0',
-            wgsl: '/* tonemap stub - struct TonemapParams { exposure: f32 }; */',
-            glsl: '',
-            bindings: '',
-          },
-        ],
-      };
-      return `data:application/json,${encodeURIComponent(JSON.stringify(manifest))}`;
-    }
-
-    function makeLog(): DeviceCallLog {
-      return {
-        encoderFinishCount: 0,
-        drawIndexedCount: 0,
-        setBindGroupCount: 0,
-        beginRenderPassCount: 0,
-        setPipelineCount: 0,
-        queueSubmitCount: 0,
-        writeBufferCount: 0,
-      };
-    }
-
-    beforeEach(() => {
-      vi.stubGlobal('navigator', { ...baseNavigator });
-    });
-
-    afterEach(() => {
-      vi.unstubAllGlobals();
-    });
-
-    async function importEngine(): Promise<{
-      createRenderer: (
-        canvas: unknown,
-        opts?: unknown,
-        bundler?: unknown,
-      ) => Promise<{
-        backend: string;
-        ready: Promise<void>;
-        draw: (worlds: unknown, opts: { cameraOwner: number; resourceOwner: number }) => void;
-        onError: (
-          cb: (err: { code: string; detail?: unknown; hint?: string; expected?: string }) => void,
-        ) => () => void;
-      }>;
-    }> {
-      return (await import(ENGINE)) as never;
-    }
-
-    async function importEcs(): Promise<{
-      World: new () => {
-        spawn: (...componentDatas: unknown[]) => unknown;
-      };
-    }> {
-      return (await import('@forgeax/engine-ecs')) as never;
-    }
-
-    async function importComponents(): Promise<{
-      Transform: unknown;
-      MeshFilter: unknown;
-      MeshRenderer: unknown;
-      Camera: unknown;
-      DirectionalLight: unknown;
-      PointLight: unknown;
-      SpotLight: unknown;
-      HANDLE_CUBE: Handle<'MeshAsset', 'shared'>;
-      HANDLE_TRIANGLE: Handle<'MeshAsset', 'shared'>;
-    }> {
-      return {
-        ...(await import('@forgeax/engine-render/internal')),
-        ...(await import('@forgeax/engine-scene')),
-      } as never;
-    }
-
-    interface TestSetup {
-      createRenderer: (
-        canvas: unknown,
-        opts?: unknown,
-        bundler?: unknown,
-      ) => Promise<{
-        backend: string;
-        ready: Promise<void>;
-        draw: (worlds: unknown, opts: { cameraOwner: number; resourceOwner: number }) => void;
-        onError: (
-          cb: (err: { code: string; detail?: unknown; hint?: string; expected?: string }) => void,
-        ) => () => void;
-      }>;
-      log: DeviceCallLog;
-    }
-
-    async function setupWebGPU(): Promise<TestSetup> {
-      const log = makeLog();
-      const { device } = makeMockGPUDevice(log);
-      vi.stubGlobal('navigator', { ...baseNavigator, gpu: makeMockGPU(device) });
-      const engine = await importEngine();
-      return { createRenderer: engine.createRenderer, log };
-    }
-
-    function identityTransform(): Record<string, number[]> {
-      return { pos: [0, 0, 0], quat: [0, 0, 0, 1], scale: [1, 1, 1] };
-    }
-
-    function cameraTransform(): Record<string, number[]> {
-      return { ...identityTransform(), pos: [0, 0, 3] };
-    }
-
-    function pointLightData(intensity: number): Record<string, number | number[]> {
-      return { color: [1, 1, 1], intensity, range: 10 };
-    }
-
-    function spotLightData(intensity: number): Record<string, number | number[]> {
-      return {
-        direction: [0, -1, 0],
-        color: [1, 1, 1],
-        intensity,
-        range: 10,
-        innerConeDeg: 10,
-        outerConeDeg: 30,
-      };
-    }
-
-    function directionalLightData(intensity: number): Record<string, number | number[]> {
-      return {
-        direction: [0, -1, 0],
-        color: [1, 1, 1],
-        intensity,
-      };
-    }
-
-    describe('record-time multi-light cap fail-fast (M3 w19)', () => {
-      it("PointLight N>4 fires warn-once console.warn with detail.type='point'", async () => {
-        const { createRenderer } = await setupWebGPU();
-        const canvas = makeMockCanvas({ webgl2: 'context', webgpu: 'context' });
-        const renderer = await createRenderer(
-          canvas,
-          {},
-          { shaderManifestUrl: buildManifestDataUrl() },
-        );
-        await renderer.ready;
-        const { World } = await importEcs();
-        const C = await importComponents();
-        const world = new World();
-        world.spawn(
-          { component: C.Camera, data: { fov: Math.PI / 4, aspect: 16 / 9, near: 0.1, far: 100 } },
-          { component: C.Transform, data: cameraTransform() },
-        );
-        // 5 PointLights (N=5 > 4 first-slice cap).
-        for (let i = 0; i < 5; i++) {
-          world.spawn(
-            {
-              component: C.Transform,
-              data: { ...identityTransform(), pos: [i, 0, 0] },
-            },
-            { component: C.PointLight, data: pointLightData(1) },
-          );
-        }
-
-        const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
-        if (!(renderer as unknown as RendererType).attachWorld(world as WorldType).ok) {
-          throw new Error('World attachment failed');
-        }
-        (world as WorldType).update().unwrap();
-        renderer.draw([world], { cameraOwner: 0, resourceOwner: 0 });
-
-        const multiLightCalls = warnSpy.mock.calls.filter(
-          (c) =>
-            typeof c[0] === 'string' &&
-            c[0].startsWith('[forgeax] render-system-multi-light point:'),
-        );
-        expect(multiLightCalls.length).toBe(1);
-        const detail = multiLightCalls[0]?.[1] as
-          | { detail?: { type: string; got: number } }
-          | undefined;
-        expect(detail).toBeDefined();
-        expect(detail?.detail?.type).toBe('point');
-        expect(detail?.detail?.got).toBe(5);
-        warnSpy.mockRestore();
-      });
-
-      it("SpotLight N>4 fires warn-once console.warn with detail.type='spot'", async () => {
-        const { createRenderer } = await setupWebGPU();
-        const canvas = makeMockCanvas({ webgl2: 'context', webgpu: 'context' });
-        const renderer = await createRenderer(
-          canvas,
-          {},
-          { shaderManifestUrl: buildManifestDataUrl() },
-        );
-        await renderer.ready;
-        const { World } = await importEcs();
-        const C = await importComponents();
-        const world = new World();
-        world.spawn(
-          { component: C.Camera, data: { fov: Math.PI / 4, aspect: 16 / 9, near: 0.1, far: 100 } },
-          { component: C.Transform, data: cameraTransform() },
-        );
-        for (let i = 0; i < 5; i++) {
-          world.spawn(
-            { component: C.Transform, data: { ...identityTransform(), pos: [i, 0, 0] } },
-            { component: C.SpotLight, data: spotLightData(1) },
-          );
-        }
-
-        const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
-        if (!(renderer as unknown as RendererType).attachWorld(world as WorldType).ok) {
-          throw new Error('World attachment failed');
-        }
-        (world as WorldType).update().unwrap();
-        renderer.draw([world], { cameraOwner: 0, resourceOwner: 0 });
-
-        const multiLightCalls = warnSpy.mock.calls.filter(
-          (c) =>
-            typeof c[0] === 'string' &&
-            c[0].startsWith('[forgeax] render-system-multi-light spot:'),
-        );
-        expect(multiLightCalls.length).toBe(1);
-        const detail = multiLightCalls[0]?.[1] as
-          | { detail?: { type: string; got: number } }
-          | undefined;
-        expect(detail).toBeDefined();
-        expect(detail?.detail?.type).toBe('spot');
-        expect(detail?.detail?.got).toBe(5);
-        warnSpy.mockRestore();
-      });
-
-      it("DirectionalLight N>1 fires warn-once console.warn with detail.type='directional' (regression guard)", async () => {
-        const { createRenderer } = await setupWebGPU();
-        const canvas = makeMockCanvas({ webgl2: 'context', webgpu: 'context' });
-        const renderer = await createRenderer(
-          canvas,
-          {},
-          { shaderManifestUrl: buildManifestDataUrl() },
-        );
-        await renderer.ready;
-        const { World } = await importEcs();
-        const C = await importComponents();
-        const world = new World();
-        world.spawn(
-          { component: C.Camera, data: { fov: Math.PI / 4, aspect: 16 / 9, near: 0.1, far: 100 } },
-          { component: C.Transform, data: cameraTransform() },
-        );
-        world.spawn({ component: C.DirectionalLight, data: directionalLightData(1) });
-        world.spawn({ component: C.DirectionalLight, data: directionalLightData(2) });
-
-        const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
-        if (!(renderer as unknown as RendererType).attachWorld(world as WorldType).ok) {
-          throw new Error('World attachment failed');
-        }
-        (world as WorldType).update().unwrap();
-        renderer.draw([world], { cameraOwner: 0, resourceOwner: 0 });
-
-        const multiLightCalls = warnSpy.mock.calls.filter(
-          (c) =>
-            typeof c[0] === 'string' &&
-            c[0].startsWith('[forgeax] render-system-multi-light directional:'),
-        );
-        expect(multiLightCalls.length).toBeGreaterThanOrEqual(1);
-        const detail = multiLightCalls[0]?.[1] as
-          | { detail?: { type: string; got: number } }
-          | undefined;
-        expect(detail?.detail?.type).toBe('directional');
-        expect(detail?.detail?.got).toBe(2);
-        warnSpy.mockRestore();
-      });
-
-      it('exactly 4 PointLights pass silently (first-slice cap at N=4)', async () => {
-        const { createRenderer } = await setupWebGPU();
-        const canvas = makeMockCanvas({ webgl2: 'context', webgpu: 'context' });
-        const renderer = await createRenderer(
-          canvas,
-          {},
-          { shaderManifestUrl: buildManifestDataUrl() },
-        );
-        await renderer.ready;
-        const { World } = await importEcs();
-        const C = await importComponents();
-        const world = new World();
-        world.spawn(
-          { component: C.Camera, data: { fov: Math.PI / 4, aspect: 16 / 9, near: 0.1, far: 100 } },
-          { component: C.Transform, data: cameraTransform() },
-        );
-        for (let i = 0; i < 4; i++) {
-          world.spawn(
-            { component: C.Transform, data: { ...identityTransform(), pos: [i, 0, 0] } },
-            { component: C.PointLight, data: pointLightData(1) },
-          );
-        }
-
-        const errors: { code: string }[] = [];
-        renderer.onError((e) => errors.push(e));
-        if (!(renderer as unknown as RendererType).attachWorld(world as WorldType).ok) {
-          throw new Error('World attachment failed');
-        }
-        (world as WorldType).update().unwrap();
-        renderer.draw([world], { cameraOwner: 0, resourceOwner: 0 });
-
-        expect(errors.some((e) => e.code === 'render-system-multi-light')).toBe(false);
-      });
-
-      it('4 PointLights + 4 SpotLights together pass silently (cap is per-bucket)', async () => {
-        const { createRenderer } = await setupWebGPU();
-        const canvas = makeMockCanvas({ webgl2: 'context', webgpu: 'context' });
-        const renderer = await createRenderer(
-          canvas,
-          {},
-          { shaderManifestUrl: buildManifestDataUrl() },
-        );
-        await renderer.ready;
-        const { World } = await importEcs();
-        const C = await importComponents();
-        const world = new World();
-        world.spawn(
-          { component: C.Camera, data: { fov: Math.PI / 4, aspect: 16 / 9, near: 0.1, far: 100 } },
-          { component: C.Transform, data: cameraTransform() },
-        );
-        for (let i = 0; i < 4; i++) {
-          world.spawn(
-            { component: C.Transform, data: { ...identityTransform(), pos: [i, 0, 0] } },
-            { component: C.PointLight, data: pointLightData(1) },
-          );
-          world.spawn(
-            { component: C.Transform, data: { ...identityTransform(), pos: [0, i, 0] } },
-            { component: C.SpotLight, data: spotLightData(1) },
-          );
-        }
-
-        const errors: { code: string }[] = [];
-        renderer.onError((e) => errors.push(e));
-        if (!(renderer as unknown as RendererType).attachWorld(world as WorldType).ok) {
-          throw new Error('World attachment failed');
-        }
-        (world as WorldType).update().unwrap();
-        renderer.draw([world], { cameraOwner: 0, resourceOwner: 0 });
-
-        expect(errors.some((e) => e.code === 'render-system-multi-light')).toBe(false);
-      });
-    });
-  });
-}
-
 {
   // ─── from spot-light-defaults.test.ts ───
   describe('spot-light-defaults.test.ts', () => {
@@ -2716,10 +2232,11 @@ function spawnValidatedLight(
     //
     // visibility flags mirror the WebGPU GPUShaderStage bitmask:
     //   VERTEX = 0x1, FRAGMENT = 0x2.
+    const VISIBILITY_VERTEX = 0x1;
     const VISIBILITY_FRAGMENT = 0x2;
     const VISIBILITY_VERTEX_FRAGMENT = 0x1 | 0x2;
 
-    describe('binding 8 = spotShadowMap (D-5 always-on, last view-BG entry)', () => {
+    describe('binding 8 = spotShadowMap (D-5 always-on shadow entry)', () => {
       it('declares binding 8 as a depth 2D texture, FRAGMENT-only', () => {
         const entries = buildPbrViewBglEntries({ storageBuffer: true });
         const b8 = entries.find((e) => e.binding === 8);
@@ -2737,10 +2254,12 @@ function spawnValidatedLight(
         expect(noStorage.some((e) => e.binding === 8)).toBe(true);
       });
 
-      it('binding 8 is the last entry (no binding 9)', () => {
+      it('reserves binding 9 and keeps Points/Lines at binding 10', () => {
         const entries = buildPbrViewBglEntries({ storageBuffer: true });
         expect(entries.some((e) => e.binding === 9)).toBe(false);
-        expect(entries.some((e) => e.binding === 10)).toBe(false);
+        const pointsLines = entries.find((e) => e.binding === 10);
+        expect(pointsLines?.buffer?.type).toBe('uniform');
+        expect(pointsLines?.visibility).toBe(VISIBILITY_VERTEX);
       });
     });
 
@@ -2756,18 +2275,19 @@ function spawnValidatedLight(
     // UBO (binding 0). This block locks that the spot matrices add ZERO new view
     // BGL buffer bindings (the WebGL2 budget invariant).
     describe('spotLightViewProj folded into View UBO (binding 0), not a new binding', () => {
-      it('view BGL declares no uniform buffer beyond binding 7 (only binding 0 = view, 6/7 = point/cascade)', () => {
+      it('view BGL includes only the vertex Points/Lines UBO beyond binding 7', () => {
         // Enumerate uniform-buffer entries on the view BGL. After the w25 fold,
-        // the only uniform buffers are binding 0 (View UBO, carries the spot
-        // matrices in its tail), binding 6 (point shadowParams) and binding 7
-        // (shadowCasterCascade). No standalone spot-matrix uniform buffer.
+        // uniform buffers are binding 0 (View UBO, carries the spot matrices
+        // in its tail), binding 6 (point shadowParams), binding 7
+        // (shadowCasterCascade), and binding 10 (Points/Lines view). No
+        // standalone spot-matrix uniform buffer exists.
         const entries = buildPbrViewBglEntries({ storageBuffer: true });
         const uniformBufferBindings = entries
           .filter((e) => e.buffer?.type === 'uniform')
           .map((e) => e.binding)
           .sort((a, b) => a - b);
         // storageBuffer=true: bindings 1+2 are read-only-storage (not uniform).
-        expect(uniformBufferBindings).toEqual([0, 6, 7]);
+        expect(uniformBufferBindings).toEqual([0, 6, 7, 10]);
       });
 
       it('storageBuffer=false: WebGL2 fallback uniform-buffer bindings stay within budget', () => {
@@ -2832,12 +2352,12 @@ function spawnValidatedLight(
       });
     });
 
-    describe('full binding roster is contiguous 0..8', () => {
-      it('exposes exactly bindings 0..8 with no gaps (binding 9 folded into View UBO, w25)', () => {
+    describe('full binding roster reserves 9 for Points/Lines at 10', () => {
+      it('exposes bindings 0..8 plus binding 10, with binding 9 reserved', () => {
         const bindings = buildPbrViewBglEntries({ storageBuffer: true })
           .map((e) => e.binding)
           .sort((a, b) => a - b);
-        expect(bindings).toEqual([0, 1, 2, 3, 4, 5, 6, 7, 8]);
+        expect(bindings).toEqual([0, 1, 2, 3, 4, 5, 6, 7, 8, 10]);
       });
     });
   });