@zephyr3d/scene 0.9.26 → 0.10.0

package/dist/shaders/atmosphere.js

@@ -1,6 +1,6 @@
 import { drawFullscreenQuad } from '../render/fullscreenquad.js';
 import { fetchSampler } from '../utility/misc.js';
-import { Matrix4x4, Vector3, Vector4 } from '@zephyr3d/base';
+import { Vector3, Matrix4x4, Vector4 } from '@zephyr3d/base';
 import { uniformSphereSamples } from '../values.js';
 import { getDevice } from '../app/api.js';
 
@@ -17,7 +17,11 @@ const OZONE_ABSORPTION_SIGMA = [
     1.881,
     0.085
 ];
-/** @internal */ const CAMERA_POS_Y = 1;
+/**
+ * Lowest observer altitude above the ground, in meters. Keeps the sky visible
+ * when the camera is at or below the virtual planet surface.
+ * @internal
+ */ const MIN_OBSERVER_ALTITUDE = 5;
 /** @internal */ function getDefaultAtmosphereParams() {
     return {
         plantRadius: 6360000,
@@ -27,12 +31,18 @@ const OZONE_ABSORPTION_SIGMA = [
         mieAnstropy: 0.8,
         ozoneCenter: 25000,
         ozoneWidth: 15000,
-        apDistance: 4000,
+        groundAlbedo: new Vector3(0.401978, 0.401978, 0.401978),
+        apDistance: 96000,
+        apViewDistanceScale: 1,
+        apStartDepth: 100,
         cameraWorldMatrix: Matrix4x4.identity(),
         lightDir: new Vector3(1, 0, 0),
         lightColor: new Vector4(1, 1, 1, 10),
         cameraAspect: 1,
-        cameraHeightScale: 1
+        cameraTanHalfFovy: 1,
+        cameraHeightScale: 1,
+        observerAltitude: MIN_OBSERVER_ALTITUDE,
+        skyViewReferential: Matrix4x4.identity()
     };
 }
 const defaultAtmosphereParams = getDefaultAtmosphereParams();
@@ -53,7 +63,9 @@ function checkParams(other) {
             ...defaultAtmosphereParams,
             lightDir: new Vector3(defaultAtmosphereParams.lightDir),
             lightColor: new Vector4(defaultAtmosphereParams.lightColor),
-            cameraWorldMatrix: new Matrix4x4(defaultAtmosphereParams.cameraWorldMatrix)
+            groundAlbedo: new Vector3(defaultAtmosphereParams.groundAlbedo),
+            cameraWorldMatrix: new Matrix4x4(defaultAtmosphereParams.cameraWorldMatrix),
+            skyViewReferential: new Matrix4x4(defaultAtmosphereParams.skyViewReferential)
         };
         result.transmittance = true;
         result.multiScattering = true;
@@ -61,9 +73,13 @@ function checkParams(other) {
         result.aerialPerspective = true;
     } else {
         result.transmittance = currentAtmosphereParams.plantRadius !== other.plantRadius || currentAtmosphereParams.atmosphereHeight !== other.atmosphereHeight || currentAtmosphereParams.rayleighScatteringHeight !== other.rayleighScatteringHeight || currentAtmosphereParams.mieScatteringHeight !== other.mieScatteringHeight || currentAtmosphereParams.ozoneCenter !== other.ozoneCenter || currentAtmosphereParams.ozoneWidth !== other.ozoneWidth;
-        result.multiScattering = result.transmittance || currentAtmosphereParams.mieAnstropy !== other.mieAnstropy;
-        result.skyView = result.transmittance || result.multiScattering || currentAtmosphereParams.cameraHeightScale !== other.cameraHeightScale || !currentAtmosphereParams.lightDir.equalsTo(other.lightDir) || !currentAtmosphereParams.lightColor.equalsTo(other.lightColor) || !currentAtmosphereParams.cameraWorldMatrix.equalsTo(other.cameraWorldMatrix);
-        result.aerialPerspective = result.transmittance || result.multiScattering || result.skyView || currentAtmosphereParams.apDistance !== other.apDistance || currentAtmosphereParams.cameraAspect !== other.cameraAspect;
+        // The multi-scattering LUT uses an isotropic phase and a unit light, so it depends on the
+        // medium only (see integralMultiScattering).
+        result.multiScattering = result.transmittance || !currentAtmosphereParams.groundAlbedo.equalsTo(other.groundAlbedo);
+        // The sky view LUT is a full lat-long sphere around the observer in its local frame: the camera
+        // orientation does not affect it, its altitude and the local light direction do.
+        result.skyView = result.transmittance || result.multiScattering || currentAtmosphereParams.mieAnstropy !== other.mieAnstropy || currentAtmosphereParams.observerAltitude !== other.observerAltitude || !currentAtmosphereParams.lightDir.equalsTo(other.lightDir) || !currentAtmosphereParams.lightColor.equalsTo(other.lightColor);
+        result.aerialPerspective = result.transmittance || result.multiScattering || result.skyView || currentAtmosphereParams.apDistance !== other.apDistance || currentAtmosphereParams.apViewDistanceScale !== other.apViewDistanceScale || currentAtmosphereParams.apStartDepth !== other.apStartDepth || currentAtmosphereParams.cameraAspect !== other.cameraAspect || currentAtmosphereParams.cameraTanHalfFovy !== other.cameraTanHalfFovy || !currentAtmosphereParams.cameraWorldMatrix.equalsTo(other.cameraWorldMatrix);
     }
     if (result.transmittance) {
         currentAtmosphereParams.plantRadius = other.plantRadius;
@@ -74,17 +90,21 @@ function checkParams(other) {
         currentAtmosphereParams.ozoneWidth = other.ozoneWidth;
     }
     if (result.multiScattering) {
-        currentAtmosphereParams.mieAnstropy = other.mieAnstropy;
+        currentAtmosphereParams.groundAlbedo.set(other.groundAlbedo);
     }
     if (result.skyView) {
-        currentAtmosphereParams.cameraHeightScale = other.cameraHeightScale;
+        currentAtmosphereParams.mieAnstropy = other.mieAnstropy;
+        currentAtmosphereParams.observerAltitude = other.observerAltitude;
         currentAtmosphereParams.lightDir.set(other.lightDir);
         currentAtmosphereParams.lightColor.set(other.lightColor);
-        currentAtmosphereParams.cameraWorldMatrix.set(other.cameraWorldMatrix);
     }
     if (result.aerialPerspective) {
         currentAtmosphereParams.apDistance = other.apDistance;
+        currentAtmosphereParams.apViewDistanceScale = other.apViewDistanceScale;
+        currentAtmosphereParams.apStartDepth = other.apStartDepth;
         currentAtmosphereParams.cameraAspect = other.cameraAspect;
+        currentAtmosphereParams.cameraTanHalfFovy = other.cameraTanHalfFovy;
+        currentAtmosphereParams.cameraWorldMatrix.set(other.cameraWorldMatrix);
     }
     return result;
 }
@@ -99,20 +119,44 @@ function checkParams(other) {
     ], function() {
         this.$l.OS = pb.length(pb.sub(this.center, this.rayStart));
         this.$l.SH = pb.dot(pb.sub(this.center, this.rayStart), this.rayDir);
-        this.$l.OH = pb.sqrt(pb.sub(pb.mul(this.OS, this.OS), pb.mul(this.SH, this.SH)));
-        this.$l.PH = pb.sqrt(pb.sub(pb.mul(this.radius, this.radius), pb.mul(this.OH, this.OH)));
+        this.$l.OH = pb.sqrt(pb.max(pb.sub(pb.mul(this.OS, this.OS), pb.mul(this.SH, this.SH)), 0));
         this.$if(pb.greaterThan(this.OH, this.radius), function() {
             this.$return(pb.float(-1));
         });
+        this.$l.PH = pb.sqrt(pb.max(pb.sub(pb.mul(this.radius, this.radius), pb.mul(this.OH, this.OH)), 0));
         this.$l.t1 = pb.sub(this.SH, this.PH);
         this.$l.t2 = pb.add(this.SH, this.PH);
         this.$return(this.$choice(pb.lessThan(this.t1, 0), this.t2, this.t1));
     });
     return scope[funcName](f3Center, fRadius, f3RayStart, f3RayDir);
 }
