@woosh/meep-engine 3.30.0 → 3.32.0

package/src/shade/renderer/light/cluster/chunk_cluster_keep_smallest.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Keep the smallest values in a full slice: replace the largest with `candidate` when `candidate`
+ * is smaller, otherwise leave it alone.
+ *
+ * **What this buys is determinism.** A cluster that resolves more lights than its local storage
+ * holds has to drop some, and it used to drop whichever arrived last — the arrival order being the
+ * order of the culled list, which `shader_cull_lights_frustum`/`_hzb` build with an `atomicAdd`,
+ * i.e. GPU scheduling order, which is not stable across frames. So the set of lights a crowded
+ * cluster lost changed every frame, and the artefact flickered instead of sitting still. Keeping
+ * the smallest indices makes the kept set a function of the scene alone: still a loss, but the same
+ * loss every frame, which is the difference between an artefact you can see and reason about and
+ * one that reads as random noise.
+ *
+ * Linear in the slice, and only paid when a cluster is over its limit — which is already a
+ * pathological cluster at {@link LIGHT_CLUSTER_LOCAL_LIGHT_LIMIT} lights of one type.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_cluster_keep_smallest: CodeChunk;
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_cluster_keep_smallest.d.ts.map

package/src/shade/renderer/light/cluster/chunk_cluster_keep_smallest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_cluster_keep_smallest.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/light/cluster/chunk_cluster_keep_smallest.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;GAiBG;AACH,0CAFU,SAAS,CA2BhB;0BA9CuB,oCAAoC"}

package/src/shade/renderer/light/cluster/chunk_cluster_keep_smallest.js

