@driftengine/core 4.8.6 → 4.8.7

package/dist/render/clusteredLights.d.ts

@@ -85,7 +85,7 @@ export declare 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 declare const LIGHT_TEXELS = 5;
+export declare const LIGHT_TEXELS = 6;
 /**
  * Where each field of a light's record sits, as an offset in `uint`s from `lightBase`.
  *
@@ -115,7 +115,11 @@ export declare 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 declare const LIGHT_RECORD: {
     readonly positionX: 0;
@@ -146,6 +150,11 @@ export declare const LIGHT_RECORD: {
      * last texels are fetched; a plain light's are not, and the shader takes the default for it.
      */
     readonly channels: 19;
+    /** The light's own falloff exponent, or 0 for the frame's falloff. `PointLightSource.falloffExponent`. */
+    readonly falloffExponent: 20;
+    /** A rectangle's barn doors: the cosine of their angle from its normal, then their length in metres. */
+    readonly barnDoorCos: 21;
+    readonly barnDoorLength: 22;
 };
 /** The lighting channel every light and every surface is on unless it says otherwise. */
 export declare const DEFAULT_LIGHT_CHANNELS = 1;
@@ -155,10 +164,16 @@ export declare const DEFAULT_LIGHT_CHANNELS = 1;
  * this, so a light named badly is on channel 1 in both rather than on two different guesses.
  */
 export declare function lightChannelsOf(value: number | undefined): number;
+/**
+ * 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 declare function lightFalloffExponentOf(value: number | undefined): number;
 /** Texels the lit pass reads for a light whose record carries no fixture. */
 export declare 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 declare const LIGHT_FIXTURE_FLAG = 32768;
@@ -287,6 +302,8 @@ export interface ClusterLightSet {
     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
@@ -310,6 +327,7 @@ export interface ClusterLightArrays {
     readonly lightIesAxes?: Float32Array;
     readonly lightCookies?: Float32Array;
     readonly lightChannels?: Float32Array;
+    readonly lightFalloffExponents?: Float32Array;
     readonly areaLights?: AreaLightBuffer | null;
 }
 /** A `ClusterLightSet` a renderer refills every frame. */
@@ -336,8 +354,8 @@ export declare function fillClusterLightSet(env: ClusterLightArrays, out: Cluste
 /** How many rectangles the fixed arm shades; the rest of the buffer is clustered. */
 areaFrom?: number): ClusterLightSet;
 /**
- * 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

package/dist/render/clusteredLights.js

@@ -84,7 +84,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`.
  *
@@ -114,7 +114,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,
@@ -145,6 +149,11 @@ export const LIGHT_RECORD = {
      * 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,
 };
 /** The lighting channel every light and every surface is on unless it says otherwise. */
 export const DEFAULT_LIGHT_CHANNELS = 1;
@@ -159,10 +168,18 @@ export function lightChannelsOf(value) {
     }
     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) {
+    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;
@@ -392,6 +409,7 @@ areaFrom = 0) {
     out.iesAxes = env.lightIesAxes;
     out.cookies = env.lightCookies;
     out.channels = env.lightChannels;
+    out.falloffExponents = env.lightFalloffExponents;
     return out;
 }
 /*
@@ -436,8 +454,8 @@ function distanceSqToBounds(x, y, z, b) {
     return dx * dx + dy * dy + dz * dz;
 }
 /**
- * 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
@@ -453,7 +471,8 @@ export function lightHasFixture(lights, light, shadowSlots) {
         (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 ||
-        lightChannelsOf(lights.channels?.[light]) !== DEFAULT_LIGHT_CHANNELS);
+        lightChannelsOf(lights.channels?.[light]) !== DEFAULT_LIGHT_CHANNELS ||
+        lightFalloffExponentOf(lights.falloffExponents?.[light]) > 0);
 }
 /**
  * The value of `uClustered` for a frame: 0 with clustering off, 1 when every light is plain, 2 when
@@ -525,6 +544,10 @@ export function writeLightRecord(lights, light, shadowSlots, out, at) {
     out[at + LIGHT_RECORD.iesAxisY] = floatBits(axes?.[light * 3 + 1] ?? 0);
     out[at + LIGHT_RECORD.iesAxisZ] = floatBits(axes?.[light * 3 + 2] ?? 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
@@ -535,9 +558,9 @@ function areaSlot(lights, light) {
 }
 /**
  * A rectangle's record, which the shader tells from a lamp's by its **negative radius** — its
- * reach, negated — and reads to its fifth texel: sidedness where a lamp keeps its shadow slot,
+ * 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, and the channels last. Never shadowed: a rectangle's occlusion is
+ * 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, light, out, at) {
@@ -568,6 +591,10 @@ function writeAreaRecord(lights, light, out, at) {
     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, light) {

package/dist/render/driftLight/bake.d.ts

@@ -26,6 +26,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;
 }
 /**
  * Fill `light` and `direction`, `BRICK_TEXELS * 4` floats each, x fastest, for brick `brick`.

package/dist/render/driftLight/bake.js

@@ -66,7 +66,7 @@ export function sampleFieldLight(px, py, pz, lights, candidates, first, last, fa
         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/dist/render/driftLight/falloff.d.ts

@@ -9,8 +9,10 @@
  *
  * 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 declare function pointLightShape(dist: number, radius: number, falloff: PointLightFalloff): number;
+export declare function pointLightShape(dist: number, radius: number, falloff: PointLightFalloff, exponent?: number): number;

package/dist/render/driftLight/falloff.js

@@ -9,10 +9,16 @@
  *
  * 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`).
  */
 /** The shader's `shape` for an unshaped point light: no cone, no photometric profile. */
