@driftengine/core 4.8.6 → 4.8.7

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

@@ -542,7 +542,7 @@ export const MAIN_GLSL = `void main() {
      * specularLobe's header argues for at length.
      */
     float sunVoH = max(dot(normalize(uCameraPos - vWorldPos), halfway), 0.0);
-    vec3 sunSpec = mix(specColor, vec3(1.0), pow(1.0 - sunVoH, 5.0) * metal);
+    vec3 sunSpec = highlightTint(specColor, sunVoH, metal);
     /*
      * **Held back until after the environment blend, because that blend is a mix and would
      * otherwise erase this.**
@@ -561,8 +561,12 @@ export const MAIN_GLSL = `void main() {
      * Zero for the whole world that carries no specular attribute and no metalness, exactly as
      * before: \`sunSpec\` is \`vec3(vSpecular)\` at metal 0 and \`vSpecular\` defaults to 0.
      */
-    vec3 sunHighlight =
-      sunColor * specularLobe(max(dot(n, halfway), 0.0), surfaceRoughness) * sunSpec * sunShade * sunFacing;
+    /* GGX's own where the surface asks (\`physicalSpecular\`): the sun is a point, so nothing widens it. */
+    float sunNdh = max(dot(n, halfway), 0.0);
+    float sunLobe = physicalSpecular()
+      ? physicalLobe(sunNdh, ndl, dot(n, normalize(uCameraPos - vWorldPos)), surfaceRoughness, 0.0, 1.0)
+      : specularLobe(sunNdh, surfaceRoughness);
+    vec3 sunHighlight = sunColor * sunLobe * sunSpec * sunShade * sunFacing;
     if (modelled) sunHighlight = sunModelSpecular;
     /*
      * The dielectric's share goes in here, where it has always gone, so the environment blend
@@ -1066,6 +1070,10 @@ export const MAIN_GLSL = `void main() {
       float cookie;
       /* The light's lighting channels, a mask: 1 unless it names others. See \`uLightIesAxis\`. */
       float lightChannels = 1.0;
+      /* The light's own falloff exponent, or 0 for the frame's falloff. See \`uLightCone\`. */
+      float lightExponent = 0.0;
+      /* A clustered rectangle's barn doors: their cosine and length, none at 0. See \`areaBarnDoors\`. */
+      vec2 areaDoors = vec2(0.0);
       /*
        * **A rectangle in the froxel table** — one past the fixed arm's \`maxAreaLights\` — which
        * its record says with a negative radius, its reach negated. Its fields come out of the
@@ -1116,8 +1124,8 @@ export const MAIN_GLSL = `void main() {
       lightWeight = sizeAndWeight.y;
       /*
        * **The fixture, read only for a light that has one.** What a plain light's record holds in
-       * the last three texels is exactly these values, so a light carrying no shadow slot, cone,
-       * profile or cookie shades the same whether they are read or assumed, and at heavy overlap
+       * the last four texels is exactly these values, so a light carrying no shadow slot, cone,
+       * profile, cookie, channels or falloff of its own shades the same whether they are read or assumed, and at heavy overlap
        * reading them was a third of the pass. A branch on a value from a texture around
        * \`texelFetch\` is not the 2026-08-07 case: an integer fetch takes no derivative.
        *
@@ -1137,6 +1145,7 @@ export const MAIN_GLSL = `void main() {
           uvec4 rec2 = clusterTexel(record + 2);
           uvec4 rec3 = clusterTexel(record + 3);
           uvec4 rec4 = clusterTexel(record + 4);
+          uvec4 rec5 = clusterTexel(record + 5);
           shadowSlot = clusteredArea ? -1 : int(uintBitsToFloat(rec2.x));
           areaTwoSided = uintBitsToFloat(rec2.x);
           lightDir = vec3(
@@ -1149,6 +1158,8 @@ export const MAIN_GLSL = `void main() {
           iesAxis = vec3(
             uintBitsToFloat(rec4.x), uintBitsToFloat(rec4.y), uintBitsToFloat(rec4.z));
           lightChannels = uintBitsToFloat(rec4.w);
+          lightExponent = uintBitsToFloat(rec5.x);
+          areaDoors = vec2(uintBitsToFloat(rec5.y), uintBitsToFloat(rec5.z));
         }
       }
       } else {
@@ -1161,7 +1172,8 @@ export const MAIN_GLSL = `void main() {
       lightWeight = uLightWeight[i];
       shadowSlot = i;
       lightDir = uLightDir[i];
-      lightCone = uLightCone[i];
+      lightCone = uLightCone[i].xy;
+      lightExponent = uLightCone[i].z;
       iesProfile = uLightIesProfile[i];
       iesAxis = uLightIesAxis[i].xyz;
       lightChannels = uLightIesAxis[i].w;
@@ -1187,12 +1199,15 @@ export const MAIN_GLSL = `void main() {
        * froxel it is binned into has no edge in the picture.
        */
       if (clusteredArea) {
-        float areaForm = areaSignedForm(n, lightPos, lightDir, iesAxis, lightCone);
+        vec3 seenCentre = lightPos;
+        vec2 seenHalf = lightCone;
+        if (!areaBarnDoors(seenCentre, lightDir, iesAxis, seenHalf, areaDoors)) continue;
+        float areaForm = areaSignedForm(n, seenCentre, lightDir, iesAxis, seenHalf);
         float areaWindow = clamp(1.0 - pow(length(lightPos - vWorldPos) / max(lightRadius, 1e-4), 4.0), 0.0, 1.0);
         areaForm = mix(max(0.0, areaForm), abs(areaForm), areaTwoSided);
         if (areaForm > 0.0) {
           areaLightAdd(
-            lightPos, lightDir, iesAxis, lightCone, lightColor * (areaWindow * areaWindow), areaForm,
+            seenCentre, lightDir, iesAxis, seenHalf, lightColor * (areaWindow * areaWindow), areaForm,
             1.0, vec3(1.0), n, albedo, metal, specColor, surfaceRoughness, modelled,
             lampOpen, lampShadowed
           );
@@ -1243,7 +1258,16 @@ export const MAIN_GLSL = `void main() {
        * same way three.js windows its own, so the light still ends where it says it does.
        */
       float falloff;
-      if (uLightFalloff == 1) {
+      /*
+       * **A light may name its own falloff, and then it is Unreal's for a light without
+       * inverse-square falloff**: \`(1 - (d/R)^2)^n\` with no distance term, so a fill authored to
+       * light a whole hall across a hundred metres does, where the inverse square would have it
+       * gone a few metres out. Zero is the frame's own rule below, which every light was before.
+       */
+      if (lightExponent > 0.0) {
+        float reach = dist / max(lightRadius, 1e-4);
+        falloff = pow(clamp(1.0 - reach * reach, 0.0, 1.0), lightExponent);
+      } else if (uLightFalloff == 1) {
         float window = clamp(1.0 - pow(dist / max(lightRadius, 1e-4), 4.0), 0.0, 1.0);
         falloff = window * window / max(dist * dist, 0.01);
       } else {
@@ -1506,7 +1530,11 @@ export const MAIN_GLSL = `void main() {
         photometric = mix(1.0, iesGain, step(0.0, iesProfile));
       }
 
-      float shape = (uLightFalloff == 1 ? falloff : falloff * falloff) * coneFalloff * photometric;
+      /* A light's own exponent already is its whole curve; the frame's smooth rule squares its own. */
+      float shape =
+        (lightExponent > 0.0 || uLightFalloff == 1 ? falloff : falloff * falloff) *
+        coneFalloff *
+        photometric;
       glassGlow += lightColor * backNdl * shape * lightWeight * shaded * lampGlass;
       if (ndl <= 0.0 && !modelledBehind) continue;
       /*
@@ -1583,16 +1611,15 @@ export const MAIN_GLSL = `void main() {
       if (vSpecular > 0.0 || metal > 0.0) {
         vec3 toEyeLamp = normalize(uCameraPos - vWorldPos);
         vec3 lampHalfway = normalize(toLight / max(dist, 1e-4) + toEyeLamp);
-        /* The same grazing whitening the sun's highlight takes, and zero at metal 0. */
-        vec3 lampSpec = mix(
-          specColor,
-          vec3(1.0),
-          pow(1.0 - max(dot(toEyeLamp, lampHalfway), 0.0), 5.0) * metal
-        );
+        /* The same grazing whitening the sun's highlight takes, and zero at metal 0 for the look. */
+        vec3 lampSpec = highlightTint(specColor, max(dot(toEyeLamp, lampHalfway), 0.0), metal);
+        /* The look's lobe, or GGX's own where the surface asks for it: see \`physicalLobe\`. */
+        float lampNdh = max(dot(n, lampHalfway), 0.0);
+        float lampLobe = physicalSpecular()
+          ? physicalLobe(lampNdh, ndl, dot(n, toEyeLamp), surfaceRoughness, lightSourceRadius, dist)
+          : sphereLobe(lampNdh, surfaceRoughness, lightSourceRadius, dist);
         /* Held back with the diffuse half, and shadowed by the same term it always was. */
-        vec3 lampHighlight =
-          lightColor * sphereLobe(max(dot(n, lampHalfway), 0.0), surfaceRoughness, lightSourceRadius, dist)
-          * lampSpec * shape * lightWeight;
+        vec3 lampHighlight = lightColor * lampLobe * lampSpec * shape * lightWeight;
         lampOpen += lampHighlight;
         lampShadowed += lampHighlight * shaded * lampGlass;
       }
@@ -1636,10 +1663,18 @@ export const MAIN_GLSL = `void main() {
       vec3 centre = uAreaLightPos[a];
       vec3 right = uAreaLightRight[a];
       vec3 up = uAreaLightUp[a];
-      vec2 halfSize = uAreaLightSize[a];
+      vec2 halfSize = uAreaLightSize[a].xy;
+      /*
+       * **The part of the rectangle this fragment sees past its barn doors** (\`areaBarnDoors\`),
+       * which its light and highlight come from. Its shadow keeps the whole rectangle's centre and
+       * size below, because that is what its map was baked from.
+       */
+      vec3 seenCentre = centre;
+      vec2 seenHalf = halfSize;
+      if (!areaBarnDoors(seenCentre, right, up, seenHalf, uAreaLightSize[a].zw)) continue;
 
       /* The form factor and its sign, which is the sidedness: see \`areaSignedForm\`. */
-      float signedForm = areaSignedForm(n, centre, right, up, halfSize);
+      float signedForm = areaSignedForm(n, seenCentre, right, up, seenHalf);
       float form = mix(max(0.0, signedForm), abs(signedForm), uAreaLightTwoSided[a]);
       /* The form factor is linear in the normal, so the one seen from behind is its negation. */
       float backForm = glassTransmission > 0.0
@@ -1756,7 +1791,7 @@ export const MAIN_GLSL = `void main() {
       if (form <= 0.0) continue;
       /* The diffuse, the model's answer or the lobe integrated over the rectangle: see areaLight.ts. */
       areaLightAdd(
-        centre, right, up, halfSize, uAreaLightColor[a], form, areaOccl, areaGlass,
+        seenCentre, right, up, seenHalf, uAreaLightColor[a], form, areaOccl, areaGlass,
         n, albedo, metal, specColor, surfaceRoughness, modelled, lampOpen, lampShadowed
       );
     }

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

@@ -1,6 +1,9 @@
 import type { SurfaceModelKind } from '../../surfaceModel.ts';
-/** The models' whole chunk, at depth zero before `main`: see `flatFrag`. */
-export declare const MODELS_GLSL: string;
+/**
+ * The models' whole chunk, at depth zero before `main`: see `flatFrag`. `physicalSpecular` is the
+ * \`PHYSICAL_SPECULAR\` lit switch's value, written in as \`litSwitchesGlsl\` writes the others.
+ */
+export declare function modelsGlsl(physicalSpecular: boolean): string;
 /**
  * Which half of a skin a lit pipeline draws under `skinScattering: 'screen-space'`: the whole
  * surface (every other pipeline), the frame's half without its diffuse, the diffuse's light alone

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

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

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

@@ -771,13 +771,15 @@ uniform float uLightWeight[MAX_LIGHTS];
  */
 uniform vec3 uLightDir[MAX_LIGHTS];
 /**
- * The cosine of each light's inner cone angle, then of its outer.
+ * The cosine of each light's inner cone angle, then of its outer, and in z the light's own falloff
+ * exponent, 0 for the frame's falloff (\`PointLightSource.falloffExponent\`): a \`vec2\` array cost
+ * a whole row a light anyway, so the exponent spends no row of its own.
  *
  * A light with no cone carries -1 and -2, which makes \`smoothstep(outer, inner, dot)\` exactly 1
  * for every direction on the sphere. See \`POINT_LIGHT_COS_OUTER\`: the pair is chosen so a point
  * light collapses to the arithmetic it had rather than to something very close to it.
  */
-uniform vec2 uLightCone[MAX_LIGHTS];
+uniform vec4 uLightCone[MAX_LIGHTS];
 /**
  * Which row of the photometric atlas each light uses, or a negative index for none.
  *
@@ -882,7 +884,12 @@ uniform vec3 uAreaLightColor[MAX_AREA_LIGHTS];
 /** The rectangle's in-plane axes, unit length, and its half extents along each. */
 uniform vec3 uAreaLightRight[MAX_AREA_LIGHTS];
 uniform vec3 uAreaLightUp[MAX_AREA_LIGHTS];
-uniform vec2 uAreaLightSize[MAX_AREA_LIGHTS];
+/*
+ * Each rectangle's half extents, and in zw its barn doors: the cosine of their angle from its normal
+ * and their length, 0 for none (\`areaBarnDoors\`). A \`vec2\` array costs a whole row a rectangle
+ * anyway, so the doors spend no row of their own.
+ */
+uniform vec4 uAreaLightSize[MAX_AREA_LIGHTS];
 /**
  * Whether the rectangle emits from both faces, 1 or 0.
  *

package/dist/render/shaders/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 = (1f - abs(_e51));\n    let _e54 = across;\n    core = pow(_e54, 10f);\n    let _e56 = across;\n    glow = pow(_e56, 1.1f);\n    let _e59 = unnamed.uTime;\n    let _e61 = vSeed_1;\n    t_1 = ((_e59 * 47f) + (_e61 * 17f));\n    let _e64 = t_1;\n    param = floor(_e64);\n    let _e66 = hash11_u0028_f1_u003b((&param));\n    let _e68 = t_1;\n    param_1 = floor((_e68 * 2.37f));\n    let _e71 = hash11_u0028_f1_u003b((&param_1));\n    stutter = (0.78f + (0.22f * ((_e66 * 0.6f) + (_e71 * 0.4f))));\n    let _e76 = vAlong_1;\n    taper = (1f - (_e76 * 0.55f));\n    let _e79 = vFade_1;\n    let _e80 = stutter;\n    let _e82 = taper;\n    let _e84 = vGain_1;\n    energy = (((_e79 * _e80) * _e82) * _e84);\n    let _e87 = unnamed.uEdgeColor;\n    let _e88 = glow;\n    let _e91 = unnamed.uCoreColor;\n    let _e92 = core;\n    let _e95 = unnamed.uCoreGain;\n    lit = ((_e87 * _e88) + ((_e91 * _e92) * _e95));\n    let _e98 = vWorldPos_1;\n    let _e100 = unnamed.uCameraPos;\n    param_2 = distance(_e98, _e100);\n    let _e103 = vWorldPos_1[1u];\n    param_3 = _e103;\n    let _e104 = mediumFog_u0028_f1_u003b_f1_u003b((&param_2), (&param_3));\n    fog = _e104;\n    let _e105 = lit;\n    let _e106 = energy;\n    let _e108 = fog;\n    let _e110 = ((_e105 * _e106) * (1f - _e108));\n    outColor = vec4<f32>(_e110.x, _e110.y, _e110.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 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_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 = (1f - abs(_e51));\n    let _e54 = across;\n    core = pow(_e54, 10f);\n    let _e56 = across;\n    glow = pow(_e56, 1.1f);\n    let _e59 = unnamed.uTime;\n    let _e61 = vSeed_1;\n    t_1 = ((_e59 * 47f) + (_e61 * 17f));\n    let _e64 = t_1;\n    param = floor(_e64);\n    let _e66 = hash11_u0028_f1_u003b((&param));\n    let _e68 = t_1;\n    param_1 = floor((_e68 * 2.37f));\n    let _e71 = hash11_u0028_f1_u003b((&param_1));\n    stutter = (0.78f + (0.22f * ((_e66 * 0.6f) + (_e71 * 0.4f))));\n    let _e76 = vAlong_1;\n    taper = (1f - (_e76 * 0.55f));\n    let _e79 = vFade_1;\n    let _e80 = stutter;\n    let _e82 = taper;\n    let _e84 = vGain_1;\n    energy = (((_e79 * _e80) * _e82) * _e84);\n    let _e87 = unnamed.uEdgeColor;\n    let _e88 = glow;\n    let _e91 = unnamed.uCoreColor;\n    let _e92 = core;\n    let _e95 = unnamed.uCoreGain;\n    lit = ((_e87 * _e88) + ((_e91 * _e92) * _e95));\n    let _e98 = vWorldPos_1;\n    let _e100 = unnamed.uCameraPos;\n    param_2 = distance(_e98, _e100);\n    let _e103 = vWorldPos_1[1u];\n    param_3 = _e103;\n    let _e104 = mediumFog_u0028_f1_u003b_f1_u003b((&param_2), (&param_3));\n    fog = _e104;\n    let _e105 = lit;\n    let _e106 = energy;\n    let _e108 = fog;\n    let _e110 = ((_e105 * _e106) * (1f - _e108));\n    outColor = vec4<f32>(_e110.x, _e110.y, _e110.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 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_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.