@@ -0,0 +1,47 @@
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { LIGHT_CLUSTER_LOCAL_LIGHT_LIMIT } from "./LIGHT_CLUSTER_LOCAL_LIGHT_LIMIT.js";
+
+/**
+ * Keep the smallest values in a full slice: replace the largest with `candidate` when `candidate`
+ * is smaller, otherwise leave it alone.
+ *
+ * **What this buys is determinism.** A cluster that resolves more lights than its local storage
+ * holds has to drop some, and it used to drop whichever arrived last — the arrival order being the
+ * order of the culled list, which `shader_cull_lights_frustum`/`_hzb` build with an `atomicAdd`,
+ * i.e. GPU scheduling order, which is not stable across frames. So the set of lights a crowded
+ * cluster lost changed every frame, and the artefact flickered instead of sitting still. Keeping
+ * the smallest indices makes the kept set a function of the scene alone: still a loss, but the same
+ * loss every frame, which is the difference between an artefact you can see and reason about and
+ * one that reads as random noise.
+ *
+ * Linear in the slice, and only paid when a cluster is over its limit — which is already a
+ * pathological cluster at {@link LIGHT_CLUSTER_LOCAL_LIGHT_LIMIT} lights of one type.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_cluster_keep_smallest = CodeChunk.from(
+    //language=WGSL
+    `
+fn cluster_keep_smallest(
+    values: ptr<function, array<u32, ${2 * LIGHT_CLUSTER_LOCAL_LIGHT_LIMIT}>>,
+    base: u32,
+    count: u32,
+    candidate: u32
+) {
+    var worst = 0u;
+    var worst_value = (*values)[base];
+
+    for (var i = 1u; i < count; i++) {
+        let value = (*values)[base + i];
+
+        if (value > worst_value) {
+            worst_value = value;
+            worst = i;
+        }
+    }
+
+    if (candidate < worst_value) {
+        (*values)[base + worst] = candidate;
+    }
+}
+`);

package/src/shade/renderer/light/cluster/shader_cluster_assign_lights.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_cluster_assign_lights.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/light/cluster/shader_cluster_assign_lights.js"],"names":[],"mappings":"AA+BA,mEAMG;AAmBH,sDAAoF;AA2IpF,yDAIG;6BArM0B,mCAAmC;4BADpC,kCAAkC;8BAoBhC,+BAA+B"}
+{"version":3,"file":"shader_cluster_assign_lights.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/light/cluster/shader_cluster_assign_lights.js"],"names":[],"mappings":"AAgCA,mEAMG;AAmBH,sDAAoF;AA8IpF,yDAIG;6BAzM0B,mCAAmC;4BADpC,kCAAkC;8BAoBhC,+BAA+B"}

package/src/shade/renderer/light/cluster/shader_cluster_assign_lights.js

@@ -22,6 +22,7 @@ import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
 import { ComputeShader } from "../../shader/ComputeShader.js";
 import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
 import { chunk_cluster_depth_from_z_slice } from "./chunk_cluster_depth_from_z_slice.js";
+import { chunk_cluster_keep_smallest } from "./chunk_cluster_keep_smallest.js";
 import { chunk_light_cluster_counts } from "./chunk_light_cluster_counts.js";
 import { chunk_light_cluster_resolution_xy_from_screen } from "./chunk_light_cluster_resolution_xy_from_screen.js";
 import { CLUSTER_LIGHT_TYPE, chunk_cluster_light_tuple } from "./CLUSTER_LIGHT_TYPE.js";
@@ -133,17 +134,19 @@ fn main(
         }
 
         if (light_type == ${CLUSTER_LIGHT_TYPE.Point}u) {
-            if (local_point_count >= ${LIGHT_CLUSTER_LOCAL_LIGHT_LIMIT}) {
-                continue; // local point storage full
+            if (local_point_count < ${LIGHT_CLUSTER_LOCAL_LIGHT_LIMIT}) {
+                local_lights[local_point_count] = light_index;
+                local_point_count += 1u;
+            } else {
+                cluster_keep_smallest(&local_lights, 0u, ${LIGHT_CLUSTER_LOCAL_LIGHT_LIMIT}u, light_index);
             }
-            local_lights[local_point_count] = light_index;
-            local_point_count += 1u;
         } else {
-            if (local_spot_count >= ${LIGHT_CLUSTER_LOCAL_LIGHT_LIMIT}) {
-                continue; // local spot storage full
+            if (local_spot_count < ${LIGHT_CLUSTER_LOCAL_LIGHT_LIMIT}) {
+                local_lights[${LIGHT_CLUSTER_LOCAL_LIGHT_LIMIT} + local_spot_count] = light_index;
+                local_spot_count += 1u;
+            } else {
+                cluster_keep_smallest(&local_lights, ${LIGHT_CLUSTER_LOCAL_LIGHT_LIMIT}u, ${LIGHT_CLUSTER_LOCAL_LIGHT_LIMIT}u, light_index);
             }
-            local_lights[${LIGHT_CLUSTER_LOCAL_LIGHT_LIMIT} + local_spot_count] = light_index;
-            local_spot_count += 1u;
         }
     }
 
@@ -177,6 +180,7 @@ fn main(
     `, [
         LIGHT_CLUSTER_METADATA.declaration_chunk,
         chunk_grid3d_to_index,
+        chunk_cluster_keep_smallest,
         chunk_cluster_slice_frustum,
         chunk_plane_from_triangle,
         chunk_frustum_to_corners,

package/src/shade/renderer/light/environment/equirectangular_zenith_first_direction_to_uv.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Direction to equirectangular UV, in the convention the environment bake uses:
+ *
+ *   u = (atan2(x, z) + pi) / 2pi
+ *   v = acos(y) / pi
+ *
+ * so **v = 0 is the zenith** (+Y) and longitude is measured from +Z, anticlockwise about +Y.
+ *
+ * ## There are two equirectangular conventions in this tree, deliberately
+ *
+ * `core/geom/3d/equirectangular` defines the projection the other way round — `u = atan2(z, x)/2pi + 0.5`,
+ * `v = asin(y)/pi + 0.5`, which puts the zenith at **v = 1** and starts longitude a quarter turn away
+ * with the opposite handedness. That one matches three.js' `equirectUv`, deliberately, so that a texture
+ * authored for `EquirectangularReflectionMapping` reads correctly through it.
+ *
+ * The two are self-consistent and **not interchangeable**. Feeding an HDRI resampled through this
+ * convention to a probe written against the `core` one gives an environment flipped vertically and
+ * rotated ninety degrees in azimuth — which reads as a bad asset rather than a code bug. The comment at
+ * `resample_equirectangular_to_octahedral`'s decode records that a previous attempt to move the bake onto
+ * the other convention produced an east-west mirrored environment, so "just call the core one" is a change
+ * that has already gone wrong once.
+ *
+ * This exists as a named function rather than as arithmetic inside the resampler because the resampler's
+ * own spec was restating it — a second copy of the mapping, in the place least able to catch a drift in it.
+ *
+ * @param {number[]|Float32Array} out receives `(u, v)`
+ * @param {number} out_offset
+ * @param {number} x unit direction
+ * @param {number} y
+ * @param {number} z
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function equirectangular_zenith_first_direction_to_uv(out: number[] | Float32Array, out_offset: number, x: number, y: number, z: number): void;
+//# sourceMappingURL=equirectangular_zenith_first_direction_to_uv.d.ts.map

package/src/shade/renderer/light/environment/equirectangular_zenith_first_direction_to_uv.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"equirectangular_zenith_first_direction_to_uv.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/light/environment/equirectangular_zenith_first_direction_to_uv.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,kEATW,MAAM,EAAE,GAAC,YAAY,cACrB,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,QAWhB"}

package/src/shade/renderer/light/environment/equirectangular_zenith_first_direction_to_uv.js

@@ -0,0 +1,41 @@
+/**
+ * Direction to equirectangular UV, in the convention the environment bake uses:
+ *
+ *   u = (atan2(x, z) + pi) / 2pi
+ *   v = acos(y) / pi
+ *
+ * so **v = 0 is the zenith** (+Y) and longitude is measured from +Z, anticlockwise about +Y.
+ *
+ * ## There are two equirectangular conventions in this tree, deliberately
+ *
+ * `core/geom/3d/equirectangular` defines the projection the other way round — `u = atan2(z, x)/2pi + 0.5`,
+ * `v = asin(y)/pi + 0.5`, which puts the zenith at **v = 1** and starts longitude a quarter turn away
+ * with the opposite handedness. That one matches three.js' `equirectUv`, deliberately, so that a texture
+ * authored for `EquirectangularReflectionMapping` reads correctly through it.
+ *
+ * The two are self-consistent and **not interchangeable**. Feeding an HDRI resampled through this
+ * convention to a probe written against the `core` one gives an environment flipped vertically and
+ * rotated ninety degrees in azimuth — which reads as a bad asset rather than a code bug. The comment at
+ * `resample_equirectangular_to_octahedral`'s decode records that a previous attempt to move the bake onto
+ * the other convention produced an east-west mirrored environment, so "just call the core one" is a change
+ * that has already gone wrong once.
+ *
+ * This exists as a named function rather than as arithmetic inside the resampler because the resampler's
+ * own spec was restating it — a second copy of the mapping, in the place least able to catch a drift in it.
+ *
+ * @param {number[]|Float32Array} out receives `(u, v)`
+ * @param {number} out_offset
+ * @param {number} x unit direction
+ * @param {number} y
+ * @param {number} z
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function equirectangular_zenith_first_direction_to_uv(out, out_offset, x, y, z) {
+    const phi = Math.atan2(x, z);
+    const theta = Math.acos(y < -1 ? -1 : y > 1 ? 1 : y);
+
+    out[out_offset] = (phi + Math.PI) / (Math.PI * 2);
+    out[out_offset + 1] = theta / Math.PI;
+}

package/src/shade/renderer/light/environment/execute_filter_environment_map.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"execute_filter_environment_map.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/light/environment/execute_filter_environment_map.js"],"names":[],"mappings":"AAIA;;;;GAIG;AACH,8GAoCC"}
+{"version":3,"file":"execute_filter_environment_map.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/light/environment/execute_filter_environment_map.js"],"names":[],"mappings":"AAKA;;;;GAIG;AACH,8GAmDC"}

package/src/shade/renderer/light/environment/execute_filter_environment_map.js

@@ -1,5 +1,6 @@
 import { assert } from "../../../../core/assert.js";
 import { TextureViewDescriptor } from "../../../descriptor/texture/TextureViewDescriptor.js";
+import { SPHERE_PROBE_MIPMAP_LEVELS } from "./DEFINES.js";
 import { shader_convolve_reflection_map } from "./shader_convolve_reflection_map.js";
 
 /**
@@ -14,8 +15,23 @@ export function execute_filter_environment_map(
     assert.defined(map);
     assert.defined(encoder);
 
-    const mips = map.descriptor.mipLevelCount;
+    /*
+     Only the levels the roughness mapping is defined over.
 
+     `sphere_probe_lod_to_roughness` divides by SPHERE_PROBE_MIPMAP_LEVELS - 1, so its domain is lod
+     0..4 and its inverse never asks the sampler for more; nothing reads a level above that. This
+     used to walk the texture's whole chain instead, which for the 12 levels a 2048-wide HDRI is
+     allocated with is seven dispatches convolving at EXTRAPOLATED roughness — lod 11 comes out at
+     2.35, well outside [0,1] — at 196 taps a texel, on every environment change. The constant and
+     the allocation were two sources of truth for one number, and this is the one that decides what
+     gets filtered.
+
+     Still open, and not this line's to fix: an environment map smaller than 16x16 has fewer than
+     five levels, so `roughness_to_lod` can ask for a level the texture does not have and the
+     sampler clamps to a blurrier one than the roughness wanted. That needs the mapping to know the
+     texture's real level count, which is a change to every shader that samples one.
+    */
+    const mips = Math.min(map.descriptor.mipLevelCount, SPHERE_PROBE_MIPMAP_LEVELS);
 
     for (let i = 1; i < mips; i++) {
         const target_width = map.size[0] >> i;

package/src/shade/renderer/light/environment/octahedral_uv_to_direction.d.ts

@@ -1,16 +1,8 @@
 /**
- * CPU port of the WGSL `uv_octahedral_unit_decode` chunk (Rune Stubbe's octahedral decode,
- * Z-pole): given a texel UV of an octahedral environment map, returns the world direction the
- * GPU will sample that texel for (the exact inverse of `uv_octahedral_unit_encode`).
- *
- * Every CPU-side producer/consumer of octahedral environment texels (the equirect resampler,
- * sun-extraction reverse decodes) must go through this ONE function so they can never drift
- * from the GPU sampling convention.
- *
- * @see chunk_uv_octahedral_unit_decode
- * @param {number[]|Float32Array} target receives the normalized direction (x, y, z)
- * @param {number} u in [0, 1]
- * @param {number} v in [0, 1]
+ * @deprecated Renamed to {@link octahedral_z_pole_uv_to_direction}, because the name collided with
+ * `core/geom/3d/octahedra/octahedral_uv_to_direction` — a different pole *and* a different signature.
+ * This re-export is kept for backward compatibility (meep is a library; old names are public surface).
  */
-export function octahedral_uv_to_direction(target: number[] | Float32Array, u: number, v: number): void;
+export const octahedral_uv_to_direction: typeof octahedral_z_pole_uv_to_direction;
+import { octahedral_z_pole_uv_to_direction } from "./octahedral_z_pole_uv_to_direction.js";
 //# sourceMappingURL=octahedral_uv_to_direction.d.ts.map

package/src/shade/renderer/light/environment/octahedral_uv_to_direction.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"octahedral_uv_to_direction.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/light/environment/octahedral_uv_to_direction.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,mDAJW,MAAM,EAAE,GAAC,YAAY,KACrB,MAAM,KACN,MAAM,QAiBhB"}
+{"version":3,"file":"octahedral_uv_to_direction.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/light/environment/octahedral_uv_to_direction.js"],"names":[],"mappings":"AAIA;;;;GAIG;AACH,kFAA4E;kDAPrE,wCAAwC"}

