diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index d471d1665..417b4248d 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -195,6 +195,30 @@ jobs:
           sdk: '3.13.0'
       - run: tool/flat_dart_check.sh
 
+  # **The native pair loops at every width this processor has** — x86-64, so
+  # the AVX2 and AVX-512 widths, which `src/pbf_kernels.c` picks at run time
+  # by what the processor says, are real here and on no developer's arm64
+  # machine. Each width is held to the scalar loop, and timed: which width a
+  # processor should take by default is a measurement, and this is where it
+  # can be made. Built with gcc and with clang, which reach the wider widths
+  # through different pragmas. Seconds; no Dart, no Flutter.
+  native-lanes:
+    runs-on: ubuntu-latest
+    timeout-minutes: 10
+    steps:
+      - uses: actions/checkout@v7
+      - run: grep -o -m1 -w -E 'avx512f|avx2|sse2' /proc/cpuinfo | sort -u
+      - name: gcc
+        working-directory: packages/flutter3d_physics
+        run: |
+          gcc -O3 -fno-math-errno -Wall -Werror -Isrc src/pbf_kernels.c test/native/lanes_check.c -lm -o lanes-gcc
+          ./lanes-gcc
+      - name: clang
+        working-directory: packages/flutter3d_physics
+        run: |
+          clang -O3 -fno-math-errno -Wall -Werror -Isrc src/pbf_kernels.c test/native/lanes_check.c -lm -o lanes-clang
+          ./lanes-clang
+
   # **A second engine opens the files this one writes, which nothing here had
   # ever checked.** The design plan's line is "the exported file opens in Godot
   # and Unity", and K2 closed on 2026-09-09 with: headless Godot in CI —
diff --git a/ARCHITECTURE.md b/ARCHITECTURE.md
index 2627251b2..436b2ec71 100644
--- a/ARCHITECTURE.md
+++ b/ARCHITECTURE.md
@@ -2691,7 +2691,7 @@ storage.
 |---|---|
 | Style | `dart format` |
 | Analysis | `flutter analyze` clean across the workspace, no warnings |
-| Unit tests | **11340 tests** across 43 packages and 10 applications |
+| Unit tests | **11377 tests** across 43 packages and 10 applications |
 | Structure rules | 35, `dart run tool/structure.dart`, the first CI step |
 | CI | GitHub Actions over `tool/ci.sh`, on `ubuntu-latest`, with no graphics card |
 
diff --git a/README.md b/README.md
index d468a8dd9..1ed2106c4 100644
--- a/README.md
+++ b/README.md
@@ -158,7 +158,7 @@ Or one package at a time:
 (cd packages/flutter3d_physics && dart test)   # plain Dart, no Flutter needed
 ```
 
-There are 11340 tests across forty-three packages and nine applications. The
+There are 11377 tests across forty-three packages and nine applications. The
 only ones that need a GPU are the Impeller half of the golden set. The other
 half is rendered by the software backend, which is what makes 90 scenes
 checkable in a headless run.
diff --git a/packages/education/chemlab/lib/main.dart b/packages/education/chemlab/lib/main.dart
index d1011d659..ed6b2ed03 100644
--- a/packages/education/chemlab/lib/main.dart
+++ b/packages/education/chemlab/lib/main.dart
@@ -119,6 +119,12 @@ class _BenchScreenState extends State<BenchScreen>
   @override
   void initState() {
     super.initState();
+    // The frame the bench draws, pass by pass, for a tool attached to it
+    // (`ext.flutter3d.render.*`), as the games have it.
+    registerRenderExtensions(
+      () => _ready?.renderer,
+      timeout: const Duration(seconds: 20),
+    );
     _open();
   }
 
@@ -312,7 +318,7 @@ class _Controls extends StatelessWidget {
                 const Text('Tilt'),
                 Expanded(
                   child: Slider(
-                    value: vessel.tilt.clamp(
+                    value: vessel.leanTo.clamp(
                       -bench.maxLean(vessel),
                       bench.maxLean(vessel),
                     ),
diff --git a/packages/education/chemlab/lib/src/bench.dart b/packages/education/chemlab/lib/src/bench.dart
index 504820e26..785b565e9 100644
--- a/packages/education/chemlab/lib/src/bench.dart
+++ b/packages/education/chemlab/lib/src/bench.dart
@@ -10,9 +10,11 @@ import 'package:flutter3d_physics/flutter3d_physics.dart'
         LiquidLayer,
         PlaneObstacle,
         RevolvedVessel,
+        SolidSurface,
         VesselVolumes,
         fallTime,
-        overCircularLip;
+        overCircularLip,
+        circularWeir;
 import 'package:vector_math/vector_math.dart';
 
 import 'glassware.dart';
@@ -60,8 +62,24 @@ final class Vessel {
   /// What its label says; null for glass that wears none.
   final Solution? solution;
 
+  /// What it last held, as concentrations: what filling it again from
+  /// empty fills it with. Null until it has held anything.
+  Map<String, double>? _held;
+
   /// How far it leans, in radians, and about which horizontal axis. State.
   double tilt = 0.0;
+
+  /// How far it is asked to lean, and how fast it is turning towards that:
+  /// [Bench.step] brings [tilt] round to it as a hand would.
+  double leanTo = 0.0;
+  double _turning = 0.0;
+  double _aim = 0.0;
+
+  /// How high the hand holds it out of the row, and how fast that is
+  /// changing.
+  double _raised = 0.0;
+  double _rising = 0.0;
+  double _raiseAim = 0.0;
   Vector3 leanAxis = Vector3(1, 0, 0);
 
   /// How far it is lifted out of the row to lean, from nought, standing in
@@ -256,7 +274,9 @@ final class Bench {
         surfaceCells: 24,
         wallThickness: glassThickness,
       );
-      if (!white) _dyes[vessel.name] = _absorbance(vessel.dye);
+      if (!white) {
+        _dyes[vessel.name] = _measured(vessel) ?? _absorbance(vessel.dye);
+      }
       world.bodies.add(vessel.liquid);
       vessel.shadow =
           MeshNode(
@@ -284,6 +304,16 @@ final class Bench {
               ..receivesTranslucentShadows = false
               ..lightChannels = _vesselChannel,
       );
+      // The glass in the tabletop too: it was left out while it was nearly
+      // invisible, and once it was not, the liquids stood in the mirror
+      // with nothing round them.
+      vessel.mirror.add(
+        _mirrored(
+          vessel.glassNode.mesh,
+          _reflection(albedo: null, colour: Vector3(0.995, 0.999, 0.997)),
+          vessel,
+        ),
+      );
       final foot = vessel.foot;
       if (foot != null) {
         final hexagon = DeviceMesh.upload(
@@ -331,8 +361,12 @@ final class Bench {
             name: 'bench',
           )
           ..setPosition(0, -0.002, 0.06)
-          // A floor casts nothing.
-          ..castsShadow = false
+          // **In the shadow map, though it shades nothing below it.** The
+          // engine's photons, bent through a liquid, land on whatever the
+          // map holds under them; with the tabletop left out they found
+          // nothing, were lost, and every solution threw the same grey
+          // shadow, clear acid as dark as permanganate.
+          ..castsShadow = true
           // Its own channel: the sun reaches every channel, and the fill
           // only the glass.
           ..lightChannels = _benchChannel,
@@ -358,7 +392,20 @@ final class Bench {
   final FluidWorld world = FluidWorld(
     gravity: Vector3(0, -9.81, 0),
     particleSpacing: 0.001,
-    floor: [PlaneObstacle(normal: Vector3(0, 1, 0), offset: 0.0)],
+    // The bench top is lacquered: water beads on it rather than spreading
+    // as it would on glass.
+    floor: [
+      PlaneObstacle(
+        normal: Vector3(0, 1, 0),
+        offset: 0.0,
+        solid: SolidSurface.laminate,
+      ),
+    ],
+    // A lesson, not a replay: what would stop a frame is worked out on
+    // another isolate, and drops run their pair loops natively where that
+    // was built. Neither changes what happens, only when and how fast.
+    background: true,
+    nativeKernels: true,
   );
 
   /// Whether the shadows come from the engine's caustics
@@ -428,10 +475,42 @@ final class Bench {
 
   // --------------------------------------------------------------- colour
 
-  /// Each dye's absorbance per metre at unit concentration: what makes it
-  /// its colour over [fade] of it.
+  /// Each dye's absorbance per metre at unit concentration — the strength
+  /// on its label.
   final Map<String, Vector3> _dyes = {};
 
+  /// Molar absorption coefficients, L·mol⁻¹·cm⁻¹, of what the labelled
+  /// tubes hold, at about 610, 550 and 465 nm, where the eye's red, green
+  /// and blue lie: read off published spectra of the aqueous ions, good to
+  /// a few tens of percent, and enough to tell which solutions light goes
+  /// through and which it does not. Copper(II) absorbs the red end weakly
+  /// (its band peaks near 810 nm), permanganate the green very strongly
+  /// (peaks at 525 and 545 nm), dichromate the blue (450 nm), nickel(II)
+  /// little anywhere (395 and 720 nm), and hydrochloric acid nothing.
+  static const Map<String, (double, double, double)> molarAbsorption = {
+    'HCl': (0.0, 0.0, 0.0),
+    'CuSO4': (4.5, 1.2, 0.2),
+    'KMnO4': (150.0, 2300.0, 450.0),
+    'K2Cr2O7': (0.2, 2.0, 250.0),
+    'NiCl2': (1.1, 0.6, 0.8),
+  };
+
+  /// [vessel]'s absorbance per metre from [molarAbsorption] and the
+  /// strength on its label, A = εcl in base ten: null for glass with no
+  /// label or a solution not in the table.
+  static Vector3? _measured(Vessel vessel) {
+    final solution = vessel.solution;
+    final eps = molarAbsorption[vessel.name];
+    if (solution == null || eps == null) return null;
+    final molar = double.tryParse(solution.note.split(' ').first);
+    if (molar == null) return null;
+    // ln 10 for base e, a hundred centimetres to the metre.
+    final k = math.ln10 * molar * 100.0;
+    return Vector3(eps.$1 * k, eps.$2 * k, eps.$3 * k);
+  }
+
+  /// What makes [colour] the colour of [fade] of a liquid: for the glass
+  /// with no label, whose solution is only a colour.
   static Vector3 _absorbance(Color colour) {
     double mu(double c) => -math.log(c.clamp(1e-3, 1.0)) / fade;
     return Vector3(mu(colour.r), mu(colour.g), mu(colour.b));
@@ -439,9 +518,11 @@ final class Bench {
 
   /// The colour of [layer]: light through [fade] of it, every dye in it
   /// taking its share by Beer and Lambert.
-  Color colourOf(LiquidLayer layer) {
+  Color colourOf(LiquidLayer layer) => _colourOf(layer.concentrations);
+
+  Color _colourOf(Map<String, double> concentrations) {
     final absorb = Vector3.zero();
-    layer.concentrations.forEach((dye, c) {
+    concentrations.forEach((dye, c) {
       final mu = _dyes[dye];
       if (mu != null) absorb.addScaled(mu, c);
     });
@@ -472,27 +553,32 @@ final class Bench {
     final now = vessel.liquid.volume;
     if (target > now) {
       final layers = vessel.liquid.layers;
+      // From empty: what it last held. The clean tube, emptied of what was
+      // poured into it and filled again, came back as plain water, its
+      // label being none.
       vessel.liquid.pour(
         target - now,
-        concentrations: layers.isEmpty
-            ? (vessel.dye.toARGB32() == 0xFFFFFFFF
-                  ? const {}
-                  : {vessel.name: 1.0})
-            : layers.last.concentrations,
+        concentrations: layers.isNotEmpty
+            ? layers.last.concentrations
+            : vessel._held ??
+                  (vessel.dye.toARGB32() == 0xFFFFFFFF
+                      ? const {}
+                      : {vessel.name: 1.0}),
       );
     } else if (target < now) {
+      final layers = vessel.liquid.layers;
+      if (layers.isNotEmpty) vessel._held = layers.last.concentrations;
       vessel.liquid.drain(now - target);
     }
     _redraw(vessel);
     if (!photons && vessel.tilt == 0.0) _repaint(vessel);
   }
 
-  /// The furthest [vessel] may lean either way: a little short of where what
-  /// it holds reaches the lip and would run out on the bench.
-  double maxLean(Vessel vessel) => math.max(
-    0.05,
-    math.min(1.45, _tiltHolding(vessel, vessel.liquid.volume) - 0.08),
-  );
+  /// The furthest [vessel] may lean either way: a half turn, mouth down.
+  /// Past the lean it holds its liquid at, what it holds runs out over the
+  /// lip, onto the bench or into whatever is under it, as it would from a
+  /// glass in a hand; stopped short of that, nothing could be spilled.
+  double maxLean(Vessel vessel) => math.pi;
 
   /// How far [vessel] must be lifted to lean as it does without passing
   /// through the glass standing round it.
@@ -501,14 +587,13 @@ final class Bench {
   /// footprint, its underside there has to clear that vessel's top by a
   /// millimetre. A vessel leaning away from its neighbours is hardly lifted;
   /// one leaning over a row of tubes goes over their mouths.
-  double _clearance(Vessel vessel) {
-    if (vessel.tilt == 0.0) return 0.0;
+  double _clearance(Vessel vessel, [double? at]) {
+    final tilt = at ?? vessel.tilt;
+    if (tilt == 0.0) return 0.0;
     final turn = Matrix3.zero()
-      ..setFrom(
-        Quaternion.axisAngle(vessel.leanAxis, vessel.tilt).asRotationMatrix(),
-      );
+      ..setFrom(Quaternion.axisAngle(vessel.leanAxis, tilt).asRotationMatrix());
     final top = vessel.glass.map((p) => p.y).reduce(math.max);
-    final sideways = math.sin(vessel.tilt).abs();
+    final sideways = math.sin(tilt).abs();
     var lowest = double.infinity;
     for (final p in [...vessel.glass, ...?vessel.foot]) {
       for (var k = 0; k < 24; k++) {
@@ -549,25 +634,94 @@ final class Bench {
   /// the way the camera looks, so it leans in the picture — after lifting
   /// it out of the row ([step] lifts and lowers it). The glass turns at
   /// once; the liquid keeps level and follows late, as liquid does.
+  ///
+  /// **Asked, not set.** [step] turns the glass to [angle] as a hand would,
+  /// smoothly. Set at once, the glass jumped a frame's worth of lean and
+  /// lift, the liquid felt a jolt of several g, its surface turned over, and
+  /// a tube tipped by ten degrees emptied itself in one step.
   void lean(Vessel vessel, double angle, {Vector3? across}) {
     if (busy) return;
     final limit = maxLean(vessel);
-    vessel.tilt = angle.clamp(-limit, limit);
-    if (across != null) {
+    vessel.leanTo = angle.clamp(-limit, limit);
+    if (across != null && vessel.tilt == 0.0) {
       final flat = Vector3(across.x, 0, across.z);
       if (flat.length2 > 1e-9) vessel.leanAxis = flat..normalize();
     }
     // One vessel in the hand: leaning this one puts the last one back.
-    if (vessel.tilt != 0.0) {
+    if (vessel.leanTo != 0.0) {
       for (final other in vessels) {
-        if (identical(other, vessel) || other.tilt == 0.0) continue;
-        other.tilt = 0.0;
-        _place(other);
-        _castBy(other);
+        if (!identical(other, vessel)) other.leanTo = 0.0;
       }
     }
+  }
+
+  /// How quickly a hand brings a glass round to the lean asked of it: the
+  /// lean asked is first eased ([_aimRate]), and the glass turns towards
+  /// the eased aim critically damped ([_handRate]), so it gathers speed
+  /// from nothing and sheds it to nothing, a third of a second or so.
+  /// Turning straight at the lean asked, critically damped alone, it took
+  /// all its angular acceleration in the first instant; a tube asked for
+  /// 0.8 rad felt three metres a second squared at once and threw a third
+  /// of what it held over its lip.
+  static const double _aimRate = 6.0;
+  static const double _handRate = 8.0;
+
+  /// Raises or lowers [vessel] towards [height] for [seconds], eased as a
+  /// turn is; says whether it moved.
+  bool _ease2(Vessel vessel, double height, double seconds) {
+    if (vessel._raised == height &&
+        vessel._raiseAim == height &&
+        vessel._rising == 0.0) {
+      return false;
+    }
+    final pieces = (seconds * 240).ceil().clamp(1, 32);
+    final dt = seconds / pieces;
+    for (var k = 0; k < pieces; k++) {
+      vessel._raiseAim += _aimRate * (height - vessel._raiseAim) * dt;
+      final pull =
+          _handRate * _handRate * (vessel._raiseAim - vessel._raised) -
+          2.0 * _handRate * vessel._rising;
+      vessel._rising += pull * dt;
+      vessel._raised += vessel._rising * dt;
+    }
+    if ((height - vessel._raised).abs() < 1e-6 && vessel._rising.abs() < 1e-5) {
+      vessel
+        .._raised = height
+        .._raiseAim = height
+        .._rising = 0.0;
+    }
+    return true;
+  }
+
+  /// Turns [vessel] towards [Vessel.leanTo] for [seconds]; says whether it
+  /// moved.
+  bool _turn(Vessel vessel, double seconds) {
+    if (vessel.tilt == vessel.leanTo &&
+        vessel._aim == vessel.leanTo &&
+        vessel._turning == 0.0) {
+      return false;
+    }
+    final wasUpright = vessel.tilt == 0.0;
+    final pieces = (seconds * 240).ceil().clamp(1, 32);
+    final dt = seconds / pieces;
+    for (var k = 0; k < pieces; k++) {
+      vessel._aim += _aimRate * (vessel.leanTo - vessel._aim) * dt;
+      final pull =
+          _handRate * _handRate * (vessel._aim - vessel.tilt) -
+          2.0 * _handRate * vessel._turning;
+      vessel._turning += pull * dt;
+      vessel.tilt += vessel._turning * dt;
+    }
+    if ((vessel.leanTo - vessel.tilt).abs() < 1e-5 &&
+        vessel._turning.abs() < 1e-4) {
+      vessel
+        ..tilt = vessel.leanTo
+        .._aim = vessel.leanTo
+        .._turning = 0.0;
+    }
     _place(vessel);
-    _castBy(vessel);
+    if (wasUpright != (vessel.tilt == 0.0)) _castBy(vessel);
+    return true;
   }
 
   /// Puts [vessel]'s glass where its lean and lift say: turned about its
@@ -586,7 +740,7 @@ final class Bench {
         lowest = math.min(lowest, turned.y);
       }
     }
-    final lift = _ease(vessel.lift) * _clearance(vessel);
+    final lift = vessel._raised;
     final y = vessel.at.y - lowest + lift;
     vessel.body
       ..setRotation(turn)
@@ -658,6 +812,9 @@ final class Bench {
         : Vector3(1, 0, 0);
     from
       ..tilt = 0.0
+      ..leanTo = 0.0
+      .._aim = 0.0
+      .._turning = 0.0
       ..lift = 0.0
       ..leanAxis = axis;
     _transfer = _Transfer(
@@ -671,10 +828,17 @@ final class Bench {
   }
 
   /// How long each part of a pour takes: up, over, and back; the pour
-  /// itself is as long as the hand takes, about two seconds.
+  /// itself is as long as the hand takes, about a second.
+  ///
+  /// **Briskly, as a chemist pours half a tube.** Over two seconds the
+  /// stream ran a millimetre across, and a thread that thin parts into
+  /// drops some forty widths down, about five centimetres: the clean tube
+  /// filled by dripping. At four times the flow the stream is twice as
+  /// wide, and since how far a stream falls before it parts grows as its
+  /// width to the power one and a half, it reaches the surface whole.
   static const double _rise = 0.45;
   static const double _over = 1.2;
-  static const double _pourTime = 2.0;
+  static const double _pourTime = 0.8;
   static const double _back = 1.4;
 
   /// The world's up seen from glass leaning [tilt] towards its local +z:
@@ -698,6 +862,46 @@ final class Bench {
     return 0.5 * (lo + hi);
   }
 
+  /// The lean at which [vessel], holding [volume], runs [flow] over its lip:
+  /// where the surface stands over the lip by the head a circular weir
+  /// needs for it. Found by halving, from the lean where it starts to run.
+  static double _tiltPouring(Vessel vessel, double volume, double flow) {
+    final lowest = _tiltHolding(vessel, volume);
+    if (flow <= 0.0) return lowest;
+    final radius = vessel.lip.z;
+    double short(double tilt) {
+      final up = _upAt(tilt);
+      final lip = vessel.shape.lip(up);
+      if (lip == null) return 0.0;
+      // By secants from the lip, which the surface is a little over.
+      final head =
+          vessel.shape.surfaceNear(up, volume, lip.height + 1e-4) - lip.height;
+      // The flow that head passes, straight from the weir, rather than the
+      // head that flow needs, which is a search of its own inside this one.
+      final passes = circularWeir(
+        head: head,
+        radius: radius,
+        tilt: tilt,
+        g: 9.81,
+        steps: 90,
+      ).flow;
+      return flow - passes;
+    }
+
+    var lo = lowest;
+    var hi = math.min(lowest + 0.8, 2.6);
+    if (short(hi) > 0.0) return hi;
+    for (var i = 0; i < 14; i++) {
+      final mid = 0.5 * (lo + hi);
+      if (short(mid) > 0.0) {
+        lo = mid;
+      } else {
+        hi = mid;
+      }
+    }
+    return 0.5 * (lo + hi);
+  }
+
   static double _ease(double t) {
     final x = t.clamp(0.0, 1.0);
     return x * x * (3.0 - 2.0 * x);
@@ -777,18 +981,19 @@ final class Bench {
           most *
           _ease((time - start) / 0.6) *
           math.min(1.0, math.sqrt(remaining / (0.8 * most)));
-      // Ahead of the liquid, not behind it: tipped to where what the glass
-      // holds below its lip is what is in it less the next eighth of a
-      // second's worth, so that much stands over the lip to run. A hand
-      // that answered the flow it saw was always late, and a glass this
-      // small, nearly on its side, empties in the time it takes to notice.
+      // Ahead of the liquid, not behind it: tipped to where the lip runs
+      // what the hand wants, by the same weir the liquid runs by. A hand
+      // that answered the flow it saw was always late; one that tipped to
+      // hold the next eighth of a second's worth less stood the surface a
+      // fraction of a millimetre over the lip of a tube on its side, where
+      // its whole length spreads it, and the clean tube filled drop by drop.
       final target = math.max(
-        _tiltHolding(from, from.liquid.volume - wanted * 0.12),
+        _tiltPouring(from, from.liquid.volume, wanted),
         t.spill,
       );
       t.hand += (target - t.hand).clamp(-2.0 * seconds, 2.0 * seconds);
       tilt = t.hand;
-      if (remaining <= 1e-10 || time - start > 3.0 * _pourTime) {
+      if (remaining <= 1e-10 || time - start > 3.0 * _pourTime + 2.0) {
         t
           ..poured = time
           ..end = tilt;
@@ -833,20 +1038,53 @@ final class Bench {
   /// The streams drawn, one per pouring vessel, and the drops.
   final Map<LiquidBody, MeshNode> _streams = {};
   final Map<String, MeshNode> _drops = {};
+  final Map<String, Color> _dropColours = {};
+
+  /// What is out of the glasses (streams, drops, puddles) hung upside down
+  /// under the tabletop, as each vessel's liquid is in its own mirror: one
+  /// reflection per node, sharing its mesh.
+  late final SceneNode _spiltMirror = () {
+    final made = SceneNode(name: 'spilt reflection')..setScale(1, -1, 1);
+    scene.add(made);
+    return made;
+  }();
+  final Map<MeshNode, MeshNode> _spiltReflections = {};
+
+  /// The puddles on the bench drawn, one node each, reused in order.
+  final List<MeshNode> _puddles = [];
+  final List<Color?> _puddleColours = [];
 
   /// Moves everything on by [seconds], and says whether anything still
   /// moves, so the caller knows to ask for another frame.
   bool step(double seconds) {
     var moving = false;
+    for (final vessel in vessels) {
+      final layers = vessel.liquid.layers;
+      if (layers.isNotEmpty) vessel._held = layers.last.concentrations;
+    }
     for (final vessel in vessels) {
       if (identical(vessel, _transfer?.from)) continue;
-      // Lifted out of the row while it leans, put back when it does not.
-      final wanted = vessel.tilt != 0.0 ? 1.0 : 0.0;
-      if (vessel.lift != wanted) {
-        final change = seconds / 0.6;
-        vessel.lift = wanted > vessel.lift
-            ? math.min(vessel.lift + change, wanted)
-            : math.max(vessel.lift - change, wanted);
+      // **Lifted out of the row before it leans, and put back after.** The
+      // height it must clear its neighbours by is taken for the lean it is
+      // going to as well as the one it has, so the hand rises first; and
+      // the rise is eased as the turn is. Taken for the lean it had, the
+      // height jumped by centimetres the frame the tipping glass first came
+      // over a neighbour, and the jolt threw nearly all it held out.
+      //
+      // **Either way, the same height.** A hand takes a glass up out of the
+      // row whichever way it then tips it: lifted only as far as the side it
+      // leaned to needed, a tube at the end of the row leaning off it was
+      // not lifted at all and lay down on the bench, and leaning one way
+      // and the other looked like two different hands.
+      final need = [
+        vessel.tilt,
+        -vessel.tilt,
+        vessel.leanTo,
+        -vessel.leanTo,
+      ].map((at) => _clearance(vessel, at)).reduce(math.max);
+      final rose = _ease2(vessel, need, seconds);
+      vessel.lift = need > 0.0 ? 1.0 : 0.0;
+      if (_turn(vessel, seconds) | rose) {
         _place(vessel);
         moving = true;
       }
@@ -895,7 +1133,15 @@ final class Bench {
       .._drawnTilt = vessel.tilt
       .._drawnLift = vessel.lift;
     final meshes = vessel.liquid.volume > 0.0
-        ? liquidMeshes(vessel.liquid)
+        ? (() {
+            final m = liquidMeshes(
+              vessel.liquid,
+              segments: 32,
+              rows: 24,
+              rings: 8,
+            );
+            return m;
+          })()
         : const <LiquidLayerMesh>[];
     // As many nodes as layers.
     while (vessel.layers.length > meshes.length) {
@@ -929,7 +1175,13 @@ final class Bench {
       final layer = vessel.layers[i];
       _swap(layer.node, meshes[i].mesh);
       layer.reflection.mesh = layer.node.mesh;
-      if (layer.colour != colour) {
+      // Made again when the colour changes, and when the width across the
+      // glass at the level does: the clean tube's first layer was made with
+      // the first drops, a hair up its round bottom where the glass is
+      // nearly no width, and kept so, the half poured into it showed a
+      // fraction of the colour of the half left behind.
+      final thickness = layer.node.material.extensions?.thickness ?? 0.0;
+      if (layer.colour != colour || (thickness - depth).abs() > 0.02 * depth) {
         layer.node.material = liquid(_rgb(colour), depth: depth);
         layer.reflection.material = _reflection(
           albedo: null,
@@ -974,22 +1226,151 @@ final class Bench {
       node.visible = mesh.triangleCount > 0;
     });
     world.particles.forEach((medium, fluid) {
+      // The colour of what is in them, as a solution's is: the drops off
+      // a pour of copper sulphate are blue, not the near white they were.
+      final colour = _colourOf(fluid.concentrations);
       final node = _drops.putIfAbsent(medium, () {
         final made = MeshNode(
           _upload(particleMesh(const [], 0.0005)),
-          liquid(Vector3(0.9, 0.95, 1.0), depth: 0.001),
+          liquid(_rgb(colour), depth: 2.0 * fluid.spacing),
           name: 'drops',
         )..castsShadow = false;
         scene.add(made);
         return made;
       });
+      if (_dropColours[medium] != colour) {
+        _dropColours[medium] = colour;
+        node.material = liquid(_rgb(colour), depth: 2.0 * fluid.spacing);
+      }
       if (fluid.count > 0) any = true;
-      _swap(node, particleMesh(fluid.positions, 0.5 * fluid.spacing));
+      final drops = _clusters(fluid.positions, fluid.volumes, fluid.spacing);
+      _swap(
+        node,
+        particleMesh(
+          [for (final d in drops) d.centre],
+          0.0,
+          radii: [
+            for (final d in drops)
+              math.pow(3.0 * d.volume / (4.0 * math.pi), 1.0 / 3.0).toDouble(),
+          ],
+        ),
+      );
       node.visible = fluid.count > 0;
     });
+    // What lies on the bench: a cap of each drop or puddle's own radius and
+    // height, the colour of what is in it.
+    final g = world.gravity.length;
+    final lying = [for (final s in world.spills) ...s.puddles];
+    for (var i = 0; i < math.max(lying.length, _puddles.length); i++) {
+      if (i >= lying.length) {
+        _puddles[i].visible = false;
+        continue;
+      }
+      final puddle = lying[i];
+      final colour = _colourOf(puddle.concentrations);
+      if (i >= _puddles.length) {
+        final made = MeshNode(
+          _upload(capMesh(const [], const [], const [])),
+          liquid(_rgb(colour), depth: 0.001),
+          name: 'puddle',
+        )..castsShadow = false;
+        scene.add(made);
+        _puddles.add(made);
+        _puddleColours.add(colour);
+      }
+      final node = _puddles[i];
+      if (_puddleColours[i] != colour) {
+        _puddleColours[i] = colour;
+        node.material = liquid(_rgb(colour), depth: 0.001);
+      }
+      final r = puddle.radius(g);
+      if (r < puddle.restRadius(g)) any = true;
+      _swap(node, capMesh([puddle.centre], [r], [puddle.capHeight(r)]));
+      node.visible = true;
+    }
+    _reflectSpilt();
     return any;
   }
 
+  /// Every stream, drop and puddle node given its reflection, or brought
+  /// up to date with it: the same mesh, shown when it is, the colour of
+  /// its liquid. Left out, a stream poured over the bench stood in the
+  /// mirror nowhere, under glasses whose liquids all did.
+  void _reflectSpilt() {
+    final nodes = [..._streams.values, ..._drops.values, ..._puddles];
+    for (final gone
+        in _spiltReflections.keys.where((n) => !nodes.contains(n)).toList()) {
+      _spiltReflections.remove(gone)!.removeFromParent();
+    }
+    for (final node in nodes) {
+      final c = node.material.baseColor;
+      final colour = Vector3(c.x, c.y, c.z);
+      final reflection = _spiltReflections.putIfAbsent(node, () {
+        final made =
+            MeshNode(
+                node.mesh,
+                _reflection(albedo: null, colour: colour),
+                name: '${node.name} reflection',
+              )
+              ..castsShadow = false
+              ..lightChannels = LightChannels.none;
+        _spiltMirror.add(made);
+        return made;
+      });
+      reflection
+        ..mesh = node.mesh
+        ..visible = node.visible;
+      final was = reflection.material.baseColor;
+      if ((was.x - colour.x * 0.7).abs() > 1e-6 ||
+          (was.y - colour.y * 0.7).abs() > 1e-6 ||
+          (was.z - colour.z * 0.7).abs() > 1e-6) {
+        reflection.material = _reflection(albedo: null, colour: colour);
+      }
+    }
+  }
+
+  /// [positions] gathered into drops: particles nearer each other than
+  /// one and a half spacings are one drop, drawn as one sphere of all their
+  /// liquid. A stream that breaks into drops two and a third of its width
+  /// across was drawn as a scatter of millimetre dots, each a particle.
+  static List<({Vector3 centre, double volume})> _clusters(
+    List<Vector3> positions,
+    List<double> volumes,
+    double spacing,
+  ) {
+    final n = positions.length;
+    final parent = List<int>.generate(n, (i) => i);
+    int root(int i) {
+      var r = i;
+      while (parent[r] != r) {
+        r = parent[r];
+      }
+      return parent[i] = r;
+    }
+
+    final reach2 = 2.25 * spacing * spacing;
+    for (var i = 0; i < n; i++) {
+      for (var j = i + 1; j < n; j++) {
+        if (positions[i].distanceToSquared(positions[j]) < reach2) {
+          parent[root(i)] = root(j);
+        }
+      }
+    }
+    // Each drop's middle is the middle of its liquid, weighed by volume.
+    final sums = <int, ({Vector3 sum, double volume})>{};
+    for (var i = 0; i < n; i++) {
+      final r = root(i);
+      final s = sums[r];
+      final v = volumes[i];
+      sums[r] = s == null
+          ? (sum: positions[i] * v, volume: v)
+          : (sum: s.sum..addScaled(positions[i], v), volume: s.volume + v);
+    }
+    return [
+      for (final s in sums.values) (centre: s.sum / s.volume, volume: s.volume),
+    ];
+  }
+
   // -------------------------------------------------------------- shadows
 
   /// Who casts [vessel]'s shadow: the engine's photons, or this bench's card,
diff --git a/packages/education/chemlab/lib/src/glassware.dart b/packages/education/chemlab/lib/src/glassware.dart
index 257a6f238..3d8db4532 100644
--- a/packages/education/chemlab/lib/src/glassware.dart
+++ b/packages/education/chemlab/lib/src/glassware.dart
@@ -178,9 +178,17 @@ Material glass() => Material(
   // what it does not reflect (see `g_pane` in the engine), so its alpha
   // weighs what it reflects and adds. At 0.22 an empty tube was a ghost; at
   // one, with every reflection whole, the glass read heavier than the
-  // liquids in it. Halfway is what the bench is lit with. The tint is
-  // laboratory glass's faint green-grey.
-  baseColor: Vector4(0.96, 0.985, 0.975, 0.55),
+  // liquids in it. Halfway is what the bench is lit with.
+  //
+  // **The tint is what one surface lets through, so it is nearly white.**
+  // Light crossing a tube meets four surfaces, in and out of each wall, and
+  // a shadow takes this colour at each; at a green-grey 0.96 that made an
+  // empty tube's shadow let through seven tenths of the sun, where a
+  // millimetre of laboratory glass absorbs next to nothing and loses about
+  // four percent to reflection at each surface, which the Fresnel term
+  // already counts: some 0.85 in all, and darker only at its edges, where
+  // the sun meets the glass edge-on.
+  baseColor: Vector4(0.995, 0.999, 0.997, 0.55),
   roughness: 0.03,
   alphaMode: MaterialAlphaMode.blend,
   doubleSided: true,
@@ -252,10 +260,17 @@ Material paper([TextureHandle? label]) =>
 /// is most of a tube. The map is twice the default's edge: at a metre and
 /// 1024 texels a tube's shadow edge stepped by most of a millimetre, which a
 /// close look at a sixteen-millimetre tube shows as stairs.
+///
+/// **The sun has a size**, a quarter of a degree across, and a tube ten
+/// centimetres tall throws a penumbra about a millimetre wide with it,
+/// several texels of the map. Drawn as a point, the edge was a hard line
+/// that the map's texels, stretched along the bench where the shadow falls
+/// long, drew as stairs.
 final RenderSettings benchSettings = RenderSettings(
   sky: labSky,
   shadows: const ShadowSettings(
     translucentCasters: true,
+    directionalLightRadius: ShadowSettings.sunAngularRadius,
     resolution: 2048,
     viewDistance: 0.6,
     normalOffset: 0.002,
@@ -268,6 +283,7 @@ final RenderSettings photonSettings = RenderSettings(
   sky: labSky,
   shadows: const ShadowSettings(
     translucentCasters: true,
+    directionalLightRadius: ShadowSettings.sunAngularRadius,
     caustics: true,
     causticPhotons: 128,
     resolution: 2048,
diff --git a/packages/education/chemlab/test/bench_test.dart b/packages/education/chemlab/test/bench_test.dart
index 0cafa5411..37b63af40 100644
--- a/packages/education/chemlab/test/bench_test.dart
+++ b/packages/education/chemlab/test/bench_test.dart
@@ -209,7 +209,9 @@ void main() {
       bench.step(1 / 60);
       seconds += 1 / 60;
       expect(seconds, lessThan(30));
-      if (from.liquid.volume < before - 1e-12) {
+      // Pouring, not evaporating: a step's pour is a tenth of a millilitre,
+      // what evaporates is let go a nanolitre at a time.
+      if (from.liquid.volume < before - 1e-10) {
         poured = true;
         // While it runs, its lip is over the clean tube's mouth.
         // Its own matrix: it hangs off the root, and the world's is only
@@ -231,7 +233,7 @@ void main() {
     expect(theirs, closeTo(total / 2, total * 0.05));
     expect(bench.world.volume, closeTo(everything, everything * 1e-9));
     // And the clean tube holds the colour poured into it.
-    expect(bench.colour(to), bench.colour(from));
+    _expectSameColour(bench.colour(to), bench.colour(from));
   });
 
   test('two dyes poured together are the colour light through both is', () {
@@ -244,10 +246,25 @@ void main() {
     to.liquid.pour(1e-6, concentrations: {orange.name: 1.0});
     final mixed = bench.colour(to);
     // Half of each: each dye's absorbance at half strength, added.
-    final expected = math.sqrt(blue.dye.r * orange.dye.r);
+    final expected = math.sqrt(bench.colour(blue).r * bench.colour(orange).r);
     expect(mixed.r, closeTo(expected, 0.01));
   });
 
+  test('a solution lets light through as its strength and absorption say', () {
+    // A = εcl: 0.02 mol/L permanganate takes nearly all the green out of
+    // three centimetres, 0.5 mol/L copper sulphate only half of the blue,
+    // and hydrochloric acid nothing. Mutation: colour them by the label's
+    // swatch instead, and every solution is equally see-through.
+    final kit = cpuTestDevice(width: 8, height: 8);
+    final bench = Bench(kit.device);
+    Vessel named(String n) => bench.vessels.firstWhere((v) => v.name == n);
+    expect(bench.colour(named('KMnO4')).g, lessThan(1e-3));
+    expect(bench.colour(named('CuSO4')).b, greaterThan(0.4));
+    expect(bench.colour(named('CuSO4')).r, lessThan(0.05));
+    expect(bench.colour(named('K2Cr2O7')).b, lessThan(1e-3));
+    expect(bench.colour(named('HCl')).r, closeTo(1.0, 1e-9));
+  });
+
   test('a pour drawn at uneven frames still pours half', () {
     // A browser's frames are anything from a 90th to a 30th of a second.
     // Mutation: stamp the glass's place with the liquid's own clock, and
@@ -301,4 +318,111 @@ void main() {
     }
     check(bench.scene.root);
   });
+
+  test('leaning a tube within its limit spills none of it', () {
+    // The hand turns and lifts it smoothly to the lean asked. Mutation: set
+    // the lean at once, or lift it by the height the lean it had needed,
+    // and the jolt turns the surface over: a tube asked for a tenth of a
+    // radian more emptied itself in one step.
+    final kit = cpuTestDevice(width: 8, height: 8);
+    final bench = Bench(kit.device);
+    final tube = bench.vessels[1];
+    final start = tube.liquid.volume;
+    for (final lean in [0.05, 0.1, 0.2, 0.0, 0.8, 1.2, 0.0]) {
+      bench.lean(tube, lean, across: Vector3(0.35, 0, -0.94));
+      for (var i = 0; i < 150; i++) {
+        bench.step(1 / 60);
+      }
+      expect(tube.tilt, closeTo(lean.clamp(0.0, bench.maxLean(tube)), 1e-3));
+    }
+    // None of it ran out: not as a stream, drops or a puddle. Only what
+    // evaporated in the twenty seconds is gone, a few millionths of it.
+    expect(bench.world.jets, isEmpty);
+    expect(bench.world.particles.values.fold(0, (s, p) => s + p.count), 0);
+    expect(bench.world.spills.fold(0.0, (s, p) => s + p.volume), 0.0);
+    expect(tube.liquid.volume, closeTo(start, start * 1e-5));
+  });
+
+  test('a tube leaned either way is lifted out of the row alike', () {
+    // Mutation: lift it only as far as the side it leans to needs, and the
+    // tube at the end of the row, leaning off it, lies down on the bench.
+    final kit = cpuTestDevice(width: 8, height: 8);
+    double height(double lean) {
+      final bench = Bench(kit.device);
+      final tube = bench.vessels.first;
+      bench.lean(tube, lean, across: Vector3(0, 0, -1));
+      for (var i = 0; i < 120; i++) {
+        bench.step(1 / 60);
+      }
+      return tube.body.localMatrix.getTranslation().y;
+    }
+
+    expect(height(-1.0), closeTo(height(1.0), 1e-6));
+    expect(height(-1.0), greaterThan(0.05));
+  });
+
+  test('a tube turned mouth down empties into a puddle on the bench', () {
+    final kit = cpuTestDevice(width: 8, height: 8);
+    final bench = Bench(kit.device);
+    final tube = bench.vessels[2];
+    final everything = bench.world.volume;
+    final held = tube.liquid.volume;
+    bench.lean(tube, bench.maxLean(tube), across: Vector3(0, 0, -1));
+    for (var i = 0; i < 600; i++) {
+      bench.step(1 / 60);
+    }
+    expect(tube.liquid.volume, lessThan(held * 0.02));
+    // Every drop of it is somewhere: in the glasses, in the air, or lying
+    // on the bench, nearly all of it as one puddle.
+    expect(bench.world.volume, closeTo(everything, everything * 1e-9));
+    final lying = bench.world.spills.single;
+    expect(lying.volume, greaterThan(held * 0.9));
+    expect(lying.puddles.first.volume, greaterThan(held * 0.8));
+  });
+
+  test('what is poured into the clean tube is as deep a colour as is left', () {
+    // Mutation: take the depth of the liquid's material at the level, and
+    // the clean tube's, made with the first drops near its round bottom,
+    // is a hair thick: the half poured in shows a fraction of the colour.
+    final kit = cpuTestDevice(width: 8, height: 8);
+    final bench = Bench(kit.device);
+    final from = bench.vessels[1];
+    final to = bench.clean;
+    bench.share(from);
+    while (bench.busy || bench.world.jets.isNotEmpty) {
+      bench.step(1 / 60);
+    }
+    double depth(Vessel v) =>
+        v.layers.single.node.material.extensions!.thickness;
+    expect(depth(to), closeTo(depth(from), 1e-9));
+  });
+
+  test('the clean tube emptied and filled again holds what it held', () {
+    // Mutation: fill it from empty with what its label says, and with none
+    // it comes back as plain water.
+    final kit = cpuTestDevice(width: 8, height: 8);
+    final bench = Bench(kit.device);
+    final from = bench.vessels[1];
+    final to = bench.clean;
+    bench.share(from);
+    while (bench.busy || bench.world.jets.isNotEmpty) {
+      bench.step(1 / 60);
+    }
+    bench
+      ..pour(to, to.lowest)
+      ..step(1 / 60);
+    expect(to.liquid.volume, 0.0);
+    bench
+      ..pour(to, 0.5 * (to.lowest + to.highest))
+      ..step(1 / 60);
+    _expectSameColour(bench.colour(to), bench.colour(from));
+  });
+}
+
+/// [a] and [b] the same colour but for the nanolitres of water each lost to
+/// the air while the test ran, which leave a solution a hair stronger.
+void _expectSameColour(Color a, Color b) {
+  expect(a.r, closeTo(b.r, 1e-3));
+  expect(a.g, closeTo(b.g, 1e-3));
+  expect(a.b, closeTo(b.b, 1e-3));
 }
diff --git a/packages/education/chemlab/test/goldens/bench.png b/packages/education/chemlab/test/goldens/bench.png
index fa03e0669..e7bf3b94b 100644
Binary files a/packages/education/chemlab/test/goldens/bench.png and b/packages/education/chemlab/test/goldens/bench.png differ
diff --git a/packages/flutter3d_core/lib/src/geometry/liquid_shapes.dart b/packages/flutter3d_core/lib/src/geometry/liquid_shapes.dart
index cba50af59..6c5aaeb49 100644
--- a/packages/flutter3d_core/lib/src/geometry/liquid_shapes.dart
+++ b/packages/flutter3d_core/lib/src/geometry/liquid_shapes.dart
@@ -151,6 +151,15 @@ MeshData _layer({
   final bottomCut = <List<Vector3>>[];
   // How far the surface stands off the top plane over a point on it.
   double lift(Vector3 p) => surface ? body.surfaceAt(p) - upper : 0.0;
+  // Lifted along up, a point on a wall that leans is lifted off it: kept a
+  // hair inside the glass instead.
+  Vector3 within(Vector3 p) {
+    final shape = body.shape;
+    if (shape is! RevolvedVessel) return p;
+    final at = shape.wallDistance(p);
+    if (at == null || at.distance < -1e-5) return p;
+    return p - at.normal * (at.distance + 1e-5);
+  }
 
   List<_P> clip(
     List<_P> polygon,
@@ -190,7 +199,7 @@ MeshData _layer({
         // four nanometres out at six centimetres, and a test tighter than
         // that left the wall's edge behind the cap it should meet.
         (up.dot(v.p) - upper).abs() < 1e-6
-            ? (p: v.p + up * lift(v.p), n: v.n)
+            ? (p: within(v.p + up * lift(v.p)), n: v.n)
             : v,
     ];
     final first = builder.addVertex(position: lifted[0].p, normal: lifted[0].n);
@@ -207,7 +216,16 @@ MeshData _layer({
       previous = next;
     }
   }
-  _cap(builder, topCut, up, surface ? lift : null, body, upper, rings);
+  _cap(
+    builder,
+    topCut,
+    up,
+    surface ? lift : null,
+    body,
+    upper,
+    rings,
+    within: within,
+  );
   if (lower.isFinite) {
     _cap(builder, bottomCut, -up, null, body, lower, 1);
   }
@@ -223,14 +241,19 @@ void _cap(
   double Function(Vector3)? lift,
   LiquidBody body,
   double height,
-  int rings,
-) {
+  int rings, {
+  Vector3 Function(Vector3)? within,
+}) {
   if (segments.length < 3) return;
   final loops = _loops(segments);
   final helper = normal.x.abs() < 0.9 ? Vector3(1, 0, 0) : Vector3(0, 0, 1);
   final e1 = normal.cross(helper)..normalize();
   final e2 = normal.cross(e1);
-  Vector3 raise(Vector3 p) => lift == null ? p : p + normal * lift(p);
+  Vector3 raise(Vector3 p) {
+    final up = lift == null ? p : p + normal * lift(p);
+    return within == null ? up : within(up);
+  }
+
   Vector3 shade(Vector3 p) {
     if (lift == null) return normal;
     // The surface's slope, by central differences in the plane.
@@ -471,11 +494,92 @@ MeshData jetMesh(Jet jet, {int sides = 14}) {
   return builder.build();
 }
 
-/// Particles drawn as small icosahedra of [radius] round [positions], in
-/// the world.
-MeshData particleMesh(List<Vector3> positions, double radius) {
+/// Particles drawn as small spheres of [radius] round [positions], in the
+/// world: an icosahedron split once, forty-two points, round enough at the
+/// size of a drop that its outline does not show its faces as the twelve
+/// points of a bare icosahedron did.
+///
+/// [radii], when given, is one radius a sphere, in place of [radius].
+MeshData particleMesh(
+  List<Vector3> positions,
+  double radius, {
+  List<double>? radii,
+}) {
+  final (points, faces) = _sphere;
+  final builder = MeshBuilder(VertexLayout.standard);
+  for (var i = 0; i < positions.length; i++) {
+    final centre = positions[i];
+    final r = radii?[i] ?? radius;
+    final base = builder.vertexCount;
+    for (final v in points) {
+      builder.addVertex(position: centre + v * r, normal: v);
+    }
+    for (final f in faces) {
+      builder.addTriangle(base + f.$1, base + f.$2, base + f.$3);
+    }
+  }
+  return builder.build();
+}
+
+/// Liquid lying on a level surface: for each, a spherical cap of base
+/// [radii] and height [heights] standing on the surface at [centres], up
+/// being +y. What a drop or a puddle on the bench is drawn as: its top as
+/// a cap, its underside, on the surface, left out.
+MeshData capMesh(
+  List<Vector3> centres,
+  List<double> radii,
+  List<double> heights, {
+  int segments = 32,
+  int rings = 6,
+}) {
+  final builder = MeshBuilder(VertexLayout.standard);
+  for (var i = 0; i < centres.length; i++) {
+    final c = centres[i];
+    final r = radii[i];
+    final h = heights[i];
+    if (r <= 0.0 || h <= 0.0) continue;
+    // The sphere the cap is cut from: its radius and how far its middle is
+    // under the surface.
+    final sphere = (r * r + h * h) / (2.0 * h);
+    final below = sphere - h;
+    final rim = math.asin((r / sphere).clamp(0.0, 1.0));
+    final base = builder.vertexCount;
+    for (var k = 0; k <= rings; k++) {
+      // From the top (k = 0) to the rim.
+      final a = rim * k / rings;
+      for (var j = 0; j < segments; j++) {
+        final b = 2.0 * math.pi * j / segments;
+        final n = Vector3(
+          math.sin(a) * math.cos(b),
+          math.cos(a),
+          math.sin(a) * math.sin(b),
+        );
+        builder.addVertex(
+          position: c + Vector3(0, -below, 0) + n * sphere,
+          normal: n,
+        );
+      }
+    }
+    for (var k = 0; k < rings; k++) {
+      for (var j = 0; j < segments; j++) {
+        final a0 = base + k * segments + j;
+        final a1 = base + k * segments + (j + 1) % segments;
+        final b0 = a0 + segments;
+        final b1 = a1 + segments;
+        builder
+          ..addTriangle(a0, a1, b1)
+          ..addTriangle(a0, b1, b0);
+      }
+    }
+  }
+  return builder.build();
+}
+
+/// A unit icosahedron split once: each face into four, the new points
+/// pushed out onto the sphere.
+final (List<Vector3>, List<(int, int, int)>) _sphere = () {
   const t = 1.618033988749895;
-  final ico = [
+  final points = [
     Vector3(-1, t, 0),
     Vector3(1, t, 0),
     Vector3(-1, -t, 0),
@@ -489,37 +593,23 @@ MeshData particleMesh(List<Vector3> positions, double radius) {
     Vector3(-t, 0, -1),
     Vector3(-t, 0, 1),
   ].map((v) => v.normalized()).toList();
-  const faces = <List<int>>[
-    [0, 11, 5],
-    [0, 5, 1],
-    [0, 1, 7],
-    [0, 7, 10],
-    [0, 10, 11],
-    [1, 5, 9],
-    [5, 11, 4],
-    [11, 10, 2],
-    [10, 7, 6],
-    [7, 1, 8],
-    [3, 9, 4],
-    [3, 4, 2],
-    [3, 2, 6],
-    [3, 6, 8],
-    [3, 8, 9],
-    [4, 9, 5],
-    [2, 4, 11],
-    [6, 2, 10],
-    [8, 6, 7],
-    [9, 8, 1],
+  const faces = <(int, int, int)>[
+    (0, 11, 5), (0, 5, 1), (0, 1, 7), (0, 7, 10), (0, 10, 11), //
+    (1, 5, 9), (5, 11, 4), (11, 10, 2), (10, 7, 6), (7, 1, 8), //
+    (3, 9, 4), (3, 4, 2), (3, 2, 6), (3, 6, 8), (3, 8, 9), //
+    (4, 9, 5), (2, 4, 11), (6, 2, 10), (8, 6, 7), (9, 8, 1),
   ];
-  final builder = MeshBuilder(VertexLayout.standard);
-  for (final centre in positions) {
-    final base = builder.vertexCount;
-    for (final v in ico) {
-      builder.addVertex(position: centre + v * radius, normal: v);
-    }
-    for (final f in faces) {
-      builder.addTriangle(base + f[0], base + f[1], base + f[2]);
-    }
-  }
-  return builder.build();
-}
+  final middles = <(int, int), int>{};
+  int middle(int a, int b) => middles.putIfAbsent(a < b ? (a, b) : (b, a), () {
+    points.add((points[a] + points[b])..normalize());
+    return points.length - 1;
+  });
+  final split = [
+    for (final (a, b, c) in faces)
+      ...() {
+        final ab = middle(a, b), bc = middle(b, c), ca = middle(c, a);
+        return [(a, ab, ca), (b, bc, ab), (c, ca, bc), (ab, bc, ca)];
+      }(),
+  ];
+  return (points, split);
+}();
diff --git a/packages/flutter3d_core/test/geometry/liquid_shapes_test.dart b/packages/flutter3d_core/test/geometry/liquid_shapes_test.dart
index dae3dbeff..8acbe462c 100644
--- a/packages/flutter3d_core/test/geometry/liquid_shapes_test.dart
+++ b/packages/flutter3d_core/test/geometry/liquid_shapes_test.dart
@@ -43,12 +43,18 @@ MeshVessel _box(Vector3 size) {
         Vector3(xx, yy, zz),
   ];
   const quads = <List<int>>[
-    [0, 1, 2, 3], [4, 7, 6, 5],
-    [0, 4, 5, 1], [1, 5, 6, 2], [2, 6, 7, 3], [3, 7, 4, 0],
+    [0, 1, 2, 3],
+    [4, 7, 6, 5],
+    [0, 4, 5, 1],
+    [1, 5, 6, 2],
+    [2, 6, 7, 3],
+    [3, 7, 4, 0],
   ];
   return MeshVessel(
     positions: p,
-    indices: [for (final q in quads) ...[q[0], q[1], q[2], q[0], q[2], q[3]]],
+    indices: [
+      for (final q in quads) ...[q[0], q[1], q[2], q[0], q[2], q[3]],
+    ],
     rim: [p[4], p[5], p[6], p[7]],
   );
 }
@@ -79,7 +85,10 @@ void main() {
   test('so does liquid in a vessel that is any mesh', () {
     final box = _box(Vector3(0.04, 0.05, 0.03));
     final body = _body(box, 2e-5, turn: Matrix3.rotationZ(0.4));
-    expect(_enclosed(liquidMeshes(body).single.mesh), closeTo(2e-5, 2e-5 * 0.01));
+    expect(
+      _enclosed(liquidMeshes(body).single.mesh),
+      closeTo(2e-5, 2e-5 * 0.01),
+    );
   });
 
   test('oil on water is two meshes, each its own volume', () {
@@ -110,7 +119,50 @@ void main() {
     }
     expect(jetMesh(jet).triangleCount, greaterThan(0));
     final dots = particleMesh([Vector3.zero(), Vector3(1, 0, 0)], 0.001);
-    expect(dots.vertexCount, 24);
+    // Two spheres of forty-two points.
+    expect(dots.vertexCount, 84);
     expect(_enclosed(dots), greaterThan(0));
   });
+
+  test('a puddle is drawn as a cap of its radius and height', () {
+    final cap = capMesh([Vector3(0.1, 0, 0)], [0.02], [0.001]);
+    final ys = [for (var i = 0; i < cap.vertexCount; i++) cap.positionAt(i).y];
+    // Its top as high as asked, its rim on the bench.
+    expect(ys.reduce(math.max), closeTo(0.001, 1e-7));
+    expect(ys.reduce(math.min), closeTo(0.0, 1e-7));
+    var widest = 0.0;
+    for (var i = 0; i < cap.vertexCount; i++) {
+      final p = cap.positionAt(i);
+      widest = math.max(widest, math.sqrt(math.pow(p.x - 0.1, 2) + p.z * p.z));
+    }
+    expect(widest, closeTo(0.02, 1e-7));
+  });
+
+  test('a tipped tube keeps its liquid inside its glass, meniscus and all', () {
+    // Mutation: lift the surface along up with the meniscus of the radius,
+    // as for a tube standing, and the long sides of a tipped tube's liquid
+    // stand out through the glass.
+    final tube = RevolvedVessel([
+      for (var i = 0; i <= 8; i++)
+        Vector2(
+          0.0075 * math.sin(i / 8 * math.pi / 2),
+          0.0005 + 0.0075 * (1 - math.cos(i / 8 * math.pi / 2)),
+        ),
+      Vector2(0.0075, 0.09),
+    ]);
+    final body = _body(tube, 6e-6, turn: Matrix3.rotationX(1.2));
+    for (final layer in liquidMeshes(body)) {
+      final mesh = layer.mesh;
+      final stride = mesh.layout.floatsPerVertex;
+      for (var i = 0; i < mesh.vertexCount; i++) {
+        final p = Vector3(
+          mesh.vertices[i * stride],
+          mesh.vertices[i * stride + 1],
+          mesh.vertices[i * stride + 2],
+        );
+        final at = tube.wallDistance(p);
+        if (at != null) expect(at.distance, lessThan(2e-5), reason: '$p');
+      }
+    }
+  });
 }
diff --git a/packages/flutter3d_cpu/lib/src/cpu_shaders_shadow_directional.dart b/packages/flutter3d_cpu/lib/src/cpu_shaders_shadow_directional.dart
index 2a3563373..f16d2933b 100644
--- a/packages/flutter3d_cpu/lib/src/cpu_shaders_shadow_directional.dart
+++ b/packages/flutter3d_cpu/lib/src/cpu_shaders_shadow_directional.dart
@@ -182,9 +182,20 @@ double shadowFactor(
 
   // What the see-through casters let through, before the filter, whose soft
   // path leaves early — `ShadowSettings.translucentCasters`; `shadow.glsl`
-  // has the layout.
+  // has the layout. Averaged over the 3×3 texels the opaque edge is, as there.
   if (biases.w > 0.5) {
-    final stored = map.sample(u.clamp(loU, hiU), vv.clamp(loV, hiV));
+    final stored = Vector4.zero();
+    for (var y = -1; y <= 1; y++) {
+      for (var x = -1; x <= 1; x++) {
+        stored.add(
+          map.sample(
+            (u + x * texelU).clamp(loU, hiU),
+            (vv + y * texelV).clamp(loV, hiV),
+          ),
+        );
+      }
+    }
+    stored.scale(1.0 / 9.0);
     final k = strength.clamp(0.0, 1.0);
     double through(double value) => 1.0 + (value.clamp(0.0, 4.0) - 1.0) * k;
     shadowTransmittance.setValues(
diff --git a/packages/flutter3d_cpu/lib/src/cpu_shaders_shadow_passes.dart b/packages/flutter3d_cpu/lib/src/cpu_shaders_shadow_passes.dart
index 5c66a2c54..724e8d88d 100644
--- a/packages/flutter3d_cpu/lib/src/cpu_shaders_shadow_passes.dart
+++ b/packages/flutter3d_cpu/lib/src/cpu_shaders_shadow_passes.dart
@@ -378,6 +378,13 @@ final class CausticPhotonVertexShader implements CpuVertexShaderByIndex {
       final prevY = _follow(b, u, v - texel);
       if (prevY != null) down = at - prevY.$1;
     }
+    // Stretched past sixteen times its own spacing either way, a photon's
+    // light is spread a two-hundred-and-fiftieth as thin as where it set
+    // out, and drawing it is a quad over most of the tile for nothing to
+    // see: as caustic_photon.vert, it is left out.
+    if (across.length > 16.0 * grid.z || down.length > 16.0 * grid.w) {
+      return away;
+    }
     final least = grid.y;
     final ax = _atLeast(across * 1.5, spacingX, least);
     final by = _atLeast(down * 1.5, spacingY, least);
diff --git a/packages/flutter3d_physics/hook/build.dart b/packages/flutter3d_physics/hook/build.dart
new file mode 100644
index 000000000..73767f563
--- /dev/null
+++ b/packages/flutter3d_physics/hook/build.dart
@@ -0,0 +1,43 @@
+// Builds the native Position Based Fluids kernels, `src/pbf_kernels.c`,
+// into a library `NativePbfKernels` binds to through `@Native`.
+//
+// **Never the reason a build fails.** The C compiler is the machine's own:
+// Xcode's, the NDK's, MSVC's, the system clang or gcc. Where there is none,
+// or the build of the library fails for any other reason, this says so and
+// builds nothing, and the fluid runs on the Dart kernels it would have run
+// on anyway; `NativePbfKernels.available` is false.
+//
+// **Optimised, and vectorised where it can be**: -O3, and on x86-64 the
+// SSE2 every such processor has. The kernels sum two neighbours at a time
+// with the compiler's vector extensions, which is why they are held to the
+// Dart reference within a tolerance rather than to the bit.
+import 'package:code_assets/code_assets.dart';
+import 'package:hooks/hooks.dart';
+import 'package:logging/logging.dart';
+import 'package:native_toolchain_c/native_toolchain_c.dart';
+
+void main(List<String> arguments) async {
+  await build(arguments, (input, output) async {
+    if (!input.config.buildCodeAssets) return;
+    final logger = Logger('flutter3d_physics')
+      // A hook's output is its standard output; there is no other logger.
+      // ignore: avoid_print
+      ..onRecord.listen((record) => print(record.message));
+    // Windows builds with MSVC, whose flags are its own.
+    final msvc = input.config.code.targetOS == OS.windows;
+    final builder = CBuilder.library(
+      name: 'flutter3d_physics_native',
+      assetName: 'src/fluid/native/pbf_native.dart',
+      sources: ['src/pbf_kernels.c', 'src/surface_modes.c', 'src/meniscus.c'],
+      flags: msvc ? const ['/O2'] : const ['-O3', '-fno-math-errno'],
+    );
+    try {
+      await builder.run(input: input, output: output, logger: logger);
+    } on Object catch (error) {
+      logger.warning(
+        'flutter3d_physics: no native fluid kernels ($error); the fluid '
+        'runs on its Dart kernels.',
+      );
+    }
+  });
+}
diff --git a/packages/flutter3d_physics/lib/flutter3d_physics.dart b/packages/flutter3d_physics/lib/flutter3d_physics.dart
index 4235be381..b6f13dfeb 100644
--- a/packages/flutter3d_physics/lib/flutter3d_physics.dart
+++ b/packages/flutter3d_physics/lib/flutter3d_physics.dart
@@ -39,18 +39,25 @@ export 'src/collision_shape.dart';
 export 'src/collision_world.dart';
 export 'src/contact.dart';
 export 'src/dynamics.dart';
+export 'src/fluid/atmosphere.dart';
+export 'src/fluid/background/fluid_background.dart';
 export 'src/fluid/buoyancy.dart';
 export 'src/fluid/capillary.dart';
 export 'src/fluid/fluid_medium.dart';
 export 'src/fluid/fluid_world.dart';
 export 'src/fluid/free_surface.dart';
+export 'src/fluid/gravity_field.dart';
 export 'src/fluid/jet.dart';
 export 'src/fluid/liquid_body.dart';
 export 'src/fluid/liquid_layer.dart';
+export 'src/fluid/native/pbf_backend.dart' show nativePbfAvailable;
 export 'src/fluid/outflow.dart';
 export 'src/fluid/particle_fluid.dart';
+export 'src/fluid/pbf_kernels.dart';
 export 'src/fluid/pipe.dart';
+export 'src/fluid/puddle.dart';
 export 'src/fluid/vessel_shape.dart';
+export 'src/fluid/wetting.dart';
 export 'src/inertia.dart';
 export 'src/portable_math.dart';
 export 'src/rigid_body.dart';
diff --git a/packages/flutter3d_physics/lib/src/fluid/atmosphere.dart b/packages/flutter3d_physics/lib/src/fluid/atmosphere.dart
new file mode 100644
index 000000000..3b7bf1b28
--- /dev/null
+++ b/packages/flutter3d_physics/lib/src/fluid/atmosphere.dart
@@ -0,0 +1,166 @@
+import 'dart:math' as math;
+
+import 'package:vector_math/vector_math.dart';
+
+import '../portable_math.dart';
+import 'fluid_medium.dart';
+
+/// The air round the liquids: how warm, at what pressure, how damp, and how
+/// it moves. What drops and streams fall through and what liquid left open
+/// evaporates into.
+///
+/// Every property follows from the four it is made with:
+///
+/// - **Density**, moist air as an ideal gas: the dry part at 28.96 g/mol,
+///   the vapour at 18.02, ρ = (p_d·M_d + p_v·M_v)/RT.
+/// - **Viscosity**, Sutherland's law for air: μ = 1.716×10⁻⁵ Pa·s at
+///   273.15 K, as (T/T₀)^1.5·(T₀ + 110.4)/(T + 110.4).
+/// - **Vapour diffusivity**, water vapour in air, 2.42×10⁻⁵ m²/s at 20 °C
+///   and an atmosphere, as T^1.81/p (Marrero and Mason, 1972).
+final class Atmosphere {
+  Atmosphere({
+    this.temperature = 293.15,
+    this.pressure = 101325.0,
+    this.humidity = 0.5,
+    Vector3? wind,
+  }) : wind = wind ?? Vector3.zero();
+
+  /// Air at 20 °C and one atmosphere, half saturated, still.
+  factory Atmosphere.standard() => Atmosphere();
+
+  /// Kelvin.
+  final double temperature;
+
+  /// Pascals.
+  final double pressure;
+
+  /// Relative humidity, nought to one: water vapour against what the air
+  /// holds saturated at [temperature].
+  final double humidity;
+
+  /// Metres per second, everywhere: the air's velocity.
+  final Vector3 wind;
+
+  static const double _gas = 8.314462618;
+  static const double _dryMolar = 0.0289644;
+  static const double _waterMolar = 0.01801528;
+
+  /// The air's velocity at [point]: a vector of the caller's own.
+  Vector3 windAt(Vector3 point) => wind.clone();
+
+  /// Partial pressure of water vapour, pascals.
+  double get vapourPressure =>
+      humidity * VapourCurve.water.saturationPressure(temperature);
+
+  /// Kilograms per cubic metre.
+  double get density {
+    final vapour = math.min(vapourPressure, pressure);
+    return ((pressure - vapour) * _dryMolar + vapour * _waterMolar) /
+        (_gas * temperature);
+  }
+
+  /// Dynamic viscosity, pascal seconds.
+  double get viscosity {
+    const t0 = 273.15;
+    const s = 110.4;
+    return 1.716e-5 *
+        Portable.pow(temperature / t0, 1.5) *
+        (t0 + s) /
+        (temperature + s);
+  }
+
+  /// How fast vapour spreads through the air, square metres per second.
+  double get vapourDiffusivity =>
+      2.42e-5 *
+      Portable.pow(temperature / 293.15, 1.81) *
+      (101325.0 / pressure);
+
+  /// The vapour of [medium] the air would take up, kilograms per cubic
+  /// metre: saturated at the surface less what the air already holds far
+  /// off. Nought for a liquid that does not evaporate.
+  double vapourDeficit(FluidMedium medium) {
+    final curve = medium.vapour;
+    if (curve == null) return 0.0;
+    final saturated = curve.saturationDensity(temperature);
+    // The air's own damp is water's; another vapour is not in it.
+    final held = curve.isWater ? humidity * saturated : 0.0;
+    return math.max(saturated - held, 0.0);
+  }
+
+  /// The drag coefficient of a sphere at Reynolds number [re]: Stokes's
+  /// 24/Re with Schiller and Naumann's correction (1933), and Newton's
+  /// 0.44 past a thousand.
+  static double sphereDrag(double re) {
+    if (re <= 0.0) return 0.0;
+    if (re >= 1000.0) return 0.44;
+    return 24.0 / re * (1.0 + 0.15 * Portable.pow(re, 0.687));
+  }
+
+  /// The drag coefficient of a long cylinder crossways to the flow at
+  /// Reynolds number [re]: White's fit, 1 + 10/Re^(2/3), for 1 to 2×10⁵.
+  static double cylinderDrag(double re) {
+    if (re <= 0.0) return 0.0;
+    return 1.0 + 10.0 / Portable.pow(math.max(re, 1.0), 2.0 / 3.0);
+  }
+
+  /// The acceleration the air gives a sphere [diameter] across of density
+  /// [density] moving at [velocity] at [point]: −¾·C_d·ρ_a·|u|·u/(ρ·d), u
+  /// its velocity through the air.
+  Vector3 dragOnSphere(
+    Vector3 velocity,
+    Vector3 point,
+    double diameter,
+    double density,
+  ) {
+    final u = velocity - windAt(point);
+    final speed = u.length;
+    if (speed <= 0.0 || diameter <= 0.0) return Vector3.zero();
+    final re = this.density * speed * diameter / viscosity;
+    final k =
+        -0.75 * sphereDrag(re) * this.density * speed / (density * diameter);
+    return u..scale(k);
+  }
+}
+
+/// How much vapour a liquid gives off at a temperature: its saturation
+/// pressure as the Magnus form p = a·exp(b·t/(c + t)), t in °C, and its
+/// molar mass.
+final class VapourCurve {
+  const VapourCurve({
+    required this.a,
+    required this.b,
+    required this.c,
+    required this.molarMass,
+    this.isWater = false,
+  });
+
+  /// Water over a flat surface, Alduchov and Eskridge (1996): within a
+  /// tenth of a percent from −40 to 50 °C.
+  static const VapourCurve water = VapourCurve(
+    a: 610.94,
+    b: 17.625,
+    c: 243.04,
+    molarMass: 0.01801528,
+    isWater: true,
+  );
+
+  final double a;
+  final double b;
+  final double c;
+
+  /// Kilograms per mole.
+  final double molarMass;
+
+  /// Whether this is water's vapour, which the air's humidity is.
+  final bool isWater;
+
+  /// Pascals at [temperature] kelvin.
+  double saturationPressure(double temperature) {
+    final t = temperature - 273.15;
+    return a * Portable.exp(b * t / (c + t));
+  }
+
+  /// Kilograms per cubic metre of saturated vapour at [temperature].
+  double saturationDensity(double temperature) =>
+      saturationPressure(temperature) * molarMass / (8.314462618 * temperature);
+}
diff --git a/packages/flutter3d_physics/lib/src/fluid/background/fluid_background.dart b/packages/flutter3d_physics/lib/src/fluid/background/fluid_background.dart
new file mode 100644
index 000000000..8193f66e4
--- /dev/null
+++ b/packages/flutter3d_physics/lib/src/fluid/background/fluid_background.dart
@@ -0,0 +1,3 @@
+// Another isolate where there are isolates, none where there are not.
+export 'fluid_background_none.dart'
+    if (dart.library.isolate) 'fluid_background_io.dart';
diff --git a/packages/flutter3d_physics/lib/src/fluid/background/fluid_background_io.dart b/packages/flutter3d_physics/lib/src/fluid/background/fluid_background_io.dart
new file mode 100644
index 000000000..0a64a511b
--- /dev/null
+++ b/packages/flutter3d_physics/lib/src/fluid/background/fluid_background_io.dart
@@ -0,0 +1,156 @@
+// The cross-sections' modes and the menisci worked out on another isolate,
+// for a world that need not step the same to the bit on every run.
+import 'dart:isolate';
+import 'dart:typed_data';
+
+import '../capillary.dart';
+import '../fluid_medium.dart';
+import '../free_surface.dart';
+
+/// A long-lived isolate that works out what a [FreeSurface] or a vessel's
+/// meniscus would otherwise stop a frame for: one for the whole program,
+/// started the first time it is asked for.
+///
+/// **What comes back is the same as what would have been worked out here**:
+/// the same functions, on the same numbers. Only when it comes differs, so
+/// a world stepped with it ([FluidWorld.background]) is not the same run to
+/// the bit twice; one stepped without it is.
+final class FluidBackground implements ModeSolver {
+  FluidBackground._() {
+    // Not what keeps a program running: a test or a tool that is done exits
+    // with this still open.
+    _port.keepIsolateAlive = false;
+    _port.handler = _receive;
+    Isolate.spawn(_work, _port.sendPort, debugName: 'flutter3d fluid');
+  }
+
+  static FluidBackground? _instance;
+
+  /// The one there is, started on first use.
+  static FluidBackground get instance => _instance ??= FluidBackground._();
+
+  final RawReceivePort _port = RawReceivePort();
+  SendPort? _send;
+  final List<List<Object?>> _waiting = [];
+  final Map<int, void Function(List<Object?>)> _replies = {};
+  int _next = 0;
+
+  /// How many requests have not come back yet.
+  int get outstanding => _replies.length;
+
+  void _receive(Object? message) {
+    if (message is SendPort) {
+      _send = message;
+      _waiting.forEach(message.send);
+      _waiting.clear();
+      return;
+    }
+    final reply = message! as List<Object?>;
+    _replies.remove(reply[0]! as int)?.call(reply);
+  }
+
+  void _post(List<Object?> request, void Function(List<Object?>) reply) {
+    _replies[request[1]! as int] = reply;
+    final send = _send;
+    if (send == null) {
+      _waiting.add(request);
+    } else {
+      send.send(request);
+    }
+  }
+
+  @override
+  void solve(
+    int n,
+    List<List<int>> neighbours,
+    double cell2,
+    int count,
+    void Function((List<Float64List>, Float64List) modes) done, {
+    bool native = false,
+  }) {
+    _post(['modes', _next++, n, neighbours, cell2, count, native], (reply) {
+      done((
+        [for (final m in reply[1]! as List<Object?>) m! as Float64List],
+        reply[2]! as Float64List,
+      ));
+    });
+  }
+
+  /// Works out the meniscus of [medium] in a tube of [radius] under [g] and
+  /// calls [done] with it, later, on this isolate.
+  void meniscus(
+    FluidMedium medium,
+    double radius,
+    double g,
+    void Function(TubeMeniscus meniscus) done, {
+    bool native = false,
+  }) {
+    _post(
+      [
+        'meniscus',
+        _next++,
+        medium.name,
+        medium.density,
+        medium.viscosity,
+        medium.surfaceTension,
+        medium.contactAngle,
+        radius,
+        g,
+        native,
+      ],
+      (reply) {
+        done(
+          TubeMeniscus.solved(
+            medium: medium,
+            radius: radius,
+            g: g,
+            solution: (
+              apexCurvature: reply[1]! as double,
+              r: (reply[2]! as List<Object?>).cast<double>(),
+              z: (reply[3]! as List<Object?>).cast<double>(),
+            ),
+          ),
+        );
+      },
+    );
+  }
+}
+
+/// The other isolate: answers each request with what it asks for.
+void _work(SendPort back) {
+  final port = ReceivePort();
+  back.send(port.sendPort);
+  port.listen((message) {
+    final request = message as List<Object?>;
+    final id = request[1]! as int;
+    switch (request[0]) {
+      case 'modes':
+        final (modes, k2) = FreeSurface.solveModes(
+          request[2]! as int,
+          (request[3]! as List<Object?>).cast<List<int>>(),
+          request[4]! as double,
+          request[5]! as int,
+          native: request[6]! as bool,
+        );
+        back.send([id, modes, k2]);
+      case 'meniscus':
+        final medium = FluidMedium(
+          name: request[2]! as String,
+          density: request[3]! as double,
+          viscosity: request[4]! as double,
+          surfaceTension: request[5]! as double,
+          contactAngle: request[6]! as double,
+        );
+        final m = TubeMeniscus(
+          medium: medium,
+          radius: request[7]! as double,
+          g: request[8]! as double,
+          native: request[9]! as bool,
+        ).solution;
+        back.send([id, m.apexCurvature, m.r, m.z]);
+    }
+  });
+}
+
+/// The background where there are isolates.
+FluidBackground? get fluidBackground => FluidBackground.instance;
diff --git a/packages/flutter3d_physics/lib/src/fluid/background/fluid_background_none.dart b/packages/flutter3d_physics/lib/src/fluid/background/fluid_background_none.dart
new file mode 100644
index 000000000..f39a3675c
--- /dev/null
+++ b/packages/flutter3d_physics/lib/src/fluid/background/fluid_background_none.dart
@@ -0,0 +1,23 @@
+// Where there are no isolates to put work on (the web): none.
+import '../capillary.dart';
+import '../fluid_medium.dart';
+import '../free_surface.dart';
+
+/// Never made here: the same face as where there are isolates, so the code
+/// that asks for one reads the same.
+abstract final class FluidBackground implements ModeSolver {
+  /// How many requests have not come back yet.
+  int get outstanding;
+
+  /// Works out a meniscus elsewhere; never called here.
+  void meniscus(
+    FluidMedium medium,
+    double radius,
+    double g,
+    void Function(TubeMeniscus meniscus) done, {
+    bool native = false,
+  });
+}
+
+/// None here: what would be put off is worked out at once.
+FluidBackground? get fluidBackground => null;
diff --git a/packages/flutter3d_physics/lib/src/fluid/buoyancy.dart b/packages/flutter3d_physics/lib/src/fluid/buoyancy.dart
index 0c5d4891e..a324fc0a8 100644
--- a/packages/flutter3d_physics/lib/src/fluid/buoyancy.dart
+++ b/packages/flutter3d_physics/lib/src/fluid/buoyancy.dart
@@ -166,6 +166,27 @@ final class FloatingBody {
         ..scale(1.0 / (1.0 + k * dt))
         ..addScaled(gravity, -dt);
     }
+    // **Turning, the liquid holds it back too**: a sphere spinning slowly in
+    // a viscous liquid feels Stokes's torque 8πμR³ω, here for the sphere of
+    // the body's volume and the share of it under, taken implicitly about
+    // the body's own axes. Without it a body set spinning in glycerol spun
+    // on for ever.
+    final spin = body.angularVelocity;
+    if (spin.length2 > 0.0) {
+      final shape = body.collider.shape;
+      final whole = _wholeVolume(shape);
+      final r = Portable.pow(3.0 * whole / (4.0 * math.pi), 1.0 / 3.0);
+      final share = (under / whole).clamp(0.0, 1.0);
+      final c = 8.0 * math.pi * medium.viscosity * r * r * r * share;
+      final turn = body.orientation.asRotationMatrix();
+      final local = (turn.clone()..transpose()).transformed(spin);
+      final inverse = body.inverseInertiaLocal;
+      local
+        ..x /= 1.0 + c * inverse.x * dt
+        ..y /= 1.0 + c * inverse.y * dt
+        ..z /= 1.0 + c * inverse.z * dt;
+      spin.setFrom(turn.transformed(local));
+    }
     return under;
   }
 
diff --git a/packages/flutter3d_physics/lib/src/fluid/capillary.dart b/packages/flutter3d_physics/lib/src/fluid/capillary.dart
index aa95d7290..10f42d007 100644
--- a/packages/flutter3d_physics/lib/src/fluid/capillary.dart
+++ b/packages/flutter3d_physics/lib/src/fluid/capillary.dart
@@ -2,6 +2,7 @@ import 'dart:math' as math;
 
 import '../portable_math.dart';
 import 'fluid_medium.dart';
+import 'native/pbf_backend.dart';
 
 /// Surface tension at a wall: how high liquid climbs it, and the shape of
 /// the surface it leaves.
@@ -38,10 +39,46 @@ final class TubeMeniscus {
     required this.radius,
     required this.g,
     this.samples = 64,
+    bool native = false,
   }) {
-    _solve();
+    final solved = native
+        ? nativeMeniscus(
+            radius,
+            medium.density * g / medium.surfaceTension,
+            medium.contactAngle,
+            samples,
+          )
+        : null;
+    if (solved == null) {
+      _solve();
+    } else {
+      apexCurvature = solved.apexCurvature;
+      _r = solved.r;
+      _z = solved.z;
+      wallRise = _z.last;
+    }
   }
 
+  /// A meniscus already solved, from what [solution] gave: for one worked
+  /// out on another isolate.
+  TubeMeniscus.solved({
+    required this.medium,
+    required this.radius,
+    required this.g,
+    required ({double apexCurvature, List<double> r, List<double> z}) solution,
+    this.samples = 64,
+  }) {
+    apexCurvature = solution.apexCurvature;
+    _r = solution.r;
+    _z = solution.z;
+    wallRise = _z.last;
+  }
+
+  /// What another isolate sends back: the curvature at the middle and the
+  /// surface's points.
+  ({double apexCurvature, List<double> r, List<double> z}) get solution =>
+      (apexCurvature: apexCurvature, r: _r, z: _z);
+
   final FluidMedium medium;
   final double radius;
   final double g;
@@ -104,14 +141,57 @@ final class TubeMeniscus {
   void _solve() {
     final target = math.pi / 2 - medium.contactAngle;
     final bond = medium.density * g / medium.surfaceTension;
+    // **By false position, not by halving.** The angle the surface meets
+    // the wall at goes smoothly and steadily with the curvature at its
+    // middle, so the straight line through the two ends of the bracket
+    // lands near the curvature that meets it at the contact angle, and
+    // Illinois's halving of the end that stays (Dowell and Jarratt, 1971)
+    // keeps that from stalling at one end. A dozen shots, where sixty
+    // halvings took ten milliseconds a meniscus, and a test tube being
+    // filled up its round bottom wanted a new one every other step. A shot
+    // that comes back with no angle, or a line that falls outside the
+    // bracket, is halved instead.
     var lo = -40.0 / radius;
     var hi = 40.0 / radius;
-    for (var i = 0; i < 60; i++) {
-      final mid = 0.5 * (lo + hi);
-      if (_shoot(mid, bond).angle < target) {
+    var flo = _shoot(lo, bond).angle - target;
+    var fhi = _shoot(hi, bond).angle - target;
+    var kept = 0;
+    // As fine as sixty halvings of the bracket went: in a wide tube the
+    // middle is nearly flat, its curvature a billionth of the bracket's,
+    // and the angle at the wall goes with it exponentially.
+    // 2⁻⁶⁰, exactly: a power of two is, in a double.
+    final tolerance = (hi - lo) * 8.673617379884035e-19;
+    for (var i = 0; i < 200 && hi - lo > tolerance; i++) {
+      var mid = flo.isFinite && fhi.isFinite && fhi != flo
+          ? lo - flo * (hi - lo) / (fhi - flo)
+          : 0.5 * (lo + hi);
+      if (!(mid > lo && mid < hi)) mid = 0.5 * (lo + hi);
+      final f = _shoot(mid, bond).angle - target;
+      if (!f.isFinite) {
+        // No surface reaches the wall this way: as halving would, take
+        // the side the bracket's own ends say.
+        if (flo.isFinite && flo > 0.0) {
+          hi = mid;
+        } else {
+          lo = mid;
+        }
+        continue;
+      }
+      if (f.abs() < 1e-15) {
+        lo = mid;
+        hi = mid;
+        break;
+      }
+      if (f < 0.0) {
         lo = mid;
+        flo = f;
+        if (kept == 1) fhi *= 0.5;
+        kept = 1;
       } else {
         hi = mid;
+        fhi = f;
+        if (kept == -1) flo *= 0.5;
+        kept = -1;
       }
     }
     apexCurvature = 0.5 * (lo + hi);
@@ -137,7 +217,10 @@ final class TubeMeniscus {
     final zs = <double>[0.0];
     double turn(double r, double z, double phi) =>
         bond * z + b - Portable.sin(phi) / math.max(r, 1e-12);
-    final ds = radius / (samples * 8);
+    // Two steps a kept sample: Runge–Kutta's error goes as the fourth power
+    // of the step, and eight a sample bought nothing measured against one
+    // eight times finer again, at four times the cost.
+    final ds = radius / (samples * 2);
     var guard = 0;
     while (r < radius && guard++ < samples * 400) {
       // Runge–Kutta in arc length.
diff --git a/packages/flutter3d_physics/lib/src/fluid/fluid_medium.dart b/packages/flutter3d_physics/lib/src/fluid/fluid_medium.dart
index aa253bb7b..0efc0be4f 100644
--- a/packages/flutter3d_physics/lib/src/fluid/fluid_medium.dart
+++ b/packages/flutter3d_physics/lib/src/fluid/fluid_medium.dart
@@ -1,5 +1,7 @@
 import 'dart:math' as math;
 
+import 'atmosphere.dart';
+
 /// A liquid, by the properties that decide how it moves: how heavy it is,
 /// how thick, how strongly its surface pulls, and how it meets a wall.
 ///
@@ -14,6 +16,7 @@ final class FluidMedium {
     required this.viscosity,
     required this.surfaceTension,
     this.contactAngle = 0.0,
+    this.vapour,
   });
 
   /// Water: 998 kg/m³, 1.0 mPa·s, 72.8 mN/m, wetting glass at about 20°.
@@ -23,6 +26,7 @@ final class FluidMedium {
     viscosity: 1.002e-3,
     surfaceTension: 0.0728,
     contactAngle: 0.35,
+    vapour: VapourCurve.water,
   );
 
   /// Glycerol: heavy and fourteen hundred times as viscous as water.
@@ -76,6 +80,11 @@ final class FluidMedium {
   /// nought wets completely, past a quarter turn does not wet.
   final double contactAngle;
 
+  /// How much vapour it gives off, for evaporating into an [Atmosphere];
+  /// null for a liquid that is taken not to. Only water has one so far: the
+  /// others' curves are not here yet, not nought.
+  final VapourCurve? vapour;
+
   /// Kinematic viscosity, square metres per second: what the damping of
   /// waves and the thickness of a boundary layer go by, which
   /// [FreeSurface] reads.
@@ -91,12 +100,14 @@ final class FluidMedium {
     double? viscosity,
     double? surfaceTension,
     double? contactAngle,
+    VapourCurve? vapour,
   }) => FluidMedium(
     name: name ?? this.name,
     density: density ?? this.density,
     viscosity: viscosity ?? this.viscosity,
     surfaceTension: surfaceTension ?? this.surfaceTension,
     contactAngle: contactAngle ?? this.contactAngle,
+    vapour: vapour ?? this.vapour,
   );
 
   @override
diff --git a/packages/flutter3d_physics/lib/src/fluid/fluid_world.dart b/packages/flutter3d_physics/lib/src/fluid/fluid_world.dart
index d97a561e2..3ec968b37 100644
--- a/packages/flutter3d_physics/lib/src/fluid/fluid_world.dart
+++ b/packages/flutter3d_physics/lib/src/fluid/fluid_world.dart
@@ -1,11 +1,15 @@
 import 'package:vector_math/vector_math.dart';
 
 import '../rigid_body.dart';
+import 'atmosphere.dart';
+import 'background/fluid_background.dart';
 import 'buoyancy.dart';
+import 'gravity_field.dart';
 import 'jet.dart';
 import 'liquid_body.dart';
 import 'particle_fluid.dart';
 import 'pipe.dart';
+import 'puddle.dart';
 
 /// Liquids in a world: the vessels, the pipes between them, and the streams
 /// running from one to another, stepped together at a fixed step.
@@ -25,7 +29,42 @@ final class FluidWorld {
     this.step = 1.0 / 240.0,
     this.particleSpacing = 0.002,
     this.floor,
-  });
+    Atmosphere? atmosphere,
+    this.field,
+    this.nativeKernels = false,
+    this.background = false,
+  }) : atmosphere = atmosphere ?? Atmosphere.standard();
+
+  /// Gravity that differs from place to place, when there is some: then
+  /// each vessel, drop and parcel of a stream feels [GravityField.at] where
+  /// it is, and [gravity] is not read. Null, every one feels [gravity].
+  final GravityField? field;
+
+  /// Whether drops run their loops over pairs natively where that was built:
+  /// see [ParticleFluid.native]. Off, the world steps the same to the bit
+  /// on every machine.
+  final bool nativeKernels;
+
+  /// Whether what would stop a frame — a cross-section's modes, a
+  /// meniscus not met before — is worked out on another isolate where
+  /// there are isolates, the vessel carrying on as it was until it comes.
+  /// The same numbers, at another time: on, a run is not the same to the
+  /// bit twice; off, it is. On the web, where there are no isolates, it is
+  /// all worked out at once either way.
+  final bool background;
+
+  /// The gravity at [point].
+  Vector3 gravityAt(Vector3 point) => field?.at(point) ?? gravity;
+
+  /// The air: what drops and streams fall through and what open liquid
+  /// evaporates into. Room air by default, as a bench stands in.
+  final Atmosphere atmosphere;
+
+  /// Cubic metres of liquid gone to vapour, from vessels, puddles and
+  /// drops: counted, so that every cubic metre poured in is still found.
+  double get evaporated =>
+      _evaporated + particles.values.fold(0.0, (s, p) => s + p.evaporated);
+  double _evaporated = 0.0;
 
   /// Metres per second squared, shared with whoever else falls.
   final Vector3 gravity;
@@ -56,12 +95,21 @@ final class FluidWorld {
   /// medium: what streams broke into, what splashed, what lies spilt.
   final Map<String, ParticleFluid> particles = {};
 
+  /// The puddles on each flat [floor]: what lands there lies there, as a
+  /// drop or a puddle, not as particles.
+  late final List<PuddleSurface> spills = [
+    for (final o in floor ?? const <JetObstacle>[])
+      if (o is PlaneObstacle) PuddleSurface(o),
+  ];
+
   /// Every cubic metre the world holds: in vessels, in the air, as
-  /// particles.
+  /// particles, in puddles, and gone to vapour as the liquid it was.
   double get volume =>
       bodies.fold(0.0, (s, b) => s + b.volume) +
       jets.values.fold(0.0, (s, j) => s + j.inFlight) +
-      particles.values.fold(0.0, (s, p) => s + p.volume);
+      particles.values.fold(0.0, (s, p) => s + p.volume) +
+      spills.fold(0.0, (s, p) => s + p.volume) +
+      evaporated;
 
   double _carried = 0.0;
   int _ran = 0;
@@ -87,22 +135,31 @@ final class FluidWorld {
   }
 
   void _stepOnce(double dt) {
+    final helper = background ? fluidBackground : null;
+    for (final body in bodies) {
+      body
+        ..background = helper
+        ..surface.solver = helper
+        ..nativeMeniscus = nativeKernels
+        ..surface.nativeModes = nativeKernels;
+    }
     for (final liquid in bodies) {
       var displaced = 0.0;
       for (final f in floating) {
-        displaced += f.push(liquid, dt, gravity);
+        displaced += f.push(liquid, dt, gravityAt(f.body.position));
       }
       liquid.displaced = displaced;
     }
     for (final pipe in pipes) {
-      pipe.step(dt, gravity: gravity);
+      pipe.step(dt, gravity: gravityAt(pipe.from.position));
     }
     for (final body in bodies) {
-      final spill = body.step(dt, gravity: gravity);
+      final here = gravityAt(body.position);
+      final spill = body.step(dt, gravity: here);
       final jet = jets[body];
       if (spill.flow > 0.0 || jet != null) {
         final stream = jets.putIfAbsent(body, () => Jet(medium: body.medium));
-        final across = gravity.cross(spill.velocity);
+        final across = here.cross(spill.velocity);
         stream.emit(
           flow: spill.flow,
           dt: dt,
@@ -129,15 +186,20 @@ final class FluidWorld {
       ];
       for (final drop in jet.step(
         dt,
-        gravity: gravity,
+        gravity: gravityAt(source.position),
+        gravityAt: field?.at,
         obstacles: walls,
-        receivers: bodies,
+        receivers: [...bodies, ...spills],
+        air: atmosphere,
       )) {
         particles
             .putIfAbsent(
               drop.medium.name,
-              () =>
-                  ParticleFluid(medium: drop.medium, spacing: particleSpacing),
+              () => ParticleFluid(
+                medium: drop.medium,
+                spacing: particleSpacing,
+                native: nativeKernels,
+              ),
             )
             .inject(
               drop.volume,
@@ -159,9 +221,25 @@ final class FluidWorld {
     for (final fluid in particles.values) {
       fluid.step(
         dt,
-        gravity: gravity,
+        gravity: field == null || fluid.count == 0
+            ? gravity
+            : gravityAt(fluid.positions.first),
+        gravityAt: field?.at,
         obstacles: everywhere,
-        receivers: bodies,
+        receivers: [...bodies, ...spills],
+        air: atmosphere,
+      );
+    }
+    for (final body in bodies) {
+      _evaporated += body.evaporate(dt, atmosphere);
+    }
+    for (final spill in spills) {
+      _evaporated += spill.evaporate(dt, atmosphere);
+    }
+    for (final spill in spills) {
+      spill.step(
+        dt,
+        gravity: gravityAt(spill.surface.normal * spill.surface.offset),
       );
     }
   }
diff --git a/packages/flutter3d_physics/lib/src/fluid/free_surface.dart b/packages/flutter3d_physics/lib/src/fluid/free_surface.dart
index dcd6a9378..4be52efac 100644
--- a/packages/flutter3d_physics/lib/src/fluid/free_surface.dart
+++ b/packages/flutter3d_physics/lib/src/fluid/free_surface.dart
@@ -5,6 +5,7 @@ import 'package:vector_math/vector_math.dart';
 
 import '../portable_math.dart';
 import 'fluid_medium.dart';
+import 'native/pbf_backend.dart';
 import 'vessel_shape.dart';
 
 /// The waves on a liquid's free surface in a vessel of any shape: how far
@@ -64,6 +65,22 @@ final class FreeSurface {
   /// The surface's area, square metres.
   double get area => _grid == null ? 0.0 : _grid!.count * _grid!.cell2;
 
+  /// [f] averaged over the surface as it is laid out, by its cells, and the
+  /// layout it was averaged over: what a caller keeps it by.
+  ({double mean, Object? layout}) meanOf(double Function(Vector3 point) f) {
+    final grid = _grid;
+    if (grid == null || grid.count == 0) return (mean: 0.0, layout: null);
+    var sum = 0.0;
+    for (var i = 0; i < grid.count; i++) {
+      sum += f(grid.point(i));
+    }
+    return (mean: sum / grid.count, layout: grid);
+  }
+
+  /// The layout the surface has now: a new object whenever it is laid out
+  /// again.
+  Object? get layout => _grid;
+
   /// How much liquid the waves hold above the plane, cubic metres: nought,
   /// since no mode but the flat one has any, and that one is never kept.
   /// For a test to hold the surface to.
@@ -92,23 +109,39 @@ final class FreeSurface {
         _modes.isNotEmpty &&
         1.0 - old.up.dot(up.normalized()) < 0.5 * reuseTurn * reuseTurn &&
         (height - old.height).abs() < 0.5 * old.cell) {
-      final moved = old.movedTo(up, height);
-      final behind = Float64List(moved.count);
-      for (var i = 0; i < moved.count; i++) {
-        final p = moved.point(i);
-        behind[i] = -(old.up.dot(p) - old.height);
-      }
-      _grid = moved;
-      final added = _project(behind);
-      for (var n = 0; n < added.length; n++) {
-        _amplitude[n] += added[n];
+      _carryOn(old, up, height);
+      return;
+    }
+    final grid = _Grid.cut(shape, up, height, cells);
+    // **Not waited for, where it may be put off.** A cross-section whose
+    // modes are not worked out yet is handed to [solver] to work out
+    // elsewhere, and the surface carries on its old grid moved to where it
+    // is now, as it does for a small turn, until they come: then it is
+    // laid out again ([step]). Waited for, a tube tipped to an angle it had
+    // not been at cost a frame a tenth of a second.
+    final defer = solver;
+    if (defer != null &&
+        old != null &&
+        _modes.isNotEmpty &&
+        grid.count >= 6 &&
+        _cachedModes(grid, modeCount, nativeModes) == null) {
+      _wanted = (shape: shape, up: up.clone(), height: height, grid: grid);
+      final count = modeCount;
+      final native = nativeModes;
+      // Asked once, however many steps go by before it comes.
+      final key = _keyOf(grid, count, native);
+      if (_asked.add(key)) {
+        defer.solve(grid.count, grid.neighbours, grid.cell2, count, (modes) {
+          _asked.remove(key);
+          _remember(grid, count, native, modes);
+        }, native: native);
       }
-      _field = null;
+      _carryOn(old, up, height);
       return;
     }
+    _wanted = null;
     final oldHeights = old == null ? null : _heights();
     final oldRates = old == null ? null : _sumModes(_rate);
-    final grid = _Grid.cut(shape, up, height, cells);
     _grid = grid;
     _field = null;
     if (grid.count < 6) {
@@ -118,7 +151,7 @@ final class FreeSurface {
       _rate = Float64List(0);
       return;
     }
-    final (shapes, k2) = _lowestModes(grid, modeCount);
+    final (shapes, k2) = _modesOf(grid, modeCount, nativeModes);
     _modes = shapes;
     _k2 = k2;
     // The liquid stays: what stood off the old plane stands off the new one
@@ -136,11 +169,55 @@ final class FreeSurface {
     _rate = _project(rates);
   }
 
+  /// The old grid moved to the plane at [height] across [up], its modes
+  /// kept: what the liquid stood off the old plane it stands off the new.
+  void _carryOn(_Grid old, Vector3 up, double height) {
+    final moved = old.movedTo(up, height);
+    final behind = Float64List(moved.count);
+    for (var i = 0; i < moved.count; i++) {
+      final p = moved.point(i);
+      behind[i] = -(old.up.dot(p) - old.height);
+    }
+    _grid = moved;
+    final added = _project(behind);
+    for (var n = 0; n < added.length; n++) {
+      _amplitude[n] += added[n];
+    }
+    _field = null;
+  }
+
+  /// Whether its cross-sections' modes are worked out natively where that
+  /// was built; set by a world that may be stepped so
+  /// (`FluidWorld.nativeKernels`).
+  bool nativeModes = false;
+
+  /// Where cross-sections not yet worked out are worked out instead of
+  /// waited for: another isolate, set by a world that may be stepped so
+  /// (`FluidWorld.background`). Null, they are worked out at once.
+  ModeSolver? solver;
+
+  /// Whether it is carrying on its old grid while its new cross-section's
+  /// modes are worked out elsewhere.
+  bool get waitingForModes => _wanted != null;
+
+  /// The cross-sections asked for and not come yet, by key.
+  static final Set<int> _asked = {};
+
+  /// The layout put off until its modes come.
+  ({VesselShape shape, Vector3 up, double height, _Grid grid})? _wanted;
+
   /// Moves the waves on by [dt] seconds under gravity [g], over a liquid
   /// [depth] deep on average: each mode exactly, as the damped oscillator it
   /// is, so any step is stable.
   void step(double dt, {required double g, required double depth}) {
     _depth = depth;
+    // The modes put off for have come: laid out now, as it would have been.
+    final wanted = _wanted;
+    if (wanted != null &&
+        _cachedModes(wanted.grid, modeCount, nativeModes) != null) {
+      _wanted = null;
+      layOut(wanted.shape, wanted.up, wanted.height);
+    }
     if (_modes.isEmpty) return;
     _applyLandings();
     // Still water stays still: nothing to ring.
@@ -424,47 +501,189 @@ final class FreeSurface {
 
   /// The lowest [count] non-flat modes of [grid]'s Laplacian with the wall's
   /// condition, orthonormal under the area, and their k².
-  static (List<Float64List>, Float64List) _lowestModes(_Grid grid, int count) {
-    final n = grid.count;
-    final inv = 1.0 / grid.cell2;
-    // The graph Laplacian: each cell against the neighbours it has inside.
-    // A neighbour outside is the wall, and leaving it out is ∂φ/∂n = 0.
-    Float64List apply(Float64List x) {
-      final y = Float64List(n);
-      for (var i = 0; i < n; i++) {
-        var sum = 0.0;
-        for (final j in grid.neighbours[i]) {
-          sum += x[i] - x[j];
-        }
-        y[i] = sum * inv;
+  /// [_lowestModes], solved once for each cross-section there is.
+  ///
+  /// **They depend on which cells are inside and on nothing else**: the grid
+  /// is laid on the same lattice at every height, so a straight-sided glass
+  /// has the one cross-section all the way up, and every tube on the bench
+  /// the same one. Solved again each time the level rose half a cell, a
+  /// tube being poured into worked out its modes every other step, fifty
+  /// milliseconds each, and that was most of a pour's cost. Read only, so
+  /// shared between surfaces.
+  ///
+  /// Kept apart by [native]: a world that must replay to the bit never
+  /// reads modes the native solve worked out for another.
+  static (List<Float64List>, Float64List) _modesOf(
+    _Grid grid,
+    int count,
+    bool native,
+  ) {
+    final cached = _cachedModes(grid, count, native);
+    if (cached != null) return cached;
+    final modes = _lowestModes(grid, count, native: native);
+    _remember(grid, count, native, modes);
+    return modes;
+  }
+
+  static int _keyOf(_Grid grid, int count, bool native) => Object.hash(
+    count,
+    native,
+    grid.columns,
+    grid.rows,
+    grid.cell,
+    Object.hashAll(grid.index),
+  );
+
+  static (List<Float64List>, Float64List)? _cachedModes(
+    _Grid grid,
+    int count,
+    bool native,
+  ) {
+    final hits = _solved[_keyOf(grid, count, native)];
+    if (hits == null) return null;
+    for (final hit in hits) {
+      if (hit.count == count &&
+          hit.native == native &&
+          hit.columns == grid.columns &&
+          hit.rows == grid.rows &&
+          hit.cell == grid.cell &&
+          _same(hit.index, grid.index)) {
+        return hit.modes;
       }
-      return y;
     }
+    return null;
+  }
 
+  static void _remember(
+    _Grid grid,
+    int count,
+    bool native,
+    (List<Float64List>, Float64List) modes,
+  ) {
+    if (_cachedModes(grid, count, native) != null) return;
+    if (_solved.length >= 256) _solved.remove(_solved.keys.first);
+    (_solved[_keyOf(grid, count, native)] ??= []).add((
+      count: count,
+      native: native,
+      columns: grid.columns,
+      rows: grid.rows,
+      cell: grid.cell,
+      index: Int32List.fromList(grid.index),
+      modes: modes,
+    ));
+  }
+
+  static bool _same(Int32List a, Int32List b) {
+    if (a.length != b.length) return false;
+    for (var i = 0; i < a.length; i++) {
+      if (a[i] != b[i]) return false;
+    }
+    return true;
+  }
+
+  static final Map<
+    int,
+    List<
+      ({
+        int count,
+        bool native,
+        int columns,
+        int rows,
+        double cell,
+        Int32List index,
+        (List<Float64List>, Float64List) modes,
+      })
+    >
+  >
+  _solved = {};
+
+  static (List<Float64List>, Float64List) _lowestModes(
+    _Grid grid,
+    int count, {
+    bool native = false,
+  }) => solveModes(
+    grid.count,
+    grid.neighbours,
+    grid.cell2,
+    count,
+    native: native,
+  );
+
+  /// The lowest [count] non-flat modes of the graph Laplacian of [n] cells
+  /// [cell2] square metres each, with [neighbours] inside, and their k²:
+  /// all the solve needs, so another isolate can do it from these alone.
+  ///
+  /// [native] runs the Lanczos steps in C where that was built: the same
+  /// steps, to within a tolerance rather than to the bit.
+  static (List<Float64List>, Float64List) solveModes(
+    int n,
+    List<List<int>> neighbours,
+    double cell2,
+    int count, {
+    bool native = false,
+  }) {
+    final inv = 1.0 / cell2;
+    // The graph Laplacian: each cell against the neighbours it has inside.
+    // A neighbour outside is the wall, and leaving it out is ∂φ/∂n = 0.
+    //
     // The lowest of L are the highest of L⁻¹, and well apart there, where
     // near nought they crowd together and Lanczos on L itself would take
-    // hundreds of steps to tell them apart. L⁻¹ is applied by conjugate
-    // gradients, on the flat-free part where L can be inverted.
+    // hundreds of steps to tell them apart.
+    //
+    // **L + σ factored once, as a band, and each solve two sweeps along
+    // it.** The cells are numbered row by row, so a cell's neighbours are
+    // within a row's worth of it and L is a band that wide. The Lanczos
+    // steps all solve against the same L; conjugate gradients went at it
+    // afresh each time, some hundreds of passes over the grid each, and a
+    // cross-section's modes cost seventy milliseconds where the factor
+    // costs a few. L is singular, the flat mode being free, so σ, a
+    // millionth of its scale, makes it definite; the modes are the same and
+    // their values come out σ higher, which is taken off below.
+    final sigma = 1e-6 * inv;
+    var band = 0;
+    for (var i = 0; i < n; i++) {
+      for (final k in neighbours[i]) {
+        band = math.max(band, (i - k).abs());
+      }
+    }
+    final w1 = band + 1;
+    // Lower band: L(i, j) at i·w1 + (i − j).
+    final factor = Float64List(n * w1);
+    for (var i = 0; i < n; i++) {
+      factor[i * w1] = neighbours[i].length * inv + sigma;
+      for (final k in neighbours[i]) {
+        if (k < i) factor[i * w1 + (i - k)] = -inv;
+      }
+    }
+    for (var i = 0; i < n; i++) {
+      final lo = math.max(0, i - band);
+      for (var j = lo; j <= i; j++) {
+        var sum = factor[i * w1 + (i - j)];
+        final from = math.max(lo, j - band);
+        for (var k = from; k < j; k++) {
+          sum -= factor[i * w1 + (i - k)] * factor[j * w1 + (j - k)];
+        }
+        factor[i * w1 + (i - j)] = i == j
+            ? math.sqrt(math.max(sum, 1e-300))
+            : sum / factor[j * w1];
+      }
+    }
     Float64List solve(Float64List b) {
-      final x = Float64List(n);
-      final r = Float64List.fromList(b);
-      _removeMean(r);
-      final p = Float64List.fromList(r);
-      var rr = _dot(r, r);
-      final stop = 1e-24 * math.max(rr, 1e-300);
-      for (var it = 0; it < 4 * n && rr > stop; it++) {
-        final ap = apply(p);
-        final step = rr / _dot(p, ap);
-        for (var i = 0; i < n; i++) {
-          x[i] += step * p[i];
-          r[i] -= step * ap[i];
+      final x = Float64List.fromList(b);
+      _removeMean(x);
+      for (var i = 0; i < n; i++) {
+        var sum = x[i];
+        for (var k = math.max(0, i - band); k < i; k++) {
+          sum -= factor[i * w1 + (i - k)] * x[k];
         }
-        final next = _dot(r, r);
-        final ratio = next / rr;
-        rr = next;
-        for (var i = 0; i < n; i++) {
-          p[i] = r[i] + ratio * p[i];
+        x[i] = sum / factor[i * w1];
+      }
+      for (var i = n - 1; i >= 0; i--) {
+        var sum = x[i];
+        for (var k = i + 1; k <= math.min(n - 1, i + band); k++) {
+          sum -= factor[k * w1 + (k - i)] * x[k];
         }
+        x[i] = sum / factor[i * w1];
       }
       _removeMean(x);
       return x;
@@ -482,6 +701,45 @@ final class FreeSurface {
     }
     _removeMean(q);
     _normalise(q);
+    if (native) {
+      final start = Int32List(n + 1);
+      for (var i = 0; i < n; i++) {
+        start[i + 1] = start[i] + neighbours[i].length;
+      }
+      final adjacent = Int32List(start[n]);
+      for (var i = 0; i < n; i++) {
+        adjacent.setAll(start[i], neighbours[i]);
+      }
+      final rows = Float64List(steps * n);
+      final a = Float64List(steps);
+      final bs = Float64List(steps);
+      final size = nativeSurfaceLanczos(
+        n,
+        start,
+        adjacent,
+        cell2,
+        band,
+        steps,
+        q,
+        rows,
+        a,
+        bs,
+      );
+      if (size > 0) {
+        return _finishModes(
+          n,
+          cell2,
+          count,
+          sigma,
+          [
+            for (var m = 0; m < size; m++)
+              Float64List.sublistView(rows, m * n, (m + 1) * n),
+          ],
+          [for (var m = 0; m < size; m++) a[m]],
+          [for (var m = 0; m < size - 1; m++) bs[m]],
+        );
+      }
+    }
     var previous = Float64List(n);
     var b = 0.0;
     for (var m = 0; m < steps; m++) {
@@ -515,6 +773,21 @@ final class FreeSurface {
         q[i] = w[i] / b;
       }
     }
+    return _finishModes(n, cell2, count, sigma, basis, alpha, beta);
+  }
+
+  /// The modes from the Lanczos [basis] and its tridiagonal [alpha] and
+  /// [beta]: its eigenvectors, the highest of (L + σ)⁻¹ first, carried back
+  /// into the cells.
+  static (List<Float64List>, Float64List) _finishModes(
+    int n,
+    double cell2,
+    int count,
+    double sigma,
+    List<Float64List> basis,
+    List<double> alpha,
+    List<double> beta,
+  ) {
     final size = alpha.length;
     final (values, vectors) = _tridiagonalEigen(alpha, beta, size);
     // Highest of L⁻¹ first, which is lowest of L.
@@ -522,10 +795,10 @@ final class FreeSurface {
       ..sort((x, y) => values[y].compareTo(values[x]));
     final modes = <Float64List>[];
     final k2 = <double>[];
-    final scale = 1.0 / math.sqrt(grid.cell2);
+    final scale = 1.0 / math.sqrt(cell2);
     for (final r in order) {
       if (values[r] <= 0.0) continue;
-      final lambda = 1.0 / values[r];
+      final lambda = 1.0 / values[r] - sigma;
       final shape = Float64List(n);
       for (var j = 0; j < size; j++) {
         final weight = vectors[j * size + r];
@@ -807,3 +1080,18 @@ final class _Grid {
     return best < 0 ? 0.0 : values[best];
   }
 }
+
+/// Something that works out a cross-section's modes elsewhere and calls back
+/// with them: see [FreeSurface.solver].
+abstract interface class ModeSolver {
+  /// Works out [FreeSurface.solveModes] for these and calls [done] with the
+  /// result, later, on this isolate.
+  void solve(
+    int n,
+    List<List<int>> neighbours,
+    double cell2,
+    int count,
+    void Function((List<Float64List>, Float64List) modes) done, {
+    bool native = false,
+  });
+}
diff --git a/packages/flutter3d_physics/lib/src/fluid/gravity_field.dart b/packages/flutter3d_physics/lib/src/fluid/gravity_field.dart
new file mode 100644
index 000000000..0299199c9
--- /dev/null
+++ b/packages/flutter3d_physics/lib/src/fluid/gravity_field.dart
@@ -0,0 +1,76 @@
+import 'dart:math' as math;
+
+import 'package:vector_math/vector_math.dart';
+
+/// Gravity that is not the same everywhere: a uniform part, and the pull of
+/// every [Attractor] in it, added.
+///
+/// **Newton's law for each**: g = μ·r̂/r², μ = G·M the attractor's standard
+/// gravitational parameter, pointing at it. Inside an attractor of
+/// [Attractor.radius], uniform in density, it falls off to nought at the
+/// middle as μ·r/R³ (the shell outside pulls equally every way), so a drop
+/// that passes through one is not flung off by a pull growing without
+/// bound.
+///
+/// A liquid asks it where it is: each vessel's surface lies across its own
+/// local gravity, and each drop and parcel of a stream falls by the gravity
+/// at its own place.
+final class GravityField {
+  GravityField({Vector3? uniform, List<Attractor>? attractors})
+    : uniform = uniform ?? Vector3.zero(),
+      attractors = attractors ?? [];
+
+  /// Metres per second squared, everywhere.
+  final Vector3 uniform;
+
+  final List<Attractor> attractors;
+
+  /// The gravity at [point]: a vector of the caller's own.
+  Vector3 at(Vector3 point) {
+    final g = uniform.clone();
+    for (final a in attractors) {
+      final dx = a.position.x - point.x;
+      final dy = a.position.y - point.y;
+      final dz = a.position.z - point.z;
+      final r2 = dx * dx + dy * dy + dz * dz;
+      if (r2 <= 0.0) continue;
+      final r = math.sqrt(r2);
+      final k = r < a.radius
+          ? a.mu / (a.radius * a.radius * a.radius)
+          : a.mu / (r2 * r);
+      g
+        ..x += dx * k
+        ..y += dy * k
+        ..z += dz * k;
+    }
+    return g;
+  }
+}
+
+/// A mass that pulls: where it is, how hard, and how big.
+final class Attractor {
+  Attractor({required this.position, required this.mu, this.radius = 0.0});
+
+  /// An attractor of [mass] kilograms, by Newton's constant.
+  factory Attractor.ofMass({
+    required Vector3 position,
+    required double mass,
+    double radius = 0.0,
+  }) => Attractor(
+    position: position,
+    mu: gravitationalConstant * mass,
+    radius: radius,
+  );
+
+  /// Newton's G, m³/(kg·s²) (CODATA 2018).
+  static const double gravitationalConstant = 6.67430e-11;
+
+  /// Where it is; move it and the field moves with it.
+  final Vector3 position;
+
+  /// G·M, cubic metres per second squared.
+  final double mu;
+
+  /// Metres: inside it the pull falls to nought at the middle.
+  final double radius;
+}
diff --git a/packages/flutter3d_physics/lib/src/fluid/jet.dart b/packages/flutter3d_physics/lib/src/fluid/jet.dart
index 7b3df9a54..a15e32de4 100644
--- a/packages/flutter3d_physics/lib/src/fluid/jet.dart
+++ b/packages/flutter3d_physics/lib/src/fluid/jet.dart
@@ -3,7 +3,9 @@ import 'dart:math' as math;
 import 'package:vector_math/vector_math.dart';
 
 import '../portable_math.dart';
+import 'atmosphere.dart';
 import 'fluid_medium.dart';
+import 'wetting.dart';
 
 /// When something thrown at [velocity] from [height] reaches [floor] under
 /// gravity [g] pointing down: the later root of height + v_y·t − g t²/2 =
@@ -24,6 +26,17 @@ abstract interface class JetReceiver {
   /// receiver's surface: whether its underside has.
   bool catches(Vector3 point, double radius);
 
+  /// Whether anything within [distance] of [centre] (world) could be
+  /// caught: false only when it certainly cannot. What a parcel asks
+  /// first, so the receivers far from it are not asked at every point of
+  /// its way.
+  bool reaches(Vector3 centre, double distance);
+
+  /// Whether a drop of [radius] at [point] (world) touches this receiver's
+  /// glass from inside it: water wets glass, and a drop held there by the
+  /// wall runs down into the liquid as a film.
+  bool wets(Vector3 point, double radius);
+
   /// Takes [volume] cubic metres of [medium] carrying [concentrations],
   /// arriving at [point] moving at [velocity].
   void receive(
@@ -46,6 +59,10 @@ abstract interface class JetObstacle {
   /// for everything in flight together, so the walls far from it are not
   /// asked again for each parcel, piece and pass.
   bool reaches(Vector3 centre, double distance);
+
+  /// What it is made of: how a liquid wets it, and how hard its edge holds
+  /// a drop.
+  SolidSurface get solid;
 }
 
 /// [obstacles] that something within [distance] of [centre] could touch.
@@ -192,10 +209,29 @@ final class Jet {
       return;
     }
     _emitted += volume;
+    _fresh = true;
     final speed = math.max(velocity.length, 1e-6);
     final w = math.max(width, 1e-6);
+    // **Laminar or turbulent, from how it leaves.** Under a Reynolds number
+    // of 2300 the stream is smooth, and parts where its own ripples have
+    // grown e¹² times, as [breakupGrowth] counts. Past 4000 it leaves the
+    // lip already disturbed, and parts sooner, at L/D = 8.51·We^0.32
+    // (Grant and Middleman, 1966, for turbulent jets). Between the two the
+    // length runs from one correlation to the other with Re.
+    final m = medium ?? this.medium;
+    final d = 2.0 * math.sqrt(flow / (speed * math.pi));
+    final re = m.density * speed * d / m.viscosity;
+    var intact = double.infinity;
+    if (re > 2300.0 && m.surfaceTension > 0.0) {
+      final we = m.density * speed * speed * d / m.surfaceTension;
+      final laminar = 12.0 * d * (math.sqrt(we) + 3.0 * we / re);
+      final turbulent = 8.51 * d * Portable.pow(we, 0.32);
+      final t = ((re - 2300.0) / 1700.0).clamp(0.0, 1.0);
+      intact = laminar + t * (turbulent - laminar);
+    }
     _parcels.add(
       _Parcel(
+        intact: intact,
         position: point.clone(),
         velocity: velocity.clone(),
         volume: volume,
@@ -216,8 +252,11 @@ final class Jet {
     required Vector3 gravity,
     List<JetObstacle> obstacles = const [],
     List<JetReceiver> receivers = const [],
+    Atmosphere? air,
+    Vector3 Function(Vector3 point)? gravityAt,
   }) {
     final drops = <JetDrop>[];
+    _retract(dt);
     var walls = obstacles;
     if (_parcels.isNotEmpty) {
       // Every parcel, and as far as any moves this step, in one ball.
@@ -241,12 +280,46 @@ final class Jet {
       final rho = p.medium.density;
       final sigma = p.medium.surfaceTension;
       final mu = p.medium.viscosity;
-      p.velocity.addScaled(gravity, dt);
+      // Its own gravity, where it is, when gravity is not one vector.
+      p.velocity.addScaled(gravityAt?.call(p.position) ?? gravity, dt);
       p.previous.setFrom(p.position);
       p.age += dt;
+      p.travelled += p.velocity.length * dt;
       final section = p.section;
       final radius = math.sqrt(section / math.pi);
       var touched = false;
+      // **The air across it**, as on a long cylinder: what blows across a
+      // stream bends it, at ½·C_d·ρ_a·u⊥²·d a metre over its ρ·πd²/4,
+      // White's C_d for a cylinder. Along it the air only rubs, a skin
+      // friction that over the centimetres of a pour comes to nothing.
+      if (air != null && !p.onWall && radius > 0.0) {
+        final speed = p.velocity.length;
+        final u = p.velocity - air.windAt(p.position);
+        if (speed > 0.0) {
+          u.addScaled(p.velocity, -u.dot(p.velocity) / (speed * speed));
+        }
+        final across = u.length;
+        if (across > 0.0) {
+          final d = 2.0 * radius;
+          final re = air.density * across * d / air.viscosity;
+          final k =
+              -2.0 *
+              Atmosphere.cylinderDrag(re) *
+              air.density *
+              across /
+              (math.pi * rho * d);
+          p.velocity.addScaled(u, k * dt);
+        }
+      }
+      // Its own walls: within what it moves this step and the three radii a
+      // clinging parcel is looked for by. Every wall near the whole stream,
+      // asked for every piece of every parcel, cost the tail of a pour a
+      // third of a frame.
+      final near = obstaclesNear(
+        walls,
+        p.position,
+        p.velocity.length * dt + 3.0 * radius,
+      );
       // **In pieces no longer than its own radius**, held by the walls after
       // each. A stream falls five millimetres a step into a test tube whose
       // glass is half a millimetre: moved in one go, a parcel above the
@@ -255,7 +328,7 @@ final class Jet {
       final pieces = (p.velocity.length * dt / radius).ceil().clamp(1, 16);
       for (var k = 0; k < pieces; k++) {
         p.position.addScaled(p.velocity, dt / pieces);
-        for (final wall in walls) {
+        for (final wall in near) {
           final hit = wall.touch(p.position, radius);
           if (hit == null) continue;
           p.position.addScaled(hit.normal, hit.depth);
@@ -273,7 +346,7 @@ final class Jet {
         final contact = 0.1 * radius;
         final reach = 2.0 * radius;
         var held = false;
-        for (final wall in walls) {
+        for (final wall in near) {
           final near = wall.touch(p.position, radius + contact);
           if (near != null) {
             held = true;
@@ -281,7 +354,7 @@ final class Jet {
           }
         }
         if (!held && p.velocity.length < clingSpeed(2.0 * radius)) {
-          for (final wall in walls) {
+          for (final wall in near) {
             final hit = wall.touch(p.position, radius + reach);
             if (hit == null) continue;
             p.position.addScaled(hit.normal, hit.depth - reach);
@@ -310,10 +383,22 @@ final class Jet {
       final radius = math.sqrt(p.section / math.pi);
       final way = p.position - p.previous;
       final looks = (way.length / radius).ceil().clamp(1, 16);
+      // Only the receivers its way passes near: every point of every
+      // parcel's way asked of every glass on the bench was a third of a
+      // pour's cost.
+      final middle = (p.position + p.previous)..scale(0.5);
+      final near = [
+        for (final r in receivers)
+          if (r.reaches(middle, 0.5 * way.length + radius)) r,
+      ];
       search:
-      for (var k = 1; k <= looks; k++) {
-        final at = p.previous + way * (k / looks);
-        for (final r in receivers) {
+      for (var k = 1; k <= looks && near.isNotEmpty; k++) {
+        // One point moved along, not one made per look.
+        final at = _look
+          ..setFrom(way)
+          ..scale(k / looks)
+          ..add(p.previous);
+        for (final r in near) {
           if (r.catches(at, radius)) {
             into = r;
             break search;
@@ -355,7 +440,7 @@ final class Jet {
         continue;
       }
       // A rivulet on a wall does not part: the wall holds it.
-      if (!p.onWall && p.growth >= breakupGrowth) {
+      if (!p.onWall && (p.growth >= breakupGrowth || p.travelled >= p.intact)) {
         // Drops of 1.89 diameters, as many as its volume makes.
         final d = 2.0 * math.sqrt(p.section / math.pi) * 1.89;
         final one = math.pi * d * d * d / 6.0;
@@ -381,6 +466,85 @@ final class Jet {
     return drops;
   }
 
+  final Vector3 _look = Vector3.zero();
+
+  /// Whether anything left the lip since the last step: the newest parcel
+  /// is held to the lip while it does, and its end is free once it stops.
+  bool _fresh = false;
+
+  /// **A free end draws back into the stream** (Keller, 1983): surface
+  /// tension pulls a thread's end in at √(σ/ρr), gathering what it passes
+  /// into a bulb. The upper end of a stretch held neither by the lip nor by
+  /// a wall gives as much of its liquid to its neighbour as that speed
+  /// covers of its length in the step, and goes once it has given it all.
+  /// Without it the tail of a pour, cut off as the glass came back up, fell
+  /// whole, as wide at its end as anywhere, like a bent rod of glass.
+  void _retract(double dt) {
+    final fresh = _fresh;
+    _fresh = false;
+    bool newerFree(int i) =>
+        (i == _parcels.length - 1 && !fresh) || _parcels[i].endsRun;
+    bool olderFree(int i) => i == 0 || _parcels[i - 1].endsRun;
+    var i = _parcels.length - 1;
+    while (i >= 1) {
+      final bulb = _parcels[i];
+      if (bulb.onWall || !newerFree(i)) {
+        i--;
+        continue;
+      }
+      // The bulb eats the thread ahead of it at the speed the thread's own
+      // radius gives, a parcel at a time, for as long as the step lasts.
+      var left = dt;
+      while (left > 0.0 && !olderFree(i)) {
+        final thread = _parcels[i - 1];
+        // The thread's far end is an end too: what is left is a drop.
+        if (thread.onWall || olderFree(i - 1)) break;
+        final radius = math.sqrt(thread.section / math.pi);
+        if (radius <= 0.0) break;
+        final speed = math.sqrt(
+          thread.medium.surfaceTension / (thread.medium.density * radius),
+        );
+        final length = math.max(thread.velocity.length, 1e-6) * thread.dt;
+        final whole = length / speed;
+        final eaten = whole <= left ? 1.0 : left / whole;
+        _gather(bulb, thread, thread.volume * eaten);
+        left -= whole * eaten;
+        if (eaten < 1.0) {
+          thread.dt *= 1.0 - eaten;
+          break;
+        }
+        // All of it: the bulb is where it was.
+        bulb.position.setFrom(thread.position);
+        bulb.previous.setFrom(thread.previous);
+        _parcels.removeAt(i - 1);
+        i--;
+      }
+      i--;
+    }
+  }
+
+  /// [amount] of [from]'s liquid into [into], with its momentum and what is
+  /// dissolved in it.
+  static void _gather(_Parcel into, _Parcel from, double amount) {
+    if (amount <= 0.0) return;
+    final total = into.volume + amount;
+    into.velocity
+      ..scale(into.volume / total)
+      ..addScaled(from.velocity, amount / total);
+    into.concentrations = {
+      for (final k in {
+        ...into.concentrations.keys,
+        ...from.concentrations.keys,
+      })
+        k:
+            ((into.concentrations[k] ?? 0.0) * into.volume +
+                (from.concentrations[k] ?? 0.0) * amount) /
+            total,
+    };
+    into.volume = total;
+    from.volume -= amount;
+  }
+
   /// The stream as runs of samples, lip first: each run is a stretch with
   /// nothing missing from it, ready to be swept into a tube.
   List<List<JetSample>> get runs {
@@ -418,6 +582,7 @@ final class Jet {
 
 final class _Parcel {
   _Parcel({
+    required this.intact,
     required this.position,
     required this.velocity,
     required this.volume,
@@ -431,15 +596,16 @@ final class _Parcel {
 
   /// What it is: which liquid, and what is dissolved in it.
   final FluidMedium medium;
-  final Map<String, double> concentrations;
+  Map<String, double> concentrations;
 
   final Vector3 position;
   final Vector3 velocity;
-  final double volume;
+  double volume;
 
   /// The step it left in: its length along the stream is its speed times
-  /// this, so its section is its volume over that.
-  final double dt;
+  /// this, so its section is its volume over that. Shortened as a bulb
+  /// eats into it, which leaves its section as it was.
+  double dt;
 
   /// How wide and thick a sheet it left as, and which way across.
   final double width;
@@ -448,6 +614,12 @@ final class _Parcel {
 
   double age = 0.0;
   double growth = 0.0;
+
+  /// How far it has come from the lip, and how far a stream that left as
+  /// it did goes before it parts: infinite for a laminar one, which parts
+  /// by [growth] instead.
+  double travelled = 0.0;
+  final double intact;
   bool onWall = false;
 
   /// Where it was at the start of the step.
diff --git a/packages/flutter3d_physics/lib/src/fluid/liquid_body.dart b/packages/flutter3d_physics/lib/src/fluid/liquid_body.dart
index dc6a138de..714374be1 100644
--- a/packages/flutter3d_physics/lib/src/fluid/liquid_body.dart
+++ b/packages/flutter3d_physics/lib/src/fluid/liquid_body.dart
@@ -3,6 +3,8 @@ import 'dart:math' as math;
 import 'package:vector_math/vector_math.dart';
 
 import '../portable_math.dart';
+import 'atmosphere.dart';
+import 'background/fluid_background.dart';
 import 'capillary.dart';
 import 'fluid_medium.dart';
 import 'free_surface.dart';
@@ -10,6 +12,7 @@ import 'jet.dart';
 import 'liquid_layer.dart';
 import 'outflow.dart';
 import 'vessel_shape.dart';
+import 'wetting.dart';
 
 /// What ran over a vessel's lip in one step, in the world.
 final class Spill {
@@ -178,6 +181,18 @@ final class LiquidBody implements JetReceiver {
     return _up.dot(q) - radius <= surface + 0.25 * radius;
   }
 
+  @override
+  bool wets(Vector3 point, double radius) {
+    final shape = this.shape;
+    if (shape is! RevolvedVessel) return false;
+    final q = _near(point, radius);
+    if (q == null || !shape.contains(q)) return false;
+    final at = shape.wallDistance(q);
+    // Held a radius off the glass, and so touching it within a radius and
+    // a quarter.
+    return at != null && at.distance > -1.25 * radius;
+  }
+
   /// Liquid arriving from a stream: added, first heaped where it lands —
   /// its own volume over the patch it strikes — and striking the surface
   /// with the momentum it comes down with, from where both spread as waves.
@@ -229,6 +244,9 @@ final class LiquidBody implements JetReceiver {
 
   /// Whether anything within [distance] of [centre] (world) could be at
   /// this vessel's walls: by the ball round its inside.
+  @override
+  bool reaches(Vector3 centre, double distance) => _reaches(centre, distance);
+
   bool _reaches(Vector3 centre, double distance) {
     final shape = this.shape;
     if (shape is! RevolvedVessel) return true;
@@ -356,6 +374,50 @@ final class LiquidBody implements JetReceiver {
     return spill;
   }
 
+  /// **What evaporates from its open surface in [dt]** into [air],
+  /// cubic metres of liquid, taken from the top layer's solvent: what is
+  /// dissolved stays, and grows stronger.
+  ///
+  /// Vapour leaves the surface by diffusing up the air standing over it to
+  /// the mouth, and from the mouth out into the room: Stefan's tube, a
+  /// column L tall over the surface's area A, then the mouth as a disc of
+  /// radius r, whose diffusive conductance is 4·D·r. In series, the rate
+  /// is Δc / (L/(D·A) + 1/(4·D·r)): about three microlitres an hour from
+  /// a test tube in room air. Applied a nanolitre at a time, about once a
+  /// second there, a few nanometres off the level; each step would wake a
+  /// sleeping glass to lower it by a fraction of that.
+  double evaporate(double dt, Atmosphere air) {
+    if (_layers.isEmpty) return 0.0;
+    final top = _layers.last;
+    final shape = this.shape;
+    if (shape is! RevolvedVessel) return 0.0;
+    final deficit = air.vapourDeficit(top.medium);
+    if (deficit <= 0.0) return 0.0;
+    final d = air.vapourDiffusivity;
+    final surfaceRadius = shape.radiusAt(height);
+    final mouth = shape.radiusAt(shape.top);
+    if (surfaceRadius <= 0.0 || mouth <= 0.0) return 0.0;
+    final edge = shape.lip(_up);
+    final column = math.max((edge?.height ?? shape.top) - height, 0.0);
+    final area = math.pi * surfaceRadius * surfaceRadius;
+    final resistance = column / (d * area) + 1.0 / (4.0 * d * mouth);
+    _evaporating += deficit / resistance / top.medium.density * dt;
+    if (_evaporating < 1e-12) return 0.0;
+    final gone = math.min(_evaporating, top.volume);
+    _evaporating = 0.0;
+    top.volume -= gone;
+    if (top.volume <= 0.0) _layers.removeLast();
+    if (_asleep) {
+      // A few nanometres lower and still asleep.
+      _sleptVolume = volume;
+    } else {
+      _relayIfMoved();
+    }
+    return gone;
+  }
+
+  double _evaporating = 0.0;
+
   bool _asleep = false;
   double _sleptVolume = double.nan;
   double _sleptDisplaced = double.nan;
@@ -432,10 +494,19 @@ final class LiquidBody implements JetReceiver {
 
   /// How far the meniscus stands over [point] (vessel frame) above the flat
   /// surface of the same volume — up at a wall the liquid wets, down at one
-  /// it does not, nought on average. For a round vessel, the exact
-  /// Young–Laplace surface for its radius at the surface ([TubeMeniscus]);
-  /// for another, the flat wall's ([wallMeniscus]) by distance from it.
+  /// it does not. For a round vessel standing upright, the exact
+  /// Young–Laplace surface for its radius at the surface ([TubeMeniscus]),
+  /// nought on average. Tipped, the surface cuts the glass in a long oval
+  /// and is no longer a surface of revolution about anything: the flat
+  /// wall's ([wallMeniscus]) by how far [point] is from the glass. Measured
+  /// by the distance from the axis there, it climbed the long sides of a
+  /// tipped tube by the radius's meniscus and stood out through the glass.
   double meniscusAt(Vector3 point) {
+    final shape = this.shape;
+    if (shape is RevolvedVessel && _up.y < 0.999) {
+      if (volume <= 0.0) return 0.0;
+      return _wallRise(shape, point) - _tippedMean(shape);
+    }
     final m = _meniscus();
     if (m == null) return 0.0;
     final r = math.sqrt(point.x * point.x + point.z * point.z);
@@ -452,6 +523,38 @@ final class LiquidBody implements JetReceiver {
   /// How deep [point] (vessel frame) is under the surface.
   double depthAbove(Vector3 point) => height - _up.dot(point);
 
+  double _wallRise(RevolvedVessel shape, Vector3 point) {
+    final at = shape.wallDistance(point);
+    if (at == null) return 0.0;
+    return wallMeniscus(medium, math.max(-at.distance, 0.0), _g);
+  }
+
+  /// The wall's meniscus averaged over a tipped surface, taken out of it so
+  /// that, like the upright one, it moves liquid about and adds none: left
+  /// in, a tube tipped half a radian drew a fortieth more than it held.
+  /// Kept until the surface is laid out again.
+  double _tippedMean(RevolvedVessel shape) {
+    final layout = surface.layout;
+    if (!identical(layout, _tippedFor) || _tippedG != _g) {
+      _tippedFor = layout;
+      _tippedG = _g;
+      _tipped = surface.meanOf((p) => _wallRise(shape, p)).mean;
+    }
+    return _tipped;
+  }
+
+  Object? _tippedFor;
+  double _tippedG = double.nan;
+  double _tipped = 0.0;
+
+  /// The most the meniscus stands above the flat surface anywhere.
+  double _meniscusPeak() => shape is RevolvedVessel && _up.y < 0.999
+      ? math.max(
+          wallMeniscus(medium, 0.0, _g) - _tippedMean(shape as RevolvedVessel),
+          0.0,
+        )
+      : (_meniscus()?.peak ?? 0.0);
+
   /// Menisci already solved, by the radius they were solved for, in steps of
   /// a hundredth of it; and the medium and gravity they were solved under.
   ///
@@ -472,16 +575,105 @@ final class LiquidBody implements JetReceiver {
     final radius = shape.radiusAt(height.clamp(shape.floor, shape.top));
     if (radius <= 0.0) return null;
     if (!identical(_menisciMedium, medium) ||
-        !((_menisciG - _g).abs() < 1e-3 * _g)) {
+        !((_menisciG - _g).abs() < 1e-3 * _g) ||
+        _menisciNative != nativeMeniscus) {
       _menisci.clear();
       _menisciMedium = medium;
       _menisciG = _g;
+      _menisciNative = nativeMeniscus;
     }
+    final native = nativeMeniscus;
     final key = (Portable.log(radius) / 0.01).round();
-    return _menisci[key] ??= TubeMeniscus(
+    final have = _menisci[key];
+    if (have != null) return have;
+    final bg = background;
+    if (bg != null) {
+      final shared =
+          _menisciShared[_meniscusId(medium, key, _menisciG, native)];
+      if (shared != null) return _menisci[key] = shared;
+      // **Asked of the background, not waited for**: until it comes, the
+      // nearest radius's meniscus stands in, or none.
+      _askMeniscus(bg, medium, key, _menisciG, native);
+      TubeMeniscus? nearest;
+      var gap = 1 << 30;
+      _menisci.forEach((k, m) {
+        if ((k - key).abs() < gap) {
+          gap = (k - key).abs();
+          nearest = m;
+        }
+      });
+      return nearest;
+    }
+    return _menisci[key] = _sharedMeniscus(medium, key, _menisciG, native);
+  }
+
+  bool _menisciNative = false;
+
+  /// Whether its menisci are solved natively where that was built: on the
+  /// platform's own sine, to within a tolerance of the Dart solve rather
+  /// than to the bit. Set by a world that may be stepped so
+  /// (`FluidWorld.nativeKernels`).
+  bool nativeMeniscus = false;
+
+  /// Where a meniscus not yet worked out is worked out instead of waited
+  /// for; set by a world that may be stepped so (`FluidWorld.background`).
+  FluidBackground? background;
+
+  static final Set<_MeniscusId> _menisciAsked = {};
+
+  static _MeniscusId _meniscusId(
+    FluidMedium medium,
+    int key,
+    double g,
+    bool native,
+  ) => (
+    medium.density,
+    medium.surfaceTension,
+    medium.contactAngle,
+    (g * 1000).roundToDouble(),
+    key,
+    native,
+  );
+
+  static void _askMeniscus(
+    FluidBackground bg,
+    FluidMedium medium,
+    int key,
+    double g,
+    bool native,
+  ) {
+    final id = _meniscusId(medium, key, g, native);
+    if (!_menisciAsked.add(id)) return;
+    bg.meniscus(medium, Portable.exp(key * 0.01), id.$4 / 1000, (m) {
+      _menisciAsked.remove(id);
+      _menisciShared[id] = m;
+    }, native: native);
+  }
+
+  /// **One meniscus for every vessel of the liquid and gravity**: the
+  /// shape depends on nothing else, and a bench's six tubes worked out the
+  /// same ones six times over, seven at the first frame, a tenth of a
+  /// second.
+  ///
+  /// Kept apart by whether they were solved natively: a world that must
+  /// replay to the bit never reads one solved for another.
+  static final Map<_MeniscusId, TubeMeniscus> _menisciShared = {};
+
+  static TubeMeniscus _sharedMeniscus(
+    FluidMedium medium,
+    int key,
+    double g,
+    bool native,
+  ) {
+    // Gravity to a part in a thousand, as a vessel's own cache keeps it.
+    final id = _meniscusId(medium, key, g, native);
+    final gKey = id.$4;
+    if (_menisciShared.length > 4096) _menisciShared.clear();
+    return _menisciShared[id] ??= TubeMeniscus(
       medium: medium,
       radius: Portable.exp(key * 0.01),
-      g: _menisciG,
+      g: gKey / 1000,
+      native: native,
     );
   }
 
@@ -520,7 +712,7 @@ final class LiquidBody implements JetReceiver {
     // nothing to ask the rim.
     final edge = shape.lip(_up);
     if (edge != null &&
-        height + surface.reach + (_meniscus()?.peak ?? 0.0) < edge.height) {
+        height + surface.reach + _meniscusPeak() < edge.height) {
       return Spill.none;
     }
     var flow = 0.0;
@@ -587,6 +779,9 @@ final class InsideWalls implements JetObstacle {
 
   final LiquidBody body;
 
+  @override
+  SolidSurface get solid => SolidSurface.glass;
+
   @override
   bool reaches(Vector3 centre, double distance) =>
       body._reaches(centre, distance + body.wallThickness);
@@ -629,6 +824,9 @@ final class OutsideWalls implements JetObstacle {
   final LiquidBody body;
   final double thickness;
 
+  @override
+  SolidSurface get solid => SolidSurface.glass;
+
   @override
   bool reaches(Vector3 centre, double distance) =>
       body._reaches(centre, distance + thickness);
@@ -663,3 +861,8 @@ final class OutsideWalls implements JetObstacle {
     );
   }
 }
+
+/// What a meniscus is kept by: the liquid's density, surface tension and
+/// contact angle, gravity to a part in a thousand, the radius's key, and
+/// whether it was solved natively.
+typedef _MeniscusId = (double, double, double, double, int, bool);
diff --git a/packages/flutter3d_physics/lib/src/fluid/native/pbf_backend.dart b/packages/flutter3d_physics/lib/src/fluid/native/pbf_backend.dart
new file mode 100644
index 000000000..6be1db8d3
--- /dev/null
+++ b/packages/flutter3d_physics/lib/src/fluid/native/pbf_backend.dart
@@ -0,0 +1,2 @@
+// The native kernels where `dart:ffi` is, none where it is not.
+export 'pbf_none.dart' if (dart.library.ffi) 'pbf_native.dart';
diff --git a/packages/flutter3d_physics/lib/src/fluid/native/pbf_native.dart b/packages/flutter3d_physics/lib/src/fluid/native/pbf_native.dart
new file mode 100644
index 000000000..e8c53a242
--- /dev/null
+++ b/packages/flutter3d_physics/lib/src/fluid/native/pbf_native.dart
@@ -0,0 +1,527 @@
+// The native Position Based Fluids kernels, `src/pbf_kernels.c`, as built by
+// `hook/build.dart`, bound through `@Native` and passed the fluid's own
+// buffers by address: nothing is copied in or out.
+import 'dart:ffi';
+import 'dart:typed_data';
+
+import '../pbf_kernels.dart';
+
+@Native<Int32 Function()>(symbol: 'f3d_pbf_version', isLeaf: true)
+external int _version();
+
+@Native<
+  Void Function(
+    Pointer<Double>,
+    Pointer<Int32>,
+    Pointer<Int32>,
+    Int32,
+    Pointer<Double>,
+    Pointer<Double>,
+  )
+>(symbol: 'f3d_pbf_densities', isLeaf: true)
+external void _densities(
+  Pointer<Double> x,
+  Pointer<Int32> start,
+  Pointer<Int32> list,
+  int n,
+  Pointer<Double> k,
+  Pointer<Double> density,
+);
+
+@Native<
+  Void Function(
+    Pointer<Double>,
+    Pointer<Int32>,
+    Pointer<Int32>,
+    Int32,
+    Pointer<Double>,
+    Pointer<Double>,
+    Pointer<Double>,
+  )
+>(symbol: 'f3d_pbf_normals', isLeaf: true)
+external void _normals(
+  Pointer<Double> x,
+  Pointer<Int32> start,
+  Pointer<Int32> list,
+  int n,
+  Pointer<Double> k,
+  Pointer<Double> density,
+  Pointer<Double> normal,
+);
+
+@Native<
+  Void Function(
+    Pointer<Double>,
+    Pointer<Int32>,
+    Pointer<Int32>,
+    Int32,
+    Pointer<Double>,
+    Pointer<Double>,
+    Pointer<Double>,
+    Pointer<Double>,
+    Pointer<Double>,
+    Pointer<Double>,
+    Double,
+  )
+>(symbol: 'f3d_pbf_forces', isLeaf: true)
+external void _forces(
+  Pointer<Double> x,
+  Pointer<Int32> start,
+  Pointer<Int32> list,
+  int n,
+  Pointer<Double> k,
+  Pointer<Double> density,
+  Pointer<Double> normal,
+  Pointer<Double> before,
+  Pointer<Double> after,
+  Pointer<Double> v,
+  double dt,
+);
+
+@Native<
+  Void Function(
+    Pointer<Double>,
+    Pointer<Int32>,
+    Pointer<Int32>,
+    Int32,
+    Pointer<Double>,
+    Pointer<Double>,
+  )
+>(symbol: 'f3d_pbf_lambdas', isLeaf: true)
+external void _lambdas(
+  Pointer<Double> p,
+  Pointer<Int32> start,
+  Pointer<Int32> list,
+  int n,
+  Pointer<Double> k,
+  Pointer<Double> lambda,
+);
+
+@Native<
+  Void Function(
+    Pointer<Double>,
+    Pointer<Int32>,
+    Pointer<Int32>,
+    Int32,
+    Pointer<Double>,
+    Pointer<Double>,
+    Pointer<Double>,
+  )
+>(symbol: 'f3d_pbf_deltas', isLeaf: true)
+external void _deltas(
+  Pointer<Double> p,
+  Pointer<Int32> start,
+  Pointer<Int32> list,
+  int n,
+  Pointer<Double> k,
+  Pointer<Double> lambda,
+  Pointer<Double> delta,
+);
+
+@Native<
+  Void Function(
+    Pointer<Double>,
+    Pointer<Double>,
+    Pointer<Int32>,
+    Pointer<Int32>,
+    Int32,
+    Pointer<Double>,
+    Double,
+    Pointer<Double>,
+  )
+>(symbol: 'f3d_pbf_viscosity', isLeaf: true)
+external void _viscosity(
+  Pointer<Double> p,
+  Pointer<Double> v,
+  Pointer<Int32> start,
+  Pointer<Int32> list,
+  int n,
+  Pointer<Double> k,
+  double share,
+  Pointer<Double> smoothed,
+);
+
+@Native<
+  Int32 Function(
+    Pointer<Double>,
+    Int32,
+    Double,
+    Pointer<Int32>,
+    Pointer<Int32>,
+    Int32,
+    Pointer<Int64>,
+  )
+>(symbol: 'f3d_pbf_neighbours', isLeaf: true)
+external int _neighbours(
+  Pointer<Double> x,
+  int n,
+  double radius,
+  Pointer<Int32> start,
+  Pointer<Int32> list,
+  int capacity,
+  Pointer<Int64> scratch,
+);
+
+@Native<
+  Int32 Function(
+    Pointer<Double>,
+    Int32,
+    Pointer<Int32>,
+    Pointer<Int32>,
+    Double,
+    Pointer<Int32>,
+    Pointer<Int32>,
+  )
+>(symbol: 'f3d_pbf_within', isLeaf: true)
+external int _within(
+  Pointer<Double> x,
+  int n,
+  Pointer<Int32> start,
+  Pointer<Int32> list,
+  double radius,
+  Pointer<Int32> outStart,
+  Pointer<Int32> out,
+);
+
+@Native<
+  Int32 Function(
+    Int32,
+    Pointer<Int32>,
+    Pointer<Int32>,
+    Double,
+    Int32,
+    Int32,
+    Pointer<Double>,
+    Pointer<Double>,
+    Pointer<Double>,
+    Pointer<Double>,
+    Pointer<Double>,
+  )
+>(symbol: 'f3d_surface_lanczos', isLeaf: true)
+external int _surfaceLanczos(
+  int n,
+  Pointer<Int32> start,
+  Pointer<Int32> adjacent,
+  double cell2,
+  int band,
+  int steps,
+  Pointer<Double> q0,
+  Pointer<Double> basis,
+  Pointer<Double> alpha,
+  Pointer<Double> beta,
+  Pointer<Double> scratch,
+);
+
+/// The Lanczos steps of `FreeSurface.solveModes` in C, into [basis],
+/// [alpha] and [beta]: how many ran, or -1 where there is no native code.
+int nativeSurfaceLanczos(
+  int n,
+  Int32List start,
+  Int32List adjacent,
+  double cell2,
+  int band,
+  int steps,
+  Float64List q0,
+  Float64List basis,
+  Float64List alpha,
+  Float64List beta,
+) {
+  if (!nativePbfAvailable) return -1;
+  final scratch = Float64List(n * (band + 1) + 2 * n);
+  return _surfaceLanczos(
+    n,
+    start.address,
+    (adjacent.isEmpty ? Int32List(1) : adjacent).address,
+    cell2,
+    band,
+    steps,
+    q0.address,
+    basis.address,
+    alpha.address,
+    (beta.isEmpty ? Float64List(1) : beta).address,
+    scratch.address,
+  );
+}
+
+@Native<
+  Int32 Function(
+    Double,
+    Double,
+    Double,
+    Int32,
+    Pointer<Double>,
+    Pointer<Double>,
+    Int32,
+    Pointer<Double>,
+  )
+>(symbol: 'f3d_meniscus', isLeaf: true)
+external int _meniscus(
+  double radius,
+  double bond,
+  double contactAngle,
+  int samples,
+  Pointer<Double> rs,
+  Pointer<Double> zs,
+  int capacity,
+  Pointer<Double> apex,
+);
+
+/// `TubeMeniscus`'s solve in C: the apex curvature and the surface's
+/// points, or null where there is no native code.
+({double apexCurvature, List<double> r, List<double> z})? nativeMeniscus(
+  double radius,
+  double bond,
+  double contactAngle,
+  int samples,
+) {
+  if (!nativePbfAvailable) return null;
+  var capacity = samples * 4;
+  final apex = Float64List(1);
+  while (true) {
+    final rs = Float64List(capacity);
+    final zs = Float64List(capacity);
+    final count = _meniscus(
+      radius,
+      bond,
+      contactAngle,
+      samples,
+      rs.address,
+      zs.address,
+      capacity,
+      apex.address,
+    );
+    if (count <= capacity) {
+      return (
+        apexCurvature: apex[0],
+        r: List<double>.of(Float64List.sublistView(rs, 0, count)),
+        z: List<double>.of(Float64List.sublistView(zs, 0, count)),
+      );
+    }
+    capacity = count;
+  }
+}
+
+@Native<Int32 Function()>(symbol: 'f3d_pbf_lanes', isLeaf: true)
+external int _lanes();
+
+@Native<Int32 Function(Int32)>(symbol: 'f3d_pbf_set_lanes', isLeaf: true)
+external int _setLanes(int lanes);
+
+/// How many neighbours the native pair loops take at a time: chosen by the
+/// running processor (four with AVX2, which measured as fast as AVX-512F's
+/// eight; two with SSE2 or NEON), or 0 where there is no native code.
+int get nativePbfLanes => nativePbfAvailable ? _lanes() : 0;
+
+/// Sets [nativePbfLanes] to [lanes] where the processor has them, 0 for its
+/// own choice, and returns what is now in use: for a test to hold each
+/// width to the Dart kernels. One setting for the whole process.
+int setNativePbfLanes(int lanes) => nativePbfAvailable ? _setLanes(lanes) : 0;
+
+/// Whether the native kernels were built and load: false where the build
+/// had no C compiler, and asked once.
+final bool nativePbfAvailable = () {
+  try {
+    return _version() == 6;
+  } on Object {
+    return false;
+  }
+}();
+
+/// [PbfKernels] in C, vectorised: [DartPbfKernels]' results to within a
+/// tolerance, several times as fast.
+final class NativePbfKernels implements PbfKernels {
+  NativePbfKernels(PbfConstants k)
+    : _k = Float64List.fromList([
+        k.h,
+        k.h2,
+        k.restDensity,
+        k.mass,
+        k.norm,
+        k.gamma,
+        k.restStiffness,
+        k.poly6,
+        k.spiky,
+        k.cohesion,
+        k.h6,
+        k.wq,
+      ]);
+
+  final Float64List _k;
+
+  // Kept between calls, grown as the fluid does.
+  Int32List _list = Int32List(1024);
+  Int64List _scratch = Int64List(5);
+
+  @override
+  (Int32List, Int32List) within(
+    Float64List x,
+    int n,
+    Int32List start,
+    Int32List list,
+    double radius,
+  ) {
+    final outStart = Int32List(n + 1);
+    final out = Int32List(list.length + 1);
+    final count = _within(
+      x.address,
+      n,
+      start.address,
+      _rows(list).address,
+      radius,
+      outStart.address,
+      out.address,
+    );
+    return (outStart, Int32List.sublistView(out, 0, count));
+  }
+
+  @override
+  (Int32List, Int32List) neighbours(Float64List x, int n, double radius) {
+    final start = Int32List(n + 1);
+    if (n == 0) return (start, Int32List(0));
+    if (_scratch.length < 5 * n) _scratch = Int64List(5 * n);
+    var count = _neighbours(
+      x.address,
+      n,
+      radius,
+      start.address,
+      _list.address,
+      _list.length,
+      _scratch.address,
+    );
+    if (count > _list.length) {
+      _list = Int32List(count * 2);
+      count = _neighbours(
+        x.address,
+        n,
+        radius,
+        start.address,
+        _list.address,
+        _list.length,
+        _scratch.address,
+      );
+    }
+    return (start, Int32List.fromList(Int32List.sublistView(_list, 0, count)));
+  }
+
+  // A list with nothing in it has no address to give; one element stands in.
+  static final Int32List _none = Int32List(1);
+  static Int32List _rows(Int32List list) => list.isEmpty ? _none : list;
+
+  @override
+  void densities(
+    Float64List x,
+    Int32List start,
+    Int32List list,
+    int n,
+    Float64List density,
+  ) => _densities(
+    x.address,
+    start.address,
+    _rows(list).address,
+    n,
+    _k.address,
+    density.address,
+  );
+
+  @override
+  void normals(
+    Float64List x,
+    Int32List start,
+    Int32List list,
+    int n,
+    Float64List density,
+    Float64List normal,
+  ) => _normals(
+    x.address,
+    start.address,
+    _rows(list).address,
+    n,
+    _k.address,
+    density.address,
+    normal.address,
+  );
+
+  @override
+  void forces(
+    Float64List x,
+    Int32List start,
+    Int32List list,
+    int n,
+    Float64List density,
+    Float64List normal,
+    Float64List before,
+    Float64List after,
+    Float64List v,
+    double dt,
+  ) => _forces(
+    x.address,
+    start.address,
+    _rows(list).address,
+    n,
+    _k.address,
+    density.address,
+    normal.address,
+    before.address,
+    after.address,
+    v.address,
+    dt,
+  );
+
+  @override
+  void lambdas(
+    Float64List p,
+    Int32List start,
+    Int32List list,
+    int n,
+    Float64List lambda,
+  ) => _lambdas(
+    p.address,
+    start.address,
+    _rows(list).address,
+    n,
+    _k.address,
+    lambda.address,
+  );
+
+  @override
+  void deltas(
+    Float64List p,
+    Int32List start,
+    Int32List list,
+    int n,
+    Float64List lambda,
+    Float64List delta,
+  ) => _deltas(
+    p.address,
+    start.address,
+    _rows(list).address,
+    n,
+    _k.address,
+    lambda.address,
+    delta.address,
+  );
+
+  @override
+  void viscosity(
+    Float64List p,
+    Float64List v,
+    Int32List start,
+    Int32List list,
+    int n,
+    double share,
+    Float64List smoothed,
+  ) => _viscosity(
+    p.address,
+    v.address,
+    start.address,
+    _rows(list).address,
+    n,
+    _k.address,
+    share,
+    smoothed.address,
+  );
+}
+
+/// The native kernels for [k], or null where there are none.
+PbfKernels? nativePbfKernels(PbfConstants k) =>
+    nativePbfAvailable ? NativePbfKernels(k) : null;
diff --git a/packages/flutter3d_physics/lib/src/fluid/native/pbf_none.dart b/packages/flutter3d_physics/lib/src/fluid/native/pbf_none.dart
new file mode 100644
index 000000000..ee6938d1b
--- /dev/null
+++ b/packages/flutter3d_physics/lib/src/fluid/native/pbf_none.dart
@@ -0,0 +1,38 @@
+// Where there is no `dart:ffi` (the web): no native kernels.
+import 'dart:typed_data';
+
+import '../pbf_kernels.dart';
+
+/// Always false here.
+const bool nativePbfAvailable = false;
+
+/// None here.
+PbfKernels? nativePbfKernels(PbfConstants k) => null;
+
+/// No native code here: -1.
+int nativeSurfaceLanczos(
+  int n,
+  Int32List start,
+  Int32List adjacent,
+  double cell2,
+  int band,
+  int steps,
+  Float64List q0,
+  Float64List basis,
+  Float64List alpha,
+  Float64List beta,
+) => -1;
+
+/// No native code here: null.
+({double apexCurvature, List<double> r, List<double> z})? nativeMeniscus(
+  double radius,
+  double bond,
+  double contactAngle,
+  int samples,
+) => null;
+
+/// No native code here: 0.
+int get nativePbfLanes => 0;
+
+/// No native code here: 0.
+int setNativePbfLanes(int lanes) => 0;
diff --git a/packages/flutter3d_physics/lib/src/fluid/particle_fluid.dart b/packages/flutter3d_physics/lib/src/fluid/particle_fluid.dart
index ccf8aaafc..4955e906c 100644
--- a/packages/flutter3d_physics/lib/src/fluid/particle_fluid.dart
+++ b/packages/flutter3d_physics/lib/src/fluid/particle_fluid.dart
@@ -1,15 +1,27 @@
 import 'dart:math' as math;
+import 'dart:typed_data';
 
 import 'package:vector_math/vector_math.dart';
 
+import '../portable_math.dart';
+import 'atmosphere.dart';
 import 'fluid_medium.dart';
 import 'jet.dart';
+import 'native/pbf_backend.dart';
+import 'pbf_kernels.dart';
+import 'wetting.dart';
 
 /// A flat surface particles rest on — a bench, a floor: the points with
 /// `normal · p ≥ offset` are clear of it.
 final class PlaneObstacle implements JetObstacle {
-  PlaneObstacle({required Vector3 normal, required this.offset})
-    : normal = normal.normalized();
+  PlaneObstacle({
+    required Vector3 normal,
+    required this.offset,
+    this.solid = SolidSurface.glass,
+  }) : normal = normal.normalized();
+
+  @override
+  final SolidSurface solid;
 
   final Vector3 normal;
   final double offset;
@@ -58,6 +70,7 @@ final class ParticleFluid {
     required this.spacing,
     this.iterations = 4,
     this.substeps = 2,
+    this.native = false,
   }) : h = 2.0 * spacing {
     _gamma = _cohesionForWorkOfCohesion();
     // The kernel summed over the lattice at rest: what a particle's density
@@ -119,6 +132,16 @@ final class ParticleFluid {
   final List<_V> _x = [];
   final List<_V> _v = [];
 
+  /// Each particle's liquid, cubic metres: [particleVolume], but for the
+  /// last of a run of drops, which is what was left in the bank.
+  final List<double> _vol = [];
+
+  /// Where and how fast the last liquid came in, and whether any came in
+  /// since the last step: the bank is let go there once none does.
+  final _V _lastAt = _V(0, 0, 0);
+  final _V _lastVelocity = _V(0, 0, 0);
+  bool _injected = false;
+
   /// What is dissolved in each particle, as concentrations; and in the
   /// bank, as amounts.
   final List<Map<String, double>> _c = [];
@@ -130,12 +153,68 @@ final class ParticleFluid {
   double get particleVolume => spacing * spacing * spacing;
   double get _mass => medium.density * particleVolume;
 
-  /// The particles' places.
-  List<Vector3> get positions => [for (final p in _x) p.toVector3()];
-  int get count => _x.length;
+  /// Where the liquid is: each particle's place, then each drop's middle.
+  List<Vector3> get positions => [
+    for (final p in _x) p.toVector3(),
+    for (final d in _drops) d.x.toVector3(),
+  ];
+
+  /// How many places [positions] has: particles and drops.
+  int get count => _x.length + _drops.length;
 
-  /// Cubic metres here: every particle and the bank.
-  double get volume => _x.length * particleVolume + _bank;
+  /// How many of them are drops, each one body: the rest are particles.
+  int get dropCount => _drops.length;
+
+  /// Cubic metres here: every particle, every drop and the bank.
+  double get volume =>
+      _vol.fold(0.0, (s, v) => s + v) +
+      _drops.fold(0.0, (s, d) => s + d.volume) +
+      _bank;
+
+  /// The liquid at each of [positions], cubic metres.
+  List<double> get volumes =>
+      List.unmodifiable([..._vol, for (final d in _drops) d.volume]);
+
+  /// What is dissolved in the particles and drops, as concentrations over
+  /// all of them: for drawing them the colour of what they are.
+  Map<String, double> get concentrations {
+    final all = [..._c, for (final d in _drops) d.c];
+    if (all.isEmpty) return const {};
+    final sum = <String, double>{};
+    for (final c in all) {
+      c.forEach((k, v) => sum[k] = (sum[k] ?? 0.0) + v);
+    }
+    return {for (final e in sum.entries) e.key: e.value / all.length};
+  }
+
+  /// **A drop in flight is one body.** Falling, it does not feel its own
+  /// weight, and what would break it up is the air: it holds together while
+  /// its aerodynamic Weber number ρ_a·u²·d/σ is under about twelve (Pilch
+  /// and Erdman, 1987), and a four-millimetre drop at a metre a second is at
+  /// a fifteenth of one. So it moves as one, its drag a sphere's, its
+  /// evaporation a sphere's, its hold on a wall Furmidge's. Laid out as
+  /// particles it was dozens of bodies stepped at the capillary time,
+  /// which were most of what a pour cost; and a block of them, free in the
+  /// air, rang until it flew apart.
+  ///
+  /// Particles are for liquid on a wall: a block that lands on glass is
+  /// particles; one that leaves the wall again is a drop.
+  final List<_Drop> _drops = [];
+
+  /// The air last flown through, for the Weber number at [inject].
+  Atmosphere? _lastAir;
+
+  /// The critical aerodynamic Weber number.
+  static const double _breakupWeber = 12.0;
+
+  bool _isDrop(double volume, Vector3 position, Vector3 velocity) {
+    if (volume <= 0.0 || medium.surfaceTension <= 0.0) return false;
+    final air = _lastAir;
+    if (air == null) return true;
+    final d = Portable.pow(6.0 * volume / math.pi, 1.0 / 3.0);
+    final u = velocity - air.windAt(position);
+    return air.density * u.length2 * d / medium.surfaceTension < _breakupWeber;
+  }
 
   /// Cubic metres handed to receivers so far.
   double get received => _received;
@@ -144,13 +223,49 @@ final class ParticleFluid {
   /// [concentrations] dissolved in it: as many whole particles as it and
   /// the bank make, laid out round [position] at the spacing so none start
   /// on top of another, each carrying what the bank holds per cubic metre.
+  ///
+  /// Less than a drop of the capillary length is one drop, of exactly
+  /// [amount]: see [dropCount].
+  ///
+  /// [asParticles] lays it out as particles whatever it is: for liquid put
+  /// straight onto a wall.
   void inject(
     double amount,
     Vector3 position,
     Vector3 velocity, {
     Map<String, double> concentrations = const {},
+    bool asParticles = false,
   }) {
+    if (!asParticles && _isDrop(amount, position, velocity)) {
+      _drops.add(
+        _Drop(
+          _V(position.x, position.y, position.z),
+          _V(velocity.x, velocity.y, velocity.z),
+          amount,
+          Map.of(concentrations),
+        ),
+      );
+      return;
+    }
+    _addToParticles(amount, position, velocity, concentrations);
+  }
+
+  void _addToParticles(
+    double amount,
+    Vector3 position,
+    Vector3 velocity,
+    Map<String, double> concentrations,
+  ) {
     _bank += amount;
+    _injected = true;
+    _lastAt
+      ..x = position.x
+      ..y = position.y
+      ..z = position.z;
+    _lastVelocity
+      ..x = velocity.x
+      ..y = velocity.y
+      ..z = velocity.z;
     concentrations.forEach((key, c) {
       _bankAmounts[key] = (_bankAmounts[key] ?? 0.0) + c * amount;
     });
@@ -181,6 +296,7 @@ final class ParticleFluid {
             ),
           );
           _v.add(_V(velocity.x, velocity.y, velocity.z));
+          _vol.add(particleVolume);
           _c.add(carried);
           placed++;
         }
@@ -189,13 +305,30 @@ final class ParticleFluid {
   }
 
   /// Moves the particles on by [dt] under [gravity], against [obstacles],
-  /// into [receivers].
+  /// into [receivers], through [air] when there is any.
   void step(
     double dt, {
     required Vector3 gravity,
     List<JetObstacle> obstacles = const [],
     List<JetReceiver> receivers = const [],
+    Atmosphere? air,
+    Vector3 Function(Vector3 point)? gravityAt,
   }) {
+    // **What is less than a particle is let go too**, once no more liquid
+    // comes to make it one: as a particle of its own amount, where the last
+    // came in. Kept in the bank, the end of every run of drops, up to a
+    // particle's worth of it, was counted and was nowhere.
+    if (!_injected && _bank > 0.0) {
+      _x.add(_lastAt.copy());
+      _v.add(_lastVelocity.copy());
+      _vol.add(_bank);
+      _c.add({for (final e in _bankAmounts.entries) e.key: e.value / _bank});
+      _bank = 0.0;
+      _bankAmounts.clear();
+    }
+    _injected = false;
+    if (air != null) _lastAir = air;
+    _stepDrops(dt, gravity, obstacles, receivers, air, gravityAt);
     if (_x.isEmpty) return;
     // A quarter of the capillary time a substep at most, and never fewer
     // than asked. How far a particle goes in one is not held here: it is
@@ -228,27 +361,478 @@ final class ParticleFluid {
           (fastest + gravity.length * dt) * dt +
           spacing,
     );
+    _air = air;
+    _gravityAt = gravityAt;
+    if (air != null) _measureDrops(dt, air);
     for (var s = 0; s < count; s++) {
       _substep(sub, g, walls);
     }
-    // Into a vessel's liquid: handed over, whole.
+    // Into a vessel's liquid, or onto its glass inside, which runs down
+    // into it: handed over, whole.
     final radius = 0.5 * spacing;
     for (var i = _x.length - 1; i >= 0; i--) {
       final at = _x[i].toVector3();
       for (final r in receivers) {
-        if (!r.catches(at, radius)) continue;
-        r.receive(particleVolume, at, _v[i].toVector3(), medium, _c[i]);
-        _received += particleVolume;
+        if (!r.reaches(at, radius)) continue;
+        if (!r.catches(at, radius) && !r.wets(at, radius)) continue;
+        r.receive(_vol[i], at, _v[i].toVector3(), medium, _c[i]);
+        _received += _vol[i];
         _x.removeAt(i);
         _v.removeAt(i);
+        _vol.removeAt(i);
         _c.removeAt(i);
         break;
       }
     }
+    _clustersToDrops(walls);
+  }
+
+  /// Each drop moved on by [dt]: the air's drag and evaporation, a wall
+  /// holding it or letting it slide, the walls it meets, the receivers it
+  /// reaches; drops that touch run together, and a drop that touches the
+  /// particles or outgrows the capillary length becomes particles.
+  void _stepDrops(
+    double dt,
+    Vector3 gravity,
+    List<JetObstacle> obstacles,
+    List<JetReceiver> receivers,
+    Atmosphere? air,
+    Vector3 Function(Vector3 point)? gravityAt,
+  ) {
+    if (_drops.isEmpty) return;
+    _mergeDrops();
+    // Into the particles it touches.
+    for (var i = _drops.length - 1; i >= 0; i--) {
+      final d = _drops[i];
+      final reach = d.radius + 0.5 * spacing;
+      var touches = false;
+      for (var j = 0; j < _x.length && !touches; j++) {
+        touches = _x[j].distance2(d.x) < reach * reach;
+      }
+      if (!touches) continue;
+      _drops.removeAt(i);
+      _addToParticles(d.volume, d.x.toVector3(), d.v.toVector3(), d.c);
+    }
+    final rho = medium.density;
+    for (var i = _drops.length - 1; i >= 0; i--) {
+      final d = _drops[i];
+      final at = d.x.toVector3();
+      final g = gravityAt?.call(at) ?? gravity;
+      final r = d.radius;
+      var ax = g.x;
+      var ay = g.y;
+      var az = g.z;
+      if (air != null) {
+        final drag = air.dragOnSphere(d.v.toVector3(), at, 2.0 * r, rho);
+        ax += drag.x;
+        ay += drag.y;
+        az += drag.z;
+        _evaporate(d, dt, air);
+        if (d.volume <= 0.0) {
+          _drops.removeAt(i);
+          continue;
+        }
+      }
+      final walls = obstaclesNear(
+        obstacles,
+        at,
+        (d.v.length + g.length * dt) * dt + 2.0 * r,
+      );
+      // On a wall: held whole by its edge, or sliding with what of its
+      // weight along the wall the edge cannot hold. Wider than the
+      // capillary length, where its weight flattens it, it spreads there
+      // as particles.
+      final touch = _touchingDrop(d, walls);
+      if (touch != null &&
+          2.0 * r > medium.capillaryLength(math.max(g.length, 1e-9))) {
+        _drops.removeAt(i);
+        _addToParticles(d.volume, at, d.v.toVector3(), d.c);
+        continue;
+      }
+      if (touch != null) {
+        final n = touch.normal;
+        final into = g.x * n.x + g.y * n.y + g.z * n.z;
+        final gx = g.x - n.x * into;
+        final gy = g.y - n.y * into;
+        final gz = g.z - n.z * into;
+        final along = math.sqrt(gx * gx + gy * gy + gz * gz);
+        final mass = rho * d.volume;
+        final hold = touch.solid.retention(
+          medium,
+          2.0 * touch.solid.baseRadius(medium, d.volume),
+        );
+        if (mass * along <= hold || along <= 0.0) {
+          d.v
+            ..x = 0.0
+            ..y = 0.0
+            ..z = 0.0;
+        } else {
+          final k = 1.0 - hold / (mass * along);
+          d.v
+            ..x += gx * k * dt
+            ..y += gy * k * dt
+            ..z += gz * k * dt;
+          final off = _dot(d.v, n);
+          if (off < 0.0) {
+            d.v
+              ..x -= n.x * off
+              ..y -= n.y * off
+              ..z -= n.z * off;
+          }
+        }
+      } else {
+        d.v
+          ..x += ax * dt
+          ..y += ay * dt
+          ..z += az * dt;
+      }
+      // In pieces no longer than its radius, held out of the walls after
+      // each: what meets a wall loses the part of its speed into it.
+      final pieces = (d.v.length * dt / r).ceil().clamp(1, 64);
+      for (var k = 0; k < pieces; k++) {
+        d.x.addScaled(d.v, dt / pieces);
+        for (final o in walls) {
+          final hit = o.touch(d.x.toVector3(), r);
+          if (hit == null) continue;
+          d.x
+            ..x += hit.normal.x * hit.depth
+            ..y += hit.normal.y * hit.depth
+            ..z += hit.normal.z * hit.depth;
+          final off =
+              d.v.x * hit.normal.x +
+              d.v.y * hit.normal.y +
+              d.v.z * hit.normal.z;
+          if (off < 0.0) {
+            d.v
+              ..x -= hit.normal.x * off
+              ..y -= hit.normal.y * off
+              ..z -= hit.normal.z * off;
+          }
+        }
+      }
+      final now = d.x.toVector3();
+      for (final receiver in receivers) {
+        if (!receiver.reaches(now, r)) continue;
+        if (!receiver.catches(now, r) && !receiver.wets(now, r)) continue;
+        receiver.receive(d.volume, now, d.v.toVector3(), medium, d.c);
+        _received += d.volume;
+        _drops.removeAt(i);
+        break;
+      }
+    }
   }
 
-  void _substep(double dt, _V gravity, List<JetObstacle> obstacles) {
+  /// The wall [d] touches and its normal and solid there, if any.
+  ({_V normal, SolidSurface solid})? _touchingDrop(
+    _Drop d,
+    List<JetObstacle> walls,
+  ) {
+    final reach = d.radius * 1.05;
+    final at = d.x.toVector3();
+    for (final o in walls) {
+      final hit = o.touch(at, reach);
+      if (hit != null) {
+        return (
+          normal: _V(hit.normal.x, hit.normal.y, hit.normal.z),
+          solid: o.solid,
+        );
+      }
+    }
+    return null;
+  }
+
+  /// Drops that touch run together: their liquid, momentum and what is
+  /// dissolved, into one at their centre of volume.
+  void _mergeDrops() {
+    var merged = true;
+    while (merged) {
+      merged = false;
+      outer:
+      for (var i = 0; i < _drops.length; i++) {
+        for (var j = i + 1; j < _drops.length; j++) {
+          final a = _drops[i];
+          final b = _drops[j];
+          final reach = a.radius + b.radius;
+          if (a.x.distance2(b.x) >= reach * reach) continue;
+          final total = a.volume + b.volume;
+          final wa = a.volume / total;
+          final wb = b.volume / total;
+          a.x
+            ..x = a.x.x * wa + b.x.x * wb
+            ..y = a.x.y * wa + b.x.y * wb
+            ..z = a.x.z * wa + b.x.z * wb;
+          a.v
+            ..x = a.v.x * wa + b.v.x * wb
+            ..y = a.v.y * wa + b.v.y * wb
+            ..z = a.v.z * wa + b.v.z * wb;
+          a.c = {
+            for (final k in {...a.c.keys, ...b.c.keys})
+              k: (a.c[k] ?? 0.0) * wa + (b.c[k] ?? 0.0) * wb,
+          };
+          a.volume = total;
+          _drops.removeAt(j);
+          merged = true;
+          break outer;
+        }
+      }
+    }
+  }
+
+  /// A drop's evaporation in [dt]: a sphere's, π·d·D·Δc·Sh with Ranz and
+  /// Marshall's Sherwood number, what is dissolved left behind.
+  void _evaporate(_Drop d, double dt, Atmosphere air) {
+    final deficit = air.vapourDeficit(medium);
+    if (deficit <= 0.0) return;
+    final diffusivity = air.vapourDiffusivity;
+    final diameter = 2.0 * d.radius;
+    final wind = air.windAt(d.x.toVector3());
+    final through = _V(d.v.x - wind.x, d.v.y - wind.y, d.v.z - wind.z).length;
+    final re = air.density * through * diameter / air.viscosity;
+    final sc = air.viscosity / (air.density * diffusivity);
+    final sherwood = 2.0 + 0.6 * math.sqrt(re) * Portable.pow(sc, 1.0 / 3.0);
+    final rate = math.pi * diameter * diffusivity * deficit * sherwood;
+    final gone = math.min(rate / medium.density * dt, d.volume);
+    _evaporated += gone;
+    final kept = d.volume - gone;
+    if (kept > 0.0) {
+      d.c = {for (final e in d.c.entries) e.key: e.value * d.volume / kept};
+    }
+    d.volume = kept;
+  }
+
+  /// For each particle, the drop it is in, by the particle that stands for
+  /// the drop: particles nearer each other than a spacing and a half are
+  /// one, through any chain of them.
+  ///
+  /// **Each step on the way halved.** Which particle stands for a drop is
+  /// set by the joins alone, so shortcuts taken on the way change none;
+  /// walked to the end each time, a block of five hundred on a pane made
+  /// chains hundreds long, and finding the drops was a sixth of a step.
+  Int32List _dropRoots(Int32List start, Int32List list) {
+    final n = _x.length;
+    final parent = Int32List.fromList([for (var i = 0; i < n; i++) i]);
+    int root(int i) {
+      var r = i;
+      while (parent[r] != r) {
+        parent[r] = parent[parent[r]];
+        r = parent[r];
+      }
+      return r;
+    }
+
+    final close = 2.25 * spacing * spacing;
+    for (var i = 0; i < n; i++) {
+      for (var q = start[i]; q < start[i + 1]; q++) {
+        final j = list[q];
+        if (_x[i].distance2(_x[j]) < close) parent[root(i)] = root(j);
+      }
+    }
+    return Int32List.fromList([for (var i = 0; i < n; i++) root(i)]);
+  }
+
+  /// Particles gathered into a drop, a spacing and a half apart at most,
+  /// that touch no wall, become that drop: one body again, in flight.
+  void _clustersToDrops(List<JetObstacle> walls) {
     final n = _x.length;
+    if (n == 0 || medium.surfaceTension <= 0.0) return;
+    final (start, list) = _rows(_x);
+    final roots = _dropRoots(start, list);
+    final volume = <int, double>{};
+    final speed = <int, _V>{};
+    final onWall = <int>{};
+    for (var i = 0; i < n; i++) {
+      final r = roots[i];
+      volume[r] = (volume[r] ?? 0.0) + _vol[i];
+      (speed[r] ??= _V(0, 0, 0)).addScaled(_v[i], _vol[i]);
+      final near = obstaclesNear(walls, _x[i].toVector3(), spacing);
+      if (_contact(_x[i], near) != null) onWall.add(r);
+    }
+    final into = <int, _Drop>{};
+    for (final MapEntry(key: r, value: v) in volume.entries) {
+      if (onWall.contains(r)) continue;
+      final at = _x[r].toVector3();
+      if (_isDrop(v, at, (speed[r]! * (1.0 / v)).toVector3())) {
+        into[r] = _Drop(_V(0, 0, 0), _V(0, 0, 0), 0.0, {});
+      }
+    }
+    if (into.isEmpty) return;
+    for (var i = n - 1; i >= 0; i--) {
+      final d = into[roots[i]];
+      if (d == null) continue;
+      final w = _vol[i];
+      final total = d.volume + w;
+      final a = d.volume / total;
+      final b = w / total;
+      d.x
+        ..x = d.x.x * a + _x[i].x * b
+        ..y = d.x.y * a + _x[i].y * b
+        ..z = d.x.z * a + _x[i].z * b;
+      d.v
+        ..x = d.v.x * a + _v[i].x * b
+        ..y = d.v.y * a + _v[i].y * b
+        ..z = d.v.z * a + _v[i].z * b;
+      d.c = {
+        for (final k in {...d.c.keys, ..._c[i].keys})
+          k: (d.c[k] ?? 0.0) * a + (_c[i][k] ?? 0.0) * b,
+      };
+      d.volume = total;
+      _x.removeAt(i);
+      _v.removeAt(i);
+      _vol.removeAt(i);
+      _c.removeAt(i);
+    }
+    _drops.addAll(into.values);
+  }
+
+  /// Whether to run the loops over pairs natively where that was built
+  /// ([nativePbfAvailable]): several times as fast, and the same to within
+  /// a tolerance rather than to the bit, so not for a world that must
+  /// replay exactly.
+  final bool native;
+
+  /// What runs the loops over pairs: the Dart reference, or the native
+  /// kernels when [native] asks for them and they are there.
+  late PbfKernels kernels = () {
+    final k = PbfConstants(
+      h: h,
+      restDensity: medium.density,
+      mass: _mass,
+      norm: 1.0 / _latticeSum,
+      gamma: _gamma,
+      restStiffness: _restStiffness,
+    );
+    return (native ? nativePbfKernels(k) : null) ?? DartPbfKernels(k);
+  }();
+
+  /// [points] as one flat buffer of x, y, z in turn.
+  static Float64List _flat(List<_V> points) {
+    final out = Float64List(3 * points.length);
+    for (var i = 0; i < points.length; i++) {
+      final p = points[i];
+      out[3 * i] = p.x;
+      out[3 * i + 1] = p.y;
+      out[3 * i + 2] = p.z;
+    }
+    return out;
+  }
+
+  /// [flat] back into [points].
+  static void _unflat(Float64List flat, List<_V> points) {
+    for (var i = 0; i < points.length; i++) {
+      points[i]
+        ..x = flat[3 * i]
+        ..y = flat[3 * i + 1]
+        ..z = flat[3 * i + 2];
+    }
+  }
+
+  /// The neighbours of each of [points] within the kernel's reach, as
+  /// compressed rows: [PbfKernels]' layout.
+  ///
+  /// Searched afresh each time. Candidates kept from one search to the next
+  /// (Verlet's list, half the reach again) were measured and cost more
+  /// here: drops landing while others still fall move apart faster than
+  /// any skin outlasts, and the wider search came round nearly every time.
+  (Int32List, Int32List) _rows(List<_V> points) =>
+      kernels.neighbours(_flat(points), points.length, h);
+
+  /// The air the particles are being stepped through, and each particle's
+  /// drop's diameter: set at the start of a step, read by its substeps.
+  Atmosphere? _air;
+  Float64List _drop = Float64List(0);
+
+  /// The gravity at a point, when it is not one vector everywhere.
+  Vector3 Function(Vector3 point)? _gravityAt;
+
+  /// Cubic metres evaporated from the drops so far.
+  double get evaporated => _evaporated;
+  double _evaporated = 0.0;
+
+  /// **The drops, as drops**: particles nearer each other than a spacing
+  /// and a half are one, of their summed volume. A drop's drag goes with
+  /// its own size, d² against a mass of d³; worked out per particle, a
+  /// drop of thirty would be slowed as thirty drops each a third its size.
+  ///
+  /// And what each drop loses to the air in [dt]: a sphere's evaporation,
+  /// π·d·D·Δc·Sh, with Ranz and Marshall's Sherwood number
+  /// 2 + 0.6·Re^½·Sc^⅓ for its speed through the air. Taken from its
+  /// particles by their share, what is dissolved in them left behind.
+  void _measureDrops(double dt, Atmosphere air) {
+    final n = _x.length;
+    final (start, list) = _rows(_x);
+    final roots = _dropRoots(start, list);
+    final volume = <int, double>{};
+    final speed = <int, _V>{};
+    for (var i = 0; i < n; i++) {
+      final r = roots[i];
+      volume[r] = (volume[r] ?? 0.0) + _vol[i];
+      (speed[r] ??= _V(0, 0, 0)).addScaled(_v[i], _vol[i]);
+    }
+    _drop = Float64List(n);
+    final deficit = air.vapourDeficit(medium);
+    final d = air.vapourDiffusivity;
+    final sc = air.viscosity / (air.density * d);
+    final lost = <int, double>{};
+    for (final MapEntry(key: r, value: v) in volume.entries) {
+      final diameter = Portable.pow(6.0 * v / math.pi, 1.0 / 3.0);
+      if (deficit > 0.0) {
+        final u = speed[r]! * (1.0 / v);
+        final wind = air.windAt(Vector3.zero());
+        final through = _V(u.x - wind.x, u.y - wind.y, u.z - wind.z).length;
+        final re = air.density * through * diameter / air.viscosity;
+        final sherwood =
+            2.0 + 0.6 * math.sqrt(re) * Portable.pow(sc, 1.0 / 3.0);
+        final rate = math.pi * diameter * d * deficit * sherwood;
+        lost[r] = math.min(rate / medium.density * dt, v) / v;
+      }
+      volume[r] = diameter;
+    }
+    for (var i = 0; i < n; i++) {
+      final r = roots[i];
+      _drop[i] = volume[r]!;
+      final share = lost[r];
+      if (share != null && share > 0.0) {
+        final gone = _vol[i] * share;
+        _evaporated += gone;
+        // What is dissolved stays: the same amount in less liquid.
+        final kept = _vol[i] - gone;
+        if (kept > 0.0) {
+          _c[i] = {
+            for (final e in _c[i].entries) e.key: e.value * _vol[i] / kept,
+          };
+        }
+        _vol[i] = kept;
+      }
+    }
+    // A drop dried away is gone.
+    for (var i = n - 1; i >= 0; i--) {
+      if (_vol[i] > 0.0) continue;
+      _x.removeAt(i);
+      _v.removeAt(i);
+      _vol.removeAt(i);
+      _c.removeAt(i);
+    }
+    if (_x.length != n) _drop = Float64List(0);
+  }
+
+  void _substep(double dt, _V gravity, List<JetObstacle> all) {
+    final n = _x.length;
+    // **Each particle's own walls**, found once a substep: those within what
+    // it moves in one and two spacings more, which the density passes never
+    // carry it past. Asked of every wall for every particle at every pass,
+    // the profile of every glass on the bench was walked for drops that had
+    // scattered across it, and thirty of them took most of a frame.
+    final g = gravity.length;
+    final walls = [
+      for (var i = 0; i < n; i++)
+        all.isEmpty
+            ? all
+            : obstaclesNear(
+                all,
+                _x[i].toVector3(),
+                (_v[i].length + g * dt) * dt + 2.0 * spacing,
+              ),
+    ];
     // Where a particle starts inside a wall or under the floor, it is put
     // out first, its velocity left alone. A drop let go near the bottom of a
     // glass is laid out as a little block round where it parted, and a
@@ -257,114 +841,240 @@ final class ParticleFluid {
     // over a fifth of a millisecond, and it left at eighteen metres a
     // second.
     for (var i = 0; i < n; i++) {
-      _collide(_x[i], obstacles);
+      _collide(_x[i], walls[i]);
     }
+    // **What touches a wall is pinned to it.** A drop's edge on glass or
+    // the bench holds where it is until something pushes harder than the
+    // contact angle's hysteresis lets it, which nothing a millimetre drop
+    // weighs does: a particle touching a wall at the start of the substep
+    // moves only off it, or not at all. Left free along it, three
+    // particles that came down on the bench rolled away over each other as
+    // a wheel does, faster with every turn.
+    //
+    // **Unless the drop's weight along the wall is more than its edge can
+    // hold**, by Furmidge's σ·w·(cos θr − cos θa): then it slides, its
+    // particles kept out of the wall and free along it.
+    // The neighbours at these places, found once: for which drop each
+    // particle is in, and for the forces.
+    final (start, list) = _rows(_x);
+    final touching = [for (var i = 0; i < n; i++) _touching(_x[i], walls[i])];
+    final held = _held(touching, gravity, start, list);
+    final pinned = [
+      for (var i = 0; i < n; i++) held[i] ? touching[i]?.normal : null,
+    ];
+    // **Component by component, into buffers made once a substep.** The
+    // loops over pairs below run tens of thousands of times a frame; with a
+    // vector made for each difference, gradient and product, thirty drops
+    // made hundreds of thousands of objects a frame, and the collector's
+    // pauses were most of what a pour with drops cost.
+    // **The loops over pairs, by [kernels]**, over flat buffers: positions
+    // and velocities copied out of the particles before each call and back
+    // after, a few hundred numbers against the tens of thousands of pair
+    // terms the call works through.
     final rho0 = medium.density;
-    final m = _mass;
-    final norm = 1.0 / _latticeSum;
+    final ker = kernels;
     // Forces first: gravity, cohesion and curvature, on the velocities.
-    final grid = _Grid(h, _x);
-    final neighbours = [for (var i = 0; i < n; i++) grid.near(i, _x)];
-    final density = List<double>.filled(n, 0.0);
-    for (var i = 0; i < n; i++) {
-      var w = _poly6(0.0);
-      for (final j in neighbours[i]) {
-        w += _poly6(_x[i].distance2(_x[j]));
-      }
-      density[i] = rho0 * w * norm;
-    }
-    final normal = List<_V>.generate(n, (_) => _V(0, 0, 0));
+    final xs = _flat(_x);
+    final vs = _flat(_v);
+    final density = Float64List(n);
+    ker.densities(xs, start, list, n, density);
+    final normal = Float64List(3 * n);
+    ker.normals(xs, start, list, n, density, normal);
+    final before = Float64List(3 * n);
+    final after = Float64List(3 * n);
+    final air = _air;
     for (var i = 0; i < n; i++) {
-      for (final j in neighbours[i]) {
-        normal[i].addScaled(_spikyGradient(_x[i] - _x[j]), h * m / density[j]);
+      final here = _gravityAt?.call(_x[i].toVector3());
+      before[3 * i] = here?.x ?? gravity.x;
+      before[3 * i + 1] = here?.y ?? gravity.y;
+      before[3 * i + 2] = here?.z ?? gravity.z;
+      // The air, on the drop it is in: its drag over the drop's mass,
+      // which every particle of it feels alike.
+      if (air != null && i < _drop.length && _drop[i] > 0.0) {
+        final drag = air.dragOnSphere(
+          _v[i].toVector3(),
+          _x[i].toVector3(),
+          _drop[i],
+          rho0,
+        );
+        after[3 * i] = drag.x;
+        after[3 * i + 1] = drag.y;
+        after[3 * i + 2] = drag.z;
       }
     }
-    for (var i = 0; i < n; i++) {
-      final a = gravity.copy();
-      for (final j in neighbours[i]) {
-        final d = _x[i] - _x[j];
-        final r = d.length;
-        if (r < 1e-12) continue;
-        final k = 2.0 * rho0 / (density[i] + density[j]);
-        a
-          ..addScaled(d, -k * _gamma * m * _cohesion(r) / r)
-          ..addScaled(normal[i] - normal[j], -k * _gamma);
-      }
-      _v[i].addScaled(a, dt);
-    }
+    ker.forces(xs, start, list, n, density, normal, before, after, vs, dt);
+    _unflat(vs, _v);
     // Predict, then hold the density to the rest density.
     final p = [
-      for (var i = 0; i < n; i++) _advance(_x[i], _v[i], dt, obstacles),
+      for (var i = 0; i < n; i++)
+        if (pinned[i] case final wall?)
+          _pin(_advance(_x[i], _v[i], dt, walls[i]), _x[i], wall)
+        else
+          _advance(_x[i], _v[i], dt, walls[i]),
     ];
-    final lambda = List<double>.filled(n, 0.0);
-    final grid2 = _Grid(h, p);
-    final near = [for (var i = 0; i < n; i++) grid2.near(i, p)];
-    final dq = 0.3 * h;
-    final wq = _poly6(dq * dq);
+    final lambda = Float64List(n);
+    final (near, rows) = _rows(p);
+    final delta = Float64List(3 * n);
     for (var it = 0; it < iterations; it++) {
+      // C = ρ/ρ₀ − 1, only where it is compressed: see [PbfKernels].
+      final ps = _flat(p);
+      ker
+        ..lambdas(ps, near, rows, n, lambda)
+        ..deltas(ps, near, rows, n, lambda, delta);
       for (var i = 0; i < n; i++) {
-        // C = ρ/ρ₀ − 1 with ρ/ρ₀ the kernel sum over the lattice's: only
-        // where it is compressed. Both ways, a surface particle with half
-        // its neighbours missing is pulled in by half a spacing a pass and
-        // the liquid flies apart; a stretched surface is held by cohesion
-        // instead.
-        var w = _poly6(0.0);
-        var sum2 = 0.0;
-        final gi = _V(0, 0, 0);
-        for (final j in near[i]) {
-          final d = p[i] - p[j];
-          w += _poly6(d.length2);
-          final g = _spikyGradient(d) * norm;
-          sum2 += g.length2;
-          gi.add(g);
-        }
-        sum2 += gi.length2;
-        final c = math.max(w * norm - 1.0, 0.0);
-        lambda[i] = -c / (sum2 + 1e-6 * norm * norm / (h * h));
-      }
-      final delta = List<_V>.generate(n, (_) => _V(0, 0, 0));
-      for (var i = 0; i < n; i++) {
-        for (final j in near[i]) {
-          final d = p[i] - p[j];
-          final ratio = _poly6(d.length2) / wq;
-          // Macklin's artificial pressure, which keeps neighbours from
-          // clumping: a fiftieth of a constraint's worth. At his tenth it
-          // held still water a sixth thinner than its rest density.
-          final corr = -0.02 * ratio * ratio * ratio * ratio / _restStiffness;
-          // Δpᵢ = Σⱼ (λᵢ + λⱼ + s_corr) ∇W(pᵢ − pⱼ), in the same
-          // normalisation as the constraint.
-          delta[i].addScaled(
-            _spikyGradient(d),
-            (lambda[i] + lambda[j] + corr) * norm,
-          );
-        }
-      }
-      for (var i = 0; i < n; i++) {
-        p[i].add(delta[i]);
-        _collide(p[i], obstacles);
+        p[i]
+          ..x += delta[3 * i]
+          ..y += delta[3 * i + 1]
+          ..z += delta[3 * i + 2];
+        _collide(p[i], walls[i]);
+        if (pinned[i] case final wall?) _pin(p[i], _x[i], wall);
       }
     }
     // Velocities from the move, then XSPH's viscosity.
+    final inverse = 1.0 / dt;
     for (var i = 0; i < n; i++) {
-      _v[i] = (p[i] - _x[i]) * (1.0 / dt);
+      _v[i]
+        ..x = (p[i].x - _x[i].x) * inverse
+        ..y = (p[i].y - _x[i].y) * inverse
+        ..z = (p[i].z - _x[i].z) * inverse;
     }
     final share = math.min(
       0.5,
       medium.kinematicViscosity * dt / (spacing * spacing) * 50.0 + 0.01,
     );
-    final smoothed = [for (final v in _v) v.copy()];
+    final smoothed = Float64List(3 * n);
+    ker.viscosity(_flat(p), _flat(_v), near, rows, n, share, smoothed);
+    // A viscous liquid's velocity at a wall at rest is nil along it, and
+    // nothing goes on into it: what touches one keeps only the part of its
+    // velocity that leaves. Left its speed along the wall, a drop that fell
+    // on the bench slid off at five centimetres a second and never
+    // stopped, and ended up under another glass's foot, looking as if it
+    // were inside.
+    // A drop that slides keeps only out of the wall.
     for (var i = 0; i < n; i++) {
-      for (final j in near[i]) {
-        final w = _poly6(p[i].distance2(p[j])) * norm;
-        smoothed[i].addScaled(_v[j] - _v[i], share * w);
+      final v = _v[i]
+        ..x = smoothed[3 * i]
+        ..y = smoothed[3 * i + 1]
+        ..z = smoothed[3 * i + 2];
+      final wall = _contact(p[i], walls[i]);
+      if (wall != null) {
+        final into = _dot(v, wall);
+        if (held[i]) {
+          final off = math.max(into, 0.0);
+          v
+            ..x = wall.x * off
+            ..y = wall.y * off
+            ..z = wall.z * off;
+        } else if (into < 0.0) {
+          v
+            ..x -= wall.x * into
+            ..y -= wall.y * into
+            ..z -= wall.z * into;
+        }
+      }
+      // A drop its edge holds stands still, as a whole: pinning only the
+      // particles that touch let the others turn over them, and a drop of
+      // three on the bench rolled away.
+      if (held[i]) {
+        v
+          ..x = 0.0
+          ..y = 0.0
+          ..z = 0.0;
+      }
+      _x[i] = p[i];
+    }
+  }
+
+  /// The wall [p] touches and its normal there, if it touches one.
+  ({_V normal, JetObstacle wall})? _touching(_V p, List<JetObstacle> walls) {
+    final reach = 0.55 * spacing;
+    for (final o in walls) {
+      final hit = o.touch(p.toVector3(), reach);
+      if (hit != null) {
+        return (normal: _V(hit.normal.x, hit.normal.y, hit.normal.z), wall: o);
       }
     }
+    return null;
+  }
+
+  /// For each particle, whether the drop it is in is held where it is by
+  /// the wall it touches: its weight along the wall, ρ·V·g∥, no more than
+  /// the wall's [SolidSurface.retention] across the circle a drop of its
+  /// volume wets. Held, a drop stands still; on a level bench every drop
+  /// is, its weight being all into the bench.
+  List<bool> _held(
+    List<({_V normal, JetObstacle wall})?> touching,
+    _V gravity,
+    Int32List start,
+    Int32List list,
+  ) {
+    final n = _x.length;
+    final out = List<bool>.filled(n, false);
+    if (n == 0 || medium.surfaceTension <= 0.0) return out;
+    final dropOf = _dropRoots(start, list);
+    // By root, in arrays: summed in the particles' order, as before.
+    final volume = Float64List(n);
+    final normal = Float64List(3 * n);
+    final solid = List<SolidSurface?>.filled(n, null);
     for (var i = 0; i < n; i++) {
-      _v[i] = smoothed[i];
-      _x[i] = p[i];
+      final r = dropOf[i];
+      volume[r] += _vol[i];
+      final t = touching[i];
+      if (t == null) continue;
+      normal[3 * r] += t.normal.x;
+      normal[3 * r + 1] += t.normal.y;
+      normal[3 * r + 2] += t.normal.z;
+      solid[r] ??= t.wall.solid;
+    }
+    final holds = List<bool>.filled(n, false);
+    for (var r = 0; r < n; r++) {
+      final surface = solid[r];
+      if (surface == null) continue;
+      final sum = _V(normal[3 * r], normal[3 * r + 1], normal[3 * r + 2]);
+      final length = sum.length;
+      if (length <= 0.0) continue;
+      final nx = sum.x / length;
+      final ny = sum.y / length;
+      final nz = sum.z / length;
+      final at = _gravityAt?.call(_x[r].toVector3());
+      final g = at == null ? gravity : _V(at.x, at.y, at.z);
+      final into = g.x * nx + g.y * ny + g.z * nz;
+      final along = math.sqrt(math.max(g.length2 - into * into, 0.0));
+      final v = volume[r];
+      final weight = medium.density * v * along;
+      final width = 2.0 * surface.baseRadius(medium, v);
+      if (weight <= surface.retention(medium, width)) holds[r] = true;
+    }
+    for (var i = 0; i < n; i++) {
+      out[i] = holds[dropOf[i]];
+    }
+    return out;
+  }
+
+  /// The normal of the wall [p] touches, if it touches one. Put out a
+  /// radius from a wall, a particle touches it at a radius and a little.
+  _V? _contact(_V p, List<JetObstacle> obstacles) {
+    final reach = 0.55 * spacing;
+    for (final o in obstacles) {
+      final hit = o.touch(p.toVector3(), reach);
+      if (hit != null) return _V(hit.normal.x, hit.normal.y, hit.normal.z);
     }
+    return null;
   }
 
+  /// [p] moved back to where [from] was along the wall of normal [n]: off
+  /// it is the only way it goes.
+  _V _pin(_V p, _V from, _V n) {
+    final off = math.max(_dot(p - from, n), 0.0);
+    p
+      ..x = from.x + n.x * off
+      ..y = from.y + n.y * off
+      ..z = from.z + n.z * off;
+    return p;
+  }
+
+  static double _dot(_V a, _V b) => a.x * b.x + a.y * b.y + a.z * b.z;
+
   /// Where [x] moving at [v] is after [dt]: moved in pieces of two fifths
   /// of a spacing, put out of the walls after each. A wall holds what comes
   /// within a radius of it or half its thickness into it, a band wider than
@@ -463,54 +1173,18 @@ final class ParticleFluid {
   static double _pow9(double x) => _pow6(x) * x * x * x;
 }
 
-/// A uniform grid of cells as wide as the kernel, for finding neighbours.
-final class _Grid {
-  _Grid(this.cell, List<_V> points) {
-    for (var i = 0; i < points.length; i++) {
-      _cells.putIfAbsent(_key(points[i]), () => []).add(i);
-    }
-  }
+/// A drop small enough to be one body: where, how fast, how much, and
+/// what is dissolved in it.
+final class _Drop {
+  _Drop(this.x, this.v, this.volume, this.c);
 
-  final double cell;
-  final Map<int, List<int>> _cells = {};
-
-  int _key(_V p) =>
-      _pack((p.x / cell).floor(), (p.y / cell).floor(), (p.z / cell).floor());
-
-  /// By multiplication, as `spatial_grid.dart` does, and not by shifting
-  /// into the high bits: on the web an int's bitwise operations are 32 bits
-  /// wide, `x << 42` kept almost nothing of `x`, cells far apart shared a
-  /// key, a particle met the same neighbour several times over, and the
-  /// liquid read as many times its density and flew apart. Each index is
-  /// held to ±2¹⁶ cells and the key under 2⁵¹, which a double holds exactly.
-  static int _pack(int x, int y, int z) {
-    const span = 1 << 17;
-    const half = 1 << 16;
-    int wrap(int v) => (v + half) % span;
-    return (wrap(x) * span + wrap(y)) * span + wrap(z);
-  }
+  final _V x;
+  final _V v;
+  double volume;
+  Map<String, double> c;
 
-  /// The points within [cell] of point [i], itself left out.
-  List<int> near(int i, List<_V> points) {
-    final p = points[i];
-    final cx = (p.x / cell).floor();
-    final cy = (p.y / cell).floor();
-    final cz = (p.z / cell).floor();
-    final out = <int>[];
-    final reach2 = cell * cell;
-    for (var dx = -1; dx <= 1; dx++) {
-      for (var dy = -1; dy <= 1; dy++) {
-        for (var dz = -1; dz <= 1; dz++) {
-          final list = _cells[_pack(cx + dx, cy + dy, cz + dz)];
-          if (list == null) continue;
-          for (final j in list) {
-            if (j != i && points[j].distance2(p) < reach2) out.add(j);
-          }
-        }
-      }
-    }
-    return out;
-  }
+  /// The radius of the sphere it is.
+  double get radius => Portable.pow(3.0 * volume / (4.0 * math.pi), 1.0 / 3.0);
 }
 
 /// A vector in double precision, for the solver's own arithmetic.
diff --git a/packages/flutter3d_physics/lib/src/fluid/pbf_kernels.dart b/packages/flutter3d_physics/lib/src/fluid/pbf_kernels.dart
new file mode 100644
index 000000000..df0e6d5b6
--- /dev/null
+++ b/packages/flutter3d_physics/lib/src/fluid/pbf_kernels.dart
@@ -0,0 +1,532 @@
+import 'dart:math' as math;
+import 'dart:typed_data';
+
+/// The loops over pairs of neighbours that a Position Based Fluids substep
+/// is made of, over flat buffers: what [ParticleFluid] hands to whichever
+/// implementation runs them, this one in Dart or a native one.
+///
+/// **Flat, so another language can take them as they are.** Positions,
+/// velocities and every per-particle vector are `Float64List`s of x, y, z
+/// in turn; the neighbours are compressed rows, particle i's being
+/// `list[start[i]]` up to `list[start[i + 1]]`, itself left out. Nothing
+/// here knows about walls, receivers or drops: [ParticleFluid] keeps those,
+/// between the calls.
+///
+/// **This implementation is the reference**: the order of every sum is the
+/// order [ParticleFluid] has always added in, so a step is the same step to
+/// the last bit. A native one, free to vectorise, is held to it within a
+/// tolerance instead.
+abstract interface class PbfKernels {
+  /// The neighbours of each of the [n] particles at [x] within [radius], at
+  /// least the kernel's reach, as compressed rows: in each row the cells
+  /// about the particle, cells [radius] wide, in x, then y, then z order
+  /// from −1 to 1, and within a cell by index.
+  (Int32List start, Int32List list) neighbours(
+    Float64List x,
+    int n,
+    double radius,
+  );
+
+  /// Of the rows [start] and [list], those within [radius] of each other at
+  /// [x], in the order they are in.
+  (Int32List start, Int32List list) within(
+    Float64List x,
+    int n,
+    Int32List start,
+    Int32List list,
+    double radius,
+  );
+
+  /// Each particle's density, from its neighbours at [x]: ρ₀·ΣW/ΣW_rest.
+  void densities(
+    Float64List x,
+    Int32List start,
+    Int32List list,
+    int n,
+    Float64List density,
+  );
+
+  /// Each particle's colour-field normal, h·Σ m/ρⱼ·∇W, into [normal].
+  void normals(
+    Float64List x,
+    Int32List start,
+    Int32List list,
+    int n,
+    Float64List density,
+    Float64List normal,
+  );
+
+  /// The forces on each particle as accelerations, added to its velocity
+  /// [v] over [dt]: [before] (gravity), then cohesion and curvature from
+  /// its neighbours, then [after] (the air's drag), in that order.
+  void forces(
+    Float64List x,
+    Int32List start,
+    Int32List list,
+    int n,
+    Float64List density,
+    Float64List normal,
+    Float64List before,
+    Float64List after,
+    Float64List v,
+    double dt,
+  );
+
+  /// Each particle's density constraint multiplier λ, from the predicted
+  /// positions [p]: only where it is compressed.
+  void lambdas(
+    Float64List p,
+    Int32List start,
+    Int32List list,
+    int n,
+    Float64List lambda,
+  );
+
+  /// Each particle's position correction Δp from [lambda], with the
+  /// artificial pressure that keeps neighbours from clumping, into [delta].
+  void deltas(
+    Float64List p,
+    Int32List start,
+    Int32List list,
+    int n,
+    Float64List lambda,
+    Float64List delta,
+  );
+
+  /// XSPH: each velocity drawn towards its neighbours' by [share] of the
+  /// kernel weight, into [smoothed].
+  void viscosity(
+    Float64List p,
+    Float64List v,
+    Int32List start,
+    Int32List list,
+    int n,
+    double share,
+    Float64List smoothed,
+  );
+}
+
+/// The constants the kernels share, worked out once for a fluid.
+final class PbfConstants {
+  PbfConstants({
+    required this.h,
+    required this.restDensity,
+    required this.mass,
+    required this.norm,
+    required this.gamma,
+    required this.restStiffness,
+  }) : h2 = h * h,
+       poly6 = 315.0 / (64.0 * math.pi * _pow9(h)),
+       spiky = -45.0 / (math.pi * _pow6(h)),
+       cohesion = 32.0 / (math.pi * _pow9(h)),
+       h6 = _pow6(h),
+       wq = _poly6Of((0.3 * h) * (0.3 * h), h);
+
+  /// The kernel's reach, and its square.
+  final double h;
+  final double h2;
+
+  /// ρ₀, and one particle's mass.
+  final double restDensity;
+  final double mass;
+
+  /// One over the kernel summed over the lattice at rest.
+  final double norm;
+
+  /// Akinci's cohesion coefficient.
+  final double gamma;
+
+  /// Σ|∇C|² on the lattice, which the artificial pressure is a share of.
+  final double restStiffness;
+
+  /// The kernels' own normalisations.
+  final double poly6;
+  final double spiky;
+  final double cohesion;
+  final double h6;
+
+  /// W at 0.3·h, the artificial pressure's reference.
+  final double wq;
+
+  static double _pow6(double x) => x * x * x * x * x * x;
+  static double _pow9(double x) => _pow6(x) * x * x * x;
+  static double _poly6Of(double r2, double h) {
+    final h2 = h * h;
+    if (r2 >= h2) return 0.0;
+    final d = h2 - r2;
+    return 315.0 / (64.0 * math.pi * _pow9(h)) * d * d * d;
+  }
+}
+
+/// [PbfKernels] in Dart: the reference.
+final class DartPbfKernels implements PbfKernels {
+  DartPbfKernels(this.k);
+
+  final PbfConstants k;
+
+  /// A cell's three indices as one key, by multiplication rather than by
+  /// shifting into high bits: on the web an int's bitwise operations are 32
+  /// bits wide. Each index is held to ±2¹⁶ cells and the key under 2⁵¹,
+  /// which a double holds exactly.
+  static double _pack(int x, int y, int z) {
+    const span = 1 << 17;
+    const half = 1 << 16;
+    int wrap(int v) => (v + half) % span;
+    return ((wrap(x) * span + wrap(y)) * span + wrap(z)).toDouble();
+  }
+
+  /// **Sorted by cell, then searched.** Each particle's cell key, the
+  /// particles ordered by key and then index, and for each particle the
+  /// run of every one of its 27 cells found by halving: no map of cells,
+  /// and no list made per particle. A map of lists, built and asked three
+  /// times a substep, was two thirds of what a cloud of drops cost.
+  @override
+  (Int32List, Int32List) within(
+    Float64List x,
+    int n,
+    Int32List start,
+    Int32List list,
+    double radius,
+  ) {
+    final reach2 = radius * radius;
+    final outStart = Int32List(n + 1);
+    final out = Int32List(list.length);
+    var count = 0;
+    for (var i = 0; i < n; i++) {
+      final xi = x[3 * i];
+      final yi = x[3 * i + 1];
+      final zi = x[3 * i + 2];
+      for (var q = start[i]; q < start[i + 1]; q++) {
+        final j = list[q];
+        final ex = x[3 * j] - xi;
+        final ey = x[3 * j + 1] - yi;
+        final ez = x[3 * j + 2] - zi;
+        if (ex * ex + ey * ey + ez * ez < reach2) out[count++] = j;
+      }
+      outStart[i + 1] = count;
+    }
+    return (outStart, Int32List.sublistView(out, 0, count));
+  }
+
+  @override
+  (Int32List, Int32List) neighbours(Float64List x, int n, double radius) {
+    final h = radius;
+    final cx = Int32List(n);
+    final cy = Int32List(n);
+    final cz = Int32List(n);
+    final keys = Float64List(n);
+    for (var i = 0; i < n; i++) {
+      cx[i] = (x[3 * i] / h).floor();
+      cy[i] = (x[3 * i + 1] / h).floor();
+      cz[i] = (x[3 * i + 2] / h).floor();
+      keys[i] = _pack(cx[i], cy[i], cz[i]);
+    }
+    final order = List<int>.generate(n, (i) => i)
+      ..sort((a, b) {
+        final c = keys[a].compareTo(keys[b]);
+        return c != 0 ? c : a - b;
+      });
+    final sorted = Float64List(n);
+    // The positions in the same order: a cell's candidates are then read
+    // one after another, not from wherever each lies in [x].
+    final at = Float64List(3 * n);
+    for (var q = 0; q < n; q++) {
+      final j = order[q];
+      sorted[q] = keys[j];
+      at[3 * q] = x[3 * j];
+      at[3 * q + 1] = x[3 * j + 1];
+      at[3 * q + 2] = x[3 * j + 2];
+    }
+    int first(double key) {
+      var lo = 0;
+      var hi = n;
+      while (lo < hi) {
+        final mid = (lo + hi) >> 1;
+        if (sorted[mid] < key) {
+          lo = mid + 1;
+        } else {
+          hi = mid;
+        }
+      }
+      return lo;
+    }
+
+    final start = Int32List(n + 1);
+    var list = Int32List(n * 16 + 16);
+    var count = 0;
+    final reach2 = h * h;
+    for (var i = 0; i < n; i++) {
+      final xi = x[3 * i];
+      final yi = x[3 * i + 1];
+      final zi = x[3 * i + 2];
+      for (var dx = -1; dx <= 1; dx++) {
+        for (var dy = -1; dy <= 1; dy++) {
+          // **The three cells from z − 1 to z + 1 are three keys in a
+          // row**, z being the key's last part: one search finds the first
+          // and the rest follow it in the sorted keys, in the order three
+          // searches gave. Where z wraps round they are not in a row, and
+          // each is searched for.
+          final from = _pack(cx[i] + dx, cy[i] + dy, cz[i] - 1);
+          final to = _pack(cx[i] + dx, cy[i] + dy, cz[i] + 1);
+          final runs = to == from + 2 ? 1 : 3;
+          for (var run = 0; run < runs; run++) {
+            final lo = runs == 1
+                ? from
+                : _pack(cx[i] + dx, cy[i] + dy, cz[i] - 1 + run);
+            final hi = runs == 1 ? to : lo;
+            for (var q = first(lo); q < n && sorted[q] <= hi; q++) {
+              final ex = at[3 * q] - xi;
+              final ey = at[3 * q + 1] - yi;
+              final ez = at[3 * q + 2] - zi;
+              // As `_V.distance2` reads it: the other point less this one.
+              if (ex * ex + ey * ey + ez * ez >= reach2) continue;
+              final j = order[q];
+              if (j == i) continue;
+              if (count == list.length) {
+                list = Int32List(list.length * 2)..setAll(0, list);
+              }
+              list[count++] = j;
+            }
+          }
+        }
+      }
+      start[i + 1] = count;
+    }
+    return (start, Int32List.sublistView(list, 0, count));
+  }
+
+  double _poly6(double r2) {
+    if (r2 >= k.h2) return 0.0;
+    final d = k.h2 - r2;
+    return k.poly6 * d * d * d;
+  }
+
+  double _spikyScale(double r) {
+    if (r <= 1e-12 || r >= k.h) return 0.0;
+    return k.spiky * (k.h - r) * (k.h - r) / r;
+  }
+
+  double _cohesion(double r) {
+    final h = k.h;
+    if (r >= h || r <= 0.0) return 0.0;
+    final a = (h - r) * (h - r) * (h - r) * r * r * r;
+    if (2.0 * r > h) return k.cohesion * a;
+    return k.cohesion * (2.0 * a - k.h6 / 64.0);
+  }
+
+  @override
+  void densities(
+    Float64List x,
+    Int32List start,
+    Int32List list,
+    int n,
+    Float64List density,
+  ) {
+    for (var i = 0; i < n; i++) {
+      final xi = x[3 * i];
+      final yi = x[3 * i + 1];
+      final zi = x[3 * i + 2];
+      var w = _poly6(0.0);
+      for (var q = start[i]; q < start[i + 1]; q++) {
+        final j = list[q];
+        final dx = xi - x[3 * j];
+        final dy = yi - x[3 * j + 1];
+        final dz = zi - x[3 * j + 2];
+        w += _poly6(dx * dx + dy * dy + dz * dz);
+      }
+      density[i] = k.restDensity * w * k.norm;
+    }
+  }
+
+  @override
+  void normals(
+    Float64List x,
+    Int32List start,
+    Int32List list,
+    int n,
+    Float64List density,
+    Float64List normal,
+  ) {
+    for (var i = 0; i < n; i++) {
+      final xi = x[3 * i];
+      final yi = x[3 * i + 1];
+      final zi = x[3 * i + 2];
+      var nx = 0.0;
+      var ny = 0.0;
+      var nz = 0.0;
+      for (var q = start[i]; q < start[i + 1]; q++) {
+        final j = list[q];
+        final dx = xi - x[3 * j];
+        final dy = yi - x[3 * j + 1];
+        final dz = zi - x[3 * j + 2];
+        final f =
+            _spikyScale(math.sqrt(dx * dx + dy * dy + dz * dz)) *
+            k.h *
+            k.mass /
+            density[j];
+        nx += dx * f;
+        ny += dy * f;
+        nz += dz * f;
+      }
+      normal[3 * i] = nx;
+      normal[3 * i + 1] = ny;
+      normal[3 * i + 2] = nz;
+    }
+  }
+
+  @override
+  void forces(
+    Float64List x,
+    Int32List start,
+    Int32List list,
+    int n,
+    Float64List density,
+    Float64List normal,
+    Float64List before,
+    Float64List after,
+    Float64List v,
+    double dt,
+  ) {
+    final rho0 = k.restDensity;
+    for (var i = 0; i < n; i++) {
+      final xi = x[3 * i];
+      final yi = x[3 * i + 1];
+      final zi = x[3 * i + 2];
+      var ax = before[3 * i];
+      var ay = before[3 * i + 1];
+      var az = before[3 * i + 2];
+      for (var q = start[i]; q < start[i + 1]; q++) {
+        final j = list[q];
+        final dx = xi - x[3 * j];
+        final dy = yi - x[3 * j + 1];
+        final dz = zi - x[3 * j + 2];
+        final r = math.sqrt(dx * dx + dy * dy + dz * dz);
+        if (r < 1e-12) continue;
+        final kk = 2.0 * rho0 / (density[i] + density[j]);
+        final c = -kk * k.gamma * k.mass * _cohesion(r) / r;
+        final t = -kk * k.gamma;
+        ax += dx * c + (normal[3 * i] - normal[3 * j]) * t;
+        ay += dy * c + (normal[3 * i + 1] - normal[3 * j + 1]) * t;
+        az += dz * c + (normal[3 * i + 2] - normal[3 * j + 2]) * t;
+      }
+      ax += after[3 * i];
+      ay += after[3 * i + 1];
+      az += after[3 * i + 2];
+      v[3 * i] += ax * dt;
+      v[3 * i + 1] += ay * dt;
+      v[3 * i + 2] += az * dt;
+    }
+  }
+
+  @override
+  void lambdas(
+    Float64List p,
+    Int32List start,
+    Int32List list,
+    int n,
+    Float64List lambda,
+  ) {
+    final norm = k.norm;
+    for (var i = 0; i < n; i++) {
+      final xi = p[3 * i];
+      final yi = p[3 * i + 1];
+      final zi = p[3 * i + 2];
+      var w = _poly6(0.0);
+      var sum2 = 0.0;
+      var gx = 0.0;
+      var gy = 0.0;
+      var gz = 0.0;
+      for (var q = start[i]; q < start[i + 1]; q++) {
+        final j = list[q];
+        final dx = xi - p[3 * j];
+        final dy = yi - p[3 * j + 1];
+        final dz = zi - p[3 * j + 2];
+        final r2 = dx * dx + dy * dy + dz * dz;
+        w += _poly6(r2);
+        final f = _spikyScale(math.sqrt(r2)) * norm;
+        sum2 += r2 * f * f;
+        gx += dx * f;
+        gy += dy * f;
+        gz += dz * f;
+      }
+      sum2 += gx * gx + gy * gy + gz * gz;
+      final c = math.max(w * norm - 1.0, 0.0);
+      lambda[i] = -c / (sum2 + 1e-6 * norm * norm / (k.h * k.h));
+    }
+  }
+
+  @override
+  void deltas(
+    Float64List p,
+    Int32List start,
+    Int32List list,
+    int n,
+    Float64List lambda,
+    Float64List delta,
+  ) {
+    final norm = k.norm;
+    for (var i = 0; i < n; i++) {
+      final xi = p[3 * i];
+      final yi = p[3 * i + 1];
+      final zi = p[3 * i + 2];
+      var sx = 0.0;
+      var sy = 0.0;
+      var sz = 0.0;
+      for (var q = start[i]; q < start[i + 1]; q++) {
+        final j = list[q];
+        final dx = xi - p[3 * j];
+        final dy = yi - p[3 * j + 1];
+        final dz = zi - p[3 * j + 2];
+        final r2 = dx * dx + dy * dy + dz * dz;
+        final ratio = _poly6(r2) / k.wq;
+        // Macklin's artificial pressure: a fiftieth of a constraint's worth.
+        final corr = -0.02 * ratio * ratio * ratio * ratio / k.restStiffness;
+        final f =
+            _spikyScale(math.sqrt(r2)) * (lambda[i] + lambda[j] + corr) * norm;
+        sx += dx * f;
+        sy += dy * f;
+        sz += dz * f;
+      }
+      delta[3 * i] = sx;
+      delta[3 * i + 1] = sy;
+      delta[3 * i + 2] = sz;
+    }
+  }
+
+  @override
+  void viscosity(
+    Float64List p,
+    Float64List v,
+    Int32List start,
+    Int32List list,
+    int n,
+    double share,
+    Float64List smoothed,
+  ) {
+    final norm = k.norm;
+    for (var i = 0; i < n; i++) {
+      final xi = p[3 * i];
+      final yi = p[3 * i + 1];
+      final zi = p[3 * i + 2];
+      final vx = v[3 * i];
+      final vy = v[3 * i + 1];
+      final vz = v[3 * i + 2];
+      var sx = vx;
+      var sy = vy;
+      var sz = vz;
+      for (var q = start[i]; q < start[i + 1]; q++) {
+        final j = list[q];
+        final dx = xi - p[3 * j];
+        final dy = yi - p[3 * j + 1];
+        final dz = zi - p[3 * j + 2];
+        final w = _poly6(dx * dx + dy * dy + dz * dz) * norm * share;
+        sx += (v[3 * j] - vx) * w;
+        sy += (v[3 * j + 1] - vy) * w;
+        sz += (v[3 * j + 2] - vz) * w;
+      }
+      smoothed[3 * i] = sx;
+      smoothed[3 * i + 1] = sy;
+      smoothed[3 * i + 2] = sz;
+    }
+  }
+}
diff --git a/packages/flutter3d_physics/lib/src/fluid/pipe.dart b/packages/flutter3d_physics/lib/src/fluid/pipe.dart
index 5740038fa..27b73f1f9 100644
--- a/packages/flutter3d_physics/lib/src/fluid/pipe.dart
+++ b/packages/flutter3d_physics/lib/src/fluid/pipe.dart
@@ -2,6 +2,7 @@ import 'dart:math' as math;
 
 import 'package:vector_math/vector_math.dart';
 
+import '../portable_math.dart';
 import 'liquid_body.dart';
 
 /// A round pipe joining two vessels below their surfaces: communicating
@@ -10,9 +11,10 @@ import 'liquid_body.dart';
 /// **The liquid in it has mass**, so it is not pushed through at once but
 /// accelerated: the pressure difference between its ends drives the column
 /// — the pipe's own length over its section, and the liquid standing in each
-/// vessel above it over the vessel's — and friction holds it back, linearly
-/// for a slow viscous flow (Hagen–Poiseuille, 8μL/πr⁴) and as the square of
-/// the flow for the losses where it enters and leaves (K·ρQ|Q|/2a²). Two
+/// vessel above it over the vessel's — and friction holds it back: along
+/// the pipe as Darcy's f·(L/D)·ρv²/2, f the [frictionFactor] at the flow's
+/// Reynolds number, laminar or turbulent, and as the square of the flow for
+/// the losses where it enters and leaves (K·ρQ|Q|/2a²). Two
 /// vessels joined this way swing about a common level before they settle on
 /// it — a U-tube's period 2π√(l/2g) for a column l long — and a thick liquid
 /// creeps to it without swinging.
@@ -31,6 +33,7 @@ final class Pipe {
     required this.radius,
     required this.length,
     this.minorLoss = 1.5,
+    this.roughness = 1.5e-6,
   });
 
   /// The two vessels, and where the pipe opens into each (vessel frame).
@@ -47,9 +50,45 @@ final class Pipe {
   /// and 1 out for sharp ends.
   final double minorLoss;
 
+  /// The height of the bumps on the bore, metres: 1.5 µm, drawn glass and
+  /// plastic tubing. What turbulent friction feels; a laminar flow does not.
+  final double roughness;
+
   /// Cubic metres a second from [from] to [to]; negative the other way.
   double flow = 0.0;
 
+  /// The flow's Reynolds number, ρ·v·D/μ: under 2300 laminar, over 4000
+  /// turbulent.
+  double get reynolds {
+    final medium = from.medium;
+    final v = flow.abs() / (math.pi * radius * radius);
+    return medium.density * v * 2.0 * radius / medium.viscosity;
+  }
+
+  /// Darcy's friction factor at Reynolds number [re] in a bore of
+  /// [relativeRoughness] ε/D.
+  ///
+  /// Laminar, Hagen and Poiseuille's 64/Re, exact. Turbulent, Haaland's
+  /// explicit form of Colebrook's, 1/√f = −1.8·log₁₀((ε/D/3.7)^1.11 +
+  /// 6.9/Re), within a couple of percent of it. Between 2300 and 4000 the
+  /// flow is neither, and goes from one to the other with Re: no law
+  /// holds there, and a straight line between the two does not pretend to
+  /// one.
+  static double frictionFactor(double re, {double relativeRoughness = 0.0}) {
+    if (re <= 0.0) return double.infinity;
+    double turbulent(double re) {
+      final x = Portable.pow(relativeRoughness / 3.7, 1.11) + 6.9 / re;
+      final inverse = -1.8 * Portable.log(x) / math.ln10;
+      return 1.0 / (inverse * inverse);
+    }
+
+    final laminar = 64.0 / re;
+    if (re <= 2300.0) return laminar;
+    if (re >= 4000.0) return turbulent(re);
+    final t = (re - 2300.0) / 1700.0;
+    return (1.0 - t) * laminar + t * turbulent(re);
+  }
+
   /// Moves the liquid in the pipe on by [dt] under [gravity].
   void step(double dt, {required Vector3 gravity}) {
     final medium = from.medium;
@@ -72,11 +111,20 @@ final class Pipe {
         (length / a +
             math.max(head0, 0.0) / math.max(from.surface.area, a) +
             math.max(head1, 0.0) / math.max(to.surface.area, a));
-    final viscous =
-        8.0 *
-        medium.viscosity *
-        length /
-        (math.pi * (radius * radius * radius * radius));
+    // Darcy's loss as a resistance, Δp/Q = f·L·ρ·|Q|/(2·D·a²); laminar it
+    // is Poiseuille's 8μL/πr⁴, whatever the flow, and that is what it is
+    // at no flow at all.
+    final re = reynolds;
+    final viscous = re < 1.0
+        ? 8.0 *
+              medium.viscosity *
+              length /
+              (math.pi * (radius * radius * radius * radius))
+        : frictionFactor(re, relativeRoughness: roughness / (2.0 * radius)) *
+              length *
+              rho *
+              flow.abs() /
+              (2.0 * 2.0 * radius * a * a);
     final quadratic = minorLoss * rho * flow.abs() / (2.0 * a * a);
     // Friction taken implicitly, so a thick liquid in a thin pipe is stable
     // at any step.
diff --git a/packages/flutter3d_physics/lib/src/fluid/puddle.dart b/packages/flutter3d_physics/lib/src/fluid/puddle.dart
new file mode 100644
index 000000000..57d0ebb6f
--- /dev/null
+++ b/packages/flutter3d_physics/lib/src/fluid/puddle.dart
@@ -0,0 +1,287 @@
+import 'dart:math' as math;
+
+import 'package:vector_math/vector_math.dart';
+
+import '../portable_math.dart';
+import 'atmosphere.dart';
+import 'fluid_medium.dart';
+import 'jet.dart';
+import 'particle_fluid.dart';
+import 'wetting.dart';
+
+/// Liquid lying on a flat surface: a drop or a puddle, as one body.
+///
+/// **Its shape is surface tension's and gravity's.** Spread out, a puddle
+/// is as deep as the capillary length and the contact angle make it,
+/// h = 2ℓc·sin(θ/2) with ℓc = √(σ/ρg) (de Gennes, Brochard-Wyart and Quéré,
+/// *Capillarity and Wetting Phenomena*, §2.1.2): wider and it would thin
+/// past what surface tension holds at its edge, narrower and gravity
+/// flattens it further. Smaller than that, it is a drop, a spherical cap
+/// meeting the surface at θ. Whichever is wider is what it is: the cap
+/// while it is small, the puddle once its weight counts.
+///
+/// **It gets there as a viscous gravity current.** A volume V let go on a
+/// plane spreads as R(t) = 0.894·(ρgV³/3μ)^⅛·t^⅛ (Huppert, 1982); it stops
+/// where it reaches its shape. Water reaches it in milliseconds; honey
+/// takes its time.
+final class Puddle {
+  Puddle({
+    required this.medium,
+    required this.centre,
+    required this.normal,
+    double? angle,
+  }) : angle = angle ?? medium.contactAngle;
+
+  final FluidMedium medium;
+
+  /// The angle it meets the surface at, radians: the surface's for this
+  /// liquid ([SolidSurface.angleFor]). Water beads on a lacquered bench
+  /// and spreads on glass.
+  final double angle;
+
+  /// Its middle, on the surface.
+  final Vector3 centre;
+
+  /// The surface's normal, away from it.
+  final Vector3 normal;
+
+  double _volume = 0.0;
+  final Map<String, double> _amounts = {};
+
+  /// Seconds since it was first wetted, as a gravity current counts them.
+  double age = 0.0;
+
+  /// Cubic metres in it.
+  double get volume => _volume;
+
+  /// What is dissolved in it, as concentrations.
+  Map<String, double> get concentrations => _volume <= 0.0
+      ? const {}
+      : {for (final e in _amounts.entries) e.key: e.value / _volume};
+
+  /// Adds [volume] carrying [concentrations], landing at [point]: the
+  /// middle moves to the centre of what it holds.
+  void add(double volume, Vector3 point, Map<String, double> concentrations) {
+    if (volume <= 0.0) return;
+    final onPlane = point - normal * normal.dot(point - centre);
+    final total = _volume + volume;
+    centre.setFrom(centre * (_volume / total) + onPlane * (volume / total));
+    _volume = total;
+    concentrations.forEach((k, c) {
+      _amounts[k] = (_amounts[k] ?? 0.0) + c * volume;
+    });
+  }
+
+  /// [other] taken in, whole.
+  void merge(Puddle other) {
+    final total = _volume + other._volume;
+    if (total <= 0.0) return;
+    centre.setFrom(
+      centre * (_volume / total) + other.centre * (other._volume / total),
+    );
+    _volume = total;
+    other._amounts.forEach((k, a) => _amounts[k] = (_amounts[k] ?? 0.0) + a);
+    age = math.max(age, other.age);
+  }
+
+  /// **What evaporates from it in [dt]** into [air], cubic metres, taken
+  /// from its solvent: what is dissolved stays behind in less liquid.
+  ///
+  /// In still air vapour diffuses away from a sessile drop at
+  /// π·R·D·Δc·(0.27θ² + 1.30) kilograms a second, R its radius and θ its
+  /// contact angle (Hu and Larson, 2002); at θ → 0 that is the flat disc's
+  /// 4·R·D·Δc. In a wind the vapour is carried off over it as from a flat
+  /// plate 2R long: a laminar boundary layer's mean Sherwood number
+  /// 0.664·Re^½·Sc^⅓. Whichever takes it faster does.
+  double evaporate(double dt, Atmosphere air, double g) {
+    if (_volume <= 0.0) return 0.0;
+    final deficit = air.vapourDeficit(medium);
+    if (deficit <= 0.0) return 0.0;
+    final r = radius(g);
+    if (r <= 0.0) return 0.0;
+    final d = air.vapourDiffusivity;
+    final theta = angle.clamp(0.0, math.pi / 2);
+    final still = math.pi * r * d * deficit * (0.27 * theta * theta + 1.30);
+    final across = air.windAt(centre)
+      ..addScaled(normal, -air.windAt(centre).dot(normal));
+    final length = 2.0 * r;
+    final re = air.density * across.length * length / air.viscosity;
+    final sc = air.viscosity / (air.density * d);
+    final sherwood = 0.664 * math.sqrt(re) * Portable.pow(sc, 1.0 / 3.0);
+    final carried = sherwood * d / length * deficit * math.pi * r * r;
+    final gone = math.min(
+      math.max(still, carried) / medium.density * dt,
+      _volume,
+    );
+    _volume -= gone;
+    return gone;
+  }
+
+  /// How far it reaches across the surface, metres.
+  double radius(double g) {
+    if (_volume <= 0.0) return 0.0;
+    final rest = restRadius(g);
+    if (medium.viscosity <= 0.0 || age <= 0.0) return rest;
+    final current =
+        0.894 *
+        Portable.pow(
+          medium.density *
+              g *
+              _volume *
+              _volume *
+              _volume /
+              (3.0 * medium.viscosity),
+          0.125,
+        ) *
+        Portable.pow(age, 0.125);
+    return math.min(rest, current.toDouble());
+  }
+
+  /// Its radius once it has stopped spreading: the cap's or the puddle's,
+  /// whichever is wider.
+  double restRadius(double g) {
+    if (_volume <= 0.0) return 0.0;
+    final theta = angle.clamp(0.05, math.pi - 0.05);
+    final s = Portable.sin(theta);
+    final c = Portable.cos(theta);
+    // A spherical cap of base R meeting the plane at θ holds
+    // πR³(2 − 3cosθ + cos³θ)/(3sin³θ).
+    final cap = math
+        .pow(
+          3.0 * _volume * s * s * s / (math.pi * (2.0 - 3.0 * c + c * c * c)),
+          1.0 / 3.0,
+        )
+        .toDouble();
+    final capillary = math.sqrt(
+      medium.surfaceTension / (medium.density * math.max(g, 1e-9)),
+    );
+    final deep = 2.0 * capillary * Portable.sin(theta / 2.0);
+    final flat = math.sqrt(_volume / (math.pi * deep));
+    return math.max(cap, flat);
+  }
+
+  /// The height of a spherical cap of base [radius] holding what it holds:
+  /// what it is drawn as. A flat puddle drawn so is a lens twice as deep
+  /// in the middle as it is on average, and holds the same.
+  double capHeight(double radius) {
+    if (_volume <= 0.0 || radius <= 0.0) return 0.0;
+    // V = πH(3R² + H²)/6, solved for H by Newton from the flat guess.
+    var h = 2.0 * _volume / (math.pi * radius * radius);
+    for (var i = 0; i < 8; i++) {
+      final f = math.pi * h * (3.0 * radius * radius + h * h) / 6.0 - _volume;
+      final df = math.pi * (radius * radius + h * h) / 2.0;
+      h -= f / df;
+    }
+    return math.max(h, 0.0);
+  }
+}
+
+/// A flat surface's puddles: everything that reaches the surface becomes
+/// one, or joins the one it lands in.
+///
+/// A receiver like a vessel: a stream that runs onto the bench lands in
+/// it, and so does a drop. Liquid on the bench is then a few bodies, each
+/// its volume and what is dissolved in it, and not thousands of particles
+/// to step and draw.
+final class PuddleSurface implements JetReceiver {
+  PuddleSurface(this.surface);
+
+  final PlaneObstacle surface;
+
+  final List<Puddle> puddles = [];
+
+  /// The gravity the puddles last spread under.
+  double _g = 9.81;
+
+  /// Cubic metres lying here.
+  double get volume => puddles.fold(0.0, (s, p) => s + p.volume);
+
+  @override
+  bool catches(Vector3 point, double radius) =>
+      // What rests on the surface rests a radius off it; a quarter of one
+      // more, as a vessel's floor allows.
+      surface.normal.dot(point) - surface.offset <= 1.25 * radius;
+
+  @override
+  bool wets(Vector3 point, double radius) => false;
+
+  @override
+  bool reaches(Vector3 centre, double distance) =>
+      surface.reaches(centre, distance);
+
+  @override
+  void receive(
+    double volume,
+    Vector3 point,
+    Vector3 velocity,
+    FluidMedium medium,
+    Map<String, double> concentrations,
+  ) {
+    final onPlane =
+        point - surface.normal * (surface.normal.dot(point) - surface.offset);
+    // Into a puddle it lands on, or the start of a new one.
+    Puddle? into;
+    for (final p in puddles) {
+      if (p.medium.name != medium.name) continue;
+      if ((p.centre - onPlane).length <= p.radius(_g)) {
+        into = p;
+        break;
+      }
+    }
+    into ??= () {
+      final made = Puddle(
+        medium: medium,
+        centre: onPlane.clone(),
+        normal: surface.normal.clone(),
+        angle: surface.solid.angleFor(medium),
+      );
+      puddles.add(made);
+      return made;
+    }();
+    into.add(volume, onPlane, concentrations);
+    _join();
+  }
+
+  /// What evaporates from every puddle in [dt] into [air], cubic metres;
+  /// a puddle dried out is gone.
+  double evaporate(double dt, Atmosphere air) {
+    var gone = 0.0;
+    for (final p in puddles) {
+      gone += p.evaporate(dt, air, _g);
+    }
+    puddles.removeWhere((p) => p.volume <= 0.0);
+    return gone;
+  }
+
+  /// Spreads every puddle on by [dt] under [gravity], and runs together
+  /// those that meet.
+  void step(double dt, {required Vector3 gravity}) {
+    _g = math.max(-gravity.dot(surface.normal), 0.0);
+    if (puddles.isEmpty) return;
+    for (final p in puddles) {
+      p.age += dt;
+    }
+    _join();
+  }
+
+  void _join() {
+    var joined = true;
+    while (joined) {
+      joined = false;
+      outer:
+      for (var i = 0; i < puddles.length; i++) {
+        for (var j = i + 1; j < puddles.length; j++) {
+          final a = puddles[i];
+          final b = puddles[j];
+          if (a.medium.name != b.medium.name) continue;
+          if ((a.centre - b.centre).length < a.radius(_g) + b.radius(_g)) {
+            a.merge(b);
+            puddles.removeAt(j);
+            joined = true;
+            break outer;
+          }
+        }
+      }
+    }
+  }
+}
diff --git a/packages/flutter3d_physics/lib/src/fluid/wetting.dart b/packages/flutter3d_physics/lib/src/fluid/wetting.dart
new file mode 100644
index 000000000..1dd614dce
--- /dev/null
+++ b/packages/flutter3d_physics/lib/src/fluid/wetting.dart
@@ -0,0 +1,93 @@
+import 'dart:math' as math;
+
+import '../portable_math.dart';
+import 'fluid_medium.dart';
+
+/// A solid a liquid lies on or runs down: how water meets it.
+///
+/// **A contact angle is not one angle.** A drop's edge moving forward meets
+/// the solid at the advancing angle θa, drawing back at the receding angle
+/// θr, and anywhere between the edge does not move at all: the hysteresis
+/// θa − θr is what holds a raindrop still on a window. The force it can
+/// hold a drop with is σ·w·(cos θr − cos θa) across a contact w wide
+/// (Furmidge, 1962), and a drop slides when the pull along the solid is
+/// more than that.
+///
+/// The angles here are water's, typical of the clean surface and not of
+/// one measurement: a solid's angles move with how it was cleaned, coated
+/// and worn. For another liquid the solid's own angles are not known here,
+/// and its angle against glass ([FluidMedium.contactAngle]) stands in, with
+/// the same hysteresis.
+final class SolidSurface {
+  const SolidSurface({
+    required this.name,
+    required this.waterAngle,
+    required this.hysteresis,
+  });
+
+  /// Clean glass: water spreads on it, 20° (as [FluidMedium.water]), and its
+  /// edge holds over about 10°.
+  static const SolidSurface glass = SolidSurface(
+    name: 'glass',
+    waterAngle: 0.35,
+    hysteresis: 0.17,
+  );
+
+  /// A lacquered or laminate bench top: water beads on it at about 75° and
+  /// its edge holds over about 25°.
+  static const SolidSurface laminate = SolidSurface(
+    name: 'laminate',
+    waterAngle: 1.31,
+    hysteresis: 0.44,
+  );
+
+  /// PTFE: water stands up on it at about 110° and rolls off easily.
+  static const SolidSurface ptfe = SolidSurface(
+    name: 'ptfe',
+    waterAngle: 1.92,
+    hysteresis: 0.17,
+  );
+
+  final String name;
+
+  /// Water's contact angle at rest, radians.
+  final double waterAngle;
+
+  /// The advancing angle less the receding one, radians.
+  final double hysteresis;
+
+  /// [medium]'s angle at rest on this solid.
+  double angleFor(FluidMedium medium) =>
+      medium.vapour?.isWater ?? false ? waterAngle : medium.contactAngle;
+
+  /// The angles [medium]'s edge advances and recedes at.
+  ({double advancing, double receding}) anglesFor(FluidMedium medium) {
+    final rest = angleFor(medium);
+    return (
+      advancing: math.min(rest + 0.5 * hysteresis, math.pi),
+      receding: math.max(rest - 0.5 * hysteresis, 0.0),
+    );
+  }
+
+  /// The most this solid holds a drop of [medium] [width] wide by its edge,
+  /// newtons: σ·w·(cos θr − cos θa).
+  double retention(FluidMedium medium, double width) {
+    final a = anglesFor(medium);
+    return medium.surfaceTension *
+        width *
+        (Portable.cos(a.receding) - Portable.cos(a.advancing));
+  }
+
+  /// The radius of the circle a drop of [volume] of [medium] wets on this
+  /// solid at rest: a spherical cap meeting it at its angle, which holds
+  /// πR³(2 − 3cosθ + cos³θ)/(3sin³θ).
+  double baseRadius(FluidMedium medium, double volume) {
+    final theta = angleFor(medium).clamp(0.05, math.pi - 0.05);
+    final s = Portable.sin(theta);
+    final c = Portable.cos(theta);
+    return Portable.pow(
+      3.0 * volume * s * s * s / (math.pi * (2.0 - 3.0 * c + c * c * c)),
+      1.0 / 3.0,
+    );
+  }
+}
diff --git a/packages/flutter3d_physics/pubspec.yaml b/packages/flutter3d_physics/pubspec.yaml
index b24693503..391c4ac9f 100644
--- a/packages/flutter3d_physics/pubspec.yaml
+++ b/packages/flutter3d_physics/pubspec.yaml
@@ -16,6 +16,13 @@ environment:
 
 dependencies:
   vector_math: ^2.2.0
+  # The native kernels' build: `hook/build.dart` compiles `src/*.c` with
+  # whatever C compiler the machine has, and builds nothing, without
+  # failing, where it has none. See `lib/src/fluid/native/`.
+  code_assets: ^2.1.0
+  hooks: ^2.0.0
+  logging: ^1.3.0
+  native_toolchain_c: ^0.19.5
 
 dev_dependencies:
 
diff --git a/packages/flutter3d_physics/src/meniscus.c b/packages/flutter3d_physics/src/meniscus.c
new file mode 100644
index 000000000..a4678ab7a
--- /dev/null
+++ b/packages/flutter3d_physics/src/meniscus.c
@@ -0,0 +1,135 @@
+// `TubeMeniscus._solve` in C: the curvature at the surface's middle that
+// meets the wall at the contact angle, by Illinois false position over shots
+// of Runge–Kutta in arc length, and the surface it gives.
+//
+// On the platform's own sine and cosine, many times as quick as the Dart
+// one's portable ones, and so held to it within a tolerance, not to the bit:
+// for a world that need not replay (`FluidWorld.nativeKernels`).
+
+#include <math.h>
+#include <stdint.h>
+
+#if defined(_WIN32)
+#define F3D_EXPORT __declspec(dllexport)
+#else
+#define F3D_EXPORT __attribute__((visibility("default")))
+#endif
+
+#define F3D_PI 3.14159265358979323846
+
+static double turn(double bond, double b, double r, double z, double phi) {
+  return bond * z + b - sin(phi) / (r > 1e-12 ? r : 1e-12);
+}
+
+// One shot from the axis to the wall for apex curvature [b]: the angle it
+// meets the wall at. Keeps its points in [rs] and [zs] when they are given,
+// [count] of them.
+static double shoot(double radius, double bond, double b, int32_t samples,
+                    double* rs, double* zs, int32_t capacity,
+                    int32_t* count) {
+  const double s0 = radius * 1e-4;
+  double r = s0;
+  double z = 0.5 * b * 0.5 * s0 * s0;
+  double phi = 0.5 * b * s0;
+  int32_t kept = 0;
+  if (rs && kept < capacity) {
+    rs[kept] = 0.0;
+    zs[kept] = 0.0;
+  }
+  kept++;
+  const double ds = radius / (samples * 2);
+  int32_t guard = 0;
+  while (r < radius && guard++ < samples * 400) {
+    const double k1r = cos(phi), k1z = sin(phi);
+    const double k1p = turn(bond, b, r, z, phi);
+    const double k2r = cos(phi + 0.5 * ds * k1p);
+    const double k2z = sin(phi + 0.5 * ds * k1p);
+    const double k2p = turn(bond, b, r + 0.5 * ds * k1r, z + 0.5 * ds * k1z,
+                            phi + 0.5 * ds * k1p);
+    const double k3r = cos(phi + 0.5 * ds * k2p);
+    const double k3z = sin(phi + 0.5 * ds * k2p);
+    const double k3p = turn(bond, b, r + 0.5 * ds * k2r, z + 0.5 * ds * k2z,
+                            phi + 0.5 * ds * k2p);
+    const double k4r = cos(phi + ds * k3p);
+    const double k4z = sin(phi + ds * k3p);
+    const double k4p =
+        turn(bond, b, r + ds * k3r, z + ds * k3z, phi + ds * k3p);
+    const double nr = r + ds / 6 * (k1r + 2 * k2r + 2 * k3r + k4r);
+    const double nz = z + ds / 6 * (k1z + 2 * k2z + 2 * k3z + k4z);
+    const double np = phi + ds / 6 * (k1p + 2 * k2p + 2 * k3p + k4p);
+    // A surface that turns back on itself before the wall has overshot.
+    if (nr <= r || fabs(np) > F3D_PI) {
+      if (count) *count = kept;
+      return (np > 0.0 ? 1.0 : (np < 0.0 ? -1.0 : 0.0)) * F3D_PI;
+    }
+    if (nr >= radius) {
+      const double t = (radius - r) / (nr - r);
+      z += (nz - z) * t;
+      phi += (np - phi) * t;
+      r = radius;
+    } else {
+      r = nr;
+      z = nz;
+      phi = np;
+    }
+    if (rs) {
+      if (kept < capacity) {
+        rs[kept] = r;
+        zs[kept] = z;
+      }
+      kept++;
+    }
+  }
+  if (count) *count = kept;
+  return phi;
+}
+
+// The meniscus in a tube of [radius]: its apex curvature into [apex], its
+// points into [rs] and [zs] (room for [capacity]); returns how many points
+// there are, which, if more than [capacity], wants a call with that room.
+F3D_EXPORT int32_t f3d_meniscus(double radius, double bond,
+                                double contact_angle, int32_t samples,
+                                double* rs, double* zs, int32_t capacity,
+                                double* apex) {
+  const double target = F3D_PI / 2 - contact_angle;
+  double lo = -40.0 / radius, hi = 40.0 / radius;
+  double flo = shoot(radius, bond, lo, samples, 0, 0, 0, 0) - target;
+  double fhi = shoot(radius, bond, hi, samples, 0, 0, 0, 0) - target;
+  int32_t kept = 0;
+  const double tolerance = (hi - lo) * 8.673617379884035e-19;
+  for (int32_t i = 0; i < 200 && hi - lo > tolerance; i++) {
+    double mid = isfinite(flo) && isfinite(fhi) && fhi != flo
+                     ? lo - flo * (hi - lo) / (fhi - flo)
+                     : 0.5 * (lo + hi);
+    if (!(mid > lo && mid < hi)) mid = 0.5 * (lo + hi);
+    const double f = shoot(radius, bond, mid, samples, 0, 0, 0, 0) - target;
+    if (!isfinite(f)) {
+      if (isfinite(flo) && flo > 0.0) {
+        hi = mid;
+      } else {
+        lo = mid;
+      }
+      continue;
+    }
+    if (fabs(f) < 1e-15) {
+      lo = mid;
+      hi = mid;
+      break;
+    }
+    if (f < 0.0) {
+      lo = mid;
+      flo = f;
+      if (kept == 1) fhi *= 0.5;
+      kept = 1;
+    } else {
+      hi = mid;
+      fhi = f;
+      if (kept == -1) flo *= 0.5;
+      kept = -1;
+    }
+  }
+  *apex = 0.5 * (lo + hi);
+  int32_t count = 0;
+  shoot(radius, bond, *apex, samples, rs, zs, capacity, &count);
+  return count;
+}
diff --git a/packages/flutter3d_physics/src/pbf_kernels.c b/packages/flutter3d_physics/src/pbf_kernels.c
new file mode 100644
index 000000000..04371d3d9
--- /dev/null
+++ b/packages/flutter3d_physics/src/pbf_kernels.c
@@ -0,0 +1,540 @@
+// The Position Based Fluids pair loops of `lib/src/fluid/pbf_kernels.dart`,
+// in C: the same five kernels over the same flat buffers, for
+// `NativePbfKernels` to call through `@Native`.
+//
+// **Held to the Dart reference within a tolerance, not to the bit.** The
+// neighbours of a particle are summed several at a time where the compiler
+// has vector extensions (clang and gcc), which adds in another order than
+// Dart's one at a time; a run is the same run to about a part in 10¹², not
+// exactly. Where the world must replay to the bit, the Dart kernels are the
+// ones to step it with.
+//
+// **How many at a time is the running processor's, chosen when first
+// asked**, not the building machine's: the hook builds on whatever machine
+// builds the app, and code for its processor would stop on an older one
+// with an illegal instruction. Two lanes everywhere (SSE2 and NEON are
+// in every x86-64 and arm64); on x86-64 also four, built for AVX2, and
+// eight, built for AVX-512F, each taken only where the processor says it
+// has them, eight being there for a test to ask for: four is the default
+// (see [f3d_default_lanes]). Without fused multiply-adds, so that each lane
+// rounds as the scalar loop does.
+//
+// The constants come as one array, in this order:
+//   0 h, 1 h², 2 ρ₀, 3 m, 4 norm, 5 γ, 6 rest stiffness,
+//   7 poly6, 8 spiky, 9 cohesion, 10 h⁶, 11 W(0.3h).
+
+#include <math.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+#if defined(__clang__) || defined(__GNUC__)
+#define F3D_VECTOR 1
+#else
+#define F3D_VECTOR 0
+#endif
+
+#if F3D_VECTOR && (defined(__x86_64__) || defined(_M_X64))
+#define F3D_X86 1
+#else
+#define F3D_X86 0
+#endif
+
+// The lanes arm64 takes unless a test sets others: what measured fastest.
+#ifndef F3D_ARM_LANES
+#define F3D_ARM_LANES 2
+#endif
+
+#if defined(_WIN32)
+#define F3D_EXPORT __declspec(dllexport)
+#else
+#define F3D_EXPORT __attribute__((visibility("default")))
+#endif
+
+enum {
+  K_H = 0,
+  K_H2,
+  K_RHO0,
+  K_MASS,
+  K_NORM,
+  K_GAMMA,
+  K_REST_STIFFNESS,
+  K_POLY6,
+  K_SPIKY,
+  K_COHESION,
+  K_H6,
+  K_WQ,
+};
+
+static inline double poly6(const double* k, double r2) {
+  if (r2 >= k[K_H2]) return 0.0;
+  const double d = k[K_H2] - r2;
+  return k[K_POLY6] * d * d * d;
+}
+
+static inline double spiky_scale(const double* k, double r) {
+  if (r <= 1e-12 || r >= k[K_H]) return 0.0;
+  const double hr = k[K_H] - r;
+  return k[K_SPIKY] * hr * hr / r;
+}
+
+static inline double cohesion(const double* k, double r) {
+  const double h = k[K_H];
+  if (r >= h || r <= 0.0) return 0.0;
+  const double a = (h - r) * (h - r) * (h - r) * r * r * r;
+  if (2.0 * r > h) return k[K_COHESION] * a;
+  return k[K_COHESION] * (2.0 * a - k[K_H6] / 64.0);
+}
+
+F3D_EXPORT int32_t f3d_pbf_version(void) { return 6; }
+
+// Of the rows [start] and [list], those within [radius] at [x], in order,
+// into [out_start] and [out] (room for as many as [list] has).
+F3D_EXPORT int32_t f3d_pbf_within(const double* x, int32_t n,
+                                  const int32_t* start, const int32_t* list,
+                                  double radius, int32_t* out_start,
+                                  int32_t* out) {
+  const double reach2 = radius * radius;
+  int32_t count = 0;
+  out_start[0] = 0;
+  for (int32_t i = 0; i < n; i++) {
+    const double xi = x[3 * i], yi = x[3 * i + 1], zi = x[3 * i + 2];
+    for (int32_t q = start[i]; q < start[i + 1]; q++) {
+      const int32_t j = list[q];
+      const double ex = x[3 * j] - xi, ey = x[3 * j + 1] - yi,
+                   ez = x[3 * j + 2] - zi;
+      if (ex * ex + ey * ey + ez * ez < reach2) out[count++] = j;
+    }
+    out_start[i + 1] = count;
+  }
+  return count;
+}
+
+// ----------------------------------------------------------- neighbours
+
+static int64_t pack_cell(int64_t x, int64_t y, int64_t z) {
+  const int64_t span = (int64_t)1 << 17, half = (int64_t)1 << 16;
+#define F3D_WRAP(v) ((((v) + half) % span + span) % span)
+  return (F3D_WRAP(x) * span + F3D_WRAP(y)) * span + F3D_WRAP(z);
+#undef F3D_WRAP
+}
+
+typedef struct {
+  int64_t key;
+  int64_t index;
+} f3d_cell_entry;
+
+static int compare_entries(const void* a, const void* b) {
+  const f3d_cell_entry* p = (const f3d_cell_entry*)a;
+  const f3d_cell_entry* q = (const f3d_cell_entry*)b;
+  if (p->key != q->key) return p->key < q->key ? -1 : 1;
+  return p->index < q->index ? -1 : (p->index > q->index ? 1 : 0);
+}
+
+// The neighbours of each particle within h, as compressed rows, the same
+// order as the Dart kernel's: cells by x, y, z from −1 to 1, within a cell
+// by index. Writes at most [capacity] into [list] and returns how many there
+// are: called again with room for that when it is more. [scratch] holds
+// 5·n int64s, the caller's own: nothing here is shared between calls, so
+// two isolates may step two fluids at once.
+//
+// **Read in the cells' order, not the particles'.** Of the 27 cells' worth
+// of candidates around a particle only one in six or seven is within h,
+// and each was read through its index from wherever it lay in [x]: nearly
+// every read missed the cache, and the search cost twice all the loops
+// over pairs together. The positions are copied out in the sorted order,
+// so a cell's candidates are read one after the other.
+F3D_EXPORT int32_t f3d_pbf_neighbours(const double* x, int32_t n,
+                                      double radius, int32_t* start,
+                                      int32_t* list, int32_t capacity,
+                                      int64_t* scratch) {
+  const double h = radius;
+  const double reach2 = h * h;
+  // Two words an entry in the scratch's first 2·n, the positions in sorted
+  // order in its last 3·n.
+  f3d_cell_entry* entries = (f3d_cell_entry*)scratch;
+  double* sorted = (double*)(scratch + 2 * n);
+  for (int32_t i = 0; i < n; i++) {
+    entries[i].key = pack_cell((int64_t)floor(x[3 * i] / h),
+                               (int64_t)floor(x[3 * i + 1] / h),
+                               (int64_t)floor(x[3 * i + 2] / h));
+    entries[i].index = i;
+  }
+  qsort(entries, (size_t)n, sizeof(f3d_cell_entry), compare_entries);
+  for (int32_t q = 0; q < n; q++) {
+    const int64_t j = entries[q].index;
+    sorted[3 * q] = x[3 * j];
+    sorted[3 * q + 1] = x[3 * j + 1];
+    sorted[3 * q + 2] = x[3 * j + 2];
+  }
+  int32_t count = 0;
+  start[0] = 0;
+  for (int32_t i = 0; i < n; i++) {
+    const double xi = x[3 * i], yi = x[3 * i + 1], zi = x[3 * i + 2];
+    const int64_t cx = (int64_t)floor(xi / h), cy = (int64_t)floor(yi / h),
+                  cz = (int64_t)floor(zi / h);
+    for (int64_t dx = -1; dx <= 1; dx++) {
+      for (int64_t dy = -1; dy <= 1; dy++) {
+        // The three cells from z − 1 to z + 1 are three keys in a row, z
+        // being the key's last part: one search finds the first, and the
+        // rest follow it in the sorted entries, in the order three searches
+        // gave. Where z wraps round they are not in a row, and each is
+        // searched for.
+        const int64_t first = pack_cell(cx + dx, cy + dy, cz - 1);
+        const int64_t last = pack_cell(cx + dx, cy + dy, cz + 1);
+        const int32_t runs = last == first + 2 ? 1 : 3;
+        for (int32_t run = 0; run < runs; run++) {
+          const int64_t from =
+              runs == 1 ? first : pack_cell(cx + dx, cy + dy, cz - 1 + run);
+          const int64_t to = runs == 1 ? last : from;
+          int32_t lo = 0, hi = n;
+          while (lo < hi) {
+            const int32_t mid = (lo + hi) >> 1;
+            if (entries[mid].key < from) {
+              lo = mid + 1;
+            } else {
+              hi = mid;
+            }
+          }
+          for (int32_t q = lo; q < n && entries[q].key <= to; q++) {
+            const double ex = sorted[3 * q] - xi, ey = sorted[3 * q + 1] - yi,
+                         ez = sorted[3 * q + 2] - zi;
+            if (ex * ex + ey * ey + ez * ez >= reach2) continue;
+            const int32_t j = (int32_t)entries[q].index;
+            if (j == i) continue;
+            if (count < capacity) list[count] = j;
+            count++;
+          }
+        }
+      }
+    }
+    start[i + 1] = count;
+  }
+  return count;
+}
+
+static void scalar_densities(const double* x, const int32_t* start,
+                                  const int32_t* list, int32_t n,
+                                  const double* k, double* density) {
+  const double self = poly6(k, 0.0);
+  for (int32_t i = 0; i < n; i++) {
+    const double xi = x[3 * i], yi = x[3 * i + 1], zi = x[3 * i + 2];
+    int32_t q = start[i];
+    const int32_t end = start[i + 1];
+    double w = self;
+    for (; q < end; q++) {
+      const int32_t j = list[q];
+      const double dx = xi - x[3 * j], dy = yi - x[3 * j + 1],
+                   dz = zi - x[3 * j + 2];
+      w += poly6(k, dx * dx + dy * dy + dz * dz);
+    }
+    density[i] = k[K_RHO0] * w * k[K_NORM];
+  }
+}
+
+static void scalar_normals(const double* x, const int32_t* start,
+                                const int32_t* list, int32_t n,
+                                const double* k, const double* density,
+                                double* normal) {
+  for (int32_t i = 0; i < n; i++) {
+    const double xi = x[3 * i], yi = x[3 * i + 1], zi = x[3 * i + 2];
+    double nx = 0.0, ny = 0.0, nz = 0.0;
+    for (int32_t q = start[i]; q < start[i + 1]; q++) {
+      const int32_t j = list[q];
+      const double dx = xi - x[3 * j], dy = yi - x[3 * j + 1],
+                   dz = zi - x[3 * j + 2];
+      const double f = spiky_scale(k, sqrt(dx * dx + dy * dy + dz * dz)) *
+                       k[K_H] * k[K_MASS] / density[j];
+      nx += dx * f;
+      ny += dy * f;
+      nz += dz * f;
+    }
+    normal[3 * i] = nx;
+    normal[3 * i + 1] = ny;
+    normal[3 * i + 2] = nz;
+  }
+}
+
+static void scalar_forces(const double* x, const int32_t* start,
+                               const int32_t* list, int32_t n,
+                               const double* k, const double* density,
+                               const double* normal, const double* before,
+                               const double* after, double* v, double dt) {
+  const double rho0 = k[K_RHO0];
+  for (int32_t i = 0; i < n; i++) {
+    const double xi = x[3 * i], yi = x[3 * i + 1], zi = x[3 * i + 2];
+    double ax = before[3 * i], ay = before[3 * i + 1], az = before[3 * i + 2];
+    for (int32_t q = start[i]; q < start[i + 1]; q++) {
+      const int32_t j = list[q];
+      const double dx = xi - x[3 * j], dy = yi - x[3 * j + 1],
+                   dz = zi - x[3 * j + 2];
+      const double r = sqrt(dx * dx + dy * dy + dz * dz);
+      if (r < 1e-12) continue;
+      const double kk = 2.0 * rho0 / (density[i] + density[j]);
+      const double c = -kk * k[K_GAMMA] * k[K_MASS] * cohesion(k, r) / r;
+      const double t = -kk * k[K_GAMMA];
+      ax += dx * c + (normal[3 * i] - normal[3 * j]) * t;
+      ay += dy * c + (normal[3 * i + 1] - normal[3 * j + 1]) * t;
+      az += dz * c + (normal[3 * i + 2] - normal[3 * j + 2]) * t;
+    }
+    ax += after[3 * i];
+    ay += after[3 * i + 1];
+    az += after[3 * i + 2];
+    v[3 * i] += ax * dt;
+    v[3 * i + 1] += ay * dt;
+    v[3 * i + 2] += az * dt;
+  }
+}
+
+static void scalar_lambdas(const double* p, const int32_t* start,
+                                const int32_t* list, int32_t n,
+                                const double* k, double* lambda) {
+  const double norm = k[K_NORM];
+  const double self = poly6(k, 0.0);
+  for (int32_t i = 0; i < n; i++) {
+    const double xi = p[3 * i], yi = p[3 * i + 1], zi = p[3 * i + 2];
+    double w = self, sum2 = 0.0, gx = 0.0, gy = 0.0, gz = 0.0;
+    for (int32_t q = start[i]; q < start[i + 1]; q++) {
+      const int32_t j = list[q];
+      const double dx = xi - p[3 * j], dy = yi - p[3 * j + 1],
+                   dz = zi - p[3 * j + 2];
+      const double r2 = dx * dx + dy * dy + dz * dz;
+      w += poly6(k, r2);
+      const double f = spiky_scale(k, sqrt(r2)) * norm;
+      sum2 += r2 * f * f;
+      gx += dx * f;
+      gy += dy * f;
+      gz += dz * f;
+    }
+    sum2 += gx * gx + gy * gy + gz * gz;
+    double c = w * norm - 1.0;
+    if (c < 0.0) c = 0.0;
+    lambda[i] = -c / (sum2 + 1e-6 * norm * norm / (k[K_H] * k[K_H]));
+  }
+}
+
+static void scalar_deltas(const double* p, const int32_t* start,
+                               const int32_t* list, int32_t n,
+                               const double* k, const double* lambda,
+                               double* delta) {
+  const double norm = k[K_NORM];
+  for (int32_t i = 0; i < n; i++) {
+    const double xi = p[3 * i], yi = p[3 * i + 1], zi = p[3 * i + 2];
+    double sx = 0.0, sy = 0.0, sz = 0.0;
+    for (int32_t q = start[i]; q < start[i + 1]; q++) {
+      const int32_t j = list[q];
+      const double dx = xi - p[3 * j], dy = yi - p[3 * j + 1],
+                   dz = zi - p[3 * j + 2];
+      const double r2 = dx * dx + dy * dy + dz * dz;
+      const double ratio = poly6(k, r2) / k[K_WQ];
+      const double corr =
+          -0.02 * ratio * ratio * ratio * ratio / k[K_REST_STIFFNESS];
+      const double f =
+          spiky_scale(k, sqrt(r2)) * (lambda[i] + lambda[j] + corr) * norm;
+      sx += dx * f;
+      sy += dy * f;
+      sz += dz * f;
+    }
+    delta[3 * i] = sx;
+    delta[3 * i + 1] = sy;
+    delta[3 * i + 2] = sz;
+  }
+}
+
+static void scalar_viscosity(const double* p, const double* v,
+                                  const int32_t* start, const int32_t* list,
+                                  int32_t n, const double* k, double share,
+                                  double* smoothed) {
+  const double norm = k[K_NORM];
+  for (int32_t i = 0; i < n; i++) {
+    const double xi = p[3 * i], yi = p[3 * i + 1], zi = p[3 * i + 2];
+    const double vx = v[3 * i], vy = v[3 * i + 1], vz = v[3 * i + 2];
+    double sx = vx, sy = vy, sz = vz;
+    for (int32_t q = start[i]; q < start[i + 1]; q++) {
+      const int32_t j = list[q];
+      const double dx = xi - p[3 * j], dy = yi - p[3 * j + 1],
+                   dz = zi - p[3 * j + 2];
+      const double w = poly6(k, dx * dx + dy * dy + dz * dz) * norm * share;
+      sx += (v[3 * j] - vx) * w;
+      sy += (v[3 * j + 1] - vy) * w;
+      sz += (v[3 * j + 2] - vz) * w;
+    }
+    smoothed[3 * i] = sx;
+    smoothed[3 * i + 1] = sy;
+    smoothed[3 * i + 2] = sz;
+  }
+}
+
+// ------------------------------------------------------------ the widths
+
+#if F3D_VECTOR
+#define F3D_W 2
+#define F3D_NAME(name) name##_w2
+#include "pbf_lanes.h"
+#undef F3D_W
+#undef F3D_NAME
+
+#if F3D_X86
+#if defined(__clang__)
+#pragma clang attribute push(__attribute__((target("avx2"))), apply_to = function)
+#else
+#pragma GCC push_options
+#pragma GCC target("avx2")
+#endif
+#define F3D_W 4
+#define F3D_NAME(name) name##_w4
+#include "pbf_lanes.h"
+#undef F3D_W
+#undef F3D_NAME
+#if defined(__clang__)
+#pragma clang attribute pop
+#else
+#pragma GCC pop_options
+#endif
+
+#if defined(__clang__)
+#pragma clang attribute push(__attribute__((target("avx512f"))), apply_to = function)
+#else
+#pragma GCC push_options
+#pragma GCC target("avx512f")
+#endif
+#define F3D_W 8
+#define F3D_NAME(name) name##_w8
+#include "pbf_lanes.h"
+#undef F3D_W
+#undef F3D_NAME
+#if defined(__clang__)
+#pragma clang attribute pop
+#else
+#pragma GCC pop_options
+#endif
+#else
+// Off x86-64 the wider widths are built for the baseline: four lanes are
+// two NEON registers an operation, eight are four. Built so that a test
+// can hold them to the Dart kernels on any machine; which one runs by
+// default is [f3d_pbf_lanes]'s choice.
+#define F3D_W 4
+#define F3D_NAME(name) name##_w4
+#include "pbf_lanes.h"
+#undef F3D_W
+#undef F3D_NAME
+#define F3D_W 8
+#define F3D_NAME(name) name##_w8
+#include "pbf_lanes.h"
+#undef F3D_W
+#undef F3D_NAME
+#endif
+#endif
+
+// The widest the running processor can take: 1 without vector extensions.
+static int32_t f3d_widest(void) {
+#if !F3D_VECTOR
+  return 1;
+#elif F3D_X86
+  __builtin_cpu_init();
+  if (__builtin_cpu_supports("avx512f")) return 8;
+  if (__builtin_cpu_supports("avx2")) return 4;
+  return 2;
+#else
+  return 8;
+#endif
+}
+
+// The lanes in use: 0 until first asked. Written once with the same value
+// by whichever isolate asks first, or set by a test.
+static int32_t f3d_lanes = 0;
+
+// **Four on x86-64 where there is AVX2, not the widest there is.** On a
+// CI runner with AVX-512F, eight lanes were as fast as four built with gcc
+// and slower built with clang (0.67 and 0.77 ms against 0.70 and 0.65): the
+// loops wait on gathering each neighbour's numbers, not on arithmetic.
+// Four against two was 1.5 times as fast.
+static int32_t f3d_default_lanes(void) {
+#if F3D_X86
+  return f3d_widest() >= 4 ? 4 : 2;
+#elif F3D_VECTOR
+  return F3D_ARM_LANES;
+#else
+  return 1;
+#endif
+}
+
+// How many neighbours each pair loop takes at a time: 1, 2, 4 or 8.
+F3D_EXPORT int32_t f3d_pbf_lanes(void) {
+  if (f3d_lanes == 0) f3d_lanes = f3d_default_lanes();
+  return f3d_lanes;
+}
+
+// Sets the lanes to [lanes] where the processor has them, and returns the
+// lanes now in use: for a test to hold each width to the Dart kernels.
+// 0 goes back to the running processor's default.
+F3D_EXPORT int32_t f3d_pbf_set_lanes(int32_t lanes) {
+  if (lanes == 0) {
+    f3d_lanes = f3d_default_lanes();
+  } else if ((lanes == 1 || lanes == 2 || lanes == 4 || lanes == 8) &&
+             lanes <= f3d_widest()) {
+    f3d_lanes = lanes;
+  }
+  return f3d_pbf_lanes();
+}
+
+#if F3D_VECTOR
+#define F3D_DISPATCH(name, ...)              \
+  switch (f3d_pbf_lanes()) {                 \
+    case 8:                                  \
+      name##_w8(__VA_ARGS__);                \
+      return;                                \
+    case 4:                                  \
+      name##_w4(__VA_ARGS__);                \
+      return;                                \
+    case 2:                                  \
+      name##_w2(__VA_ARGS__);                \
+      return;                                \
+    default:                                 \
+      scalar_##name(__VA_ARGS__);            \
+      return;                                \
+  }
+#else
+#define F3D_DISPATCH(name, ...) scalar_##name(__VA_ARGS__);
+#endif
+
+F3D_EXPORT void f3d_pbf_densities(const double* x, const int32_t* start,
+                                  const int32_t* list, int32_t n,
+                                  const double* k, double* density) {
+  F3D_DISPATCH(densities, x, start, list, n, k, density)
+}
+
+F3D_EXPORT void f3d_pbf_normals(const double* x, const int32_t* start,
+                                const int32_t* list, int32_t n,
+                                const double* k, const double* density,
+                                double* normal) {
+  F3D_DISPATCH(normals, x, start, list, n, k, density, normal)
+}
+
+F3D_EXPORT void f3d_pbf_forces(const double* x, const int32_t* start,
+                               const int32_t* list, int32_t n,
+                               const double* k, const double* density,
+                               const double* normal, const double* before,
+                               const double* after, double* v, double dt) {
+  F3D_DISPATCH(forces, x, start, list, n, k, density, normal, before, after,
+               v, dt)
+}
+
+F3D_EXPORT void f3d_pbf_lambdas(const double* p, const int32_t* start,
+                                const int32_t* list, int32_t n,
+                                const double* k, double* lambda) {
+  F3D_DISPATCH(lambdas, p, start, list, n, k, lambda)
+}
+
+F3D_EXPORT void f3d_pbf_deltas(const double* p, const int32_t* start,
+                               const int32_t* list, int32_t n,
+                               const double* k, const double* lambda,
+                               double* delta) {
+  F3D_DISPATCH(deltas, p, start, list, n, k, lambda, delta)
+}
+
+F3D_EXPORT void f3d_pbf_viscosity(const double* p, const double* v,
+                                  const int32_t* start, const int32_t* list,
+                                  int32_t n, const double* k, double share,
+                                  double* smoothed) {
+  F3D_DISPATCH(viscosity, p, v, start, list, n, k, share, smoothed)
+}
diff --git a/packages/flutter3d_physics/src/pbf_lanes.h b/packages/flutter3d_physics/src/pbf_lanes.h
new file mode 100644
index 000000000..a84e25104
--- /dev/null
+++ b/packages/flutter3d_physics/src/pbf_lanes.h
@@ -0,0 +1,322 @@
+// The pair loops of `pbf_kernels.c`, F3D_W neighbours at a time: included
+// once for each width, with F3D_W and F3D_NAME(name) set by the includer
+// (and, for the AVX2 width on x86-64, inside a target that allows it).
+//
+// Each loop takes the neighbours F3D_W at a time, a lane each, and the last
+// few one at a time as the scalar loop does; the lanes are summed at the end
+// in order. The sums so come out in another order than the scalar loop's,
+// and so differ from it, and from Dart, in the last few bits.
+//
+// Branches become masks: a lane a kernel is nil for (past h, or at the same
+// point) is computed anyway, inf or NaN as may be, and then cleared by
+// and-ing its bits with the mask.
+
+typedef double F3D_NAME(vd) __attribute__((vector_size(F3D_W * 8)));
+typedef long long F3D_NAME(vi) __attribute__((vector_size(F3D_W * 8)));
+#define VD F3D_NAME(vd)
+#define VI F3D_NAME(vi)
+// Lanes of [a] where [m] is set, nil elsewhere; [a] where set, [b] where not.
+#define KEEP(m, a) ((VD)((VI)(a) & (m)))
+#define PICK(m, a, b) ((VD)(((VI)(a) & (m)) | ((VI)(b) & ~(m))))
+
+// Component [c] of the points [list] names from [q] on, a lane each.
+static inline VD F3D_NAME(gather3)(const double* a, const int32_t* list,
+                                   int32_t q, int c) {
+  VD r;
+  for (int l = 0; l < F3D_W; l++) r[l] = a[3 * list[q + l] + c];
+  return r;
+}
+
+static inline VD F3D_NAME(gather1)(const double* a, const int32_t* list,
+                                   int32_t q) {
+  VD r;
+  for (int l = 0; l < F3D_W; l++) r[l] = a[list[q + l]];
+  return r;
+}
+
+static inline VD F3D_NAME(root)(VD r2) {
+  VD r;
+  for (int l = 0; l < F3D_W; l++) r[l] = sqrt(r2[l]);
+  return r;
+}
+
+static inline double F3D_NAME(sum)(VD v) {
+  double s = 0.0;
+  for (int l = 0; l < F3D_W; l++) s += v[l];
+  return s;
+}
+
+static inline VD F3D_NAME(poly6)(const double* k, VD r2) {
+  const VD d = k[K_H2] - r2;
+  return KEEP((VI)(d > 0.0), k[K_POLY6] * d * d * d);
+}
+
+static inline VD F3D_NAME(spiky)(const double* k, VD r) {
+  const VD hr = k[K_H] - r;
+  const VI live = (VI)(r > 1e-12) & (VI)(r < k[K_H]);
+  return KEEP(live, k[K_SPIKY] * hr * hr / r);
+}
+
+static inline VD F3D_NAME(cohesion)(const double* k, VD r) {
+  const double h = k[K_H];
+  const VD hr = h - r;
+  const VD a = hr * hr * hr * r * r * r;
+  const VI live = (VI)(r < h) & (VI)(r > 0.0);
+  const VI far = (VI)(2.0 * r > h);
+  const VD value =
+      PICK(far, k[K_COHESION] * a, k[K_COHESION] * (2.0 * a - k[K_H6] / 64.0));
+  return KEEP(live, value);
+}
+
+static void F3D_NAME(densities)(const double* x, const int32_t* start,
+                                const int32_t* list, int32_t n,
+                                const double* k, double* density) {
+  const double self = poly6(k, 0.0);
+  for (int32_t i = 0; i < n; i++) {
+    const double xi = x[3 * i], yi = x[3 * i + 1], zi = x[3 * i + 2];
+    int32_t q = start[i];
+    const int32_t end = start[i + 1];
+    VD acc = {0.0};
+    for (; q + F3D_W <= end; q += F3D_W) {
+      const VD dx = xi - F3D_NAME(gather3)(x, list, q, 0);
+      const VD dy = yi - F3D_NAME(gather3)(x, list, q, 1);
+      const VD dz = zi - F3D_NAME(gather3)(x, list, q, 2);
+      acc += F3D_NAME(poly6)(k, dx * dx + dy * dy + dz * dz);
+    }
+    double w = self + F3D_NAME(sum)(acc);
+    for (; q < end; q++) {
+      const int32_t j = list[q];
+      const double dx = xi - x[3 * j], dy = yi - x[3 * j + 1],
+                   dz = zi - x[3 * j + 2];
+      w += poly6(k, dx * dx + dy * dy + dz * dz);
+    }
+    density[i] = k[K_RHO0] * w * k[K_NORM];
+  }
+}
+
+static void F3D_NAME(normals)(const double* x, const int32_t* start,
+                              const int32_t* list, int32_t n,
+                              const double* k, const double* density,
+                              double* normal) {
+  const double hm = k[K_H] * k[K_MASS];
+  for (int32_t i = 0; i < n; i++) {
+    const double xi = x[3 * i], yi = x[3 * i + 1], zi = x[3 * i + 2];
+    int32_t q = start[i];
+    const int32_t end = start[i + 1];
+    VD ax = {0.0}, ay = {0.0}, az = {0.0};
+    for (; q + F3D_W <= end; q += F3D_W) {
+      const VD dx = xi - F3D_NAME(gather3)(x, list, q, 0);
+      const VD dy = yi - F3D_NAME(gather3)(x, list, q, 1);
+      const VD dz = zi - F3D_NAME(gather3)(x, list, q, 2);
+      const VD r = F3D_NAME(root)(dx * dx + dy * dy + dz * dz);
+      const VD f = F3D_NAME(spiky)(k, r) * hm /
+                   F3D_NAME(gather1)(density, list, q);
+      ax += dx * f;
+      ay += dy * f;
+      az += dz * f;
+    }
+    double nx = F3D_NAME(sum)(ax), ny = F3D_NAME(sum)(ay),
+           nz = F3D_NAME(sum)(az);
+    for (; q < end; q++) {
+      const int32_t j = list[q];
+      const double dx = xi - x[3 * j], dy = yi - x[3 * j + 1],
+                   dz = zi - x[3 * j + 2];
+      const double f = spiky_scale(k, sqrt(dx * dx + dy * dy + dz * dz)) *
+                       k[K_H] * k[K_MASS] / density[j];
+      nx += dx * f;
+      ny += dy * f;
+      nz += dz * f;
+    }
+    normal[3 * i] = nx;
+    normal[3 * i + 1] = ny;
+    normal[3 * i + 2] = nz;
+  }
+}
+
+static void F3D_NAME(forces)(const double* x, const int32_t* start,
+                             const int32_t* list, int32_t n, const double* k,
+                             const double* density, const double* normal,
+                             const double* before, const double* after,
+                             double* v, double dt) {
+  const double rho0 = k[K_RHO0];
+  const double gm = k[K_GAMMA] * k[K_MASS];
+  for (int32_t i = 0; i < n; i++) {
+    const double xi = x[3 * i], yi = x[3 * i + 1], zi = x[3 * i + 2];
+    const double di = density[i];
+    const double nxi = normal[3 * i], nyi = normal[3 * i + 1],
+                 nzi = normal[3 * i + 2];
+    int32_t q = start[i];
+    const int32_t end = start[i + 1];
+    VD sx = {0.0}, sy = {0.0}, sz = {0.0};
+    for (; q + F3D_W <= end; q += F3D_W) {
+      const VD dx = xi - F3D_NAME(gather3)(x, list, q, 0);
+      const VD dy = yi - F3D_NAME(gather3)(x, list, q, 1);
+      const VD dz = zi - F3D_NAME(gather3)(x, list, q, 2);
+      const VD r = F3D_NAME(root)(dx * dx + dy * dy + dz * dz);
+      const VI apart = (VI)(r >= 1e-12);
+      const VD kk = 2.0 * rho0 / (di + F3D_NAME(gather1)(density, list, q));
+      const VD c = -kk * gm * F3D_NAME(cohesion)(k, r) / r;
+      const VD t = -kk * k[K_GAMMA];
+      sx += KEEP(apart,
+                 dx * c + (nxi - F3D_NAME(gather3)(normal, list, q, 0)) * t);
+      sy += KEEP(apart,
+                 dy * c + (nyi - F3D_NAME(gather3)(normal, list, q, 1)) * t);
+      sz += KEEP(apart,
+                 dz * c + (nzi - F3D_NAME(gather3)(normal, list, q, 2)) * t);
+    }
+    double ax = before[3 * i] + F3D_NAME(sum)(sx);
+    double ay = before[3 * i + 1] + F3D_NAME(sum)(sy);
+    double az = before[3 * i + 2] + F3D_NAME(sum)(sz);
+    for (; q < end; q++) {
+      const int32_t j = list[q];
+      const double dx = xi - x[3 * j], dy = yi - x[3 * j + 1],
+                   dz = zi - x[3 * j + 2];
+      const double r = sqrt(dx * dx + dy * dy + dz * dz);
+      if (r < 1e-12) continue;
+      const double kk = 2.0 * rho0 / (di + density[j]);
+      const double c = -kk * gm * cohesion(k, r) / r;
+      const double t = -kk * k[K_GAMMA];
+      ax += dx * c + (nxi - normal[3 * j]) * t;
+      ay += dy * c + (nyi - normal[3 * j + 1]) * t;
+      az += dz * c + (nzi - normal[3 * j + 2]) * t;
+    }
+    ax += after[3 * i];
+    ay += after[3 * i + 1];
+    az += after[3 * i + 2];
+    v[3 * i] += ax * dt;
+    v[3 * i + 1] += ay * dt;
+    v[3 * i + 2] += az * dt;
+  }
+}
+
+static void F3D_NAME(lambdas)(const double* p, const int32_t* start,
+                              const int32_t* list, int32_t n,
+                              const double* k, double* lambda) {
+  const double norm = k[K_NORM];
+  const double self = poly6(k, 0.0);
+  for (int32_t i = 0; i < n; i++) {
+    const double xi = p[3 * i], yi = p[3 * i + 1], zi = p[3 * i + 2];
+    int32_t q = start[i];
+    const int32_t end = start[i + 1];
+    VD vw = {0.0}, vs = {0.0}, vx = {0.0}, vy = {0.0}, vz = {0.0};
+    for (; q + F3D_W <= end; q += F3D_W) {
+      const VD dx = xi - F3D_NAME(gather3)(p, list, q, 0);
+      const VD dy = yi - F3D_NAME(gather3)(p, list, q, 1);
+      const VD dz = zi - F3D_NAME(gather3)(p, list, q, 2);
+      const VD r2 = dx * dx + dy * dy + dz * dz;
+      vw += F3D_NAME(poly6)(k, r2);
+      const VD f = F3D_NAME(spiky)(k, F3D_NAME(root)(r2)) * norm;
+      vs += r2 * f * f;
+      vx += dx * f;
+      vy += dy * f;
+      vz += dz * f;
+    }
+    double w = self + F3D_NAME(sum)(vw), sum2 = F3D_NAME(sum)(vs);
+    double gx = F3D_NAME(sum)(vx), gy = F3D_NAME(sum)(vy),
+           gz = F3D_NAME(sum)(vz);
+    for (; q < end; q++) {
+      const int32_t j = list[q];
+      const double dx = xi - p[3 * j], dy = yi - p[3 * j + 1],
+                   dz = zi - p[3 * j + 2];
+      const double r2 = dx * dx + dy * dy + dz * dz;
+      w += poly6(k, r2);
+      const double f = spiky_scale(k, sqrt(r2)) * norm;
+      sum2 += r2 * f * f;
+      gx += dx * f;
+      gy += dy * f;
+      gz += dz * f;
+    }
+    sum2 += gx * gx + gy * gy + gz * gz;
+    double c = w * norm - 1.0;
+    if (c < 0.0) c = 0.0;
+    lambda[i] = -c / (sum2 + 1e-6 * norm * norm / (k[K_H] * k[K_H]));
+  }
+}
+
+static void F3D_NAME(deltas)(const double* p, const int32_t* start,
+                             const int32_t* list, int32_t n, const double* k,
+                             const double* lambda, double* delta) {
+  const double norm = k[K_NORM];
+  const double corr_scale = -0.02 / k[K_REST_STIFFNESS];
+  for (int32_t i = 0; i < n; i++) {
+    const double xi = p[3 * i], yi = p[3 * i + 1], zi = p[3 * i + 2];
+    const double li = lambda[i];
+    int32_t q = start[i];
+    const int32_t end = start[i + 1];
+    VD vx = {0.0}, vy = {0.0}, vz = {0.0};
+    for (; q + F3D_W <= end; q += F3D_W) {
+      const VD dx = xi - F3D_NAME(gather3)(p, list, q, 0);
+      const VD dy = yi - F3D_NAME(gather3)(p, list, q, 1);
+      const VD dz = zi - F3D_NAME(gather3)(p, list, q, 2);
+      const VD r2 = dx * dx + dy * dy + dz * dz;
+      const VD ratio = F3D_NAME(poly6)(k, r2) / k[K_WQ];
+      const VD corr = ratio * ratio * ratio * ratio * corr_scale;
+      const VD f = F3D_NAME(spiky)(k, F3D_NAME(root)(r2)) *
+                   (li + F3D_NAME(gather1)(lambda, list, q) + corr) * norm;
+      vx += dx * f;
+      vy += dy * f;
+      vz += dz * f;
+    }
+    double sx = F3D_NAME(sum)(vx), sy = F3D_NAME(sum)(vy),
+           sz = F3D_NAME(sum)(vz);
+    for (; q < end; q++) {
+      const int32_t j = list[q];
+      const double dx = xi - p[3 * j], dy = yi - p[3 * j + 1],
+                   dz = zi - p[3 * j + 2];
+      const double r2 = dx * dx + dy * dy + dz * dz;
+      const double ratio = poly6(k, r2) / k[K_WQ];
+      const double corr =
+          -0.02 * ratio * ratio * ratio * ratio / k[K_REST_STIFFNESS];
+      const double f =
+          spiky_scale(k, sqrt(r2)) * (li + lambda[j] + corr) * norm;
+      sx += dx * f;
+      sy += dy * f;
+      sz += dz * f;
+    }
+    delta[3 * i] = sx;
+    delta[3 * i + 1] = sy;
+    delta[3 * i + 2] = sz;
+  }
+}
+
+static void F3D_NAME(viscosity)(const double* p, const double* v,
+                                const int32_t* start, const int32_t* list,
+                                int32_t n, const double* k, double share,
+                                double* smoothed) {
+  const double scale = k[K_NORM] * share;
+  for (int32_t i = 0; i < n; i++) {
+    const double xi = p[3 * i], yi = p[3 * i + 1], zi = p[3 * i + 2];
+    const double vxi = v[3 * i], vyi = v[3 * i + 1], vzi = v[3 * i + 2];
+    int32_t q = start[i];
+    const int32_t end = start[i + 1];
+    VD ax = {0.0}, ay = {0.0}, az = {0.0};
+    for (; q + F3D_W <= end; q += F3D_W) {
+      const VD dx = xi - F3D_NAME(gather3)(p, list, q, 0);
+      const VD dy = yi - F3D_NAME(gather3)(p, list, q, 1);
+      const VD dz = zi - F3D_NAME(gather3)(p, list, q, 2);
+      const VD w = F3D_NAME(poly6)(k, dx * dx + dy * dy + dz * dz) * scale;
+      ax += (F3D_NAME(gather3)(v, list, q, 0) - vxi) * w;
+      ay += (F3D_NAME(gather3)(v, list, q, 1) - vyi) * w;
+      az += (F3D_NAME(gather3)(v, list, q, 2) - vzi) * w;
+    }
+    double sx = vxi + F3D_NAME(sum)(ax), sy = vyi + F3D_NAME(sum)(ay),
+           sz = vzi + F3D_NAME(sum)(az);
+    for (; q < end; q++) {
+      const int32_t j = list[q];
+      const double dx = xi - p[3 * j], dy = yi - p[3 * j + 1],
+                   dz = zi - p[3 * j + 2];
+      const double w = poly6(k, dx * dx + dy * dy + dz * dz) * scale;
+      sx += (v[3 * j] - vxi) * w;
+      sy += (v[3 * j + 1] - vyi) * w;
+      sz += (v[3 * j + 2] - vzi) * w;
+    }
+    smoothed[3 * i] = sx;
+    smoothed[3 * i + 1] = sy;
+    smoothed[3 * i + 2] = sz;
+  }
+}
+
+#undef VD
+#undef VI
+#undef KEEP
+#undef PICK
diff --git a/packages/flutter3d_physics/src/surface_modes.c b/packages/flutter3d_physics/src/surface_modes.c
new file mode 100644
index 000000000..d476e01d2
--- /dev/null
+++ b/packages/flutter3d_physics/src/surface_modes.c
@@ -0,0 +1,120 @@
+// The heavy half of `FreeSurface.solveModes`, in C: the banded Cholesky
+// factor of the surface's graph Laplacian (shifted by σ) and the Lanczos
+// steps on its inverse, with full reorthogonalisation. What comes back, the
+// tridiagonal and its basis, is finished in Dart: the tridiagonal is at most
+// a few dozen across.
+//
+// Step for step the Dart one; held to it within a tolerance, since the
+// compiler may fuse a multiply and an add where Dart rounds twice.
+
+#include <math.h>
+#include <stdint.h>
+#include <string.h>
+
+#if defined(_WIN32)
+#define F3D_EXPORT __declspec(dllexport)
+#else
+#define F3D_EXPORT __attribute__((visibility("default")))
+#endif
+
+static double dot(const double* a, const double* b, int32_t n) {
+  double s = 0.0;
+  for (int32_t i = 0; i < n; i++) s += a[i] * b[i];
+  return s;
+}
+
+static void remove_mean(double* a, int32_t n) {
+  double mean = 0.0;
+  for (int32_t i = 0; i < n; i++) mean += a[i];
+  mean /= n;
+  for (int32_t i = 0; i < n; i++) a[i] -= mean;
+}
+
+// x = (L + σ)⁻¹ b on the flat-free part, by the factor's two sweeps.
+static void solve(const double* factor, int32_t n, int32_t band,
+                  const double* b, double* x) {
+  const int32_t w1 = band + 1;
+  memcpy(x, b, sizeof(double) * (size_t)n);
+  remove_mean(x, n);
+  for (int32_t i = 0; i < n; i++) {
+    double sum = x[i];
+    const int32_t lo = i - band > 0 ? i - band : 0;
+    for (int32_t k = lo; k < i; k++) sum -= factor[i * w1 + (i - k)] * x[k];
+    x[i] = sum / factor[i * w1];
+  }
+  for (int32_t i = n - 1; i >= 0; i--) {
+    double sum = x[i];
+    const int32_t hi = i + band < n - 1 ? i + band : n - 1;
+    for (int32_t k = i + 1; k <= hi; k++) {
+      sum -= factor[k * w1 + (k - i)] * x[k];
+    }
+    x[i] = sum / factor[i * w1];
+  }
+  remove_mean(x, n);
+}
+
+// Lanczos on (L + σ)⁻¹ from [q0] for at most [steps] steps: [basis] (steps
+// rows of n), [alpha] and [beta] (one fewer). Returns how many steps ran.
+// [scratch] holds n·(band + 1) + 2·n doubles, the caller's own.
+F3D_EXPORT int32_t f3d_surface_lanczos(int32_t n, const int32_t* start,
+                                       const int32_t* adjacent, double cell2,
+                                       int32_t band, int32_t steps,
+                                       const double* q0, double* basis,
+                                       double* alpha, double* beta,
+                                       double* scratch) {
+  const double inv = 1.0 / cell2;
+  const double sigma = 1e-6 * inv;
+  const int32_t w1 = band + 1;
+  double* factor = scratch;
+  double* w = scratch + (size_t)n * w1;
+  double* previous = w + n;
+  memset(factor, 0, sizeof(double) * (size_t)n * w1);
+  for (int32_t i = 0; i < n; i++) {
+    factor[i * w1] = (start[i + 1] - start[i]) * inv + sigma;
+    for (int32_t q = start[i]; q < start[i + 1]; q++) {
+      const int32_t k = adjacent[q];
+      if (k < i) factor[i * w1 + (i - k)] = -inv;
+    }
+  }
+  for (int32_t i = 0; i < n; i++) {
+    const int32_t lo = i - band > 0 ? i - band : 0;
+    for (int32_t j = lo; j <= i; j++) {
+      double sum = factor[i * w1 + (i - j)];
+      const int32_t from = lo > j - band ? lo : j - band;
+      for (int32_t k = from; k < j; k++) {
+        sum -= factor[i * w1 + (i - k)] * factor[j * w1 + (j - k)];
+      }
+      factor[i * w1 + (i - j)] =
+          i == j ? sqrt(sum > 1e-300 ? sum : 1e-300) : sum / factor[j * w1];
+    }
+  }
+  memset(previous, 0, sizeof(double) * (size_t)n);
+  memcpy(basis, q0, sizeof(double) * (size_t)n);
+  double b = 0.0;
+  int32_t size = 0;
+  for (int32_t m = 0; m < steps; m++) {
+    const double* q = basis + (size_t)m * n;
+    solve(factor, n, band, q, w);
+    for (int32_t i = 0; i < n; i++) w[i] -= b * previous[i];
+    const double a = dot(w, q, n);
+    for (int32_t i = 0; i < n; i++) w[i] -= a * q[i];
+    // Full reorthogonalisation, twice: Lanczos alone loses it.
+    for (int32_t pass = 0; pass < 2; pass++) {
+      for (int32_t v = 0; v <= m; v++) {
+        const double* row = basis + (size_t)v * n;
+        const double c = dot(w, row, n);
+        for (int32_t i = 0; i < n; i++) w[i] -= c * row[i];
+      }
+      remove_mean(w, n);
+    }
+    alpha[m] = a;
+    size = m + 1;
+    b = sqrt(dot(w, w, n));
+    if (b < 1e-12 * fabs(a) || m == steps - 1) break;
+    beta[m] = b;
+    memcpy(previous, q, sizeof(double) * (size_t)n);
+    double* next = basis + (size_t)(m + 1) * n;
+    for (int32_t i = 0; i < n; i++) next[i] = w[i] / b;
+  }
+  return size;
+}
diff --git a/packages/flutter3d_physics/test/fluid/atmosphere_test.dart b/packages/flutter3d_physics/test/fluid/atmosphere_test.dart
new file mode 100644
index 000000000..1de215c07
--- /dev/null
+++ b/packages/flutter3d_physics/test/fluid/atmosphere_test.dart
@@ -0,0 +1,144 @@
+import 'dart:math' as math;
+
+import 'package:flutter3d_physics/flutter3d_physics.dart';
+import 'package:test/test.dart';
+import 'package:vector_math/vector_math.dart';
+
+void main() {
+  test('room air is what the tables say', () {
+    // Dry air at 20 °C and an atmosphere: 1.204 kg/m³ and 18.1 µPa·s;
+    // water's saturation pressure there, 2339 Pa.
+    final dry = Atmosphere(humidity: 0.0);
+    expect(dry.density, closeTo(1.204, 1.204 * 0.005));
+    expect(dry.viscosity, closeTo(1.81e-5, 1.81e-5 * 0.01));
+    expect(
+      VapourCurve.water.saturationPressure(293.15),
+      closeTo(2339.0, 2339.0 * 0.005),
+    );
+    // Damp air is lighter: water vapour is lighter than the air it
+    // displaces.
+    expect(Atmosphere(humidity: 1.0).density, lessThan(dry.density));
+  });
+
+  test('a millimetre drop falls at the speed Gunn and Kinzer measured', () {
+    // 4.03 m/s for a drop a millimetre across (Gunn and Kinzer, 1949).
+    // Mutation: leave the air out, and it is still gathering speed at
+    // thirty metres a second.
+    const d = 0.001;
+    // One particle holding a millimetre drop's volume.
+    final spacing = math.pow(math.pi / 6.0, 1.0 / 3.0) * d;
+    final fluid = ParticleFluid(medium: FluidMedium.water, spacing: spacing)
+      ..inject(math.pi / 6.0 * d * d * d, Vector3(0, 100, 0), Vector3.zero());
+    final air = Atmosphere();
+    final before = fluid.positions.single.y;
+    for (var i = 0; i < 240 * 3; i++) {
+      fluid.step(1 / 240, gravity: Vector3(0, -9.81, 0), air: air);
+    }
+    final y0 = fluid.positions.single.y;
+    fluid.step(1 / 240, gravity: Vector3(0, -9.81, 0), air: air);
+    final speed = (y0 - fluid.positions.single.y) * 240;
+    expect(before, greaterThan(y0));
+    // Schiller and Naumann's is a rigid sphere's drag, and gives 3.83: a
+    // drop's inside circulates and it falls a little faster than a ball,
+    // which this does not model. Within six percent of the measurement.
+    expect(speed, closeTo(4.03, 4.03 * 0.06));
+  });
+
+  test('a wind across a stream carries it downwind', () {
+    Vector3 lowest(Atmosphere? air) {
+      final jet = Jet(medium: FluidMedium.water, breakupGrowth: 1e9);
+      for (var k = 0; k < 200; k++) {
+        jet.emit(
+          flow: 1e-6,
+          dt: 1 / 1000,
+          point: Vector3(0, 1, 0),
+          velocity: Vector3(0, -0.1, 0),
+          width: 0.002,
+          across: Vector3(0, 0, 1),
+        );
+        jet.step(1 / 1000, gravity: Vector3(0, -9.81, 0), air: air);
+      }
+      return jet.runs.single.last.position;
+    }
+
+    // Mutation: drop the drag, and the stream falls straight.
+    expect(lowest(null).x, closeTo(0.0, 1e-12));
+    final blown = lowest(Atmosphere(wind: Vector3(3, 0, 0)));
+    expect(blown.x, greaterThan(1e-4));
+  });
+
+  test('a puddle evaporates, leaves what was in it, and is counted', () {
+    final world = FluidWorld(
+      gravity: Vector3(0, -9.81, 0),
+      floor: [PlaneObstacle(normal: Vector3(0, 1, 0), offset: 0)],
+      atmosphere: Atmosphere(humidity: 0.3),
+    );
+    final bench = world.spills.single
+      ..receive(
+        1e-7,
+        Vector3(0, 0.001, 0),
+        Vector3.zero(),
+        FluidMedium.water,
+        const {'salt': 2.0},
+      );
+    final total = world.volume;
+    final puddle = bench.puddles.single;
+    for (var i = 0; i < 240 * 60; i++) {
+      world.advance(world.step);
+    }
+    // A minute in drier air takes some of it.
+    expect(world.evaporated, greaterThan(0.0));
+    expect(puddle.volume, lessThan(1e-7));
+    // The salt stayed: the same amount in less water.
+    expect(
+      puddle.concentrations['salt']! * puddle.volume,
+      closeTo(2.0 * 1e-7, 1e-15),
+    );
+    // Mutation: lose the vapour from the count, and the world is short.
+    expect(world.volume, closeTo(total, total * 1e-9));
+  });
+
+  test('flat, a puddle evaporates as a disc does, 4·R·D·Δc', () {
+    final air = Atmosphere(humidity: 0.5);
+    final flat = FluidMedium.water.copyWith(contactAngle: 0.0);
+    final puddle = Puddle(
+      medium: flat,
+      centre: Vector3.zero(),
+      normal: Vector3(0, 1, 0),
+    )..add(1e-6, Vector3.zero(), const {});
+    final r = puddle.radius(9.81);
+    final gone = puddle.evaporate(1.0, air, 9.81);
+    final disc =
+        4.0 *
+        r *
+        air.vapourDiffusivity *
+        air.vapourDeficit(flat) /
+        flat.density;
+    expect(gone, closeTo(disc, disc * 0.03));
+  });
+
+  test('a tube evaporates up the air over its liquid and out of its mouth', () {
+    // Stefan's tube: L/(D·A) for the column to the mouth, then 1/(4·D·r)
+    // from the mouth out, in series. An hour, in one go.
+    const r = 0.008;
+    final tube = LiquidBody(
+      shape: RevolvedVessel([Vector2(0, 0), Vector2(r, 0), Vector2(r, 0.1)]),
+      medium: FluidMedium.water,
+      volume: math.pi * r * r * 0.06,
+      modes: 2,
+    )..place(Matrix3.identity(), Vector3.zero());
+    tube.pour(0.0, concentrations: const {});
+    final air = Atmosphere(humidity: 0.5);
+    final before = tube.volume;
+    final gone = tube.evaporate(3600.0, air);
+    final d = air.vapourDiffusivity;
+    final column = 0.1 - tube.height;
+    final rate =
+        air.vapourDeficit(FluidMedium.water) /
+        (column / (d * math.pi * r * r) + 1.0 / (4.0 * d * r));
+    expect(gone, closeTo(rate * 3600.0 / 998.2, rate * 3600.0 / 998.2 * 0.01));
+    expect(tube.volume, closeTo(before - gone, 1e-18));
+    // About three microlitres an hour: why an open tube on a bench keeps.
+    expect(gone, inInclusiveRange(1e-9, 1e-8));
+  });
+}
diff --git a/packages/flutter3d_physics/test/fluid/background_test.dart b/packages/flutter3d_physics/test/fluid/background_test.dart
new file mode 100644
index 000000000..8bedcf10b
--- /dev/null
+++ b/packages/flutter3d_physics/test/fluid/background_test.dart
@@ -0,0 +1,113 @@
+// The background is another isolate, which the web has not: there what
+// would be put off is worked out at once, and nothing here applies.
+@TestOn('vm')
+library;
+
+import 'dart:math' as math;
+import 'dart:typed_data';
+
+import 'package:flutter3d_physics/flutter3d_physics.dart';
+import 'package:test/test.dart';
+import 'package:vector_math/vector_math.dart';
+
+/// Lets the other isolate answer everything it has been asked.
+Future<void> _settle() async {
+  for (var i = 0; i < 400 && fluidBackground!.outstanding > 0; i++) {
+    await Future<void>.delayed(const Duration(milliseconds: 5));
+  }
+}
+
+void main() {
+  test(
+    'modes worked out on the other isolate are the same, to the bit',
+    () async {
+      // A 9 × 9 square of cells, each with its neighbours inside.
+      const side = 9;
+      final neighbours = [
+        for (var r = 0; r < side; r++)
+          for (var c = 0; c < side; c++)
+            [
+              if (c + 1 < side) r * side + c + 1,
+              if (c > 0) r * side + c - 1,
+              if (r + 1 < side) (r + 1) * side + c,
+              if (r > 0) (r - 1) * side + c,
+            ],
+      ];
+      final here = FreeSurface.solveModes(side * side, neighbours, 1e-6, 4);
+      (List<Float64List>, Float64List)? there;
+      fluidBackground!.solve(
+        side * side,
+        neighbours,
+        1e-6,
+        4,
+        (modes) => there = modes,
+      );
+      await _settle();
+      expect(there, isNotNull);
+      expect(there!.$2, here.$2);
+      for (var m = 0; m < here.$1.length; m++) {
+        expect(there!.$1[m], here.$1[m]);
+      }
+    },
+  );
+
+  test('a meniscus worked out on the other isolate is the same', () async {
+    final here = TubeMeniscus(
+      medium: FluidMedium.water,
+      radius: 0.0075,
+      g: 9.81,
+    );
+    TubeMeniscus? there;
+    fluidBackground!.meniscus(
+      FluidMedium.water,
+      0.0075,
+      9.81,
+      (m) => there = m,
+    );
+    await _settle();
+    expect(there!.apexCurvature, here.apexCurvature);
+    expect(there!.meanHeight, here.meanHeight);
+    expect(there!.wallRise, here.wallRise);
+  });
+
+  test(
+    'a tube tipped to a new angle carries on, then takes its modes',
+    () async {
+      final world = FluidWorld(gravity: Vector3(0, -9.81, 0), background: true);
+      final tube = LiquidBody(
+        shape: RevolvedVessel([
+          for (var i = 0; i <= 8; i++)
+            Vector2(
+              0.0075 * math.sin(i * math.pi / 16),
+              0.0075 - 0.0075 * math.cos(i * math.pi / 16),
+            ),
+          Vector2(0.0075, 0.1),
+        ]),
+        medium: FluidMedium.water,
+        volume: 3e-6,
+        modes: 4,
+      );
+      world.bodies.add(tube);
+      void at(double tilt) {
+        tube.place(
+          Matrix3.rotationX(tilt),
+          Vector3.zero(),
+          time: world.time + world.step,
+        );
+        world.advance(world.step);
+      }
+
+      for (var i = 0; i < 10; i++) {
+        at(0.0);
+      }
+      // An angle no tube has been at here: its cross-section is new.
+      at(0.6123);
+      expect(tube.surface.waitingForModes, isTrue);
+      await _settle();
+      at(0.6123);
+      expect(tube.surface.waitingForModes, isFalse);
+      // And the liquid is all there throughout.
+      expect(tube.volume, closeTo(3e-6, 1e-18));
+    },
+  );
+}
diff --git a/packages/flutter3d_physics/test/fluid/buoyancy_test.dart b/packages/flutter3d_physics/test/fluid/buoyancy_test.dart
index a9f046e0c..470eb2c09 100644
--- a/packages/flutter3d_physics/test/fluid/buoyancy_test.dart
+++ b/packages/flutter3d_physics/test/fluid/buoyancy_test.dart
@@ -113,6 +113,45 @@ void main() {
     expect(-ball.velocity.y, closeTo(stokes, stokes * 0.03));
   });
 
+  test('a ball spun in glycerol slows as Stokes\'s torque says', () {
+    // 8πμR³ω against a ball's 2/5·mR²: its spin falls by e in ρR²/15μ, six
+    // milliseconds for a centimetre ball as heavy as the glycerol. Slow
+    // enough, a tenth of a Reynolds number, for Stokes to hold. Mutation:
+    // leave the torque out, and it spins on as it was.
+    final gravity = Vector3(0, -9.81, 0);
+    final collisions = CollisionWorld();
+    final dynamics = Dynamics(world: collisions, gravity: gravity);
+    const r = 0.01;
+    final rho = FluidMedium.glycerol.density;
+    final ball = RigidBody(
+      world: collisions,
+      shape: CollisionSphere(r),
+      position: Vector3(0, 0.1, 0),
+      mass: rho * 4 / 3 * math.pi * r * r * r,
+      canRotate: true,
+    );
+    ball.angularVelocity.setValues(0, 1, 0);
+    dynamics.add(ball);
+    const dt = 1 / 20000;
+    final world = FluidWorld(gravity: gravity, step: dt);
+    final vat = LiquidBody(
+      shape: _vat(0.05, 0.4),
+      medium: FluidMedium.glycerol,
+      volume: math.pi * 0.0025 * 0.3,
+      modes: 2,
+    );
+    world.bodies.add(vat);
+    world.float(ball);
+    final tau = rho * r * r / (15 * FluidMedium.glycerol.viscosity);
+    final steps = (tau / dt).round();
+    for (var i = 0; i < steps; i++) {
+      vat.place(Matrix3.identity(), Vector3.zero());
+      world.advance(dt);
+      dynamics.step(dt);
+    }
+    expect(ball.angularVelocity.y, closeTo(math.exp(-1), math.exp(-1) * 0.02));
+  });
+
   test('a body under the surface raises the level by its volume', () {
     final collisions = CollisionWorld();
     final world = FluidWorld(gravity: Vector3(0, -9.81, 0));
diff --git a/packages/flutter3d_physics/test/fluid/drop_test.dart b/packages/flutter3d_physics/test/fluid/drop_test.dart
new file mode 100644
index 000000000..4c4e2edd7
--- /dev/null
+++ b/packages/flutter3d_physics/test/fluid/drop_test.dart
@@ -0,0 +1,66 @@
+import 'package:flutter3d_physics/flutter3d_physics.dart';
+import 'package:test/test.dart';
+import 'package:vector_math/vector_math.dart';
+
+void main() {
+  final g = Vector3(0, -9.81, 0);
+
+  test('a drop under the capillary length is one body, falling as one', () {
+    final fluid = ParticleFluid(medium: FluidMedium.water, spacing: 0.001)
+      ..inject(4e-9, Vector3(0, 1, 0), Vector3.zero());
+    expect(fluid.count, 1);
+    expect(fluid.dropCount, 1);
+    for (var i = 0; i < 240; i++) {
+      fluid.step(1 / 240, gravity: g);
+    }
+    // A second's fall, as a body falls: ½gt², to the step's first order.
+    expect(1 - fluid.positions.single.y, closeTo(4.905, 0.03));
+    expect(fluid.volume, 4e-9);
+  });
+
+  test('two drops that meet run together, liquid and momentum and all', () {
+    final fluid = ParticleFluid(medium: FluidMedium.water, spacing: 0.001)
+      ..inject(
+        1e-9,
+        Vector3(0, 0, 0),
+        Vector3(0.1, 0, 0),
+        concentrations: const {'dye': 1.0},
+      )
+      ..inject(2e-9, Vector3(0.002, 0, 0), Vector3(-0.1, 0, 0));
+    // Apart at first; they meet within the second step.
+    fluid
+      ..step(1 / 240, gravity: Vector3.zero())
+      ..step(1 / 240, gravity: Vector3.zero());
+    expect(fluid.dropCount, 1);
+    expect(fluid.volume, closeTo(3e-9, 1e-21));
+    // A third of it was dye at one.
+    expect(fluid.concentrations['dye'], closeTo(1 / 3, 1e-12));
+  });
+
+  test('a block of liquid in the air is one drop, and holds together', () {
+    // Twenty-seven particles laid out as a block, free in the air, rang
+    // until they flew apart, ten centimetres in a tenth of a second. A
+    // drop in flight is held whole by surface tension against the air
+    // (its Weber number far under twelve): one body. Mutation: leave free
+    // blocks as particles, and they fly apart.
+    final fluid = ParticleFluid(medium: FluidMedium.water, spacing: 0.001)
+      ..inject(27e-9, Vector3(0, 1, 0), Vector3.zero());
+    for (var i = 0; i < 24; i++) {
+      fluid.step(1 / 240, gravity: Vector3.zero());
+    }
+    expect(fluid.dropCount, 1);
+    expect(fluid.count, 1);
+    expect(fluid.positions.single.y, closeTo(1.0, 1e-6));
+    expect(fluid.volume, closeTo(27e-9, 1e-21));
+  });
+
+  test('a drop that lands on glass is particles there', () {
+    final fluid = ParticleFluid(medium: FluidMedium.water, spacing: 0.001);
+    final pane = [PlaneObstacle(normal: Vector3(0, 1, 0), offset: 0)];
+    // A block resting on the glass from the start: particles, held there.
+    fluid.inject(27e-9, Vector3(0, 0.0015, 0), Vector3.zero());
+    fluid.step(1 / 240, gravity: Vector3(0, -9.81, 0), obstacles: pane);
+    expect(fluid.dropCount, 0);
+    expect(fluid.count, 27);
+  });
+}
diff --git a/packages/flutter3d_physics/test/fluid/gravity_field_test.dart b/packages/flutter3d_physics/test/fluid/gravity_field_test.dart
new file mode 100644
index 000000000..477c7fc07
--- /dev/null
+++ b/packages/flutter3d_physics/test/fluid/gravity_field_test.dart
@@ -0,0 +1,74 @@
+import 'package:flutter3d_physics/flutter3d_physics.dart';
+import 'package:test/test.dart';
+import 'package:vector_math/vector_math.dart';
+
+void main() {
+  test('the Earth pulls 9.82 at its surface and half that halfway down', () {
+    // μ = 3.986×10¹⁴ m³/s², R = 6371 km.
+    const r = 6.371e6;
+    final earth = GravityField(
+      attractors: [
+        Attractor(position: Vector3.zero(), mu: 3.986e14, radius: r),
+      ],
+    );
+    final surface = earth.at(Vector3(0, r, 0));
+    expect(surface.length, closeTo(9.82, 0.01));
+    expect(surface.y, lessThan(0.0));
+    // Inside a uniform ball the pull falls straight to nought at the middle.
+    expect(earth.at(Vector3(0, r / 2, 0)).length, closeTo(9.82 / 2, 0.01));
+    // Between two equal masses, none at all.
+    final pair = GravityField(
+      attractors: [
+        Attractor(position: Vector3(-1, 0, 0), mu: 10),
+        Attractor(position: Vector3(1, 0, 0), mu: 10),
+      ],
+    );
+    expect(pair.at(Vector3.zero()).length, closeTo(0.0, 1e-12));
+  });
+
+  test('a glass beside an attractor levels across its own gravity', () {
+    // A pull of 9.81 at a metre, sideways to the glass, and no other:
+    // the liquid lies along the glass's side, its surface facing the
+    // attractor's way out. Mutation: hand every vessel the world's one
+    // gravity, which here is nought, and the surface never turns.
+    final field = GravityField(
+      attractors: [Attractor(position: Vector3.zero(), mu: 9.81)],
+    );
+    final world = FluidWorld(gravity: Vector3.zero(), field: field);
+    final glass = LiquidBody(
+      shape: RevolvedVessel([
+        Vector2(0, 0),
+        Vector2(0.02, 0),
+        Vector2(0.02, 0.1),
+      ]),
+      medium: FluidMedium.water,
+      volume: 2e-5,
+      modes: 2,
+    );
+    world.bodies.add(glass);
+    for (var i = 0; i < 240; i++) {
+      glass.place(
+        Matrix3.identity(),
+        Vector3(1, 0, 0),
+        time: world.time + world.step,
+      );
+      world.advance(world.step);
+    }
+    expect(glass.up.x, closeTo(1.0, 1e-6));
+  });
+
+  test('a drop between two attractors falls to the nearer', () {
+    final field = GravityField(
+      attractors: [
+        Attractor(position: Vector3(-0.1, 0, 0), mu: 1e-3),
+        Attractor(position: Vector3(0.1, 0, 0), mu: 1e-3),
+      ],
+    );
+    final fluid = ParticleFluid(medium: FluidMedium.water, spacing: 0.001)
+      ..inject(1e-9, Vector3(0.01, 0, 0), Vector3.zero());
+    for (var i = 0; i < 24; i++) {
+      fluid.step(1 / 240, gravity: Vector3.zero(), gravityAt: field.at);
+    }
+    expect(fluid.positions.single.x, greaterThan(0.01));
+  });
+}
diff --git a/packages/flutter3d_physics/test/fluid/jet_test.dart b/packages/flutter3d_physics/test/fluid/jet_test.dart
index 54f676083..a698ad72f 100644
--- a/packages/flutter3d_physics/test/fluid/jet_test.dart
+++ b/packages/flutter3d_physics/test/fluid/jet_test.dart
@@ -84,6 +84,36 @@ void main() {
     expect((oldest - expected).length, lessThan(1e-3));
   });
 
+  test('the tail of a stream cut off draws back into a bulb', () {
+    // Mutation: leave its end where it was, and the tail falls as wide at
+    // its end as along it, like a rod, for as long as it falls.
+    final jet = Jet(medium: FluidMedium.water, breakupGrowth: 1e9);
+    const dt = 1 / 1000;
+    final g = Vector3(0, -9.81, 0);
+    for (var k = 0; k < 100; k++) {
+      jet.emit(
+        flow: 4e-6,
+        dt: dt,
+        point: Vector3(0, 1, 0),
+        velocity: Vector3(0.3, 0, 0),
+        width: 0.004,
+        across: Vector3(0, 0, 1),
+      );
+      jet.step(dt, gravity: g);
+    }
+    final before = jet.runs.single.length;
+    for (var k = 0; k < 30; k++) {
+      jet.step(dt, gravity: g);
+    }
+    final run = jet.runs.single;
+    // Its end, the lip's side, has gathered what it drew back past.
+    double section(JetSample s) => math.pi * s.wide * s.thick;
+    final middle = run[run.length ~/ 2];
+    expect(section(run.first), greaterThan(1.5 * section(middle)));
+    expect(run.length, lessThan(before));
+    expect(jet.inFlight, closeTo(jet.emitted, jet.emitted * 1e-12));
+  });
+
   test('every drop of it is somewhere', () {
     final body = LiquidBody(
       shape: RevolvedVessel([
diff --git a/packages/flutter3d_physics/test/fluid/mixture_test.dart b/packages/flutter3d_physics/test/fluid/mixture_test.dart
index e4dc01c2c..0fd97c3d1 100644
--- a/packages/flutter3d_physics/test/fluid/mixture_test.dart
+++ b/packages/flutter3d_physics/test/fluid/mixture_test.dart
@@ -48,8 +48,12 @@ void main() {
     final body = _tube(FluidMedium.water, 5e-5);
     body.pour(2e-6, medium: FluidMedium.oil);
     var oil = 0.0, water = 0.0;
+    // Tipped well past where it starts to run: at 1.2 rad the glass came to
+    // rest at its lip with a film of oil still in it once the meniscus of a
+    // tipped surface was the wall's, so neither the order nor the amounts
+    // were what was being tested.
     for (var i = 0; i < 3000; i++) {
-      body.place(Matrix3.rotationX(1.2), Vector3.zero());
+      body.place(Matrix3.rotationX(1.3), Vector3.zero());
       final spill = body.step(1e-3, gravity: Vector3(0, -9.81, 0));
       if (spill.medium.name == 'oil') oil += spill.flow * 1e-3;
       if (spill.medium.name == 'water') water += spill.flow * 1e-3;
diff --git a/packages/flutter3d_physics/test/fluid/native_kernels_test.dart b/packages/flutter3d_physics/test/fluid/native_kernels_test.dart
new file mode 100644
index 000000000..2ce3bbde9
--- /dev/null
+++ b/packages/flutter3d_physics/test/fluid/native_kernels_test.dart
@@ -0,0 +1,279 @@
+// The native kernels are reached through dart:ffi, which the web has not:
+// there the Dart kernels run, and nothing here applies.
+@TestOn('vm')
+library;
+
+import 'dart:math' as math;
+import 'dart:typed_data';
+
+import 'package:flutter3d_physics/flutter3d_physics.dart';
+import 'package:flutter3d_physics/src/fluid/native/pbf_backend.dart'
+    show nativePbfLanes, setNativePbfLanes;
+import 'package:test/test.dart';
+import 'package:vector_math/vector_math.dart';
+
+/// A loose cloud of [n] particles about a millimetre apart, the same every
+/// run, and its neighbours within [h] as compressed rows.
+(Float64List, Int32List, Int32List) _cloud(int n, double h) {
+  final random = math.Random(7);
+  final x = Float64List(3 * n);
+  for (var i = 0; i < 3 * n; i++) {
+    x[i] = random.nextDouble() * 0.006;
+  }
+  final rows = <List<int>>[
+    for (var i = 0; i < n; i++)
+      [
+        for (var j = 0; j < n; j++)
+          if (j != i &&
+              math.pow(x[3 * i] - x[3 * j], 2) +
+                      math.pow(x[3 * i + 1] - x[3 * j + 1], 2) +
+                      math.pow(x[3 * i + 2] - x[3 * j + 2], 2) <
+                  h * h)
+            j,
+      ],
+  ];
+  final start = Int32List(n + 1);
+  for (var i = 0; i < n; i++) {
+    start[i + 1] = start[i] + rows[i].length;
+  }
+  final list = Int32List(start[n]);
+  for (var i = 0; i < n; i++) {
+    list.setAll(start[i], rows[i]);
+  }
+  return (x, start, list);
+}
+
+void _close(Float64List a, Float64List b) {
+  var scale = 0.0;
+  for (final v in a) {
+    scale = math.max(scale, v.abs());
+  }
+  for (var i = 0; i < a.length; i++) {
+    expect(b[i], closeTo(a[i], 1e-12 * scale + 1e-300), reason: 'entry $i');
+  }
+}
+
+void main() {
+  test('the native kernels are built here', () {
+    // On a machine with a C compiler the hook builds them; this one has.
+    expect(nativePbfAvailable, isTrue);
+  });
+
+  for (final lanes in const [1, 2, 4, 8]) {
+    test('each native kernel matches the Dart one to a part in 10¹², '
+        '$lanes at a time', () {
+      // Each width this processor has: the wider are only the running
+      // processor's (AVX2, AVX-512F) on x86-64, and all of them on arm64.
+      if (setNativePbfLanes(lanes) != lanes) {
+        markTestSkipped('not on this processor');
+        return;
+      }
+      addTearDown(() => setNativePbfLanes(0));
+      _matches();
+    });
+  }
+
+  test('the processor chooses how many at a time', () {
+    expect(const [2, 4], contains(nativePbfLanes));
+  });
+
+  test('both find the same neighbours, in the same order', () {
+    final fluid = ParticleFluid(medium: FluidMedium.water, spacing: 0.001);
+    final native = ParticleFluid(
+      medium: FluidMedium.water,
+      spacing: 0.001,
+      native: true,
+    );
+    const n = 300;
+    final (x, start, list) = _cloud(n, fluid.h);
+    final (s1, l1) = fluid.kernels.neighbours(x, n, fluid.h);
+    final (s2, l2) = native.kernels.neighbours(x, n, fluid.h);
+    expect(s2, s1);
+    expect(l2, l1);
+    // And the same as every pair within reach, counted the slow way.
+    expect(l1.length, list.length);
+    expect(s1, start);
+    // Candidates half as far again, cut back to the reach, are the same
+    // pairs: each row the same set, in the candidates' own order.
+    for (final kernels in [fluid.kernels, native.kernels]) {
+      final (cs, cl) = kernels.neighbours(x, n, 1.5 * fluid.h);
+      expect(cl.length, greaterThan(list.length));
+      final (ws, wl) = kernels.within(x, n, cs, cl, fluid.h);
+      expect(ws, start);
+      for (var i = 0; i < n; i++) {
+        expect(
+          wl.sublist(ws[i], ws[i + 1]).toSet(),
+          list.sublist(start[i], start[i + 1]).toSet(),
+        );
+      }
+    }
+  });
+
+  test(
+    'a drop run natively lands where the Dart one does, every drop of it',
+    () {
+      Vector3 run({required bool native}) {
+        final fluid = ParticleFluid(
+          medium: FluidMedium.water,
+          spacing: 0.001,
+          native: native,
+        )..inject(27e-9, Vector3(0, 0.01, 0), Vector3(0.05, 0, 0));
+        final bench = [PlaneObstacle(normal: Vector3(0, 1, 0), offset: 0)];
+        for (var i = 0; i < 120; i++) {
+          fluid.step(1 / 240, gravity: Vector3(0, -9.81, 0), obstacles: bench);
+        }
+        expect(fluid.volume, closeTo(27e-9, 1e-21));
+        final centre = Vector3.zero();
+        for (final p in fluid.positions) {
+          centre.add(p);
+        }
+        return centre..scale(1.0 / fluid.count);
+      }
+
+      final reference = run(native: false);
+      final fast = run(native: true);
+      // **Not the same path: the same drop.** A step decides things — whether
+      // a particle touches the bench, whether its edge holds the drop — and a
+      // part in 10¹² either side of a threshold decides differently: the Dart
+      // run started a millionth of a micrometre over lands seventy-five
+      // micrometres off its own. So the two land as the same drop, on the
+      // bench, within a particle's spacing of each other, every drop of it
+      // there; to the bit is the Dart kernels' promise, not this.
+      expect(fast.y, lessThan(0.003));
+      expect((fast - reference).length, lessThan(0.001));
+    },
+  );
+
+  test('the native modes of a round cross-section are the Dart ones', () {
+    // A disc of cells twelve across its radius, as a test tube's surface.
+    const r = 12;
+    final index = <int, int>{};
+    for (var y = -r; y <= r; y++) {
+      for (var x = -r; x <= r; x++) {
+        if (x * x + y * y <= r * r) {
+          index[(y + r) * 100 + (x + r)] = index.length;
+        }
+      }
+    }
+    final neighbours = List<List<int>>.generate(index.length, (_) => []);
+    index.forEach((key, i) {
+      for (final d in const [1, -1, 100, -100]) {
+        final j = index[key + d];
+        if (j != null) neighbours[i].add(j);
+      }
+    });
+    final n = index.length;
+    const cell2 = 0.0006 * 0.0006;
+    final dart = FreeSurface.solveModes(n, neighbours, cell2, 4);
+    final native = FreeSurface.solveModes(
+      n,
+      neighbours,
+      cell2,
+      4,
+      native: true,
+    );
+    for (var m = 0; m < 4; m++) {
+      expect(native.$2[m], closeTo(dart.$2[m], dart.$2[m] * 1e-9));
+    }
+    // Each native mode lies in the span of the Dart modes of its own k²:
+    // a round section's come in pairs, and either turn of a pair is right.
+    double dot(Float64List a, Float64List b) {
+      var s = 0.0;
+      for (var i = 0; i < n; i++) {
+        s += a[i] * b[i];
+      }
+      return s;
+    }
+
+    for (var m = 0; m < 4; m++) {
+      final mode = native.$1[m];
+      var projected = 0.0;
+      for (var d = 0; d < 4; d++) {
+        if ((dart.$2[d] - native.$2[m]).abs() > dart.$2[d] * 1e-6) continue;
+        final c = dot(mode, dart.$1[d]) / dot(dart.$1[d], dart.$1[d]);
+        projected += c * c * dot(dart.$1[d], dart.$1[d]);
+      }
+      expect(projected / dot(mode, mode), closeTo(1.0, 1e-9));
+    }
+  });
+
+  test('the native meniscus is the Dart one, to within a tolerance', () {
+    for (final medium in [
+      FluidMedium.water,
+      FluidMedium.ethanol,
+      FluidMedium.mercury,
+    ]) {
+      for (final radius in [0.0005, 0.0075, 0.02]) {
+        final dart = TubeMeniscus(medium: medium, radius: radius, g: 9.81);
+        final native = TubeMeniscus(
+          medium: medium,
+          radius: radius,
+          g: 9.81,
+          native: true,
+        );
+        final scale = dart.apexCurvature.abs() + 1.0 / radius * 1e-6;
+        expect(
+          native.apexCurvature,
+          closeTo(dart.apexCurvature, scale * 1e-9),
+          reason: '\${medium.name} in \$radius m',
+        );
+        expect(native.wallRise, closeTo(dart.wallRise, radius * 1e-9));
+        expect(native.meanHeight, closeTo(dart.meanHeight, radius * 1e-9));
+      }
+    }
+  });
+}
+
+/// Each native kernel against the Dart one, at the width set.
+void _matches() {
+  final fluid = ParticleFluid(medium: FluidMedium.water, spacing: 0.001);
+  final native = ParticleFluid(
+    medium: FluidMedium.water,
+    spacing: 0.001,
+    native: true,
+  );
+  final dart = fluid.kernels;
+  final c = native.kernels;
+  expect(c, isNot(isA<DartPbfKernels>()));
+  const n = 200;
+  final (x, start, list) = _cloud(n, fluid.h);
+  expect(list.length, greaterThan(n));
+
+  final d1 = Float64List(n);
+  final d2 = Float64List(n);
+  dart.densities(x, start, list, n, d1);
+  c.densities(x, start, list, n, d2);
+  _close(d1, d2);
+
+  final n1 = Float64List(3 * n);
+  final n2 = Float64List(3 * n);
+  dart.normals(x, start, list, n, d1, n1);
+  c.normals(x, start, list, n, d1, n2);
+  _close(n1, n2);
+
+  final before = Float64List(3 * n)..fillRange(0, 3 * n, -9.81);
+  final after = Float64List(3 * n)..fillRange(0, 3 * n, 0.1);
+  final v1 = Float64List(3 * n);
+  final v2 = Float64List(3 * n);
+  dart.forces(x, start, list, n, d1, n1, before, after, v1, 1e-4);
+  c.forces(x, start, list, n, d1, n1, before, after, v2, 1e-4);
+  _close(v1, v2);
+
+  final l1 = Float64List(n);
+  final l2 = Float64List(n);
+  dart.lambdas(x, start, list, n, l1);
+  c.lambdas(x, start, list, n, l2);
+  _close(l1, l2);
+
+  final p1 = Float64List(3 * n);
+  final p2 = Float64List(3 * n);
+  dart.deltas(x, start, list, n, l1, p1);
+  c.deltas(x, start, list, n, l1, p2);
+  _close(p1, p2);
+
+  final s1 = Float64List(3 * n);
+  final s2 = Float64List(3 * n);
+  dart.viscosity(x, v1, start, list, n, 0.05, s1);
+  c.viscosity(x, v1, start, list, n, 0.05, s2);
+  _close(s1, s2);
+}
diff --git a/packages/flutter3d_physics/test/fluid/particle_fluid_test.dart b/packages/flutter3d_physics/test/fluid/particle_fluid_test.dart
index 36354817b..6e38454c2 100644
--- a/packages/flutter3d_physics/test/fluid/particle_fluid_test.dart
+++ b/packages/flutter3d_physics/test/fluid/particle_fluid_test.dart
@@ -24,15 +24,92 @@ void main() {
     expect(1 - y, closeTo(0.5 * 1.62 * 0.25, 0.5 * 1.62 * 0.25 * 0.01));
   });
 
+  test('a drop thrown along the bench stops where it lands', () {
+    // Mutation: drop the no-slip at walls, and a drop that came down
+    // moving five centimetres a second sideways is half a metre off after
+    // ten seconds, sliding still.
+    final fluid = ParticleFluid(medium: FluidMedium.water, spacing: 0.001);
+    final bench = [PlaneObstacle(normal: Vector3(0, 1, 0), offset: 0)];
+    fluid.inject(
+      3 * fluid.particleVolume,
+      Vector3(0, 0.01, 0),
+      Vector3(0.05, 0, 0),
+    );
+    for (var i = 0; i < 2400; i++) {
+      fluid.step(1 / 240, gravity: Vector3(0, -9.81, 0), obstacles: bench);
+    }
+    for (final p in fluid.positions) {
+      // A fall of a centimetre takes 45 ms, and five centimetres a second
+      // carries it two and a quarter millimetres in that.
+      expect(p.x, lessThan(0.005));
+      expect(p.y, lessThan(0.002));
+    }
+  });
+
   test('what is less than a particle waits in the bank, and is counted', () {
     final fluid = ParticleFluid(medium: FluidMedium.water, spacing: 0.002);
-    fluid.inject(2.5 * fluid.particleVolume, Vector3.zero(), Vector3.zero());
+    fluid.inject(
+      2.5 * fluid.particleVolume,
+      Vector3.zero(),
+      Vector3.zero(),
+      asParticles: true,
+    );
     expect(fluid.count, 2);
     expect(fluid.volume, closeTo(2.5 * fluid.particleVolume, 1e-18));
-    fluid.inject(0.5 * fluid.particleVolume, Vector3.zero(), Vector3.zero());
+    fluid.inject(
+      0.5 * fluid.particleVolume,
+      Vector3.zero(),
+      Vector3.zero(),
+      asParticles: true,
+    );
     expect(fluid.count, 3);
   });
 
+  test('what is left in the bank is let go once no more comes', () {
+    // Mutation: keep it banked, and a third of a particle stays counted
+    // and nowhere, however long the world runs.
+    // Particles on a pane of glass, which keeps them particles.
+    final fluid = ParticleFluid(medium: FluidMedium.water, spacing: 0.002);
+    final pane = [PlaneObstacle(normal: Vector3(0, 1, 0), offset: 0.098)];
+    final at = Vector3(0, 0.1, 0);
+    fluid
+      ..inject(
+        3.3 * fluid.particleVolume,
+        at,
+        Vector3.zero(),
+        asParticles: true,
+      )
+      // The step it came in on, more may still come.
+      ..step(1 / 240, gravity: Vector3(0, -9.81, 0), obstacles: pane);
+    expect(fluid.count, 3);
+    fluid.step(1 / 240, gravity: Vector3(0, -9.81, 0), obstacles: pane);
+    expect(fluid.count, 4);
+    expect(fluid.dropCount, 0);
+    expect(fluid.volumes.last, closeTo(0.3 * fluid.particleVolume, 1e-18));
+    expect(fluid.volume, closeTo(3.3 * fluid.particleVolume, 1e-18));
+    // And off the pane, it falls and lands as what it is.
+    final glass = LiquidBody(
+      shape: RevolvedVessel([
+        Vector2(0, 0),
+        Vector2(0.02, 0),
+        Vector2(0.02, 0.2),
+      ]),
+      medium: FluidMedium.water,
+      volume: 1e-6,
+      modes: 2,
+    )..place(Matrix3.identity(), Vector3(0, -0.15, 0));
+    for (var i = 0; i < 240; i++) {
+      fluid.step(
+        1 / 240,
+        gravity: Vector3(0, -9.81, 0),
+        obstacles: [InsideWalls(glass)],
+        receivers: [glass],
+      );
+    }
+    expect(fluid.count, 0);
+    expect(glass.volume, closeTo(1e-6 + 3.3 * fluid.particleVolume, 1e-18));
+  });
+
   test(
     'a block of liquid settles at its rest density and stays in its box',
     () {
diff --git a/packages/flutter3d_physics/test/fluid/puddle_test.dart b/packages/flutter3d_physics/test/fluid/puddle_test.dart
new file mode 100644
index 000000000..d08fa4f8b
--- /dev/null
+++ b/packages/flutter3d_physics/test/fluid/puddle_test.dart
@@ -0,0 +1,89 @@
+import 'dart:math' as math;
+
+import 'package:flutter3d_physics/flutter3d_physics.dart';
+import 'package:test/test.dart';
+import 'package:vector_math/vector_math.dart';
+
+PuddleSurface _bench() =>
+    PuddleSurface(PlaneObstacle(normal: Vector3(0, 1, 0), offset: 0));
+
+void main() {
+  const g = 9.81;
+  const water = FluidMedium.water;
+
+  test('a spread puddle is as deep as the capillary length and θ make it', () {
+    // 2ℓc·sin(θ/2): a little under a millimetre for water on glass at 20°.
+    // Mutation: leave out the sine, and ten millilitres lie as a disc
+    // five centimetres across, five millimetres deep.
+    final bench = _bench()
+      ..receive(1e-5, Vector3(0, 0.001, 0), Vector3.zero(), water, const {});
+    final puddle = bench.puddles.single;
+    final r = puddle.restRadius(g);
+    final deep = puddle.volume / (math.pi * r * r);
+    final capillary = math.sqrt(water.surfaceTension / (water.density * g));
+    expect(
+      deep,
+      closeTo(2 * capillary * math.sin(water.contactAngle / 2), 1e-9),
+    );
+  });
+
+  test('a small drop is a cap meeting the bench at its contact angle', () {
+    final bench = _bench()
+      ..receive(1e-9, Vector3(0, 0.0005, 0), Vector3.zero(), water, const {});
+    final drop = bench.puddles.single;
+    final r = drop.restRadius(g);
+    final h = drop.capHeight(r);
+    // The cap's angle at its edge, from its base and height.
+    expect(2 * math.atan(h / r), closeTo(water.contactAngle, 1e-6));
+    expect(math.pi * h * (3 * r * r + h * h) / 6, closeTo(drop.volume, 1e-18));
+  });
+
+  test('drops landing apart stay apart, and run together when they meet', () {
+    final bench = _bench()
+      ..receive(1e-8, Vector3(0, 0, 0), Vector3.zero(), water, const {'a': 1})
+      ..receive(1e-8, Vector3(0.1, 0, 0), Vector3.zero(), water, const {});
+    expect(bench.puddles, hasLength(2));
+    // Poured between them until they reach each other.
+    for (var i = 0; i < 40; i++) {
+      bench.receive(5e-7, Vector3(0.05, 0, 0), Vector3.zero(), water, const {});
+    }
+    expect(bench.puddles, hasLength(1));
+    expect(bench.volume, closeTo(2e-8 + 40 * 5e-7, 1e-15));
+    // What was dissolved in one is in the whole, by its share.
+    expect(
+      bench.puddles.single.concentrations['a'],
+      closeTo(1e-8 / bench.volume, 1e-12),
+    );
+  });
+
+  test('a glass emptied on the bench lies there, every drop of it', () {
+    // Mutation: leave the bench out of the receivers, and what ran out is
+    // thousands of particles, which took a quarter of an hour to step.
+    final world = FluidWorld(
+      gravity: Vector3(0, -g, 0),
+      floor: [PlaneObstacle(normal: Vector3(0, 1, 0), offset: 0)],
+    );
+    final glass = LiquidBody(
+      shape: RevolvedVessel([
+        Vector2(0, 0.0005),
+        Vector2(0.008, 0.0005),
+        Vector2(0.008, 0.1),
+      ]),
+      medium: water,
+      volume: math.pi * 0.008 * 0.008 * 0.05,
+      modes: 4,
+    );
+    world.bodies.add(glass);
+    final total = world.volume;
+    final turn = Matrix3.rotationZ(2.5);
+    for (var i = 0; i < 240 * 4; i++) {
+      glass.place(turn, Vector3(0, 0.12, 0));
+      world.advance(world.step);
+    }
+    expect(glass.volume, lessThan(total * 0.02));
+    expect(world.volume, closeTo(total, total * 1e-9));
+    final lying = world.spills.single.volume;
+    expect(lying, greaterThan(total * 0.9));
+    expect(world.particles.values.fold(0, (s, p) => s + p.count), lessThan(50));
+  });
+}
diff --git a/packages/flutter3d_physics/test/fluid/regime_test.dart b/packages/flutter3d_physics/test/fluid/regime_test.dart
new file mode 100644
index 000000000..42a1629a0
--- /dev/null
+++ b/packages/flutter3d_physics/test/fluid/regime_test.dart
@@ -0,0 +1,59 @@
+import 'dart:math' as math;
+
+import 'package:flutter3d_physics/flutter3d_physics.dart';
+import 'package:test/test.dart';
+import 'package:vector_math/vector_math.dart';
+
+void main() {
+  test('a pipe rubs as Poiseuille laminar and as Blasius turbulent', () {
+    // Laminar, exactly 64/Re.
+    expect(Pipe.frictionFactor(1000.0), closeTo(0.064, 1e-12));
+    // Smooth and turbulent, Blasius's 0.316·Re^−¼ to a few percent at a
+    // hundred thousand, where it holds.
+    final blasius = 0.316 * math.pow(1e5, -0.25);
+    expect(Pipe.frictionFactor(1e5), closeTo(blasius, blasius * 0.03));
+    // A rough bore rubs harder, once the flow is turbulent; laminar, it
+    // does not care.
+    expect(
+      Pipe.frictionFactor(1e5, relativeRoughness: 0.01),
+      greaterThan(1.5 * Pipe.frictionFactor(1e5)),
+    );
+    expect(
+      Pipe.frictionFactor(1000.0, relativeRoughness: 0.01),
+      Pipe.frictionFactor(1000.0),
+    );
+    // Through the transition it climbs from one to the other, without a
+    // jump at either end.
+    expect(Pipe.frictionFactor(2300.0), closeTo(64.0 / 2300.0, 1e-12));
+    expect(Pipe.frictionFactor(2300.0 + 1e-6), closeTo(64.0 / 2300.0, 1e-6));
+  });
+
+  test('a turbulent stream parts at L/D = 8.51·We^0.32', () {
+    // Five millimetres at two metres a second: Re 10 000, We 275. Laminar
+    // it would hold for a metre; turbulent, for a quarter of one (Grant
+    // and Middleman). Mutation: let it part only by its ripples, and it
+    // flies a metre whole.
+    const d = 0.005;
+    const v = 2.0;
+    final q = v * math.pi * d * d / 4.0;
+    final jet = Jet(medium: FluidMedium.water);
+    final water = FluidMedium.water;
+    final we = water.density * v * v * d / water.surfaceTension;
+    final expected = 8.51 * d * math.pow(we, 0.32);
+    double? first;
+    for (var k = 0; k < 400 && first == null; k++) {
+      jet.emit(
+        flow: q,
+        dt: 1 / 1000,
+        point: Vector3.zero(),
+        velocity: Vector3(v, 0, 0),
+        width: d,
+        across: Vector3(0, 0, 1),
+      );
+      final drops = jet.step(1 / 1000, gravity: Vector3.zero());
+      if (drops.isNotEmpty) first = drops.first.position.x;
+    }
+    expect(first, isNotNull);
+    expect(first, closeTo(expected, expected * 0.05));
+  });
+}
diff --git a/packages/flutter3d_physics/test/fluid/wetting_test.dart b/packages/flutter3d_physics/test/fluid/wetting_test.dart
new file mode 100644
index 000000000..c761f9ad1
--- /dev/null
+++ b/packages/flutter3d_physics/test/fluid/wetting_test.dart
@@ -0,0 +1,60 @@
+import 'package:flutter3d_physics/flutter3d_physics.dart';
+import 'package:test/test.dart';
+import 'package:vector_math/vector_math.dart';
+
+void main() {
+  /// Where a drop of [microlitres] left against a vertical pane of glass is
+  /// after a second, and where it started.
+  (double, double) onPane(int microlitres) {
+    final fluid = ParticleFluid(medium: FluidMedium.water, spacing: 0.001);
+    final pane = [PlaneObstacle(normal: Vector3(1, 0, 0), offset: 0.0)];
+    fluid.inject(microlitres * 1e-9, Vector3(0.002, 0.1, 0), Vector3.zero());
+    double low() =>
+        fluid.positions.map((p) => p.y).reduce((a, b) => a < b ? a : b);
+    // Let it come to the glass first.
+    for (var i = 0; i < 24; i++) {
+      fluid.step(1 / 240, gravity: Vector3(-9.81, 0, 0), obstacles: pane);
+    }
+    final start = low();
+    for (var i = 0; i < 240; i++) {
+      fluid.step(1 / 240, gravity: Vector3(0, -9.81, 0), obstacles: pane);
+    }
+    return (start, low());
+  }
+
+  test('a small drop hangs on a pane and a big one runs down it', () {
+    // Furmidge: a microlitre weighs three quarters of what clean glass's
+    // edge holds it with; twenty weigh five times what holds them.
+    // Mutation: hold every drop under the capillary length, as before,
+    // and the big one, under it at its four-millimetre base, stays.
+    final (smallStart, smallEnd) = onPane(1);
+    expect(smallEnd, closeTo(smallStart, 1e-3));
+    final (bigStart, bigEnd) = onPane(20);
+    expect(bigStart - bigEnd, greaterThan(0.01));
+  });
+
+  test('water beads on a lacquered bench and spreads on glass', () {
+    Puddle lying(SolidSurface solid) {
+      final bench =
+          PuddleSurface(
+            PlaneObstacle(normal: Vector3(0, 1, 0), offset: 0, solid: solid),
+          )..receive(
+            5e-7,
+            Vector3.zero(),
+            Vector3.zero(),
+            FluidMedium.water,
+            const {},
+          );
+      return bench.puddles.single;
+    }
+
+    final glass = lying(SolidSurface.glass);
+    final laminate = lying(SolidSurface.laminate);
+    expect(laminate.restRadius(9.81), lessThan(glass.restRadius(9.81)));
+    final r = laminate.restRadius(9.81);
+    expect(
+      laminate.capHeight(r),
+      greaterThan(glass.capHeight(glass.restRadius(9.81))),
+    );
+  });
+}
diff --git a/packages/flutter3d_physics/test/native/lanes_check.c b/packages/flutter3d_physics/test/native/lanes_check.c
new file mode 100644
index 000000000..563af039f
--- /dev/null
+++ b/packages/flutter3d_physics/test/native/lanes_check.c
@@ -0,0 +1,68 @@
+// Each width of the native pair loops (`src/pbf_lanes.h`) held to the
+// scalar loop, on whatever processor runs it, and timed: for CI's x86-64,
+// where the AVX2 and AVX-512 widths are real, which no arm64 machine can
+// say. Built and run by the `native-lanes` job:
+//
+//   cc -O3 -fno-math-errno -Isrc src/pbf_kernels.c test/native/lanes_check.c -lm
+//
+// Exits 1 when a width differs from the scalar loop by more than a part in
+// 10¹² of the largest value, which is summing in another order and nothing
+// else.
+#include <math.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+int32_t f3d_pbf_lanes(void); int32_t f3d_pbf_set_lanes(int32_t);
+int32_t f3d_pbf_neighbours(const double*, int32_t, double, int32_t*, int32_t*, int32_t, int64_t*);
+void f3d_pbf_densities(const double*, const int32_t*, const int32_t*, int32_t, const double*, double*);
+void f3d_pbf_normals(const double*, const int32_t*, const int32_t*, int32_t, const double*, const double*, double*);
+void f3d_pbf_forces(const double*, const int32_t*, const int32_t*, int32_t, const double*, const double*, const double*, const double*, const double*, double*, double);
+void f3d_pbf_lambdas(const double*, const int32_t*, const int32_t*, int32_t, const double*, double*);
+void f3d_pbf_deltas(const double*, const int32_t*, const int32_t*, int32_t, const double*, const double*, double*);
+void f3d_pbf_viscosity(const double*, const double*, const int32_t*, const int32_t*, int32_t, const double*, double, double*);
+#define N 2000
+static double x[3*N], v[3*N], k[12], bef[3*N], aft[3*N];
+static int32_t st[N+1], lst[N*200]; static int64_t scr[5*N];
+typedef struct { double d[N], n[3*N], f[3*N], l[N], dl[3*N], vs[3*N]; } out_t;
+static out_t o[9];
+static void run(out_t* r) {
+  f3d_pbf_densities(x, st, lst, N, k, r->d);
+  f3d_pbf_normals(x, st, lst, N, k, r->d, r->n);
+  for (int i=0;i<3*N;i++) r->f[i]=v[i];
+  f3d_pbf_forces(x, st, lst, N, k, r->d, r->n, bef, aft, r->f, 1e-3);
+  f3d_pbf_lambdas(x, st, lst, N, k, r->l);
+  f3d_pbf_deltas(x, st, lst, N, k, r->l, r->dl);
+  f3d_pbf_viscosity(x, v, st, lst, N, k, 0.1, r->vs);
+}
+static double rel(const double* a, const double* b, int n) {
+  double m=0, s=0; for (int i=0;i<n;i++){ double e=fabs(a[i]-b[i]); if(e>m)m=e; if(fabs(b[i])>s)s=fabs(b[i]); } return s>0? m/s : m;
+}
+int main(void) {
+  int failed = 0;
+  srand(7); const double sp=0.001, h=2*sp;
+  // A jittered block, with a few particles on top of each other.
+  for (int i=0;i<N;i++){ int a=i%13,b=(i/13)%13,c=i/169; x[3*i]=a*sp*0.9+((rand()%1000)-500)*1e-7; x[3*i+1]=b*sp*0.9+((rand()%1000)-500)*1e-7; x[3*i+2]=c*sp*0.9+((rand()%1000)-500)*1e-7; for(int d=0;d<3;d++){v[3*i+d]=((rand()%1000)-500)*1e-4; bef[3*i+d]=-9.81*(d==1); aft[3*i+d]=0;} }
+  x[3]=x[0]; x[4]=x[1]; x[5]=x[2];
+  double m=1000*sp*sp*sp, H6=pow(h,6);
+  k[0]=h;k[1]=h*h;k[2]=1000;k[3]=m;k[4]=m/1000;k[5]=0.072;k[6]=1e-4;k[7]=315/(64*M_PI*pow(h,9));k[8]=-45/(M_PI*H6);k[9]=32/(M_PI*pow(h,9));k[10]=H6;k[11]=k[7]*pow(h*h-0.09*h*h,3);
+  int32_t cnt=f3d_pbf_neighbours(x,N,h,st,lst,N*200,scr);
+  printf("default lanes %d, %d pairs (%.1f a particle)\n", f3d_pbf_lanes(), cnt, (double)cnt/N);
+  int widths[4]={1,2,4,8};
+  for (int w=0;w<4;w++){
+    int got=f3d_pbf_set_lanes(widths[w]);
+    if (got!=widths[w]) { printf("lanes %d: not on this processor\n", widths[w]); continue; }
+    run(&o[widths[w]]);
+    clock_t t=clock(); for(int r=0;r<50;r++) run(&o[widths[w]]); double ms=(double)(clock()-t)*1000/CLOCKS_PER_SEC/50;
+    if (widths[w]==1) { printf("lanes 1: %.3f ms\n", ms); continue; }
+    out_t* a=&o[widths[w]]; out_t* b=&o[1];
+    double worst = rel(a->d,b->d,N);
+    double e[5] = {rel(a->n,b->n,3*N), rel(a->f,b->f,3*N), rel(a->l,b->l,N), rel(a->dl,b->dl,3*N), rel(a->vs,b->vs,3*N)};
+    for (int q=0;q<5;q++) if (e[q]>worst) worst=e[q];
+    if (worst > 1e-12) failed = 1;
+    printf("lanes %d: %.3f ms; against scalar: density %.1e normals %.1e forces %.1e lambda %.1e delta %.1e viscosity %.1e\n", widths[w], ms,
+      rel(a->d,b->d,N), rel(a->n,b->n,3*N), rel(a->f,b->f,3*N), rel(a->l,b->l,N), rel(a->dl,b->dl,3*N), rel(a->vs,b->vs,3*N));
+  }
+  if (failed) printf("a width differs from the scalar loop\n");
+  return failed;
+}
diff --git a/packages/flutter3d_physics/tool/filter_cost.dart b/packages/flutter3d_physics/tool/filter_cost.dart
deleted file mode 100644
index a70014c6b..000000000
--- a/packages/flutter3d_physics/tool/filter_cost.dart
+++ /dev/null
@@ -1,96 +0,0 @@
-/// How much the contact filter costs in the loop it was put into.
-///
-///     dart run tool/filter_cost.dart
-///
-/// The predicate goes into `sweep`, which the character controller calls four
-/// times a step and a game steps sixty times a second. An indirect call there
-/// is the kind of thing that is cheap until it is not, and the plan that asked
-/// for it asked for this number too.
-///
-/// ## What the context object cost
-///
-/// The filter took `(Collider, Vector3)` until it was widened to one
-/// [SweptContact], so that a field could be added to it later without breaking
-/// every filter anybody had written. That is not free, and this is what it came
-/// to on one machine, three runs each, microseconds per step with a trivial
-/// filter installed:
-///
-///     two positional arguments   1.932
-///     a `late`-field context     1.997   (+3.4%)
-///     the context as it is now   1.953   (+1.1%)
-///
-/// Half the cost was `late`. A `late` field carries an is-it-initialised check
-/// on every read, and a filter reads both fields on every contact; the object
-/// now holds a nullable behind a non-null getter and a vector it copies into,
-/// and neither is checked. The remaining one percent is the object itself, and
-/// it buys the ability to tell a filter something new without a major version.
-library;
-
-import 'package:flutter3d_physics/flutter3d_physics.dart';
-import 'package:vector_math/vector_math.dart';
-
-const int _steps = 200000;
-
-CollisionWorld _level() {
-  final world = CollisionWorld()
-    ..add(
-      Collider(
-        shape: CollisionBox(Vector3(60.0, 0.5, 60.0)),
-        position: Vector3(0.0, -0.5, 0.0),
-      ),
-    );
-  // Something to sweep against: a field of pillars, which is what a level of
-  // brushes looks like to the broadphase.
-  for (var x = -40; x <= 40; x += 4) {
-    for (var z = -40; z <= 40; z += 4) {
-      world.add(
-        Collider(
-          shape: CollisionBox(Vector3(0.6, 2.0, 0.6)),
-          position: Vector3(x.toDouble(), 2.0, z.toDouble()),
-        ),
-      );
-    }
-  }
-  return world;
-}
-
-double _run({ContactFilter? filter}) {
-  final world = _level();
-  final body = CharacterController(
-    world: world,
-    position: Vector3(1.0, 0.9, 1.0),
-  )..solidFilter = filter;
-  final wish = Vector3(1.0, 0.0, 0.35);
-  final clock = Stopwatch()..start();
-  for (var i = 0; i < _steps; i++) {
-    if (i % 900 == 0) body.requestJump();
-    body.step(1.0 / 60.0, wishDirection: wish);
-    if (body.position.x > 40.0 || body.position.z > 40.0) {
-      body.teleport(Vector3(-40.0, 0.9, -40.0));
-    }
-  }
-  clock.stop();
-  return clock.elapsedMicroseconds / _steps;
-}
-
-void main() {
-  // Warm, then measure: the first thousand steps are the JIT's.
-  _run();
-  final without = _run();
-  _run(filter: (SweptContact c) => true);
-  final trivial = _run(filter: (SweptContact c) => true);
-  final oneWay = _run(
-    filter: (SweptContact c) =>
-        c.other.layer & (1 << 6) == 0 || c.normal.y > 0.5,
-  );
-
-  // ignore: avoid_print
-  print(
-    'microseconds per step over $_steps steps\n'
-    '  no filter      ${without.toStringAsFixed(3)}\n'
-    '  trivial filter ${trivial.toStringAsFixed(3)}  '
-    '(+${((trivial / without - 1) * 100).toStringAsFixed(1)}%)\n'
-    '  one-way filter ${oneWay.toStringAsFixed(3)}  '
-    '(+${((oneWay / without - 1) * 100).toStringAsFixed(1)}%)',
-  );
-}
diff --git a/packages/flutter3d_physics/tool/ground_cost.dart b/packages/flutter3d_physics/tool/ground_cost.dart
deleted file mode 100644
index 9ae5bcf2b..000000000
--- a/packages/flutter3d_physics/tool/ground_cost.dart
+++ /dev/null
@@ -1,185 +0,0 @@
-/// What sweeping against sampled ground costs, beside sweeping against a box.
-///
-///     dart run tool/ground_cost.dart
-///
-/// **The number that decides whether ground can be a collision shape at all.**
-/// A field of triangles is not one convex solid, so every sweep against it
-/// walks several prisms instead of one set of planes, and "several" is decided
-/// by how much ground the swept box covers. A body a third of a metre across
-/// moving a tenth of a metre a step touches one or two cells, which is two or
-/// four triangles — but that is an argument, and this is the measurement.
-///
-/// ## What was measured, on macOS-arm64, Dart 3.12, 2026-09-08
-///
-/// One sweep of a player-sized box onto the surface, averaged over two hundred
-/// thousand of them, microseconds each — two runs, and they agreed to within
-/// three per cent:
-///
-///     against one box                       0.13
-///     against ground, 1 m cells             0.53   (4.1x)
-///     against ground, 4 m cells             0.31   (2.4x)
-///     against ground, 1 m cells, a capsule  0.48
-///
-/// And the step those add up to, sixty thousand of them:
-///
-///     a walking body over one box           0.52
-///     a walking body over ground            3.5    (6.7x)
-///
-/// **Four times a brush for one sweep, and nearly seven times for a step.** The
-/// step is the worse ratio because a controller makes four or five sweeps and a
-/// depenetration in one, and each of them now walks four to eight prisms where
-/// it used to walk one box. Three and a half microseconds is still a
-/// three-hundredth of a sixtieth of a second, so a hundred bodies walking on
-/// ground is a fifth of a frame — comfortable for a strategy and worth knowing
-/// before somebody puts a thousand there.
-///
-/// **The cell size is the dial, and it is the level's.** Wider cells mean fewer
-/// triangles under a body and a coarser surface; the difference between one
-/// metre and four is nearly a factor of two, and it is what a level author is
-/// choosing between without being told.
-///
-/// The capsule being *cheaper* than the box it fits in reads backwards. It
-/// walks exactly the same prisms — the broadphase asks the bounding box, and
-/// the two have the same one — so the tenth is in the growth: a capsule's reach
-/// along a normal is one multiply and an add, and a box's is three of each.
-///
-/// ## What is not measured here
-///
-/// A triangle mesh. There is not one: `CollisionHeightfield` is the whole of
-/// what this package can be handed as ground, and a general mesh — which needs
-/// a spatial index inside the shape rather than a grid it already is — has not
-/// been written. The row it would occupy in the table above is missing rather
-/// than estimated.
-library;
-
-import 'dart:typed_data';
-
-import 'package:flutter3d_physics/flutter3d_physics.dart';
-import 'package:vector_math/vector_math.dart';
-
-const int _sweeps = 200000;
-
-CollisionWorld _ground(double cellSize) {
-  const n = 65;
-  final heights = Float32List(n * n);
-  for (var row = 0; row < n; row++) {
-    for (var column = 0; column < n; column++) {
-      heights[row * n + column] =
-          0.06 * ((column * 5 + row * 3) % 7) +
-          0.04 * ((column * 3 + row * 11) % 5);
-    }
-  }
-  final world = CollisionWorld()
-    ..add(
-      Collider(
-        shape: CollisionHeightfield(
-          columns: n,
-          rows: n,
-          cellSize: cellSize,
-          heights: heights,
-        ),
-        position: Vector3.zero(),
-      ),
-    );
-  world.update();
-  return world;
-}
-
-/// One brush the same size as the whole field, so the broadphase has the same
-/// amount of work to do and the difference is the narrow phase alone.
-CollisionWorld _brush(double cellSize) {
-  final span = 64.0 * cellSize;
-  final world = CollisionWorld()
-    ..addBox(Vector3(0.0, -1.0, 0.0), Vector3(span, 2.0, span));
-  world.update();
-  return world;
-}
-
-/// Sweeps [shape] downward from a walk across the field, and returns the
-/// microseconds one sweep took.
-double _cost(CollisionWorld world, CollisionShape shape, double span) {
-  final hit = SweepHit();
-  final from = Vector3.zero();
-  // Down onto the surface and a little along it: the shape of the probe the
-  // ground check makes, and long enough to actually land. A sweep that misses
-  // is a sweep that stops at the first rejection, which would measure the
-  // broadphase rather than the geometry.
-  final delta = Vector3(0.05, -1.6, 0.03);
-  var landed = 0;
-  final clock = Stopwatch()..start();
-  for (var i = 0; i < _sweeps; i++) {
-    // A walk that covers the field rather than one spot, so the measurement is
-    // not of one cell staying in the cache.
-    final t = i / _sweeps;
-    from.setValues(
-      (t * span * 7.0) % span - span * 0.5,
-      2.0,
-      (t * span * 3.0) % span - span * 0.5,
-    );
-    if (world.sweep(shape, from, delta, hit)) landed++;
-  }
-  clock.stop();
-  if (landed < _sweeps) {
-    // ignore: avoid_print
-    print('  (only $landed of $_sweeps sweeps landed on anything)');
-  }
-  return clock.elapsedMicroseconds / _sweeps;
-}
-
-/// A whole step of a walking body, which is what the sweep cost adds up to.
-double _stepCost(CollisionWorld world) {
-  final walker = CharacterController(
-    world: world,
-    position: Vector3(0.0, 2.0, 0.0),
-  );
-  final wish = Vector3(1.0, 0.0, 0.35);
-  const steps = 60000;
-  final clock = Stopwatch()..start();
-  for (var i = 0; i < steps; i++) {
-    walker.step(1.0 / 60.0, wishDirection: wish);
-    if (walker.position.x > 24.0 || walker.position.z > 24.0) {
-      walker.teleport(Vector3(-24.0, 2.0, -24.0));
-    }
-  }
-  clock.stop();
-  return clock.elapsedMicroseconds / steps;
-}
-
-void main() {
-  final body = CollisionBox(Vector3(0.35, 0.9, 0.35));
-  final capsule = CollisionCapsule(radius: 0.35, halfHeight: 0.55);
-
-  final fine = _ground(1.0);
-  final coarse = _ground(4.0);
-  final flat = _brush(1.0);
-
-  // Warm, then measure: the first pass is the JIT's.
-  _cost(flat, body, 64.0);
-  _cost(fine, body, 64.0);
-  _cost(coarse, body, 256.0);
-
-  final box = _cost(flat, body, 64.0);
-  final ground = _cost(fine, body, 64.0);
-  final wide = _cost(coarse, body, 256.0);
-  final rounded = _cost(fine, capsule, 64.0);
-
-  _stepCost(_brush(1.0));
-  _stepCost(_ground(1.0));
-  final walkFlat = _stepCost(_brush(1.0));
-  final walkGround = _stepCost(_ground(1.0));
-
-  // ignore: avoid_print
-  print(
-    'microseconds a sweep, over $_sweeps of them\n'
-    '  against one box                       ${box.toStringAsFixed(3)}\n'
-    '  against ground, 1 m cells             ${ground.toStringAsFixed(3)}'
-    '   (${(ground / box).toStringAsFixed(1)}x)\n'
-    '  against ground, 4 m cells             ${wide.toStringAsFixed(3)}'
-    '   (${(wide / box).toStringAsFixed(1)}x)\n'
-    '  against ground, 1 m cells, a capsule  ${rounded.toStringAsFixed(3)}\n'
-    '\nmicroseconds a step of a walking body\n'
-    '  over one box                          ${walkFlat.toStringAsFixed(3)}\n'
-    '  over ground, 1 m cells                ${walkGround.toStringAsFixed(3)}'
-    '   (${(walkGround / walkFlat).toStringAsFixed(1)}x)',
-  );
-}
diff --git a/packages/flutter3d_shaders/shaders/lib/shadow.glsl b/packages/flutter3d_shaders/shaders/lib/shadow.glsl
index dedd5d86e..933fc48f9 100644
--- a/packages/flutter3d_shaders/shaders/lib/shadow.glsl
+++ b/packages/flutter3d_shaders/shaders/lib/shadow.glsl
@@ -220,13 +220,23 @@ float ShadowFactor(Surface s, LightSample light, int lightIndex) {
   // cut. A sign rather than another uniform, for the reason the softness
   // itself rides here.
   // **What the see-through casters let through** — before the filter, whose
-  // soft path leaves early where it finds no blocker. One bilinear tap: a
-  // translucent caster's shadow is light shaded rather than light stopped,
-  // and its edge is softened by the filtering the tap already gets. Green
-  // and blue hold what was taken from red and green, alpha what was left of
-  // blue — the layout `shadow_transmittance.frag` explains.
+  // soft path leaves early where it finds no blocker. Averaged over the same
+  // 3×3 texels the opaque edge is: the atlas is read without filtering, and
+  // one tap, which once relied on the sampler's bilinear step, drew a glass
+  // or a liquid's shadow edge as stairs a texel high. Green and blue hold
+  // what was taken from red and green, alpha what was left of blue — the
+  // layout `shadow_transmittance.frag` explains.
   if (frag_info.shadow_bias.w > 0.5) {
-    vec4 stored = textureLod(shadow_texture, clamp(uv, tileLo, tileHi), 0.0);
+    vec4 stored = vec4(0.0);
+    for (int y = -1; y <= 1; y++) {
+      for (int x = -1; x <= 1; x++) {
+        stored += textureLod(
+            shadow_texture,
+            clamp(uv + vec2(float(x), float(y)) * texel, tileLo, tileHi),
+            0.0);
+      }
+    }
+    stored *= 1.0 / 9.0;
     // Up to four: light a caster gathered, not only light it stopped.
     vec3 through = clamp(vec3(1.0 - stored.g, 1.0 - stored.b, stored.a), 0.0, 4.0);
     light_transmittance = mix(vec3(1.0), through, clamp(strength, 0.0, 1.0));
diff --git a/packages/flutter3d_shaders/shaders/lighting/caustic_photon.vert b/packages/flutter3d_shaders/shaders/lighting/caustic_photon.vert
index 1faf27c50..2fec53e5b 100644
--- a/packages/flutter3d_shaders/shaders/lighting/caustic_photon.vert
+++ b/packages/flutter3d_shaders/shaders/lighting/caustic_photon.vert
@@ -199,6 +199,16 @@ void main() {
     vec4 prev_y = Follow(uv - vec2(0.0, texel), unused);
     if (prev_y.w > 0.5) b = here.xy - prev_y.xy;
   }
+  // **Stretched past sixteen times its own spacing either way, left out.**
+  // Its light is spread a two-hundred-and-fiftieth as thin as where it set
+  // out, so it shows nothing; drawn, a photon whose neighbour landed across
+  // the tile was a quad over most of it, and the hundreds of them at a
+  // liquid's rim, where the light leaves edge-on, cost more than the rest
+  // of the frame together once the bench was in the map for them to land.
+  if (length(a) > 16.0 * caustic_info.grid.z ||
+      length(b) > 16.0 * caustic_info.grid.w) {
+    return;
+  }
   // Half again, so neighbouring quads overlap, and never under the least.
   float least = caustic_info.grid.y;
   a = AtLeast(1.5 * a, spacing_x, least);
diff --git a/packages/flutter3d_webgl/lib/engine_shaders.dart b/packages/flutter3d_webgl/lib/engine_shaders.dart
index 552bf6411..3059a9354 100644
--- a/packages/flutter3d_webgl/lib/engine_shaders.dart
+++ b/packages/flutter3d_webgl/lib/engine_shaders.dart
@@ -2364,6 +2364,16 @@ void main() {
     vec4 prev_y = Follow(uv - vec2(0.0, texel), unused);
     if (prev_y.w > 0.5) b = here.xy - prev_y.xy;
   }
+  // **Stretched past sixteen times its own spacing either way, left out.**
+  // Its light is spread a two-hundred-and-fiftieth as thin as where it set
+  // out, so it shows nothing; drawn, a photon whose neighbour landed across
+  // the tile was a quad over most of it, and the hundreds of them at a
+  // liquid's rim, where the light leaves edge-on, cost more than the rest
+  // of the frame together once the bench was in the map for them to land.
+  if (length(a) > 16.0 * caustic_info.grid.z ||
+      length(b) > 16.0 * caustic_info.grid.w) {
+    return;
+  }
   // Half again, so neighbouring quads overlap, and never under the least.
   float least = caustic_info.grid.y;
   a = AtLeast(1.5 * a, spacing_x, least);
@@ -9674,13 +9684,23 @@ float ShadowFactor(Surface s, LightSample light, int lightIndex) {
   // cut. A sign rather than another uniform, for the reason the softness
   // itself rides here.
   // **What the see-through casters let through** — before the filter, whose
-  // soft path leaves early where it finds no blocker. One bilinear tap: a
-  // translucent caster's shadow is light shaded rather than light stopped,
-  // and its edge is softened by the filtering the tap already gets. Green
-  // and blue hold what was taken from red and green, alpha what was left of
-  // blue — the layout `shadow_transmittance.frag` explains.
+  // soft path leaves early where it finds no blocker. Averaged over the same
+  // 3×3 texels the opaque edge is: the atlas is read without filtering, and
+  // one tap, which once relied on the sampler's bilinear step, drew a glass
+  // or a liquid's shadow edge as stairs a texel high. Green and blue hold
+  // what was taken from red and green, alpha what was left of blue — the
+  // layout `shadow_transmittance.frag` explains.
   if (frag_info.shadow_bias.w > 0.5) {
-    vec4 stored = textureLod(shadow_texture, clamp(uv, tileLo, tileHi), 0.0);
+    vec4 stored = vec4(0.0);
+    for (int y = -1; y <= 1; y++) {
+      for (int x = -1; x <= 1; x++) {
+        stored += textureLod(
+            shadow_texture,
+            clamp(uv + vec2(float(x), float(y)) * texel, tileLo, tileHi),
+            0.0);
+      }
+    }
+    stored *= 1.0 / 9.0;
     // Up to four: light a caster gathered, not only light it stopped.
     vec3 through = clamp(vec3(1.0 - stored.g, 1.0 - stored.b, stored.a), 0.0, 4.0);
     light_transmittance = mix(vec3(1.0), through, clamp(strength, 0.0, 1.0));
@@ -12328,13 +12348,23 @@ float ShadowFactor(Surface s, LightSample light, int lightIndex) {
   // cut. A sign rather than another uniform, for the reason the softness
   // itself rides here.
   // **What the see-through casters let through** — before the filter, whose
-  // soft path leaves early where it finds no blocker. One bilinear tap: a
-  // translucent caster's shadow is light shaded rather than light stopped,
-  // and its edge is softened by the filtering the tap already gets. Green
-  // and blue hold what was taken from red and green, alpha what was left of
-  // blue — the layout `shadow_transmittance.frag` explains.
+  // soft path leaves early where it finds no blocker. Averaged over the same
+  // 3×3 texels the opaque edge is: the atlas is read without filtering, and
+  // one tap, which once relied on the sampler's bilinear step, drew a glass
+  // or a liquid's shadow edge as stairs a texel high. Green and blue hold
+  // what was taken from red and green, alpha what was left of blue — the
+  // layout `shadow_transmittance.frag` explains.
   if (frag_info.shadow_bias.w > 0.5) {
-    vec4 stored = textureLod(shadow_texture, clamp(uv, tileLo, tileHi), 0.0);
+    vec4 stored = vec4(0.0);
+    for (int y = -1; y <= 1; y++) {
+      for (int x = -1; x <= 1; x++) {
+        stored += textureLod(
+            shadow_texture,
+            clamp(uv + vec2(float(x), float(y)) * texel, tileLo, tileHi),
+            0.0);
+      }
+    }
+    stored *= 1.0 / 9.0;
     // Up to four: light a caster gathered, not only light it stopped.
     vec3 through = clamp(vec3(1.0 - stored.g, 1.0 - stored.b, stored.a), 0.0, 4.0);
     light_transmittance = mix(vec3(1.0), through, clamp(strength, 0.0, 1.0));
@@ -15017,13 +15047,23 @@ float ShadowFactor(Surface s, LightSample light, int lightIndex) {
   // cut. A sign rather than another uniform, for the reason the softness
   // itself rides here.
   // **What the see-through casters let through** — before the filter, whose
-  // soft path leaves early where it finds no blocker. One bilinear tap: a
-  // translucent caster's shadow is light shaded rather than light stopped,
-  // and its edge is softened by the filtering the tap already gets. Green
-  // and blue hold what was taken from red and green, alpha what was left of
-  // blue — the layout `shadow_transmittance.frag` explains.
+  // soft path leaves early where it finds no blocker. Averaged over the same
+  // 3×3 texels the opaque edge is: the atlas is read without filtering, and
+  // one tap, which once relied on the sampler's bilinear step, drew a glass
+  // or a liquid's shadow edge as stairs a texel high. Green and blue hold
+  // what was taken from red and green, alpha what was left of blue — the
+  // layout `shadow_transmittance.frag` explains.
   if (frag_info.shadow_bias.w > 0.5) {
-    vec4 stored = textureLod(shadow_texture, clamp(uv, tileLo, tileHi), 0.0);
+    vec4 stored = vec4(0.0);
+    for (int y = -1; y <= 1; y++) {
+      for (int x = -1; x <= 1; x++) {
+        stored += textureLod(
+            shadow_texture,
+            clamp(uv + vec2(float(x), float(y)) * texel, tileLo, tileHi),
+            0.0);
+      }
+    }
+    stored *= 1.0 / 9.0;
     // Up to four: light a caster gathered, not only light it stopped.
     vec3 through = clamp(vec3(1.0 - stored.g, 1.0 - stored.b, stored.a), 0.0, 4.0);
     light_transmittance = mix(vec3(1.0), through, clamp(strength, 0.0, 1.0));
@@ -18562,13 +18602,23 @@ float ShadowFactor(Surface s, LightSample light, int lightIndex) {
   // cut. A sign rather than another uniform, for the reason the softness
   // itself rides here.
   // **What the see-through casters let through** — before the filter, whose
-  // soft path leaves early where it finds no blocker. One bilinear tap: a
-  // translucent caster's shadow is light shaded rather than light stopped,
-  // and its edge is softened by the filtering the tap already gets. Green
-  // and blue hold what was taken from red and green, alpha what was left of
-  // blue — the layout `shadow_transmittance.frag` explains.
+  // soft path leaves early where it finds no blocker. Averaged over the same
+  // 3×3 texels the opaque edge is: the atlas is read without filtering, and
+  // one tap, which once relied on the sampler's bilinear step, drew a glass
+  // or a liquid's shadow edge as stairs a texel high. Green and blue hold
+  // what was taken from red and green, alpha what was left of blue — the
+  // layout `shadow_transmittance.frag` explains.
   if (frag_info.shadow_bias.w > 0.5) {
-    vec4 stored = textureLod(shadow_texture, clamp(uv, tileLo, tileHi), 0.0);
+    vec4 stored = vec4(0.0);
+    for (int y = -1; y <= 1; y++) {
+      for (int x = -1; x <= 1; x++) {
+        stored += textureLod(
+            shadow_texture,
+            clamp(uv + vec2(float(x), float(y)) * texel, tileLo, tileHi),
+            0.0);
+      }
+    }
+    stored *= 1.0 / 9.0;
     // Up to four: light a caster gathered, not only light it stopped.
     vec3 through = clamp(vec3(1.0 - stored.g, 1.0 - stored.b, stored.a), 0.0, 4.0);
     light_transmittance = mix(vec3(1.0), through, clamp(strength, 0.0, 1.0));
@@ -22075,13 +22125,23 @@ float ShadowFactor(Surface s, LightSample light, int lightIndex) {
   // cut. A sign rather than another uniform, for the reason the softness
   // itself rides here.
   // **What the see-through casters let through** — before the filter, whose
-  // soft path leaves early where it finds no blocker. One bilinear tap: a
-  // translucent caster's shadow is light shaded rather than light stopped,
-  // and its edge is softened by the filtering the tap already gets. Green
-  // and blue hold what was taken from red and green, alpha what was left of
-  // blue — the layout `shadow_transmittance.frag` explains.
+  // soft path leaves early where it finds no blocker. Averaged over the same
+  // 3×3 texels the opaque edge is: the atlas is read without filtering, and
+  // one tap, which once relied on the sampler's bilinear step, drew a glass
+  // or a liquid's shadow edge as stairs a texel high. Green and blue hold
+  // what was taken from red and green, alpha what was left of blue — the
+  // layout `shadow_transmittance.frag` explains.
   if (frag_info.shadow_bias.w > 0.5) {
-    vec4 stored = textureLod(shadow_texture, clamp(uv, tileLo, tileHi), 0.0);
+    vec4 stored = vec4(0.0);
+    for (int y = -1; y <= 1; y++) {
+      for (int x = -1; x <= 1; x++) {
+        stored += textureLod(
+            shadow_texture,
+            clamp(uv + vec2(float(x), float(y)) * texel, tileLo, tileHi),
+            0.0);
+      }
+    }
+    stored *= 1.0 / 9.0;
     // Up to four: light a caster gathered, not only light it stopped.
     vec3 through = clamp(vec3(1.0 - stored.g, 1.0 - stored.b, stored.a), 0.0, 4.0);
     light_transmittance = mix(vec3(1.0), through, clamp(strength, 0.0, 1.0));
@@ -37895,13 +37955,23 @@ float ShadowFactor(Surface s, LightSample light, int lightIndex) {
   // cut. A sign rather than another uniform, for the reason the softness
   // itself rides here.
   // **What the see-through casters let through** — before the filter, whose
-  // soft path leaves early where it finds no blocker. One bilinear tap: a
-  // translucent caster's shadow is light shaded rather than light stopped,
-  // and its edge is softened by the filtering the tap already gets. Green
-  // and blue hold what was taken from red and green, alpha what was left of
-  // blue — the layout `shadow_transmittance.frag` explains.
+  // soft path leaves early where it finds no blocker. Averaged over the same
+  // 3×3 texels the opaque edge is: the atlas is read without filtering, and
+  // one tap, which once relied on the sampler's bilinear step, drew a glass
+  // or a liquid's shadow edge as stairs a texel high. Green and blue hold
+  // what was taken from red and green, alpha what was left of blue — the
+  // layout `shadow_transmittance.frag` explains.
   if (frag_info.shadow_bias.w > 0.5) {
-    vec4 stored = textureLod(shadow_texture, clamp(uv, tileLo, tileHi), 0.0);
+    vec4 stored = vec4(0.0);
+    for (int y = -1; y <= 1; y++) {
+      for (int x = -1; x <= 1; x++) {
+        stored += textureLod(
+            shadow_texture,
+            clamp(uv + vec2(float(x), float(y)) * texel, tileLo, tileHi),
+            0.0);
+      }
+    }
+    stored *= 1.0 / 9.0;
     // Up to four: light a caster gathered, not only light it stopped.
     vec3 through = clamp(vec3(1.0 - stored.g, 1.0 - stored.b, stored.a), 0.0, 4.0);
     light_transmittance = mix(vec3(1.0), through, clamp(strength, 0.0, 1.0));
diff --git a/packages/flutter3d_webgpu/lib/engine_shaders.dart b/packages/flutter3d_webgpu/lib/engine_shaders.dart
index 138fca5e1..3e30f3ac1 100644
--- a/packages/flutter3d_webgpu/lib/engine_shaders.dart
+++ b/packages/flutter3d_webgpu/lib/engine_shaders.dart
@@ -3535,48 +3535,48 @@ fn AtLeast_u0028_vf2_u003b_vf2_u003b_f1_u003b(a: ptr<function, vec2<f32>>, fallb
     var size: f32;
     var local: vec2<f32>;
 
-    let _e50 = (*a);
-    size = length(_e50);
-    let _e52 = size;
-    if (_e52 < 0.000000001f) {
-        let _e54 = (*fallback);
-        let _e56 = (*least);
-        return (normalize(_e54) * _e56);
-    }
-    let _e58 = size;
-    let _e59 = (*least);
-    if (_e58 < _e59) {
-        let _e61 = (*a);
-        let _e62 = (*least);
-        let _e63 = size;
-        local = (_e61 * (_e62 / _e63));
-    } else {
-        let _e66 = (*a);
-        local = _e66;
-    }
-    let _e67 = local;
-    return _e67;
+    let _e51 = (*a);
+    size = length(_e51);
+    let _e53 = size;
+    if (_e53 < 0.000000001f) {
+        let _e55 = (*fallback);
+        let _e57 = (*least);
+        return (normalize(_e55) * _e57);
+    }
+    let _e59 = size;
+    let _e60 = (*least);
+    if (_e59 < _e60) {
+        let _e62 = (*a);
+        let _e63 = (*least);
+        let _e64 = size;
+        local = (_e62 * (_e63 / _e64));
+    } else {
+        let _e67 = (*a);
+        local = _e67;
+    }
+    let _e68 = local;
+    return _e68;
 }
 
 fn Schlick_u0028_f1_u003b_f1_u003b(f0_: ptr<function, f32>, cosine: ptr<function, f32>) -> f32 {
     var c: f32;
 
-    let _e48 = (*cosine);
-    c = clamp((1f - _e48), 0f, 1f);
-    let _e51 = (*f0_);
+    let _e49 = (*cosine);
+    c = clamp((1f - _e49), 0f, 1f);
     let _e52 = (*f0_);
-    let _e54 = c;
-    let _e56 = c;
-    let _e58 = c;
-    let _e60 = c;
-    let _e62 = c;
-    return (_e51 + ((((((1f - _e52) * _e54) * _e56) * _e58) * _e60) * _e62));
+    let _e53 = (*f0_);
+    let _e55 = c;
+    let _e57 = c;
+    let _e59 = c;
+    let _e61 = c;
+    let _e63 = c;
+    return (_e52 + ((((((1f - _e53) * _e55) * _e57) * _e59) * _e61) * _e63));
 }
 
 fn MapUv_u0028_vf4_u003b(p: ptr<function, vec4<f32>>) -> vec2<f32> {
-    let _e47 = (*p)[0u];
-    let _e51 = (*p)[1u];
-    return vec2<f32>(((_e47 * 0.5f) + 0.5f), (0.5f - (_e51 * 0.5f)));
+    let _e48 = (*p)[0u];
+    let _e52 = (*p)[1u];
+    return vec2<f32>(((_e48 * 0.5f) + 0.5f), (0.5f - (_e52 * 0.5f)));
 }
 
 fn Follow_u0028_vf2_u003b_vf3_u003b(uv: ptr<function, vec2<f32>>, energy: ptr<function, vec3<f32>>) -> vec4<f32> {
@@ -3616,191 +3616,191 @@ fn Follow_u0028_vf2_u003b_vf3_u003b(uv: ptr<function, vec2<f32>>, energy: ptr<fu
     var phi_100_: bool;
 
     (*energy) = vec3<f32>(0f, 0f, 0f);
-    let _e80 = (*uv);
-    let _e81 = textureSampleLevel(caustic_front_tex, caustic_front_smp, _e80, 0f);
-    front = _e81;
-    let _e83 = front[3u];
-    let _e84 = (_e83 >= 1f);
-    phi_100_ = _e84;
-    if !(_e84) {
-        let _e86 = front;
-        let _e88 = front;
-        phi_100_ = (dot(_e86.xyz, _e88.xyz) < 0.25f);
-    }
-    let _e93 = phi_100_;
-    if _e93 {
+    let _e81 = (*uv);
+    let _e82 = textureSampleLevel(caustic_front_tex, caustic_front_smp, _e81, 0f);
+    front = _e82;
+    let _e84 = front[3u];
+    let _e85 = (_e84 >= 1f);
+    phi_100_ = _e85;
+    if !(_e85) {
+        let _e87 = front;
+        let _e89 = front;
+        phi_100_ = (dot(_e87.xyz, _e89.xyz) < 0.25f);
+    }
+    let _e94 = phi_100_;
+    if _e94 {
         return vec4<f32>(0f, 0f, 0f, 0f);
     }
-    let _e95 = (*uv)[0u];
-    let _e99 = (*uv)[1u];
-    ndc = vec2<f32>(((_e95 * 2f) - 1f), ((0.5f - _e99) * 2f));
-    let _e104 = caustic_info.map_to_world;
-    let _e105 = ndc;
-    let _e107 = front[3u];
-    entry = (_e104 * vec4<f32>(_e105.x, _e105.y, _e107, 1f)).xyz;
-    let _e114 = caustic_info.map_to_world;
-    range = length((_e114 * vec4<f32>(0f, 0f, 1f, 0f)).xyz);
-    let _e119 = caustic_info.light;
-    l = normalize(_e119.xyz);
-    let _e122 = front;
-    n1_ = normalize(_e122.xyz);
-    let _e125 = n1_;
-    let _e126 = l;
-    if (dot(_e125, _e126) > 0f) {
-        let _e129 = n1_;
-        n1_ = -(_e129);
-    }
-    let _e133 = caustic_info.optics[0u];
-    index = max(_e133, 1f);
-    let _e135 = l;
-    let _e136 = n1_;
-    let _e137 = index;
-    inside = refract(_e135, _e136, (1f / _e137));
-    let _e140 = (*uv);
-    let _e141 = textureSampleLevel(caustic_back_tex, caustic_back_smp, _e140, 0f);
-    back = _e141;
-    let _e143 = back[3u];
-    let _e145 = front[3u];
-    if (_e143 <= _e145) {
+    let _e96 = (*uv)[0u];
+    let _e100 = (*uv)[1u];
+    ndc = vec2<f32>(((_e96 * 2f) - 1f), ((0.5f - _e100) * 2f));
+    let _e105 = caustic_info.map_to_world;
+    let _e106 = ndc;
+    let _e108 = front[3u];
+    entry = (_e105 * vec4<f32>(_e106.x, _e106.y, _e108, 1f)).xyz;
+    let _e115 = caustic_info.map_to_world;
+    range = length((_e115 * vec4<f32>(0f, 0f, 1f, 0f)).xyz);
+    let _e120 = caustic_info.light;
+    l = normalize(_e120.xyz);
+    let _e123 = front;
+    n1_ = normalize(_e123.xyz);
+    let _e126 = n1_;
+    let _e127 = l;
+    if (dot(_e126, _e127) > 0f) {
+        let _e130 = n1_;
+        n1_ = -(_e130);
+    }
+    let _e134 = caustic_info.optics[0u];
+    index = max(_e134, 1f);
+    let _e136 = l;
+    let _e137 = n1_;
+    let _e138 = index;
+    inside = refract(_e136, _e137, (1f / _e138));
+    let _e141 = (*uv);
+    let _e142 = textureSampleLevel(caustic_back_tex, caustic_back_smp, _e141, 0f);
+    back = _e142;
+    let _e144 = back[3u];
+    let _e146 = front[3u];
+    if (_e144 <= _e146) {
         return vec4<f32>(0f, 0f, 0f, 0f);
     }
-    let _e148 = back[3u];
-    let _e150 = front[3u];
-    let _e152 = range;
-    across = ((_e148 - _e150) * _e152);
-    let _e154 = entry;
-    let _e155 = inside;
-    let _e156 = across;
-    let _e157 = inside;
-    let _e158 = l;
-    exit = (_e154 + (_e155 * (_e156 / max(dot(_e157, _e158), 0.2f))));
-    let _e165 = caustic_info.world_to_map;
-    let _e166 = exit;
-    param = (_e165 * vec4<f32>(_e166.x, _e166.y, _e166.z, 1f));
-    let _e172 = MapUv_u0028_vf4_u003b((&param));
-    let _e176 = textureSampleLevel(caustic_back_tex, caustic_back_smp, clamp(_e172, vec2(0f), vec2(1f)), 0f);
-    there = _e176;
-    let _e177 = there;
-    let _e179 = there;
-    if (dot(_e177.xyz, _e179.xyz) > 0.25f) {
-        let _e183 = there;
-        local_1 = normalize(_e183.xyz);
-    } else {
-        let _e186 = back;
-        local_1 = normalize(_e186.xyz);
-    }
-    let _e189 = local_1;
-    n2_ = _e189;
-    let _e190 = n2_;
-    let _e191 = inside;
-    if (dot(_e190, _e191) < 0f) {
-        let _e194 = n2_;
-        n2_ = -(_e194);
-    }
-    let _e196 = inside;
-    let _e197 = n2_;
-    let _e199 = index;
-    out_ray = refract(_e196, -(_e197), _e199);
-    let _e201 = out_ray;
+    let _e149 = back[3u];
+    let _e151 = front[3u];
+    let _e153 = range;
+    across = ((_e149 - _e151) * _e153);
+    let _e155 = entry;
+    let _e156 = inside;
+    let _e157 = across;
+    let _e158 = inside;
+    let _e159 = l;
+    exit = (_e155 + (_e156 * (_e157 / max(dot(_e158, _e159), 0.2f))));
+    let _e166 = caustic_info.world_to_map;
+    let _e167 = exit;
+    param = (_e166 * vec4<f32>(_e167.x, _e167.y, _e167.z, 1f));
+    let _e173 = MapUv_u0028_vf4_u003b((&param));
+    let _e177 = textureSampleLevel(caustic_back_tex, caustic_back_smp, clamp(_e173, vec2(0f), vec2(1f)), 0f);
+    there = _e177;
+    let _e178 = there;
+    let _e180 = there;
+    if (dot(_e178.xyz, _e180.xyz) > 0.25f) {
+        let _e184 = there;
+        local_1 = normalize(_e184.xyz);
+    } else {
+        let _e187 = back;
+        local_1 = normalize(_e187.xyz);
+    }
+    let _e190 = local_1;
+    n2_ = _e190;
+    let _e191 = n2_;
+    let _e192 = inside;
+    if (dot(_e191, _e192) < 0f) {
+        let _e195 = n2_;
+        n2_ = -(_e195);
+    }
+    let _e197 = inside;
+    let _e198 = n2_;
+    let _e200 = index;
+    out_ray = refract(_e197, -(_e198), _e200);
     let _e202 = out_ray;
-    if (dot(_e201, _e202) < 0.000001f) {
+    let _e203 = out_ray;
+    if (dot(_e202, _e203) < 0.000001f) {
         return vec4<f32>(0f, 0f, 0f, 0f);
     }
-    let _e205 = out_ray;
-    out_ray = normalize(_e205);
-    let _e207 = out_ray;
-    let _e208 = l;
-    if (dot(_e207, _e208) < 0.3f) {
+    let _e206 = out_ray;
+    out_ray = normalize(_e206);
+    let _e208 = out_ray;
+    let _e209 = l;
+    if (dot(_e208, _e209) < 0.3f) {
         return vec4<f32>(0f, 0f, 0f, 0f);
     }
-    let _e213 = caustic_info.optics[1u];
-    f0_1 = _e213;
-    let _e215 = caustic_info.tint;
-    let _e217 = l;
-    let _e218 = n1_;
-    let _e221 = f0_1;
-    param_1 = _e221;
-    param_2 = abs(dot(_e217, _e218));
-    let _e222 = Schlick_u0028_f1_u003b_f1_u003b((&param_1), (&param_2));
-    let _e225 = out_ray;
-    let _e226 = n2_;
-    let _e229 = f0_1;
-    param_3 = _e229;
-    param_4 = abs(dot(_e225, _e226));
-    let _e230 = Schlick_u0028_f1_u003b_f1_u003b((&param_3), (&param_4));
-    (*energy) = ((_e215.xyz * (1f - _e222)) * (1f - _e230));
-    let _e235 = caustic_info.optics[2u];
-    fading = _e235;
-    let _e236 = fading;
-    if (_e236 > 0f) {
-        let _e239 = caustic_info.attenuation;
-        let _e242 = exit;
-        let _e243 = entry;
-        let _e246 = fading;
-        let _e250 = (*energy);
-        (*energy) = (_e250 * pow(max(_e239.xyz, vec3<f32>(0.0001f, 0.0001f, 0.0001f)), vec3((length((_e242 - _e243)) / _e246))));
-    }
-    let _e252 = exit;
-    p_1 = _e252;
-    let _e253 = out_ray;
-    let _e254 = l;
-    down = max(dot(_e253, _e254), 0.05f);
+    let _e214 = caustic_info.optics[1u];
+    f0_1 = _e214;
+    let _e216 = caustic_info.tint;
+    let _e218 = l;
+    let _e219 = n1_;
+    let _e222 = f0_1;
+    param_1 = _e222;
+    param_2 = abs(dot(_e218, _e219));
+    let _e223 = Schlick_u0028_f1_u003b_f1_u003b((&param_1), (&param_2));
+    let _e226 = out_ray;
+    let _e227 = n2_;
+    let _e230 = f0_1;
+    param_3 = _e230;
+    param_4 = abs(dot(_e226, _e227));
+    let _e231 = Schlick_u0028_f1_u003b_f1_u003b((&param_3), (&param_4));
+    (*energy) = ((_e216.xyz * (1f - _e223)) * (1f - _e231));
+    let _e236 = caustic_info.optics[2u];
+    fading = _e236;
+    let _e237 = fading;
+    if (_e237 > 0f) {
+        let _e240 = caustic_info.attenuation;
+        let _e243 = exit;
+        let _e244 = entry;
+        let _e247 = fading;
+        let _e251 = (*energy);
+        (*energy) = (_e251 * pow(max(_e240.xyz, vec3<f32>(0.0001f, 0.0001f, 0.0001f)), vec3((length((_e243 - _e244)) / _e247))));
+    }
+    let _e253 = exit;
+    p_1 = _e253;
+    let _e254 = out_ray;
+    let _e255 = l;
+    down = max(dot(_e254, _e255), 0.05f);
     k = 0i;
     loop {
-        let _e257 = k;
-        if (_e257 < 4i) {
-            let _e260 = caustic_info.world_to_tile;
-            let _e261 = p_1;
-            q = (_e260 * vec4<f32>(_e261.x, _e261.y, _e261.z, 1f));
-            let _e267 = q;
-            param_5 = _e267;
-            let _e268 = MapUv_u0028_vf4_u003b((&param_5));
-            let _e272 = textureSampleLevel(caustic_depth_tex, caustic_depth_smp, clamp(_e268, vec2(0f), vec2(1f)), 0f);
-            receiver = _e272.x;
-            let _e274 = receiver;
-            let _e276 = q[2u];
-            let _e278 = range;
-            let _e280 = down;
-            advance = (((_e274 - _e276) * _e278) / _e280);
-            let _e282 = k;
-            if (_e282 == 0i) {
-                let _e284 = advance;
-                advance = max(_e284, 0f);
-            }
-            let _e286 = out_ray;
-            let _e287 = advance;
-            let _e289 = p_1;
-            p_1 = (_e289 + (_e286 * _e287));
+        let _e258 = k;
+        if (_e258 < 4i) {
+            let _e261 = caustic_info.world_to_tile;
+            let _e262 = p_1;
+            q = (_e261 * vec4<f32>(_e262.x, _e262.y, _e262.z, 1f));
+            let _e268 = q;
+            param_5 = _e268;
+            let _e269 = MapUv_u0028_vf4_u003b((&param_5));
+            let _e273 = textureSampleLevel(caustic_depth_tex, caustic_depth_smp, clamp(_e269, vec2(0f), vec2(1f)), 0f);
+            receiver = _e273.x;
+            let _e275 = receiver;
+            let _e277 = q[2u];
+            let _e279 = range;
+            let _e281 = down;
+            advance = (((_e275 - _e277) * _e279) / _e281);
+            let _e283 = k;
+            if (_e283 == 0i) {
+                let _e285 = advance;
+                advance = max(_e285, 0f);
+            }
+            let _e287 = out_ray;
+            let _e288 = advance;
+            let _e290 = p_1;
+            p_1 = (_e290 + (_e287 * _e288));
             continue;
         } else {
             break;
         }
         continuing {
-            let _e291 = k;
-            k = (_e291 + 1i);
-        }
-    }
-    let _e294 = caustic_info.world_to_tile;
-    let _e295 = p_1;
-    landed = (_e294 * vec4<f32>(_e295.x, _e295.y, _e295.z, 1f));
-    let _e301 = landed;
-    param_6 = _e301;
-    let _e302 = MapUv_u0028_vf4_u003b((&param_6));
-    let _e306 = textureSampleLevel(caustic_depth_tex, caustic_depth_smp, clamp(_e302, vec2(0f), vec2(1f)), 0f);
-    under = _e306.x;
-    let _e308 = under;
-    let _e310 = landed[2u];
-    let _e313 = range;
-    if ((abs((_e308 - _e310)) * _e313) > 0.02f) {
+            let _e292 = k;
+            k = (_e292 + 1i);
+        }
+    }
+    let _e295 = caustic_info.world_to_tile;
+    let _e296 = p_1;
+    landed = (_e295 * vec4<f32>(_e296.x, _e296.y, _e296.z, 1f));
+    let _e302 = landed;
+    param_6 = _e302;
+    let _e303 = MapUv_u0028_vf4_u003b((&param_6));
+    let _e307 = textureSampleLevel(caustic_depth_tex, caustic_depth_smp, clamp(_e303, vec2(0f), vec2(1f)), 0f);
+    under = _e307.x;
+    let _e309 = under;
+    let _e311 = landed[2u];
+    let _e314 = range;
+    if ((abs((_e309 - _e311)) * _e314) > 0.02f) {
         return vec4<f32>(0f, 0f, 0f, 0f);
     }
-    let _e317 = caustic_info.world_to_clip;
-    let _e318 = p_1;
-    clip = (_e317 * vec4<f32>(_e318.x, _e318.y, _e318.z, 1f));
-    let _e324 = clip;
-    let _e327 = clip[3u];
-    let _e329 = (_e324.xy / vec2(_e327));
-    return vec4<f32>(_e329.x, _e329.y, 0f, 1f);
+    let _e318 = caustic_info.world_to_clip;
+    let _e319 = p_1;
+    clip = (_e318 * vec4<f32>(_e319.x, _e319.y, _e319.z, 1f));
+    let _e325 = clip;
+    let _e328 = clip[3u];
+    let _e330 = (_e325.xy / vec2(_e328));
+    return vec4<f32>(_e330.x, _e330.y, 0f, 1f);
 }
 
 fn main_1() {
@@ -3842,150 +3842,164 @@ fn main_1() {
     var param_22: f32;
     var area: f32;
     var share: f32;
+    var phi_654_: bool;
 
-    let _e83 = corner_1;
-    v_uv = _e83;
+    let _e84 = corner_1;
+    v_uv = _e84;
     v_color = vec4<f32>(0f, 0f, 0f, 0f);
     unnamed.gl_Position = vec4<f32>(4f, 4f, 0.5f, 1f);
-    let _e87 = caustic_info.grid[0u];
-    n = _e87;
-    let _e88 = gl_InstanceIndex_1;
-    id = f32(_e88);
-    let _e90 = id;
-    let _e91 = n;
-    column = (_e90 - (floor((_e90 / _e91)) * _e91));
-    let _e96 = id;
-    let _e97 = n;
-    row = floor((_e96 / _e97));
-    let _e100 = column;
-    let _e102 = n;
-    let _e104 = row;
-    let _e106 = n;
-    uv_1 = vec2<f32>(((_e100 + 0.5f) / _e102), ((_e104 + 0.5f) / _e106));
-    let _e109 = n;
-    texel = (1f / _e109);
-    let _e111 = uv_1;
-    param_7 = _e111;
-    let _e112 = Follow_u0028_vf2_u003b_vf3_u003b((&param_7), (&param_8));
-    let _e113 = param_8;
-    energy_1 = _e113;
-    here = _e112;
-    let _e115 = here[3u];
-    if (_e115 < 0.5f) {
+    let _e88 = caustic_info.grid[0u];
+    n = _e88;
+    let _e89 = gl_InstanceIndex_1;
+    id = f32(_e89);
+    let _e91 = id;
+    let _e92 = n;
+    column = (_e91 - (floor((_e91 / _e92)) * _e92));
+    let _e97 = id;
+    let _e98 = n;
+    row = floor((_e97 / _e98));
+    let _e101 = column;
+    let _e103 = n;
+    let _e105 = row;
+    let _e107 = n;
+    uv_1 = vec2<f32>(((_e101 + 0.5f) / _e103), ((_e105 + 0.5f) / _e107));
+    let _e110 = n;
+    texel = (1f / _e110);
+    let _e112 = uv_1;
+    param_7 = _e112;
+    let _e113 = Follow_u0028_vf2_u003b_vf3_u003b((&param_7), (&param_8));
+    let _e114 = param_8;
+    energy_1 = _e114;
+    here = _e113;
+    let _e116 = here[3u];
+    if (_e116 < 0.5f) {
         return;
     }
-    let _e119 = caustic_info.grid[2u];
-    spacing_x = vec2<f32>(_e119, 0f);
-    let _e123 = caustic_info.grid[3u];
-    spacing_y = vec2<f32>(0f, _e123);
-    let _e125 = uv_1;
-    let _e126 = texel;
-    param_9 = (_e125 + vec2<f32>(_e126, 0f));
-    let _e129 = Follow_u0028_vf2_u003b_vf3_u003b((&param_9), (&param_10));
-    let _e130 = param_10;
-    unused = _e130;
-    next_x = _e129;
-    let _e132 = next_x[3u];
-    if (_e132 > 0.5f) {
-        let _e134 = next_x;
-        let _e136 = here;
-        local_2 = (_e134.xy - _e136.xy);
-    } else {
-        let _e139 = spacing_x;
-        local_2 = _e139;
-    }
-    let _e140 = local_2;
-    a_1 = _e140;
-    let _e142 = next_x[3u];
-    if (_e142 < 0.5f) {
-        let _e144 = uv_1;
-        let _e145 = texel;
-        param_11 = (_e144 - vec2<f32>(_e145, 0f));
-        let _e148 = Follow_u0028_vf2_u003b_vf3_u003b((&param_11), (&param_12));
-        let _e149 = param_12;
-        unused = _e149;
-        prev_x = _e148;
-        let _e151 = prev_x[3u];
-        if (_e151 > 0.5f) {
-            let _e153 = here;
-            let _e155 = prev_x;
-            a_1 = (_e153.xy - _e155.xy);
-        }
-    }
-    let _e158 = uv_1;
-    let _e159 = texel;
-    param_13 = (_e158 + vec2<f32>(0f, _e159));
-    let _e162 = Follow_u0028_vf2_u003b_vf3_u003b((&param_13), (&param_14));
-    let _e163 = param_14;
-    unused = _e163;
-    next_y = _e162;
-    let _e165 = next_y[3u];
-    if (_e165 > 0.5f) {
-        let _e167 = next_y;
-        let _e169 = here;
-        local_3 = (_e167.xy - _e169.xy);
-    } else {
-        let _e172 = spacing_y;
-        local_3 = _e172;
-    }
-    let _e173 = local_3;
-    b = _e173;
-    let _e175 = next_y[3u];
-    if (_e175 < 0.5f) {
-        let _e177 = uv_1;
-        let _e178 = texel;
-        param_15 = (_e177 - vec2<f32>(0f, _e178));
-        let _e181 = Follow_u0028_vf2_u003b_vf3_u003b((&param_15), (&param_16));
-        let _e182 = param_16;
-        unused = _e182;
-        prev_y = _e181;
-        let _e184 = prev_y[3u];
-        if (_e184 > 0.5f) {
-            let _e186 = here;
-            let _e188 = prev_y;
-            b = (_e186.xy - _e188.xy);
-        }
-    }
-    let _e193 = caustic_info.grid[1u];
-    least_1 = _e193;
-    let _e194 = a_1;
-    param_17 = (_e194 * 1.5f);
-    let _e196 = spacing_x;
-    param_18 = _e196;
-    let _e197 = least_1;
-    param_19 = _e197;
-    let _e198 = AtLeast_u0028_vf2_u003b_vf2_u003b_f1_u003b((&param_17), (&param_18), (&param_19));
-    a_1 = _e198;
-    let _e199 = b;
-    param_20 = (_e199 * 1.5f);
-    let _e201 = spacing_y;
-    param_21 = _e201;
-    let _e202 = least_1;
-    param_22 = _e202;
-    let _e203 = AtLeast_u0028_vf2_u003b_vf2_u003b_f1_u003b((&param_20), (&param_21), (&param_22));
-    b = _e203;
-    let _e205 = a_1[0u];
-    let _e207 = b[1u];
-    let _e210 = a_1[1u];
-    let _e212 = b[0u];
-    let _e216 = least_1;
-    let _e217 = least_1;
-    area = max(abs(((_e205 * _e207) - (_e210 * _e212))), (_e216 * _e217));
-    let _e220 = here;
-    let _e223 = corner_1[0u];
-    let _e224 = a_1;
-    let _e228 = corner_1[1u];
-    let _e229 = b;
-    let _e231 = ((_e220.xy + (_e224 * _e223)) + (_e229 * _e228));
-    unnamed.gl_Position = vec4<f32>(_e231.x, _e231.y, 0.5f, 1f);
-    let _e238 = caustic_info.grid[2u];
-    let _e241 = caustic_info.grid[3u];
-    share = (_e238 * _e241);
-    let _e243 = energy_1;
-    let _e244 = share;
-    let _e246 = area;
-    let _e249 = ((_e243 * _e244) / vec3((1.0471976f * _e246)));
-    v_color = vec4<f32>(_e249.x, _e249.y, _e249.z, 0f);
+    let _e120 = caustic_info.grid[2u];
+    spacing_x = vec2<f32>(_e120, 0f);
+    let _e124 = caustic_info.grid[3u];
+    spacing_y = vec2<f32>(0f, _e124);
+    let _e126 = uv_1;
+    let _e127 = texel;
+    param_9 = (_e126 + vec2<f32>(_e127, 0f));
+    let _e130 = Follow_u0028_vf2_u003b_vf3_u003b((&param_9), (&param_10));
+    let _e131 = param_10;
+    unused = _e131;
+    next_x = _e130;
+    let _e133 = next_x[3u];
+    if (_e133 > 0.5f) {
+        let _e135 = next_x;
+        let _e137 = here;
+        local_2 = (_e135.xy - _e137.xy);
+    } else {
+        let _e140 = spacing_x;
+        local_2 = _e140;
+    }
+    let _e141 = local_2;
+    a_1 = _e141;
+    let _e143 = next_x[3u];
+    if (_e143 < 0.5f) {
+        let _e145 = uv_1;
+        let _e146 = texel;
+        param_11 = (_e145 - vec2<f32>(_e146, 0f));
+        let _e149 = Follow_u0028_vf2_u003b_vf3_u003b((&param_11), (&param_12));
+        let _e150 = param_12;
+        unused = _e150;
+        prev_x = _e149;
+        let _e152 = prev_x[3u];
+        if (_e152 > 0.5f) {
+            let _e154 = here;
+            let _e156 = prev_x;
+            a_1 = (_e154.xy - _e156.xy);
+        }
+    }
+    let _e159 = uv_1;
+    let _e160 = texel;
+    param_13 = (_e159 + vec2<f32>(0f, _e160));
+    let _e163 = Follow_u0028_vf2_u003b_vf3_u003b((&param_13), (&param_14));
+    let _e164 = param_14;
+    unused = _e164;
+    next_y = _e163;
+    let _e166 = next_y[3u];
+    if (_e166 > 0.5f) {
+        let _e168 = next_y;
+        let _e170 = here;
+        local_3 = (_e168.xy - _e170.xy);
+    } else {
+        let _e173 = spacing_y;
+        local_3 = _e173;
+    }
+    let _e174 = local_3;
+    b = _e174;
+    let _e176 = next_y[3u];
+    if (_e176 < 0.5f) {
+        let _e178 = uv_1;
+        let _e179 = texel;
+        param_15 = (_e178 - vec2<f32>(0f, _e179));
+        let _e182 = Follow_u0028_vf2_u003b_vf3_u003b((&param_15), (&param_16));
+        let _e183 = param_16;
+        unused = _e183;
+        prev_y = _e182;
+        let _e185 = prev_y[3u];
+        if (_e185 > 0.5f) {
+            let _e187 = here;
+            let _e189 = prev_y;
+            b = (_e187.xy - _e189.xy);
+        }
+    }
+    let _e192 = a_1;
+    let _e196 = caustic_info.grid[2u];
+    let _e198 = (length(_e192) > (16f * _e196));
+    phi_654_ = _e198;
+    if !(_e198) {
+        let _e200 = b;
+        let _e204 = caustic_info.grid[3u];
+        phi_654_ = (length(_e200) > (16f * _e204));
+    }
+    let _e208 = phi_654_;
+    if _e208 {
+        return;
+    }
+    let _e211 = caustic_info.grid[1u];
+    least_1 = _e211;
+    let _e212 = a_1;
+    param_17 = (_e212 * 1.5f);
+    let _e214 = spacing_x;
+    param_18 = _e214;
+    let _e215 = least_1;
+    param_19 = _e215;
+    let _e216 = AtLeast_u0028_vf2_u003b_vf2_u003b_f1_u003b((&param_17), (&param_18), (&param_19));
+    a_1 = _e216;
+    let _e217 = b;
+    param_20 = (_e217 * 1.5f);
+    let _e219 = spacing_y;
+    param_21 = _e219;
+    let _e220 = least_1;
+    param_22 = _e220;
+    let _e221 = AtLeast_u0028_vf2_u003b_vf2_u003b_f1_u003b((&param_20), (&param_21), (&param_22));
+    b = _e221;
+    let _e223 = a_1[0u];
+    let _e225 = b[1u];
+    let _e228 = a_1[1u];
+    let _e230 = b[0u];
+    let _e234 = least_1;
+    let _e235 = least_1;
+    area = max(abs(((_e223 * _e225) - (_e228 * _e230))), (_e234 * _e235));
+    let _e238 = here;
+    let _e241 = corner_1[0u];
+    let _e242 = a_1;
+    let _e246 = corner_1[1u];
+    let _e247 = b;
+    let _e249 = ((_e238.xy + (_e242 * _e241)) + (_e247 * _e246));
+    unnamed.gl_Position = vec4<f32>(_e249.x, _e249.y, 0.5f, 1f);
+    let _e256 = caustic_info.grid[2u];
+    let _e259 = caustic_info.grid[3u];
+    share = (_e256 * _e259);
+    let _e261 = energy_1;
+    let _e262 = share;
+    let _e264 = area;
+    let _e267 = ((_e261 * _e262) / vec3((1.0471976f * _e264)));
+    v_color = vec4<f32>(_e267.x, _e267.y, _e267.z, 0f);
     return;
 }
 
@@ -6532,10 +6546,10 @@ var metallic_roughness_texture_tex: texture_2d<f32>;
 var metallic_roughness_texture_smp: sampler;
 
 fn ViewDepth_u0028_() -> f32 {
-    let _e186 = v_world_position_1;
-    let _e188 = fog_info.eye;
-    let _e192 = fog_info.forward;
-    return dot((_e186 - _e188.xyz), _e192.xyz);
+    let _e187 = v_world_position_1;
+    let _e189 = fog_info.eye;
+    let _e193 = fog_info.forward;
+    return dot((_e187 - _e189.xyz), _e193.xyz);
 }
 
 fn WeightedBlendedWeight_u0028_f1_u003b(alpha: ptr<function, f32>) -> f32 {
@@ -6544,22 +6558,22 @@ fn WeightedBlendedWeight_u0028_f1_u003b(alpha: ptr<function, f32>) -> f32 {
     var far: f32;
     var far3_: f32;
 
-    let _e191 = ViewDepth_u0028_();
-    z = abs(_e191);
-    let _e193 = z;
-    near = (_e193 / 5f);
-    let _e195 = z;
-    far = (_e195 / 200f);
-    let _e197 = far;
+    let _e192 = ViewDepth_u0028_();
+    z = abs(_e192);
+    let _e194 = z;
+    near = (_e194 / 5f);
+    let _e196 = z;
+    far = (_e196 / 200f);
     let _e198 = far;
-    let _e200 = far;
-    far3_ = ((_e197 * _e198) * _e200);
-    let _e202 = (*alpha);
-    let _e203 = near;
+    let _e199 = far;
+    let _e201 = far;
+    far3_ = ((_e198 * _e199) * _e201);
+    let _e203 = (*alpha);
     let _e204 = near;
-    let _e207 = far3_;
+    let _e205 = near;
     let _e208 = far3_;
-    return (_e202 * clamp((10f / ((0.00001f + (_e203 * _e204)) + (_e207 * _e208))), 0.01f, 3000f));
+    let _e209 = far3_;
+    return (_e203 * clamp((10f / ((0.00001f + (_e204 * _e205)) + (_e208 * _e209))), 0.01f, 3000f));
 }
 
 fn WriteWeightedBlended_u0028_() {
@@ -6571,39 +6585,39 @@ fn WriteWeightedBlended_u0028_() {
     var revealage: bool;
     var local: vec4<f32>;
 
-    let _e195 = fog_info.forward[3u];
-    mode = _e195;
-    let _e196 = mode;
-    if (_e196 > 0.5f) {
-        let _e199 = frag_color[3u];
-        alpha_1 = _e199;
-        let _e200 = alpha_1;
-        param = _e200;
-        let _e201 = WeightedBlendedWeight_u0028_f1_u003b((&param));
-        weight = _e201;
-        let _e202 = frag_color;
-        let _e204 = weight;
-        let _e205 = (_e202.xyz * _e204);
-        let _e206 = alpha_1;
-        let _e207 = weight;
-        accumulate = vec4<f32>(_e205.x, _e205.y, _e205.z, (_e206 * _e207));
-        let _e213 = mode;
-        let _e215 = mode;
-        revealage = ((_e213 > 1.5f) && (_e215 < 2.5f));
-        let _e218 = revealage;
-        if _e218 {
-            let _e219 = alpha_1;
-            local = vec4(_e219);
+    let _e196 = fog_info.forward[3u];
+    mode = _e196;
+    let _e197 = mode;
+    if (_e197 > 0.5f) {
+        let _e200 = frag_color[3u];
+        alpha_1 = _e200;
+        let _e201 = alpha_1;
+        param = _e201;
+        let _e202 = WeightedBlendedWeight_u0028_f1_u003b((&param));
+        weight = _e202;
+        let _e203 = frag_color;
+        let _e205 = weight;
+        let _e206 = (_e203.xyz * _e205);
+        let _e207 = alpha_1;
+        let _e208 = weight;
+        accumulate = vec4<f32>(_e206.x, _e206.y, _e206.z, (_e207 * _e208));
+        let _e214 = mode;
+        let _e216 = mode;
+        revealage = ((_e214 > 1.5f) && (_e216 < 2.5f));
+        let _e219 = revealage;
+        if _e219 {
+            let _e220 = alpha_1;
+            local = vec4(_e220);
         } else {
-            let _e221 = accumulate;
-            local = _e221;
+            let _e222 = accumulate;
+            local = _e222;
         }
-        let _e222 = local;
-        frag_color = _e222;
-        let _e223 = mode;
-        if (_e223 > 2.5f) {
-            let _e225 = alpha_1;
-            frag_surface = vec4(_e225);
+        let _e223 = local;
+        frag_color = _e223;
+        let _e224 = mode;
+        if (_e224 > 2.5f) {
+            let _e226 = alpha_1;
+            frag_surface = vec4(_e226);
         }
     }
     return;
@@ -6612,29 +6626,29 @@ fn WriteWeightedBlended_u0028_() {
 fn EncodeOctahedral_u0028_vf3_u003b(n: ptr<function, vec3<f32>>) -> vec2<f32> {
     var e: vec2<f32>;
 
-    let _e189 = (*n)[0u];
-    let _e192 = (*n)[1u];
-    let _e196 = (*n)[2u];
-    let _e199 = (*n);
-    (*n) = (_e199 / vec3(((abs(_e189) + abs(_e192)) + abs(_e196))));
-    let _e202 = (*n);
-    e = _e202.xy;
-    let _e205 = (*n)[2u];
-    if (_e205 < 0f) {
-        let _e207 = (*n);
-        let _e213 = (*n)[0u];
-        let _e217 = (*n)[1u];
-        e = ((vec2(1f) - abs(_e207.yx)) * vec2<f32>(select(-1f, 1f, (_e213 >= 0f)), select(-1f, 1f, (_e217 >= 0f))));
+    let _e190 = (*n)[0u];
+    let _e193 = (*n)[1u];
+    let _e197 = (*n)[2u];
+    let _e200 = (*n);
+    (*n) = (_e200 / vec3(((abs(_e190) + abs(_e193)) + abs(_e197))));
+    let _e203 = (*n);
+    e = _e203.xy;
+    let _e206 = (*n)[2u];
+    if (_e206 < 0f) {
+        let _e208 = (*n);
+        let _e214 = (*n)[0u];
+        let _e218 = (*n)[1u];
+        e = ((vec2(1f) - abs(_e208.yx)) * vec2<f32>(select(-1f, 1f, (_e214 >= 0f)), select(-1f, 1f, (_e218 >= 0f))));
     }
-    let _e222 = e;
-    return ((_e222 * 0.5f) + vec2(0.5f));
+    let _e223 = e;
+    return ((_e223 * 0.5f) + vec2(0.5f));
 }
 
 fn LinearToSrgb_u0028_vf3_u003b(linear: ptr<function, vec3<f32>>) -> vec3<f32> {
-    let _e187 = (*linear);
-    let _e189 = (*linear);
-    let _e193 = (*linear);
-    return mix((_e187 * 12.92f), ((pow(_e189, vec3<f32>(0.41666666f, 0.41666666f, 0.41666666f)) * 1.055f) - vec3<f32>(0.055f, 0.055f, 0.055f)), step(vec3<f32>(0.0031308f, 0.0031308f, 0.0031308f), _e193));
+    let _e188 = (*linear);
+    let _e190 = (*linear);
+    let _e194 = (*linear);
+    return mix((_e188 * 12.92f), ((pow(_e190, vec3<f32>(0.41666666f, 0.41666666f, 0.41666666f)) * 1.055f) - vec3<f32>(0.055f, 0.055f, 0.055f)), step(vec3<f32>(0.0031308f, 0.0031308f, 0.0031308f), _e194));
 }
 
 fn WriteSurfaceGeometry_u0028_f1_u003b(roughness: ptr<function, f32>) {
@@ -6642,52 +6656,52 @@ fn WriteSurfaceGeometry_u0028_f1_u003b(roughness: ptr<function, f32>) {
     var geometric: vec3<f32>;
     var param_2: vec3<f32>;
 
-    let _e190 = g_albedo;
-    param_1 = clamp(_e190, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
-    let _e192 = LinearToSrgb_u0028_vf3_u003b((&param_1));
-    frag_albedo = vec4<f32>(_e192.x, _e192.y, _e192.z, 1f);
-    let _e197 = g_debug_surface_on;
-    if _e197 {
-        let _e198 = g_debug_surface;
-        let _e199 = ViewDepth_u0028_();
-        frag_surface = vec4<f32>(_e198.x, _e198.y, _e198.z, _e199);
+    let _e191 = g_albedo;
+    param_1 = clamp(_e191, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
+    let _e193 = LinearToSrgb_u0028_vf3_u003b((&param_1));
+    frag_albedo = vec4<f32>(_e193.x, _e193.y, _e193.z, 1f);
+    let _e198 = g_debug_surface_on;
+    if _e198 {
+        let _e199 = g_debug_surface;
+        let _e200 = ViewDepth_u0028_();
+        frag_surface = vec4<f32>(_e199.x, _e199.y, _e199.z, _e200);
         return;
     }
-    let _e204 = v_normal_1;
-    geometric = normalize(_e204);
-    let _e206 = gl_FrontFacing_1;
-    if !(_e206) {
-        let _e208 = geometric;
-        geometric = -(_e208);
-    }
-    let _e210 = geometric;
-    param_2 = _e210;
-    let _e211 = EncodeOctahedral_u0028_vf3_u003b((&param_2));
-    let _e212 = (*roughness);
-    let _e214 = ViewDepth_u0028_();
-    frag_surface = vec4<f32>(_e211.x, _e211.y, clamp(_e212, 0f, 1f), _e214);
+    let _e205 = v_normal_1;
+    geometric = normalize(_e205);
+    let _e207 = gl_FrontFacing_1;
+    if !(_e207) {
+        let _e209 = geometric;
+        geometric = -(_e209);
+    }
+    let _e211 = geometric;
+    param_2 = _e211;
+    let _e212 = EncodeOctahedral_u0028_vf3_u003b((&param_2));
+    let _e213 = (*roughness);
+    let _e215 = ViewDepth_u0028_();
+    frag_surface = vec4<f32>(_e212.x, _e212.y, clamp(_e213, 0f, 1f), _e215);
     return;
 }
 
 fn Orthographic_u0028_() -> bool {
-    let _e188 = fog_info.projection[0u];
-    return (_e188 > 0.5f);
+    let _e189 = fog_info.projection[0u];
+    return (_e189 > 0.5f);
 }
 
 fn EyeDistance_u0028_() -> f32 {
     var local_1: f32;
 
-    let _e187 = Orthographic_u0028_();
-    if _e187 {
-        let _e188 = ViewDepth_u0028_();
-        local_1 = max(_e188, 0f);
+    let _e188 = Orthographic_u0028_();
+    if _e188 {
+        let _e189 = ViewDepth_u0028_();
+        local_1 = max(_e189, 0f);
     } else {
-        let _e190 = v_world_position_1;
-        let _e192 = fog_info.eye;
-        local_1 = distance(_e190, _e192.xyz);
+        let _e191 = v_world_position_1;
+        let _e193 = fog_info.eye;
+        local_1 = distance(_e191, _e193.xyz);
     }
-    let _e195 = local_1;
-    return _e195;
+    let _e196 = local_1;
+    return _e196;
 }
 
 fn ApplyFog_u0028_vf3_u003b(color: ptr<function, vec3<f32>>) -> vec3<f32> {
@@ -6697,41 +6711,41 @@ fn ApplyFog_u0028_vf3_u003b(color: ptr<function, vec3<f32>>) -> vec3<f32> {
     var k: f32;
     var local_2: f32;
 
-    let _e194 = fog_info.fog[3u];
-    density = _e194;
-    let _e195 = density;
-    if (_e195 <= 0f) {
-        let _e197 = (*color);
-        return _e197;
-    }
-    let _e198 = EyeDistance_u0028_();
-    d = _e198;
-    let _e201 = fog_info.eye[3u];
-    falloff = _e201;
-    let _e202 = falloff;
-    if (_e202 > 0f) {
-        let _e204 = falloff;
-        let _e206 = v_world_position_1[1u];
-        let _e209 = fog_info.eye[1u];
-        k = (_e204 * (_e206 - _e209));
-        let _e212 = k;
-        if (abs(_e212) > 0.001f) {
-            let _e215 = k;
-            let _e219 = k;
-            local_2 = ((1f - exp(-(_e215))) / _e219);
+    let _e195 = fog_info.fog[3u];
+    density = _e195;
+    let _e196 = density;
+    if (_e196 <= 0f) {
+        let _e198 = (*color);
+        return _e198;
+    }
+    let _e199 = EyeDistance_u0028_();
+    d = _e199;
+    let _e202 = fog_info.eye[3u];
+    falloff = _e202;
+    let _e203 = falloff;
+    if (_e203 > 0f) {
+        let _e205 = falloff;
+        let _e207 = v_world_position_1[1u];
+        let _e210 = fog_info.eye[1u];
+        k = (_e205 * (_e207 - _e210));
+        let _e213 = k;
+        if (abs(_e213) > 0.001f) {
+            let _e216 = k;
+            let _e220 = k;
+            local_2 = ((1f - exp(-(_e216))) / _e220);
         } else {
-            let _e221 = k;
-            local_2 = (1f - (0.5f * _e221));
+            let _e222 = k;
+            local_2 = (1f - (0.5f * _e222));
         }
-        let _e224 = local_2;
-        let _e225 = density;
-        density = (_e225 * _e224);
+        let _e225 = local_2;
+        let _e226 = density;
+        density = (_e226 * _e225);
     }
-    let _e228 = fog_info.fog;
-    let _e230 = (*color);
-    let _e231 = density;
-    let _e233 = d;
-    return mix(_e228.xyz, _e230, vec3(clamp(exp((-(_e231) * _e233)), 0f, 1f)));
+    let _e229 = fog_info.fog;
+    let _e231 = (*color);
+    let _e232 = density;
+    let _e234 = d;
+    return mix(_e229.xyz, _e231, vec3(clamp(exp((-(_e232) * _e234)), 0f, 1f)));
 }
 
 fn WriteSurface_u0028_vf3_u003b_f1_u003b_f1_u003b(linearColor: ptr<function, vec3<f32>>, alpha_2: ptr<function, f32>, roughness_1: ptr<function, f32>) {
@@ -6739,44 +6753,44 @@ fn WriteSurface_u0028_vf3_u003b_f1_u003b_f1_u003b(linearColor: ptr<function, vec
     var param_3: vec3<f32>;
     var param_4: f32;
 
-    let _e192 = g_premultiply;
-    let _e193 = (*alpha_2);
-    weight_1 = select(1f, _e193, _e192);
-    let _e195 = (*linearColor);
-    param_3 = _e195;
-    let _e196 = ApplyFog_u0028_vf3_u003b((&param_3));
-    let _e197 = weight_1;
-    let _e198 = (_e196 * _e197);
-    let _e199 = (*alpha_2);
-    let _e200 = g_pass_through;
-    frag_color = vec4<f32>(_e198.x, _e198.y, _e198.z, (_e199 * (1f - _e200)));
-    let _e207 = (*roughness_1);
-    param_4 = _e207;
+    let _e193 = g_premultiply;
+    let _e194 = (*alpha_2);
+    weight_1 = select(1f, _e194, _e193);
+    let _e196 = (*linearColor);
+    param_3 = _e196;
+    let _e197 = ApplyFog_u0028_vf3_u003b((&param_3));
+    let _e198 = weight_1;
+    let _e199 = (_e197 * _e198);
+    let _e200 = (*alpha_2);
+    let _e201 = g_pass_through;
+    frag_color = vec4<f32>(_e199.x, _e199.y, _e199.z, (_e200 * (1f - _e201)));
+    let _e208 = (*roughness_1);
+    param_4 = _e208;
     WriteSurfaceGeometry_u0028_f1_u003b((&param_4));
     WriteWeightedBlended_u0028_();
     return;
 }
 
 fn SrgbToLinear_u0028_vf3_u003b(srgb: ptr<function, vec3<f32>>) -> vec3<f32> {
-    let _e187 = (*srgb);
-    let _e190 = (*srgb);
-    let _e195 = (*srgb);
-    return mix((_e187 / vec3(12.92f)), pow(((_e190 + vec3<f32>(0.055f, 0.055f, 0.055f)) / vec3(1.055f)), vec3<f32>(2.4f, 2.4f, 2.4f)), step(vec3<f32>(0.04045f, 0.04045f, 0.04045f), _e195));
+    let _e188 = (*srgb);
+    let _e191 = (*srgb);
+    let _e196 = (*srgb);
+    return mix((_e188 / vec3(12.92f)), pow(((_e191 + vec3<f32>(0.055f, 0.055f, 0.055f)) / vec3(1.055f)), vec3<f32>(2.4f, 2.4f, 2.4f)), step(vec3<f32>(0.04045f, 0.04045f, 0.04045f), _e196));
 }
 
 fn NonFinite_u0028_vf3_u003b(c: ptr<function, vec3<f32>>) -> bool {
     var phi_2559_: bool;
 
-    let _e187 = (*c);
     let _e188 = (*c);
-    let _e190 = any((_e187 != _e188));
-    phi_2559_ = _e190;
-    if !(_e190) {
-        let _e192 = (*c);
-        phi_2559_ = any((abs(_e192) > vec3<f32>(300000000000000000000000000000000000000f, 300000000000000000000000000000000000000f, 300000000000000000000000000000000000000f)));
+    let _e189 = (*c);
+    let _e191 = any((_e188 != _e189));
+    phi_2559_ = _e191;
+    if !(_e191) {
+        let _e193 = (*c);
+        phi_2559_ = any((abs(_e193) > vec3<f32>(300000000000000000000000000000000000000f, 300000000000000000000000000000000000000f, 300000000000000000000000000000000000000f)));
     }
-    let _e197 = phi_2559_;
-    return _e197;
+    let _e198 = phi_2559_;
+    return _e198;
 }
 
 fn WriteDebugView_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_vf3_u003b(s: ptr<function, Surface>, lit: ptr<function, vec3<f32>>) -> bool {
@@ -6794,78 +6808,78 @@ fn WriteDebugView_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_
     var param_9: vec3<f32>;
     var param_10: f32;
 
-    let _e203 = frag_info.debug_view[0u];
-    view = _e203;
-    let _e204 = view;
-    if (_e204 < 0.5f) {
+    let _e204 = frag_info.debug_view[0u];
+    view = _e204;
+    let _e205 = view;
+    if (_e205 < 0.5f) {
         return false;
     }
-    let _e207 = gl_FragCoord_1[0u];
-    let _e210 = frag_info.debug_view[1u];
-    let _e213 = frag_info.debug_view[2u];
-    if (_e207 < (_e210 * _e213)) {
+    let _e208 = gl_FragCoord_1[0u];
+    let _e211 = frag_info.debug_view[1u];
+    let _e214 = frag_info.debug_view[2u];
+    if (_e208 < (_e211 * _e214)) {
         return false;
     }
-    let _e216 = view;
-    code = i32((_e216 + 0.5f));
+    let _e217 = view;
+    code = i32((_e217 + 0.5f));
     shown = vec3<f32>(0f, 0f, 0f);
-    let _e219 = code;
-    if (_e219 == 1i) {
-        let _e222 = (*s).albedo;
-        param_5 = clamp(_e222, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
-        let _e224 = LinearToSrgb_u0028_vf3_u003b((&param_5));
-        shown = _e224;
-    } else {
-        let _e225 = code;
-        if (_e225 == 2i) {
-            let _e228 = (*s).n;
-            shown = ((_e228 * 0.5f) + vec3<f32>(0.5f, 0.5f, 0.5f));
+    let _e220 = code;
+    if (_e220 == 1i) {
+        let _e223 = (*s).albedo;
+        param_5 = clamp(_e223, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
+        let _e225 = LinearToSrgb_u0028_vf3_u003b((&param_5));
+        shown = _e225;
+    } else {
+        let _e226 = code;
+        if (_e226 == 2i) {
+            let _e229 = (*s).n;
+            shown = ((_e229 * 0.5f) + vec3<f32>(0.5f, 0.5f, 0.5f));
         } else {
-            let _e231 = code;
-            if (_e231 == 3i) {
-                let _e234 = (*s).roughness;
-                shown = vec3(clamp(_e234, 0f, 1f));
+            let _e232 = code;
+            if (_e232 == 3i) {
+                let _e235 = (*s).roughness;
+                shown = vec3(clamp(_e235, 0f, 1f));
             } else {
-                let _e237 = code;
-                if (_e237 == 4i) {
-                    let _e240 = (*s).metallic;
-                    shown = vec3(clamp(_e240, 0f, 1f));
+                let _e238 = code;
+                if (_e238 == 4i) {
+                    let _e241 = (*s).metallic;
+                    shown = vec3(clamp(_e241, 0f, 1f));
                 } else {
-                    let _e243 = code;
-                    if (_e243 == 5i) {
-                        let _e246 = (*s).occlusion;
-                        shown = vec3(clamp(_e246, 0f, 1f));
+                    let _e244 = code;
+                    if (_e244 == 5i) {
+                        let _e247 = (*s).occlusion;
+                        shown = vec3(clamp(_e247, 0f, 1f));
                     } else {
-                        let _e249 = code;
-                        if (_e249 == 6i) {
-                            let _e252 = (*s).emissive;
-                            param_6 = clamp(_e252, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
-                            let _e254 = LinearToSrgb_u0028_vf3_u003b((&param_6));
-                            shown = _e254;
+                        let _e250 = code;
+                        if (_e250 == 6i) {
+                            let _e253 = (*s).emissive;
+                            param_6 = clamp(_e253, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
+                            let _e255 = LinearToSrgb_u0028_vf3_u003b((&param_6));
+                            shown = _e255;
                         } else {
-                            let _e255 = code;
-                            if (_e255 == 7i) {
-                                let _e257 = v_texcoord_1;
-                                let _e258 = fract(_e257);
-                                shown = vec3<f32>(_e258.x, _e258.y, 0f);
+                            let _e256 = code;
+                            if (_e256 == 7i) {
+                                let _e258 = v_texcoord_1;
+                                let _e259 = fract(_e258);
+                                shown = vec3<f32>(_e259.x, _e259.y, 0f);
                             } else {
-                                let _e262 = code;
-                                if (_e262 == 8i) {
-                                    let _e264 = (*lit);
-                                    param_7 = clamp(_e264, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
-                                    let _e266 = LinearToSrgb_u0028_vf3_u003b((&param_7));
-                                    grey = dot(_e266, vec3<f32>(0.2126f, 0.7152f, 0.0722f));
-                                    let _e268 = (*lit);
-                                    param_8 = _e268;
-                                    let _e269 = NonFinite_u0028_vf3_u003b((&param_8));
-                                    if _e269 {
+                                let _e263 = code;
+                                if (_e263 == 8i) {
+                                    let _e265 = (*lit);
+                                    param_7 = clamp(_e265, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
+                                    let _e267 = LinearToSrgb_u0028_vf3_u003b((&param_7));
+                                    grey = dot(_e267, vec3<f32>(0.2126f, 0.7152f, 0.0722f));
+                                    let _e269 = (*lit);
+                                    param_8 = _e269;
+                                    let _e270 = NonFinite_u0028_vf3_u003b((&param_8));
+                                    if _e270 {
                                         local_3 = vec3<f32>(1f, 0f, 1f);
                                     } else {
-                                        let _e270 = grey;
-                                        local_3 = vec3((_e270 * 0.5f));
+                                        let _e271 = grey;
+                                        local_3 = vec3((_e271 * 0.5f));
                                     }
-                                    let _e273 = local_3;
-                                    shown = _e273;
+                                    let _e274 = local_3;
+                                    shown = _e274;
                                 }
                             }
                         }
@@ -6874,61 +6888,61 @@ fn WriteDebugView_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_
             }
         }
     }
-    let _e274 = g_premultiply;
-    if _e274 {
-        let _e276 = (*s).alpha;
-        local_4 = _e276;
+    let _e275 = g_premultiply;
+    if _e275 {
+        let _e277 = (*s).alpha;
+        local_4 = _e277;
     } else {
         local_4 = 1f;
     }
-    let _e277 = local_4;
-    weight_2 = _e277;
-    let _e278 = shown;
-    param_9 = _e278;
-    let _e279 = SrgbToLinear_u0028_vf3_u003b((&param_9));
-    let _e280 = weight_2;
-    let _e281 = (_e279 * _e280);
-    let _e283 = (*s).alpha;
-    frag_color = vec4<f32>(_e281.x, _e281.y, _e281.z, _e283);
-    let _e289 = (*s).roughness;
-    param_10 = _e289;
+    let _e278 = local_4;
+    weight_2 = _e278;
+    let _e279 = shown;
+    param_9 = _e279;
+    let _e280 = SrgbToLinear_u0028_vf3_u003b((&param_9));
+    let _e281 = weight_2;
+    let _e282 = (_e280 * _e281);
+    let _e284 = (*s).alpha;
+    frag_color = vec4<f32>(_e282.x, _e282.y, _e282.z, _e284);
+    let _e290 = (*s).roughness;
+    param_10 = _e290;
     WriteSurfaceGeometry_u0028_f1_u003b((&param_10));
     WriteWeightedBlended_u0028_();
     return true;
 }
 
 fn ShadeLight_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b(s_1: ptr<function, Surface>, light: ptr<function, LightSample>) -> vec3<f32> {
-    let _e189 = (*s_1).albedo;
-    return _e189;
+    let _e190 = (*s_1).albedo;
+    return _e190;
 }
 
 fn PointShadowDiskTap_u0028_i1_u003b(i: ptr<function, i32>) -> vec2<f32> {
-    let _e187 = (*i);
-    if (_e187 == 0i) {
+    let _e188 = (*i);
+    if (_e188 == 0i) {
         return vec2<f32>(-0.94201624f, -0.39906216f);
     }
-    let _e189 = (*i);
-    if (_e189 == 1i) {
+    let _e190 = (*i);
+    if (_e190 == 1i) {
         return vec2<f32>(0.9455861f, -0.76890725f);
     }
-    let _e191 = (*i);
-    if (_e191 == 2i) {
+    let _e192 = (*i);
+    if (_e192 == 2i) {
         return vec2<f32>(-0.0941841f, -0.9293887f);
     }
-    let _e193 = (*i);
-    if (_e193 == 3i) {
+    let _e194 = (*i);
+    if (_e194 == 3i) {
         return vec2<f32>(0.34495938f, 0.2938776f);
     }
-    let _e195 = (*i);
-    if (_e195 == 4i) {
+    let _e196 = (*i);
+    if (_e196 == 4i) {
         return vec2<f32>(-0.9158858f, 0.45771432f);
     }
-    let _e197 = (*i);
-    if (_e197 == 5i) {
+    let _e198 = (*i);
+    if (_e198 == 5i) {
         return vec2<f32>(-0.8154423f, -0.87912464f);
     }
-    let _e199 = (*i);
-    if (_e199 == 6i) {
+    let _e200 = (*i);
+    if (_e200 == 6i) {
         return vec2<f32>(-0.38277543f, 0.27676845f);
     }
     return vec2<f32>(0.974844f, 0.7564838f);
@@ -6938,20 +6952,20 @@ fn PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b(i_1: ptr<function
     var p: vec2<f32>;
     var param_11: i32;
 
-    let _e192 = (*i_1);
-    param_11 = _e192;
-    let _e193 = PointShadowDiskTap_u0028_i1_u003b((&param_11));
-    p = _e193;
-    let _e195 = p[0u];
-    let _e196 = (*ca);
-    let _e199 = p[1u];
-    let _e200 = (*sa);
-    let _e204 = p[0u];
-    let _e205 = (*sa);
-    let _e208 = p[1u];
-    let _e209 = (*ca);
-    let _e213 = (*radius);
-    return (vec2<f32>(((_e195 * _e196) - (_e199 * _e200)), ((_e204 * _e205) + (_e208 * _e209))) * _e213);
+    let _e193 = (*i_1);
+    param_11 = _e193;
+    let _e194 = PointShadowDiskTap_u0028_i1_u003b((&param_11));
+    p = _e194;
+    let _e196 = p[0u];
+    let _e197 = (*ca);
+    let _e200 = p[1u];
+    let _e201 = (*sa);
+    let _e205 = p[0u];
+    let _e206 = (*sa);
+    let _e209 = p[1u];
+    let _e210 = (*ca);
+    let _e214 = (*radius);
+    return (vec2<f32>(((_e196 * _e197) - (_e200 * _e201)), ((_e205 * _e206) + (_e209 * _e210))) * _e214);
 }
 
 fn PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b(uv: ptr<function, vec2<f32>>, offset: ptr<function, vec2<f32>>, tile: ptr<function, vec2<f32>>, range: ptr<function, f32>) -> f32 {
@@ -6959,27 +6973,27 @@ fn PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b(uv: ptr<func
     var local_5: vec2<f32>;
     var atlas: vec2<f32>;
 
-    let _e195 = point_shadow.params[0u];
-    inset = _e195;
-    let _e196 = (*uv);
-    let _e197 = (*offset);
-    let _e199 = inset;
+    let _e196 = point_shadow.params[0u];
+    inset = _e196;
+    let _e197 = (*uv);
+    let _e198 = (*offset);
     let _e200 = inset;
-    local_5 = clamp((_e196 + _e197), vec2(_e199), vec2((1f - _e200)));
-    let _e205 = local_5;
-    let _e206 = (*tile);
-    atlas = ((_e205 + _e206) * vec2<f32>(0.16666667f, 0.16666667f));
-    let _e211 = point_shadow.params3_[0u];
-    if (_e211 > 0.5f) {
-        let _e214 = atlas[1u];
-        atlas[1u] = (1f - _e214);
-    }
-    let _e217 = atlas;
-    let _e218 = textureSampleLevel(point_shadow_texture_tex, point_shadow_texture_smp, _e217, 0f);
-    let _e220 = atlas;
-    let _e221 = textureSampleLevel(point_shadow_static_texture_tex, point_shadow_static_texture_smp, _e220, 0f);
-    let _e224 = (*range);
-    return (min(_e218.x, _e221.x) * _e224);
+    let _e201 = inset;
+    local_5 = clamp((_e197 + _e198), vec2(_e200), vec2((1f - _e201)));
+    let _e206 = local_5;
+    let _e207 = (*tile);
+    atlas = ((_e206 + _e207) * vec2<f32>(0.16666667f, 0.16666667f));
+    let _e212 = point_shadow.params3_[0u];
+    if (_e212 > 0.5f) {
+        let _e215 = atlas[1u];
+        atlas[1u] = (1f - _e215);
+    }
+    let _e218 = atlas;
+    let _e219 = textureSampleLevel(point_shadow_texture_tex, point_shadow_texture_smp, _e218, 0f);
+    let _e221 = atlas;
+    let _e222 = textureSampleLevel(point_shadow_static_texture_tex, point_shadow_static_texture_smp, _e221, 0f);
+    let _e225 = (*range);
+    return (min(_e219.x, _e222.x) * _e225);
 }
 
 fn PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b(uv_1: ptr<function, vec2<f32>>, offset_1: ptr<function, vec2<f32>>, tile_1: ptr<function, vec2<f32>>, range_1: ptr<function, f32>, receiver: ptr<function, f32>) -> f32 {
@@ -6989,24 +7003,24 @@ fn PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b(uv_1: pt
     var param_14: vec2<f32>;
     var param_15: f32;
 
-    let _e196 = (*uv_1);
-    param_12 = _e196;
-    let _e197 = (*offset_1);
-    param_13 = _e197;
-    let _e198 = (*tile_1);
-    param_14 = _e198;
-    let _e199 = (*range_1);
-    param_15 = _e199;
-    let _e200 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((&param_12), (&param_13), (&param_14), (&param_15));
-    stored = _e200;
-    let _e201 = stored;
-    let _e202 = (*range_1);
-    if (_e201 >= (_e202 * 0.999f)) {
+    let _e197 = (*uv_1);
+    param_12 = _e197;
+    let _e198 = (*offset_1);
+    param_13 = _e198;
+    let _e199 = (*tile_1);
+    param_14 = _e199;
+    let _e200 = (*range_1);
+    param_15 = _e200;
+    let _e201 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((&param_12), (&param_13), (&param_14), (&param_15));
+    stored = _e201;
+    let _e202 = stored;
+    let _e203 = (*range_1);
+    if (_e202 >= (_e203 * 0.999f)) {
         return 1f;
     }
-    let _e205 = (*receiver);
-    let _e206 = stored;
-    return select(1f, 0f, (_e205 > _e206));
+    let _e206 = (*receiver);
+    let _e207 = stored;
+    return select(1f, 0f, (_e206 > _e207));
 }
 
 fn PointShadowPenumbra_u0028_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b(uv_2: ptr<function, vec2<f32>>, tile_2: ptr<function, vec2<f32>>, range_2: ptr<function, f32>, receiver_1: ptr<function, f32>, ca_1: ptr<function, f32>, sa_1: ptr<function, f32>, tanHalf: ptr<function, f32>, blockerOut: ptr<function, f32>) -> f32 {
@@ -7033,111 +7047,111 @@ fn PointShadowPenumbra_u0028_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u
     var world: f32;
 
     (*blockerOut) = -1f;
-    let _e217 = point_shadow.params2_[1u];
-    lightRadius = _e217;
-    let _e220 = point_shadow.params2_[0u];
-    minRadius = _e220;
-    let _e223 = point_shadow.params2_[2u];
-    maxRadius = _e223;
-    let _e224 = lightRadius;
-    if (_e224 <= 0f) {
-        let _e226 = (*uv_2);
-        param_16 = _e226;
+    let _e218 = point_shadow.params2_[1u];
+    lightRadius = _e218;
+    let _e221 = point_shadow.params2_[0u];
+    minRadius = _e221;
+    let _e224 = point_shadow.params2_[2u];
+    maxRadius = _e224;
+    let _e225 = lightRadius;
+    if (_e225 <= 0f) {
+        let _e227 = (*uv_2);
+        param_16 = _e227;
         param_17 = vec2<f32>(0f, 0f);
-        let _e227 = (*tile_2);
-        param_18 = _e227;
-        let _e228 = (*range_2);
-        param_19 = _e228;
-        let _e229 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((&param_16), (&param_17), (&param_18), (&param_19));
-        (*blockerOut) = _e229;
-        let _e230 = minRadius;
-        return _e230;
+        let _e228 = (*tile_2);
+        param_18 = _e228;
+        let _e229 = (*range_2);
+        param_19 = _e229;
+        let _e230 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((&param_16), (&param_17), (&param_18), (&param_19));
+        (*blockerOut) = _e230;
+        let _e231 = minRadius;
+        return _e231;
     }
     sum = 0f;
     count = 0f;
     i_2 = 0i;
     loop {
-        let _e231 = i_2;
-        if (_e231 < 8i) {
-            let _e233 = i_2;
-            param_20 = _e233;
-            let _e234 = (*ca_1);
-            param_21 = _e234;
-            let _e235 = (*sa_1);
-            param_22 = _e235;
-            let _e236 = maxRadius;
-            param_23 = _e236;
-            let _e237 = PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b((&param_20), (&param_21), (&param_22), (&param_23));
-            let _e238 = (*uv_2);
-            param_24 = _e238;
-            param_25 = _e237;
-            let _e239 = (*tile_2);
-            param_26 = _e239;
-            let _e240 = (*range_2);
-            param_27 = _e240;
-            let _e241 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((&param_24), (&param_25), (&param_26), (&param_27));
-            stored_1 = _e241;
-            let _e242 = stored_1;
-            let _e243 = (*range_2);
-            if (_e242 >= (_e243 * 0.999f)) {
+        let _e232 = i_2;
+        if (_e232 < 8i) {
+            let _e234 = i_2;
+            param_20 = _e234;
+            let _e235 = (*ca_1);
+            param_21 = _e235;
+            let _e236 = (*sa_1);
+            param_22 = _e236;
+            let _e237 = maxRadius;
+            param_23 = _e237;
+            let _e238 = PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b((&param_20), (&param_21), (&param_22), (&param_23));
+            let _e239 = (*uv_2);
+            param_24 = _e239;
+            param_25 = _e238;
+            let _e240 = (*tile_2);
+            param_26 = _e240;
+            let _e241 = (*range_2);
+            param_27 = _e241;
+            let _e242 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((&param_24), (&param_25), (&param_26), (&param_27));
+            stored_1 = _e242;
+            let _e243 = stored_1;
+            let _e244 = (*range_2);
+            if (_e243 >= (_e244 * 0.999f)) {
                 continue;
             }
-            let _e246 = stored_1;
-            let _e247 = (*receiver_1);
-            if (_e246 >= _e247) {
+            let _e247 = stored_1;
+            let _e248 = (*receiver_1);
+            if (_e247 >= _e248) {
                 continue;
             }
-            let _e249 = stored_1;
-            let _e250 = sum;
-            sum = (_e250 + _e249);
-            let _e252 = count;
-            count = (_e252 + 1f);
+            let _e250 = stored_1;
+            let _e251 = sum;
+            sum = (_e251 + _e250);
+            let _e253 = count;
+            count = (_e253 + 1f);
             continue;
         } else {
             break;
         }
         continuing {
-            let _e254 = i_2;
-            i_2 = (_e254 + 1i);
+            let _e255 = i_2;
+            i_2 = (_e255 + 1i);
         }
     }
-    let _e256 = count;
-    if (_e256 < 0.5f) {
+    let _e257 = count;
+    if (_e257 < 0.5f) {
         return -1f;
     }
-    let _e258 = sum;
-    let _e259 = count;
-    blocker = max((_e258 / _e259), 0.0001f);
-    let _e262 = blocker;
-    (*blockerOut) = _e262;
-    let _e263 = lightRadius;
-    let _e264 = (*receiver_1);
-    let _e265 = blocker;
-    let _e269 = blocker;
-    world = ((_e263 * max((_e264 - _e265), 0f)) / _e269);
-    let _e271 = world;
-    let _e272 = (*receiver_1);
-    let _e274 = (*tanHalf);
-    let _e277 = minRadius;
-    let _e278 = maxRadius;
-    return clamp((_e271 / ((2f * _e272) * _e274)), _e277, _e278);
+    let _e259 = sum;
+    let _e260 = count;
+    blocker = max((_e259 / _e260), 0.0001f);
+    let _e263 = blocker;
+    (*blockerOut) = _e263;
+    let _e264 = lightRadius;
+    let _e265 = (*receiver_1);
+    let _e266 = blocker;
+    let _e270 = blocker;
+    world = ((_e264 * max((_e265 - _e266), 0f)) / _e270);
+    let _e272 = world;
+    let _e273 = (*receiver_1);
+    let _e275 = (*tanHalf);
+    let _e278 = minRadius;
+    let _e279 = maxRadius;
+    return clamp((_e272 / ((2f * _e273) * _e275)), _e278, _e279);
 }
 
 fn FragCoordFromTop_u0028_f1_u003b(rows: ptr<function, f32>) -> vec2<f32> {
     var local_6: vec2<f32>;
 
-    let _e188 = (*rows);
-    if (_e188 > 0f) {
-        let _e191 = gl_FragCoord_1[0u];
-        let _e192 = (*rows);
-        let _e194 = gl_FragCoord_1[1u];
-        local_6 = vec2<f32>(_e191, (_e192 - _e194));
+    let _e189 = (*rows);
+    if (_e189 > 0f) {
+        let _e192 = gl_FragCoord_1[0u];
+        let _e193 = (*rows);
+        let _e195 = gl_FragCoord_1[1u];
+        local_6 = vec2<f32>(_e192, (_e193 - _e195));
     } else {
-        let _e197 = gl_FragCoord_1;
-        local_6 = _e197.xy;
+        let _e198 = gl_FragCoord_1;
+        local_6 = _e198.xy;
     }
-    let _e199 = local_6;
-    return _e199;
+    let _e200 = local_6;
+    return _e200;
 }
 
 fn PointShadowFactor_u0028_vf3_u003b_vf3_u003b_i1_u003b(world_1: ptr<function, vec3<f32>>, normal: ptr<function, vec3<f32>>, lightIndex: ptr<function, i32>) -> f32 {
@@ -7195,257 +7209,257 @@ fn PointShadowFactor_u0028_vf3_u003b_vf3_u003b_i1_u003b(world_1: ptr<function, v
     var phi_2246_: bool;
     var phi_2307_: bool;
 
-    let _e240 = (*lightIndex);
-    let _e244 = point_shadow.slots[_e240][0u];
-    slot = i32((_e244 + 0.5f));
-    let _e247 = (*lightIndex);
-    let _e251 = point_shadow.slots[_e247][0u];
-    if (_e251 < 0f) {
+    let _e241 = (*lightIndex);
+    let _e245 = point_shadow.slots[_e241][0u];
+    slot = i32((_e245 + 0.5f));
+    let _e248 = (*lightIndex);
+    let _e252 = point_shadow.slots[_e248][0u];
+    if (_e252 < 0f) {
         return 1f;
     }
-    let _e255 = point_shadow.params[2u];
-    strength = _e255;
-    let _e256 = strength;
-    if (_e256 <= 0f) {
+    let _e256 = point_shadow.params[2u];
+    strength = _e256;
+    let _e257 = strength;
+    if (_e257 <= 0f) {
         return 1f;
     }
-    let _e258 = slot;
-    let _e261 = point_shadow.lights[_e258];
-    let _e263 = (*world_1);
-    toLight = (_e261.xyz - _e263);
-    let _e265 = toLight;
-    toLightLength = max(length(_e265), 0.000001f);
-    let _e268 = (*normal);
-    let _e269 = toLight;
-    let _e270 = toLightLength;
-    nDotL = max(dot(_e268, (_e269 / vec3(_e270))), 0.15f);
-    let _e275 = nDotL;
+    let _e259 = slot;
+    let _e262 = point_shadow.lights[_e259];
+    let _e264 = (*world_1);
+    toLight = (_e262.xyz - _e264);
+    let _e266 = toLight;
+    toLightLength = max(length(_e266), 0.000001f);
+    let _e269 = (*normal);
+    let _e270 = toLight;
+    let _e271 = toLightLength;
+    nDotL = max(dot(_e269, (_e270 / vec3(_e271))), 0.15f);
     let _e276 = nDotL;
-    let _e281 = nDotL;
+    let _e277 = nDotL;
     let _e282 = nDotL;
-    slope = min((sqrt(max((1f - (_e275 * _e276)), 0f)) / (_e281 * _e282)), 8f);
-    let _e286 = toLightLength;
-    let _e288 = (*lightIndex);
-    let _e292 = point_shadow.slots[_e288][2u];
-    let _e297 = point_shadow.params3_[1u];
-    texel = (((2f * _e286) * max(_e292, 0.0001f)) * _e297);
-    let _e299 = (*world_1);
-    let _e300 = (*normal);
-    let _e301 = texel;
-    let _e305 = point_shadow.params[3u];
-    let _e307 = slope;
-    origin = (_e299 + (((_e300 * _e301) * _e305) * (1f + _e307)));
-    let _e311 = origin;
-    let _e312 = slot;
-    let _e315 = point_shadow.lights[_e312];
-    toFragment = (_e311 - _e315.xyz);
-    let _e318 = toFragment;
-    distance_ = length(_e318);
-    let _e320 = slot;
-    let _e324 = point_shadow.lights[_e320][3u];
-    range_3 = max(_e324, 0.0001f);
-    let _e326 = distance_;
-    let _e327 = range_3;
-    if (_e326 >= _e327) {
+    let _e283 = nDotL;
+    slope = min((sqrt(max((1f - (_e276 * _e277)), 0f)) / (_e282 * _e283)), 8f);
+    let _e287 = toLightLength;
+    let _e289 = (*lightIndex);
+    let _e293 = point_shadow.slots[_e289][2u];
+    let _e298 = point_shadow.params3_[1u];
+    texel = (((2f * _e287) * max(_e293, 0.0001f)) * _e298);
+    let _e300 = (*world_1);
+    let _e301 = (*normal);
+    let _e302 = texel;
+    let _e306 = point_shadow.params[3u];
+    let _e308 = slope;
+    origin = (_e300 + (((_e301 * _e302) * _e306) * (1f + _e308)));
+    let _e312 = origin;
+    let _e313 = slot;
+    let _e316 = point_shadow.lights[_e313];
+    toFragment = (_e312 - _e316.xyz);
+    let _e319 = toFragment;
+    distance_ = length(_e319);
+    let _e321 = slot;
+    let _e325 = point_shadow.lights[_e321][3u];
+    range_3 = max(_e325, 0.0001f);
+    let _e327 = distance_;
+    let _e328 = range_3;
+    if (_e327 >= _e328) {
         return 1f;
     }
     face = 0i;
-    let _e329 = (*lightIndex);
-    let _e333 = point_shadow.slots[_e329][1u];
-    if (_e333 < 0.5f) {
-        let _e335 = toFragment;
-        a = abs(_e335);
-        let _e338 = a[0u];
-        let _e340 = a[1u];
-        let _e341 = (_e338 >= _e340);
-        phi_2246_ = _e341;
-        if _e341 {
-            let _e343 = a[0u];
-            let _e345 = a[2u];
-            phi_2246_ = (_e343 >= _e345);
-        }
-        let _e348 = phi_2246_;
-        if _e348 {
-            let _e350 = toFragment[0u];
-            face = select(1i, 0i, (_e350 > 0f));
+    let _e330 = (*lightIndex);
+    let _e334 = point_shadow.slots[_e330][1u];
+    if (_e334 < 0.5f) {
+        let _e336 = toFragment;
+        a = abs(_e336);
+        let _e339 = a[0u];
+        let _e341 = a[1u];
+        let _e342 = (_e339 >= _e341);
+        phi_2246_ = _e342;
+        if _e342 {
+            let _e344 = a[0u];
+            let _e346 = a[2u];
+            phi_2246_ = (_e344 >= _e346);
+        }
+        let _e349 = phi_2246_;
+        if _e349 {
+            let _e351 = toFragment[0u];
+            face = select(1i, 0i, (_e351 > 0f));
         } else {
-            let _e354 = a[1u];
-            let _e356 = a[2u];
-            if (_e354 >= _e356) {
-                let _e359 = toFragment[1u];
-                face = select(3i, 2i, (_e359 > 0f));
+            let _e355 = a[1u];
+            let _e357 = a[2u];
+            if (_e355 >= _e357) {
+                let _e360 = toFragment[1u];
+                face = select(3i, 2i, (_e360 > 0f));
             } else {
-                let _e363 = toFragment[2u];
-                face = select(5i, 4i, (_e363 > 0f));
+                let _e364 = toFragment[2u];
+                face = select(5i, 4i, (_e364 > 0f));
             }
         }
     }
-    let _e366 = slot;
-    let _e368 = face;
-    let _e372 = point_shadow.faces[((_e366 * 6i) + _e368)];
-    let _e373 = origin;
-    clip = (_e372 * vec4<f32>(_e373.x, _e373.y, _e373.z, 1f));
-    let _e380 = clip[3u];
-    if (_e380 <= 0f) {
+    let _e367 = slot;
+    let _e369 = face;
+    let _e373 = point_shadow.faces[((_e367 * 6i) + _e369)];
+    let _e374 = origin;
+    clip = (_e373 * vec4<f32>(_e374.x, _e374.y, _e374.z, 1f));
+    let _e381 = clip[3u];
+    if (_e381 <= 0f) {
         return 1f;
     }
-    let _e382 = clip;
-    let _e385 = clip[3u];
-    ndc = (_e382.xy / vec2(_e385));
-    let _e389 = ndc[0u];
-    let _e391 = (abs(_e389) > 1f);
-    phi_2307_ = _e391;
-    if !(_e391) {
-        let _e394 = ndc[1u];
-        phi_2307_ = (abs(_e394) > 1f);
-    }
-    let _e398 = phi_2307_;
-    if _e398 {
+    let _e383 = clip;
+    let _e386 = clip[3u];
+    ndc = (_e383.xy / vec2(_e386));
+    let _e390 = ndc[0u];
+    let _e392 = (abs(_e390) > 1f);
+    phi_2307_ = _e392;
+    if !(_e392) {
+        let _e395 = ndc[1u];
+        phi_2307_ = (abs(_e395) > 1f);
+    }
+    let _e399 = phi_2307_;
+    if _e399 {
         return 1f;
     }
-    let _e400 = ndc[0u];
-    let _e404 = ndc[1u];
-    uv_3 = vec2<f32>(((_e400 * 0.5f) + 0.5f), (0.5f - (_e404 * 0.5f)));
-    let _e408 = face;
-    let _e410 = slot;
-    tile_3 = vec2<f32>(f32(_e408), f32(_e410));
-    let _e413 = distance_;
-    let _e416 = point_shadow.params[1u];
-    receiver_2 = (_e413 - _e416);
-    let _e420 = frag_info.target_origin[0u];
-    param_28 = _e420;
-    let _e421 = FragCoordFromTop_u0028_f1_u003b((&param_28));
-    noise = fract((52.982918f * fract(dot(_e421, vec2<f32>(0.06711056f, 0.00583715f)))));
-    let _e426 = noise;
-    angle = (_e426 * 6.2831855f);
-    let _e428 = angle;
-    ca_2 = cos(_e428);
-    let _e430 = angle;
-    sa_2 = sin(_e430);
-    let _e432 = (*lightIndex);
-    let _e436 = point_shadow.slots[_e432][2u];
-    tanHalf_1 = max(_e436, 0.0001f);
+    let _e401 = ndc[0u];
+    let _e405 = ndc[1u];
+    uv_3 = vec2<f32>(((_e401 * 0.5f) + 0.5f), (0.5f - (_e405 * 0.5f)));
+    let _e409 = face;
+    let _e411 = slot;
+    tile_3 = vec2<f32>(f32(_e409), f32(_e411));
+    let _e414 = distance_;
+    let _e417 = point_shadow.params[1u];
+    receiver_2 = (_e414 - _e417);
+    let _e421 = frag_info.target_origin[0u];
+    param_28 = _e421;
+    let _e422 = FragCoordFromTop_u0028_f1_u003b((&param_28));
+    noise = fract((52.982918f * fract(dot(_e422, vec2<f32>(0.06711056f, 0.00583715f)))));
+    let _e427 = noise;
+    angle = (_e427 * 6.2831855f);
+    let _e429 = angle;
+    ca_2 = cos(_e429);
+    let _e431 = angle;
+    sa_2 = sin(_e431);
+    let _e433 = (*lightIndex);
+    let _e437 = point_shadow.slots[_e433][2u];
+    tanHalf_1 = max(_e437, 0.0001f);
     blocker_1 = -1f;
-    let _e438 = uv_3;
-    param_29 = _e438;
-    let _e439 = tile_3;
-    param_30 = _e439;
-    let _e440 = range_3;
-    param_31 = _e440;
-    let _e441 = receiver_2;
-    param_32 = _e441;
-    let _e442 = ca_2;
-    param_33 = _e442;
-    let _e443 = sa_2;
-    param_34 = _e443;
-    let _e444 = tanHalf_1;
-    param_35 = _e444;
-    let _e445 = PointShadowPenumbra_u0028_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b((&param_29), (&param_30), (&param_31), (&param_32), (&param_33), (&param_34), (&param_35), (&param_36));
-    let _e446 = param_36;
-    blocker_1 = _e446;
-    radius_1 = _e445;
-    let _e449 = point_shadow.params2_[3u];
-    if (_e449 > 0.5f) {
+    let _e439 = uv_3;
+    param_29 = _e439;
+    let _e440 = tile_3;
+    param_30 = _e440;
+    let _e441 = range_3;
+    param_31 = _e441;
+    let _e442 = receiver_2;
+    param_32 = _e442;
+    let _e443 = ca_2;
+    param_33 = _e443;
+    let _e444 = sa_2;
+    param_34 = _e444;
+    let _e445 = tanHalf_1;
+    param_35 = _e445;
+    let _e446 = PointShadowPenumbra_u0028_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b((&param_29), (&param_30), (&param_31), (&param_32), (&param_33), (&param_34), (&param_35), (&param_36));
+    let _e447 = param_36;
+    blocker_1 = _e447;
+    radius_1 = _e446;
+    let _e450 = point_shadow.params2_[3u];
+    if (_e450 > 0.5f) {
         g_debug_surface_on = true;
-        let _e451 = radius_1;
-        if (_e451 < 0f) {
+        let _e452 = radius_1;
+        if (_e452 < 0f) {
             local_7 = vec3<f32>(0f, 0f, 1f);
         } else {
-            let _e453 = radius_1;
-            let _e456 = point_shadow.params2_[2u];
-            let _e460 = blocker_1;
-            let _e461 = range_3;
-            local_7 = vec3<f32>(clamp((_e453 / max(_e456, 0.000001f)), 0f, 1f), clamp((_e460 / _e461), 0f, 1f), 0f);
+            let _e454 = radius_1;
+            let _e457 = point_shadow.params2_[2u];
+            let _e461 = blocker_1;
+            let _e462 = range_3;
+            local_7 = vec3<f32>(clamp((_e454 / max(_e457, 0.000001f)), 0f, 1f), clamp((_e461 / _e462), 0f, 1f), 0f);
         }
-        let _e465 = local_7;
-        g_debug_surface = _e465;
+        let _e466 = local_7;
+        g_debug_surface = _e466;
     }
-    let _e466 = radius_1;
-    if (_e466 < 0f) {
+    let _e467 = radius_1;
+    if (_e467 < 0f) {
         return 1f;
     }
-    let _e468 = uv_3;
-    param_37 = _e468;
+    let _e469 = uv_3;
+    param_37 = _e469;
     param_38 = vec2<f32>(0f, 0f);
-    let _e469 = tile_3;
-    param_39 = _e469;
-    let _e470 = range_3;
-    param_40 = _e470;
-    let _e471 = receiver_2;
-    param_41 = _e471;
-    let _e472 = PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((&param_37), (&param_38), (&param_39), (&param_40), (&param_41));
-    lit_1 = _e472;
-    let _e473 = radius_1;
-    if (_e473 > 0f) {
+    let _e470 = tile_3;
+    param_39 = _e470;
+    let _e471 = range_3;
+    param_40 = _e471;
+    let _e472 = receiver_2;
+    param_41 = _e472;
+    let _e473 = PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((&param_37), (&param_38), (&param_39), (&param_40), (&param_41));
+    lit_1 = _e473;
+    let _e474 = radius_1;
+    if (_e474 > 0f) {
         i_3 = 0i;
         loop {
-            let _e475 = i_3;
-            if (_e475 < 8i) {
-                let _e477 = i_3;
-                param_42 = _e477;
-                let _e478 = ca_2;
-                param_43 = _e478;
-                let _e479 = sa_2;
-                param_44 = _e479;
-                let _e480 = radius_1;
-                param_45 = _e480;
-                let _e481 = PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b((&param_42), (&param_43), (&param_44), (&param_45));
-                let _e482 = uv_3;
-                param_46 = _e482;
-                param_47 = _e481;
-                let _e483 = tile_3;
-                param_48 = _e483;
-                let _e484 = range_3;
-                param_49 = _e484;
-                let _e485 = receiver_2;
-                param_50 = _e485;
-                let _e486 = PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((&param_46), (&param_47), (&param_48), (&param_49), (&param_50));
-                let _e487 = lit_1;
-                lit_1 = (_e487 + _e486);
+            let _e476 = i_3;
+            if (_e476 < 8i) {
+                let _e478 = i_3;
+                param_42 = _e478;
+                let _e479 = ca_2;
+                param_43 = _e479;
+                let _e480 = sa_2;
+                param_44 = _e480;
+                let _e481 = radius_1;
+                param_45 = _e481;
+                let _e482 = PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b((&param_42), (&param_43), (&param_44), (&param_45));
+                let _e483 = uv_3;
+                param_46 = _e483;
+                param_47 = _e482;
+                let _e484 = tile_3;
+                param_48 = _e484;
+                let _e485 = range_3;
+                param_49 = _e485;
+                let _e486 = receiver_2;
+                param_50 = _e486;
+                let _e487 = PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((&param_46), (&param_47), (&param_48), (&param_49), (&param_50));
+                let _e488 = lit_1;
+                lit_1 = (_e488 + _e487);
                 continue;
             } else {
                 break;
             }
             continuing {
-                let _e489 = i_3;
-                i_3 = (_e489 + 1i);
+                let _e490 = i_3;
+                i_3 = (_e490 + 1i);
             }
         }
-        let _e491 = lit_1;
-        lit_1 = (_e491 * 0.11111111f);
+        let _e492 = lit_1;
+        lit_1 = (_e492 * 0.11111111f);
     }
-    let _e493 = lit_1;
-    let _e494 = strength;
-    return mix(1f, _e493, clamp(_e494, 0f, 1f));
+    let _e494 = lit_1;
+    let _e495 = strength;
+    return mix(1f, _e494, clamp(_e495, 0f, 1f));
 }
 
 fn VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b(i_4: ptr<function, i32>, n_1: ptr<function, i32>, turn: ptr<function, f32>) -> vec2<f32> {
     var r: f32;
     var theta: f32;
 
-    let _e191 = (*i_4);
-    let _e194 = (*n_1);
-    r = sqrt(((f32(_e191) + 0.5f) / f32(_e194)));
-    let _e198 = (*i_4);
-    let _e201 = (*turn);
-    theta = ((f32(_e198) * 2.3999631f) + _e201);
-    let _e203 = r;
-    let _e204 = theta;
-    let _e206 = theta;
-    return (vec2<f32>(cos(_e204), sin(_e206)) * _e203);
+    let _e192 = (*i_4);
+    let _e195 = (*n_1);
+    r = sqrt(((f32(_e192) + 0.5f) / f32(_e195)));
+    let _e199 = (*i_4);
+    let _e202 = (*turn);
+    theta = ((f32(_e199) * 2.3999631f) + _e202);
+    let _e204 = r;
+    let _e205 = theta;
+    let _e207 = theta;
+    return (vec2<f32>(cos(_e205), sin(_e207)) * _e204);
 }
 
 fn ShadowNoise_u0028_() -> f32 {
     var at: vec2<f32>;
     var param_51: f32;
 
-    let _e190 = frag_info.target_origin[0u];
-    param_51 = _e190;
-    let _e191 = FragCoordFromTop_u0028_f1_u003b((&param_51));
-    let _e194 = frag_info.target_origin[3u];
-    at = (_e191 + vec2((5.588238f * max(_e194, 0f))));
-    let _e199 = at;
-    return fract((52.982918f * fract(dot(_e199, vec2<f32>(0.06711056f, 0.00583715f)))));
+    let _e191 = frag_info.target_origin[0u];
+    param_51 = _e191;
+    let _e192 = FragCoordFromTop_u0028_f1_u003b((&param_51));
+    let _e195 = frag_info.target_origin[3u];
+    at = (_e192 + vec2((5.588238f * max(_e195, 0f))));
+    let _e200 = at;
+    return fract((52.982918f * fract(dot(_e200, vec2<f32>(0.06711056f, 0.00583715f)))));
 }
 
 fn EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b(moments: ptr<function, vec2<f32>>, t: ptr<function, f32>, minVariance: ptr<function, f32>, bleed: ptr<function, f32>) -> f32 {
@@ -7454,37 +7468,37 @@ fn EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b(moments: ptr<functio
     var pMax: f32;
     var reduced: f32;
 
-    let _e195 = (*moments)[1u];
-    let _e197 = (*moments)[0u];
-    let _e199 = (*moments)[0u];
-    let _e202 = (*minVariance);
-    variance = max((_e195 - (_e197 * _e199)), _e202);
-    let _e204 = (*t);
-    let _e206 = (*moments)[0u];
-    d_1 = (_e204 - _e206);
-    let _e208 = variance;
+    let _e196 = (*moments)[1u];
+    let _e198 = (*moments)[0u];
+    let _e200 = (*moments)[0u];
+    let _e203 = (*minVariance);
+    variance = max((_e196 - (_e198 * _e200)), _e203);
+    let _e205 = (*t);
+    let _e207 = (*moments)[0u];
+    d_1 = (_e205 - _e207);
     let _e209 = variance;
-    let _e210 = d_1;
+    let _e210 = variance;
     let _e211 = d_1;
-    pMax = (_e208 / (_e209 + (_e210 * _e211)));
-    let _e215 = pMax;
-    let _e216 = (*bleed);
-    let _e218 = (*bleed);
-    reduced = clamp(((_e215 - _e216) / max((1f - _e218), 0.0001f)), 0f, 1f);
-    let _e223 = (*t);
-    let _e225 = (*moments)[0u];
-    let _e227 = reduced;
-    return select(_e227, 1f, (_e223 <= _e225));
+    let _e212 = d_1;
+    pMax = (_e209 / (_e210 + (_e211 * _e212)));
+    let _e216 = pMax;
+    let _e217 = (*bleed);
+    let _e219 = (*bleed);
+    reduced = clamp(((_e216 - _e217) / max((1f - _e219), 0.0001f)), 0f, 1f);
+    let _e224 = (*t);
+    let _e226 = (*moments)[0u];
+    let _e228 = reduced;
+    return select(_e228, 1f, (_e224 <= _e226));
 }
 
 fn EvsmWarp_u0028_f1_u003b(depth: ptr<function, f32>) -> vec2<f32> {
     var d_2: f32;
 
-    let _e188 = (*depth);
-    d_2 = ((2f * clamp(_e188, 0f, 1f)) - 1f);
-    let _e192 = d_2;
-    let _e195 = d_2;
-    return vec2<f32>(exp((40f * _e192)), -(exp((-5f * _e195))));
+    let _e189 = (*depth);
+    d_2 = ((2f * clamp(_e189, 0f, 1f)) - 1f);
+    let _e193 = d_2;
+    let _e196 = d_2;
+    return vec2<f32>(exp((40f * _e193)), -(exp((-5f * _e196))));
 }
 
 fn EvsmVisibility_u0028_vf4_u003b_f1_u003b_f1_u003b(moments_1: ptr<function, vec4<f32>>, depth_1: ptr<function, f32>, bleed_1: ptr<function, f32>) -> f32 {
@@ -7502,37 +7516,37 @@ fn EvsmVisibility_u0028_vf4_u003b_f1_u003b_f1_u003b(moments_1: ptr<function, vec
     var param_59: f32;
     var param_60: f32;
 
-    let _e202 = (*depth_1);
-    param_52 = _e202;
-    let _e203 = EvsmWarp_u0028_f1_u003b((&param_52));
-    warped = _e203;
-    let _e204 = warped;
-    scale = (vec2<f32>(0.004f, 0.0005f) * _e204);
-    let _e207 = scale[0u];
-    let _e209 = scale[0u];
-    let _e211 = (*moments_1);
-    param_53 = _e211.xy;
-    let _e214 = warped[0u];
-    param_54 = _e214;
-    param_55 = (_e207 * _e209);
-    let _e215 = (*bleed_1);
-    param_56 = _e215;
-    let _e216 = EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b((&param_53), (&param_54), (&param_55), (&param_56));
-    positive = _e216;
-    let _e218 = scale[1u];
-    let _e220 = scale[1u];
-    let _e222 = (*moments_1);
-    param_57 = _e222.zw;
-    let _e225 = warped[1u];
-    param_58 = _e225;
-    param_59 = (_e218 * _e220);
-    let _e226 = (*bleed_1);
-    param_60 = _e226;
-    let _e227 = EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b((&param_57), (&param_58), (&param_59), (&param_60));
-    negative = _e227;
-    let _e228 = positive;
-    let _e229 = negative;
-    return min(_e228, _e229);
+    let _e203 = (*depth_1);
+    param_52 = _e203;
+    let _e204 = EvsmWarp_u0028_f1_u003b((&param_52));
+    warped = _e204;
+    let _e205 = warped;
+    scale = (vec2<f32>(0.004f, 0.0005f) * _e205);
+    let _e208 = scale[0u];
+    let _e210 = scale[0u];
+    let _e212 = (*moments_1);
+    param_53 = _e212.xy;
+    let _e215 = warped[0u];
+    param_54 = _e215;
+    param_55 = (_e208 * _e210);
+    let _e216 = (*bleed_1);
+    param_56 = _e216;
+    let _e217 = EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b((&param_53), (&param_54), (&param_55), (&param_56));
+    positive = _e217;
+    let _e219 = scale[1u];
+    let _e221 = scale[1u];
+    let _e223 = (*moments_1);
+    param_57 = _e223.zw;
+    let _e226 = warped[1u];
+    param_58 = _e226;
+    param_59 = (_e219 * _e221);
+    let _e227 = (*bleed_1);
+    param_60 = _e227;
+    let _e228 = EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b((&param_57), (&param_58), (&param_59), (&param_60));
+    negative = _e228;
+    let _e229 = positive;
+    let _e230 = negative;
+    return min(_e229, _e230);
 }
 
 fn ShadowFactor_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b_i1_u003b(s_2: ptr<function, Surface>, light_1: ptr<function, LightSample>, lightIndex_1: ptr<function, i32>) -> f32 {
@@ -7570,6 +7584,8 @@ fn ShadowFactor_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf
     var tileLo: vec2<f32>;
     var tileHi: vec2<f32>;
     var stored_2: vec4<f32>;
+    var y: i32;
+    var x: i32;
     var through: vec3<f32>;
     var softness: f32;
     var lit_2: f32;
@@ -7577,8 +7593,8 @@ fn ShadowFactor_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf
     var param_61: vec4<f32>;
     var param_62: f32;
     var param_63: f32;
-    var y: i32;
-    var x: i32;
+    var y_1: i32;
+    var x_1: i32;
     var occluder: f32;
     var spread: f32;
     var turn_1: f32;
@@ -7607,45 +7623,45 @@ fn ShadowFactor_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf
     var phi_3683_: bool;
     var phi_3690_: bool;
 
-    let _e256 = frag_info.shadow_params[3u];
-    strength_1 = _e256;
-    let _e257 = strength_1;
-    if (_e257 <= 0f) {
+    let _e259 = frag_info.shadow_params[3u];
+    strength_1 = _e259;
+    let _e260 = strength_1;
+    if (_e260 <= 0f) {
         return 1f;
     }
-    let _e259 = (*lightIndex_1);
-    let _e262 = frag_info.frame_params[2u];
-    if (_e259 != i32((_e262 + 0.5f))) {
+    let _e262 = (*lightIndex_1);
+    let _e265 = frag_info.frame_params[2u];
+    if (_e262 != i32((_e265 + 0.5f))) {
         return 1f;
     }
-    let _e268 = frag_info.shadow_cascades[2u];
-    cascadeCount = i32((_e268 + 0.5f));
-    let _e271 = v_world_position_1;
-    let _e273 = frag_info.camera_position;
-    viewDistance = length((_e271 - _e273.xyz));
+    let _e271 = frag_info.shadow_cascades[2u];
+    cascadeCount = i32((_e271 + 0.5f));
+    let _e274 = v_world_position_1;
+    let _e276 = frag_info.camera_position;
+    viewDistance = length((_e274 - _e276.xyz));
     cascade = 0i;
-    let _e277 = cascadeCount;
-    let _e278 = (_e277 > 1i);
-    phi_3504_ = _e278;
-    if _e278 {
-        let _e279 = viewDistance;
-        let _e282 = frag_info.shadow_cascades[0u];
-        phi_3504_ = (_e279 > _e282);
-    }
-    let _e285 = phi_3504_;
-    if _e285 {
+    let _e280 = cascadeCount;
+    let _e281 = (_e280 > 1i);
+    phi_3504_ = _e281;
+    if _e281 {
+        let _e282 = viewDistance;
+        let _e285 = frag_info.shadow_cascades[0u];
+        phi_3504_ = (_e282 > _e285);
+    }
+    let _e288 = phi_3504_;
+    if _e288 {
         cascade = 1i;
     }
-    let _e286 = cascadeCount;
-    let _e287 = (_e286 > 2i);
-    phi_3515_ = _e287;
-    if _e287 {
-        let _e288 = viewDistance;
-        let _e291 = frag_info.shadow_cascades[1u];
-        phi_3515_ = (_e288 > _e291);
+    let _e289 = cascadeCount;
+    let _e290 = (_e289 > 2i);
+    phi_3515_ = _e290;
+    if _e290 {
+        let _e291 = viewDistance;
+        let _e294 = frag_info.shadow_cascades[1u];
+        phi_3515_ = (_e291 > _e294);
     }
-    let _e294 = phi_3515_;
-    if _e294 {
+    let _e297 = phi_3515_;
+    if _e297 {
         cascade = 2i;
     }
     uv_4 = vec2<f32>(0f, 0f);
@@ -7656,247 +7672,280 @@ fn ShadowFactor_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf
     receiverSlope = 0f;
     attempt = 0i;
     loop {
-        let _e295 = attempt;
-        if (_e295 < 3i) {
-            let _e297 = cascade;
-            let _e298 = attempt;
-            which = (_e297 + _e298);
-            let _e300 = which;
-            let _e301 = cascadeCount;
-            if (_e300 >= _e301) {
+        let _e298 = attempt;
+        if (_e298 < 3i) {
+            let _e300 = cascade;
+            let _e301 = attempt;
+            which = (_e300 + _e301);
+            let _e303 = which;
+            let _e304 = cascadeCount;
+            if (_e303 >= _e304) {
                 break;
             }
-            let _e303 = which;
-            if (_e303 == 0i) {
-                let _e306 = frag_info.shadow_matrix;
-                local_8 = _e306;
+            let _e306 = which;
+            if (_e306 == 0i) {
+                let _e309 = frag_info.shadow_matrix;
+                local_8 = _e309;
             } else {
-                let _e307 = which;
-                if (_e307 == 1i) {
-                    let _e310 = frag_info.shadow_matrix_far;
-                    local_9 = _e310;
+                let _e310 = which;
+                if (_e310 == 1i) {
+                    let _e313 = frag_info.shadow_matrix_far;
+                    local_9 = _e313;
                 } else {
-                    let _e312 = frag_info.shadow_matrix_farthest;
-                    local_9 = _e312;
+                    let _e315 = frag_info.shadow_matrix_farthest;
+                    local_9 = _e315;
                 }
-                let _e313 = local_9;
-                local_8 = _e313;
-            }
-            let _e314 = local_8;
-            matrix = _e314;
-            let _e317 = matrix[0][0u];
-            let _e320 = matrix[1][0u];
-            let _e323 = matrix[2][0u];
-            axisX = vec3<f32>(_e317, _e320, _e323);
-            let _e327 = matrix[0][1u];
-            let _e330 = matrix[1][1u];
-            let _e333 = matrix[2][1u];
-            axisY = vec3<f32>(_e327, _e330, _e333);
-            let _e335 = axisX;
-            rowX = max(length(_e335), 0.000001f);
-            let _e338 = axisY;
-            rowY = max(length(_e338), 0.000001f);
-            let _e343 = frag_info.shadow_cascades[3u];
-            let _e345 = rowX;
-            texelMetres = ((2f * _e343) / _e345);
-            let _e349 = frag_info.shadow_cascades[3u];
-            let _e352 = (*s_2).n;
-            let _e353 = axisX;
-            let _e356 = rowX;
-            let _e357 = rowX;
-            let _e361 = (*s_2).n;
-            let _e362 = axisY;
-            let _e365 = rowY;
-            let _e366 = rowY;
-            reach = ((3f * _e349) * ((abs(dot(_e352, _e353)) / (_e356 * _e357)) + (abs(dot(_e361, _e362)) / (_e365 * _e366))));
-            let _e373 = frag_info.shadow_params[2u];
-            let _e374 = texelMetres;
-            flatOffset = min(_e373, _e374);
-            let _e376 = v_world_position_1;
-            let _e378 = (*s_2).n;
-            let _e379 = flatOffset;
-            let _e380 = reach;
-            origin_1 = (_e376 + (_e378 * (_e379 + _e380)));
-            let _e384 = matrix;
-            let _e385 = origin_1;
-            lightSpace = (_e384 * vec4<f32>(_e385.x, _e385.y, _e385.z, 1f));
-            let _e392 = lightSpace[3u];
-            if (_e392 <= 0f) {
+                let _e316 = local_9;
+                local_8 = _e316;
+            }
+            let _e317 = local_8;
+            matrix = _e317;
+            let _e320 = matrix[0][0u];
+            let _e323 = matrix[1][0u];
+            let _e326 = matrix[2][0u];
+            axisX = vec3<f32>(_e320, _e323, _e326);
+            let _e330 = matrix[0][1u];
+            let _e333 = matrix[1][1u];
+            let _e336 = matrix[2][1u];
+            axisY = vec3<f32>(_e330, _e333, _e336);
+            let _e338 = axisX;
+            rowX = max(length(_e338), 0.000001f);
+            let _e341 = axisY;
+            rowY = max(length(_e341), 0.000001f);
+            let _e346 = frag_info.shadow_cascades[3u];
+            let _e348 = rowX;
+            texelMetres = ((2f * _e346) / _e348);
+            let _e352 = frag_info.shadow_cascades[3u];
+            let _e355 = (*s_2).n;
+            let _e356 = axisX;
+            let _e359 = rowX;
+            let _e360 = rowX;
+            let _e364 = (*s_2).n;
+            let _e365 = axisY;
+            let _e368 = rowY;
+            let _e369 = rowY;
+            reach = ((3f * _e352) * ((abs(dot(_e355, _e356)) / (_e359 * _e360)) + (abs(dot(_e364, _e365)) / (_e368 * _e369))));
+            let _e376 = frag_info.shadow_params[2u];
+            let _e377 = texelMetres;
+            flatOffset = min(_e376, _e377);
+            let _e379 = v_world_position_1;
+            let _e381 = (*s_2).n;
+            let _e382 = flatOffset;
+            let _e383 = reach;
+            origin_1 = (_e379 + (_e381 * (_e382 + _e383)));
+            let _e387 = matrix;
+            let _e388 = origin_1;
+            lightSpace = (_e387 * vec4<f32>(_e388.x, _e388.y, _e388.z, 1f));
+            let _e395 = lightSpace[3u];
+            if (_e395 <= 0f) {
                 continue;
             }
-            let _e394 = lightSpace;
-            let _e397 = lightSpace[3u];
-            candidate = (_e394.xyz / vec3(_e397));
-            let _e401 = candidate[0u];
-            let _e405 = candidate[1u];
-            inTile = vec2<f32>(((_e401 * 0.5f) + 0.5f), (0.5f - (_e405 * 0.5f)));
-            let _e410 = inTile[0u];
-            let _e411 = (_e410 < 0f);
-            phi_3676_ = _e411;
-            if !(_e411) {
-                let _e414 = inTile[0u];
-                phi_3676_ = (_e414 > 1f);
-            }
-            let _e417 = phi_3676_;
-            phi_3683_ = _e417;
-            if !(_e417) {
-                let _e420 = inTile[1u];
-                phi_3683_ = (_e420 < 0f);
-            }
-            let _e423 = phi_3683_;
-            phi_3690_ = _e423;
-            if !(_e423) {
-                let _e426 = inTile[1u];
-                phi_3690_ = (_e426 > 1f);
-            }
-            let _e429 = phi_3690_;
-            if _e429 {
+            let _e397 = lightSpace;
+            let _e400 = lightSpace[3u];
+            candidate = (_e397.xyz / vec3(_e400));
+            let _e404 = candidate[0u];
+            let _e408 = candidate[1u];
+            inTile = vec2<f32>(((_e404 * 0.5f) + 0.5f), (0.5f - (_e408 * 0.5f)));
+            let _e413 = inTile[0u];
+            let _e414 = (_e413 < 0f);
+            phi_3676_ = _e414;
+            if !(_e414) {
+                let _e417 = inTile[0u];
+                phi_3676_ = (_e417 > 1f);
+            }
+            let _e420 = phi_3676_;
+            phi_3683_ = _e420;
+            if !(_e420) {
+                let _e423 = inTile[1u];
+                phi_3683_ = (_e423 < 0f);
+            }
+            let _e426 = phi_3683_;
+            phi_3690_ = _e426;
+            if !(_e426) {
+                let _e429 = inTile[1u];
+                phi_3690_ = (_e429 > 1f);
+            }
+            let _e432 = phi_3690_;
+            if _e432 {
                 continue;
             }
-            let _e431 = candidate[2u];
-            if (_e431 > 1f) {
-                let _e433 = which;
-                let _e434 = cascadeCount;
-                if (_e433 < (_e434 - 1i)) {
+            let _e434 = candidate[2u];
+            if (_e434 > 1f) {
+                let _e436 = which;
+                let _e437 = cascadeCount;
+                if (_e436 < (_e437 - 1i)) {
                     continue;
                 }
                 candidate[2u] = 1f;
             }
-            let _e439 = inTile[0u];
-            let _e440 = which;
-            let _e443 = cascadeCount;
-            let _e447 = inTile[1u];
-            uv_4 = vec2<f32>(((_e439 + f32(_e440)) / f32(_e443)), _e447);
-            let _e449 = candidate;
-            projected = _e449;
-            let _e450 = which;
-            cascade = _e450;
-            let _e451 = texelMetres;
-            cascadeTexel = _e451;
-            let _e454 = matrix[0][2u];
-            let _e457 = matrix[1][2u];
-            let _e460 = matrix[2][2u];
-            cascadeDepth = (1f / max(length(vec3<f32>(_e454, _e457, _e460)), 0.000001f));
-            let _e466 = (*s_2).n;
-            let _e469 = matrix[0][2u];
-            let _e472 = matrix[1][2u];
-            let _e475 = matrix[2][2u];
-            let _e479 = cascadeDepth;
-            cosSlope = clamp((abs(dot(_e466, vec3<f32>(_e469, _e472, _e475))) * _e479), 0.1f, 1f);
-            let _e482 = texelMetres;
-            let _e483 = cosSlope;
-            let _e484 = cosSlope;
-            let _e490 = cosSlope;
-            let _e492 = cascadeDepth;
-            receiverSlope = (((_e482 * sqrt(max((1f - (_e483 * _e484)), 0f))) / _e490) / _e492);
+            let _e442 = inTile[0u];
+            let _e443 = which;
+            let _e446 = cascadeCount;
+            let _e450 = inTile[1u];
+            uv_4 = vec2<f32>(((_e442 + f32(_e443)) / f32(_e446)), _e450);
+            let _e452 = candidate;
+            projected = _e452;
+            let _e453 = which;
+            cascade = _e453;
+            let _e454 = texelMetres;
+            cascadeTexel = _e454;
+            let _e457 = matrix[0][2u];
+            let _e460 = matrix[1][2u];
+            let _e463 = matrix[2][2u];
+            cascadeDepth = (1f / max(length(vec3<f32>(_e457, _e460, _e463)), 0.000001f));
+            let _e469 = (*s_2).n;
+            let _e472 = matrix[0][2u];
+            let _e475 = matrix[1][2u];
+            let _e478 = matrix[2][2u];
+            let _e482 = cascadeDepth;
+            cosSlope = clamp((abs(dot(_e469, vec3<f32>(_e472, _e475, _e478))) * _e482), 0.1f, 1f);
+            let _e485 = texelMetres;
+            let _e486 = cosSlope;
+            let _e487 = cosSlope;
+            let _e493 = cosSlope;
+            let _e495 = cascadeDepth;
+            receiverSlope = (((_e485 * sqrt(max((1f - (_e486 * _e487)), 0f))) / _e493) / _e495);
             found = true;
             break;
         } else {
             break;
         }
         continuing {
-            let _e494 = attempt;
-            attempt = (_e494 + 1i);
+            let _e497 = attempt;
+            attempt = (_e497 + 1i);
         }
     }
-    let _e496 = found;
-    if !(_e496) {
+    let _e499 = found;
+    if !(_e499) {
         return 1f;
     }
-    let _e498 = cascade;
-    if (_e498 == 0i) {
-        let _e502 = frag_info.shadow_bias[0u];
-        local_10 = _e502;
+    let _e501 = cascade;
+    if (_e501 == 0i) {
+        let _e505 = frag_info.shadow_bias[0u];
+        local_10 = _e505;
     } else {
-        let _e503 = cascade;
-        if (_e503 == 1i) {
-            let _e507 = frag_info.shadow_bias[1u];
-            local_11 = _e507;
-        } else {
-            let _e510 = frag_info.shadow_bias[2u];
+        let _e506 = cascade;
+        if (_e506 == 1i) {
+            let _e510 = frag_info.shadow_bias[1u];
             local_11 = _e510;
-        }
-        let _e511 = local_11;
-        local_10 = _e511;
-    }
-    let _e512 = local_10;
-    bias = _e512;
-    let _e515 = frag_info.shadow_params[0u];
-    let _e518 = frag_info.shadow_cascades[3u];
-    texel_1 = vec2<f32>(_e515, _e518);
-    let _e520 = cascade;
-    let _e522 = cascadeCount;
-    let _e526 = texel_1;
-    tileLo = (vec2<f32>((f32(_e520) / f32(_e522)), 0f) + (_e526 * 0.5f));
-    let _e529 = cascade;
-    let _e532 = cascadeCount;
-    let _e536 = texel_1;
-    tileHi = (vec2<f32>((f32((_e529 + 1i)) / f32(_e532)), 1f) - (_e536 * 0.5f));
-    let _e541 = frag_info.shadow_bias[3u];
-    if (_e541 > 0.5f) {
-        let _e543 = uv_4;
-        let _e544 = tileLo;
-        let _e545 = tileHi;
-        let _e547 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp(_e543, _e544, _e545), 0f);
-        stored_2 = _e547;
-        let _e549 = stored_2[1u];
-        let _e552 = stored_2[2u];
-        let _e555 = stored_2[3u];
-        through = clamp(vec3<f32>((1f - _e549), (1f - _e552), _e555), vec3(0f), vec3(4f));
-        let _e560 = through;
-        let _e561 = strength_1;
-        light_transmittance = mix(vec3<f32>(1f, 1f, 1f), _e560, vec3(clamp(_e561, 0f, 1f)));
-    }
-    let _e567 = frag_info.ambient_ground[3u];
-    softness = _e567;
+        } else {
+            let _e513 = frag_info.shadow_bias[2u];
+            local_11 = _e513;
+        }
+        let _e514 = local_11;
+        local_10 = _e514;
+    }
+    let _e515 = local_10;
+    bias = _e515;
+    let _e518 = frag_info.shadow_params[0u];
+    let _e521 = frag_info.shadow_cascades[3u];
+    texel_1 = vec2<f32>(_e518, _e521);
+    let _e523 = cascade;
+    let _e525 = cascadeCount;
+    let _e529 = texel_1;
+    tileLo = (vec2<f32>((f32(_e523) / f32(_e525)), 0f) + (_e529 * 0.5f));
+    let _e532 = cascade;
+    let _e535 = cascadeCount;
+    let _e539 = texel_1;
+    tileHi = (vec2<f32>((f32((_e532 + 1i)) / f32(_e535)), 1f) - (_e539 * 0.5f));
+    let _e544 = frag_info.shadow_bias[3u];
+    if (_e544 > 0.5f) {
+        stored_2 = vec4<f32>(0f, 0f, 0f, 0f);
+        y = -1i;
+        loop {
+            let _e546 = y;
+            if (_e546 <= 1i) {
+                x = -1i;
+                loop {
+                    let _e548 = x;
+                    if (_e548 <= 1i) {
+                        let _e550 = uv_4;
+                        let _e551 = x;
+                        let _e553 = y;
+                        let _e556 = texel_1;
+                        let _e559 = tileLo;
+                        let _e560 = tileHi;
+                        let _e562 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e550 + (vec2<f32>(f32(_e551), f32(_e553)) * _e556)), _e559, _e560), 0f);
+                        let _e563 = stored_2;
+                        stored_2 = (_e563 + _e562);
+                        continue;
+                    } else {
+                        break;
+                    }
+                    continuing {
+                        let _e565 = x;
+                        x = (_e565 + 1i);
+                    }
+                }
+                continue;
+            } else {
+                break;
+            }
+            continuing {
+                let _e567 = y;
+                y = (_e567 + 1i);
+            }
+        }
+        let _e569 = stored_2;
+        stored_2 = (_e569 * 0.11111111f);
+        let _e572 = stored_2[1u];
+        let _e575 = stored_2[2u];
+        let _e578 = stored_2[3u];
+        through = clamp(vec3<f32>((1f - _e572), (1f - _e575), _e578), vec3(0f), vec3(4f));
+        let _e583 = through;
+        let _e584 = strength_1;
+        light_transmittance = mix(vec3<f32>(1f, 1f, 1f), _e583, vec3(clamp(_e584, 0f, 1f)));
+    }
+    let _e590 = frag_info.ambient_ground[3u];
+    softness = _e590;
     lit_2 = 0f;
-    let _e568 = softness;
-    if (_e568 < 0f) {
-        let _e570 = uv_4;
-        let _e571 = tileLo;
-        let _e572 = tileHi;
-        let _e574 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp(_e570, _e571, _e572), 0f);
-        moments_2 = _e574;
-        let _e576 = projected[2u];
-        let _e577 = bias;
-        let _e579 = softness;
-        let _e583 = moments_2;
-        param_61 = _e583;
-        param_62 = (_e576 - _e577);
-        param_63 = clamp((-(_e579) - 1f), 0f, 0.95f);
-        let _e584 = EvsmVisibility_u0028_vf4_u003b_f1_u003b_f1_u003b((&param_61), (&param_62), (&param_63));
-        lit_2 = _e584;
-    } else {
-        let _e585 = softness;
-        if (_e585 <= 0f) {
-            y = -1i;
+    let _e591 = softness;
+    if (_e591 < 0f) {
+        let _e593 = uv_4;
+        let _e594 = tileLo;
+        let _e595 = tileHi;
+        let _e597 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp(_e593, _e594, _e595), 0f);
+        moments_2 = _e597;
+        let _e599 = projected[2u];
+        let _e600 = bias;
+        let _e602 = softness;
+        let _e606 = moments_2;
+        param_61 = _e606;
+        param_62 = (_e599 - _e600);
+        param_63 = clamp((-(_e602) - 1f), 0f, 0.95f);
+        let _e607 = EvsmVisibility_u0028_vf4_u003b_f1_u003b_f1_u003b((&param_61), (&param_62), (&param_63));
+        lit_2 = _e607;
+    } else {
+        let _e608 = softness;
+        if (_e608 <= 0f) {
+            y_1 = -1i;
             loop {
-                let _e587 = y;
-                if (_e587 <= 1i) {
-                    x = -1i;
+                let _e610 = y_1;
+                if (_e610 <= 1i) {
+                    x_1 = -1i;
                     loop {
-                        let _e589 = x;
-                        if (_e589 <= 1i) {
-                            let _e591 = uv_4;
-                            let _e592 = x;
-                            let _e594 = y;
-                            let _e597 = texel_1;
-                            let _e600 = tileLo;
-                            let _e601 = tileHi;
-                            let _e603 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e591 + (vec2<f32>(f32(_e592), f32(_e594)) * _e597)), _e600, _e601), 0f);
-                            occluder = _e603.x;
-                            let _e606 = projected[2u];
-                            let _e607 = bias;
-                            let _e609 = occluder;
-                            let _e612 = lit_2;
-                            lit_2 = (_e612 + select(1f, 0f, ((_e606 - _e607) > _e609)));
+                        let _e612 = x_1;
+                        if (_e612 <= 1i) {
+                            let _e614 = uv_4;
+                            let _e615 = x_1;
+                            let _e617 = y_1;
+                            let _e620 = texel_1;
+                            let _e623 = tileLo;
+                            let _e624 = tileHi;
+                            let _e626 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e614 + (vec2<f32>(f32(_e615), f32(_e617)) * _e620)), _e623, _e624), 0f);
+                            occluder = _e626.x;
+                            let _e629 = projected[2u];
+                            let _e630 = bias;
+                            let _e632 = occluder;
+                            let _e635 = lit_2;
+                            lit_2 = (_e635 + select(1f, 0f, ((_e629 - _e630) > _e632)));
                             continue;
                         } else {
                             break;
                         }
                         continuing {
-                            let _e614 = x;
-                            x = (_e614 + 1i);
+                            let _e637 = x_1;
+                            x_1 = (_e637 + 1i);
                         }
                     }
                     continue;
@@ -7904,125 +7953,125 @@ fn ShadowFactor_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf
                     break;
                 }
                 continuing {
-                    let _e616 = y;
-                    y = (_e616 + 1i);
+                    let _e639 = y_1;
+                    y_1 = (_e639 + 1i);
                 }
             }
-            let _e618 = lit_2;
-            lit_2 = (_e618 * 0.11111111f);
+            let _e641 = lit_2;
+            lit_2 = (_e641 * 0.11111111f);
         } else {
-            let _e620 = softness;
-            spread = tan(min(_e620, 0.5f));
-            let _e623 = ShadowNoise_u0028_();
-            turn_1 = (_e623 * 6.2831855f);
-            let _e625 = spread;
-            let _e627 = projected[2u];
-            let _e629 = cascadeDepth;
-            let _e631 = cascadeTexel;
-            searchRadius = clamp((((_e625 * _e627) * _e629) / _e631), 1f, 16f);
+            let _e643 = softness;
+            spread = tan(min(_e643, 0.5f));
+            let _e646 = ShadowNoise_u0028_();
+            turn_1 = (_e646 * 6.2831855f);
+            let _e648 = spread;
+            let _e650 = projected[2u];
+            let _e652 = cascadeDepth;
+            let _e654 = cascadeTexel;
+            searchRadius = clamp((((_e648 * _e650) * _e652) / _e654), 1f, 16f);
             blockerSum = 0f;
             blockerCount = 0f;
             i_5 = 0i;
             loop {
-                let _e634 = i_5;
-                if (_e634 < 16i) {
-                    let _e636 = i_5;
-                    param_64 = _e636;
+                let _e657 = i_5;
+                if (_e657 < 16i) {
+                    let _e659 = i_5;
+                    param_64 = _e659;
                     param_65 = 16i;
-                    let _e637 = turn_1;
-                    param_66 = _e637;
-                    let _e638 = VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b((&param_64), (&param_65), (&param_66));
-                    disc = _e638;
-                    let _e639 = bias;
-                    let _e640 = disc;
-                    let _e642 = searchRadius;
-                    let _e646 = receiverSlope;
-                    tapBias = (_e639 + (max(((length(_e640) * _e642) - 1.5f), 0f) * _e646));
-                    let _e649 = uv_4;
-                    let _e650 = disc;
-                    let _e651 = texel_1;
-                    let _e653 = searchRadius;
-                    let _e656 = tileLo;
-                    let _e657 = tileHi;
-                    let _e659 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e649 + ((_e650 * _e651) * _e653)), _e656, _e657), 0f);
-                    occluder_1 = _e659.x;
-                    let _e662 = projected[2u];
-                    let _e663 = tapBias;
-                    let _e665 = occluder_1;
-                    if ((_e662 - _e663) > _e665) {
-                        let _e667 = occluder_1;
-                        let _e668 = blockerSum;
-                        blockerSum = (_e668 + _e667);
-                        let _e670 = blockerCount;
-                        blockerCount = (_e670 + 1f);
+                    let _e660 = turn_1;
+                    param_66 = _e660;
+                    let _e661 = VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b((&param_64), (&param_65), (&param_66));
+                    disc = _e661;
+                    let _e662 = bias;
+                    let _e663 = disc;
+                    let _e665 = searchRadius;
+                    let _e669 = receiverSlope;
+                    tapBias = (_e662 + (max(((length(_e663) * _e665) - 1.5f), 0f) * _e669));
+                    let _e672 = uv_4;
+                    let _e673 = disc;
+                    let _e674 = texel_1;
+                    let _e676 = searchRadius;
+                    let _e679 = tileLo;
+                    let _e680 = tileHi;
+                    let _e682 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e672 + ((_e673 * _e674) * _e676)), _e679, _e680), 0f);
+                    occluder_1 = _e682.x;
+                    let _e685 = projected[2u];
+                    let _e686 = tapBias;
+                    let _e688 = occluder_1;
+                    if ((_e685 - _e686) > _e688) {
+                        let _e690 = occluder_1;
+                        let _e691 = blockerSum;
+                        blockerSum = (_e691 + _e690);
+                        let _e693 = blockerCount;
+                        blockerCount = (_e693 + 1f);
                     }
                     continue;
                 } else {
                     break;
                 }
                 continuing {
-                    let _e672 = i_5;
-                    i_5 = (_e672 + 1i);
+                    let _e695 = i_5;
+                    i_5 = (_e695 + 1i);
                 }
             }
-            let _e674 = blockerCount;
-            if (_e674 <= 0f) {
+            let _e697 = blockerCount;
+            if (_e697 <= 0f) {
                 return 1f;
             }
-            let _e677 = projected[2u];
-            let _e678 = blockerSum;
-            let _e679 = blockerCount;
-            let _e683 = cascadeDepth;
-            gap = (max((_e677 - (_e678 / _e679)), 0f) * _e683);
-            let _e685 = spread;
-            let _e686 = gap;
-            let _e688 = cascadeTexel;
-            radius_2 = clamp(((_e685 * _e686) / _e688), 1f, 16f);
+            let _e700 = projected[2u];
+            let _e701 = blockerSum;
+            let _e702 = blockerCount;
+            let _e706 = cascadeDepth;
+            gap = (max((_e700 - (_e701 / _e702)), 0f) * _e706);
+            let _e708 = spread;
+            let _e709 = gap;
+            let _e711 = cascadeTexel;
+            radius_2 = clamp(((_e708 * _e709) / _e711), 1f, 16f);
             i_6 = 0i;
             loop {
-                let _e691 = i_6;
-                if (_e691 < 16i) {
-                    let _e693 = turn_1;
-                    let _e695 = i_6;
-                    param_67 = _e695;
+                let _e714 = i_6;
+                if (_e714 < 16i) {
+                    let _e716 = turn_1;
+                    let _e718 = i_6;
+                    param_67 = _e718;
                     param_68 = 16i;
-                    param_69 = (_e693 + 1f);
-                    let _e696 = VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b((&param_67), (&param_68), (&param_69));
-                    disc_1 = _e696;
-                    let _e697 = bias;
-                    let _e698 = disc_1;
-                    let _e700 = radius_2;
-                    let _e704 = receiverSlope;
-                    tapBias_1 = (_e697 + (max(((length(_e698) * _e700) - 1.5f), 0f) * _e704));
-                    let _e707 = uv_4;
-                    let _e708 = disc_1;
-                    let _e709 = texel_1;
-                    let _e711 = radius_2;
-                    let _e714 = tileLo;
-                    let _e715 = tileHi;
-                    let _e717 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e707 + ((_e708 * _e709) * _e711)), _e714, _e715), 0f);
-                    occluder_2 = _e717.x;
-                    let _e720 = projected[2u];
-                    let _e721 = tapBias_1;
-                    let _e723 = occluder_2;
-                    let _e726 = lit_2;
-                    lit_2 = (_e726 + select(1f, 0f, ((_e720 - _e721) > _e723)));
+                    param_69 = (_e716 + 1f);
+                    let _e719 = VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b((&param_67), (&param_68), (&param_69));
+                    disc_1 = _e719;
+                    let _e720 = bias;
+                    let _e721 = disc_1;
+                    let _e723 = radius_2;
+                    let _e727 = receiverSlope;
+                    tapBias_1 = (_e720 + (max(((length(_e721) * _e723) - 1.5f), 0f) * _e727));
+                    let _e730 = uv_4;
+                    let _e731 = disc_1;
+                    let _e732 = texel_1;
+                    let _e734 = radius_2;
+                    let _e737 = tileLo;
+                    let _e738 = tileHi;
+                    let _e740 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e730 + ((_e731 * _e732) * _e734)), _e737, _e738), 0f);
+                    occluder_2 = _e740.x;
+                    let _e743 = projected[2u];
+                    let _e744 = tapBias_1;
+                    let _e746 = occluder_2;
+                    let _e749 = lit_2;
+                    lit_2 = (_e749 + select(1f, 0f, ((_e743 - _e744) > _e746)));
                     continue;
                 } else {
                     break;
                 }
                 continuing {
-                    let _e728 = i_6;
-                    i_6 = (_e728 + 1i);
+                    let _e751 = i_6;
+                    i_6 = (_e751 + 1i);
                 }
             }
-            let _e730 = lit_2;
-            lit_2 = (_e730 * 0.0625f);
+            let _e753 = lit_2;
+            lit_2 = (_e753 * 0.0625f);
         }
     }
-    let _e732 = lit_2;
-    let _e733 = strength_1;
-    return mix(1f, _e732, clamp(_e733, 0f, 1f));
+    let _e755 = lit_2;
+    let _e756 = strength_1;
+    return mix(1f, _e755, clamp(_e756, 0f, 1f));
 }
 
 fn LightVisibility_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b_i1_u003b(s_3: ptr<function, Surface>, light_2: ptr<function, LightSample>, index: ptr<function, i32>) -> f32 {
@@ -8030,19 +8079,19 @@ fn LightVisibility_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d
     var param_71: LightSample;
     var param_72: i32;
 
-    let _e192 = (*s_3);
-    param_70 = _e192;
-    let _e193 = (*light_2);
-    param_71 = _e193;
-    let _e194 = (*index);
-    param_72 = _e194;
-    let _e195 = ShadowFactor_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b_i1_u003b((&param_70), (&param_71), (&param_72));
-    return _e195;
+    let _e193 = (*s_3);
+    param_70 = _e193;
+    let _e194 = (*light_2);
+    param_71 = _e194;
+    let _e195 = (*index);
+    param_72 = _e195;
+    let _e196 = ShadowFactor_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b_i1_u003b((&param_70), (&param_71), (&param_72));
+    return _e196;
 }
 
 fn LightHasShadow_u0028_i1_u003b(index_1: ptr<function, i32>) -> bool {
-    let _e187 = (*index_1);
-    return (_e187 < 8i);
+    let _e188 = (*index_1);
+    return (_e188 < 8i);
 }
 
 fn PunctualAttenuation_u0028_f1_u003b_f1_u003b(distance_1: ptr<function, f32>, range_4: ptr<function, f32>) -> f32 {
@@ -8050,26 +8099,26 @@ fn PunctualAttenuation_u0028_f1_u003b_f1_u003b(distance_1: ptr<function, f32>, r
     var ratio: f32;
     var window: f32;
 
-    let _e191 = (*distance_1);
     let _e192 = (*distance_1);
-    attenuation = (1f / max((_e191 * _e192), 0.0001f));
-    let _e196 = (*range_4);
-    if (_e196 > 0f) {
-        let _e198 = (*distance_1);
-        let _e199 = (*range_4);
-        ratio = (_e198 / _e199);
-        let _e201 = ratio;
+    let _e193 = (*distance_1);
+    attenuation = (1f / max((_e192 * _e193), 0.0001f));
+    let _e197 = (*range_4);
+    if (_e197 > 0f) {
+        let _e199 = (*distance_1);
+        let _e200 = (*range_4);
+        ratio = (_e199 / _e200);
         let _e202 = ratio;
-        let _e204 = ratio;
-        let _e206 = ratio;
-        window = clamp((1f - (((_e201 * _e202) * _e204) * _e206)), 0f, 1f);
-        let _e210 = window;
+        let _e203 = ratio;
+        let _e205 = ratio;
+        let _e207 = ratio;
+        window = clamp((1f - (((_e202 * _e203) * _e205) * _e207)), 0f, 1f);
         let _e211 = window;
-        let _e213 = attenuation;
-        attenuation = (_e213 * (_e210 * _e211));
+        let _e212 = window;
+        let _e214 = attenuation;
+        attenuation = (_e214 * (_e211 * _e212));
     }
-    let _e215 = attenuation;
-    return _e215;
+    let _e216 = attenuation;
+    return _e216;
 }
 
 fn RectangleClosestPoint_u0028_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b(centre: ptr<function, vec3<f32>>, halfWidth: ptr<function, vec3<f32>>, halfHeight: ptr<function, vec3<f32>>, world_2: ptr<function, vec3<f32>>, mirror: ptr<function, vec3<f32>>) -> vec3<f32> {
@@ -8086,75 +8135,75 @@ fn RectangleClosestPoint_u0028_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b
     var u: f32;
     var v: f32;
 
-    let _e203 = (*halfWidth);
-    let _e204 = (*halfHeight);
-    n_2 = cross(_e203, _e204);
-    let _e206 = n_2;
-    nLen = length(_e206);
-    let _e208 = nLen;
-    if (_e208 < 0.000000000001f) {
-        let _e210 = (*centre);
-        return _e210;
+    let _e204 = (*halfWidth);
+    let _e205 = (*halfHeight);
+    n_2 = cross(_e204, _e205);
+    let _e207 = n_2;
+    nLen = length(_e207);
+    let _e209 = nLen;
+    if (_e209 < 0.000000000001f) {
+        let _e211 = (*centre);
+        return _e211;
     }
-    let _e211 = nLen;
-    let _e212 = n_2;
-    n_2 = (_e212 / vec3(_e211));
-    let _e215 = (*centre);
-    let _e216 = (*world_2);
-    toPlane = (_e215 - _e216);
-    let _e218 = (*mirror);
-    let _e219 = n_2;
-    denom = dot(_e218, _e219);
-    let _e221 = denom;
-    if (abs(_e221) < 0.00001f) {
-        let _e224 = toPlane;
-        let _e225 = n_2;
-        let _e226 = toPlane;
-        let _e227 = n_2;
-        onPlane = (_e224 - (_e225 * dot(_e226, _e227)));
-    } else {
-        let _e231 = toPlane;
-        let _e232 = n_2;
-        let _e234 = denom;
-        t_1 = (dot(_e231, _e232) / _e234);
-        let _e236 = t_1;
-        if (_e236 > 0f) {
-            let _e238 = (*mirror);
-            let _e239 = t_1;
-            local_12 = (_e238 * _e239);
+    let _e212 = nLen;
+    let _e213 = n_2;
+    n_2 = (_e213 / vec3(_e212));
+    let _e216 = (*centre);
+    let _e217 = (*world_2);
+    toPlane = (_e216 - _e217);
+    let _e219 = (*mirror);
+    let _e220 = n_2;
+    denom = dot(_e219, _e220);
+    let _e222 = denom;
+    if (abs(_e222) < 0.00001f) {
+        let _e225 = toPlane;
+        let _e226 = n_2;
+        let _e227 = toPlane;
+        let _e228 = n_2;
+        onPlane = (_e225 - (_e226 * dot(_e227, _e228)));
+    } else {
+        let _e232 = toPlane;
+        let _e233 = n_2;
+        let _e235 = denom;
+        t_1 = (dot(_e232, _e233) / _e235);
+        let _e237 = t_1;
+        if (_e237 > 0f) {
+            let _e239 = (*mirror);
+            let _e240 = t_1;
+            local_12 = (_e239 * _e240);
         } else {
-            let _e241 = toPlane;
-            let _e242 = n_2;
-            let _e243 = toPlane;
-            let _e244 = n_2;
-            local_12 = (_e241 - (_e242 * dot(_e243, _e244)));
+            let _e242 = toPlane;
+            let _e243 = n_2;
+            let _e244 = toPlane;
+            let _e245 = n_2;
+            local_12 = (_e242 - (_e243 * dot(_e244, _e245)));
         }
-        let _e248 = local_12;
-        onPlane = _e248;
+        let _e249 = local_12;
+        onPlane = _e249;
     }
-    let _e249 = onPlane;
-    let _e250 = toPlane;
-    offset_2 = (_e249 - _e250);
-    let _e252 = (*halfWidth);
+    let _e250 = onPlane;
+    let _e251 = toPlane;
+    offset_2 = (_e250 - _e251);
     let _e253 = (*halfWidth);
-    wLen2_ = max(dot(_e252, _e253), 0.000000000001f);
-    let _e256 = (*halfHeight);
+    let _e254 = (*halfWidth);
+    wLen2_ = max(dot(_e253, _e254), 0.000000000001f);
     let _e257 = (*halfHeight);
-    hLen2_ = max(dot(_e256, _e257), 0.000000000001f);
-    let _e260 = offset_2;
-    let _e261 = (*halfWidth);
-    let _e263 = wLen2_;
-    u = clamp((dot(_e260, _e261) / _e263), -1f, 1f);
-    let _e266 = offset_2;
-    let _e267 = (*halfHeight);
-    let _e269 = hLen2_;
-    v = clamp((dot(_e266, _e267) / _e269), -1f, 1f);
-    let _e272 = (*centre);
-    let _e273 = (*halfWidth);
-    let _e274 = u;
-    let _e277 = (*halfHeight);
-    let _e278 = v;
-    return ((_e272 + (_e273 * _e274)) + (_e277 * _e278));
+    let _e258 = (*halfHeight);
+    hLen2_ = max(dot(_e257, _e258), 0.000000000001f);
+    let _e261 = offset_2;
+    let _e262 = (*halfWidth);
+    let _e264 = wLen2_;
+    u = clamp((dot(_e261, _e262) / _e264), -1f, 1f);
+    let _e267 = offset_2;
+    let _e268 = (*halfHeight);
+    let _e270 = hLen2_;
+    v = clamp((dot(_e267, _e268) / _e270), -1f, 1f);
+    let _e273 = (*centre);
+    let _e274 = (*halfWidth);
+    let _e275 = u;
+    let _e278 = (*halfHeight);
+    let _e279 = v;
+    return ((_e273 + (_e274 * _e275)) + (_e278 * _e279));
 }
 
 fn LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b(a_1: ptr<function, vec3<f32>>, b: ptr<function, vec3<f32>>, n_3: ptr<function, vec3<f32>>) -> f32 {
@@ -8165,32 +8214,32 @@ fn LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b(a_1: ptr<function, vec3<f32>>
     var len: f32;
     var local_13: f32;
 
-    let _e195 = (*a_1);
     let _e196 = (*a_1);
-    ua = (_e195 / vec3(max(length(_e196), 0.000000000001f)));
-    let _e201 = (*b);
+    let _e197 = (*a_1);
+    ua = (_e196 / vec3(max(length(_e197), 0.000000000001f)));
     let _e202 = (*b);
-    ub = (_e201 / vec3(max(length(_e202), 0.000000000001f)));
-    let _e207 = ua;
-    let _e208 = ub;
-    angle_1 = acos(clamp(dot(_e207, _e208), -1f, 1f));
-    let _e212 = ua;
-    let _e213 = ub;
-    axis = cross(_e212, _e213);
-    let _e215 = axis;
-    len = length(_e215);
-    let _e217 = len;
-    if (_e217 > 0.000001f) {
-        let _e219 = angle_1;
-        let _e220 = axis;
-        let _e221 = (*n_3);
-        let _e224 = len;
-        local_13 = ((_e219 * dot(_e220, _e221)) / _e224);
+    let _e203 = (*b);
+    ub = (_e202 / vec3(max(length(_e203), 0.000000000001f)));
+    let _e208 = ua;
+    let _e209 = ub;
+    angle_1 = acos(clamp(dot(_e208, _e209), -1f, 1f));
+    let _e213 = ua;
+    let _e214 = ub;
+    axis = cross(_e213, _e214);
+    let _e216 = axis;
+    len = length(_e216);
+    let _e218 = len;
+    if (_e218 > 0.000001f) {
+        let _e220 = angle_1;
+        let _e221 = axis;
+        let _e222 = (*n_3);
+        let _e225 = len;
+        local_13 = ((_e220 * dot(_e221, _e222)) / _e225);
     } else {
         local_13 = 0f;
     }
-    let _e226 = local_13;
-    return _e226;
+    let _e227 = local_13;
+    return _e227;
 }
 
 fn RectangleFormFactor_u0028_vf3_u005b_4_u005d_u003b_vf3_u003b(corners: ptr<function, array<vec3<f32>, 4>>, n_4: ptr<function, vec3<f32>>) -> f32 {
@@ -8221,98 +8270,98 @@ fn RectangleFormFactor_u0028_vf3_u005b_4_u005d_u003b_vf3_u003b(corners: ptr<func
     entry = vec3<f32>(0f, 0f, 0f);
     i_7 = 0i;
     loop {
-        let _e209 = i_7;
-        if (_e209 < 4i) {
-            let _e211 = i_7;
-            let _e213 = (*corners)[_e211];
-            a_2 = _e213;
-            let _e214 = i_7;
-            if (_e214 == 3i) {
+        let _e210 = i_7;
+        if (_e210 < 4i) {
+            let _e212 = i_7;
+            let _e214 = (*corners)[_e212];
+            a_2 = _e214;
+            let _e215 = i_7;
+            if (_e215 == 3i) {
                 local_14 = 0i;
             } else {
-                let _e216 = i_7;
-                local_14 = (_e216 + 1i);
-            }
-            let _e218 = local_14;
-            let _e220 = (*corners)[_e218];
-            b_1 = _e220;
-            let _e221 = a_2;
-            let _e222 = (*n_4);
-            ha = dot(_e221, _e222);
-            let _e224 = b_1;
-            let _e225 = (*n_4);
-            hb = dot(_e224, _e225);
-            let _e227 = ha;
-            let _e228 = hb;
-            d_3 = (_e227 - _e228);
-            let _e230 = a_2;
-            let _e231 = b_1;
-            let _e232 = a_2;
-            let _e234 = d_3;
-            if (abs(_e234) > 0.000000000001f) {
-                let _e237 = ha;
-                let _e238 = d_3;
-                local_15 = (_e237 / _e238);
+                let _e217 = i_7;
+                local_14 = (_e217 + 1i);
+            }
+            let _e219 = local_14;
+            let _e221 = (*corners)[_e219];
+            b_1 = _e221;
+            let _e222 = a_2;
+            let _e223 = (*n_4);
+            ha = dot(_e222, _e223);
+            let _e225 = b_1;
+            let _e226 = (*n_4);
+            hb = dot(_e225, _e226);
+            let _e228 = ha;
+            let _e229 = hb;
+            d_3 = (_e228 - _e229);
+            let _e231 = a_2;
+            let _e232 = b_1;
+            let _e233 = a_2;
+            let _e235 = d_3;
+            if (abs(_e235) > 0.000000000001f) {
+                let _e238 = ha;
+                let _e239 = d_3;
+                local_15 = (_e238 / _e239);
             } else {
                 local_15 = 0f;
             }
-            let _e240 = local_15;
-            q = (_e230 + ((_e231 - _e232) * _e240));
-            let _e243 = ha;
-            aAbove = (_e243 > 0f);
-            let _e245 = hb;
-            bAbove = (_e245 > 0f);
-            let _e247 = aAbove;
-            let _e248 = bAbove;
-            if (_e247 || _e248) {
-                let _e250 = aAbove;
-                let _e251 = a_2;
-                let _e252 = q;
-                let _e255 = bAbove;
-                let _e256 = b_1;
-                let _e257 = q;
-                param_73 = select(_e252, _e251, vec3(_e250));
-                param_74 = select(_e257, _e256, vec3(_e255));
-                let _e260 = (*n_4);
-                param_75 = _e260;
-                let _e261 = LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b((&param_73), (&param_74), (&param_75));
-                local_16 = _e261;
+            let _e241 = local_15;
+            q = (_e231 + ((_e232 - _e233) * _e241));
+            let _e244 = ha;
+            aAbove = (_e244 > 0f);
+            let _e246 = hb;
+            bAbove = (_e246 > 0f);
+            let _e248 = aAbove;
+            let _e249 = bAbove;
+            if (_e248 || _e249) {
+                let _e251 = aAbove;
+                let _e252 = a_2;
+                let _e253 = q;
+                let _e256 = bAbove;
+                let _e257 = b_1;
+                let _e258 = q;
+                param_73 = select(_e253, _e252, vec3(_e251));
+                param_74 = select(_e258, _e257, vec3(_e256));
+                let _e261 = (*n_4);
+                param_75 = _e261;
+                let _e262 = LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b((&param_73), (&param_74), (&param_75));
+                local_16 = _e262;
             } else {
                 local_16 = 0f;
             }
-            let _e262 = local_16;
-            let _e263 = total;
-            total = (_e263 + _e262);
-            let _e265 = aAbove;
-            let _e266 = bAbove;
-            let _e269 = q;
-            let _e270 = exit;
-            exit = select(_e270, _e269, vec3((_e265 && !(_e266))));
-            let _e273 = aAbove;
-            let _e275 = bAbove;
-            let _e277 = q;
-            let _e278 = entry;
-            entry = select(_e278, _e277, vec3((!(_e273) && _e275)));
+            let _e263 = local_16;
+            let _e264 = total;
+            total = (_e264 + _e263);
+            let _e266 = aAbove;
+            let _e267 = bAbove;
+            let _e270 = q;
+            let _e271 = exit;
+            exit = select(_e271, _e270, vec3((_e266 && !(_e267))));
+            let _e274 = aAbove;
+            let _e276 = bAbove;
+            let _e278 = q;
+            let _e279 = entry;
+            entry = select(_e279, _e278, vec3((!(_e274) && _e276)));
             continue;
         } else {
             break;
         }
         continuing {
-            let _e281 = i_7;
-            i_7 = (_e281 + 1i);
-        }
-    }
-    let _e283 = exit;
-    param_76 = _e283;
-    let _e284 = entry;
-    param_77 = _e284;
-    let _e285 = (*n_4);
-    param_78 = _e285;
-    let _e286 = LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b((&param_76), (&param_77), (&param_78));
-    let _e287 = total;
-    total = (_e287 + _e286);
-    let _e289 = total;
-    return max((-(_e289) * 0.5f), 0f);
+            let _e282 = i_7;
+            i_7 = (_e282 + 1i);
+        }
+    }
+    let _e284 = exit;
+    param_76 = _e284;
+    let _e285 = entry;
+    param_77 = _e285;
+    let _e286 = (*n_4);
+    param_78 = _e286;
+    let _e287 = LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b((&param_76), (&param_77), (&param_78));
+    let _e288 = total;
+    total = (_e288 + _e287);
+    let _e290 = total;
+    return max((-(_e290) * 0.5f), 0f);
 }
 
 fn LightListLane_u0028_vf4_u003b_i1_u003b(four: ptr<function, vec4<f32>>, slot_1: ptr<function, i32>) -> f32 {
@@ -8321,91 +8370,91 @@ fn LightListLane_u0028_vf4_u003b_i1_u003b(four: ptr<function, vec4<f32>>, slot_1
     var local_18: f32;
     var local_19: f32;
 
-    let _e192 = (*slot_1);
     let _e193 = (*slot_1);
-    lane = (_e192 - ((_e193 / 4i) * 4i));
-    let _e197 = lane;
-    if (_e197 == 0i) {
-        let _e200 = (*four)[0u];
-        local_17 = _e200;
-    } else {
-        let _e201 = lane;
-        if (_e201 == 1i) {
-            let _e204 = (*four)[1u];
-            local_18 = _e204;
+    let _e194 = (*slot_1);
+    lane = (_e193 - ((_e194 / 4i) * 4i));
+    let _e198 = lane;
+    if (_e198 == 0i) {
+        let _e201 = (*four)[0u];
+        local_17 = _e201;
+    } else {
+        let _e202 = lane;
+        if (_e202 == 1i) {
+            let _e205 = (*four)[1u];
+            local_18 = _e205;
         } else {
-            let _e205 = lane;
-            if (_e205 == 2i) {
-                let _e208 = (*four)[2u];
-                local_19 = _e208;
+            let _e206 = lane;
+            if (_e206 == 2i) {
+                let _e209 = (*four)[2u];
+                local_19 = _e209;
             } else {
-                let _e210 = (*four)[3u];
-                local_19 = _e210;
+                let _e211 = (*four)[3u];
+                local_19 = _e211;
             }
-            let _e211 = local_19;
-            local_18 = _e211;
+            let _e212 = local_19;
+            local_18 = _e212;
         }
-        let _e212 = local_18;
-        local_17 = _e212;
+        let _e213 = local_18;
+        local_17 = _e213;
     }
-    let _e213 = local_17;
-    return _e213;
+    let _e214 = local_17;
+    return _e214;
 }
 
 fn LightListScale_u0028_i1_u003b(slot_2: ptr<function, i32>) -> f32 {
     var param_79: vec4<f32>;
     var param_80: i32;
 
-    let _e189 = (*slot_2);
-    let _e193 = light_list_info.scales[(_e189 / 4i)];
-    param_79 = _e193;
-    let _e194 = (*slot_2);
-    param_80 = _e194;
-    let _e195 = LightListLane_u0028_vf4_u003b_i1_u003b((&param_79), (&param_80));
-    return _e195;
+    let _e190 = (*slot_2);
+    let _e194 = light_list_info.scales[(_e190 / 4i)];
+    param_79 = _e194;
+    let _e195 = (*slot_2);
+    param_80 = _e195;
+    let _e196 = LightListLane_u0028_vf4_u003b_i1_u003b((&param_79), (&param_80));
+    return _e196;
 }
 
 fn InSlots_u0028_f1_u003b(row: ptr<function, f32>) -> bool {
     var a_3: vec4<f32>;
     var b_2: vec4<f32>;
 
-    let _e191 = light_list_info.slot_rows[0i];
-    let _e192 = (*row);
-    a_3 = abs((_e191 - vec4(_e192)));
-    let _e198 = light_list_info.slot_rows[1i];
-    let _e199 = (*row);
-    b_2 = abs((_e198 - vec4(_e199)));
-    let _e204 = a_3[0u];
-    let _e206 = a_3[1u];
-    let _e209 = a_3[2u];
-    let _e211 = a_3[3u];
-    let _e215 = b_2[0u];
-    let _e217 = b_2[1u];
-    let _e220 = b_2[2u];
-    let _e222 = b_2[3u];
-    return (min(min(min(_e204, _e206), min(_e209, _e211)), min(min(_e215, _e217), min(_e220, _e222))) < 0.5f);
+    let _e192 = light_list_info.slot_rows[0i];
+    let _e193 = (*row);
+    a_3 = abs((_e192 - vec4(_e193)));
+    let _e199 = light_list_info.slot_rows[1i];
+    let _e200 = (*row);
+    b_2 = abs((_e199 - vec4(_e200)));
+    let _e205 = a_3[0u];
+    let _e207 = a_3[1u];
+    let _e210 = a_3[2u];
+    let _e212 = a_3[3u];
+    let _e216 = b_2[0u];
+    let _e218 = b_2[1u];
+    let _e221 = b_2[2u];
+    let _e223 = b_2[3u];
+    return (min(min(min(_e205, _e207), min(_e210, _e212)), min(min(_e216, _e218), min(_e221, _e223))) < 0.5f);
 }
 
 fn LightListRow_u0028_i1_u003b(slot_3: ptr<function, i32>) -> f32 {
     var param_81: vec4<f32>;
     var param_82: i32;
 
-    let _e189 = (*slot_3);
-    let _e193 = light_list_info.indices[(_e189 / 4i)];
-    param_81 = _e193;
-    let _e194 = (*slot_3);
-    param_82 = _e194;
-    let _e195 = LightListLane_u0028_vf4_u003b_i1_u003b((&param_81), (&param_82));
-    return _e195;
+    let _e190 = (*slot_3);
+    let _e194 = light_list_info.indices[(_e190 / 4i)];
+    param_81 = _e194;
+    let _e195 = (*slot_3);
+    param_82 = _e195;
+    let _e196 = LightListLane_u0028_vf4_u003b_i1_u003b((&param_81), (&param_82));
+    return _e196;
 }
 
 fn LightListTexel_u0028_f1_u003b_f1_u003b(texel_2: ptr<function, f32>, row_1: ptr<function, f32>) -> vec4<f32> {
-    let _e188 = (*texel_2);
-    let _e192 = light_list_info.list[1u];
-    let _e194 = (*row_1);
-    let _e198 = light_list_info.list[2u];
-    let _e201 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>(((_e188 + 0.5f) * _e192), ((_e194 + 0.5f) * _e198)), 0f);
-    return _e201;
+    let _e189 = (*texel_2);
+    let _e193 = light_list_info.list[1u];
+    let _e195 = (*row_1);
+    let _e199 = light_list_info.list[2u];
+    let _e202 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>(((_e189 + 0.5f) * _e193), ((_e195 + 0.5f) * _e199)), 0f);
+    return _e202;
 }
 
 fn ClusterRow_u0028_i1_u003b(slot_4: ptr<function, i32>) -> f32 {
@@ -8419,35 +8468,35 @@ fn ClusterRow_u0028_i1_u003b(slot_4: ptr<function, i32>) -> f32 {
     var param_85: vec4<f32>;
     var param_86: i32;
 
-    let _e196 = g_cluster_offset;
-    let _e197 = (*slot_4);
-    entry_1 = (_e196 + f32(_e197));
-    let _e200 = entry_1;
-    row_2 = floor((_e200 / 16f));
-    let _e203 = entry_1;
-    let _e204 = row_2;
-    within = (_e203 - (_e204 * 16f));
-    let _e207 = within;
-    texel_3 = floor((_e207 / 4f));
-    let _e212 = light_list_info.cluster_depth[3u];
-    let _e213 = row_2;
-    let _e215 = texel_3;
-    param_83 = _e215;
-    param_84 = (_e212 + _e213);
-    let _e216 = LightListTexel_u0028_f1_u003b_f1_u003b((&param_83), (&param_84));
-    four_1 = _e216;
-    let _e217 = within;
-    let _e218 = texel_3;
-    let _e223 = four_1;
-    param_85 = _e223;
-    param_86 = i32(((_e217 - (_e218 * 4f)) + 0.5f));
-    let _e224 = LightListLane_u0028_vf4_u003b_i1_u003b((&param_85), (&param_86));
-    return _e224;
+    let _e197 = g_cluster_offset;
+    let _e198 = (*slot_4);
+    entry_1 = (_e197 + f32(_e198));
+    let _e201 = entry_1;
+    row_2 = floor((_e201 / 16f));
+    let _e204 = entry_1;
+    let _e205 = row_2;
+    within = (_e204 - (_e205 * 16f));
+    let _e208 = within;
+    texel_3 = floor((_e208 / 4f));
+    let _e213 = light_list_info.cluster_depth[3u];
+    let _e214 = row_2;
+    let _e216 = texel_3;
+    param_83 = _e216;
+    param_84 = (_e213 + _e214);
+    let _e217 = LightListTexel_u0028_f1_u003b_f1_u003b((&param_83), (&param_84));
+    four_1 = _e217;
+    let _e218 = within;
+    let _e219 = texel_3;
+    let _e224 = four_1;
+    param_85 = _e224;
+    param_86 = i32(((_e218 - (_e219 * 4f)) + 0.5f));
+    let _e225 = LightListLane_u0028_vf4_u003b_i1_u003b((&param_85), (&param_86));
+    return _e225;
 }
 
 fn Clustered_u0028_() -> bool {
-    let _e188 = light_list_info.cluster_grid[3u];
-    return (_e188 > 0.5f);
+    let _e189 = light_list_info.cluster_grid[3u];
+    return (_e189 > 0.5f);
 }
 
 fn SampleLight_u0028_i1_u003b_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(index_2: ptr<function, i32>, s_4: ptr<function, Surface>) -> LightSample {
@@ -8503,264 +8552,264 @@ fn SampleLight_u0028_i1_u003b_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_
 
     light_3.integrated = 0f;
     light_3.ltc = vec3<f32>(0f, 0f, 0f);
-    let _e239 = (*index_2);
-    if (_e239 < 8i) {
-        let _e241 = (*index_2);
-        let _e244 = frag_info.light_position[_e241];
-        position = _e244;
-        let _e245 = (*index_2);
-        let _e248 = frag_info.light_color[_e245];
-        color_1 = _e248;
-        let _e249 = (*index_2);
-        let _e252 = frag_info.light_direction[_e249];
-        direction = _e252;
-        let _e253 = (*index_2);
-        let _e256 = frag_info.light_cone[_e253];
-        cone = _e256;
-    } else {
-        let _e257 = (*index_2);
-        slot_5 = (_e257 - 8i);
-        let _e259 = Clustered_u0028_();
-        clustered = _e259;
-        let _e260 = clustered;
-        if _e260 {
-            let _e261 = slot_5;
-            param_87 = _e261;
-            let _e262 = ClusterRow_u0028_i1_u003b((&param_87));
-            local_20 = _e262;
+    let _e240 = (*index_2);
+    if (_e240 < 8i) {
+        let _e242 = (*index_2);
+        let _e245 = frag_info.light_position[_e242];
+        position = _e245;
+        let _e246 = (*index_2);
+        let _e249 = frag_info.light_color[_e246];
+        color_1 = _e249;
+        let _e250 = (*index_2);
+        let _e253 = frag_info.light_direction[_e250];
+        direction = _e253;
+        let _e254 = (*index_2);
+        let _e257 = frag_info.light_cone[_e254];
+        cone = _e257;
+    } else {
+        let _e258 = (*index_2);
+        slot_5 = (_e258 - 8i);
+        let _e260 = Clustered_u0028_();
+        clustered = _e260;
+        let _e261 = clustered;
+        if _e261 {
+            let _e262 = slot_5;
+            param_87 = _e262;
+            let _e263 = ClusterRow_u0028_i1_u003b((&param_87));
+            local_20 = _e263;
         } else {
-            let _e263 = slot_5;
-            param_88 = _e263;
-            let _e264 = LightListRow_u0028_i1_u003b((&param_88));
-            local_20 = _e264;
+            let _e264 = slot_5;
+            param_88 = _e264;
+            let _e265 = LightListRow_u0028_i1_u003b((&param_88));
+            local_20 = _e265;
         }
-        let _e265 = local_20;
-        listRow = _e265;
-        let _e266 = listRow;
-        let _e270 = light_list_info.list[2u];
-        v_1 = ((_e266 + 0.5f) * _e270);
-        let _e274 = light_list_info.list[1u];
-        u_1 = _e274;
-        let _e275 = u_1;
-        let _e277 = v_1;
-        let _e279 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((0.5f * _e275), _e277), 0f);
-        position = _e279;
-        let _e280 = u_1;
-        let _e282 = v_1;
-        let _e284 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((1.5f * _e280), _e282), 0f);
-        color_1 = _e284;
-        let _e285 = u_1;
-        let _e287 = v_1;
-        let _e289 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((2.5f * _e285), _e287), 0f);
-        direction = _e289;
-        let _e290 = u_1;
-        let _e292 = v_1;
-        let _e294 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((3.5f * _e290), _e292), 0f);
-        cone = _e294;
-        let _e295 = clustered;
-        if _e295 {
-            let _e296 = listRow;
-            param_89 = _e296;
-            let _e297 = InSlots_u0028_f1_u003b((&param_89));
-            local_21 = select(1f, 0f, _e297);
+        let _e266 = local_20;
+        listRow = _e266;
+        let _e267 = listRow;
+        let _e271 = light_list_info.list[2u];
+        v_1 = ((_e267 + 0.5f) * _e271);
+        let _e275 = light_list_info.list[1u];
+        u_1 = _e275;
+        let _e276 = u_1;
+        let _e278 = v_1;
+        let _e280 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((0.5f * _e276), _e278), 0f);
+        position = _e280;
+        let _e281 = u_1;
+        let _e283 = v_1;
+        let _e285 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((1.5f * _e281), _e283), 0f);
+        color_1 = _e285;
+        let _e286 = u_1;
+        let _e288 = v_1;
+        let _e290 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((2.5f * _e286), _e288), 0f);
+        direction = _e290;
+        let _e291 = u_1;
+        let _e293 = v_1;
+        let _e295 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((3.5f * _e291), _e293), 0f);
+        cone = _e295;
+        let _e296 = clustered;
+        if _e296 {
+            let _e297 = listRow;
+            param_89 = _e297;
+            let _e298 = InSlots_u0028_f1_u003b((&param_89));
+            local_21 = select(1f, 0f, _e298);
         } else {
-            let _e299 = slot_5;
-            param_90 = _e299;
-            let _e300 = LightListScale_u0028_i1_u003b((&param_90));
-            local_21 = _e300;
-        }
-        let _e301 = local_21;
-        let _e303 = color_1[3u];
-        color_1[3u] = (_e303 * _e301);
-    }
-    let _e307 = position[3u];
-    type_39 = _e307;
-    let _e308 = type_39;
-    if (_e308 > 2.5f) {
-        let _e310 = direction;
-        halfWidth_1 = _e310.xyz;
-        let _e312 = cone;
-        halfHeight_1 = _e312.xyz;
-        let _e314 = position;
-        let _e316 = v_world_position_1;
-        toCentre = (_e314.xyz - _e316);
-        let _e318 = toCentre;
-        let _e319 = halfWidth_1;
-        let _e321 = halfHeight_1;
-        corners_1[0i] = ((_e318 - _e319) - _e321);
-        let _e324 = toCentre;
-        let _e325 = halfWidth_1;
-        let _e327 = halfHeight_1;
-        corners_1[1i] = ((_e324 + _e325) - _e327);
-        let _e330 = toCentre;
-        let _e331 = halfWidth_1;
-        let _e333 = halfHeight_1;
-        corners_1[2i] = ((_e330 + _e331) + _e333);
-        let _e336 = toCentre;
-        let _e337 = halfWidth_1;
-        let _e339 = halfHeight_1;
-        corners_1[3i] = ((_e336 - _e337) + _e339);
-        let _e342 = toCentre;
-        let _e343 = halfWidth_1;
-        let _e344 = halfHeight_1;
-        behind = (dot(_e342, cross(_e343, _e344)) >= 0f);
-        let _e348 = behind;
-        if _e348 {
+            let _e300 = slot_5;
+            param_90 = _e300;
+            let _e301 = LightListScale_u0028_i1_u003b((&param_90));
+            local_21 = _e301;
+        }
+        let _e302 = local_21;
+        let _e304 = color_1[3u];
+        color_1[3u] = (_e304 * _e302);
+    }
+    let _e308 = position[3u];
+    type_39 = _e308;
+    let _e309 = type_39;
+    if (_e309 > 2.5f) {
+        let _e311 = direction;
+        halfWidth_1 = _e311.xyz;
+        let _e313 = cone;
+        halfHeight_1 = _e313.xyz;
+        let _e315 = position;
+        let _e317 = v_world_position_1;
+        toCentre = (_e315.xyz - _e317);
+        let _e319 = toCentre;
+        let _e320 = halfWidth_1;
+        let _e322 = halfHeight_1;
+        corners_1[0i] = ((_e319 - _e320) - _e322);
+        let _e325 = toCentre;
+        let _e326 = halfWidth_1;
+        let _e328 = halfHeight_1;
+        corners_1[1i] = ((_e325 + _e326) - _e328);
+        let _e331 = toCentre;
+        let _e332 = halfWidth_1;
+        let _e334 = halfHeight_1;
+        corners_1[2i] = ((_e331 + _e332) + _e334);
+        let _e337 = toCentre;
+        let _e338 = halfWidth_1;
+        let _e340 = halfHeight_1;
+        corners_1[3i] = ((_e337 - _e338) + _e340);
+        let _e343 = toCentre;
+        let _e344 = halfWidth_1;
+        let _e345 = halfHeight_1;
+        behind = (dot(_e343, cross(_e344, _e345)) >= 0f);
+        let _e349 = behind;
+        if _e349 {
             local_22 = 0f;
         } else {
-            let _e349 = corners_1;
-            param_91 = _e349;
-            let _e351 = (*s_4).n;
-            param_92 = _e351;
-            let _e352 = RectangleFormFactor_u0028_vf3_u005b_4_u005d_u003b_vf3_u003b((&param_91), (&param_92));
-            local_22 = _e352;
-        }
-        let _e353 = local_22;
-        formFactor = _e353;
-        let _e354 = halfWidth_1;
-        let _e355 = halfHeight_1;
-        area = (length(cross(_e354, _e355)) * 4f);
-        let _e359 = area;
-        if (_e359 > 0.000000001f) {
-            let _e361 = area;
-            local_23 = (1f / _e361);
+            let _e350 = corners_1;
+            param_91 = _e350;
+            let _e352 = (*s_4).n;
+            param_92 = _e352;
+            let _e353 = RectangleFormFactor_u0028_vf3_u005b_4_u005d_u003b_vf3_u003b((&param_91), (&param_92));
+            local_22 = _e353;
+        }
+        let _e354 = local_22;
+        formFactor = _e354;
+        let _e355 = halfWidth_1;
+        let _e356 = halfHeight_1;
+        area = (length(cross(_e355, _e356)) * 4f);
+        let _e360 = area;
+        if (_e360 > 0.000000001f) {
+            let _e362 = area;
+            local_23 = (1f / _e362);
         } else {
             local_23 = 0f;
         }
-        let _e363 = local_23;
-        radiance = _e363;
-        let _e364 = toCentre;
-        distance_2 = length(_e364);
-        let _e367 = direction[3u];
-        if (_e367 > 0f) {
-            let _e369 = distance_2;
-            let _e371 = direction[3u];
-            ratio_1 = (_e369 / _e371);
-            let _e373 = ratio_1;
+        let _e364 = local_23;
+        radiance = _e364;
+        let _e365 = toCentre;
+        distance_2 = length(_e365);
+        let _e368 = direction[3u];
+        if (_e368 > 0f) {
+            let _e370 = distance_2;
+            let _e372 = direction[3u];
+            ratio_1 = (_e370 / _e372);
             let _e374 = ratio_1;
-            let _e376 = ratio_1;
-            let _e378 = ratio_1;
-            window_1 = clamp((1f - (((_e373 * _e374) * _e376) * _e378)), 0f, 1f);
-            let _e382 = window_1;
+            let _e375 = ratio_1;
+            let _e377 = ratio_1;
+            let _e379 = ratio_1;
+            window_1 = clamp((1f - (((_e374 * _e375) * _e377) * _e379)), 0f, 1f);
             let _e383 = window_1;
-            let _e385 = radiance;
-            radiance = (_e385 * (_e382 * _e383));
-        }
-        let _e388 = (*s_4).v;
-        let _e391 = (*s_4).n;
-        mirror_1 = reflect(-(_e388), _e391);
-        let _e393 = position;
-        param_93 = _e393.xyz;
-        let _e395 = halfWidth_1;
-        param_94 = _e395;
-        let _e396 = halfHeight_1;
-        param_95 = _e396;
-        let _e397 = v_world_position_1;
-        param_96 = _e397;
-        let _e398 = mirror_1;
-        param_97 = _e398;
-        let _e399 = RectangleClosestPoint_u0028_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b((&param_93), (&param_94), (&param_95), (&param_96), (&param_97));
-        representative = _e399;
-        let _e400 = representative;
-        let _e401 = v_world_position_1;
-        toPoint = (_e400 - _e401);
-        let _e403 = toPoint;
-        pointDistance = length(_e403);
-        let _e405 = pointDistance;
-        if (_e405 > 0.000001f) {
-            let _e407 = toPoint;
-            let _e408 = pointDistance;
-            local_24 = (_e407 / vec3(_e408));
+            let _e384 = window_1;
+            let _e386 = radiance;
+            radiance = (_e386 * (_e383 * _e384));
+        }
+        let _e389 = (*s_4).v;
+        let _e392 = (*s_4).n;
+        mirror_1 = reflect(-(_e389), _e392);
+        let _e394 = position;
+        param_93 = _e394.xyz;
+        let _e396 = halfWidth_1;
+        param_94 = _e396;
+        let _e397 = halfHeight_1;
+        param_95 = _e397;
+        let _e398 = v_world_position_1;
+        param_96 = _e398;
+        let _e399 = mirror_1;
+        param_97 = _e399;
+        let _e400 = RectangleClosestPoint_u0028_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b((&param_93), (&param_94), (&param_95), (&param_96), (&param_97));
+        representative = _e400;
+        let _e401 = representative;
+        let _e402 = v_world_position_1;
+        toPoint = (_e401 - _e402);
+        let _e404 = toPoint;
+        pointDistance = length(_e404);
+        let _e406 = pointDistance;
+        if (_e406 > 0.000001f) {
+            let _e408 = toPoint;
+            let _e409 = pointDistance;
+            local_24 = (_e408 / vec3(_e409));
         } else {
-            let _e412 = (*s_4).n;
-            local_24 = _e412;
-        }
-        let _e413 = local_24;
-        light_3.l = _e413;
-        let _e416 = light_3.l;
-        let _e418 = (*s_4).v;
-        light_3.h = normalize((_e416 + _e418));
-        let _e422 = formFactor;
-        light_3.n_dot_l = _e422;
-        let _e425 = (*s_4).n;
-        let _e427 = light_3.h;
-        light_3.n_dot_h = max(dot(_e425, _e427), 0f);
-        let _e432 = (*s_4).v;
-        let _e434 = light_3.h;
-        light_3.v_dot_h = max(dot(_e432, _e434), 0f);
-        let _e438 = color_1;
-        let _e441 = color_1[3u];
-        let _e443 = radiance;
-        light_3.radiance = ((_e438.xyz * _e441) * _e443);
-        let _e446 = light_3;
-        return _e446;
-    }
-    let _e447 = direction;
-    aim = normalize(_e447.xyz);
+            let _e413 = (*s_4).n;
+            local_24 = _e413;
+        }
+        let _e414 = local_24;
+        light_3.l = _e414;
+        let _e417 = light_3.l;
+        let _e419 = (*s_4).v;
+        light_3.h = normalize((_e417 + _e419));
+        let _e423 = formFactor;
+        light_3.n_dot_l = _e423;
+        let _e426 = (*s_4).n;
+        let _e428 = light_3.h;
+        light_3.n_dot_h = max(dot(_e426, _e428), 0f);
+        let _e433 = (*s_4).v;
+        let _e435 = light_3.h;
+        light_3.v_dot_h = max(dot(_e433, _e435), 0f);
+        let _e439 = color_1;
+        let _e442 = color_1[3u];
+        let _e444 = radiance;
+        light_3.radiance = ((_e439.xyz * _e442) * _e444);
+        let _e447 = light_3;
+        return _e447;
+    }
+    let _e448 = direction;
+    aim = normalize(_e448.xyz);
     attenuation_1 = 1f;
-    let _e450 = type_39;
-    if (_e450 < 0.5f) {
-        let _e452 = aim;
-        light_3.l = -(_e452);
-    } else {
-        let _e455 = position;
-        let _e457 = v_world_position_1;
-        toLight_1 = (_e455.xyz - _e457);
-        let _e459 = toLight_1;
-        distance_3 = length(_e459);
-        let _e461 = distance_3;
-        if (_e461 < 0.000001f) {
-            let _e464 = (*s_4).n;
-            light_3.l = _e464;
-            let _e467 = (*s_4).n;
-            light_3.h = _e467;
+    let _e451 = type_39;
+    if (_e451 < 0.5f) {
+        let _e453 = aim;
+        light_3.l = -(_e453);
+    } else {
+        let _e456 = position;
+        let _e458 = v_world_position_1;
+        toLight_1 = (_e456.xyz - _e458);
+        let _e460 = toLight_1;
+        distance_3 = length(_e460);
+        let _e462 = distance_3;
+        if (_e462 < 0.000001f) {
+            let _e465 = (*s_4).n;
+            light_3.l = _e465;
+            let _e468 = (*s_4).n;
+            light_3.h = _e468;
             light_3.radiance = vec3<f32>(0f, 0f, 0f);
             light_3.n_dot_l = 0f;
             light_3.n_dot_h = 0f;
             light_3.v_dot_h = 0f;
-            let _e473 = light_3;
-            return _e473;
-        }
-        let _e474 = toLight_1;
-        let _e475 = distance_3;
-        light_3.l = (_e474 / vec3(_e475));
-        let _e479 = distance_3;
-        param_98 = _e479;
-        let _e481 = direction[3u];
-        param_99 = _e481;
-        let _e482 = PunctualAttenuation_u0028_f1_u003b_f1_u003b((&param_98), (&param_99));
-        attenuation_1 = _e482;
-        let _e483 = type_39;
-        if (_e483 > 1.5f) {
-            let _e485 = aim;
-            let _e487 = light_3.l;
-            cosAngle = dot(_e485, -(_e487));
-            let _e490 = cosAngle;
-            let _e492 = cone[1u];
-            let _e495 = cone[0u];
-            let _e497 = cone[1u];
-            let _e501 = attenuation_1;
-            attenuation_1 = (_e501 * clamp(((_e490 - _e492) / (_e495 - _e497)), 0f, 1f));
-        }
-    }
-    let _e504 = light_3.l;
-    let _e506 = (*s_4).v;
-    light_3.h = normalize((_e504 + _e506));
-    let _e511 = (*s_4).n;
-    let _e513 = light_3.l;
-    light_3.n_dot_l = max(dot(_e511, _e513), 0f);
-    let _e518 = (*s_4).n;
-    let _e520 = light_3.h;
-    light_3.n_dot_h = max(dot(_e518, _e520), 0f);
-    let _e525 = (*s_4).v;
-    let _e527 = light_3.h;
-    light_3.v_dot_h = max(dot(_e525, _e527), 0f);
-    let _e531 = color_1;
-    let _e534 = color_1[3u];
-    let _e536 = attenuation_1;
-    light_3.radiance = ((_e531.xyz * _e534) * _e536);
-    let _e539 = light_3;
-    return _e539;
+            let _e474 = light_3;
+            return _e474;
+        }
+        let _e475 = toLight_1;
+        let _e476 = distance_3;
+        light_3.l = (_e475 / vec3(_e476));
+        let _e480 = distance_3;
+        param_98 = _e480;
+        let _e482 = direction[3u];
+        param_99 = _e482;
+        let _e483 = PunctualAttenuation_u0028_f1_u003b_f1_u003b((&param_98), (&param_99));
+        attenuation_1 = _e483;
+        let _e484 = type_39;
+        if (_e484 > 1.5f) {
+            let _e486 = aim;
+            let _e488 = light_3.l;
+            cosAngle = dot(_e486, -(_e488));
+            let _e491 = cosAngle;
+            let _e493 = cone[1u];
+            let _e496 = cone[0u];
+            let _e498 = cone[1u];
+            let _e502 = attenuation_1;
+            attenuation_1 = (_e502 * clamp(((_e491 - _e493) / (_e496 - _e498)), 0f, 1f));
+        }
+    }
+    let _e505 = light_3.l;
+    let _e507 = (*s_4).v;
+    light_3.h = normalize((_e505 + _e507));
+    let _e512 = (*s_4).n;
+    let _e514 = light_3.l;
+    light_3.n_dot_l = max(dot(_e512, _e514), 0f);
+    let _e519 = (*s_4).n;
+    let _e521 = light_3.h;
+    light_3.n_dot_h = max(dot(_e519, _e521), 0f);
+    let _e526 = (*s_4).v;
+    let _e528 = light_3.h;
+    light_3.v_dot_h = max(dot(_e526, _e528), 0f);
+    let _e532 = color_1;
+    let _e535 = color_1[3u];
+    let _e537 = attenuation_1;
+    light_3.radiance = ((_e532.xyz * _e535) * _e537);
+    let _e540 = light_3;
+    return _e540;
 }
 
 fn FindCluster_u0028_vf3_u003b(world_3: ptr<function, vec3<f32>>) {
@@ -8778,58 +8827,58 @@ fn FindCluster_u0028_vf3_u003b(world_3: ptr<function, vec3<f32>>) {
     var param_100: f32;
     var param_101: f32;
 
-    let _e201 = light_list_info.cluster_view_projection;
-    let _e202 = (*world_3);
-    clip_1 = (_e201 * vec4<f32>(_e202.x, _e202.y, _e202.z, 1f));
-    let _e208 = clip_1;
-    let _e211 = clip_1[3u];
-    ndc_1 = (_e208.xy / vec2(max(_e211, 0.000001f)));
-    let _e216 = light_list_info.cluster_grid;
-    grid = _e216.xyz;
-    let _e220 = light_list_info.cluster_depth[0u];
-    near_1 = _e220;
-    let _e222 = ndc_1[0u];
-    let _e226 = grid[0u];
-    let _e230 = grid[0u];
-    tx = clamp(floor((((_e222 * 0.5f) + 0.5f) * _e226)), 0f, (_e230 - 1f));
-    let _e234 = ndc_1[1u];
-    let _e238 = grid[1u];
-    let _e242 = grid[1u];
-    ty = clamp(floor((((_e234 * 0.5f) + 0.5f) * _e238)), 0f, (_e242 - 1f));
-    let _e246 = clip_1[3u];
-    let _e247 = near_1;
-    if (_e246 <= _e247) {
+    let _e202 = light_list_info.cluster_view_projection;
+    let _e203 = (*world_3);
+    clip_1 = (_e202 * vec4<f32>(_e203.x, _e203.y, _e203.z, 1f));
+    let _e209 = clip_1;
+    let _e212 = clip_1[3u];
+    ndc_1 = (_e209.xy / vec2(max(_e212, 0.000001f)));
+    let _e217 = light_list_info.cluster_grid;
+    grid = _e217.xyz;
+    let _e221 = light_list_info.cluster_depth[0u];
+    near_1 = _e221;
+    let _e223 = ndc_1[0u];
+    let _e227 = grid[0u];
+    let _e231 = grid[0u];
+    tx = clamp(floor((((_e223 * 0.5f) + 0.5f) * _e227)), 0f, (_e231 - 1f));
+    let _e235 = ndc_1[1u];
+    let _e239 = grid[1u];
+    let _e243 = grid[1u];
+    ty = clamp(floor((((_e235 * 0.5f) + 0.5f) * _e239)), 0f, (_e243 - 1f));
+    let _e247 = clip_1[3u];
+    let _e248 = near_1;
+    if (_e247 <= _e248) {
         local_25 = 0f;
     } else {
-        let _e250 = clip_1[3u];
-        let _e251 = near_1;
-        let _e256 = light_list_info.cluster_depth[1u];
-        let _e260 = grid[2u];
-        local_25 = clamp(floor((log((_e250 / _e251)) * _e256)), 0f, (_e260 - 1f));
-    }
-    let _e263 = local_25;
-    tz = _e263;
-    let _e264 = tx;
-    let _e265 = ty;
-    let _e267 = grid[0u];
-    let _e270 = tz;
-    let _e272 = grid[0u];
-    let _e275 = grid[1u];
-    cell = ((_e264 + (_e265 * _e267)) + ((_e270 * _e272) * _e275));
-    let _e278 = cell;
-    row_3 = floor((_e278 / 4f));
-    let _e281 = cell;
-    let _e282 = row_3;
-    let _e287 = light_list_info.cluster_depth[2u];
-    let _e288 = row_3;
-    param_100 = (_e281 - (_e282 * 4f));
-    param_101 = (_e287 + _e288);
-    let _e290 = LightListTexel_u0028_f1_u003b_f1_u003b((&param_100), (&param_101));
-    header = _e290;
-    let _e292 = header[0u];
-    g_cluster_offset = _e292;
-    let _e294 = header[1u];
-    g_cluster_count = _e294;
+        let _e251 = clip_1[3u];
+        let _e252 = near_1;
+        let _e257 = light_list_info.cluster_depth[1u];
+        let _e261 = grid[2u];
+        local_25 = clamp(floor((log((_e251 / _e252)) * _e257)), 0f, (_e261 - 1f));
+    }
+    let _e264 = local_25;
+    tz = _e264;
+    let _e265 = tx;
+    let _e266 = ty;
+    let _e268 = grid[0u];
+    let _e271 = tz;
+    let _e273 = grid[0u];
+    let _e276 = grid[1u];
+    cell = ((_e265 + (_e266 * _e268)) + ((_e271 * _e273) * _e276));
+    let _e279 = cell;
+    row_3 = floor((_e279 / 4f));
+    let _e282 = cell;
+    let _e283 = row_3;
+    let _e288 = light_list_info.cluster_depth[2u];
+    let _e289 = row_3;
+    param_100 = (_e282 - (_e283 * 4f));
+    param_101 = (_e288 + _e289);
+    let _e291 = LightListTexel_u0028_f1_u003b_f1_u003b((&param_100), (&param_101));
+    header = _e291;
+    let _e293 = header[0u];
+    g_cluster_offset = _e293;
+    let _e295 = header[1u];
+    g_cluster_count = _e295;
     return;
 }
 
@@ -8837,19 +8886,19 @@ fn LightCount_u0028_() -> i32 {
     var tail: f32;
     var param_102: vec3<f32>;
 
-    let _e190 = light_list_info.list[0u];
-    tail = _e190;
-    let _e191 = Clustered_u0028_();
-    if _e191 {
-        let _e192 = v_world_position_1;
-        param_102 = _e192;
+    let _e191 = light_list_info.list[0u];
+    tail = _e191;
+    let _e192 = Clustered_u0028_();
+    if _e192 {
+        let _e193 = v_world_position_1;
+        param_102 = _e193;
         FindCluster_u0028_vf3_u003b((&param_102));
-        let _e193 = g_cluster_count;
-        tail = _e193;
+        let _e194 = g_cluster_count;
+        tail = _e194;
     }
-    let _e196 = frag_info.frame_params[1u];
-    let _e200 = tail;
-    return (clamp(i32((_e196 + 0.5f)), 0i, 8i) + clamp(i32((_e200 + 0.5f)), 0i, 24i));
+    let _e197 = frag_info.frame_params[1u];
+    let _e201 = tail;
+    return (clamp(i32((_e197 + 0.5f)), 0i, 8i) + clamp(i32((_e201 + 0.5f)), 0i, 24i));
 }
 
 fn AccumulateLights_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_5: ptr<function, Surface>) -> vec3<f32> {
@@ -8872,123 +8921,123 @@ fn AccumulateLights_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002
     var param_113: LightSample;
 
     total_1 = vec3<f32>(0f, 0f, 0f);
-    let _e204 = LightCount_u0028_();
-    count_1 = _e204;
+    let _e205 = LightCount_u0028_();
+    count_1 = _e205;
     i_8 = 0i;
     loop {
-        let _e205 = i_8;
-        if (_e205 < 32i) {
-            let _e207 = i_8;
-            let _e208 = count_1;
-            if (_e207 >= _e208) {
+        let _e206 = i_8;
+        if (_e206 < 32i) {
+            let _e208 = i_8;
+            let _e209 = count_1;
+            if (_e208 >= _e209) {
                 break;
             }
-            let _e210 = i_8;
-            param_103 = _e210;
-            let _e211 = (*s_5);
-            param_104 = _e211;
-            let _e212 = SampleLight_u0028_i1_u003b_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_103), (&param_104));
-            light_4 = _e212;
-            let _e214 = light_4.n_dot_l;
-            if (_e214 <= 0f) {
+            let _e211 = i_8;
+            param_103 = _e211;
+            let _e212 = (*s_5);
+            param_104 = _e212;
+            let _e213 = SampleLight_u0028_i1_u003b_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_103), (&param_104));
+            light_4 = _e213;
+            let _e215 = light_4.n_dot_l;
+            if (_e215 <= 0f) {
                 continue;
             }
             light_transmittance = vec3<f32>(1f, 1f, 1f);
-            let _e216 = i_8;
-            param_105 = _e216;
-            let _e217 = LightHasShadow_u0028_i1_u003b((&param_105));
-            if _e217 {
-                let _e218 = (*s_5);
-                param_106 = _e218;
-                let _e219 = light_4;
-                param_107 = _e219;
-                let _e220 = i_8;
-                param_108 = _e220;
-                let _e221 = LightVisibility_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b_i1_u003b((&param_106), (&param_107), (&param_108));
-                let _e222 = v_world_position_1;
-                param_109 = _e222;
-                let _e224 = (*s_5).n;
-                param_110 = _e224;
-                let _e225 = i_8;
-                param_111 = _e225;
-                let _e226 = PointShadowFactor_u0028_vf3_u003b_vf3_u003b_i1_u003b((&param_109), (&param_110), (&param_111));
-                local_26 = (_e221 * _e226);
-            } else {
-                local_26 = 1f;
-            }
-            let _e228 = local_26;
-            visibility = _e228;
-            let _e229 = visibility;
-            if (_e229 <= 0f) {
+            let _e217 = i_8;
+            param_105 = _e217;
+            let _e218 = LightHasShadow_u0028_i1_u003b((&param_105));
+            if _e218 {
+                let _e219 = (*s_5);
+                param_106 = _e219;
+                let _e220 = light_4;
+                param_107 = _e220;
+                let _e221 = i_8;
+                param_108 = _e221;
+                let _e222 = LightVisibility_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b_i1_u003b((&param_106), (&param_107), (&param_108));
+                let _e223 = v_world_position_1;
+                param_109 = _e223;
+                let _e225 = (*s_5).n;
+                param_110 = _e225;
+                let _e226 = i_8;
+                param_111 = _e226;
+                let _e227 = PointShadowFactor_u0028_vf3_u003b_vf3_u003b_i1_u003b((&param_109), (&param_110), (&param_111));
+                local_26 = (_e222 * _e227);
+            } else {
+                local_26 = 1f;
+            }
+            let _e229 = local_26;
+            visibility = _e229;
+            let _e230 = visibility;
+            if (_e230 <= 0f) {
                 continue;
             }
-            let _e231 = (*s_5);
-            param_112 = _e231;
-            let _e232 = light_4;
-            param_113 = _e232;
-            let _e233 = ShadeLight_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b((&param_112), (&param_113));
-            let _e235 = light_4.radiance;
-            let _e238 = light_4.n_dot_l;
-            let _e240 = visibility;
-            let _e242 = light_transmittance;
-            let _e244 = total_1;
-            total_1 = (_e244 + ((((_e233 * _e235) * _e238) * _e240) * _e242));
+            let _e232 = (*s_5);
+            param_112 = _e232;
+            let _e233 = light_4;
+            param_113 = _e233;
+            let _e234 = ShadeLight_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b((&param_112), (&param_113));
+            let _e236 = light_4.radiance;
+            let _e239 = light_4.n_dot_l;
+            let _e241 = visibility;
+            let _e243 = light_transmittance;
+            let _e245 = total_1;
+            total_1 = (_e245 + ((((_e234 * _e236) * _e239) * _e241) * _e243));
             continue;
         } else {
             break;
         }
         continuing {
-            let _e246 = i_8;
-            i_8 = (_e246 + 1i);
+            let _e247 = i_8;
+            i_8 = (_e247 + 1i);
         }
     }
-    let _e248 = total_1;
-    return _e248;
+    let _e249 = total_1;
+    return _e249;
 }
 
 fn SampleLightmap_u0028_() -> vec3<f32> {
     var texel_4: vec4<f32>;
 
-    let _e187 = v_lightmap_uv_1;
-    let _e188 = textureSample(lightmap_texture_tex, lightmap_texture_smp, _e187);
-    texel_4 = _e188;
-    let _e189 = texel_4;
-    let _e192 = texel_4[3u];
-    return ((_e189.xyz * _e192) * 8f);
+    let _e188 = v_lightmap_uv_1;
+    let _e189 = textureSample(lightmap_texture_tex, lightmap_texture_smp, _e188);
+    texel_4 = _e189;
+    let _e190 = texel_4;
+    let _e193 = texel_4[3u];
+    return ((_e190.xyz * _e193) * 8f);
 }
 
 fn MaterialLodBias_u0028_() -> f32 {
-    let _e188 = frag_info.target_origin[1u];
-    return _e188;
+    let _e189 = frag_info.target_origin[1u];
+    return _e189;
 }
 
 fn ApplyEmissiveMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_6: ptr<function, Surface>) {
     var emissive: vec3<f32>;
     var param_114: vec3<f32>;
 
-    let _e189 = v_texcoord_1;
-    let _e190 = MaterialLodBias_u0028_();
-    let _e191 = textureSampleBias(emissive_texture_tex, emissive_texture_smp, _e189, _e190);
-    param_114 = _e191.xyz;
-    let _e193 = SrgbToLinear_u0028_vf3_u003b((&param_114));
-    emissive = _e193;
-    let _e194 = emissive;
-    let _e196 = frag_info.emissive;
-    let _e201 = frag_info.material2_[3u];
-    (*s_6).emissive = ((_e194 * _e196.xyz) * _e201);
+    let _e190 = v_texcoord_1;
+    let _e191 = MaterialLodBias_u0028_();
+    let _e192 = textureSampleBias(emissive_texture_tex, emissive_texture_smp, _e190, _e191);
+    param_114 = _e192.xyz;
+    let _e194 = SrgbToLinear_u0028_vf3_u003b((&param_114));
+    emissive = _e194;
+    let _e195 = emissive;
+    let _e197 = frag_info.emissive;
+    let _e202 = frag_info.material2_[3u];
+    (*s_6).emissive = ((_e195 * _e197.xyz) * _e202);
     return;
 }
 
 fn ApplyOcclusionMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_7: ptr<function, Surface>) {
     var occlusion: f32;
 
-    let _e188 = v_texcoord_1;
-    let _e189 = MaterialLodBias_u0028_();
-    let _e190 = textureSampleBias(occlusion_texture_tex, occlusion_texture_smp, _e188, _e189);
-    occlusion = _e190.x;
-    let _e192 = occlusion;
-    let _e195 = frag_info.material2_[2u];
-    (*s_7).occlusion = mix(1f, _e192, clamp(_e195, 0f, 1f));
+    let _e189 = v_texcoord_1;
+    let _e190 = MaterialLodBias_u0028_();
+    let _e191 = textureSampleBias(occlusion_texture_tex, occlusion_texture_smp, _e189, _e190);
+    occlusion = _e191.x;
+    let _e193 = occlusion;
+    let _e196 = frag_info.material2_[2u];
+    (*s_7).occlusion = mix(1f, _e193, clamp(_e196, 0f, 1f));
     return;
 }
 
@@ -8998,64 +9047,64 @@ fn ApplyNormalMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_
     var b_3: vec3<f32>;
     var sampled: vec3<f32>;
 
-    let _e191 = v_texcoord_1;
-    let _e192 = MaterialLodBias_u0028_();
-    let _e193 = textureSampleBias(normal_texture_tex, normal_texture_smp, _e191, _e192);
-    sampledTexel = _e193;
-    let _e194 = v_tangent_1;
-    t_2 = _e194.xyz;
-    let _e196 = t_2;
-    let _e198 = (*s_8).n;
-    let _e200 = (*s_8).n;
-    let _e201 = t_2;
-    t_2 = (_e196 - (_e198 * dot(_e200, _e201)));
-    let _e205 = t_2;
+    let _e192 = v_texcoord_1;
+    let _e193 = MaterialLodBias_u0028_();
+    let _e194 = textureSampleBias(normal_texture_tex, normal_texture_smp, _e192, _e193);
+    sampledTexel = _e194;
+    let _e195 = v_tangent_1;
+    t_2 = _e195.xyz;
+    let _e197 = t_2;
+    let _e199 = (*s_8).n;
+    let _e201 = (*s_8).n;
+    let _e202 = t_2;
+    t_2 = (_e197 - (_e199 * dot(_e201, _e202)));
     let _e206 = t_2;
-    if (dot(_e205, _e206) < 0.000000000001f) {
+    let _e207 = t_2;
+    if (dot(_e206, _e207) < 0.000000000001f) {
         return;
     }
-    let _e209 = t_2;
-    t_2 = normalize(_e209);
-    let _e212 = (*s_8).n;
-    let _e213 = t_2;
-    let _e216 = v_tangent_1[3u];
-    b_3 = (cross(_e212, _e213) * _e216);
-    let _e218 = gl_FrontFacing_1;
-    if !(_e218) {
-        let _e220 = t_2;
-        t_2 = -(_e220);
-    }
-    let _e222 = sampledTexel;
-    sampled = ((_e222.xyz * 2f) - vec3(1f));
-    let _e229 = frag_info.emissive[3u];
-    if (_e229 > 0.5f) {
-        let _e231 = sampled;
-        let _e233 = sampled;
-        sampled[2u] = sqrt(max((1f - dot(_e231.xy, _e233.xy)), 0f));
-    }
-    let _e242 = frag_info.material2_[1u];
-    let _e243 = sampled;
-    let _e245 = (_e243.xy * _e242);
-    sampled[0u] = _e245.x;
-    sampled[1u] = _e245.y;
-    let _e250 = t_2;
-    let _e252 = sampled[0u];
-    let _e254 = b_3;
-    let _e256 = sampled[1u];
-    let _e260 = (*s_8).n;
-    let _e262 = sampled[2u];
-    (*s_8).n = normalize((((_e250 * _e252) + (_e254 * _e256)) + (_e260 * _e262)));
-    let _e268 = (*s_8).n;
-    let _e270 = (*s_8).v;
-    (*s_8).n_dot_v = max(dot(_e268, _e270), 0.0001f);
+    let _e210 = t_2;
+    t_2 = normalize(_e210);
+    let _e213 = (*s_8).n;
+    let _e214 = t_2;
+    let _e217 = v_tangent_1[3u];
+    b_3 = (cross(_e213, _e214) * _e217);
+    let _e219 = gl_FrontFacing_1;
+    if !(_e219) {
+        let _e221 = t_2;
+        t_2 = -(_e221);
+    }
+    let _e223 = sampledTexel;
+    sampled = ((_e223.xyz * 2f) - vec3(1f));
+    let _e230 = frag_info.emissive[3u];
+    if (_e230 > 0.5f) {
+        let _e232 = sampled;
+        let _e234 = sampled;
+        sampled[2u] = sqrt(max((1f - dot(_e232.xy, _e234.xy)), 0f));
+    }
+    let _e243 = frag_info.material2_[1u];
+    let _e244 = sampled;
+    let _e246 = (_e244.xy * _e243);
+    sampled[0u] = _e246.x;
+    sampled[1u] = _e246.y;
+    let _e251 = t_2;
+    let _e253 = sampled[0u];
+    let _e255 = b_3;
+    let _e257 = sampled[1u];
+    let _e261 = (*s_8).n;
+    let _e263 = sampled[2u];
+    (*s_8).n = normalize((((_e251 * _e253) + (_e255 * _e257)) + (_e261 * _e263)));
+    let _e269 = (*s_8).n;
+    let _e271 = (*s_8).v;
+    (*s_8).n_dot_v = max(dot(_e269, _e271), 0.0001f);
     return;
 }
 
 fn AtlasTexel_u0028_vf2_u003b(texel_5: ptr<function, vec2<f32>>) -> vec4<f32> {
-    let _e187 = (*texel_5);
-    let _e191 = irradiance_info.atlas;
-    let _e194 = textureSampleLevel(irradiance_texture_tex, irradiance_texture_smp, ((_e187 + vec2(0.5f)) * _e191.xy), 0f);
-    return _e194;
+    let _e188 = (*texel_5);
+    let _e192 = irradiance_info.atlas;
+    let _e195 = textureSampleLevel(irradiance_texture_tex, irradiance_texture_smp, ((_e188 + vec2(0.5f)) * _e192.xy), 0f);
+    return _e195;
 }
 
 fn TileBilinear_u0028_vf2_u003b_f1_u003b_vf2_u003b(corner: ptr<function, vec2<f32>>, interior: ptr<function, f32>, uv_5: ptr<function, vec2<f32>>) -> vec4<f32> {
@@ -9071,42 +9120,42 @@ fn TileBilinear_u0028_vf2_u003b_f1_u003b_vf2_u003b(corner: ptr<function, vec2<f3
     var d_4: vec4<f32>;
     var param_118: vec2<f32>;
 
-    let _e200 = (*uv_5);
-    let _e201 = (*interior);
-    at_1 = ((vec2(1f) + (_e200 * _e201)) - vec2(0.5f));
-    let _e207 = at_1;
-    low = floor(_e207);
-    let _e209 = at_1;
-    let _e210 = low;
-    f = (_e209 - _e210);
-    let _e212 = (*corner);
-    let _e213 = low;
-    param_115 = (_e212 + _e213);
-    let _e215 = AtlasTexel_u0028_vf2_u003b((&param_115));
-    a_4 = _e215;
-    let _e216 = (*corner);
-    let _e217 = low;
-    param_116 = ((_e216 + _e217) + vec2<f32>(1f, 0f));
-    let _e220 = AtlasTexel_u0028_vf2_u003b((&param_116));
-    b_4 = _e220;
-    let _e221 = (*corner);
-    let _e222 = low;
-    param_117 = ((_e221 + _e222) + vec2<f32>(0f, 1f));
-    let _e225 = AtlasTexel_u0028_vf2_u003b((&param_117));
-    c_1 = _e225;
-    let _e226 = (*corner);
-    let _e227 = low;
-    param_118 = ((_e226 + _e227) + vec2<f32>(1f, 1f));
-    let _e230 = AtlasTexel_u0028_vf2_u003b((&param_118));
-    d_4 = _e230;
-    let _e231 = a_4;
-    let _e232 = b_4;
-    let _e234 = f[0u];
-    let _e237 = c_1;
-    let _e238 = d_4;
-    let _e240 = f[0u];
-    let _e244 = f[1u];
-    return mix(mix(_e231, _e232, vec4(_e234)), mix(_e237, _e238, vec4(_e240)), vec4(_e244));
+    let _e201 = (*uv_5);
+    let _e202 = (*interior);
+    at_1 = ((vec2(1f) + (_e201 * _e202)) - vec2(0.5f));
+    let _e208 = at_1;
+    low = floor(_e208);
+    let _e210 = at_1;
+    let _e211 = low;
+    f = (_e210 - _e211);
+    let _e213 = (*corner);
+    let _e214 = low;
+    param_115 = (_e213 + _e214);
+    let _e216 = AtlasTexel_u0028_vf2_u003b((&param_115));
+    a_4 = _e216;
+    let _e217 = (*corner);
+    let _e218 = low;
+    param_116 = ((_e217 + _e218) + vec2<f32>(1f, 0f));
+    let _e221 = AtlasTexel_u0028_vf2_u003b((&param_116));
+    b_4 = _e221;
+    let _e222 = (*corner);
+    let _e223 = low;
+    param_117 = ((_e222 + _e223) + vec2<f32>(0f, 1f));
+    let _e226 = AtlasTexel_u0028_vf2_u003b((&param_117));
+    c_1 = _e226;
+    let _e227 = (*corner);
+    let _e228 = low;
+    param_118 = ((_e227 + _e228) + vec2<f32>(1f, 1f));
+    let _e231 = AtlasTexel_u0028_vf2_u003b((&param_118));
+    d_4 = _e231;
+    let _e232 = a_4;
+    let _e233 = b_4;
+    let _e235 = f[0u];
+    let _e238 = c_1;
+    let _e239 = d_4;
+    let _e241 = f[0u];
+    let _e245 = f[1u];
+    return mix(mix(_e232, _e233, vec4(_e235)), mix(_e238, _e239, vec4(_e241)), vec4(_e245));
 }
 
 fn ProbeOctahedral_u0028_vf3_u003b(direction_1: ptr<function, vec3<f32>>) -> vec2<f32> {
@@ -9114,29 +9163,29 @@ fn ProbeOctahedral_u0028_vf3_u003b(direction_1: ptr<function, vec3<f32>>) -> vec
     var n_5: vec3<f32>;
     var xy: vec2<f32>;
 
-    let _e191 = (*direction_1)[0u];
-    let _e194 = (*direction_1)[1u];
-    let _e198 = (*direction_1)[2u];
-    sum_1 = ((abs(_e191) + abs(_e194)) + abs(_e198));
-    let _e201 = sum_1;
-    if (_e201 <= 0f) {
+    let _e192 = (*direction_1)[0u];
+    let _e195 = (*direction_1)[1u];
+    let _e199 = (*direction_1)[2u];
+    sum_1 = ((abs(_e192) + abs(_e195)) + abs(_e199));
+    let _e202 = sum_1;
+    if (_e202 <= 0f) {
         return vec2<f32>(0.5f, 0.5f);
     }
-    let _e203 = (*direction_1);
-    let _e204 = sum_1;
-    n_5 = (_e203 / vec3(_e204));
-    let _e207 = n_5;
-    xy = _e207.xy;
-    let _e210 = n_5[2u];
-    if (_e210 < 0f) {
-        let _e213 = n_5[1u];
-        let _e217 = n_5[0u];
-        let _e222 = n_5[0u];
-        let _e226 = n_5[1u];
-        xy = vec2<f32>(((1f - abs(_e213)) * select(-1f, 1f, (_e217 >= 0f))), ((1f - abs(_e222)) * select(-1f, 1f, (_e226 >= 0f))));
+    let _e204 = (*direction_1);
+    let _e205 = sum_1;
+    n_5 = (_e204 / vec3(_e205));
+    let _e208 = n_5;
+    xy = _e208.xy;
+    let _e211 = n_5[2u];
+    if (_e211 < 0f) {
+        let _e214 = n_5[1u];
+        let _e218 = n_5[0u];
+        let _e223 = n_5[0u];
+        let _e227 = n_5[1u];
+        xy = vec2<f32>(((1f - abs(_e214)) * select(-1f, 1f, (_e218 >= 0f))), ((1f - abs(_e223)) * select(-1f, 1f, (_e227 >= 0f))));
     }
-    let _e231 = xy;
-    return ((_e231 * 0.5f) + vec2(0.5f));
+    let _e232 = xy;
+    return ((_e232 * 0.5f) + vec2(0.5f));
 }
 
 fn SampleIrradiance_u0028_vf3_u003b_vf3_u003b_vf3_u003b(world_4: ptr<function, vec3<f32>>, normal_1: ptr<function, vec3<f32>>, view_1: ptr<function, vec3<f32>>) -> vec3<f32> {
@@ -9184,190 +9233,190 @@ fn SampleIrradiance_u0028_vf3_u003b_vf3_u003b_vf3_u003b(world_4: ptr<function, v
     var param_127: vec2<f32>;
     var local_27: vec3<f32>;
 
-    let _e233 = irradiance_info.origin;
-    origin_2 = _e233.xyz;
-    let _e236 = irradiance_info.spacing;
-    spacing = _e236.xyz;
-    let _e239 = irradiance_info.counts;
-    counts = _e239.xyz;
-    let _e243 = irradiance_info.tiles[0u];
-    irradianceTile = _e243;
-    let _e246 = irradiance_info.tiles[1u];
-    depthTile = _e246;
-    let _e249 = irradiance_info.tiles[2u];
-    columns = _e249;
-    let _e252 = irradiance_info.tiles[3u];
-    momentsTop = _e252;
-    let _e253 = (*normal_1);
-    unit = normalize(_e253);
-    let _e255 = (*world_4);
-    let _e256 = unit;
-    let _e259 = irradiance_info.spacing[3u];
-    let _e262 = (*view_1);
-    let _e265 = irradiance_info.counts[3u];
-    biased = ((_e255 + (_e256 * _e259)) + (_e262 * _e265));
-    let _e268 = biased;
-    let _e269 = origin_2;
-    let _e271 = spacing;
-    grid_1 = ((_e268 - _e269) / _e271);
-    let _e273 = grid_1;
-    let _e275 = counts;
-    base = clamp(floor(_e273), vec3<f32>(0f, 0f, 0f), (_e275 - vec3(2f)));
-    let _e279 = grid_1;
-    let _e280 = base;
-    f_1 = clamp((_e279 - _e280), vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
+    let _e234 = irradiance_info.origin;
+    origin_2 = _e234.xyz;
+    let _e237 = irradiance_info.spacing;
+    spacing = _e237.xyz;
+    let _e240 = irradiance_info.counts;
+    counts = _e240.xyz;
+    let _e244 = irradiance_info.tiles[0u];
+    irradianceTile = _e244;
+    let _e247 = irradiance_info.tiles[1u];
+    depthTile = _e247;
+    let _e250 = irradiance_info.tiles[2u];
+    columns = _e250;
+    let _e253 = irradiance_info.tiles[3u];
+    momentsTop = _e253;
+    let _e254 = (*normal_1);
+    unit = normalize(_e254);
+    let _e256 = (*world_4);
+    let _e257 = unit;
+    let _e260 = irradiance_info.spacing[3u];
+    let _e263 = (*view_1);
+    let _e266 = irradiance_info.counts[3u];
+    biased = ((_e256 + (_e257 * _e260)) + (_e263 * _e266));
+    let _e269 = biased;
+    let _e270 = origin_2;
+    let _e272 = spacing;
+    grid_1 = ((_e269 - _e270) / _e272);
+    let _e274 = grid_1;
+    let _e276 = counts;
+    base = clamp(floor(_e274), vec3<f32>(0f, 0f, 0f), (_e276 - vec3(2f)));
+    let _e280 = grid_1;
+    let _e281 = base;
+    f_1 = clamp((_e280 - _e281), vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
     total_2 = vec3<f32>(0f, 0f, 0f);
     weights = 0f;
     corner_1 = 0i;
     loop {
-        let _e283 = corner_1;
-        if (_e283 < 8i) {
-            let _e285 = corner_1;
-            let _e288 = corner_1;
-            let _e293 = corner_1;
-            offset_3 = vec3<f32>(f32((_e285 & 1i)), f32(((_e288 >> bitcast<u32>(1i)) & 1i)), f32(((_e293 >> bitcast<u32>(2i)) & 1i)));
-            let _e299 = base;
-            let _e300 = offset_3;
-            cell_1 = (_e299 + _e300);
-            let _e303 = cell_1[2u];
-            let _e305 = counts[1u];
-            let _e308 = cell_1[1u];
-            let _e311 = counts[0u];
-            let _e314 = cell_1[0u];
-            probe = ((((_e303 * _e305) + _e308) * _e311) + _e314);
-            let _e316 = probe;
-            let _e317 = columns;
-            let _e322 = probe;
-            let _e323 = columns;
-            tile_4 = vec2<f32>((_e316 - (floor((_e316 / _e317)) * _e317)), floor((_e322 / _e323)));
-            let _e327 = tile_4;
-            let _e328 = irradianceTile;
-            irradianceCorner = (_e327 * (_e328 + 2f));
-            let _e332 = tile_4[0u];
-            let _e333 = depthTile;
-            let _e336 = momentsTop;
-            let _e338 = tile_4[1u];
-            let _e339 = depthTile;
-            momentCorner = vec2<f32>((_e332 * (_e333 + 2f)), (_e336 + (_e338 * (_e339 + 2f))));
-            let _e344 = irradianceCorner;
-            param_119 = (_e344 + vec2(1f));
-            let _e347 = AtlasTexel_u0028_vf2_u003b((&param_119));
-            if (_e347.w < 0.5f) {
+        let _e284 = corner_1;
+        if (_e284 < 8i) {
+            let _e286 = corner_1;
+            let _e289 = corner_1;
+            let _e294 = corner_1;
+            offset_3 = vec3<f32>(f32((_e286 & 1i)), f32(((_e289 >> bitcast<u32>(1i)) & 1i)), f32(((_e294 >> bitcast<u32>(2i)) & 1i)));
+            let _e300 = base;
+            let _e301 = offset_3;
+            cell_1 = (_e300 + _e301);
+            let _e304 = cell_1[2u];
+            let _e306 = counts[1u];
+            let _e309 = cell_1[1u];
+            let _e312 = counts[0u];
+            let _e315 = cell_1[0u];
+            probe = ((((_e304 * _e306) + _e309) * _e312) + _e315);
+            let _e317 = probe;
+            let _e318 = columns;
+            let _e323 = probe;
+            let _e324 = columns;
+            tile_4 = vec2<f32>((_e317 - (floor((_e317 / _e318)) * _e318)), floor((_e323 / _e324)));
+            let _e328 = tile_4;
+            let _e329 = irradianceTile;
+            irradianceCorner = (_e328 * (_e329 + 2f));
+            let _e333 = tile_4[0u];
+            let _e334 = depthTile;
+            let _e337 = momentsTop;
+            let _e339 = tile_4[1u];
+            let _e340 = depthTile;
+            momentCorner = vec2<f32>((_e333 * (_e334 + 2f)), (_e337 + (_e339 * (_e340 + 2f))));
+            let _e345 = irradianceCorner;
+            param_119 = (_e345 + vec2(1f));
+            let _e348 = AtlasTexel_u0028_vf2_u003b((&param_119));
+            if (_e348.w < 0.5f) {
                 continue;
             }
-            let _e350 = f_1;
-            let _e352 = f_1;
-            let _e353 = offset_3;
-            trilinear = mix((vec3<f32>(1f, 1f, 1f) - _e350), _e352, _e353);
-            let _e356 = trilinear[0u];
-            let _e358 = trilinear[1u];
-            let _e361 = trilinear[2u];
-            weight_3 = max(((_e356 * _e358) * _e361), 0.001f);
-            let _e364 = origin_2;
-            let _e365 = spacing;
-            let _e366 = cell_1;
-            probePosition = (_e364 + (_e365 * _e366));
-            let _e369 = probePosition;
-            let _e370 = biased;
-            toProbe = (_e369 - _e370);
-            let _e372 = toProbe;
-            distance_4 = length(_e372);
-            let _e374 = distance_4;
-            if (_e374 > 0.000001f) {
-                let _e376 = toProbe;
-                let _e377 = distance_4;
-                direction_2 = (_e376 / vec3(_e377));
-                let _e380 = unit;
-                let _e381 = probePosition;
-                let _e382 = (*world_4);
-                facing = ((dot(_e380, normalize((_e381 - _e382))) * 0.5f) + 0.5f);
-                let _e388 = facing;
+            let _e351 = f_1;
+            let _e353 = f_1;
+            let _e354 = offset_3;
+            trilinear = mix((vec3<f32>(1f, 1f, 1f) - _e351), _e353, _e354);
+            let _e357 = trilinear[0u];
+            let _e359 = trilinear[1u];
+            let _e362 = trilinear[2u];
+            weight_3 = max(((_e357 * _e359) * _e362), 0.001f);
+            let _e365 = origin_2;
+            let _e366 = spacing;
+            let _e367 = cell_1;
+            probePosition = (_e365 + (_e366 * _e367));
+            let _e370 = probePosition;
+            let _e371 = biased;
+            toProbe = (_e370 - _e371);
+            let _e373 = toProbe;
+            distance_4 = length(_e373);
+            let _e375 = distance_4;
+            if (_e375 > 0.000001f) {
+                let _e377 = toProbe;
+                let _e378 = distance_4;
+                direction_2 = (_e377 / vec3(_e378));
+                let _e381 = unit;
+                let _e382 = probePosition;
+                let _e383 = (*world_4);
+                facing = ((dot(_e381, normalize((_e382 - _e383))) * 0.5f) + 0.5f);
                 let _e389 = facing;
-                probeWeight = ((_e388 * _e389) + 0.2f);
-                let _e392 = direction_2;
-                param_120 = -(_e392);
-                let _e394 = ProbeOctahedral_u0028_vf3_u003b((&param_120));
-                let _e395 = momentCorner;
-                param_121 = _e395;
-                let _e396 = depthTile;
-                param_122 = _e396;
-                param_123 = _e394;
-                let _e397 = TileBilinear_u0028_vf2_u003b_f1_u003b_vf2_u003b((&param_121), (&param_122), (&param_123));
-                moments_3 = _e397.xy;
+                let _e390 = facing;
+                probeWeight = ((_e389 * _e390) + 0.2f);
+                let _e393 = direction_2;
+                param_120 = -(_e393);
+                let _e395 = ProbeOctahedral_u0028_vf3_u003b((&param_120));
+                let _e396 = momentCorner;
+                param_121 = _e396;
+                let _e397 = depthTile;
+                param_122 = _e397;
+                param_123 = _e395;
+                let _e398 = TileBilinear_u0028_vf2_u003b_f1_u003b_vf2_u003b((&param_121), (&param_122), (&param_123));
+                moments_3 = _e398.xy;
                 chebyshev = 1f;
-                let _e399 = distance_4;
-                let _e401 = moments_3[0u];
-                if (_e399 > _e401) {
-                    let _e404 = moments_3[1u];
-                    let _e406 = moments_3[0u];
-                    let _e408 = moments_3[0u];
-                    variance_1 = max((_e404 - (_e406 * _e408)), 0.000001f);
-                    let _e412 = distance_4;
-                    let _e414 = moments_3[0u];
-                    difference = (_e412 - _e414);
-                    let _e416 = variance_1;
+                let _e400 = distance_4;
+                let _e402 = moments_3[0u];
+                if (_e400 > _e402) {
+                    let _e405 = moments_3[1u];
+                    let _e407 = moments_3[0u];
+                    let _e409 = moments_3[0u];
+                    variance_1 = max((_e405 - (_e407 * _e409)), 0.000001f);
+                    let _e413 = distance_4;
+                    let _e415 = moments_3[0u];
+                    difference = (_e413 - _e415);
                     let _e417 = variance_1;
-                    let _e418 = difference;
+                    let _e418 = variance_1;
                     let _e419 = difference;
-                    chebyshev = (_e416 / (_e417 + (_e418 * _e419)));
-                    let _e423 = chebyshev;
+                    let _e420 = difference;
+                    chebyshev = (_e417 / (_e418 + (_e419 * _e420)));
                     let _e424 = chebyshev;
-                    let _e426 = chebyshev;
-                    chebyshev = ((_e423 * _e424) * _e426);
+                    let _e425 = chebyshev;
+                    let _e427 = chebyshev;
+                    chebyshev = ((_e424 * _e425) * _e427);
                 }
-                let _e428 = probeWeight;
-                let _e429 = chebyshev;
-                probeWeight = max((_e428 * max(_e429, 0.05f)), 0.000001f);
-                let _e433 = probeWeight;
-                if (_e433 < 0.2f) {
-                    let _e435 = probeWeight;
+                let _e429 = probeWeight;
+                let _e430 = chebyshev;
+                probeWeight = max((_e429 * max(_e430, 0.05f)), 0.000001f);
+                let _e434 = probeWeight;
+                if (_e434 < 0.2f) {
                     let _e436 = probeWeight;
-                    let _e439 = probeWeight;
-                    probeWeight = (_e439 * ((_e435 * _e436) * 25f));
+                    let _e437 = probeWeight;
+                    let _e440 = probeWeight;
+                    probeWeight = (_e440 * ((_e436 * _e437) * 25f));
                 }
-                let _e441 = probeWeight;
-                let _e442 = weight_3;
-                weight_3 = (_e442 * _e441);
-            }
-            let _e444 = unit;
-            param_124 = _e444;
-            let _e445 = ProbeOctahedral_u0028_vf3_u003b((&param_124));
-            let _e446 = irradianceCorner;
-            param_125 = _e446;
-            let _e447 = irradianceTile;
-            param_126 = _e447;
-            param_127 = _e445;
-            let _e448 = TileBilinear_u0028_vf2_u003b_f1_u003b_vf2_u003b((&param_125), (&param_126), (&param_127));
-            let _e450 = weight_3;
-            let _e452 = total_2;
-            total_2 = (_e452 + (_e448.xyz * _e450));
-            let _e454 = weight_3;
-            let _e455 = weights;
-            weights = (_e455 + _e454);
+                let _e442 = probeWeight;
+                let _e443 = weight_3;
+                weight_3 = (_e443 * _e442);
+            }
+            let _e445 = unit;
+            param_124 = _e445;
+            let _e446 = ProbeOctahedral_u0028_vf3_u003b((&param_124));
+            let _e447 = irradianceCorner;
+            param_125 = _e447;
+            let _e448 = irradianceTile;
+            param_126 = _e448;
+            param_127 = _e446;
+            let _e449 = TileBilinear_u0028_vf2_u003b_f1_u003b_vf2_u003b((&param_125), (&param_126), (&param_127));
+            let _e451 = weight_3;
+            let _e453 = total_2;
+            total_2 = (_e453 + (_e449.xyz * _e451));
+            let _e455 = weight_3;
+            let _e456 = weights;
+            weights = (_e456 + _e455);
             continue;
         } else {
             break;
         }
         continuing {
-            let _e457 = corner_1;
-            corner_1 = (_e457 + 1i);
+            let _e458 = corner_1;
+            corner_1 = (_e458 + 1i);
         }
     }
-    let _e459 = weights;
-    if (_e459 > 0f) {
-        let _e461 = total_2;
-        let _e462 = weights;
-        local_27 = (_e461 / vec3(_e462));
+    let _e460 = weights;
+    if (_e460 > 0f) {
+        let _e462 = total_2;
+        let _e463 = weights;
+        local_27 = (_e462 / vec3(_e463));
     } else {
         local_27 = vec3<f32>(0f, 0f, 0f);
     }
-    let _e465 = local_27;
-    return _e465;
+    let _e466 = local_27;
+    return _e466;
 }
 
 fn IrradianceEnabled_u0028_() -> bool {
-    let _e188 = irradiance_info.origin[3u];
-    return (_e188 > 0.5f);
+    let _e189 = irradiance_info.origin[3u];
+    return (_e189 > 0.5f);
 }
 
 fn ApplyCommonMaps_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_9: ptr<function, Surface>) {
@@ -9378,50 +9427,50 @@ fn ApplyCommonMaps_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d
     var param_132: Surface;
     var param_133: Surface;
 
-    let _e193 = IrradianceEnabled_u0028_();
-    if _e193 {
-        let _e194 = v_world_position_1;
-        param_128 = _e194;
-        let _e196 = (*s_9).n;
-        param_129 = _e196;
-        let _e198 = (*s_9).v;
-        param_130 = _e198;
-        let _e199 = SampleIrradiance_u0028_vf3_u003b_vf3_u003b_vf3_u003b((&param_128), (&param_129), (&param_130));
-        let _e202 = frag_info.material[2u];
-        (*s_9).ambient = (_e199 * _e202);
-    }
-    let _e205 = (*s_9);
-    param_131 = _e205;
+    let _e194 = IrradianceEnabled_u0028_();
+    if _e194 {
+        let _e195 = v_world_position_1;
+        param_128 = _e195;
+        let _e197 = (*s_9).n;
+        param_129 = _e197;
+        let _e199 = (*s_9).v;
+        param_130 = _e199;
+        let _e200 = SampleIrradiance_u0028_vf3_u003b_vf3_u003b_vf3_u003b((&param_128), (&param_129), (&param_130));
+        let _e203 = frag_info.material[2u];
+        (*s_9).ambient = (_e200 * _e203);
+    }
+    let _e206 = (*s_9);
+    param_131 = _e206;
     ApplyNormalMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_131));
-    let _e206 = param_131;
-    (*s_9) = _e206;
-    let _e207 = (*s_9);
-    param_132 = _e207;
+    let _e207 = param_131;
+    (*s_9) = _e207;
+    let _e208 = (*s_9);
+    param_132 = _e208;
     ApplyOcclusionMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_132));
-    let _e208 = param_132;
-    (*s_9) = _e208;
-    let _e209 = (*s_9);
-    param_133 = _e209;
+    let _e209 = param_132;
+    (*s_9) = _e209;
+    let _e210 = (*s_9);
+    param_133 = _e210;
     ApplyEmissiveMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_133));
-    let _e210 = param_133;
-    (*s_9) = _e210;
+    let _e211 = param_133;
+    (*s_9) = _e211;
     return;
 }
 
 fn TowardsEye_u0028_() -> vec3<f32> {
     var local_28: vec3<f32>;
 
-    let _e187 = Orthographic_u0028_();
-    if _e187 {
-        let _e189 = fog_info.forward;
-        local_28 = -(_e189.xyz);
+    let _e188 = Orthographic_u0028_();
+    if _e188 {
+        let _e190 = fog_info.forward;
+        local_28 = -(_e190.xyz);
     } else {
-        let _e193 = fog_info.eye;
-        let _e195 = v_world_position_1;
-        local_28 = normalize((_e193.xyz - _e195));
+        let _e194 = fog_info.eye;
+        let _e196 = v_world_position_1;
+        local_28 = normalize((_e194.xyz - _e196));
     }
-    let _e198 = local_28;
-    return _e198;
+    let _e199 = local_28;
+    return _e199;
 }
 
 fn ReadSurface_u0028_() -> Surface {
@@ -9434,89 +9483,89 @@ fn ReadSurface_u0028_() -> Surface {
     var anchored: vec3<f32>;
     var noise_1: f32;
 
-    let _e194 = v_texcoord_1;
-    let _e195 = MaterialLodBias_u0028_();
-    let _e196 = textureSampleBias(base_color_texture_tex, base_color_texture_smp, _e194, _e195);
-    texel_6 = _e196;
-    let _e197 = texel_6;
-    param_134 = _e197.xyz;
-    let _e199 = SrgbToLinear_u0028_vf3_u003b((&param_134));
-    let _e201 = frag_info.base_color;
-    param_135 = _e201.xyz;
-    let _e203 = SrgbToLinear_u0028_vf3_u003b((&param_135));
-    let _e205 = v_color_1;
-    s_10.albedo = ((_e199 * _e203) * _e205.xyz);
-    let _e210 = texel_6[3u];
-    let _e213 = frag_info.base_color[3u];
-    let _e216 = v_color_1[3u];
-    s_10.alpha = ((_e210 * _e213) * _e216);
-    let _e220 = s_10.albedo;
-    g_albedo = _e220;
-    let _e223 = frag_info.material2_[0u];
-    cutoff = _e223;
-    let _e224 = cutoff;
-    if (_e224 > 1f) {
-        let _e226 = cutoff;
-        edge = (_e226 - 1f);
-        let _e229 = s_10.alpha;
-        let _e230 = edge;
-        let _e233 = s_10.alpha;
-        let _e234 = fwidth(_e233);
-        s_10.alpha = clamp((((_e229 - _e230) / max(_e234, 0.0001f)) + 0.5f), 0f, 1f);
-    } else {
-        let _e240 = cutoff;
-        if (_e240 >= 0f) {
-            let _e243 = s_10.alpha;
-            let _e244 = cutoff;
-            if (_e243 < _e244) {
+    let _e195 = v_texcoord_1;
+    let _e196 = MaterialLodBias_u0028_();
+    let _e197 = textureSampleBias(base_color_texture_tex, base_color_texture_smp, _e195, _e196);
+    texel_6 = _e197;
+    let _e198 = texel_6;
+    param_134 = _e198.xyz;
+    let _e200 = SrgbToLinear_u0028_vf3_u003b((&param_134));
+    let _e202 = frag_info.base_color;
+    param_135 = _e202.xyz;
+    let _e204 = SrgbToLinear_u0028_vf3_u003b((&param_135));
+    let _e206 = v_color_1;
+    s_10.albedo = ((_e200 * _e204) * _e206.xyz);
+    let _e211 = texel_6[3u];
+    let _e214 = frag_info.base_color[3u];
+    let _e217 = v_color_1[3u];
+    s_10.alpha = ((_e211 * _e214) * _e217);
+    let _e221 = s_10.albedo;
+    g_albedo = _e221;
+    let _e224 = frag_info.material2_[0u];
+    cutoff = _e224;
+    let _e225 = cutoff;
+    if (_e225 > 1f) {
+        let _e227 = cutoff;
+        edge = (_e227 - 1f);
+        let _e230 = s_10.alpha;
+        let _e231 = edge;
+        let _e234 = s_10.alpha;
+        let _e235 = fwidth(_e234);
+        s_10.alpha = clamp((((_e230 - _e231) / max(_e235, 0.0001f)) + 0.5f), 0f, 1f);
+    } else {
+        let _e241 = cutoff;
+        if (_e241 >= 0f) {
+            let _e244 = s_10.alpha;
+            let _e245 = cutoff;
+            if (_e244 < _e245) {
                 discard;
             }
             s_10.alpha = 1f;
         } else {
-            let _e247 = cutoff;
-            if (_e247 < -1.5f) {
-                let _e249 = v_world_position_1;
-                anchored = floor((_e249 * 16f));
-                let _e252 = anchored;
-                noise_1 = fract((sin(dot(_e252, vec3<f32>(12.9898f, 78.233f, 37.719f))) * 43758.547f));
-                let _e258 = s_10.alpha;
-                let _e259 = noise_1;
-                if (_e258 < _e259) {
+            let _e248 = cutoff;
+            if (_e248 < -1.5f) {
+                let _e250 = v_world_position_1;
+                anchored = floor((_e250 * 16f));
+                let _e253 = anchored;
+                noise_1 = fract((sin(dot(_e253, vec3<f32>(12.9898f, 78.233f, 37.719f))) * 43758.547f));
+                let _e259 = s_10.alpha;
+                let _e260 = noise_1;
+                if (_e259 < _e260) {
                     discard;
                 }
             }
         }
     }
-    let _e261 = cutoff;
-    let _e263 = cutoff;
-    g_premultiply = ((_e261 < 0f) && (_e263 > -0.75f));
-    let _e266 = v_normal_1;
-    s_10.n = normalize(_e266);
-    let _e269 = gl_FrontFacing_1;
-    if !(_e269) {
-        let _e272 = s_10.n;
-        s_10.n = -(_e272);
-    }
-    let _e275 = TowardsEye_u0028_();
-    s_10.v = _e275;
-    let _e278 = s_10.n;
-    let _e280 = s_10.v;
-    s_10.n_dot_v = max(dot(_e278, _e280), 0.0001f);
-    let _e286 = frag_info.material[0u];
-    s_10.metallic = clamp(_e286, 0f, 1f);
-    let _e291 = frag_info.material[1u];
-    s_10.roughness = clamp(_e291, 0.02f, 1f);
-    let _e295 = frag_info.ambient_ground;
-    let _e298 = frag_info.ambient_sky;
-    let _e302 = s_10.n[1u];
-    let _e309 = frag_info.material[2u];
-    s_10.ambient = (mix(_e295.xyz, _e298.xyz, vec3(((_e302 * 0.5f) + 0.5f))) * _e309);
-    let _e314 = frag_info.frame_params[0u];
-    s_10.exposure = max(_e314, 0f);
+    let _e262 = cutoff;
+    let _e264 = cutoff;
+    g_premultiply = ((_e262 < 0f) && (_e264 > -0.75f));
+    let _e267 = v_normal_1;
+    s_10.n = normalize(_e267);
+    let _e270 = gl_FrontFacing_1;
+    if !(_e270) {
+        let _e273 = s_10.n;
+        s_10.n = -(_e273);
+    }
+    let _e276 = TowardsEye_u0028_();
+    s_10.v = _e276;
+    let _e279 = s_10.n;
+    let _e281 = s_10.v;
+    s_10.n_dot_v = max(dot(_e279, _e281), 0.0001f);
+    let _e287 = frag_info.material[0u];
+    s_10.metallic = clamp(_e287, 0f, 1f);
+    let _e292 = frag_info.material[1u];
+    s_10.roughness = clamp(_e292, 0.02f, 1f);
+    let _e296 = frag_info.ambient_ground;
+    let _e299 = frag_info.ambient_sky;
+    let _e303 = s_10.n[1u];
+    let _e310 = frag_info.material[2u];
+    s_10.ambient = (mix(_e296.xyz, _e299.xyz, vec3(((_e303 * 0.5f) + 0.5f))) * _e310);
+    let _e315 = frag_info.frame_params[0u];
+    s_10.exposure = max(_e315, 0f);
     s_10.occlusion = 1f;
     s_10.emissive = vec3<f32>(0f, 0f, 0f);
-    let _e319 = s_10;
-    return _e319;
+    let _e320 = s_10;
+    return _e320;
 }
 
 fn main_1() {
@@ -9539,39 +9588,39 @@ fn main_1() {
     g_cluster_offset = 0f;
     g_cluster_count = 0f;
     light_transmittance = vec3<f32>(1f, 1f, 1f);
-    let _e196 = ReadSurface_u0028_();
-    s_11 = _e196;
-    let _e197 = s_11;
-    param_136 = _e197;
+    let _e197 = ReadSurface_u0028_();
+    s_11 = _e197;
+    let _e198 = s_11;
+    param_136 = _e198;
     ApplyCommonMaps_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_136));
-    let _e198 = param_136;
-    s_11 = _e198;
-    let _e200 = s_11.albedo;
-    let _e202 = s_11.ambient;
-    let _e203 = SampleLightmap_u0028_();
-    let _e207 = s_11.occlusion;
-    ambient = ((_e200 * (_e202 + _e203)) * _e207);
-    let _e209 = s_11;
-    param_137 = _e209;
-    let _e210 = AccumulateLights_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_137));
-    let _e212 = s_11.occlusion;
-    let _e214 = ambient;
-    let _e217 = s_11.emissive;
-    lit_3 = (((_e210 * _e212) + _e214) + _e217);
-    let _e219 = s_11;
-    param_138 = _e219;
-    let _e220 = lit_3;
-    param_139 = _e220;
-    let _e221 = WriteDebugView_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_vf3_u003b((&param_138), (&param_139));
-    if _e221 {
+    let _e199 = param_136;
+    s_11 = _e199;
+    let _e201 = s_11.albedo;
+    let _e203 = s_11.ambient;
+    let _e204 = SampleLightmap_u0028_();
+    let _e208 = s_11.occlusion;
+    ambient = ((_e201 * (_e203 + _e204)) * _e208);
+    let _e210 = s_11;
+    param_137 = _e210;
+    let _e211 = AccumulateLights_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_137));
+    let _e213 = s_11.occlusion;
+    let _e215 = ambient;
+    let _e218 = s_11.emissive;
+    lit_3 = (((_e211 * _e213) + _e215) + _e218);
+    let _e220 = s_11;
+    param_138 = _e220;
+    let _e221 = lit_3;
+    param_139 = _e221;
+    let _e222 = WriteDebugView_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_vf3_u003b((&param_138), (&param_139));
+    if _e222 {
         return;
     }
-    let _e222 = lit_3;
-    param_140 = _e222;
-    let _e224 = s_11.alpha;
-    param_141 = _e224;
-    let _e226 = s_11.roughness;
-    param_142 = _e226;
+    let _e223 = lit_3;
+    param_140 = _e223;
+    let _e225 = s_11.alpha;
+    param_141 = _e225;
+    let _e227 = s_11.roughness;
+    param_142 = _e227;
     WriteSurface_u0028_vf3_u003b_f1_u003b_f1_u003b((&param_140), (&param_141), (&param_142));
     return;
 }
@@ -10079,10 +10128,10 @@ var shadow_texture_tex: texture_2d<f32>;
 var shadow_texture_smp: sampler;
 
 fn ViewDepth_u0028_() -> f32 {
-    let _e187 = v_world_position_1;
-    let _e189 = fog_info.eye;
-    let _e193 = fog_info.forward;
-    return dot((_e187 - _e189.xyz), _e193.xyz);
+    let _e188 = v_world_position_1;
+    let _e190 = fog_info.eye;
+    let _e194 = fog_info.forward;
+    return dot((_e188 - _e190.xyz), _e194.xyz);
 }
 
 fn WeightedBlendedWeight_u0028_f1_u003b(alpha: ptr<function, f32>) -> f32 {
@@ -10091,22 +10140,22 @@ fn WeightedBlendedWeight_u0028_f1_u003b(alpha: ptr<function, f32>) -> f32 {
     var far: f32;
     var far3_: f32;
 
-    let _e192 = ViewDepth_u0028_();
-    z = abs(_e192);
-    let _e194 = z;
-    near = (_e194 / 5f);
-    let _e196 = z;
-    far = (_e196 / 200f);
-    let _e198 = far;
+    let _e193 = ViewDepth_u0028_();
+    z = abs(_e193);
+    let _e195 = z;
+    near = (_e195 / 5f);
+    let _e197 = z;
+    far = (_e197 / 200f);
     let _e199 = far;
-    let _e201 = far;
-    far3_ = ((_e198 * _e199) * _e201);
-    let _e203 = (*alpha);
-    let _e204 = near;
+    let _e200 = far;
+    let _e202 = far;
+    far3_ = ((_e199 * _e200) * _e202);
+    let _e204 = (*alpha);
     let _e205 = near;
-    let _e208 = far3_;
+    let _e206 = near;
     let _e209 = far3_;
-    return (_e203 * clamp((10f / ((0.00001f + (_e204 * _e205)) + (_e208 * _e209))), 0.01f, 3000f));
+    let _e210 = far3_;
+    return (_e204 * clamp((10f / ((0.00001f + (_e205 * _e206)) + (_e209 * _e210))), 0.01f, 3000f));
 }
 
 fn WriteWeightedBlended_u0028_() {
@@ -10118,39 +10167,39 @@ fn WriteWeightedBlended_u0028_() {
     var revealage: bool;
     var local: vec4<f32>;
 
-    let _e196 = fog_info.forward[3u];
-    mode = _e196;
-    let _e197 = mode;
-    if (_e197 > 0.5f) {
-        let _e200 = frag_color[3u];
-        alpha_1 = _e200;
-        let _e201 = alpha_1;
-        param = _e201;
-        let _e202 = WeightedBlendedWeight_u0028_f1_u003b((&param));
-        weight = _e202;
-        let _e203 = frag_color;
-        let _e205 = weight;
-        let _e206 = (_e203.xyz * _e205);
-        let _e207 = alpha_1;
-        let _e208 = weight;
-        accumulate = vec4<f32>(_e206.x, _e206.y, _e206.z, (_e207 * _e208));
-        let _e214 = mode;
-        let _e216 = mode;
-        revealage = ((_e214 > 1.5f) && (_e216 < 2.5f));
-        let _e219 = revealage;
-        if _e219 {
-            let _e220 = alpha_1;
-            local = vec4(_e220);
+    let _e197 = fog_info.forward[3u];
+    mode = _e197;
+    let _e198 = mode;
+    if (_e198 > 0.5f) {
+        let _e201 = frag_color[3u];
+        alpha_1 = _e201;
+        let _e202 = alpha_1;
+        param = _e202;
+        let _e203 = WeightedBlendedWeight_u0028_f1_u003b((&param));
+        weight = _e203;
+        let _e204 = frag_color;
+        let _e206 = weight;
+        let _e207 = (_e204.xyz * _e206);
+        let _e208 = alpha_1;
+        let _e209 = weight;
+        accumulate = vec4<f32>(_e207.x, _e207.y, _e207.z, (_e208 * _e209));
+        let _e215 = mode;
+        let _e217 = mode;
+        revealage = ((_e215 > 1.5f) && (_e217 < 2.5f));
+        let _e220 = revealage;
+        if _e220 {
+            let _e221 = alpha_1;
+            local = vec4(_e221);
         } else {
-            let _e222 = accumulate;
-            local = _e222;
-        }
-        let _e223 = local;
-        frag_color = _e223;
-        let _e224 = mode;
-        if (_e224 > 2.5f) {
-            let _e226 = alpha_1;
-            frag_surface = vec4(_e226);
+            let _e223 = accumulate;
+            local = _e223;
+        }
+        let _e224 = local;
+        frag_color = _e224;
+        let _e225 = mode;
+        if (_e225 > 2.5f) {
+            let _e227 = alpha_1;
+            frag_surface = vec4(_e227);
         }
     }
     return;
@@ -10159,29 +10208,29 @@ fn WriteWeightedBlended_u0028_() {
 fn EncodeOctahedral_u0028_vf3_u003b(n: ptr<function, vec3<f32>>) -> vec2<f32> {
     var e: vec2<f32>;
 
-    let _e190 = (*n)[0u];
-    let _e193 = (*n)[1u];
-    let _e197 = (*n)[2u];
-    let _e200 = (*n);
-    (*n) = (_e200 / vec3(((abs(_e190) + abs(_e193)) + abs(_e197))));
-    let _e203 = (*n);
-    e = _e203.xy;
-    let _e206 = (*n)[2u];
-    if (_e206 < 0f) {
-        let _e208 = (*n);
-        let _e214 = (*n)[0u];
-        let _e218 = (*n)[1u];
-        e = ((vec2(1f) - abs(_e208.yx)) * vec2<f32>(select(-1f, 1f, (_e214 >= 0f)), select(-1f, 1f, (_e218 >= 0f))));
+    let _e191 = (*n)[0u];
+    let _e194 = (*n)[1u];
+    let _e198 = (*n)[2u];
+    let _e201 = (*n);
+    (*n) = (_e201 / vec3(((abs(_e191) + abs(_e194)) + abs(_e198))));
+    let _e204 = (*n);
+    e = _e204.xy;
+    let _e207 = (*n)[2u];
+    if (_e207 < 0f) {
+        let _e209 = (*n);
+        let _e215 = (*n)[0u];
+        let _e219 = (*n)[1u];
+        e = ((vec2(1f) - abs(_e209.yx)) * vec2<f32>(select(-1f, 1f, (_e215 >= 0f)), select(-1f, 1f, (_e219 >= 0f))));
     }
-    let _e223 = e;
-    return ((_e223 * 0.5f) + vec2(0.5f));
+    let _e224 = e;
+    return ((_e224 * 0.5f) + vec2(0.5f));
 }
 
 fn LinearToSrgb_u0028_vf3_u003b(linear: ptr<function, vec3<f32>>) -> vec3<f32> {
-    let _e188 = (*linear);
-    let _e190 = (*linear);
-    let _e194 = (*linear);
-    return mix((_e188 * 12.92f), ((pow(_e190, vec3<f32>(0.41666666f, 0.41666666f, 0.41666666f)) * 1.055f) - vec3<f32>(0.055f, 0.055f, 0.055f)), step(vec3<f32>(0.0031308f, 0.0031308f, 0.0031308f), _e194));
+    let _e189 = (*linear);
+    let _e191 = (*linear);
+    let _e195 = (*linear);
+    return mix((_e189 * 12.92f), ((pow(_e191, vec3<f32>(0.41666666f, 0.41666666f, 0.41666666f)) * 1.055f) - vec3<f32>(0.055f, 0.055f, 0.055f)), step(vec3<f32>(0.0031308f, 0.0031308f, 0.0031308f), _e195));
 }
 
 fn WriteSurfaceGeometry_u0028_f1_u003b(roughness: ptr<function, f32>) {
@@ -10189,52 +10238,52 @@ fn WriteSurfaceGeometry_u0028_f1_u003b(roughness: ptr<function, f32>) {
     var geometric: vec3<f32>;
     var param_2: vec3<f32>;
 
-    let _e191 = g_albedo;
-    param_1 = clamp(_e191, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
-    let _e193 = LinearToSrgb_u0028_vf3_u003b((&param_1));
-    frag_albedo = vec4<f32>(_e193.x, _e193.y, _e193.z, 1f);
-    let _e198 = g_debug_surface_on;
-    if _e198 {
-        let _e199 = g_debug_surface;
-        let _e200 = ViewDepth_u0028_();
-        frag_surface = vec4<f32>(_e199.x, _e199.y, _e199.z, _e200);
+    let _e192 = g_albedo;
+    param_1 = clamp(_e192, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
+    let _e194 = LinearToSrgb_u0028_vf3_u003b((&param_1));
+    frag_albedo = vec4<f32>(_e194.x, _e194.y, _e194.z, 1f);
+    let _e199 = g_debug_surface_on;
+    if _e199 {
+        let _e200 = g_debug_surface;
+        let _e201 = ViewDepth_u0028_();
+        frag_surface = vec4<f32>(_e200.x, _e200.y, _e200.z, _e201);
         return;
     }
-    let _e205 = v_normal_1;
-    geometric = normalize(_e205);
-    let _e207 = gl_FrontFacing_1;
-    if !(_e207) {
-        let _e209 = geometric;
-        geometric = -(_e209);
+    let _e206 = v_normal_1;
+    geometric = normalize(_e206);
+    let _e208 = gl_FrontFacing_1;
+    if !(_e208) {
+        let _e210 = geometric;
+        geometric = -(_e210);
     }
-    let _e211 = geometric;
-    param_2 = _e211;
-    let _e212 = EncodeOctahedral_u0028_vf3_u003b((&param_2));
-    let _e213 = (*roughness);
-    let _e215 = ViewDepth_u0028_();
-    frag_surface = vec4<f32>(_e212.x, _e212.y, clamp(_e213, 0f, 1f), _e215);
+    let _e212 = geometric;
+    param_2 = _e212;
+    let _e213 = EncodeOctahedral_u0028_vf3_u003b((&param_2));
+    let _e214 = (*roughness);
+    let _e216 = ViewDepth_u0028_();
+    frag_surface = vec4<f32>(_e213.x, _e213.y, clamp(_e214, 0f, 1f), _e216);
     return;
 }
 
 fn Orthographic_u0028_() -> bool {
-    let _e189 = fog_info.projection[0u];
-    return (_e189 > 0.5f);
+    let _e190 = fog_info.projection[0u];
+    return (_e190 > 0.5f);
 }
 
 fn EyeDistance_u0028_() -> f32 {
     var local_1: f32;
 
-    let _e188 = Orthographic_u0028_();
-    if _e188 {
-        let _e189 = ViewDepth_u0028_();
-        local_1 = max(_e189, 0f);
+    let _e189 = Orthographic_u0028_();
+    if _e189 {
+        let _e190 = ViewDepth_u0028_();
+        local_1 = max(_e190, 0f);
     } else {
-        let _e191 = v_world_position_1;
-        let _e193 = fog_info.eye;
-        local_1 = distance(_e191, _e193.xyz);
+        let _e192 = v_world_position_1;
+        let _e194 = fog_info.eye;
+        local_1 = distance(_e192, _e194.xyz);
     }
-    let _e196 = local_1;
-    return _e196;
+    let _e197 = local_1;
+    return _e197;
 }
 
 fn ApplyFog_u0028_vf3_u003b(color: ptr<function, vec3<f32>>) -> vec3<f32> {
@@ -10244,41 +10293,41 @@ fn ApplyFog_u0028_vf3_u003b(color: ptr<function, vec3<f32>>) -> vec3<f32> {
     var k: f32;
     var local_2: f32;
 
-    let _e195 = fog_info.fog[3u];
-    density = _e195;
-    let _e196 = density;
-    if (_e196 <= 0f) {
-        let _e198 = (*color);
-        return _e198;
+    let _e196 = fog_info.fog[3u];
+    density = _e196;
+    let _e197 = density;
+    if (_e197 <= 0f) {
+        let _e199 = (*color);
+        return _e199;
     }
-    let _e199 = EyeDistance_u0028_();
-    d = _e199;
-    let _e202 = fog_info.eye[3u];
-    falloff = _e202;
-    let _e203 = falloff;
-    if (_e203 > 0f) {
-        let _e205 = falloff;
-        let _e207 = v_world_position_1[1u];
-        let _e210 = fog_info.eye[1u];
-        k = (_e205 * (_e207 - _e210));
-        let _e213 = k;
-        if (abs(_e213) > 0.001f) {
-            let _e216 = k;
-            let _e220 = k;
-            local_2 = ((1f - exp(-(_e216))) / _e220);
+    let _e200 = EyeDistance_u0028_();
+    d = _e200;
+    let _e203 = fog_info.eye[3u];
+    falloff = _e203;
+    let _e204 = falloff;
+    if (_e204 > 0f) {
+        let _e206 = falloff;
+        let _e208 = v_world_position_1[1u];
+        let _e211 = fog_info.eye[1u];
+        k = (_e206 * (_e208 - _e211));
+        let _e214 = k;
+        if (abs(_e214) > 0.001f) {
+            let _e217 = k;
+            let _e221 = k;
+            local_2 = ((1f - exp(-(_e217))) / _e221);
         } else {
-            let _e222 = k;
-            local_2 = (1f - (0.5f * _e222));
+            let _e223 = k;
+            local_2 = (1f - (0.5f * _e223));
         }
-        let _e225 = local_2;
-        let _e226 = density;
-        density = (_e226 * _e225);
+        let _e226 = local_2;
+        let _e227 = density;
+        density = (_e227 * _e226);
     }
-    let _e229 = fog_info.fog;
-    let _e231 = (*color);
-    let _e232 = density;
-    let _e234 = d;
-    return mix(_e229.xyz, _e231, vec3(clamp(exp((-(_e232) * _e234)), 0f, 1f)));
+    let _e230 = fog_info.fog;
+    let _e232 = (*color);
+    let _e233 = density;
+    let _e235 = d;
+    return mix(_e230.xyz, _e232, vec3(clamp(exp((-(_e233) * _e235)), 0f, 1f)));
 }
 
 fn WriteSurface_u0028_vf3_u003b_f1_u003b_f1_u003b(linearColor: ptr<function, vec3<f32>>, alpha_2: ptr<function, f32>, roughness_1: ptr<function, f32>) {
@@ -10286,44 +10335,44 @@ fn WriteSurface_u0028_vf3_u003b_f1_u003b_f1_u003b(linearColor: ptr<function, vec
     var param_3: vec3<f32>;
     var param_4: f32;
 
-    let _e193 = g_premultiply;
-    let _e194 = (*alpha_2);
-    weight_1 = select(1f, _e194, _e193);
-    let _e196 = (*linearColor);
-    param_3 = _e196;
-    let _e197 = ApplyFog_u0028_vf3_u003b((&param_3));
-    let _e198 = weight_1;
-    let _e199 = (_e197 * _e198);
-    let _e200 = (*alpha_2);
-    let _e201 = g_pass_through;
-    frag_color = vec4<f32>(_e199.x, _e199.y, _e199.z, (_e200 * (1f - _e201)));
-    let _e208 = (*roughness_1);
-    param_4 = _e208;
+    let _e194 = g_premultiply;
+    let _e195 = (*alpha_2);
+    weight_1 = select(1f, _e195, _e194);
+    let _e197 = (*linearColor);
+    param_3 = _e197;
+    let _e198 = ApplyFog_u0028_vf3_u003b((&param_3));
+    let _e199 = weight_1;
+    let _e200 = (_e198 * _e199);
+    let _e201 = (*alpha_2);
+    let _e202 = g_pass_through;
+    frag_color = vec4<f32>(_e200.x, _e200.y, _e200.z, (_e201 * (1f - _e202)));
+    let _e209 = (*roughness_1);
+    param_4 = _e209;
     WriteSurfaceGeometry_u0028_f1_u003b((&param_4));
     WriteWeightedBlended_u0028_();
     return;
 }
 
 fn SrgbToLinear_u0028_vf3_u003b(srgb: ptr<function, vec3<f32>>) -> vec3<f32> {
-    let _e188 = (*srgb);
-    let _e191 = (*srgb);
-    let _e196 = (*srgb);
-    return mix((_e188 / vec3(12.92f)), pow(((_e191 + vec3<f32>(0.055f, 0.055f, 0.055f)) / vec3(1.055f)), vec3<f32>(2.4f, 2.4f, 2.4f)), step(vec3<f32>(0.04045f, 0.04045f, 0.04045f), _e196));
+    let _e189 = (*srgb);
+    let _e192 = (*srgb);
+    let _e197 = (*srgb);
+    return mix((_e189 / vec3(12.92f)), pow(((_e192 + vec3<f32>(0.055f, 0.055f, 0.055f)) / vec3(1.055f)), vec3<f32>(2.4f, 2.4f, 2.4f)), step(vec3<f32>(0.04045f, 0.04045f, 0.04045f), _e197));
 }
 
 fn NonFinite_u0028_vf3_u003b(c: ptr<function, vec3<f32>>) -> bool {
     var phi_2562_: bool;
 
-    let _e188 = (*c);
     let _e189 = (*c);
-    let _e191 = any((_e188 != _e189));
-    phi_2562_ = _e191;
-    if !(_e191) {
-        let _e193 = (*c);
-        phi_2562_ = any((abs(_e193) > vec3<f32>(300000000000000000000000000000000000000f, 300000000000000000000000000000000000000f, 300000000000000000000000000000000000000f)));
+    let _e190 = (*c);
+    let _e192 = any((_e189 != _e190));
+    phi_2562_ = _e192;
+    if !(_e192) {
+        let _e194 = (*c);
+        phi_2562_ = any((abs(_e194) > vec3<f32>(300000000000000000000000000000000000000f, 300000000000000000000000000000000000000f, 300000000000000000000000000000000000000f)));
     }
-    let _e198 = phi_2562_;
-    return _e198;
+    let _e199 = phi_2562_;
+    return _e199;
 }
 
 fn WriteDebugView_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_vf3_u003b(s: ptr<function, Surface>, lit: ptr<function, vec3<f32>>) -> bool {
@@ -10341,78 +10390,78 @@ fn WriteDebugView_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_
     var param_9: vec3<f32>;
     var param_10: f32;
 
-    let _e204 = frag_info.debug_view[0u];
-    view = _e204;
-    let _e205 = view;
-    if (_e205 < 0.5f) {
+    let _e205 = frag_info.debug_view[0u];
+    view = _e205;
+    let _e206 = view;
+    if (_e206 < 0.5f) {
         return false;
     }
-    let _e208 = gl_FragCoord_1[0u];
-    let _e211 = frag_info.debug_view[1u];
-    let _e214 = frag_info.debug_view[2u];
-    if (_e208 < (_e211 * _e214)) {
+    let _e209 = gl_FragCoord_1[0u];
+    let _e212 = frag_info.debug_view[1u];
+    let _e215 = frag_info.debug_view[2u];
+    if (_e209 < (_e212 * _e215)) {
         return false;
     }
-    let _e217 = view;
-    code = i32((_e217 + 0.5f));
+    let _e218 = view;
+    code = i32((_e218 + 0.5f));
     shown = vec3<f32>(0f, 0f, 0f);
-    let _e220 = code;
-    if (_e220 == 1i) {
-        let _e223 = (*s).albedo;
-        param_5 = clamp(_e223, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
-        let _e225 = LinearToSrgb_u0028_vf3_u003b((&param_5));
-        shown = _e225;
+    let _e221 = code;
+    if (_e221 == 1i) {
+        let _e224 = (*s).albedo;
+        param_5 = clamp(_e224, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
+        let _e226 = LinearToSrgb_u0028_vf3_u003b((&param_5));
+        shown = _e226;
     } else {
-        let _e226 = code;
-        if (_e226 == 2i) {
-            let _e229 = (*s).n;
-            shown = ((_e229 * 0.5f) + vec3<f32>(0.5f, 0.5f, 0.5f));
+        let _e227 = code;
+        if (_e227 == 2i) {
+            let _e230 = (*s).n;
+            shown = ((_e230 * 0.5f) + vec3<f32>(0.5f, 0.5f, 0.5f));
         } else {
-            let _e232 = code;
-            if (_e232 == 3i) {
-                let _e235 = (*s).roughness;
-                shown = vec3(clamp(_e235, 0f, 1f));
+            let _e233 = code;
+            if (_e233 == 3i) {
+                let _e236 = (*s).roughness;
+                shown = vec3(clamp(_e236, 0f, 1f));
             } else {
-                let _e238 = code;
-                if (_e238 == 4i) {
-                    let _e241 = (*s).metallic;
-                    shown = vec3(clamp(_e241, 0f, 1f));
+                let _e239 = code;
+                if (_e239 == 4i) {
+                    let _e242 = (*s).metallic;
+                    shown = vec3(clamp(_e242, 0f, 1f));
                 } else {
-                    let _e244 = code;
-                    if (_e244 == 5i) {
-                        let _e247 = (*s).occlusion;
-                        shown = vec3(clamp(_e247, 0f, 1f));
+                    let _e245 = code;
+                    if (_e245 == 5i) {
+                        let _e248 = (*s).occlusion;
+                        shown = vec3(clamp(_e248, 0f, 1f));
                     } else {
-                        let _e250 = code;
-                        if (_e250 == 6i) {
-                            let _e253 = (*s).emissive;
-                            param_6 = clamp(_e253, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
-                            let _e255 = LinearToSrgb_u0028_vf3_u003b((&param_6));
-                            shown = _e255;
+                        let _e251 = code;
+                        if (_e251 == 6i) {
+                            let _e254 = (*s).emissive;
+                            param_6 = clamp(_e254, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
+                            let _e256 = LinearToSrgb_u0028_vf3_u003b((&param_6));
+                            shown = _e256;
                         } else {
-                            let _e256 = code;
-                            if (_e256 == 7i) {
-                                let _e258 = v_texcoord_1;
-                                let _e259 = fract(_e258);
-                                shown = vec3<f32>(_e259.x, _e259.y, 0f);
+                            let _e257 = code;
+                            if (_e257 == 7i) {
+                                let _e259 = v_texcoord_1;
+                                let _e260 = fract(_e259);
+                                shown = vec3<f32>(_e260.x, _e260.y, 0f);
                             } else {
-                                let _e263 = code;
-                                if (_e263 == 8i) {
-                                    let _e265 = (*lit);
-                                    param_7 = clamp(_e265, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
-                                    let _e267 = LinearToSrgb_u0028_vf3_u003b((&param_7));
-                                    grey = dot(_e267, vec3<f32>(0.2126f, 0.7152f, 0.0722f));
-                                    let _e269 = (*lit);
-                                    param_8 = _e269;
-                                    let _e270 = NonFinite_u0028_vf3_u003b((&param_8));
-                                    if _e270 {
+                                let _e264 = code;
+                                if (_e264 == 8i) {
+                                    let _e266 = (*lit);
+                                    param_7 = clamp(_e266, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
+                                    let _e268 = LinearToSrgb_u0028_vf3_u003b((&param_7));
+                                    grey = dot(_e268, vec3<f32>(0.2126f, 0.7152f, 0.0722f));
+                                    let _e270 = (*lit);
+                                    param_8 = _e270;
+                                    let _e271 = NonFinite_u0028_vf3_u003b((&param_8));
+                                    if _e271 {
                                         local_3 = vec3<f32>(1f, 0f, 1f);
                                     } else {
-                                        let _e271 = grey;
-                                        local_3 = vec3((_e271 * 0.5f));
+                                        let _e272 = grey;
+                                        local_3 = vec3((_e272 * 0.5f));
                                     }
-                                    let _e274 = local_3;
-                                    shown = _e274;
+                                    let _e275 = local_3;
+                                    shown = _e275;
                                 }
                             }
                         }
@@ -10421,24 +10470,24 @@ fn WriteDebugView_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_
             }
         }
     }
-    let _e275 = g_premultiply;
-    if _e275 {
-        let _e277 = (*s).alpha;
-        local_4 = _e277;
+    let _e276 = g_premultiply;
+    if _e276 {
+        let _e278 = (*s).alpha;
+        local_4 = _e278;
     } else {
         local_4 = 1f;
     }
-    let _e278 = local_4;
-    weight_2 = _e278;
-    let _e279 = shown;
-    param_9 = _e279;
-    let _e280 = SrgbToLinear_u0028_vf3_u003b((&param_9));
-    let _e281 = weight_2;
-    let _e282 = (_e280 * _e281);
-    let _e284 = (*s).alpha;
-    frag_color = vec4<f32>(_e282.x, _e282.y, _e282.z, _e284);
-    let _e290 = (*s).roughness;
-    param_10 = _e290;
+    let _e279 = local_4;
+    weight_2 = _e279;
+    let _e280 = shown;
+    param_9 = _e280;
+    let _e281 = SrgbToLinear_u0028_vf3_u003b((&param_9));
+    let _e282 = weight_2;
+    let _e283 = (_e281 * _e282);
+    let _e285 = (*s).alpha;
+    frag_color = vec4<f32>(_e283.x, _e283.y, _e283.z, _e285);
+    let _e291 = (*s).roughness;
+    param_10 = _e291;
     WriteSurfaceGeometry_u0028_f1_u003b((&param_10));
     WriteWeightedBlended_u0028_();
     return true;
@@ -10448,44 +10497,44 @@ fn ShadeLight_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_
     var shininess: f32;
     var specular: f32;
 
-    let _e192 = (*s_1).roughness;
-    shininess = mix(256f, 4f, _e192);
-    let _e195 = (*light).n_dot_h;
-    let _e196 = shininess;
-    let _e200 = frag_info.material[3u];
-    specular = (pow(_e195, _e196) * _e200);
-    let _e203 = (*s_1).albedo;
-    let _e204 = specular;
-    return (_e203 + vec3(_e204));
+    let _e193 = (*s_1).roughness;
+    shininess = mix(256f, 4f, _e193);
+    let _e196 = (*light).n_dot_h;
+    let _e197 = shininess;
+    let _e201 = frag_info.material[3u];
+    specular = (pow(_e196, _e197) * _e201);
+    let _e204 = (*s_1).albedo;
+    let _e205 = specular;
+    return (_e204 + vec3(_e205));
 }
 
 fn PointShadowDiskTap_u0028_i1_u003b(i: ptr<function, i32>) -> vec2<f32> {
-    let _e188 = (*i);
-    if (_e188 == 0i) {
+    let _e189 = (*i);
+    if (_e189 == 0i) {
         return vec2<f32>(-0.94201624f, -0.39906216f);
     }
-    let _e190 = (*i);
-    if (_e190 == 1i) {
+    let _e191 = (*i);
+    if (_e191 == 1i) {
         return vec2<f32>(0.9455861f, -0.76890725f);
     }
-    let _e192 = (*i);
-    if (_e192 == 2i) {
+    let _e193 = (*i);
+    if (_e193 == 2i) {
         return vec2<f32>(-0.0941841f, -0.9293887f);
     }
-    let _e194 = (*i);
-    if (_e194 == 3i) {
+    let _e195 = (*i);
+    if (_e195 == 3i) {
         return vec2<f32>(0.34495938f, 0.2938776f);
     }
-    let _e196 = (*i);
-    if (_e196 == 4i) {
+    let _e197 = (*i);
+    if (_e197 == 4i) {
         return vec2<f32>(-0.9158858f, 0.45771432f);
     }
-    let _e198 = (*i);
-    if (_e198 == 5i) {
+    let _e199 = (*i);
+    if (_e199 == 5i) {
         return vec2<f32>(-0.8154423f, -0.87912464f);
     }
-    let _e200 = (*i);
-    if (_e200 == 6i) {
+    let _e201 = (*i);
+    if (_e201 == 6i) {
         return vec2<f32>(-0.38277543f, 0.27676845f);
     }
     return vec2<f32>(0.974844f, 0.7564838f);
@@ -10495,20 +10544,20 @@ fn PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b(i_1: ptr<function
     var p: vec2<f32>;
     var param_11: i32;
 
-    let _e193 = (*i_1);
-    param_11 = _e193;
-    let _e194 = PointShadowDiskTap_u0028_i1_u003b((&param_11));
-    p = _e194;
-    let _e196 = p[0u];
-    let _e197 = (*ca);
-    let _e200 = p[1u];
-    let _e201 = (*sa);
-    let _e205 = p[0u];
-    let _e206 = (*sa);
-    let _e209 = p[1u];
-    let _e210 = (*ca);
-    let _e214 = (*radius);
-    return (vec2<f32>(((_e196 * _e197) - (_e200 * _e201)), ((_e205 * _e206) + (_e209 * _e210))) * _e214);
+    let _e194 = (*i_1);
+    param_11 = _e194;
+    let _e195 = PointShadowDiskTap_u0028_i1_u003b((&param_11));
+    p = _e195;
+    let _e197 = p[0u];
+    let _e198 = (*ca);
+    let _e201 = p[1u];
+    let _e202 = (*sa);
+    let _e206 = p[0u];
+    let _e207 = (*sa);
+    let _e210 = p[1u];
+    let _e211 = (*ca);
+    let _e215 = (*radius);
+    return (vec2<f32>(((_e197 * _e198) - (_e201 * _e202)), ((_e206 * _e207) + (_e210 * _e211))) * _e215);
 }
 
 fn PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b(uv: ptr<function, vec2<f32>>, offset: ptr<function, vec2<f32>>, tile: ptr<function, vec2<f32>>, range: ptr<function, f32>) -> f32 {
@@ -10516,27 +10565,27 @@ fn PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b(uv: ptr<func
     var local_5: vec2<f32>;
     var atlas: vec2<f32>;
 
-    let _e196 = point_shadow.params[0u];
-    inset = _e196;
-    let _e197 = (*uv);
-    let _e198 = (*offset);
-    let _e200 = inset;
+    let _e197 = point_shadow.params[0u];
+    inset = _e197;
+    let _e198 = (*uv);
+    let _e199 = (*offset);
     let _e201 = inset;
-    local_5 = clamp((_e197 + _e198), vec2(_e200), vec2((1f - _e201)));
-    let _e206 = local_5;
-    let _e207 = (*tile);
-    atlas = ((_e206 + _e207) * vec2<f32>(0.16666667f, 0.16666667f));
-    let _e212 = point_shadow.params3_[0u];
-    if (_e212 > 0.5f) {
-        let _e215 = atlas[1u];
-        atlas[1u] = (1f - _e215);
+    let _e202 = inset;
+    local_5 = clamp((_e198 + _e199), vec2(_e201), vec2((1f - _e202)));
+    let _e207 = local_5;
+    let _e208 = (*tile);
+    atlas = ((_e207 + _e208) * vec2<f32>(0.16666667f, 0.16666667f));
+    let _e213 = point_shadow.params3_[0u];
+    if (_e213 > 0.5f) {
+        let _e216 = atlas[1u];
+        atlas[1u] = (1f - _e216);
     }
-    let _e218 = atlas;
-    let _e219 = textureSampleLevel(point_shadow_texture_tex, point_shadow_texture_smp, _e218, 0f);
-    let _e221 = atlas;
-    let _e222 = textureSampleLevel(point_shadow_static_texture_tex, point_shadow_static_texture_smp, _e221, 0f);
-    let _e225 = (*range);
-    return (min(_e219.x, _e222.x) * _e225);
+    let _e219 = atlas;
+    let _e220 = textureSampleLevel(point_shadow_texture_tex, point_shadow_texture_smp, _e219, 0f);
+    let _e222 = atlas;
+    let _e223 = textureSampleLevel(point_shadow_static_texture_tex, point_shadow_static_texture_smp, _e222, 0f);
+    let _e226 = (*range);
+    return (min(_e220.x, _e223.x) * _e226);
 }
 
 fn PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b(uv_1: ptr<function, vec2<f32>>, offset_1: ptr<function, vec2<f32>>, tile_1: ptr<function, vec2<f32>>, range_1: ptr<function, f32>, receiver: ptr<function, f32>) -> f32 {
@@ -10546,24 +10595,24 @@ fn PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b(uv_1: pt
     var param_14: vec2<f32>;
     var param_15: f32;
 
-    let _e197 = (*uv_1);
-    param_12 = _e197;
-    let _e198 = (*offset_1);
-    param_13 = _e198;
-    let _e199 = (*tile_1);
-    param_14 = _e199;
-    let _e200 = (*range_1);
-    param_15 = _e200;
-    let _e201 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((&param_12), (&param_13), (&param_14), (&param_15));
-    stored = _e201;
-    let _e202 = stored;
-    let _e203 = (*range_1);
-    if (_e202 >= (_e203 * 0.999f)) {
+    let _e198 = (*uv_1);
+    param_12 = _e198;
+    let _e199 = (*offset_1);
+    param_13 = _e199;
+    let _e200 = (*tile_1);
+    param_14 = _e200;
+    let _e201 = (*range_1);
+    param_15 = _e201;
+    let _e202 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((&param_12), (&param_13), (&param_14), (&param_15));
+    stored = _e202;
+    let _e203 = stored;
+    let _e204 = (*range_1);
+    if (_e203 >= (_e204 * 0.999f)) {
         return 1f;
     }
-    let _e206 = (*receiver);
-    let _e207 = stored;
-    return select(1f, 0f, (_e206 > _e207));
+    let _e207 = (*receiver);
+    let _e208 = stored;
+    return select(1f, 0f, (_e207 > _e208));
 }
 
 fn PointShadowPenumbra_u0028_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b(uv_2: ptr<function, vec2<f32>>, tile_2: ptr<function, vec2<f32>>, range_2: ptr<function, f32>, receiver_1: ptr<function, f32>, ca_1: ptr<function, f32>, sa_1: ptr<function, f32>, tanHalf: ptr<function, f32>, blockerOut: ptr<function, f32>) -> f32 {
@@ -10590,111 +10639,111 @@ fn PointShadowPenumbra_u0028_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u
     var world: f32;
 
     (*blockerOut) = -1f;
-    let _e218 = point_shadow.params2_[1u];
-    lightRadius = _e218;
-    let _e221 = point_shadow.params2_[0u];
-    minRadius = _e221;
-    let _e224 = point_shadow.params2_[2u];
-    maxRadius = _e224;
-    let _e225 = lightRadius;
-    if (_e225 <= 0f) {
-        let _e227 = (*uv_2);
-        param_16 = _e227;
+    let _e219 = point_shadow.params2_[1u];
+    lightRadius = _e219;
+    let _e222 = point_shadow.params2_[0u];
+    minRadius = _e222;
+    let _e225 = point_shadow.params2_[2u];
+    maxRadius = _e225;
+    let _e226 = lightRadius;
+    if (_e226 <= 0f) {
+        let _e228 = (*uv_2);
+        param_16 = _e228;
         param_17 = vec2<f32>(0f, 0f);
-        let _e228 = (*tile_2);
-        param_18 = _e228;
-        let _e229 = (*range_2);
-        param_19 = _e229;
-        let _e230 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((&param_16), (&param_17), (&param_18), (&param_19));
-        (*blockerOut) = _e230;
-        let _e231 = minRadius;
-        return _e231;
+        let _e229 = (*tile_2);
+        param_18 = _e229;
+        let _e230 = (*range_2);
+        param_19 = _e230;
+        let _e231 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((&param_16), (&param_17), (&param_18), (&param_19));
+        (*blockerOut) = _e231;
+        let _e232 = minRadius;
+        return _e232;
     }
     sum = 0f;
     count = 0f;
     i_2 = 0i;
     loop {
-        let _e232 = i_2;
-        if (_e232 < 8i) {
-            let _e234 = i_2;
-            param_20 = _e234;
-            let _e235 = (*ca_1);
-            param_21 = _e235;
-            let _e236 = (*sa_1);
-            param_22 = _e236;
-            let _e237 = maxRadius;
-            param_23 = _e237;
-            let _e238 = PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b((&param_20), (&param_21), (&param_22), (&param_23));
-            let _e239 = (*uv_2);
-            param_24 = _e239;
-            param_25 = _e238;
-            let _e240 = (*tile_2);
-            param_26 = _e240;
-            let _e241 = (*range_2);
-            param_27 = _e241;
-            let _e242 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((&param_24), (&param_25), (&param_26), (&param_27));
-            stored_1 = _e242;
-            let _e243 = stored_1;
-            let _e244 = (*range_2);
-            if (_e243 >= (_e244 * 0.999f)) {
+        let _e233 = i_2;
+        if (_e233 < 8i) {
+            let _e235 = i_2;
+            param_20 = _e235;
+            let _e236 = (*ca_1);
+            param_21 = _e236;
+            let _e237 = (*sa_1);
+            param_22 = _e237;
+            let _e238 = maxRadius;
+            param_23 = _e238;
+            let _e239 = PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b((&param_20), (&param_21), (&param_22), (&param_23));
+            let _e240 = (*uv_2);
+            param_24 = _e240;
+            param_25 = _e239;
+            let _e241 = (*tile_2);
+            param_26 = _e241;
+            let _e242 = (*range_2);
+            param_27 = _e242;
+            let _e243 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((&param_24), (&param_25), (&param_26), (&param_27));
+            stored_1 = _e243;
+            let _e244 = stored_1;
+            let _e245 = (*range_2);
+            if (_e244 >= (_e245 * 0.999f)) {
                 continue;
             }
-            let _e247 = stored_1;
-            let _e248 = (*receiver_1);
-            if (_e247 >= _e248) {
+            let _e248 = stored_1;
+            let _e249 = (*receiver_1);
+            if (_e248 >= _e249) {
                 continue;
             }
-            let _e250 = stored_1;
-            let _e251 = sum;
-            sum = (_e251 + _e250);
-            let _e253 = count;
-            count = (_e253 + 1f);
+            let _e251 = stored_1;
+            let _e252 = sum;
+            sum = (_e252 + _e251);
+            let _e254 = count;
+            count = (_e254 + 1f);
             continue;
         } else {
             break;
         }
         continuing {
-            let _e255 = i_2;
-            i_2 = (_e255 + 1i);
+            let _e256 = i_2;
+            i_2 = (_e256 + 1i);
         }
     }
-    let _e257 = count;
-    if (_e257 < 0.5f) {
+    let _e258 = count;
+    if (_e258 < 0.5f) {
         return -1f;
     }
-    let _e259 = sum;
-    let _e260 = count;
-    blocker = max((_e259 / _e260), 0.0001f);
-    let _e263 = blocker;
-    (*blockerOut) = _e263;
-    let _e264 = lightRadius;
-    let _e265 = (*receiver_1);
-    let _e266 = blocker;
-    let _e270 = blocker;
-    world = ((_e264 * max((_e265 - _e266), 0f)) / _e270);
-    let _e272 = world;
-    let _e273 = (*receiver_1);
-    let _e275 = (*tanHalf);
-    let _e278 = minRadius;
-    let _e279 = maxRadius;
-    return clamp((_e272 / ((2f * _e273) * _e275)), _e278, _e279);
+    let _e260 = sum;
+    let _e261 = count;
+    blocker = max((_e260 / _e261), 0.0001f);
+    let _e264 = blocker;
+    (*blockerOut) = _e264;
+    let _e265 = lightRadius;
+    let _e266 = (*receiver_1);
+    let _e267 = blocker;
+    let _e271 = blocker;
+    world = ((_e265 * max((_e266 - _e267), 0f)) / _e271);
+    let _e273 = world;
+    let _e274 = (*receiver_1);
+    let _e276 = (*tanHalf);
+    let _e279 = minRadius;
+    let _e280 = maxRadius;
+    return clamp((_e273 / ((2f * _e274) * _e276)), _e279, _e280);
 }
 
 fn FragCoordFromTop_u0028_f1_u003b(rows: ptr<function, f32>) -> vec2<f32> {
     var local_6: vec2<f32>;
 
-    let _e189 = (*rows);
-    if (_e189 > 0f) {
-        let _e192 = gl_FragCoord_1[0u];
-        let _e193 = (*rows);
-        let _e195 = gl_FragCoord_1[1u];
-        local_6 = vec2<f32>(_e192, (_e193 - _e195));
+    let _e190 = (*rows);
+    if (_e190 > 0f) {
+        let _e193 = gl_FragCoord_1[0u];
+        let _e194 = (*rows);
+        let _e196 = gl_FragCoord_1[1u];
+        local_6 = vec2<f32>(_e193, (_e194 - _e196));
     } else {
-        let _e198 = gl_FragCoord_1;
-        local_6 = _e198.xy;
+        let _e199 = gl_FragCoord_1;
+        local_6 = _e199.xy;
     }
-    let _e200 = local_6;
-    return _e200;
+    let _e201 = local_6;
+    return _e201;
 }
 
 fn PointShadowFactor_u0028_vf3_u003b_vf3_u003b_i1_u003b(world_1: ptr<function, vec3<f32>>, normal: ptr<function, vec3<f32>>, lightIndex: ptr<function, i32>) -> f32 {
@@ -10752,257 +10801,257 @@ fn PointShadowFactor_u0028_vf3_u003b_vf3_u003b_i1_u003b(world_1: ptr<function, v
     var phi_2249_: bool;
     var phi_2310_: bool;
 
-    let _e241 = (*lightIndex);
-    let _e245 = point_shadow.slots[_e241][0u];
-    slot = i32((_e245 + 0.5f));
-    let _e248 = (*lightIndex);
-    let _e252 = point_shadow.slots[_e248][0u];
-    if (_e252 < 0f) {
+    let _e242 = (*lightIndex);
+    let _e246 = point_shadow.slots[_e242][0u];
+    slot = i32((_e246 + 0.5f));
+    let _e249 = (*lightIndex);
+    let _e253 = point_shadow.slots[_e249][0u];
+    if (_e253 < 0f) {
         return 1f;
     }
-    let _e256 = point_shadow.params[2u];
-    strength = _e256;
-    let _e257 = strength;
-    if (_e257 <= 0f) {
+    let _e257 = point_shadow.params[2u];
+    strength = _e257;
+    let _e258 = strength;
+    if (_e258 <= 0f) {
         return 1f;
     }
-    let _e259 = slot;
-    let _e262 = point_shadow.lights[_e259];
-    let _e264 = (*world_1);
-    toLight = (_e262.xyz - _e264);
-    let _e266 = toLight;
-    toLightLength = max(length(_e266), 0.000001f);
-    let _e269 = (*normal);
-    let _e270 = toLight;
-    let _e271 = toLightLength;
-    nDotL = max(dot(_e269, (_e270 / vec3(_e271))), 0.15f);
-    let _e276 = nDotL;
+    let _e260 = slot;
+    let _e263 = point_shadow.lights[_e260];
+    let _e265 = (*world_1);
+    toLight = (_e263.xyz - _e265);
+    let _e267 = toLight;
+    toLightLength = max(length(_e267), 0.000001f);
+    let _e270 = (*normal);
+    let _e271 = toLight;
+    let _e272 = toLightLength;
+    nDotL = max(dot(_e270, (_e271 / vec3(_e272))), 0.15f);
     let _e277 = nDotL;
-    let _e282 = nDotL;
+    let _e278 = nDotL;
     let _e283 = nDotL;
-    slope = min((sqrt(max((1f - (_e276 * _e277)), 0f)) / (_e282 * _e283)), 8f);
-    let _e287 = toLightLength;
-    let _e289 = (*lightIndex);
-    let _e293 = point_shadow.slots[_e289][2u];
-    let _e298 = point_shadow.params3_[1u];
-    texel = (((2f * _e287) * max(_e293, 0.0001f)) * _e298);
-    let _e300 = (*world_1);
-    let _e301 = (*normal);
-    let _e302 = texel;
-    let _e306 = point_shadow.params[3u];
-    let _e308 = slope;
-    origin = (_e300 + (((_e301 * _e302) * _e306) * (1f + _e308)));
-    let _e312 = origin;
-    let _e313 = slot;
-    let _e316 = point_shadow.lights[_e313];
-    toFragment = (_e312 - _e316.xyz);
-    let _e319 = toFragment;
-    distance_ = length(_e319);
-    let _e321 = slot;
-    let _e325 = point_shadow.lights[_e321][3u];
-    range_3 = max(_e325, 0.0001f);
-    let _e327 = distance_;
-    let _e328 = range_3;
-    if (_e327 >= _e328) {
+    let _e284 = nDotL;
+    slope = min((sqrt(max((1f - (_e277 * _e278)), 0f)) / (_e283 * _e284)), 8f);
+    let _e288 = toLightLength;
+    let _e290 = (*lightIndex);
+    let _e294 = point_shadow.slots[_e290][2u];
+    let _e299 = point_shadow.params3_[1u];
+    texel = (((2f * _e288) * max(_e294, 0.0001f)) * _e299);
+    let _e301 = (*world_1);
+    let _e302 = (*normal);
+    let _e303 = texel;
+    let _e307 = point_shadow.params[3u];
+    let _e309 = slope;
+    origin = (_e301 + (((_e302 * _e303) * _e307) * (1f + _e309)));
+    let _e313 = origin;
+    let _e314 = slot;
+    let _e317 = point_shadow.lights[_e314];
+    toFragment = (_e313 - _e317.xyz);
+    let _e320 = toFragment;
+    distance_ = length(_e320);
+    let _e322 = slot;
+    let _e326 = point_shadow.lights[_e322][3u];
+    range_3 = max(_e326, 0.0001f);
+    let _e328 = distance_;
+    let _e329 = range_3;
+    if (_e328 >= _e329) {
         return 1f;
     }
     face = 0i;
-    let _e330 = (*lightIndex);
-    let _e334 = point_shadow.slots[_e330][1u];
-    if (_e334 < 0.5f) {
-        let _e336 = toFragment;
-        a = abs(_e336);
-        let _e339 = a[0u];
-        let _e341 = a[1u];
-        let _e342 = (_e339 >= _e341);
-        phi_2249_ = _e342;
-        if _e342 {
-            let _e344 = a[0u];
-            let _e346 = a[2u];
-            phi_2249_ = (_e344 >= _e346);
+    let _e331 = (*lightIndex);
+    let _e335 = point_shadow.slots[_e331][1u];
+    if (_e335 < 0.5f) {
+        let _e337 = toFragment;
+        a = abs(_e337);
+        let _e340 = a[0u];
+        let _e342 = a[1u];
+        let _e343 = (_e340 >= _e342);
+        phi_2249_ = _e343;
+        if _e343 {
+            let _e345 = a[0u];
+            let _e347 = a[2u];
+            phi_2249_ = (_e345 >= _e347);
         }
-        let _e349 = phi_2249_;
-        if _e349 {
-            let _e351 = toFragment[0u];
-            face = select(1i, 0i, (_e351 > 0f));
+        let _e350 = phi_2249_;
+        if _e350 {
+            let _e352 = toFragment[0u];
+            face = select(1i, 0i, (_e352 > 0f));
         } else {
-            let _e355 = a[1u];
-            let _e357 = a[2u];
-            if (_e355 >= _e357) {
-                let _e360 = toFragment[1u];
-                face = select(3i, 2i, (_e360 > 0f));
+            let _e356 = a[1u];
+            let _e358 = a[2u];
+            if (_e356 >= _e358) {
+                let _e361 = toFragment[1u];
+                face = select(3i, 2i, (_e361 > 0f));
             } else {
-                let _e364 = toFragment[2u];
-                face = select(5i, 4i, (_e364 > 0f));
+                let _e365 = toFragment[2u];
+                face = select(5i, 4i, (_e365 > 0f));
             }
         }
     }
-    let _e367 = slot;
-    let _e369 = face;
-    let _e373 = point_shadow.faces[((_e367 * 6i) + _e369)];
-    let _e374 = origin;
-    clip = (_e373 * vec4<f32>(_e374.x, _e374.y, _e374.z, 1f));
-    let _e381 = clip[3u];
-    if (_e381 <= 0f) {
+    let _e368 = slot;
+    let _e370 = face;
+    let _e374 = point_shadow.faces[((_e368 * 6i) + _e370)];
+    let _e375 = origin;
+    clip = (_e374 * vec4<f32>(_e375.x, _e375.y, _e375.z, 1f));
+    let _e382 = clip[3u];
+    if (_e382 <= 0f) {
         return 1f;
     }
-    let _e383 = clip;
-    let _e386 = clip[3u];
-    ndc = (_e383.xy / vec2(_e386));
-    let _e390 = ndc[0u];
-    let _e392 = (abs(_e390) > 1f);
-    phi_2310_ = _e392;
-    if !(_e392) {
-        let _e395 = ndc[1u];
-        phi_2310_ = (abs(_e395) > 1f);
+    let _e384 = clip;
+    let _e387 = clip[3u];
+    ndc = (_e384.xy / vec2(_e387));
+    let _e391 = ndc[0u];
+    let _e393 = (abs(_e391) > 1f);
+    phi_2310_ = _e393;
+    if !(_e393) {
+        let _e396 = ndc[1u];
+        phi_2310_ = (abs(_e396) > 1f);
     }
-    let _e399 = phi_2310_;
-    if _e399 {
+    let _e400 = phi_2310_;
+    if _e400 {
         return 1f;
     }
-    let _e401 = ndc[0u];
-    let _e405 = ndc[1u];
-    uv_3 = vec2<f32>(((_e401 * 0.5f) + 0.5f), (0.5f - (_e405 * 0.5f)));
-    let _e409 = face;
-    let _e411 = slot;
-    tile_3 = vec2<f32>(f32(_e409), f32(_e411));
-    let _e414 = distance_;
-    let _e417 = point_shadow.params[1u];
-    receiver_2 = (_e414 - _e417);
-    let _e421 = frag_info.target_origin[0u];
-    param_28 = _e421;
-    let _e422 = FragCoordFromTop_u0028_f1_u003b((&param_28));
-    noise = fract((52.982918f * fract(dot(_e422, vec2<f32>(0.06711056f, 0.00583715f)))));
-    let _e427 = noise;
-    angle = (_e427 * 6.2831855f);
-    let _e429 = angle;
-    ca_2 = cos(_e429);
-    let _e431 = angle;
-    sa_2 = sin(_e431);
-    let _e433 = (*lightIndex);
-    let _e437 = point_shadow.slots[_e433][2u];
-    tanHalf_1 = max(_e437, 0.0001f);
+    let _e402 = ndc[0u];
+    let _e406 = ndc[1u];
+    uv_3 = vec2<f32>(((_e402 * 0.5f) + 0.5f), (0.5f - (_e406 * 0.5f)));
+    let _e410 = face;
+    let _e412 = slot;
+    tile_3 = vec2<f32>(f32(_e410), f32(_e412));
+    let _e415 = distance_;
+    let _e418 = point_shadow.params[1u];
+    receiver_2 = (_e415 - _e418);
+    let _e422 = frag_info.target_origin[0u];
+    param_28 = _e422;
+    let _e423 = FragCoordFromTop_u0028_f1_u003b((&param_28));
+    noise = fract((52.982918f * fract(dot(_e423, vec2<f32>(0.06711056f, 0.00583715f)))));
+    let _e428 = noise;
+    angle = (_e428 * 6.2831855f);
+    let _e430 = angle;
+    ca_2 = cos(_e430);
+    let _e432 = angle;
+    sa_2 = sin(_e432);
+    let _e434 = (*lightIndex);
+    let _e438 = point_shadow.slots[_e434][2u];
+    tanHalf_1 = max(_e438, 0.0001f);
     blocker_1 = -1f;
-    let _e439 = uv_3;
-    param_29 = _e439;
-    let _e440 = tile_3;
-    param_30 = _e440;
-    let _e441 = range_3;
-    param_31 = _e441;
-    let _e442 = receiver_2;
-    param_32 = _e442;
-    let _e443 = ca_2;
-    param_33 = _e443;
-    let _e444 = sa_2;
-    param_34 = _e444;
-    let _e445 = tanHalf_1;
-    param_35 = _e445;
-    let _e446 = PointShadowPenumbra_u0028_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b((&param_29), (&param_30), (&param_31), (&param_32), (&param_33), (&param_34), (&param_35), (&param_36));
-    let _e447 = param_36;
-    blocker_1 = _e447;
-    radius_1 = _e446;
-    let _e450 = point_shadow.params2_[3u];
-    if (_e450 > 0.5f) {
+    let _e440 = uv_3;
+    param_29 = _e440;
+    let _e441 = tile_3;
+    param_30 = _e441;
+    let _e442 = range_3;
+    param_31 = _e442;
+    let _e443 = receiver_2;
+    param_32 = _e443;
+    let _e444 = ca_2;
+    param_33 = _e444;
+    let _e445 = sa_2;
+    param_34 = _e445;
+    let _e446 = tanHalf_1;
+    param_35 = _e446;
+    let _e447 = PointShadowPenumbra_u0028_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b((&param_29), (&param_30), (&param_31), (&param_32), (&param_33), (&param_34), (&param_35), (&param_36));
+    let _e448 = param_36;
+    blocker_1 = _e448;
+    radius_1 = _e447;
+    let _e451 = point_shadow.params2_[3u];
+    if (_e451 > 0.5f) {
         g_debug_surface_on = true;
-        let _e452 = radius_1;
-        if (_e452 < 0f) {
+        let _e453 = radius_1;
+        if (_e453 < 0f) {
             local_7 = vec3<f32>(0f, 0f, 1f);
         } else {
-            let _e454 = radius_1;
-            let _e457 = point_shadow.params2_[2u];
-            let _e461 = blocker_1;
-            let _e462 = range_3;
-            local_7 = vec3<f32>(clamp((_e454 / max(_e457, 0.000001f)), 0f, 1f), clamp((_e461 / _e462), 0f, 1f), 0f);
+            let _e455 = radius_1;
+            let _e458 = point_shadow.params2_[2u];
+            let _e462 = blocker_1;
+            let _e463 = range_3;
+            local_7 = vec3<f32>(clamp((_e455 / max(_e458, 0.000001f)), 0f, 1f), clamp((_e462 / _e463), 0f, 1f), 0f);
         }
-        let _e466 = local_7;
-        g_debug_surface = _e466;
+        let _e467 = local_7;
+        g_debug_surface = _e467;
     }
-    let _e467 = radius_1;
-    if (_e467 < 0f) {
+    let _e468 = radius_1;
+    if (_e468 < 0f) {
         return 1f;
     }
-    let _e469 = uv_3;
-    param_37 = _e469;
+    let _e470 = uv_3;
+    param_37 = _e470;
     param_38 = vec2<f32>(0f, 0f);
-    let _e470 = tile_3;
-    param_39 = _e470;
-    let _e471 = range_3;
-    param_40 = _e471;
-    let _e472 = receiver_2;
-    param_41 = _e472;
-    let _e473 = PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((&param_37), (&param_38), (&param_39), (&param_40), (&param_41));
-    lit_1 = _e473;
-    let _e474 = radius_1;
-    if (_e474 > 0f) {
+    let _e471 = tile_3;
+    param_39 = _e471;
+    let _e472 = range_3;
+    param_40 = _e472;
+    let _e473 = receiver_2;
+    param_41 = _e473;
+    let _e474 = PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((&param_37), (&param_38), (&param_39), (&param_40), (&param_41));
+    lit_1 = _e474;
+    let _e475 = radius_1;
+    if (_e475 > 0f) {
         i_3 = 0i;
         loop {
-            let _e476 = i_3;
-            if (_e476 < 8i) {
-                let _e478 = i_3;
-                param_42 = _e478;
-                let _e479 = ca_2;
-                param_43 = _e479;
-                let _e480 = sa_2;
-                param_44 = _e480;
-                let _e481 = radius_1;
-                param_45 = _e481;
-                let _e482 = PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b((&param_42), (&param_43), (&param_44), (&param_45));
-                let _e483 = uv_3;
-                param_46 = _e483;
-                param_47 = _e482;
-                let _e484 = tile_3;
-                param_48 = _e484;
-                let _e485 = range_3;
-                param_49 = _e485;
-                let _e486 = receiver_2;
-                param_50 = _e486;
-                let _e487 = PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((&param_46), (&param_47), (&param_48), (&param_49), (&param_50));
-                let _e488 = lit_1;
-                lit_1 = (_e488 + _e487);
+            let _e477 = i_3;
+            if (_e477 < 8i) {
+                let _e479 = i_3;
+                param_42 = _e479;
+                let _e480 = ca_2;
+                param_43 = _e480;
+                let _e481 = sa_2;
+                param_44 = _e481;
+                let _e482 = radius_1;
+                param_45 = _e482;
+                let _e483 = PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b((&param_42), (&param_43), (&param_44), (&param_45));
+                let _e484 = uv_3;
+                param_46 = _e484;
+                param_47 = _e483;
+                let _e485 = tile_3;
+                param_48 = _e485;
+                let _e486 = range_3;
+                param_49 = _e486;
+                let _e487 = receiver_2;
+                param_50 = _e487;
+                let _e488 = PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((&param_46), (&param_47), (&param_48), (&param_49), (&param_50));
+                let _e489 = lit_1;
+                lit_1 = (_e489 + _e488);
                 continue;
             } else {
                 break;
             }
             continuing {
-                let _e490 = i_3;
-                i_3 = (_e490 + 1i);
+                let _e491 = i_3;
+                i_3 = (_e491 + 1i);
             }
         }
-        let _e492 = lit_1;
-        lit_1 = (_e492 * 0.11111111f);
+        let _e493 = lit_1;
+        lit_1 = (_e493 * 0.11111111f);
     }
-    let _e494 = lit_1;
-    let _e495 = strength;
-    return mix(1f, _e494, clamp(_e495, 0f, 1f));
+    let _e495 = lit_1;
+    let _e496 = strength;
+    return mix(1f, _e495, clamp(_e496, 0f, 1f));
 }
 
 fn VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b(i_4: ptr<function, i32>, n_1: ptr<function, i32>, turn: ptr<function, f32>) -> vec2<f32> {
     var r: f32;
     var theta: f32;
 
-    let _e192 = (*i_4);
-    let _e195 = (*n_1);
-    r = sqrt(((f32(_e192) + 0.5f) / f32(_e195)));
-    let _e199 = (*i_4);
-    let _e202 = (*turn);
-    theta = ((f32(_e199) * 2.3999631f) + _e202);
-    let _e204 = r;
-    let _e205 = theta;
-    let _e207 = theta;
-    return (vec2<f32>(cos(_e205), sin(_e207)) * _e204);
-}
-
-fn ShadowNoise_u0028_() -> f32 {
-    var at: vec2<f32>;
-    var param_51: f32;
-
-    let _e191 = frag_info.target_origin[0u];
-    param_51 = _e191;
-    let _e192 = FragCoordFromTop_u0028_f1_u003b((&param_51));
-    let _e195 = frag_info.target_origin[3u];
-    at = (_e192 + vec2((5.588238f * max(_e195, 0f))));
-    let _e200 = at;
-    return fract((52.982918f * fract(dot(_e200, vec2<f32>(0.06711056f, 0.00583715f)))));
+    let _e193 = (*i_4);
+    let _e196 = (*n_1);
+    r = sqrt(((f32(_e193) + 0.5f) / f32(_e196)));
+    let _e200 = (*i_4);
+    let _e203 = (*turn);
+    theta = ((f32(_e200) * 2.3999631f) + _e203);
+    let _e205 = r;
+    let _e206 = theta;
+    let _e208 = theta;
+    return (vec2<f32>(cos(_e206), sin(_e208)) * _e205);
+}
+
+fn ShadowNoise_u0028_() -> f32 {
+    var at: vec2<f32>;
+    var param_51: f32;
+
+    let _e192 = frag_info.target_origin[0u];
+    param_51 = _e192;
+    let _e193 = FragCoordFromTop_u0028_f1_u003b((&param_51));
+    let _e196 = frag_info.target_origin[3u];
+    at = (_e193 + vec2((5.588238f * max(_e196, 0f))));
+    let _e201 = at;
+    return fract((52.982918f * fract(dot(_e201, vec2<f32>(0.06711056f, 0.00583715f)))));
 }
 
 fn EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b(moments: ptr<function, vec2<f32>>, t: ptr<function, f32>, minVariance: ptr<function, f32>, bleed: ptr<function, f32>) -> f32 {
@@ -11011,37 +11060,37 @@ fn EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b(moments: ptr<functio
     var pMax: f32;
     var reduced: f32;
 
-    let _e196 = (*moments)[1u];
-    let _e198 = (*moments)[0u];
-    let _e200 = (*moments)[0u];
-    let _e203 = (*minVariance);
-    variance = max((_e196 - (_e198 * _e200)), _e203);
-    let _e205 = (*t);
-    let _e207 = (*moments)[0u];
-    d_1 = (_e205 - _e207);
-    let _e209 = variance;
+    let _e197 = (*moments)[1u];
+    let _e199 = (*moments)[0u];
+    let _e201 = (*moments)[0u];
+    let _e204 = (*minVariance);
+    variance = max((_e197 - (_e199 * _e201)), _e204);
+    let _e206 = (*t);
+    let _e208 = (*moments)[0u];
+    d_1 = (_e206 - _e208);
     let _e210 = variance;
-    let _e211 = d_1;
+    let _e211 = variance;
     let _e212 = d_1;
-    pMax = (_e209 / (_e210 + (_e211 * _e212)));
-    let _e216 = pMax;
-    let _e217 = (*bleed);
-    let _e219 = (*bleed);
-    reduced = clamp(((_e216 - _e217) / max((1f - _e219), 0.0001f)), 0f, 1f);
-    let _e224 = (*t);
-    let _e226 = (*moments)[0u];
-    let _e228 = reduced;
-    return select(_e228, 1f, (_e224 <= _e226));
+    let _e213 = d_1;
+    pMax = (_e210 / (_e211 + (_e212 * _e213)));
+    let _e217 = pMax;
+    let _e218 = (*bleed);
+    let _e220 = (*bleed);
+    reduced = clamp(((_e217 - _e218) / max((1f - _e220), 0.0001f)), 0f, 1f);
+    let _e225 = (*t);
+    let _e227 = (*moments)[0u];
+    let _e229 = reduced;
+    return select(_e229, 1f, (_e225 <= _e227));
 }
 
 fn EvsmWarp_u0028_f1_u003b(depth: ptr<function, f32>) -> vec2<f32> {
     var d_2: f32;
 
-    let _e189 = (*depth);
-    d_2 = ((2f * clamp(_e189, 0f, 1f)) - 1f);
-    let _e193 = d_2;
-    let _e196 = d_2;
-    return vec2<f32>(exp((40f * _e193)), -(exp((-5f * _e196))));
+    let _e190 = (*depth);
+    d_2 = ((2f * clamp(_e190, 0f, 1f)) - 1f);
+    let _e194 = d_2;
+    let _e197 = d_2;
+    return vec2<f32>(exp((40f * _e194)), -(exp((-5f * _e197))));
 }
 
 fn EvsmVisibility_u0028_vf4_u003b_f1_u003b_f1_u003b(moments_1: ptr<function, vec4<f32>>, depth_1: ptr<function, f32>, bleed_1: ptr<function, f32>) -> f32 {
@@ -11059,37 +11108,37 @@ fn EvsmVisibility_u0028_vf4_u003b_f1_u003b_f1_u003b(moments_1: ptr<function, vec
     var param_59: f32;
     var param_60: f32;
 
-    let _e203 = (*depth_1);
-    param_52 = _e203;
-    let _e204 = EvsmWarp_u0028_f1_u003b((&param_52));
-    warped = _e204;
-    let _e205 = warped;
-    scale = (vec2<f32>(0.004f, 0.0005f) * _e205);
-    let _e208 = scale[0u];
-    let _e210 = scale[0u];
-    let _e212 = (*moments_1);
-    param_53 = _e212.xy;
-    let _e215 = warped[0u];
-    param_54 = _e215;
-    param_55 = (_e208 * _e210);
-    let _e216 = (*bleed_1);
-    param_56 = _e216;
-    let _e217 = EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b((&param_53), (&param_54), (&param_55), (&param_56));
-    positive = _e217;
-    let _e219 = scale[1u];
-    let _e221 = scale[1u];
-    let _e223 = (*moments_1);
-    param_57 = _e223.zw;
-    let _e226 = warped[1u];
-    param_58 = _e226;
-    param_59 = (_e219 * _e221);
-    let _e227 = (*bleed_1);
-    param_60 = _e227;
-    let _e228 = EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b((&param_57), (&param_58), (&param_59), (&param_60));
-    negative = _e228;
-    let _e229 = positive;
-    let _e230 = negative;
-    return min(_e229, _e230);
+    let _e204 = (*depth_1);
+    param_52 = _e204;
+    let _e205 = EvsmWarp_u0028_f1_u003b((&param_52));
+    warped = _e205;
+    let _e206 = warped;
+    scale = (vec2<f32>(0.004f, 0.0005f) * _e206);
+    let _e209 = scale[0u];
+    let _e211 = scale[0u];
+    let _e213 = (*moments_1);
+    param_53 = _e213.xy;
+    let _e216 = warped[0u];
+    param_54 = _e216;
+    param_55 = (_e209 * _e211);
+    let _e217 = (*bleed_1);
+    param_56 = _e217;
+    let _e218 = EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b((&param_53), (&param_54), (&param_55), (&param_56));
+    positive = _e218;
+    let _e220 = scale[1u];
+    let _e222 = scale[1u];
+    let _e224 = (*moments_1);
+    param_57 = _e224.zw;
+    let _e227 = warped[1u];
+    param_58 = _e227;
+    param_59 = (_e220 * _e222);
+    let _e228 = (*bleed_1);
+    param_60 = _e228;
+    let _e229 = EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b((&param_57), (&param_58), (&param_59), (&param_60));
+    negative = _e229;
+    let _e230 = positive;
+    let _e231 = negative;
+    return min(_e230, _e231);
 }
 
 fn ShadowFactor_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b_i1_u003b(s_2: ptr<function, Surface>, light_1: ptr<function, LightSample>, lightIndex_1: ptr<function, i32>) -> f32 {
@@ -11127,6 +11176,8 @@ fn ShadowFactor_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf
     var tileLo: vec2<f32>;
     var tileHi: vec2<f32>;
     var stored_2: vec4<f32>;
+    var y: i32;
+    var x: i32;
     var through: vec3<f32>;
     var softness: f32;
     var lit_2: f32;
@@ -11134,8 +11185,8 @@ fn ShadowFactor_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf
     var param_61: vec4<f32>;
     var param_62: f32;
     var param_63: f32;
-    var y: i32;
-    var x: i32;
+    var y_1: i32;
+    var x_1: i32;
     var occluder: f32;
     var spread: f32;
     var turn_1: f32;
@@ -11164,45 +11215,45 @@ fn ShadowFactor_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf
     var phi_3710_: bool;
     var phi_3717_: bool;
 
-    let _e257 = frag_info.shadow_params[3u];
-    strength_1 = _e257;
-    let _e258 = strength_1;
-    if (_e258 <= 0f) {
+    let _e260 = frag_info.shadow_params[3u];
+    strength_1 = _e260;
+    let _e261 = strength_1;
+    if (_e261 <= 0f) {
         return 1f;
     }
-    let _e260 = (*lightIndex_1);
-    let _e263 = frag_info.frame_params[2u];
-    if (_e260 != i32((_e263 + 0.5f))) {
+    let _e263 = (*lightIndex_1);
+    let _e266 = frag_info.frame_params[2u];
+    if (_e263 != i32((_e266 + 0.5f))) {
         return 1f;
     }
-    let _e269 = frag_info.shadow_cascades[2u];
-    cascadeCount = i32((_e269 + 0.5f));
-    let _e272 = v_world_position_1;
-    let _e274 = frag_info.camera_position;
-    viewDistance = length((_e272 - _e274.xyz));
+    let _e272 = frag_info.shadow_cascades[2u];
+    cascadeCount = i32((_e272 + 0.5f));
+    let _e275 = v_world_position_1;
+    let _e277 = frag_info.camera_position;
+    viewDistance = length((_e275 - _e277.xyz));
     cascade = 0i;
-    let _e278 = cascadeCount;
-    let _e279 = (_e278 > 1i);
-    phi_3531_ = _e279;
-    if _e279 {
-        let _e280 = viewDistance;
-        let _e283 = frag_info.shadow_cascades[0u];
-        phi_3531_ = (_e280 > _e283);
-    }
-    let _e286 = phi_3531_;
-    if _e286 {
+    let _e281 = cascadeCount;
+    let _e282 = (_e281 > 1i);
+    phi_3531_ = _e282;
+    if _e282 {
+        let _e283 = viewDistance;
+        let _e286 = frag_info.shadow_cascades[0u];
+        phi_3531_ = (_e283 > _e286);
+    }
+    let _e289 = phi_3531_;
+    if _e289 {
         cascade = 1i;
     }
-    let _e287 = cascadeCount;
-    let _e288 = (_e287 > 2i);
-    phi_3542_ = _e288;
-    if _e288 {
-        let _e289 = viewDistance;
-        let _e292 = frag_info.shadow_cascades[1u];
-        phi_3542_ = (_e289 > _e292);
+    let _e290 = cascadeCount;
+    let _e291 = (_e290 > 2i);
+    phi_3542_ = _e291;
+    if _e291 {
+        let _e292 = viewDistance;
+        let _e295 = frag_info.shadow_cascades[1u];
+        phi_3542_ = (_e292 > _e295);
     }
-    let _e295 = phi_3542_;
-    if _e295 {
+    let _e298 = phi_3542_;
+    if _e298 {
         cascade = 2i;
     }
     uv_4 = vec2<f32>(0f, 0f);
@@ -11213,247 +11264,280 @@ fn ShadowFactor_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf
     receiverSlope = 0f;
     attempt = 0i;
     loop {
-        let _e296 = attempt;
-        if (_e296 < 3i) {
-            let _e298 = cascade;
-            let _e299 = attempt;
-            which = (_e298 + _e299);
-            let _e301 = which;
-            let _e302 = cascadeCount;
-            if (_e301 >= _e302) {
+        let _e299 = attempt;
+        if (_e299 < 3i) {
+            let _e301 = cascade;
+            let _e302 = attempt;
+            which = (_e301 + _e302);
+            let _e304 = which;
+            let _e305 = cascadeCount;
+            if (_e304 >= _e305) {
                 break;
             }
-            let _e304 = which;
-            if (_e304 == 0i) {
-                let _e307 = frag_info.shadow_matrix;
-                local_8 = _e307;
+            let _e307 = which;
+            if (_e307 == 0i) {
+                let _e310 = frag_info.shadow_matrix;
+                local_8 = _e310;
             } else {
-                let _e308 = which;
-                if (_e308 == 1i) {
-                    let _e311 = frag_info.shadow_matrix_far;
-                    local_9 = _e311;
+                let _e311 = which;
+                if (_e311 == 1i) {
+                    let _e314 = frag_info.shadow_matrix_far;
+                    local_9 = _e314;
                 } else {
-                    let _e313 = frag_info.shadow_matrix_farthest;
-                    local_9 = _e313;
+                    let _e316 = frag_info.shadow_matrix_farthest;
+                    local_9 = _e316;
                 }
-                let _e314 = local_9;
-                local_8 = _e314;
-            }
-            let _e315 = local_8;
-            matrix = _e315;
-            let _e318 = matrix[0][0u];
-            let _e321 = matrix[1][0u];
-            let _e324 = matrix[2][0u];
-            axisX = vec3<f32>(_e318, _e321, _e324);
-            let _e328 = matrix[0][1u];
-            let _e331 = matrix[1][1u];
-            let _e334 = matrix[2][1u];
-            axisY = vec3<f32>(_e328, _e331, _e334);
-            let _e336 = axisX;
-            rowX = max(length(_e336), 0.000001f);
-            let _e339 = axisY;
-            rowY = max(length(_e339), 0.000001f);
-            let _e344 = frag_info.shadow_cascades[3u];
-            let _e346 = rowX;
-            texelMetres = ((2f * _e344) / _e346);
-            let _e350 = frag_info.shadow_cascades[3u];
-            let _e353 = (*s_2).n;
-            let _e354 = axisX;
-            let _e357 = rowX;
-            let _e358 = rowX;
-            let _e362 = (*s_2).n;
-            let _e363 = axisY;
-            let _e366 = rowY;
-            let _e367 = rowY;
-            reach = ((3f * _e350) * ((abs(dot(_e353, _e354)) / (_e357 * _e358)) + (abs(dot(_e362, _e363)) / (_e366 * _e367))));
-            let _e374 = frag_info.shadow_params[2u];
-            let _e375 = texelMetres;
-            flatOffset = min(_e374, _e375);
-            let _e377 = v_world_position_1;
-            let _e379 = (*s_2).n;
-            let _e380 = flatOffset;
-            let _e381 = reach;
-            origin_1 = (_e377 + (_e379 * (_e380 + _e381)));
-            let _e385 = matrix;
-            let _e386 = origin_1;
-            lightSpace = (_e385 * vec4<f32>(_e386.x, _e386.y, _e386.z, 1f));
-            let _e393 = lightSpace[3u];
-            if (_e393 <= 0f) {
+                let _e317 = local_9;
+                local_8 = _e317;
+            }
+            let _e318 = local_8;
+            matrix = _e318;
+            let _e321 = matrix[0][0u];
+            let _e324 = matrix[1][0u];
+            let _e327 = matrix[2][0u];
+            axisX = vec3<f32>(_e321, _e324, _e327);
+            let _e331 = matrix[0][1u];
+            let _e334 = matrix[1][1u];
+            let _e337 = matrix[2][1u];
+            axisY = vec3<f32>(_e331, _e334, _e337);
+            let _e339 = axisX;
+            rowX = max(length(_e339), 0.000001f);
+            let _e342 = axisY;
+            rowY = max(length(_e342), 0.000001f);
+            let _e347 = frag_info.shadow_cascades[3u];
+            let _e349 = rowX;
+            texelMetres = ((2f * _e347) / _e349);
+            let _e353 = frag_info.shadow_cascades[3u];
+            let _e356 = (*s_2).n;
+            let _e357 = axisX;
+            let _e360 = rowX;
+            let _e361 = rowX;
+            let _e365 = (*s_2).n;
+            let _e366 = axisY;
+            let _e369 = rowY;
+            let _e370 = rowY;
+            reach = ((3f * _e353) * ((abs(dot(_e356, _e357)) / (_e360 * _e361)) + (abs(dot(_e365, _e366)) / (_e369 * _e370))));
+            let _e377 = frag_info.shadow_params[2u];
+            let _e378 = texelMetres;
+            flatOffset = min(_e377, _e378);
+            let _e380 = v_world_position_1;
+            let _e382 = (*s_2).n;
+            let _e383 = flatOffset;
+            let _e384 = reach;
+            origin_1 = (_e380 + (_e382 * (_e383 + _e384)));
+            let _e388 = matrix;
+            let _e389 = origin_1;
+            lightSpace = (_e388 * vec4<f32>(_e389.x, _e389.y, _e389.z, 1f));
+            let _e396 = lightSpace[3u];
+            if (_e396 <= 0f) {
                 continue;
             }
-            let _e395 = lightSpace;
-            let _e398 = lightSpace[3u];
-            candidate = (_e395.xyz / vec3(_e398));
-            let _e402 = candidate[0u];
-            let _e406 = candidate[1u];
-            inTile = vec2<f32>(((_e402 * 0.5f) + 0.5f), (0.5f - (_e406 * 0.5f)));
-            let _e411 = inTile[0u];
-            let _e412 = (_e411 < 0f);
-            phi_3703_ = _e412;
-            if !(_e412) {
-                let _e415 = inTile[0u];
-                phi_3703_ = (_e415 > 1f);
-            }
-            let _e418 = phi_3703_;
-            phi_3710_ = _e418;
-            if !(_e418) {
-                let _e421 = inTile[1u];
-                phi_3710_ = (_e421 < 0f);
-            }
-            let _e424 = phi_3710_;
-            phi_3717_ = _e424;
-            if !(_e424) {
-                let _e427 = inTile[1u];
-                phi_3717_ = (_e427 > 1f);
-            }
-            let _e430 = phi_3717_;
-            if _e430 {
+            let _e398 = lightSpace;
+            let _e401 = lightSpace[3u];
+            candidate = (_e398.xyz / vec3(_e401));
+            let _e405 = candidate[0u];
+            let _e409 = candidate[1u];
+            inTile = vec2<f32>(((_e405 * 0.5f) + 0.5f), (0.5f - (_e409 * 0.5f)));
+            let _e414 = inTile[0u];
+            let _e415 = (_e414 < 0f);
+            phi_3703_ = _e415;
+            if !(_e415) {
+                let _e418 = inTile[0u];
+                phi_3703_ = (_e418 > 1f);
+            }
+            let _e421 = phi_3703_;
+            phi_3710_ = _e421;
+            if !(_e421) {
+                let _e424 = inTile[1u];
+                phi_3710_ = (_e424 < 0f);
+            }
+            let _e427 = phi_3710_;
+            phi_3717_ = _e427;
+            if !(_e427) {
+                let _e430 = inTile[1u];
+                phi_3717_ = (_e430 > 1f);
+            }
+            let _e433 = phi_3717_;
+            if _e433 {
                 continue;
             }
-            let _e432 = candidate[2u];
-            if (_e432 > 1f) {
-                let _e434 = which;
-                let _e435 = cascadeCount;
-                if (_e434 < (_e435 - 1i)) {
+            let _e435 = candidate[2u];
+            if (_e435 > 1f) {
+                let _e437 = which;
+                let _e438 = cascadeCount;
+                if (_e437 < (_e438 - 1i)) {
                     continue;
                 }
                 candidate[2u] = 1f;
             }
-            let _e440 = inTile[0u];
-            let _e441 = which;
-            let _e444 = cascadeCount;
-            let _e448 = inTile[1u];
-            uv_4 = vec2<f32>(((_e440 + f32(_e441)) / f32(_e444)), _e448);
-            let _e450 = candidate;
-            projected = _e450;
-            let _e451 = which;
-            cascade = _e451;
-            let _e452 = texelMetres;
-            cascadeTexel = _e452;
-            let _e455 = matrix[0][2u];
-            let _e458 = matrix[1][2u];
-            let _e461 = matrix[2][2u];
-            cascadeDepth = (1f / max(length(vec3<f32>(_e455, _e458, _e461)), 0.000001f));
-            let _e467 = (*s_2).n;
-            let _e470 = matrix[0][2u];
-            let _e473 = matrix[1][2u];
-            let _e476 = matrix[2][2u];
-            let _e480 = cascadeDepth;
-            cosSlope = clamp((abs(dot(_e467, vec3<f32>(_e470, _e473, _e476))) * _e480), 0.1f, 1f);
-            let _e483 = texelMetres;
-            let _e484 = cosSlope;
-            let _e485 = cosSlope;
-            let _e491 = cosSlope;
-            let _e493 = cascadeDepth;
-            receiverSlope = (((_e483 * sqrt(max((1f - (_e484 * _e485)), 0f))) / _e491) / _e493);
+            let _e443 = inTile[0u];
+            let _e444 = which;
+            let _e447 = cascadeCount;
+            let _e451 = inTile[1u];
+            uv_4 = vec2<f32>(((_e443 + f32(_e444)) / f32(_e447)), _e451);
+            let _e453 = candidate;
+            projected = _e453;
+            let _e454 = which;
+            cascade = _e454;
+            let _e455 = texelMetres;
+            cascadeTexel = _e455;
+            let _e458 = matrix[0][2u];
+            let _e461 = matrix[1][2u];
+            let _e464 = matrix[2][2u];
+            cascadeDepth = (1f / max(length(vec3<f32>(_e458, _e461, _e464)), 0.000001f));
+            let _e470 = (*s_2).n;
+            let _e473 = matrix[0][2u];
+            let _e476 = matrix[1][2u];
+            let _e479 = matrix[2][2u];
+            let _e483 = cascadeDepth;
+            cosSlope = clamp((abs(dot(_e470, vec3<f32>(_e473, _e476, _e479))) * _e483), 0.1f, 1f);
+            let _e486 = texelMetres;
+            let _e487 = cosSlope;
+            let _e488 = cosSlope;
+            let _e494 = cosSlope;
+            let _e496 = cascadeDepth;
+            receiverSlope = (((_e486 * sqrt(max((1f - (_e487 * _e488)), 0f))) / _e494) / _e496);
             found = true;
             break;
         } else {
             break;
         }
         continuing {
-            let _e495 = attempt;
-            attempt = (_e495 + 1i);
+            let _e498 = attempt;
+            attempt = (_e498 + 1i);
         }
     }
-    let _e497 = found;
-    if !(_e497) {
+    let _e500 = found;
+    if !(_e500) {
         return 1f;
     }
-    let _e499 = cascade;
-    if (_e499 == 0i) {
-        let _e503 = frag_info.shadow_bias[0u];
-        local_10 = _e503;
+    let _e502 = cascade;
+    if (_e502 == 0i) {
+        let _e506 = frag_info.shadow_bias[0u];
+        local_10 = _e506;
     } else {
-        let _e504 = cascade;
-        if (_e504 == 1i) {
-            let _e508 = frag_info.shadow_bias[1u];
-            local_11 = _e508;
-        } else {
-            let _e511 = frag_info.shadow_bias[2u];
+        let _e507 = cascade;
+        if (_e507 == 1i) {
+            let _e511 = frag_info.shadow_bias[1u];
             local_11 = _e511;
-        }
-        let _e512 = local_11;
-        local_10 = _e512;
-    }
-    let _e513 = local_10;
-    bias = _e513;
-    let _e516 = frag_info.shadow_params[0u];
-    let _e519 = frag_info.shadow_cascades[3u];
-    texel_1 = vec2<f32>(_e516, _e519);
-    let _e521 = cascade;
-    let _e523 = cascadeCount;
-    let _e527 = texel_1;
-    tileLo = (vec2<f32>((f32(_e521) / f32(_e523)), 0f) + (_e527 * 0.5f));
-    let _e530 = cascade;
-    let _e533 = cascadeCount;
-    let _e537 = texel_1;
-    tileHi = (vec2<f32>((f32((_e530 + 1i)) / f32(_e533)), 1f) - (_e537 * 0.5f));
-    let _e542 = frag_info.shadow_bias[3u];
-    if (_e542 > 0.5f) {
-        let _e544 = uv_4;
-        let _e545 = tileLo;
-        let _e546 = tileHi;
-        let _e548 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp(_e544, _e545, _e546), 0f);
-        stored_2 = _e548;
-        let _e550 = stored_2[1u];
-        let _e553 = stored_2[2u];
-        let _e556 = stored_2[3u];
-        through = clamp(vec3<f32>((1f - _e550), (1f - _e553), _e556), vec3(0f), vec3(4f));
-        let _e561 = through;
-        let _e562 = strength_1;
-        light_transmittance = mix(vec3<f32>(1f, 1f, 1f), _e561, vec3(clamp(_e562, 0f, 1f)));
-    }
-    let _e568 = frag_info.ambient_ground[3u];
-    softness = _e568;
+        } else {
+            let _e514 = frag_info.shadow_bias[2u];
+            local_11 = _e514;
+        }
+        let _e515 = local_11;
+        local_10 = _e515;
+    }
+    let _e516 = local_10;
+    bias = _e516;
+    let _e519 = frag_info.shadow_params[0u];
+    let _e522 = frag_info.shadow_cascades[3u];
+    texel_1 = vec2<f32>(_e519, _e522);
+    let _e524 = cascade;
+    let _e526 = cascadeCount;
+    let _e530 = texel_1;
+    tileLo = (vec2<f32>((f32(_e524) / f32(_e526)), 0f) + (_e530 * 0.5f));
+    let _e533 = cascade;
+    let _e536 = cascadeCount;
+    let _e540 = texel_1;
+    tileHi = (vec2<f32>((f32((_e533 + 1i)) / f32(_e536)), 1f) - (_e540 * 0.5f));
+    let _e545 = frag_info.shadow_bias[3u];
+    if (_e545 > 0.5f) {
+        stored_2 = vec4<f32>(0f, 0f, 0f, 0f);
+        y = -1i;
+        loop {
+            let _e547 = y;
+            if (_e547 <= 1i) {
+                x = -1i;
+                loop {
+                    let _e549 = x;
+                    if (_e549 <= 1i) {
+                        let _e551 = uv_4;
+                        let _e552 = x;
+                        let _e554 = y;
+                        let _e557 = texel_1;
+                        let _e560 = tileLo;
+                        let _e561 = tileHi;
+                        let _e563 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e551 + (vec2<f32>(f32(_e552), f32(_e554)) * _e557)), _e560, _e561), 0f);
+                        let _e564 = stored_2;
+                        stored_2 = (_e564 + _e563);
+                        continue;
+                    } else {
+                        break;
+                    }
+                    continuing {
+                        let _e566 = x;
+                        x = (_e566 + 1i);
+                    }
+                }
+                continue;
+            } else {
+                break;
+            }
+            continuing {
+                let _e568 = y;
+                y = (_e568 + 1i);
+            }
+        }
+        let _e570 = stored_2;
+        stored_2 = (_e570 * 0.11111111f);
+        let _e573 = stored_2[1u];
+        let _e576 = stored_2[2u];
+        let _e579 = stored_2[3u];
+        through = clamp(vec3<f32>((1f - _e573), (1f - _e576), _e579), vec3(0f), vec3(4f));
+        let _e584 = through;
+        let _e585 = strength_1;
+        light_transmittance = mix(vec3<f32>(1f, 1f, 1f), _e584, vec3(clamp(_e585, 0f, 1f)));
+    }
+    let _e591 = frag_info.ambient_ground[3u];
+    softness = _e591;
     lit_2 = 0f;
-    let _e569 = softness;
-    if (_e569 < 0f) {
-        let _e571 = uv_4;
-        let _e572 = tileLo;
-        let _e573 = tileHi;
-        let _e575 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp(_e571, _e572, _e573), 0f);
-        moments_2 = _e575;
-        let _e577 = projected[2u];
-        let _e578 = bias;
-        let _e580 = softness;
-        let _e584 = moments_2;
-        param_61 = _e584;
-        param_62 = (_e577 - _e578);
-        param_63 = clamp((-(_e580) - 1f), 0f, 0.95f);
-        let _e585 = EvsmVisibility_u0028_vf4_u003b_f1_u003b_f1_u003b((&param_61), (&param_62), (&param_63));
-        lit_2 = _e585;
-    } else {
-        let _e586 = softness;
-        if (_e586 <= 0f) {
-            y = -1i;
+    let _e592 = softness;
+    if (_e592 < 0f) {
+        let _e594 = uv_4;
+        let _e595 = tileLo;
+        let _e596 = tileHi;
+        let _e598 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp(_e594, _e595, _e596), 0f);
+        moments_2 = _e598;
+        let _e600 = projected[2u];
+        let _e601 = bias;
+        let _e603 = softness;
+        let _e607 = moments_2;
+        param_61 = _e607;
+        param_62 = (_e600 - _e601);
+        param_63 = clamp((-(_e603) - 1f), 0f, 0.95f);
+        let _e608 = EvsmVisibility_u0028_vf4_u003b_f1_u003b_f1_u003b((&param_61), (&param_62), (&param_63));
+        lit_2 = _e608;
+    } else {
+        let _e609 = softness;
+        if (_e609 <= 0f) {
+            y_1 = -1i;
             loop {
-                let _e588 = y;
-                if (_e588 <= 1i) {
-                    x = -1i;
+                let _e611 = y_1;
+                if (_e611 <= 1i) {
+                    x_1 = -1i;
                     loop {
-                        let _e590 = x;
-                        if (_e590 <= 1i) {
-                            let _e592 = uv_4;
-                            let _e593 = x;
-                            let _e595 = y;
-                            let _e598 = texel_1;
-                            let _e601 = tileLo;
-                            let _e602 = tileHi;
-                            let _e604 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e592 + (vec2<f32>(f32(_e593), f32(_e595)) * _e598)), _e601, _e602), 0f);
-                            occluder = _e604.x;
-                            let _e607 = projected[2u];
-                            let _e608 = bias;
-                            let _e610 = occluder;
-                            let _e613 = lit_2;
-                            lit_2 = (_e613 + select(1f, 0f, ((_e607 - _e608) > _e610)));
+                        let _e613 = x_1;
+                        if (_e613 <= 1i) {
+                            let _e615 = uv_4;
+                            let _e616 = x_1;
+                            let _e618 = y_1;
+                            let _e621 = texel_1;
+                            let _e624 = tileLo;
+                            let _e625 = tileHi;
+                            let _e627 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e615 + (vec2<f32>(f32(_e616), f32(_e618)) * _e621)), _e624, _e625), 0f);
+                            occluder = _e627.x;
+                            let _e630 = projected[2u];
+                            let _e631 = bias;
+                            let _e633 = occluder;
+                            let _e636 = lit_2;
+                            lit_2 = (_e636 + select(1f, 0f, ((_e630 - _e631) > _e633)));
                             continue;
                         } else {
                             break;
                         }
                         continuing {
-                            let _e615 = x;
-                            x = (_e615 + 1i);
+                            let _e638 = x_1;
+                            x_1 = (_e638 + 1i);
                         }
                     }
                     continue;
@@ -11461,125 +11545,125 @@ fn ShadowFactor_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf
                     break;
                 }
                 continuing {
-                    let _e617 = y;
-                    y = (_e617 + 1i);
+                    let _e640 = y_1;
+                    y_1 = (_e640 + 1i);
                 }
             }
-            let _e619 = lit_2;
-            lit_2 = (_e619 * 0.11111111f);
+            let _e642 = lit_2;
+            lit_2 = (_e642 * 0.11111111f);
         } else {
-            let _e621 = softness;
-            spread = tan(min(_e621, 0.5f));
-            let _e624 = ShadowNoise_u0028_();
-            turn_1 = (_e624 * 6.2831855f);
-            let _e626 = spread;
-            let _e628 = projected[2u];
-            let _e630 = cascadeDepth;
-            let _e632 = cascadeTexel;
-            searchRadius = clamp((((_e626 * _e628) * _e630) / _e632), 1f, 16f);
+            let _e644 = softness;
+            spread = tan(min(_e644, 0.5f));
+            let _e647 = ShadowNoise_u0028_();
+            turn_1 = (_e647 * 6.2831855f);
+            let _e649 = spread;
+            let _e651 = projected[2u];
+            let _e653 = cascadeDepth;
+            let _e655 = cascadeTexel;
+            searchRadius = clamp((((_e649 * _e651) * _e653) / _e655), 1f, 16f);
             blockerSum = 0f;
             blockerCount = 0f;
             i_5 = 0i;
             loop {
-                let _e635 = i_5;
-                if (_e635 < 16i) {
-                    let _e637 = i_5;
-                    param_64 = _e637;
+                let _e658 = i_5;
+                if (_e658 < 16i) {
+                    let _e660 = i_5;
+                    param_64 = _e660;
                     param_65 = 16i;
-                    let _e638 = turn_1;
-                    param_66 = _e638;
-                    let _e639 = VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b((&param_64), (&param_65), (&param_66));
-                    disc = _e639;
-                    let _e640 = bias;
-                    let _e641 = disc;
-                    let _e643 = searchRadius;
-                    let _e647 = receiverSlope;
-                    tapBias = (_e640 + (max(((length(_e641) * _e643) - 1.5f), 0f) * _e647));
-                    let _e650 = uv_4;
-                    let _e651 = disc;
-                    let _e652 = texel_1;
-                    let _e654 = searchRadius;
-                    let _e657 = tileLo;
-                    let _e658 = tileHi;
-                    let _e660 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e650 + ((_e651 * _e652) * _e654)), _e657, _e658), 0f);
-                    occluder_1 = _e660.x;
-                    let _e663 = projected[2u];
-                    let _e664 = tapBias;
-                    let _e666 = occluder_1;
-                    if ((_e663 - _e664) > _e666) {
-                        let _e668 = occluder_1;
-                        let _e669 = blockerSum;
-                        blockerSum = (_e669 + _e668);
-                        let _e671 = blockerCount;
-                        blockerCount = (_e671 + 1f);
+                    let _e661 = turn_1;
+                    param_66 = _e661;
+                    let _e662 = VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b((&param_64), (&param_65), (&param_66));
+                    disc = _e662;
+                    let _e663 = bias;
+                    let _e664 = disc;
+                    let _e666 = searchRadius;
+                    let _e670 = receiverSlope;
+                    tapBias = (_e663 + (max(((length(_e664) * _e666) - 1.5f), 0f) * _e670));
+                    let _e673 = uv_4;
+                    let _e674 = disc;
+                    let _e675 = texel_1;
+                    let _e677 = searchRadius;
+                    let _e680 = tileLo;
+                    let _e681 = tileHi;
+                    let _e683 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e673 + ((_e674 * _e675) * _e677)), _e680, _e681), 0f);
+                    occluder_1 = _e683.x;
+                    let _e686 = projected[2u];
+                    let _e687 = tapBias;
+                    let _e689 = occluder_1;
+                    if ((_e686 - _e687) > _e689) {
+                        let _e691 = occluder_1;
+                        let _e692 = blockerSum;
+                        blockerSum = (_e692 + _e691);
+                        let _e694 = blockerCount;
+                        blockerCount = (_e694 + 1f);
                     }
                     continue;
                 } else {
                     break;
                 }
                 continuing {
-                    let _e673 = i_5;
-                    i_5 = (_e673 + 1i);
+                    let _e696 = i_5;
+                    i_5 = (_e696 + 1i);
                 }
             }
-            let _e675 = blockerCount;
-            if (_e675 <= 0f) {
+            let _e698 = blockerCount;
+            if (_e698 <= 0f) {
                 return 1f;
             }
-            let _e678 = projected[2u];
-            let _e679 = blockerSum;
-            let _e680 = blockerCount;
-            let _e684 = cascadeDepth;
-            gap = (max((_e678 - (_e679 / _e680)), 0f) * _e684);
-            let _e686 = spread;
-            let _e687 = gap;
-            let _e689 = cascadeTexel;
-            radius_2 = clamp(((_e686 * _e687) / _e689), 1f, 16f);
+            let _e701 = projected[2u];
+            let _e702 = blockerSum;
+            let _e703 = blockerCount;
+            let _e707 = cascadeDepth;
+            gap = (max((_e701 - (_e702 / _e703)), 0f) * _e707);
+            let _e709 = spread;
+            let _e710 = gap;
+            let _e712 = cascadeTexel;
+            radius_2 = clamp(((_e709 * _e710) / _e712), 1f, 16f);
             i_6 = 0i;
             loop {
-                let _e692 = i_6;
-                if (_e692 < 16i) {
-                    let _e694 = turn_1;
-                    let _e696 = i_6;
-                    param_67 = _e696;
+                let _e715 = i_6;
+                if (_e715 < 16i) {
+                    let _e717 = turn_1;
+                    let _e719 = i_6;
+                    param_67 = _e719;
                     param_68 = 16i;
-                    param_69 = (_e694 + 1f);
-                    let _e697 = VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b((&param_67), (&param_68), (&param_69));
-                    disc_1 = _e697;
-                    let _e698 = bias;
-                    let _e699 = disc_1;
-                    let _e701 = radius_2;
-                    let _e705 = receiverSlope;
-                    tapBias_1 = (_e698 + (max(((length(_e699) * _e701) - 1.5f), 0f) * _e705));
-                    let _e708 = uv_4;
-                    let _e709 = disc_1;
-                    let _e710 = texel_1;
-                    let _e712 = radius_2;
-                    let _e715 = tileLo;
-                    let _e716 = tileHi;
-                    let _e718 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e708 + ((_e709 * _e710) * _e712)), _e715, _e716), 0f);
-                    occluder_2 = _e718.x;
-                    let _e721 = projected[2u];
-                    let _e722 = tapBias_1;
-                    let _e724 = occluder_2;
-                    let _e727 = lit_2;
-                    lit_2 = (_e727 + select(1f, 0f, ((_e721 - _e722) > _e724)));
+                    param_69 = (_e717 + 1f);
+                    let _e720 = VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b((&param_67), (&param_68), (&param_69));
+                    disc_1 = _e720;
+                    let _e721 = bias;
+                    let _e722 = disc_1;
+                    let _e724 = radius_2;
+                    let _e728 = receiverSlope;
+                    tapBias_1 = (_e721 + (max(((length(_e722) * _e724) - 1.5f), 0f) * _e728));
+                    let _e731 = uv_4;
+                    let _e732 = disc_1;
+                    let _e733 = texel_1;
+                    let _e735 = radius_2;
+                    let _e738 = tileLo;
+                    let _e739 = tileHi;
+                    let _e741 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e731 + ((_e732 * _e733) * _e735)), _e738, _e739), 0f);
+                    occluder_2 = _e741.x;
+                    let _e744 = projected[2u];
+                    let _e745 = tapBias_1;
+                    let _e747 = occluder_2;
+                    let _e750 = lit_2;
+                    lit_2 = (_e750 + select(1f, 0f, ((_e744 - _e745) > _e747)));
                     continue;
                 } else {
                     break;
                 }
                 continuing {
-                    let _e729 = i_6;
-                    i_6 = (_e729 + 1i);
+                    let _e752 = i_6;
+                    i_6 = (_e752 + 1i);
                 }
             }
-            let _e731 = lit_2;
-            lit_2 = (_e731 * 0.0625f);
+            let _e754 = lit_2;
+            lit_2 = (_e754 * 0.0625f);
         }
     }
-    let _e733 = lit_2;
-    let _e734 = strength_1;
-    return mix(1f, _e733, clamp(_e734, 0f, 1f));
+    let _e756 = lit_2;
+    let _e757 = strength_1;
+    return mix(1f, _e756, clamp(_e757, 0f, 1f));
 }
 
 fn LightVisibility_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b_i1_u003b(s_3: ptr<function, Surface>, light_2: ptr<function, LightSample>, index: ptr<function, i32>) -> f32 {
@@ -11587,19 +11671,19 @@ fn LightVisibility_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d
     var param_71: LightSample;
     var param_72: i32;
 
-    let _e193 = (*s_3);
-    param_70 = _e193;
-    let _e194 = (*light_2);
-    param_71 = _e194;
-    let _e195 = (*index);
-    param_72 = _e195;
-    let _e196 = ShadowFactor_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b_i1_u003b((&param_70), (&param_71), (&param_72));
-    return _e196;
+    let _e194 = (*s_3);
+    param_70 = _e194;
+    let _e195 = (*light_2);
+    param_71 = _e195;
+    let _e196 = (*index);
+    param_72 = _e196;
+    let _e197 = ShadowFactor_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b_i1_u003b((&param_70), (&param_71), (&param_72));
+    return _e197;
 }
 
 fn LightHasShadow_u0028_i1_u003b(index_1: ptr<function, i32>) -> bool {
-    let _e188 = (*index_1);
-    return (_e188 < 8i);
+    let _e189 = (*index_1);
+    return (_e189 < 8i);
 }
 
 fn PunctualAttenuation_u0028_f1_u003b_f1_u003b(distance_1: ptr<function, f32>, range_4: ptr<function, f32>) -> f32 {
@@ -11607,26 +11691,26 @@ fn PunctualAttenuation_u0028_f1_u003b_f1_u003b(distance_1: ptr<function, f32>, r
     var ratio: f32;
     var window: f32;
 
-    let _e192 = (*distance_1);
     let _e193 = (*distance_1);
-    attenuation = (1f / max((_e192 * _e193), 0.0001f));
-    let _e197 = (*range_4);
-    if (_e197 > 0f) {
-        let _e199 = (*distance_1);
-        let _e200 = (*range_4);
-        ratio = (_e199 / _e200);
-        let _e202 = ratio;
+    let _e194 = (*distance_1);
+    attenuation = (1f / max((_e193 * _e194), 0.0001f));
+    let _e198 = (*range_4);
+    if (_e198 > 0f) {
+        let _e200 = (*distance_1);
+        let _e201 = (*range_4);
+        ratio = (_e200 / _e201);
         let _e203 = ratio;
-        let _e205 = ratio;
-        let _e207 = ratio;
-        window = clamp((1f - (((_e202 * _e203) * _e205) * _e207)), 0f, 1f);
-        let _e211 = window;
+        let _e204 = ratio;
+        let _e206 = ratio;
+        let _e208 = ratio;
+        window = clamp((1f - (((_e203 * _e204) * _e206) * _e208)), 0f, 1f);
         let _e212 = window;
-        let _e214 = attenuation;
-        attenuation = (_e214 * (_e211 * _e212));
+        let _e213 = window;
+        let _e215 = attenuation;
+        attenuation = (_e215 * (_e212 * _e213));
     }
-    let _e216 = attenuation;
-    return _e216;
+    let _e217 = attenuation;
+    return _e217;
 }
 
 fn RectangleClosestPoint_u0028_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b(centre: ptr<function, vec3<f32>>, halfWidth: ptr<function, vec3<f32>>, halfHeight: ptr<function, vec3<f32>>, world_2: ptr<function, vec3<f32>>, mirror: ptr<function, vec3<f32>>) -> vec3<f32> {
@@ -11643,75 +11727,75 @@ fn RectangleClosestPoint_u0028_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b
     var u: f32;
     var v: f32;
 
-    let _e204 = (*halfWidth);
-    let _e205 = (*halfHeight);
-    n_2 = cross(_e204, _e205);
-    let _e207 = n_2;
-    nLen = length(_e207);
-    let _e209 = nLen;
-    if (_e209 < 0.000000000001f) {
-        let _e211 = (*centre);
-        return _e211;
+    let _e205 = (*halfWidth);
+    let _e206 = (*halfHeight);
+    n_2 = cross(_e205, _e206);
+    let _e208 = n_2;
+    nLen = length(_e208);
+    let _e210 = nLen;
+    if (_e210 < 0.000000000001f) {
+        let _e212 = (*centre);
+        return _e212;
     }
-    let _e212 = nLen;
-    let _e213 = n_2;
-    n_2 = (_e213 / vec3(_e212));
-    let _e216 = (*centre);
-    let _e217 = (*world_2);
-    toPlane = (_e216 - _e217);
-    let _e219 = (*mirror);
-    let _e220 = n_2;
-    denom = dot(_e219, _e220);
-    let _e222 = denom;
-    if (abs(_e222) < 0.00001f) {
-        let _e225 = toPlane;
-        let _e226 = n_2;
-        let _e227 = toPlane;
-        let _e228 = n_2;
-        onPlane = (_e225 - (_e226 * dot(_e227, _e228)));
+    let _e213 = nLen;
+    let _e214 = n_2;
+    n_2 = (_e214 / vec3(_e213));
+    let _e217 = (*centre);
+    let _e218 = (*world_2);
+    toPlane = (_e217 - _e218);
+    let _e220 = (*mirror);
+    let _e221 = n_2;
+    denom = dot(_e220, _e221);
+    let _e223 = denom;
+    if (abs(_e223) < 0.00001f) {
+        let _e226 = toPlane;
+        let _e227 = n_2;
+        let _e228 = toPlane;
+        let _e229 = n_2;
+        onPlane = (_e226 - (_e227 * dot(_e228, _e229)));
     } else {
-        let _e232 = toPlane;
-        let _e233 = n_2;
-        let _e235 = denom;
-        t_1 = (dot(_e232, _e233) / _e235);
-        let _e237 = t_1;
-        if (_e237 > 0f) {
-            let _e239 = (*mirror);
-            let _e240 = t_1;
-            local_12 = (_e239 * _e240);
+        let _e233 = toPlane;
+        let _e234 = n_2;
+        let _e236 = denom;
+        t_1 = (dot(_e233, _e234) / _e236);
+        let _e238 = t_1;
+        if (_e238 > 0f) {
+            let _e240 = (*mirror);
+            let _e241 = t_1;
+            local_12 = (_e240 * _e241);
         } else {
-            let _e242 = toPlane;
-            let _e243 = n_2;
-            let _e244 = toPlane;
-            let _e245 = n_2;
-            local_12 = (_e242 - (_e243 * dot(_e244, _e245)));
+            let _e243 = toPlane;
+            let _e244 = n_2;
+            let _e245 = toPlane;
+            let _e246 = n_2;
+            local_12 = (_e243 - (_e244 * dot(_e245, _e246)));
         }
-        let _e249 = local_12;
-        onPlane = _e249;
+        let _e250 = local_12;
+        onPlane = _e250;
     }
-    let _e250 = onPlane;
-    let _e251 = toPlane;
-    offset_2 = (_e250 - _e251);
-    let _e253 = (*halfWidth);
+    let _e251 = onPlane;
+    let _e252 = toPlane;
+    offset_2 = (_e251 - _e252);
     let _e254 = (*halfWidth);
-    wLen2_ = max(dot(_e253, _e254), 0.000000000001f);
-    let _e257 = (*halfHeight);
+    let _e255 = (*halfWidth);
+    wLen2_ = max(dot(_e254, _e255), 0.000000000001f);
     let _e258 = (*halfHeight);
-    hLen2_ = max(dot(_e257, _e258), 0.000000000001f);
-    let _e261 = offset_2;
-    let _e262 = (*halfWidth);
-    let _e264 = wLen2_;
-    u = clamp((dot(_e261, _e262) / _e264), -1f, 1f);
-    let _e267 = offset_2;
-    let _e268 = (*halfHeight);
-    let _e270 = hLen2_;
-    v = clamp((dot(_e267, _e268) / _e270), -1f, 1f);
-    let _e273 = (*centre);
-    let _e274 = (*halfWidth);
-    let _e275 = u;
-    let _e278 = (*halfHeight);
-    let _e279 = v;
-    return ((_e273 + (_e274 * _e275)) + (_e278 * _e279));
+    let _e259 = (*halfHeight);
+    hLen2_ = max(dot(_e258, _e259), 0.000000000001f);
+    let _e262 = offset_2;
+    let _e263 = (*halfWidth);
+    let _e265 = wLen2_;
+    u = clamp((dot(_e262, _e263) / _e265), -1f, 1f);
+    let _e268 = offset_2;
+    let _e269 = (*halfHeight);
+    let _e271 = hLen2_;
+    v = clamp((dot(_e268, _e269) / _e271), -1f, 1f);
+    let _e274 = (*centre);
+    let _e275 = (*halfWidth);
+    let _e276 = u;
+    let _e279 = (*halfHeight);
+    let _e280 = v;
+    return ((_e274 + (_e275 * _e276)) + (_e279 * _e280));
 }
 
 fn LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b(a_1: ptr<function, vec3<f32>>, b: ptr<function, vec3<f32>>, n_3: ptr<function, vec3<f32>>) -> f32 {
@@ -11722,32 +11806,32 @@ fn LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b(a_1: ptr<function, vec3<f32>>
     var len: f32;
     var local_13: f32;
 
-    let _e196 = (*a_1);
     let _e197 = (*a_1);
-    ua = (_e196 / vec3(max(length(_e197), 0.000000000001f)));
-    let _e202 = (*b);
+    let _e198 = (*a_1);
+    ua = (_e197 / vec3(max(length(_e198), 0.000000000001f)));
     let _e203 = (*b);
-    ub = (_e202 / vec3(max(length(_e203), 0.000000000001f)));
-    let _e208 = ua;
-    let _e209 = ub;
-    angle_1 = acos(clamp(dot(_e208, _e209), -1f, 1f));
-    let _e213 = ua;
-    let _e214 = ub;
-    axis = cross(_e213, _e214);
-    let _e216 = axis;
-    len = length(_e216);
-    let _e218 = len;
-    if (_e218 > 0.000001f) {
-        let _e220 = angle_1;
-        let _e221 = axis;
-        let _e222 = (*n_3);
-        let _e225 = len;
-        local_13 = ((_e220 * dot(_e221, _e222)) / _e225);
+    let _e204 = (*b);
+    ub = (_e203 / vec3(max(length(_e204), 0.000000000001f)));
+    let _e209 = ua;
+    let _e210 = ub;
+    angle_1 = acos(clamp(dot(_e209, _e210), -1f, 1f));
+    let _e214 = ua;
+    let _e215 = ub;
+    axis = cross(_e214, _e215);
+    let _e217 = axis;
+    len = length(_e217);
+    let _e219 = len;
+    if (_e219 > 0.000001f) {
+        let _e221 = angle_1;
+        let _e222 = axis;
+        let _e223 = (*n_3);
+        let _e226 = len;
+        local_13 = ((_e221 * dot(_e222, _e223)) / _e226);
     } else {
         local_13 = 0f;
     }
-    let _e227 = local_13;
-    return _e227;
+    let _e228 = local_13;
+    return _e228;
 }
 
 fn RectangleFormFactor_u0028_vf3_u005b_4_u005d_u003b_vf3_u003b(corners: ptr<function, array<vec3<f32>, 4>>, n_4: ptr<function, vec3<f32>>) -> f32 {
@@ -11778,98 +11862,98 @@ fn RectangleFormFactor_u0028_vf3_u005b_4_u005d_u003b_vf3_u003b(corners: ptr<func
     entry = vec3<f32>(0f, 0f, 0f);
     i_7 = 0i;
     loop {
-        let _e210 = i_7;
-        if (_e210 < 4i) {
-            let _e212 = i_7;
-            let _e214 = (*corners)[_e212];
-            a_2 = _e214;
-            let _e215 = i_7;
-            if (_e215 == 3i) {
+        let _e211 = i_7;
+        if (_e211 < 4i) {
+            let _e213 = i_7;
+            let _e215 = (*corners)[_e213];
+            a_2 = _e215;
+            let _e216 = i_7;
+            if (_e216 == 3i) {
                 local_14 = 0i;
             } else {
-                let _e217 = i_7;
-                local_14 = (_e217 + 1i);
+                let _e218 = i_7;
+                local_14 = (_e218 + 1i);
             }
-            let _e219 = local_14;
-            let _e221 = (*corners)[_e219];
-            b_1 = _e221;
-            let _e222 = a_2;
-            let _e223 = (*n_4);
-            ha = dot(_e222, _e223);
-            let _e225 = b_1;
-            let _e226 = (*n_4);
-            hb = dot(_e225, _e226);
-            let _e228 = ha;
-            let _e229 = hb;
-            d_3 = (_e228 - _e229);
-            let _e231 = a_2;
-            let _e232 = b_1;
-            let _e233 = a_2;
-            let _e235 = d_3;
-            if (abs(_e235) > 0.000000000001f) {
-                let _e238 = ha;
-                let _e239 = d_3;
-                local_15 = (_e238 / _e239);
+            let _e220 = local_14;
+            let _e222 = (*corners)[_e220];
+            b_1 = _e222;
+            let _e223 = a_2;
+            let _e224 = (*n_4);
+            ha = dot(_e223, _e224);
+            let _e226 = b_1;
+            let _e227 = (*n_4);
+            hb = dot(_e226, _e227);
+            let _e229 = ha;
+            let _e230 = hb;
+            d_3 = (_e229 - _e230);
+            let _e232 = a_2;
+            let _e233 = b_1;
+            let _e234 = a_2;
+            let _e236 = d_3;
+            if (abs(_e236) > 0.000000000001f) {
+                let _e239 = ha;
+                let _e240 = d_3;
+                local_15 = (_e239 / _e240);
             } else {
                 local_15 = 0f;
             }
-            let _e241 = local_15;
-            q = (_e231 + ((_e232 - _e233) * _e241));
-            let _e244 = ha;
-            aAbove = (_e244 > 0f);
-            let _e246 = hb;
-            bAbove = (_e246 > 0f);
-            let _e248 = aAbove;
-            let _e249 = bAbove;
-            if (_e248 || _e249) {
-                let _e251 = aAbove;
-                let _e252 = a_2;
-                let _e253 = q;
-                let _e256 = bAbove;
-                let _e257 = b_1;
-                let _e258 = q;
-                param_73 = select(_e253, _e252, vec3(_e251));
-                param_74 = select(_e258, _e257, vec3(_e256));
-                let _e261 = (*n_4);
-                param_75 = _e261;
-                let _e262 = LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b((&param_73), (&param_74), (&param_75));
-                local_16 = _e262;
+            let _e242 = local_15;
+            q = (_e232 + ((_e233 - _e234) * _e242));
+            let _e245 = ha;
+            aAbove = (_e245 > 0f);
+            let _e247 = hb;
+            bAbove = (_e247 > 0f);
+            let _e249 = aAbove;
+            let _e250 = bAbove;
+            if (_e249 || _e250) {
+                let _e252 = aAbove;
+                let _e253 = a_2;
+                let _e254 = q;
+                let _e257 = bAbove;
+                let _e258 = b_1;
+                let _e259 = q;
+                param_73 = select(_e254, _e253, vec3(_e252));
+                param_74 = select(_e259, _e258, vec3(_e257));
+                let _e262 = (*n_4);
+                param_75 = _e262;
+                let _e263 = LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b((&param_73), (&param_74), (&param_75));
+                local_16 = _e263;
             } else {
                 local_16 = 0f;
             }
-            let _e263 = local_16;
-            let _e264 = total;
-            total = (_e264 + _e263);
-            let _e266 = aAbove;
-            let _e267 = bAbove;
-            let _e270 = q;
-            let _e271 = exit;
-            exit = select(_e271, _e270, vec3((_e266 && !(_e267))));
-            let _e274 = aAbove;
-            let _e276 = bAbove;
-            let _e278 = q;
-            let _e279 = entry;
-            entry = select(_e279, _e278, vec3((!(_e274) && _e276)));
+            let _e264 = local_16;
+            let _e265 = total;
+            total = (_e265 + _e264);
+            let _e267 = aAbove;
+            let _e268 = bAbove;
+            let _e271 = q;
+            let _e272 = exit;
+            exit = select(_e272, _e271, vec3((_e267 && !(_e268))));
+            let _e275 = aAbove;
+            let _e277 = bAbove;
+            let _e279 = q;
+            let _e280 = entry;
+            entry = select(_e280, _e279, vec3((!(_e275) && _e277)));
             continue;
         } else {
             break;
         }
         continuing {
-            let _e282 = i_7;
-            i_7 = (_e282 + 1i);
+            let _e283 = i_7;
+            i_7 = (_e283 + 1i);
         }
     }
-    let _e284 = exit;
-    param_76 = _e284;
-    let _e285 = entry;
-    param_77 = _e285;
-    let _e286 = (*n_4);
-    param_78 = _e286;
-    let _e287 = LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b((&param_76), (&param_77), (&param_78));
-    let _e288 = total;
-    total = (_e288 + _e287);
-    let _e290 = total;
-    return max((-(_e290) * 0.5f), 0f);
+    let _e285 = exit;
+    param_76 = _e285;
+    let _e286 = entry;
+    param_77 = _e286;
+    let _e287 = (*n_4);
+    param_78 = _e287;
+    let _e288 = LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b((&param_76), (&param_77), (&param_78));
+    let _e289 = total;
+    total = (_e289 + _e288);
+    let _e291 = total;
+    return max((-(_e291) * 0.5f), 0f);
 }
 
 fn LightListLane_u0028_vf4_u003b_i1_u003b(four: ptr<function, vec4<f32>>, slot_1: ptr<function, i32>) -> f32 {
@@ -11878,91 +11962,91 @@ fn LightListLane_u0028_vf4_u003b_i1_u003b(four: ptr<function, vec4<f32>>, slot_1
     var local_18: f32;
     var local_19: f32;
 
-    let _e193 = (*slot_1);
     let _e194 = (*slot_1);
-    lane = (_e193 - ((_e194 / 4i) * 4i));
-    let _e198 = lane;
-    if (_e198 == 0i) {
-        let _e201 = (*four)[0u];
-        local_17 = _e201;
+    let _e195 = (*slot_1);
+    lane = (_e194 - ((_e195 / 4i) * 4i));
+    let _e199 = lane;
+    if (_e199 == 0i) {
+        let _e202 = (*four)[0u];
+        local_17 = _e202;
     } else {
-        let _e202 = lane;
-        if (_e202 == 1i) {
-            let _e205 = (*four)[1u];
-            local_18 = _e205;
+        let _e203 = lane;
+        if (_e203 == 1i) {
+            let _e206 = (*four)[1u];
+            local_18 = _e206;
         } else {
-            let _e206 = lane;
-            if (_e206 == 2i) {
-                let _e209 = (*four)[2u];
-                local_19 = _e209;
+            let _e207 = lane;
+            if (_e207 == 2i) {
+                let _e210 = (*four)[2u];
+                local_19 = _e210;
             } else {
-                let _e211 = (*four)[3u];
-                local_19 = _e211;
+                let _e212 = (*four)[3u];
+                local_19 = _e212;
             }
-            let _e212 = local_19;
-            local_18 = _e212;
+            let _e213 = local_19;
+            local_18 = _e213;
         }
-        let _e213 = local_18;
-        local_17 = _e213;
+        let _e214 = local_18;
+        local_17 = _e214;
     }
-    let _e214 = local_17;
-    return _e214;
+    let _e215 = local_17;
+    return _e215;
 }
 
 fn LightListScale_u0028_i1_u003b(slot_2: ptr<function, i32>) -> f32 {
     var param_79: vec4<f32>;
     var param_80: i32;
 
-    let _e190 = (*slot_2);
-    let _e194 = light_list_info.scales[(_e190 / 4i)];
-    param_79 = _e194;
-    let _e195 = (*slot_2);
-    param_80 = _e195;
-    let _e196 = LightListLane_u0028_vf4_u003b_i1_u003b((&param_79), (&param_80));
-    return _e196;
+    let _e191 = (*slot_2);
+    let _e195 = light_list_info.scales[(_e191 / 4i)];
+    param_79 = _e195;
+    let _e196 = (*slot_2);
+    param_80 = _e196;
+    let _e197 = LightListLane_u0028_vf4_u003b_i1_u003b((&param_79), (&param_80));
+    return _e197;
 }
 
 fn InSlots_u0028_f1_u003b(row: ptr<function, f32>) -> bool {
     var a_3: vec4<f32>;
     var b_2: vec4<f32>;
 
-    let _e192 = light_list_info.slot_rows[0i];
-    let _e193 = (*row);
-    a_3 = abs((_e192 - vec4(_e193)));
-    let _e199 = light_list_info.slot_rows[1i];
-    let _e200 = (*row);
-    b_2 = abs((_e199 - vec4(_e200)));
-    let _e205 = a_3[0u];
-    let _e207 = a_3[1u];
-    let _e210 = a_3[2u];
-    let _e212 = a_3[3u];
-    let _e216 = b_2[0u];
-    let _e218 = b_2[1u];
-    let _e221 = b_2[2u];
-    let _e223 = b_2[3u];
-    return (min(min(min(_e205, _e207), min(_e210, _e212)), min(min(_e216, _e218), min(_e221, _e223))) < 0.5f);
+    let _e193 = light_list_info.slot_rows[0i];
+    let _e194 = (*row);
+    a_3 = abs((_e193 - vec4(_e194)));
+    let _e200 = light_list_info.slot_rows[1i];
+    let _e201 = (*row);
+    b_2 = abs((_e200 - vec4(_e201)));
+    let _e206 = a_3[0u];
+    let _e208 = a_3[1u];
+    let _e211 = a_3[2u];
+    let _e213 = a_3[3u];
+    let _e217 = b_2[0u];
+    let _e219 = b_2[1u];
+    let _e222 = b_2[2u];
+    let _e224 = b_2[3u];
+    return (min(min(min(_e206, _e208), min(_e211, _e213)), min(min(_e217, _e219), min(_e222, _e224))) < 0.5f);
 }
 
 fn LightListRow_u0028_i1_u003b(slot_3: ptr<function, i32>) -> f32 {
     var param_81: vec4<f32>;
     var param_82: i32;
 
-    let _e190 = (*slot_3);
-    let _e194 = light_list_info.indices[(_e190 / 4i)];
-    param_81 = _e194;
-    let _e195 = (*slot_3);
-    param_82 = _e195;
-    let _e196 = LightListLane_u0028_vf4_u003b_i1_u003b((&param_81), (&param_82));
-    return _e196;
+    let _e191 = (*slot_3);
+    let _e195 = light_list_info.indices[(_e191 / 4i)];
+    param_81 = _e195;
+    let _e196 = (*slot_3);
+    param_82 = _e196;
+    let _e197 = LightListLane_u0028_vf4_u003b_i1_u003b((&param_81), (&param_82));
+    return _e197;
 }
 
 fn LightListTexel_u0028_f1_u003b_f1_u003b(texel_2: ptr<function, f32>, row_1: ptr<function, f32>) -> vec4<f32> {
-    let _e189 = (*texel_2);
-    let _e193 = light_list_info.list[1u];
-    let _e195 = (*row_1);
-    let _e199 = light_list_info.list[2u];
-    let _e202 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>(((_e189 + 0.5f) * _e193), ((_e195 + 0.5f) * _e199)), 0f);
-    return _e202;
+    let _e190 = (*texel_2);
+    let _e194 = light_list_info.list[1u];
+    let _e196 = (*row_1);
+    let _e200 = light_list_info.list[2u];
+    let _e203 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>(((_e190 + 0.5f) * _e194), ((_e196 + 0.5f) * _e200)), 0f);
+    return _e203;
 }
 
 fn ClusterRow_u0028_i1_u003b(slot_4: ptr<function, i32>) -> f32 {
@@ -11976,35 +12060,35 @@ fn ClusterRow_u0028_i1_u003b(slot_4: ptr<function, i32>) -> f32 {
     var param_85: vec4<f32>;
     var param_86: i32;
 
-    let _e197 = g_cluster_offset;
-    let _e198 = (*slot_4);
-    entry_1 = (_e197 + f32(_e198));
-    let _e201 = entry_1;
-    row_2 = floor((_e201 / 16f));
-    let _e204 = entry_1;
-    let _e205 = row_2;
-    within = (_e204 - (_e205 * 16f));
-    let _e208 = within;
-    texel_3 = floor((_e208 / 4f));
-    let _e213 = light_list_info.cluster_depth[3u];
-    let _e214 = row_2;
-    let _e216 = texel_3;
-    param_83 = _e216;
-    param_84 = (_e213 + _e214);
-    let _e217 = LightListTexel_u0028_f1_u003b_f1_u003b((&param_83), (&param_84));
-    four_1 = _e217;
-    let _e218 = within;
-    let _e219 = texel_3;
-    let _e224 = four_1;
-    param_85 = _e224;
-    param_86 = i32(((_e218 - (_e219 * 4f)) + 0.5f));
-    let _e225 = LightListLane_u0028_vf4_u003b_i1_u003b((&param_85), (&param_86));
-    return _e225;
+    let _e198 = g_cluster_offset;
+    let _e199 = (*slot_4);
+    entry_1 = (_e198 + f32(_e199));
+    let _e202 = entry_1;
+    row_2 = floor((_e202 / 16f));
+    let _e205 = entry_1;
+    let _e206 = row_2;
+    within = (_e205 - (_e206 * 16f));
+    let _e209 = within;
+    texel_3 = floor((_e209 / 4f));
+    let _e214 = light_list_info.cluster_depth[3u];
+    let _e215 = row_2;
+    let _e217 = texel_3;
+    param_83 = _e217;
+    param_84 = (_e214 + _e215);
+    let _e218 = LightListTexel_u0028_f1_u003b_f1_u003b((&param_83), (&param_84));
+    four_1 = _e218;
+    let _e219 = within;
+    let _e220 = texel_3;
+    let _e225 = four_1;
+    param_85 = _e225;
+    param_86 = i32(((_e219 - (_e220 * 4f)) + 0.5f));
+    let _e226 = LightListLane_u0028_vf4_u003b_i1_u003b((&param_85), (&param_86));
+    return _e226;
 }
 
 fn Clustered_u0028_() -> bool {
-    let _e189 = light_list_info.cluster_grid[3u];
-    return (_e189 > 0.5f);
+    let _e190 = light_list_info.cluster_grid[3u];
+    return (_e190 > 0.5f);
 }
 
 fn SampleLight_u0028_i1_u003b_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(index_2: ptr<function, i32>, s_4: ptr<function, Surface>) -> LightSample {
@@ -12060,264 +12144,264 @@ fn SampleLight_u0028_i1_u003b_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_
 
     light_3.integrated = 0f;
     light_3.ltc = vec3<f32>(0f, 0f, 0f);
-    let _e240 = (*index_2);
-    if (_e240 < 8i) {
-        let _e242 = (*index_2);
-        let _e245 = frag_info.light_position[_e242];
-        position = _e245;
-        let _e246 = (*index_2);
-        let _e249 = frag_info.light_color[_e246];
-        color_1 = _e249;
-        let _e250 = (*index_2);
-        let _e253 = frag_info.light_direction[_e250];
-        direction = _e253;
-        let _e254 = (*index_2);
-        let _e257 = frag_info.light_cone[_e254];
-        cone = _e257;
+    let _e241 = (*index_2);
+    if (_e241 < 8i) {
+        let _e243 = (*index_2);
+        let _e246 = frag_info.light_position[_e243];
+        position = _e246;
+        let _e247 = (*index_2);
+        let _e250 = frag_info.light_color[_e247];
+        color_1 = _e250;
+        let _e251 = (*index_2);
+        let _e254 = frag_info.light_direction[_e251];
+        direction = _e254;
+        let _e255 = (*index_2);
+        let _e258 = frag_info.light_cone[_e255];
+        cone = _e258;
     } else {
-        let _e258 = (*index_2);
-        slot_5 = (_e258 - 8i);
-        let _e260 = Clustered_u0028_();
-        clustered = _e260;
-        let _e261 = clustered;
-        if _e261 {
-            let _e262 = slot_5;
-            param_87 = _e262;
-            let _e263 = ClusterRow_u0028_i1_u003b((&param_87));
-            local_20 = _e263;
+        let _e259 = (*index_2);
+        slot_5 = (_e259 - 8i);
+        let _e261 = Clustered_u0028_();
+        clustered = _e261;
+        let _e262 = clustered;
+        if _e262 {
+            let _e263 = slot_5;
+            param_87 = _e263;
+            let _e264 = ClusterRow_u0028_i1_u003b((&param_87));
+            local_20 = _e264;
         } else {
-            let _e264 = slot_5;
-            param_88 = _e264;
-            let _e265 = LightListRow_u0028_i1_u003b((&param_88));
-            local_20 = _e265;
+            let _e265 = slot_5;
+            param_88 = _e265;
+            let _e266 = LightListRow_u0028_i1_u003b((&param_88));
+            local_20 = _e266;
         }
-        let _e266 = local_20;
-        listRow = _e266;
-        let _e267 = listRow;
-        let _e271 = light_list_info.list[2u];
-        v_1 = ((_e267 + 0.5f) * _e271);
-        let _e275 = light_list_info.list[1u];
-        u_1 = _e275;
-        let _e276 = u_1;
-        let _e278 = v_1;
-        let _e280 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((0.5f * _e276), _e278), 0f);
-        position = _e280;
-        let _e281 = u_1;
-        let _e283 = v_1;
-        let _e285 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((1.5f * _e281), _e283), 0f);
-        color_1 = _e285;
-        let _e286 = u_1;
-        let _e288 = v_1;
-        let _e290 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((2.5f * _e286), _e288), 0f);
-        direction = _e290;
-        let _e291 = u_1;
-        let _e293 = v_1;
-        let _e295 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((3.5f * _e291), _e293), 0f);
-        cone = _e295;
-        let _e296 = clustered;
-        if _e296 {
-            let _e297 = listRow;
-            param_89 = _e297;
-            let _e298 = InSlots_u0028_f1_u003b((&param_89));
-            local_21 = select(1f, 0f, _e298);
+        let _e267 = local_20;
+        listRow = _e267;
+        let _e268 = listRow;
+        let _e272 = light_list_info.list[2u];
+        v_1 = ((_e268 + 0.5f) * _e272);
+        let _e276 = light_list_info.list[1u];
+        u_1 = _e276;
+        let _e277 = u_1;
+        let _e279 = v_1;
+        let _e281 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((0.5f * _e277), _e279), 0f);
+        position = _e281;
+        let _e282 = u_1;
+        let _e284 = v_1;
+        let _e286 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((1.5f * _e282), _e284), 0f);
+        color_1 = _e286;
+        let _e287 = u_1;
+        let _e289 = v_1;
+        let _e291 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((2.5f * _e287), _e289), 0f);
+        direction = _e291;
+        let _e292 = u_1;
+        let _e294 = v_1;
+        let _e296 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((3.5f * _e292), _e294), 0f);
+        cone = _e296;
+        let _e297 = clustered;
+        if _e297 {
+            let _e298 = listRow;
+            param_89 = _e298;
+            let _e299 = InSlots_u0028_f1_u003b((&param_89));
+            local_21 = select(1f, 0f, _e299);
         } else {
-            let _e300 = slot_5;
-            param_90 = _e300;
-            let _e301 = LightListScale_u0028_i1_u003b((&param_90));
-            local_21 = _e301;
+            let _e301 = slot_5;
+            param_90 = _e301;
+            let _e302 = LightListScale_u0028_i1_u003b((&param_90));
+            local_21 = _e302;
         }
-        let _e302 = local_21;
-        let _e304 = color_1[3u];
-        color_1[3u] = (_e304 * _e302);
+        let _e303 = local_21;
+        let _e305 = color_1[3u];
+        color_1[3u] = (_e305 * _e303);
     }
-    let _e308 = position[3u];
-    type_39 = _e308;
-    let _e309 = type_39;
-    if (_e309 > 2.5f) {
-        let _e311 = direction;
-        halfWidth_1 = _e311.xyz;
-        let _e313 = cone;
-        halfHeight_1 = _e313.xyz;
-        let _e315 = position;
-        let _e317 = v_world_position_1;
-        toCentre = (_e315.xyz - _e317);
-        let _e319 = toCentre;
-        let _e320 = halfWidth_1;
-        let _e322 = halfHeight_1;
-        corners_1[0i] = ((_e319 - _e320) - _e322);
-        let _e325 = toCentre;
-        let _e326 = halfWidth_1;
-        let _e328 = halfHeight_1;
-        corners_1[1i] = ((_e325 + _e326) - _e328);
-        let _e331 = toCentre;
-        let _e332 = halfWidth_1;
-        let _e334 = halfHeight_1;
-        corners_1[2i] = ((_e331 + _e332) + _e334);
-        let _e337 = toCentre;
-        let _e338 = halfWidth_1;
-        let _e340 = halfHeight_1;
-        corners_1[3i] = ((_e337 - _e338) + _e340);
-        let _e343 = toCentre;
-        let _e344 = halfWidth_1;
-        let _e345 = halfHeight_1;
-        behind = (dot(_e343, cross(_e344, _e345)) >= 0f);
-        let _e349 = behind;
-        if _e349 {
+    let _e309 = position[3u];
+    type_39 = _e309;
+    let _e310 = type_39;
+    if (_e310 > 2.5f) {
+        let _e312 = direction;
+        halfWidth_1 = _e312.xyz;
+        let _e314 = cone;
+        halfHeight_1 = _e314.xyz;
+        let _e316 = position;
+        let _e318 = v_world_position_1;
+        toCentre = (_e316.xyz - _e318);
+        let _e320 = toCentre;
+        let _e321 = halfWidth_1;
+        let _e323 = halfHeight_1;
+        corners_1[0i] = ((_e320 - _e321) - _e323);
+        let _e326 = toCentre;
+        let _e327 = halfWidth_1;
+        let _e329 = halfHeight_1;
+        corners_1[1i] = ((_e326 + _e327) - _e329);
+        let _e332 = toCentre;
+        let _e333 = halfWidth_1;
+        let _e335 = halfHeight_1;
+        corners_1[2i] = ((_e332 + _e333) + _e335);
+        let _e338 = toCentre;
+        let _e339 = halfWidth_1;
+        let _e341 = halfHeight_1;
+        corners_1[3i] = ((_e338 - _e339) + _e341);
+        let _e344 = toCentre;
+        let _e345 = halfWidth_1;
+        let _e346 = halfHeight_1;
+        behind = (dot(_e344, cross(_e345, _e346)) >= 0f);
+        let _e350 = behind;
+        if _e350 {
             local_22 = 0f;
         } else {
-            let _e350 = corners_1;
-            param_91 = _e350;
-            let _e352 = (*s_4).n;
-            param_92 = _e352;
-            let _e353 = RectangleFormFactor_u0028_vf3_u005b_4_u005d_u003b_vf3_u003b((&param_91), (&param_92));
-            local_22 = _e353;
+            let _e351 = corners_1;
+            param_91 = _e351;
+            let _e353 = (*s_4).n;
+            param_92 = _e353;
+            let _e354 = RectangleFormFactor_u0028_vf3_u005b_4_u005d_u003b_vf3_u003b((&param_91), (&param_92));
+            local_22 = _e354;
         }
-        let _e354 = local_22;
-        formFactor = _e354;
-        let _e355 = halfWidth_1;
-        let _e356 = halfHeight_1;
-        area = (length(cross(_e355, _e356)) * 4f);
-        let _e360 = area;
-        if (_e360 > 0.000000001f) {
-            let _e362 = area;
-            local_23 = (1f / _e362);
+        let _e355 = local_22;
+        formFactor = _e355;
+        let _e356 = halfWidth_1;
+        let _e357 = halfHeight_1;
+        area = (length(cross(_e356, _e357)) * 4f);
+        let _e361 = area;
+        if (_e361 > 0.000000001f) {
+            let _e363 = area;
+            local_23 = (1f / _e363);
         } else {
             local_23 = 0f;
         }
-        let _e364 = local_23;
-        radiance = _e364;
-        let _e365 = toCentre;
-        distance_2 = length(_e365);
-        let _e368 = direction[3u];
-        if (_e368 > 0f) {
-            let _e370 = distance_2;
-            let _e372 = direction[3u];
-            ratio_1 = (_e370 / _e372);
-            let _e374 = ratio_1;
+        let _e365 = local_23;
+        radiance = _e365;
+        let _e366 = toCentre;
+        distance_2 = length(_e366);
+        let _e369 = direction[3u];
+        if (_e369 > 0f) {
+            let _e371 = distance_2;
+            let _e373 = direction[3u];
+            ratio_1 = (_e371 / _e373);
             let _e375 = ratio_1;
-            let _e377 = ratio_1;
-            let _e379 = ratio_1;
-            window_1 = clamp((1f - (((_e374 * _e375) * _e377) * _e379)), 0f, 1f);
-            let _e383 = window_1;
+            let _e376 = ratio_1;
+            let _e378 = ratio_1;
+            let _e380 = ratio_1;
+            window_1 = clamp((1f - (((_e375 * _e376) * _e378) * _e380)), 0f, 1f);
             let _e384 = window_1;
-            let _e386 = radiance;
-            radiance = (_e386 * (_e383 * _e384));
+            let _e385 = window_1;
+            let _e387 = radiance;
+            radiance = (_e387 * (_e384 * _e385));
         }
-        let _e389 = (*s_4).v;
-        let _e392 = (*s_4).n;
-        mirror_1 = reflect(-(_e389), _e392);
-        let _e394 = position;
-        param_93 = _e394.xyz;
-        let _e396 = halfWidth_1;
-        param_94 = _e396;
-        let _e397 = halfHeight_1;
-        param_95 = _e397;
-        let _e398 = v_world_position_1;
-        param_96 = _e398;
-        let _e399 = mirror_1;
-        param_97 = _e399;
-        let _e400 = RectangleClosestPoint_u0028_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b((&param_93), (&param_94), (&param_95), (&param_96), (&param_97));
-        representative = _e400;
-        let _e401 = representative;
-        let _e402 = v_world_position_1;
-        toPoint = (_e401 - _e402);
-        let _e404 = toPoint;
-        pointDistance = length(_e404);
-        let _e406 = pointDistance;
-        if (_e406 > 0.000001f) {
-            let _e408 = toPoint;
-            let _e409 = pointDistance;
-            local_24 = (_e408 / vec3(_e409));
+        let _e390 = (*s_4).v;
+        let _e393 = (*s_4).n;
+        mirror_1 = reflect(-(_e390), _e393);
+        let _e395 = position;
+        param_93 = _e395.xyz;
+        let _e397 = halfWidth_1;
+        param_94 = _e397;
+        let _e398 = halfHeight_1;
+        param_95 = _e398;
+        let _e399 = v_world_position_1;
+        param_96 = _e399;
+        let _e400 = mirror_1;
+        param_97 = _e400;
+        let _e401 = RectangleClosestPoint_u0028_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b((&param_93), (&param_94), (&param_95), (&param_96), (&param_97));
+        representative = _e401;
+        let _e402 = representative;
+        let _e403 = v_world_position_1;
+        toPoint = (_e402 - _e403);
+        let _e405 = toPoint;
+        pointDistance = length(_e405);
+        let _e407 = pointDistance;
+        if (_e407 > 0.000001f) {
+            let _e409 = toPoint;
+            let _e410 = pointDistance;
+            local_24 = (_e409 / vec3(_e410));
         } else {
-            let _e413 = (*s_4).n;
-            local_24 = _e413;
+            let _e414 = (*s_4).n;
+            local_24 = _e414;
         }
-        let _e414 = local_24;
-        light_3.l = _e414;
-        let _e417 = light_3.l;
-        let _e419 = (*s_4).v;
-        light_3.h = normalize((_e417 + _e419));
-        let _e423 = formFactor;
-        light_3.n_dot_l = _e423;
-        let _e426 = (*s_4).n;
-        let _e428 = light_3.h;
-        light_3.n_dot_h = max(dot(_e426, _e428), 0f);
-        let _e433 = (*s_4).v;
-        let _e435 = light_3.h;
-        light_3.v_dot_h = max(dot(_e433, _e435), 0f);
-        let _e439 = color_1;
-        let _e442 = color_1[3u];
-        let _e444 = radiance;
-        light_3.radiance = ((_e439.xyz * _e442) * _e444);
-        let _e447 = light_3;
-        return _e447;
+        let _e415 = local_24;
+        light_3.l = _e415;
+        let _e418 = light_3.l;
+        let _e420 = (*s_4).v;
+        light_3.h = normalize((_e418 + _e420));
+        let _e424 = formFactor;
+        light_3.n_dot_l = _e424;
+        let _e427 = (*s_4).n;
+        let _e429 = light_3.h;
+        light_3.n_dot_h = max(dot(_e427, _e429), 0f);
+        let _e434 = (*s_4).v;
+        let _e436 = light_3.h;
+        light_3.v_dot_h = max(dot(_e434, _e436), 0f);
+        let _e440 = color_1;
+        let _e443 = color_1[3u];
+        let _e445 = radiance;
+        light_3.radiance = ((_e440.xyz * _e443) * _e445);
+        let _e448 = light_3;
+        return _e448;
     }
-    let _e448 = direction;
-    aim = normalize(_e448.xyz);
+    let _e449 = direction;
+    aim = normalize(_e449.xyz);
     attenuation_1 = 1f;
-    let _e451 = type_39;
-    if (_e451 < 0.5f) {
-        let _e453 = aim;
-        light_3.l = -(_e453);
+    let _e452 = type_39;
+    if (_e452 < 0.5f) {
+        let _e454 = aim;
+        light_3.l = -(_e454);
     } else {
-        let _e456 = position;
-        let _e458 = v_world_position_1;
-        toLight_1 = (_e456.xyz - _e458);
-        let _e460 = toLight_1;
-        distance_3 = length(_e460);
-        let _e462 = distance_3;
-        if (_e462 < 0.000001f) {
-            let _e465 = (*s_4).n;
-            light_3.l = _e465;
-            let _e468 = (*s_4).n;
-            light_3.h = _e468;
+        let _e457 = position;
+        let _e459 = v_world_position_1;
+        toLight_1 = (_e457.xyz - _e459);
+        let _e461 = toLight_1;
+        distance_3 = length(_e461);
+        let _e463 = distance_3;
+        if (_e463 < 0.000001f) {
+            let _e466 = (*s_4).n;
+            light_3.l = _e466;
+            let _e469 = (*s_4).n;
+            light_3.h = _e469;
             light_3.radiance = vec3<f32>(0f, 0f, 0f);
             light_3.n_dot_l = 0f;
             light_3.n_dot_h = 0f;
             light_3.v_dot_h = 0f;
-            let _e474 = light_3;
-            return _e474;
+            let _e475 = light_3;
+            return _e475;
         }
-        let _e475 = toLight_1;
-        let _e476 = distance_3;
-        light_3.l = (_e475 / vec3(_e476));
-        let _e480 = distance_3;
-        param_98 = _e480;
-        let _e482 = direction[3u];
-        param_99 = _e482;
-        let _e483 = PunctualAttenuation_u0028_f1_u003b_f1_u003b((&param_98), (&param_99));
-        attenuation_1 = _e483;
-        let _e484 = type_39;
-        if (_e484 > 1.5f) {
-            let _e486 = aim;
-            let _e488 = light_3.l;
-            cosAngle = dot(_e486, -(_e488));
-            let _e491 = cosAngle;
-            let _e493 = cone[1u];
-            let _e496 = cone[0u];
-            let _e498 = cone[1u];
-            let _e502 = attenuation_1;
-            attenuation_1 = (_e502 * clamp(((_e491 - _e493) / (_e496 - _e498)), 0f, 1f));
+        let _e476 = toLight_1;
+        let _e477 = distance_3;
+        light_3.l = (_e476 / vec3(_e477));
+        let _e481 = distance_3;
+        param_98 = _e481;
+        let _e483 = direction[3u];
+        param_99 = _e483;
+        let _e484 = PunctualAttenuation_u0028_f1_u003b_f1_u003b((&param_98), (&param_99));
+        attenuation_1 = _e484;
+        let _e485 = type_39;
+        if (_e485 > 1.5f) {
+            let _e487 = aim;
+            let _e489 = light_3.l;
+            cosAngle = dot(_e487, -(_e489));
+            let _e492 = cosAngle;
+            let _e494 = cone[1u];
+            let _e497 = cone[0u];
+            let _e499 = cone[1u];
+            let _e503 = attenuation_1;
+            attenuation_1 = (_e503 * clamp(((_e492 - _e494) / (_e497 - _e499)), 0f, 1f));
         }
     }
-    let _e505 = light_3.l;
-    let _e507 = (*s_4).v;
-    light_3.h = normalize((_e505 + _e507));
-    let _e512 = (*s_4).n;
-    let _e514 = light_3.l;
-    light_3.n_dot_l = max(dot(_e512, _e514), 0f);
-    let _e519 = (*s_4).n;
-    let _e521 = light_3.h;
-    light_3.n_dot_h = max(dot(_e519, _e521), 0f);
-    let _e526 = (*s_4).v;
-    let _e528 = light_3.h;
-    light_3.v_dot_h = max(dot(_e526, _e528), 0f);
-    let _e532 = color_1;
-    let _e535 = color_1[3u];
-    let _e537 = attenuation_1;
-    light_3.radiance = ((_e532.xyz * _e535) * _e537);
-    let _e540 = light_3;
-    return _e540;
+    let _e506 = light_3.l;
+    let _e508 = (*s_4).v;
+    light_3.h = normalize((_e506 + _e508));
+    let _e513 = (*s_4).n;
+    let _e515 = light_3.l;
+    light_3.n_dot_l = max(dot(_e513, _e515), 0f);
+    let _e520 = (*s_4).n;
+    let _e522 = light_3.h;
+    light_3.n_dot_h = max(dot(_e520, _e522), 0f);
+    let _e527 = (*s_4).v;
+    let _e529 = light_3.h;
+    light_3.v_dot_h = max(dot(_e527, _e529), 0f);
+    let _e533 = color_1;
+    let _e536 = color_1[3u];
+    let _e538 = attenuation_1;
+    light_3.radiance = ((_e533.xyz * _e536) * _e538);
+    let _e541 = light_3;
+    return _e541;
 }
 
 fn FindCluster_u0028_vf3_u003b(world_3: ptr<function, vec3<f32>>) {
@@ -12335,58 +12419,58 @@ fn FindCluster_u0028_vf3_u003b(world_3: ptr<function, vec3<f32>>) {
     var param_100: f32;
     var param_101: f32;
 
-    let _e202 = light_list_info.cluster_view_projection;
-    let _e203 = (*world_3);
-    clip_1 = (_e202 * vec4<f32>(_e203.x, _e203.y, _e203.z, 1f));
-    let _e209 = clip_1;
-    let _e212 = clip_1[3u];
-    ndc_1 = (_e209.xy / vec2(max(_e212, 0.000001f)));
-    let _e217 = light_list_info.cluster_grid;
-    grid = _e217.xyz;
-    let _e221 = light_list_info.cluster_depth[0u];
-    near_1 = _e221;
-    let _e223 = ndc_1[0u];
-    let _e227 = grid[0u];
-    let _e231 = grid[0u];
-    tx = clamp(floor((((_e223 * 0.5f) + 0.5f) * _e227)), 0f, (_e231 - 1f));
-    let _e235 = ndc_1[1u];
-    let _e239 = grid[1u];
-    let _e243 = grid[1u];
-    ty = clamp(floor((((_e235 * 0.5f) + 0.5f) * _e239)), 0f, (_e243 - 1f));
-    let _e247 = clip_1[3u];
-    let _e248 = near_1;
-    if (_e247 <= _e248) {
+    let _e203 = light_list_info.cluster_view_projection;
+    let _e204 = (*world_3);
+    clip_1 = (_e203 * vec4<f32>(_e204.x, _e204.y, _e204.z, 1f));
+    let _e210 = clip_1;
+    let _e213 = clip_1[3u];
+    ndc_1 = (_e210.xy / vec2(max(_e213, 0.000001f)));
+    let _e218 = light_list_info.cluster_grid;
+    grid = _e218.xyz;
+    let _e222 = light_list_info.cluster_depth[0u];
+    near_1 = _e222;
+    let _e224 = ndc_1[0u];
+    let _e228 = grid[0u];
+    let _e232 = grid[0u];
+    tx = clamp(floor((((_e224 * 0.5f) + 0.5f) * _e228)), 0f, (_e232 - 1f));
+    let _e236 = ndc_1[1u];
+    let _e240 = grid[1u];
+    let _e244 = grid[1u];
+    ty = clamp(floor((((_e236 * 0.5f) + 0.5f) * _e240)), 0f, (_e244 - 1f));
+    let _e248 = clip_1[3u];
+    let _e249 = near_1;
+    if (_e248 <= _e249) {
         local_25 = 0f;
     } else {
-        let _e251 = clip_1[3u];
-        let _e252 = near_1;
-        let _e257 = light_list_info.cluster_depth[1u];
-        let _e261 = grid[2u];
-        local_25 = clamp(floor((log((_e251 / _e252)) * _e257)), 0f, (_e261 - 1f));
+        let _e252 = clip_1[3u];
+        let _e253 = near_1;
+        let _e258 = light_list_info.cluster_depth[1u];
+        let _e262 = grid[2u];
+        local_25 = clamp(floor((log((_e252 / _e253)) * _e258)), 0f, (_e262 - 1f));
     }
-    let _e264 = local_25;
-    tz = _e264;
-    let _e265 = tx;
-    let _e266 = ty;
-    let _e268 = grid[0u];
-    let _e271 = tz;
-    let _e273 = grid[0u];
-    let _e276 = grid[1u];
-    cell = ((_e265 + (_e266 * _e268)) + ((_e271 * _e273) * _e276));
-    let _e279 = cell;
-    row_3 = floor((_e279 / 4f));
-    let _e282 = cell;
-    let _e283 = row_3;
-    let _e288 = light_list_info.cluster_depth[2u];
-    let _e289 = row_3;
-    param_100 = (_e282 - (_e283 * 4f));
-    param_101 = (_e288 + _e289);
-    let _e291 = LightListTexel_u0028_f1_u003b_f1_u003b((&param_100), (&param_101));
-    header = _e291;
-    let _e293 = header[0u];
-    g_cluster_offset = _e293;
-    let _e295 = header[1u];
-    g_cluster_count = _e295;
+    let _e265 = local_25;
+    tz = _e265;
+    let _e266 = tx;
+    let _e267 = ty;
+    let _e269 = grid[0u];
+    let _e272 = tz;
+    let _e274 = grid[0u];
+    let _e277 = grid[1u];
+    cell = ((_e266 + (_e267 * _e269)) + ((_e272 * _e274) * _e277));
+    let _e280 = cell;
+    row_3 = floor((_e280 / 4f));
+    let _e283 = cell;
+    let _e284 = row_3;
+    let _e289 = light_list_info.cluster_depth[2u];
+    let _e290 = row_3;
+    param_100 = (_e283 - (_e284 * 4f));
+    param_101 = (_e289 + _e290);
+    let _e292 = LightListTexel_u0028_f1_u003b_f1_u003b((&param_100), (&param_101));
+    header = _e292;
+    let _e294 = header[0u];
+    g_cluster_offset = _e294;
+    let _e296 = header[1u];
+    g_cluster_count = _e296;
     return;
 }
 
@@ -12394,19 +12478,19 @@ fn LightCount_u0028_() -> i32 {
     var tail: f32;
     var param_102: vec3<f32>;
 
-    let _e191 = light_list_info.list[0u];
-    tail = _e191;
-    let _e192 = Clustered_u0028_();
-    if _e192 {
-        let _e193 = v_world_position_1;
-        param_102 = _e193;
+    let _e192 = light_list_info.list[0u];
+    tail = _e192;
+    let _e193 = Clustered_u0028_();
+    if _e193 {
+        let _e194 = v_world_position_1;
+        param_102 = _e194;
         FindCluster_u0028_vf3_u003b((&param_102));
-        let _e194 = g_cluster_count;
-        tail = _e194;
+        let _e195 = g_cluster_count;
+        tail = _e195;
     }
-    let _e197 = frag_info.frame_params[1u];
-    let _e201 = tail;
-    return (clamp(i32((_e197 + 0.5f)), 0i, 8i) + clamp(i32((_e201 + 0.5f)), 0i, 24i));
+    let _e198 = frag_info.frame_params[1u];
+    let _e202 = tail;
+    return (clamp(i32((_e198 + 0.5f)), 0i, 8i) + clamp(i32((_e202 + 0.5f)), 0i, 24i));
 }
 
 fn AccumulateLights_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_5: ptr<function, Surface>) -> vec3<f32> {
@@ -12429,109 +12513,109 @@ fn AccumulateLights_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002
     var param_113: LightSample;
 
     total_1 = vec3<f32>(0f, 0f, 0f);
-    let _e205 = LightCount_u0028_();
-    count_1 = _e205;
+    let _e206 = LightCount_u0028_();
+    count_1 = _e206;
     i_8 = 0i;
     loop {
-        let _e206 = i_8;
-        if (_e206 < 32i) {
-            let _e208 = i_8;
-            let _e209 = count_1;
-            if (_e208 >= _e209) {
+        let _e207 = i_8;
+        if (_e207 < 32i) {
+            let _e209 = i_8;
+            let _e210 = count_1;
+            if (_e209 >= _e210) {
                 break;
             }
-            let _e211 = i_8;
-            param_103 = _e211;
-            let _e212 = (*s_5);
-            param_104 = _e212;
-            let _e213 = SampleLight_u0028_i1_u003b_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_103), (&param_104));
-            light_4 = _e213;
-            let _e215 = light_4.n_dot_l;
-            if (_e215 <= 0f) {
+            let _e212 = i_8;
+            param_103 = _e212;
+            let _e213 = (*s_5);
+            param_104 = _e213;
+            let _e214 = SampleLight_u0028_i1_u003b_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_103), (&param_104));
+            light_4 = _e214;
+            let _e216 = light_4.n_dot_l;
+            if (_e216 <= 0f) {
                 continue;
             }
             light_transmittance = vec3<f32>(1f, 1f, 1f);
-            let _e217 = i_8;
-            param_105 = _e217;
-            let _e218 = LightHasShadow_u0028_i1_u003b((&param_105));
-            if _e218 {
-                let _e219 = (*s_5);
-                param_106 = _e219;
-                let _e220 = light_4;
-                param_107 = _e220;
-                let _e221 = i_8;
-                param_108 = _e221;
-                let _e222 = LightVisibility_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b_i1_u003b((&param_106), (&param_107), (&param_108));
-                let _e223 = v_world_position_1;
-                param_109 = _e223;
-                let _e225 = (*s_5).n;
-                param_110 = _e225;
-                let _e226 = i_8;
-                param_111 = _e226;
-                let _e227 = PointShadowFactor_u0028_vf3_u003b_vf3_u003b_i1_u003b((&param_109), (&param_110), (&param_111));
-                local_26 = (_e222 * _e227);
+            let _e218 = i_8;
+            param_105 = _e218;
+            let _e219 = LightHasShadow_u0028_i1_u003b((&param_105));
+            if _e219 {
+                let _e220 = (*s_5);
+                param_106 = _e220;
+                let _e221 = light_4;
+                param_107 = _e221;
+                let _e222 = i_8;
+                param_108 = _e222;
+                let _e223 = LightVisibility_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b_i1_u003b((&param_106), (&param_107), (&param_108));
+                let _e224 = v_world_position_1;
+                param_109 = _e224;
+                let _e226 = (*s_5).n;
+                param_110 = _e226;
+                let _e227 = i_8;
+                param_111 = _e227;
+                let _e228 = PointShadowFactor_u0028_vf3_u003b_vf3_u003b_i1_u003b((&param_109), (&param_110), (&param_111));
+                local_26 = (_e223 * _e228);
             } else {
                 local_26 = 1f;
             }
-            let _e229 = local_26;
-            visibility = _e229;
-            let _e230 = visibility;
-            if (_e230 <= 0f) {
+            let _e230 = local_26;
+            visibility = _e230;
+            let _e231 = visibility;
+            if (_e231 <= 0f) {
                 continue;
             }
-            let _e232 = (*s_5);
-            param_112 = _e232;
-            let _e233 = light_4;
-            param_113 = _e233;
-            let _e234 = ShadeLight_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b((&param_112), (&param_113));
-            let _e236 = light_4.radiance;
-            let _e239 = light_4.n_dot_l;
-            let _e241 = visibility;
-            let _e243 = light_transmittance;
-            let _e245 = total_1;
-            total_1 = (_e245 + ((((_e234 * _e236) * _e239) * _e241) * _e243));
+            let _e233 = (*s_5);
+            param_112 = _e233;
+            let _e234 = light_4;
+            param_113 = _e234;
+            let _e235 = ShadeLight_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b((&param_112), (&param_113));
+            let _e237 = light_4.radiance;
+            let _e240 = light_4.n_dot_l;
+            let _e242 = visibility;
+            let _e244 = light_transmittance;
+            let _e246 = total_1;
+            total_1 = (_e246 + ((((_e235 * _e237) * _e240) * _e242) * _e244));
             continue;
         } else {
             break;
         }
         continuing {
-            let _e247 = i_8;
-            i_8 = (_e247 + 1i);
+            let _e248 = i_8;
+            i_8 = (_e248 + 1i);
         }
     }
-    let _e249 = total_1;
-    return _e249;
+    let _e250 = total_1;
+    return _e250;
 }
 
 fn SampleLightmap_u0028_() -> vec3<f32> {
     var texel_4: vec4<f32>;
 
-    let _e188 = v_lightmap_uv_1;
-    let _e189 = textureSample(lightmap_texture_tex, lightmap_texture_smp, _e188);
-    texel_4 = _e189;
-    let _e190 = texel_4;
-    let _e193 = texel_4[3u];
-    return ((_e190.xyz * _e193) * 8f);
+    let _e189 = v_lightmap_uv_1;
+    let _e190 = textureSample(lightmap_texture_tex, lightmap_texture_smp, _e189);
+    texel_4 = _e190;
+    let _e191 = texel_4;
+    let _e194 = texel_4[3u];
+    return ((_e191.xyz * _e194) * 8f);
 }
 
 fn MaterialLodBias_u0028_() -> f32 {
-    let _e189 = frag_info.target_origin[1u];
-    return _e189;
+    let _e190 = frag_info.target_origin[1u];
+    return _e190;
 }
 
 fn ApplyMetallicRoughnessMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_6: ptr<function, Surface>) {
     var orm: vec3<f32>;
 
-    let _e189 = v_texcoord_1;
-    let _e190 = MaterialLodBias_u0028_();
-    let _e191 = textureSampleBias(metallic_roughness_texture_tex, metallic_roughness_texture_smp, _e189, _e190);
-    orm = _e191.xyz;
-    let _e194 = (*s_6).metallic;
-    let _e196 = orm[2u];
-    (*s_6).metallic = clamp((_e194 * _e196), 0f, 1f);
-    let _e201 = (*s_6).roughness;
-    let _e203 = orm[1u];
-    (*s_6).roughness = clamp((_e201 * _e203), 0.02f, 1f);
+    let _e190 = v_texcoord_1;
+    let _e191 = MaterialLodBias_u0028_();
+    let _e192 = textureSampleBias(metallic_roughness_texture_tex, metallic_roughness_texture_smp, _e190, _e191);
+    orm = _e192.xyz;
+    let _e195 = (*s_6).metallic;
+    let _e197 = orm[2u];
+    (*s_6).metallic = clamp((_e195 * _e197), 0f, 1f);
+    let _e202 = (*s_6).roughness;
+    let _e204 = orm[1u];
+    (*s_6).roughness = clamp((_e202 * _e204), 0.02f, 1f);
     return;
 }
 
@@ -12539,29 +12623,29 @@ fn ApplyEmissiveMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002
     var emissive: vec3<f32>;
     var param_114: vec3<f32>;
 
-    let _e190 = v_texcoord_1;
-    let _e191 = MaterialLodBias_u0028_();
-    let _e192 = textureSampleBias(emissive_texture_tex, emissive_texture_smp, _e190, _e191);
-    param_114 = _e192.xyz;
-    let _e194 = SrgbToLinear_u0028_vf3_u003b((&param_114));
-    emissive = _e194;
-    let _e195 = emissive;
-    let _e197 = frag_info.emissive;
-    let _e202 = frag_info.material2_[3u];
-    (*s_7).emissive = ((_e195 * _e197.xyz) * _e202);
+    let _e191 = v_texcoord_1;
+    let _e192 = MaterialLodBias_u0028_();
+    let _e193 = textureSampleBias(emissive_texture_tex, emissive_texture_smp, _e191, _e192);
+    param_114 = _e193.xyz;
+    let _e195 = SrgbToLinear_u0028_vf3_u003b((&param_114));
+    emissive = _e195;
+    let _e196 = emissive;
+    let _e198 = frag_info.emissive;
+    let _e203 = frag_info.material2_[3u];
+    (*s_7).emissive = ((_e196 * _e198.xyz) * _e203);
     return;
 }
 
 fn ApplyOcclusionMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_8: ptr<function, Surface>) {
     var occlusion: f32;
 
-    let _e189 = v_texcoord_1;
-    let _e190 = MaterialLodBias_u0028_();
-    let _e191 = textureSampleBias(occlusion_texture_tex, occlusion_texture_smp, _e189, _e190);
-    occlusion = _e191.x;
-    let _e193 = occlusion;
-    let _e196 = frag_info.material2_[2u];
-    (*s_8).occlusion = mix(1f, _e193, clamp(_e196, 0f, 1f));
+    let _e190 = v_texcoord_1;
+    let _e191 = MaterialLodBias_u0028_();
+    let _e192 = textureSampleBias(occlusion_texture_tex, occlusion_texture_smp, _e190, _e191);
+    occlusion = _e192.x;
+    let _e194 = occlusion;
+    let _e197 = frag_info.material2_[2u];
+    (*s_8).occlusion = mix(1f, _e194, clamp(_e197, 0f, 1f));
     return;
 }
 
@@ -12571,64 +12655,64 @@ fn ApplyNormalMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_
     var b_3: vec3<f32>;
     var sampled: vec3<f32>;
 
-    let _e192 = v_texcoord_1;
-    let _e193 = MaterialLodBias_u0028_();
-    let _e194 = textureSampleBias(normal_texture_tex, normal_texture_smp, _e192, _e193);
-    sampledTexel = _e194;
-    let _e195 = v_tangent_1;
-    t_2 = _e195.xyz;
-    let _e197 = t_2;
-    let _e199 = (*s_9).n;
-    let _e201 = (*s_9).n;
-    let _e202 = t_2;
-    t_2 = (_e197 - (_e199 * dot(_e201, _e202)));
-    let _e206 = t_2;
+    let _e193 = v_texcoord_1;
+    let _e194 = MaterialLodBias_u0028_();
+    let _e195 = textureSampleBias(normal_texture_tex, normal_texture_smp, _e193, _e194);
+    sampledTexel = _e195;
+    let _e196 = v_tangent_1;
+    t_2 = _e196.xyz;
+    let _e198 = t_2;
+    let _e200 = (*s_9).n;
+    let _e202 = (*s_9).n;
+    let _e203 = t_2;
+    t_2 = (_e198 - (_e200 * dot(_e202, _e203)));
     let _e207 = t_2;
-    if (dot(_e206, _e207) < 0.000000000001f) {
+    let _e208 = t_2;
+    if (dot(_e207, _e208) < 0.000000000001f) {
         return;
     }
-    let _e210 = t_2;
-    t_2 = normalize(_e210);
-    let _e213 = (*s_9).n;
-    let _e214 = t_2;
-    let _e217 = v_tangent_1[3u];
-    b_3 = (cross(_e213, _e214) * _e217);
-    let _e219 = gl_FrontFacing_1;
-    if !(_e219) {
-        let _e221 = t_2;
-        t_2 = -(_e221);
+    let _e211 = t_2;
+    t_2 = normalize(_e211);
+    let _e214 = (*s_9).n;
+    let _e215 = t_2;
+    let _e218 = v_tangent_1[3u];
+    b_3 = (cross(_e214, _e215) * _e218);
+    let _e220 = gl_FrontFacing_1;
+    if !(_e220) {
+        let _e222 = t_2;
+        t_2 = -(_e222);
     }
-    let _e223 = sampledTexel;
-    sampled = ((_e223.xyz * 2f) - vec3(1f));
-    let _e230 = frag_info.emissive[3u];
-    if (_e230 > 0.5f) {
-        let _e232 = sampled;
-        let _e234 = sampled;
-        sampled[2u] = sqrt(max((1f - dot(_e232.xy, _e234.xy)), 0f));
+    let _e224 = sampledTexel;
+    sampled = ((_e224.xyz * 2f) - vec3(1f));
+    let _e231 = frag_info.emissive[3u];
+    if (_e231 > 0.5f) {
+        let _e233 = sampled;
+        let _e235 = sampled;
+        sampled[2u] = sqrt(max((1f - dot(_e233.xy, _e235.xy)), 0f));
     }
-    let _e243 = frag_info.material2_[1u];
-    let _e244 = sampled;
-    let _e246 = (_e244.xy * _e243);
-    sampled[0u] = _e246.x;
-    sampled[1u] = _e246.y;
-    let _e251 = t_2;
-    let _e253 = sampled[0u];
-    let _e255 = b_3;
-    let _e257 = sampled[1u];
-    let _e261 = (*s_9).n;
-    let _e263 = sampled[2u];
-    (*s_9).n = normalize((((_e251 * _e253) + (_e255 * _e257)) + (_e261 * _e263)));
-    let _e269 = (*s_9).n;
-    let _e271 = (*s_9).v;
-    (*s_9).n_dot_v = max(dot(_e269, _e271), 0.0001f);
+    let _e244 = frag_info.material2_[1u];
+    let _e245 = sampled;
+    let _e247 = (_e245.xy * _e244);
+    sampled[0u] = _e247.x;
+    sampled[1u] = _e247.y;
+    let _e252 = t_2;
+    let _e254 = sampled[0u];
+    let _e256 = b_3;
+    let _e258 = sampled[1u];
+    let _e262 = (*s_9).n;
+    let _e264 = sampled[2u];
+    (*s_9).n = normalize((((_e252 * _e254) + (_e256 * _e258)) + (_e262 * _e264)));
+    let _e270 = (*s_9).n;
+    let _e272 = (*s_9).v;
+    (*s_9).n_dot_v = max(dot(_e270, _e272), 0.0001f);
     return;
 }
 
 fn AtlasTexel_u0028_vf2_u003b(texel_5: ptr<function, vec2<f32>>) -> vec4<f32> {
-    let _e188 = (*texel_5);
-    let _e192 = irradiance_info.atlas;
-    let _e195 = textureSampleLevel(irradiance_texture_tex, irradiance_texture_smp, ((_e188 + vec2(0.5f)) * _e192.xy), 0f);
-    return _e195;
+    let _e189 = (*texel_5);
+    let _e193 = irradiance_info.atlas;
+    let _e196 = textureSampleLevel(irradiance_texture_tex, irradiance_texture_smp, ((_e189 + vec2(0.5f)) * _e193.xy), 0f);
+    return _e196;
 }
 
 fn TileBilinear_u0028_vf2_u003b_f1_u003b_vf2_u003b(corner: ptr<function, vec2<f32>>, interior: ptr<function, f32>, uv_5: ptr<function, vec2<f32>>) -> vec4<f32> {
@@ -12644,42 +12728,42 @@ fn TileBilinear_u0028_vf2_u003b_f1_u003b_vf2_u003b(corner: ptr<function, vec2<f3
     var d_4: vec4<f32>;
     var param_118: vec2<f32>;
 
-    let _e201 = (*uv_5);
-    let _e202 = (*interior);
-    at_1 = ((vec2(1f) + (_e201 * _e202)) - vec2(0.5f));
-    let _e208 = at_1;
-    low = floor(_e208);
-    let _e210 = at_1;
-    let _e211 = low;
-    f = (_e210 - _e211);
-    let _e213 = (*corner);
-    let _e214 = low;
-    param_115 = (_e213 + _e214);
-    let _e216 = AtlasTexel_u0028_vf2_u003b((&param_115));
-    a_4 = _e216;
-    let _e217 = (*corner);
-    let _e218 = low;
-    param_116 = ((_e217 + _e218) + vec2<f32>(1f, 0f));
-    let _e221 = AtlasTexel_u0028_vf2_u003b((&param_116));
-    b_4 = _e221;
-    let _e222 = (*corner);
-    let _e223 = low;
-    param_117 = ((_e222 + _e223) + vec2<f32>(0f, 1f));
-    let _e226 = AtlasTexel_u0028_vf2_u003b((&param_117));
-    c_1 = _e226;
-    let _e227 = (*corner);
-    let _e228 = low;
-    param_118 = ((_e227 + _e228) + vec2<f32>(1f, 1f));
-    let _e231 = AtlasTexel_u0028_vf2_u003b((&param_118));
-    d_4 = _e231;
-    let _e232 = a_4;
-    let _e233 = b_4;
-    let _e235 = f[0u];
-    let _e238 = c_1;
-    let _e239 = d_4;
-    let _e241 = f[0u];
-    let _e245 = f[1u];
-    return mix(mix(_e232, _e233, vec4(_e235)), mix(_e238, _e239, vec4(_e241)), vec4(_e245));
+    let _e202 = (*uv_5);
+    let _e203 = (*interior);
+    at_1 = ((vec2(1f) + (_e202 * _e203)) - vec2(0.5f));
+    let _e209 = at_1;
+    low = floor(_e209);
+    let _e211 = at_1;
+    let _e212 = low;
+    f = (_e211 - _e212);
+    let _e214 = (*corner);
+    let _e215 = low;
+    param_115 = (_e214 + _e215);
+    let _e217 = AtlasTexel_u0028_vf2_u003b((&param_115));
+    a_4 = _e217;
+    let _e218 = (*corner);
+    let _e219 = low;
+    param_116 = ((_e218 + _e219) + vec2<f32>(1f, 0f));
+    let _e222 = AtlasTexel_u0028_vf2_u003b((&param_116));
+    b_4 = _e222;
+    let _e223 = (*corner);
+    let _e224 = low;
+    param_117 = ((_e223 + _e224) + vec2<f32>(0f, 1f));
+    let _e227 = AtlasTexel_u0028_vf2_u003b((&param_117));
+    c_1 = _e227;
+    let _e228 = (*corner);
+    let _e229 = low;
+    param_118 = ((_e228 + _e229) + vec2<f32>(1f, 1f));
+    let _e232 = AtlasTexel_u0028_vf2_u003b((&param_118));
+    d_4 = _e232;
+    let _e233 = a_4;
+    let _e234 = b_4;
+    let _e236 = f[0u];
+    let _e239 = c_1;
+    let _e240 = d_4;
+    let _e242 = f[0u];
+    let _e246 = f[1u];
+    return mix(mix(_e233, _e234, vec4(_e236)), mix(_e239, _e240, vec4(_e242)), vec4(_e246));
 }
 
 fn ProbeOctahedral_u0028_vf3_u003b(direction_1: ptr<function, vec3<f32>>) -> vec2<f32> {
@@ -12687,29 +12771,29 @@ fn ProbeOctahedral_u0028_vf3_u003b(direction_1: ptr<function, vec3<f32>>) -> vec
     var n_5: vec3<f32>;
     var xy: vec2<f32>;
 
-    let _e192 = (*direction_1)[0u];
-    let _e195 = (*direction_1)[1u];
-    let _e199 = (*direction_1)[2u];
-    sum_1 = ((abs(_e192) + abs(_e195)) + abs(_e199));
-    let _e202 = sum_1;
-    if (_e202 <= 0f) {
+    let _e193 = (*direction_1)[0u];
+    let _e196 = (*direction_1)[1u];
+    let _e200 = (*direction_1)[2u];
+    sum_1 = ((abs(_e193) + abs(_e196)) + abs(_e200));
+    let _e203 = sum_1;
+    if (_e203 <= 0f) {
         return vec2<f32>(0.5f, 0.5f);
     }
-    let _e204 = (*direction_1);
-    let _e205 = sum_1;
-    n_5 = (_e204 / vec3(_e205));
-    let _e208 = n_5;
-    xy = _e208.xy;
-    let _e211 = n_5[2u];
-    if (_e211 < 0f) {
-        let _e214 = n_5[1u];
-        let _e218 = n_5[0u];
-        let _e223 = n_5[0u];
-        let _e227 = n_5[1u];
-        xy = vec2<f32>(((1f - abs(_e214)) * select(-1f, 1f, (_e218 >= 0f))), ((1f - abs(_e223)) * select(-1f, 1f, (_e227 >= 0f))));
+    let _e205 = (*direction_1);
+    let _e206 = sum_1;
+    n_5 = (_e205 / vec3(_e206));
+    let _e209 = n_5;
+    xy = _e209.xy;
+    let _e212 = n_5[2u];
+    if (_e212 < 0f) {
+        let _e215 = n_5[1u];
+        let _e219 = n_5[0u];
+        let _e224 = n_5[0u];
+        let _e228 = n_5[1u];
+        xy = vec2<f32>(((1f - abs(_e215)) * select(-1f, 1f, (_e219 >= 0f))), ((1f - abs(_e224)) * select(-1f, 1f, (_e228 >= 0f))));
     }
-    let _e232 = xy;
-    return ((_e232 * 0.5f) + vec2(0.5f));
+    let _e233 = xy;
+    return ((_e233 * 0.5f) + vec2(0.5f));
 }
 
 fn SampleIrradiance_u0028_vf3_u003b_vf3_u003b_vf3_u003b(world_4: ptr<function, vec3<f32>>, normal_1: ptr<function, vec3<f32>>, view_1: ptr<function, vec3<f32>>) -> vec3<f32> {
@@ -12757,190 +12841,190 @@ fn SampleIrradiance_u0028_vf3_u003b_vf3_u003b_vf3_u003b(world_4: ptr<function, v
     var param_127: vec2<f32>;
     var local_27: vec3<f32>;
 
-    let _e234 = irradiance_info.origin;
-    origin_2 = _e234.xyz;
-    let _e237 = irradiance_info.spacing;
-    spacing = _e237.xyz;
-    let _e240 = irradiance_info.counts;
-    counts = _e240.xyz;
-    let _e244 = irradiance_info.tiles[0u];
-    irradianceTile = _e244;
-    let _e247 = irradiance_info.tiles[1u];
-    depthTile = _e247;
-    let _e250 = irradiance_info.tiles[2u];
-    columns = _e250;
-    let _e253 = irradiance_info.tiles[3u];
-    momentsTop = _e253;
-    let _e254 = (*normal_1);
-    unit = normalize(_e254);
-    let _e256 = (*world_4);
-    let _e257 = unit;
-    let _e260 = irradiance_info.spacing[3u];
-    let _e263 = (*view_1);
-    let _e266 = irradiance_info.counts[3u];
-    biased = ((_e256 + (_e257 * _e260)) + (_e263 * _e266));
-    let _e269 = biased;
-    let _e270 = origin_2;
-    let _e272 = spacing;
-    grid_1 = ((_e269 - _e270) / _e272);
-    let _e274 = grid_1;
-    let _e276 = counts;
-    base = clamp(floor(_e274), vec3<f32>(0f, 0f, 0f), (_e276 - vec3(2f)));
-    let _e280 = grid_1;
-    let _e281 = base;
-    f_1 = clamp((_e280 - _e281), vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
+    let _e235 = irradiance_info.origin;
+    origin_2 = _e235.xyz;
+    let _e238 = irradiance_info.spacing;
+    spacing = _e238.xyz;
+    let _e241 = irradiance_info.counts;
+    counts = _e241.xyz;
+    let _e245 = irradiance_info.tiles[0u];
+    irradianceTile = _e245;
+    let _e248 = irradiance_info.tiles[1u];
+    depthTile = _e248;
+    let _e251 = irradiance_info.tiles[2u];
+    columns = _e251;
+    let _e254 = irradiance_info.tiles[3u];
+    momentsTop = _e254;
+    let _e255 = (*normal_1);
+    unit = normalize(_e255);
+    let _e257 = (*world_4);
+    let _e258 = unit;
+    let _e261 = irradiance_info.spacing[3u];
+    let _e264 = (*view_1);
+    let _e267 = irradiance_info.counts[3u];
+    biased = ((_e257 + (_e258 * _e261)) + (_e264 * _e267));
+    let _e270 = biased;
+    let _e271 = origin_2;
+    let _e273 = spacing;
+    grid_1 = ((_e270 - _e271) / _e273);
+    let _e275 = grid_1;
+    let _e277 = counts;
+    base = clamp(floor(_e275), vec3<f32>(0f, 0f, 0f), (_e277 - vec3(2f)));
+    let _e281 = grid_1;
+    let _e282 = base;
+    f_1 = clamp((_e281 - _e282), vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
     total_2 = vec3<f32>(0f, 0f, 0f);
     weights = 0f;
     corner_1 = 0i;
     loop {
-        let _e284 = corner_1;
-        if (_e284 < 8i) {
-            let _e286 = corner_1;
-            let _e289 = corner_1;
-            let _e294 = corner_1;
-            offset_3 = vec3<f32>(f32((_e286 & 1i)), f32(((_e289 >> bitcast<u32>(1i)) & 1i)), f32(((_e294 >> bitcast<u32>(2i)) & 1i)));
-            let _e300 = base;
-            let _e301 = offset_3;
-            cell_1 = (_e300 + _e301);
-            let _e304 = cell_1[2u];
-            let _e306 = counts[1u];
-            let _e309 = cell_1[1u];
-            let _e312 = counts[0u];
-            let _e315 = cell_1[0u];
-            probe = ((((_e304 * _e306) + _e309) * _e312) + _e315);
-            let _e317 = probe;
-            let _e318 = columns;
-            let _e323 = probe;
-            let _e324 = columns;
-            tile_4 = vec2<f32>((_e317 - (floor((_e317 / _e318)) * _e318)), floor((_e323 / _e324)));
-            let _e328 = tile_4;
-            let _e329 = irradianceTile;
-            irradianceCorner = (_e328 * (_e329 + 2f));
-            let _e333 = tile_4[0u];
-            let _e334 = depthTile;
-            let _e337 = momentsTop;
-            let _e339 = tile_4[1u];
-            let _e340 = depthTile;
-            momentCorner = vec2<f32>((_e333 * (_e334 + 2f)), (_e337 + (_e339 * (_e340 + 2f))));
-            let _e345 = irradianceCorner;
-            param_119 = (_e345 + vec2(1f));
-            let _e348 = AtlasTexel_u0028_vf2_u003b((&param_119));
-            if (_e348.w < 0.5f) {
+        let _e285 = corner_1;
+        if (_e285 < 8i) {
+            let _e287 = corner_1;
+            let _e290 = corner_1;
+            let _e295 = corner_1;
+            offset_3 = vec3<f32>(f32((_e287 & 1i)), f32(((_e290 >> bitcast<u32>(1i)) & 1i)), f32(((_e295 >> bitcast<u32>(2i)) & 1i)));
+            let _e301 = base;
+            let _e302 = offset_3;
+            cell_1 = (_e301 + _e302);
+            let _e305 = cell_1[2u];
+            let _e307 = counts[1u];
+            let _e310 = cell_1[1u];
+            let _e313 = counts[0u];
+            let _e316 = cell_1[0u];
+            probe = ((((_e305 * _e307) + _e310) * _e313) + _e316);
+            let _e318 = probe;
+            let _e319 = columns;
+            let _e324 = probe;
+            let _e325 = columns;
+            tile_4 = vec2<f32>((_e318 - (floor((_e318 / _e319)) * _e319)), floor((_e324 / _e325)));
+            let _e329 = tile_4;
+            let _e330 = irradianceTile;
+            irradianceCorner = (_e329 * (_e330 + 2f));
+            let _e334 = tile_4[0u];
+            let _e335 = depthTile;
+            let _e338 = momentsTop;
+            let _e340 = tile_4[1u];
+            let _e341 = depthTile;
+            momentCorner = vec2<f32>((_e334 * (_e335 + 2f)), (_e338 + (_e340 * (_e341 + 2f))));
+            let _e346 = irradianceCorner;
+            param_119 = (_e346 + vec2(1f));
+            let _e349 = AtlasTexel_u0028_vf2_u003b((&param_119));
+            if (_e349.w < 0.5f) {
                 continue;
             }
-            let _e351 = f_1;
-            let _e353 = f_1;
-            let _e354 = offset_3;
-            trilinear = mix((vec3<f32>(1f, 1f, 1f) - _e351), _e353, _e354);
-            let _e357 = trilinear[0u];
-            let _e359 = trilinear[1u];
-            let _e362 = trilinear[2u];
-            weight_3 = max(((_e357 * _e359) * _e362), 0.001f);
-            let _e365 = origin_2;
-            let _e366 = spacing;
-            let _e367 = cell_1;
-            probePosition = (_e365 + (_e366 * _e367));
-            let _e370 = probePosition;
-            let _e371 = biased;
-            toProbe = (_e370 - _e371);
-            let _e373 = toProbe;
-            distance_4 = length(_e373);
-            let _e375 = distance_4;
-            if (_e375 > 0.000001f) {
-                let _e377 = toProbe;
-                let _e378 = distance_4;
-                direction_2 = (_e377 / vec3(_e378));
-                let _e381 = unit;
-                let _e382 = probePosition;
-                let _e383 = (*world_4);
-                facing = ((dot(_e381, normalize((_e382 - _e383))) * 0.5f) + 0.5f);
-                let _e389 = facing;
+            let _e352 = f_1;
+            let _e354 = f_1;
+            let _e355 = offset_3;
+            trilinear = mix((vec3<f32>(1f, 1f, 1f) - _e352), _e354, _e355);
+            let _e358 = trilinear[0u];
+            let _e360 = trilinear[1u];
+            let _e363 = trilinear[2u];
+            weight_3 = max(((_e358 * _e360) * _e363), 0.001f);
+            let _e366 = origin_2;
+            let _e367 = spacing;
+            let _e368 = cell_1;
+            probePosition = (_e366 + (_e367 * _e368));
+            let _e371 = probePosition;
+            let _e372 = biased;
+            toProbe = (_e371 - _e372);
+            let _e374 = toProbe;
+            distance_4 = length(_e374);
+            let _e376 = distance_4;
+            if (_e376 > 0.000001f) {
+                let _e378 = toProbe;
+                let _e379 = distance_4;
+                direction_2 = (_e378 / vec3(_e379));
+                let _e382 = unit;
+                let _e383 = probePosition;
+                let _e384 = (*world_4);
+                facing = ((dot(_e382, normalize((_e383 - _e384))) * 0.5f) + 0.5f);
                 let _e390 = facing;
-                probeWeight = ((_e389 * _e390) + 0.2f);
-                let _e393 = direction_2;
-                param_120 = -(_e393);
-                let _e395 = ProbeOctahedral_u0028_vf3_u003b((&param_120));
-                let _e396 = momentCorner;
-                param_121 = _e396;
-                let _e397 = depthTile;
-                param_122 = _e397;
-                param_123 = _e395;
-                let _e398 = TileBilinear_u0028_vf2_u003b_f1_u003b_vf2_u003b((&param_121), (&param_122), (&param_123));
-                moments_3 = _e398.xy;
+                let _e391 = facing;
+                probeWeight = ((_e390 * _e391) + 0.2f);
+                let _e394 = direction_2;
+                param_120 = -(_e394);
+                let _e396 = ProbeOctahedral_u0028_vf3_u003b((&param_120));
+                let _e397 = momentCorner;
+                param_121 = _e397;
+                let _e398 = depthTile;
+                param_122 = _e398;
+                param_123 = _e396;
+                let _e399 = TileBilinear_u0028_vf2_u003b_f1_u003b_vf2_u003b((&param_121), (&param_122), (&param_123));
+                moments_3 = _e399.xy;
                 chebyshev = 1f;
-                let _e400 = distance_4;
-                let _e402 = moments_3[0u];
-                if (_e400 > _e402) {
-                    let _e405 = moments_3[1u];
-                    let _e407 = moments_3[0u];
-                    let _e409 = moments_3[0u];
-                    variance_1 = max((_e405 - (_e407 * _e409)), 0.000001f);
-                    let _e413 = distance_4;
-                    let _e415 = moments_3[0u];
-                    difference = (_e413 - _e415);
-                    let _e417 = variance_1;
+                let _e401 = distance_4;
+                let _e403 = moments_3[0u];
+                if (_e401 > _e403) {
+                    let _e406 = moments_3[1u];
+                    let _e408 = moments_3[0u];
+                    let _e410 = moments_3[0u];
+                    variance_1 = max((_e406 - (_e408 * _e410)), 0.000001f);
+                    let _e414 = distance_4;
+                    let _e416 = moments_3[0u];
+                    difference = (_e414 - _e416);
                     let _e418 = variance_1;
-                    let _e419 = difference;
+                    let _e419 = variance_1;
                     let _e420 = difference;
-                    chebyshev = (_e417 / (_e418 + (_e419 * _e420)));
-                    let _e424 = chebyshev;
+                    let _e421 = difference;
+                    chebyshev = (_e418 / (_e419 + (_e420 * _e421)));
                     let _e425 = chebyshev;
-                    let _e427 = chebyshev;
-                    chebyshev = ((_e424 * _e425) * _e427);
+                    let _e426 = chebyshev;
+                    let _e428 = chebyshev;
+                    chebyshev = ((_e425 * _e426) * _e428);
                 }
-                let _e429 = probeWeight;
-                let _e430 = chebyshev;
-                probeWeight = max((_e429 * max(_e430, 0.05f)), 0.000001f);
-                let _e434 = probeWeight;
-                if (_e434 < 0.2f) {
-                    let _e436 = probeWeight;
+                let _e430 = probeWeight;
+                let _e431 = chebyshev;
+                probeWeight = max((_e430 * max(_e431, 0.05f)), 0.000001f);
+                let _e435 = probeWeight;
+                if (_e435 < 0.2f) {
                     let _e437 = probeWeight;
-                    let _e440 = probeWeight;
-                    probeWeight = (_e440 * ((_e436 * _e437) * 25f));
+                    let _e438 = probeWeight;
+                    let _e441 = probeWeight;
+                    probeWeight = (_e441 * ((_e437 * _e438) * 25f));
                 }
-                let _e442 = probeWeight;
-                let _e443 = weight_3;
-                weight_3 = (_e443 * _e442);
+                let _e443 = probeWeight;
+                let _e444 = weight_3;
+                weight_3 = (_e444 * _e443);
             }
-            let _e445 = unit;
-            param_124 = _e445;
-            let _e446 = ProbeOctahedral_u0028_vf3_u003b((&param_124));
-            let _e447 = irradianceCorner;
-            param_125 = _e447;
-            let _e448 = irradianceTile;
-            param_126 = _e448;
-            param_127 = _e446;
-            let _e449 = TileBilinear_u0028_vf2_u003b_f1_u003b_vf2_u003b((&param_125), (&param_126), (&param_127));
-            let _e451 = weight_3;
-            let _e453 = total_2;
-            total_2 = (_e453 + (_e449.xyz * _e451));
-            let _e455 = weight_3;
-            let _e456 = weights;
-            weights = (_e456 + _e455);
+            let _e446 = unit;
+            param_124 = _e446;
+            let _e447 = ProbeOctahedral_u0028_vf3_u003b((&param_124));
+            let _e448 = irradianceCorner;
+            param_125 = _e448;
+            let _e449 = irradianceTile;
+            param_126 = _e449;
+            param_127 = _e447;
+            let _e450 = TileBilinear_u0028_vf2_u003b_f1_u003b_vf2_u003b((&param_125), (&param_126), (&param_127));
+            let _e452 = weight_3;
+            let _e454 = total_2;
+            total_2 = (_e454 + (_e450.xyz * _e452));
+            let _e456 = weight_3;
+            let _e457 = weights;
+            weights = (_e457 + _e456);
             continue;
         } else {
             break;
         }
         continuing {
-            let _e458 = corner_1;
-            corner_1 = (_e458 + 1i);
+            let _e459 = corner_1;
+            corner_1 = (_e459 + 1i);
         }
     }
-    let _e460 = weights;
-    if (_e460 > 0f) {
-        let _e462 = total_2;
-        let _e463 = weights;
-        local_27 = (_e462 / vec3(_e463));
+    let _e461 = weights;
+    if (_e461 > 0f) {
+        let _e463 = total_2;
+        let _e464 = weights;
+        local_27 = (_e463 / vec3(_e464));
     } else {
         local_27 = vec3<f32>(0f, 0f, 0f);
     }
-    let _e466 = local_27;
-    return _e466;
+    let _e467 = local_27;
+    return _e467;
 }
 
 fn IrradianceEnabled_u0028_() -> bool {
-    let _e189 = irradiance_info.origin[3u];
-    return (_e189 > 0.5f);
+    let _e190 = irradiance_info.origin[3u];
+    return (_e190 > 0.5f);
 }
 
 fn ApplyCommonMaps_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_10: ptr<function, Surface>) {
@@ -12951,50 +13035,50 @@ fn ApplyCommonMaps_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d
     var param_132: Surface;
     var param_133: Surface;
 
-    let _e194 = IrradianceEnabled_u0028_();
-    if _e194 {
-        let _e195 = v_world_position_1;
-        param_128 = _e195;
-        let _e197 = (*s_10).n;
-        param_129 = _e197;
-        let _e199 = (*s_10).v;
-        param_130 = _e199;
-        let _e200 = SampleIrradiance_u0028_vf3_u003b_vf3_u003b_vf3_u003b((&param_128), (&param_129), (&param_130));
-        let _e203 = frag_info.material[2u];
-        (*s_10).ambient = (_e200 * _e203);
+    let _e195 = IrradianceEnabled_u0028_();
+    if _e195 {
+        let _e196 = v_world_position_1;
+        param_128 = _e196;
+        let _e198 = (*s_10).n;
+        param_129 = _e198;
+        let _e200 = (*s_10).v;
+        param_130 = _e200;
+        let _e201 = SampleIrradiance_u0028_vf3_u003b_vf3_u003b_vf3_u003b((&param_128), (&param_129), (&param_130));
+        let _e204 = frag_info.material[2u];
+        (*s_10).ambient = (_e201 * _e204);
     }
-    let _e206 = (*s_10);
-    param_131 = _e206;
+    let _e207 = (*s_10);
+    param_131 = _e207;
     ApplyNormalMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_131));
-    let _e207 = param_131;
-    (*s_10) = _e207;
-    let _e208 = (*s_10);
-    param_132 = _e208;
+    let _e208 = param_131;
+    (*s_10) = _e208;
+    let _e209 = (*s_10);
+    param_132 = _e209;
     ApplyOcclusionMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_132));
-    let _e209 = param_132;
-    (*s_10) = _e209;
-    let _e210 = (*s_10);
-    param_133 = _e210;
+    let _e210 = param_132;
+    (*s_10) = _e210;
+    let _e211 = (*s_10);
+    param_133 = _e211;
     ApplyEmissiveMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_133));
-    let _e211 = param_133;
-    (*s_10) = _e211;
+    let _e212 = param_133;
+    (*s_10) = _e212;
     return;
 }
 
 fn TowardsEye_u0028_() -> vec3<f32> {
     var local_28: vec3<f32>;
 
-    let _e188 = Orthographic_u0028_();
-    if _e188 {
-        let _e190 = fog_info.forward;
-        local_28 = -(_e190.xyz);
+    let _e189 = Orthographic_u0028_();
+    if _e189 {
+        let _e191 = fog_info.forward;
+        local_28 = -(_e191.xyz);
     } else {
-        let _e194 = fog_info.eye;
-        let _e196 = v_world_position_1;
-        local_28 = normalize((_e194.xyz - _e196));
+        let _e195 = fog_info.eye;
+        let _e197 = v_world_position_1;
+        local_28 = normalize((_e195.xyz - _e197));
     }
-    let _e199 = local_28;
-    return _e199;
+    let _e200 = local_28;
+    return _e200;
 }
 
 fn ReadSurface_u0028_() -> Surface {
@@ -13007,89 +13091,89 @@ fn ReadSurface_u0028_() -> Surface {
     var anchored: vec3<f32>;
     var noise_1: f32;
 
-    let _e195 = v_texcoord_1;
-    let _e196 = MaterialLodBias_u0028_();
-    let _e197 = textureSampleBias(base_color_texture_tex, base_color_texture_smp, _e195, _e196);
-    texel_6 = _e197;
-    let _e198 = texel_6;
-    param_134 = _e198.xyz;
-    let _e200 = SrgbToLinear_u0028_vf3_u003b((&param_134));
-    let _e202 = frag_info.base_color;
-    param_135 = _e202.xyz;
-    let _e204 = SrgbToLinear_u0028_vf3_u003b((&param_135));
-    let _e206 = v_color_1;
-    s_11.albedo = ((_e200 * _e204) * _e206.xyz);
-    let _e211 = texel_6[3u];
-    let _e214 = frag_info.base_color[3u];
-    let _e217 = v_color_1[3u];
-    s_11.alpha = ((_e211 * _e214) * _e217);
-    let _e221 = s_11.albedo;
-    g_albedo = _e221;
-    let _e224 = frag_info.material2_[0u];
-    cutoff = _e224;
-    let _e225 = cutoff;
-    if (_e225 > 1f) {
-        let _e227 = cutoff;
-        edge = (_e227 - 1f);
-        let _e230 = s_11.alpha;
-        let _e231 = edge;
-        let _e234 = s_11.alpha;
-        let _e235 = fwidth(_e234);
-        s_11.alpha = clamp((((_e230 - _e231) / max(_e235, 0.0001f)) + 0.5f), 0f, 1f);
+    let _e196 = v_texcoord_1;
+    let _e197 = MaterialLodBias_u0028_();
+    let _e198 = textureSampleBias(base_color_texture_tex, base_color_texture_smp, _e196, _e197);
+    texel_6 = _e198;
+    let _e199 = texel_6;
+    param_134 = _e199.xyz;
+    let _e201 = SrgbToLinear_u0028_vf3_u003b((&param_134));
+    let _e203 = frag_info.base_color;
+    param_135 = _e203.xyz;
+    let _e205 = SrgbToLinear_u0028_vf3_u003b((&param_135));
+    let _e207 = v_color_1;
+    s_11.albedo = ((_e201 * _e205) * _e207.xyz);
+    let _e212 = texel_6[3u];
+    let _e215 = frag_info.base_color[3u];
+    let _e218 = v_color_1[3u];
+    s_11.alpha = ((_e212 * _e215) * _e218);
+    let _e222 = s_11.albedo;
+    g_albedo = _e222;
+    let _e225 = frag_info.material2_[0u];
+    cutoff = _e225;
+    let _e226 = cutoff;
+    if (_e226 > 1f) {
+        let _e228 = cutoff;
+        edge = (_e228 - 1f);
+        let _e231 = s_11.alpha;
+        let _e232 = edge;
+        let _e235 = s_11.alpha;
+        let _e236 = fwidth(_e235);
+        s_11.alpha = clamp((((_e231 - _e232) / max(_e236, 0.0001f)) + 0.5f), 0f, 1f);
     } else {
-        let _e241 = cutoff;
-        if (_e241 >= 0f) {
-            let _e244 = s_11.alpha;
-            let _e245 = cutoff;
-            if (_e244 < _e245) {
+        let _e242 = cutoff;
+        if (_e242 >= 0f) {
+            let _e245 = s_11.alpha;
+            let _e246 = cutoff;
+            if (_e245 < _e246) {
                 discard;
             }
             s_11.alpha = 1f;
         } else {
-            let _e248 = cutoff;
-            if (_e248 < -1.5f) {
-                let _e250 = v_world_position_1;
-                anchored = floor((_e250 * 16f));
-                let _e253 = anchored;
-                noise_1 = fract((sin(dot(_e253, vec3<f32>(12.9898f, 78.233f, 37.719f))) * 43758.547f));
-                let _e259 = s_11.alpha;
-                let _e260 = noise_1;
-                if (_e259 < _e260) {
+            let _e249 = cutoff;
+            if (_e249 < -1.5f) {
+                let _e251 = v_world_position_1;
+                anchored = floor((_e251 * 16f));
+                let _e254 = anchored;
+                noise_1 = fract((sin(dot(_e254, vec3<f32>(12.9898f, 78.233f, 37.719f))) * 43758.547f));
+                let _e260 = s_11.alpha;
+                let _e261 = noise_1;
+                if (_e260 < _e261) {
                     discard;
                 }
             }
         }
     }
-    let _e262 = cutoff;
-    let _e264 = cutoff;
-    g_premultiply = ((_e262 < 0f) && (_e264 > -0.75f));
-    let _e267 = v_normal_1;
-    s_11.n = normalize(_e267);
-    let _e270 = gl_FrontFacing_1;
-    if !(_e270) {
-        let _e273 = s_11.n;
-        s_11.n = -(_e273);
+    let _e263 = cutoff;
+    let _e265 = cutoff;
+    g_premultiply = ((_e263 < 0f) && (_e265 > -0.75f));
+    let _e268 = v_normal_1;
+    s_11.n = normalize(_e268);
+    let _e271 = gl_FrontFacing_1;
+    if !(_e271) {
+        let _e274 = s_11.n;
+        s_11.n = -(_e274);
     }
-    let _e276 = TowardsEye_u0028_();
-    s_11.v = _e276;
-    let _e279 = s_11.n;
-    let _e281 = s_11.v;
-    s_11.n_dot_v = max(dot(_e279, _e281), 0.0001f);
-    let _e287 = frag_info.material[0u];
-    s_11.metallic = clamp(_e287, 0f, 1f);
-    let _e292 = frag_info.material[1u];
-    s_11.roughness = clamp(_e292, 0.02f, 1f);
-    let _e296 = frag_info.ambient_ground;
-    let _e299 = frag_info.ambient_sky;
-    let _e303 = s_11.n[1u];
-    let _e310 = frag_info.material[2u];
-    s_11.ambient = (mix(_e296.xyz, _e299.xyz, vec3(((_e303 * 0.5f) + 0.5f))) * _e310);
-    let _e315 = frag_info.frame_params[0u];
-    s_11.exposure = max(_e315, 0f);
+    let _e277 = TowardsEye_u0028_();
+    s_11.v = _e277;
+    let _e280 = s_11.n;
+    let _e282 = s_11.v;
+    s_11.n_dot_v = max(dot(_e280, _e282), 0.0001f);
+    let _e288 = frag_info.material[0u];
+    s_11.metallic = clamp(_e288, 0f, 1f);
+    let _e293 = frag_info.material[1u];
+    s_11.roughness = clamp(_e293, 0.02f, 1f);
+    let _e297 = frag_info.ambient_ground;
+    let _e300 = frag_info.ambient_sky;
+    let _e304 = s_11.n[1u];
+    let _e311 = frag_info.material[2u];
+    s_11.ambient = (mix(_e297.xyz, _e300.xyz, vec3(((_e304 * 0.5f) + 0.5f))) * _e311);
+    let _e316 = frag_info.frame_params[0u];
+    s_11.exposure = max(_e316, 0f);
     s_11.occlusion = 1f;
     s_11.emissive = vec3<f32>(0f, 0f, 0f);
-    let _e320 = s_11;
-    return _e320;
+    let _e321 = s_11;
+    return _e321;
 }
 
 fn main_1() {
@@ -13113,44 +13197,44 @@ fn main_1() {
     g_cluster_offset = 0f;
     g_cluster_count = 0f;
     light_transmittance = vec3<f32>(1f, 1f, 1f);
-    let _e198 = ReadSurface_u0028_();
-    s_12 = _e198;
-    let _e199 = s_12;
-    param_136 = _e199;
+    let _e199 = ReadSurface_u0028_();
+    s_12 = _e199;
+    let _e200 = s_12;
+    param_136 = _e200;
     ApplyCommonMaps_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_136));
-    let _e200 = param_136;
-    s_12 = _e200;
-    let _e201 = s_12;
-    param_137 = _e201;
+    let _e201 = param_136;
+    s_12 = _e201;
+    let _e202 = s_12;
+    param_137 = _e202;
     ApplyMetallicRoughnessMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_137));
-    let _e202 = param_137;
-    s_12 = _e202;
-    let _e204 = s_12.albedo;
-    let _e206 = s_12.ambient;
-    let _e207 = SampleLightmap_u0028_();
-    let _e211 = s_12.occlusion;
-    ambient = ((_e204 * (_e206 + _e207)) * _e211);
-    let _e213 = s_12;
-    param_138 = _e213;
-    let _e214 = AccumulateLights_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_138));
-    let _e216 = s_12.occlusion;
-    let _e218 = ambient;
-    let _e221 = s_12.emissive;
-    lit_3 = (((_e214 * _e216) + _e218) + _e221);
-    let _e223 = s_12;
-    param_139 = _e223;
-    let _e224 = lit_3;
-    param_140 = _e224;
-    let _e225 = WriteDebugView_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_vf3_u003b((&param_139), (&param_140));
-    if _e225 {
+    let _e203 = param_137;
+    s_12 = _e203;
+    let _e205 = s_12.albedo;
+    let _e207 = s_12.ambient;
+    let _e208 = SampleLightmap_u0028_();
+    let _e212 = s_12.occlusion;
+    ambient = ((_e205 * (_e207 + _e208)) * _e212);
+    let _e214 = s_12;
+    param_138 = _e214;
+    let _e215 = AccumulateLights_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_138));
+    let _e217 = s_12.occlusion;
+    let _e219 = ambient;
+    let _e222 = s_12.emissive;
+    lit_3 = (((_e215 * _e217) + _e219) + _e222);
+    let _e224 = s_12;
+    param_139 = _e224;
+    let _e225 = lit_3;
+    param_140 = _e225;
+    let _e226 = WriteDebugView_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_vf3_u003b((&param_139), (&param_140));
+    if _e226 {
         return;
     }
-    let _e226 = lit_3;
-    param_141 = _e226;
-    let _e228 = s_12.alpha;
-    param_142 = _e228;
-    let _e230 = s_12.roughness;
-    param_143 = _e230;
+    let _e227 = lit_3;
+    param_141 = _e227;
+    let _e229 = s_12.alpha;
+    param_142 = _e229;
+    let _e231 = s_12.roughness;
+    param_143 = _e231;
     WriteSurface_u0028_vf3_u003b_f1_u003b_f1_u003b((&param_141), (&param_142), (&param_143));
     return;
 }
@@ -13666,10 +13750,10 @@ var environment_texture_tex: texture_cube<f32>;
 var environment_texture_smp: sampler;
 
 fn ViewDepth_u0028_() -> f32 {
-    let _e206 = v_world_position_1;
-    let _e208 = fog_info.eye;
-    let _e212 = fog_info.forward;
-    return dot((_e206 - _e208.xyz), _e212.xyz);
+    let _e207 = v_world_position_1;
+    let _e209 = fog_info.eye;
+    let _e213 = fog_info.forward;
+    return dot((_e207 - _e209.xyz), _e213.xyz);
 }
 
 fn WeightedBlendedWeight_u0028_f1_u003b(alpha: ptr<function, f32>) -> f32 {
@@ -13678,22 +13762,22 @@ fn WeightedBlendedWeight_u0028_f1_u003b(alpha: ptr<function, f32>) -> f32 {
     var far: f32;
     var far3_: f32;
 
-    let _e211 = ViewDepth_u0028_();
-    z = abs(_e211);
-    let _e213 = z;
-    near = (_e213 / 5f);
-    let _e215 = z;
-    far = (_e215 / 200f);
-    let _e217 = far;
+    let _e212 = ViewDepth_u0028_();
+    z = abs(_e212);
+    let _e214 = z;
+    near = (_e214 / 5f);
+    let _e216 = z;
+    far = (_e216 / 200f);
     let _e218 = far;
-    let _e220 = far;
-    far3_ = ((_e217 * _e218) * _e220);
-    let _e222 = (*alpha);
-    let _e223 = near;
+    let _e219 = far;
+    let _e221 = far;
+    far3_ = ((_e218 * _e219) * _e221);
+    let _e223 = (*alpha);
     let _e224 = near;
-    let _e227 = far3_;
+    let _e225 = near;
     let _e228 = far3_;
-    return (_e222 * clamp((10f / ((0.00001f + (_e223 * _e224)) + (_e227 * _e228))), 0.01f, 3000f));
+    let _e229 = far3_;
+    return (_e223 * clamp((10f / ((0.00001f + (_e224 * _e225)) + (_e228 * _e229))), 0.01f, 3000f));
 }
 
 fn WriteWeightedBlended_u0028_() {
@@ -13705,39 +13789,39 @@ fn WriteWeightedBlended_u0028_() {
     var revealage: bool;
     var local: vec4<f32>;
 
-    let _e215 = fog_info.forward[3u];
-    mode = _e215;
-    let _e216 = mode;
-    if (_e216 > 0.5f) {
-        let _e219 = frag_color[3u];
-        alpha_1 = _e219;
-        let _e220 = alpha_1;
-        param = _e220;
-        let _e221 = WeightedBlendedWeight_u0028_f1_u003b((&param));
-        weight = _e221;
-        let _e222 = frag_color;
-        let _e224 = weight;
-        let _e225 = (_e222.xyz * _e224);
-        let _e226 = alpha_1;
-        let _e227 = weight;
-        accumulate = vec4<f32>(_e225.x, _e225.y, _e225.z, (_e226 * _e227));
-        let _e233 = mode;
-        let _e235 = mode;
-        revealage = ((_e233 > 1.5f) && (_e235 < 2.5f));
-        let _e238 = revealage;
-        if _e238 {
-            let _e239 = alpha_1;
-            local = vec4(_e239);
+    let _e216 = fog_info.forward[3u];
+    mode = _e216;
+    let _e217 = mode;
+    if (_e217 > 0.5f) {
+        let _e220 = frag_color[3u];
+        alpha_1 = _e220;
+        let _e221 = alpha_1;
+        param = _e221;
+        let _e222 = WeightedBlendedWeight_u0028_f1_u003b((&param));
+        weight = _e222;
+        let _e223 = frag_color;
+        let _e225 = weight;
+        let _e226 = (_e223.xyz * _e225);
+        let _e227 = alpha_1;
+        let _e228 = weight;
+        accumulate = vec4<f32>(_e226.x, _e226.y, _e226.z, (_e227 * _e228));
+        let _e234 = mode;
+        let _e236 = mode;
+        revealage = ((_e234 > 1.5f) && (_e236 < 2.5f));
+        let _e239 = revealage;
+        if _e239 {
+            let _e240 = alpha_1;
+            local = vec4(_e240);
         } else {
-            let _e241 = accumulate;
-            local = _e241;
+            let _e242 = accumulate;
+            local = _e242;
         }
-        let _e242 = local;
-        frag_color = _e242;
-        let _e243 = mode;
-        if (_e243 > 2.5f) {
-            let _e245 = alpha_1;
-            frag_surface = vec4(_e245);
+        let _e243 = local;
+        frag_color = _e243;
+        let _e244 = mode;
+        if (_e244 > 2.5f) {
+            let _e246 = alpha_1;
+            frag_surface = vec4(_e246);
         }
     }
     return;
@@ -13746,29 +13830,29 @@ fn WriteWeightedBlended_u0028_() {
 fn EncodeOctahedral_u0028_vf3_u003b(n: ptr<function, vec3<f32>>) -> vec2<f32> {
     var e: vec2<f32>;
 
-    let _e209 = (*n)[0u];
-    let _e212 = (*n)[1u];
-    let _e216 = (*n)[2u];
-    let _e219 = (*n);
-    (*n) = (_e219 / vec3(((abs(_e209) + abs(_e212)) + abs(_e216))));
-    let _e222 = (*n);
-    e = _e222.xy;
-    let _e225 = (*n)[2u];
-    if (_e225 < 0f) {
-        let _e227 = (*n);
-        let _e233 = (*n)[0u];
-        let _e237 = (*n)[1u];
-        e = ((vec2(1f) - abs(_e227.yx)) * vec2<f32>(select(-1f, 1f, (_e233 >= 0f)), select(-1f, 1f, (_e237 >= 0f))));
+    let _e210 = (*n)[0u];
+    let _e213 = (*n)[1u];
+    let _e217 = (*n)[2u];
+    let _e220 = (*n);
+    (*n) = (_e220 / vec3(((abs(_e210) + abs(_e213)) + abs(_e217))));
+    let _e223 = (*n);
+    e = _e223.xy;
+    let _e226 = (*n)[2u];
+    if (_e226 < 0f) {
+        let _e228 = (*n);
+        let _e234 = (*n)[0u];
+        let _e238 = (*n)[1u];
+        e = ((vec2(1f) - abs(_e228.yx)) * vec2<f32>(select(-1f, 1f, (_e234 >= 0f)), select(-1f, 1f, (_e238 >= 0f))));
     }
-    let _e242 = e;
-    return ((_e242 * 0.5f) + vec2(0.5f));
+    let _e243 = e;
+    return ((_e243 * 0.5f) + vec2(0.5f));
 }
 
 fn LinearToSrgb_u0028_vf3_u003b(linear: ptr<function, vec3<f32>>) -> vec3<f32> {
-    let _e207 = (*linear);
-    let _e209 = (*linear);
-    let _e213 = (*linear);
-    return mix((_e207 * 12.92f), ((pow(_e209, vec3<f32>(0.41666666f, 0.41666666f, 0.41666666f)) * 1.055f) - vec3<f32>(0.055f, 0.055f, 0.055f)), step(vec3<f32>(0.0031308f, 0.0031308f, 0.0031308f), _e213));
+    let _e208 = (*linear);
+    let _e210 = (*linear);
+    let _e214 = (*linear);
+    return mix((_e208 * 12.92f), ((pow(_e210, vec3<f32>(0.41666666f, 0.41666666f, 0.41666666f)) * 1.055f) - vec3<f32>(0.055f, 0.055f, 0.055f)), step(vec3<f32>(0.0031308f, 0.0031308f, 0.0031308f), _e214));
 }
 
 fn WriteSurfaceGeometry_u0028_f1_u003b(roughness: ptr<function, f32>) {
@@ -13776,52 +13860,52 @@ fn WriteSurfaceGeometry_u0028_f1_u003b(roughness: ptr<function, f32>) {
     var geometric: vec3<f32>;
     var param_2: vec3<f32>;
 
-    let _e210 = g_albedo;
-    param_1 = clamp(_e210, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
-    let _e212 = LinearToSrgb_u0028_vf3_u003b((&param_1));
-    frag_albedo = vec4<f32>(_e212.x, _e212.y, _e212.z, 1f);
-    let _e217 = g_debug_surface_on;
-    if _e217 {
-        let _e218 = g_debug_surface;
-        let _e219 = ViewDepth_u0028_();
-        frag_surface = vec4<f32>(_e218.x, _e218.y, _e218.z, _e219);
+    let _e211 = g_albedo;
+    param_1 = clamp(_e211, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
+    let _e213 = LinearToSrgb_u0028_vf3_u003b((&param_1));
+    frag_albedo = vec4<f32>(_e213.x, _e213.y, _e213.z, 1f);
+    let _e218 = g_debug_surface_on;
+    if _e218 {
+        let _e219 = g_debug_surface;
+        let _e220 = ViewDepth_u0028_();
+        frag_surface = vec4<f32>(_e219.x, _e219.y, _e219.z, _e220);
         return;
     }
-    let _e224 = v_normal_1;
-    geometric = normalize(_e224);
-    let _e226 = gl_FrontFacing_1;
-    if !(_e226) {
-        let _e228 = geometric;
-        geometric = -(_e228);
-    }
-    let _e230 = geometric;
-    param_2 = _e230;
-    let _e231 = EncodeOctahedral_u0028_vf3_u003b((&param_2));
-    let _e232 = (*roughness);
-    let _e234 = ViewDepth_u0028_();
-    frag_surface = vec4<f32>(_e231.x, _e231.y, clamp(_e232, 0f, 1f), _e234);
+    let _e225 = v_normal_1;
+    geometric = normalize(_e225);
+    let _e227 = gl_FrontFacing_1;
+    if !(_e227) {
+        let _e229 = geometric;
+        geometric = -(_e229);
+    }
+    let _e231 = geometric;
+    param_2 = _e231;
+    let _e232 = EncodeOctahedral_u0028_vf3_u003b((&param_2));
+    let _e233 = (*roughness);
+    let _e235 = ViewDepth_u0028_();
+    frag_surface = vec4<f32>(_e232.x, _e232.y, clamp(_e233, 0f, 1f), _e235);
     return;
 }
 
 fn Orthographic_u0028_() -> bool {
-    let _e208 = fog_info.projection[0u];
-    return (_e208 > 0.5f);
+    let _e209 = fog_info.projection[0u];
+    return (_e209 > 0.5f);
 }
 
 fn EyeDistance_u0028_() -> f32 {
     var local_1: f32;
 
-    let _e207 = Orthographic_u0028_();
-    if _e207 {
-        let _e208 = ViewDepth_u0028_();
-        local_1 = max(_e208, 0f);
+    let _e208 = Orthographic_u0028_();
+    if _e208 {
+        let _e209 = ViewDepth_u0028_();
+        local_1 = max(_e209, 0f);
     } else {
-        let _e210 = v_world_position_1;
-        let _e212 = fog_info.eye;
-        local_1 = distance(_e210, _e212.xyz);
+        let _e211 = v_world_position_1;
+        let _e213 = fog_info.eye;
+        local_1 = distance(_e211, _e213.xyz);
     }
-    let _e215 = local_1;
-    return _e215;
+    let _e216 = local_1;
+    return _e216;
 }
 
 fn ApplyFog_u0028_vf3_u003b(color: ptr<function, vec3<f32>>) -> vec3<f32> {
@@ -13831,41 +13915,41 @@ fn ApplyFog_u0028_vf3_u003b(color: ptr<function, vec3<f32>>) -> vec3<f32> {
     var k: f32;
     var local_2: f32;
 
-    let _e214 = fog_info.fog[3u];
-    density = _e214;
-    let _e215 = density;
-    if (_e215 <= 0f) {
-        let _e217 = (*color);
-        return _e217;
-    }
-    let _e218 = EyeDistance_u0028_();
-    d = _e218;
-    let _e221 = fog_info.eye[3u];
-    falloff = _e221;
-    let _e222 = falloff;
-    if (_e222 > 0f) {
-        let _e224 = falloff;
-        let _e226 = v_world_position_1[1u];
-        let _e229 = fog_info.eye[1u];
-        k = (_e224 * (_e226 - _e229));
-        let _e232 = k;
-        if (abs(_e232) > 0.001f) {
-            let _e235 = k;
-            let _e239 = k;
-            local_2 = ((1f - exp(-(_e235))) / _e239);
+    let _e215 = fog_info.fog[3u];
+    density = _e215;
+    let _e216 = density;
+    if (_e216 <= 0f) {
+        let _e218 = (*color);
+        return _e218;
+    }
+    let _e219 = EyeDistance_u0028_();
+    d = _e219;
+    let _e222 = fog_info.eye[3u];
+    falloff = _e222;
+    let _e223 = falloff;
+    if (_e223 > 0f) {
+        let _e225 = falloff;
+        let _e227 = v_world_position_1[1u];
+        let _e230 = fog_info.eye[1u];
+        k = (_e225 * (_e227 - _e230));
+        let _e233 = k;
+        if (abs(_e233) > 0.001f) {
+            let _e236 = k;
+            let _e240 = k;
+            local_2 = ((1f - exp(-(_e236))) / _e240);
         } else {
-            let _e241 = k;
-            local_2 = (1f - (0.5f * _e241));
+            let _e242 = k;
+            local_2 = (1f - (0.5f * _e242));
         }
-        let _e244 = local_2;
-        let _e245 = density;
-        density = (_e245 * _e244);
+        let _e245 = local_2;
+        let _e246 = density;
+        density = (_e246 * _e245);
     }
-    let _e248 = fog_info.fog;
-    let _e250 = (*color);
-    let _e251 = density;
-    let _e253 = d;
-    return mix(_e248.xyz, _e250, vec3(clamp(exp((-(_e251) * _e253)), 0f, 1f)));
+    let _e249 = fog_info.fog;
+    let _e251 = (*color);
+    let _e252 = density;
+    let _e254 = d;
+    return mix(_e249.xyz, _e251, vec3(clamp(exp((-(_e252) * _e254)), 0f, 1f)));
 }
 
 fn WriteSurface_u0028_vf3_u003b_f1_u003b_f1_u003b(linearColor: ptr<function, vec3<f32>>, alpha_2: ptr<function, f32>, roughness_1: ptr<function, f32>) {
@@ -13873,44 +13957,44 @@ fn WriteSurface_u0028_vf3_u003b_f1_u003b_f1_u003b(linearColor: ptr<function, vec
     var param_3: vec3<f32>;
     var param_4: f32;
 
-    let _e212 = g_premultiply;
-    let _e213 = (*alpha_2);
-    weight_1 = select(1f, _e213, _e212);
-    let _e215 = (*linearColor);
-    param_3 = _e215;
-    let _e216 = ApplyFog_u0028_vf3_u003b((&param_3));
-    let _e217 = weight_1;
-    let _e218 = (_e216 * _e217);
-    let _e219 = (*alpha_2);
-    let _e220 = g_pass_through;
-    frag_color = vec4<f32>(_e218.x, _e218.y, _e218.z, (_e219 * (1f - _e220)));
-    let _e227 = (*roughness_1);
-    param_4 = _e227;
+    let _e213 = g_premultiply;
+    let _e214 = (*alpha_2);
+    weight_1 = select(1f, _e214, _e213);
+    let _e216 = (*linearColor);
+    param_3 = _e216;
+    let _e217 = ApplyFog_u0028_vf3_u003b((&param_3));
+    let _e218 = weight_1;
+    let _e219 = (_e217 * _e218);
+    let _e220 = (*alpha_2);
+    let _e221 = g_pass_through;
+    frag_color = vec4<f32>(_e219.x, _e219.y, _e219.z, (_e220 * (1f - _e221)));
+    let _e228 = (*roughness_1);
+    param_4 = _e228;
     WriteSurfaceGeometry_u0028_f1_u003b((&param_4));
     WriteWeightedBlended_u0028_();
     return;
 }
 
 fn SrgbToLinear_u0028_vf3_u003b(srgb: ptr<function, vec3<f32>>) -> vec3<f32> {
-    let _e207 = (*srgb);
-    let _e210 = (*srgb);
-    let _e215 = (*srgb);
-    return mix((_e207 / vec3(12.92f)), pow(((_e210 + vec3<f32>(0.055f, 0.055f, 0.055f)) / vec3(1.055f)), vec3<f32>(2.4f, 2.4f, 2.4f)), step(vec3<f32>(0.04045f, 0.04045f, 0.04045f), _e215));
+    let _e208 = (*srgb);
+    let _e211 = (*srgb);
+    let _e216 = (*srgb);
+    return mix((_e208 / vec3(12.92f)), pow(((_e211 + vec3<f32>(0.055f, 0.055f, 0.055f)) / vec3(1.055f)), vec3<f32>(2.4f, 2.4f, 2.4f)), step(vec3<f32>(0.04045f, 0.04045f, 0.04045f), _e216));
 }
 
 fn NonFinite_u0028_vf3_u003b(c: ptr<function, vec3<f32>>) -> bool {
     var phi_2901_: bool;
 
-    let _e207 = (*c);
     let _e208 = (*c);
-    let _e210 = any((_e207 != _e208));
-    phi_2901_ = _e210;
-    if !(_e210) {
-        let _e212 = (*c);
-        phi_2901_ = any((abs(_e212) > vec3<f32>(300000000000000000000000000000000000000f, 300000000000000000000000000000000000000f, 300000000000000000000000000000000000000f)));
-    }
-    let _e217 = phi_2901_;
-    return _e217;
+    let _e209 = (*c);
+    let _e211 = any((_e208 != _e209));
+    phi_2901_ = _e211;
+    if !(_e211) {
+        let _e213 = (*c);
+        phi_2901_ = any((abs(_e213) > vec3<f32>(300000000000000000000000000000000000000f, 300000000000000000000000000000000000000f, 300000000000000000000000000000000000000f)));
+    }
+    let _e218 = phi_2901_;
+    return _e218;
 }
 
 fn WriteDebugView_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_vf3_u003b(s: ptr<function, Surface>, lit: ptr<function, vec3<f32>>) -> bool {
@@ -13928,78 +14012,78 @@ fn WriteDebugView_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_
     var param_9: vec3<f32>;
     var param_10: f32;
 
-    let _e223 = frag_info.debug_view[0u];
-    view = _e223;
-    let _e224 = view;
-    if (_e224 < 0.5f) {
+    let _e224 = frag_info.debug_view[0u];
+    view = _e224;
+    let _e225 = view;
+    if (_e225 < 0.5f) {
         return false;
     }
-    let _e227 = gl_FragCoord_1[0u];
-    let _e230 = frag_info.debug_view[1u];
-    let _e233 = frag_info.debug_view[2u];
-    if (_e227 < (_e230 * _e233)) {
+    let _e228 = gl_FragCoord_1[0u];
+    let _e231 = frag_info.debug_view[1u];
+    let _e234 = frag_info.debug_view[2u];
+    if (_e228 < (_e231 * _e234)) {
         return false;
     }
-    let _e236 = view;
-    code = i32((_e236 + 0.5f));
+    let _e237 = view;
+    code = i32((_e237 + 0.5f));
     shown = vec3<f32>(0f, 0f, 0f);
-    let _e239 = code;
-    if (_e239 == 1i) {
-        let _e242 = (*s).albedo;
-        param_5 = clamp(_e242, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
-        let _e244 = LinearToSrgb_u0028_vf3_u003b((&param_5));
-        shown = _e244;
-    } else {
-        let _e245 = code;
-        if (_e245 == 2i) {
-            let _e248 = (*s).n;
-            shown = ((_e248 * 0.5f) + vec3<f32>(0.5f, 0.5f, 0.5f));
+    let _e240 = code;
+    if (_e240 == 1i) {
+        let _e243 = (*s).albedo;
+        param_5 = clamp(_e243, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
+        let _e245 = LinearToSrgb_u0028_vf3_u003b((&param_5));
+        shown = _e245;
+    } else {
+        let _e246 = code;
+        if (_e246 == 2i) {
+            let _e249 = (*s).n;
+            shown = ((_e249 * 0.5f) + vec3<f32>(0.5f, 0.5f, 0.5f));
         } else {
-            let _e251 = code;
-            if (_e251 == 3i) {
-                let _e254 = (*s).roughness;
-                shown = vec3(clamp(_e254, 0f, 1f));
+            let _e252 = code;
+            if (_e252 == 3i) {
+                let _e255 = (*s).roughness;
+                shown = vec3(clamp(_e255, 0f, 1f));
             } else {
-                let _e257 = code;
-                if (_e257 == 4i) {
-                    let _e260 = (*s).metallic;
-                    shown = vec3(clamp(_e260, 0f, 1f));
+                let _e258 = code;
+                if (_e258 == 4i) {
+                    let _e261 = (*s).metallic;
+                    shown = vec3(clamp(_e261, 0f, 1f));
                 } else {
-                    let _e263 = code;
-                    if (_e263 == 5i) {
-                        let _e266 = (*s).occlusion;
-                        shown = vec3(clamp(_e266, 0f, 1f));
+                    let _e264 = code;
+                    if (_e264 == 5i) {
+                        let _e267 = (*s).occlusion;
+                        shown = vec3(clamp(_e267, 0f, 1f));
                     } else {
-                        let _e269 = code;
-                        if (_e269 == 6i) {
-                            let _e272 = (*s).emissive;
-                            param_6 = clamp(_e272, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
-                            let _e274 = LinearToSrgb_u0028_vf3_u003b((&param_6));
-                            shown = _e274;
+                        let _e270 = code;
+                        if (_e270 == 6i) {
+                            let _e273 = (*s).emissive;
+                            param_6 = clamp(_e273, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
+                            let _e275 = LinearToSrgb_u0028_vf3_u003b((&param_6));
+                            shown = _e275;
                         } else {
-                            let _e275 = code;
-                            if (_e275 == 7i) {
-                                let _e277 = v_texcoord_1;
-                                let _e278 = fract(_e277);
-                                shown = vec3<f32>(_e278.x, _e278.y, 0f);
+                            let _e276 = code;
+                            if (_e276 == 7i) {
+                                let _e278 = v_texcoord_1;
+                                let _e279 = fract(_e278);
+                                shown = vec3<f32>(_e279.x, _e279.y, 0f);
                             } else {
-                                let _e282 = code;
-                                if (_e282 == 8i) {
-                                    let _e284 = (*lit);
-                                    param_7 = clamp(_e284, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
-                                    let _e286 = LinearToSrgb_u0028_vf3_u003b((&param_7));
-                                    grey = dot(_e286, vec3<f32>(0.2126f, 0.7152f, 0.0722f));
-                                    let _e288 = (*lit);
-                                    param_8 = _e288;
-                                    let _e289 = NonFinite_u0028_vf3_u003b((&param_8));
-                                    if _e289 {
+                                let _e283 = code;
+                                if (_e283 == 8i) {
+                                    let _e285 = (*lit);
+                                    param_7 = clamp(_e285, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
+                                    let _e287 = LinearToSrgb_u0028_vf3_u003b((&param_7));
+                                    grey = dot(_e287, vec3<f32>(0.2126f, 0.7152f, 0.0722f));
+                                    let _e289 = (*lit);
+                                    param_8 = _e289;
+                                    let _e290 = NonFinite_u0028_vf3_u003b((&param_8));
+                                    if _e290 {
                                         local_3 = vec3<f32>(1f, 0f, 1f);
                                     } else {
-                                        let _e290 = grey;
-                                        local_3 = vec3((_e290 * 0.5f));
+                                        let _e291 = grey;
+                                        local_3 = vec3((_e291 * 0.5f));
                                     }
-                                    let _e293 = local_3;
-                                    shown = _e293;
+                                    let _e294 = local_3;
+                                    shown = _e294;
                                 }
                             }
                         }
@@ -14008,24 +14092,24 @@ fn WriteDebugView_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_
             }
         }
     }
-    let _e294 = g_premultiply;
-    if _e294 {
-        let _e296 = (*s).alpha;
-        local_4 = _e296;
+    let _e295 = g_premultiply;
+    if _e295 {
+        let _e297 = (*s).alpha;
+        local_4 = _e297;
     } else {
         local_4 = 1f;
     }
-    let _e297 = local_4;
-    weight_2 = _e297;
-    let _e298 = shown;
-    param_9 = _e298;
-    let _e299 = SrgbToLinear_u0028_vf3_u003b((&param_9));
-    let _e300 = weight_2;
-    let _e301 = (_e299 * _e300);
-    let _e303 = (*s).alpha;
-    frag_color = vec4<f32>(_e301.x, _e301.y, _e301.z, _e303);
-    let _e309 = (*s).roughness;
-    param_10 = _e309;
+    let _e298 = local_4;
+    weight_2 = _e298;
+    let _e299 = shown;
+    param_9 = _e299;
+    let _e300 = SrgbToLinear_u0028_vf3_u003b((&param_9));
+    let _e301 = weight_2;
+    let _e302 = (_e300 * _e301);
+    let _e304 = (*s).alpha;
+    frag_color = vec4<f32>(_e302.x, _e302.y, _e302.z, _e304);
+    let _e310 = (*s).roughness;
+    param_10 = _e310;
     WriteSurfaceGeometry_u0028_f1_u003b((&param_10));
     WriteWeightedBlended_u0028_();
     return true;
@@ -14035,32 +14119,32 @@ fn FonAlbedo_u0028_f1_u003b_f1_u003b(mu: ptr<function, f32>, r: ptr<function, f3
     var m: f32;
     var g: f32;
 
-    let _e210 = (*mu);
-    m = (1f - _e210);
-    let _e212 = m;
+    let _e211 = (*mu);
+    m = (1f - _e211);
     let _e213 = m;
     let _e214 = m;
     let _e215 = m;
-    g = (_e212 * (0.05710853f + (_e213 * (0.49188188f + (_e214 * (-0.33218145f + (_e215 * 0.071443f)))))));
-    let _e223 = (*r);
-    let _e224 = g;
-    let _e227 = (*r);
-    return ((1f + (_e223 * _e224)) / (1f + (0.2877934f * _e227)));
+    let _e216 = m;
+    g = (_e213 * (0.05710853f + (_e214 * (0.49188188f + (_e215 * (-0.33218145f + (_e216 * 0.071443f)))))));
+    let _e224 = (*r);
+    let _e225 = g;
+    let _e228 = (*r);
+    return ((1f + (_e224 * _e225)) / (1f + (0.2877934f * _e228)));
 }
 
 fn EonMultiAlbedo_u0028_vf3_u003b_f1_u003b(rho: ptr<function, vec3<f32>>, average: ptr<function, f32>) -> vec3<f32> {
-    let _e208 = (*rho);
     let _e209 = (*rho);
-    let _e211 = (*average);
-    let _e213 = (*rho);
-    let _e214 = (*average);
-    return (((_e208 * _e209) * _e211) / (vec3<f32>(1f, 1f, 1f) - (_e213 * (1f - _e214))));
+    let _e210 = (*rho);
+    let _e212 = (*average);
+    let _e214 = (*rho);
+    let _e215 = (*average);
+    return (((_e209 * _e210) * _e212) / (vec3<f32>(1f, 1f, 1f) - (_e214 * (1f - _e215))));
 }
 
 fn FonAverage_u0028_f1_u003b(r_1: ptr<function, f32>) -> f32 {
-    let _e207 = (*r_1);
-    let _e210 = (*r_1);
-    return ((1f + (0.07248821f * _e207)) / (1f + (0.2877934f * _e210)));
+    let _e208 = (*r_1);
+    let _e211 = (*r_1);
+    return ((1f + (0.07248821f * _e208)) / (1f + (0.2877934f * _e211)));
 }
 
 fn EonLobe_u0028_vf3_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b(rho_1: ptr<function, vec3<f32>>, r_2: ptr<function, f32>, mu_i: ptr<function, f32>, mu_o: ptr<function, f32>, l_dot_v: ptr<function, f32>) -> vec3<f32> {
@@ -14079,70 +14163,70 @@ fn EonLobe_u0028_vf3_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b(rho_1: ptr<functi
     var param_16: f32;
     var param_17: f32;
 
-    let _e225 = (*l_dot_v);
-    let _e226 = (*mu_i);
-    let _e227 = (*mu_o);
-    s_1 = (_e225 - (_e226 * _e227));
-    let _e230 = s_1;
-    if (_e230 > 0f) {
-        let _e232 = s_1;
-        let _e233 = (*mu_i);
-        let _e234 = (*mu_o);
-        local_5 = (_e232 / max(_e233, _e234));
-    } else {
-        let _e237 = s_1;
-        local_5 = _e237;
-    }
-    let _e238 = local_5;
-    s_over_t = _e238;
-    let _e239 = (*r_2);
-    af = (1f / (1f + (0.2877934f * _e239)));
-    let _e243 = (*rho_1);
-    let _e244 = af;
-    let _e245 = (*r_2);
-    let _e246 = s_over_t;
-    single = (_e243 * (_e244 * (1f + (_e245 * _e246))));
-    let _e251 = (*r_2);
-    param_11 = _e251;
-    let _e252 = FonAverage_u0028_f1_u003b((&param_11));
-    average_1 = _e252;
-    let _e253 = (*rho_1);
-    param_12 = _e253;
-    let _e254 = average_1;
-    param_13 = _e254;
-    let _e255 = EonMultiAlbedo_u0028_vf3_u003b_f1_u003b((&param_12), (&param_13));
-    let _e256 = (*mu_o);
-    param_14 = _e256;
-    let _e257 = (*r_2);
-    param_15 = _e257;
-    let _e258 = FonAlbedo_u0028_f1_u003b_f1_u003b((&param_14), (&param_15));
-    let _e261 = (*mu_i);
-    param_16 = _e261;
-    let _e262 = (*r_2);
-    param_17 = _e262;
-    let _e263 = FonAlbedo_u0028_f1_u003b_f1_u003b((&param_16), (&param_17));
-    let _e267 = average_1;
-    multi = (_e255 * ((max((1f - _e258), 0.0000001f) * max((1f - _e263), 0.0000001f)) / max((1f - _e267), 0.0000001f)));
-    let _e272 = single;
-    let _e273 = multi;
-    return ((_e272 + _e273) / vec3(3.1415927f));
+    let _e226 = (*l_dot_v);
+    let _e227 = (*mu_i);
+    let _e228 = (*mu_o);
+    s_1 = (_e226 - (_e227 * _e228));
+    let _e231 = s_1;
+    if (_e231 > 0f) {
+        let _e233 = s_1;
+        let _e234 = (*mu_i);
+        let _e235 = (*mu_o);
+        local_5 = (_e233 / max(_e234, _e235));
+    } else {
+        let _e238 = s_1;
+        local_5 = _e238;
+    }
+    let _e239 = local_5;
+    s_over_t = _e239;
+    let _e240 = (*r_2);
+    af = (1f / (1f + (0.2877934f * _e240)));
+    let _e244 = (*rho_1);
+    let _e245 = af;
+    let _e246 = (*r_2);
+    let _e247 = s_over_t;
+    single = (_e244 * (_e245 * (1f + (_e246 * _e247))));
+    let _e252 = (*r_2);
+    param_11 = _e252;
+    let _e253 = FonAverage_u0028_f1_u003b((&param_11));
+    average_1 = _e253;
+    let _e254 = (*rho_1);
+    param_12 = _e254;
+    let _e255 = average_1;
+    param_13 = _e255;
+    let _e256 = EonMultiAlbedo_u0028_vf3_u003b_f1_u003b((&param_12), (&param_13));
+    let _e257 = (*mu_o);
+    param_14 = _e257;
+    let _e258 = (*r_2);
+    param_15 = _e258;
+    let _e259 = FonAlbedo_u0028_f1_u003b_f1_u003b((&param_14), (&param_15));
+    let _e262 = (*mu_i);
+    param_16 = _e262;
+    let _e263 = (*r_2);
+    param_17 = _e263;
+    let _e264 = FonAlbedo_u0028_f1_u003b_f1_u003b((&param_16), (&param_17));
+    let _e268 = average_1;
+    multi = (_e256 * ((max((1f - _e259), 0.0000001f) * max((1f - _e264), 0.0000001f)) / max((1f - _e268), 0.0000001f)));
+    let _e273 = single;
+    let _e274 = multi;
+    return ((_e273 + _e274) / vec3(3.1415927f));
 }
 
 fn EonDiffuse_u0028_() -> bool {
-    let _e208 = frag_info.ambient_sky[3u];
-    return (_e208 > 0.5f);
+    let _e209 = frag_info.ambient_sky[3u];
+    return (_e209 > 0.5f);
 }
 
 fn LtcUv_u0028_f1_u003b_f1_u003b_f1_u003b(x: ptr<function, f32>, y: ptr<function, f32>, table: ptr<function, f32>) -> vec2<f32> {
     var inTable: vec2<f32>;
 
-    let _e210 = (*x);
-    let _e211 = (*y);
-    inTable = ((vec2<f32>(_e210, _e211) * 0.984375f) + vec2(0.0078125f));
-    let _e217 = inTable[0u];
-    let _e219 = inTable[1u];
-    let _e220 = (*table);
-    return vec2<f32>(_e217, ((_e219 + _e220) * 0.5f));
+    let _e211 = (*x);
+    let _e212 = (*y);
+    inTable = ((vec2<f32>(_e211, _e212) * 0.984375f) + vec2(0.0078125f));
+    let _e218 = inTable[0u];
+    let _e220 = inTable[1u];
+    let _e221 = (*table);
+    return vec2<f32>(_e218, ((_e220 + _e221) * 0.5f));
 }
 
 fn EnvBrdf_u0028_f1_u003b_f1_u003b(roughness_2: ptr<function, f32>, n_dot_v: ptr<function, f32>) -> vec2<f32> {
@@ -14151,18 +14235,18 @@ fn EnvBrdf_u0028_f1_u003b_f1_u003b(roughness_2: ptr<function, f32>, n_dot_v: ptr
     var param_19: f32;
     var param_20: f32;
 
-    let _e212 = (*roughness_2);
-    let _e214 = (*n_dot_v);
-    param_18 = clamp(_e212, 0f, 1f);
-    param_19 = sqrt(clamp((1f - _e214), 0f, 1f));
+    let _e213 = (*roughness_2);
+    let _e215 = (*n_dot_v);
+    param_18 = clamp(_e213, 0f, 1f);
+    param_19 = sqrt(clamp((1f - _e215), 0f, 1f));
     param_20 = 1f;
-    let _e218 = LtcUv_u0028_f1_u003b_f1_u003b_f1_u003b((&param_18), (&param_19), (&param_20));
-    let _e219 = textureSampleLevel(ltc_texture_tex, ltc_texture_smp, _e218, 0f);
-    dfg = _e219.xy;
-    let _e222 = dfg[0u];
-    let _e224 = dfg[1u];
-    let _e227 = dfg[1u];
-    return vec2<f32>((_e222 - _e224), _e227);
+    let _e219 = LtcUv_u0028_f1_u003b_f1_u003b_f1_u003b((&param_18), (&param_19), (&param_20));
+    let _e220 = textureSampleLevel(ltc_texture_tex, ltc_texture_smp, _e219, 0f);
+    dfg = _e220.xy;
+    let _e223 = dfg[0u];
+    let _e225 = dfg[1u];
+    let _e228 = dfg[1u];
+    return vec2<f32>((_e223 - _e225), _e228);
 }
 
 fn MultiscatterScale_u0028_vf3_u003b_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(f0_: ptr<function, vec3<f32>>, s_2: ptr<function, Surface>) -> vec3<f32> {
@@ -14171,34 +14255,34 @@ fn MultiscatterScale_u0028_vf3_u003b_struct_u002d_Surface_u002d_vf3_u002d_f1_u00
     var param_22: f32;
     var ess: f32;
 
-    let _e213 = (*s_2).roughness;
-    param_21 = max(_e213, 0.045f);
-    let _e216 = (*s_2).n_dot_v;
-    param_22 = _e216;
-    let _e217 = EnvBrdf_u0028_f1_u003b_f1_u003b((&param_21), (&param_22));
-    ab = _e217;
-    let _e219 = ab[0u];
-    let _e221 = ab[1u];
-    ess = max((_e219 + _e221), 0.0001f);
-    let _e224 = (*f0_);
-    let _e225 = ess;
-    return (vec3<f32>(1f, 1f, 1f) + (_e224 * ((1f / _e225) - 1f)));
+    let _e214 = (*s_2).roughness;
+    param_21 = max(_e214, 0.045f);
+    let _e217 = (*s_2).n_dot_v;
+    param_22 = _e217;
+    let _e218 = EnvBrdf_u0028_f1_u003b_f1_u003b((&param_21), (&param_22));
+    ab = _e218;
+    let _e220 = ab[0u];
+    let _e222 = ab[1u];
+    ess = max((_e220 + _e222), 0.0001f);
+    let _e225 = (*f0_);
+    let _e226 = ess;
+    return (vec3<f32>(1f, 1f, 1f) + (_e225 * ((1f / _e226) - 1f)));
 }
 
 fn EnergyCompensation_u0028_() -> bool {
-    let _e208 = frag_info.target_origin[2u];
-    return (_e208 > 0.5f);
+    let _e209 = frag_info.target_origin[2u];
+    return (_e209 > 0.5f);
 }
 
 fn F_Schlick_u0028_vf3_u003b_f1_u003b(f0_1: ptr<function, vec3<f32>>, v_dot_h: ptr<function, f32>) -> vec3<f32> {
     var f: f32;
 
-    let _e209 = (*v_dot_h);
-    f = pow((1f - _e209), 5f);
-    let _e212 = (*f0_1);
+    let _e210 = (*v_dot_h);
+    f = pow((1f - _e210), 5f);
     let _e213 = (*f0_1);
-    let _e215 = f;
-    return (_e212 + ((vec3<f32>(1f, 1f, 1f) - _e213) * _e215));
+    let _e214 = (*f0_1);
+    let _e216 = f;
+    return (_e213 + ((vec3<f32>(1f, 1f, 1f) - _e214) * _e216));
 }
 
 fn V_SmithGGXCorrelated_u0028_f1_u003b_f1_u003b_f1_u003b(n_dot_v_1: ptr<function, f32>, n_dot_l: ptr<function, f32>, alpha_3: ptr<function, f32>) -> f32 {
@@ -14206,42 +14290,42 @@ fn V_SmithGGXCorrelated_u0028_f1_u003b_f1_u003b_f1_u003b(n_dot_v_1: ptr<function
     var lambda_v: f32;
     var lambda_l: f32;
 
-    let _e212 = (*alpha_3);
     let _e213 = (*alpha_3);
-    a2_ = (_e212 * _e213);
-    let _e215 = (*n_dot_l);
-    let _e216 = (*n_dot_v_1);
+    let _e214 = (*alpha_3);
+    a2_ = (_e213 * _e214);
+    let _e216 = (*n_dot_l);
     let _e217 = (*n_dot_v_1);
-    let _e219 = a2_;
-    let _e222 = a2_;
-    lambda_v = (_e215 * sqrt((((_e216 * _e217) * (1f - _e219)) + _e222)));
-    let _e226 = (*n_dot_v_1);
-    let _e227 = (*n_dot_l);
+    let _e218 = (*n_dot_v_1);
+    let _e220 = a2_;
+    let _e223 = a2_;
+    lambda_v = (_e216 * sqrt((((_e217 * _e218) * (1f - _e220)) + _e223)));
+    let _e227 = (*n_dot_v_1);
     let _e228 = (*n_dot_l);
-    let _e230 = a2_;
-    let _e233 = a2_;
-    lambda_l = (_e226 * sqrt((((_e227 * _e228) * (1f - _e230)) + _e233)));
-    let _e237 = lambda_v;
-    let _e238 = lambda_l;
-    return (0.5f / max((_e237 + _e238), 0.00001f));
+    let _e229 = (*n_dot_l);
+    let _e231 = a2_;
+    let _e234 = a2_;
+    lambda_l = (_e227 * sqrt((((_e228 * _e229) * (1f - _e231)) + _e234)));
+    let _e238 = lambda_v;
+    let _e239 = lambda_l;
+    return (0.5f / max((_e238 + _e239), 0.00001f));
 }
 
 fn D_GGX_u0028_f1_u003b_f1_u003b(n_dot_h: ptr<function, f32>, alpha_4: ptr<function, f32>) -> f32 {
     var a: f32;
     var k_1: f32;
 
-    let _e210 = (*n_dot_h);
-    let _e211 = (*alpha_4);
-    a = (_e210 * _e211);
-    let _e213 = (*alpha_4);
-    let _e214 = (*n_dot_h);
+    let _e211 = (*n_dot_h);
+    let _e212 = (*alpha_4);
+    a = (_e211 * _e212);
+    let _e214 = (*alpha_4);
     let _e215 = (*n_dot_h);
-    let _e218 = a;
+    let _e216 = (*n_dot_h);
     let _e219 = a;
-    k_1 = (_e213 / max(((1f - (_e214 * _e215)) + (_e218 * _e219)), 0.0000001f));
-    let _e224 = k_1;
+    let _e220 = a;
+    k_1 = (_e214 / max(((1f - (_e215 * _e216)) + (_e219 * _e220)), 0.0000001f));
     let _e225 = k_1;
-    return ((_e224 * _e225) * 0.31830987f);
+    let _e226 = k_1;
+    return ((_e225 * _e226) * 0.31830987f);
 }
 
 fn ShadeLight_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b(s_3: ptr<function, Surface>, light: ptr<function, LightSample>) -> vec3<f32> {
@@ -14269,116 +14353,116 @@ fn ShadeLight_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_
     var param_35: f32;
     var param_36: f32;
 
-    let _e232 = (*s_3).roughness;
-    lobe = max(_e232, 0.045f);
-    let _e234 = lobe;
+    let _e233 = (*s_3).roughness;
+    lobe = max(_e233, 0.045f);
     let _e235 = lobe;
-    alpha_5 = (_e234 * _e235);
-    let _e238 = (*s_3).albedo;
-    let _e240 = (*s_3).metallic;
-    f0_2 = mix(vec3<f32>(0.04f, 0.04f, 0.04f), _e238, vec3(_e240));
-    let _e244 = (*s_3).albedo;
-    let _e246 = (*s_3).metallic;
-    diffuseColor = (_e244 * (1f - _e246));
-    let _e250 = (*light).n_dot_h;
-    param_23 = _e250;
-    let _e251 = alpha_5;
-    param_24 = _e251;
-    let _e252 = D_GGX_u0028_f1_u003b_f1_u003b((&param_23), (&param_24));
-    d_1 = _e252;
-    let _e254 = (*s_3).n_dot_v;
-    param_25 = _e254;
-    let _e256 = (*light).n_dot_l;
-    param_26 = _e256;
-    let _e257 = alpha_5;
-    param_27 = _e257;
-    let _e258 = V_SmithGGXCorrelated_u0028_f1_u003b_f1_u003b_f1_u003b((&param_25), (&param_26), (&param_27));
-    vis = _e258;
-    let _e259 = f0_2;
-    param_28 = _e259;
-    let _e261 = (*light).v_dot_h;
-    param_29 = _e261;
-    let _e262 = F_Schlick_u0028_vf3_u003b_f1_u003b((&param_28), (&param_29));
-    f_1 = _e262;
-    let _e263 = d_1;
-    let _e264 = vis;
-    let _e266 = f_1;
-    let _e270 = frag_info.material[3u];
-    specular = ((_e266 * (_e263 * _e264)) * _e270);
-    let _e273 = (*light).integrated;
-    if (_e273 > 0.5f) {
-        let _e277 = (*light).ltc[0u];
-        let _e278 = f0_2;
-        let _e281 = (*light).ltc[1u];
-        let _e283 = f0_2;
-        let _e288 = (*light).ltc[2u];
-        let _e294 = frag_info.material[3u];
-        let _e297 = (*light).n_dot_l;
-        specular = (((((_e278 * _e281) + ((vec3(1f) - _e283) * _e288)) * _e277) * _e294) / vec3(max(_e297, 0.000001f)));
-    }
-    let _e301 = EnergyCompensation_u0028_();
-    if _e301 {
-        let _e302 = f0_2;
-        param_30 = _e302;
-        let _e303 = (*s_3);
-        param_31 = _e303;
-        let _e304 = MultiscatterScale_u0028_vf3_u003b_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_30), (&param_31));
-        let _e305 = specular;
-        specular = (_e305 * _e304);
-    }
-    let _e307 = diffuseColor;
-    let _e308 = f_1;
-    diffuse = ((_e307 * (vec3<f32>(1f, 1f, 1f) - _e308)) / vec3(3.1415927f));
-    let _e313 = EonDiffuse_u0028_();
-    if _e313 {
-        let _e315 = (*s_3).n;
-        let _e317 = (*light).l;
-        let _e321 = (*light).l;
-        let _e323 = (*s_3).v;
-        let _e325 = diffuseColor;
-        param_32 = _e325;
-        let _e327 = (*s_3).roughness;
-        param_33 = _e327;
-        param_34 = clamp(dot(_e315, _e317), 0.0001f, 1f);
-        let _e329 = (*s_3).n_dot_v;
-        param_35 = _e329;
-        param_36 = dot(_e321, _e323);
-        let _e330 = EonLobe_u0028_vf3_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b((&param_32), (&param_33), (&param_34), (&param_35), (&param_36));
-        let _e331 = f_1;
-        diffuse = (_e330 * (vec3<f32>(1f, 1f, 1f) - _e331));
-    }
-    let _e334 = diffuse;
-    let _e335 = specular;
-    return ((_e334 + _e335) * 3.1415927f);
+    let _e236 = lobe;
+    alpha_5 = (_e235 * _e236);
+    let _e239 = (*s_3).albedo;
+    let _e241 = (*s_3).metallic;
+    f0_2 = mix(vec3<f32>(0.04f, 0.04f, 0.04f), _e239, vec3(_e241));
+    let _e245 = (*s_3).albedo;
+    let _e247 = (*s_3).metallic;
+    diffuseColor = (_e245 * (1f - _e247));
+    let _e251 = (*light).n_dot_h;
+    param_23 = _e251;
+    let _e252 = alpha_5;
+    param_24 = _e252;
+    let _e253 = D_GGX_u0028_f1_u003b_f1_u003b((&param_23), (&param_24));
+    d_1 = _e253;
+    let _e255 = (*s_3).n_dot_v;
+    param_25 = _e255;
+    let _e257 = (*light).n_dot_l;
+    param_26 = _e257;
+    let _e258 = alpha_5;
+    param_27 = _e258;
+    let _e259 = V_SmithGGXCorrelated_u0028_f1_u003b_f1_u003b_f1_u003b((&param_25), (&param_26), (&param_27));
+    vis = _e259;
+    let _e260 = f0_2;
+    param_28 = _e260;
+    let _e262 = (*light).v_dot_h;
+    param_29 = _e262;
+    let _e263 = F_Schlick_u0028_vf3_u003b_f1_u003b((&param_28), (&param_29));
+    f_1 = _e263;
+    let _e264 = d_1;
+    let _e265 = vis;
+    let _e267 = f_1;
+    let _e271 = frag_info.material[3u];
+    specular = ((_e267 * (_e264 * _e265)) * _e271);
+    let _e274 = (*light).integrated;
+    if (_e274 > 0.5f) {
+        let _e278 = (*light).ltc[0u];
+        let _e279 = f0_2;
+        let _e282 = (*light).ltc[1u];
+        let _e284 = f0_2;
+        let _e289 = (*light).ltc[2u];
+        let _e295 = frag_info.material[3u];
+        let _e298 = (*light).n_dot_l;
+        specular = (((((_e279 * _e282) + ((vec3(1f) - _e284) * _e289)) * _e278) * _e295) / vec3(max(_e298, 0.000001f)));
+    }
+    let _e302 = EnergyCompensation_u0028_();
+    if _e302 {
+        let _e303 = f0_2;
+        param_30 = _e303;
+        let _e304 = (*s_3);
+        param_31 = _e304;
+        let _e305 = MultiscatterScale_u0028_vf3_u003b_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_30), (&param_31));
+        let _e306 = specular;
+        specular = (_e306 * _e305);
+    }
+    let _e308 = diffuseColor;
+    let _e309 = f_1;
+    diffuse = ((_e308 * (vec3<f32>(1f, 1f, 1f) - _e309)) / vec3(3.1415927f));
+    let _e314 = EonDiffuse_u0028_();
+    if _e314 {
+        let _e316 = (*s_3).n;
+        let _e318 = (*light).l;
+        let _e322 = (*light).l;
+        let _e324 = (*s_3).v;
+        let _e326 = diffuseColor;
+        param_32 = _e326;
+        let _e328 = (*s_3).roughness;
+        param_33 = _e328;
+        param_34 = clamp(dot(_e316, _e318), 0.0001f, 1f);
+        let _e330 = (*s_3).n_dot_v;
+        param_35 = _e330;
+        param_36 = dot(_e322, _e324);
+        let _e331 = EonLobe_u0028_vf3_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b((&param_32), (&param_33), (&param_34), (&param_35), (&param_36));
+        let _e332 = f_1;
+        diffuse = (_e331 * (vec3<f32>(1f, 1f, 1f) - _e332));
+    }
+    let _e335 = diffuse;
+    let _e336 = specular;
+    return ((_e335 + _e336) * 3.1415927f);
 }
 
 fn PointShadowDiskTap_u0028_i1_u003b(i: ptr<function, i32>) -> vec2<f32> {
-    let _e207 = (*i);
-    if (_e207 == 0i) {
+    let _e208 = (*i);
+    if (_e208 == 0i) {
         return vec2<f32>(-0.94201624f, -0.39906216f);
     }
-    let _e209 = (*i);
-    if (_e209 == 1i) {
+    let _e210 = (*i);
+    if (_e210 == 1i) {
         return vec2<f32>(0.9455861f, -0.76890725f);
     }
-    let _e211 = (*i);
-    if (_e211 == 2i) {
+    let _e212 = (*i);
+    if (_e212 == 2i) {
         return vec2<f32>(-0.0941841f, -0.9293887f);
     }
-    let _e213 = (*i);
-    if (_e213 == 3i) {
+    let _e214 = (*i);
+    if (_e214 == 3i) {
         return vec2<f32>(0.34495938f, 0.2938776f);
     }
-    let _e215 = (*i);
-    if (_e215 == 4i) {
+    let _e216 = (*i);
+    if (_e216 == 4i) {
         return vec2<f32>(-0.9158858f, 0.45771432f);
     }
-    let _e217 = (*i);
-    if (_e217 == 5i) {
+    let _e218 = (*i);
+    if (_e218 == 5i) {
         return vec2<f32>(-0.8154423f, -0.87912464f);
     }
-    let _e219 = (*i);
-    if (_e219 == 6i) {
+    let _e220 = (*i);
+    if (_e220 == 6i) {
         return vec2<f32>(-0.38277543f, 0.27676845f);
     }
     return vec2<f32>(0.974844f, 0.7564838f);
@@ -14388,20 +14472,20 @@ fn PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b(i_1: ptr<function
     var p: vec2<f32>;
     var param_37: i32;
 
-    let _e212 = (*i_1);
-    param_37 = _e212;
-    let _e213 = PointShadowDiskTap_u0028_i1_u003b((&param_37));
-    p = _e213;
-    let _e215 = p[0u];
-    let _e216 = (*ca);
-    let _e219 = p[1u];
-    let _e220 = (*sa);
-    let _e224 = p[0u];
-    let _e225 = (*sa);
-    let _e228 = p[1u];
-    let _e229 = (*ca);
-    let _e233 = (*radius);
-    return (vec2<f32>(((_e215 * _e216) - (_e219 * _e220)), ((_e224 * _e225) + (_e228 * _e229))) * _e233);
+    let _e213 = (*i_1);
+    param_37 = _e213;
+    let _e214 = PointShadowDiskTap_u0028_i1_u003b((&param_37));
+    p = _e214;
+    let _e216 = p[0u];
+    let _e217 = (*ca);
+    let _e220 = p[1u];
+    let _e221 = (*sa);
+    let _e225 = p[0u];
+    let _e226 = (*sa);
+    let _e229 = p[1u];
+    let _e230 = (*ca);
+    let _e234 = (*radius);
+    return (vec2<f32>(((_e216 * _e217) - (_e220 * _e221)), ((_e225 * _e226) + (_e229 * _e230))) * _e234);
 }
 
 fn PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b(uv: ptr<function, vec2<f32>>, offset: ptr<function, vec2<f32>>, tile: ptr<function, vec2<f32>>, range: ptr<function, f32>) -> f32 {
@@ -14409,27 +14493,27 @@ fn PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b(uv: ptr<func
     var local_6: vec2<f32>;
     var atlas: vec2<f32>;
 
-    let _e215 = point_shadow.params[0u];
-    inset = _e215;
-    let _e216 = (*uv);
-    let _e217 = (*offset);
-    let _e219 = inset;
+    let _e216 = point_shadow.params[0u];
+    inset = _e216;
+    let _e217 = (*uv);
+    let _e218 = (*offset);
     let _e220 = inset;
-    local_6 = clamp((_e216 + _e217), vec2(_e219), vec2((1f - _e220)));
-    let _e225 = local_6;
-    let _e226 = (*tile);
-    atlas = ((_e225 + _e226) * vec2<f32>(0.16666667f, 0.16666667f));
-    let _e231 = point_shadow.params3_[0u];
-    if (_e231 > 0.5f) {
-        let _e234 = atlas[1u];
-        atlas[1u] = (1f - _e234);
-    }
-    let _e237 = atlas;
-    let _e238 = textureSampleLevel(point_shadow_texture_tex, point_shadow_texture_smp, _e237, 0f);
-    let _e240 = atlas;
-    let _e241 = textureSampleLevel(point_shadow_static_texture_tex, point_shadow_static_texture_smp, _e240, 0f);
-    let _e244 = (*range);
-    return (min(_e238.x, _e241.x) * _e244);
+    let _e221 = inset;
+    local_6 = clamp((_e217 + _e218), vec2(_e220), vec2((1f - _e221)));
+    let _e226 = local_6;
+    let _e227 = (*tile);
+    atlas = ((_e226 + _e227) * vec2<f32>(0.16666667f, 0.16666667f));
+    let _e232 = point_shadow.params3_[0u];
+    if (_e232 > 0.5f) {
+        let _e235 = atlas[1u];
+        atlas[1u] = (1f - _e235);
+    }
+    let _e238 = atlas;
+    let _e239 = textureSampleLevel(point_shadow_texture_tex, point_shadow_texture_smp, _e238, 0f);
+    let _e241 = atlas;
+    let _e242 = textureSampleLevel(point_shadow_static_texture_tex, point_shadow_static_texture_smp, _e241, 0f);
+    let _e245 = (*range);
+    return (min(_e239.x, _e242.x) * _e245);
 }
 
 fn PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b(uv_1: ptr<function, vec2<f32>>, offset_1: ptr<function, vec2<f32>>, tile_1: ptr<function, vec2<f32>>, range_1: ptr<function, f32>, receiver: ptr<function, f32>) -> f32 {
@@ -14439,24 +14523,24 @@ fn PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b(uv_1: pt
     var param_40: vec2<f32>;
     var param_41: f32;
 
-    let _e216 = (*uv_1);
-    param_38 = _e216;
-    let _e217 = (*offset_1);
-    param_39 = _e217;
-    let _e218 = (*tile_1);
-    param_40 = _e218;
-    let _e219 = (*range_1);
-    param_41 = _e219;
-    let _e220 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((&param_38), (&param_39), (&param_40), (&param_41));
-    stored = _e220;
-    let _e221 = stored;
-    let _e222 = (*range_1);
-    if (_e221 >= (_e222 * 0.999f)) {
+    let _e217 = (*uv_1);
+    param_38 = _e217;
+    let _e218 = (*offset_1);
+    param_39 = _e218;
+    let _e219 = (*tile_1);
+    param_40 = _e219;
+    let _e220 = (*range_1);
+    param_41 = _e220;
+    let _e221 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((&param_38), (&param_39), (&param_40), (&param_41));
+    stored = _e221;
+    let _e222 = stored;
+    let _e223 = (*range_1);
+    if (_e222 >= (_e223 * 0.999f)) {
         return 1f;
     }
-    let _e225 = (*receiver);
-    let _e226 = stored;
-    return select(1f, 0f, (_e225 > _e226));
+    let _e226 = (*receiver);
+    let _e227 = stored;
+    return select(1f, 0f, (_e226 > _e227));
 }
 
 fn PointShadowPenumbra_u0028_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b(uv_2: ptr<function, vec2<f32>>, tile_2: ptr<function, vec2<f32>>, range_2: ptr<function, f32>, receiver_1: ptr<function, f32>, ca_1: ptr<function, f32>, sa_1: ptr<function, f32>, tanHalf: ptr<function, f32>, blockerOut: ptr<function, f32>) -> f32 {
@@ -14483,111 +14567,111 @@ fn PointShadowPenumbra_u0028_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u
     var world: f32;
 
     (*blockerOut) = -1f;
-    let _e237 = point_shadow.params2_[1u];
-    lightRadius = _e237;
-    let _e240 = point_shadow.params2_[0u];
-    minRadius = _e240;
-    let _e243 = point_shadow.params2_[2u];
-    maxRadius = _e243;
-    let _e244 = lightRadius;
-    if (_e244 <= 0f) {
-        let _e246 = (*uv_2);
-        param_42 = _e246;
+    let _e238 = point_shadow.params2_[1u];
+    lightRadius = _e238;
+    let _e241 = point_shadow.params2_[0u];
+    minRadius = _e241;
+    let _e244 = point_shadow.params2_[2u];
+    maxRadius = _e244;
+    let _e245 = lightRadius;
+    if (_e245 <= 0f) {
+        let _e247 = (*uv_2);
+        param_42 = _e247;
         param_43 = vec2<f32>(0f, 0f);
-        let _e247 = (*tile_2);
-        param_44 = _e247;
-        let _e248 = (*range_2);
-        param_45 = _e248;
-        let _e249 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((&param_42), (&param_43), (&param_44), (&param_45));
-        (*blockerOut) = _e249;
-        let _e250 = minRadius;
-        return _e250;
+        let _e248 = (*tile_2);
+        param_44 = _e248;
+        let _e249 = (*range_2);
+        param_45 = _e249;
+        let _e250 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((&param_42), (&param_43), (&param_44), (&param_45));
+        (*blockerOut) = _e250;
+        let _e251 = minRadius;
+        return _e251;
     }
     sum = 0f;
     count = 0f;
     i_2 = 0i;
     loop {
-        let _e251 = i_2;
-        if (_e251 < 8i) {
-            let _e253 = i_2;
-            param_46 = _e253;
-            let _e254 = (*ca_1);
-            param_47 = _e254;
-            let _e255 = (*sa_1);
-            param_48 = _e255;
-            let _e256 = maxRadius;
-            param_49 = _e256;
-            let _e257 = PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b((&param_46), (&param_47), (&param_48), (&param_49));
-            let _e258 = (*uv_2);
-            param_50 = _e258;
-            param_51 = _e257;
-            let _e259 = (*tile_2);
-            param_52 = _e259;
-            let _e260 = (*range_2);
-            param_53 = _e260;
-            let _e261 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((&param_50), (&param_51), (&param_52), (&param_53));
-            stored_1 = _e261;
-            let _e262 = stored_1;
-            let _e263 = (*range_2);
-            if (_e262 >= (_e263 * 0.999f)) {
+        let _e252 = i_2;
+        if (_e252 < 8i) {
+            let _e254 = i_2;
+            param_46 = _e254;
+            let _e255 = (*ca_1);
+            param_47 = _e255;
+            let _e256 = (*sa_1);
+            param_48 = _e256;
+            let _e257 = maxRadius;
+            param_49 = _e257;
+            let _e258 = PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b((&param_46), (&param_47), (&param_48), (&param_49));
+            let _e259 = (*uv_2);
+            param_50 = _e259;
+            param_51 = _e258;
+            let _e260 = (*tile_2);
+            param_52 = _e260;
+            let _e261 = (*range_2);
+            param_53 = _e261;
+            let _e262 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((&param_50), (&param_51), (&param_52), (&param_53));
+            stored_1 = _e262;
+            let _e263 = stored_1;
+            let _e264 = (*range_2);
+            if (_e263 >= (_e264 * 0.999f)) {
                 continue;
             }
-            let _e266 = stored_1;
-            let _e267 = (*receiver_1);
-            if (_e266 >= _e267) {
+            let _e267 = stored_1;
+            let _e268 = (*receiver_1);
+            if (_e267 >= _e268) {
                 continue;
             }
-            let _e269 = stored_1;
-            let _e270 = sum;
-            sum = (_e270 + _e269);
-            let _e272 = count;
-            count = (_e272 + 1f);
+            let _e270 = stored_1;
+            let _e271 = sum;
+            sum = (_e271 + _e270);
+            let _e273 = count;
+            count = (_e273 + 1f);
             continue;
         } else {
             break;
         }
         continuing {
-            let _e274 = i_2;
-            i_2 = (_e274 + 1i);
+            let _e275 = i_2;
+            i_2 = (_e275 + 1i);
         }
     }
-    let _e276 = count;
-    if (_e276 < 0.5f) {
+    let _e277 = count;
+    if (_e277 < 0.5f) {
         return -1f;
     }
-    let _e278 = sum;
-    let _e279 = count;
-    blocker = max((_e278 / _e279), 0.0001f);
-    let _e282 = blocker;
-    (*blockerOut) = _e282;
-    let _e283 = lightRadius;
-    let _e284 = (*receiver_1);
-    let _e285 = blocker;
-    let _e289 = blocker;
-    world = ((_e283 * max((_e284 - _e285), 0f)) / _e289);
-    let _e291 = world;
-    let _e292 = (*receiver_1);
-    let _e294 = (*tanHalf);
-    let _e297 = minRadius;
-    let _e298 = maxRadius;
-    return clamp((_e291 / ((2f * _e292) * _e294)), _e297, _e298);
+    let _e279 = sum;
+    let _e280 = count;
+    blocker = max((_e279 / _e280), 0.0001f);
+    let _e283 = blocker;
+    (*blockerOut) = _e283;
+    let _e284 = lightRadius;
+    let _e285 = (*receiver_1);
+    let _e286 = blocker;
+    let _e290 = blocker;
+    world = ((_e284 * max((_e285 - _e286), 0f)) / _e290);
+    let _e292 = world;
+    let _e293 = (*receiver_1);
+    let _e295 = (*tanHalf);
+    let _e298 = minRadius;
+    let _e299 = maxRadius;
+    return clamp((_e292 / ((2f * _e293) * _e295)), _e298, _e299);
 }
 
 fn FragCoordFromTop_u0028_f1_u003b(rows: ptr<function, f32>) -> vec2<f32> {
     var local_7: vec2<f32>;
 
-    let _e208 = (*rows);
-    if (_e208 > 0f) {
-        let _e211 = gl_FragCoord_1[0u];
-        let _e212 = (*rows);
-        let _e214 = gl_FragCoord_1[1u];
-        local_7 = vec2<f32>(_e211, (_e212 - _e214));
+    let _e209 = (*rows);
+    if (_e209 > 0f) {
+        let _e212 = gl_FragCoord_1[0u];
+        let _e213 = (*rows);
+        let _e215 = gl_FragCoord_1[1u];
+        local_7 = vec2<f32>(_e212, (_e213 - _e215));
     } else {
-        let _e217 = gl_FragCoord_1;
-        local_7 = _e217.xy;
+        let _e218 = gl_FragCoord_1;
+        local_7 = _e218.xy;
     }
-    let _e219 = local_7;
-    return _e219;
+    let _e220 = local_7;
+    return _e220;
 }
 
 fn PointShadowFactor_u0028_vf3_u003b_vf3_u003b_i1_u003b(world_1: ptr<function, vec3<f32>>, normal: ptr<function, vec3<f32>>, lightIndex: ptr<function, i32>) -> f32 {
@@ -14645,257 +14729,257 @@ fn PointShadowFactor_u0028_vf3_u003b_vf3_u003b_i1_u003b(world_1: ptr<function, v
     var phi_2590_: bool;
     var phi_2651_: bool;
 
-    let _e260 = (*lightIndex);
-    let _e264 = point_shadow.slots[_e260][0u];
-    slot = i32((_e264 + 0.5f));
-    let _e267 = (*lightIndex);
-    let _e271 = point_shadow.slots[_e267][0u];
-    if (_e271 < 0f) {
+    let _e261 = (*lightIndex);
+    let _e265 = point_shadow.slots[_e261][0u];
+    slot = i32((_e265 + 0.5f));
+    let _e268 = (*lightIndex);
+    let _e272 = point_shadow.slots[_e268][0u];
+    if (_e272 < 0f) {
         return 1f;
     }
-    let _e275 = point_shadow.params[2u];
-    strength = _e275;
-    let _e276 = strength;
-    if (_e276 <= 0f) {
+    let _e276 = point_shadow.params[2u];
+    strength = _e276;
+    let _e277 = strength;
+    if (_e277 <= 0f) {
         return 1f;
     }
-    let _e278 = slot;
-    let _e281 = point_shadow.lights[_e278];
-    let _e283 = (*world_1);
-    toLight = (_e281.xyz - _e283);
-    let _e285 = toLight;
-    toLightLength = max(length(_e285), 0.000001f);
-    let _e288 = (*normal);
-    let _e289 = toLight;
-    let _e290 = toLightLength;
-    nDotL = max(dot(_e288, (_e289 / vec3(_e290))), 0.15f);
-    let _e295 = nDotL;
+    let _e279 = slot;
+    let _e282 = point_shadow.lights[_e279];
+    let _e284 = (*world_1);
+    toLight = (_e282.xyz - _e284);
+    let _e286 = toLight;
+    toLightLength = max(length(_e286), 0.000001f);
+    let _e289 = (*normal);
+    let _e290 = toLight;
+    let _e291 = toLightLength;
+    nDotL = max(dot(_e289, (_e290 / vec3(_e291))), 0.15f);
     let _e296 = nDotL;
-    let _e301 = nDotL;
+    let _e297 = nDotL;
     let _e302 = nDotL;
-    slope = min((sqrt(max((1f - (_e295 * _e296)), 0f)) / (_e301 * _e302)), 8f);
-    let _e306 = toLightLength;
-    let _e308 = (*lightIndex);
-    let _e312 = point_shadow.slots[_e308][2u];
-    let _e317 = point_shadow.params3_[1u];
-    texel = (((2f * _e306) * max(_e312, 0.0001f)) * _e317);
-    let _e319 = (*world_1);
-    let _e320 = (*normal);
-    let _e321 = texel;
-    let _e325 = point_shadow.params[3u];
-    let _e327 = slope;
-    origin = (_e319 + (((_e320 * _e321) * _e325) * (1f + _e327)));
-    let _e331 = origin;
-    let _e332 = slot;
-    let _e335 = point_shadow.lights[_e332];
-    toFragment = (_e331 - _e335.xyz);
-    let _e338 = toFragment;
-    distance_ = length(_e338);
-    let _e340 = slot;
-    let _e344 = point_shadow.lights[_e340][3u];
-    range_3 = max(_e344, 0.0001f);
-    let _e346 = distance_;
-    let _e347 = range_3;
-    if (_e346 >= _e347) {
+    let _e303 = nDotL;
+    slope = min((sqrt(max((1f - (_e296 * _e297)), 0f)) / (_e302 * _e303)), 8f);
+    let _e307 = toLightLength;
+    let _e309 = (*lightIndex);
+    let _e313 = point_shadow.slots[_e309][2u];
+    let _e318 = point_shadow.params3_[1u];
+    texel = (((2f * _e307) * max(_e313, 0.0001f)) * _e318);
+    let _e320 = (*world_1);
+    let _e321 = (*normal);
+    let _e322 = texel;
+    let _e326 = point_shadow.params[3u];
+    let _e328 = slope;
+    origin = (_e320 + (((_e321 * _e322) * _e326) * (1f + _e328)));
+    let _e332 = origin;
+    let _e333 = slot;
+    let _e336 = point_shadow.lights[_e333];
+    toFragment = (_e332 - _e336.xyz);
+    let _e339 = toFragment;
+    distance_ = length(_e339);
+    let _e341 = slot;
+    let _e345 = point_shadow.lights[_e341][3u];
+    range_3 = max(_e345, 0.0001f);
+    let _e347 = distance_;
+    let _e348 = range_3;
+    if (_e347 >= _e348) {
         return 1f;
     }
     face = 0i;
-    let _e349 = (*lightIndex);
-    let _e353 = point_shadow.slots[_e349][1u];
-    if (_e353 < 0.5f) {
-        let _e355 = toFragment;
-        a_1 = abs(_e355);
-        let _e358 = a_1[0u];
-        let _e360 = a_1[1u];
-        let _e361 = (_e358 >= _e360);
-        phi_2590_ = _e361;
-        if _e361 {
-            let _e363 = a_1[0u];
-            let _e365 = a_1[2u];
-            phi_2590_ = (_e363 >= _e365);
-        }
-        let _e368 = phi_2590_;
-        if _e368 {
-            let _e370 = toFragment[0u];
-            face = select(1i, 0i, (_e370 > 0f));
+    let _e350 = (*lightIndex);
+    let _e354 = point_shadow.slots[_e350][1u];
+    if (_e354 < 0.5f) {
+        let _e356 = toFragment;
+        a_1 = abs(_e356);
+        let _e359 = a_1[0u];
+        let _e361 = a_1[1u];
+        let _e362 = (_e359 >= _e361);
+        phi_2590_ = _e362;
+        if _e362 {
+            let _e364 = a_1[0u];
+            let _e366 = a_1[2u];
+            phi_2590_ = (_e364 >= _e366);
+        }
+        let _e369 = phi_2590_;
+        if _e369 {
+            let _e371 = toFragment[0u];
+            face = select(1i, 0i, (_e371 > 0f));
         } else {
-            let _e374 = a_1[1u];
-            let _e376 = a_1[2u];
-            if (_e374 >= _e376) {
-                let _e379 = toFragment[1u];
-                face = select(3i, 2i, (_e379 > 0f));
+            let _e375 = a_1[1u];
+            let _e377 = a_1[2u];
+            if (_e375 >= _e377) {
+                let _e380 = toFragment[1u];
+                face = select(3i, 2i, (_e380 > 0f));
             } else {
-                let _e383 = toFragment[2u];
-                face = select(5i, 4i, (_e383 > 0f));
+                let _e384 = toFragment[2u];
+                face = select(5i, 4i, (_e384 > 0f));
             }
         }
     }
-    let _e386 = slot;
-    let _e388 = face;
-    let _e392 = point_shadow.faces[((_e386 * 6i) + _e388)];
-    let _e393 = origin;
-    clip = (_e392 * vec4<f32>(_e393.x, _e393.y, _e393.z, 1f));
-    let _e400 = clip[3u];
-    if (_e400 <= 0f) {
+    let _e387 = slot;
+    let _e389 = face;
+    let _e393 = point_shadow.faces[((_e387 * 6i) + _e389)];
+    let _e394 = origin;
+    clip = (_e393 * vec4<f32>(_e394.x, _e394.y, _e394.z, 1f));
+    let _e401 = clip[3u];
+    if (_e401 <= 0f) {
         return 1f;
     }
-    let _e402 = clip;
-    let _e405 = clip[3u];
-    ndc = (_e402.xy / vec2(_e405));
-    let _e409 = ndc[0u];
-    let _e411 = (abs(_e409) > 1f);
-    phi_2651_ = _e411;
-    if !(_e411) {
-        let _e414 = ndc[1u];
-        phi_2651_ = (abs(_e414) > 1f);
-    }
-    let _e418 = phi_2651_;
-    if _e418 {
+    let _e403 = clip;
+    let _e406 = clip[3u];
+    ndc = (_e403.xy / vec2(_e406));
+    let _e410 = ndc[0u];
+    let _e412 = (abs(_e410) > 1f);
+    phi_2651_ = _e412;
+    if !(_e412) {
+        let _e415 = ndc[1u];
+        phi_2651_ = (abs(_e415) > 1f);
+    }
+    let _e419 = phi_2651_;
+    if _e419 {
         return 1f;
     }
-    let _e420 = ndc[0u];
-    let _e424 = ndc[1u];
-    uv_3 = vec2<f32>(((_e420 * 0.5f) + 0.5f), (0.5f - (_e424 * 0.5f)));
-    let _e428 = face;
-    let _e430 = slot;
-    tile_3 = vec2<f32>(f32(_e428), f32(_e430));
-    let _e433 = distance_;
-    let _e436 = point_shadow.params[1u];
-    receiver_2 = (_e433 - _e436);
-    let _e440 = frag_info.target_origin[0u];
-    param_54 = _e440;
-    let _e441 = FragCoordFromTop_u0028_f1_u003b((&param_54));
-    noise = fract((52.982918f * fract(dot(_e441, vec2<f32>(0.06711056f, 0.00583715f)))));
-    let _e446 = noise;
-    angle = (_e446 * 6.2831855f);
-    let _e448 = angle;
-    ca_2 = cos(_e448);
-    let _e450 = angle;
-    sa_2 = sin(_e450);
-    let _e452 = (*lightIndex);
-    let _e456 = point_shadow.slots[_e452][2u];
-    tanHalf_1 = max(_e456, 0.0001f);
+    let _e421 = ndc[0u];
+    let _e425 = ndc[1u];
+    uv_3 = vec2<f32>(((_e421 * 0.5f) + 0.5f), (0.5f - (_e425 * 0.5f)));
+    let _e429 = face;
+    let _e431 = slot;
+    tile_3 = vec2<f32>(f32(_e429), f32(_e431));
+    let _e434 = distance_;
+    let _e437 = point_shadow.params[1u];
+    receiver_2 = (_e434 - _e437);
+    let _e441 = frag_info.target_origin[0u];
+    param_54 = _e441;
+    let _e442 = FragCoordFromTop_u0028_f1_u003b((&param_54));
+    noise = fract((52.982918f * fract(dot(_e442, vec2<f32>(0.06711056f, 0.00583715f)))));
+    let _e447 = noise;
+    angle = (_e447 * 6.2831855f);
+    let _e449 = angle;
+    ca_2 = cos(_e449);
+    let _e451 = angle;
+    sa_2 = sin(_e451);
+    let _e453 = (*lightIndex);
+    let _e457 = point_shadow.slots[_e453][2u];
+    tanHalf_1 = max(_e457, 0.0001f);
     blocker_1 = -1f;
-    let _e458 = uv_3;
-    param_55 = _e458;
-    let _e459 = tile_3;
-    param_56 = _e459;
-    let _e460 = range_3;
-    param_57 = _e460;
-    let _e461 = receiver_2;
-    param_58 = _e461;
-    let _e462 = ca_2;
-    param_59 = _e462;
-    let _e463 = sa_2;
-    param_60 = _e463;
-    let _e464 = tanHalf_1;
-    param_61 = _e464;
-    let _e465 = PointShadowPenumbra_u0028_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b((&param_55), (&param_56), (&param_57), (&param_58), (&param_59), (&param_60), (&param_61), (&param_62));
-    let _e466 = param_62;
-    blocker_1 = _e466;
-    radius_1 = _e465;
-    let _e469 = point_shadow.params2_[3u];
-    if (_e469 > 0.5f) {
+    let _e459 = uv_3;
+    param_55 = _e459;
+    let _e460 = tile_3;
+    param_56 = _e460;
+    let _e461 = range_3;
+    param_57 = _e461;
+    let _e462 = receiver_2;
+    param_58 = _e462;
+    let _e463 = ca_2;
+    param_59 = _e463;
+    let _e464 = sa_2;
+    param_60 = _e464;
+    let _e465 = tanHalf_1;
+    param_61 = _e465;
+    let _e466 = PointShadowPenumbra_u0028_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b((&param_55), (&param_56), (&param_57), (&param_58), (&param_59), (&param_60), (&param_61), (&param_62));
+    let _e467 = param_62;
+    blocker_1 = _e467;
+    radius_1 = _e466;
+    let _e470 = point_shadow.params2_[3u];
+    if (_e470 > 0.5f) {
         g_debug_surface_on = true;
-        let _e471 = radius_1;
-        if (_e471 < 0f) {
+        let _e472 = radius_1;
+        if (_e472 < 0f) {
             local_8 = vec3<f32>(0f, 0f, 1f);
         } else {
-            let _e473 = radius_1;
-            let _e476 = point_shadow.params2_[2u];
-            let _e480 = blocker_1;
-            let _e481 = range_3;
-            local_8 = vec3<f32>(clamp((_e473 / max(_e476, 0.000001f)), 0f, 1f), clamp((_e480 / _e481), 0f, 1f), 0f);
+            let _e474 = radius_1;
+            let _e477 = point_shadow.params2_[2u];
+            let _e481 = blocker_1;
+            let _e482 = range_3;
+            local_8 = vec3<f32>(clamp((_e474 / max(_e477, 0.000001f)), 0f, 1f), clamp((_e481 / _e482), 0f, 1f), 0f);
         }
-        let _e485 = local_8;
-        g_debug_surface = _e485;
+        let _e486 = local_8;
+        g_debug_surface = _e486;
     }
-    let _e486 = radius_1;
-    if (_e486 < 0f) {
+    let _e487 = radius_1;
+    if (_e487 < 0f) {
         return 1f;
     }
-    let _e488 = uv_3;
-    param_63 = _e488;
+    let _e489 = uv_3;
+    param_63 = _e489;
     param_64 = vec2<f32>(0f, 0f);
-    let _e489 = tile_3;
-    param_65 = _e489;
-    let _e490 = range_3;
-    param_66 = _e490;
-    let _e491 = receiver_2;
-    param_67 = _e491;
-    let _e492 = PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((&param_63), (&param_64), (&param_65), (&param_66), (&param_67));
-    lit_1 = _e492;
-    let _e493 = radius_1;
-    if (_e493 > 0f) {
+    let _e490 = tile_3;
+    param_65 = _e490;
+    let _e491 = range_3;
+    param_66 = _e491;
+    let _e492 = receiver_2;
+    param_67 = _e492;
+    let _e493 = PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((&param_63), (&param_64), (&param_65), (&param_66), (&param_67));
+    lit_1 = _e493;
+    let _e494 = radius_1;
+    if (_e494 > 0f) {
         i_3 = 0i;
         loop {
-            let _e495 = i_3;
-            if (_e495 < 8i) {
-                let _e497 = i_3;
-                param_68 = _e497;
-                let _e498 = ca_2;
-                param_69 = _e498;
-                let _e499 = sa_2;
-                param_70 = _e499;
-                let _e500 = radius_1;
-                param_71 = _e500;
-                let _e501 = PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b((&param_68), (&param_69), (&param_70), (&param_71));
-                let _e502 = uv_3;
-                param_72 = _e502;
-                param_73 = _e501;
-                let _e503 = tile_3;
-                param_74 = _e503;
-                let _e504 = range_3;
-                param_75 = _e504;
-                let _e505 = receiver_2;
-                param_76 = _e505;
-                let _e506 = PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((&param_72), (&param_73), (&param_74), (&param_75), (&param_76));
-                let _e507 = lit_1;
-                lit_1 = (_e507 + _e506);
+            let _e496 = i_3;
+            if (_e496 < 8i) {
+                let _e498 = i_3;
+                param_68 = _e498;
+                let _e499 = ca_2;
+                param_69 = _e499;
+                let _e500 = sa_2;
+                param_70 = _e500;
+                let _e501 = radius_1;
+                param_71 = _e501;
+                let _e502 = PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b((&param_68), (&param_69), (&param_70), (&param_71));
+                let _e503 = uv_3;
+                param_72 = _e503;
+                param_73 = _e502;
+                let _e504 = tile_3;
+                param_74 = _e504;
+                let _e505 = range_3;
+                param_75 = _e505;
+                let _e506 = receiver_2;
+                param_76 = _e506;
+                let _e507 = PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((&param_72), (&param_73), (&param_74), (&param_75), (&param_76));
+                let _e508 = lit_1;
+                lit_1 = (_e508 + _e507);
                 continue;
             } else {
                 break;
             }
             continuing {
-                let _e509 = i_3;
-                i_3 = (_e509 + 1i);
+                let _e510 = i_3;
+                i_3 = (_e510 + 1i);
             }
         }
-        let _e511 = lit_1;
-        lit_1 = (_e511 * 0.11111111f);
+        let _e512 = lit_1;
+        lit_1 = (_e512 * 0.11111111f);
     }
-    let _e513 = lit_1;
-    let _e514 = strength;
-    return mix(1f, _e513, clamp(_e514, 0f, 1f));
+    let _e514 = lit_1;
+    let _e515 = strength;
+    return mix(1f, _e514, clamp(_e515, 0f, 1f));
 }
 
 fn VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b(i_4: ptr<function, i32>, n_1: ptr<function, i32>, turn: ptr<function, f32>) -> vec2<f32> {
     var r_3: f32;
     var theta: f32;
 
-    let _e211 = (*i_4);
-    let _e214 = (*n_1);
-    r_3 = sqrt(((f32(_e211) + 0.5f) / f32(_e214)));
-    let _e218 = (*i_4);
-    let _e221 = (*turn);
-    theta = ((f32(_e218) * 2.3999631f) + _e221);
-    let _e223 = r_3;
-    let _e224 = theta;
-    let _e226 = theta;
-    return (vec2<f32>(cos(_e224), sin(_e226)) * _e223);
+    let _e212 = (*i_4);
+    let _e215 = (*n_1);
+    r_3 = sqrt(((f32(_e212) + 0.5f) / f32(_e215)));
+    let _e219 = (*i_4);
+    let _e222 = (*turn);
+    theta = ((f32(_e219) * 2.3999631f) + _e222);
+    let _e224 = r_3;
+    let _e225 = theta;
+    let _e227 = theta;
+    return (vec2<f32>(cos(_e225), sin(_e227)) * _e224);
 }
 
 fn ShadowNoise_u0028_() -> f32 {
     var at: vec2<f32>;
     var param_77: f32;
 
-    let _e210 = frag_info.target_origin[0u];
-    param_77 = _e210;
-    let _e211 = FragCoordFromTop_u0028_f1_u003b((&param_77));
-    let _e214 = frag_info.target_origin[3u];
-    at = (_e211 + vec2((5.588238f * max(_e214, 0f))));
-    let _e219 = at;
-    return fract((52.982918f * fract(dot(_e219, vec2<f32>(0.06711056f, 0.00583715f)))));
+    let _e211 = frag_info.target_origin[0u];
+    param_77 = _e211;
+    let _e212 = FragCoordFromTop_u0028_f1_u003b((&param_77));
+    let _e215 = frag_info.target_origin[3u];
+    at = (_e212 + vec2((5.588238f * max(_e215, 0f))));
+    let _e220 = at;
+    return fract((52.982918f * fract(dot(_e220, vec2<f32>(0.06711056f, 0.00583715f)))));
 }
 
 fn EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b(moments: ptr<function, vec2<f32>>, t: ptr<function, f32>, minVariance: ptr<function, f32>, bleed: ptr<function, f32>) -> f32 {
@@ -14904,37 +14988,37 @@ fn EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b(moments: ptr<functio
     var pMax: f32;
     var reduced: f32;
 
-    let _e215 = (*moments)[1u];
-    let _e217 = (*moments)[0u];
-    let _e219 = (*moments)[0u];
-    let _e222 = (*minVariance);
-    variance = max((_e215 - (_e217 * _e219)), _e222);
-    let _e224 = (*t);
-    let _e226 = (*moments)[0u];
-    d_2 = (_e224 - _e226);
-    let _e228 = variance;
+    let _e216 = (*moments)[1u];
+    let _e218 = (*moments)[0u];
+    let _e220 = (*moments)[0u];
+    let _e223 = (*minVariance);
+    variance = max((_e216 - (_e218 * _e220)), _e223);
+    let _e225 = (*t);
+    let _e227 = (*moments)[0u];
+    d_2 = (_e225 - _e227);
     let _e229 = variance;
-    let _e230 = d_2;
+    let _e230 = variance;
     let _e231 = d_2;
-    pMax = (_e228 / (_e229 + (_e230 * _e231)));
-    let _e235 = pMax;
-    let _e236 = (*bleed);
-    let _e238 = (*bleed);
-    reduced = clamp(((_e235 - _e236) / max((1f - _e238), 0.0001f)), 0f, 1f);
-    let _e243 = (*t);
-    let _e245 = (*moments)[0u];
-    let _e247 = reduced;
-    return select(_e247, 1f, (_e243 <= _e245));
+    let _e232 = d_2;
+    pMax = (_e229 / (_e230 + (_e231 * _e232)));
+    let _e236 = pMax;
+    let _e237 = (*bleed);
+    let _e239 = (*bleed);
+    reduced = clamp(((_e236 - _e237) / max((1f - _e239), 0.0001f)), 0f, 1f);
+    let _e244 = (*t);
+    let _e246 = (*moments)[0u];
+    let _e248 = reduced;
+    return select(_e248, 1f, (_e244 <= _e246));
 }
 
 fn EvsmWarp_u0028_f1_u003b(depth: ptr<function, f32>) -> vec2<f32> {
     var d_3: f32;
 
-    let _e208 = (*depth);
-    d_3 = ((2f * clamp(_e208, 0f, 1f)) - 1f);
-    let _e212 = d_3;
-    let _e215 = d_3;
-    return vec2<f32>(exp((40f * _e212)), -(exp((-5f * _e215))));
+    let _e209 = (*depth);
+    d_3 = ((2f * clamp(_e209, 0f, 1f)) - 1f);
+    let _e213 = d_3;
+    let _e216 = d_3;
+    return vec2<f32>(exp((40f * _e213)), -(exp((-5f * _e216))));
 }
 
 fn EvsmVisibility_u0028_vf4_u003b_f1_u003b_f1_u003b(moments_1: ptr<function, vec4<f32>>, depth_1: ptr<function, f32>, bleed_1: ptr<function, f32>) -> f32 {
@@ -14952,37 +15036,37 @@ fn EvsmVisibility_u0028_vf4_u003b_f1_u003b_f1_u003b(moments_1: ptr<function, vec
     var param_85: f32;
     var param_86: f32;
 
-    let _e222 = (*depth_1);
-    param_78 = _e222;
-    let _e223 = EvsmWarp_u0028_f1_u003b((&param_78));
-    warped = _e223;
-    let _e224 = warped;
-    scale = (vec2<f32>(0.004f, 0.0005f) * _e224);
-    let _e227 = scale[0u];
-    let _e229 = scale[0u];
-    let _e231 = (*moments_1);
-    param_79 = _e231.xy;
-    let _e234 = warped[0u];
-    param_80 = _e234;
-    param_81 = (_e227 * _e229);
-    let _e235 = (*bleed_1);
-    param_82 = _e235;
-    let _e236 = EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b((&param_79), (&param_80), (&param_81), (&param_82));
-    positive = _e236;
-    let _e238 = scale[1u];
-    let _e240 = scale[1u];
-    let _e242 = (*moments_1);
-    param_83 = _e242.zw;
-    let _e245 = warped[1u];
-    param_84 = _e245;
-    param_85 = (_e238 * _e240);
-    let _e246 = (*bleed_1);
-    param_86 = _e246;
-    let _e247 = EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b((&param_83), (&param_84), (&param_85), (&param_86));
-    negative = _e247;
-    let _e248 = positive;
-    let _e249 = negative;
-    return min(_e248, _e249);
+    let _e223 = (*depth_1);
+    param_78 = _e223;
+    let _e224 = EvsmWarp_u0028_f1_u003b((&param_78));
+    warped = _e224;
+    let _e225 = warped;
+    scale = (vec2<f32>(0.004f, 0.0005f) * _e225);
+    let _e228 = scale[0u];
+    let _e230 = scale[0u];
+    let _e232 = (*moments_1);
+    param_79 = _e232.xy;
+    let _e235 = warped[0u];
+    param_80 = _e235;
+    param_81 = (_e228 * _e230);
+    let _e236 = (*bleed_1);
+    param_82 = _e236;
+    let _e237 = EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b((&param_79), (&param_80), (&param_81), (&param_82));
+    positive = _e237;
+    let _e239 = scale[1u];
+    let _e241 = scale[1u];
+    let _e243 = (*moments_1);
+    param_83 = _e243.zw;
+    let _e246 = warped[1u];
+    param_84 = _e246;
+    param_85 = (_e239 * _e241);
+    let _e247 = (*bleed_1);
+    param_86 = _e247;
+    let _e248 = EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b((&param_83), (&param_84), (&param_85), (&param_86));
+    negative = _e248;
+    let _e249 = positive;
+    let _e250 = negative;
+    return min(_e249, _e250);
 }
 
 fn ShadowFactor_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b_i1_u003b(s_4: ptr<function, Surface>, light_1: ptr<function, LightSample>, lightIndex_1: ptr<function, i32>) -> f32 {
@@ -15020,6 +15104,8 @@ fn ShadowFactor_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf
     var tileLo: vec2<f32>;
     var tileHi: vec2<f32>;
     var stored_2: vec4<f32>;
+    var y_1: i32;
+    var x_1: i32;
     var through: vec3<f32>;
     var softness: f32;
     var lit_2: f32;
@@ -15027,8 +15113,8 @@ fn ShadowFactor_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf
     var param_87: vec4<f32>;
     var param_88: f32;
     var param_89: f32;
-    var y_1: i32;
-    var x_1: i32;
+    var y_2: i32;
+    var x_2: i32;
     var occluder: f32;
     var spread: f32;
     var turn_1: f32;
@@ -15057,45 +15143,45 @@ fn ShadowFactor_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf
     var phi_4049_: bool;
     var phi_4056_: bool;
 
-    let _e276 = frag_info.shadow_params[3u];
-    strength_1 = _e276;
-    let _e277 = strength_1;
-    if (_e277 <= 0f) {
+    let _e279 = frag_info.shadow_params[3u];
+    strength_1 = _e279;
+    let _e280 = strength_1;
+    if (_e280 <= 0f) {
         return 1f;
     }
-    let _e279 = (*lightIndex_1);
-    let _e282 = frag_info.frame_params[2u];
-    if (_e279 != i32((_e282 + 0.5f))) {
+    let _e282 = (*lightIndex_1);
+    let _e285 = frag_info.frame_params[2u];
+    if (_e282 != i32((_e285 + 0.5f))) {
         return 1f;
     }
-    let _e288 = frag_info.shadow_cascades[2u];
-    cascadeCount = i32((_e288 + 0.5f));
-    let _e291 = v_world_position_1;
-    let _e293 = frag_info.camera_position;
-    viewDistance = length((_e291 - _e293.xyz));
+    let _e291 = frag_info.shadow_cascades[2u];
+    cascadeCount = i32((_e291 + 0.5f));
+    let _e294 = v_world_position_1;
+    let _e296 = frag_info.camera_position;
+    viewDistance = length((_e294 - _e296.xyz));
     cascade = 0i;
-    let _e297 = cascadeCount;
-    let _e298 = (_e297 > 1i);
-    phi_3870_ = _e298;
-    if _e298 {
-        let _e299 = viewDistance;
-        let _e302 = frag_info.shadow_cascades[0u];
-        phi_3870_ = (_e299 > _e302);
+    let _e300 = cascadeCount;
+    let _e301 = (_e300 > 1i);
+    phi_3870_ = _e301;
+    if _e301 {
+        let _e302 = viewDistance;
+        let _e305 = frag_info.shadow_cascades[0u];
+        phi_3870_ = (_e302 > _e305);
     }
-    let _e305 = phi_3870_;
-    if _e305 {
+    let _e308 = phi_3870_;
+    if _e308 {
         cascade = 1i;
     }
-    let _e306 = cascadeCount;
-    let _e307 = (_e306 > 2i);
-    phi_3881_ = _e307;
-    if _e307 {
-        let _e308 = viewDistance;
-        let _e311 = frag_info.shadow_cascades[1u];
-        phi_3881_ = (_e308 > _e311);
+    let _e309 = cascadeCount;
+    let _e310 = (_e309 > 2i);
+    phi_3881_ = _e310;
+    if _e310 {
+        let _e311 = viewDistance;
+        let _e314 = frag_info.shadow_cascades[1u];
+        phi_3881_ = (_e311 > _e314);
     }
-    let _e314 = phi_3881_;
-    if _e314 {
+    let _e317 = phi_3881_;
+    if _e317 {
         cascade = 2i;
     }
     uv_4 = vec2<f32>(0f, 0f);
@@ -15106,247 +15192,280 @@ fn ShadowFactor_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf
     receiverSlope = 0f;
     attempt = 0i;
     loop {
-        let _e315 = attempt;
-        if (_e315 < 3i) {
-            let _e317 = cascade;
-            let _e318 = attempt;
-            which = (_e317 + _e318);
-            let _e320 = which;
-            let _e321 = cascadeCount;
-            if (_e320 >= _e321) {
+        let _e318 = attempt;
+        if (_e318 < 3i) {
+            let _e320 = cascade;
+            let _e321 = attempt;
+            which = (_e320 + _e321);
+            let _e323 = which;
+            let _e324 = cascadeCount;
+            if (_e323 >= _e324) {
                 break;
             }
-            let _e323 = which;
-            if (_e323 == 0i) {
-                let _e326 = frag_info.shadow_matrix;
-                local_9 = _e326;
+            let _e326 = which;
+            if (_e326 == 0i) {
+                let _e329 = frag_info.shadow_matrix;
+                local_9 = _e329;
             } else {
-                let _e327 = which;
-                if (_e327 == 1i) {
-                    let _e330 = frag_info.shadow_matrix_far;
-                    local_10 = _e330;
+                let _e330 = which;
+                if (_e330 == 1i) {
+                    let _e333 = frag_info.shadow_matrix_far;
+                    local_10 = _e333;
                 } else {
-                    let _e332 = frag_info.shadow_matrix_farthest;
-                    local_10 = _e332;
+                    let _e335 = frag_info.shadow_matrix_farthest;
+                    local_10 = _e335;
                 }
-                let _e333 = local_10;
-                local_9 = _e333;
-            }
-            let _e334 = local_9;
-            matrix = _e334;
-            let _e337 = matrix[0][0u];
-            let _e340 = matrix[1][0u];
-            let _e343 = matrix[2][0u];
-            axisX = vec3<f32>(_e337, _e340, _e343);
-            let _e347 = matrix[0][1u];
-            let _e350 = matrix[1][1u];
-            let _e353 = matrix[2][1u];
-            axisY = vec3<f32>(_e347, _e350, _e353);
-            let _e355 = axisX;
-            rowX = max(length(_e355), 0.000001f);
-            let _e358 = axisY;
-            rowY = max(length(_e358), 0.000001f);
-            let _e363 = frag_info.shadow_cascades[3u];
-            let _e365 = rowX;
-            texelMetres = ((2f * _e363) / _e365);
-            let _e369 = frag_info.shadow_cascades[3u];
-            let _e372 = (*s_4).n;
-            let _e373 = axisX;
-            let _e376 = rowX;
-            let _e377 = rowX;
-            let _e381 = (*s_4).n;
-            let _e382 = axisY;
-            let _e385 = rowY;
-            let _e386 = rowY;
-            reach = ((3f * _e369) * ((abs(dot(_e372, _e373)) / (_e376 * _e377)) + (abs(dot(_e381, _e382)) / (_e385 * _e386))));
-            let _e393 = frag_info.shadow_params[2u];
-            let _e394 = texelMetres;
-            flatOffset = min(_e393, _e394);
-            let _e396 = v_world_position_1;
-            let _e398 = (*s_4).n;
-            let _e399 = flatOffset;
-            let _e400 = reach;
-            origin_1 = (_e396 + (_e398 * (_e399 + _e400)));
-            let _e404 = matrix;
-            let _e405 = origin_1;
-            lightSpace = (_e404 * vec4<f32>(_e405.x, _e405.y, _e405.z, 1f));
-            let _e412 = lightSpace[3u];
-            if (_e412 <= 0f) {
+                let _e336 = local_10;
+                local_9 = _e336;
+            }
+            let _e337 = local_9;
+            matrix = _e337;
+            let _e340 = matrix[0][0u];
+            let _e343 = matrix[1][0u];
+            let _e346 = matrix[2][0u];
+            axisX = vec3<f32>(_e340, _e343, _e346);
+            let _e350 = matrix[0][1u];
+            let _e353 = matrix[1][1u];
+            let _e356 = matrix[2][1u];
+            axisY = vec3<f32>(_e350, _e353, _e356);
+            let _e358 = axisX;
+            rowX = max(length(_e358), 0.000001f);
+            let _e361 = axisY;
+            rowY = max(length(_e361), 0.000001f);
+            let _e366 = frag_info.shadow_cascades[3u];
+            let _e368 = rowX;
+            texelMetres = ((2f * _e366) / _e368);
+            let _e372 = frag_info.shadow_cascades[3u];
+            let _e375 = (*s_4).n;
+            let _e376 = axisX;
+            let _e379 = rowX;
+            let _e380 = rowX;
+            let _e384 = (*s_4).n;
+            let _e385 = axisY;
+            let _e388 = rowY;
+            let _e389 = rowY;
+            reach = ((3f * _e372) * ((abs(dot(_e375, _e376)) / (_e379 * _e380)) + (abs(dot(_e384, _e385)) / (_e388 * _e389))));
+            let _e396 = frag_info.shadow_params[2u];
+            let _e397 = texelMetres;
+            flatOffset = min(_e396, _e397);
+            let _e399 = v_world_position_1;
+            let _e401 = (*s_4).n;
+            let _e402 = flatOffset;
+            let _e403 = reach;
+            origin_1 = (_e399 + (_e401 * (_e402 + _e403)));
+            let _e407 = matrix;
+            let _e408 = origin_1;
+            lightSpace = (_e407 * vec4<f32>(_e408.x, _e408.y, _e408.z, 1f));
+            let _e415 = lightSpace[3u];
+            if (_e415 <= 0f) {
                 continue;
             }
-            let _e414 = lightSpace;
-            let _e417 = lightSpace[3u];
-            candidate = (_e414.xyz / vec3(_e417));
-            let _e421 = candidate[0u];
-            let _e425 = candidate[1u];
-            inTile = vec2<f32>(((_e421 * 0.5f) + 0.5f), (0.5f - (_e425 * 0.5f)));
-            let _e430 = inTile[0u];
-            let _e431 = (_e430 < 0f);
-            phi_4042_ = _e431;
-            if !(_e431) {
-                let _e434 = inTile[0u];
-                phi_4042_ = (_e434 > 1f);
-            }
-            let _e437 = phi_4042_;
-            phi_4049_ = _e437;
-            if !(_e437) {
-                let _e440 = inTile[1u];
-                phi_4049_ = (_e440 < 0f);
-            }
-            let _e443 = phi_4049_;
-            phi_4056_ = _e443;
-            if !(_e443) {
-                let _e446 = inTile[1u];
-                phi_4056_ = (_e446 > 1f);
-            }
-            let _e449 = phi_4056_;
-            if _e449 {
+            let _e417 = lightSpace;
+            let _e420 = lightSpace[3u];
+            candidate = (_e417.xyz / vec3(_e420));
+            let _e424 = candidate[0u];
+            let _e428 = candidate[1u];
+            inTile = vec2<f32>(((_e424 * 0.5f) + 0.5f), (0.5f - (_e428 * 0.5f)));
+            let _e433 = inTile[0u];
+            let _e434 = (_e433 < 0f);
+            phi_4042_ = _e434;
+            if !(_e434) {
+                let _e437 = inTile[0u];
+                phi_4042_ = (_e437 > 1f);
+            }
+            let _e440 = phi_4042_;
+            phi_4049_ = _e440;
+            if !(_e440) {
+                let _e443 = inTile[1u];
+                phi_4049_ = (_e443 < 0f);
+            }
+            let _e446 = phi_4049_;
+            phi_4056_ = _e446;
+            if !(_e446) {
+                let _e449 = inTile[1u];
+                phi_4056_ = (_e449 > 1f);
+            }
+            let _e452 = phi_4056_;
+            if _e452 {
                 continue;
             }
-            let _e451 = candidate[2u];
-            if (_e451 > 1f) {
-                let _e453 = which;
-                let _e454 = cascadeCount;
-                if (_e453 < (_e454 - 1i)) {
+            let _e454 = candidate[2u];
+            if (_e454 > 1f) {
+                let _e456 = which;
+                let _e457 = cascadeCount;
+                if (_e456 < (_e457 - 1i)) {
                     continue;
                 }
                 candidate[2u] = 1f;
             }
-            let _e459 = inTile[0u];
-            let _e460 = which;
-            let _e463 = cascadeCount;
-            let _e467 = inTile[1u];
-            uv_4 = vec2<f32>(((_e459 + f32(_e460)) / f32(_e463)), _e467);
-            let _e469 = candidate;
-            projected = _e469;
-            let _e470 = which;
-            cascade = _e470;
-            let _e471 = texelMetres;
-            cascadeTexel = _e471;
-            let _e474 = matrix[0][2u];
-            let _e477 = matrix[1][2u];
-            let _e480 = matrix[2][2u];
-            cascadeDepth = (1f / max(length(vec3<f32>(_e474, _e477, _e480)), 0.000001f));
-            let _e486 = (*s_4).n;
-            let _e489 = matrix[0][2u];
-            let _e492 = matrix[1][2u];
-            let _e495 = matrix[2][2u];
-            let _e499 = cascadeDepth;
-            cosSlope = clamp((abs(dot(_e486, vec3<f32>(_e489, _e492, _e495))) * _e499), 0.1f, 1f);
-            let _e502 = texelMetres;
-            let _e503 = cosSlope;
-            let _e504 = cosSlope;
-            let _e510 = cosSlope;
-            let _e512 = cascadeDepth;
-            receiverSlope = (((_e502 * sqrt(max((1f - (_e503 * _e504)), 0f))) / _e510) / _e512);
+            let _e462 = inTile[0u];
+            let _e463 = which;
+            let _e466 = cascadeCount;
+            let _e470 = inTile[1u];
+            uv_4 = vec2<f32>(((_e462 + f32(_e463)) / f32(_e466)), _e470);
+            let _e472 = candidate;
+            projected = _e472;
+            let _e473 = which;
+            cascade = _e473;
+            let _e474 = texelMetres;
+            cascadeTexel = _e474;
+            let _e477 = matrix[0][2u];
+            let _e480 = matrix[1][2u];
+            let _e483 = matrix[2][2u];
+            cascadeDepth = (1f / max(length(vec3<f32>(_e477, _e480, _e483)), 0.000001f));
+            let _e489 = (*s_4).n;
+            let _e492 = matrix[0][2u];
+            let _e495 = matrix[1][2u];
+            let _e498 = matrix[2][2u];
+            let _e502 = cascadeDepth;
+            cosSlope = clamp((abs(dot(_e489, vec3<f32>(_e492, _e495, _e498))) * _e502), 0.1f, 1f);
+            let _e505 = texelMetres;
+            let _e506 = cosSlope;
+            let _e507 = cosSlope;
+            let _e513 = cosSlope;
+            let _e515 = cascadeDepth;
+            receiverSlope = (((_e505 * sqrt(max((1f - (_e506 * _e507)), 0f))) / _e513) / _e515);
             found = true;
             break;
         } else {
             break;
         }
         continuing {
-            let _e514 = attempt;
-            attempt = (_e514 + 1i);
+            let _e517 = attempt;
+            attempt = (_e517 + 1i);
         }
     }
-    let _e516 = found;
-    if !(_e516) {
+    let _e519 = found;
+    if !(_e519) {
         return 1f;
     }
-    let _e518 = cascade;
-    if (_e518 == 0i) {
-        let _e522 = frag_info.shadow_bias[0u];
-        local_11 = _e522;
+    let _e521 = cascade;
+    if (_e521 == 0i) {
+        let _e525 = frag_info.shadow_bias[0u];
+        local_11 = _e525;
     } else {
-        let _e523 = cascade;
-        if (_e523 == 1i) {
-            let _e527 = frag_info.shadow_bias[1u];
-            local_12 = _e527;
-        } else {
-            let _e530 = frag_info.shadow_bias[2u];
+        let _e526 = cascade;
+        if (_e526 == 1i) {
+            let _e530 = frag_info.shadow_bias[1u];
             local_12 = _e530;
-        }
-        let _e531 = local_12;
-        local_11 = _e531;
-    }
-    let _e532 = local_11;
-    bias = _e532;
-    let _e535 = frag_info.shadow_params[0u];
-    let _e538 = frag_info.shadow_cascades[3u];
-    texel_1 = vec2<f32>(_e535, _e538);
-    let _e540 = cascade;
-    let _e542 = cascadeCount;
-    let _e546 = texel_1;
-    tileLo = (vec2<f32>((f32(_e540) / f32(_e542)), 0f) + (_e546 * 0.5f));
-    let _e549 = cascade;
-    let _e552 = cascadeCount;
-    let _e556 = texel_1;
-    tileHi = (vec2<f32>((f32((_e549 + 1i)) / f32(_e552)), 1f) - (_e556 * 0.5f));
-    let _e561 = frag_info.shadow_bias[3u];
-    if (_e561 > 0.5f) {
-        let _e563 = uv_4;
-        let _e564 = tileLo;
-        let _e565 = tileHi;
-        let _e567 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp(_e563, _e564, _e565), 0f);
-        stored_2 = _e567;
-        let _e569 = stored_2[1u];
-        let _e572 = stored_2[2u];
-        let _e575 = stored_2[3u];
-        through = clamp(vec3<f32>((1f - _e569), (1f - _e572), _e575), vec3(0f), vec3(4f));
-        let _e580 = through;
-        let _e581 = strength_1;
-        light_transmittance = mix(vec3<f32>(1f, 1f, 1f), _e580, vec3(clamp(_e581, 0f, 1f)));
-    }
-    let _e587 = frag_info.ambient_ground[3u];
-    softness = _e587;
+        } else {
+            let _e533 = frag_info.shadow_bias[2u];
+            local_12 = _e533;
+        }
+        let _e534 = local_12;
+        local_11 = _e534;
+    }
+    let _e535 = local_11;
+    bias = _e535;
+    let _e538 = frag_info.shadow_params[0u];
+    let _e541 = frag_info.shadow_cascades[3u];
+    texel_1 = vec2<f32>(_e538, _e541);
+    let _e543 = cascade;
+    let _e545 = cascadeCount;
+    let _e549 = texel_1;
+    tileLo = (vec2<f32>((f32(_e543) / f32(_e545)), 0f) + (_e549 * 0.5f));
+    let _e552 = cascade;
+    let _e555 = cascadeCount;
+    let _e559 = texel_1;
+    tileHi = (vec2<f32>((f32((_e552 + 1i)) / f32(_e555)), 1f) - (_e559 * 0.5f));
+    let _e564 = frag_info.shadow_bias[3u];
+    if (_e564 > 0.5f) {
+        stored_2 = vec4<f32>(0f, 0f, 0f, 0f);
+        y_1 = -1i;
+        loop {
+            let _e566 = y_1;
+            if (_e566 <= 1i) {
+                x_1 = -1i;
+                loop {
+                    let _e568 = x_1;
+                    if (_e568 <= 1i) {
+                        let _e570 = uv_4;
+                        let _e571 = x_1;
+                        let _e573 = y_1;
+                        let _e576 = texel_1;
+                        let _e579 = tileLo;
+                        let _e580 = tileHi;
+                        let _e582 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e570 + (vec2<f32>(f32(_e571), f32(_e573)) * _e576)), _e579, _e580), 0f);
+                        let _e583 = stored_2;
+                        stored_2 = (_e583 + _e582);
+                        continue;
+                    } else {
+                        break;
+                    }
+                    continuing {
+                        let _e585 = x_1;
+                        x_1 = (_e585 + 1i);
+                    }
+                }
+                continue;
+            } else {
+                break;
+            }
+            continuing {
+                let _e587 = y_1;
+                y_1 = (_e587 + 1i);
+            }
+        }
+        let _e589 = stored_2;
+        stored_2 = (_e589 * 0.11111111f);
+        let _e592 = stored_2[1u];
+        let _e595 = stored_2[2u];
+        let _e598 = stored_2[3u];
+        through = clamp(vec3<f32>((1f - _e592), (1f - _e595), _e598), vec3(0f), vec3(4f));
+        let _e603 = through;
+        let _e604 = strength_1;
+        light_transmittance = mix(vec3<f32>(1f, 1f, 1f), _e603, vec3(clamp(_e604, 0f, 1f)));
+    }
+    let _e610 = frag_info.ambient_ground[3u];
+    softness = _e610;
     lit_2 = 0f;
-    let _e588 = softness;
-    if (_e588 < 0f) {
-        let _e590 = uv_4;
-        let _e591 = tileLo;
-        let _e592 = tileHi;
-        let _e594 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp(_e590, _e591, _e592), 0f);
-        moments_2 = _e594;
-        let _e596 = projected[2u];
-        let _e597 = bias;
-        let _e599 = softness;
-        let _e603 = moments_2;
-        param_87 = _e603;
-        param_88 = (_e596 - _e597);
-        param_89 = clamp((-(_e599) - 1f), 0f, 0.95f);
-        let _e604 = EvsmVisibility_u0028_vf4_u003b_f1_u003b_f1_u003b((&param_87), (&param_88), (&param_89));
-        lit_2 = _e604;
-    } else {
-        let _e605 = softness;
-        if (_e605 <= 0f) {
-            y_1 = -1i;
+    let _e611 = softness;
+    if (_e611 < 0f) {
+        let _e613 = uv_4;
+        let _e614 = tileLo;
+        let _e615 = tileHi;
+        let _e617 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp(_e613, _e614, _e615), 0f);
+        moments_2 = _e617;
+        let _e619 = projected[2u];
+        let _e620 = bias;
+        let _e622 = softness;
+        let _e626 = moments_2;
+        param_87 = _e626;
+        param_88 = (_e619 - _e620);
+        param_89 = clamp((-(_e622) - 1f), 0f, 0.95f);
+        let _e627 = EvsmVisibility_u0028_vf4_u003b_f1_u003b_f1_u003b((&param_87), (&param_88), (&param_89));
+        lit_2 = _e627;
+    } else {
+        let _e628 = softness;
+        if (_e628 <= 0f) {
+            y_2 = -1i;
             loop {
-                let _e607 = y_1;
-                if (_e607 <= 1i) {
-                    x_1 = -1i;
+                let _e630 = y_2;
+                if (_e630 <= 1i) {
+                    x_2 = -1i;
                     loop {
-                        let _e609 = x_1;
-                        if (_e609 <= 1i) {
-                            let _e611 = uv_4;
-                            let _e612 = x_1;
-                            let _e614 = y_1;
-                            let _e617 = texel_1;
-                            let _e620 = tileLo;
-                            let _e621 = tileHi;
-                            let _e623 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e611 + (vec2<f32>(f32(_e612), f32(_e614)) * _e617)), _e620, _e621), 0f);
-                            occluder = _e623.x;
-                            let _e626 = projected[2u];
-                            let _e627 = bias;
-                            let _e629 = occluder;
-                            let _e632 = lit_2;
-                            lit_2 = (_e632 + select(1f, 0f, ((_e626 - _e627) > _e629)));
+                        let _e632 = x_2;
+                        if (_e632 <= 1i) {
+                            let _e634 = uv_4;
+                            let _e635 = x_2;
+                            let _e637 = y_2;
+                            let _e640 = texel_1;
+                            let _e643 = tileLo;
+                            let _e644 = tileHi;
+                            let _e646 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e634 + (vec2<f32>(f32(_e635), f32(_e637)) * _e640)), _e643, _e644), 0f);
+                            occluder = _e646.x;
+                            let _e649 = projected[2u];
+                            let _e650 = bias;
+                            let _e652 = occluder;
+                            let _e655 = lit_2;
+                            lit_2 = (_e655 + select(1f, 0f, ((_e649 - _e650) > _e652)));
                             continue;
                         } else {
                             break;
                         }
                         continuing {
-                            let _e634 = x_1;
-                            x_1 = (_e634 + 1i);
+                            let _e657 = x_2;
+                            x_2 = (_e657 + 1i);
                         }
                     }
                     continue;
@@ -15354,125 +15473,125 @@ fn ShadowFactor_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf
                     break;
                 }
                 continuing {
-                    let _e636 = y_1;
-                    y_1 = (_e636 + 1i);
+                    let _e659 = y_2;
+                    y_2 = (_e659 + 1i);
                 }
             }
-            let _e638 = lit_2;
-            lit_2 = (_e638 * 0.11111111f);
+            let _e661 = lit_2;
+            lit_2 = (_e661 * 0.11111111f);
         } else {
-            let _e640 = softness;
-            spread = tan(min(_e640, 0.5f));
-            let _e643 = ShadowNoise_u0028_();
-            turn_1 = (_e643 * 6.2831855f);
-            let _e645 = spread;
-            let _e647 = projected[2u];
-            let _e649 = cascadeDepth;
-            let _e651 = cascadeTexel;
-            searchRadius = clamp((((_e645 * _e647) * _e649) / _e651), 1f, 16f);
+            let _e663 = softness;
+            spread = tan(min(_e663, 0.5f));
+            let _e666 = ShadowNoise_u0028_();
+            turn_1 = (_e666 * 6.2831855f);
+            let _e668 = spread;
+            let _e670 = projected[2u];
+            let _e672 = cascadeDepth;
+            let _e674 = cascadeTexel;
+            searchRadius = clamp((((_e668 * _e670) * _e672) / _e674), 1f, 16f);
             blockerSum = 0f;
             blockerCount = 0f;
             i_5 = 0i;
             loop {
-                let _e654 = i_5;
-                if (_e654 < 16i) {
-                    let _e656 = i_5;
-                    param_90 = _e656;
+                let _e677 = i_5;
+                if (_e677 < 16i) {
+                    let _e679 = i_5;
+                    param_90 = _e679;
                     param_91 = 16i;
-                    let _e657 = turn_1;
-                    param_92 = _e657;
-                    let _e658 = VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b((&param_90), (&param_91), (&param_92));
-                    disc = _e658;
-                    let _e659 = bias;
-                    let _e660 = disc;
-                    let _e662 = searchRadius;
-                    let _e666 = receiverSlope;
-                    tapBias = (_e659 + (max(((length(_e660) * _e662) - 1.5f), 0f) * _e666));
-                    let _e669 = uv_4;
-                    let _e670 = disc;
-                    let _e671 = texel_1;
-                    let _e673 = searchRadius;
-                    let _e676 = tileLo;
-                    let _e677 = tileHi;
-                    let _e679 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e669 + ((_e670 * _e671) * _e673)), _e676, _e677), 0f);
-                    occluder_1 = _e679.x;
-                    let _e682 = projected[2u];
-                    let _e683 = tapBias;
-                    let _e685 = occluder_1;
-                    if ((_e682 - _e683) > _e685) {
-                        let _e687 = occluder_1;
-                        let _e688 = blockerSum;
-                        blockerSum = (_e688 + _e687);
-                        let _e690 = blockerCount;
-                        blockerCount = (_e690 + 1f);
+                    let _e680 = turn_1;
+                    param_92 = _e680;
+                    let _e681 = VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b((&param_90), (&param_91), (&param_92));
+                    disc = _e681;
+                    let _e682 = bias;
+                    let _e683 = disc;
+                    let _e685 = searchRadius;
+                    let _e689 = receiverSlope;
+                    tapBias = (_e682 + (max(((length(_e683) * _e685) - 1.5f), 0f) * _e689));
+                    let _e692 = uv_4;
+                    let _e693 = disc;
+                    let _e694 = texel_1;
+                    let _e696 = searchRadius;
+                    let _e699 = tileLo;
+                    let _e700 = tileHi;
+                    let _e702 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e692 + ((_e693 * _e694) * _e696)), _e699, _e700), 0f);
+                    occluder_1 = _e702.x;
+                    let _e705 = projected[2u];
+                    let _e706 = tapBias;
+                    let _e708 = occluder_1;
+                    if ((_e705 - _e706) > _e708) {
+                        let _e710 = occluder_1;
+                        let _e711 = blockerSum;
+                        blockerSum = (_e711 + _e710);
+                        let _e713 = blockerCount;
+                        blockerCount = (_e713 + 1f);
                     }
                     continue;
                 } else {
                     break;
                 }
                 continuing {
-                    let _e692 = i_5;
-                    i_5 = (_e692 + 1i);
+                    let _e715 = i_5;
+                    i_5 = (_e715 + 1i);
                 }
             }
-            let _e694 = blockerCount;
-            if (_e694 <= 0f) {
+            let _e717 = blockerCount;
+            if (_e717 <= 0f) {
                 return 1f;
             }
-            let _e697 = projected[2u];
-            let _e698 = blockerSum;
-            let _e699 = blockerCount;
-            let _e703 = cascadeDepth;
-            gap = (max((_e697 - (_e698 / _e699)), 0f) * _e703);
-            let _e705 = spread;
-            let _e706 = gap;
-            let _e708 = cascadeTexel;
-            radius_2 = clamp(((_e705 * _e706) / _e708), 1f, 16f);
+            let _e720 = projected[2u];
+            let _e721 = blockerSum;
+            let _e722 = blockerCount;
+            let _e726 = cascadeDepth;
+            gap = (max((_e720 - (_e721 / _e722)), 0f) * _e726);
+            let _e728 = spread;
+            let _e729 = gap;
+            let _e731 = cascadeTexel;
+            radius_2 = clamp(((_e728 * _e729) / _e731), 1f, 16f);
             i_6 = 0i;
             loop {
-                let _e711 = i_6;
-                if (_e711 < 16i) {
-                    let _e713 = turn_1;
-                    let _e715 = i_6;
-                    param_93 = _e715;
+                let _e734 = i_6;
+                if (_e734 < 16i) {
+                    let _e736 = turn_1;
+                    let _e738 = i_6;
+                    param_93 = _e738;
                     param_94 = 16i;
-                    param_95 = (_e713 + 1f);
-                    let _e716 = VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b((&param_93), (&param_94), (&param_95));
-                    disc_1 = _e716;
-                    let _e717 = bias;
-                    let _e718 = disc_1;
-                    let _e720 = radius_2;
-                    let _e724 = receiverSlope;
-                    tapBias_1 = (_e717 + (max(((length(_e718) * _e720) - 1.5f), 0f) * _e724));
-                    let _e727 = uv_4;
-                    let _e728 = disc_1;
-                    let _e729 = texel_1;
-                    let _e731 = radius_2;
-                    let _e734 = tileLo;
-                    let _e735 = tileHi;
-                    let _e737 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e727 + ((_e728 * _e729) * _e731)), _e734, _e735), 0f);
-                    occluder_2 = _e737.x;
-                    let _e740 = projected[2u];
-                    let _e741 = tapBias_1;
-                    let _e743 = occluder_2;
-                    let _e746 = lit_2;
-                    lit_2 = (_e746 + select(1f, 0f, ((_e740 - _e741) > _e743)));
+                    param_95 = (_e736 + 1f);
+                    let _e739 = VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b((&param_93), (&param_94), (&param_95));
+                    disc_1 = _e739;
+                    let _e740 = bias;
+                    let _e741 = disc_1;
+                    let _e743 = radius_2;
+                    let _e747 = receiverSlope;
+                    tapBias_1 = (_e740 + (max(((length(_e741) * _e743) - 1.5f), 0f) * _e747));
+                    let _e750 = uv_4;
+                    let _e751 = disc_1;
+                    let _e752 = texel_1;
+                    let _e754 = radius_2;
+                    let _e757 = tileLo;
+                    let _e758 = tileHi;
+                    let _e760 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e750 + ((_e751 * _e752) * _e754)), _e757, _e758), 0f);
+                    occluder_2 = _e760.x;
+                    let _e763 = projected[2u];
+                    let _e764 = tapBias_1;
+                    let _e766 = occluder_2;
+                    let _e769 = lit_2;
+                    lit_2 = (_e769 + select(1f, 0f, ((_e763 - _e764) > _e766)));
                     continue;
                 } else {
                     break;
                 }
                 continuing {
-                    let _e748 = i_6;
-                    i_6 = (_e748 + 1i);
+                    let _e771 = i_6;
+                    i_6 = (_e771 + 1i);
                 }
             }
-            let _e750 = lit_2;
-            lit_2 = (_e750 * 0.0625f);
+            let _e773 = lit_2;
+            lit_2 = (_e773 * 0.0625f);
         }
     }
-    let _e752 = lit_2;
-    let _e753 = strength_1;
-    return mix(1f, _e752, clamp(_e753, 0f, 1f));
+    let _e775 = lit_2;
+    let _e776 = strength_1;
+    return mix(1f, _e775, clamp(_e776, 0f, 1f));
 }
 
 fn LightVisibility_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b_i1_u003b(s_5: ptr<function, Surface>, light_2: ptr<function, LightSample>, index: ptr<function, i32>) -> f32 {
@@ -15480,19 +15599,19 @@ fn LightVisibility_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d
     var param_97: LightSample;
     var param_98: i32;
 
-    let _e212 = (*s_5);
-    param_96 = _e212;
-    let _e213 = (*light_2);
-    param_97 = _e213;
-    let _e214 = (*index);
-    param_98 = _e214;
-    let _e215 = ShadowFactor_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b_i1_u003b((&param_96), (&param_97), (&param_98));
-    return _e215;
+    let _e213 = (*s_5);
+    param_96 = _e213;
+    let _e214 = (*light_2);
+    param_97 = _e214;
+    let _e215 = (*index);
+    param_98 = _e215;
+    let _e216 = ShadowFactor_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b_i1_u003b((&param_96), (&param_97), (&param_98));
+    return _e216;
 }
 
 fn LightHasShadow_u0028_i1_u003b(index_1: ptr<function, i32>) -> bool {
-    let _e207 = (*index_1);
-    return (_e207 < 8i);
+    let _e208 = (*index_1);
+    return (_e208 < 8i);
 }
 
 fn PunctualAttenuation_u0028_f1_u003b_f1_u003b(distance_1: ptr<function, f32>, range_4: ptr<function, f32>) -> f32 {
@@ -15500,26 +15619,26 @@ fn PunctualAttenuation_u0028_f1_u003b_f1_u003b(distance_1: ptr<function, f32>, r
     var ratio: f32;
     var window: f32;
 
-    let _e211 = (*distance_1);
     let _e212 = (*distance_1);
-    attenuation = (1f / max((_e211 * _e212), 0.0001f));
-    let _e216 = (*range_4);
-    if (_e216 > 0f) {
-        let _e218 = (*distance_1);
-        let _e219 = (*range_4);
-        ratio = (_e218 / _e219);
-        let _e221 = ratio;
+    let _e213 = (*distance_1);
+    attenuation = (1f / max((_e212 * _e213), 0.0001f));
+    let _e217 = (*range_4);
+    if (_e217 > 0f) {
+        let _e219 = (*distance_1);
+        let _e220 = (*range_4);
+        ratio = (_e219 / _e220);
         let _e222 = ratio;
-        let _e224 = ratio;
-        let _e226 = ratio;
-        window = clamp((1f - (((_e221 * _e222) * _e224) * _e226)), 0f, 1f);
-        let _e230 = window;
+        let _e223 = ratio;
+        let _e225 = ratio;
+        let _e227 = ratio;
+        window = clamp((1f - (((_e222 * _e223) * _e225) * _e227)), 0f, 1f);
         let _e231 = window;
-        let _e233 = attenuation;
-        attenuation = (_e233 * (_e230 * _e231));
+        let _e232 = window;
+        let _e234 = attenuation;
+        attenuation = (_e234 * (_e231 * _e232));
     }
-    let _e235 = attenuation;
-    return _e235;
+    let _e236 = attenuation;
+    return _e236;
 }
 
 fn LtcEdge_u0028_vf3_u003b_vf3_u003b(a_2: ptr<function, vec3<f32>>, b: ptr<function, vec3<f32>>) -> vec3<f32> {
@@ -15528,25 +15647,25 @@ fn LtcEdge_u0028_vf3_u003b_vf3_u003b(a_2: ptr<function, vec3<f32>>, b: ptr<funct
     var angle_1: f32;
     var local_13: vec3<f32>;
 
-    let _e212 = (*a_2);
-    let _e213 = (*b);
-    axis = cross(_e212, _e213);
-    let _e215 = axis;
-    len = length(_e215);
-    let _e217 = (*a_2);
-    let _e218 = (*b);
-    angle_1 = acos(clamp(dot(_e217, _e218), -1f, 1f));
-    let _e222 = len;
-    if (_e222 > 0.000001f) {
-        let _e224 = axis;
-        let _e225 = angle_1;
-        let _e226 = len;
-        local_13 = (_e224 * (_e225 / (_e226 * 6.2831855f)));
+    let _e213 = (*a_2);
+    let _e214 = (*b);
+    axis = cross(_e213, _e214);
+    let _e216 = axis;
+    len = length(_e216);
+    let _e218 = (*a_2);
+    let _e219 = (*b);
+    angle_1 = acos(clamp(dot(_e218, _e219), -1f, 1f));
+    let _e223 = len;
+    if (_e223 > 0.000001f) {
+        let _e225 = axis;
+        let _e226 = angle_1;
+        let _e227 = len;
+        local_13 = (_e225 * (_e226 / (_e227 * 6.2831855f)));
     } else {
         local_13 = vec3<f32>(0f, 0f, 0f);
     }
-    let _e230 = local_13;
-    return _e230;
+    let _e231 = local_13;
+    return _e231;
 }
 
 fn LtcRectangle_u0028_vf3_u003b_vf3_u003b_f1_u003b_vf3_u005b_4_u005d_u003b(n_2: ptr<function, vec3<f32>>, v: ptr<function, vec3<f32>>, roughness_3: ptr<function, f32>, corners: ptr<function, array<vec3<f32>, 4>>) -> vec3<f32> {
@@ -15585,126 +15704,126 @@ fn LtcRectangle_u0028_vf3_u003b_vf3_u003b_f1_u003b_vf3_u005b_4_u005d_u003b(n_2:
     var param_114: f32;
     var param_115: f32;
 
-    let _e244 = (*roughness_3);
-    let _e246 = (*n_2);
-    let _e247 = (*v);
-    uv_5 = vec2<f32>(clamp(_e244, 0f, 1f), sqrt(clamp((1f - dot(_e246, _e247)), 0f, 1f)));
-    let _e254 = uv_5[0u];
-    param_99 = _e254;
-    let _e256 = uv_5[1u];
-    param_100 = _e256;
+    let _e245 = (*roughness_3);
+    let _e247 = (*n_2);
+    let _e248 = (*v);
+    uv_5 = vec2<f32>(clamp(_e245, 0f, 1f), sqrt(clamp((1f - dot(_e247, _e248)), 0f, 1f)));
+    let _e255 = uv_5[0u];
+    param_99 = _e255;
+    let _e257 = uv_5[1u];
+    param_100 = _e257;
     param_101 = 0f;
-    let _e257 = LtcUv_u0028_f1_u003b_f1_u003b_f1_u003b((&param_99), (&param_100), (&param_101));
-    let _e258 = textureSampleLevel(ltc_texture_tex, ltc_texture_smp, _e257, 0f);
-    inverse = _e258;
-    let _e260 = uv_5[0u];
-    param_102 = _e260;
-    let _e262 = uv_5[1u];
-    param_103 = _e262;
+    let _e258 = LtcUv_u0028_f1_u003b_f1_u003b_f1_u003b((&param_99), (&param_100), (&param_101));
+    let _e259 = textureSampleLevel(ltc_texture_tex, ltc_texture_smp, _e258, 0f);
+    inverse = _e259;
+    let _e261 = uv_5[0u];
+    param_102 = _e261;
+    let _e263 = uv_5[1u];
+    param_103 = _e263;
     param_104 = 1f;
-    let _e263 = LtcUv_u0028_f1_u003b_f1_u003b_f1_u003b((&param_102), (&param_103), (&param_104));
-    let _e264 = textureSampleLevel(ltc_texture_tex, ltc_texture_smp, _e263, 0f);
-    fit = _e264;
-    let _e265 = (*v);
-    let _e266 = (*n_2);
-    let _e267 = (*v);
-    let _e268 = (*n_2);
-    along = (_e265 - (_e266 * dot(_e267, _e268)));
-    let _e272 = along;
-    alongLength = length(_e272);
-    let _e274 = alongLength;
-    if (_e274 > 0.00001f) {
-        let _e276 = along;
-        let _e277 = alongLength;
-        local_14 = (_e276 / vec3(_e277));
-    } else {
-        let _e280 = (*n_2);
-        let _e282 = (*n_2)[2u];
-        local_14 = normalize(cross(_e280, select(vec3<f32>(1f, 0f, 0f), vec3<f32>(0f, 0f, 1f), vec3((abs(_e282) < 0.999f)))));
-    }
-    let _e289 = local_14;
-    t1_ = _e289;
-    let _e290 = (*n_2);
-    let _e291 = t1_;
-    t2_ = cross(_e290, _e291);
-    let _e294 = inverse[0u];
-    let _e296 = inverse[1u];
-    let _e297 = vec3<f32>(_e294, 0f, _e296);
-    let _e299 = inverse[2u];
-    let _e301 = inverse[3u];
-    let _e302 = vec3<f32>(_e299, 0f, _e301);
-    minv = mat3x3<f32>(vec3<f32>(_e297.x, _e297.y, _e297.z), vec3<f32>(vec3<f32>(0f, 1f, 0f).x, vec3<f32>(0f, 1f, 0f).y, vec3<f32>(0f, 1f, 0f).z), vec3<f32>(_e302.x, _e302.y, _e302.z));
+    let _e264 = LtcUv_u0028_f1_u003b_f1_u003b_f1_u003b((&param_102), (&param_103), (&param_104));
+    let _e265 = textureSampleLevel(ltc_texture_tex, ltc_texture_smp, _e264, 0f);
+    fit = _e265;
+    let _e266 = (*v);
+    let _e267 = (*n_2);
+    let _e268 = (*v);
+    let _e269 = (*n_2);
+    along = (_e266 - (_e267 * dot(_e268, _e269)));
+    let _e273 = along;
+    alongLength = length(_e273);
+    let _e275 = alongLength;
+    if (_e275 > 0.00001f) {
+        let _e277 = along;
+        let _e278 = alongLength;
+        local_14 = (_e277 / vec3(_e278));
+    } else {
+        let _e281 = (*n_2);
+        let _e283 = (*n_2)[2u];
+        local_14 = normalize(cross(_e281, select(vec3<f32>(1f, 0f, 0f), vec3<f32>(0f, 0f, 1f), vec3((abs(_e283) < 0.999f)))));
+    }
+    let _e290 = local_14;
+    t1_ = _e290;
+    let _e291 = (*n_2);
+    let _e292 = t1_;
+    t2_ = cross(_e291, _e292);
+    let _e295 = inverse[0u];
+    let _e297 = inverse[1u];
+    let _e298 = vec3<f32>(_e295, 0f, _e297);
+    let _e300 = inverse[2u];
+    let _e302 = inverse[3u];
+    let _e303 = vec3<f32>(_e300, 0f, _e302);
+    minv = mat3x3<f32>(vec3<f32>(_e298.x, _e298.y, _e298.z), vec3<f32>(vec3<f32>(0f, 1f, 0f).x, vec3<f32>(0f, 1f, 0f).y, vec3<f32>(0f, 1f, 0f).z), vec3<f32>(_e303.x, _e303.y, _e303.z));
     i_7 = 0i;
     loop {
-        let _e316 = i_7;
-        if (_e316 < 4i) {
-            let _e318 = i_7;
-            let _e320 = (*corners)[_e318];
-            p_1 = _e320;
-            let _e321 = i_7;
-            let _e322 = minv;
-            let _e323 = p_1;
-            let _e324 = t1_;
-            let _e326 = p_1;
-            let _e327 = t2_;
-            let _e329 = p_1;
-            let _e330 = (*n_2);
-            l[_e321] = normalize((_e322 * vec3<f32>(dot(_e323, _e324), dot(_e326, _e327), dot(_e329, _e330))));
+        let _e317 = i_7;
+        if (_e317 < 4i) {
+            let _e319 = i_7;
+            let _e321 = (*corners)[_e319];
+            p_1 = _e321;
+            let _e322 = i_7;
+            let _e323 = minv;
+            let _e324 = p_1;
+            let _e325 = t1_;
+            let _e327 = p_1;
+            let _e328 = t2_;
+            let _e330 = p_1;
+            let _e331 = (*n_2);
+            l[_e322] = normalize((_e323 * vec3<f32>(dot(_e324, _e325), dot(_e327, _e328), dot(_e330, _e331))));
             continue;
         } else {
             break;
         }
         continuing {
-            let _e336 = i_7;
-            i_7 = (_e336 + 1i);
-        }
-    }
-    let _e339 = l[0i];
-    param_105 = _e339;
-    let _e341 = l[1i];
-    param_106 = _e341;
-    let _e342 = LtcEdge_u0028_vf3_u003b_vf3_u003b((&param_105), (&param_106));
-    let _e344 = l[1i];
-    param_107 = _e344;
-    let _e346 = l[2i];
-    param_108 = _e346;
-    let _e347 = LtcEdge_u0028_vf3_u003b_vf3_u003b((&param_107), (&param_108));
-    let _e350 = l[2i];
-    param_109 = _e350;
-    let _e352 = l[3i];
-    param_110 = _e352;
-    let _e353 = LtcEdge_u0028_vf3_u003b_vf3_u003b((&param_109), (&param_110));
-    let _e356 = l[3i];
-    param_111 = _e356;
-    let _e358 = l[0i];
-    param_112 = _e358;
-    let _e359 = LtcEdge_u0028_vf3_u003b_vf3_u003b((&param_111), (&param_112));
-    f_2 = -((((_e342 + _e347) + _e353) + _e359));
-    let _e362 = f_2;
-    len_1 = length(_e362);
-    let _e364 = len_1;
-    if (_e364 > 0.000000001f) {
-        let _e367 = f_2[2u];
-        let _e368 = len_1;
-        local_15 = (_e367 / _e368);
+            let _e337 = i_7;
+            i_7 = (_e337 + 1i);
+        }
+    }
+    let _e340 = l[0i];
+    param_105 = _e340;
+    let _e342 = l[1i];
+    param_106 = _e342;
+    let _e343 = LtcEdge_u0028_vf3_u003b_vf3_u003b((&param_105), (&param_106));
+    let _e345 = l[1i];
+    param_107 = _e345;
+    let _e347 = l[2i];
+    param_108 = _e347;
+    let _e348 = LtcEdge_u0028_vf3_u003b_vf3_u003b((&param_107), (&param_108));
+    let _e351 = l[2i];
+    param_109 = _e351;
+    let _e353 = l[3i];
+    param_110 = _e353;
+    let _e354 = LtcEdge_u0028_vf3_u003b_vf3_u003b((&param_109), (&param_110));
+    let _e357 = l[3i];
+    param_111 = _e357;
+    let _e359 = l[0i];
+    param_112 = _e359;
+    let _e360 = LtcEdge_u0028_vf3_u003b_vf3_u003b((&param_111), (&param_112));
+    f_2 = -((((_e343 + _e348) + _e354) + _e360));
+    let _e363 = f_2;
+    len_1 = length(_e363);
+    let _e365 = len_1;
+    if (_e365 > 0.000000001f) {
+        let _e368 = f_2[2u];
+        let _e369 = len_1;
+        local_15 = (_e368 / _e369);
     } else {
         local_15 = 0f;
     }
-    let _e370 = local_15;
-    z_1 = _e370;
-    let _e371 = z_1;
-    let _e374 = len_1;
-    param_113 = ((_e371 * 0.5f) + 0.5f);
-    param_114 = clamp(_e374, 0f, 1f);
+    let _e371 = local_15;
+    z_1 = _e371;
+    let _e372 = z_1;
+    let _e375 = len_1;
+    param_113 = ((_e372 * 0.5f) + 0.5f);
+    param_114 = clamp(_e375, 0f, 1f);
     param_115 = 1f;
-    let _e376 = LtcUv_u0028_f1_u003b_f1_u003b_f1_u003b((&param_113), (&param_114), (&param_115));
-    let _e377 = textureSampleLevel(ltc_texture_tex, ltc_texture_smp, _e376, 0f);
-    sphere = _e377.w;
-    let _e379 = len_1;
-    let _e380 = sphere;
-    let _e384 = fit[0u];
-    let _e386 = fit[1u];
-    return vec3<f32>(max((_e379 * _e380), 0f), _e384, _e386);
+    let _e377 = LtcUv_u0028_f1_u003b_f1_u003b_f1_u003b((&param_113), (&param_114), (&param_115));
+    let _e378 = textureSampleLevel(ltc_texture_tex, ltc_texture_smp, _e377, 0f);
+    sphere = _e378.w;
+    let _e380 = len_1;
+    let _e381 = sphere;
+    let _e385 = fit[0u];
+    let _e387 = fit[1u];
+    return vec3<f32>(max((_e380 * _e381), 0f), _e385, _e387);
 }
 
 fn RectangleClosestPoint_u0028_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b(centre: ptr<function, vec3<f32>>, halfWidth: ptr<function, vec3<f32>>, halfHeight: ptr<function, vec3<f32>>, world_2: ptr<function, vec3<f32>>, mirror: ptr<function, vec3<f32>>) -> vec3<f32> {
@@ -15721,75 +15840,75 @@ fn RectangleClosestPoint_u0028_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b
     var u: f32;
     var v_1: f32;
 
-    let _e223 = (*halfWidth);
-    let _e224 = (*halfHeight);
-    n_3 = cross(_e223, _e224);
-    let _e226 = n_3;
-    nLen = length(_e226);
-    let _e228 = nLen;
-    if (_e228 < 0.000000000001f) {
-        let _e230 = (*centre);
-        return _e230;
-    }
-    let _e231 = nLen;
-    let _e232 = n_3;
-    n_3 = (_e232 / vec3(_e231));
-    let _e235 = (*centre);
-    let _e236 = (*world_2);
-    toPlane = (_e235 - _e236);
-    let _e238 = (*mirror);
-    let _e239 = n_3;
-    denom = dot(_e238, _e239);
-    let _e241 = denom;
-    if (abs(_e241) < 0.00001f) {
-        let _e244 = toPlane;
-        let _e245 = n_3;
-        let _e246 = toPlane;
-        let _e247 = n_3;
-        onPlane = (_e244 - (_e245 * dot(_e246, _e247)));
-    } else {
-        let _e251 = toPlane;
-        let _e252 = n_3;
-        let _e254 = denom;
-        t_1 = (dot(_e251, _e252) / _e254);
-        let _e256 = t_1;
-        if (_e256 > 0f) {
-            let _e258 = (*mirror);
-            let _e259 = t_1;
-            local_16 = (_e258 * _e259);
+    let _e224 = (*halfWidth);
+    let _e225 = (*halfHeight);
+    n_3 = cross(_e224, _e225);
+    let _e227 = n_3;
+    nLen = length(_e227);
+    let _e229 = nLen;
+    if (_e229 < 0.000000000001f) {
+        let _e231 = (*centre);
+        return _e231;
+    }
+    let _e232 = nLen;
+    let _e233 = n_3;
+    n_3 = (_e233 / vec3(_e232));
+    let _e236 = (*centre);
+    let _e237 = (*world_2);
+    toPlane = (_e236 - _e237);
+    let _e239 = (*mirror);
+    let _e240 = n_3;
+    denom = dot(_e239, _e240);
+    let _e242 = denom;
+    if (abs(_e242) < 0.00001f) {
+        let _e245 = toPlane;
+        let _e246 = n_3;
+        let _e247 = toPlane;
+        let _e248 = n_3;
+        onPlane = (_e245 - (_e246 * dot(_e247, _e248)));
+    } else {
+        let _e252 = toPlane;
+        let _e253 = n_3;
+        let _e255 = denom;
+        t_1 = (dot(_e252, _e253) / _e255);
+        let _e257 = t_1;
+        if (_e257 > 0f) {
+            let _e259 = (*mirror);
+            let _e260 = t_1;
+            local_16 = (_e259 * _e260);
         } else {
-            let _e261 = toPlane;
-            let _e262 = n_3;
-            let _e263 = toPlane;
-            let _e264 = n_3;
-            local_16 = (_e261 - (_e262 * dot(_e263, _e264)));
-        }
-        let _e268 = local_16;
-        onPlane = _e268;
-    }
-    let _e269 = onPlane;
-    let _e270 = toPlane;
-    offset_2 = (_e269 - _e270);
-    let _e272 = (*halfWidth);
+            let _e262 = toPlane;
+            let _e263 = n_3;
+            let _e264 = toPlane;
+            let _e265 = n_3;
+            local_16 = (_e262 - (_e263 * dot(_e264, _e265)));
+        }
+        let _e269 = local_16;
+        onPlane = _e269;
+    }
+    let _e270 = onPlane;
+    let _e271 = toPlane;
+    offset_2 = (_e270 - _e271);
     let _e273 = (*halfWidth);
-    wLen2_ = max(dot(_e272, _e273), 0.000000000001f);
-    let _e276 = (*halfHeight);
+    let _e274 = (*halfWidth);
+    wLen2_ = max(dot(_e273, _e274), 0.000000000001f);
     let _e277 = (*halfHeight);
-    hLen2_ = max(dot(_e276, _e277), 0.000000000001f);
-    let _e280 = offset_2;
-    let _e281 = (*halfWidth);
-    let _e283 = wLen2_;
-    u = clamp((dot(_e280, _e281) / _e283), -1f, 1f);
-    let _e286 = offset_2;
-    let _e287 = (*halfHeight);
-    let _e289 = hLen2_;
-    v_1 = clamp((dot(_e286, _e287) / _e289), -1f, 1f);
-    let _e292 = (*centre);
-    let _e293 = (*halfWidth);
-    let _e294 = u;
-    let _e297 = (*halfHeight);
-    let _e298 = v_1;
-    return ((_e292 + (_e293 * _e294)) + (_e297 * _e298));
+    let _e278 = (*halfHeight);
+    hLen2_ = max(dot(_e277, _e278), 0.000000000001f);
+    let _e281 = offset_2;
+    let _e282 = (*halfWidth);
+    let _e284 = wLen2_;
+    u = clamp((dot(_e281, _e282) / _e284), -1f, 1f);
+    let _e287 = offset_2;
+    let _e288 = (*halfHeight);
+    let _e290 = hLen2_;
+    v_1 = clamp((dot(_e287, _e288) / _e290), -1f, 1f);
+    let _e293 = (*centre);
+    let _e294 = (*halfWidth);
+    let _e295 = u;
+    let _e298 = (*halfHeight);
+    let _e299 = v_1;
+    return ((_e293 + (_e294 * _e295)) + (_e298 * _e299));
 }
 
 fn LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b(a_3: ptr<function, vec3<f32>>, b_1: ptr<function, vec3<f32>>, n_4: ptr<function, vec3<f32>>) -> f32 {
@@ -15800,32 +15919,32 @@ fn LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b(a_3: ptr<function, vec3<f32>>
     var len_2: f32;
     var local_17: f32;
 
-    let _e215 = (*a_3);
     let _e216 = (*a_3);
-    ua = (_e215 / vec3(max(length(_e216), 0.000000000001f)));
-    let _e221 = (*b_1);
+    let _e217 = (*a_3);
+    ua = (_e216 / vec3(max(length(_e217), 0.000000000001f)));
     let _e222 = (*b_1);
-    ub = (_e221 / vec3(max(length(_e222), 0.000000000001f)));
-    let _e227 = ua;
-    let _e228 = ub;
-    angle_2 = acos(clamp(dot(_e227, _e228), -1f, 1f));
-    let _e232 = ua;
-    let _e233 = ub;
-    axis_1 = cross(_e232, _e233);
-    let _e235 = axis_1;
-    len_2 = length(_e235);
-    let _e237 = len_2;
-    if (_e237 > 0.000001f) {
-        let _e239 = angle_2;
-        let _e240 = axis_1;
-        let _e241 = (*n_4);
-        let _e244 = len_2;
-        local_17 = ((_e239 * dot(_e240, _e241)) / _e244);
+    let _e223 = (*b_1);
+    ub = (_e222 / vec3(max(length(_e223), 0.000000000001f)));
+    let _e228 = ua;
+    let _e229 = ub;
+    angle_2 = acos(clamp(dot(_e228, _e229), -1f, 1f));
+    let _e233 = ua;
+    let _e234 = ub;
+    axis_1 = cross(_e233, _e234);
+    let _e236 = axis_1;
+    len_2 = length(_e236);
+    let _e238 = len_2;
+    if (_e238 > 0.000001f) {
+        let _e240 = angle_2;
+        let _e241 = axis_1;
+        let _e242 = (*n_4);
+        let _e245 = len_2;
+        local_17 = ((_e240 * dot(_e241, _e242)) / _e245);
     } else {
         local_17 = 0f;
     }
-    let _e246 = local_17;
-    return _e246;
+    let _e247 = local_17;
+    return _e247;
 }
 
 fn RectangleFormFactor_u0028_vf3_u005b_4_u005d_u003b_vf3_u003b(corners_1: ptr<function, array<vec3<f32>, 4>>, n_5: ptr<function, vec3<f32>>) -> f32 {
@@ -15856,98 +15975,98 @@ fn RectangleFormFactor_u0028_vf3_u005b_4_u005d_u003b_vf3_u003b(corners_1: ptr<fu
     entry = vec3<f32>(0f, 0f, 0f);
     i_8 = 0i;
     loop {
-        let _e229 = i_8;
-        if (_e229 < 4i) {
-            let _e231 = i_8;
-            let _e233 = (*corners_1)[_e231];
-            a_4 = _e233;
-            let _e234 = i_8;
-            if (_e234 == 3i) {
+        let _e230 = i_8;
+        if (_e230 < 4i) {
+            let _e232 = i_8;
+            let _e234 = (*corners_1)[_e232];
+            a_4 = _e234;
+            let _e235 = i_8;
+            if (_e235 == 3i) {
                 local_18 = 0i;
             } else {
-                let _e236 = i_8;
-                local_18 = (_e236 + 1i);
-            }
-            let _e238 = local_18;
-            let _e240 = (*corners_1)[_e238];
-            b_2 = _e240;
-            let _e241 = a_4;
-            let _e242 = (*n_5);
-            ha = dot(_e241, _e242);
-            let _e244 = b_2;
-            let _e245 = (*n_5);
-            hb = dot(_e244, _e245);
-            let _e247 = ha;
-            let _e248 = hb;
-            d_4 = (_e247 - _e248);
-            let _e250 = a_4;
-            let _e251 = b_2;
-            let _e252 = a_4;
-            let _e254 = d_4;
-            if (abs(_e254) > 0.000000000001f) {
-                let _e257 = ha;
-                let _e258 = d_4;
-                local_19 = (_e257 / _e258);
+                let _e237 = i_8;
+                local_18 = (_e237 + 1i);
+            }
+            let _e239 = local_18;
+            let _e241 = (*corners_1)[_e239];
+            b_2 = _e241;
+            let _e242 = a_4;
+            let _e243 = (*n_5);
+            ha = dot(_e242, _e243);
+            let _e245 = b_2;
+            let _e246 = (*n_5);
+            hb = dot(_e245, _e246);
+            let _e248 = ha;
+            let _e249 = hb;
+            d_4 = (_e248 - _e249);
+            let _e251 = a_4;
+            let _e252 = b_2;
+            let _e253 = a_4;
+            let _e255 = d_4;
+            if (abs(_e255) > 0.000000000001f) {
+                let _e258 = ha;
+                let _e259 = d_4;
+                local_19 = (_e258 / _e259);
             } else {
                 local_19 = 0f;
             }
-            let _e260 = local_19;
-            q = (_e250 + ((_e251 - _e252) * _e260));
-            let _e263 = ha;
-            aAbove = (_e263 > 0f);
-            let _e265 = hb;
-            bAbove = (_e265 > 0f);
-            let _e267 = aAbove;
-            let _e268 = bAbove;
-            if (_e267 || _e268) {
-                let _e270 = aAbove;
-                let _e271 = a_4;
-                let _e272 = q;
-                let _e275 = bAbove;
-                let _e276 = b_2;
-                let _e277 = q;
-                param_116 = select(_e272, _e271, vec3(_e270));
-                param_117 = select(_e277, _e276, vec3(_e275));
-                let _e280 = (*n_5);
-                param_118 = _e280;
-                let _e281 = LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b((&param_116), (&param_117), (&param_118));
-                local_20 = _e281;
+            let _e261 = local_19;
+            q = (_e251 + ((_e252 - _e253) * _e261));
+            let _e264 = ha;
+            aAbove = (_e264 > 0f);
+            let _e266 = hb;
+            bAbove = (_e266 > 0f);
+            let _e268 = aAbove;
+            let _e269 = bAbove;
+            if (_e268 || _e269) {
+                let _e271 = aAbove;
+                let _e272 = a_4;
+                let _e273 = q;
+                let _e276 = bAbove;
+                let _e277 = b_2;
+                let _e278 = q;
+                param_116 = select(_e273, _e272, vec3(_e271));
+                param_117 = select(_e278, _e277, vec3(_e276));
+                let _e281 = (*n_5);
+                param_118 = _e281;
+                let _e282 = LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b((&param_116), (&param_117), (&param_118));
+                local_20 = _e282;
             } else {
                 local_20 = 0f;
             }
-            let _e282 = local_20;
-            let _e283 = total;
-            total = (_e283 + _e282);
-            let _e285 = aAbove;
-            let _e286 = bAbove;
-            let _e289 = q;
-            let _e290 = exit;
-            exit = select(_e290, _e289, vec3((_e285 && !(_e286))));
-            let _e293 = aAbove;
-            let _e295 = bAbove;
-            let _e297 = q;
-            let _e298 = entry;
-            entry = select(_e298, _e297, vec3((!(_e293) && _e295)));
+            let _e283 = local_20;
+            let _e284 = total;
+            total = (_e284 + _e283);
+            let _e286 = aAbove;
+            let _e287 = bAbove;
+            let _e290 = q;
+            let _e291 = exit;
+            exit = select(_e291, _e290, vec3((_e286 && !(_e287))));
+            let _e294 = aAbove;
+            let _e296 = bAbove;
+            let _e298 = q;
+            let _e299 = entry;
+            entry = select(_e299, _e298, vec3((!(_e294) && _e296)));
             continue;
         } else {
             break;
         }
         continuing {
-            let _e301 = i_8;
-            i_8 = (_e301 + 1i);
+            let _e302 = i_8;
+            i_8 = (_e302 + 1i);
         }
     }
-    let _e303 = exit;
-    param_119 = _e303;
-    let _e304 = entry;
-    param_120 = _e304;
-    let _e305 = (*n_5);
-    param_121 = _e305;
-    let _e306 = LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b((&param_119), (&param_120), (&param_121));
-    let _e307 = total;
-    total = (_e307 + _e306);
-    let _e309 = total;
-    return max((-(_e309) * 0.5f), 0f);
+    let _e304 = exit;
+    param_119 = _e304;
+    let _e305 = entry;
+    param_120 = _e305;
+    let _e306 = (*n_5);
+    param_121 = _e306;
+    let _e307 = LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b((&param_119), (&param_120), (&param_121));
+    let _e308 = total;
+    total = (_e308 + _e307);
+    let _e310 = total;
+    return max((-(_e310) * 0.5f), 0f);
 }
 
 fn LightListLane_u0028_vf4_u003b_i1_u003b(four: ptr<function, vec4<f32>>, slot_1: ptr<function, i32>) -> f32 {
@@ -15956,91 +16075,91 @@ fn LightListLane_u0028_vf4_u003b_i1_u003b(four: ptr<function, vec4<f32>>, slot_1
     var local_22: f32;
     var local_23: f32;
 
-    let _e212 = (*slot_1);
     let _e213 = (*slot_1);
-    lane = (_e212 - ((_e213 / 4i) * 4i));
-    let _e217 = lane;
-    if (_e217 == 0i) {
-        let _e220 = (*four)[0u];
-        local_21 = _e220;
-    } else {
-        let _e221 = lane;
-        if (_e221 == 1i) {
-            let _e224 = (*four)[1u];
-            local_22 = _e224;
+    let _e214 = (*slot_1);
+    lane = (_e213 - ((_e214 / 4i) * 4i));
+    let _e218 = lane;
+    if (_e218 == 0i) {
+        let _e221 = (*four)[0u];
+        local_21 = _e221;
+    } else {
+        let _e222 = lane;
+        if (_e222 == 1i) {
+            let _e225 = (*four)[1u];
+            local_22 = _e225;
         } else {
-            let _e225 = lane;
-            if (_e225 == 2i) {
-                let _e228 = (*four)[2u];
-                local_23 = _e228;
+            let _e226 = lane;
+            if (_e226 == 2i) {
+                let _e229 = (*four)[2u];
+                local_23 = _e229;
             } else {
-                let _e230 = (*four)[3u];
-                local_23 = _e230;
+                let _e231 = (*four)[3u];
+                local_23 = _e231;
             }
-            let _e231 = local_23;
-            local_22 = _e231;
+            let _e232 = local_23;
+            local_22 = _e232;
         }
-        let _e232 = local_22;
-        local_21 = _e232;
+        let _e233 = local_22;
+        local_21 = _e233;
     }
-    let _e233 = local_21;
-    return _e233;
+    let _e234 = local_21;
+    return _e234;
 }
 
 fn LightListScale_u0028_i1_u003b(slot_2: ptr<function, i32>) -> f32 {
     var param_122: vec4<f32>;
     var param_123: i32;
 
-    let _e209 = (*slot_2);
-    let _e213 = light_list_info.scales[(_e209 / 4i)];
-    param_122 = _e213;
-    let _e214 = (*slot_2);
-    param_123 = _e214;
-    let _e215 = LightListLane_u0028_vf4_u003b_i1_u003b((&param_122), (&param_123));
-    return _e215;
+    let _e210 = (*slot_2);
+    let _e214 = light_list_info.scales[(_e210 / 4i)];
+    param_122 = _e214;
+    let _e215 = (*slot_2);
+    param_123 = _e215;
+    let _e216 = LightListLane_u0028_vf4_u003b_i1_u003b((&param_122), (&param_123));
+    return _e216;
 }
 
 fn InSlots_u0028_f1_u003b(row: ptr<function, f32>) -> bool {
     var a_5: vec4<f32>;
     var b_3: vec4<f32>;
 
-    let _e211 = light_list_info.slot_rows[0i];
-    let _e212 = (*row);
-    a_5 = abs((_e211 - vec4(_e212)));
-    let _e218 = light_list_info.slot_rows[1i];
-    let _e219 = (*row);
-    b_3 = abs((_e218 - vec4(_e219)));
-    let _e224 = a_5[0u];
-    let _e226 = a_5[1u];
-    let _e229 = a_5[2u];
-    let _e231 = a_5[3u];
-    let _e235 = b_3[0u];
-    let _e237 = b_3[1u];
-    let _e240 = b_3[2u];
-    let _e242 = b_3[3u];
-    return (min(min(min(_e224, _e226), min(_e229, _e231)), min(min(_e235, _e237), min(_e240, _e242))) < 0.5f);
+    let _e212 = light_list_info.slot_rows[0i];
+    let _e213 = (*row);
+    a_5 = abs((_e212 - vec4(_e213)));
+    let _e219 = light_list_info.slot_rows[1i];
+    let _e220 = (*row);
+    b_3 = abs((_e219 - vec4(_e220)));
+    let _e225 = a_5[0u];
+    let _e227 = a_5[1u];
+    let _e230 = a_5[2u];
+    let _e232 = a_5[3u];
+    let _e236 = b_3[0u];
+    let _e238 = b_3[1u];
+    let _e241 = b_3[2u];
+    let _e243 = b_3[3u];
+    return (min(min(min(_e225, _e227), min(_e230, _e232)), min(min(_e236, _e238), min(_e241, _e243))) < 0.5f);
 }
 
 fn LightListRow_u0028_i1_u003b(slot_3: ptr<function, i32>) -> f32 {
     var param_124: vec4<f32>;
     var param_125: i32;
 
-    let _e209 = (*slot_3);
-    let _e213 = light_list_info.indices[(_e209 / 4i)];
-    param_124 = _e213;
-    let _e214 = (*slot_3);
-    param_125 = _e214;
-    let _e215 = LightListLane_u0028_vf4_u003b_i1_u003b((&param_124), (&param_125));
-    return _e215;
+    let _e210 = (*slot_3);
+    let _e214 = light_list_info.indices[(_e210 / 4i)];
+    param_124 = _e214;
+    let _e215 = (*slot_3);
+    param_125 = _e215;
+    let _e216 = LightListLane_u0028_vf4_u003b_i1_u003b((&param_124), (&param_125));
+    return _e216;
 }
 
 fn LightListTexel_u0028_f1_u003b_f1_u003b(texel_2: ptr<function, f32>, row_1: ptr<function, f32>) -> vec4<f32> {
-    let _e208 = (*texel_2);
-    let _e212 = light_list_info.list[1u];
-    let _e214 = (*row_1);
-    let _e218 = light_list_info.list[2u];
-    let _e221 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>(((_e208 + 0.5f) * _e212), ((_e214 + 0.5f) * _e218)), 0f);
-    return _e221;
+    let _e209 = (*texel_2);
+    let _e213 = light_list_info.list[1u];
+    let _e215 = (*row_1);
+    let _e219 = light_list_info.list[2u];
+    let _e222 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>(((_e209 + 0.5f) * _e213), ((_e215 + 0.5f) * _e219)), 0f);
+    return _e222;
 }
 
 fn ClusterRow_u0028_i1_u003b(slot_4: ptr<function, i32>) -> f32 {
@@ -16054,35 +16173,35 @@ fn ClusterRow_u0028_i1_u003b(slot_4: ptr<function, i32>) -> f32 {
     var param_128: vec4<f32>;
     var param_129: i32;
 
-    let _e216 = g_cluster_offset;
-    let _e217 = (*slot_4);
-    entry_1 = (_e216 + f32(_e217));
-    let _e220 = entry_1;
-    row_2 = floor((_e220 / 16f));
-    let _e223 = entry_1;
-    let _e224 = row_2;
-    within = (_e223 - (_e224 * 16f));
-    let _e227 = within;
-    texel_3 = floor((_e227 / 4f));
-    let _e232 = light_list_info.cluster_depth[3u];
-    let _e233 = row_2;
-    let _e235 = texel_3;
-    param_126 = _e235;
-    param_127 = (_e232 + _e233);
-    let _e236 = LightListTexel_u0028_f1_u003b_f1_u003b((&param_126), (&param_127));
-    four_1 = _e236;
-    let _e237 = within;
-    let _e238 = texel_3;
-    let _e243 = four_1;
-    param_128 = _e243;
-    param_129 = i32(((_e237 - (_e238 * 4f)) + 0.5f));
-    let _e244 = LightListLane_u0028_vf4_u003b_i1_u003b((&param_128), (&param_129));
-    return _e244;
+    let _e217 = g_cluster_offset;
+    let _e218 = (*slot_4);
+    entry_1 = (_e217 + f32(_e218));
+    let _e221 = entry_1;
+    row_2 = floor((_e221 / 16f));
+    let _e224 = entry_1;
+    let _e225 = row_2;
+    within = (_e224 - (_e225 * 16f));
+    let _e228 = within;
+    texel_3 = floor((_e228 / 4f));
+    let _e233 = light_list_info.cluster_depth[3u];
+    let _e234 = row_2;
+    let _e236 = texel_3;
+    param_126 = _e236;
+    param_127 = (_e233 + _e234);
+    let _e237 = LightListTexel_u0028_f1_u003b_f1_u003b((&param_126), (&param_127));
+    four_1 = _e237;
+    let _e238 = within;
+    let _e239 = texel_3;
+    let _e244 = four_1;
+    param_128 = _e244;
+    param_129 = i32(((_e238 - (_e239 * 4f)) + 0.5f));
+    let _e245 = LightListLane_u0028_vf4_u003b_i1_u003b((&param_128), (&param_129));
+    return _e245;
 }
 
 fn Clustered_u0028_() -> bool {
-    let _e208 = light_list_info.cluster_grid[3u];
-    return (_e208 > 0.5f);
+    let _e209 = light_list_info.cluster_grid[3u];
+    return (_e209 > 0.5f);
 }
 
 fn SampleLight_u0028_i1_u003b_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(index_2: ptr<function, i32>, s_6: ptr<function, Surface>) -> LightSample {
@@ -16142,275 +16261,275 @@ fn SampleLight_u0028_i1_u003b_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_
 
     light_3.integrated = 0f;
     light_3.ltc = vec3<f32>(0f, 0f, 0f);
-    let _e263 = (*index_2);
-    if (_e263 < 8i) {
-        let _e265 = (*index_2);
-        let _e268 = frag_info.light_position[_e265];
-        position = _e268;
-        let _e269 = (*index_2);
-        let _e272 = frag_info.light_color[_e269];
-        color_1 = _e272;
-        let _e273 = (*index_2);
-        let _e276 = frag_info.light_direction[_e273];
-        direction = _e276;
-        let _e277 = (*index_2);
-        let _e280 = frag_info.light_cone[_e277];
-        cone = _e280;
-    } else {
-        let _e281 = (*index_2);
-        slot_5 = (_e281 - 8i);
-        let _e283 = Clustered_u0028_();
-        clustered = _e283;
-        let _e284 = clustered;
-        if _e284 {
-            let _e285 = slot_5;
-            param_130 = _e285;
-            let _e286 = ClusterRow_u0028_i1_u003b((&param_130));
-            local_24 = _e286;
+    let _e264 = (*index_2);
+    if (_e264 < 8i) {
+        let _e266 = (*index_2);
+        let _e269 = frag_info.light_position[_e266];
+        position = _e269;
+        let _e270 = (*index_2);
+        let _e273 = frag_info.light_color[_e270];
+        color_1 = _e273;
+        let _e274 = (*index_2);
+        let _e277 = frag_info.light_direction[_e274];
+        direction = _e277;
+        let _e278 = (*index_2);
+        let _e281 = frag_info.light_cone[_e278];
+        cone = _e281;
+    } else {
+        let _e282 = (*index_2);
+        slot_5 = (_e282 - 8i);
+        let _e284 = Clustered_u0028_();
+        clustered = _e284;
+        let _e285 = clustered;
+        if _e285 {
+            let _e286 = slot_5;
+            param_130 = _e286;
+            let _e287 = ClusterRow_u0028_i1_u003b((&param_130));
+            local_24 = _e287;
         } else {
-            let _e287 = slot_5;
-            param_131 = _e287;
-            let _e288 = LightListRow_u0028_i1_u003b((&param_131));
-            local_24 = _e288;
-        }
-        let _e289 = local_24;
-        listRow = _e289;
-        let _e290 = listRow;
-        let _e294 = light_list_info.list[2u];
-        v_2 = ((_e290 + 0.5f) * _e294);
-        let _e298 = light_list_info.list[1u];
-        u_1 = _e298;
-        let _e299 = u_1;
-        let _e301 = v_2;
-        let _e303 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((0.5f * _e299), _e301), 0f);
-        position = _e303;
-        let _e304 = u_1;
-        let _e306 = v_2;
-        let _e308 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((1.5f * _e304), _e306), 0f);
-        color_1 = _e308;
-        let _e309 = u_1;
-        let _e311 = v_2;
-        let _e313 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((2.5f * _e309), _e311), 0f);
-        direction = _e313;
-        let _e314 = u_1;
-        let _e316 = v_2;
-        let _e318 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((3.5f * _e314), _e316), 0f);
-        cone = _e318;
-        let _e319 = clustered;
-        if _e319 {
-            let _e320 = listRow;
-            param_132 = _e320;
-            let _e321 = InSlots_u0028_f1_u003b((&param_132));
-            local_25 = select(1f, 0f, _e321);
+            let _e288 = slot_5;
+            param_131 = _e288;
+            let _e289 = LightListRow_u0028_i1_u003b((&param_131));
+            local_24 = _e289;
+        }
+        let _e290 = local_24;
+        listRow = _e290;
+        let _e291 = listRow;
+        let _e295 = light_list_info.list[2u];
+        v_2 = ((_e291 + 0.5f) * _e295);
+        let _e299 = light_list_info.list[1u];
+        u_1 = _e299;
+        let _e300 = u_1;
+        let _e302 = v_2;
+        let _e304 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((0.5f * _e300), _e302), 0f);
+        position = _e304;
+        let _e305 = u_1;
+        let _e307 = v_2;
+        let _e309 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((1.5f * _e305), _e307), 0f);
+        color_1 = _e309;
+        let _e310 = u_1;
+        let _e312 = v_2;
+        let _e314 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((2.5f * _e310), _e312), 0f);
+        direction = _e314;
+        let _e315 = u_1;
+        let _e317 = v_2;
+        let _e319 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((3.5f * _e315), _e317), 0f);
+        cone = _e319;
+        let _e320 = clustered;
+        if _e320 {
+            let _e321 = listRow;
+            param_132 = _e321;
+            let _e322 = InSlots_u0028_f1_u003b((&param_132));
+            local_25 = select(1f, 0f, _e322);
         } else {
-            let _e323 = slot_5;
-            param_133 = _e323;
-            let _e324 = LightListScale_u0028_i1_u003b((&param_133));
-            local_25 = _e324;
-        }
-        let _e325 = local_25;
-        let _e327 = color_1[3u];
-        color_1[3u] = (_e327 * _e325);
-    }
-    let _e331 = position[3u];
-    type_42 = _e331;
-    let _e332 = type_42;
-    if (_e332 > 2.5f) {
-        let _e334 = direction;
-        halfWidth_1 = _e334.xyz;
-        let _e336 = cone;
-        halfHeight_1 = _e336.xyz;
-        let _e338 = position;
-        let _e340 = v_world_position_1;
-        toCentre = (_e338.xyz - _e340);
-        let _e342 = toCentre;
-        let _e343 = halfWidth_1;
-        let _e345 = halfHeight_1;
-        corners_2[0i] = ((_e342 - _e343) - _e345);
-        let _e348 = toCentre;
-        let _e349 = halfWidth_1;
-        let _e351 = halfHeight_1;
-        corners_2[1i] = ((_e348 + _e349) - _e351);
-        let _e354 = toCentre;
-        let _e355 = halfWidth_1;
-        let _e357 = halfHeight_1;
-        corners_2[2i] = ((_e354 + _e355) + _e357);
-        let _e360 = toCentre;
-        let _e361 = halfWidth_1;
-        let _e363 = halfHeight_1;
-        corners_2[3i] = ((_e360 - _e361) + _e363);
-        let _e366 = toCentre;
-        let _e367 = halfWidth_1;
-        let _e368 = halfHeight_1;
-        behind = (dot(_e366, cross(_e367, _e368)) >= 0f);
-        let _e372 = behind;
-        if _e372 {
+            let _e324 = slot_5;
+            param_133 = _e324;
+            let _e325 = LightListScale_u0028_i1_u003b((&param_133));
+            local_25 = _e325;
+        }
+        let _e326 = local_25;
+        let _e328 = color_1[3u];
+        color_1[3u] = (_e328 * _e326);
+    }
+    let _e332 = position[3u];
+    type_42 = _e332;
+    let _e333 = type_42;
+    if (_e333 > 2.5f) {
+        let _e335 = direction;
+        halfWidth_1 = _e335.xyz;
+        let _e337 = cone;
+        halfHeight_1 = _e337.xyz;
+        let _e339 = position;
+        let _e341 = v_world_position_1;
+        toCentre = (_e339.xyz - _e341);
+        let _e343 = toCentre;
+        let _e344 = halfWidth_1;
+        let _e346 = halfHeight_1;
+        corners_2[0i] = ((_e343 - _e344) - _e346);
+        let _e349 = toCentre;
+        let _e350 = halfWidth_1;
+        let _e352 = halfHeight_1;
+        corners_2[1i] = ((_e349 + _e350) - _e352);
+        let _e355 = toCentre;
+        let _e356 = halfWidth_1;
+        let _e358 = halfHeight_1;
+        corners_2[2i] = ((_e355 + _e356) + _e358);
+        let _e361 = toCentre;
+        let _e362 = halfWidth_1;
+        let _e364 = halfHeight_1;
+        corners_2[3i] = ((_e361 - _e362) + _e364);
+        let _e367 = toCentre;
+        let _e368 = halfWidth_1;
+        let _e369 = halfHeight_1;
+        behind = (dot(_e367, cross(_e368, _e369)) >= 0f);
+        let _e373 = behind;
+        if _e373 {
             local_26 = 0f;
         } else {
-            let _e373 = corners_2;
-            param_134 = _e373;
-            let _e375 = (*s_6).n;
-            param_135 = _e375;
-            let _e376 = RectangleFormFactor_u0028_vf3_u005b_4_u005d_u003b_vf3_u003b((&param_134), (&param_135));
-            local_26 = _e376;
-        }
-        let _e377 = local_26;
-        formFactor = _e377;
-        let _e378 = halfWidth_1;
-        let _e379 = halfHeight_1;
-        area = (length(cross(_e378, _e379)) * 4f);
-        let _e383 = area;
-        if (_e383 > 0.000000001f) {
-            let _e385 = area;
-            local_27 = (1f / _e385);
+            let _e374 = corners_2;
+            param_134 = _e374;
+            let _e376 = (*s_6).n;
+            param_135 = _e376;
+            let _e377 = RectangleFormFactor_u0028_vf3_u005b_4_u005d_u003b_vf3_u003b((&param_134), (&param_135));
+            local_26 = _e377;
+        }
+        let _e378 = local_26;
+        formFactor = _e378;
+        let _e379 = halfWidth_1;
+        let _e380 = halfHeight_1;
+        area = (length(cross(_e379, _e380)) * 4f);
+        let _e384 = area;
+        if (_e384 > 0.000000001f) {
+            let _e386 = area;
+            local_27 = (1f / _e386);
         } else {
             local_27 = 0f;
         }
-        let _e387 = local_27;
-        radiance = _e387;
-        let _e388 = toCentre;
-        distance_2 = length(_e388);
-        let _e391 = direction[3u];
-        if (_e391 > 0f) {
-            let _e393 = distance_2;
-            let _e395 = direction[3u];
-            ratio_1 = (_e393 / _e395);
-            let _e397 = ratio_1;
+        let _e388 = local_27;
+        radiance = _e388;
+        let _e389 = toCentre;
+        distance_2 = length(_e389);
+        let _e392 = direction[3u];
+        if (_e392 > 0f) {
+            let _e394 = distance_2;
+            let _e396 = direction[3u];
+            ratio_1 = (_e394 / _e396);
             let _e398 = ratio_1;
-            let _e400 = ratio_1;
-            let _e402 = ratio_1;
-            window_1 = clamp((1f - (((_e397 * _e398) * _e400) * _e402)), 0f, 1f);
-            let _e406 = window_1;
+            let _e399 = ratio_1;
+            let _e401 = ratio_1;
+            let _e403 = ratio_1;
+            window_1 = clamp((1f - (((_e398 * _e399) * _e401) * _e403)), 0f, 1f);
             let _e407 = window_1;
-            let _e409 = radiance;
-            radiance = (_e409 * (_e406 * _e407));
-        }
-        let _e412 = (*s_6).v;
-        let _e415 = (*s_6).n;
-        mirror_1 = reflect(-(_e412), _e415);
-        let _e417 = position;
-        param_136 = _e417.xyz;
-        let _e419 = halfWidth_1;
-        param_137 = _e419;
-        let _e420 = halfHeight_1;
-        param_138 = _e420;
-        let _e421 = v_world_position_1;
-        param_139 = _e421;
-        let _e422 = mirror_1;
-        param_140 = _e422;
-        let _e423 = RectangleClosestPoint_u0028_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b((&param_136), (&param_137), (&param_138), (&param_139), (&param_140));
-        representative = _e423;
-        let _e424 = representative;
-        let _e425 = v_world_position_1;
-        toPoint = (_e424 - _e425);
-        let _e427 = toPoint;
-        pointDistance = length(_e427);
-        let _e429 = pointDistance;
-        if (_e429 > 0.000001f) {
-            let _e431 = toPoint;
-            let _e432 = pointDistance;
-            local_28 = (_e431 / vec3(_e432));
+            let _e408 = window_1;
+            let _e410 = radiance;
+            radiance = (_e410 * (_e407 * _e408));
+        }
+        let _e413 = (*s_6).v;
+        let _e416 = (*s_6).n;
+        mirror_1 = reflect(-(_e413), _e416);
+        let _e418 = position;
+        param_136 = _e418.xyz;
+        let _e420 = halfWidth_1;
+        param_137 = _e420;
+        let _e421 = halfHeight_1;
+        param_138 = _e421;
+        let _e422 = v_world_position_1;
+        param_139 = _e422;
+        let _e423 = mirror_1;
+        param_140 = _e423;
+        let _e424 = RectangleClosestPoint_u0028_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b((&param_136), (&param_137), (&param_138), (&param_139), (&param_140));
+        representative = _e424;
+        let _e425 = representative;
+        let _e426 = v_world_position_1;
+        toPoint = (_e425 - _e426);
+        let _e428 = toPoint;
+        pointDistance = length(_e428);
+        let _e430 = pointDistance;
+        if (_e430 > 0.000001f) {
+            let _e432 = toPoint;
+            let _e433 = pointDistance;
+            local_28 = (_e432 / vec3(_e433));
         } else {
-            let _e436 = (*s_6).n;
-            local_28 = _e436;
-        }
-        let _e437 = local_28;
-        light_3.l = _e437;
-        let _e440 = light_3.l;
-        let _e442 = (*s_6).v;
-        light_3.h = normalize((_e440 + _e442));
-        let _e446 = formFactor;
-        light_3.n_dot_l = _e446;
-        let _e449 = (*s_6).n;
-        let _e451 = light_3.h;
-        light_3.n_dot_h = max(dot(_e449, _e451), 0f);
-        let _e456 = (*s_6).v;
-        let _e458 = light_3.h;
-        light_3.v_dot_h = max(dot(_e456, _e458), 0f);
-        let _e462 = color_1;
-        let _e465 = color_1[3u];
-        let _e467 = radiance;
-        light_3.radiance = ((_e462.xyz * _e465) * _e467);
+            let _e437 = (*s_6).n;
+            local_28 = _e437;
+        }
+        let _e438 = local_28;
+        light_3.l = _e438;
+        let _e441 = light_3.l;
+        let _e443 = (*s_6).v;
+        light_3.h = normalize((_e441 + _e443));
+        let _e447 = formFactor;
+        light_3.n_dot_l = _e447;
+        let _e450 = (*s_6).n;
+        let _e452 = light_3.h;
+        light_3.n_dot_h = max(dot(_e450, _e452), 0f);
+        let _e457 = (*s_6).v;
+        let _e459 = light_3.h;
+        light_3.v_dot_h = max(dot(_e457, _e459), 0f);
+        let _e463 = color_1;
+        let _e466 = color_1[3u];
+        let _e468 = radiance;
+        light_3.radiance = ((_e463.xyz * _e466) * _e468);
         light_3.integrated = 1f;
-        let _e472 = (*s_6).n;
-        param_141 = _e472;
-        let _e474 = (*s_6).v;
-        param_142 = _e474;
-        let _e476 = (*s_6).roughness;
-        param_143 = _e476;
-        let _e477 = corners_2;
-        param_144 = _e477;
-        let _e478 = LtcRectangle_u0028_vf3_u003b_vf3_u003b_f1_u003b_vf3_u005b_4_u005d_u003b((&param_141), (&param_142), (&param_143), (&param_144));
-        light_3.ltc = _e478;
-        let _e480 = light_3;
-        return _e480;
-    }
-    let _e481 = direction;
-    aim = normalize(_e481.xyz);
+        let _e473 = (*s_6).n;
+        param_141 = _e473;
+        let _e475 = (*s_6).v;
+        param_142 = _e475;
+        let _e477 = (*s_6).roughness;
+        param_143 = _e477;
+        let _e478 = corners_2;
+        param_144 = _e478;
+        let _e479 = LtcRectangle_u0028_vf3_u003b_vf3_u003b_f1_u003b_vf3_u005b_4_u005d_u003b((&param_141), (&param_142), (&param_143), (&param_144));
+        light_3.ltc = _e479;
+        let _e481 = light_3;
+        return _e481;
+    }
+    let _e482 = direction;
+    aim = normalize(_e482.xyz);
     attenuation_1 = 1f;
-    let _e484 = type_42;
-    if (_e484 < 0.5f) {
-        let _e486 = aim;
-        light_3.l = -(_e486);
-    } else {
-        let _e489 = position;
-        let _e491 = v_world_position_1;
-        toLight_1 = (_e489.xyz - _e491);
-        let _e493 = toLight_1;
-        distance_3 = length(_e493);
-        let _e495 = distance_3;
-        if (_e495 < 0.000001f) {
-            let _e498 = (*s_6).n;
-            light_3.l = _e498;
-            let _e501 = (*s_6).n;
-            light_3.h = _e501;
+    let _e485 = type_42;
+    if (_e485 < 0.5f) {
+        let _e487 = aim;
+        light_3.l = -(_e487);
+    } else {
+        let _e490 = position;
+        let _e492 = v_world_position_1;
+        toLight_1 = (_e490.xyz - _e492);
+        let _e494 = toLight_1;
+        distance_3 = length(_e494);
+        let _e496 = distance_3;
+        if (_e496 < 0.000001f) {
+            let _e499 = (*s_6).n;
+            light_3.l = _e499;
+            let _e502 = (*s_6).n;
+            light_3.h = _e502;
             light_3.radiance = vec3<f32>(0f, 0f, 0f);
             light_3.n_dot_l = 0f;
             light_3.n_dot_h = 0f;
             light_3.v_dot_h = 0f;
-            let _e507 = light_3;
-            return _e507;
-        }
-        let _e508 = toLight_1;
-        let _e509 = distance_3;
-        light_3.l = (_e508 / vec3(_e509));
-        let _e513 = distance_3;
-        param_145 = _e513;
-        let _e515 = direction[3u];
-        param_146 = _e515;
-        let _e516 = PunctualAttenuation_u0028_f1_u003b_f1_u003b((&param_145), (&param_146));
-        attenuation_1 = _e516;
-        let _e517 = type_42;
-        if (_e517 > 1.5f) {
-            let _e519 = aim;
-            let _e521 = light_3.l;
-            cosAngle = dot(_e519, -(_e521));
-            let _e524 = cosAngle;
-            let _e526 = cone[1u];
-            let _e529 = cone[0u];
-            let _e531 = cone[1u];
-            let _e535 = attenuation_1;
-            attenuation_1 = (_e535 * clamp(((_e524 - _e526) / (_e529 - _e531)), 0f, 1f));
-        }
-    }
-    let _e538 = light_3.l;
-    let _e540 = (*s_6).v;
-    light_3.h = normalize((_e538 + _e540));
-    let _e545 = (*s_6).n;
-    let _e547 = light_3.l;
-    light_3.n_dot_l = max(dot(_e545, _e547), 0f);
-    let _e552 = (*s_6).n;
-    let _e554 = light_3.h;
-    light_3.n_dot_h = max(dot(_e552, _e554), 0f);
-    let _e559 = (*s_6).v;
-    let _e561 = light_3.h;
-    light_3.v_dot_h = max(dot(_e559, _e561), 0f);
-    let _e565 = color_1;
-    let _e568 = color_1[3u];
-    let _e570 = attenuation_1;
-    light_3.radiance = ((_e565.xyz * _e568) * _e570);
-    let _e573 = light_3;
-    return _e573;
+            let _e508 = light_3;
+            return _e508;
+        }
+        let _e509 = toLight_1;
+        let _e510 = distance_3;
+        light_3.l = (_e509 / vec3(_e510));
+        let _e514 = distance_3;
+        param_145 = _e514;
+        let _e516 = direction[3u];
+        param_146 = _e516;
+        let _e517 = PunctualAttenuation_u0028_f1_u003b_f1_u003b((&param_145), (&param_146));
+        attenuation_1 = _e517;
+        let _e518 = type_42;
+        if (_e518 > 1.5f) {
+            let _e520 = aim;
+            let _e522 = light_3.l;
+            cosAngle = dot(_e520, -(_e522));
+            let _e525 = cosAngle;
+            let _e527 = cone[1u];
+            let _e530 = cone[0u];
+            let _e532 = cone[1u];
+            let _e536 = attenuation_1;
+            attenuation_1 = (_e536 * clamp(((_e525 - _e527) / (_e530 - _e532)), 0f, 1f));
+        }
+    }
+    let _e539 = light_3.l;
+    let _e541 = (*s_6).v;
+    light_3.h = normalize((_e539 + _e541));
+    let _e546 = (*s_6).n;
+    let _e548 = light_3.l;
+    light_3.n_dot_l = max(dot(_e546, _e548), 0f);
+    let _e553 = (*s_6).n;
+    let _e555 = light_3.h;
+    light_3.n_dot_h = max(dot(_e553, _e555), 0f);
+    let _e560 = (*s_6).v;
+    let _e562 = light_3.h;
+    light_3.v_dot_h = max(dot(_e560, _e562), 0f);
+    let _e566 = color_1;
+    let _e569 = color_1[3u];
+    let _e571 = attenuation_1;
+    light_3.radiance = ((_e566.xyz * _e569) * _e571);
+    let _e574 = light_3;
+    return _e574;
 }
 
 fn FindCluster_u0028_vf3_u003b(world_3: ptr<function, vec3<f32>>) {
@@ -16428,58 +16547,58 @@ fn FindCluster_u0028_vf3_u003b(world_3: ptr<function, vec3<f32>>) {
     var param_147: f32;
     var param_148: f32;
 
-    let _e221 = light_list_info.cluster_view_projection;
-    let _e222 = (*world_3);
-    clip_1 = (_e221 * vec4<f32>(_e222.x, _e222.y, _e222.z, 1f));
-    let _e228 = clip_1;
-    let _e231 = clip_1[3u];
-    ndc_1 = (_e228.xy / vec2(max(_e231, 0.000001f)));
-    let _e236 = light_list_info.cluster_grid;
-    grid = _e236.xyz;
-    let _e240 = light_list_info.cluster_depth[0u];
-    near_1 = _e240;
-    let _e242 = ndc_1[0u];
-    let _e246 = grid[0u];
-    let _e250 = grid[0u];
-    tx = clamp(floor((((_e242 * 0.5f) + 0.5f) * _e246)), 0f, (_e250 - 1f));
-    let _e254 = ndc_1[1u];
-    let _e258 = grid[1u];
-    let _e262 = grid[1u];
-    ty = clamp(floor((((_e254 * 0.5f) + 0.5f) * _e258)), 0f, (_e262 - 1f));
-    let _e266 = clip_1[3u];
-    let _e267 = near_1;
-    if (_e266 <= _e267) {
+    let _e222 = light_list_info.cluster_view_projection;
+    let _e223 = (*world_3);
+    clip_1 = (_e222 * vec4<f32>(_e223.x, _e223.y, _e223.z, 1f));
+    let _e229 = clip_1;
+    let _e232 = clip_1[3u];
+    ndc_1 = (_e229.xy / vec2(max(_e232, 0.000001f)));
+    let _e237 = light_list_info.cluster_grid;
+    grid = _e237.xyz;
+    let _e241 = light_list_info.cluster_depth[0u];
+    near_1 = _e241;
+    let _e243 = ndc_1[0u];
+    let _e247 = grid[0u];
+    let _e251 = grid[0u];
+    tx = clamp(floor((((_e243 * 0.5f) + 0.5f) * _e247)), 0f, (_e251 - 1f));
+    let _e255 = ndc_1[1u];
+    let _e259 = grid[1u];
+    let _e263 = grid[1u];
+    ty = clamp(floor((((_e255 * 0.5f) + 0.5f) * _e259)), 0f, (_e263 - 1f));
+    let _e267 = clip_1[3u];
+    let _e268 = near_1;
+    if (_e267 <= _e268) {
         local_29 = 0f;
     } else {
-        let _e270 = clip_1[3u];
-        let _e271 = near_1;
-        let _e276 = light_list_info.cluster_depth[1u];
-        let _e280 = grid[2u];
-        local_29 = clamp(floor((log((_e270 / _e271)) * _e276)), 0f, (_e280 - 1f));
-    }
-    let _e283 = local_29;
-    tz = _e283;
-    let _e284 = tx;
-    let _e285 = ty;
-    let _e287 = grid[0u];
-    let _e290 = tz;
-    let _e292 = grid[0u];
-    let _e295 = grid[1u];
-    cell = ((_e284 + (_e285 * _e287)) + ((_e290 * _e292) * _e295));
-    let _e298 = cell;
-    row_3 = floor((_e298 / 4f));
-    let _e301 = cell;
-    let _e302 = row_3;
-    let _e307 = light_list_info.cluster_depth[2u];
-    let _e308 = row_3;
-    param_147 = (_e301 - (_e302 * 4f));
-    param_148 = (_e307 + _e308);
-    let _e310 = LightListTexel_u0028_f1_u003b_f1_u003b((&param_147), (&param_148));
-    header = _e310;
-    let _e312 = header[0u];
-    g_cluster_offset = _e312;
-    let _e314 = header[1u];
-    g_cluster_count = _e314;
+        let _e271 = clip_1[3u];
+        let _e272 = near_1;
+        let _e277 = light_list_info.cluster_depth[1u];
+        let _e281 = grid[2u];
+        local_29 = clamp(floor((log((_e271 / _e272)) * _e277)), 0f, (_e281 - 1f));
+    }
+    let _e284 = local_29;
+    tz = _e284;
+    let _e285 = tx;
+    let _e286 = ty;
+    let _e288 = grid[0u];
+    let _e291 = tz;
+    let _e293 = grid[0u];
+    let _e296 = grid[1u];
+    cell = ((_e285 + (_e286 * _e288)) + ((_e291 * _e293) * _e296));
+    let _e299 = cell;
+    row_3 = floor((_e299 / 4f));
+    let _e302 = cell;
+    let _e303 = row_3;
+    let _e308 = light_list_info.cluster_depth[2u];
+    let _e309 = row_3;
+    param_147 = (_e302 - (_e303 * 4f));
+    param_148 = (_e308 + _e309);
+    let _e311 = LightListTexel_u0028_f1_u003b_f1_u003b((&param_147), (&param_148));
+    header = _e311;
+    let _e313 = header[0u];
+    g_cluster_offset = _e313;
+    let _e315 = header[1u];
+    g_cluster_count = _e315;
     return;
 }
 
@@ -16487,19 +16606,19 @@ fn LightCount_u0028_() -> i32 {
     var tail: f32;
     var param_149: vec3<f32>;
 
-    let _e210 = light_list_info.list[0u];
-    tail = _e210;
-    let _e211 = Clustered_u0028_();
-    if _e211 {
-        let _e212 = v_world_position_1;
-        param_149 = _e212;
+    let _e211 = light_list_info.list[0u];
+    tail = _e211;
+    let _e212 = Clustered_u0028_();
+    if _e212 {
+        let _e213 = v_world_position_1;
+        param_149 = _e213;
         FindCluster_u0028_vf3_u003b((&param_149));
-        let _e213 = g_cluster_count;
-        tail = _e213;
+        let _e214 = g_cluster_count;
+        tail = _e214;
     }
-    let _e216 = frag_info.frame_params[1u];
-    let _e220 = tail;
-    return (clamp(i32((_e216 + 0.5f)), 0i, 8i) + clamp(i32((_e220 + 0.5f)), 0i, 24i));
+    let _e217 = frag_info.frame_params[1u];
+    let _e221 = tail;
+    return (clamp(i32((_e217 + 0.5f)), 0i, 8i) + clamp(i32((_e221 + 0.5f)), 0i, 24i));
 }
 
 fn AccumulateLights_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_7: ptr<function, Surface>) -> vec3<f32> {
@@ -16522,89 +16641,89 @@ fn AccumulateLights_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002
     var param_160: LightSample;
 
     total_1 = vec3<f32>(0f, 0f, 0f);
-    let _e224 = LightCount_u0028_();
-    count_1 = _e224;
+    let _e225 = LightCount_u0028_();
+    count_1 = _e225;
     i_9 = 0i;
     loop {
-        let _e225 = i_9;
-        if (_e225 < 32i) {
-            let _e227 = i_9;
-            let _e228 = count_1;
-            if (_e227 >= _e228) {
+        let _e226 = i_9;
+        if (_e226 < 32i) {
+            let _e228 = i_9;
+            let _e229 = count_1;
+            if (_e228 >= _e229) {
                 break;
             }
-            let _e230 = i_9;
-            param_150 = _e230;
-            let _e231 = (*s_7);
-            param_151 = _e231;
-            let _e232 = SampleLight_u0028_i1_u003b_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_150), (&param_151));
-            light_4 = _e232;
-            let _e234 = light_4.n_dot_l;
-            if (_e234 <= 0f) {
+            let _e231 = i_9;
+            param_150 = _e231;
+            let _e232 = (*s_7);
+            param_151 = _e232;
+            let _e233 = SampleLight_u0028_i1_u003b_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_150), (&param_151));
+            light_4 = _e233;
+            let _e235 = light_4.n_dot_l;
+            if (_e235 <= 0f) {
                 continue;
             }
             light_transmittance = vec3<f32>(1f, 1f, 1f);
-            let _e236 = i_9;
-            param_152 = _e236;
-            let _e237 = LightHasShadow_u0028_i1_u003b((&param_152));
-            if _e237 {
-                let _e238 = (*s_7);
-                param_153 = _e238;
-                let _e239 = light_4;
-                param_154 = _e239;
-                let _e240 = i_9;
-                param_155 = _e240;
-                let _e241 = LightVisibility_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b_i1_u003b((&param_153), (&param_154), (&param_155));
-                let _e242 = v_world_position_1;
-                param_156 = _e242;
-                let _e244 = (*s_7).n;
-                param_157 = _e244;
-                let _e245 = i_9;
-                param_158 = _e245;
-                let _e246 = PointShadowFactor_u0028_vf3_u003b_vf3_u003b_i1_u003b((&param_156), (&param_157), (&param_158));
-                local_30 = (_e241 * _e246);
+            let _e237 = i_9;
+            param_152 = _e237;
+            let _e238 = LightHasShadow_u0028_i1_u003b((&param_152));
+            if _e238 {
+                let _e239 = (*s_7);
+                param_153 = _e239;
+                let _e240 = light_4;
+                param_154 = _e240;
+                let _e241 = i_9;
+                param_155 = _e241;
+                let _e242 = LightVisibility_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b_i1_u003b((&param_153), (&param_154), (&param_155));
+                let _e243 = v_world_position_1;
+                param_156 = _e243;
+                let _e245 = (*s_7).n;
+                param_157 = _e245;
+                let _e246 = i_9;
+                param_158 = _e246;
+                let _e247 = PointShadowFactor_u0028_vf3_u003b_vf3_u003b_i1_u003b((&param_156), (&param_157), (&param_158));
+                local_30 = (_e242 * _e247);
             } else {
                 local_30 = 1f;
             }
-            let _e248 = local_30;
-            visibility = _e248;
-            let _e249 = visibility;
-            if (_e249 <= 0f) {
+            let _e249 = local_30;
+            visibility = _e249;
+            let _e250 = visibility;
+            if (_e250 <= 0f) {
                 continue;
             }
-            let _e251 = (*s_7);
-            param_159 = _e251;
-            let _e252 = light_4;
-            param_160 = _e252;
-            let _e253 = ShadeLight_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b((&param_159), (&param_160));
-            let _e255 = light_4.radiance;
-            let _e258 = light_4.n_dot_l;
-            let _e260 = visibility;
-            let _e262 = light_transmittance;
-            let _e264 = total_1;
-            total_1 = (_e264 + ((((_e253 * _e255) * _e258) * _e260) * _e262));
+            let _e252 = (*s_7);
+            param_159 = _e252;
+            let _e253 = light_4;
+            param_160 = _e253;
+            let _e254 = ShadeLight_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b((&param_159), (&param_160));
+            let _e256 = light_4.radiance;
+            let _e259 = light_4.n_dot_l;
+            let _e261 = visibility;
+            let _e263 = light_transmittance;
+            let _e265 = total_1;
+            total_1 = (_e265 + ((((_e254 * _e256) * _e259) * _e261) * _e263));
             continue;
         } else {
             break;
         }
         continuing {
-            let _e266 = i_9;
-            i_9 = (_e266 + 1i);
+            let _e267 = i_9;
+            i_9 = (_e267 + 1i);
         }
     }
-    let _e268 = total_1;
-    return _e268;
+    let _e269 = total_1;
+    return _e269;
 }
 
 fn SampleLightmap_u0028_() -> vec3<f32> {
     var texel_4: vec4<f32>;
 
-    let _e207 = v_lightmap_uv_1;
-    let _e208 = textureSample(lightmap_texture_tex, lightmap_texture_smp, _e207);
-    texel_4 = _e208;
-    let _e209 = texel_4;
-    let _e212 = texel_4[3u];
-    return ((_e209.xyz * _e212) * 8f);
+    let _e208 = v_lightmap_uv_1;
+    let _e209 = textureSample(lightmap_texture_tex, lightmap_texture_smp, _e208);
+    texel_4 = _e209;
+    let _e210 = texel_4;
+    let _e213 = texel_4[3u];
+    return ((_e210.xyz * _e213) * 8f);
 }
 
 fn EonAlbedo_u0028_vf3_u003b_f1_u003b_f1_u003b(rho_2: ptr<function, vec3<f32>>, r_4: ptr<function, f32>, mu_1: ptr<function, f32>) -> vec3<f32> {
@@ -16615,43 +16734,43 @@ fn EonAlbedo_u0028_vf3_u003b_f1_u003b_f1_u003b(rho_2: ptr<function, vec3<f32>>,
     var param_164: vec3<f32>;
     var param_165: f32;
 
-    let _e215 = (*mu_1);
-    param_161 = _e215;
-    let _e216 = (*r_4);
-    param_162 = _e216;
-    let _e217 = FonAlbedo_u0028_f1_u003b_f1_u003b((&param_161), (&param_162));
-    e_1 = _e217;
-    let _e218 = (*rho_2);
-    let _e219 = e_1;
-    let _e221 = (*r_4);
-    param_163 = _e221;
-    let _e222 = FonAverage_u0028_f1_u003b((&param_163));
-    let _e223 = (*rho_2);
-    param_164 = _e223;
-    param_165 = _e222;
-    let _e224 = EonMultiAlbedo_u0028_vf3_u003b_f1_u003b((&param_164), (&param_165));
-    let _e225 = e_1;
-    return ((_e218 * _e219) + (_e224 * (1f - _e225)));
+    let _e216 = (*mu_1);
+    param_161 = _e216;
+    let _e217 = (*r_4);
+    param_162 = _e217;
+    let _e218 = FonAlbedo_u0028_f1_u003b_f1_u003b((&param_161), (&param_162));
+    e_1 = _e218;
+    let _e219 = (*rho_2);
+    let _e220 = e_1;
+    let _e222 = (*r_4);
+    param_163 = _e222;
+    let _e223 = FonAverage_u0028_f1_u003b((&param_163));
+    let _e224 = (*rho_2);
+    param_164 = _e224;
+    param_165 = _e223;
+    let _e225 = EonMultiAlbedo_u0028_vf3_u003b_f1_u003b((&param_164), (&param_165));
+    let _e226 = e_1;
+    return ((_e219 * _e220) + (_e225 * (1f - _e226)));
 }
 
 fn MaterialLodBias_u0028_() -> f32 {
-    let _e208 = frag_info.target_origin[1u];
-    return _e208;
+    let _e209 = frag_info.target_origin[1u];
+    return _e209;
 }
 
 fn ApplyMetallicRoughnessMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_8: ptr<function, Surface>) {
     var orm: vec3<f32>;
 
-    let _e208 = v_texcoord_1;
-    let _e209 = MaterialLodBias_u0028_();
-    let _e210 = textureSampleBias(metallic_roughness_texture_tex, metallic_roughness_texture_smp, _e208, _e209);
-    orm = _e210.xyz;
-    let _e213 = (*s_8).metallic;
-    let _e215 = orm[2u];
-    (*s_8).metallic = clamp((_e213 * _e215), 0f, 1f);
-    let _e220 = (*s_8).roughness;
-    let _e222 = orm[1u];
-    (*s_8).roughness = clamp((_e220 * _e222), 0.02f, 1f);
+    let _e209 = v_texcoord_1;
+    let _e210 = MaterialLodBias_u0028_();
+    let _e211 = textureSampleBias(metallic_roughness_texture_tex, metallic_roughness_texture_smp, _e209, _e210);
+    orm = _e211.xyz;
+    let _e214 = (*s_8).metallic;
+    let _e216 = orm[2u];
+    (*s_8).metallic = clamp((_e214 * _e216), 0f, 1f);
+    let _e221 = (*s_8).roughness;
+    let _e223 = orm[1u];
+    (*s_8).roughness = clamp((_e221 * _e223), 0.02f, 1f);
     return;
 }
 
@@ -16659,29 +16778,29 @@ fn ApplyEmissiveMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002
     var emissive: vec3<f32>;
     var param_166: vec3<f32>;
 
-    let _e209 = v_texcoord_1;
-    let _e210 = MaterialLodBias_u0028_();
-    let _e211 = textureSampleBias(emissive_texture_tex, emissive_texture_smp, _e209, _e210);
-    param_166 = _e211.xyz;
-    let _e213 = SrgbToLinear_u0028_vf3_u003b((&param_166));
-    emissive = _e213;
-    let _e214 = emissive;
-    let _e216 = frag_info.emissive;
-    let _e221 = frag_info.material2_[3u];
-    (*s_9).emissive = ((_e214 * _e216.xyz) * _e221);
+    let _e210 = v_texcoord_1;
+    let _e211 = MaterialLodBias_u0028_();
+    let _e212 = textureSampleBias(emissive_texture_tex, emissive_texture_smp, _e210, _e211);
+    param_166 = _e212.xyz;
+    let _e214 = SrgbToLinear_u0028_vf3_u003b((&param_166));
+    emissive = _e214;
+    let _e215 = emissive;
+    let _e217 = frag_info.emissive;
+    let _e222 = frag_info.material2_[3u];
+    (*s_9).emissive = ((_e215 * _e217.xyz) * _e222);
     return;
 }
 
 fn ApplyOcclusionMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_10: ptr<function, Surface>) {
     var occlusion: f32;
 
-    let _e208 = v_texcoord_1;
-    let _e209 = MaterialLodBias_u0028_();
-    let _e210 = textureSampleBias(occlusion_texture_tex, occlusion_texture_smp, _e208, _e209);
-    occlusion = _e210.x;
-    let _e212 = occlusion;
-    let _e215 = frag_info.material2_[2u];
-    (*s_10).occlusion = mix(1f, _e212, clamp(_e215, 0f, 1f));
+    let _e209 = v_texcoord_1;
+    let _e210 = MaterialLodBias_u0028_();
+    let _e211 = textureSampleBias(occlusion_texture_tex, occlusion_texture_smp, _e209, _e210);
+    occlusion = _e211.x;
+    let _e213 = occlusion;
+    let _e216 = frag_info.material2_[2u];
+    (*s_10).occlusion = mix(1f, _e213, clamp(_e216, 0f, 1f));
     return;
 }
 
@@ -16691,64 +16810,64 @@ fn ApplyNormalMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_
     var b_4: vec3<f32>;
     var sampled: vec3<f32>;
 
-    let _e211 = v_texcoord_1;
-    let _e212 = MaterialLodBias_u0028_();
-    let _e213 = textureSampleBias(normal_texture_tex, normal_texture_smp, _e211, _e212);
-    sampledTexel = _e213;
-    let _e214 = v_tangent_1;
-    t_2 = _e214.xyz;
-    let _e216 = t_2;
-    let _e218 = (*s_11).n;
-    let _e220 = (*s_11).n;
-    let _e221 = t_2;
-    t_2 = (_e216 - (_e218 * dot(_e220, _e221)));
-    let _e225 = t_2;
+    let _e212 = v_texcoord_1;
+    let _e213 = MaterialLodBias_u0028_();
+    let _e214 = textureSampleBias(normal_texture_tex, normal_texture_smp, _e212, _e213);
+    sampledTexel = _e214;
+    let _e215 = v_tangent_1;
+    t_2 = _e215.xyz;
+    let _e217 = t_2;
+    let _e219 = (*s_11).n;
+    let _e221 = (*s_11).n;
+    let _e222 = t_2;
+    t_2 = (_e217 - (_e219 * dot(_e221, _e222)));
     let _e226 = t_2;
-    if (dot(_e225, _e226) < 0.000000000001f) {
+    let _e227 = t_2;
+    if (dot(_e226, _e227) < 0.000000000001f) {
         return;
     }
-    let _e229 = t_2;
-    t_2 = normalize(_e229);
-    let _e232 = (*s_11).n;
-    let _e233 = t_2;
-    let _e236 = v_tangent_1[3u];
-    b_4 = (cross(_e232, _e233) * _e236);
-    let _e238 = gl_FrontFacing_1;
-    if !(_e238) {
-        let _e240 = t_2;
-        t_2 = -(_e240);
-    }
-    let _e242 = sampledTexel;
-    sampled = ((_e242.xyz * 2f) - vec3(1f));
-    let _e249 = frag_info.emissive[3u];
-    if (_e249 > 0.5f) {
-        let _e251 = sampled;
-        let _e253 = sampled;
-        sampled[2u] = sqrt(max((1f - dot(_e251.xy, _e253.xy)), 0f));
-    }
-    let _e262 = frag_info.material2_[1u];
-    let _e263 = sampled;
-    let _e265 = (_e263.xy * _e262);
-    sampled[0u] = _e265.x;
-    sampled[1u] = _e265.y;
-    let _e270 = t_2;
-    let _e272 = sampled[0u];
-    let _e274 = b_4;
-    let _e276 = sampled[1u];
-    let _e280 = (*s_11).n;
-    let _e282 = sampled[2u];
-    (*s_11).n = normalize((((_e270 * _e272) + (_e274 * _e276)) + (_e280 * _e282)));
-    let _e288 = (*s_11).n;
-    let _e290 = (*s_11).v;
-    (*s_11).n_dot_v = max(dot(_e288, _e290), 0.0001f);
+    let _e230 = t_2;
+    t_2 = normalize(_e230);
+    let _e233 = (*s_11).n;
+    let _e234 = t_2;
+    let _e237 = v_tangent_1[3u];
+    b_4 = (cross(_e233, _e234) * _e237);
+    let _e239 = gl_FrontFacing_1;
+    if !(_e239) {
+        let _e241 = t_2;
+        t_2 = -(_e241);
+    }
+    let _e243 = sampledTexel;
+    sampled = ((_e243.xyz * 2f) - vec3(1f));
+    let _e250 = frag_info.emissive[3u];
+    if (_e250 > 0.5f) {
+        let _e252 = sampled;
+        let _e254 = sampled;
+        sampled[2u] = sqrt(max((1f - dot(_e252.xy, _e254.xy)), 0f));
+    }
+    let _e263 = frag_info.material2_[1u];
+    let _e264 = sampled;
+    let _e266 = (_e264.xy * _e263);
+    sampled[0u] = _e266.x;
+    sampled[1u] = _e266.y;
+    let _e271 = t_2;
+    let _e273 = sampled[0u];
+    let _e275 = b_4;
+    let _e277 = sampled[1u];
+    let _e281 = (*s_11).n;
+    let _e283 = sampled[2u];
+    (*s_11).n = normalize((((_e271 * _e273) + (_e275 * _e277)) + (_e281 * _e283)));
+    let _e289 = (*s_11).n;
+    let _e291 = (*s_11).v;
+    (*s_11).n_dot_v = max(dot(_e289, _e291), 0.0001f);
     return;
 }
 
 fn AtlasTexel_u0028_vf2_u003b(texel_5: ptr<function, vec2<f32>>) -> vec4<f32> {
-    let _e207 = (*texel_5);
-    let _e211 = irradiance_info.atlas;
-    let _e214 = textureSampleLevel(irradiance_texture_tex, irradiance_texture_smp, ((_e207 + vec2(0.5f)) * _e211.xy), 0f);
-    return _e214;
+    let _e208 = (*texel_5);
+    let _e212 = irradiance_info.atlas;
+    let _e215 = textureSampleLevel(irradiance_texture_tex, irradiance_texture_smp, ((_e208 + vec2(0.5f)) * _e212.xy), 0f);
+    return _e215;
 }
 
 fn TileBilinear_u0028_vf2_u003b_f1_u003b_vf2_u003b(corner: ptr<function, vec2<f32>>, interior: ptr<function, f32>, uv_6: ptr<function, vec2<f32>>) -> vec4<f32> {
@@ -16764,42 +16883,42 @@ fn TileBilinear_u0028_vf2_u003b_f1_u003b_vf2_u003b(corner: ptr<function, vec2<f3
     var d_5: vec4<f32>;
     var param_170: vec2<f32>;
 
-    let _e220 = (*uv_6);
-    let _e221 = (*interior);
-    at_1 = ((vec2(1f) + (_e220 * _e221)) - vec2(0.5f));
-    let _e227 = at_1;
-    low = floor(_e227);
-    let _e229 = at_1;
-    let _e230 = low;
-    f_3 = (_e229 - _e230);
-    let _e232 = (*corner);
-    let _e233 = low;
-    param_167 = (_e232 + _e233);
-    let _e235 = AtlasTexel_u0028_vf2_u003b((&param_167));
-    a_6 = _e235;
-    let _e236 = (*corner);
-    let _e237 = low;
-    param_168 = ((_e236 + _e237) + vec2<f32>(1f, 0f));
-    let _e240 = AtlasTexel_u0028_vf2_u003b((&param_168));
-    b_5 = _e240;
-    let _e241 = (*corner);
-    let _e242 = low;
-    param_169 = ((_e241 + _e242) + vec2<f32>(0f, 1f));
-    let _e245 = AtlasTexel_u0028_vf2_u003b((&param_169));
-    c_1 = _e245;
-    let _e246 = (*corner);
-    let _e247 = low;
-    param_170 = ((_e246 + _e247) + vec2<f32>(1f, 1f));
-    let _e250 = AtlasTexel_u0028_vf2_u003b((&param_170));
-    d_5 = _e250;
-    let _e251 = a_6;
-    let _e252 = b_5;
-    let _e254 = f_3[0u];
-    let _e257 = c_1;
-    let _e258 = d_5;
-    let _e260 = f_3[0u];
-    let _e264 = f_3[1u];
-    return mix(mix(_e251, _e252, vec4(_e254)), mix(_e257, _e258, vec4(_e260)), vec4(_e264));
+    let _e221 = (*uv_6);
+    let _e222 = (*interior);
+    at_1 = ((vec2(1f) + (_e221 * _e222)) - vec2(0.5f));
+    let _e228 = at_1;
+    low = floor(_e228);
+    let _e230 = at_1;
+    let _e231 = low;
+    f_3 = (_e230 - _e231);
+    let _e233 = (*corner);
+    let _e234 = low;
+    param_167 = (_e233 + _e234);
+    let _e236 = AtlasTexel_u0028_vf2_u003b((&param_167));
+    a_6 = _e236;
+    let _e237 = (*corner);
+    let _e238 = low;
+    param_168 = ((_e237 + _e238) + vec2<f32>(1f, 0f));
+    let _e241 = AtlasTexel_u0028_vf2_u003b((&param_168));
+    b_5 = _e241;
+    let _e242 = (*corner);
+    let _e243 = low;
+    param_169 = ((_e242 + _e243) + vec2<f32>(0f, 1f));
+    let _e246 = AtlasTexel_u0028_vf2_u003b((&param_169));
+    c_1 = _e246;
+    let _e247 = (*corner);
+    let _e248 = low;
+    param_170 = ((_e247 + _e248) + vec2<f32>(1f, 1f));
+    let _e251 = AtlasTexel_u0028_vf2_u003b((&param_170));
+    d_5 = _e251;
+    let _e252 = a_6;
+    let _e253 = b_5;
+    let _e255 = f_3[0u];
+    let _e258 = c_1;
+    let _e259 = d_5;
+    let _e261 = f_3[0u];
+    let _e265 = f_3[1u];
+    return mix(mix(_e252, _e253, vec4(_e255)), mix(_e258, _e259, vec4(_e261)), vec4(_e265));
 }
 
 fn ProbeOctahedral_u0028_vf3_u003b(direction_1: ptr<function, vec3<f32>>) -> vec2<f32> {
@@ -16807,29 +16926,29 @@ fn ProbeOctahedral_u0028_vf3_u003b(direction_1: ptr<function, vec3<f32>>) -> vec
     var n_6: vec3<f32>;
     var xy: vec2<f32>;
 
-    let _e211 = (*direction_1)[0u];
-    let _e214 = (*direction_1)[1u];
-    let _e218 = (*direction_1)[2u];
-    sum_1 = ((abs(_e211) + abs(_e214)) + abs(_e218));
-    let _e221 = sum_1;
-    if (_e221 <= 0f) {
+    let _e212 = (*direction_1)[0u];
+    let _e215 = (*direction_1)[1u];
+    let _e219 = (*direction_1)[2u];
+    sum_1 = ((abs(_e212) + abs(_e215)) + abs(_e219));
+    let _e222 = sum_1;
+    if (_e222 <= 0f) {
         return vec2<f32>(0.5f, 0.5f);
     }
-    let _e223 = (*direction_1);
-    let _e224 = sum_1;
-    n_6 = (_e223 / vec3(_e224));
-    let _e227 = n_6;
-    xy = _e227.xy;
-    let _e230 = n_6[2u];
-    if (_e230 < 0f) {
-        let _e233 = n_6[1u];
-        let _e237 = n_6[0u];
-        let _e242 = n_6[0u];
-        let _e246 = n_6[1u];
-        xy = vec2<f32>(((1f - abs(_e233)) * select(-1f, 1f, (_e237 >= 0f))), ((1f - abs(_e242)) * select(-1f, 1f, (_e246 >= 0f))));
+    let _e224 = (*direction_1);
+    let _e225 = sum_1;
+    n_6 = (_e224 / vec3(_e225));
+    let _e228 = n_6;
+    xy = _e228.xy;
+    let _e231 = n_6[2u];
+    if (_e231 < 0f) {
+        let _e234 = n_6[1u];
+        let _e238 = n_6[0u];
+        let _e243 = n_6[0u];
+        let _e247 = n_6[1u];
+        xy = vec2<f32>(((1f - abs(_e234)) * select(-1f, 1f, (_e238 >= 0f))), ((1f - abs(_e243)) * select(-1f, 1f, (_e247 >= 0f))));
     }
-    let _e251 = xy;
-    return ((_e251 * 0.5f) + vec2(0.5f));
+    let _e252 = xy;
+    return ((_e252 * 0.5f) + vec2(0.5f));
 }
 
 fn SampleIrradiance_u0028_vf3_u003b_vf3_u003b_vf3_u003b(world_4: ptr<function, vec3<f32>>, normal_1: ptr<function, vec3<f32>>, view_1: ptr<function, vec3<f32>>) -> vec3<f32> {
@@ -16877,190 +16996,190 @@ fn SampleIrradiance_u0028_vf3_u003b_vf3_u003b_vf3_u003b(world_4: ptr<function, v
     var param_179: vec2<f32>;
     var local_31: vec3<f32>;
 
-    let _e253 = irradiance_info.origin;
-    origin_2 = _e253.xyz;
-    let _e256 = irradiance_info.spacing;
-    spacing = _e256.xyz;
-    let _e259 = irradiance_info.counts;
-    counts = _e259.xyz;
-    let _e263 = irradiance_info.tiles[0u];
-    irradianceTile = _e263;
-    let _e266 = irradiance_info.tiles[1u];
-    depthTile = _e266;
-    let _e269 = irradiance_info.tiles[2u];
-    columns = _e269;
-    let _e272 = irradiance_info.tiles[3u];
-    momentsTop = _e272;
-    let _e273 = (*normal_1);
-    unit = normalize(_e273);
-    let _e275 = (*world_4);
-    let _e276 = unit;
-    let _e279 = irradiance_info.spacing[3u];
-    let _e282 = (*view_1);
-    let _e285 = irradiance_info.counts[3u];
-    biased = ((_e275 + (_e276 * _e279)) + (_e282 * _e285));
-    let _e288 = biased;
-    let _e289 = origin_2;
-    let _e291 = spacing;
-    grid_1 = ((_e288 - _e289) / _e291);
-    let _e293 = grid_1;
-    let _e295 = counts;
-    base = clamp(floor(_e293), vec3<f32>(0f, 0f, 0f), (_e295 - vec3(2f)));
-    let _e299 = grid_1;
-    let _e300 = base;
-    f_4 = clamp((_e299 - _e300), vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
+    let _e254 = irradiance_info.origin;
+    origin_2 = _e254.xyz;
+    let _e257 = irradiance_info.spacing;
+    spacing = _e257.xyz;
+    let _e260 = irradiance_info.counts;
+    counts = _e260.xyz;
+    let _e264 = irradiance_info.tiles[0u];
+    irradianceTile = _e264;
+    let _e267 = irradiance_info.tiles[1u];
+    depthTile = _e267;
+    let _e270 = irradiance_info.tiles[2u];
+    columns = _e270;
+    let _e273 = irradiance_info.tiles[3u];
+    momentsTop = _e273;
+    let _e274 = (*normal_1);
+    unit = normalize(_e274);
+    let _e276 = (*world_4);
+    let _e277 = unit;
+    let _e280 = irradiance_info.spacing[3u];
+    let _e283 = (*view_1);
+    let _e286 = irradiance_info.counts[3u];
+    biased = ((_e276 + (_e277 * _e280)) + (_e283 * _e286));
+    let _e289 = biased;
+    let _e290 = origin_2;
+    let _e292 = spacing;
+    grid_1 = ((_e289 - _e290) / _e292);
+    let _e294 = grid_1;
+    let _e296 = counts;
+    base = clamp(floor(_e294), vec3<f32>(0f, 0f, 0f), (_e296 - vec3(2f)));
+    let _e300 = grid_1;
+    let _e301 = base;
+    f_4 = clamp((_e300 - _e301), vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
     total_2 = vec3<f32>(0f, 0f, 0f);
     weights = 0f;
     corner_1 = 0i;
     loop {
-        let _e303 = corner_1;
-        if (_e303 < 8i) {
-            let _e305 = corner_1;
-            let _e308 = corner_1;
-            let _e313 = corner_1;
-            offset_3 = vec3<f32>(f32((_e305 & 1i)), f32(((_e308 >> bitcast<u32>(1i)) & 1i)), f32(((_e313 >> bitcast<u32>(2i)) & 1i)));
-            let _e319 = base;
-            let _e320 = offset_3;
-            cell_1 = (_e319 + _e320);
-            let _e323 = cell_1[2u];
-            let _e325 = counts[1u];
-            let _e328 = cell_1[1u];
-            let _e331 = counts[0u];
-            let _e334 = cell_1[0u];
-            probe = ((((_e323 * _e325) + _e328) * _e331) + _e334);
-            let _e336 = probe;
-            let _e337 = columns;
-            let _e342 = probe;
-            let _e343 = columns;
-            tile_4 = vec2<f32>((_e336 - (floor((_e336 / _e337)) * _e337)), floor((_e342 / _e343)));
-            let _e347 = tile_4;
-            let _e348 = irradianceTile;
-            irradianceCorner = (_e347 * (_e348 + 2f));
-            let _e352 = tile_4[0u];
-            let _e353 = depthTile;
-            let _e356 = momentsTop;
-            let _e358 = tile_4[1u];
-            let _e359 = depthTile;
-            momentCorner = vec2<f32>((_e352 * (_e353 + 2f)), (_e356 + (_e358 * (_e359 + 2f))));
-            let _e364 = irradianceCorner;
-            param_171 = (_e364 + vec2(1f));
-            let _e367 = AtlasTexel_u0028_vf2_u003b((&param_171));
-            if (_e367.w < 0.5f) {
+        let _e304 = corner_1;
+        if (_e304 < 8i) {
+            let _e306 = corner_1;
+            let _e309 = corner_1;
+            let _e314 = corner_1;
+            offset_3 = vec3<f32>(f32((_e306 & 1i)), f32(((_e309 >> bitcast<u32>(1i)) & 1i)), f32(((_e314 >> bitcast<u32>(2i)) & 1i)));
+            let _e320 = base;
+            let _e321 = offset_3;
+            cell_1 = (_e320 + _e321);
+            let _e324 = cell_1[2u];
+            let _e326 = counts[1u];
+            let _e329 = cell_1[1u];
+            let _e332 = counts[0u];
+            let _e335 = cell_1[0u];
+            probe = ((((_e324 * _e326) + _e329) * _e332) + _e335);
+            let _e337 = probe;
+            let _e338 = columns;
+            let _e343 = probe;
+            let _e344 = columns;
+            tile_4 = vec2<f32>((_e337 - (floor((_e337 / _e338)) * _e338)), floor((_e343 / _e344)));
+            let _e348 = tile_4;
+            let _e349 = irradianceTile;
+            irradianceCorner = (_e348 * (_e349 + 2f));
+            let _e353 = tile_4[0u];
+            let _e354 = depthTile;
+            let _e357 = momentsTop;
+            let _e359 = tile_4[1u];
+            let _e360 = depthTile;
+            momentCorner = vec2<f32>((_e353 * (_e354 + 2f)), (_e357 + (_e359 * (_e360 + 2f))));
+            let _e365 = irradianceCorner;
+            param_171 = (_e365 + vec2(1f));
+            let _e368 = AtlasTexel_u0028_vf2_u003b((&param_171));
+            if (_e368.w < 0.5f) {
                 continue;
             }
-            let _e370 = f_4;
-            let _e372 = f_4;
-            let _e373 = offset_3;
-            trilinear = mix((vec3<f32>(1f, 1f, 1f) - _e370), _e372, _e373);
-            let _e376 = trilinear[0u];
-            let _e378 = trilinear[1u];
-            let _e381 = trilinear[2u];
-            weight_3 = max(((_e376 * _e378) * _e381), 0.001f);
-            let _e384 = origin_2;
-            let _e385 = spacing;
-            let _e386 = cell_1;
-            probePosition = (_e384 + (_e385 * _e386));
-            let _e389 = probePosition;
-            let _e390 = biased;
-            toProbe = (_e389 - _e390);
-            let _e392 = toProbe;
-            distance_4 = length(_e392);
-            let _e394 = distance_4;
-            if (_e394 > 0.000001f) {
-                let _e396 = toProbe;
-                let _e397 = distance_4;
-                direction_2 = (_e396 / vec3(_e397));
-                let _e400 = unit;
-                let _e401 = probePosition;
-                let _e402 = (*world_4);
-                facing = ((dot(_e400, normalize((_e401 - _e402))) * 0.5f) + 0.5f);
-                let _e408 = facing;
+            let _e371 = f_4;
+            let _e373 = f_4;
+            let _e374 = offset_3;
+            trilinear = mix((vec3<f32>(1f, 1f, 1f) - _e371), _e373, _e374);
+            let _e377 = trilinear[0u];
+            let _e379 = trilinear[1u];
+            let _e382 = trilinear[2u];
+            weight_3 = max(((_e377 * _e379) * _e382), 0.001f);
+            let _e385 = origin_2;
+            let _e386 = spacing;
+            let _e387 = cell_1;
+            probePosition = (_e385 + (_e386 * _e387));
+            let _e390 = probePosition;
+            let _e391 = biased;
+            toProbe = (_e390 - _e391);
+            let _e393 = toProbe;
+            distance_4 = length(_e393);
+            let _e395 = distance_4;
+            if (_e395 > 0.000001f) {
+                let _e397 = toProbe;
+                let _e398 = distance_4;
+                direction_2 = (_e397 / vec3(_e398));
+                let _e401 = unit;
+                let _e402 = probePosition;
+                let _e403 = (*world_4);
+                facing = ((dot(_e401, normalize((_e402 - _e403))) * 0.5f) + 0.5f);
                 let _e409 = facing;
-                probeWeight = ((_e408 * _e409) + 0.2f);
-                let _e412 = direction_2;
-                param_172 = -(_e412);
-                let _e414 = ProbeOctahedral_u0028_vf3_u003b((&param_172));
-                let _e415 = momentCorner;
-                param_173 = _e415;
-                let _e416 = depthTile;
-                param_174 = _e416;
-                param_175 = _e414;
-                let _e417 = TileBilinear_u0028_vf2_u003b_f1_u003b_vf2_u003b((&param_173), (&param_174), (&param_175));
-                moments_3 = _e417.xy;
+                let _e410 = facing;
+                probeWeight = ((_e409 * _e410) + 0.2f);
+                let _e413 = direction_2;
+                param_172 = -(_e413);
+                let _e415 = ProbeOctahedral_u0028_vf3_u003b((&param_172));
+                let _e416 = momentCorner;
+                param_173 = _e416;
+                let _e417 = depthTile;
+                param_174 = _e417;
+                param_175 = _e415;
+                let _e418 = TileBilinear_u0028_vf2_u003b_f1_u003b_vf2_u003b((&param_173), (&param_174), (&param_175));
+                moments_3 = _e418.xy;
                 chebyshev = 1f;
-                let _e419 = distance_4;
-                let _e421 = moments_3[0u];
-                if (_e419 > _e421) {
-                    let _e424 = moments_3[1u];
-                    let _e426 = moments_3[0u];
-                    let _e428 = moments_3[0u];
-                    variance_1 = max((_e424 - (_e426 * _e428)), 0.000001f);
-                    let _e432 = distance_4;
-                    let _e434 = moments_3[0u];
-                    difference = (_e432 - _e434);
-                    let _e436 = variance_1;
+                let _e420 = distance_4;
+                let _e422 = moments_3[0u];
+                if (_e420 > _e422) {
+                    let _e425 = moments_3[1u];
+                    let _e427 = moments_3[0u];
+                    let _e429 = moments_3[0u];
+                    variance_1 = max((_e425 - (_e427 * _e429)), 0.000001f);
+                    let _e433 = distance_4;
+                    let _e435 = moments_3[0u];
+                    difference = (_e433 - _e435);
                     let _e437 = variance_1;
-                    let _e438 = difference;
+                    let _e438 = variance_1;
                     let _e439 = difference;
-                    chebyshev = (_e436 / (_e437 + (_e438 * _e439)));
-                    let _e443 = chebyshev;
+                    let _e440 = difference;
+                    chebyshev = (_e437 / (_e438 + (_e439 * _e440)));
                     let _e444 = chebyshev;
-                    let _e446 = chebyshev;
-                    chebyshev = ((_e443 * _e444) * _e446);
+                    let _e445 = chebyshev;
+                    let _e447 = chebyshev;
+                    chebyshev = ((_e444 * _e445) * _e447);
                 }
-                let _e448 = probeWeight;
-                let _e449 = chebyshev;
-                probeWeight = max((_e448 * max(_e449, 0.05f)), 0.000001f);
-                let _e453 = probeWeight;
-                if (_e453 < 0.2f) {
-                    let _e455 = probeWeight;
+                let _e449 = probeWeight;
+                let _e450 = chebyshev;
+                probeWeight = max((_e449 * max(_e450, 0.05f)), 0.000001f);
+                let _e454 = probeWeight;
+                if (_e454 < 0.2f) {
                     let _e456 = probeWeight;
-                    let _e459 = probeWeight;
-                    probeWeight = (_e459 * ((_e455 * _e456) * 25f));
+                    let _e457 = probeWeight;
+                    let _e460 = probeWeight;
+                    probeWeight = (_e460 * ((_e456 * _e457) * 25f));
                 }
-                let _e461 = probeWeight;
-                let _e462 = weight_3;
-                weight_3 = (_e462 * _e461);
-            }
-            let _e464 = unit;
-            param_176 = _e464;
-            let _e465 = ProbeOctahedral_u0028_vf3_u003b((&param_176));
-            let _e466 = irradianceCorner;
-            param_177 = _e466;
-            let _e467 = irradianceTile;
-            param_178 = _e467;
-            param_179 = _e465;
-            let _e468 = TileBilinear_u0028_vf2_u003b_f1_u003b_vf2_u003b((&param_177), (&param_178), (&param_179));
-            let _e470 = weight_3;
-            let _e472 = total_2;
-            total_2 = (_e472 + (_e468.xyz * _e470));
-            let _e474 = weight_3;
-            let _e475 = weights;
-            weights = (_e475 + _e474);
+                let _e462 = probeWeight;
+                let _e463 = weight_3;
+                weight_3 = (_e463 * _e462);
+            }
+            let _e465 = unit;
+            param_176 = _e465;
+            let _e466 = ProbeOctahedral_u0028_vf3_u003b((&param_176));
+            let _e467 = irradianceCorner;
+            param_177 = _e467;
+            let _e468 = irradianceTile;
+            param_178 = _e468;
+            param_179 = _e466;
+            let _e469 = TileBilinear_u0028_vf2_u003b_f1_u003b_vf2_u003b((&param_177), (&param_178), (&param_179));
+            let _e471 = weight_3;
+            let _e473 = total_2;
+            total_2 = (_e473 + (_e469.xyz * _e471));
+            let _e475 = weight_3;
+            let _e476 = weights;
+            weights = (_e476 + _e475);
             continue;
         } else {
             break;
         }
         continuing {
-            let _e477 = corner_1;
-            corner_1 = (_e477 + 1i);
+            let _e478 = corner_1;
+            corner_1 = (_e478 + 1i);
         }
     }
-    let _e479 = weights;
-    if (_e479 > 0f) {
-        let _e481 = total_2;
-        let _e482 = weights;
-        local_31 = (_e481 / vec3(_e482));
+    let _e480 = weights;
+    if (_e480 > 0f) {
+        let _e482 = total_2;
+        let _e483 = weights;
+        local_31 = (_e482 / vec3(_e483));
     } else {
         local_31 = vec3<f32>(0f, 0f, 0f);
     }
-    let _e485 = local_31;
-    return _e485;
+    let _e486 = local_31;
+    return _e486;
 }
 
 fn IrradianceEnabled_u0028_() -> bool {
-    let _e208 = irradiance_info.origin[3u];
-    return (_e208 > 0.5f);
+    let _e209 = irradiance_info.origin[3u];
+    return (_e209 > 0.5f);
 }
 
 fn ApplyCommonMaps_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_12: ptr<function, Surface>) {
@@ -17071,50 +17190,50 @@ fn ApplyCommonMaps_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d
     var param_184: Surface;
     var param_185: Surface;
 
-    let _e213 = IrradianceEnabled_u0028_();
-    if _e213 {
-        let _e214 = v_world_position_1;
-        param_180 = _e214;
-        let _e216 = (*s_12).n;
-        param_181 = _e216;
-        let _e218 = (*s_12).v;
-        param_182 = _e218;
-        let _e219 = SampleIrradiance_u0028_vf3_u003b_vf3_u003b_vf3_u003b((&param_180), (&param_181), (&param_182));
-        let _e222 = frag_info.material[2u];
-        (*s_12).ambient = (_e219 * _e222);
-    }
-    let _e225 = (*s_12);
-    param_183 = _e225;
+    let _e214 = IrradianceEnabled_u0028_();
+    if _e214 {
+        let _e215 = v_world_position_1;
+        param_180 = _e215;
+        let _e217 = (*s_12).n;
+        param_181 = _e217;
+        let _e219 = (*s_12).v;
+        param_182 = _e219;
+        let _e220 = SampleIrradiance_u0028_vf3_u003b_vf3_u003b_vf3_u003b((&param_180), (&param_181), (&param_182));
+        let _e223 = frag_info.material[2u];
+        (*s_12).ambient = (_e220 * _e223);
+    }
+    let _e226 = (*s_12);
+    param_183 = _e226;
     ApplyNormalMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_183));
-    let _e226 = param_183;
-    (*s_12) = _e226;
-    let _e227 = (*s_12);
-    param_184 = _e227;
+    let _e227 = param_183;
+    (*s_12) = _e227;
+    let _e228 = (*s_12);
+    param_184 = _e228;
     ApplyOcclusionMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_184));
-    let _e228 = param_184;
-    (*s_12) = _e228;
-    let _e229 = (*s_12);
-    param_185 = _e229;
+    let _e229 = param_184;
+    (*s_12) = _e229;
+    let _e230 = (*s_12);
+    param_185 = _e230;
     ApplyEmissiveMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_185));
-    let _e230 = param_185;
-    (*s_12) = _e230;
+    let _e231 = param_185;
+    (*s_12) = _e231;
     return;
 }
 
 fn TowardsEye_u0028_() -> vec3<f32> {
     var local_32: vec3<f32>;
 
-    let _e207 = Orthographic_u0028_();
-    if _e207 {
-        let _e209 = fog_info.forward;
-        local_32 = -(_e209.xyz);
+    let _e208 = Orthographic_u0028_();
+    if _e208 {
+        let _e210 = fog_info.forward;
+        local_32 = -(_e210.xyz);
     } else {
-        let _e213 = fog_info.eye;
-        let _e215 = v_world_position_1;
-        local_32 = normalize((_e213.xyz - _e215));
+        let _e214 = fog_info.eye;
+        let _e216 = v_world_position_1;
+        local_32 = normalize((_e214.xyz - _e216));
     }
-    let _e218 = local_32;
-    return _e218;
+    let _e219 = local_32;
+    return _e219;
 }
 
 fn ReadSurface_u0028_() -> Surface {
@@ -17127,89 +17246,89 @@ fn ReadSurface_u0028_() -> Surface {
     var anchored: vec3<f32>;
     var noise_1: f32;
 
-    let _e214 = v_texcoord_1;
-    let _e215 = MaterialLodBias_u0028_();
-    let _e216 = textureSampleBias(base_color_texture_tex, base_color_texture_smp, _e214, _e215);
-    texel_6 = _e216;
-    let _e217 = texel_6;
-    param_186 = _e217.xyz;
-    let _e219 = SrgbToLinear_u0028_vf3_u003b((&param_186));
-    let _e221 = frag_info.base_color;
-    param_187 = _e221.xyz;
-    let _e223 = SrgbToLinear_u0028_vf3_u003b((&param_187));
-    let _e225 = v_color_1;
-    s_13.albedo = ((_e219 * _e223) * _e225.xyz);
-    let _e230 = texel_6[3u];
-    let _e233 = frag_info.base_color[3u];
-    let _e236 = v_color_1[3u];
-    s_13.alpha = ((_e230 * _e233) * _e236);
-    let _e240 = s_13.albedo;
-    g_albedo = _e240;
-    let _e243 = frag_info.material2_[0u];
-    cutoff = _e243;
-    let _e244 = cutoff;
-    if (_e244 > 1f) {
-        let _e246 = cutoff;
-        edge = (_e246 - 1f);
-        let _e249 = s_13.alpha;
-        let _e250 = edge;
-        let _e253 = s_13.alpha;
-        let _e254 = fwidth(_e253);
-        s_13.alpha = clamp((((_e249 - _e250) / max(_e254, 0.0001f)) + 0.5f), 0f, 1f);
-    } else {
-        let _e260 = cutoff;
-        if (_e260 >= 0f) {
-            let _e263 = s_13.alpha;
-            let _e264 = cutoff;
-            if (_e263 < _e264) {
+    let _e215 = v_texcoord_1;
+    let _e216 = MaterialLodBias_u0028_();
+    let _e217 = textureSampleBias(base_color_texture_tex, base_color_texture_smp, _e215, _e216);
+    texel_6 = _e217;
+    let _e218 = texel_6;
+    param_186 = _e218.xyz;
+    let _e220 = SrgbToLinear_u0028_vf3_u003b((&param_186));
+    let _e222 = frag_info.base_color;
+    param_187 = _e222.xyz;
+    let _e224 = SrgbToLinear_u0028_vf3_u003b((&param_187));
+    let _e226 = v_color_1;
+    s_13.albedo = ((_e220 * _e224) * _e226.xyz);
+    let _e231 = texel_6[3u];
+    let _e234 = frag_info.base_color[3u];
+    let _e237 = v_color_1[3u];
+    s_13.alpha = ((_e231 * _e234) * _e237);
+    let _e241 = s_13.albedo;
+    g_albedo = _e241;
+    let _e244 = frag_info.material2_[0u];
+    cutoff = _e244;
+    let _e245 = cutoff;
+    if (_e245 > 1f) {
+        let _e247 = cutoff;
+        edge = (_e247 - 1f);
+        let _e250 = s_13.alpha;
+        let _e251 = edge;
+        let _e254 = s_13.alpha;
+        let _e255 = fwidth(_e254);
+        s_13.alpha = clamp((((_e250 - _e251) / max(_e255, 0.0001f)) + 0.5f), 0f, 1f);
+    } else {
+        let _e261 = cutoff;
+        if (_e261 >= 0f) {
+            let _e264 = s_13.alpha;
+            let _e265 = cutoff;
+            if (_e264 < _e265) {
                 discard;
             }
             s_13.alpha = 1f;
         } else {
-            let _e267 = cutoff;
-            if (_e267 < -1.5f) {
-                let _e269 = v_world_position_1;
-                anchored = floor((_e269 * 16f));
-                let _e272 = anchored;
-                noise_1 = fract((sin(dot(_e272, vec3<f32>(12.9898f, 78.233f, 37.719f))) * 43758.547f));
-                let _e278 = s_13.alpha;
-                let _e279 = noise_1;
-                if (_e278 < _e279) {
+            let _e268 = cutoff;
+            if (_e268 < -1.5f) {
+                let _e270 = v_world_position_1;
+                anchored = floor((_e270 * 16f));
+                let _e273 = anchored;
+                noise_1 = fract((sin(dot(_e273, vec3<f32>(12.9898f, 78.233f, 37.719f))) * 43758.547f));
+                let _e279 = s_13.alpha;
+                let _e280 = noise_1;
+                if (_e279 < _e280) {
                     discard;
                 }
             }
         }
     }
-    let _e281 = cutoff;
-    let _e283 = cutoff;
-    g_premultiply = ((_e281 < 0f) && (_e283 > -0.75f));
-    let _e286 = v_normal_1;
-    s_13.n = normalize(_e286);
-    let _e289 = gl_FrontFacing_1;
-    if !(_e289) {
-        let _e292 = s_13.n;
-        s_13.n = -(_e292);
-    }
-    let _e295 = TowardsEye_u0028_();
-    s_13.v = _e295;
-    let _e298 = s_13.n;
-    let _e300 = s_13.v;
-    s_13.n_dot_v = max(dot(_e298, _e300), 0.0001f);
-    let _e306 = frag_info.material[0u];
-    s_13.metallic = clamp(_e306, 0f, 1f);
-    let _e311 = frag_info.material[1u];
-    s_13.roughness = clamp(_e311, 0.02f, 1f);
-    let _e315 = frag_info.ambient_ground;
-    let _e318 = frag_info.ambient_sky;
-    let _e322 = s_13.n[1u];
-    let _e329 = frag_info.material[2u];
-    s_13.ambient = (mix(_e315.xyz, _e318.xyz, vec3(((_e322 * 0.5f) + 0.5f))) * _e329);
-    let _e334 = frag_info.frame_params[0u];
-    s_13.exposure = max(_e334, 0f);
+    let _e282 = cutoff;
+    let _e284 = cutoff;
+    g_premultiply = ((_e282 < 0f) && (_e284 > -0.75f));
+    let _e287 = v_normal_1;
+    s_13.n = normalize(_e287);
+    let _e290 = gl_FrontFacing_1;
+    if !(_e290) {
+        let _e293 = s_13.n;
+        s_13.n = -(_e293);
+    }
+    let _e296 = TowardsEye_u0028_();
+    s_13.v = _e296;
+    let _e299 = s_13.n;
+    let _e301 = s_13.v;
+    s_13.n_dot_v = max(dot(_e299, _e301), 0.0001f);
+    let _e307 = frag_info.material[0u];
+    s_13.metallic = clamp(_e307, 0f, 1f);
+    let _e312 = frag_info.material[1u];
+    s_13.roughness = clamp(_e312, 0.02f, 1f);
+    let _e316 = frag_info.ambient_ground;
+    let _e319 = frag_info.ambient_sky;
+    let _e323 = s_13.n[1u];
+    let _e330 = frag_info.material[2u];
+    s_13.ambient = (mix(_e316.xyz, _e319.xyz, vec3(((_e323 * 0.5f) + 0.5f))) * _e330);
+    let _e335 = frag_info.frame_params[0u];
+    s_13.exposure = max(_e335, 0f);
     s_13.occlusion = 1f;
     s_13.emissive = vec3<f32>(0f, 0f, 0f);
-    let _e339 = s_13;
-    return _e339;
+    let _e340 = s_13;
+    return _e340;
 }
 
 fn main_1() {
@@ -17251,122 +17370,122 @@ fn main_1() {
     g_cluster_offset = 0f;
     g_cluster_count = 0f;
     light_transmittance = vec3<f32>(1f, 1f, 1f);
-    let _e235 = ReadSurface_u0028_();
-    s_14 = _e235;
-    let _e236 = s_14;
-    param_188 = _e236;
+    let _e236 = ReadSurface_u0028_();
+    s_14 = _e236;
+    let _e237 = s_14;
+    param_188 = _e237;
     ApplyCommonMaps_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_188));
-    let _e237 = param_188;
-    s_14 = _e237;
-    let _e238 = s_14;
-    param_189 = _e238;
+    let _e238 = param_188;
+    s_14 = _e238;
+    let _e239 = s_14;
+    param_189 = _e239;
     ApplyMetallicRoughnessMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_189));
-    let _e239 = param_189;
-    s_14 = _e239;
-    let _e241 = s_14.metallic;
-    metallic = clamp(_e241, 0f, 1f);
-    let _e244 = s_14.albedo;
-    let _e245 = metallic;
-    diffuseColor_1 = (_e244 * (1f - _e245));
-    let _e248 = EonDiffuse_u0028_();
-    if _e248 {
-        let _e249 = diffuseColor_1;
-        param_190 = _e249;
-        let _e251 = s_14.roughness;
-        param_191 = _e251;
-        let _e253 = s_14.n_dot_v;
-        param_192 = _e253;
-        let _e254 = EonAlbedo_u0028_vf3_u003b_f1_u003b_f1_u003b((&param_190), (&param_191), (&param_192));
-        diffuseColor_1 = _e254;
-    }
-    let _e255 = diffuseColor_1;
-    let _e257 = s_14.ambient;
-    let _e260 = s_14.occlusion;
-    ambient = ((_e255 * _e257) * _e260);
-    let _e264 = frag_info.frame_params[3u];
-    levels = _e264;
-    let _e265 = levels;
-    if (_e265 > 0f) {
-        let _e268 = s_14.albedo;
-        let _e269 = metallic;
-        f0_3 = mix(vec3<f32>(0.04f, 0.04f, 0.04f), _e268, vec3(_e269));
-        let _e273 = s_14.v;
-        let _e276 = s_14.n;
-        reflected = reflect(-(_e273), _e276);
-        let _e279 = s_14.n;
-        let _e280 = levels;
-        let _e281 = textureSampleLevel(environment_texture_tex, environment_texture_smp, _e279, _e280);
-        irradiance = _e281.xyz;
-        let _e283 = reflected;
-        let _e285 = s_14.roughness;
-        let _e286 = levels;
-        let _e288 = textureSampleLevel(environment_texture_tex, environment_texture_smp, _e283, (_e285 * _e286));
-        prefiltered = _e288.xyz;
-        let _e291 = s_14.roughness;
-        param_193 = _e291;
-        let _e293 = s_14.n_dot_v;
-        param_194 = _e293;
-        let _e294 = EnvBrdf_u0028_f1_u003b_f1_u003b((&param_193), (&param_194));
-        ab_1 = _e294;
-        let _e295 = f0_3;
-        let _e297 = ab_1[0u];
-        let _e300 = ab_1[1u];
-        single_1 = ((_e295 * _e297) + vec3(_e300));
-        let _e303 = prefiltered;
-        let _e304 = single_1;
-        specular_1 = (_e303 * _e304);
-        let _e306 = EnergyCompensation_u0028_();
-        if _e306 {
-            let _e308 = ab_1[0u];
-            let _e310 = ab_1[1u];
-            missed = (1f - (_e308 + _e310));
-            let _e313 = f0_3;
+    let _e240 = param_189;
+    s_14 = _e240;
+    let _e242 = s_14.metallic;
+    metallic = clamp(_e242, 0f, 1f);
+    let _e245 = s_14.albedo;
+    let _e246 = metallic;
+    diffuseColor_1 = (_e245 * (1f - _e246));
+    let _e249 = EonDiffuse_u0028_();
+    if _e249 {
+        let _e250 = diffuseColor_1;
+        param_190 = _e250;
+        let _e252 = s_14.roughness;
+        param_191 = _e252;
+        let _e254 = s_14.n_dot_v;
+        param_192 = _e254;
+        let _e255 = EonAlbedo_u0028_vf3_u003b_f1_u003b_f1_u003b((&param_190), (&param_191), (&param_192));
+        diffuseColor_1 = _e255;
+    }
+    let _e256 = diffuseColor_1;
+    let _e258 = s_14.ambient;
+    let _e261 = s_14.occlusion;
+    ambient = ((_e256 * _e258) * _e261);
+    let _e265 = frag_info.frame_params[3u];
+    levels = _e265;
+    let _e266 = levels;
+    if (_e266 > 0f) {
+        let _e269 = s_14.albedo;
+        let _e270 = metallic;
+        f0_3 = mix(vec3<f32>(0.04f, 0.04f, 0.04f), _e269, vec3(_e270));
+        let _e274 = s_14.v;
+        let _e277 = s_14.n;
+        reflected = reflect(-(_e274), _e277);
+        let _e280 = s_14.n;
+        let _e281 = levels;
+        let _e282 = textureSampleLevel(environment_texture_tex, environment_texture_smp, _e280, _e281);
+        irradiance = _e282.xyz;
+        let _e284 = reflected;
+        let _e286 = s_14.roughness;
+        let _e287 = levels;
+        let _e289 = textureSampleLevel(environment_texture_tex, environment_texture_smp, _e284, (_e286 * _e287));
+        prefiltered = _e289.xyz;
+        let _e292 = s_14.roughness;
+        param_193 = _e292;
+        let _e294 = s_14.n_dot_v;
+        param_194 = _e294;
+        let _e295 = EnvBrdf_u0028_f1_u003b_f1_u003b((&param_193), (&param_194));
+        ab_1 = _e295;
+        let _e296 = f0_3;
+        let _e298 = ab_1[0u];
+        let _e301 = ab_1[1u];
+        single_1 = ((_e296 * _e298) + vec3(_e301));
+        let _e304 = prefiltered;
+        let _e305 = single_1;
+        specular_1 = (_e304 * _e305);
+        let _e307 = EnergyCompensation_u0028_();
+        if _e307 {
+            let _e309 = ab_1[0u];
+            let _e311 = ab_1[1u];
+            missed = (1f - (_e309 + _e311));
             let _e314 = f0_3;
-            average_2 = (_e313 + ((vec3<f32>(1f, 1f, 1f) - _e314) / vec3(21f)));
-            let _e319 = single_1;
-            let _e320 = average_2;
-            let _e322 = missed;
-            let _e323 = average_2;
-            multiple = ((_e319 * _e320) / (vec3<f32>(1f, 1f, 1f) - (_e323 * _e322)));
-            let _e327 = multiple;
-            let _e328 = missed;
-            let _e330 = irradiance;
-            let _e332 = specular_1;
-            specular_1 = (_e332 + ((_e327 * _e328) * _e330));
-        }
-        let _e334 = diffuseColor_1;
-        let _e335 = irradiance;
-        let _e337 = specular_1;
-        let _e341 = frag_info.material[2u];
-        let _e344 = s_14.occlusion;
-        ambient = ((((_e334 * _e335) + _e337) * _e341) * _e344);
-    }
-    let _e346 = diffuseColor_1;
-    let _e347 = SampleLightmap_u0028_();
-    let _e350 = s_14.occlusion;
-    let _e352 = ambient;
-    ambient = (_e352 + ((_e346 * _e347) * _e350));
-    let _e354 = s_14;
-    param_195 = _e354;
-    let _e355 = AccumulateLights_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_195));
-    let _e357 = s_14.occlusion;
-    let _e359 = ambient;
-    let _e362 = s_14.emissive;
-    lit_3 = (((_e355 * _e357) + _e359) + _e362);
-    let _e364 = s_14;
-    param_196 = _e364;
-    let _e365 = lit_3;
-    param_197 = _e365;
-    let _e366 = WriteDebugView_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_vf3_u003b((&param_196), (&param_197));
-    if _e366 {
+            let _e315 = f0_3;
+            average_2 = (_e314 + ((vec3<f32>(1f, 1f, 1f) - _e315) / vec3(21f)));
+            let _e320 = single_1;
+            let _e321 = average_2;
+            let _e323 = missed;
+            let _e324 = average_2;
+            multiple = ((_e320 * _e321) / (vec3<f32>(1f, 1f, 1f) - (_e324 * _e323)));
+            let _e328 = multiple;
+            let _e329 = missed;
+            let _e331 = irradiance;
+            let _e333 = specular_1;
+            specular_1 = (_e333 + ((_e328 * _e329) * _e331));
+        }
+        let _e335 = diffuseColor_1;
+        let _e336 = irradiance;
+        let _e338 = specular_1;
+        let _e342 = frag_info.material[2u];
+        let _e345 = s_14.occlusion;
+        ambient = ((((_e335 * _e336) + _e338) * _e342) * _e345);
+    }
+    let _e347 = diffuseColor_1;
+    let _e348 = SampleLightmap_u0028_();
+    let _e351 = s_14.occlusion;
+    let _e353 = ambient;
+    ambient = (_e353 + ((_e347 * _e348) * _e351));
+    let _e355 = s_14;
+    param_195 = _e355;
+    let _e356 = AccumulateLights_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_195));
+    let _e358 = s_14.occlusion;
+    let _e360 = ambient;
+    let _e363 = s_14.emissive;
+    lit_3 = (((_e356 * _e358) + _e360) + _e363);
+    let _e365 = s_14;
+    param_196 = _e365;
+    let _e366 = lit_3;
+    param_197 = _e366;
+    let _e367 = WriteDebugView_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_vf3_u003b((&param_196), (&param_197));
+    if _e367 {
         return;
     }
-    let _e367 = lit_3;
-    param_198 = _e367;
-    let _e369 = s_14.alpha;
-    param_199 = _e369;
-    let _e371 = s_14.roughness;
-    param_200 = _e371;
+    let _e368 = lit_3;
+    param_198 = _e368;
+    let _e370 = s_14.alpha;
+    param_199 = _e370;
+    let _e372 = s_14.roughness;
+    param_200 = _e372;
     WriteSurface_u0028_vf3_u003b_f1_u003b_f1_u003b((&param_198), (&param_199), (&param_200));
     return;
 }
@@ -17946,10 +18065,10 @@ var scene_colour_texture_tex: texture_2d<f32>;
 var scene_colour_texture_smp: sampler;
 
 fn ViewDepth_u0028_() -> f32 {
-    let _e273 = v_world_position_1;
-    let _e275 = fog_info.eye;
-    let _e279 = fog_info.forward;
-    return dot((_e273 - _e275.xyz), _e279.xyz);
+    let _e274 = v_world_position_1;
+    let _e276 = fog_info.eye;
+    let _e280 = fog_info.forward;
+    return dot((_e274 - _e276.xyz), _e280.xyz);
 }
 
 fn WeightedBlendedWeight_u0028_f1_u003b(alpha: ptr<function, f32>) -> f32 {
@@ -17958,22 +18077,22 @@ fn WeightedBlendedWeight_u0028_f1_u003b(alpha: ptr<function, f32>) -> f32 {
     var far: f32;
     var far3_: f32;
 
-    let _e278 = ViewDepth_u0028_();
-    z = abs(_e278);
-    let _e280 = z;
-    near = (_e280 / 5f);
-    let _e282 = z;
-    far = (_e282 / 200f);
-    let _e284 = far;
+    let _e279 = ViewDepth_u0028_();
+    z = abs(_e279);
+    let _e281 = z;
+    near = (_e281 / 5f);
+    let _e283 = z;
+    far = (_e283 / 200f);
     let _e285 = far;
-    let _e287 = far;
-    far3_ = ((_e284 * _e285) * _e287);
-    let _e289 = (*alpha);
-    let _e290 = near;
+    let _e286 = far;
+    let _e288 = far;
+    far3_ = ((_e285 * _e286) * _e288);
+    let _e290 = (*alpha);
     let _e291 = near;
-    let _e294 = far3_;
+    let _e292 = near;
     let _e295 = far3_;
-    return (_e289 * clamp((10f / ((0.00001f + (_e290 * _e291)) + (_e294 * _e295))), 0.01f, 3000f));
+    let _e296 = far3_;
+    return (_e290 * clamp((10f / ((0.00001f + (_e291 * _e292)) + (_e295 * _e296))), 0.01f, 3000f));
 }
 
 fn WriteWeightedBlended_u0028_() {
@@ -17985,39 +18104,39 @@ fn WriteWeightedBlended_u0028_() {
     var revealage: bool;
     var local: vec4<f32>;
 
-    let _e282 = fog_info.forward[3u];
-    mode = _e282;
-    let _e283 = mode;
-    if (_e283 > 0.5f) {
-        let _e286 = frag_color[3u];
-        alpha_1 = _e286;
-        let _e287 = alpha_1;
-        param = _e287;
-        let _e288 = WeightedBlendedWeight_u0028_f1_u003b((&param));
-        weight = _e288;
-        let _e289 = frag_color;
-        let _e291 = weight;
-        let _e292 = (_e289.xyz * _e291);
-        let _e293 = alpha_1;
-        let _e294 = weight;
-        accumulate = vec4<f32>(_e292.x, _e292.y, _e292.z, (_e293 * _e294));
-        let _e300 = mode;
-        let _e302 = mode;
-        revealage = ((_e300 > 1.5f) && (_e302 < 2.5f));
-        let _e305 = revealage;
-        if _e305 {
-            let _e306 = alpha_1;
-            local = vec4(_e306);
+    let _e283 = fog_info.forward[3u];
+    mode = _e283;
+    let _e284 = mode;
+    if (_e284 > 0.5f) {
+        let _e287 = frag_color[3u];
+        alpha_1 = _e287;
+        let _e288 = alpha_1;
+        param = _e288;
+        let _e289 = WeightedBlendedWeight_u0028_f1_u003b((&param));
+        weight = _e289;
+        let _e290 = frag_color;
+        let _e292 = weight;
+        let _e293 = (_e290.xyz * _e292);
+        let _e294 = alpha_1;
+        let _e295 = weight;
+        accumulate = vec4<f32>(_e293.x, _e293.y, _e293.z, (_e294 * _e295));
+        let _e301 = mode;
+        let _e303 = mode;
+        revealage = ((_e301 > 1.5f) && (_e303 < 2.5f));
+        let _e306 = revealage;
+        if _e306 {
+            let _e307 = alpha_1;
+            local = vec4(_e307);
         } else {
-            let _e308 = accumulate;
-            local = _e308;
+            let _e309 = accumulate;
+            local = _e309;
         }
-        let _e309 = local;
-        frag_color = _e309;
-        let _e310 = mode;
-        if (_e310 > 2.5f) {
-            let _e312 = alpha_1;
-            frag_surface = vec4(_e312);
+        let _e310 = local;
+        frag_color = _e310;
+        let _e311 = mode;
+        if (_e311 > 2.5f) {
+            let _e313 = alpha_1;
+            frag_surface = vec4(_e313);
         }
     }
     return;
@@ -18026,29 +18145,29 @@ fn WriteWeightedBlended_u0028_() {
 fn EncodeOctahedral_u0028_vf3_u003b(n: ptr<function, vec3<f32>>) -> vec2<f32> {
     var e: vec2<f32>;
 
-    let _e276 = (*n)[0u];
-    let _e279 = (*n)[1u];
-    let _e283 = (*n)[2u];
-    let _e286 = (*n);
-    (*n) = (_e286 / vec3(((abs(_e276) + abs(_e279)) + abs(_e283))));
-    let _e289 = (*n);
-    e = _e289.xy;
-    let _e292 = (*n)[2u];
-    if (_e292 < 0f) {
-        let _e294 = (*n);
-        let _e300 = (*n)[0u];
-        let _e304 = (*n)[1u];
-        e = ((vec2(1f) - abs(_e294.yx)) * vec2<f32>(select(-1f, 1f, (_e300 >= 0f)), select(-1f, 1f, (_e304 >= 0f))));
+    let _e277 = (*n)[0u];
+    let _e280 = (*n)[1u];
+    let _e284 = (*n)[2u];
+    let _e287 = (*n);
+    (*n) = (_e287 / vec3(((abs(_e277) + abs(_e280)) + abs(_e284))));
+    let _e290 = (*n);
+    e = _e290.xy;
+    let _e293 = (*n)[2u];
+    if (_e293 < 0f) {
+        let _e295 = (*n);
+        let _e301 = (*n)[0u];
+        let _e305 = (*n)[1u];
+        e = ((vec2(1f) - abs(_e295.yx)) * vec2<f32>(select(-1f, 1f, (_e301 >= 0f)), select(-1f, 1f, (_e305 >= 0f))));
     }
-    let _e309 = e;
-    return ((_e309 * 0.5f) + vec2(0.5f));
+    let _e310 = e;
+    return ((_e310 * 0.5f) + vec2(0.5f));
 }
 
 fn LinearToSrgb_u0028_vf3_u003b(linear: ptr<function, vec3<f32>>) -> vec3<f32> {
-    let _e274 = (*linear);
-    let _e276 = (*linear);
-    let _e280 = (*linear);
-    return mix((_e274 * 12.92f), ((pow(_e276, vec3<f32>(0.41666666f, 0.41666666f, 0.41666666f)) * 1.055f) - vec3<f32>(0.055f, 0.055f, 0.055f)), step(vec3<f32>(0.0031308f, 0.0031308f, 0.0031308f), _e280));
+    let _e275 = (*linear);
+    let _e277 = (*linear);
+    let _e281 = (*linear);
+    return mix((_e275 * 12.92f), ((pow(_e277, vec3<f32>(0.41666666f, 0.41666666f, 0.41666666f)) * 1.055f) - vec3<f32>(0.055f, 0.055f, 0.055f)), step(vec3<f32>(0.0031308f, 0.0031308f, 0.0031308f), _e281));
 }
 
 fn WriteSurfaceGeometry_u0028_f1_u003b(roughness: ptr<function, f32>) {
@@ -18056,52 +18175,52 @@ fn WriteSurfaceGeometry_u0028_f1_u003b(roughness: ptr<function, f32>) {
     var geometric: vec3<f32>;
     var param_2: vec3<f32>;
 
-    let _e277 = g_albedo;
-    param_1 = clamp(_e277, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
-    let _e279 = LinearToSrgb_u0028_vf3_u003b((&param_1));
-    frag_albedo = vec4<f32>(_e279.x, _e279.y, _e279.z, 1f);
-    let _e284 = g_debug_surface_on;
-    if _e284 {
-        let _e285 = g_debug_surface;
-        let _e286 = ViewDepth_u0028_();
-        frag_surface = vec4<f32>(_e285.x, _e285.y, _e285.z, _e286);
+    let _e278 = g_albedo;
+    param_1 = clamp(_e278, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
+    let _e280 = LinearToSrgb_u0028_vf3_u003b((&param_1));
+    frag_albedo = vec4<f32>(_e280.x, _e280.y, _e280.z, 1f);
+    let _e285 = g_debug_surface_on;
+    if _e285 {
+        let _e286 = g_debug_surface;
+        let _e287 = ViewDepth_u0028_();
+        frag_surface = vec4<f32>(_e286.x, _e286.y, _e286.z, _e287);
         return;
     }
-    let _e291 = v_normal_1;
-    geometric = normalize(_e291);
-    let _e293 = gl_FrontFacing_1;
-    if !(_e293) {
-        let _e295 = geometric;
-        geometric = -(_e295);
-    }
-    let _e297 = geometric;
-    param_2 = _e297;
-    let _e298 = EncodeOctahedral_u0028_vf3_u003b((&param_2));
-    let _e299 = (*roughness);
-    let _e301 = ViewDepth_u0028_();
-    frag_surface = vec4<f32>(_e298.x, _e298.y, clamp(_e299, 0f, 1f), _e301);
+    let _e292 = v_normal_1;
+    geometric = normalize(_e292);
+    let _e294 = gl_FrontFacing_1;
+    if !(_e294) {
+        let _e296 = geometric;
+        geometric = -(_e296);
+    }
+    let _e298 = geometric;
+    param_2 = _e298;
+    let _e299 = EncodeOctahedral_u0028_vf3_u003b((&param_2));
+    let _e300 = (*roughness);
+    let _e302 = ViewDepth_u0028_();
+    frag_surface = vec4<f32>(_e299.x, _e299.y, clamp(_e300, 0f, 1f), _e302);
     return;
 }
 
 fn Orthographic_u0028_() -> bool {
-    let _e275 = fog_info.projection[0u];
-    return (_e275 > 0.5f);
+    let _e276 = fog_info.projection[0u];
+    return (_e276 > 0.5f);
 }
 
 fn EyeDistance_u0028_() -> f32 {
     var local_1: f32;
 
-    let _e274 = Orthographic_u0028_();
-    if _e274 {
-        let _e275 = ViewDepth_u0028_();
-        local_1 = max(_e275, 0f);
+    let _e275 = Orthographic_u0028_();
+    if _e275 {
+        let _e276 = ViewDepth_u0028_();
+        local_1 = max(_e276, 0f);
     } else {
-        let _e277 = v_world_position_1;
-        let _e279 = fog_info.eye;
-        local_1 = distance(_e277, _e279.xyz);
+        let _e278 = v_world_position_1;
+        let _e280 = fog_info.eye;
+        local_1 = distance(_e278, _e280.xyz);
     }
-    let _e282 = local_1;
-    return _e282;
+    let _e283 = local_1;
+    return _e283;
 }
 
 fn ApplyFog_u0028_vf3_u003b(color: ptr<function, vec3<f32>>) -> vec3<f32> {
@@ -18111,41 +18230,41 @@ fn ApplyFog_u0028_vf3_u003b(color: ptr<function, vec3<f32>>) -> vec3<f32> {
     var k: f32;
     var local_2: f32;
 
-    let _e281 = fog_info.fog[3u];
-    density = _e281;
-    let _e282 = density;
-    if (_e282 <= 0f) {
-        let _e284 = (*color);
-        return _e284;
-    }
-    let _e285 = EyeDistance_u0028_();
-    d = _e285;
-    let _e288 = fog_info.eye[3u];
-    falloff = _e288;
-    let _e289 = falloff;
-    if (_e289 > 0f) {
-        let _e291 = falloff;
-        let _e293 = v_world_position_1[1u];
-        let _e296 = fog_info.eye[1u];
-        k = (_e291 * (_e293 - _e296));
-        let _e299 = k;
-        if (abs(_e299) > 0.001f) {
-            let _e302 = k;
-            let _e306 = k;
-            local_2 = ((1f - exp(-(_e302))) / _e306);
+    let _e282 = fog_info.fog[3u];
+    density = _e282;
+    let _e283 = density;
+    if (_e283 <= 0f) {
+        let _e285 = (*color);
+        return _e285;
+    }
+    let _e286 = EyeDistance_u0028_();
+    d = _e286;
+    let _e289 = fog_info.eye[3u];
+    falloff = _e289;
+    let _e290 = falloff;
+    if (_e290 > 0f) {
+        let _e292 = falloff;
+        let _e294 = v_world_position_1[1u];
+        let _e297 = fog_info.eye[1u];
+        k = (_e292 * (_e294 - _e297));
+        let _e300 = k;
+        if (abs(_e300) > 0.001f) {
+            let _e303 = k;
+            let _e307 = k;
+            local_2 = ((1f - exp(-(_e303))) / _e307);
         } else {
-            let _e308 = k;
-            local_2 = (1f - (0.5f * _e308));
+            let _e309 = k;
+            local_2 = (1f - (0.5f * _e309));
         }
-        let _e311 = local_2;
-        let _e312 = density;
-        density = (_e312 * _e311);
+        let _e312 = local_2;
+        let _e313 = density;
+        density = (_e313 * _e312);
     }
-    let _e315 = fog_info.fog;
-    let _e317 = (*color);
-    let _e318 = density;
-    let _e320 = d;
-    return mix(_e315.xyz, _e317, vec3(clamp(exp((-(_e318) * _e320)), 0f, 1f)));
+    let _e316 = fog_info.fog;
+    let _e318 = (*color);
+    let _e319 = density;
+    let _e321 = d;
+    return mix(_e316.xyz, _e318, vec3(clamp(exp((-(_e319) * _e321)), 0f, 1f)));
 }
 
 fn WriteSurface_u0028_vf3_u003b_f1_u003b_f1_u003b(linearColor: ptr<function, vec3<f32>>, alpha_2: ptr<function, f32>, roughness_1: ptr<function, f32>) {
@@ -18153,58 +18272,58 @@ fn WriteSurface_u0028_vf3_u003b_f1_u003b_f1_u003b(linearColor: ptr<function, vec
     var param_3: vec3<f32>;
     var param_4: f32;
 
-    let _e279 = g_premultiply;
-    let _e280 = (*alpha_2);
-    weight_1 = select(1f, _e280, _e279);
-    let _e282 = (*linearColor);
-    param_3 = _e282;
-    let _e283 = ApplyFog_u0028_vf3_u003b((&param_3));
-    let _e284 = weight_1;
-    let _e285 = (_e283 * _e284);
-    let _e286 = (*alpha_2);
-    let _e287 = g_pass_through;
-    frag_color = vec4<f32>(_e285.x, _e285.y, _e285.z, (_e286 * (1f - _e287)));
-    let _e294 = (*roughness_1);
-    param_4 = _e294;
+    let _e280 = g_premultiply;
+    let _e281 = (*alpha_2);
+    weight_1 = select(1f, _e281, _e280);
+    let _e283 = (*linearColor);
+    param_3 = _e283;
+    let _e284 = ApplyFog_u0028_vf3_u003b((&param_3));
+    let _e285 = weight_1;
+    let _e286 = (_e284 * _e285);
+    let _e287 = (*alpha_2);
+    let _e288 = g_pass_through;
+    frag_color = vec4<f32>(_e286.x, _e286.y, _e286.z, (_e287 * (1f - _e288)));
+    let _e295 = (*roughness_1);
+    param_4 = _e295;
     WriteSurfaceGeometry_u0028_f1_u003b((&param_4));
     WriteWeightedBlended_u0028_();
     return;
 }
 
 fn SrgbToLinear_u0028_vf3_u003b(srgb: ptr<function, vec3<f32>>) -> vec3<f32> {
-    let _e274 = (*srgb);
-    let _e277 = (*srgb);
-    let _e282 = (*srgb);
-    return mix((_e274 / vec3(12.92f)), pow(((_e277 + vec3<f32>(0.055f, 0.055f, 0.055f)) / vec3(1.055f)), vec3<f32>(2.4f, 2.4f, 2.4f)), step(vec3<f32>(0.04045f, 0.04045f, 0.04045f), _e282));
+    let _e275 = (*srgb);
+    let _e278 = (*srgb);
+    let _e283 = (*srgb);
+    return mix((_e275 / vec3(12.92f)), pow(((_e278 + vec3<f32>(0.055f, 0.055f, 0.055f)) / vec3(1.055f)), vec3<f32>(2.4f, 2.4f, 2.4f)), step(vec3<f32>(0.04045f, 0.04045f, 0.04045f), _e283));
 }
 
 fn NonFinite_u0028_vf3_u003b(c: ptr<function, vec3<f32>>) -> bool {
     var phi_3014_: bool;
 
-    let _e274 = (*c);
     let _e275 = (*c);
-    let _e277 = any((_e274 != _e275));
-    phi_3014_ = _e277;
-    if !(_e277) {
-        let _e279 = (*c);
-        phi_3014_ = any((abs(_e279) > vec3<f32>(300000000000000000000000000000000000000f, 300000000000000000000000000000000000000f, 300000000000000000000000000000000000000f)));
-    }
-    let _e284 = phi_3014_;
-    return _e284;
+    let _e276 = (*c);
+    let _e278 = any((_e275 != _e276));
+    phi_3014_ = _e278;
+    if !(_e278) {
+        let _e280 = (*c);
+        phi_3014_ = any((abs(_e280) > vec3<f32>(300000000000000000000000000000000000000f, 300000000000000000000000000000000000000f, 300000000000000000000000000000000000000f)));
+    }
+    let _e285 = phi_3014_;
+    return _e285;
 }
 
 fn MapUv_u0028_i1_u003b(slot: ptr<function, i32>) -> vec2<f32> {
     var uvw: vec3<f32>;
 
-    let _e275 = v_texcoord_1;
-    uvw = vec3<f32>(_e275.x, _e275.y, 1f);
-    let _e279 = (*slot);
-    let _e283 = layer_info.uv_transform[(_e279 * 2i)];
-    let _e285 = uvw;
-    let _e287 = (*slot);
-    let _e292 = layer_info.uv_transform[((_e287 * 2i) + 1i)];
-    let _e294 = uvw;
-    return vec2<f32>(dot(_e283.xyz, _e285), dot(_e292.xyz, _e294));
+    let _e276 = v_texcoord_1;
+    uvw = vec3<f32>(_e276.x, _e276.y, 1f);
+    let _e280 = (*slot);
+    let _e284 = layer_info.uv_transform[(_e280 * 2i)];
+    let _e286 = uvw;
+    let _e288 = (*slot);
+    let _e293 = layer_info.uv_transform[((_e288 * 2i) + 1i)];
+    let _e295 = uvw;
+    return vec2<f32>(dot(_e284.xyz, _e286), dot(_e293.xyz, _e295));
 }
 
 fn WriteDebugView_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_vf3_u003b(s: ptr<function, Surface>, lit: ptr<function, vec3<f32>>) -> bool {
@@ -18223,79 +18342,79 @@ fn WriteDebugView_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_
     var param_10: vec3<f32>;
     var param_11: f32;
 
-    let _e291 = frag_info.debug_view[0u];
-    view = _e291;
-    let _e292 = view;
-    if (_e292 < 0.5f) {
+    let _e292 = frag_info.debug_view[0u];
+    view = _e292;
+    let _e293 = view;
+    if (_e293 < 0.5f) {
         return false;
     }
-    let _e295 = gl_FragCoord_1[0u];
-    let _e298 = frag_info.debug_view[1u];
-    let _e301 = frag_info.debug_view[2u];
-    if (_e295 < (_e298 * _e301)) {
+    let _e296 = gl_FragCoord_1[0u];
+    let _e299 = frag_info.debug_view[1u];
+    let _e302 = frag_info.debug_view[2u];
+    if (_e296 < (_e299 * _e302)) {
         return false;
     }
-    let _e304 = view;
-    code = i32((_e304 + 0.5f));
+    let _e305 = view;
+    code = i32((_e305 + 0.5f));
     shown = vec3<f32>(0f, 0f, 0f);
-    let _e307 = code;
-    if (_e307 == 1i) {
-        let _e310 = (*s).albedo;
-        param_5 = clamp(_e310, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
-        let _e312 = LinearToSrgb_u0028_vf3_u003b((&param_5));
-        shown = _e312;
-    } else {
-        let _e313 = code;
-        if (_e313 == 2i) {
-            let _e316 = (*s).n;
-            shown = ((_e316 * 0.5f) + vec3<f32>(0.5f, 0.5f, 0.5f));
+    let _e308 = code;
+    if (_e308 == 1i) {
+        let _e311 = (*s).albedo;
+        param_5 = clamp(_e311, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
+        let _e313 = LinearToSrgb_u0028_vf3_u003b((&param_5));
+        shown = _e313;
+    } else {
+        let _e314 = code;
+        if (_e314 == 2i) {
+            let _e317 = (*s).n;
+            shown = ((_e317 * 0.5f) + vec3<f32>(0.5f, 0.5f, 0.5f));
         } else {
-            let _e319 = code;
-            if (_e319 == 3i) {
-                let _e322 = (*s).roughness;
-                shown = vec3(clamp(_e322, 0f, 1f));
+            let _e320 = code;
+            if (_e320 == 3i) {
+                let _e323 = (*s).roughness;
+                shown = vec3(clamp(_e323, 0f, 1f));
             } else {
-                let _e325 = code;
-                if (_e325 == 4i) {
-                    let _e328 = (*s).metallic;
-                    shown = vec3(clamp(_e328, 0f, 1f));
+                let _e326 = code;
+                if (_e326 == 4i) {
+                    let _e329 = (*s).metallic;
+                    shown = vec3(clamp(_e329, 0f, 1f));
                 } else {
-                    let _e331 = code;
-                    if (_e331 == 5i) {
-                        let _e334 = (*s).occlusion;
-                        shown = vec3(clamp(_e334, 0f, 1f));
+                    let _e332 = code;
+                    if (_e332 == 5i) {
+                        let _e335 = (*s).occlusion;
+                        shown = vec3(clamp(_e335, 0f, 1f));
                     } else {
-                        let _e337 = code;
-                        if (_e337 == 6i) {
-                            let _e340 = (*s).emissive;
-                            param_6 = clamp(_e340, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
-                            let _e342 = LinearToSrgb_u0028_vf3_u003b((&param_6));
-                            shown = _e342;
+                        let _e338 = code;
+                        if (_e338 == 6i) {
+                            let _e341 = (*s).emissive;
+                            param_6 = clamp(_e341, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
+                            let _e343 = LinearToSrgb_u0028_vf3_u003b((&param_6));
+                            shown = _e343;
                         } else {
-                            let _e343 = code;
-                            if (_e343 == 7i) {
+                            let _e344 = code;
+                            if (_e344 == 7i) {
                                 param_7 = 0i;
-                                let _e345 = MapUv_u0028_i1_u003b((&param_7));
-                                let _e346 = fract(_e345);
-                                shown = vec3<f32>(_e346.x, _e346.y, 0f);
+                                let _e346 = MapUv_u0028_i1_u003b((&param_7));
+                                let _e347 = fract(_e346);
+                                shown = vec3<f32>(_e347.x, _e347.y, 0f);
                             } else {
-                                let _e350 = code;
-                                if (_e350 == 8i) {
-                                    let _e352 = (*lit);
-                                    param_8 = clamp(_e352, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
-                                    let _e354 = LinearToSrgb_u0028_vf3_u003b((&param_8));
-                                    grey = dot(_e354, vec3<f32>(0.2126f, 0.7152f, 0.0722f));
-                                    let _e356 = (*lit);
-                                    param_9 = _e356;
-                                    let _e357 = NonFinite_u0028_vf3_u003b((&param_9));
-                                    if _e357 {
+                                let _e351 = code;
+                                if (_e351 == 8i) {
+                                    let _e353 = (*lit);
+                                    param_8 = clamp(_e353, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
+                                    let _e355 = LinearToSrgb_u0028_vf3_u003b((&param_8));
+                                    grey = dot(_e355, vec3<f32>(0.2126f, 0.7152f, 0.0722f));
+                                    let _e357 = (*lit);
+                                    param_9 = _e357;
+                                    let _e358 = NonFinite_u0028_vf3_u003b((&param_9));
+                                    if _e358 {
                                         local_3 = vec3<f32>(1f, 0f, 1f);
                                     } else {
-                                        let _e358 = grey;
-                                        local_3 = vec3((_e358 * 0.5f));
+                                        let _e359 = grey;
+                                        local_3 = vec3((_e359 * 0.5f));
                                     }
-                                    let _e361 = local_3;
-                                    shown = _e361;
+                                    let _e362 = local_3;
+                                    shown = _e362;
                                 }
                             }
                         }
@@ -18304,24 +18423,24 @@ fn WriteDebugView_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_
             }
         }
     }
-    let _e362 = g_premultiply;
-    if _e362 {
-        let _e364 = (*s).alpha;
-        local_4 = _e364;
+    let _e363 = g_premultiply;
+    if _e363 {
+        let _e365 = (*s).alpha;
+        local_4 = _e365;
     } else {
         local_4 = 1f;
     }
-    let _e365 = local_4;
-    weight_2 = _e365;
-    let _e366 = shown;
-    param_10 = _e366;
-    let _e367 = SrgbToLinear_u0028_vf3_u003b((&param_10));
-    let _e368 = weight_2;
-    let _e369 = (_e367 * _e368);
-    let _e371 = (*s).alpha;
-    frag_color = vec4<f32>(_e369.x, _e369.y, _e369.z, _e371);
-    let _e377 = (*s).roughness;
-    param_11 = _e377;
+    let _e366 = local_4;
+    weight_2 = _e366;
+    let _e367 = shown;
+    param_10 = _e367;
+    let _e368 = SrgbToLinear_u0028_vf3_u003b((&param_10));
+    let _e369 = weight_2;
+    let _e370 = (_e368 * _e369);
+    let _e372 = (*s).alpha;
+    frag_color = vec4<f32>(_e370.x, _e370.y, _e370.z, _e372);
+    let _e378 = (*s).roughness;
+    param_11 = _e378;
     WriteSurfaceGeometry_u0028_f1_u003b((&param_11));
     WriteWeightedBlended_u0028_();
     return true;
@@ -18332,42 +18451,42 @@ fn V_SmithGGXCorrelated_u0028_f1_u003b_f1_u003b_f1_u003b(n_dot_v: ptr<function,
     var lambda_v: f32;
     var lambda_l: f32;
 
-    let _e279 = (*alpha_3);
     let _e280 = (*alpha_3);
-    a2_ = (_e279 * _e280);
-    let _e282 = (*n_dot_l);
-    let _e283 = (*n_dot_v);
+    let _e281 = (*alpha_3);
+    a2_ = (_e280 * _e281);
+    let _e283 = (*n_dot_l);
     let _e284 = (*n_dot_v);
-    let _e286 = a2_;
-    let _e289 = a2_;
-    lambda_v = (_e282 * sqrt((((_e283 * _e284) * (1f - _e286)) + _e289)));
-    let _e293 = (*n_dot_v);
-    let _e294 = (*n_dot_l);
+    let _e285 = (*n_dot_v);
+    let _e287 = a2_;
+    let _e290 = a2_;
+    lambda_v = (_e283 * sqrt((((_e284 * _e285) * (1f - _e287)) + _e290)));
+    let _e294 = (*n_dot_v);
     let _e295 = (*n_dot_l);
-    let _e297 = a2_;
-    let _e300 = a2_;
-    lambda_l = (_e293 * sqrt((((_e294 * _e295) * (1f - _e297)) + _e300)));
-    let _e304 = lambda_v;
-    let _e305 = lambda_l;
-    return (0.5f / max((_e304 + _e305), 0.00001f));
+    let _e296 = (*n_dot_l);
+    let _e298 = a2_;
+    let _e301 = a2_;
+    lambda_l = (_e294 * sqrt((((_e295 * _e296) * (1f - _e298)) + _e301)));
+    let _e305 = lambda_v;
+    let _e306 = lambda_l;
+    return (0.5f / max((_e305 + _e306), 0.00001f));
 }
 
 fn D_GGX_u0028_f1_u003b_f1_u003b(n_dot_h: ptr<function, f32>, alpha_4: ptr<function, f32>) -> f32 {
     var a: f32;
     var k_1: f32;
 
-    let _e277 = (*n_dot_h);
-    let _e278 = (*alpha_4);
-    a = (_e277 * _e278);
-    let _e280 = (*alpha_4);
-    let _e281 = (*n_dot_h);
+    let _e278 = (*n_dot_h);
+    let _e279 = (*alpha_4);
+    a = (_e278 * _e279);
+    let _e281 = (*alpha_4);
     let _e282 = (*n_dot_h);
-    let _e285 = a;
+    let _e283 = (*n_dot_h);
     let _e286 = a;
-    k_1 = (_e280 / max(((1f - (_e281 * _e282)) + (_e285 * _e286)), 0.0000001f));
-    let _e291 = k_1;
+    let _e287 = a;
+    k_1 = (_e281 / max(((1f - (_e282 * _e283)) + (_e286 * _e287)), 0.0000001f));
     let _e292 = k_1;
-    return ((_e291 * _e292) * 0.31830987f);
+    let _e293 = k_1;
+    return ((_e292 * _e293) * 0.31830987f);
 }
 
 fn LtcEdge_u0028_vf3_u003b_vf3_u003b(a_1: ptr<function, vec3<f32>>, b: ptr<function, vec3<f32>>) -> vec3<f32> {
@@ -18376,37 +18495,37 @@ fn LtcEdge_u0028_vf3_u003b_vf3_u003b(a_1: ptr<function, vec3<f32>>, b: ptr<funct
     var angle: f32;
     var local_5: vec3<f32>;
 
-    let _e279 = (*a_1);
-    let _e280 = (*b);
-    axis = cross(_e279, _e280);
-    let _e282 = axis;
-    len = length(_e282);
-    let _e284 = (*a_1);
-    let _e285 = (*b);
-    angle = acos(clamp(dot(_e284, _e285), -1f, 1f));
-    let _e289 = len;
-    if (_e289 > 0.000001f) {
-        let _e291 = axis;
-        let _e292 = angle;
-        let _e293 = len;
-        local_5 = (_e291 * (_e292 / (_e293 * 6.2831855f)));
+    let _e280 = (*a_1);
+    let _e281 = (*b);
+    axis = cross(_e280, _e281);
+    let _e283 = axis;
+    len = length(_e283);
+    let _e285 = (*a_1);
+    let _e286 = (*b);
+    angle = acos(clamp(dot(_e285, _e286), -1f, 1f));
+    let _e290 = len;
+    if (_e290 > 0.000001f) {
+        let _e292 = axis;
+        let _e293 = angle;
+        let _e294 = len;
+        local_5 = (_e292 * (_e293 / (_e294 * 6.2831855f)));
     } else {
         local_5 = vec3<f32>(0f, 0f, 0f);
     }
-    let _e297 = local_5;
-    return _e297;
+    let _e298 = local_5;
+    return _e298;
 }
 
 fn LtcUv_u0028_f1_u003b_f1_u003b_f1_u003b(x: ptr<function, f32>, y: ptr<function, f32>, table: ptr<function, f32>) -> vec2<f32> {
     var inTable: vec2<f32>;
 
-    let _e277 = (*x);
-    let _e278 = (*y);
-    inTable = ((vec2<f32>(_e277, _e278) * 0.984375f) + vec2(0.0078125f));
-    let _e284 = inTable[0u];
-    let _e286 = inTable[1u];
-    let _e287 = (*table);
-    return vec2<f32>(_e284, ((_e286 + _e287) * 0.5f));
+    let _e278 = (*x);
+    let _e279 = (*y);
+    inTable = ((vec2<f32>(_e278, _e279) * 0.984375f) + vec2(0.0078125f));
+    let _e285 = inTable[0u];
+    let _e287 = inTable[1u];
+    let _e288 = (*table);
+    return vec2<f32>(_e285, ((_e287 + _e288) * 0.5f));
 }
 
 fn LtcRectangle_u0028_vf3_u003b_vf3_u003b_f1_u003b_vf3_u005b_4_u005d_u003b(n_1: ptr<function, vec3<f32>>, v: ptr<function, vec3<f32>>, roughness_2: ptr<function, f32>, corners: ptr<function, array<vec3<f32>, 4>>) -> vec3<f32> {
@@ -18445,126 +18564,126 @@ fn LtcRectangle_u0028_vf3_u003b_vf3_u003b_f1_u003b_vf3_u005b_4_u005d_u003b(n_1:
     var param_27: f32;
     var param_28: f32;
 
-    let _e311 = (*roughness_2);
-    let _e313 = (*n_1);
-    let _e314 = (*v);
-    uv = vec2<f32>(clamp(_e311, 0f, 1f), sqrt(clamp((1f - dot(_e313, _e314)), 0f, 1f)));
-    let _e321 = uv[0u];
-    param_12 = _e321;
-    let _e323 = uv[1u];
-    param_13 = _e323;
+    let _e312 = (*roughness_2);
+    let _e314 = (*n_1);
+    let _e315 = (*v);
+    uv = vec2<f32>(clamp(_e312, 0f, 1f), sqrt(clamp((1f - dot(_e314, _e315)), 0f, 1f)));
+    let _e322 = uv[0u];
+    param_12 = _e322;
+    let _e324 = uv[1u];
+    param_13 = _e324;
     param_14 = 0f;
-    let _e324 = LtcUv_u0028_f1_u003b_f1_u003b_f1_u003b((&param_12), (&param_13), (&param_14));
-    let _e325 = textureSampleLevel(ltc_texture_tex, ltc_texture_smp, _e324, 0f);
-    inverse = _e325;
-    let _e327 = uv[0u];
-    param_15 = _e327;
-    let _e329 = uv[1u];
-    param_16 = _e329;
+    let _e325 = LtcUv_u0028_f1_u003b_f1_u003b_f1_u003b((&param_12), (&param_13), (&param_14));
+    let _e326 = textureSampleLevel(ltc_texture_tex, ltc_texture_smp, _e325, 0f);
+    inverse = _e326;
+    let _e328 = uv[0u];
+    param_15 = _e328;
+    let _e330 = uv[1u];
+    param_16 = _e330;
     param_17 = 1f;
-    let _e330 = LtcUv_u0028_f1_u003b_f1_u003b_f1_u003b((&param_15), (&param_16), (&param_17));
-    let _e331 = textureSampleLevel(ltc_texture_tex, ltc_texture_smp, _e330, 0f);
-    fit = _e331;
-    let _e332 = (*v);
-    let _e333 = (*n_1);
-    let _e334 = (*v);
-    let _e335 = (*n_1);
-    along = (_e332 - (_e333 * dot(_e334, _e335)));
-    let _e339 = along;
-    alongLength = length(_e339);
-    let _e341 = alongLength;
-    if (_e341 > 0.00001f) {
-        let _e343 = along;
-        let _e344 = alongLength;
-        local_6 = (_e343 / vec3(_e344));
-    } else {
-        let _e347 = (*n_1);
-        let _e349 = (*n_1)[2u];
-        local_6 = normalize(cross(_e347, select(vec3<f32>(1f, 0f, 0f), vec3<f32>(0f, 0f, 1f), vec3((abs(_e349) < 0.999f)))));
-    }
-    let _e356 = local_6;
-    t1_ = _e356;
-    let _e357 = (*n_1);
-    let _e358 = t1_;
-    t2_ = cross(_e357, _e358);
-    let _e361 = inverse[0u];
-    let _e363 = inverse[1u];
-    let _e364 = vec3<f32>(_e361, 0f, _e363);
-    let _e366 = inverse[2u];
-    let _e368 = inverse[3u];
-    let _e369 = vec3<f32>(_e366, 0f, _e368);
-    minv = mat3x3<f32>(vec3<f32>(_e364.x, _e364.y, _e364.z), vec3<f32>(vec3<f32>(0f, 1f, 0f).x, vec3<f32>(0f, 1f, 0f).y, vec3<f32>(0f, 1f, 0f).z), vec3<f32>(_e369.x, _e369.y, _e369.z));
+    let _e331 = LtcUv_u0028_f1_u003b_f1_u003b_f1_u003b((&param_15), (&param_16), (&param_17));
+    let _e332 = textureSampleLevel(ltc_texture_tex, ltc_texture_smp, _e331, 0f);
+    fit = _e332;
+    let _e333 = (*v);
+    let _e334 = (*n_1);
+    let _e335 = (*v);
+    let _e336 = (*n_1);
+    along = (_e333 - (_e334 * dot(_e335, _e336)));
+    let _e340 = along;
+    alongLength = length(_e340);
+    let _e342 = alongLength;
+    if (_e342 > 0.00001f) {
+        let _e344 = along;
+        let _e345 = alongLength;
+        local_6 = (_e344 / vec3(_e345));
+    } else {
+        let _e348 = (*n_1);
+        let _e350 = (*n_1)[2u];
+        local_6 = normalize(cross(_e348, select(vec3<f32>(1f, 0f, 0f), vec3<f32>(0f, 0f, 1f), vec3((abs(_e350) < 0.999f)))));
+    }
+    let _e357 = local_6;
+    t1_ = _e357;
+    let _e358 = (*n_1);
+    let _e359 = t1_;
+    t2_ = cross(_e358, _e359);
+    let _e362 = inverse[0u];
+    let _e364 = inverse[1u];
+    let _e365 = vec3<f32>(_e362, 0f, _e364);
+    let _e367 = inverse[2u];
+    let _e369 = inverse[3u];
+    let _e370 = vec3<f32>(_e367, 0f, _e369);
+    minv = mat3x3<f32>(vec3<f32>(_e365.x, _e365.y, _e365.z), vec3<f32>(vec3<f32>(0f, 1f, 0f).x, vec3<f32>(0f, 1f, 0f).y, vec3<f32>(0f, 1f, 0f).z), vec3<f32>(_e370.x, _e370.y, _e370.z));
     i = 0i;
     loop {
-        let _e383 = i;
-        if (_e383 < 4i) {
-            let _e385 = i;
-            let _e387 = (*corners)[_e385];
-            p = _e387;
-            let _e388 = i;
-            let _e389 = minv;
-            let _e390 = p;
-            let _e391 = t1_;
-            let _e393 = p;
-            let _e394 = t2_;
-            let _e396 = p;
-            let _e397 = (*n_1);
-            l[_e388] = normalize((_e389 * vec3<f32>(dot(_e390, _e391), dot(_e393, _e394), dot(_e396, _e397))));
+        let _e384 = i;
+        if (_e384 < 4i) {
+            let _e386 = i;
+            let _e388 = (*corners)[_e386];
+            p = _e388;
+            let _e389 = i;
+            let _e390 = minv;
+            let _e391 = p;
+            let _e392 = t1_;
+            let _e394 = p;
+            let _e395 = t2_;
+            let _e397 = p;
+            let _e398 = (*n_1);
+            l[_e389] = normalize((_e390 * vec3<f32>(dot(_e391, _e392), dot(_e394, _e395), dot(_e397, _e398))));
             continue;
         } else {
             break;
         }
         continuing {
-            let _e403 = i;
-            i = (_e403 + 1i);
-        }
-    }
-    let _e406 = l[0i];
-    param_18 = _e406;
-    let _e408 = l[1i];
-    param_19 = _e408;
-    let _e409 = LtcEdge_u0028_vf3_u003b_vf3_u003b((&param_18), (&param_19));
-    let _e411 = l[1i];
-    param_20 = _e411;
-    let _e413 = l[2i];
-    param_21 = _e413;
-    let _e414 = LtcEdge_u0028_vf3_u003b_vf3_u003b((&param_20), (&param_21));
-    let _e417 = l[2i];
-    param_22 = _e417;
-    let _e419 = l[3i];
-    param_23 = _e419;
-    let _e420 = LtcEdge_u0028_vf3_u003b_vf3_u003b((&param_22), (&param_23));
-    let _e423 = l[3i];
-    param_24 = _e423;
-    let _e425 = l[0i];
-    param_25 = _e425;
-    let _e426 = LtcEdge_u0028_vf3_u003b_vf3_u003b((&param_24), (&param_25));
-    f = -((((_e409 + _e414) + _e420) + _e426));
-    let _e429 = f;
-    len_1 = length(_e429);
-    let _e431 = len_1;
-    if (_e431 > 0.000000001f) {
-        let _e434 = f[2u];
-        let _e435 = len_1;
-        local_7 = (_e434 / _e435);
+            let _e404 = i;
+            i = (_e404 + 1i);
+        }
+    }
+    let _e407 = l[0i];
+    param_18 = _e407;
+    let _e409 = l[1i];
+    param_19 = _e409;
+    let _e410 = LtcEdge_u0028_vf3_u003b_vf3_u003b((&param_18), (&param_19));
+    let _e412 = l[1i];
+    param_20 = _e412;
+    let _e414 = l[2i];
+    param_21 = _e414;
+    let _e415 = LtcEdge_u0028_vf3_u003b_vf3_u003b((&param_20), (&param_21));
+    let _e418 = l[2i];
+    param_22 = _e418;
+    let _e420 = l[3i];
+    param_23 = _e420;
+    let _e421 = LtcEdge_u0028_vf3_u003b_vf3_u003b((&param_22), (&param_23));
+    let _e424 = l[3i];
+    param_24 = _e424;
+    let _e426 = l[0i];
+    param_25 = _e426;
+    let _e427 = LtcEdge_u0028_vf3_u003b_vf3_u003b((&param_24), (&param_25));
+    f = -((((_e410 + _e415) + _e421) + _e427));
+    let _e430 = f;
+    len_1 = length(_e430);
+    let _e432 = len_1;
+    if (_e432 > 0.000000001f) {
+        let _e435 = f[2u];
+        let _e436 = len_1;
+        local_7 = (_e435 / _e436);
     } else {
         local_7 = 0f;
     }
-    let _e437 = local_7;
-    z_1 = _e437;
-    let _e438 = z_1;
-    let _e441 = len_1;
-    param_26 = ((_e438 * 0.5f) + 0.5f);
-    param_27 = clamp(_e441, 0f, 1f);
+    let _e438 = local_7;
+    z_1 = _e438;
+    let _e439 = z_1;
+    let _e442 = len_1;
+    param_26 = ((_e439 * 0.5f) + 0.5f);
+    param_27 = clamp(_e442, 0f, 1f);
     param_28 = 1f;
-    let _e443 = LtcUv_u0028_f1_u003b_f1_u003b_f1_u003b((&param_26), (&param_27), (&param_28));
-    let _e444 = textureSampleLevel(ltc_texture_tex, ltc_texture_smp, _e443, 0f);
-    sphere = _e444.w;
-    let _e446 = len_1;
-    let _e447 = sphere;
-    let _e451 = fit[0u];
-    let _e453 = fit[1u];
-    return vec3<f32>(max((_e446 * _e447), 0f), _e451, _e453);
+    let _e444 = LtcUv_u0028_f1_u003b_f1_u003b_f1_u003b((&param_26), (&param_27), (&param_28));
+    let _e445 = textureSampleLevel(ltc_texture_tex, ltc_texture_smp, _e444, 0f);
+    sphere = _e445.w;
+    let _e447 = len_1;
+    let _e448 = sphere;
+    let _e452 = fit[0u];
+    let _e454 = fit[1u];
+    return vec3<f32>(max((_e447 * _e448), 0f), _e452, _e454);
 }
 
 fn CoatLobe_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b(s_1: ptr<function, Surface>, light: ptr<function, LightSample>) -> f32 {
@@ -18586,115 +18705,115 @@ fn CoatLobe_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u0
     var param_37: f32;
     var f_1: f32;
 
-    let _e293 = (*light).integrated;
-    if (_e293 > 0.5f) {
-        let _e295 = g_coat_n;
-        param_29 = _e295;
-        let _e297 = (*s_1).v;
-        param_30 = _e297;
-        let _e298 = g_coat_roughness;
-        param_31 = _e298;
-        let _e299 = g_rect_corners;
-        param_32 = _e299;
-        let _e300 = LtcRectangle_u0028_vf3_u003b_vf3_u003b_f1_u003b_vf3_u005b_4_u005d_u003b((&param_29), (&param_30), (&param_31), (&param_32));
-        ltc = _e300;
-        let _e302 = ltc[0u];
-        let _e304 = ltc[1u];
-        let _e307 = ltc[2u];
-        let _e313 = frag_info.material[3u];
-        let _e316 = (*light).n_dot_l;
-        return (((_e302 * ((0.04f * _e304) + (0.96f * _e307))) * _e313) / max(_e316, 0.000001f));
-    }
-    let _e319 = g_coat_roughness;
-    lobe = max(_e319, 0.045f);
-    let _e321 = lobe;
+    let _e294 = (*light).integrated;
+    if (_e294 > 0.5f) {
+        let _e296 = g_coat_n;
+        param_29 = _e296;
+        let _e298 = (*s_1).v;
+        param_30 = _e298;
+        let _e299 = g_coat_roughness;
+        param_31 = _e299;
+        let _e300 = g_rect_corners;
+        param_32 = _e300;
+        let _e301 = LtcRectangle_u0028_vf3_u003b_vf3_u003b_f1_u003b_vf3_u005b_4_u005d_u003b((&param_29), (&param_30), (&param_31), (&param_32));
+        ltc = _e301;
+        let _e303 = ltc[0u];
+        let _e305 = ltc[1u];
+        let _e308 = ltc[2u];
+        let _e314 = frag_info.material[3u];
+        let _e317 = (*light).n_dot_l;
+        return (((_e303 * ((0.04f * _e305) + (0.96f * _e308))) * _e314) / max(_e317, 0.000001f));
+    }
+    let _e320 = g_coat_roughness;
+    lobe = max(_e320, 0.045f);
     let _e322 = lobe;
-    alpha_5 = (_e321 * _e322);
-    let _e324 = g_coat_n;
-    let _e326 = (*light).l;
-    n_dot_l_1 = max(dot(_e324, _e326), 0f);
-    let _e329 = g_coat_n;
-    let _e331 = (*light).h;
-    n_dot_h_1 = max(dot(_e329, _e331), 0f);
-    let _e334 = n_dot_h_1;
-    param_33 = _e334;
-    let _e335 = alpha_5;
-    param_34 = _e335;
-    let _e336 = D_GGX_u0028_f1_u003b_f1_u003b((&param_33), (&param_34));
-    d_1 = _e336;
-    let _e337 = g_coat_n_dot_v;
-    param_35 = _e337;
-    let _e338 = n_dot_l_1;
-    param_36 = _e338;
-    let _e339 = alpha_5;
-    param_37 = _e339;
-    let _e340 = V_SmithGGXCorrelated_u0028_f1_u003b_f1_u003b_f1_u003b((&param_35), (&param_36), (&param_37));
-    vis = _e340;
-    let _e342 = (*light).v_dot_h;
-    f_1 = (0.04f + (0.96f * pow((1f - _e342), 5f)));
-    let _e347 = d_1;
-    let _e348 = vis;
-    let _e350 = f_1;
-    let _e354 = frag_info.material[3u];
-    let _e356 = n_dot_l_1;
-    let _e359 = (*light).n_dot_l;
-    return (((((_e347 * _e348) * _e350) * _e354) * _e356) / max(_e359, 0.000001f));
+    let _e323 = lobe;
+    alpha_5 = (_e322 * _e323);
+    let _e325 = g_coat_n;
+    let _e327 = (*light).l;
+    n_dot_l_1 = max(dot(_e325, _e327), 0f);
+    let _e330 = g_coat_n;
+    let _e332 = (*light).h;
+    n_dot_h_1 = max(dot(_e330, _e332), 0f);
+    let _e335 = n_dot_h_1;
+    param_33 = _e335;
+    let _e336 = alpha_5;
+    param_34 = _e336;
+    let _e337 = D_GGX_u0028_f1_u003b_f1_u003b((&param_33), (&param_34));
+    d_1 = _e337;
+    let _e338 = g_coat_n_dot_v;
+    param_35 = _e338;
+    let _e339 = n_dot_l_1;
+    param_36 = _e339;
+    let _e340 = alpha_5;
+    param_37 = _e340;
+    let _e341 = V_SmithGGXCorrelated_u0028_f1_u003b_f1_u003b_f1_u003b((&param_35), (&param_36), (&param_37));
+    vis = _e341;
+    let _e343 = (*light).v_dot_h;
+    f_1 = (0.04f + (0.96f * pow((1f - _e343), 5f)));
+    let _e348 = d_1;
+    let _e349 = vis;
+    let _e351 = f_1;
+    let _e355 = frag_info.material[3u];
+    let _e357 = n_dot_l_1;
+    let _e360 = (*light).n_dot_l;
+    return (((((_e348 * _e349) * _e351) * _e355) * _e357) / max(_e360, 0.000001f));
 }
 
 fn V_Neubelt_u0028_f1_u003b_f1_u003b(n_dot_v_1: ptr<function, f32>, n_dot_l_2: ptr<function, f32>) -> f32 {
-    let _e275 = (*n_dot_l_2);
-    let _e276 = (*n_dot_v_1);
-    let _e278 = (*n_dot_l_2);
-    let _e279 = (*n_dot_v_1);
-    return (1f / (4f * ((_e275 + _e276) - (_e278 * _e279))));
+    let _e276 = (*n_dot_l_2);
+    let _e277 = (*n_dot_v_1);
+    let _e279 = (*n_dot_l_2);
+    let _e280 = (*n_dot_v_1);
+    return (1f / (4f * ((_e276 + _e277) - (_e279 * _e280))));
 }
 
 fn D_Charlie_u0028_f1_u003b_f1_u003b(roughness_3: ptr<function, f32>, n_dot_h_2: ptr<function, f32>) -> f32 {
     var inv_alpha: f32;
     var sin2h: f32;
 
-    let _e277 = (*roughness_3);
     let _e278 = (*roughness_3);
-    inv_alpha = (1f / (_e277 * _e278));
-    let _e281 = (*n_dot_h_2);
+    let _e279 = (*roughness_3);
+    inv_alpha = (1f / (_e278 * _e279));
     let _e282 = (*n_dot_h_2);
-    sin2h = max((1f - (_e281 * _e282)), 0.0078125f);
-    let _e286 = inv_alpha;
-    let _e288 = sin2h;
-    let _e289 = inv_alpha;
-    return (((2f + _e286) * pow(_e288, (_e289 * 0.5f))) / 6.2831855f);
+    let _e283 = (*n_dot_h_2);
+    sin2h = max((1f - (_e282 * _e283)), 0.0078125f);
+    let _e287 = inv_alpha;
+    let _e289 = sin2h;
+    let _e290 = inv_alpha;
+    return (((2f + _e287) * pow(_e289, (_e290 * 0.5f))) / 6.2831855f);
 }
 
 fn FonAlbedo_u0028_f1_u003b_f1_u003b(mu: ptr<function, f32>, r: ptr<function, f32>) -> f32 {
     var m: f32;
     var g: f32;
 
-    let _e277 = (*mu);
-    m = (1f - _e277);
-    let _e279 = m;
+    let _e278 = (*mu);
+    m = (1f - _e278);
     let _e280 = m;
     let _e281 = m;
     let _e282 = m;
-    g = (_e279 * (0.05710853f + (_e280 * (0.49188188f + (_e281 * (-0.33218145f + (_e282 * 0.071443f)))))));
-    let _e290 = (*r);
-    let _e291 = g;
-    let _e294 = (*r);
-    return ((1f + (_e290 * _e291)) / (1f + (0.2877934f * _e294)));
+    let _e283 = m;
+    g = (_e280 * (0.05710853f + (_e281 * (0.49188188f + (_e282 * (-0.33218145f + (_e283 * 0.071443f)))))));
+    let _e291 = (*r);
+    let _e292 = g;
+    let _e295 = (*r);
+    return ((1f + (_e291 * _e292)) / (1f + (0.2877934f * _e295)));
 }
 
 fn EonMultiAlbedo_u0028_vf3_u003b_f1_u003b(rho: ptr<function, vec3<f32>>, average: ptr<function, f32>) -> vec3<f32> {
-    let _e275 = (*rho);
     let _e276 = (*rho);
-    let _e278 = (*average);
-    let _e280 = (*rho);
-    let _e281 = (*average);
-    return (((_e275 * _e276) * _e278) / (vec3<f32>(1f, 1f, 1f) - (_e280 * (1f - _e281))));
+    let _e277 = (*rho);
+    let _e279 = (*average);
+    let _e281 = (*rho);
+    let _e282 = (*average);
+    return (((_e276 * _e277) * _e279) / (vec3<f32>(1f, 1f, 1f) - (_e281 * (1f - _e282))));
 }
 
 fn FonAverage_u0028_f1_u003b(r_1: ptr<function, f32>) -> f32 {
-    let _e274 = (*r_1);
-    let _e277 = (*r_1);
-    return ((1f + (0.07248821f * _e274)) / (1f + (0.2877934f * _e277)));
+    let _e275 = (*r_1);
+    let _e278 = (*r_1);
+    return ((1f + (0.07248821f * _e275)) / (1f + (0.2877934f * _e278)));
 }
 
 fn EonLobe_u0028_vf3_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b(rho_1: ptr<function, vec3<f32>>, r_2: ptr<function, f32>, mu_i: ptr<function, f32>, mu_o: ptr<function, f32>, l_dot_v: ptr<function, f32>) -> vec3<f32> {
@@ -18713,58 +18832,58 @@ fn EonLobe_u0028_vf3_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b(rho_1: ptr<functi
     var param_43: f32;
     var param_44: f32;
 
-    let _e292 = (*l_dot_v);
-    let _e293 = (*mu_i);
-    let _e294 = (*mu_o);
-    s_2 = (_e292 - (_e293 * _e294));
-    let _e297 = s_2;
-    if (_e297 > 0f) {
-        let _e299 = s_2;
-        let _e300 = (*mu_i);
-        let _e301 = (*mu_o);
-        local_8 = (_e299 / max(_e300, _e301));
-    } else {
-        let _e304 = s_2;
-        local_8 = _e304;
-    }
-    let _e305 = local_8;
-    s_over_t = _e305;
-    let _e306 = (*r_2);
-    af = (1f / (1f + (0.2877934f * _e306)));
-    let _e310 = (*rho_1);
-    let _e311 = af;
-    let _e312 = (*r_2);
-    let _e313 = s_over_t;
-    single = (_e310 * (_e311 * (1f + (_e312 * _e313))));
-    let _e318 = (*r_2);
-    param_38 = _e318;
-    let _e319 = FonAverage_u0028_f1_u003b((&param_38));
-    average_1 = _e319;
-    let _e320 = (*rho_1);
-    param_39 = _e320;
-    let _e321 = average_1;
-    param_40 = _e321;
-    let _e322 = EonMultiAlbedo_u0028_vf3_u003b_f1_u003b((&param_39), (&param_40));
-    let _e323 = (*mu_o);
-    param_41 = _e323;
-    let _e324 = (*r_2);
-    param_42 = _e324;
-    let _e325 = FonAlbedo_u0028_f1_u003b_f1_u003b((&param_41), (&param_42));
-    let _e328 = (*mu_i);
-    param_43 = _e328;
-    let _e329 = (*r_2);
-    param_44 = _e329;
-    let _e330 = FonAlbedo_u0028_f1_u003b_f1_u003b((&param_43), (&param_44));
-    let _e334 = average_1;
-    multi = (_e322 * ((max((1f - _e325), 0.0000001f) * max((1f - _e330), 0.0000001f)) / max((1f - _e334), 0.0000001f)));
-    let _e339 = single;
-    let _e340 = multi;
-    return ((_e339 + _e340) / vec3(3.1415927f));
+    let _e293 = (*l_dot_v);
+    let _e294 = (*mu_i);
+    let _e295 = (*mu_o);
+    s_2 = (_e293 - (_e294 * _e295));
+    let _e298 = s_2;
+    if (_e298 > 0f) {
+        let _e300 = s_2;
+        let _e301 = (*mu_i);
+        let _e302 = (*mu_o);
+        local_8 = (_e300 / max(_e301, _e302));
+    } else {
+        let _e305 = s_2;
+        local_8 = _e305;
+    }
+    let _e306 = local_8;
+    s_over_t = _e306;
+    let _e307 = (*r_2);
+    af = (1f / (1f + (0.2877934f * _e307)));
+    let _e311 = (*rho_1);
+    let _e312 = af;
+    let _e313 = (*r_2);
+    let _e314 = s_over_t;
+    single = (_e311 * (_e312 * (1f + (_e313 * _e314))));
+    let _e319 = (*r_2);
+    param_38 = _e319;
+    let _e320 = FonAverage_u0028_f1_u003b((&param_38));
+    average_1 = _e320;
+    let _e321 = (*rho_1);
+    param_39 = _e321;
+    let _e322 = average_1;
+    param_40 = _e322;
+    let _e323 = EonMultiAlbedo_u0028_vf3_u003b_f1_u003b((&param_39), (&param_40));
+    let _e324 = (*mu_o);
+    param_41 = _e324;
+    let _e325 = (*r_2);
+    param_42 = _e325;
+    let _e326 = FonAlbedo_u0028_f1_u003b_f1_u003b((&param_41), (&param_42));
+    let _e329 = (*mu_i);
+    param_43 = _e329;
+    let _e330 = (*r_2);
+    param_44 = _e330;
+    let _e331 = FonAlbedo_u0028_f1_u003b_f1_u003b((&param_43), (&param_44));
+    let _e335 = average_1;
+    multi = (_e323 * ((max((1f - _e326), 0.0000001f) * max((1f - _e331), 0.0000001f)) / max((1f - _e335), 0.0000001f)));
+    let _e340 = single;
+    let _e341 = multi;
+    return ((_e340 + _e341) / vec3(3.1415927f));
 }
 
 fn EonDiffuse_u0028_() -> bool {
-    let _e275 = frag_info.ambient_sky[3u];
-    return (_e275 > 0.5f);
+    let _e276 = frag_info.ambient_sky[3u];
+    return (_e276 > 0.5f);
 }
 
 fn EnvBrdf_u0028_f1_u003b_f1_u003b(roughness_4: ptr<function, f32>, n_dot_v_2: ptr<function, f32>) -> vec2<f32> {
@@ -18773,18 +18892,18 @@ fn EnvBrdf_u0028_f1_u003b_f1_u003b(roughness_4: ptr<function, f32>, n_dot_v_2: p
     var param_46: f32;
     var param_47: f32;
 
-    let _e279 = (*roughness_4);
-    let _e281 = (*n_dot_v_2);
-    param_45 = clamp(_e279, 0f, 1f);
-    param_46 = sqrt(clamp((1f - _e281), 0f, 1f));
+    let _e280 = (*roughness_4);
+    let _e282 = (*n_dot_v_2);
+    param_45 = clamp(_e280, 0f, 1f);
+    param_46 = sqrt(clamp((1f - _e282), 0f, 1f));
     param_47 = 1f;
-    let _e285 = LtcUv_u0028_f1_u003b_f1_u003b_f1_u003b((&param_45), (&param_46), (&param_47));
-    let _e286 = textureSampleLevel(ltc_texture_tex, ltc_texture_smp, _e285, 0f);
-    dfg = _e286.xy;
-    let _e289 = dfg[0u];
-    let _e291 = dfg[1u];
-    let _e294 = dfg[1u];
-    return vec2<f32>((_e289 - _e291), _e294);
+    let _e286 = LtcUv_u0028_f1_u003b_f1_u003b_f1_u003b((&param_45), (&param_46), (&param_47));
+    let _e287 = textureSampleLevel(ltc_texture_tex, ltc_texture_smp, _e286, 0f);
+    dfg = _e287.xy;
+    let _e290 = dfg[0u];
+    let _e292 = dfg[1u];
+    let _e295 = dfg[1u];
+    return vec2<f32>((_e290 - _e292), _e295);
 }
 
 fn MultiscatterScale_u0028_vf3_u003b_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(f0_: ptr<function, vec3<f32>>, s_3: ptr<function, Surface>) -> vec3<f32> {
@@ -18793,58 +18912,58 @@ fn MultiscatterScale_u0028_vf3_u003b_struct_u002d_Surface_u002d_vf3_u002d_f1_u00
     var param_49: f32;
     var ess: f32;
 
-    let _e280 = (*s_3).roughness;
-    param_48 = max(_e280, 0.045f);
-    let _e283 = (*s_3).n_dot_v;
-    param_49 = _e283;
-    let _e284 = EnvBrdf_u0028_f1_u003b_f1_u003b((&param_48), (&param_49));
-    ab = _e284;
-    let _e286 = ab[0u];
-    let _e288 = ab[1u];
-    ess = max((_e286 + _e288), 0.0001f);
-    let _e291 = (*f0_);
-    let _e292 = ess;
-    return (vec3<f32>(1f, 1f, 1f) + (_e291 * ((1f / _e292) - 1f)));
+    let _e281 = (*s_3).roughness;
+    param_48 = max(_e281, 0.045f);
+    let _e284 = (*s_3).n_dot_v;
+    param_49 = _e284;
+    let _e285 = EnvBrdf_u0028_f1_u003b_f1_u003b((&param_48), (&param_49));
+    ab = _e285;
+    let _e287 = ab[0u];
+    let _e289 = ab[1u];
+    ess = max((_e287 + _e289), 0.0001f);
+    let _e292 = (*f0_);
+    let _e293 = ess;
+    return (vec3<f32>(1f, 1f, 1f) + (_e292 * ((1f / _e293) - 1f)));
 }
 
 fn EnergyCompensation_u0028_() -> bool {
-    let _e275 = frag_info.target_origin[2u];
-    return (_e275 > 0.5f);
+    let _e276 = frag_info.target_origin[2u];
+    return (_e276 > 0.5f);
 }
 
 fn F_SchlickF90_u0028_vf3_u003b_vf3_u003b_f1_u003b(f0_1: ptr<function, vec3<f32>>, f90_: ptr<function, vec3<f32>>, v_dot_h: ptr<function, f32>) -> vec3<f32> {
     var f_2: f32;
 
-    let _e277 = (*v_dot_h);
-    f_2 = pow((1f - _e277), 5f);
-    let _e280 = (*f0_1);
-    let _e281 = (*f90_);
-    let _e282 = (*f0_1);
-    let _e284 = f_2;
-    return (_e280 + ((_e281 - _e282) * _e284));
+    let _e278 = (*v_dot_h);
+    f_2 = pow((1f - _e278), 5f);
+    let _e281 = (*f0_1);
+    let _e282 = (*f90_);
+    let _e283 = (*f0_1);
+    let _e285 = f_2;
+    return (_e281 + ((_e282 - _e283) * _e285));
 }
 
 fn V_GGXAnisotropic_u0028_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b(n_dot_l_3: ptr<function, f32>, n_dot_v_3: ptr<function, f32>, b_dot_v: ptr<function, f32>, t_dot_v: ptr<function, f32>, t_dot_l: ptr<function, f32>, b_dot_l: ptr<function, f32>, at: ptr<function, f32>, ab_1: ptr<function, f32>) -> f32 {
     var ggx_v: f32;
     var ggx_l: f32;
 
-    let _e283 = (*n_dot_l_3);
-    let _e284 = (*at);
-    let _e285 = (*t_dot_v);
-    let _e287 = (*ab_1);
-    let _e288 = (*b_dot_v);
-    let _e290 = (*n_dot_v_3);
-    ggx_v = (_e283 * length(vec3<f32>((_e284 * _e285), (_e287 * _e288), _e290)));
-    let _e294 = (*n_dot_v_3);
-    let _e295 = (*at);
-    let _e296 = (*t_dot_l);
-    let _e298 = (*ab_1);
-    let _e299 = (*b_dot_l);
-    let _e301 = (*n_dot_l_3);
-    ggx_l = (_e294 * length(vec3<f32>((_e295 * _e296), (_e298 * _e299), _e301)));
-    let _e305 = ggx_v;
-    let _e306 = ggx_l;
-    return clamp((0.5f / max((_e305 + _e306), 0.00001f)), 0f, 1f);
+    let _e284 = (*n_dot_l_3);
+    let _e285 = (*at);
+    let _e286 = (*t_dot_v);
+    let _e288 = (*ab_1);
+    let _e289 = (*b_dot_v);
+    let _e291 = (*n_dot_v_3);
+    ggx_v = (_e284 * length(vec3<f32>((_e285 * _e286), (_e288 * _e289), _e291)));
+    let _e295 = (*n_dot_v_3);
+    let _e296 = (*at);
+    let _e297 = (*t_dot_l);
+    let _e299 = (*ab_1);
+    let _e300 = (*b_dot_l);
+    let _e302 = (*n_dot_l_3);
+    ggx_l = (_e295 * length(vec3<f32>((_e296 * _e297), (_e299 * _e300), _e302)));
+    let _e306 = ggx_v;
+    let _e307 = ggx_l;
+    return clamp((0.5f / max((_e306 + _e307), 0.00001f)), 0f, 1f);
 }
 
 fn D_GGXAnisotropic_u0028_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b(n_dot_h_3: ptr<function, f32>, t_dot_h: ptr<function, f32>, b_dot_h: ptr<function, f32>, at_1: ptr<function, f32>, ab_2: ptr<function, f32>) -> f32 {
@@ -18852,24 +18971,24 @@ fn D_GGXAnisotropic_u0028_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b(n_dot_h_3
     var f_3: vec3<f32>;
     var w2_: f32;
 
-    let _e281 = (*at_1);
-    let _e282 = (*ab_2);
-    a2_1 = (_e281 * _e282);
-    let _e284 = (*ab_2);
-    let _e285 = (*t_dot_h);
-    let _e287 = (*at_1);
-    let _e288 = (*b_dot_h);
-    let _e290 = a2_1;
-    let _e291 = (*n_dot_h_3);
-    f_3 = vec3<f32>((_e284 * _e285), (_e287 * _e288), (_e290 * _e291));
-    let _e294 = a2_1;
-    let _e295 = f_3;
+    let _e282 = (*at_1);
+    let _e283 = (*ab_2);
+    a2_1 = (_e282 * _e283);
+    let _e285 = (*ab_2);
+    let _e286 = (*t_dot_h);
+    let _e288 = (*at_1);
+    let _e289 = (*b_dot_h);
+    let _e291 = a2_1;
+    let _e292 = (*n_dot_h_3);
+    f_3 = vec3<f32>((_e285 * _e286), (_e288 * _e289), (_e291 * _e292));
+    let _e295 = a2_1;
     let _e296 = f_3;
-    w2_ = (_e294 / max(dot(_e295, _e296), 0.000000000001f));
-    let _e300 = a2_1;
-    let _e301 = w2_;
-    let _e303 = w2_;
-    return (((_e300 * _e301) * _e303) / 3.1415927f);
+    let _e297 = f_3;
+    w2_ = (_e295 / max(dot(_e296, _e297), 0.000000000001f));
+    let _e301 = a2_1;
+    let _e302 = w2_;
+    let _e304 = w2_;
+    return (((_e301 * _e302) * _e304) / 3.1415927f);
 }
 
 fn ShadeLight_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b(s_4: ptr<function, Surface>, light_1: ptr<function, LightSample>) -> vec3<f32> {
@@ -18921,197 +19040,197 @@ fn ShadeLight_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_
     var param_82: Surface;
     var param_83: LightSample;
 
-    let _e323 = (*s_4).roughness;
-    lobe_1 = max(_e323, 0.045f);
-    let _e325 = lobe_1;
+    let _e324 = (*s_4).roughness;
+    lobe_1 = max(_e324, 0.045f);
     let _e326 = lobe_1;
-    alpha_6 = (_e325 * _e326);
-    let _e328 = g_f0_dielectric;
-    let _e330 = (*s_4).albedo;
-    let _e332 = (*s_4).metallic;
-    f0_2 = mix(_e328, _e330, vec3(_e332));
-    let _e335 = g_f90_;
-    let _e337 = (*s_4).metallic;
-    f90_1 = vec3(mix(_e335, 1f, _e337));
-    let _e341 = (*s_4).albedo;
-    let _e343 = (*s_4).metallic;
-    diffuseColor = (_e341 * (1f - _e343));
-    let _e347 = (*light_1).n_dot_h;
-    param_50 = _e347;
-    let _e348 = alpha_6;
-    param_51 = _e348;
-    let _e349 = D_GGX_u0028_f1_u003b_f1_u003b((&param_50), (&param_51));
-    d_2 = _e349;
-    let _e351 = (*s_4).n_dot_v;
-    param_52 = _e351;
-    let _e353 = (*light_1).n_dot_l;
-    param_53 = _e353;
-    let _e354 = alpha_6;
-    param_54 = _e354;
-    let _e355 = V_SmithGGXCorrelated_u0028_f1_u003b_f1_u003b_f1_u003b((&param_52), (&param_53), (&param_54));
-    vis_1 = _e355;
-    let _e356 = g_aniso;
-    if (_e356 > 0f) {
-        let _e358 = alpha_6;
-        let _e359 = g_aniso;
+    let _e327 = lobe_1;
+    alpha_6 = (_e326 * _e327);
+    let _e329 = g_f0_dielectric;
+    let _e331 = (*s_4).albedo;
+    let _e333 = (*s_4).metallic;
+    f0_2 = mix(_e329, _e331, vec3(_e333));
+    let _e336 = g_f90_;
+    let _e338 = (*s_4).metallic;
+    f90_1 = vec3(mix(_e336, 1f, _e338));
+    let _e342 = (*s_4).albedo;
+    let _e344 = (*s_4).metallic;
+    diffuseColor = (_e342 * (1f - _e344));
+    let _e348 = (*light_1).n_dot_h;
+    param_50 = _e348;
+    let _e349 = alpha_6;
+    param_51 = _e349;
+    let _e350 = D_GGX_u0028_f1_u003b_f1_u003b((&param_50), (&param_51));
+    d_2 = _e350;
+    let _e352 = (*s_4).n_dot_v;
+    param_52 = _e352;
+    let _e354 = (*light_1).n_dot_l;
+    param_53 = _e354;
+    let _e355 = alpha_6;
+    param_54 = _e355;
+    let _e356 = V_SmithGGXCorrelated_u0028_f1_u003b_f1_u003b_f1_u003b((&param_52), (&param_53), (&param_54));
+    vis_1 = _e356;
+    let _e357 = g_aniso;
+    if (_e357 > 0f) {
+        let _e359 = alpha_6;
         let _e360 = g_aniso;
-        at_2 = mix(_e358, 1f, (_e359 * _e360));
-        let _e363 = alpha_6;
-        ab_3 = max(_e363, 0.001f);
-        let _e365 = g_aniso_t;
-        let _e367 = (*light_1).h;
-        let _e369 = g_aniso_b;
-        let _e371 = (*light_1).h;
-        let _e374 = (*light_1).n_dot_h;
-        param_55 = _e374;
-        param_56 = dot(_e365, _e367);
-        param_57 = dot(_e369, _e371);
-        let _e375 = at_2;
-        param_58 = _e375;
-        let _e376 = ab_3;
-        param_59 = _e376;
-        let _e377 = D_GGXAnisotropic_u0028_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b((&param_55), (&param_56), (&param_57), (&param_58), (&param_59));
-        d_2 = _e377;
-        let _e378 = g_aniso_b;
-        let _e380 = (*s_4).v;
-        let _e382 = g_aniso_t;
-        let _e384 = (*s_4).v;
-        let _e386 = g_aniso_t;
-        let _e388 = (*light_1).l;
-        let _e390 = g_aniso_b;
-        let _e392 = (*light_1).l;
-        let _e395 = (*light_1).n_dot_l;
-        param_60 = _e395;
-        let _e397 = (*s_4).n_dot_v;
-        param_61 = _e397;
-        param_62 = dot(_e378, _e380);
-        param_63 = dot(_e382, _e384);
-        param_64 = dot(_e386, _e388);
-        param_65 = dot(_e390, _e392);
-        let _e398 = at_2;
-        param_66 = _e398;
-        let _e399 = ab_3;
-        param_67 = _e399;
-        let _e400 = V_GGXAnisotropic_u0028_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b((&param_60), (&param_61), (&param_62), (&param_63), (&param_64), (&param_65), (&param_66), (&param_67));
-        vis_1 = _e400;
-    }
-    let _e401 = f0_2;
-    param_68 = _e401;
-    let _e402 = f90_1;
-    param_69 = _e402;
-    let _e404 = (*light_1).v_dot_h;
-    param_70 = _e404;
-    let _e405 = F_SchlickF90_u0028_vf3_u003b_vf3_u003b_f1_u003b((&param_68), (&param_69), (&param_70));
-    f_4 = _e405;
-    let _e406 = f_4;
-    let _e407 = g_irid_fresnel;
-    let _e408 = g_iridescence;
-    f_4 = mix(_e406, _e407, vec3(_e408));
-    let _e411 = d_2;
-    let _e412 = vis_1;
-    let _e414 = f_4;
-    let _e418 = frag_info.material[3u];
-    specular = ((_e414 * (_e411 * _e412)) * _e418);
-    let _e421 = (*light_1).integrated;
-    if (_e421 > 0.5f) {
-        let _e425 = (*light_1).ltc[0u];
-        let _e426 = f0_2;
-        let _e429 = (*light_1).ltc[1u];
-        let _e431 = f90_1;
-        let _e432 = f0_2;
-        let _e436 = (*light_1).ltc[2u];
-        let _e442 = frag_info.material[3u];
-        let _e445 = (*light_1).n_dot_l;
-        specular = (((((_e426 * _e429) + ((_e431 - _e432) * _e436)) * _e425) * _e442) / vec3(max(_e445, 0.000001f)));
-    }
-    let _e449 = EnergyCompensation_u0028_();
-    if _e449 {
-        let _e450 = f0_2;
-        param_71 = _e450;
-        let _e451 = (*s_4);
-        param_72 = _e451;
-        let _e452 = MultiscatterScale_u0028_vf3_u003b_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_71), (&param_72));
-        let _e453 = specular;
-        specular = (_e453 * _e452);
-    }
-    let _e455 = diffuseColor;
-    let _e456 = f_4;
-    diffuse = ((_e455 * (vec3<f32>(1f, 1f, 1f) - _e456)) / vec3(3.1415927f));
-    let _e461 = EonDiffuse_u0028_();
-    if _e461 {
-        let _e463 = (*s_4).n;
-        let _e465 = (*light_1).l;
-        let _e469 = (*light_1).l;
-        let _e471 = (*s_4).v;
-        let _e473 = diffuseColor;
-        param_73 = _e473;
-        let _e475 = (*s_4).roughness;
-        param_74 = _e475;
-        param_75 = clamp(dot(_e463, _e465), 0.0001f, 1f);
-        let _e477 = (*s_4).n_dot_v;
-        param_76 = _e477;
-        param_77 = dot(_e469, _e471);
-        let _e478 = EonLobe_u0028_vf3_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b((&param_73), (&param_74), (&param_75), (&param_76), (&param_77));
-        let _e479 = f_4;
-        diffuse = (_e478 * (vec3<f32>(1f, 1f, 1f) - _e479));
-    }
-    let _e482 = g_transmission;
-    let _e484 = diffuse;
-    diffuse = (_e484 * (1f - _e482));
-    let _e486 = g_sheen;
-    let _e487 = g_sheen_roughness;
-    param_78 = _e487;
-    let _e489 = (*light_1).n_dot_h;
-    param_79 = _e489;
-    let _e490 = D_Charlie_u0028_f1_u003b_f1_u003b((&param_78), (&param_79));
-    let _e493 = (*s_4).n;
-    let _e495 = (*light_1).l;
-    let _e499 = (*s_4).n_dot_v;
-    param_80 = _e499;
-    param_81 = clamp(dot(_e493, _e495), 0f, 1f);
-    let _e500 = V_Neubelt_u0028_f1_u003b_f1_u003b((&param_80), (&param_81));
-    sheen = ((_e486 * _e490) * _e500);
-    let _e502 = diffuse;
-    let _e503 = specular;
-    let _e505 = g_sheen_scale;
-    let _e507 = sheen;
-    let _e509 = g_coat_through;
-    let _e511 = g_coat;
-    let _e512 = (*s_4);
-    param_82 = _e512;
-    let _e513 = (*light_1);
-    param_83 = _e513;
-    let _e514 = CoatLobe_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b((&param_82), (&param_83));
-    return ((((((_e502 + _e503) * _e505) + _e507) * _e509) + vec3((_e511 * _e514))) * 3.1415927f);
+        let _e361 = g_aniso;
+        at_2 = mix(_e359, 1f, (_e360 * _e361));
+        let _e364 = alpha_6;
+        ab_3 = max(_e364, 0.001f);
+        let _e366 = g_aniso_t;
+        let _e368 = (*light_1).h;
+        let _e370 = g_aniso_b;
+        let _e372 = (*light_1).h;
+        let _e375 = (*light_1).n_dot_h;
+        param_55 = _e375;
+        param_56 = dot(_e366, _e368);
+        param_57 = dot(_e370, _e372);
+        let _e376 = at_2;
+        param_58 = _e376;
+        let _e377 = ab_3;
+        param_59 = _e377;
+        let _e378 = D_GGXAnisotropic_u0028_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b((&param_55), (&param_56), (&param_57), (&param_58), (&param_59));
+        d_2 = _e378;
+        let _e379 = g_aniso_b;
+        let _e381 = (*s_4).v;
+        let _e383 = g_aniso_t;
+        let _e385 = (*s_4).v;
+        let _e387 = g_aniso_t;
+        let _e389 = (*light_1).l;
+        let _e391 = g_aniso_b;
+        let _e393 = (*light_1).l;
+        let _e396 = (*light_1).n_dot_l;
+        param_60 = _e396;
+        let _e398 = (*s_4).n_dot_v;
+        param_61 = _e398;
+        param_62 = dot(_e379, _e381);
+        param_63 = dot(_e383, _e385);
+        param_64 = dot(_e387, _e389);
+        param_65 = dot(_e391, _e393);
+        let _e399 = at_2;
+        param_66 = _e399;
+        let _e400 = ab_3;
+        param_67 = _e400;
+        let _e401 = V_GGXAnisotropic_u0028_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b((&param_60), (&param_61), (&param_62), (&param_63), (&param_64), (&param_65), (&param_66), (&param_67));
+        vis_1 = _e401;
+    }
+    let _e402 = f0_2;
+    param_68 = _e402;
+    let _e403 = f90_1;
+    param_69 = _e403;
+    let _e405 = (*light_1).v_dot_h;
+    param_70 = _e405;
+    let _e406 = F_SchlickF90_u0028_vf3_u003b_vf3_u003b_f1_u003b((&param_68), (&param_69), (&param_70));
+    f_4 = _e406;
+    let _e407 = f_4;
+    let _e408 = g_irid_fresnel;
+    let _e409 = g_iridescence;
+    f_4 = mix(_e407, _e408, vec3(_e409));
+    let _e412 = d_2;
+    let _e413 = vis_1;
+    let _e415 = f_4;
+    let _e419 = frag_info.material[3u];
+    specular = ((_e415 * (_e412 * _e413)) * _e419);
+    let _e422 = (*light_1).integrated;
+    if (_e422 > 0.5f) {
+        let _e426 = (*light_1).ltc[0u];
+        let _e427 = f0_2;
+        let _e430 = (*light_1).ltc[1u];
+        let _e432 = f90_1;
+        let _e433 = f0_2;
+        let _e437 = (*light_1).ltc[2u];
+        let _e443 = frag_info.material[3u];
+        let _e446 = (*light_1).n_dot_l;
+        specular = (((((_e427 * _e430) + ((_e432 - _e433) * _e437)) * _e426) * _e443) / vec3(max(_e446, 0.000001f)));
+    }
+    let _e450 = EnergyCompensation_u0028_();
+    if _e450 {
+        let _e451 = f0_2;
+        param_71 = _e451;
+        let _e452 = (*s_4);
+        param_72 = _e452;
+        let _e453 = MultiscatterScale_u0028_vf3_u003b_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_71), (&param_72));
+        let _e454 = specular;
+        specular = (_e454 * _e453);
+    }
+    let _e456 = diffuseColor;
+    let _e457 = f_4;
+    diffuse = ((_e456 * (vec3<f32>(1f, 1f, 1f) - _e457)) / vec3(3.1415927f));
+    let _e462 = EonDiffuse_u0028_();
+    if _e462 {
+        let _e464 = (*s_4).n;
+        let _e466 = (*light_1).l;
+        let _e470 = (*light_1).l;
+        let _e472 = (*s_4).v;
+        let _e474 = diffuseColor;
+        param_73 = _e474;
+        let _e476 = (*s_4).roughness;
+        param_74 = _e476;
+        param_75 = clamp(dot(_e464, _e466), 0.0001f, 1f);
+        let _e478 = (*s_4).n_dot_v;
+        param_76 = _e478;
+        param_77 = dot(_e470, _e472);
+        let _e479 = EonLobe_u0028_vf3_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b((&param_73), (&param_74), (&param_75), (&param_76), (&param_77));
+        let _e480 = f_4;
+        diffuse = (_e479 * (vec3<f32>(1f, 1f, 1f) - _e480));
+    }
+    let _e483 = g_transmission;
+    let _e485 = diffuse;
+    diffuse = (_e485 * (1f - _e483));
+    let _e487 = g_sheen;
+    let _e488 = g_sheen_roughness;
+    param_78 = _e488;
+    let _e490 = (*light_1).n_dot_h;
+    param_79 = _e490;
+    let _e491 = D_Charlie_u0028_f1_u003b_f1_u003b((&param_78), (&param_79));
+    let _e494 = (*s_4).n;
+    let _e496 = (*light_1).l;
+    let _e500 = (*s_4).n_dot_v;
+    param_80 = _e500;
+    param_81 = clamp(dot(_e494, _e496), 0f, 1f);
+    let _e501 = V_Neubelt_u0028_f1_u003b_f1_u003b((&param_80), (&param_81));
+    sheen = ((_e487 * _e491) * _e501);
+    let _e503 = diffuse;
+    let _e504 = specular;
+    let _e506 = g_sheen_scale;
+    let _e508 = sheen;
+    let _e510 = g_coat_through;
+    let _e512 = g_coat;
+    let _e513 = (*s_4);
+    param_82 = _e513;
+    let _e514 = (*light_1);
+    param_83 = _e514;
+    let _e515 = CoatLobe_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b((&param_82), (&param_83));
+    return ((((((_e503 + _e504) * _e506) + _e508) * _e510) + vec3((_e512 * _e515))) * 3.1415927f);
 }
 
 fn PointShadowDiskTap_u0028_i1_u003b(i_1: ptr<function, i32>) -> vec2<f32> {
-    let _e274 = (*i_1);
-    if (_e274 == 0i) {
+    let _e275 = (*i_1);
+    if (_e275 == 0i) {
         return vec2<f32>(-0.94201624f, -0.39906216f);
     }
-    let _e276 = (*i_1);
-    if (_e276 == 1i) {
+    let _e277 = (*i_1);
+    if (_e277 == 1i) {
         return vec2<f32>(0.9455861f, -0.76890725f);
     }
-    let _e278 = (*i_1);
-    if (_e278 == 2i) {
+    let _e279 = (*i_1);
+    if (_e279 == 2i) {
         return vec2<f32>(-0.0941841f, -0.9293887f);
     }
-    let _e280 = (*i_1);
-    if (_e280 == 3i) {
+    let _e281 = (*i_1);
+    if (_e281 == 3i) {
         return vec2<f32>(0.34495938f, 0.2938776f);
     }
-    let _e282 = (*i_1);
-    if (_e282 == 4i) {
+    let _e283 = (*i_1);
+    if (_e283 == 4i) {
         return vec2<f32>(-0.9158858f, 0.45771432f);
     }
-    let _e284 = (*i_1);
-    if (_e284 == 5i) {
+    let _e285 = (*i_1);
+    if (_e285 == 5i) {
         return vec2<f32>(-0.8154423f, -0.87912464f);
     }
-    let _e286 = (*i_1);
-    if (_e286 == 6i) {
+    let _e287 = (*i_1);
+    if (_e287 == 6i) {
         return vec2<f32>(-0.38277543f, 0.27676845f);
     }
     return vec2<f32>(0.974844f, 0.7564838f);
@@ -19121,20 +19240,20 @@ fn PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b(i_2: ptr<function
     var p_1: vec2<f32>;
     var param_84: i32;
 
-    let _e279 = (*i_2);
-    param_84 = _e279;
-    let _e280 = PointShadowDiskTap_u0028_i1_u003b((&param_84));
-    p_1 = _e280;
-    let _e282 = p_1[0u];
-    let _e283 = (*ca);
-    let _e286 = p_1[1u];
-    let _e287 = (*sa);
-    let _e291 = p_1[0u];
-    let _e292 = (*sa);
-    let _e295 = p_1[1u];
-    let _e296 = (*ca);
-    let _e300 = (*radius);
-    return (vec2<f32>(((_e282 * _e283) - (_e286 * _e287)), ((_e291 * _e292) + (_e295 * _e296))) * _e300);
+    let _e280 = (*i_2);
+    param_84 = _e280;
+    let _e281 = PointShadowDiskTap_u0028_i1_u003b((&param_84));
+    p_1 = _e281;
+    let _e283 = p_1[0u];
+    let _e284 = (*ca);
+    let _e287 = p_1[1u];
+    let _e288 = (*sa);
+    let _e292 = p_1[0u];
+    let _e293 = (*sa);
+    let _e296 = p_1[1u];
+    let _e297 = (*ca);
+    let _e301 = (*radius);
+    return (vec2<f32>(((_e283 * _e284) - (_e287 * _e288)), ((_e292 * _e293) + (_e296 * _e297))) * _e301);
 }
 
 fn PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b(uv_1: ptr<function, vec2<f32>>, offset: ptr<function, vec2<f32>>, tile: ptr<function, vec2<f32>>, range: ptr<function, f32>) -> f32 {
@@ -19142,27 +19261,27 @@ fn PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b(uv_1: ptr<fu
     var local_9: vec2<f32>;
     var atlas: vec2<f32>;
 
-    let _e282 = point_shadow.params[0u];
-    inset = _e282;
-    let _e283 = (*uv_1);
-    let _e284 = (*offset);
-    let _e286 = inset;
+    let _e283 = point_shadow.params[0u];
+    inset = _e283;
+    let _e284 = (*uv_1);
+    let _e285 = (*offset);
     let _e287 = inset;
-    local_9 = clamp((_e283 + _e284), vec2(_e286), vec2((1f - _e287)));
-    let _e292 = local_9;
-    let _e293 = (*tile);
-    atlas = ((_e292 + _e293) * vec2<f32>(0.16666667f, 0.16666667f));
-    let _e298 = point_shadow.params3_[0u];
-    if (_e298 > 0.5f) {
-        let _e301 = atlas[1u];
-        atlas[1u] = (1f - _e301);
-    }
-    let _e304 = atlas;
-    let _e305 = textureSampleLevel(point_shadow_texture_tex, point_shadow_texture_smp, _e304, 0f);
-    let _e307 = atlas;
-    let _e308 = textureSampleLevel(point_shadow_static_texture_tex, point_shadow_static_texture_smp, _e307, 0f);
-    let _e311 = (*range);
-    return (min(_e305.x, _e308.x) * _e311);
+    let _e288 = inset;
+    local_9 = clamp((_e284 + _e285), vec2(_e287), vec2((1f - _e288)));
+    let _e293 = local_9;
+    let _e294 = (*tile);
+    atlas = ((_e293 + _e294) * vec2<f32>(0.16666667f, 0.16666667f));
+    let _e299 = point_shadow.params3_[0u];
+    if (_e299 > 0.5f) {
+        let _e302 = atlas[1u];
+        atlas[1u] = (1f - _e302);
+    }
+    let _e305 = atlas;
+    let _e306 = textureSampleLevel(point_shadow_texture_tex, point_shadow_texture_smp, _e305, 0f);
+    let _e308 = atlas;
+    let _e309 = textureSampleLevel(point_shadow_static_texture_tex, point_shadow_static_texture_smp, _e308, 0f);
+    let _e312 = (*range);
+    return (min(_e306.x, _e309.x) * _e312);
 }
 
 fn PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b(uv_2: ptr<function, vec2<f32>>, offset_1: ptr<function, vec2<f32>>, tile_1: ptr<function, vec2<f32>>, range_1: ptr<function, f32>, receiver: ptr<function, f32>) -> f32 {
@@ -19172,24 +19291,24 @@ fn PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b(uv_2: pt
     var param_87: vec2<f32>;
     var param_88: f32;
 
-    let _e283 = (*uv_2);
-    param_85 = _e283;
-    let _e284 = (*offset_1);
-    param_86 = _e284;
-    let _e285 = (*tile_1);
-    param_87 = _e285;
-    let _e286 = (*range_1);
-    param_88 = _e286;
-    let _e287 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((&param_85), (&param_86), (&param_87), (&param_88));
-    stored = _e287;
-    let _e288 = stored;
-    let _e289 = (*range_1);
-    if (_e288 >= (_e289 * 0.999f)) {
+    let _e284 = (*uv_2);
+    param_85 = _e284;
+    let _e285 = (*offset_1);
+    param_86 = _e285;
+    let _e286 = (*tile_1);
+    param_87 = _e286;
+    let _e287 = (*range_1);
+    param_88 = _e287;
+    let _e288 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((&param_85), (&param_86), (&param_87), (&param_88));
+    stored = _e288;
+    let _e289 = stored;
+    let _e290 = (*range_1);
+    if (_e289 >= (_e290 * 0.999f)) {
         return 1f;
     }
-    let _e292 = (*receiver);
-    let _e293 = stored;
-    return select(1f, 0f, (_e292 > _e293));
+    let _e293 = (*receiver);
+    let _e294 = stored;
+    return select(1f, 0f, (_e293 > _e294));
 }
 
 fn PointShadowPenumbra_u0028_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b(uv_3: ptr<function, vec2<f32>>, tile_2: ptr<function, vec2<f32>>, range_2: ptr<function, f32>, receiver_1: ptr<function, f32>, ca_1: ptr<function, f32>, sa_1: ptr<function, f32>, tanHalf: ptr<function, f32>, blockerOut: ptr<function, f32>) -> f32 {
@@ -19216,111 +19335,111 @@ fn PointShadowPenumbra_u0028_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u
     var world: f32;
 
     (*blockerOut) = -1f;
-    let _e304 = point_shadow.params2_[1u];
-    lightRadius = _e304;
-    let _e307 = point_shadow.params2_[0u];
-    minRadius = _e307;
-    let _e310 = point_shadow.params2_[2u];
-    maxRadius = _e310;
-    let _e311 = lightRadius;
-    if (_e311 <= 0f) {
-        let _e313 = (*uv_3);
-        param_89 = _e313;
+    let _e305 = point_shadow.params2_[1u];
+    lightRadius = _e305;
+    let _e308 = point_shadow.params2_[0u];
+    minRadius = _e308;
+    let _e311 = point_shadow.params2_[2u];
+    maxRadius = _e311;
+    let _e312 = lightRadius;
+    if (_e312 <= 0f) {
+        let _e314 = (*uv_3);
+        param_89 = _e314;
         param_90 = vec2<f32>(0f, 0f);
-        let _e314 = (*tile_2);
-        param_91 = _e314;
-        let _e315 = (*range_2);
-        param_92 = _e315;
-        let _e316 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((&param_89), (&param_90), (&param_91), (&param_92));
-        (*blockerOut) = _e316;
-        let _e317 = minRadius;
-        return _e317;
+        let _e315 = (*tile_2);
+        param_91 = _e315;
+        let _e316 = (*range_2);
+        param_92 = _e316;
+        let _e317 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((&param_89), (&param_90), (&param_91), (&param_92));
+        (*blockerOut) = _e317;
+        let _e318 = minRadius;
+        return _e318;
     }
     sum = 0f;
     count = 0f;
     i_3 = 0i;
     loop {
-        let _e318 = i_3;
-        if (_e318 < 8i) {
-            let _e320 = i_3;
-            param_93 = _e320;
-            let _e321 = (*ca_1);
-            param_94 = _e321;
-            let _e322 = (*sa_1);
-            param_95 = _e322;
-            let _e323 = maxRadius;
-            param_96 = _e323;
-            let _e324 = PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b((&param_93), (&param_94), (&param_95), (&param_96));
-            let _e325 = (*uv_3);
-            param_97 = _e325;
-            param_98 = _e324;
-            let _e326 = (*tile_2);
-            param_99 = _e326;
-            let _e327 = (*range_2);
-            param_100 = _e327;
-            let _e328 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((&param_97), (&param_98), (&param_99), (&param_100));
-            stored_1 = _e328;
-            let _e329 = stored_1;
-            let _e330 = (*range_2);
-            if (_e329 >= (_e330 * 0.999f)) {
+        let _e319 = i_3;
+        if (_e319 < 8i) {
+            let _e321 = i_3;
+            param_93 = _e321;
+            let _e322 = (*ca_1);
+            param_94 = _e322;
+            let _e323 = (*sa_1);
+            param_95 = _e323;
+            let _e324 = maxRadius;
+            param_96 = _e324;
+            let _e325 = PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b((&param_93), (&param_94), (&param_95), (&param_96));
+            let _e326 = (*uv_3);
+            param_97 = _e326;
+            param_98 = _e325;
+            let _e327 = (*tile_2);
+            param_99 = _e327;
+            let _e328 = (*range_2);
+            param_100 = _e328;
+            let _e329 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((&param_97), (&param_98), (&param_99), (&param_100));
+            stored_1 = _e329;
+            let _e330 = stored_1;
+            let _e331 = (*range_2);
+            if (_e330 >= (_e331 * 0.999f)) {
                 continue;
             }
-            let _e333 = stored_1;
-            let _e334 = (*receiver_1);
-            if (_e333 >= _e334) {
+            let _e334 = stored_1;
+            let _e335 = (*receiver_1);
+            if (_e334 >= _e335) {
                 continue;
             }
-            let _e336 = stored_1;
-            let _e337 = sum;
-            sum = (_e337 + _e336);
-            let _e339 = count;
-            count = (_e339 + 1f);
+            let _e337 = stored_1;
+            let _e338 = sum;
+            sum = (_e338 + _e337);
+            let _e340 = count;
+            count = (_e340 + 1f);
             continue;
         } else {
             break;
         }
         continuing {
-            let _e341 = i_3;
-            i_3 = (_e341 + 1i);
+            let _e342 = i_3;
+            i_3 = (_e342 + 1i);
         }
     }
-    let _e343 = count;
-    if (_e343 < 0.5f) {
+    let _e344 = count;
+    if (_e344 < 0.5f) {
         return -1f;
     }
-    let _e345 = sum;
-    let _e346 = count;
-    blocker = max((_e345 / _e346), 0.0001f);
-    let _e349 = blocker;
-    (*blockerOut) = _e349;
-    let _e350 = lightRadius;
-    let _e351 = (*receiver_1);
-    let _e352 = blocker;
-    let _e356 = blocker;
-    world = ((_e350 * max((_e351 - _e352), 0f)) / _e356);
-    let _e358 = world;
-    let _e359 = (*receiver_1);
-    let _e361 = (*tanHalf);
-    let _e364 = minRadius;
-    let _e365 = maxRadius;
-    return clamp((_e358 / ((2f * _e359) * _e361)), _e364, _e365);
+    let _e346 = sum;
+    let _e347 = count;
+    blocker = max((_e346 / _e347), 0.0001f);
+    let _e350 = blocker;
+    (*blockerOut) = _e350;
+    let _e351 = lightRadius;
+    let _e352 = (*receiver_1);
+    let _e353 = blocker;
+    let _e357 = blocker;
+    world = ((_e351 * max((_e352 - _e353), 0f)) / _e357);
+    let _e359 = world;
+    let _e360 = (*receiver_1);
+    let _e362 = (*tanHalf);
+    let _e365 = minRadius;
+    let _e366 = maxRadius;
+    return clamp((_e359 / ((2f * _e360) * _e362)), _e365, _e366);
 }
 
 fn FragCoordFromTop_u0028_f1_u003b(rows: ptr<function, f32>) -> vec2<f32> {
     var local_10: vec2<f32>;
 
-    let _e275 = (*rows);
-    if (_e275 > 0f) {
-        let _e278 = gl_FragCoord_1[0u];
-        let _e279 = (*rows);
-        let _e281 = gl_FragCoord_1[1u];
-        local_10 = vec2<f32>(_e278, (_e279 - _e281));
+    let _e276 = (*rows);
+    if (_e276 > 0f) {
+        let _e279 = gl_FragCoord_1[0u];
+        let _e280 = (*rows);
+        let _e282 = gl_FragCoord_1[1u];
+        local_10 = vec2<f32>(_e279, (_e280 - _e282));
     } else {
-        let _e284 = gl_FragCoord_1;
-        local_10 = _e284.xy;
+        let _e285 = gl_FragCoord_1;
+        local_10 = _e285.xy;
     }
-    let _e286 = local_10;
-    return _e286;
+    let _e287 = local_10;
+    return _e287;
 }
 
 fn PointShadowFactor_u0028_vf3_u003b_vf3_u003b_i1_u003b(world_1: ptr<function, vec3<f32>>, normal: ptr<function, vec3<f32>>, lightIndex: ptr<function, i32>) -> f32 {
@@ -19378,257 +19497,257 @@ fn PointShadowFactor_u0028_vf3_u003b_vf3_u003b_i1_u003b(world_1: ptr<function, v
     var phi_2703_: bool;
     var phi_2764_: bool;
 
-    let _e327 = (*lightIndex);
-    let _e331 = point_shadow.slots[_e327][0u];
-    slot_1 = i32((_e331 + 0.5f));
-    let _e334 = (*lightIndex);
-    let _e338 = point_shadow.slots[_e334][0u];
-    if (_e338 < 0f) {
+    let _e328 = (*lightIndex);
+    let _e332 = point_shadow.slots[_e328][0u];
+    slot_1 = i32((_e332 + 0.5f));
+    let _e335 = (*lightIndex);
+    let _e339 = point_shadow.slots[_e335][0u];
+    if (_e339 < 0f) {
         return 1f;
     }
-    let _e342 = point_shadow.params[2u];
-    strength = _e342;
-    let _e343 = strength;
-    if (_e343 <= 0f) {
+    let _e343 = point_shadow.params[2u];
+    strength = _e343;
+    let _e344 = strength;
+    if (_e344 <= 0f) {
         return 1f;
     }
-    let _e345 = slot_1;
-    let _e348 = point_shadow.lights[_e345];
-    let _e350 = (*world_1);
-    toLight = (_e348.xyz - _e350);
-    let _e352 = toLight;
-    toLightLength = max(length(_e352), 0.000001f);
-    let _e355 = (*normal);
-    let _e356 = toLight;
-    let _e357 = toLightLength;
-    nDotL = max(dot(_e355, (_e356 / vec3(_e357))), 0.15f);
-    let _e362 = nDotL;
+    let _e346 = slot_1;
+    let _e349 = point_shadow.lights[_e346];
+    let _e351 = (*world_1);
+    toLight = (_e349.xyz - _e351);
+    let _e353 = toLight;
+    toLightLength = max(length(_e353), 0.000001f);
+    let _e356 = (*normal);
+    let _e357 = toLight;
+    let _e358 = toLightLength;
+    nDotL = max(dot(_e356, (_e357 / vec3(_e358))), 0.15f);
     let _e363 = nDotL;
-    let _e368 = nDotL;
+    let _e364 = nDotL;
     let _e369 = nDotL;
-    slope = min((sqrt(max((1f - (_e362 * _e363)), 0f)) / (_e368 * _e369)), 8f);
-    let _e373 = toLightLength;
-    let _e375 = (*lightIndex);
-    let _e379 = point_shadow.slots[_e375][2u];
-    let _e384 = point_shadow.params3_[1u];
-    texel = (((2f * _e373) * max(_e379, 0.0001f)) * _e384);
-    let _e386 = (*world_1);
-    let _e387 = (*normal);
-    let _e388 = texel;
-    let _e392 = point_shadow.params[3u];
-    let _e394 = slope;
-    origin = (_e386 + (((_e387 * _e388) * _e392) * (1f + _e394)));
-    let _e398 = origin;
-    let _e399 = slot_1;
-    let _e402 = point_shadow.lights[_e399];
-    toFragment = (_e398 - _e402.xyz);
-    let _e405 = toFragment;
-    distance_ = length(_e405);
-    let _e407 = slot_1;
-    let _e411 = point_shadow.lights[_e407][3u];
-    range_3 = max(_e411, 0.0001f);
-    let _e413 = distance_;
-    let _e414 = range_3;
-    if (_e413 >= _e414) {
+    let _e370 = nDotL;
+    slope = min((sqrt(max((1f - (_e363 * _e364)), 0f)) / (_e369 * _e370)), 8f);
+    let _e374 = toLightLength;
+    let _e376 = (*lightIndex);
+    let _e380 = point_shadow.slots[_e376][2u];
+    let _e385 = point_shadow.params3_[1u];
+    texel = (((2f * _e374) * max(_e380, 0.0001f)) * _e385);
+    let _e387 = (*world_1);
+    let _e388 = (*normal);
+    let _e389 = texel;
+    let _e393 = point_shadow.params[3u];
+    let _e395 = slope;
+    origin = (_e387 + (((_e388 * _e389) * _e393) * (1f + _e395)));
+    let _e399 = origin;
+    let _e400 = slot_1;
+    let _e403 = point_shadow.lights[_e400];
+    toFragment = (_e399 - _e403.xyz);
+    let _e406 = toFragment;
+    distance_ = length(_e406);
+    let _e408 = slot_1;
+    let _e412 = point_shadow.lights[_e408][3u];
+    range_3 = max(_e412, 0.0001f);
+    let _e414 = distance_;
+    let _e415 = range_3;
+    if (_e414 >= _e415) {
         return 1f;
     }
     face = 0i;
-    let _e416 = (*lightIndex);
-    let _e420 = point_shadow.slots[_e416][1u];
-    if (_e420 < 0.5f) {
-        let _e422 = toFragment;
-        a_2 = abs(_e422);
-        let _e425 = a_2[0u];
-        let _e427 = a_2[1u];
-        let _e428 = (_e425 >= _e427);
-        phi_2703_ = _e428;
-        if _e428 {
-            let _e430 = a_2[0u];
-            let _e432 = a_2[2u];
-            phi_2703_ = (_e430 >= _e432);
-        }
-        let _e435 = phi_2703_;
-        if _e435 {
-            let _e437 = toFragment[0u];
-            face = select(1i, 0i, (_e437 > 0f));
+    let _e417 = (*lightIndex);
+    let _e421 = point_shadow.slots[_e417][1u];
+    if (_e421 < 0.5f) {
+        let _e423 = toFragment;
+        a_2 = abs(_e423);
+        let _e426 = a_2[0u];
+        let _e428 = a_2[1u];
+        let _e429 = (_e426 >= _e428);
+        phi_2703_ = _e429;
+        if _e429 {
+            let _e431 = a_2[0u];
+            let _e433 = a_2[2u];
+            phi_2703_ = (_e431 >= _e433);
+        }
+        let _e436 = phi_2703_;
+        if _e436 {
+            let _e438 = toFragment[0u];
+            face = select(1i, 0i, (_e438 > 0f));
         } else {
-            let _e441 = a_2[1u];
-            let _e443 = a_2[2u];
-            if (_e441 >= _e443) {
-                let _e446 = toFragment[1u];
-                face = select(3i, 2i, (_e446 > 0f));
+            let _e442 = a_2[1u];
+            let _e444 = a_2[2u];
+            if (_e442 >= _e444) {
+                let _e447 = toFragment[1u];
+                face = select(3i, 2i, (_e447 > 0f));
             } else {
-                let _e450 = toFragment[2u];
-                face = select(5i, 4i, (_e450 > 0f));
+                let _e451 = toFragment[2u];
+                face = select(5i, 4i, (_e451 > 0f));
             }
         }
     }
-    let _e453 = slot_1;
-    let _e455 = face;
-    let _e459 = point_shadow.faces[((_e453 * 6i) + _e455)];
-    let _e460 = origin;
-    clip = (_e459 * vec4<f32>(_e460.x, _e460.y, _e460.z, 1f));
-    let _e467 = clip[3u];
-    if (_e467 <= 0f) {
+    let _e454 = slot_1;
+    let _e456 = face;
+    let _e460 = point_shadow.faces[((_e454 * 6i) + _e456)];
+    let _e461 = origin;
+    clip = (_e460 * vec4<f32>(_e461.x, _e461.y, _e461.z, 1f));
+    let _e468 = clip[3u];
+    if (_e468 <= 0f) {
         return 1f;
     }
-    let _e469 = clip;
-    let _e472 = clip[3u];
-    ndc = (_e469.xy / vec2(_e472));
-    let _e476 = ndc[0u];
-    let _e478 = (abs(_e476) > 1f);
-    phi_2764_ = _e478;
-    if !(_e478) {
-        let _e481 = ndc[1u];
-        phi_2764_ = (abs(_e481) > 1f);
-    }
-    let _e485 = phi_2764_;
-    if _e485 {
+    let _e470 = clip;
+    let _e473 = clip[3u];
+    ndc = (_e470.xy / vec2(_e473));
+    let _e477 = ndc[0u];
+    let _e479 = (abs(_e477) > 1f);
+    phi_2764_ = _e479;
+    if !(_e479) {
+        let _e482 = ndc[1u];
+        phi_2764_ = (abs(_e482) > 1f);
+    }
+    let _e486 = phi_2764_;
+    if _e486 {
         return 1f;
     }
-    let _e487 = ndc[0u];
-    let _e491 = ndc[1u];
-    uv_4 = vec2<f32>(((_e487 * 0.5f) + 0.5f), (0.5f - (_e491 * 0.5f)));
-    let _e495 = face;
-    let _e497 = slot_1;
-    tile_3 = vec2<f32>(f32(_e495), f32(_e497));
-    let _e500 = distance_;
-    let _e503 = point_shadow.params[1u];
-    receiver_2 = (_e500 - _e503);
-    let _e507 = frag_info.target_origin[0u];
-    param_101 = _e507;
-    let _e508 = FragCoordFromTop_u0028_f1_u003b((&param_101));
-    noise = fract((52.982918f * fract(dot(_e508, vec2<f32>(0.06711056f, 0.00583715f)))));
-    let _e513 = noise;
-    angle_1 = (_e513 * 6.2831855f);
-    let _e515 = angle_1;
-    ca_2 = cos(_e515);
-    let _e517 = angle_1;
-    sa_2 = sin(_e517);
-    let _e519 = (*lightIndex);
-    let _e523 = point_shadow.slots[_e519][2u];
-    tanHalf_1 = max(_e523, 0.0001f);
+    let _e488 = ndc[0u];
+    let _e492 = ndc[1u];
+    uv_4 = vec2<f32>(((_e488 * 0.5f) + 0.5f), (0.5f - (_e492 * 0.5f)));
+    let _e496 = face;
+    let _e498 = slot_1;
+    tile_3 = vec2<f32>(f32(_e496), f32(_e498));
+    let _e501 = distance_;
+    let _e504 = point_shadow.params[1u];
+    receiver_2 = (_e501 - _e504);
+    let _e508 = frag_info.target_origin[0u];
+    param_101 = _e508;
+    let _e509 = FragCoordFromTop_u0028_f1_u003b((&param_101));
+    noise = fract((52.982918f * fract(dot(_e509, vec2<f32>(0.06711056f, 0.00583715f)))));
+    let _e514 = noise;
+    angle_1 = (_e514 * 6.2831855f);
+    let _e516 = angle_1;
+    ca_2 = cos(_e516);
+    let _e518 = angle_1;
+    sa_2 = sin(_e518);
+    let _e520 = (*lightIndex);
+    let _e524 = point_shadow.slots[_e520][2u];
+    tanHalf_1 = max(_e524, 0.0001f);
     blocker_1 = -1f;
-    let _e525 = uv_4;
-    param_102 = _e525;
-    let _e526 = tile_3;
-    param_103 = _e526;
-    let _e527 = range_3;
-    param_104 = _e527;
-    let _e528 = receiver_2;
-    param_105 = _e528;
-    let _e529 = ca_2;
-    param_106 = _e529;
-    let _e530 = sa_2;
-    param_107 = _e530;
-    let _e531 = tanHalf_1;
-    param_108 = _e531;
-    let _e532 = PointShadowPenumbra_u0028_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b((&param_102), (&param_103), (&param_104), (&param_105), (&param_106), (&param_107), (&param_108), (&param_109));
-    let _e533 = param_109;
-    blocker_1 = _e533;
-    radius_1 = _e532;
-    let _e536 = point_shadow.params2_[3u];
-    if (_e536 > 0.5f) {
+    let _e526 = uv_4;
+    param_102 = _e526;
+    let _e527 = tile_3;
+    param_103 = _e527;
+    let _e528 = range_3;
+    param_104 = _e528;
+    let _e529 = receiver_2;
+    param_105 = _e529;
+    let _e530 = ca_2;
+    param_106 = _e530;
+    let _e531 = sa_2;
+    param_107 = _e531;
+    let _e532 = tanHalf_1;
+    param_108 = _e532;
+    let _e533 = PointShadowPenumbra_u0028_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b((&param_102), (&param_103), (&param_104), (&param_105), (&param_106), (&param_107), (&param_108), (&param_109));
+    let _e534 = param_109;
+    blocker_1 = _e534;
+    radius_1 = _e533;
+    let _e537 = point_shadow.params2_[3u];
+    if (_e537 > 0.5f) {
         g_debug_surface_on = true;
-        let _e538 = radius_1;
-        if (_e538 < 0f) {
+        let _e539 = radius_1;
+        if (_e539 < 0f) {
             local_11 = vec3<f32>(0f, 0f, 1f);
         } else {
-            let _e540 = radius_1;
-            let _e543 = point_shadow.params2_[2u];
-            let _e547 = blocker_1;
-            let _e548 = range_3;
-            local_11 = vec3<f32>(clamp((_e540 / max(_e543, 0.000001f)), 0f, 1f), clamp((_e547 / _e548), 0f, 1f), 0f);
+            let _e541 = radius_1;
+            let _e544 = point_shadow.params2_[2u];
+            let _e548 = blocker_1;
+            let _e549 = range_3;
+            local_11 = vec3<f32>(clamp((_e541 / max(_e544, 0.000001f)), 0f, 1f), clamp((_e548 / _e549), 0f, 1f), 0f);
         }
-        let _e552 = local_11;
-        g_debug_surface = _e552;
+        let _e553 = local_11;
+        g_debug_surface = _e553;
     }
-    let _e553 = radius_1;
-    if (_e553 < 0f) {
+    let _e554 = radius_1;
+    if (_e554 < 0f) {
         return 1f;
     }
-    let _e555 = uv_4;
-    param_110 = _e555;
+    let _e556 = uv_4;
+    param_110 = _e556;
     param_111 = vec2<f32>(0f, 0f);
-    let _e556 = tile_3;
-    param_112 = _e556;
-    let _e557 = range_3;
-    param_113 = _e557;
-    let _e558 = receiver_2;
-    param_114 = _e558;
-    let _e559 = PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((&param_110), (&param_111), (&param_112), (&param_113), (&param_114));
-    lit_1 = _e559;
-    let _e560 = radius_1;
-    if (_e560 > 0f) {
+    let _e557 = tile_3;
+    param_112 = _e557;
+    let _e558 = range_3;
+    param_113 = _e558;
+    let _e559 = receiver_2;
+    param_114 = _e559;
+    let _e560 = PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((&param_110), (&param_111), (&param_112), (&param_113), (&param_114));
+    lit_1 = _e560;
+    let _e561 = radius_1;
+    if (_e561 > 0f) {
         i_4 = 0i;
         loop {
-            let _e562 = i_4;
-            if (_e562 < 8i) {
-                let _e564 = i_4;
-                param_115 = _e564;
-                let _e565 = ca_2;
-                param_116 = _e565;
-                let _e566 = sa_2;
-                param_117 = _e566;
-                let _e567 = radius_1;
-                param_118 = _e567;
-                let _e568 = PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b((&param_115), (&param_116), (&param_117), (&param_118));
-                let _e569 = uv_4;
-                param_119 = _e569;
-                param_120 = _e568;
-                let _e570 = tile_3;
-                param_121 = _e570;
-                let _e571 = range_3;
-                param_122 = _e571;
-                let _e572 = receiver_2;
-                param_123 = _e572;
-                let _e573 = PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((&param_119), (&param_120), (&param_121), (&param_122), (&param_123));
-                let _e574 = lit_1;
-                lit_1 = (_e574 + _e573);
+            let _e563 = i_4;
+            if (_e563 < 8i) {
+                let _e565 = i_4;
+                param_115 = _e565;
+                let _e566 = ca_2;
+                param_116 = _e566;
+                let _e567 = sa_2;
+                param_117 = _e567;
+                let _e568 = radius_1;
+                param_118 = _e568;
+                let _e569 = PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b((&param_115), (&param_116), (&param_117), (&param_118));
+                let _e570 = uv_4;
+                param_119 = _e570;
+                param_120 = _e569;
+                let _e571 = tile_3;
+                param_121 = _e571;
+                let _e572 = range_3;
+                param_122 = _e572;
+                let _e573 = receiver_2;
+                param_123 = _e573;
+                let _e574 = PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((&param_119), (&param_120), (&param_121), (&param_122), (&param_123));
+                let _e575 = lit_1;
+                lit_1 = (_e575 + _e574);
                 continue;
             } else {
                 break;
             }
             continuing {
-                let _e576 = i_4;
-                i_4 = (_e576 + 1i);
+                let _e577 = i_4;
+                i_4 = (_e577 + 1i);
             }
         }
-        let _e578 = lit_1;
-        lit_1 = (_e578 * 0.11111111f);
+        let _e579 = lit_1;
+        lit_1 = (_e579 * 0.11111111f);
     }
-    let _e580 = lit_1;
-    let _e581 = strength;
-    return mix(1f, _e580, clamp(_e581, 0f, 1f));
+    let _e581 = lit_1;
+    let _e582 = strength;
+    return mix(1f, _e581, clamp(_e582, 0f, 1f));
 }
 
 fn VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b(i_5: ptr<function, i32>, n_2: ptr<function, i32>, turn: ptr<function, f32>) -> vec2<f32> {
     var r_3: f32;
     var theta: f32;
 
-    let _e278 = (*i_5);
-    let _e281 = (*n_2);
-    r_3 = sqrt(((f32(_e278) + 0.5f) / f32(_e281)));
-    let _e285 = (*i_5);
-    let _e288 = (*turn);
-    theta = ((f32(_e285) * 2.3999631f) + _e288);
-    let _e290 = r_3;
-    let _e291 = theta;
-    let _e293 = theta;
-    return (vec2<f32>(cos(_e291), sin(_e293)) * _e290);
+    let _e279 = (*i_5);
+    let _e282 = (*n_2);
+    r_3 = sqrt(((f32(_e279) + 0.5f) / f32(_e282)));
+    let _e286 = (*i_5);
+    let _e289 = (*turn);
+    theta = ((f32(_e286) * 2.3999631f) + _e289);
+    let _e291 = r_3;
+    let _e292 = theta;
+    let _e294 = theta;
+    return (vec2<f32>(cos(_e292), sin(_e294)) * _e291);
 }
 
 fn ShadowNoise_u0028_() -> f32 {
     var at_3: vec2<f32>;
     var param_124: f32;
 
-    let _e277 = frag_info.target_origin[0u];
-    param_124 = _e277;
-    let _e278 = FragCoordFromTop_u0028_f1_u003b((&param_124));
-    let _e281 = frag_info.target_origin[3u];
-    at_3 = (_e278 + vec2((5.588238f * max(_e281, 0f))));
-    let _e286 = at_3;
-    return fract((52.982918f * fract(dot(_e286, vec2<f32>(0.06711056f, 0.00583715f)))));
+    let _e278 = frag_info.target_origin[0u];
+    param_124 = _e278;
+    let _e279 = FragCoordFromTop_u0028_f1_u003b((&param_124));
+    let _e282 = frag_info.target_origin[3u];
+    at_3 = (_e279 + vec2((5.588238f * max(_e282, 0f))));
+    let _e287 = at_3;
+    return fract((52.982918f * fract(dot(_e287, vec2<f32>(0.06711056f, 0.00583715f)))));
 }
 
 fn EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b(moments: ptr<function, vec2<f32>>, t: ptr<function, f32>, minVariance: ptr<function, f32>, bleed: ptr<function, f32>) -> f32 {
@@ -19637,37 +19756,37 @@ fn EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b(moments: ptr<functio
     var pMax: f32;
     var reduced: f32;
 
-    let _e282 = (*moments)[1u];
-    let _e284 = (*moments)[0u];
-    let _e286 = (*moments)[0u];
-    let _e289 = (*minVariance);
-    variance = max((_e282 - (_e284 * _e286)), _e289);
-    let _e291 = (*t);
-    let _e293 = (*moments)[0u];
-    d_3 = (_e291 - _e293);
-    let _e295 = variance;
+    let _e283 = (*moments)[1u];
+    let _e285 = (*moments)[0u];
+    let _e287 = (*moments)[0u];
+    let _e290 = (*minVariance);
+    variance = max((_e283 - (_e285 * _e287)), _e290);
+    let _e292 = (*t);
+    let _e294 = (*moments)[0u];
+    d_3 = (_e292 - _e294);
     let _e296 = variance;
-    let _e297 = d_3;
+    let _e297 = variance;
     let _e298 = d_3;
-    pMax = (_e295 / (_e296 + (_e297 * _e298)));
-    let _e302 = pMax;
-    let _e303 = (*bleed);
-    let _e305 = (*bleed);
-    reduced = clamp(((_e302 - _e303) / max((1f - _e305), 0.0001f)), 0f, 1f);
-    let _e310 = (*t);
-    let _e312 = (*moments)[0u];
-    let _e314 = reduced;
-    return select(_e314, 1f, (_e310 <= _e312));
+    let _e299 = d_3;
+    pMax = (_e296 / (_e297 + (_e298 * _e299)));
+    let _e303 = pMax;
+    let _e304 = (*bleed);
+    let _e306 = (*bleed);
+    reduced = clamp(((_e303 - _e304) / max((1f - _e306), 0.0001f)), 0f, 1f);
+    let _e311 = (*t);
+    let _e313 = (*moments)[0u];
+    let _e315 = reduced;
+    return select(_e315, 1f, (_e311 <= _e313));
 }
 
 fn EvsmWarp_u0028_f1_u003b(depth: ptr<function, f32>) -> vec2<f32> {
     var d_4: f32;
 
-    let _e275 = (*depth);
-    d_4 = ((2f * clamp(_e275, 0f, 1f)) - 1f);
-    let _e279 = d_4;
-    let _e282 = d_4;
-    return vec2<f32>(exp((40f * _e279)), -(exp((-5f * _e282))));
+    let _e276 = (*depth);
+    d_4 = ((2f * clamp(_e276, 0f, 1f)) - 1f);
+    let _e280 = d_4;
+    let _e283 = d_4;
+    return vec2<f32>(exp((40f * _e280)), -(exp((-5f * _e283))));
 }
 
 fn EvsmVisibility_u0028_vf4_u003b_f1_u003b_f1_u003b(moments_1: ptr<function, vec4<f32>>, depth_1: ptr<function, f32>, bleed_1: ptr<function, f32>) -> f32 {
@@ -19685,37 +19804,37 @@ fn EvsmVisibility_u0028_vf4_u003b_f1_u003b_f1_u003b(moments_1: ptr<function, vec
     var param_132: f32;
     var param_133: f32;
 
-    let _e289 = (*depth_1);
-    param_125 = _e289;
-    let _e290 = EvsmWarp_u0028_f1_u003b((&param_125));
-    warped = _e290;
-    let _e291 = warped;
-    scale = (vec2<f32>(0.004f, 0.0005f) * _e291);
-    let _e294 = scale[0u];
-    let _e296 = scale[0u];
-    let _e298 = (*moments_1);
-    param_126 = _e298.xy;
-    let _e301 = warped[0u];
-    param_127 = _e301;
-    param_128 = (_e294 * _e296);
-    let _e302 = (*bleed_1);
-    param_129 = _e302;
-    let _e303 = EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b((&param_126), (&param_127), (&param_128), (&param_129));
-    positive = _e303;
-    let _e305 = scale[1u];
-    let _e307 = scale[1u];
-    let _e309 = (*moments_1);
-    param_130 = _e309.zw;
-    let _e312 = warped[1u];
-    param_131 = _e312;
-    param_132 = (_e305 * _e307);
-    let _e313 = (*bleed_1);
-    param_133 = _e313;
-    let _e314 = EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b((&param_130), (&param_131), (&param_132), (&param_133));
-    negative = _e314;
-    let _e315 = positive;
-    let _e316 = negative;
-    return min(_e315, _e316);
+    let _e290 = (*depth_1);
+    param_125 = _e290;
+    let _e291 = EvsmWarp_u0028_f1_u003b((&param_125));
+    warped = _e291;
+    let _e292 = warped;
+    scale = (vec2<f32>(0.004f, 0.0005f) * _e292);
+    let _e295 = scale[0u];
+    let _e297 = scale[0u];
+    let _e299 = (*moments_1);
+    param_126 = _e299.xy;
+    let _e302 = warped[0u];
+    param_127 = _e302;
+    param_128 = (_e295 * _e297);
+    let _e303 = (*bleed_1);
+    param_129 = _e303;
+    let _e304 = EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b((&param_126), (&param_127), (&param_128), (&param_129));
+    positive = _e304;
+    let _e306 = scale[1u];
+    let _e308 = scale[1u];
+    let _e310 = (*moments_1);
+    param_130 = _e310.zw;
+    let _e313 = warped[1u];
+    param_131 = _e313;
+    param_132 = (_e306 * _e308);
+    let _e314 = (*bleed_1);
+    param_133 = _e314;
+    let _e315 = EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b((&param_130), (&param_131), (&param_132), (&param_133));
+    negative = _e315;
+    let _e316 = positive;
+    let _e317 = negative;
+    return min(_e316, _e317);
 }
 
 fn ShadowFactor_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b_i1_u003b(s_5: ptr<function, Surface>, light_2: ptr<function, LightSample>, lightIndex_1: ptr<function, i32>) -> f32 {
@@ -19753,6 +19872,8 @@ fn ShadowFactor_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf
     var tileLo: vec2<f32>;
     var tileHi: vec2<f32>;
     var stored_2: vec4<f32>;
+    var y_1: i32;
+    var x_1: i32;
     var through: vec3<f32>;
     var softness: f32;
     var lit_2: f32;
@@ -19760,8 +19881,8 @@ fn ShadowFactor_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf
     var param_134: vec4<f32>;
     var param_135: f32;
     var param_136: f32;
-    var y_1: i32;
-    var x_1: i32;
+    var y_2: i32;
+    var x_2: i32;
     var occluder: f32;
     var spread: f32;
     var turn_1: f32;
@@ -19790,45 +19911,45 @@ fn ShadowFactor_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf
     var phi_4266_: bool;
     var phi_4273_: bool;
 
-    let _e343 = frag_info.shadow_params[3u];
-    strength_1 = _e343;
-    let _e344 = strength_1;
-    if (_e344 <= 0f) {
+    let _e346 = frag_info.shadow_params[3u];
+    strength_1 = _e346;
+    let _e347 = strength_1;
+    if (_e347 <= 0f) {
         return 1f;
     }
-    let _e346 = (*lightIndex_1);
-    let _e349 = frag_info.frame_params[2u];
-    if (_e346 != i32((_e349 + 0.5f))) {
+    let _e349 = (*lightIndex_1);
+    let _e352 = frag_info.frame_params[2u];
+    if (_e349 != i32((_e352 + 0.5f))) {
         return 1f;
     }
-    let _e355 = frag_info.shadow_cascades[2u];
-    cascadeCount = i32((_e355 + 0.5f));
-    let _e358 = v_world_position_1;
-    let _e360 = frag_info.camera_position;
-    viewDistance = length((_e358 - _e360.xyz));
+    let _e358 = frag_info.shadow_cascades[2u];
+    cascadeCount = i32((_e358 + 0.5f));
+    let _e361 = v_world_position_1;
+    let _e363 = frag_info.camera_position;
+    viewDistance = length((_e361 - _e363.xyz));
     cascade = 0i;
-    let _e364 = cascadeCount;
-    let _e365 = (_e364 > 1i);
-    phi_4087_ = _e365;
-    if _e365 {
-        let _e366 = viewDistance;
-        let _e369 = frag_info.shadow_cascades[0u];
-        phi_4087_ = (_e366 > _e369);
-    }
-    let _e372 = phi_4087_;
-    if _e372 {
+    let _e367 = cascadeCount;
+    let _e368 = (_e367 > 1i);
+    phi_4087_ = _e368;
+    if _e368 {
+        let _e369 = viewDistance;
+        let _e372 = frag_info.shadow_cascades[0u];
+        phi_4087_ = (_e369 > _e372);
+    }
+    let _e375 = phi_4087_;
+    if _e375 {
         cascade = 1i;
     }
-    let _e373 = cascadeCount;
-    let _e374 = (_e373 > 2i);
-    phi_4098_ = _e374;
-    if _e374 {
-        let _e375 = viewDistance;
-        let _e378 = frag_info.shadow_cascades[1u];
-        phi_4098_ = (_e375 > _e378);
+    let _e376 = cascadeCount;
+    let _e377 = (_e376 > 2i);
+    phi_4098_ = _e377;
+    if _e377 {
+        let _e378 = viewDistance;
+        let _e381 = frag_info.shadow_cascades[1u];
+        phi_4098_ = (_e378 > _e381);
     }
-    let _e381 = phi_4098_;
-    if _e381 {
+    let _e384 = phi_4098_;
+    if _e384 {
         cascade = 2i;
     }
     uv_5 = vec2<f32>(0f, 0f);
@@ -19839,247 +19960,280 @@ fn ShadowFactor_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf
     receiverSlope = 0f;
     attempt = 0i;
     loop {
-        let _e382 = attempt;
-        if (_e382 < 3i) {
-            let _e384 = cascade;
-            let _e385 = attempt;
-            which = (_e384 + _e385);
-            let _e387 = which;
-            let _e388 = cascadeCount;
-            if (_e387 >= _e388) {
+        let _e385 = attempt;
+        if (_e385 < 3i) {
+            let _e387 = cascade;
+            let _e388 = attempt;
+            which = (_e387 + _e388);
+            let _e390 = which;
+            let _e391 = cascadeCount;
+            if (_e390 >= _e391) {
                 break;
             }
-            let _e390 = which;
-            if (_e390 == 0i) {
-                let _e393 = frag_info.shadow_matrix;
-                local_12 = _e393;
+            let _e393 = which;
+            if (_e393 == 0i) {
+                let _e396 = frag_info.shadow_matrix;
+                local_12 = _e396;
             } else {
-                let _e394 = which;
-                if (_e394 == 1i) {
-                    let _e397 = frag_info.shadow_matrix_far;
-                    local_13 = _e397;
+                let _e397 = which;
+                if (_e397 == 1i) {
+                    let _e400 = frag_info.shadow_matrix_far;
+                    local_13 = _e400;
                 } else {
-                    let _e399 = frag_info.shadow_matrix_farthest;
-                    local_13 = _e399;
+                    let _e402 = frag_info.shadow_matrix_farthest;
+                    local_13 = _e402;
                 }
-                let _e400 = local_13;
-                local_12 = _e400;
-            }
-            let _e401 = local_12;
-            matrix = _e401;
-            let _e404 = matrix[0][0u];
-            let _e407 = matrix[1][0u];
-            let _e410 = matrix[2][0u];
-            axisX = vec3<f32>(_e404, _e407, _e410);
-            let _e414 = matrix[0][1u];
-            let _e417 = matrix[1][1u];
-            let _e420 = matrix[2][1u];
-            axisY = vec3<f32>(_e414, _e417, _e420);
-            let _e422 = axisX;
-            rowX = max(length(_e422), 0.000001f);
-            let _e425 = axisY;
-            rowY = max(length(_e425), 0.000001f);
-            let _e430 = frag_info.shadow_cascades[3u];
-            let _e432 = rowX;
-            texelMetres = ((2f * _e430) / _e432);
-            let _e436 = frag_info.shadow_cascades[3u];
-            let _e439 = (*s_5).n;
-            let _e440 = axisX;
-            let _e443 = rowX;
-            let _e444 = rowX;
-            let _e448 = (*s_5).n;
-            let _e449 = axisY;
-            let _e452 = rowY;
-            let _e453 = rowY;
-            reach = ((3f * _e436) * ((abs(dot(_e439, _e440)) / (_e443 * _e444)) + (abs(dot(_e448, _e449)) / (_e452 * _e453))));
-            let _e460 = frag_info.shadow_params[2u];
-            let _e461 = texelMetres;
-            flatOffset = min(_e460, _e461);
-            let _e463 = v_world_position_1;
-            let _e465 = (*s_5).n;
-            let _e466 = flatOffset;
-            let _e467 = reach;
-            origin_1 = (_e463 + (_e465 * (_e466 + _e467)));
-            let _e471 = matrix;
-            let _e472 = origin_1;
-            lightSpace = (_e471 * vec4<f32>(_e472.x, _e472.y, _e472.z, 1f));
-            let _e479 = lightSpace[3u];
-            if (_e479 <= 0f) {
+                let _e403 = local_13;
+                local_12 = _e403;
+            }
+            let _e404 = local_12;
+            matrix = _e404;
+            let _e407 = matrix[0][0u];
+            let _e410 = matrix[1][0u];
+            let _e413 = matrix[2][0u];
+            axisX = vec3<f32>(_e407, _e410, _e413);
+            let _e417 = matrix[0][1u];
+            let _e420 = matrix[1][1u];
+            let _e423 = matrix[2][1u];
+            axisY = vec3<f32>(_e417, _e420, _e423);
+            let _e425 = axisX;
+            rowX = max(length(_e425), 0.000001f);
+            let _e428 = axisY;
+            rowY = max(length(_e428), 0.000001f);
+            let _e433 = frag_info.shadow_cascades[3u];
+            let _e435 = rowX;
+            texelMetres = ((2f * _e433) / _e435);
+            let _e439 = frag_info.shadow_cascades[3u];
+            let _e442 = (*s_5).n;
+            let _e443 = axisX;
+            let _e446 = rowX;
+            let _e447 = rowX;
+            let _e451 = (*s_5).n;
+            let _e452 = axisY;
+            let _e455 = rowY;
+            let _e456 = rowY;
+            reach = ((3f * _e439) * ((abs(dot(_e442, _e443)) / (_e446 * _e447)) + (abs(dot(_e451, _e452)) / (_e455 * _e456))));
+            let _e463 = frag_info.shadow_params[2u];
+            let _e464 = texelMetres;
+            flatOffset = min(_e463, _e464);
+            let _e466 = v_world_position_1;
+            let _e468 = (*s_5).n;
+            let _e469 = flatOffset;
+            let _e470 = reach;
+            origin_1 = (_e466 + (_e468 * (_e469 + _e470)));
+            let _e474 = matrix;
+            let _e475 = origin_1;
+            lightSpace = (_e474 * vec4<f32>(_e475.x, _e475.y, _e475.z, 1f));
+            let _e482 = lightSpace[3u];
+            if (_e482 <= 0f) {
                 continue;
             }
-            let _e481 = lightSpace;
-            let _e484 = lightSpace[3u];
-            candidate = (_e481.xyz / vec3(_e484));
-            let _e488 = candidate[0u];
-            let _e492 = candidate[1u];
-            inTile = vec2<f32>(((_e488 * 0.5f) + 0.5f), (0.5f - (_e492 * 0.5f)));
-            let _e497 = inTile[0u];
-            let _e498 = (_e497 < 0f);
-            phi_4259_ = _e498;
-            if !(_e498) {
-                let _e501 = inTile[0u];
-                phi_4259_ = (_e501 > 1f);
-            }
-            let _e504 = phi_4259_;
-            phi_4266_ = _e504;
-            if !(_e504) {
-                let _e507 = inTile[1u];
-                phi_4266_ = (_e507 < 0f);
-            }
-            let _e510 = phi_4266_;
-            phi_4273_ = _e510;
-            if !(_e510) {
-                let _e513 = inTile[1u];
-                phi_4273_ = (_e513 > 1f);
-            }
-            let _e516 = phi_4273_;
-            if _e516 {
+            let _e484 = lightSpace;
+            let _e487 = lightSpace[3u];
+            candidate = (_e484.xyz / vec3(_e487));
+            let _e491 = candidate[0u];
+            let _e495 = candidate[1u];
+            inTile = vec2<f32>(((_e491 * 0.5f) + 0.5f), (0.5f - (_e495 * 0.5f)));
+            let _e500 = inTile[0u];
+            let _e501 = (_e500 < 0f);
+            phi_4259_ = _e501;
+            if !(_e501) {
+                let _e504 = inTile[0u];
+                phi_4259_ = (_e504 > 1f);
+            }
+            let _e507 = phi_4259_;
+            phi_4266_ = _e507;
+            if !(_e507) {
+                let _e510 = inTile[1u];
+                phi_4266_ = (_e510 < 0f);
+            }
+            let _e513 = phi_4266_;
+            phi_4273_ = _e513;
+            if !(_e513) {
+                let _e516 = inTile[1u];
+                phi_4273_ = (_e516 > 1f);
+            }
+            let _e519 = phi_4273_;
+            if _e519 {
                 continue;
             }
-            let _e518 = candidate[2u];
-            if (_e518 > 1f) {
-                let _e520 = which;
-                let _e521 = cascadeCount;
-                if (_e520 < (_e521 - 1i)) {
+            let _e521 = candidate[2u];
+            if (_e521 > 1f) {
+                let _e523 = which;
+                let _e524 = cascadeCount;
+                if (_e523 < (_e524 - 1i)) {
                     continue;
                 }
                 candidate[2u] = 1f;
             }
-            let _e526 = inTile[0u];
-            let _e527 = which;
-            let _e530 = cascadeCount;
-            let _e534 = inTile[1u];
-            uv_5 = vec2<f32>(((_e526 + f32(_e527)) / f32(_e530)), _e534);
-            let _e536 = candidate;
-            projected = _e536;
-            let _e537 = which;
-            cascade = _e537;
-            let _e538 = texelMetres;
-            cascadeTexel = _e538;
-            let _e541 = matrix[0][2u];
-            let _e544 = matrix[1][2u];
-            let _e547 = matrix[2][2u];
-            cascadeDepth = (1f / max(length(vec3<f32>(_e541, _e544, _e547)), 0.000001f));
-            let _e553 = (*s_5).n;
-            let _e556 = matrix[0][2u];
-            let _e559 = matrix[1][2u];
-            let _e562 = matrix[2][2u];
-            let _e566 = cascadeDepth;
-            cosSlope = clamp((abs(dot(_e553, vec3<f32>(_e556, _e559, _e562))) * _e566), 0.1f, 1f);
-            let _e569 = texelMetres;
-            let _e570 = cosSlope;
-            let _e571 = cosSlope;
-            let _e577 = cosSlope;
-            let _e579 = cascadeDepth;
-            receiverSlope = (((_e569 * sqrt(max((1f - (_e570 * _e571)), 0f))) / _e577) / _e579);
+            let _e529 = inTile[0u];
+            let _e530 = which;
+            let _e533 = cascadeCount;
+            let _e537 = inTile[1u];
+            uv_5 = vec2<f32>(((_e529 + f32(_e530)) / f32(_e533)), _e537);
+            let _e539 = candidate;
+            projected = _e539;
+            let _e540 = which;
+            cascade = _e540;
+            let _e541 = texelMetres;
+            cascadeTexel = _e541;
+            let _e544 = matrix[0][2u];
+            let _e547 = matrix[1][2u];
+            let _e550 = matrix[2][2u];
+            cascadeDepth = (1f / max(length(vec3<f32>(_e544, _e547, _e550)), 0.000001f));
+            let _e556 = (*s_5).n;
+            let _e559 = matrix[0][2u];
+            let _e562 = matrix[1][2u];
+            let _e565 = matrix[2][2u];
+            let _e569 = cascadeDepth;
+            cosSlope = clamp((abs(dot(_e556, vec3<f32>(_e559, _e562, _e565))) * _e569), 0.1f, 1f);
+            let _e572 = texelMetres;
+            let _e573 = cosSlope;
+            let _e574 = cosSlope;
+            let _e580 = cosSlope;
+            let _e582 = cascadeDepth;
+            receiverSlope = (((_e572 * sqrt(max((1f - (_e573 * _e574)), 0f))) / _e580) / _e582);
             found = true;
             break;
         } else {
             break;
         }
         continuing {
-            let _e581 = attempt;
-            attempt = (_e581 + 1i);
+            let _e584 = attempt;
+            attempt = (_e584 + 1i);
         }
     }
-    let _e583 = found;
-    if !(_e583) {
+    let _e586 = found;
+    if !(_e586) {
         return 1f;
     }
-    let _e585 = cascade;
-    if (_e585 == 0i) {
-        let _e589 = frag_info.shadow_bias[0u];
-        local_14 = _e589;
+    let _e588 = cascade;
+    if (_e588 == 0i) {
+        let _e592 = frag_info.shadow_bias[0u];
+        local_14 = _e592;
     } else {
-        let _e590 = cascade;
-        if (_e590 == 1i) {
-            let _e594 = frag_info.shadow_bias[1u];
-            local_15 = _e594;
-        } else {
-            let _e597 = frag_info.shadow_bias[2u];
+        let _e593 = cascade;
+        if (_e593 == 1i) {
+            let _e597 = frag_info.shadow_bias[1u];
             local_15 = _e597;
-        }
-        let _e598 = local_15;
-        local_14 = _e598;
-    }
-    let _e599 = local_14;
-    bias = _e599;
-    let _e602 = frag_info.shadow_params[0u];
-    let _e605 = frag_info.shadow_cascades[3u];
-    texel_1 = vec2<f32>(_e602, _e605);
-    let _e607 = cascade;
-    let _e609 = cascadeCount;
-    let _e613 = texel_1;
-    tileLo = (vec2<f32>((f32(_e607) / f32(_e609)), 0f) + (_e613 * 0.5f));
-    let _e616 = cascade;
-    let _e619 = cascadeCount;
-    let _e623 = texel_1;
-    tileHi = (vec2<f32>((f32((_e616 + 1i)) / f32(_e619)), 1f) - (_e623 * 0.5f));
-    let _e628 = frag_info.shadow_bias[3u];
-    if (_e628 > 0.5f) {
-        let _e630 = uv_5;
-        let _e631 = tileLo;
-        let _e632 = tileHi;
-        let _e634 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp(_e630, _e631, _e632), 0f);
-        stored_2 = _e634;
-        let _e636 = stored_2[1u];
-        let _e639 = stored_2[2u];
-        let _e642 = stored_2[3u];
-        through = clamp(vec3<f32>((1f - _e636), (1f - _e639), _e642), vec3(0f), vec3(4f));
-        let _e647 = through;
-        let _e648 = strength_1;
-        light_transmittance = mix(vec3<f32>(1f, 1f, 1f), _e647, vec3(clamp(_e648, 0f, 1f)));
-    }
-    let _e654 = frag_info.ambient_ground[3u];
-    softness = _e654;
+        } else {
+            let _e600 = frag_info.shadow_bias[2u];
+            local_15 = _e600;
+        }
+        let _e601 = local_15;
+        local_14 = _e601;
+    }
+    let _e602 = local_14;
+    bias = _e602;
+    let _e605 = frag_info.shadow_params[0u];
+    let _e608 = frag_info.shadow_cascades[3u];
+    texel_1 = vec2<f32>(_e605, _e608);
+    let _e610 = cascade;
+    let _e612 = cascadeCount;
+    let _e616 = texel_1;
+    tileLo = (vec2<f32>((f32(_e610) / f32(_e612)), 0f) + (_e616 * 0.5f));
+    let _e619 = cascade;
+    let _e622 = cascadeCount;
+    let _e626 = texel_1;
+    tileHi = (vec2<f32>((f32((_e619 + 1i)) / f32(_e622)), 1f) - (_e626 * 0.5f));
+    let _e631 = frag_info.shadow_bias[3u];
+    if (_e631 > 0.5f) {
+        stored_2 = vec4<f32>(0f, 0f, 0f, 0f);
+        y_1 = -1i;
+        loop {
+            let _e633 = y_1;
+            if (_e633 <= 1i) {
+                x_1 = -1i;
+                loop {
+                    let _e635 = x_1;
+                    if (_e635 <= 1i) {
+                        let _e637 = uv_5;
+                        let _e638 = x_1;
+                        let _e640 = y_1;
+                        let _e643 = texel_1;
+                        let _e646 = tileLo;
+                        let _e647 = tileHi;
+                        let _e649 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e637 + (vec2<f32>(f32(_e638), f32(_e640)) * _e643)), _e646, _e647), 0f);
+                        let _e650 = stored_2;
+                        stored_2 = (_e650 + _e649);
+                        continue;
+                    } else {
+                        break;
+                    }
+                    continuing {
+                        let _e652 = x_1;
+                        x_1 = (_e652 + 1i);
+                    }
+                }
+                continue;
+            } else {
+                break;
+            }
+            continuing {
+                let _e654 = y_1;
+                y_1 = (_e654 + 1i);
+            }
+        }
+        let _e656 = stored_2;
+        stored_2 = (_e656 * 0.11111111f);
+        let _e659 = stored_2[1u];
+        let _e662 = stored_2[2u];
+        let _e665 = stored_2[3u];
+        through = clamp(vec3<f32>((1f - _e659), (1f - _e662), _e665), vec3(0f), vec3(4f));
+        let _e670 = through;
+        let _e671 = strength_1;
+        light_transmittance = mix(vec3<f32>(1f, 1f, 1f), _e670, vec3(clamp(_e671, 0f, 1f)));
+    }
+    let _e677 = frag_info.ambient_ground[3u];
+    softness = _e677;
     lit_2 = 0f;
-    let _e655 = softness;
-    if (_e655 < 0f) {
-        let _e657 = uv_5;
-        let _e658 = tileLo;
-        let _e659 = tileHi;
-        let _e661 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp(_e657, _e658, _e659), 0f);
-        moments_2 = _e661;
-        let _e663 = projected[2u];
-        let _e664 = bias;
-        let _e666 = softness;
-        let _e670 = moments_2;
-        param_134 = _e670;
-        param_135 = (_e663 - _e664);
-        param_136 = clamp((-(_e666) - 1f), 0f, 0.95f);
-        let _e671 = EvsmVisibility_u0028_vf4_u003b_f1_u003b_f1_u003b((&param_134), (&param_135), (&param_136));
-        lit_2 = _e671;
-    } else {
-        let _e672 = softness;
-        if (_e672 <= 0f) {
-            y_1 = -1i;
+    let _e678 = softness;
+    if (_e678 < 0f) {
+        let _e680 = uv_5;
+        let _e681 = tileLo;
+        let _e682 = tileHi;
+        let _e684 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp(_e680, _e681, _e682), 0f);
+        moments_2 = _e684;
+        let _e686 = projected[2u];
+        let _e687 = bias;
+        let _e689 = softness;
+        let _e693 = moments_2;
+        param_134 = _e693;
+        param_135 = (_e686 - _e687);
+        param_136 = clamp((-(_e689) - 1f), 0f, 0.95f);
+        let _e694 = EvsmVisibility_u0028_vf4_u003b_f1_u003b_f1_u003b((&param_134), (&param_135), (&param_136));
+        lit_2 = _e694;
+    } else {
+        let _e695 = softness;
+        if (_e695 <= 0f) {
+            y_2 = -1i;
             loop {
-                let _e674 = y_1;
-                if (_e674 <= 1i) {
-                    x_1 = -1i;
+                let _e697 = y_2;
+                if (_e697 <= 1i) {
+                    x_2 = -1i;
                     loop {
-                        let _e676 = x_1;
-                        if (_e676 <= 1i) {
-                            let _e678 = uv_5;
-                            let _e679 = x_1;
-                            let _e681 = y_1;
-                            let _e684 = texel_1;
-                            let _e687 = tileLo;
-                            let _e688 = tileHi;
-                            let _e690 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e678 + (vec2<f32>(f32(_e679), f32(_e681)) * _e684)), _e687, _e688), 0f);
-                            occluder = _e690.x;
-                            let _e693 = projected[2u];
-                            let _e694 = bias;
-                            let _e696 = occluder;
-                            let _e699 = lit_2;
-                            lit_2 = (_e699 + select(1f, 0f, ((_e693 - _e694) > _e696)));
+                        let _e699 = x_2;
+                        if (_e699 <= 1i) {
+                            let _e701 = uv_5;
+                            let _e702 = x_2;
+                            let _e704 = y_2;
+                            let _e707 = texel_1;
+                            let _e710 = tileLo;
+                            let _e711 = tileHi;
+                            let _e713 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e701 + (vec2<f32>(f32(_e702), f32(_e704)) * _e707)), _e710, _e711), 0f);
+                            occluder = _e713.x;
+                            let _e716 = projected[2u];
+                            let _e717 = bias;
+                            let _e719 = occluder;
+                            let _e722 = lit_2;
+                            lit_2 = (_e722 + select(1f, 0f, ((_e716 - _e717) > _e719)));
                             continue;
                         } else {
                             break;
                         }
                         continuing {
-                            let _e701 = x_1;
-                            x_1 = (_e701 + 1i);
+                            let _e724 = x_2;
+                            x_2 = (_e724 + 1i);
                         }
                     }
                     continue;
@@ -20087,125 +20241,125 @@ fn ShadowFactor_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf
                     break;
                 }
                 continuing {
-                    let _e703 = y_1;
-                    y_1 = (_e703 + 1i);
+                    let _e726 = y_2;
+                    y_2 = (_e726 + 1i);
                 }
             }
-            let _e705 = lit_2;
-            lit_2 = (_e705 * 0.11111111f);
+            let _e728 = lit_2;
+            lit_2 = (_e728 * 0.11111111f);
         } else {
-            let _e707 = softness;
-            spread = tan(min(_e707, 0.5f));
-            let _e710 = ShadowNoise_u0028_();
-            turn_1 = (_e710 * 6.2831855f);
-            let _e712 = spread;
-            let _e714 = projected[2u];
-            let _e716 = cascadeDepth;
-            let _e718 = cascadeTexel;
-            searchRadius = clamp((((_e712 * _e714) * _e716) / _e718), 1f, 16f);
+            let _e730 = softness;
+            spread = tan(min(_e730, 0.5f));
+            let _e733 = ShadowNoise_u0028_();
+            turn_1 = (_e733 * 6.2831855f);
+            let _e735 = spread;
+            let _e737 = projected[2u];
+            let _e739 = cascadeDepth;
+            let _e741 = cascadeTexel;
+            searchRadius = clamp((((_e735 * _e737) * _e739) / _e741), 1f, 16f);
             blockerSum = 0f;
             blockerCount = 0f;
             i_6 = 0i;
             loop {
-                let _e721 = i_6;
-                if (_e721 < 16i) {
-                    let _e723 = i_6;
-                    param_137 = _e723;
+                let _e744 = i_6;
+                if (_e744 < 16i) {
+                    let _e746 = i_6;
+                    param_137 = _e746;
                     param_138 = 16i;
-                    let _e724 = turn_1;
-                    param_139 = _e724;
-                    let _e725 = VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b((&param_137), (&param_138), (&param_139));
-                    disc = _e725;
-                    let _e726 = bias;
-                    let _e727 = disc;
-                    let _e729 = searchRadius;
-                    let _e733 = receiverSlope;
-                    tapBias = (_e726 + (max(((length(_e727) * _e729) - 1.5f), 0f) * _e733));
-                    let _e736 = uv_5;
-                    let _e737 = disc;
-                    let _e738 = texel_1;
-                    let _e740 = searchRadius;
-                    let _e743 = tileLo;
-                    let _e744 = tileHi;
-                    let _e746 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e736 + ((_e737 * _e738) * _e740)), _e743, _e744), 0f);
-                    occluder_1 = _e746.x;
-                    let _e749 = projected[2u];
-                    let _e750 = tapBias;
-                    let _e752 = occluder_1;
-                    if ((_e749 - _e750) > _e752) {
-                        let _e754 = occluder_1;
-                        let _e755 = blockerSum;
-                        blockerSum = (_e755 + _e754);
-                        let _e757 = blockerCount;
-                        blockerCount = (_e757 + 1f);
+                    let _e747 = turn_1;
+                    param_139 = _e747;
+                    let _e748 = VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b((&param_137), (&param_138), (&param_139));
+                    disc = _e748;
+                    let _e749 = bias;
+                    let _e750 = disc;
+                    let _e752 = searchRadius;
+                    let _e756 = receiverSlope;
+                    tapBias = (_e749 + (max(((length(_e750) * _e752) - 1.5f), 0f) * _e756));
+                    let _e759 = uv_5;
+                    let _e760 = disc;
+                    let _e761 = texel_1;
+                    let _e763 = searchRadius;
+                    let _e766 = tileLo;
+                    let _e767 = tileHi;
+                    let _e769 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e759 + ((_e760 * _e761) * _e763)), _e766, _e767), 0f);
+                    occluder_1 = _e769.x;
+                    let _e772 = projected[2u];
+                    let _e773 = tapBias;
+                    let _e775 = occluder_1;
+                    if ((_e772 - _e773) > _e775) {
+                        let _e777 = occluder_1;
+                        let _e778 = blockerSum;
+                        blockerSum = (_e778 + _e777);
+                        let _e780 = blockerCount;
+                        blockerCount = (_e780 + 1f);
                     }
                     continue;
                 } else {
                     break;
                 }
                 continuing {
-                    let _e759 = i_6;
-                    i_6 = (_e759 + 1i);
+                    let _e782 = i_6;
+                    i_6 = (_e782 + 1i);
                 }
             }
-            let _e761 = blockerCount;
-            if (_e761 <= 0f) {
+            let _e784 = blockerCount;
+            if (_e784 <= 0f) {
                 return 1f;
             }
-            let _e764 = projected[2u];
-            let _e765 = blockerSum;
-            let _e766 = blockerCount;
-            let _e770 = cascadeDepth;
-            gap = (max((_e764 - (_e765 / _e766)), 0f) * _e770);
-            let _e772 = spread;
-            let _e773 = gap;
-            let _e775 = cascadeTexel;
-            radius_2 = clamp(((_e772 * _e773) / _e775), 1f, 16f);
+            let _e787 = projected[2u];
+            let _e788 = blockerSum;
+            let _e789 = blockerCount;
+            let _e793 = cascadeDepth;
+            gap = (max((_e787 - (_e788 / _e789)), 0f) * _e793);
+            let _e795 = spread;
+            let _e796 = gap;
+            let _e798 = cascadeTexel;
+            radius_2 = clamp(((_e795 * _e796) / _e798), 1f, 16f);
             i_7 = 0i;
             loop {
-                let _e778 = i_7;
-                if (_e778 < 16i) {
-                    let _e780 = turn_1;
-                    let _e782 = i_7;
-                    param_140 = _e782;
+                let _e801 = i_7;
+                if (_e801 < 16i) {
+                    let _e803 = turn_1;
+                    let _e805 = i_7;
+                    param_140 = _e805;
                     param_141 = 16i;
-                    param_142 = (_e780 + 1f);
-                    let _e783 = VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b((&param_140), (&param_141), (&param_142));
-                    disc_1 = _e783;
-                    let _e784 = bias;
-                    let _e785 = disc_1;
-                    let _e787 = radius_2;
-                    let _e791 = receiverSlope;
-                    tapBias_1 = (_e784 + (max(((length(_e785) * _e787) - 1.5f), 0f) * _e791));
-                    let _e794 = uv_5;
-                    let _e795 = disc_1;
-                    let _e796 = texel_1;
-                    let _e798 = radius_2;
-                    let _e801 = tileLo;
-                    let _e802 = tileHi;
-                    let _e804 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e794 + ((_e795 * _e796) * _e798)), _e801, _e802), 0f);
-                    occluder_2 = _e804.x;
-                    let _e807 = projected[2u];
-                    let _e808 = tapBias_1;
-                    let _e810 = occluder_2;
-                    let _e813 = lit_2;
-                    lit_2 = (_e813 + select(1f, 0f, ((_e807 - _e808) > _e810)));
+                    param_142 = (_e803 + 1f);
+                    let _e806 = VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b((&param_140), (&param_141), (&param_142));
+                    disc_1 = _e806;
+                    let _e807 = bias;
+                    let _e808 = disc_1;
+                    let _e810 = radius_2;
+                    let _e814 = receiverSlope;
+                    tapBias_1 = (_e807 + (max(((length(_e808) * _e810) - 1.5f), 0f) * _e814));
+                    let _e817 = uv_5;
+                    let _e818 = disc_1;
+                    let _e819 = texel_1;
+                    let _e821 = radius_2;
+                    let _e824 = tileLo;
+                    let _e825 = tileHi;
+                    let _e827 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e817 + ((_e818 * _e819) * _e821)), _e824, _e825), 0f);
+                    occluder_2 = _e827.x;
+                    let _e830 = projected[2u];
+                    let _e831 = tapBias_1;
+                    let _e833 = occluder_2;
+                    let _e836 = lit_2;
+                    lit_2 = (_e836 + select(1f, 0f, ((_e830 - _e831) > _e833)));
                     continue;
                 } else {
                     break;
                 }
                 continuing {
-                    let _e815 = i_7;
-                    i_7 = (_e815 + 1i);
+                    let _e838 = i_7;
+                    i_7 = (_e838 + 1i);
                 }
             }
-            let _e817 = lit_2;
-            lit_2 = (_e817 * 0.0625f);
+            let _e840 = lit_2;
+            lit_2 = (_e840 * 0.0625f);
         }
     }
-    let _e819 = lit_2;
-    let _e820 = strength_1;
-    return mix(1f, _e819, clamp(_e820, 0f, 1f));
+    let _e842 = lit_2;
+    let _e843 = strength_1;
+    return mix(1f, _e842, clamp(_e843, 0f, 1f));
 }
 
 fn LightVisibility_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b_i1_u003b(s_6: ptr<function, Surface>, light_3: ptr<function, LightSample>, index: ptr<function, i32>) -> f32 {
@@ -20213,19 +20367,19 @@ fn LightVisibility_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d
     var param_144: LightSample;
     var param_145: i32;
 
-    let _e279 = (*s_6);
-    param_143 = _e279;
-    let _e280 = (*light_3);
-    param_144 = _e280;
-    let _e281 = (*index);
-    param_145 = _e281;
-    let _e282 = ShadowFactor_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b_i1_u003b((&param_143), (&param_144), (&param_145));
-    return _e282;
+    let _e280 = (*s_6);
+    param_143 = _e280;
+    let _e281 = (*light_3);
+    param_144 = _e281;
+    let _e282 = (*index);
+    param_145 = _e282;
+    let _e283 = ShadowFactor_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b_i1_u003b((&param_143), (&param_144), (&param_145));
+    return _e283;
 }
 
 fn LightHasShadow_u0028_i1_u003b(index_1: ptr<function, i32>) -> bool {
-    let _e274 = (*index_1);
-    return (_e274 < 8i);
+    let _e275 = (*index_1);
+    return (_e275 < 8i);
 }
 
 fn PunctualAttenuation_u0028_f1_u003b_f1_u003b(distance_1: ptr<function, f32>, range_4: ptr<function, f32>) -> f32 {
@@ -20233,26 +20387,26 @@ fn PunctualAttenuation_u0028_f1_u003b_f1_u003b(distance_1: ptr<function, f32>, r
     var ratio: f32;
     var window: f32;
 
-    let _e278 = (*distance_1);
     let _e279 = (*distance_1);
-    attenuation = (1f / max((_e278 * _e279), 0.0001f));
-    let _e283 = (*range_4);
-    if (_e283 > 0f) {
-        let _e285 = (*distance_1);
-        let _e286 = (*range_4);
-        ratio = (_e285 / _e286);
-        let _e288 = ratio;
+    let _e280 = (*distance_1);
+    attenuation = (1f / max((_e279 * _e280), 0.0001f));
+    let _e284 = (*range_4);
+    if (_e284 > 0f) {
+        let _e286 = (*distance_1);
+        let _e287 = (*range_4);
+        ratio = (_e286 / _e287);
         let _e289 = ratio;
-        let _e291 = ratio;
-        let _e293 = ratio;
-        window = clamp((1f - (((_e288 * _e289) * _e291) * _e293)), 0f, 1f);
-        let _e297 = window;
+        let _e290 = ratio;
+        let _e292 = ratio;
+        let _e294 = ratio;
+        window = clamp((1f - (((_e289 * _e290) * _e292) * _e294)), 0f, 1f);
         let _e298 = window;
-        let _e300 = attenuation;
-        attenuation = (_e300 * (_e297 * _e298));
+        let _e299 = window;
+        let _e301 = attenuation;
+        attenuation = (_e301 * (_e298 * _e299));
     }
-    let _e302 = attenuation;
-    return _e302;
+    let _e303 = attenuation;
+    return _e303;
 }
 
 fn RectangleClosestPoint_u0028_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b(centre: ptr<function, vec3<f32>>, halfWidth: ptr<function, vec3<f32>>, halfHeight: ptr<function, vec3<f32>>, world_2: ptr<function, vec3<f32>>, mirror: ptr<function, vec3<f32>>) -> vec3<f32> {
@@ -20269,75 +20423,75 @@ fn RectangleClosestPoint_u0028_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b
     var u: f32;
     var v_1: f32;
 
-    let _e290 = (*halfWidth);
-    let _e291 = (*halfHeight);
-    n_3 = cross(_e290, _e291);
-    let _e293 = n_3;
-    nLen = length(_e293);
-    let _e295 = nLen;
-    if (_e295 < 0.000000000001f) {
-        let _e297 = (*centre);
-        return _e297;
-    }
-    let _e298 = nLen;
-    let _e299 = n_3;
-    n_3 = (_e299 / vec3(_e298));
-    let _e302 = (*centre);
-    let _e303 = (*world_2);
-    toPlane = (_e302 - _e303);
-    let _e305 = (*mirror);
-    let _e306 = n_3;
-    denom = dot(_e305, _e306);
-    let _e308 = denom;
-    if (abs(_e308) < 0.00001f) {
-        let _e311 = toPlane;
-        let _e312 = n_3;
-        let _e313 = toPlane;
-        let _e314 = n_3;
-        onPlane = (_e311 - (_e312 * dot(_e313, _e314)));
-    } else {
-        let _e318 = toPlane;
-        let _e319 = n_3;
-        let _e321 = denom;
-        t_1 = (dot(_e318, _e319) / _e321);
-        let _e323 = t_1;
-        if (_e323 > 0f) {
-            let _e325 = (*mirror);
-            let _e326 = t_1;
-            local_16 = (_e325 * _e326);
+    let _e291 = (*halfWidth);
+    let _e292 = (*halfHeight);
+    n_3 = cross(_e291, _e292);
+    let _e294 = n_3;
+    nLen = length(_e294);
+    let _e296 = nLen;
+    if (_e296 < 0.000000000001f) {
+        let _e298 = (*centre);
+        return _e298;
+    }
+    let _e299 = nLen;
+    let _e300 = n_3;
+    n_3 = (_e300 / vec3(_e299));
+    let _e303 = (*centre);
+    let _e304 = (*world_2);
+    toPlane = (_e303 - _e304);
+    let _e306 = (*mirror);
+    let _e307 = n_3;
+    denom = dot(_e306, _e307);
+    let _e309 = denom;
+    if (abs(_e309) < 0.00001f) {
+        let _e312 = toPlane;
+        let _e313 = n_3;
+        let _e314 = toPlane;
+        let _e315 = n_3;
+        onPlane = (_e312 - (_e313 * dot(_e314, _e315)));
+    } else {
+        let _e319 = toPlane;
+        let _e320 = n_3;
+        let _e322 = denom;
+        t_1 = (dot(_e319, _e320) / _e322);
+        let _e324 = t_1;
+        if (_e324 > 0f) {
+            let _e326 = (*mirror);
+            let _e327 = t_1;
+            local_16 = (_e326 * _e327);
         } else {
-            let _e328 = toPlane;
-            let _e329 = n_3;
-            let _e330 = toPlane;
-            let _e331 = n_3;
-            local_16 = (_e328 - (_e329 * dot(_e330, _e331)));
-        }
-        let _e335 = local_16;
-        onPlane = _e335;
-    }
-    let _e336 = onPlane;
-    let _e337 = toPlane;
-    offset_2 = (_e336 - _e337);
-    let _e339 = (*halfWidth);
+            let _e329 = toPlane;
+            let _e330 = n_3;
+            let _e331 = toPlane;
+            let _e332 = n_3;
+            local_16 = (_e329 - (_e330 * dot(_e331, _e332)));
+        }
+        let _e336 = local_16;
+        onPlane = _e336;
+    }
+    let _e337 = onPlane;
+    let _e338 = toPlane;
+    offset_2 = (_e337 - _e338);
     let _e340 = (*halfWidth);
-    wLen2_ = max(dot(_e339, _e340), 0.000000000001f);
-    let _e343 = (*halfHeight);
+    let _e341 = (*halfWidth);
+    wLen2_ = max(dot(_e340, _e341), 0.000000000001f);
     let _e344 = (*halfHeight);
-    hLen2_ = max(dot(_e343, _e344), 0.000000000001f);
-    let _e347 = offset_2;
-    let _e348 = (*halfWidth);
-    let _e350 = wLen2_;
-    u = clamp((dot(_e347, _e348) / _e350), -1f, 1f);
-    let _e353 = offset_2;
-    let _e354 = (*halfHeight);
-    let _e356 = hLen2_;
-    v_1 = clamp((dot(_e353, _e354) / _e356), -1f, 1f);
-    let _e359 = (*centre);
-    let _e360 = (*halfWidth);
-    let _e361 = u;
-    let _e364 = (*halfHeight);
-    let _e365 = v_1;
-    return ((_e359 + (_e360 * _e361)) + (_e364 * _e365));
+    let _e345 = (*halfHeight);
+    hLen2_ = max(dot(_e344, _e345), 0.000000000001f);
+    let _e348 = offset_2;
+    let _e349 = (*halfWidth);
+    let _e351 = wLen2_;
+    u = clamp((dot(_e348, _e349) / _e351), -1f, 1f);
+    let _e354 = offset_2;
+    let _e355 = (*halfHeight);
+    let _e357 = hLen2_;
+    v_1 = clamp((dot(_e354, _e355) / _e357), -1f, 1f);
+    let _e360 = (*centre);
+    let _e361 = (*halfWidth);
+    let _e362 = u;
+    let _e365 = (*halfHeight);
+    let _e366 = v_1;
+    return ((_e360 + (_e361 * _e362)) + (_e365 * _e366));
 }
 
 fn LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b(a_3: ptr<function, vec3<f32>>, b_1: ptr<function, vec3<f32>>, n_4: ptr<function, vec3<f32>>) -> f32 {
@@ -20348,32 +20502,32 @@ fn LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b(a_3: ptr<function, vec3<f32>>
     var len_2: f32;
     var local_17: f32;
 
-    let _e282 = (*a_3);
     let _e283 = (*a_3);
-    ua = (_e282 / vec3(max(length(_e283), 0.000000000001f)));
-    let _e288 = (*b_1);
+    let _e284 = (*a_3);
+    ua = (_e283 / vec3(max(length(_e284), 0.000000000001f)));
     let _e289 = (*b_1);
-    ub = (_e288 / vec3(max(length(_e289), 0.000000000001f)));
-    let _e294 = ua;
-    let _e295 = ub;
-    angle_2 = acos(clamp(dot(_e294, _e295), -1f, 1f));
-    let _e299 = ua;
-    let _e300 = ub;
-    axis_1 = cross(_e299, _e300);
-    let _e302 = axis_1;
-    len_2 = length(_e302);
-    let _e304 = len_2;
-    if (_e304 > 0.000001f) {
-        let _e306 = angle_2;
-        let _e307 = axis_1;
-        let _e308 = (*n_4);
-        let _e311 = len_2;
-        local_17 = ((_e306 * dot(_e307, _e308)) / _e311);
+    let _e290 = (*b_1);
+    ub = (_e289 / vec3(max(length(_e290), 0.000000000001f)));
+    let _e295 = ua;
+    let _e296 = ub;
+    angle_2 = acos(clamp(dot(_e295, _e296), -1f, 1f));
+    let _e300 = ua;
+    let _e301 = ub;
+    axis_1 = cross(_e300, _e301);
+    let _e303 = axis_1;
+    len_2 = length(_e303);
+    let _e305 = len_2;
+    if (_e305 > 0.000001f) {
+        let _e307 = angle_2;
+        let _e308 = axis_1;
+        let _e309 = (*n_4);
+        let _e312 = len_2;
+        local_17 = ((_e307 * dot(_e308, _e309)) / _e312);
     } else {
         local_17 = 0f;
     }
-    let _e313 = local_17;
-    return _e313;
+    let _e314 = local_17;
+    return _e314;
 }
 
 fn RectangleFormFactor_u0028_vf3_u005b_4_u005d_u003b_vf3_u003b(corners_1: ptr<function, array<vec3<f32>, 4>>, n_5: ptr<function, vec3<f32>>) -> f32 {
@@ -20404,98 +20558,98 @@ fn RectangleFormFactor_u0028_vf3_u005b_4_u005d_u003b_vf3_u003b(corners_1: ptr<fu
     entry = vec3<f32>(0f, 0f, 0f);
     i_8 = 0i;
     loop {
-        let _e296 = i_8;
-        if (_e296 < 4i) {
-            let _e298 = i_8;
-            let _e300 = (*corners_1)[_e298];
-            a_4 = _e300;
-            let _e301 = i_8;
-            if (_e301 == 3i) {
+        let _e297 = i_8;
+        if (_e297 < 4i) {
+            let _e299 = i_8;
+            let _e301 = (*corners_1)[_e299];
+            a_4 = _e301;
+            let _e302 = i_8;
+            if (_e302 == 3i) {
                 local_18 = 0i;
             } else {
-                let _e303 = i_8;
-                local_18 = (_e303 + 1i);
-            }
-            let _e305 = local_18;
-            let _e307 = (*corners_1)[_e305];
-            b_2 = _e307;
-            let _e308 = a_4;
-            let _e309 = (*n_5);
-            ha = dot(_e308, _e309);
-            let _e311 = b_2;
-            let _e312 = (*n_5);
-            hb = dot(_e311, _e312);
-            let _e314 = ha;
-            let _e315 = hb;
-            d_5 = (_e314 - _e315);
-            let _e317 = a_4;
-            let _e318 = b_2;
-            let _e319 = a_4;
-            let _e321 = d_5;
-            if (abs(_e321) > 0.000000000001f) {
-                let _e324 = ha;
-                let _e325 = d_5;
-                local_19 = (_e324 / _e325);
+                let _e304 = i_8;
+                local_18 = (_e304 + 1i);
+            }
+            let _e306 = local_18;
+            let _e308 = (*corners_1)[_e306];
+            b_2 = _e308;
+            let _e309 = a_4;
+            let _e310 = (*n_5);
+            ha = dot(_e309, _e310);
+            let _e312 = b_2;
+            let _e313 = (*n_5);
+            hb = dot(_e312, _e313);
+            let _e315 = ha;
+            let _e316 = hb;
+            d_5 = (_e315 - _e316);
+            let _e318 = a_4;
+            let _e319 = b_2;
+            let _e320 = a_4;
+            let _e322 = d_5;
+            if (abs(_e322) > 0.000000000001f) {
+                let _e325 = ha;
+                let _e326 = d_5;
+                local_19 = (_e325 / _e326);
             } else {
                 local_19 = 0f;
             }
-            let _e327 = local_19;
-            q = (_e317 + ((_e318 - _e319) * _e327));
-            let _e330 = ha;
-            aAbove = (_e330 > 0f);
-            let _e332 = hb;
-            bAbove = (_e332 > 0f);
-            let _e334 = aAbove;
-            let _e335 = bAbove;
-            if (_e334 || _e335) {
-                let _e337 = aAbove;
-                let _e338 = a_4;
-                let _e339 = q;
-                let _e342 = bAbove;
-                let _e343 = b_2;
-                let _e344 = q;
-                param_146 = select(_e339, _e338, vec3(_e337));
-                param_147 = select(_e344, _e343, vec3(_e342));
-                let _e347 = (*n_5);
-                param_148 = _e347;
-                let _e348 = LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b((&param_146), (&param_147), (&param_148));
-                local_20 = _e348;
+            let _e328 = local_19;
+            q = (_e318 + ((_e319 - _e320) * _e328));
+            let _e331 = ha;
+            aAbove = (_e331 > 0f);
+            let _e333 = hb;
+            bAbove = (_e333 > 0f);
+            let _e335 = aAbove;
+            let _e336 = bAbove;
+            if (_e335 || _e336) {
+                let _e338 = aAbove;
+                let _e339 = a_4;
+                let _e340 = q;
+                let _e343 = bAbove;
+                let _e344 = b_2;
+                let _e345 = q;
+                param_146 = select(_e340, _e339, vec3(_e338));
+                param_147 = select(_e345, _e344, vec3(_e343));
+                let _e348 = (*n_5);
+                param_148 = _e348;
+                let _e349 = LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b((&param_146), (&param_147), (&param_148));
+                local_20 = _e349;
             } else {
                 local_20 = 0f;
             }
-            let _e349 = local_20;
-            let _e350 = total;
-            total = (_e350 + _e349);
-            let _e352 = aAbove;
-            let _e353 = bAbove;
-            let _e356 = q;
-            let _e357 = exit;
-            exit = select(_e357, _e356, vec3((_e352 && !(_e353))));
-            let _e360 = aAbove;
-            let _e362 = bAbove;
-            let _e364 = q;
-            let _e365 = entry;
-            entry = select(_e365, _e364, vec3((!(_e360) && _e362)));
+            let _e350 = local_20;
+            let _e351 = total;
+            total = (_e351 + _e350);
+            let _e353 = aAbove;
+            let _e354 = bAbove;
+            let _e357 = q;
+            let _e358 = exit;
+            exit = select(_e358, _e357, vec3((_e353 && !(_e354))));
+            let _e361 = aAbove;
+            let _e363 = bAbove;
+            let _e365 = q;
+            let _e366 = entry;
+            entry = select(_e366, _e365, vec3((!(_e361) && _e363)));
             continue;
         } else {
             break;
         }
         continuing {
-            let _e368 = i_8;
-            i_8 = (_e368 + 1i);
+            let _e369 = i_8;
+            i_8 = (_e369 + 1i);
         }
     }
-    let _e370 = exit;
-    param_149 = _e370;
-    let _e371 = entry;
-    param_150 = _e371;
-    let _e372 = (*n_5);
-    param_151 = _e372;
-    let _e373 = LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b((&param_149), (&param_150), (&param_151));
-    let _e374 = total;
-    total = (_e374 + _e373);
-    let _e376 = total;
-    return max((-(_e376) * 0.5f), 0f);
+    let _e371 = exit;
+    param_149 = _e371;
+    let _e372 = entry;
+    param_150 = _e372;
+    let _e373 = (*n_5);
+    param_151 = _e373;
+    let _e374 = LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b((&param_149), (&param_150), (&param_151));
+    let _e375 = total;
+    total = (_e375 + _e374);
+    let _e377 = total;
+    return max((-(_e377) * 0.5f), 0f);
 }
 
 fn LightListLane_u0028_vf4_u003b_i1_u003b(four: ptr<function, vec4<f32>>, slot_2: ptr<function, i32>) -> f32 {
@@ -20504,91 +20658,91 @@ fn LightListLane_u0028_vf4_u003b_i1_u003b(four: ptr<function, vec4<f32>>, slot_2
     var local_22: f32;
     var local_23: f32;
 
-    let _e279 = (*slot_2);
     let _e280 = (*slot_2);
-    lane = (_e279 - ((_e280 / 4i) * 4i));
-    let _e284 = lane;
-    if (_e284 == 0i) {
-        let _e287 = (*four)[0u];
-        local_21 = _e287;
-    } else {
-        let _e288 = lane;
-        if (_e288 == 1i) {
-            let _e291 = (*four)[1u];
-            local_22 = _e291;
+    let _e281 = (*slot_2);
+    lane = (_e280 - ((_e281 / 4i) * 4i));
+    let _e285 = lane;
+    if (_e285 == 0i) {
+        let _e288 = (*four)[0u];
+        local_21 = _e288;
+    } else {
+        let _e289 = lane;
+        if (_e289 == 1i) {
+            let _e292 = (*four)[1u];
+            local_22 = _e292;
         } else {
-            let _e292 = lane;
-            if (_e292 == 2i) {
-                let _e295 = (*four)[2u];
-                local_23 = _e295;
+            let _e293 = lane;
+            if (_e293 == 2i) {
+                let _e296 = (*four)[2u];
+                local_23 = _e296;
             } else {
-                let _e297 = (*four)[3u];
-                local_23 = _e297;
+                let _e298 = (*four)[3u];
+                local_23 = _e298;
             }
-            let _e298 = local_23;
-            local_22 = _e298;
+            let _e299 = local_23;
+            local_22 = _e299;
         }
-        let _e299 = local_22;
-        local_21 = _e299;
+        let _e300 = local_22;
+        local_21 = _e300;
     }
-    let _e300 = local_21;
-    return _e300;
+    let _e301 = local_21;
+    return _e301;
 }
 
 fn LightListScale_u0028_i1_u003b(slot_3: ptr<function, i32>) -> f32 {
     var param_152: vec4<f32>;
     var param_153: i32;
 
-    let _e276 = (*slot_3);
-    let _e280 = light_list_info.scales[(_e276 / 4i)];
-    param_152 = _e280;
-    let _e281 = (*slot_3);
-    param_153 = _e281;
-    let _e282 = LightListLane_u0028_vf4_u003b_i1_u003b((&param_152), (&param_153));
-    return _e282;
+    let _e277 = (*slot_3);
+    let _e281 = light_list_info.scales[(_e277 / 4i)];
+    param_152 = _e281;
+    let _e282 = (*slot_3);
+    param_153 = _e282;
+    let _e283 = LightListLane_u0028_vf4_u003b_i1_u003b((&param_152), (&param_153));
+    return _e283;
 }
 
 fn InSlots_u0028_f1_u003b(row: ptr<function, f32>) -> bool {
     var a_5: vec4<f32>;
     var b_3: vec4<f32>;
 
-    let _e278 = light_list_info.slot_rows[0i];
-    let _e279 = (*row);
-    a_5 = abs((_e278 - vec4(_e279)));
-    let _e285 = light_list_info.slot_rows[1i];
-    let _e286 = (*row);
-    b_3 = abs((_e285 - vec4(_e286)));
-    let _e291 = a_5[0u];
-    let _e293 = a_5[1u];
-    let _e296 = a_5[2u];
-    let _e298 = a_5[3u];
-    let _e302 = b_3[0u];
-    let _e304 = b_3[1u];
-    let _e307 = b_3[2u];
-    let _e309 = b_3[3u];
-    return (min(min(min(_e291, _e293), min(_e296, _e298)), min(min(_e302, _e304), min(_e307, _e309))) < 0.5f);
+    let _e279 = light_list_info.slot_rows[0i];
+    let _e280 = (*row);
+    a_5 = abs((_e279 - vec4(_e280)));
+    let _e286 = light_list_info.slot_rows[1i];
+    let _e287 = (*row);
+    b_3 = abs((_e286 - vec4(_e287)));
+    let _e292 = a_5[0u];
+    let _e294 = a_5[1u];
+    let _e297 = a_5[2u];
+    let _e299 = a_5[3u];
+    let _e303 = b_3[0u];
+    let _e305 = b_3[1u];
+    let _e308 = b_3[2u];
+    let _e310 = b_3[3u];
+    return (min(min(min(_e292, _e294), min(_e297, _e299)), min(min(_e303, _e305), min(_e308, _e310))) < 0.5f);
 }
 
 fn LightListRow_u0028_i1_u003b(slot_4: ptr<function, i32>) -> f32 {
     var param_154: vec4<f32>;
     var param_155: i32;
 
-    let _e276 = (*slot_4);
-    let _e280 = light_list_info.indices[(_e276 / 4i)];
-    param_154 = _e280;
-    let _e281 = (*slot_4);
-    param_155 = _e281;
-    let _e282 = LightListLane_u0028_vf4_u003b_i1_u003b((&param_154), (&param_155));
-    return _e282;
+    let _e277 = (*slot_4);
+    let _e281 = light_list_info.indices[(_e277 / 4i)];
+    param_154 = _e281;
+    let _e282 = (*slot_4);
+    param_155 = _e282;
+    let _e283 = LightListLane_u0028_vf4_u003b_i1_u003b((&param_154), (&param_155));
+    return _e283;
 }
 
 fn LightListTexel_u0028_f1_u003b_f1_u003b(texel_2: ptr<function, f32>, row_1: ptr<function, f32>) -> vec4<f32> {
-    let _e275 = (*texel_2);
-    let _e279 = light_list_info.list[1u];
-    let _e281 = (*row_1);
-    let _e285 = light_list_info.list[2u];
-    let _e288 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>(((_e275 + 0.5f) * _e279), ((_e281 + 0.5f) * _e285)), 0f);
-    return _e288;
+    let _e276 = (*texel_2);
+    let _e280 = light_list_info.list[1u];
+    let _e282 = (*row_1);
+    let _e286 = light_list_info.list[2u];
+    let _e289 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>(((_e276 + 0.5f) * _e280), ((_e282 + 0.5f) * _e286)), 0f);
+    return _e289;
 }
 
 fn ClusterRow_u0028_i1_u003b(slot_5: ptr<function, i32>) -> f32 {
@@ -20602,35 +20756,35 @@ fn ClusterRow_u0028_i1_u003b(slot_5: ptr<function, i32>) -> f32 {
     var param_158: vec4<f32>;
     var param_159: i32;
 
-    let _e283 = g_cluster_offset;
-    let _e284 = (*slot_5);
-    entry_1 = (_e283 + f32(_e284));
-    let _e287 = entry_1;
-    row_2 = floor((_e287 / 16f));
-    let _e290 = entry_1;
-    let _e291 = row_2;
-    within = (_e290 - (_e291 * 16f));
-    let _e294 = within;
-    texel_3 = floor((_e294 / 4f));
-    let _e299 = light_list_info.cluster_depth[3u];
-    let _e300 = row_2;
-    let _e302 = texel_3;
-    param_156 = _e302;
-    param_157 = (_e299 + _e300);
-    let _e303 = LightListTexel_u0028_f1_u003b_f1_u003b((&param_156), (&param_157));
-    four_1 = _e303;
-    let _e304 = within;
-    let _e305 = texel_3;
-    let _e310 = four_1;
-    param_158 = _e310;
-    param_159 = i32(((_e304 - (_e305 * 4f)) + 0.5f));
-    let _e311 = LightListLane_u0028_vf4_u003b_i1_u003b((&param_158), (&param_159));
-    return _e311;
+    let _e284 = g_cluster_offset;
+    let _e285 = (*slot_5);
+    entry_1 = (_e284 + f32(_e285));
+    let _e288 = entry_1;
+    row_2 = floor((_e288 / 16f));
+    let _e291 = entry_1;
+    let _e292 = row_2;
+    within = (_e291 - (_e292 * 16f));
+    let _e295 = within;
+    texel_3 = floor((_e295 / 4f));
+    let _e300 = light_list_info.cluster_depth[3u];
+    let _e301 = row_2;
+    let _e303 = texel_3;
+    param_156 = _e303;
+    param_157 = (_e300 + _e301);
+    let _e304 = LightListTexel_u0028_f1_u003b_f1_u003b((&param_156), (&param_157));
+    four_1 = _e304;
+    let _e305 = within;
+    let _e306 = texel_3;
+    let _e311 = four_1;
+    param_158 = _e311;
+    param_159 = i32(((_e305 - (_e306 * 4f)) + 0.5f));
+    let _e312 = LightListLane_u0028_vf4_u003b_i1_u003b((&param_158), (&param_159));
+    return _e312;
 }
 
 fn Clustered_u0028_() -> bool {
-    let _e275 = light_list_info.cluster_grid[3u];
-    return (_e275 > 0.5f);
+    let _e276 = light_list_info.cluster_grid[3u];
+    return (_e276 > 0.5f);
 }
 
 fn SampleLight_u0028_i1_u003b_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(index_2: ptr<function, i32>, s_7: ptr<function, Surface>) -> LightSample {
@@ -20690,277 +20844,277 @@ fn SampleLight_u0028_i1_u003b_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_
 
     light_4.integrated = 0f;
     light_4.ltc = vec3<f32>(0f, 0f, 0f);
-    let _e330 = (*index_2);
-    if (_e330 < 8i) {
-        let _e332 = (*index_2);
-        let _e335 = frag_info.light_position[_e332];
-        position = _e335;
-        let _e336 = (*index_2);
-        let _e339 = frag_info.light_color[_e336];
-        color_1 = _e339;
-        let _e340 = (*index_2);
-        let _e343 = frag_info.light_direction[_e340];
-        direction = _e343;
-        let _e344 = (*index_2);
-        let _e347 = frag_info.light_cone[_e344];
-        cone = _e347;
-    } else {
-        let _e348 = (*index_2);
-        slot_6 = (_e348 - 8i);
-        let _e350 = Clustered_u0028_();
-        clustered = _e350;
-        let _e351 = clustered;
-        if _e351 {
-            let _e352 = slot_6;
-            param_160 = _e352;
-            let _e353 = ClusterRow_u0028_i1_u003b((&param_160));
-            local_24 = _e353;
+    let _e331 = (*index_2);
+    if (_e331 < 8i) {
+        let _e333 = (*index_2);
+        let _e336 = frag_info.light_position[_e333];
+        position = _e336;
+        let _e337 = (*index_2);
+        let _e340 = frag_info.light_color[_e337];
+        color_1 = _e340;
+        let _e341 = (*index_2);
+        let _e344 = frag_info.light_direction[_e341];
+        direction = _e344;
+        let _e345 = (*index_2);
+        let _e348 = frag_info.light_cone[_e345];
+        cone = _e348;
+    } else {
+        let _e349 = (*index_2);
+        slot_6 = (_e349 - 8i);
+        let _e351 = Clustered_u0028_();
+        clustered = _e351;
+        let _e352 = clustered;
+        if _e352 {
+            let _e353 = slot_6;
+            param_160 = _e353;
+            let _e354 = ClusterRow_u0028_i1_u003b((&param_160));
+            local_24 = _e354;
         } else {
-            let _e354 = slot_6;
-            param_161 = _e354;
-            let _e355 = LightListRow_u0028_i1_u003b((&param_161));
-            local_24 = _e355;
-        }
-        let _e356 = local_24;
-        listRow = _e356;
-        let _e357 = listRow;
-        let _e361 = light_list_info.list[2u];
-        v_2 = ((_e357 + 0.5f) * _e361);
-        let _e365 = light_list_info.list[1u];
-        u_1 = _e365;
-        let _e366 = u_1;
-        let _e368 = v_2;
-        let _e370 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((0.5f * _e366), _e368), 0f);
-        position = _e370;
-        let _e371 = u_1;
-        let _e373 = v_2;
-        let _e375 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((1.5f * _e371), _e373), 0f);
-        color_1 = _e375;
-        let _e376 = u_1;
-        let _e378 = v_2;
-        let _e380 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((2.5f * _e376), _e378), 0f);
-        direction = _e380;
-        let _e381 = u_1;
-        let _e383 = v_2;
-        let _e385 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((3.5f * _e381), _e383), 0f);
-        cone = _e385;
-        let _e386 = clustered;
-        if _e386 {
-            let _e387 = listRow;
-            param_162 = _e387;
-            let _e388 = InSlots_u0028_f1_u003b((&param_162));
-            local_25 = select(1f, 0f, _e388);
+            let _e355 = slot_6;
+            param_161 = _e355;
+            let _e356 = LightListRow_u0028_i1_u003b((&param_161));
+            local_24 = _e356;
+        }
+        let _e357 = local_24;
+        listRow = _e357;
+        let _e358 = listRow;
+        let _e362 = light_list_info.list[2u];
+        v_2 = ((_e358 + 0.5f) * _e362);
+        let _e366 = light_list_info.list[1u];
+        u_1 = _e366;
+        let _e367 = u_1;
+        let _e369 = v_2;
+        let _e371 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((0.5f * _e367), _e369), 0f);
+        position = _e371;
+        let _e372 = u_1;
+        let _e374 = v_2;
+        let _e376 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((1.5f * _e372), _e374), 0f);
+        color_1 = _e376;
+        let _e377 = u_1;
+        let _e379 = v_2;
+        let _e381 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((2.5f * _e377), _e379), 0f);
+        direction = _e381;
+        let _e382 = u_1;
+        let _e384 = v_2;
+        let _e386 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((3.5f * _e382), _e384), 0f);
+        cone = _e386;
+        let _e387 = clustered;
+        if _e387 {
+            let _e388 = listRow;
+            param_162 = _e388;
+            let _e389 = InSlots_u0028_f1_u003b((&param_162));
+            local_25 = select(1f, 0f, _e389);
         } else {
-            let _e390 = slot_6;
-            param_163 = _e390;
-            let _e391 = LightListScale_u0028_i1_u003b((&param_163));
-            local_25 = _e391;
-        }
-        let _e392 = local_25;
-        let _e394 = color_1[3u];
-        color_1[3u] = (_e394 * _e392);
-    }
-    let _e398 = position[3u];
-    type_45 = _e398;
-    let _e399 = type_45;
-    if (_e399 > 2.5f) {
-        let _e401 = direction;
-        halfWidth_1 = _e401.xyz;
-        let _e403 = cone;
-        halfHeight_1 = _e403.xyz;
-        let _e405 = position;
-        let _e407 = v_world_position_1;
-        toCentre = (_e405.xyz - _e407);
-        let _e409 = toCentre;
-        let _e410 = halfWidth_1;
-        let _e412 = halfHeight_1;
-        corners_2[0i] = ((_e409 - _e410) - _e412);
-        let _e415 = toCentre;
-        let _e416 = halfWidth_1;
-        let _e418 = halfHeight_1;
-        corners_2[1i] = ((_e415 + _e416) - _e418);
-        let _e421 = toCentre;
-        let _e422 = halfWidth_1;
-        let _e424 = halfHeight_1;
-        corners_2[2i] = ((_e421 + _e422) + _e424);
-        let _e427 = toCentre;
-        let _e428 = halfWidth_1;
-        let _e430 = halfHeight_1;
-        corners_2[3i] = ((_e427 - _e428) + _e430);
-        let _e433 = toCentre;
-        let _e434 = halfWidth_1;
-        let _e435 = halfHeight_1;
-        behind = (dot(_e433, cross(_e434, _e435)) >= 0f);
-        let _e439 = behind;
-        if _e439 {
+            let _e391 = slot_6;
+            param_163 = _e391;
+            let _e392 = LightListScale_u0028_i1_u003b((&param_163));
+            local_25 = _e392;
+        }
+        let _e393 = local_25;
+        let _e395 = color_1[3u];
+        color_1[3u] = (_e395 * _e393);
+    }
+    let _e399 = position[3u];
+    type_45 = _e399;
+    let _e400 = type_45;
+    if (_e400 > 2.5f) {
+        let _e402 = direction;
+        halfWidth_1 = _e402.xyz;
+        let _e404 = cone;
+        halfHeight_1 = _e404.xyz;
+        let _e406 = position;
+        let _e408 = v_world_position_1;
+        toCentre = (_e406.xyz - _e408);
+        let _e410 = toCentre;
+        let _e411 = halfWidth_1;
+        let _e413 = halfHeight_1;
+        corners_2[0i] = ((_e410 - _e411) - _e413);
+        let _e416 = toCentre;
+        let _e417 = halfWidth_1;
+        let _e419 = halfHeight_1;
+        corners_2[1i] = ((_e416 + _e417) - _e419);
+        let _e422 = toCentre;
+        let _e423 = halfWidth_1;
+        let _e425 = halfHeight_1;
+        corners_2[2i] = ((_e422 + _e423) + _e425);
+        let _e428 = toCentre;
+        let _e429 = halfWidth_1;
+        let _e431 = halfHeight_1;
+        corners_2[3i] = ((_e428 - _e429) + _e431);
+        let _e434 = toCentre;
+        let _e435 = halfWidth_1;
+        let _e436 = halfHeight_1;
+        behind = (dot(_e434, cross(_e435, _e436)) >= 0f);
+        let _e440 = behind;
+        if _e440 {
             local_26 = 0f;
         } else {
-            let _e440 = corners_2;
-            param_164 = _e440;
-            let _e442 = (*s_7).n;
-            param_165 = _e442;
-            let _e443 = RectangleFormFactor_u0028_vf3_u005b_4_u005d_u003b_vf3_u003b((&param_164), (&param_165));
-            local_26 = _e443;
-        }
-        let _e444 = local_26;
-        formFactor = _e444;
-        let _e445 = halfWidth_1;
-        let _e446 = halfHeight_1;
-        area = (length(cross(_e445, _e446)) * 4f);
-        let _e450 = area;
-        if (_e450 > 0.000000001f) {
-            let _e452 = area;
-            local_27 = (1f / _e452);
+            let _e441 = corners_2;
+            param_164 = _e441;
+            let _e443 = (*s_7).n;
+            param_165 = _e443;
+            let _e444 = RectangleFormFactor_u0028_vf3_u005b_4_u005d_u003b_vf3_u003b((&param_164), (&param_165));
+            local_26 = _e444;
+        }
+        let _e445 = local_26;
+        formFactor = _e445;
+        let _e446 = halfWidth_1;
+        let _e447 = halfHeight_1;
+        area = (length(cross(_e446, _e447)) * 4f);
+        let _e451 = area;
+        if (_e451 > 0.000000001f) {
+            let _e453 = area;
+            local_27 = (1f / _e453);
         } else {
             local_27 = 0f;
         }
-        let _e454 = local_27;
-        radiance = _e454;
-        let _e455 = toCentre;
-        distance_2 = length(_e455);
-        let _e458 = direction[3u];
-        if (_e458 > 0f) {
-            let _e460 = distance_2;
-            let _e462 = direction[3u];
-            ratio_1 = (_e460 / _e462);
-            let _e464 = ratio_1;
+        let _e455 = local_27;
+        radiance = _e455;
+        let _e456 = toCentre;
+        distance_2 = length(_e456);
+        let _e459 = direction[3u];
+        if (_e459 > 0f) {
+            let _e461 = distance_2;
+            let _e463 = direction[3u];
+            ratio_1 = (_e461 / _e463);
             let _e465 = ratio_1;
-            let _e467 = ratio_1;
-            let _e469 = ratio_1;
-            window_1 = clamp((1f - (((_e464 * _e465) * _e467) * _e469)), 0f, 1f);
-            let _e473 = window_1;
+            let _e466 = ratio_1;
+            let _e468 = ratio_1;
+            let _e470 = ratio_1;
+            window_1 = clamp((1f - (((_e465 * _e466) * _e468) * _e470)), 0f, 1f);
             let _e474 = window_1;
-            let _e476 = radiance;
-            radiance = (_e476 * (_e473 * _e474));
-        }
-        let _e479 = (*s_7).v;
-        let _e482 = (*s_7).n;
-        mirror_1 = reflect(-(_e479), _e482);
-        let _e484 = position;
-        param_166 = _e484.xyz;
-        let _e486 = halfWidth_1;
-        param_167 = _e486;
-        let _e487 = halfHeight_1;
-        param_168 = _e487;
-        let _e488 = v_world_position_1;
-        param_169 = _e488;
-        let _e489 = mirror_1;
-        param_170 = _e489;
-        let _e490 = RectangleClosestPoint_u0028_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b((&param_166), (&param_167), (&param_168), (&param_169), (&param_170));
-        representative = _e490;
-        let _e491 = representative;
-        let _e492 = v_world_position_1;
-        toPoint = (_e491 - _e492);
-        let _e494 = toPoint;
-        pointDistance = length(_e494);
-        let _e496 = pointDistance;
-        if (_e496 > 0.000001f) {
-            let _e498 = toPoint;
-            let _e499 = pointDistance;
-            local_28 = (_e498 / vec3(_e499));
+            let _e475 = window_1;
+            let _e477 = radiance;
+            radiance = (_e477 * (_e474 * _e475));
+        }
+        let _e480 = (*s_7).v;
+        let _e483 = (*s_7).n;
+        mirror_1 = reflect(-(_e480), _e483);
+        let _e485 = position;
+        param_166 = _e485.xyz;
+        let _e487 = halfWidth_1;
+        param_167 = _e487;
+        let _e488 = halfHeight_1;
+        param_168 = _e488;
+        let _e489 = v_world_position_1;
+        param_169 = _e489;
+        let _e490 = mirror_1;
+        param_170 = _e490;
+        let _e491 = RectangleClosestPoint_u0028_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b((&param_166), (&param_167), (&param_168), (&param_169), (&param_170));
+        representative = _e491;
+        let _e492 = representative;
+        let _e493 = v_world_position_1;
+        toPoint = (_e492 - _e493);
+        let _e495 = toPoint;
+        pointDistance = length(_e495);
+        let _e497 = pointDistance;
+        if (_e497 > 0.000001f) {
+            let _e499 = toPoint;
+            let _e500 = pointDistance;
+            local_28 = (_e499 / vec3(_e500));
         } else {
-            let _e503 = (*s_7).n;
-            local_28 = _e503;
-        }
-        let _e504 = local_28;
-        light_4.l = _e504;
-        let _e507 = light_4.l;
-        let _e509 = (*s_7).v;
-        light_4.h = normalize((_e507 + _e509));
-        let _e513 = formFactor;
-        light_4.n_dot_l = _e513;
-        let _e516 = (*s_7).n;
-        let _e518 = light_4.h;
-        light_4.n_dot_h = max(dot(_e516, _e518), 0f);
-        let _e523 = (*s_7).v;
-        let _e525 = light_4.h;
-        light_4.v_dot_h = max(dot(_e523, _e525), 0f);
-        let _e529 = color_1;
-        let _e532 = color_1[3u];
-        let _e534 = radiance;
-        light_4.radiance = ((_e529.xyz * _e532) * _e534);
+            let _e504 = (*s_7).n;
+            local_28 = _e504;
+        }
+        let _e505 = local_28;
+        light_4.l = _e505;
+        let _e508 = light_4.l;
+        let _e510 = (*s_7).v;
+        light_4.h = normalize((_e508 + _e510));
+        let _e514 = formFactor;
+        light_4.n_dot_l = _e514;
+        let _e517 = (*s_7).n;
+        let _e519 = light_4.h;
+        light_4.n_dot_h = max(dot(_e517, _e519), 0f);
+        let _e524 = (*s_7).v;
+        let _e526 = light_4.h;
+        light_4.v_dot_h = max(dot(_e524, _e526), 0f);
+        let _e530 = color_1;
+        let _e533 = color_1[3u];
+        let _e535 = radiance;
+        light_4.radiance = ((_e530.xyz * _e533) * _e535);
         light_4.integrated = 1f;
-        let _e539 = (*s_7).n;
-        param_171 = _e539;
-        let _e541 = (*s_7).v;
-        param_172 = _e541;
-        let _e543 = (*s_7).roughness;
-        param_173 = _e543;
-        let _e544 = corners_2;
-        param_174 = _e544;
-        let _e545 = LtcRectangle_u0028_vf3_u003b_vf3_u003b_f1_u003b_vf3_u005b_4_u005d_u003b((&param_171), (&param_172), (&param_173), (&param_174));
-        light_4.ltc = _e545;
-        let _e547 = corners_2;
-        g_rect_corners = _e547;
-        let _e548 = light_4;
-        return _e548;
-    }
-    let _e549 = direction;
-    aim = normalize(_e549.xyz);
+        let _e540 = (*s_7).n;
+        param_171 = _e540;
+        let _e542 = (*s_7).v;
+        param_172 = _e542;
+        let _e544 = (*s_7).roughness;
+        param_173 = _e544;
+        let _e545 = corners_2;
+        param_174 = _e545;
+        let _e546 = LtcRectangle_u0028_vf3_u003b_vf3_u003b_f1_u003b_vf3_u005b_4_u005d_u003b((&param_171), (&param_172), (&param_173), (&param_174));
+        light_4.ltc = _e546;
+        let _e548 = corners_2;
+        g_rect_corners = _e548;
+        let _e549 = light_4;
+        return _e549;
+    }
+    let _e550 = direction;
+    aim = normalize(_e550.xyz);
     attenuation_1 = 1f;
-    let _e552 = type_45;
-    if (_e552 < 0.5f) {
-        let _e554 = aim;
-        light_4.l = -(_e554);
-    } else {
-        let _e557 = position;
-        let _e559 = v_world_position_1;
-        toLight_1 = (_e557.xyz - _e559);
-        let _e561 = toLight_1;
-        distance_3 = length(_e561);
-        let _e563 = distance_3;
-        if (_e563 < 0.000001f) {
-            let _e566 = (*s_7).n;
-            light_4.l = _e566;
-            let _e569 = (*s_7).n;
-            light_4.h = _e569;
+    let _e553 = type_45;
+    if (_e553 < 0.5f) {
+        let _e555 = aim;
+        light_4.l = -(_e555);
+    } else {
+        let _e558 = position;
+        let _e560 = v_world_position_1;
+        toLight_1 = (_e558.xyz - _e560);
+        let _e562 = toLight_1;
+        distance_3 = length(_e562);
+        let _e564 = distance_3;
+        if (_e564 < 0.000001f) {
+            let _e567 = (*s_7).n;
+            light_4.l = _e567;
+            let _e570 = (*s_7).n;
+            light_4.h = _e570;
             light_4.radiance = vec3<f32>(0f, 0f, 0f);
             light_4.n_dot_l = 0f;
             light_4.n_dot_h = 0f;
             light_4.v_dot_h = 0f;
-            let _e575 = light_4;
-            return _e575;
-        }
-        let _e576 = toLight_1;
-        let _e577 = distance_3;
-        light_4.l = (_e576 / vec3(_e577));
-        let _e581 = distance_3;
-        param_175 = _e581;
-        let _e583 = direction[3u];
-        param_176 = _e583;
-        let _e584 = PunctualAttenuation_u0028_f1_u003b_f1_u003b((&param_175), (&param_176));
-        attenuation_1 = _e584;
-        let _e585 = type_45;
-        if (_e585 > 1.5f) {
-            let _e587 = aim;
-            let _e589 = light_4.l;
-            cosAngle = dot(_e587, -(_e589));
-            let _e592 = cosAngle;
-            let _e594 = cone[1u];
-            let _e597 = cone[0u];
-            let _e599 = cone[1u];
-            let _e603 = attenuation_1;
-            attenuation_1 = (_e603 * clamp(((_e592 - _e594) / (_e597 - _e599)), 0f, 1f));
-        }
-    }
-    let _e606 = light_4.l;
-    let _e608 = (*s_7).v;
-    light_4.h = normalize((_e606 + _e608));
-    let _e613 = (*s_7).n;
-    let _e615 = light_4.l;
-    light_4.n_dot_l = max(dot(_e613, _e615), 0f);
-    let _e620 = (*s_7).n;
-    let _e622 = light_4.h;
-    light_4.n_dot_h = max(dot(_e620, _e622), 0f);
-    let _e627 = (*s_7).v;
-    let _e629 = light_4.h;
-    light_4.v_dot_h = max(dot(_e627, _e629), 0f);
-    let _e633 = color_1;
-    let _e636 = color_1[3u];
-    let _e638 = attenuation_1;
-    light_4.radiance = ((_e633.xyz * _e636) * _e638);
-    let _e641 = light_4;
-    return _e641;
+            let _e576 = light_4;
+            return _e576;
+        }
+        let _e577 = toLight_1;
+        let _e578 = distance_3;
+        light_4.l = (_e577 / vec3(_e578));
+        let _e582 = distance_3;
+        param_175 = _e582;
+        let _e584 = direction[3u];
+        param_176 = _e584;
+        let _e585 = PunctualAttenuation_u0028_f1_u003b_f1_u003b((&param_175), (&param_176));
+        attenuation_1 = _e585;
+        let _e586 = type_45;
+        if (_e586 > 1.5f) {
+            let _e588 = aim;
+            let _e590 = light_4.l;
+            cosAngle = dot(_e588, -(_e590));
+            let _e593 = cosAngle;
+            let _e595 = cone[1u];
+            let _e598 = cone[0u];
+            let _e600 = cone[1u];
+            let _e604 = attenuation_1;
+            attenuation_1 = (_e604 * clamp(((_e593 - _e595) / (_e598 - _e600)), 0f, 1f));
+        }
+    }
+    let _e607 = light_4.l;
+    let _e609 = (*s_7).v;
+    light_4.h = normalize((_e607 + _e609));
+    let _e614 = (*s_7).n;
+    let _e616 = light_4.l;
+    light_4.n_dot_l = max(dot(_e614, _e616), 0f);
+    let _e621 = (*s_7).n;
+    let _e623 = light_4.h;
+    light_4.n_dot_h = max(dot(_e621, _e623), 0f);
+    let _e628 = (*s_7).v;
+    let _e630 = light_4.h;
+    light_4.v_dot_h = max(dot(_e628, _e630), 0f);
+    let _e634 = color_1;
+    let _e637 = color_1[3u];
+    let _e639 = attenuation_1;
+    light_4.radiance = ((_e634.xyz * _e637) * _e639);
+    let _e642 = light_4;
+    return _e642;
 }
 
 fn FindCluster_u0028_vf3_u003b(world_3: ptr<function, vec3<f32>>) {
@@ -20978,58 +21132,58 @@ fn FindCluster_u0028_vf3_u003b(world_3: ptr<function, vec3<f32>>) {
     var param_177: f32;
     var param_178: f32;
 
-    let _e288 = light_list_info.cluster_view_projection;
-    let _e289 = (*world_3);
-    clip_1 = (_e288 * vec4<f32>(_e289.x, _e289.y, _e289.z, 1f));
-    let _e295 = clip_1;
-    let _e298 = clip_1[3u];
-    ndc_1 = (_e295.xy / vec2(max(_e298, 0.000001f)));
-    let _e303 = light_list_info.cluster_grid;
-    grid = _e303.xyz;
-    let _e307 = light_list_info.cluster_depth[0u];
-    near_1 = _e307;
-    let _e309 = ndc_1[0u];
-    let _e313 = grid[0u];
-    let _e317 = grid[0u];
-    tx = clamp(floor((((_e309 * 0.5f) + 0.5f) * _e313)), 0f, (_e317 - 1f));
-    let _e321 = ndc_1[1u];
-    let _e325 = grid[1u];
-    let _e329 = grid[1u];
-    ty = clamp(floor((((_e321 * 0.5f) + 0.5f) * _e325)), 0f, (_e329 - 1f));
-    let _e333 = clip_1[3u];
-    let _e334 = near_1;
-    if (_e333 <= _e334) {
+    let _e289 = light_list_info.cluster_view_projection;
+    let _e290 = (*world_3);
+    clip_1 = (_e289 * vec4<f32>(_e290.x, _e290.y, _e290.z, 1f));
+    let _e296 = clip_1;
+    let _e299 = clip_1[3u];
+    ndc_1 = (_e296.xy / vec2(max(_e299, 0.000001f)));
+    let _e304 = light_list_info.cluster_grid;
+    grid = _e304.xyz;
+    let _e308 = light_list_info.cluster_depth[0u];
+    near_1 = _e308;
+    let _e310 = ndc_1[0u];
+    let _e314 = grid[0u];
+    let _e318 = grid[0u];
+    tx = clamp(floor((((_e310 * 0.5f) + 0.5f) * _e314)), 0f, (_e318 - 1f));
+    let _e322 = ndc_1[1u];
+    let _e326 = grid[1u];
+    let _e330 = grid[1u];
+    ty = clamp(floor((((_e322 * 0.5f) + 0.5f) * _e326)), 0f, (_e330 - 1f));
+    let _e334 = clip_1[3u];
+    let _e335 = near_1;
+    if (_e334 <= _e335) {
         local_29 = 0f;
     } else {
-        let _e337 = clip_1[3u];
-        let _e338 = near_1;
-        let _e343 = light_list_info.cluster_depth[1u];
-        let _e347 = grid[2u];
-        local_29 = clamp(floor((log((_e337 / _e338)) * _e343)), 0f, (_e347 - 1f));
-    }
-    let _e350 = local_29;
-    tz = _e350;
-    let _e351 = tx;
-    let _e352 = ty;
-    let _e354 = grid[0u];
-    let _e357 = tz;
-    let _e359 = grid[0u];
-    let _e362 = grid[1u];
-    cell = ((_e351 + (_e352 * _e354)) + ((_e357 * _e359) * _e362));
-    let _e365 = cell;
-    row_3 = floor((_e365 / 4f));
-    let _e368 = cell;
-    let _e369 = row_3;
-    let _e374 = light_list_info.cluster_depth[2u];
-    let _e375 = row_3;
-    param_177 = (_e368 - (_e369 * 4f));
-    param_178 = (_e374 + _e375);
-    let _e377 = LightListTexel_u0028_f1_u003b_f1_u003b((&param_177), (&param_178));
-    header = _e377;
-    let _e379 = header[0u];
-    g_cluster_offset = _e379;
-    let _e381 = header[1u];
-    g_cluster_count = _e381;
+        let _e338 = clip_1[3u];
+        let _e339 = near_1;
+        let _e344 = light_list_info.cluster_depth[1u];
+        let _e348 = grid[2u];
+        local_29 = clamp(floor((log((_e338 / _e339)) * _e344)), 0f, (_e348 - 1f));
+    }
+    let _e351 = local_29;
+    tz = _e351;
+    let _e352 = tx;
+    let _e353 = ty;
+    let _e355 = grid[0u];
+    let _e358 = tz;
+    let _e360 = grid[0u];
+    let _e363 = grid[1u];
+    cell = ((_e352 + (_e353 * _e355)) + ((_e358 * _e360) * _e363));
+    let _e366 = cell;
+    row_3 = floor((_e366 / 4f));
+    let _e369 = cell;
+    let _e370 = row_3;
+    let _e375 = light_list_info.cluster_depth[2u];
+    let _e376 = row_3;
+    param_177 = (_e369 - (_e370 * 4f));
+    param_178 = (_e375 + _e376);
+    let _e378 = LightListTexel_u0028_f1_u003b_f1_u003b((&param_177), (&param_178));
+    header = _e378;
+    let _e380 = header[0u];
+    g_cluster_offset = _e380;
+    let _e382 = header[1u];
+    g_cluster_count = _e382;
     return;
 }
 
@@ -21037,19 +21191,19 @@ fn LightCount_u0028_() -> i32 {
     var tail: f32;
     var param_179: vec3<f32>;
 
-    let _e277 = light_list_info.list[0u];
-    tail = _e277;
-    let _e278 = Clustered_u0028_();
-    if _e278 {
-        let _e279 = v_world_position_1;
-        param_179 = _e279;
+    let _e278 = light_list_info.list[0u];
+    tail = _e278;
+    let _e279 = Clustered_u0028_();
+    if _e279 {
+        let _e280 = v_world_position_1;
+        param_179 = _e280;
         FindCluster_u0028_vf3_u003b((&param_179));
-        let _e280 = g_cluster_count;
-        tail = _e280;
+        let _e281 = g_cluster_count;
+        tail = _e281;
     }
-    let _e283 = frag_info.frame_params[1u];
-    let _e287 = tail;
-    return (clamp(i32((_e283 + 0.5f)), 0i, 8i) + clamp(i32((_e287 + 0.5f)), 0i, 24i));
+    let _e284 = frag_info.frame_params[1u];
+    let _e288 = tail;
+    return (clamp(i32((_e284 + 0.5f)), 0i, 8i) + clamp(i32((_e288 + 0.5f)), 0i, 24i));
 }
 
 fn AccumulateLights_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_8: ptr<function, Surface>) -> vec3<f32> {
@@ -21072,89 +21226,89 @@ fn AccumulateLights_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002
     var param_190: LightSample;
 
     total_1 = vec3<f32>(0f, 0f, 0f);
-    let _e291 = LightCount_u0028_();
-    count_1 = _e291;
+    let _e292 = LightCount_u0028_();
+    count_1 = _e292;
     i_9 = 0i;
     loop {
-        let _e292 = i_9;
-        if (_e292 < 32i) {
-            let _e294 = i_9;
-            let _e295 = count_1;
-            if (_e294 >= _e295) {
+        let _e293 = i_9;
+        if (_e293 < 32i) {
+            let _e295 = i_9;
+            let _e296 = count_1;
+            if (_e295 >= _e296) {
                 break;
             }
-            let _e297 = i_9;
-            param_180 = _e297;
-            let _e298 = (*s_8);
-            param_181 = _e298;
-            let _e299 = SampleLight_u0028_i1_u003b_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_180), (&param_181));
-            light_5 = _e299;
-            let _e301 = light_5.n_dot_l;
-            if (_e301 <= 0f) {
+            let _e298 = i_9;
+            param_180 = _e298;
+            let _e299 = (*s_8);
+            param_181 = _e299;
+            let _e300 = SampleLight_u0028_i1_u003b_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_180), (&param_181));
+            light_5 = _e300;
+            let _e302 = light_5.n_dot_l;
+            if (_e302 <= 0f) {
                 continue;
             }
             light_transmittance = vec3<f32>(1f, 1f, 1f);
-            let _e303 = i_9;
-            param_182 = _e303;
-            let _e304 = LightHasShadow_u0028_i1_u003b((&param_182));
-            if _e304 {
-                let _e305 = (*s_8);
-                param_183 = _e305;
-                let _e306 = light_5;
-                param_184 = _e306;
-                let _e307 = i_9;
-                param_185 = _e307;
-                let _e308 = LightVisibility_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b_i1_u003b((&param_183), (&param_184), (&param_185));
-                let _e309 = v_world_position_1;
-                param_186 = _e309;
-                let _e311 = (*s_8).n;
-                param_187 = _e311;
-                let _e312 = i_9;
-                param_188 = _e312;
-                let _e313 = PointShadowFactor_u0028_vf3_u003b_vf3_u003b_i1_u003b((&param_186), (&param_187), (&param_188));
-                local_30 = (_e308 * _e313);
+            let _e304 = i_9;
+            param_182 = _e304;
+            let _e305 = LightHasShadow_u0028_i1_u003b((&param_182));
+            if _e305 {
+                let _e306 = (*s_8);
+                param_183 = _e306;
+                let _e307 = light_5;
+                param_184 = _e307;
+                let _e308 = i_9;
+                param_185 = _e308;
+                let _e309 = LightVisibility_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b_i1_u003b((&param_183), (&param_184), (&param_185));
+                let _e310 = v_world_position_1;
+                param_186 = _e310;
+                let _e312 = (*s_8).n;
+                param_187 = _e312;
+                let _e313 = i_9;
+                param_188 = _e313;
+                let _e314 = PointShadowFactor_u0028_vf3_u003b_vf3_u003b_i1_u003b((&param_186), (&param_187), (&param_188));
+                local_30 = (_e309 * _e314);
             } else {
                 local_30 = 1f;
             }
-            let _e315 = local_30;
-            visibility = _e315;
-            let _e316 = visibility;
-            if (_e316 <= 0f) {
+            let _e316 = local_30;
+            visibility = _e316;
+            let _e317 = visibility;
+            if (_e317 <= 0f) {
                 continue;
             }
-            let _e318 = (*s_8);
-            param_189 = _e318;
-            let _e319 = light_5;
-            param_190 = _e319;
-            let _e320 = ShadeLight_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b((&param_189), (&param_190));
-            let _e322 = light_5.radiance;
-            let _e325 = light_5.n_dot_l;
-            let _e327 = visibility;
-            let _e329 = light_transmittance;
-            let _e331 = total_1;
-            total_1 = (_e331 + ((((_e320 * _e322) * _e325) * _e327) * _e329));
+            let _e319 = (*s_8);
+            param_189 = _e319;
+            let _e320 = light_5;
+            param_190 = _e320;
+            let _e321 = ShadeLight_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b((&param_189), (&param_190));
+            let _e323 = light_5.radiance;
+            let _e326 = light_5.n_dot_l;
+            let _e328 = visibility;
+            let _e330 = light_transmittance;
+            let _e332 = total_1;
+            total_1 = (_e332 + ((((_e321 * _e323) * _e326) * _e328) * _e330));
             continue;
         } else {
             break;
         }
         continuing {
-            let _e333 = i_9;
-            i_9 = (_e333 + 1i);
+            let _e334 = i_9;
+            i_9 = (_e334 + 1i);
         }
     }
-    let _e335 = total_1;
-    return _e335;
+    let _e336 = total_1;
+    return _e336;
 }
 
 fn SampleLightmap_u0028_() -> vec3<f32> {
     var texel_4: vec4<f32>;
 
-    let _e274 = v_lightmap_uv_1;
-    let _e275 = textureSample(lightmap_texture_tex, lightmap_texture_smp, _e274);
-    texel_4 = _e275;
-    let _e276 = texel_4;
-    let _e279 = texel_4[3u];
-    return ((_e276.xyz * _e279) * 8f);
+    let _e275 = v_lightmap_uv_1;
+    let _e276 = textureSample(lightmap_texture_tex, lightmap_texture_smp, _e275);
+    texel_4 = _e276;
+    let _e277 = texel_4;
+    let _e280 = texel_4[3u];
+    return ((_e277.xyz * _e280) * 8f);
 }
 
 fn SceneColourLevel_u0028_vf2_u003b_i1_u003b(uv_6: ptr<function, vec2<f32>>, level: ptr<function, i32>) -> vec3<f32> {
@@ -21162,22 +21316,22 @@ fn SceneColourLevel_u0028_vf2_u003b_i1_u003b(uv_6: ptr<function, vec2<f32>>, lev
     var inset_1: vec2<f32>;
     var at_4: vec2<f32>;
 
-    let _e278 = (*level);
-    let _e281 = layer_info.scene_levels[_e278];
-    rect = _e281;
-    let _e283 = layer_info.scene_colour;
-    inset_1 = (_e283.yz * 0.5f);
-    let _e286 = rect;
-    let _e288 = (*uv_6);
-    let _e289 = rect;
-    let _e292 = inset_1;
-    let _e293 = rect;
-    let _e295 = inset_1;
-    let _e297 = inset_1;
-    at_4 = (_e286.xy + clamp((_e288 * _e289.zw), _e292, max((_e293.zw - _e295), _e297)));
-    let _e301 = at_4;
-    let _e302 = textureSampleLevel(scene_colour_texture_tex, scene_colour_texture_smp, _e301, 0f);
-    return _e302.xyz;
+    let _e279 = (*level);
+    let _e282 = layer_info.scene_levels[_e279];
+    rect = _e282;
+    let _e284 = layer_info.scene_colour;
+    inset_1 = (_e284.yz * 0.5f);
+    let _e287 = rect;
+    let _e289 = (*uv_6);
+    let _e290 = rect;
+    let _e293 = inset_1;
+    let _e294 = rect;
+    let _e296 = inset_1;
+    let _e298 = inset_1;
+    at_4 = (_e287.xy + clamp((_e289 * _e290.zw), _e293, max((_e294.zw - _e296), _e298)));
+    let _e302 = at_4;
+    let _e303 = textureSampleLevel(scene_colour_texture_tex, scene_colour_texture_smp, _e302, 0f);
+    return _e303.xyz;
 }
 
 fn SceneColourAt_u0028_vf3_u003b_f1_u003b(world_4: ptr<function, vec3<f32>>, lod: ptr<function, f32>) -> vec3<f32> {
@@ -21195,78 +21349,78 @@ fn SceneColourAt_u0028_vf3_u003b_f1_u003b(world_4: ptr<function, vec3<f32>>, lod
     var param_193: vec2<f32>;
     var param_194: i32;
 
-    let _e289 = layer_info.scene_view_projection;
-    let _e290 = (*world_4);
-    clip_2 = (_e289 * vec4<f32>(_e290.x, _e290.y, _e290.z, 1f));
-    let _e296 = clip_2;
-    let _e299 = clip_2[3u];
-    ndc_2 = (_e296.xy / vec2(max(_e299, 0.000001f)));
-    let _e304 = ndc_2[0u];
-    let _e308 = ndc_2[1u];
-    view_1 = clamp(vec2<f32>(((_e304 * 0.5f) + 0.5f), (0.5f - (_e308 * 0.5f))), vec2<f32>(0f, 0f), vec2<f32>(1f, 1f));
-    let _e314 = layer_info.scene_viewport;
-    let _e316 = view_1;
-    let _e318 = layer_info.scene_viewport;
-    uv_7 = (_e314.xy + (_e316 * _e318.zw));
-    let _e324 = layer_info.scene_colour[0u];
-    top = (_e324 - 1f);
-    let _e326 = (*lod);
-    let _e327 = top;
-    level_1 = clamp(_e326, 0f, _e327);
-    let _e329 = level_1;
-    lower = floor(_e329);
-    let _e331 = lower;
-    let _e333 = uv_7;
-    param_191 = _e333;
-    param_192 = i32(_e331);
-    let _e334 = SceneColourLevel_u0028_vf2_u003b_i1_u003b((&param_191), (&param_192));
-    near_2 = _e334;
-    let _e335 = lower;
-    let _e337 = top;
-    let _e340 = uv_7;
-    param_193 = _e340;
-    param_194 = i32(min((_e335 + 1f), _e337));
-    let _e341 = SceneColourLevel_u0028_vf2_u003b_i1_u003b((&param_193), (&param_194));
-    far_1 = _e341;
-    let _e342 = near_2;
-    let _e343 = far_1;
-    let _e344 = level_1;
-    let _e345 = lower;
-    return mix(_e342, _e343, vec3((_e344 - _e345)));
+    let _e290 = layer_info.scene_view_projection;
+    let _e291 = (*world_4);
+    clip_2 = (_e290 * vec4<f32>(_e291.x, _e291.y, _e291.z, 1f));
+    let _e297 = clip_2;
+    let _e300 = clip_2[3u];
+    ndc_2 = (_e297.xy / vec2(max(_e300, 0.000001f)));
+    let _e305 = ndc_2[0u];
+    let _e309 = ndc_2[1u];
+    view_1 = clamp(vec2<f32>(((_e305 * 0.5f) + 0.5f), (0.5f - (_e309 * 0.5f))), vec2<f32>(0f, 0f), vec2<f32>(1f, 1f));
+    let _e315 = layer_info.scene_viewport;
+    let _e317 = view_1;
+    let _e319 = layer_info.scene_viewport;
+    uv_7 = (_e315.xy + (_e317 * _e319.zw));
+    let _e325 = layer_info.scene_colour[0u];
+    top = (_e325 - 1f);
+    let _e327 = (*lod);
+    let _e328 = top;
+    level_1 = clamp(_e327, 0f, _e328);
+    let _e330 = level_1;
+    lower = floor(_e330);
+    let _e332 = lower;
+    let _e334 = uv_7;
+    param_191 = _e334;
+    param_192 = i32(_e332);
+    let _e335 = SceneColourLevel_u0028_vf2_u003b_i1_u003b((&param_191), (&param_192));
+    near_2 = _e335;
+    let _e336 = lower;
+    let _e338 = top;
+    let _e341 = uv_7;
+    param_193 = _e341;
+    param_194 = i32(min((_e336 + 1f), _e338));
+    let _e342 = SceneColourLevel_u0028_vf2_u003b_i1_u003b((&param_193), (&param_194));
+    far_1 = _e342;
+    let _e343 = near_2;
+    let _e344 = far_1;
+    let _e345 = level_1;
+    let _e346 = lower;
+    return mix(_e343, _e344, vec3((_e345 - _e346)));
 }
 
 fn IorInfinite_u0028_() -> bool {
-    let _e275 = layer_info.coat[2u];
-    return (_e275 == 0f);
+    let _e276 = layer_info.coat[2u];
+    return (_e276 == 0f);
 }
 
 fn DispersionSpread_u0028_f1_u003b(ior: ptr<function, f32>) -> f32 {
     var local_31: f32;
 
-    let _e275 = IorInfinite_u0028_();
-    if _e275 {
+    let _e276 = IorInfinite_u0028_();
+    if _e276 {
         local_31 = 0f;
     } else {
-        let _e276 = (*ior);
-        let _e281 = layer_info.transmission[3u];
-        local_31 = (((_e276 - 1f) * 0.025f) * _e281);
+        let _e277 = (*ior);
+        let _e282 = layer_info.transmission[3u];
+        local_31 = (((_e277 - 1f) * 0.025f) * _e282);
     }
-    let _e283 = local_31;
-    return _e283;
+    let _e284 = local_31;
+    return _e284;
 }
 
 fn RefractionIor_u0028_() -> f32 {
     var local_32: f32;
 
-    let _e274 = IorInfinite_u0028_();
-    if _e274 {
+    let _e275 = IorInfinite_u0028_();
+    if _e275 {
         local_32 = 10000f;
     } else {
-        let _e277 = layer_info.coat[2u];
-        local_32 = max(_e277, 1f);
+        let _e278 = layer_info.coat[2u];
+        local_32 = max(_e278, 1f);
     }
-    let _e279 = local_32;
-    return _e279;
+    let _e280 = local_32;
+    return _e280;
 }
 
 fn SceneBehind_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_9: ptr<function, Surface>) -> vec3<f32> {
@@ -21289,81 +21443,81 @@ fn SceneBehind_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3
     var param_200: vec3<f32>;
     var param_201: f32;
 
-    let _e292 = RefractionIor_u0028_();
-    ior_1 = _e292;
-    let _e293 = ior_1;
-    param_195 = _e293;
-    let _e294 = DispersionSpread_u0028_f1_u003b((&param_195));
-    spread_1 = _e294;
-    let _e298 = layer_info.scene_levels[0i][2u];
-    let _e301 = layer_info.scene_colour[1u];
-    width = (_e298 / max(_e301, 0.000000001f));
-    let _e304 = width;
-    let _e308 = (*s_9).roughness;
-    let _e310 = ior_1;
-    lod_1 = ((log2(max(_e304, 1f)) * _e308) * clamp(((_e310 * 2f) - 2f), 0f, 1f));
-    let _e315 = g_thickness;
-    thin = (_e315 <= 0f);
-    let _e317 = thin;
-    if _e317 {
-        let _e319 = (*s_9).v;
-        local_33 = -(_e319);
-    } else {
-        let _e322 = (*s_9).v;
-        let _e325 = (*s_9).n;
-        let _e326 = ior_1;
-        let _e327 = spread_1;
-        local_33 = refract(-(_e322), _e325, (1f / max((_e326 - _e327), 1f)));
-    }
-    let _e332 = local_33;
-    red = _e332;
-    let _e333 = thin;
-    if _e333 {
-        let _e335 = (*s_9).v;
-        local_34 = -(_e335);
-    } else {
-        let _e338 = (*s_9).v;
-        let _e341 = (*s_9).n;
-        let _e342 = ior_1;
-        local_34 = refract(-(_e338), _e341, (1f / _e342));
-    }
-    let _e345 = local_34;
-    green = _e345;
-    let _e346 = thin;
-    if _e346 {
-        let _e348 = (*s_9).v;
-        local_35 = -(_e348);
-    } else {
-        let _e351 = (*s_9).v;
-        let _e354 = (*s_9).n;
-        let _e355 = ior_1;
-        let _e356 = spread_1;
-        local_35 = refract(-(_e351), _e354, (1f / (_e355 + _e356)));
-    }
-    let _e360 = local_35;
-    blue = _e360;
-    let _e361 = v_world_position_1;
-    let _e362 = red;
-    let _e363 = g_thickness;
-    param_196 = (_e361 + (_e362 * _e363));
-    let _e366 = lod_1;
-    param_197 = _e366;
-    let _e367 = SceneColourAt_u0028_vf3_u003b_f1_u003b((&param_196), (&param_197));
-    let _e369 = v_world_position_1;
-    let _e370 = green;
-    let _e371 = g_thickness;
-    param_198 = (_e369 + (_e370 * _e371));
-    let _e374 = lod_1;
-    param_199 = _e374;
-    let _e375 = SceneColourAt_u0028_vf3_u003b_f1_u003b((&param_198), (&param_199));
-    let _e377 = v_world_position_1;
-    let _e378 = blue;
-    let _e379 = g_thickness;
-    param_200 = (_e377 + (_e378 * _e379));
-    let _e382 = lod_1;
-    param_201 = _e382;
-    let _e383 = SceneColourAt_u0028_vf3_u003b_f1_u003b((&param_200), (&param_201));
-    return vec3<f32>(_e367.x, _e375.y, _e383.z);
+    let _e293 = RefractionIor_u0028_();
+    ior_1 = _e293;
+    let _e294 = ior_1;
+    param_195 = _e294;
+    let _e295 = DispersionSpread_u0028_f1_u003b((&param_195));
+    spread_1 = _e295;
+    let _e299 = layer_info.scene_levels[0i][2u];
+    let _e302 = layer_info.scene_colour[1u];
+    width = (_e299 / max(_e302, 0.000000001f));
+    let _e305 = width;
+    let _e309 = (*s_9).roughness;
+    let _e311 = ior_1;
+    lod_1 = ((log2(max(_e305, 1f)) * _e309) * clamp(((_e311 * 2f) - 2f), 0f, 1f));
+    let _e316 = g_thickness;
+    thin = (_e316 <= 0f);
+    let _e318 = thin;
+    if _e318 {
+        let _e320 = (*s_9).v;
+        local_33 = -(_e320);
+    } else {
+        let _e323 = (*s_9).v;
+        let _e326 = (*s_9).n;
+        let _e327 = ior_1;
+        let _e328 = spread_1;
+        local_33 = refract(-(_e323), _e326, (1f / max((_e327 - _e328), 1f)));
+    }
+    let _e333 = local_33;
+    red = _e333;
+    let _e334 = thin;
+    if _e334 {
+        let _e336 = (*s_9).v;
+        local_34 = -(_e336);
+    } else {
+        let _e339 = (*s_9).v;
+        let _e342 = (*s_9).n;
+        let _e343 = ior_1;
+        local_34 = refract(-(_e339), _e342, (1f / _e343));
+    }
+    let _e346 = local_34;
+    green = _e346;
+    let _e347 = thin;
+    if _e347 {
+        let _e349 = (*s_9).v;
+        local_35 = -(_e349);
+    } else {
+        let _e352 = (*s_9).v;
+        let _e355 = (*s_9).n;
+        let _e356 = ior_1;
+        let _e357 = spread_1;
+        local_35 = refract(-(_e352), _e355, (1f / (_e356 + _e357)));
+    }
+    let _e361 = local_35;
+    blue = _e361;
+    let _e362 = v_world_position_1;
+    let _e363 = red;
+    let _e364 = g_thickness;
+    param_196 = (_e362 + (_e363 * _e364));
+    let _e367 = lod_1;
+    param_197 = _e367;
+    let _e368 = SceneColourAt_u0028_vf3_u003b_f1_u003b((&param_196), (&param_197));
+    let _e370 = v_world_position_1;
+    let _e371 = green;
+    let _e372 = g_thickness;
+    param_198 = (_e370 + (_e371 * _e372));
+    let _e375 = lod_1;
+    param_199 = _e375;
+    let _e376 = SceneColourAt_u0028_vf3_u003b_f1_u003b((&param_198), (&param_199));
+    let _e378 = v_world_position_1;
+    let _e379 = blue;
+    let _e380 = g_thickness;
+    param_200 = (_e378 + (_e379 * _e380));
+    let _e383 = lod_1;
+    param_201 = _e383;
+    let _e384 = SceneColourAt_u0028_vf3_u003b_f1_u003b((&param_200), (&param_201));
+    return vec3<f32>(_e368.x, _e376.y, _e384.z);
 }
 
 fn TransmittedRadiance_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_f1_u003b(s_10: ptr<function, Surface>, levels: ptr<function, f32>) -> vec3<f32> {
@@ -21379,71 +21533,71 @@ fn TransmittedRadiance_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u
     var blue_1: vec3<f32>;
     var local_38: vec3<f32>;
 
-    let _e286 = RefractionIor_u0028_();
-    ior_2 = _e286;
-    let _e287 = ior_2;
-    param_202 = _e287;
-    let _e288 = DispersionSpread_u0028_f1_u003b((&param_202));
-    spread_2 = _e288;
-    let _e290 = (*s_10).roughness;
-    let _e291 = ior_2;
-    let _e296 = (*levels);
-    lod_2 = ((_e290 * clamp(((_e291 * 2f) - 2f), 0f, 1f)) * _e296);
-    let _e298 = g_thickness;
-    thin_1 = (_e298 <= 0f);
-    let _e300 = thin_1;
-    if _e300 {
-        let _e302 = (*s_10).v;
-        local_36 = -(_e302);
-    } else {
-        let _e305 = (*s_10).v;
-        let _e308 = (*s_10).n;
-        let _e309 = ior_2;
-        let _e310 = spread_2;
-        local_36 = refract(-(_e305), _e308, (1f / max((_e309 - _e310), 1f)));
-    }
-    let _e315 = local_36;
-    red_1 = _e315;
-    let _e316 = thin_1;
-    if _e316 {
-        let _e318 = (*s_10).v;
-        local_37 = -(_e318);
-    } else {
-        let _e321 = (*s_10).v;
-        let _e324 = (*s_10).n;
-        let _e325 = ior_2;
-        local_37 = refract(-(_e321), _e324, (1f / _e325));
-    }
-    let _e328 = local_37;
-    green_1 = _e328;
-    let _e329 = thin_1;
-    if _e329 {
-        let _e331 = (*s_10).v;
-        local_38 = -(_e331);
-    } else {
-        let _e334 = (*s_10).v;
-        let _e337 = (*s_10).n;
-        let _e338 = ior_2;
-        let _e339 = spread_2;
-        local_38 = refract(-(_e334), _e337, (1f / (_e338 + _e339)));
-    }
-    let _e343 = local_38;
-    blue_1 = _e343;
-    let _e344 = red_1;
-    let _e345 = lod_2;
-    let _e346 = textureSampleLevel(environment_texture_tex, environment_texture_smp, _e344, _e345);
-    let _e348 = green_1;
-    let _e349 = lod_2;
-    let _e350 = textureSampleLevel(environment_texture_tex, environment_texture_smp, _e348, _e349);
-    let _e352 = blue_1;
-    let _e353 = lod_2;
-    let _e354 = textureSampleLevel(environment_texture_tex, environment_texture_smp, _e352, _e353);
-    return vec3<f32>(_e346.x, _e350.y, _e354.z);
+    let _e287 = RefractionIor_u0028_();
+    ior_2 = _e287;
+    let _e288 = ior_2;
+    param_202 = _e288;
+    let _e289 = DispersionSpread_u0028_f1_u003b((&param_202));
+    spread_2 = _e289;
+    let _e291 = (*s_10).roughness;
+    let _e292 = ior_2;
+    let _e297 = (*levels);
+    lod_2 = ((_e291 * clamp(((_e292 * 2f) - 2f), 0f, 1f)) * _e297);
+    let _e299 = g_thickness;
+    thin_1 = (_e299 <= 0f);
+    let _e301 = thin_1;
+    if _e301 {
+        let _e303 = (*s_10).v;
+        local_36 = -(_e303);
+    } else {
+        let _e306 = (*s_10).v;
+        let _e309 = (*s_10).n;
+        let _e310 = ior_2;
+        let _e311 = spread_2;
+        local_36 = refract(-(_e306), _e309, (1f / max((_e310 - _e311), 1f)));
+    }
+    let _e316 = local_36;
+    red_1 = _e316;
+    let _e317 = thin_1;
+    if _e317 {
+        let _e319 = (*s_10).v;
+        local_37 = -(_e319);
+    } else {
+        let _e322 = (*s_10).v;
+        let _e325 = (*s_10).n;
+        let _e326 = ior_2;
+        local_37 = refract(-(_e322), _e325, (1f / _e326));
+    }
+    let _e329 = local_37;
+    green_1 = _e329;
+    let _e330 = thin_1;
+    if _e330 {
+        let _e332 = (*s_10).v;
+        local_38 = -(_e332);
+    } else {
+        let _e335 = (*s_10).v;
+        let _e338 = (*s_10).n;
+        let _e339 = ior_2;
+        let _e340 = spread_2;
+        local_38 = refract(-(_e335), _e338, (1f / (_e339 + _e340)));
+    }
+    let _e344 = local_38;
+    blue_1 = _e344;
+    let _e345 = red_1;
+    let _e346 = lod_2;
+    let _e347 = textureSampleLevel(environment_texture_tex, environment_texture_smp, _e345, _e346);
+    let _e349 = green_1;
+    let _e350 = lod_2;
+    let _e351 = textureSampleLevel(environment_texture_tex, environment_texture_smp, _e349, _e350);
+    let _e353 = blue_1;
+    let _e354 = lod_2;
+    let _e355 = textureSampleLevel(environment_texture_tex, environment_texture_smp, _e353, _e354);
+    return vec3<f32>(_e347.x, _e351.y, _e355.z);
 }
 
 fn SceneColourBound_u0028_() -> bool {
-    let _e275 = layer_info.scene_colour[0u];
-    return (_e275 > 0f);
+    let _e276 = layer_info.scene_colour[0u];
+    return (_e276 > 0f);
 }
 
 fn EonAlbedo_u0028_vf3_u003b_f1_u003b_f1_u003b(rho_2: ptr<function, vec3<f32>>, r_4: ptr<function, f32>, mu_1: ptr<function, f32>) -> vec3<f32> {
@@ -21454,23 +21608,23 @@ fn EonAlbedo_u0028_vf3_u003b_f1_u003b_f1_u003b(rho_2: ptr<function, vec3<f32>>,
     var param_206: vec3<f32>;
     var param_207: f32;
 
-    let _e282 = (*mu_1);
-    param_203 = _e282;
-    let _e283 = (*r_4);
-    param_204 = _e283;
-    let _e284 = FonAlbedo_u0028_f1_u003b_f1_u003b((&param_203), (&param_204));
-    e_1 = _e284;
-    let _e285 = (*rho_2);
-    let _e286 = e_1;
-    let _e288 = (*r_4);
-    param_205 = _e288;
-    let _e289 = FonAverage_u0028_f1_u003b((&param_205));
-    let _e290 = (*rho_2);
-    param_206 = _e290;
-    param_207 = _e289;
-    let _e291 = EonMultiAlbedo_u0028_vf3_u003b_f1_u003b((&param_206), (&param_207));
-    let _e292 = e_1;
-    return ((_e285 * _e286) + (_e291 * (1f - _e292)));
+    let _e283 = (*mu_1);
+    param_203 = _e283;
+    let _e284 = (*r_4);
+    param_204 = _e284;
+    let _e285 = FonAlbedo_u0028_f1_u003b_f1_u003b((&param_203), (&param_204));
+    e_1 = _e285;
+    let _e286 = (*rho_2);
+    let _e287 = e_1;
+    let _e289 = (*r_4);
+    param_205 = _e289;
+    let _e290 = FonAverage_u0028_f1_u003b((&param_205));
+    let _e291 = (*rho_2);
+    param_206 = _e291;
+    param_207 = _e290;
+    let _e292 = EonMultiAlbedo_u0028_vf3_u003b_f1_u003b((&param_206), (&param_207));
+    let _e293 = e_1;
+    return ((_e286 * _e287) + (_e292 * (1f - _e293)));
 }
 
 fn IridescenceSensitivity_u0028_f1_u003b_vf3_u003b(opd: ptr<function, f32>, shift: ptr<function, vec3<f32>>) -> vec3<f32> {
@@ -21480,30 +21634,30 @@ fn IridescenceSensitivity_u0028_f1_u003b_vf3_u003b(opd: ptr<function, f32>, shif
     var variance_1: vec3<f32>;
     var xyz: vec3<f32>;
 
-    let _e280 = (*opd);
-    phase = ((6.2831855f * _e280) * 0.000000001f);
+    let _e281 = (*opd);
+    phase = ((6.2831855f * _e281) * 0.000000001f);
     val = vec3<f32>(0.00000000000054856f, 0.00000000000044201f, 0.00000000000052481f);
     pos = vec3<f32>(1681000f, 1795300f, 2208400f);
     variance_1 = vec3<f32>(4327800000f, 9304600000f, 6612100000f);
-    let _e283 = val;
-    let _e284 = variance_1;
-    let _e288 = pos;
-    let _e289 = phase;
-    let _e291 = (*shift);
-    let _e295 = phase;
+    let _e284 = val;
+    let _e285 = variance_1;
+    let _e289 = pos;
+    let _e290 = phase;
+    let _e292 = (*shift);
     let _e296 = phase;
-    let _e299 = variance_1;
-    xyz = (((_e283 * sqrt((_e284 * 6.2831855f))) * cos(((_e288 * _e289) + _e291))) * exp((_e299 * -((_e295 * _e296)))));
-    let _e303 = phase;
-    let _e306 = (*shift)[0u];
-    let _e310 = phase;
-    let _e312 = phase;
-    let _e317 = xyz[0u];
-    xyz[0u] = (_e317 + ((0.00000001644083f * cos(((2239900f * _e303) + _e306))) * exp(((-4528200000f * _e310) * _e312))));
-    let _e320 = xyz;
-    xyz = (_e320 / vec3(0.00000010685f));
-    let _e323 = xyz;
-    return (mat3x3<f32>(vec3<f32>(3.2404542f, -0.969266f, 0.0556434f), vec3<f32>(-1.5371385f, 1.8760108f, -0.2040259f), vec3<f32>(-0.4985314f, 0.041556f, 1.0572252f)) * _e323);
+    let _e297 = phase;
+    let _e300 = variance_1;
+    xyz = (((_e284 * sqrt((_e285 * 6.2831855f))) * cos(((_e289 * _e290) + _e292))) * exp((_e300 * -((_e296 * _e297)))));
+    let _e304 = phase;
+    let _e307 = (*shift)[0u];
+    let _e311 = phase;
+    let _e313 = phase;
+    let _e318 = xyz[0u];
+    xyz[0u] = (_e318 + ((0.00000001644083f * cos(((2239900f * _e304) + _e307))) * exp(((-4528200000f * _e311) * _e313))));
+    let _e321 = xyz;
+    xyz = (_e321 / vec3(0.00000010685f));
+    let _e324 = xyz;
+    return (mat3x3<f32>(vec3<f32>(3.2404542f, -0.969266f, 0.0556434f), vec3<f32>(-1.5371385f, 1.8760108f, -0.2040259f), vec3<f32>(-0.4985314f, 0.041556f, 1.0572252f)) * _e324);
 }
 
 fn FresnelIridescence_u0028_f1_u003b_f1_u003b_f1_u003b_vf3_u003b(film: ptr<function, f32>, cos1_: ptr<function, f32>, thickness: ptr<function, f32>, base: ptr<function, vec3<f32>>) -> vec3<f32> {
@@ -21533,115 +21687,115 @@ fn FresnelIridescence_u0028_f1_u003b_f1_u003b_f1_u003b_vf3_u003b(film: ptr<funct
     var param_209: vec3<f32>;
     var local_39: vec3<f32>;
 
-    let _e302 = (*film);
-    let _e303 = (*thickness);
-    eta2_ = mix(1f, _e302, smoothstep(0f, 0.03f, _e303));
-    let _e306 = (*cos1_);
+    let _e303 = (*film);
+    let _e304 = (*thickness);
+    eta2_ = mix(1f, _e303, smoothstep(0f, 0.03f, _e304));
     let _e307 = (*cos1_);
-    let _e310 = eta2_;
+    let _e308 = (*cos1_);
     let _e311 = eta2_;
-    sin2Sq = ((1f - (_e306 * _e307)) / (_e310 * _e311));
-    let _e314 = sin2Sq;
-    cos2Sq = (1f - _e314);
-    let _e316 = cos2Sq;
-    cos2_ = sqrt(max(_e316, 0f));
-    let _e319 = eta2_;
-    let _e321 = eta2_;
-    r0_ = ((_e319 - 1f) / (_e321 + 1f));
-    let _e324 = r0_;
+    let _e312 = eta2_;
+    sin2Sq = ((1f - (_e307 * _e308)) / (_e311 * _e312));
+    let _e315 = sin2Sq;
+    cos2Sq = (1f - _e315);
+    let _e317 = cos2Sq;
+    cos2_ = sqrt(max(_e317, 0f));
+    let _e320 = eta2_;
+    let _e322 = eta2_;
+    r0_ = ((_e320 - 1f) / (_e322 + 1f));
     let _e325 = r0_;
-    let _e327 = r0_;
+    let _e326 = r0_;
     let _e328 = r0_;
-    let _e331 = (*cos1_);
-    r12_ = ((_e324 * _e325) + ((1f - (_e327 * _e328)) * pow((1f - _e331), 5f)));
-    let _e336 = r12_;
-    t121_ = (1f - _e336);
-    let _e338 = eta2_;
-    phi12_ = select(0f, 3.1415927f, (_e338 < 1f));
-    let _e341 = phi12_;
-    phi21_ = (3.1415927f - _e341);
-    let _e343 = (*base);
-    sqrtBase = sqrt(clamp(_e343, vec3<f32>(0f, 0f, 0f), vec3<f32>(0.9999f, 0.9999f, 0.9999f)));
-    let _e346 = sqrtBase;
-    let _e348 = sqrtBase;
-    baseIor = ((vec3<f32>(1f, 1f, 1f) + _e346) / (vec3<f32>(1f, 1f, 1f) - _e348));
-    let _e351 = baseIor;
-    let _e352 = eta2_;
-    let _e355 = baseIor;
-    let _e356 = eta2_;
-    r1_ = ((_e351 - vec3(_e352)) / (_e355 + vec3(_e356)));
-    let _e360 = r1_;
+    let _e329 = r0_;
+    let _e332 = (*cos1_);
+    r12_ = ((_e325 * _e326) + ((1f - (_e328 * _e329)) * pow((1f - _e332), 5f)));
+    let _e337 = r12_;
+    t121_ = (1f - _e337);
+    let _e339 = eta2_;
+    phi12_ = select(0f, 3.1415927f, (_e339 < 1f));
+    let _e342 = phi12_;
+    phi21_ = (3.1415927f - _e342);
+    let _e344 = (*base);
+    sqrtBase = sqrt(clamp(_e344, vec3<f32>(0f, 0f, 0f), vec3<f32>(0.9999f, 0.9999f, 0.9999f)));
+    let _e347 = sqrtBase;
+    let _e349 = sqrtBase;
+    baseIor = ((vec3<f32>(1f, 1f, 1f) + _e347) / (vec3<f32>(1f, 1f, 1f) - _e349));
+    let _e352 = baseIor;
+    let _e353 = eta2_;
+    let _e356 = baseIor;
+    let _e357 = eta2_;
+    r1_ = ((_e352 - vec3(_e353)) / (_e356 + vec3(_e357)));
     let _e361 = r1_;
-    r1_ = (_e361 * _e360);
-    let _e363 = r1_;
+    let _e362 = r1_;
+    r1_ = (_e362 * _e361);
     let _e364 = r1_;
-    let _e366 = cos2_;
-    r23_ = (_e363 + ((vec3<f32>(1f, 1f, 1f) - _e364) * pow((1f - _e366), 5f)));
-    let _e372 = baseIor[0u];
-    let _e373 = eta2_;
-    let _e377 = baseIor[1u];
-    let _e378 = eta2_;
-    let _e382 = baseIor[2u];
-    let _e383 = eta2_;
-    phi23_ = vec3<f32>(select(0f, 3.1415927f, (_e372 < _e373)), select(0f, 3.1415927f, (_e377 < _e378)), select(0f, 3.1415927f, (_e382 < _e383)));
-    let _e387 = eta2_;
-    let _e389 = (*thickness);
-    let _e391 = cos2_;
-    opd_1 = (((2f * _e387) * _e389) * _e391);
-    let _e393 = phi21_;
-    let _e395 = phi23_;
-    phi = (vec3(_e393) + _e395);
-    let _e397 = r12_;
-    let _e398 = r23_;
-    r123_ = clamp((_e398 * _e397), vec3<f32>(0.00001f, 0.00001f, 0.00001f), vec3<f32>(0.9999f, 0.9999f, 0.9999f));
-    let _e401 = r123_;
-    rootR123_ = sqrt(_e401);
-    let _e403 = t121_;
+    let _e365 = r1_;
+    let _e367 = cos2_;
+    r23_ = (_e364 + ((vec3<f32>(1f, 1f, 1f) - _e365) * pow((1f - _e367), 5f)));
+    let _e373 = baseIor[0u];
+    let _e374 = eta2_;
+    let _e378 = baseIor[1u];
+    let _e379 = eta2_;
+    let _e383 = baseIor[2u];
+    let _e384 = eta2_;
+    phi23_ = vec3<f32>(select(0f, 3.1415927f, (_e373 < _e374)), select(0f, 3.1415927f, (_e378 < _e379)), select(0f, 3.1415927f, (_e383 < _e384)));
+    let _e388 = eta2_;
+    let _e390 = (*thickness);
+    let _e392 = cos2_;
+    opd_1 = (((2f * _e388) * _e390) * _e392);
+    let _e394 = phi21_;
+    let _e396 = phi23_;
+    phi = (vec3(_e394) + _e396);
+    let _e398 = r12_;
+    let _e399 = r23_;
+    r123_ = clamp((_e399 * _e398), vec3<f32>(0.00001f, 0.00001f, 0.00001f), vec3<f32>(0.9999f, 0.9999f, 0.9999f));
+    let _e402 = r123_;
+    rootR123_ = sqrt(_e402);
     let _e404 = t121_;
-    let _e406 = r23_;
-    let _e408 = r123_;
-    rs = ((_e406 * (_e403 * _e404)) / (vec3<f32>(1f, 1f, 1f) - _e408));
-    let _e411 = r12_;
-    let _e413 = rs;
-    total_2 = (vec3(_e411) + _e413);
-    let _e415 = rs;
-    let _e416 = t121_;
-    cm = (_e415 - vec3(_e416));
+    let _e405 = t121_;
+    let _e407 = r23_;
+    let _e409 = r123_;
+    rs = ((_e407 * (_e404 * _e405)) / (vec3<f32>(1f, 1f, 1f) - _e409));
+    let _e412 = r12_;
+    let _e414 = rs;
+    total_2 = (vec3(_e412) + _e414);
+    let _e416 = rs;
+    let _e417 = t121_;
+    cm = (_e416 - vec3(_e417));
     m_1 = 1i;
     loop {
-        let _e419 = m_1;
-        if (_e419 <= 2i) {
-            let _e421 = rootR123_;
-            let _e422 = cm;
-            cm = (_e422 * _e421);
-            let _e424 = cm;
-            let _e426 = m_1;
-            let _e428 = opd_1;
-            let _e430 = m_1;
-            let _e432 = phi;
-            param_208 = (f32(_e426) * _e428);
-            param_209 = (_e432 * f32(_e430));
-            let _e434 = IridescenceSensitivity_u0028_f1_u003b_vf3_u003b((&param_208), (&param_209));
-            let _e436 = total_2;
-            total_2 = (_e436 + ((_e424 * 2f) * _e434));
+        let _e420 = m_1;
+        if (_e420 <= 2i) {
+            let _e422 = rootR123_;
+            let _e423 = cm;
+            cm = (_e423 * _e422);
+            let _e425 = cm;
+            let _e427 = m_1;
+            let _e429 = opd_1;
+            let _e431 = m_1;
+            let _e433 = phi;
+            param_208 = (f32(_e427) * _e429);
+            param_209 = (_e433 * f32(_e431));
+            let _e435 = IridescenceSensitivity_u0028_f1_u003b_vf3_u003b((&param_208), (&param_209));
+            let _e437 = total_2;
+            total_2 = (_e437 + ((_e425 * 2f) * _e435));
             continue;
         } else {
             break;
         }
         continuing {
-            let _e438 = m_1;
-            m_1 = (_e438 + 1i);
+            let _e439 = m_1;
+            m_1 = (_e439 + 1i);
         }
     }
-    let _e440 = cos2Sq;
-    if (_e440 < 0f) {
+    let _e441 = cos2Sq;
+    if (_e441 < 0f) {
         local_39 = vec3<f32>(1f, 1f, 1f);
     } else {
-        let _e442 = total_2;
-        local_39 = max(_e442, vec3<f32>(0f, 0f, 0f));
+        let _e443 = total_2;
+        local_39 = max(_e443, vec3<f32>(0f, 0f, 0f));
     }
-    let _e444 = local_39;
-    return _e444;
+    let _e445 = local_39;
+    return _e445;
 }
 
 fn ReadIridescence_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_11: ptr<function, Surface>) {
@@ -21651,20 +21805,20 @@ fn ReadIridescence_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d
     var param_212: f32;
     var param_213: vec3<f32>;
 
-    let _e279 = g_f0_dielectric;
-    let _e281 = (*s_11).albedo;
-    let _e283 = (*s_11).metallic;
-    f0_3 = mix(_e279, _e281, vec3(clamp(_e283, 0f, 1f)));
-    let _e289 = layer_info.iridescence[1u];
-    param_210 = _e289;
-    let _e291 = (*s_11).n_dot_v;
-    param_211 = _e291;
-    let _e294 = layer_info.iridescence[2u];
-    param_212 = _e294;
-    let _e295 = f0_3;
-    param_213 = _e295;
-    let _e296 = FresnelIridescence_u0028_f1_u003b_f1_u003b_f1_u003b_vf3_u003b((&param_210), (&param_211), (&param_212), (&param_213));
-    g_irid_fresnel = _e296;
+    let _e280 = g_f0_dielectric;
+    let _e282 = (*s_11).albedo;
+    let _e284 = (*s_11).metallic;
+    f0_3 = mix(_e280, _e282, vec3(clamp(_e284, 0f, 1f)));
+    let _e290 = layer_info.iridescence[1u];
+    param_210 = _e290;
+    let _e292 = (*s_11).n_dot_v;
+    param_211 = _e292;
+    let _e295 = layer_info.iridescence[2u];
+    param_212 = _e295;
+    let _e296 = f0_3;
+    param_213 = _e296;
+    let _e297 = FresnelIridescence_u0028_f1_u003b_f1_u003b_f1_u003b_vf3_u003b((&param_210), (&param_211), (&param_212), (&param_213));
+    g_irid_fresnel = _e297;
     return;
 }
 
@@ -21680,89 +21834,89 @@ fn ReadLayersOnMaps_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002
     var along_1: vec3<f32>;
     var local_41: f32;
     var local_42: vec3<f32>;
-    var phi_5007_: bool;
+    var phi_5040_: bool;
 
-    let _e286 = (*s_12).n_dot_v;
-    let _e290 = g_sheen_roughness;
-    param_214 = _e290;
-    param_215 = sqrt(clamp((1f - _e286), 0f, 1f));
+    let _e287 = (*s_12).n_dot_v;
+    let _e291 = g_sheen_roughness;
+    param_214 = _e291;
+    param_215 = sqrt(clamp((1f - _e287), 0f, 1f));
     param_216 = 1f;
-    let _e291 = LtcUv_u0028_f1_u003b_f1_u003b_f1_u003b((&param_214), (&param_215), (&param_216));
-    let _e292 = textureSampleLevel(ltc_texture_tex, ltc_texture_smp, _e291, 0f);
-    g_sheen_albedo = _e292.z;
-    let _e295 = g_sheen[0u];
-    let _e297 = g_sheen[1u];
-    let _e300 = g_sheen[2u];
-    let _e302 = g_sheen_albedo;
-    g_sheen_scale = (1f - (max(max(_e295, _e297), _e300) * _e302));
-    let _e305 = v_tangent_1;
-    let _e308 = (*s_12).n;
-    let _e310 = (*s_12).n;
-    let _e311 = v_tangent_1;
-    t_2 = (_e305.xyz - (_e308 * dot(_e310, _e311.xyz)));
-    let _e316 = t_2;
+    let _e292 = LtcUv_u0028_f1_u003b_f1_u003b_f1_u003b((&param_214), (&param_215), (&param_216));
+    let _e293 = textureSampleLevel(ltc_texture_tex, ltc_texture_smp, _e292, 0f);
+    g_sheen_albedo = _e293.z;
+    let _e296 = g_sheen[0u];
+    let _e298 = g_sheen[1u];
+    let _e301 = g_sheen[2u];
+    let _e303 = g_sheen_albedo;
+    g_sheen_scale = (1f - (max(max(_e296, _e298), _e301) * _e303));
+    let _e306 = v_tangent_1;
+    let _e309 = (*s_12).n;
+    let _e311 = (*s_12).n;
+    let _e312 = v_tangent_1;
+    t_2 = (_e306.xyz - (_e309 * dot(_e311, _e312.xyz)));
     let _e317 = t_2;
-    usable = (dot(_e316, _e317) > 0.000000000001f);
-    let _e320 = usable;
-    if _e320 {
-        let _e321 = t_2;
-        local_40 = normalize(_e321);
+    let _e318 = t_2;
+    usable = (dot(_e317, _e318) > 0.000000000001f);
+    let _e321 = usable;
+    if _e321 {
+        let _e322 = t_2;
+        local_40 = normalize(_e322);
     } else {
         local_40 = vec3<f32>(1f, 0f, 0f);
     }
-    let _e323 = local_40;
-    t_2 = _e323;
-    let _e325 = (*s_12).n;
-    let _e326 = t_2;
-    let _e329 = v_tangent_1[3u];
-    b_4 = (cross(_e325, _e326) * _e329);
-    let _e331 = gl_FrontFacing_1;
-    if !(_e331) {
-        let _e333 = t_2;
-        t_2 = -(_e333);
-    }
-    let _e336 = layer_info.anisotropy;
-    turn_2 = _e336.yz;
-    let _e338 = t_2;
-    let _e340 = turn_2[0u];
-    let _e342 = b_4;
-    let _e344 = turn_2[1u];
-    along_1 = ((_e338 * _e340) + (_e342 * _e344));
-    let _e347 = usable;
-    phi_5007_ = _e347;
-    if _e347 {
-        let _e348 = along_1;
+    let _e324 = local_40;
+    t_2 = _e324;
+    let _e326 = (*s_12).n;
+    let _e327 = t_2;
+    let _e330 = v_tangent_1[3u];
+    b_4 = (cross(_e326, _e327) * _e330);
+    let _e332 = gl_FrontFacing_1;
+    if !(_e332) {
+        let _e334 = t_2;
+        t_2 = -(_e334);
+    }
+    let _e337 = layer_info.anisotropy;
+    turn_2 = _e337.yz;
+    let _e339 = t_2;
+    let _e341 = turn_2[0u];
+    let _e343 = b_4;
+    let _e345 = turn_2[1u];
+    along_1 = ((_e339 * _e341) + (_e343 * _e345));
+    let _e348 = usable;
+    phi_5040_ = _e348;
+    if _e348 {
         let _e349 = along_1;
-        phi_5007_ = (dot(_e348, _e349) > 0.000000000001f);
+        let _e350 = along_1;
+        phi_5040_ = (dot(_e349, _e350) > 0.000000000001f);
     }
-    let _e353 = phi_5007_;
-    if _e353 {
-        let _e356 = layer_info.anisotropy[0u];
-        local_41 = clamp(_e356, 0f, 1f);
+    let _e354 = phi_5040_;
+    if _e354 {
+        let _e357 = layer_info.anisotropy[0u];
+        local_41 = clamp(_e357, 0f, 1f);
     } else {
         local_41 = 0f;
     }
-    let _e358 = local_41;
-    g_aniso = _e358;
-    let _e359 = g_aniso;
-    if (_e359 > 0f) {
-        let _e361 = along_1;
-        local_42 = normalize(_e361);
-    } else {
-        let _e363 = t_2;
-        local_42 = _e363;
-    }
-    let _e364 = local_42;
-    g_aniso_t = _e364;
-    let _e366 = (*s_12).n;
-    let _e367 = g_aniso_t;
-    g_aniso_b = cross(_e366, _e367);
+    let _e359 = local_41;
+    g_aniso = _e359;
+    let _e360 = g_aniso;
+    if (_e360 > 0f) {
+        let _e362 = along_1;
+        local_42 = normalize(_e362);
+    } else {
+        let _e364 = t_2;
+        local_42 = _e364;
+    }
+    let _e365 = local_42;
+    g_aniso_t = _e365;
+    let _e367 = (*s_12).n;
+    let _e368 = g_aniso_t;
+    g_aniso_b = cross(_e367, _e368);
     return;
 }
 
 fn MaterialLodBias_u0028_() -> f32 {
-    let _e275 = frag_info.target_origin[1u];
-    return _e275;
+    let _e276 = frag_info.target_origin[1u];
+    return _e276;
 }
 
 fn ApplyMetallicRoughnessMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_13: ptr<function, Surface>) {
@@ -21770,16 +21924,16 @@ fn ApplyMetallicRoughnessMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d
     var param_217: i32;
 
     param_217 = 1i;
-    let _e276 = MapUv_u0028_i1_u003b((&param_217));
-    let _e277 = MaterialLodBias_u0028_();
-    let _e278 = textureSampleBias(metallic_roughness_texture_tex, metallic_roughness_texture_smp, _e276, _e277);
-    orm = _e278.xyz;
-    let _e281 = (*s_13).metallic;
-    let _e283 = orm[2u];
-    (*s_13).metallic = clamp((_e281 * _e283), 0f, 1f);
-    let _e288 = (*s_13).roughness;
-    let _e290 = orm[1u];
-    (*s_13).roughness = clamp((_e288 * _e290), 0.02f, 1f);
+    let _e277 = MapUv_u0028_i1_u003b((&param_217));
+    let _e278 = MaterialLodBias_u0028_();
+    let _e279 = textureSampleBias(metallic_roughness_texture_tex, metallic_roughness_texture_smp, _e277, _e278);
+    orm = _e279.xyz;
+    let _e282 = (*s_13).metallic;
+    let _e284 = orm[2u];
+    (*s_13).metallic = clamp((_e282 * _e284), 0f, 1f);
+    let _e289 = (*s_13).roughness;
+    let _e291 = orm[1u];
+    (*s_13).roughness = clamp((_e289 * _e291), 0.02f, 1f);
     return;
 }
 
@@ -21789,16 +21943,16 @@ fn ApplyEmissiveMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002
     var param_219: vec3<f32>;
 
     param_218 = 4i;
-    let _e277 = MapUv_u0028_i1_u003b((&param_218));
-    let _e278 = MaterialLodBias_u0028_();
-    let _e279 = textureSampleBias(emissive_texture_tex, emissive_texture_smp, _e277, _e278);
-    param_219 = _e279.xyz;
-    let _e281 = SrgbToLinear_u0028_vf3_u003b((&param_219));
-    emissive = _e281;
-    let _e282 = emissive;
-    let _e284 = frag_info.emissive;
-    let _e289 = frag_info.material2_[3u];
-    (*s_14).emissive = ((_e282 * _e284.xyz) * _e289);
+    let _e278 = MapUv_u0028_i1_u003b((&param_218));
+    let _e279 = MaterialLodBias_u0028_();
+    let _e280 = textureSampleBias(emissive_texture_tex, emissive_texture_smp, _e278, _e279);
+    param_219 = _e280.xyz;
+    let _e282 = SrgbToLinear_u0028_vf3_u003b((&param_219));
+    emissive = _e282;
+    let _e283 = emissive;
+    let _e285 = frag_info.emissive;
+    let _e290 = frag_info.material2_[3u];
+    (*s_14).emissive = ((_e283 * _e285.xyz) * _e290);
     return;
 }
 
@@ -21807,13 +21961,13 @@ fn ApplyOcclusionMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u00
     var param_220: i32;
 
     param_220 = 3i;
-    let _e276 = MapUv_u0028_i1_u003b((&param_220));
-    let _e277 = MaterialLodBias_u0028_();
-    let _e278 = textureSampleBias(occlusion_texture_tex, occlusion_texture_smp, _e276, _e277);
-    occlusion = _e278.x;
-    let _e280 = occlusion;
-    let _e283 = frag_info.material2_[2u];
-    (*s_15).occlusion = mix(1f, _e280, clamp(_e283, 0f, 1f));
+    let _e277 = MapUv_u0028_i1_u003b((&param_220));
+    let _e278 = MaterialLodBias_u0028_();
+    let _e279 = textureSampleBias(occlusion_texture_tex, occlusion_texture_smp, _e277, _e278);
+    occlusion = _e279.x;
+    let _e281 = occlusion;
+    let _e284 = frag_info.material2_[2u];
+    (*s_15).occlusion = mix(1f, _e281, clamp(_e284, 0f, 1f));
     return;
 }
 
@@ -21821,17 +21975,17 @@ fn MapMatrix_u0028_i1_u003b(slot_7: ptr<function, i32>) -> vec4<f32> {
     var u_2: vec4<f32>;
     var v_3: vec4<f32>;
 
-    let _e276 = (*slot_7);
-    let _e280 = layer_info.uv_transform[(_e276 * 2i)];
-    u_2 = _e280;
-    let _e281 = (*slot_7);
-    let _e286 = layer_info.uv_transform[((_e281 * 2i) + 1i)];
-    v_3 = _e286;
-    let _e288 = u_2[0u];
-    let _e290 = u_2[1u];
-    let _e292 = v_3[0u];
-    let _e294 = v_3[1u];
-    return vec4<f32>(_e288, _e290, _e292, _e294);
+    let _e277 = (*slot_7);
+    let _e281 = layer_info.uv_transform[(_e277 * 2i)];
+    u_2 = _e281;
+    let _e282 = (*slot_7);
+    let _e287 = layer_info.uv_transform[((_e282 * 2i) + 1i)];
+    v_3 = _e287;
+    let _e289 = u_2[0u];
+    let _e291 = u_2[1u];
+    let _e293 = v_3[0u];
+    let _e295 = v_3[1u];
+    return vec4<f32>(_e289, _e291, _e293, _e295);
 }
 
 fn ApplyNormalMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_16: ptr<function, Surface>) {
@@ -21856,141 +22010,141 @@ fn ApplyNormalMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_
     var phi_3787_: bool;
 
     param_221 = 2i;
-    let _e289 = MapUv_u0028_i1_u003b((&param_221));
-    let _e290 = MaterialLodBias_u0028_();
-    let _e291 = textureSampleBias(normal_texture_tex, normal_texture_smp, _e289, _e290);
-    sampledTexel = _e291;
-    let _e292 = v_tangent_1;
-    t_3 = _e292.xyz;
-    let _e294 = t_3;
-    let _e296 = (*s_16).n;
-    let _e298 = (*s_16).n;
-    let _e299 = t_3;
-    t_3 = (_e294 - (_e296 * dot(_e298, _e299)));
-    let _e303 = t_3;
+    let _e290 = MapUv_u0028_i1_u003b((&param_221));
+    let _e291 = MaterialLodBias_u0028_();
+    let _e292 = textureSampleBias(normal_texture_tex, normal_texture_smp, _e290, _e291);
+    sampledTexel = _e292;
+    let _e293 = v_tangent_1;
+    t_3 = _e293.xyz;
+    let _e295 = t_3;
+    let _e297 = (*s_16).n;
+    let _e299 = (*s_16).n;
+    let _e300 = t_3;
+    t_3 = (_e295 - (_e297 * dot(_e299, _e300)));
     let _e304 = t_3;
-    if (dot(_e303, _e304) < 0.000000000001f) {
+    let _e305 = t_3;
+    if (dot(_e304, _e305) < 0.000000000001f) {
         return;
     }
-    let _e307 = t_3;
-    t_3 = normalize(_e307);
-    let _e310 = (*s_16).n;
-    let _e311 = t_3;
-    let _e314 = v_tangent_1[3u];
-    b_5 = (cross(_e310, _e311) * _e314);
+    let _e308 = t_3;
+    t_3 = normalize(_e308);
+    let _e311 = (*s_16).n;
+    let _e312 = t_3;
+    let _e315 = v_tangent_1[3u];
+    b_5 = (cross(_e311, _e312) * _e315);
     param_222 = 2i;
-    let _e316 = MapMatrix_u0028_i1_u003b((&param_222));
-    m_2 = _e316;
-    let _e318 = m_2[0u];
-    let _e320 = m_2[3u];
-    let _e323 = m_2[1u];
-    let _e325 = m_2[2u];
-    det = ((_e318 * _e320) - (_e323 * _e325));
-    let _e328 = det;
-    flip = select(1f, -1f, (_e328 < 0f));
-    let _e331 = gl_FrontFacing_1;
-    if _e331 {
-        let _e332 = b_5;
-        local_43 = _e332;
-    } else {
+    let _e317 = MapMatrix_u0028_i1_u003b((&param_222));
+    m_2 = _e317;
+    let _e319 = m_2[0u];
+    let _e321 = m_2[3u];
+    let _e324 = m_2[1u];
+    let _e326 = m_2[2u];
+    det = ((_e319 * _e321) - (_e324 * _e326));
+    let _e329 = det;
+    flip = select(1f, -1f, (_e329 < 0f));
+    let _e332 = gl_FrontFacing_1;
+    if _e332 {
         let _e333 = b_5;
-        local_43 = -(_e333);
-    }
-    let _e335 = local_43;
-    front = _e335;
-    let _e336 = t_3;
-    let _e338 = m_2[3u];
-    let _e340 = front;
-    let _e342 = m_2[2u];
-    let _e345 = flip;
-    turned = (((_e336 * _e338) + (_e340 * _e342)) * _e345);
-    let _e348 = m_2[1u];
-    let _e349 = (_e348 != 0f);
-    phi_3766_ = _e349;
-    if !(_e349) {
-        let _e352 = m_2[2u];
-        phi_3766_ = (_e352 != 0f);
-    }
-    let _e355 = phi_3766_;
-    phi_3773_ = _e355;
-    if !(_e355) {
-        let _e358 = m_2[0u];
-        phi_3773_ = (_e358 < 0f);
-    }
-    let _e361 = phi_3773_;
-    phi_3780_ = _e361;
-    if !(_e361) {
-        let _e364 = m_2[3u];
-        phi_3780_ = (_e364 < 0f);
-    }
-    let _e367 = phi_3780_;
-    phi_3787_ = _e367;
-    if _e367 {
-        let _e368 = turned;
+        local_43 = _e333;
+    } else {
+        let _e334 = b_5;
+        local_43 = -(_e334);
+    }
+    let _e336 = local_43;
+    front = _e336;
+    let _e337 = t_3;
+    let _e339 = m_2[3u];
+    let _e341 = front;
+    let _e343 = m_2[2u];
+    let _e346 = flip;
+    turned = (((_e337 * _e339) + (_e341 * _e343)) * _e346);
+    let _e349 = m_2[1u];
+    let _e350 = (_e349 != 0f);
+    phi_3766_ = _e350;
+    if !(_e350) {
+        let _e353 = m_2[2u];
+        phi_3766_ = (_e353 != 0f);
+    }
+    let _e356 = phi_3766_;
+    phi_3773_ = _e356;
+    if !(_e356) {
+        let _e359 = m_2[0u];
+        phi_3773_ = (_e359 < 0f);
+    }
+    let _e362 = phi_3773_;
+    phi_3780_ = _e362;
+    if !(_e362) {
+        let _e365 = m_2[3u];
+        phi_3780_ = (_e365 < 0f);
+    }
+    let _e368 = phi_3780_;
+    phi_3787_ = _e368;
+    if _e368 {
         let _e369 = turned;
-        phi_3787_ = (dot(_e368, _e369) > 0.000000000001f);
-    }
-    let _e373 = phi_3787_;
-    turns = _e373;
-    let _e374 = turns;
-    if _e374 {
-        let _e375 = turned;
-        local_44 = normalize(_e375);
-    } else {
-        let _e377 = t_3;
-        local_44 = _e377;
-    }
-    let _e378 = local_44;
-    t_3 = _e378;
-    let _e379 = turns;
-    if _e379 {
-        let _e381 = (*s_16).n;
-        let _e382 = t_3;
-        let _e385 = v_tangent_1[3u];
-        let _e387 = flip;
-        local_45 = ((cross(_e381, _e382) * _e385) * _e387);
-    } else {
-        let _e389 = b_5;
-        local_45 = _e389;
-    }
-    let _e390 = local_45;
-    b_5 = _e390;
-    let _e391 = gl_FrontFacing_1;
-    if !(_e391) {
-        let _e393 = t_3;
-        t_3 = -(_e393);
-    }
-    let _e395 = sampledTexel;
-    sampled = ((_e395.xyz * 2f) - vec3(1f));
-    let _e402 = frag_info.emissive[3u];
-    if (_e402 > 0.5f) {
-        let _e404 = sampled;
-        let _e406 = sampled;
-        sampled[2u] = sqrt(max((1f - dot(_e404.xy, _e406.xy)), 0f));
-    }
-    let _e415 = frag_info.material2_[1u];
-    let _e416 = sampled;
-    let _e418 = (_e416.xy * _e415);
-    sampled[0u] = _e418.x;
-    sampled[1u] = _e418.y;
-    let _e423 = t_3;
-    let _e425 = sampled[0u];
-    let _e427 = b_5;
-    let _e429 = sampled[1u];
-    let _e433 = (*s_16).n;
-    let _e435 = sampled[2u];
-    (*s_16).n = normalize((((_e423 * _e425) + (_e427 * _e429)) + (_e433 * _e435)));
-    let _e441 = (*s_16).n;
-    let _e443 = (*s_16).v;
-    (*s_16).n_dot_v = max(dot(_e441, _e443), 0.0001f);
+        let _e370 = turned;
+        phi_3787_ = (dot(_e369, _e370) > 0.000000000001f);
+    }
+    let _e374 = phi_3787_;
+    turns = _e374;
+    let _e375 = turns;
+    if _e375 {
+        let _e376 = turned;
+        local_44 = normalize(_e376);
+    } else {
+        let _e378 = t_3;
+        local_44 = _e378;
+    }
+    let _e379 = local_44;
+    t_3 = _e379;
+    let _e380 = turns;
+    if _e380 {
+        let _e382 = (*s_16).n;
+        let _e383 = t_3;
+        let _e386 = v_tangent_1[3u];
+        let _e388 = flip;
+        local_45 = ((cross(_e382, _e383) * _e386) * _e388);
+    } else {
+        let _e390 = b_5;
+        local_45 = _e390;
+    }
+    let _e391 = local_45;
+    b_5 = _e391;
+    let _e392 = gl_FrontFacing_1;
+    if !(_e392) {
+        let _e394 = t_3;
+        t_3 = -(_e394);
+    }
+    let _e396 = sampledTexel;
+    sampled = ((_e396.xyz * 2f) - vec3(1f));
+    let _e403 = frag_info.emissive[3u];
+    if (_e403 > 0.5f) {
+        let _e405 = sampled;
+        let _e407 = sampled;
+        sampled[2u] = sqrt(max((1f - dot(_e405.xy, _e407.xy)), 0f));
+    }
+    let _e416 = frag_info.material2_[1u];
+    let _e417 = sampled;
+    let _e419 = (_e417.xy * _e416);
+    sampled[0u] = _e419.x;
+    sampled[1u] = _e419.y;
+    let _e424 = t_3;
+    let _e426 = sampled[0u];
+    let _e428 = b_5;
+    let _e430 = sampled[1u];
+    let _e434 = (*s_16).n;
+    let _e436 = sampled[2u];
+    (*s_16).n = normalize((((_e424 * _e426) + (_e428 * _e430)) + (_e434 * _e436)));
+    let _e442 = (*s_16).n;
+    let _e444 = (*s_16).v;
+    (*s_16).n_dot_v = max(dot(_e442, _e444), 0.0001f);
     return;
 }
 
 fn AtlasTexel_u0028_vf2_u003b(texel_5: ptr<function, vec2<f32>>) -> vec4<f32> {
-    let _e274 = (*texel_5);
-    let _e278 = irradiance_info.atlas;
-    let _e281 = textureSampleLevel(irradiance_texture_tex, irradiance_texture_smp, ((_e274 + vec2(0.5f)) * _e278.xy), 0f);
-    return _e281;
+    let _e275 = (*texel_5);
+    let _e279 = irradiance_info.atlas;
+    let _e282 = textureSampleLevel(irradiance_texture_tex, irradiance_texture_smp, ((_e275 + vec2(0.5f)) * _e279.xy), 0f);
+    return _e282;
 }
 
 fn TileBilinear_u0028_vf2_u003b_f1_u003b_vf2_u003b(corner: ptr<function, vec2<f32>>, interior: ptr<function, f32>, uv_8: ptr<function, vec2<f32>>) -> vec4<f32> {
@@ -22006,42 +22160,42 @@ fn TileBilinear_u0028_vf2_u003b_f1_u003b_vf2_u003b(corner: ptr<function, vec2<f3
     var d_6: vec4<f32>;
     var param_226: vec2<f32>;
 
-    let _e287 = (*uv_8);
-    let _e288 = (*interior);
-    at_5 = ((vec2(1f) + (_e287 * _e288)) - vec2(0.5f));
-    let _e294 = at_5;
-    low = floor(_e294);
-    let _e296 = at_5;
-    let _e297 = low;
-    f_5 = (_e296 - _e297);
-    let _e299 = (*corner);
-    let _e300 = low;
-    param_223 = (_e299 + _e300);
-    let _e302 = AtlasTexel_u0028_vf2_u003b((&param_223));
-    a_6 = _e302;
-    let _e303 = (*corner);
-    let _e304 = low;
-    param_224 = ((_e303 + _e304) + vec2<f32>(1f, 0f));
-    let _e307 = AtlasTexel_u0028_vf2_u003b((&param_224));
-    b_6 = _e307;
-    let _e308 = (*corner);
-    let _e309 = low;
-    param_225 = ((_e308 + _e309) + vec2<f32>(0f, 1f));
-    let _e312 = AtlasTexel_u0028_vf2_u003b((&param_225));
-    c_1 = _e312;
-    let _e313 = (*corner);
-    let _e314 = low;
-    param_226 = ((_e313 + _e314) + vec2<f32>(1f, 1f));
-    let _e317 = AtlasTexel_u0028_vf2_u003b((&param_226));
-    d_6 = _e317;
-    let _e318 = a_6;
-    let _e319 = b_6;
-    let _e321 = f_5[0u];
-    let _e324 = c_1;
-    let _e325 = d_6;
-    let _e327 = f_5[0u];
-    let _e331 = f_5[1u];
-    return mix(mix(_e318, _e319, vec4(_e321)), mix(_e324, _e325, vec4(_e327)), vec4(_e331));
+    let _e288 = (*uv_8);
+    let _e289 = (*interior);
+    at_5 = ((vec2(1f) + (_e288 * _e289)) - vec2(0.5f));
+    let _e295 = at_5;
+    low = floor(_e295);
+    let _e297 = at_5;
+    let _e298 = low;
+    f_5 = (_e297 - _e298);
+    let _e300 = (*corner);
+    let _e301 = low;
+    param_223 = (_e300 + _e301);
+    let _e303 = AtlasTexel_u0028_vf2_u003b((&param_223));
+    a_6 = _e303;
+    let _e304 = (*corner);
+    let _e305 = low;
+    param_224 = ((_e304 + _e305) + vec2<f32>(1f, 0f));
+    let _e308 = AtlasTexel_u0028_vf2_u003b((&param_224));
+    b_6 = _e308;
+    let _e309 = (*corner);
+    let _e310 = low;
+    param_225 = ((_e309 + _e310) + vec2<f32>(0f, 1f));
+    let _e313 = AtlasTexel_u0028_vf2_u003b((&param_225));
+    c_1 = _e313;
+    let _e314 = (*corner);
+    let _e315 = low;
+    param_226 = ((_e314 + _e315) + vec2<f32>(1f, 1f));
+    let _e318 = AtlasTexel_u0028_vf2_u003b((&param_226));
+    d_6 = _e318;
+    let _e319 = a_6;
+    let _e320 = b_6;
+    let _e322 = f_5[0u];
+    let _e325 = c_1;
+    let _e326 = d_6;
+    let _e328 = f_5[0u];
+    let _e332 = f_5[1u];
+    return mix(mix(_e319, _e320, vec4(_e322)), mix(_e325, _e326, vec4(_e328)), vec4(_e332));
 }
 
 fn ProbeOctahedral_u0028_vf3_u003b(direction_1: ptr<function, vec3<f32>>) -> vec2<f32> {
@@ -22049,29 +22203,29 @@ fn ProbeOctahedral_u0028_vf3_u003b(direction_1: ptr<function, vec3<f32>>) -> vec
     var n_6: vec3<f32>;
     var xy: vec2<f32>;
 
-    let _e278 = (*direction_1)[0u];
-    let _e281 = (*direction_1)[1u];
-    let _e285 = (*direction_1)[2u];
-    sum_1 = ((abs(_e278) + abs(_e281)) + abs(_e285));
-    let _e288 = sum_1;
-    if (_e288 <= 0f) {
+    let _e279 = (*direction_1)[0u];
+    let _e282 = (*direction_1)[1u];
+    let _e286 = (*direction_1)[2u];
+    sum_1 = ((abs(_e279) + abs(_e282)) + abs(_e286));
+    let _e289 = sum_1;
+    if (_e289 <= 0f) {
         return vec2<f32>(0.5f, 0.5f);
     }
-    let _e290 = (*direction_1);
-    let _e291 = sum_1;
-    n_6 = (_e290 / vec3(_e291));
-    let _e294 = n_6;
-    xy = _e294.xy;
-    let _e297 = n_6[2u];
-    if (_e297 < 0f) {
-        let _e300 = n_6[1u];
-        let _e304 = n_6[0u];
-        let _e309 = n_6[0u];
-        let _e313 = n_6[1u];
-        xy = vec2<f32>(((1f - abs(_e300)) * select(-1f, 1f, (_e304 >= 0f))), ((1f - abs(_e309)) * select(-1f, 1f, (_e313 >= 0f))));
+    let _e291 = (*direction_1);
+    let _e292 = sum_1;
+    n_6 = (_e291 / vec3(_e292));
+    let _e295 = n_6;
+    xy = _e295.xy;
+    let _e298 = n_6[2u];
+    if (_e298 < 0f) {
+        let _e301 = n_6[1u];
+        let _e305 = n_6[0u];
+        let _e310 = n_6[0u];
+        let _e314 = n_6[1u];
+        xy = vec2<f32>(((1f - abs(_e301)) * select(-1f, 1f, (_e305 >= 0f))), ((1f - abs(_e310)) * select(-1f, 1f, (_e314 >= 0f))));
     }
-    let _e318 = xy;
-    return ((_e318 * 0.5f) + vec2(0.5f));
+    let _e319 = xy;
+    return ((_e319 * 0.5f) + vec2(0.5f));
 }
 
 fn SampleIrradiance_u0028_vf3_u003b_vf3_u003b_vf3_u003b(world_5: ptr<function, vec3<f32>>, normal_1: ptr<function, vec3<f32>>, view_2: ptr<function, vec3<f32>>) -> vec3<f32> {
@@ -22119,190 +22273,190 @@ fn SampleIrradiance_u0028_vf3_u003b_vf3_u003b_vf3_u003b(world_5: ptr<function, v
     var param_235: vec2<f32>;
     var local_46: vec3<f32>;
 
-    let _e320 = irradiance_info.origin;
-    origin_2 = _e320.xyz;
-    let _e323 = irradiance_info.spacing;
-    spacing = _e323.xyz;
-    let _e326 = irradiance_info.counts;
-    counts = _e326.xyz;
-    let _e330 = irradiance_info.tiles[0u];
-    irradianceTile = _e330;
-    let _e333 = irradiance_info.tiles[1u];
-    depthTile = _e333;
-    let _e336 = irradiance_info.tiles[2u];
-    columns = _e336;
-    let _e339 = irradiance_info.tiles[3u];
-    momentsTop = _e339;
-    let _e340 = (*normal_1);
-    unit = normalize(_e340);
-    let _e342 = (*world_5);
-    let _e343 = unit;
-    let _e346 = irradiance_info.spacing[3u];
-    let _e349 = (*view_2);
-    let _e352 = irradiance_info.counts[3u];
-    biased = ((_e342 + (_e343 * _e346)) + (_e349 * _e352));
-    let _e355 = biased;
-    let _e356 = origin_2;
-    let _e358 = spacing;
-    grid_1 = ((_e355 - _e356) / _e358);
-    let _e360 = grid_1;
-    let _e362 = counts;
-    base_1 = clamp(floor(_e360), vec3<f32>(0f, 0f, 0f), (_e362 - vec3(2f)));
-    let _e366 = grid_1;
-    let _e367 = base_1;
-    f_6 = clamp((_e366 - _e367), vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
+    let _e321 = irradiance_info.origin;
+    origin_2 = _e321.xyz;
+    let _e324 = irradiance_info.spacing;
+    spacing = _e324.xyz;
+    let _e327 = irradiance_info.counts;
+    counts = _e327.xyz;
+    let _e331 = irradiance_info.tiles[0u];
+    irradianceTile = _e331;
+    let _e334 = irradiance_info.tiles[1u];
+    depthTile = _e334;
+    let _e337 = irradiance_info.tiles[2u];
+    columns = _e337;
+    let _e340 = irradiance_info.tiles[3u];
+    momentsTop = _e340;
+    let _e341 = (*normal_1);
+    unit = normalize(_e341);
+    let _e343 = (*world_5);
+    let _e344 = unit;
+    let _e347 = irradiance_info.spacing[3u];
+    let _e350 = (*view_2);
+    let _e353 = irradiance_info.counts[3u];
+    biased = ((_e343 + (_e344 * _e347)) + (_e350 * _e353));
+    let _e356 = biased;
+    let _e357 = origin_2;
+    let _e359 = spacing;
+    grid_1 = ((_e356 - _e357) / _e359);
+    let _e361 = grid_1;
+    let _e363 = counts;
+    base_1 = clamp(floor(_e361), vec3<f32>(0f, 0f, 0f), (_e363 - vec3(2f)));
+    let _e367 = grid_1;
+    let _e368 = base_1;
+    f_6 = clamp((_e367 - _e368), vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
     total_3 = vec3<f32>(0f, 0f, 0f);
     weights = 0f;
     corner_1 = 0i;
     loop {
-        let _e370 = corner_1;
-        if (_e370 < 8i) {
-            let _e372 = corner_1;
-            let _e375 = corner_1;
-            let _e380 = corner_1;
-            offset_3 = vec3<f32>(f32((_e372 & 1i)), f32(((_e375 >> bitcast<u32>(1i)) & 1i)), f32(((_e380 >> bitcast<u32>(2i)) & 1i)));
-            let _e386 = base_1;
-            let _e387 = offset_3;
-            cell_1 = (_e386 + _e387);
-            let _e390 = cell_1[2u];
-            let _e392 = counts[1u];
-            let _e395 = cell_1[1u];
-            let _e398 = counts[0u];
-            let _e401 = cell_1[0u];
-            probe = ((((_e390 * _e392) + _e395) * _e398) + _e401);
-            let _e403 = probe;
-            let _e404 = columns;
-            let _e409 = probe;
-            let _e410 = columns;
-            tile_4 = vec2<f32>((_e403 - (floor((_e403 / _e404)) * _e404)), floor((_e409 / _e410)));
-            let _e414 = tile_4;
-            let _e415 = irradianceTile;
-            irradianceCorner = (_e414 * (_e415 + 2f));
-            let _e419 = tile_4[0u];
-            let _e420 = depthTile;
-            let _e423 = momentsTop;
-            let _e425 = tile_4[1u];
-            let _e426 = depthTile;
-            momentCorner = vec2<f32>((_e419 * (_e420 + 2f)), (_e423 + (_e425 * (_e426 + 2f))));
-            let _e431 = irradianceCorner;
-            param_227 = (_e431 + vec2(1f));
-            let _e434 = AtlasTexel_u0028_vf2_u003b((&param_227));
-            if (_e434.w < 0.5f) {
+        let _e371 = corner_1;
+        if (_e371 < 8i) {
+            let _e373 = corner_1;
+            let _e376 = corner_1;
+            let _e381 = corner_1;
+            offset_3 = vec3<f32>(f32((_e373 & 1i)), f32(((_e376 >> bitcast<u32>(1i)) & 1i)), f32(((_e381 >> bitcast<u32>(2i)) & 1i)));
+            let _e387 = base_1;
+            let _e388 = offset_3;
+            cell_1 = (_e387 + _e388);
+            let _e391 = cell_1[2u];
+            let _e393 = counts[1u];
+            let _e396 = cell_1[1u];
+            let _e399 = counts[0u];
+            let _e402 = cell_1[0u];
+            probe = ((((_e391 * _e393) + _e396) * _e399) + _e402);
+            let _e404 = probe;
+            let _e405 = columns;
+            let _e410 = probe;
+            let _e411 = columns;
+            tile_4 = vec2<f32>((_e404 - (floor((_e404 / _e405)) * _e405)), floor((_e410 / _e411)));
+            let _e415 = tile_4;
+            let _e416 = irradianceTile;
+            irradianceCorner = (_e415 * (_e416 + 2f));
+            let _e420 = tile_4[0u];
+            let _e421 = depthTile;
+            let _e424 = momentsTop;
+            let _e426 = tile_4[1u];
+            let _e427 = depthTile;
+            momentCorner = vec2<f32>((_e420 * (_e421 + 2f)), (_e424 + (_e426 * (_e427 + 2f))));
+            let _e432 = irradianceCorner;
+            param_227 = (_e432 + vec2(1f));
+            let _e435 = AtlasTexel_u0028_vf2_u003b((&param_227));
+            if (_e435.w < 0.5f) {
                 continue;
             }
-            let _e437 = f_6;
-            let _e439 = f_6;
-            let _e440 = offset_3;
-            trilinear = mix((vec3<f32>(1f, 1f, 1f) - _e437), _e439, _e440);
-            let _e443 = trilinear[0u];
-            let _e445 = trilinear[1u];
-            let _e448 = trilinear[2u];
-            weight_3 = max(((_e443 * _e445) * _e448), 0.001f);
-            let _e451 = origin_2;
-            let _e452 = spacing;
-            let _e453 = cell_1;
-            probePosition = (_e451 + (_e452 * _e453));
-            let _e456 = probePosition;
-            let _e457 = biased;
-            toProbe = (_e456 - _e457);
-            let _e459 = toProbe;
-            distance_4 = length(_e459);
-            let _e461 = distance_4;
-            if (_e461 > 0.000001f) {
-                let _e463 = toProbe;
-                let _e464 = distance_4;
-                direction_2 = (_e463 / vec3(_e464));
-                let _e467 = unit;
-                let _e468 = probePosition;
-                let _e469 = (*world_5);
-                facing = ((dot(_e467, normalize((_e468 - _e469))) * 0.5f) + 0.5f);
-                let _e475 = facing;
+            let _e438 = f_6;
+            let _e440 = f_6;
+            let _e441 = offset_3;
+            trilinear = mix((vec3<f32>(1f, 1f, 1f) - _e438), _e440, _e441);
+            let _e444 = trilinear[0u];
+            let _e446 = trilinear[1u];
+            let _e449 = trilinear[2u];
+            weight_3 = max(((_e444 * _e446) * _e449), 0.001f);
+            let _e452 = origin_2;
+            let _e453 = spacing;
+            let _e454 = cell_1;
+            probePosition = (_e452 + (_e453 * _e454));
+            let _e457 = probePosition;
+            let _e458 = biased;
+            toProbe = (_e457 - _e458);
+            let _e460 = toProbe;
+            distance_4 = length(_e460);
+            let _e462 = distance_4;
+            if (_e462 > 0.000001f) {
+                let _e464 = toProbe;
+                let _e465 = distance_4;
+                direction_2 = (_e464 / vec3(_e465));
+                let _e468 = unit;
+                let _e469 = probePosition;
+                let _e470 = (*world_5);
+                facing = ((dot(_e468, normalize((_e469 - _e470))) * 0.5f) + 0.5f);
                 let _e476 = facing;
-                probeWeight = ((_e475 * _e476) + 0.2f);
-                let _e479 = direction_2;
-                param_228 = -(_e479);
-                let _e481 = ProbeOctahedral_u0028_vf3_u003b((&param_228));
-                let _e482 = momentCorner;
-                param_229 = _e482;
-                let _e483 = depthTile;
-                param_230 = _e483;
-                param_231 = _e481;
-                let _e484 = TileBilinear_u0028_vf2_u003b_f1_u003b_vf2_u003b((&param_229), (&param_230), (&param_231));
-                moments_3 = _e484.xy;
+                let _e477 = facing;
+                probeWeight = ((_e476 * _e477) + 0.2f);
+                let _e480 = direction_2;
+                param_228 = -(_e480);
+                let _e482 = ProbeOctahedral_u0028_vf3_u003b((&param_228));
+                let _e483 = momentCorner;
+                param_229 = _e483;
+                let _e484 = depthTile;
+                param_230 = _e484;
+                param_231 = _e482;
+                let _e485 = TileBilinear_u0028_vf2_u003b_f1_u003b_vf2_u003b((&param_229), (&param_230), (&param_231));
+                moments_3 = _e485.xy;
                 chebyshev = 1f;
-                let _e486 = distance_4;
-                let _e488 = moments_3[0u];
-                if (_e486 > _e488) {
-                    let _e491 = moments_3[1u];
-                    let _e493 = moments_3[0u];
-                    let _e495 = moments_3[0u];
-                    variance_2 = max((_e491 - (_e493 * _e495)), 0.000001f);
-                    let _e499 = distance_4;
-                    let _e501 = moments_3[0u];
-                    difference = (_e499 - _e501);
-                    let _e503 = variance_2;
+                let _e487 = distance_4;
+                let _e489 = moments_3[0u];
+                if (_e487 > _e489) {
+                    let _e492 = moments_3[1u];
+                    let _e494 = moments_3[0u];
+                    let _e496 = moments_3[0u];
+                    variance_2 = max((_e492 - (_e494 * _e496)), 0.000001f);
+                    let _e500 = distance_4;
+                    let _e502 = moments_3[0u];
+                    difference = (_e500 - _e502);
                     let _e504 = variance_2;
-                    let _e505 = difference;
+                    let _e505 = variance_2;
                     let _e506 = difference;
-                    chebyshev = (_e503 / (_e504 + (_e505 * _e506)));
-                    let _e510 = chebyshev;
+                    let _e507 = difference;
+                    chebyshev = (_e504 / (_e505 + (_e506 * _e507)));
                     let _e511 = chebyshev;
-                    let _e513 = chebyshev;
-                    chebyshev = ((_e510 * _e511) * _e513);
+                    let _e512 = chebyshev;
+                    let _e514 = chebyshev;
+                    chebyshev = ((_e511 * _e512) * _e514);
                 }
-                let _e515 = probeWeight;
-                let _e516 = chebyshev;
-                probeWeight = max((_e515 * max(_e516, 0.05f)), 0.000001f);
-                let _e520 = probeWeight;
-                if (_e520 < 0.2f) {
-                    let _e522 = probeWeight;
+                let _e516 = probeWeight;
+                let _e517 = chebyshev;
+                probeWeight = max((_e516 * max(_e517, 0.05f)), 0.000001f);
+                let _e521 = probeWeight;
+                if (_e521 < 0.2f) {
                     let _e523 = probeWeight;
-                    let _e526 = probeWeight;
-                    probeWeight = (_e526 * ((_e522 * _e523) * 25f));
+                    let _e524 = probeWeight;
+                    let _e527 = probeWeight;
+                    probeWeight = (_e527 * ((_e523 * _e524) * 25f));
                 }
-                let _e528 = probeWeight;
-                let _e529 = weight_3;
-                weight_3 = (_e529 * _e528);
-            }
-            let _e531 = unit;
-            param_232 = _e531;
-            let _e532 = ProbeOctahedral_u0028_vf3_u003b((&param_232));
-            let _e533 = irradianceCorner;
-            param_233 = _e533;
-            let _e534 = irradianceTile;
-            param_234 = _e534;
-            param_235 = _e532;
-            let _e535 = TileBilinear_u0028_vf2_u003b_f1_u003b_vf2_u003b((&param_233), (&param_234), (&param_235));
-            let _e537 = weight_3;
-            let _e539 = total_3;
-            total_3 = (_e539 + (_e535.xyz * _e537));
-            let _e541 = weight_3;
-            let _e542 = weights;
-            weights = (_e542 + _e541);
+                let _e529 = probeWeight;
+                let _e530 = weight_3;
+                weight_3 = (_e530 * _e529);
+            }
+            let _e532 = unit;
+            param_232 = _e532;
+            let _e533 = ProbeOctahedral_u0028_vf3_u003b((&param_232));
+            let _e534 = irradianceCorner;
+            param_233 = _e534;
+            let _e535 = irradianceTile;
+            param_234 = _e535;
+            param_235 = _e533;
+            let _e536 = TileBilinear_u0028_vf2_u003b_f1_u003b_vf2_u003b((&param_233), (&param_234), (&param_235));
+            let _e538 = weight_3;
+            let _e540 = total_3;
+            total_3 = (_e540 + (_e536.xyz * _e538));
+            let _e542 = weight_3;
+            let _e543 = weights;
+            weights = (_e543 + _e542);
             continue;
         } else {
             break;
         }
         continuing {
-            let _e544 = corner_1;
-            corner_1 = (_e544 + 1i);
+            let _e545 = corner_1;
+            corner_1 = (_e545 + 1i);
         }
     }
-    let _e546 = weights;
-    if (_e546 > 0f) {
-        let _e548 = total_3;
-        let _e549 = weights;
-        local_46 = (_e548 / vec3(_e549));
+    let _e547 = weights;
+    if (_e547 > 0f) {
+        let _e549 = total_3;
+        let _e550 = weights;
+        local_46 = (_e549 / vec3(_e550));
     } else {
         local_46 = vec3<f32>(0f, 0f, 0f);
     }
-    let _e552 = local_46;
-    return _e552;
+    let _e553 = local_46;
+    return _e553;
 }
 
 fn IrradianceEnabled_u0028_() -> bool {
-    let _e275 = irradiance_info.origin[3u];
-    return (_e275 > 0.5f);
+    let _e276 = irradiance_info.origin[3u];
+    return (_e276 > 0.5f);
 }
 
 fn ApplyCommonMaps_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_17: ptr<function, Surface>) {
@@ -22313,33 +22467,33 @@ fn ApplyCommonMaps_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d
     var param_240: Surface;
     var param_241: Surface;
 
-    let _e280 = IrradianceEnabled_u0028_();
-    if _e280 {
-        let _e281 = v_world_position_1;
-        param_236 = _e281;
-        let _e283 = (*s_17).n;
-        param_237 = _e283;
-        let _e285 = (*s_17).v;
-        param_238 = _e285;
-        let _e286 = SampleIrradiance_u0028_vf3_u003b_vf3_u003b_vf3_u003b((&param_236), (&param_237), (&param_238));
-        let _e289 = frag_info.material[2u];
-        (*s_17).ambient = (_e286 * _e289);
-    }
-    let _e292 = (*s_17);
-    param_239 = _e292;
+    let _e281 = IrradianceEnabled_u0028_();
+    if _e281 {
+        let _e282 = v_world_position_1;
+        param_236 = _e282;
+        let _e284 = (*s_17).n;
+        param_237 = _e284;
+        let _e286 = (*s_17).v;
+        param_238 = _e286;
+        let _e287 = SampleIrradiance_u0028_vf3_u003b_vf3_u003b_vf3_u003b((&param_236), (&param_237), (&param_238));
+        let _e290 = frag_info.material[2u];
+        (*s_17).ambient = (_e287 * _e290);
+    }
+    let _e293 = (*s_17);
+    param_239 = _e293;
     ApplyNormalMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_239));
-    let _e293 = param_239;
-    (*s_17) = _e293;
-    let _e294 = (*s_17);
-    param_240 = _e294;
+    let _e294 = param_239;
+    (*s_17) = _e294;
+    let _e295 = (*s_17);
+    param_240 = _e295;
     ApplyOcclusionMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_240));
-    let _e295 = param_240;
-    (*s_17) = _e295;
-    let _e296 = (*s_17);
-    param_241 = _e296;
+    let _e296 = param_240;
+    (*s_17) = _e296;
+    let _e297 = (*s_17);
+    param_241 = _e297;
     ApplyEmissiveMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_241));
-    let _e297 = param_241;
-    (*s_17) = _e297;
+    let _e298 = param_241;
+    (*s_17) = _e298;
     return;
 }
 
@@ -22355,108 +22509,108 @@ fn ReadLayers_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_
     var local_48: vec3<f32>;
     var fc: f32;
 
-    let _e284 = v_texcoord_1;
-    let _e285 = MaterialLodBias_u0028_();
-    let _e286 = textureSampleBias(coat_texture_tex, coat_texture_smp, _e284, _e285);
-    coatTexel = _e286;
-    let _e287 = v_texcoord_1;
-    let _e288 = MaterialLodBias_u0028_();
-    let _e289 = textureSampleBias(sheen_texture_tex, sheen_texture_smp, _e287, _e288);
-    sheenTexel = _e289;
-    let _e291 = layer_info.sheen;
-    let _e293 = sheenTexel;
-    param_242 = _e293.xyz;
-    let _e295 = SrgbToLinear_u0028_vf3_u003b((&param_242));
-    g_sheen = (_e291.xyz * _e295);
-    let _e299 = layer_info.sheen[3u];
-    let _e301 = sheenTexel[3u];
-    g_sheen_roughness = clamp((_e299 * _e301), 0.07f, 1f);
-    let _e306 = layer_info.coat[2u];
-    ior_3 = max(_e306, 1f);
-    let _e308 = IorInfinite_u0028_();
-    if _e308 {
+    let _e285 = v_texcoord_1;
+    let _e286 = MaterialLodBias_u0028_();
+    let _e287 = textureSampleBias(coat_texture_tex, coat_texture_smp, _e285, _e286);
+    coatTexel = _e287;
+    let _e288 = v_texcoord_1;
+    let _e289 = MaterialLodBias_u0028_();
+    let _e290 = textureSampleBias(sheen_texture_tex, sheen_texture_smp, _e288, _e289);
+    sheenTexel = _e290;
+    let _e292 = layer_info.sheen;
+    let _e294 = sheenTexel;
+    param_242 = _e294.xyz;
+    let _e296 = SrgbToLinear_u0028_vf3_u003b((&param_242));
+    g_sheen = (_e292.xyz * _e296);
+    let _e300 = layer_info.sheen[3u];
+    let _e302 = sheenTexel[3u];
+    g_sheen_roughness = clamp((_e300 * _e302), 0.07f, 1f);
+    let _e307 = layer_info.coat[2u];
+    ior_3 = max(_e307, 1f);
+    let _e309 = IorInfinite_u0028_();
+    if _e309 {
         local_47 = 1f;
     } else {
-        let _e309 = ior_3;
-        let _e311 = ior_3;
-        local_47 = ((_e309 - 1f) / (_e311 + 1f));
+        let _e310 = ior_3;
+        let _e312 = ior_3;
+        local_47 = ((_e310 - 1f) / (_e312 + 1f));
     }
-    let _e314 = local_47;
-    r_5 = _e314;
-    let _e315 = r_5;
+    let _e315 = local_47;
+    r_5 = _e315;
     let _e316 = r_5;
-    let _e320 = layer_info.specular;
-    let _e326 = layer_info.specular[3u];
-    g_f0_dielectric = (min((vec3((_e315 * _e316)) * _e320.xyz), vec3<f32>(1f, 1f, 1f)) * _e326);
-    let _e330 = layer_info.specular[3u];
-    g_f90_ = _e330;
-    let _e333 = layer_info.coat[0u];
-    let _e335 = coatTexel[0u];
-    g_coat = clamp((_e333 * _e335), 0f, 1f);
-    let _e340 = layer_info.coat[1u];
-    let _e342 = coatTexel[1u];
-    g_coat_roughness = clamp((_e340 * _e342), 0.02f, 1f);
-    let _e347 = layer_info.transmission[0u];
-    let _e349 = coatTexel[2u];
-    g_transmission = clamp((_e347 * _e349), 0f, 1f);
-    let _e354 = layer_info.transmission[1u];
-    let _e356 = coatTexel[3u];
-    g_thickness = max((_e354 * _e356), 0f);
-    let _e361 = layer_info.attenuation[3u];
-    let _e363 = g_thickness;
-    if ((_e361 > 0.5f) && (_e363 > 0f)) {
-        let _e367 = (*s_18).v;
-        let _e370 = (*s_18).n;
-        let _e371 = RefractionIor_u0028_();
-        bent = refract(-(_e367), _e370, (1f / _e371));
-        let _e374 = g_thickness;
-        let _e376 = (*s_18).n;
-        let _e377 = bent;
-        let _e382 = g_thickness;
-        g_thickness = max((_e374 * max(-(dot(_e376, _e377)), 0f)), (0.0001f * _e382));
-    }
-    let _e387 = layer_info.transmission[2u];
-    distance_5 = _e387;
-    let _e388 = distance_5;
-    if (_e388 > 0f) {
-        let _e391 = layer_info.attenuation;
-        let _e394 = g_thickness;
-        let _e395 = distance_5;
-        local_48 = pow(max(_e391.xyz, vec3<f32>(0.0001f, 0.0001f, 0.0001f)), vec3((_e394 / _e395)));
+    let _e317 = r_5;
+    let _e321 = layer_info.specular;
+    let _e327 = layer_info.specular[3u];
+    g_f0_dielectric = (min((vec3((_e316 * _e317)) * _e321.xyz), vec3<f32>(1f, 1f, 1f)) * _e327);
+    let _e331 = layer_info.specular[3u];
+    g_f90_ = _e331;
+    let _e334 = layer_info.coat[0u];
+    let _e336 = coatTexel[0u];
+    g_coat = clamp((_e334 * _e336), 0f, 1f);
+    let _e341 = layer_info.coat[1u];
+    let _e343 = coatTexel[1u];
+    g_coat_roughness = clamp((_e341 * _e343), 0.02f, 1f);
+    let _e348 = layer_info.transmission[0u];
+    let _e350 = coatTexel[2u];
+    g_transmission = clamp((_e348 * _e350), 0f, 1f);
+    let _e355 = layer_info.transmission[1u];
+    let _e357 = coatTexel[3u];
+    g_thickness = max((_e355 * _e357), 0f);
+    let _e362 = layer_info.attenuation[3u];
+    let _e364 = g_thickness;
+    if ((_e362 > 0.5f) && (_e364 > 0f)) {
+        let _e368 = (*s_18).v;
+        let _e371 = (*s_18).n;
+        let _e372 = RefractionIor_u0028_();
+        bent = refract(-(_e368), _e371, (1f / _e372));
+        let _e375 = g_thickness;
+        let _e377 = (*s_18).n;
+        let _e378 = bent;
+        let _e383 = g_thickness;
+        g_thickness = max((_e375 * max(-(dot(_e377, _e378)), 0f)), (0.0001f * _e383));
+    }
+    let _e388 = layer_info.transmission[2u];
+    distance_5 = _e388;
+    let _e389 = distance_5;
+    if (_e389 > 0f) {
+        let _e392 = layer_info.attenuation;
+        let _e395 = g_thickness;
+        let _e396 = distance_5;
+        local_48 = pow(max(_e392.xyz, vec3<f32>(0.0001f, 0.0001f, 0.0001f)), vec3((_e395 / _e396)));
     } else {
         local_48 = vec3<f32>(1f, 1f, 1f);
     }
-    let _e399 = local_48;
-    g_transmittance = _e399;
-    let _e402 = layer_info.iridescence[0u];
-    g_iridescence = clamp(_e402, 0f, 1f);
-    let _e405 = (*s_18).n;
-    g_coat_n = _e405;
-    let _e407 = (*s_18).n;
-    let _e409 = (*s_18).v;
-    g_coat_n_dot_v = max(dot(_e407, _e409), 0.0001f);
-    let _e412 = g_coat_n_dot_v;
-    fc = (0.04f + (0.96f * pow((1f - _e412), 5f)));
-    let _e417 = g_coat;
-    let _e418 = fc;
-    g_coat_through = (1f - (_e417 * _e418));
+    let _e400 = local_48;
+    g_transmittance = _e400;
+    let _e403 = layer_info.iridescence[0u];
+    g_iridescence = clamp(_e403, 0f, 1f);
+    let _e406 = (*s_18).n;
+    g_coat_n = _e406;
+    let _e408 = (*s_18).n;
+    let _e410 = (*s_18).v;
+    g_coat_n_dot_v = max(dot(_e408, _e410), 0.0001f);
+    let _e413 = g_coat_n_dot_v;
+    fc = (0.04f + (0.96f * pow((1f - _e413), 5f)));
+    let _e418 = g_coat;
+    let _e419 = fc;
+    g_coat_through = (1f - (_e418 * _e419));
     return;
 }
 
 fn TowardsEye_u0028_() -> vec3<f32> {
     var local_49: vec3<f32>;
 
-    let _e274 = Orthographic_u0028_();
-    if _e274 {
-        let _e276 = fog_info.forward;
-        local_49 = -(_e276.xyz);
+    let _e275 = Orthographic_u0028_();
+    if _e275 {
+        let _e277 = fog_info.forward;
+        local_49 = -(_e277.xyz);
     } else {
-        let _e280 = fog_info.eye;
-        let _e282 = v_world_position_1;
-        local_49 = normalize((_e280.xyz - _e282));
+        let _e281 = fog_info.eye;
+        let _e283 = v_world_position_1;
+        local_49 = normalize((_e281.xyz - _e283));
     }
-    let _e285 = local_49;
-    return _e285;
+    let _e286 = local_49;
+    return _e286;
 }
 
 fn ReadSurface_u0028_() -> Surface {
@@ -22471,89 +22625,89 @@ fn ReadSurface_u0028_() -> Surface {
     var noise_1: f32;
 
     param_243 = 0i;
-    let _e282 = MapUv_u0028_i1_u003b((&param_243));
-    let _e283 = MaterialLodBias_u0028_();
-    let _e284 = textureSampleBias(base_color_texture_tex, base_color_texture_smp, _e282, _e283);
-    texel_6 = _e284;
-    let _e285 = texel_6;
-    param_244 = _e285.xyz;
-    let _e287 = SrgbToLinear_u0028_vf3_u003b((&param_244));
-    let _e289 = frag_info.base_color;
-    param_245 = _e289.xyz;
-    let _e291 = SrgbToLinear_u0028_vf3_u003b((&param_245));
-    let _e293 = v_color_1;
-    s_19.albedo = ((_e287 * _e291) * _e293.xyz);
-    let _e298 = texel_6[3u];
-    let _e301 = frag_info.base_color[3u];
-    let _e304 = v_color_1[3u];
-    s_19.alpha = ((_e298 * _e301) * _e304);
-    let _e308 = s_19.albedo;
-    g_albedo = _e308;
-    let _e311 = frag_info.material2_[0u];
-    cutoff = _e311;
-    let _e312 = cutoff;
-    if (_e312 > 1f) {
-        let _e314 = cutoff;
-        edge = (_e314 - 1f);
-        let _e317 = s_19.alpha;
-        let _e318 = edge;
-        let _e321 = s_19.alpha;
-        let _e322 = fwidth(_e321);
-        s_19.alpha = clamp((((_e317 - _e318) / max(_e322, 0.0001f)) + 0.5f), 0f, 1f);
-    } else {
-        let _e328 = cutoff;
-        if (_e328 >= 0f) {
-            let _e331 = s_19.alpha;
-            let _e332 = cutoff;
-            if (_e331 < _e332) {
+    let _e283 = MapUv_u0028_i1_u003b((&param_243));
+    let _e284 = MaterialLodBias_u0028_();
+    let _e285 = textureSampleBias(base_color_texture_tex, base_color_texture_smp, _e283, _e284);
+    texel_6 = _e285;
+    let _e286 = texel_6;
+    param_244 = _e286.xyz;
+    let _e288 = SrgbToLinear_u0028_vf3_u003b((&param_244));
+    let _e290 = frag_info.base_color;
+    param_245 = _e290.xyz;
+    let _e292 = SrgbToLinear_u0028_vf3_u003b((&param_245));
+    let _e294 = v_color_1;
+    s_19.albedo = ((_e288 * _e292) * _e294.xyz);
+    let _e299 = texel_6[3u];
+    let _e302 = frag_info.base_color[3u];
+    let _e305 = v_color_1[3u];
+    s_19.alpha = ((_e299 * _e302) * _e305);
+    let _e309 = s_19.albedo;
+    g_albedo = _e309;
+    let _e312 = frag_info.material2_[0u];
+    cutoff = _e312;
+    let _e313 = cutoff;
+    if (_e313 > 1f) {
+        let _e315 = cutoff;
+        edge = (_e315 - 1f);
+        let _e318 = s_19.alpha;
+        let _e319 = edge;
+        let _e322 = s_19.alpha;
+        let _e323 = fwidth(_e322);
+        s_19.alpha = clamp((((_e318 - _e319) / max(_e323, 0.0001f)) + 0.5f), 0f, 1f);
+    } else {
+        let _e329 = cutoff;
+        if (_e329 >= 0f) {
+            let _e332 = s_19.alpha;
+            let _e333 = cutoff;
+            if (_e332 < _e333) {
                 discard;
             }
             s_19.alpha = 1f;
         } else {
-            let _e335 = cutoff;
-            if (_e335 < -1.5f) {
-                let _e337 = v_world_position_1;
-                anchored = floor((_e337 * 16f));
-                let _e340 = anchored;
-                noise_1 = fract((sin(dot(_e340, vec3<f32>(12.9898f, 78.233f, 37.719f))) * 43758.547f));
-                let _e346 = s_19.alpha;
-                let _e347 = noise_1;
-                if (_e346 < _e347) {
+            let _e336 = cutoff;
+            if (_e336 < -1.5f) {
+                let _e338 = v_world_position_1;
+                anchored = floor((_e338 * 16f));
+                let _e341 = anchored;
+                noise_1 = fract((sin(dot(_e341, vec3<f32>(12.9898f, 78.233f, 37.719f))) * 43758.547f));
+                let _e347 = s_19.alpha;
+                let _e348 = noise_1;
+                if (_e347 < _e348) {
                     discard;
                 }
             }
         }
     }
-    let _e349 = cutoff;
-    let _e351 = cutoff;
-    g_premultiply = ((_e349 < 0f) && (_e351 > -0.75f));
-    let _e354 = v_normal_1;
-    s_19.n = normalize(_e354);
-    let _e357 = gl_FrontFacing_1;
-    if !(_e357) {
-        let _e360 = s_19.n;
-        s_19.n = -(_e360);
-    }
-    let _e363 = TowardsEye_u0028_();
-    s_19.v = _e363;
-    let _e366 = s_19.n;
-    let _e368 = s_19.v;
-    s_19.n_dot_v = max(dot(_e366, _e368), 0.0001f);
-    let _e374 = frag_info.material[0u];
-    s_19.metallic = clamp(_e374, 0f, 1f);
-    let _e379 = frag_info.material[1u];
-    s_19.roughness = clamp(_e379, 0.02f, 1f);
-    let _e383 = frag_info.ambient_ground;
-    let _e386 = frag_info.ambient_sky;
-    let _e390 = s_19.n[1u];
-    let _e397 = frag_info.material[2u];
-    s_19.ambient = (mix(_e383.xyz, _e386.xyz, vec3(((_e390 * 0.5f) + 0.5f))) * _e397);
-    let _e402 = frag_info.frame_params[0u];
-    s_19.exposure = max(_e402, 0f);
+    let _e350 = cutoff;
+    let _e352 = cutoff;
+    g_premultiply = ((_e350 < 0f) && (_e352 > -0.75f));
+    let _e355 = v_normal_1;
+    s_19.n = normalize(_e355);
+    let _e358 = gl_FrontFacing_1;
+    if !(_e358) {
+        let _e361 = s_19.n;
+        s_19.n = -(_e361);
+    }
+    let _e364 = TowardsEye_u0028_();
+    s_19.v = _e364;
+    let _e367 = s_19.n;
+    let _e369 = s_19.v;
+    s_19.n_dot_v = max(dot(_e367, _e369), 0.0001f);
+    let _e375 = frag_info.material[0u];
+    s_19.metallic = clamp(_e375, 0f, 1f);
+    let _e380 = frag_info.material[1u];
+    s_19.roughness = clamp(_e380, 0.02f, 1f);
+    let _e384 = frag_info.ambient_ground;
+    let _e387 = frag_info.ambient_sky;
+    let _e391 = s_19.n[1u];
+    let _e398 = frag_info.material[2u];
+    s_19.ambient = (mix(_e384.xyz, _e387.xyz, vec3(((_e391 * 0.5f) + 0.5f))) * _e398);
+    let _e403 = frag_info.frame_params[0u];
+    s_19.exposure = max(_e403, 0f);
     s_19.occlusion = 1f;
     s_19.emissive = vec3<f32>(0f, 0f, 0f);
-    let _e407 = s_19;
-    return _e407;
+    let _e408 = s_19;
+    return _e408;
 }
 
 fn main_1() {
@@ -22642,274 +22796,274 @@ fn main_1() {
     g_iridescence = 0f;
     g_irid_fresnel = vec3<f32>(0.04f, 0.04f, 0.04f);
     g_pane = false;
-    let _e329 = ReadSurface_u0028_();
-    s_20 = _e329;
-    let _e330 = s_20;
-    param_246 = _e330;
-    ReadLayers_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_246));
+    let _e330 = ReadSurface_u0028_();
+    s_20 = _e330;
     let _e331 = s_20;
-    param_247 = _e331;
+    param_246 = _e331;
+    ReadLayers_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_246));
+    let _e332 = s_20;
+    param_247 = _e332;
     ApplyCommonMaps_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_247));
-    let _e332 = param_247;
-    s_20 = _e332;
-    let _e333 = s_20;
-    param_248 = _e333;
+    let _e333 = param_247;
+    s_20 = _e333;
+    let _e334 = s_20;
+    param_248 = _e334;
     ApplyMetallicRoughnessMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_248));
-    let _e334 = param_248;
-    s_20 = _e334;
-    let _e335 = s_20;
-    param_249 = _e335;
-    ReadLayersOnMaps_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_249));
+    let _e335 = param_248;
+    s_20 = _e335;
     let _e336 = s_20;
-    param_250 = _e336;
+    param_249 = _e336;
+    ReadLayersOnMaps_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_249));
+    let _e337 = s_20;
+    param_250 = _e337;
     ReadIridescence_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_250));
-    let _e338 = s_20.metallic;
-    metallic = clamp(_e338, 0f, 1f);
-    let _e341 = s_20.albedo;
-    let _e342 = metallic;
-    diffuseColor_1 = (_e341 * (1f - _e342));
-    let _e345 = EonDiffuse_u0028_();
-    if _e345 {
-        let _e346 = diffuseColor_1;
-        param_251 = _e346;
-        let _e348 = s_20.roughness;
-        param_252 = _e348;
-        let _e350 = s_20.n_dot_v;
-        param_253 = _e350;
-        let _e351 = EonAlbedo_u0028_vf3_u003b_f1_u003b_f1_u003b((&param_251), (&param_252), (&param_253));
-        diffuseColor_1 = _e351;
-    }
-    let _e352 = diffuseColor_1;
-    let _e354 = s_20.ambient;
-    let _e357 = s_20.occlusion;
-    ambient = ((_e352 * _e354) * _e357);
-    let _e359 = g_premultiply;
-    let _e360 = g_transmission;
-    let _e363 = g_thickness;
-    g_pane = ((_e359 && (_e360 > 0f)) && (_e363 <= 0f));
-    let _e366 = SceneColourBound_u0028_();
-    let _e367 = g_pane;
-    let _e369 = g_transmittance;
-    let _e372 = g_transmission;
-    let _e375 = ambient;
-    ambient = (_e375 * mix(vec3<f32>(1f, 1f, 1f), select(_e369, vec3<f32>(0f, 0f, 0f), vec3((_e366 || _e367))), vec3(_e372)));
-    let _e379 = frag_info.frame_params[3u];
-    levels_1 = _e379;
+    let _e339 = s_20.metallic;
+    metallic = clamp(_e339, 0f, 1f);
+    let _e342 = s_20.albedo;
+    let _e343 = metallic;
+    diffuseColor_1 = (_e342 * (1f - _e343));
+    let _e346 = EonDiffuse_u0028_();
+    if _e346 {
+        let _e347 = diffuseColor_1;
+        param_251 = _e347;
+        let _e349 = s_20.roughness;
+        param_252 = _e349;
+        let _e351 = s_20.n_dot_v;
+        param_253 = _e351;
+        let _e352 = EonAlbedo_u0028_vf3_u003b_f1_u003b_f1_u003b((&param_251), (&param_252), (&param_253));
+        diffuseColor_1 = _e352;
+    }
+    let _e353 = diffuseColor_1;
+    let _e355 = s_20.ambient;
+    let _e358 = s_20.occlusion;
+    ambient = ((_e353 * _e355) * _e358);
+    let _e360 = g_premultiply;
+    let _e361 = g_transmission;
+    let _e364 = g_thickness;
+    g_pane = ((_e360 && (_e361 > 0f)) && (_e364 <= 0f));
+    let _e367 = SceneColourBound_u0028_();
+    let _e368 = g_pane;
+    let _e370 = g_transmittance;
+    let _e373 = g_transmission;
+    let _e376 = ambient;
+    ambient = (_e376 * mix(vec3<f32>(1f, 1f, 1f), select(_e370, vec3<f32>(0f, 0f, 0f), vec3((_e367 || _e368))), vec3(_e373)));
+    let _e380 = frag_info.frame_params[3u];
+    levels_1 = _e380;
     coatAmbient = vec3<f32>(0f, 0f, 0f);
-    let _e381 = s_20.ambient;
-    sheenIncoming = _e381;
-    let _e382 = levels_1;
-    if (_e382 > 0f) {
-        let _e384 = g_f0_dielectric;
-        let _e386 = s_20.albedo;
-        let _e387 = metallic;
-        f0_4 = mix(_e384, _e386, vec3(_e387));
-        let _e390 = g_f90_;
-        let _e391 = metallic;
-        f90_2 = mix(_e390, 1f, _e391);
-        let _e394 = s_20.n;
-        bent_1 = _e394;
-        let _e395 = g_aniso;
-        if (_e395 > 0f) {
-            let _e397 = g_aniso_t;
-            let _e399 = s_20.v;
-            across = cross(_e397, _e399);
-            let _e401 = across;
-            let _e402 = g_aniso_t;
-            anisoN = cross(_e401, _e402);
-            let _e404 = g_aniso;
-            let _e406 = s_20.roughness;
-            bend = (1f - (_e404 * (1f - _e406)));
-            let _e410 = bend;
+    let _e382 = s_20.ambient;
+    sheenIncoming = _e382;
+    let _e383 = levels_1;
+    if (_e383 > 0f) {
+        let _e385 = g_f0_dielectric;
+        let _e387 = s_20.albedo;
+        let _e388 = metallic;
+        f0_4 = mix(_e385, _e387, vec3(_e388));
+        let _e391 = g_f90_;
+        let _e392 = metallic;
+        f90_2 = mix(_e391, 1f, _e392);
+        let _e395 = s_20.n;
+        bent_1 = _e395;
+        let _e396 = g_aniso;
+        if (_e396 > 0f) {
+            let _e398 = g_aniso_t;
+            let _e400 = s_20.v;
+            across = cross(_e398, _e400);
+            let _e402 = across;
+            let _e403 = g_aniso_t;
+            anisoN = cross(_e402, _e403);
+            let _e405 = g_aniso;
+            let _e407 = s_20.roughness;
+            bend = (1f - (_e405 * (1f - _e407)));
             let _e411 = bend;
-            let _e413 = bend;
-            let _e415 = bend;
-            bend4_ = (((_e410 * _e411) * _e413) * _e415);
-            let _e417 = anisoN;
-            let _e419 = s_20.n;
-            let _e420 = bend4_;
-            bent_1 = normalize(mix(_e417, _e419, vec3(_e420)));
-        }
-        let _e425 = s_20.v;
-        let _e427 = bent_1;
-        reflected = reflect(-(_e425), _e427);
-        let _e430 = s_20.n;
-        let _e431 = levels_1;
-        let _e432 = textureSampleLevel(environment_texture_tex, environment_texture_smp, _e430, _e431);
-        irradiance = _e432.xyz;
-        let _e434 = reflected;
-        let _e436 = s_20.roughness;
-        let _e437 = levels_1;
-        let _e439 = textureSampleLevel(environment_texture_tex, environment_texture_smp, _e434, (_e436 * _e437));
-        prefiltered = _e439.xyz;
-        let _e442 = s_20.roughness;
-        param_254 = _e442;
-        let _e444 = s_20.n_dot_v;
-        param_255 = _e444;
-        let _e445 = EnvBrdf_u0028_f1_u003b_f1_u003b((&param_254), (&param_255));
-        ab_4 = _e445;
-        let _e446 = f0_4;
-        let _e447 = g_irid_fresnel;
-        let _e448 = g_iridescence;
-        let _e452 = ab_4[0u];
-        let _e454 = f90_2;
-        let _e456 = ab_4[1u];
-        single_1 = ((mix(_e446, _e447, vec3(_e448)) * _e452) + vec3((_e454 * _e456)));
-        let _e460 = prefiltered;
-        let _e461 = single_1;
-        specular_1 = (_e460 * _e461);
-        let _e463 = EnergyCompensation_u0028_();
-        if _e463 {
-            let _e465 = ab_4[0u];
-            let _e467 = ab_4[1u];
-            missed = (1f - (_e465 + _e467));
-            let _e470 = f0_4;
+            let _e412 = bend;
+            let _e414 = bend;
+            let _e416 = bend;
+            bend4_ = (((_e411 * _e412) * _e414) * _e416);
+            let _e418 = anisoN;
+            let _e420 = s_20.n;
+            let _e421 = bend4_;
+            bent_1 = normalize(mix(_e418, _e420, vec3(_e421)));
+        }
+        let _e426 = s_20.v;
+        let _e428 = bent_1;
+        reflected = reflect(-(_e426), _e428);
+        let _e431 = s_20.n;
+        let _e432 = levels_1;
+        let _e433 = textureSampleLevel(environment_texture_tex, environment_texture_smp, _e431, _e432);
+        irradiance = _e433.xyz;
+        let _e435 = reflected;
+        let _e437 = s_20.roughness;
+        let _e438 = levels_1;
+        let _e440 = textureSampleLevel(environment_texture_tex, environment_texture_smp, _e435, (_e437 * _e438));
+        prefiltered = _e440.xyz;
+        let _e443 = s_20.roughness;
+        param_254 = _e443;
+        let _e445 = s_20.n_dot_v;
+        param_255 = _e445;
+        let _e446 = EnvBrdf_u0028_f1_u003b_f1_u003b((&param_254), (&param_255));
+        ab_4 = _e446;
+        let _e447 = f0_4;
+        let _e448 = g_irid_fresnel;
+        let _e449 = g_iridescence;
+        let _e453 = ab_4[0u];
+        let _e455 = f90_2;
+        let _e457 = ab_4[1u];
+        single_1 = ((mix(_e447, _e448, vec3(_e449)) * _e453) + vec3((_e455 * _e457)));
+        let _e461 = prefiltered;
+        let _e462 = single_1;
+        specular_1 = (_e461 * _e462);
+        let _e464 = EnergyCompensation_u0028_();
+        if _e464 {
+            let _e466 = ab_4[0u];
+            let _e468 = ab_4[1u];
+            missed = (1f - (_e466 + _e468));
             let _e471 = f0_4;
-            average_2 = (_e470 + ((vec3<f32>(1f, 1f, 1f) - _e471) / vec3(21f)));
-            let _e476 = single_1;
-            let _e477 = average_2;
-            let _e479 = missed;
-            let _e480 = average_2;
-            multiple = ((_e476 * _e477) / (vec3<f32>(1f, 1f, 1f) - (_e480 * _e479)));
-            let _e484 = multiple;
-            let _e485 = missed;
-            let _e487 = irradiance;
-            let _e489 = specular_1;
-            specular_1 = (_e489 + ((_e484 * _e485) * _e487));
-        }
-        let _e491 = diffuseColor_1;
-        let _e492 = irradiance;
-        let _e494 = specular_1;
-        let _e498 = frag_info.material[2u];
-        let _e501 = s_20.occlusion;
-        ambient = ((((_e491 * _e492) + _e494) * _e498) * _e501);
-        let _e503 = g_f0_dielectric;
-        let _e504 = g_irid_fresnel;
-        let _e505 = g_iridescence;
-        let _e509 = ab_4[0u];
-        let _e511 = g_f90_;
-        let _e513 = ab_4[1u];
-        reflects = ((mix(_e503, _e504, vec3(_e505)) * _e509) + vec3((_e511 * _e513)));
-        let _e517 = SceneColourBound_u0028_();
-        let _e518 = g_pane;
-        if (_e517 || _e518) {
+            let _e472 = f0_4;
+            average_2 = (_e471 + ((vec3<f32>(1f, 1f, 1f) - _e472) / vec3(21f)));
+            let _e477 = single_1;
+            let _e478 = average_2;
+            let _e480 = missed;
+            let _e481 = average_2;
+            multiple = ((_e477 * _e478) / (vec3<f32>(1f, 1f, 1f) - (_e481 * _e480)));
+            let _e485 = multiple;
+            let _e486 = missed;
+            let _e488 = irradiance;
+            let _e490 = specular_1;
+            specular_1 = (_e490 + ((_e485 * _e486) * _e488));
+        }
+        let _e492 = diffuseColor_1;
+        let _e493 = irradiance;
+        let _e495 = specular_1;
+        let _e499 = frag_info.material[2u];
+        let _e502 = s_20.occlusion;
+        ambient = ((((_e492 * _e493) + _e495) * _e499) * _e502);
+        let _e504 = g_f0_dielectric;
+        let _e505 = g_irid_fresnel;
+        let _e506 = g_iridescence;
+        let _e510 = ab_4[0u];
+        let _e512 = g_f90_;
+        let _e514 = ab_4[1u];
+        reflects = ((mix(_e504, _e505, vec3(_e506)) * _e510) + vec3((_e512 * _e514)));
+        let _e518 = SceneColourBound_u0028_();
+        let _e519 = g_pane;
+        if (_e518 || _e519) {
             local_50 = vec3<f32>(0f, 0f, 0f);
         } else {
-            let _e520 = s_20;
-            param_256 = _e520;
-            let _e521 = levels_1;
-            param_257 = _e521;
-            let _e522 = TransmittedRadiance_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_f1_u003b((&param_256), (&param_257));
-            let _e523 = g_transmittance;
-            let _e525 = reflects;
-            local_50 = ((_e522 * _e523) * (vec3<f32>(1f, 1f, 1f) - min(_e525, vec3<f32>(1f, 1f, 1f))));
-        }
-        let _e529 = local_50;
-        through_1 = _e529;
-        let _e530 = diffuseColor_1;
-        let _e531 = through_1;
-        let _e532 = irradiance;
-        let _e535 = g_transmission;
-        let _e539 = frag_info.material[2u];
-        let _e542 = s_20.occlusion;
-        let _e544 = ambient;
-        ambient = (_e544 + ((((_e530 * (_e531 - _e532)) * _e535) * _e539) * _e542));
-        let _e547 = s_20.v;
-        let _e549 = g_coat_n;
-        let _e551 = g_coat_roughness;
-        let _e552 = levels_1;
-        let _e554 = textureSampleLevel(environment_texture_tex, environment_texture_smp, reflect(-(_e547), _e549), (_e551 * _e552));
-        coatPrefiltered = _e554.xyz;
-        let _e556 = g_coat_roughness;
-        param_258 = _e556;
-        let _e557 = g_coat_n_dot_v;
-        param_259 = _e557;
-        let _e558 = EnvBrdf_u0028_f1_u003b_f1_u003b((&param_258), (&param_259));
-        coatAb = _e558;
-        let _e559 = coatPrefiltered;
-        let _e561 = coatAb[0u];
-        let _e564 = coatAb[1u];
-        let _e567 = g_coat;
-        let _e571 = frag_info.material[2u];
-        let _e574 = s_20.occlusion;
-        coatAmbient = ((((_e559 * ((0.04f * _e561) + _e564)) * _e567) * _e571) * _e574);
-        let _e577 = s_20.n;
-        let _e578 = g_sheen_roughness;
-        let _e579 = levels_1;
-        let _e581 = textureSampleLevel(environment_texture_tex, environment_texture_smp, _e577, (_e578 * _e579));
-        let _e585 = frag_info.material[2u];
-        sheenIncoming = (_e581.xyz * _e585);
-    }
-    let _e588 = s_20.roughness;
-    param_260 = _e588;
-    let _e590 = s_20.n_dot_v;
-    param_261 = _e590;
-    let _e591 = EnvBrdf_u0028_f1_u003b_f1_u003b((&param_260), (&param_261));
-    sceneAb = _e591;
-    let _e592 = g_f0_dielectric;
-    let _e593 = g_irid_fresnel;
-    let _e594 = g_iridescence;
-    let _e598 = sceneAb[0u];
-    let _e600 = g_f90_;
-    let _e602 = sceneAb[1u];
-    sceneReflects = ((mix(_e592, _e593, vec3(_e594)) * _e598) + vec3((_e600 * _e602)));
-    let _e606 = diffuseColor_1;
-    let _e607 = g_transmittance;
-    let _e609 = sceneReflects;
-    let _e613 = g_transmission;
-    passes = (((_e606 * _e607) * (vec3<f32>(1f, 1f, 1f) - min(_e609, vec3<f32>(1f, 1f, 1f)))) * _e613);
-    let _e615 = g_pane;
-    if _e615 {
-        let _e617 = passes[0u];
-        let _e619 = passes[1u];
-        let _e622 = passes[2u];
-        g_pass_through = clamp((((_e617 + _e619) + _e622) / 3f), 0f, 1f);
-    } else {
-        let _e626 = SceneColourBound_u0028_();
-        if _e626 {
-            let _e627 = s_20;
-            param_262 = _e627;
-            let _e628 = SceneBehind_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_262));
-            let _e629 = passes;
-            let _e631 = ambient;
-            ambient = (_e631 + (_e628 * _e629));
-        }
-    }
-    let _e633 = diffuseColor_1;
-    let _e634 = SampleLightmap_u0028_();
-    let _e637 = s_20.occlusion;
-    let _e639 = ambient;
-    ambient = (_e639 + ((_e633 * _e634) * _e637));
-    let _e641 = g_sheen;
-    let _e642 = g_sheen_albedo;
-    let _e644 = sheenIncoming;
-    let _e647 = s_20.occlusion;
-    sheenAmbient = (((_e641 * _e642) * _e644) * _e647);
-    let _e649 = s_20;
-    param_263 = _e649;
-    let _e650 = AccumulateLights_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_263));
-    let _e652 = s_20.occlusion;
-    let _e654 = ambient;
-    let _e655 = g_sheen_scale;
-    let _e657 = sheenAmbient;
-    let _e660 = s_20.emissive;
-    let _e662 = g_coat_through;
-    let _e665 = coatAmbient;
-    lit_3 = (((_e650 * _e652) + ((((_e654 * _e655) + _e657) + _e660) * _e662)) + _e665);
-    let _e667 = s_20;
-    param_264 = _e667;
-    let _e668 = lit_3;
-    param_265 = _e668;
-    let _e669 = WriteDebugView_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_vf3_u003b((&param_264), (&param_265));
-    if _e669 {
+            let _e521 = s_20;
+            param_256 = _e521;
+            let _e522 = levels_1;
+            param_257 = _e522;
+            let _e523 = TransmittedRadiance_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_f1_u003b((&param_256), (&param_257));
+            let _e524 = g_transmittance;
+            let _e526 = reflects;
+            local_50 = ((_e523 * _e524) * (vec3<f32>(1f, 1f, 1f) - min(_e526, vec3<f32>(1f, 1f, 1f))));
+        }
+        let _e530 = local_50;
+        through_1 = _e530;
+        let _e531 = diffuseColor_1;
+        let _e532 = through_1;
+        let _e533 = irradiance;
+        let _e536 = g_transmission;
+        let _e540 = frag_info.material[2u];
+        let _e543 = s_20.occlusion;
+        let _e545 = ambient;
+        ambient = (_e545 + ((((_e531 * (_e532 - _e533)) * _e536) * _e540) * _e543));
+        let _e548 = s_20.v;
+        let _e550 = g_coat_n;
+        let _e552 = g_coat_roughness;
+        let _e553 = levels_1;
+        let _e555 = textureSampleLevel(environment_texture_tex, environment_texture_smp, reflect(-(_e548), _e550), (_e552 * _e553));
+        coatPrefiltered = _e555.xyz;
+        let _e557 = g_coat_roughness;
+        param_258 = _e557;
+        let _e558 = g_coat_n_dot_v;
+        param_259 = _e558;
+        let _e559 = EnvBrdf_u0028_f1_u003b_f1_u003b((&param_258), (&param_259));
+        coatAb = _e559;
+        let _e560 = coatPrefiltered;
+        let _e562 = coatAb[0u];
+        let _e565 = coatAb[1u];
+        let _e568 = g_coat;
+        let _e572 = frag_info.material[2u];
+        let _e575 = s_20.occlusion;
+        coatAmbient = ((((_e560 * ((0.04f * _e562) + _e565)) * _e568) * _e572) * _e575);
+        let _e578 = s_20.n;
+        let _e579 = g_sheen_roughness;
+        let _e580 = levels_1;
+        let _e582 = textureSampleLevel(environment_texture_tex, environment_texture_smp, _e578, (_e579 * _e580));
+        let _e586 = frag_info.material[2u];
+        sheenIncoming = (_e582.xyz * _e586);
+    }
+    let _e589 = s_20.roughness;
+    param_260 = _e589;
+    let _e591 = s_20.n_dot_v;
+    param_261 = _e591;
+    let _e592 = EnvBrdf_u0028_f1_u003b_f1_u003b((&param_260), (&param_261));
+    sceneAb = _e592;
+    let _e593 = g_f0_dielectric;
+    let _e594 = g_irid_fresnel;
+    let _e595 = g_iridescence;
+    let _e599 = sceneAb[0u];
+    let _e601 = g_f90_;
+    let _e603 = sceneAb[1u];
+    sceneReflects = ((mix(_e593, _e594, vec3(_e595)) * _e599) + vec3((_e601 * _e603)));
+    let _e607 = diffuseColor_1;
+    let _e608 = g_transmittance;
+    let _e610 = sceneReflects;
+    let _e614 = g_transmission;
+    passes = (((_e607 * _e608) * (vec3<f32>(1f, 1f, 1f) - min(_e610, vec3<f32>(1f, 1f, 1f)))) * _e614);
+    let _e616 = g_pane;
+    if _e616 {
+        let _e618 = passes[0u];
+        let _e620 = passes[1u];
+        let _e623 = passes[2u];
+        g_pass_through = clamp((((_e618 + _e620) + _e623) / 3f), 0f, 1f);
+    } else {
+        let _e627 = SceneColourBound_u0028_();
+        if _e627 {
+            let _e628 = s_20;
+            param_262 = _e628;
+            let _e629 = SceneBehind_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_262));
+            let _e630 = passes;
+            let _e632 = ambient;
+            ambient = (_e632 + (_e629 * _e630));
+        }
+    }
+    let _e634 = diffuseColor_1;
+    let _e635 = SampleLightmap_u0028_();
+    let _e638 = s_20.occlusion;
+    let _e640 = ambient;
+    ambient = (_e640 + ((_e634 * _e635) * _e638));
+    let _e642 = g_sheen;
+    let _e643 = g_sheen_albedo;
+    let _e645 = sheenIncoming;
+    let _e648 = s_20.occlusion;
+    sheenAmbient = (((_e642 * _e643) * _e645) * _e648);
+    let _e650 = s_20;
+    param_263 = _e650;
+    let _e651 = AccumulateLights_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_263));
+    let _e653 = s_20.occlusion;
+    let _e655 = ambient;
+    let _e656 = g_sheen_scale;
+    let _e658 = sheenAmbient;
+    let _e661 = s_20.emissive;
+    let _e663 = g_coat_through;
+    let _e666 = coatAmbient;
+    lit_3 = (((_e651 * _e653) + ((((_e655 * _e656) + _e658) + _e661) * _e663)) + _e666);
+    let _e668 = s_20;
+    param_264 = _e668;
+    let _e669 = lit_3;
+    param_265 = _e669;
+    let _e670 = WriteDebugView_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_vf3_u003b((&param_264), (&param_265));
+    if _e670 {
         return;
     }
-    let _e670 = lit_3;
-    param_266 = _e670;
-    let _e672 = s_20.alpha;
-    param_267 = _e672;
-    let _e674 = s_20.roughness;
-    param_268 = _e674;
+    let _e671 = lit_3;
+    param_266 = _e671;
+    let _e673 = s_20.alpha;
+    param_267 = _e673;
+    let _e675 = s_20.roughness;
+    param_268 = _e675;
     WriteSurface_u0028_vf3_u003b_f1_u003b_f1_u003b((&param_266), (&param_267), (&param_268));
     return;
 }
@@ -23516,10 +23670,10 @@ var shadow_texture_tex: texture_2d<f32>;
 var shadow_texture_smp: sampler;
 
 fn ViewDepth_u0028_() -> f32 {
-    let _e188 = v_world_position_1;
-    let _e190 = fog_info.eye;
-    let _e194 = fog_info.forward;
-    return dot((_e188 - _e190.xyz), _e194.xyz);
+    let _e189 = v_world_position_1;
+    let _e191 = fog_info.eye;
+    let _e195 = fog_info.forward;
+    return dot((_e189 - _e191.xyz), _e195.xyz);
 }
 
 fn WeightedBlendedWeight_u0028_f1_u003b(alpha: ptr<function, f32>) -> f32 {
@@ -23528,66 +23682,66 @@ fn WeightedBlendedWeight_u0028_f1_u003b(alpha: ptr<function, f32>) -> f32 {
     var far: f32;
     var far3_: f32;
 
-    let _e193 = ViewDepth_u0028_();
-    z = abs(_e193);
-    let _e195 = z;
-    near = (_e195 / 5f);
-    let _e197 = z;
-    far = (_e197 / 200f);
-    let _e199 = far;
+    let _e194 = ViewDepth_u0028_();
+    z = abs(_e194);
+    let _e196 = z;
+    near = (_e196 / 5f);
+    let _e198 = z;
+    far = (_e198 / 200f);
     let _e200 = far;
-    let _e202 = far;
-    far3_ = ((_e199 * _e200) * _e202);
-    let _e204 = (*alpha);
-    let _e205 = near;
+    let _e201 = far;
+    let _e203 = far;
+    far3_ = ((_e200 * _e201) * _e203);
+    let _e205 = (*alpha);
     let _e206 = near;
-    let _e209 = far3_;
+    let _e207 = near;
     let _e210 = far3_;
-    return (_e204 * clamp((10f / ((0.00001f + (_e205 * _e206)) + (_e209 * _e210))), 0.01f, 3000f));
-}
-
-fn WriteWeightedBlended_u0028_() {
-    var mode: f32;
-    var alpha_1: f32;
-    var weight: f32;
-    var param: f32;
-    var accumulate: vec4<f32>;
-    var revealage: bool;
-    var local: vec4<f32>;
-
-    let _e197 = fog_info.forward[3u];
-    mode = _e197;
-    let _e198 = mode;
-    if (_e198 > 0.5f) {
-        let _e201 = frag_color[3u];
-        alpha_1 = _e201;
-        let _e202 = alpha_1;
-        param = _e202;
-        let _e203 = WeightedBlendedWeight_u0028_f1_u003b((&param));
-        weight = _e203;
-        let _e204 = frag_color;
-        let _e206 = weight;
-        let _e207 = (_e204.xyz * _e206);
-        let _e208 = alpha_1;
-        let _e209 = weight;
-        accumulate = vec4<f32>(_e207.x, _e207.y, _e207.z, (_e208 * _e209));
-        let _e215 = mode;
-        let _e217 = mode;
-        revealage = ((_e215 > 1.5f) && (_e217 < 2.5f));
-        let _e220 = revealage;
-        if _e220 {
-            let _e221 = alpha_1;
-            local = vec4(_e221);
+    let _e211 = far3_;
+    return (_e205 * clamp((10f / ((0.00001f + (_e206 * _e207)) + (_e210 * _e211))), 0.01f, 3000f));
+}
+
+fn WriteWeightedBlended_u0028_() {
+    var mode: f32;
+    var alpha_1: f32;
+    var weight: f32;
+    var param: f32;
+    var accumulate: vec4<f32>;
+    var revealage: bool;
+    var local: vec4<f32>;
+
+    let _e198 = fog_info.forward[3u];
+    mode = _e198;
+    let _e199 = mode;
+    if (_e199 > 0.5f) {
+        let _e202 = frag_color[3u];
+        alpha_1 = _e202;
+        let _e203 = alpha_1;
+        param = _e203;
+        let _e204 = WeightedBlendedWeight_u0028_f1_u003b((&param));
+        weight = _e204;
+        let _e205 = frag_color;
+        let _e207 = weight;
+        let _e208 = (_e205.xyz * _e207);
+        let _e209 = alpha_1;
+        let _e210 = weight;
+        accumulate = vec4<f32>(_e208.x, _e208.y, _e208.z, (_e209 * _e210));
+        let _e216 = mode;
+        let _e218 = mode;
+        revealage = ((_e216 > 1.5f) && (_e218 < 2.5f));
+        let _e221 = revealage;
+        if _e221 {
+            let _e222 = alpha_1;
+            local = vec4(_e222);
         } else {
-            let _e223 = accumulate;
-            local = _e223;
+            let _e224 = accumulate;
+            local = _e224;
         }
-        let _e224 = local;
-        frag_color = _e224;
-        let _e225 = mode;
-        if (_e225 > 2.5f) {
-            let _e227 = alpha_1;
-            frag_surface = vec4(_e227);
+        let _e225 = local;
+        frag_color = _e225;
+        let _e226 = mode;
+        if (_e226 > 2.5f) {
+            let _e228 = alpha_1;
+            frag_surface = vec4(_e228);
         }
     }
     return;
@@ -23596,29 +23750,29 @@ fn WriteWeightedBlended_u0028_() {
 fn EncodeOctahedral_u0028_vf3_u003b(n: ptr<function, vec3<f32>>) -> vec2<f32> {
     var e: vec2<f32>;
 
-    let _e191 = (*n)[0u];
-    let _e194 = (*n)[1u];
-    let _e198 = (*n)[2u];
-    let _e201 = (*n);
-    (*n) = (_e201 / vec3(((abs(_e191) + abs(_e194)) + abs(_e198))));
-    let _e204 = (*n);
-    e = _e204.xy;
-    let _e207 = (*n)[2u];
-    if (_e207 < 0f) {
-        let _e209 = (*n);
-        let _e215 = (*n)[0u];
-        let _e219 = (*n)[1u];
-        e = ((vec2(1f) - abs(_e209.yx)) * vec2<f32>(select(-1f, 1f, (_e215 >= 0f)), select(-1f, 1f, (_e219 >= 0f))));
+    let _e192 = (*n)[0u];
+    let _e195 = (*n)[1u];
+    let _e199 = (*n)[2u];
+    let _e202 = (*n);
+    (*n) = (_e202 / vec3(((abs(_e192) + abs(_e195)) + abs(_e199))));
+    let _e205 = (*n);
+    e = _e205.xy;
+    let _e208 = (*n)[2u];
+    if (_e208 < 0f) {
+        let _e210 = (*n);
+        let _e216 = (*n)[0u];
+        let _e220 = (*n)[1u];
+        e = ((vec2(1f) - abs(_e210.yx)) * vec2<f32>(select(-1f, 1f, (_e216 >= 0f)), select(-1f, 1f, (_e220 >= 0f))));
     }
-    let _e224 = e;
-    return ((_e224 * 0.5f) + vec2(0.5f));
+    let _e225 = e;
+    return ((_e225 * 0.5f) + vec2(0.5f));
 }
 
 fn LinearToSrgb_u0028_vf3_u003b(linear: ptr<function, vec3<f32>>) -> vec3<f32> {
-    let _e189 = (*linear);
-    let _e191 = (*linear);
-    let _e195 = (*linear);
-    return mix((_e189 * 12.92f), ((pow(_e191, vec3<f32>(0.41666666f, 0.41666666f, 0.41666666f)) * 1.055f) - vec3<f32>(0.055f, 0.055f, 0.055f)), step(vec3<f32>(0.0031308f, 0.0031308f, 0.0031308f), _e195));
+    let _e190 = (*linear);
+    let _e192 = (*linear);
+    let _e196 = (*linear);
+    return mix((_e190 * 12.92f), ((pow(_e192, vec3<f32>(0.41666666f, 0.41666666f, 0.41666666f)) * 1.055f) - vec3<f32>(0.055f, 0.055f, 0.055f)), step(vec3<f32>(0.0031308f, 0.0031308f, 0.0031308f), _e196));
 }
 
 fn WriteSurfaceGeometry_u0028_f1_u003b(roughness: ptr<function, f32>) {
@@ -23626,52 +23780,52 @@ fn WriteSurfaceGeometry_u0028_f1_u003b(roughness: ptr<function, f32>) {
     var geometric: vec3<f32>;
     var param_2: vec3<f32>;
 
-    let _e192 = g_albedo;
-    param_1 = clamp(_e192, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
-    let _e194 = LinearToSrgb_u0028_vf3_u003b((&param_1));
-    frag_albedo = vec4<f32>(_e194.x, _e194.y, _e194.z, 1f);
-    let _e199 = g_debug_surface_on;
-    if _e199 {
-        let _e200 = g_debug_surface;
-        let _e201 = ViewDepth_u0028_();
-        frag_surface = vec4<f32>(_e200.x, _e200.y, _e200.z, _e201);
+    let _e193 = g_albedo;
+    param_1 = clamp(_e193, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
+    let _e195 = LinearToSrgb_u0028_vf3_u003b((&param_1));
+    frag_albedo = vec4<f32>(_e195.x, _e195.y, _e195.z, 1f);
+    let _e200 = g_debug_surface_on;
+    if _e200 {
+        let _e201 = g_debug_surface;
+        let _e202 = ViewDepth_u0028_();
+        frag_surface = vec4<f32>(_e201.x, _e201.y, _e201.z, _e202);
         return;
     }
-    let _e206 = v_normal_1;
-    geometric = normalize(_e206);
-    let _e208 = gl_FrontFacing_1;
-    if !(_e208) {
-        let _e210 = geometric;
-        geometric = -(_e210);
-    }
-    let _e212 = geometric;
-    param_2 = _e212;
-    let _e213 = EncodeOctahedral_u0028_vf3_u003b((&param_2));
-    let _e214 = (*roughness);
-    let _e216 = ViewDepth_u0028_();
-    frag_surface = vec4<f32>(_e213.x, _e213.y, clamp(_e214, 0f, 1f), _e216);
+    let _e207 = v_normal_1;
+    geometric = normalize(_e207);
+    let _e209 = gl_FrontFacing_1;
+    if !(_e209) {
+        let _e211 = geometric;
+        geometric = -(_e211);
+    }
+    let _e213 = geometric;
+    param_2 = _e213;
+    let _e214 = EncodeOctahedral_u0028_vf3_u003b((&param_2));
+    let _e215 = (*roughness);
+    let _e217 = ViewDepth_u0028_();
+    frag_surface = vec4<f32>(_e214.x, _e214.y, clamp(_e215, 0f, 1f), _e217);
     return;
 }
 
 fn Orthographic_u0028_() -> bool {
-    let _e190 = fog_info.projection[0u];
-    return (_e190 > 0.5f);
+    let _e191 = fog_info.projection[0u];
+    return (_e191 > 0.5f);
 }
 
 fn EyeDistance_u0028_() -> f32 {
     var local_1: f32;
 
-    let _e189 = Orthographic_u0028_();
-    if _e189 {
-        let _e190 = ViewDepth_u0028_();
-        local_1 = max(_e190, 0f);
+    let _e190 = Orthographic_u0028_();
+    if _e190 {
+        let _e191 = ViewDepth_u0028_();
+        local_1 = max(_e191, 0f);
     } else {
-        let _e192 = v_world_position_1;
-        let _e194 = fog_info.eye;
-        local_1 = distance(_e192, _e194.xyz);
+        let _e193 = v_world_position_1;
+        let _e195 = fog_info.eye;
+        local_1 = distance(_e193, _e195.xyz);
     }
-    let _e197 = local_1;
-    return _e197;
+    let _e198 = local_1;
+    return _e198;
 }
 
 fn ApplyFog_u0028_vf3_u003b(color: ptr<function, vec3<f32>>) -> vec3<f32> {
@@ -23681,41 +23835,41 @@ fn ApplyFog_u0028_vf3_u003b(color: ptr<function, vec3<f32>>) -> vec3<f32> {
     var k: f32;
     var local_2: f32;
 
-    let _e196 = fog_info.fog[3u];
-    density = _e196;
-    let _e197 = density;
-    if (_e197 <= 0f) {
-        let _e199 = (*color);
-        return _e199;
-    }
-    let _e200 = EyeDistance_u0028_();
-    d = _e200;
-    let _e203 = fog_info.eye[3u];
-    falloff = _e203;
-    let _e204 = falloff;
-    if (_e204 > 0f) {
-        let _e206 = falloff;
-        let _e208 = v_world_position_1[1u];
-        let _e211 = fog_info.eye[1u];
-        k = (_e206 * (_e208 - _e211));
-        let _e214 = k;
-        if (abs(_e214) > 0.001f) {
-            let _e217 = k;
-            let _e221 = k;
-            local_2 = ((1f - exp(-(_e217))) / _e221);
+    let _e197 = fog_info.fog[3u];
+    density = _e197;
+    let _e198 = density;
+    if (_e198 <= 0f) {
+        let _e200 = (*color);
+        return _e200;
+    }
+    let _e201 = EyeDistance_u0028_();
+    d = _e201;
+    let _e204 = fog_info.eye[3u];
+    falloff = _e204;
+    let _e205 = falloff;
+    if (_e205 > 0f) {
+        let _e207 = falloff;
+        let _e209 = v_world_position_1[1u];
+        let _e212 = fog_info.eye[1u];
+        k = (_e207 * (_e209 - _e212));
+        let _e215 = k;
+        if (abs(_e215) > 0.001f) {
+            let _e218 = k;
+            let _e222 = k;
+            local_2 = ((1f - exp(-(_e218))) / _e222);
         } else {
-            let _e223 = k;
-            local_2 = (1f - (0.5f * _e223));
+            let _e224 = k;
+            local_2 = (1f - (0.5f * _e224));
         }
-        let _e226 = local_2;
-        let _e227 = density;
-        density = (_e227 * _e226);
+        let _e227 = local_2;
+        let _e228 = density;
+        density = (_e228 * _e227);
     }
-    let _e230 = fog_info.fog;
-    let _e232 = (*color);
-    let _e233 = density;
-    let _e235 = d;
-    return mix(_e230.xyz, _e232, vec3(clamp(exp((-(_e233) * _e235)), 0f, 1f)));
+    let _e231 = fog_info.fog;
+    let _e233 = (*color);
+    let _e234 = density;
+    let _e236 = d;
+    return mix(_e231.xyz, _e233, vec3(clamp(exp((-(_e234) * _e236)), 0f, 1f)));
 }
 
 fn WriteSurface_u0028_vf3_u003b_f1_u003b_f1_u003b(linearColor: ptr<function, vec3<f32>>, alpha_2: ptr<function, f32>, roughness_1: ptr<function, f32>) {
@@ -23723,44 +23877,44 @@ fn WriteSurface_u0028_vf3_u003b_f1_u003b_f1_u003b(linearColor: ptr<function, vec
     var param_3: vec3<f32>;
     var param_4: f32;
 
-    let _e194 = g_premultiply;
-    let _e195 = (*alpha_2);
-    weight_1 = select(1f, _e195, _e194);
-    let _e197 = (*linearColor);
-    param_3 = _e197;
-    let _e198 = ApplyFog_u0028_vf3_u003b((&param_3));
-    let _e199 = weight_1;
-    let _e200 = (_e198 * _e199);
-    let _e201 = (*alpha_2);
-    let _e202 = g_pass_through;
-    frag_color = vec4<f32>(_e200.x, _e200.y, _e200.z, (_e201 * (1f - _e202)));
-    let _e209 = (*roughness_1);
-    param_4 = _e209;
+    let _e195 = g_premultiply;
+    let _e196 = (*alpha_2);
+    weight_1 = select(1f, _e196, _e195);
+    let _e198 = (*linearColor);
+    param_3 = _e198;
+    let _e199 = ApplyFog_u0028_vf3_u003b((&param_3));
+    let _e200 = weight_1;
+    let _e201 = (_e199 * _e200);
+    let _e202 = (*alpha_2);
+    let _e203 = g_pass_through;
+    frag_color = vec4<f32>(_e201.x, _e201.y, _e201.z, (_e202 * (1f - _e203)));
+    let _e210 = (*roughness_1);
+    param_4 = _e210;
     WriteSurfaceGeometry_u0028_f1_u003b((&param_4));
     WriteWeightedBlended_u0028_();
     return;
 }
 
 fn SrgbToLinear_u0028_vf3_u003b(srgb: ptr<function, vec3<f32>>) -> vec3<f32> {
-    let _e189 = (*srgb);
-    let _e192 = (*srgb);
-    let _e197 = (*srgb);
-    return mix((_e189 / vec3(12.92f)), pow(((_e192 + vec3<f32>(0.055f, 0.055f, 0.055f)) / vec3(1.055f)), vec3<f32>(2.4f, 2.4f, 2.4f)), step(vec3<f32>(0.04045f, 0.04045f, 0.04045f), _e197));
+    let _e190 = (*srgb);
+    let _e193 = (*srgb);
+    let _e198 = (*srgb);
+    return mix((_e190 / vec3(12.92f)), pow(((_e193 + vec3<f32>(0.055f, 0.055f, 0.055f)) / vec3(1.055f)), vec3<f32>(2.4f, 2.4f, 2.4f)), step(vec3<f32>(0.04045f, 0.04045f, 0.04045f), _e198));
 }
 
 fn NonFinite_u0028_vf3_u003b(c: ptr<function, vec3<f32>>) -> bool {
     var phi_2562_: bool;
 
-    let _e189 = (*c);
     let _e190 = (*c);
-    let _e192 = any((_e189 != _e190));
-    phi_2562_ = _e192;
-    if !(_e192) {
-        let _e194 = (*c);
-        phi_2562_ = any((abs(_e194) > vec3<f32>(300000000000000000000000000000000000000f, 300000000000000000000000000000000000000f, 300000000000000000000000000000000000000f)));
-    }
-    let _e199 = phi_2562_;
-    return _e199;
+    let _e191 = (*c);
+    let _e193 = any((_e190 != _e191));
+    phi_2562_ = _e193;
+    if !(_e193) {
+        let _e195 = (*c);
+        phi_2562_ = any((abs(_e195) > vec3<f32>(300000000000000000000000000000000000000f, 300000000000000000000000000000000000000f, 300000000000000000000000000000000000000f)));
+    }
+    let _e200 = phi_2562_;
+    return _e200;
 }
 
 fn WriteDebugView_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_vf3_u003b(s: ptr<function, Surface>, lit: ptr<function, vec3<f32>>) -> bool {
@@ -23778,78 +23932,78 @@ fn WriteDebugView_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_
     var param_9: vec3<f32>;
     var param_10: f32;
 
-    let _e205 = frag_info.debug_view[0u];
-    view = _e205;
-    let _e206 = view;
-    if (_e206 < 0.5f) {
+    let _e206 = frag_info.debug_view[0u];
+    view = _e206;
+    let _e207 = view;
+    if (_e207 < 0.5f) {
         return false;
     }
-    let _e209 = gl_FragCoord_1[0u];
-    let _e212 = frag_info.debug_view[1u];
-    let _e215 = frag_info.debug_view[2u];
-    if (_e209 < (_e212 * _e215)) {
+    let _e210 = gl_FragCoord_1[0u];
+    let _e213 = frag_info.debug_view[1u];
+    let _e216 = frag_info.debug_view[2u];
+    if (_e210 < (_e213 * _e216)) {
         return false;
     }
-    let _e218 = view;
-    code = i32((_e218 + 0.5f));
+    let _e219 = view;
+    code = i32((_e219 + 0.5f));
     shown = vec3<f32>(0f, 0f, 0f);
-    let _e221 = code;
-    if (_e221 == 1i) {
-        let _e224 = (*s).albedo;
-        param_5 = clamp(_e224, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
-        let _e226 = LinearToSrgb_u0028_vf3_u003b((&param_5));
-        shown = _e226;
-    } else {
-        let _e227 = code;
-        if (_e227 == 2i) {
-            let _e230 = (*s).n;
-            shown = ((_e230 * 0.5f) + vec3<f32>(0.5f, 0.5f, 0.5f));
+    let _e222 = code;
+    if (_e222 == 1i) {
+        let _e225 = (*s).albedo;
+        param_5 = clamp(_e225, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
+        let _e227 = LinearToSrgb_u0028_vf3_u003b((&param_5));
+        shown = _e227;
+    } else {
+        let _e228 = code;
+        if (_e228 == 2i) {
+            let _e231 = (*s).n;
+            shown = ((_e231 * 0.5f) + vec3<f32>(0.5f, 0.5f, 0.5f));
         } else {
-            let _e233 = code;
-            if (_e233 == 3i) {
-                let _e236 = (*s).roughness;
-                shown = vec3(clamp(_e236, 0f, 1f));
+            let _e234 = code;
+            if (_e234 == 3i) {
+                let _e237 = (*s).roughness;
+                shown = vec3(clamp(_e237, 0f, 1f));
             } else {
-                let _e239 = code;
-                if (_e239 == 4i) {
-                    let _e242 = (*s).metallic;
-                    shown = vec3(clamp(_e242, 0f, 1f));
+                let _e240 = code;
+                if (_e240 == 4i) {
+                    let _e243 = (*s).metallic;
+                    shown = vec3(clamp(_e243, 0f, 1f));
                 } else {
-                    let _e245 = code;
-                    if (_e245 == 5i) {
-                        let _e248 = (*s).occlusion;
-                        shown = vec3(clamp(_e248, 0f, 1f));
+                    let _e246 = code;
+                    if (_e246 == 5i) {
+                        let _e249 = (*s).occlusion;
+                        shown = vec3(clamp(_e249, 0f, 1f));
                     } else {
-                        let _e251 = code;
-                        if (_e251 == 6i) {
-                            let _e254 = (*s).emissive;
-                            param_6 = clamp(_e254, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
-                            let _e256 = LinearToSrgb_u0028_vf3_u003b((&param_6));
-                            shown = _e256;
+                        let _e252 = code;
+                        if (_e252 == 6i) {
+                            let _e255 = (*s).emissive;
+                            param_6 = clamp(_e255, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
+                            let _e257 = LinearToSrgb_u0028_vf3_u003b((&param_6));
+                            shown = _e257;
                         } else {
-                            let _e257 = code;
-                            if (_e257 == 7i) {
-                                let _e259 = v_texcoord_1;
-                                let _e260 = fract(_e259);
-                                shown = vec3<f32>(_e260.x, _e260.y, 0f);
+                            let _e258 = code;
+                            if (_e258 == 7i) {
+                                let _e260 = v_texcoord_1;
+                                let _e261 = fract(_e260);
+                                shown = vec3<f32>(_e261.x, _e261.y, 0f);
                             } else {
-                                let _e264 = code;
-                                if (_e264 == 8i) {
-                                    let _e266 = (*lit);
-                                    param_7 = clamp(_e266, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
-                                    let _e268 = LinearToSrgb_u0028_vf3_u003b((&param_7));
-                                    grey = dot(_e268, vec3<f32>(0.2126f, 0.7152f, 0.0722f));
-                                    let _e270 = (*lit);
-                                    param_8 = _e270;
-                                    let _e271 = NonFinite_u0028_vf3_u003b((&param_8));
-                                    if _e271 {
+                                let _e265 = code;
+                                if (_e265 == 8i) {
+                                    let _e267 = (*lit);
+                                    param_7 = clamp(_e267, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
+                                    let _e269 = LinearToSrgb_u0028_vf3_u003b((&param_7));
+                                    grey = dot(_e269, vec3<f32>(0.2126f, 0.7152f, 0.0722f));
+                                    let _e271 = (*lit);
+                                    param_8 = _e271;
+                                    let _e272 = NonFinite_u0028_vf3_u003b((&param_8));
+                                    if _e272 {
                                         local_3 = vec3<f32>(1f, 0f, 1f);
                                     } else {
-                                        let _e272 = grey;
-                                        local_3 = vec3((_e272 * 0.5f));
+                                        let _e273 = grey;
+                                        local_3 = vec3((_e273 * 0.5f));
                                     }
-                                    let _e275 = local_3;
-                                    shown = _e275;
+                                    let _e276 = local_3;
+                                    shown = _e276;
                                 }
                             }
                         }
@@ -23858,24 +24012,24 @@ fn WriteDebugView_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_
             }
         }
     }
-    let _e276 = g_premultiply;
-    if _e276 {
-        let _e278 = (*s).alpha;
-        local_4 = _e278;
+    let _e277 = g_premultiply;
+    if _e277 {
+        let _e279 = (*s).alpha;
+        local_4 = _e279;
     } else {
         local_4 = 1f;
     }
-    let _e279 = local_4;
-    weight_2 = _e279;
-    let _e280 = shown;
-    param_9 = _e280;
-    let _e281 = SrgbToLinear_u0028_vf3_u003b((&param_9));
-    let _e282 = weight_2;
-    let _e283 = (_e281 * _e282);
-    let _e285 = (*s).alpha;
-    frag_color = vec4<f32>(_e283.x, _e283.y, _e283.z, _e285);
-    let _e291 = (*s).roughness;
-    param_10 = _e291;
+    let _e280 = local_4;
+    weight_2 = _e280;
+    let _e281 = shown;
+    param_9 = _e281;
+    let _e282 = SrgbToLinear_u0028_vf3_u003b((&param_9));
+    let _e283 = weight_2;
+    let _e284 = (_e282 * _e283);
+    let _e286 = (*s).alpha;
+    frag_color = vec4<f32>(_e284.x, _e284.y, _e284.z, _e286);
+    let _e292 = (*s).roughness;
+    param_10 = _e292;
     WriteSurfaceGeometry_u0028_f1_u003b((&param_10));
     WriteWeightedBlended_u0028_();
     return true;
@@ -23887,54 +24041,54 @@ fn ShadeLight_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_
     var fraction: f32;
     var ramp: f32;
 
-    let _e195 = (*s_1).roughness;
-    bands = mix(5f, 2f, _e195);
-    let _e198 = (*light).n_dot_l;
-    let _e199 = bands;
-    let _e202 = bands;
-    quantized = (floor((_e198 * _e199)) / _e202);
-    let _e205 = (*light).n_dot_l;
-    let _e206 = bands;
-    fraction = fract((_e205 * _e206));
-    let _e209 = fraction;
-    let _e211 = bands;
-    let _e213 = quantized;
-    quantized = (_e213 + (smoothstep(0.85f, 1f, _e209) / _e211));
-    let _e215 = quantized;
-    let _e217 = (*light).n_dot_l;
-    ramp = (_e215 / max(_e217, 0.001f));
-    let _e221 = (*s_1).albedo;
-    let _e222 = ramp;
-    return (_e221 * _e222);
+    let _e196 = (*s_1).roughness;
+    bands = mix(5f, 2f, _e196);
+    let _e199 = (*light).n_dot_l;
+    let _e200 = bands;
+    let _e203 = bands;
+    quantized = (floor((_e199 * _e200)) / _e203);
+    let _e206 = (*light).n_dot_l;
+    let _e207 = bands;
+    fraction = fract((_e206 * _e207));
+    let _e210 = fraction;
+    let _e212 = bands;
+    let _e214 = quantized;
+    quantized = (_e214 + (smoothstep(0.85f, 1f, _e210) / _e212));
+    let _e216 = quantized;
+    let _e218 = (*light).n_dot_l;
+    ramp = (_e216 / max(_e218, 0.001f));
+    let _e222 = (*s_1).albedo;
+    let _e223 = ramp;
+    return (_e222 * _e223);
 }
 
 fn PointShadowDiskTap_u0028_i1_u003b(i: ptr<function, i32>) -> vec2<f32> {
-    let _e189 = (*i);
-    if (_e189 == 0i) {
+    let _e190 = (*i);
+    if (_e190 == 0i) {
         return vec2<f32>(-0.94201624f, -0.39906216f);
     }
-    let _e191 = (*i);
-    if (_e191 == 1i) {
+    let _e192 = (*i);
+    if (_e192 == 1i) {
         return vec2<f32>(0.9455861f, -0.76890725f);
     }
-    let _e193 = (*i);
-    if (_e193 == 2i) {
+    let _e194 = (*i);
+    if (_e194 == 2i) {
         return vec2<f32>(-0.0941841f, -0.9293887f);
     }
-    let _e195 = (*i);
-    if (_e195 == 3i) {
+    let _e196 = (*i);
+    if (_e196 == 3i) {
         return vec2<f32>(0.34495938f, 0.2938776f);
     }
-    let _e197 = (*i);
-    if (_e197 == 4i) {
+    let _e198 = (*i);
+    if (_e198 == 4i) {
         return vec2<f32>(-0.9158858f, 0.45771432f);
     }
-    let _e199 = (*i);
-    if (_e199 == 5i) {
+    let _e200 = (*i);
+    if (_e200 == 5i) {
         return vec2<f32>(-0.8154423f, -0.87912464f);
     }
-    let _e201 = (*i);
-    if (_e201 == 6i) {
+    let _e202 = (*i);
+    if (_e202 == 6i) {
         return vec2<f32>(-0.38277543f, 0.27676845f);
     }
     return vec2<f32>(0.974844f, 0.7564838f);
@@ -23944,20 +24098,20 @@ fn PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b(i_1: ptr<function
     var p: vec2<f32>;
     var param_11: i32;
 
-    let _e194 = (*i_1);
-    param_11 = _e194;
-    let _e195 = PointShadowDiskTap_u0028_i1_u003b((&param_11));
-    p = _e195;
-    let _e197 = p[0u];
-    let _e198 = (*ca);
-    let _e201 = p[1u];
-    let _e202 = (*sa);
-    let _e206 = p[0u];
-    let _e207 = (*sa);
-    let _e210 = p[1u];
-    let _e211 = (*ca);
-    let _e215 = (*radius);
-    return (vec2<f32>(((_e197 * _e198) - (_e201 * _e202)), ((_e206 * _e207) + (_e210 * _e211))) * _e215);
+    let _e195 = (*i_1);
+    param_11 = _e195;
+    let _e196 = PointShadowDiskTap_u0028_i1_u003b((&param_11));
+    p = _e196;
+    let _e198 = p[0u];
+    let _e199 = (*ca);
+    let _e202 = p[1u];
+    let _e203 = (*sa);
+    let _e207 = p[0u];
+    let _e208 = (*sa);
+    let _e211 = p[1u];
+    let _e212 = (*ca);
+    let _e216 = (*radius);
+    return (vec2<f32>(((_e198 * _e199) - (_e202 * _e203)), ((_e207 * _e208) + (_e211 * _e212))) * _e216);
 }
 
 fn PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b(uv: ptr<function, vec2<f32>>, offset: ptr<function, vec2<f32>>, tile: ptr<function, vec2<f32>>, range: ptr<function, f32>) -> f32 {
@@ -23965,27 +24119,27 @@ fn PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b(uv: ptr<func
     var local_5: vec2<f32>;
     var atlas: vec2<f32>;
 
-    let _e197 = point_shadow.params[0u];
-    inset = _e197;
-    let _e198 = (*uv);
-    let _e199 = (*offset);
-    let _e201 = inset;
+    let _e198 = point_shadow.params[0u];
+    inset = _e198;
+    let _e199 = (*uv);
+    let _e200 = (*offset);
     let _e202 = inset;
-    local_5 = clamp((_e198 + _e199), vec2(_e201), vec2((1f - _e202)));
-    let _e207 = local_5;
-    let _e208 = (*tile);
-    atlas = ((_e207 + _e208) * vec2<f32>(0.16666667f, 0.16666667f));
-    let _e213 = point_shadow.params3_[0u];
-    if (_e213 > 0.5f) {
-        let _e216 = atlas[1u];
-        atlas[1u] = (1f - _e216);
+    let _e203 = inset;
+    local_5 = clamp((_e199 + _e200), vec2(_e202), vec2((1f - _e203)));
+    let _e208 = local_5;
+    let _e209 = (*tile);
+    atlas = ((_e208 + _e209) * vec2<f32>(0.16666667f, 0.16666667f));
+    let _e214 = point_shadow.params3_[0u];
+    if (_e214 > 0.5f) {
+        let _e217 = atlas[1u];
+        atlas[1u] = (1f - _e217);
     }
-    let _e219 = atlas;
-    let _e220 = textureSampleLevel(point_shadow_texture_tex, point_shadow_texture_smp, _e219, 0f);
-    let _e222 = atlas;
-    let _e223 = textureSampleLevel(point_shadow_static_texture_tex, point_shadow_static_texture_smp, _e222, 0f);
-    let _e226 = (*range);
-    return (min(_e220.x, _e223.x) * _e226);
+    let _e220 = atlas;
+    let _e221 = textureSampleLevel(point_shadow_texture_tex, point_shadow_texture_smp, _e220, 0f);
+    let _e223 = atlas;
+    let _e224 = textureSampleLevel(point_shadow_static_texture_tex, point_shadow_static_texture_smp, _e223, 0f);
+    let _e227 = (*range);
+    return (min(_e221.x, _e224.x) * _e227);
 }
 
 fn PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b(uv_1: ptr<function, vec2<f32>>, offset_1: ptr<function, vec2<f32>>, tile_1: ptr<function, vec2<f32>>, range_1: ptr<function, f32>, receiver: ptr<function, f32>) -> f32 {
@@ -23995,24 +24149,24 @@ fn PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b(uv_1: pt
     var param_14: vec2<f32>;
     var param_15: f32;
 
-    let _e198 = (*uv_1);
-    param_12 = _e198;
-    let _e199 = (*offset_1);
-    param_13 = _e199;
-    let _e200 = (*tile_1);
-    param_14 = _e200;
-    let _e201 = (*range_1);
-    param_15 = _e201;
-    let _e202 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((&param_12), (&param_13), (&param_14), (&param_15));
-    stored = _e202;
-    let _e203 = stored;
-    let _e204 = (*range_1);
-    if (_e203 >= (_e204 * 0.999f)) {
+    let _e199 = (*uv_1);
+    param_12 = _e199;
+    let _e200 = (*offset_1);
+    param_13 = _e200;
+    let _e201 = (*tile_1);
+    param_14 = _e201;
+    let _e202 = (*range_1);
+    param_15 = _e202;
+    let _e203 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((&param_12), (&param_13), (&param_14), (&param_15));
+    stored = _e203;
+    let _e204 = stored;
+    let _e205 = (*range_1);
+    if (_e204 >= (_e205 * 0.999f)) {
         return 1f;
     }
-    let _e207 = (*receiver);
-    let _e208 = stored;
-    return select(1f, 0f, (_e207 > _e208));
+    let _e208 = (*receiver);
+    let _e209 = stored;
+    return select(1f, 0f, (_e208 > _e209));
 }
 
 fn PointShadowPenumbra_u0028_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b(uv_2: ptr<function, vec2<f32>>, tile_2: ptr<function, vec2<f32>>, range_2: ptr<function, f32>, receiver_1: ptr<function, f32>, ca_1: ptr<function, f32>, sa_1: ptr<function, f32>, tanHalf: ptr<function, f32>, blockerOut: ptr<function, f32>) -> f32 {
@@ -24039,111 +24193,111 @@ fn PointShadowPenumbra_u0028_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u
     var world: f32;
 
     (*blockerOut) = -1f;
-    let _e219 = point_shadow.params2_[1u];
-    lightRadius = _e219;
-    let _e222 = point_shadow.params2_[0u];
-    minRadius = _e222;
-    let _e225 = point_shadow.params2_[2u];
-    maxRadius = _e225;
-    let _e226 = lightRadius;
-    if (_e226 <= 0f) {
-        let _e228 = (*uv_2);
-        param_16 = _e228;
+    let _e220 = point_shadow.params2_[1u];
+    lightRadius = _e220;
+    let _e223 = point_shadow.params2_[0u];
+    minRadius = _e223;
+    let _e226 = point_shadow.params2_[2u];
+    maxRadius = _e226;
+    let _e227 = lightRadius;
+    if (_e227 <= 0f) {
+        let _e229 = (*uv_2);
+        param_16 = _e229;
         param_17 = vec2<f32>(0f, 0f);
-        let _e229 = (*tile_2);
-        param_18 = _e229;
-        let _e230 = (*range_2);
-        param_19 = _e230;
-        let _e231 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((&param_16), (&param_17), (&param_18), (&param_19));
-        (*blockerOut) = _e231;
-        let _e232 = minRadius;
-        return _e232;
+        let _e230 = (*tile_2);
+        param_18 = _e230;
+        let _e231 = (*range_2);
+        param_19 = _e231;
+        let _e232 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((&param_16), (&param_17), (&param_18), (&param_19));
+        (*blockerOut) = _e232;
+        let _e233 = minRadius;
+        return _e233;
     }
     sum = 0f;
     count = 0f;
     i_2 = 0i;
     loop {
-        let _e233 = i_2;
-        if (_e233 < 8i) {
-            let _e235 = i_2;
-            param_20 = _e235;
-            let _e236 = (*ca_1);
-            param_21 = _e236;
-            let _e237 = (*sa_1);
-            param_22 = _e237;
-            let _e238 = maxRadius;
-            param_23 = _e238;
-            let _e239 = PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b((&param_20), (&param_21), (&param_22), (&param_23));
-            let _e240 = (*uv_2);
-            param_24 = _e240;
-            param_25 = _e239;
-            let _e241 = (*tile_2);
-            param_26 = _e241;
-            let _e242 = (*range_2);
-            param_27 = _e242;
-            let _e243 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((&param_24), (&param_25), (&param_26), (&param_27));
-            stored_1 = _e243;
-            let _e244 = stored_1;
-            let _e245 = (*range_2);
-            if (_e244 >= (_e245 * 0.999f)) {
+        let _e234 = i_2;
+        if (_e234 < 8i) {
+            let _e236 = i_2;
+            param_20 = _e236;
+            let _e237 = (*ca_1);
+            param_21 = _e237;
+            let _e238 = (*sa_1);
+            param_22 = _e238;
+            let _e239 = maxRadius;
+            param_23 = _e239;
+            let _e240 = PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b((&param_20), (&param_21), (&param_22), (&param_23));
+            let _e241 = (*uv_2);
+            param_24 = _e241;
+            param_25 = _e240;
+            let _e242 = (*tile_2);
+            param_26 = _e242;
+            let _e243 = (*range_2);
+            param_27 = _e243;
+            let _e244 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((&param_24), (&param_25), (&param_26), (&param_27));
+            stored_1 = _e244;
+            let _e245 = stored_1;
+            let _e246 = (*range_2);
+            if (_e245 >= (_e246 * 0.999f)) {
                 continue;
             }
-            let _e248 = stored_1;
-            let _e249 = (*receiver_1);
-            if (_e248 >= _e249) {
+            let _e249 = stored_1;
+            let _e250 = (*receiver_1);
+            if (_e249 >= _e250) {
                 continue;
             }
-            let _e251 = stored_1;
-            let _e252 = sum;
-            sum = (_e252 + _e251);
-            let _e254 = count;
-            count = (_e254 + 1f);
+            let _e252 = stored_1;
+            let _e253 = sum;
+            sum = (_e253 + _e252);
+            let _e255 = count;
+            count = (_e255 + 1f);
             continue;
         } else {
             break;
         }
         continuing {
-            let _e256 = i_2;
-            i_2 = (_e256 + 1i);
+            let _e257 = i_2;
+            i_2 = (_e257 + 1i);
         }
     }
-    let _e258 = count;
-    if (_e258 < 0.5f) {
+    let _e259 = count;
+    if (_e259 < 0.5f) {
         return -1f;
     }
-    let _e260 = sum;
-    let _e261 = count;
-    blocker = max((_e260 / _e261), 0.0001f);
-    let _e264 = blocker;
-    (*blockerOut) = _e264;
-    let _e265 = lightRadius;
-    let _e266 = (*receiver_1);
-    let _e267 = blocker;
-    let _e271 = blocker;
-    world = ((_e265 * max((_e266 - _e267), 0f)) / _e271);
-    let _e273 = world;
-    let _e274 = (*receiver_1);
-    let _e276 = (*tanHalf);
-    let _e279 = minRadius;
-    let _e280 = maxRadius;
-    return clamp((_e273 / ((2f * _e274) * _e276)), _e279, _e280);
+    let _e261 = sum;
+    let _e262 = count;
+    blocker = max((_e261 / _e262), 0.0001f);
+    let _e265 = blocker;
+    (*blockerOut) = _e265;
+    let _e266 = lightRadius;
+    let _e267 = (*receiver_1);
+    let _e268 = blocker;
+    let _e272 = blocker;
+    world = ((_e266 * max((_e267 - _e268), 0f)) / _e272);
+    let _e274 = world;
+    let _e275 = (*receiver_1);
+    let _e277 = (*tanHalf);
+    let _e280 = minRadius;
+    let _e281 = maxRadius;
+    return clamp((_e274 / ((2f * _e275) * _e277)), _e280, _e281);
 }
 
 fn FragCoordFromTop_u0028_f1_u003b(rows: ptr<function, f32>) -> vec2<f32> {
     var local_6: vec2<f32>;
 
-    let _e190 = (*rows);
-    if (_e190 > 0f) {
-        let _e193 = gl_FragCoord_1[0u];
-        let _e194 = (*rows);
-        let _e196 = gl_FragCoord_1[1u];
-        local_6 = vec2<f32>(_e193, (_e194 - _e196));
+    let _e191 = (*rows);
+    if (_e191 > 0f) {
+        let _e194 = gl_FragCoord_1[0u];
+        let _e195 = (*rows);
+        let _e197 = gl_FragCoord_1[1u];
+        local_6 = vec2<f32>(_e194, (_e195 - _e197));
     } else {
-        let _e199 = gl_FragCoord_1;
-        local_6 = _e199.xy;
+        let _e200 = gl_FragCoord_1;
+        local_6 = _e200.xy;
     }
-    let _e201 = local_6;
-    return _e201;
+    let _e202 = local_6;
+    return _e202;
 }
 
 fn PointShadowFactor_u0028_vf3_u003b_vf3_u003b_i1_u003b(world_1: ptr<function, vec3<f32>>, normal: ptr<function, vec3<f32>>, lightIndex: ptr<function, i32>) -> f32 {
@@ -24201,257 +24355,257 @@ fn PointShadowFactor_u0028_vf3_u003b_vf3_u003b_i1_u003b(world_1: ptr<function, v
     var phi_2249_: bool;
     var phi_2310_: bool;
 
-    let _e242 = (*lightIndex);
-    let _e246 = point_shadow.slots[_e242][0u];
-    slot = i32((_e246 + 0.5f));
-    let _e249 = (*lightIndex);
-    let _e253 = point_shadow.slots[_e249][0u];
-    if (_e253 < 0f) {
+    let _e243 = (*lightIndex);
+    let _e247 = point_shadow.slots[_e243][0u];
+    slot = i32((_e247 + 0.5f));
+    let _e250 = (*lightIndex);
+    let _e254 = point_shadow.slots[_e250][0u];
+    if (_e254 < 0f) {
         return 1f;
     }
-    let _e257 = point_shadow.params[2u];
-    strength = _e257;
-    let _e258 = strength;
-    if (_e258 <= 0f) {
+    let _e258 = point_shadow.params[2u];
+    strength = _e258;
+    let _e259 = strength;
+    if (_e259 <= 0f) {
         return 1f;
     }
-    let _e260 = slot;
-    let _e263 = point_shadow.lights[_e260];
-    let _e265 = (*world_1);
-    toLight = (_e263.xyz - _e265);
-    let _e267 = toLight;
-    toLightLength = max(length(_e267), 0.000001f);
-    let _e270 = (*normal);
-    let _e271 = toLight;
-    let _e272 = toLightLength;
-    nDotL = max(dot(_e270, (_e271 / vec3(_e272))), 0.15f);
-    let _e277 = nDotL;
+    let _e261 = slot;
+    let _e264 = point_shadow.lights[_e261];
+    let _e266 = (*world_1);
+    toLight = (_e264.xyz - _e266);
+    let _e268 = toLight;
+    toLightLength = max(length(_e268), 0.000001f);
+    let _e271 = (*normal);
+    let _e272 = toLight;
+    let _e273 = toLightLength;
+    nDotL = max(dot(_e271, (_e272 / vec3(_e273))), 0.15f);
     let _e278 = nDotL;
-    let _e283 = nDotL;
+    let _e279 = nDotL;
     let _e284 = nDotL;
-    slope = min((sqrt(max((1f - (_e277 * _e278)), 0f)) / (_e283 * _e284)), 8f);
-    let _e288 = toLightLength;
-    let _e290 = (*lightIndex);
-    let _e294 = point_shadow.slots[_e290][2u];
-    let _e299 = point_shadow.params3_[1u];
-    texel = (((2f * _e288) * max(_e294, 0.0001f)) * _e299);
-    let _e301 = (*world_1);
-    let _e302 = (*normal);
-    let _e303 = texel;
-    let _e307 = point_shadow.params[3u];
-    let _e309 = slope;
-    origin = (_e301 + (((_e302 * _e303) * _e307) * (1f + _e309)));
-    let _e313 = origin;
-    let _e314 = slot;
-    let _e317 = point_shadow.lights[_e314];
-    toFragment = (_e313 - _e317.xyz);
-    let _e320 = toFragment;
-    distance_ = length(_e320);
-    let _e322 = slot;
-    let _e326 = point_shadow.lights[_e322][3u];
-    range_3 = max(_e326, 0.0001f);
-    let _e328 = distance_;
-    let _e329 = range_3;
-    if (_e328 >= _e329) {
+    let _e285 = nDotL;
+    slope = min((sqrt(max((1f - (_e278 * _e279)), 0f)) / (_e284 * _e285)), 8f);
+    let _e289 = toLightLength;
+    let _e291 = (*lightIndex);
+    let _e295 = point_shadow.slots[_e291][2u];
+    let _e300 = point_shadow.params3_[1u];
+    texel = (((2f * _e289) * max(_e295, 0.0001f)) * _e300);
+    let _e302 = (*world_1);
+    let _e303 = (*normal);
+    let _e304 = texel;
+    let _e308 = point_shadow.params[3u];
+    let _e310 = slope;
+    origin = (_e302 + (((_e303 * _e304) * _e308) * (1f + _e310)));
+    let _e314 = origin;
+    let _e315 = slot;
+    let _e318 = point_shadow.lights[_e315];
+    toFragment = (_e314 - _e318.xyz);
+    let _e321 = toFragment;
+    distance_ = length(_e321);
+    let _e323 = slot;
+    let _e327 = point_shadow.lights[_e323][3u];
+    range_3 = max(_e327, 0.0001f);
+    let _e329 = distance_;
+    let _e330 = range_3;
+    if (_e329 >= _e330) {
         return 1f;
     }
     face = 0i;
-    let _e331 = (*lightIndex);
-    let _e335 = point_shadow.slots[_e331][1u];
-    if (_e335 < 0.5f) {
-        let _e337 = toFragment;
-        a = abs(_e337);
-        let _e340 = a[0u];
-        let _e342 = a[1u];
-        let _e343 = (_e340 >= _e342);
-        phi_2249_ = _e343;
-        if _e343 {
-            let _e345 = a[0u];
-            let _e347 = a[2u];
-            phi_2249_ = (_e345 >= _e347);
+    let _e332 = (*lightIndex);
+    let _e336 = point_shadow.slots[_e332][1u];
+    if (_e336 < 0.5f) {
+        let _e338 = toFragment;
+        a = abs(_e338);
+        let _e341 = a[0u];
+        let _e343 = a[1u];
+        let _e344 = (_e341 >= _e343);
+        phi_2249_ = _e344;
+        if _e344 {
+            let _e346 = a[0u];
+            let _e348 = a[2u];
+            phi_2249_ = (_e346 >= _e348);
         }
-        let _e350 = phi_2249_;
-        if _e350 {
-            let _e352 = toFragment[0u];
-            face = select(1i, 0i, (_e352 > 0f));
+        let _e351 = phi_2249_;
+        if _e351 {
+            let _e353 = toFragment[0u];
+            face = select(1i, 0i, (_e353 > 0f));
         } else {
-            let _e356 = a[1u];
-            let _e358 = a[2u];
-            if (_e356 >= _e358) {
-                let _e361 = toFragment[1u];
-                face = select(3i, 2i, (_e361 > 0f));
+            let _e357 = a[1u];
+            let _e359 = a[2u];
+            if (_e357 >= _e359) {
+                let _e362 = toFragment[1u];
+                face = select(3i, 2i, (_e362 > 0f));
             } else {
-                let _e365 = toFragment[2u];
-                face = select(5i, 4i, (_e365 > 0f));
-            }
-        }
-    }
-    let _e368 = slot;
-    let _e370 = face;
-    let _e374 = point_shadow.faces[((_e368 * 6i) + _e370)];
-    let _e375 = origin;
-    clip = (_e374 * vec4<f32>(_e375.x, _e375.y, _e375.z, 1f));
-    let _e382 = clip[3u];
-    if (_e382 <= 0f) {
-        return 1f;
-    }
-    let _e384 = clip;
-    let _e387 = clip[3u];
-    ndc = (_e384.xy / vec2(_e387));
-    let _e391 = ndc[0u];
-    let _e393 = (abs(_e391) > 1f);
-    phi_2310_ = _e393;
-    if !(_e393) {
-        let _e396 = ndc[1u];
-        phi_2310_ = (abs(_e396) > 1f);
-    }
-    let _e400 = phi_2310_;
-    if _e400 {
-        return 1f;
-    }
-    let _e402 = ndc[0u];
-    let _e406 = ndc[1u];
-    uv_3 = vec2<f32>(((_e402 * 0.5f) + 0.5f), (0.5f - (_e406 * 0.5f)));
-    let _e410 = face;
-    let _e412 = slot;
-    tile_3 = vec2<f32>(f32(_e410), f32(_e412));
-    let _e415 = distance_;
-    let _e418 = point_shadow.params[1u];
-    receiver_2 = (_e415 - _e418);
-    let _e422 = frag_info.target_origin[0u];
-    param_28 = _e422;
-    let _e423 = FragCoordFromTop_u0028_f1_u003b((&param_28));
-    noise = fract((52.982918f * fract(dot(_e423, vec2<f32>(0.06711056f, 0.00583715f)))));
-    let _e428 = noise;
-    angle = (_e428 * 6.2831855f);
-    let _e430 = angle;
-    ca_2 = cos(_e430);
-    let _e432 = angle;
-    sa_2 = sin(_e432);
-    let _e434 = (*lightIndex);
-    let _e438 = point_shadow.slots[_e434][2u];
-    tanHalf_1 = max(_e438, 0.0001f);
-    blocker_1 = -1f;
-    let _e440 = uv_3;
-    param_29 = _e440;
-    let _e441 = tile_3;
-    param_30 = _e441;
-    let _e442 = range_3;
-    param_31 = _e442;
-    let _e443 = receiver_2;
-    param_32 = _e443;
-    let _e444 = ca_2;
-    param_33 = _e444;
-    let _e445 = sa_2;
-    param_34 = _e445;
-    let _e446 = tanHalf_1;
-    param_35 = _e446;
-    let _e447 = PointShadowPenumbra_u0028_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b((&param_29), (&param_30), (&param_31), (&param_32), (&param_33), (&param_34), (&param_35), (&param_36));
-    let _e448 = param_36;
-    blocker_1 = _e448;
-    radius_1 = _e447;
-    let _e451 = point_shadow.params2_[3u];
-    if (_e451 > 0.5f) {
+                let _e366 = toFragment[2u];
+                face = select(5i, 4i, (_e366 > 0f));
+            }
+        }
+    }
+    let _e369 = slot;
+    let _e371 = face;
+    let _e375 = point_shadow.faces[((_e369 * 6i) + _e371)];
+    let _e376 = origin;
+    clip = (_e375 * vec4<f32>(_e376.x, _e376.y, _e376.z, 1f));
+    let _e383 = clip[3u];
+    if (_e383 <= 0f) {
+        return 1f;
+    }
+    let _e385 = clip;
+    let _e388 = clip[3u];
+    ndc = (_e385.xy / vec2(_e388));
+    let _e392 = ndc[0u];
+    let _e394 = (abs(_e392) > 1f);
+    phi_2310_ = _e394;
+    if !(_e394) {
+        let _e397 = ndc[1u];
+        phi_2310_ = (abs(_e397) > 1f);
+    }
+    let _e401 = phi_2310_;
+    if _e401 {
+        return 1f;
+    }
+    let _e403 = ndc[0u];
+    let _e407 = ndc[1u];
+    uv_3 = vec2<f32>(((_e403 * 0.5f) + 0.5f), (0.5f - (_e407 * 0.5f)));
+    let _e411 = face;
+    let _e413 = slot;
+    tile_3 = vec2<f32>(f32(_e411), f32(_e413));
+    let _e416 = distance_;
+    let _e419 = point_shadow.params[1u];
+    receiver_2 = (_e416 - _e419);
+    let _e423 = frag_info.target_origin[0u];
+    param_28 = _e423;
+    let _e424 = FragCoordFromTop_u0028_f1_u003b((&param_28));
+    noise = fract((52.982918f * fract(dot(_e424, vec2<f32>(0.06711056f, 0.00583715f)))));
+    let _e429 = noise;
+    angle = (_e429 * 6.2831855f);
+    let _e431 = angle;
+    ca_2 = cos(_e431);
+    let _e433 = angle;
+    sa_2 = sin(_e433);
+    let _e435 = (*lightIndex);
+    let _e439 = point_shadow.slots[_e435][2u];
+    tanHalf_1 = max(_e439, 0.0001f);
+    blocker_1 = -1f;
+    let _e441 = uv_3;
+    param_29 = _e441;
+    let _e442 = tile_3;
+    param_30 = _e442;
+    let _e443 = range_3;
+    param_31 = _e443;
+    let _e444 = receiver_2;
+    param_32 = _e444;
+    let _e445 = ca_2;
+    param_33 = _e445;
+    let _e446 = sa_2;
+    param_34 = _e446;
+    let _e447 = tanHalf_1;
+    param_35 = _e447;
+    let _e448 = PointShadowPenumbra_u0028_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b((&param_29), (&param_30), (&param_31), (&param_32), (&param_33), (&param_34), (&param_35), (&param_36));
+    let _e449 = param_36;
+    blocker_1 = _e449;
+    radius_1 = _e448;
+    let _e452 = point_shadow.params2_[3u];
+    if (_e452 > 0.5f) {
         g_debug_surface_on = true;
-        let _e453 = radius_1;
-        if (_e453 < 0f) {
+        let _e454 = radius_1;
+        if (_e454 < 0f) {
             local_7 = vec3<f32>(0f, 0f, 1f);
         } else {
-            let _e455 = radius_1;
-            let _e458 = point_shadow.params2_[2u];
-            let _e462 = blocker_1;
-            let _e463 = range_3;
-            local_7 = vec3<f32>(clamp((_e455 / max(_e458, 0.000001f)), 0f, 1f), clamp((_e462 / _e463), 0f, 1f), 0f);
+            let _e456 = radius_1;
+            let _e459 = point_shadow.params2_[2u];
+            let _e463 = blocker_1;
+            let _e464 = range_3;
+            local_7 = vec3<f32>(clamp((_e456 / max(_e459, 0.000001f)), 0f, 1f), clamp((_e463 / _e464), 0f, 1f), 0f);
         }
-        let _e467 = local_7;
-        g_debug_surface = _e467;
+        let _e468 = local_7;
+        g_debug_surface = _e468;
     }
-    let _e468 = radius_1;
-    if (_e468 < 0f) {
+    let _e469 = radius_1;
+    if (_e469 < 0f) {
         return 1f;
     }
-    let _e470 = uv_3;
-    param_37 = _e470;
+    let _e471 = uv_3;
+    param_37 = _e471;
     param_38 = vec2<f32>(0f, 0f);
-    let _e471 = tile_3;
-    param_39 = _e471;
-    let _e472 = range_3;
-    param_40 = _e472;
-    let _e473 = receiver_2;
-    param_41 = _e473;
-    let _e474 = PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((&param_37), (&param_38), (&param_39), (&param_40), (&param_41));
-    lit_1 = _e474;
-    let _e475 = radius_1;
-    if (_e475 > 0f) {
+    let _e472 = tile_3;
+    param_39 = _e472;
+    let _e473 = range_3;
+    param_40 = _e473;
+    let _e474 = receiver_2;
+    param_41 = _e474;
+    let _e475 = PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((&param_37), (&param_38), (&param_39), (&param_40), (&param_41));
+    lit_1 = _e475;
+    let _e476 = radius_1;
+    if (_e476 > 0f) {
         i_3 = 0i;
         loop {
-            let _e477 = i_3;
-            if (_e477 < 8i) {
-                let _e479 = i_3;
-                param_42 = _e479;
-                let _e480 = ca_2;
-                param_43 = _e480;
-                let _e481 = sa_2;
-                param_44 = _e481;
-                let _e482 = radius_1;
-                param_45 = _e482;
-                let _e483 = PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b((&param_42), (&param_43), (&param_44), (&param_45));
-                let _e484 = uv_3;
-                param_46 = _e484;
-                param_47 = _e483;
-                let _e485 = tile_3;
-                param_48 = _e485;
-                let _e486 = range_3;
-                param_49 = _e486;
-                let _e487 = receiver_2;
-                param_50 = _e487;
-                let _e488 = PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((&param_46), (&param_47), (&param_48), (&param_49), (&param_50));
-                let _e489 = lit_1;
-                lit_1 = (_e489 + _e488);
+            let _e478 = i_3;
+            if (_e478 < 8i) {
+                let _e480 = i_3;
+                param_42 = _e480;
+                let _e481 = ca_2;
+                param_43 = _e481;
+                let _e482 = sa_2;
+                param_44 = _e482;
+                let _e483 = radius_1;
+                param_45 = _e483;
+                let _e484 = PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b((&param_42), (&param_43), (&param_44), (&param_45));
+                let _e485 = uv_3;
+                param_46 = _e485;
+                param_47 = _e484;
+                let _e486 = tile_3;
+                param_48 = _e486;
+                let _e487 = range_3;
+                param_49 = _e487;
+                let _e488 = receiver_2;
+                param_50 = _e488;
+                let _e489 = PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((&param_46), (&param_47), (&param_48), (&param_49), (&param_50));
+                let _e490 = lit_1;
+                lit_1 = (_e490 + _e489);
                 continue;
             } else {
                 break;
             }
             continuing {
-                let _e491 = i_3;
-                i_3 = (_e491 + 1i);
+                let _e492 = i_3;
+                i_3 = (_e492 + 1i);
             }
         }
-        let _e493 = lit_1;
-        lit_1 = (_e493 * 0.11111111f);
+        let _e494 = lit_1;
+        lit_1 = (_e494 * 0.11111111f);
     }
-    let _e495 = lit_1;
-    let _e496 = strength;
-    return mix(1f, _e495, clamp(_e496, 0f, 1f));
+    let _e496 = lit_1;
+    let _e497 = strength;
+    return mix(1f, _e496, clamp(_e497, 0f, 1f));
 }
 
 fn VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b(i_4: ptr<function, i32>, n_1: ptr<function, i32>, turn: ptr<function, f32>) -> vec2<f32> {
     var r: f32;
     var theta: f32;
 
-    let _e193 = (*i_4);
-    let _e196 = (*n_1);
-    r = sqrt(((f32(_e193) + 0.5f) / f32(_e196)));
-    let _e200 = (*i_4);
-    let _e203 = (*turn);
-    theta = ((f32(_e200) * 2.3999631f) + _e203);
-    let _e205 = r;
-    let _e206 = theta;
-    let _e208 = theta;
-    return (vec2<f32>(cos(_e206), sin(_e208)) * _e205);
+    let _e194 = (*i_4);
+    let _e197 = (*n_1);
+    r = sqrt(((f32(_e194) + 0.5f) / f32(_e197)));
+    let _e201 = (*i_4);
+    let _e204 = (*turn);
+    theta = ((f32(_e201) * 2.3999631f) + _e204);
+    let _e206 = r;
+    let _e207 = theta;
+    let _e209 = theta;
+    return (vec2<f32>(cos(_e207), sin(_e209)) * _e206);
 }
 
 fn ShadowNoise_u0028_() -> f32 {
     var at: vec2<f32>;
     var param_51: f32;
 
-    let _e192 = frag_info.target_origin[0u];
-    param_51 = _e192;
-    let _e193 = FragCoordFromTop_u0028_f1_u003b((&param_51));
-    let _e196 = frag_info.target_origin[3u];
-    at = (_e193 + vec2((5.588238f * max(_e196, 0f))));
-    let _e201 = at;
-    return fract((52.982918f * fract(dot(_e201, vec2<f32>(0.06711056f, 0.00583715f)))));
+    let _e193 = frag_info.target_origin[0u];
+    param_51 = _e193;
+    let _e194 = FragCoordFromTop_u0028_f1_u003b((&param_51));
+    let _e197 = frag_info.target_origin[3u];
+    at = (_e194 + vec2((5.588238f * max(_e197, 0f))));
+    let _e202 = at;
+    return fract((52.982918f * fract(dot(_e202, vec2<f32>(0.06711056f, 0.00583715f)))));
 }
 
 fn EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b(moments: ptr<function, vec2<f32>>, t: ptr<function, f32>, minVariance: ptr<function, f32>, bleed: ptr<function, f32>) -> f32 {
@@ -24460,37 +24614,37 @@ fn EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b(moments: ptr<functio
     var pMax: f32;
     var reduced: f32;
 
-    let _e197 = (*moments)[1u];
-    let _e199 = (*moments)[0u];
-    let _e201 = (*moments)[0u];
-    let _e204 = (*minVariance);
-    variance = max((_e197 - (_e199 * _e201)), _e204);
-    let _e206 = (*t);
-    let _e208 = (*moments)[0u];
-    d_1 = (_e206 - _e208);
-    let _e210 = variance;
+    let _e198 = (*moments)[1u];
+    let _e200 = (*moments)[0u];
+    let _e202 = (*moments)[0u];
+    let _e205 = (*minVariance);
+    variance = max((_e198 - (_e200 * _e202)), _e205);
+    let _e207 = (*t);
+    let _e209 = (*moments)[0u];
+    d_1 = (_e207 - _e209);
     let _e211 = variance;
-    let _e212 = d_1;
+    let _e212 = variance;
     let _e213 = d_1;
-    pMax = (_e210 / (_e211 + (_e212 * _e213)));
-    let _e217 = pMax;
-    let _e218 = (*bleed);
-    let _e220 = (*bleed);
-    reduced = clamp(((_e217 - _e218) / max((1f - _e220), 0.0001f)), 0f, 1f);
-    let _e225 = (*t);
-    let _e227 = (*moments)[0u];
-    let _e229 = reduced;
-    return select(_e229, 1f, (_e225 <= _e227));
+    let _e214 = d_1;
+    pMax = (_e211 / (_e212 + (_e213 * _e214)));
+    let _e218 = pMax;
+    let _e219 = (*bleed);
+    let _e221 = (*bleed);
+    reduced = clamp(((_e218 - _e219) / max((1f - _e221), 0.0001f)), 0f, 1f);
+    let _e226 = (*t);
+    let _e228 = (*moments)[0u];
+    let _e230 = reduced;
+    return select(_e230, 1f, (_e226 <= _e228));
 }
 
 fn EvsmWarp_u0028_f1_u003b(depth: ptr<function, f32>) -> vec2<f32> {
     var d_2: f32;
 
-    let _e190 = (*depth);
-    d_2 = ((2f * clamp(_e190, 0f, 1f)) - 1f);
-    let _e194 = d_2;
-    let _e197 = d_2;
-    return vec2<f32>(exp((40f * _e194)), -(exp((-5f * _e197))));
+    let _e191 = (*depth);
+    d_2 = ((2f * clamp(_e191, 0f, 1f)) - 1f);
+    let _e195 = d_2;
+    let _e198 = d_2;
+    return vec2<f32>(exp((40f * _e195)), -(exp((-5f * _e198))));
 }
 
 fn EvsmVisibility_u0028_vf4_u003b_f1_u003b_f1_u003b(moments_1: ptr<function, vec4<f32>>, depth_1: ptr<function, f32>, bleed_1: ptr<function, f32>) -> f32 {
@@ -24508,37 +24662,37 @@ fn EvsmVisibility_u0028_vf4_u003b_f1_u003b_f1_u003b(moments_1: ptr<function, vec
     var param_59: f32;
     var param_60: f32;
 
-    let _e204 = (*depth_1);
-    param_52 = _e204;
-    let _e205 = EvsmWarp_u0028_f1_u003b((&param_52));
-    warped = _e205;
-    let _e206 = warped;
-    scale = (vec2<f32>(0.004f, 0.0005f) * _e206);
-    let _e209 = scale[0u];
-    let _e211 = scale[0u];
-    let _e213 = (*moments_1);
-    param_53 = _e213.xy;
-    let _e216 = warped[0u];
-    param_54 = _e216;
-    param_55 = (_e209 * _e211);
-    let _e217 = (*bleed_1);
-    param_56 = _e217;
-    let _e218 = EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b((&param_53), (&param_54), (&param_55), (&param_56));
-    positive = _e218;
-    let _e220 = scale[1u];
-    let _e222 = scale[1u];
-    let _e224 = (*moments_1);
-    param_57 = _e224.zw;
-    let _e227 = warped[1u];
-    param_58 = _e227;
-    param_59 = (_e220 * _e222);
-    let _e228 = (*bleed_1);
-    param_60 = _e228;
-    let _e229 = EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b((&param_57), (&param_58), (&param_59), (&param_60));
-    negative = _e229;
-    let _e230 = positive;
-    let _e231 = negative;
-    return min(_e230, _e231);
+    let _e205 = (*depth_1);
+    param_52 = _e205;
+    let _e206 = EvsmWarp_u0028_f1_u003b((&param_52));
+    warped = _e206;
+    let _e207 = warped;
+    scale = (vec2<f32>(0.004f, 0.0005f) * _e207);
+    let _e210 = scale[0u];
+    let _e212 = scale[0u];
+    let _e214 = (*moments_1);
+    param_53 = _e214.xy;
+    let _e217 = warped[0u];
+    param_54 = _e217;
+    param_55 = (_e210 * _e212);
+    let _e218 = (*bleed_1);
+    param_56 = _e218;
+    let _e219 = EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b((&param_53), (&param_54), (&param_55), (&param_56));
+    positive = _e219;
+    let _e221 = scale[1u];
+    let _e223 = scale[1u];
+    let _e225 = (*moments_1);
+    param_57 = _e225.zw;
+    let _e228 = warped[1u];
+    param_58 = _e228;
+    param_59 = (_e221 * _e223);
+    let _e229 = (*bleed_1);
+    param_60 = _e229;
+    let _e230 = EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b((&param_57), (&param_58), (&param_59), (&param_60));
+    negative = _e230;
+    let _e231 = positive;
+    let _e232 = negative;
+    return min(_e231, _e232);
 }
 
 fn ShadowFactor_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b_i1_u003b(s_2: ptr<function, Surface>, light_1: ptr<function, LightSample>, lightIndex_1: ptr<function, i32>) -> f32 {
@@ -24576,6 +24730,8 @@ fn ShadowFactor_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf
     var tileLo: vec2<f32>;
     var tileHi: vec2<f32>;
     var stored_2: vec4<f32>;
+    var y: i32;
+    var x: i32;
     var through: vec3<f32>;
     var softness: f32;
     var lit_2: f32;
@@ -24583,8 +24739,8 @@ fn ShadowFactor_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf
     var param_61: vec4<f32>;
     var param_62: f32;
     var param_63: f32;
-    var y: i32;
-    var x: i32;
+    var y_1: i32;
+    var x_1: i32;
     var occluder: f32;
     var spread: f32;
     var turn_1: f32;
@@ -24613,45 +24769,45 @@ fn ShadowFactor_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf
     var phi_3710_: bool;
     var phi_3717_: bool;
 
-    let _e258 = frag_info.shadow_params[3u];
-    strength_1 = _e258;
-    let _e259 = strength_1;
-    if (_e259 <= 0f) {
+    let _e261 = frag_info.shadow_params[3u];
+    strength_1 = _e261;
+    let _e262 = strength_1;
+    if (_e262 <= 0f) {
         return 1f;
     }
-    let _e261 = (*lightIndex_1);
-    let _e264 = frag_info.frame_params[2u];
-    if (_e261 != i32((_e264 + 0.5f))) {
+    let _e264 = (*lightIndex_1);
+    let _e267 = frag_info.frame_params[2u];
+    if (_e264 != i32((_e267 + 0.5f))) {
         return 1f;
     }
-    let _e270 = frag_info.shadow_cascades[2u];
-    cascadeCount = i32((_e270 + 0.5f));
-    let _e273 = v_world_position_1;
-    let _e275 = frag_info.camera_position;
-    viewDistance = length((_e273 - _e275.xyz));
+    let _e273 = frag_info.shadow_cascades[2u];
+    cascadeCount = i32((_e273 + 0.5f));
+    let _e276 = v_world_position_1;
+    let _e278 = frag_info.camera_position;
+    viewDistance = length((_e276 - _e278.xyz));
     cascade = 0i;
-    let _e279 = cascadeCount;
-    let _e280 = (_e279 > 1i);
-    phi_3531_ = _e280;
-    if _e280 {
-        let _e281 = viewDistance;
-        let _e284 = frag_info.shadow_cascades[0u];
-        phi_3531_ = (_e281 > _e284);
-    }
-    let _e287 = phi_3531_;
-    if _e287 {
+    let _e282 = cascadeCount;
+    let _e283 = (_e282 > 1i);
+    phi_3531_ = _e283;
+    if _e283 {
+        let _e284 = viewDistance;
+        let _e287 = frag_info.shadow_cascades[0u];
+        phi_3531_ = (_e284 > _e287);
+    }
+    let _e290 = phi_3531_;
+    if _e290 {
         cascade = 1i;
     }
-    let _e288 = cascadeCount;
-    let _e289 = (_e288 > 2i);
-    phi_3542_ = _e289;
-    if _e289 {
-        let _e290 = viewDistance;
-        let _e293 = frag_info.shadow_cascades[1u];
-        phi_3542_ = (_e290 > _e293);
+    let _e291 = cascadeCount;
+    let _e292 = (_e291 > 2i);
+    phi_3542_ = _e292;
+    if _e292 {
+        let _e293 = viewDistance;
+        let _e296 = frag_info.shadow_cascades[1u];
+        phi_3542_ = (_e293 > _e296);
     }
-    let _e296 = phi_3542_;
-    if _e296 {
+    let _e299 = phi_3542_;
+    if _e299 {
         cascade = 2i;
     }
     uv_4 = vec2<f32>(0f, 0f);
@@ -24662,247 +24818,280 @@ fn ShadowFactor_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf
     receiverSlope = 0f;
     attempt = 0i;
     loop {
-        let _e297 = attempt;
-        if (_e297 < 3i) {
-            let _e299 = cascade;
-            let _e300 = attempt;
-            which = (_e299 + _e300);
-            let _e302 = which;
-            let _e303 = cascadeCount;
-            if (_e302 >= _e303) {
+        let _e300 = attempt;
+        if (_e300 < 3i) {
+            let _e302 = cascade;
+            let _e303 = attempt;
+            which = (_e302 + _e303);
+            let _e305 = which;
+            let _e306 = cascadeCount;
+            if (_e305 >= _e306) {
                 break;
             }
-            let _e305 = which;
-            if (_e305 == 0i) {
-                let _e308 = frag_info.shadow_matrix;
-                local_8 = _e308;
+            let _e308 = which;
+            if (_e308 == 0i) {
+                let _e311 = frag_info.shadow_matrix;
+                local_8 = _e311;
             } else {
-                let _e309 = which;
-                if (_e309 == 1i) {
-                    let _e312 = frag_info.shadow_matrix_far;
-                    local_9 = _e312;
+                let _e312 = which;
+                if (_e312 == 1i) {
+                    let _e315 = frag_info.shadow_matrix_far;
+                    local_9 = _e315;
                 } else {
-                    let _e314 = frag_info.shadow_matrix_farthest;
-                    local_9 = _e314;
+                    let _e317 = frag_info.shadow_matrix_farthest;
+                    local_9 = _e317;
                 }
-                let _e315 = local_9;
-                local_8 = _e315;
-            }
-            let _e316 = local_8;
-            matrix = _e316;
-            let _e319 = matrix[0][0u];
-            let _e322 = matrix[1][0u];
-            let _e325 = matrix[2][0u];
-            axisX = vec3<f32>(_e319, _e322, _e325);
-            let _e329 = matrix[0][1u];
-            let _e332 = matrix[1][1u];
-            let _e335 = matrix[2][1u];
-            axisY = vec3<f32>(_e329, _e332, _e335);
-            let _e337 = axisX;
-            rowX = max(length(_e337), 0.000001f);
-            let _e340 = axisY;
-            rowY = max(length(_e340), 0.000001f);
-            let _e345 = frag_info.shadow_cascades[3u];
-            let _e347 = rowX;
-            texelMetres = ((2f * _e345) / _e347);
-            let _e351 = frag_info.shadow_cascades[3u];
-            let _e354 = (*s_2).n;
-            let _e355 = axisX;
-            let _e358 = rowX;
-            let _e359 = rowX;
-            let _e363 = (*s_2).n;
-            let _e364 = axisY;
-            let _e367 = rowY;
-            let _e368 = rowY;
-            reach = ((3f * _e351) * ((abs(dot(_e354, _e355)) / (_e358 * _e359)) + (abs(dot(_e363, _e364)) / (_e367 * _e368))));
-            let _e375 = frag_info.shadow_params[2u];
-            let _e376 = texelMetres;
-            flatOffset = min(_e375, _e376);
-            let _e378 = v_world_position_1;
-            let _e380 = (*s_2).n;
-            let _e381 = flatOffset;
-            let _e382 = reach;
-            origin_1 = (_e378 + (_e380 * (_e381 + _e382)));
-            let _e386 = matrix;
-            let _e387 = origin_1;
-            lightSpace = (_e386 * vec4<f32>(_e387.x, _e387.y, _e387.z, 1f));
-            let _e394 = lightSpace[3u];
-            if (_e394 <= 0f) {
+                let _e318 = local_9;
+                local_8 = _e318;
+            }
+            let _e319 = local_8;
+            matrix = _e319;
+            let _e322 = matrix[0][0u];
+            let _e325 = matrix[1][0u];
+            let _e328 = matrix[2][0u];
+            axisX = vec3<f32>(_e322, _e325, _e328);
+            let _e332 = matrix[0][1u];
+            let _e335 = matrix[1][1u];
+            let _e338 = matrix[2][1u];
+            axisY = vec3<f32>(_e332, _e335, _e338);
+            let _e340 = axisX;
+            rowX = max(length(_e340), 0.000001f);
+            let _e343 = axisY;
+            rowY = max(length(_e343), 0.000001f);
+            let _e348 = frag_info.shadow_cascades[3u];
+            let _e350 = rowX;
+            texelMetres = ((2f * _e348) / _e350);
+            let _e354 = frag_info.shadow_cascades[3u];
+            let _e357 = (*s_2).n;
+            let _e358 = axisX;
+            let _e361 = rowX;
+            let _e362 = rowX;
+            let _e366 = (*s_2).n;
+            let _e367 = axisY;
+            let _e370 = rowY;
+            let _e371 = rowY;
+            reach = ((3f * _e354) * ((abs(dot(_e357, _e358)) / (_e361 * _e362)) + (abs(dot(_e366, _e367)) / (_e370 * _e371))));
+            let _e378 = frag_info.shadow_params[2u];
+            let _e379 = texelMetres;
+            flatOffset = min(_e378, _e379);
+            let _e381 = v_world_position_1;
+            let _e383 = (*s_2).n;
+            let _e384 = flatOffset;
+            let _e385 = reach;
+            origin_1 = (_e381 + (_e383 * (_e384 + _e385)));
+            let _e389 = matrix;
+            let _e390 = origin_1;
+            lightSpace = (_e389 * vec4<f32>(_e390.x, _e390.y, _e390.z, 1f));
+            let _e397 = lightSpace[3u];
+            if (_e397 <= 0f) {
                 continue;
             }
-            let _e396 = lightSpace;
-            let _e399 = lightSpace[3u];
-            candidate = (_e396.xyz / vec3(_e399));
-            let _e403 = candidate[0u];
-            let _e407 = candidate[1u];
-            inTile = vec2<f32>(((_e403 * 0.5f) + 0.5f), (0.5f - (_e407 * 0.5f)));
-            let _e412 = inTile[0u];
-            let _e413 = (_e412 < 0f);
-            phi_3703_ = _e413;
-            if !(_e413) {
-                let _e416 = inTile[0u];
-                phi_3703_ = (_e416 > 1f);
-            }
-            let _e419 = phi_3703_;
-            phi_3710_ = _e419;
-            if !(_e419) {
-                let _e422 = inTile[1u];
-                phi_3710_ = (_e422 < 0f);
-            }
-            let _e425 = phi_3710_;
-            phi_3717_ = _e425;
-            if !(_e425) {
-                let _e428 = inTile[1u];
-                phi_3717_ = (_e428 > 1f);
-            }
-            let _e431 = phi_3717_;
-            if _e431 {
+            let _e399 = lightSpace;
+            let _e402 = lightSpace[3u];
+            candidate = (_e399.xyz / vec3(_e402));
+            let _e406 = candidate[0u];
+            let _e410 = candidate[1u];
+            inTile = vec2<f32>(((_e406 * 0.5f) + 0.5f), (0.5f - (_e410 * 0.5f)));
+            let _e415 = inTile[0u];
+            let _e416 = (_e415 < 0f);
+            phi_3703_ = _e416;
+            if !(_e416) {
+                let _e419 = inTile[0u];
+                phi_3703_ = (_e419 > 1f);
+            }
+            let _e422 = phi_3703_;
+            phi_3710_ = _e422;
+            if !(_e422) {
+                let _e425 = inTile[1u];
+                phi_3710_ = (_e425 < 0f);
+            }
+            let _e428 = phi_3710_;
+            phi_3717_ = _e428;
+            if !(_e428) {
+                let _e431 = inTile[1u];
+                phi_3717_ = (_e431 > 1f);
+            }
+            let _e434 = phi_3717_;
+            if _e434 {
                 continue;
             }
-            let _e433 = candidate[2u];
-            if (_e433 > 1f) {
-                let _e435 = which;
-                let _e436 = cascadeCount;
-                if (_e435 < (_e436 - 1i)) {
+            let _e436 = candidate[2u];
+            if (_e436 > 1f) {
+                let _e438 = which;
+                let _e439 = cascadeCount;
+                if (_e438 < (_e439 - 1i)) {
                     continue;
                 }
                 candidate[2u] = 1f;
             }
-            let _e441 = inTile[0u];
-            let _e442 = which;
-            let _e445 = cascadeCount;
-            let _e449 = inTile[1u];
-            uv_4 = vec2<f32>(((_e441 + f32(_e442)) / f32(_e445)), _e449);
-            let _e451 = candidate;
-            projected = _e451;
-            let _e452 = which;
-            cascade = _e452;
-            let _e453 = texelMetres;
-            cascadeTexel = _e453;
-            let _e456 = matrix[0][2u];
-            let _e459 = matrix[1][2u];
-            let _e462 = matrix[2][2u];
-            cascadeDepth = (1f / max(length(vec3<f32>(_e456, _e459, _e462)), 0.000001f));
-            let _e468 = (*s_2).n;
-            let _e471 = matrix[0][2u];
-            let _e474 = matrix[1][2u];
-            let _e477 = matrix[2][2u];
-            let _e481 = cascadeDepth;
-            cosSlope = clamp((abs(dot(_e468, vec3<f32>(_e471, _e474, _e477))) * _e481), 0.1f, 1f);
-            let _e484 = texelMetres;
-            let _e485 = cosSlope;
-            let _e486 = cosSlope;
-            let _e492 = cosSlope;
-            let _e494 = cascadeDepth;
-            receiverSlope = (((_e484 * sqrt(max((1f - (_e485 * _e486)), 0f))) / _e492) / _e494);
+            let _e444 = inTile[0u];
+            let _e445 = which;
+            let _e448 = cascadeCount;
+            let _e452 = inTile[1u];
+            uv_4 = vec2<f32>(((_e444 + f32(_e445)) / f32(_e448)), _e452);
+            let _e454 = candidate;
+            projected = _e454;
+            let _e455 = which;
+            cascade = _e455;
+            let _e456 = texelMetres;
+            cascadeTexel = _e456;
+            let _e459 = matrix[0][2u];
+            let _e462 = matrix[1][2u];
+            let _e465 = matrix[2][2u];
+            cascadeDepth = (1f / max(length(vec3<f32>(_e459, _e462, _e465)), 0.000001f));
+            let _e471 = (*s_2).n;
+            let _e474 = matrix[0][2u];
+            let _e477 = matrix[1][2u];
+            let _e480 = matrix[2][2u];
+            let _e484 = cascadeDepth;
+            cosSlope = clamp((abs(dot(_e471, vec3<f32>(_e474, _e477, _e480))) * _e484), 0.1f, 1f);
+            let _e487 = texelMetres;
+            let _e488 = cosSlope;
+            let _e489 = cosSlope;
+            let _e495 = cosSlope;
+            let _e497 = cascadeDepth;
+            receiverSlope = (((_e487 * sqrt(max((1f - (_e488 * _e489)), 0f))) / _e495) / _e497);
             found = true;
             break;
         } else {
             break;
         }
         continuing {
-            let _e496 = attempt;
-            attempt = (_e496 + 1i);
+            let _e499 = attempt;
+            attempt = (_e499 + 1i);
         }
     }
-    let _e498 = found;
-    if !(_e498) {
+    let _e501 = found;
+    if !(_e501) {
         return 1f;
     }
-    let _e500 = cascade;
-    if (_e500 == 0i) {
-        let _e504 = frag_info.shadow_bias[0u];
-        local_10 = _e504;
+    let _e503 = cascade;
+    if (_e503 == 0i) {
+        let _e507 = frag_info.shadow_bias[0u];
+        local_10 = _e507;
     } else {
-        let _e505 = cascade;
-        if (_e505 == 1i) {
-            let _e509 = frag_info.shadow_bias[1u];
-            local_11 = _e509;
-        } else {
-            let _e512 = frag_info.shadow_bias[2u];
+        let _e508 = cascade;
+        if (_e508 == 1i) {
+            let _e512 = frag_info.shadow_bias[1u];
             local_11 = _e512;
-        }
-        let _e513 = local_11;
-        local_10 = _e513;
-    }
-    let _e514 = local_10;
-    bias = _e514;
-    let _e517 = frag_info.shadow_params[0u];
-    let _e520 = frag_info.shadow_cascades[3u];
-    texel_1 = vec2<f32>(_e517, _e520);
-    let _e522 = cascade;
-    let _e524 = cascadeCount;
-    let _e528 = texel_1;
-    tileLo = (vec2<f32>((f32(_e522) / f32(_e524)), 0f) + (_e528 * 0.5f));
-    let _e531 = cascade;
-    let _e534 = cascadeCount;
-    let _e538 = texel_1;
-    tileHi = (vec2<f32>((f32((_e531 + 1i)) / f32(_e534)), 1f) - (_e538 * 0.5f));
-    let _e543 = frag_info.shadow_bias[3u];
-    if (_e543 > 0.5f) {
-        let _e545 = uv_4;
-        let _e546 = tileLo;
-        let _e547 = tileHi;
-        let _e549 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp(_e545, _e546, _e547), 0f);
-        stored_2 = _e549;
-        let _e551 = stored_2[1u];
-        let _e554 = stored_2[2u];
-        let _e557 = stored_2[3u];
-        through = clamp(vec3<f32>((1f - _e551), (1f - _e554), _e557), vec3(0f), vec3(4f));
-        let _e562 = through;
-        let _e563 = strength_1;
-        light_transmittance = mix(vec3<f32>(1f, 1f, 1f), _e562, vec3(clamp(_e563, 0f, 1f)));
-    }
-    let _e569 = frag_info.ambient_ground[3u];
-    softness = _e569;
+        } else {
+            let _e515 = frag_info.shadow_bias[2u];
+            local_11 = _e515;
+        }
+        let _e516 = local_11;
+        local_10 = _e516;
+    }
+    let _e517 = local_10;
+    bias = _e517;
+    let _e520 = frag_info.shadow_params[0u];
+    let _e523 = frag_info.shadow_cascades[3u];
+    texel_1 = vec2<f32>(_e520, _e523);
+    let _e525 = cascade;
+    let _e527 = cascadeCount;
+    let _e531 = texel_1;
+    tileLo = (vec2<f32>((f32(_e525) / f32(_e527)), 0f) + (_e531 * 0.5f));
+    let _e534 = cascade;
+    let _e537 = cascadeCount;
+    let _e541 = texel_1;
+    tileHi = (vec2<f32>((f32((_e534 + 1i)) / f32(_e537)), 1f) - (_e541 * 0.5f));
+    let _e546 = frag_info.shadow_bias[3u];
+    if (_e546 > 0.5f) {
+        stored_2 = vec4<f32>(0f, 0f, 0f, 0f);
+        y = -1i;
+        loop {
+            let _e548 = y;
+            if (_e548 <= 1i) {
+                x = -1i;
+                loop {
+                    let _e550 = x;
+                    if (_e550 <= 1i) {
+                        let _e552 = uv_4;
+                        let _e553 = x;
+                        let _e555 = y;
+                        let _e558 = texel_1;
+                        let _e561 = tileLo;
+                        let _e562 = tileHi;
+                        let _e564 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e552 + (vec2<f32>(f32(_e553), f32(_e555)) * _e558)), _e561, _e562), 0f);
+                        let _e565 = stored_2;
+                        stored_2 = (_e565 + _e564);
+                        continue;
+                    } else {
+                        break;
+                    }
+                    continuing {
+                        let _e567 = x;
+                        x = (_e567 + 1i);
+                    }
+                }
+                continue;
+            } else {
+                break;
+            }
+            continuing {
+                let _e569 = y;
+                y = (_e569 + 1i);
+            }
+        }
+        let _e571 = stored_2;
+        stored_2 = (_e571 * 0.11111111f);
+        let _e574 = stored_2[1u];
+        let _e577 = stored_2[2u];
+        let _e580 = stored_2[3u];
+        through = clamp(vec3<f32>((1f - _e574), (1f - _e577), _e580), vec3(0f), vec3(4f));
+        let _e585 = through;
+        let _e586 = strength_1;
+        light_transmittance = mix(vec3<f32>(1f, 1f, 1f), _e585, vec3(clamp(_e586, 0f, 1f)));
+    }
+    let _e592 = frag_info.ambient_ground[3u];
+    softness = _e592;
     lit_2 = 0f;
-    let _e570 = softness;
-    if (_e570 < 0f) {
-        let _e572 = uv_4;
-        let _e573 = tileLo;
-        let _e574 = tileHi;
-        let _e576 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp(_e572, _e573, _e574), 0f);
-        moments_2 = _e576;
-        let _e578 = projected[2u];
-        let _e579 = bias;
-        let _e581 = softness;
-        let _e585 = moments_2;
-        param_61 = _e585;
-        param_62 = (_e578 - _e579);
-        param_63 = clamp((-(_e581) - 1f), 0f, 0.95f);
-        let _e586 = EvsmVisibility_u0028_vf4_u003b_f1_u003b_f1_u003b((&param_61), (&param_62), (&param_63));
-        lit_2 = _e586;
-    } else {
-        let _e587 = softness;
-        if (_e587 <= 0f) {
-            y = -1i;
+    let _e593 = softness;
+    if (_e593 < 0f) {
+        let _e595 = uv_4;
+        let _e596 = tileLo;
+        let _e597 = tileHi;
+        let _e599 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp(_e595, _e596, _e597), 0f);
+        moments_2 = _e599;
+        let _e601 = projected[2u];
+        let _e602 = bias;
+        let _e604 = softness;
+        let _e608 = moments_2;
+        param_61 = _e608;
+        param_62 = (_e601 - _e602);
+        param_63 = clamp((-(_e604) - 1f), 0f, 0.95f);
+        let _e609 = EvsmVisibility_u0028_vf4_u003b_f1_u003b_f1_u003b((&param_61), (&param_62), (&param_63));
+        lit_2 = _e609;
+    } else {
+        let _e610 = softness;
+        if (_e610 <= 0f) {
+            y_1 = -1i;
             loop {
-                let _e589 = y;
-                if (_e589 <= 1i) {
-                    x = -1i;
+                let _e612 = y_1;
+                if (_e612 <= 1i) {
+                    x_1 = -1i;
                     loop {
-                        let _e591 = x;
-                        if (_e591 <= 1i) {
-                            let _e593 = uv_4;
-                            let _e594 = x;
-                            let _e596 = y;
-                            let _e599 = texel_1;
-                            let _e602 = tileLo;
-                            let _e603 = tileHi;
-                            let _e605 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e593 + (vec2<f32>(f32(_e594), f32(_e596)) * _e599)), _e602, _e603), 0f);
-                            occluder = _e605.x;
-                            let _e608 = projected[2u];
-                            let _e609 = bias;
-                            let _e611 = occluder;
-                            let _e614 = lit_2;
-                            lit_2 = (_e614 + select(1f, 0f, ((_e608 - _e609) > _e611)));
+                        let _e614 = x_1;
+                        if (_e614 <= 1i) {
+                            let _e616 = uv_4;
+                            let _e617 = x_1;
+                            let _e619 = y_1;
+                            let _e622 = texel_1;
+                            let _e625 = tileLo;
+                            let _e626 = tileHi;
+                            let _e628 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e616 + (vec2<f32>(f32(_e617), f32(_e619)) * _e622)), _e625, _e626), 0f);
+                            occluder = _e628.x;
+                            let _e631 = projected[2u];
+                            let _e632 = bias;
+                            let _e634 = occluder;
+                            let _e637 = lit_2;
+                            lit_2 = (_e637 + select(1f, 0f, ((_e631 - _e632) > _e634)));
                             continue;
                         } else {
                             break;
                         }
                         continuing {
-                            let _e616 = x;
-                            x = (_e616 + 1i);
+                            let _e639 = x_1;
+                            x_1 = (_e639 + 1i);
                         }
                     }
                     continue;
@@ -24910,125 +25099,125 @@ fn ShadowFactor_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf
                     break;
                 }
                 continuing {
-                    let _e618 = y;
-                    y = (_e618 + 1i);
+                    let _e641 = y_1;
+                    y_1 = (_e641 + 1i);
                 }
             }
-            let _e620 = lit_2;
-            lit_2 = (_e620 * 0.11111111f);
+            let _e643 = lit_2;
+            lit_2 = (_e643 * 0.11111111f);
         } else {
-            let _e622 = softness;
-            spread = tan(min(_e622, 0.5f));
-            let _e625 = ShadowNoise_u0028_();
-            turn_1 = (_e625 * 6.2831855f);
-            let _e627 = spread;
-            let _e629 = projected[2u];
-            let _e631 = cascadeDepth;
-            let _e633 = cascadeTexel;
-            searchRadius = clamp((((_e627 * _e629) * _e631) / _e633), 1f, 16f);
+            let _e645 = softness;
+            spread = tan(min(_e645, 0.5f));
+            let _e648 = ShadowNoise_u0028_();
+            turn_1 = (_e648 * 6.2831855f);
+            let _e650 = spread;
+            let _e652 = projected[2u];
+            let _e654 = cascadeDepth;
+            let _e656 = cascadeTexel;
+            searchRadius = clamp((((_e650 * _e652) * _e654) / _e656), 1f, 16f);
             blockerSum = 0f;
             blockerCount = 0f;
             i_5 = 0i;
             loop {
-                let _e636 = i_5;
-                if (_e636 < 16i) {
-                    let _e638 = i_5;
-                    param_64 = _e638;
+                let _e659 = i_5;
+                if (_e659 < 16i) {
+                    let _e661 = i_5;
+                    param_64 = _e661;
                     param_65 = 16i;
-                    let _e639 = turn_1;
-                    param_66 = _e639;
-                    let _e640 = VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b((&param_64), (&param_65), (&param_66));
-                    disc = _e640;
-                    let _e641 = bias;
-                    let _e642 = disc;
-                    let _e644 = searchRadius;
-                    let _e648 = receiverSlope;
-                    tapBias = (_e641 + (max(((length(_e642) * _e644) - 1.5f), 0f) * _e648));
-                    let _e651 = uv_4;
-                    let _e652 = disc;
-                    let _e653 = texel_1;
-                    let _e655 = searchRadius;
-                    let _e658 = tileLo;
-                    let _e659 = tileHi;
-                    let _e661 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e651 + ((_e652 * _e653) * _e655)), _e658, _e659), 0f);
-                    occluder_1 = _e661.x;
-                    let _e664 = projected[2u];
-                    let _e665 = tapBias;
-                    let _e667 = occluder_1;
-                    if ((_e664 - _e665) > _e667) {
-                        let _e669 = occluder_1;
-                        let _e670 = blockerSum;
-                        blockerSum = (_e670 + _e669);
-                        let _e672 = blockerCount;
-                        blockerCount = (_e672 + 1f);
+                    let _e662 = turn_1;
+                    param_66 = _e662;
+                    let _e663 = VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b((&param_64), (&param_65), (&param_66));
+                    disc = _e663;
+                    let _e664 = bias;
+                    let _e665 = disc;
+                    let _e667 = searchRadius;
+                    let _e671 = receiverSlope;
+                    tapBias = (_e664 + (max(((length(_e665) * _e667) - 1.5f), 0f) * _e671));
+                    let _e674 = uv_4;
+                    let _e675 = disc;
+                    let _e676 = texel_1;
+                    let _e678 = searchRadius;
+                    let _e681 = tileLo;
+                    let _e682 = tileHi;
+                    let _e684 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e674 + ((_e675 * _e676) * _e678)), _e681, _e682), 0f);
+                    occluder_1 = _e684.x;
+                    let _e687 = projected[2u];
+                    let _e688 = tapBias;
+                    let _e690 = occluder_1;
+                    if ((_e687 - _e688) > _e690) {
+                        let _e692 = occluder_1;
+                        let _e693 = blockerSum;
+                        blockerSum = (_e693 + _e692);
+                        let _e695 = blockerCount;
+                        blockerCount = (_e695 + 1f);
                     }
                     continue;
                 } else {
                     break;
                 }
                 continuing {
-                    let _e674 = i_5;
-                    i_5 = (_e674 + 1i);
+                    let _e697 = i_5;
+                    i_5 = (_e697 + 1i);
                 }
             }
-            let _e676 = blockerCount;
-            if (_e676 <= 0f) {
+            let _e699 = blockerCount;
+            if (_e699 <= 0f) {
                 return 1f;
             }
-            let _e679 = projected[2u];
-            let _e680 = blockerSum;
-            let _e681 = blockerCount;
-            let _e685 = cascadeDepth;
-            gap = (max((_e679 - (_e680 / _e681)), 0f) * _e685);
-            let _e687 = spread;
-            let _e688 = gap;
-            let _e690 = cascadeTexel;
-            radius_2 = clamp(((_e687 * _e688) / _e690), 1f, 16f);
+            let _e702 = projected[2u];
+            let _e703 = blockerSum;
+            let _e704 = blockerCount;
+            let _e708 = cascadeDepth;
+            gap = (max((_e702 - (_e703 / _e704)), 0f) * _e708);
+            let _e710 = spread;
+            let _e711 = gap;
+            let _e713 = cascadeTexel;
+            radius_2 = clamp(((_e710 * _e711) / _e713), 1f, 16f);
             i_6 = 0i;
             loop {
-                let _e693 = i_6;
-                if (_e693 < 16i) {
-                    let _e695 = turn_1;
-                    let _e697 = i_6;
-                    param_67 = _e697;
+                let _e716 = i_6;
+                if (_e716 < 16i) {
+                    let _e718 = turn_1;
+                    let _e720 = i_6;
+                    param_67 = _e720;
                     param_68 = 16i;
-                    param_69 = (_e695 + 1f);
-                    let _e698 = VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b((&param_67), (&param_68), (&param_69));
-                    disc_1 = _e698;
-                    let _e699 = bias;
-                    let _e700 = disc_1;
-                    let _e702 = radius_2;
-                    let _e706 = receiverSlope;
-                    tapBias_1 = (_e699 + (max(((length(_e700) * _e702) - 1.5f), 0f) * _e706));
-                    let _e709 = uv_4;
-                    let _e710 = disc_1;
-                    let _e711 = texel_1;
-                    let _e713 = radius_2;
-                    let _e716 = tileLo;
-                    let _e717 = tileHi;
-                    let _e719 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e709 + ((_e710 * _e711) * _e713)), _e716, _e717), 0f);
-                    occluder_2 = _e719.x;
-                    let _e722 = projected[2u];
-                    let _e723 = tapBias_1;
-                    let _e725 = occluder_2;
-                    let _e728 = lit_2;
-                    lit_2 = (_e728 + select(1f, 0f, ((_e722 - _e723) > _e725)));
+                    param_69 = (_e718 + 1f);
+                    let _e721 = VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b((&param_67), (&param_68), (&param_69));
+                    disc_1 = _e721;
+                    let _e722 = bias;
+                    let _e723 = disc_1;
+                    let _e725 = radius_2;
+                    let _e729 = receiverSlope;
+                    tapBias_1 = (_e722 + (max(((length(_e723) * _e725) - 1.5f), 0f) * _e729));
+                    let _e732 = uv_4;
+                    let _e733 = disc_1;
+                    let _e734 = texel_1;
+                    let _e736 = radius_2;
+                    let _e739 = tileLo;
+                    let _e740 = tileHi;
+                    let _e742 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e732 + ((_e733 * _e734) * _e736)), _e739, _e740), 0f);
+                    occluder_2 = _e742.x;
+                    let _e745 = projected[2u];
+                    let _e746 = tapBias_1;
+                    let _e748 = occluder_2;
+                    let _e751 = lit_2;
+                    lit_2 = (_e751 + select(1f, 0f, ((_e745 - _e746) > _e748)));
                     continue;
                 } else {
                     break;
                 }
                 continuing {
-                    let _e730 = i_6;
-                    i_6 = (_e730 + 1i);
+                    let _e753 = i_6;
+                    i_6 = (_e753 + 1i);
                 }
             }
-            let _e732 = lit_2;
-            lit_2 = (_e732 * 0.0625f);
+            let _e755 = lit_2;
+            lit_2 = (_e755 * 0.0625f);
         }
     }
-    let _e734 = lit_2;
-    let _e735 = strength_1;
-    return mix(1f, _e734, clamp(_e735, 0f, 1f));
+    let _e757 = lit_2;
+    let _e758 = strength_1;
+    return mix(1f, _e757, clamp(_e758, 0f, 1f));
 }
 
 fn LightVisibility_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b_i1_u003b(s_3: ptr<function, Surface>, light_2: ptr<function, LightSample>, index: ptr<function, i32>) -> f32 {
@@ -25036,19 +25225,19 @@ fn LightVisibility_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d
     var param_71: LightSample;
     var param_72: i32;
 
-    let _e194 = (*s_3);
-    param_70 = _e194;
-    let _e195 = (*light_2);
-    param_71 = _e195;
-    let _e196 = (*index);
-    param_72 = _e196;
-    let _e197 = ShadowFactor_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b_i1_u003b((&param_70), (&param_71), (&param_72));
-    return _e197;
+    let _e195 = (*s_3);
+    param_70 = _e195;
+    let _e196 = (*light_2);
+    param_71 = _e196;
+    let _e197 = (*index);
+    param_72 = _e197;
+    let _e198 = ShadowFactor_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b_i1_u003b((&param_70), (&param_71), (&param_72));
+    return _e198;
 }
 
 fn LightHasShadow_u0028_i1_u003b(index_1: ptr<function, i32>) -> bool {
-    let _e189 = (*index_1);
-    return (_e189 < 8i);
+    let _e190 = (*index_1);
+    return (_e190 < 8i);
 }
 
 fn PunctualAttenuation_u0028_f1_u003b_f1_u003b(distance_1: ptr<function, f32>, range_4: ptr<function, f32>) -> f32 {
@@ -25056,26 +25245,26 @@ fn PunctualAttenuation_u0028_f1_u003b_f1_u003b(distance_1: ptr<function, f32>, r
     var ratio: f32;
     var window: f32;
 
-    let _e193 = (*distance_1);
     let _e194 = (*distance_1);
-    attenuation = (1f / max((_e193 * _e194), 0.0001f));
-    let _e198 = (*range_4);
-    if (_e198 > 0f) {
-        let _e200 = (*distance_1);
-        let _e201 = (*range_4);
-        ratio = (_e200 / _e201);
-        let _e203 = ratio;
+    let _e195 = (*distance_1);
+    attenuation = (1f / max((_e194 * _e195), 0.0001f));
+    let _e199 = (*range_4);
+    if (_e199 > 0f) {
+        let _e201 = (*distance_1);
+        let _e202 = (*range_4);
+        ratio = (_e201 / _e202);
         let _e204 = ratio;
-        let _e206 = ratio;
-        let _e208 = ratio;
-        window = clamp((1f - (((_e203 * _e204) * _e206) * _e208)), 0f, 1f);
-        let _e212 = window;
+        let _e205 = ratio;
+        let _e207 = ratio;
+        let _e209 = ratio;
+        window = clamp((1f - (((_e204 * _e205) * _e207) * _e209)), 0f, 1f);
         let _e213 = window;
-        let _e215 = attenuation;
-        attenuation = (_e215 * (_e212 * _e213));
+        let _e214 = window;
+        let _e216 = attenuation;
+        attenuation = (_e216 * (_e213 * _e214));
     }
-    let _e217 = attenuation;
-    return _e217;
+    let _e218 = attenuation;
+    return _e218;
 }
 
 fn RectangleClosestPoint_u0028_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b(centre: ptr<function, vec3<f32>>, halfWidth: ptr<function, vec3<f32>>, halfHeight: ptr<function, vec3<f32>>, world_2: ptr<function, vec3<f32>>, mirror: ptr<function, vec3<f32>>) -> vec3<f32> {
@@ -25092,75 +25281,75 @@ fn RectangleClosestPoint_u0028_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b
     var u: f32;
     var v: f32;
 
-    let _e205 = (*halfWidth);
-    let _e206 = (*halfHeight);
-    n_2 = cross(_e205, _e206);
-    let _e208 = n_2;
-    nLen = length(_e208);
-    let _e210 = nLen;
-    if (_e210 < 0.000000000001f) {
-        let _e212 = (*centre);
-        return _e212;
-    }
-    let _e213 = nLen;
-    let _e214 = n_2;
-    n_2 = (_e214 / vec3(_e213));
-    let _e217 = (*centre);
-    let _e218 = (*world_2);
-    toPlane = (_e217 - _e218);
-    let _e220 = (*mirror);
-    let _e221 = n_2;
-    denom = dot(_e220, _e221);
-    let _e223 = denom;
-    if (abs(_e223) < 0.00001f) {
-        let _e226 = toPlane;
-        let _e227 = n_2;
-        let _e228 = toPlane;
-        let _e229 = n_2;
-        onPlane = (_e226 - (_e227 * dot(_e228, _e229)));
-    } else {
-        let _e233 = toPlane;
-        let _e234 = n_2;
-        let _e236 = denom;
-        t_1 = (dot(_e233, _e234) / _e236);
-        let _e238 = t_1;
-        if (_e238 > 0f) {
-            let _e240 = (*mirror);
-            let _e241 = t_1;
-            local_12 = (_e240 * _e241);
+    let _e206 = (*halfWidth);
+    let _e207 = (*halfHeight);
+    n_2 = cross(_e206, _e207);
+    let _e209 = n_2;
+    nLen = length(_e209);
+    let _e211 = nLen;
+    if (_e211 < 0.000000000001f) {
+        let _e213 = (*centre);
+        return _e213;
+    }
+    let _e214 = nLen;
+    let _e215 = n_2;
+    n_2 = (_e215 / vec3(_e214));
+    let _e218 = (*centre);
+    let _e219 = (*world_2);
+    toPlane = (_e218 - _e219);
+    let _e221 = (*mirror);
+    let _e222 = n_2;
+    denom = dot(_e221, _e222);
+    let _e224 = denom;
+    if (abs(_e224) < 0.00001f) {
+        let _e227 = toPlane;
+        let _e228 = n_2;
+        let _e229 = toPlane;
+        let _e230 = n_2;
+        onPlane = (_e227 - (_e228 * dot(_e229, _e230)));
+    } else {
+        let _e234 = toPlane;
+        let _e235 = n_2;
+        let _e237 = denom;
+        t_1 = (dot(_e234, _e235) / _e237);
+        let _e239 = t_1;
+        if (_e239 > 0f) {
+            let _e241 = (*mirror);
+            let _e242 = t_1;
+            local_12 = (_e241 * _e242);
         } else {
-            let _e243 = toPlane;
-            let _e244 = n_2;
-            let _e245 = toPlane;
-            let _e246 = n_2;
-            local_12 = (_e243 - (_e244 * dot(_e245, _e246)));
+            let _e244 = toPlane;
+            let _e245 = n_2;
+            let _e246 = toPlane;
+            let _e247 = n_2;
+            local_12 = (_e244 - (_e245 * dot(_e246, _e247)));
         }
-        let _e250 = local_12;
-        onPlane = _e250;
+        let _e251 = local_12;
+        onPlane = _e251;
     }
-    let _e251 = onPlane;
-    let _e252 = toPlane;
-    offset_2 = (_e251 - _e252);
-    let _e254 = (*halfWidth);
+    let _e252 = onPlane;
+    let _e253 = toPlane;
+    offset_2 = (_e252 - _e253);
     let _e255 = (*halfWidth);
-    wLen2_ = max(dot(_e254, _e255), 0.000000000001f);
-    let _e258 = (*halfHeight);
+    let _e256 = (*halfWidth);
+    wLen2_ = max(dot(_e255, _e256), 0.000000000001f);
     let _e259 = (*halfHeight);
-    hLen2_ = max(dot(_e258, _e259), 0.000000000001f);
-    let _e262 = offset_2;
-    let _e263 = (*halfWidth);
-    let _e265 = wLen2_;
-    u = clamp((dot(_e262, _e263) / _e265), -1f, 1f);
-    let _e268 = offset_2;
-    let _e269 = (*halfHeight);
-    let _e271 = hLen2_;
-    v = clamp((dot(_e268, _e269) / _e271), -1f, 1f);
-    let _e274 = (*centre);
-    let _e275 = (*halfWidth);
-    let _e276 = u;
-    let _e279 = (*halfHeight);
-    let _e280 = v;
-    return ((_e274 + (_e275 * _e276)) + (_e279 * _e280));
+    let _e260 = (*halfHeight);
+    hLen2_ = max(dot(_e259, _e260), 0.000000000001f);
+    let _e263 = offset_2;
+    let _e264 = (*halfWidth);
+    let _e266 = wLen2_;
+    u = clamp((dot(_e263, _e264) / _e266), -1f, 1f);
+    let _e269 = offset_2;
+    let _e270 = (*halfHeight);
+    let _e272 = hLen2_;
+    v = clamp((dot(_e269, _e270) / _e272), -1f, 1f);
+    let _e275 = (*centre);
+    let _e276 = (*halfWidth);
+    let _e277 = u;
+    let _e280 = (*halfHeight);
+    let _e281 = v;
+    return ((_e275 + (_e276 * _e277)) + (_e280 * _e281));
 }
 
 fn LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b(a_1: ptr<function, vec3<f32>>, b: ptr<function, vec3<f32>>, n_3: ptr<function, vec3<f32>>) -> f32 {
@@ -25171,32 +25360,32 @@ fn LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b(a_1: ptr<function, vec3<f32>>
     var len: f32;
     var local_13: f32;
 
-    let _e197 = (*a_1);
     let _e198 = (*a_1);
-    ua = (_e197 / vec3(max(length(_e198), 0.000000000001f)));
-    let _e203 = (*b);
+    let _e199 = (*a_1);
+    ua = (_e198 / vec3(max(length(_e199), 0.000000000001f)));
     let _e204 = (*b);
-    ub = (_e203 / vec3(max(length(_e204), 0.000000000001f)));
-    let _e209 = ua;
-    let _e210 = ub;
-    angle_1 = acos(clamp(dot(_e209, _e210), -1f, 1f));
-    let _e214 = ua;
-    let _e215 = ub;
-    axis = cross(_e214, _e215);
-    let _e217 = axis;
-    len = length(_e217);
-    let _e219 = len;
-    if (_e219 > 0.000001f) {
-        let _e221 = angle_1;
-        let _e222 = axis;
-        let _e223 = (*n_3);
-        let _e226 = len;
-        local_13 = ((_e221 * dot(_e222, _e223)) / _e226);
+    let _e205 = (*b);
+    ub = (_e204 / vec3(max(length(_e205), 0.000000000001f)));
+    let _e210 = ua;
+    let _e211 = ub;
+    angle_1 = acos(clamp(dot(_e210, _e211), -1f, 1f));
+    let _e215 = ua;
+    let _e216 = ub;
+    axis = cross(_e215, _e216);
+    let _e218 = axis;
+    len = length(_e218);
+    let _e220 = len;
+    if (_e220 > 0.000001f) {
+        let _e222 = angle_1;
+        let _e223 = axis;
+        let _e224 = (*n_3);
+        let _e227 = len;
+        local_13 = ((_e222 * dot(_e223, _e224)) / _e227);
     } else {
         local_13 = 0f;
     }
-    let _e228 = local_13;
-    return _e228;
+    let _e229 = local_13;
+    return _e229;
 }
 
 fn RectangleFormFactor_u0028_vf3_u005b_4_u005d_u003b_vf3_u003b(corners: ptr<function, array<vec3<f32>, 4>>, n_4: ptr<function, vec3<f32>>) -> f32 {
@@ -25227,98 +25416,98 @@ fn RectangleFormFactor_u0028_vf3_u005b_4_u005d_u003b_vf3_u003b(corners: ptr<func
     entry = vec3<f32>(0f, 0f, 0f);
     i_7 = 0i;
     loop {
-        let _e211 = i_7;
-        if (_e211 < 4i) {
-            let _e213 = i_7;
-            let _e215 = (*corners)[_e213];
-            a_2 = _e215;
-            let _e216 = i_7;
-            if (_e216 == 3i) {
+        let _e212 = i_7;
+        if (_e212 < 4i) {
+            let _e214 = i_7;
+            let _e216 = (*corners)[_e214];
+            a_2 = _e216;
+            let _e217 = i_7;
+            if (_e217 == 3i) {
                 local_14 = 0i;
             } else {
-                let _e218 = i_7;
-                local_14 = (_e218 + 1i);
+                let _e219 = i_7;
+                local_14 = (_e219 + 1i);
             }
-            let _e220 = local_14;
-            let _e222 = (*corners)[_e220];
-            b_1 = _e222;
-            let _e223 = a_2;
-            let _e224 = (*n_4);
-            ha = dot(_e223, _e224);
-            let _e226 = b_1;
-            let _e227 = (*n_4);
-            hb = dot(_e226, _e227);
-            let _e229 = ha;
-            let _e230 = hb;
-            d_3 = (_e229 - _e230);
-            let _e232 = a_2;
-            let _e233 = b_1;
-            let _e234 = a_2;
-            let _e236 = d_3;
-            if (abs(_e236) > 0.000000000001f) {
-                let _e239 = ha;
-                let _e240 = d_3;
-                local_15 = (_e239 / _e240);
+            let _e221 = local_14;
+            let _e223 = (*corners)[_e221];
+            b_1 = _e223;
+            let _e224 = a_2;
+            let _e225 = (*n_4);
+            ha = dot(_e224, _e225);
+            let _e227 = b_1;
+            let _e228 = (*n_4);
+            hb = dot(_e227, _e228);
+            let _e230 = ha;
+            let _e231 = hb;
+            d_3 = (_e230 - _e231);
+            let _e233 = a_2;
+            let _e234 = b_1;
+            let _e235 = a_2;
+            let _e237 = d_3;
+            if (abs(_e237) > 0.000000000001f) {
+                let _e240 = ha;
+                let _e241 = d_3;
+                local_15 = (_e240 / _e241);
             } else {
                 local_15 = 0f;
             }
-            let _e242 = local_15;
-            q = (_e232 + ((_e233 - _e234) * _e242));
-            let _e245 = ha;
-            aAbove = (_e245 > 0f);
-            let _e247 = hb;
-            bAbove = (_e247 > 0f);
-            let _e249 = aAbove;
-            let _e250 = bAbove;
-            if (_e249 || _e250) {
-                let _e252 = aAbove;
-                let _e253 = a_2;
-                let _e254 = q;
-                let _e257 = bAbove;
-                let _e258 = b_1;
-                let _e259 = q;
-                param_73 = select(_e254, _e253, vec3(_e252));
-                param_74 = select(_e259, _e258, vec3(_e257));
-                let _e262 = (*n_4);
-                param_75 = _e262;
-                let _e263 = LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b((&param_73), (&param_74), (&param_75));
-                local_16 = _e263;
+            let _e243 = local_15;
+            q = (_e233 + ((_e234 - _e235) * _e243));
+            let _e246 = ha;
+            aAbove = (_e246 > 0f);
+            let _e248 = hb;
+            bAbove = (_e248 > 0f);
+            let _e250 = aAbove;
+            let _e251 = bAbove;
+            if (_e250 || _e251) {
+                let _e253 = aAbove;
+                let _e254 = a_2;
+                let _e255 = q;
+                let _e258 = bAbove;
+                let _e259 = b_1;
+                let _e260 = q;
+                param_73 = select(_e255, _e254, vec3(_e253));
+                param_74 = select(_e260, _e259, vec3(_e258));
+                let _e263 = (*n_4);
+                param_75 = _e263;
+                let _e264 = LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b((&param_73), (&param_74), (&param_75));
+                local_16 = _e264;
             } else {
                 local_16 = 0f;
             }
-            let _e264 = local_16;
-            let _e265 = total;
-            total = (_e265 + _e264);
-            let _e267 = aAbove;
-            let _e268 = bAbove;
-            let _e271 = q;
-            let _e272 = exit;
-            exit = select(_e272, _e271, vec3((_e267 && !(_e268))));
-            let _e275 = aAbove;
-            let _e277 = bAbove;
-            let _e279 = q;
-            let _e280 = entry;
-            entry = select(_e280, _e279, vec3((!(_e275) && _e277)));
+            let _e265 = local_16;
+            let _e266 = total;
+            total = (_e266 + _e265);
+            let _e268 = aAbove;
+            let _e269 = bAbove;
+            let _e272 = q;
+            let _e273 = exit;
+            exit = select(_e273, _e272, vec3((_e268 && !(_e269))));
+            let _e276 = aAbove;
+            let _e278 = bAbove;
+            let _e280 = q;
+            let _e281 = entry;
+            entry = select(_e281, _e280, vec3((!(_e276) && _e278)));
             continue;
         } else {
             break;
         }
         continuing {
-            let _e283 = i_7;
-            i_7 = (_e283 + 1i);
+            let _e284 = i_7;
+            i_7 = (_e284 + 1i);
         }
     }
-    let _e285 = exit;
-    param_76 = _e285;
-    let _e286 = entry;
-    param_77 = _e286;
-    let _e287 = (*n_4);
-    param_78 = _e287;
-    let _e288 = LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b((&param_76), (&param_77), (&param_78));
-    let _e289 = total;
-    total = (_e289 + _e288);
-    let _e291 = total;
-    return max((-(_e291) * 0.5f), 0f);
+    let _e286 = exit;
+    param_76 = _e286;
+    let _e287 = entry;
+    param_77 = _e287;
+    let _e288 = (*n_4);
+    param_78 = _e288;
+    let _e289 = LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b((&param_76), (&param_77), (&param_78));
+    let _e290 = total;
+    total = (_e290 + _e289);
+    let _e292 = total;
+    return max((-(_e292) * 0.5f), 0f);
 }
 
 fn LightListLane_u0028_vf4_u003b_i1_u003b(four: ptr<function, vec4<f32>>, slot_1: ptr<function, i32>) -> f32 {
@@ -25327,91 +25516,91 @@ fn LightListLane_u0028_vf4_u003b_i1_u003b(four: ptr<function, vec4<f32>>, slot_1
     var local_18: f32;
     var local_19: f32;
 
-    let _e194 = (*slot_1);
     let _e195 = (*slot_1);
-    lane = (_e194 - ((_e195 / 4i) * 4i));
-    let _e199 = lane;
-    if (_e199 == 0i) {
-        let _e202 = (*four)[0u];
-        local_17 = _e202;
-    } else {
-        let _e203 = lane;
-        if (_e203 == 1i) {
-            let _e206 = (*four)[1u];
-            local_18 = _e206;
+    let _e196 = (*slot_1);
+    lane = (_e195 - ((_e196 / 4i) * 4i));
+    let _e200 = lane;
+    if (_e200 == 0i) {
+        let _e203 = (*four)[0u];
+        local_17 = _e203;
+    } else {
+        let _e204 = lane;
+        if (_e204 == 1i) {
+            let _e207 = (*four)[1u];
+            local_18 = _e207;
         } else {
-            let _e207 = lane;
-            if (_e207 == 2i) {
-                let _e210 = (*four)[2u];
-                local_19 = _e210;
+            let _e208 = lane;
+            if (_e208 == 2i) {
+                let _e211 = (*four)[2u];
+                local_19 = _e211;
             } else {
-                let _e212 = (*four)[3u];
-                local_19 = _e212;
+                let _e213 = (*four)[3u];
+                local_19 = _e213;
             }
-            let _e213 = local_19;
-            local_18 = _e213;
+            let _e214 = local_19;
+            local_18 = _e214;
         }
-        let _e214 = local_18;
-        local_17 = _e214;
+        let _e215 = local_18;
+        local_17 = _e215;
     }
-    let _e215 = local_17;
-    return _e215;
+    let _e216 = local_17;
+    return _e216;
 }
 
 fn LightListScale_u0028_i1_u003b(slot_2: ptr<function, i32>) -> f32 {
     var param_79: vec4<f32>;
     var param_80: i32;
 
-    let _e191 = (*slot_2);
-    let _e195 = light_list_info.scales[(_e191 / 4i)];
-    param_79 = _e195;
-    let _e196 = (*slot_2);
-    param_80 = _e196;
-    let _e197 = LightListLane_u0028_vf4_u003b_i1_u003b((&param_79), (&param_80));
-    return _e197;
+    let _e192 = (*slot_2);
+    let _e196 = light_list_info.scales[(_e192 / 4i)];
+    param_79 = _e196;
+    let _e197 = (*slot_2);
+    param_80 = _e197;
+    let _e198 = LightListLane_u0028_vf4_u003b_i1_u003b((&param_79), (&param_80));
+    return _e198;
 }
 
 fn InSlots_u0028_f1_u003b(row: ptr<function, f32>) -> bool {
     var a_3: vec4<f32>;
     var b_2: vec4<f32>;
 
-    let _e193 = light_list_info.slot_rows[0i];
-    let _e194 = (*row);
-    a_3 = abs((_e193 - vec4(_e194)));
-    let _e200 = light_list_info.slot_rows[1i];
-    let _e201 = (*row);
-    b_2 = abs((_e200 - vec4(_e201)));
-    let _e206 = a_3[0u];
-    let _e208 = a_3[1u];
-    let _e211 = a_3[2u];
-    let _e213 = a_3[3u];
-    let _e217 = b_2[0u];
-    let _e219 = b_2[1u];
-    let _e222 = b_2[2u];
-    let _e224 = b_2[3u];
-    return (min(min(min(_e206, _e208), min(_e211, _e213)), min(min(_e217, _e219), min(_e222, _e224))) < 0.5f);
+    let _e194 = light_list_info.slot_rows[0i];
+    let _e195 = (*row);
+    a_3 = abs((_e194 - vec4(_e195)));
+    let _e201 = light_list_info.slot_rows[1i];
+    let _e202 = (*row);
+    b_2 = abs((_e201 - vec4(_e202)));
+    let _e207 = a_3[0u];
+    let _e209 = a_3[1u];
+    let _e212 = a_3[2u];
+    let _e214 = a_3[3u];
+    let _e218 = b_2[0u];
+    let _e220 = b_2[1u];
+    let _e223 = b_2[2u];
+    let _e225 = b_2[3u];
+    return (min(min(min(_e207, _e209), min(_e212, _e214)), min(min(_e218, _e220), min(_e223, _e225))) < 0.5f);
 }
 
 fn LightListRow_u0028_i1_u003b(slot_3: ptr<function, i32>) -> f32 {
     var param_81: vec4<f32>;
     var param_82: i32;
 
-    let _e191 = (*slot_3);
-    let _e195 = light_list_info.indices[(_e191 / 4i)];
-    param_81 = _e195;
-    let _e196 = (*slot_3);
-    param_82 = _e196;
-    let _e197 = LightListLane_u0028_vf4_u003b_i1_u003b((&param_81), (&param_82));
-    return _e197;
+    let _e192 = (*slot_3);
+    let _e196 = light_list_info.indices[(_e192 / 4i)];
+    param_81 = _e196;
+    let _e197 = (*slot_3);
+    param_82 = _e197;
+    let _e198 = LightListLane_u0028_vf4_u003b_i1_u003b((&param_81), (&param_82));
+    return _e198;
 }
 
 fn LightListTexel_u0028_f1_u003b_f1_u003b(texel_2: ptr<function, f32>, row_1: ptr<function, f32>) -> vec4<f32> {
-    let _e190 = (*texel_2);
-    let _e194 = light_list_info.list[1u];
-    let _e196 = (*row_1);
-    let _e200 = light_list_info.list[2u];
-    let _e203 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>(((_e190 + 0.5f) * _e194), ((_e196 + 0.5f) * _e200)), 0f);
-    return _e203;
+    let _e191 = (*texel_2);
+    let _e195 = light_list_info.list[1u];
+    let _e197 = (*row_1);
+    let _e201 = light_list_info.list[2u];
+    let _e204 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>(((_e191 + 0.5f) * _e195), ((_e197 + 0.5f) * _e201)), 0f);
+    return _e204;
 }
 
 fn ClusterRow_u0028_i1_u003b(slot_4: ptr<function, i32>) -> f32 {
@@ -25425,35 +25614,35 @@ fn ClusterRow_u0028_i1_u003b(slot_4: ptr<function, i32>) -> f32 {
     var param_85: vec4<f32>;
     var param_86: i32;
 
-    let _e198 = g_cluster_offset;
-    let _e199 = (*slot_4);
-    entry_1 = (_e198 + f32(_e199));
-    let _e202 = entry_1;
-    row_2 = floor((_e202 / 16f));
-    let _e205 = entry_1;
-    let _e206 = row_2;
-    within = (_e205 - (_e206 * 16f));
-    let _e209 = within;
-    texel_3 = floor((_e209 / 4f));
-    let _e214 = light_list_info.cluster_depth[3u];
-    let _e215 = row_2;
-    let _e217 = texel_3;
-    param_83 = _e217;
-    param_84 = (_e214 + _e215);
-    let _e218 = LightListTexel_u0028_f1_u003b_f1_u003b((&param_83), (&param_84));
-    four_1 = _e218;
-    let _e219 = within;
-    let _e220 = texel_3;
-    let _e225 = four_1;
-    param_85 = _e225;
-    param_86 = i32(((_e219 - (_e220 * 4f)) + 0.5f));
-    let _e226 = LightListLane_u0028_vf4_u003b_i1_u003b((&param_85), (&param_86));
-    return _e226;
+    let _e199 = g_cluster_offset;
+    let _e200 = (*slot_4);
+    entry_1 = (_e199 + f32(_e200));
+    let _e203 = entry_1;
+    row_2 = floor((_e203 / 16f));
+    let _e206 = entry_1;
+    let _e207 = row_2;
+    within = (_e206 - (_e207 * 16f));
+    let _e210 = within;
+    texel_3 = floor((_e210 / 4f));
+    let _e215 = light_list_info.cluster_depth[3u];
+    let _e216 = row_2;
+    let _e218 = texel_3;
+    param_83 = _e218;
+    param_84 = (_e215 + _e216);
+    let _e219 = LightListTexel_u0028_f1_u003b_f1_u003b((&param_83), (&param_84));
+    four_1 = _e219;
+    let _e220 = within;
+    let _e221 = texel_3;
+    let _e226 = four_1;
+    param_85 = _e226;
+    param_86 = i32(((_e220 - (_e221 * 4f)) + 0.5f));
+    let _e227 = LightListLane_u0028_vf4_u003b_i1_u003b((&param_85), (&param_86));
+    return _e227;
 }
 
 fn Clustered_u0028_() -> bool {
-    let _e190 = light_list_info.cluster_grid[3u];
-    return (_e190 > 0.5f);
+    let _e191 = light_list_info.cluster_grid[3u];
+    return (_e191 > 0.5f);
 }
 
 fn SampleLight_u0028_i1_u003b_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(index_2: ptr<function, i32>, s_4: ptr<function, Surface>) -> LightSample {
@@ -25503,270 +25692,270 @@ fn SampleLight_u0028_i1_u003b_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_
     var attenuation_1: f32;
     var toLight_1: vec3<f32>;
     var distance_3: f32;
-    var param_98: f32;
-    var param_99: f32;
-    var cosAngle: f32;
-
-    light_3.integrated = 0f;
-    light_3.ltc = vec3<f32>(0f, 0f, 0f);
-    let _e241 = (*index_2);
-    if (_e241 < 8i) {
-        let _e243 = (*index_2);
-        let _e246 = frag_info.light_position[_e243];
-        position = _e246;
-        let _e247 = (*index_2);
-        let _e250 = frag_info.light_color[_e247];
-        color_1 = _e250;
-        let _e251 = (*index_2);
-        let _e254 = frag_info.light_direction[_e251];
-        direction = _e254;
-        let _e255 = (*index_2);
-        let _e258 = frag_info.light_cone[_e255];
-        cone = _e258;
-    } else {
-        let _e259 = (*index_2);
-        slot_5 = (_e259 - 8i);
-        let _e261 = Clustered_u0028_();
-        clustered = _e261;
-        let _e262 = clustered;
-        if _e262 {
-            let _e263 = slot_5;
-            param_87 = _e263;
-            let _e264 = ClusterRow_u0028_i1_u003b((&param_87));
-            local_20 = _e264;
+    var param_98: f32;
+    var param_99: f32;
+    var cosAngle: f32;
+
+    light_3.integrated = 0f;
+    light_3.ltc = vec3<f32>(0f, 0f, 0f);
+    let _e242 = (*index_2);
+    if (_e242 < 8i) {
+        let _e244 = (*index_2);
+        let _e247 = frag_info.light_position[_e244];
+        position = _e247;
+        let _e248 = (*index_2);
+        let _e251 = frag_info.light_color[_e248];
+        color_1 = _e251;
+        let _e252 = (*index_2);
+        let _e255 = frag_info.light_direction[_e252];
+        direction = _e255;
+        let _e256 = (*index_2);
+        let _e259 = frag_info.light_cone[_e256];
+        cone = _e259;
+    } else {
+        let _e260 = (*index_2);
+        slot_5 = (_e260 - 8i);
+        let _e262 = Clustered_u0028_();
+        clustered = _e262;
+        let _e263 = clustered;
+        if _e263 {
+            let _e264 = slot_5;
+            param_87 = _e264;
+            let _e265 = ClusterRow_u0028_i1_u003b((&param_87));
+            local_20 = _e265;
         } else {
-            let _e265 = slot_5;
-            param_88 = _e265;
-            let _e266 = LightListRow_u0028_i1_u003b((&param_88));
-            local_20 = _e266;
-        }
-        let _e267 = local_20;
-        listRow = _e267;
-        let _e268 = listRow;
-        let _e272 = light_list_info.list[2u];
-        v_1 = ((_e268 + 0.5f) * _e272);
-        let _e276 = light_list_info.list[1u];
-        u_1 = _e276;
-        let _e277 = u_1;
-        let _e279 = v_1;
-        let _e281 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((0.5f * _e277), _e279), 0f);
-        position = _e281;
-        let _e282 = u_1;
-        let _e284 = v_1;
-        let _e286 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((1.5f * _e282), _e284), 0f);
-        color_1 = _e286;
-        let _e287 = u_1;
-        let _e289 = v_1;
-        let _e291 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((2.5f * _e287), _e289), 0f);
-        direction = _e291;
-        let _e292 = u_1;
-        let _e294 = v_1;
-        let _e296 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((3.5f * _e292), _e294), 0f);
-        cone = _e296;
-        let _e297 = clustered;
-        if _e297 {
-            let _e298 = listRow;
-            param_89 = _e298;
-            let _e299 = InSlots_u0028_f1_u003b((&param_89));
-            local_21 = select(1f, 0f, _e299);
+            let _e266 = slot_5;
+            param_88 = _e266;
+            let _e267 = LightListRow_u0028_i1_u003b((&param_88));
+            local_20 = _e267;
+        }
+        let _e268 = local_20;
+        listRow = _e268;
+        let _e269 = listRow;
+        let _e273 = light_list_info.list[2u];
+        v_1 = ((_e269 + 0.5f) * _e273);
+        let _e277 = light_list_info.list[1u];
+        u_1 = _e277;
+        let _e278 = u_1;
+        let _e280 = v_1;
+        let _e282 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((0.5f * _e278), _e280), 0f);
+        position = _e282;
+        let _e283 = u_1;
+        let _e285 = v_1;
+        let _e287 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((1.5f * _e283), _e285), 0f);
+        color_1 = _e287;
+        let _e288 = u_1;
+        let _e290 = v_1;
+        let _e292 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((2.5f * _e288), _e290), 0f);
+        direction = _e292;
+        let _e293 = u_1;
+        let _e295 = v_1;
+        let _e297 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((3.5f * _e293), _e295), 0f);
+        cone = _e297;
+        let _e298 = clustered;
+        if _e298 {
+            let _e299 = listRow;
+            param_89 = _e299;
+            let _e300 = InSlots_u0028_f1_u003b((&param_89));
+            local_21 = select(1f, 0f, _e300);
         } else {
-            let _e301 = slot_5;
-            param_90 = _e301;
-            let _e302 = LightListScale_u0028_i1_u003b((&param_90));
-            local_21 = _e302;
-        }
-        let _e303 = local_21;
-        let _e305 = color_1[3u];
-        color_1[3u] = (_e305 * _e303);
-    }
-    let _e309 = position[3u];
-    type_39 = _e309;
-    let _e310 = type_39;
-    if (_e310 > 2.5f) {
-        let _e312 = direction;
-        halfWidth_1 = _e312.xyz;
-        let _e314 = cone;
-        halfHeight_1 = _e314.xyz;
-        let _e316 = position;
-        let _e318 = v_world_position_1;
-        toCentre = (_e316.xyz - _e318);
-        let _e320 = toCentre;
-        let _e321 = halfWidth_1;
-        let _e323 = halfHeight_1;
-        corners_1[0i] = ((_e320 - _e321) - _e323);
-        let _e326 = toCentre;
-        let _e327 = halfWidth_1;
-        let _e329 = halfHeight_1;
-        corners_1[1i] = ((_e326 + _e327) - _e329);
-        let _e332 = toCentre;
-        let _e333 = halfWidth_1;
-        let _e335 = halfHeight_1;
-        corners_1[2i] = ((_e332 + _e333) + _e335);
-        let _e338 = toCentre;
-        let _e339 = halfWidth_1;
-        let _e341 = halfHeight_1;
-        corners_1[3i] = ((_e338 - _e339) + _e341);
-        let _e344 = toCentre;
-        let _e345 = halfWidth_1;
-        let _e346 = halfHeight_1;
-        behind = (dot(_e344, cross(_e345, _e346)) >= 0f);
-        let _e350 = behind;
-        if _e350 {
+            let _e302 = slot_5;
+            param_90 = _e302;
+            let _e303 = LightListScale_u0028_i1_u003b((&param_90));
+            local_21 = _e303;
+        }
+        let _e304 = local_21;
+        let _e306 = color_1[3u];
+        color_1[3u] = (_e306 * _e304);
+    }
+    let _e310 = position[3u];
+    type_39 = _e310;
+    let _e311 = type_39;
+    if (_e311 > 2.5f) {
+        let _e313 = direction;
+        halfWidth_1 = _e313.xyz;
+        let _e315 = cone;
+        halfHeight_1 = _e315.xyz;
+        let _e317 = position;
+        let _e319 = v_world_position_1;
+        toCentre = (_e317.xyz - _e319);
+        let _e321 = toCentre;
+        let _e322 = halfWidth_1;
+        let _e324 = halfHeight_1;
+        corners_1[0i] = ((_e321 - _e322) - _e324);
+        let _e327 = toCentre;
+        let _e328 = halfWidth_1;
+        let _e330 = halfHeight_1;
+        corners_1[1i] = ((_e327 + _e328) - _e330);
+        let _e333 = toCentre;
+        let _e334 = halfWidth_1;
+        let _e336 = halfHeight_1;
+        corners_1[2i] = ((_e333 + _e334) + _e336);
+        let _e339 = toCentre;
+        let _e340 = halfWidth_1;
+        let _e342 = halfHeight_1;
+        corners_1[3i] = ((_e339 - _e340) + _e342);
+        let _e345 = toCentre;
+        let _e346 = halfWidth_1;
+        let _e347 = halfHeight_1;
+        behind = (dot(_e345, cross(_e346, _e347)) >= 0f);
+        let _e351 = behind;
+        if _e351 {
             local_22 = 0f;
         } else {
-            let _e351 = corners_1;
-            param_91 = _e351;
-            let _e353 = (*s_4).n;
-            param_92 = _e353;
-            let _e354 = RectangleFormFactor_u0028_vf3_u005b_4_u005d_u003b_vf3_u003b((&param_91), (&param_92));
-            local_22 = _e354;
-        }
-        let _e355 = local_22;
-        formFactor = _e355;
-        let _e356 = halfWidth_1;
-        let _e357 = halfHeight_1;
-        area = (length(cross(_e356, _e357)) * 4f);
-        let _e361 = area;
-        if (_e361 > 0.000000001f) {
-            let _e363 = area;
-            local_23 = (1f / _e363);
+            let _e352 = corners_1;
+            param_91 = _e352;
+            let _e354 = (*s_4).n;
+            param_92 = _e354;
+            let _e355 = RectangleFormFactor_u0028_vf3_u005b_4_u005d_u003b_vf3_u003b((&param_91), (&param_92));
+            local_22 = _e355;
+        }
+        let _e356 = local_22;
+        formFactor = _e356;
+        let _e357 = halfWidth_1;
+        let _e358 = halfHeight_1;
+        area = (length(cross(_e357, _e358)) * 4f);
+        let _e362 = area;
+        if (_e362 > 0.000000001f) {
+            let _e364 = area;
+            local_23 = (1f / _e364);
         } else {
             local_23 = 0f;
         }
-        let _e365 = local_23;
-        radiance = _e365;
-        let _e366 = toCentre;
-        distance_2 = length(_e366);
-        let _e369 = direction[3u];
-        if (_e369 > 0f) {
-            let _e371 = distance_2;
-            let _e373 = direction[3u];
-            ratio_1 = (_e371 / _e373);
-            let _e375 = ratio_1;
+        let _e366 = local_23;
+        radiance = _e366;
+        let _e367 = toCentre;
+        distance_2 = length(_e367);
+        let _e370 = direction[3u];
+        if (_e370 > 0f) {
+            let _e372 = distance_2;
+            let _e374 = direction[3u];
+            ratio_1 = (_e372 / _e374);
             let _e376 = ratio_1;
-            let _e378 = ratio_1;
-            let _e380 = ratio_1;
-            window_1 = clamp((1f - (((_e375 * _e376) * _e378) * _e380)), 0f, 1f);
-            let _e384 = window_1;
+            let _e377 = ratio_1;
+            let _e379 = ratio_1;
+            let _e381 = ratio_1;
+            window_1 = clamp((1f - (((_e376 * _e377) * _e379) * _e381)), 0f, 1f);
             let _e385 = window_1;
-            let _e387 = radiance;
-            radiance = (_e387 * (_e384 * _e385));
-        }
-        let _e390 = (*s_4).v;
-        let _e393 = (*s_4).n;
-        mirror_1 = reflect(-(_e390), _e393);
-        let _e395 = position;
-        param_93 = _e395.xyz;
-        let _e397 = halfWidth_1;
-        param_94 = _e397;
-        let _e398 = halfHeight_1;
-        param_95 = _e398;
-        let _e399 = v_world_position_1;
-        param_96 = _e399;
-        let _e400 = mirror_1;
-        param_97 = _e400;
-        let _e401 = RectangleClosestPoint_u0028_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b((&param_93), (&param_94), (&param_95), (&param_96), (&param_97));
-        representative = _e401;
-        let _e402 = representative;
-        let _e403 = v_world_position_1;
-        toPoint = (_e402 - _e403);
-        let _e405 = toPoint;
-        pointDistance = length(_e405);
-        let _e407 = pointDistance;
-        if (_e407 > 0.000001f) {
-            let _e409 = toPoint;
-            let _e410 = pointDistance;
-            local_24 = (_e409 / vec3(_e410));
+            let _e386 = window_1;
+            let _e388 = radiance;
+            radiance = (_e388 * (_e385 * _e386));
+        }
+        let _e391 = (*s_4).v;
+        let _e394 = (*s_4).n;
+        mirror_1 = reflect(-(_e391), _e394);
+        let _e396 = position;
+        param_93 = _e396.xyz;
+        let _e398 = halfWidth_1;
+        param_94 = _e398;
+        let _e399 = halfHeight_1;
+        param_95 = _e399;
+        let _e400 = v_world_position_1;
+        param_96 = _e400;
+        let _e401 = mirror_1;
+        param_97 = _e401;
+        let _e402 = RectangleClosestPoint_u0028_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b((&param_93), (&param_94), (&param_95), (&param_96), (&param_97));
+        representative = _e402;
+        let _e403 = representative;
+        let _e404 = v_world_position_1;
+        toPoint = (_e403 - _e404);
+        let _e406 = toPoint;
+        pointDistance = length(_e406);
+        let _e408 = pointDistance;
+        if (_e408 > 0.000001f) {
+            let _e410 = toPoint;
+            let _e411 = pointDistance;
+            local_24 = (_e410 / vec3(_e411));
         } else {
-            let _e414 = (*s_4).n;
-            local_24 = _e414;
-        }
-        let _e415 = local_24;
-        light_3.l = _e415;
-        let _e418 = light_3.l;
-        let _e420 = (*s_4).v;
-        light_3.h = normalize((_e418 + _e420));
-        let _e424 = formFactor;
-        light_3.n_dot_l = _e424;
-        let _e427 = (*s_4).n;
-        let _e429 = light_3.h;
-        light_3.n_dot_h = max(dot(_e427, _e429), 0f);
-        let _e434 = (*s_4).v;
-        let _e436 = light_3.h;
-        light_3.v_dot_h = max(dot(_e434, _e436), 0f);
-        let _e440 = color_1;
-        let _e443 = color_1[3u];
-        let _e445 = radiance;
-        light_3.radiance = ((_e440.xyz * _e443) * _e445);
-        let _e448 = light_3;
-        return _e448;
-    }
-    let _e449 = direction;
-    aim = normalize(_e449.xyz);
+            let _e415 = (*s_4).n;
+            local_24 = _e415;
+        }
+        let _e416 = local_24;
+        light_3.l = _e416;
+        let _e419 = light_3.l;
+        let _e421 = (*s_4).v;
+        light_3.h = normalize((_e419 + _e421));
+        let _e425 = formFactor;
+        light_3.n_dot_l = _e425;
+        let _e428 = (*s_4).n;
+        let _e430 = light_3.h;
+        light_3.n_dot_h = max(dot(_e428, _e430), 0f);
+        let _e435 = (*s_4).v;
+        let _e437 = light_3.h;
+        light_3.v_dot_h = max(dot(_e435, _e437), 0f);
+        let _e441 = color_1;
+        let _e444 = color_1[3u];
+        let _e446 = radiance;
+        light_3.radiance = ((_e441.xyz * _e444) * _e446);
+        let _e449 = light_3;
+        return _e449;
+    }
+    let _e450 = direction;
+    aim = normalize(_e450.xyz);
     attenuation_1 = 1f;
-    let _e452 = type_39;
-    if (_e452 < 0.5f) {
-        let _e454 = aim;
-        light_3.l = -(_e454);
-    } else {
-        let _e457 = position;
-        let _e459 = v_world_position_1;
-        toLight_1 = (_e457.xyz - _e459);
-        let _e461 = toLight_1;
-        distance_3 = length(_e461);
-        let _e463 = distance_3;
-        if (_e463 < 0.000001f) {
-            let _e466 = (*s_4).n;
-            light_3.l = _e466;
-            let _e469 = (*s_4).n;
-            light_3.h = _e469;
+    let _e453 = type_39;
+    if (_e453 < 0.5f) {
+        let _e455 = aim;
+        light_3.l = -(_e455);
+    } else {
+        let _e458 = position;
+        let _e460 = v_world_position_1;
+        toLight_1 = (_e458.xyz - _e460);
+        let _e462 = toLight_1;
+        distance_3 = length(_e462);
+        let _e464 = distance_3;
+        if (_e464 < 0.000001f) {
+            let _e467 = (*s_4).n;
+            light_3.l = _e467;
+            let _e470 = (*s_4).n;
+            light_3.h = _e470;
             light_3.radiance = vec3<f32>(0f, 0f, 0f);
             light_3.n_dot_l = 0f;
             light_3.n_dot_h = 0f;
             light_3.v_dot_h = 0f;
-            let _e475 = light_3;
-            return _e475;
-        }
-        let _e476 = toLight_1;
-        let _e477 = distance_3;
-        light_3.l = (_e476 / vec3(_e477));
-        let _e481 = distance_3;
-        param_98 = _e481;
-        let _e483 = direction[3u];
-        param_99 = _e483;
-        let _e484 = PunctualAttenuation_u0028_f1_u003b_f1_u003b((&param_98), (&param_99));
-        attenuation_1 = _e484;
-        let _e485 = type_39;
-        if (_e485 > 1.5f) {
-            let _e487 = aim;
-            let _e489 = light_3.l;
-            cosAngle = dot(_e487, -(_e489));
-            let _e492 = cosAngle;
-            let _e494 = cone[1u];
-            let _e497 = cone[0u];
-            let _e499 = cone[1u];
-            let _e503 = attenuation_1;
-            attenuation_1 = (_e503 * clamp(((_e492 - _e494) / (_e497 - _e499)), 0f, 1f));
-        }
-    }
-    let _e506 = light_3.l;
-    let _e508 = (*s_4).v;
-    light_3.h = normalize((_e506 + _e508));
-    let _e513 = (*s_4).n;
-    let _e515 = light_3.l;
-    light_3.n_dot_l = max(dot(_e513, _e515), 0f);
-    let _e520 = (*s_4).n;
-    let _e522 = light_3.h;
-    light_3.n_dot_h = max(dot(_e520, _e522), 0f);
-    let _e527 = (*s_4).v;
-    let _e529 = light_3.h;
-    light_3.v_dot_h = max(dot(_e527, _e529), 0f);
-    let _e533 = color_1;
-    let _e536 = color_1[3u];
-    let _e538 = attenuation_1;
-    light_3.radiance = ((_e533.xyz * _e536) * _e538);
-    let _e541 = light_3;
-    return _e541;
+            let _e476 = light_3;
+            return _e476;
+        }
+        let _e477 = toLight_1;
+        let _e478 = distance_3;
+        light_3.l = (_e477 / vec3(_e478));
+        let _e482 = distance_3;
+        param_98 = _e482;
+        let _e484 = direction[3u];
+        param_99 = _e484;
+        let _e485 = PunctualAttenuation_u0028_f1_u003b_f1_u003b((&param_98), (&param_99));
+        attenuation_1 = _e485;
+        let _e486 = type_39;
+        if (_e486 > 1.5f) {
+            let _e488 = aim;
+            let _e490 = light_3.l;
+            cosAngle = dot(_e488, -(_e490));
+            let _e493 = cosAngle;
+            let _e495 = cone[1u];
+            let _e498 = cone[0u];
+            let _e500 = cone[1u];
+            let _e504 = attenuation_1;
+            attenuation_1 = (_e504 * clamp(((_e493 - _e495) / (_e498 - _e500)), 0f, 1f));
+        }
+    }
+    let _e507 = light_3.l;
+    let _e509 = (*s_4).v;
+    light_3.h = normalize((_e507 + _e509));
+    let _e514 = (*s_4).n;
+    let _e516 = light_3.l;
+    light_3.n_dot_l = max(dot(_e514, _e516), 0f);
+    let _e521 = (*s_4).n;
+    let _e523 = light_3.h;
+    light_3.n_dot_h = max(dot(_e521, _e523), 0f);
+    let _e528 = (*s_4).v;
+    let _e530 = light_3.h;
+    light_3.v_dot_h = max(dot(_e528, _e530), 0f);
+    let _e534 = color_1;
+    let _e537 = color_1[3u];
+    let _e539 = attenuation_1;
+    light_3.radiance = ((_e534.xyz * _e537) * _e539);
+    let _e542 = light_3;
+    return _e542;
 }
 
 fn FindCluster_u0028_vf3_u003b(world_3: ptr<function, vec3<f32>>) {
@@ -25784,58 +25973,58 @@ fn FindCluster_u0028_vf3_u003b(world_3: ptr<function, vec3<f32>>) {
     var param_100: f32;
     var param_101: f32;
 
-    let _e203 = light_list_info.cluster_view_projection;
-    let _e204 = (*world_3);
-    clip_1 = (_e203 * vec4<f32>(_e204.x, _e204.y, _e204.z, 1f));
-    let _e210 = clip_1;
-    let _e213 = clip_1[3u];
-    ndc_1 = (_e210.xy / vec2(max(_e213, 0.000001f)));
-    let _e218 = light_list_info.cluster_grid;
-    grid = _e218.xyz;
-    let _e222 = light_list_info.cluster_depth[0u];
-    near_1 = _e222;
-    let _e224 = ndc_1[0u];
-    let _e228 = grid[0u];
-    let _e232 = grid[0u];
-    tx = clamp(floor((((_e224 * 0.5f) + 0.5f) * _e228)), 0f, (_e232 - 1f));
-    let _e236 = ndc_1[1u];
-    let _e240 = grid[1u];
-    let _e244 = grid[1u];
-    ty = clamp(floor((((_e236 * 0.5f) + 0.5f) * _e240)), 0f, (_e244 - 1f));
-    let _e248 = clip_1[3u];
-    let _e249 = near_1;
-    if (_e248 <= _e249) {
+    let _e204 = light_list_info.cluster_view_projection;
+    let _e205 = (*world_3);
+    clip_1 = (_e204 * vec4<f32>(_e205.x, _e205.y, _e205.z, 1f));
+    let _e211 = clip_1;
+    let _e214 = clip_1[3u];
+    ndc_1 = (_e211.xy / vec2(max(_e214, 0.000001f)));
+    let _e219 = light_list_info.cluster_grid;
+    grid = _e219.xyz;
+    let _e223 = light_list_info.cluster_depth[0u];
+    near_1 = _e223;
+    let _e225 = ndc_1[0u];
+    let _e229 = grid[0u];
+    let _e233 = grid[0u];
+    tx = clamp(floor((((_e225 * 0.5f) + 0.5f) * _e229)), 0f, (_e233 - 1f));
+    let _e237 = ndc_1[1u];
+    let _e241 = grid[1u];
+    let _e245 = grid[1u];
+    ty = clamp(floor((((_e237 * 0.5f) + 0.5f) * _e241)), 0f, (_e245 - 1f));
+    let _e249 = clip_1[3u];
+    let _e250 = near_1;
+    if (_e249 <= _e250) {
         local_25 = 0f;
     } else {
-        let _e252 = clip_1[3u];
-        let _e253 = near_1;
-        let _e258 = light_list_info.cluster_depth[1u];
-        let _e262 = grid[2u];
-        local_25 = clamp(floor((log((_e252 / _e253)) * _e258)), 0f, (_e262 - 1f));
-    }
-    let _e265 = local_25;
-    tz = _e265;
-    let _e266 = tx;
-    let _e267 = ty;
-    let _e269 = grid[0u];
-    let _e272 = tz;
-    let _e274 = grid[0u];
-    let _e277 = grid[1u];
-    cell = ((_e266 + (_e267 * _e269)) + ((_e272 * _e274) * _e277));
-    let _e280 = cell;
-    row_3 = floor((_e280 / 4f));
-    let _e283 = cell;
-    let _e284 = row_3;
-    let _e289 = light_list_info.cluster_depth[2u];
-    let _e290 = row_3;
-    param_100 = (_e283 - (_e284 * 4f));
-    param_101 = (_e289 + _e290);
-    let _e292 = LightListTexel_u0028_f1_u003b_f1_u003b((&param_100), (&param_101));
-    header = _e292;
-    let _e294 = header[0u];
-    g_cluster_offset = _e294;
-    let _e296 = header[1u];
-    g_cluster_count = _e296;
+        let _e253 = clip_1[3u];
+        let _e254 = near_1;
+        let _e259 = light_list_info.cluster_depth[1u];
+        let _e263 = grid[2u];
+        local_25 = clamp(floor((log((_e253 / _e254)) * _e259)), 0f, (_e263 - 1f));
+    }
+    let _e266 = local_25;
+    tz = _e266;
+    let _e267 = tx;
+    let _e268 = ty;
+    let _e270 = grid[0u];
+    let _e273 = tz;
+    let _e275 = grid[0u];
+    let _e278 = grid[1u];
+    cell = ((_e267 + (_e268 * _e270)) + ((_e273 * _e275) * _e278));
+    let _e281 = cell;
+    row_3 = floor((_e281 / 4f));
+    let _e284 = cell;
+    let _e285 = row_3;
+    let _e290 = light_list_info.cluster_depth[2u];
+    let _e291 = row_3;
+    param_100 = (_e284 - (_e285 * 4f));
+    param_101 = (_e290 + _e291);
+    let _e293 = LightListTexel_u0028_f1_u003b_f1_u003b((&param_100), (&param_101));
+    header = _e293;
+    let _e295 = header[0u];
+    g_cluster_offset = _e295;
+    let _e297 = header[1u];
+    g_cluster_count = _e297;
     return;
 }
 
@@ -25843,19 +26032,19 @@ fn LightCount_u0028_() -> i32 {
     var tail: f32;
     var param_102: vec3<f32>;
 
-    let _e192 = light_list_info.list[0u];
-    tail = _e192;
-    let _e193 = Clustered_u0028_();
-    if _e193 {
-        let _e194 = v_world_position_1;
-        param_102 = _e194;
+    let _e193 = light_list_info.list[0u];
+    tail = _e193;
+    let _e194 = Clustered_u0028_();
+    if _e194 {
+        let _e195 = v_world_position_1;
+        param_102 = _e195;
         FindCluster_u0028_vf3_u003b((&param_102));
-        let _e195 = g_cluster_count;
-        tail = _e195;
+        let _e196 = g_cluster_count;
+        tail = _e196;
     }
-    let _e198 = frag_info.frame_params[1u];
-    let _e202 = tail;
-    return (clamp(i32((_e198 + 0.5f)), 0i, 8i) + clamp(i32((_e202 + 0.5f)), 0i, 24i));
+    let _e199 = frag_info.frame_params[1u];
+    let _e203 = tail;
+    return (clamp(i32((_e199 + 0.5f)), 0i, 8i) + clamp(i32((_e203 + 0.5f)), 0i, 24i));
 }
 
 fn AccumulateLights_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_5: ptr<function, Surface>) -> vec3<f32> {
@@ -25878,109 +26067,109 @@ fn AccumulateLights_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002
     var param_113: LightSample;
 
     total_1 = vec3<f32>(0f, 0f, 0f);
-    let _e206 = LightCount_u0028_();
-    count_1 = _e206;
+    let _e207 = LightCount_u0028_();
+    count_1 = _e207;
     i_8 = 0i;
     loop {
-        let _e207 = i_8;
-        if (_e207 < 32i) {
-            let _e209 = i_8;
-            let _e210 = count_1;
-            if (_e209 >= _e210) {
+        let _e208 = i_8;
+        if (_e208 < 32i) {
+            let _e210 = i_8;
+            let _e211 = count_1;
+            if (_e210 >= _e211) {
                 break;
             }
-            let _e212 = i_8;
-            param_103 = _e212;
-            let _e213 = (*s_5);
-            param_104 = _e213;
-            let _e214 = SampleLight_u0028_i1_u003b_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_103), (&param_104));
-            light_4 = _e214;
-            let _e216 = light_4.n_dot_l;
-            if (_e216 <= 0f) {
+            let _e213 = i_8;
+            param_103 = _e213;
+            let _e214 = (*s_5);
+            param_104 = _e214;
+            let _e215 = SampleLight_u0028_i1_u003b_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_103), (&param_104));
+            light_4 = _e215;
+            let _e217 = light_4.n_dot_l;
+            if (_e217 <= 0f) {
                 continue;
             }
             light_transmittance = vec3<f32>(1f, 1f, 1f);
-            let _e218 = i_8;
-            param_105 = _e218;
-            let _e219 = LightHasShadow_u0028_i1_u003b((&param_105));
-            if _e219 {
-                let _e220 = (*s_5);
-                param_106 = _e220;
-                let _e221 = light_4;
-                param_107 = _e221;
-                let _e222 = i_8;
-                param_108 = _e222;
-                let _e223 = LightVisibility_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b_i1_u003b((&param_106), (&param_107), (&param_108));
-                let _e224 = v_world_position_1;
-                param_109 = _e224;
-                let _e226 = (*s_5).n;
-                param_110 = _e226;
-                let _e227 = i_8;
-                param_111 = _e227;
-                let _e228 = PointShadowFactor_u0028_vf3_u003b_vf3_u003b_i1_u003b((&param_109), (&param_110), (&param_111));
-                local_26 = (_e223 * _e228);
+            let _e219 = i_8;
+            param_105 = _e219;
+            let _e220 = LightHasShadow_u0028_i1_u003b((&param_105));
+            if _e220 {
+                let _e221 = (*s_5);
+                param_106 = _e221;
+                let _e222 = light_4;
+                param_107 = _e222;
+                let _e223 = i_8;
+                param_108 = _e223;
+                let _e224 = LightVisibility_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b_i1_u003b((&param_106), (&param_107), (&param_108));
+                let _e225 = v_world_position_1;
+                param_109 = _e225;
+                let _e227 = (*s_5).n;
+                param_110 = _e227;
+                let _e228 = i_8;
+                param_111 = _e228;
+                let _e229 = PointShadowFactor_u0028_vf3_u003b_vf3_u003b_i1_u003b((&param_109), (&param_110), (&param_111));
+                local_26 = (_e224 * _e229);
             } else {
                 local_26 = 1f;
             }
-            let _e230 = local_26;
-            visibility = _e230;
-            let _e231 = visibility;
-            if (_e231 <= 0f) {
+            let _e231 = local_26;
+            visibility = _e231;
+            let _e232 = visibility;
+            if (_e232 <= 0f) {
                 continue;
             }
-            let _e233 = (*s_5);
-            param_112 = _e233;
-            let _e234 = light_4;
-            param_113 = _e234;
-            let _e235 = ShadeLight_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b((&param_112), (&param_113));
-            let _e237 = light_4.radiance;
-            let _e240 = light_4.n_dot_l;
-            let _e242 = visibility;
-            let _e244 = light_transmittance;
-            let _e246 = total_1;
-            total_1 = (_e246 + ((((_e235 * _e237) * _e240) * _e242) * _e244));
+            let _e234 = (*s_5);
+            param_112 = _e234;
+            let _e235 = light_4;
+            param_113 = _e235;
+            let _e236 = ShadeLight_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b((&param_112), (&param_113));
+            let _e238 = light_4.radiance;
+            let _e241 = light_4.n_dot_l;
+            let _e243 = visibility;
+            let _e245 = light_transmittance;
+            let _e247 = total_1;
+            total_1 = (_e247 + ((((_e236 * _e238) * _e241) * _e243) * _e245));
             continue;
         } else {
             break;
         }
         continuing {
-            let _e248 = i_8;
-            i_8 = (_e248 + 1i);
+            let _e249 = i_8;
+            i_8 = (_e249 + 1i);
         }
     }
-    let _e250 = total_1;
-    return _e250;
+    let _e251 = total_1;
+    return _e251;
 }
 
 fn SampleLightmap_u0028_() -> vec3<f32> {
     var texel_4: vec4<f32>;
 
-    let _e189 = v_lightmap_uv_1;
-    let _e190 = textureSample(lightmap_texture_tex, lightmap_texture_smp, _e189);
-    texel_4 = _e190;
-    let _e191 = texel_4;
-    let _e194 = texel_4[3u];
-    return ((_e191.xyz * _e194) * 8f);
+    let _e190 = v_lightmap_uv_1;
+    let _e191 = textureSample(lightmap_texture_tex, lightmap_texture_smp, _e190);
+    texel_4 = _e191;
+    let _e192 = texel_4;
+    let _e195 = texel_4[3u];
+    return ((_e192.xyz * _e195) * 8f);
 }
 
 fn MaterialLodBias_u0028_() -> f32 {
-    let _e190 = frag_info.target_origin[1u];
-    return _e190;
+    let _e191 = frag_info.target_origin[1u];
+    return _e191;
 }
 
 fn ApplyMetallicRoughnessMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_6: ptr<function, Surface>) {
     var orm: vec3<f32>;
 
-    let _e190 = v_texcoord_1;
-    let _e191 = MaterialLodBias_u0028_();
-    let _e192 = textureSampleBias(metallic_roughness_texture_tex, metallic_roughness_texture_smp, _e190, _e191);
-    orm = _e192.xyz;
-    let _e195 = (*s_6).metallic;
-    let _e197 = orm[2u];
-    (*s_6).metallic = clamp((_e195 * _e197), 0f, 1f);
-    let _e202 = (*s_6).roughness;
-    let _e204 = orm[1u];
-    (*s_6).roughness = clamp((_e202 * _e204), 0.02f, 1f);
+    let _e191 = v_texcoord_1;
+    let _e192 = MaterialLodBias_u0028_();
+    let _e193 = textureSampleBias(metallic_roughness_texture_tex, metallic_roughness_texture_smp, _e191, _e192);
+    orm = _e193.xyz;
+    let _e196 = (*s_6).metallic;
+    let _e198 = orm[2u];
+    (*s_6).metallic = clamp((_e196 * _e198), 0f, 1f);
+    let _e203 = (*s_6).roughness;
+    let _e205 = orm[1u];
+    (*s_6).roughness = clamp((_e203 * _e205), 0.02f, 1f);
     return;
 }
 
@@ -25988,29 +26177,29 @@ fn ApplyEmissiveMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002
     var emissive: vec3<f32>;
     var param_114: vec3<f32>;
 
-    let _e191 = v_texcoord_1;
-    let _e192 = MaterialLodBias_u0028_();
-    let _e193 = textureSampleBias(emissive_texture_tex, emissive_texture_smp, _e191, _e192);
-    param_114 = _e193.xyz;
-    let _e195 = SrgbToLinear_u0028_vf3_u003b((&param_114));
-    emissive = _e195;
-    let _e196 = emissive;
-    let _e198 = frag_info.emissive;
-    let _e203 = frag_info.material2_[3u];
-    (*s_7).emissive = ((_e196 * _e198.xyz) * _e203);
+    let _e192 = v_texcoord_1;
+    let _e193 = MaterialLodBias_u0028_();
+    let _e194 = textureSampleBias(emissive_texture_tex, emissive_texture_smp, _e192, _e193);
+    param_114 = _e194.xyz;
+    let _e196 = SrgbToLinear_u0028_vf3_u003b((&param_114));
+    emissive = _e196;
+    let _e197 = emissive;
+    let _e199 = frag_info.emissive;
+    let _e204 = frag_info.material2_[3u];
+    (*s_7).emissive = ((_e197 * _e199.xyz) * _e204);
     return;
 }
 
 fn ApplyOcclusionMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_8: ptr<function, Surface>) {
     var occlusion: f32;
 
-    let _e190 = v_texcoord_1;
-    let _e191 = MaterialLodBias_u0028_();
-    let _e192 = textureSampleBias(occlusion_texture_tex, occlusion_texture_smp, _e190, _e191);
-    occlusion = _e192.x;
-    let _e194 = occlusion;
-    let _e197 = frag_info.material2_[2u];
-    (*s_8).occlusion = mix(1f, _e194, clamp(_e197, 0f, 1f));
+    let _e191 = v_texcoord_1;
+    let _e192 = MaterialLodBias_u0028_();
+    let _e193 = textureSampleBias(occlusion_texture_tex, occlusion_texture_smp, _e191, _e192);
+    occlusion = _e193.x;
+    let _e195 = occlusion;
+    let _e198 = frag_info.material2_[2u];
+    (*s_8).occlusion = mix(1f, _e195, clamp(_e198, 0f, 1f));
     return;
 }
 
@@ -26020,64 +26209,64 @@ fn ApplyNormalMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_
     var b_3: vec3<f32>;
     var sampled: vec3<f32>;
 
-    let _e193 = v_texcoord_1;
-    let _e194 = MaterialLodBias_u0028_();
-    let _e195 = textureSampleBias(normal_texture_tex, normal_texture_smp, _e193, _e194);
-    sampledTexel = _e195;
-    let _e196 = v_tangent_1;
-    t_2 = _e196.xyz;
-    let _e198 = t_2;
-    let _e200 = (*s_9).n;
-    let _e202 = (*s_9).n;
-    let _e203 = t_2;
-    t_2 = (_e198 - (_e200 * dot(_e202, _e203)));
-    let _e207 = t_2;
+    let _e194 = v_texcoord_1;
+    let _e195 = MaterialLodBias_u0028_();
+    let _e196 = textureSampleBias(normal_texture_tex, normal_texture_smp, _e194, _e195);
+    sampledTexel = _e196;
+    let _e197 = v_tangent_1;
+    t_2 = _e197.xyz;
+    let _e199 = t_2;
+    let _e201 = (*s_9).n;
+    let _e203 = (*s_9).n;
+    let _e204 = t_2;
+    t_2 = (_e199 - (_e201 * dot(_e203, _e204)));
     let _e208 = t_2;
-    if (dot(_e207, _e208) < 0.000000000001f) {
+    let _e209 = t_2;
+    if (dot(_e208, _e209) < 0.000000000001f) {
         return;
     }
-    let _e211 = t_2;
-    t_2 = normalize(_e211);
-    let _e214 = (*s_9).n;
-    let _e215 = t_2;
-    let _e218 = v_tangent_1[3u];
-    b_3 = (cross(_e214, _e215) * _e218);
-    let _e220 = gl_FrontFacing_1;
-    if !(_e220) {
-        let _e222 = t_2;
-        t_2 = -(_e222);
-    }
-    let _e224 = sampledTexel;
-    sampled = ((_e224.xyz * 2f) - vec3(1f));
-    let _e231 = frag_info.emissive[3u];
-    if (_e231 > 0.5f) {
-        let _e233 = sampled;
-        let _e235 = sampled;
-        sampled[2u] = sqrt(max((1f - dot(_e233.xy, _e235.xy)), 0f));
-    }
-    let _e244 = frag_info.material2_[1u];
-    let _e245 = sampled;
-    let _e247 = (_e245.xy * _e244);
-    sampled[0u] = _e247.x;
-    sampled[1u] = _e247.y;
-    let _e252 = t_2;
-    let _e254 = sampled[0u];
-    let _e256 = b_3;
-    let _e258 = sampled[1u];
-    let _e262 = (*s_9).n;
-    let _e264 = sampled[2u];
-    (*s_9).n = normalize((((_e252 * _e254) + (_e256 * _e258)) + (_e262 * _e264)));
-    let _e270 = (*s_9).n;
-    let _e272 = (*s_9).v;
-    (*s_9).n_dot_v = max(dot(_e270, _e272), 0.0001f);
+    let _e212 = t_2;
+    t_2 = normalize(_e212);
+    let _e215 = (*s_9).n;
+    let _e216 = t_2;
+    let _e219 = v_tangent_1[3u];
+    b_3 = (cross(_e215, _e216) * _e219);
+    let _e221 = gl_FrontFacing_1;
+    if !(_e221) {
+        let _e223 = t_2;
+        t_2 = -(_e223);
+    }
+    let _e225 = sampledTexel;
+    sampled = ((_e225.xyz * 2f) - vec3(1f));
+    let _e232 = frag_info.emissive[3u];
+    if (_e232 > 0.5f) {
+        let _e234 = sampled;
+        let _e236 = sampled;
+        sampled[2u] = sqrt(max((1f - dot(_e234.xy, _e236.xy)), 0f));
+    }
+    let _e245 = frag_info.material2_[1u];
+    let _e246 = sampled;
+    let _e248 = (_e246.xy * _e245);
+    sampled[0u] = _e248.x;
+    sampled[1u] = _e248.y;
+    let _e253 = t_2;
+    let _e255 = sampled[0u];
+    let _e257 = b_3;
+    let _e259 = sampled[1u];
+    let _e263 = (*s_9).n;
+    let _e265 = sampled[2u];
+    (*s_9).n = normalize((((_e253 * _e255) + (_e257 * _e259)) + (_e263 * _e265)));
+    let _e271 = (*s_9).n;
+    let _e273 = (*s_9).v;
+    (*s_9).n_dot_v = max(dot(_e271, _e273), 0.0001f);
     return;
 }
 
 fn AtlasTexel_u0028_vf2_u003b(texel_5: ptr<function, vec2<f32>>) -> vec4<f32> {
-    let _e189 = (*texel_5);
-    let _e193 = irradiance_info.atlas;
-    let _e196 = textureSampleLevel(irradiance_texture_tex, irradiance_texture_smp, ((_e189 + vec2(0.5f)) * _e193.xy), 0f);
-    return _e196;
+    let _e190 = (*texel_5);
+    let _e194 = irradiance_info.atlas;
+    let _e197 = textureSampleLevel(irradiance_texture_tex, irradiance_texture_smp, ((_e190 + vec2(0.5f)) * _e194.xy), 0f);
+    return _e197;
 }
 
 fn TileBilinear_u0028_vf2_u003b_f1_u003b_vf2_u003b(corner: ptr<function, vec2<f32>>, interior: ptr<function, f32>, uv_5: ptr<function, vec2<f32>>) -> vec4<f32> {
@@ -26093,42 +26282,42 @@ fn TileBilinear_u0028_vf2_u003b_f1_u003b_vf2_u003b(corner: ptr<function, vec2<f3
     var d_4: vec4<f32>;
     var param_118: vec2<f32>;
 
-    let _e202 = (*uv_5);
-    let _e203 = (*interior);
-    at_1 = ((vec2(1f) + (_e202 * _e203)) - vec2(0.5f));
-    let _e209 = at_1;
-    low = floor(_e209);
-    let _e211 = at_1;
-    let _e212 = low;
-    f = (_e211 - _e212);
-    let _e214 = (*corner);
-    let _e215 = low;
-    param_115 = (_e214 + _e215);
-    let _e217 = AtlasTexel_u0028_vf2_u003b((&param_115));
-    a_4 = _e217;
-    let _e218 = (*corner);
-    let _e219 = low;
-    param_116 = ((_e218 + _e219) + vec2<f32>(1f, 0f));
-    let _e222 = AtlasTexel_u0028_vf2_u003b((&param_116));
-    b_4 = _e222;
-    let _e223 = (*corner);
-    let _e224 = low;
-    param_117 = ((_e223 + _e224) + vec2<f32>(0f, 1f));
-    let _e227 = AtlasTexel_u0028_vf2_u003b((&param_117));
-    c_1 = _e227;
-    let _e228 = (*corner);
-    let _e229 = low;
-    param_118 = ((_e228 + _e229) + vec2<f32>(1f, 1f));
-    let _e232 = AtlasTexel_u0028_vf2_u003b((&param_118));
-    d_4 = _e232;
-    let _e233 = a_4;
-    let _e234 = b_4;
-    let _e236 = f[0u];
-    let _e239 = c_1;
-    let _e240 = d_4;
-    let _e242 = f[0u];
-    let _e246 = f[1u];
-    return mix(mix(_e233, _e234, vec4(_e236)), mix(_e239, _e240, vec4(_e242)), vec4(_e246));
+    let _e203 = (*uv_5);
+    let _e204 = (*interior);
+    at_1 = ((vec2(1f) + (_e203 * _e204)) - vec2(0.5f));
+    let _e210 = at_1;
+    low = floor(_e210);
+    let _e212 = at_1;
+    let _e213 = low;
+    f = (_e212 - _e213);
+    let _e215 = (*corner);
+    let _e216 = low;
+    param_115 = (_e215 + _e216);
+    let _e218 = AtlasTexel_u0028_vf2_u003b((&param_115));
+    a_4 = _e218;
+    let _e219 = (*corner);
+    let _e220 = low;
+    param_116 = ((_e219 + _e220) + vec2<f32>(1f, 0f));
+    let _e223 = AtlasTexel_u0028_vf2_u003b((&param_116));
+    b_4 = _e223;
+    let _e224 = (*corner);
+    let _e225 = low;
+    param_117 = ((_e224 + _e225) + vec2<f32>(0f, 1f));
+    let _e228 = AtlasTexel_u0028_vf2_u003b((&param_117));
+    c_1 = _e228;
+    let _e229 = (*corner);
+    let _e230 = low;
+    param_118 = ((_e229 + _e230) + vec2<f32>(1f, 1f));
+    let _e233 = AtlasTexel_u0028_vf2_u003b((&param_118));
+    d_4 = _e233;
+    let _e234 = a_4;
+    let _e235 = b_4;
+    let _e237 = f[0u];
+    let _e240 = c_1;
+    let _e241 = d_4;
+    let _e243 = f[0u];
+    let _e247 = f[1u];
+    return mix(mix(_e234, _e235, vec4(_e237)), mix(_e240, _e241, vec4(_e243)), vec4(_e247));
 }
 
 fn ProbeOctahedral_u0028_vf3_u003b(direction_1: ptr<function, vec3<f32>>) -> vec2<f32> {
@@ -26136,29 +26325,29 @@ fn ProbeOctahedral_u0028_vf3_u003b(direction_1: ptr<function, vec3<f32>>) -> vec
     var n_5: vec3<f32>;
     var xy: vec2<f32>;
 
-    let _e193 = (*direction_1)[0u];
-    let _e196 = (*direction_1)[1u];
-    let _e200 = (*direction_1)[2u];
-    sum_1 = ((abs(_e193) + abs(_e196)) + abs(_e200));
-    let _e203 = sum_1;
-    if (_e203 <= 0f) {
+    let _e194 = (*direction_1)[0u];
+    let _e197 = (*direction_1)[1u];
+    let _e201 = (*direction_1)[2u];
+    sum_1 = ((abs(_e194) + abs(_e197)) + abs(_e201));
+    let _e204 = sum_1;
+    if (_e204 <= 0f) {
         return vec2<f32>(0.5f, 0.5f);
     }
-    let _e205 = (*direction_1);
-    let _e206 = sum_1;
-    n_5 = (_e205 / vec3(_e206));
-    let _e209 = n_5;
-    xy = _e209.xy;
-    let _e212 = n_5[2u];
-    if (_e212 < 0f) {
-        let _e215 = n_5[1u];
-        let _e219 = n_5[0u];
-        let _e224 = n_5[0u];
-        let _e228 = n_5[1u];
-        xy = vec2<f32>(((1f - abs(_e215)) * select(-1f, 1f, (_e219 >= 0f))), ((1f - abs(_e224)) * select(-1f, 1f, (_e228 >= 0f))));
+    let _e206 = (*direction_1);
+    let _e207 = sum_1;
+    n_5 = (_e206 / vec3(_e207));
+    let _e210 = n_5;
+    xy = _e210.xy;
+    let _e213 = n_5[2u];
+    if (_e213 < 0f) {
+        let _e216 = n_5[1u];
+        let _e220 = n_5[0u];
+        let _e225 = n_5[0u];
+        let _e229 = n_5[1u];
+        xy = vec2<f32>(((1f - abs(_e216)) * select(-1f, 1f, (_e220 >= 0f))), ((1f - abs(_e225)) * select(-1f, 1f, (_e229 >= 0f))));
     }
-    let _e233 = xy;
-    return ((_e233 * 0.5f) + vec2(0.5f));
+    let _e234 = xy;
+    return ((_e234 * 0.5f) + vec2(0.5f));
 }
 
 fn SampleIrradiance_u0028_vf3_u003b_vf3_u003b_vf3_u003b(world_4: ptr<function, vec3<f32>>, normal_1: ptr<function, vec3<f32>>, view_1: ptr<function, vec3<f32>>) -> vec3<f32> {
@@ -26206,190 +26395,190 @@ fn SampleIrradiance_u0028_vf3_u003b_vf3_u003b_vf3_u003b(world_4: ptr<function, v
     var param_127: vec2<f32>;
     var local_27: vec3<f32>;
 
-    let _e235 = irradiance_info.origin;
-    origin_2 = _e235.xyz;
-    let _e238 = irradiance_info.spacing;
-    spacing = _e238.xyz;
-    let _e241 = irradiance_info.counts;
-    counts = _e241.xyz;
-    let _e245 = irradiance_info.tiles[0u];
-    irradianceTile = _e245;
-    let _e248 = irradiance_info.tiles[1u];
-    depthTile = _e248;
-    let _e251 = irradiance_info.tiles[2u];
-    columns = _e251;
-    let _e254 = irradiance_info.tiles[3u];
-    momentsTop = _e254;
-    let _e255 = (*normal_1);
-    unit = normalize(_e255);
-    let _e257 = (*world_4);
-    let _e258 = unit;
-    let _e261 = irradiance_info.spacing[3u];
-    let _e264 = (*view_1);
-    let _e267 = irradiance_info.counts[3u];
-    biased = ((_e257 + (_e258 * _e261)) + (_e264 * _e267));
-    let _e270 = biased;
-    let _e271 = origin_2;
-    let _e273 = spacing;
-    grid_1 = ((_e270 - _e271) / _e273);
-    let _e275 = grid_1;
-    let _e277 = counts;
-    base = clamp(floor(_e275), vec3<f32>(0f, 0f, 0f), (_e277 - vec3(2f)));
-    let _e281 = grid_1;
-    let _e282 = base;
-    f_1 = clamp((_e281 - _e282), vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
+    let _e236 = irradiance_info.origin;
+    origin_2 = _e236.xyz;
+    let _e239 = irradiance_info.spacing;
+    spacing = _e239.xyz;
+    let _e242 = irradiance_info.counts;
+    counts = _e242.xyz;
+    let _e246 = irradiance_info.tiles[0u];
+    irradianceTile = _e246;
+    let _e249 = irradiance_info.tiles[1u];
+    depthTile = _e249;
+    let _e252 = irradiance_info.tiles[2u];
+    columns = _e252;
+    let _e255 = irradiance_info.tiles[3u];
+    momentsTop = _e255;
+    let _e256 = (*normal_1);
+    unit = normalize(_e256);
+    let _e258 = (*world_4);
+    let _e259 = unit;
+    let _e262 = irradiance_info.spacing[3u];
+    let _e265 = (*view_1);
+    let _e268 = irradiance_info.counts[3u];
+    biased = ((_e258 + (_e259 * _e262)) + (_e265 * _e268));
+    let _e271 = biased;
+    let _e272 = origin_2;
+    let _e274 = spacing;
+    grid_1 = ((_e271 - _e272) / _e274);
+    let _e276 = grid_1;
+    let _e278 = counts;
+    base = clamp(floor(_e276), vec3<f32>(0f, 0f, 0f), (_e278 - vec3(2f)));
+    let _e282 = grid_1;
+    let _e283 = base;
+    f_1 = clamp((_e282 - _e283), vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
     total_2 = vec3<f32>(0f, 0f, 0f);
     weights = 0f;
     corner_1 = 0i;
     loop {
-        let _e285 = corner_1;
-        if (_e285 < 8i) {
-            let _e287 = corner_1;
-            let _e290 = corner_1;
-            let _e295 = corner_1;
-            offset_3 = vec3<f32>(f32((_e287 & 1i)), f32(((_e290 >> bitcast<u32>(1i)) & 1i)), f32(((_e295 >> bitcast<u32>(2i)) & 1i)));
-            let _e301 = base;
-            let _e302 = offset_3;
-            cell_1 = (_e301 + _e302);
-            let _e305 = cell_1[2u];
-            let _e307 = counts[1u];
-            let _e310 = cell_1[1u];
-            let _e313 = counts[0u];
-            let _e316 = cell_1[0u];
-            probe = ((((_e305 * _e307) + _e310) * _e313) + _e316);
-            let _e318 = probe;
-            let _e319 = columns;
-            let _e324 = probe;
-            let _e325 = columns;
-            tile_4 = vec2<f32>((_e318 - (floor((_e318 / _e319)) * _e319)), floor((_e324 / _e325)));
-            let _e329 = tile_4;
-            let _e330 = irradianceTile;
-            irradianceCorner = (_e329 * (_e330 + 2f));
-            let _e334 = tile_4[0u];
-            let _e335 = depthTile;
-            let _e338 = momentsTop;
-            let _e340 = tile_4[1u];
-            let _e341 = depthTile;
-            momentCorner = vec2<f32>((_e334 * (_e335 + 2f)), (_e338 + (_e340 * (_e341 + 2f))));
-            let _e346 = irradianceCorner;
-            param_119 = (_e346 + vec2(1f));
-            let _e349 = AtlasTexel_u0028_vf2_u003b((&param_119));
-            if (_e349.w < 0.5f) {
+        let _e286 = corner_1;
+        if (_e286 < 8i) {
+            let _e288 = corner_1;
+            let _e291 = corner_1;
+            let _e296 = corner_1;
+            offset_3 = vec3<f32>(f32((_e288 & 1i)), f32(((_e291 >> bitcast<u32>(1i)) & 1i)), f32(((_e296 >> bitcast<u32>(2i)) & 1i)));
+            let _e302 = base;
+            let _e303 = offset_3;
+            cell_1 = (_e302 + _e303);
+            let _e306 = cell_1[2u];
+            let _e308 = counts[1u];
+            let _e311 = cell_1[1u];
+            let _e314 = counts[0u];
+            let _e317 = cell_1[0u];
+            probe = ((((_e306 * _e308) + _e311) * _e314) + _e317);
+            let _e319 = probe;
+            let _e320 = columns;
+            let _e325 = probe;
+            let _e326 = columns;
+            tile_4 = vec2<f32>((_e319 - (floor((_e319 / _e320)) * _e320)), floor((_e325 / _e326)));
+            let _e330 = tile_4;
+            let _e331 = irradianceTile;
+            irradianceCorner = (_e330 * (_e331 + 2f));
+            let _e335 = tile_4[0u];
+            let _e336 = depthTile;
+            let _e339 = momentsTop;
+            let _e341 = tile_4[1u];
+            let _e342 = depthTile;
+            momentCorner = vec2<f32>((_e335 * (_e336 + 2f)), (_e339 + (_e341 * (_e342 + 2f))));
+            let _e347 = irradianceCorner;
+            param_119 = (_e347 + vec2(1f));
+            let _e350 = AtlasTexel_u0028_vf2_u003b((&param_119));
+            if (_e350.w < 0.5f) {
                 continue;
             }
-            let _e352 = f_1;
-            let _e354 = f_1;
-            let _e355 = offset_3;
-            trilinear = mix((vec3<f32>(1f, 1f, 1f) - _e352), _e354, _e355);
-            let _e358 = trilinear[0u];
-            let _e360 = trilinear[1u];
-            let _e363 = trilinear[2u];
-            weight_3 = max(((_e358 * _e360) * _e363), 0.001f);
-            let _e366 = origin_2;
-            let _e367 = spacing;
-            let _e368 = cell_1;
-            probePosition = (_e366 + (_e367 * _e368));
-            let _e371 = probePosition;
-            let _e372 = biased;
-            toProbe = (_e371 - _e372);
-            let _e374 = toProbe;
-            distance_4 = length(_e374);
-            let _e376 = distance_4;
-            if (_e376 > 0.000001f) {
-                let _e378 = toProbe;
-                let _e379 = distance_4;
-                direction_2 = (_e378 / vec3(_e379));
-                let _e382 = unit;
-                let _e383 = probePosition;
-                let _e384 = (*world_4);
-                facing = ((dot(_e382, normalize((_e383 - _e384))) * 0.5f) + 0.5f);
-                let _e390 = facing;
+            let _e353 = f_1;
+            let _e355 = f_1;
+            let _e356 = offset_3;
+            trilinear = mix((vec3<f32>(1f, 1f, 1f) - _e353), _e355, _e356);
+            let _e359 = trilinear[0u];
+            let _e361 = trilinear[1u];
+            let _e364 = trilinear[2u];
+            weight_3 = max(((_e359 * _e361) * _e364), 0.001f);
+            let _e367 = origin_2;
+            let _e368 = spacing;
+            let _e369 = cell_1;
+            probePosition = (_e367 + (_e368 * _e369));
+            let _e372 = probePosition;
+            let _e373 = biased;
+            toProbe = (_e372 - _e373);
+            let _e375 = toProbe;
+            distance_4 = length(_e375);
+            let _e377 = distance_4;
+            if (_e377 > 0.000001f) {
+                let _e379 = toProbe;
+                let _e380 = distance_4;
+                direction_2 = (_e379 / vec3(_e380));
+                let _e383 = unit;
+                let _e384 = probePosition;
+                let _e385 = (*world_4);
+                facing = ((dot(_e383, normalize((_e384 - _e385))) * 0.5f) + 0.5f);
                 let _e391 = facing;
-                probeWeight = ((_e390 * _e391) + 0.2f);
-                let _e394 = direction_2;
-                param_120 = -(_e394);
-                let _e396 = ProbeOctahedral_u0028_vf3_u003b((&param_120));
-                let _e397 = momentCorner;
-                param_121 = _e397;
-                let _e398 = depthTile;
-                param_122 = _e398;
-                param_123 = _e396;
-                let _e399 = TileBilinear_u0028_vf2_u003b_f1_u003b_vf2_u003b((&param_121), (&param_122), (&param_123));
-                moments_3 = _e399.xy;
+                let _e392 = facing;
+                probeWeight = ((_e391 * _e392) + 0.2f);
+                let _e395 = direction_2;
+                param_120 = -(_e395);
+                let _e397 = ProbeOctahedral_u0028_vf3_u003b((&param_120));
+                let _e398 = momentCorner;
+                param_121 = _e398;
+                let _e399 = depthTile;
+                param_122 = _e399;
+                param_123 = _e397;
+                let _e400 = TileBilinear_u0028_vf2_u003b_f1_u003b_vf2_u003b((&param_121), (&param_122), (&param_123));
+                moments_3 = _e400.xy;
                 chebyshev = 1f;
-                let _e401 = distance_4;
-                let _e403 = moments_3[0u];
-                if (_e401 > _e403) {
-                    let _e406 = moments_3[1u];
-                    let _e408 = moments_3[0u];
-                    let _e410 = moments_3[0u];
-                    variance_1 = max((_e406 - (_e408 * _e410)), 0.000001f);
-                    let _e414 = distance_4;
-                    let _e416 = moments_3[0u];
-                    difference = (_e414 - _e416);
-                    let _e418 = variance_1;
+                let _e402 = distance_4;
+                let _e404 = moments_3[0u];
+                if (_e402 > _e404) {
+                    let _e407 = moments_3[1u];
+                    let _e409 = moments_3[0u];
+                    let _e411 = moments_3[0u];
+                    variance_1 = max((_e407 - (_e409 * _e411)), 0.000001f);
+                    let _e415 = distance_4;
+                    let _e417 = moments_3[0u];
+                    difference = (_e415 - _e417);
                     let _e419 = variance_1;
-                    let _e420 = difference;
+                    let _e420 = variance_1;
                     let _e421 = difference;
-                    chebyshev = (_e418 / (_e419 + (_e420 * _e421)));
-                    let _e425 = chebyshev;
+                    let _e422 = difference;
+                    chebyshev = (_e419 / (_e420 + (_e421 * _e422)));
                     let _e426 = chebyshev;
-                    let _e428 = chebyshev;
-                    chebyshev = ((_e425 * _e426) * _e428);
+                    let _e427 = chebyshev;
+                    let _e429 = chebyshev;
+                    chebyshev = ((_e426 * _e427) * _e429);
                 }
-                let _e430 = probeWeight;
-                let _e431 = chebyshev;
-                probeWeight = max((_e430 * max(_e431, 0.05f)), 0.000001f);
-                let _e435 = probeWeight;
-                if (_e435 < 0.2f) {
-                    let _e437 = probeWeight;
+                let _e431 = probeWeight;
+                let _e432 = chebyshev;
+                probeWeight = max((_e431 * max(_e432, 0.05f)), 0.000001f);
+                let _e436 = probeWeight;
+                if (_e436 < 0.2f) {
                     let _e438 = probeWeight;
-                    let _e441 = probeWeight;
-                    probeWeight = (_e441 * ((_e437 * _e438) * 25f));
+                    let _e439 = probeWeight;
+                    let _e442 = probeWeight;
+                    probeWeight = (_e442 * ((_e438 * _e439) * 25f));
                 }
-                let _e443 = probeWeight;
-                let _e444 = weight_3;
-                weight_3 = (_e444 * _e443);
-            }
-            let _e446 = unit;
-            param_124 = _e446;
-            let _e447 = ProbeOctahedral_u0028_vf3_u003b((&param_124));
-            let _e448 = irradianceCorner;
-            param_125 = _e448;
-            let _e449 = irradianceTile;
-            param_126 = _e449;
-            param_127 = _e447;
-            let _e450 = TileBilinear_u0028_vf2_u003b_f1_u003b_vf2_u003b((&param_125), (&param_126), (&param_127));
-            let _e452 = weight_3;
-            let _e454 = total_2;
-            total_2 = (_e454 + (_e450.xyz * _e452));
-            let _e456 = weight_3;
-            let _e457 = weights;
-            weights = (_e457 + _e456);
+                let _e444 = probeWeight;
+                let _e445 = weight_3;
+                weight_3 = (_e445 * _e444);
+            }
+            let _e447 = unit;
+            param_124 = _e447;
+            let _e448 = ProbeOctahedral_u0028_vf3_u003b((&param_124));
+            let _e449 = irradianceCorner;
+            param_125 = _e449;
+            let _e450 = irradianceTile;
+            param_126 = _e450;
+            param_127 = _e448;
+            let _e451 = TileBilinear_u0028_vf2_u003b_f1_u003b_vf2_u003b((&param_125), (&param_126), (&param_127));
+            let _e453 = weight_3;
+            let _e455 = total_2;
+            total_2 = (_e455 + (_e451.xyz * _e453));
+            let _e457 = weight_3;
+            let _e458 = weights;
+            weights = (_e458 + _e457);
             continue;
         } else {
             break;
         }
         continuing {
-            let _e459 = corner_1;
-            corner_1 = (_e459 + 1i);
+            let _e460 = corner_1;
+            corner_1 = (_e460 + 1i);
         }
     }
-    let _e461 = weights;
-    if (_e461 > 0f) {
-        let _e463 = total_2;
-        let _e464 = weights;
-        local_27 = (_e463 / vec3(_e464));
+    let _e462 = weights;
+    if (_e462 > 0f) {
+        let _e464 = total_2;
+        let _e465 = weights;
+        local_27 = (_e464 / vec3(_e465));
     } else {
         local_27 = vec3<f32>(0f, 0f, 0f);
     }
-    let _e467 = local_27;
-    return _e467;
+    let _e468 = local_27;
+    return _e468;
 }
 
 fn IrradianceEnabled_u0028_() -> bool {
-    let _e190 = irradiance_info.origin[3u];
-    return (_e190 > 0.5f);
+    let _e191 = irradiance_info.origin[3u];
+    return (_e191 > 0.5f);
 }
 
 fn ApplyCommonMaps_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_10: ptr<function, Surface>) {
@@ -26400,50 +26589,50 @@ fn ApplyCommonMaps_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d
     var param_132: Surface;
     var param_133: Surface;
 
-    let _e195 = IrradianceEnabled_u0028_();
-    if _e195 {
-        let _e196 = v_world_position_1;
-        param_128 = _e196;
-        let _e198 = (*s_10).n;
-        param_129 = _e198;
-        let _e200 = (*s_10).v;
-        param_130 = _e200;
-        let _e201 = SampleIrradiance_u0028_vf3_u003b_vf3_u003b_vf3_u003b((&param_128), (&param_129), (&param_130));
-        let _e204 = frag_info.material[2u];
-        (*s_10).ambient = (_e201 * _e204);
+    let _e196 = IrradianceEnabled_u0028_();
+    if _e196 {
+        let _e197 = v_world_position_1;
+        param_128 = _e197;
+        let _e199 = (*s_10).n;
+        param_129 = _e199;
+        let _e201 = (*s_10).v;
+        param_130 = _e201;
+        let _e202 = SampleIrradiance_u0028_vf3_u003b_vf3_u003b_vf3_u003b((&param_128), (&param_129), (&param_130));
+        let _e205 = frag_info.material[2u];
+        (*s_10).ambient = (_e202 * _e205);
     }
-    let _e207 = (*s_10);
-    param_131 = _e207;
+    let _e208 = (*s_10);
+    param_131 = _e208;
     ApplyNormalMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_131));
-    let _e208 = param_131;
-    (*s_10) = _e208;
-    let _e209 = (*s_10);
-    param_132 = _e209;
+    let _e209 = param_131;
+    (*s_10) = _e209;
+    let _e210 = (*s_10);
+    param_132 = _e210;
     ApplyOcclusionMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_132));
-    let _e210 = param_132;
-    (*s_10) = _e210;
-    let _e211 = (*s_10);
-    param_133 = _e211;
+    let _e211 = param_132;
+    (*s_10) = _e211;
+    let _e212 = (*s_10);
+    param_133 = _e212;
     ApplyEmissiveMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_133));
-    let _e212 = param_133;
-    (*s_10) = _e212;
+    let _e213 = param_133;
+    (*s_10) = _e213;
     return;
 }
 
 fn TowardsEye_u0028_() -> vec3<f32> {
     var local_28: vec3<f32>;
 
-    let _e189 = Orthographic_u0028_();
-    if _e189 {
-        let _e191 = fog_info.forward;
-        local_28 = -(_e191.xyz);
+    let _e190 = Orthographic_u0028_();
+    if _e190 {
+        let _e192 = fog_info.forward;
+        local_28 = -(_e192.xyz);
     } else {
-        let _e195 = fog_info.eye;
-        let _e197 = v_world_position_1;
-        local_28 = normalize((_e195.xyz - _e197));
+        let _e196 = fog_info.eye;
+        let _e198 = v_world_position_1;
+        local_28 = normalize((_e196.xyz - _e198));
     }
-    let _e200 = local_28;
-    return _e200;
+    let _e201 = local_28;
+    return _e201;
 }
 
 fn ReadSurface_u0028_() -> Surface {
@@ -26456,89 +26645,89 @@ fn ReadSurface_u0028_() -> Surface {
     var anchored: vec3<f32>;
     var noise_1: f32;
 
-    let _e196 = v_texcoord_1;
-    let _e197 = MaterialLodBias_u0028_();
-    let _e198 = textureSampleBias(base_color_texture_tex, base_color_texture_smp, _e196, _e197);
-    texel_6 = _e198;
-    let _e199 = texel_6;
-    param_134 = _e199.xyz;
-    let _e201 = SrgbToLinear_u0028_vf3_u003b((&param_134));
-    let _e203 = frag_info.base_color;
-    param_135 = _e203.xyz;
-    let _e205 = SrgbToLinear_u0028_vf3_u003b((&param_135));
-    let _e207 = v_color_1;
-    s_11.albedo = ((_e201 * _e205) * _e207.xyz);
-    let _e212 = texel_6[3u];
-    let _e215 = frag_info.base_color[3u];
-    let _e218 = v_color_1[3u];
-    s_11.alpha = ((_e212 * _e215) * _e218);
-    let _e222 = s_11.albedo;
-    g_albedo = _e222;
-    let _e225 = frag_info.material2_[0u];
-    cutoff = _e225;
-    let _e226 = cutoff;
-    if (_e226 > 1f) {
-        let _e228 = cutoff;
-        edge = (_e228 - 1f);
-        let _e231 = s_11.alpha;
-        let _e232 = edge;
-        let _e235 = s_11.alpha;
-        let _e236 = fwidth(_e235);
-        s_11.alpha = clamp((((_e231 - _e232) / max(_e236, 0.0001f)) + 0.5f), 0f, 1f);
-    } else {
-        let _e242 = cutoff;
-        if (_e242 >= 0f) {
-            let _e245 = s_11.alpha;
-            let _e246 = cutoff;
-            if (_e245 < _e246) {
+    let _e197 = v_texcoord_1;
+    let _e198 = MaterialLodBias_u0028_();
+    let _e199 = textureSampleBias(base_color_texture_tex, base_color_texture_smp, _e197, _e198);
+    texel_6 = _e199;
+    let _e200 = texel_6;
+    param_134 = _e200.xyz;
+    let _e202 = SrgbToLinear_u0028_vf3_u003b((&param_134));
+    let _e204 = frag_info.base_color;
+    param_135 = _e204.xyz;
+    let _e206 = SrgbToLinear_u0028_vf3_u003b((&param_135));
+    let _e208 = v_color_1;
+    s_11.albedo = ((_e202 * _e206) * _e208.xyz);
+    let _e213 = texel_6[3u];
+    let _e216 = frag_info.base_color[3u];
+    let _e219 = v_color_1[3u];
+    s_11.alpha = ((_e213 * _e216) * _e219);
+    let _e223 = s_11.albedo;
+    g_albedo = _e223;
+    let _e226 = frag_info.material2_[0u];
+    cutoff = _e226;
+    let _e227 = cutoff;
+    if (_e227 > 1f) {
+        let _e229 = cutoff;
+        edge = (_e229 - 1f);
+        let _e232 = s_11.alpha;
+        let _e233 = edge;
+        let _e236 = s_11.alpha;
+        let _e237 = fwidth(_e236);
+        s_11.alpha = clamp((((_e232 - _e233) / max(_e237, 0.0001f)) + 0.5f), 0f, 1f);
+    } else {
+        let _e243 = cutoff;
+        if (_e243 >= 0f) {
+            let _e246 = s_11.alpha;
+            let _e247 = cutoff;
+            if (_e246 < _e247) {
                 discard;
             }
             s_11.alpha = 1f;
         } else {
-            let _e249 = cutoff;
-            if (_e249 < -1.5f) {
-                let _e251 = v_world_position_1;
-                anchored = floor((_e251 * 16f));
-                let _e254 = anchored;
-                noise_1 = fract((sin(dot(_e254, vec3<f32>(12.9898f, 78.233f, 37.719f))) * 43758.547f));
-                let _e260 = s_11.alpha;
-                let _e261 = noise_1;
-                if (_e260 < _e261) {
+            let _e250 = cutoff;
+            if (_e250 < -1.5f) {
+                let _e252 = v_world_position_1;
+                anchored = floor((_e252 * 16f));
+                let _e255 = anchored;
+                noise_1 = fract((sin(dot(_e255, vec3<f32>(12.9898f, 78.233f, 37.719f))) * 43758.547f));
+                let _e261 = s_11.alpha;
+                let _e262 = noise_1;
+                if (_e261 < _e262) {
                     discard;
                 }
             }
         }
     }
-    let _e263 = cutoff;
-    let _e265 = cutoff;
-    g_premultiply = ((_e263 < 0f) && (_e265 > -0.75f));
-    let _e268 = v_normal_1;
-    s_11.n = normalize(_e268);
-    let _e271 = gl_FrontFacing_1;
-    if !(_e271) {
-        let _e274 = s_11.n;
-        s_11.n = -(_e274);
-    }
-    let _e277 = TowardsEye_u0028_();
-    s_11.v = _e277;
-    let _e280 = s_11.n;
-    let _e282 = s_11.v;
-    s_11.n_dot_v = max(dot(_e280, _e282), 0.0001f);
-    let _e288 = frag_info.material[0u];
-    s_11.metallic = clamp(_e288, 0f, 1f);
-    let _e293 = frag_info.material[1u];
-    s_11.roughness = clamp(_e293, 0.02f, 1f);
-    let _e297 = frag_info.ambient_ground;
-    let _e300 = frag_info.ambient_sky;
-    let _e304 = s_11.n[1u];
-    let _e311 = frag_info.material[2u];
-    s_11.ambient = (mix(_e297.xyz, _e300.xyz, vec3(((_e304 * 0.5f) + 0.5f))) * _e311);
-    let _e316 = frag_info.frame_params[0u];
-    s_11.exposure = max(_e316, 0f);
+    let _e264 = cutoff;
+    let _e266 = cutoff;
+    g_premultiply = ((_e264 < 0f) && (_e266 > -0.75f));
+    let _e269 = v_normal_1;
+    s_11.n = normalize(_e269);
+    let _e272 = gl_FrontFacing_1;
+    if !(_e272) {
+        let _e275 = s_11.n;
+        s_11.n = -(_e275);
+    }
+    let _e278 = TowardsEye_u0028_();
+    s_11.v = _e278;
+    let _e281 = s_11.n;
+    let _e283 = s_11.v;
+    s_11.n_dot_v = max(dot(_e281, _e283), 0.0001f);
+    let _e289 = frag_info.material[0u];
+    s_11.metallic = clamp(_e289, 0f, 1f);
+    let _e294 = frag_info.material[1u];
+    s_11.roughness = clamp(_e294, 0.02f, 1f);
+    let _e298 = frag_info.ambient_ground;
+    let _e301 = frag_info.ambient_sky;
+    let _e305 = s_11.n[1u];
+    let _e312 = frag_info.material[2u];
+    s_11.ambient = (mix(_e298.xyz, _e301.xyz, vec3(((_e305 * 0.5f) + 0.5f))) * _e312);
+    let _e317 = frag_info.frame_params[0u];
+    s_11.exposure = max(_e317, 0f);
     s_11.occlusion = 1f;
     s_11.emissive = vec3<f32>(0f, 0f, 0f);
-    let _e321 = s_11;
-    return _e321;
+    let _e322 = s_11;
+    return _e322;
 }
 
 fn main_1() {
@@ -26563,48 +26752,48 @@ fn main_1() {
     g_cluster_offset = 0f;
     g_cluster_count = 0f;
     light_transmittance = vec3<f32>(1f, 1f, 1f);
-    let _e200 = ReadSurface_u0028_();
-    s_12 = _e200;
-    let _e201 = s_12;
-    param_136 = _e201;
+    let _e201 = ReadSurface_u0028_();
+    s_12 = _e201;
+    let _e202 = s_12;
+    param_136 = _e202;
     ApplyCommonMaps_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_136));
-    let _e202 = param_136;
-    s_12 = _e202;
-    let _e203 = s_12;
-    param_137 = _e203;
+    let _e203 = param_136;
+    s_12 = _e203;
+    let _e204 = s_12;
+    param_137 = _e204;
     ApplyMetallicRoughnessMap_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_137));
-    let _e204 = param_137;
-    s_12 = _e204;
-    let _e206 = s_12.n_dot_v;
-    let _e211 = frag_info.material[3u];
-    rim = (pow((1f - _e206), 3f) * _e211);
-    let _e214 = s_12.albedo;
-    let _e216 = s_12.ambient;
-    let _e217 = SampleLightmap_u0028_();
-    let _e221 = s_12.occlusion;
-    ambient = ((_e214 * (_e216 + _e217)) * _e221);
-    let _e223 = s_12;
-    param_138 = _e223;
-    let _e224 = AccumulateLights_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_138));
-    let _e226 = s_12.occlusion;
-    let _e228 = ambient;
-    let _e230 = rim;
-    let _e235 = s_12.emissive;
-    lit_3 = ((((_e224 * _e226) + _e228) + vec3((_e230 * 0.35f))) + _e235);
-    let _e237 = s_12;
-    param_139 = _e237;
-    let _e238 = lit_3;
-    param_140 = _e238;
-    let _e239 = WriteDebugView_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_vf3_u003b((&param_139), (&param_140));
-    if _e239 {
+    let _e205 = param_137;
+    s_12 = _e205;
+    let _e207 = s_12.n_dot_v;
+    let _e212 = frag_info.material[3u];
+    rim = (pow((1f - _e207), 3f) * _e212);
+    let _e215 = s_12.albedo;
+    let _e217 = s_12.ambient;
+    let _e218 = SampleLightmap_u0028_();
+    let _e222 = s_12.occlusion;
+    ambient = ((_e215 * (_e217 + _e218)) * _e222);
+    let _e224 = s_12;
+    param_138 = _e224;
+    let _e225 = AccumulateLights_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_138));
+    let _e227 = s_12.occlusion;
+    let _e229 = ambient;
+    let _e231 = rim;
+    let _e236 = s_12.emissive;
+    lit_3 = ((((_e225 * _e227) + _e229) + vec3((_e231 * 0.35f))) + _e236);
+    let _e238 = s_12;
+    param_139 = _e238;
+    let _e239 = lit_3;
+    param_140 = _e239;
+    let _e240 = WriteDebugView_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_vf3_u003b((&param_139), (&param_140));
+    if _e240 {
         return;
     }
-    let _e240 = lit_3;
-    param_141 = _e240;
-    let _e242 = s_12.alpha;
-    param_142 = _e242;
-    let _e244 = s_12.roughness;
-    param_143 = _e244;
+    let _e241 = lit_3;
+    param_141 = _e241;
+    let _e243 = s_12.alpha;
+    param_142 = _e243;
+    let _e245 = s_12.roughness;
+    param_143 = _e245;
     WriteSurface_u0028_vf3_u003b_f1_u003b_f1_u003b((&param_141), (&param_142), (&param_143));
     return;
 }
@@ -46193,10 +46382,10 @@ var<private> v_tangent_1: vec4<f32>;
 var<private> v_lightmap_uv_1: vec2<f32>;
 
 fn ViewDepth_u0028_() -> f32 {
-    let _e178 = v_world_position_1;
-    let _e180 = fog_info.eye;
-    let _e184 = fog_info.forward;
-    return dot((_e178 - _e180.xyz), _e184.xyz);
+    let _e179 = v_world_position_1;
+    let _e181 = fog_info.eye;
+    let _e185 = fog_info.forward;
+    return dot((_e179 - _e181.xyz), _e185.xyz);
 }
 
 fn WeightedBlendedWeight_u0028_f1_u003b(alpha: ptr<function, f32>) -> f32 {
@@ -46205,22 +46394,22 @@ fn WeightedBlendedWeight_u0028_f1_u003b(alpha: ptr<function, f32>) -> f32 {
     var far: f32;
     var far3_: f32;
 
-    let _e183 = ViewDepth_u0028_();
-    z = abs(_e183);
-    let _e185 = z;
-    near = (_e185 / 5f);
-    let _e187 = z;
-    far = (_e187 / 200f);
-    let _e189 = far;
+    let _e184 = ViewDepth_u0028_();
+    z = abs(_e184);
+    let _e186 = z;
+    near = (_e186 / 5f);
+    let _e188 = z;
+    far = (_e188 / 200f);
     let _e190 = far;
-    let _e192 = far;
-    far3_ = ((_e189 * _e190) * _e192);
-    let _e194 = (*alpha);
-    let _e195 = near;
+    let _e191 = far;
+    let _e193 = far;
+    far3_ = ((_e190 * _e191) * _e193);
+    let _e195 = (*alpha);
     let _e196 = near;
-    let _e199 = far3_;
+    let _e197 = near;
     let _e200 = far3_;
-    return (_e194 * clamp((10f / ((0.00001f + (_e195 * _e196)) + (_e199 * _e200))), 0.01f, 3000f));
+    let _e201 = far3_;
+    return (_e195 * clamp((10f / ((0.00001f + (_e196 * _e197)) + (_e200 * _e201))), 0.01f, 3000f));
 }
 
 fn WriteWeightedBlended_u0028_() {
@@ -46232,39 +46421,39 @@ fn WriteWeightedBlended_u0028_() {
     var revealage: bool;
     var local: vec4<f32>;
 
-    let _e187 = fog_info.forward[3u];
-    mode = _e187;
-    let _e188 = mode;
-    if (_e188 > 0.5f) {
-        let _e191 = frag_color[3u];
-        alpha_1 = _e191;
-        let _e192 = alpha_1;
-        param = _e192;
-        let _e193 = WeightedBlendedWeight_u0028_f1_u003b((&param));
-        weight = _e193;
-        let _e194 = frag_color;
-        let _e196 = weight;
-        let _e197 = (_e194.xyz * _e196);
-        let _e198 = alpha_1;
-        let _e199 = weight;
-        accumulate = vec4<f32>(_e197.x, _e197.y, _e197.z, (_e198 * _e199));
-        let _e205 = mode;
-        let _e207 = mode;
-        revealage = ((_e205 > 1.5f) && (_e207 < 2.5f));
-        let _e210 = revealage;
-        if _e210 {
-            let _e211 = alpha_1;
-            local = vec4(_e211);
+    let _e188 = fog_info.forward[3u];
+    mode = _e188;
+    let _e189 = mode;
+    if (_e189 > 0.5f) {
+        let _e192 = frag_color[3u];
+        alpha_1 = _e192;
+        let _e193 = alpha_1;
+        param = _e193;
+        let _e194 = WeightedBlendedWeight_u0028_f1_u003b((&param));
+        weight = _e194;
+        let _e195 = frag_color;
+        let _e197 = weight;
+        let _e198 = (_e195.xyz * _e197);
+        let _e199 = alpha_1;
+        let _e200 = weight;
+        accumulate = vec4<f32>(_e198.x, _e198.y, _e198.z, (_e199 * _e200));
+        let _e206 = mode;
+        let _e208 = mode;
+        revealage = ((_e206 > 1.5f) && (_e208 < 2.5f));
+        let _e211 = revealage;
+        if _e211 {
+            let _e212 = alpha_1;
+            local = vec4(_e212);
         } else {
-            let _e213 = accumulate;
-            local = _e213;
+            let _e214 = accumulate;
+            local = _e214;
         }
-        let _e214 = local;
-        frag_color = _e214;
-        let _e215 = mode;
-        if (_e215 > 2.5f) {
-            let _e217 = alpha_1;
-            frag_surface = vec4(_e217);
+        let _e215 = local;
+        frag_color = _e215;
+        let _e216 = mode;
+        if (_e216 > 2.5f) {
+            let _e218 = alpha_1;
+            frag_surface = vec4(_e218);
         }
     }
     return;
@@ -46273,29 +46462,29 @@ fn WriteWeightedBlended_u0028_() {
 fn EncodeOctahedral_u0028_vf3_u003b(n: ptr<function, vec3<f32>>) -> vec2<f32> {
     var e: vec2<f32>;
 
-    let _e181 = (*n)[0u];
-    let _e184 = (*n)[1u];
-    let _e188 = (*n)[2u];
-    let _e191 = (*n);
-    (*n) = (_e191 / vec3(((abs(_e181) + abs(_e184)) + abs(_e188))));
-    let _e194 = (*n);
-    e = _e194.xy;
-    let _e197 = (*n)[2u];
-    if (_e197 < 0f) {
-        let _e199 = (*n);
-        let _e205 = (*n)[0u];
-        let _e209 = (*n)[1u];
-        e = ((vec2(1f) - abs(_e199.yx)) * vec2<f32>(select(-1f, 1f, (_e205 >= 0f)), select(-1f, 1f, (_e209 >= 0f))));
+    let _e182 = (*n)[0u];
+    let _e185 = (*n)[1u];
+    let _e189 = (*n)[2u];
+    let _e192 = (*n);
+    (*n) = (_e192 / vec3(((abs(_e182) + abs(_e185)) + abs(_e189))));
+    let _e195 = (*n);
+    e = _e195.xy;
+    let _e198 = (*n)[2u];
+    if (_e198 < 0f) {
+        let _e200 = (*n);
+        let _e206 = (*n)[0u];
+        let _e210 = (*n)[1u];
+        e = ((vec2(1f) - abs(_e200.yx)) * vec2<f32>(select(-1f, 1f, (_e206 >= 0f)), select(-1f, 1f, (_e210 >= 0f))));
     }
-    let _e214 = e;
-    return ((_e214 * 0.5f) + vec2(0.5f));
+    let _e215 = e;
+    return ((_e215 * 0.5f) + vec2(0.5f));
 }
 
 fn LinearToSrgb_u0028_vf3_u003b(linear: ptr<function, vec3<f32>>) -> vec3<f32> {
-    let _e179 = (*linear);
-    let _e181 = (*linear);
-    let _e185 = (*linear);
-    return mix((_e179 * 12.92f), ((pow(_e181, vec3<f32>(0.41666666f, 0.41666666f, 0.41666666f)) * 1.055f) - vec3<f32>(0.055f, 0.055f, 0.055f)), step(vec3<f32>(0.0031308f, 0.0031308f, 0.0031308f), _e185));
+    let _e180 = (*linear);
+    let _e182 = (*linear);
+    let _e186 = (*linear);
+    return mix((_e180 * 12.92f), ((pow(_e182, vec3<f32>(0.41666666f, 0.41666666f, 0.41666666f)) * 1.055f) - vec3<f32>(0.055f, 0.055f, 0.055f)), step(vec3<f32>(0.0031308f, 0.0031308f, 0.0031308f), _e186));
 }
 
 fn WriteSurfaceGeometry_u0028_f1_u003b(roughness: ptr<function, f32>) {
@@ -46303,52 +46492,52 @@ fn WriteSurfaceGeometry_u0028_f1_u003b(roughness: ptr<function, f32>) {
     var geometric: vec3<f32>;
     var param_2: vec3<f32>;
 
-    let _e182 = g_albedo;
-    param_1 = clamp(_e182, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
-    let _e184 = LinearToSrgb_u0028_vf3_u003b((&param_1));
-    frag_albedo = vec4<f32>(_e184.x, _e184.y, _e184.z, 1f);
-    let _e189 = g_debug_surface_on;
-    if _e189 {
-        let _e190 = g_debug_surface;
-        let _e191 = ViewDepth_u0028_();
-        frag_surface = vec4<f32>(_e190.x, _e190.y, _e190.z, _e191);
+    let _e183 = g_albedo;
+    param_1 = clamp(_e183, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
+    let _e185 = LinearToSrgb_u0028_vf3_u003b((&param_1));
+    frag_albedo = vec4<f32>(_e185.x, _e185.y, _e185.z, 1f);
+    let _e190 = g_debug_surface_on;
+    if _e190 {
+        let _e191 = g_debug_surface;
+        let _e192 = ViewDepth_u0028_();
+        frag_surface = vec4<f32>(_e191.x, _e191.y, _e191.z, _e192);
         return;
     }
-    let _e196 = v_normal_1;
-    geometric = normalize(_e196);
-    let _e198 = gl_FrontFacing_1;
-    if !(_e198) {
-        let _e200 = geometric;
-        geometric = -(_e200);
-    }
-    let _e202 = geometric;
-    param_2 = _e202;
-    let _e203 = EncodeOctahedral_u0028_vf3_u003b((&param_2));
-    let _e204 = (*roughness);
-    let _e206 = ViewDepth_u0028_();
-    frag_surface = vec4<f32>(_e203.x, _e203.y, clamp(_e204, 0f, 1f), _e206);
+    let _e197 = v_normal_1;
+    geometric = normalize(_e197);
+    let _e199 = gl_FrontFacing_1;
+    if !(_e199) {
+        let _e201 = geometric;
+        geometric = -(_e201);
+    }
+    let _e203 = geometric;
+    param_2 = _e203;
+    let _e204 = EncodeOctahedral_u0028_vf3_u003b((&param_2));
+    let _e205 = (*roughness);
+    let _e207 = ViewDepth_u0028_();
+    frag_surface = vec4<f32>(_e204.x, _e204.y, clamp(_e205, 0f, 1f), _e207);
     return;
 }
 
 fn Orthographic_u0028_() -> bool {
-    let _e180 = fog_info.projection[0u];
-    return (_e180 > 0.5f);
+    let _e181 = fog_info.projection[0u];
+    return (_e181 > 0.5f);
 }
 
 fn EyeDistance_u0028_() -> f32 {
     var local_1: f32;
 
-    let _e179 = Orthographic_u0028_();
-    if _e179 {
-        let _e180 = ViewDepth_u0028_();
-        local_1 = max(_e180, 0f);
+    let _e180 = Orthographic_u0028_();
+    if _e180 {
+        let _e181 = ViewDepth_u0028_();
+        local_1 = max(_e181, 0f);
     } else {
-        let _e182 = v_world_position_1;
-        let _e184 = fog_info.eye;
-        local_1 = distance(_e182, _e184.xyz);
+        let _e183 = v_world_position_1;
+        let _e185 = fog_info.eye;
+        local_1 = distance(_e183, _e185.xyz);
     }
-    let _e187 = local_1;
-    return _e187;
+    let _e188 = local_1;
+    return _e188;
 }
 
 fn ApplyFog_u0028_vf3_u003b(color: ptr<function, vec3<f32>>) -> vec3<f32> {
@@ -46358,41 +46547,41 @@ fn ApplyFog_u0028_vf3_u003b(color: ptr<function, vec3<f32>>) -> vec3<f32> {
     var k: f32;
     var local_2: f32;
 
-    let _e186 = fog_info.fog[3u];
-    density = _e186;
-    let _e187 = density;
-    if (_e187 <= 0f) {
-        let _e189 = (*color);
-        return _e189;
-    }
-    let _e190 = EyeDistance_u0028_();
-    d = _e190;
-    let _e193 = fog_info.eye[3u];
-    falloff = _e193;
-    let _e194 = falloff;
-    if (_e194 > 0f) {
-        let _e196 = falloff;
-        let _e198 = v_world_position_1[1u];
-        let _e201 = fog_info.eye[1u];
-        k = (_e196 * (_e198 - _e201));
-        let _e204 = k;
-        if (abs(_e204) > 0.001f) {
-            let _e207 = k;
-            let _e211 = k;
-            local_2 = ((1f - exp(-(_e207))) / _e211);
+    let _e187 = fog_info.fog[3u];
+    density = _e187;
+    let _e188 = density;
+    if (_e188 <= 0f) {
+        let _e190 = (*color);
+        return _e190;
+    }
+    let _e191 = EyeDistance_u0028_();
+    d = _e191;
+    let _e194 = fog_info.eye[3u];
+    falloff = _e194;
+    let _e195 = falloff;
+    if (_e195 > 0f) {
+        let _e197 = falloff;
+        let _e199 = v_world_position_1[1u];
+        let _e202 = fog_info.eye[1u];
+        k = (_e197 * (_e199 - _e202));
+        let _e205 = k;
+        if (abs(_e205) > 0.001f) {
+            let _e208 = k;
+            let _e212 = k;
+            local_2 = ((1f - exp(-(_e208))) / _e212);
         } else {
-            let _e213 = k;
-            local_2 = (1f - (0.5f * _e213));
+            let _e214 = k;
+            local_2 = (1f - (0.5f * _e214));
         }
-        let _e216 = local_2;
-        let _e217 = density;
-        density = (_e217 * _e216);
+        let _e217 = local_2;
+        let _e218 = density;
+        density = (_e218 * _e217);
     }
-    let _e220 = fog_info.fog;
-    let _e222 = (*color);
-    let _e223 = density;
-    let _e225 = d;
-    return mix(_e220.xyz, _e222, vec3(clamp(exp((-(_e223) * _e225)), 0f, 1f)));
+    let _e221 = fog_info.fog;
+    let _e223 = (*color);
+    let _e224 = density;
+    let _e226 = d;
+    return mix(_e221.xyz, _e223, vec3(clamp(exp((-(_e224) * _e226)), 0f, 1f)));
 }
 
 fn WriteSurface_u0028_vf3_u003b_f1_u003b_f1_u003b(linearColor: ptr<function, vec3<f32>>, alpha_2: ptr<function, f32>, roughness_1: ptr<function, f32>) {
@@ -46400,44 +46589,44 @@ fn WriteSurface_u0028_vf3_u003b_f1_u003b_f1_u003b(linearColor: ptr<function, vec
     var param_3: vec3<f32>;
     var param_4: f32;
 
-    let _e184 = g_premultiply;
-    let _e185 = (*alpha_2);
-    weight_1 = select(1f, _e185, _e184);
-    let _e187 = (*linearColor);
-    param_3 = _e187;
-    let _e188 = ApplyFog_u0028_vf3_u003b((&param_3));
-    let _e189 = weight_1;
-    let _e190 = (_e188 * _e189);
-    let _e191 = (*alpha_2);
-    let _e192 = g_pass_through;
-    frag_color = vec4<f32>(_e190.x, _e190.y, _e190.z, (_e191 * (1f - _e192)));
-    let _e199 = (*roughness_1);
-    param_4 = _e199;
+    let _e185 = g_premultiply;
+    let _e186 = (*alpha_2);
+    weight_1 = select(1f, _e186, _e185);
+    let _e188 = (*linearColor);
+    param_3 = _e188;
+    let _e189 = ApplyFog_u0028_vf3_u003b((&param_3));
+    let _e190 = weight_1;
+    let _e191 = (_e189 * _e190);
+    let _e192 = (*alpha_2);
+    let _e193 = g_pass_through;
+    frag_color = vec4<f32>(_e191.x, _e191.y, _e191.z, (_e192 * (1f - _e193)));
+    let _e200 = (*roughness_1);
+    param_4 = _e200;
     WriteSurfaceGeometry_u0028_f1_u003b((&param_4));
     WriteWeightedBlended_u0028_();
     return;
 }
 
 fn SrgbToLinear_u0028_vf3_u003b(srgb: ptr<function, vec3<f32>>) -> vec3<f32> {
-    let _e179 = (*srgb);
-    let _e182 = (*srgb);
-    let _e187 = (*srgb);
-    return mix((_e179 / vec3(12.92f)), pow(((_e182 + vec3<f32>(0.055f, 0.055f, 0.055f)) / vec3(1.055f)), vec3<f32>(2.4f, 2.4f, 2.4f)), step(vec3<f32>(0.04045f, 0.04045f, 0.04045f), _e187));
+    let _e180 = (*srgb);
+    let _e183 = (*srgb);
+    let _e188 = (*srgb);
+    return mix((_e180 / vec3(12.92f)), pow(((_e183 + vec3<f32>(0.055f, 0.055f, 0.055f)) / vec3(1.055f)), vec3<f32>(2.4f, 2.4f, 2.4f)), step(vec3<f32>(0.04045f, 0.04045f, 0.04045f), _e188));
 }
 
 fn NonFinite_u0028_vf3_u003b(c: ptr<function, vec3<f32>>) -> bool {
     var phi_2753_: bool;
 
-    let _e179 = (*c);
     let _e180 = (*c);
-    let _e182 = any((_e179 != _e180));
-    phi_2753_ = _e182;
-    if !(_e182) {
-        let _e184 = (*c);
-        phi_2753_ = any((abs(_e184) > vec3<f32>(300000000000000000000000000000000000000f, 300000000000000000000000000000000000000f, 300000000000000000000000000000000000000f)));
-    }
-    let _e189 = phi_2753_;
-    return _e189;
+    let _e181 = (*c);
+    let _e183 = any((_e180 != _e181));
+    phi_2753_ = _e183;
+    if !(_e183) {
+        let _e185 = (*c);
+        phi_2753_ = any((abs(_e185) > vec3<f32>(300000000000000000000000000000000000000f, 300000000000000000000000000000000000000f, 300000000000000000000000000000000000000f)));
+    }
+    let _e190 = phi_2753_;
+    return _e190;
 }
 
 fn WriteDebugView_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_vf3_u003b(s: ptr<function, Surface>, lit: ptr<function, vec3<f32>>) -> bool {
@@ -46455,78 +46644,78 @@ fn WriteDebugView_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_
     var param_9: vec3<f32>;
     var param_10: f32;
 
-    let _e195 = frag_info.debug_view[0u];
-    view = _e195;
-    let _e196 = view;
-    if (_e196 < 0.5f) {
+    let _e196 = frag_info.debug_view[0u];
+    view = _e196;
+    let _e197 = view;
+    if (_e197 < 0.5f) {
         return false;
     }
-    let _e199 = gl_FragCoord_1[0u];
-    let _e202 = frag_info.debug_view[1u];
-    let _e205 = frag_info.debug_view[2u];
-    if (_e199 < (_e202 * _e205)) {
+    let _e200 = gl_FragCoord_1[0u];
+    let _e203 = frag_info.debug_view[1u];
+    let _e206 = frag_info.debug_view[2u];
+    if (_e200 < (_e203 * _e206)) {
         return false;
     }
-    let _e208 = view;
-    code = i32((_e208 + 0.5f));
+    let _e209 = view;
+    code = i32((_e209 + 0.5f));
     shown = vec3<f32>(0f, 0f, 0f);
-    let _e211 = code;
-    if (_e211 == 1i) {
-        let _e214 = (*s).albedo;
-        param_5 = clamp(_e214, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
-        let _e216 = LinearToSrgb_u0028_vf3_u003b((&param_5));
-        shown = _e216;
-    } else {
-        let _e217 = code;
-        if (_e217 == 2i) {
-            let _e220 = (*s).n;
-            shown = ((_e220 * 0.5f) + vec3<f32>(0.5f, 0.5f, 0.5f));
+    let _e212 = code;
+    if (_e212 == 1i) {
+        let _e215 = (*s).albedo;
+        param_5 = clamp(_e215, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
+        let _e217 = LinearToSrgb_u0028_vf3_u003b((&param_5));
+        shown = _e217;
+    } else {
+        let _e218 = code;
+        if (_e218 == 2i) {
+            let _e221 = (*s).n;
+            shown = ((_e221 * 0.5f) + vec3<f32>(0.5f, 0.5f, 0.5f));
         } else {
-            let _e223 = code;
-            if (_e223 == 3i) {
-                let _e226 = (*s).roughness;
-                shown = vec3(clamp(_e226, 0f, 1f));
+            let _e224 = code;
+            if (_e224 == 3i) {
+                let _e227 = (*s).roughness;
+                shown = vec3(clamp(_e227, 0f, 1f));
             } else {
-                let _e229 = code;
-                if (_e229 == 4i) {
-                    let _e232 = (*s).metallic;
-                    shown = vec3(clamp(_e232, 0f, 1f));
+                let _e230 = code;
+                if (_e230 == 4i) {
+                    let _e233 = (*s).metallic;
+                    shown = vec3(clamp(_e233, 0f, 1f));
                 } else {
-                    let _e235 = code;
-                    if (_e235 == 5i) {
-                        let _e238 = (*s).occlusion;
-                        shown = vec3(clamp(_e238, 0f, 1f));
+                    let _e236 = code;
+                    if (_e236 == 5i) {
+                        let _e239 = (*s).occlusion;
+                        shown = vec3(clamp(_e239, 0f, 1f));
                     } else {
-                        let _e241 = code;
-                        if (_e241 == 6i) {
-                            let _e244 = (*s).emissive;
-                            param_6 = clamp(_e244, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
-                            let _e246 = LinearToSrgb_u0028_vf3_u003b((&param_6));
-                            shown = _e246;
+                        let _e242 = code;
+                        if (_e242 == 6i) {
+                            let _e245 = (*s).emissive;
+                            param_6 = clamp(_e245, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
+                            let _e247 = LinearToSrgb_u0028_vf3_u003b((&param_6));
+                            shown = _e247;
                         } else {
-                            let _e247 = code;
-                            if (_e247 == 7i) {
-                                let _e249 = v_texcoord_1;
-                                let _e250 = fract(_e249);
-                                shown = vec3<f32>(_e250.x, _e250.y, 0f);
+                            let _e248 = code;
+                            if (_e248 == 7i) {
+                                let _e250 = v_texcoord_1;
+                                let _e251 = fract(_e250);
+                                shown = vec3<f32>(_e251.x, _e251.y, 0f);
                             } else {
-                                let _e254 = code;
-                                if (_e254 == 8i) {
-                                    let _e256 = (*lit);
-                                    param_7 = clamp(_e256, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
-                                    let _e258 = LinearToSrgb_u0028_vf3_u003b((&param_7));
-                                    grey = dot(_e258, vec3<f32>(0.2126f, 0.7152f, 0.0722f));
-                                    let _e260 = (*lit);
-                                    param_8 = _e260;
-                                    let _e261 = NonFinite_u0028_vf3_u003b((&param_8));
-                                    if _e261 {
+                                let _e255 = code;
+                                if (_e255 == 8i) {
+                                    let _e257 = (*lit);
+                                    param_7 = clamp(_e257, vec3<f32>(0f, 0f, 0f), vec3<f32>(1f, 1f, 1f));
+                                    let _e259 = LinearToSrgb_u0028_vf3_u003b((&param_7));
+                                    grey = dot(_e259, vec3<f32>(0.2126f, 0.7152f, 0.0722f));
+                                    let _e261 = (*lit);
+                                    param_8 = _e261;
+                                    let _e262 = NonFinite_u0028_vf3_u003b((&param_8));
+                                    if _e262 {
                                         local_3 = vec3<f32>(1f, 0f, 1f);
                                     } else {
-                                        let _e262 = grey;
-                                        local_3 = vec3((_e262 * 0.5f));
+                                        let _e263 = grey;
+                                        local_3 = vec3((_e263 * 0.5f));
                                     }
-                                    let _e265 = local_3;
-                                    shown = _e265;
+                                    let _e266 = local_3;
+                                    shown = _e266;
                                 }
                             }
                         }
@@ -46535,61 +46724,61 @@ fn WriteDebugView_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_
             }
         }
     }
-    let _e266 = g_premultiply;
-    if _e266 {
-        let _e268 = (*s).alpha;
-        local_4 = _e268;
+    let _e267 = g_premultiply;
+    if _e267 {
+        let _e269 = (*s).alpha;
+        local_4 = _e269;
     } else {
         local_4 = 1f;
     }
-    let _e269 = local_4;
-    weight_2 = _e269;
-    let _e270 = shown;
-    param_9 = _e270;
-    let _e271 = SrgbToLinear_u0028_vf3_u003b((&param_9));
-    let _e272 = weight_2;
-    let _e273 = (_e271 * _e272);
-    let _e275 = (*s).alpha;
-    frag_color = vec4<f32>(_e273.x, _e273.y, _e273.z, _e275);
-    let _e281 = (*s).roughness;
-    param_10 = _e281;
+    let _e270 = local_4;
+    weight_2 = _e270;
+    let _e271 = shown;
+    param_9 = _e271;
+    let _e272 = SrgbToLinear_u0028_vf3_u003b((&param_9));
+    let _e273 = weight_2;
+    let _e274 = (_e272 * _e273);
+    let _e276 = (*s).alpha;
+    frag_color = vec4<f32>(_e274.x, _e274.y, _e274.z, _e276);
+    let _e282 = (*s).roughness;
+    param_10 = _e282;
     WriteSurfaceGeometry_u0028_f1_u003b((&param_10));
     WriteWeightedBlended_u0028_();
     return true;
 }
 
 fn ShadeLight_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b(s_1: ptr<function, Surface>, light: ptr<function, LightSample>) -> vec3<f32> {
-    let _e181 = (*s_1).albedo;
-    return _e181;
+    let _e182 = (*s_1).albedo;
+    return _e182;
 }
 
 fn PointShadowDiskTap_u0028_i1_u003b(i: ptr<function, i32>) -> vec2<f32> {
-    let _e179 = (*i);
-    if (_e179 == 0i) {
+    let _e180 = (*i);
+    if (_e180 == 0i) {
         return vec2<f32>(-0.94201624f, -0.39906216f);
     }
-    let _e181 = (*i);
-    if (_e181 == 1i) {
+    let _e182 = (*i);
+    if (_e182 == 1i) {
         return vec2<f32>(0.9455861f, -0.76890725f);
     }
-    let _e183 = (*i);
-    if (_e183 == 2i) {
+    let _e184 = (*i);
+    if (_e184 == 2i) {
         return vec2<f32>(-0.0941841f, -0.9293887f);
     }
-    let _e185 = (*i);
-    if (_e185 == 3i) {
+    let _e186 = (*i);
+    if (_e186 == 3i) {
         return vec2<f32>(0.34495938f, 0.2938776f);
     }
-    let _e187 = (*i);
-    if (_e187 == 4i) {
+    let _e188 = (*i);
+    if (_e188 == 4i) {
         return vec2<f32>(-0.9158858f, 0.45771432f);
     }
-    let _e189 = (*i);
-    if (_e189 == 5i) {
+    let _e190 = (*i);
+    if (_e190 == 5i) {
         return vec2<f32>(-0.8154423f, -0.87912464f);
     }
-    let _e191 = (*i);
-    if (_e191 == 6i) {
+    let _e192 = (*i);
+    if (_e192 == 6i) {
         return vec2<f32>(-0.38277543f, 0.27676845f);
     }
     return vec2<f32>(0.974844f, 0.7564838f);
@@ -46599,20 +46788,20 @@ fn PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b(i_1: ptr<function
     var p: vec2<f32>;
     var param_11: i32;
 
-    let _e184 = (*i_1);
-    param_11 = _e184;
-    let _e185 = PointShadowDiskTap_u0028_i1_u003b((&param_11));
-    p = _e185;
-    let _e187 = p[0u];
-    let _e188 = (*ca);
-    let _e191 = p[1u];
-    let _e192 = (*sa);
-    let _e196 = p[0u];
-    let _e197 = (*sa);
-    let _e200 = p[1u];
-    let _e201 = (*ca);
-    let _e205 = (*radius);
-    return (vec2<f32>(((_e187 * _e188) - (_e191 * _e192)), ((_e196 * _e197) + (_e200 * _e201))) * _e205);
+    let _e185 = (*i_1);
+    param_11 = _e185;
+    let _e186 = PointShadowDiskTap_u0028_i1_u003b((&param_11));
+    p = _e186;
+    let _e188 = p[0u];
+    let _e189 = (*ca);
+    let _e192 = p[1u];
+    let _e193 = (*sa);
+    let _e197 = p[0u];
+    let _e198 = (*sa);
+    let _e201 = p[1u];
+    let _e202 = (*ca);
+    let _e206 = (*radius);
+    return (vec2<f32>(((_e188 * _e189) - (_e192 * _e193)), ((_e197 * _e198) + (_e201 * _e202))) * _e206);
 }
 
 fn PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b(uv: ptr<function, vec2<f32>>, offset: ptr<function, vec2<f32>>, tile: ptr<function, vec2<f32>>, range: ptr<function, f32>) -> f32 {
@@ -46620,27 +46809,27 @@ fn PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b(uv: ptr<func
     var local_5: vec2<f32>;
     var atlas: vec2<f32>;
 
-    let _e187 = point_shadow.params[0u];
-    inset = _e187;
-    let _e188 = (*uv);
-    let _e189 = (*offset);
-    let _e191 = inset;
+    let _e188 = point_shadow.params[0u];
+    inset = _e188;
+    let _e189 = (*uv);
+    let _e190 = (*offset);
     let _e192 = inset;
-    local_5 = clamp((_e188 + _e189), vec2(_e191), vec2((1f - _e192)));
-    let _e197 = local_5;
-    let _e198 = (*tile);
-    atlas = ((_e197 + _e198) * vec2<f32>(0.16666667f, 0.16666667f));
-    let _e203 = point_shadow.params3_[0u];
-    if (_e203 > 0.5f) {
-        let _e206 = atlas[1u];
-        atlas[1u] = (1f - _e206);
-    }
-    let _e209 = atlas;
-    let _e210 = textureSampleLevel(point_shadow_texture_tex, point_shadow_texture_smp, _e209, 0f);
-    let _e212 = atlas;
-    let _e213 = textureSampleLevel(point_shadow_static_texture_tex, point_shadow_static_texture_smp, _e212, 0f);
-    let _e216 = (*range);
-    return (min(_e210.x, _e213.x) * _e216);
+    let _e193 = inset;
+    local_5 = clamp((_e189 + _e190), vec2(_e192), vec2((1f - _e193)));
+    let _e198 = local_5;
+    let _e199 = (*tile);
+    atlas = ((_e198 + _e199) * vec2<f32>(0.16666667f, 0.16666667f));
+    let _e204 = point_shadow.params3_[0u];
+    if (_e204 > 0.5f) {
+        let _e207 = atlas[1u];
+        atlas[1u] = (1f - _e207);
+    }
+    let _e210 = atlas;
+    let _e211 = textureSampleLevel(point_shadow_texture_tex, point_shadow_texture_smp, _e210, 0f);
+    let _e213 = atlas;
+    let _e214 = textureSampleLevel(point_shadow_static_texture_tex, point_shadow_static_texture_smp, _e213, 0f);
+    let _e217 = (*range);
+    return (min(_e211.x, _e214.x) * _e217);
 }
 
 fn PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b(uv_1: ptr<function, vec2<f32>>, offset_1: ptr<function, vec2<f32>>, tile_1: ptr<function, vec2<f32>>, range_1: ptr<function, f32>, receiver: ptr<function, f32>) -> f32 {
@@ -46650,24 +46839,24 @@ fn PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b(uv_1: pt
     var param_14: vec2<f32>;
     var param_15: f32;
 
-    let _e188 = (*uv_1);
-    param_12 = _e188;
-    let _e189 = (*offset_1);
-    param_13 = _e189;
-    let _e190 = (*tile_1);
-    param_14 = _e190;
-    let _e191 = (*range_1);
-    param_15 = _e191;
-    let _e192 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((&param_12), (&param_13), (&param_14), (&param_15));
-    stored = _e192;
-    let _e193 = stored;
-    let _e194 = (*range_1);
-    if (_e193 >= (_e194 * 0.999f)) {
+    let _e189 = (*uv_1);
+    param_12 = _e189;
+    let _e190 = (*offset_1);
+    param_13 = _e190;
+    let _e191 = (*tile_1);
+    param_14 = _e191;
+    let _e192 = (*range_1);
+    param_15 = _e192;
+    let _e193 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((&param_12), (&param_13), (&param_14), (&param_15));
+    stored = _e193;
+    let _e194 = stored;
+    let _e195 = (*range_1);
+    if (_e194 >= (_e195 * 0.999f)) {
         return 1f;
     }
-    let _e197 = (*receiver);
-    let _e198 = stored;
-    return select(1f, 0f, (_e197 > _e198));
+    let _e198 = (*receiver);
+    let _e199 = stored;
+    return select(1f, 0f, (_e198 > _e199));
 }
 
 fn PointShadowPenumbra_u0028_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b(uv_2: ptr<function, vec2<f32>>, tile_2: ptr<function, vec2<f32>>, range_2: ptr<function, f32>, receiver_1: ptr<function, f32>, ca_1: ptr<function, f32>, sa_1: ptr<function, f32>, tanHalf: ptr<function, f32>, blockerOut: ptr<function, f32>) -> f32 {
@@ -46694,111 +46883,111 @@ fn PointShadowPenumbra_u0028_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u
     var world: f32;
 
     (*blockerOut) = -1f;
-    let _e209 = point_shadow.params2_[1u];
-    lightRadius = _e209;
-    let _e212 = point_shadow.params2_[0u];
-    minRadius = _e212;
-    let _e215 = point_shadow.params2_[2u];
-    maxRadius = _e215;
-    let _e216 = lightRadius;
-    if (_e216 <= 0f) {
-        let _e218 = (*uv_2);
-        param_16 = _e218;
+    let _e210 = point_shadow.params2_[1u];
+    lightRadius = _e210;
+    let _e213 = point_shadow.params2_[0u];
+    minRadius = _e213;
+    let _e216 = point_shadow.params2_[2u];
+    maxRadius = _e216;
+    let _e217 = lightRadius;
+    if (_e217 <= 0f) {
+        let _e219 = (*uv_2);
+        param_16 = _e219;
         param_17 = vec2<f32>(0f, 0f);
-        let _e219 = (*tile_2);
-        param_18 = _e219;
-        let _e220 = (*range_2);
-        param_19 = _e220;
-        let _e221 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((&param_16), (&param_17), (&param_18), (&param_19));
-        (*blockerOut) = _e221;
-        let _e222 = minRadius;
-        return _e222;
+        let _e220 = (*tile_2);
+        param_18 = _e220;
+        let _e221 = (*range_2);
+        param_19 = _e221;
+        let _e222 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((&param_16), (&param_17), (&param_18), (&param_19));
+        (*blockerOut) = _e222;
+        let _e223 = minRadius;
+        return _e223;
     }
     sum = 0f;
     count = 0f;
     i_2 = 0i;
     loop {
-        let _e223 = i_2;
-        if (_e223 < 8i) {
-            let _e225 = i_2;
-            param_20 = _e225;
-            let _e226 = (*ca_1);
-            param_21 = _e226;
-            let _e227 = (*sa_1);
-            param_22 = _e227;
-            let _e228 = maxRadius;
-            param_23 = _e228;
-            let _e229 = PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b((&param_20), (&param_21), (&param_22), (&param_23));
-            let _e230 = (*uv_2);
-            param_24 = _e230;
-            param_25 = _e229;
-            let _e231 = (*tile_2);
-            param_26 = _e231;
-            let _e232 = (*range_2);
-            param_27 = _e232;
-            let _e233 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((&param_24), (&param_25), (&param_26), (&param_27));
-            stored_1 = _e233;
-            let _e234 = stored_1;
-            let _e235 = (*range_2);
-            if (_e234 >= (_e235 * 0.999f)) {
+        let _e224 = i_2;
+        if (_e224 < 8i) {
+            let _e226 = i_2;
+            param_20 = _e226;
+            let _e227 = (*ca_1);
+            param_21 = _e227;
+            let _e228 = (*sa_1);
+            param_22 = _e228;
+            let _e229 = maxRadius;
+            param_23 = _e229;
+            let _e230 = PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b((&param_20), (&param_21), (&param_22), (&param_23));
+            let _e231 = (*uv_2);
+            param_24 = _e231;
+            param_25 = _e230;
+            let _e232 = (*tile_2);
+            param_26 = _e232;
+            let _e233 = (*range_2);
+            param_27 = _e233;
+            let _e234 = PointShadowDistance_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b((&param_24), (&param_25), (&param_26), (&param_27));
+            stored_1 = _e234;
+            let _e235 = stored_1;
+            let _e236 = (*range_2);
+            if (_e235 >= (_e236 * 0.999f)) {
                 continue;
             }
-            let _e238 = stored_1;
-            let _e239 = (*receiver_1);
-            if (_e238 >= _e239) {
+            let _e239 = stored_1;
+            let _e240 = (*receiver_1);
+            if (_e239 >= _e240) {
                 continue;
             }
-            let _e241 = stored_1;
-            let _e242 = sum;
-            sum = (_e242 + _e241);
-            let _e244 = count;
-            count = (_e244 + 1f);
+            let _e242 = stored_1;
+            let _e243 = sum;
+            sum = (_e243 + _e242);
+            let _e245 = count;
+            count = (_e245 + 1f);
             continue;
         } else {
             break;
         }
         continuing {
-            let _e246 = i_2;
-            i_2 = (_e246 + 1i);
+            let _e247 = i_2;
+            i_2 = (_e247 + 1i);
         }
     }
-    let _e248 = count;
-    if (_e248 < 0.5f) {
+    let _e249 = count;
+    if (_e249 < 0.5f) {
         return -1f;
     }
-    let _e250 = sum;
-    let _e251 = count;
-    blocker = max((_e250 / _e251), 0.0001f);
-    let _e254 = blocker;
-    (*blockerOut) = _e254;
-    let _e255 = lightRadius;
-    let _e256 = (*receiver_1);
-    let _e257 = blocker;
-    let _e261 = blocker;
-    world = ((_e255 * max((_e256 - _e257), 0f)) / _e261);
-    let _e263 = world;
-    let _e264 = (*receiver_1);
-    let _e266 = (*tanHalf);
-    let _e269 = minRadius;
-    let _e270 = maxRadius;
-    return clamp((_e263 / ((2f * _e264) * _e266)), _e269, _e270);
+    let _e251 = sum;
+    let _e252 = count;
+    blocker = max((_e251 / _e252), 0.0001f);
+    let _e255 = blocker;
+    (*blockerOut) = _e255;
+    let _e256 = lightRadius;
+    let _e257 = (*receiver_1);
+    let _e258 = blocker;
+    let _e262 = blocker;
+    world = ((_e256 * max((_e257 - _e258), 0f)) / _e262);
+    let _e264 = world;
+    let _e265 = (*receiver_1);
+    let _e267 = (*tanHalf);
+    let _e270 = minRadius;
+    let _e271 = maxRadius;
+    return clamp((_e264 / ((2f * _e265) * _e267)), _e270, _e271);
 }
 
 fn FragCoordFromTop_u0028_f1_u003b(rows: ptr<function, f32>) -> vec2<f32> {
     var local_6: vec2<f32>;
 
-    let _e180 = (*rows);
-    if (_e180 > 0f) {
-        let _e183 = gl_FragCoord_1[0u];
-        let _e184 = (*rows);
-        let _e186 = gl_FragCoord_1[1u];
-        local_6 = vec2<f32>(_e183, (_e184 - _e186));
+    let _e181 = (*rows);
+    if (_e181 > 0f) {
+        let _e184 = gl_FragCoord_1[0u];
+        let _e185 = (*rows);
+        let _e187 = gl_FragCoord_1[1u];
+        local_6 = vec2<f32>(_e184, (_e185 - _e187));
     } else {
-        let _e189 = gl_FragCoord_1;
-        local_6 = _e189.xy;
+        let _e190 = gl_FragCoord_1;
+        local_6 = _e190.xy;
     }
-    let _e191 = local_6;
-    return _e191;
+    let _e192 = local_6;
+    return _e192;
 }
 
 fn PointShadowFactor_u0028_vf3_u003b_vf3_u003b_i1_u003b(world_1: ptr<function, vec3<f32>>, normal: ptr<function, vec3<f32>>, lightIndex: ptr<function, i32>) -> f32 {
@@ -46856,257 +47045,257 @@ fn PointShadowFactor_u0028_vf3_u003b_vf3_u003b_i1_u003b(world_1: ptr<function, v
     var phi_2440_: bool;
     var phi_2501_: bool;
 
-    let _e232 = (*lightIndex);
-    let _e236 = point_shadow.slots[_e232][0u];
-    slot = i32((_e236 + 0.5f));
-    let _e239 = (*lightIndex);
-    let _e243 = point_shadow.slots[_e239][0u];
-    if (_e243 < 0f) {
+    let _e233 = (*lightIndex);
+    let _e237 = point_shadow.slots[_e233][0u];
+    slot = i32((_e237 + 0.5f));
+    let _e240 = (*lightIndex);
+    let _e244 = point_shadow.slots[_e240][0u];
+    if (_e244 < 0f) {
         return 1f;
     }
-    let _e247 = point_shadow.params[2u];
-    strength = _e247;
-    let _e248 = strength;
-    if (_e248 <= 0f) {
+    let _e248 = point_shadow.params[2u];
+    strength = _e248;
+    let _e249 = strength;
+    if (_e249 <= 0f) {
         return 1f;
     }
-    let _e250 = slot;
-    let _e253 = point_shadow.lights[_e250];
-    let _e255 = (*world_1);
-    toLight = (_e253.xyz - _e255);
-    let _e257 = toLight;
-    toLightLength = max(length(_e257), 0.000001f);
-    let _e260 = (*normal);
-    let _e261 = toLight;
-    let _e262 = toLightLength;
-    nDotL = max(dot(_e260, (_e261 / vec3(_e262))), 0.15f);
-    let _e267 = nDotL;
+    let _e251 = slot;
+    let _e254 = point_shadow.lights[_e251];
+    let _e256 = (*world_1);
+    toLight = (_e254.xyz - _e256);
+    let _e258 = toLight;
+    toLightLength = max(length(_e258), 0.000001f);
+    let _e261 = (*normal);
+    let _e262 = toLight;
+    let _e263 = toLightLength;
+    nDotL = max(dot(_e261, (_e262 / vec3(_e263))), 0.15f);
     let _e268 = nDotL;
-    let _e273 = nDotL;
+    let _e269 = nDotL;
     let _e274 = nDotL;
-    slope = min((sqrt(max((1f - (_e267 * _e268)), 0f)) / (_e273 * _e274)), 8f);
-    let _e278 = toLightLength;
-    let _e280 = (*lightIndex);
-    let _e284 = point_shadow.slots[_e280][2u];
-    let _e289 = point_shadow.params3_[1u];
-    texel = (((2f * _e278) * max(_e284, 0.0001f)) * _e289);
-    let _e291 = (*world_1);
-    let _e292 = (*normal);
-    let _e293 = texel;
-    let _e297 = point_shadow.params[3u];
-    let _e299 = slope;
-    origin = (_e291 + (((_e292 * _e293) * _e297) * (1f + _e299)));
-    let _e303 = origin;
-    let _e304 = slot;
-    let _e307 = point_shadow.lights[_e304];
-    toFragment = (_e303 - _e307.xyz);
-    let _e310 = toFragment;
-    distance_ = length(_e310);
-    let _e312 = slot;
-    let _e316 = point_shadow.lights[_e312][3u];
-    range_3 = max(_e316, 0.0001f);
-    let _e318 = distance_;
-    let _e319 = range_3;
-    if (_e318 >= _e319) {
+    let _e275 = nDotL;
+    slope = min((sqrt(max((1f - (_e268 * _e269)), 0f)) / (_e274 * _e275)), 8f);
+    let _e279 = toLightLength;
+    let _e281 = (*lightIndex);
+    let _e285 = point_shadow.slots[_e281][2u];
+    let _e290 = point_shadow.params3_[1u];
+    texel = (((2f * _e279) * max(_e285, 0.0001f)) * _e290);
+    let _e292 = (*world_1);
+    let _e293 = (*normal);
+    let _e294 = texel;
+    let _e298 = point_shadow.params[3u];
+    let _e300 = slope;
+    origin = (_e292 + (((_e293 * _e294) * _e298) * (1f + _e300)));
+    let _e304 = origin;
+    let _e305 = slot;
+    let _e308 = point_shadow.lights[_e305];
+    toFragment = (_e304 - _e308.xyz);
+    let _e311 = toFragment;
+    distance_ = length(_e311);
+    let _e313 = slot;
+    let _e317 = point_shadow.lights[_e313][3u];
+    range_3 = max(_e317, 0.0001f);
+    let _e319 = distance_;
+    let _e320 = range_3;
+    if (_e319 >= _e320) {
         return 1f;
     }
     face = 0i;
-    let _e321 = (*lightIndex);
-    let _e325 = point_shadow.slots[_e321][1u];
-    if (_e325 < 0.5f) {
-        let _e327 = toFragment;
-        a = abs(_e327);
-        let _e330 = a[0u];
-        let _e332 = a[1u];
-        let _e333 = (_e330 >= _e332);
-        phi_2440_ = _e333;
-        if _e333 {
-            let _e335 = a[0u];
-            let _e337 = a[2u];
-            phi_2440_ = (_e335 >= _e337);
-        }
-        let _e340 = phi_2440_;
-        if _e340 {
-            let _e342 = toFragment[0u];
-            face = select(1i, 0i, (_e342 > 0f));
+    let _e322 = (*lightIndex);
+    let _e326 = point_shadow.slots[_e322][1u];
+    if (_e326 < 0.5f) {
+        let _e328 = toFragment;
+        a = abs(_e328);
+        let _e331 = a[0u];
+        let _e333 = a[1u];
+        let _e334 = (_e331 >= _e333);
+        phi_2440_ = _e334;
+        if _e334 {
+            let _e336 = a[0u];
+            let _e338 = a[2u];
+            phi_2440_ = (_e336 >= _e338);
+        }
+        let _e341 = phi_2440_;
+        if _e341 {
+            let _e343 = toFragment[0u];
+            face = select(1i, 0i, (_e343 > 0f));
         } else {
-            let _e346 = a[1u];
-            let _e348 = a[2u];
-            if (_e346 >= _e348) {
-                let _e351 = toFragment[1u];
-                face = select(3i, 2i, (_e351 > 0f));
+            let _e347 = a[1u];
+            let _e349 = a[2u];
+            if (_e347 >= _e349) {
+                let _e352 = toFragment[1u];
+                face = select(3i, 2i, (_e352 > 0f));
             } else {
-                let _e355 = toFragment[2u];
-                face = select(5i, 4i, (_e355 > 0f));
+                let _e356 = toFragment[2u];
+                face = select(5i, 4i, (_e356 > 0f));
             }
         }
     }
-    let _e358 = slot;
-    let _e360 = face;
-    let _e364 = point_shadow.faces[((_e358 * 6i) + _e360)];
-    let _e365 = origin;
-    clip = (_e364 * vec4<f32>(_e365.x, _e365.y, _e365.z, 1f));
-    let _e372 = clip[3u];
-    if (_e372 <= 0f) {
+    let _e359 = slot;
+    let _e361 = face;
+    let _e365 = point_shadow.faces[((_e359 * 6i) + _e361)];
+    let _e366 = origin;
+    clip = (_e365 * vec4<f32>(_e366.x, _e366.y, _e366.z, 1f));
+    let _e373 = clip[3u];
+    if (_e373 <= 0f) {
         return 1f;
     }
-    let _e374 = clip;
-    let _e377 = clip[3u];
-    ndc = (_e374.xy / vec2(_e377));
-    let _e381 = ndc[0u];
-    let _e383 = (abs(_e381) > 1f);
-    phi_2501_ = _e383;
-    if !(_e383) {
-        let _e386 = ndc[1u];
-        phi_2501_ = (abs(_e386) > 1f);
-    }
-    let _e390 = phi_2501_;
-    if _e390 {
+    let _e375 = clip;
+    let _e378 = clip[3u];
+    ndc = (_e375.xy / vec2(_e378));
+    let _e382 = ndc[0u];
+    let _e384 = (abs(_e382) > 1f);
+    phi_2501_ = _e384;
+    if !(_e384) {
+        let _e387 = ndc[1u];
+        phi_2501_ = (abs(_e387) > 1f);
+    }
+    let _e391 = phi_2501_;
+    if _e391 {
         return 1f;
     }
-    let _e392 = ndc[0u];
-    let _e396 = ndc[1u];
-    uv_3 = vec2<f32>(((_e392 * 0.5f) + 0.5f), (0.5f - (_e396 * 0.5f)));
-    let _e400 = face;
-    let _e402 = slot;
-    tile_3 = vec2<f32>(f32(_e400), f32(_e402));
-    let _e405 = distance_;
-    let _e408 = point_shadow.params[1u];
-    receiver_2 = (_e405 - _e408);
-    let _e412 = frag_info.target_origin[0u];
-    param_28 = _e412;
-    let _e413 = FragCoordFromTop_u0028_f1_u003b((&param_28));
-    noise = fract((52.982918f * fract(dot(_e413, vec2<f32>(0.06711056f, 0.00583715f)))));
-    let _e418 = noise;
-    angle = (_e418 * 6.2831855f);
-    let _e420 = angle;
-    ca_2 = cos(_e420);
-    let _e422 = angle;
-    sa_2 = sin(_e422);
-    let _e424 = (*lightIndex);
-    let _e428 = point_shadow.slots[_e424][2u];
-    tanHalf_1 = max(_e428, 0.0001f);
+    let _e393 = ndc[0u];
+    let _e397 = ndc[1u];
+    uv_3 = vec2<f32>(((_e393 * 0.5f) + 0.5f), (0.5f - (_e397 * 0.5f)));
+    let _e401 = face;
+    let _e403 = slot;
+    tile_3 = vec2<f32>(f32(_e401), f32(_e403));
+    let _e406 = distance_;
+    let _e409 = point_shadow.params[1u];
+    receiver_2 = (_e406 - _e409);
+    let _e413 = frag_info.target_origin[0u];
+    param_28 = _e413;
+    let _e414 = FragCoordFromTop_u0028_f1_u003b((&param_28));
+    noise = fract((52.982918f * fract(dot(_e414, vec2<f32>(0.06711056f, 0.00583715f)))));
+    let _e419 = noise;
+    angle = (_e419 * 6.2831855f);
+    let _e421 = angle;
+    ca_2 = cos(_e421);
+    let _e423 = angle;
+    sa_2 = sin(_e423);
+    let _e425 = (*lightIndex);
+    let _e429 = point_shadow.slots[_e425][2u];
+    tanHalf_1 = max(_e429, 0.0001f);
     blocker_1 = -1f;
-    let _e430 = uv_3;
-    param_29 = _e430;
-    let _e431 = tile_3;
-    param_30 = _e431;
-    let _e432 = range_3;
-    param_31 = _e432;
-    let _e433 = receiver_2;
-    param_32 = _e433;
-    let _e434 = ca_2;
-    param_33 = _e434;
-    let _e435 = sa_2;
-    param_34 = _e435;
-    let _e436 = tanHalf_1;
-    param_35 = _e436;
-    let _e437 = PointShadowPenumbra_u0028_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b((&param_29), (&param_30), (&param_31), (&param_32), (&param_33), (&param_34), (&param_35), (&param_36));
-    let _e438 = param_36;
-    blocker_1 = _e438;
-    radius_1 = _e437;
-    let _e441 = point_shadow.params2_[3u];
-    if (_e441 > 0.5f) {
+    let _e431 = uv_3;
+    param_29 = _e431;
+    let _e432 = tile_3;
+    param_30 = _e432;
+    let _e433 = range_3;
+    param_31 = _e433;
+    let _e434 = receiver_2;
+    param_32 = _e434;
+    let _e435 = ca_2;
+    param_33 = _e435;
+    let _e436 = sa_2;
+    param_34 = _e436;
+    let _e437 = tanHalf_1;
+    param_35 = _e437;
+    let _e438 = PointShadowPenumbra_u0028_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b_f1_u003b((&param_29), (&param_30), (&param_31), (&param_32), (&param_33), (&param_34), (&param_35), (&param_36));
+    let _e439 = param_36;
+    blocker_1 = _e439;
+    radius_1 = _e438;
+    let _e442 = point_shadow.params2_[3u];
+    if (_e442 > 0.5f) {
         g_debug_surface_on = true;
-        let _e443 = radius_1;
-        if (_e443 < 0f) {
+        let _e444 = radius_1;
+        if (_e444 < 0f) {
             local_7 = vec3<f32>(0f, 0f, 1f);
         } else {
-            let _e445 = radius_1;
-            let _e448 = point_shadow.params2_[2u];
-            let _e452 = blocker_1;
-            let _e453 = range_3;
-            local_7 = vec3<f32>(clamp((_e445 / max(_e448, 0.000001f)), 0f, 1f), clamp((_e452 / _e453), 0f, 1f), 0f);
+            let _e446 = radius_1;
+            let _e449 = point_shadow.params2_[2u];
+            let _e453 = blocker_1;
+            let _e454 = range_3;
+            local_7 = vec3<f32>(clamp((_e446 / max(_e449, 0.000001f)), 0f, 1f), clamp((_e453 / _e454), 0f, 1f), 0f);
         }
-        let _e457 = local_7;
-        g_debug_surface = _e457;
+        let _e458 = local_7;
+        g_debug_surface = _e458;
     }
-    let _e458 = radius_1;
-    if (_e458 < 0f) {
+    let _e459 = radius_1;
+    if (_e459 < 0f) {
         return 1f;
     }
-    let _e460 = uv_3;
-    param_37 = _e460;
+    let _e461 = uv_3;
+    param_37 = _e461;
     param_38 = vec2<f32>(0f, 0f);
-    let _e461 = tile_3;
-    param_39 = _e461;
-    let _e462 = range_3;
-    param_40 = _e462;
-    let _e463 = receiver_2;
-    param_41 = _e463;
-    let _e464 = PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((&param_37), (&param_38), (&param_39), (&param_40), (&param_41));
-    lit_1 = _e464;
-    let _e465 = radius_1;
-    if (_e465 > 0f) {
+    let _e462 = tile_3;
+    param_39 = _e462;
+    let _e463 = range_3;
+    param_40 = _e463;
+    let _e464 = receiver_2;
+    param_41 = _e464;
+    let _e465 = PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((&param_37), (&param_38), (&param_39), (&param_40), (&param_41));
+    lit_1 = _e465;
+    let _e466 = radius_1;
+    if (_e466 > 0f) {
         i_3 = 0i;
         loop {
-            let _e467 = i_3;
-            if (_e467 < 8i) {
-                let _e469 = i_3;
-                param_42 = _e469;
-                let _e470 = ca_2;
-                param_43 = _e470;
-                let _e471 = sa_2;
-                param_44 = _e471;
-                let _e472 = radius_1;
-                param_45 = _e472;
-                let _e473 = PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b((&param_42), (&param_43), (&param_44), (&param_45));
-                let _e474 = uv_3;
-                param_46 = _e474;
-                param_47 = _e473;
-                let _e475 = tile_3;
-                param_48 = _e475;
-                let _e476 = range_3;
-                param_49 = _e476;
-                let _e477 = receiver_2;
-                param_50 = _e477;
-                let _e478 = PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((&param_46), (&param_47), (&param_48), (&param_49), (&param_50));
-                let _e479 = lit_1;
-                lit_1 = (_e479 + _e478);
+            let _e468 = i_3;
+            if (_e468 < 8i) {
+                let _e470 = i_3;
+                param_42 = _e470;
+                let _e471 = ca_2;
+                param_43 = _e471;
+                let _e472 = sa_2;
+                param_44 = _e472;
+                let _e473 = radius_1;
+                param_45 = _e473;
+                let _e474 = PointShadowOffset_u0028_i1_u003b_f1_u003b_f1_u003b_f1_u003b((&param_42), (&param_43), (&param_44), (&param_45));
+                let _e475 = uv_3;
+                param_46 = _e475;
+                param_47 = _e474;
+                let _e476 = tile_3;
+                param_48 = _e476;
+                let _e477 = range_3;
+                param_49 = _e477;
+                let _e478 = receiver_2;
+                param_50 = _e478;
+                let _e479 = PointShadowTap_u0028_vf2_u003b_vf2_u003b_vf2_u003b_f1_u003b_f1_u003b((&param_46), (&param_47), (&param_48), (&param_49), (&param_50));
+                let _e480 = lit_1;
+                lit_1 = (_e480 + _e479);
                 continue;
             } else {
                 break;
             }
             continuing {
-                let _e481 = i_3;
-                i_3 = (_e481 + 1i);
+                let _e482 = i_3;
+                i_3 = (_e482 + 1i);
             }
         }
-        let _e483 = lit_1;
-        lit_1 = (_e483 * 0.11111111f);
+        let _e484 = lit_1;
+        lit_1 = (_e484 * 0.11111111f);
     }
-    let _e485 = lit_1;
-    let _e486 = strength;
-    return mix(1f, _e485, clamp(_e486, 0f, 1f));
+    let _e486 = lit_1;
+    let _e487 = strength;
+    return mix(1f, _e486, clamp(_e487, 0f, 1f));
 }
 
 fn VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b(i_4: ptr<function, i32>, n_1: ptr<function, i32>, turn: ptr<function, f32>) -> vec2<f32> {
     var r: f32;
     var theta: f32;
 
-    let _e183 = (*i_4);
-    let _e186 = (*n_1);
-    r = sqrt(((f32(_e183) + 0.5f) / f32(_e186)));
-    let _e190 = (*i_4);
-    let _e193 = (*turn);
-    theta = ((f32(_e190) * 2.3999631f) + _e193);
-    let _e195 = r;
-    let _e196 = theta;
-    let _e198 = theta;
-    return (vec2<f32>(cos(_e196), sin(_e198)) * _e195);
+    let _e184 = (*i_4);
+    let _e187 = (*n_1);
+    r = sqrt(((f32(_e184) + 0.5f) / f32(_e187)));
+    let _e191 = (*i_4);
+    let _e194 = (*turn);
+    theta = ((f32(_e191) * 2.3999631f) + _e194);
+    let _e196 = r;
+    let _e197 = theta;
+    let _e199 = theta;
+    return (vec2<f32>(cos(_e197), sin(_e199)) * _e196);
 }
 
 fn ShadowNoise_u0028_() -> f32 {
     var at: vec2<f32>;
     var param_51: f32;
 
-    let _e182 = frag_info.target_origin[0u];
-    param_51 = _e182;
-    let _e183 = FragCoordFromTop_u0028_f1_u003b((&param_51));
-    let _e186 = frag_info.target_origin[3u];
-    at = (_e183 + vec2((5.588238f * max(_e186, 0f))));
-    let _e191 = at;
-    return fract((52.982918f * fract(dot(_e191, vec2<f32>(0.06711056f, 0.00583715f)))));
+    let _e183 = frag_info.target_origin[0u];
+    param_51 = _e183;
+    let _e184 = FragCoordFromTop_u0028_f1_u003b((&param_51));
+    let _e187 = frag_info.target_origin[3u];
+    at = (_e184 + vec2((5.588238f * max(_e187, 0f))));
+    let _e192 = at;
+    return fract((52.982918f * fract(dot(_e192, vec2<f32>(0.06711056f, 0.00583715f)))));
 }
 
 fn EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b(moments: ptr<function, vec2<f32>>, t: ptr<function, f32>, minVariance: ptr<function, f32>, bleed: ptr<function, f32>) -> f32 {
@@ -47115,37 +47304,37 @@ fn EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b(moments: ptr<functio
     var pMax: f32;
     var reduced: f32;
 
-    let _e187 = (*moments)[1u];
-    let _e189 = (*moments)[0u];
-    let _e191 = (*moments)[0u];
-    let _e194 = (*minVariance);
-    variance = max((_e187 - (_e189 * _e191)), _e194);
-    let _e196 = (*t);
-    let _e198 = (*moments)[0u];
-    d_1 = (_e196 - _e198);
-    let _e200 = variance;
+    let _e188 = (*moments)[1u];
+    let _e190 = (*moments)[0u];
+    let _e192 = (*moments)[0u];
+    let _e195 = (*minVariance);
+    variance = max((_e188 - (_e190 * _e192)), _e195);
+    let _e197 = (*t);
+    let _e199 = (*moments)[0u];
+    d_1 = (_e197 - _e199);
     let _e201 = variance;
-    let _e202 = d_1;
+    let _e202 = variance;
     let _e203 = d_1;
-    pMax = (_e200 / (_e201 + (_e202 * _e203)));
-    let _e207 = pMax;
-    let _e208 = (*bleed);
-    let _e210 = (*bleed);
-    reduced = clamp(((_e207 - _e208) / max((1f - _e210), 0.0001f)), 0f, 1f);
-    let _e215 = (*t);
-    let _e217 = (*moments)[0u];
-    let _e219 = reduced;
-    return select(_e219, 1f, (_e215 <= _e217));
+    let _e204 = d_1;
+    pMax = (_e201 / (_e202 + (_e203 * _e204)));
+    let _e208 = pMax;
+    let _e209 = (*bleed);
+    let _e211 = (*bleed);
+    reduced = clamp(((_e208 - _e209) / max((1f - _e211), 0.0001f)), 0f, 1f);
+    let _e216 = (*t);
+    let _e218 = (*moments)[0u];
+    let _e220 = reduced;
+    return select(_e220, 1f, (_e216 <= _e218));
 }
 
 fn EvsmWarp_u0028_f1_u003b(depth: ptr<function, f32>) -> vec2<f32> {
     var d_2: f32;
 
-    let _e180 = (*depth);
-    d_2 = ((2f * clamp(_e180, 0f, 1f)) - 1f);
-    let _e184 = d_2;
-    let _e187 = d_2;
-    return vec2<f32>(exp((40f * _e184)), -(exp((-5f * _e187))));
+    let _e181 = (*depth);
+    d_2 = ((2f * clamp(_e181, 0f, 1f)) - 1f);
+    let _e185 = d_2;
+    let _e188 = d_2;
+    return vec2<f32>(exp((40f * _e185)), -(exp((-5f * _e188))));
 }
 
 fn EvsmVisibility_u0028_vf4_u003b_f1_u003b_f1_u003b(moments_1: ptr<function, vec4<f32>>, depth_1: ptr<function, f32>, bleed_1: ptr<function, f32>) -> f32 {
@@ -47163,37 +47352,37 @@ fn EvsmVisibility_u0028_vf4_u003b_f1_u003b_f1_u003b(moments_1: ptr<function, vec
     var param_59: f32;
     var param_60: f32;
 
-    let _e194 = (*depth_1);
-    param_52 = _e194;
-    let _e195 = EvsmWarp_u0028_f1_u003b((&param_52));
-    warped = _e195;
-    let _e196 = warped;
-    scale = (vec2<f32>(0.004f, 0.0005f) * _e196);
-    let _e199 = scale[0u];
-    let _e201 = scale[0u];
-    let _e203 = (*moments_1);
-    param_53 = _e203.xy;
-    let _e206 = warped[0u];
-    param_54 = _e206;
-    param_55 = (_e199 * _e201);
-    let _e207 = (*bleed_1);
-    param_56 = _e207;
-    let _e208 = EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b((&param_53), (&param_54), (&param_55), (&param_56));
-    positive = _e208;
-    let _e210 = scale[1u];
-    let _e212 = scale[1u];
-    let _e214 = (*moments_1);
-    param_57 = _e214.zw;
-    let _e217 = warped[1u];
-    param_58 = _e217;
-    param_59 = (_e210 * _e212);
-    let _e218 = (*bleed_1);
-    param_60 = _e218;
-    let _e219 = EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b((&param_57), (&param_58), (&param_59), (&param_60));
-    negative = _e219;
-    let _e220 = positive;
-    let _e221 = negative;
-    return min(_e220, _e221);
+    let _e195 = (*depth_1);
+    param_52 = _e195;
+    let _e196 = EvsmWarp_u0028_f1_u003b((&param_52));
+    warped = _e196;
+    let _e197 = warped;
+    scale = (vec2<f32>(0.004f, 0.0005f) * _e197);
+    let _e200 = scale[0u];
+    let _e202 = scale[0u];
+    let _e204 = (*moments_1);
+    param_53 = _e204.xy;
+    let _e207 = warped[0u];
+    param_54 = _e207;
+    param_55 = (_e200 * _e202);
+    let _e208 = (*bleed_1);
+    param_56 = _e208;
+    let _e209 = EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b((&param_53), (&param_54), (&param_55), (&param_56));
+    positive = _e209;
+    let _e211 = scale[1u];
+    let _e213 = scale[1u];
+    let _e215 = (*moments_1);
+    param_57 = _e215.zw;
+    let _e218 = warped[1u];
+    param_58 = _e218;
+    param_59 = (_e211 * _e213);
+    let _e219 = (*bleed_1);
+    param_60 = _e219;
+    let _e220 = EvsmChebyshev_u0028_vf2_u003b_f1_u003b_f1_u003b_f1_u003b((&param_57), (&param_58), (&param_59), (&param_60));
+    negative = _e220;
+    let _e221 = positive;
+    let _e222 = negative;
+    return min(_e221, _e222);
 }
 
 fn ShadowFactor_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b_i1_u003b(s_2: ptr<function, Surface>, light_1: ptr<function, LightSample>, lightIndex_1: ptr<function, i32>) -> f32 {
@@ -47231,6 +47420,8 @@ fn ShadowFactor_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf
     var tileLo: vec2<f32>;
     var tileHi: vec2<f32>;
     var stored_2: vec4<f32>;
+    var y: i32;
+    var x: i32;
     var through: vec3<f32>;
     var softness: f32;
     var lit_2: f32;
@@ -47238,8 +47429,8 @@ fn ShadowFactor_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf
     var param_61: vec4<f32>;
     var param_62: f32;
     var param_63: f32;
-    var y: i32;
-    var x: i32;
+    var y_1: i32;
+    var x_1: i32;
     var occluder: f32;
     var spread: f32;
     var turn_1: f32;
@@ -47268,45 +47459,45 @@ fn ShadowFactor_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf
     var phi_3162_: bool;
     var phi_3169_: bool;
 
-    let _e248 = frag_info.shadow_params[3u];
-    strength_1 = _e248;
-    let _e249 = strength_1;
-    if (_e249 <= 0f) {
+    let _e251 = frag_info.shadow_params[3u];
+    strength_1 = _e251;
+    let _e252 = strength_1;
+    if (_e252 <= 0f) {
         return 1f;
     }
-    let _e251 = (*lightIndex_1);
-    let _e254 = frag_info.frame_params[2u];
-    if (_e251 != i32((_e254 + 0.5f))) {
+    let _e254 = (*lightIndex_1);
+    let _e257 = frag_info.frame_params[2u];
+    if (_e254 != i32((_e257 + 0.5f))) {
         return 1f;
     }
-    let _e260 = frag_info.shadow_cascades[2u];
-    cascadeCount = i32((_e260 + 0.5f));
-    let _e263 = v_world_position_1;
-    let _e265 = frag_info.camera_position;
-    viewDistance = length((_e263 - _e265.xyz));
+    let _e263 = frag_info.shadow_cascades[2u];
+    cascadeCount = i32((_e263 + 0.5f));
+    let _e266 = v_world_position_1;
+    let _e268 = frag_info.camera_position;
+    viewDistance = length((_e266 - _e268.xyz));
     cascade = 0i;
-    let _e269 = cascadeCount;
-    let _e270 = (_e269 > 1i);
-    phi_2983_ = _e270;
-    if _e270 {
-        let _e271 = viewDistance;
-        let _e274 = frag_info.shadow_cascades[0u];
-        phi_2983_ = (_e271 > _e274);
-    }
-    let _e277 = phi_2983_;
-    if _e277 {
+    let _e272 = cascadeCount;
+    let _e273 = (_e272 > 1i);
+    phi_2983_ = _e273;
+    if _e273 {
+        let _e274 = viewDistance;
+        let _e277 = frag_info.shadow_cascades[0u];
+        phi_2983_ = (_e274 > _e277);
+    }
+    let _e280 = phi_2983_;
+    if _e280 {
         cascade = 1i;
     }
-    let _e278 = cascadeCount;
-    let _e279 = (_e278 > 2i);
-    phi_2994_ = _e279;
-    if _e279 {
-        let _e280 = viewDistance;
-        let _e283 = frag_info.shadow_cascades[1u];
-        phi_2994_ = (_e280 > _e283);
+    let _e281 = cascadeCount;
+    let _e282 = (_e281 > 2i);
+    phi_2994_ = _e282;
+    if _e282 {
+        let _e283 = viewDistance;
+        let _e286 = frag_info.shadow_cascades[1u];
+        phi_2994_ = (_e283 > _e286);
     }
-    let _e286 = phi_2994_;
-    if _e286 {
+    let _e289 = phi_2994_;
+    if _e289 {
         cascade = 2i;
     }
     uv_4 = vec2<f32>(0f, 0f);
@@ -47317,247 +47508,280 @@ fn ShadowFactor_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf
     receiverSlope = 0f;
     attempt = 0i;
     loop {
-        let _e287 = attempt;
-        if (_e287 < 3i) {
-            let _e289 = cascade;
-            let _e290 = attempt;
-            which = (_e289 + _e290);
-            let _e292 = which;
-            let _e293 = cascadeCount;
-            if (_e292 >= _e293) {
+        let _e290 = attempt;
+        if (_e290 < 3i) {
+            let _e292 = cascade;
+            let _e293 = attempt;
+            which = (_e292 + _e293);
+            let _e295 = which;
+            let _e296 = cascadeCount;
+            if (_e295 >= _e296) {
                 break;
             }
-            let _e295 = which;
-            if (_e295 == 0i) {
-                let _e298 = frag_info.shadow_matrix;
-                local_8 = _e298;
+            let _e298 = which;
+            if (_e298 == 0i) {
+                let _e301 = frag_info.shadow_matrix;
+                local_8 = _e301;
             } else {
-                let _e299 = which;
-                if (_e299 == 1i) {
-                    let _e302 = frag_info.shadow_matrix_far;
-                    local_9 = _e302;
+                let _e302 = which;
+                if (_e302 == 1i) {
+                    let _e305 = frag_info.shadow_matrix_far;
+                    local_9 = _e305;
                 } else {
-                    let _e304 = frag_info.shadow_matrix_farthest;
-                    local_9 = _e304;
+                    let _e307 = frag_info.shadow_matrix_farthest;
+                    local_9 = _e307;
                 }
-                let _e305 = local_9;
-                local_8 = _e305;
-            }
-            let _e306 = local_8;
-            matrix = _e306;
-            let _e309 = matrix[0][0u];
-            let _e312 = matrix[1][0u];
-            let _e315 = matrix[2][0u];
-            axisX = vec3<f32>(_e309, _e312, _e315);
-            let _e319 = matrix[0][1u];
-            let _e322 = matrix[1][1u];
-            let _e325 = matrix[2][1u];
-            axisY = vec3<f32>(_e319, _e322, _e325);
-            let _e327 = axisX;
-            rowX = max(length(_e327), 0.000001f);
-            let _e330 = axisY;
-            rowY = max(length(_e330), 0.000001f);
-            let _e335 = frag_info.shadow_cascades[3u];
-            let _e337 = rowX;
-            texelMetres = ((2f * _e335) / _e337);
-            let _e341 = frag_info.shadow_cascades[3u];
-            let _e344 = (*s_2).n;
-            let _e345 = axisX;
-            let _e348 = rowX;
-            let _e349 = rowX;
-            let _e353 = (*s_2).n;
-            let _e354 = axisY;
-            let _e357 = rowY;
-            let _e358 = rowY;
-            reach = ((3f * _e341) * ((abs(dot(_e344, _e345)) / (_e348 * _e349)) + (abs(dot(_e353, _e354)) / (_e357 * _e358))));
-            let _e365 = frag_info.shadow_params[2u];
-            let _e366 = texelMetres;
-            flatOffset = min(_e365, _e366);
-            let _e368 = v_world_position_1;
-            let _e370 = (*s_2).n;
-            let _e371 = flatOffset;
-            let _e372 = reach;
-            origin_1 = (_e368 + (_e370 * (_e371 + _e372)));
-            let _e376 = matrix;
-            let _e377 = origin_1;
-            lightSpace = (_e376 * vec4<f32>(_e377.x, _e377.y, _e377.z, 1f));
-            let _e384 = lightSpace[3u];
-            if (_e384 <= 0f) {
+                let _e308 = local_9;
+                local_8 = _e308;
+            }
+            let _e309 = local_8;
+            matrix = _e309;
+            let _e312 = matrix[0][0u];
+            let _e315 = matrix[1][0u];
+            let _e318 = matrix[2][0u];
+            axisX = vec3<f32>(_e312, _e315, _e318);
+            let _e322 = matrix[0][1u];
+            let _e325 = matrix[1][1u];
+            let _e328 = matrix[2][1u];
+            axisY = vec3<f32>(_e322, _e325, _e328);
+            let _e330 = axisX;
+            rowX = max(length(_e330), 0.000001f);
+            let _e333 = axisY;
+            rowY = max(length(_e333), 0.000001f);
+            let _e338 = frag_info.shadow_cascades[3u];
+            let _e340 = rowX;
+            texelMetres = ((2f * _e338) / _e340);
+            let _e344 = frag_info.shadow_cascades[3u];
+            let _e347 = (*s_2).n;
+            let _e348 = axisX;
+            let _e351 = rowX;
+            let _e352 = rowX;
+            let _e356 = (*s_2).n;
+            let _e357 = axisY;
+            let _e360 = rowY;
+            let _e361 = rowY;
+            reach = ((3f * _e344) * ((abs(dot(_e347, _e348)) / (_e351 * _e352)) + (abs(dot(_e356, _e357)) / (_e360 * _e361))));
+            let _e368 = frag_info.shadow_params[2u];
+            let _e369 = texelMetres;
+            flatOffset = min(_e368, _e369);
+            let _e371 = v_world_position_1;
+            let _e373 = (*s_2).n;
+            let _e374 = flatOffset;
+            let _e375 = reach;
+            origin_1 = (_e371 + (_e373 * (_e374 + _e375)));
+            let _e379 = matrix;
+            let _e380 = origin_1;
+            lightSpace = (_e379 * vec4<f32>(_e380.x, _e380.y, _e380.z, 1f));
+            let _e387 = lightSpace[3u];
+            if (_e387 <= 0f) {
                 continue;
             }
-            let _e386 = lightSpace;
-            let _e389 = lightSpace[3u];
-            candidate = (_e386.xyz / vec3(_e389));
-            let _e393 = candidate[0u];
-            let _e397 = candidate[1u];
-            inTile = vec2<f32>(((_e393 * 0.5f) + 0.5f), (0.5f - (_e397 * 0.5f)));
-            let _e402 = inTile[0u];
-            let _e403 = (_e402 < 0f);
-            phi_3155_ = _e403;
-            if !(_e403) {
-                let _e406 = inTile[0u];
-                phi_3155_ = (_e406 > 1f);
-            }
-            let _e409 = phi_3155_;
-            phi_3162_ = _e409;
-            if !(_e409) {
-                let _e412 = inTile[1u];
-                phi_3162_ = (_e412 < 0f);
-            }
-            let _e415 = phi_3162_;
-            phi_3169_ = _e415;
-            if !(_e415) {
-                let _e418 = inTile[1u];
-                phi_3169_ = (_e418 > 1f);
+            let _e389 = lightSpace;
+            let _e392 = lightSpace[3u];
+            candidate = (_e389.xyz / vec3(_e392));
+            let _e396 = candidate[0u];
+            let _e400 = candidate[1u];
+            inTile = vec2<f32>(((_e396 * 0.5f) + 0.5f), (0.5f - (_e400 * 0.5f)));
+            let _e405 = inTile[0u];
+            let _e406 = (_e405 < 0f);
+            phi_3155_ = _e406;
+            if !(_e406) {
+                let _e409 = inTile[0u];
+                phi_3155_ = (_e409 > 1f);
+            }
+            let _e412 = phi_3155_;
+            phi_3162_ = _e412;
+            if !(_e412) {
+                let _e415 = inTile[1u];
+                phi_3162_ = (_e415 < 0f);
             }
-            let _e421 = phi_3169_;
-            if _e421 {
+            let _e418 = phi_3162_;
+            phi_3169_ = _e418;
+            if !(_e418) {
+                let _e421 = inTile[1u];
+                phi_3169_ = (_e421 > 1f);
+            }
+            let _e424 = phi_3169_;
+            if _e424 {
                 continue;
             }
-            let _e423 = candidate[2u];
-            if (_e423 > 1f) {
-                let _e425 = which;
-                let _e426 = cascadeCount;
-                if (_e425 < (_e426 - 1i)) {
+            let _e426 = candidate[2u];
+            if (_e426 > 1f) {
+                let _e428 = which;
+                let _e429 = cascadeCount;
+                if (_e428 < (_e429 - 1i)) {
                     continue;
                 }
                 candidate[2u] = 1f;
             }
-            let _e431 = inTile[0u];
-            let _e432 = which;
-            let _e435 = cascadeCount;
-            let _e439 = inTile[1u];
-            uv_4 = vec2<f32>(((_e431 + f32(_e432)) / f32(_e435)), _e439);
-            let _e441 = candidate;
-            projected = _e441;
-            let _e442 = which;
-            cascade = _e442;
-            let _e443 = texelMetres;
-            cascadeTexel = _e443;
-            let _e446 = matrix[0][2u];
-            let _e449 = matrix[1][2u];
-            let _e452 = matrix[2][2u];
-            cascadeDepth = (1f / max(length(vec3<f32>(_e446, _e449, _e452)), 0.000001f));
-            let _e458 = (*s_2).n;
-            let _e461 = matrix[0][2u];
-            let _e464 = matrix[1][2u];
-            let _e467 = matrix[2][2u];
-            let _e471 = cascadeDepth;
-            cosSlope = clamp((abs(dot(_e458, vec3<f32>(_e461, _e464, _e467))) * _e471), 0.1f, 1f);
-            let _e474 = texelMetres;
-            let _e475 = cosSlope;
-            let _e476 = cosSlope;
-            let _e482 = cosSlope;
-            let _e484 = cascadeDepth;
-            receiverSlope = (((_e474 * sqrt(max((1f - (_e475 * _e476)), 0f))) / _e482) / _e484);
+            let _e434 = inTile[0u];
+            let _e435 = which;
+            let _e438 = cascadeCount;
+            let _e442 = inTile[1u];
+            uv_4 = vec2<f32>(((_e434 + f32(_e435)) / f32(_e438)), _e442);
+            let _e444 = candidate;
+            projected = _e444;
+            let _e445 = which;
+            cascade = _e445;
+            let _e446 = texelMetres;
+            cascadeTexel = _e446;
+            let _e449 = matrix[0][2u];
+            let _e452 = matrix[1][2u];
+            let _e455 = matrix[2][2u];
+            cascadeDepth = (1f / max(length(vec3<f32>(_e449, _e452, _e455)), 0.000001f));
+            let _e461 = (*s_2).n;
+            let _e464 = matrix[0][2u];
+            let _e467 = matrix[1][2u];
+            let _e470 = matrix[2][2u];
+            let _e474 = cascadeDepth;
+            cosSlope = clamp((abs(dot(_e461, vec3<f32>(_e464, _e467, _e470))) * _e474), 0.1f, 1f);
+            let _e477 = texelMetres;
+            let _e478 = cosSlope;
+            let _e479 = cosSlope;
+            let _e485 = cosSlope;
+            let _e487 = cascadeDepth;
+            receiverSlope = (((_e477 * sqrt(max((1f - (_e478 * _e479)), 0f))) / _e485) / _e487);
             found = true;
             break;
         } else {
             break;
         }
         continuing {
-            let _e486 = attempt;
-            attempt = (_e486 + 1i);
+            let _e489 = attempt;
+            attempt = (_e489 + 1i);
         }
     }
-    let _e488 = found;
-    if !(_e488) {
+    let _e491 = found;
+    if !(_e491) {
         return 1f;
     }
-    let _e490 = cascade;
-    if (_e490 == 0i) {
-        let _e494 = frag_info.shadow_bias[0u];
-        local_10 = _e494;
+    let _e493 = cascade;
+    if (_e493 == 0i) {
+        let _e497 = frag_info.shadow_bias[0u];
+        local_10 = _e497;
     } else {
-        let _e495 = cascade;
-        if (_e495 == 1i) {
-            let _e499 = frag_info.shadow_bias[1u];
-            local_11 = _e499;
-        } else {
-            let _e502 = frag_info.shadow_bias[2u];
+        let _e498 = cascade;
+        if (_e498 == 1i) {
+            let _e502 = frag_info.shadow_bias[1u];
             local_11 = _e502;
-        }
-        let _e503 = local_11;
-        local_10 = _e503;
-    }
-    let _e504 = local_10;
-    bias = _e504;
-    let _e507 = frag_info.shadow_params[0u];
-    let _e510 = frag_info.shadow_cascades[3u];
-    texel_1 = vec2<f32>(_e507, _e510);
-    let _e512 = cascade;
-    let _e514 = cascadeCount;
-    let _e518 = texel_1;
-    tileLo = (vec2<f32>((f32(_e512) / f32(_e514)), 0f) + (_e518 * 0.5f));
-    let _e521 = cascade;
-    let _e524 = cascadeCount;
-    let _e528 = texel_1;
-    tileHi = (vec2<f32>((f32((_e521 + 1i)) / f32(_e524)), 1f) - (_e528 * 0.5f));
-    let _e533 = frag_info.shadow_bias[3u];
-    if (_e533 > 0.5f) {
-        let _e535 = uv_4;
-        let _e536 = tileLo;
-        let _e537 = tileHi;
-        let _e539 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp(_e535, _e536, _e537), 0f);
-        stored_2 = _e539;
-        let _e541 = stored_2[1u];
-        let _e544 = stored_2[2u];
-        let _e547 = stored_2[3u];
-        through = clamp(vec3<f32>((1f - _e541), (1f - _e544), _e547), vec3(0f), vec3(4f));
-        let _e552 = through;
-        let _e553 = strength_1;
-        light_transmittance = mix(vec3<f32>(1f, 1f, 1f), _e552, vec3(clamp(_e553, 0f, 1f)));
-    }
-    let _e559 = frag_info.ambient_ground[3u];
-    softness = _e559;
+        } else {
+            let _e505 = frag_info.shadow_bias[2u];
+            local_11 = _e505;
+        }
+        let _e506 = local_11;
+        local_10 = _e506;
+    }
+    let _e507 = local_10;
+    bias = _e507;
+    let _e510 = frag_info.shadow_params[0u];
+    let _e513 = frag_info.shadow_cascades[3u];
+    texel_1 = vec2<f32>(_e510, _e513);
+    let _e515 = cascade;
+    let _e517 = cascadeCount;
+    let _e521 = texel_1;
+    tileLo = (vec2<f32>((f32(_e515) / f32(_e517)), 0f) + (_e521 * 0.5f));
+    let _e524 = cascade;
+    let _e527 = cascadeCount;
+    let _e531 = texel_1;
+    tileHi = (vec2<f32>((f32((_e524 + 1i)) / f32(_e527)), 1f) - (_e531 * 0.5f));
+    let _e536 = frag_info.shadow_bias[3u];
+    if (_e536 > 0.5f) {
+        stored_2 = vec4<f32>(0f, 0f, 0f, 0f);
+        y = -1i;
+        loop {
+            let _e538 = y;
+            if (_e538 <= 1i) {
+                x = -1i;
+                loop {
+                    let _e540 = x;
+                    if (_e540 <= 1i) {
+                        let _e542 = uv_4;
+                        let _e543 = x;
+                        let _e545 = y;
+                        let _e548 = texel_1;
+                        let _e551 = tileLo;
+                        let _e552 = tileHi;
+                        let _e554 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e542 + (vec2<f32>(f32(_e543), f32(_e545)) * _e548)), _e551, _e552), 0f);
+                        let _e555 = stored_2;
+                        stored_2 = (_e555 + _e554);
+                        continue;
+                    } else {
+                        break;
+                    }
+                    continuing {
+                        let _e557 = x;
+                        x = (_e557 + 1i);
+                    }
+                }
+                continue;
+            } else {
+                break;
+            }
+            continuing {
+                let _e559 = y;
+                y = (_e559 + 1i);
+            }
+        }
+        let _e561 = stored_2;
+        stored_2 = (_e561 * 0.11111111f);
+        let _e564 = stored_2[1u];
+        let _e567 = stored_2[2u];
+        let _e570 = stored_2[3u];
+        through = clamp(vec3<f32>((1f - _e564), (1f - _e567), _e570), vec3(0f), vec3(4f));
+        let _e575 = through;
+        let _e576 = strength_1;
+        light_transmittance = mix(vec3<f32>(1f, 1f, 1f), _e575, vec3(clamp(_e576, 0f, 1f)));
+    }
+    let _e582 = frag_info.ambient_ground[3u];
+    softness = _e582;
     lit_2 = 0f;
-    let _e560 = softness;
-    if (_e560 < 0f) {
-        let _e562 = uv_4;
-        let _e563 = tileLo;
-        let _e564 = tileHi;
-        let _e566 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp(_e562, _e563, _e564), 0f);
-        moments_2 = _e566;
-        let _e568 = projected[2u];
-        let _e569 = bias;
-        let _e571 = softness;
-        let _e575 = moments_2;
-        param_61 = _e575;
-        param_62 = (_e568 - _e569);
-        param_63 = clamp((-(_e571) - 1f), 0f, 0.95f);
-        let _e576 = EvsmVisibility_u0028_vf4_u003b_f1_u003b_f1_u003b((&param_61), (&param_62), (&param_63));
-        lit_2 = _e576;
-    } else {
-        let _e577 = softness;
-        if (_e577 <= 0f) {
-            y = -1i;
+    let _e583 = softness;
+    if (_e583 < 0f) {
+        let _e585 = uv_4;
+        let _e586 = tileLo;
+        let _e587 = tileHi;
+        let _e589 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp(_e585, _e586, _e587), 0f);
+        moments_2 = _e589;
+        let _e591 = projected[2u];
+        let _e592 = bias;
+        let _e594 = softness;
+        let _e598 = moments_2;
+        param_61 = _e598;
+        param_62 = (_e591 - _e592);
+        param_63 = clamp((-(_e594) - 1f), 0f, 0.95f);
+        let _e599 = EvsmVisibility_u0028_vf4_u003b_f1_u003b_f1_u003b((&param_61), (&param_62), (&param_63));
+        lit_2 = _e599;
+    } else {
+        let _e600 = softness;
+        if (_e600 <= 0f) {
+            y_1 = -1i;
             loop {
-                let _e579 = y;
-                if (_e579 <= 1i) {
-                    x = -1i;
+                let _e602 = y_1;
+                if (_e602 <= 1i) {
+                    x_1 = -1i;
                     loop {
-                        let _e581 = x;
-                        if (_e581 <= 1i) {
-                            let _e583 = uv_4;
-                            let _e584 = x;
-                            let _e586 = y;
-                            let _e589 = texel_1;
-                            let _e592 = tileLo;
-                            let _e593 = tileHi;
-                            let _e595 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e583 + (vec2<f32>(f32(_e584), f32(_e586)) * _e589)), _e592, _e593), 0f);
-                            occluder = _e595.x;
-                            let _e598 = projected[2u];
-                            let _e599 = bias;
-                            let _e601 = occluder;
-                            let _e604 = lit_2;
-                            lit_2 = (_e604 + select(1f, 0f, ((_e598 - _e599) > _e601)));
+                        let _e604 = x_1;
+                        if (_e604 <= 1i) {
+                            let _e606 = uv_4;
+                            let _e607 = x_1;
+                            let _e609 = y_1;
+                            let _e612 = texel_1;
+                            let _e615 = tileLo;
+                            let _e616 = tileHi;
+                            let _e618 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e606 + (vec2<f32>(f32(_e607), f32(_e609)) * _e612)), _e615, _e616), 0f);
+                            occluder = _e618.x;
+                            let _e621 = projected[2u];
+                            let _e622 = bias;
+                            let _e624 = occluder;
+                            let _e627 = lit_2;
+                            lit_2 = (_e627 + select(1f, 0f, ((_e621 - _e622) > _e624)));
                             continue;
                         } else {
                             break;
                         }
                         continuing {
-                            let _e606 = x;
-                            x = (_e606 + 1i);
+                            let _e629 = x_1;
+                            x_1 = (_e629 + 1i);
                         }
                     }
                     continue;
@@ -47565,125 +47789,125 @@ fn ShadowFactor_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf
                     break;
                 }
                 continuing {
-                    let _e608 = y;
-                    y = (_e608 + 1i);
+                    let _e631 = y_1;
+                    y_1 = (_e631 + 1i);
                 }
             }
-            let _e610 = lit_2;
-            lit_2 = (_e610 * 0.11111111f);
+            let _e633 = lit_2;
+            lit_2 = (_e633 * 0.11111111f);
         } else {
-            let _e612 = softness;
-            spread = tan(min(_e612, 0.5f));
-            let _e615 = ShadowNoise_u0028_();
-            turn_1 = (_e615 * 6.2831855f);
-            let _e617 = spread;
-            let _e619 = projected[2u];
-            let _e621 = cascadeDepth;
-            let _e623 = cascadeTexel;
-            searchRadius = clamp((((_e617 * _e619) * _e621) / _e623), 1f, 16f);
+            let _e635 = softness;
+            spread = tan(min(_e635, 0.5f));
+            let _e638 = ShadowNoise_u0028_();
+            turn_1 = (_e638 * 6.2831855f);
+            let _e640 = spread;
+            let _e642 = projected[2u];
+            let _e644 = cascadeDepth;
+            let _e646 = cascadeTexel;
+            searchRadius = clamp((((_e640 * _e642) * _e644) / _e646), 1f, 16f);
             blockerSum = 0f;
             blockerCount = 0f;
             i_5 = 0i;
             loop {
-                let _e626 = i_5;
-                if (_e626 < 16i) {
-                    let _e628 = i_5;
-                    param_64 = _e628;
+                let _e649 = i_5;
+                if (_e649 < 16i) {
+                    let _e651 = i_5;
+                    param_64 = _e651;
                     param_65 = 16i;
-                    let _e629 = turn_1;
-                    param_66 = _e629;
-                    let _e630 = VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b((&param_64), (&param_65), (&param_66));
-                    disc = _e630;
-                    let _e631 = bias;
-                    let _e632 = disc;
-                    let _e634 = searchRadius;
-                    let _e638 = receiverSlope;
-                    tapBias = (_e631 + (max(((length(_e632) * _e634) - 1.5f), 0f) * _e638));
-                    let _e641 = uv_4;
-                    let _e642 = disc;
-                    let _e643 = texel_1;
-                    let _e645 = searchRadius;
-                    let _e648 = tileLo;
-                    let _e649 = tileHi;
-                    let _e651 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e641 + ((_e642 * _e643) * _e645)), _e648, _e649), 0f);
-                    occluder_1 = _e651.x;
-                    let _e654 = projected[2u];
-                    let _e655 = tapBias;
-                    let _e657 = occluder_1;
-                    if ((_e654 - _e655) > _e657) {
-                        let _e659 = occluder_1;
-                        let _e660 = blockerSum;
-                        blockerSum = (_e660 + _e659);
-                        let _e662 = blockerCount;
-                        blockerCount = (_e662 + 1f);
+                    let _e652 = turn_1;
+                    param_66 = _e652;
+                    let _e653 = VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b((&param_64), (&param_65), (&param_66));
+                    disc = _e653;
+                    let _e654 = bias;
+                    let _e655 = disc;
+                    let _e657 = searchRadius;
+                    let _e661 = receiverSlope;
+                    tapBias = (_e654 + (max(((length(_e655) * _e657) - 1.5f), 0f) * _e661));
+                    let _e664 = uv_4;
+                    let _e665 = disc;
+                    let _e666 = texel_1;
+                    let _e668 = searchRadius;
+                    let _e671 = tileLo;
+                    let _e672 = tileHi;
+                    let _e674 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e664 + ((_e665 * _e666) * _e668)), _e671, _e672), 0f);
+                    occluder_1 = _e674.x;
+                    let _e677 = projected[2u];
+                    let _e678 = tapBias;
+                    let _e680 = occluder_1;
+                    if ((_e677 - _e678) > _e680) {
+                        let _e682 = occluder_1;
+                        let _e683 = blockerSum;
+                        blockerSum = (_e683 + _e682);
+                        let _e685 = blockerCount;
+                        blockerCount = (_e685 + 1f);
                     }
                     continue;
                 } else {
                     break;
                 }
                 continuing {
-                    let _e664 = i_5;
-                    i_5 = (_e664 + 1i);
+                    let _e687 = i_5;
+                    i_5 = (_e687 + 1i);
                 }
             }
-            let _e666 = blockerCount;
-            if (_e666 <= 0f) {
+            let _e689 = blockerCount;
+            if (_e689 <= 0f) {
                 return 1f;
             }
-            let _e669 = projected[2u];
-            let _e670 = blockerSum;
-            let _e671 = blockerCount;
-            let _e675 = cascadeDepth;
-            gap = (max((_e669 - (_e670 / _e671)), 0f) * _e675);
-            let _e677 = spread;
-            let _e678 = gap;
-            let _e680 = cascadeTexel;
-            radius_2 = clamp(((_e677 * _e678) / _e680), 1f, 16f);
+            let _e692 = projected[2u];
+            let _e693 = blockerSum;
+            let _e694 = blockerCount;
+            let _e698 = cascadeDepth;
+            gap = (max((_e692 - (_e693 / _e694)), 0f) * _e698);
+            let _e700 = spread;
+            let _e701 = gap;
+            let _e703 = cascadeTexel;
+            radius_2 = clamp(((_e700 * _e701) / _e703), 1f, 16f);
             i_6 = 0i;
             loop {
-                let _e683 = i_6;
-                if (_e683 < 16i) {
-                    let _e685 = turn_1;
-                    let _e687 = i_6;
-                    param_67 = _e687;
+                let _e706 = i_6;
+                if (_e706 < 16i) {
+                    let _e708 = turn_1;
+                    let _e710 = i_6;
+                    param_67 = _e710;
                     param_68 = 16i;
-                    param_69 = (_e685 + 1f);
-                    let _e688 = VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b((&param_67), (&param_68), (&param_69));
-                    disc_1 = _e688;
-                    let _e689 = bias;
-                    let _e690 = disc_1;
-                    let _e692 = radius_2;
-                    let _e696 = receiverSlope;
-                    tapBias_1 = (_e689 + (max(((length(_e690) * _e692) - 1.5f), 0f) * _e696));
-                    let _e699 = uv_4;
-                    let _e700 = disc_1;
-                    let _e701 = texel_1;
-                    let _e703 = radius_2;
-                    let _e706 = tileLo;
-                    let _e707 = tileHi;
-                    let _e709 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e699 + ((_e700 * _e701) * _e703)), _e706, _e707), 0f);
-                    occluder_2 = _e709.x;
-                    let _e712 = projected[2u];
-                    let _e713 = tapBias_1;
-                    let _e715 = occluder_2;
-                    let _e718 = lit_2;
-                    lit_2 = (_e718 + select(1f, 0f, ((_e712 - _e713) > _e715)));
+                    param_69 = (_e708 + 1f);
+                    let _e711 = VogelDisc_u0028_i1_u003b_i1_u003b_f1_u003b((&param_67), (&param_68), (&param_69));
+                    disc_1 = _e711;
+                    let _e712 = bias;
+                    let _e713 = disc_1;
+                    let _e715 = radius_2;
+                    let _e719 = receiverSlope;
+                    tapBias_1 = (_e712 + (max(((length(_e713) * _e715) - 1.5f), 0f) * _e719));
+                    let _e722 = uv_4;
+                    let _e723 = disc_1;
+                    let _e724 = texel_1;
+                    let _e726 = radius_2;
+                    let _e729 = tileLo;
+                    let _e730 = tileHi;
+                    let _e732 = textureSampleLevel(shadow_texture_tex, shadow_texture_smp, clamp((_e722 + ((_e723 * _e724) * _e726)), _e729, _e730), 0f);
+                    occluder_2 = _e732.x;
+                    let _e735 = projected[2u];
+                    let _e736 = tapBias_1;
+                    let _e738 = occluder_2;
+                    let _e741 = lit_2;
+                    lit_2 = (_e741 + select(1f, 0f, ((_e735 - _e736) > _e738)));
                     continue;
                 } else {
                     break;
                 }
                 continuing {
-                    let _e720 = i_6;
-                    i_6 = (_e720 + 1i);
+                    let _e743 = i_6;
+                    i_6 = (_e743 + 1i);
                 }
             }
-            let _e722 = lit_2;
-            lit_2 = (_e722 * 0.0625f);
+            let _e745 = lit_2;
+            lit_2 = (_e745 * 0.0625f);
         }
     }
-    let _e724 = lit_2;
-    let _e725 = strength_1;
-    return mix(1f, _e724, clamp(_e725, 0f, 1f));
+    let _e747 = lit_2;
+    let _e748 = strength_1;
+    return mix(1f, _e747, clamp(_e748, 0f, 1f));
 }
 
 fn LightVisibility_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b_i1_u003b(s_3: ptr<function, Surface>, light_2: ptr<function, LightSample>, index: ptr<function, i32>) -> f32 {
@@ -47691,19 +47915,19 @@ fn LightVisibility_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d
     var param_71: LightSample;
     var param_72: i32;
 
-    let _e184 = (*s_3);
-    param_70 = _e184;
-    let _e185 = (*light_2);
-    param_71 = _e185;
-    let _e186 = (*index);
-    param_72 = _e186;
-    let _e187 = ShadowFactor_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b_i1_u003b((&param_70), (&param_71), (&param_72));
-    return _e187;
+    let _e185 = (*s_3);
+    param_70 = _e185;
+    let _e186 = (*light_2);
+    param_71 = _e186;
+    let _e187 = (*index);
+    param_72 = _e187;
+    let _e188 = ShadowFactor_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b_i1_u003b((&param_70), (&param_71), (&param_72));
+    return _e188;
 }
 
 fn LightHasShadow_u0028_i1_u003b(index_1: ptr<function, i32>) -> bool {
-    let _e179 = (*index_1);
-    return (_e179 < 8i);
+    let _e180 = (*index_1);
+    return (_e180 < 8i);
 }
 
 fn PunctualAttenuation_u0028_f1_u003b_f1_u003b(distance_1: ptr<function, f32>, range_4: ptr<function, f32>) -> f32 {
@@ -47711,26 +47935,26 @@ fn PunctualAttenuation_u0028_f1_u003b_f1_u003b(distance_1: ptr<function, f32>, r
     var ratio: f32;
     var window: f32;
 
-    let _e183 = (*distance_1);
     let _e184 = (*distance_1);
-    attenuation = (1f / max((_e183 * _e184), 0.0001f));
-    let _e188 = (*range_4);
-    if (_e188 > 0f) {
-        let _e190 = (*distance_1);
-        let _e191 = (*range_4);
-        ratio = (_e190 / _e191);
-        let _e193 = ratio;
+    let _e185 = (*distance_1);
+    attenuation = (1f / max((_e184 * _e185), 0.0001f));
+    let _e189 = (*range_4);
+    if (_e189 > 0f) {
+        let _e191 = (*distance_1);
+        let _e192 = (*range_4);
+        ratio = (_e191 / _e192);
         let _e194 = ratio;
-        let _e196 = ratio;
-        let _e198 = ratio;
-        window = clamp((1f - (((_e193 * _e194) * _e196) * _e198)), 0f, 1f);
-        let _e202 = window;
+        let _e195 = ratio;
+        let _e197 = ratio;
+        let _e199 = ratio;
+        window = clamp((1f - (((_e194 * _e195) * _e197) * _e199)), 0f, 1f);
         let _e203 = window;
-        let _e205 = attenuation;
-        attenuation = (_e205 * (_e202 * _e203));
+        let _e204 = window;
+        let _e206 = attenuation;
+        attenuation = (_e206 * (_e203 * _e204));
     }
-    let _e207 = attenuation;
-    return _e207;
+    let _e208 = attenuation;
+    return _e208;
 }
 
 fn RectangleClosestPoint_u0028_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b(centre: ptr<function, vec3<f32>>, halfWidth: ptr<function, vec3<f32>>, halfHeight: ptr<function, vec3<f32>>, world_2: ptr<function, vec3<f32>>, mirror: ptr<function, vec3<f32>>) -> vec3<f32> {
@@ -47747,75 +47971,75 @@ fn RectangleClosestPoint_u0028_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b
     var u: f32;
     var v: f32;
 
-    let _e195 = (*halfWidth);
-    let _e196 = (*halfHeight);
-    n_2 = cross(_e195, _e196);
-    let _e198 = n_2;
-    nLen = length(_e198);
-    let _e200 = nLen;
-    if (_e200 < 0.000000000001f) {
-        let _e202 = (*centre);
-        return _e202;
-    }
-    let _e203 = nLen;
-    let _e204 = n_2;
-    n_2 = (_e204 / vec3(_e203));
-    let _e207 = (*centre);
-    let _e208 = (*world_2);
-    toPlane = (_e207 - _e208);
-    let _e210 = (*mirror);
-    let _e211 = n_2;
-    denom = dot(_e210, _e211);
-    let _e213 = denom;
-    if (abs(_e213) < 0.00001f) {
-        let _e216 = toPlane;
-        let _e217 = n_2;
-        let _e218 = toPlane;
-        let _e219 = n_2;
-        onPlane = (_e216 - (_e217 * dot(_e218, _e219)));
-    } else {
-        let _e223 = toPlane;
-        let _e224 = n_2;
-        let _e226 = denom;
-        t_1 = (dot(_e223, _e224) / _e226);
-        let _e228 = t_1;
-        if (_e228 > 0f) {
-            let _e230 = (*mirror);
-            let _e231 = t_1;
-            local_12 = (_e230 * _e231);
+    let _e196 = (*halfWidth);
+    let _e197 = (*halfHeight);
+    n_2 = cross(_e196, _e197);
+    let _e199 = n_2;
+    nLen = length(_e199);
+    let _e201 = nLen;
+    if (_e201 < 0.000000000001f) {
+        let _e203 = (*centre);
+        return _e203;
+    }
+    let _e204 = nLen;
+    let _e205 = n_2;
+    n_2 = (_e205 / vec3(_e204));
+    let _e208 = (*centre);
+    let _e209 = (*world_2);
+    toPlane = (_e208 - _e209);
+    let _e211 = (*mirror);
+    let _e212 = n_2;
+    denom = dot(_e211, _e212);
+    let _e214 = denom;
+    if (abs(_e214) < 0.00001f) {
+        let _e217 = toPlane;
+        let _e218 = n_2;
+        let _e219 = toPlane;
+        let _e220 = n_2;
+        onPlane = (_e217 - (_e218 * dot(_e219, _e220)));
+    } else {
+        let _e224 = toPlane;
+        let _e225 = n_2;
+        let _e227 = denom;
+        t_1 = (dot(_e224, _e225) / _e227);
+        let _e229 = t_1;
+        if (_e229 > 0f) {
+            let _e231 = (*mirror);
+            let _e232 = t_1;
+            local_12 = (_e231 * _e232);
         } else {
-            let _e233 = toPlane;
-            let _e234 = n_2;
-            let _e235 = toPlane;
-            let _e236 = n_2;
-            local_12 = (_e233 - (_e234 * dot(_e235, _e236)));
-        }
-        let _e240 = local_12;
-        onPlane = _e240;
-    }
-    let _e241 = onPlane;
-    let _e242 = toPlane;
-    offset_2 = (_e241 - _e242);
-    let _e244 = (*halfWidth);
+            let _e234 = toPlane;
+            let _e235 = n_2;
+            let _e236 = toPlane;
+            let _e237 = n_2;
+            local_12 = (_e234 - (_e235 * dot(_e236, _e237)));
+        }
+        let _e241 = local_12;
+        onPlane = _e241;
+    }
+    let _e242 = onPlane;
+    let _e243 = toPlane;
+    offset_2 = (_e242 - _e243);
     let _e245 = (*halfWidth);
-    wLen2_ = max(dot(_e244, _e245), 0.000000000001f);
-    let _e248 = (*halfHeight);
+    let _e246 = (*halfWidth);
+    wLen2_ = max(dot(_e245, _e246), 0.000000000001f);
     let _e249 = (*halfHeight);
-    hLen2_ = max(dot(_e248, _e249), 0.000000000001f);
-    let _e252 = offset_2;
-    let _e253 = (*halfWidth);
-    let _e255 = wLen2_;
-    u = clamp((dot(_e252, _e253) / _e255), -1f, 1f);
-    let _e258 = offset_2;
-    let _e259 = (*halfHeight);
-    let _e261 = hLen2_;
-    v = clamp((dot(_e258, _e259) / _e261), -1f, 1f);
-    let _e264 = (*centre);
-    let _e265 = (*halfWidth);
-    let _e266 = u;
-    let _e269 = (*halfHeight);
-    let _e270 = v;
-    return ((_e264 + (_e265 * _e266)) + (_e269 * _e270));
+    let _e250 = (*halfHeight);
+    hLen2_ = max(dot(_e249, _e250), 0.000000000001f);
+    let _e253 = offset_2;
+    let _e254 = (*halfWidth);
+    let _e256 = wLen2_;
+    u = clamp((dot(_e253, _e254) / _e256), -1f, 1f);
+    let _e259 = offset_2;
+    let _e260 = (*halfHeight);
+    let _e262 = hLen2_;
+    v = clamp((dot(_e259, _e260) / _e262), -1f, 1f);
+    let _e265 = (*centre);
+    let _e266 = (*halfWidth);
+    let _e267 = u;
+    let _e270 = (*halfHeight);
+    let _e271 = v;
+    return ((_e265 + (_e266 * _e267)) + (_e270 * _e271));
 }
 
 fn LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b(a_1: ptr<function, vec3<f32>>, b: ptr<function, vec3<f32>>, n_3: ptr<function, vec3<f32>>) -> f32 {
@@ -47826,32 +48050,32 @@ fn LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b(a_1: ptr<function, vec3<f32>>
     var len: f32;
     var local_13: f32;
 
-    let _e187 = (*a_1);
     let _e188 = (*a_1);
-    ua = (_e187 / vec3(max(length(_e188), 0.000000000001f)));
-    let _e193 = (*b);
+    let _e189 = (*a_1);
+    ua = (_e188 / vec3(max(length(_e189), 0.000000000001f)));
     let _e194 = (*b);
-    ub = (_e193 / vec3(max(length(_e194), 0.000000000001f)));
-    let _e199 = ua;
-    let _e200 = ub;
-    angle_1 = acos(clamp(dot(_e199, _e200), -1f, 1f));
-    let _e204 = ua;
-    let _e205 = ub;
-    axis = cross(_e204, _e205);
-    let _e207 = axis;
-    len = length(_e207);
-    let _e209 = len;
-    if (_e209 > 0.000001f) {
-        let _e211 = angle_1;
-        let _e212 = axis;
-        let _e213 = (*n_3);
-        let _e216 = len;
-        local_13 = ((_e211 * dot(_e212, _e213)) / _e216);
+    let _e195 = (*b);
+    ub = (_e194 / vec3(max(length(_e195), 0.000000000001f)));
+    let _e200 = ua;
+    let _e201 = ub;
+    angle_1 = acos(clamp(dot(_e200, _e201), -1f, 1f));
+    let _e205 = ua;
+    let _e206 = ub;
+    axis = cross(_e205, _e206);
+    let _e208 = axis;
+    len = length(_e208);
+    let _e210 = len;
+    if (_e210 > 0.000001f) {
+        let _e212 = angle_1;
+        let _e213 = axis;
+        let _e214 = (*n_3);
+        let _e217 = len;
+        local_13 = ((_e212 * dot(_e213, _e214)) / _e217);
     } else {
         local_13 = 0f;
     }
-    let _e218 = local_13;
-    return _e218;
+    let _e219 = local_13;
+    return _e219;
 }
 
 fn RectangleFormFactor_u0028_vf3_u005b_4_u005d_u003b_vf3_u003b(corners: ptr<function, array<vec3<f32>, 4>>, n_4: ptr<function, vec3<f32>>) -> f32 {
@@ -47882,98 +48106,98 @@ fn RectangleFormFactor_u0028_vf3_u005b_4_u005d_u003b_vf3_u003b(corners: ptr<func
     entry = vec3<f32>(0f, 0f, 0f);
     i_7 = 0i;
     loop {
-        let _e201 = i_7;
-        if (_e201 < 4i) {
-            let _e203 = i_7;
-            let _e205 = (*corners)[_e203];
-            a_2 = _e205;
-            let _e206 = i_7;
-            if (_e206 == 3i) {
+        let _e202 = i_7;
+        if (_e202 < 4i) {
+            let _e204 = i_7;
+            let _e206 = (*corners)[_e204];
+            a_2 = _e206;
+            let _e207 = i_7;
+            if (_e207 == 3i) {
                 local_14 = 0i;
             } else {
-                let _e208 = i_7;
-                local_14 = (_e208 + 1i);
-            }
-            let _e210 = local_14;
-            let _e212 = (*corners)[_e210];
-            b_1 = _e212;
-            let _e213 = a_2;
-            let _e214 = (*n_4);
-            ha = dot(_e213, _e214);
-            let _e216 = b_1;
-            let _e217 = (*n_4);
-            hb = dot(_e216, _e217);
-            let _e219 = ha;
-            let _e220 = hb;
-            d_3 = (_e219 - _e220);
-            let _e222 = a_2;
-            let _e223 = b_1;
-            let _e224 = a_2;
-            let _e226 = d_3;
-            if (abs(_e226) > 0.000000000001f) {
-                let _e229 = ha;
-                let _e230 = d_3;
-                local_15 = (_e229 / _e230);
+                let _e209 = i_7;
+                local_14 = (_e209 + 1i);
+            }
+            let _e211 = local_14;
+            let _e213 = (*corners)[_e211];
+            b_1 = _e213;
+            let _e214 = a_2;
+            let _e215 = (*n_4);
+            ha = dot(_e214, _e215);
+            let _e217 = b_1;
+            let _e218 = (*n_4);
+            hb = dot(_e217, _e218);
+            let _e220 = ha;
+            let _e221 = hb;
+            d_3 = (_e220 - _e221);
+            let _e223 = a_2;
+            let _e224 = b_1;
+            let _e225 = a_2;
+            let _e227 = d_3;
+            if (abs(_e227) > 0.000000000001f) {
+                let _e230 = ha;
+                let _e231 = d_3;
+                local_15 = (_e230 / _e231);
             } else {
                 local_15 = 0f;
             }
-            let _e232 = local_15;
-            q = (_e222 + ((_e223 - _e224) * _e232));
-            let _e235 = ha;
-            aAbove = (_e235 > 0f);
-            let _e237 = hb;
-            bAbove = (_e237 > 0f);
-            let _e239 = aAbove;
-            let _e240 = bAbove;
-            if (_e239 || _e240) {
-                let _e242 = aAbove;
-                let _e243 = a_2;
-                let _e244 = q;
-                let _e247 = bAbove;
-                let _e248 = b_1;
-                let _e249 = q;
-                param_73 = select(_e244, _e243, vec3(_e242));
-                param_74 = select(_e249, _e248, vec3(_e247));
-                let _e252 = (*n_4);
-                param_75 = _e252;
-                let _e253 = LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b((&param_73), (&param_74), (&param_75));
-                local_16 = _e253;
+            let _e233 = local_15;
+            q = (_e223 + ((_e224 - _e225) * _e233));
+            let _e236 = ha;
+            aAbove = (_e236 > 0f);
+            let _e238 = hb;
+            bAbove = (_e238 > 0f);
+            let _e240 = aAbove;
+            let _e241 = bAbove;
+            if (_e240 || _e241) {
+                let _e243 = aAbove;
+                let _e244 = a_2;
+                let _e245 = q;
+                let _e248 = bAbove;
+                let _e249 = b_1;
+                let _e250 = q;
+                param_73 = select(_e245, _e244, vec3(_e243));
+                param_74 = select(_e250, _e249, vec3(_e248));
+                let _e253 = (*n_4);
+                param_75 = _e253;
+                let _e254 = LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b((&param_73), (&param_74), (&param_75));
+                local_16 = _e254;
             } else {
                 local_16 = 0f;
             }
-            let _e254 = local_16;
-            let _e255 = total;
-            total = (_e255 + _e254);
-            let _e257 = aAbove;
-            let _e258 = bAbove;
-            let _e261 = q;
-            let _e262 = exit;
-            exit = select(_e262, _e261, vec3((_e257 && !(_e258))));
-            let _e265 = aAbove;
-            let _e267 = bAbove;
-            let _e269 = q;
-            let _e270 = entry;
-            entry = select(_e270, _e269, vec3((!(_e265) && _e267)));
+            let _e255 = local_16;
+            let _e256 = total;
+            total = (_e256 + _e255);
+            let _e258 = aAbove;
+            let _e259 = bAbove;
+            let _e262 = q;
+            let _e263 = exit;
+            exit = select(_e263, _e262, vec3((_e258 && !(_e259))));
+            let _e266 = aAbove;
+            let _e268 = bAbove;
+            let _e270 = q;
+            let _e271 = entry;
+            entry = select(_e271, _e270, vec3((!(_e266) && _e268)));
             continue;
         } else {
             break;
         }
         continuing {
-            let _e273 = i_7;
-            i_7 = (_e273 + 1i);
+            let _e274 = i_7;
+            i_7 = (_e274 + 1i);
         }
     }
-    let _e275 = exit;
-    param_76 = _e275;
-    let _e276 = entry;
-    param_77 = _e276;
-    let _e277 = (*n_4);
-    param_78 = _e277;
-    let _e278 = LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b((&param_76), (&param_77), (&param_78));
-    let _e279 = total;
-    total = (_e279 + _e278);
-    let _e281 = total;
-    return max((-(_e281) * 0.5f), 0f);
+    let _e276 = exit;
+    param_76 = _e276;
+    let _e277 = entry;
+    param_77 = _e277;
+    let _e278 = (*n_4);
+    param_78 = _e278;
+    let _e279 = LambertEdge_u0028_vf3_u003b_vf3_u003b_vf3_u003b((&param_76), (&param_77), (&param_78));
+    let _e280 = total;
+    total = (_e280 + _e279);
+    let _e282 = total;
+    return max((-(_e282) * 0.5f), 0f);
 }
 
 fn LightListLane_u0028_vf4_u003b_i1_u003b(four: ptr<function, vec4<f32>>, slot_1: ptr<function, i32>) -> f32 {
@@ -47982,91 +48206,91 @@ fn LightListLane_u0028_vf4_u003b_i1_u003b(four: ptr<function, vec4<f32>>, slot_1
     var local_18: f32;
     var local_19: f32;
 
-    let _e184 = (*slot_1);
     let _e185 = (*slot_1);
-    lane = (_e184 - ((_e185 / 4i) * 4i));
-    let _e189 = lane;
-    if (_e189 == 0i) {
-        let _e192 = (*four)[0u];
-        local_17 = _e192;
-    } else {
-        let _e193 = lane;
-        if (_e193 == 1i) {
-            let _e196 = (*four)[1u];
-            local_18 = _e196;
+    let _e186 = (*slot_1);
+    lane = (_e185 - ((_e186 / 4i) * 4i));
+    let _e190 = lane;
+    if (_e190 == 0i) {
+        let _e193 = (*four)[0u];
+        local_17 = _e193;
+    } else {
+        let _e194 = lane;
+        if (_e194 == 1i) {
+            let _e197 = (*four)[1u];
+            local_18 = _e197;
         } else {
-            let _e197 = lane;
-            if (_e197 == 2i) {
-                let _e200 = (*four)[2u];
-                local_19 = _e200;
+            let _e198 = lane;
+            if (_e198 == 2i) {
+                let _e201 = (*four)[2u];
+                local_19 = _e201;
             } else {
-                let _e202 = (*four)[3u];
-                local_19 = _e202;
+                let _e203 = (*four)[3u];
+                local_19 = _e203;
             }
-            let _e203 = local_19;
-            local_18 = _e203;
+            let _e204 = local_19;
+            local_18 = _e204;
         }
-        let _e204 = local_18;
-        local_17 = _e204;
+        let _e205 = local_18;
+        local_17 = _e205;
     }
-    let _e205 = local_17;
-    return _e205;
+    let _e206 = local_17;
+    return _e206;
 }
 
 fn LightListScale_u0028_i1_u003b(slot_2: ptr<function, i32>) -> f32 {
     var param_79: vec4<f32>;
     var param_80: i32;
 
-    let _e181 = (*slot_2);
-    let _e185 = light_list_info.scales[(_e181 / 4i)];
-    param_79 = _e185;
-    let _e186 = (*slot_2);
-    param_80 = _e186;
-    let _e187 = LightListLane_u0028_vf4_u003b_i1_u003b((&param_79), (&param_80));
-    return _e187;
+    let _e182 = (*slot_2);
+    let _e186 = light_list_info.scales[(_e182 / 4i)];
+    param_79 = _e186;
+    let _e187 = (*slot_2);
+    param_80 = _e187;
+    let _e188 = LightListLane_u0028_vf4_u003b_i1_u003b((&param_79), (&param_80));
+    return _e188;
 }
 
 fn InSlots_u0028_f1_u003b(row: ptr<function, f32>) -> bool {
     var a_3: vec4<f32>;
     var b_2: vec4<f32>;
 
-    let _e183 = light_list_info.slot_rows[0i];
-    let _e184 = (*row);
-    a_3 = abs((_e183 - vec4(_e184)));
-    let _e190 = light_list_info.slot_rows[1i];
-    let _e191 = (*row);
-    b_2 = abs((_e190 - vec4(_e191)));
-    let _e196 = a_3[0u];
-    let _e198 = a_3[1u];
-    let _e201 = a_3[2u];
-    let _e203 = a_3[3u];
-    let _e207 = b_2[0u];
-    let _e209 = b_2[1u];
-    let _e212 = b_2[2u];
-    let _e214 = b_2[3u];
-    return (min(min(min(_e196, _e198), min(_e201, _e203)), min(min(_e207, _e209), min(_e212, _e214))) < 0.5f);
+    let _e184 = light_list_info.slot_rows[0i];
+    let _e185 = (*row);
+    a_3 = abs((_e184 - vec4(_e185)));
+    let _e191 = light_list_info.slot_rows[1i];
+    let _e192 = (*row);
+    b_2 = abs((_e191 - vec4(_e192)));
+    let _e197 = a_3[0u];
+    let _e199 = a_3[1u];
+    let _e202 = a_3[2u];
+    let _e204 = a_3[3u];
+    let _e208 = b_2[0u];
+    let _e210 = b_2[1u];
+    let _e213 = b_2[2u];
+    let _e215 = b_2[3u];
+    return (min(min(min(_e197, _e199), min(_e202, _e204)), min(min(_e208, _e210), min(_e213, _e215))) < 0.5f);
 }
 
 fn LightListRow_u0028_i1_u003b(slot_3: ptr<function, i32>) -> f32 {
     var param_81: vec4<f32>;
     var param_82: i32;
 
-    let _e181 = (*slot_3);
-    let _e185 = light_list_info.indices[(_e181 / 4i)];
-    param_81 = _e185;
-    let _e186 = (*slot_3);
-    param_82 = _e186;
-    let _e187 = LightListLane_u0028_vf4_u003b_i1_u003b((&param_81), (&param_82));
-    return _e187;
+    let _e182 = (*slot_3);
+    let _e186 = light_list_info.indices[(_e182 / 4i)];
+    param_81 = _e186;
+    let _e187 = (*slot_3);
+    param_82 = _e187;
+    let _e188 = LightListLane_u0028_vf4_u003b_i1_u003b((&param_81), (&param_82));
+    return _e188;
 }
 
 fn LightListTexel_u0028_f1_u003b_f1_u003b(texel_2: ptr<function, f32>, row_1: ptr<function, f32>) -> vec4<f32> {
-    let _e180 = (*texel_2);
-    let _e184 = light_list_info.list[1u];
-    let _e186 = (*row_1);
-    let _e190 = light_list_info.list[2u];
-    let _e193 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>(((_e180 + 0.5f) * _e184), ((_e186 + 0.5f) * _e190)), 0f);
-    return _e193;
+    let _e181 = (*texel_2);
+    let _e185 = light_list_info.list[1u];
+    let _e187 = (*row_1);
+    let _e191 = light_list_info.list[2u];
+    let _e194 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>(((_e181 + 0.5f) * _e185), ((_e187 + 0.5f) * _e191)), 0f);
+    return _e194;
 }
 
 fn ClusterRow_u0028_i1_u003b(slot_4: ptr<function, i32>) -> f32 {
@@ -48080,35 +48304,35 @@ fn ClusterRow_u0028_i1_u003b(slot_4: ptr<function, i32>) -> f32 {
     var param_85: vec4<f32>;
     var param_86: i32;
 
-    let _e188 = g_cluster_offset;
-    let _e189 = (*slot_4);
-    entry_1 = (_e188 + f32(_e189));
-    let _e192 = entry_1;
-    row_2 = floor((_e192 / 16f));
-    let _e195 = entry_1;
-    let _e196 = row_2;
-    within = (_e195 - (_e196 * 16f));
-    let _e199 = within;
-    texel_3 = floor((_e199 / 4f));
-    let _e204 = light_list_info.cluster_depth[3u];
-    let _e205 = row_2;
-    let _e207 = texel_3;
-    param_83 = _e207;
-    param_84 = (_e204 + _e205);
-    let _e208 = LightListTexel_u0028_f1_u003b_f1_u003b((&param_83), (&param_84));
-    four_1 = _e208;
-    let _e209 = within;
-    let _e210 = texel_3;
-    let _e215 = four_1;
-    param_85 = _e215;
-    param_86 = i32(((_e209 - (_e210 * 4f)) + 0.5f));
-    let _e216 = LightListLane_u0028_vf4_u003b_i1_u003b((&param_85), (&param_86));
-    return _e216;
+    let _e189 = g_cluster_offset;
+    let _e190 = (*slot_4);
+    entry_1 = (_e189 + f32(_e190));
+    let _e193 = entry_1;
+    row_2 = floor((_e193 / 16f));
+    let _e196 = entry_1;
+    let _e197 = row_2;
+    within = (_e196 - (_e197 * 16f));
+    let _e200 = within;
+    texel_3 = floor((_e200 / 4f));
+    let _e205 = light_list_info.cluster_depth[3u];
+    let _e206 = row_2;
+    let _e208 = texel_3;
+    param_83 = _e208;
+    param_84 = (_e205 + _e206);
+    let _e209 = LightListTexel_u0028_f1_u003b_f1_u003b((&param_83), (&param_84));
+    four_1 = _e209;
+    let _e210 = within;
+    let _e211 = texel_3;
+    let _e216 = four_1;
+    param_85 = _e216;
+    param_86 = i32(((_e210 - (_e211 * 4f)) + 0.5f));
+    let _e217 = LightListLane_u0028_vf4_u003b_i1_u003b((&param_85), (&param_86));
+    return _e217;
 }
 
 fn Clustered_u0028_() -> bool {
-    let _e180 = light_list_info.cluster_grid[3u];
-    return (_e180 > 0.5f);
+    let _e181 = light_list_info.cluster_grid[3u];
+    return (_e181 > 0.5f);
 }
 
 fn SampleLight_u0028_i1_u003b_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(index_2: ptr<function, i32>, s_4: ptr<function, Surface>) -> LightSample {
@@ -48164,264 +48388,264 @@ fn SampleLight_u0028_i1_u003b_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_
 
     light_3.integrated = 0f;
     light_3.ltc = vec3<f32>(0f, 0f, 0f);
-    let _e231 = (*index_2);
-    if (_e231 < 8i) {
-        let _e233 = (*index_2);
-        let _e236 = frag_info.light_position[_e233];
-        position = _e236;
-        let _e237 = (*index_2);
-        let _e240 = frag_info.light_color[_e237];
-        color_1 = _e240;
-        let _e241 = (*index_2);
-        let _e244 = frag_info.light_direction[_e241];
-        direction = _e244;
-        let _e245 = (*index_2);
-        let _e248 = frag_info.light_cone[_e245];
-        cone = _e248;
-    } else {
-        let _e249 = (*index_2);
-        slot_5 = (_e249 - 8i);
-        let _e251 = Clustered_u0028_();
-        clustered = _e251;
-        let _e252 = clustered;
-        if _e252 {
-            let _e253 = slot_5;
-            param_87 = _e253;
-            let _e254 = ClusterRow_u0028_i1_u003b((&param_87));
-            local_20 = _e254;
+    let _e232 = (*index_2);
+    if (_e232 < 8i) {
+        let _e234 = (*index_2);
+        let _e237 = frag_info.light_position[_e234];
+        position = _e237;
+        let _e238 = (*index_2);
+        let _e241 = frag_info.light_color[_e238];
+        color_1 = _e241;
+        let _e242 = (*index_2);
+        let _e245 = frag_info.light_direction[_e242];
+        direction = _e245;
+        let _e246 = (*index_2);
+        let _e249 = frag_info.light_cone[_e246];
+        cone = _e249;
+    } else {
+        let _e250 = (*index_2);
+        slot_5 = (_e250 - 8i);
+        let _e252 = Clustered_u0028_();
+        clustered = _e252;
+        let _e253 = clustered;
+        if _e253 {
+            let _e254 = slot_5;
+            param_87 = _e254;
+            let _e255 = ClusterRow_u0028_i1_u003b((&param_87));
+            local_20 = _e255;
         } else {
-            let _e255 = slot_5;
-            param_88 = _e255;
-            let _e256 = LightListRow_u0028_i1_u003b((&param_88));
-            local_20 = _e256;
-        }
-        let _e257 = local_20;
-        listRow = _e257;
-        let _e258 = listRow;
-        let _e262 = light_list_info.list[2u];
-        v_1 = ((_e258 + 0.5f) * _e262);
-        let _e266 = light_list_info.list[1u];
-        u_1 = _e266;
-        let _e267 = u_1;
-        let _e269 = v_1;
-        let _e271 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((0.5f * _e267), _e269), 0f);
-        position = _e271;
-        let _e272 = u_1;
-        let _e274 = v_1;
-        let _e276 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((1.5f * _e272), _e274), 0f);
-        color_1 = _e276;
-        let _e277 = u_1;
-        let _e279 = v_1;
-        let _e281 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((2.5f * _e277), _e279), 0f);
-        direction = _e281;
-        let _e282 = u_1;
-        let _e284 = v_1;
-        let _e286 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((3.5f * _e282), _e284), 0f);
-        cone = _e286;
-        let _e287 = clustered;
-        if _e287 {
-            let _e288 = listRow;
-            param_89 = _e288;
-            let _e289 = InSlots_u0028_f1_u003b((&param_89));
-            local_21 = select(1f, 0f, _e289);
+            let _e256 = slot_5;
+            param_88 = _e256;
+            let _e257 = LightListRow_u0028_i1_u003b((&param_88));
+            local_20 = _e257;
+        }
+        let _e258 = local_20;
+        listRow = _e258;
+        let _e259 = listRow;
+        let _e263 = light_list_info.list[2u];
+        v_1 = ((_e259 + 0.5f) * _e263);
+        let _e267 = light_list_info.list[1u];
+        u_1 = _e267;
+        let _e268 = u_1;
+        let _e270 = v_1;
+        let _e272 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((0.5f * _e268), _e270), 0f);
+        position = _e272;
+        let _e273 = u_1;
+        let _e275 = v_1;
+        let _e277 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((1.5f * _e273), _e275), 0f);
+        color_1 = _e277;
+        let _e278 = u_1;
+        let _e280 = v_1;
+        let _e282 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((2.5f * _e278), _e280), 0f);
+        direction = _e282;
+        let _e283 = u_1;
+        let _e285 = v_1;
+        let _e287 = textureSampleLevel(light_list_texture_tex, light_list_texture_smp, vec2<f32>((3.5f * _e283), _e285), 0f);
+        cone = _e287;
+        let _e288 = clustered;
+        if _e288 {
+            let _e289 = listRow;
+            param_89 = _e289;
+            let _e290 = InSlots_u0028_f1_u003b((&param_89));
+            local_21 = select(1f, 0f, _e290);
         } else {
-            let _e291 = slot_5;
-            param_90 = _e291;
-            let _e292 = LightListScale_u0028_i1_u003b((&param_90));
-            local_21 = _e292;
-        }
-        let _e293 = local_21;
-        let _e295 = color_1[3u];
-        color_1[3u] = (_e295 * _e293);
-    }
-    let _e299 = position[3u];
-    type_39 = _e299;
-    let _e300 = type_39;
-    if (_e300 > 2.5f) {
-        let _e302 = direction;
-        halfWidth_1 = _e302.xyz;
-        let _e304 = cone;
-        halfHeight_1 = _e304.xyz;
-        let _e306 = position;
-        let _e308 = v_world_position_1;
-        toCentre = (_e306.xyz - _e308);
-        let _e310 = toCentre;
-        let _e311 = halfWidth_1;
-        let _e313 = halfHeight_1;
-        corners_1[0i] = ((_e310 - _e311) - _e313);
-        let _e316 = toCentre;
-        let _e317 = halfWidth_1;
-        let _e319 = halfHeight_1;
-        corners_1[1i] = ((_e316 + _e317) - _e319);
-        let _e322 = toCentre;
-        let _e323 = halfWidth_1;
-        let _e325 = halfHeight_1;
-        corners_1[2i] = ((_e322 + _e323) + _e325);
-        let _e328 = toCentre;
-        let _e329 = halfWidth_1;
-        let _e331 = halfHeight_1;
-        corners_1[3i] = ((_e328 - _e329) + _e331);
-        let _e334 = toCentre;
-        let _e335 = halfWidth_1;
-        let _e336 = halfHeight_1;
-        behind = (dot(_e334, cross(_e335, _e336)) >= 0f);
-        let _e340 = behind;
-        if _e340 {
+            let _e292 = slot_5;
+            param_90 = _e292;
+            let _e293 = LightListScale_u0028_i1_u003b((&param_90));
+            local_21 = _e293;
+        }
+        let _e294 = local_21;
+        let _e296 = color_1[3u];
+        color_1[3u] = (_e296 * _e294);
+    }
+    let _e300 = position[3u];
+    type_39 = _e300;
+    let _e301 = type_39;
+    if (_e301 > 2.5f) {
+        let _e303 = direction;
+        halfWidth_1 = _e303.xyz;
+        let _e305 = cone;
+        halfHeight_1 = _e305.xyz;
+        let _e307 = position;
+        let _e309 = v_world_position_1;
+        toCentre = (_e307.xyz - _e309);
+        let _e311 = toCentre;
+        let _e312 = halfWidth_1;
+        let _e314 = halfHeight_1;
+        corners_1[0i] = ((_e311 - _e312) - _e314);
+        let _e317 = toCentre;
+        let _e318 = halfWidth_1;
+        let _e320 = halfHeight_1;
+        corners_1[1i] = ((_e317 + _e318) - _e320);
+        let _e323 = toCentre;
+        let _e324 = halfWidth_1;
+        let _e326 = halfHeight_1;
+        corners_1[2i] = ((_e323 + _e324) + _e326);
+        let _e329 = toCentre;
+        let _e330 = halfWidth_1;
+        let _e332 = halfHeight_1;
+        corners_1[3i] = ((_e329 - _e330) + _e332);
+        let _e335 = toCentre;
+        let _e336 = halfWidth_1;
+        let _e337 = halfHeight_1;
+        behind = (dot(_e335, cross(_e336, _e337)) >= 0f);
+        let _e341 = behind;
+        if _e341 {
             local_22 = 0f;
         } else {
-            let _e341 = corners_1;
-            param_91 = _e341;
-            let _e343 = (*s_4).n;
-            param_92 = _e343;
-            let _e344 = RectangleFormFactor_u0028_vf3_u005b_4_u005d_u003b_vf3_u003b((&param_91), (&param_92));
-            local_22 = _e344;
-        }
-        let _e345 = local_22;
-        formFactor = _e345;
-        let _e346 = halfWidth_1;
-        let _e347 = halfHeight_1;
-        area = (length(cross(_e346, _e347)) * 4f);
-        let _e351 = area;
-        if (_e351 > 0.000000001f) {
-            let _e353 = area;
-            local_23 = (1f / _e353);
+            let _e342 = corners_1;
+            param_91 = _e342;
+            let _e344 = (*s_4).n;
+            param_92 = _e344;
+            let _e345 = RectangleFormFactor_u0028_vf3_u005b_4_u005d_u003b_vf3_u003b((&param_91), (&param_92));
+            local_22 = _e345;
+        }
+        let _e346 = local_22;
+        formFactor = _e346;
+        let _e347 = halfWidth_1;
+        let _e348 = halfHeight_1;
+        area = (length(cross(_e347, _e348)) * 4f);
+        let _e352 = area;
+        if (_e352 > 0.000000001f) {
+            let _e354 = area;
+            local_23 = (1f / _e354);
         } else {
             local_23 = 0f;
         }
-        let _e355 = local_23;
-        radiance = _e355;
-        let _e356 = toCentre;
-        distance_2 = length(_e356);
-        let _e359 = direction[3u];
-        if (_e359 > 0f) {
-            let _e361 = distance_2;
-            let _e363 = direction[3u];
-            ratio_1 = (_e361 / _e363);
-            let _e365 = ratio_1;
+        let _e356 = local_23;
+        radiance = _e356;
+        let _e357 = toCentre;
+        distance_2 = length(_e357);
+        let _e360 = direction[3u];
+        if (_e360 > 0f) {
+            let _e362 = distance_2;
+            let _e364 = direction[3u];
+            ratio_1 = (_e362 / _e364);
             let _e366 = ratio_1;
-            let _e368 = ratio_1;
-            let _e370 = ratio_1;
-            window_1 = clamp((1f - (((_e365 * _e366) * _e368) * _e370)), 0f, 1f);
-            let _e374 = window_1;
+            let _e367 = ratio_1;
+            let _e369 = ratio_1;
+            let _e371 = ratio_1;
+            window_1 = clamp((1f - (((_e366 * _e367) * _e369) * _e371)), 0f, 1f);
             let _e375 = window_1;
-            let _e377 = radiance;
-            radiance = (_e377 * (_e374 * _e375));
-        }
-        let _e380 = (*s_4).v;
-        let _e383 = (*s_4).n;
-        mirror_1 = reflect(-(_e380), _e383);
-        let _e385 = position;
-        param_93 = _e385.xyz;
-        let _e387 = halfWidth_1;
-        param_94 = _e387;
-        let _e388 = halfHeight_1;
-        param_95 = _e388;
-        let _e389 = v_world_position_1;
-        param_96 = _e389;
-        let _e390 = mirror_1;
-        param_97 = _e390;
-        let _e391 = RectangleClosestPoint_u0028_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b((&param_93), (&param_94), (&param_95), (&param_96), (&param_97));
-        representative = _e391;
-        let _e392 = representative;
-        let _e393 = v_world_position_1;
-        toPoint = (_e392 - _e393);
-        let _e395 = toPoint;
-        pointDistance = length(_e395);
-        let _e397 = pointDistance;
-        if (_e397 > 0.000001f) {
-            let _e399 = toPoint;
-            let _e400 = pointDistance;
-            local_24 = (_e399 / vec3(_e400));
+            let _e376 = window_1;
+            let _e378 = radiance;
+            radiance = (_e378 * (_e375 * _e376));
+        }
+        let _e381 = (*s_4).v;
+        let _e384 = (*s_4).n;
+        mirror_1 = reflect(-(_e381), _e384);
+        let _e386 = position;
+        param_93 = _e386.xyz;
+        let _e388 = halfWidth_1;
+        param_94 = _e388;
+        let _e389 = halfHeight_1;
+        param_95 = _e389;
+        let _e390 = v_world_position_1;
+        param_96 = _e390;
+        let _e391 = mirror_1;
+        param_97 = _e391;
+        let _e392 = RectangleClosestPoint_u0028_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b_vf3_u003b((&param_93), (&param_94), (&param_95), (&param_96), (&param_97));
+        representative = _e392;
+        let _e393 = representative;
+        let _e394 = v_world_position_1;
+        toPoint = (_e393 - _e394);
+        let _e396 = toPoint;
+        pointDistance = length(_e396);
+        let _e398 = pointDistance;
+        if (_e398 > 0.000001f) {
+            let _e400 = toPoint;
+            let _e401 = pointDistance;
+            local_24 = (_e400 / vec3(_e401));
         } else {
-            let _e404 = (*s_4).n;
-            local_24 = _e404;
-        }
-        let _e405 = local_24;
-        light_3.l = _e405;
-        let _e408 = light_3.l;
-        let _e410 = (*s_4).v;
-        light_3.h = normalize((_e408 + _e410));
-        let _e414 = formFactor;
-        light_3.n_dot_l = _e414;
-        let _e417 = (*s_4).n;
-        let _e419 = light_3.h;
-        light_3.n_dot_h = max(dot(_e417, _e419), 0f);
-        let _e424 = (*s_4).v;
-        let _e426 = light_3.h;
-        light_3.v_dot_h = max(dot(_e424, _e426), 0f);
-        let _e430 = color_1;
-        let _e433 = color_1[3u];
-        let _e435 = radiance;
-        light_3.radiance = ((_e430.xyz * _e433) * _e435);
-        let _e438 = light_3;
-        return _e438;
-    }
-    let _e439 = direction;
-    aim = normalize(_e439.xyz);
+            let _e405 = (*s_4).n;
+            local_24 = _e405;
+        }
+        let _e406 = local_24;
+        light_3.l = _e406;
+        let _e409 = light_3.l;
+        let _e411 = (*s_4).v;
+        light_3.h = normalize((_e409 + _e411));
+        let _e415 = formFactor;
+        light_3.n_dot_l = _e415;
+        let _e418 = (*s_4).n;
+        let _e420 = light_3.h;
+        light_3.n_dot_h = max(dot(_e418, _e420), 0f);
+        let _e425 = (*s_4).v;
+        let _e427 = light_3.h;
+        light_3.v_dot_h = max(dot(_e425, _e427), 0f);
+        let _e431 = color_1;
+        let _e434 = color_1[3u];
+        let _e436 = radiance;
+        light_3.radiance = ((_e431.xyz * _e434) * _e436);
+        let _e439 = light_3;
+        return _e439;
+    }
+    let _e440 = direction;
+    aim = normalize(_e440.xyz);
     attenuation_1 = 1f;
-    let _e442 = type_39;
-    if (_e442 < 0.5f) {
-        let _e444 = aim;
-        light_3.l = -(_e444);
-    } else {
-        let _e447 = position;
-        let _e449 = v_world_position_1;
-        toLight_1 = (_e447.xyz - _e449);
-        let _e451 = toLight_1;
-        distance_3 = length(_e451);
-        let _e453 = distance_3;
-        if (_e453 < 0.000001f) {
-            let _e456 = (*s_4).n;
-            light_3.l = _e456;
-            let _e459 = (*s_4).n;
-            light_3.h = _e459;
+    let _e443 = type_39;
+    if (_e443 < 0.5f) {
+        let _e445 = aim;
+        light_3.l = -(_e445);
+    } else {
+        let _e448 = position;
+        let _e450 = v_world_position_1;
+        toLight_1 = (_e448.xyz - _e450);
+        let _e452 = toLight_1;
+        distance_3 = length(_e452);
+        let _e454 = distance_3;
+        if (_e454 < 0.000001f) {
+            let _e457 = (*s_4).n;
+            light_3.l = _e457;
+            let _e460 = (*s_4).n;
+            light_3.h = _e460;
             light_3.radiance = vec3<f32>(0f, 0f, 0f);
             light_3.n_dot_l = 0f;
             light_3.n_dot_h = 0f;
             light_3.v_dot_h = 0f;
-            let _e465 = light_3;
-            return _e465;
-        }
-        let _e466 = toLight_1;
-        let _e467 = distance_3;
-        light_3.l = (_e466 / vec3(_e467));
-        let _e471 = distance_3;
-        param_98 = _e471;
-        let _e473 = direction[3u];
-        param_99 = _e473;
-        let _e474 = PunctualAttenuation_u0028_f1_u003b_f1_u003b((&param_98), (&param_99));
-        attenuation_1 = _e474;
-        let _e475 = type_39;
-        if (_e475 > 1.5f) {
-            let _e477 = aim;
-            let _e479 = light_3.l;
-            cosAngle = dot(_e477, -(_e479));
-            let _e482 = cosAngle;
-            let _e484 = cone[1u];
-            let _e487 = cone[0u];
-            let _e489 = cone[1u];
-            let _e493 = attenuation_1;
-            attenuation_1 = (_e493 * clamp(((_e482 - _e484) / (_e487 - _e489)), 0f, 1f));
-        }
-    }
-    let _e496 = light_3.l;
-    let _e498 = (*s_4).v;
-    light_3.h = normalize((_e496 + _e498));
-    let _e503 = (*s_4).n;
-    let _e505 = light_3.l;
-    light_3.n_dot_l = max(dot(_e503, _e505), 0f);
-    let _e510 = (*s_4).n;
-    let _e512 = light_3.h;
-    light_3.n_dot_h = max(dot(_e510, _e512), 0f);
-    let _e517 = (*s_4).v;
-    let _e519 = light_3.h;
-    light_3.v_dot_h = max(dot(_e517, _e519), 0f);
-    let _e523 = color_1;
-    let _e526 = color_1[3u];
-    let _e528 = attenuation_1;
-    light_3.radiance = ((_e523.xyz * _e526) * _e528);
-    let _e531 = light_3;
-    return _e531;
+            let _e466 = light_3;
+            return _e466;
+        }
+        let _e467 = toLight_1;
+        let _e468 = distance_3;
+        light_3.l = (_e467 / vec3(_e468));
+        let _e472 = distance_3;
+        param_98 = _e472;
+        let _e474 = direction[3u];
+        param_99 = _e474;
+        let _e475 = PunctualAttenuation_u0028_f1_u003b_f1_u003b((&param_98), (&param_99));
+        attenuation_1 = _e475;
+        let _e476 = type_39;
+        if (_e476 > 1.5f) {
+            let _e478 = aim;
+            let _e480 = light_3.l;
+            cosAngle = dot(_e478, -(_e480));
+            let _e483 = cosAngle;
+            let _e485 = cone[1u];
+            let _e488 = cone[0u];
+            let _e490 = cone[1u];
+            let _e494 = attenuation_1;
+            attenuation_1 = (_e494 * clamp(((_e483 - _e485) / (_e488 - _e490)), 0f, 1f));
+        }
+    }
+    let _e497 = light_3.l;
+    let _e499 = (*s_4).v;
+    light_3.h = normalize((_e497 + _e499));
+    let _e504 = (*s_4).n;
+    let _e506 = light_3.l;
+    light_3.n_dot_l = max(dot(_e504, _e506), 0f);
+    let _e511 = (*s_4).n;
+    let _e513 = light_3.h;
+    light_3.n_dot_h = max(dot(_e511, _e513), 0f);
+    let _e518 = (*s_4).v;
+    let _e520 = light_3.h;
+    light_3.v_dot_h = max(dot(_e518, _e520), 0f);
+    let _e524 = color_1;
+    let _e527 = color_1[3u];
+    let _e529 = attenuation_1;
+    light_3.radiance = ((_e524.xyz * _e527) * _e529);
+    let _e532 = light_3;
+    return _e532;
 }
 
 fn FindCluster_u0028_vf3_u003b(world_3: ptr<function, vec3<f32>>) {
@@ -48439,58 +48663,58 @@ fn FindCluster_u0028_vf3_u003b(world_3: ptr<function, vec3<f32>>) {
     var param_100: f32;
     var param_101: f32;
 
-    let _e193 = light_list_info.cluster_view_projection;
-    let _e194 = (*world_3);
-    clip_1 = (_e193 * vec4<f32>(_e194.x, _e194.y, _e194.z, 1f));
-    let _e200 = clip_1;
-    let _e203 = clip_1[3u];
-    ndc_1 = (_e200.xy / vec2(max(_e203, 0.000001f)));
-    let _e208 = light_list_info.cluster_grid;
-    grid = _e208.xyz;
-    let _e212 = light_list_info.cluster_depth[0u];
-    near_1 = _e212;
-    let _e214 = ndc_1[0u];
-    let _e218 = grid[0u];
-    let _e222 = grid[0u];
-    tx = clamp(floor((((_e214 * 0.5f) + 0.5f) * _e218)), 0f, (_e222 - 1f));
-    let _e226 = ndc_1[1u];
-    let _e230 = grid[1u];
-    let _e234 = grid[1u];
-    ty = clamp(floor((((_e226 * 0.5f) + 0.5f) * _e230)), 0f, (_e234 - 1f));
-    let _e238 = clip_1[3u];
-    let _e239 = near_1;
-    if (_e238 <= _e239) {
+    let _e194 = light_list_info.cluster_view_projection;
+    let _e195 = (*world_3);
+    clip_1 = (_e194 * vec4<f32>(_e195.x, _e195.y, _e195.z, 1f));
+    let _e201 = clip_1;
+    let _e204 = clip_1[3u];
+    ndc_1 = (_e201.xy / vec2(max(_e204, 0.000001f)));
+    let _e209 = light_list_info.cluster_grid;
+    grid = _e209.xyz;
+    let _e213 = light_list_info.cluster_depth[0u];
+    near_1 = _e213;
+    let _e215 = ndc_1[0u];
+    let _e219 = grid[0u];
+    let _e223 = grid[0u];
+    tx = clamp(floor((((_e215 * 0.5f) + 0.5f) * _e219)), 0f, (_e223 - 1f));
+    let _e227 = ndc_1[1u];
+    let _e231 = grid[1u];
+    let _e235 = grid[1u];
+    ty = clamp(floor((((_e227 * 0.5f) + 0.5f) * _e231)), 0f, (_e235 - 1f));
+    let _e239 = clip_1[3u];
+    let _e240 = near_1;
+    if (_e239 <= _e240) {
         local_25 = 0f;
     } else {
-        let _e242 = clip_1[3u];
-        let _e243 = near_1;
-        let _e248 = light_list_info.cluster_depth[1u];
-        let _e252 = grid[2u];
-        local_25 = clamp(floor((log((_e242 / _e243)) * _e248)), 0f, (_e252 - 1f));
-    }
-    let _e255 = local_25;
-    tz = _e255;
-    let _e256 = tx;
-    let _e257 = ty;
-    let _e259 = grid[0u];
-    let _e262 = tz;
-    let _e264 = grid[0u];
-    let _e267 = grid[1u];
-    cell = ((_e256 + (_e257 * _e259)) + ((_e262 * _e264) * _e267));
-    let _e270 = cell;
-    row_3 = floor((_e270 / 4f));
-    let _e273 = cell;
-    let _e274 = row_3;
-    let _e279 = light_list_info.cluster_depth[2u];
-    let _e280 = row_3;
-    param_100 = (_e273 - (_e274 * 4f));
-    param_101 = (_e279 + _e280);
-    let _e282 = LightListTexel_u0028_f1_u003b_f1_u003b((&param_100), (&param_101));
-    header = _e282;
-    let _e284 = header[0u];
-    g_cluster_offset = _e284;
-    let _e286 = header[1u];
-    g_cluster_count = _e286;
+        let _e243 = clip_1[3u];
+        let _e244 = near_1;
+        let _e249 = light_list_info.cluster_depth[1u];
+        let _e253 = grid[2u];
+        local_25 = clamp(floor((log((_e243 / _e244)) * _e249)), 0f, (_e253 - 1f));
+    }
+    let _e256 = local_25;
+    tz = _e256;
+    let _e257 = tx;
+    let _e258 = ty;
+    let _e260 = grid[0u];
+    let _e263 = tz;
+    let _e265 = grid[0u];
+    let _e268 = grid[1u];
+    cell = ((_e257 + (_e258 * _e260)) + ((_e263 * _e265) * _e268));
+    let _e271 = cell;
+    row_3 = floor((_e271 / 4f));
+    let _e274 = cell;
+    let _e275 = row_3;
+    let _e280 = light_list_info.cluster_depth[2u];
+    let _e281 = row_3;
+    param_100 = (_e274 - (_e275 * 4f));
+    param_101 = (_e280 + _e281);
+    let _e283 = LightListTexel_u0028_f1_u003b_f1_u003b((&param_100), (&param_101));
+    header = _e283;
+    let _e285 = header[0u];
+    g_cluster_offset = _e285;
+    let _e287 = header[1u];
+    g_cluster_count = _e287;
     return;
 }
 
@@ -48498,19 +48722,19 @@ fn LightCount_u0028_() -> i32 {
     var tail: f32;
     var param_102: vec3<f32>;
 
-    let _e182 = light_list_info.list[0u];
-    tail = _e182;
-    let _e183 = Clustered_u0028_();
-    if _e183 {
-        let _e184 = v_world_position_1;
-        param_102 = _e184;
+    let _e183 = light_list_info.list[0u];
+    tail = _e183;
+    let _e184 = Clustered_u0028_();
+    if _e184 {
+        let _e185 = v_world_position_1;
+        param_102 = _e185;
         FindCluster_u0028_vf3_u003b((&param_102));
-        let _e185 = g_cluster_count;
-        tail = _e185;
+        let _e186 = g_cluster_count;
+        tail = _e186;
     }
-    let _e188 = frag_info.frame_params[1u];
-    let _e192 = tail;
-    return (clamp(i32((_e188 + 0.5f)), 0i, 8i) + clamp(i32((_e192 + 0.5f)), 0i, 24i));
+    let _e189 = frag_info.frame_params[1u];
+    let _e193 = tail;
+    return (clamp(i32((_e189 + 0.5f)), 0i, 8i) + clamp(i32((_e193 + 0.5f)), 0i, 24i));
 }
 
 fn AccumulateLights_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b(s_5: ptr<function, Surface>) -> vec3<f32> {
@@ -48533,116 +48757,116 @@ fn AccumulateLights_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002
     var param_113: LightSample;
 
     total_1 = vec3<f32>(0f, 0f, 0f);
-    let _e196 = LightCount_u0028_();
-    count_1 = _e196;
+    let _e197 = LightCount_u0028_();
+    count_1 = _e197;
     i_8 = 0i;
     loop {
-        let _e197 = i_8;
-        if (_e197 < 32i) {
-            let _e199 = i_8;
-            let _e200 = count_1;
-            if (_e199 >= _e200) {
+        let _e198 = i_8;
+        if (_e198 < 32i) {
+            let _e200 = i_8;
+            let _e201 = count_1;
+            if (_e200 >= _e201) {
                 break;
             }
-            let _e202 = i_8;
-            param_103 = _e202;
-            let _e203 = (*s_5);
-            param_104 = _e203;
-            let _e204 = SampleLight_u0028_i1_u003b_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_103), (&param_104));
-            light_4 = _e204;
-            let _e206 = light_4.n_dot_l;
-            if (_e206 <= 0f) {
+            let _e203 = i_8;
+            param_103 = _e203;
+            let _e204 = (*s_5);
+            param_104 = _e204;
+            let _e205 = SampleLight_u0028_i1_u003b_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_103), (&param_104));
+            light_4 = _e205;
+            let _e207 = light_4.n_dot_l;
+            if (_e207 <= 0f) {
                 continue;
             }
             light_transmittance = vec3<f32>(1f, 1f, 1f);
-            let _e208 = i_8;
-            param_105 = _e208;
-            let _e209 = LightHasShadow_u0028_i1_u003b((&param_105));
-            if _e209 {
-                let _e210 = (*s_5);
-                param_106 = _e210;
-                let _e211 = light_4;
-                param_107 = _e211;
-                let _e212 = i_8;
-                param_108 = _e212;
-                let _e213 = LightVisibility_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b_i1_u003b((&param_106), (&param_107), (&param_108));
-                let _e214 = v_world_position_1;
-                param_109 = _e214;
-                let _e216 = (*s_5).n;
-                param_110 = _e216;
-                let _e217 = i_8;
-                param_111 = _e217;
-                let _e218 = PointShadowFactor_u0028_vf3_u003b_vf3_u003b_i1_u003b((&param_109), (&param_110), (&param_111));
-                local_26 = (_e213 * _e218);
+            let _e209 = i_8;
+            param_105 = _e209;
+            let _e210 = LightHasShadow_u0028_i1_u003b((&param_105));
+            if _e210 {
+                let _e211 = (*s_5);
+                param_106 = _e211;
+                let _e212 = light_4;
+                param_107 = _e212;
+                let _e213 = i_8;
+                param_108 = _e213;
+                let _e214 = LightVisibility_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b_i1_u003b((&param_106), (&param_107), (&param_108));
+                let _e215 = v_world_position_1;
+                param_109 = _e215;
+                let _e217 = (*s_5).n;
+                param_110 = _e217;
+                let _e218 = i_8;
+                param_111 = _e218;
+                let _e219 = PointShadowFactor_u0028_vf3_u003b_vf3_u003b_i1_u003b((&param_109), (&param_110), (&param_111));
+                local_26 = (_e214 * _e219);
             } else {
                 local_26 = 1f;
             }
-            let _e220 = local_26;
-            visibility = _e220;
-            let _e221 = visibility;
-            if (_e221 <= 0f) {
+            let _e221 = local_26;
+            visibility = _e221;
+            let _e222 = visibility;
+            if (_e222 <= 0f) {
                 continue;
             }
-            let _e223 = (*s_5);
-            param_112 = _e223;
-            let _e224 = light_4;
-            param_113 = _e224;
-            let _e225 = ShadeLight_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b((&param_112), (&param_113));
-            let _e227 = light_4.radiance;
-            let _e230 = light_4.n_dot_l;
-            let _e232 = visibility;
-            let _e234 = light_transmittance;
-            let _e236 = total_1;
-            total_1 = (_e236 + ((((_e225 * _e227) * _e230) * _e232) * _e234));
+            let _e224 = (*s_5);
+            param_112 = _e224;
+            let _e225 = light_4;
+            param_113 = _e225;
+            let _e226 = ShadeLight_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_struct_u002d_LightSample_u002d_vf3_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf31_u003b((&param_112), (&param_113));
+            let _e228 = light_4.radiance;
+            let _e231 = light_4.n_dot_l;
+            let _e233 = visibility;
+            let _e235 = light_transmittance;
+            let _e237 = total_1;
+            total_1 = (_e237 + ((((_e226 * _e228) * _e231) * _e233) * _e235));
             continue;
         } else {
             break;
         }
         continuing {
-            let _e238 = i_8;
-            i_8 = (_e238 + 1i);
+            let _e239 = i_8;
+            i_8 = (_e239 + 1i);
         }
     }
-    let _e240 = total_1;
-    return _e240;
+    let _e241 = total_1;
+    return _e241;
 }
 
 fn ImpostorRight_u0028_vf3_u003b(d_4: ptr<function, vec3<f32>>) -> vec3<f32> {
     var up: vec3<f32>;
 
-    let _e181 = (*d_4)[1u];
-    up = select(vec3<f32>(0f, 1f, 0f), vec3<f32>(0f, 0f, -1f), vec3((abs(_e181) > 0.999f)));
-    let _e186 = up;
-    let _e187 = (*d_4);
-    return normalize(cross(_e186, _e187));
+    let _e182 = (*d_4)[1u];
+    up = select(vec3<f32>(0f, 1f, 0f), vec3<f32>(0f, 0f, -1f), vec3((abs(_e182) > 0.999f)));
+    let _e187 = up;
+    let _e188 = (*d_4);
+    return normalize(cross(_e187, _e188));
 }
 
 fn ImpostorDecode_u0028_vf2_u003b(uv_5: ptr<function, vec2<f32>>) -> vec3<f32> {
     var p_1: vec2<f32>;
-    var y_1: f32;
+    var y_2: f32;
     var s_6: vec2<f32>;
     var folded: vec2<f32>;
     var xz: vec2<f32>;
 
-    let _e184 = (*uv_5);
-    p_1 = ((_e184 * 2f) - vec2<f32>(1f, 1f));
-    let _e188 = p_1[0u];
-    let _e192 = p_1[1u];
-    y_1 = ((1f - abs(_e188)) - abs(_e192));
-    let _e196 = p_1[0u];
-    let _e200 = p_1[1u];
-    s_6 = vec2<f32>(select(-1f, 1f, (_e196 >= 0f)), select(-1f, 1f, (_e200 >= 0f)));
-    let _e204 = p_1;
-    let _e208 = s_6;
-    folded = ((vec2<f32>(1f, 1f) - abs(_e204.yx)) * _e208);
-    let _e210 = y_1;
-    let _e212 = p_1;
-    let _e213 = folded;
-    xz = select(_e213, _e212, vec2((_e210 >= 0f)));
-    let _e217 = xz[0u];
-    let _e218 = y_1;
-    let _e220 = xz[1u];
-    return normalize(vec3<f32>(_e217, _e218, _e220));
+    let _e185 = (*uv_5);
+    p_1 = ((_e185 * 2f) - vec2<f32>(1f, 1f));
+    let _e189 = p_1[0u];
+    let _e193 = p_1[1u];
+    y_2 = ((1f - abs(_e189)) - abs(_e193));
+    let _e197 = p_1[0u];
+    let _e201 = p_1[1u];
+    s_6 = vec2<f32>(select(-1f, 1f, (_e197 >= 0f)), select(-1f, 1f, (_e201 >= 0f)));
+    let _e205 = p_1;
+    let _e209 = s_6;
+    folded = ((vec2<f32>(1f, 1f) - abs(_e205.yx)) * _e209);
+    let _e211 = y_2;
+    let _e213 = p_1;
+    let _e214 = folded;
+    xz = select(_e214, _e213, vec2((_e211 >= 0f)));
+    let _e218 = xz[0u];
+    let _e219 = y_2;
+    let _e221 = xz[1u];
+    return normalize(vec3<f32>(_e218, _e219, _e221));
 }
 
 fn ImpostorViewUv_u0028_vf2_u003b_vf3_u003b(cell_1: ptr<function, vec2<f32>>, offset_3: ptr<function, vec3<f32>>) -> vec2<f32> {
@@ -48653,25 +48877,25 @@ fn ImpostorViewUv_u0028_vf2_u003b_vf3_u003b(cell_1: ptr<function, vec2<f32>>, of
     var up_1: vec3<f32>;
     var local_27: vec2<f32>;
 
-    let _e186 = (*cell_1);
-    param_114 = (_e186 / vec2(7f));
-    let _e189 = ImpostorDecode_u0028_vf2_u003b((&param_114));
-    d_5 = _e189;
-    let _e190 = d_5;
-    param_115 = _e190;
-    let _e191 = ImpostorRight_u0028_vf3_u003b((&param_115));
-    right = _e191;
-    let _e192 = d_5;
-    let _e193 = right;
-    up_1 = cross(_e192, _e193);
-    let _e195 = (*offset_3);
-    let _e196 = right;
-    let _e200 = (*offset_3);
-    let _e201 = up_1;
-    local_27 = vec2<f32>(((dot(_e195, _e196) * 0.5f) + 0.5f), (0.5f - (dot(_e200, _e201) * 0.5f)));
-    let _e206 = (*cell_1);
-    let _e207 = local_27;
-    return ((_e206 + clamp(_e207, vec2<f32>(0f, 0f), vec2<f32>(1f, 1f))) / vec2(8f));
+    let _e187 = (*cell_1);
+    param_114 = (_e187 / vec2(7f));
+    let _e190 = ImpostorDecode_u0028_vf2_u003b((&param_114));
+    d_5 = _e190;
+    let _e191 = d_5;
+    param_115 = _e191;
+    let _e192 = ImpostorRight_u0028_vf3_u003b((&param_115));
+    right = _e192;
+    let _e193 = d_5;
+    let _e194 = right;
+    up_1 = cross(_e193, _e194);
+    let _e196 = (*offset_3);
+    let _e197 = right;
+    let _e201 = (*offset_3);
+    let _e202 = up_1;
+    local_27 = vec2<f32>(((dot(_e196, _e197) * 0.5f) + 0.5f), (0.5f - (dot(_e201, _e202) * 0.5f)));
+    let _e207 = (*cell_1);
+    let _e208 = local_27;
+    return ((_e207 + clamp(_e208, vec2<f32>(0f, 0f), vec2<f32>(1f, 1f))) / vec2(8f));
 }
 
 fn ImpostorEncode_u0028_vf3_u003b(d_6: ptr<function, vec3<f32>>) -> vec2<f32> {
@@ -48680,44 +48904,44 @@ fn ImpostorEncode_u0028_vf3_u003b(d_6: ptr<function, vec3<f32>>) -> vec2<f32> {
     var s_7: vec2<f32>;
     var folded_1: vec2<f32>;
 
-    let _e183 = (*d_6);
-    a_4 = abs(_e183);
-    let _e185 = (*d_6);
-    let _e188 = a_4[0u];
-    let _e190 = a_4[1u];
-    let _e193 = a_4[2u];
-    p_2 = (_e185.xz / vec2(max(((_e188 + _e190) + _e193), 0.00000001f)));
-    let _e199 = p_2[0u];
-    let _e203 = p_2[1u];
-    s_7 = vec2<f32>(select(-1f, 1f, (_e199 >= 0f)), select(-1f, 1f, (_e203 >= 0f)));
-    let _e207 = p_2;
-    let _e211 = s_7;
-    folded_1 = ((vec2<f32>(1f, 1f) - abs(_e207.yx)) * _e211);
-    let _e214 = (*d_6)[1u];
-    let _e216 = p_2;
-    let _e217 = folded_1;
-    return ((select(_e217, _e216, vec2((_e214 >= 0f))) * 0.5f) + vec2<f32>(0.5f, 0.5f));
+    let _e184 = (*d_6);
+    a_4 = abs(_e184);
+    let _e186 = (*d_6);
+    let _e189 = a_4[0u];
+    let _e191 = a_4[1u];
+    let _e194 = a_4[2u];
+    p_2 = (_e186.xz / vec2(max(((_e189 + _e191) + _e194), 0.00000001f)));
+    let _e200 = p_2[0u];
+    let _e204 = p_2[1u];
+    s_7 = vec2<f32>(select(-1f, 1f, (_e200 >= 0f)), select(-1f, 1f, (_e204 >= 0f)));
+    let _e208 = p_2;
+    let _e212 = s_7;
+    folded_1 = ((vec2<f32>(1f, 1f) - abs(_e208.yx)) * _e212);
+    let _e215 = (*d_6)[1u];
+    let _e217 = p_2;
+    let _e218 = folded_1;
+    return ((select(_e218, _e217, vec2((_e215 >= 0f))) * 0.5f) + vec2<f32>(0.5f, 0.5f));
 }
 
 fn TowardsEye_u0028_() -> vec3<f32> {
     var local_28: vec3<f32>;
 
-    let _e179 = Orthographic_u0028_();
-    if _e179 {
-        let _e181 = fog_info.forward;
-        local_28 = -(_e181.xyz);
+    let _e180 = Orthographic_u0028_();
+    if _e180 {
+        let _e182 = fog_info.forward;
+        local_28 = -(_e182.xyz);
     } else {
-        let _e185 = fog_info.eye;
-        let _e187 = v_world_position_1;
-        local_28 = normalize((_e185.xyz - _e187));
+        let _e186 = fog_info.eye;
+        let _e188 = v_world_position_1;
+        local_28 = normalize((_e186.xyz - _e188));
     }
-    let _e190 = local_28;
-    return _e190;
+    let _e191 = local_28;
+    return _e191;
 }
 
 fn MaterialLodBias_u0028_() -> f32 {
-    let _e180 = frag_info.target_origin[1u];
-    return _e180;
+    let _e181 = frag_info.target_origin[1u];
+    return _e181;
 }
 
 fn ReadSurface_u0028_() -> Surface {
@@ -48730,89 +48954,89 @@ fn ReadSurface_u0028_() -> Surface {
     var anchored: vec3<f32>;
     var noise_1: f32;
 
-    let _e186 = v_texcoord_1;
-    let _e187 = MaterialLodBias_u0028_();
-    let _e188 = textureSampleBias(base_color_texture_tex, base_color_texture_smp, _e186, _e187);
-    texel_4 = _e188;
-    let _e189 = texel_4;
-    param_116 = _e189.xyz;
-    let _e191 = SrgbToLinear_u0028_vf3_u003b((&param_116));
-    let _e193 = frag_info.base_color;
-    param_117 = _e193.xyz;
-    let _e195 = SrgbToLinear_u0028_vf3_u003b((&param_117));
-    let _e197 = v_color_1;
-    s_8.albedo = ((_e191 * _e195) * _e197.xyz);
-    let _e202 = texel_4[3u];
-    let _e205 = frag_info.base_color[3u];
-    let _e208 = v_color_1[3u];
-    s_8.alpha = ((_e202 * _e205) * _e208);
-    let _e212 = s_8.albedo;
-    g_albedo = _e212;
-    let _e215 = frag_info.material2_[0u];
-    cutoff = _e215;
-    let _e216 = cutoff;
-    if (_e216 > 1f) {
-        let _e218 = cutoff;
-        edge = (_e218 - 1f);
-        let _e221 = s_8.alpha;
-        let _e222 = edge;
-        let _e225 = s_8.alpha;
-        let _e226 = fwidth(_e225);
-        s_8.alpha = clamp((((_e221 - _e222) / max(_e226, 0.0001f)) + 0.5f), 0f, 1f);
-    } else {
-        let _e232 = cutoff;
-        if (_e232 >= 0f) {
-            let _e235 = s_8.alpha;
-            let _e236 = cutoff;
-            if (_e235 < _e236) {
+    let _e187 = v_texcoord_1;
+    let _e188 = MaterialLodBias_u0028_();
+    let _e189 = textureSampleBias(base_color_texture_tex, base_color_texture_smp, _e187, _e188);
+    texel_4 = _e189;
+    let _e190 = texel_4;
+    param_116 = _e190.xyz;
+    let _e192 = SrgbToLinear_u0028_vf3_u003b((&param_116));
+    let _e194 = frag_info.base_color;
+    param_117 = _e194.xyz;
+    let _e196 = SrgbToLinear_u0028_vf3_u003b((&param_117));
+    let _e198 = v_color_1;
+    s_8.albedo = ((_e192 * _e196) * _e198.xyz);
+    let _e203 = texel_4[3u];
+    let _e206 = frag_info.base_color[3u];
+    let _e209 = v_color_1[3u];
+    s_8.alpha = ((_e203 * _e206) * _e209);
+    let _e213 = s_8.albedo;
+    g_albedo = _e213;
+    let _e216 = frag_info.material2_[0u];
+    cutoff = _e216;
+    let _e217 = cutoff;
+    if (_e217 > 1f) {
+        let _e219 = cutoff;
+        edge = (_e219 - 1f);
+        let _e222 = s_8.alpha;
+        let _e223 = edge;
+        let _e226 = s_8.alpha;
+        let _e227 = fwidth(_e226);
+        s_8.alpha = clamp((((_e222 - _e223) / max(_e227, 0.0001f)) + 0.5f), 0f, 1f);
+    } else {
+        let _e233 = cutoff;
+        if (_e233 >= 0f) {
+            let _e236 = s_8.alpha;
+            let _e237 = cutoff;
+            if (_e236 < _e237) {
                 discard;
             }
             s_8.alpha = 1f;
         } else {
-            let _e239 = cutoff;
-            if (_e239 < -1.5f) {
-                let _e241 = v_world_position_1;
-                anchored = floor((_e241 * 16f));
-                let _e244 = anchored;
-                noise_1 = fract((sin(dot(_e244, vec3<f32>(12.9898f, 78.233f, 37.719f))) * 43758.547f));
-                let _e250 = s_8.alpha;
-                let _e251 = noise_1;
-                if (_e250 < _e251) {
+            let _e240 = cutoff;
+            if (_e240 < -1.5f) {
+                let _e242 = v_world_position_1;
+                anchored = floor((_e242 * 16f));
+                let _e245 = anchored;
+                noise_1 = fract((sin(dot(_e245, vec3<f32>(12.9898f, 78.233f, 37.719f))) * 43758.547f));
+                let _e251 = s_8.alpha;
+                let _e252 = noise_1;
+                if (_e251 < _e252) {
                     discard;
                 }
             }
         }
     }
-    let _e253 = cutoff;
-    let _e255 = cutoff;
-    g_premultiply = ((_e253 < 0f) && (_e255 > -0.75f));
-    let _e258 = v_normal_1;
-    s_8.n = normalize(_e258);
-    let _e261 = gl_FrontFacing_1;
-    if !(_e261) {
-        let _e264 = s_8.n;
-        s_8.n = -(_e264);
-    }
-    let _e267 = TowardsEye_u0028_();
-    s_8.v = _e267;
-    let _e270 = s_8.n;
-    let _e272 = s_8.v;
-    s_8.n_dot_v = max(dot(_e270, _e272), 0.0001f);
-    let _e278 = frag_info.material[0u];
-    s_8.metallic = clamp(_e278, 0f, 1f);
-    let _e283 = frag_info.material[1u];
-    s_8.roughness = clamp(_e283, 0.02f, 1f);
-    let _e287 = frag_info.ambient_ground;
-    let _e290 = frag_info.ambient_sky;
-    let _e294 = s_8.n[1u];
-    let _e301 = frag_info.material[2u];
-    s_8.ambient = (mix(_e287.xyz, _e290.xyz, vec3(((_e294 * 0.5f) + 0.5f))) * _e301);
-    let _e306 = frag_info.frame_params[0u];
-    s_8.exposure = max(_e306, 0f);
+    let _e254 = cutoff;
+    let _e256 = cutoff;
+    g_premultiply = ((_e254 < 0f) && (_e256 > -0.75f));
+    let _e259 = v_normal_1;
+    s_8.n = normalize(_e259);
+    let _e262 = gl_FrontFacing_1;
+    if !(_e262) {
+        let _e265 = s_8.n;
+        s_8.n = -(_e265);
+    }
+    let _e268 = TowardsEye_u0028_();
+    s_8.v = _e268;
+    let _e271 = s_8.n;
+    let _e273 = s_8.v;
+    s_8.n_dot_v = max(dot(_e271, _e273), 0.0001f);
+    let _e279 = frag_info.material[0u];
+    s_8.metallic = clamp(_e279, 0f, 1f);
+    let _e284 = frag_info.material[1u];
+    s_8.roughness = clamp(_e284, 0.02f, 1f);
+    let _e288 = frag_info.ambient_ground;
+    let _e291 = frag_info.ambient_sky;
+    let _e295 = s_8.n[1u];
+    let _e302 = frag_info.material[2u];
+    s_8.ambient = (mix(_e288.xyz, _e291.xyz, vec3(((_e295 * 0.5f) + 0.5f))) * _e302);
+    let _e307 = frag_info.frame_params[0u];
+    s_8.exposure = max(_e307, 0f);
     s_8.occlusion = 1f;
     s_8.emissive = vec3<f32>(0f, 0f, 0f);
-    let _e311 = s_8;
-    return _e311;
+    let _e312 = s_8;
+    return _e312;
 }
 
 fn main_1() {
@@ -48874,186 +49098,186 @@ fn main_1() {
     g_cluster_offset = 0f;
     g_cluster_count = 0f;
     light_transmittance = vec3<f32>(1f, 1f, 1f);
-    let _e227 = ReadSurface_u0028_();
-    s_9 = _e227;
-    let _e228 = v_color_1;
-    d_7 = normalize(_e228.xyz);
-    let _e231 = d_7;
-    param_118 = _e231;
-    let _e232 = ImpostorRight_u0028_vf3_u003b((&param_118));
-    right_1 = _e232;
-    let _e233 = d_7;
-    let _e234 = right_1;
-    up_2 = cross(_e233, _e234);
-    let _e236 = right_1;
-    let _e238 = v_texcoord_1[0u];
-    let _e242 = up_2;
-    let _e244 = v_texcoord_1[1u];
-    offset_4 = ((_e236 * ((_e238 * 2f) - 1f)) + (_e242 * (1f - (_e244 * 2f))));
-    let _e249 = d_7;
-    param_119 = _e249;
-    let _e250 = ImpostorEncode_u0028_vf3_u003b((&param_119));
-    g = (_e250 * 7f);
-    let _e252 = g;
-    base = clamp(floor(_e252), vec2<f32>(0f, 0f), vec2<f32>(6f, 6f));
-    let _e255 = g;
-    let _e256 = base;
-    f = (_e255 - _e256);
-    let _e259 = f[0u];
-    let _e261 = f[1u];
-    lower = ((_e259 + _e261) < 1f);
-    let _e264 = lower;
-    if _e264 {
-        let _e265 = base;
-        local_29 = _e265;
-    } else {
+    let _e228 = ReadSurface_u0028_();
+    s_9 = _e228;
+    let _e229 = v_color_1;
+    d_7 = normalize(_e229.xyz);
+    let _e232 = d_7;
+    param_118 = _e232;
+    let _e233 = ImpostorRight_u0028_vf3_u003b((&param_118));
+    right_1 = _e233;
+    let _e234 = d_7;
+    let _e235 = right_1;
+    up_2 = cross(_e234, _e235);
+    let _e237 = right_1;
+    let _e239 = v_texcoord_1[0u];
+    let _e243 = up_2;
+    let _e245 = v_texcoord_1[1u];
+    offset_4 = ((_e237 * ((_e239 * 2f) - 1f)) + (_e243 * (1f - (_e245 * 2f))));
+    let _e250 = d_7;
+    param_119 = _e250;
+    let _e251 = ImpostorEncode_u0028_vf3_u003b((&param_119));
+    g = (_e251 * 7f);
+    let _e253 = g;
+    base = clamp(floor(_e253), vec2<f32>(0f, 0f), vec2<f32>(6f, 6f));
+    let _e256 = g;
+    let _e257 = base;
+    f = (_e256 - _e257);
+    let _e260 = f[0u];
+    let _e262 = f[1u];
+    lower = ((_e260 + _e262) < 1f);
+    let _e265 = lower;
+    if _e265 {
         let _e266 = base;
-        local_29 = (_e266 + vec2<f32>(1f, 1f));
-    }
-    let _e268 = local_29;
-    c0_ = _e268;
-    let _e269 = base;
-    c1_ = (_e269 + vec2<f32>(1f, 0f));
-    let _e271 = base;
-    c2_ = (_e271 + vec2<f32>(0f, 1f));
-    let _e273 = lower;
-    if _e273 {
-        let _e275 = f[0u];
-        let _e278 = f[1u];
-        let _e281 = f[0u];
-        let _e283 = f[1u];
-        local_30 = vec3<f32>(((1f - _e275) - _e278), _e281, _e283);
-    } else {
-        let _e286 = f[0u];
-        let _e288 = f[1u];
-        let _e292 = f[1u];
-        let _e295 = f[0u];
-        local_30 = vec3<f32>(((_e286 + _e288) - 1f), (1f - _e292), (1f - _e295));
-    }
-    let _e298 = local_30;
-    w = _e298;
-    let _e299 = c0_;
-    param_120 = _e299;
-    let _e300 = offset_4;
-    param_121 = _e300;
-    let _e301 = ImpostorViewUv_u0028_vf2_u003b_vf3_u003b((&param_120), (&param_121));
-    uv0_ = _e301;
-    let _e302 = c1_;
-    param_122 = _e302;
-    let _e303 = offset_4;
-    param_123 = _e303;
-    let _e304 = ImpostorViewUv_u0028_vf2_u003b_vf3_u003b((&param_122), (&param_123));
-    uv1_ = _e304;
-    let _e305 = c2_;
-    param_124 = _e305;
-    let _e306 = offset_4;
-    param_125 = _e306;
-    let _e307 = ImpostorViewUv_u0028_vf2_u003b_vf3_u003b((&param_124), (&param_125));
-    uv2_ = _e307;
-    let _e308 = uv0_;
-    let _e309 = textureSampleLevel(base_color_texture_tex, base_color_texture_smp, _e308, 0f);
-    a0_ = _e309;
-    let _e310 = uv1_;
-    let _e311 = textureSampleLevel(base_color_texture_tex, base_color_texture_smp, _e310, 0f);
-    a1_ = _e311;
-    let _e312 = uv2_;
-    let _e313 = textureSampleLevel(base_color_texture_tex, base_color_texture_smp, _e312, 0f);
-    a2_ = _e313;
-    let _e314 = uv0_;
-    let _e315 = textureSampleLevel(normal_texture_tex, normal_texture_smp, _e314, 0f);
-    n0_ = _e315;
-    let _e316 = uv1_;
-    let _e317 = textureSampleLevel(normal_texture_tex, normal_texture_smp, _e316, 0f);
-    n1_ = _e317;
-    let _e318 = uv2_;
-    let _e319 = textureSampleLevel(normal_texture_tex, normal_texture_smp, _e318, 0f);
-    n2_ = _e319;
-    let _e320 = w;
-    let _e322 = a0_[3u];
-    let _e324 = a1_[3u];
-    let _e326 = a2_[3u];
-    wa = (_e320 * vec3<f32>(_e322, _e324, _e326));
-    let _e330 = wa[0u];
-    let _e332 = wa[1u];
-    let _e335 = wa[2u];
-    alpha_3 = ((_e330 + _e332) + _e335);
-    let _e337 = alpha_3;
-    if (_e337 < 0.5f) {
+        local_29 = _e266;
+    } else {
+        let _e267 = base;
+        local_29 = (_e267 + vec2<f32>(1f, 1f));
+    }
+    let _e269 = local_29;
+    c0_ = _e269;
+    let _e270 = base;
+    c1_ = (_e270 + vec2<f32>(1f, 0f));
+    let _e272 = base;
+    c2_ = (_e272 + vec2<f32>(0f, 1f));
+    let _e274 = lower;
+    if _e274 {
+        let _e276 = f[0u];
+        let _e279 = f[1u];
+        let _e282 = f[0u];
+        let _e284 = f[1u];
+        local_30 = vec3<f32>(((1f - _e276) - _e279), _e282, _e284);
+    } else {
+        let _e287 = f[0u];
+        let _e289 = f[1u];
+        let _e293 = f[1u];
+        let _e296 = f[0u];
+        local_30 = vec3<f32>(((_e287 + _e289) - 1f), (1f - _e293), (1f - _e296));
+    }
+    let _e299 = local_30;
+    w = _e299;
+    let _e300 = c0_;
+    param_120 = _e300;
+    let _e301 = offset_4;
+    param_121 = _e301;
+    let _e302 = ImpostorViewUv_u0028_vf2_u003b_vf3_u003b((&param_120), (&param_121));
+    uv0_ = _e302;
+    let _e303 = c1_;
+    param_122 = _e303;
+    let _e304 = offset_4;
+    param_123 = _e304;
+    let _e305 = ImpostorViewUv_u0028_vf2_u003b_vf3_u003b((&param_122), (&param_123));
+    uv1_ = _e305;
+    let _e306 = c2_;
+    param_124 = _e306;
+    let _e307 = offset_4;
+    param_125 = _e307;
+    let _e308 = ImpostorViewUv_u0028_vf2_u003b_vf3_u003b((&param_124), (&param_125));
+    uv2_ = _e308;
+    let _e309 = uv0_;
+    let _e310 = textureSampleLevel(base_color_texture_tex, base_color_texture_smp, _e309, 0f);
+    a0_ = _e310;
+    let _e311 = uv1_;
+    let _e312 = textureSampleLevel(base_color_texture_tex, base_color_texture_smp, _e311, 0f);
+    a1_ = _e312;
+    let _e313 = uv2_;
+    let _e314 = textureSampleLevel(base_color_texture_tex, base_color_texture_smp, _e313, 0f);
+    a2_ = _e314;
+    let _e315 = uv0_;
+    let _e316 = textureSampleLevel(normal_texture_tex, normal_texture_smp, _e315, 0f);
+    n0_ = _e316;
+    let _e317 = uv1_;
+    let _e318 = textureSampleLevel(normal_texture_tex, normal_texture_smp, _e317, 0f);
+    n1_ = _e318;
+    let _e319 = uv2_;
+    let _e320 = textureSampleLevel(normal_texture_tex, normal_texture_smp, _e319, 0f);
+    n2_ = _e320;
+    let _e321 = w;
+    let _e323 = a0_[3u];
+    let _e325 = a1_[3u];
+    let _e327 = a2_[3u];
+    wa = (_e321 * vec3<f32>(_e323, _e325, _e327));
+    let _e331 = wa[0u];
+    let _e333 = wa[1u];
+    let _e336 = wa[2u];
+    alpha_3 = ((_e331 + _e333) + _e336);
+    let _e338 = alpha_3;
+    if (_e338 < 0.5f) {
         discard;
     }
-    let _e339 = a0_;
-    let _e342 = wa[0u];
-    let _e344 = a1_;
-    let _e347 = wa[1u];
-    let _e350 = a2_;
-    let _e353 = wa[2u];
-    let _e356 = alpha_3;
-    srgb_1 = ((((_e339.xyz * _e342) + (_e344.xyz * _e347)) + (_e350.xyz * _e353)) / vec3(_e356));
-    let _e359 = n0_;
-    let _e364 = wa[0u];
-    let _e366 = n1_;
-    let _e371 = wa[1u];
-    let _e374 = n2_;
-    let _e379 = wa[2u];
-    local_31 = (((((_e359.xyz * 2f) - vec3<f32>(1f, 1f, 1f)) * _e364) + (((_e366.xyz * 2f) - vec3<f32>(1f, 1f, 1f)) * _e371)) + (((_e374.xyz * 2f) - vec3<f32>(1f, 1f, 1f)) * _e379));
-    let _e382 = local_31;
+    let _e340 = a0_;
+    let _e343 = wa[0u];
+    let _e345 = a1_;
+    let _e348 = wa[1u];
+    let _e351 = a2_;
+    let _e354 = wa[2u];
+    let _e357 = alpha_3;
+    srgb_1 = ((((_e340.xyz * _e343) + (_e345.xyz * _e348)) + (_e351.xyz * _e354)) / vec3(_e357));
+    let _e360 = n0_;
+    let _e365 = wa[0u];
+    let _e367 = n1_;
+    let _e372 = wa[1u];
+    let _e375 = n2_;
+    let _e380 = wa[2u];
+    local_31 = (((((_e360.xyz * 2f) - vec3<f32>(1f, 1f, 1f)) * _e365) + (((_e367.xyz * 2f) - vec3<f32>(1f, 1f, 1f)) * _e372)) + (((_e375.xyz * 2f) - vec3<f32>(1f, 1f, 1f)) * _e380));
     let _e383 = local_31;
-    let _e386 = local_31;
-    let _e387 = d_7;
-    local_31 = normalize(select(_e387, _e386, vec3((dot(_e382, _e383) > 0.000000000001f))));
-    let _e391 = v_tangent_1;
-    worldRight = normalize(_e391.xyz);
-    let _e394 = v_normal_1;
-    worldFacing = normalize(_e394);
-    let _e396 = worldFacing;
-    let _e397 = worldRight;
-    worldUp = cross(_e396, _e397);
-    let _e399 = worldRight;
-    let _e400 = local_31;
-    let _e401 = right_1;
-    let _e404 = worldUp;
-    let _e405 = local_31;
-    let _e406 = up_2;
-    let _e410 = worldFacing;
-    let _e411 = local_31;
-    let _e412 = d_7;
-    s_9.n = normalize((((_e399 * dot(_e400, _e401)) + (_e404 * dot(_e405, _e406))) + (_e410 * dot(_e411, _e412))));
-    let _e419 = s_9.n;
-    let _e421 = s_9.v;
-    s_9.n_dot_v = max(dot(_e419, _e421), 0.0001f);
-    let _e425 = srgb_1;
-    param_126 = _e425;
-    let _e426 = SrgbToLinear_u0028_vf3_u003b((&param_126));
-    let _e428 = frag_info.base_color;
-    param_127 = _e428.xyz;
-    let _e430 = SrgbToLinear_u0028_vf3_u003b((&param_127));
-    s_9.albedo = (_e426 * _e430);
+    let _e384 = local_31;
+    let _e387 = local_31;
+    let _e388 = d_7;
+    local_31 = normalize(select(_e388, _e387, vec3((dot(_e383, _e384) > 0.000000000001f))));
+    let _e392 = v_tangent_1;
+    worldRight = normalize(_e392.xyz);
+    let _e395 = v_normal_1;
+    worldFacing = normalize(_e395);
+    let _e397 = worldFacing;
+    let _e398 = worldRight;
+    worldUp = cross(_e397, _e398);
+    let _e400 = worldRight;
+    let _e401 = local_31;
+    let _e402 = right_1;
+    let _e405 = worldUp;
+    let _e406 = local_31;
+    let _e407 = up_2;
+    let _e411 = worldFacing;
+    let _e412 = local_31;
+    let _e413 = d_7;
+    s_9.n = normalize((((_e400 * dot(_e401, _e402)) + (_e405 * dot(_e406, _e407))) + (_e411 * dot(_e412, _e413))));
+    let _e420 = s_9.n;
+    let _e422 = s_9.v;
+    s_9.n_dot_v = max(dot(_e420, _e422), 0.0001f);
+    let _e426 = srgb_1;
+    param_126 = _e426;
+    let _e427 = SrgbToLinear_u0028_vf3_u003b((&param_126));
+    let _e429 = frag_info.base_color;
+    param_127 = _e429.xyz;
+    let _e431 = SrgbToLinear_u0028_vf3_u003b((&param_127));
+    s_9.albedo = (_e427 * _e431);
     s_9.alpha = 1f;
-    let _e435 = s_9.albedo;
-    g_albedo = _e435;
-    let _e437 = frag_info.ambient_ground;
-    let _e440 = frag_info.ambient_sky;
-    let _e444 = s_9.n[1u];
-    let _e451 = frag_info.material[2u];
-    s_9.ambient = (mix(_e437.xyz, _e440.xyz, vec3(((_e444 * 0.5f) + 0.5f))) * _e451);
-    let _e455 = s_9.albedo;
-    let _e457 = s_9.ambient;
-    ambient = (_e455 * _e457);
-    let _e459 = s_9;
-    param_128 = _e459;
-    let _e460 = AccumulateLights_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_128));
-    let _e461 = ambient;
-    lit_3 = (_e460 + _e461);
-    let _e463 = s_9;
-    param_129 = _e463;
-    let _e464 = lit_3;
-    param_130 = _e464;
-    let _e465 = WriteDebugView_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_vf3_u003b((&param_129), (&param_130));
-    if _e465 {
+    let _e436 = s_9.albedo;
+    g_albedo = _e436;
+    let _e438 = frag_info.ambient_ground;
+    let _e441 = frag_info.ambient_sky;
+    let _e445 = s_9.n[1u];
+    let _e452 = frag_info.material[2u];
+    s_9.ambient = (mix(_e438.xyz, _e441.xyz, vec3(((_e445 * 0.5f) + 0.5f))) * _e452);
+    let _e456 = s_9.albedo;
+    let _e458 = s_9.ambient;
+    ambient = (_e456 * _e458);
+    let _e460 = s_9;
+    param_128 = _e460;
+    let _e461 = AccumulateLights_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b((&param_128));
+    let _e462 = ambient;
+    lit_3 = (_e461 + _e462);
+    let _e464 = s_9;
+    param_129 = _e464;
+    let _e465 = lit_3;
+    param_130 = _e465;
+    let _e466 = WriteDebugView_u0028_struct_u002d_Surface_u002d_vf3_u002d_f1_u002d_vf3_u002d_vf3_u002d_f1_u002d_f1_u002d_f1_u002d_f1_u002d_vf3_u002d_vf3_u002d_f11_u003b_vf3_u003b((&param_129), (&param_130));
+    if _e466 {
         return;
     }
-    let _e466 = lit_3;
-    param_131 = _e466;
+    let _e467 = lit_3;
+    param_131 = _e467;
     param_132 = 1f;
     param_133 = 1f;
     WriteSurface_u0028_vf3_u003b_f1_u003b_f1_u003b((&param_131), (&param_132), (&param_133));
diff --git a/site/content/core/liquids.md b/site/content/core/liquids.md
index ef8a8ab48..5c1cc92f5 100644
--- a/site/content/core/liquids.md
+++ b/site/content/core/liquids.md
@@ -6,7 +6,7 @@ description: Incompressible liquid in vessels of any shape, in SI units under th
 
 The liquid part of `flutter3d_physics` lives in `lib/src/fluid/` and knows nothing about any particular game. It is in metres, kilograms and seconds, and gravity is whatever the world says, so the same tube on the Moon pours six times slower and its meniscus stands six times taller.
 
-It is a hybrid, because no single method is right everywhere. Liquid standing in a vessel is a volume with a free surface on it, and the surface moves by its modes. Liquid leaving a vessel is a stream of parcels. A stream that breaks becomes drops, and drops are particles. Each part hands volume to the next one exactly, and the world can tell you where every cubic millimetre is.
+It is a hybrid, because no single method is right everywhere. Liquid standing in a vessel is a volume with a free surface on it, and the surface moves by its modes. Liquid leaving a vessel is a stream of parcels. A stream that breaks becomes drops, and drops are particles. What reaches the bench lies there as a puddle. Each part hands volume to the next one exactly, and the world can tell you where every cubic millimetre is.
 
 ```dart
 final world = FluidWorld(
@@ -29,6 +29,10 @@ world.advance(dt);
 
 Draw it with `liquidMeshes(tube)`, `jetMesh(jet)` and `particleMesh(...)` from `flutter3d_core`'s geometry. The chemistry bench is built this way; its [article](/education/chemlab/) shows what that looks like.
 
+## Gravity that varies
+
+`FluidWorld.gravity` is one vector for everything. Give the world a `GravityField` instead, a uniform part and any number of `Attractor`s, and each vessel, drop and parcel of a stream feels the gravity where it is. Each attractor pulls as μ·r̂/r², μ = G·M, and inside its radius it pulls as a uniform ball does, less the deeper in. A glass beside an attractor levels across its own pull, and a drop between two falls to the nearer.
+
 ## Volume first
 
 A vessel is a `VesselShape`: something that can say how much of it lies under a plane. `RevolvedVessel` does it exactly upright, as a sum of frustums, and tilted as a sum of circular segments. `MeshVessel` takes any closed mesh and does it with the divergence theorem over the triangles the plane cuts. Everything else is built on that one question. The surface's height is the plane that leaves the liquid's volume under it, and the most a tipped glass holds is the volume under its lowest point of rim.
@@ -57,12 +61,39 @@ What leaves goes into a `Jet`, as parcels each holding one step's flow. A parcel
 - A thread grows Rayleigh–Plateau ripples at Weber's rate, the Grant–Middleman form of it, and breaks into drops when they have grown e¹² times. On a wall it does not break.
 - Where it meets glass the liquid wets, it runs down the wall as a rivulet. Too slow, and it runs down the outside of the glass it came from: the teapot effect, with cling speed √(σ(1 + cos θ)/(ρe)).
 - A fast drop that lands on a surface splashes when Mundo's K = Oh·Re^1.25 is over 57.7.
+- The upper end of a stretch the lip no longer holds, the tail of a pour that has stopped, draws back into a bulb at Keller's √(σ/ρr), eating the thread ahead of it.
 
 The world keeps the accounts: every jet's `emitted` is `inFlight + landed + dropped`.
 
 ## Drops
 
-Drops are `ParticleFluid`, position-based fluids on the CPU, in double precision. Particles are held to the rest density only where they are compressed, so a surface does not pull itself inward. Cohesion follows Akinci, with the coefficient worked out so that pulling a slab of particles apart costs 2σ per square metre, which is what surface tension is. A particle is stepped in substeps short against the capillary time √(ρs³/σ), a third of a millisecond for millimetre water, and short enough that nothing passes through glass between one look and the next. Drops that land in a vessel become its liquid, with what was dissolved in them.
+A drop in flight is one body. Falling, it does not feel its own weight, and what would break it up is the air: it holds together while its aerodynamic Weber number ρ_a·u²·d/σ is under about twelve (Pilch and Erdman), which a four-millimetre drop at a metre a second is a fifteenth of. So it moves as a sphere: its drag, its evaporation, and on a wall Furmidge's hold or a slide. Drops that touch run together. A drop wider than the capillary length that comes to a wall spreads there as particles, and particles that leave every wall gather into a drop again.
+
+Liquid on a wall is `ParticleFluid`'s particles, position-based fluids on the CPU, in double precision. Particles are held to the rest density only where they are compressed, so a surface does not pull itself inward. Cohesion follows Akinci, with the coefficient worked out so that pulling a slab of particles apart costs 2σ per square metre, which is what surface tension is. A particle is stepped in substeps short against the capillary time √(ρs³/σ), a third of a millisecond for millimetre water, and short enough that nothing passes through glass between one look and the next. Drops that land in a vessel become its liquid, with what was dissolved in them. Liquid arrives in any amount and leaves as whole particles; what is short of one waits only while more is coming, and then goes as a last, smaller particle where the rest came in.
+
+A drop is stopped by the wall it touches: a viscous liquid has no velocity along a wall at rest, and a drop's edge holds it there. Every wall is a `SolidSurface` with water's contact angle and its hysteresis, the advancing angle less the receding one: glass, a lacquered bench, PTFE. The edge holds a drop with Furmidge's σ·w·(cos θr − cos θa) across the circle it wets, so a microlitre hangs on a pane while twenty run down it, and every drop on a level bench stays where it fell. A drop that touches a vessel's glass from inside runs down into its liquid. For liquids other than water the solids' own angles are not known here, and the liquid's angle on glass stands in.
+
+## Puddles
+
+What reaches a floor given to the world becomes a `Puddle` on its `PuddleSurface`, one body with a volume and what is dissolved in it, not particles. Its angle θ is the surface's, so water beads on a lacquered bench and spreads on glass. A spread puddle is 2ℓc·sin(θ/2) deep, under a millimetre for water on glass; a smaller one is a spherical cap meeting the surface at the contact angle. It spreads there as a viscous gravity current, R ∝ (ρgV³/μ)^⅛·t^⅛ (Huppert), which water finishes in milliseconds. Puddles that meet run together. Draw them with `capMesh(...)`.
+
+## Laminar and turbulent
+
+Where it matters, the Reynolds number decides the law.
+
+- In a `Pipe`, friction is Darcy's, with 64/Re under 2300 and Haaland's form of Colebrook over 4000, for the bore's `roughness`. In between the flow is neither, and the factor goes from one to the other along a straight line, which claims no law it does not have. `Pipe.reynolds` says where a flow is.
+- A stream that leaves the lip under 2300 is smooth and parts by its own ripples. Past 4000 it leaves already disturbed and parts at Grant and Middleman's turbulent L/D = 8.51·We^0.32, a quarter of the laminar length for a brisk five-millimetre stream. A pour from a test tube is usually in between.
+- Waves in a vessel are damped in the laminar boundary layer at the wall, which is what they have at a bench's sizes.
+
+## Air
+
+A `FluidWorld` has an `Atmosphere`: temperature, pressure, humidity and wind, room air unless told otherwise. Its density is moist air's as an ideal gas, its viscosity Sutherland's, and water vapour diffuses through it at Marrero and Mason's rate.
+
+- A drop falls against Schiller and Naumann's drag on a sphere of the drop's own size, so a millimetre drop settles at 3.8 m/s. Gunn and Kinzer measured 4.03: a drop's inside circulates, and a rigid sphere's drag does not know that.
+- A stream bends in a crosswind, with White's drag on a cylinder across it.
+- Open liquid evaporates. A tube does so up the air standing over its liquid and out of its mouth, Stefan's tube, about three microlitres an hour. A puddle follows Hu and Larson in still air and a flat plate's boundary layer in a wind, and a drop follows Ranz and Marshall. Only the solvent leaves, so what is dissolved grows stronger, and `FluidWorld.evaporated` keeps the vapour in the accounts.
+
+Only water has a vapour curve so far; the other media do not evaporate yet.
 
 ## Capillarity
 
@@ -80,6 +111,15 @@ A body holds layers. Liquids that mix are one layer, keeping amounts of solutes,
 
 `FloatingBody` wraps a rigid body. The liquid pushes up with ρgV of what it displaces, exactly for spheres, boxes and capsules, and drags with White's coefficient for the part that is under. The displaced volume raises the level. A small ball sinking in glycerol settles at Stokes's speed; the tests check it within three percent.
 
+A body turning in the liquid is held back too, by Stokes's torque 8πμR³ω on the sphere of its volume, for the part of it that is under: a ball spun in glycerol slows by e in ρR²/15μ.
+
+## Faster, where a run need not replay
+
+Two switches on `FluidWorld` trade the bit-for-bit replay for speed, and change nothing that happens otherwise.
+
+- `nativeKernels: true` runs the particles' pair loops and neighbour search in C, built by the package's own hook with the machine's C compiler and vectorised. Each kernel matches the Dart one to a part in 10¹². The same switch moves the heavy half of a surface's mode solve (a millisecond against three or four in Dart) and the meniscus solve into C. Where no compiler was found, and on the web, the Dart code runs.
+- `background: true` works out what would stop a frame, a cross-section's modes or a meniscus not met before, on another isolate. The vessel carries on as it was until the answer comes. On the web there are no isolates, and it is all worked out at once.
+
 ## Being honest about it
 
 - The surface is linear, so it rocks harder where real water would break.
diff --git a/site/content/education/chemlab.md b/site/content/education/chemlab.md
index 7286be483..ddee533c7 100644
--- a/site/content/education/chemlab.md
+++ b/site/content/education/chemlab.md
@@ -134,7 +134,7 @@ Everything that lands carries what was dissolved in it. Each solution is a dye a
 
 **The caustics come from the optics** described above: the bright line the liquid focuses is where the traced beams pile up on the bench. An earlier version put a small coloured spot light in each shadow instead, which looked right from a distance and was wrong in every detail, and cost a light per vessel out of the eight the engine gives an object.
 
-**The reflections in the tabletop are geometry.** Screen-space reflections were the first try, and they reflected only the labels: the pass reads what the opaque pass drew, and the glass and the liquids come after it. A flat mirror, though, has an exact answer. Each liquid and label is drawn again, scaled by -1 in height so it hangs under the tabletop, flat and a little darker. The copies used to show through a top a twelfth transparent; now the top is opaque, for the refraction above, and the copies are laid over it at a twelfth of their strength with `CompareFunction.greater`, which draws them only where they are behind the top. That is where a mirror shows them, and nowhere else.
+**The reflections in the tabletop are geometry.** Screen-space reflections were the first try, and they reflected only the labels: the pass reads what the opaque pass drew, and the glass and the liquids come after it. A flat mirror, though, has an exact answer. Each liquid, label and glass is drawn again, scaled by -1 in height so it hangs under the tabletop, flat and a little darker. The copies used to show through a top a twelfth transparent; now the top is opaque, for the refraction above, and the copies are laid over it at a twelfth of their strength with `CompareFunction.greater`, which draws them only where they are behind the top. That is where a mirror shows them, and nowhere else.
 
 ## Labels without a decal
 
@@ -159,7 +159,6 @@ The camera is the engine's `OrbitController`, with tighter limits than its defau
 ## What it does not do yet
 
 - **Shadows of everything else.** The optics are worked out for surfaces of revolution under one sun. A vessel's light passing through another vessel is not followed, and a lamp casts ordinary shadows.
-- **The glass in the mirror.** The reflections carry the liquids and the labels; the glass itself is left out, since a copy of something nearly invisible is nearly invisible.
 - **Waves that break.** The modes are linear, so a hard enough jerk makes a surface that would in reality splash simply rock harder.
 - **Speed.** The drops are worked out on the CPU, a few dozen at a time, and the slowest part of a pour is stepping them as finely as surface tension at this size needs: a third of a millisecond at most.
 
diff --git a/site/content/quickstart.md b/site/content/quickstart.md
index 9dac63652..fe869b70e 100644
--- a/site/content/quickstart.md
+++ b/site/content/quickstart.md
@@ -91,7 +91,7 @@ tool/ci.sh                                  # shaders, analyze, every test
 (cd packages/flutter3d_physics && dart test) # plain Dart, no Flutter needed
 ```
 
-There are 11340 tests across 43 packages and twelve applications, and only about thirty need a GPU: the Impeller half of the golden set. The other half renders through the software backend, so ninety scenes stay checkable in a headless run.
+There are 11377 tests across 43 packages and twelve applications, and only about thirty need a GPU: the Impeller half of the golden set. The other half renders through the software backend, so ninety scenes stay checkable in a headless run.
 
 ## Your own application
 
diff --git a/site/content/reference/testing.md b/site/content/reference/testing.md
index d89d101c1..e0aea063a 100644
--- a/site/content/reference/testing.md
+++ b/site/content/reference/testing.md
@@ -1,10 +1,10 @@
 ---
-description: Four independent golden sets, mutation-checking every new test, determinism and snapshots, and why only about thirty of 11340 tests need a GPU.
+description: Four independent golden sets, mutation-checking every new test, determinism and snapshots, and why only about thirty of 11377 tests need a GPU.
 ---
 
 # Testing
 
-11340 tests across 43 packages and nine applications, counted the same way the `the document says how many tests there are` rule does: a scan of every `test(`/`testWidgets(` call. The rule holds `ARCHITECTURE.md` §13, the README and this page to the answer. The README went on saying 1242 across thirteen packages for as long as nothing compared it with anything. About thirty need a GPU; the [architecture](/core/architecture/) is what keeps the number that low.
+11377 tests across 43 packages and nine applications, counted the same way the `the document says how many tests there are` rule does: a scan of every `test(`/`testWidgets(` call. The rule holds `ARCHITECTURE.md` §13, the README and this page to the answer. The README went on saying 1242 across thirteen packages for as long as nothing compared it with anything. About thirty need a GPU; the [architecture](/core/architecture/) is what keeps the number that low.
 
 | Package | Tests | | Package | Tests |
 |---|---|---|---|---|
@@ -12,7 +12,7 @@ description: Four independent golden sets, mutation-checking every new test, det
 | | | | `flutter3d_mesh` | 599 |
 | | | | `apps/flutter3d_modeler` | 1750 |
 | `flutter3d_sim` | 691 | | `pad_input` | 67 |
-| `flutter3d_lab` | 15 | | `flutter3d_core` | 771 |
+| `flutter3d_lab` | 15 | | `flutter3d_core` | 773 |
 | `flutter3d_lti` | 26 | | `apps/flutter3d_lab_pendulum` | 7 |
 | | | | `apps/flutter3d_lab_incident` | 13 |
 | `flutter3d_game_shooter` | 340 | | `flutter3d_audio_core` | 55 |
@@ -23,7 +23,7 @@ description: Four independent golden sets, mutation-checking every new test, det
 | `flutter3d_cpu` | 380 | | `apps/flutter3d_demo_strategy` | 50 |
 | `apps/flutter3d_editor` | 234 | | `apps/flutter3d_demo_arcade` | 20 |
 | `apps/flutter3d_demo_racing` | 162 | | `pointer_lock` | 28 |
-| `flutter3d_physics` | 269 | | `flutter3d_webgpu` | 193 |
+| `flutter3d_physics` | 304 | | `flutter3d_webgpu` | 193 |
 | `flutter3d_game_strategy` | 133 | | `flutter3d_editor_mcp` | 36 |
 | `apps/flutter3d_demo_river` | 54 | | `flutter3d_testing` | 45 |
 | `flutter3d_editor_core` | 141 | | `flutter3d_editor_widgets` | 91 |
@@ -40,7 +40,7 @@ description: Four independent golden sets, mutation-checking every new test, det
 | `flame_flutter3d` | 140 | | `apps/flutter3d_showcase` | 88 |
 | `flame_multiplayer` | 9 | | `flame_multiplayer_dashwire` | 3 |
 
-The rows sum to 11313 rather than 11340: the remaining 26 live in `packages/*/example/test`, which the count includes and this table does not, among them the two seeds a new project starts from, `packages/flutter3d_app/example` and `packages/flutter3d_game/example`.
+The rows sum to 11350 rather than 11377: the remaining 26 live in `packages/*/example/test`, which the count includes and this table does not, among them the two seeds a new project starts from, `packages/flutter3d_app/example` and `packages/flutter3d_game/example`.
 
 `flutter3d_samples` is not in the table and has no `test/` at all: it is test data with two path constants over it, and other packages' decoder tests are what exercise it. `flutter3d_conformance` is missing for a different reason: it is invoked as a script harness rather than through `flutter test`, so it does not surface in a grep of `test(` calls either. See below for what that cost once.