@woosh/meep-engine 3.11.1 → 3.11.3

package/src/shade/renderer/atmosphere/chunk_get_multiscatter_values.js

@@ -1,177 +1,163 @@
-import { ATMOSPHERE_HEIGHT_DECLARATION } from "../shader/chunk/atmosphere/ATMOSPHERE_HEIGHT_DECLARATION.js";
-import {
-    C_MIE_ABSORPTION_DECLARATION,
-    C_MIE_SCATTERING_DECLARATION
-} from "../shader/chunk/atmosphere/C_MIE_SCATTERING_DECLARATION.js";
-import { C_OZONE_DECLARATION } from "../shader/chunk/atmosphere/C_OZONE_DECLARATION.js";
-import { C_RAYLEIGH_DECLARATION } from "../shader/chunk/atmosphere/C_RAYLEIGH_DECLARATION.js";
-import { chunk_atmosphere_density } from "../shader/chunk/atmosphere/chunk_atmosphere_density.js";
-import { chunk_atmosphere_height } from "../shader/chunk/atmosphere/chunk_atmosphere_height.js";
-import { chunk_atmosphere_intersection } from "../shader/chunk/atmosphere/chunk_atmosphere_intersection.js";
-import {
-    chunk_position_relative_to_planet_center
-} from "../shader/chunk/atmosphere/chunk_position_relative_to_planet_center.js";
-import { chunk_sphere_intersection } from "../shader/chunk/atmosphere/chunk_sphere_intersection.js";
-import { chunk_sphere_intersection_nearest } from "../shader/chunk/atmosphere/chunk_sphere_intersection_nearest.js";
-import {
-    chunk_phase_mie_cornette_shanks
-} from "../shader/chunk/atmosphere/phase/chunk_phase_mie_cornette_shanks.js";
-import { chunk_phase_rayleigh } from "../shader/chunk/atmosphere/phase/chunk_phase_rayleigh.js";
-import { PLANET_CENTER_DECLARATION } from "../shader/chunk/atmosphere/PLANET_CENTER_DECLARATION.js";
-import { PLANET_RADIUS_DECLARATION } from "../shader/chunk/atmosphere/PLANET_RADIUS_DECLARATION.js";
-import { chunk_spherical_to_cartesian } from "../shader/chunk/geometry/sphere/chunk_spherical_to_cartesian.js";
-import { chunk_safe_acos } from "../shader/chunk/math/chunk_safe_acos.js";
-import { PI_DECLARATION } from "../shader/chunk/math/PI_DECLARATION.js";
-import { CodeChunk } from "../shader/compiler/CodeChunk.js";
-import { chunk_sample_transmittance_lut } from "./chunk_sample_transmittance_lut.js";
-import { MIE_G } from "./MIE_G.js";
-
-
-/**
- * Calculates Equation (5) and (7) from the paper.
- * @see "A Scalable and Production Ready Sky and Atmosphere Rendering Technique", Hillaire (2020)
- */
-export const chunk_get_multiscatter_values = CodeChunk.from(
-    //language=WGSL
-    `
-fn get_multiscatter_values( 
-    pos: vec3<f32>,
-    sunDir: vec3<f32>,
-    steps: f32,
-    sqrt_samples: u32,
-    out_lumTotal: ptr<function,vec3<f32>>,
-    out_fms: ptr<function,vec3<f32>>,
-) {
-    const groundAlbedo = vec3(0.3);
-
-    var lumTotal = vec3(0.0);
-    var fms = vec3(0.0);
-    
-    let inv_samples = 1.0 / f32( sqrt_samples * sqrt_samples );
-    
-    for (var i = 0u; i < sqrt_samples; i++) {
-        for (var j = 0u; j < sqrt_samples; j++) {
-        
-            // This integral is symmetric about theta = 0 (or theta = PI), so we
-            // only need to integrate from zero to PI, not zero to 2*PI.
-            
-            let theta = PI * ( f32(i) + 0.5 ) / f32(sqrt_samples);
-            let phi = safe_acos(1.0 - 2.0*(f32(j) + 0.5) / f32(sqrt_samples));
-            
-            let rayDir = spherical_to_cartesian(theta, phi);
-            
-            // distance to the edge of the atmosphere
-            let atmoDist = sphere_intersection_nearest(pos, rayDir, PLANET_CENTER, PLANET_RADIUS + ATMOSPHERE_HEIGHT);
-            let groundDist = sphere_intersection_nearest(pos, rayDir, PLANET_CENTER, PLANET_RADIUS);
-            
-            var tMax = atmoDist;
-            
-            if (groundDist > 0.0) {
-                // in case we're looking down
-                tMax = groundDist;
-            }
-            
-            let cosTheta = dot(rayDir, sunDir);
-    
-            let miePhaseValue = phase_mie(cosTheta, ${MIE_G});
-            let rayleighPhaseValue = phase_rayleigh(-cosTheta);
-            
-            var lum = vec3(0.0);
-            var lumFactor = vec3(0.0);
-            var transmittance = vec3(1.0);
-            
-            var t = 0.0;
-            for (var stepI = 0.0; stepI < steps; stepI += 1.0) {
-                let newT = ( (stepI + 0.3) / steps ) * tMax;
-                let dt = newT - t;
-                t = newT;
-
-                let newPos = pos + t * rayDir;
-                
-                
-                let local_height = atmosphere_height(newPos);
-                let local_density = atmosphere_density(local_height);
-                
-                let ozone_density = local_density.z;
-                let ozone_absorption =  ozone_density * C_OZONE;
-                
-                let mie_density = local_density.y;
-                let mie_absorption = mie_density * C_MIE_ABSORPTION;
-                let mie_scattering = mie_density * C_MIE_SCATTERING;
-                
-                // note - taken from the Hillaire's atmosphere code: https://github.com/sebh/UnrealEngineSkyAtmosphere/blob/183ead5bdacc701b3b626347a680a2f3cd3d4fbd/Resources/RenderSkyCommon.hlsl#L248
-                let rayleigh_absorption = 0.0;
-                let rayleigh_scattering = local_density.x * C_RAYLEIGH;
-                
-                let extinction = rayleigh_scattering + rayleigh_absorption + mie_scattering + mie_absorption + ozone_absorption;
-
-                
-                let sample_transmittance = exp(-dt * extinction);
-                
-                // Integrate within each segment.
-                let scatteringNoPhase = rayleigh_scattering + mie_scattering;
-                let scatteringF = (scatteringNoPhase - scatteringNoPhase * sample_transmittance) / extinction;
-                lumFactor += transmittance * scatteringF;
-                
-                // This is slightly different from the paper, but I think the paper has a mistake?
-                // In equation (6), I think S(x,w_s) should be S(x-tv,w_s).
-                let sun_transmittance = sample_transmittance_lut(newPos, sunDir);
-
-                let rayleighInScattering = rayleigh_scattering * rayleighPhaseValue;
-                let mieInScattering = mie_scattering * miePhaseValue;
-                let inScattering = (rayleighInScattering + mieInScattering) * sun_transmittance;
-
-                // Integrated scattering within path segment.
-                let scatteringIntegral = (inScattering - inScattering * sample_transmittance) / extinction;
-
-                lum += scatteringIntegral * transmittance;
-                transmittance *= sample_transmittance;
-            }
-            
-            if (groundDist > 0.0) {
-            
-                
-                let relative_pos = position_relative_to_planet_center(pos);
-                
-                if (dot(relative_pos, sunDir) > 0.0) {
-                
-                    // sun is behind us, pick a point on the planet to sample
-                    let hitPos = normalize(relative_pos + groundDist*rayDir) * PLANET_RADIUS + PLANET_CENTER;
-                    
-                    lum += transmittance * groundAlbedo * sample_transmittance_lut(hitPos, sunDir);
-                
-                }
-                
-            }
-            
-            fms += lumFactor * inv_samples;
-            lumTotal += lum * inv_samples;
-        }
-    }
-    
-    *out_fms = fms;
-    *out_lumTotal = lumTotal;
-    
-}
-    `, [
-        PI_DECLARATION,
-        PLANET_CENTER_DECLARATION,
-        PLANET_RADIUS_DECLARATION,
-        ATMOSPHERE_HEIGHT_DECLARATION,
-        C_OZONE_DECLARATION,
-        C_MIE_SCATTERING_DECLARATION,
-        C_MIE_ABSORPTION_DECLARATION,
-        C_RAYLEIGH_DECLARATION,
-        chunk_safe_acos,
-        chunk_atmosphere_height,
-        chunk_spherical_to_cartesian,
-        chunk_sphere_intersection,
-        chunk_atmosphere_intersection,
-        chunk_atmosphere_density,
-        chunk_phase_mie_cornette_shanks,
-        chunk_phase_rayleigh,
-        chunk_sample_transmittance_lut,
-        chunk_sphere_intersection_nearest,
-        chunk_position_relative_to_planet_center,
-    ]
-)
+import { ATMOSPHERE_RADII_DECLARATION } from "../shader/chunk/atmosphere/ATMOSPHERE_RADII_DECLARATION.js";
+import {
+    C_MIE_ABSORPTION_DECLARATION,
+    C_MIE_SCATTERING_DECLARATION
+} from "../shader/chunk/atmosphere/C_MIE_SCATTERING_DECLARATION.js";
+import { C_OZONE_DECLARATION } from "../shader/chunk/atmosphere/C_OZONE_DECLARATION.js";
+import { C_RAYLEIGH_DECLARATION } from "../shader/chunk/atmosphere/C_RAYLEIGH_DECLARATION.js";
+import { chunk_atmosphere_density } from "../shader/chunk/atmosphere/chunk_atmosphere_density.js";
+import { chunk_atmosphere_ray_bounds } from "../shader/chunk/atmosphere/chunk_atmosphere_ray_bounds.js";
+import {
+    chunk_position_relative_to_planet_center
+} from "../shader/chunk/atmosphere/chunk_position_relative_to_planet_center.js";
+import {
+    chunk_phase_mie_cornette_shanks
+} from "../shader/chunk/atmosphere/phase/chunk_phase_mie_cornette_shanks.js";
+import { chunk_phase_rayleigh } from "../shader/chunk/atmosphere/phase/chunk_phase_rayleigh.js";
+import { PI_DECLARATION } from "../shader/chunk/math/PI_DECLARATION.js";
+import { CodeChunk } from "../shader/compiler/CodeChunk.js";
+import { chunk_sample_transmittance_lut_params } from "./chunk_sample_transmittance_lut.js";
+import { MIE_G } from "./MIE_G.js";
+import { MULTISCATTER_LUT_STEPS } from "./MULTISCATTER_LUT_CONFIG.js";
+
+
+/**
+ * One direction's contribution to Equations (5) and (7) from the paper: `out_lum` is the
+ * second-order in-scattered luminance along `rayDir`, `out_fms` the luminance that would
+ * come back if the medium scattered one unit of light isotropically. The caller integrates
+ * over the direction set -- see {@link chunk_multiscatter_sample_direction} -- by taking the
+ * mean, which is what the paper's uniform phase p_u = 1/(4*PI) reduces to.
+ *
+ * Splitting one direction out of the loop is what lets `shader_multiscatter_lut` put a
+ * thread on each of the 64 directions, the way Hillaire's `NewMultiScattCS` does.
+ *
+ * `pos` is assumed to be inside the atmosphere and at or above the surface, which is what
+ * makes the far root of the outer sphere the atmosphere exit.
+ *
+ * @see "A Scalable and Production Ready Sky and Atmosphere Rendering Technique", Hillaire (2020)
+ * @see https://www.shadertoy.com/view/slSXRW
+ * @type {CodeChunk}
+ */
+export const chunk_get_multiscatter_values = CodeChunk.from(
+    //language=WGSL
+    `
+const MULTISCATTER_GROUND_ALBEDO = vec3(0.3);
+const MULTISCATTER_STEPS = ${MULTISCATTER_LUT_STEPS}u;
+const MULTISCATTER_STEPS_F = f32(MULTISCATTER_STEPS);
+
+fn get_multiscatter_values(
+    pos: vec3<f32>,
+    sunDir: vec3<f32>,
+    rayDir: vec3<f32>,
+    out_lum: ptr<function,vec3<f32>>,
+    out_fms: ptr<function,vec3<f32>>,
+) {
+    let rel = position_relative_to_planet_center(pos);
+
+    // one quadratic setup for both spheres; in case we're looking down, the ground is as far
+    // as the march goes
+    let bounds = atmosphere_ray_bounds(rel, rayDir);
+
+    let tMax = bounds.t_max;
+
+    let cosTheta = dot(rayDir, sunDir);
+
+    let miePhaseValue = phase_mie(cosTheta, ${MIE_G});
+    let rayleighPhaseValue = phase_rayleigh(-cosTheta);
+
+    var lum = vec3(0.0);
+    var lumFactor = vec3(0.0);
+    var transmittance = vec3(1.0);
+
+    var t = 0.0;
+    for (var stepI = 0u; stepI < MULTISCATTER_STEPS; stepI++) {
+        let newT = ( (f32(stepI) + 0.3) / MULTISCATTER_STEPS_F ) * tMax;
+        let dt = newT - t;
+        t = newT;
+
+        // Stepping the planet-relative position directly: building the world position only
+        // to have the LUT lookup subtract the planet centre back off it was the second of
+        // two square roots per step.
+        let step_rel = rel + t * rayDir;
+        let step_radius = length(step_rel);
+        let up = step_rel / step_radius;
+
+        let local_height = step_radius - ATMOSPHERE_GROUND_RADIUS;
+        let local_density = atmosphere_density(local_height);
+
+        let ozone_density = local_density.z;
+        let ozone_absorption =  ozone_density * C_OZONE;
+
+        let mie_density = local_density.y;
+        let mie_absorption = mie_density * C_MIE_ABSORPTION;
+        let mie_scattering = mie_density * C_MIE_SCATTERING;
+
+        // note - taken from the Hillaire's atmosphere code: https://github.com/sebh/UnrealEngineSkyAtmosphere/blob/183ead5bdacc701b3b626347a680a2f3cd3d4fbd/Resources/RenderSkyCommon.hlsl#L248
+        let rayleigh_absorption = 0.0;
+        let rayleigh_scattering = local_density.x * C_RAYLEIGH;
+
+        let extinction = rayleigh_scattering + rayleigh_absorption + mie_scattering + mie_absorption + ozone_absorption;
+
+
+        let sample_transmittance = exp(-dt * extinction);
+
+        // Integrate within each segment.
+        let scatteringNoPhase = rayleigh_scattering + mie_scattering;
+        let scatteringF = (scatteringNoPhase - scatteringNoPhase * sample_transmittance) / extinction;
+        lumFactor += transmittance * scatteringF;
+
+        // This is slightly different from the paper, but I think the paper has a mistake?
+        // In equation (6), I think S(x,w_s) should be S(x-tv,w_s).
+        let sun_transmittance = sample_transmittance_lut_params(local_height, dot(sunDir, up));
+
+        let rayleighInScattering = rayleigh_scattering * rayleighPhaseValue;
+        let mieInScattering = mie_scattering * miePhaseValue;
+        let inScattering = (rayleighInScattering + mieInScattering) * sun_transmittance;
+
+        // Integrated scattering within path segment.
+        let scatteringIntegral = (inScattering - inScattering * sample_transmittance) / extinction;
+
+        lum += scatteringIntegral * transmittance;
+        transmittance *= sample_transmittance;
+    }
+
+    if (bounds.hits_ground) {
+
+        // Light bounced off the planet. Hillaire reaches this through
+        // IntegrateScatteredLuminance:
+        //     L += ... * throughput * NdotL * Atmosphere.GroundAlbedo / PI
+        // The surface is Lambertian, hence albedo/PI, and the cosine belongs to the hit
+        // point rather than to \`pos\`: along a shallow ray the two are hundreds of
+        // kilometres apart and can sit on opposite sides of the terminator.
+        let hit_up = normalize(rel + bounds.ground_distance * rayDir);
+
+        let sun_cos_zenith_angle = dot(hit_up, sunDir);
+
+        // the hit lies on the surface by construction, so its LUT altitude is exactly zero
+        let sun_transmittance = sample_transmittance_lut_params(0.0, sun_cos_zenith_angle);
+
+        lum += transmittance
+            * saturate(sun_cos_zenith_angle)
+            * (MULTISCATTER_GROUND_ALBEDO / PI)
+            * sun_transmittance;
+    }
+
+    *out_fms = lumFactor;
+    *out_lum = lum;
+
+}
+    `, [
+        PI_DECLARATION,
+        ATMOSPHERE_RADII_DECLARATION,
+        C_OZONE_DECLARATION,
+        C_MIE_SCATTERING_DECLARATION,
+        C_MIE_ABSORPTION_DECLARATION,
+        C_RAYLEIGH_DECLARATION,
+        chunk_atmosphere_density,
+        chunk_atmosphere_ray_bounds,
+        chunk_phase_mie_cornette_shanks,
+        chunk_phase_rayleigh,
+        chunk_position_relative_to_planet_center,
+        chunk_sample_transmittance_lut_params,
+    ]
+)

