@woosh/meep-engine 3.53.0 → 3.55.0

package/src/shade/renderer/light/world_cluster/shader_world_cluster_assign_lights.js

@@ -0,0 +1,163 @@
+import { COLLECTION_U32_STRUCT_READ } from "../../gpu_primitive/COLLECTION_U32_STRUCT_READ.js";
+import { COLLECTION_U32_STRUCT_WRITE } from "../../gpu_primitive/COLLECTION_U32_STRUCT_WRITE.js";
+import { chunk_grid3d_to_index } from "../../shader/chunk/grid/chunk_grid3d_to_index.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 { IRRADIANCE_CLIPMAP_TILE_BORDER } from "../../volumetrics/irradiance_clipmap/IRRADIANCE_CLIPMAP.js";
+import { IRRADIANCE_CLIPMAP_STRUCT } from "../../volumetrics/irradiance_clipmap/IRRADIANCE_CLIPMAP_STRUCT.js";
+import { chunk_light_cluster_counts } from "../cluster/chunk_light_cluster_counts.js";
+import { CLUSTER_LIGHT_PROXY } from "../cluster/CLUSTER_LIGHT_PROXY.js";
+import { chunk_cluster_light_tuple } from "../cluster/CLUSTER_LIGHT_TYPE.js";
+import { LIGHT_CLUSTER_METADATA } from "../cluster/LIGHT_CLUSTER_METADATA.js";
+import { LIGHT_CLUSTER_LOOKUP_STRUCT } from "../cluster/shader_cluster_assign_lights.js";
+import {
+    chunk_world_cluster_aabb,
+    WORLD_LIGHT_CLUSTER_GRID_SIZE,
+    WORLD_LIGHT_CLUSTER_MAX_LIGHTS_PER_CELL,
+} from "./WORLD_LIGHT_CLUSTER.js";
+
+export const WORLD_CLUSTER_ASSIGN_WORKGROUP_SIZE = Object.freeze([4, 4, 4]);
+const BATCH_SIZE = 64;
+const MAX_PER_TYPE = WORLD_LIGHT_CLUSTER_MAX_LIGHTS_PER_CELL >>> 1;
+
+const resources = new ShaderResourceSetDescriptor();
+
+resources.createGroup()
+    .addUniform("irradiance_clipmap", IRRADIANCE_CLIPMAP_STRUCT)
+    .addStorageBuffer("culled_lights", COLLECTION_U32_STRUCT_READ, false)
+    .addStorageBuffer("proxies", WebGPUArray.from(CLUSTER_LIGHT_PROXY), false)
+    .addStorageBuffer("world_cluster_lookup", LIGHT_CLUSTER_LOOKUP_STRUCT, true)
+    .addStorageBuffer("world_cluster_data", COLLECTION_U32_STRUCT_WRITE, true);
+
+const body = CodeChunk.from(
+    //language=WGSL
+    `
+const GRID_SIZE: u32 = ${WORLD_LIGHT_CLUSTER_GRID_SIZE}u;
+const BATCH_SIZE: u32 = ${BATCH_SIZE}u;
+const MAX_PER_TYPE: u32 = ${MAX_PER_TYPE}u;
+const BORDER: f32 = ${IRRADIANCE_CLIPMAP_TILE_BORDER}.0;
+
+var<workgroup> shared_tuples: array<u32, ${BATCH_SIZE}>;
+var<workgroup> shared_proxies: array<${CLUSTER_LIGHT_PROXY.wgsl_ref}, ${BATCH_SIZE}>;
+
+@compute @workgroup_size(4, 4, 4)
+fn main(
+    @builtin(global_invocation_id) global_id: vec3<u32>,
+    @builtin(local_invocation_index) local_index: u32,
+) {
+    let cascade = global_id.z / GRID_SIZE;
+    let cell = vec3<u32>(global_id.x, global_id.y, global_id.z % GRID_SIZE);
+    let valid_cell = cascade < irradiance_clipmap.cascade_count && all(cell < vec3<u32>(GRID_SIZE));
+
+    var cell_lo = vec3<f32>(0.0);
+    var cell_hi = vec3<f32>(0.0);
+
+    if (valid_cell) {
+        let level = irradiance_clipmap.levels[cascade];
+        let box_min = (vec3<f32>(level.corner) - vec3<f32>(BORDER)) * level.cell_size;
+        let cluster_cell_size = (vec3<f32>(level.size) + vec3<f32>(2.0 * BORDER)) * (level.cell_size / f32(GRID_SIZE));
+        let base_lo = box_min + vec3<f32>(cell) * cluster_cell_size;
+        let half_voxel = vec3<f32>(0.5 * level.cell_size);
+        cell_lo = base_lo - half_voxel;
+        cell_hi = base_lo + cluster_cell_size + half_voxel;
+    }
+
+    var point_ids: array<u32, ${MAX_PER_TYPE}>;
+    var spot_ids: array<u32, ${MAX_PER_TYPE}>;
+    var point_count = 0u;
+    var spot_count = 0u;
+
+    let total_lights = min(culled_lights.count, u32(arrayLength(&proxies)));
+
+    for (var base = 0u; base < total_lights; base += BATCH_SIZE) {
+        let idx = base + local_index;
+        if (idx < total_lights) {
+            shared_tuples[local_index] = culled_lights.elements[idx];
+            shared_proxies[local_index] = proxies[idx];
+        }
+        workgroupBarrier();
+
+        if (valid_cell) {
+            let batch_count = min(BATCH_SIZE, total_lights - base);
+            for (var i = 0u; i < batch_count; i++) {
+                let tuple = shared_tuples[i];
+                let proxy = shared_proxies[i];
+                let light_type = cluster_light_tuple_type(tuple);
+                let light_id = cluster_light_tuple_id(tuple);
+
+                if (light_type == CLUSTER_LIGHT_TYPE_POINT) {
+                    if (point_count < MAX_PER_TYPE) {
+                        if (proxy.unbounded != 0u || world_cluster_sphere_intersects_aabb(proxy.bound.xyz, proxy.bound.w, cell_lo, cell_hi)) {
+                            point_ids[point_count] = light_id;
+                            point_count++;
+                        }
+                    }
+                } else {
+                    if (spot_count < MAX_PER_TYPE) {
+                        if (proxy.unbounded != 0u || world_cluster_cone_intersects_aabb(proxy, cell_lo, cell_hi)) {
+                            spot_ids[spot_count] = light_id;
+                            spot_count++;
+                        }
+                    }
+                }
+            }
+        }
+
+        workgroupBarrier();
+    }
+
+    if (!valid_cell) {
+        return;
+    }
+
+    let cluster_index = grid3d_to_index(vec3<u32>(cell.xy, cascade * GRID_SIZE + cell.z), vec2<u32>(GRID_SIZE));
+    let total_assigned = point_count + spot_count;
+    var offset = 0u;
+
+    if (total_assigned > 0u) {
+        let capacity = u32(arrayLength(&world_cluster_data.elements));
+        let raw_offset = atomicAdd(&world_cluster_data.count, total_assigned);
+        if (raw_offset + total_assigned <= capacity) {
+            offset = raw_offset;
+            for (var p = 0u; p < point_count; p++) {
+                world_cluster_data.elements[offset + p] = point_ids[p];
+            }
+            for (var s = 0u; s < spot_count; s++) {
+                world_cluster_data.elements[offset + point_count + s] = spot_ids[s];
+            }
+        } else {
+            point_count = 0u;
+            spot_count = 0u;
+        }
+    }
+
+    world_cluster_lookup[cluster_index] = ${LIGHT_CLUSTER_METADATA.make({
+        // +4u because COLLECTION_U32_STRUCT_WRITE aligns `elements` to 16 bytes (4 u32 words)
+        offset: "offset + 4u",
+        counts: "light_cluster_pack_counts(point_count, spot_count)",
+    })};
+}
+`, [
+        IRRADIANCE_CLIPMAP_STRUCT.declaration_chunk,
+        CLUSTER_LIGHT_PROXY.declaration_chunk,
+        LIGHT_CLUSTER_METADATA.declaration_chunk,
+        chunk_grid3d_to_index,
+        chunk_world_cluster_aabb,
+        chunk_cluster_light_tuple,
+        chunk_light_cluster_counts,
+    ]
+);
+
+/**
+ * Assigns world-space culled point and spot lights to the `8 × 8 × 8` cluster cells of each
+ * cascade of the world-space irradiance clipmap.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_world_cluster_assign_lights = ComputeShader.from({
+    label: "World cluster / assign lights",
+    resources,
+    body,
+});

package/src/shade/renderer/light/world_cluster/shader_world_cluster_cull_lights.d.ts

@@ -0,0 +1,4 @@
+export const shader_world_cluster_cull_point_lights: ComputeShader;
+export const shader_world_cluster_cull_spot_lights: ComputeShader;
+import { ComputeShader } from "../../shader/ComputeShader.js";
+//# sourceMappingURL=shader_world_cluster_cull_lights.d.ts.map

package/src/shade/renderer/light/world_cluster/shader_world_cluster_cull_lights.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shader_world_cluster_cull_lights.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/light/world_cluster/shader_world_cluster_cull_lights.js"],"names":[],"mappings":"AAwHA,mEAOG;AAEH,kEAOG;8BAtI2B,+BAA+B"}

package/src/shade/renderer/light/world_cluster/shader_world_cluster_cull_lights.js

@@ -0,0 +1,137 @@
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { COMPUTE_SHADER_DEFAULT_GROUP_SIZE } from "../../shader/COMPUTE_SHADER_DEFAULT_GROUP_SIZE.js";
+import { ComputeShader } from "../../shader/ComputeShader.js";
+import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
+import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
+import { chunk_point_lights_iterate } from "../../shader/chunk/light/io/chunk_point_lights_iterate.js";
+import { chunk_spot_lights_iterate } from "../../shader/chunk/light/io/chunk_spot_lights_iterate.js";
+import { SUBGROUP_APPEND_NONE } from "../../shader/chunk/subgroup/chunk_subgroup_append_slot.js";
+import { LIGHT_DATABASE_SPEC } from "../LIGHT_DATABASE_SPEC.js";
+import { chunk_collection_u32_append } from "../../gpu_primitive/chunk_collection_u32_append.js";
+import { COLLECTION_U32_STRUCT_WRITE } from "../../gpu_primitive/COLLECTION_U32_STRUCT_WRITE.js";
+import { chunk_cluster_light_proxy } from "../cluster/chunk_cluster_light_proxy.js";
+import { CLUSTER_LIGHT_PROXY, CLUSTER_LIGHT_PROXY_UNBOUNDED_RADIUS } from "../cluster/CLUSTER_LIGHT_PROXY.js";
+import { CLUSTER_LIGHT_TYPE, chunk_cluster_light_tuple } from "../cluster/CLUSTER_LIGHT_TYPE.js";
+import { chunk_world_cluster_aabb, WORLD_LIGHT_CLUSTER_CULL_SETTINGS } from "./WORLD_LIGHT_CLUSTER.js";
+
+const POINT_DESCRIPTOR = LIGHT_DATABASE_SPEC.get("light_point");
+const SPOT_DESCRIPTOR = LIGHT_DATABASE_SPEC.get("light_spot");
+
+const WORKGROUP_SIZE = COMPUTE_SHADER_DEFAULT_GROUP_SIZE;
+
+function build_world_cull_shader({
+    label,
+    prefix_upper,
+    prefix_lower,
+    iterate_chunk,
+    read_chunk,
+    is_spot,
+}) {
+    const resources = new ShaderResourceSetDescriptor();
+
+    resources.createGroup()
+        .addUniform("settings", WORLD_LIGHT_CLUSTER_CULL_SETTINGS)
+        .addStorageBuffer("light_data", WebGPUArray.u32, false)
+        .addStorageBuffer("output_list", COLLECTION_U32_STRUCT_WRITE, true)
+        .addStorageBuffer("proxies", WebGPUArray.from(CLUSTER_LIGHT_PROXY), true);
+
+    const build_proxy_wgsl = is_spot
+        ? /* language=WGSL */ `
+                let light = ${SPOT_DESCRIPTOR.marshalling_method_read}(&light_data, light_index);
+                let apex = light.position;
+                let direction = normalize(light.direction);
+                let height = light.distance + light.radius;
+                proxy.apex_height = vec4<f32>(apex, height);
+                proxy.direction_cos = vec4<f32>(direction, light.coneCos);
+                proxy.source_radius = light.radius;
+                if (light.distance <= 0.0) {
+                    proxy.unbounded = 1u;
+                    proxy.bound = vec4<f32>(apex, ${CLUSTER_LIGHT_PROXY_UNBOUNDED_RADIUS.toExponential()});
+                } else {
+                    proxy.bound = cluster_spot_bound(apex, direction, height, light.coneCos, light.radius);
+                }
+                want = proxy.unbounded != 0u || world_cluster_cone_intersects_aabb(proxy, settings.coarsest_min, settings.coarsest_max);
+`
+        : /* language=WGSL */ `
+                let light = ${POINT_DESCRIPTOR.marshalling_method_read}(&light_data, light_index);
+                let radius = select(light.radius + light.distance, ${CLUSTER_LIGHT_PROXY_UNBOUNDED_RADIUS.toExponential()}, light.distance <= 0.0);
+                proxy.unbounded = select(0u, 1u, light.distance <= 0.0);
+                proxy.bound = vec4<f32>(light.position, radius);
+                proxy.source_radius = light.radius;
+                want = proxy.unbounded != 0u || world_cluster_sphere_intersects_aabb(proxy.bound.xyz, proxy.bound.w, settings.coarsest_min, settings.coarsest_max);
+`;
+
+    const cluster_type = is_spot ? CLUSTER_LIGHT_TYPE.Spot : CLUSTER_LIGHT_TYPE.Point;
+
+    const body = CodeChunk.from(
+        //language=WGSL
+        `
+@compute @workgroup_size(${WORKGROUP_SIZE}, 1, 1)
+fn main(@builtin(global_invocation_id) global_id: vec3<u32>) {
+    if (settings.cascade_count == 0u) {
+        return;
+    }
+
+    let id = global_id.x;
+    let page_index = id / ${prefix_upper}_ELEMENTS_PER_PAGE;
+    let in_page_slot = id % ${prefix_upper}_ELEMENTS_PER_PAGE;
+
+    var want = false;
+    var light_index = 0u;
+    var proxy: ${CLUSTER_LIGHT_PROXY.wgsl_ref};
+
+    if (page_index < ${prefix_upper}_PAGE_LIMIT) {
+        let page_address = ${prefix_lower}_page_address(&light_data, page_index);
+        if (page_address != ~0u) {
+            let word_index = in_page_slot >> 5u;
+            let bit = in_page_slot & 31u;
+            let bitmap_word = ${prefix_lower}_page_bitmap_word(&light_data, page_address, word_index);
+            if ((bitmap_word & (1u << bit)) != 0u) {
+                light_index = ${prefix_lower}_slot_to_index(page_index, in_page_slot);
+${build_proxy_wgsl}
+            }
+        }
+    }
+
+    let capacity = min(u32(arrayLength(&output_list.elements)), u32(arrayLength(&proxies)));
+    let tuple = cluster_light_tuple_pack(light_index, ${cluster_type}u);
+    let slot = collection_u32_append(&output_list, want, tuple, capacity);
+    if (slot != ${SUBGROUP_APPEND_NONE}u) {
+        proxies[slot] = proxy;
+    }
+}
+`, [
+        CLUSTER_LIGHT_PROXY.declaration_chunk,
+        chunk_cluster_light_proxy,
+        chunk_world_cluster_aabb,
+        chunk_cluster_light_tuple,
+        chunk_collection_u32_append,
+        iterate_chunk,
+        read_chunk,
+        ]
+    );
+
+    return ComputeShader.from({
+        label,
+        resources,
+        body,
+    });
+}
+
+export const shader_world_cluster_cull_point_lights = build_world_cull_shader({
+    label: "World cluster / cull point lights",
+    prefix_upper: "POINT_LIGHTS",
+    prefix_lower: "point_lights",
+    iterate_chunk: chunk_point_lights_iterate,
+    read_chunk: POINT_DESCRIPTOR.chunk_read,
+    is_spot: false,
+});
+
+export const shader_world_cluster_cull_spot_lights = build_world_cull_shader({
+    label: "World cluster / cull spot lights",
+    prefix_upper: "SPOT_LIGHTS",
+    prefix_lower: "spot_lights",
+    iterate_chunk: chunk_spot_lights_iterate,
+    read_chunk: SPOT_DESCRIPTOR.chunk_read,
+    is_spot: true,
+});

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

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

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

