@woosh/meep-engine 3.37.0 → 3.39.0

package/src/shade/renderer/shader/chunk/brdf/fresnel/chunk_F_dielectric.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Exact Fresnel reflectance of a smooth dielectric interface for unpolarized light: the mean of
+ * the s- and p-polarized reflectances, with total internal reflection.
+ *
+ * - `cos_theta_i` is the cosine between the incident direction (pointing away from the surface,
+ *   towards where the light comes from) and the interface normal. A negative value means the
+ *   incident side is the one the normal points away from, and the interface is then seen with the
+ *   inverse ratio — so one normal and one `eta` describe both sides of the same interface.
+ * - `eta` is the ratio n_t / n_i of the refractive index on the side the normal points away from
+ *   to the one it points towards. Relative, not absolute: water seen from air is 1.333, glass
+ *   under water is 1.5 / 1.333.
+ *
+ * Returns 1 beyond the critical angle. Transmittance is `1 - F_dielectric(...)`; nothing is
+ * absorbed at the interface.
+ *
+ * At normal incidence this is `((eta - 1) / (eta + 1))^2`, the F0 that
+ * `dielectric_specular_color` gives for the same relative index — the two agree where both apply,
+ * and this one stays right at grazing angles and from the dense side, where Schlick's form does not.
+ *
+ * @see Pharr, Jakob, Humphreys, "Physically Based Rendering", 4th ed., §9.3 (`FrDielectric`)
+ */
+export const chunk_F_dielectric: CodeChunk;
+import { CodeChunk } from "../../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_F_dielectric.d.ts.map

package/src/shade/renderer/shader/chunk/brdf/fresnel/chunk_F_dielectric.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_F_dielectric.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/brdf/fresnel/chunk_F_dielectric.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,2CA6BE;0BApDwB,gCAAgC"}

package/src/shade/renderer/shader/chunk/brdf/fresnel/chunk_F_dielectric.js

@@ -0,0 +1,53 @@
+import { CodeChunk } from "../../../compiler/CodeChunk.js";
+
+/**
+ * Exact Fresnel reflectance of a smooth dielectric interface for unpolarized light: the mean of
+ * the s- and p-polarized reflectances, with total internal reflection.
+ *
+ * - `cos_theta_i` is the cosine between the incident direction (pointing away from the surface,
+ *   towards where the light comes from) and the interface normal. A negative value means the
+ *   incident side is the one the normal points away from, and the interface is then seen with the
+ *   inverse ratio — so one normal and one `eta` describe both sides of the same interface.
+ * - `eta` is the ratio n_t / n_i of the refractive index on the side the normal points away from
+ *   to the one it points towards. Relative, not absolute: water seen from air is 1.333, glass
+ *   under water is 1.5 / 1.333.
+ *
+ * Returns 1 beyond the critical angle. Transmittance is `1 - F_dielectric(...)`; nothing is
+ * absorbed at the interface.
+ *
+ * At normal incidence this is `((eta - 1) / (eta + 1))^2`, the F0 that
+ * `dielectric_specular_color` gives for the same relative index — the two agree where both apply,
+ * and this one stays right at grazing angles and from the dense side, where Schlick's form does not.
+ *
+ * @see Pharr, Jakob, Humphreys, "Physically Based Rendering", 4th ed., §9.3 (`FrDielectric`)
+ */
+export const chunk_F_dielectric = CodeChunk.from(
+    //language=WGSL
+    `
+fn F_dielectric(cos_theta_i: f32, eta: f32) -> f32 {
+    var cos_i = clamp(cos_theta_i, -1.0, 1.0);
+    var eta_i = eta;
+
+    if (cos_i < 0.0) {
+        // incident on the side the normal points away from: same interface, inverse ratio
+        eta_i = 1.0 / eta_i;
+        cos_i = -cos_i;
+    }
+
+    let sin2_theta_i = max(0.0, 1.0 - cos_i * cos_i);
+    let sin2_theta_t = sin2_theta_i / (eta_i * eta_i);
+
+    if (sin2_theta_t >= 1.0) {
+        // total internal reflection
+        return 1.0;
+    }
+
+    let cos_t = sqrt(max(0.0, 1.0 - sin2_theta_t));
+
+    let r_parallel = (eta_i * cos_i - cos_t) / (eta_i * cos_i + cos_t);
+    let r_perpendicular = (cos_i - eta_i * cos_t) / (cos_i + eta_i * cos_t);
+
+    return 0.5 * (r_parallel * r_parallel + r_perpendicular * r_perpendicular);
+}
+    `
+);