package/src/shade/renderer/atmosphere/chunk_multiscatter_sample_direction.d.ts

@@ -0,0 +1,20 @@
+/**
+ * The direction set the multiple-scattering LUT integrates over, one direction per index in
+ * `[0, MULTISCATTER_LUT_DIRECTION_COUNT)`. Stratified: midpoints of a uniform grid in
+ * azimuth, and of a uniform grid in the cosine of the polar angle, so every sample carries
+ * the same solid angle and a plain mean over the set is the spherical average that
+ * Equations (5) and (7) ask for.
+ *
+ * PRECONDITION: only valid when the sun lies in the y-z plane (`sunDir.x == 0`) and the
+ * sample position is on the +y axis through the planet centre. Azimuth spans [0, PI), not
+ * [0, 2*PI), which covers only the x >= 0 hemisphere; the mean over that half equals the
+ * mean over the whole sphere because reflecting x -> -x leaves both the sun direction and a
+ * spherically symmetric atmosphere unchanged. Hillaire integrates the full 2*PI precisely
+ * because his formulation does not lean on that. `shader_multiscatter_lut` satisfies the
+ * precondition by construction; a caller that does not must widen the azimuth.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_multiscatter_sample_direction: CodeChunk;
+import { CodeChunk } from "../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_multiscatter_sample_direction.d.ts.map

package/src/shade/renderer/atmosphere/chunk_multiscatter_sample_direction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_multiscatter_sample_direction.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/atmosphere/chunk_multiscatter_sample_direction.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;GAgBG;AACH,kDAFU,SAAS,CAwBjB;0BA1CwB,iCAAiC"}

package/src/shade/renderer/atmosphere/chunk_multiscatter_sample_direction.js

@@ -0,0 +1,46 @@
+import { chunk_spherical_to_cartesian } from "../shader/chunk/geometry/sphere/chunk_spherical_to_cartesian.js";
+import { chunk_safe_acos } from "../shader/chunk/math/chunk_safe_acos.js";
+import { PI_DECLARATION } from "../shader/chunk/math/PI_DECLARATION.js";
+import { CodeChunk } from "../shader/compiler/CodeChunk.js";
+import { MULTISCATTER_LUT_SQRT_SAMPLES } from "./MULTISCATTER_LUT_CONFIG.js";
+
+/**
+ * The direction set the multiple-scattering LUT integrates over, one direction per index in
+ * `[0, MULTISCATTER_LUT_DIRECTION_COUNT)`. Stratified: midpoints of a uniform grid in
+ * azimuth, and of a uniform grid in the cosine of the polar angle, so every sample carries
+ * the same solid angle and a plain mean over the set is the spherical average that
+ * Equations (5) and (7) ask for.
+ *
+ * PRECONDITION: only valid when the sun lies in the y-z plane (`sunDir.x == 0`) and the
+ * sample position is on the +y axis through the planet centre. Azimuth spans [0, PI), not
+ * [0, 2*PI), which covers only the x >= 0 hemisphere; the mean over that half equals the
+ * mean over the whole sphere because reflecting x -> -x leaves both the sun direction and a
+ * spherically symmetric atmosphere unchanged. Hillaire integrates the full 2*PI precisely
+ * because his formulation does not lean on that. `shader_multiscatter_lut` satisfies the
+ * precondition by construction; a caller that does not must widen the azimuth.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_multiscatter_sample_direction = CodeChunk.from(
+    //language=WGSL
+    `
+const MULTISCATTER_SQRT_SAMPLES = ${MULTISCATTER_LUT_SQRT_SAMPLES}u;
+const MULTISCATTER_SQRT_SAMPLES_F = f32(MULTISCATTER_SQRT_SAMPLES);
+
+fn multiscatter_sample_direction(index: u32) -> vec3<f32> {
+
+    let i = f32(index / MULTISCATTER_SQRT_SAMPLES);
+    let j = f32(index % MULTISCATTER_SQRT_SAMPLES);
+
+    // see the PRECONDITION note: half the azimuth, by symmetry about the sun plane
+    let theta = PI * (i + 0.5) / MULTISCATTER_SQRT_SAMPLES_F;
+    let phi = safe_acos(1.0 - 2.0 * (j + 0.5) / MULTISCATTER_SQRT_SAMPLES_F);
+
+    return spherical_to_cartesian(theta, phi);
+}
+    `, [
+        PI_DECLARATION,
+        chunk_safe_acos,
+        chunk_spherical_to_cartesian,
+    ]
+);

package/src/shade/renderer/atmosphere/chunk_sample_multiscatter_lut.d.ts

@@ -1,5 +1,15 @@
 /**
- * see {@link shader_multiscatter_lut}
+ * Assumes following in the context:
+ *      tSkyLutMultiscatter: texture_2d<f32>    (sample type "float", i.e. filterable)
+ *      sSkyLut: sampler                        (see {@link SAMPLER_SKY_LUT})
+ *
+ * see {@link shader_multiscatter_lut}, and {@link chunk_sample_transmittance_lut_params} for
+ * why this filters in hardware and reads its own resolution.
+ * @type {CodeChunk}
+ */
+export const chunk_sample_multiscatter_lut_params: CodeChunk;
+/**
+ * {@link chunk_sample_multiscatter_lut_params} from a world-space position.
  * @type {CodeChunk}
  */
 export const chunk_sample_multiscatter_lut: CodeChunk;

