@woosh/meep-engine 3.37.0 → 3.39.0

package/src/shade/renderer/shadow/map/csm/shader/shader_csm_caster_range.d.ts

@@ -1,13 +1,14 @@
 export const CSM_CASTER_RANGE_WORKGROUP_SIZE: number;
 /**
- * What one directional shadow map's accumulate pass runs with: the frusta the CPU fitted this
- * frame, and where in the scratch buffer this map's cascades accumulate.
+ * What one directional shadow map's accumulate pass runs with, besides its cascades' planes: the
+ * light's axis, and where in the scratch buffer the map's cascades accumulate.
  *
  * @type {WebGPUStruct}
  */
 export const CSM_CASTER_RANGE_SETTINGS_STRUCT: WebGPUStruct;
 /**
- * What the publish pass runs with.
+ * What the publish pass runs with: the map's cascades, as the `shadow_directional` range names them.
+ * Its scratch words are the same rows' — see {@link CSM_CASTER_RANGE_SETTINGS_STRUCT#base}.
  *
  * @type {WebGPUStruct}
  */
@@ -43,10 +44,11 @@ export const CSM_CASTER_RANGE_PUBLISH_STRUCT: WebGPUStruct;
  */
 export const shader_csm_caster_range_accumulate: ComputeShader;
 /**
- * Copy one map's accumulated ranges into its row of the light database's `shadow_csm_caster_range`
- * table — where the readback reads them from — and reset the scratch for the next frame.
+ * Copy one map's accumulated ranges into its cascades' rows of the light database's
+ * `shadow_cascade` table — the `caster_near` field and nothing else, which the readback reads — and
+ * reset the scratch for the next frame.
  *
- * One workgroup, one thread: the row is one record, written whole.
+ * One workgroup, one thread: a map has a handful of cascades.
  *
  * @type {ComputeShader}
  */

package/src/shade/renderer/shadow/map/csm/shader/shader_csm_caster_range.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_csm_caster_range.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shadow/map/csm/shader/shader_csm_caster_range.js"],"names":[],"mappings":"AAcA,qDAAiF;AAEjF;;;;;GAKG;AACH,+CAFU,YAAY,CAmBc;AAEpC;;;;GAIG;AACH,8CAFU,YAAY,CAQa;AAqFnC;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,iDAFU,aAAa,CAMpB;AAUH;;;;;;;GAOG;AACH,8CAFU,aAAa,CAgCpB;6BAvN0B,yCAAyC;8BAGxC,qCAAqC"}
+{"version":3,"file":"shader_csm_caster_range.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shadow/map/csm/shader/shader_csm_caster_range.js"],"names":[],"mappings":"AAaA,qDAAiF;AAEjF;;;;;GAKG;AACH,+CAFU,YAAY,CAgBc;AAEpC;;;;;GAKG;AACH,8CAFU,YAAY,CAKa;AAyFnC;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,iDAFU,aAAa,CAMpB;AAUH;;;;;;;;GAQG;AACH,8CAFU,aAAa,CA2BpB;6BAjN0B,yCAAyC;8BAGxC,qCAAqC"}

package/src/shade/renderer/shadow/map/csm/shader/shader_csm_caster_range.js

@@ -9,14 +9,13 @@ import { ShaderResourceSetDescriptor } from "../../../../shader/resource/ShaderR
 import { chunk_atomic_min_f32_storage } from "../../../../shader/chunk/atomic/chunk_atomic_min_f32_storage.js";
 import { LIGHT_DATABASE_SPEC } from "../../../../light/LIGHT_DATABASE_SPEC.js";
 import { MESHES_TABLE } from "../../../../scene/chunk_scene_database_access.js";
-import { CSM_CASTER_RANGE_UNKNOWN } from "../CSM_CASTER_RANGE_STRUCT.js";
-import { SHADOWMAP_CSM_CASCADE_COUNT } from "../SHADOWMAP_CSM_CASCADE_COUNT.js";
+import { CSM_CASTER_RANGE_UNKNOWN } from "../CSM_CASCADE_STRUCT.js";
 
 export const CSM_CASTER_RANGE_WORKGROUP_SIZE = COMPUTE_SHADER_DEFAULT_GROUP_SIZE;
 
 /**
- * What one directional shadow map's accumulate pass runs with: the frusta the CPU fitted this
- * frame, and where in the scratch buffer this map's cascades accumulate.
+ * What one directional shadow map's accumulate pass runs with, besides its cascades' planes: the
+ * light's axis, and where in the scratch buffer the map's cascades accumulate.
  *
  * @type {WebGPUStruct}
  */