package/src/shade/renderer/light/environment/octahedral_uv_to_direction.js

@@ -1,30 +1,10 @@
-/**
- * CPU port of the WGSL `uv_octahedral_unit_decode` chunk (Rune Stubbe's octahedral decode,
- * Z-pole): given a texel UV of an octahedral environment map, returns the world direction the
- * GPU will sample that texel for (the exact inverse of `uv_octahedral_unit_encode`).
- *
- * Every CPU-side producer/consumer of octahedral environment texels (the equirect resampler,
- * sun-extraction reverse decodes) must go through this ONE function so they can never drift
- * from the GPU sampling convention.
- *
- * @see chunk_uv_octahedral_unit_decode
- * @param {number[]|Float32Array} target receives the normalized direction (x, y, z)
- * @param {number} u in [0, 1]
- * @param {number} v in [0, 1]
- */
-export function octahedral_uv_to_direction(target, u, v) {
-    let x = u * 2 - 1;
-    let y = v * 2 - 1;
-    const z = 1 - Math.abs(x) - Math.abs(y);
-
-    // octahedron fold for the lower hemisphere (mirrors the WGSL select-based form)
-    const t = Math.max(-z, 0);
-    x += x > 0 ? -t : t;
-    y += y > 0 ? -t : t;
-
-    const m = 1 / Math.sqrt(x * x + y * y + z * z);
-
-    target[0] = x * m;
-    target[1] = y * m;
-    target[2] = z * m;
-}
+import {
+    octahedral_z_pole_uv_to_direction
+} from "./octahedral_z_pole_uv_to_direction.js";
+
+/**
+ * @deprecated Renamed to {@link octahedral_z_pole_uv_to_direction}, because the name collided with
+ * `core/geom/3d/octahedra/octahedral_uv_to_direction` — a different pole *and* a different signature.
+ * This re-export is kept for backward compatibility (meep is a library; old names are public surface).
+ */
+export const octahedral_uv_to_direction = octahedral_z_pole_uv_to_direction;