@@ -1 +1 @@
-{"version":3,"file":"GPUParticleSystem.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/particles/GPUParticleSystem.js"],"names":[],"mappings":"AA4DA;;;;;;;;;;;;;GAaG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6FG;AACH;IAmLI;;;;;;OAMG;IACH,sBANW,MAAM,iBACN,OAAO,6BAA6B,EAAE,eAAe;QAEpC,QAAQ,GAAzB,MAAM;QACW,sBAAsB,GAAvC,MAAM;OAoBhB;IA1MD;;;OAGG;IACH,UAFU,MAAM,CAEP;IAET;;;;OAIG;IACH,eAFU,OAAO,6BAA6B,EAAE,eAAe,CAEjD;IAEd;;;OAGG;IACH,UAFU,MAAM,CAEP;IAET;;OAEG;IACH,UAFU,eAAe,CAEhB;IAET;;;OAGG;IACH,OAFU,MAAM,CAEN;IAEV;;;OAGG;IACH,MAFU,MAAM,CAEP;IAET;;;OAGG;IACH,qBAFU,MAAM,CAEQ;IAExB;;;;OAIG;IACH,sBAAM;IAEN,yBAAyB;IACzB,0BAAc;IAEd;;;;;;;;;;;OAWG;IACH,SAFU,MAAM,CAEH;IA4Ib;;;OAGG;IACH,kCAEC;IAED;;;OAGG;IACH,yEAEC;IAED;;;;;;;;;;;;OAYG;IACH,eAFa,MAAM,CAIlB;IAED;;;;;;;OAOG;IACH,eAHW,OAAO,8BAA8B,EAAE,eAAe,SACtD,MAAM,QAwBhB;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;IACH;QAPkG,KAAK,EAA5F,OAAO,2DAA2D,EAAE,UAAU;QAC/D,MAAM,EAArB,MAAM;QACS,cAAc,EAA7B,MAAM;QAES,EAAE,EAAjB,MAAM;QACJ,OAAO,sBAAsB,EAAE,yBAAyB,CAgEpE;IAiBD;;;;;;;;;OASG;IACH;QANgG,KAAK,EAA1F,OAAO,2DAA2D,EAAE,UAAU;QACjE,MAAM,EAAnB,MAAM;QACkB,kBAAkB,EAA1C,UAAU,MAAM,CAAC;QACJ,SAAS,EAAtB,MAAM;QACJ,MAAM,CAalB;IAED;;;;;;;;;;OAUG;IACH;QAPgG,KAAK,EAA1F,OAAO,2DAA2D,EAAE,UAAU;QACjE,MAAM,EAAnB,MAAM;QACO,IAAI,EAAjB,MAAM;QACO,aAAa,EAA1B,MAAM;QACsD,MAAM,EAAlE;YAAC,UAAU,EAAE,MAAM,CAAC;YAAC,QAAQ,EAAE,MAAM,CAAC;YAAC,KAAK,EAAE,MAAM,CAAA;SAAC;QACnD;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAC,CAkBjE;IAED;;;;;;;;;;;;;;;;OAgBG;IACH;QAbgG,KAAK,EAA1F,OAAO,2DAA2D,EAAE,UAAU;QACrB,QAAQ,EAAjE,OAAO,2BAA2B,EAAE,cAAc;QACrC,MAAM,EAAnB,MAAM;QACO,aAAa,EAA1B,MAAM;QACO,IAAI,EAAjB,MAAM;QACO,QAAQ,EAArB,MAAM;QACO,eAAe,EAA5B,MAAM;QACO,oBAAoB,EAAjC,MAAM;QAC0B,sBAAsB,EAAtD;YAAC,CAAC,EAAE,MAAM,CAAC;YAAC,IAAI,EAAE,MAAM,CAAA;SAAC;QAEiD,YAAY,EAAtF;YAAC,KAAK,EAAE,MAAM,CAAC;YAAC,IAAI,EAAE,MAAM,CAAC;YAAC,UAAU,EAAE,MAAM,CAAC;YAAC,QAAQ,EAAE,MAAM,CAAA;SAAC;QACjE;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAC,CAuB/E;IAED;;;;;;;;;OASG;IACH,qBAHW,OAAO,8BAA8B,EAAE,eAAe,iBACtD,MAAM,QAehB;IAED;;;;OAIG;IACH,wBAFW,OAAO,8BAA8B,EAAE,eAAe,QAMhE;IAED;;;;;OAKG;IACH,2BAHW,OAAO,8BAA8B,EAAE,eAAe,iBACtD,MAAM,QAMhB;IA6bD;;;;;;;OAOG;IACH;YAFoB,MAAM,GAAE,MAAM;MAgBjC;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,cAFa,QAAQ,mBAAmB,CAAC,CA8BxC;IAED,gBA2BC;;CACJ;;;;;;;;WA9oCa,MAAM;;;;UACN,MAAM;;;;kBACN,MAAM;;;;;cACN,MAAM;;;;;gBAEN,MAAM;;;;;oBAEN,MAAM;;gCAxCY,8BAA8B"}
+{"version":3,"file":"GPUParticleSystem.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/particles/GPUParticleSystem.js"],"names":[],"mappings":"AA4DA;;;;;;;;;;;;;GAaG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6FG;AACH;IAmLI;;;;;;OAMG;IACH,sBANW,MAAM,iBACN,OAAO,6BAA6B,EAAE,eAAe;QAEpC,QAAQ,GAAzB,MAAM;QACW,sBAAsB,GAAvC,MAAM;OAoBhB;IA1MD;;;OAGG;IACH,UAFU,MAAM,CAEP;IAET;;;;OAIG;IACH,eAFU,OAAO,6BAA6B,EAAE,eAAe,CAEjD;IAEd;;;OAGG;IACH,UAFU,MAAM,CAEP;IAET;;OAEG;IACH,UAFU,eAAe,CAEhB;IAET;;;OAGG;IACH,OAFU,MAAM,CAEN;IAEV;;;OAGG;IACH,MAFU,MAAM,CAEP;IAET;;;OAGG;IACH,qBAFU,MAAM,CAEQ;IAExB;;;;OAIG;IACH,sBAAM;IAEN,yBAAyB;IACzB,0BAAc;IAEd;;;;;;;;;;;OAWG;IACH,SAFU,MAAM,CAEH;IA4Ib;;;OAGG;IACH,kCAEC;IAED;;;OAGG;IACH,yEAEC;IAED;;;;;;;;;;;;OAYG;IACH,eAFa,MAAM,CAIlB;IAED;;;;;;;OAOG;IACH,eAHW,OAAO,8BAA8B,EAAE,eAAe,SACtD,MAAM,QAwBhB;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;IACH;QAPkG,KAAK,EAA5F,OAAO,2DAA2D,EAAE,UAAU;QAC/D,MAAM,EAArB,MAAM;QACS,cAAc,EAA7B,MAAM;QAES,EAAE,EAAjB,MAAM;QACJ,OAAO,sBAAsB,EAAE,yBAAyB,CAgEpE;IAiBD;;;;;;;;;OASG;IACH;QANgG,KAAK,EAA1F,OAAO,2DAA2D,EAAE,UAAU;QACjE,MAAM,EAAnB,MAAM;QACkB,kBAAkB,EAA1C,UAAU,MAAM,CAAC;QACJ,SAAS,EAAtB,MAAM;QACJ,MAAM,CAalB;IAED;;;;;;;;;;OAUG;IACH;QAPgG,KAAK,EAA1F,OAAO,2DAA2D,EAAE,UAAU;QACjE,MAAM,EAAnB,MAAM;QACO,IAAI,EAAjB,MAAM;QACO,aAAa,EAA1B,MAAM;QACsD,MAAM,EAAlE;YAAC,UAAU,EAAE,MAAM,CAAC;YAAC,QAAQ,EAAE,MAAM,CAAC;YAAC,KAAK,EAAE,MAAM,CAAA;SAAC;QACnD;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAC,CAkBjE;IAED;;;;;;;;;;;;;;;;OAgBG;IACH;QAbgG,KAAK,EAA1F,OAAO,2DAA2D,EAAE,UAAU;QACrB,QAAQ,EAAjE,OAAO,2BAA2B,EAAE,cAAc;QACrC,MAAM,EAAnB,MAAM;QACO,aAAa,EAA1B,MAAM;QACO,IAAI,EAAjB,MAAM;QACO,QAAQ,EAArB,MAAM;QACO,eAAe,EAA5B,MAAM;QACO,oBAAoB,EAAjC,MAAM;QAC0B,sBAAsB,EAAtD;YAAC,CAAC,EAAE,MAAM,CAAC;YAAC,IAAI,EAAE,MAAM,CAAA;SAAC;QAEiD,YAAY,EAAtF;YAAC,KAAK,EAAE,MAAM,CAAC;YAAC,IAAI,EAAE,MAAM,CAAC;YAAC,UAAU,EAAE,MAAM,CAAC;YAAC,QAAQ,EAAE,MAAM,CAAA;SAAC;QACjE;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAC,CAwB/E;IAED;;;;;;;;;OASG;IACH,qBAHW,OAAO,8BAA8B,EAAE,eAAe,iBACtD,MAAM,QAehB;IAED;;;;OAIG;IACH,wBAFW,OAAO,8BAA8B,EAAE,eAAe,QAMhE;IAED;;;;;OAKG;IACH,2BAHW,OAAO,8BAA8B,EAAE,eAAe,iBACtD,MAAM,QAMhB;IA6bD;;;;;;;OAOG;IACH;YAFoB,MAAM,GAAE,MAAM;MAgBjC;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,cAFa,QAAQ,mBAAmB,CAAC,CA8BxC;IAED,gBA2BC;;CACJ;;;;;;;;WA/oCa,MAAM;;;;UACN,MAAM;;;;kBACN,MAAM;;;;;cACN,MAAM;;;;;gBAEN,MAAM;;;;;oBAEN,MAAM;;gCAxCY,8BAA8B"}

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

