@woosh/meep-engine 3.65.0 → 3.68.0

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

@@ -0,0 +1,123 @@
+import { v3_quaternion_apply } from "../../../core/geom/vec3/v3_quaternion_apply.js";
+import { TRANSFORM64_ROTATION_OFFSET } from "../../../engine/ecs/transform/Transform64.js";
+import { light_pack_color } from "../light/model/io/light_pack_color.js";
+
+/**
+ * @typedef {import("../scene/Scene.js").Scene} Scene
+ */
+
+/**
+ * @typedef {Object} AtmosphereSunState
+ * @property {Float32Array} sun_direction world-space unit vector pointing **toward** the sun
+ * @property {Float32Array} sun_irradiance extraterrestrial RGB irradiance driving atmospheric scattering
+ * @property {number} sun_disk_radius angular half-radius of the solar disc in radians
+ * @property {number} sun_has_disc `1` when an explicit directional sun disc should be drawn, `0` otherwise
+ */
+
+const _forward = new Float64Array(3);
+const _packed_color = new Float32Array(3);
+
+/**
+ * Allocate a reusable {@link AtmosphereSunState} container so per-frame updates perform zero heap
+ * allocations.
+ *
+ * @returns {AtmosphereSunState}
+ */
+export function create_atmosphere_sun_state() {
+    return {
+        sun_direction: new Float32Array([0, 1, 0]),
+        sun_irradiance: new Float32Array(3),
+        sun_disk_radius: 0,
+        sun_has_disc: 0,
+    };
+}
+
+/**
+ * Resolve the active solar light driving {@link Scene#atmosphere}:
+ * 1. The first `DirectionalLight` in `scene.lights.elements`, using `-forward` as the direction
+ *    pointing **toward** the sun (`DirectionalLight` shines along `+Z` / `forward`).
+ * 2. Otherwise, when `atmosphere.fallback_sun_enabled` is true, the fallback sun configured on
+ *    {@link SceneAtmosphere} (with `sun_has_disc = 0` so sunless scenes get skylight IBL without
+ *    an unshadowed solar disc).
+ * 3. Otherwise, zero irradiance.
+ *
+ * @param {Scene} scene
+ * @param {AtmosphereSunState} [out]
+ * @returns {AtmosphereSunState}
+ */
+export function resolve_atmosphere_sun(scene, out = create_atmosphere_sun_state()) {
+    const atmosphere = scene.atmosphere;
+    const scale = Math.max(0, atmosphere.sun_irradiance_scale);
+    const lights = scene.lights.elements;
+
+    for (let i = 0; i < lights.length; i++) {
+        const light = lights[i];
+        if (light.isDirectionalLight !== true) {
+            continue;
+        }
+
+        const t = light.transform;
+        v3_quaternion_apply(
+            _forward, 0,
+            0, 0, 1,
+            t[TRANSFORM64_ROTATION_OFFSET],
+            t[TRANSFORM64_ROTATION_OFFSET + 1],
+            t[TRANSFORM64_ROTATION_OFFSET + 2],
+            t[TRANSFORM64_ROTATION_OFFSET + 3]
+        );
+
+        const len = Math.hypot(_forward[0], _forward[1], _forward[2]);
+        if (len > 1e-6) {
+            out.sun_direction[0] = -_forward[0] / len;
+            out.sun_direction[1] = -_forward[1] / len;
+            out.sun_direction[2] = -_forward[2] / len;
+        } else {
+            out.sun_direction[0] = 0;
+            out.sun_direction[1] = 1;
+            out.sun_direction[2] = 0;
+        }
+
+        light_pack_color(_packed_color, 0, light.color, Math.max(0, light.intensity));
+
+        out.sun_irradiance[0] = _packed_color[0] * scale;
+        out.sun_irradiance[1] = _packed_color[1] * scale;
+        out.sun_irradiance[2] = _packed_color[2] * scale;
+
+        const disk_radius = Math.max(0, light.radius);
+        out.sun_disk_radius = disk_radius;
+        out.sun_has_disc = disk_radius > 0 ? 1 : 0;
+        return out;
+    }
+
+    if (atmosphere.fallback_sun_enabled) {
+        const fb_dir = atmosphere.fallback_sun_direction;
+        const len = Math.hypot(fb_dir[0], fb_dir[1], fb_dir[2]);
+        if (len > 1e-6) {
+            out.sun_direction[0] = fb_dir[0] / len;
+            out.sun_direction[1] = fb_dir[1] / len;
+            out.sun_direction[2] = fb_dir[2] / len;
+        } else {
+            out.sun_direction[0] = 0;
+            out.sun_direction[1] = 1;
+            out.sun_direction[2] = 0;
+        }
+
+        const fb_irr = atmosphere.fallback_sun_irradiance;
+        out.sun_irradiance[0] = Math.max(0, fb_irr[0]) * scale;
+        out.sun_irradiance[1] = Math.max(0, fb_irr[1]) * scale;
+        out.sun_irradiance[2] = Math.max(0, fb_irr[2]) * scale;
+        out.sun_disk_radius = 0;
+        out.sun_has_disc = 0;
+        return out;
+    }
+
+    out.sun_direction[0] = 0;
+    out.sun_direction[1] = 1;
+    out.sun_direction[2] = 0;
+    out.sun_irradiance[0] = 0;
+    out.sun_irradiance[1] = 0;
+    out.sun_irradiance[2] = 0;
+    out.sun_disk_radius = 0;
+    out.sun_has_disc = 0;
+    return out;
+}

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