-export function pointLightShape(dist, radius, falloff) {
+export function pointLightShape(dist, radius, falloff, exponent = 0) {
+    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/dist/render/gi/bounceLights.d.ts

@@ -26,9 +26,10 @@ import type { PointLightSet } from '../lightBudget.ts';
 export declare 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 declare const BOUNCE_LIGHT_FLOATS = 12;
+export declare const BOUNCE_LIGHT_FLOATS = 16;
 export declare function createBounceLights(): Float32Array;
 /** Pack the lights of `lights` the bounce reads into `out`, and answer how many. */
 export declare function resolveBounceLights(lights: PointLightSet | null, out: Float32Array): number;

package/dist/render/gi/bounceLights.js

@@ -21,14 +21,15 @@
  * What it gives up against the frame: a photometric profile and a cookie, which the bounce reads as
  * a plain cone, and a light's specular, which a diffuse bounce has no use for.
  */
-import { POINT_LIGHT_COS_INNER, POINT_LIGHT_COS_OUTER } from '../clusteredLights.js';
+import { POINT_LIGHT_COS_INNER, POINT_LIGHT_COS_OUTER, lightFalloffExponentOf, } from '../clusteredLights.js';
 /** 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() {
     return new Float32Array(MAX_BOUNCE_LIGHTS * BOUNCE_LIGHT_FLOATS);
 }
@@ -60,6 +61,10 @@ export function resolveBounceLights(lights, out) {
         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/dist/render/instanceCull.js

@@ -51,6 +51,11 @@ export function cullInstances(data, local, frustum, out) {
             for (let k = 0; k < 4; k++)
                 out.lightmapRegions[kept * 4 + k] = regions[i * 4 + k];
         }
+        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];
+        }
         kept++;
     }
     out.count = kept;

package/dist/render/instances.d.ts

@@ -12,9 +12,9 @@
  *
  * **What it gives up** is a matrix per instance where a scatter spends five floats: 80 bytes
  * against 44, and no wind. **What would make it wrong** is a caller wanting per-instance
- * anything beyond an opacity — a morph weight, a texture cell — which wants another attribute,
- * and the sixteen WebGL2 guarantees are already spent. The opacity rides the float the stride was
- * padded with, which is why it costs nothing.
+ * anything beyond an opacity and a texture cell — a morph weight, say — which wants another
+ * attribute, and the sixteen WebGL2 guarantees are already spent. The opacity rides the float the
+ * stride was padded with and the cell the matrix's bottom row, which is why neither costs a byte.
  */
 export interface MeshInstances {
     /**
@@ -51,6 +51,20 @@ export interface MeshInstances {
      * either mismatch is said once on the console.
      */
     readonly lightmapRegions?: Float32Array;
+    /**
+     * Four floats each, the instance's cell of its texture: `[scaleU, scaleV, offsetU, offsetV]`,
+     * applied to the mesh's coordinates before the material's own scale and offset, in every pass
+     * that reads them — so one draw carries particles in different cells of a flipbook, or props
+     * wearing different tiles of one atlas. **Absent, or past `count`, is the whole texture**,
+     * `[1, 1, 0, 0]`, which is what every instance read before 4.8.7.
+     *
+     * **It rides the matrix's bottom row**, which an instance's placement — a turn, a scale and a
+     * move — leaves at `[0, 0, 0, 1]`, and which every stage drawing an instance rebuilds as that.
+     * So a placement must be affine, as every placement of a solid object is; a projective one is
+     * drawn as its affine part. A culled batch (`cullInstances`) carries the cells only into a
+     * target that has the array.
+     */
+    readonly uvRegions?: Float32Array;
     /** How many instances the arrays hold. Fixed at creation; the buffers are sized from it. */
     readonly capacity: number;
     /** How many are live. The rest of the buffer is neither uploaded nor drawn. */
@@ -65,8 +79,8 @@ export interface MeshInstances {
  */
 export declare function createMeshInstances(capacity: number): MeshInstances;
 /**
- * Floats one instance occupies in the interleaved vertex buffer: sixteen of matrix, three of
- * tint, and the opacity.
+ * Floats one instance occupies in the interleaved vertex buffer: sixteen of matrix, the bottom row
+ * of which carries the texture cell, three of tint, and the opacity.
  *
  * **Twenty so the stride is 80 bytes rather than 76.** A vertex buffer's stride must be a multiple
  * of four on both backends, which 76 already is — the twentieth float was padding for the

package/dist/render/instances.js

@@ -15,8 +15,8 @@ export function createMeshInstances(capacity) {
     };
 }
 /**
- * Floats one instance occupies in the interleaved vertex buffer: sixteen of matrix, three of
- * tint, and the opacity.
+ * Floats one instance occupies in the interleaved vertex buffer: sixteen of matrix, the bottom row
+ * of which carries the texture cell, three of tint, and the opacity.
  *
  * **Twenty so the stride is 80 bytes rather than 76.** A vertex buffer's stride must be a multiple
  * of four on both backends, which 76 already is — the twentieth float was padding for the
@@ -39,13 +39,19 @@ export const INSTANCE_STRIDE = INSTANCE_FLOATS * 4;
  * Writes nothing beyond `count`, and allocates nothing: `out` is the caller's staging array.
  */
 export function packInstances(instances, out) {
-    const { models, tints, alphas, lightmapRegions } = instances;
+    const { models, tints, alphas, lightmapRegions, uvRegions } = instances;
     const count = Math.min(instances.count, instances.capacity);
     for (let i = 0; i < count; i += 1) {
         const at = i * INSTANCE_FLOATS;
         const m = i * 16;
         for (let c = 0; c < 16; c += 1)
             out[at + c] = models[m + c];
+        /* The texture cell in the bottom row an affine placement leaves free. See `uvRegions`. */
+        const cell = i * 4;
+        out[at + 3] = uvRegions?.[cell] ?? 1;
+        out[at + 7] = uvRegions?.[cell + 1] ?? 1;
+        out[at + 11] = uvRegions?.[cell + 2] ?? 0;
+        out[at + 15] = uvRegions?.[cell + 3] ?? 0;
         if (lightmapRegions !== undefined) {
             /* The region in the tint's and the opacity's place. See `lightmapRegions`. */
             for (let c = 0; c < 4; c += 1)

package/dist/render/lightBudget.d.ts

@@ -1,4 +1,3 @@
-/** Fixed point-light budget shared by CPU selection and the flat shader. */
 import type { AreaLightBuffer } from './areaLights.ts';
 import type { ResolvedAreaShadows } from './areaShadowSet.ts';
 /**
@@ -368,6 +367,12 @@ export interface PointLightSet {
      * character's own key and rim lights, which the floor around the character must not take.
      */
     readonly lightChannels?: Float32Array;
+    /**
+     * One per light: its own falloff exponent, `(1 - (d/R)^2)^n` with no distance term, or 0 for the
+     * frame's falloff. **Absent, or a short array, is 0 for every light**, so a scene that names none
+     * falls off as it did. See `PointLightSource.falloffExponent`.
+     */
+    readonly lightFalloffExponents?: Float32Array;
 }
 /**
  * A cone that admits every direction, for every light.
@@ -441,6 +446,12 @@ export interface ResolvedPointLights {
      * array of their own, which would cost a row a light of a budget that has none to give.
      */
     readonly axesAndChannels: Float32Array;
+    /**
+     * Owned, four a light: the cone's two cosines, then the light's own falloff exponent, as
+     * `uLightCone` carries them — a `vec2` array costs a whole row a light on WebGL2 anyway, so the
+     * exponent rides the half it left rather than a row of its own.
+     */
+    readonly conesAndFalloffs: Float32Array;
     /**
      * Owned, `MAX_POINT_LIGHTS` long: the emitter sizes and weights as the froxel record carries
      * them, at half precision. `sourceRadii` and `weights` point here once a light set resolves, so

package/dist/render/lightBudget.js

@@ -1,4 +1,6 @@
-import { POINT_LIGHT_COS_INNER, POINT_LIGHT_COS_OUTER, lampSourceRadius, lampWeight, lightChannelsOf, } from './clusteredLights.js';
+/** Fixed point-light budget shared by CPU selection and the flat shader. */
+import { MAX_AREA_LIGHTS, packAreaSizesAndDoors } from './areaLights.js';
+import { POINT_LIGHT_COS_INNER, POINT_LIGHT_COS_OUTER, lampSourceRadius, lampWeight, lightChannelsOf, lightFalloffExponentOf, } from './clusteredLights.js';
 /**
  * How many point lights the shading pass shades against at once.
  *
@@ -302,6 +304,8 @@ export const SDF_TEXT_TEXTURE_UNIT = SURFACE_TEXTURE_UNIT;
 export const POINT_SHADOW_POOL = MAX_POINT_LIGHTS + 4;
 /** Weights are optional per consumer; a short array means every light is fully present. */
 const FULLY_PRESENT = new Float32Array(MAX_POINT_LIGHTS).fill(1);
+/** The fixed arm's rectangles as `uAreaLightSize` holds them; refilled per bind, allocated once. */
+const AREA_SIZES_AND_DOORS = new Float32Array(MAX_AREA_LIGHTS * 4);
 /** No size at all, which is the behaviour every scene had before a light could have one. */
 const POINT_SOURCES = new Float32Array(MAX_POINT_LIGHTS);
 /**
@@ -394,7 +398,8 @@ export function bindPointLights(gl, uniforms, lights, falloff) {
      * every lamp switched off.
      */
     gl.uniform3fv(uniforms['uLightDir[0]'] ?? null, r.directions);
-    gl.uniform2fv(uniforms['uLightCone[0]'] ?? null, r.coneCos);
+    /* The cone and, in z, the light's own falloff exponent. See `conesAndFalloffs`. */
+    gl.uniform4fv(uniforms['uLightCone[0]'] ?? null, r.conesAndFalloffs);
     gl.uniform1fv(uniforms['uLightIesProfile[0]'] ?? null, r.iesProfiles);
     /* The azimuth and, in w, the channels. See `axesAndChannels`. */
     gl.uniform4fv(uniforms['uLightIesAxis[0]'] ?? null, r.axesAndChannels);
@@ -421,7 +426,9 @@ export function bindAreaLights(gl, uniforms, lights) {
     gl.uniform3fv(uniforms['uAreaLightColor[0]'] ?? null, lights.colors);
     gl.uniform3fv(uniforms['uAreaLightRight[0]'] ?? null, lights.right);
     gl.uniform3fv(uniforms['uAreaLightUp[0]'] ?? null, lights.up);
-    gl.uniform2fv(uniforms['uAreaLightSize[0]'] ?? null, lights.sizes);
+    /* The half extents and, in zw, the barn doors. See `packAreaSizesAndDoors`. */
+    packAreaSizesAndDoors(lights, AREA_SIZES_AND_DOORS);
+    gl.uniform4fv(uniforms['uAreaLightSize[0]'] ?? null, AREA_SIZES_AND_DOORS);
     gl.uniform1fv(uniforms['uAreaLightTwoSided[0]'] ?? null, lights.twoSided);
 }
 /**
@@ -463,6 +470,7 @@ const glLights = {
     iesAxes: NO_IES_AXES,
     cookies: NO_COOKIES,
     axesAndChannels: new Float32Array(MAX_POINT_LIGHTS * 4),
+    conesAndFalloffs: new Float32Array(MAX_POINT_LIGHTS * 4),
     heldSourceRadii: new Float32Array(MAX_POINT_LIGHTS),
     heldWeights: new Float32Array(MAX_POINT_LIGHTS),
 };
@@ -493,6 +501,7 @@ export function resolvePointLights(lights, falloff, out) {
         out.iesAxes = NO_IES_AXES;
         out.cookies = NO_COOKIES;
         packAxesAndChannels(NO_IES_AXES, undefined, out.axesAndChannels);
+        packConesAndFalloffs(OPEN_CONES, undefined, out.conesAndFalloffs);
         return out;
     }
     /*
@@ -574,8 +583,19 @@ export function resolvePointLights(lights, falloff, out) {
     out.iesAxes = iesAxes;
     out.cookies = cookies;
     packAxesAndChannels(iesAxes, lights.lightChannels, out.axesAndChannels);
+    packConesAndFalloffs(coneCos, lights.lightFalloffExponents, out.conesAndFalloffs);
     return out;
 }
+/** The cone and the falloff exponent, four a light, as `uLightCone` holds them. */
+function packConesAndFalloffs(cones, exponents, out) {
+    const named = (exponents?.length ?? 0) >= MAX_POINT_LIGHTS ? exponents : undefined;
+    for (let light = 0; light < MAX_POINT_LIGHTS; light++) {
+        out[light * 4] = cones[light * 2] ?? POINT_LIGHT_COS_INNER;
+        out[light * 4 + 1] = cones[light * 2 + 1] ?? POINT_LIGHT_COS_OUTER;
+        out[light * 4 + 2] = lightFalloffExponentOf(named?.[light]);
+        out[light * 4 + 3] = 0;
+    }
+}
 /** The azimuth and the channels, four a light, as `uLightIesAxis` holds them. */
 function packAxesAndChannels(axes, channels, out) {
     const named = (channels?.length ?? 0) >= MAX_POINT_LIGHTS ? channels : undefined;

package/dist/render/lightmap.d.ts

@@ -35,10 +35,12 @@ export interface LightmapPage {
     readonly width: number;
     readonly height: number;
     /**
-     * Linear irradiance, three floats a texel, row-major from the top, in the same units every other
-     * light here is in — a bake from another engine scaled by that engine's exposure, as its lights are.
+     * Linear irradiance, row-major from the top, in the same units every other light here is in — a
+     * bake from another engine scaled by that engine's exposure, as its lights are. Either three
+     * floats a texel, or one word a texel already packed as rgb9e5 (`rgb9e5.ts`), which is how such a
+     * bake usually arrives and which uploads with no conversion at all.
      */
-    readonly irradiance: Float32Array;
+    readonly irradiance: Float32Array | Uint32Array;
     /**
      * The direction the light arrives from, four bytes a texel: a first-order spherical harmonic in
      * this engine's world axes, each value stored as `v * 0.5 + 0.5` — xyz the axis, w the constant.
@@ -54,20 +56,32 @@ export declare const LIGHTMAP_LAYERS = 2;
 export type LightmapRegion = readonly [number, number, number, number];
 /** The whole page. */
 export declare const WHOLE_PAGE: LightmapRegion;
-/** A page as both backends upload it: `layers` images of half-float RGBA, row-major from the top. */
+/**
+ * A page as both backends upload it: two layers of four bytes a texel, row-major from the top. The
+ * first is the irradiance's rgb9e5 word, byte by byte from its lowest; the second is the direction.
+ *
+ * **Eight bytes a texel, and the shader filters it.** Half floats were sixteen: a stage of 49 pages
+ * and 21.8 million texels held 348 MB, where this holds 174. The price is that the irradiance cannot
+ * be filtered as it is stored — a bilinear blend of two words with different exponents is not the
+ * blend of the colours they hold — so the lit stage fetches a texel's four neighbours, decodes each
+ * and blends the colours (`modelBaked` in `shaders/flat/models.ts`): four fetches a layer where one
+ * filtered sample was, on lightmapped surfaces alone. **What would make it wrong** is every device
+ * a page reaches sampling `rgb9e5ufloat`, which WebGL2 does as `RGB9_E5` too; it would then be a
+ * texture of its own, filtered by the device, and a binding the lit stage has no room for.
+ */
 export interface LightmapTexels {
     readonly kind: 'lightmap-texels';
     readonly width: number;
     readonly height: number;
-    readonly layers: number;
-    readonly texels: Uint16Array;
+    /** Each layer's bytes, in layer order: the irradiance, then the direction. */
+    readonly layers: readonly Uint8Array[];
 }
 /** Whether a surface texture's source is a page's texels rather than an image or blocks. */
 export declare function isLightmapTexels(source: unknown): source is LightmapTexels;
 /**
- * A page as both backends upload it: two layers of half-float RGBA, the irradiance with an alpha of
- * one and the direction as the fractions its bytes are. Refuses a page whose arrays are not its
- * size, naming the one that is short.
+ * A page as both backends upload it (see `LightmapTexels`). Refuses a page whose arrays are not its
+ * size, naming the one that is short. Packed irradiance is read where it lies, with no copy; float
+ * irradiance is packed once, here.
  */
 export declare function lightmapTexels(page: LightmapPage): LightmapTexels;
 /**

package/dist/render/lightmap.js

@@ -1,4 +1,4 @@
-import { toHalfFloats } from './halfFloat.js';
+import { packRgb9e5 } from './rgb9e5.js';
 /** Layers a page is uploaded as: the irradiance, then the direction. */
 export const LIGHTMAP_LAYERS = 2;
 /** The whole page. */
@@ -10,9 +10,9 @@ export function isLightmapTexels(source) {
         source.kind === 'lightmap-texels');
 }
 /**
- * A page as both backends upload it: two layers of half-float RGBA, the irradiance with an alpha of
- * one and the direction as the fractions its bytes are. Refuses a page whose arrays are not its
- * size, naming the one that is short.
+ * A page as both backends upload it (see `LightmapTexels`). Refuses a page whose arrays are not its
+ * size, naming the one that is short. Packed irradiance is read where it lies, with no copy; float
+ * irradiance is packed once, here.
  */
 export function lightmapTexels(page) {
     const { width, height } = page;
@@ -20,32 +20,54 @@ export function lightmapTexels(page) {
         throw new Error(`createLightmap: a ${width} by ${height} page has nothing in it`);
     }
     const texels = width * height;
-    if (page.irradiance.length !== texels * 3) {
-        throw new Error(`createLightmap: ${page.irradiance.length} irradiance floats for a ${width} by ${height} ` +
-            `page, which wants ${texels * 3}: three a texel`);
+    const irradiance = page.irradiance;
+    const packed = irradiance instanceof Uint32Array;
+    const wanted = packed ? texels : texels * 3;
+    if (irradiance.length !== wanted) {
+        throw new Error(`createLightmap: ${irradiance.length} irradiance ${packed ? 'words' : 'floats'} for a ` +
+            `${width} by ${height} page, which wants ${wanted}: ` +
+            (packed ? 'one rgb9e5 word a texel' : 'three a texel'));
     }
     if (page.direction.length !== texels * 4) {
         throw new Error(`createLightmap: ${page.direction.length} direction bytes for a ${width} by ${height} ` +
             `page, which wants ${texels * 4}: four a texel`);
     }
-    const floats = new Float32Array(texels * 4 * LIGHTMAP_LAYERS);
-    for (let t = 0; t < texels; t++) {
-        floats[t * 4] = page.irradiance[t * 3];
-        floats[t * 4 + 1] = page.irradiance[t * 3 + 1];
-        floats[t * 4 + 2] = page.irradiance[t * 3 + 2];
-        floats[t * 4 + 3] = 1;
-        const at = (texels + t) * 4;
-        for (let c = 0; c < 4; c++)
-            floats[at + c] = page.direction[t * 4 + c] / 255;
+    let words;
+    if (packed) {
+        words = irradiance;
+    }
+    else {
+        words = new Uint32Array(texels);
+        for (let t = 0; t < texels; t++) {
+            words[t] = packRgb9e5(irradiance[t * 3], irradiance[t * 3 + 1], irradiance[t * 3 + 2]);
+        }
     }
     return {
         kind: 'lightmap-texels',
         width,
         height,
-        layers: LIGHTMAP_LAYERS,
-        texels: toHalfFloats(floats),
+        layers: [littleEndianBytes(words), page.direction],
     };
 }
+/** Whether this platform lays a word out lowest byte first, which the shader's decode assumes. */
+const LITTLE_ENDIAN = new Uint8Array(new Uint32Array([1]).buffer)[0] === 1;
+/**
+ * A page's words as bytes, lowest first: a view of the same memory on every little-endian platform,
+ * which is every one a browser runs on, and a reordered copy anywhere else.
+ */
+function littleEndianBytes(words) {
+    const bytes = new Uint8Array(words.buffer, words.byteOffset, words.length * 4);
+    if (LITTLE_ENDIAN)
+        return bytes;
+    const swapped = new Uint8Array(bytes.length);
+    for (let i = 0; i < bytes.length; i += 4) {
+        swapped[i] = bytes[i + 3];
+        swapped[i + 1] = bytes[i + 2];
+        swapped[i + 2] = bytes[i + 1];
+        swapped[i + 3] = bytes[i];
+    }
+    return swapped;
+}
 /**
  * A mesh with its second coordinates moved onto the grain and relief streams they ride, or the
  * mesh itself where it has none. Called by both backends' `createMesh`, before anything records