@forgeax/engine-render 0.1.7 → 0.1.20

package/src/features/motion-blur/motion-blur-params.ts

@@ -0,0 +1,89 @@
+import { err, ok, type Result } from '@forgeax/engine-types';
+
+export interface MotionBlurParams {
+  readonly shutterAngle: number;
+  readonly maxRadiusPixels: number;
+  readonly sampleCount: number;
+}
+
+export const DEFAULT_MOTION_BLUR_PARAMS: MotionBlurParams = Object.freeze({
+  shutterAngle: 180,
+  maxRadiusPixels: 32,
+  sampleCount: 8,
+});
+
+export interface MotionBlurInvalidParamsDetail {
+  readonly field: keyof MotionBlurParams;
+  readonly value: unknown;
+  readonly min: number;
+  readonly max: number;
+  readonly integer?: boolean;
+}
+
+export class MotionBlurValidationError extends Error {
+  readonly code = 'motion-blur-invalid-params' as const;
+  readonly expected: string;
+  readonly hint: string;
+  readonly detail: MotionBlurInvalidParamsDetail;
+
+  constructor(detail: MotionBlurInvalidParamsDetail) {
+    const integer = detail.integer === true ? 'integer ' : '';
+    const expected = `${detail.field} ${integer}in [${detail.min}, ${detail.max}]`;
+    super(`motion-blur-invalid-params: ${expected}`);
+    this.name = 'MotionBlurValidationError';
+    this.expected = expected;
+    this.hint = `set ${detail.field} to an ${integer}value in [${detail.min}, ${detail.max}]`;
+    this.detail = detail;
+  }
+}
+
+function validateField(
+  field: keyof MotionBlurParams,
+  value: number,
+  min: number,
+  max: number,
+  integer = false,
+): MotionBlurValidationError | undefined {
+  if (
+    !Number.isFinite(value) ||
+    value < min ||
+    value > max ||
+    (integer && !Number.isInteger(value))
+  ) {
+    return new MotionBlurValidationError({
+      field,
+      value,
+      min,
+      max,
+      ...(integer ? { integer } : {}),
+    });
+  }
+  return undefined;
+}
+
+export function validateMotionBlurParams(
+  input: Partial<MotionBlurParams> | undefined,
+): Result<MotionBlurParams, MotionBlurValidationError> {
+  const value = input ?? {};
+  const shutterAngle = value.shutterAngle ?? DEFAULT_MOTION_BLUR_PARAMS.shutterAngle;
+  const maxRadiusPixels = value.maxRadiusPixels ?? DEFAULT_MOTION_BLUR_PARAMS.maxRadiusPixels;
+  const sampleCount = value.sampleCount ?? DEFAULT_MOTION_BLUR_PARAMS.sampleCount;
+  const shutterError = validateField('shutterAngle', shutterAngle, 0, 360);
+  if (shutterError !== undefined) return err(shutterError);
+  const radiusError = validateField('maxRadiusPixels', maxRadiusPixels, 0, 64);
+  if (radiusError !== undefined) return err(radiusError);
+  const sampleError = validateField('sampleCount', sampleCount, 4, 16, true);
+  if (sampleError !== undefined) return err(sampleError);
+  return ok(Object.freeze({ shutterAngle, maxRadiusPixels, sampleCount }));
+}
+
+export function motionBlurTemporalDemand(params: MotionBlurParams | undefined): boolean {
+  return params !== undefined && params.shutterAngle > 0;
+}
+
+export function resolveMotionBlurParams(
+  input: Partial<MotionBlurParams> | undefined,
+): Result<MotionBlurParams | undefined, MotionBlurValidationError> {
+  if (input === undefined) return ok(undefined);
+  return validateMotionBlurParams(input);
+}

package/src/features/plan.ts

@@ -2,6 +2,7 @@ import type { GraphBufferAccess, GraphTextureAccess } from '@forgeax/engine-rend
 import type { RhiCaps, TextureFormat } from '@forgeax/engine-rhi';
 import { err, ok, type Result } from '@forgeax/engine-types';
 import type { RenderError } from '../errors/render';