@@ -56,7 +56,7 @@ const STORAGE_GROWABLE = GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST | GPUB
  */
 const INDIRECT = GPUBufferUsage.STORAGE | GPUBufferUsage.INDIRECT | GPUBufferUsage.COPY_SRC;
 
-const DEFAULT_CAPACITY = 131072;
+const DEFAULT_CAPACITY = 65536;
 
 /**
  * What {@link GPUParticleSystem#read_stats} decodes: the counts the GPU keeps between frames, named.
@@ -618,6 +618,7 @@ export class GPUParticleSystem {
         const { handles } = this.#simulated_for(graph);
 
         return graph_particle_avboit_draw({
+            scene_context: this.scene_context,
             graph,
             view_ctx,
             camera,
@@ -1120,8 +1121,8 @@ export class GPUParticleSystem {
         this.atlas_sampler = device.createSampler({
             label: "particles/atlas_sampler",
             magFilter: "linear",
-            minFilter: "linear",
-            mipmapFilter: "linear",
+            minFilter: "linear",
+            mipmapFilter: "linear",
             maxAnisotropy: 16,
             addressModeU: "clamp-to-edge",
             addressModeV: "clamp-to-edge",

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

@@ -70,8 +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 {{Y: number, CoCg: number, uniform?: number}} params.volumetrics_irradiance graph handles of
+ *   the world-space irradiance clipmap 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
@@ -81,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, volumetrics_irradiance, accumulators, atlas, atlas_sampler, pool, alive, emitter_database, draw_args, }: {
+export function graph_particle_avboit_draw({ graph, view_ctx, scene_context, 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;
@@ -93,6 +93,7 @@ export function graph_particle_avboit_draw({ graph, view_ctx, camera, depth_text
     volumetrics_irradiance: {
         Y: number;
         CoCg: number;
+        uniform?: number;
     };
     accumulators: {
         color: 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;;;;;;;;;;;;;;;;;;;;;;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"}
+{"version":3,"file":"graph_particles_avboit.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/particles/graph_particles_avboit.js"],"names":[],"mappings":"AA2CA;;;;;;;;;;;;;;;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,CA0EjE;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;IAC8C,sBAAsB,EAA1E;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAA;KAAC;IAEiC,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,CAmI/E"}

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

@@ -3,14 +3,18 @@ import { SamplerDescriptor } from "../../descriptor/texture/SamplerDescriptor.js
 import { TextureViewDescriptor } from "../../descriptor/texture/TextureViewDescriptor.js";
 import { DEFAULT_DEPTH_TEXTURE_VIEW } from "../depth/DEFAULT_DEPTH_TEXTURE_VIEW.js";
 import { AVBOIT_OCCUPANCY_SETTINGS_STRUCT } from "../rasterize/native/avboit/shader_avboit_occupancy.js";
+import {
+    METRO_L1_IRRADIANCE_STRUCT
+} from "../shader/chunk/spherical_harmonics/l1i/chunk_convert_to_irradiance_sh.js";
 import { STATIC_GRAPHICS_ENGINE_ASSETS } from "../STATIC_GRAPHICS_ENGINE_ASSETS.js";
-import { shader_particle_avboit_occupancy } from "./shaders/shader_particle_avboit_occupancy.js";
+import { IRRADIANCE_CLIPMAP_STRUCT } from "../volumetrics/irradiance_clipmap/IRRADIANCE_CLIPMAP_STRUCT.js";
 import {
-    PARTICLE_AVBOIT_DRAW_ALPHA_PIPELINE,
     PARTICLE_AVBOIT_DRAW_ADDITIVE_PIPELINE,
+    PARTICLE_AVBOIT_DRAW_ALPHA_PIPELINE,
     PARTICLE_AVBOIT_DRAW_GENERAL_PIPELINE,
     PARTICLE_AVBOIT_DRAW_RESOURCES,
 } from "./shaders/shader_particle_avboit_draw.js";
+import { shader_particle_avboit_occupancy } from "./shaders/shader_particle_avboit_occupancy.js";
 import {
     PARTICLE_AVBOIT_SPLAT_PIPELINE,
     PARTICLE_AVBOIT_SPLAT_RESOURCES,
@@ -135,10 +139,6 @@ export function graph_particle_avboit_splat({
     function execute(data, resources, context) {
         const encoder = context.encoder;
 
-        // By name, never by position: the order a shader declares its bindings in is the shader's
-        // business, and a list built here to match it binds a sampler where a texture goes the
-        // moment a binding is inserted anywhere but the end. The device rejects that, and only when
-        // the pass is first encoded on real hardware. See the layout-kind check in the spec.
         const bindings = PARTICLE_AVBOIT_SPLAT_RESOURCES.generateBindings({
             camera: resources.get(data.camera),
             warp: resources.get(data.warp),
@@ -205,8 +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 {{Y: number, CoCg: number, uniform?: number}} params.volumetrics_irradiance graph handles of
+ *   the world-space irradiance clipmap 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
@@ -219,6 +219,7 @@ export function graph_particle_avboit_splat({
 export function graph_particle_avboit_draw({
                                                graph,
                                                view_ctx,
+                                               scene_context,
                                                camera,
                                                depth_texture,
                                                warp,
@@ -246,6 +247,16 @@ export function graph_particle_avboit_draw({
 
         const t_depth = resources.get(data.depth);
         const depth_view = t_depth.obtainView(DEFAULT_DEPTH_TEXTURE_VIEW);
+        const linear_sampler = graphics.samplers.obtain(SAMPLER_LINEAR);
+
+        const irradiance_clipmap_buffer = data.irradiance_uniform !== undefined
+            ? resources.get(data.irradiance_uniform)
+            : (view_ctx.volumetrics?.irradiance_clipmap?.uniform
+                ?? encoder.allocateTransientBuffer(GPUBufferUsage.UNIFORM, IRRADIANCE_CLIPMAP_STRUCT.size));
+
+        const far_field_sh_buffer = scene_context?.lights?.far_field_irradiance_sh
+            ?? view_ctx.scene?.lights?.far_field_irradiance_sh
+            ?? encoder.allocateTransientBuffer(GPUBufferUsage.UNIFORM, METRO_L1_IRRADIANCE_STRUCT.aligned_size);
 
         // by name rather than by position, for the reason the splat gives
         const bindings = PARTICLE_AVBOIT_DRAW_RESOURCES.generateBindings({
@@ -259,12 +270,15 @@ export function graph_particle_avboit_draw({
             atlas_sampler,
             scene_depth: depth_view,
             tIntegral: resources.get(data.integral).obtainView(),
-            sLinear: graphics.samplers.obtain(SAMPLER_LINEAR),
+            sLinear: linear_sampler,
             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(),
+            irradiance_clipmap: irradiance_clipmap_buffer,
+            irradiance_clipmap_atlas_y: resources.get(data.irradiance_Y).obtainView(),
+            irradiance_clipmap_atlas_cocg: resources.get(data.irradiance_CoCg).obtainView(),
+            irradiance_clipmap_sampler: linear_sampler,
+            far_field_irradiance_sh: far_field_sh_buffer,
         }, encoder);
 
         const attachment = (handle) => ({
@@ -312,6 +326,9 @@ export function graph_particle_avboit_draw({
     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);
+    if (volumetrics_irradiance.uniform !== undefined) {
+        pass_data.irradiance_uniform = pass.read(volumetrics_irradiance.uniform);
+    }
     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_lighting.d.ts

@@ -1,19 +1,15 @@
 /**
  * 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, as the surfaces around the particle receive them. One trilinear read of each
- * of its two textures, so the cost grows with neither the lights nor the GI; the price is resolution —
- * a froxel is 16 pixels across and a slice deep, and light and shadow edges inside a particle are that
- * soft.
+ * `particle_apply_lighting(color, world_position, normal)` treats the particle's colour as a diffuse
+ * albedo and returns what it reflects and transmits (`chunk_particle_lighting_model`), sampled from
+ * the world-space irradiance clipmap (`chunk_irradiance_clipmap_sample_with_far_field`):
  *
- * 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.
+ * - Inside the clipmap cascades, performs a single-cascade stochastic tap using a non-linear
+ *   `smoothstep` transition across each cascade's blend-skirt (`irradiance_clipmap.blend_skirt`,
+ *   default `IRRADIANCE_CLIPMAP_DEFAULT_BLEND_SKIRT = 2` voxels), with `random_u` generated via
+ *   `hash_lowbias32_vec2u` and `hash_to_float01`.
+ * - Across the coarsest cascade's blend-skirt and outside all cascades (`CLIPMAP_LEVEL_NONE`),
+ *   smoothly falls back to `far_field_irradiance_sh` (cached on `GPULightCollection`).
  *
  * @type {CodeChunk}
  */

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":"AAMA;;;;;;;;;;;;;;;;;;GAkBG;AACH,sCAFU,SAAS,CAgBZ;0BAvCmB,oCAAoC"}
+{"version":3,"file":"chunk_particle_lighting.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/shaders/chunk_particle_lighting.js"],"names":[],"mappings":"AAUA;;;;;;;;;;;;;;GAcG;AACH,sCAFU,SAAS,CAmBZ;0BAvCmB,oCAAoC"}

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

