@driftengine/core 4.8.5 → 4.8.7

package/dist/render/shaders/flat/models.js

@@ -33,12 +33,25 @@ const bool MODEL_HAIR = false;  // wgsl:override
 const bool MODEL_SKIN = false;  // wgsl:override
 const bool MODEL_EYE = false;  // wgsl:override
 /*
- * Skin's screen-space scattering, as two halves of one surface: the scene pass without its diffuse,
- * and a pass that is nothing but it, which the blur spreads before it is added back. Both off but
- * where \`skinScattering\` is \`'screen-space'\`; see \`skinBlur.ts\`.
+ * Skin's screen-space scattering, as halves of one surface: the scene pass without its diffuse; a
+ * pass that is nothing but the light the diffuse is made of, which the blur spreads; and a pass that
+ * is nothing but the colour that light is multiplied by once it has spread. All off but where
+ * \`skinScattering\` is \`'screen-space'\`; see \`skinBlur.ts\`.
  */
 const bool SKIN_SCREEN = false;  // wgsl:override
 const bool SKIN_DIFFUSE = false;  // wgsl:override
+const bool SKIN_ALBEDO = false;  // wgsl:override
+/*
+ * Not a model of light but a page of it: the standard model, plus what a bake left (lightmap.ts).
+ * Declared after skin's halves so that every switch before it keeps the id it shipped with.
+ */
+const bool MODEL_LIGHTMAP = false;  // wgsl:override
+/*
+ * Not a model either: whether this program carries GGX's own highlight for a material that asks
+ * (\`SurfaceMaterial.physicalSpecular\`). A lit switch, off until a material first asks and then
+ * on for good, as \`litSwitchesGlsl\`'s are; declared last so every switch before it keeps its id.
+ */
+const bool PHYSICAL_SPECULAR = PHYSICAL_SPECULAR_ON;  // wgsl:override
 
 /*
  * A model's numbers, two vectors a material — the lit stage's uniform budget has no more room
@@ -65,6 +78,14 @@ bool modelDiffuseAlone() {
   return false;
 }
 
+/** Whether this pipeline draws skin's colour alone, which the spread light is multiplied by. */
+bool modelAlbedoAlone() {
+  if (MODEL_SKIN) {
+    if (SKIN_ALBEDO) return true;
+  }
+  return false;
+}
+
 /** Whether light from behind the surface reaches the eye through it: hair, and skin's thin parts. */
 bool modelSeesBehind() {
   if (MODEL_HAIR) return true;
@@ -109,15 +130,57 @@ float smithMasking(float ndl, float ndv, float alpha) {
   );
 }
 
+/*
+ * Whether this surface's highlights are GGX's own (\`SurfaceMaterial.physicalSpecular\`), from the
+ * lane the standard, lightmap and anisotropic models leave free (\`packModel\`). Skin, hair and the
+ * eye shade their own highlights, and the eye's axis holds that lane, so they are never asked. The
+ * lit switch first, so a program built before any material asked carries none of it.
+ */
+bool physicalSpecular() {
+  if (PHYSICAL_SPECULAR) {
+    if (MODEL_HAIR) return false;
+    if (MODEL_SKIN) return false;
+    if (MODEL_EYE) return false;
+    return uModelParams[1].z > 0.5;
+  }
+  return false;
+}
+
+/**
+ * GGX as a BRDF in this engine's light units, \`π · D · Vis · N·L\` with Fresnel left to the caller:
+ * the term skin's and the eye's highlights are, for a surface that asks for it. Its peak is
+ * \`1 / (4 α²)\` of the light head-on, against the look's 1. A lamp's size widens α as \`sphereLobe\`
+ * widens it, and a normalised distribution keeps its energy as it widens.
+ */
+float physicalLobe(float ndh, float ndl, float ndv, float roughness, float sourceRadius, float dist) {
+  float grow = sourceRadius / max(2.0 * dist, 1e-3);
+  float alpha = min(max(roughness * roughness, MIN_LOBE_ALPHA) + grow, 1.0);
+  return 3.14159265 * ggxLobe(ndh, alpha) * smithMasking(ndl, max(ndv, 1e-4), alpha) * ndl;
+}
+
+/**
+ * A highlight's colour: Schlick's Fresnel from the surface's reflectance toward white at a grazing
+ * \`voh\`. On a metal alone for the look, whose dielectric attribute is a strength rather than a
+ * reflectance; on every surface where the highlight is physical, whose attribute is its F0 — but
+ * one reflecting nothing head-on keeps nothing, as the lamps' gate on that attribute has it.
+ */
+vec3 highlightTint(vec3 specColor, float voh, float metal) {
+  float edge = pow(1.0 - voh, 5.0);
+  bool reflects = max(max(specColor.r, specColor.g), specColor.b) > 0.0;
+  return mix(specColor, vec3(1.0), physicalSpecular() && reflects ? edge : edge * metal);
+}
+
 /** The standard model's answer to one light, which a model falls back to for what it does not change. */
 void standardLight(vec3 l, float sourceRadius, float dist) {
   float ndl = max(dot(mNormal, l), 0.0);
   vec3 h = normalize(l + mToEye);
   float ndh = max(dot(mNormal, h), 0.0);
-  float lobe = sourceRadius > 0.0
-    ? sphereLobe(ndh, mRoughness, sourceRadius, dist)
-    : specularLobe(ndh, mRoughness);
-  vec3 tint = mix(mSpecColor, vec3(1.0), pow(1.0 - max(dot(mToEye, h), 0.0), 5.0) * mMetal);
+  float lobe = physicalSpecular()
+    ? physicalLobe(ndh, ndl, dot(mNormal, mToEye), mRoughness, sourceRadius, dist)
+    : sourceRadius > 0.0
+      ? sphereLobe(ndh, mRoughness, sourceRadius, dist)
+      : specularLobe(ndh, mRoughness);
+  vec3 tint = highlightTint(mSpecColor, max(dot(mToEye, h), 0.0), mMetal);
   mDiffuse = mAlbedo * ndl * (1.0 - mMetal);
   mSpecular = ndl > 0.0 ? tint * lobe : vec3(0.0);
 }
