@woosh/meep-engine 3.65.0 → 3.68.0

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

@@ -1,119 +1,78 @@
-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 {
+    ATMOSPHERE_PARAMETERS_STRUCT,
+    chunk_atmosphere_parameters
+} from "./ATMOSPHERE_PARAMETERS_STRUCT.js";
+import { chunk_sample_transmittance_lut_params_for } from "./chunk_sample_transmittance_lut.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.
- *
- * `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.
+ * One direction's contribution to Equations (5) and (7) from Hillaire (2020): `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.
  *
  * @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>,
+fn get_multiscatter_values_rel_for(
+    atm: ${ATMOSPHERE_PARAMETERS_STRUCT.wgsl_ref},
+    rel: vec3<f32>,
     sunDir: vec3<f32>,
     rayDir: vec3<f32>,
-    out_lum: ptr<function,vec3<f32>>,
-    out_fms: ptr<function,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 bounds = atmosphere_ray_bounds_for(atm, rel, rayDir);
     let tMax = bounds.t_max;
 
     let cosTheta = dot(rayDir, sunDir);
+    let miePhaseValue = phase_mie(cosTheta, atm.mie_phase_g);
+    let rayleighPhaseValue = phase_rayleigh(cosTheta);
 
-    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 lum = vec3<f32>(0.0);
+    var lumFactor = vec3<f32>(0.0);
+    var transmittance = vec3<f32>(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 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;
-
-        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 local_height = step_radius - atm.planet_radius;
+        let local_density = atmosphere_density_for(atm, local_height);
 
+        let rayleigh_scattering = local_density.x * atm.rayleigh_scattering;
+        let mie_scattering = local_density.y * atm.mie_scattering;
+        let extinction = max(atmosphere_extinction_for(atm, local_density), vec3<f32>(1e-12));
 
         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 sun_transmittance = sample_transmittance_lut_params_for(atm, 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;
@@ -121,42 +80,46 @@ fn get_multiscatter_values(
     }
 
     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);
+        let sun_transmittance = sample_transmittance_lut_params_for(atm, 0.0, sun_cos_zenith_angle);
 
         lum += transmittance
             * saturate(sun_cos_zenith_angle)
-            * (MULTISCATTER_GROUND_ALBEDO / PI)
+            * (atm.ground_albedo / PI)
             * sun_transmittance;
     }
 
     *out_fms = lumFactor;
     *out_lum = lum;
+}
 