@@ -1,25 +1,25 @@
+import { chunk_hash_to_float01 } from "../../shader/chunk/random/chunk_hash_to_float01.js";
+import { chunk_hash_lowbias32_vec2u } from "../../shader/chunk/random/lowbias/chunk_hash_lowbias32_vec2u.js";
+import { chunk_hash_lowbias32_vec3u } from "../../shader/chunk/random/lowbias/chunk_hash_lowbias32_vec3u.js";
 import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { VIEW_RESOURCE } from "../../view/VIEW_RESOURCE.js";
 import {
-    volumetrics_position_world_to_froxel_uvw
-} from "../../volumetrics/volumetrics_position_world_to_froxel_uvw.js";
+    chunk_irradiance_clipmap_sample_with_far_field
+} from "../../volumetrics/irradiance_clipmap/chunk_irradiance_clipmap_sample.js";
 import { chunk_particle_lighting_model } from "./chunk_particle_lighting_model.js";
 
 /**
  * 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, as the surfaces around the particle receive them. One trilinear read of each
- * of its two textures, so the cost grows with neither the lights nor the GI; the price is resolution —
- * a froxel is 16 pixels across and a slice deep, and light and shadow edges inside a particle are that
- * soft.
+ * `particle_apply_lighting(color, world_position, normal)` treats the particle's colour as a diffuse
+ * albedo and returns what it reflects and transmits (`chunk_particle_lighting_model`), sampled from
+ * the world-space irradiance clipmap (`chunk_irradiance_clipmap_sample_with_far_field`):
  *
- * 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.
+ * - Inside the clipmap cascades, performs a single-cascade stochastic tap using a non-linear
+ *   `smoothstep` transition across each cascade's blend-skirt (`irradiance_clipmap.blend_skirt`,
+ *   default `IRRADIANCE_CLIPMAP_DEFAULT_BLEND_SKIRT = 2` voxels), with `random_u` generated via
+ *   `hash_lowbias32_vec2u` and `hash_to_float01`.
+ * - Across the coarsest cascade's blend-skirt and outside all cascades (`CLIPMAP_LEVEL_NONE`),
+ *   smoothly falls back to `far_field_irradiance_sh` (cached on `GPULightCollection`).
  *
  * @type {CodeChunk}
  */
