@woosh/meep-engine 3.67.0 → 3.68.0

package/package.json

@@ -6,7 +6,7 @@
   "description": "Advanced 3D game engine",
   "type": "module",
   "author": "Alexander Goldring",
-  "version": "3.67.0",
+  "version": "3.68.0",
   "exports": {
     "./build/*": "./build/*",
     "./src/*": "./src/*",

package/src/engine/graphics3/GraphicsEngine.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GraphicsEngine.d.ts","sourceRoot":"","sources":["../../../../src/engine/graphics3/GraphicsEngine.js"],"names":[],"mappings":"AA2DA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH;IACI;;;;;OAKG;IACH,gCAEC;IAUD;;;;OAIG;IACH,yBAEC;IAmEG;;;;;;OAMG;IACH,QAFU,kBAAkB,CAEsB;IAElD;QACI;;;;;;;;WAQG;mBADO,MAAM;QAIhB;;;;;WAKG;oBADO,MAAM;QAIhB;;;;WAIG;qBADO,MAAM;QAIhB;;;;;;;WAOG;;QAGH;;;;;WAKG;;MAEN;IAID;;;;;OAKG;IACH,4BAFU,OAAO,CAEyB;IAE1C;;;;;;OAMG;IACH,UAFU,SAAS,CAEY;IAG/B;;OAEG;IACH,YAFU,iBAAiB,GAAC,IAAI,CAEV;IAEtB;;;;;OAKG;IACH,UAFU,OAAO,CAEG;IAEpB;;;;;OAKG;IACH,UAFU,OAAO,CAEG;IAEpB;;OAEG;IACH,YAFU,MAAM,CAEG;IAoBvB;;;;;;;;;;;;OAYG;IACH,mDAEC;IAED;;;;;;;;OAQG;IACH,iBAFW,KAAK,QAoBf;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,6BAFW,YAAY,QAStB;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,yBAHW,eAAe,GACb,eAAe,CAa3B;IAED;;;;;;;;;;OAUG;IACH,uBAHW,UAAU,GACR,MAAM,CAclB;IAED;;;;;;OAMG;IACH,4BAHW,eAAe,GACb,OAAO,CAgBnB;IAED;;;;;;;;;;;;;OAaG;IACH,kCAHW,iBAAiB,GACf,iBAAiB,CAqB7B;IAED;;;;;;OAMG;IACH,8BAFa,MAAM,CAIlB;IAED;;;;;OAKG;IACH,qCAHW,iBAAiB,GACf,OAAO,CAgBnB;IAED;;;;;;;;;;;;;;;;;;OAkBG;IACH,qBALW,KAAK,GACH,eAAe,GAAC,IAAI,CAehC;IAED;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,yBARW,KAAK,UACL,MAAM,SACN,MAAM,UACN,MAAM,GACJ,QAAQ,SAAS,CAAC,CAwD9B;IAED;;;;OAIG;IACH,0BAEC;IAED;;;;;;;;;;OAUG;IACH,SAFa,QAAQ,IAAI,CAAC,CAuDzB;IAED;;;;;;;;;;;;;;;OAeG;IACH,qBAFW,iBAAiB,QAc3B;IAED;;;;;OAKG;IACH,aAiBC;IASD;;;;;;;;OAQG;IACH,8BAHW,OAAO,GAAC,OAAO,UACf,OAAO,GAAC,OAAO,QAQzB;IAED;;;;;;;;;;;;;;;OAeG;IACH,yBALW,MAAM,KACN,MAAM,UACN,OAAO,aACP,OAAO,QAIjB;IAED;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,mBAyBC;IAED;;;;;;;;;OASG;IACH,4BAPW,MAAM,GAKJ,OAAO,CA2DnB;;CACJ;sBA74BY,OAAO,4BAA4B,EAAE,OAAO;yBAC5C,OAAO,8CAA8C,EAAE,UAAU;8BACjE,OAAO,mDAAmD,EAAE,eAAe;gCAC3E,OAAO,mEAAmE,EAAE,iBAAiB;8BAC7F,OAAO,+CAA+C,EAAE,eAAe;2BACvE,OAAO,8CAA8C,EAAE,YAAY;qBACnE,OAAO,kCAAkC,EAAE,MAAM;yBAfrC,kCAAkC;mCAMxB,yBAAyB;mBAZzC,oCAAoC;wBAC/B,4BAA4B;sBAQ9B,kCAAkC;yCAJf,kDAAkD;sBAErE,qCAAqC;0BACjC,0CAA0C"}
+{"version":3,"file":"GraphicsEngine.d.ts","sourceRoot":"","sources":["../../../../src/engine/graphics3/GraphicsEngine.js"],"names":[],"mappings":"AA0DA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH;IACI;;;;;OAKG;IACH,gCAEC;IAUD;;;;OAIG;IACH,yBAEC;IAmEG;;;;;;OAMG;IACH,QAFU,kBAAkB,CAEsB;IAElD;QACI;;;;;;;;WAQG;mBADO,MAAM;QAIhB;;;;;WAKG;oBADO,MAAM;QAIhB;;;;WAIG;qBADO,MAAM;QAIhB;;;;;;;WAOG;;QAGH;;;;;WAKG;;MAEN;IAID;;;;;OAKG;IACH,4BAFU,OAAO,CAEyB;IAE1C;;;;;;OAMG;IACH,UAFU,SAAS,CAEY;IAG/B;;OAEG;IACH,YAFU,iBAAiB,GAAC,IAAI,CAEV;IAEtB;;;;;OAKG;IACH,UAFU,OAAO,CAEG;IAEpB;;;;;OAKG;IACH,UAFU,OAAO,CAEG;IAEpB;;OAEG;IACH,YAFU,MAAM,CAEG;IAoBvB;;;;;;;;;;;;OAYG;IACH,mDAEC;IAED;;;;;;;;OAQG;IACH,iBAFW,KAAK,QAgBf;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,6BAFW,YAAY,QAStB;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,yBAHW,eAAe,GACb,eAAe,CAa3B;IAED;;;;;;;;;;OAUG;IACH,uBAHW,UAAU,GACR,MAAM,CAclB;IAED;;;;;;OAMG;IACH,4BAHW,eAAe,GACb,OAAO,CAgBnB;IAED;;;;;;;;;;;;;OAaG;IACH,kCAHW,iBAAiB,GACf,iBAAiB,CAqB7B;IAED;;;;;;OAMG;IACH,8BAFa,MAAM,CAIlB;IAED;;;;;OAKG;IACH,qCAHW,iBAAiB,GACf,OAAO,CAgBnB;IAED;;;;;;;;;;;;;;;;;;OAkBG;IACH,qBALW,KAAK,GACH,eAAe,GAAC,IAAI,CAehC;IAED;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,yBARW,KAAK,UACL,MAAM,SACN,MAAM,UACN,MAAM,GACJ,QAAQ,SAAS,CAAC,CAwD9B;IAED;;;;OAIG;IACH,0BAEC;IAED;;;;;;;;;;OAUG;IACH,SAFa,QAAQ,IAAI,CAAC,CAuDzB;IAED;;;;;;;;;;;;;;;OAeG;IACH,qBAFW,iBAAiB,QAc3B;IAED;;;;;OAKG;IACH,aAiBC;IASD;;;;;;;;OAQG;IACH,8BAHW,OAAO,GAAC,OAAO,UACf,OAAO,GAAC,OAAO,QAQzB;IAED;;;;;;;;;;;;;;;OAeG;IACH,yBALW,MAAM,KACN,MAAM,UACN,OAAO,aACP,OAAO,QAIjB;IAED;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,mBAyBC;IAED;;;;;;;;;OASG;IACH,4BAPW,MAAM,GAKJ,OAAO,CA2DnB;;CACJ;sBAz4BY,OAAO,4BAA4B,EAAE,OAAO;yBAC5C,OAAO,8CAA8C,EAAE,UAAU;8BACjE,OAAO,mDAAmD,EAAE,eAAe;gCAC3E,OAAO,mEAAmE,EAAE,iBAAiB;8BAC7F,OAAO,+CAA+C,EAAE,eAAe;2BACvE,OAAO,8CAA8C,EAAE,YAAY;qBACnE,OAAO,kCAAkC,EAAE,MAAM;yBAdrC,kCAAkC;mCAKxB,yBAAyB;mBAXzC,oCAAoC;wBAC/B,4BAA4B;sBAQ9B,kCAAkC;yCAJf,kDAAkD;sBAErE,qCAAqC;0BACjC,0CAA0C"}

package/src/engine/graphics3/GraphicsEngine.js

@@ -9,7 +9,6 @@ import { Renderer } from "../../shade/renderer/Renderer.js";
 import { Scene } from "../../shade/renderer/scene/Scene.js";
 import { Sampler2D } from "../graphics/texture/sampler/Sampler2D.js";
 import EmptyView from "../../view/elements/EmptyView.js";
-import { make_default_environment } from "./make_default_environment.js";
 import { shade_camera_projection_ray } from "./shade_camera_projection_ray.js";
 import { ShadeCameraAdapter } from "./ShadeCameraAdapter.js";
 
@@ -334,16 +333,12 @@ export class GraphicsEngine {
         this.#scene = scene;
 
         /*
-         Shade lights with indirect by default and a scene without an environment renders unlit, so
-         the engine supplies one rather than leaving every caller to. Turning global illumination off
-         is the thing that takes a decision, not turning it on.
-
-         A scene that arrives with an environment keeps it: the scene owns its lighting and this only
-         fills in what is missing. Otherwise handing over a scene would silently discard the
-         environment it was built with, and the fix would be to call things in a particular order.
+         Shade lights with indirect by default and a scene with neither an authored environment nor
+         an active procedural atmosphere renders unlit, so the engine enables Hillaire sky/IBL on
+         scenes that arrive without an explicit environment or explicit `atmosphere.enabled = false`.
          */
         if (scene.lights.environment === undefined) {
-            scene.lights.environment = make_default_environment();
+            scene.atmosphere.enable_by_default();
         }
     }
 

package/src/engine/graphics3/load_cube_environment.js

@@ -12,9 +12,9 @@ import { ShadeTexture } from "../../shade/renderer/texture/ShadeTexture.js";
 import { ShadeImage } from "../../shade/renderer/texture/source/ShadeImage.js";
 
 /**
- * Resolution of the octahedral map, matching `make_default_environment` for the same reason: it is
- * convolved into irradiance and a handful of roughness mips before anything samples it, so what
- * matters is that it is smooth and correctly oriented rather than detailed.
+ * Resolution of the octahedral map: it is convolved into irradiance and a handful of roughness mips
+ * before anything samples it, so what matters is that it is smooth and correctly oriented rather
+ * than detailed.
  *
  * @type {number}
  */

package/src/engine/physics/fluid/ecs/FluidObstacleSystem.d.ts

@@ -66,11 +66,11 @@ export class FluidObstacleSystem extends System<any> {
     /**
      * @param {FluidComponent} fluid
      */
-    static "__#497@#refresh_masks"(fluid: FluidComponent): void;
+    static "__#500@#refresh_masks"(fluid: FluidComponent): void;
     /**
      * @param {FluidComponent} fluid
      */
-    static "__#497@#clear_field"(fluid: FluidComponent): void;
+    static "__#500@#clear_field"(fluid: FluidComponent): void;
     /**
      * Mark every cell of `fluid` whose centre lies within `inflation` of the
      * posed shape as solid. Iteration is clipped to the shape's world AABB
@@ -82,7 +82,7 @@ export class FluidObstacleSystem extends System<any> {
      * @param {number} inflation       world-units SDF threshold
      * @param {Float64Array} point     length-3 scratch
      */
-    static "__#497@#voxelize"(fluid: FluidComponent, posed: PosedShape3D, aabb: Float64Array, inflation: number, point: Float64Array): void;
+    static "__#500@#voxelize"(fluid: FluidComponent, posed: PosedShape3D, aabb: Float64Array, inflation: number, point: Float64Array): void;
     /**
      * Write the obstacle's translation velocity onto every face of every cell
      * it voxelized — the moving-wall boundary condition. Runs AFTER the mask
@@ -102,7 +102,7 @@ export class FluidObstacleSystem extends System<any> {
      * @param {number} wvy
      * @param {number} wvz
      */
-    static "__#497@#stamp_wall_velocity"(fluid: FluidComponent, posed: PosedShape3D, aabb: Float64Array, inflation: number, point: Float64Array, wvx: number, wvy: number, wvz: number): void;
+    static "__#500@#stamp_wall_velocity"(fluid: FluidComponent, posed: PosedShape3D, aabb: Float64Array, inflation: number, point: Float64Array, wvx: number, wvy: number, wvz: number): void;
     constructor();
     dependencies: (typeof FluidObstacle)[];
     components_used: (ResourceAccessSpecification<typeof Transform64> | ResourceAccessSpecification<typeof FluidObstacle> | ResourceAccessSpecification<typeof Collider> | ResourceAccessSpecification<typeof RigidBody> | ResourceAccessSpecification<typeof FluidComponent>)[];

package/src/shade/playground/probe_clipmap/index.html

@@ -89,6 +89,7 @@
         <span>Indirect light</span>
         <select id="indirect">
             <option value="ProbeClipmap" selected>Probe clipmap</option>
+            <option value="ScreenProbes">Screen probes — Lumen's gather over the clipmap's world</option>
             <option value="IBL">IBL</option>
         </select>
     </label>
@@ -124,6 +125,48 @@
 
     <hr>
 
+    <label>
+        <span>Screen probes</span>
+        <select id="screen_probe_debug_view">
+            <option value="None" selected>Debug: none</option>
+            <option value="IndirectDiffuse">Indirect diffuse — irradiance / π, before the material</option>
+            <option value="ProbePlacement">Probe placement — uniform green, adaptive red, uncovered blue</option>
+            <option value="TraceKinds">Trace kinds — screen red, bricks green, world probes blue</option>
+        </select>
+    </label>
+
+    <label>
+        <span>Downsample</span>
+        <select id="screen_probe_downsample">
+            <option value="2">1 probe / 2×2 pixels</option>
+            <option value="4">1 probe / 4×4 pixels</option>
+            <option value="8">1 probe / 8×8 pixels</option>
+            <option value="16" selected>1 probe / 16×16 pixels</option>
+            <option value="32">1 probe / 32×32 pixels</option>
+        </select>
+    </label>
+
+    <label>
+        <span>Octahedron</span>
+        <select id="screen_probe_octahedron">
+            <option value="4">4×4 rays a probe</option>
+            <option value="8" selected>8×8 rays a probe</option>
+            <option value="16">16×16 rays a probe</option>
+        </select>
+    </label>
+
+    <label>
+        <input type="checkbox" id="screen_probe_importance" checked>
+        <span>Importance sampling <span class="hint">— rays follow the BRDF and last frame's light</span></span>
+    </label>
+
+    <label>
+        <input type="checkbox" id="screen_probe_screen_traces" checked>
+        <span>Screen traces <span class="hint">— the depth buffer before the SDF bricks</span></span>
+    </label>
+
+    <hr>
+
     <label>
         <input type="checkbox" id="sun" checked>
         <span>Sun <span class="hint">— the directional light; L flips it</span></span>

package/src/shade/playground/probe_clipmap/main.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/probe_clipmap/main.js"],"names":[],"mappings":"AAyFA;;;;;GAKG;AACH,yBAFa,QAAQ,IAAI,CAAC,CA8UzB"}
+{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/probe_clipmap/main.js"],"names":[],"mappings":"AA0FA;;;;;GAKG;AACH,yBAFa,QAAQ,IAAI,CAAC,CA0WzB"}

package/src/shade/playground/probe_clipmap/main.js

@@ -12,6 +12,7 @@ import { OrbitalCameraController } from "../../renderer/camera/orbital/OrbitalCa
 import { PerspectiveCamera } from "../../renderer/camera/PerspectiveCamera.js";
 import { create_frame_loop } from "../../renderer/create_frame_loop.js";
 import { ProbeClipmapDebugView } from "../../renderer/global_illumination/probe_clipmap/debug/ProbeClipmapDebugView.js";
+import { ScreenProbeDebugView } from "../../renderer/global_illumination/screen_probe/ScreenProbeDebugView.js";
 import { make_sunlight } from "../../renderer/light/make_sunlight.js";
 import { PointLight } from "../../renderer/light/model/PointLight.js";
 import { place_light } from "../../renderer/light/place_light.js";
@@ -272,6 +273,34 @@ export async function start() {
         renderer.probe_clipmap.debug_view = ProbeClipmapDebugView[event.target.value];
     });
 
+    element('screen_probe_debug_view').addEventListener('change', event => {
+        renderer.screen_probes.debug_view = ScreenProbeDebugView[event.target.value];
+    });
+
+    element('screen_probe_downsample').addEventListener('change', event => {
+        renderer.screen_probes.downsample_factor = Number(event.target.value);
+    });
+
+    element('screen_probe_octahedron').addEventListener('change', event => {
+        renderer.screen_probes.octahedron_resolution = Number(event.target.value);
+    });
+
+    element('screen_probe_importance').addEventListener('change', event => {
+        renderer.screen_probes.importance_sampling = event.target.checked;
+    });
+
+    element('screen_probe_screen_traces').addEventListener('change', event => {
+        renderer.screen_probes.screen_traces = event.target.checked;
+    });
+
+    // ?mode=ScreenProbes starts the page in another mode, as the panel's select would set it
+    const mode = new URLSearchParams(location.search).get('mode');
+
+    if (mode !== null && ShadeIndirectLightingMode[mode] !== undefined) {
+        renderer.indirect_lighting_mode = ShadeIndirectLightingMode[mode];
+        element('indirect').value = mode;
+    }
+
     const taa_toggle = element('taa');
     const path_tracing_toggle = element('path_tracing');
 

package/src/shade/renderer/Renderer.d.ts

@@ -44,6 +44,12 @@ export class Renderer {
      * @type {ProbeClipmapSettings}
      */
     probe_clipmap: ProbeClipmapSettings;
+    /**
+     * Settings of {@link ShadeIndirectLightingMode.ScreenProbes}, read every frame it runs; its world, the bricks and
+     * the world-space probes, is set by {@link probe_clipmap}. See {@link ScreenProbeSettings}.
+     * @type {ScreenProbeSettings}
+     */
+    screen_probes: ScreenProbeSettings;
     /**
      * Which order-independent transparency technique draws the transparent buckets. Both modes
      * are wired at the single transparency call site and take the same inputs, so this is safe to
@@ -577,6 +583,7 @@ import { SceneManager } from "./scene/SceneManager.js";
 import { ShadeIndirectLightingMode } from "./ShadeIndirectLightingMode.js";
 import { MaterialDispatch } from "./material/dispatch/MaterialDispatch.js";
 import { ProbeClipmapSettings } from "./global_illumination/probe_clipmap/ProbeClipmapSettings.js";
+import { ScreenProbeSettings } from "./global_illumination/screen_probe/ScreenProbeSettings.js";
 import { ShadeTransparencyMode } from "./ShadeTransparencyMode.js";
 import { ToneMapper } from "./deferred/tonemap/ToneMapper.js";
 import { AVBOITSettings } from "./rasterize/native/avboit/AVBOITSettings.js";

package/src/shade/renderer/Renderer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Renderer.d.ts","sourceRoot":"","sources":["../../../../src/shade/renderer/Renderer.js"],"names":[],"mappings":"AA6IA;IAOI,0BAEC;IAED;;OAEG;IACH,0BAAQ;IAER;;;;;;OAMG;IACH,kDAEC;IAED;;OAEG;IACH,kBAAO;IAYP;;;OAGG;IACH,2BAEC;IAaD,wCAGC;IAED,uCAEC;IAED;;;;OAIG;IACH,wBAFU,yBAAyB,CAEoB;IAEvD;;;;;;;OAOG;IACH,mBAFU,gBAAgB,CAEgB;IAE1C;;;;OAIG;IACH,eAFU,oBAAoB,CAEa;IAY3C;;;;;;;OAOG;IACH,mBAFU,qBAAqB,CAEkB;IAEjD;;;;OAIG;IACH,aAFU,UAAU,CAER;IAEZ;;;OAGG;IACH,QAFU,cAAc,CAEM;IAE9B;;;;;;;;;OASG;IACH,2BAFU,OAAO,CAEiB;IAElC,6BAA4B;IAC5B,8BAA4B;IAC5B;;;;OAIG;IACH,mCAAkC;IAClC;;;;;;;OAOG;IACH,mCAFU,OAAO,CAEyB;IAW1C,oCAIC;IAED,mCAEC;IAYD,oCAIC;IAED,mCAEC;IAED;;;;;;OAMG;IACH,6BAFU,OAAO,CAEmB;IAcpC;;OAEG;IACH,uCAEC;IAyBD,0CAIC;IAED,yCAEC;IAED;;;;;OAKG;IACH,yBAFU,MAAM,CAEY;IAW5B,8CAMC;IAED,6CAEC;IAUD,8CAMC;IAED,6CAEC;IAWD,mDAKC;IAED,kDAEC;IASD,+CAKC;IAED,8CAEC;IAED,+BAA6B;IAC7B,4CAA0C;IAkB1C,qCAKC;IArBD;;;;;;;;;;OAUG;IACH,oCAGC;IASD;;;;;;;OAOG;IACH,0BAFU,OAAO,CAEe;IAQhC;;;;;;;OAOG;IACH,oCAOC;IAnBD,mCAEC;IAmBD;;;;;;;;;OASG;IACH,6BAFU,OAAO,CAEmB;IAWpC;;;;;OAKG;IACH,8BAA+C;IAE/C;;;;;;;;OAQG;IACH,6BAFU,OAAO,CAEmB;IAEpC;;;;;;;;;;;;;;OAcG;IACH,8BAFU,OAAO,CAEoB;IAErC;;;;;;;;;;OAUG;IACH,qBAFU,OAAO,CAEW;IAU5B;;;;;OAKG;IACH,wBAA0C;IAE1C;;;;;;;;OAQG;IACH,eAFU,UAAU,GAAC,QAAQ,CAEF;IAU3B;;;;OAIG;IACH,gCAAwD;IAExD;;;OAGG;IACH,4BAFU,OAAO,CAEiB;IAKlC;;;OAGG;IACH,yBAEC;IAYD;;OAEG;IACH,sCAEC;IAOD;;;OAGG;IACH,gCAEC;IAcD;;;;;;;;;OASG;IACH,qBAA+B;IAE/B;;;;;;;;;;OAUG;IACH,qBAA+B;IAgB/B;;;OAGG;IACH,yCAeC;IAED;;;OAGG;IACH,wCAEC;IA0BD;;;OAGG;IACH,iCAEC;IAED;;;;OAIG;IACH,2BAEC;IAQD;;;OAGG;IACH,+CAIC;IAED;;;OAGG;IACH,gDAIC;IAeD;;;OAGG;IACH,6CAIC;IAED;;;;OAIG;IACH,8CAIC;IAkCD;;;OAGG;IACH,+BAcC;IA1BD;;;OAGG;IACH,0BAEC;IAsBD;;;;;;;;;;;;;;;;;;;OAmBG;IACH,iBAFU,iBAAiB,GAAC,IAAI,CAET;IAEvB;;OAEG;IACH;;;;;;;;;;;;;;OAcG;IACH,yBAHW,eAAe,GACb,eAAe,CA8B3B;IAED;;;;;OAKG;IACH,4BAHW,eAAe,GACb,OAAO,CAInB;IAED;;;OAGG;IACH,uBAHW,UAAU,GACR,MAAM,CAIlB;IAUD;;;;;;;;;;;;;;;;;OAiBG;IACH,kCAHW,iBAAiB,GACf,iBAAiB,CAsB7B;IAED;;;;;OAKG;IACH,qCAHW,iBAAiB,GACf,OAAO,CAYnB;IAED;;OAEG;IACH,8BAFa,MAAM,CAIlB;IAgBD;;;;OAIG;IACH,yBAHW,KAAK,GACJ,gBAAgB,CAW3B;IAED;;;OAGG;IACH,6BAMC;IAiBD;;;;OAIG;IACH,gCAHW,KAAK,GACH,2BAA2B,CAcvC;IAGD;;;OAGG;IACH,kBAFW,KAAK,QAyBf;IA8TD,oGAAoG;IACpG,kDAA2C;IAO3C;;;;OAIG;IACH,0BAEC;IAiBD;;;;;;OAMG;IACH,qBAHW,eAAe,GACb,iBAAiB,CAW7B;IAgBD;;;;;;OAMG;IACH,cAFU,iBAAiB,CAEU;IAErC;;;;;;OAMG;IACH,eAgBC;IAkED;;;;;;;;OAQG;IACH;QAJsC,OAAO;QACd,MAAM;QACT,UAAU,GAA3B,MAAM;sBAyNhB;IAED;;;;;;;;;;;;;;OAcG;IACH,0BAFW,eAAe,QAkEzB;IAiCD;;;;;;;;;;;;;;;;;OAiBG;IACH,WAFa,IAAI,CA0ChB;IAkCD,4BAoBC;IAkID;;;;;OAKG;IACH,UAHW,MAAM,KACN,MAAM,QAgBhB;IAoFD,0CAMC;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,eAZW,iBAAiB,SACjB,KAAK,uBACL,MAAM,GAIJ,OAAO,CAuCnB;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,yBARW,iBAAiB,SACjB,KAAK,sBACL,MAAM,UACN,iBAAiB,GACf,OAAO,CAiBnB;;CA+lCJ;+BA/3GY,OAAO,8CAA8C,EAAE,gBAAgB;gCACvE,OAAO,+CAA+C,EAAE,iBAAiB;gCACzE,OAAO,+BAA+B,EAAE,iBAAiB;8BACzD,OAAO,gCAAgC,EAAE,eAAe;gCACxD,OAAO,gDAAgD,EAAE,iBAAiB;8BAC1E,OAAO,4BAA4B,EAAE,eAAe;oBACpD,OAAO,kBAAkB,EAAE,KAAK;6BAnChB,yBAAyB;0CACZ,gCAAgC;iCACzC,yCAAyC;qCA9CrC,6DAA6D;sCA+C5D,4BAA4B;2BAvEvC,kCAAkC;+BAwE9B,6CAA6C;gCAC5C,sCAAsC;2BAhC3C,yCAAyC;6BAFvC,4CAA4C;8BAD3C,2CAA2C;4BAuD7C,uBAAuB;mCAChB,qCAAqC;gCAnExC,sBAAsB;oBAhDlC,4BAA4B;kCA+Gd,gCAAgC;2BAxFvC,2BAA2B;iCAsFrB,0CAA0C;4CAnE/B,+DAA+D;yBA6ClF,yBAAyB;kCAChB,kCAAkC;kCAUlC,wBAAwB;oBAnCtC,0BAA0B;gCAlDd,uCAAuC;uCAwChC,sDAAsD"}
+{"version":3,"file":"Renderer.d.ts","sourceRoot":"","sources":["../../../../src/shade/renderer/Renderer.js"],"names":[],"mappings":"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"}

package/src/shade/renderer/Renderer.js

@@ -16,8 +16,11 @@ import { shade_device_floor_unmet } from "../device/shade_device_floor_unmet.js"
 import { ShadeDeviceFailure } from "../device/ShadeDeviceFailure.js";
 import { PipelineEnquiry } from "../device/pipeline/PipelineEnquiry.js";
 import { ShadeGPUCommandContext } from "../device/ShadeGPUCommandContext.js";
+import { create_atmosphere_sun_state, resolve_atmosphere_sun } from "./atmosphere/resolve_atmosphere_sun.js";
+import { SKY_VIEW_LUT_HEIGHT, SKY_VIEW_LUT_WIDTH, shader_sky_view_lut } from "./atmosphere/shader_sky_view_lut.js";
 import { CameraManager } from "./camera/CameraManager.js";
 import { shader_background } from "./deferred/shader_background.js";
+import { shader_background_sky } from "./deferred/shader_background_sky.js";
 import { shader_composite_volumetrics } from "./deferred/shader_composite_volumetrics.js";
 import { shader_deferred_main } from "./deferred/shader_deferred_main.js";
 import { LOCAL_LIGHT_SHADING } from "./deferred/LOCAL_LIGHT_SHADING.js";
@@ -48,6 +51,14 @@ import { shader_diffuse_LPV } from "./global_illumination/lpv/shader_diffuse_LPV
 import { GPUProbeClipmapGI } from "./global_illumination/probe_clipmap/GPUProbeClipmapGI.js";
 import { ProbeClipmapSettings } from "./global_illumination/probe_clipmap/ProbeClipmapSettings.js";
 import { ProbeClipmapDebugView } from "./global_illumination/probe_clipmap/debug/ProbeClipmapDebugView.js";
+import { GPUScreenProbeGI } from "./global_illumination/screen_probe/GPUScreenProbeGI.js";
+import { ScreenProbeSettings } from "./global_illumination/screen_probe/ScreenProbeSettings.js";
+import { ScreenProbeDebugView } from "./global_illumination/screen_probe/ScreenProbeDebugView.js";
+import { graph_screen_probe_debug_view } from "./global_illumination/screen_probe/graph_screen_probe_debug_view.js";
+import {
+    shader_screen_probe_diffuse,
+    shader_screen_probe_indirect_lighting
+} from "./global_illumination/screen_probe/shader_screen_probe_indirect_lighting.js";
 import { shader_resolve_indirect_lighting } from "./global_illumination/shader_resolve_indirect_lighting.js";
 import { GraphicsContext } from "./GraphicsContext.js";
 import {
@@ -137,6 +148,8 @@ METRICS.create({ name: 'frame_time' });
  */
 const INTERNAL_RESOLUTION_MIN = 1;
 
+const SKY_VIEW_LUT_RESOLUTION = Object.freeze([SKY_VIEW_LUT_WIDTH, SKY_VIEW_LUT_HEIGHT]);
+
 MetricCollectionConsoleMonitor.from(METRICS);
 
 export class Renderer {
@@ -243,6 +256,22 @@ export class Renderer {
      */
     #probe_clipmap_gi;
 
+    /**
+     * Settings of {@link ShadeIndirectLightingMode.ScreenProbes}, read every frame it runs; its world, the bricks and
+     * the world-space probes, is set by {@link probe_clipmap}. See {@link ScreenProbeSettings}.
+     * @type {ScreenProbeSettings}
+     */
+    screen_probes = new ScreenProbeSettings();
+
+    /**
+     * The main view's screen probes under {@link ShadeIndirectLightingMode.ScreenProbes}, over the world
+     * {@link #probe_clipmap_gi} holds: made on the first frame in the mode, given back on the first frame out of it.
+     *
+     * Constructed in {@link initialize}.
+     * @type {GPUScreenProbeGI | undefined}
+     */
+    #screen_probe_gi;
+
     /**
      * Which order-independent transparency technique draws the transparent buckets. Both modes
      * are wired at the single transparency call site and take the same inputs, so this is safe to
@@ -713,6 +742,26 @@ export class Renderer {
      */
     #extensions = new RenderExtensionRegistry();
 
+    /**
+     * Reusable per-frame sun state and immediate uniform payloads for Hillaire Sky-View LUT and
+     * background solar-disc composition.
+     */
+    #sky_sun_state = create_atmosphere_sun_state();
+
+    #sky_view_lut_settings = {
+        sun_direction: this.#sky_sun_state.sun_direction,
+        resolution_x: SKY_VIEW_LUT_WIDTH,
+        sun_irradiance: this.#sky_sun_state.sun_irradiance,
+        resolution_y: SKY_VIEW_LUT_HEIGHT,
+    };
+
+    #sky_background_settings = {
+        sun_direction: this.#sky_sun_state.sun_direction,
+        sun_disk_radius: 0,
+        sun_irradiance: this.#sky_sun_state.sun_irradiance,
+        sun_has_disc: 0,
+    };
+
     /**
      * Raised when there is no usable device — the browser has no WebGPU, the hardware is below the
      * floor, or a working device was lost while running. Carries a {@link ShadeDeviceFailure}.
@@ -1150,6 +1199,8 @@ export class Renderer {
         }
 
         this.#volumetrics?.reset_history();
+
+        this.#screen_probe_gi?.reset_history();
     }
 
     /**
@@ -1252,6 +1303,7 @@ export class Renderer {
      * @param {number} params.gr_occlusion_clip
      * @param {number} params.gr_buffer_camera_current
      * @param {number} params.gr_buffer_camera_previous
+     * @param {number} params.gr_exposure_multiplier - graph resource ID of the exposure the last frame was shown at
      * @param {Vector2} params.resolution
      * @returns {number} Updated scene-color graph resource ID
      */
@@ -1273,6 +1325,7 @@ export class Renderer {
                                  gr_occlusion_clip,
                                  gr_buffer_camera_current,
                                  gr_buffer_camera_previous,
+                                 gr_exposure_multiplier,
                                  resolution,
                              }) {
 
@@ -1354,6 +1407,65 @@ export class Renderer {
                 }
                 break;
 
+            case ShadeIndirectLightingMode.ScreenProbes: {
+                // the diffuse is the screen probes', resolved once the bent normals exist; the specular the world-space
+                // probes', as under the probe clipmap
+                const diffuse = this.#screen_probe_gi.graph_resolve({
+                    graph,
+                    depth: gr_texture_depth_current,
+                    depth_previous: gr_texture_depth_previous,
+                    pbr: gr_texture_pbr,
+                    velocity: gr_velocity,
+                    bent_normals,
+                    exposure: gr_exposure_multiplier,
+                });
+
+                if (prefer_fused && !this.feature_ssr_enabled) {
+                    [current_color_out] = graph_image_pass({
+                        graph,
+                        shader: shader_screen_probe_indirect_lighting,
+                        output: [current_color_out],
+                        input_depth: gr_texture_depth_current,
+                        load_op: "load",
+                        inputs: this.#probe_clipmap_gi.write_sampling_bindings({
+                            ...this.#probe_clipmap_indirect_inputs({
+                                view_ctx,
+                                depth: gr_texture_depth_current,
+                                normal: gr_texture_normal,
+                                bent_normal: bent_normals,
+                                albedo_ao: gr_texture_material_albedo_ao,
+                                pbr: gr_texture_pbr,
+                                environment: gr_texture_environment,
+                                camera: gr_buffer_camera_current,
+                            }),
+                            tScreenProbeDiffuse: diffuse,
+                        }),
+                    });
+
+                    return current_color_out;
+                }
+
+                diffuse_pass = {
+                    shader: shader_screen_probe_diffuse,
+                    inputs: {
+                        tGBufferAlbedo: gr_texture_material_albedo_ao,
+                        tScreenProbeDiffuse: diffuse,
+                    },
+                };
+                specular_pass = {
+                    shader: shader_specular_IBL,
+                    inputs: {
+                        tBentNormals: bent_normals,
+                        tNormals: gr_texture_normal,
+                        tDepth: gr_texture_depth_current,
+                        tPBR: gr_texture_pbr,
+                        tEnvironment: gr_texture_environment,
+                        camera: gr_buffer_camera_current,
+                    },
+                };
+                break;
+            }
+
             case ShadeIndirectLightingMode.Brick4:
                 // SSR needs its own specular resolve and denoising passes.
                 if (prefer_fused && !this.feature_ssr_enabled) {
@@ -1469,7 +1581,7 @@ export class Renderer {
                 input_environment: gr_texture_environment,
                 brick4: ssr_brick4,
                 lpv: ssr_lpv,
-                input_indirect_diffuse: mode === ShadeIndirectLightingMode.ProbeClipmap ? indirect_diffuse : undefined,
+                input_indirect_diffuse: mode === ShadeIndirectLightingMode.ProbeClipmap || mode === ShadeIndirectLightingMode.ScreenProbes ? indirect_diffuse : undefined,
                 // in every mode: a clipmap of no cascade while it has no probes
                 probes: this.#probe_clipmap_gi,
                 shader_switches: this.#shader_switches,
@@ -1843,6 +1955,7 @@ export class Renderer {
         this.#views = new ViewManager(graphics, this.#cameras, this.#scenes);
         this.#volumetrics = new GPUViewVolumetrics(this.device);
         this.#probe_clipmap_gi = new GPUProbeClipmapGI(graphics);
+        this.#screen_probe_gi = new GPUScreenProbeGI(this.device);
 
         const resolution_internal = this.#internal_resolution.asArray();
 
@@ -1954,6 +2067,8 @@ export class Renderer {
         }
 
         enquiry.render.push(shader_background.pipeline_for(color_formats));
+        enquiry.render.push(shader_sky_view_lut.pipeline);
+        enquiry.render.push(shader_background_sky.pipeline_for(color_formats));
 
         if (this.indirect_lighting_mode === ShadeIndirectLightingMode.IBL) {
             if (!this.feature_ssr_enabled) {
@@ -2067,6 +2182,7 @@ export class Renderer {
         this.#nss?.destroy();
         this.#volumetrics?.destroy();
         this.#probe_clipmap_gi?.destroy();
+        this.#screen_probe_gi?.destroy();
 
         this.#views?.destroy();
         this.#scenes?.destroy();
@@ -2964,7 +3080,11 @@ export class Renderer {
         // (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §5); its hits trace their own shadow rays, so it reads no
         // shadow map. Made for this view and these settings on the first frame in the mode, and given back
         // on the first frame out of it.
-        if (this.indirect_lighting_mode === ShadeIndirectLightingMode.ProbeClipmap) {
+        // The screen probes trace the probe clipmap's world and read its world-space probes past their reach, so that
+        // world runs under both modes; the screen probes follow it in the same frame.
+        const screen_probes = this.indirect_lighting_mode === ShadeIndirectLightingMode.ScreenProbes;
+
+        if (this.indirect_lighting_mode === ShadeIndirectLightingMode.ProbeClipmap || screen_probes) {
             this.#probe_clipmap_gi.graph_update({
                 graph,
                 view: view_ctx,
@@ -2979,6 +3099,25 @@ export class Renderer {
             this.#probe_clipmap_gi.release();
         }
 
+        if (screen_probes) {
+            this.#screen_probe_gi.graph_update({
+                graph,
+                view: view_ctx,
+                settings: this.screen_probes,
+                world: this.#probe_clipmap_gi,
+                stbn: STATIC_GRAPHICS_ENGINE_ASSETS.stbn_vec2,
+                depth: gr_texture_depth_current,
+                normal: gr_texture_normal,
+                pbr: gr_texture_pbr,
+                velocity: gr_velocity,
+                occlusion: gr_occlusion_clip,
+                hzb: gr_texture_hzb,
+                exposure: gr_exposure_multiplier,
+            });
+        } else {
+            this.#screen_probe_gi.release();
+        }
+
         const volumetrics = this.#volumetrics.graph_update({
             graph,
             view: view_ctx,
@@ -3098,18 +3237,60 @@ export class Renderer {
 
 
         // Shade background
-        [current_color_out] = graph_image_pass({
-            graph,
-            shader: shader_background,
-            inputs: {
-                camera: view_ctx.camera.buffer,
-                view: view_ctx.uniform_buffer.buffer,
-                tEnvironment: gr_texture_environment,
-            },
-            input_depth: gr_texture_depth_current,
-            load_op: "load",
-            output: [current_color_out],
-        });
+        if (scene_ctx.scene.lights.environment === undefined && scene_ctx.scene.atmosphere.enabled) {
+            const sky = scene_ctx.sky;
+            sky.update();
+
+            const gr_sky_transmittance = volumetrics.lut_transmittance
+                ?? graph_import_texture(graph, sky.lut_transmittance, "sky/transmittance");
+            const gr_sky_multiscatter = volumetrics.lut_multiple_scattering
+                ?? graph_import_texture(graph, sky.lut_multiple_scattering, "sky/multiscatter");
+
+            const sun = resolve_atmosphere_sun(scene_ctx.scene, this.#sky_sun_state);
+            this.#sky_background_settings.sun_disk_radius = sun.sun_disk_radius;
+            this.#sky_background_settings.sun_has_disc = sun.sun_has_disc;
+
+            const [gr_sky_view_lut] = graph_image_pass({
+                graph,
+                shader: shader_sky_view_lut,
+                output_resolution: SKY_VIEW_LUT_RESOLUTION,
+                inputs: {
+                    settings: this.#sky_view_lut_settings,
+                    camera: view_ctx.camera.buffer,
+                    atmosphere: sky.parameters_buffer.buffer,
+                    tSkyLutTransmittance: gr_sky_transmittance,
+                    tSkyLutMultiscatter: gr_sky_multiscatter,
+                },
+            });
+
+            [current_color_out] = graph_image_pass({
+                graph,
+                shader: shader_background_sky,
+                inputs: {
+                    settings: this.#sky_background_settings,
+                    camera: view_ctx.camera.buffer,
+                    atmosphere: sky.parameters_buffer.buffer,
+                    tSkyViewLut: gr_sky_view_lut,
+                    tSkyLutTransmittance: gr_sky_transmittance,
+                },
+                input_depth: gr_texture_depth_current,
+                load_op: "load",
+                output: [current_color_out],
+            });
+        } else {
+            [current_color_out] = graph_image_pass({
+                graph,
+                shader: shader_background,
+                inputs: {
+                    camera: view_ctx.camera.buffer,
+                    view: view_ctx.uniform_buffer.buffer,
+                    tEnvironment: gr_texture_environment,
+                },
+                input_depth: gr_texture_depth_current,
+                load_op: "load",
+                output: [current_color_out],
+            });
+        }
 
         current_color_out = this.#graph_indirect_lighting({
             graph,
@@ -3129,9 +3310,15 @@ export class Renderer {
             gr_occlusion_clip,
             gr_buffer_camera_current,
             gr_buffer_camera_previous,
+            gr_exposure_multiplier,
             resolution,
         });
 
+        // the opaque surfaces' lit colour, the screen probes' hits' radiance next frame: before fog and transparencies
+        if (screen_probes) {
+            this.#screen_probe_gi.graph_capture({ graph, color: current_color_out });
+        }
+
         // Composite volumetric fog over the finalized opaque + background + indirect colour.
         // A dedicated pass (not inline in the shading shaders) because indirect lighting is added
         // in a separate additively-blended pass, so the full surface radiance only exists here.
@@ -3299,7 +3486,18 @@ export class Renderer {
 
         // the probe clipmap mode's debug views replace the colour the same way
         if (
-            this.indirect_lighting_mode === ShadeIndirectLightingMode.ProbeClipmap
+            screen_probes
+            && this.screen_probes.debug_view !== ScreenProbeDebugView.None
+        ) {
+            current_color_out = graph_screen_probe_debug_view({
+                graph,
+                gi: this.#screen_probe_gi,
+                view_mode: this.screen_probes.debug_view,
+                depth: gr_texture_depth_current,
+                resolution: resolution_internal.asArray(),
+            });
+        } else if (
+            (this.indirect_lighting_mode === ShadeIndirectLightingMode.ProbeClipmap || screen_probes)
             && this.probe_clipmap.debug_view !== ProbeClipmapDebugView.None
         ) {
             current_color_out = this.#probe_clipmap_gi.graph_debug_view({

package/src/shade/renderer/ShadeIndirectLightingMode.d.ts

@@ -8,5 +8,6 @@ export namespace ShadeIndirectLightingMode {
     let Brick4: number;
     let LPV: number;
     let ProbeClipmap: number;
+    let ScreenProbes: number;
 }
 //# sourceMappingURL=ShadeIndirectLightingMode.d.ts.map

package/src/shade/renderer/ShadeIndirectLightingMode.js

@@ -17,4 +17,13 @@ export const ShadeIndirectLightingMode = {
      * `Renderer.probe_clipmap`. Lit as {@link IBL} until its probes are traced (that proposal's §13, S4).
      */
     ProbeClipmap: 3,
+    /**
+     * Lumen's screen probe gather over the {@link ProbeClipmap}'s world: probes placed on the G-buffer every few
+     * pixels, more densely where interpolation between them would cross an edge, traced through the screen and
+     * then the SDF bricks, the world-space probes standing in for what lies past a probe's own reach, and
+     * reprojected from frame to frame (`global_illumination/screen_probe/GPUScreenProbeGI.js`). The opaque surfaces'
+     * diffuse light is the screen probes'; everything else reads the world-space probes as under
+     * {@link ProbeClipmap}. Settings are `Renderer.screen_probes`, and `Renderer.probe_clipmap` for the world.
+     */
+    ScreenProbes: 4,
 };

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

@@ -0,0 +1,22 @@
+/**
+ * Packed GPU uniform representation of {@link SceneAtmosphere} in GPU atmosphere units
+ * ($\text{km}$ and $\text{km}^{-1}$, scaled via `ATMOSPHERE_UNIT_METERS`).
+ *
+ * @see "A Scalable and Production Ready Sky and Atmosphere Rendering Technique", Hillaire (2020)
+ * @type {WebGPUStruct}
+ */
+export const ATMOSPHERE_PARAMETERS_STRUCT: WebGPUStruct;
+/**
+ * Deeply frozen default Earth uniform payload matching {@link ATMOSPHERE_PARAMETERS_STRUCT}.
+ */
+export const ATMOSPHERE_EARTH_UNIFORM: Readonly<Record<string, any>>;
+/**
+ * Parameterised Hillaire (2020) atmosphere medium, geometry, and LUT coordinate helpers operating
+ * on {@link ATMOSPHERE_PARAMETERS_STRUCT}.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_atmosphere_parameters: CodeChunk;
+import { WebGPUStruct } from "../shader/type/WebGPUStruct.js";
+import { CodeChunk } from "../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=ATMOSPHERE_PARAMETERS_STRUCT.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ATMOSPHERE_PARAMETERS_STRUCT.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/atmosphere/ATMOSPHERE_PARAMETERS_STRUCT.js"],"names":[],"mappings":"AAQA;;;;;;GAMG;AACH,2CAFU,YAAY,CAmBK;AAE3B;;GAEG;AACH,qEAQK;AAEL;;;;;GAKG;AACH,0CAFU,SAAS,CA4GjB;6BA5J2B,gCAAgC;0BAFnC,iCAAiC"}