@@ -1 +1 @@
-{"version":3,"file":"shader_multiscatter_lut.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/atmosphere/shader_multiscatter_lut.js"],"names":[],"mappings":"AA+JA,oDAIG;8BA/J2B,4BAA4B"}
+{"version":3,"file":"shader_multiscatter_lut.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/atmosphere/shader_multiscatter_lut.js"],"names":[],"mappings":"AAoHA,oDAIG;8BArH2B,4BAA4B"}

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

@@ -1,9 +1,9 @@
 import { WebGPUExtensionType } from "../../descriptor/WebGPUExtensionType.js";
-import { ATMOSPHERE_HEIGHT_DECLARATION } from "../shader/chunk/atmosphere/ATMOSPHERE_HEIGHT_DECLARATION.js";
 import { chunk_safe_acos } from "../shader/chunk/math/chunk_safe_acos.js";
 import { CodeChunk } from "../shader/compiler/CodeChunk.js";
 import { ComputeShader } from "../shader/ComputeShader.js";
 import { ShaderResourceSetDescriptor } from "../shader/resource/ShaderResourceSetDescriptor.js";
+import { ATMOSPHERE_PARAMETERS_STRUCT } from "./ATMOSPHERE_PARAMETERS_STRUCT.js";
 import { chunk_get_multiscatter_values } from "./chunk_get_multiscatter_values.js";
 import { chunk_multiscatter_sample_direction } from "./chunk_multiscatter_sample_direction.js";
 import { chunk_sky_lut_texel_to_unit } from "./chunk_sky_lut_texel_to_unit.js";
@@ -11,36 +11,23 @@ import {
     MULTISCATTER_LUT_DIRECTION_COUNT,
     MULTISCATTER_LUT_MAX_SUBGROUP_PARTIALS
 } from "./MULTISCATTER_LUT_CONFIG.js";
-import { SAMPLER_SKY_LUT } from "./SAMPLER_SKY_LUT.js";
+import {
+    SKY_LUT_SAMPLER_RESOURCE,
+    SKY_LUT_TRANSMITTANCE_RESOURCE
+} from "./SAMPLER_SKY_LUT.js";
 
 const resources = new ShaderResourceSetDescriptor();
 resources.createGroup()
