@forgeax/engine-render 0.1.29 → 0.1.31

package/src/ssr/graph.ts

@@ -481,23 +481,22 @@ export function addSsrSpatialPasses<FrameCtx extends RenderGraphFrame>(
   );
   if (added.ok) passNames.push('ssr-hiz-seed');
   if (!added.ok) return added;
-  for (let level = 1; level < hiz.levels.length; level += 1) {
-    const source = hiz.levels[level - 1];
-    const target = hiz.levels[level];
-    if (source === undefined || target === undefined) return missingInput(`hiz.mip${level}`);
-    const sourceExtent = hiz.plan.levels[level - 1];
-    const targetExtent = hiz.plan.levels[level];
+  if (hiz.levels.length > 1) {
     added = addPass(
       graph,
-      `ssr-hiz-reduce-${level}`,
-      [
-        { resource: source, usage: 'sampled-read' },
-        { resource: target, usage: 'storage-write' },
-      ],
+      'ssr-hiz-reduce-chain',
+      hiz.levels.map((resource, level) => ({
+        resource,
+        usage:
+          level === 0
+            ? 'sampled-read'
+            : level === hiz.levels.length - 1
+              ? 'storage-write'
+              : 'sampled-storage-write',
+      })),
       ({ pass, frame, resources: resolver }) => {
         const shader = shaderSource(frame, 'hizReduce');
-        if (shader === undefined || sourceExtent === undefined || targetExtent === undefined)
-          return;
+        if (shader === undefined) return;
         hizReduceState ??= computeState(
           frame,
           shader,
@@ -506,28 +505,33 @@ export function addSsrSpatialPasses<FrameCtx extends RenderGraphFrame>(
           'ssr_hiz_reduce',
         );
         pass.setPipeline(hizReduceState.pipeline);
-        pass.setBindGroup(
-          0,
-          bindGroup(frame, hizReduceState, [
-            {
-              binding: 0,
-              resource: { kind: 'textureView', value: resolvedView(resolver, source) },
-            },
-            {
-              binding: 1,
-              resource: { kind: 'textureView', value: resolvedView(resolver, target) },
-            },
-          ]),
-        );
-        pass.dispatchWorkgroups(
-          Math.ceil(targetExtent.width / 8),
-          Math.ceil(targetExtent.height / 8),
-          1,
-        );
+        // Compute dispatches are ordered usage scopes. Each dispatch reads
+        // only the completed preceding mip and writes a disjoint next mip.
+        for (let level = 1; level < hiz.levels.length; level++) {
+          const source = hiz.levels[level - 1];
+          const target = hiz.levels[level];
+          const extent = hiz.plan.levels[level];
+          if (source === undefined || target === undefined || extent === undefined)
+            throw pipelineError('Hi-Z mip chain');
+          pass.setBindGroup(
+            0,
+            bindGroup(frame, hizReduceState, [
+              {
+                binding: 0,
+                resource: { kind: 'textureView', value: resolvedView(resolver, source) },
+              },
+              {
+                binding: 1,
+                resource: { kind: 'textureView', value: resolvedView(resolver, target) },
+              },
+            ]),
+          );
+          pass.dispatchWorkgroups(Math.ceil(extent.width / 8), Math.ceil(extent.height / 8), 1);
+        }
       },
     );
     if (!added.ok) return added;
-    passNames.push(`ssr-hiz-reduce-${level}`);
+    passNames.push('ssr-hiz-reduce-chain');
   }
   added = addPass(
     graph,
@@ -708,21 +712,21 @@ export function addSsrSpatialPasses<FrameCtx extends RenderGraphFrame>(
     if (!added.ok) return added;
     passNames.push('ssr-temporal');
   }
-  for (let level = 1; level < reflectionLevels.length; level++) {
-    const previous = reflectionLevels[level - 1];
-    const target = reflectionLevels[level];
-    if (previous === undefined || target === undefined || resolved === undefined)
-      return missingInput('reflection-mip');
-    const width = Math.max(1, resolved.width >> level);
-    const height = Math.max(1, resolved.height >> level);
-    const name = `ssr-reflection-mip-${level}`;
+  if (reflectionLevels.length > 1 && resolved !== undefined) {
+    const output = resolved;
+    const name = 'ssr-reflection-mip-chain';
     const added = addPass(
       graph,
       name,
-      [
-        { resource: previous, usage: 'sampled-read' },
-        { resource: target, usage: 'storage-write' },
-      ],
+      reflectionLevels.map((resource, level) => ({
+        resource,
+        usage:
+          level === 0
+            ? 'sampled-read'
+            : level === reflectionLevels.length - 1
+              ? 'storage-write'
+              : 'sampled-storage-write',
+      })),
       ({ pass, frame, resources: resolver }) => {
         const source = shaderSource(frame, 'temporal');
         if (source === undefined) return;
@@ -745,20 +749,36 @@ export function addSsrSpatialPasses<FrameCtx extends RenderGraphFrame>(
           'ssr_reflection_mip',
         );
         pass.setPipeline(reflectionMipState.pipeline);
-        pass.setBindGroup(
-          0,
-          bindGroup(frame, reflectionMipState, [
-            {
-              binding: 0,
-              resource: { kind: 'textureView', value: resolvedView(resolver, previous) },
-            },
-            {
-              binding: 7,
-              resource: { kind: 'textureView', value: resolvedView(resolver, target) },
-            },
-          ]),
-        );
-        pass.dispatchWorkgroups(Math.ceil(width / 8), Math.ceil(height / 8), 1);
+        for (let level = 1; level < reflectionLevels.length; level++) {
+          const previous = reflectionLevels[level - 1];
+          const target = reflectionLevels[level];
+          if (previous === undefined || target === undefined)
+            throw pipelineError('reflection mip chain');
+          pass.setBindGroup(
+            0,
+            bindGroup(frame, reflectionMipState, [
+              {
+                binding: 0,
+                resource: {
+                  kind: 'textureView',
+                  value: resolvedView(resolver, previous),
+                },
+              },
+              {
+                binding: 7,
+                resource: {
+                  kind: 'textureView',
+                  value: resolvedView(resolver, target),
+                },
+              },
+            ]),
+          );
+          pass.dispatchWorkgroups(
+            Math.ceil(Math.max(1, output.width >> level) / 8),
+            Math.ceil(Math.max(1, output.height >> level) / 8),
+            1,
+          );
+        }
       },
     );
     if (!added.ok) return added;

package/src/temporal/gpu.ts

@@ -251,6 +251,11 @@ export function getTemporalBindGroupResources(state: TemporalGpuState): {
           visibility: 2,
           texture: { sampleType: 'unfilterable-float', viewDimension: '2d' },
         },
+        {
+          binding: 11,
+          visibility: 2,
+          texture: { sampleType: 'unfilterable-float', viewDimension: '2d' },
+        },
       ],
     });
     if (!layout.ok) throw layout.error;

package/src/temporal/standard-scene-data.ts

@@ -4,6 +4,8 @@ import type {
   RenderGraphError,
 } from '@forgeax/engine-render-graph';
 import { ok, type Result } from '@forgeax/engine-types';
+import type { RenderExtent } from '../pipeline/render-extent';
+import { renderExtentSize } from '../pipeline/render-extent';
 import type { RenderPipelineFrame, RenderPipelineTarget } from '../render-pipeline';
 import { createRenderPipelineTarget } from '../render-pipeline';
 import { addTypedFullscreenPass, addTypedScenePass } from '../typed-render-graph-primitives';
@@ -135,8 +137,12 @@ const TEMPORAL_TARGET: GraphTextureDescriptor = {
 /** The single Standard TAA current-frame producer target. */
 export function createStandardSceneDataTarget(
   graph: RenderGraphBuilder<RenderPipelineFrame>,
+  extent?: RenderExtent,
 ): Result<StandardSceneDataTargets, RenderGraphError> {
-  const temporal = createRenderPipelineTarget(graph, 'standard-scene-temporal', TEMPORAL_TARGET);
+  const temporal = createRenderPipelineTarget(graph, 'standard-scene-temporal', {
+    ...TEMPORAL_TARGET,
+    size: extent === undefined ? TEMPORAL_TARGET.size : renderExtentSize(extent, 'internal'),
+  });
   return temporal.ok ? ok({ temporal: temporal.value }) : temporal;
 }
 

package/src/temporal/target-coverage-attachment.ts

@@ -0,0 +1,72 @@
+import type {
+  GraphTextureDescriptor,
+  RenderGraphBuilder,
+  RenderGraphError,
+} from '@forgeax/engine-render-graph';
+import { ok, type Result } from '@forgeax/engine-types';
+import { GPU_TEXTURE_USAGE_COPY_SRC } from '../gpu-texture-usage';
+import type { RenderExtent } from '../pipeline/render-extent';
+import type { RenderPipelineFrame, RenderPipelineTarget } from '../render-pipeline';
+import { createRenderPipelineTarget } from '../render-pipeline';
+import { addTypedScenePass } from '../typed-render-graph-primitives';
+
+export interface TargetCoverageAttachment {
+  readonly coverage: RenderPipelineTarget;
+  readonly depth: RenderPipelineTarget;
+  readonly outputWidth: number;
+  readonly outputHeight: number;
+}
+
+const COVERAGE_DESCRIPTOR: GraphTextureDescriptor = {
+  format: 'r8unorm',
+  size: 'surface',
+  sampleCount: 1,
+  usage: GPU_TEXTURE_USAGE_COPY_SRC,
+};
+
+const COVERAGE_DEPTH_DESCRIPTOR: GraphTextureDescriptor = {
+  format: 'depth24plus-stencil8',
+  size: 'surface',
+  sampleCount: 1,
+};
+
+/** Create the per-generation output-domain coverage/depth pair. */
+export function createTargetCoverageAttachment(
+  graph: RenderGraphBuilder<RenderPipelineFrame>,
+  extent: RenderExtent,
+): Result<TargetCoverageAttachment, RenderGraphError> {
+  const coverage = createRenderPipelineTarget(graph, 'standard-scene-coverage', {
+    ...COVERAGE_DESCRIPTOR,
+    size: { width: extent.outputWidth, height: extent.outputHeight },
+  });
+  if (!coverage.ok) return coverage;
+  const depth = createRenderPipelineTarget(graph, 'standard-scene-coverage-depth', {
+    ...COVERAGE_DEPTH_DESCRIPTOR,
+    size: { width: extent.outputWidth, height: extent.outputHeight },
+  });
+  if (!depth.ok) return depth;
+  return ok({
+    coverage: coverage.value,
+    depth: depth.value,
+    outputWidth: extent.outputWidth,
+    outputHeight: extent.outputHeight,
+  });
+}
+
+/** Rasterize the real Standard draw list into binary output-domain coverage. */
+export function addTargetCoveragePass(
+  graph: RenderGraphBuilder<RenderPipelineFrame>,
+  target: TargetCoverageAttachment,
+): Result<void, RenderGraphError> {
+  return addTypedScenePass(graph, {
+    name: 'standard-scene-coverage',
+    color: target.coverage,
+    colorTargets: [target.coverage],
+    depth: target.depth,
+    selector: { LightMode: ['Deferred', 'Forward'] },
+    passKind: 'temporal',
+    clearColor: [0, 0, 0, 0],
+    depthLoadOp: 'clear',
+    coverageOnly: true,
+  });
+}

package/src/temporal/temporal-view.ts

@@ -4,8 +4,8 @@ import type { CameraSnapshot } from '../render-contract';
 
 export const TEMPORAL_JITTER_SAMPLE_COUNT = 8;
 
-/** Current temporal view owns fixed surface dimensions; dynamic TAAU is deferred. */
-export const TEMPORAL_TAAU_DEPENDENCY_STATUS = 'dependency-deferred' as const;
+/** TAAU shares the temporal view owner; its internal dimensions are optional. */
+export const TEMPORAL_TAAU_DEPENDENCY_STATUS = 'available' as const;
 
 export type TemporalViewResetReason =
   | 'first-frame'
@@ -31,6 +31,8 @@ export interface TemporalView {
   readonly historyValid: boolean;
   readonly resetReason: TemporalViewResetReason | undefined;
   readonly currentJitterUv: readonly [number, number];
+  readonly internalWidth: number;
+  readonly internalHeight: number;
   readonly previousJitterUv: readonly [number, number];
   readonly currentJitteredViewProjection: Float32Array;
   readonly currentUnjitteredViewProjection: Float32Array;
@@ -45,6 +47,8 @@ export interface TemporalViewInput {
   readonly temporalFrameIndex: number;
   readonly surfaceWidth: number;
   readonly surfaceHeight: number;
+  readonly internalWidth?: number;
+  readonly internalHeight?: number;
   readonly lastSubmitted?: SubmittedTemporalView;
 }
 
@@ -125,8 +129,8 @@ export function projectTemporalView(input: TemporalViewInput): TemporalView {
   const viewId = temporalViewId(camera.worldId ?? 0, camera.entityKey ?? 0);
   const currentJitterUv = temporalJitterUv(
     input.temporalFrameIndex,
-    input.surfaceWidth,
-    input.surfaceHeight,
+    input.internalWidth ?? input.surfaceWidth,
+    input.internalHeight ?? input.surfaceHeight,
   );
   const view = mat4.invert(mat4.create(), camera.world);
   const projection = cameraProjection(camera);
@@ -145,6 +149,8 @@ export function projectTemporalView(input: TemporalViewInput): TemporalView {
     historyValid,
     resetReason: reason,
     currentJitterUv,
+    internalWidth: input.internalWidth ?? input.surfaceWidth,
+    internalHeight: input.internalHeight ?? input.surfaceHeight,
     previousJitterUv: historyValid
       ? (input.lastSubmitted?.jitterUv ?? currentJitterUv)
       : currentJitterUv,

package/src/temporal/view.ts

@@ -28,6 +28,9 @@ export interface TemporalViewInput {
   readonly antialias: Antialias;
   readonly width: number;
   readonly height: number;
+  /** Internal scene extent used to normalize TAA jitter for TAAU. */
+  readonly internalWidth?: number;
+  readonly internalHeight?: number;
   readonly frameIndex?: number;
   readonly historyVersion?: number;
   readonly viewIdentity?: string;
@@ -47,6 +50,9 @@ interface TemporalViewSnapshot {
   readonly antialias: Antialias;
   readonly width: number;
   readonly height: number;
+  /** Internal scene extent used for TAAU jitter normalization. */
+  readonly internalWidth: number;
+  readonly internalHeight: number;
   readonly frameIndex: number;
   readonly historyVersion: number;
   readonly viewIdentity: string;
@@ -93,6 +99,8 @@ function validDimension(value: number, field: string): number {
 export function createTemporalView(input: TemporalViewInput): TemporalView {
   const width = validDimension(input.width, 'width');
   const height = validDimension(input.height, 'height');
+  const internalWidth = validDimension(input.internalWidth ?? width, 'internalWidth');
+  const internalHeight = validDimension(input.internalHeight ?? height, 'internalHeight');
   const historyVersion = input.historyVersion ?? 0;
   const frameIndex = input.frameIndex ?? 0;
   const deviceGeneration = input.deviceGeneration ?? 0;
@@ -109,6 +117,8 @@ export function createTemporalView(input: TemporalViewInput): TemporalView {
     ...input,
     width,
     height,
+    internalWidth,
+    internalHeight,
     frameIndex,
     historyVersion,
     viewIdentity: input.viewIdentity ?? 'camera:default',
@@ -135,11 +145,11 @@ export function createTemporalView(input: TemporalViewInput): TemporalView {
     jitterCancellationUv:
       jitter === undefined
         ? undefined
-        : (Object.freeze([jitter[0] / width, jitter[1] / height]) as Jitter),
+        : (Object.freeze([jitter[0] / internalWidth, jitter[1] / internalHeight]) as Jitter),
     currentJitterUv:
       jitter === undefined
         ? undefined
-        : (Object.freeze([jitter[0] / width, jitter[1] / height]) as Jitter),
+        : (Object.freeze([jitter[0] / internalWidth, jitter[1] / internalHeight]) as Jitter),
     historyValid: normalized.historyValid,
     temporalFrameIndex: frameIndex,
     currentUnjitteredViewProjection: input.currentUnjitteredViewProjection,

package/src/transmission/__tests__/standard-transmission.dawn.test.ts

@@ -360,6 +360,30 @@ function luma(pixel: readonly [number, number, number, number]): number {
 }
 
 describe('Standard transmission Dawn ROI', () => {
+  it('completes a 300-frame transmission stream without renderer errors', async () => {
+    const result = await renderCase(
+      {
+        name: 'sustained-transmission',
+        transmission: 1,
+        ior: 1.5,
+        thickness: 0.5,
+        roughness: 0.3,
+        attenuationColor: [0.7, 0.8, 0.9],
+        attenuationDistance: 2,
+        renderPath: 'forward',
+      },
+      300,
+    );
+    expect(result.framesObserved).toBe(300);
+    expect(result.errors).toEqual([]);
+    expect(result.observation).toBe(true);
+    expect(result.passNames).toContain('transmission-forward');
+    expect(result.pixel.every(Number.isFinite)).toBe(true);
+    process.stdout.write(
+      `[transmission-smoke-frames] ${JSON.stringify({ framesObserved: result.framesObserved })}\n`,
+    );
+  }, 120_000);
+
   it('uses linear HDR observation and responds to F0, Beer, texture, TIR, and fallback inputs', async () => {
     const baseline = await renderCase({
       name: 'baseline',
@@ -534,15 +558,6 @@ describe('Standard transmission Dawn ROI', () => {
       process.stdout.write(
         `[smoke] PASS - transmission stability frames=${result.framesObserved}\n`,
       );
-      process.stdout.write(
-        `[forgeax-smoke-receipt] ${JSON.stringify({
-          schemaVersion: 1,
-          gateId: 'app-learn-render-6-pbr-4-transmission-refraction/smoke',
-          commandId: 'smoke',
-          framesObserved: result.framesObserved,
-          completed: true,
-        })}\n`,
-      );
     }, 120_000);
   }
 });

package/src/typed-render-graph-primitives.ts

@@ -256,6 +256,7 @@ export function addTypedSkyboxPass(
 }
 
 export interface TypedScenePassOptions {
+  readonly environment?: import('./environment/ibl').GraphEnvironment | undefined;
   readonly name: string;
   readonly color: RenderPipelineTarget;
   readonly depth: RenderPipelineTarget;
@@ -270,6 +271,7 @@ export interface TypedScenePassOptions {
   readonly clearColor?: readonly [number, number, number, number] | undefined;
   readonly colorLoadOp?: GPULoadOp | readonly GPULoadOp[] | undefined;
   readonly depthLoadOp?: GPULoadOp | undefined;
+  readonly coverageOnly?: boolean | undefined;
   readonly recordMode?: 'opaque' | 'transmission' | 'transparent' | undefined;
   /** Exclude material/pass pairs consumed by an earlier graph lane. */
   readonly excludeSelector?: PassSelector | undefined;
@@ -299,6 +301,12 @@ export function addTypedScenePass(
     ...(options.transmissionBackdrop === undefined
       ? []
       : [{ resource: options.transmissionBackdrop, usage: 'sampled-read' as const }]),
+    ...(options.environment === undefined
+      ? []
+      : [options.environment.irradiance, options.environment.prefilter].map((resource) => ({
+          resource,
+          usage: 'sampled-read' as const,
+        }))),
     ...(options.extraAccesses ?? []),
     ...(options.gpuDriven?.accesses ?? []),
   ];
@@ -386,6 +394,14 @@ export function addTypedScenePass(
       const activeOcclusion = options.occlusion;
       const passContext: _InternalRenderPipelineContext = {
         ...internal,
+        ...(options.environment === undefined
+          ? {}
+          : {
+              environmentIbl: {
+                irradiance: resolvedView(resources, options.environment.irradiance),
+                prefilter: resolvedView(resources, options.environment.prefilter),
+              },
+            }),
         ...(activeOcclusion === undefined ? {} : { occlusion: activeOcclusion }),
         geometryColorView: colorViews[0] ?? null,
         geometryDepthView: depthView,
@@ -410,6 +426,7 @@ export function addTypedScenePass(
         passKind: options.passKind ?? 'forward',
         ...(options.clearColor === undefined ? {} : { clearColor: options.clearColor }),
         ...(options.recordMode === undefined ? {} : { recordMode: options.recordMode }),
+        ...(options.coverageOnly === undefined ? {} : { coverageOnly: options.coverageOnly }),
         ...(options.excludeSelector === undefined
           ? {}
           : { excludeSelector: options.excludeSelector }),
@@ -668,6 +685,10 @@ export interface TypedFullscreenPassOptions {
 
 export interface TypedTemporalResolveTargets {
   readonly scene: RenderPipelineTarget;
+  /** Output-domain coverage produced by the Standard raster witness. */
+  readonly coverage?: RenderPipelineTarget | undefined;
+  /** Paired output-domain depth used to keep the producer observable. */
+  readonly coverageDepth?: RenderPipelineTarget | undefined;
   /** Optional producer-owned R-channel reactivity in current screen space. */
   readonly secondaryReactivity?: GraphTextureView;
   readonly currentTemporal: RenderPipelineTarget;
@@ -688,6 +709,12 @@ export function addTypedTemporalResolvePass(
     accesses: [
       { resource: targets.scene.view, usage: 'sampled-read' },
       { resource: targets.currentTemporal.view, usage: 'sampled-read' },
+      ...(targets.coverage === undefined
+        ? []
+        : [{ resource: targets.coverage.view, usage: 'sampled-read' as const }]),
+      ...(targets.coverageDepth === undefined
+        ? []
+        : [{ resource: targets.coverageDepth.view, usage: 'sampled-read' as const }]),
       { resource: targets.historyColor.view, usage: 'sampled-read' },
       { resource: targets.historyTemporal.view, usage: 'sampled-read' },
       { resource: targets.historyStability.view, usage: 'sampled-read' },
@@ -746,6 +773,7 @@ export function addTypedTemporalResolvePass(
       words[2] = state.valid && (frame.camera.temporal?.historyValid ?? true) ? 1 : 0;
       words[3] = frame.camera.temporal?.temporalFrameIndex ?? 0;
       words[4] = Number(targets.secondaryReactivity !== undefined);
+      words[5] = Number(targets.coverage !== undefined);
       const written = frame.runtime.device.queue.writeBuffer(params, 0, new Uint8Array(payload));
       if (!written.ok)
         throwTemporalEncodeFailure('TAA resolve params upload succeeds', written.error);
@@ -773,6 +801,16 @@ export function addTypedTemporalResolvePass(
                   : resolvedView(resources, targets.secondaryReactivity),
             },
           },
+          {
+            binding: 11,
+            resource: {
+              kind: 'textureView',
+              value:
+                targets.coverage === undefined
+                  ? currentTemporal
+                  : resolvedView(resources, targets.coverage.view),
+            },
+          },
         ] as never,
       });
       if (!bindGroup.ok) {

package/src/volume/component.ts

@@ -35,6 +35,7 @@ export interface VolumetricFogAuthoring {
   readonly light: EntityHandle;
   /** The optional same-World SpotLight paired with a PointLight. */
   readonly spotLight?: EntityHandle;
+  /** Linear scalar density over bounds; the renderer adds no noise or animation. */
   readonly density: VolumeDensityBinding;
   readonly bounds: VolumeBounds;
   readonly extinction: readonly [number, number, number];

package/src/volume/passes.ts

@@ -481,9 +481,9 @@ export function addVolumetricFogPasses(
       const densitySampler = frame.runtime.device.createSampler({
         minFilter: 'linear',
         magFilter: 'linear',
-        addressModeU: 'repeat',
-        addressModeV: 'repeat',
-        addressModeW: 'repeat',
+        addressModeU: 'clamp-to-edge',
+        addressModeV: 'clamp-to-edge',
+        addressModeW: 'clamp-to-edge',
       });
       if (!densitySampler.ok) throw densitySampler.error;
       const bindings = volumeBindGroup(frame, integrate.layout, [