@woosh/meep-engine 3.33.0 → 3.35.0

package/src/shade/renderer/particles/ParticleConstants.d.ts

@@ -253,9 +253,7 @@ export const PARTICLE_SIM_PAD_SLOT: number;
  * Above all it is what the two passes that have to agree on a fragment's coverage agree on: the
  * AVBOIT draw, which weights the accumulators by it, and the AVBOIT splat, which records the
  * extinction the volume then hands to everything behind. A fade in one and not the other is a
- * surface that is invisible and still occludes. The blended billboard pipeline
- * (`shaders/shader_particle_render.js`) reads it too, so a particle fades over the same distance
- * whichever pipeline draws it.
+ * surface that is invisible and still occludes.
  *
  * @type {number}
  */

package/src/shade/renderer/particles/ParticleConstants.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ParticleConstants.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/particles/ParticleConstants.js"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH;;;;;;;;;GASG;AACH,yCAFU,MAAM,CAE6B;AAE7C;;;;GAIG;AACH,6CAFU,MAAM,CAEgC;AAEhD;;;;;;GAMG;AACH,mDAFU,MAAM,CAEuC;AAEvD;;;;;;;;;;;GAWG;AACH,wCAFU,MAAM,CAE4B;AAE5C;;;;;;;GAOG;AACH,2CAFU,MAAM,CAEmC;AAEnD;;;;;;;;;;GAUG;AACH,wCAFU,MAAM,CAE6B;AAE7C;;;;;;;GAOG;AACH,6CAFU,MAAM,CAEkC;AAElD;;;;GAIG;AACH,0CAFU,MAAM,CAE6B;AAE7C;;;;;;;;GAQG;AACH,2CAFU,MAAM,CAEiC;AAEjD;;;GAGG;AACH,6CAFU,MAAM,CAEiC;AAEjD;;;GAGG;AACH,2CAFU,MAAM,CAE8B;AAE9C;;;;;;;;;GASG;AACH,4CAFU,MAAM,CAE+B;AAE/C;;;GAGG;AACH,8CAFU,MAAM,CAEiC;AAEjD;;;GAGG;AACH,8CAFU,MAAM,CAEiC;AAEjD;;;;;;;;;;;;;;;GAeG;AACH,yCAFU,MAAM,CAE8B;AAE9C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,8CAFU,MAAM,CAEkC;AAElD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,4CAFU,MAAM,CAEkC;;AASlD;;;;;;;;;;;;;;;GAeG;AACH,2CAFU,MAAM,CAEiC;AAEjD;;;;;;;;;;;;;;;GAeG;AACH,+CAFU,MAAM,CAEmC;AAEnD;;;;;;;;;;;;GAYG;AACH,oCAFU,MAAM,CAEgC;AAEhD;;;;;;;;;;;;GAYG;AACH,uCAFU,MAAM,CAE4B"}
+{"version":3,"file":"ParticleConstants.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/particles/ParticleConstants.js"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH;;;;;;;;;GASG;AACH,yCAFU,MAAM,CAE6B;AAE7C;;;;GAIG;AACH,6CAFU,MAAM,CAEgC;AAEhD;;;;;;GAMG;AACH,mDAFU,MAAM,CAEuC;AAEvD;;;;;;;;;;;GAWG;AACH,wCAFU,MAAM,CAE4B;AAE5C;;;;;;;GAOG;AACH,2CAFU,MAAM,CAEmC;AAEnD;;;;;;;;;;GAUG;AACH,wCAFU,MAAM,CAE6B;AAE7C;;;;;;;GAOG;AACH,6CAFU,MAAM,CAEkC;AAElD;;;;GAIG;AACH,0CAFU,MAAM,CAE6B;AAE7C;;;;;;;;GAQG;AACH,2CAFU,MAAM,CAEiC;AAEjD;;;GAGG;AACH,6CAFU,MAAM,CAEiC;AAEjD;;;GAGG;AACH,2CAFU,MAAM,CAE8B;AAE9C;;;;;;;;;GASG;AACH,4CAFU,MAAM,CAE+B;AAE/C;;;GAGG;AACH,8CAFU,MAAM,CAEiC;AAEjD;;;GAGG;AACH,8CAFU,MAAM,CAEiC;AAEjD;;;;;;;;;;;;;;;GAeG;AACH,yCAFU,MAAM,CAE8B;AAE9C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,8CAFU,MAAM,CAEkC;AAElD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,4CAFU,MAAM,CAEkC;;AASlD;;;;;;;;;;;;;;;GAeG;AACH,2CAFU,MAAM,CAEiC;AAEjD;;;;;;;;;;;;;;;GAeG;AACH,+CAFU,MAAM,CAEmC;AAEnD;;;;;;;;;;;;GAYG;AACH,oCAFU,MAAM,CAEgC;AAEhD;;;;;;;;;;GAUG;AACH,uCAFU,MAAM,CAE4B"}

package/src/shade/renderer/particles/ParticleConstants.js

@@ -280,9 +280,7 @@ export const PARTICLE_SIM_PAD_SLOT = 0xffffffff;
  * Above all it is what the two passes that have to agree on a fragment's coverage agree on: the
  * AVBOIT draw, which weights the accumulators by it, and the AVBOIT splat, which records the
  * extinction the volume then hands to everything behind. A fade in one and not the other is a
- * surface that is invisible and still occludes. The blended billboard pipeline
- * (`shaders/shader_particle_render.js`) reads it too, so a particle fades over the same distance
- * whichever pipeline draws it.
+ * surface that is invisible and still occludes.
  *
  * @type {number}
  */

package/src/shade/renderer/particles/graph_particles_avboit.d.ts

@@ -70,6 +70,8 @@ export function graph_particle_avboit_splat({ graph, camera, warp, depth_texture
  * @param {number} params.integral graph handle of the integral texture
  * @param {number} params.volumetrics_lut graph handle
  * @param {number} params.volumetrics_metadata graph handle
+ * @param {{Y: number, CoCg: number}} params.volumetrics_irradiance graph handles of the froxel
+ *   irradiance volume a lit emitter's particles are lit by
  * @param {{color: number, norm: number, extinction: number, emission: number}} params.accumulators to add to
  * @param {GPUTextureView} params.atlas
  * @param {GPUSampler} params.atlas_sampler
@@ -79,7 +81,7 @@ export function graph_particle_avboit_splat({ graph, camera, warp, depth_texture
  * @param {number} params.draw_args graph handle of the indirect draw args
  * @returns {{color: number, norm: number, extinction: number, emission: number}} the accumulators after the draw
  */
-export function graph_particle_avboit_draw({ graph, view_ctx, camera, depth_texture, warp, integral, volumetrics_lut, volumetrics_metadata, accumulators, atlas, atlas_sampler, pool, alive, emitter_database, draw_args, }: {
+export function graph_particle_avboit_draw({ graph, view_ctx, camera, depth_texture, warp, integral, volumetrics_lut, volumetrics_metadata, volumetrics_irradiance, accumulators, atlas, atlas_sampler, pool, alive, emitter_database, draw_args, }: {
     graph: import("../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph;
     view_ctx: import("../view/GPUViewContext.js").GPUViewContext;
     camera: number;
@@ -88,6 +90,10 @@ export function graph_particle_avboit_draw({ graph, view_ctx, camera, depth_text
     integral: number;
     volumetrics_lut: number;
     volumetrics_metadata: number;
+    volumetrics_irradiance: {
+        Y: number;
+        CoCg: number;
+    };
     accumulators: {
         color: number;
         norm: number;

package/src/shade/renderer/particles/graph_particles_avboit.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graph_particles_avboit.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/particles/graph_particles_avboit.js"],"names":[],"mappings":"AAuCA;;;;;;;;;;;;;;;GAeG;AACH;IARkG,KAAK,EAA5F,OAAO,2DAA2D,EAAE,UAAU;IAC/D,MAAM,EAArB,MAAM;IACoB,kBAAkB,EAA5C,UAAU,MAAM,CAAC;IACF,SAAS,EAAxB,MAAM;IACS,gBAAgB,EAA/B,MAAM;IACS,mBAAmB,EAAlC,MAAM;IACJ,MAAM,CA8ClB;AAED;;;;;;;;;;;;;;;GAeG;AACH;IAZkG,KAAK,EAA5F,OAAO,2DAA2D,EAAE,UAAU;IAC/D,MAAM,EAArB,MAAM;IACS,IAAI,EAAnB,MAAM;IACwD,MAAM,EAApE;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAC;IAC9B,KAAK;IACT,aAAa;IACjB,IAAI,EAAnB,MAAM;IACS,KAAK,EAApB,MAAM;IACS,gBAAgB,EAA/B,MAAM;IACS,SAAS,EAAxB,MAAM;IACJ;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAC,CA8EjE;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH;IAjBkG,KAAK,EAA5F,OAAO,2DAA2D,EAAE,UAAU;IACnB,QAAQ,EAAnE,OAAO,2BAA2B,EAAE,cAAc;IACnC,MAAM,EAArB,MAAM;IACS,aAAa,EAA5B,MAAM;IACS,IAAI,EAAnB,MAAM;IACS,QAAQ,EAAvB,MAAM;IACS,eAAe,EAA9B,MAAM;IACS,oBAAoB,EAAnC,MAAM;IACsE,YAAY,EAAxF;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAC;IAC5C,KAAK;IACT,aAAa;IACjB,IAAI,EAAnB,MAAM;IACS,KAAK,EAApB,MAAM;IACS,gBAAgB,EAA/B,MAAM;IACS,SAAS,EAAxB,MAAM;IACJ;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAC,CA2G/E"}
+{"version":3,"file":"graph_particles_avboit.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/particles/graph_particles_avboit.js"],"names":[],"mappings":"AAuCA;;;;;;;;;;;;;;;GAeG;AACH;IARkG,KAAK,EAA5F,OAAO,2DAA2D,EAAE,UAAU;IAC/D,MAAM,EAArB,MAAM;IACoB,kBAAkB,EAA5C,UAAU,MAAM,CAAC;IACF,SAAS,EAAxB,MAAM;IACS,gBAAgB,EAA/B,MAAM;IACS,mBAAmB,EAAlC,MAAM;IACJ,MAAM,CA8ClB;AAED;;;;;;;;;;;;;;;GAeG;AACH;IAZkG,KAAK,EAA5F,OAAO,2DAA2D,EAAE,UAAU;IAC/D,MAAM,EAArB,MAAM;IACS,IAAI,EAAnB,MAAM;IACwD,MAAM,EAApE;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAC;IAC9B,KAAK;IACT,aAAa;IACjB,IAAI,EAAnB,MAAM;IACS,KAAK,EAApB,MAAM;IACS,gBAAgB,EAA/B,MAAM;IACS,SAAS,EAAxB,MAAM;IACJ;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAC,CA8EjE;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH;IAnBkG,KAAK,EAA5F,OAAO,2DAA2D,EAAE,UAAU;IACnB,QAAQ,EAAnE,OAAO,2BAA2B,EAAE,cAAc;IACnC,MAAM,EAArB,MAAM;IACS,aAAa,EAA5B,MAAM;IACS,IAAI,EAAnB,MAAM;IACS,QAAQ,EAAvB,MAAM;IACS,eAAe,EAA9B,MAAM;IACS,oBAAoB,EAAnC,MAAM;IAC4B,sBAAsB,EAAxD;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAC;IAEmD,YAAY,EAAxF;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAC;IAC5C,KAAK;IACT,aAAa;IACjB,IAAI,EAAnB,MAAM;IACS,KAAK,EAApB,MAAM;IACS,gBAAgB,EAA/B,MAAM;IACS,SAAS,EAAxB,MAAM;IACJ;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAC,CAkH/E"}

package/src/shade/renderer/particles/graph_particles_avboit.js

@@ -205,6 +205,8 @@ export function graph_particle_avboit_splat({
  * @param {number} params.integral graph handle of the integral texture
  * @param {number} params.volumetrics_lut graph handle
  * @param {number} params.volumetrics_metadata graph handle
+ * @param {{Y: number, CoCg: number}} params.volumetrics_irradiance graph handles of the froxel
+ *   irradiance volume a lit emitter's particles are lit by
  * @param {{color: number, norm: number, extinction: number, emission: number}} params.accumulators to add to
  * @param {GPUTextureView} params.atlas
  * @param {GPUSampler} params.atlas_sampler
@@ -223,6 +225,7 @@ export function graph_particle_avboit_draw({
                                                integral,
                                                volumetrics_lut,
                                                volumetrics_metadata,
+                                               volumetrics_irradiance,
                                                accumulators,
                                                atlas,
                                                atlas_sampler,
@@ -234,6 +237,8 @@ export function graph_particle_avboit_draw({
     assert.defined(accumulators, "accumulators");
     assert.isNonNegativeInteger(depth_texture, "depth_texture");
     assert.isNonNegativeInteger(integral, "integral");
+    assert.isNonNegativeInteger(volumetrics_irradiance.Y, "volumetrics_irradiance.Y");
+    assert.isNonNegativeInteger(volumetrics_irradiance.CoCg, "volumetrics_irradiance.CoCg");
 
     function execute(data, resources, context) {
         const encoder = context.encoder;
@@ -258,6 +263,8 @@ export function graph_particle_avboit_draw({
             volumetrics_metadata: resources.get(data.volumetrics_metadata),
             tVolumetrics: resources.get(data.volumetrics_lut).obtainView(),
             tSTBN_vec3: graphics.textures.obtain(STATIC_GRAPHICS_ENGINE_ASSETS.stbn_vec3).obtainView(),
+            tIrradianceY: resources.get(data.irradiance_Y).obtainView(),
+            tIrradianceCoCg: resources.get(data.irradiance_CoCg).obtainView(),
         }, encoder);
 
         const attachment = (handle) => ({
@@ -303,6 +310,8 @@ export function graph_particle_avboit_draw({
     pass_data.integral = pass.read(integral);
     pass_data.volumetrics_lut = pass.read(volumetrics_lut);
     pass_data.volumetrics_metadata = pass.read(volumetrics_metadata);
+    pass_data.irradiance_Y = pass.read(volumetrics_irradiance.Y);
+    pass_data.irradiance_CoCg = pass.read(volumetrics_irradiance.CoCg);
     pass_data.pool = pass.read(pool);
     pass_data.alive = pass.read(alive);
     pass_data.emitter_database = pass.read(emitter_database);

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

@@ -1,9 +1,8 @@
 /**
  * The billboard vertex stage, shared by every pass that rasterizes particles: the AVBOIT splat and
- * draw, and the blended pipeline `particular` draws its CPU-simulated particles with. One instance
- * per particle, six vertices per instance; the instance indexes the slot list, the vertex picks a
- * quad corner, and the corner is expanded per the emitter's projection mode and projected with the
- * camera.
+ * draw. One instance per particle, six vertices per instance; the instance indexes the slot list,
+ * the vertex picks a quad corner, and the corner is expanded per the emitter's projection mode and
+ * projected with the camera.
  *
  * The enclosing shader binds `camera` (`CAMERA_UNIFORM_STRUCT`), `pool` and `emitter_database`
  * (`array<u32>`) and `draw_list` (the slot list, `array<u32>`) under those names; this reads them

package/src/shade/renderer/particles/shaders/chunk_particle_billboard_vertex.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_particle_billboard_vertex.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/shaders/chunk_particle_billboard_vertex.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;;;;GAiBG;AACH,8CAFU,SAAS,CAuE6D;0BA9FtD,oCAAoC"}
+{"version":3,"file":"chunk_particle_billboard_vertex.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/shaders/chunk_particle_billboard_vertex.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;;;GAgBG;AACH,8CAFU,SAAS,CAyE6D;0BA/FtD,oCAAoC"}

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

@@ -7,10 +7,9 @@ import { chunk_particle_render_math } from "./chunk_particle_render_math.js";
 
 /**
  * The billboard vertex stage, shared by every pass that rasterizes particles: the AVBOIT splat and
- * draw, and the blended pipeline `particular` draws its CPU-simulated particles with. One instance
- * per particle, six vertices per instance; the instance indexes the slot list, the vertex picks a
- * quad corner, and the corner is expanded per the emitter's projection mode and projected with the
- * camera.
+ * draw. One instance per particle, six vertices per instance; the instance indexes the slot list,
+ * the vertex picks a quad corner, and the corner is expanded per the emitter's projection mode and
+ * projected with the camera.
  *
  * The enclosing shader binds `camera` (`CAMERA_UNIFORM_STRUCT`), `pool` and `emitter_database`
  * (`array<u32>`) and `draw_list` (the slot list, `array<u32>`) under those names; this reads them
@@ -77,8 +76,10 @@ fn particle_billboard_vertex(vi : u32, ii : u32) -> ParticleVertexOut {
     let cam_right = camera.transform[0].xyz;
     let cam_up = camera.transform[1].xyz;
     let cam_forward = -camera.transform[2].xyz;
+    let cam_position = camera.transform[3].xyz;
 
-    let offset = particle_billboard_offset(corner, size, rotation, cam_right, cam_up, cam_forward, velocity, particle_emitter_projection(em.flags));
+    let projection = particle_emitter_projection(em.flags);
+    let offset = particle_billboard_offset(corner, size, rotation, cam_right, cam_up, cam_forward, velocity, projection);
     let world = world_center + offset;
 
     var out : ParticleVertexOut;
@@ -86,7 +87,7 @@ fn particle_billboard_vertex(vi : u32, ii : u32) -> ParticleVertexOut {
     out.uv = particle_atlas_uv(corner * 0.5 + vec2<f32>(0.5), em.atlas_region, em.flipbook, frame);
     out.color = color;
     out.world_position = world;
-    out.normal = -cam_forward;
+    out.normal = particle_billboard_normal(offset, cam_position - world, cam_forward, projection);
     out.view_depth = -(camera.view_matrix * vec4<f32>(world, 1.0)).z;
     out.flags = em.flags;
     out.blend = particle_emitter_blend(em.flags);

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

@@ -1,16 +1,22 @@
 /**
- * Pluggable lighting hook for every particle fragment shader — the AVBOIT draw and the blended
- * billboard pipeline alike. `particle_apply_lighting(color, world, normal)` returns the lit colour;
- * the default is a pass-through (unlit / emissive).
+ * How an emitter flagged `EMITTER_FLAG.LIGHTING` is lit, per fragment:
+ * `particle_apply_lighting(color, world, normal)` treats the particle's colour as a diffuse albedo and
+ * 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
+ * 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.
  *
- * A caller swaps this for a chunk that binds
- * {@link ../../deferred/SHADING_LIGHT_RESOURCE_GROUP.js} and calls `shade_standard_material_direct` + IBL —
- * i.e. billboards reuse the exact same lighting path as opaque surfaces when an emitter opts in via
- * its `lighting` flag. Keeping it a hook means unlit emitters compile without pulling in the whole
- * clustered-lighting resource group.
+ * The normal is whatever the vertex stage bent it to (`particle_billboard_normal`), so a camera-facing
+ * sprite reads as a rounded puff rather than a card.
+ *
+ * The enclosing shader binds `camera`, `volumetrics_metadata`, `sLinear`, `tIrradianceY` and
+ * `tIrradianceCoCg` under those names.
  *
  * @type {CodeChunk}
  */
-export const chunk_particle_lighting_unlit: CodeChunk;
+export const chunk_particle_lighting: CodeChunk;
 import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
 //# sourceMappingURL=chunk_particle_lighting.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"chunk_particle_lighting.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/shaders/chunk_particle_lighting.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;GAYG;AACH,4CAFU,SAAS,CAQhB;0BArBuB,oCAAoC"}
+{"version":3,"file":"chunk_particle_lighting.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/shaders/chunk_particle_lighting.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;;;GAkBG;AACH,sCAFU,SAAS,CAgBZ;0BAvCmB,oCAAoC"}

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

@@ -1,22 +1,40 @@
 import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import {
+    volumetrics_position_world_to_froxel_uvw
+} from "../../volumetrics/volumetrics_position_world_to_froxel_uvw.js";
+import { chunk_particle_lighting_model } from "./chunk_particle_lighting_model.js";
 
 /**
- * Pluggable lighting hook for every particle fragment shader — the AVBOIT draw and the blended
- * billboard pipeline alike. `particle_apply_lighting(color, world, normal)` returns the lit colour;
- * the default is a pass-through (unlit / emissive).
+ * How an emitter flagged `EMITTER_FLAG.LIGHTING` is lit, per fragment:
+ * `particle_apply_lighting(color, world, normal)` treats the particle's colour as a diffuse albedo and
+ * 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
+ * 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.
  *
- * A caller swaps this for a chunk that binds
- * {@link ../../deferred/SHADING_LIGHT_RESOURCE_GROUP.js} and calls `shade_standard_material_direct` + IBL —
- * i.e. billboards reuse the exact same lighting path as opaque surfaces when an emitter opts in via
- * its `lighting` flag. Keeping it a hook means unlit emitters compile without pulling in the whole
- * clustered-lighting resource group.
+ * The normal is whatever the vertex stage bent it to (`particle_billboard_normal`), so a camera-facing
+ * sprite reads as a rounded puff rather than a card.
+ *
+ * The enclosing shader binds `camera`, `volumetrics_metadata`, `sLinear`, `tIrradianceY` and
+ * `tIrradianceCoCg` under those names.
  *
  * @type {CodeChunk}
  */
-export const chunk_particle_lighting_unlit = CodeChunk.from(
+export const chunk_particle_lighting = CodeChunk.from(
     /* language=wgsl */
     `
 fn particle_apply_lighting(color : vec4<f32>, world_position : vec3<f32>, normal : vec3<f32>) -> vec4<f32> {
-    return color;
+    let uvw = volumetrics_position_world_to_froxel_uvw(world_position);
+
+    let sh_Y = textureSampleLevel(tIrradianceY, sLinear, uvw, 0.0);
+    let sh_CoCg = textureSampleLevel(tIrradianceCoCg, sLinear, uvw, 0.0).xy;
+
+    return particle_lit(color, sh_Y, sh_CoCg, normal);
 }
-`);
+`, [
+        volumetrics_position_world_to_froxel_uvw,
+        chunk_particle_lighting_model,
+    ]);

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

@@ -0,0 +1,24 @@
+/**
+ * What a lit particle reflects, given what it is lit by — no bindings, so the emulator can run it.
+ * `chunk_particle_lighting` fetches the input: one sample of the froxel irradiance volume
+ * (`chunk_volumetrics_irradiance_sh`), which holds the scene's lights and whatever indirect lighting
+ * the renderer runs, in one encoding.
+ *
+ * - `particle_lighting_received(sh_Y, sh_CoCg, normal)` — the sample evaluated at the normal, the
+ *   irradiance clamped at zero, over pi. One light gives `E max(0, 1/4 + cos/2)`, SH2's band-limited
+ *   clamped cosine. What SH2 cannot do is keep two lights apart: a light's lobe is `-E/4` facing
+ *   directly 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, the moon behind the smoke brings what the fire gives
+ *   the smoke's lit side down to about half.
+ * - `particle_lit(color, sh_Y, sh_CoCg, normal)` — `color` is the particle's albedo and coverage. It
+ *   reflects what falls on its front, and passes on what falls on its back where it is thin:
+ *   back-face transmission (Persson, "Practical Particle Lighting", GDC 2012, pp.34-37), the same
+ *   light evaluated at `-normal` and scaled by `1 - alpha`. The dense core of a puff holds light from
+ *   behind back and its thin edges let it through, which is the silver lining a backlit cloud of
+ *   smoke has and a surface lit from one side cannot.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_particle_lighting_model: CodeChunk;
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_particle_lighting_model.d.ts.map

package/src/shade/renderer/particles/shaders/chunk_particle_lighting_model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_particle_lighting_model.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/shaders/chunk_particle_lighting_model.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,4CAFU,SAAS,CAoBZ;0BAzCmB,oCAAoC"}

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

@@ -0,0 +1,45 @@
+import {
+    chunk_resolve_irradiance_sh_to_diffuse
+} from "../../shader/chunk/spherical_harmonics/l1i/chunk_resolve_irradiance_sh_to_diffuse.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+
+/**
+ * What a lit particle reflects, given what it is lit by — no bindings, so the emulator can run it.
+ * `chunk_particle_lighting` fetches the input: one sample of the froxel irradiance volume
+ * (`chunk_volumetrics_irradiance_sh`), which holds the scene's lights and whatever indirect lighting
+ * the renderer runs, in one encoding.
+ *
+ * - `particle_lighting_received(sh_Y, sh_CoCg, normal)` — the sample evaluated at the normal, the
+ *   irradiance clamped at zero, over pi. One light gives `E max(0, 1/4 + cos/2)`, SH2's band-limited
+ *   clamped cosine. What SH2 cannot do is keep two lights apart: a light's lobe is `-E/4` facing
+ *   directly 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, the moon behind the smoke brings what the fire gives
+ *   the smoke's lit side down to about half.
+ * - `particle_lit(color, sh_Y, sh_CoCg, normal)` — `color` is the particle's albedo and coverage. It
+ *   reflects what falls on its front, and passes on what falls on its back where it is thin:
+ *   back-face transmission (Persson, "Practical Particle Lighting", GDC 2012, pp.34-37), the same
+ *   light evaluated at `-normal` and scaled by `1 - alpha`. The dense core of a puff holds light from
+ *   behind back and its thin edges let it through, which is the silver lining a backlit cloud of
+ *   smoke has and a surface lit from one side cannot.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_particle_lighting_model = CodeChunk.from(
+    /* language=wgsl */
+    `
+fn particle_lighting_received(sh_Y : vec4<f32>, sh_CoCg : vec2<f32>, normal : vec3<f32>) -> vec3<f32> {
+    // E / pi, clamped at zero; the volume is scaled for exactly this read
+    return resolve_irradiance_sh_to_diffuse(sh_Y, sh_CoCg, normal);
+}
+
+fn particle_lit(color : vec4<f32>, sh_Y : vec4<f32>, sh_CoCg : vec2<f32>, normal : vec3<f32>) -> vec4<f32> {
+    let front = particle_lighting_received(sh_Y, sh_CoCg, normal);
+    let back = particle_lighting_received(sh_Y, sh_CoCg, -normal);
+
+    let transmitted = back * (1.0 - saturate(color.a));
+
+    return vec4<f32>(color.rgb * (front + transmitted), color.a);
+}
+`, [
+        chunk_resolve_irradiance_sh_to_diffuse,
+    ]);

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

@@ -8,6 +8,9 @@
  *   every roll angle and every camera. What a bounds pass has to dilate a particle's centre by to
  *   hold its quad, and the reason it sits next to the function it bounds rather than with the bounds
  *   pass: the two are one statement, and they drift the moment they are written apart.
+ * - `particle_billboard_normal` — the normal a lit particle is shaded with at a corner: the plane
+ *   that function lays the quad in, turned to the side the camera sees and bent out toward the
+ *   corner.
  * - `particle_atlas_uv` — map a local quad uv into an atlas sub-rect, honouring a flipbook grid +
  *   frame index (mirrors meep's AtlasPatch offset/scale convention).
  * - `particle_soft_fade` — soft-particle alpha fade from scene-vs-particle view depth.

package/src/shade/renderer/particles/shaders/chunk_particle_render_math.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_particle_render_math.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/shaders/chunk_particle_render_math.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;GAkBG;AACH,yCAFU,SAAS,CA2HhB;0BA/IuB,oCAAoC"}
+{"version":3,"file":"chunk_particle_render_math.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/shaders/chunk_particle_render_math.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,yCAFU,SAAS,CA8JhB;0BArLuB,oCAAoC"}

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

@@ -11,6 +11,9 @@ import { EMITTER_BLEND, EMITTER_PROJECTION } from "../data/PARTICLE_EMITTER_STRU
  *   every roll angle and every camera. What a bounds pass has to dilate a particle's centre by to
  *   hold its quad, and the reason it sits next to the function it bounds rather than with the bounds
  *   pass: the two are one statement, and they drift the moment they are written apart.
+ * - `particle_billboard_normal` — the normal a lit particle is shaded with at a corner: the plane
+ *   that function lays the quad in, turned to the side the camera sees and bent out toward the
+ *   corner.
  * - `particle_atlas_uv` — map a local quad uv into an atlas sub-rect, honouring a flipbook grid +
  *   frame index (mirrors meep's AtlasPatch offset/scale convention).
  * - `particle_soft_fade` — soft-particle alpha fade from scene-vs-particle view depth.
@@ -105,6 +108,41 @@ fn particle_billboard_radius(size : f32, velocity_ws : vec3<f32>, projection : u
     return abs(size) * 1.4142135623730951 * (1.0 + stretch);
 }
 
+// How far a corner's normal leans out of the quad's plane toward the corner: 1 is 45 degrees.
+// Interpolated across the quad that is flat at the centre and rounding off toward the edges, so a
+// sprite of a puff shades like a puff instead of like the card it is drawn on.
+const PARTICLE_NORMAL_CURVATURE : f32 = 1.0;
+
+// The shading normal at a corner that particle_billboard_offset put at offset from the centre.
+//
+// Each projection mode lays the quad on two fixed axes, and the face normal is theirs: the camera
+// plane for BILLBOARD and STRETCHED, world up for HORIZONTAL, the camera direction flattened onto
+// the ground for VERTICAL (world Z when the camera looks straight down, as the offset falls back to
+// world X there), world Z for FACING_WORLD. A quad has two sides and is drawn from both, so the face
+// is turned toward to_camera, the vector from the corner to the eye, not the camera's axis: a
+// camera tilted up at a quad lying on the ground below it still sees its top.
+fn particle_billboard_normal(offset : vec3<f32>, to_camera : vec3<f32>, cam_forward : vec3<f32>, projection : u32) -> vec3<f32> {
+    var face = -cam_forward;
+
+    if (projection == PARTICLE_PROJ_HORIZONTAL) {
+        face = vec3<f32>(0.0, 1.0, 0.0);
+    } else if (projection == PARTICLE_PROJ_VERTICAL) {
+        let horizontal = vec3<f32>(cam_forward.x, 0.0, cam_forward.z);
+        let hl = length(horizontal);
+        face = select(vec3<f32>(0.0, 0.0, 1.0), horizontal / hl, hl > 1e-5);
+    } else if (projection == PARTICLE_PROJ_FACING_WORLD) {
+        face = vec3<f32>(0.0, 0.0, 1.0);
+    }
+
+    face = select(face, -face, dot(face, to_camera) < 0.0);
+
+    // a zero-size particle has no corner to lean toward
+    let ol = length(offset);
+    let outward = select(vec3<f32>(0.0), offset / ol, ol > 0.0);
+
+    return normalize(face + outward * PARTICLE_NORMAL_CURVATURE);
+}
+
 // Map a local quad uv (0..1) into an atlas sub-rect + flipbook cell.
 fn particle_atlas_uv(local_uv : vec2<f32>, region : vec4<f32>, flipbook : vec2<f32>, frame : f32) -> vec2<f32> {
     let cols = max(flipbook.x, 1.0);

package/src/shade/renderer/particles/shaders/shader_particle_avboit_draw.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_particle_avboit_draw.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/shaders/shader_particle_avboit_draw.js"],"names":[],"mappings":"AAgLA,2EAAsI;AACtI,8EAA2I;AAC3I,6EAA8I;AAE9I,mEAAmE;AACnE,yEAAwD;AAExD,mDAAmD;AACnD,2DAAsD;yCAxLb,iEAAiE;4CAW9D,sDAAsD;iCAFjE,kCAAkC"}
+{"version":3,"file":"shader_particle_avboit_draw.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/shaders/shader_particle_avboit_draw.js"],"names":[],"mappings":"AAqLA,2EAAsI;AACtI,8EAA2I;AAC3I,6EAA8I;AAE9I,mEAAmE;AACnE,yEAAwD;AAExD,mDAAmD;AACnD,2DAAsD;yCA7Lb,iEAAiE;4CAW9D,sDAAsD;iCAFjE,kCAAkC"}