package/src/shade/renderer/shader/chunk/geometry/plane/{plane_ray_raycast.d.ts → chunk_plane_ray_raycast.d.ts}

@@ -2,6 +2,6 @@
  * Ported from meep
  * @type {CodeChunk}
  */
-export const plane_ray_raycast: CodeChunk;
+export const chunk_plane_ray_raycast: CodeChunk;
 import { CodeChunk } from "../../../compiler/CodeChunk.js";
-//# sourceMappingURL=plane_ray_raycast.d.ts.map
+//# sourceMappingURL=chunk_plane_ray_raycast.d.ts.map

package/src/shade/renderer/shader/chunk/geometry/plane/chunk_plane_ray_raycast.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_plane_ray_raycast.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/geometry/plane/chunk_plane_ray_raycast.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH,sCAFU,SAAS,CA2Cf;0BA/CsB,gCAAgC"}

package/src/shade/renderer/shader/chunk/geometry/ray/chunk_scene_point_query_is_inside_geometry.d.ts

@@ -1,5 +1,11 @@
 /**
- * Checks whether a given point is inside any mesh
+ * Checks whether a given point is inside any mesh: {@link chunk_scene_point_query_volume_sign}'s
+ * vote, read as a yes or a no.
+ *
+ * Inside means more than 60% of 64 rays strike the back of a triangle first. From inside a closed
+ * mesh with nothing else around it every ray does, and from outside none, so the threshold only
+ * decides where meshes are open, one-sided or overlapping, or where a point is further inside one
+ * than `max_distance` reaches.
  */
 export const chunk_scene_point_query_is_inside_geometry: CodeChunk;
 import { CodeChunk } from "../../../compiler/CodeChunk.js";

package/src/shade/renderer/shader/chunk/geometry/ray/chunk_scene_point_query_is_inside_geometry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_scene_point_query_is_inside_geometry.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/geometry/ray/chunk_scene_point_query_is_inside_geometry.js"],"names":[],"mappings":"AAOA;;GAEG;AACH,mEA0DO;0BApEmB,gCAAgC"}
+{"version":3,"file":"chunk_scene_point_query_is_inside_geometry.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/geometry/ray/chunk_scene_point_query_is_inside_geometry.js"],"names":[],"mappings":"AAGA;;;;;;;;GAQG;AACH,mEAQO;0BAnBmB,gCAAgC"}

package/src/shade/renderer/shader/chunk/geometry/ray/chunk_scene_point_query_is_inside_geometry.js

@@ -1,69 +1,21 @@
+import { chunk_scene_point_query_volume_sign } from "../../../../geometry/sdf/chunk_scene_point_query_volume_sign.js";
 import { CodeChunk } from "../../../compiler/CodeChunk.js";