package/src/shade/renderer/light/environment/octahedral_z_pole_uv_to_direction.d.ts

@@ -0,0 +1,31 @@
+/**
+ * CPU port of the WGSL `uv_octahedral_unit_decode` chunk (Rune Stubbe's octahedral decode,
+ * **Z-pole**): given a texel UV of an octahedral environment map, returns the world direction the
+ * GPU will sample that texel for (the exact inverse of `uv_octahedral_unit_encode`).
+ *
+ * Every CPU-side producer/consumer of octahedral environment texels (the equirect resampler,
+ * sun-extraction reverse decodes) must go through this ONE function so they can never drift
+ * from the GPU sampling convention.
+ *
+ * ## Two conventions, and why the name says which
+ *
+ * `core/geom/3d` has its own octahedral codec — `octahedral_uv_to_direction` /
+ * `octahedral_direction_to_uv`, and `decode_octahedron_to_unit` / `encode_unit_to_octahedron` over the
+ * `[-1, 1]` range — and it folds on **`y`**, emitting `(x, z)`. This one folds on `z` and emits
+ * `(x, y)`, matching the WGSL chunks, which is why a producer feeding the GPU decoder swizzles y and z
+ * at the call site (see `encode_normals_to_octahedral_u32`).
+ *
+ * This function used to be called `octahedral_uv_to_direction` — the same name as the `core` one, with a
+ * different pole *and* a different signature: `(target, u, v)` against
+ * `(out, out_offset, in_uv, in_offset)`. An importer who autocompleted the name got one of two functions
+ * that disagree about which axis is up, and the `core` one silently reads `u` out of
+ * `arguments[2][arguments[3]]` if handed this call shape. The old name is kept as a deprecated alias
+ * because it is published surface.
+ *
+ * @see chunk_uv_octahedral_unit_decode
+ * @param {number[]|Float32Array} target receives the normalized direction (x, y, z)
+ * @param {number} u in [0, 1]
+ * @param {number} v in [0, 1]
+ */
+export function octahedral_z_pole_uv_to_direction(target: number[] | Float32Array, u: number, v: number): void;
+//# sourceMappingURL=octahedral_z_pole_uv_to_direction.d.ts.map