+import type { SceneDataTarget } from '../temporal/scene-data';
 import type {
   RenderFeatureGpuBufferUsage,
   RenderFeatureGpuProgramDescriptor,
@@ -10,10 +11,27 @@ import type { RenderFeaturePipelineDescriptor } from './prepared-graphics';
 
 export type RenderFeatureResourceUsage = GraphBufferAccess | GraphTextureAccess;
 
+/**
+ * Renderer-owned binding layout contract for a material shader.
+ *
+ * Producer features use this read-only projection to describe which logical
+ * scene resources a custom material consumes. The render owner remains the
+ * source of truth for the shader source and its pipeline layout.
+ */
+export type RenderFeatureMaterialShaderBindingContract =
+  | 'group-0'
+  | 'group-0-resource'
+  | 'view-only'
+  | 'view-and-scene-depth'
+  | 'render-material';
+
 export type RenderFeatureFullscreenRead =
   | string
   | { readonly key: string; readonly sampleType?: 'depth' };
 
+/** A named graph target or an authorized semantic sampled-read target. */
+export type RenderFeatureSampledTarget = string | SceneDataTarget;
+
 /** A cooked fullscreen shader declaration owned by a RenderFeature plan. */
 export interface RenderFeatureFullscreenProgramDeclaration {
   readonly kind: 'fullscreen-program';
@@ -32,6 +50,7 @@ export type RenderFeatureBindingValue =
   | number
   | string
   | ArrayBufferView
+  | SceneDataTarget
   | readonly RenderFeatureBindingValue[]
   | { readonly [name: string]: RenderFeatureBindingValue };
 
@@ -167,7 +186,7 @@ export type RenderFeaturePassDeclaration =
         readonly depthLoadOp: 'load' | 'clear';
         readonly depthStoreOp: 'store' | 'discard';
       };
-      readonly sampledTargets?: readonly string[];
+      readonly sampledTargets?: readonly RenderFeatureSampledTarget[];
       readonly draws: readonly RenderFeatureDrawDeclaration[];
     };
 
@@ -193,6 +212,12 @@ export interface RenderFeaturePlanContext {
   readonly frame: { readonly frameNumber: number };
   readonly generation: number;
   readonly targets: readonly RenderFeatureLogicalTarget[];
+  /** Read-only semantic scene-data resolver bound to this plan generation. */
+  readonly sceneData: import('../temporal/scene-data-catalog').SceneDataCatalog;
+  /** Resolve a material shader's renderer-owned binding contract. */
+  readonly materialShaderBindingContract?: (
+    materialShaderId: string,
+  ) => RenderFeatureMaterialShaderBindingContract;
 }
 
 /** Frozen declaration produced for one feature in one frame. */
