@forgeax/engine-render 0.1.32 → 0.1.33

package/src/__tests__/volumetric-fog-topology.unit.test.ts

@@ -8,6 +8,10 @@ const pipelineSource = readFileSync(
   fileURLToPath(new URL('../pipeline/standard-pipeline.ts', import.meta.url)),
   'utf8',
 );
+const forwardPipelineSource = readFileSync(
+  fileURLToPath(new URL('../pipeline/standard-forward-lane.ts', import.meta.url)),
+  'utf8',
+);
 const shaderSource = (name: string): string =>
   readFileSync(
     fileURLToPath(new URL(`../../../shader/src/volume/${name}`, import.meta.url)),
@@ -34,9 +38,8 @@ describe('volumetric fog RenderGraph topology', () => {
     expect(composite).toContain('abs(neighbor.a - center.a) * 6.0');
   });
 
-  it('derives deterministic integration density from the authored froxel depth', () => {
+  it('integrates the ray independently of packed visibility depth', () => {
     const integrate = shaderSource('volume-integrate.wgsl');
-    expect(integrate).toContain('let ray_step_count = visibility_depth;');
     expect(integrate).toContain('for (var step = 0u; step < ray_step_count; step = step + 1u)');
     expect(integrate).toContain('let visibility_depth = max(textureNumLayers(froxel) * 4u, 1u);');
   });
@@ -44,7 +47,7 @@ describe('volumetric fog RenderGraph topology', () => {
   it('keeps the Beer-Lambert extinction input physically non-negative', () => {
     const integrate = shaderSource('volume-integrate.wgsl');
     expect(integrate).toContain(
-      'let density_value = max(volume_scattering_density(world_position), 0.0);',
+      'let density_value = max(volume_scattering_density(world_position, volume_params.simulation.x), 0.0);',
     );
   });
 
@@ -114,6 +117,15 @@ describe('volumetric fog RenderGraph topology', () => {
     );
   });
 
+  it('keeps mesh CSM visibility on the shared volume owner in both Standard lanes', () => {
+    for (const source of [pipelineSource, forwardPipelineSource]) {
+      expect(source).toContain('addAuthoredVolumetricFogPasses');
+      expect(source).toContain('shadows.value.directional?.view');
+    }
+    expect(shaderSource('volume-inject.wgsl')).toContain('fn volume_cascade');
+    expect(shaderSource('volume-inject.wgsl')).toContain('sample_shadow_2d_kernel');
+  });
+
   it('encodes real volume work and non-constant optical semantics', () => {
     const passes = readFileSync(
       fileURLToPath(new URL('../volume/passes.ts', import.meta.url)),
@@ -182,6 +194,10 @@ describe('volumetric fog RenderGraph topology', () => {
     expect(frameSource).toContain('volumetricFogHistorySlot');
     expect(frameSource).toContain('volumetricFogHistorySignature');
     expect(frameSource).toContain('activeVolumetricFogSignature');
+    expect(frameSource).toContain('params[32] = fog.worldTimeSeconds ?? 0');
+    expect(
+      readFileSync(fileURLToPath(new URL('../volume/temporal.ts', import.meta.url)), 'utf8'),
+    ).toContain("reason: 'simulation-time'");
   });
 
   it('advances temporal history only after the accepted queue submit', () => {

package/src/assembly/analytic-fog-registration.ts

@@ -0,0 +1,14 @@
+import type { RenderSystem } from '../render-system';
+
+export function registerAnalyticFogPostProcess(
+  renderSystem: Pick<RenderSystem, 'registerBuiltinPostProcess'>,
+  source: string,
+  candidate: boolean,
+): void {
+  if (candidate) return;
+  renderSystem.registerBuiltinPostProcess('forgeax.analytic-fog', {
+    source,
+    params: { byteSize: 112, defaultValue: new Uint8Array(112) },
+    reads: ['scene-color', { key: 'scene-depth', sampleType: 'depth' }],
+  });
+}

package/src/assembly/fxaa-registration.ts

@@ -0,0 +1,17 @@
+import { FXAA_POST_PROCESS_ID } from '../render-contract';
+import type { RenderSystem } from '../render-system';
+
+/** Register the built-in FXAA post-process once for the active generation. */
+export function registerFxaaPostProcess(
+  renderSystem: Pick<RenderSystem, 'registerBuiltinPostProcess'>,
+  source: string,
+  registered: boolean,
+): boolean {
+  if (registered) return true;
+  renderSystem.registerBuiltinPostProcess(FXAA_POST_PROCESS_ID, {
+    source,
+    params: { byteSize: 16, defaultValue: new Uint8Array(16) },
+    reads: ['ldrColor'],
+  });
+  return true;
+}

package/src/assembly/lod-observation.ts

@@ -0,0 +1,12 @@
+import type { FrameReceipt } from '../render-contract';
+import type { RenderSystem } from '../render-system';
+
+export function observeLodOcclusionForReceipt(
+  renderSystem: Pick<RenderSystem, 'observeLodOcclusion'>,
+  receipt: Pick<FrameReceipt, 'frameId' | 'deviceGeneration'>,
+): Promise<void> {
+  return renderSystem.observeLodOcclusion({
+    frameId: receipt.frameId,
+    deviceGeneration: receipt.deviceGeneration,
+  });
+}

package/src/assembly/motion-blur-registration.ts

@@ -0,0 +1,17 @@
+import { MOTION_BLUR_PARAMS_BYTE_SIZE } from '../features/motion-blur/motion-blur-params';
+import type { PostProcessShaderEntry } from '../fullscreen-post-process-pass';
+import type { RenderSystem } from '../render-system';
+
+export function registerMotionBlurPostProcess(
+  renderSystem: Pick<RenderSystem, 'registerBuiltinPostProcess'>,
+  source: string,
+): void {
+  renderSystem.registerBuiltinPostProcess('forgeax.motion-blur', {
+    source,
+    params: {
+      byteSize: MOTION_BLUR_PARAMS_BYTE_SIZE,
+      defaultValue: new Uint8Array(MOTION_BLUR_PARAMS_BYTE_SIZE),
+    },
+    reads: ['scene-color', 'scene-temporal'],
+  } satisfies PostProcessShaderEntry);
+}

package/src/assembly/renderer-facade.ts

@@ -15,6 +15,7 @@ import {
   type RendererOperationCause,
   RendererOperationError,
 } from '../errors/render';
+import { MotionBlurValidationError } from '../features/motion-blur/motion-blur-params';
 import {
   STANDARD_LIGHT_COUNTS,
   STANDARD_PIPELINE_ID,
@@ -63,6 +64,7 @@ export function exposeRenderer(renderer: RendererHostImplementation): Renderer {
           cause: structuredRendererCause(cause, 'renderer-event'),
         });
   const drawError = (cause: RhiError | RenderError): RenderError => {
+    if (cause instanceof MotionBlurValidationError) return cause;
     if (cause instanceof RendererOperationError) return cause;
     if (cause instanceof RendererContractFailureError) {
       return new RendererOperationError('device-operation-failed', {

package/src/assembly/temporal-post-process-prewarm.ts

@@ -0,0 +1,40 @@
+import type { Result, RhiDevice, RhiError, ShaderModule } from '@forgeax/engine-rhi';
+import type { ManifestEntry } from '@forgeax/engine-types';
+import { postProcessShaderModuleLabel } from '../fullscreen-post-process-pass';
+import { invokeDeviceCreateShaderModule } from './material-shader-policy';
+import { runShimStep } from './renderer-helpers';
+
+export type AsyncShaderModuleFactory =
+  | ((
+      device: RhiDevice,
+      desc: { readonly code: string; readonly label?: string },
+    ) => Promise<Result<ShaderModule, RhiError>>)
+  | undefined;
+
+/** Create the shared readiness prewarmer for temporal/fullscreen shader entries. */
+export function createTemporalShaderPrewarmer(input: {
+  readonly device: RhiDevice;
+  readonly asyncCreateShaderModule: AsyncShaderModuleFactory;
+  readonly seedShaderModule: (label: string, module: ShaderModule) => void;
+}): (entry: ManifestEntry | undefined, id: string) => Promise<void> {
+  return async (entry, id): Promise<void> => {
+    if (entry === undefined) return;
+    const prewarm = await runShimStep(
+      () =>
+        input.asyncCreateShaderModule
+          ? input.asyncCreateShaderModule(input.device, {
+              code: entry.wgsl,
+              label: postProcessShaderModuleLabel(id, entry.wgsl),
+            })
+          : invokeDeviceCreateShaderModule(input.device, {
+              code: entry.wgsl,
+              label: postProcessShaderModuleLabel(id, entry.wgsl),
+            }),
+      'shader-compile-failed',
+      `${id} shader module compiled (unified post-process prewarm)`,
+      `inspect manifest ${id} entry composed wgsl; check device.features`,
+    );
+    if (!prewarm.ok) throw prewarm.error;
+    input.seedShaderModule(postProcessShaderModuleLabel(id, entry.wgsl), prewarm.value);
+  };
+}

package/src/assembly/webgpu-ready-contract.ts

@@ -7,8 +7,13 @@ export const MIPMAP_PREWARM_FORMATS: readonly GPUTextureFormat[] = [
   'rgba8unorm',
   'rgba16float',
 ];
-export const BRIGHT_PARAMS_BYTES = 16;
-export const BLUR_PARAMS_BYTES = 16;
-export const COMPOSITE_PARAMS_BYTES = 16;
+// WebGPU requires every dynamic uniform-buffer binding offset to satisfy the
+// device's minimum uniform-buffer offset alignment.  Keep one shared buffer
+// per pass family, with the small POD payload at the start of each 256-byte
+// slice so every level remains a single production path.
+export const BLOOM_UNIFORM_PARAMS_STRIDE_BYTES = 256;
+export const BLOOM_DOWNSAMPLE_PARAMS_BYTES = 5 * BLOOM_UNIFORM_PARAMS_STRIDE_BYTES;
+export const BLOOM_UPSAMPLE_PARAMS_BYTES = 4 * BLOOM_UNIFORM_PARAMS_STRIDE_BYTES;
+export const BLOOM_COMPOSITE_PARAMS_BYTES = 16;
 export const HDR_COLOR_ATTACHMENT_FORMAT: GPUTextureFormat = 'rgba16float';
 export const DEPTH_TEXTURE_FORMAT: GPUTextureFormat = 'depth24plus-stencil8';