@@ -146,6 +209,15 @@ void modelSurface(vec3 n, vec3 albedo, float roughness, float metal, vec3 at) {
   mTangent = frame[0];
   mBitangent = frame[1];
   mAlbedo = albedo;
+  /*
+   * **The diffuse half is light, not colour.** The blur spreads what this half writes, and what
+   * spreads beneath skin is the light: a brow, a lip line and a freckle stay where they are drawn.
+   * So this half shades a white surface and the colour is applied after the spread, from a half of
+   * its own. Spreading the coloured diffuse smeared every mark on a face into the skin around it.
+   */
+  if (MODEL_SKIN) {
+    if (SKIN_DIFFUSE) mAlbedo = vec3(1.0);
+  }
   mSpecColor = mix(vec3(vSpecular), albedo, metal);
   mRoughness = roughness;
   mMetal = metal;
@@ -226,6 +298,56 @@ vec3 modelEnvironment(vec3 environment) {
   return environment;
 }
 
+/**
+ * One texel of a page's irradiance layer: its four bytes put back into the rgb9e5 word they are,
+ * lowest first, and decoded — three 9-bit mantissas over the exponent in the top five bits.
+ */
+vec3 bakedIrradianceAt(ivec3 texel) {
+  uvec4 bytes = uvec4(texelFetch(uModelMap, texel, 0) * 255.0 + 0.5);
+  uint word = bytes.x | (bytes.y << 8u) | (bytes.z << 16u) | (bytes.w << 24u);
+  float scale = exp2(float(word >> 27u) - 24.0);
+  return vec3(float(word & 511u), float((word >> 9u) & 511u), float((word >> 18u) & 511u)) * scale;
+}
+
+/**
+ * What a baked page adds to this surface's diffuse: nothing in any pipeline but a lightmapped one,
+ * nor in one whose page is missing. The page's two layers at the surface's second coordinates, which
+ * ride the grain and relief lanes as \`-1 - uv\` (lightmap.ts) and are placed by the material's
+ * region: the irradiance, and the first-order harmonic its direction is, answered by the shading
+ * normal.
+ *
+ * **Filtered here, because the page cannot be filtered as it is stored**: the irradiance is a
+ * shared-exponent word in four bytes, and a blend of two words is not the blend of their colours.
+ * So the four texels around the sample are fetched, decoded and blended, as a bilinear sampler
+ * clamped at the page's edge would. Fetches need no derivative, so the branch costs nothing there.
+ */
+vec3 modelBaked(vec3 n, vec3 albedo, float metal) {
+  if (MODEL_LIGHTMAP) {
+    if (uModelParams[1].w <= 0.0) return vec3(0.0);
+    vec2 at = (vec2(-1.0) - vec2(vGrain, vRelief)) * uModelParams[0].xy + uModelParams[0].zw;
+    ivec2 size = textureSize(uModelMap, 0).xy;
+    vec2 texel = at * vec2(size) - 0.5;
+    vec2 corner = floor(texel);
+    vec2 f = texel - corner;
+    ivec2 last = size - 1;
+    ivec2 lo = clamp(ivec2(corner), ivec2(0), last);
+    ivec2 hi = clamp(ivec2(corner) + 1, ivec2(0), last);
+    vec3 irradiance = mix(
+      mix(bakedIrradianceAt(ivec3(lo.x, lo.y, 0)), bakedIrradianceAt(ivec3(hi.x, lo.y, 0)), f.x),
+      mix(bakedIrradianceAt(ivec3(lo.x, hi.y, 0)), bakedIrradianceAt(ivec3(hi.x, hi.y, 0)), f.x),
+      f.y
+    );
+    vec4 direction = mix(
+      mix(texelFetch(uModelMap, ivec3(lo.x, lo.y, 1), 0), texelFetch(uModelMap, ivec3(hi.x, lo.y, 1), 0), f.x),
+      mix(texelFetch(uModelMap, ivec3(lo.x, hi.y, 1), 0), texelFetch(uModelMap, ivec3(hi.x, hi.y, 1), 0), f.x),
+      f.y
+    );
+    vec4 d = direction * 2.0 - 1.0;
+    return albedo * (1.0 - metal) * irradiance * max(dot(d.xyz, n) + d.w, 0.0);
+  }
+  return vec3(0.0);
+}
+
 /** Skin's diffuse as the diffuse pass writes it, from the lit total before emission, fogged. */
 vec3 modelDiffuseOut(vec3 diffuse, float fog) {
   return diffuse * (1.0 - fog);
@@ -242,26 +364,48 @@ float modelReflectance(float standard) {
   return standard;
 }
 `;
-/** The models' whole chunk, at depth zero before `main`: see `flatFrag`. */
-export const MODELS_GLSL = [
-    MODELS_HEAD,
-    ANISOTROPIC_GLSL,
-    HAIR_GLSL,
-    SKIN_GLSL,
-    EYE_GLSL,
-    MODELS_DISPATCH,
-].join('\n');
+/**
+ * The models' whole chunk, at depth zero before `main`: see `flatFrag`. `physicalSpecular` is the
+ * \`PHYSICAL_SPECULAR\` lit switch's value, written in as \`litSwitchesGlsl\` writes the others.
+ */
+export function modelsGlsl(physicalSpecular) {
+    return [
+        MODELS_HEAD.replace('PHYSICAL_SPECULAR_ON', physicalSpecular ? 'true' : 'false'),
+        ANISOTROPIC_GLSL,
+        HAIR_GLSL,
+        SKIN_GLSL,
+        EYE_GLSL,
+        MODELS_DISPATCH,
+    ].join('\n');
+}
+/** The constant each half of a skin turns on. See `SkinHalf`. */
+export const SKIN_HALF_SWITCH = {
+    scene: 'SKIN_SCREEN',
+    diffuse: 'SKIN_DIFFUSE',
+    albedo: 'SKIN_ALBEDO',
+};
 /** A skin lit stage with one half's switch on, WebGL2's way: see `SkinHalf`. */
 export function skinHalfBound(source, half) {
     if (half === 'whole')
         return source;
-    const name = half === 'scene' ? 'SKIN_SCREEN' : 'SKIN_DIFFUSE';
+    const name = SKIN_HALF_SWITCH[half];
     const off = `const bool ${name} = false;`;
     if (!source.includes(off)) {
         throw new Error(`skinHalfBound: this lit stage declares no ${name} constant`);
     }
     return source.replace(off, `const bool ${name} = true;`);
 }
+/**
+ * An instanced vertex stage whose tint lane is a lightmap region: the same source, the constant
+ * flipped — WebGL2's way. Only the instanced stage declares it.
+ */
+export function lightmapRegionsBound(source) {
+    const off = 'const bool LIGHTMAP_REGIONS = false;';
+    if (!source.includes(off)) {
+        throw new Error('lightmapRegionsBound: this vertex stage declares no LIGHTMAP_REGIONS constant');
+    }
+    return source.replace(off, 'const bool LIGHTMAP_REGIONS = true;');
+}
 /** A lit stage with one model's switch on: the same source, the constant flipped — WebGL2's way. */
 export function modelBound(source, kind) {
     const name = SURFACE_MODEL_SWITCH[kind];

package/dist/render/shaders/flat/normalMap.d.ts

@@ -0,0 +1,10 @@
+/**
+ * The material's normal map applied to a surface normal. **The one statement of it**, read by the
+ * lit block for every light and by an unlit refracting draw for the direction it bends, so a lit
+ * pane and an unlit distortion bend by one tilt rather than two transcriptions of it.
+ *
+ * Depth zero, after the tangent frame it calls; see `flatFrag`. **Only ever called under a branch
+ * on a uniform** — `uNormalStrength` and whatever gates its caller — which is what makes the
+ * derivatives inside `tangentFrame` and the implicit level of the read legal: AGENTS.md 2026-08-07.
+ */
+export declare const NORMAL_MAP_GLSL = "\nvec3 normalMapped(vec3 n, vec3 at) {\n  vec3 mapped = texture(uNormalMap, at).xyz * 2.0 - 1.0;\n  /*\n   * z rebuilt where none is stored. A tangent-space normal points out of its surface, so a\n   * stored z at or below zero is never a real one: it is a two-channel map, BC5, whose blue a\n   * device samples as zero and which arrives here as -1. Every map baked from BC5 to PNG before\n   * 4.8.4 carried the same zero. A select rather than a flag: no uniform to bind, no material\n   * that has to say what format it holds, and continuous at the boundary, since a unit texel\n   * lying flat has its z near zero either way. A texel with z above zero is left as it was.\n   */\n  mapped.z = mapped.z > 0.0 ? mapped.z : sqrt(max(0.0, 1.0 - dot(mapped.xy, mapped.xy)));\n  mat3 tbn = tangentFrame(n, vWorldPos, vUv.xy, vTangent, vHasTangents);\n  return normalize(mix(n, normalize(tbn * mapped), uNormalStrength));\n}\n";

package/dist/render/shaders/flat/normalMap.js

@@ -0,0 +1,25 @@
+/**
+ * The material's normal map applied to a surface normal. **The one statement of it**, read by the
+ * lit block for every light and by an unlit refracting draw for the direction it bends, so a lit
+ * pane and an unlit distortion bend by one tilt rather than two transcriptions of it.
+ *
+ * Depth zero, after the tangent frame it calls; see `flatFrag`. **Only ever called under a branch
+ * on a uniform** — `uNormalStrength` and whatever gates its caller — which is what makes the
+ * derivatives inside `tangentFrame` and the implicit level of the read legal: AGENTS.md 2026-08-07.
+ */
+export const NORMAL_MAP_GLSL = /* glsl */ `
+vec3 normalMapped(vec3 n, vec3 at) {
+  vec3 mapped = texture(uNormalMap, at).xyz * 2.0 - 1.0;
+  /*
+   * z rebuilt where none is stored. A tangent-space normal points out of its surface, so a
+   * stored z at or below zero is never a real one: it is a two-channel map, BC5, whose blue a
+   * device samples as zero and which arrives here as -1. Every map baked from BC5 to PNG before
+   * 4.8.4 carried the same zero. A select rather than a flag: no uniform to bind, no material
+   * that has to say what format it holds, and continuous at the boundary, since a unit texel
+   * lying flat has its z near zero either way. A texel with z above zero is left as it was.
+   */
+  mapped.z = mapped.z > 0.0 ? mapped.z : sqrt(max(0.0, 1.0 - dot(mapped.xy, mapped.xy)));
+  mat3 tbn = tangentFrame(n, vWorldPos, vUv.xy, vTangent, vHasTangents);
+  return normalize(mix(n, normalize(tbn * mapped), uNormalStrength));
+}
+`;

package/dist/render/shaders/flat/preamble.js

@@ -156,10 +156,38 @@ uniform ivec4 uMaterialFlags;
  *
  * **Four numbers in one row**: x is the cutoff, y how this frame resolves the edge (0 the hard test,
  * 1 a dither the temporal resolve averages, 2 alpha-to-coverage; see \`cutoutDither.ts\`), z the
- * frame the dither's pattern is offset by, w spare. One vector rather than a float and two more,
- * because every loose scalar is a row of WebGL2's 224 that the light budget gives up.
+ * frame the dither's pattern is offset by, w the material's lighting channels — a mask a light
+ * shades it only where its own shares a bit with (\`SurfaceMaterial.lightChannels\`, 1 unless a
+ * material names others). One vector rather than a float and three more, because every loose
+ * scalar is a row of WebGL2's 224 that the light budget gives up.
  */
 uniform vec4 uCutout;
+/**
+ * A draw's own ambient, as nine spherical-harmonic coefficients of incoming radiance, red green blue
+ * in turn, twenty-seven floats, and in the last of the twenty-eight a 1 where they are on — 0 is the
+ * frame's own ambient, the sky's gradient or the probes'. \`ambientHarmonics.ts\` is the arithmetic
+ * and the basis, and its tests hold this to it. Seven rows of the material block, which is per draw
+ * as far as anything here is: \`setAmbientSH\` moves it between two draws as \`setMaterial\` does.
+ */
+uniform vec4 uAmbientSH[7];
+
+/** The ambient a surface facing \`n\` receives from \`uAmbientSH\`: \`ambientFromSH\`'s arithmetic. */
+vec3 ambientHarmonics(vec3 n) {
+  vec3 c0 = uAmbientSH[0].xyz;
+  vec3 c1 = vec3(uAmbientSH[0].w, uAmbientSH[1].xy);
+  vec3 c2 = vec3(uAmbientSH[1].zw, uAmbientSH[2].x);
+  vec3 c3 = uAmbientSH[2].yzw;
+  vec3 c4 = uAmbientSH[3].xyz;
+  vec3 c5 = vec3(uAmbientSH[3].w, uAmbientSH[4].xy);
+  vec3 c6 = vec3(uAmbientSH[4].zw, uAmbientSH[5].x);
+  vec3 c7 = uAmbientSH[5].yzw;
+  vec3 c8 = uAmbientSH[6].xyz;
+  /* The bands over pi after the cosine convolution: 1, 2/3 and 1/4. */
+  vec3 band1 = (0.488603 * 2.0 / 3.0) * (c1 * n.y + c2 * n.z + c3 * n.x);
+  vec3 band2 = 0.25 * (1.092548 * (c4 * n.x * n.y + c5 * n.y * n.z + c7 * n.x * n.z)
+    + 0.315392 * c6 * (3.0 * n.z * n.z - 1.0) + 0.546274 * c8 * (n.x * n.x - n.y * n.y));
+  return max(0.282095 * c0 + band1 + band2, vec3(0.0));
+}
 /**
  * The albedo array's per-layer effects table: six texels a layer, read with \`texelFetch\` at the
  * layer a vertex carries. A 1×1 stand-in where the array has none, which the size test below reads
@@ -220,8 +248,12 @@ uniform vec3 uOrmScale;
  *
  * A uniform rather than a permutation flag, following the ORM map's in \`uMaterialFlags\`: a fifth boolean doubles the
  * generated WGSL every consumer bundles as source, and this is a few multiply-adds.
+ *
+ * **x of \`uEnvironmentDials\`**, beside the two below: one row where three floats were three
+ * (\`uniformVectorBudget.ts\`). y is how much of the environment the material mirrors, z how
+ * bright what it mirrors is.
  */
-uniform float uEnvironmentPrefiltered;
+uniform vec3 uEnvironmentDials;
 
 /**
  * Where a surface glows, and in what colour.
@@ -325,8 +357,12 @@ uniform vec4 uClipPlane;
  * One row for all four, paid for by the flag the clip plane no longer needs.
  */
 uniform vec4 uSurfaceScene;
-uniform float uEmissiveGain;
-uniform float uNightFactor;
+/**
+ * What emission is multiplied by: x the gain (\`setEmissiveGain\`, the environment's own until a
+ * draw moves it), y the night factor emission is gated on. One row where two floats were two
+ * (\`uniformVectorBudget.ts\`).
+ */
+uniform vec2 uEmission;
 #if NIGHT_EMISSIVE
 /**
  * Emission that only shows where the dominant light does not reach. 0 is off and is the default.
@@ -455,10 +491,9 @@ uniform float uGrain;
  * Two numbers rather than one because they are what separates the surfaces this exists for.
  * Asphalt is coarse and deep, orange peel on paint is fine and shallow, cast concrete sits
  * between them, and the geometry carrying them is identical in all three cases. See
- * Renderer.setSurfaceRelief.
+ * Renderer.setSurfaceRelief. x is the strength and y the bumps to a metre, in one row.
  */
-uniform float uRelief;
-uniform float uReliefCycles;
+uniform vec2 uRelief;
 /**
  * How hard the bound surface texture's own luminance turns the shading normal, 0 for not at all.
  *
@@ -491,9 +526,8 @@ uniform float uTextureRelief;
  * how tight the lobe was made, because what makes a car body look wet is mostly the world
  * in it rather than the lights on it.
  *
- * Off by default, so every scene written before it is unchanged.
+ * Off by default, so every scene written before it is unchanged. **y of \`uEnvironmentDials\`.**
  */
-uniform float uReflectivity;
 /**
  * How bright the environment these surfaces reflect is, as a multiplier on it.
  *
@@ -513,9 +547,8 @@ uniform float uReflectivity;
  *
  * Applies to whatever the surface reflects, probe or hemispheric approximation alike, and to the
  * probe's own irradiance where a caller asked for that. **1 is the default and the identity**, so
- * every scene written before this is unchanged.
+ * every scene written before this is unchanged. **z of \`uEnvironmentDials\`.**
  */
-uniform float uEnvironmentGain;
 /**
  * The room itself, as a cubemap baked from one point, and whether one exists.
  *
@@ -615,10 +648,12 @@ uniform float uProbeGridAmbient;
  */
 uniform vec3 uProbeGridSets;
 #endif
-/** A world-space box that lights up regardless of time of day (run finished). */
+/**
+ * A world-space box that lights up regardless of time of day: its corners, and in the far corner's
+ * w the gain — one row where a loose float was another (\`uniformVectorBudget.ts\`).
+ */
 uniform vec3 uHighlightMin;
-uniform vec3 uHighlightMax;
-uniform float uHighlightGain;
+uniform vec4 uHighlightMax;
 
 /*
  * The froxel table, and the numbers needed to find a fragment's place in it.
@@ -736,13 +771,15 @@ uniform float uLightWeight[MAX_LIGHTS];
  */
 uniform vec3 uLightDir[MAX_LIGHTS];
 /**
- * The cosine of each light's inner cone angle, then of its outer.
+ * The cosine of each light's inner cone angle, then of its outer, and in z the light's own falloff
+ * exponent, 0 for the frame's falloff (\`PointLightSource.falloffExponent\`): a \`vec2\` array cost
+ * a whole row a light anyway, so the exponent spends no row of its own.
  *
  * A light with no cone carries -1 and -2, which makes \`smoothstep(outer, inner, dot)\` exactly 1
  * for every direction on the sphere. See \`POINT_LIGHT_COS_OUTER\`: the pair is chosen so a point
  * light collapses to the arithmetic it had rather than to something very close to it.
  */
-uniform vec2 uLightCone[MAX_LIGHTS];
+uniform vec4 uLightCone[MAX_LIGHTS];
 /**
  * Which row of the photometric atlas each light uses, or a negative index for none.
  *
@@ -762,8 +799,13 @@ uniform float uLightIesProfile[MAX_LIGHTS];
  * tangent to a sphere, so any reference built from the aim alone flips somewhere — and the obvious
  * constructions put that flip exactly where these fixtures point, \`cross(worldUp, dir)\` being
  * singular for a light aimed straight down.
+ *
+ * **w is the light's lighting channels**, a mask compared with the material's (\`uCutout.w\`): a
+ * light shades a surface only where the two share a bit. In the lane the axis left, because an
+ * array of its own would be a row a light of a budget with none to spare; the froxel record keeps
+ * it beside the axis too, in the slot that was spare there.
  */
-uniform vec3 uLightIesAxis[MAX_LIGHTS];
+uniform vec4 uLightIesAxis[MAX_LIGHTS];
 /**
  * Which tile of the cookie atlas each light projects, or a negative index for none.
  *
@@ -781,32 +823,29 @@ uniform float uLightCookie[MAX_LIGHTS];
  * single row of ones, the multiplicative identity, because a declared sampler needs a complete
  * texture whether or not the branch reads it and a row of zeros would switch off every light.
  */
-/** Rows of profile in the fixture atlas, below its cookies. At least 1. */
-uniform float uIesAtlasRows;
-/**
- * Horizontal planes each profile occupies, so a row is \`profile * planes + plane\`.
- *
- * **1 for an atlas with nothing asymmetric in it**, which is nearly every atlas, and the whole
- * plane path is branched away on that — see \`photometric\` in \`main.ts\`. One count for the atlas
- * rather than one per profile, because a per-profile count would need a second number in a light's
- * record to divide by, and a light's record is where space is expensive.
- */
-uniform float uIesPlaneCount;
 /**
- * Cookies: one row of square tiles, one tile a fixture's mask.
- *
- * **0 when no consumer has loaded one, and the whole projection is branched away on it** — a
- * \`uniform float\` is provably uniform control flow, so a scene with no cookie performs no
- * arithmetic and no fetch. With none loaded this holds a single white texel, the multiplicative
- * identity, because a declared sampler needs a complete texture whether or not the branch reads it
- * and a black stand-in would switch off every light that reached it.
- */
-uniform float uCookieTiles;
+ * The fixture atlas's shape, three numbers in one row — a row each would be three of a budget that
+ * has none to give (\`uniformVectorBudget.ts\`):
+ *
+ * - **x, rows of profile** below its cookies. At least 1.
+ * - **y, horizontal planes each profile occupies**, so a row is \`profile * planes + plane\`. 1 for
+ *   an atlas with nothing asymmetric in it, which is nearly every atlas, and the whole plane path is
+ *   branched away on that — see \`photometric\` in \`main.ts\`. One count for the atlas rather
+ *   than one per profile, because a per-profile count would need a second number in a light's
+ *   record to divide by, and a light's record is where space is expensive.
+ * - **z, cookie tiles**: one row of square tiles, one a fixture's mask. 0 when no consumer has
+ *   loaded one, and the whole projection is branched away on it — a uniform is provably uniform
+ *   control flow, so a scene with no cookie performs no arithmetic and no fetch. With none loaded
+ *   the atlas holds a single white texel, the multiplicative identity, because a declared sampler
+ *   needs a complete texture whether or not the branch reads it and a black stand-in would switch
+ *   off every light that reached it.
+ */
+uniform vec3 uFixtureShape;
 /**
  * Both tables in one texture: the cookies' row of tiles in the top band, the profiles' rows below.
  * One sampler for the two since 2026-09-30, because the lit stage bound fifteen of the sixteen
  * WebGL2 guarantees; see \`fixtureAtlas.ts\`. The bands are found from \`textureSize\` and
- * \`uIesAtlasRows\`, so the fold cost no uniform.
+ * \`uFixtureShape.x\`, so the fold cost no uniform.
  */
 uniform sampler2D uFixtureAtlas;
 /**
@@ -845,7 +884,12 @@ uniform vec3 uAreaLightColor[MAX_AREA_LIGHTS];
 /** The rectangle's in-plane axes, unit length, and its half extents along each. */
 uniform vec3 uAreaLightRight[MAX_AREA_LIGHTS];
 uniform vec3 uAreaLightUp[MAX_AREA_LIGHTS];
-uniform vec2 uAreaLightSize[MAX_AREA_LIGHTS];
+/*
+ * Each rectangle's half extents, and in zw its barn doors: the cosine of their angle from its normal
+ * and their length, 0 for none (\`areaBarnDoors\`). A \`vec2\` array costs a whole row a rectangle
+ * anyway, so the doors spend no row of their own.
+ */
+uniform vec4 uAreaLightSize[MAX_AREA_LIGHTS];
 /**
  * Whether the rectangle emits from both faces, 1 or 0.
  *

package/dist/render/shaders/flat/skin.js

@@ -17,11 +17,12 @@
  * behind both, still glows. The shadow map's depth at the receiver would separate the two, and the
  * lamp loop reads a visibility rather than a depth.
  *
- * **Under \`skinScattering: 'screen-space'\`** the surface is drawn in two halves: the frame's
- * without its diffuse, and the diffuse alone into the blur's target — Lambert's, with the shadow as
- * it is, because the blur that follows carries light across curvature and shadow edges in the
- * picture and the fit as well would count it twice — keeping the transmission, which the picture
- * cannot see. \`skinBlur.ts\` is the rest.
+ * **Under \`skinScattering: 'screen-space'\`** the surface is drawn in halves: the frame's without
+ * its diffuse; the diffuse's light alone into the blur's target, shaded on a white surface —
+ * Lambert's, with the shadow as it is, because the blur that follows carries light across curvature
+ * and shadow edges in the picture and the fit as well would count it twice — keeping the
+ * transmission, which the picture cannot see; and the colour alone, which the spread light is
+ * multiplied by. \`skinBlur.ts\` is the rest.
  *
  * **The highlight** is two GGX lobes — 0.85 at the material's roughness and 0.15 at 0.6 of it, for
  * the skin's oil — normalised, with Smith's masking and the Fresnel of index 1.4, in lamp units, so

package/dist/render/shaders/generated/bloom.wgsl.d.ts

@@ -1,6 +1,6 @@
 export declare const BLOOM_DOWNSAMPLE_FRAG_WGSL = "struct Uniforms {\n    uTexel: vec2<f32>,\n}\n\n@group(0) @binding(32) \nvar uSource_t: texture_2d<f32>;\n@group(0) @binding(33) \nvar uSource_s: sampler;\n@group(0) @binding(1) \nvar<uniform> unnamed: Uniforms;\nvar<private> vUv_1: vec2<f32>;\nvar<private> fragColor: vec4<f32>;\n\nfn fetch_u0028_vf2_u003b(uv: ptr<function, vec2<f32>>) -> vec3<f32> {\n    let _e27 = (*uv);\n    let _e28 = textureSampleLevel(uSource_t, uSource_s, _e27, 0f);\n    return _e28.xyz;\n}\n\nfn main_1() {\n    var t: vec2<f32>;\n    var a: vec3<f32>;\n    var param: vec2<f32>;\n    var b: vec3<f32>;\n    var param_1: vec2<f32>;\n    var c: vec3<f32>;\n    var param_2: vec2<f32>;\n    var d: vec3<f32>;\n    var param_3: vec2<f32>;\n    var e: vec3<f32>;\n    var param_4: vec2<f32>;\n    var f: vec3<f32>;\n    var param_5: vec2<f32>;\n    var g: vec3<f32>;\n    var param_6: vec2<f32>;\n    var h: vec3<f32>;\n    var param_7: vec2<f32>;\n    var i: vec3<f32>;\n    var param_8: vec2<f32>;\n    var j: vec3<f32>;\n    var param_9: vec2<f32>;\n    var k: vec3<f32>;\n    var param_10: vec2<f32>;\n    var l: vec3<f32>;\n    var param_11: vec2<f32>;\n    var m: vec3<f32>;\n    var param_12: vec2<f32>;\n    var box0_: vec3<f32>;\n    var box1_: vec3<f32>;\n    var box2_: vec3<f32>;\n    var box3_: vec3<f32>;\n    var box4_: vec3<f32>;\n\n    let _e59 = unnamed.uTexel;\n    t = _e59;\n    let _e60 = vUv_1;\n    let _e61 = t;\n    param = (_e60 + (vec2<f32>(-2f, 2f) * _e61));\n    let _e64 = fetch_u0028_vf2_u003b((&param));\n    a = _e64;\n    let _e65 = vUv_1;\n    let _e66 = t;\n    param_1 = (_e65 + (vec2<f32>(0f, 2f) * _e66));\n    let _e69 = fetch_u0028_vf2_u003b((&param_1));\n    b = _e69;\n    let _e70 = vUv_1;\n    let _e71 = t;\n    param_2 = (_e70 + (vec2<f32>(2f, 2f) * _e71));\n    let _e74 = fetch_u0028_vf2_u003b((&param_2));\n    c = _e74;\n    let _e75 = vUv_1;\n    let _e76 = t;\n    param_3 = (_e75 + (vec2<f32>(-2f, 0f) * _e76));\n    let _e79 = fetch_u0028_vf2_u003b((&param_3));\n    d = _e79;\n    let _e80 = vUv_1;\n    param_4 = _e80;\n    let _e81 = fetch_u0028_vf2_u003b((&param_4));\n    e = _e81;\n    let _e82 = vUv_1;\n    let _e83 = t;\n    param_5 = (_e82 + (vec2<f32>(2f, 0f) * _e83));\n    let _e86 = fetch_u0028_vf2_u003b((&param_5));\n    f = _e86;\n    let _e87 = vUv_1;\n    let _e88 = t;\n    param_6 = (_e87 + (vec2<f32>(-2f, -2f) * _e88));\n    let _e91 = fetch_u0028_vf2_u003b((&param_6));\n    g = _e91;\n    let _e92 = vUv_1;\n    let _e93 = t;\n    param_7 = (_e92 + (vec2<f32>(0f, -2f) * _e93));\n    let _e96 = fetch_u0028_vf2_u003b((&param_7));\n    h = _e96;\n    let _e97 = vUv_1;\n    let _e98 = t;\n    param_8 = (_e97 + (vec2<f32>(2f, -2f) * _e98));\n    let _e101 = fetch_u0028_vf2_u003b((&param_8));\n    i = _e101;\n    let _e102 = vUv_1;\n    let _e103 = t;\n    param_9 = (_e102 + (vec2<f32>(-1f, 1f) * _e103));\n    let _e106 = fetch_u0028_vf2_u003b((&param_9));\n    j = _e106;\n    let _e107 = vUv_1;\n    let _e108 = t;\n    param_10 = (_e107 + (vec2<f32>(1f, 1f) * _e108));\n    let _e111 = fetch_u0028_vf2_u003b((&param_10));\n    k = _e111;\n    let _e112 = vUv_1;\n    let _e113 = t;\n    param_11 = (_e112 + (vec2<f32>(-1f, -1f) * _e113));\n    let _e116 = fetch_u0028_vf2_u003b((&param_11));\n    l = _e116;\n    let _e117 = vUv_1;\n    let _e118 = t;\n    param_12 = (_e117 + (vec2<f32>(1f, -1f) * _e118));\n    let _e121 = fetch_u0028_vf2_u003b((&param_12));\n    m = _e121;\n    let _e122 = a;\n    let _e123 = b;\n    let _e125 = d;\n    let _e127 = e;\n    box0_ = ((((_e122 + _e123) + _e125) + _e127) * 0.25f);\n    let _e130 = b;\n    let _e131 = c;\n    let _e133 = e;\n    let _e135 = f;\n    box1_ = ((((_e130 + _e131) + _e133) + _e135) * 0.25f);\n    let _e138 = d;\n    let _e139 = e;\n    let _e141 = g;\n    let _e143 = h;\n    box2_ = ((((_e138 + _e139) + _e141) + _e143) * 0.25f);\n    let _e146 = e;\n    let _e147 = f;\n    let _e149 = h;\n    let _e151 = i;\n    box3_ = ((((_e146 + _e147) + _e149) + _e151) * 0.25f);\n    let _e154 = j;\n    let _e155 = k;\n    let _e157 = l;\n    let _e159 = m;\n    box4_ = ((((_e154 + _e155) + _e157) + _e159) * 0.25f);\n    let _e162 = box4_;\n    let _e164 = box0_;\n    let _e165 = box1_;\n    let _e167 = box2_;\n    let _e169 = box3_;\n    let _e172 = ((_e162 * 0.5f) + ((((_e164 + _e165) + _e167) + _e169) * 0.125f));\n    fragColor = vec4<f32>(_e172.x, _e172.y, _e172.z, 1f);\n    return;\n}\n\n@fragment \nfn main(@location(0) vUv: vec2<f32>) -> @location(0) vec4<f32> {\n    vUv_1 = vUv;\n    main_1();\n    let _e3 = fragColor;\n    return _e3;\n}\n";
-export declare const BLOOM_PREFILTER_FRAG_WGSL = "struct Uniforms {\n    uTexel: vec2<f32>,\n    uThreshold: f32,\n}\n\n@group(0) @binding(32) \nvar uSource_t: texture_2d<f32>;\n@group(0) @binding(33) \nvar uSource_s: sampler;\n@group(0) @binding(1) \nvar<uniform> unnamed: Uniforms;\nvar<private> vUv_1: vec2<f32>;\nvar<private> fragColor: vec4<f32>;\n\nfn brightness_u0028_vf3_u003b(c: ptr<function, vec3<f32>>) -> f32 {\n    let _e35 = (*c)[0u];\n    let _e37 = (*c)[1u];\n    let _e39 = (*c)[2u];\n    return max(_e35, max(_e37, _e39));\n}\n\nfn firefly_u0028_vf3_u003b(c_1: ptr<function, vec3<f32>>) -> f32 {\n    var param: vec3<f32>;\n\n    let _e35 = (*c_1);\n    param = _e35;\n    let _e36 = brightness_u0028_vf3_u003b((&param));\n    return (1f / (1f + _e36));\n}\n\nfn fetch_u0028_vf2_u003b(uv: ptr<function, vec2<f32>>) -> vec3<f32> {\n    var c_2: vec3<f32>;\n    var bright: f32;\n    var param_1: vec3<f32>;\n\n    let _e37 = (*uv);\n    let _e38 = textureSampleLevel(uSource_t, uSource_s, _e37, 0f);\n    c_2 = min(_e38.xyz, vec3<f32>(256f, 256f, 256f));\n    let _e41 = c_2;\n    param_1 = _e41;\n    let _e42 = brightness_u0028_vf3_u003b((&param_1));\n    bright = _e42;\n    let _e43 = c_2;\n    let _e44 = bright;\n    let _e46 = unnamed.uThreshold;\n    let _e49 = bright;\n    return (_e43 * (max((_e44 - _e46), 0f) / max(_e49, 0.0001f)));\n}\n\nfn main_1() {\n    var t: vec2<f32>;\n    var a: vec3<f32>;\n    var param_2: vec2<f32>;\n    var b: vec3<f32>;\n    var param_3: vec2<f32>;\n    var c_3: vec3<f32>;\n    var param_4: vec2<f32>;\n    var d: vec3<f32>;\n    var param_5: vec2<f32>;\n    var e: vec3<f32>;\n    var param_6: vec2<f32>;\n    var f: vec3<f32>;\n    var param_7: vec2<f32>;\n    var g: vec3<f32>;\n    var param_8: vec2<f32>;\n    var h: vec3<f32>;\n    var param_9: vec2<f32>;\n    var i: vec3<f32>;\n    var param_10: vec2<f32>;\n    var j: vec3<f32>;\n    var param_11: vec2<f32>;\n    var k: vec3<f32>;\n    var param_12: vec2<f32>;\n    var l: vec3<f32>;\n    var param_13: vec2<f32>;\n    var m: vec3<f32>;\n    var param_14: vec2<f32>;\n    var box0_: vec3<f32>;\n    var box1_: vec3<f32>;\n    var box2_: vec3<f32>;\n    var box3_: vec3<f32>;\n    var box4_: vec3<f32>;\n    var w0_: f32;\n    var param_15: vec3<f32>;\n    var w1_: f32;\n    var param_16: vec3<f32>;\n    var w2_: f32;\n    var param_17: vec3<f32>;\n    var w3_: f32;\n    var param_18: vec3<f32>;\n    var w4_: f32;\n    var param_19: vec3<f32>;\n    var sum: vec3<f32>;\n\n    let _e77 = unnamed.uTexel;\n    t = _e77;\n    let _e78 = vUv_1;\n    let _e79 = t;\n    param_2 = (_e78 + (vec2<f32>(-2f, 2f) * _e79));\n    let _e82 = fetch_u0028_vf2_u003b((&param_2));\n    a = _e82;\n    let _e83 = vUv_1;\n    let _e84 = t;\n    param_3 = (_e83 + (vec2<f32>(0f, 2f) * _e84));\n    let _e87 = fetch_u0028_vf2_u003b((&param_3));\n    b = _e87;\n    let _e88 = vUv_1;\n    let _e89 = t;\n    param_4 = (_e88 + (vec2<f32>(2f, 2f) * _e89));\n    let _e92 = fetch_u0028_vf2_u003b((&param_4));\n    c_3 = _e92;\n    let _e93 = vUv_1;\n    let _e94 = t;\n    param_5 = (_e93 + (vec2<f32>(-2f, 0f) * _e94));\n    let _e97 = fetch_u0028_vf2_u003b((&param_5));\n    d = _e97;\n    let _e98 = vUv_1;\n    param_6 = _e98;\n    let _e99 = fetch_u0028_vf2_u003b((&param_6));\n    e = _e99;\n    let _e100 = vUv_1;\n    let _e101 = t;\n    param_7 = (_e100 + (vec2<f32>(2f, 0f) * _e101));\n    let _e104 = fetch_u0028_vf2_u003b((&param_7));\n    f = _e104;\n    let _e105 = vUv_1;\n    let _e106 = t;\n    param_8 = (_e105 + (vec2<f32>(-2f, -2f) * _e106));\n    let _e109 = fetch_u0028_vf2_u003b((&param_8));\n    g = _e109;\n    let _e110 = vUv_1;\n    let _e111 = t;\n    param_9 = (_e110 + (vec2<f32>(0f, -2f) * _e111));\n    let _e114 = fetch_u0028_vf2_u003b((&param_9));\n    h = _e114;\n    let _e115 = vUv_1;\n    let _e116 = t;\n    param_10 = (_e115 + (vec2<f32>(2f, -2f) * _e116));\n    let _e119 = fetch_u0028_vf2_u003b((&param_10));\n    i = _e119;\n    let _e120 = vUv_1;\n    let _e121 = t;\n    param_11 = (_e120 + (vec2<f32>(-1f, 1f) * _e121));\n    let _e124 = fetch_u0028_vf2_u003b((&param_11));\n    j = _e124;\n    let _e125 = vUv_1;\n    let _e126 = t;\n    param_12 = (_e125 + (vec2<f32>(1f, 1f) * _e126));\n    let _e129 = fetch_u0028_vf2_u003b((&param_12));\n    k = _e129;\n    let _e130 = vUv_1;\n    let _e131 = t;\n    param_13 = (_e130 + (vec2<f32>(-1f, -1f) * _e131));\n    let _e134 = fetch_u0028_vf2_u003b((&param_13));\n    l = _e134;\n    let _e135 = vUv_1;\n    let _e136 = t;\n    param_14 = (_e135 + (vec2<f32>(1f, -1f) * _e136));\n    let _e139 = fetch_u0028_vf2_u003b((&param_14));\n    m = _e139;\n    let _e140 = a;\n    let _e141 = b;\n    let _e143 = d;\n    let _e145 = e;\n    box0_ = ((((_e140 + _e141) + _e143) + _e145) * 0.25f);\n    let _e148 = b;\n    let _e149 = c_3;\n    let _e151 = e;\n    let _e153 = f;\n    box1_ = ((((_e148 + _e149) + _e151) + _e153) * 0.25f);\n    let _e156 = d;\n    let _e157 = e;\n    let _e159 = g;\n    let _e161 = h;\n    box2_ = ((((_e156 + _e157) + _e159) + _e161) * 0.25f);\n    let _e164 = e;\n    let _e165 = f;\n    let _e167 = h;\n    let _e169 = i;\n    box3_ = ((((_e164 + _e165) + _e167) + _e169) * 0.25f);\n    let _e172 = j;\n    let _e173 = k;\n    let _e175 = l;\n    let _e177 = m;\n    box4_ = ((((_e172 + _e173) + _e175) + _e177) * 0.25f);\n    let _e180 = box0_;\n    param_15 = _e180;\n    let _e181 = firefly_u0028_vf3_u003b((&param_15));\n    w0_ = (_e181 * 0.125f);\n    let _e183 = box1_;\n    param_16 = _e183;\n    let _e184 = firefly_u0028_vf3_u003b((&param_16));\n    w1_ = (_e184 * 0.125f);\n    let _e186 = box2_;\n    param_17 = _e186;\n    let _e187 = firefly_u0028_vf3_u003b((&param_17));\n    w2_ = (_e187 * 0.125f);\n    let _e189 = box3_;\n    param_18 = _e189;\n    let _e190 = firefly_u0028_vf3_u003b((&param_18));\n    w3_ = (_e190 * 0.125f);\n    let _e192 = box4_;\n    param_19 = _e192;\n    let _e193 = firefly_u0028_vf3_u003b((&param_19));\n    w4_ = (_e193 * 0.5f);\n    let _e195 = box0_;\n    let _e196 = w0_;\n    let _e198 = box1_;\n    let _e199 = w1_;\n    let _e202 = box2_;\n    let _e203 = w2_;\n    let _e206 = box3_;\n    let _e207 = w3_;\n    let _e210 = box4_;\n    let _e211 = w4_;\n    sum = (((((_e195 * _e196) + (_e198 * _e199)) + (_e202 * _e203)) + (_e206 * _e207)) + (_e210 * _e211));\n    let _e214 = sum;\n    let _e215 = w0_;\n    let _e216 = w1_;\n    let _e218 = w2_;\n    let _e220 = w3_;\n    let _e222 = w4_;\n    let _e226 = (_e214 / vec3(max(((((_e215 + _e216) + _e218) + _e220) + _e222), 0.0001f)));\n    fragColor = vec4<f32>(_e226.x, _e226.y, _e226.z, 1f);\n    return;\n}\n\n@fragment \nfn main(@location(0) vUv: vec2<f32>) -> @location(0) vec4<f32> {\n    vUv_1 = vUv;\n    main_1();\n    let _e3 = fragColor;\n    return _e3;\n}\n";
-export declare const BLOOM_UPSAMPLE_FRAG_WGSL = "struct Uniforms {\n    uRadius: f32,\n}\n\n@group(0) @binding(1) \nvar<uniform> unnamed: Uniforms;\n@group(0) @binding(32) \nvar uSource_t: texture_2d<f32>;\n@group(0) @binding(33) \nvar uSource_s: sampler;\nvar<private> vUv_1: vec2<f32>;\nvar<private> fragColor: vec4<f32>;\n\nfn main_1() {\n    var r: f32;\n    var a: vec3<f32>;\n    var b: vec3<f32>;\n    var c: vec3<f32>;\n    var d: vec3<f32>;\n    var e: vec3<f32>;\n    var f: vec3<f32>;\n    var g: vec3<f32>;\n    var h: vec3<f32>;\n    var i: vec3<f32>;\n    var sum: vec3<f32>;\n\n    let _e23 = unnamed.uRadius;\n    r = _e23;\n    let _e24 = vUv_1;\n    let _e25 = r;\n    let _e27 = r;\n    let _e30 = textureSampleLevel(uSource_t, uSource_s, (_e24 + vec2<f32>(-(_e25), _e27)), 0f);\n    a = _e30.xyz;\n    let _e32 = vUv_1;\n    let _e33 = r;\n    let _e36 = textureSampleLevel(uSource_t, uSource_s, (_e32 + vec2<f32>(0f, _e33)), 0f);\n    b = _e36.xyz;\n    let _e38 = vUv_1;\n    let _e39 = r;\n    let _e40 = r;\n    let _e43 = textureSampleLevel(uSource_t, uSource_s, (_e38 + vec2<f32>(_e39, _e40)), 0f);\n    c = _e43.xyz;\n    let _e45 = vUv_1;\n    let _e46 = r;\n    let _e50 = textureSampleLevel(uSource_t, uSource_s, (_e45 + vec2<f32>(-(_e46), 0f)), 0f);\n    d = _e50.xyz;\n    let _e52 = vUv_1;\n    let _e53 = textureSampleLevel(uSource_t, uSource_s, _e52, 0f);\n    e = _e53.xyz;\n    let _e55 = vUv_1;\n    let _e56 = r;\n    let _e59 = textureSampleLevel(uSource_t, uSource_s, (_e55 + vec2<f32>(_e56, 0f)), 0f);\n    f = _e59.xyz;\n    let _e61 = vUv_1;\n    let _e62 = r;\n    let _e64 = r;\n    let _e68 = textureSampleLevel(uSource_t, uSource_s, (_e61 + vec2<f32>(-(_e62), -(_e64))), 0f);\n    g = _e68.xyz;\n    let _e70 = vUv_1;\n    let _e71 = r;\n    let _e75 = textureSampleLevel(uSource_t, uSource_s, (_e70 + vec2<f32>(0f, -(_e71))), 0f);\n    h = _e75.xyz;\n    let _e77 = vUv_1;\n    let _e78 = r;\n    let _e79 = r;\n    let _e83 = textureSampleLevel(uSource_t, uSource_s, (_e77 + vec2<f32>(_e78, -(_e79))), 0f);\n    i = _e83.xyz;\n    let _e85 = e;\n    let _e87 = b;\n    let _e88 = d;\n    let _e90 = f;\n    let _e92 = h;\n    let _e96 = a;\n    let _e97 = c;\n    let _e99 = g;\n    let _e101 = i;\n    sum = (((_e85 * 4f) + ((((_e87 + _e88) + _e90) + _e92) * 2f)) + (((_e96 + _e97) + _e99) + _e101));\n    let _e104 = sum;\n    let _e105 = (_e104 * 0.0625f);\n    fragColor = vec4<f32>(_e105.x, _e105.y, _e105.z, 1f);\n    return;\n}\n\n@fragment \nfn main(@location(0) vUv: vec2<f32>) -> @location(0) vec4<f32> {\n    vUv_1 = vUv;\n    main_1();\n    let _e3 = fragColor;\n    return _e3;\n}\n";
+export declare const BLOOM_PREFILTER_FRAG_WGSL = "struct Uniforms {\n    uTexel: vec2<f32>,\n    uThreshold: f32,\n    uRamp: f32,\n}\n\n@group(0) @binding(32) \nvar uSource_t: texture_2d<f32>;\n@group(0) @binding(33) \nvar uSource_s: sampler;\n@group(0) @binding(1) \nvar<uniform> unnamed: Uniforms;\nvar<private> vUv_1: vec2<f32>;\nvar<private> fragColor: vec4<f32>;\n\nfn brightness_u0028_vf3_u003b(c: ptr<function, vec3<f32>>) -> f32 {\n    let _e36 = (*c)[0u];\n    let _e38 = (*c)[1u];\n    let _e40 = (*c)[2u];\n    return max(_e36, max(_e38, _e40));\n}\n\nfn firefly_u0028_vf3_u003b(c_1: ptr<function, vec3<f32>>) -> f32 {\n    var param: vec3<f32>;\n\n    let _e36 = (*c_1);\n    param = _e36;\n    let _e37 = brightness_u0028_vf3_u003b((&param));\n    return (1f / (1f + _e37));\n}\n\nfn fetch_u0028_vf2_u003b(uv: ptr<function, vec2<f32>>) -> vec3<f32> {\n    var c_2: vec3<f32>;\n    var bright: f32;\n    var param_1: vec3<f32>;\n\n    let _e38 = (*uv);\n    let _e39 = textureSampleLevel(uSource_t, uSource_s, _e38, 0f);\n    c_2 = min(_e39.xyz, vec3<f32>(256f, 256f, 256f));\n    let _e42 = c_2;\n    param_1 = _e42;\n    let _e43 = brightness_u0028_vf3_u003b((&param_1));\n    bright = _e43;\n    let _e45 = unnamed.uRamp;\n    if (_e45 > 0f) {\n        let _e47 = c_2;\n        let _e48 = bright;\n        let _e50 = unnamed.uThreshold;\n        let _e53 = unnamed.uRamp;\n        return (_e47 * clamp(((_e48 - _e50) / _e53), 0f, 1f));\n    }\n    let _e57 = c_2;\n    let _e58 = bright;\n    let _e60 = unnamed.uThreshold;\n    let _e63 = bright;\n    return (_e57 * (max((_e58 - _e60), 0f) / max(_e63, 0.0001f)));\n}\n\nfn main_1() {\n    var t: vec2<f32>;\n    var a: vec3<f32>;\n    var param_2: vec2<f32>;\n    var b: vec3<f32>;\n    var param_3: vec2<f32>;\n    var c_3: vec3<f32>;\n    var param_4: vec2<f32>;\n    var d: vec3<f32>;\n    var param_5: vec2<f32>;\n    var e: vec3<f32>;\n    var param_6: vec2<f32>;\n    var f: vec3<f32>;\n    var param_7: vec2<f32>;\n    var g: vec3<f32>;\n    var param_8: vec2<f32>;\n    var h: vec3<f32>;\n    var param_9: vec2<f32>;\n    var i: vec3<f32>;\n    var param_10: vec2<f32>;\n    var j: vec3<f32>;\n    var param_11: vec2<f32>;\n    var k: vec3<f32>;\n    var param_12: vec2<f32>;\n    var l: vec3<f32>;\n    var param_13: vec2<f32>;\n    var m: vec3<f32>;\n    var param_14: vec2<f32>;\n    var box0_: vec3<f32>;\n    var box1_: vec3<f32>;\n    var box2_: vec3<f32>;\n    var box3_: vec3<f32>;\n    var box4_: vec3<f32>;\n    var w0_: f32;\n    var param_15: vec3<f32>;\n    var w1_: f32;\n    var param_16: vec3<f32>;\n    var w2_: f32;\n    var param_17: vec3<f32>;\n    var w3_: f32;\n    var param_18: vec3<f32>;\n    var w4_: f32;\n    var param_19: vec3<f32>;\n    var sum: vec3<f32>;\n\n    let _e78 = unnamed.uTexel;\n    t = _e78;\n    let _e79 = vUv_1;\n    let _e80 = t;\n    param_2 = (_e79 + (vec2<f32>(-2f, 2f) * _e80));\n    let _e83 = fetch_u0028_vf2_u003b((&param_2));\n    a = _e83;\n    let _e84 = vUv_1;\n    let _e85 = t;\n    param_3 = (_e84 + (vec2<f32>(0f, 2f) * _e85));\n    let _e88 = fetch_u0028_vf2_u003b((&param_3));\n    b = _e88;\n    let _e89 = vUv_1;\n    let _e90 = t;\n    param_4 = (_e89 + (vec2<f32>(2f, 2f) * _e90));\n    let _e93 = fetch_u0028_vf2_u003b((&param_4));\n    c_3 = _e93;\n    let _e94 = vUv_1;\n    let _e95 = t;\n    param_5 = (_e94 + (vec2<f32>(-2f, 0f) * _e95));\n    let _e98 = fetch_u0028_vf2_u003b((&param_5));\n    d = _e98;\n    let _e99 = vUv_1;\n    param_6 = _e99;\n    let _e100 = fetch_u0028_vf2_u003b((&param_6));\n    e = _e100;\n    let _e101 = vUv_1;\n    let _e102 = t;\n    param_7 = (_e101 + (vec2<f32>(2f, 0f) * _e102));\n    let _e105 = fetch_u0028_vf2_u003b((&param_7));\n    f = _e105;\n    let _e106 = vUv_1;\n    let _e107 = t;\n    param_8 = (_e106 + (vec2<f32>(-2f, -2f) * _e107));\n    let _e110 = fetch_u0028_vf2_u003b((&param_8));\n    g = _e110;\n    let _e111 = vUv_1;\n    let _e112 = t;\n    param_9 = (_e111 + (vec2<f32>(0f, -2f) * _e112));\n    let _e115 = fetch_u0028_vf2_u003b((&param_9));\n    h = _e115;\n    let _e116 = vUv_1;\n    let _e117 = t;\n    param_10 = (_e116 + (vec2<f32>(2f, -2f) * _e117));\n    let _e120 = fetch_u0028_vf2_u003b((&param_10));\n    i = _e120;\n    let _e121 = vUv_1;\n    let _e122 = t;\n    param_11 = (_e121 + (vec2<f32>(-1f, 1f) * _e122));\n    let _e125 = fetch_u0028_vf2_u003b((&param_11));\n    j = _e125;\n    let _e126 = vUv_1;\n    let _e127 = t;\n    param_12 = (_e126 + (vec2<f32>(1f, 1f) * _e127));\n    let _e130 = fetch_u0028_vf2_u003b((&param_12));\n    k = _e130;\n    let _e131 = vUv_1;\n    let _e132 = t;\n    param_13 = (_e131 + (vec2<f32>(-1f, -1f) * _e132));\n    let _e135 = fetch_u0028_vf2_u003b((&param_13));\n    l = _e135;\n    let _e136 = vUv_1;\n    let _e137 = t;\n    param_14 = (_e136 + (vec2<f32>(1f, -1f) * _e137));\n    let _e140 = fetch_u0028_vf2_u003b((&param_14));\n    m = _e140;\n    let _e141 = a;\n    let _e142 = b;\n    let _e144 = d;\n    let _e146 = e;\n    box0_ = ((((_e141 + _e142) + _e144) + _e146) * 0.25f);\n    let _e149 = b;\n    let _e150 = c_3;\n    let _e152 = e;\n    let _e154 = f;\n    box1_ = ((((_e149 + _e150) + _e152) + _e154) * 0.25f);\n    let _e157 = d;\n    let _e158 = e;\n    let _e160 = g;\n    let _e162 = h;\n    box2_ = ((((_e157 + _e158) + _e160) + _e162) * 0.25f);\n    let _e165 = e;\n    let _e166 = f;\n    let _e168 = h;\n    let _e170 = i;\n    box3_ = ((((_e165 + _e166) + _e168) + _e170) * 0.25f);\n    let _e173 = j;\n    let _e174 = k;\n    let _e176 = l;\n    let _e178 = m;\n    box4_ = ((((_e173 + _e174) + _e176) + _e178) * 0.25f);\n    let _e181 = box0_;\n    param_15 = _e181;\n    let _e182 = firefly_u0028_vf3_u003b((&param_15));\n    w0_ = (_e182 * 0.125f);\n    let _e184 = box1_;\n    param_16 = _e184;\n    let _e185 = firefly_u0028_vf3_u003b((&param_16));\n    w1_ = (_e185 * 0.125f);\n    let _e187 = box2_;\n    param_17 = _e187;\n    let _e188 = firefly_u0028_vf3_u003b((&param_17));\n    w2_ = (_e188 * 0.125f);\n    let _e190 = box3_;\n    param_18 = _e190;\n    let _e191 = firefly_u0028_vf3_u003b((&param_18));\n    w3_ = (_e191 * 0.125f);\n    let _e193 = box4_;\n    param_19 = _e193;\n    let _e194 = firefly_u0028_vf3_u003b((&param_19));\n    w4_ = (_e194 * 0.5f);\n    let _e196 = box0_;\n    let _e197 = w0_;\n    let _e199 = box1_;\n    let _e200 = w1_;\n    let _e203 = box2_;\n    let _e204 = w2_;\n    let _e207 = box3_;\n    let _e208 = w3_;\n    let _e211 = box4_;\n    let _e212 = w4_;\n    sum = (((((_e196 * _e197) + (_e199 * _e200)) + (_e203 * _e204)) + (_e207 * _e208)) + (_e211 * _e212));\n    let _e215 = sum;\n    let _e216 = w0_;\n    let _e217 = w1_;\n    let _e219 = w2_;\n    let _e221 = w3_;\n    let _e223 = w4_;\n    let _e227 = (_e215 / vec3(max(((((_e216 + _e217) + _e219) + _e221) + _e223), 0.0001f)));\n    fragColor = vec4<f32>(_e227.x, _e227.y, _e227.z, 1f);\n    return;\n}\n\n@fragment \nfn main(@location(0) vUv: vec2<f32>) -> @location(0) vec4<f32> {\n    vUv_1 = vUv;\n    main_1();\n    let _e3 = fragColor;\n    return _e3;\n}\n";
+export declare const BLOOM_UPSAMPLE_FRAG_WGSL = "struct Uniforms {\n    uScale: vec3<f32>,\n    uRadius: f32,\n}\n\n@group(0) @binding(1) \nvar<uniform> unnamed: Uniforms;\n@group(0) @binding(32) \nvar uSource_t: texture_2d<f32>;\n@group(0) @binding(33) \nvar uSource_s: sampler;\nvar<private> vUv_1: vec2<f32>;\nvar<private> fragColor: vec4<f32>;\n\nfn main_1() {\n    var r: f32;\n    var a: vec3<f32>;\n    var b: vec3<f32>;\n    var c: vec3<f32>;\n    var d: vec3<f32>;\n    var e: vec3<f32>;\n    var f: vec3<f32>;\n    var g: vec3<f32>;\n    var h: vec3<f32>;\n    var i: vec3<f32>;\n    var sum: vec3<f32>;\n\n    let _e24 = unnamed.uRadius;\n    r = _e24;\n    let _e25 = vUv_1;\n    let _e26 = r;\n    let _e28 = r;\n    let _e31 = textureSampleLevel(uSource_t, uSource_s, (_e25 + vec2<f32>(-(_e26), _e28)), 0f);\n    a = _e31.xyz;\n    let _e33 = vUv_1;\n    let _e34 = r;\n    let _e37 = textureSampleLevel(uSource_t, uSource_s, (_e33 + vec2<f32>(0f, _e34)), 0f);\n    b = _e37.xyz;\n    let _e39 = vUv_1;\n    let _e40 = r;\n    let _e41 = r;\n    let _e44 = textureSampleLevel(uSource_t, uSource_s, (_e39 + vec2<f32>(_e40, _e41)), 0f);\n    c = _e44.xyz;\n    let _e46 = vUv_1;\n    let _e47 = r;\n    let _e51 = textureSampleLevel(uSource_t, uSource_s, (_e46 + vec2<f32>(-(_e47), 0f)), 0f);\n    d = _e51.xyz;\n    let _e53 = vUv_1;\n    let _e54 = textureSampleLevel(uSource_t, uSource_s, _e53, 0f);\n    e = _e54.xyz;\n    let _e56 = vUv_1;\n    let _e57 = r;\n    let _e60 = textureSampleLevel(uSource_t, uSource_s, (_e56 + vec2<f32>(_e57, 0f)), 0f);\n    f = _e60.xyz;\n    let _e62 = vUv_1;\n    let _e63 = r;\n    let _e65 = r;\n    let _e69 = textureSampleLevel(uSource_t, uSource_s, (_e62 + vec2<f32>(-(_e63), -(_e65))), 0f);\n    g = _e69.xyz;\n    let _e71 = vUv_1;\n    let _e72 = r;\n    let _e76 = textureSampleLevel(uSource_t, uSource_s, (_e71 + vec2<f32>(0f, -(_e72))), 0f);\n    h = _e76.xyz;\n    let _e78 = vUv_1;\n    let _e79 = r;\n    let _e80 = r;\n    let _e84 = textureSampleLevel(uSource_t, uSource_s, (_e78 + vec2<f32>(_e79, -(_e80))), 0f);\n    i = _e84.xyz;\n    let _e86 = e;\n    let _e88 = b;\n    let _e89 = d;\n    let _e91 = f;\n    let _e93 = h;\n    let _e97 = a;\n    let _e98 = c;\n    let _e100 = g;\n    let _e102 = i;\n    sum = (((_e86 * 4f) + ((((_e88 + _e89) + _e91) + _e93) * 2f)) + (((_e97 + _e98) + _e100) + _e102));\n    let _e105 = sum;\n    let _e108 = unnamed.uScale;\n    let _e109 = ((_e105 * 0.0625f) * _e108);\n    fragColor = vec4<f32>(_e109.x, _e109.y, _e109.z, 1f);\n    return;\n}\n\n@fragment \nfn main(@location(0) vUv: vec2<f32>) -> @location(0) vec4<f32> {\n    vUv_1 = vUv;\n    main_1();\n    let _e3 = fragColor;\n    return _e3;\n}\n";
 /**
  * What the transform assigned, so the renderer binds the same numbers.
  *
@@ -39,6 +39,11 @@ export declare const BLOOM_BINDINGS: {
                 readonly size: 4;
                 readonly type: "float";
             };
+            readonly uRamp: {
+                readonly offset: 12;
+                readonly size: 4;
+                readonly type: "float";
+            };
         };
         readonly textures: {
             readonly uSource: {
@@ -52,8 +57,13 @@ export declare const BLOOM_BINDINGS: {
         readonly uniforms: 1;
         readonly uniformSize: 16;
         readonly fields: {
-            readonly uRadius: {
+            readonly uScale: {
                 readonly offset: 0;
+                readonly size: 12;
+                readonly type: "vec3";
+            };
+            readonly uRadius: {
+                readonly offset: 12;
                 readonly size: 4;
                 readonly type: "float";
             };