@driftengine/core 4.13.3 → 4.13.5

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

@@ -694,8 +694,9 @@ export const MAIN_GLSL = `void main() {
      * branch it did not take before.
      */
     /* A model reflects its environment whatever the pass asked of the standard model: see
-       modelReflectance. On the switches alone, so the derivatives below stay in uniform flow. */
-    if (uEnvironmentDials.y > 0.0 || uMaterialFlags.y != 0 || modelled) {
+       modelReflectance. Hair takes none: modelReflects. On the switches alone, so the derivatives
+       below stay in uniform flow. */
+    if ((uEnvironmentDials.y > 0.0 || uMaterialFlags.y != 0 || modelled) && modelReflects()) {
       vec3 toEye = normalize(uCameraPos - vWorldPos);
       vec3 mirrored = reflect(-toEye, modelled ? modelReflectNormal(n) : n);
       vec3 environment = mix(uAmbientGround, uAmbient, mirrored.y * 0.5 + 0.5);
@@ -833,6 +834,19 @@ export const MAIN_GLSL = `void main() {
        * caller sets this.
        */
       environment *= mix(1.0, uEnvironmentDials.z, metal);
+      /*
+       * **And brought to the light where the surface stands**, metal or not: a probe is captured
+       * at one place and seen from many, so a rough surface standing in light twice what the probe
+       * saw takes twice its reflection, and a mirror keeps the capture as it is. The weight is the
+       * caller's, the place's indirect light over the probe's average; mixed in by roughness, with
+       * the smoothstep written out because GLSL leaves one over an empty range undefined. 0, the
+       * weight less one, is exactly the reflection there was.
+       */
+      if (uEnvironmentMixing.x != 0.0) {
+        float span = max(uEnvironmentMixing.z - uEnvironmentMixing.y, 1e-4);
+        float rough = clamp((surfaceRoughness - uEnvironmentMixing.y) / span, 0.0, 1.0);
+        environment *= 1.0 + uEnvironmentMixing.x * rough * rough * (3.0 - 2.0 * rough);
+      }
       float facing = 1.0 - max(dot(n, toEye), 0.0);
       /*
        * **A metal's Fresnel base is close to its albedo, not a dielectric's four percent.** Schlick
@@ -2088,8 +2102,14 @@ export const MAIN_GLSL = `void main() {
    * the medium's colour and adding it puts the haze into the frame twice — a glow by day drew as
    * a grey shape of itself, greyer the thicker the air.
    */
+  /* And the sun's glow in the haze, which a surface takes after its fog and an added light never
+     does: what is behind it already has it. */
+  vec3 glow = vec3(0.0);
+  if (uFogEnabled == 1) {
+    glow = mediumGlow(distance(vWorldPos, uCameraPos), vWorldPos.y, normalize(vWorldPos - uCameraPos));
+  }
   vec3 shaded = applyOutputTransform(
-    uFogEnabled == 2 ? lit * (1.0 - fog) : mix(lit, mediumColor(), fog));
+    uFogEnabled == 2 ? lit * (1.0 - fog) : mix(lit, mediumColor(), fog) + glow);
 
   /*
    * **Refraction: the scene behind this surface, bent and absorbed.**

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

@@ -12,8 +12,8 @@
  * **Where the models plug in.** `main` gathers the surface once (`modelSurface`), then asks at each
  * place light arrives: `modelLight` for the sun, each lamp and each rectangle, `modelAmbient` for
  * the sky and the probe's irradiance, `modelIrradiance` for DriftLight, `modelReflectNormal` and
- * `modelReflectance` for the environment's reflection. Each returns today's term for the standard
- * model, and each model's file is where its own answers are.
+ * `modelReflectance` for the environment's reflection, which `modelReflects` keeps from hair. Each
+ * returns today's term for the standard model, and each model's file is where its own answers are.
  *
  * **What a model returns from a light** is the two halves the standard terms are: a diffuse already
  * weighted by the angle of arrival, and a specular lobe in the engine's peak-normalised units (see
@@ -93,6 +93,15 @@ bool modelSeesBehind() {
   return false;
 }
 
+/**
+ * Whether the environment's reflection reaches this surface: every model's but hair's, whose share
+ * of it is in its light from every side (hair.ts).
+ */
+bool modelReflects() {
+  if (MODEL_HAIR) return false;
+  return true;
+}
+
 /* The surface a model shades, gathered once in main before any light reaches it. */
 vec3 mNormal;
 vec3 mToEye;
@@ -224,7 +233,7 @@ void modelSurface(vec3 n, vec3 albedo, float roughness, float metal, vec3 at) {
   mMap = vec4(0.5, 0.5, 1.0, 1.0);
   if (uModelParams[1].w > 0.0) mMap = texture(uModelMap, at);
   if (MODEL_ANISOTROPIC) anisotropicSurface();
-  if (MODEL_HAIR) hairSurface();
+  if (MODEL_HAIR) hairSurface(at);
   if (MODEL_SKIN) skinSurface();
   if (MODEL_EYE) eyeSurface(at);
 }
