@forgeax/engine-runtime 0.1.4 → 0.1.7

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

@@ -10,16 +10,14 @@
 // must be replaced by buildBindGroupLayoutDescriptor calls without changing
 // what the device sees.
 
-import type { PipelineSpec } from '@forgeax/engine-render/internal';
+import { describe, expect, it } from 'vitest';
 import {
   appendInjection,
-  buildBindGroupLayoutDescriptor,
   buildPbrMaterialUserRegionEntries,
   buildPbrViewBglEntries,
-} from '@forgeax/engine-render/internal';
-import { DEFAULT_UNLIT_PARAM_SCHEMA } from '@forgeax/engine-shader';
-import { derive } from '@forgeax/engine-types';
-import { describe, expect, it } from 'vitest';
+} from '../../../render/src/pbr-pipeline';
+import type { PipelineSpec } from '../../../render/src/pipeline-spec';
+import { buildBindGroupLayoutDescriptor } from '../../../render/src/pipeline-spec';
 
 // Stable spec stub — the dispatcher uses spec.shader for reflection only when
 // a registry is supplied; without registry the BGL shape comes purely from
@@ -46,7 +44,7 @@ function makeSpec(): PipelineSpec {
 
 describe('buildBindGroupLayoutDescriptor — pbr-pipeline 6 sites byte-equiv', () => {
   describe('pbr-view', () => {
-    it('storageBuffer=true: 9 entries with read-only-storage on bindings 1+2', () => {
+    it('storageBuffer=true: 10 entries with read-only-storage on bindings 1+2', () => {
       const spec = makeSpec();
       const out = buildBindGroupLayoutDescriptor(spec, {
         kind: 'pbr-view',
@@ -58,12 +56,15 @@ describe('buildBindGroupLayoutDescriptor — pbr-pipeline 6 sites byte-equiv', (
       };
       expect(out).toEqual(expected);
       // feat-20260625-spot-light-shadow-mapping: binding 8 (spot shadow atlas,
-      // w14) raised the view BGL to 9 entries (always-on, D-5). w25 (scope-amend
+      // w14) raised the view BGL to 9 entries (always-on, D-5). The
+      // Points/Lines viewport UBO occupies binding 10, while w25 (scope-amend
       // webkit-fallback) folded the former binding 9 spotLightViewProj matrices
       // UBO into the View UBO (`view.spotLightViewProj`), so the BGL stays at 9
-      // entries (bindings 0..8) — keeping the WebGL2 fallback fragment uniform-
+      // entries (bindings 0..8 plus binding 10) — keeping the WebGL2 fallback fragment uniform-
       // buffer count <= 11 (GLES 3.0).
-      expect(out.entries.length).toBe(9);
+      expect(out.entries.length).toBe(10);
+      expect(out.entries.find((entry) => entry.binding === 9)).toBeUndefined();
+      expect(out.entries.find((entry) => entry.binding === 10)?.buffer?.type).toBe('uniform');
     });
 
     it('storageBuffer=false: bindings 1+2 fall back to uniform', () => {
@@ -81,22 +82,22 @@ describe('buildBindGroupLayoutDescriptor — pbr-pipeline 6 sites byte-equiv', (
   });
 
   describe('pbr-material-merged', () => {
-    it('20 entries: user-region 13 (derived) + ibl 7', () => {
+    it('24 entries: user-region 13 (derived) + ibl 7 + lightmap 4', () => {
       const spec = makeSpec();
       const out = buildBindGroupLayoutDescriptor(spec, {
         kind: 'pbr-material-merged',
       });
       // Post-M2 (D-1): user-region comes from derive(paramSchema).bglEntries
-      // (built-in standard-PBR 6-texture fallback), then IBL is appended at
-      // start = userRegion.length.
+      // (built-in standard-PBR 4-texture fallback), then IBL + lightmap are
+      // appended at start = userRegion.length.
       const userRegion = buildPbrMaterialUserRegionEntries();
       const afterIbl = [...userRegion, ...appendInjection(userRegion, 'ibl')];
       const expected = {
         label: 'pbr-material-skylight-bgl',
-        entries: afterIbl,
+        entries: [...afterIbl, ...appendInjection(afterIbl, 'lightmap')],
       };
       expect(out).toEqual(expected);
-      expect(out.entries.length).toBe(20);
+      expect(out.entries.length).toBe(24);
     });
   });
 
@@ -159,7 +160,7 @@ describe('buildBindGroupLayoutDescriptor — pbr-pipeline 6 sites byte-equiv', (
   });
 
   describe('pbr-skin-mesh-array', () => {
-    it('storageBuffer=true: mesh plus current/previous palettes use dynamic offsets', () => {
+    it('storageBuffer=true: 2 entries, both dynamic offset', () => {
       const spec = makeSpec();
       const out = buildBindGroupLayoutDescriptor(spec, {
         kind: 'pbr-skin-mesh-array',
@@ -170,16 +171,11 @@ describe('buildBindGroupLayoutDescriptor — pbr-pipeline 6 sites byte-equiv', (
         entries: [
           {
             binding: 0,
-            visibility: 0x3,
-            buffer: { type: 'read-only-storage', hasDynamicOffset: true },
-          },
-          {
-            binding: 1,
             visibility: 0x1,
             buffer: { type: 'read-only-storage', hasDynamicOffset: true },
           },
           {
-            binding: 2,
+            binding: 1,
             visibility: 0x1,
             buffer: { type: 'read-only-storage', hasDynamicOffset: true },
           },
@@ -189,16 +185,16 @@ describe('buildBindGroupLayoutDescriptor — pbr-pipeline 6 sites byte-equiv', (
   });
 
   describe('unlit-material', () => {
-    it('3 entries: reflected unlit material only (no skylight injection)', () => {
+    it('13 entries: base PBR material only (no skylight injection)', () => {
       const spec = makeSpec();
       const out = buildBindGroupLayoutDescriptor(spec, {
         kind: 'unlit-material',
       });
       expect(out).toEqual({
         label: 'unlit-material-bgl',
-        entries: buildPbrMaterialUserRegionEntries(derive(DEFAULT_UNLIT_PARAM_SCHEMA)),
+        entries: buildPbrMaterialUserRegionEntries(),
       });
-      expect(out.entries.length).toBe(3);
+      expect(out.entries.length).toBe(13);
     });
   });
 });

package/src/__tests__/pipeline-builder-msaa.unit.test.ts

@@ -12,10 +12,6 @@
  * the descriptor stage without a real GPU.
  */
 
-import {
-  buildPipelineForMaterialShader,
-  type PipelineBuilderContext,
-} from '@forgeax/engine-render/internal';
 import {
   ok,
   type RenderPipeline,
@@ -25,6 +21,10 @@ import {
   type ShaderModule,
 } from '@forgeax/engine-rhi';
 import { describe, expect, it, vi } from 'vitest';
+import {
+  buildPipelineForMaterialShader,
+  type PipelineBuilderContext,
+} from '../../../render/src/pipeline-builder';
 
 function fakeShaderModule(): ShaderModule {
   return { label: 'fake-module' } as unknown as ShaderModule;
@@ -147,10 +147,7 @@ describe('buildPipelineForMaterialShader multisample descriptor (M2)', () => {
     expect(desc.multisample).toEqual({ count: 4, alphaToCoverageEnabled: true });
   });
 
-  it('sampleCount=2 narrowed to 1 per PipelineSpec contract (1 | 4 only)', () => {
-    // M2-T4: PipelineSpec.sampleCount is 1 | 4 (closed set). sampleCount=2
-    // is narrowed to 1 by the pipeline-builder, producing undefined multisample.
-    // When sampleCount=2 is added to the union, this test must be reverted.
+  it('sampleCount=2 preserves the explicit multisample count', () => {
     const spy = vi.fn<(desc: unknown) => Result<RenderPipeline, RhiError>>(
       () => ok(fakeRenderPipeline()) as unknown as Result<RenderPipeline, RhiError>,
     );
@@ -171,7 +168,7 @@ describe('buildPipelineForMaterialShader multisample descriptor (M2)', () => {
 
     expect(spy).toHaveBeenCalledTimes(1);
     const desc = spy.mock.calls[0]?.[0] as Record<string, unknown>;
-    expect(desc.multisample).toBeUndefined();
+    expect(desc.multisample).toEqual({ count: 2 });
   });
 
   it('shadow-caster pass with sampleCount=1 produces multisample: undefined', () => {

package/src/__tests__/pipeline-cache-keying.unit.test.ts

@@ -1,10 +1,7 @@
-import {
-  cacheKeyOf,
-  type PipelineSpec,
-  SPRITE_PASS_PER_INSTANCE_REGION_VARIANT_SET,
-} from '@forgeax/engine-render/internal';
 import { KNOWN_PASS_KINDS, type PassKind, type VertexAttributeMap } from '@forgeax/engine-types';
 import { describe, expect, expectTypeOf, it } from 'vitest';
+import { SPRITE_PASS_PER_INSTANCE_REGION_VARIANT_SET } from '../../../render/src/pbr-pipeline';
+import { cacheKeyOf, type PipelineSpec } from '../../../render/src/pipeline-spec';
 
 /*
  * feat-20260615-pipeline-spec-ssot M2-T2: cache key axis tests migrated from
@@ -129,18 +126,18 @@ describe('cacheKeyOf passKind dimension', () => {
  */
 describe('PassKind open string + KNOWN_PASS_KINDS (feat-20260615 D-10)', () => {
   // M2-T4 expanded KNOWN_PASS_KINDS from 4 to 6 entries by adding 'post-process'
-  // and 'skybox' so fullscreen-post + skybox passes can route through
-  // SPEC_CONST_TABLE / getOrBuildPipeline rather than raw createRenderPipeline.
+  // and 'skybox'; point-shadow-caster is the engine's depth-only point-light
+  // pass and is part of the discoverable catalogue as well.
   it('KNOWN_PASS_KINDS has exactly 7 entries', () => {
     expect(KNOWN_PASS_KINDS).toHaveLength(7);
   });
 
-  it('KNOWN_PASS_KINDS contains the 6 engine-shipped pass kinds', () => {
+  it('KNOWN_PASS_KINDS contains the 7 engine-shipped pass kinds', () => {
     expect(KNOWN_PASS_KINDS).toContain('forward');
     expect(KNOWN_PASS_KINDS).toContain('deferred');
-    expect(KNOWN_PASS_KINDS).toContain('temporal');
     expect(KNOWN_PASS_KINDS).toContain('lighting');
     expect(KNOWN_PASS_KINDS).toContain('shadow-caster');
+    expect(KNOWN_PASS_KINDS).toContain('point-shadow-caster');
     expect(KNOWN_PASS_KINDS).toContain('post-process');
     expect(KNOWN_PASS_KINDS).toContain('skybox');
   });

package/src/__tests__/pipeline-spec.test.ts

@@ -10,26 +10,24 @@
 // M1-T4-TEST: getOrBuildPipeline cache miss/hit + fail-fast unit (5 cases)
 // M1-T5-TEST: 12 SPEC_CONST unit (mutual uniqueness + sampleCount + axis round-trip)
 
+import { describe, expect, it } from 'vitest';
+// M1-T1 (after impl exists) re-exports (only import what the tests actually use):
 import {
   buildBeginRenderPassDescriptor,
   buildLinearLdrMaterialSpecTable,
   buildPipelineDescriptor,
   cacheKeyOf,
-  deriveBglShapeFromShader,
   getOrBuildPipeline,
   // M1-T0: type-level imports
   KNOWN_PASS_KINDS,
+  type PipelineDeviceProvider,
   type PipelineSpec,
   PipelineSpecError,
   type PipelineSpecErrorCode,
   passKindPolicyTable,
   SPEC_CONST_TABLE,
-  specsEqual,
   validateSpec,
-} from '@forgeax/engine-render/internal';
-// M1-T1 (after impl exists) re-exports (only import what the tests actually use):
-import { ParamSchemaProjectionOwner } from '@forgeax/engine-types';
-import { describe, expect, it } from 'vitest';
+} from '../../../render/src/pipeline-spec';
 
 // =============================================================================
 // M1-T0: PipelineSpec type + error codes narrowing
@@ -221,34 +219,6 @@ describe('cacheKeyOf', () => {
   });
 });
 
-describe('specsEqual', () => {
-  it('returns true for identical specs', () => {
-    const a = makeSpec();
-    const b = makeSpec();
-    expect(specsEqual(a, b)).toBe(true);
-  });
-
-  it('returns false when shader differs', () => {
-    const a = makeSpec();
-    const b = makeSpec({
-      shader: { id: 'forgeax::default-standard-pbr', passKind: 'forward', variantSet: undefined },
-    });
-    expect(specsEqual(a, b)).toBe(false);
-  });
-
-  it('returns false when attachments differ', () => {
-    const a = makeSpec();
-    const b = makeSpec({
-      attachments: {
-        colorFormats: ['bgra8unorm-srgb' as unknown as GPUTextureFormat],
-        depthFormat: 'depth24plus-stencil8' as unknown as GPUTextureFormat,
-        sampleCount: 4,
-      },
-    });
-    expect(specsEqual(a, b)).toBe(false);
-  });
-});
-
 describe('validateSpec', () => {
   it('passes for a valid spec', () => {
     const s = makeSpec();
@@ -286,141 +256,19 @@ describe('validateSpec', () => {
       expect(r.code).toBe('attachment-format-incompatible');
     }
   });
-});
 
-// =============================================================================
-// M1-T3-TEST: deriveBglShapeFromShader helper unit (12 cases)
-// =============================================================================
-
-describe('deriveBglShapeFromShader', () => {
-  // Helper: create a minimal ShaderEntry fixture.
-  function shaderEntry(
-    params: readonly { name: string; type: string }[] = [],
-  ): import('@forgeax/engine-shader').RegisteredMaterialShaderEntry {
-    const entry = {
-      source: 'fn vs() {} fn fs() {}',
-      paramSchema: params.map((p) => ({
-        name: p.name,
-        type: p.type as import('@forgeax/engine-types').MaterialParamType,
-      })),
-    };
-    const owner = new ParamSchemaProjectionOwner();
-    const paramSchemaProjection = owner.admit({
-      ownerId: 'test::pipeline-spec',
-      revision: 1,
-      schema: entry.paramSchema,
+  it('returns attachment-format-incompatible for a depth-only pass without depthFormat', () => {
+    const s = makeSpec({
+      shader: {
+        id: 'forgeax::default-unlit',
+        passKind: 'point-shadow-caster',
+        variantSet: undefined,
+      },
+      attachments: { colorFormats: [], depthFormat: undefined, sampleCount: 1 },
     });
-    return { ...entry, paramSchema: paramSchemaProjection.schema, paramSchemaProjection };
-  }
-
-  it('reflects empty schema to empty BGL shape', () => {
-    const entry = shaderEntry([]);
-    const shape = deriveBglShapeFromShader(entry);
-    expect(shape.entries).toHaveLength(0);
-  });
-
-  it('reflects 1 f32 param to 1 entry UBO shape', () => {
-    const entry = shaderEntry([{ name: 'u_color', type: 'color' }]);
-    const shape = deriveBglShapeFromShader(entry);
-    expect(shape.entries.length).toBeGreaterThanOrEqual(1);
-    // The first entry should be a uniform buffer binding.
-    const e0 = shape.entries[0];
-    expect(e0?.buffer).toBeDefined();
-  });
-
-  it('reflects texture param with auto-paired sampler', () => {
-    const entry = shaderEntry([{ name: 't_albedo', type: 'texture2d' }]);
-    const shape = deriveBglShapeFromShader(entry);
-    // Derived layout: uniform coordinate record + auto-paired sampler + texture.
-    expect(shape.entries.length).toBe(3);
-  });
-
-  it('reflects storage_buffer param', () => {
-    const entry = shaderEntry([{ name: 's_mesh', type: 'storage_buffer' }]);
-    const shape = deriveBglShapeFromShader(entry);
-    expect(shape.entries.length).toBe(1);
-    expect(shape.entries[0]?.buffer).toBeDefined();
-  });
-
-  it('reflects multiple numeric params into single UBO entry', () => {
-    const entry = shaderEntry([
-      { name: 'u_baseColor', type: 'color' },
-      { name: 'u_metallic', type: 'f32' },
-      { name: 'u_roughness', type: 'f32' },
-    ]);
-    const shape = deriveBglShapeFromShader(entry);
-    // Multiple numeric types should merge into a single UBO binding entry.
-    const uboEntries = shape.entries.filter((e) => e.buffer !== undefined);
-    expect(uboEntries.length).toBe(1);
-  });
-
-  it('reflects sprite-1-slot shape (sprite base UBO only)', () => {
-    const entry = shaderEntry([{ name: 'u_baseColor', type: 'color' }]);
-    const shape = deriveBglShapeFromShader(entry);
-    expect(shape.entries.length).toBeGreaterThanOrEqual(1);
-  });
-
-  it('reflects unlit-1-slot shape (unlit base params)', () => {
-    const entry = shaderEntry([
-      { name: 'u_color', type: 'color' },
-      { name: 't_baseColor', type: 'texture2d' },
-    ]);
-    const shape = deriveBglShapeFromShader(entry);
-    // unlit: 1 UBO + 1 texture + 1 sampler = 3 entries
-    expect(shape.entries.length).toBe(3);
-  });
-
-  it('reflects pbr-1-slot shape (standard PBR params)', () => {
-    const entry = shaderEntry([
-      { name: 'u_baseColor', type: 'color' },
-      { name: 'u_metallicRoughness', type: 'vec2' },
-      { name: 'u_emissive', type: 'vec3' },
-      { name: 't_baseColor', type: 'texture2d' },
-      { name: 't_metallicRoughness', type: 'texture2d' },
-      { name: 't_normal', type: 'texture2d' },
-      { name: 't_emissive', type: 'texture2d' },
-      { name: 't_occlusion', type: 'texture2d' },
-    ]);
-    const shape = deriveBglShapeFromShader(entry);
-    // pbr: 1 UBO + 5 textures + 5 samplers = 11 entries
-    expect(shape.entries.length).toBe(11);
-  });
-
-  it('reflects pbr-skin-2-slot shape (standard PBR + skin palette)', () => {
-    // skin variant: same param schema as pbr but the variantSet triggers
-    // 2-slot mesh-array entry (meshes + palette).
-    const entry = shaderEntry([
-      { name: 'u_baseColor', type: 'color' },
-      { name: 't_baseColor', type: 'texture2d' },
-    ]);
-    const shape = deriveBglShapeFromShader(entry, 'SKIN_AVAILABLE=1');
-    expect(shape.entries.length).toBeGreaterThanOrEqual(1);
-  });
-
-  it('accepts hdrp variantSet without error (M1 skeleton, full reflection in M3)', () => {
-    const entry = shaderEntry([
-      { name: 'u_baseColor', type: 'color' },
-      { name: 'u_metallicRoughness', type: 'vec2' },
-    ]);
-    // M1: variantSet is accepted but detailed classification deferred to M3.
-    const shape = deriveBglShapeFromShader(entry, 'CLUSTER_FORWARD_AVAILABLE=true');
-    expect(shape.entries.length).toBeGreaterThanOrEqual(1);
-  });
-
-  it('reflects fullscreen-tonemap shape (post-process BGL)', () => {
-    const entry = shaderEntry([{ name: 't_color', type: 'texture2d' }]);
-    const shape = deriveBglShapeFromShader(entry);
-    // Fullscreen: 1 coordinate UBO + 1 texture + 1 sampler = 3 entries.
-    expect(shape.entries.length).toBe(3);
-  });
-
-  it('reflects fullscreen-fxaa shape (storage input)', () => {
-    const entry = shaderEntry([
-      { name: 't_input', type: 'texture2d' },
-      { name: 'u_params', type: 'vec2' },
-    ]);
-    const shape = deriveBglShapeFromShader(entry);
-    expect(shape.entries.length).toBe(3); // 1 UBO + 1 tex + 1 sampler
+    const r = validateSpec(s);
+    expect(r.ok).toBe(false);
+    if (!r.ok) expect(r.code).toBe('attachment-format-incompatible');
   });
 });
 
@@ -442,7 +290,7 @@ describe('getOrBuildPipeline', () => {
       createRenderPipeline: () => {
         throw new Error('should not be called on cache hit');
       },
-    } as unknown as import('@forgeax/engine-render/internal').PipelineDeviceProvider;
+    } as unknown as PipelineDeviceProvider;
 
     // M1: verify cache hit returns the pre-populated handle.
     const result = getOrBuildPipeline(spec, _deviceProvider, cache);
@@ -711,8 +559,6 @@ describe('passKindPolicyTable (M4-T1)', () => {
   it('exposes 10 passKind entries covering 9 attachment shapes + post-process catch-all', () => {
     const expectedKeys = [
       'forward',
-      'deferred',
-      'temporal',
       'shadow-caster',
       'point-shadow-caster',
       'skybox',
@@ -726,13 +572,6 @@ describe('passKindPolicyTable (M4-T1)', () => {
     for (const k of expectedKeys) {
       expect(passKindPolicyTable[k]).toBeDefined();
     }
-    expect(passKindPolicyTable.temporal?.shape).toBe('color-and-depth');
-    expect(passKindPolicyTable.temporal?.defaultColorOps?.clearValue).toEqual({
-      r: 0,
-      g: 0,
-      b: -1,
-      a: 1,
-    });
   });
 
   it('depth-only shape entries omit defaultColorOps', () => {