@forgeax/engine-runtime 0.1.3 → 0.1.6

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', () => {