@forgeax/engine-render 0.1.25 → 0.1.27

package/src/pipeline-spec.ts

@@ -248,7 +248,11 @@ export function cacheKeyOf(spec: PipelineSpec): string {
       stripSegment,
       `vl:${vlDigest}`,
       renderStateHash(renderState),
-    ].join(':') + uvSetCountSegment
+    ].join(':') +
+    uvSetCountSegment +
+    (shader.vertexEntry === undefined && shader.fragmentEntry === undefined
+      ? ''
+      : `:entries:${JSON.stringify([shader.vertexEntry ?? null, shader.fragmentEntry ?? null])}`)
   );
 }
 
@@ -417,7 +421,7 @@ export function buildPipelineDescriptor(
   const descriptor: Record<string, unknown> = {
     vertex: {
       module: modules.vertex,
-      entryPoint: modules.vertexEntryPoint ?? 'vs_main',
+      entryPoint: spec.shader.vertexEntry ?? modules.vertexEntryPoint ?? 'vs_main',
       buffers: vertexBuffers,
     },
   };
@@ -426,7 +430,7 @@ export function buildPipelineDescriptor(
   if (attachments.colorFormats.length > 0) {
     descriptor.fragment = {
       module: modules.fragment,
-      entryPoint: modules.fragmentEntryPoint ?? 'fs_main',
+      entryPoint: spec.shader.fragmentEntry ?? modules.fragmentEntryPoint ?? 'fs_main',
       targets: attachments.colorFormats.map((fmt) => {
         const target: Record<string, unknown> = { format: fmt };
         if (renderState?.blend !== undefined) {

package/src/record/__tests__/standard-pbr-ubo-layout.unit.test.ts

@@ -3,7 +3,8 @@ import { vec3 } from '@forgeax/engine-math';
 import { DEFAULT_STANDARD_PBR_PARAM_SCHEMA } from '@forgeax/engine-shader';
 import { derive } from '@forgeax/engine-types';
 import { describe, expect, it } from 'vitest';
-import type { MaterialSnapshot } from '../../render-system-extract';
+import { Materials } from '../../materials';
+import { type MaterialSnapshot, materialParamSchemaForMaterial } from '../../render-system-extract';
 import { applyMaterialTextureUvScales, buildPbrMaterialUboPayload } from '../main-pass-material';
 
 describe('Standard PBR UBO layout', () => {
@@ -69,6 +70,72 @@ describe('Standard PBR UBO layout', () => {
     );
   });
 
+  it('writes custom Standard Surface parameters at their published offsets', () => {
+    const custom = Materials.standard({
+      surfaceModule: 'game_3d::rusted_iron_surface',
+      colorSpace: 'linear',
+      parameters: [
+        { name: 'ironColor', type: 'color' },
+        { name: 'rustDark', type: 'color' },
+        { name: 'rustBright', type: 'color' },
+        { name: 'noiseScale', type: 'f32' },
+      ],
+      values: {
+        ironColor: [0.4, 0.45, 0.47, 1],
+        rustDark: [0.42, 0.085, 0.018, 1],
+        rustBright: [0.95, 0.34, 0.055, 1],
+        noiseScale: 1.85,
+      },
+    });
+    const schema = materialParamSchemaForMaterial(
+      custom.parameters ?? [],
+      'forgeax::default-standard-pbr',
+      custom.passes ?? [],
+    );
+    const material = {
+      baseColor: vec3.create(1, 1, 1),
+      metallic: 0,
+      roughness: 0.5,
+      materialShaderId: 'sha256:rusted-iron-forward',
+      materialParamSchema: schema,
+      paramSnapshot: {
+        ironColor: [0.4, 0.45, 0.47, 1],
+        rustDark: [0.42, 0.085, 0.018, 1],
+        rustBright: [0.95, 0.34, 0.055, 1],
+        noiseScale: 1.85,
+      },
+    } satisfies MaterialSnapshot;
+    const f32 = new Float32Array(buildPbrMaterialUboPayload(material).buffer);
+    const derived = derive(schema);
+    const numericOffsets = new Map(
+      derived.numericMembers.map((member) => [member.name, member.offset / 4]),
+    );
+
+    expect(numericOffsets.get('ironColor')).toBeDefined();
+    expect(numericOffsets.get('rustDark')).toBeDefined();
+    expect(numericOffsets.get('rustBright')).toBeDefined();
+    expect(numericOffsets.get('noiseScale')).toBeDefined();
+    const requireOffset = (name: string): number => {
+      const offset = numericOffsets.get(name);
+      if (offset === undefined) throw new Error(`missing numeric offset for ${name}`);
+      return offset;
+    };
+    const ironColorOffset = requireOffset('ironColor');
+    const rustDarkOffset = requireOffset('rustDark');
+    const rustBrightOffset = requireOffset('rustBright');
+    const noiseScaleOffset = requireOffset('noiseScale');
+    expect(f32.slice(ironColorOffset, ironColorOffset + 4)).toEqual(
+      new Float32Array([0.4, 0.45, 0.47, 1]),
+    );
+    expect(f32.slice(rustDarkOffset, rustDarkOffset + 4)).toEqual(
+      new Float32Array([0.42, 0.085, 0.018, 1]),
+    );
+    expect(f32.slice(rustBrightOffset, rustBrightOffset + 4)).toEqual(
+      new Float32Array([0.95, 0.34, 0.055, 1]),
+    );
+    expect(f32[noiseScaleOffset]).toBeCloseTo(1.85, 6);
+  });
+
   it('uses all seven user-region identity coordinate records in the no-snapshot fallback', () => {
     const material = {
       baseColor: vec3.create(0.7, 0.7, 0.7),

package/src/record/frame.ts

@@ -1,3 +1,4 @@
+import { uploadMaterialUniforms } from './material-uniforms';
 // @forgeax/engine-runtime - RenderSystem record stage: frame.
 // Extracted from render-system-record.ts (feat-20260704 M3/w17, pure move).
 
@@ -1925,7 +1926,11 @@ export function recordFrame(
     // the swap-chain fallback uses its raw storage view. The encoder and
     // sprite PSO must use the same resolved format because WebGPU requires
     // attachment and pipeline target formats to match.
-    const splitLdrSprite = computeSplitLdrSprite(validatedOrdered, tonemapActive);
+    const splitLdrSprite = computeSplitLdrSprite(
+      validatedOrdered,
+      tonemapActive,
+      transparentDispatch,
+    );
     let ldrSpritePassView: TextureView | null = null;
     if (splitLdrSprite) {
       const unormViewRes = internals.device.createTextureView(currentTexture, {});
@@ -2155,6 +2160,7 @@ export function recordFrame(
       directionalShadowCacheReuse: directionalShadowCache.reuse,
       ...(profilePhase !== undefined ? { profilePhase } : {}),
     };
+    uploadMaterialUniforms(passCtx);
     const fallbackReadbackRequest = createReflectionFallbackReadbackRequest(internals, frameState);
     if (fallbackReadbackRequest !== undefined) {
       frameState.reflectionFallbackReadback = fallbackReadbackRequest;