@@ -28,41 +27,40 @@ export const CSM_CASTER_RANGE_SETTINGS_STRUCT = WebGPUStruct.from({
      */
     z_axis: vec4f,
     /**
-     * The four side planes of each cascade's light frustum, four per cascade in cascade order,
-     * inward: `dot(n, p) + w >= 0` is inside. Not normalized, and they need not be.
-     */
-    planes: WebGPUArray.from(vec4f, SHADOWMAP_CSM_CASCADE_COUNT * 4),
-    /**
-     * First scratch word of this map's cascades: cascade `c` accumulates into `base + c`.
+     * First scratch word of this map's cascades: cascade `c` accumulates into `base + c`. The
+     * scratch has a word per row of the `shadow_cascade` table, so this is the map's first cascade
+     * row.
      */
     base: u32,
     cascade_count: u32,
 }, "CSMCasterRangeSettings").pack();
 
 /**
- * What the publish pass runs with.
+ * What the publish pass runs with: the map's cascades, as the `shadow_directional` range names them.
+ * Its scratch words are the same rows' — see {@link CSM_CASTER_RANGE_SETTINGS_STRUCT#base}.
  *
  * @type {WebGPUStruct}
  */
 export const CSM_CASTER_RANGE_PUBLISH_STRUCT = WebGPUStruct.from({
-    /** the map's row of the light database's `shadow_csm_caster_range` table */
-    row: u32,
-    /** see {@link CSM_CASTER_RANGE_SETTINGS_STRUCT#base} */
-    base: u32,
+    first_cascade: u32,
     cascade_count: u32,
 }, "CSMCasterRangePublish").pack();
 
 const WG = CSM_CASTER_RANGE_WORKGROUP_SIZE;
 const PG = MESHES_TABLE.page_iterator_symbol_prefix(WG);
-const RANGE_TABLE = LIGHT_DATABASE_SPEC.get('shadow_csm_caster_range');
+const CASCADE_TABLE = LIGHT_DATABASE_SPEC.get('shadow_cascade');
 
 const accumulate_resources = new ShaderResourceSetDescriptor();
 
 accumulate_resources.createGroup()
     .addStorageBuffer('scene_database', WebGPUArray.from(u32), false)
     .addUniform('settings', CSM_CASTER_RANGE_SETTINGS_STRUCT)
