@woosh/meep-engine 3.42.0 → 3.43.0

package/src/shade/renderer/lightmap/bake/shader_lightmap_denoise_sh.js

@@ -39,8 +39,15 @@ fn estimate_sh_similarity(
     // extract dominant luma direction
     // Metro encodes SH coeffcients in axis-aligned way (L11, L1_1, L10) with L00 being in forth position (w)
     
-    let a_luma_direction = a.Y.xyz / a.Y.w;
-    let b_luma_direction = b.Y.xyz / b.Y.w;
+    // Zero DC is black and has no dominant direction.
+    var a_luma_direction = vec3<f32>(0.0);
+    var b_luma_direction = vec3<f32>(0.0);
+    if (a.Y.w != 0.0) {
+        a_luma_direction = a.Y.xyz / a.Y.w;
+    }
+    if (b.Y.w != 0.0) {
+        b_luma_direction = b.Y.xyz / b.Y.w;
+    }
 
     const DIRECTION_PHI = 10.0;
 
@@ -189,4 +196,4 @@ export const shader_lightmap_denoise_sh = ImageShader.from({
         resources,
     }),
     targets: LIGHTMAP_SH_COLOR_TARGETS_DESCRIPTOR
-})
+})

package/src/shade/renderer/loader/gltf/tiny-gltf.d.ts

