@forgeax/engine-render 0.1.19 → 0.1.20

package/src/light-buffer-layout.ts

@@ -15,23 +15,24 @@
 //             PointLight in common.wgsl. -1 (0xFFFFFFFF) is the no-shadow
 //             sentinel — shader path samples shadow only when layer >= 0.
 //
-//   SpotLight (64 B / 16 floats):
+//   SpotLight (80 B / 20 floats):
 //     [ 0..2 ] position vec3<f32>
 //     [   3 ] invRangeSquared f32
 //     [ 4..6 ] color vec3<f32> (host-pre-multiplied)
 //     [   7 ] cosInner f32
 //     [ 8..10] direction vec3<f32> (raw outgoing vector)
 //     [  11 ] cosOuter f32
-//     [12..14] pad f32 = 0 (std430 vec4 stride alignment)
+//     [12] depthBias, [13] normalBias, [14] pcfKernelSize
 //     [  15 ] shadowAtlasTile i32 (sentinel -1 = unassigned/clipped; 0..3 = tile)
 //             — feat-20260625-spot-light-shadow-mapping M2 / w8 (D-4):
-//             SpotLight GPU struct had no free pad lane (8 lanes full), so the
-//             clip signal extends the struct to a 4th vec4 column. The lane is
-//             written i32 via an Int32Array view of the same backing
+//             SpotLight receiver controls occupy the 4th vec4 column. The tile
+//             lane is written i32 via an Int32Array view of the same backing
 //             ArrayBuffer; the shader reads `shadowAtlasTile: i32` from byte
 //             60..64 of struct SpotLight (common.wgsl). -1 (0xFFFFFFFF) is the
 //             unassigned/clipped sentinel — shader samples shadow only when
 //             tile >= 0. Mirrors point's slot-7 shadowAtlasLayer pattern.
+//     [  16 ] shadowIntensity f32 (default 1; [0,1] residual visibility)
+//     [17..19] std430 tail pad (the struct rounds to the next 16 B boundary)
 //
 // Array header (16 B, std430 stride alignment):
 //     [ 0 ] count u32 (number of valid slots in the trailing array)
@@ -69,13 +70,16 @@ import type { PointLightSnapshot, SpotLightSnapshot } from './render-system-extr
 //   [  11 ] cosOuter          f32         (point: 0.0)
 //   [  12 ] kind              u32         (POINT = 0, SPOT = 1)
 //   [  13 ] shadow identity   i32         (point layer / spot tile, -1 sentinel)
-//   [14..15] point depth       f32x2       (point near/far; spot zero)
+//   [14] point near / spot shadowIntensity f32
+//   [15] point far / spot pcfKernelSize f32
 //
 // Design: research Finding 1 (Bevy GpuClusteredLight 152B -> forgeax 64B),
 // plan-strategy D-light-slot (kind bit-tag discriminant).
 //
-// The existing URP PointLight (32B) / SpotLight (48B) pack functions remain
-// untouched; packLightSlot is the new HDRP-only entry.
+// The existing URP PointLight (32B) pack function remains unchanged; the URP
+// SpotLight grows from 64B to 80B to carry the independent shadow visibility
+// factor without stealing the tile or PCF lanes. packLightSlot remains the
+// compact 64B HDRP owner and uses a spot-only pad lane for the same value.
 
 /** Byte size of one HDRP LightSlot in std430 (16 x f32). AC-11 absolute-value lock. */
 export const BYTES_PER_LIGHT_SLOT = 64;