package/src/shade/renderer/light/environment/octahedral_z_pole_uv_to_direction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"octahedral_z_pole_uv_to_direction.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/light/environment/octahedral_z_pole_uv_to_direction.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,0DAJW,MAAM,EAAE,GAAC,YAAY,KACrB,MAAM,KACN,MAAM,QAiBhB"}

package/src/shade/renderer/light/environment/octahedral_z_pole_uv_to_direction.js

@@ -0,0 +1,45 @@
+/**
+ * CPU port of the WGSL `uv_octahedral_unit_decode` chunk (Rune Stubbe's octahedral decode,
+ * **Z-pole**): given a texel UV of an octahedral environment map, returns the world direction the
+ * GPU will sample that texel for (the exact inverse of `uv_octahedral_unit_encode`).
+ *
+ * Every CPU-side producer/consumer of octahedral environment texels (the equirect resampler,
+ * sun-extraction reverse decodes) must go through this ONE function so they can never drift
+ * from the GPU sampling convention.
+ *
+ * ## Two conventions, and why the name says which
+ *
+ * `core/geom/3d` has its own octahedral codec — `octahedral_uv_to_direction` /
+ * `octahedral_direction_to_uv`, and `decode_octahedron_to_unit` / `encode_unit_to_octahedron` over the
+ * `[-1, 1]` range — and it folds on **`y`**, emitting `(x, z)`. This one folds on `z` and emits
+ * `(x, y)`, matching the WGSL chunks, which is why a producer feeding the GPU decoder swizzles y and z
+ * at the call site (see `encode_normals_to_octahedral_u32`).
+ *
+ * This function used to be called `octahedral_uv_to_direction` — the same name as the `core` one, with a
+ * different pole *and* a different signature: `(target, u, v)` against
+ * `(out, out_offset, in_uv, in_offset)`. An importer who autocompleted the name got one of two functions
+ * that disagree about which axis is up, and the `core` one silently reads `u` out of
+ * `arguments[2][arguments[3]]` if handed this call shape. The old name is kept as a deprecated alias
+ * because it is published surface.
+ *
+ * @see chunk_uv_octahedral_unit_decode
+ * @param {number[]|Float32Array} target receives the normalized direction (x, y, z)
+ * @param {number} u in [0, 1]
+ * @param {number} v in [0, 1]
+ */
+export function octahedral_z_pole_uv_to_direction(target, u, v) {
+    let x = u * 2 - 1;
+    let y = v * 2 - 1;
+    const z = 1 - Math.abs(x) - Math.abs(y);
+
+    // octahedron fold for the lower hemisphere (mirrors the WGSL select-based form)
+    const t = Math.max(-z, 0);
+    x += x > 0 ? -t : t;
+    y += y > 0 ? -t : t;
+
+    const m = 1 / Math.sqrt(x * x + y * y + z * z);
+
+    target[0] = x * m;
+    target[1] = y * m;
+    target[2] = z * m;
+}