+fn get_multiscatter_values_for(
+    atm: ${ATMOSPHERE_PARAMETERS_STRUCT.wgsl_ref},
+    pos_ws: vec3<f32>,
+    sunDir: vec3<f32>,
+    rayDir: vec3<f32>,
+    out_lum: ptr<function, vec3<f32>>,
+    out_fms: ptr<function, vec3<f32>>,
+) {
+    let rel = atmosphere_position_relative_for(atm, pos_ws);
+    get_multiscatter_values_rel_for(atm, rel, sunDir, rayDir, out_lum, out_fms);
+}
+
+fn get_multiscatter_values(
+    pos_ws: vec3<f32>,
+    sunDir: vec3<f32>,
+    rayDir: vec3<f32>,
+    out_lum: ptr<function, vec3<f32>>,
+    out_fms: ptr<function, vec3<f32>>,
+) {
+    get_multiscatter_values_for(atmosphere_earth_parameters(), pos_ws, sunDir, rayDir, out_lum, out_fms);
 }
     `, [
         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_atmosphere_parameters,
         chunk_phase_mie_cornette_shanks,
         chunk_phase_rayleigh,
-        chunk_position_relative_to_planet_center,
-        chunk_sample_transmittance_lut_params,
+        chunk_sample_transmittance_lut_params_for,
     ]
-)
+);

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

@@ -0,0 +1,14 @@
+export const SKY_SCATTERING_RAYMARCH_STEPS: 32;
+/**
+ * Shared 32-step Hillaire (2020) sky radiance integrator (single scattering + isotropic
+ * multiple-scattering LUT $\Psi_{\text{ms}}$ + Lambertian planet ground bounce), returning radiance
+ * per unit extraterrestrial solar irradiance.
+ *
+ * Used by both {@link shader_sky_irradiance_lut} (scene-cached octahedral sky IBL) and
+ * {@link shader_sky_view_lut} (per-view $192 \times 108$ horizon-warped Sky-View LUT).
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_raymarch_sky_scattering: CodeChunk;
+import { CodeChunk } from "../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_raymarch_sky_scattering.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_raymarch_sky_scattering.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/atmosphere/chunk_raymarch_sky_scattering.js"],"names":[],"mappings":"AAaA,+CAAgD;AAEhD;;;;;;;;;GASG;AACH,4CAFU,SAAS,CA+EjB;0BAjGwB,iCAAiC"}

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

@@ -0,0 +1,103 @@
+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 {
+    ATMOSPHERE_PARAMETERS_STRUCT,
+    chunk_atmosphere_parameters
+} from "./ATMOSPHERE_PARAMETERS_STRUCT.js";
+import { chunk_sample_multiscatter_lut_params_for } from "./chunk_sample_multiscatter_lut.js";
+import { chunk_sample_transmittance_lut_params_for } from "./chunk_sample_transmittance_lut.js";
+
+export const SKY_SCATTERING_RAYMARCH_STEPS = 32;
+
+/**
+ * Shared 32-step Hillaire (2020) sky radiance integrator (single scattering + isotropic
+ * multiple-scattering LUT $\Psi_{\text{ms}}$ + Lambertian planet ground bounce), returning radiance
+ * per unit extraterrestrial solar irradiance.
+ *
+ * Used by both {@link shader_sky_irradiance_lut} (scene-cached octahedral sky IBL) and
+ * {@link shader_sky_view_lut} (per-view $192 \times 108$ horizon-warped Sky-View LUT).
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_raymarch_sky_scattering = CodeChunk.from(
+    //language=WGSL
+    `
+const SKY_SCATTERING_STEPS = ${SKY_SCATTERING_RAYMARCH_STEPS}u;
+const SKY_SCATTERING_STEPS_F = f32(SKY_SCATTERING_STEPS);
+
+fn raymarch_sky_scattering(
+    atm: ${ATMOSPHERE_PARAMETERS_STRUCT.wgsl_ref},
+    origin_rel: vec3<f32>,
+    ray_dir: vec3<f32>,
+    sun_dir: vec3<f32>,
+    t_max: f32,
+    hits_ground: bool
+) -> vec3<f32> {
+    let cosTheta = dot(ray_dir, sun_dir);
+
+    let miePhaseValue = phase_mie(cosTheta, atm.mie_phase_g);
+    let rayleighPhaseValue = phase_rayleigh(cosTheta);
+
+    var lum = vec3<f32>(0.0);
+    var transmittance = vec3<f32>(1.0);
+
+    var t = 0.0;
+    for (var step_i = 0u; step_i < SKY_SCATTERING_STEPS; step_i++) {
+        let newT = ((f32(step_i) + 0.3) / SKY_SCATTERING_STEPS_F) * t_max;
+        let dt = newT - t;
+        t = newT;
+
+        let step_rel = origin_rel + t * ray_dir;
+        let step_radius = length(step_rel);
+        let up = step_rel / step_radius;
+
+        let local_height = step_radius - atm.planet_radius;
+        let sun_cos_zenith_angle = dot(sun_dir, up);
+
+        let local_density = atmosphere_density_for(atm, local_height);
+
+        let rayleigh_scattering = local_density.x * atm.rayleigh_scattering;
+        let mie_scattering = local_density.y * atm.mie_scattering;
+        let extinction = max(atmosphere_extinction_for(atm, local_density), vec3<f32>(1e-12));
+
+        let sample_transmittance = exp(-dt * extinction);
+
+        let sun_transmittance = sample_transmittance_lut_params_for(atm, local_height, sun_cos_zenith_angle);
+        let psiMS = sample_multiscatter_lut_params_for(atm, local_height, sun_cos_zenith_angle);
+
+        let rayleigh_in_scattering = rayleigh_scattering * (rayleighPhaseValue * sun_transmittance + psiMS);
+        let mie_in_scattering = mie_scattering * (miePhaseValue * sun_transmittance + psiMS);
+        let in_scattering = rayleigh_in_scattering + mie_in_scattering;
+
+        let scattering_integral = (in_scattering - in_scattering * sample_transmittance) / extinction;
+
+        lum += scattering_integral * transmittance;
+        transmittance *= sample_transmittance;
+    }
+
+    if (hits_ground) {
+        let hit_up = normalize(origin_rel + t_max * ray_dir);
+        let sun_cos_zenith_angle = dot(hit_up, sun_dir);
+        let sun_transmittance = sample_transmittance_lut_params_for(atm, 0.0, sun_cos_zenith_angle);
+        let psi_ground = sample_multiscatter_lut_params_for(atm, 0.0, sun_cos_zenith_angle);
+
+        let direct_bounce = saturate(sun_cos_zenith_angle) * sun_transmittance * (1.0 / PI);
+        let diffuse_bounce = psi_ground;
+        lum += transmittance * atm.ground_albedo * (direct_bounce + diffuse_bounce);
+    }
+
+    return max(lum, vec3<f32>(0.0));
+}
+    `, [
+        PI_DECLARATION,
+        chunk_atmosphere_parameters,
+        chunk_phase_mie_cornette_shanks,
+        chunk_phase_rayleigh,
+        chunk_sample_transmittance_lut_params_for,
+        chunk_sample_multiscatter_lut_params_for,
+    ]
+);

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

@@ -1,10 +1,16 @@
 /**
- * Assumes following in the context:
- *      tSkyLutMultiscatter: texture_2d<f32>    (sample type "float", i.e. filterable)
+ * Parameterised multiple-scattering LUT lookup using `atm.atmosphere_height`.
+ *
+ * Assumes in shader scope:
+ *      tSkyLutMultiscatter: texture_2d<f32>    (sample type "float", 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_for: CodeChunk;
+/**
+ * Earth-default multiple-scattering LUT lookup by `(height, sun_cos_zenith_angle)`.
+ *
  * @type {CodeChunk}
  */
 export const chunk_sample_multiscatter_lut_params: 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":"AAIA;;;;;;;;GAQG;AACH,mDAFU,SAAS,CAsBjB;AAEF;;;GAGG;AACH,4CAFU,SAAS,CAmBjB;0BAxDwB,iCAAiC"}
+{"version":3,"file":"chunk_sample_multiscatter_lut.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/atmosphere/chunk_sample_multiscatter_lut.js"],"names":[],"mappings":"AASA;;;;;;;;GAQG;AACH,uDAFU,SAAS,CAsBjB;AAKF;;;;GAIG;AACH,mDAFU,SAAS,CAsBjB;AAKF;;;GAGG;AACH,4CAFU,SAAS,CAmBjB;0BA9FwB,iCAAiC"}

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

@@ -1,57 +1,95 @@
-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,
-    ]
-);
+import { CodeChunk } from "../shader/compiler/CodeChunk.js";
+import {
+    ATMOSPHERE_PARAMETERS_STRUCT,
+    chunk_atmosphere_parameters
+} from "./ATMOSPHERE_PARAMETERS_STRUCT.js";
+import { chunk_sky_lut_params } from "./chunk_sky_lut_params.js";
+import { chunk_sky_lut_uv } from "./chunk_sky_lut_uv.js";
+import { SKY_LUT_MULTISCATTER_RESOURCE, SKY_LUT_SAMPLER_RESOURCE } from "./SAMPLER_SKY_LUT.js";
+
+/**
+ * Parameterised multiple-scattering LUT lookup using `atm.atmosphere_height`.
+ *
+ * Assumes in shader scope:
+ *      tSkyLutMultiscatter: texture_2d<f32>    (sample type "float", filterable)
+ *      sSkyLut: sampler                        (see {@link SAMPLER_SKY_LUT})
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_sample_multiscatter_lut_params_for = CodeChunk.from(
+    //language=WGSL
+    `
+fn sample_multiscatter_lut_params_for(
+    atm: ${ATMOSPHERE_PARAMETERS_STRUCT.wgsl_ref},
+    height: f32,
+    sun_cos_zenith_angle: f32
+) -> vec3<f32> {
+    let uv = sky_lut_uv_for(
+        atm,
+        height,
+        sun_cos_zenith_angle,
+        vec2<f32>(textureDimensions(tSkyLutMultiscatter))
+    );
+
+    return textureSampleLevel(tSkyLutMultiscatter, sSkyLut, uv, 0.0).rgb;
+}
+    `, [
+        chunk_atmosphere_parameters,
+    ]
+);
+
+chunk_sample_multiscatter_lut_params_for.requireResource(SKY_LUT_MULTISCATTER_RESOURCE);
+chunk_sample_multiscatter_lut_params_for.requireResource(SKY_LUT_SAMPLER_RESOURCE);
+
+/**
+ * Earth-default multiple-scattering LUT lookup by `(height, sun_cos_zenith_angle)`.
+ *
+ * @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,
+    ]
+);
+
+chunk_sample_multiscatter_lut_params.requireResource(SKY_LUT_MULTISCATTER_RESOURCE);
+chunk_sample_multiscatter_lut_params.requireResource(SKY_LUT_SAMPLER_RESOURCE);
+
+/**
+ * {@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,25 +1,21 @@
 /**
- * Assumes following in the context:
- *      tSkyLutTransmittance: texture_2d<f32>   (sample type "float", i.e. filterable)
- *      sSkyLut: sampler                        (see {@link SAMPLER_SKY_LUT})
+ * Parameterised transmittance LUT lookup using `atm.atmosphere_height`.
  *
- * 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.
+ * Assumes in shader scope:
+ *      tSkyLutTransmittance: texture_2d<f32>   (sample type "float", filterable)
+ *      sSkyLut: sampler                        (see {@link SAMPLER_SKY_LUT})
  *
- * 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.
+ * @type {CodeChunk}
+ */
+export const chunk_sample_transmittance_lut_params_for: CodeChunk;
+/**
+ * Earth-default transmittance LUT lookup by `(height, sun_cos_zenith_angle)`.
  *
- * 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.
+ * {@link chunk_sample_transmittance_lut_params} from a world-space position.
  *
  * @type {CodeChunk}
  */

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":"AAIA;;;;;;;;;;;;;;;;GAgBG;AACH,oDAFU,SAAS,CAsBjB;AAEF;;;;;;GAMG;AACH,6CAFU,SAAS,CAoBjB;0BApEwB,iCAAiC"}
+{"version":3,"file":"chunk_sample_transmittance_lut.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/atmosphere/chunk_sample_transmittance_lut.js"],"names":[],"mappings":"AASA;;;;;;;;GAQG;AACH,wDAFU,SAAS,CAsBjB;AAKF;;;;GAIG;AACH,oDAFU,SAAS,CAsBjB;AAKF;;;;GAIG;AACH,6CAFU,SAAS,CAoBjB;0BAhGwB,iCAAiC"}