package/src/shade/renderer/atmosphere/chunk_sample_multiscatter_lut.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_sample_multiscatter_lut.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/atmosphere/chunk_sample_multiscatter_lut.js"],"names":[],"mappings":"AAMA;;;GAGG;AACH,4CAFU,SAAS,CAkBjB;0BAvBwB,iCAAiC"}
+{"version":3,"file":"chunk_sample_multiscatter_lut.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/atmosphere/chunk_sample_multiscatter_lut.js"],"names":[],"mappings":"AAIA;;;;;;;;GAQG;AACH,mDAFU,SAAS,CAsBjB;AAEF;;;GAGG;AACH,4CAFU,SAAS,CAmBjB;0BAxDwB,iCAAiC"}

package/src/shade/renderer/atmosphere/chunk_sample_multiscatter_lut.js

@@ -1,27 +1,57 @@
-import {
-    chunk_texture_sample_bilinear_uv
-} from "../shader/chunk/texture/sample/chunk_texture_sample_bilinear_uv.js";
-import { CodeChunk } from "../shader/compiler/CodeChunk.js";
-import { chunk_sky_lut_compute_uv } from "./chunk_sky_lut_compute_uv.js";
-
-/**
- * see {@link shader_multiscatter_lut}
- * @type {CodeChunk}
- */
-export const chunk_sample_multiscatter_lut = CodeChunk.from(
-//language=WGSL
-    `
-fn sample_multiscatter_lut(
-    pos:vec3<f32>,
-    sunDir:vec3<f32>
-) -> vec3<f32>{
-
-    let uv = sky_lut_compute_uv(pos, sunDir);
-        
-    return texture_sample_bilinear_uv(tSkyLutMultiscatter, uv, 0).rgb;
-}
-    `, [
-        chunk_sky_lut_compute_uv,
-        chunk_texture_sample_bilinear_uv
-    ]
-);
+import { CodeChunk } from "../shader/compiler/CodeChunk.js";
+import { chunk_sky_lut_params } from "./chunk_sky_lut_params.js";
+import { chunk_sky_lut_uv } from "./chunk_sky_lut_uv.js";
+
+/**
+ * Assumes following in the context:
+ *      tSkyLutMultiscatter: texture_2d<f32>    (sample type "float", i.e. filterable)
+ *      sSkyLut: sampler                        (see {@link SAMPLER_SKY_LUT})
+ *
+ * see {@link shader_multiscatter_lut}, and {@link chunk_sample_transmittance_lut_params} for
+ * why this filters in hardware and reads its own resolution.
+ * @type {CodeChunk}
+ */
+export const chunk_sample_multiscatter_lut_params = CodeChunk.from(
+//language=WGSL
+    `
+fn sample_multiscatter_lut_params(
+    height: f32,
+    sun_cos_zenith_angle: f32
+) -> vec3<f32>{
+
+    let uv = sky_lut_uv(
+        height,
+        sun_cos_zenith_angle,
+        vec2<f32>(textureDimensions(tSkyLutMultiscatter))
+    );
+
+    return textureSampleLevel(tSkyLutMultiscatter, sSkyLut, uv, 0.0).rgb;
+
+}
+    `, [
+        chunk_sky_lut_uv,
+    ]
+);
+
+/**
+ * {@link chunk_sample_multiscatter_lut_params} from a world-space position.
+ * @type {CodeChunk}
+ */
+export const chunk_sample_multiscatter_lut = CodeChunk.from(
+//language=WGSL
+    `
+fn sample_multiscatter_lut(
+    pos:vec3<f32>,
+    sunDir:vec3<f32>
+) -> vec3<f32>{
+
+    let params = sky_lut_params(pos, sunDir);
+
+    return sample_multiscatter_lut_params(params.x, params.y);
+
+}
+    `, [
+        chunk_sample_multiscatter_lut_params,
+        chunk_sky_lut_params,
+    ]
+);