package/src/shade/renderer/light/environment/resample_cube_to_octahedral.js

@@ -1,7 +1,7 @@
 import { assert } from "../../../../core/assert.js";
 import { Sampler2D } from "../../../../engine/graphics/texture/sampler/Sampler2D.js";
 import { SAMPLE_OFFSETS, SAMPLE_WEIGHTS, SUPER_SAMPLE_COUNT } from "./octahedral_resample_kernel.js";
-import { octahedral_uv_to_direction } from "./octahedral_uv_to_direction.js";
+import { octahedral_z_pole_uv_to_direction } from "./octahedral_z_pole_uv_to_direction.js";
 
 /**
  * Standard cube-map face selection — the GL/D3D/WebGPU table — for a direction already in cube
@@ -124,7 +124,7 @@ export function resample_cube_to_octahedral(faces, output_resolution) {
                 const v = (y + SAMPLE_OFFSETS[s * 2 + 1] + 0.5) / output_resolution;
 
                 // the direction the GPU will sample this texel for
-                octahedral_uv_to_direction(SCRATCH_DIRECTION, u, v);
+                octahedral_z_pole_uv_to_direction(SCRATCH_DIRECTION, u, v);
 
                 const face = cube_direction_to_face(
                     -SCRATCH_DIRECTION[0],

package/src/shade/renderer/light/environment/resample_equirectangular_to_octahedral.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"resample_equirectangular_to_octahedral.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/light/environment/resample_equirectangular_to_octahedral.js"],"names":[],"mappings":"AAKA;;;;GAIG;AACH,8DAHW,SAAS,qBACT,MAAM,aAkEhB;0BAzEyB,0DAA0D"}
+{"version":3,"file":"resample_equirectangular_to_octahedral.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/light/environment/resample_equirectangular_to_octahedral.js"],"names":[],"mappings":"AAMA;;;;GAIG;AACH,8DAHW,SAAS,qBACT,MAAM,aAoEhB;0BA5EyB,0DAA0D"}

package/src/shade/renderer/light/environment/resample_equirectangular_to_octahedral.js

@@ -1,7 +1,8 @@
 import { assert } from "../../../../core/assert.js";
 import { Sampler2D } from "../../../../engine/graphics/texture/sampler/Sampler2D.js";
+import { equirectangular_zenith_first_direction_to_uv } from "./equirectangular_zenith_first_direction_to_uv.js";
 import { SAMPLE_OFFSETS, SAMPLE_WEIGHTS, SUPER_SAMPLE_COUNT } from "./octahedral_resample_kernel.js";
-import { octahedral_uv_to_direction } from "./octahedral_uv_to_direction.js";
+import { octahedral_z_pole_uv_to_direction } from "./octahedral_z_pole_uv_to_direction.js";
 
 /**
  *
@@ -17,6 +18,7 @@ export function resample_equirectangular_to_octahedral(input, output_resolution)
     output.data.fill(1);
 
     const scratch_v3 = new Float32Array(3);
+    const scratch_uv = new Float32Array(2);
 
     const SAMPLE = new Float32Array(SUPER_SAMPLE_COUNT * 3);
 
@@ -40,15 +42,16 @@ export function resample_equirectangular_to_octahedral(input, output_resolution)
                 // The direction the GPU will sample this texel for — MUST be the exact inverse of
                 // uv_octahedral_unit_encode (the previous meep Y-pole decode with a negated U
                 // produced an east-west MIRRORED environment relative to the source panorama).
-                octahedral_uv_to_direction(scratch_v3, out_u, out_v);
+                octahedral_z_pole_uv_to_direction(scratch_v3, out_u, out_v);
 
-                // Y-up equirectangular convention: v = 0 is the zenith (+Y), phi = atan2(x, z).
-                // The reverse decode in sun-extraction tools mirrors this exact mapping.
-                const phi = Math.atan2(scratch_v3[0], scratch_v3[2]);
-                const theta = Math.acos(scratch_v3[1]);
+                // Y-up equirectangular convention: v = 0 is the zenith (+Y), phi = atan2(x, z). This is
+                // NOT the convention core/geom/3d/equirectangular defines — see the function's docblock.
+                equirectangular_zenith_first_direction_to_uv(
+                    scratch_uv, 0, scratch_v3[0], scratch_v3[1], scratch_v3[2]
+                );
 
-                const in_u = (phi + Math.PI) / (Math.PI * 2);
-                const in_v = (theta) / (Math.PI);
+                const in_u = scratch_uv[0];
+                const in_v = scratch_uv[1];
 
                 const weight = SAMPLE_WEIGHTS[super_sample_i];
 

package/src/shade/renderer/light/model/SpotLight.d.ts

@@ -1,6 +1,15 @@
 export class SpotLight extends Light {
     /**
-     * How far does the light reach?
+     * How far does the light reach? Zero or below means no cutoff, which is what the cull shaders
+     * read it as — see the UNBOUNDED branch in `chunk_spot_light_to_aabb3`.
+     *
+     * The default used to be FLOAT32_MAX, which says the same thing and contradicts that sentinel:
+     * the shaders took it as a real cone height, so `cone_to_bounding_box` computed
+     * `3.4e38 * tan(PI/3)` and overflowed f32 to +Inf. The AABB came back degenerate,
+     * `aabb3_project_perspective` then failed its bounds check and the HZB test was skipped
+     * entirely — so a default-constructed spot light, which is what an artist authoring one
+     * produces, was never occlusion-culled. The sentinel takes the clean 1e30 path instead.
+     *
      * @type {number}
      */
     distance: number;

