@driftengine/core 4.8.7 → 4.9.0

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

@@ -25,6 +25,10 @@ export const MAIN_GLSL = `void main() {
   vec2 fxDx = dFdx(surfaceAt.xy);
   vec2 fxDy = dFdy(surfaceAt.xy);
   if (uWriteMode.y != 0.0 && !ditherKeeps(uWriteMode.y)) discard;
+  /* A draw's dissolve cuts the surface away before anything is shaded: overlay.ts. */
+  if (SURFACE_OVERLAY) {
+    if (overlayCuts(surfaceAt.xy)) discard;
+  }
 
   /*
    * Surface colour and its coverage, resolved before anything else — including before it is
@@ -139,6 +143,11 @@ export const MAIN_GLSL = `void main() {
   }
 
   vec3 lit = albedo;
+  /* How much of the environment the frame shows here, and how a found reflection would land:
+     reflectionSurface.ts. None where nothing is reflected. */
+  vec3 reflectedProbe = vec3(0.0);
+  vec3 reflectedTint = vec3(0.0);
+  float reflectedRoughness = 1.0;
   /* Skin's diffuse, held before emission for the screen-space blur's own pass: models.ts. */
   vec3 diffuseAlone = vec3(0.0);
   /* The light arriving at a glass pane from behind it, gathered in each light loop below and added
@@ -186,7 +195,10 @@ export const MAIN_GLSL = `void main() {
      * right: a mipped colour image, sampled under uniform control flow, exactly as uAlbedo is
      * below. The rule is about non-uniform branches, and this branch is on a uniform.
      */
+    vec3 unmapped = n;
     if (uNormalStrength > 0.0) n = normalMapped(n, surfaceAt);
+    /* A draw's wrinkles, by region, over whatever the map made: overlay.ts. */
+    if (SURFACE_OVERLAY) n = overlayWrinkle(n, unmapped, surfaceAt.xy);
 
     /*
      * Microscopic relief: the surface's own texture, as a turn of the normal rather than a change
@@ -915,6 +927,15 @@ export const MAIN_GLSL = `void main() {
         environment * mix(vec3(1.0), albedo, metal),
         weight
       );
+      reflectedTint = mix(vec3(1.0), albedo, metal) * weight;
+      reflectedProbe = environment * reflectedTint;
+      reflectedRoughness = surfaceRoughness;
+    }
+    /* The reflection pass's surface half leaves here, before the lamps: reflectionSurface.ts. */
+    if (REFLECTION_SURFACE) {
+      reflectionSurfaceOut(reflectedProbe, reflectedTint, reflectedRoughness, ormOcclusion,
+        reflectionAir());
+      return;
     }
     /*
      * The sun's highlight, on top of whatever the surface reflects rather than underneath it —
@@ -1939,6 +1960,9 @@ export const MAIN_GLSL = `void main() {
       * mix(1.0, min(lightShade, sunShade), EMISSIVE_SHADOW_SHARE) * fxGlow;
     /* And a lit window's glow, which the scene's lit share already times: not gated on night. */
     lit += windowGlow * uEmission.x;
