@call-me-sensei/toonlab 0.3.1 → 0.4.20

package/src/shaders-tsl/grass.js

@@ -15,12 +15,14 @@ import {
   cameraViewMatrix,
   clamp,
   cos,
+  cross,
   Discard,
   distance,
   dot,
   float,
   Fn,
   fract,
+  If,
   length,
   mix,
   modelWorldMatrix,
@@ -40,14 +42,22 @@ import {
 import { NodeMaterial } from 'three/webgpu';
 
 import { sampleEnvironmentSunShadow } from './chunks/environment-sun-shadow.js';
+import { sampleEnvironmentCloudShadow } from '../sky/cloudShadow.js';
+import { sampleGroundColor } from './chunks/environment-ground-field.js';
 import { stylizedCloudShadow } from './chunks/stylized-cloud-shadow.js';
+import { shiftNormalizedHue } from './chunks/normalized-hue.js';
 import {
   createVegetationStyleUniforms,
   shadeVegetationSurface,
   tagVegetationRole,
 } from './chunks/vegetation-style.js';
 
-export function createGrassNodeMaterial(settings, vegetationShader = null) {
+export function createGrassNodeMaterial(
+  settings,
+  vegetationShader = null,
+  { geometryMode = 'blade', groundField = true } = {},
+) {
+  const clumpGeometry = geometryMode === 'clump';
   const styleUniforms = createVegetationStyleUniforms(vegetationShader, 'grassBlade');
   const u = {
     uBaseColor: uniform(new THREE.Color()),
@@ -57,6 +67,9 @@ export function createGrassNodeMaterial(settings, vegetationShader = null) {
     uCloudShadowVelocity: uniform(new THREE.Vector2(settings.cloudShadowVelocity[0], settings.cloudShadowVelocity[1])),
     uFadeEnd: uniform(1e6 + 1),
     uFadeStart: uniform(1e6),
+    uGroundAdoptHeight: uniform(settings.groundAdoptHeight),
+    uGroundAdoptStrength: uniform(settings.groundAdoptStrength),
+    uGroundAdoptTint: uniform(new THREE.Color(...settings.groundAdoptTint)),
     uGustFrequency: uniform(settings.gustFrequency),
     uGustResponse: uniform(settings.gustResponse),
     uGustSpeed: uniform(settings.gustSpeed),
@@ -69,10 +82,13 @@ export function createGrassNodeMaterial(settings, vegetationShader = null) {
     uSunDirection: uniform(new THREE.Vector3(...settings.sunDirection).normalize()),
     uTime: uniform(0),
     uTipColor: uniform(new THREE.Color()),
+    uStaticLean: uniform(settings.leanStrength),
     uWindDirection: uniform(new THREE.Vector2(settings.windDirection[0], settings.windDirection[1])),
     uWindResponse: uniform(settings.windResponse),
     uWindSpeed: uniform(settings.windSpeed),
     uWindStrength: uniform(settings.windStrength),
+    uWashLift: uniform(settings.washLift),
+    uWashOpacity: uniform(settings.washOpacity),
     ...styleUniforms,
   };
   if (!vegetationShader) u.uStyleGrassBacklitStrength.value = settings.backlitStrength;
@@ -83,25 +99,68 @@ export function createGrassNodeMaterial(settings, vegetationShader = null) {
   material.name = 'StylizedGrass';
   material.side = THREE.DoubleSide;
   material.fog = true;
+  material.transparent = settings.washOpacity < 0.999;
+  material.depthWrite = true;
 
   const vUv = uv();
   const vJitter = varying(float(), 'vGrassJitter');
   const vGust = varying(float(), 'vGrassGust');
   const vNormal = varying(vec3(), 'vGrassNormal');
   const vWorldPosition = varying(vec3(), 'vGrassWorldPosition');
+  const vGroundColor = varying(vec4(), 'vGrassGroundColor');
 
   material.vertexNode = Fn(() => {
     const iOrigin = attribute('iOrigin', 'vec3');
-    const iInfo = attribute('iInfo', 'vec4');
+    const iInfo = clumpGeometry
+      ? attribute('iClump', 'vec4')
+      : attribute('iInfo', 'vec4');
+    const bladeOrigin = clumpGeometry
+      ? attribute('aBladeOrigin', 'vec3')
+      : vec3(0.0);
+    const bladeInfo = clumpGeometry
+      ? attribute('aBladeInfo', 'vec4')
+      : iInfo;
+    const surfaceUp = clumpGeometry
+      ? normalize(attribute('iSurfaceNormal', 'vec3'))
+      : vec3(0.0, 1.0, 0.0);
+    const surfaceForward = clumpGeometry
+      ? normalize(attribute('iSurfaceForward', 'vec3'))
+      : vec3(1.0, 0.0, 0.0);
+    const clumpScale = clumpGeometry ? iInfo.x : float(1.0);
+    const bladeHeight = clumpGeometry ? bladeInfo.x.mul(clumpScale) : iInfo.x;
+    const bladeWidth = clumpGeometry ? bladeInfo.y.mul(clumpScale) : iInfo.z;
+    const bladePhase = clumpGeometry
+      ? fract(iInfo.y.add(bladeInfo.z))
+      : iInfo.y;
+    const facingAngle = clumpGeometry
+      ? iInfo.z.add(bladeInfo.w)
+      : iInfo.w;
 
-    vJitter.assign(fract(iInfo.y.mul(13.73)));
+    vJitter.assign(fract(bladePhase.mul(13.73)));
     const heightFraction = vUv.y;
-    const facing = vec2(cos(iInfo.w), sin(iInfo.w)).toVar();
+    const facing = vec2(cos(facingAngle), sin(facingAngle)).toVar();
     const windDirection = normalize(u.uWindDirection.add(vec2(1e-4, 0.0))).toVar();
 
-    const bladePosition = vec3(iOrigin).toVar();
-    bladePosition.xz.addAssign(facing.mul(positionLocal.x.mul(iInfo.z)));
-    bladePosition.y.addAssign(heightFraction.mul(iInfo.x));
+    const rootPosition = vec3(iOrigin).toVar();
+    const bladePosition = vec3(rootPosition).toVar();
+    if (clumpGeometry) {
+      const clumpForward = vec3(surfaceForward).toVar();
+      const clumpRight = normalize(cross(clumpForward, surfaceUp)).toVar();
+      rootPosition.addAssign(
+        clumpForward.mul(bladeOrigin.x)
+          .add(clumpRight.mul(bladeOrigin.z))
+          .mul(clumpScale),
+      );
+      bladePosition.assign(rootPosition);
+      const bladeFacing = clumpForward.mul(cos(bladeInfo.w))
+        .add(clumpRight.mul(sin(bladeInfo.w)));
+      bladePosition.addAssign(bladeFacing.mul(positionLocal.x.mul(bladeWidth)));
+      bladePosition.addAssign(surfaceUp.mul(heightFraction.mul(bladeHeight)));
+      facing.assign(normalize(bladeFacing.xz.add(vec2(1e-4, 0.0))));
+    } else {
+      bladePosition.xz.addAssign(facing.mul(positionLocal.x.mul(bladeWidth)));
+      bladePosition.y.addAssign(heightFraction.mul(bladeHeight));
+    }
 
     const bendCurve = pow(heightFraction, u.uStyleGrassBendExponent).toVar();
 
@@ -109,51 +168,66 @@ export function createGrassNodeMaterial(settings, vegetationShader = null) {
     const bowDirection = vec2(facing.y.negate(), facing.x);
     const leanDirection = normalize(
       bowDirection.mul(vJitter.sub(0.5))
-        .add(facing.mul(fract(iInfo.y.mul(7.31)).sub(0.5)))
+        .add(facing.mul(fract(bladePhase.mul(7.31)).sub(0.5)))
         .add(vec2(1e-4, 0.0)),
     ).toVar();
-    const leanAmount = fract(iInfo.y.mul(3.17)).mul(0.5).add(0.18).toVar();
-    bladePosition.xz.addAssign(leanDirection.mul(leanAmount).mul(bendCurve).mul(iInfo.x));
-    bladePosition.y.subAssign(leanAmount.mul(leanAmount).mul(0.4).mul(bendCurve).mul(iInfo.x));
+    const leanAmount = fract(bladePhase.mul(3.17)).mul(0.5).add(0.18)
+      .mul(u.uStaticLean).toVar();
+    bladePosition.xz.addAssign(leanDirection.mul(leanAmount).mul(bendCurve).mul(bladeHeight));
+    bladePosition.y.subAssign(leanAmount.mul(leanAmount).mul(0.4).mul(bendCurve).mul(bladeHeight));
 
     // Traveling gust wave.
-    const gustPhase = dot(iOrigin.xz, windDirection).mul(u.uGustFrequency)
+    const gustPhase = dot(rootPosition.xz, windDirection).mul(u.uGustFrequency)
       .sub(u.uTime.mul(u.uGustSpeed));
     const gust = sin(gustPhase).mul(0.5)
       .add(sin(gustPhase.mul(0.43).add(1.7)).mul(0.3))
-      .add(sin(gustPhase.mul(2.3).add(iInfo.y.mul(4.0))).mul(0.2));
+      .add(sin(gustPhase.mul(2.3).add(bladePhase.mul(4.0))).mul(0.2));
     vGust.assign(clamp(gust.mul(0.5).add(0.5), 0.0, 1.0));
 
-    const phase = u.uTime.mul(u.uWindSpeed).add(iInfo.y.mul(6.2831))
-      .add(dot(iOrigin.xz, vec2(0.35, 0.28)));
+    const phase = u.uTime.mul(u.uWindSpeed).add(bladePhase.mul(6.2831))
+      .add(dot(rootPosition.xz, vec2(0.35, 0.28)));
     const flutter = sin(phase).mul(0.5).add(0.5).add(sin(phase.mul(2.33).add(1.7)).mul(0.3));
     const wind = windDirection.mul(
       flutter.mul(0.6).add(vGust.mul(1.1).mul(u.uGustResponse)),
     ).toVar();
     const windAmplitude = u.uWindStrength.mul(u.uWindResponse).toVar();
-    bladePosition.xz.addAssign(wind.mul(windAmplitude).mul(bendCurve).mul(iInfo.x));
+    bladePosition.xz.addAssign(wind.mul(windAmplitude).mul(bendCurve).mul(bladeHeight));
 
     // Character push.
     const fromPush = bladePosition.xz.sub(u.uPushPosition.xz).toVar();
     const pushDistance = length(fromPush);
     const push = smoothstep(0.0, u.uPushRadius, pushDistance).oneMinus()
-      .mul(step(abs(iOrigin.y.sub(u.uPushPosition.y)), 1.8));
+      .mul(step(abs(rootPosition.y.sub(u.uPushPosition.y)), 1.8));
     bladePosition.xz.addAssign(
       normalize(fromPush.add(vec2(1e-4, 0.0))).mul(push).mul(0.42)
-        .mul(bendCurve).mul(iInfo.x).mul(u.uStyleGrassInteractionResponse),
+        .mul(bendCurve).mul(bladeHeight).mul(u.uStyleGrassInteractionResponse),
     );
     bladePosition.y.subAssign(
-      push.mul(0.14).mul(bendCurve).mul(iInfo.x).mul(u.uStyleGrassInteractionResponse),
+      push.mul(0.14).mul(bendCurve).mul(bladeHeight).mul(u.uStyleGrassInteractionResponse),
     );
 
     // Shared field normal, tilted by the current bend.
     const tilt = wind.mul(windAmplitude).add(leanDirection.mul(leanAmount).mul(0.35)).mul(heightFraction);
-    vNormal.assign(normalize(vec3(tilt.x.mul(1.4), 1.0, tilt.y.mul(1.4))));
+    vNormal.assign(normalize(
+      surfaceUp.add(vec3(tilt.x.mul(1.4), 0.0, tilt.y.mul(1.4))),
+    ));
 
     // Distance fade to a degenerate point.
-    const fadeDistance = distance(modelWorldMatrix.mul(vec4(iOrigin, 1.0)).xz, cameraPosition.xz);
+    const originWorld = modelWorldMatrix.mul(vec4(rootPosition, 1.0)).toVar();
+    const fadeDistance = distance(originWorld.xz, cameraPosition.xz);
     const fade = smoothstep(u.uFadeStart, u.uFadeEnd, fadeDistance).oneMinus();
-    bladePosition.assign(mix(iOrigin, bladePosition, fade));
+    bladePosition.assign(mix(rootPosition, bladePosition, fade));
+
+    // Ground-field adoption: one sample per vertex at the blade ROOT, so the
+    // whole blade carries the color of the terrain it grows from (the
+    // reference pack's RVT-colored grass). Alpha is field coverage — 0 off
+    // the terrain or before the pass runs, leaving the palette untouched.
+    // Small isolated lab previews do not run the landscape ground-field pass.
+    // Omitting the texture nodes entirely in that case avoids compiling an
+    // unused textureDimensions binding on WebGPU.
+    vGroundColor.assign(
+      groundField ? sampleGroundColor(originWorld.xyz) : vec4(0.0),
+    );
 
     const worldPosition = modelWorldMatrix.mul(vec4(bladePosition, 1.0));
     vWorldPosition.assign(worldPosition.xyz);
@@ -161,17 +235,59 @@ export function createGrassNodeMaterial(settings, vegetationShader = null) {
   })();
 
   material.fragmentNode = Fn(() => {
-    // Rounded taper silhouette.
-    const taper = pow(vUv.y, 1.6).mul(0.96).oneMinus();
-    const halfWidth = taper.mul(0.5);
-    Discard(abs(vUv.x.sub(0.5)).greaterThan(halfWidth));
+    if (!clumpGeometry) {
+      // The legacy single-blade geometry is a rectangle, so trim it into a
+      // rounded taper. Clump geometry carries a real five-triangle tapered
+      // silhouette and does not pay this discarded-fragment cost.
+      const taper = pow(vUv.y, 1.6).mul(0.96).oneMinus();
+      const halfWidth = taper.mul(0.5);
+      Discard(abs(vUv.x.sub(0.5)).greaterThan(halfWidth));
+    }
 
     const tipMix = smoothstep(
       u.uStyleGrassTipGradientStart,
       u.uStyleGrassTipGradientEnd,
       vUv.y.mul(vJitter.mul(0.3).add(0.85)),
     ).toVar();
-    const color = mix(u.uBaseColor, u.uTipColor, tipMix).toVar();
+    const sourceColor = mix(u.uBaseColor, u.uTipColor, tipMix).toVar();
+    const styleTipRaw = u.uStyleGrassBaseColor.add(u.uStyleGrassTipBrightness);
+    const styleTipLuminance = dot(styleTipRaw, vec3(0.3, 0.59, 0.11));
+    const styleTip = shiftNormalizedHue(
+      mix(styleTipRaw, vec3(styleTipLuminance), u.uStyleGrassTipDesaturation),
+      u.uStyleGrassTipHueShift,
+    );
+    const styleColor = mix(u.uStyleGrassBaseColor, styleTip, tipMix);
+    const color = mix(
+      sourceColor,
+      styleColor,
+      u.uStyleGrassStyleColorStrength,
+    ).toVar();
+    // Ground adoption follows MI_Grass rather than simply tinting the roots:
+    // the sampled landscape albedo becomes the blade's root palette and the
+    // lighter/saturated tip is derived from that same albedo. This keeps the
+    // entire silhouette coherent with grass, dirt, and path colors beneath
+    // it instead of revealing a bright authored tip over a terrain-colored
+    // root. uGroundAdoptHeight controls how long the exact ground color is
+    // retained before the ground-derived tip treatment takes over.
+    If(u.uGroundAdoptStrength.greaterThan(0.0), () => {
+      const groundRoot = vGroundColor.rgb.mul(u.uGroundAdoptTint).toVar();
+      // Brighten multiplicatively so a green ground remains green. Additive
+      // RGB lift desaturates and can rotate green toward yellow at the tips.
+      const groundTipScale = clamp(
+        u.uStyleGrassTipBrightness.mul(0.9).add(1.0), 0.1, 2.0,
+      );
+      const groundTipRaw = groundRoot.mul(groundTipScale);
+      const groundTipLuminance = dot(groundTipRaw, vec3(0.3, 0.59, 0.11));
+      const groundTip = shiftNormalizedHue(
+        mix(groundTipRaw, vec3(groundTipLuminance), u.uStyleGrassTipDesaturation),
+        u.uStyleGrassTipHueShift,
+      );
+      const groundDriven = mix(groundRoot, groundTip, tipMix).toVar();
+      const exactGround = smoothstep(u.uGroundAdoptHeight, 0.0, vUv.y);
+      groundDriven.assign(mix(groundDriven, groundRoot, exactGround));
+      const adopt = clamp(u.uGroundAdoptStrength.mul(vGroundColor.a), 0.0, 1.0);
+      color.assign(mix(color, groundDriven, adopt));
+    });
     color.mulAssign(vJitter.sub(0.5).mul(u.uStyleGrassColorVariationStrength).add(1.0));
 
     // Dense-field AO toward the roots.
@@ -183,10 +299,14 @@ export function createGrassNodeMaterial(settings, vegetationShader = null) {
 
     const normal = normalize(vNormal);
     const sunDirection = normalize(u.uSunDirection);
-    const cloudShadow = stylizedCloudShadow(
+    const proceduralCloudShadow = stylizedCloudShadow(
       vWorldPosition.xz, u.uTime,
       u.uCloudShadowStrength, u.uCloudShadowCoverage, u.uCloudShadowScale, u.uCloudShadowVelocity,
     );
+    const cloudShadow = sampleEnvironmentCloudShadow(
+      vWorldPosition,
+      proceduralCloudShadow,
+    ).toVar();
     const sceneShadow = mix(1.0, sampleEnvironmentSunShadow(vWorldPosition), u.uShadowStrength);
     const shaded = shadeVegetationSurface({
       baseColor: color,
@@ -207,12 +327,57 @@ export function createGrassNodeMaterial(settings, vegetationShader = null) {
       worldPosition: vWorldPosition,
     });
 
+    const groundCoverage = clamp(
+      u.uGroundAdoptStrength.mul(vGroundColor.a), 0.0, 1.0,
+    );
+    // The field now contains the ground's visible sun/sky/shared-shadow
+    // result. Do not light the adopted part a second time: that would make
+    // grass ignore or exaggerate the cast-shadow color beneath it.
+    shaded.color.assign(mix(shaded.color, color, groundCoverage));
+
     const sheen = smoothstep(u.uStyleGrassGustSheenThreshold, 1.0, vGust).mul(tipMix);
     shaded.color.addAssign(
       u.uSunColor.mul(sheen).mul(u.uStyleGrassGustSheenStrength).mul(shaded.band),
     );
+    const viewDirection = normalize(cameraPosition.sub(vWorldPosition));
+    const halfVector = normalize(sunDirection.add(viewDirection));
+    const highlightPower = mix(96.0, 8.0, u.uStyleGrassRoughness);
+    const highlight = pow(
+      clamp(dot(normal, halfVector), 0, 1),
+      highlightPower,
+    ).mul(sceneShadow).mul(u.uStyleGrassSpecularStrength);
+    shaded.color.addAssign(u.uSunColor.mul(highlight));
+    shaded.color.addAssign(color.mul(u.uStyleGrassEmissiveStrength));
+
+    // Texture-free watercolor layering. Two low-frequency bands create
+    // irregular pigment lift along each stroke; seeded opacity lets dense
+    // clumps read as overlapping painted blades instead of one opaque cutout.
+    // Neutral defaults leave other grass presets unchanged.
+    const washBand = sin(
+      vUv.y.mul(10.7)
+        .add(vJitter.mul(6.2831))
+        .add(dot(vWorldPosition.xz, vec2(0.73, 0.41))),
+    ).mul(0.5).add(0.5);
+    const washGrain = sin(
+      vUv.y.mul(23.1)
+        .sub(vJitter.mul(4.7))
+        .add(dot(vWorldPosition.xz, vec2(-0.29, 0.83))),
+    ).mul(0.5).add(0.5);
+    const wash = washBand.mul(0.65).add(washGrain.mul(0.35));
+    // Watercolor lift layers over the lit, ground-adopted blade. Returning to
+    // flat ground albedo here would undo the shared scene-light response a
+    // second time.
+    const washTarget = shaded.color.mul(1.18).add(
+      u.uSunColor.mul(0.035).mul(groundCoverage.oneMinus()),
+    );
+    shaded.color.assign(mix(shaded.color, washTarget, u.uWashLift));
+    const strokeAlpha = mix(
+      u.uWashOpacity.mul(0.86),
+      u.uWashOpacity,
+      wash.mul(0.65).add(vJitter.mul(0.35)),
+    );
 
-    return vec4(shaded.color, 1.0);
+    return vec4(shaded.color, strokeAlpha);
   })();
 
   material.uniforms = u;

package/src/shaders-tsl/post-composite.js

@@ -56,6 +56,7 @@ import {
   distance,
   dot,
   float,
+  exp,
   floor,
   fract,
   Fn,
@@ -64,6 +65,7 @@ import {
   max,
   min,
   mix,
+  pow,
   positionLocal,
   screenCoordinate,
   sign,
@@ -79,6 +81,8 @@ import {
 } from 'three/tsl';
 import { NodeMaterial } from 'three/webgpu';
 
+import { environmentStateUniformNodes } from './chunks/environment-state.js';
+
 // Shared 1x1 placeholder so every optional texture uniform (tLut,
 // tCharacterMask, tBloom, and the not-yet-wired tDepth/tDiffuse at
 // construction time) always has a real bound texture. Classic tolerates a
@@ -245,6 +249,21 @@ export function createPostCompositeNodeMaterial() {
     depthCueFar: uniform(24.0),
     depthCueNear: uniform(1.0),
     depthCueStrength: uniform(0.0),
+    // Two-layer stylized atmosphere (the reference sky system's signature
+    // fog): a scene-color mix fog with height falloff + an additive glow fog
+    // centered on the sun/moon. Colors and glow parameters come from the
+    // shared environment state so the day cycle drives them scene-wide.
+    useAtmosphere: uniform(0.0),
+    atmosphereStrength: uniform(0.55),
+    atmosphereNear: uniform(60.0),
+    atmosphereFar: uniform(900.0),
+    atmosphereHeightFalloff: uniform(0.012),
+    atmosphereBaseHeight: uniform(0.0),
+    atmosphereGlowStrength: uniform(1.0),
+    atmosphereInverseViewProjection: uniform(new THREE.Matrix4()),
+    atmosphereViewProjection: uniform(new THREE.Matrix4()),
+    atmosphereCameraPosition: uniform(new THREE.Vector3()),
+    atmosphereAspect: uniform(16 / 9),
     exposure: uniform(1.0),
     tLut: texture(fallbackPostTexture()),
     lutSize: uniform(0.0),
@@ -298,6 +317,23 @@ export function createPostCompositeNodeMaterial() {
     return viewZToOrthographicDepth(viewZ, u.cameraNear, u.cameraFar);
   });
 
+  // View distance in METERS — depthCue/atmosphere parameters are authored in
+  // world units (depthCueFar: 1250 means 1250 m), so comparing them against
+  // the [0,1] normalized depth above silently disabled the whole stage.
+  const readViewDistance = Fn(([sampleUv]) => {
+    const fragCoordZ = u.tDepth.sample(rtUv(sampleUv)).level(0).x;
+    return perspectiveDepthToViewZ(fragCoordZ, u.cameraNear, u.cameraFar).negate();
+  });
+
+  // World-position reconstruction from the depth prepass (same NDC math the
+  // motion-blur stage uses).
+  const reconstructWorldPosition = Fn(([sampleUv]) => {
+    const fragDepth = u.tDepth.sample(rtUv(sampleUv)).level(0).x;
+    const ndc = vec4(sampleUv.mul(2.0).sub(1.0), fragDepth.mul(2.0).sub(1.0), 1.0);
+    const world = u.atmosphereInverseViewProjection.mul(ndc).toVar();
+    return world.xyz.div(world.w);
+  });
+
   const sampleLutSlice = Fn(([color, slice]) => {
     const uCoord = slice.mul(u.lutSize).add(0.5).add(color.r.mul(u.lutSize.sub(1.0))).div(u.lutSize.mul(u.lutSize));
     const vCoord = float(0.5).add(color.g.mul(u.lutSize.sub(1.0))).div(u.lutSize);
@@ -401,11 +437,56 @@ export function createPostCompositeNodeMaterial() {
     });
 
     If(u.useDepthCue.greaterThan(0.5), () => {
-      const depth = readLinearDepth(vUv);
-      const cue = smoothstep(u.depthCueNear, u.depthCueFar, depth).mul(u.depthCueStrength);
+      const viewDistance = readViewDistance(vUv);
+      const cue = smoothstep(u.depthCueNear, u.depthCueFar, viewDistance).mul(u.depthCueStrength);
       color.assign(mix(color, u.depthCueColor, cue));
     });
 
+    If(u.useAtmosphere.greaterThan(0.5), () => {
+      const env = environmentStateUniformNodes;
+      const viewDistance = readViewDistance(vUv).toVar();
+      const worldPosition = reconstructWorldPosition(vUv).toVar();
+
+      // Layer 1 — atmospheric mix fog: fades the world toward the state fog
+      // color with distance, thinning with altitude so peaks stay clear.
+      const heightAbove = max(worldPosition.y.sub(u.atmosphereBaseHeight), 0.0);
+      const heightWeight = exp(heightAbove.mul(u.atmosphereHeightFalloff).negate());
+      const fogAmount = smoothstep(u.atmosphereNear, max(u.atmosphereFar, u.atmosphereNear.add(1.0)), viewDistance)
+        .mul(clamp(u.atmosphereStrength, 0.0, 1.0))
+        .mul(heightWeight)
+        .toVar();
+      color.assign(mix(color, env.atmosphereFogColor, clamp(fogAmount, 0.0, 0.97)));
+
+      // Layer 2 — additive celestial glow fog: a depth-aware halo around the
+      // screen-projected sun/moon. This is what builds the multi-colored
+      // sunrise/sunset gradients over the far landscape.
+      const glowTotal = env.atmosphereGlowIntensity.mul(u.atmosphereGlowStrength);
+      If(glowTotal.greaterThan(0.001), () => {
+        const addGlow = (direction, bodyColor, visibility) => {
+          const clip = u.atmosphereViewProjection.mul(
+            vec4(u.atmosphereCameraPosition.add(direction.mul(1000.0)), 1.0),
+          ).toVar();
+          If(clip.w.greaterThan(0.0), () => {
+            const bodyUv = clip.xy.div(clip.w).mul(0.5).add(0.5);
+            const offset = vUv.sub(bodyUv).mul(vec2(u.atmosphereAspect, 1.0));
+            const halo = pow(
+              clamp(length(offset).div(max(env.atmosphereGlowSpread, 0.01)).oneMinus(), 0.0, 1.0),
+              2.2,
+            );
+            // Far pixels only: the glow is fog lit by the body, not a lens
+            // flare — nearby geometry keeps its own color.
+            const depthWeight = smoothstep(u.atmosphereNear.mul(0.4), u.atmosphereFar.mul(0.8), viewDistance);
+            color.addAssign(
+              env.atmosphereGlowColor.mul(bodyColor)
+                .mul(halo).mul(depthWeight).mul(glowTotal).mul(visibility),
+            );
+          });
+        };
+        addGlow(env.sunDirection, vec3(1.0), env.sunVisibility);
+        addGlow(env.moonDirection, env.moonColor, env.moonVisibility.mul(env.moonIntensity));
+      });
+    });
+
     If(u.useColorGrade.greaterThan(0.5), () => {
       color.mulAssign(u.exposure);
       color.assign(color.sub(0.5).mul(u.contrast).add(0.5));