@driftengine/core 3.62.0 → 4.0.0

package/dist/render/sdfFont.js

@@ -19,9 +19,11 @@ const SUPPORTED_VERSION = 1;
  * beside a reference and they do not match. Every other required field is checked the same way.
  */
 export function parseSdfFont(document) {
+    // platform: feature probe — a bake and a worker both reach here without one
     if (typeof document !== 'object' || document === null) {
         throw new Error('parseSdfFont: expected a metrics object');
     }
+    // platform: feature probe — guarded by the line above
     const source = document;
     if (source['version'] !== SUPPORTED_VERSION) {
         throw new Error(`parseSdfFont: metrics version ${String(source['version'])}, this build reads ${SUPPORTED_VERSION}`);

package/dist/render/segmentQuads.d.ts

@@ -1,4 +1,5 @@
 import type { BoltSegments } from './boltPool.ts';
+import type { LineSegments } from './linePoints.ts';
 /**
  * How a list of segments becomes triangles, held once for every renderer that draws one.
  *
@@ -27,3 +28,15 @@ export declare function buildSegmentQuads(capacity: number): SegmentQuads;
  * capacity — a pool that overruns loses its tail rather than the frame.
  */
 export declare function expandBoltSegments(data: BoltSegments, capacity: number, from: Float32Array, to: Float32Array, arc: Float32Array): number;
+/**
+ * Expand this frame's segments to their four vertices each, into arrays the caller owns.
+ *
+ * Returns how many segments were written, which is the list's count clamped to the batch's
+ * capacity — a caller that overruns loses its tail rather than its frame, the same rule
+ * `expandBoltSegments` follows. Reads only `LineSegments.from`/`.to`.
+ *
+ * **Both backends call it**, which is the reason it is here: the WebGL2 batch wrote the same walk
+ * inline until 2026-09-19, so the number of segments a batch draws — and so whether it draws at
+ * all, and is counted — was one decision written twice.
+ */
+export declare function expandLineSegments(data: LineSegments, capacity: number, from: Float32Array, to: Float32Array): number;

package/dist/render/segmentQuads.js

@@ -73,3 +73,35 @@ export function expandBoltSegments(data, capacity, from, to, arc) {
     }
     return count;
 }
+/**
+ * Expand this frame's segments to their four vertices each, into arrays the caller owns.
+ *
+ * Returns how many segments were written, which is the list's count clamped to the batch's
+ * capacity — a caller that overruns loses its tail rather than its frame, the same rule
+ * `expandBoltSegments` follows. Reads only `LineSegments.from`/`.to`.
+ *
+ * **Both backends call it**, which is the reason it is here: the WebGL2 batch wrote the same walk
+ * inline until 2026-09-19, so the number of segments a batch draws — and so whether it draws at
+ * all, and is counted — was one decision written twice.
+ */
+export function expandLineSegments(data, capacity, from, to) {
+    const count = Math.min(data.count, capacity);
+    for (let s = 0; s < count; s++) {
+        const fx = data.from[s * 3];
+        const fy = data.from[s * 3 + 1];
+        const fz = data.from[s * 3 + 2];
+        const tx = data.to[s * 3];
+        const ty = data.to[s * 3 + 1];
+        const tz = data.to[s * 3 + 2];
+        for (let c = 0; c < 4; c++) {
+            const v = s * 4 + c;
+            from[v * 3] = fx;
+            from[v * 3 + 1] = fy;
+            from[v * 3 + 2] = fz;
+            to[v * 3] = tx;
+            to[v * 3 + 1] = ty;
+            to[v * 3 + 2] = tz;
+        }
+    }
+    return count;
+}

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

@@ -1 +1,28 @@
+/**
+ * How much of a self-lit surface's glow a shadow may take. See the GLSL constant's own comment.
+ *
+ * Exported because the GPU-driven pipeline dims its emission by the same share, and a number two
+ * shaders read is a number that belongs in one place.
+ */
+export declare const EMISSIVE_SHADOW_SHARE = 0.55;
+/**
+ * The narrowest lobe this engine draws, as the distribution's own width.
+ *
+ * **Derived rather than chosen.** These lobes are divided by their own peak, `a2*a2 / (d*d)`, and
+ * the division is guarded at `1e-8` so a mirror cannot divide by nothing. At the peak `d` *is*
+ * `a2`, so the guard starts binding exactly where `a2*a2` reaches `1e-8` — at `a = 0.01` — and
+ * below that it scales the answer instead of protecting it: the peak fell to **0.0039 at roughness
+ * 0.05, 256 times dimmer than at 0.1**, so a polished surface had a fainter highlight than a satin
+ * one. Flooring `a` here keeps the peak at one for every roughness and leaves the guard as the
+ * guard it was meant to be.
+ *
+ * **What it gives up**: a surface smoother than this is drawn at this width rather than narrower.
+ * That is the same trade `sphereLobe` argues below — a reflection narrower than a fragment cannot
+ * be sampled and comes back as speckle — so the floor is where the engine stops pretending to
+ * resolve something it cannot. **What would make it wrong** is a path that integrates the lobe
+ * rather than sampling it at a point, where the narrow tail is carried by the integral;
+ * `prefilter.ts`'s `ggxDistribution` is that path, keeps the honest normalisation, and is
+ * deliberately not this.
+ */
+export declare const MIN_LOBE_ALPHA = 0.01;
 export declare const LOBES_GLSL: string;

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

@@ -1,5 +1,32 @@
 /** How light falls off with distance, and the specular lobes a highlight is made of. */
 import { POINT_SHADOW_FADE_START } from '../../renderQuality.js';
+/**
+ * How much of a self-lit surface's glow a shadow may take. See the GLSL constant's own comment.
+ *
+ * Exported because the GPU-driven pipeline dims its emission by the same share, and a number two
+ * shaders read is a number that belongs in one place.
+ */
+export const EMISSIVE_SHADOW_SHARE = 0.55;
+/**
+ * The narrowest lobe this engine draws, as the distribution's own width.
+ *
+ * **Derived rather than chosen.** These lobes are divided by their own peak, `a2*a2 / (d*d)`, and
+ * the division is guarded at `1e-8` so a mirror cannot divide by nothing. At the peak `d` *is*
+ * `a2`, so the guard starts binding exactly where `a2*a2` reaches `1e-8` — at `a = 0.01` — and
+ * below that it scales the answer instead of protecting it: the peak fell to **0.0039 at roughness
+ * 0.05, 256 times dimmer than at 0.1**, so a polished surface had a fainter highlight than a satin
+ * one. Flooring `a` here keeps the peak at one for every roughness and leaves the guard as the
+ * guard it was meant to be.
+ *
+ * **What it gives up**: a surface smoother than this is drawn at this width rather than narrower.
+ * That is the same trade `sphereLobe` argues below — a reflection narrower than a fragment cannot
+ * be sampled and comes back as speckle — so the floor is where the engine stops pretending to
+ * resolve something it cannot. **What would make it wrong** is a path that integrates the lobe
+ * rather than sampling it at a point, where the narrow tail is carried by the integral;
+ * `prefilter.ts`'s `ggxDistribution` is that path, keeps the honest normalisation, and is
+ * deliberately not this.
+ */
+export const MIN_LOBE_ALPHA = 0.01;
 export const LOBES_GLSL = `float shadowReach(float distance, float maxDistance) {
   return 1.0 - smoothstep(
     maxDistance * ${POINT_SHADOW_FADE_START.toFixed(2)},
@@ -52,7 +79,10 @@ const float MAX_FILTER_RADIUS = 0.25;
  * something passed in front of it, which is worse. Just over half reads as an inlay lit
  * from within a deck that is itself in shade.
  */
-const float EMISSIVE_SHADOW_SHARE = 0.55;
+const float EMISSIVE_SHADOW_SHARE = ${EMISSIVE_SHADOW_SHARE};
+
+/* The narrowest lobe this engine draws. See MIN_LOBE_ALPHA in this module for why it is this. */
+const float MIN_LOBE_ALPHA = ${MIN_LOBE_ALPHA};
 
 /*
  * Trowbridge-Reitz, because the width of a highlight is the whole effect.
@@ -76,7 +106,7 @@ const float EMISSIVE_SHADOW_SHARE = 0.55;
  * is a multiply cheaper than the honest spelling as well.
  */
 float specularLobe(float ndh, float roughness) {
-  float a = max(roughness * roughness, 1e-3);
+  float a = max(roughness * roughness, MIN_LOBE_ALPHA);
   float a2 = a * a;
   float d = ndh * ndh * (a2 - 1.0) + 1.0;
   return (a2 * a2) / max(d * d, 1e-8);
@@ -102,7 +132,7 @@ float specularLobe(float ndh, float roughness) {
  * scene ever does, so r/d is large and its highlight is genuinely broad.
  */
 float sphereLobe(float ndh, float roughness, float sourceRadius, float dist) {
-  float a = max(roughness * roughness, 1e-3);
+  float a = max(roughness * roughness, MIN_LOBE_ALPHA);
   float widened = clamp(a + sourceRadius / max(2.0 * dist, 1e-3), a, 1.0);
   float energy = (a / widened) * (a / widened);
   float w2 = widened * widened;

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

@@ -1,3 +1,10 @@
+/**
+ * How much roughness a relieved or normal-mapped surface gains per unit of relief.
+ *
+ * Exported because the GPU-driven pipeline widens its roughness by a normal map's strength the way
+ * this shader does, and one number read by two shaders is a number that cannot drift between them.
+ */
+export declare const RELIEF_ROUGHNESS = 0.35;
 import type { LightBudget } from '../../uniformVectorBudget.ts';
 /**
  * The preamble, built for one light budget.

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

@@ -1,6 +1,13 @@
 /** Version, inputs, uniforms and the defines the rest of the fragment shader is written against. */
 import { COOKIE_TILE } from '../../lightBudget.js';
 import { CLUSTER_TEXELS, CLUSTER_X, CLUSTER_Y, CLUSTER_Z, LIGHT_REGION_TEXELS, LIGHT_TEXELS, MAX_LIGHTS_PER_CLUSTER, TABLE_WIDTH, } from '../../clusteredLights.js';
+/**
+ * How much roughness a relieved or normal-mapped surface gains per unit of relief.
+ *
+ * Exported because the GPU-driven pipeline widens its roughness by a normal map's strength the way
+ * this shader does, and one number read by two shaders is a number that cannot drift between them.
+ */
+export const RELIEF_ROUGHNESS = 0.35;
 import { MAX_SHADOW_FILTER_TAPS } from '../../renderQuality.js';
 import { FOG_GLSL } from '../fog.js';
 /**
@@ -37,7 +44,7 @@ in float vRoughness;
  * because the amplitude is known here rather than measured off the screen.
  */
 #define RELIEF_TILT 1.6
-#define RELIEF_ROUGHNESS 0.35
+#define RELIEF_ROUGHNESS ${RELIEF_ROUGHNESS}
 /**
  * The furthest a texture-derived bump may turn the shading normal, as a tangent.
  *
@@ -471,6 +478,22 @@ uniform float uEnvironmentMaxLod;
  * under-sampled and forced to a roughness it does not have.
  */
 uniform float uEnvironmentEdge;
+/**
+ * Whether the probe blend consults what each probe can see, and where those moments are.
+ *
+ * **Zero is off, and off is what every published scene is gated at.** On, each probe's visibility
+ * map is a *layer of this same array*, offset past the radiance layers by the grid's probe count:
+ * two moments a texel, the mean distance to geometry along a direction and the mean of its square.
+ *
+ * **In this array rather than a sampler of its own, and branched at run time rather than compiled
+ * in or out.** A sampler of its own would be a seventeenth on a backend that guarantees sixteen
+ * units — the reason \`environmentProbe\` is a permutation at all — and a permutation flag of its
+ * own would double the generated shader corpus for every consumer, which \`scripts/wgsl.ts\` prices
+ * at 400,728 to 597,638 gzipped bytes. Sharing the array costs neither: no new unit, no new
+ * permutation, and the arithmetic sits behind a branch on this uniform the way the clustered light
+ * table's does.
+ */
+uniform float uProbeVisibilityEnabled;
 /**
  * The level holding the cosine convolution, which is the scene's diffuse ambient.
  *

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

@@ -18,4 +18,4 @@
  * reflection's four are two probes at two levels. A grid of one collapses to one and two, because
  * every corner resolves to the same layer and the zero-weight ones are skipped.
  */
-export declare const PROBEGRID_GLSL = "#if ENVIRONMENT_PROBE\n/**\n * Where a direction lands in one layer at one level, inset past that level's gutter.\n *\n * The level's own edge rather than the map's, since a gutter is one texel at every level and its\n * share of the map doubles as the chain coarsens.\n */\nvec3 probeCoord(vec3 dir, float level, float layer) {\n  float levelEdge = max(uEnvironmentEdge / exp2(level), 4.0);\n  return vec3(octInsetUv(dir, levelEdge), layer);\n}\n\n/**\n * A layer index from whole lattice coordinates: x fastest, then y, then z.\n *\n * Clamped, which is what makes an axis one probe wide safe: the second corner of a pair that does\n * not exist resolves to the first, at a weight the caller has already set to zero.\n */\nfloat probeLayer(vec3 index) {\n  vec3 top = max(uProbeGridCounts - 1.0, vec3(0.0));\n  vec3 held = clamp(index, vec3(0.0), top);\n  return held.x + uProbeGridCounts.x * (held.y + uProbeGridCounts.y * held.z);\n}\n\n/**\n * The cell a world position is in, as a base corner and the fraction past it.\n *\n * **Clamped rather than wrapped**, so a point outside the grid takes the nearest probes at full\n * weight \u2014 the environment it would have had one step inside. Wrapping would light one end of a\n * world with the probe from the other end, which is invisible in any test that stays indoors.\n *\n * An axis one probe wide has its fraction forced to zero, so that axis contributes a factor of one\n * to every corner weight and the eight corners collapse onto fewer layers whose weights still sum\n * to one.\n */\nvoid probeCell(vec3 worldPos, out vec3 base, out vec3 frac) {\n  vec3 top = max(uProbeGridCounts - 1.0, vec3(0.0));\n  vec3 local = clamp((worldPos - uProbeGridOrigin) * uProbeGridInvSpacing, vec3(0.0), top);\n  base = min(floor(local), max(top - 1.0, vec3(0.0)));\n  frac = local - base;\n  frac *= step(vec3(1.5), uProbeGridCounts);\n}\n\n/** One probe's diffuse light: the cosine convolution, at its own level, in one fetch. */\nvec3 probeIrradiance(vec3 dir, float layer) {\n  float level = uEnvironmentIrradianceLevel;\n  return textureLod(uEnvironment, probeCoord(dir, level, layer), level).rgb;\n}\n\n/**\n * One probe's reflection at a roughness, as two levels mixed by hand.\n *\n * textureLod rather than texture throughout, per the 2026-08-07 rule and for a second reason on\n * top of it: the level is wanted here, and the fetches sit inside a loop that no compiler can\n * prove uniform.\n */\nvec3 probeRadiance(vec3 dir, float lod, float layer) {\n  float lo = clamp(floor(lod), 0.0, uEnvironmentMaxLod);\n  float hi = min(lo + 1.0, uEnvironmentMaxLod);\n  vec3 coarse = textureLod(uEnvironment, probeCoord(dir, hi, layer), hi).rgb;\n  vec3 fine = textureLod(uEnvironment, probeCoord(dir, lo, layer), lo).rgb;\n  return mix(fine, coarse, clamp(lod - lo, 0.0, 1.0));\n}\n\n/**\n * The grid's diffuse light at a point, trilinear over the eight probes around it.\n *\n * **Eight, because diffuse is the term a grid exists for.** A floor spanning four probes is the\n * case the whole row was costed against, and a hard selection steps visibly across it \u2014 which is\n * exactly where a lit surface has nothing else going on to hide the seam.\n *\n * Zero-weight corners are skipped, so a grid of one does one fetch rather than eight.\n *\n * The cell is recomputed here rather than passed in, because the two terms sit in separate\n * conditional blocks of the lit pass and threading a pair of vectors between them would mean a\n * third. Six arithmetic operations against that.\n */\nvec3 gridIrradiance(vec3 dir, vec3 worldPos) {\n  vec3 base;\n  vec3 frac;\n  probeCell(worldPos, base, frac);\n  vec3 sum = vec3(0.0);\n  for (int c = 0; c < 8; c++) {\n    vec3 corner = vec3(float(c & 1), float((c >> 1) & 1), float((c >> 2) & 1));\n    vec3 axisWeight = mix(1.0 - frac, frac, corner);\n    float weight = axisWeight.x * axisWeight.y * axisWeight.z;\n    if (weight <= 0.0) continue;\n    sum += probeIrradiance(dir, probeLayer(base + corner)) * weight;\n  }\n  return sum;\n}\n\n/**\n * The grid's reflection at a point: two probes along the axis the point is most between.\n *\n * **Two rather than eight, and the axis is chosen rather than fixed.** Sixteen fetches for a\n * reflection is not affordable on the parts this engine targets, and a single probe pops as a\n * smooth surface crosses a cell boundary. Blending along the axis with the largest betweenness\n * removes the pop where it is largest for one extra pair of fetches; the other two axes take their\n * nearest probe, where the switch happens at the point the blend would have been half and half.\n *\n * Full trilinear here is recorded as deferred rather than refused, with its reversal condition: a\n * consumer measuring the remaining seam as their constraint.\n */\nvec3 gridRadiance(vec3 dir, float lod, vec3 worldPos) {\n  vec3 base;\n  vec3 frac;\n  probeCell(worldPos, base, frac);\n  vec3 between = min(frac, 1.0 - frac);\n  vec3 nearest = base + step(vec3(0.5), frac);\n  vec3 low = nearest;\n  vec3 high = nearest;\n  float t = 0.0;\n  if (between.x >= between.y && between.x >= between.z) {\n    low.x = base.x;\n    high.x = base.x + 1.0;\n    t = frac.x;\n  } else if (between.y >= between.z) {\n    low.y = base.y;\n    high.y = base.y + 1.0;\n    t = frac.y;\n  } else {\n    low.z = base.z;\n    high.z = base.z + 1.0;\n    t = frac.z;\n  }\n  vec3 near = probeRadiance(dir, lod, probeLayer(low));\n  if (t <= 0.0) return near;\n  return mix(near, probeRadiance(dir, lod, probeLayer(high)), t);\n}\n#endif";
+export declare const PROBEGRID_GLSL: string;

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

@@ -1,4 +1,9 @@
 /** Reading the probe array: which layers a point sits between, and what each of them holds. */
+import { PROBE_VISIBILITY_CRUSH, PROBE_VISIBILITY_SHARPNESS, PROBE_VISIBILITY_VARIANCE_FLOOR, } from '../../gi/probeVolume.js';
+/** A number as GLSL always reads it as a float, so an integer constant is not an `int`. */
+function glslFloat(value) {
+    return Number.isInteger(value) ? value.toFixed(1) : String(value);
+}
 /**
  * The lit pass's half of the grid, and the two things it has to get right.
  *
@@ -82,6 +87,41 @@ vec3 probeRadiance(vec3 dir, float lod, float layer) {
   return mix(fine, coarse, clamp(lod - lo, 0.0, 1.0));
 }
 
+/** Layers of radiance in the array, which is where the visibility moments start. */
+float probeLayerCount() {
+  return uProbeGridCounts.x * uProbeGridCounts.y * uProbeGridCounts.z;
+}
+
+/**
+ * How much of a probe a point can actually see, from one to zero.
+ *
+ * **The same arithmetic as "probeVisibilityWeight", and the constants are interpolated from it**
+ * rather than written again: one in front of what the probe saw along that direction, and behind it
+ * a Chebyshev bound on the variance of the distances the probe recorded — confident where the
+ * geometry is flat, uncertain where it is not, which is exactly where a hard answer would be wrong.
+ *
+ * The variance floor is not a tolerance. A probe facing a flat wall records the same distance in
+ * every direction of its cone, so the variance is exactly zero and the bound becomes a step: one in
+ * front of the wall and zero behind it, with a hard line between them that crawls every time the
+ * probes are rebaked.
+ *
+ * The moments live in the radiance array, offset past its layers by the grid's probe count, at
+ * level zero. See "uProbeVisibilityEnabled".
+ */
+float probeVisible(vec3 fromProbe, float distanceM, float layer) {
+  vec2 moments = textureLod(
+    uEnvironment,
+    vec3(octInsetUv(fromProbe, uEnvironmentEdge), layer + probeLayerCount()),
+    0.0
+  ).rg;
+  if (distanceM <= moments.x) return 1.0;
+  float variance =
+    max(abs(moments.x * moments.x - moments.y), ${glslFloat(PROBE_VISIBILITY_VARIANCE_FLOOR)});
+  float beyond = distanceM - moments.x;
+  float chebyshev = variance / (variance + beyond * beyond);
+  return pow(chebyshev, ${glslFloat(PROBE_VISIBILITY_SHARPNESS)});
+}
+
 /**
  * The grid's diffuse light at a point, trilinear over the eight probes around it.
  *
@@ -100,14 +140,43 @@ vec3 gridIrradiance(vec3 dir, vec3 worldPos) {
   vec3 frac;
   probeCell(worldPos, base, frac);
   vec3 sum = vec3(0.0);
+  /*
+   * **The weights are renormalised rather than used as they fall.** Multiplying by visibility takes
+   * energy out of the blend, and a blend that quietly drops a share of its probes darkens every
+   * bounce — the property "visibleProbes" states and the white furnace rests on.
+   *
+   * And a point every probe is blind to still gets an answer: inside a solid, or in a sealed void
+   * with a probe on each side of a wall, every weight crushes to nothing and the nearest probe
+   * takes the lot. This is the last level of the chain and there is nothing behind it.
+   */
+  float total = 0.0;
+  float nearestDistance = 1.0e30;
+  vec3 nearestColour = vec3(0.0);
   for (int c = 0; c < 8; c++) {
     vec3 corner = vec3(float(c & 1), float((c >> 1) & 1), float((c >> 2) & 1));
     vec3 axisWeight = mix(1.0 - frac, frac, corner);
     float weight = axisWeight.x * axisWeight.y * axisWeight.z;
     if (weight <= 0.0) continue;
-    sum += probeIrradiance(dir, probeLayer(base + corner)) * weight;
+    float layer = probeLayer(base + corner);
+    vec3 colour = probeIrradiance(dir, layer);
+    float kept = weight;
+    if (uProbeVisibilityEnabled > 0.5) {
+      vec3 fromProbe = worldPos - (uProbeGridOrigin + (base + corner) / uProbeGridInvSpacing);
+      float distanceM = length(fromProbe);
+      /* A point standing exactly on a probe is seen by it, and has no direction to ask about. */
+      float seen = distanceM > 0.0 ? probeVisible(fromProbe / distanceM, distanceM, layer) : 1.0;
+      kept = weight * seen;
+      kept = kept < ${glslFloat(PROBE_VISIBILITY_CRUSH)} ? 0.0 : kept;
+      if (distanceM < nearestDistance) {
+        nearestDistance = distanceM;
+        nearestColour = colour;
+      }
+    }
+    sum += colour * kept;
+    total += kept;
   }
-  return sum;
+  if (uProbeVisibilityEnabled <= 0.5) return sum;
+  return total > 0.0 ? sum / total : nearestColour;
 }
 
 /**

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

@@ -2337,11 +2337,16 @@ export declare const FLAT_BINDINGS: {
                     readonly size: 4;
                     readonly type: "float";
                 };
-                readonly uEnvironmentIrradianceLevel: {
+                readonly uProbeVisibilityEnabled: {
                     readonly offset: 320;
                     readonly size: 4;
                     readonly type: "float";
                 };
+                readonly uEnvironmentIrradianceLevel: {
+                    readonly offset: 324;
+                    readonly size: 4;
+                    readonly type: "float";
+                };
                 readonly uProbeGridOrigin: {
                     readonly offset: 336;
                     readonly size: 12;
@@ -2818,11 +2823,16 @@ export declare const FLAT_BINDINGS: {
                     readonly size: 4;
                     readonly type: "float";
                 };
-                readonly uEnvironmentIrradianceLevel: {
+                readonly uProbeVisibilityEnabled: {
                     readonly offset: 320;
                     readonly size: 4;
                     readonly type: "float";
                 };
+                readonly uEnvironmentIrradianceLevel: {
+                    readonly offset: 324;
+                    readonly size: 4;
+                    readonly type: "float";
+                };
                 readonly uProbeGridOrigin: {
                     readonly offset: 336;
                     readonly size: 12;
@@ -3461,11 +3471,16 @@ export declare const FLAT_BINDINGS: {
                     readonly size: 4;
                     readonly type: "float";
                 };
-                readonly uEnvironmentIrradianceLevel: {
+                readonly uProbeVisibilityEnabled: {
                     readonly offset: 352;
                     readonly size: 4;
                     readonly type: "float";
                 };
+                readonly uEnvironmentIrradianceLevel: {
+                    readonly offset: 356;
+                    readonly size: 4;
+                    readonly type: "float";
+                };
                 readonly uProbeGridOrigin: {
                     readonly offset: 368;
                     readonly size: 12;
@@ -3990,11 +4005,16 @@ export declare const FLAT_BINDINGS: {
                     readonly size: 4;
                     readonly type: "float";
                 };
-                readonly uEnvironmentIrradianceLevel: {
+                readonly uProbeVisibilityEnabled: {
                     readonly offset: 352;
                     readonly size: 4;
                     readonly type: "float";
                 };
+                readonly uEnvironmentIrradianceLevel: {
+                    readonly offset: 356;
+                    readonly size: 4;
+                    readonly type: "float";
+                };
                 readonly uProbeGridOrigin: {
                     readonly offset: 368;
                     readonly size: 12;
@@ -6750,11 +6770,16 @@ export declare const FLAT_BINDINGS: {
                     readonly size: 4;
                     readonly type: "float";
                 };
-                readonly uEnvironmentIrradianceLevel: {
+                readonly uProbeVisibilityEnabled: {
                     readonly offset: 324;
                     readonly size: 4;
                     readonly type: "float";
                 };
+                readonly uEnvironmentIrradianceLevel: {
+                    readonly offset: 328;
+                    readonly size: 4;
+                    readonly type: "float";
+                };
                 readonly uProbeGridOrigin: {
                     readonly offset: 336;
                     readonly size: 12;
@@ -7236,11 +7261,16 @@ export declare const FLAT_BINDINGS: {
                     readonly size: 4;
                     readonly type: "float";
                 };
-                readonly uEnvironmentIrradianceLevel: {
+                readonly uProbeVisibilityEnabled: {
                     readonly offset: 324;
                     readonly size: 4;
                     readonly type: "float";
                 };
+                readonly uEnvironmentIrradianceLevel: {
+                    readonly offset: 328;
+                    readonly size: 4;
+                    readonly type: "float";
+                };
                 readonly uProbeGridOrigin: {
                     readonly offset: 336;
                     readonly size: 12;
@@ -7884,11 +7914,16 @@ export declare const FLAT_BINDINGS: {
                     readonly size: 4;
                     readonly type: "float";
                 };
-                readonly uEnvironmentIrradianceLevel: {
+                readonly uProbeVisibilityEnabled: {
                     readonly offset: 356;
                     readonly size: 4;
                     readonly type: "float";
                 };
+                readonly uEnvironmentIrradianceLevel: {
+                    readonly offset: 360;
+                    readonly size: 4;
+                    readonly type: "float";
+                };
                 readonly uProbeGridOrigin: {
                     readonly offset: 368;
                     readonly size: 12;
@@ -8418,11 +8453,16 @@ export declare const FLAT_BINDINGS: {
                     readonly size: 4;
                     readonly type: "float";
                 };
-                readonly uEnvironmentIrradianceLevel: {
+                readonly uProbeVisibilityEnabled: {
                     readonly offset: 356;
                     readonly size: 4;
                     readonly type: "float";
                 };
+                readonly uEnvironmentIrradianceLevel: {
+                    readonly offset: 360;
+                    readonly size: 4;
+                    readonly type: "float";
+                };
                 readonly uProbeGridOrigin: {
                     readonly offset: 368;
                     readonly size: 12;