@@ -282,7 +291,6 @@ vec3 modelIrradiance(vec3 irradiance) {
 /** The normal the environment is reflected about: the surface's own, but for a stretched lobe. */
 vec3 modelReflectNormal(vec3 n) {
   if (MODEL_ANISOTROPIC) return anisotropicReflectNormal(n);
-  if (MODEL_HAIR) return hairAcross();
   return n;
 }
 
@@ -358,7 +366,6 @@ vec3 modelDiffuseOut(vec3 diffuse, float fog) {
  * what the standard model would.
  */
 float modelReflectance(float standard) {
-  if (MODEL_HAIR) return hairReflectance();
   if (MODEL_SKIN) return skinReflectance();
   if (MODEL_EYE) return eyeReflectance();
   return standard;

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

@@ -276,6 +276,13 @@ uniform vec3 uOrmScale; // wgsl:material
  */
 uniform vec3 uEnvironmentDials; // wgsl:material
 
+/**
+ * The environment a surface reflects brought to the light where it stands, for every surface:
+ * \`setEnvironmentMixing\`. x is the weight less one, so a program nothing wrote reflects as it did;
+ * y and z the roughnesses the weight is mixed in over, smooth to rough.
+ */
+uniform vec4 uEnvironmentMixing; // wgsl:material
+
 /**
  * Where a surface glows, and in what colour.
  *

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

@@ -30,8 +30,8 @@
  * at the eye times `(1 − e⁻ᵗ)/t`, with `t` the height climbed in scale heights. The eye
  * density and `1/H` arrive precomputed from `bindAtmosphere`.
  *
- * `uFogEyeY` rather than `uCameraPos.y` because two of the seven programs (the plumes)
- * never needed the camera position in their fragment stage, and a block that declares
- * everything it uses can be pasted anywhere.
+ * `uFogMedium.z`, the eye's height, rather than `uCameraPos.y`, because two of the seven
+ * programs (the plumes) 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  // 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";
+export declare const FOG_GLSL = "\nuniform vec3 uFogColor;\n/**\n * The haze: its extinction per metre **at the camera's own height**, not at the base; its\n * reciprocal scale height per metre, 0 for a uniform medium; the camera's height, so a fragment's\n * own height is one subtraction away; and the water column's own density.\n *\n * **Four numbers in one vector rather than four uniforms**, and the reason is a phone: a scalar\n * costs a whole row of the uniform grid, and the lit stage at its eight-light rung must fit the 256\n * rows an Adreno 740 offers (uniformVectorBudget.ts). Packed, the haze's eight scalars cost two\n * rows where they cost eight, which is what paid for the second layer and the sun's glow below.\n */\nuniform vec4 uFogMedium;\n/** Where haze begins, where a linear ramp is total, and the mode: 0 a medium, 1 a ramp. */\nuniform vec4 uFogRange;\nuniform vec3 uUnderwaterColor;\nuniform float uUnderwaterFactor;\n/**\n * The second layer's extinction per metre at the camera's height and its falloff; then the least of\n * a surface the haze must leave, Atmosphere.fogMaxOpacity's complement, and the distance past which\n * it hides nothing (0 is none). **Every lane is none at zero**, and so are uFogGlow's: a program a\n * binder never wrote these into draws the haze it drew before they existed, rather than none.\n */\nuniform vec4 uFogLayer2;\n/** The sun's glow in the haze: its colour, black for none, and the exponent of its lobe. */\nuniform vec4 uFogGlow;\n/** Surface \u2192 the glow's light, and how far past the haze's start the glow begins. */\nuniform vec4 uFogGlowDir;\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 * The haze's optical depth from where it begins along the ray to a point at height pointY, dist\n * metres away: each layer's density at the eye carried over what is left of the ray, with the\n * second layer only where there is one. The fog and the sun's glow both integrate it.\n */\nfloat hazeDepth(float dist, float pointY) {\n  // Where the medium begins along the ray: uFogRange.x, 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(uFogRange.x, dist);\n  float before = dist > 0.0 ? start / dist : 0.0;\n  float t = (pointY - uFogMedium.z) * uFogMedium.y;\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 depth = uFogMedium.x * exp(-t * before) * (dist - start) * (1.0 - exp(-denom)) / denom;\n  if (uFogLayer2.x > 0.0) {\n    float t2 = (pointY - uFogMedium.z) * uFogLayer2.y;\n    float rest2 = t2 * (1.0 - before);\n    float denom2 = abs(rest2) < 1e-4 ? 1e-4 : rest2;\n    depth += uFogLayer2.x * exp(-t2 * before) * (dist - start) * (1.0 - exp(-denom2)) / denom2;\n  }\n  return depth;\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  /* Past the cutoff the air hides nothing, in either mode; the water column keeps its own law. */\n  bool cut = uFogLayer2.w > 0.0 && dist > uFogLayer2.w;\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 (uFogRange.z == 1.0) {\n    float span = max(uFogRange.y - uFogRange.x, 1e-4);\n    float ramp = cut ? 0.0 : min(clamp((dist - uFogRange.x) / span, 0.0, 1.0), 1.0 - uFogLayer2.z);\n    if (uUnderwaterFactor <= 0.0) return ramp;\n    float wetLinear = uFogMedium.w * dist;\n    return mix(ramp, 1.0 - exp2(-wetLinear * wetLinear * 1.442695), uUnderwaterFactor);\n  }\n\n  // Beer-Lambert through both layers, leaving at least uFogLayer2.z of the surface: a floor on\n  // what survives rather than a ceiling on the depth, so the curve keeps its shape above it.\n  float air = cut ? 0.0 : 1.0 - max(exp(-hazeDepth(dist, pointY)), uFogLayer2.z);\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 = uFogMedium.w * dist;\n  return mix(air, 1.0 - exp2(-wet * wet * 1.442695), uUnderwaterFactor);\n}\n\n/**\n * The sun's light the haze scatters toward the eye along a ray to a point at height pointY, dist\n * metres away in the direction toPoint: added to a surface after its fog, never mixed. A lobe of\n * cos^exponent about the light, by as much of the ray past the glow's own start as the haze hides \u2014\n * the haze's depth per metre carried over that stretch. None in a linear ramp, past the cutoff, or\n * under water, which keeps its own medium.\n */\nvec3 mediumGlow(float dist, float pointY, vec3 toPoint) {\n  if (uFogRange.z == 1.0 || max(max(uFogGlow.r, uFogGlow.g), uFogGlow.b) <= 0.0) return vec3(0.0);\n  if (uFogLayer2.w > 0.0 && dist > uFogLayer2.w) return vec3(0.0);\n  float span = dist - min(uFogRange.x, dist);\n  if (span <= 0.0) return vec3(0.0);\n  float perMetre = hazeDepth(dist, pointY) / span;\n  float hidden = 1.0 - exp(-perMetre * max(span - uFogGlowDir.w, 0.0));\n  float lobe = pow(clamp(dot(toPoint, uFogGlowDir.xyz), 0.0, 1.0), uFogGlow.a);\n  return uFogGlow.rgb * (lobe * hidden * (1.0 - uUnderwaterFactor));\n}\n";

package/dist/render/shaders/fog.js

@@ -30,37 +30,77 @@
  * at the eye times `(1 − e⁻ᵗ)/t`, with `t` the height climbed in scale heights. The eye
  * density and `1/H` arrive precomputed from `bindAtmosphere`.
  *
- * `uFogEyeY` rather than `uCameraPos.y` because two of the seven programs (the plumes)
- * never needed the camera position in their fragment stage, and a block that declares
- * everything it uses can be pasted anywhere.
+ * `uFogMedium.z`, the eye's height, rather than `uCameraPos.y`, because two of the seven
+ * programs (the plumes) never needed the camera position in their fragment stage, and a block
+ * that declares everything it uses can be pasted anywhere.
  */
 export const FOG_GLSL = `
 uniform vec3 uFogColor;
-/** Extinction per metre **at the camera's own height**, not at the base. */
-uniform float uFogDensity;
-/** Reciprocal scale height of the haze, per metre. 0 is a uniform medium. */
-uniform float uFogHeightFalloff;
-/** The camera's height, so a fragment's own height is one subtraction away. */
-uniform float uFogEyeY;
+/**
+ * The haze: its extinction per metre **at the camera's own height**, not at the base; its
+ * reciprocal scale height per metre, 0 for a uniform medium; the camera's height, so a fragment's
+ * own height is one subtraction away; and the water column's own density.
+ *
+ * **Four numbers in one vector rather than four uniforms**, and the reason is a phone: a scalar
+ * costs a whole row of the uniform grid, and the lit stage at its eight-light rung must fit the 256
+ * rows an Adreno 740 offers (uniformVectorBudget.ts). Packed, the haze's eight scalars cost two
+ * rows where they cost eight, which is what paid for the second layer and the sun's glow below.
+ */
+uniform vec4 uFogMedium;
+/** Where haze begins, where a linear ramp is total, and the mode: 0 a medium, 1 a ramp. */
+uniform vec4 uFogRange;
 uniform vec3 uUnderwaterColor;
-uniform float uUnderwaterFogDensity;
 uniform float uUnderwaterFactor;
-/** 0 integrates a medium (Beer-Lambert); 1 ramps linearly between near and far. */
-uniform int uFogMode;
-/** Linear mode only: where haze begins, and where it is total. */
-uniform float uFogNear;
-uniform float uFogFar;
+/**
+ * The second layer's extinction per metre at the camera's height and its falloff; then the least of
+ * a surface the haze must leave, Atmosphere.fogMaxOpacity's complement, and the distance past which
+ * it hides nothing (0 is none). **Every lane is none at zero**, and so are uFogGlow's: a program a
+ * binder never wrote these into draws the haze it drew before they existed, rather than none.
+ */
+uniform vec4 uFogLayer2;
+/** The sun's glow in the haze: its colour, black for none, and the exponent of its lobe. */
+uniform vec4 uFogGlow;
+/** Surface → the glow's light, and how far past the haze's start the glow begins. */
+uniform vec4 uFogGlowDir;
 
 /** What distance converges toward: the day's haze, or the water column. */
 vec3 mediumColor() {
   return mix(uFogColor, uUnderwaterColor, uUnderwaterFactor);
 }
 
+/**
+ * The haze's optical depth from where it begins along the ray to a point at height pointY, dist
+ * metres away: each layer's density at the eye carried over what is left of the ray, with the
+ * second layer only where there is one. The fog and the sun's glow both integrate it.
+ */
+float hazeDepth(float dist, float pointY) {
+  // Where the medium begins along the ray: uFogRange.x, 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(uFogRange.x, dist);
+  float before = dist > 0.0 ? start / dist : 0.0;
+  float t = (pointY - uFogMedium.z) * uFogMedium.y;
+  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(rest) < 1e-4 ? 1e-4 : rest;
+  float depth = uFogMedium.x * exp(-t * before) * (dist - start) * (1.0 - exp(-denom)) / denom;
+  if (uFogLayer2.x > 0.0) {
+    float t2 = (pointY - uFogMedium.z) * uFogLayer2.y;
+    float rest2 = t2 * (1.0 - before);
+    float denom2 = abs(rest2) < 1e-4 ? 1e-4 : rest2;
+    depth += uFogLayer2.x * exp(-t2 * before) * (dist - start) * (1.0 - exp(-denom2)) / denom2;
+  }
+  return depth;
+}
+
 /**
  * How much of a surface standing at height pointY, dist metres away, is lost to
  * the medium in between. 0 is perfectly clear, 1 is the medium's own colour.
  */
 float mediumFog(float dist, float pointY) {
+  /* Past the cutoff the air hides nothing, in either mode; the water column keeps its own law. */
+  bool cut = uFogLayer2.w > 0.0 && dist > uFogLayer2.w;
   /*
    * A depth ramp rather than a medium, for worlds authored against one.
    *
@@ -76,30 +116,39 @@ float mediumFog(float dist, float pointY) {
    * Height falloff has no meaning here and is ignored: a ramp is defined on distance
    * alone.
    */
-  if (uFogMode == 1) {
-    float span = max(uFogFar - uFogNear, 1e-4);
-    float ramp = clamp((dist - uFogNear) / span, 0.0, 1.0);
+  if (uFogRange.z == 1.0) {
+    float span = max(uFogRange.y - uFogRange.x, 1e-4);
+    float ramp = cut ? 0.0 : min(clamp((dist - uFogRange.x) / span, 0.0, 1.0), 1.0 - uFogLayer2.z);
     if (uUnderwaterFactor <= 0.0) return ramp;
-    float wetLinear = uUnderwaterFogDensity * dist;
+    float wetLinear = uFogMedium.w * dist;
     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(rest) < 1e-4 ? 1e-4 : rest;
-  float air =
-    1.0 - exp(-uFogDensity * exp(-t * before) * (dist - start) * (1.0 - exp(-denom)) / denom);
+  // Beer-Lambert through both layers, leaving at least uFogLayer2.z of the surface: a floor on
+  // what survives rather than a ceiling on the depth, so the curve keeps its shape above it.
+  float air = cut ? 0.0 : 1.0 - max(exp(-hazeDepth(dist, pointY)), uFogLayer2.z);
   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.
-  float wet = uUnderwaterFogDensity * dist;
+  float wet = uFogMedium.w * dist;
   return mix(air, 1.0 - exp2(-wet * wet * 1.442695), uUnderwaterFactor);
 }
+
+/**
+ * The sun's light the haze scatters toward the eye along a ray to a point at height pointY, dist
+ * metres away in the direction toPoint: added to a surface after its fog, never mixed. A lobe of
+ * cos^exponent about the light, by as much of the ray past the glow's own start as the haze hides —
+ * the haze's depth per metre carried over that stretch. None in a linear ramp, past the cutoff, or
+ * under water, which keeps its own medium.
+ */
+vec3 mediumGlow(float dist, float pointY, vec3 toPoint) {
+  if (uFogRange.z == 1.0 || max(max(uFogGlow.r, uFogGlow.g), uFogGlow.b) <= 0.0) return vec3(0.0);
+  if (uFogLayer2.w > 0.0 && dist > uFogLayer2.w) return vec3(0.0);
+  float span = dist - min(uFogRange.x, dist);
+  if (span <= 0.0) return vec3(0.0);
+  float perMetre = hazeDepth(dist, pointY) / span;
+  float hidden = 1.0 - exp(-perMetre * max(span - uFogGlowDir.w, 0.0));
+  float lobe = pow(clamp(dot(toPoint, uFogGlowDir.xyz), 0.0, 1.0), uFogGlow.a);
+  return uFogGlow.rgb * (lobe * hidden * (1.0 - uUnderwaterFactor));
+}
 `;

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    uOutputTransform: i32,\n    uOutputExposure: f32,\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 linearToSrgb_u0028_vf3_u003b(c: ptr<function, vec3<f32>>) -> vec3<f32> {\n    var low: vec3<f32>;\n    var high: vec3<f32>;\n\n    let _e105 = (*c);\n    low = (_e105 * 12.92f);\n    let _e107 = (*c);\n    high = ((pow(max(_e107, vec3<f32>(0f, 0f, 0f)), vec3<f32>(0.41666666f, 0.41666666f, 0.41666666f)) * 1.055f) - vec3(0.055f));\n    let _e113 = high;\n    let _e114 = low;\n    let _e115 = (*c);\n    return mix(_e113, _e114, step(_e115, vec3<f32>(0.0031308f, 0.0031308f, 0.0031308f)));\n}\n\nfn highlightShoulder_u0028_vf3_u003b(c_1: ptr<function, vec3<f32>>) -> vec3<f32> {\n    var m: f32;\n    var e: f32;\n\n    let _e106 = (*c_1)[0u];\n    let _e108 = (*c_1)[1u];\n    let _e110 = (*c_1)[2u];\n    m = max(_e106, max(_e108, _e110));\n    let _e113 = m;\n    if (_e113 <= 0.8f) {\n        let _e115 = (*c_1);\n        return _e115;\n    }\n    let _e116 = m;\n    e = (_e116 - 0.8f);\n    let _e118 = (*c_1);\n    let _e119 = e;\n    let _e121 = e;\n    let _e125 = m;\n    return (_e118 * ((0.8f + ((0.2f * _e119) / (_e121 + 0.2f))) / _e125));\n}\n\nfn rrtAndOdtFit_u0028_vf3_u003b(v: ptr<function, vec3<f32>>) -> vec3<f32> {\n    var a: vec3<f32>;\n    var b: vec3<f32>;\n\n    let _e105 = (*v);\n    let _e106 = (*v);\n    a = ((_e105 * (_e106 + vec3(0.0245786f))) - vec3(0.000090537f));\n    let _e112 = (*v);\n    let _e113 = (*v);\n    b = ((_e112 * ((_e113 * 0.983729f) + vec3(0.432951f))) + vec3(0.238081f));\n    let _e120 = a;\n    let _e121 = b;\n    return (_e120 / _e121);\n}\n\nfn acesFilmic_u0028_vf3_u003b(x: ptr<function, vec3<f32>>) -> vec3<f32> {\n    var param: vec3<f32>;\n\n    let _e105 = unnamed.uOutputExposure;\n    let _e106 = (*x);\n    (*x) = (_e106 * _e105);\n    let _e108 = (*x);\n    param = (mat3x3<f32>(vec3<f32>(0.59719f, 0.076f, 0.0284f), vec3<f32>(0.35458f, 0.90834f, 0.13383f), vec3<f32>(0.04823f, 0.01566f, 0.83777f)) * _e108);\n    let _e110 = rrtAndOdtFit_u0028_vf3_u003b((&param));\n    return clamp((mat3x3<f32>(vec3<f32>(1.60475f, -0.10208f, -0.00327f), vec3<f32>(-0.53108f, 1.10813f, -0.07276f), vec3<f32>(-0.07367f, -0.00605f, 1.07602f)) * _e110), vec3(0f), vec3(1f));\n}\n\nfn applyOutputTransform_u0028_vf3_u003b(c_2: ptr<function, vec3<f32>>) -> vec3<f32> {\n    var param_1: vec3<f32>;\n    var param_2: vec3<f32>;\n    var param_3: vec3<f32>;\n\n    let _e107 = unnamed.uOutputTransform;\n    if (_e107 == 0i) {\n        let _e109 = (*c_2);\n        return _e109;\n    }\n    let _e111 = unnamed.uOutputTransform;\n    if (_e111 == 2i) {\n        let _e113 = (*c_2);\n        param_1 = _e113;\n        let _e114 = acesFilmic_u0028_vf3_u003b((&param_1));\n        (*c_2) = _e114;\n    }\n    let _e116 = unnamed.uOutputTransform;\n    if (_e116 == 3i) {\n        let _e118 = (*c_2);\n        let _e120 = unnamed.uOutputExposure;\n        param_2 = (_e118 * _e120);\n        let _e122 = highlightShoulder_u0028_vf3_u003b((&param_2));\n        (*c_2) = _e122;\n    }\n    let _e123 = (*c_2);\n    param_3 = _e123;\n    let _e124 = linearToSrgb_u0028_vf3_u003b((&param_3));\n    return _e124;\n}\n\nfn mediumColor_u0028_() -> vec3<f32> {\n    let _e103 = unnamed.uFogColor;\n    let _e105 = unnamed.uUnderwaterColor;\n    let _e107 = unnamed.uUnderwaterFactor;\n    return mix(_e103, _e105, vec3(_e107));\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 _e116 = unnamed.uFogMode;\n    if (_e116 == 1i) {\n        let _e119 = unnamed.uFogFar;\n        let _e121 = unnamed.uFogNear;\n        span = max((_e119 - _e121), 0.0001f);\n        let _e124 = (*dist);\n        let _e126 = unnamed.uFogNear;\n        let _e128 = span;\n        ramp = clamp(((_e124 - _e126) / _e128), 0f, 1f);\n        let _e132 = unnamed.uUnderwaterFactor;\n        if (_e132 <= 0f) {\n            let _e134 = ramp;\n            return _e134;\n        }\n        let _e136 = unnamed.uUnderwaterFogDensity;\n        let _e137 = (*dist);\n        wetLinear = (_e136 * _e137);\n        let _e139 = ramp;\n        let _e140 = wetLinear;\n        let _e142 = wetLinear;\n        let _e148 = unnamed.uUnderwaterFactor;\n        return mix(_e139, (1f - exp2(((-(_e140) * _e142) * 1.442695f))), _e148);\n    }\n    let _e151 = unnamed.uFogNear;\n    let _e152 = (*dist);\n    start = min(_e151, _e152);\n    let _e154 = (*dist);\n    if (_e154 > 0f) {\n        let _e156 = start;\n        let _e157 = (*dist);\n        local = (_e156 / _e157);\n    } else {\n        local = 0f;\n    }\n    let _e159 = local;\n    before = _e159;\n    let _e160 = (*pointY);\n    let _e162 = unnamed.uFogEyeY;\n    let _e165 = unnamed.uFogHeightFalloff;\n    t = ((_e160 - _e162) * _e165);\n    let _e167 = t;\n    let _e168 = before;\n    rest = (_e167 * (1f - _e168));\n    let _e171 = rest;\n    let _e174 = rest;\n    denom = select(_e174, 0.0001f, (abs(_e171) < 0.0001f));\n    let _e177 = unnamed.uFogDensity;\n    let _e179 = t;\n    let _e181 = before;\n    let _e185 = (*dist);\n    let _e186 = start;\n    let _e189 = denom;\n    let _e194 = denom;\n    air = (1f - exp(((((-(_e177) * exp((-(_e179) * _e181))) * (_e185 - _e186)) * (1f - exp(-(_e189)))) / _e194)));\n    let _e199 = unnamed.uUnderwaterFactor;\n    if (_e199 <= 0f) {\n        let _e201 = air;\n        return _e201;\n    }\n    let _e203 = unnamed.uUnderwaterFogDensity;\n    let _e204 = (*dist);\n    wet = (_e203 * _e204);\n    let _e206 = air;\n    let _e207 = wet;\n    let _e209 = wet;\n    let _e215 = unnamed.uUnderwaterFactor;\n    return mix(_e206, (1f - exp2(((-(_e207) * _e209) * 1.442695f))), _e215);\n}\n\nfn hash21_u0028_vf2_u003b(p: ptr<function, vec2<f32>>) -> f32 {\n    let _e103 = (*p);\n    return fract((sin(dot(_e103, 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_4: vec2<f32>;\n    var param_5: vec2<f32>;\n    var param_6: vec2<f32>;\n    var param_7: vec2<f32>;\n\n    let _e110 = (*p_1);\n    i = floor(_e110);\n    let _e112 = (*p_1);\n    f = fract(_e112);\n    let _e114 = f;\n    let _e115 = f;\n    let _e117 = f;\n    u = ((_e114 * _e115) * (vec2(3f) - (_e117 * 2f)));\n    let _e122 = i;\n    param_4 = _e122;\n    let _e123 = hash21_u0028_vf2_u003b((&param_4));\n    let _e124 = i;\n    param_5 = (_e124 + vec2<f32>(1f, 0f));\n    let _e126 = hash21_u0028_vf2_u003b((&param_5));\n    let _e128 = u[0u];\n    let _e130 = i;\n    param_6 = (_e130 + vec2<f32>(0f, 1f));\n    let _e132 = hash21_u0028_vf2_u003b((&param_6));\n    let _e133 = i;\n    param_7 = (_e133 + vec2<f32>(1f, 1f));\n    let _e135 = hash21_u0028_vf2_u003b((&param_7));\n    let _e137 = u[0u];\n    let _e140 = u[1u];\n    return mix(mix(_e123, _e126, _e128), mix(_e132, _e135, _e137), _e140);\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_8: vec2<f32>;\n    var outer: f32;\n    var param_9: vec2<f32>;\n    var swirl: f32;\n    var param_10: 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_11: f32;\n    var param_12: f32;\n    var param_13: vec3<f32>;\n    var phi_442_: bool;\n\n    let _e122 = unnamed.uClipEnabled;\n    let _e123 = (_e122 != 0i);\n    phi_442_ = _e123;\n    if _e123 {\n        let _e124 = vWorldPos_1;\n        let _e130 = unnamed.uClipPlane;\n        phi_442_ = (dot(vec4<f32>(_e124.x, _e124.y, _e124.z, 1f), _e130) < 0f);\n    }\n    let _e134 = phi_442_;\n    if _e134 {\n        discard;\n    }\n    let _e135 = vUv_1;\n    radius = (length((_e135 - vec2(0.5f))) * 2f);\n    let _e140 = radius;\n    if (_e140 >= 1f) {\n        discard;\n    }\n    let _e142 = vUv_1;\n    d = (_e142 - vec2(0.5f));\n    let _e146 = d[1u];\n    let _e148 = d[0u];\n    angle = atan2(_e146, _e148);\n    let _e151 = unnamed.uTime;\n    let _e152 = vSeed_1;\n    t_1 = (_e151 + (_e152 * 37f));\n    let _e155 = angle;\n    let _e157 = t_1;\n    let _e160 = radius;\n    param_8 = vec2<f32>(((_e155 * 1.9f) + (_e157 * 0.55f)), (_e160 * 4.2f));\n    let _e163 = valueNoise_u0028_vf2_u003b((&param_8));\n    inner = _e163;\n    let _e164 = angle;\n    let _e166 = t_1;\n    let _e169 = radius;\n    param_9 = vec2<f32>(((_e164 * 3.1f) - (_e166 * 0.34f)), (_e169 * 2.6f));\n    let _e172 = valueNoise_u0028_vf2_u003b((&param_9));\n    outer = _e172;\n    let _e173 = inner;\n    let _e175 = outer;\n    swirl = ((_e173 * 0.62f) + (_e175 * 0.38f));\n    let _e179 = unnamed.uNoiseOctaves;\n    if (_e179 > 1i) {\n        let _e181 = swirl;\n        let _e182 = swirl;\n        let _e183 = angle;\n        let _e185 = t_1;\n        let _e188 = radius;\n        param_10 = vec2<f32>(((_e183 * 6.3f) + (_e185 * 0.9f)), (_e188 * 8f));\n        let _e191 = valueNoise_u0028_vf2_u003b((&param_10));\n        swirl = mix(_e181, ((_e182 * _e191) * 2f), 0.35f);\n    }\n    let _e195 = radius;\n    core = (1f - smoothstep(0f, 0.28f, _e195));\n    let _e198 = radius;\n    let _e201 = swirl;\n    corona = ((1f - smoothstep(0.18f, 1f, _e198)) * (0.35f + (_e201 * 0.65f)));\n    let _e205 = core;\n    let _e207 = corona;\n    body = ((_e205 * 0.9f) + _e207);\n    let _e209 = body;\n    if (_e209 <= 0.02f) {\n        discard;\n    }\n    let _e212 = unnamed.uTint;\n    let _e215 = unnamed.uTint;\n    let _e216 = body;\n    col = mix((_e212 * 0.35f), _e215, vec3(smoothstep(0f, 0.55f, _e216)));\n    let _e220 = col;\n    let _e221 = body;\n    col = mix(_e220, vec3<f32>(1f, 1f, 1f), vec3(smoothstep(0.82f, 1.4f, _e221)));\n    let _e226 = unnamed.uTint;\n    let _e227 = col;\n    col = (_e227 * _e226);\n    let _e229 = body;\n    alpha = clamp((_e229 * 1.6f), 0f, 1f);\n    let _e232 = vDistance_1;\n    param_11 = _e232;\n    let _e234 = vWorldPos_1[1u];\n    param_12 = _e234;\n    let _e235 = mediumFog_u0028_f1_u003b_f1_u003b((&param_11), (&param_12));\n    fog = _e235;\n    let _e236 = col;\n    let _e237 = mediumColor_u0028_();\n    let _e238 = fog;\n    col = mix(_e236, _e237, vec3(_e238));\n    let _e241 = fog;\n    let _e243 = alpha;\n    alpha = (_e243 * (1f - _e241));\n    let _e245 = col;\n    param_13 = _e245;\n    let _e246 = applyOutputTransform_u0028_vf3_u003b((&param_13));\n    let _e247 = alpha;\n    outColor = vec4<f32>(_e246.x, _e246.y, _e246.z, _e247);\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    uFogMedium: vec4<f32>,\n    uFogRange: vec4<f32>,\n    uUnderwaterColor: vec3<f32>,\n    uUnderwaterFactor: f32,\n    uFogLayer2_: vec4<f32>,\n    uFogGlow: vec4<f32>,\n    uFogGlowDir: vec4<f32>,\n    uNoiseOctaves: i32,\n    uClipPlane: vec4<f32>,\n    uClipEnabled: i32,\n    uOutputTransform: i32,\n    uOutputExposure: f32,\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 linearToSrgb_u0028_vf3_u003b(c: ptr<function, vec3<f32>>) -> vec3<f32> {\n    var low: vec3<f32>;\n    var high: vec3<f32>;\n\n    let _e102 = (*c);\n    low = (_e102 * 12.92f);\n    let _e104 = (*c);\n    high = ((pow(max(_e104, vec3<f32>(0f, 0f, 0f)), vec3<f32>(0.41666666f, 0.41666666f, 0.41666666f)) * 1.055f) - vec3(0.055f));\n    let _e110 = high;\n    let _e111 = low;\n    let _e112 = (*c);\n    return mix(_e110, _e111, step(_e112, vec3<f32>(0.0031308f, 0.0031308f, 0.0031308f)));\n}\n\nfn highlightShoulder_u0028_vf3_u003b(c_1: ptr<function, vec3<f32>>) -> vec3<f32> {\n    var m: f32;\n    var e: f32;\n\n    let _e103 = (*c_1)[0u];\n    let _e105 = (*c_1)[1u];\n    let _e107 = (*c_1)[2u];\n    m = max(_e103, max(_e105, _e107));\n    let _e110 = m;\n    if (_e110 <= 0.8f) {\n        let _e112 = (*c_1);\n        return _e112;\n    }\n    let _e113 = m;\n    e = (_e113 - 0.8f);\n    let _e115 = (*c_1);\n    let _e116 = e;\n    let _e118 = e;\n    let _e122 = m;\n    return (_e115 * ((0.8f + ((0.2f * _e116) / (_e118 + 0.2f))) / _e122));\n}\n\nfn rrtAndOdtFit_u0028_vf3_u003b(v: ptr<function, vec3<f32>>) -> vec3<f32> {\n    var a: vec3<f32>;\n    var b: vec3<f32>;\n\n    let _e102 = (*v);\n    let _e103 = (*v);\n    a = ((_e102 * (_e103 + vec3(0.0245786f))) - vec3(0.000090537f));\n    let _e109 = (*v);\n    let _e110 = (*v);\n    b = ((_e109 * ((_e110 * 0.983729f) + vec3(0.432951f))) + vec3(0.238081f));\n    let _e117 = a;\n    let _e118 = b;\n    return (_e117 / _e118);\n}\n\nfn acesFilmic_u0028_vf3_u003b(x: ptr<function, vec3<f32>>) -> vec3<f32> {\n    var param: vec3<f32>;\n\n    let _e102 = unnamed.uOutputExposure;\n    let _e103 = (*x);\n    (*x) = (_e103 * _e102);\n    let _e105 = (*x);\n    param = (mat3x3<f32>(vec3<f32>(0.59719f, 0.076f, 0.0284f), vec3<f32>(0.35458f, 0.90834f, 0.13383f), vec3<f32>(0.04823f, 0.01566f, 0.83777f)) * _e105);\n    let _e107 = rrtAndOdtFit_u0028_vf3_u003b((&param));\n    return clamp((mat3x3<f32>(vec3<f32>(1.60475f, -0.10208f, -0.00327f), vec3<f32>(-0.53108f, 1.10813f, -0.07276f), vec3<f32>(-0.07367f, -0.00605f, 1.07602f)) * _e107), vec3(0f), vec3(1f));\n}\n\nfn applyOutputTransform_u0028_vf3_u003b(c_2: ptr<function, vec3<f32>>) -> vec3<f32> {\n    var param_1: vec3<f32>;\n    var param_2: vec3<f32>;\n    var param_3: vec3<f32>;\n\n    let _e104 = unnamed.uOutputTransform;\n    if (_e104 == 0i) {\n        let _e106 = (*c_2);\n        return _e106;\n    }\n    let _e108 = unnamed.uOutputTransform;\n    if (_e108 == 2i) {\n        let _e110 = (*c_2);\n        param_1 = _e110;\n        let _e111 = acesFilmic_u0028_vf3_u003b((&param_1));\n        (*c_2) = _e111;\n    }\n    let _e113 = unnamed.uOutputTransform;\n    if (_e113 == 3i) {\n        let _e115 = (*c_2);\n        let _e117 = unnamed.uOutputExposure;\n        param_2 = (_e115 * _e117);\n        let _e119 = highlightShoulder_u0028_vf3_u003b((&param_2));\n        (*c_2) = _e119;\n    }\n    let _e120 = (*c_2);\n    param_3 = _e120;\n    let _e121 = linearToSrgb_u0028_vf3_u003b((&param_3));\n    return _e121;\n}\n\nfn mediumColor_u0028_() -> vec3<f32> {\n    let _e100 = unnamed.uFogColor;\n    let _e102 = unnamed.uUnderwaterColor;\n    let _e104 = unnamed.uUnderwaterFactor;\n    return mix(_e100, _e102, vec3(_e104));\n}\n\nfn hazeDepth_u0028_f1_u003b_f1_u003b(dist: ptr<function, f32>, pointY: ptr<function, f32>) -> 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 depth: f32;\n    var t2_: f32;\n    var rest2_: f32;\n    var denom2_: f32;\n\n    let _e113 = unnamed.uFogRange[0u];\n    let _e114 = (*dist);\n    start = min(_e113, _e114);\n    let _e116 = (*dist);\n    if (_e116 > 0f) {\n        let _e118 = start;\n        let _e119 = (*dist);\n        local = (_e118 / _e119);\n    } else {\n        local = 0f;\n    }\n    let _e121 = local;\n    before = _e121;\n    let _e122 = (*pointY);\n    let _e125 = unnamed.uFogMedium[2u];\n    let _e129 = unnamed.uFogMedium[1u];\n    t = ((_e122 - _e125) * _e129);\n    let _e131 = t;\n    let _e132 = before;\n    rest = (_e131 * (1f - _e132));\n    let _e135 = rest;\n    let _e138 = rest;\n    denom = select(_e138, 0.0001f, (abs(_e135) < 0.0001f));\n    let _e142 = unnamed.uFogMedium[0u];\n    let _e143 = t;\n    let _e145 = before;\n    let _e149 = (*dist);\n    let _e150 = start;\n    let _e153 = denom;\n    let _e158 = denom;\n    depth = ((((_e142 * exp((-(_e143) * _e145))) * (_e149 - _e150)) * (1f - exp(-(_e153)))) / _e158);\n    let _e162 = unnamed.uFogLayer2_[0u];\n    if (_e162 > 0f) {\n        let _e164 = (*pointY);\n        let _e167 = unnamed.uFogMedium[2u];\n        let _e171 = unnamed.uFogLayer2_[1u];\n        t2_ = ((_e164 - _e167) * _e171);\n        let _e173 = t2_;\n        let _e174 = before;\n        rest2_ = (_e173 * (1f - _e174));\n        let _e177 = rest2_;\n        let _e180 = rest2_;\n        denom2_ = select(_e180, 0.0001f, (abs(_e177) < 0.0001f));\n        let _e184 = unnamed.uFogLayer2_[0u];\n        let _e185 = t2_;\n        let _e187 = before;\n        let _e191 = (*dist);\n        let _e192 = start;\n        let _e195 = denom2_;\n        let _e200 = denom2_;\n        let _e202 = depth;\n        depth = (_e202 + ((((_e184 * exp((-(_e185) * _e187))) * (_e191 - _e192)) * (1f - exp(-(_e195)))) / _e200));\n    }\n    let _e204 = depth;\n    return _e204;\n}\n\nfn mediumFog_u0028_f1_u003b_f1_u003b(dist_1: ptr<function, f32>, pointY_1: ptr<function, f32>) -> f32 {\n    var cut: bool;\n    var span: f32;\n    var ramp: f32;\n    var local_1: f32;\n    var wetLinear: f32;\n    var air: f32;\n    var local_2: f32;\n    var param_4: f32;\n    var param_5: f32;\n    var wet: f32;\n    var phi_193_: bool;\n\n    let _e113 = unnamed.uFogLayer2_[3u];\n    let _e114 = (_e113 > 0f);\n    phi_193_ = _e114;\n    if _e114 {\n        let _e115 = (*dist_1);\n        let _e118 = unnamed.uFogLayer2_[3u];\n        phi_193_ = (_e115 > _e118);\n    }\n    let _e121 = phi_193_;\n    cut = _e121;\n    let _e124 = unnamed.uFogRange[2u];\n    if (_e124 == 1f) {\n        let _e128 = unnamed.uFogRange[1u];\n        let _e131 = unnamed.uFogRange[0u];\n        span = max((_e128 - _e131), 0.0001f);\n        let _e134 = cut;\n        if _e134 {\n            local_1 = 0f;\n        } else {\n            let _e135 = (*dist_1);\n            let _e138 = unnamed.uFogRange[0u];\n            let _e140 = span;\n            let _e145 = unnamed.uFogLayer2_[2u];\n            local_1 = min(clamp(((_e135 - _e138) / _e140), 0f, 1f), (1f - _e145));\n        }\n        let _e148 = local_1;\n        ramp = _e148;\n        let _e150 = unnamed.uUnderwaterFactor;\n        if (_e150 <= 0f) {\n            let _e152 = ramp;\n            return _e152;\n        }\n        let _e155 = unnamed.uFogMedium[3u];\n        let _e156 = (*dist_1);\n        wetLinear = (_e155 * _e156);\n        let _e158 = ramp;\n        let _e159 = wetLinear;\n        let _e161 = wetLinear;\n        let _e167 = unnamed.uUnderwaterFactor;\n        return mix(_e158, (1f - exp2(((-(_e159) * _e161) * 1.442695f))), _e167);\n    }\n    let _e169 = cut;\n    if _e169 {\n        local_2 = 0f;\n    } else {\n        let _e170 = (*dist_1);\n        param_4 = _e170;\n        let _e171 = (*pointY_1);\n        param_5 = _e171;\n        let _e172 = hazeDepth_u0028_f1_u003b_f1_u003b((&param_4), (&param_5));\n        let _e177 = unnamed.uFogLayer2_[2u];\n        local_2 = (1f - max(exp(-(_e172)), _e177));\n    }\n    let _e180 = local_2;\n    air = _e180;\n    let _e182 = unnamed.uUnderwaterFactor;\n    if (_e182 <= 0f) {\n        let _e184 = air;\n        return _e184;\n    }\n    let _e187 = unnamed.uFogMedium[3u];\n    let _e188 = (*dist_1);\n    wet = (_e187 * _e188);\n    let _e190 = air;\n    let _e191 = wet;\n    let _e193 = wet;\n    let _e199 = unnamed.uUnderwaterFactor;\n    return mix(_e190, (1f - exp2(((-(_e191) * _e193) * 1.442695f))), _e199);\n}\n\nfn hash21_u0028_vf2_u003b(p: ptr<function, vec2<f32>>) -> f32 {\n    let _e100 = (*p);\n    return fract((sin(dot(_e100, 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_6: vec2<f32>;\n    var param_7: vec2<f32>;\n    var param_8: vec2<f32>;\n    var param_9: vec2<f32>;\n\n    let _e107 = (*p_1);\n    i = floor(_e107);\n    let _e109 = (*p_1);\n    f = fract(_e109);\n    let _e111 = f;\n    let _e112 = f;\n    let _e114 = f;\n    u = ((_e111 * _e112) * (vec2(3f) - (_e114 * 2f)));\n    let _e119 = i;\n    param_6 = _e119;\n    let _e120 = hash21_u0028_vf2_u003b((&param_6));\n    let _e121 = i;\n    param_7 = (_e121 + vec2<f32>(1f, 0f));\n    let _e123 = hash21_u0028_vf2_u003b((&param_7));\n    let _e125 = u[0u];\n    let _e127 = i;\n    param_8 = (_e127 + vec2<f32>(0f, 1f));\n    let _e129 = hash21_u0028_vf2_u003b((&param_8));\n    let _e130 = i;\n    param_9 = (_e130 + vec2<f32>(1f, 1f));\n    let _e132 = hash21_u0028_vf2_u003b((&param_9));\n    let _e134 = u[0u];\n    let _e137 = u[1u];\n    return mix(mix(_e120, _e123, _e125), mix(_e129, _e132, _e134), _e137);\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_10: vec2<f32>;\n    var outer: f32;\n    var param_11: vec2<f32>;\n    var swirl: f32;\n    var param_12: 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_13: f32;\n    var param_14: f32;\n    var param_15: vec3<f32>;\n    var phi_528_: bool;\n\n    let _e119 = unnamed.uClipEnabled;\n    let _e120 = (_e119 != 0i);\n    phi_528_ = _e120;\n    if _e120 {\n        let _e121 = vWorldPos_1;\n        let _e127 = unnamed.uClipPlane;\n        phi_528_ = (dot(vec4<f32>(_e121.x, _e121.y, _e121.z, 1f), _e127) < 0f);\n    }\n    let _e131 = phi_528_;\n    if _e131 {\n        discard;\n    }\n    let _e132 = vUv_1;\n    radius = (length((_e132 - vec2(0.5f))) * 2f);\n    let _e137 = radius;\n    if (_e137 >= 1f) {\n        discard;\n    }\n    let _e139 = vUv_1;\n    d = (_e139 - vec2(0.5f));\n    let _e143 = d[1u];\n    let _e145 = d[0u];\n    angle = atan2(_e143, _e145);\n    let _e148 = unnamed.uTime;\n    let _e149 = vSeed_1;\n    t_1 = (_e148 + (_e149 * 37f));\n    let _e152 = angle;\n    let _e154 = t_1;\n    let _e157 = radius;\n    param_10 = vec2<f32>(((_e152 * 1.9f) + (_e154 * 0.55f)), (_e157 * 4.2f));\n    let _e160 = valueNoise_u0028_vf2_u003b((&param_10));\n    inner = _e160;\n    let _e161 = angle;\n    let _e163 = t_1;\n    let _e166 = radius;\n    param_11 = vec2<f32>(((_e161 * 3.1f) - (_e163 * 0.34f)), (_e166 * 2.6f));\n    let _e169 = valueNoise_u0028_vf2_u003b((&param_11));\n    outer = _e169;\n    let _e170 = inner;\n    let _e172 = outer;\n    swirl = ((_e170 * 0.62f) + (_e172 * 0.38f));\n    let _e176 = unnamed.uNoiseOctaves;\n    if (_e176 > 1i) {\n        let _e178 = swirl;\n        let _e179 = swirl;\n        let _e180 = angle;\n        let _e182 = t_1;\n        let _e185 = radius;\n        param_12 = vec2<f32>(((_e180 * 6.3f) + (_e182 * 0.9f)), (_e185 * 8f));\n        let _e188 = valueNoise_u0028_vf2_u003b((&param_12));\n        swirl = mix(_e178, ((_e179 * _e188) * 2f), 0.35f);\n    }\n    let _e192 = radius;\n    core = (1f - smoothstep(0f, 0.28f, _e192));\n    let _e195 = radius;\n    let _e198 = swirl;\n    corona = ((1f - smoothstep(0.18f, 1f, _e195)) * (0.35f + (_e198 * 0.65f)));\n    let _e202 = core;\n    let _e204 = corona;\n    body = ((_e202 * 0.9f) + _e204);\n    let _e206 = body;\n    if (_e206 <= 0.02f) {\n        discard;\n    }\n    let _e209 = unnamed.uTint;\n    let _e212 = unnamed.uTint;\n    let _e213 = body;\n    col = mix((_e209 * 0.35f), _e212, vec3(smoothstep(0f, 0.55f, _e213)));\n    let _e217 = col;\n    let _e218 = body;\n    col = mix(_e217, vec3<f32>(1f, 1f, 1f), vec3(smoothstep(0.82f, 1.4f, _e218)));\n    let _e223 = unnamed.uTint;\n    let _e224 = col;\n    col = (_e224 * _e223);\n    let _e226 = body;\n    alpha = clamp((_e226 * 1.6f), 0f, 1f);\n    let _e229 = vDistance_1;\n    param_13 = _e229;\n    let _e231 = vWorldPos_1[1u];\n    param_14 = _e231;\n    let _e232 = mediumFog_u0028_f1_u003b_f1_u003b((&param_13), (&param_14));\n    fog = _e232;\n    let _e233 = col;\n    let _e234 = mediumColor_u0028_();\n    let _e235 = fog;\n    col = mix(_e233, _e234, vec3(_e235));\n    let _e238 = fog;\n    let _e240 = alpha;\n    alpha = (_e240 * (1f - _e238));\n    let _e242 = col;\n    param_15 = _e242;\n    let _e243 = applyOutputTransform_u0028_vf3_u003b((&param_15));\n    let _e244 = alpha;\n    outColor = vec4<f32>(_e243.x, _e243.y, _e243.z, _e244);\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.
  *
@@ -7,7 +7,7 @@ export declare const ARCANE_FRAG_WGSL = "struct Uniforms {\n    uTime: f32,\n
 export declare const ARCANE_BINDINGS: {
     readonly ARCANE_FRAG: {
         readonly uniforms: 1;
-        readonly uniformSize: 144;
+        readonly uniformSize: 192;
         readonly fields: {
             readonly uTime: {
                 readonly offset: 0;
@@ -19,78 +19,68 @@ export declare const ARCANE_BINDINGS: {
                 readonly size: 12;
                 readonly type: "vec3";
             };
-            readonly uFogDensity: {
-                readonly offset: 28;
-                readonly size: 4;
-                readonly type: "float";
-            };
-            readonly uFogHeightFalloff: {
+            readonly uFogMedium: {
                 readonly offset: 32;
-                readonly size: 4;
-                readonly type: "float";
+                readonly size: 16;
+                readonly type: "vec4";
             };
-            readonly uFogEyeY: {
-                readonly offset: 36;
-                readonly size: 4;
-                readonly type: "float";
+            readonly uFogRange: {
+                readonly offset: 48;
+                readonly size: 16;
+                readonly type: "vec4";
             };
             readonly uUnderwaterColor: {
-                readonly offset: 48;
+                readonly offset: 64;
                 readonly size: 12;
                 readonly type: "vec3";
             };
-            readonly uUnderwaterFogDensity: {
-                readonly offset: 60;
-                readonly size: 4;
-                readonly type: "float";
-            };
             readonly uUnderwaterFactor: {
-                readonly offset: 64;
+                readonly offset: 76;
                 readonly size: 4;
                 readonly type: "float";
             };
-            readonly uFogMode: {
-                readonly offset: 68;
-                readonly size: 4;
-                readonly type: "int";
+            readonly uFogLayer2: {
+                readonly offset: 80;
+                readonly size: 16;
+                readonly type: "vec4";
             };
-            readonly uFogNear: {
-                readonly offset: 72;
-                readonly size: 4;
-                readonly type: "float";
+            readonly uFogGlow: {
+                readonly offset: 96;
+                readonly size: 16;
+                readonly type: "vec4";
             };
-            readonly uFogFar: {
-                readonly offset: 76;
-                readonly size: 4;
-                readonly type: "float";
+            readonly uFogGlowDir: {
+                readonly offset: 112;
+                readonly size: 16;
+                readonly type: "vec4";
             };
             readonly uNoiseOctaves: {
-                readonly offset: 80;
+                readonly offset: 128;
                 readonly size: 4;
                 readonly type: "int";
             };
             readonly uClipPlane: {
-                readonly offset: 96;
+                readonly offset: 144;
                 readonly size: 16;
                 readonly type: "vec4";
             };
             readonly uClipEnabled: {
-                readonly offset: 112;
+                readonly offset: 160;
                 readonly size: 4;
                 readonly type: "int";
             };
             readonly uOutputTransform: {
-                readonly offset: 116;
+                readonly offset: 164;
                 readonly size: 4;
                 readonly type: "int";
             };
             readonly uOutputExposure: {
-                readonly offset: 120;
+                readonly offset: 168;
                 readonly size: 4;
                 readonly type: "float";
             };
             readonly uTint: {
-                readonly offset: 128;
+                readonly offset: 176;
                 readonly size: 12;
                 readonly type: "vec3";
             };