-    // "float" rather than the default "unfilterable-float": rgba16float is filterable in
-    // core WebGPU, so the LUT goes through the texture unit instead of a 4-tap manual
-    // bilinear.
-    .addTexture("tSkyLutTransmittance", "float")
-    .addSampler("sSkyLut", "filtering", SAMPLER_SKY_LUT)
-    .addStorageTexture("tSkyLutMultiscatterOut", "rgba16float")
-;
-
+    .addUniform("atmosphere", ATMOSPHERE_PARAMETERS_STRUCT)
+    .add(SKY_LUT_TRANSMITTANCE_RESOURCE)
+    .add(SKY_LUT_SAMPLER_RESOURCE)
+    .addStorageTexture("tSkyLutMultiscatterOut", "rgba16float");
 
 /**
- * the multiple-scattering LUT. Each pixel coordinate corresponds to a height and sun zenith angle, and
- * the value is the multiple scattering approximation (Psi_ms from the paper, Eq. 10).
- *
+ * Multiple-scattering LUT (`32×32` `rgba16float`, $\Psi_{\text{ms}}$ from Hillaire 2020 Eq. 10).
  * One workgroup per LUT texel, one thread per direction (64 threads per workgroup).
- * The 64 directions used to be a serial loop
- * inside a fragment shader, which left the whole pass with 32*32 = 1024 threads of
- * parallelism -- a few dozen waves, one per scheduler at best, with nothing to hide the
- * latency of the transmittance fetches. Per-thread it is now a single direction's 20-step
- * march.
- *
- * The per-direction results are summed with `subgroupAdd` and then across subgroups through
- * workgroup memory, collapsing a six-step groupshared log-reduction into one subgroup
- * instruction plus a handful of partials.
  *
  * @see "A Scalable and Production Ready Sky and Atmosphere Rendering Technique", Hillaire (2020)
- * @see https://www.shadertoy.com/view/slSXRW
  * @type {CodeChunk}
  */
 const body = CodeChunk.from(
@@ -58,56 +45,33 @@ fn main(
     @builtin(workgroup_id) workgroup_id: vec3<u32>,
     @builtin(local_invocation_index) thread_index: u32,
 ) {
-
     if (thread_index == 0u) {
         atomicStore(&wg_partial_count, 0u);
     }
 
-    // Every thread is here together anyway, so the counter's initialisation costs nothing
-    // beyond the barrier itself. WGSL does not promise workgroup variables start zeroed.
     workgroupBarrier();
 
-    // one workgroup per texel; the dispatch is sized from the texture, so this is in range
     let texel = workgroup_id.xy;
-
     let lut_size = vec2<f32>(textureDimensions(tSkyLutMultiscatterOut));
-
-    // The point of each range this texel stands for: texel 0 carries the bottom and the last
-    // texel the top, which is what lets a lookup at either end read a value computed there
-    // rather than one from half a texel inside. sky_lut_uv is the other half of this.
     let unit = sky_lut_texel_to_unit(vec2<f32>(texel), lut_size);
 
-    let sunCosTheta = 2.0*unit.x - 1.0;
+    let sunCosTheta = 2.0 * unit.x - 1.0;
     let sunTheta = safe_acos(sunCosTheta);
 
-    let height = ATMOSPHERE_HEIGHT*unit.y;
-
-    let pos = vec3(0.0, height, 0.0);
-    let sunDir = normalize(vec3(0.0, sunCosTheta, -sin(sunTheta)));
+    let height = atmosphere.atmosphere_height * unit.y;
 
-    // pos on the +y axis and sunDir with a zero x component are exactly the preconditions
-    // multiscatter_sample_direction's half-azimuth sample set needs
+    let origin_rel = vec3<f32>(0.0, atmosphere.planet_radius + height, 0.0);
+    let sunDir = normalize(vec3<f32>(0.0, sunCosTheta, -sin(sunTheta)));
     let rayDir = multiscatter_sample_direction(thread_index);
 
-    var lum:vec3<f32>;
-    var f_ms:vec3<f32>;
+    var lum: vec3<f32>;
+    var f_ms: vec3<f32>;
 
-    get_multiscatter_values(pos, sunDir, rayDir, &lum, &f_ms);
+    get_multiscatter_values_rel_for(atmosphere, origin_rel, sunDir, rayDir, &lum, &f_ms);
 
-    // Uniform control flow up to here, so every one of the workgroup's threads is an active
-    // lane and the subgroup sum covers all of them.
     let lum_subgroup = subgroupAdd(lum);
     let fms_subgroup = subgroupAdd(f_ms);
 
-    // subgroupElect picks exactly one active invocation per subgroup, and the slot it claims
-    // is whichever the counter hands out. Deriving the slot from local_invocation_index /
-    // subgroup_size instead would assume invocations are packed into subgroups in contiguous
-    // index order, which WGSL leaves unspecified: a mapping that is not contiguous blocks
-    // would collide two subgroups onto one slot and silently drop a partial sum. Which slot
-    // a subgroup lands in does not matter, only that it gets its own.
-    //
-    // Every lane holds the same subgroup sum, so letting them all store it would be a data
-    // race on one address even though the values agree.
     if (subgroupElect()) {
         let slot = atomicAdd(&wg_partial_count, 1u);
 
@@ -121,34 +85,27 @@ fn main(
         return;
     }
 
-    // WGSL pins the subgroup size to a power of two in [4, 128], so the workgroup cannot hold
-    // more subgroups than the partials array has room for. The clamp keeps a driver that
-    // broke that promise reading initialised slots rather than garbage.
     let partial_count = min(atomicLoad(&wg_partial_count), MULTISCATTER_MAX_SUBGROUP_PARTIALS);
 
-    var lum_total = vec3(0.0);
-    var fms_total = vec3(0.0);
+    var lum_total = vec3<f32>(0.0);
+    var fms_total = vec3<f32>(0.0);
 
     for (var i = 0u; i < partial_count; i++) {
         lum_total += wg_lum[i];
         fms_total += wg_fms[i];
     }
 
-    // The directions carry equal solid angle, so the mean over them is the spherical average
-    // the paper's uniform phase reduces to.
     let inv_samples = 1.0 / f32(MULTISCATTER_DIRECTION_COUNT);
 
     lum_total *= inv_samples;
     fms_total *= inv_samples;
 
-    // Equation 10 from the paper.
-    let psi = lum_total / (1.0 - fms_total);
+    let psi = lum_total / max(vec3<f32>(1.0) - fms_total, vec3<f32>(1e-4));
 
-    textureStore(tSkyLutMultiscatterOut, texel, vec4(psi, 1.0));
+    textureStore(tSkyLutMultiscatterOut, texel, vec4<f32>(psi, 1.0));
 }
     `, [
         chunk_safe_acos,
-        ATMOSPHERE_HEIGHT_DECLARATION,
         chunk_multiscatter_sample_direction,
         chunk_sky_lut_texel_to_unit,
         chunk_get_multiscatter_values,

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

@@ -1,9 +1,13 @@
 /**
- * Side of the sky irradiance map, skirt included: it is an environment map like any other, so its
- * level 0 carries the one-texel octahedral skirt (see `texture_octahedral_skirt_uv`).
+ * Default side of the scene's octahedral procedural sky map (including the one-texel octahedral
+ * skirt). $256 \times 256$ yields 9 mip levels (`256 >> 4 = 16 >= 3` at the roughest prefilter
+ * level) while baking in ~0.1 ms whenever the sun or atmosphere changes.
+ *
  * @type {number}
  */
 export const SKY_IRRADIANCE_LUT_RESOLUTION: number;
+export const SKY_IRRADIANCE_LUT_SETTINGS_STRUCT: WebGPUStruct;
 export const shader_sky_irradiance_lut: ImageShader;
+import { WebGPUStruct } from "../shader/type/WebGPUStruct.js";
 import { ImageShader } from "../shader/ImageShader.js";
 //# sourceMappingURL=shader_sky_irradiance_lut.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"shader_sky_irradiance_lut.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/atmosphere/shader_sky_irradiance_lut.js"],"names":[],"mappings":"AAiDA;;;;GAIG;AACH,4CAFU,MAAM,CAEkC;AAkKlD,oDAWG;4BAnMyB,0BAA0B"}
+{"version":3,"file":"shader_sky_irradiance_lut.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/atmosphere/shader_sky_irradiance_lut.js"],"names":[],"mappings":"AAqBA;;;;;;GAMG;AACH,4CAFU,MAAM,CAEiC;AAEjD,8DAK+B;AAyD/B,oDAWG;6BA5F0B,gCAAgC;4BAJjC,0BAA0B"}

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

@@ -1,31 +1,6 @@
-import { WebGPUArray } from "../shader/type/WebGPUArray.js";
-import { CAMERA_UNIFORM_STRUCT } from "../camera/CAMERA_UNIFORM_STRUCT.js";
-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 { ATMOSPHERE_RADII_DECLARATION } from "../shader/chunk/atmosphere/ATMOSPHERE_RADII_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 { PLANET_RADIUS_DECLARATION } from "../shader/chunk/atmosphere/PLANET_RADIUS_DECLARATION.js";
-import { chunk_mat4_extract_position } from "../shader/chunk/geometry/mat4/chunk_mat4_extract_position.js";
 import {
     chunk_uv_octahedral_unit_decode
 } from "../shader/chunk/geometry/octahedron/chunk_uv_octahedral_unit_decode.js";
-import { chunk_light_get_sun } from "../shader/chunk/light/sky/chunk_sample_sky_color.js";
-import { chunk_safe_acos } from "../shader/chunk/math/chunk_safe_acos.js";
-import { PI_DECLARATION } from "../shader/chunk/math/PI_DECLARATION.js";
 import {
     chunk_texture_octahedral_skirt_texel_uv
 } from "../shader/chunk/texture/octahedral/chunk_texture_octahedral_skirt_texel_uv.js";
@@ -33,128 +8,42 @@ import { CodeChunk } from "../shader/compiler/CodeChunk.js";
 import { ImageShader } from "../shader/ImageShader.js";
 import { ShaderResourceSetDescriptor } from "../shader/resource/ShaderResourceSetDescriptor.js";
 import { ShaderDescriptor } from "../shader/ShaderDescriptor.js";
+import { f32, u32, vec3f } from "../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUStruct } from "../shader/type/WebGPUStruct.js";
 import { ATMOSPHERE_ALTITUDE_CUTOFF } from "./ATMOSPHERE_ALTITUDE_CUTOFF.js";
-
-import { chunk_sample_multiscatter_lut_params } from "./chunk_sample_multiscatter_lut.js";
-import { chunk_sample_transmittance_lut_params } from "./chunk_sample_transmittance_lut.js";
-import { MIE_G } from "./MIE_G.js";
-import { SAMPLER_SKY_LUT } from "./SAMPLER_SKY_LUT.js";
+import { ATMOSPHERE_PARAMETERS_STRUCT } from "./ATMOSPHERE_PARAMETERS_STRUCT.js";
+import { chunk_raymarch_sky_scattering } from "./chunk_raymarch_sky_scattering.js";
+import {
+    SKY_LUT_MULTISCATTER_RESOURCE,
+    SKY_LUT_SAMPLER_RESOURCE,
+    SKY_LUT_TRANSMITTANCE_RESOURCE
+} from "./SAMPLER_SKY_LUT.js";
 
 /**
- * Ray-march steps per texel. Compile-time on purpose: as a uniform the march could not be
- * unrolled and its trip count had to be re-tested against an f32 every iteration.
+ * Default side of the scene's octahedral procedural sky map (including the one-texel octahedral
+ * skirt). $256 \times 256$ yields 9 mip levels (`256 >> 4 = 16 >= 3` at the roughest prefilter
+ * level) while baking in ~0.1 ms whenever the sun or atmosphere changes.
+ *
  * @type {number}
  */
-const SKY_IRRADIANCE_LUT_STEPS = 32;
+export const SKY_IRRADIANCE_LUT_RESOLUTION = 256;
 
-/**
- * Side of the sky irradiance map, skirt included: it is an environment map like any other, so its
- * level 0 carries the one-texel octahedral skirt (see `texture_octahedral_skirt_uv`).
- * @type {number}
- */
-export const SKY_IRRADIANCE_LUT_RESOLUTION = 1024;
+export const SKY_IRRADIANCE_LUT_SETTINGS_STRUCT = WebGPUStruct.from({
+    sun_direction: vec3f,
+    reference_altitude: f32,
+    sun_irradiance: vec3f,
+    resolution: u32,
+}, "SkyIrradianceLutSettings");
 
 const resources = new ShaderResourceSetDescriptor();
 
-resources.createGroup()
-    .addUniform("camera", CAMERA_UNIFORM_STRUCT)
-    // "float" rather than the default "unfilterable-float": both LUTs are rgba16float,
-    // which is filterable in core WebGPU, so they go through the texture unit rather than a
-    // 4-tap manual bilinear -- see chunk_sample_transmittance_lut.
-    .addTexture("tSkyLutTransmittance", "float")
-    .addTexture("tSkyLutMultiscatter", "float")
-    .addSampler("sSkyLut", "filtering", SAMPLER_SKY_LUT)
-;
+resources.setImmediate("settings", SKY_IRRADIANCE_LUT_SETTINGS_STRUCT);
 
 resources.createGroup()
-    .addStorageBuffer("light_data", WebGPUArray.u32)
-
-const chunk_raymarch_scattering = CodeChunk.from(
-    //language=WGSL
-    `
-const SKY_IRRADIANCE_STEPS = ${SKY_IRRADIANCE_LUT_STEPS}u;
-const SKY_IRRADIANCE_STEPS_F = f32(SKY_IRRADIANCE_STEPS);
-
-fn raymarch_scattering(
-    origin_rel: vec3<f32>,
-    ray_dir: vec3<f32>,
-    sun_dir: vec3<f32>,
-    tMax: f32
-) -> vec3<f32> {
-    let cosTheta = dot(ray_dir, sun_dir);
-    
-    let miePhaseValue = phase_mie(cosTheta, ${MIE_G});
-    let rayleighPhaseValue = phase_rayleigh(-cosTheta);
-    
-    var lum = vec3(0.0);
-    var transmittance = vec3(1.0);
-    
-    var t = 0.0;
-    for (var step_i = 0u; step_i < SKY_IRRADIANCE_STEPS; step_i++) {
-
-        let newT = ((f32(step_i) + 0.3)/SKY_IRRADIANCE_STEPS_F)*tMax;
-        let dt = newT - t;
-        t = newT;
-
-        // One square root for the whole step. Marching the planet-relative position yields
-        // the altitude and the up vector from the same length, and both LUT lookups take
-        // that pair directly -- each used to recover it from a world position of its own,
-        // which was three lengths and two normalizes per step for one step's worth of work.
-        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 - ATMOSPHERE_GROUND_RADIUS;
-        let sun_cos_zenith_angle = dot(sun_dir, up);
-
-        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;
-        
-        // Rayleigh does not absorb
-        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 );
-
-        let sun_transmittance = sample_transmittance_lut_params(local_height, sun_cos_zenith_angle);
-        let psiMS = sample_multiscatter_lut_params(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 );
-
-        // Integrated scattering within path segment.
-        let scattering_integral = ( in_scattering - in_scattering * sample_transmittance ) / extinction;
-
-        lum += scattering_integral * transmittance;
-        
-        transmittance *= sample_transmittance;
-    }
-    
-    return lum;
-}
-    `, [
-        ATMOSPHERE_RADII_DECLARATION,
-        chunk_atmosphere_density,
-        chunk_phase_mie_cornette_shanks,
-        chunk_phase_rayleigh,
-        chunk_sample_transmittance_lut_params,
-        chunk_sample_multiscatter_lut_params,
-        C_MIE_ABSORPTION_DECLARATION,
-        C_MIE_SCATTERING_DECLARATION,
-        C_OZONE_DECLARATION,
-        C_RAYLEIGH_DECLARATION,
-    ]
-);
+    .addUniform("atmosphere", ATMOSPHERE_PARAMETERS_STRUCT)
+    .add(SKY_LUT_TRANSMITTANCE_RESOURCE)
+    .add(SKY_LUT_MULTISCATTER_RESOURCE)
+    .add(SKY_LUT_SAMPLER_RESOURCE);
 
 const body = CodeChunk.from(
     //language=WGSL
@@ -164,53 +53,40 @@ fn main(
     @builtin(position) coord: vec4<f32>,
     @location(0) uv: vec2<f32>,
 ) -> @location(0) vec4<f32> {
-    
-	var actual_view_position = mat4_extract_position(camera.transform);
-	
-    let relative_position = position_relative_to_planet_center(actual_view_position);
-    
-    let up = normalize(relative_position);
-    
-    let height = length(relative_position);
-    
-    // force view into valid range
-    let clamped_height = clamp(height , PLANET_RADIUS + ${ATMOSPHERE_ALTITUDE_CUTOFF}, PLANET_RADIUS + ATMOSPHERE_HEIGHT - ${ATMOSPHERE_ALTITUDE_CUTOFF});
-    
-    // planet-relative, which is what both the bounds and the march want
-    let view_rel = up * clamped_height;
-
-    // skirt texels compute their interior twin's direction, so the skirt is a copy of it
-    let rayDir = uv_octahedral_unit_decode(texture_octahedral_skirt_texel_uv(vec2<u32>(coord.xy), ${SKY_IRRADIANCE_LUT_RESOLUTION}u));
-    
-    let sun = light_get_sun();
-    
-    let sunAltitude = ( 0.5 * PI ) - safe_acos( dot(-sun.direction, up) );
-    let sunDir = vec3(0.0, sin(sunAltitude), -cos(sunAltitude));
-    
-    // one quadratic setup for both spheres, rather than two calls sharing an origin and a
-    // centre that differ only in radius
-    let bounds = atmosphere_ray_bounds(view_rel, rayDir);
-
-    let lum = raymarch_scattering(view_rel, rayDir, sunDir, bounds.t_max);
-    
-    // TODO validate this, it "feels" wrong to me
-    let irradiance = lum * sun.color;
-    
-    return vec4(irradiance, 1.0);
+    let sun_len_sq = dot(settings.sun_direction, settings.sun_direction);
+    if (sun_len_sq <= 1e-12 || all(settings.sun_irradiance <= vec3<f32>(0.0))) {
+        return vec4<f32>(0.0, 0.0, 0.0, 1.0);
+    }
 
+    let sun_dir = settings.sun_direction * inverseSqrt(sun_len_sq);
+
+    let min_alt = ${ATMOSPHERE_ALTITUDE_CUTOFF.toFixed(1)} * METERS_TO_ATMOSPHERE_UNITS;
+    let max_alt = max(min_alt, atmosphere.atmosphere_height - min_alt);
+    let clamped_alt = clamp(settings.reference_altitude * METERS_TO_ATMOSPHERE_UNITS, min_alt, max_alt);
+    let view_rel = vec3<f32>(0.0, atmosphere.planet_radius + clamped_alt, 0.0);
+
+    // Skirt texels decode their interior twin's world direction so the one-texel border matches
+    // octahedral_skirt_matches without a separate copy pass.
+    let ray_dir = uv_octahedral_unit_decode(
+        texture_octahedral_skirt_texel_uv(vec2<u32>(coord.xy), settings.resolution)
+    );
+
+    let bounds = atmosphere_ray_bounds_for(atmosphere, view_rel, ray_dir);
+    let lum = raymarch_sky_scattering(
+        atmosphere,
+        view_rel,
+        ray_dir,
+        sun_dir,
+        bounds.t_max,
+        bounds.hits_ground
+    );
+
+    return vec4<f32>(lum * settings.sun_irradiance, 1.0);
 }
     `, [
-        chunk_safe_acos,
-        chunk_light_get_sun,
-        chunk_position_relative_to_planet_center,
-        chunk_mat4_extract_position,
-        PLANET_RADIUS_DECLARATION,
-        ATMOSPHERE_HEIGHT_DECLARATION,
-        PI_DECLARATION,
-        chunk_atmosphere_ray_bounds,
         chunk_uv_octahedral_unit_decode,
         chunk_texture_octahedral_skirt_texel_uv,
-        chunk_raymarch_scattering,
+        chunk_raymarch_sky_scattering,
     ]
 );
 
@@ -225,4 +101,4 @@ export const shader_sky_irradiance_lut = new ImageShader({
             format: "rgba16float"
         }
     ]
-});
+});

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

@@ -0,0 +1,7 @@
+export const SKY_VIEW_LUT_WIDTH: 192;
+export const SKY_VIEW_LUT_HEIGHT: 108;
+export const SKY_VIEW_LUT_SETTINGS_STRUCT: WebGPUStruct;
+export const shader_sky_view_lut: ImageShader;
+import { WebGPUStruct } from "../shader/type/WebGPUStruct.js";
+import { ImageShader } from "../shader/ImageShader.js";
+//# sourceMappingURL=shader_sky_view_lut.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"shader_sky_view_lut.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/atmosphere/shader_sky_view_lut.js"],"names":[],"mappings":"AAiBA,qCAAsC;AACtC,sCAAuC;AAEvC,wDAKyB;AAyEzB,8CAYG;6BAvG0B,gCAAgC;4BAJjC,0BAA0B"}