-    // one word per cascade per map, holding plain f32 bit patterns, seeded to the largest finite
-    // f32 and reset to it by the publish
+    // The four side planes of each cascade's light frustum, four per cascade in cascade order,
+    // inward: `dot(n, p) + w >= 0` is inside. Not normalized, and they need not be. As many as the
+    // map has cascades, which is why they are not in the uniform.
+    .addStorageBuffer('planes', WebGPUArray.from(vec4f), false)
+    // one word per cascade row, holding plain f32 bit patterns, seeded to the largest finite f32
+    // and reset to it by the publish
     .addStorageBuffer('ranges', WebGPUArray.from(atomic_u32), true);
 
 const accumulate_body = CodeChunk.from(
@@ -110,7 +108,7 @@ fn main(
         var inside = live;
 
         for (var p = 0u; p < 4u; p += 1u) {
-            let plane = settings.planes[c * 4u + p];
+            let plane = planes[c * 4u + p];
 
             // the corner furthest along the normal decides whether any of the box is inside
             let furthest = select(low, high, plane.xyz >= vec3<f32>(0.0));
@@ -179,10 +177,11 @@ publish_resources.createGroup()
     .addStorageBuffer('light_database', WebGPUArray.from(u32), true);
 
 /**
- * Copy one map's accumulated ranges into its row of the light database's `shadow_csm_caster_range`
- * table — where the readback reads them from — and reset the scratch for the next frame.
+ * Copy one map's accumulated ranges into its cascades' rows of the light database's
+ * `shadow_cascade` table — the `caster_near` field and nothing else, which the readback reads — and
+ * reset the scratch for the next frame.
  *
- * One workgroup, one thread: the row is one record, written whole.
+ * One workgroup, one thread: a map has a handful of cascades.
  *
  * @type {ComputeShader}
  */
@@ -196,24 +195,19 @@ const RANGE_UNKNOWN = ${CSM_CASTER_RANGE_UNKNOWN};
 
 @compute @workgroup_size(1,1,1)
 fn main() {
-    var near: array<f32, ${SHADOWMAP_CSM_CASCADE_COUNT}>;
+    for (var c = 0u; c < publish.cascade_count; c += 1u) {
+        // a cascade's scratch word is its row
+        let row = publish.first_cascade + c;
 
-    for (var c = 0u; c < ${SHADOWMAP_CSM_CASCADE_COUNT}u; c += 1u) {
-        if c < publish.cascade_count {
-            let word = publish.base + c;
+        let near = bitcast<f32>(atomicLoad(&ranges[row]));
 
-            near[c] = bitcast<f32>(atomicLoad(&ranges[word]));
+        atomicStore(&ranges[row], bitcast<u32>(RANGE_UNKNOWN));
 
-            atomicStore(&ranges[word], bitcast<u32>(RANGE_UNKNOWN));
-        } else {
-            near[c] = RANGE_UNKNOWN;
-        }
+        ${CASCADE_TABLE.marshalling_method_write_field('caster_near')}(&light_database, row, near);
     }
-
-    ${RANGE_TABLE.marshalling_method_write_field('near')}(&light_database, publish.row, near);
 }
 `, [
-            RANGE_TABLE.wgsl_gen_write_field_code('near'),
+            CASCADE_TABLE.wgsl_gen_write_field_code('caster_near'),
         ]),
     resources: publish_resources,
 });

package/src/shade/renderer/shadow/map/shader/chunk_shadowmap_csm_compute_cascade_blended.d.ts

@@ -1,8 +1,9 @@
 /**
  * 'view_direction' is used to figure out the direction of the blend.
  *
- * Takes the per-light cascades array (already loaded from the `shadow_directional` table)
- * by value rather than re-reading from a global, so the caller controls the read pattern.
+ * Walks a map's cascades — `cascade_count` rows of the `shadow_cascade` table from `first_cascade`,
+ * nearest first, as its `shadow_directional` record names them — and reads each one as it gets to
+ * it: the first that holds the position is the one, so the cascades past it are never read.
  *
  * @see https://github.com/TheRealMJP/Shadows/blob/338290a57e7c65d493783fd48f39a28321e84e81/Shadows/Mesh.hlsl#L740
  * @type {CodeChunk}

package/src/shade/renderer/shadow/map/shader/chunk_shadowmap_csm_compute_cascade_blended.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_shadowmap_csm_compute_cascade_blended.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shadow/map/shader/chunk_shadowmap_csm_compute_cascade_blended.js"],"names":[],"mappings":"AAsBA;;;;;;;;GAQG;AACH,0DAFU,SAAS,CA+GlB;0BA1IyB,uCAAuC"}
+{"version":3,"file":"chunk_shadowmap_csm_compute_cascade_blended.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shadow/map/shader/chunk_shadowmap_csm_compute_cascade_blended.js"],"names":[],"mappings":"AAuBA;;;;;;;;;GASG;AACH,0DAFU,SAAS,CAkHlB;0BA9IyB,uCAAuC"}

package/src/shade/renderer/shadow/map/shader/chunk_shadowmap_csm_compute_cascade_blended.js

@@ -1,17 +1,18 @@
+import { LIGHT_DATABASE_SPEC } from "../../../light/LIGHT_DATABASE_SPEC.js";
 import { f32, u32 } from "../../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
 import { WebGPUStruct } from "../../../shader/type/WebGPUStruct.js";
 import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
-import { SHADOWMAP_CSM_CASCADE_COUNT } from "../csm/SHADOWMAP_CSM_CASCADE_COUNT.js";
 import { SHADOWMAP_FILTER_SIZE } from "../SHADOWMAP_FILTER_SIZE.js";
-import { SHADOWMAP_VIEW_METADATA_STRUCT } from "./SHADOWMAP_VIEW_METADATA_STRUCT.js";
+
+const CASCADE_DESCRIPTOR = LIGHT_DATABASE_SPEC.get('shadow_cascade');
 
 const CASCADE_BLEND_INFO = WebGPUStruct.from({
     /**
-     * First cascade to blend
+     * First cascade to blend, as its `shadow_cascade` row
      */
     index_0: u32,
     /**
-     * Second cascade to blend
+     * Second cascade to blend, as its `shadow_cascade` row
      */
     index_1: u32,
     /**
@@ -23,8 +24,9 @@ const CASCADE_BLEND_INFO = WebGPUStruct.from({
 /**
  * 'view_direction' is used to figure out the direction of the blend.
  *
- * Takes the per-light cascades array (already loaded from the `shadow_directional` table)
- * by value rather than re-reading from a global, so the caller controls the read pattern.
+ * Walks a map's cascades — `cascade_count` rows of the `shadow_cascade` table from `first_cascade`,
+ * nearest first, as its `shadow_directional` record names them — and reads each one as it gets to
+ * it: the first that holds the position is the one, so the cascades past it are never read.
  *
  * @see https://github.com/TheRealMJP/Shadows/blob/338290a57e7c65d493783fd48f39a28321e84e81/Shadows/Mesh.hlsl#L740
  * @type {CodeChunk}
@@ -33,15 +35,18 @@ export const chunk_shadowmap_csm_compute_cascade_blended = CodeChunk.from(
     //language=WGSL
     `
 fn shadowmap_csm_compute_cascade_blended(
+    database: ptr<storage, array<u32>>,
+    first_cascade: u32,
+    cascade_count: u32,
     position_ws: vec3f,
     view_direction_ws: vec3f,
-    cascades: array<${SHADOWMAP_VIEW_METADATA_STRUCT.wgsl_ref}, ${SHADOWMAP_CSM_CASCADE_COUNT}>,
 ) -> ${CASCADE_BLEND_INFO.wgsl_ref} {
 
     const BLEND_BORDER_FRACTION: f32 = 0.07;
 
-    for(var i = 0u; i < ${SHADOWMAP_CSM_CASCADE_COUNT}; i++){
-        let m = cascades[i];
+    for(var i = 0u; i < cascade_count; i++){
+        let row = first_cascade + i;
+        let m = ${CASCADE_DESCRIPTOR.marshalling_method_read}(database, row);
 
         // Select based on whether or not the pixel is inside the projection
         // used for rendering to the cascade
@@ -55,15 +60,15 @@ fn shadowmap_csm_compute_cascade_blended(
         let valid_extents = vec3(projection_bias, 1.0);
 
         if(all(abs(cascade_position) < valid_extents)){
-            var info = ${CASCADE_BLEND_INFO.make({index_0:"i", index_1:"i", blend:"0.0"})};
+            var info = ${CASCADE_BLEND_INFO.make({index_0:"row", index_1:"row", blend:"0.0"})};
 
             // If this is not the last cascade, check if we need to blend
-            if (i < ${SHADOWMAP_CSM_CASCADE_COUNT - 1}) {
+            if (i + 1u < cascade_count) {
 
-                let next_index = i + 1u;
+                let next_index = row + 1u;
 
                 // check if next cascade covers this position
-                let m1 = cascades[next_index];
+                let m1 = ${CASCADE_DESCRIPTOR.marshalling_method_read}(database, next_index);
 
                  // Select based on whether or not the pixel is inside the projection
                 // used for rendering to the cascade
@@ -135,7 +140,7 @@ fn shadowmap_csm_compute_cascade_blended(
     })};
 }
     `, [
-        SHADOWMAP_VIEW_METADATA_STRUCT.declaration_chunk,
+        CASCADE_DESCRIPTOR.chunk_read,
         CASCADE_BLEND_INFO.declaration_chunk,
     ]
 )

package/src/shade/renderer/shadow/map/shader/chunk_shadowmap_sample_directional.d.ts

@@ -1,7 +1,8 @@
 /**
- * Directional-light shadow sampling with CSM cascade blending. The cascade array (atlas + view-
- * projection per cascade) is loaded once from the `shadow_directional` table and passed by value
- * to {@link shadowmap_csm_compute_cascade_blended}.
+ * Directional-light shadow sampling with CSM cascade blending. The light's `shadow_directional`
+ * record names its cascades as a range of `shadow_cascade` rows (atlas + view-projection each);
+ * {@link shadowmap_csm_compute_cascade_blended} picks among them, and the one or two it picks are
+ * read again here to sample.
  * @type {CodeChunk}
  */
 export const chunk_shadowmap_sample_directional: CodeChunk;

package/src/shade/renderer/shadow/map/shader/chunk_shadowmap_sample_directional.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_shadowmap_sample_directional.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shadow/map/shader/chunk_shadowmap_sample_directional.js"],"names":[],"mappings":"AAQA;;;;;GAKG;AACH,iDAFU,SAAS,CAyDjB;0BAnEwB,uCAAuC"}
+{"version":3,"file":"chunk_shadowmap_sample_directional.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shadow/map/shader/chunk_shadowmap_sample_directional.js"],"names":[],"mappings":"AASA;;;;;;GAMG;AACH,iDAFU,SAAS,CA4DjB;0BAxEwB,uCAAuC"}

package/src/shade/renderer/shadow/map/shader/chunk_shadowmap_sample_directional.js

@@ -5,11 +5,13 @@ import { chunk_sample_shadowmap_atlas_for_light } from "./chunk_sample_shadowmap
 import { chunk_shadowmap_csm_compute_cascade_blended } from "./chunk_shadowmap_csm_compute_cascade_blended.js";
 
 const SHADOW_DIRECTIONAL_DESCRIPTOR = LIGHT_DATABASE_SPEC.get('shadow_directional');
+const CASCADE_DESCRIPTOR = LIGHT_DATABASE_SPEC.get('shadow_cascade');
 
 /**
- * Directional-light shadow sampling with CSM cascade blending. The cascade array (atlas + view-
- * projection per cascade) is loaded once from the `shadow_directional` table and passed by value
- * to {@link shadowmap_csm_compute_cascade_blended}.
+ * Directional-light shadow sampling with CSM cascade blending. The light's `shadow_directional`
+ * record names its cascades as a range of `shadow_cascade` rows (atlas + view-projection each);
+ * {@link shadowmap_csm_compute_cascade_blended} picks among them, and the one or two it picks are
+ * read again here to sample.
  * @type {CodeChunk}
  */
 export const chunk_shadowmap_sample_directional = CodeChunk.from(
@@ -23,12 +25,14 @@ fn shadowmap_sample_directional(
     surface_normal_ws: vec3f,
     light: ${INCIDENT_LIGHT_STRUCT.wgsl_ref},
 ) -> f32 {
-    let cascades = ${SHADOW_DIRECTIONAL_DESCRIPTOR.marshalling_method_read}(database, shadow_id);
+    let shadowmap = ${SHADOW_DIRECTIONAL_DESCRIPTOR.marshalling_method_read}(database, shadow_id);
 
     let cascade_info = shadowmap_csm_compute_cascade_blended(
+        database,
+        shadowmap.first_cascade,
+        shadowmap.cascade_count,
         position_ws,
         view_direction_ws,
-        cascades,
     );
 
     if(cascade_info.index_0 == ~0u){
@@ -36,7 +40,7 @@ fn shadowmap_sample_directional(
         return 1.0;
     }
 
-    let cascade_meta_0 = cascades[cascade_info.index_0];
+    let cascade_meta_0 = ${CASCADE_DESCRIPTOR.marshalling_method_read}(database, cascade_info.index_0);
 
     let visibility_0 = sample_shadowmap_atlas_for_light(
         cascade_meta_0.projection,
@@ -50,7 +54,7 @@ fn shadowmap_sample_directional(
         return visibility_0;
     }
 
-    let cascade_meta_1 = cascades[cascade_info.index_1];
+    let cascade_meta_1 = ${CASCADE_DESCRIPTOR.marshalling_method_read}(database, cascade_info.index_1);
 
     let visibility_1 = sample_shadowmap_atlas_for_light(
         cascade_meta_1.projection,
@@ -64,6 +68,7 @@ fn shadowmap_sample_directional(
 }
     `, [
         SHADOW_DIRECTIONAL_DESCRIPTOR.chunk_read,
+        CASCADE_DESCRIPTOR.chunk_read,
         chunk_sample_shadowmap_atlas_for_light,
         chunk_shadowmap_csm_compute_cascade_blended,
     ]

package/src/shade/renderer/shadow/map/shadowmap_budget_carry_over.d.ts

@@ -4,10 +4,10 @@
  * run of idle frames does not inflate the pool.
  *
  * The spend it is measured against is the BUDGETED one — the local lights. Directionals are
- * selected unconditionally and cannot be refused, so charging their three cascades each against
- * the pool the locals compete for could only shrink it: `views_spent` then met `budget_total` on
- * every frame, the remainder clamped to zero on every frame, and no local map ever satisfied
- * `views_spent + cost <= budget_total` again. Three directional lights at the default budget of 8,
+ * selected unconditionally and cannot be refused, so charging their cascades (three each by
+ * default) against the pool the locals compete for could only shrink it: `views_spent` then met
+ * `budget_total` on every frame, the remainder clamped to zero on every frame, and no local map
+ * ever satisfied `views_spent + cost <= budget_total` again. Three directional lights at the default budget of 8,
  * or one directional at a budget of 1 or 2, froze every spot and point shadow in the scene on its
  * first frame's depth — moving casters leaving their shadows behind, with `debug_render_count`
  * flat, which reads as converged.

package/src/shade/renderer/shadow/map/shadowmap_budget_carry_over.js

@@ -15,10 +15,10 @@ export const SHADOWMAP_BUDGET_CARRY_OVER_FRAMES = 4;
  * run of idle frames does not inflate the pool.
  *
  * The spend it is measured against is the BUDGETED one — the local lights. Directionals are
- * selected unconditionally and cannot be refused, so charging their three cascades each against
- * the pool the locals compete for could only shrink it: `views_spent` then met `budget_total` on
- * every frame, the remainder clamped to zero on every frame, and no local map ever satisfied
- * `views_spent + cost <= budget_total` again. Three directional lights at the default budget of 8,
+ * selected unconditionally and cannot be refused, so charging their cascades (three each by
+ * default) against the pool the locals compete for could only shrink it: `views_spent` then met
+ * `budget_total` on every frame, the remainder clamped to zero on every frame, and no local map
+ * ever satisfied `views_spent + cost <= budget_total` again. Three directional lights at the default budget of 8,
  * or one directional at a budget of 1 or 2, froze every spot and point shadow in the scene on its
  * first frame's depth — moving casters leaving their shadows behind, with `debug_render_count`
  * flat, which reads as converged.

package/src/shade/renderer/shadow/vsm/GPUViewShadowMaps.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUViewShadowMaps.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shadow/vsm/GPUViewShadowMaps.js"],"names":[],"mappings":"AAaA;IAYI;;;;OAIG;IACH,uDAGC;IAED;;;OAGG;IACH,SAFU,mBAAmB,gBAAgB,CAAC,CAE1B;IAEpB;;OAEG;IACH,+BAEC;IAED;;OAEG;IACH,2BAAO;IA8CP,eAkBC;IAED,qBAEC;IAED,gBAEC;;CACJ;iCA1HgC,uBAAuB"}
+{"version":3,"file":"GPUViewShadowMaps.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shadow/vsm/GPUViewShadowMaps.js"],"names":[],"mappings":"AAaA;IAYI;;;;OAIG;IACH,uDAGC;IAED;;;OAGG;IACH,SAFU,mBAAmB,gBAAgB,CAAC,CAE1B;IAEpB;;OAEG;IACH,+BAEC;IAED;;OAEG;IACH,2BAAO;IAoDP,eA+BC;IAED,qBAEC;IAED,gBAKC;;CACJ;iCAhJgC,uBAAuB"}

package/src/shade/renderer/shadow/vsm/GPUViewShadowMaps.js

@@ -77,22 +77,28 @@ export class GPUViewShadowMaps {
         shadow_camera.top = 100;
         shadow_camera.bottom = -100;
 
-        shadow_camera.transform.setTranslation(0, -10, 0);
-        t64_look_rotation(
-            shadow_camera.transform,
-            light.direction[0], light.direction[1], light.direction[2],
-            0, 1, 0
-        );
+        try {
+            const context = new GPUCameraContext(this.#device, shadow_camera);
+            vsm.light_views.push(context);
+            this.#update_map_for_directional_light(light, vsm);
+        } catch (error) {
+            vsm.destroy();
+            throw error;
+        }
 
-        const context = new GPUCameraContext(this.#device, shadow_camera);
+        return vsm;
+    }
 
+    #update_map_for_directional_light(light, map) {
+        const pose = light.transform;
+        const forward = pose.forward;
+        const up = pose.up;
+        const position = pose.translation;
+        const context = map.light_views[0];
+        const transform = context.camera.transform;
+        transform.setTranslation(position[0], position[1], position[2]);
+        t64_look_rotation(transform, forward[0], forward[1], forward[2], up[0], up[1], up[2]);
         context.update();
-
-        vsm.light_views.push(
-            context
-        );
-
-        return vsm;
     }
 
     update() {
@@ -101,14 +107,27 @@ export class GPUViewShadowMaps {
         const collection = lights.source;
         const light_count = collection.elements.length;
 
+        for (const [light, map] of this.mapping) {
+            if (!collection.has(light) || !light.casts_shadow || light.isDirectionalLight !== true) {
+                map.destroy();
+                this.mapping.delete(light);
+            }
+        }
+
         for (let i = 0; i < light_count; i++) {
             const light = collection.elements[i];
             const map = this.mapping.get(light);
 
-            if (map === undefined && light.isDirectionalLight === true) {
+            if (light.isDirectionalLight !== true || !light.casts_shadow) {
+                continue;
+            }
+
+            if (map === undefined) {
                 const vsm = this.#build_map_for_directional_light(light);
 
-                this.mapping.set(light, vsm)
+                this.mapping.set(light, vsm);
+            } else {
+                this.#update_map_for_directional_light(light, map);
             }
 
         }
@@ -120,6 +139,9 @@ export class GPUViewShadowMaps {
     }
 
     destroy() {
-
+        for (const map of this.mapping.values()) {
+            map.destroy();
+        }
+        this.mapping.clear();
     }
-}
+}

package/src/shade/renderer/shadow/vsm/GPUVirtualShadowTextureResidence.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUVirtualShadowTextureResidence.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shadow/vsm/GPUVirtualShadowTextureResidence.js"],"names":[],"mappings":"AA2BA;;;;GAIG;AACH,wGAQC"}
+{"version":3,"file":"GPUVirtualShadowTextureResidence.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shadow/vsm/GPUVirtualShadowTextureResidence.js"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,wGAIC"}

package/src/shade/renderer/shadow/vsm/GPUVirtualShadowTextureResidence.js

@@ -1,41 +1,10 @@
-import { BindGroupLayoutDescriptor } from "../../../descriptor/binding/BindGroupLayoutDescriptor.js";
-import { BufferBindingLayout } from "../../../descriptor/binding/BufferBindingLayout.js";
-import { ComputePipelineDescriptor } from "../../../descriptor/pipeline/compute/ComputePipelineDescriptor.js";
-import { PipelineLayoutDescriptor } from "../../../descriptor/pipeline/PipelineLayoutDescriptor.js";
-import wgsl from "../../rasterize/expand/pass1/filter_meshlets.2-way.compute.js";
-
-
-const BIND_GROUP_LAYOUT_DESCRIPTOR_0 = BindGroupLayoutDescriptor.forCompute(
-    'io',
-    [
-        // var<storage, read> input: Inputs
-        BufferBindingLayout.readOnlyStorage,
-        // var<storage, read_write> output_positive: Output
-        BufferBindingLayout.storage,
-        // var<storage, read_write> output_maybe: Output;
-        BufferBindingLayout.storage,
-    ]
-);
-
-const pipeline_descriptor = ComputePipelineDescriptor.from(
-    "Unpack Instances to Meshlets",
-    wgsl,
-    PipelineLayoutDescriptor.from([
-            BIND_GROUP_LAYOUT_DESCRIPTOR_0
-        ])
-);
-
 /**
  *
  * @param {ShadeGPUCommandContext} encoder
  * @param {GraphicsContext} graphics
  */
-export function vsm_compute_residence(encoder, graphics,){
-    const pass = encoder.constructComputePass({
-        label: "VSM compute residence",
-        pipeline:pipeline_descriptor,
-        bindings:[]
-    });
-
-    pass.end();
-}
+export function vsm_compute_residence(encoder, graphics) {
+    // This unfinished entry point has no map, camera, depth or output inputs. Previously it
+    // silently encoded an unrelated meshlet pipeline without bindings or a dispatch.
+    throw new Error('vsm_compute_residence is incomplete; use the VSMTileUsagePassData and vsm_time_usage_data frame-graph pass');
+}

package/src/shade/renderer/shadow/vsm/VSM_UNIFORMS_STRUCT.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"VSM_UNIFORMS_STRUCT.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shadow/vsm/VSM_UNIFORMS_STRUCT.js"],"names":[],"mappings":"AAGA,+CAGkB;6BALW,mCAAmC"}
+{"version":3,"file":"VSM_UNIFORMS_STRUCT.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shadow/vsm/VSM_UNIFORMS_STRUCT.js"],"names":[],"mappings":"AAGA,+CAIkB;6BANW,mCAAmC"}

package/src/shade/renderer/shadow/vsm/VSM_UNIFORMS_STRUCT.js

@@ -3,5 +3,6 @@ import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
 
 export const VSM_UNIFORMS_STRUCT = WebGPUStruct.from({
     tile_resolution: u32,
-    resolution_in_tiles: u32
-},"ShadowConfig");
+    resolution_in_tiles: u32,
+    physical_tile_count: u32
+},"ShadowConfig");

package/src/shade/renderer/shadow/vsm/VirtualShadowMap.d.ts

@@ -34,7 +34,7 @@ export class VirtualShadowMap {
      * @param {GPUDevice} device
      * @param {number} [virtual_resolution]
      * @param {number} [physical_resolution]
-     * @param {number} [tile_size]
+     * @param {number} [tile_resolution]
      */
     initialize({ device, virtual_resolution, physical_resolution, tile_resolution }: GPUDevice): void;
     destroy(): void;

package/src/shade/renderer/shadow/vsm/VirtualShadowMap.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"VirtualShadowMap.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shadow/vsm/VirtualShadowMap.js"],"names":[],"mappings":"AAMA;IAEI,wBAAsB;IAEtB;;OAEG;IACH,kBAFU,iBAAiB,CAEV;IAGjB;;;OAGG;IACH,qBAFU,MAAM,CAEQ;IAExB;;OAEG;IACH,qBAAM;IAEN;;OAEG;IACH,aAFU,kBAAkB,CAEX;IAEjB;;OAEG;IACH,2BAAgB;IAGhB;;;;;OAKG;IACH,yBAAa;IAEb,+BAIC;IAED;;;;;;OAMG;IACH,kGAgFC;IAED,gBAYC;CACJ;kCAvJiC,oCAAoC"}
+{"version":3,"file":"VirtualShadowMap.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shadow/vsm/VirtualShadowMap.js"],"names":[],"mappings":"AAIA;IAEI,wBAAsB;IAEtB;;OAEG;IACH,kBAFU,iBAAiB,CAEV;IAGjB;;;OAGG;IACH,qBAFU,MAAM,CAEQ;IAExB;;OAEG;IACH,qBAAM;IAEN;;OAEG;IACH,aAFU,kBAAkB,CAEX;IAEjB;;OAEG;IACH,2BAAgB;IAGhB;;;;;OAKG;IACH,yBAAa;IAEb,+BAGC;IAED;;;;;;OAMG;IACH,kGAuFC;IAED,gBAsBC;CACJ;kCAvKiC,oCAAoC"}