+    /* And a draw's overlay: its rim, its dissolve's band and the colour laid over. Not gated on the
+       night, as emission is: a glow the surface wears rather than light it gives off. overlay.ts. */
+    if (SURFACE_OVERLAY) lit += overlayGlow(surfaceAt.xy, n);
 
 #if NIGHT_EMISSIVE
     /*
@@ -2137,6 +2161,10 @@ export const MAIN_GLSL = `void main() {
     return;
   }
 
+  /* WebGL2's frame writes the reflection maps itself, with the fog already reckoned above. */
+  if (REFLECTION_MAPS) {
+    reflectionSurfaceOut(reflectedProbe, reflectedTint, reflectedRoughness, ormOcclusion, fog);
+  }
   outColor = vec4(shaded, alpha);
 }
 `;

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

@@ -0,0 +1,16 @@
+/**
+ * A draw's surface overlay in the lit stage: the rim, the dissolve and the wrinkles
+ * `surfaceOverlay.ts` packs into `uOverlay`. Called from `main` at three places — the dissolve's cut
+ * before anything is shaded, the wrinkles after the normal map, and the glow beside emission.
+ *
+ * **A lit switch, `SURFACE_OVERLAY`**, off until a draw first sets an overlay and then on for good,
+ * as `litSwitchesGlsl`'s are; declared after the models so every switch before it keeps its id.
+ * Compiled out, the three calls are stubs and the fifteen vectors are not declared at all, which is
+ * what lets WebGL2 build a lit program without them on a device that has no room.
+ *
+ * **Images come from the atlas bound where the frame's refraction copy goes**, which an opaque draw
+ * never reads; a draw that refracts or is glass reads that copy there, so its overlay reads no image
+ * (`overlayImagesBound`). Each image is read by `textureLod` at level 0: several are reached under a
+ * branch on a per-pixel value, and the atlas carries no chain anyway.
+ */
+export declare function overlayGlsl(on: boolean): string;

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

@@ -0,0 +1,117 @@
+/**
+ * A draw's surface overlay in the lit stage: the rim, the dissolve and the wrinkles
+ * `surfaceOverlay.ts` packs into `uOverlay`. Called from `main` at three places — the dissolve's cut
+ * before anything is shaded, the wrinkles after the normal map, and the glow beside emission.
+ *
+ * **A lit switch, `SURFACE_OVERLAY`**, off until a draw first sets an overlay and then on for good,
+ * as `litSwitchesGlsl`'s are; declared after the models so every switch before it keeps its id.
+ * Compiled out, the three calls are stubs and the fifteen vectors are not declared at all, which is
+ * what lets WebGL2 build a lit program without them on a device that has no room.
+ *
+ * **Images come from the atlas bound where the frame's refraction copy goes**, which an opaque draw
+ * never reads; a draw that refracts or is glass reads that copy there, so its overlay reads no image
+ * (`overlayImagesBound`). Each image is read by `textureLod` at level 0: several are reached under a
+ * branch on a per-pixel value, and the atlas carries no chain anyway.
+ */
+export function overlayGlsl(on) {
+    if (!on) {
+        return /* glsl */ `
+const bool SURFACE_OVERLAY = false;  // wgsl:override
+bool overlayCuts(vec2 uv) { return false; }
+vec3 overlayWrinkle(vec3 mapped, vec3 unmapped, vec2 uv) { return mapped; }
+vec3 overlayGlow(vec2 uv, vec3 n) { return vec3(0.0); }
+`;
+    }
+    return /* glsl */ `
+/* Whether this program carries a draw's overlay. Off but where one has been set: overlay.ts. */
+const bool SURFACE_OVERLAY = true;  // wgsl:override
+/* The overlay's fifteen vectors; packSurfaceOverlay in surfaceOverlay.ts says what each holds. */
+uniform vec4 uOverlay[15];
+
+/* Whether the atlas is what the refraction slot holds: not where this draw refracts or is glass. */
+bool overlayImagesBound() {
+  return uSeeThrough.x <= 0.0 && uSeeThrough.z <= 0.0;
+}
+
+/* One image of the atlas at uv, repeated within its region; zero where the region has no size. */
+vec4 overlayImage(vec4 region, vec2 uv) {
+  if (region.x <= 0.0) return vec4(0.0);
+  return textureLod(uRefractScene, region.zw + fract(uv) * region.xy, 0.0);
+}
+
+/* The dissolve's noise at uv, and whether the draw dissolves at all: -1 where it does not. */
+float overlayDissolveNoise(vec2 uv) {
+  if (uOverlay[6].x <= 0.0 || uOverlay[7].z <= 0.0) return -1.0;
+  if (!overlayImagesBound()) return -1.0;
+  return overlayImage(uOverlay[6], uv * uOverlay[7].xy).r;
+}
+
+/* Whether the dissolve cuts this fragment away: where its noise is under the threshold, or all of
+   it at a threshold of 1. */
+bool overlayCuts(vec2 uv) {
+  float noise = overlayDissolveNoise(uv);
+  if (noise < 0.0) return false;
+  return noise < uOverlay[7].z || uOverlay[7].z >= 1.0;
+}
+
+/*
+ * The wrinkle normal blended into the mapped one by the two masks' channels times the six weights,
+ * in the frame the normal map is read in. **Under uniform control flow up to the frame**, which
+ * takes derivatives: every branch before it is on the overlay's numbers alone, and the weight a
+ * pixel takes is a mix rather than a branch.
+ */
+vec3 overlayWrinkle(vec3 mapped, vec3 unmapped, vec2 uv) {
+  if (uOverlay[10].x <= 0.0 || !overlayImagesBound()) return mapped;
+  mat3 tbn = tangentFrame(unmapped, vWorldPos, vUv.xy, vTangent, vHasTangents);
+  vec3 a = overlayImage(uOverlay[11], uv).rgb;
+  vec3 b = overlayImage(uOverlay[12], uv).rgb;
+  float weight = clamp(
+    dot(a, uOverlay[13].xyz) + dot(b, vec3(uOverlay[13].w, uOverlay[14].xy)), 0.0, 1.0);
+  vec3 wrinkle = overlayImage(uOverlay[10], uv).xyz * 2.0 - 1.0;
+  /* z rebuilt where none is stored, as normalMapped does: see normalMap.ts. */
+  wrinkle.z = wrinkle.z > 0.0 ? wrinkle.z : sqrt(max(0.0, 1.0 - dot(wrinkle.xy, wrinkle.xy)));
+  return normalize(mix(mapped, normalize(tbn * wrinkle), weight));
+}
+
+/*
+ * The rim's place on the screen, 0 to 1 up its height and its width in the same units: from view
+ * space and the projection's tangent, not from gl_FragCoord, whose y runs up on one backend and
+ * down on the other (the 2026-08-17 rule), and whose scale is a render target's, not the screen's.
+ */
+vec2 overlayScreen() {
+  vec4 eye = uView * vec4(vWorldPos, 1.0);
+  float depth = max(-eye.z, 1e-4) * uClusterFrustum.z;
+  return vec2(eye.x / depth + uClusterFrustum.w, eye.y / depth + 1.0) * 0.5;
+}
+
+/* What the overlay adds to the light the surface gives off: the dissolve's band, the colour laid
+   over through its noise, and the rim. Zero where the draw sets none of them. */
+vec3 overlayGlow(vec2 uv, vec3 n) {
+  vec3 glow = vec3(0.0);
+  float noise = overlayDissolveNoise(uv);
+  if (noise >= 0.0) {
+    float band = 1.0 - clamp((noise - uOverlay[7].z) / uOverlay[7].w, 0.0, 1.0);
+    glow += uOverlay[8].rgb * uOverlay[8].w * band + uOverlay[9].rgb * uOverlay[9].w * noise;
+  }
+  float strength = uOverlay[0].w;
+  if (strength > 0.0) {
+    vec3 toEye = normalize(uCameraPos - vWorldPos);
+    float edge = pow(1.0 - clamp(dot(n, toEye), 0.0, 1.0), max(uOverlay[1].x, 1e-4));
+    float up = pow(clamp(n.y * 0.5 + 0.5, 0.0, 1.0), max(uOverlay[1].y, 1e-4));
+    float rim = pow(edge * up, max(uOverlay[1].z, 1e-4));
+    float time = uSurfaceScene.x;
+    if (uOverlay[2].x > 0.0 && overlayImagesBound()) {
+      vec2 at = overlayScreen() * uOverlay[3].z + uOverlay[3].xy * time;
+      rim *= overlayImage(uOverlay[2], at).r;
+    }
+    rim = min(rim, 1.0);
+    rim *= mix(uOverlay[4].x, uOverlay[4].y, 0.5 + 0.5 * sin(uOverlay[3].w * time));
+    if (uOverlay[5].x > 0.0 && overlayImagesBound()) {
+      rim *= 1.0 - uOverlay[1].w * overlayImage(uOverlay[5], uv).r;
+    }
+    glow += uOverlay[0].rgb * strength * rim;
+  }
+  return glow;
+}
+`;
+}

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

@@ -341,7 +341,7 @@ float areaShadow(
 ${LAMP_GLASS_GLSL}
 #endif
 
-out vec4 outColor;
+layout(location = 0) out vec4 outColor;
 
 ${OUTPUT_TRANSFORM_GLSL}
 

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

@@ -0,0 +1,21 @@
+/**
+ * What the lit stage leaves for a reflection traced in the frame: how much of the environment each
+ * pixel shows, and how a reflection found in the frame would land there instead. Read by the
+ * reflection pass (`screenSpaceReflection.ts`), which swaps the one for the other where its ray
+ * finds something.
+ *
+ * **The swap is exact because the lit stage's own blend is a mix**: `lit = mix(lit, environment ·
+ * tint, weight)` leaves `environment · tint · weight` of the probe in the frame, and a reflection
+ * found in the frame belongs there with the same tint and the same weight. So the frame gains
+ * `(found · tint − environment · tint) · weight` and nothing else moves: the diffuse the blend
+ * already took its share from keeps it. Both are carried the rest of the way the shaded colour
+ * goes — the occlusion, the water and the medium in front of the surface — so the swap lands in the
+ * frame's own units.
+ *
+ * **Two outputs beside the colour, written by every lit draw and kept only where a target is
+ * bound.** WebGL2 binds them during opaque lit draws alone; WebGPU's frame pass binds none, and a
+ * second pass replays the frame's opaque draws into them with `REFLECTION_SURFACE` on, which leaves
+ * before the lamps (`main`). What it gives up is a vector of arithmetic on every lit pixel whether
+ * or not anything reads it.
+ */
+export declare function reflectionSurfaceGlsl(maps: boolean): string;

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

@@ -0,0 +1,61 @@
+/**
+ * What the lit stage leaves for a reflection traced in the frame: how much of the environment each
+ * pixel shows, and how a reflection found in the frame would land there instead. Read by the
+ * reflection pass (`screenSpaceReflection.ts`), which swaps the one for the other where its ray
+ * finds something.
+ *
+ * **The swap is exact because the lit stage's own blend is a mix**: `lit = mix(lit, environment ·
+ * tint, weight)` leaves `environment · tint · weight` of the probe in the frame, and a reflection
+ * found in the frame belongs there with the same tint and the same weight. So the frame gains
+ * `(found · tint − environment · tint) · weight` and nothing else moves: the diffuse the blend
+ * already took its share from keeps it. Both are carried the rest of the way the shaded colour
+ * goes — the occlusion, the water and the medium in front of the surface — so the swap lands in the
+ * frame's own units.
+ *
+ * **Two outputs beside the colour, written by every lit draw and kept only where a target is
+ * bound.** WebGL2 binds them during opaque lit draws alone; WebGPU's frame pass binds none, and a
+ * second pass replays the frame's opaque draws into them with `REFLECTION_SURFACE` on, which leaves
+ * before the lamps (`main`). What it gives up is a vector of arithmetic on every lit pixel whether
+ * or not anything reads it.
+ */
+export function reflectionSurfaceGlsl(maps) {
+    return /* glsl */ `
+/*
+ * Whether this pipeline is the reflection pass's surface half: the frame's opaque draws again,
+ * against the depth they wrote, leaving the two outputs below and no light. Off in every other
+ * pipeline, and set from the key as skin's halves are. See reflectionSurface.ts.
+ */
+const bool REFLECTION_SURFACE = false;  // wgsl:override
+/*
+ * Whether the frame's own draws write the two outputs as well: WebGL2's arrangement, on where the
+ * frame's materials' reflections are, and off in every WebGPU pipeline, which replays the draws
+ * instead. A lit switch, so a program that does not write them carries nothing live across the
+ * lamps for them.
+ */
+const bool REFLECTION_MAPS = ${maps ? 'true' : 'false'};  // wgsl:override
+/* The environment as the frame shows it, and the surface's roughness in w. */
+layout(location = 1) out vec4 outReflectedProbe;
+/* What a reflection found in the frame is multiplied by to land where the environment did. */
+layout(location = 2) out vec4 outReflectedTint;
+
+/* How much of the surface the medium in front of it leaves: the fog block below's own measure. */
+float reflectionAir() {
+  return uFogEnabled != 0 ? mediumFog(distance(vWorldPos, uCameraPos), vWorldPos.y) : 0.0;
+}
+
+/*
+ * The two outputs, carried through what the shaded colour meets after the blend: its occlusion,
+ * the water, and the air, as \`main\` applies them. \`air\` is the fog the caller has already
+ * reckoned, so the frame's own draws pay for it once.
+ */
+void reflectionSurfaceOut(vec3 probe, vec3 tint, float roughness, float occlusion, float air) {
+  vec3 keep = vec3(occlusion * (1.0 - air));
+  if (uFogEnabled != 0) {
+    vec3 waterTransmission = vec3(0.42) + uUnderwaterColor * 2.0;
+    keep *= mix(vec3(1.0), waterTransmission, uUnderwaterFactor * 0.55);
+  }
+  outReflectedProbe = vec4(probe * keep, roughness);
+  outReflectedTint = vec4(tint * keep, 1.0);
+}
+`;
+}

package/dist/render/shaders/fog.d.ts

@@ -34,4 +34,4 @@
  * never needed the camera position in their fragment stage, and a block that declares
  * everything it uses can be pasted anywhere.
  */
-export declare const FOG_GLSL = "\nuniform vec3 uFogColor;\n/** Extinction per metre **at the camera's own height**, not at the base. */\nuniform float uFogDensity;\n/** Reciprocal scale height of the haze, per metre. 0 is a uniform medium. */\nuniform float uFogHeightFalloff;\n/** The camera's height, so a fragment's own height is one subtraction away. */\nuniform float uFogEyeY;\nuniform vec3 uUnderwaterColor;\nuniform float uUnderwaterFogDensity;\nuniform float uUnderwaterFactor;\n/** 0 integrates a medium (Beer-Lambert); 1 ramps linearly between near and far. */\nuniform int uFogMode;\n/** Linear mode only: where haze begins, and where it is total. */\nuniform float uFogNear;\nuniform float uFogFar;\n\n/** What distance converges toward: the day's haze, or the water column. */\nvec3 mediumColor() {\n  return mix(uFogColor, uUnderwaterColor, uUnderwaterFactor);\n}\n\n/**\n * How much of a surface standing at height pointY, dist metres away, is lost to\n * the medium in between. 0 is perfectly clear, 1 is the medium's own colour.\n */\nfloat mediumFog(float dist, float pointY) {\n  /*\n   * A depth ramp rather than a medium, for worlds authored against one.\n   *\n   * Beer-Lambert is the honest model and stays the default: it integrates something\n   * physically there, so extinction begins at the eye and never stops. A linear near/far\n   * fog is not that \u2014 it is a *look*, with a hard start distance before which the air is\n   * perfectly clear, and it is what the fixed-function pipeline offered and what several\n   * renderers still expose. Approximating one with the other is not a matter of tuning:\n   * matched at half occlusion, the exponential curve still lays haze over everything\n   * inside near, where the ramp lays none, and near-field colour desaturates toward the\n   * fog colour with nothing to show for it.\n   *\n   * Height falloff has no meaning here and is ignored: a ramp is defined on distance\n   * alone.\n   */\n  if (uFogMode == 1) {\n    float span = max(uFogFar - uFogNear, 1e-4);\n    float ramp = clamp((dist - uFogNear) / span, 0.0, 1.0);\n    if (uUnderwaterFactor <= 0.0) return ramp;\n    float wetLinear = uUnderwaterFogDensity * dist;\n    return mix(ramp, 1.0 - exp2(-wetLinear * wetLinear * 1.442695), uUnderwaterFactor);\n  }\n\n  float t = (pointY - uFogEyeY) * uFogHeightFalloff;\n  // (1 - e^-t)/t, which tends to 1 as the ray levels out. Guarded rather than\n  // branched: at t = 0 the quotient is 0/0, and 1e-4 of a scale height is 8 mm.\n  float denom = abs(t) < 1e-4 ? 1e-4 : t;\n  float air = 1.0 - exp(-uFogDensity * dist * (1.0 - exp(-denom)) / denom);\n  if (uUnderwaterFactor <= 0.0) return air;\n  // Water is its own medium and keeps its own curve, so crossing the surface\n  // changes nothing about how the water column reads.\n  float wet = uUnderwaterFogDensity * dist;\n  return mix(air, 1.0 - exp2(-wet * wet * 1.442695), uUnderwaterFactor);\n}\n";
+export declare const FOG_GLSL = "\nuniform vec3 uFogColor;\n/** Extinction per metre **at the camera's own height**, not at the base. */\nuniform float uFogDensity;\n/** Reciprocal scale height of the haze, per metre. 0 is a uniform medium. */\nuniform float uFogHeightFalloff;\n/** The camera's height, so a fragment's own height is one subtraction away. */\nuniform float uFogEyeY;\nuniform vec3 uUnderwaterColor;\nuniform float uUnderwaterFogDensity;\nuniform float uUnderwaterFactor;\n/** 0 integrates a medium (Beer-Lambert); 1 ramps linearly between near and far. */\nuniform int uFogMode;\n/** Linear mode only: where haze begins, and where it is total. */\nuniform float uFogNear;\nuniform float uFogFar;\n\n/** What distance converges toward: the day's haze, or the water column. */\nvec3 mediumColor() {\n  return mix(uFogColor, uUnderwaterColor, uUnderwaterFactor);\n}\n\n/**\n * How much of a surface standing at height pointY, dist metres away, is lost to\n * the medium in between. 0 is perfectly clear, 1 is the medium's own colour.\n */\nfloat mediumFog(float dist, float pointY) {\n  /*\n   * A depth ramp rather than a medium, for worlds authored against one.\n   *\n   * Beer-Lambert is the honest model and stays the default: it integrates something\n   * physically there, so extinction begins at the eye and never stops. A linear near/far\n   * fog is not that \u2014 it is a *look*, with a hard start distance before which the air is\n   * perfectly clear, and it is what the fixed-function pipeline offered and what several\n   * renderers still expose. Approximating one with the other is not a matter of tuning:\n   * matched at half occlusion, the exponential curve still lays haze over everything\n   * inside near, where the ramp lays none, and near-field colour desaturates toward the\n   * fog colour with nothing to show for it.\n   *\n   * Height falloff has no meaning here and is ignored: a ramp is defined on distance\n   * alone.\n   */\n  if (uFogMode == 1) {\n    float span = max(uFogFar - uFogNear, 1e-4);\n    float ramp = clamp((dist - uFogNear) / span, 0.0, 1.0);\n    if (uUnderwaterFactor <= 0.0) return ramp;\n    float wetLinear = uUnderwaterFogDensity * dist;\n    return mix(ramp, 1.0 - exp2(-wetLinear * wetLinear * 1.442695), uUnderwaterFactor);\n  }\n\n  // Where the medium begins along the ray: uFogNear, the linear mode's slot, which this mode\n  // never read before Atmosphere.fogStart. The ray is integrated from there on, at the density\n  // of that point; at a start of 0 every term is the one it always was. See render/fog.ts.\n  float start = min(uFogNear, dist);\n  float before = dist > 0.0 ? start / dist : 0.0;\n  float t = (pointY - uFogEyeY) * uFogHeightFalloff;\n  float rest = t * (1.0 - before);\n  // (1 - e^-t)/t, which tends to 1 as the ray levels out. Guarded rather than\n  // branched: at t = 0 the quotient is 0/0, and 1e-4 of a scale height is 8 mm.\n  float denom = abs(rest) < 1e-4 ? 1e-4 : rest;\n  float air =\n    1.0 - exp(-uFogDensity * exp(-t * before) * (dist - start) * (1.0 - exp(-denom)) / denom);\n  if (uUnderwaterFactor <= 0.0) return air;\n  // Water is its own medium and keeps its own curve, so crossing the surface\n  // changes nothing about how the water column reads.\n  float wet = uUnderwaterFogDensity * dist;\n  return mix(air, 1.0 - exp2(-wet * wet * 1.442695), uUnderwaterFactor);\n}\n";

package/dist/render/shaders/fog.js

@@ -84,11 +84,18 @@ float mediumFog(float dist, float pointY) {
     return mix(ramp, 1.0 - exp2(-wetLinear * wetLinear * 1.442695), uUnderwaterFactor);
   }
 
+  // Where the medium begins along the ray: uFogNear, the linear mode's slot, which this mode
+  // never read before Atmosphere.fogStart. The ray is integrated from there on, at the density
+  // of that point; at a start of 0 every term is the one it always was. See render/fog.ts.
+  float start = min(uFogNear, dist);
+  float before = dist > 0.0 ? start / dist : 0.0;
   float t = (pointY - uFogEyeY) * uFogHeightFalloff;
+  float rest = t * (1.0 - before);
   // (1 - e^-t)/t, which tends to 1 as the ray levels out. Guarded rather than
   // branched: at t = 0 the quotient is 0/0, and 1e-4 of a scale height is 8 mm.
-  float denom = abs(t) < 1e-4 ? 1e-4 : t;
-  float air = 1.0 - exp(-uFogDensity * dist * (1.0 - exp(-denom)) / denom);
+  float denom = abs(rest) < 1e-4 ? 1e-4 : rest;
+  float air =
+    1.0 - exp(-uFogDensity * exp(-t * before) * (dist - start) * (1.0 - exp(-denom)) / denom);
   if (uUnderwaterFactor <= 0.0) return air;
   // Water is its own medium and keeps its own curve, so crossing the surface
   // changes nothing about how the water column reads.

package/dist/render/shaders/fringe.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Chromatic aberration: a lens bending each colour by its own amount, so red and green land a
+ * little nearer the centre than blue toward the frame's edges.
+ *
+ * **Linear in wavelength, from an offset outward.** A simple lens's dispersion is close to linear
+ * in wavelength over the visible range, so red (611 nm) and green (549 nm) are pulled toward the
+ * centre by their distance from blue (464 nm), which is drawn where it is. Nothing moves inside
+ * `start` — a share of the half-frame, 0 at the centre — and the pull grows linearly past it,
+ * scaled so that the frame's edge takes the whole of `intensity`, which is a percentage.
+ *
+ * **What it gives up**: it re-reads the scene at the composite's first sample, so the camera's
+ * motion blur and the depth of field, which re-read the scene themselves, carry less of the fringe
+ * where they are strong. A pass of its own after both would carry it whole, at a full-frame read
+ * and write a frame. **What would make that wrong** is a game that blurs heavily and fringes
+ * heavily at once, where the colour edges would be seen to soften with the blur.
+ */
+/** How many floats `resolveFringe` fills: the red pull, the green pull, and where they begin. */
+export declare const FRINGE_FLOATS = 3;
+/**
+ * The fringe's three numbers, into `out`: how far red and green are pulled toward the centre at
+ * the frame's edge, as a share of the half-frame, and the start offset. `intensity` 0 or below is
+ * none; a start of 1 or more is none too, since nothing then lies past it. Not finite is none.
+ */
+export declare function resolveFringe(intensity: number, start: number, out: Float32Array): void;
+/**
+ * `withFringe(scene)`: the scene's colour with red and green read again where the lens put them.
+ * Reads `uScene` and `vUv`, which the including stage declares, and `uFringe`, which this declares.
+ */
+export declare const FRINGE_GLSL = "\n/** Red's and green's pull at the frame's edge, and where it begins: see shaders/fringe.ts. */\nuniform vec3 uFringe;\n\nvec3 withFringe(vec3 scene) {\n  if (uFringe.x <= 0.0) return scene;\n  vec2 lens = vUv * 2.0 - 1.0;\n  vec2 past = sign(lens) * clamp(abs(lens) - uFringe.z, 0.0, 1.0);\n  vec2 red = (lens - past * uFringe.x) * 0.5 + 0.5;\n  vec2 green = (lens - past * uFringe.y) * 0.5 + 0.5;\n  return vec3(textureLod(uScene, red, 0.0).r, textureLod(uScene, green, 0.0).g, scene.b);\n}\n";

package/dist/render/shaders/fringe.js

@@ -0,0 +1,55 @@
+/**
+ * Chromatic aberration: a lens bending each colour by its own amount, so red and green land a
+ * little nearer the centre than blue toward the frame's edges.
+ *
+ * **Linear in wavelength, from an offset outward.** A simple lens's dispersion is close to linear
+ * in wavelength over the visible range, so red (611 nm) and green (549 nm) are pulled toward the
+ * centre by their distance from blue (464 nm), which is drawn where it is. Nothing moves inside
+ * `start` — a share of the half-frame, 0 at the centre — and the pull grows linearly past it,
+ * scaled so that the frame's edge takes the whole of `intensity`, which is a percentage.
+ *
+ * **What it gives up**: it re-reads the scene at the composite's first sample, so the camera's
+ * motion blur and the depth of field, which re-read the scene themselves, carry less of the fringe
+ * where they are strong. A pass of its own after both would carry it whole, at a full-frame read
+ * and write a frame. **What would make that wrong** is a game that blurs heavily and fringes
+ * heavily at once, where the colour edges would be seen to soften with the blur.
+ */
+/** How many floats `resolveFringe` fills: the red pull, the green pull, and where they begin. */
+export const FRINGE_FLOATS = 3;
+/** The primaries' wavelengths, nanometres. */
+const RED_NM = 611.3;
+const GREEN_NM = 549.1;
+const BLUE_NM = 464.3;
+/** The lens's dispersion per nanometre, the constant that makes `intensity` a percentage. */
+const PER_NM = 0.007;
+/**
+ * The fringe's three numbers, into `out`: how far red and green are pulled toward the centre at
+ * the frame's edge, as a share of the half-frame, and the start offset. `intensity` 0 or below is
+ * none; a start of 1 or more is none too, since nothing then lies past it. Not finite is none.
+ */
+export function resolveFringe(intensity, start, out) {
+    const at = Number.isFinite(start) ? Math.min(Math.max(start, 0), 1) : 0;
+    const amount = Number.isFinite(intensity) && intensity > 0 && at < 1 ? intensity * 0.01 : 0;
+    /* Divided only where there is something to divide: at a start of 1 this is 0 over 0. */
+    const reach = amount > 0 ? amount / (1 - at) : 0;
+    out[0] = reach * PER_NM * (RED_NM - BLUE_NM);
+    out[1] = reach * PER_NM * (GREEN_NM - BLUE_NM);
+    out[2] = at;
+}
+/**
+ * `withFringe(scene)`: the scene's colour with red and green read again where the lens put them.
+ * Reads `uScene` and `vUv`, which the including stage declares, and `uFringe`, which this declares.
+ */
+export const FRINGE_GLSL = `
+/** Red's and green's pull at the frame's edge, and where it begins: see shaders/fringe.ts. */
+uniform vec3 uFringe;
+
+vec3 withFringe(vec3 scene) {
+  if (uFringe.x <= 0.0) return scene;
+  vec2 lens = vUv * 2.0 - 1.0;
+  vec2 past = sign(lens) * clamp(abs(lens) - uFringe.z, 0.0, 1.0);
+  vec2 red = (lens - past * uFringe.x) * 0.5 + 0.5;
+  vec2 green = (lens - past * uFringe.y) * 0.5 + 0.5;
+  return vec3(textureLod(uScene, red, 0.0).r, textureLod(uScene, green, 0.0).g, scene.b);
+}
+`;

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

@@ -1,4 +1,4 @@
-export declare const ARCANE_FRAG_WGSL = "struct Uniforms {\n    uTime: f32,\n    uFogColor: vec3<f32>,\n    uFogDensity: f32,\n    uFogHeightFalloff: f32,\n    uFogEyeY: f32,\n    uUnderwaterColor: vec3<f32>,\n    uUnderwaterFogDensity: f32,\n    uUnderwaterFactor: f32,\n    uFogMode: i32,\n    uFogNear: f32,\n    uFogFar: f32,\n    uNoiseOctaves: i32,\n    uClipPlane: vec4<f32>,\n    uClipEnabled: i32,\n    uTint: vec3<f32>,\n}\n\n@group(0) @binding(1) \nvar<uniform> unnamed: Uniforms;\nvar<private> vWorldPos_1: vec3<f32>;\nvar<private> vUv_1: vec2<f32>;\nvar<private> vSeed_1: f32;\nvar<private> vDistance_1: f32;\nvar<private> outColor: vec4<f32>;\n\nfn mediumColor_u0028_() -> vec3<f32> {\n    let _e59 = unnamed.uFogColor;\n    let _e61 = unnamed.uUnderwaterColor;\n    let _e63 = unnamed.uUnderwaterFactor;\n    return mix(_e59, _e61, vec3(_e63));\n}\n\nfn mediumFog_u0028_f1_u003b_f1_u003b(dist: ptr<function, f32>, pointY: ptr<function, f32>) -> f32 {\n    var span: f32;\n    var ramp: f32;\n    var wetLinear: f32;\n    var t: f32;\n    var denom: f32;\n    var air: f32;\n    var wet: f32;\n\n    let _e68 = unnamed.uFogMode;\n    if (_e68 == 1i) {\n        let _e71 = unnamed.uFogFar;\n        let _e73 = unnamed.uFogNear;\n        span = max((_e71 - _e73), 0.0001f);\n        let _e76 = (*dist);\n        let _e78 = unnamed.uFogNear;\n        let _e80 = span;\n        ramp = clamp(((_e76 - _e78) / _e80), 0f, 1f);\n        let _e84 = unnamed.uUnderwaterFactor;\n        if (_e84 <= 0f) {\n            let _e86 = ramp;\n            return _e86;\n        }\n        let _e88 = unnamed.uUnderwaterFogDensity;\n        let _e89 = (*dist);\n        wetLinear = (_e88 * _e89);\n        let _e91 = ramp;\n        let _e92 = wetLinear;\n        let _e94 = wetLinear;\n        let _e100 = unnamed.uUnderwaterFactor;\n        return mix(_e91, (1f - exp2(((-(_e92) * _e94) * 1.442695f))), _e100);\n    }\n    let _e102 = (*pointY);\n    let _e104 = unnamed.uFogEyeY;\n    let _e107 = unnamed.uFogHeightFalloff;\n    t = ((_e102 - _e104) * _e107);\n    let _e109 = t;\n    let _e112 = t;\n    denom = select(_e112, 0.0001f, (abs(_e109) < 0.0001f));\n    let _e115 = unnamed.uFogDensity;\n    let _e117 = (*dist);\n    let _e119 = denom;\n    let _e124 = denom;\n    air = (1f - exp((((-(_e115) * _e117) * (1f - exp(-(_e119)))) / _e124)));\n    let _e129 = unnamed.uUnderwaterFactor;\n    if (_e129 <= 0f) {\n        let _e131 = air;\n        return _e131;\n    }\n    let _e133 = unnamed.uUnderwaterFogDensity;\n    let _e134 = (*dist);\n    wet = (_e133 * _e134);\n    let _e136 = air;\n    let _e137 = wet;\n    let _e139 = wet;\n    let _e145 = unnamed.uUnderwaterFactor;\n    return mix(_e136, (1f - exp2(((-(_e137) * _e139) * 1.442695f))), _e145);\n}\n\nfn hash21_u0028_vf2_u003b(p: ptr<function, vec2<f32>>) -> f32 {\n    let _e59 = (*p);\n    return fract((sin(dot(_e59, vec2<f32>(127.1f, 311.7f))) * 43758.547f));\n}\n\nfn valueNoise_u0028_vf2_u003b(p_1: ptr<function, vec2<f32>>) -> f32 {\n    var i: vec2<f32>;\n    var f: vec2<f32>;\n    var u: vec2<f32>;\n    var param: vec2<f32>;\n    var param_1: vec2<f32>;\n    var param_2: vec2<f32>;\n    var param_3: vec2<f32>;\n\n    let _e66 = (*p_1);\n    i = floor(_e66);\n    let _e68 = (*p_1);\n    f = fract(_e68);\n    let _e70 = f;\n    let _e71 = f;\n    let _e73 = f;\n    u = ((_e70 * _e71) * (vec2(3f) - (_e73 * 2f)));\n    let _e78 = i;\n    param = _e78;\n    let _e79 = hash21_u0028_vf2_u003b((&param));\n    let _e80 = i;\n    param_1 = (_e80 + vec2<f32>(1f, 0f));\n    let _e82 = hash21_u0028_vf2_u003b((&param_1));\n    let _e84 = u[0u];\n    let _e86 = i;\n    param_2 = (_e86 + vec2<f32>(0f, 1f));\n    let _e88 = hash21_u0028_vf2_u003b((&param_2));\n    let _e89 = i;\n    param_3 = (_e89 + vec2<f32>(1f, 1f));\n    let _e91 = hash21_u0028_vf2_u003b((&param_3));\n    let _e93 = u[0u];\n    let _e96 = u[1u];\n    return mix(mix(_e79, _e82, _e84), mix(_e88, _e91, _e93), _e96);\n}\n\nfn main_1() {\n    var radius: f32;\n    var d: vec2<f32>;\n    var angle: f32;\n    var t_1: f32;\n    var inner: f32;\n    var param_4: vec2<f32>;\n    var outer: f32;\n    var param_5: vec2<f32>;\n    var swirl: f32;\n    var param_6: vec2<f32>;\n    var core: f32;\n    var corona: f32;\n    var body: f32;\n    var col: vec3<f32>;\n    var alpha: f32;\n    var fog: f32;\n    var param_7: f32;\n    var param_8: f32;\n    var phi_237_: bool;\n\n    let _e77 = unnamed.uClipEnabled;\n    let _e78 = (_e77 != 0i);\n    phi_237_ = _e78;\n    if _e78 {\n        let _e79 = vWorldPos_1;\n        let _e85 = unnamed.uClipPlane;\n        phi_237_ = (dot(vec4<f32>(_e79.x, _e79.y, _e79.z, 1f), _e85) < 0f);\n    }\n    let _e89 = phi_237_;\n    if _e89 {\n        discard;\n    }\n    let _e90 = vUv_1;\n    radius = (length((_e90 - vec2(0.5f))) * 2f);\n    let _e95 = radius;\n    if (_e95 >= 1f) {\n        discard;\n    }\n    let _e97 = vUv_1;\n    d = (_e97 - vec2(0.5f));\n    let _e101 = d[1u];\n    let _e103 = d[0u];\n    angle = atan2(_e101, _e103);\n    let _e106 = unnamed.uTime;\n    let _e107 = vSeed_1;\n    t_1 = (_e106 + (_e107 * 37f));\n    let _e110 = angle;\n    let _e112 = t_1;\n    let _e115 = radius;\n    param_4 = vec2<f32>(((_e110 * 1.9f) + (_e112 * 0.55f)), (_e115 * 4.2f));\n    let _e118 = valueNoise_u0028_vf2_u003b((&param_4));\n    inner = _e118;\n    let _e119 = angle;\n    let _e121 = t_1;\n    let _e124 = radius;\n    param_5 = vec2<f32>(((_e119 * 3.1f) - (_e121 * 0.34f)), (_e124 * 2.6f));\n    let _e127 = valueNoise_u0028_vf2_u003b((&param_5));\n    outer = _e127;\n    let _e128 = inner;\n    let _e130 = outer;\n    swirl = ((_e128 * 0.62f) + (_e130 * 0.38f));\n    let _e134 = unnamed.uNoiseOctaves;\n    if (_e134 > 1i) {\n        let _e136 = swirl;\n        let _e137 = swirl;\n        let _e138 = angle;\n        let _e140 = t_1;\n        let _e143 = radius;\n        param_6 = vec2<f32>(((_e138 * 6.3f) + (_e140 * 0.9f)), (_e143 * 8f));\n        let _e146 = valueNoise_u0028_vf2_u003b((&param_6));\n        swirl = mix(_e136, ((_e137 * _e146) * 2f), 0.35f);\n    }\n    let _e150 = radius;\n    core = (1f - smoothstep(0f, 0.28f, _e150));\n    let _e153 = radius;\n    let _e156 = swirl;\n    corona = ((1f - smoothstep(0.18f, 1f, _e153)) * (0.35f + (_e156 * 0.65f)));\n    let _e160 = core;\n    let _e162 = corona;\n    body = ((_e160 * 0.9f) + _e162);\n    let _e164 = body;\n    if (_e164 <= 0.02f) {\n        discard;\n    }\n    let _e167 = unnamed.uTint;\n    let _e170 = unnamed.uTint;\n    let _e171 = body;\n    col = mix((_e167 * 0.35f), _e170, vec3(smoothstep(0f, 0.55f, _e171)));\n    let _e175 = col;\n    let _e176 = body;\n    col = mix(_e175, vec3<f32>(1f, 1f, 1f), vec3(smoothstep(0.82f, 1.4f, _e176)));\n    let _e181 = unnamed.uTint;\n    let _e182 = col;\n    col = (_e182 * _e181);\n    let _e184 = body;\n    alpha = clamp((_e184 * 1.6f), 0f, 1f);\n    let _e187 = vDistance_1;\n    param_7 = _e187;\n    let _e189 = vWorldPos_1[1u];\n    param_8 = _e189;\n    let _e190 = mediumFog_u0028_f1_u003b_f1_u003b((&param_7), (&param_8));\n    fog = _e190;\n    let _e191 = col;\n    let _e192 = mediumColor_u0028_();\n    let _e193 = fog;\n    col = mix(_e191, _e192, vec3(_e193));\n    let _e196 = fog;\n    let _e198 = alpha;\n    alpha = (_e198 * (1f - _e196));\n    let _e200 = col;\n    let _e201 = alpha;\n    outColor = vec4<f32>(_e200.x, _e200.y, _e200.z, _e201);\n    return;\n}\n\n@fragment \nfn main(@location(3) vWorldPos: vec3<f32>, @location(0) vUv: vec2<f32>, @location(1) vSeed: f32, @location(2) vDistance: f32) -> @location(0) vec4<f32> {\n    vWorldPos_1 = vWorldPos;\n    vUv_1 = vUv;\n    vSeed_1 = vSeed;\n    vDistance_1 = vDistance;\n    main_1();\n    let _e9 = outColor;\n    return _e9;\n}\n";
+export declare const ARCANE_FRAG_WGSL = "struct Uniforms {\n    uTime: f32,\n    uFogColor: vec3<f32>,\n    uFogDensity: f32,\n    uFogHeightFalloff: f32,\n    uFogEyeY: f32,\n    uUnderwaterColor: vec3<f32>,\n    uUnderwaterFogDensity: f32,\n    uUnderwaterFactor: f32,\n    uFogMode: i32,\n    uFogNear: f32,\n    uFogFar: f32,\n    uNoiseOctaves: i32,\n    uClipPlane: vec4<f32>,\n    uClipEnabled: i32,\n    uTint: vec3<f32>,\n}\n\n@group(0) @binding(1) \nvar<uniform> unnamed: Uniforms;\nvar<private> vWorldPos_1: vec3<f32>;\nvar<private> vUv_1: vec2<f32>;\nvar<private> vSeed_1: f32;\nvar<private> vDistance_1: f32;\nvar<private> outColor: vec4<f32>;\n\nfn mediumColor_u0028_() -> vec3<f32> {\n    let _e59 = unnamed.uFogColor;\n    let _e61 = unnamed.uUnderwaterColor;\n    let _e63 = unnamed.uUnderwaterFactor;\n    return mix(_e59, _e61, vec3(_e63));\n}\n\nfn mediumFog_u0028_f1_u003b_f1_u003b(dist: ptr<function, f32>, pointY: ptr<function, f32>) -> f32 {\n    var span: f32;\n    var ramp: f32;\n    var wetLinear: f32;\n    var start: f32;\n    var before: f32;\n    var local: f32;\n    var t: f32;\n    var rest: f32;\n    var denom: f32;\n    var air: f32;\n    var wet: f32;\n\n    let _e72 = unnamed.uFogMode;\n    if (_e72 == 1i) {\n        let _e75 = unnamed.uFogFar;\n        let _e77 = unnamed.uFogNear;\n        span = max((_e75 - _e77), 0.0001f);\n        let _e80 = (*dist);\n        let _e82 = unnamed.uFogNear;\n        let _e84 = span;\n        ramp = clamp(((_e80 - _e82) / _e84), 0f, 1f);\n        let _e88 = unnamed.uUnderwaterFactor;\n        if (_e88 <= 0f) {\n            let _e90 = ramp;\n            return _e90;\n        }\n        let _e92 = unnamed.uUnderwaterFogDensity;\n        let _e93 = (*dist);\n        wetLinear = (_e92 * _e93);\n        let _e95 = ramp;\n        let _e96 = wetLinear;\n        let _e98 = wetLinear;\n        let _e104 = unnamed.uUnderwaterFactor;\n        return mix(_e95, (1f - exp2(((-(_e96) * _e98) * 1.442695f))), _e104);\n    }\n    let _e107 = unnamed.uFogNear;\n    let _e108 = (*dist);\n    start = min(_e107, _e108);\n    let _e110 = (*dist);\n    if (_e110 > 0f) {\n        let _e112 = start;\n        let _e113 = (*dist);\n        local = (_e112 / _e113);\n    } else {\n        local = 0f;\n    }\n    let _e115 = local;\n    before = _e115;\n    let _e116 = (*pointY);\n    let _e118 = unnamed.uFogEyeY;\n    let _e121 = unnamed.uFogHeightFalloff;\n    t = ((_e116 - _e118) * _e121);\n    let _e123 = t;\n    let _e124 = before;\n    rest = (_e123 * (1f - _e124));\n    let _e127 = rest;\n    let _e130 = rest;\n    denom = select(_e130, 0.0001f, (abs(_e127) < 0.0001f));\n    let _e133 = unnamed.uFogDensity;\n    let _e135 = t;\n    let _e137 = before;\n    let _e141 = (*dist);\n    let _e142 = start;\n    let _e145 = denom;\n    let _e150 = denom;\n    air = (1f - exp(((((-(_e133) * exp((-(_e135) * _e137))) * (_e141 - _e142)) * (1f - exp(-(_e145)))) / _e150)));\n    let _e155 = unnamed.uUnderwaterFactor;\n    if (_e155 <= 0f) {\n        let _e157 = air;\n        return _e157;\n    }\n    let _e159 = unnamed.uUnderwaterFogDensity;\n    let _e160 = (*dist);\n    wet = (_e159 * _e160);\n    let _e162 = air;\n    let _e163 = wet;\n    let _e165 = wet;\n    let _e171 = unnamed.uUnderwaterFactor;\n    return mix(_e162, (1f - exp2(((-(_e163) * _e165) * 1.442695f))), _e171);\n}\n\nfn hash21_u0028_vf2_u003b(p: ptr<function, vec2<f32>>) -> f32 {\n    let _e59 = (*p);\n    return fract((sin(dot(_e59, vec2<f32>(127.1f, 311.7f))) * 43758.547f));\n}\n\nfn valueNoise_u0028_vf2_u003b(p_1: ptr<function, vec2<f32>>) -> f32 {\n    var i: vec2<f32>;\n    var f: vec2<f32>;\n    var u: vec2<f32>;\n    var param: vec2<f32>;\n    var param_1: vec2<f32>;\n    var param_2: vec2<f32>;\n    var param_3: vec2<f32>;\n\n    let _e66 = (*p_1);\n    i = floor(_e66);\n    let _e68 = (*p_1);\n    f = fract(_e68);\n    let _e70 = f;\n    let _e71 = f;\n    let _e73 = f;\n    u = ((_e70 * _e71) * (vec2(3f) - (_e73 * 2f)));\n    let _e78 = i;\n    param = _e78;\n    let _e79 = hash21_u0028_vf2_u003b((&param));\n    let _e80 = i;\n    param_1 = (_e80 + vec2<f32>(1f, 0f));\n    let _e82 = hash21_u0028_vf2_u003b((&param_1));\n    let _e84 = u[0u];\n    let _e86 = i;\n    param_2 = (_e86 + vec2<f32>(0f, 1f));\n    let _e88 = hash21_u0028_vf2_u003b((&param_2));\n    let _e89 = i;\n    param_3 = (_e89 + vec2<f32>(1f, 1f));\n    let _e91 = hash21_u0028_vf2_u003b((&param_3));\n    let _e93 = u[0u];\n    let _e96 = u[1u];\n    return mix(mix(_e79, _e82, _e84), mix(_e88, _e91, _e93), _e96);\n}\n\nfn main_1() {\n    var radius: f32;\n    var d: vec2<f32>;\n    var angle: f32;\n    var t_1: f32;\n    var inner: f32;\n    var param_4: vec2<f32>;\n    var outer: f32;\n    var param_5: vec2<f32>;\n    var swirl: f32;\n    var param_6: vec2<f32>;\n    var core: f32;\n    var corona: f32;\n    var body: f32;\n    var col: vec3<f32>;\n    var alpha: f32;\n    var fog: f32;\n    var param_7: f32;\n    var param_8: f32;\n    var phi_266_: bool;\n\n    let _e77 = unnamed.uClipEnabled;\n    let _e78 = (_e77 != 0i);\n    phi_266_ = _e78;\n    if _e78 {\n        let _e79 = vWorldPos_1;\n        let _e85 = unnamed.uClipPlane;\n        phi_266_ = (dot(vec4<f32>(_e79.x, _e79.y, _e79.z, 1f), _e85) < 0f);\n    }\n    let _e89 = phi_266_;\n    if _e89 {\n        discard;\n    }\n    let _e90 = vUv_1;\n    radius = (length((_e90 - vec2(0.5f))) * 2f);\n    let _e95 = radius;\n    if (_e95 >= 1f) {\n        discard;\n    }\n    let _e97 = vUv_1;\n    d = (_e97 - vec2(0.5f));\n    let _e101 = d[1u];\n    let _e103 = d[0u];\n    angle = atan2(_e101, _e103);\n    let _e106 = unnamed.uTime;\n    let _e107 = vSeed_1;\n    t_1 = (_e106 + (_e107 * 37f));\n    let _e110 = angle;\n    let _e112 = t_1;\n    let _e115 = radius;\n    param_4 = vec2<f32>(((_e110 * 1.9f) + (_e112 * 0.55f)), (_e115 * 4.2f));\n    let _e118 = valueNoise_u0028_vf2_u003b((&param_4));\n    inner = _e118;\n    let _e119 = angle;\n    let _e121 = t_1;\n    let _e124 = radius;\n    param_5 = vec2<f32>(((_e119 * 3.1f) - (_e121 * 0.34f)), (_e124 * 2.6f));\n    let _e127 = valueNoise_u0028_vf2_u003b((&param_5));\n    outer = _e127;\n    let _e128 = inner;\n    let _e130 = outer;\n    swirl = ((_e128 * 0.62f) + (_e130 * 0.38f));\n    let _e134 = unnamed.uNoiseOctaves;\n    if (_e134 > 1i) {\n        let _e136 = swirl;\n        let _e137 = swirl;\n        let _e138 = angle;\n        let _e140 = t_1;\n        let _e143 = radius;\n        param_6 = vec2<f32>(((_e138 * 6.3f) + (_e140 * 0.9f)), (_e143 * 8f));\n        let _e146 = valueNoise_u0028_vf2_u003b((&param_6));\n        swirl = mix(_e136, ((_e137 * _e146) * 2f), 0.35f);\n    }\n    let _e150 = radius;\n    core = (1f - smoothstep(0f, 0.28f, _e150));\n    let _e153 = radius;\n    let _e156 = swirl;\n    corona = ((1f - smoothstep(0.18f, 1f, _e153)) * (0.35f + (_e156 * 0.65f)));\n    let _e160 = core;\n    let _e162 = corona;\n    body = ((_e160 * 0.9f) + _e162);\n    let _e164 = body;\n    if (_e164 <= 0.02f) {\n        discard;\n    }\n    let _e167 = unnamed.uTint;\n    let _e170 = unnamed.uTint;\n    let _e171 = body;\n    col = mix((_e167 * 0.35f), _e170, vec3(smoothstep(0f, 0.55f, _e171)));\n    let _e175 = col;\n    let _e176 = body;\n    col = mix(_e175, vec3<f32>(1f, 1f, 1f), vec3(smoothstep(0.82f, 1.4f, _e176)));\n    let _e181 = unnamed.uTint;\n    let _e182 = col;\n    col = (_e182 * _e181);\n    let _e184 = body;\n    alpha = clamp((_e184 * 1.6f), 0f, 1f);\n    let _e187 = vDistance_1;\n    param_7 = _e187;\n    let _e189 = vWorldPos_1[1u];\n    param_8 = _e189;\n    let _e190 = mediumFog_u0028_f1_u003b_f1_u003b((&param_7), (&param_8));\n    fog = _e190;\n    let _e191 = col;\n    let _e192 = mediumColor_u0028_();\n    let _e193 = fog;\n    col = mix(_e191, _e192, vec3(_e193));\n    let _e196 = fog;\n    let _e198 = alpha;\n    alpha = (_e198 * (1f - _e196));\n    let _e200 = col;\n    let _e201 = alpha;\n    outColor = vec4<f32>(_e200.x, _e200.y, _e200.z, _e201);\n    return;\n}\n\n@fragment \nfn main(@location(3) vWorldPos: vec3<f32>, @location(0) vUv: vec2<f32>, @location(1) vSeed: f32, @location(2) vDistance: f32) -> @location(0) vec4<f32> {\n    vWorldPos_1 = vWorldPos;\n    vUv_1 = vUv;\n    vSeed_1 = vSeed;\n    vDistance_1 = vDistance;\n    main_1();\n    let _e9 = outColor;\n    return _e9;\n}\n";
 /**
  * What the transform assigned, so the renderer binds the same numbers.
  *

package/dist/render/shaders/generated/arcane.wgsl.js

@@ -4,7 +4,7 @@
  * The GLSL beside this file is the source of truth. A hand edit here is discarded by
  * the next generation, and `npm run wgsl:check` fails the build when this is stale.
  */
-export const ARCANE_FRAG_WGSL = "struct Uniforms {\n    uTime: f32,\n    uFogColor: vec3<f32>,\n    uFogDensity: f32,\n    uFogHeightFalloff: f32,\n    uFogEyeY: f32,\n    uUnderwaterColor: vec3<f32>,\n    uUnderwaterFogDensity: f32,\n    uUnderwaterFactor: f32,\n    uFogMode: i32,\n    uFogNear: f32,\n    uFogFar: f32,\n    uNoiseOctaves: i32,\n    uClipPlane: vec4<f32>,\n    uClipEnabled: i32,\n    uTint: vec3<f32>,\n}\n\n@group(0) @binding(1) \nvar<uniform> unnamed: Uniforms;\nvar<private> vWorldPos_1: vec3<f32>;\nvar<private> vUv_1: vec2<f32>;\nvar<private> vSeed_1: f32;\nvar<private> vDistance_1: f32;\nvar<private> outColor: vec4<f32>;\n\nfn mediumColor_u0028_() -> vec3<f32> {\n    let _e59 = unnamed.uFogColor;\n    let _e61 = unnamed.uUnderwaterColor;\n    let _e63 = unnamed.uUnderwaterFactor;\n    return mix(_e59, _e61, vec3(_e63));\n}\n\nfn mediumFog_u0028_f1_u003b_f1_u003b(dist: ptr<function, f32>, pointY: ptr<function, f32>) -> f32 {\n    var span: f32;\n    var ramp: f32;\n    var wetLinear: f32;\n    var t: f32;\n    var denom: f32;\n    var air: f32;\n    var wet: f32;\n\n    let _e68 = unnamed.uFogMode;\n    if (_e68 == 1i) {\n        let _e71 = unnamed.uFogFar;\n        let _e73 = unnamed.uFogNear;\n        span = max((_e71 - _e73), 0.0001f);\n        let _e76 = (*dist);\n        let _e78 = unnamed.uFogNear;\n        let _e80 = span;\n        ramp = clamp(((_e76 - _e78) / _e80), 0f, 1f);\n        let _e84 = unnamed.uUnderwaterFactor;\n        if (_e84 <= 0f) {\n            let _e86 = ramp;\n            return _e86;\n        }\n        let _e88 = unnamed.uUnderwaterFogDensity;\n        let _e89 = (*dist);\n        wetLinear = (_e88 * _e89);\n        let _e91 = ramp;\n        let _e92 = wetLinear;\n        let _e94 = wetLinear;\n        let _e100 = unnamed.uUnderwaterFactor;\n        return mix(_e91, (1f - exp2(((-(_e92) * _e94) * 1.442695f))), _e100);\n    }\n    let _e102 = (*pointY);\n    let _e104 = unnamed.uFogEyeY;\n    let _e107 = unnamed.uFogHeightFalloff;\n    t = ((_e102 - _e104) * _e107);\n    let _e109 = t;\n    let _e112 = t;\n    denom = select(_e112, 0.0001f, (abs(_e109) < 0.0001f));\n    let _e115 = unnamed.uFogDensity;\n    let _e117 = (*dist);\n    let _e119 = denom;\n    let _e124 = denom;\n    air = (1f - exp((((-(_e115) * _e117) * (1f - exp(-(_e119)))) / _e124)));\n    let _e129 = unnamed.uUnderwaterFactor;\n    if (_e129 <= 0f) {\n        let _e131 = air;\n        return _e131;\n    }\n    let _e133 = unnamed.uUnderwaterFogDensity;\n    let _e134 = (*dist);\n    wet = (_e133 * _e134);\n    let _e136 = air;\n    let _e137 = wet;\n    let _e139 = wet;\n    let _e145 = unnamed.uUnderwaterFactor;\n    return mix(_e136, (1f - exp2(((-(_e137) * _e139) * 1.442695f))), _e145);\n}\n\nfn hash21_u0028_vf2_u003b(p: ptr<function, vec2<f32>>) -> f32 {\n    let _e59 = (*p);\n    return fract((sin(dot(_e59, vec2<f32>(127.1f, 311.7f))) * 43758.547f));\n}\n\nfn valueNoise_u0028_vf2_u003b(p_1: ptr<function, vec2<f32>>) -> f32 {\n    var i: vec2<f32>;\n    var f: vec2<f32>;\n    var u: vec2<f32>;\n    var param: vec2<f32>;\n    var param_1: vec2<f32>;\n    var param_2: vec2<f32>;\n    var param_3: vec2<f32>;\n\n    let _e66 = (*p_1);\n    i = floor(_e66);\n    let _e68 = (*p_1);\n    f = fract(_e68);\n    let _e70 = f;\n    let _e71 = f;\n    let _e73 = f;\n    u = ((_e70 * _e71) * (vec2(3f) - (_e73 * 2f)));\n    let _e78 = i;\n    param = _e78;\n    let _e79 = hash21_u0028_vf2_u003b((&param));\n    let _e80 = i;\n    param_1 = (_e80 + vec2<f32>(1f, 0f));\n    let _e82 = hash21_u0028_vf2_u003b((&param_1));\n    let _e84 = u[0u];\n    let _e86 = i;\n    param_2 = (_e86 + vec2<f32>(0f, 1f));\n    let _e88 = hash21_u0028_vf2_u003b((&param_2));\n    let _e89 = i;\n    param_3 = (_e89 + vec2<f32>(1f, 1f));\n    let _e91 = hash21_u0028_vf2_u003b((&param_3));\n    let _e93 = u[0u];\n    let _e96 = u[1u];\n    return mix(mix(_e79, _e82, _e84), mix(_e88, _e91, _e93), _e96);\n}\n\nfn main_1() {\n    var radius: f32;\n    var d: vec2<f32>;\n    var angle: f32;\n    var t_1: f32;\n    var inner: f32;\n    var param_4: vec2<f32>;\n    var outer: f32;\n    var param_5: vec2<f32>;\n    var swirl: f32;\n    var param_6: vec2<f32>;\n    var core: f32;\n    var corona: f32;\n    var body: f32;\n    var col: vec3<f32>;\n    var alpha: f32;\n    var fog: f32;\n    var param_7: f32;\n    var param_8: f32;\n    var phi_237_: bool;\n\n    let _e77 = unnamed.uClipEnabled;\n    let _e78 = (_e77 != 0i);\n    phi_237_ = _e78;\n    if _e78 {\n        let _e79 = vWorldPos_1;\n        let _e85 = unnamed.uClipPlane;\n        phi_237_ = (dot(vec4<f32>(_e79.x, _e79.y, _e79.z, 1f), _e85) < 0f);\n    }\n    let _e89 = phi_237_;\n    if _e89 {\n        discard;\n    }\n    let _e90 = vUv_1;\n    radius = (length((_e90 - vec2(0.5f))) * 2f);\n    let _e95 = radius;\n    if (_e95 >= 1f) {\n        discard;\n    }\n    let _e97 = vUv_1;\n    d = (_e97 - vec2(0.5f));\n    let _e101 = d[1u];\n    let _e103 = d[0u];\n    angle = atan2(_e101, _e103);\n    let _e106 = unnamed.uTime;\n    let _e107 = vSeed_1;\n    t_1 = (_e106 + (_e107 * 37f));\n    let _e110 = angle;\n    let _e112 = t_1;\n    let _e115 = radius;\n    param_4 = vec2<f32>(((_e110 * 1.9f) + (_e112 * 0.55f)), (_e115 * 4.2f));\n    let _e118 = valueNoise_u0028_vf2_u003b((&param_4));\n    inner = _e118;\n    let _e119 = angle;\n    let _e121 = t_1;\n    let _e124 = radius;\n    param_5 = vec2<f32>(((_e119 * 3.1f) - (_e121 * 0.34f)), (_e124 * 2.6f));\n    let _e127 = valueNoise_u0028_vf2_u003b((&param_5));\n    outer = _e127;\n    let _e128 = inner;\n    let _e130 = outer;\n    swirl = ((_e128 * 0.62f) + (_e130 * 0.38f));\n    let _e134 = unnamed.uNoiseOctaves;\n    if (_e134 > 1i) {\n        let _e136 = swirl;\n        let _e137 = swirl;\n        let _e138 = angle;\n        let _e140 = t_1;\n        let _e143 = radius;\n        param_6 = vec2<f32>(((_e138 * 6.3f) + (_e140 * 0.9f)), (_e143 * 8f));\n        let _e146 = valueNoise_u0028_vf2_u003b((&param_6));\n        swirl = mix(_e136, ((_e137 * _e146) * 2f), 0.35f);\n    }\n    let _e150 = radius;\n    core = (1f - smoothstep(0f, 0.28f, _e150));\n    let _e153 = radius;\n    let _e156 = swirl;\n    corona = ((1f - smoothstep(0.18f, 1f, _e153)) * (0.35f + (_e156 * 0.65f)));\n    let _e160 = core;\n    let _e162 = corona;\n    body = ((_e160 * 0.9f) + _e162);\n    let _e164 = body;\n    if (_e164 <= 0.02f) {\n        discard;\n    }\n    let _e167 = unnamed.uTint;\n    let _e170 = unnamed.uTint;\n    let _e171 = body;\n    col = mix((_e167 * 0.35f), _e170, vec3(smoothstep(0f, 0.55f, _e171)));\n    let _e175 = col;\n    let _e176 = body;\n    col = mix(_e175, vec3<f32>(1f, 1f, 1f), vec3(smoothstep(0.82f, 1.4f, _e176)));\n    let _e181 = unnamed.uTint;\n    let _e182 = col;\n    col = (_e182 * _e181);\n    let _e184 = body;\n    alpha = clamp((_e184 * 1.6f), 0f, 1f);\n    let _e187 = vDistance_1;\n    param_7 = _e187;\n    let _e189 = vWorldPos_1[1u];\n    param_8 = _e189;\n    let _e190 = mediumFog_u0028_f1_u003b_f1_u003b((&param_7), (&param_8));\n    fog = _e190;\n    let _e191 = col;\n    let _e192 = mediumColor_u0028_();\n    let _e193 = fog;\n    col = mix(_e191, _e192, vec3(_e193));\n    let _e196 = fog;\n    let _e198 = alpha;\n    alpha = (_e198 * (1f - _e196));\n    let _e200 = col;\n    let _e201 = alpha;\n    outColor = vec4<f32>(_e200.x, _e200.y, _e200.z, _e201);\n    return;\n}\n\n@fragment \nfn main(@location(3) vWorldPos: vec3<f32>, @location(0) vUv: vec2<f32>, @location(1) vSeed: f32, @location(2) vDistance: f32) -> @location(0) vec4<f32> {\n    vWorldPos_1 = vWorldPos;\n    vUv_1 = vUv;\n    vSeed_1 = vSeed;\n    vDistance_1 = vDistance;\n    main_1();\n    let _e9 = outColor;\n    return _e9;\n}\n";
+export const ARCANE_FRAG_WGSL = "struct Uniforms {\n    uTime: f32,\n    uFogColor: vec3<f32>,\n    uFogDensity: f32,\n    uFogHeightFalloff: f32,\n    uFogEyeY: f32,\n    uUnderwaterColor: vec3<f32>,\n    uUnderwaterFogDensity: f32,\n    uUnderwaterFactor: f32,\n    uFogMode: i32,\n    uFogNear: f32,\n    uFogFar: f32,\n    uNoiseOctaves: i32,\n    uClipPlane: vec4<f32>,\n    uClipEnabled: i32,\n    uTint: vec3<f32>,\n}\n\n@group(0) @binding(1) \nvar<uniform> unnamed: Uniforms;\nvar<private> vWorldPos_1: vec3<f32>;\nvar<private> vUv_1: vec2<f32>;\nvar<private> vSeed_1: f32;\nvar<private> vDistance_1: f32;\nvar<private> outColor: vec4<f32>;\n\nfn mediumColor_u0028_() -> vec3<f32> {\n    let _e59 = unnamed.uFogColor;\n    let _e61 = unnamed.uUnderwaterColor;\n    let _e63 = unnamed.uUnderwaterFactor;\n    return mix(_e59, _e61, vec3(_e63));\n}\n\nfn mediumFog_u0028_f1_u003b_f1_u003b(dist: ptr<function, f32>, pointY: ptr<function, f32>) -> f32 {\n    var span: f32;\n    var ramp: f32;\n    var wetLinear: f32;\n    var start: f32;\n    var before: f32;\n    var local: f32;\n    var t: f32;\n    var rest: f32;\n    var denom: f32;\n    var air: f32;\n    var wet: f32;\n\n    let _e72 = unnamed.uFogMode;\n    if (_e72 == 1i) {\n        let _e75 = unnamed.uFogFar;\n        let _e77 = unnamed.uFogNear;\n        span = max((_e75 - _e77), 0.0001f);\n        let _e80 = (*dist);\n        let _e82 = unnamed.uFogNear;\n        let _e84 = span;\n        ramp = clamp(((_e80 - _e82) / _e84), 0f, 1f);\n        let _e88 = unnamed.uUnderwaterFactor;\n        if (_e88 <= 0f) {\n            let _e90 = ramp;\n            return _e90;\n        }\n        let _e92 = unnamed.uUnderwaterFogDensity;\n        let _e93 = (*dist);\n        wetLinear = (_e92 * _e93);\n        let _e95 = ramp;\n        let _e96 = wetLinear;\n        let _e98 = wetLinear;\n        let _e104 = unnamed.uUnderwaterFactor;\n        return mix(_e95, (1f - exp2(((-(_e96) * _e98) * 1.442695f))), _e104);\n    }\n    let _e107 = unnamed.uFogNear;\n    let _e108 = (*dist);\n    start = min(_e107, _e108);\n    let _e110 = (*dist);\n    if (_e110 > 0f) {\n        let _e112 = start;\n        let _e113 = (*dist);\n        local = (_e112 / _e113);\n    } else {\n        local = 0f;\n    }\n    let _e115 = local;\n    before = _e115;\n    let _e116 = (*pointY);\n    let _e118 = unnamed.uFogEyeY;\n    let _e121 = unnamed.uFogHeightFalloff;\n    t = ((_e116 - _e118) * _e121);\n    let _e123 = t;\n    let _e124 = before;\n    rest = (_e123 * (1f - _e124));\n    let _e127 = rest;\n    let _e130 = rest;\n    denom = select(_e130, 0.0001f, (abs(_e127) < 0.0001f));\n    let _e133 = unnamed.uFogDensity;\n    let _e135 = t;\n    let _e137 = before;\n    let _e141 = (*dist);\n    let _e142 = start;\n    let _e145 = denom;\n    let _e150 = denom;\n    air = (1f - exp(((((-(_e133) * exp((-(_e135) * _e137))) * (_e141 - _e142)) * (1f - exp(-(_e145)))) / _e150)));\n    let _e155 = unnamed.uUnderwaterFactor;\n    if (_e155 <= 0f) {\n        let _e157 = air;\n        return _e157;\n    }\n    let _e159 = unnamed.uUnderwaterFogDensity;\n    let _e160 = (*dist);\n    wet = (_e159 * _e160);\n    let _e162 = air;\n    let _e163 = wet;\n    let _e165 = wet;\n    let _e171 = unnamed.uUnderwaterFactor;\n    return mix(_e162, (1f - exp2(((-(_e163) * _e165) * 1.442695f))), _e171);\n}\n\nfn hash21_u0028_vf2_u003b(p: ptr<function, vec2<f32>>) -> f32 {\n    let _e59 = (*p);\n    return fract((sin(dot(_e59, vec2<f32>(127.1f, 311.7f))) * 43758.547f));\n}\n\nfn valueNoise_u0028_vf2_u003b(p_1: ptr<function, vec2<f32>>) -> f32 {\n    var i: vec2<f32>;\n    var f: vec2<f32>;\n    var u: vec2<f32>;\n    var param: vec2<f32>;\n    var param_1: vec2<f32>;\n    var param_2: vec2<f32>;\n    var param_3: vec2<f32>;\n\n    let _e66 = (*p_1);\n    i = floor(_e66);\n    let _e68 = (*p_1);\n    f = fract(_e68);\n    let _e70 = f;\n    let _e71 = f;\n    let _e73 = f;\n    u = ((_e70 * _e71) * (vec2(3f) - (_e73 * 2f)));\n    let _e78 = i;\n    param = _e78;\n    let _e79 = hash21_u0028_vf2_u003b((&param));\n    let _e80 = i;\n    param_1 = (_e80 + vec2<f32>(1f, 0f));\n    let _e82 = hash21_u0028_vf2_u003b((&param_1));\n    let _e84 = u[0u];\n    let _e86 = i;\n    param_2 = (_e86 + vec2<f32>(0f, 1f));\n    let _e88 = hash21_u0028_vf2_u003b((&param_2));\n    let _e89 = i;\n    param_3 = (_e89 + vec2<f32>(1f, 1f));\n    let _e91 = hash21_u0028_vf2_u003b((&param_3));\n    let _e93 = u[0u];\n    let _e96 = u[1u];\n    return mix(mix(_e79, _e82, _e84), mix(_e88, _e91, _e93), _e96);\n}\n\nfn main_1() {\n    var radius: f32;\n    var d: vec2<f32>;\n    var angle: f32;\n    var t_1: f32;\n    var inner: f32;\n    var param_4: vec2<f32>;\n    var outer: f32;\n    var param_5: vec2<f32>;\n    var swirl: f32;\n    var param_6: vec2<f32>;\n    var core: f32;\n    var corona: f32;\n    var body: f32;\n    var col: vec3<f32>;\n    var alpha: f32;\n    var fog: f32;\n    var param_7: f32;\n    var param_8: f32;\n    var phi_266_: bool;\n\n    let _e77 = unnamed.uClipEnabled;\n    let _e78 = (_e77 != 0i);\n    phi_266_ = _e78;\n    if _e78 {\n        let _e79 = vWorldPos_1;\n        let _e85 = unnamed.uClipPlane;\n        phi_266_ = (dot(vec4<f32>(_e79.x, _e79.y, _e79.z, 1f), _e85) < 0f);\n    }\n    let _e89 = phi_266_;\n    if _e89 {\n        discard;\n    }\n    let _e90 = vUv_1;\n    radius = (length((_e90 - vec2(0.5f))) * 2f);\n    let _e95 = radius;\n    if (_e95 >= 1f) {\n        discard;\n    }\n    let _e97 = vUv_1;\n    d = (_e97 - vec2(0.5f));\n    let _e101 = d[1u];\n    let _e103 = d[0u];\n    angle = atan2(_e101, _e103);\n    let _e106 = unnamed.uTime;\n    let _e107 = vSeed_1;\n    t_1 = (_e106 + (_e107 * 37f));\n    let _e110 = angle;\n    let _e112 = t_1;\n    let _e115 = radius;\n    param_4 = vec2<f32>(((_e110 * 1.9f) + (_e112 * 0.55f)), (_e115 * 4.2f));\n    let _e118 = valueNoise_u0028_vf2_u003b((&param_4));\n    inner = _e118;\n    let _e119 = angle;\n    let _e121 = t_1;\n    let _e124 = radius;\n    param_5 = vec2<f32>(((_e119 * 3.1f) - (_e121 * 0.34f)), (_e124 * 2.6f));\n    let _e127 = valueNoise_u0028_vf2_u003b((&param_5));\n    outer = _e127;\n    let _e128 = inner;\n    let _e130 = outer;\n    swirl = ((_e128 * 0.62f) + (_e130 * 0.38f));\n    let _e134 = unnamed.uNoiseOctaves;\n    if (_e134 > 1i) {\n        let _e136 = swirl;\n        let _e137 = swirl;\n        let _e138 = angle;\n        let _e140 = t_1;\n        let _e143 = radius;\n        param_6 = vec2<f32>(((_e138 * 6.3f) + (_e140 * 0.9f)), (_e143 * 8f));\n        let _e146 = valueNoise_u0028_vf2_u003b((&param_6));\n        swirl = mix(_e136, ((_e137 * _e146) * 2f), 0.35f);\n    }\n    let _e150 = radius;\n    core = (1f - smoothstep(0f, 0.28f, _e150));\n    let _e153 = radius;\n    let _e156 = swirl;\n    corona = ((1f - smoothstep(0.18f, 1f, _e153)) * (0.35f + (_e156 * 0.65f)));\n    let _e160 = core;\n    let _e162 = corona;\n    body = ((_e160 * 0.9f) + _e162);\n    let _e164 = body;\n    if (_e164 <= 0.02f) {\n        discard;\n    }\n    let _e167 = unnamed.uTint;\n    let _e170 = unnamed.uTint;\n    let _e171 = body;\n    col = mix((_e167 * 0.35f), _e170, vec3(smoothstep(0f, 0.55f, _e171)));\n    let _e175 = col;\n    let _e176 = body;\n    col = mix(_e175, vec3<f32>(1f, 1f, 1f), vec3(smoothstep(0.82f, 1.4f, _e176)));\n    let _e181 = unnamed.uTint;\n    let _e182 = col;\n    col = (_e182 * _e181);\n    let _e184 = body;\n    alpha = clamp((_e184 * 1.6f), 0f, 1f);\n    let _e187 = vDistance_1;\n    param_7 = _e187;\n    let _e189 = vWorldPos_1[1u];\n    param_8 = _e189;\n    let _e190 = mediumFog_u0028_f1_u003b_f1_u003b((&param_7), (&param_8));\n    fog = _e190;\n    let _e191 = col;\n    let _e192 = mediumColor_u0028_();\n    let _e193 = fog;\n    col = mix(_e191, _e192, vec3(_e193));\n    let _e196 = fog;\n    let _e198 = alpha;\n    alpha = (_e198 * (1f - _e196));\n    let _e200 = col;\n    let _e201 = alpha;\n    outColor = vec4<f32>(_e200.x, _e200.y, _e200.z, _e201);\n    return;\n}\n\n@fragment \nfn main(@location(3) vWorldPos: vec3<f32>, @location(0) vUv: vec2<f32>, @location(1) vSeed: f32, @location(2) vDistance: f32) -> @location(0) vec4<f32> {\n    vWorldPos_1 = vWorldPos;\n    vUv_1 = vUv;\n    vSeed_1 = vSeed;\n    vDistance_1 = vDistance;\n    main_1();\n    let _e9 = outColor;\n    return _e9;\n}\n";
 /**
  * What the transform assigned, so the renderer binds the same numbers.
  *

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

@@ -1,4 +1,4 @@
-export declare const BOLT_FRAG_WGSL = "struct Uniforms {\n    uTime: f32,\n    uCoreColor: vec3<f32>,\n    uEdgeColor: vec3<f32>,\n    uCoreGain: f32,\n    uFogColor: vec3<f32>,\n    uFogDensity: f32,\n    uFogHeightFalloff: f32,\n    uFogEyeY: f32,\n    uUnderwaterColor: vec3<f32>,\n    uUnderwaterFogDensity: f32,\n    uUnderwaterFactor: f32,\n    uFogMode: i32,\n    uFogNear: f32,\n    uFogFar: f32,\n    uCameraPos: vec3<f32>,\n}\n\n@group(0) @binding(1) \nvar<uniform> unnamed: Uniforms;\nvar<private> vSide_1: f32;\nvar<private> vSeed_1: f32;\nvar<private> vAlong_1: f32;\nvar<private> vFade_1: f32;\nvar<private> vGain_1: f32;\nvar<private> vWorldPos_1: vec3<f32>;\nvar<private> outColor: vec4<f32>;\n\nfn mediumFog_u0028_f1_u003b_f1_u003b(dist: ptr<function, f32>, pointY: ptr<function, f32>) -> f32 {\n    var span: f32;\n    var ramp: f32;\n    var wetLinear: f32;\n    var t: f32;\n    var denom: f32;\n    var air: f32;\n    var wet: f32;\n\n    let _e48 = unnamed.uFogMode;\n    if (_e48 == 1i) {\n        let _e51 = unnamed.uFogFar;\n        let _e53 = unnamed.uFogNear;\n        span = max((_e51 - _e53), 0.0001f);\n        let _e56 = (*dist);\n        let _e58 = unnamed.uFogNear;\n        let _e60 = span;\n        ramp = clamp(((_e56 - _e58) / _e60), 0f, 1f);\n        let _e64 = unnamed.uUnderwaterFactor;\n        if (_e64 <= 0f) {\n            let _e66 = ramp;\n            return _e66;\n        }\n        let _e68 = unnamed.uUnderwaterFogDensity;\n        let _e69 = (*dist);\n        wetLinear = (_e68 * _e69);\n        let _e71 = ramp;\n        let _e72 = wetLinear;\n        let _e74 = wetLinear;\n        let _e80 = unnamed.uUnderwaterFactor;\n        return mix(_e71, (1f - exp2(((-(_e72) * _e74) * 1.442695f))), _e80);\n    }\n    let _e82 = (*pointY);\n    let _e84 = unnamed.uFogEyeY;\n    let _e87 = unnamed.uFogHeightFalloff;\n    t = ((_e82 - _e84) * _e87);\n    let _e89 = t;\n    let _e92 = t;\n    denom = select(_e92, 0.0001f, (abs(_e89) < 0.0001f));\n    let _e95 = unnamed.uFogDensity;\n    let _e97 = (*dist);\n    let _e99 = denom;\n    let _e104 = denom;\n    air = (1f - exp((((-(_e95) * _e97) * (1f - exp(-(_e99)))) / _e104)));\n    let _e109 = unnamed.uUnderwaterFactor;\n    if (_e109 <= 0f) {\n        let _e111 = air;\n        return _e111;\n    }\n    let _e113 = unnamed.uUnderwaterFogDensity;\n    let _e114 = (*dist);\n    wet = (_e113 * _e114);\n    let _e116 = air;\n    let _e117 = wet;\n    let _e119 = wet;\n    let _e125 = unnamed.uUnderwaterFactor;\n    return mix(_e116, (1f - exp2(((-(_e117) * _e119) * 1.442695f))), _e125);\n}\n\nfn hash11_u0028_f1_u003b(p: ptr<function, f32>) -> f32 {\n    let _e39 = (*p);\n    return fract((sin((_e39 * 12.9898f)) * 43758.547f));\n}\n\nfn main_1() {\n    var across: f32;\n    var core: f32;\n    var glow: f32;\n    var t_1: f32;\n    var stutter: f32;\n    var param: f32;\n    var param_1: f32;\n    var taper: f32;\n    var energy: f32;\n    var lit: vec3<f32>;\n    var fog: f32;\n    var param_2: f32;\n    var param_3: f32;\n\n    let _e51 = vSide_1;\n    across = clamp((1f - abs(_e51)), 0f, 1f);\n    let _e55 = across;\n    core = pow(_e55, 10f);\n    let _e57 = across;\n    glow = pow(_e57, 1.1f);\n    let _e60 = unnamed.uTime;\n    let _e62 = vSeed_1;\n    t_1 = ((_e60 * 47f) + (_e62 * 17f));\n    let _e65 = t_1;\n    param = floor(_e65);\n    let _e67 = hash11_u0028_f1_u003b((&param));\n    let _e69 = t_1;\n    param_1 = floor((_e69 * 2.37f));\n    let _e72 = hash11_u0028_f1_u003b((&param_1));\n    stutter = (0.78f + (0.22f * ((_e67 * 0.6f) + (_e72 * 0.4f))));\n    let _e77 = vAlong_1;\n    taper = (1f - (_e77 * 0.55f));\n    let _e80 = vFade_1;\n    let _e81 = stutter;\n    let _e83 = taper;\n    let _e85 = vGain_1;\n    energy = (((_e80 * _e81) * _e83) * _e85);\n    let _e88 = unnamed.uEdgeColor;\n    let _e89 = glow;\n    let _e92 = unnamed.uCoreColor;\n    let _e93 = core;\n    let _e96 = unnamed.uCoreGain;\n    lit = ((_e88 * _e89) + ((_e92 * _e93) * _e96));\n    let _e99 = vWorldPos_1;\n    let _e101 = unnamed.uCameraPos;\n    param_2 = distance(_e99, _e101);\n    let _e104 = vWorldPos_1[1u];\n    param_3 = _e104;\n    let _e105 = mediumFog_u0028_f1_u003b_f1_u003b((&param_2), (&param_3));\n    fog = _e105;\n    let _e106 = lit;\n    let _e107 = energy;\n    let _e109 = fog;\n    let _e111 = ((_e106 * _e107) * (1f - _e109));\n    outColor = vec4<f32>(_e111.x, _e111.y, _e111.z, 1f);\n    return;\n}\n\n@fragment \nfn main(@location(0) vSide: f32, @location(3) vSeed: f32, @location(1) vAlong: f32, @location(2) vFade: f32, @location(4) vGain: f32, @location(5) vWorldPos: vec3<f32>) -> @location(0) vec4<f32> {\n    vSide_1 = vSide;\n    vSeed_1 = vSeed;\n    vAlong_1 = vAlong;\n    vFade_1 = vFade;\n    vGain_1 = vGain;\n    vWorldPos_1 = vWorldPos;\n    main_1();\n    let _e13 = outColor;\n    return _e13;\n}\n";
+export declare const BOLT_FRAG_WGSL = "struct Uniforms {\n    uTime: f32,\n    uCoreColor: vec3<f32>,\n    uEdgeColor: vec3<f32>,\n    uCoreGain: f32,\n    uFogColor: vec3<f32>,\n    uFogDensity: f32,\n    uFogHeightFalloff: f32,\n    uFogEyeY: f32,\n    uUnderwaterColor: vec3<f32>,\n    uUnderwaterFogDensity: f32,\n    uUnderwaterFactor: f32,\n    uFogMode: i32,\n    uFogNear: f32,\n    uFogFar: f32,\n    uCameraPos: vec3<f32>,\n}\n\n@group(0) @binding(1) \nvar<uniform> unnamed: Uniforms;\nvar<private> vSide_1: f32;\nvar<private> vSeed_1: f32;\nvar<private> vAlong_1: f32;\nvar<private> vFade_1: f32;\nvar<private> vGain_1: f32;\nvar<private> vWorldPos_1: vec3<f32>;\nvar<private> outColor: vec4<f32>;\n\nfn mediumFog_u0028_f1_u003b_f1_u003b(dist: ptr<function, f32>, pointY: ptr<function, f32>) -> f32 {\n    var span: f32;\n    var ramp: f32;\n    var wetLinear: f32;\n    var start: f32;\n    var before: f32;\n    var local: f32;\n    var t: f32;\n    var rest: f32;\n    var denom: f32;\n    var air: f32;\n    var wet: f32;\n\n    let _e52 = unnamed.uFogMode;\n    if (_e52 == 1i) {\n        let _e55 = unnamed.uFogFar;\n        let _e57 = unnamed.uFogNear;\n        span = max((_e55 - _e57), 0.0001f);\n        let _e60 = (*dist);\n        let _e62 = unnamed.uFogNear;\n        let _e64 = span;\n        ramp = clamp(((_e60 - _e62) / _e64), 0f, 1f);\n        let _e68 = unnamed.uUnderwaterFactor;\n        if (_e68 <= 0f) {\n            let _e70 = ramp;\n            return _e70;\n        }\n        let _e72 = unnamed.uUnderwaterFogDensity;\n        let _e73 = (*dist);\n        wetLinear = (_e72 * _e73);\n        let _e75 = ramp;\n        let _e76 = wetLinear;\n        let _e78 = wetLinear;\n        let _e84 = unnamed.uUnderwaterFactor;\n        return mix(_e75, (1f - exp2(((-(_e76) * _e78) * 1.442695f))), _e84);\n    }\n    let _e87 = unnamed.uFogNear;\n    let _e88 = (*dist);\n    start = min(_e87, _e88);\n    let _e90 = (*dist);\n    if (_e90 > 0f) {\n        let _e92 = start;\n        let _e93 = (*dist);\n        local = (_e92 / _e93);\n    } else {\n        local = 0f;\n    }\n    let _e95 = local;\n    before = _e95;\n    let _e96 = (*pointY);\n    let _e98 = unnamed.uFogEyeY;\n    let _e101 = unnamed.uFogHeightFalloff;\n    t = ((_e96 - _e98) * _e101);\n    let _e103 = t;\n    let _e104 = before;\n    rest = (_e103 * (1f - _e104));\n    let _e107 = rest;\n    let _e110 = rest;\n    denom = select(_e110, 0.0001f, (abs(_e107) < 0.0001f));\n    let _e113 = unnamed.uFogDensity;\n    let _e115 = t;\n    let _e117 = before;\n    let _e121 = (*dist);\n    let _e122 = start;\n    let _e125 = denom;\n    let _e130 = denom;\n    air = (1f - exp(((((-(_e113) * exp((-(_e115) * _e117))) * (_e121 - _e122)) * (1f - exp(-(_e125)))) / _e130)));\n    let _e135 = unnamed.uUnderwaterFactor;\n    if (_e135 <= 0f) {\n        let _e137 = air;\n        return _e137;\n    }\n    let _e139 = unnamed.uUnderwaterFogDensity;\n    let _e140 = (*dist);\n    wet = (_e139 * _e140);\n    let _e142 = air;\n    let _e143 = wet;\n    let _e145 = wet;\n    let _e151 = unnamed.uUnderwaterFactor;\n    return mix(_e142, (1f - exp2(((-(_e143) * _e145) * 1.442695f))), _e151);\n}\n\nfn hash11_u0028_f1_u003b(p: ptr<function, f32>) -> f32 {\n    let _e39 = (*p);\n    return fract((sin((_e39 * 12.9898f)) * 43758.547f));\n}\n\nfn main_1() {\n    var across: f32;\n    var core: f32;\n    var glow: f32;\n    var t_1: f32;\n    var stutter: f32;\n    var param: f32;\n    var param_1: f32;\n    var taper: f32;\n    var energy: f32;\n    var lit: vec3<f32>;\n    var fog: f32;\n    var param_2: f32;\n    var param_3: f32;\n\n    let _e51 = vSide_1;\n    across = clamp((1f - abs(_e51)), 0f, 1f);\n    let _e55 = across;\n    core = pow(_e55, 10f);\n    let _e57 = across;\n    glow = pow(_e57, 1.1f);\n    let _e60 = unnamed.uTime;\n    let _e62 = vSeed_1;\n    t_1 = ((_e60 * 47f) + (_e62 * 17f));\n    let _e65 = t_1;\n    param = floor(_e65);\n    let _e67 = hash11_u0028_f1_u003b((&param));\n    let _e69 = t_1;\n    param_1 = floor((_e69 * 2.37f));\n    let _e72 = hash11_u0028_f1_u003b((&param_1));\n    stutter = (0.78f + (0.22f * ((_e67 * 0.6f) + (_e72 * 0.4f))));\n    let _e77 = vAlong_1;\n    taper = (1f - (_e77 * 0.55f));\n    let _e80 = vFade_1;\n    let _e81 = stutter;\n    let _e83 = taper;\n    let _e85 = vGain_1;\n    energy = (((_e80 * _e81) * _e83) * _e85);\n    let _e88 = unnamed.uEdgeColor;\n    let _e89 = glow;\n    let _e92 = unnamed.uCoreColor;\n    let _e93 = core;\n    let _e96 = unnamed.uCoreGain;\n    lit = ((_e88 * _e89) + ((_e92 * _e93) * _e96));\n    let _e99 = vWorldPos_1;\n    let _e101 = unnamed.uCameraPos;\n    param_2 = distance(_e99, _e101);\n    let _e104 = vWorldPos_1[1u];\n    param_3 = _e104;\n    let _e105 = mediumFog_u0028_f1_u003b_f1_u003b((&param_2), (&param_3));\n    fog = _e105;\n    let _e106 = lit;\n    let _e107 = energy;\n    let _e109 = fog;\n    let _e111 = ((_e106 * _e107) * (1f - _e109));\n    outColor = vec4<f32>(_e111.x, _e111.y, _e111.z, 1f);\n    return;\n}\n\n@fragment \nfn main(@location(0) vSide: f32, @location(3) vSeed: f32, @location(1) vAlong: f32, @location(2) vFade: f32, @location(4) vGain: f32, @location(5) vWorldPos: vec3<f32>) -> @location(0) vec4<f32> {\n    vSide_1 = vSide;\n    vSeed_1 = vSeed;\n    vAlong_1 = vAlong;\n    vFade_1 = vFade;\n    vGain_1 = vGain;\n    vWorldPos_1 = vWorldPos;\n    main_1();\n    let _e13 = outColor;\n    return _e13;\n}\n";
 export declare const BOLT_VERT_WGSL = "struct Uniforms {\n    uViewProj: mat4x4<f32>,\n    uCameraPos: vec3<f32>,\n    uWidth: f32,\n    uMinWidthPerMetre: f32,\n}\n\nstruct gl_PerVertex {\n    @builtin(position) gl_Position: vec4<f32>,\n    gl_PointSize: f32,\n}\n\nstruct VertexOutput {\n    @location(0) member: f32,\n    @location(1) member_1: f32,\n    @location(2) member_2: f32,\n    @location(3) member_3: f32,\n    @location(4) member_4: f32,\n    @location(5) member_5: vec3<f32>,\n    @builtin(position) gl_Position: vec4<f32>,\n}\n\nvar<private> aFrom_1: vec3<f32>;\nvar<private> aTo_1: vec3<f32>;\nvar<private> aCorner_1: vec2<f32>;\n@group(0) @binding(0) \nvar<uniform> unnamed: Uniforms;\nvar<private> vSide: f32;\nvar<private> vAlong: f32;\nvar<private> aArc_1: vec4<f32>;\nvar<private> vFade: f32;\nvar<private> vSeed: f32;\nvar<private> vGain: f32;\nvar<private> vWorldPos: vec3<f32>;\nvar<private> unnamed_1: gl_PerVertex = gl_PerVertex(vec4<f32>(0f, 0f, 0f, 1f), 1f);\n\nfn main_1() {\n    var mid: vec3<f32>;\n    var dir: vec3<f32>;\n    var len: f32;\n    var local: vec3<f32>;\n    var view: vec3<f32>;\n    var dist: f32;\n    var local_1: vec3<f32>;\n    var across: vec3<f32>;\n    var span: f32;\n    var local_2: vec3<f32>;\n    var halfWidth: f32;\n    var world: vec3<f32>;\n\n    let _e40 = aFrom_1;\n    let _e41 = aTo_1;\n    let _e43 = aCorner_1[0u];\n    mid = mix(_e40, _e41, vec3(_e43));\n    let _e46 = aTo_1;\n    let _e47 = aFrom_1;\n    dir = (_e46 - _e47);\n    let _e49 = dir;\n    len = length(_e49);\n    let _e51 = len;\n    if (_e51 > 0.000001f) {\n        let _e53 = dir;\n        let _e54 = len;\n        local = (_e53 / vec3(_e54));\n    } else {\n        local = vec3<f32>(0f, 1f, 0f);\n    }\n    let _e57 = local;\n    dir = _e57;\n    let _e58 = mid;\n    let _e60 = unnamed.uCameraPos;\n    view = (_e58 - _e60);\n    let _e62 = view;\n    dist = length(_e62);\n    let _e64 = dist;\n    if (_e64 > 0.000001f) {\n        let _e66 = view;\n        let _e67 = dist;\n        local_1 = (_e66 / vec3(_e67));\n    } else {\n        local_1 = vec3<f32>(0f, 0f, 1f);\n    }\n    let _e70 = local_1;\n    view = _e70;\n    let _e71 = dir;\n    let _e72 = view;\n    across = cross(_e71, _e72);\n    let _e74 = across;\n    span = length(_e74);\n    let _e76 = span;\n    if (_e76 > 0.0001f) {\n        let _e78 = across;\n        let _e79 = span;\n        local_2 = (_e78 / vec3(_e79));\n    } else {\n        let _e82 = dir;\n        local_2 = normalize((cross(_e82, vec3<f32>(0f, 1f, 0f)) + vec3<f32>(0.001f, 0.001f, 0.001f)));\n    }\n    let _e86 = local_2;\n    across = _e86;\n    let _e88 = unnamed.uWidth;\n    let _e89 = dist;\n    let _e91 = unnamed.uMinWidthPerMetre;\n    halfWidth = max(_e88, (_e89 * _e91));\n    let _e94 = mid;\n    let _e95 = across;\n    let _e97 = aCorner_1[1u];\n    let _e99 = halfWidth;\n    world = (_e94 + ((_e95 * _e97) * _e99));\n    let _e103 = aCorner_1[1u];\n    vSide = _e103;\n    let _e105 = aArc_1[0u];\n    vAlong = _e105;\n    let _e107 = aArc_1[1u];\n    vFade = _e107;\n    let _e109 = aArc_1[2u];\n    vSeed = _e109;\n    let _e111 = aArc_1[3u];\n    vGain = _e111;\n    let _e112 = world;\n    vWorldPos = _e112;\n    let _e114 = unnamed.uViewProj;\n    let _e115 = world;\n    unnamed_1.gl_Position = (_e114 * vec4<f32>(_e115.x, _e115.y, _e115.z, 1f));\n    return;\n}\n\n@vertex \nfn main(@location(0) aFrom: vec3<f32>, @location(1) aTo: vec3<f32>, @location(2) aCorner: vec2<f32>, @location(3) aArc: vec4<f32>) -> VertexOutput {\n    aFrom_1 = aFrom;\n    aTo_1 = aTo;\n    aCorner_1 = aCorner;\n    aArc_1 = aArc;\n    main_1();\n    let _e17 = unnamed_1.gl_Position.y;\n    unnamed_1.gl_Position.y = -(_e17);\n    let _e19 = vSide;\n    let _e20 = vAlong;\n    let _e21 = vFade;\n    let _e22 = vSeed;\n    let _e23 = vGain;\n    let _e24 = vWorldPos;\n    let _e25 = unnamed_1.gl_Position;\n    return VertexOutput(_e19, _e20, _e21, _e22, _e23, _e24, _e25);\n}\n";
 /**
  * What the transform assigned, so the renderer binds the same numbers.

package/dist/render/shaders/generated/bolt.wgsl.js

@@ -4,7 +4,7 @@
  * The GLSL beside this file is the source of truth. A hand edit here is discarded by
  * the next generation, and `npm run wgsl:check` fails the build when this is stale.
  */
-export const BOLT_FRAG_WGSL = "struct Uniforms {\n    uTime: f32,\n    uCoreColor: vec3<f32>,\n    uEdgeColor: vec3<f32>,\n    uCoreGain: f32,\n    uFogColor: vec3<f32>,\n    uFogDensity: f32,\n    uFogHeightFalloff: f32,\n    uFogEyeY: f32,\n    uUnderwaterColor: vec3<f32>,\n    uUnderwaterFogDensity: f32,\n    uUnderwaterFactor: f32,\n    uFogMode: i32,\n    uFogNear: f32,\n    uFogFar: f32,\n    uCameraPos: vec3<f32>,\n}\n\n@group(0) @binding(1) \nvar<uniform> unnamed: Uniforms;\nvar<private> vSide_1: f32;\nvar<private> vSeed_1: f32;\nvar<private> vAlong_1: f32;\nvar<private> vFade_1: f32;\nvar<private> vGain_1: f32;\nvar<private> vWorldPos_1: vec3<f32>;\nvar<private> outColor: vec4<f32>;\n\nfn mediumFog_u0028_f1_u003b_f1_u003b(dist: ptr<function, f32>, pointY: ptr<function, f32>) -> f32 {\n    var span: f32;\n    var ramp: f32;\n    var wetLinear: f32;\n    var t: f32;\n    var denom: f32;\n    var air: f32;\n    var wet: f32;\n\n    let _e48 = unnamed.uFogMode;\n    if (_e48 == 1i) {\n        let _e51 = unnamed.uFogFar;\n        let _e53 = unnamed.uFogNear;\n        span = max((_e51 - _e53), 0.0001f);\n        let _e56 = (*dist);\n        let _e58 = unnamed.uFogNear;\n        let _e60 = span;\n        ramp = clamp(((_e56 - _e58) / _e60), 0f, 1f);\n        let _e64 = unnamed.uUnderwaterFactor;\n        if (_e64 <= 0f) {\n            let _e66 = ramp;\n            return _e66;\n        }\n        let _e68 = unnamed.uUnderwaterFogDensity;\n        let _e69 = (*dist);\n        wetLinear = (_e68 * _e69);\n        let _e71 = ramp;\n        let _e72 = wetLinear;\n        let _e74 = wetLinear;\n        let _e80 = unnamed.uUnderwaterFactor;\n        return mix(_e71, (1f - exp2(((-(_e72) * _e74) * 1.442695f))), _e80);\n    }\n    let _e82 = (*pointY);\n    let _e84 = unnamed.uFogEyeY;\n    let _e87 = unnamed.uFogHeightFalloff;\n    t = ((_e82 - _e84) * _e87);\n    let _e89 = t;\n    let _e92 = t;\n    denom = select(_e92, 0.0001f, (abs(_e89) < 0.0001f));\n    let _e95 = unnamed.uFogDensity;\n    let _e97 = (*dist);\n    let _e99 = denom;\n    let _e104 = denom;\n    air = (1f - exp((((-(_e95) * _e97) * (1f - exp(-(_e99)))) / _e104)));\n    let _e109 = unnamed.uUnderwaterFactor;\n    if (_e109 <= 0f) {\n        let _e111 = air;\n        return _e111;\n    }\n    let _e113 = unnamed.uUnderwaterFogDensity;\n    let _e114 = (*dist);\n    wet = (_e113 * _e114);\n    let _e116 = air;\n    let _e117 = wet;\n    let _e119 = wet;\n    let _e125 = unnamed.uUnderwaterFactor;\n    return mix(_e116, (1f - exp2(((-(_e117) * _e119) * 1.442695f))), _e125);\n}\n\nfn hash11_u0028_f1_u003b(p: ptr<function, f32>) -> f32 {\n    let _e39 = (*p);\n    return fract((sin((_e39 * 12.9898f)) * 43758.547f));\n}\n\nfn main_1() {\n    var across: f32;\n    var core: f32;\n    var glow: f32;\n    var t_1: f32;\n    var stutter: f32;\n    var param: f32;\n    var param_1: f32;\n    var taper: f32;\n    var energy: f32;\n    var lit: vec3<f32>;\n    var fog: f32;\n    var param_2: f32;\n    var param_3: f32;\n\n    let _e51 = vSide_1;\n    across = clamp((1f - abs(_e51)), 0f, 1f);\n    let _e55 = across;\n    core = pow(_e55, 10f);\n    let _e57 = across;\n    glow = pow(_e57, 1.1f);\n    let _e60 = unnamed.uTime;\n    let _e62 = vSeed_1;\n    t_1 = ((_e60 * 47f) + (_e62 * 17f));\n    let _e65 = t_1;\n    param = floor(_e65);\n    let _e67 = hash11_u0028_f1_u003b((&param));\n    let _e69 = t_1;\n    param_1 = floor((_e69 * 2.37f));\n    let _e72 = hash11_u0028_f1_u003b((&param_1));\n    stutter = (0.78f + (0.22f * ((_e67 * 0.6f) + (_e72 * 0.4f))));\n    let _e77 = vAlong_1;\n    taper = (1f - (_e77 * 0.55f));\n    let _e80 = vFade_1;\n    let _e81 = stutter;\n    let _e83 = taper;\n    let _e85 = vGain_1;\n    energy = (((_e80 * _e81) * _e83) * _e85);\n    let _e88 = unnamed.uEdgeColor;\n    let _e89 = glow;\n    let _e92 = unnamed.uCoreColor;\n    let _e93 = core;\n    let _e96 = unnamed.uCoreGain;\n    lit = ((_e88 * _e89) + ((_e92 * _e93) * _e96));\n    let _e99 = vWorldPos_1;\n    let _e101 = unnamed.uCameraPos;\n    param_2 = distance(_e99, _e101);\n    let _e104 = vWorldPos_1[1u];\n    param_3 = _e104;\n    let _e105 = mediumFog_u0028_f1_u003b_f1_u003b((&param_2), (&param_3));\n    fog = _e105;\n    let _e106 = lit;\n    let _e107 = energy;\n    let _e109 = fog;\n    let _e111 = ((_e106 * _e107) * (1f - _e109));\n    outColor = vec4<f32>(_e111.x, _e111.y, _e111.z, 1f);\n    return;\n}\n\n@fragment \nfn main(@location(0) vSide: f32, @location(3) vSeed: f32, @location(1) vAlong: f32, @location(2) vFade: f32, @location(4) vGain: f32, @location(5) vWorldPos: vec3<f32>) -> @location(0) vec4<f32> {\n    vSide_1 = vSide;\n    vSeed_1 = vSeed;\n    vAlong_1 = vAlong;\n    vFade_1 = vFade;\n    vGain_1 = vGain;\n    vWorldPos_1 = vWorldPos;\n    main_1();\n    let _e13 = outColor;\n    return _e13;\n}\n";
+export const BOLT_FRAG_WGSL = "struct Uniforms {\n    uTime: f32,\n    uCoreColor: vec3<f32>,\n    uEdgeColor: vec3<f32>,\n    uCoreGain: f32,\n    uFogColor: vec3<f32>,\n    uFogDensity: f32,\n    uFogHeightFalloff: f32,\n    uFogEyeY: f32,\n    uUnderwaterColor: vec3<f32>,\n    uUnderwaterFogDensity: f32,\n    uUnderwaterFactor: f32,\n    uFogMode: i32,\n    uFogNear: f32,\n    uFogFar: f32,\n    uCameraPos: vec3<f32>,\n}\n\n@group(0) @binding(1) \nvar<uniform> unnamed: Uniforms;\nvar<private> vSide_1: f32;\nvar<private> vSeed_1: f32;\nvar<private> vAlong_1: f32;\nvar<private> vFade_1: f32;\nvar<private> vGain_1: f32;\nvar<private> vWorldPos_1: vec3<f32>;\nvar<private> outColor: vec4<f32>;\n\nfn mediumFog_u0028_f1_u003b_f1_u003b(dist: ptr<function, f32>, pointY: ptr<function, f32>) -> f32 {\n    var span: f32;\n    var ramp: f32;\n    var wetLinear: f32;\n    var start: f32;\n    var before: f32;\n    var local: f32;\n    var t: f32;\n    var rest: f32;\n    var denom: f32;\n    var air: f32;\n    var wet: f32;\n\n    let _e52 = unnamed.uFogMode;\n    if (_e52 == 1i) {\n        let _e55 = unnamed.uFogFar;\n        let _e57 = unnamed.uFogNear;\n        span = max((_e55 - _e57), 0.0001f);\n        let _e60 = (*dist);\n        let _e62 = unnamed.uFogNear;\n        let _e64 = span;\n        ramp = clamp(((_e60 - _e62) / _e64), 0f, 1f);\n        let _e68 = unnamed.uUnderwaterFactor;\n        if (_e68 <= 0f) {\n            let _e70 = ramp;\n            return _e70;\n        }\n        let _e72 = unnamed.uUnderwaterFogDensity;\n        let _e73 = (*dist);\n        wetLinear = (_e72 * _e73);\n        let _e75 = ramp;\n        let _e76 = wetLinear;\n        let _e78 = wetLinear;\n        let _e84 = unnamed.uUnderwaterFactor;\n        return mix(_e75, (1f - exp2(((-(_e76) * _e78) * 1.442695f))), _e84);\n    }\n    let _e87 = unnamed.uFogNear;\n    let _e88 = (*dist);\n    start = min(_e87, _e88);\n    let _e90 = (*dist);\n    if (_e90 > 0f) {\n        let _e92 = start;\n        let _e93 = (*dist);\n        local = (_e92 / _e93);\n    } else {\n        local = 0f;\n    }\n    let _e95 = local;\n    before = _e95;\n    let _e96 = (*pointY);\n    let _e98 = unnamed.uFogEyeY;\n    let _e101 = unnamed.uFogHeightFalloff;\n    t = ((_e96 - _e98) * _e101);\n    let _e103 = t;\n    let _e104 = before;\n    rest = (_e103 * (1f - _e104));\n    let _e107 = rest;\n    let _e110 = rest;\n    denom = select(_e110, 0.0001f, (abs(_e107) < 0.0001f));\n    let _e113 = unnamed.uFogDensity;\n    let _e115 = t;\n    let _e117 = before;\n    let _e121 = (*dist);\n    let _e122 = start;\n    let _e125 = denom;\n    let _e130 = denom;\n    air = (1f - exp(((((-(_e113) * exp((-(_e115) * _e117))) * (_e121 - _e122)) * (1f - exp(-(_e125)))) / _e130)));\n    let _e135 = unnamed.uUnderwaterFactor;\n    if (_e135 <= 0f) {\n        let _e137 = air;\n        return _e137;\n    }\n    let _e139 = unnamed.uUnderwaterFogDensity;\n    let _e140 = (*dist);\n    wet = (_e139 * _e140);\n    let _e142 = air;\n    let _e143 = wet;\n    let _e145 = wet;\n    let _e151 = unnamed.uUnderwaterFactor;\n    return mix(_e142, (1f - exp2(((-(_e143) * _e145) * 1.442695f))), _e151);\n}\n\nfn hash11_u0028_f1_u003b(p: ptr<function, f32>) -> f32 {\n    let _e39 = (*p);\n    return fract((sin((_e39 * 12.9898f)) * 43758.547f));\n}\n\nfn main_1() {\n    var across: f32;\n    var core: f32;\n    var glow: f32;\n    var t_1: f32;\n    var stutter: f32;\n    var param: f32;\n    var param_1: f32;\n    var taper: f32;\n    var energy: f32;\n    var lit: vec3<f32>;\n    var fog: f32;\n    var param_2: f32;\n    var param_3: f32;\n\n    let _e51 = vSide_1;\n    across = clamp((1f - abs(_e51)), 0f, 1f);\n    let _e55 = across;\n    core = pow(_e55, 10f);\n    let _e57 = across;\n    glow = pow(_e57, 1.1f);\n    let _e60 = unnamed.uTime;\n    let _e62 = vSeed_1;\n    t_1 = ((_e60 * 47f) + (_e62 * 17f));\n    let _e65 = t_1;\n    param = floor(_e65);\n    let _e67 = hash11_u0028_f1_u003b((&param));\n    let _e69 = t_1;\n    param_1 = floor((_e69 * 2.37f));\n    let _e72 = hash11_u0028_f1_u003b((&param_1));\n    stutter = (0.78f + (0.22f * ((_e67 * 0.6f) + (_e72 * 0.4f))));\n    let _e77 = vAlong_1;\n    taper = (1f - (_e77 * 0.55f));\n    let _e80 = vFade_1;\n    let _e81 = stutter;\n    let _e83 = taper;\n    let _e85 = vGain_1;\n    energy = (((_e80 * _e81) * _e83) * _e85);\n    let _e88 = unnamed.uEdgeColor;\n    let _e89 = glow;\n    let _e92 = unnamed.uCoreColor;\n    let _e93 = core;\n    let _e96 = unnamed.uCoreGain;\n    lit = ((_e88 * _e89) + ((_e92 * _e93) * _e96));\n    let _e99 = vWorldPos_1;\n    let _e101 = unnamed.uCameraPos;\n    param_2 = distance(_e99, _e101);\n    let _e104 = vWorldPos_1[1u];\n    param_3 = _e104;\n    let _e105 = mediumFog_u0028_f1_u003b_f1_u003b((&param_2), (&param_3));\n    fog = _e105;\n    let _e106 = lit;\n    let _e107 = energy;\n    let _e109 = fog;\n    let _e111 = ((_e106 * _e107) * (1f - _e109));\n    outColor = vec4<f32>(_e111.x, _e111.y, _e111.z, 1f);\n    return;\n}\n\n@fragment \nfn main(@location(0) vSide: f32, @location(3) vSeed: f32, @location(1) vAlong: f32, @location(2) vFade: f32, @location(4) vGain: f32, @location(5) vWorldPos: vec3<f32>) -> @location(0) vec4<f32> {\n    vSide_1 = vSide;\n    vSeed_1 = vSeed;\n    vAlong_1 = vAlong;\n    vFade_1 = vFade;\n    vGain_1 = vGain;\n    vWorldPos_1 = vWorldPos;\n    main_1();\n    let _e13 = outColor;\n    return _e13;\n}\n";
 export const BOLT_VERT_WGSL = "struct Uniforms {\n    uViewProj: mat4x4<f32>,\n    uCameraPos: vec3<f32>,\n    uWidth: f32,\n    uMinWidthPerMetre: f32,\n}\n\nstruct gl_PerVertex {\n    @builtin(position) gl_Position: vec4<f32>,\n    gl_PointSize: f32,\n}\n\nstruct VertexOutput {\n    @location(0) member: f32,\n    @location(1) member_1: f32,\n    @location(2) member_2: f32,\n    @location(3) member_3: f32,\n    @location(4) member_4: f32,\n    @location(5) member_5: vec3<f32>,\n    @builtin(position) gl_Position: vec4<f32>,\n}\n\nvar<private> aFrom_1: vec3<f32>;\nvar<private> aTo_1: vec3<f32>;\nvar<private> aCorner_1: vec2<f32>;\n@group(0) @binding(0) \nvar<uniform> unnamed: Uniforms;\nvar<private> vSide: f32;\nvar<private> vAlong: f32;\nvar<private> aArc_1: vec4<f32>;\nvar<private> vFade: f32;\nvar<private> vSeed: f32;\nvar<private> vGain: f32;\nvar<private> vWorldPos: vec3<f32>;\nvar<private> unnamed_1: gl_PerVertex = gl_PerVertex(vec4<f32>(0f, 0f, 0f, 1f), 1f);\n\nfn main_1() {\n    var mid: vec3<f32>;\n    var dir: vec3<f32>;\n    var len: f32;\n    var local: vec3<f32>;\n    var view: vec3<f32>;\n    var dist: f32;\n    var local_1: vec3<f32>;\n    var across: vec3<f32>;\n    var span: f32;\n    var local_2: vec3<f32>;\n    var halfWidth: f32;\n    var world: vec3<f32>;\n\n    let _e40 = aFrom_1;\n    let _e41 = aTo_1;\n    let _e43 = aCorner_1[0u];\n    mid = mix(_e40, _e41, vec3(_e43));\n    let _e46 = aTo_1;\n    let _e47 = aFrom_1;\n    dir = (_e46 - _e47);\n    let _e49 = dir;\n    len = length(_e49);\n    let _e51 = len;\n    if (_e51 > 0.000001f) {\n        let _e53 = dir;\n        let _e54 = len;\n        local = (_e53 / vec3(_e54));\n    } else {\n        local = vec3<f32>(0f, 1f, 0f);\n    }\n    let _e57 = local;\n    dir = _e57;\n    let _e58 = mid;\n    let _e60 = unnamed.uCameraPos;\n    view = (_e58 - _e60);\n    let _e62 = view;\n    dist = length(_e62);\n    let _e64 = dist;\n    if (_e64 > 0.000001f) {\n        let _e66 = view;\n        let _e67 = dist;\n        local_1 = (_e66 / vec3(_e67));\n    } else {\n        local_1 = vec3<f32>(0f, 0f, 1f);\n    }\n    let _e70 = local_1;\n    view = _e70;\n    let _e71 = dir;\n    let _e72 = view;\n    across = cross(_e71, _e72);\n    let _e74 = across;\n    span = length(_e74);\n    let _e76 = span;\n    if (_e76 > 0.0001f) {\n        let _e78 = across;\n        let _e79 = span;\n        local_2 = (_e78 / vec3(_e79));\n    } else {\n        let _e82 = dir;\n        local_2 = normalize((cross(_e82, vec3<f32>(0f, 1f, 0f)) + vec3<f32>(0.001f, 0.001f, 0.001f)));\n    }\n    let _e86 = local_2;\n    across = _e86;\n    let _e88 = unnamed.uWidth;\n    let _e89 = dist;\n    let _e91 = unnamed.uMinWidthPerMetre;\n    halfWidth = max(_e88, (_e89 * _e91));\n    let _e94 = mid;\n    let _e95 = across;\n    let _e97 = aCorner_1[1u];\n    let _e99 = halfWidth;\n    world = (_e94 + ((_e95 * _e97) * _e99));\n    let _e103 = aCorner_1[1u];\n    vSide = _e103;\n    let _e105 = aArc_1[0u];\n    vAlong = _e105;\n    let _e107 = aArc_1[1u];\n    vFade = _e107;\n    let _e109 = aArc_1[2u];\n    vSeed = _e109;\n    let _e111 = aArc_1[3u];\n    vGain = _e111;\n    let _e112 = world;\n    vWorldPos = _e112;\n    let _e114 = unnamed.uViewProj;\n    let _e115 = world;\n    unnamed_1.gl_Position = (_e114 * vec4<f32>(_e115.x, _e115.y, _e115.z, 1f));\n    return;\n}\n\n@vertex \nfn main(@location(0) aFrom: vec3<f32>, @location(1) aTo: vec3<f32>, @location(2) aCorner: vec2<f32>, @location(3) aArc: vec4<f32>) -> VertexOutput {\n    aFrom_1 = aFrom;\n    aTo_1 = aTo;\n    aCorner_1 = aCorner;\n    aArc_1 = aArc;\n    main_1();\n    let _e17 = unnamed_1.gl_Position.y;\n    unnamed_1.gl_Position.y = -(_e17);\n    let _e19 = vSide;\n    let _e20 = vAlong;\n    let _e21 = vFade;\n    let _e22 = vSeed;\n    let _e23 = vGain;\n    let _e24 = vWorldPos;\n    let _e25 = unnamed_1.gl_Position;\n    return VertexOutput(_e19, _e20, _e21, _e22, _e23, _e24, _e25);\n}\n";
 /**
  * What the transform assigned, so the renderer binds the same numbers.