-/** @internal */ function transmittanceToSky(scope, stParams, f3Pos, f3Dir, texLut) {
+/**
+ * Far intersection of a ray with a sphere, -1 when missed. For a start inside the sphere this is
+ * where the ray leaves it: unlike {@link rayIntersectSphere} it cannot mistake a near root that float
+ * error nudged above 0 for the exit in IntegrateSingleScatteredLuminance).
+ * @internal
+ */ function rayIntersectSphereFar(scope, fRadius, f3RayStart, f3RayDir) {
     const pb = scope.$builder;
-    const funcName = 'z_transmittanceToSky';
+    const funcName = 'z_rayIntersectSphereFar';
+    pb.func(funcName, [
+        pb.float('radius'),
+        pb.vec3('rayStart'),
+        pb.vec3('rayDir')
+    ], function() {
+        this.$l.OS = pb.length(this.rayStart);
+        this.$l.SH = pb.neg(pb.dot(this.rayStart, this.rayDir));
+        this.$l.OH = pb.sqrt(pb.max(pb.sub(pb.mul(this.OS, this.OS), pb.mul(this.SH, this.SH)), 0));
+        this.$if(pb.greaterThan(this.OH, this.radius), function() {
+            this.$return(pb.float(-1));
+        });
+        this.$l.PH = pb.sqrt(pb.max(pb.sub(pb.mul(this.radius, this.radius), pb.mul(this.OH, this.OH)), 0));
+        this.$return(pb.add(this.SH, this.PH));
+    });
+    return scope[funcName](fRadius, f3RayStart, f3RayDir);
+}
+/** @internal */ function transmittanceToSky(scope, stParams, f3Pos, f3Dir, texLut, planetShadow = true) {
+    const pb = scope.$builder;
+    const funcName = planetShadow ? 'z_transmittanceToSky' : 'z_transmittanceToSkyNoShadow';
     const Params = getAtmosphereParamsStruct(pb);
     pb.func(funcName, [
         Params('params'),
@@ -122,8 +166,27 @@ function checkParams(other) {
         this.$l.bottomRadius = this.params.plantRadius;
         this.$l.topRadius = pb.add(this.params.plantRadius, this.params.atmosphereHeight);
         this.$l.upVector = pb.normalize(this.p);
+        // Planet shadow. The LUT only parameterizes zenith..horizon: a direction below the horizon
+        // would clamp to the horizon texel and keep the sun lit after it has set. Test the planet
+        // analytically instead, from a point lifted 1m to stay clear of float error on the sphere
+        if (planetShadow) {
+            this.$l.tPlanet = rayIntersectSphere(this, pb.vec3(0), this.bottomRadius, pb.add(this.p, this.upVector), this.dir);
+            this.$if(pb.greaterThan(this.tPlanet, 0), function() {
+                this.$return(pb.vec3(0));
+            });
+        }
+        // Above the atmosphere the LUT has no entry: look it up from where the ray enters it.
+        this.$l.pos = this.p;
+        this.$if(pb.greaterThan(pb.length(this.p), this.topRadius), function() {
+            this.$l.tTop = rayIntersectSphere(this, pb.vec3(0), this.topRadius, this.p, this.dir);
+            this.$if(pb.lessThan(this.tTop, 0), function() {
+                this.$return(pb.vec3(1));
+            });
+            this.pos = pb.add(this.p, pb.mul(this.dir, this.tTop));
+            this.upVector = pb.normalize(this.pos);
+        });
         this.$l.cosTheta = pb.dot(this.upVector, this.dir);
-        this.$l.r = pb.length(this.p);
+        this.$l.r = pb.min(pb.length(this.pos), this.topRadius);
         this.$l.uv = transmittanceLutToUV(this, this.bottomRadius, this.topRadius, this.cosTheta, this.r);
         this.$return(pb.textureSampleLevel(texLut, this.uv, 0).rgb);
     });
@@ -137,7 +200,7 @@ function checkParams(other) {
         pb.float('h')
     ], function() {
         this.$l.sigma = pb.mul(pb.vec3(RAYLEIGH_SIGMA[0], RAYLEIGH_SIGMA[1], RAYLEIGH_SIGMA[2]), 1e-6);
-        this.$l.rho_h = pb.exp(pb.neg(pb.div(this.h, this.rayleighScatteringHeight)));
+        this.$l.rho_h = pb.exp(pb.neg(pb.div(pb.max(this.h, 0), this.rayleighScatteringHeight)));
         this.$return(pb.mul(this.sigma, this.rho_h));
     });
     return scope[funcName](fRayleighScatteringHeight, fH);
@@ -160,7 +223,7 @@ function checkParams(other) {
         pb.float('h')
     ], function() {
         this.$l.sigma = pb.mul(pb.vec3(MIE_SIGMA), 1e-6);
-        this.$l.rho_h = pb.exp(pb.neg(pb.div(this.h, this.mieScatteringHeight)));
+        this.$l.rho_h = pb.exp(pb.neg(pb.div(pb.max(this.h, 0), this.mieScatteringHeight)));
         this.$return(pb.mul(this.sigma, this.rho_h));
     });
     return scope[funcName](fMieScatteringHeight, fH);
@@ -173,11 +236,8 @@ function checkParams(other) {
         pb.float('cosTheta')
     ], function() {
         this.$l.g2 = pb.mul(this.g, this.g);
-        this.$l.a = 3 / (8 * Math.PI);
-        this.$l.b = pb.div(pb.sub(1, this.g2), pb.add(2, this.g2));
-        this.$l.c = pb.add(1, pb.mul(this.cosTheta, this.cosTheta));
-        this.$l.d = pb.pow(pb.sub(pb.add(1, this.g2), pb.mul(this.g, this.cosTheta, 2)), 1.5);
-        this.$return(pb.div(pb.mul(this.a, this.b, this.c), this.d));
+        this.$l.denom = pb.sub(pb.add(1, this.g2), pb.mul(this.g, this.cosTheta, 2));
+        this.$return(pb.div(pb.sub(1, this.g2), pb.mul(4 * Math.PI, this.denom, pb.sqrt(this.denom))));
     });
     return scope[funcName](fMieAnstropy, fCosTheta);
 }
@@ -189,7 +249,7 @@ function checkParams(other) {
         pb.float('h')
     ], function() {
         this.$l.sigma = pb.mul(pb.vec3(MIE_ABSORPTION_SIGMA), 1e-6);
-        this.$l.rho_h = pb.exp(pb.neg(pb.div(this.h, this.mieScatteringHeight)));
+        this.$l.rho_h = pb.exp(pb.neg(pb.div(pb.max(this.h, 0), this.mieScatteringHeight)));
         this.$return(pb.mul(this.sigma, this.rho_h));
     });
     return scope[funcName](fMieScatteringHeight, fH);
@@ -208,10 +268,40 @@ function checkParams(other) {
     });
     return scope[funcName](fOzoneLevelCenterHeight, fOzoneLevelWidth, fH);
 }