@@ -303,12 +328,15 @@ export function deriveRenderFeaturePassAccess(
   if (pass.depthStencilAttachment !== undefined) {
     accesses.push({
       resource: pass.depthStencilAttachment.target,
-      usage: pass.sampledTargets?.includes(pass.depthStencilAttachment.target)
+      usage: pass.sampledTargets?.some(
+        (target) => typeof target === 'string' && target === pass.depthStencilAttachment?.target,
+      )
         ? 'depth-stencil-read'
         : 'depth-stencil-write',
     });
   }
   for (const target of pass.sampledTargets ?? []) {
+    if (typeof target !== 'string') continue;
     accesses.push({ resource: target, usage: 'sampled-read' });
   }
   for (const draw of pass.draws) {
@@ -411,7 +439,8 @@ export function freezeRenderFeaturePlan(
       pass.colorAttachments.some((attachment) => !targets.has(attachment.target)) ||
       (pass.depthStencilAttachment !== undefined &&
         !targets.has(pass.depthStencilAttachment.target)) ||
-      pass.sampledTargets?.some((target) => !targets.has(target)) === true
+      pass.sampledTargets?.some((target) => typeof target === 'string' && !targets.has(target)) ===
+        true
     ) {
       return err(stageFailure(identity));
     }

package/src/features/prepared-gpu-work.ts

@@ -13,6 +13,7 @@ import type {
 import { type BindGroupLayoutDescriptor, err, ok, type Result } from '@forgeax/engine-types';
 import { type RenderError, RenderFeaturePreparationFailedError } from '../errors/render';
 import type { PipelineBuilderShaderModuleFactory } from '../pipeline-builder';
+import type { RenderFeatureShaderModuleMode } from './types';
 
 declare const RenderFeatureGpuProgramBrand: unique symbol;
 export interface RenderFeatureGpuProgramRef {
@@ -909,7 +910,11 @@ function createRenderFeatureGpuWorkSession(input: {
  * retains the per-feature prepared GPU state and recreates it after recovery.
  */
 export interface RenderFeatureGpuWorkOwner {
-  beginFeature(featureIdentity: string, generation: number): RenderFeatureGpuPrepareSession;
+  beginFeature(
+    featureIdentity: string,
+    generation: number,
+    shaderModuleMode?: RenderFeatureShaderModuleMode,
+  ): RenderFeatureGpuPrepareSession;
   resolveBuffer(
     featureIdentity: string,
     reference: RenderFeatureGpuBufferRef,
@@ -920,27 +925,37 @@ export interface RenderFeatureGpuWorkOwner {
 export function createRenderFeatureGpuWorkOwner(input: {
   readonly getDevice: () => RhiDevice;
   readonly getShaderModuleFactory: () => PipelineBuilderShaderModuleFactory;
+  readonly getImmediateShaderModuleFactory?: () => PipelineBuilderShaderModuleFactory;
 }): RenderFeatureGpuWorkOwner {
   const sessions = new Map<
     string,
-    { generation: number; session: RenderFeatureGpuPrepareSession }
+    {
+      generation: number;
+      shaderModuleMode: RenderFeatureShaderModuleMode;
+      session: RenderFeatureGpuPrepareSession;
+    }
   >();
 
   return {
-    beginFeature: (featureIdentity, generation) => {
+    beginFeature: (featureIdentity, generation, requestedShaderModuleMode = 'validated') => {
+      const shaderModuleMode = requestedShaderModuleMode;
       const existing = sessions.get(featureIdentity);
-      if (existing?.generation === generation) {
+      if (existing?.generation === generation && existing.shaderModuleMode === shaderModuleMode) {
         existing.session.beginFrame();
         return existing.session;
       }
       if (existing !== undefined) existing.session.dispose();
+      const shaderModuleFactory =
+        shaderModuleMode === 'immediate'
+          ? (input.getImmediateShaderModuleFactory?.() ?? input.getShaderModuleFactory())
+          : input.getShaderModuleFactory();
       const session = createRenderFeatureGpuWorkSession({
         device: input.getDevice(),
-        shaderModuleFactory: input.getShaderModuleFactory(),
+        shaderModuleFactory,
         generation,
         featureIdentity,
       });
-      sessions.set(featureIdentity, { generation, session });
+      sessions.set(featureIdentity, { generation, shaderModuleMode, session });
       session.beginFrame();
       return session;
     },

package/src/features/prepared-graphics.ts

@@ -19,6 +19,7 @@ import {
   type RenderFeaturePreparedStateMismatchDetail,
   RenderFeaturePreparedStateMismatchError,
 } from '../errors/render';
+import type { SceneDataTarget } from '../temporal/scene-data';
 import type { RenderFeatureGpuBufferRef } from './prepared-gpu-work';
 import type { RenderFeatureTargetHandle } from './targets';
 import type { PreparedKind } from './vocabulary';
@@ -234,7 +235,7 @@ export type RenderFeatureDrawRecord =
 export interface RenderFeatureGraphicsPassDescriptor {
   readonly attachments: RenderFeatureGraphicsPassAttachments;
   /** Targets sampled by shaders but not attached for writing in this pass. */
-  readonly sampledTargets?: readonly RenderFeatureTargetHandle[];
+  readonly sampledTargets?: readonly (RenderFeatureTargetHandle | SceneDataTarget)[];
   readonly draws: readonly RenderFeatureDrawRecord[];
 }
 

package/src/features/render-graph-raster.ts

@@ -19,6 +19,7 @@ import type {
   PreparedGraphicsResolvedResource,
   PreparedGraphicsResolvedSnapshot,
 } from '../prepare/prepared-graphics-resolver';
+import type { SceneDataTarget } from '../temporal/scene-data';
 import type { RenderFeatureResolvedGpuBuffer } from './prepared-gpu-work';
 import type {
   RenderFeatureGraphicsPassDescriptor,
@@ -40,7 +41,7 @@ export interface RenderFeatureGraphTarget {
 }
 
 export type RenderFeatureGraphTargetResolver = (
-  resource: string | RenderFeatureTargetHandle,
+  resource: string | RenderFeatureTargetHandle | SceneDataTarget,
 ) => RenderFeatureGraphTarget | undefined;
 
 export type RenderFeatureGraphBindingsResolution =

package/src/features/targets.ts

@@ -12,6 +12,8 @@ export type RenderFeatureTargetKind = 'scene-color' | 'scene-depth';
  * internal graph key.
  */
 export interface RenderFeatureTargetHandle {
+  /** Stable alias used when a pipeline exposes more than one color role. */
+  readonly name?: string;
   readonly kind: RenderFeatureTargetKind;
   readonly format: TextureFormat;
   readonly sampleCount: 1 | 4;
@@ -19,6 +21,7 @@ export interface RenderFeatureTargetHandle {
 }
 
 export interface RenderFeatureTargetInput {
+  readonly name?: string;
   readonly kind: RenderFeatureTargetKind;
   readonly format: TextureFormat;
   readonly sampleCount: 1 | 4;
@@ -54,17 +57,36 @@ export function resolveStandardRenderFeatureTargets(input: {
   readonly colorAttachmentFormat: TextureFormat;
 }): readonly RenderFeatureTargetHandle[] {
   const sampleCount: 1 | 4 = input.antialias === 'msaa' && input.multisample ? 4 : 1;
-  const linearLdr = input.tonemap === 'none' && input.storageBuffer;
+  const linearLdr =
+    (input.tonemap === 'none' && input.storageBuffer) ||
+    input.antialias === 'fxaa' ||
+    (input.antialias === 'msaa' && input.multisample);
+  const colorFormat =
+    input.tonemap !== 'none' || linearLdr ? 'rgba16float' : input.colorAttachmentFormat;
   return [
     createRenderFeatureTarget({
+      name: 'color',
       kind: 'scene-color',
-      format: input.tonemap !== 'none' || linearLdr ? 'rgba16float' : input.colorAttachmentFormat,
+      format: colorFormat,
       sampleCount,
     }),
     createRenderFeatureTarget({
+      name: 'depth',
       kind: 'scene-depth',
       format: 'depth24plus-stencil8',
       sampleCount,
     }),
+    createRenderFeatureTarget({
+      name: 'motion-input',
+      kind: 'scene-color',
+      format: colorFormat,
+      sampleCount,
+    }),
+    createRenderFeatureTarget({
+      name: 'motion-output',
+      kind: 'scene-color',
+      format: colorFormat,
+      sampleCount: 1,
+    }),
   ];
 }

package/src/features/types.ts

@@ -42,6 +42,17 @@ export type {
 /** Closed lifecycle states exposed by the feature host. */
 export type RenderFeatureStatus = 'active' | 'failed' | 'disabled' | 'disposed';
 
+/**
+ * Shader preparation policy for feature-owned GPU programs.
+ *
+ * `validated` waits for the backend's diagnostic-rich shader preparation before
+ * exposing a module to the render graph. `immediate` is reserved for generated
+ * feature programs that must hand a WebGPU module to pipeline creation without
+ * serialising first-use on `getCompilationInfo()`; pipeline creation remains
+ * the validation boundary for that mode.
+ */
+export type RenderFeatureShaderModuleMode = 'validated' | 'immediate';
+
 export interface RenderFeatureResourceHandle {
   readonly __renderFeatureResource: unique symbol;
 }
@@ -79,6 +90,8 @@ export interface RenderFeatureExtractContext {
 export interface RenderFeature<FrameData> {
   readonly identity: string;
   readonly requiredCapabilities?: readonly RenderFeatureCapabilityKey[];
+  /** Optional feature-owned shader preparation policy; defaults to `validated`. */
+  readonly shaderModuleMode?: RenderFeatureShaderModuleMode;
   /**
    * Material shader identifiers whose modules must be ready before the first
    * frame. The renderer resolves these against the loaded manifest and seeds

package/src/fullscreen-post-process-pass.ts

@@ -23,6 +23,7 @@ import type {
   Sampler,
   TextureView,
 } from '@forgeax/engine-rhi';
+import { GPU_SHADER_STAGE_FRAGMENT } from './gpu-stage';
 import type { BglKind } from './pipeline-spec';
 import { buildBindGroupLayoutDescriptor, type PipelineSpec } from './pipeline-spec';
 
@@ -103,6 +104,15 @@ export interface PostProcessShaderEntry {
   readonly reads?: readonly (string | PostProcessReadEntry)[] | undefined;
 }
 
+/** Whether a feature binding opts into the temporal multi-read contract. */
+export function isTemporalFullscreenBinding(values: Readonly<Record<string, unknown>>): boolean {
+  return (
+    values.temporal !== undefined ||
+    values.shader === 'forgeax.taa-resolve' ||
+    values.shader === 'forgeax.motion-blur'
+  );
+}
+
 /**
  * Structured read entry for a post-process shader.
  *
@@ -252,6 +262,7 @@ export function buildFullscreenPostProcessPass(
   bindGroupLayout: BindGroupLayout;
   sampler: Sampler | null;
   depthSampler: Sampler | null;
+  extraColorBindings: readonly number[];
   createHandle: (
     name: string,
     pipeline: unknown,
@@ -279,11 +290,20 @@ export function buildFullscreenPostProcessPass(
     : entry.params !== undefined
       ? 'fullscreen-post-with-params'
       : 'fullscreen-post';
-  const bglRes = device.createBindGroupLayout(
-    buildBindGroupLayoutDescriptor(FULLSCREEN_DEFAULT_SPEC, {
-      kind: bglKind,
-    }),
+  const descriptor = buildBindGroupLayoutDescriptor(FULLSCREEN_DEFAULT_SPEC, { kind: bglKind });
+  const colorReads = (entry.reads ?? []).filter(
+    (read) => typeof read === 'string' || read.sampleType !== 'depth',
   );
+  const extraColorCount = Math.max(0, colorReads.length - 1);
+  const firstExtraBinding = hasDepth ? 5 : entry.params === undefined ? 2 : 3;
+  for (let index = 0; index < extraColorCount; index += 1) {
+    descriptor.entries.push({
+      binding: firstExtraBinding + index,
+      visibility: GPU_SHADER_STAGE_FRAGMENT,
+      texture: { sampleType: 'float', viewDimension: '2d' },
+    });
+  }
+  const bglRes = device.createBindGroupLayout(descriptor);
   if (!bglRes.ok) {
     ctx.errorRegistry.fire(bglRes.error);
     return null;
@@ -297,6 +317,9 @@ export function buildFullscreenPostProcessPass(
     bindGroupLayout: bglRes.value,
     sampler,
     depthSampler,
+    extraColorBindings: Object.freeze(
+      Array.from({ length: extraColorCount }, (_, index) => firstExtraBinding + index),
+    ),
     createHandle: (name, pipeline, paramsBuffer) => ({
       name,
       paramsBuffer,
@@ -334,6 +357,7 @@ export function createFullscreenBindGroup(
   paramsBuffer?: Buffer | null,
   depthTexView?: TextureView | null,
   depthSampler?: Sampler | null,
+  additionalViews: readonly { readonly binding: number; readonly view: TextureView }[] = [],
 ): BindGroup | null {
   const entries: { binding: number; resource: { kind: string; value: unknown } }[] = [
     { binding: 0, resource: { kind: 'textureView', value: inputView } },
@@ -353,6 +377,12 @@ export function createFullscreenBindGroup(
     entries.push({ binding: 3, resource: { kind: 'textureView', value: depthTexView } });
     entries.push({ binding: 4, resource: { kind: 'sampler', value: depthSampler } });
   }
+  for (const additional of additionalViews) {
+    entries.push({
+      binding: additional.binding,
+      resource: { kind: 'textureView', value: additional.view },
+    });
+  }
   const res = device.createBindGroup({
     label: 'fullscreen-post-process-bg',
     layout: bgl,

package/src/gpu-scene.ts

@@ -294,6 +294,30 @@ export class GpuScene {
     });
   }
 
+  /** Publish current transforms as previous only after a successful submit. */
+  commitTemporalFrame(): Result<void, RhiError> {
+    const nextTransform = this.tableBytes.transform.slice(0);
+    const next = new Uint8Array(nextTransform);
+    const current = new Uint8Array(this.tableBytes.transform);
+    const currentOffset = offset(TRANSFORM, 'currentWorld');
+    const previousOffset = offset(TRANSFORM, 'previousWorld');
+    for (let index = 0; index < this.capacity; index += 1) {
+      next.set(
+        current.subarray(
+          index * TRANSFORM.stride + currentOffset,
+          index * TRANSFORM.stride + currentOffset + 64,
+        ),
+        index * TRANSFORM.stride + previousOffset,
+      );
+    }
+    const uploaded = this.device.queue.writeBuffer(this.buffers.transform, 0, next);
+    if (!uploaded.ok) return uploaded;
+    this.tableBytes.transform = nextTransform;
+    this.uploadRanges += 1;
+    this.uploadBytes += next.byteLength;
+    return ok(undefined);
+  }
+
   rebuild(slots: readonly RenderSceneSlot[]): Result<GpuSceneSyncResult, RhiError> {
     this.allocations.clear();
     this.instances.reset();

package/src/gpu-usage.ts

@@ -12,3 +12,5 @@ export const GPU_BUFFER_USAGE_UNIFORM = 0x40;
 export const GPU_BUFFER_USAGE_STORAGE = 0x80;
 export const GPU_BUFFER_USAGE_INDIRECT = 0x100;
 export const GPU_BUFFER_USAGE_MAP_READ = 0x01;
+/** GPUBufferUsage.QUERY_RESOLVE, used by optional timestamp captures. */
+export const GPU_BUFFER_USAGE_QUERY_RESOLVE = 0x200;

package/src/ibl/skylight-bind-group.ts

@@ -1,5 +1,6 @@
 // skylight-bind-group.ts -- Skylight resources merged into @group(1) PBR
-// material BGL (binding 7..13) + fallback identity resource bundle.
+// material BGL (binding 7..13) + fallback identity resource bundle. The
+// complete Standard material group appends transmission entries.
 //
 // Plan-strategy D-5 (round-4 REVISED): the round-2 stand-alone @group(4)
 // Skylight BindGroupLayout collided with WebGPU's default maxBindGroups=4
@@ -18,9 +19,10 @@
 //     (createRenderer) is responsible for passing the result to
 //     `device.createBindGroupLayout`.
 //   - assembleMaterialWithSkylightEntries(materialEntries, skylightResources):
-//     given the existing 7 material BindGroupEntry values + a skylight
-//     resource bundle (active or fallback), returns the merged 14-entry
-//     array suitable for `device.createBindGroup`. Charter P5 minimal
+//     given the existing material BindGroupEntry values + a skylight
+//     resource bundle (active or fallback), returns the merged material
+//     array with the engine-owned transmission pair at the end, suitable for
+//     `device.createBindGroup`. Charter P5 minimal
 //     surface: this helper does NOT allocate samplers/textures itself.
 //   - createSkylightFallback(device, queue): allocate a 1x1 white
 //     irradiance/prefilter cube pair + a 1x1 BRDF approximation + intensity=0 uniform
@@ -232,22 +234,20 @@ export function mergeSkylightIntoMaterialBgl(
  * call site, same layout shape -- charter P4 + F1 (AI users do not need
  * a `if (hasSkylight)` branch when writing demos).
  */
-export interface EmissiveAoBindGroupResources {
-  readonly emissiveSampler: Sampler;
-  readonly emissiveView: TextureView;
-  readonly occlusionSampler: Sampler;
-  readonly occlusionView: TextureView;
+/** Engine-owned material transmission injection resources. */
+export interface TransmissionBindGroupResources {
+  readonly sampler: Sampler;
+  readonly backdropView?: TextureView | null;
 }
 
-// Lightmap (emissive + occlusion sampler/texture pair x 2) injection start
-// is computed from the assembled list length on each push — no hardcoded
-// 14-slot literal. After 7 material + 7 skylight entries are pushed below,
-// the lightmap binding land naturally at start = 14 (D-6 / w15).
+// Lightmap (emissive + occlusion sampler/texture pair x 2) and transmission
+// injection starts are computed from the assembled list length on each push —
+// no hardcoded binding literals.
 
 export function assembleMaterialWithSkylightEntries(
   materialEntries: readonly BindGroupEntry[],
   skylight: SkylightBindGroupResources,
-  emissiveAo?: EmissiveAoBindGroupResources | undefined,
+  transmission?: TransmissionBindGroupResources | undefined,
 ): BindGroupEntry[] {
   // IBL injection start = end of the user-region. The user-region IS
   // `materialEntries` (UBO binding 0 + N sampler/texture pairs), so its length
@@ -287,30 +287,22 @@ export function assembleMaterialWithSkylightEntries(
       resource: { kind: 'buffer', value: { buffer: skylight.intensityBuffer } },
     },
   ];
-  if (emissiveAo !== undefined) {
-    // Lightmap injection start = current accumulated length
-    // (post material + skylight). Mirrors the appendInjection contract
-    // in pbr-pipeline.ts (D-6).
-    const lightmapStart = result.length;
-    result.push(
-      {
-        binding: lightmapStart,
-        resource: { kind: 'sampler', value: emissiveAo.emissiveSampler },
-      },
-      {
-        binding: lightmapStart + 1,
-        resource: { kind: 'textureView', value: emissiveAo.emissiveView },
-      },
-      {
-        binding: lightmapStart + 2,
-        resource: { kind: 'sampler', value: emissiveAo.occlusionSampler },
-      },
-      {
-        binding: lightmapStart + 3,
-        resource: { kind: 'textureView', value: emissiveAo.occlusionView },
-      },
-    );
-  }
+  // Transmission injection is always present after IBL. Non-transmission
+  // variants bind the existing Skylight resources as layout-only placeholders;
+  // they are not a functional fallback and are never sampled by those shaders.
+  const transmissionSampler = transmission?.sampler ?? skylight.irradianceSampler;
+  const transmissionView = transmission?.backdropView ?? skylight.brdfLutView;
+  const transmissionStart = result.length;
+  result.push(
+    {
+      binding: transmissionStart,
+      resource: { kind: 'sampler', value: transmissionSampler },
+    },
+    {
+      binding: transmissionStart + 1,
+      resource: { kind: 'textureView', value: transmissionView },
+    },
+  );
   return result;
 }