@driftengine/core 4.8.5 → 4.8.7

package/src/render/bloomPass.ts

@@ -159,7 +159,14 @@ export class BloomPass {
    * `threshold` is in scene units, so it only separates a light from white paint on a target
    * that kept the range. The caller owns that decision and the warning that goes with it.
    */
-  run(scene: WebGLTexture, width: number, height: number, threshold: number): WebGLTexture | null {
+  run(
+    scene: WebGLTexture,
+    width: number,
+    height: number,
+    threshold: number,
+    /** The ramp, then each level's tint: `resolveBloomResponse`'s floats. */
+    response: Float32Array,
+  ): WebGLTexture | null {
     if (!this.ensureSize(width, height)) return null;
     const { gl } = this;
     const levels = this.levels;
@@ -182,6 +189,7 @@ export class BloomPass {
     gl.bindTexture(gl.TEXTURE_2D, scene);
     gl.uniform1i(this.prefilterUniforms['uSource'] ?? null, 0);
     gl.uniform1f(this.prefilterUniforms['uThreshold'] ?? null, threshold);
+    gl.uniform1f(this.prefilterUniforms['uRamp'] ?? null, response[0] ?? 0);
     this.uploadTexel(this.prefilterUniforms, width, height);
     gl.drawArrays(gl.TRIANGLES, 0, 3);
 
@@ -204,8 +212,13 @@ export class BloomPass {
      * every octave at once. Additive blending rather than a second target to ping-pong through:
      * a level is only ever read while a *different* level is bound, so there is no feedback.
      */
+    /*
+     * Each level's tint rides the blend: the level being added onto is multiplied by its own as the
+     * octave below is added, and the deepest by `uScale` on the first draw, the only one reading it
+     * before anything has been added to it. White everywhere is `ONE, ONE` exactly.
+     */
     gl.enable(gl.BLEND);
-    gl.blendFunc(gl.ONE, gl.ONE);
+    gl.blendFunc(gl.ONE, gl.CONSTANT_COLOR);
     gl.useProgram(this.upsampleProgram);
     gl.uniform1i(this.upsampleUniforms['uSource'] ?? null, 0);
     gl.uniform1f(this.upsampleUniforms['uRadius'] ?? null, BLOOM_FILTER_RADIUS_UV);
@@ -213,12 +226,23 @@ export class BloomPass {
       const target = levels[index - 1];
       const source = levels[index];
       if (target === undefined || source === undefined) break;
+      const deepest = index === levels.length - 1;
+      const into = 1 + (index - 1) * 3;
+      const from = 1 + index * 3;
+      gl.blendColor(response[into] ?? 1, response[into + 1] ?? 1, response[into + 2] ?? 1, 1);
+      gl.uniform3f(
+        this.upsampleUniforms['uScale'] ?? null,
+        deepest ? (response[from] ?? 1) : 1,
+        deepest ? (response[from + 1] ?? 1) : 1,
+        deepest ? (response[from + 2] ?? 1) : 1,
+      );
       gl.bindFramebuffer(gl.FRAMEBUFFER, target.framebuffer);
       gl.viewport(0, 0, target.width, target.height);
       gl.bindTexture(gl.TEXTURE_2D, source.texture);
       gl.drawArrays(gl.TRIANGLES, 0, 3);
     }
 
+    gl.blendColor(0, 0, 0, 0);
     gl.disable(gl.BLEND);
     gl.bindVertexArray(null);
     gl.bindFramebuffer(gl.FRAMEBUFFER, null);

package/src/render/clusteredLights.ts

@@ -1,3 +1,5 @@
+import type { AreaLightBuffer } from './areaLights.ts';
+
 /**
  * The froxel table: what it looks like in memory, and the CPU binner that fills it.
  *
@@ -90,7 +92,7 @@ export const MAX_CLUSTERED_LIGHTS = 320;
  * it cannot. That is what lets a light index the shadow uniforms by a number read from a texture,
  * and it is the same fact the octahedral array texture was built on.
  */
-export const LIGHT_TEXELS = 5;
+export const LIGHT_TEXELS = 6;
 
 /**
  * Where each field of a light's record sits, as an offset in `uint`s from `lightBase`.
@@ -121,7 +123,11 @@ export const LIGHT_TEXELS = 5;
  * **Reordered 2026-10-02 so a plain light's fields are the first eight**, which is what lets the
  * shader stop after two texels. Nine values are needed by every light and eight fit in two
  * texels, so the emitter size and the weight share slot 7 as two halves; see `packSizeAndWeight`.
- * Slot 19 is spare.
+ *
+ * **A sixth texel arrived in 4.8.7 for a light's own falloff exponent**, the fifth's last slot
+ * having gone to the channels: 6 KB more of a table near 300, read only for a light whose record
+ * carries a fixture, which a light with an exponent does. Slots 21 and 22 are a rectangle's barn
+ * doors and spare on a lamp; slot 23 is spare.
  */
 export const LIGHT_RECORD = {
   positionX: 0,
@@ -146,13 +152,48 @@ export const LIGHT_RECORD = {
   iesAxisX: 16,
   iesAxisY: 17,
   iesAxisZ: 18,
+  /**
+   * The light's lighting channels, a mask (`PointLightSet.lightChannels`), in the slot that was
+   * spare. A light naming channels other than the default is read as carrying a fixture, so its
+   * last texels are fetched; a plain light's are not, and the shader takes the default for it.
+   */
+  channels: 19,
+  /** The light's own falloff exponent, or 0 for the frame's falloff. `PointLightSource.falloffExponent`. */
+  falloffExponent: 20,
+  /** A rectangle's barn doors: the cosine of their angle from its normal, then their length in metres. */
+  barnDoorCos: 21,
+  barnDoorLength: 22,
 } as const;
 
+/** The lighting channel every light and every surface is on unless it says otherwise. */
+export const DEFAULT_LIGHT_CHANNELS = 1;
+
+/**
+ * A light's channels as the shader compares them: a whole mask from 1 to 255, or the default where
+ * none was named or what was named is not one. The froxel record and the uniform path both write
+ * this, so a light named badly is on channel 1 in both rather than on two different guesses.
+ */
+export function lightChannelsOf(value: number | undefined): number {
+  if (value === undefined || !Number.isInteger(value) || value < 1 || value > 255) {
+    return DEFAULT_LIGHT_CHANNELS;
+  }
+  return value;
+}
+
+/**
+ * A light's own falloff exponent as the shader reads it: a positive finite number, or 0 for the
+ * frame's falloff where none was named or what was named is not one. The record and the uniform
+ * path both write this, so a light named badly falls off by the frame's rule in both.
+ */
+export function lightFalloffExponentOf(value: number | undefined): number {
+  return value !== undefined && Number.isFinite(value) && value > 0 ? value : 0;
+}
+
 /** Texels the lit pass reads for a light whose record carries no fixture. */
 export const PLAIN_LIGHT_TEXELS = 2;
 
 /**
- * The bit of `sizeAndWeight` that says the record's last three texels hold something: the sign of
+ * The bit of `sizeAndWeight` that says the record's last four texels hold something: the sign of
  * the emitter size's half, which a size never needs.
  */
 export const LIGHT_FIXTURE_FLAG = 0x8000;
@@ -401,6 +442,18 @@ export interface ClusterLightSet {
   readonly cookies?: Float32Array;
   /** One per light: an index into the IES atlas, or −1. */
   readonly iesProfiles?: Float32Array;
+  /** One per light: its lighting channels. See `PointLightSet.lightChannels`. */
+  readonly channels?: Float32Array;
+  /** One per light: its own falloff exponent, or 0. See `PointLightSource.falloffExponent`. */
+  readonly falloffExponents?: Float32Array;
+  /**
+   * The rectangles shaded through the table, after the `count` point lights: those of `areas` from
+   * `areaFrom` on, `areaCount` of them. The ones before `areaFrom` are the fixed arm's, which is
+   * where a rectangle's shadow lives. Absent, there are none.
+   */
+  readonly areas?: AreaLightBuffer | null;
+  readonly areaFrom?: number;
+  readonly areaCount?: number;
 }
 
 /** Where `fillClusterLightSet` reads a frame's lights from: the arrays `Environment` carries. */
@@ -416,6 +469,9 @@ export interface ClusterLightArrays {
   readonly lightIesProfiles?: Float32Array;
   readonly lightIesAxes?: Float32Array;
   readonly lightCookies?: Float32Array;
+  readonly lightChannels?: Float32Array;
+  readonly lightFalloffExponents?: Float32Array;
+  readonly areaLights?: AreaLightBuffer | null;
 }
 
 /** A `ClusterLightSet` a renderer refills every frame. */
@@ -453,8 +509,17 @@ export function createClusterLightSet(): ClusterLightScratch {
 export function fillClusterLightSet(
   env: ClusterLightArrays,
   out: ClusterLightScratch,
+  /** How many rectangles the fixed arm shades; the rest of the buffer is clustered. */
+  areaFrom = 0,
 ): ClusterLightSet {
   out.count = Math.min(env.lightCount ?? 0, MAX_CLUSTERED_LIGHTS);
+  const areas = env.areaLights ?? null;
+  out.areas = areas;
+  out.areaFrom = areaFrom;
+  out.areaCount = Math.max(
+    0,
+    Math.min((areas?.count ?? 0) - areaFrom, MAX_CLUSTERED_LIGHTS - out.count),
+  );
   out.positions = env.lightPositions;
   out.colors = env.lightColors;
   out.radii = env.lightRadii;
@@ -465,6 +530,8 @@ export function fillClusterLightSet(
   out.iesProfiles = env.lightIesProfiles;
   out.iesAxes = env.lightIesAxes;
   out.cookies = env.lightCookies;
+  out.channels = env.lightChannels;
+  out.falloffExponents = env.lightFalloffExponents;
   return out;
 }
 
@@ -514,8 +581,8 @@ function distanceSqToBounds(x: number, y: number, z: number, b: Float32Array): n
 }
 
 /**
- * Whether a light's record needs its last three texels: it holds a shadow slot, a cone, a profile
- * or a cookie. Everything else is a plain light, read in `PLAIN_LIGHT_TEXELS`.
+ * Whether a light's record needs its last four texels: it holds a shadow slot, a cone, a profile,
+ * a cookie, channels of its own or a falloff exponent of its own. Everything else is a plain light, read in `PLAIN_LIGHT_TEXELS`.
  *
  * **`shadowSlots` is zero where the lit shader has no point shadows**, and both binners are handed
  * it that way: a slot is only read under `POINT_SHADOWS`, so a light holding one in a build without
@@ -526,13 +593,17 @@ export function lightHasFixture(
   light: number,
   shadowSlots: number,
 ): boolean {
+  /* A rectangle's record always carries its axes and extents past the second texel. */
+  if (light >= lights.count) return true;
   const cone = lights.coneCos;
   return (
     light < shadowSlots ||
     (cone?.[light * 2] ?? POINT_LIGHT_COS_INNER) !== POINT_LIGHT_COS_INNER ||
     (cone?.[light * 2 + 1] ?? POINT_LIGHT_COS_OUTER) !== POINT_LIGHT_COS_OUTER ||
     (lights.iesProfiles?.[light] ?? NO_IES_PROFILE) >= 0 ||
-    (lights.cookies?.[light] ?? NO_IES_PROFILE) >= 0
+    (lights.cookies?.[light] ?? NO_IES_PROFILE) >= 0 ||
+    lightChannelsOf(lights.channels?.[light]) !== DEFAULT_LIGHT_CHANNELS ||
+    lightFalloffExponentOf(lights.falloffExponents?.[light]) > 0
   );
 }
 
@@ -576,6 +647,10 @@ export function writeLightRecord(
   out: Uint32Array,
   at: number,
 ): void {
+  if (light >= lights.count) {
+    writeAreaRecord(lights, light, out, at);
+    return;
+  }
   const directions = lights.directions;
   const cone = lights.coneCos;
   const axes = lights.iesAxes;
@@ -612,7 +687,82 @@ export function writeLightRecord(
   out[at + LIGHT_RECORD.iesAxisX] = floatBits(axes?.[light * 3] ?? 0);
   out[at + LIGHT_RECORD.iesAxisY] = floatBits(axes?.[light * 3 + 1] ?? 0);
   out[at + LIGHT_RECORD.iesAxisZ] = floatBits(axes?.[light * 3 + 2] ?? 0);
-  out[at + 19] = 0;
+  out[at + LIGHT_RECORD.channels] = floatBits(lightChannelsOf(lights.channels?.[light]));
+  out[at + LIGHT_RECORD.falloffExponent] = floatBits(
+    lightFalloffExponentOf(lights.falloffExponents?.[light]),
+  );
+  out[at + LIGHT_RECORD.barnDoorCos] = 0;
+  out[at + LIGHT_RECORD.barnDoorLength] = 0;
+  out[at + LIGHT_RECORD.barnDoorLength + 1] = 0;
+}
+
+/**
+ * Which rectangle of the area buffer clustered light `light` is, for a light past the point
+ * lights. See `ClusterLightSet.areas`.
+ */
+function areaSlot(lights: ClusterLightSet, light: number): number {
+  return (lights.areaFrom ?? 0) + light - lights.count;
+}
+
+/**
+ * A rectangle's record, which the shader tells from a lamp's by its **negative radius** — its
+ * reach, negated — and reads to its sixth texel: sidedness where a lamp keeps its shadow slot,
+ * the right axis where a spot keeps its direction, the half extents where its cone is, the up
+ * axis where the azimuth is, the channels, and the barn doors in the sixth. Never shadowed: a rectangle's occlusion is
+ * the fixed arm's, which is why the first `maxAreaLights` stay there.
+ */
+function writeAreaRecord(
+  lights: ClusterLightSet,
+  light: number,
+  out: Uint32Array,
+  at: number,
+): void {
+  const areas = lights.areas;
+  const a = areaSlot(lights, light);
+  const pos = areas?.positions;
+  const color = areas?.colors;
+  const right = areas?.right;
+  const up = areas?.up;
+  const sizes = areas?.sizes;
+  out[at + LIGHT_RECORD.positionX] = floatBits(pos?.[a * 3] ?? 0);
+  out[at + LIGHT_RECORD.positionY] = floatBits(pos?.[a * 3 + 1] ?? 0);
+  out[at + LIGHT_RECORD.positionZ] = floatBits(pos?.[a * 3 + 2] ?? 0);
+  out[at + LIGHT_RECORD.radius] = floatBits(-areaReach(lights, light));
+  out[at + LIGHT_RECORD.colorR] = floatBits(color?.[a * 3] ?? 0);
+  out[at + LIGHT_RECORD.colorG] = floatBits(color?.[a * 3 + 1] ?? 0);
+  out[at + LIGHT_RECORD.colorB] = floatBits(color?.[a * 3 + 2] ?? 0);
+  out[at + LIGHT_RECORD.sizeAndWeight] = packSizeAndWeight(0, 1, true);
+  out[at + LIGHT_RECORD.shadowSlot] = floatBits(areas?.twoSided[a] ?? 0);
+  out[at + LIGHT_RECORD.directionX] = floatBits(right?.[a * 3] ?? 1);
+  out[at + LIGHT_RECORD.directionY] = floatBits(right?.[a * 3 + 1] ?? 0);
+  out[at + LIGHT_RECORD.directionZ] = floatBits(right?.[a * 3 + 2] ?? 0);
+  out[at + LIGHT_RECORD.cosInner] = floatBits(sizes?.[a * 2] ?? 0);
+  out[at + LIGHT_RECORD.cosOuter] = floatBits(sizes?.[a * 2 + 1] ?? 0);
+  out[at + LIGHT_RECORD.iesProfile] = floatBits(NO_IES_PROFILE);
+  out[at + LIGHT_RECORD.cookie] = floatBits(NO_IES_PROFILE);
+  out[at + LIGHT_RECORD.iesAxisX] = floatBits(up?.[a * 3] ?? 0);
+  out[at + LIGHT_RECORD.iesAxisY] = floatBits(up?.[a * 3 + 1] ?? 1);
+  out[at + LIGHT_RECORD.iesAxisZ] = floatBits(up?.[a * 3 + 2] ?? 0);
+  out[at + LIGHT_RECORD.channels] = floatBits(DEFAULT_LIGHT_CHANNELS);
+  out[at + LIGHT_RECORD.falloffExponent] = 0;
+  out[at + LIGHT_RECORD.barnDoorCos] = floatBits(areas?.barnDoors?.[a * 2] ?? 0);
+  out[at + LIGHT_RECORD.barnDoorLength] = floatBits(areas?.barnDoors?.[a * 2 + 1] ?? 0);
+  out[at + LIGHT_RECORD.barnDoorLength + 1] = 0;
+}
+
+/** A clustered rectangle's reach, which its record carries negated. See `AreaLightSource.range`. */
+function areaReach(lights: ClusterLightSet, light: number): number {
+  const areas = lights.areas;
+  const a = areaSlot(lights, light);
+  const named = areas?.ranges?.[a] ?? 0;
+  if (named > 0) return named;
+  const sizes = areas?.sizes;
+  return Math.hypot(sizes?.[a * 2] ?? 0, sizes?.[a * 2 + 1] ?? 0);
+}
+
+/** How many lights the table carries: the point lights and the clustered rectangles after them. */
+export function clusteredLightTotal(lights: ClusterLightSet): number {
+  return Math.min(lights.count + (lights.areaCount ?? 0), MAX_CLUSTERED_LIGHTS);
 }
 
 /**
@@ -670,7 +820,7 @@ export function buildLightClusters(
   table: Uint32Array,
   shadowSlots: number,
 ): number {
-  const count = Math.min(lights.count, MAX_CLUSTERED_LIGHTS);
+  const count = clusteredLightTotal(lights);
 
   /*
    * The whole cluster region, not just the counts.
@@ -686,10 +836,14 @@ export function buildLightClusters(
   for (let k = 0; k <= CLUSTER_Z; k++) sliceDepths[k] = sliceNearDepth(k, near, far);
 
   for (let light = 0; light < count; light++) {
-    const x = lights.positions[light * 3] ?? 0;
-    const y = lights.positions[light * 3 + 1] ?? 0;
-    const z = lights.positions[light * 3 + 2] ?? 0;
-    const radius = lights.radii[light] ?? 0;
+    /* A rectangle past the lamps is placed by its centre and binned by its reach. */
+    const area = light >= lights.count;
+    const from = area ? (lights.areas?.positions ?? lights.positions) : lights.positions;
+    const slot = area ? areaSlot(lights, light) : light;
+    const x = from[slot * 3] ?? 0;
+    const y = from[slot * 3 + 1] ?? 0;
+    const z = from[slot * 3 + 2] ?? 0;
+    const radius = area ? areaReach(lights, light) : (lights.radii[light] ?? 0);
 
     /* The record, as the shader reads it. World space; see the note above. */
     writeLightRecord(lights, light, shadowSlots, table, lightBase(light));
@@ -706,6 +860,40 @@ export function buildLightClusters(
     /* Entirely behind the camera, so no cluster can reach it. */
     if (depth + radius <= 0) continue;
 
+    /*
+     * **A spot is binned by its cone as well as its sphere.** A 10° spot reaching thirty metres
+     * touches every froxel its sphere does and lights a sliver of them, and a stage rigged with
+     * hundreds of such fixtures put every one of them in nearly every froxel near the floor: 313
+     * lights cost 11.7 ms of a 1600x900 frame. The cone is tested against each froxel's bounding
+     * sphere in view space, which is conservative, by the construction `coneBoxGap` describes.
+     */
+    const cosOuter = lights.coneCos?.[light * 2 + 1] ?? POINT_LIGHT_COS_OUTER;
+    const directions = lights.directions;
+    let coneCos = POINT_LIGHT_COS_OUTER;
+    let coneSin = 0;
+    let axisX = 0;
+    let axisY = 0;
+    let axisZ = 0;
+    if (!area && directions !== undefined && cosOuter > -1) {
+      const dx = directions[light * 3] ?? 0;
+      const dy = directions[light * 3 + 1] ?? 0;
+      const dz = directions[light * 3 + 2] ?? 0;
+      const ax = (view[0] ?? 0) * dx + (view[4] ?? 0) * dy + (view[8] ?? 0) * dz;
+      const ay = (view[1] ?? 0) * dx + (view[5] ?? 0) * dy + (view[9] ?? 0) * dz;
+      const az = -((view[2] ?? 0) * dx + (view[6] ?? 0) * dy + (view[10] ?? 0) * dz);
+      const length = Math.sqrt(ax * ax + ay * ay + az * az);
+      /* The shader measures the cone against the direction as given, so a long one is a wider
+         cone: `dot(L, d) >= c` is `dot(L, d / |d|) >= c / |d|`. */
+      if (length > 1e-6 && cosOuter / length > -1) {
+        coneCos = cosOuter / length;
+        coneSin = Math.sqrt(Math.max(0, 1 - coneCos * coneCos));
+        axisX = ax / length;
+        axisY = ay / length;
+        axisZ = az / length;
+      }
+    }
+    const spot = coneCos > -1;
+
     /*
      * The slices the sphere could possibly touch. The tiles are derived per slice, below.
      *
@@ -765,6 +953,12 @@ export function buildLightClusters(
         for (let i = iLo; i <= iHi; i++) {
           sliceBounds(i, j, zNear, zFar, halfWNear, halfWFar, halfHNear, halfHFar, bounds);
           if (distanceSqToBounds(vx, vy, depth, bounds) > radiusSq) continue;
+          if (
+            spot &&
+            coneBoxGap(vx, vy, depth, axisX, axisY, axisZ, coneCos, coneSin, bounds) > 0
+          ) {
+            continue;
+          }
           insert(table, i + j * CLUSTER_X + k * CLUSTER_X * CLUSTER_Y, light, bounds);
         }
       }
@@ -773,6 +967,59 @@ export function buildLightClusters(
   return count;
 }
 
+/**
+ * How far a froxel lies outside a spot's cone, in metres, or a negative number where the cone
+ * reaches it: positive is a froxel the light cannot shade. Everything in view space with depth
+ * positive, as the binner holds it; `axis` is unit length and `cosA`, `sinA` are the outer cone's.
+ *
+ * **The froxel's bounding sphere against the infinite cone**, after Wronski's cone test for
+ * clustered spots. With `V` from the apex to the sphere's centre at an angle `θ` from the axis and
+ * `A` the cone's half-angle, the centre's distance from the cone is `|V| sin(θ − A)` — which is
+ * `cosA |V⊥| − (V·axis) sinA` — while `θ − A` is under a right angle, and `|V|` past it, where the
+ * nearest point of the cone is its apex. Inside the cone it is negative. So the gap is exact for
+ * the sphere, and the sphere holds the froxel: the test can only keep a light, never drop one the
+ * shader would draw. The apex case is what drops a froxel behind a spot whose sphere reaches it,
+ * which the formula alone underestimates.
+ *
+ * **What it gives up** is tightness at the near end of the frustum, where a froxel is a long thin
+ * box whose sphere is much larger than it: a spot grazing such a froxel is kept. **What would make
+ * it wrong** is a profile showing those near froxels hold the cost; testing the box's corners is
+ * the tight version, at eight dot products a pair.
+ *
+ * Exported so the conformance page can tell a disagreement at the cone's edge from a real one; the
+ * GPU binner writes the same arithmetic in WGSL.
+ */
+export function coneBoxGap(
+  px: number,
+  py: number,
+  pz: number,
+  axisX: number,
+  axisY: number,
+  axisZ: number,
+  cosA: number,
+  sinA: number,
+  box: Float32Array,
+): number {
+  const b0 = box[0] ?? 0;
+  const b1 = box[1] ?? 0;
+  const b2 = box[2] ?? 0;
+  const b3 = box[3] ?? 0;
+  const b4 = box[4] ?? 0;
+  const b5 = box[5] ?? 0;
+  const ex = (b3 - b0) * 0.5;
+  const ey = (b4 - b1) * 0.5;
+  const ez = (b5 - b2) * 0.5;
+  const vx = (b0 + b3) * 0.5 - px;
+  const vy = (b1 + b4) * 0.5 - py;
+  const vz = (b2 + b5) * 0.5 - pz;
+  const along = vx * axisX + vy * axisY + vz * axisZ;
+  const lengthSq = vx * vx + vy * vy + vz * vz;
+  const across = Math.sqrt(Math.max(lengthSq - along * along, 0));
+  const reach = Math.sqrt(lengthSq);
+  const distance = along < -sinA * reach ? reach : cosA * across - along * sinA;
+  return distance - Math.sqrt(ex * ex + ey * ey + ez * ez);
+}
+
 /** An NDC coordinate to a tile index, clamped. */
 function tileOf(ndc: number, tiles: number): number {
   const tile = Math.floor((ndc + 1) * 0.5 * tiles);

package/src/render/driftLight/bake.ts

@@ -32,6 +32,8 @@ export interface FieldLight extends LightReach {
   readonly b: number;
   /** The emitter's physical radius, which widens its penumbra. */
   readonly sourceRadius: number;
+  /** Its own falloff exponent, overriding the frame's above zero. See `pointLightShape`. */
+  readonly falloffExponent?: number;
 }
 
 /**
@@ -115,7 +117,7 @@ export function sampleFieldLight(
     const dz = source.z - pz;
     const dist = Math.hypot(dx, dy, dz);
     if (dist >= source.radius) continue;
-    const shape = pointLightShape(dist, source.radius, falloff);
+    const shape = pointLightShape(dist, source.radius, falloff, source.falloffExponent);
     if (shape <= 0) continue;
     const seen =
       distance === null

package/src/render/driftLight/falloff.ts

@@ -9,13 +9,24 @@
  *
  * Both of the renderer's falloffs: `smooth`, the default, is a linear ramp squared, reaching zero at
  * the radius; `inverseSquare` is physical, windowed so it still reaches zero at the radius, and
- * floored at ten centimetres so a surface touching a light is not infinitely bright.
+ * floored at ten centimetres so a surface touching a light is not infinitely bright. And a light's
+ * own, which overrides both: `(1 - (d/R)^2)^n` with no distance term, for an exponent `n` above zero
+ * (`PointLightSource.falloffExponent`).
  */
 
 export type PointLightFalloff = 'smooth' | 'inverseSquare';
 
 /** The shader's `shape` for an unshaped point light: no cone, no photometric profile. */
-export function pointLightShape(dist: number, radius: number, falloff: PointLightFalloff): number {
+export function pointLightShape(
+  dist: number,
+  radius: number,
+  falloff: PointLightFalloff,
+  exponent = 0,
+): number {
+  if (exponent > 0) {
+    const reach = dist / Math.max(radius, 1e-4);
+    return Math.min(1, Math.max(0, 1 - reach * reach)) ** exponent;
+  }
   if (falloff === 'inverseSquare') {
     const ratio = dist / Math.max(radius, 1e-4);
     const window = Math.min(1, Math.max(0, 1 - ratio ** 4));

package/src/render/fixtureAtlas.ts

@@ -12,7 +12,7 @@
  * only ever reaches forward — to the next plane, and from the last to the repeat of the first — so
  * past its last row it meets the texture's edge and the clamp, never a cookie. A cookie's own
  * half-texel inset keeps it inside its band on both axes. The shader finds the bands from
- * `textureSize` and `uIesAtlasRows`, so the fold cost no uniform.
+ * `textureSize` and `uFixtureShape.x`, so the fold cost no uniform.
  *
  * **What it gives up**: every texel is four half floats where a profile needed one, a few kilobytes
  * a scene; and setting either table rebuilds the whole texture, which a consumer does once per set.

package/src/render/gi/bounceLights.ts

@@ -23,15 +23,20 @@
  */
 
 import type { PointLightSet } from '../lightBudget.ts';
-import { POINT_LIGHT_COS_INNER, POINT_LIGHT_COS_OUTER } from '../clusteredLights.ts';
+import {
+  POINT_LIGHT_COS_INNER,
+  POINT_LIGHT_COS_OUTER,
+  lightFalloffExponentOf,
+} from '../clusteredLights.ts';
 
 /** Lights the probe bake shades a hit with. */
 export const MAX_BOUNCE_LIGHTS = 32;
 /**
  * Floats a light takes: where it is and how far it reaches; its colour at its weight and the cosine
- * of its inner cone; the way it points and the cosine of its outer cone.
+ * of its inner cone; the way it points and the cosine of its outer cone; and its own falloff
+ * exponent, 0 for the frame's, in a fourth row of its own (`PointLightSource.falloffExponent`).
  */
-export const BOUNCE_LIGHT_FLOATS = 12;
+export const BOUNCE_LIGHT_FLOATS = 16;
 
 export function createBounceLights(): Float32Array {
   return new Float32Array(MAX_BOUNCE_LIGHTS * BOUNCE_LIGHT_FLOATS);
@@ -62,6 +67,10 @@ export function resolveBounceLights(lights: PointLightSet | null, out: Float32Ar
     out[at + 9] = lights.lightDirections?.[i * 3 + 1] ?? 0;
     out[at + 10] = lights.lightDirections?.[i * 3 + 2] ?? 0;
     out[at + 11] = lights.lightConeCos?.[i * 2 + 1] ?? POINT_LIGHT_COS_OUTER;
+    out[at + 12] = lightFalloffExponentOf(lights.lightFalloffExponents?.[i]);
+    out[at + 13] = 0;
+    out[at + 14] = 0;
+    out[at + 15] = 0;
     count++;
   }
   return count;

package/src/render/instanceCull.ts

@@ -71,6 +71,15 @@ export function cullInstances(
     out.tints[kept * 3] = tints[i * 3] as number;
     out.tints[kept * 3 + 1] = tints[i * 3 + 1] as number;
     out.tints[kept * 3 + 2] = tints[i * 3 + 2] as number;
+    if (out.alphas !== undefined) out.alphas[kept] = data.alphas?.[i] ?? 1;
+    const regions = data.lightmapRegions;
+    if (regions !== undefined && out.lightmapRegions !== undefined) {
+      for (let k = 0; k < 4; k++) out.lightmapRegions[kept * 4 + k] = regions[i * 4 + k] as number;
+    }
+    const cells = data.uvRegions;
+    if (cells !== undefined && out.uvRegions !== undefined) {
+      for (let k = 0; k < 4; k++) out.uvRegions[kept * 4 + k] = cells[i * 4 + k] as number;
+    }
     kept++;
   }
   out.count = kept;