-import { chunk_geometry_read_triangle_vertices } from "../format/chunk_geometry_read_triangle_vertices.js";
-import { chunk_compute_triangle_face_normal } from "../normal/chunk_compute_triangle_face_normal.js";
-import { chunk_sphere_fibonacci_point } from "../sphere/chunk_sphere_fibonacci_point.js";
-import { chunk_ray_query_nearest } from "./chunk_ray_query_nearest.js";
-import { RAY_STRUCT } from "./RAY_STRUCT.js";
 
 /**
- * Checks whether a given point is inside any mesh
+ * Checks whether a given point is inside any mesh: {@link chunk_scene_point_query_volume_sign}'s
+ * vote, read as a yes or a no.
+ *
+ * Inside means more than 60% of 64 rays strike the back of a triangle first. From inside a closed
+ * mesh with nothing else around it every ray does, and from outside none, so the threshold only
+ * decides where meshes are open, one-sided or overlapping, or where a point is further inside one
+ * than `max_distance` reaches.
  */
 export const chunk_scene_point_query_is_inside_geometry = CodeChunk.from(
     //language=WGSL
     `
-fn scene_point_query_is_inside_geometry(postion_ws: vec3<f32>, max_distance:f32 ) -> bool{
-    const POINT_COUNT = 64;
-    
-    var ray: ${RAY_STRUCT.wgsl_ref};
-    ray.origin = postion_ws;
-    ray.tmax = max_distance;
-    
-    var back_facing_hits = 0;
-    
-    
-    for(var i=0; i<POINT_COUNT; i++){
-       
-        let direction = sphere_fibonacci_point(f32(i), POINT_COUNT);
-        
-        ray.direction = direction;
-        
-        let hit = ray_query_nearest(ray);
-    
-        if(hit.t < 0){
-            // miss
-            continue;
-        }
-        
-        let geometry = geometries[hit.geometry];
-        
-        // construct normal
-        let triangle = geometry_read_triangle_vertices(geometry, hit.triangle);
-        
-        let a = triangle.a.position;
-        let b = triangle.b.position;
-        let c = triangle.c.position;
-        
-        let normal = compute_triangle_face_normal(a,b,c);
-        
-        
-        if(dot(normal, ray.direction) > 0.0){
-            // back-facing
-            back_facing_hits++;
-        }
-        
-    }
-    
-    if(back_facing_hits >= (POINT_COUNT / 2) ){
-        return true;
-    }else{
-        return false;
-    }
-
+fn scene_point_query_is_inside_geometry(position_ws: vec3<f32>, max_distance: f32) -> bool {
+    return scene_point_query_volume_sign(position_ws, max_distance) < 0.0;
 }
 `, [
-        RAY_STRUCT.declaration_chunk,
-        chunk_ray_query_nearest,
-        chunk_geometry_read_triangle_vertices,
-        chunk_compute_triangle_face_normal,
-        chunk_sphere_fibonacci_point,
-    ]);
+        chunk_scene_point_query_volume_sign,
+    ]);

package/src/shade/renderer/shader/chunk/geometry/sphere/chunk_compute_spherical_excess.d.ts

@@ -1,10 +1,30 @@
 /**
- * Computes the solid angle of a spherical triangle with vertices A, B, C as unit length vectors.
- * https://en.wikipedia.org/wiki/Spherical_trigonometry#Area_and_spherical_excess
- * tan (e/2) = sinC/(cosC + coTan(0.5*a)*coTan(0.5*b))
- * cotan(0.5a) = sqrt((1+cosa)/(1-cosa))
- * coTan(0.5*a)*coTan(0.5*b) = sqrt((1+cosb)*(1+cosa)/((1-cosa)*((1-cosb)))
- * @see https://github.com/GaijinEntertainment/DagorEngine/blob/fc6764ee0c056a30a975c29524c86b54c7433239/prog/gameLibs/daGI2/shaders/octahedral_solid_angle.hlsl#L10
+ * Computes the solid angle of a spherical triangle with vertices A, B, C as unit length vectors, in
+ * either winding.
+ *
+ * Van Oosterom and Strackee, "The Solid Angle of a Plane Triangle", IEEE Transactions on Biomedical
+ * Engineering 30(2), 1983:
+ *
+ *     tan(E / 2) = |A · (B × C)| / (1 + A·B + B·C + C·A)
+ *
+ * This replaced the half-angle-cotangent form taken from Dagor's `octahedral_solid_angle.hlsl`
+ * (https://github.com/GaijinEntertainment/DagorEngine/blob/fc6764ee0c056a30a975c29524c86b54c7433239/prog/gameLibs/daGI2/shaders/octahedral_solid_angle.hlsl#L10),
+ * which takes `sqrt(sin²AB sin²BC - cos²C)` and divides by `(1 - cos AB)(1 - cos BC)`. For the small
+ * triangles of a texel those are differences of numbers near 1, and in f32 the square root's argument
+ * goes negative: simulated texel by texel through `octahedral_solid_angle`, 4 texels of a 64² octahedral
+ * map came out non-finite, 56 of a 1024² map and 228 of a 2048², all along the octahedron's creases,
+ * and the finite rest summed to 12.549 sr at 2048² instead of 4π. On an RTX 4090 the 1024² Venice-sunset
+ * map gave 20 non-finite cells of 4096 in the SH-exponential encoder's integration, which turned every
+ * reflectance its fit reads into NaN. This form has no square root and no division by a small
+ * difference: the same simulation gives no non-finite texel at any of those sizes, and 4π to the
+ * fifth decimal. A degenerate triangle (a repeated vertex, three vertices within half of one great
+ * circle) is 0, where the old form was 0 / 0. Three vertices spread around a whole great circle are
+ * a hemisphere to this form, 2π: the denominator goes negative and `atan2` takes the far side, which is
+ * also how a triangle larger than a hemisphere comes out right.
+ *
+ * The old form's crease failure shows under the WGSL emulator as well, through every texel of a 16² and
+ * a 64² map — pinned in `chunk_octahedral_solid_angle.spec.js`.
+ *
  * @type {CodeChunk}
  */
 export const chunk_compute_spherical_excess: CodeChunk;