@@ -27,14 +27,19 @@ 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> {
-    let uvw = volumetrics_position_world_to_froxel_uvw(world_position);
+    let pos_hash = hash_lowbias32_vec3u(bitcast<vec3<u32>>(world_position));
+    let random_u = hash_to_float01(hash_lowbias32_vec2u(vec2<u32>(pos_hash, view.frame_index)));
 
-    let sh_Y = textureSampleLevel(tIrradianceY, sLinear, uvw, 0.0);
-    let sh_CoCg = textureSampleLevel(tIrradianceCoCg, sLinear, uvw, 0.0).xy;
+    let sh = irradiance_clipmap_sample_with_far_field(world_position, random_u);
 
-    return particle_lit(color, sh_Y, sh_CoCg, normal);
+    return particle_lit(color, sh.Y, sh.CoCg, normal);
 }
 `, [
-        volumetrics_position_world_to_froxel_uvw,
+        chunk_hash_lowbias32_vec3u,
+        chunk_hash_lowbias32_vec2u,
+        chunk_hash_to_float01,
+        chunk_irradiance_clipmap_sample_with_far_field,
         chunk_particle_lighting_model,
     ]);
+
+chunk_particle_lighting.requireResource(VIEW_RESOURCE);

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":"AAyMA,2EAAsI;AACtI,8EAA2I;AAC3I,6EAA8I;AAE9I,mEAAmE;AACnE,yEAAwD;AAExD,mDAAmD;AACnD,2DAAsD;yCAjNb,iEAAiE;4CAa9D,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":"AAwLA,2EAAsI;AACtI,8EAA2I;AAC3I,6EAA8I;AAE9I,mEAAmE;AACnE,yEAAwD;AAExD,mDAAmD;AACnD,2DAAsD;yCA/Lb,iEAAiE;4CAU9D,sDAAsD;iCACjE,kCAAkC"}