package/src/shade/renderer/light/model/SpotLight.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SpotLight.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/light/model/SpotLight.js"],"names":[],"mappings":"AAGA;IACI;;;OAGG;IACH,UAFU,MAAM,CAEO;IAEvB;;;OAGG;IACH,OAFU,MAAM,CAEI;IAEpB;;;OAGG;IACH,UAFU,MAAM,CAEH;IAyBb,oCAGC;IApBD;;;;;;;;;;;OAWG;IACH,+BAGC;IAQL;;;OAGG;IACH,sBAFU,OAAO,CAEc;CAN9B;sBAhDqB,YAAY"}
+{"version":3,"file":"SpotLight.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/light/model/SpotLight.js"],"names":[],"mappings":"AAEA;IACI;;;;;;;;;;;;OAYG;IACH,UAFU,MAAM,CAEH;IAEb;;;OAGG;IACH,OAFU,MAAM,CAEI;IAEpB;;;OAGG;IACH,UAFU,MAAM,CAEH;IAyBb,oCAGC;IApBD;;;;;;;;;;;OAWG;IACH,+BAGC;IAQL;;;OAGG;IACH,sBAFU,OAAO,CAEc;CAN9B;sBAzDqB,YAAY"}

package/src/shade/renderer/light/model/SpotLight.js