package/src/shade/renderer/shader/chunk/geometry/sphere/chunk_compute_spherical_excess.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_compute_spherical_excess.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/geometry/sphere/chunk_compute_spherical_excess.js"],"names":[],"mappings":"AAEA;;;;;;;;GAQG;AACH,6CAFU,SAAS,CAqBjB;0BA9BwB,gCAAgC"}
+{"version":3,"file":"chunk_compute_spherical_excess.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/geometry/sphere/chunk_compute_spherical_excess.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,6CAFU,SAAS,CAYjB;0BAzCwB,gCAAgC"}

package/src/shade/renderer/shader/chunk/geometry/sphere/chunk_compute_spherical_excess.js

@@ -1,32 +1,42 @@
 import { CodeChunk } from "../../../compiler/CodeChunk.js";
 
 /**
- * Computes the solid angle of a spherical triangle with vertices A, B, C as unit length vectors.
- * https://en.wikipedia.org/wiki/Spherical_trigonometry#Area_and_spherical_excess
- * tan (e/2) = sinC/(cosC + coTan(0.5*a)*coTan(0.5*b))
- * cotan(0.5a) = sqrt((1+cosa)/(1-cosa))
- * coTan(0.5*a)*coTan(0.5*b) = sqrt((1+cosb)*(1+cosa)/((1-cosa)*((1-cosb)))
- * @see https://github.com/GaijinEntertainment/DagorEngine/blob/fc6764ee0c056a30a975c29524c86b54c7433239/prog/gameLibs/daGI2/shaders/octahedral_solid_angle.hlsl#L10
+ * Computes the solid angle of a spherical triangle with vertices A, B, C as unit length vectors, in
+ * either winding.
+ *
+ * Van Oosterom and Strackee, "The Solid Angle of a Plane Triangle", IEEE Transactions on Biomedical
+ * Engineering 30(2), 1983:
+ *
+ *     tan(E / 2) = |A · (B × C)| / (1 + A·B + B·C + C·A)
+ *
+ * This replaced the half-angle-cotangent form taken from Dagor's `octahedral_solid_angle.hlsl`
+ * (https://github.com/GaijinEntertainment/DagorEngine/blob/fc6764ee0c056a30a975c29524c86b54c7433239/prog/gameLibs/daGI2/shaders/octahedral_solid_angle.hlsl#L10),
+ * which takes `sqrt(sin²AB sin²BC - cos²C)` and divides by `(1 - cos AB)(1 - cos BC)`. For the small
+ * triangles of a texel those are differences of numbers near 1, and in f32 the square root's argument
+ * goes negative: simulated texel by texel through `octahedral_solid_angle`, 4 texels of a 64² octahedral
+ * map came out non-finite, 56 of a 1024² map and 228 of a 2048², all along the octahedron's creases,
+ * and the finite rest summed to 12.549 sr at 2048² instead of 4π. On an RTX 4090 the 1024² Venice-sunset
+ * map gave 20 non-finite cells of 4096 in the SH-exponential encoder's integration, which turned every
+ * reflectance its fit reads into NaN. This form has no square root and no division by a small
+ * difference: the same simulation gives no non-finite texel at any of those sizes, and 4π to the
+ * fifth decimal. A degenerate triangle (a repeated vertex, three vertices within half of one great
+ * circle) is 0, where the old form was 0 / 0. Three vertices spread around a whole great circle are
+ * a hemisphere to this form, 2π: the denominator goes negative and `atan2` takes the far side, which is
+ * also how a triangle larger than a hemisphere comes out right.
+ *
+ * The old form's crease failure shows under the WGSL emulator as well, through every texel of a 16² and
+ * a 64² map — pinned in `chunk_octahedral_solid_angle.spec.js`.
+ *
  * @type {CodeChunk}
  */
 export const chunk_compute_spherical_excess = CodeChunk.from(
     //language=WGSL
     `
 fn compute_spherical_excess(A: vec3<f32>, B: vec3<f32>, C: vec3<f32>) -> f32{
-    let cosAB = dot(A, B);
-    let cosBC = dot(B, C);
-    let cosCA = dot(C, A);
-    
-    let sinAB = 1.0f - cosAB * cosAB;
-    let sinBC = 1.0f - cosBC * cosBC;
-    
-    let cosC = cosCA - cosAB * cosBC;
-    let sinC = sqrt(sinAB * sinBC - cosC * cosC);
-    
-    let norm = (1.0f - cosAB) * (1.0f - cosBC);
-    
-    return 2.0f * atan2(sinC, sqrt((sinAB * sinBC * (1.0f + cosBC) * (1.0f + cosAB)) / norm) + cosC);
+    let triple = dot(A, cross(B, C));
+    let denominator = 1.0 + dot(A, B) + dot(B, C) + dot(C, A);
+
+    return 2.0 * atan2(abs(triple), denominator);
 }
     `
 );
