@forgeax/engine-render 0.1.27 → 0.1.29

package/src/__tests__/gpu-driven-pbr.integration.test.ts

@@ -0,0 +1,21 @@
+import { createStandardPbrArtifactReceipt } from '@forgeax/engine-shader';
+import { describe, expect, it } from 'vitest';
+
+describe('GPU-driven Standard PBR contract', () => {
+  it('keeps the producer receipt as the source of scene-index ABI facts', () => {
+    const receipt = createStandardPbrArtifactReceipt();
+    expect(receipt.directEntry).toBe('vs_main');
+    expect(receipt.sceneIndexEntry).toBe('vs_scene_index');
+    expect(receipt.resourceSlots).toHaveLength(14);
+    expect(receipt.alphaMask.cutoff).toBe('alphaCutoff');
+    expect(receipt.alphaMask.source).toBe('baseColor.a');
+    expect(receipt.reflection.layoutIdentity).toBe(receipt.receiptIdentity);
+  });
+
+  it('keeps Alpha Blend outside the opaque and Alpha Mask GPU lane', () => {
+    expect(createStandardPbrArtifactReceipt().alphaMask.cutoff).toBe('alphaCutoff');
+    expect(createStandardPbrArtifactReceipt().resourceSlots.every((slot) => slot.group === 1)).toBe(
+      true,
+    );
+  });
+});

package/src/__tests__/gpu-driven-production-fixture.ts

@@ -0,0 +1,96 @@
+import type { BindGroupLayout, RhiDevice, ShaderModule } from '@forgeax/engine-rhi';
+import { createStandardPbrArtifactReceipt } from '@forgeax/engine-shader';
+import { standardPbrProgramKey } from '../gpu-driven/pbr-program';
+import type { GpuDrivenProduction } from '../gpu-driven/production-raster';
+import type { PipelineState } from '../record/render-context';
+import type { RenderableSnapshot } from '../render-system-extract';
+
+const receipt = createStandardPbrArtifactReceipt();
+const materialShaderId = 'forgeax::default-standard-pbr';
+
+/** Receipt-backed fixture for tests of scene identity and raster resource routing. */
+export function preparedPbrSnapshot(source: RenderableSnapshot): RenderableSnapshot {
+  const material = { ...source.material, materialShaderId: materialShaderId };
+  return {
+    ...source,
+    material,
+    materials: source.materials.map((value) => ({ ...value, materialShaderId: materialShaderId })),
+    gpuDrivenDraws: (source.gpuDrivenDraws ?? []).map((draw) => ({
+      ...draw,
+      pipelineClass: `${materialShaderId}|${draw.topology}|rigid`,
+      materialResourceClass: 'standard-pbr-resources',
+      prepared: {
+        identity: { material: materialShaderId, geometry: 'fixture', deformation: 'rigid' },
+        receiptGeneration: receipt.generation,
+        directEntry: receipt.directEntry,
+        sceneIndexEntry: receipt.sceneIndexEntry,
+        materialRow: receipt.materialRow,
+        resourceSlots: receipt.resourceSlots,
+        uvSets: receipt.uvSets,
+        vertexInputs: receipt.vertexInputs,
+        alphaMask: receipt.alphaMask,
+        skinPaletteAddress: receipt.skinPaletteAddress,
+        topology: draw.topology,
+        indexed: draw.kind === 'indexed',
+        first: draw.first,
+        count: draw.count,
+        baseVertex: draw.baseVertex,
+      },
+    })),
+  };
+}
+
+export function standardPbrInputs(
+  device: RhiDevice,
+  shader: ShaderModule,
+  viewLayout: BindGroupLayout,
+): Pick<
+  Parameters<GpuDrivenProduction['prepare']>[0],
+  'standardPbrArtifact' | 'standardPbrPipelineState'
+> {
+  const materialLayout = device.createBindGroupLayout({ entries: [] }).unwrap();
+  const meshLayout = device
+    .createBindGroupLayout({
+      entries: [{ binding: 0, visibility: 1, buffer: { type: 'read-only-storage' } }],
+    })
+    .unwrap();
+  const instancesLayout = device
+    .createBindGroupLayout({
+      entries: [
+        { binding: 0, visibility: 1, buffer: { type: 'read-only-storage' } },
+        { binding: 1, visibility: 1, buffer: { type: 'read-only-storage' } },
+      ],
+    })
+    .unwrap();
+  const pbrPipelineLayout = device
+    .createPipelineLayout({
+      bindGroupLayouts: [viewLayout, materialLayout, meshLayout, instancesLayout],
+    })
+    .unwrap();
+  const programKey = standardPbrProgramKey(materialShaderId);
+  if (programKey === undefined) throw new Error(`unsupported fixture material ${materialShaderId}`);
+  const artifact = {
+    material: materialShaderId,
+    pass: 'forward',
+    wgsl: 'synthetic',
+    layoutIdentity: receipt.reflection.layoutIdentity,
+    bindings: [],
+    deps: [],
+    vertexInputs: receipt.vertexInputs as unknown as readonly Readonly<Record<string, unknown>>[],
+    receipt,
+  };
+  return {
+    standardPbrArtifact: artifact,
+    // These tests stop before material binding; only the raster layout is consumed.
+    standardPbrPipelineState: {
+      pbrPipelineLayout,
+      meshBindGroupLayout: meshLayout,
+      instancesBindGroupLayout: instancesLayout,
+      gpuDrivenInstancesBindGroupLayout: instancesLayout,
+      gpuDrivenPbrPipelineLayout: pbrPipelineLayout,
+      standardPbrShaderModule: shader,
+      gpuDrivenPbrPrograms: new Map([[programKey, { module: shader, artifact }]]),
+      standardPbrShaderUvSetCount: 1,
+    } as unknown as PipelineState,
+  };
+}