@woosh/meep-engine 3.34.0 → 3.36.0

package/src/shade/playground/particle_system/README.md

@@ -134,6 +134,5 @@ and `camera_state()` / `apply_camera(...)` copy a view between sessions.
 
 ## What this page does not cover
 
-Lighting is the unlit hook — `chunk_particle_lighting_unlit`, not the shading-chunk-backed one a
-lit-emitter variant would swap in. No emitter opts into simulation culling, so the frustum test in
+No emitter here opts into `EMITTER_FLAG.LIGHTING`; the bonfire in `../particle_ecs/` does. No emitter opts into simulation culling, so the frustum test in
 the tick pass is never taken here; the measured boxes are read by the occupancy pass all the same.

package/src/shade/playground/profile_hotkey.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"profile_hotkey.d.ts","sourceRoot":"","sources":["../../../../src/shade/playground/profile_hotkey.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;GAcG;AAEH;;;;;GAKG;AAEH;;;;;;;;;;;;;;;GAeG;AACH;IAZ8D,QAAQ,EAA3D,OAAO,yBAAyB,EAAE,QAAQ;IAE3B,IAAI,EAAnB,MAAM;IACoB,MAAM,GAAhC,WAAW,GAAC,IAAI;IAEc,QAAQ,SAA1B,MAAM,EAAE;IAEJ,KAAK,GAArB,MAAM;IACU,GAAG,GAAnB,MAAM;IACe,MAAM,GAA3B,WAAW;IACT,mBAAmB,CAwO/B;;wBA3PyB,OAAO;;;;kBACP,QAAQ,IAAI,CAAC;;;;mBACb,IAAI"}
+{"version":3,"file":"profile_hotkey.d.ts","sourceRoot":"","sources":["../../../../src/shade/playground/profile_hotkey.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;GAcG;AAEH;;;;;GAKG;AAEH;;;;;;;;;;;;;;;GAeG;AACH;IAZ8D,QAAQ,EAA3D,OAAO,yBAAyB,EAAE,QAAQ;IAE3B,IAAI,EAAnB,MAAM;IACoB,MAAM,GAAhC,WAAW,GAAC,IAAI;IAEc,QAAQ,SAA1B,MAAM,EAAE;IAEJ,KAAK,GAArB,MAAM;IACU,GAAG,GAAnB,MAAM;IACe,MAAM,GAA3B,WAAW;IACT,mBAAmB,CAoM/B;;wBAvNyB,OAAO;;;;kBACP,QAAQ,IAAI,CAAC;;;;mBACb,IAAI"}

package/src/shade/playground/profile_hotkey.js

@@ -139,56 +139,20 @@ export function install_profile_hotkey({
         );
     }
 
-    /**
-     * Wait for frames already submitted to finish landing in the session.
-     *
-     * A frame is committed when its timestamp readback resolves — a `mapAsync` a frame or two behind
-     * submit, see `ShadeGPUCommandContext.profiling_absorbed` — and `record_frame` silently ignores
-     * anything arriving after `stop()`. Stopping the instant the key goes down therefore discards
-     * the last few frames, which are the ones you were most likely looking at.
-     *
-     * Drains the queue, then waits for the frame count to stop moving. Capped, because a recording
-     * taken while the page is paused never moves at all.
-     *
-     * @param {GPUProfileSession} recording
-     * @returns {Promise<void>}
-     */
-    async function drain(recording) {
-        const DEADLINE_MS = 1000;
-        const QUIET_MS = 60;
-
-        await renderer.device.queue.onSubmittedWorkDone();
-
-        const deadline = performance.now() + DEADLINE_MS;
-
-        let previous = recording.frames_recorded;
-
-        while (performance.now() < deadline) {
-            await new Promise(resolve => setTimeout(resolve, QUIET_MS));
-
-            if (recording.frames_recorded === previous) {
-                return;
-            }
-
-            previous = recording.frames_recorded;
-        }
-    }
-
     async function stop() {
         const recording = session;
 
         session = null;
 
-        // Detached first, so nothing encoded during the drain below joins the recording. Frames
-        // already encoded are unaffected: Renderer captures the session into a local before it
+        // Detached first, so nothing encoded while the frames in flight land joins the recording.
+        // Those frames are unaffected: Renderer captures the session into a local before it
         // subscribes to the readback.
         renderer.profile_session = null;
 
         set_status("stopping — draining in-flight frames…");
 
-        await drain(recording);
-
-        const bytes = recording.stop();
+        // resolves once the frames already submitted have landed, the last ones you were looking at
+        const bytes = await recording.stop();
         const filename = `${name}-${file_timestamp()}.sgpt`;
 
         download_bytes(bytes, filename);

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

@@ -1 +1 @@
-{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/skinned_blas_refit/main.js"],"names":[],"mappings":"AAwQA;;;;;GAKG;AACH,yBAFa,QAAQ,IAAI,CAAC,CAukBzB"}
+{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/skinned_blas_refit/main.js"],"names":[],"mappings":"AAwQA;;;;;GAKG;AACH,yBAFa,QAAQ,IAAI,CAAC,CAoiBzB"}

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

@@ -702,55 +702,20 @@ export async function start() {
         );
     }
 
-    /**
-     * Wait for frames already submitted to finish landing in the session.
-     *
-     * A frame is committed when its timestamp readback resolves — a `mapAsync` a frame or two behind
-     * submit, see `ShadeGPUCommandContext.profiling_absorbed` — and `record_frame` silently ignores
-     * anything arriving after `stop()`. Stopping the instant the key goes down therefore discards
-     * the last few frames, which are the ones you were most likely looking at.
-     *
-     * Drains the queue, then waits for the frame count to stop moving. Capped, because a recording
-     * taken while the page is paused never moves at all.
-     *
-     * @param {GPUProfileSession} session
-     */
-    async function drain_profile(session) {
-        const DEADLINE_MS = 1000;
-        const QUIET_MS = 60;
-
-        await renderer.device.queue.onSubmittedWorkDone();
-
-        const deadline = performance.now() + DEADLINE_MS;
-
-        let previous = session.frames_recorded;
-
-        while (performance.now() < deadline) {
-            await new Promise(resolve => setTimeout(resolve, QUIET_MS));
-
-            if (session.frames_recorded === previous) {
-                return;
-            }
-
-            previous = session.frames_recorded;
-        }
-    }
-
     async function stop_profile() {
         const session = profile_session;
 
         profile_session = null;
 
-        // Detach first, so nothing encoded during the drain below joins the recording. Frames
-        // already encoded are unaffected: Renderer captures the session into a local before it
+        // Detached first, so nothing encoded while the frames in flight land joins the recording.
+        // Those frames are unaffected: Renderer captures the session into a local before it
         // subscribes to the readback.
         renderer.profile_session = null;
 
         set_profile_status('stopping — draining in-flight frames…');
 
-        await drain_profile(session);
-
-        const bytes = session.stop();
+        // resolves once the frames already submitted have landed, the last ones you were looking at
+        const bytes = await session.stop();
 
         const filename = `skinned_blas_refit-${file_timestamp()}.sgpt`;
 

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

@@ -1 +1 @@
-{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/volumetrics_froxel/main.js"],"names":[],"mappings":"AA2aA,uCAigBC"}
+{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/volumetrics_froxel/main.js"],"names":[],"mappings":"AA2aA,uCA8dC"}

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

@@ -766,55 +766,20 @@ export async function start() {
         );
     }
 
-    /**
-     * Wait for frames already submitted to finish landing in the session.
-     *
-     * A frame is committed when its timestamp readback resolves — a `mapAsync` a frame or two behind
-     * submit, see `ShadeGPUCommandContext.profiling_absorbed` — and `record_frame` silently ignores
-     * anything arriving after `stop()`. Stopping the instant the key goes down therefore discards
-     * the last few frames, which are the ones you were most likely looking at.
-     *
-     * Drains the queue, then waits for the frame count to stop moving. Capped, because a recording
-     * taken while the page is paused never moves at all.
-     *
-     * @param {GPUProfileSession} session
-     */
-    async function drain_profile(session) {
-        const DEADLINE_MS = 1000;
-        const QUIET_MS = 60;
-
-        await renderer.device.queue.onSubmittedWorkDone();
-
-        const deadline = performance.now() + DEADLINE_MS;
-
-        let previous = session.frames_recorded;
-
-        while (performance.now() < deadline) {
-            await new Promise(resolve => setTimeout(resolve, QUIET_MS));
-
-            if (session.frames_recorded === previous) {
-                return;
-            }
-
-            previous = session.frames_recorded;
-        }
-    }
-
     async function stop_profile() {
         const session = profile_session;
 
         profile_session = null;
 
-        // Detach first, so nothing encoded during the drain below joins the recording. Frames
-        // already encoded are unaffected: Renderer captures the session into a local before it
+        // Detached first, so nothing encoded while the frames in flight land joins the recording.
+        // Those frames are unaffected: Renderer captures the session into a local before it
         // subscribes to the readback.
         renderer.profile_session = null;
 
         set_profile_status('stopping — draining in-flight frames…');
 
-        await drain_profile(session);
-
-        const bytes = session.stop();
+        // resolves once the frames already submitted have landed, the last ones you were looking at
+        const bytes = await session.stop();
 
         const filename = `volumetrics_froxel-${file_timestamp()}.sgpt`;
 

package/src/shade/playground/volumetrics_froxel/measure.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"measure.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/volumetrics_froxel/measure.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AAEH;;;;;;GAMG;AACH;IAL8B,QAAQ;IACX,KAAK;IACO,MAAM;IACA,UAAU;;;;;;;;;;UAuLtC,QAAQ,YAAY,CAAC;;;;;gCA5DvB,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UA4MV,QAAQ,MAAM,EAAE,CAAC;;;;;;;;;;;;;QAsGF,MAAM,GAAvB,MAAM;QACW,MAAM,GAAvB,MAAM;UACJ;YAAe,MAAM,GAAE,MAAM;MAAE;;GAsF/C"}
+{"version":3,"file":"measure.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/volumetrics_froxel/measure.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AAEH;;;;;;GAMG;AACH;IAL8B,QAAQ;IACX,KAAK;IACO,MAAM;IACA,UAAU;;;;;;;;;;UAuLtC,QAAQ,YAAY,CAAC;;;;;gCA5DvB,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UA4MV,QAAQ,MAAM,EAAE,CAAC;;;;;;;;;;;;;QAsGF,MAAM,GAAvB,MAAM;QACW,MAAM,GAAvB,MAAM;UACJ;YAAe,MAAM,GAAE,MAAM;MAAE;;GAoF/C"}

package/src/shade/playground/volumetrics_froxel/measure.js

@@ -495,10 +495,8 @@ export async function attach({
 
         renderer.profile_session = null;
 
-        await device.queue.onSubmittedWorkDone();
-        await new Promise(resolve => setTimeout(resolve, 200));
-
-        const bytes = session.stop();
+        // resolves once the frames already submitted have landed
+        const bytes = await session.stop();
 
         const buffer = bytes instanceof ArrayBuffer
             ? bytes

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

@@ -277,7 +277,7 @@ export class Renderer {
      * renderer.profile_session = session;
      * session.start();
      * // ... frames ...
-     * const bytes = session.stop();
+     * const bytes = await session.stop();
      * renderer.profile_session = null;
      * ```
      *

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":"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"}
+{"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

@@ -668,7 +668,7 @@ export class Renderer {
      * renderer.profile_session = session;
      * session.start();
      * // ... frames ...
-     * const bytes = session.stop();
+     * const bytes = await session.stop();
      * renderer.profile_session = null;
      * ```
      *
@@ -2433,6 +2433,7 @@ export class Renderer {
             light_cluster_lookup: light_clusters.lookup,
             light_cluster_parameters: light_clusters.parameters,
             shadowmap_atlas: gr_shadowmap_atlas,
+            indirect_lighting_mode: this.indirect_lighting_mode,
         });
 
         /**
@@ -2687,6 +2688,7 @@ export class Renderer {
 
                 volumetrics_lut: volumetrics.resolved,
                 volumetrics_metadata: volumetrics.metadata,
+                volumetrics_irradiance: volumetrics.irradiance,
 
                 indirect_lighting_mode: this.indirect_lighting_mode,
                 avboit: this.avboit,

package/src/shade/renderer/light/GPULightCollection.d.ts

@@ -42,7 +42,15 @@ export class GPULightCollection {
      * @returns {GPUTextureContext}
      */
     get environment(): GPUTextureContext;
-    get gpu_memory_usage(): number;
+    /**
+     * The environment's radiance as RGB SH2 (`ENVIRONMENT_SH_TYPE`), the form the renderer's probe-based
+     * indirect lighting hands over too: what the froxel GI stage starts the froxel irradiance volume
+     * with under IBL. Zero while there is no environment, as {@link environment} is black then.
+     *
+     * @returns {GPUBuffer}
+     */
+    get environment_sh(): GPUBuffer;
+    get gpu_memory_usage(): any;
     /**
      *
      * @param {GraphicsContext} ctx

package/src/shade/renderer/light/GPULightCollection.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPULightCollection.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/light/GPULightCollection.js"],"names":[],"mappings":"AA0CA;IAgII;;;;;;OAMG;IACH,sBALW,eAAe,aACf,eAAe,EA8BzB;IA1JD;;;OAGG;IACH,6DAEC;IAeD;;OAEG;IACH,4BAEC;IAED;;;;;;OAMG;IACH,6BAEC;IAED;;;;;;;OAOG;IACH,qFAEC;IAWD;;OAEG;IACH,+CAEC;IAyCD;;;OAGG;IACH,qCAEC;IAGD,+BAIC;IA4GD;;;OAGG;IACH,YAFW,eAAe,QA8BzB;IAED;;;;;;;;;OASG;IACH,gBAFW,OAAO,+BAA+B,EAAE,YAAY,QAkC9D;IAED;;;;;;OAMG;IACH,uBAHW,sBAAsB,mCAyBhC;IAwED,gBAQC;;CACJ;8BA3bY,OAAO,uBAAuB,EAAE,eAAe;8BAC/C,OAAO,6BAA6B,EAAE,eAAe;8BACrD,OAAO,sBAAsB,EAAE,eAAe;4BApB/B,gCAAgC;yCACnB,2CAA2C;kCAClD,iCAAiC;uCAH5B,wCAAwC"}
+{"version":3,"file":"GPULightCollection.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/light/GPULightCollection.js"],"names":[],"mappings":"AA2CA;IAmJI;;;;;;OAMG;IACH,sBALW,eAAe,aACf,eAAe,EAqCzB;IApLD;;;OAGG;IACH,6DAEC;IAeD;;OAEG;IACH,4BAEC;IAED;;;;;;OAMG;IACH,6BAEC;IAED;;;;;;;OAOG;IACH,qFAEC;IAWD;;OAEG;IACH,+CAEC;IAgDD;;;OAGG;IACH,qCAEC;IAED;;;;;;OAMG;IACH,gCAEC;IAGD,4BAKC;IAgID;;;OAGG;IACH,YAFW,eAAe,QA8BzB;IAED;;;;;;;;;OASG;IACH,gBAFW,OAAO,+BAA+B,EAAE,YAAY,QAkC9D;IAED;;;;;;OAMG;IACH,uBAHW,sBAAsB,mCAyBhC;IAwED,gBASC;;CACJ;8BAneY,OAAO,uBAAuB,EAAE,eAAe;8BAC/C,OAAO,6BAA6B,EAAE,eAAe;8BACrD,OAAO,sBAAsB,EAAE,eAAe;4BArB/B,gCAAgC;yCACnB,2CAA2C;kCAClD,iCAAiC;uCAH5B,wCAAwC"}

package/src/shade/renderer/light/GPULightCollection.js

@@ -7,6 +7,7 @@ import { GPUTextureContext } from "../texture/GPUTextureContext.js";
 import { texture_mip_level_count } from "../../util/texture_mip_extent.js";
 import { texture_write_to_gpu } from "../texture/texture_write_to_gpu.js";
 import { execute_filter_environment_map } from "./environment/execute_filter_environment_map.js";
+import { ENVIRONMENT_SH_TYPE, shader_project_environment_sh } from "./environment/shader_project_environment_sh.js";
 import { LIGHT_DATABASE_SPEC } from "./LIGHT_DATABASE_SPEC.js";
 import { light_record_directional } from "./model/io/light_record_directional.js";
 import { light_record_point } from "./model/io/light_record_point.js";
@@ -152,6 +153,13 @@ export class GPULightCollection {
      */
     #environment_source;
 
+    /**
+     * The environment's radiance as RGB SH2, projected from {@link #environment} whenever it changes;
+     * see {@link shader_project_environment_sh}.
+     * @type {GPUBuffer}
+     */
+    #environment_sh;
+
 
     /**
      *
@@ -161,9 +169,21 @@ export class GPULightCollection {
         return this.#environment;
     }
 
+    /**
+     * The environment's radiance as RGB SH2 (`ENVIRONMENT_SH_TYPE`), the form the renderer's probe-based
+     * indirect lighting hands over too: what the froxel GI stage starts the froxel irradiance volume
+     * with under IBL. Zero while there is no environment, as {@link environment} is black then.
+     *
+     * @returns {GPUBuffer}
+     */
+    get environment_sh() {
+        return this.#environment_sh;
+    }
+
 
     get gpu_memory_usage() {
         return this.#environment.gpu_memory_usage
+            + this.#environment_sh.size
             + this.#database.gpu_memory_usage
             ;
     }
@@ -194,6 +214,13 @@ export class GPULightCollection {
             | GPUTextureUsage.STORAGE_BINDING // so we can convolve it in compute shader
         ;
 
+        // zeroed on creation, which is what an absent environment projects to
+        this.#environment_sh = device.createBuffer({
+            label: "environment SH",
+            size: ENVIRONMENT_SH_TYPE.size,
+            usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST,
+        });
+
         this.#database = new GPUDatabase({
             device,
             label: 'Light Collection / Database',
@@ -236,6 +263,9 @@ export class GPULightCollection {
 
             gpu_ctx.allocate();
 
+            // what a black environment projects to; nothing to run the projection over
+            this.#device.queue.writeBuffer(this.#environment_sh, 0, new Float32Array(this.#environment_sh.size / 4));
+
             return;
         }
 
@@ -271,6 +301,16 @@ export class GPULightCollection {
 
         execute_filter_environment_map(gpu_ctx, cmd);
 
+        // after the prefilter, whose roughest levels are what it reads
+        shader_project_environment_sh.dispatch({
+            encoder: cmd,
+            group_count_x: 1,
+            bindings: {
+                tEnvironment: gpu_ctx.obtainView(),
+                output: this.#environment_sh,
+            },
+        });
+
         cmd.finish();
     }
 
@@ -461,5 +501,6 @@ export class GPULightCollection {
         this.#shadow_context.destroy();
         this.#database.destroy();
         this.#environment.destroy();
+        this.#environment_sh.destroy();
     }
 }

package/src/shade/renderer/light/environment/shader_project_environment_sh.d.ts

@@ -0,0 +1,37 @@
+/**
+ * The layout {@link shader_project_environment_sh} writes: the environment's radiance as RGB SH2,
+ * coefficient `k` in `.xyz` of element `k`, ordered `[DC, y, z, x]` in the project's all-positive
+ * basis (`sh2_basis_at`); `.w` is unused. Radiance, not cosine-convolved — the convention the probes
+ * of Brick4 and of the light probe volume are stored in — so `sh2_color_get_irradiance_at` turns it
+ * into the irradiance of a surface facing the direction evaluated at.
+ *
+ * @type {WebGPUArray}
+ */
+export const ENVIRONMENT_SH_TYPE: WebGPUArray;
+/**
+ * Directions the projection samples, spread evenly over the sphere (`sphere_fibonacci_point`).
+ * The field is the environment at the roughness diffuse reads it at, so this is far more than its
+ * two bands can hold, and it costs nothing that recurs: the pass runs when the environment changes.
+ *
+ * @type {number}
+ */
+export const ENVIRONMENT_SH_SAMPLE_COUNT: number;
+/**
+ * The environment as RGB SH2 of radiance ({@link ENVIRONMENT_SH_TYPE}): the form the renderer's other
+ * indirect lighting — Brick4, the light probe volume — already hands over, so the froxel GI stage
+ * (`volumetrics/gi/`) takes the environment as one more source of it. What the froxel irradiance
+ * volume is started with under IBL, and what a lit particle's ambient is there; reading the
+ * environment itself per pixel, as the forward mesh path does, cost 880 us of lighting's 1,090 us on
+ * the bonfire's overdraw at 1898x926 (RTX 4090).
+ *
+ * The field projected is the one the forward path reads (`get_ibl_irradiance`: the prefiltered map at
+ * roughness 1, times pi), and the radiance stored is what that field is the cosine convolution of, so
+ * convolving it back gives the forward path's diffuse up to what two bands drop. Run by
+ * `GPULightCollection` when the environment changes, after the prefilter it reads.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_project_environment_sh: ComputeShader;
+import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
+import { ComputeShader } from "../../shader/ComputeShader.js";
+//# sourceMappingURL=shader_project_environment_sh.d.ts.map

package/src/shade/renderer/light/environment/shader_project_environment_sh.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shader_project_environment_sh.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/light/environment/shader_project_environment_sh.js"],"names":[],"mappings":"AAUA;;;;;;;;GAQG;AACH,kCAFU,WAAW,CAEyC;AAE9D;;;;;;GAMG;AACH,0CAFU,MAAM,CAEgC;AAyDhD;;;;;;;;;;;;;;GAcG;AACH,4CAFU,aAAa,CAMpB;4BAjGyB,kCAAkC;8BAFhC,+BAA+B"}

package/src/shade/renderer/light/environment/shader_project_environment_sh.js

@@ -0,0 +1,105 @@
+import { chunk_get_ibl_irradiance } from "../../deferred/indirect/chunk_get_ibl_irradiance.js";
+import { PI_DECLARATION } from "../../shader/chunk/math/PI_DECLARATION.js";
+import { chunk_sphere_fibonacci_point } from "../../shader/chunk/geometry/sphere/chunk_sphere_fibonacci_point.js";
+import { chunk_sh2_basis_at } from "../../shader/chunk/spherical_harmonics/chunk_sh2_basis_at.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { ComputeShader } from "../../shader/ComputeShader.js";
+import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
+import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
+import { vec4f } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+
+/**
+ * The layout {@link shader_project_environment_sh} writes: the environment's radiance as RGB SH2,
+ * coefficient `k` in `.xyz` of element `k`, ordered `[DC, y, z, x]` in the project's all-positive
+ * basis (`sh2_basis_at`); `.w` is unused. Radiance, not cosine-convolved — the convention the probes
+ * of Brick4 and of the light probe volume are stored in — so `sh2_color_get_irradiance_at` turns it
+ * into the irradiance of a surface facing the direction evaluated at.
+ *
+ * @type {WebGPUArray}
+ */
+export const ENVIRONMENT_SH_TYPE = WebGPUArray.from(vec4f, 4);
+
+/**
+ * Directions the projection samples, spread evenly over the sphere (`sphere_fibonacci_point`).
+ * The field is the environment at the roughness diffuse reads it at, so this is far more than its
+ * two bands can hold, and it costs nothing that recurs: the pass runs when the environment changes.
+ *
+ * @type {number}
+ */
+export const ENVIRONMENT_SH_SAMPLE_COUNT = 1024;
+
+const resources = new ShaderResourceSetDescriptor();
+
+resources.createGroup()
+    // read texel by texel (texture_octahedral_sample_bilinear), as the forward path reads it
+    .addTexture("tEnvironment")
+    .addStorageBuffer("output", ENVIRONMENT_SH_TYPE, true);
+
+const body = CodeChunk.from(
+    //language=WGSL
+    `
+const SAMPLE_COUNT : u32 = ${ENVIRONMENT_SH_SAMPLE_COUNT}u;
+
+// One invocation: the projection is 1024 reads that happen when the environment changes and never
+// otherwise, and a single lane needs no reduction and runs whole on the emulator.
+@compute @workgroup_size(1)
+fn main() {
+    var sh_0 = vec3<f32>(0.0);
+    var sh_1 = vec3<f32>(0.0);
+    var sh_2 = vec3<f32>(0.0);
+    var sh_3 = vec3<f32>(0.0);
+
+    for (var i = 0u; i < SAMPLE_COUNT; i++) {
+        let direction = sphere_fibonacci_point(f32(i), f32(SAMPLE_COUNT));
+
+        // exactly what the forward mesh path takes as a surface's diffuse irradiance under IBL
+        let irradiance = get_ibl_irradiance(direction);
+
+        let basis = sh2_basis_at(direction);
+
+        sh_0 += irradiance * basis[0];
+        sh_1 += irradiance * basis[1];
+        sh_2 += irradiance * basis[2];
+        sh_3 += irradiance * basis[3];
+    }
+
+    // each sample stands for an equal share of the sphere
+    let weight = 4.0 * PI / f32(SAMPLE_COUNT);
+
+    // What was projected is irradiance; what is stored is the radiance it is the cosine convolution
+    // of, band by band: the clamped cosine's zonal weights are pi for band 0 and 2 pi / 3 for band 1.
+    let band_0 = weight / PI;
+    let band_1 = weight * 3.0 / (2.0 * PI);
+
+    output[0] = vec4<f32>(sh_0 * band_0, 0.0);
+    output[1] = vec4<f32>(sh_1 * band_1, 0.0);
+    output[2] = vec4<f32>(sh_2 * band_1, 0.0);
+    output[3] = vec4<f32>(sh_3 * band_1, 0.0);
+}
+`, [
+    chunk_sphere_fibonacci_point,
+    chunk_get_ibl_irradiance,
+    chunk_sh2_basis_at,
+    PI_DECLARATION,
+]);
+
+/**
+ * The environment as RGB SH2 of radiance ({@link ENVIRONMENT_SH_TYPE}): the form the renderer's other
+ * indirect lighting — Brick4, the light probe volume — already hands over, so the froxel GI stage
+ * (`volumetrics/gi/`) takes the environment as one more source of it. What the froxel irradiance
+ * volume is started with under IBL, and what a lit particle's ambient is there; reading the
+ * environment itself per pixel, as the forward mesh path does, cost 880 us of lighting's 1,090 us on
+ * the bonfire's overdraw at 1898x926 (RTX 4090).
+ *
+ * The field projected is the one the forward path reads (`get_ibl_irradiance`: the prefiltered map at
+ * roughness 1, times pi), and the radiance stored is what that field is the cosine convolution of, so
+ * convolving it back gives the forward path's diffuse up to what two bands drop. Run by
+ * `GPULightCollection` when the environment changes, after the prefilter it reads.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_project_environment_sh = ComputeShader.from({
+    label: "Environment / project SH",
+    resources,
+    body,
+});

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

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

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

@@ -21,7 +21,8 @@ rows, and the decision to spawn is the GPU's.
 - Scene / bone attachment: an emitter stands at an entity with a row; its world matrix is that row
   of the scene's `transforms` table, composed by the GPU hierarchy pass.
 - Distinct per-particle lifecycle: **no** built-in age/position — the schema + program define state.
-- Billboard drawing reuses engine shader chunks incl. lighting (forward-shaded, optional per emitter).
+- Lighting per emitter (`EMITTER_FLAG.LIGHTING`): the scene's lights from the froxel irradiance
+  volume the fog pass writes, plus the environment map. See "Lighting" below.
 - Blend modes (alpha + additive) via a **single** premultiplied blend setup.
 - Authored curves and RGB/RGBA gradients compiled into arithmetic for simulation.
 - Spawning decided on the GPU, per emitter, with the CPU able to ask for bursts through the same path.
@@ -516,10 +517,9 @@ draw's.
 ### Rendering
 
 A 6-vertex quad is expanded per instance (billboard/velocity-stretch/axis-lock/world modes) by
-`chunk_particle_billboard_vertex`. Fragment: sample atlas (region + flipbook frame), optional forward
-lighting via `chunk_shade_standard_material_direct` + IBL, optional soft-depth fade. Soft-depth
-fading scales both RGB and alpha for premultiplied inputs; straight-alpha and additive inputs have
-alpha scaled before premultiplication.
+`chunk_particle_billboard_vertex`. Fragment: sample atlas (region + flipbook frame), optional
+soft-depth fade, optional lighting (below). Soft-depth fading scales both RGB and alpha for
+premultiplied inputs; straight-alpha and additive inputs have alpha scaled before premultiplication.
 
 Additive vs. alpha is never a pipeline switch: the shader emits premultiplied RGB with alpha 0
 (additive) or alpha a (normal), so one setup covers both and the choice stays per particle and
@@ -778,6 +778,63 @@ was seeded.
 
 Done: `Renderer.feature_particles_enabled` (off by default), `Renderer.particles(scene_ctx)` creating
 one system per scene context on first use, `simulate` recorded before the transparency pass and the
-system passed to the AVBOIT orchestrator as its side channel. Remaining:
-1. For lit emitters, compile a render variant that swaps the disabled lighting hook for a
-   shading-chunk-backed lighting hook (+ the `SHADING_LIGHT_RESOURCE_GROUP`).
+system passed to the AVBOIT orchestrator as its side channel.
+
+### Lighting
+
+An emitter flagged `EMITTER_FLAG.LIGHTING` treats its colour as a diffuse albedo; an emitter without
+it is its own colour, which is what additive (emissive) emitters want and stay. The flag is read per
+fragment from the emitter record, so lit and unlit particles share one pipeline and one draw. All of
+it is evaluated per pixel (`chunk_particle_lighting`, the model in `chunk_particle_lighting_model`):
+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
+  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
+  world-space light lookup this engine does not have).
+- **The SH is evaluated at the normal and the irradiance clamped at zero.** One light gives
+  `E max(0, 1/4 + cos/2)`. SH2 cannot keep two lights apart: a light's lobe is `-E/4` facing away
+  from it, so a light behind a particle subtracts from the ones in front before the clamp sees a
+  total. Measured on the bonfire before transmission, the moon behind the smoke brought the fire-lit
+  side down to about half (display red 10 against 21).
+- **Chroma has no direction**: two lights of different colours from opposite sides tint both sides
+  their mix. Measured on the bonfire, the blue moon moves the fire-lit underside of the smoke from
+  (22.9, 5.3, 1.5) to (15.9, 4.7, 2.6) in display values; a same-coloured moon only brightens it.
+- **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
+  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
+  brick alike; LPV interpolates the tetrahedron the froxel falls in, and gives nothing outside the
+  mesh, as the deferred LPV pass does. Measured at 1898x926 (RTX 4090): the IBL module 5-6 us, the
+  Brick4 module 31 us over an empty map. Reading the environment per pixel instead, as the forward
+  mesh path does, had been 880 us of lighting's 1,090 us — the particle draw is all overdraw.
+- **Back-face transmission** (Persson, "Practical Particle Lighting", GDC 2012, pp.34-37): the same
+  light evaluated at `-normal`, passed on in proportion to `1 - alpha`. The dense core of a puff
+  holds light from behind back and its thin edges let it through — smoke backlit by the moon has an
+  edge instead of being black. It costs nothing measurable: the draw is bound by its texture reads.
+- **The normal** is the quad's own plane per projection mode, turned to the side the eye is on and
+  bent out toward the corners (`particle_billboard_normal`), so a sprite shades as a puff.
+- **The directional light skips the atmosphere's transmittance** the fog applies: meshes are lit by
+  `sun.color` as it stands, and a lit particle has to agree with the surface beside it.
+
+Cost, bonfire (~1,300 live, smoke and soot lit), RTX 4090, lit minus unlit p10 in one page: the
+draw +90..275 us at 1898x926 (of ~450) across runs, +0.8..1.2 ms at 3818x2006 (of ~2.1 ms). The fog pass does
+not get slower for the two extra stores — paired against the tree before it, it measured 77 vs 89 us
+and 280 vs 320 us, reason not established. The volume has no temporal filter of its own: with the
+simulation frozen, lit and unlit smoke change equally from frame to frame even with the screen TAA
+off (0.09 vs 0.09 mean display units). That scene has no shadow edge through the smoke, which is
+where a one-sample-per-froxel volume would show it first.
+
+Open: a particle does not shade the fog or other particles (the volume holds no particle density).