-

package/src/shade/renderer/shader/chunk/light/sample/chunk_light_importance_directional.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_light_importance_directional.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/light/sample/chunk_light_importance_directional.js"],"names":[],"mappings":"AAIA;;;;;;GAMG;AACH,iDAFU,SAAS,CAgBjB;0BAzBwB,gCAAgC"}
+{"version":3,"file":"chunk_light_importance_directional.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/light/sample/chunk_light_importance_directional.js"],"names":[],"mappings":"AAKA;;;;;;GAMG;AACH,iDAFU,SAAS,CAiBjB;0BA3BwB,gCAAgC"}

package/src/shade/renderer/shader/chunk/light/sample/chunk_light_importance_directional.js

@@ -1,4 +1,5 @@
 import { CodeChunk } from "../../../compiler/CodeChunk.js";
+import { chunk_light_receiver_cosine } from "./chunk_light_receiver_cosine.js";
 import { chunk_rgb_to_luminance } from "../../color/chunk_rgb_to_luminance.js";
 import { DIRECTIONAL_LIGHT_STRUCT } from "../DIRECTIONAL_LIGHT_STRUCT.js";
 
@@ -17,10 +18,11 @@ fn light_importance_directional(
     position: vec3<f32>,
     normal: vec3<f32>
 ) -> f32 {
-    let cos_factor = max(0.0, dot(normal, -light.direction));
+    let cos_factor = light_receiver_cosine(normal, -light.direction);
     return rgb_to_luminance(light.color) * cos_factor;
 }
     `, [
         chunk_rgb_to_luminance,
+        chunk_light_receiver_cosine,
     ]
 );

package/src/shade/renderer/shader/chunk/light/sample/chunk_light_importance_point.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_light_importance_point.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/light/sample/chunk_light_importance_point.js"],"names":[],"mappings":"AAKA;;;;;;;;GAQG;AACH,2CAFU,SAAS,CAmCjB;0BA/CwB,gCAAgC"}
+{"version":3,"file":"chunk_light_importance_point.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/light/sample/chunk_light_importance_point.js"],"names":[],"mappings":"AAMA;;;;;;;;GAQG;AACH,2CAFU,SAAS,CAoCjB;0BAjDwB,gCAAgC"}

package/src/shade/renderer/shader/chunk/light/sample/chunk_light_importance_point.js

@@ -1,4 +1,5 @@
 import { CodeChunk } from "../../../compiler/CodeChunk.js";
+import { chunk_light_receiver_cosine } from "./chunk_light_receiver_cosine.js";
 import { chunk_rgb_to_luminance } from "../../color/chunk_rgb_to_luminance.js";
 import { chunk_light_sphere_distance_attenuation } from "../io/chunk_light_sphere_distance_attenuation.js";
 import { POINT_LIGHT_STRUCT } from "../POINT_LIGHT_STRUCT.js";
@@ -31,7 +32,7 @@ fn light_importance_point(
     }
 
     let dir_to_center = to_light / max(distance_to_center, 1e-7);
-    let cos_factor = max(0.0, dot(normal, dir_to_center));
+    let cos_factor = light_receiver_cosine(normal, dir_to_center);
     if (cos_factor <= 0.0) {
         return 0.0;
     }
@@ -44,5 +45,6 @@ fn light_importance_point(
         POINT_LIGHT_STRUCT.declaration_chunk,
         chunk_light_sphere_distance_attenuation,
         chunk_rgb_to_luminance,
+        chunk_light_receiver_cosine,
     ]
 );

package/src/shade/renderer/shader/chunk/light/sample/chunk_light_importance_spot.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_light_importance_spot.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/light/sample/chunk_light_importance_spot.js"],"names":[],"mappings":"AAMA;;;;;;;GAOG;AACH,0CAFU,SAAS,CAyCjB;0BArDwB,gCAAgC"}
+{"version":3,"file":"chunk_light_importance_spot.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/light/sample/chunk_light_importance_spot.js"],"names":[],"mappings":"AAOA;;;;;;;GAOG;AACH,0CAFU,SAAS,CA0CjB;0BAvDwB,gCAAgC"}

package/src/shade/renderer/shader/chunk/light/sample/chunk_light_importance_spot.js

@@ -1,4 +1,5 @@
 import { CodeChunk } from "../../../compiler/CodeChunk.js";
+import { chunk_light_receiver_cosine } from "./chunk_light_receiver_cosine.js";
 import { chunk_rgb_to_luminance } from "../../color/chunk_rgb_to_luminance.js";
 import { chunk_light_get_spot_attenuation } from "../io/chunk_light_get_spot_attenuation.js";
 import { chunk_light_sphere_distance_attenuation } from "../io/chunk_light_sphere_distance_attenuation.js";
@@ -30,7 +31,7 @@ fn light_importance_spot(
     }
 
     let dir_to_center = to_origin / max(distance_to_center, 1e-7);
-    let cos_factor = max(0.0, dot(normal, dir_to_center));
+    let cos_factor = light_receiver_cosine(normal, dir_to_center);
     if (cos_factor <= 0.0) {
         return 0.0;
     }
@@ -50,5 +51,6 @@ fn light_importance_spot(
         chunk_light_sphere_distance_attenuation,
         chunk_light_get_spot_attenuation,
         chunk_rgb_to_luminance,
+        chunk_light_receiver_cosine,
     ]
 );

package/src/shade/renderer/shader/chunk/light/sample/chunk_light_receiver_cosine.d.ts

@@ -0,0 +1,14 @@
+/**
+ * How much a receiver at a point weighs light arriving from `direction` (unit, towards the light),
+ * for choosing which light to sample: the clamped cosine against the surface `normal`, so lights
+ * below a surface's horizon are never chosen — or 1 for every direction when `normal` is the zero
+ * vector, which is how a point with no surface says so: a scattering point inside a medium, which
+ * receives light from all around.
+ *
+ * The one place the light importance functions read the normal through.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_light_receiver_cosine: CodeChunk;
+import { CodeChunk } from "../../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_light_receiver_cosine.d.ts.map

package/src/shade/renderer/shader/chunk/light/sample/chunk_light_receiver_cosine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_light_receiver_cosine.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/light/sample/chunk_light_receiver_cosine.js"],"names":[],"mappings":"AAEA;;;;;;;;;;GAUG;AACH,0CAFU,SAAS,CAajB;0BAxBwB,gCAAgC"}

package/src/shade/renderer/shader/chunk/light/sample/chunk_light_receiver_cosine.js

@@ -0,0 +1,25 @@
+import { CodeChunk } from "../../../compiler/CodeChunk.js";
+
+/**
+ * How much a receiver at a point weighs light arriving from `direction` (unit, towards the light),
+ * for choosing which light to sample: the clamped cosine against the surface `normal`, so lights
+ * below a surface's horizon are never chosen — or 1 for every direction when `normal` is the zero
+ * vector, which is how a point with no surface says so: a scattering point inside a medium, which
+ * receives light from all around.
+ *
+ * The one place the light importance functions read the normal through.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_light_receiver_cosine = CodeChunk.from(
+    //language=WGSL
+    `
+fn light_receiver_cosine(normal: vec3<f32>, direction: vec3<f32>) -> f32 {
+    if (all(normal == vec3<f32>(0.0))) {
+        return 1.0;
+    }
+
+    return max(0.0, dot(normal, direction));
+}
+    `
+);

package/src/shade/renderer/shader/chunk/light/sample/chunk_select_light_importance.d.ts

@@ -7,12 +7,19 @@
  * shadow ray that follows. Lights returning 0 importance (out of range,
  * outside spot cone, etc.) are never selected.
  *
- * Iteration is per-thread, no workgroup memory: point/spot walk every
- * page in the table (no cap, suits clustered scenes); directional uses
+ * Iteration is per-thread, no workgroup memory: point/spot walk the pages
+ * their lights occupy — `GPULightCollection` packs them into rows
+ * [0, count), so the walk ends at the first missing or empty page and reads
+ * a page's bitmap only as far as its live count, never the table's page
+ * capacity (which it used to read whole, every call); directional uses
  * the 32-cap iteration mask. The path tracer's main shader is
  * register-pressure-sensitive, so workgroup-shared iteration would cost
  * occupancy.
  *
+ * `normal` is the receiving surface's; the zero vector is a point with no surface, inside a
+ * medium, which weighs every light by its unshadowed irradiance alone (see
+ * `light_receiver_cosine`).
+ *
  * The returned pdf is the true discrete selection probability w_i / sum_w,
  * so the Monte Carlo estimator divides by (selection.pdf * record.pdf)
  * rather than by the uniform 1/N approximation.

package/src/shade/renderer/shader/chunk/light/sample/chunk_select_light_importance.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_select_light_importance.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/light/sample/chunk_select_light_importance.js"],"names":[],"mappings":"AASA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,4CAFU,SAAS,CA+IZ;0BA3KmB,gCAAgC"}
+{"version":3,"file":"chunk_select_light_importance.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/light/sample/chunk_select_light_importance.js"],"names":[],"mappings":"AASA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,4CAFU,SAAS,CA+JZ;0BAlMmB,gCAAgC"}

package/src/shade/renderer/shader/chunk/light/sample/chunk_select_light_importance.js

@@ -16,12 +16,19 @@ import { LIGHT_SELECTION_STRUCT, LIGHT_SELECTION_TYPE } from "./LIGHT_SELECTION_
  * shadow ray that follows. Lights returning 0 importance (out of range,
  * outside spot cone, etc.) are never selected.
  *
- * Iteration is per-thread, no workgroup memory: point/spot walk every
- * page in the table (no cap, suits clustered scenes); directional uses
+ * Iteration is per-thread, no workgroup memory: point/spot walk the pages
+ * their lights occupy — `GPULightCollection` packs them into rows
+ * [0, count), so the walk ends at the first missing or empty page and reads
+ * a page's bitmap only as far as its live count, never the table's page
+ * capacity (which it used to read whole, every call); directional uses
  * the 32-cap iteration mask. The path tracer's main shader is
  * register-pressure-sensitive, so workgroup-shared iteration would cost
  * occupancy.
  *
+ * `normal` is the receiving surface's; the zero vector is a point with no surface, inside a
+ * medium, which weighs every light by its unshadowed irradiance alone (see
+ * `light_receiver_cosine`).
+ *
  * The returned pdf is the true discrete selection probability w_i / sum_w,
  * so the Monte Carlo estimator divides by (selection.pdf * record.pdf)
  * rather than by the uniform 1/N approximation.
@@ -43,8 +50,12 @@ fn select_light_importance(position: vec3<f32>, normal: vec3<f32>, random: f32)
 
     for (var p = 0u; p < POINT_LIGHTS_PAGE_LIMIT; p = p + 1u) {
         let page_addr = point_lights_page_address(&light_data, p);
-        if (page_addr == ~0u) { continue; }
-        for (var w = 0u; w < POINT_LIGHTS_OCCUPANCY_BITMAP_WORDS; w = w + 1u) {
+        // packed into rows [0, count): the first missing or empty page ends the table, and a
+        // page's live rows are its first slots
+        if (page_addr == ~0u) { break; }
+        let live = light_data[page_addr];
+        if (live == 0u) { break; }
+        for (var w = 0u; w * 32u < live; w = w + 1u) {
             var bits = point_lights_page_bitmap_word(&light_data, page_addr, w);
             while (bits != 0u) {
                 let bit = countTrailingZeros(bits);
@@ -56,8 +67,12 @@ fn select_light_importance(position: vec3<f32>, normal: vec3<f32>, random: f32)
     }
     for (var p = 0u; p < SPOT_LIGHTS_PAGE_LIMIT; p = p + 1u) {
         let page_addr = spot_lights_page_address(&light_data, p);
-        if (page_addr == ~0u) { continue; }
-        for (var w = 0u; w < SPOT_LIGHTS_OCCUPANCY_BITMAP_WORDS; w = w + 1u) {
+        // packed into rows [0, count): the first missing or empty page ends the table, and a
+        // page's live rows are its first slots
+        if (page_addr == ~0u) { break; }
+        let live = light_data[page_addr];
+        if (live == 0u) { break; }
+        for (var w = 0u; w * 32u < live; w = w + 1u) {
             var bits = spot_lights_page_bitmap_word(&light_data, page_addr, w);
             while (bits != 0u) {
                 let bit = countTrailingZeros(bits);
@@ -88,8 +103,12 @@ fn select_light_importance(position: vec3<f32>, normal: vec3<f32>, random: f32)
 
     for (var p = 0u; p < POINT_LIGHTS_PAGE_LIMIT; p = p + 1u) {
         let page_addr = point_lights_page_address(&light_data, p);
-        if (page_addr == ~0u) { continue; }
-        for (var w = 0u; w < POINT_LIGHTS_OCCUPANCY_BITMAP_WORDS; w = w + 1u) {
+        // packed into rows [0, count): the first missing or empty page ends the table, and a
+        // page's live rows are its first slots
+        if (page_addr == ~0u) { break; }
+        let live = light_data[page_addr];
+        if (live == 0u) { break; }
+        for (var w = 0u; w * 32u < live; w = w + 1u) {
             var bits = point_lights_page_bitmap_word(&light_data, page_addr, w);
             while (bits != 0u) {
                 let bit = countTrailingZeros(bits);
@@ -113,8 +132,12 @@ fn select_light_importance(position: vec3<f32>, normal: vec3<f32>, random: f32)
     }
     for (var p = 0u; p < SPOT_LIGHTS_PAGE_LIMIT; p = p + 1u) {
         let page_addr = spot_lights_page_address(&light_data, p);
-        if (page_addr == ~0u) { continue; }
-        for (var w = 0u; w < SPOT_LIGHTS_OCCUPANCY_BITMAP_WORDS; w = w + 1u) {
+        // packed into rows [0, count): the first missing or empty page ends the table, and a
+        // page's live rows are its first slots
+        if (page_addr == ~0u) { break; }
+        let live = light_data[page_addr];
+        if (live == 0u) { break; }
+        for (var w = 0u; w * 32u < live; w = w + 1u) {
             var bits = spot_lights_page_bitmap_word(&light_data, page_addr, w);
             while (bits != 0u) {
                 let bit = countTrailingZeros(bits);

package/src/shade/renderer/shader/chunk/screen_space/chunk_screen_space_newton_ray.d.ts

@@ -0,0 +1,4 @@
+/** Mayer et al. 2026 tangent-plane refinement. All arithmetic is in matrix view space. */
+export const chunk_screen_space_newton_ray: CodeChunk;
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_screen_space_newton_ray.d.ts.map

package/src/shade/renderer/shader/chunk/screen_space/chunk_screen_space_newton_ray.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_screen_space_newton_ray.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/screen_space/chunk_screen_space_newton_ray.js"],"names":[],"mappings":"AAWA,0FAA0F;AAC1F,sDA0HkF;0BAtIxD,6BAA6B"}