@@ -13,7 +13,7 @@ export class TinyGltf {
      * @readonly
      * @type {TextureFormat}
      */
-    static readonly "__#264@#UNCOMPRESSED_TARGET": TextureFormat;
+    static readonly "__#265@#UNCOMPRESSED_TARGET": TextureFormat;
     /**
      * @param {AssetManager} assetManager
      * @param {AssetRequestScope} [scope]

package/src/shade/renderer/particles/DESIGN.md

@@ -791,14 +791,18 @@ it is evaluated per pixel (`chunk_particle_lighting`, the model in `chunk_partic
 a vertex need not be on screen, and one quad can span the frustum.
 
 - **Direct light comes from the froxel irradiance volume** (`volumetrics/chunk_volumetrics_irradiance_sh`),
-  which `shader_volumetrics_build_lighting` writes in the loop that lights the fog: every
-  directional, point and spot light at the froxel, shadowed, attenuated by the fog toward it, stored
-  as luma SH2 + constant chroma (Metro's L1 YCoCg, 6 coefficients in two `rgba16float` volumes, since
-  `rg16float` is not a storage format without `texture-formats-tier1`). The volume rides the
-  orchestrator to side channels as `volumetrics_irradiance`. Resolution is the fog's — 16 px tiles
-  and 64 slices — so light and shadow edges inside a particle are soft. idTech 8 builds the same
-  volume in the same pass (Sousa, SIGGRAPH 2025, p.29); Ghost of Tsushima lights particles from its
-  haze grid the same way. Chosen over per-pixel forward shading (UE's most expensive mode, and a
+  which `shader_volumetrics_build_irradiance` writes: every directional, point and spot light at a
+  point jittered through the froxel every frame, shadowed, stored as luma SH2 + constant chroma (Metro's L1 YCoCg, 6 coefficients
+  in two `rgba16float` volumes, since `rg16float` is not a storage format without
+  `texture-formats-tier1`). The volume rides the orchestrator to side channels as
+  `volumetrics_irradiance`. Resolution is the fog's froxel grid — 16 px tiles and 64 slices — so light
+  and shadow edges inside a particle are soft. idTech 8 builds the same volume (Sousa, SIGGRAPH 2025,
+  p.29); Ghost of Tsushima lights particles from its haze grid the same way. idTech 8 builds it in the
+  pass that lights its fog, and this one did too until 2026-10-09, dimming each light by the medium
+  on its way in. That tied particle lighting to the fog's whole chain (media, sun cascades, sky LUTs),
+  so the fog could not be skipped in a scene without volumes. It now has its own pass with no medium
+  in it: a lit particle is lit as the surfaces beside it are, which the deferred and forward paths
+  never dimmed either, and the fog is composited over both. Chosen over per-pixel forward shading (UE's most expensive mode, and a
   flat card lit that way goes black from behind), per-vertex/per-particle lighting (the light
   clusters are screen-space: a point off screen has no light list, the artefact that moved idTech 8
   off it) and a per-particle lighting atlas (DOOM 2016, CoD IW: best-looking, but it needs a
@@ -814,7 +818,7 @@ a vertex need not be on screen, and one quad can span the frustum.
 - **Indirect light is in the same volume**, whatever the renderer's `indirect_lighting_mode`. The
   froxel GI stage (`volumetrics/gi/`) starts the volume with one concrete module per mode — IBL,
   Brick4, LPV — each asking its source what radiance arrives at the froxel's centre, as RGB SH2,
-  and `shader_volumetrics_build_lighting` adds the lights to that. The particle knows no mode: a new
+  and `shader_volumetrics_build_irradiance` adds the lights to that. The particle knows no mode: a new
   GI system is one more module. IBL's source is `GPULightCollection.environment_sh`, the
   environment projected to radiance SH2 when it changes (`shader_project_environment_sh`); Brick4
   interpolates its probes (SH3, truncated) with a zero normal, which weighs every probe of the

package/src/shade/renderer/particles/shaders/chunk_particle_lighting.d.ts

@@ -4,7 +4,7 @@
  * returns what it reflects and transmits (`chunk_particle_lighting_model`), from the froxel
  * irradiance volume (`chunk_volumetrics_irradiance_sh`) at the fragment: the renderer's indirect
  * lighting, whichever mode it runs (the froxel GI stage, `volumetrics/gi/`), plus every directional,
- * point and spot light, shadowed, and attenuated by the fog on its way in. One trilinear read of each
+ * point and spot light, shadowed, as the surfaces around the particle receive them. One trilinear read of each
  * of its two textures, so the cost grows with neither the lights nor the GI; the price is resolution —
  * a froxel is 16 pixels across and a slice deep, and light and shadow edges inside a particle are that
  * soft.

package/src/shade/renderer/particles/shaders/chunk_particle_lighting.js

@@ -10,7 +10,7 @@ import { chunk_particle_lighting_model } from "./chunk_particle_lighting_model.j
  * returns what it reflects and transmits (`chunk_particle_lighting_model`), from the froxel
  * irradiance volume (`chunk_volumetrics_irradiance_sh`) at the fragment: the renderer's indirect
  * lighting, whichever mode it runs (the froxel GI stage, `volumetrics/gi/`), plus every directional,
- * point and spot light, shadowed, and attenuated by the fog on its way in. One trilinear read of each
+ * point and spot light, shadowed, as the surfaces around the particle receive them. One trilinear read of each
  * of its two textures, so the cost grows with neither the lights nor the GI; the price is resolution —
  * a froxel is 16 pixels across and a slice deep, and light and shadow edges inside a particle are that
  * soft.

package/src/shade/renderer/postprocess/nss/NSS.d.ts

@@ -53,7 +53,7 @@ export class NSS {
      * @returns {number}
      */
     static recommended_jitter_sequence_size(upscale_ratio: number): number;
-    static "__#192@#preprocess_tensor_descriptor"(render_w: any, render_h: any): TextureResourceDescriptor;
+    static "__#193@#preprocess_tensor_descriptor"(render_w: any, render_h: any): TextureResourceDescriptor;
     /**
      * @param {GraphicsContext} graphics
      */

package/src/shade/renderer/rasterize/native/avboit/AVBOITSideChannel.d.ts

@@ -99,8 +99,9 @@ export type AVBOITSideChannel = {
      * nothing into the volume passes `0`.
      * `volumetrics_irradiance` is what a fragment standing in a froxel is lit by
      * (`chunk_volumetrics_irradiance_sh`), for a channel whose fragments are lit: the renderer's
-     * indirect lighting, whichever mode it runs, and the scene's lights, shadowed and attenuated by
-     * the fog, written by the pass that lights the fog.
+     * indirect lighting, whichever mode it runs, and the scene's lights, shadowed — lit as the
+     * surfaces around it are, with no fog on the way in. Its own pass builds it, whether or not the
+     * scene has fog.
      */
     avboit_draw: (args: {
         graph: import("../../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph;

package/src/shade/renderer/rasterize/native/avboit/AVBOITSideChannel.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AVBOITSideChannel.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/AVBOITSideChannel.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAoCc,CAAC,IAAI,EAAE;QAAC,KAAK,EAAE,OAAO,iEAAiE,EAAE,UAAU,CAAC;QACjH,QAAc,EAAE,OAAO,iCAAiC,EAAE,cAAc,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QACzF,aAAmB,EAAE,MAAM,CAAC;QAAC,aAAa,EAAE,MAAM,CAAC;QAAC,cAAc,EAAE,MAAM,CAAC;QAC3E,WAAiB,EAAE,MAAM,CAAC;QAAC,mBAAmB,EAAE,MAAM,CAAC;QACvD,wBAA8B,EAAE,MAAM,CAAC;QAAC,oBAAoB,EAAE,MAAM,CAAC;QAAC,kBAAkB,EAAE,MAAM,CAAC;QACjG,eAAqB,EAAE,MAAM,CAAC;QAC9B,sBAA4B,EAAE,OAAO,uCAAuC,EAAE,yBAAyB,CAAC;KACrG,KAAK;QAAC,gBAAgB,CAAC,EAAE,MAAM,CAAA;KAAC;;;;;sBAKtB,CAAC,IAAI,EAAE;QACpB,KAAW,EAAE,OAAO,iEAAiE,EAAE,UAAU,CAAC;QAClG,MAAY,EAAE,MAAM,CAAC;QACrB,kBAAwB,EAAE,UAAU,MAAM,CAAC,CAAC;QAC5C,SAAe,EAAE,MAAM,CAAC;KACrB,KAAK,MAAM;;;;;;;;kBAED,CAAC,IAAI,EAAE;QACpB,KAAW,EAAE,OAAO,iEAAiE,EAAE,UAAU,CAAC;QAClG,MAAY,EAAE,MAAM,CAAC;QACrB,IAAU,EAAE,MAAM,CAAC;QACnB,aAAmB,EAAE,MAAM,CAAC;QAC5B,gBAAsB,EAAE,MAAM,EAAE,CAAC;QACjC,MAAY,EAAE;YAAC,UAAU,EAAE,MAAM,CAAC;YAAC,QAAQ,EAAE,MAAM,CAAC;YAAC,KAAK,EAAE,MAAM,CAAA;SAAC,CAAC;KACjE,KAAK;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAC;;;;;;;;;;;;;iBAKhD,CAAC,IAAI,EAAE;QACpB,KAAW,EAAE,OAAO,iEAAiE,EAAE,UAAU,CAAC;QAClG,QAAc,EAAE,OAAO,iCAAiC,EAAE,cAAc,CAAC;QACzE,MAAY,EAAE,MAAM,CAAC;QACrB,aAAmB,EAAE,MAAM,CAAC;QAC5B,IAAU,EAAE,MAAM,CAAC;QACnB,QAAc,EAAE,MAAM,CAAC;QACvB,eAAqB,EAAE,MAAM,CAAC;QAC9B,oBAA0B,EAAE,MAAM,CAAC;QACnC,sBAA4B,EAAE;YAAC,CAAC,EAAE,MAAM,CAAC;YAAC,IAAI,EAAE,MAAM,CAAA;SAAC,CAAC;QACxD,YAAkB,EAAE;YAAC,KAAK,EAAE,MAAM,CAAC;YAAC,IAAI,EAAE,MAAM,CAAC;YAAC,UAAU,EAAE,MAAM,CAAC;YAAC,QAAQ,EAAE,MAAM,CAAA;SAAC,CAAC;KACrF,KAAK;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAC;;;;;;sBAU9D,CAAC,IAAI,EAAE,OAAO,iCAAiC,EAAE,cAAc,KAAK,OAAO"}
+{"version":3,"file":"AVBOITSideChannel.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/native/avboit/AVBOITSideChannel.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAoCc,CAAC,IAAI,EAAE;QAAC,KAAK,EAAE,OAAO,iEAAiE,EAAE,UAAU,CAAC;QACjH,QAAc,EAAE,OAAO,iCAAiC,EAAE,cAAc,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QACzF,aAAmB,EAAE,MAAM,CAAC;QAAC,aAAa,EAAE,MAAM,CAAC;QAAC,cAAc,EAAE,MAAM,CAAC;QAC3E,WAAiB,EAAE,MAAM,CAAC;QAAC,mBAAmB,EAAE,MAAM,CAAC;QACvD,wBAA8B,EAAE,MAAM,CAAC;QAAC,oBAAoB,EAAE,MAAM,CAAC;QAAC,kBAAkB,EAAE,MAAM,CAAC;QACjG,eAAqB,EAAE,MAAM,CAAC;QAC9B,sBAA4B,EAAE,OAAO,uCAAuC,EAAE,yBAAyB,CAAC;KACrG,KAAK;QAAC,gBAAgB,CAAC,EAAE,MAAM,CAAA;KAAC;;;;;sBAKtB,CAAC,IAAI,EAAE;QACpB,KAAW,EAAE,OAAO,iEAAiE,EAAE,UAAU,CAAC;QAClG,MAAY,EAAE,MAAM,CAAC;QACrB,kBAAwB,EAAE,UAAU,MAAM,CAAC,CAAC;QAC5C,SAAe,EAAE,MAAM,CAAC;KACrB,KAAK,MAAM;;;;;;;;kBAED,CAAC,IAAI,EAAE;QACpB,KAAW,EAAE,OAAO,iEAAiE,EAAE,UAAU,CAAC;QAClG,MAAY,EAAE,MAAM,CAAC;QACrB,IAAU,EAAE,MAAM,CAAC;QACnB,aAAmB,EAAE,MAAM,CAAC;QAC5B,gBAAsB,EAAE,MAAM,EAAE,CAAC;QACjC,MAAY,EAAE;YAAC,UAAU,EAAE,MAAM,CAAC;YAAC,QAAQ,EAAE,MAAM,CAAC;YAAC,KAAK,EAAE,MAAM,CAAA;SAAC,CAAC;KACjE,KAAK;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAC;;;;;;;;;;;;;;iBAKhD,CAAC,IAAI,EAAE;QACpB,KAAW,EAAE,OAAO,iEAAiE,EAAE,UAAU,CAAC;QAClG,QAAc,EAAE,OAAO,iCAAiC,EAAE,cAAc,CAAC;QACzE,MAAY,EAAE,MAAM,CAAC;QACrB,aAAmB,EAAE,MAAM,CAAC;QAC5B,IAAU,EAAE,MAAM,CAAC;QACnB,QAAc,EAAE,MAAM,CAAC;QACvB,eAAqB,EAAE,MAAM,CAAC;QAC9B,oBAA0B,EAAE,MAAM,CAAC;QACnC,sBAA4B,EAAE;YAAC,CAAC,EAAE,MAAM,CAAC;YAAC,IAAI,EAAE,MAAM,CAAA;SAAC,CAAC;QACxD,YAAkB,EAAE;YAAC,KAAK,EAAE,MAAM,CAAC;YAAC,IAAI,EAAE,MAAM,CAAC;YAAC,UAAU,EAAE,MAAM,CAAC;YAAC,QAAQ,EAAE,MAAM,CAAA;SAAC,CAAC;KACrF,KAAK;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAC;;;;;;sBAW9D,CAAC,IAAI,EAAE,OAAO,iCAAiC,EAAE,cAAc,KAAK,OAAO"}

package/src/shade/renderer/rasterize/native/avboit/AVBOITSideChannel.js

@@ -84,8 +84,9 @@
  *     nothing into the volume passes `0`.
  *     `volumetrics_irradiance` is what a fragment standing in a froxel is lit by
  *     (`chunk_volumetrics_irradiance_sh`), for a channel whose fragments are lit: the renderer's
- *     indirect lighting, whichever mode it runs, and the scene's lights, shadowed and attenuated by
- *     the fog, written by the pass that lights the fog.
+ *     indirect lighting, whichever mode it runs, and the scene's lights, shadowed — lit as the
+ *     surfaces around it are, with no fog on the way in. Its own pass builds it, whether or not the
+ *     scene has fog.
  * @property {(view: import("../../../view/GPUViewContext.js").GPUViewContext) => boolean} [avboit_is_empty] whether the channel would add nothing for this view;
  *     asked before the orchestrator records, and a channel that answers `true` is not asked for
  *     anything else in that frame.

package/src/shade/renderer/scene/GPUSceneContext.d.ts

@@ -38,6 +38,13 @@ export class GPUSceneContext {
      */
     get scene(): Scene;
     get volumetrics(): GPUSceneVolumetrics;
+    /**
+     * Not necessarily current: a reader calls {@link GPUSky#update} first, which does the work the
+     * first time and nothing after.
+     *
+     * @returns {GPUSky}
+     */
+    get sky(): GPUSky;
     /**
      *
      * @returns {GPULightCollection}
@@ -186,7 +193,7 @@ export class GPUSceneContext {
      * Release this context's virtual geometry — everything {@link enable_virtual_geometry} built,
      * so that a host tears a scene down by destroying the renderer and nothing of the streaming loop
      * is left for it to find — then its rows, its database, its TLAS, its lights, its probe volume,
-     * its volumetrics, its volumetric light map, its animation and its skinning: every buffer the
+     * its volumetrics, its sky, its volumetric light map, its animation and its skinning: every buffer the
      * context made. Safe to call twice, and on a context that never enabled virtual geometry.
      */
     destroy(): void;
@@ -205,6 +212,7 @@ export type GPURecordWriter = import("../buffer/table/serde/generate_record_writ
 import { Brick4LightMap } from "../global_illumination/brick4/Brick4LightMap.js";
 import { Scene } from "./Scene.js";
 import { GPUSceneVolumetrics } from "../volumetrics/GPUSceneVolumetrics.js";
+import { GPUSky } from "../atmosphere/GPUSky.js";
 import { GPULightCollection } from "../light/GPULightCollection.js";
 import { GPULightProbeVolume } from "../global_illumination/lpv/GPULightProbeVolume.js";
 import { GPUInstancesAccelerationStructure } from "./GPUInstancesAccelerationStructure.js";

package/src/shade/renderer/scene/GPUSceneContext.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUSceneContext.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/scene/GPUSceneContext.js"],"names":[],"mappings":"AAqEA;;;;;;;;;GASG;AACH;IA0II;;;;OAIG;IACH,sBAHW,eAAe,SACf,KAAK,EAoCf;IA/KD;;;OAGG;IACH,aAFU,MAAM,CAEE;IAElB;;OAEG;IACH,YAFU,kBAAkB,CAEjB;IAEX;;OAEG;IACH,WAFU,kBAAkB,CAElB;IAGV;;OAEG;IACH,sBAFU,cAAc,CAEH;IASrB;;;OAGG;IACH,mBAEC;IAOD,uCAEC;IAQD;;;OAGG;IACH,iCAEC;IAOD;;;OAGG;IACH,8CAEC;IAOD;;;OAGG;IACH,8CAEC;IA8HD;;OAEG;IACH,kDAEC;IAED;;OAEG;IACH,gDAEC;IAED;;OAEG;IACH,kDAEC;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IACH;QAH0C,SAAS,GAAxC,oBAAoB;QAClB,yBAAyB,CAuDrC;IAED;;OAEG;IACH,6CAEC;IAYD;;;OAGG;IACH,kCAEC;IAED;;;;;OAKG;IACH,uCAEC;IAED;;;;;;;;;;;OAWG;IACH,uCAUC;IAED,+BAUC;IAED;;;;;;;;;;OAUG;IACH,yBAEC;IAED;;;;;OAKG;IACH,sCAMC;IAOD;;;;;;;OAOG;IACH,8EAEC;IA0BD;;;;;OAKG;IACH,cAsEC;IAED;;;OAGG;IACH,YAFW,eAAe,QA0BzB;IAED;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,cAHW,sBAAsB,cACtB,MAAM,QAuBhB;IAoCD;;;;;;OAMG;IACH,gBAiBC;IAoCL;;;OAGG;IACH,4BAFU,OAAO,CAE0B;;CAN1C;8BAzuBY,OAAO,uBAAuB,EAAE,eAAe;iCAC/C,OAAO,mCAAmC,EAAE,kBAAkB;iCAC9D,OAAO,mCAAmC,EAAE,kBAAkB;4BAC9D,OAAO,8BAA8B,EAAE,aAAa;8BACpD,OAAO,iDAAiD,EAAE,eAAe;+BAtBvD,iDAAiD;sBAI1D,YAAY;oCADE,uCAAuC;mCADxC,gCAAgC;oCAD/B,mDAAmD;kDAIrC,wCAAwC;0CAfhD,0DAA0D;8BAItE,8CAA8C;iCAF3C,iDAAiD;qCAG7C,qDAAqD;oCAGtD,qCAAqC;4BAC7C,gCAAgC;uCAOrB,iDAAiD;6BAM3D,wBAAwB;wCADb,mCAAmC;uCAdpC,wCAAwC"}
+{"version":3,"file":"GPUSceneContext.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/scene/GPUSceneContext.js"],"names":[],"mappings":"AAsEA;;;;;;;;;GASG;AACH;IA4JI;;;;OAIG;IACH,sBAHW,eAAe,SACf,KAAK,EAsCf;IAnMD;;;OAGG;IACH,aAFU,MAAM,CAEE;IAElB;;OAEG;IACH,YAFU,kBAAkB,CAEjB;IAEX;;OAEG;IACH,WAFU,kBAAkB,CAElB;IAGV;;OAEG;IACH,sBAFU,cAAc,CAEH;IASrB;;;OAGG;IACH,mBAEC;IAOD,uCAEC;IAUD;;;;;OAKG;IACH,kBAEC;IAQD;;;OAGG;IACH,iCAEC;IAOD;;;OAGG;IACH,8CAEC;IAOD;;;OAGG;IACH,8CAEC;IAgID;;OAEG;IACH,kDAEC;IAED;;OAEG;IACH,gDAEC;IAED;;OAEG;IACH,kDAEC;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IACH;QAH0C,SAAS,GAAxC,oBAAoB;QAClB,yBAAyB,CAuDrC;IAED;;OAEG;IACH,6CAEC;IAYD;;;OAGG;IACH,kCAEC;IAED;;;;;OAKG;IACH,uCAEC;IAED;;;;;;;;;;;OAWG;IACH,uCAUC;IAED,+BAUC;IAED;;;;;;;;;;OAUG;IACH,yBAEC;IAED;;;;;OAKG;IACH,sCAMC;IAOD;;;;;;;OAOG;IACH,8EAEC;IA0BD;;;;;OAKG;IACH,cAsEC;IAED;;;OAGG;IACH,YAFW,eAAe,QA0BzB;IAED;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,cAHW,sBAAsB,cACtB,MAAM,QAuBhB;IAoCD;;;;;;OAMG;IACH,gBAkBC;IAoCL;;;OAGG;IACH,4BAFU,OAAO,CAE0B;;CAN1C;8BA9vBY,OAAO,uBAAuB,EAAE,eAAe;iCAC/C,OAAO,mCAAmC,EAAE,kBAAkB;iCAC9D,OAAO,mCAAmC,EAAE,kBAAkB;4BAC9D,OAAO,8BAA8B,EAAE,aAAa;8BACpD,OAAO,iDAAiD,EAAE,eAAe;+BAvBvD,iDAAiD;sBAK1D,YAAY;oCADE,uCAAuC;uBAFpD,yBAAyB;mCACb,gCAAgC;oCAF/B,mDAAmD;kDAKrC,wCAAwC;0CAhBhD,0DAA0D;8BAItE,8CAA8C;iCAF3C,iDAAiD;qCAG7C,qDAAqD;oCAGtD,qCAAqC;4BAC7C,gCAAgC;uCAQrB,iDAAiD;6BAM3D,wBAAwB;wCADb,mCAAmC;uCAfpC,wCAAwC"}

package/src/shade/renderer/scene/GPUSceneContext.js

@@ -11,6 +11,7 @@ import { GPUAnimationManager } from "../animation/GPUAnimationManager.js";
 import { GPUDatabase } from "../buffer/table/GPUDatabase.js";
 import { Brick4LightMap } from "../global_illumination/brick4/Brick4LightMap.js";
 import { GPULightProbeVolume } from "../global_illumination/lpv/GPULightProbeVolume.js";
+import { GPUSky } from "../atmosphere/GPUSky.js";
 import { GPULightCollection } from "../light/GPULightCollection.js";
 import { GPUSceneVolumetrics } from "../volumetrics/GPUSceneVolumetrics.js";
 import { Scene } from "./Scene.js";
@@ -125,6 +126,24 @@ export class GPUSceneContext {
         return this.#volumetrics;
     }
 
+    /**
+     * The atmosphere's LUTs, built once for the scene and read by every view that needs them. They
+     * depend on the atmosphere's constants alone, so no view owns a copy.
+     *
+     * @type {GPUSky}
+     */
+    #sky;
+
+    /**
+     * Not necessarily current: a reader calls {@link GPUSky#update} first, which does the work the
+     * first time and nothing after.
+     *
+     * @returns {GPUSky}
+     */
+    get sky() {
+        return this.#sky;
+    }
+
     /**
      * @type {GPULightCollection}
      */
@@ -253,6 +272,8 @@ export class GPUSceneContext {
             scene.volumetrics
         );
 
+        this.#sky = new GPUSky(graphics);
+
         this.#animation_manager = new GPUAnimationManager(device, `GPUSceneContext[${this.id}]/Animation`, this);
     }
 
@@ -718,7 +739,7 @@ export class GPUSceneContext {
      * Release this context's virtual geometry — everything {@link enable_virtual_geometry} built,
      * so that a host tears a scene down by destroying the renderer and nothing of the streaming loop
      * is left for it to find — then its rows, its database, its TLAS, its lights, its probe volume,
-     * its volumetrics, its volumetric light map, its animation and its skinning: every buffer the
+     * its volumetrics, its sky, its volumetric light map, its animation and its skinning: every buffer the
      * context made. Safe to call twice, and on a context that never enabled virtual geometry.
      */
     destroy() {
@@ -733,6 +754,7 @@ export class GPUSceneContext {
         this.#lights.destroy();
         this.#light_probe_volume.destroy();
         this.#volumetrics.destroy();
+        this.#sky.destroy();
         this.volumetric_light_map.destroy();
         this.#animation_manager.destroy();
         if (this.#skinning !== null) {

package/src/shade/renderer/volumetrics/GPUViewVolumetrics.d.ts

@@ -34,7 +34,10 @@ export class GPUViewVolumetrics {
      *   module that starts the froxel irradiance volume
      * @returns {{resolved: number, metadata: number, irradiance: {Y: number, CoCg: number}}} the
      *   integrated aerial LUT, the metadata buffer, and the froxel irradiance volume
-     *   (chunk_volumetrics_irradiance_sh) for the transparent surfaces the lighting pass cannot see
+     *   (chunk_volumetrics_irradiance_sh) that lit particles are lit by. The two do not depend on
+     *   each other, and a pass building only one of them is culled when nothing reads it. A scene
+     *   with no participating-media volume records no fog at all, and `resolved` is then a constant:
+     *   no in-scatter, full transmittance.
      */
     graph_update({ graph, light_cluster_data, light_cluster_lookup, light_cluster_parameters, shadowmap_atlas, indirect_lighting_mode, }: {
         graph: FrameGraph;

package/src/shade/renderer/volumetrics/GPUViewVolumetrics.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUViewVolumetrics.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/volumetrics/GPUViewVolumetrics.js"],"names":[],"mappings":"AAiCA;IAkII;;;;OAIG;IACH,kBAHW,cAAc,qBAwBxB;IAxHD;;OAEG;IACH,4BAOC;IAjBD;;OAEG;IACH,2BAEC;IAsCD;;OAEG;IACH,0BAEC;IAZD;;OAEG;IACH,yBAEC;IAwFD,gBAWC;IA6ND;;;;;;;;;;;;;OAaG;IACH;QAX+B,KAAK,EAAzB,UAAU;QACM,kBAAkB,EAAlC,MAAM;QACU,oBAAoB,EAApC,MAAM;QACU,wBAAwB,EAAxC,MAAM;QACU,eAAe,EAA/B,MAAM;QACuE,sBAAsB,EAAnG,OAAO,iCAAiC,EAAE,yBAAyB;QAEjE;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE;YAAC,CAAC,EAAE,MAAM,CAAC;YAAC,IAAI,EAAE,MAAM,CAAA;SAAC,CAAA;KAAC,CAyFvF;;CAEJ;yBApfY,OAAO,2DAA2D,EAAE,UAAU;6BAC9E,OAAO,2BAA2B,EAAE,cAAc"}
+{"version":3,"file":"GPUViewVolumetrics.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/volumetrics/GPUViewVolumetrics.js"],"names":[],"mappings":"AAkCA;IA2II;;;;OAIG;IACH,kBAHW,cAAc,qBAyCxB;IAlJD;;OAEG;IACH,4BAOC;IAjBD;;OAEG;IACH,2BAEC;IAsCD;;OAEG;IACH,0BAEC;IAZD;;OAEG;IACH,yBAEC;IAkHD,gBAaC;IA6ND;;;;;;;;;;;;;;;;OAgBG;IACH;QAd+B,KAAK,EAAzB,UAAU;QACM,kBAAkB,EAAlC,MAAM;QACU,oBAAoB,EAApC,MAAM;QACU,wBAAwB,EAAxC,MAAM;QACU,eAAe,EAA/B,MAAM;QACuE,sBAAsB,EAAnG,OAAO,iCAAiC,EAAE,yBAAyB;QAEjE;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE;YAAC,CAAC,EAAE,MAAM,CAAC;YAAC,IAAI,EAAE,MAAM,CAAA;SAAC,CAAA;KAAC,CAmIvF;;CAEJ;yBA1jBY,OAAO,2DAA2D,EAAE,UAAU;6BAC9E,OAAO,2BAA2B,EAAE,cAAc"}

package/src/shade/renderer/volumetrics/GPUViewVolumetrics.js

@@ -10,6 +10,7 @@ import {
     build_volumetrics_sun_shadow_transform,
     volumetrics_sun_shadow_cascade_far
 } from "./build_volumetrics_sun_shadow_transform.js";
+import { graph_build_froxel_irradiance } from "./graph_build_froxel_irradiance.js";
 import { graph_build_volumetrics } from "./graph_build_volumetrics.js";
 import {
     VOLUMETRICS_SUN_SHADOW_CASCADE_COUNT,
@@ -151,6 +152,15 @@ export class GPUViewVolumetrics {
      */
     #sun_shadow_cascade_far = new Float32Array(4);
 
+    /**
+     * What the fog integrates to through no medium: nothing in-scattered (.rgb 0), everything
+     * transmitted (.a 1). Handed out in place of the aerial LUT on a frame whose scene has no
+     * participating-media volume, so every surface that samples the fog keeps doing so and reads
+     * it as none, for one texel and no pass. Written once, at construction.
+     * @type {GPUTextureContext}
+     */
+    #no_medium;
+
     /**
      * @type {GPUTypedBuffer}
      */
@@ -181,6 +191,23 @@ export class GPUViewVolumetrics {
             this.#volumetrics_textures[i] = texture;
         }
 
+        const no_medium = new GPUTextureContext(device);
+        no_medium.descriptor.label = "volumetrics/no medium";
+        no_medium.descriptor.format = "rgba16float";
+        no_medium.descriptor.dimension = "3d";
+        no_medium.descriptor.size = [1, 1, 1];
+        no_medium.descriptor.usage = GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_DST;
+
+        device.queue.writeTexture(
+            { texture: no_medium.gpu_texture },
+            new Float16Array([0, 0, 0, 1]),
+            { bytesPerRow: 8, rowsPerImage: 1 },
+            [1, 1, 1]
+        );
+        no_medium.incrementVersion();
+
+        this.#no_medium = no_medium;
+
         this.#metadata = GPUTypedBuffer.create({
             type: VOLUMETRICS_METADATA_STRUCT,
             device,
@@ -200,6 +227,8 @@ export class GPUViewVolumetrics {
             textures[i] = null;
         }
 
+        this.#no_medium.destroy();
+
     }
 
     #update_resolution() {
@@ -433,7 +462,10 @@ export class GPUViewVolumetrics {
      *   module that starts the froxel irradiance volume
      * @returns {{resolved: number, metadata: number, irradiance: {Y: number, CoCg: number}}} the
      *   integrated aerial LUT, the metadata buffer, and the froxel irradiance volume
-     *   (chunk_volumetrics_irradiance_sh) for the transparent surfaces the lighting pass cannot see
+     *   (chunk_volumetrics_irradiance_sh) that lit particles are lit by. The two do not depend on
+     *   each other, and a pass building only one of them is culled when nothing reads it. A scene
+     *   with no participating-media volume records no fog at all, and `resolved` is then a constant:
+     *   no in-scatter, full transmittance.
      */
     graph_update({
                      graph,
@@ -479,6 +511,35 @@ export class GPUViewVolumetrics {
 
         const resolution = this.#volumetrics_textures[0].size;
 
+        // Particle lighting first, and on its own: it reads no medium. The frame graph culls it when
+        // nothing reads it.
+        const irradiance = graph_build_froxel_irradiance({
+            graph,
+            camera,
+            view,
+            lights,
+            light_cluster_data,
+            light_cluster_lookup,
+            light_cluster_parameters,
+            shadowmap_atlas,
+            volumetrics_metadata: gr_metadata,
+            resolution,
+            indirect_lighting_mode,
+        });
+
+        if (view.scene.volumetrics.source.volumes.length === 0) {
+            // No medium: nothing scatters and nothing absorbs, so the fog is the identity everywhere
+            // and the passes that would integrate it to that are not recorded. Nothing accumulates
+            // either, which leaves the history stale for whenever a volume arrives.
+            this.#reset_history = true;
+
+            return {
+                resolved: graph_import_texture(graph, this.#no_medium, "volumetrics no medium"),
+                metadata: gr_metadata,
+                irradiance,
+            };
+        }
+
         // Ping-pong the two persistent froxel textures: this frame writes [parity] and reads the
         // previous frame's accumulation from [parity ^ 1]. On the first frame / after a resize the
         // history is invalid, which #update_metadata signals via history_reset (the TAA then emits
@@ -493,16 +554,26 @@ export class GPUViewVolumetrics {
             taa_output = graph_import_texture(graph, this.#volumetrics_textures[parity], "volumetrics taa output");
         }
 
-        const { lut_aerial, irradiance } = graph_build_volumetrics({
+        /*
+         The sun's transmittance and the multiple scattering are the scene sky's, built once and
+         read from here on. Brought current now rather than in a pass: the sky submits commands of
+         its own, which land ahead of this frame's -- recorded into the frame graph they would be
+         paid every frame, which is what they used to be. A no-op after the first call.
+        */
+        const sky = view.scene.sky;
+
+        sky.update();
+
+        const { lut_aerial } = graph_build_volumetrics({
             graph,
             camera,
             lights,
             view,
+            sky,
             light_cluster_data,
             light_cluster_lookup,
             light_cluster_parameters,
             shadowmap_atlas,
-            indirect_lighting_mode,
 
             volumetrics_metadata: gr_metadata,
             volumetric_resolution: resolution,