package/src/shade/renderer/atmosphere/chunk_sample_transmittance_lut.d.ts

@@ -1,10 +1,28 @@
 /**
  * Assumes following in the context:
- *      tSkyLutTransmittance: texture_2d<f32>
+ *      tSkyLutTransmittance: texture_2d<f32>   (sample type "float", i.e. filterable)
+ *      sSkyLut: sampler                        (see {@link SAMPLER_SKY_LUT})
+ *
+ * The LUT is rgba16float, which is filterable in core WebGPU -- only the 32-bit float
+ * formats need the `float32-filterable` feature -- so this goes through the texture unit
+ * rather than the 4-tap `texture_sample_bilinear_uv`. Clamp-to-edge on the sampler
+ * reproduces that function's per-corner clamping.
+ *
+ * The half-texel inset {@link chunk_sky_lut_uv} applies needs the LUT's resolution, which is
+ * read from the binding rather than passed in: the texture is the authority on its own size,
+ * and a caller cannot get it wrong.
  *
  * see {@link shader_transmittance_lut}
  * @type {CodeChunk}
  */
+export const chunk_sample_transmittance_lut_params: CodeChunk;
+/**
+ * {@link chunk_sample_transmittance_lut_params} from a world-space position. A ray-march that
+ * already knows the altitude and the local up vector should build the pair itself and call
+ * the primitive, rather than have this recover them with another square root.
+ *
+ * @type {CodeChunk}
+ */
 export const chunk_sample_transmittance_lut: CodeChunk;
 import { CodeChunk } from "../shader/compiler/CodeChunk.js";
 //# sourceMappingURL=chunk_sample_transmittance_lut.d.ts.map

package/src/shade/renderer/atmosphere/chunk_sample_transmittance_lut.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_sample_transmittance_lut.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/atmosphere/chunk_sample_transmittance_lut.js"],"names":[],"mappings":"AAMA;;;;;;GAMG;AACH,6CAFU,SAAS,CAoBjB;0BA5BwB,iCAAiC"}
+{"version":3,"file":"chunk_sample_transmittance_lut.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/atmosphere/chunk_sample_transmittance_lut.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;GAgBG;AACH,oDAFU,SAAS,CAsBjB;AAEF;;;;;;GAMG;AACH,6CAFU,SAAS,CAoBjB;0BApEwB,iCAAiC"}