@@ -99,9 +103,11 @@ export type LightSlotKind = (typeof LightSlotKind)[keyof typeof LightSlotKind];
  * feat-20260612-point-light-shadows-urp-hdrp M4 / T-M4-4 (plan-strategy §D-8):
  * the prior u32x3 pad lanes at byte 52..64 carry shadow-side data on the HDRP
  * path. `kind_and_pad.x = kind` (u32), `.y = shadow identity` (i32, sentinel
- * -1 = no shadow), `.z = near` (f32 via bitcast), `.w = far`
- * (f32 via bitcast). The shader reads near/far through `bitcast<f32>(...)`
- * to keep the WGSL struct as `vec4<u32>` (alignment + naga_oil unchanged).
+ * -1 = no shadow). For point lights `.z/.w` carry near/far (f32 via bitcast);
+ * for spot lights `.z` carries shadowIntensity and `.w` carries the PCF
+ * kernel width (f32 via bitcast). The shader reads these lanes through
+ * `bitcast<f32>(...)` to
+ * keep the WGSL struct as `vec4<u32>` (alignment + naga_oil unchanged).
  */
 export const LIGHTSLOT_LAYOUT = {
   byteSize: BYTES_PER_LIGHT_SLOT,
@@ -117,6 +123,7 @@ export const LIGHTSLOT_LAYOUT = {
   shadowAtlasTileOffset: 52,
   shadowNearOffset: 56,
   shadowFarOffset: 60,
+  spotPcfKernelSizeOffset: 60,
   floatCount: 16,
   vec4Count: 4,
 } as const;
@@ -137,16 +144,18 @@ export const STORAGE_BUFFER_MIN_REQUIRED = 4;
 /** Byte size of one PointLight std430 slot (vec4 * 2). */
 export const POINT_LIGHT_STD430_BYTES = 32;
 /**
- * Byte size of one SpotLight std430 slot (vec4 * 4).
+ * Byte size of one SpotLight std430 slot (five 16-byte columns).
  *
- * feat-20260625-spot-light-shadow-mapping M2 / w8 (D-4): grew 48 -> 64 to make
- * room for the `shadowAtlasTile: i32` clip-signal lane (slot 15). Slots 0..11
- * keep the prior layout; slots 12..14 are vec4-alignment padding.
+ * feat-20260625-spot-light-shadow-mapping M2 / w8 (D-4) grew 48 -> 64 for
+ * `shadowAtlasTile`; the visual-parity contract then adds a fifth column for
+ * `shadowIntensity` rather than overloading the tile/PCF lanes.
  */
-export const SPOT_LIGHT_STD430_BYTES = 64;
+export const SPOT_LIGHT_STD430_BYTES = 80;
 
 /** Sentinel value for SpotLight slot[15] meaning "no shadow / clipped". */
 export const SPOT_LIGHT_SHADOW_TILE_SENTINEL = -1;
+/** Sentinel for a projector-only SpotLight with no shadow atlas tile. */
+export const SPOT_LIGHT_PROJECTOR_ONLY_SENTINEL = -2;
 /** Byte size of the array header (count u32 + 12 B pad to 16 B stride). */
 export const LIGHT_ARRAY_HEADER_BYTES = 16;
 /** Maximum number of slots packed in the first-slice cap layout (D-S3). */
@@ -182,7 +191,7 @@ export function packPointLight(snap: PointLightSnapshot): Float32Array {
 }
 
 /**
- * Pack one SpotLightSnapshot into 16 floats (64 B byte-for-byte std430).
+ * Pack one SpotLightSnapshot into 20 floats (80 B byte-for-byte std430).
  *
  * cosInner / cosOuter ride the otherwise-padding `.w` lanes of the
  * `color` and `direction` vec4 columns (AC-04 c + plan D-S2 16 B alignment
@@ -190,10 +199,13 @@ export function packPointLight(snap: PointLightSnapshot): Float32Array {
  * (sentinel -1 = unassigned/clipped, 0..3 = atlas tile) written through an
  * Int32Array view so the shader's `i32` read at byte 60..64 of struct SpotLight
  * (common.wgsl) sees the correct two's-complement bits (-1 = 0xFFFFFFFF).
- * Slots 12..14 stay zero (vec4-alignment padding). feat-20260625 M2 / w8 (D-4).
+ * Slots 12..14 carry the shared receiver controls; slot 15 remains the i32
+ * shadow tile sentinel; slot 16 carries shadowIntensity and slots 17..19 are
+ * alignment tail padding. Surface and volume consumers therefore share one
+ * extracted shadow configuration.
  */
 export function packSpotLight(snap: SpotLightSnapshot): Float32Array {
-  const out = new Float32Array(16);
+  const out = new Float32Array(20);
   out[0] = snap.position[0] ?? 0;
   out[1] = snap.position[1] ?? 0;
   out[2] = snap.position[2] ?? 0;
@@ -206,10 +218,20 @@ export function packSpotLight(snap: SpotLightSnapshot): Float32Array {
   out[9] = snap.direction[1] ?? 0;
   out[10] = snap.direction[2] ?? 0;
   out[11] = snap.cosOuter;
-  // Slots 12..14 stay zero (vec4-alignment padding).
+  out[12] = snap.depthBias ?? 0.005;
+  out[13] = snap.normalBias ?? 0.05;
+  out[14] = snap.pcfKernelSize ?? 3;
   // Slot 15: shadowAtlasTile i32 via Int32Array view (sentinel -1 default).
   const i32 = new Int32Array(out.buffer);
-  i32[15] = snap.shadowAtlasTile ?? SPOT_LIGHT_SHADOW_TILE_SENTINEL;
+  i32[15] =
+    snap.shadowAtlasTile >= 0
+      ? snap.shadowAtlasTile
+      : snap.projectorAsset !== undefined && snap.lightViewProj !== undefined
+        ? SPOT_LIGHT_PROJECTOR_ONLY_SENTINEL
+        : SPOT_LIGHT_SHADOW_TILE_SENTINEL;
+  // Slot 16 begins the fifth vec4 column. The remaining tail lanes stay zero
+  // so the std430 array stride is the explicit 80-byte contract.
+  out[16] = snap.shadowIntensity ?? 1;
   return out;
 }
 
@@ -275,8 +297,8 @@ export interface PointShadowSlotInfo {
  * feat-20260612-point-light-shadows-urp-hdrp M4 / T-M4-4 (plan-strategy §D-8):
  * the optional point `shadow` info threads through to bytes 52..64 as
  * `(shadowAtlasLayer i32, near f32, far f32)`. Spot snapshots write their
- * `shadowAtlasTile` directly into the same identity lane and keep near/far 0.
- * The shader reads `near`/`far`
+ * `shadowAtlasTile` directly into the same identity lane, put shadowIntensity
+ * in the `.z` lane, and the PCF kernel width in `.w`. The shader reads `near`/`far`
  * through `bitcast<f32>(kind_and_pad.zw)` so the WGSL struct stays
  * `kind_and_pad: vec4<u32>` (alignment + naga_oil compose unchanged). When
  * `shadow` is undefined (no PointLightShadow) the lanes default to
@@ -309,15 +331,26 @@ export function packLightSlot(
   // Float32Array: SPOT=1 must be 0x00000001, not f32(1.0) bits.
   const u32 = new Uint32Array(out.buffer);
   u32[12] = snap.kind === 'point' ? LightSlotKind.POINT : LightSlotKind.SPOT;
-  // Lanes 13..15 carry one kind-discriminated shadow identity. Point keeps
-  // layer/near/far; spot writes its snapshot tile and leaves near/far zero.
+  // Lanes 13..15 carry one kind-discriminated shadow payload. Point keeps
+  // layer/near/far; spot writes its snapshot tile, shadowIntensity, and PCF
+  // kernel width.
   const i32 = new Int32Array(out.buffer);
   if (snap.kind === 'point' && shadow !== undefined) {
     i32[13] = shadow.shadowAtlasLayer;
     out[14] = shadow.near;
     out[15] = shadow.far;
   } else if (snap.kind === 'spot') {
-    i32[13] = snap.shadowAtlasTile;
+    i32[13] =
+      snap.shadowAtlasTile >= 0
+        ? snap.shadowAtlasTile
+        : snap.projectorAsset !== undefined && snap.lightViewProj !== undefined
+          ? SPOT_LIGHT_PROJECTOR_ONLY_SENTINEL
+          : SPOT_LIGHT_SHADOW_TILE_SENTINEL;
+    out[14] = snap.shadowIntensity ?? 1;
+    // HDRP has no separate 80-byte SpotLight payload. Reuse the otherwise
+    // unused spot `.w` lane so the cluster path consumes the same authored PCF
+    // width as the URP and volume paths.
+    out[15] = snap.pcfKernelSize ?? 3;
   } else {
     i32[13] = POINT_LIGHT_SHADOW_LAYER_SENTINEL;
     // out[14] / out[15] remain zero (Float32Array zero-init).

package/src/pbr-pipeline.ts

@@ -140,7 +140,7 @@ export function buildPbrMaterialUserRegionEntries(
   // material-UBO contract. derive() emits binding 0 as the first numeric run's
   // merged UBO; an empty schema has no binding-0 UBO and needs no patch.
   const ubo = entries[0];
-  if (ubo !== undefined && ubo.binding === 0 && ubo.buffer !== undefined) {
+  if (ubo !== undefined && ubo.binding === 0 && ubo.buffer?.type === 'uniform') {
     entries[0] = {
       binding: 0,
       visibility: GPU_SHADER_STAGE_VERTEX | GPU_SHADER_STAGE_FRAGMENT,
@@ -325,6 +325,8 @@ export const INJECTION_KIND_LENGTHS = {
  */
 export interface PbrCaps {
   readonly storageBuffer: boolean;
+  /** Whether the device can carry the optional SpotLight projector texture. */
+  readonly projectorAvailable?: boolean;
 }
 
 /**
@@ -376,7 +378,7 @@ export interface PbrCaps {
  */
 export function buildPbrViewBglEntries(caps: PbrCaps): GPUBindGroupLayoutEntry[] {
   const lightBufType: GPUBufferBindingType = caps.storageBuffer ? 'read-only-storage' : 'uniform';
-  return [
+  const entries: GPUBindGroupLayoutEntry[] = [
     {
       binding: 0,
       visibility: GPU_SHADER_STAGE_VERTEX | GPU_SHADER_STAGE_FRAGMENT,
@@ -469,12 +471,32 @@ export function buildPbrViewBglEntries(caps: PbrCaps): GPUBindGroupLayoutEntry[]
       visibility: GPU_SHADER_STAGE_FRAGMENT,
       texture: { sampleType: 'depth', viewDimension: '2d' },
     },
-    {
-      binding: 10,
-      visibility: GPU_SHADER_STAGE_VERTEX,
-      buffer: { type: 'uniform', hasDynamicOffset: true },
-    },
   ];
+  // The projector is optional, but when present it is a sampled texture in
+  // the fragment stage. Keep it out of the low-limit view layout so the
+  // remaining HDRP PBR ABI stays within WebGPU's minimum 16 sampled textures.
+  // The corresponding PROJECTOR_AVAILABLE shader variant is selected from
+  // the same device capability bit and returns a white modulation.
+  if (caps.projectorAvailable !== false) {
+    entries.push(
+      {
+        binding: 11,
+        visibility: GPU_SHADER_STAGE_FRAGMENT,
+        texture: { sampleType: 'float', viewDimension: '2d' },
+      },
+      {
+        binding: 12,
+        visibility: GPU_SHADER_STAGE_FRAGMENT,
+        sampler: { type: 'filtering' },
+      },
+    );
+  }
+  entries.push({
+    binding: 10,
+    visibility: GPU_SHADER_STAGE_VERTEX,
+    buffer: { type: 'uniform', hasDynamicOffset: true },
+  });
+  return entries;
 }
 
 // ─── PBR pipeline layout factory ────────────────────────────────────────────
@@ -784,9 +806,10 @@ export const SPRITE_PASS_PER_INSTANCE_REGION_VARIANT_SET = '';
  *    - `'unlit-material'` — 7 entries: base PBR material only (no inject)
  *    - `'hdrp-7-slot'` — 7 entries (binding 0 + 3..8): HDRP cluster + SSAO group(2) BGL
  * 2. Caps-driven literal shapes (no shader):
- *    - `'pbr-view'` — 10 entries: view UBO + lights + 6 shadow bindings
- *      (directional 3/4, point 5/6, cascade 7, spot atlas 8, spot
- *      lightViewProj matrices 9 — feat-20260625)
+ *    - `'pbr-view'` — 12 entries: view UBO + lights + shadow bindings,
+ *      projector texture/sampler (11/12), and the Points/Lines UBO (10)
+ *      (directional 3/4, point 5/6, cascade 7, spot atlas 8; the former
+ *      spot lightViewProj matrices moved into the View UBO)
  *    - `'pbr-mesh-array'` — 1 entry: per-entity mesh SSBO (dynamic-offset)
  *    - `'pbr-instances'` — 1 entry: per-instance SSBO (no dynamic-offset)
  *    - `'pbr-skin-mesh-array'` — 2 entries: meshes + skin palette

package/src/pipeline/standard-forward-lane.ts

@@ -34,6 +34,7 @@ import {
   addTypedSkyboxPass,
 } from '../typed-render-graph-primitives';
 import { addTypedShadowPasses } from '../typed-shadow-passes';
+import { addAuthoredVolumetricFogPasses } from '../volume/passes';
 import { addStandardPost } from './standard-post';
 
 function target(
@@ -245,8 +246,27 @@ function buildUrp(
     if (!temporal.ok) return temporal;
   }
 
+  if (topology.volumetricFog?.enabled === true) {
+    const depthSample = graph.view(depth.value.texture, {
+      label: 'scene-depth.sample',
+      dimension: '2d',
+      aspect: 'depth-only',
+    });
+    if (!depthSample.ok) return depthSample;
+    const volume = addAuthoredVolumetricFogPasses(
+      graph,
+      topology,
+      sceneResolved.value,
+      depthSample.value,
+      shadows.value.directional.view,
+      shadows.value.spot.view,
+    );
+    if (!volume.ok) return volume;
+  }
+
   const features = context.contributeFeatures([
     {
+      name: 'linear-hdr',
       kind: 'scene-color',
       texture: scene.value.texture,
       view: scene.value.view,

package/src/pipeline/standard-pipeline.ts

@@ -47,6 +47,7 @@ import {
   typedFrameClearColor,
 } from '../typed-render-graph-primitives';
 import { addTypedShadowPasses } from '../typed-shadow-passes';
+import { addAuthoredVolumetricFogPasses } from '../volume/passes';
 
 import { buildStandardForwardLane } from './standard-forward-lane';
 import { addStandardPost } from './standard-post';
@@ -516,9 +517,28 @@ function buildHdrp(
     const temporal = addTransmissionBackdropTemporalPass(graph, scene.value);
     if (!temporal.ok) return temporal;
   }
+  if (topology.volumetricFog?.enabled === true) {
+    const depthSample = graph.view(depth.value.texture, {
+      label: 'scene-depth.sample',
+      dimension: '2d',
+      aspect: 'depth-only',
+    });
+    if (!depthSample.ok) return depthSample;
+    const volume = addAuthoredVolumetricFogPasses(
+      graph,
+      topology,
+      scene.value,
+      depthSample.value,
+      shadows.value.directional.view,
+      shadows.value.spot.view,
+    );
+    if (!volume.ok) return volume;
+  }
+  // The volume-composite pass remains in linear HDR before tone mapping.
 
   const features = context.contributeFeatures([
     {
+      name: 'linear-hdr',
       kind: 'scene-color',
       texture: scene.value.texture,
       view: scene.value.view,

package/src/pipeline/standard-profile.ts

@@ -29,6 +29,13 @@ export const STANDARD_POST_STAGE_NAMES = [
   'present',
 ] as const;
 export type StandardPostStage = (typeof STANDARD_POST_STAGE_NAMES)[number];
+export type StandardVolumetricFogQuality = 'low' | 'high';
+
+export interface StandardVolumetricFogProfile {
+  readonly quality: StandardVolumetricFogQuality;
+  readonly depth: 48 | 64;
+  readonly tileSize: 4 | 16;
+}
 
 export interface StandardProfile {
   readonly pipelineId: typeof STANDARD_PIPELINE_ID;
@@ -38,6 +45,12 @@ export interface StandardProfile {
   readonly pbr: boolean;
   readonly ibl: boolean;
   readonly ssao: boolean;
+  readonly bloom: boolean;
+  readonly tone: StandardTone;
+  readonly antialias: StandardAntialias;
+  readonly sky: boolean;
+  /** Renderer-owned 1080p volume profile; tile width/height remain surface-derived. */
+  readonly volumetricFog?: StandardVolumetricFogProfile | undefined;
   readonly fallback: StandardFallbackLane;
   readonly postStages: typeof STANDARD_POST_STAGE_NAMES;
 }
@@ -50,10 +63,20 @@ export const DEFAULT_STANDARD_PROFILE: StandardProfile = Object.freeze({
   pbr: true,
   ibl: true,
   ssao: false,
+  bloom: true,
+  tone: 'aces-filmic',
+  antialias: 'fxaa',
+  sky: true,
   fallback: 'native',
   postStages: STANDARD_POST_STAGE_NAMES,
 });
 
+export function resolveVolumetricFogProfile(
+  profile: Pick<StandardProfile, 'volumetricFog'>,
+): StandardVolumetricFogProfile {
+  return profile.volumetricFog ?? { quality: 'high', depth: 64, tileSize: 4 };
+}
+
 export type StandardLane = StandardLightingLane | 'cpu-webgl2';
 
 export function resolveStandardLane(

package/src/record/frame-lighting.ts

@@ -5,6 +5,7 @@
 import { mat4, type Vec3, vec3 } from '@forgeax/engine-math';
 import {
   type BindGroup,
+  type BindGroupEntry,
   type BindGroupLayout,
   RhiError,
   type TextureView,
@@ -87,6 +88,8 @@ export function buildPerFrameBindGroups(
   graphTargets?: {
     readonly directionalShadow?: TextureView | undefined;
     readonly spotShadow?: TextureView | undefined;
+    readonly projector?: TextureView | undefined;
+    readonly projectorSampler?: import('@forgeax/engine-rhi').Sampler | undefined;
   },
   includeView = true,
 ): {
@@ -150,6 +153,9 @@ export function buildPerFrameBindGroups(
         graphSpotShadowView !== undefined
           ? graphSpotShadowView
           : pipelineState.shadowFallbackTextureView;
+      const projectorAvailable = pipelineState.projectorAvailable !== false;
+      const b11View = graphTargets?.projector ?? pipelineState.defaultWhiteTextureView;
+      const b12Sampler = graphTargets?.projectorSampler ?? pipelineState.defaultSampler;
       viewBindGroup = getOrCreateFromChain(
         frameState.viewBindGroupCache,
         [
@@ -161,110 +167,118 @@ export function buildPerFrameBindGroups(
           b5View,
           pipelineState.shadowParamsBuffer,
           b8View,
+          ...(projectorAvailable ? [b11View, b12Sampler] : []),
           pipelineState.pointsLinesViewBuffer ?? pipelineState.viewUniformBuffer,
         ],
         'view-main',
         () => {
-          const viewBindGroupResult = internals.device.createBindGroup({
-            label: 'pbr-view-bg',
-            layout: pipelineState.viewBindGroupLayout,
-            entries: [
-              {
-                binding: 0,
-                resource: {
-                  kind: 'buffer',
-                  value: { buffer: pipelineState.viewUniformBuffer, size: VIEW_UNIFORM_BYTES },
-                },
+          const entries: BindGroupEntry[] = [
+            {
+              binding: 0,
+              resource: {
+                kind: 'buffer',
+                value: { buffer: pipelineState.viewUniformBuffer, size: VIEW_UNIFORM_BYTES },
               },
-              {
-                binding: 1,
-                resource: {
-                  kind: 'buffer',
-                  value: { buffer: pipelineState.pointLightsBuffer },
-                },
+            },
+            {
+              binding: 1,
+              resource: {
+                kind: 'buffer',
+                value: { buffer: pipelineState.pointLightsBuffer },
               },
-              {
-                binding: 2,
-                resource: {
-                  kind: 'buffer',
-                  value: { buffer: pipelineState.spotLightsBuffer },
-                },
+            },
+            {
+              binding: 2,
+              resource: {
+                kind: 'buffer',
+                value: { buffer: pipelineState.spotLightsBuffer },
               },
-              {
-                binding: 3,
-                resource: {
-                  kind: 'textureView',
-                  value: b3View,
-                },
+            },
+            {
+              binding: 3,
+              resource: {
+                kind: 'textureView',
+                value: b3View,
               },
-              {
-                binding: 4,
-                resource: {
-                  kind: 'sampler',
-                  value: shadowSampler,
-                },
+            },
+            {
+              binding: 4,
+              resource: {
+                kind: 'sampler',
+                value: shadowSampler,
               },
-              // feat-20260612-point-light-shadows-urp-hdrp Round-2 F-1:
-              // cube_array shadow atlas view (real ShadowAtlas when point
-              // shadows are active; else 1x1x6 fallback).
-              {
-                binding: 5,
-                resource: {
-                  kind: 'textureView',
-                  value: b5View,
-                },
+            },
+            // feat-20260612-point-light-shadows-urp-hdrp Round-2 F-1:
+            // cube_array shadow atlas view (real ShadowAtlas when point
+            // shadows are active; else 1x1x6 fallback).
+            {
+              binding: 5,
+              resource: {
+                kind: 'textureView',
+                value: b5View,
               },
-              // feat-20260612-point-light-shadows-urp-hdrp Round-2 F-1:
-              // shadowParams UBO (`array<vec4<f32>, 4>` = 64 B). Lane N
-              // stores `(near, far, 1/(far-near), 0)` for the point light
-              // with shadowAtlasLayer === N. Updated per frame from
-              // `pointShadowSnapshots` below.
-              {
-                binding: 6,
-                resource: {
-                  kind: 'buffer',
-                  value: { buffer: pipelineState.shadowParamsBuffer },
-                },
+            },
+            // feat-20260612-point-light-shadows-urp-hdrp Round-2 F-1:
+            // shadowParams UBO (`array<vec4<f32>, 4>` = 64 B). Lane N
+            // stores `(near, far, 1/(far-near), 0)` for the point light
+            // with shadowAtlasLayer === N. Updated per frame from
+            // `pointShadowSnapshots` below.
+            {
+              binding: 6,
+              resource: {
+                kind: 'buffer',
+                value: { buffer: pipelineState.shadowParamsBuffer },
               },
-              // feat-20260613-csm-cascaded-shadow-maps M5 / w28 (rebased to
-              // binding 7 on 2026-06-13 to make room for point-shadow 5/6):
-              // forward shaders declare binding 7 in common.wgsl (shared
-              // view BGL) but never reference it; only shadow_caster.wgsl
-              // reads it. Host writes a stable singleton buffer so every
-              // forward bind group entry stays populated.
-              {
-                binding: 7,
-                resource: {
-                  kind: 'buffer',
-                  value: { buffer: pipelineState.shadowCasterCascadeBuffer },
-                },
+            },
+            // feat-20260613-csm-cascaded-shadow-maps M5 / w28 (rebased to
+            // binding 7 on 2026-06-13 to make room for point-shadow 5/6):
+            // forward shaders declare binding 7 in common.wgsl (shared
+            // view BGL) but never reference it; only shadow_caster.wgsl
+            // reads it. Host writes a stable singleton buffer so every
+            // forward bind group entry stays populated.
+            {
+              binding: 7,
+              resource: {
+                kind: 'buffer',
+                value: { buffer: pipelineState.shadowCasterCascadeBuffer },
               },
-              // feat-20260625-spot-light-shadow-mapping M3 / w21 (D-5):
-              // spot shadow 2D atlas (real spotShadowDepth view when spot
-              // shadows run this frame, else the 1x1 depth fallback). Always-on.
-              {
-                binding: 8,
-                resource: {
-                  kind: 'textureView',
-                  value: b8View,
-                },
+            },
+            // feat-20260625-spot-light-shadow-mapping M3 / w21 (D-5):
+            // spot shadow 2D atlas (real spotShadowDepth view when spot
+            // shadows run this frame, else the 1x1 depth fallback). Always-on.
+            {
+              binding: 8,
+              resource: {
+                kind: 'textureView',
+                value: b8View,
               },
-              {
-                binding: 10,
-                resource: {
-                  kind: 'buffer',
-                  value: {
-                    buffer: pipelineState.pointsLinesViewBuffer ?? pipelineState.viewUniformBuffer,
-                    size: POINTS_LINES_VIEW_BYTES,
-                  },
+            },
+            {
+              binding: 10,
+              resource: {
+                kind: 'buffer',
+                value: {
+                  buffer: pipelineState.pointsLinesViewBuffer ?? pipelineState.viewUniformBuffer,
+                  size: POINTS_LINES_VIEW_BYTES,
                 },
               },
-              // feat-20260625-spot-light-shadow-mapping w25: the per-spot
-              // fragment-read lightViewProj matrices fold into the View UBO
-              // (binding 0, `view.spotLightViewProj`) — no standalone binding 9
-              // (WebGL2 fragment uniform-buffer budget). binding 10 is the
-              // dedicated vertex-only Points/Lines viewport UBO.
-            ],
+            },
+            ...(projectorAvailable
+              ? [
+                  { binding: 11, resource: { kind: 'textureView' as const, value: b11View } },
+                  { binding: 12, resource: { kind: 'sampler' as const, value: b12Sampler } },
+                ]
+              : []),
+            // feat-20260625-spot-light-shadow-mapping w25: the per-spot
+            // fragment-read lightViewProj matrices fold into the View UBO
+            // (binding 0, `view.spotLightViewProj`) — no standalone binding 9
+            // (WebGL2 fragment uniform-buffer budget). binding 10 is the
+            // dedicated vertex-only Points/Lines viewport UBO.
+          ];
+          const viewBindGroupResult = internals.device.createBindGroup({
+            label: 'pbr-view-bg',
+            layout: pipelineState.viewBindGroupLayout,
+            entries,
           });
           if (!viewBindGroupResult.ok) throw viewBindGroupResult.error;
           return viewBindGroupResult.value;