@driftengine/core 4.8.7 → 4.10.0

package/src/render/shaders/flat/main.ts

@@ -26,6 +26,10 @@ export const MAIN_GLSL = `void main() {
   vec2 fxDx = dFdx(surfaceAt.xy);
   vec2 fxDy = dFdy(surfaceAt.xy);
   if (uWriteMode.y != 0.0 && !ditherKeeps(uWriteMode.y)) discard;
+  /* A draw's dissolve cuts the surface away before anything is shaded: overlay.ts. */
+  if (SURFACE_OVERLAY) {
+    if (overlayCuts(surfaceAt.xy)) discard;
+  }
 
   /*
    * Surface colour and its coverage, resolved before anything else — including before it is
@@ -78,7 +82,7 @@ export const MAIN_GLSL = `void main() {
          */
         float share = cutoutShare(tested, uCutout.x);
         if (uCutout.y == 1.0) {
-          if (!cutoutKeeps(share, gl_FragCoord.xy, uCutout.z)) discard;
+          if (!cutoutKeeps(share, gl_FragCoord.xy, uHighlightMin.w)) discard;
           kept = 1.0;
         } else {
           kept = share;
@@ -140,6 +144,11 @@ export const MAIN_GLSL = `void main() {
   }
 
   vec3 lit = albedo;
+  /* How much of the environment the frame shows here, and how a found reflection would land:
+     reflectionSurface.ts. None where nothing is reflected. */
+  vec3 reflectedProbe = vec3(0.0);
+  vec3 reflectedTint = vec3(0.0);
+  float reflectedRoughness = 1.0;
   /* Skin's diffuse, held before emission for the screen-space blur's own pass: models.ts. */
   vec3 diffuseAlone = vec3(0.0);
   /* The light arriving at a glass pane from behind it, gathered in each light loop below and added
@@ -187,7 +196,10 @@ export const MAIN_GLSL = `void main() {
      * right: a mipped colour image, sampled under uniform control flow, exactly as uAlbedo is
      * below. The rule is about non-uniform branches, and this branch is on a uniform.
      */
+    vec3 unmapped = n;
     if (uNormalStrength > 0.0) n = normalMapped(n, surfaceAt);
+    /* A draw's wrinkles, by region, over whatever the map made: overlay.ts. */
+    if (SURFACE_OVERLAY) n = overlayWrinkle(n, unmapped, surfaceAt.xy);
 
     /*
      * Microscopic relief: the surface's own texture, as a turn of the normal rather than a change
@@ -916,6 +928,15 @@ export const MAIN_GLSL = `void main() {
         environment * mix(vec3(1.0), albedo, metal),
         weight
       );
+      reflectedTint = mix(vec3(1.0), albedo, metal) * weight;
+      reflectedProbe = environment * reflectedTint;
+      reflectedRoughness = surfaceRoughness;
+    }
+    /* The reflection pass's surface half leaves here, before the lamps: reflectionSurface.ts. */
+    if (REFLECTION_SURFACE) {
+      reflectionSurfaceOut(reflectedProbe, reflectedTint, reflectedRoughness, ormOcclusion,
+        reflectionAir());
+      return;
     }
     /*
      * The sun's highlight, on top of whatever the surface reflects rather than underneath it —
@@ -1260,7 +1281,7 @@ export const MAIN_GLSL = `void main() {
        */
       float falloff;
       /*
-       * **A light may name its own falloff, and then it is Unreal's for a light without
+       * **A light may name its own falloff, and then it is the usual one 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.
@@ -1940,6 +1961,9 @@ export const MAIN_GLSL = `void main() {
       * mix(1.0, min(lightShade, sunShade), EMISSIVE_SHADOW_SHARE) * fxGlow;
     /* And a lit window's glow, which the scene's lit share already times: not gated on night. */
     lit += windowGlow * uEmission.x;
+    /* And a draw's overlay: its rim, its dissolve's band and the colour laid over. Not gated on the
+       night, as emission is: a glow the surface wears rather than light it gives off. overlay.ts. */
+    if (SURFACE_OVERLAY) lit += overlayGlow(surfaceAt.xy, n);
 
 #if NIGHT_EMISSIVE
     /*
@@ -1973,7 +1997,7 @@ export const MAIN_GLSL = `void main() {
     // finishing a run reads the same at noon and at midnight. Costs one compare
     // per fragment and no extra draw call — the box is a uniform, not geometry.
     if (uHighlightMax.w > 0.0) {
-      vec3 inside = step(uHighlightMin, vWorldPos) * step(vWorldPos, uHighlightMax.xyz);
+      vec3 inside = step(uHighlightMin.xyz, vWorldPos) * step(vWorldPos, uHighlightMax.xyz);
       lit += albedo * uHighlightMax.w * inside.x * inside.y * inside.z;
     }
   }
@@ -2077,7 +2101,17 @@ export const MAIN_GLSL = `void main() {
     vec3 refractV = normalize(uCameraPos - vWorldPos);
     ivec2 snapSize = textureSize(uRefractScene, 0);
     vec2 screenUv = gl_FragCoord.xy / vec2(snapSize);
-    vec2 bent = clamp(screenUv + refractN.xy * uSeeThrough.x, vec2(0.0), vec2(1.0));
+    /*
+     * **The normal's sideways part as the eye sees it**: the shading normal in view space, its x
+     * and y across the screen, y turned to the way this frame's rows run (w of the tint). It was the
+     * normal's world x and y until 4.10.0, which on a quad facing the camera is the quad's own lean
+     * against the world's axes: one offset over the whole quad, a lens, with a normal map's tilt a
+     * small change on top. In view space a quad facing the eye bends by nothing but its map, which
+     * is a shimmer, and a pane bends by how it leans toward the eye wherever the eye stands.
+     */
+    vec3 seenN = mat3(uView) * refractN;
+    vec2 bend = vec2(seenN.x, seenN.y * uRefractTint.w);
+    vec2 bent = clamp(screenUv + bend * uSeeThrough.x, vec2(0.0), vec2(1.0));
     /*
      * **An explicit level, and frost is what picks it** — the 2026-08-07 rule, and the reason a
      * frosted pane blurs rather than fades: the copy carries a mip chain on a frame that draws glass,
@@ -2091,7 +2125,7 @@ export const MAIN_GLSL = `void main() {
     /* Unsigned: a pane passes the same light seen from either side, and so does its Fresnel. */
     float cosView = max(abs(dot(refractN, refractV)), 0.05);
     float pathLength = uSeeThrough.y * vThickness / cosView;
-    vec3 seen = behind * pow(uRefractTint, vec3(pathLength));
+    vec3 seen = behind * pow(uRefractTint.rgb, vec3(pathLength));
     if (glassTransmission > 0.0) {
       /*
        * **Glass keeps its own surface and shows what is behind over it**, by how much it lets
@@ -2138,6 +2172,10 @@ export const MAIN_GLSL = `void main() {
     return;
   }
 
+  /* WebGL2's frame writes the reflection maps itself, with the fog already reckoned above. */
+  if (REFLECTION_MAPS) {
+    reflectionSurfaceOut(reflectedProbe, reflectedTint, reflectedRoughness, ormOcclusion, fog);
+  }
   outColor = vec4(shaded, alpha);
 }
 `;

package/src/render/shaders/flat/models.ts

@@ -59,7 +59,7 @@ 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
  * (surfaceModel.ts) — and whether a model map is bound, in the last component.
  */
-uniform vec4 uModelParams[2];
+uniform vec4 uModelParams[2]; // wgsl:material
 /* The model's own channels, in the albedo's layout: what each means is each model's to say. */
 uniform highp sampler2DArray uModelMap;
 

package/src/render/shaders/flat/overlay.ts

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

package/src/render/shaders/flat/pointShadow.ts

@@ -13,7 +13,7 @@
  * picture and is its own change.
  */
 import { MAX_SHADOW_FILTER_TAPS } from '../../renderQuality.ts';
-import { OUTPUT_TRANSFORM_GLSL } from '../outputTransform.ts';
+import { LIT_OUTPUT_TRANSFORM_GLSL } from '../outputTransform.ts';
 import { LAMP_GLASS_GLSL } from './lampGlass.ts';
 
 export const POINTSHADOW_GLSL = `/**
@@ -342,9 +342,9 @@ float areaShadow(
 ${LAMP_GLASS_GLSL}
 #endif
 
-out vec4 outColor;
+layout(location = 0) out vec4 outColor;
 
-${OUTPUT_TRANSFORM_GLSL}
+${LIT_OUTPUT_TRANSFORM_GLSL}
 
 /**
  * A fixed Poisson disk avoids the grid-shaped edge left by square 3x3 PCF.

package/src/render/shaders/flat/preamble.ts

@@ -121,9 +121,15 @@ uniform sampler2D uRefractScene;
  * gives up, and four separate floats cost half the shadowed lights such a device can have. The tints
  * stay colours of their own. Zero transmission is not glass — see glass.ts.
  */
-uniform vec4 uSeeThrough;
-uniform vec3 uRefractTint;
-uniform vec3 uGlassTint;
+uniform vec4 uSeeThrough; // wgsl:material
+/*
+ * What a metre of the medium leaves of each channel (rgb), and in w which way this frame's rows run
+ * up the screen: +1 where the first row is the bottom (WebGL2), -1 where it is the top (WebGPU). The
+ * bend is taken in view space, whose y is up whatever the framebuffer says, so it is turned here to
+ * the rows a screen coordinate counts. A vec4 where a vec3 already spent the row.
+ */
+uniform vec4 uRefractTint; // wgsl:material
+uniform vec3 uGlassTint; // wgsl:material
 flat in int vHasTangents;
 
 /**
@@ -154,7 +160,7 @@ uniform mediump sampler2DArray uAlbedo;
  *   card. Its draw culls nothing, and a back face is lit as a front, with the shading normal turned
  *   toward the viewer.
  */
-uniform ivec4 uMaterialFlags;
+uniform ivec4 uMaterialFlags; // wgsl:material
 /**
  * Alpha below which a textured fragment is thrown away entirely, 0 to disable.
  *
@@ -168,13 +174,17 @@ uniform ivec4 uMaterialFlags;
  * else changes.
  *
  * **Four numbers in one row**: x is the cutoff, y how this frame resolves the edge (0 the hard test,
- * 1 a dither the temporal resolve averages, 2 alpha-to-coverage; see \`cutoutDither.ts\`), z the
- * frame the dither's pattern is offset by, w the material's lighting channels — a mask a light
- * shades it only where its own shares a bit with (\`SurfaceMaterial.lightChannels\`, 1 unless a
- * material names others). One vector rather than a float and three more, because every loose
- * scalar is a row of WebGL2's 224 that the light budget gives up.
+ * 1 a dither the temporal resolve averages, 2 alpha-to-coverage; see \`cutoutDither.ts\`), z unused,
+ * w the material's lighting channels — a mask a light shades it only where its own shares a bit
+ * with (\`SurfaceMaterial.lightChannels\`, 1 unless a material names others). One vector rather than
+ * a float and three more, because every loose scalar is a row of WebGL2's 224 that the light budget
+ * gives up.
+ *
+ * **z was the frame the dither's pattern is offset by until 4.10.0**, and that made every material
+ * new every frame: a material is kept on WebGPU by its numbers, and one of them changed with the
+ * clock. The frame is the pass's, in \`uHighlightMin.w\`.
  */
-uniform vec4 uCutout;
+uniform vec4 uCutout; // wgsl:material
 /**
  * A draw's own ambient, as nine spherical-harmonic coefficients of incoming radiance, red green blue
  * in turn, twenty-seven floats, and in the last of the twenty-eight a 1 where they are on — 0 is the
@@ -182,7 +192,7 @@ uniform vec4 uCutout;
  * and the basis, and its tests hold this to it. Seven rows of the material block, which is per draw
  * as far as anything here is: \`setAmbientSH\` moves it between two draws as \`setMaterial\` does.
  */
-uniform vec4 uAmbientSH[7];
+uniform vec4 uAmbientSH[7]; // wgsl:material
 
 /** The ambient a surface facing \`n\` receives from \`uAmbientSH\`: \`ambientFromSH\`'s arithmetic. */
 vec3 ambientHarmonics(vec3 n) {
@@ -229,7 +239,7 @@ uniform highp sampler2DArray uNormalMap;
  * shadow samplers, where a profile with shadows off should declare none of them; it is the wrong
  * tool for one image on a shader that already declares one.
  */
-uniform float uNormalStrength;
+uniform float uNormalStrength; // wgsl:material
 
 /**
  * Occlusion, roughness and metallic in one image. glTF's packing, because that is what an import
@@ -250,7 +260,7 @@ uniform highp sampler2DArray uOrmMap;
  * occlusionTexture.strength is: 1 + strength * (texel - 1). A multiply at 0 means fully occluded,
  * which is the opposite of what a caller asking for no occlusion means.
  */
-uniform vec3 uOrmScale;
+uniform vec3 uOrmScale; // wgsl:material
 /**
  * 1 when \`uEnvironment\` holds the GGX-prefiltered cube, 0 when it holds the capture's box chain.
  *
@@ -266,7 +276,7 @@ uniform vec3 uOrmScale;
  * (\`uniformVectorBudget.ts\`). y is how much of the environment the material mirrors, z how
  * bright what it mirrors is.
  */
-uniform vec3 uEnvironmentDials;
+uniform vec3 uEnvironmentDials; // wgsl:material
 
 /**
  * Where a surface glows, and in what colour.
@@ -288,7 +298,7 @@ uniform highp sampler2DArray uEmissiveMap;
  * The counterpart of \`uOrmScale\`: a factor that multiplies a texture is not a value, and this is
  * where the multiplier lives once an image supplies the shape.
  */
-uniform vec3 uEmissiveScale;
+uniform vec3 uEmissiveScale; // wgsl:material
 
 #if DIRECTIONAL_SHADOWS
 /*
@@ -375,7 +385,7 @@ uniform vec4 uSurfaceScene;
  * draw moves it), y the night factor emission is gated on. One row where two floats were two
  * (\`uniformVectorBudget.ts\`).
  */
-uniform vec2 uEmission;
+uniform vec2 uEmission; // wgsl:material
 #if NIGHT_EMISSIVE
 /**
  * Emission that only shows where the dominant light does not reach. 0 is off and is the default.
@@ -400,7 +410,7 @@ uniform float uNightEmissive;
  * of that to change one channel is how a renderer ends up with two shaders that
  * disagree about the sun. The caller owns the blend state; this owns the number.
  */
-uniform float uOpacity;
+uniform float uOpacity; // wgsl:material
 
 /**
  * Two per-draw switches on how a fragment is *written* rather than what colour it is, sharing one
@@ -432,7 +442,7 @@ uniform float uOpacity;
  * crossfade reads as grain for as long as it lasts, which is why it should be short; and a blended
  * draw that asks for it is dithered too, since the test is a discard.
  */
-uniform vec2 uWriteMode;
+uniform vec2 uWriteMode; // wgsl:material
 
 /** Whether this fragment is one \`uWriteMode.y\` keeps. Integer arithmetic, per the device rule. */
 bool ditherKeeps(float amount) {
@@ -465,7 +475,7 @@ bool ditherKeeps(float amount) {
  * one uniform skips the untaken side rather than computing both and discarding one, which is
  * only true because nothing here reads it through a *varying*-dependent branch.
  */
-uniform int uLightingEnabled;
+uniform int uLightingEnabled; // wgsl:material
 /**
  * How this draw meets the medium: the atmospheric haze and the underwater tint both, folded
  * together because both are the *camera's* medium rather than a property of the surface — see
@@ -487,7 +497,7 @@ uniform int uLightingEnabled;
  * is what "exactly as its colour says" has to mean for it; the cost is that such a draw will
  * not tint if the camera goes under water, unlike everything else in the frame.
  */
-uniform int uFogEnabled;
+uniform int uFogEnabled; // wgsl:material
 
 /**
  * A pass-level scale over the grain the geometry declared, 0 to 1.
@@ -497,7 +507,7 @@ uniform int uFogEnabled;
  * imported model that declares nothing is drawn with the pass's own answer, and a scene
  * can dial a whole draw down without rebuilding its geometry.
  */
-uniform float uGrain;
+uniform float uGrain; // wgsl:material
 /*
  * The material's own relief: how strong, and how many bumps to a metre.
  *
@@ -506,7 +516,7 @@ uniform float uGrain;
  * between them, and the geometry carrying them is identical in all three cases. See
  * Renderer.setSurfaceRelief. x is the strength and y the bumps to a metre, in one row.
  */
-uniform vec2 uRelief;
+uniform vec2 uRelief; // wgsl:material
 /**
  * How hard the bound surface texture's own luminance turns the shading normal, 0 for not at all.
  *
@@ -529,7 +539,7 @@ uniform vec2 uRelief;
  * 0..1 like its neighbours for the same reason: this is an amplitude against a luminance
  * gradient, not a fraction of anything.
  */
-uniform float uTextureRelief;
+uniform float uTextureRelief; // wgsl:material
 
 /**
  * How much of the environment this material mirrors, 0 to 1.
@@ -664,8 +674,12 @@ uniform vec3 uProbeGridSets;
 /**
  * A world-space box that lights up regardless of time of day: its corners, and in the far corner's
  * w the gain — one row where a loose float was another (\`uniformVectorBudget.ts\`).
+ *
+ * **And in the near corner's w the frame the cutout dither's pattern is offset by**, for the same
+ * reason: a row the lit stage already pays for, holding a number the pass sets and no material does.
+ * See \`uCutout\`.
  */
-uniform vec3 uHighlightMin;
+uniform vec4 uHighlightMin;
 uniform vec4 uHighlightMax;
 
 /*

package/src/render/shaders/flat/reflectionSurface.ts

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

package/src/render/shaders/fog.ts

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

package/src/render/shaders/fringe.ts

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

package/src/render/shaders/generated/arcane.wgsl.ts

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