feat(renderer): raise light caps 4+16 → 8+256 (the audit's top graphics blocker)

Every layer that mirrored the fixed arrays moves in lockstep:
LightingUniforms (Rust consts, now the single source), both legacy 3D
WGSL shaders, the material ABI's PerView block (ABI-VERSION 2 → 3 per
the documented protocol, EXPECTED_ABI_VERSION bumped), and the
material-system Rust mirror (population uses array::from_fn, so the
new capacity flows through without copy-length edits).

Deliberately a uniform buffer, not storage: 256×32B + 8×32B < 9KB fits
WebGL2's 16KB minimum UBO, so the cap raise lands on every backend with
zero shader permutations. Shaders loop only over the live count —
small scenes pay nothing. Froxel clustering (per-pixel cost for
genuinely large counts) is the follow-up optimization, now safe to
build against the golden harness.

New golden: 40 point lights in a hue ring over a floor — under the old
cap 60% of the ring goes dark, far past tolerance. Existing goldens
pass pixel-identical (capacity-only change).

Author: proggeramlug

native/shared/shaders/material_abi.wgsl

@@ -1,6 +1,6 @@
 // Bloom shader ABI header — see docs/rfc/0001-material-render-graph.md.
 //
-// ABI-VERSION: 2
+// ABI-VERSION: 3
 //
 // Included by every 3D shader (built-in PBR, sky, custom user materials).
 // Defines the five bind groups and the vertex attribute layout that any
@@ -76,9 +76,9 @@ struct PerView {
 
   // Arrayed lights
   dir_light_count:   vec4<f32>, // x = count, yzw = 0
-  dir_lights:        array<DirLight,  4>,
+  dir_lights:        array<DirLight,  8>,
   point_light_count: vec4<f32>,
-  point_lights:     array<PointLight, 16>,
+  point_lights:     array<PointLight, 256>,
 
   // Shadow data — three cascades, split by shadow_splits.xyz
   shadow_splits:   vec4<f32>,

native/shared/src/renderer/material_system.rs

@@ -66,9 +66,9 @@ pub struct PerViewUniforms {
     pub sun_dir:        [f32; 4],
     pub sun_color:      [f32; 4],
     pub dir_light_count:   [f32; 4],
-    pub dir_lights:        [PerViewDirLight; 4],
+    pub dir_lights:        [PerViewDirLight; 8],
     pub point_light_count: [f32; 4],
-    pub point_lights:      [PerViewPointLight; 16],
+    pub point_lights:      [PerViewPointLight; 256],
     pub shadow_splits:   [f32; 4],
     pub shadow_view:     [[f32; 4]; 4],
     pub shadow_cascades: [[[f32; 4]; 4]; 3],

native/shared/src/renderer/shader_library.rs

@@ -51,7 +51,7 @@ pub fn verify_abi_version(expected: u32) -> Result<(), String> {
 /// when MaterialFactors gained `shading_model` + `foliage_params`
 /// (foliage shading model). Bump together with the
 /// `ABI-VERSION:` comment in `shaders/material_abi.wgsl`.
-pub const EXPECTED_ABI_VERSION: u32 = 2;
+pub const EXPECTED_ABI_VERSION: u32 = 3;
 
 #[cfg(test)]
 mod tests {

native/shared/src/renderer/shaders.rs

@@ -71,9 +71,9 @@ struct Lighting {
     light_dir: vec4<f32>,
     light_color: vec4<f32>,
     dir_light_count: vec4<f32>,
-    dir_lights: array<DirLight, 4>,
+    dir_lights: array<DirLight, 8>,
     point_light_count: vec4<f32>,
-    point_lights: array<PointLight, 16>,
+    point_lights: array<PointLight, 256>,
 };
 
 struct JointMatrices {
@@ -219,9 +219,9 @@ struct Lighting {
     light_dir: vec4<f32>,
     light_color: vec4<f32>,
     dir_light_count: vec4<f32>,
-    dir_lights: array<DirLight, 4>,
+    dir_lights: array<DirLight, 8>,
     point_light_count: vec4<f32>,
-    point_lights: array<PointLight, 16>,
+    point_lights: array<PointLight, 256>,
     camera_pos: vec4<f32>,
     shadow_cascade_vps: array<mat4x4<f32>, 3>,
     shadow_cascade_splits: vec4<f32>,

native/shared/src/renderer/types.rs

@@ -75,8 +75,15 @@ impl SceneMaterialUniforms {
     }
 }
 
-pub(super) const MAX_DIR_LIGHTS: usize = 4;
-pub(super) const MAX_POINT_LIGHTS: usize = 16;
+// Raised from 4/16: scenes were hard-capped at 16 point lights, the
+// audit's top graphics blocker. Arrays stay in a uniform buffer so the
+// cap raise works on every backend including WebGL2 (whose 16KB minimum
+// UBO size this still fits: 256*32B + 8*32B + header < 9KB). Shaders
+// loop only over the live count, so small scenes pay nothing. Per-pixel
+// cost for genuinely large light counts is the follow-up (froxel
+// clustering); this change removes the capability ceiling.
+pub(crate) const MAX_DIR_LIGHTS: usize = 8;
+pub(crate) const MAX_POINT_LIGHTS: usize = 256;
 
 #[repr(C)]
 #[derive(Copy, Clone, bytemuck::Pod, bytemuck::Zeroable)]

native/shared/tests/golden/many_point_lights.png

@@ -176,3 +176,37 @@ fn golden_lit_primitives_3d() {
     });
     compare_or_update("lit_primitives_3d", w, h, &rgba);
 }
+
+#[test]
+fn golden_many_point_lights() {
+    let Some(mut eng) = try_engine() else {
+        eprintln!("skip: no GPU adapter");
+        return;
+    };
+    // 40 colored point lights in a ring over a dark floor — far past the
+    // old 16-light cap. If the cap regressed, lights 17..40 vanish and
+    // the right side of the ring goes dark (well past tolerance).
+    let (w, h, rgba) = render(&mut eng, 6, |eng| {
+        let r = &mut eng.renderer;
+        r.set_clear_color(2.0, 2.0, 4.0, 255.0);
+        r.begin_mode_3d(
+            0.0, 9.0, 0.01, // eye: straight above
+            0.0, 0.0, 0.0,
+            0.0, 1.0, 0.0,
+            60.0, 0.0,
+        );
+        r.draw_plane(0.0, 0.0, 0.0, 14.0, 14.0, 110.0, 110.0, 110.0, 255.0);
+        for i in 0..40u32 {
+            let t = i as f32 / 40.0 * std::f32::consts::TAU;
+            let (sx, sz) = (t.cos() * 4.0, t.sin() * 4.0);
+            // hue cycles so neighboring lights are distinguishable
+            let (lr, lg, lb) = (
+                0.5 + 0.5 * (t).cos(),
+                0.5 + 0.5 * (t + 2.094).cos(),
+                0.5 + 0.5 * (t + 4.189).cos(),
+            );
+            r.add_point_light(sx, 1.2, sz, 3.5, lr, lg, lb, 1.6);
+        }
+    });
+    compare_or_update("many_point_lights", w, h, &rgba);
+}