@woosh/meep-engine 3.39.0 → 3.40.0

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

@@ -1 +1 @@
-{"version":3,"file":"chunk_sample_shadowmap_atlas_for_light.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shadow/map/shader/chunk_sample_shadowmap_atlas_for_light.js"],"names":[],"mappings":"AAQA;;;;GAIG;AACH,qDAFU,SAAS,CAkEjB;0BA1EwB,uCAAuC"}
+{"version":3,"file":"chunk_sample_shadowmap_atlas_for_light.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shadow/map/shader/chunk_sample_shadowmap_atlas_for_light.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;GAYG;AACH,qDAFU,SAAS,CAyFjB;0BAzGwB,uCAAuC"}

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

@@ -9,6 +9,14 @@ import { chunk_shadowmap_sample_5 } from "./chunk_shadowmap_sample_5.js";
 /**
  * Samples the shadow atlas for a given light, using the supplied shadow projection matrix and
  * atlas rect. Applies receiver normal-offset bias to reduce self-shadowing.
+ *
+ * Two entry points: `sample_shadowmap_atlas_for_light` sizes the bias by a texel's world size as
+ * read off the matrix, and `sample_shadowmap_atlas_with_texel` takes that size from a caller that
+ * knows it exactly — a virtual shadow map's page, whose texel is fixed by its level, where the
+ * matrix's reading grows with the depth range as the light turns toward a world axis.
+ *
+ * A receiver past the far plane is shadowed only by what was drawn in front of it: its reference
+ * depth is held just above the cleared value, which would otherwise compare as shadowed.
  * @type {CodeChunk}
  */
 export const chunk_sample_shadowmap_atlas_for_light = CodeChunk.from(
@@ -21,6 +29,27 @@ fn sample_shadowmap_atlas_for_light(
     light: ${INCIDENT_LIGHT_STRUCT.wgsl_ref},
     atlas_aabb: vec4f, // x0,y0, width, height
 ) -> f32{
+    let projection_scale = m4_projection_size(projection_matrix);
+    let world_pixel_size = max(projection_scale.x, projection_scale.y) / atlas_aabb.z;
+
+    return sample_shadowmap_atlas_with_texel(
+        projection_matrix,
+        world_pixel_size,
+        position_ws,
+        surface_normal,
+        light,
+        atlas_aabb,
+    );
+}
+
+fn sample_shadowmap_atlas_with_texel(
+    projection_matrix: mat4x4f, // shadow VIEW-projection matrix (combined view * projection)
+    world_pixel_size: f32, // world size of a texel of the map
+    position_ws: vec3f,
+    surface_normal: vec3f,
+    light: ${INCIDENT_LIGHT_STRUCT.wgsl_ref},
+    atlas_aabb: vec4f, // x0,y0, width, height
+) -> f32{
 
     const NORMAL_BIAS_SCALE = 0.5;
 
@@ -31,8 +60,10 @@ fn sample_shadowmap_atlas_for_light(
     // camera.far (contact shadows detach as the far plane grows).
     const DEPTH_BIAS_TEXELS = 0.5;
 
-    let projection_scale = m4_projection_size(projection_matrix);
-    let world_pixel_size = max(projection_scale.x, projection_scale.y) / atlas_aabb.z;
+    // Reverse-Z clears to 0 and compares "greater": past the far plane a receiver's depth is <= 0,
+    // and against a texel nothing was drawn into it would read shadowed. Held just above 0, it
+    // reads lit there and still shadowed by anything drawn.
+    const DEPTH_FLOOR = 1e-6;
 
     let shadowmap_bias = get_shadow_offsets(surface_normal, light.direction);
     let normal_offset = world_pixel_size * shadowmap_bias.x * surface_normal * NORMAL_BIAS_SCALE;
@@ -54,7 +85,7 @@ fn sample_shadowmap_atlas_for_light(
     let light_coords = light_uvw.xy * atlas_aabb.zw;
 
     // bias is already applied in world space (depth_offset above)
-    let depth = light_uvw.z;
+    let depth = max(light_uvw.z, DEPTH_FLOOR);
 
     // Clamp so the whole filter footprint stays inside this light's atlas tile (bias can
     // push coordinates outside it). The optimized 5-tap kernel reaches ±2.25 texels around

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

@@ -1,6 +1,7 @@
 /**
- * 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);
+ * Directional-light shadow sampling. The light's `shadow_directional` record either names a virtual
+ * shadow map, sampled by {@link shadowmap_sample_virtual}, or names its cascades as a range of
+ * `shadow_cascade` rows (atlas + view-projection each), with CSM cascade blending:
  * {@link shadowmap_csm_compute_cascade_blended} picks among them, and the one or two it picks are
  * read again here to sample.
  * @type {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":"AASA;;;;;;GAMG;AACH,iDAFU,SAAS,CA4DjB;0BAxEwB,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":"AAWA;;;;;;;GAOG;AACH,iDAFU,SAAS,CAwEjB;0BAtFwB,uCAAuC"}

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

@@ -1,15 +1,18 @@
+import { GPU_DATABASE_NULL } from "../../../buffer/table/GPU_DATABASE_NULL.js";
 import { LIGHT_DATABASE_SPEC } from "../../../light/LIGHT_DATABASE_SPEC.js";
 import { INCIDENT_LIGHT_STRUCT } from "../../../shader/chunk/light/INCIDENT_LIGHT_STRUCT.js";
 import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
 import { chunk_sample_shadowmap_atlas_for_light } from "./chunk_sample_shadowmap_atlas_for_light.js";
 import { chunk_shadowmap_csm_compute_cascade_blended } from "./chunk_shadowmap_csm_compute_cascade_blended.js";
+import { chunk_shadowmap_sample_virtual } from "../../vsm/shader/chunk_shadowmap_sample_virtual.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 light's `shadow_directional`
- * record names its cascades as a range of `shadow_cascade` rows (atlas + view-projection each);
+ * Directional-light shadow sampling. The light's `shadow_directional` record either names a virtual
+ * shadow map, sampled by {@link shadowmap_sample_virtual}, or names its cascades as a range of
+ * `shadow_cascade` rows (atlas + view-projection each), with CSM cascade blending:
  * {@link shadowmap_csm_compute_cascade_blended} picks among them, and the one or two it picks are
  * read again here to sample.
  * @type {CodeChunk}
@@ -27,6 +30,17 @@ fn shadowmap_sample_directional(
 ) -> f32 {
     let shadowmap = ${SHADOW_DIRECTIONAL_DESCRIPTOR.marshalling_method_read}(database, shadow_id);
 
+    if (shadowmap.virtual_map != ${GPU_DATABASE_NULL}u) {
+        // a virtual shadow map rather than cascades
+        return shadowmap_sample_virtual(
+            database,
+            shadowmap.virtual_map,
+            position_ws,
+            surface_normal_ws,
+            light,
+        );
+    }
+
     let cascade_info = shadowmap_csm_compute_cascade_blended(
         database,
         shadowmap.first_cascade,
@@ -71,5 +85,6 @@ fn shadowmap_sample_directional(
         CASCADE_DESCRIPTOR.chunk_read,
         chunk_sample_shadowmap_atlas_for_light,
         chunk_shadowmap_csm_compute_cascade_blended,
+        chunk_shadowmap_sample_virtual,
     ]
 );

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

@@ -1 +1 @@
-{"version":3,"file":"chunk_shadowmap_sample_point2.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shadow/map/shader/chunk_shadowmap_sample_point2.js"],"names":[],"mappings":"AAgBA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,4CAFU,SAAS,CAiGjB;0BA3HwB,uCAAuC"}
+{"version":3,"file":"chunk_shadowmap_sample_point2.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shadow/map/shader/chunk_shadowmap_sample_point2.js"],"names":[],"mappings":"AAgBA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,4CAFU,SAAS,CAqGjB;0BA/HwB,uCAAuC"}

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

@@ -1,133 +1,137 @@
-import { LIGHT_DATABASE_SPEC } from "../../../light/LIGHT_DATABASE_SPEC.js";
-import { chunk_cone_sample_direction } from "../../../shader/chunk/geometry/cone/chunk_cone_sample_direction.js";
-import {
-    chunk_uv_octahedral_unit_encode
-} from "../../../shader/chunk/geometry/octahedron/chunk_uv_octahedral_unit_encode.js";
-import { chunk_random } from "../../../shader/chunk/random/chunk_random.js";
-import { chunk_random_round_vec2 } from "../../../shader/chunk/random/chunk_random_round_vec2.js";
-import { chunk_random_vec2 } from "../../../shader/chunk/random/chunk_random_vec2.js";
-import { chunk_uv_to_texel_coordinate } from "../../../shader/chunk/texture/chunk_uv_to_texel_coordinate.js";
-import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
-import { chunk_get_shadow_offsets } from "./chunk_get_shadow_offsets.js";
-import { chunk_contact_harden_pcf_kernel } from "./dpcf/chunk_contact_harden_pcf_kernel.js";
-import { chunk_max_penumbra_percentage } from "./dpcf/chunk_max_penumbra_percentage.js";
-
-const SHADOW_POINT_DESCRIPTOR = LIGHT_DATABASE_SPEC.get('shadow_point');
-
-/**
- * Cone-sampled point shadow PCF: 8 random directions inside a cone around the receiver-to-light
- * vector, each re-encoded to the light's octahedral map, one `textureLoad` per tap, ending in
- * {@link chunk_contact_harden_pcf_kernel}. Tap directions come from {@link chunk_random}, which the
- * calling shader (deferred lighting / volumetrics) initialises per invocation, so neighbouring
- * pixels decorrelate without a rotation table or a blue-noise disk.
- *
- * The aperture is the GDC bulb-radius scaling in {@link chunk_max_penumbra_percentage}; the factor
- * of 2 carries over the texels → tangent-plane conversion an earlier disk-based variant used (1
- * atlas texel ≈ 2/face_dim of Δn.xy near the +Z pole), so the angular footprint stays comparable.
- *
- * Addressing: `atlas_aabb` is the INNER octahedral surface, and the cube → octahedral remap
- * surrounds it with a `SHADOWMAP_ATLAS_BORDER`-texel skirt holding
- * `inner[texture_octahedral_wrap_texel_coordinates(local)]`. Under the bilinear convention
- * `uv * size - 0.5` a uv on the edge of the square rounds to -1 or `size` — one texel into that
- * skirt, which is this light's own wrapped data. The encode always lands in [0, 1]² and the round
- * can overshoot by at most one texel, so the aperture needs no clamp.
- *
- * @see chunk_cone_sample_direction
- * @type {CodeChunk}
- */
-export const chunk_shadowmap_sample_point2 = CodeChunk.from(
-    //language=WGSL
-    `
-fn shadowmap_sample_point(
-    database: ptr<storage, array<u32>>,
-    shadow_id: u32,
-    position_ws: vec3f,
-    surface_normal_ws: vec3f,
-    light_position_ws: vec3f,
-    light_max_distance: f32,
-    light_radius: f32,
-) -> f32 {
-    const NORMAL_BIAS_SCALE = 2.0;
-    const DEPTH_OFFSET_BIAS = 0.0001;
-
-    let atlas_aabb = ${SHADOW_POINT_DESCRIPTOR.marshalling_method_read}(database, shadow_id);
-
-    // unbiased distance and light direction, used to compute the bias amounts
-    let to_light_unbiased = light_position_ws - position_ws;
-    let dist_to_light_unbiased = length(to_light_unbiased);
-    let light_direction = to_light_unbiased / max(dist_to_light_unbiased, 1e-6);
-
-    let world_pixel_size = 2.0 * dist_to_light_unbiased / max(atlas_aabb.z, 1.0);
-    let shadowmap_bias = get_shadow_offsets(surface_normal_ws, light_direction);
-    let normal_offset = world_pixel_size * shadowmap_bias.x * surface_normal_ws * NORMAL_BIAS_SCALE;
-
-    // re-evaluate direction and distance from the normal-biased position
-    let to_surface = (position_ws + normal_offset) - light_position_ws;
-    let distance_to_center = length(to_surface);
-
-    // Direction the cube faces captured: FROM LIGHT TO SURFACE
-    let dir_light_to_surface = to_surface / max(distance_to_center, 1e-6);
-
-    let face_size = vec2u(atlas_aabb.zw);
-
-    // reverse-Z convention: close to light -> 1, at or beyond light_max_distance -> 0.
-    let radial = distance_to_center / max(light_max_distance, 1e-6);
-    let depth_bias = DEPTH_OFFSET_BIAS * shadowmap_bias.y;
-    let reference_depth = (1.0 - saturate(radial)) + depth_bias;
-
-    // Cone aperture (~ tan of the half-angle). max_penumbra_percentage is the GDC formula mapping
-    // bulb radius to a fraction of the atlas face; the 2× factor is the texels → tangent-plane
-    // conversion. Unclamped — see the header on why any aperture stays addressable.
-    let cone_aperture = 2.0 * max_penumbra_percentage(light_radius, light_radius);
-
-    var occluders: f32 = 0.0;
-    var occluder_dist_sum: f32 = 0.0;
-
-    for (var tap: u32 = 0u; tap < 8u; tap++) {
-
-        let xi = random_vec2();
-
-        let perturbed_dir = cone_sample_direction(dir_light_to_surface, cone_aperture, xi);
-
-        let octahedral_uv = uv_octahedral_unit_encode(perturbed_dir);
-        let local_texel = uv_to_texel_coordinate(octahedral_uv, face_size);
-
-        // one of the two neighbours at random rather than a blend of them: stochastic bilinear
-        let rounded_local_texel = random_round_vec2(local_texel);
-
-        // Signed: the round reaches -1 at a uv of 0, and the skirt is where that tap belongs. Via
-        // u32 the -1 would be an indeterminate conversion — 0xFFFFFFFF reaches the skirt through
-        // the wrapping add, 0 silently reads the opposite edge of the inner surface. i32 is exact
-        // here, and the inner origin is at least SHADOWMAP_ATLAS_BORDER, so the sum is positive.
-        let sample_texel = vec2<u32>(vec2<i32>(rounded_local_texel) + vec2<i32>(atlas_aabb.xy));
-
-        let stored = textureLoad(shadowmapAtlas, sample_texel, 0);
-        let dist = stored - reference_depth;
-
-        // Per-tap binary compare; reverse-Z + step(0, stored - ref) ⇒ 1 = occluded.
-        let occluded = step(0.0, dist);
-
-        occluders += occluded;
-        occluder_dist_sum += dist * occluded;
-    }
-
-    return contact_harden_pcf_kernel(
-        occluders,
-        occluder_dist_sum,
-        reference_depth,
-
-    );
-}
-    `, [
-        SHADOW_POINT_DESCRIPTOR.chunk_read,
-        chunk_cone_sample_direction,
-        chunk_contact_harden_pcf_kernel,
-        chunk_get_shadow_offsets,
-        chunk_max_penumbra_percentage,
-        chunk_random,
-        chunk_uv_octahedral_unit_encode,
-        chunk_uv_to_texel_coordinate,
-        chunk_random_round_vec2,
-        chunk_random_vec2,
-    ]
-);
+import { LIGHT_DATABASE_SPEC } from "../../../light/LIGHT_DATABASE_SPEC.js";
+import { chunk_cone_sample_direction } from "../../../shader/chunk/geometry/cone/chunk_cone_sample_direction.js";
+import {
+    chunk_uv_octahedral_unit_encode
+} from "../../../shader/chunk/geometry/octahedron/chunk_uv_octahedral_unit_encode.js";
+import { chunk_random } from "../../../shader/chunk/random/chunk_random.js";
+import { chunk_random_round_vec2 } from "../../../shader/chunk/random/chunk_random_round_vec2.js";
+import { chunk_random_vec2 } from "../../../shader/chunk/random/chunk_random_vec2.js";
+import { chunk_uv_to_texel_coordinate } from "../../../shader/chunk/texture/chunk_uv_to_texel_coordinate.js";
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+import { chunk_get_shadow_offsets } from "./chunk_get_shadow_offsets.js";
+import { chunk_contact_harden_pcf_kernel } from "./dpcf/chunk_contact_harden_pcf_kernel.js";
+import { chunk_max_penumbra_percentage } from "./dpcf/chunk_max_penumbra_percentage.js";
+
+const SHADOW_POINT_DESCRIPTOR = LIGHT_DATABASE_SPEC.get('shadow_point');
+
+/**
+ * Cone-sampled point shadow PCF: 8 random directions inside a cone around the receiver-to-light
+ * vector, each re-encoded to the light's octahedral map, one `textureLoad` per tap, ending in
+ * {@link chunk_contact_harden_pcf_kernel}. Tap directions come from {@link chunk_random}, which the
+ * calling shader (deferred lighting / volumetrics) initialises per invocation, so neighbouring
+ * pixels decorrelate without a rotation table or a blue-noise disk.
+ *
+ * The aperture is the GDC bulb-radius scaling in {@link chunk_max_penumbra_percentage}; the factor
+ * of 2 carries over the texels → tangent-plane conversion an earlier disk-based variant used (1
+ * atlas texel ≈ 2/face_dim of Δn.xy near the +Z pole), so the angular footprint stays comparable.
+ *
+ * Addressing: `atlas_aabb` is the INNER octahedral surface, and the cube → octahedral remap
+ * surrounds it with a `SHADOWMAP_ATLAS_BORDER`-texel skirt holding
+ * `inner[texture_octahedral_wrap_texel_coordinates(local)]`. Under the bilinear convention
+ * `uv * size - 0.5` a uv on the edge of the square rounds to -1 or `size` — one texel into that
+ * skirt, which is this light's own wrapped data. The encode always lands in [0, 1]² and the round
+ * can overshoot by at most one texel, so the aperture needs no clamp.
+ *
+ * @see chunk_cone_sample_direction
+ * @type {CodeChunk}
+ */
+export const chunk_shadowmap_sample_point2 = CodeChunk.from(
+    //language=WGSL
+    `
+fn shadowmap_sample_point(
+    database: ptr<storage, array<u32>>,
+    shadow_id: u32,
+    position_ws: vec3f,
+    surface_normal_ws: vec3f,
+    light_position_ws: vec3f,
+    light_max_distance: f32,
+    light_radius: f32,
+) -> f32 {
+    const NORMAL_BIAS_SCALE = 2.0;
+    // Toward the light, in texels of the map at the receiver, scaled by the slope: casters are drawn
+    // by their front faces, so the map holds the lit surface itself, and a tap a texel along it
+    // reads it a texel's slope nearer — the cube → octahedral remap adds up to half a cube texel's
+    // more. A flat offset in the map's normalized depth cleared none of that.
+    const DEPTH_BIAS_TEXELS = 1.0;
+
+    let atlas_aabb = ${SHADOW_POINT_DESCRIPTOR.marshalling_method_read}(database, shadow_id);
+
+    // unbiased distance and light direction, used to compute the bias amounts
+    let to_light_unbiased = light_position_ws - position_ws;
+    let dist_to_light_unbiased = length(to_light_unbiased);
+    let light_direction = to_light_unbiased / max(dist_to_light_unbiased, 1e-6);
+
+    let world_pixel_size = 2.0 * dist_to_light_unbiased / max(atlas_aabb.z, 1.0);
+    let shadowmap_bias = get_shadow_offsets(surface_normal_ws, light_direction);
+    let normal_offset = world_pixel_size * shadowmap_bias.x * surface_normal_ws * NORMAL_BIAS_SCALE;
+
+    // re-evaluate direction and distance from the normal-biased position
+    let to_surface = (position_ws + normal_offset) - light_position_ws;
+    let distance_to_center = length(to_surface);
+
+    // Direction the cube faces captured: FROM LIGHT TO SURFACE
+    let dir_light_to_surface = to_surface / max(distance_to_center, 1e-6);
+
+    let face_size = vec2u(atlas_aabb.zw);
+
+    // reverse-Z convention: close to light -> 1, at or beyond light_max_distance -> 0.
+    let radial = distance_to_center / max(light_max_distance, 1e-6);
+    let depth_bias = world_pixel_size * shadowmap_bias.y * DEPTH_BIAS_TEXELS / max(light_max_distance, 1e-6);
+    let reference_depth = (1.0 - saturate(radial)) + depth_bias;
+
+    // Cone aperture (~ tan of the half-angle). max_penumbra_percentage is the GDC formula mapping
+    // bulb radius to a fraction of the atlas face; the 2× factor is the texels → tangent-plane
+    // conversion. Unclamped — see the header on why any aperture stays addressable.
+    let cone_aperture = 2.0 * max_penumbra_percentage(light_radius, light_radius);
+
+    var occluders: f32 = 0.0;
+    var occluder_dist_sum: f32 = 0.0;
+
+    for (var tap: u32 = 0u; tap < 8u; tap++) {
+
+        let xi = random_vec2();
+
+        let perturbed_dir = cone_sample_direction(dir_light_to_surface, cone_aperture, xi);
+
+        let octahedral_uv = uv_octahedral_unit_encode(perturbed_dir);
+        let local_texel = uv_to_texel_coordinate(octahedral_uv, face_size);
+
+        // one of the two neighbours at random rather than a blend of them: stochastic bilinear
+        let rounded_local_texel = random_round_vec2(local_texel);
+
+        // Signed: the round reaches -1 at a uv of 0, and the skirt is where that tap belongs. Via
+        // u32 the -1 would be an indeterminate conversion — 0xFFFFFFFF reaches the skirt through
+        // the wrapping add, 0 silently reads the opposite edge of the inner surface. i32 is exact
+        // here, and the inner origin is at least SHADOWMAP_ATLAS_BORDER, so the sum is positive.
+        let sample_texel = vec2<u32>(vec2<i32>(rounded_local_texel) + vec2<i32>(atlas_aabb.xy));
+
+        let stored = textureLoad(shadowmapAtlas, sample_texel, 0);
+        let dist = stored - reference_depth;
+
+        // Per-tap binary compare; reverse-Z + step(0, stored - ref) ⇒ 1 = occluded.
+        let occluded = step(0.0, dist);
+
+        occluders += occluded;
+        occluder_dist_sum += dist * occluded;
+    }
+
+    return contact_harden_pcf_kernel(
+        occluders,
+        occluder_dist_sum,
+        reference_depth,
+
+    );
+}
+    `, [
+        SHADOW_POINT_DESCRIPTOR.chunk_read,
+        chunk_cone_sample_direction,
+        chunk_contact_harden_pcf_kernel,
+        chunk_get_shadow_offsets,
+        chunk_max_penumbra_percentage,
+        chunk_random,
+        chunk_uv_octahedral_unit_encode,
+        chunk_uv_to_texel_coordinate,
+        chunk_random_round_vec2,
+        chunk_random_vec2,
+    ]
+);

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

@@ -0,0 +1,15 @@
+/**
+ * Default world size of a texel of a virtual shadow map's finest level, in metres.
+ *
+ * A 1080p view at 60° spans a 1 mrad pixel, so level 0 is what receivers within about 10 m of the
+ * camera ask for, and each level doubles that reach: with twelve levels, the coarsest texel is
+ * 20 m and receivers some 20 km out still find a level whose texel matches their pixel.
+ *
+ * Only the starting value: what a scene uses is
+ * {@link GPUSceneShadowmapContext.virtual_first_texel_size}, pushed from
+ * {@link Renderer.shadow_virtual_first_texel_size}; a change rebuilds the maps.
+ *
+ * @type {number}
+ */
+export const DEFAULT_VSM_FIRST_TEXEL_SIZE: number;
+//# sourceMappingURL=DEFAULT_VSM_FIRST_TEXEL_SIZE.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"DEFAULT_VSM_FIRST_TEXEL_SIZE.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shadow/vsm/DEFAULT_VSM_FIRST_TEXEL_SIZE.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,2CAFU,MAAM,CAEiC"}

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

@@ -0,0 +1,14 @@
+/**
+ * Default world size of a texel of a virtual shadow map's finest level, in metres.
+ *
+ * A 1080p view at 60° spans a 1 mrad pixel, so level 0 is what receivers within about 10 m of the
+ * camera ask for, and each level doubles that reach: with twelve levels, the coarsest texel is
+ * 20 m and receivers some 20 km out still find a level whose texel matches their pixel.
+ *
+ * Only the starting value: what a scene uses is
+ * {@link GPUSceneShadowmapContext.virtual_first_texel_size}, pushed from
+ * {@link Renderer.shadow_virtual_first_texel_size}; a change rebuilds the maps.
+ *
+ * @type {number}
+ */
+export const DEFAULT_VSM_FIRST_TEXEL_SIZE = 0.01;

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

@@ -0,0 +1,16 @@
+/**
+ * Default number of virtual shadow map pages a scene may render per frame, across its maps.
+ *
+ * Each page is one pooled shadow view through the Fast rasterization path — a mesh cull, the bucket
+ * classify, the meshlet expansion with its virtual geometry cut, and the draws — into a 136² slot,
+ * so a page costs about what one CSM cascade's view costs, over far fewer pixels. Pages that a frame
+ * wants beyond the budget wait for the next one, in priority order: covers for unshadowed pixels,
+ * then stale pages in view, then missing pages, each by the pixels asking.
+ *
+ * Only the starting value: what a scene spends is {@link GPUSceneShadowmapContext.virtual_page_budget},
+ * which the renderer pushes from {@link Renderer.shadow_virtual_page_budget} every frame.
+ *
+ * @type {number}
+ */
+export const DEFAULT_VSM_PAGE_BUDGET: number;
+//# sourceMappingURL=DEFAULT_VSM_PAGE_BUDGET.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"DEFAULT_VSM_PAGE_BUDGET.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shadow/vsm/DEFAULT_VSM_PAGE_BUDGET.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,sCAFU,MAAM,CAEyB"}

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

@@ -0,0 +1,15 @@
+/**
+ * Default number of virtual shadow map pages a scene may render per frame, across its maps.
+ *
+ * Each page is one pooled shadow view through the Fast rasterization path — a mesh cull, the bucket
+ * classify, the meshlet expansion with its virtual geometry cut, and the draws — into a 136² slot,
+ * so a page costs about what one CSM cascade's view costs, over far fewer pixels. Pages that a frame
+ * wants beyond the budget wait for the next one, in priority order: covers for unshadowed pixels,
+ * then stale pages in view, then missing pages, each by the pixels asking.
+ *
+ * Only the starting value: what a scene spends is {@link GPUSceneShadowmapContext.virtual_page_budget},
+ * which the renderer pushes from {@link Renderer.shadow_virtual_page_budget} every frame.
+ *
+ * @type {number}
+ */
+export const DEFAULT_VSM_PAGE_BUDGET = 8;