-/** @internal */ function getSkyView(scope, stParams, f3EyePos, f3ViewDir, fMaxDis, texTransmittanceLut, texMultiScatteringLut, withGround = true) {
+/**
+ * Sun light reflected by the virtual planet ground at `groundPos`, per unit illuminance: a Lambertian
+ * surface of albedo `groundAlbedo` lit through the atmosphere. Multiply by the throughput from the observer.
+ * @internal
+ */ function groundBounce(scope, stParams, f3GroundPos, f3LightDir, texTransmittanceLut) {
+    const pb = scope.$builder;
+    const Params = getAtmosphereParamsStruct(pb);
+    const funcName = 'z_groundBounce';
+    pb.func(funcName, [
+        Params('params'),
+        pb.vec3('groundPos'),
+        pb.vec3('lightDir')
+    ], function() {
+        this.$l.up = pb.normalize(this.groundPos);
+        this.$l.NdotL = pb.clamp(pb.dot(this.up, this.lightDir), 0, 1);
+        this.$l.transmittanceToLight = transmittanceToSky(this, this.params, this.groundPos, this.lightDir, texTransmittanceLut, false);
+        this.$return(pb.mul(this.transmittanceToLight, this.params.groundAlbedo, this.NdotL, 1 / Math.PI));
+    });
+    return scope[funcName](stParams, f3GroundPos, f3LightDir);
+}
+/**
+ * @internal
+ *
+ * Single scattering along a view ray, plus multiple scattering from the LUT.
+ *
+ * @param withGround - Stop the ray at the planet ground.
+ * @param groundLit - When the ray ends on the ground (not cut short by `maxDis`), add the sun light
+ *   the ground reflects. Implies `withGround`.
+ * @param apScale - Scale the integrated segment lengths by `params.apViewDistanceScale`, for the
+ *   aerial perspective. The medium is still sampled at the true positions.
+ */ function getSkyView(scope, stParams, f3EyePos, f3ViewDir, fMaxDis, texTransmittanceLut, texMultiScatteringLut, withGround = true, groundLit = false, apScale = false) {
     const pb = scope.$builder;
     const Params = getAtmosphereParamsStruct(pb);
-    const funcName = 'z_getSkyView';
+    const funcName = `z_getSkyView${withGround ? '_G' : ''}${groundLit ? '_L' : ''}${apScale ? '_AP' : ''}`;
     pb.func(funcName, [
         Params('params'),
         pb.vec3('eyePos'),
@@ -220,37 +310,64 @@ function checkParams(other) {
     ], function() {
         const N_SAMPLE = 32;
         this.$l.color = pb.vec3(0);
-        this.$l.dis = rayIntersectSphere(this, pb.vec3(0), pb.add(this.params.plantRadius, this.params.atmosphereHeight), this.eyePos, this.viewDir);
+        this.$l.topRadius = pb.add(this.params.plantRadius, this.params.atmosphereHeight);
+        this.$l.eye = this.eyePos;
+        this.$l.maxDistance = this.maxDis;
+        this.$l.dis = rayIntersectSphere(this, pb.vec3(0), this.topRadius, this.eye, this.viewDir);
         this.$if(pb.lessThan(this.dis, 0), function() {
-            this.$return(pb.vec3(0));
+            this.$return(pb.vec4(0, 0, 0, 1));
+        });
+        this.$if(pb.greaterThan(pb.length(this.eye), this.topRadius), function() {
+            this.$l.tEnter = this.dis;
+            this.eye = pb.add(this.eye, pb.mul(this.viewDir, this.tEnter));
+            this.eye = pb.sub(this.eye, pb.normalize(this.eye));
+            this.$if(pb.greaterThanEqual(this.maxDistance, 0), function() {
+                this.maxDistance = pb.sub(this.maxDistance, this.tEnter);
+                this.$if(pb.lessThanEqual(this.maxDistance, 0), function() {
+                    this.$return(pb.vec4(0, 0, 0, 1));
+                });
+            });
+            this.dis = pb.max(rayIntersectSphereFar(this, this.topRadius, this.eye, this.viewDir), 0);
         });
-        if (withGround) {
-            this.$l.d = rayIntersectSphere(this, pb.vec3(0), this.params.plantRadius, this.eyePos, this.viewDir);
-            this.$if(pb.greaterThan(this.d, 0), function() {
-                this.dis = pb.min(this.dis, this.d);
+        this.$l.hitGround = pb.bool(false);
+        if (withGround || groundLit) {
+            this.$l.d = rayIntersectSphere(this, pb.vec3(0), this.params.plantRadius, this.eye, this.viewDir);
+            this.$if(pb.and(pb.greaterThan(this.d, 0), pb.lessThanEqual(this.d, this.dis)), function() {
+                this.dis = this.d;
+                this.hitGround = pb.bool(true);
             });
         }
-        this.$if(pb.greaterThanEqual(this.maxDis, 0), function() {
-            this.dis = pb.min(this.dis, this.maxDis);
+        this.$if(pb.and(pb.greaterThanEqual(this.maxDistance, 0), pb.lessThan(this.maxDistance, this.dis)), function() {
+            this.dis = this.maxDistance;
+            this.hitGround = pb.bool(false);
         });
         this.$l.ds = pb.div(this.dis, N_SAMPLE);
-        this.$l.p = pb.add(this.eyePos, pb.mul(this.viewDir, this.ds, 0.5));
+        this.$l.p = pb.add(this.eye, pb.mul(this.viewDir, this.ds, 0.5));
         this.$l.sunLuminance = pb.mul(this.params.lightColor.rgb, this.params.lightColor.a);
-        this.$l.opticalDepth = pb.vec3(0);
+        this.$l.throughput = pb.vec3(1);
         this.$for(pb.int('i'), 0, N_SAMPLE, function() {
             this.$l.h = pb.sub(pb.length(this.p), this.params.plantRadius);
             this.$l.extinction = pb.add(rayleighCoefficient(this, this.params.rayleighScatteringHeight, this.h), mieCoefficient(this, this.params.mieScatteringHeight, this.h), ozoneAbsorption(this, this.params.ozoneCenter, this.params.ozoneWidth, this.h), mieAbsorption(this, this.params.mieScatteringHeight, this.h));
-            this.opticalDepth = pb.add(this.opticalDepth, pb.mul(this.extinction, this.ds));
+            this.$l.sampleTransmittance = pb.exp(pb.neg(pb.mul(this.extinction, this.ds, apScale ? this.params.apViewDistanceScale : 1)));
             this.$l.t1 = transmittanceToSky(this, this.params, this.p, this.params.lightDir, texTransmittanceLut);
             this.$l.s = scattering(this, this.params, this.p, this.viewDir);
-            this.$l.t2 = pb.exp(pb.neg(this.opticalDepth));
-            this.$l.inScattering = pb.mul(this.t1, this.s, this.t2, this.ds, this.sunLuminance);
-            this.color = pb.add(this.color, this.inScattering);
+            // Multi-scattering is diffuse light left after single scattering: not planet shadowed.
             this.$l.multiScattering = getMultiScattering(this, this.params, this.p, texMultiScatteringLut);
-            this.color = pb.add(this.color, pb.mul(this.multiScattering, this.t2, this.ds, this.sunLuminance));
+            this.$l.S = pb.mul(pb.add(pb.mul(this.t1, this.s), this.multiScattering), this.sunLuminance);
+            // Integrate the source term analytically over the segment instead of weighting it by the
+            // transmittance to the segment end, which darkens long (horizon) steps.
+            this.$l.Sint = pb.div(pb.sub(this.S, pb.mul(this.S, this.sampleTransmittance)), pb.max(this.extinction, pb.vec3(1e-12)));
+            this.color = pb.add(this.color, pb.mul(this.throughput, this.Sint));
+            this.throughput = pb.mul(this.throughput, this.sampleTransmittance);
             this.p = pb.add(this.p, pb.mul(this.viewDir, this.ds));
         });
-        this.$return(this.color);
+        if (groundLit) {
+            this.$if(this.hitGround, function() {
+                this.$l.groundPos = pb.add(this.eye, pb.mul(this.viewDir, this.dis));
+                this.color = pb.add(this.color, pb.mul(groundBounce(this, this.params, this.groundPos, this.params.lightDir, texTransmittanceLut), this.throughput, this.sunLuminance));
+            });
+        }
+        this.$return(pb.vec4(this.color, pb.dot(this.throughput, pb.vec3(1 / 3))));
     });
     return scope[funcName](stParams, f3EyePos, f3ViewDir, fMaxDis);
 }
@@ -283,35 +400,42 @@ function checkParams(other) {
         pb.vec3('samplePoint')
     ], function() {
         const uniformPhase = 1 / (4 * Math.PI);
-        const sphereSolidAngle = 4 * Math.PI / N_DIRECTION;
         this.$l.G_2 = pb.vec3(0);
         this.$l.f_ms = pb.vec3(0);
         this.$for(pb.int('i'), 0, N_DIRECTION, function() {
             this.$l.viewDir = this.uniformSphereSamples.at(this.i).xyz;
             this.$l.dis = rayIntersectSphere(this, pb.vec3(0), pb.add(this.params.plantRadius, this.params.atmosphereHeight), this.samplePoint, this.viewDir);
             this.$l.d = rayIntersectSphere(this, pb.vec3(0), this.params.plantRadius, this.samplePoint, this.viewDir);
-            this.$if(pb.greaterThan(this.d, 0), function() {
-                this.dis = pb.min(this.dis, this.d);
+            this.$l.hitGround = pb.and(pb.greaterThan(this.d, 0), pb.lessThanEqual(this.d, this.dis));
+            this.$if(this.hitGround, function() {
+                this.dis = this.d;
             });
             this.$l.ds = pb.div(this.dis, N_SAMPLE);
             this.$l.p = pb.add(this.samplePoint, pb.mul(this.viewDir, this.ds, 0.5));
-            this.$l.opticalDepth = pb.vec3(0);
+            this.$l.throughput = pb.vec3(1);
             this.$for(pb.int('j'), 0, N_SAMPLE, function() {
                 this.$l.h = pb.sub(pb.length(this.p), this.params.plantRadius);
                 this.$l.sigma_s = pb.add(rayleighCoefficient(this, this.params.rayleighScatteringHeight, this.h), mieCoefficient(this, this.params.mieScatteringHeight, this.h));
                 this.$l.sigma_a = pb.add(ozoneAbsorption(this, this.params.ozoneCenter, this.params.ozoneWidth, this.h), mieAbsorption(this, this.params.mieScatteringHeight, this.h));
                 this.$l.sigma_t = pb.add(this.sigma_s, this.sigma_a);
-                this.opticalDepth = pb.add(this.opticalDepth, pb.mul(this.sigma_t, this.ds));
+                this.$l.sampleTransmittance = pb.exp(pb.neg(pb.mul(this.sigma_t, this.ds)));
                 this.$l.t1 = transmittanceToSky(this, this.params, this.p, this.lightDir, texTransmittanceLut);
-                this.$l.s = scattering(this, this.params, this.p, this.viewDir);
-                this.$l.t2 = pb.exp(pb.neg(this.opticalDepth));
-                this.G_2 = pb.add(this.G_2, pb.mul(this.t1, this.s, this.t2, uniformPhase, this.ds));
-                this.f_ms = pb.add(this.f_ms, pb.mul(this.t2, this.sigma_s, uniformPhase, this.ds));
+                this.$l.S = pb.mul(this.t1, this.sigma_s, uniformPhase);
+                this.$l.Sint = pb.div(pb.sub(this.S, pb.mul(this.S, this.sampleTransmittance)), pb.max(this.sigma_t, pb.vec3(1e-12)));
+                this.G_2 = pb.add(this.G_2, pb.mul(this.throughput, this.Sint));
+                this.f_ms = pb.add(this.f_ms, pb.mul(this.throughput, this.sigma_s, this.ds));
+                this.throughput = pb.mul(this.throughput, this.sampleTransmittance);
                 this.p = pb.add(this.p, pb.mul(this.viewDir, this.ds));
             });
+            this.$if(this.hitGround, function() {
+                this.$l.groundPos = pb.add(this.samplePoint, pb.mul(this.viewDir, this.dis));
+                this.G_2 = pb.add(this.G_2, pb.mul(groundBounce(this, this.params, this.groundPos, this.lightDir, texTransmittanceLut), this.throughput));
+            });
         });
-        this.G_2 = pb.mul(this.G_2, sphereSolidAngle);
-        this.f_ms = pb.mul(this.f_ms, sphereSolidAngle);
+        // G_2: (4pi / N) * sum(L) is the illuminance, times the isotropic phase 1 / (4pi) gives the
+        // in-scattered luminance, i.e. the plain average over the N directions.
+        this.G_2 = pb.div(this.G_2, N_DIRECTION);
+        this.f_ms = pb.div(this.f_ms, N_DIRECTION);
         this.$return(pb.div(this.G_2, pb.sub(pb.vec3(1), this.f_ms)));
     });
     return scope[funcName](stParams, f3LightDir, f3SamplePoint);
@@ -371,7 +495,9 @@ function checkParams(other) {
         this.$l.H = pb.sqrt(pb.max(0, pb.sub(pb.mul(this.topRadius, this.topRadius), pb.mul(this.bottomRadius, this.bottomRadius))));
         this.$l.rho = pb.sqrt(pb.max(0, pb.sub(pb.mul(this.r, this.r), pb.mul(this.bottomRadius, this.bottomRadius))));
         this.$l.discriminant = pb.add(pb.mul(this.r, this.r, pb.sub(pb.mul(this.mu, this.mu), 1)), pb.mul(this.topRadius, this.topRadius));
-        this.$l.d = pb.max(0, pb.sub(pb.sqrt(this.discriminant), pb.mul(this.mu, this.r)));
+        // r ~ topRadius (a ray entering from space) makes this top^2 - r^2 difference of two ~4e13 values,
+        // which float error can drive negative.
+        this.$l.d = pb.max(0, pb.sub(pb.sqrt(pb.max(this.discriminant, 0)), pb.mul(this.mu, this.r)));
         this.$l.d_min = pb.sub(this.topRadius, this.r);
         this.$l.d_max = pb.add(this.rho, this.H);
         this.$l.x_mu = pb.div(pb.sub(this.d, this.d_min), pb.sub(this.d_max, this.d_min));
@@ -380,33 +506,92 @@ function checkParams(other) {
     });
     return scope[funcName](fBottomRadius, fTopRadius, fMu, fR);
 }
-/** @internal */ function viewDirToUV(scope, f3ViewDir) {
+/** @internal */ const SKY_VIEW_LUT_WIDTH = 256;
+/** @internal */ const SKY_VIEW_LUT_HEIGHT = 128;
+/**
+ * Zenith angle of the horizon, and the angle from the horizon down to the nadir, seen from the
+ * sky view LUT observer.
+ */ function skyViewHorizon(scope, stParams) {
     const pb = scope.$builder;
+    const Params = getAtmosphereParamsStruct(pb);
+    const funcName = 'z_skyViewHorizon';
+    pb.func(funcName, [
+        Params('params')
+    ], function() {
+        this.$l.altitude = this.params.observerAltitude;
+        this.$l.viewHeight = pb.add(this.params.plantRadius, this.altitude);
+        // sqrt(h^2 - R^2) written as sqrt(a * (2R + a)): at an altitude of meters against a radius of
+        // thousands of kilometers, h^2 - R^2 is pure fp32 cancellation.
+        this.$l.vHorizon = pb.sqrt(pb.mul(this.altitude, pb.add(pb.mul(this.params.plantRadius, 2), this.altitude)));
+        this.$l.beta = pb.acos(pb.clamp(pb.div(this.vHorizon, this.viewHeight), -1, 1));
+        this.$return(pb.vec2(pb.sub(Math.PI, this.beta), this.beta));
+    });
+    return scope[funcName](stParams);
+}
+/**
+ * Sky view LUT parameterization. Latitude is split at the observer's horizon, which lands exactly on v = 0.5, with texels concentrated towards it on both sides: a
+ * uniform latitude mapping interpolates the dark below-horizon texels into the sky just above it.
+ * v = 0 is the zenith.
+ *
+ * @internal
+ */ function viewDirToUV(scope, stParams, f3ViewDir) {
+    const pb = scope.$builder;
+    const Params = getAtmosphereParamsStruct(pb);
     const funcName = 'z_viewDirToUV';
     pb.func(funcName, [
+        Params('params'),
         pb.vec3('viewDir')
     ], function() {
-        this.$l.uv = pb.vec2(pb.atan2(this.viewDir.z, this.viewDir.x), pb.asin(this.viewDir.y));
-        this.uv = pb.div(this.uv, pb.vec2(2 * Math.PI, Math.PI));
-        this.uv = pb.add(this.uv, pb.vec2(0.5));
-        this.$return(this.uv);
+        this.$l.horizon = skyViewHorizon(this, this.params);
+        this.$l.zenithHorizonAngle = this.horizon.x;
+        this.$l.beta = this.horizon.y;
+        this.$l.viewZenithAngle = pb.acos(pb.clamp(this.viewDir.y, -1, 1));
+        this.$l.v = pb.float();
+        this.$if(pb.lessThan(this.viewZenithAngle, this.zenithHorizonAngle), function() {
+            this.$l.coord = pb.div(this.viewZenithAngle, this.zenithHorizonAngle);
+            this.v = pb.mul(pb.sub(1, pb.sqrt(pb.max(pb.sub(1, this.coord), 0))), 0.5);
+        }).$else(function() {
+            this.$l.coord = pb.div(pb.sub(this.viewZenithAngle, this.zenithHorizonAngle), this.beta);
+            this.v = pb.add(pb.mul(pb.sqrt(pb.max(this.coord, 0)), 0.5), 0.5);
+        });
+        this.$l.u = pb.add(pb.div(pb.atan2(this.viewDir.z, this.viewDir.x), 2 * Math.PI), 0.5);
+        // FromUnitToSubUvs: keep lookups inside the texel-center range.
+        this.$l.size = pb.vec2(SKY_VIEW_LUT_WIDTH, SKY_VIEW_LUT_HEIGHT);
+        this.$return(pb.mul(pb.add(pb.vec2(this.u, this.v), pb.div(pb.vec2(0.5), this.size)), pb.div(this.size, pb.add(this.size, pb.vec2(1)))));
     });
-    return scope[funcName](f3ViewDir);
+    return scope[funcName](stParams, f3ViewDir);
 }
-/** @internal */ function uvToViewDir(scope, f2UV) {
+/**
+ * Inverse of {@link viewDirToUV}.
+ *
+ * @internal
+ */ function uvToViewDir(scope, stParams, f2UV) {
     const pb = scope.$builder;
+    const Params = getAtmosphereParamsStruct(pb);
     const funcName = 'z_uvToViewDir';
     pb.func(funcName, [
+        Params('params'),
         pb.vec2('uv')
     ], function() {
-        this.$l.theta = pb.mul(pb.sub(1, this.uv.y), Math.PI);
-        this.$l.phi = pb.mul(pb.sub(pb.mul(this.uv.x, 2), 1), Math.PI);
-        this.$l.x = pb.mul(pb.sin(this.theta), pb.cos(this.phi));
-        this.$l.z = pb.mul(pb.sin(this.theta), pb.sin(this.phi));
-        this.$l.y = pb.cos(this.theta);
-        this.$return(pb.vec3(this.x, this.y, this.z));
+        // FromSubUvsToUnit
+        this.$l.size = pb.vec2(SKY_VIEW_LUT_WIDTH, SKY_VIEW_LUT_HEIGHT);
+        this.$l.unit = pb.mul(pb.sub(this.uv, pb.div(pb.vec2(0.5), this.size)), pb.div(this.size, pb.sub(this.size, pb.vec2(1))));
+        this.$l.horizon = skyViewHorizon(this, this.params);
+        this.$l.zenithHorizonAngle = this.horizon.x;
+        this.$l.beta = this.horizon.y;
+        this.$l.viewZenithAngle = pb.float();
+        this.$if(pb.lessThan(this.unit.y, 0.5), function() {
+            this.$l.coord = pb.sub(1, pb.mul(this.unit.y, 2));
+            this.viewZenithAngle = pb.mul(this.zenithHorizonAngle, pb.sub(1, pb.mul(this.coord, this.coord)));
+        }).$else(function() {
+            this.$l.coord = pb.sub(pb.mul(this.unit.y, 2), 1);
+            this.viewZenithAngle = pb.add(this.zenithHorizonAngle, pb.mul(this.beta, this.coord, this.coord));
+        });
+        this.$l.phi = pb.mul(pb.sub(pb.mul(this.unit.x, 2), 1), Math.PI);
+        this.$l.sinTheta = pb.sin(this.viewZenithAngle);
+        this.$return(pb.vec3(pb.mul(this.sinTheta, pb.cos(this.phi)), pb.cos(this.viewZenithAngle), pb.mul(this.sinTheta, pb.sin(this.phi))));
     });
-    return scope[funcName](f2UV);
+    return scope[funcName](stParams, f2UV);
 }
 /** @internal */ function uvToTransmittanceLut(scope, f2UV, fBottomRadius, fTopRadius) {
     const pb = scope.$builder;
@@ -452,31 +637,80 @@ function sunBloom(scope, f3ViewDir, f3LightDir, f4LightColorAndIntensity, fSunSo
     });
     return scope[funcName](f3ViewDir, f3LightDir, f4LightColorAndIntensity, fSunSolidAngle);
 }
-/** @internal */ function skyBox(scope, stParams, f4SunColor, f3SkyBoxWorldPos, fSunSolidAngle, fIncludeSunDisk, texTransmittanceLut, texSkyViewLut) {
+/**
+ * Default sun angular diameter (DirectionalLight LightSourceAngle), as a half apex angle
+ *
+ * @internal
+ **/ const SUN_DISK_HALF_APEX_ANGLE = 0.5 * 0.5357 * Math.PI / 180;
+/**
+ * @internal
+ *
+ * Sky luminance along a view direction, plus the sun disk.
+ *
+ * @remarks
+ * `f3LocalDir` is in the observer's local frame (see {@link AtmosphereParams.skyViewReferential}).
+ * Inside the atmosphere the luminance comes from the sky view LUT; above it the LUT, which is
+ * parameterized around a horizon inside the atmosphere, does not apply and the view ray is marched
+ * per pixel instead, starting where it enters the atmosphere. That path draws the planet as seen from
+ * space: the lit virtual ground behind the full atmosphere.
+ *
+ * `sunColor` receives the light color attenuated towards the observer.
+ *
+ * @param fIncludeSunDisk - 0: no sun disk; 1: legacy stylized disk with glow; 2: physical disk.
+ * @param fPixelAngle - Angular size of a screen pixel in radians, for anti-aliasing the physical disk.
+ * @param fSunDiskMaxLuminance - Ceiling for the physical disk before its edge coverage is applied, in
+ *   the unscaled luminance this function returns (the output clamp divided by the luminance scale).
+ */ function skyBox(scope, stParams, f4SunColor, f3LocalDir, fSunSolidAngle, fIncludeSunDisk, fPixelAngle, fSunDiskMaxLuminance, texTransmittanceLut, texSkyViewLut, texMultiScatteringLut) {
     const pb = scope.$builder;
     const funcName = 'v_skybox';
     const Params = getAtmosphereParamsStruct(pb);
     pb.func(funcName, [
         Params('params'),
         pb.vec4('sunColor').out(),
-        pb.vec3('worldPos'),
+        pb.vec3('localDir'),
         pb.float('sunSolidAngle'),
-        pb.int('includeSunDisk')
+        pb.int('includeSunDisk'),
+        pb.float('pixelAngle'),
+        pb.float('sunDiskMaxLuminance')
     ], function() {
+        this.$l.viewDir = pb.normalize(this.localDir);
+        this.$l.eyePos = pb.vec3(0, pb.add(this.params.plantRadius, this.params.observerAltitude), 0);
         this.$l.rgb = pb.vec3(0);
-        this.$l.viewDir = pb.normalize(this.worldPos);
-        this.rgb = pb.add(this.rgb, pb.textureSampleLevel(texSkyViewLut, viewDirToUV(this, this.viewDir), 0).rgb);
-        this.$l.groundDistance = rayIntersectSphere(this, pb.vec3(0), this.params.plantRadius, pb.vec3(0, pb.add(this.params.plantRadius, pb.mul(CAMERA_POS_Y, this.params.cameraHeightScale)), 0), this.viewDir);
-        this.$l.sunTransmittance = transmittanceToSky(this, this.params, pb.vec3(0, pb.add(this.params.cameraHeightScale, this.params.plantRadius), 0), this.params.lightDir, texTransmittanceLut);
+        this.$if(pb.lessThan(this.params.observerAltitude, this.params.atmosphereHeight), function() {
+            this.rgb = pb.textureSampleLevel(texSkyViewLut, viewDirToUV(this, this.params, this.viewDir), 0).rgb;
+        }).$else(function() {
+            this.rgb = getSkyView(this, this.params, this.eyePos, this.viewDir, pb.float(-1), texTransmittanceLut, texMultiScatteringLut, true, true).rgb;
+        });
+        this.$l.groundDistance = rayIntersectSphere(this, pb.vec3(0), this.params.plantRadius, this.eyePos, this.viewDir);
+        this.$l.sunTransmittance = transmittanceToSky(this, this.params, this.eyePos, this.params.lightDir, texTransmittanceLut);
         this.sunColor = pb.mul(this.params.lightColor, pb.vec4(this.sunTransmittance, 1));
-        this.$if(pb.and(pb.notEqual(this.includeSunDisk, 0), pb.lessThan(this.groundDistance, 0)), function() {
+        this.$if(pb.and(pb.equal(this.includeSunDisk, 1), pb.lessThan(this.groundDistance, 0)), function() {
             this.rgb = pb.add(this.rgb, sunBloom(this, this.viewDir, this.params.lightDir, this.sunColor, this.sunSolidAngle));
         });
+        this.$if(pb.equal(this.includeSunDisk, 2), function() {
+            const halfApex = SUN_DISK_HALF_APEX_ANGLE;
+            const solidAngle = 2 * Math.PI * (1 - Math.cos(halfApex));
+            this.$l.theta = pb.distance(this.viewDir, this.params.lightDir);
+            this.$l.halfPixel = pb.mul(this.pixelAngle, 0.5);
+            this.$if(pb.lessThan(this.theta, pb.add(halfApex, this.halfPixel)), function() {
+                this.$l.transmittanceToLight = transmittanceToSky(this, this.params, this.eyePos, this.viewDir, texTransmittanceLut);
+                this.$l.edgeTheta = pb.div(pb.max(pb.sub(this.theta, this.halfPixel), 0), halfApex);
+                this.$l.softEdge = pb.clamp(pb.mul(pb.sub(1, pb.mul(this.edgeTheta, this.edgeTheta)), 2), 0, 1);
+                this.$l.coverage = pb.clamp(pb.add(pb.div(pb.sub(halfApex, this.theta), pb.max(this.pixelAngle, 1e-6)), 0.5), 0, 1);
+                this.$l.diskLuminance = pb.mul(this.transmittanceToLight, this.params.lightColor.rgb, pb.div(this.params.lightColor.a, solidAngle), this.softEdge);
+                this.rgb = pb.add(this.rgb, pb.mul(pb.min(this.diskLuminance, pb.vec3(this.sunDiskMaxLuminance)), this.coverage));
+            });
+        });
         this.$return(pb.vec4(this.rgb, 1));
     });
-    return scope[funcName](stParams, f4SunColor, f3SkyBoxWorldPos, fSunSolidAngle, fIncludeSunDisk);
+    return scope[funcName](stParams, f4SunColor, f3LocalDir, fSunSolidAngle, fIncludeSunDisk, fPixelAngle, fSunDiskMaxLuminance);
 }
-/** @internal */ function aerialPerspective(scope, f2UV, stParams, f3CameraPos, f3WorldPos, f3Dim, texAerialPerspectiveLut) {
+/** @internal */ const AP_LUT_SLICE_SIZE = 32;
+/** @internal */ const AP_LUT_DEPTH_SLICES = 32;
+/**
+ * Samples the aerial perspective LUT.
+ * @internal
+ */ function aerialPerspective(scope, f2UV, stParams, f3CameraPos, f3WorldPos, f3Dim, texAerialPerspectiveLut) {
     const pb = scope.$builder;
     const Params = getAtmosphereParamsStruct(pb);
     const funcName = 'z_aerialPerspective';
@@ -487,99 +721,82 @@ function sunBloom(scope, f3ViewDir, f3LightDir, f4LightColorAndIntensity, fSunSo
         pb.vec3('worldPos'),
         pb.vec3('dim')
     ], function() {
-        this.$l.V = pb.sub(this.worldPos, this.cameraPos);
-        this.$l.dis = pb.length(this.V);
-        this.$l.viewDir = pb.normalize(this.V);
-        this.$l.apDistance = pb.div(this.params.apDistance, this.params.cameraHeightScale);
-        this.$l.d0 = pb.clamp(pb.div(this.dis, this.apDistance), 0, 1);
-        this.$l.weight = pb.clamp(pb.mul(this.d0, 2), 0, 1);
-        this.$l.dz = pb.mul(this.d0, pb.sub(this.dim.z, 1));
-        this.$l.slice = pb.floor(this.dz);
-        this.$l.nextSlice = pb.min(pb.add(this.slice, 1), pb.sub(this.dim.z, 1));
-        this.$l.factor = pb.sub(this.dz, pb.floor(this.dz));
-        this.t = pb.div(this.uv, pb.vec2(this.dim.x, 1));
-        this.$l.uv1 = pb.add(this.t, pb.vec2(pb.div(this.slice, this.dim.z), 0));
-        this.$l.uv2 = pb.add(this.t, pb.vec2(pb.div(this.nextSlice, this.dim.z), 0));
+        this.$l.tDepth = pb.max(pb.sub(pb.mul(pb.distance(this.worldPos, this.cameraPos), this.params.cameraHeightScale), this.params.apStartDepth), 0);
+        this.$l.linearW = pb.clamp(pb.div(this.tDepth, this.params.apDistance), 0, 1);
+        this.$l.nonLinSlice = pb.mul(pb.sqrt(this.linearW), this.dim.z);
+        this.$l.weight = pb.clamp(pb.mul(this.nonLinSlice, this.nonLinSlice, 2), 0, 1);
+        this.$l.sliceF = pb.clamp(pb.sub(this.nonLinSlice, 0.5), 0, pb.sub(this.dim.z, 1));
+        this.$l.slice0 = pb.floor(this.sliceF);
+        this.$l.slice1 = pb.min(pb.add(this.slice0, 1), pb.sub(this.dim.z, 1));
+        this.$l.factor = pb.sub(this.sliceF, this.slice0);
+        this.$l.halfTexel = pb.div(0.5, this.dim.x);
+        this.$l.u = pb.clamp(this.uv.x, this.halfTexel, pb.sub(1, this.halfTexel));
+        this.$l.uv1 = pb.vec2(pb.div(pb.add(this.slice0, this.u), this.dim.z), this.uv.y);
+        this.$l.uv2 = pb.vec2(pb.div(pb.add(this.slice1, this.u), this.dim.z), this.uv.y);
         this.$l.data1 = pb.textureSampleLevel(texAerialPerspectiveLut, this.uv1, 0);
         this.$l.data2 = pb.textureSampleLevel(texAerialPerspectiveLut, this.uv2, 0);
         this.$l.data = pb.mix(this.data1, this.data2, this.factor);
-        this.$l.inscattering = pb.mul(this.data.rgb, this.weight);
-        //this.$l.transmittance = pb.sub(1, pb.mul(this.weight, pb.sub(1, this.data.a)));
-        this.$l.planetTranslate = pb.vec3(0, this.params.plantRadius, 0);
-        this.$l.transmittance = pb.dot(transmittance(this, this.params, pb.add(this.cameraPos, this.planetTranslate), pb.add(this.worldPos, this.planetTranslate)), pb.vec3(1 / 3, 1 / 3, 1 / 3));
-        this.$return(pb.vec4(this.inscattering, this.transmittance));
+        this.$return(pb.vec4(pb.mul(this.data.rgb, this.weight), pb.sub(1, pb.mul(this.weight, pb.sub(1, this.data.a)))));
     });
     return scope[funcName](stParams, f2UV, f3CameraPos, f3WorldPos, f3Dim);
 }
-/** @internal */ function aerialPerspectiveLut(scope, stParams, f2UV, f3VoxelDim, texTransmittanceLut, texMultiScatteringLut) {
+/**
+ * @internal
+ *
+ * Renders one texel of the aerial perspective LUT atlas: rgb is the in-scattered luminance and a
+ * the mean transmittance from the observer to the froxel.
+ */ function aerialPerspectiveLut(scope, stParams, f2UV, f3VoxelDim, texTransmittanceLut, texMultiScatteringLut) {
     const pb = scope.$builder;
     const Params = getAtmosphereParamsStruct(pb);
-    const funcNameFixVoxel = 'z_fixVoxel';
-    pb.func(funcNameFixVoxel, [
-        Params('params'),
-        pb.vec3('eyePos'),
-        pb.vec3('viewDir').inout(),
-        pb.float('maxDis'),
-        pb.float('adjustedMaxDis').inout()
-    ], function() {
-        this.$l.voxelPos = pb.add(this.eyePos, pb.mul(this.viewDir, this.maxDis));
-        this.$l.voxelHeight = pb.length(this.voxelPos);
-        this.$l.underGround = pb.lessThan(this.voxelHeight, this.params.plantRadius);
-        this.$l.cameraToVoxel = pb.sub(this.voxelPos, this.eyePos);
-        this.$l.cameraToVoxelLen = pb.length(this.cameraToVoxel);
-        this.$l.cameraToVoxelDir = pb.div(this.cameraToVoxel, this.cameraToVoxelLen);
-        this.$l.planetNearT = rayIntersectSphere(this, pb.vec3(0), this.params.plantRadius, this.eyePos, this.cameraToVoxelDir);
-        this.$l.belowHorizon = pb.and(pb.greaterThan(this.planetNearT, 0), pb.greaterThan(this.cameraToVoxelLen, this.planetNearT));
-        this.$l.eyePos2 = this.eyePos;
-        this.$if(pb.or(this.underGround, this.belowHorizon), function() {
-            this.eyePos2 = pb.add(this.eyePos2, pb.mul(pb.normalize(this.eyePos2), 0.02));
-            this.$if(this.belowHorizon, function() {
-                this.$l.voxelWorldPosNorm = pb.normalize(this.voxelPos);
-                this.$l.camProjOnGround = pb.mul(pb.normalize(this.eyePos2), this.params.plantRadius);
-                this.$l.voxProjOnGround = pb.mul(this.voxelWorldPosNorm, this.params.plantRadius);
-                this.$l.voxelGroundToRayStart = pb.sub(this.eyePos2, this.voxProjOnGround);
-                this.$if(pb.lessThan(pb.dot(pb.normalize(this.voxelGroundToRayStart), this.voxelWorldPosNorm), 0.0001), function() {
-                    this.$l.middlePoint = pb.mul(pb.add(this.camProjOnGround, this.voxProjOnGround), 0.5);
-                    this.$l.middlePointOnGround = pb.mul(pb.normalize(this.middlePoint), this.params.plantRadius);
-                    this.voxelPos = pb.add(this.eyePos2, pb.mul(pb.sub(this.middlePointOnGround, this.eyePos2), 2));
-                });
-            }).$else(function() {
-                this.voxelPos = pb.mul(pb.normalize(this.voxelPos), this.params.plantRadius);
-            });
-            this.$l.V = pb.sub(this.voxelPos, this.eyePos2);
-            this.adjustedMaxDis = pb.length(this.V);
-            this.viewDir = pb.div(this.V, this.adjustedMaxDis);
-        });
-        this.$return(this.eyePos2);
-    });
     const funcName = 'z_aerialPerspectiveLut';
     pb.func(funcName, [
         Params('params'),
         pb.vec2('uv'),
-        pb.vec3('dim'),
-        pb.float('cameraPosY')
+        pb.vec3('dim')
     ], function() {
-        this.$l.uvw = pb.vec3(this.uv, 0);
-        this.uvw.x = pb.mul(this.uvw.x, this.dim.x, this.dim.z);
-        this.uvw.z = pb.div(pb.floor(pb.div(this.uvw.x, this.dim.z)), this.dim.x);
-        this.uvw.x = pb.div(pb.mod(this.uvw.x, this.dim.z), this.dim.x);
-        this.uvw = pb.add(this.uvw, pb.div(pb.vec3(0.5), this.dim));
-        this.$l.slice = this.uvw.z; //pb.mul(this.uvw.z, this.uvw.z);
-        this.$l.viewDir = pb.normalize(pb.mul(this.params.cameraWorldMatrix, pb.vec4(pb.sub(pb.mul(this.uvw.x, 2), 1), pb.div(pb.sub(pb.mul(this.uvw.y, 2), 1), this.params.cameraAspect), -1, 0)).xyz);
-        this.$l.eyePos = pb.vec3(0, pb.add(pb.mul(this.cameraPosY, this.params.cameraHeightScale), this.params.plantRadius), 0);
-        this.$l.maxDis = pb.mul(this.slice, this.params.apDistance);
+        // uv arrives at the texel center of the dim.x * dim.z wide atlas.
+        this.$l.px = pb.floor(pb.mul(this.uv.x, this.dim.x, this.dim.z));
+        this.$l.slice = pb.floor(pb.div(this.px, this.dim.x));
+        this.$l.screenUV = pb.vec2(pb.div(pb.add(pb.sub(this.px, pb.mul(this.slice, this.dim.x)), 0.5), this.dim.x), this.uv.y);
+        this.$l.w = pb.div(pb.add(this.slice, 0.5), this.dim.z);
+        this.$l.ndc = pb.sub(pb.mul(this.screenUV, 2), pb.vec2(1));
+        this.$l.viewDir = pb.normalize(pb.mul(this.params.cameraWorldMatrix, pb.vec4(pb.mul(this.ndc.x, this.params.cameraTanHalfFovy, this.params.cameraAspect), pb.mul(this.ndc.y, this.params.cameraTanHalfFovy), -1, 0)).xyz);
+        this.$l.eyePos = pb.vec3(0, pb.add(this.params.observerAltitude, this.params.plantRadius), 0);
+        // Slices start at the start depth (RayStartWorldPos = CamPos + StartDepth * WorldDir).
+        this.$l.maxDis = pb.add(this.params.apStartDepth, pb.mul(this.w, this.w, this.params.apDistance));
         this.$l.voxelPos = pb.add(this.eyePos, pb.mul(this.viewDir, this.maxDis));
-        this.$if(pb.lessThan(pb.length(this.voxelPos), this.params.plantRadius), function() {
-            this.voxelPos = pb.mul(pb.normalize(this.voxelPos), this.params.plantRadius);
-            this.maxDis = pb.length(pb.sub(this.eyePos, this.voxelPos));
+        this.$l.underGround = pb.lessThan(pb.length(this.voxelPos), this.params.plantRadius);
+        this.$l.planetNearT = rayIntersectSphere(this, pb.vec3(0), this.params.plantRadius, this.eyePos, this.viewDir);
+        this.$l.belowHorizon = pb.and(pb.greaterThan(this.planetNearT, 0), pb.greaterThan(this.maxDis, this.planetNearT));
+        // A froxel behind the ground would only integrate up to the ground hit, leaving surfaces seen
+        // from above (the observer sits just above the planet) without any aerial perspective. Instead
+        // integrate towards the ground point below the froxel.
+        this.$if(pb.or(this.underGround, this.belowHorizon), function() {
+            this.$l.voxelPosNorm = pb.normalize(this.voxelPos);
+            this.$l.camProjOnGround = pb.mul(pb.normalize(this.eyePos), this.params.plantRadius);
+            this.$l.voxProjOnGround = pb.mul(this.voxelPosNorm, this.params.plantRadius);
+            this.$l.voxelGroundToRayStart = pb.sub(this.eyePos, this.voxProjOnGround);
+            this.$if(pb.and(this.belowHorizon, pb.lessThan(pb.dot(pb.normalize(this.voxelGroundToRayStart), this.voxelPosNorm), 0.0001)), function() {
+                // Behind the planet: evaluate the point mirrored through the horizon point.
+                this.$l.middlePoint = pb.mul(pb.add(this.camProjOnGround, this.voxProjOnGround), 0.5);
+                this.$l.middlePointOnGround = pb.mul(pb.normalize(this.middlePoint), this.params.plantRadius);
+                this.voxelPos = pb.add(this.eyePos, pb.mul(pb.sub(this.middlePointOnGround, this.eyePos), 2));
+            }).$elseif(this.underGround, function() {
+                this.voxelPos = this.voxProjOnGround;
+            });
+            this.$l.V = pb.sub(this.voxelPos, this.eyePos);
+            this.maxDis = pb.length(this.V);
+            this.viewDir = pb.div(this.V, this.maxDis);
         });
-        this.$l.color = getSkyView(this, this.params, this.eyePos, this.viewDir, this.maxDis, texTransmittanceLut, texMultiScatteringLut);
-        this.$l.t1 = transmittanceToSky(this, this.params, this.eyePos, this.viewDir, texTransmittanceLut);
-        this.$l.t2 = transmittanceToSky(this, this.params, this.voxelPos, this.viewDir, texTransmittanceLut);
-        this.$l.t = pb.clamp(pb.div(this.t1, pb.max(this.t2, pb.vec3(0.0001))), pb.vec3(0), pb.vec3(1));
-        this.$return(pb.vec4(this.color, pb.dot(this.t, pb.vec3(1 / 3, 1 / 3, 1 / 3))));
+        // Integrate from the start depth along the (possibly redirected) ray up to the froxel.
+        this.$l.rayStart = pb.add(this.eyePos, pb.mul(this.viewDir, this.params.apStartDepth));
+        this.$l.segment = pb.sub(this.maxDis, this.params.apStartDepth);
+        this.$if(pb.lessThanEqual(this.segment, 0), function() {
+            this.$return(pb.vec4(0, 0, 0, 1));
+        });
+        this.$return(getSkyView(this, this.params, this.rayStart, this.viewDir, this.segment, texTransmittanceLut, texMultiScatteringLut, true, false, true));
     });
-    return scope[funcName](stParams, f2UV, f3VoxelDim, CAMERA_POS_Y);
+    return scope[funcName](stParams, f2UV, f3VoxelDim);
 }
 /** @internal */ function skyViewLut(scope, stParams, f2UV, texTransmittanceLut, texMultiScatteringLut) {
     const pb = scope.$builder;
@@ -587,16 +804,15 @@ function sunBloom(scope, f3ViewDir, f3LightDir, f4LightColorAndIntensity, fSunSo
     const funcName = 'v_skyViewLut';
     pb.func(funcName, [
         Params('params'),
-        pb.vec2('uv'),
-        pb.float('cameraPosY')
+        pb.vec2('uv')
     ], function() {
-        this.$l.viewDir = uvToViewDir(this, this.uv);
-        this.$l.h = pb.add(this.params.plantRadius, pb.mul(this.cameraPosY, this.params.cameraHeightScale));
+        this.$l.viewDir = uvToViewDir(this, this.params, this.uv);
+        this.$l.h = pb.add(this.params.plantRadius, this.params.observerAltitude);
         this.$l.eyePos = pb.vec3(0, this.h, 0);
-        this.$l.rgb = getSkyView(this, this.params, this.eyePos, this.viewDir, pb.float(-1), texTransmittanceLut, texMultiScatteringLut);
+        this.$l.rgb = getSkyView(this, this.params, this.eyePos, this.viewDir, pb.float(-1), texTransmittanceLut, texMultiScatteringLut, true, true).rgb;
         this.$return(pb.vec4(this.rgb, 1));
     });
-    return scope[funcName](stParams, f2UV, CAMERA_POS_Y);
+    return scope[funcName](stParams, f2UV);
 }
 /** @internal */ function multiScatteringLut(scope, stParams, f2UV, texTransmittanceLut) {
     const pb = scope.$builder;
@@ -693,6 +909,8 @@ let APFramebuffer;
         pb.vec4('lightColor'),
         pb.vec3('lightDir'),
         pb.float('cameraAspect'),
+        pb.vec3('groundAlbedo'),
+        pb.float('cameraTanHalfFovy'),
         pb.float('plantRadius'),
         pb.float('atmosphereHeight'),
         pb.float('rayleighScatteringHeight'),
@@ -701,7 +919,11 @@ let APFramebuffer;
         pb.float('ozoneCenter'),
         pb.float('ozoneWidth'),
         pb.float('apDistance'),
-        pb.float('cameraHeightScale')
+        pb.float('apViewDistanceScale'),
+        pb.float('apStartDepth'),
+        pb.float('cameraHeightScale'),
+        pb.float('observerAltitude'),
+        pb.mat4('skyViewReferential')
     ]);
 }
 /** @internal */ function createTransmittanceLutProgram(device) {
@@ -859,7 +1081,7 @@ let APFramebuffer;
         try {
             skyViewLutProgram = createSkyViewLutProgram(device);
             skyViewLutBindGroup = device.createBindGroup(skyViewLutProgram.bindGroupLayouts[0]);
-            skyViewLUT = device.createTexture2D('rgba16f', 256, 128, {
+            skyViewLUT = device.createTexture2D('rgba16f', SKY_VIEW_LUT_WIDTH, SKY_VIEW_LUT_HEIGHT, {
                 mipmapping: false
             });
             skyViewLUT.name = 'DebugSkyViewLut';
@@ -904,7 +1126,7 @@ let APFramebuffer;
             this.multiScatteringLut = pb.tex2D().uniform(0);
             this.$outputs.outColor = pb.vec4();
             pb.main(function() {
-                this.$outputs.outColor = aerialPerspectiveLut(this, this.params, this.$inputs.uv, pb.vec3(32, 32, 32), this.transmittanceLut, this.multiScatteringLut);
+                this.$outputs.outColor = aerialPerspectiveLut(this, this.params, this.$inputs.uv, pb.vec3(AP_LUT_SLICE_SIZE, AP_LUT_SLICE_SIZE, AP_LUT_DEPTH_SLICES), this.transmittanceLut, this.multiScatteringLut);
             });
         }
     });
@@ -917,7 +1139,7 @@ let APFramebuffer;
         try {
             APLutProgram = createAPLutProgram(device);
             APLutBindGroup = device.createBindGroup(APLutProgram.bindGroupLayouts[0]);
-            ApLut = device.createTexture2D('rgba16f', 32 * 32, 32, {
+            ApLut = device.createTexture2D('rgba16f', AP_LUT_SLICE_SIZE * AP_LUT_DEPTH_SLICES, AP_LUT_SLICE_SIZE, {
                 mipmapping: false
             });
             ApLut.name = 'DebugAPLut';
@@ -942,5 +1164,5 @@ let APFramebuffer;
     }
 }
 
-export { CAMERA_POS_Y, aerialPerspective, aerialPerspectiveLut, atmosphereLUTRendered, createAPLutProgram, createMultiScatteringLutProgram, createSkyViewLutProgram, createTransmittanceLutProgram, getAerialPerspectiveLut, getAtmosphereParamsStruct, getDefaultAtmosphereParams, getMultiScattering, getMultiScatteringLut, getSkyView, getSkyViewLut, getTransmittanceLut, integralMultiScattering, mieAbsorption, mieCoefficient, miePhase, multiScatteringLut, ozoneAbsorption, rayIntersectSphere, rayleighCoefficient, rayleighPhase, renderAPLut, renderAtmosphereLUTs, renderMultiScatteringLut, renderSkyViewLut, renderTransmittanceLut, scattering, skyBox, skyViewLut, transmittance, transmittanceLut, transmittanceLutToUV, transmittanceToSky, uvToTransmittanceLut, uvToViewDir, viewDirToUV };
+export { AP_LUT_DEPTH_SLICES, AP_LUT_SLICE_SIZE, MIN_OBSERVER_ALTITUDE, SKY_VIEW_LUT_HEIGHT, SKY_VIEW_LUT_WIDTH, SUN_DISK_HALF_APEX_ANGLE, aerialPerspective, aerialPerspectiveLut, atmosphereLUTRendered, createAPLutProgram, createMultiScatteringLutProgram, createSkyViewLutProgram, createTransmittanceLutProgram, getAerialPerspectiveLut, getAtmosphereParamsStruct, getDefaultAtmosphereParams, getMultiScattering, getMultiScatteringLut, getSkyView, getSkyViewLut, getTransmittanceLut, groundBounce, integralMultiScattering, mieAbsorption, mieCoefficient, miePhase, multiScatteringLut, ozoneAbsorption, rayIntersectSphere, rayIntersectSphereFar, rayleighCoefficient, rayleighPhase, renderAPLut, renderAtmosphereLUTs, renderMultiScatteringLut, renderSkyViewLut, renderTransmittanceLut, scattering, skyBox, skyViewLut, transmittance, transmittanceLut, transmittanceLutToUV, transmittanceToSky, uvToTransmittanceLut, uvToViewDir, viewDirToUV };
 //# sourceMappingURL=atmosphere.js.map