@@ -1,12 +1,20 @@
-import { FLOAT32_MAX } from "../../../../core/binary/FLOAT32_MAX.js";
 import { Light } from "./Light.js";
 
 export class SpotLight extends Light {
     /**
-     * How far does the light reach?
+     * How far does the light reach? Zero or below means no cutoff, which is what the cull shaders
+     * read it as — see the UNBOUNDED branch in `chunk_spot_light_to_aabb3`.
+     *
+     * The default used to be FLOAT32_MAX, which says the same thing and contradicts that sentinel:
+     * the shaders took it as a real cone height, so `cone_to_bounding_box` computed
+     * `3.4e38 * tan(PI/3)` and overflowed f32 to +Inf. The AABB came back degenerate,
+     * `aabb3_project_perspective` then failed its bounds check and the HZB test was skipped
+     * entirely — so a default-constructed spot light, which is what an artist authoring one
+     * produces, was never occlusion-culled. The sentinel takes the clean 1e30 path instead.
+     *
      * @type {number}
      */
-    distance = FLOAT32_MAX;
+    distance = 0;
 
     /**
      * Limit is Pi/2 (90 degrees) this is a half-angle of the cone.

package/src/shade/renderer/light/model/io/light_record_directional.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"light_record_directional.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/light/model/io/light_record_directional.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;GAYG;AACH,iFAJW,MAAM,OAyBhB"}
+{"version":3,"file":"light_record_directional.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/light/model/io/light_record_directional.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;;GAYG;AACH,iFAJW,MAAM,OA0BhB"}

package/src/shade/renderer/light/model/io/light_record_directional.js

@@ -1,3 +1,4 @@
+import { GPU_DATABASE_NULL } from "../../../buffer/table/GPU_DATABASE_NULL.js";
 import { light_flags_pack } from "./LIGHT_FLAGS.js";
 import { light_pack_color } from "./light_pack_color.js";
 
@@ -35,7 +36,8 @@ export function light_record_directional(light, transform_row) {
         disk_radius: light.radius,
         flags: light_flags_pack(has_shadow),
         near_clip_distance: light.near_clip_distance,
-        shadow_id: has_shadow ? shadowmap_id : 0,
+        // a link into shadow_directional; a light without a shadow names no slot
+        shadow_id: has_shadow ? shadowmap_id : GPU_DATABASE_NULL,
         node: transform_row,
     };
 }

package/src/shade/renderer/light/model/io/light_record_point.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"light_record_point.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/light/model/io/light_record_point.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;GAYG;AACH,qEAJW,MAAM,OA0BhB"}
+{"version":3,"file":"light_record_point.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/light/model/io/light_record_point.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;;GAYG;AACH,qEAJW,MAAM,OA2BhB"}

package/src/shade/renderer/light/model/io/light_record_point.js

@@ -1,3 +1,4 @@
+import { GPU_DATABASE_NULL } from "../../../buffer/table/GPU_DATABASE_NULL.js";
 import { light_flags_pack } from "./LIGHT_FLAGS.js";
 import { light_pack_color } from "./light_pack_color.js";
 
@@ -36,7 +37,8 @@ export function light_record_point(light, transform_row) {
         radius: light.radius,
         flags: light_flags_pack(has_shadow),
         near_clip_distance: light.near_clip_distance,
-        shadow_id: has_shadow ? shadowmap_id : 0,
+        // a link into shadow_point; a light without a shadow names no slot
+        shadow_id: has_shadow ? shadowmap_id : GPU_DATABASE_NULL,
         node: transform_row,
     };
 }

package/src/shade/renderer/light/model/io/light_record_spot.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"light_record_spot.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/light/model/io/light_record_spot.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;GAaG;AACH,mEALW,MAAM,OAoChB"}
+{"version":3,"file":"light_record_spot.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/light/model/io/light_record_spot.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;GAaG;AACH,mEALW,MAAM,OAqChB"}

package/src/shade/renderer/light/model/io/light_record_spot.js

@@ -1,3 +1,4 @@
+import { GPU_DATABASE_NULL } from "../../../buffer/table/GPU_DATABASE_NULL.js";
 import { light_flags_pack } from "./LIGHT_FLAGS.js";
 import { light_pack_color } from "./light_pack_color.js";
 
@@ -47,7 +48,8 @@ export function light_record_spot(light, transform_row) {
         penumbraCos: Math.cos(light.angle * (1 - light.penumbra)),
         flags: light_flags_pack(has_shadow),
         near_clip_distance: light.near_clip_distance,
-        shadow_id: has_shadow ? shadowmap_id : 0,
+        // a link into shadow_spot; a light without a shadow names no slot
+        shadow_id: has_shadow ? shadowmap_id : GPU_DATABASE_NULL,
         node: transform_row,
     };
 }

package/src/shade/renderer/loader/gltf/gltf_base_url.d.ts

@@ -0,0 +1,20 @@
+/**
+ * The directory a container's sibling files are resolved against.
+ *
+ * Three cases, and the test used to be against the wrong sentinel — `lastIndexOf('/') !== 0` where
+ * `!== -1` was meant — so it got two of the three wrong:
+ *
+ *  - a bare file name has no slash at all, `lastIndexOf` is -1, and the old test took the "has a
+ *    directory" branch to produce `url.substring(0, 0)` — the empty string, which `loadFromJson`
+ *    rejects outright with "baseUrl must be specified". That is what a drag-and-drop `fileMap`
+ *    produces, which is the case the option exists for.
+ *  - a root-relative `/model.glb` has its only slash at 0, and the old test sent it to `'./'`, so
+ *    a sibling `scene.bin` resolved against the current directory rather than the root.
+ *  - everything with an interior slash was, and is, the prefix up to and including it. That is
+ *    every call site in this repo, which is why neither of the other two has been seen.
+ *
+ * @param {string} url
+ * @returns {string} with a trailing separator, or `'./'` when there is no directory part
+ */
+export function gltf_base_url(url: string): string;
+//# sourceMappingURL=gltf_base_url.d.ts.map

package/src/shade/renderer/loader/gltf/gltf_base_url.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gltf_base_url.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/loader/gltf/gltf_base_url.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,mCAHW,MAAM,GACJ,MAAM,CAUlB"}