@woosh/meep-engine 2.168.1 → 2.169.1

package/src/engine/graphics/sh3/lightmap/lightmap_rasterize_triangle.d.ts

@@ -23,8 +23,8 @@
  * @param {number} cy vertex C y, in pixels
  * @param {number} width raster width (texel centers tested in [0, width))
  * @param {number} height raster height (texel centers tested in [0, height))
- * @param {function(px:number, py:number, wA:number, wB:number, wC:number):void} callback
+ * @param {(px: number, py: number, wA: number, wB: number, wC: number) => void} callback
  * @param {boolean} [conservative] include edge-overlapping texels with a clamped sample (default false)
  */
-export function lightmap_rasterize_triangle(ax: number, ay: number, bx: number, by: number, cx: number, cy: number, width: number, height: number, callback: any, conservative?: boolean): void;
+export function lightmap_rasterize_triangle(ax: number, ay: number, bx: number, by: number, cx: number, cy: number, width: number, height: number, callback: (px: number, py: number, wA: number, wB: number, wC: number) => void, conservative?: boolean): void;
 //# sourceMappingURL=lightmap_rasterize_triangle.d.ts.map

package/src/engine/graphics/sh3/lightmap/lightmap_rasterize_triangle.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lightmap_rasterize_triangle.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/sh3/lightmap/lightmap_rasterize_triangle.js"],"names":[],"mappings":"AAsDA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,gDAXW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,SACN,MAAM,UACN,MAAM,gCAEN,OAAO,QAgEjB"}
+{"version":3,"file":"lightmap_rasterize_triangle.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/sh3/lightmap/lightmap_rasterize_triangle.js"],"names":[],"mappings":"AAsDA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,gDAXW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,SACN,MAAM,UACN,MAAM,iBACD,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,MAAM,KAAK,IAAI,iBACpE,OAAO,QAgEjB"}

package/src/engine/graphics/sh3/lightmap/lightmap_rasterize_triangle.js

@@ -1,145 +1,145 @@
-/** Half the diagonal of a unit texel — the conservative overlap reach from a center. */
-const HALF_TEXEL_DIAGONAL = Math.SQRT2 * 0.5;
-
-/**
- * Closest point to (px,py) on segment (ax,ay)->(bx,by), written to out[0..1].
- *
- * @param {Float32Array|number[]} out
- * @param {number} px
- * @param {number} py
- * @param {number} ax
- * @param {number} ay
- * @param {number} bx
- * @param {number} by
- */
-function closest_on_segment(out, px, py, ax, ay, bx, by) {
-    const ex = bx - ax;
-    const ey = by - ay;
-    const len2 = ex * ex + ey * ey;
-    let t = len2 > 0 ? ((px - ax) * ex + (py - ay) * ey) / len2 : 0;
-    if (t < 0) t = 0; else if (t > 1) t = 1;
-    out[0] = ax + t * ex;
-    out[1] = ay + t * ey;
-}
-
-const _q = new Float32Array(2);
-const _e = new Float32Array(2);
-
-/**
- * Closest point to (px,py) on the (filled) triangle, written to out[0..1].
- * Assumes the point is outside the triangle (callers test inside first).
- *
- * @param {Float32Array|number[]} out
- */
-function closest_on_triangle(out, px, py, ax, ay, bx, by, cx, cy) {
-    let best_d2 = Infinity;
-
-    closest_on_segment(_e, px, py, ax, ay, bx, by);
-    let dx = px - _e[0], dy = py - _e[1];
-    let d2 = dx * dx + dy * dy;
-    if (d2 < best_d2) { best_d2 = d2; out[0] = _e[0]; out[1] = _e[1]; }
-
-    closest_on_segment(_e, px, py, bx, by, cx, cy);
-    dx = px - _e[0]; dy = py - _e[1];
-    d2 = dx * dx + dy * dy;
-    if (d2 < best_d2) { best_d2 = d2; out[0] = _e[0]; out[1] = _e[1]; }
-
-    closest_on_segment(_e, px, py, cx, cy, ax, ay);
-    dx = px - _e[0]; dy = py - _e[1];
-    d2 = dx * dx + dy * dy;
-    if (d2 < best_d2) { best_d2 = d2; out[0] = _e[0]; out[1] = _e[1]; }
-
-    return Math.sqrt(best_d2);
-}
-
-/**
- * Rasterize a 2D triangle in integer pixel space, invoking `callback` once per
- * covered texel with the barycentric weights of the three vertices (A, B, C) at
- * the sampled point. The weights are an exact partition of unity (`wA+wB+wC===1`,
- * all `>=0`), so a caller can interpolate any per-vertex attribute directly.
- *
- * Default (center) mode: a texel is covered iff its CENTER lies inside the
- * triangle, sampled at that center.
- *
- * Conservative mode (`conservative === true`): a texel is also covered if its
- * cell overlaps the triangle even though its center is outside (thin features,
- * chart borders). For those, the sample is **clamped to the closest point on the
- * triangle** so the interpolated position/normal stays on the surface — avoiding
- * the dropped-edge-texel black gutters of center-only coverage.
- *
- * Degenerate (zero-area) triangles produce no callbacks.
- *
- * @param {number} ax vertex A x, in pixels
- * @param {number} ay vertex A y, in pixels
- * @param {number} bx vertex B x, in pixels
- * @param {number} by vertex B y, in pixels
- * @param {number} cx vertex C x, in pixels
- * @param {number} cy vertex C y, in pixels
- * @param {number} width raster width (texel centers tested in [0, width))
- * @param {number} height raster height (texel centers tested in [0, height))
- * @param {function(px:number, py:number, wA:number, wB:number, wC:number):void} callback
- * @param {boolean} [conservative] include edge-overlapping texels with a clamped sample (default false)
- */
-export function lightmap_rasterize_triangle(ax, ay, bx, by, cx, cy, width, height, callback, conservative = false) {
-    // conservative mode reaches one extra texel of overlap, so widen the scan box
-    const margin = conservative ? 1 : 0;
-
-    const min_x = Math.max(0, Math.floor(Math.min(ax, bx, cx)) - margin);
-    const max_x = Math.min(width - 1, Math.floor(Math.max(ax, bx, cx)) + margin);
-    const min_y = Math.max(0, Math.floor(Math.min(ay, by, cy)) - margin);
-    const max_y = Math.min(height - 1, Math.floor(Math.max(ay, by, cy)) + margin);
-
-    const d = (by - cy) * (ax - cx) + (cx - bx) * (ay - cy);
-
-    if (d === 0) {
-        // degenerate triangle, no area to cover
-        return;
-    }
-
-    const inv_d = 1 / d;
-
-    for (let py = min_y; py <= max_y; py++) {
-        const sy = py + 0.5;
-
-        for (let px = min_x; px <= max_x; px++) {
-            const sx = px + 0.5;
-
-            const wA = ((by - cy) * (sx - cx) + (cx - bx) * (sy - cy)) * inv_d;
-            const wB = ((cy - ay) * (sx - cx) + (ax - cx) * (sy - cy)) * inv_d;
-            const wC = 1 - wA - wB;
-
-            if (wA >= 0 && wB >= 0 && wC >= 0) {
-                callback(px, py, wA, wB, wC);
-                continue;
-            }
-
-            if (!conservative) {
-                continue;
-            }
-
-            // center is outside: keep the texel only if its cell overlaps the
-            // triangle, sampling the clamped (on-triangle) closest point
-            const dist = closest_on_triangle(_q, sx, sy, ax, ay, bx, by, cx, cy);
-            if (dist > HALF_TEXEL_DIAGONAL) {
-                continue;
-            }
-
-            const qx = _q[0];
-            const qy = _q[1];
-            let cwA = ((by - cy) * (qx - cx) + (cx - bx) * (qy - cy)) * inv_d;
-            let cwB = ((cy - ay) * (qx - cx) + (ax - cx) * (qy - cy)) * inv_d;
-            // clamp tiny negative fp drift so the weights stay a valid convex combo
-            if (cwA < 0) cwA = 0;
-            if (cwB < 0) cwB = 0;
-            let cwC = 1 - cwA - cwB;
-            if (cwC < 0) {
-                cwC = 0;
-                const s = cwA + cwB;
-                cwA /= s;
-                cwB /= s;
-            }
-
-            callback(px, py, cwA, cwB, cwC);
-        }
-    }
-}
+/** Half the diagonal of a unit texel — the conservative overlap reach from a center. */
+const HALF_TEXEL_DIAGONAL = Math.SQRT2 * 0.5;
+
+/**
+ * Closest point to (px,py) on segment (ax,ay)->(bx,by), written to out[0..1].
+ *
+ * @param {Float32Array|number[]} out
+ * @param {number} px
+ * @param {number} py
+ * @param {number} ax
+ * @param {number} ay
+ * @param {number} bx
+ * @param {number} by
+ */
+function closest_on_segment(out, px, py, ax, ay, bx, by) {
+    const ex = bx - ax;
+    const ey = by - ay;
+    const len2 = ex * ex + ey * ey;
+    let t = len2 > 0 ? ((px - ax) * ex + (py - ay) * ey) / len2 : 0;
+    if (t < 0) t = 0; else if (t > 1) t = 1;
+    out[0] = ax + t * ex;
+    out[1] = ay + t * ey;
+}
+
+const _q = new Float32Array(2);
+const _e = new Float32Array(2);
+
+/**
+ * Closest point to (px,py) on the (filled) triangle, written to out[0..1].
+ * Assumes the point is outside the triangle (callers test inside first).
+ *
+ * @param {Float32Array|number[]} out
+ */
+function closest_on_triangle(out, px, py, ax, ay, bx, by, cx, cy) {
+    let best_d2 = Infinity;
+
+    closest_on_segment(_e, px, py, ax, ay, bx, by);
+    let dx = px - _e[0], dy = py - _e[1];
+    let d2 = dx * dx + dy * dy;
+    if (d2 < best_d2) { best_d2 = d2; out[0] = _e[0]; out[1] = _e[1]; }
+
+    closest_on_segment(_e, px, py, bx, by, cx, cy);
+    dx = px - _e[0]; dy = py - _e[1];
+    d2 = dx * dx + dy * dy;
+    if (d2 < best_d2) { best_d2 = d2; out[0] = _e[0]; out[1] = _e[1]; }
+
+    closest_on_segment(_e, px, py, cx, cy, ax, ay);
+    dx = px - _e[0]; dy = py - _e[1];
+    d2 = dx * dx + dy * dy;
+    if (d2 < best_d2) { best_d2 = d2; out[0] = _e[0]; out[1] = _e[1]; }
+
+    return Math.sqrt(best_d2);
+}
+
+/**
+ * Rasterize a 2D triangle in integer pixel space, invoking `callback` once per
+ * covered texel with the barycentric weights of the three vertices (A, B, C) at
+ * the sampled point. The weights are an exact partition of unity (`wA+wB+wC===1`,
+ * all `>=0`), so a caller can interpolate any per-vertex attribute directly.
+ *
+ * Default (center) mode: a texel is covered iff its CENTER lies inside the
+ * triangle, sampled at that center.
+ *
+ * Conservative mode (`conservative === true`): a texel is also covered if its
+ * cell overlaps the triangle even though its center is outside (thin features,
+ * chart borders). For those, the sample is **clamped to the closest point on the
+ * triangle** so the interpolated position/normal stays on the surface — avoiding
+ * the dropped-edge-texel black gutters of center-only coverage.
+ *
+ * Degenerate (zero-area) triangles produce no callbacks.
+ *
+ * @param {number} ax vertex A x, in pixels
+ * @param {number} ay vertex A y, in pixels
+ * @param {number} bx vertex B x, in pixels
+ * @param {number} by vertex B y, in pixels
+ * @param {number} cx vertex C x, in pixels
+ * @param {number} cy vertex C y, in pixels
+ * @param {number} width raster width (texel centers tested in [0, width))
+ * @param {number} height raster height (texel centers tested in [0, height))
+ * @param {(px: number, py: number, wA: number, wB: number, wC: number) => void} callback
+ * @param {boolean} [conservative] include edge-overlapping texels with a clamped sample (default false)
+ */
+export function lightmap_rasterize_triangle(ax, ay, bx, by, cx, cy, width, height, callback, conservative = false) {
+    // conservative mode reaches one extra texel of overlap, so widen the scan box
+    const margin = conservative ? 1 : 0;
+
+    const min_x = Math.max(0, Math.floor(Math.min(ax, bx, cx)) - margin);
+    const max_x = Math.min(width - 1, Math.floor(Math.max(ax, bx, cx)) + margin);
+    const min_y = Math.max(0, Math.floor(Math.min(ay, by, cy)) - margin);
+    const max_y = Math.min(height - 1, Math.floor(Math.max(ay, by, cy)) + margin);
+
+    const d = (by - cy) * (ax - cx) + (cx - bx) * (ay - cy);
+
+    if (d === 0) {
+        // degenerate triangle, no area to cover
+        return;
+    }
+
+    const inv_d = 1 / d;
+
+    for (let py = min_y; py <= max_y; py++) {
+        const sy = py + 0.5;
+
+        for (let px = min_x; px <= max_x; px++) {
+            const sx = px + 0.5;
+
+            const wA = ((by - cy) * (sx - cx) + (cx - bx) * (sy - cy)) * inv_d;
+            const wB = ((cy - ay) * (sx - cx) + (ax - cx) * (sy - cy)) * inv_d;
+            const wC = 1 - wA - wB;
+
+            if (wA >= 0 && wB >= 0 && wC >= 0) {
+                callback(px, py, wA, wB, wC);
+                continue;
+            }
+
+            if (!conservative) {
+                continue;
+            }
+
+            // center is outside: keep the texel only if its cell overlaps the
+            // triangle, sampling the clamped (on-triangle) closest point
+            const dist = closest_on_triangle(_q, sx, sy, ax, ay, bx, by, cx, cy);
+            if (dist > HALF_TEXEL_DIAGONAL) {
+                continue;
+            }
+
+            const qx = _q[0];
+            const qy = _q[1];
+            let cwA = ((by - cy) * (qx - cx) + (cx - bx) * (qy - cy)) * inv_d;
+            let cwB = ((cy - ay) * (qx - cx) + (ax - cx) * (qy - cy)) * inv_d;
+            // clamp tiny negative fp drift so the weights stay a valid convex combo
+            if (cwA < 0) cwA = 0;
+            if (cwB < 0) cwB = 0;
+            let cwC = 1 - cwA - cwB;
+            if (cwC < 0) {
+                cwC = 0;
+                const s = cwA + cwB;
+                cwA /= s;
+                cwB /= s;
+            }
+
+            callback(px, py, cwA, cwB, cwC);
+        }
+    }
+}

package/src/engine/graphics/sh3/lpv/PathTracerProbeRenderer.d.ts

@@ -3,7 +3,8 @@ export class PathTracerProbeRenderer extends ProbeRenderer {
     max_bounce_count: number;
     sample_count: number;
     random: (() => number) | {
-        setCurrentSeed: (arg0: v) => number;
+        setCurrentSeed: (v: number) => void;
+        getCurrentSeed: () => number;
     };
     scene: PathTracedScene;
     /**

package/src/engine/graphics/sh3/lpv/PathTracerProbeRenderer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"PathTracerProbeRenderer.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/sh3/lpv/PathTracerProbeRenderer.js"],"names":[],"mappings":"AAuBA;IACI,mBAA0B;IAC1B,yBAAqB;IAErB,qBAAoB;IAEpB;;MAAyB;IAEzB,uBAA6B;IAE7B;;;;;;;;OAQG;IACH,kCAPW,MAAM,aACN,MAAM,YACN,MAAM,EAAE,mBACR,MAAM,UACN,MAAM,EAAE,iBACR,MAAM,QAchB;IAED,iFAuCC;IAKD,mBACC;IAED,4BAKC;CACJ;8BA/F6B,oBAAoB;2BAHvB,8BAA8B;gCADzB,mCAAmC"}
+{"version":3,"file":"PathTracerProbeRenderer.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/sh3/lpv/PathTracerProbeRenderer.js"],"names":[],"mappings":"AAuBA;IACI,mBAA0B;IAC1B,yBAAqB;IAErB,qBAAoB;IAEpB;;;MAAyB;IAEzB,uBAA6B;IAE7B;;;;;;;;OAQG;IACH,kCAPW,MAAM,aACN,MAAM,YACN,MAAM,EAAE,mBACR,MAAM,UACN,MAAM,EAAE,iBACR,MAAM,QAchB;IAED,iFAuCC;IAKD,mBACC;IAED,4BAKC;CACJ;8BA/F6B,oBAAoB;2BAHvB,8BAA8B;gCADzB,mCAAmC"}

package/src/engine/graphics/texture/atlas/AtlasLookupTexture.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AtlasLookupTexture.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/texture/atlas/AtlasLookupTexture.js"],"names":[],"mappings":"AAEA;IAEQ;;;OAGG;IACH,OAFU,eAAa,IAAI,CAEV;IAEjB;;;;OAIG;IACH,mBAAoB;IAEpB;;;;OAIG;IACH,eAAgC;IAEhC,qBAAiD;IAUrD;;;OAGG;IACH,kCAEC;IAED,eA0CC;CACJ;4BArFgF,OAAO"}
+{"version":3,"file":"AtlasLookupTexture.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/texture/atlas/AtlasLookupTexture.js"],"names":[],"mappings":"AAEA;IAEQ;;;OAGG;IACH,OAFU,eAAa,IAAI,CAEV;IAEjB;;;;OAIG;IACH,mBAAoB;IAEpB;;;;OAIG;IACH,eAAgC;IAEhC,qBAAiD;IAYrD;;;OAGG;IACH,kCAEC;IAED,eA+CC;CACJ;4BA5FgF,OAAO"}

package/src/engine/graphics/texture/atlas/AtlasLookupTexture.js

@@ -29,7 +29,9 @@ export class AtlasLookupTexture {
         this.texture.magFilter = NearestFilter;
         this.texture.minFilter = NearestFilter;
         this.texture.generateMipmaps = false;
-        this.texture.internalFormat = 'RGB16UI';
+        // four channels are written per record, so the internal format has to be
+        // the four-channel one to match RGBAIntegerFormat
+        this.texture.internalFormat = 'RGBA16UI';
     }
 
     /**
@@ -49,13 +51,18 @@ export class AtlasLookupTexture {
 
         const rowSize = this.__row_size;
 
-        const expected_row_count = Math.ceil(patch_count / rowSize);
+        // at least one row: a zero-height texture is not a valid GL allocation,
+        // and an atlas legitimately starts out with no patches
+        const expected_row_count = Math.max(1, Math.ceil(patch_count / rowSize));
 
         const texture = this.texture;
 
         const image = texture.image;
 
-        if (image.height < expected_row_count) {
+        // the texture starts out 1x1, so a height-only check is satisfied by any
+        // patch count that fits in a single row and no storage is ever allocated
+        // for it -- writes past the first record are then silently dropped
+        if (image.width !== rowSize || image.height < expected_row_count) {
             texture.dispose();
 
             image.height = expected_row_count;

package/src/engine/graphics/texture/atlas/TextureAtlas.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TextureAtlas.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/texture/atlas/TextureAtlas.js"],"names":[],"mappings":"AAkBA;IACI;;;;;;OAMG;IACH,mBALW,MAAM,cACN,cAAc,kBACd,MAAM,EA2DhB;IAjDG;;;;OAIG;IACH,eAA0B;IAE1B;;;OAGG;IACH,gBAAiB;IAEjB;;;OAGG;IACH,eAFU,OAAO,CAEkB;IAInC;;;;OAIG;IACH,2BAAgH;IAGhH;;;OAGG;IACH,eAAiD;IAEjD;;QAEI;;WAEG;;MAEN;IAED;;;;OAIG;IACH,sBAA0B;IAG9B;;;OAGG;IACH,yBAEC;IAED;;;;OAIG;IACH,kBAHW,SAAS,GACP,UAAU,GAAC,SAAS,CAYhC;IAED;;;OAGG;IACH,eAFa,OAAO,CAInB;IAED;;;;OAIG;IACH,gBAHW,UAAU,GACR,OAAO,CAQnB;IAED;;OAEG;IACH,cAkBC;IAED;;;;;OAKG;IACH,UAJW,MAAM,KACN,MAAM,GACJ,OAAO,CA0CnB;IAED;;;;OAIG;IACH,mBAqBC;IAED;;;;OAIG;IACH,mBAaC;IAED;;;;;;OAMG;IACH,kBAIC;IAED;;;;;OAKG;IACH,aAJW,SAAS,YACT,MAAM,GACL,UAAU,CAgCrB;IAED;;;;;OAKG;IACH,YAJW,MAAM,KACN,MAAM,GACJ,OAAO,CAInB;IAED;;;;OAIG;IACH,cAHW,UAAU,GACT,OAAO,CAiClB;IAED;;;OAGG;IACH,UAFa,OAAO,CAsBnB;IAED;;;;OAIG;IACH,aAqGC;IAED;;OAEG;IACH,cA6BC;IAsDD;;OAEG;IACH,cAQC;CACJ;qCAtjBoC,2BAA2B;oBAN5C,kCAAkC;mBAFnC,0CAA0C;0BAMnC,yBAAyB;2BAGxB,iBAAiB;+BAbb,gDAAgD"}
+{"version":3,"file":"TextureAtlas.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/texture/atlas/TextureAtlas.js"],"names":[],"mappings":"AAkBA;IACI;;;;;;OAMG;IACH,mBALW,MAAM,cACN,cAAc,kBACd,MAAM,EA2DhB;IAjDG;;;;OAIG;IACH,eAA0B;IAE1B;;;OAGG;IACH,gBAAiB;IAEjB;;;OAGG;IACH,eAFU,OAAO,CAEkB;IAInC;;;;OAIG;IACH,2BAAgH;IAGhH;;;OAGG;IACH,eAAiD;IAEjD;;QAEI;;WAEG;;MAEN;IAED;;;;OAIG;IACH,sBAA0B;IAG9B;;;OAGG;IACH,yBAEC;IAED;;;;OAIG;IACH,kBAHW,SAAS,GACP,UAAU,GAAC,SAAS,CAYhC;IAED;;;OAGG;IACH,eAFa,OAAO,CAInB;IAED;;;;OAIG;IACH,gBAHW,UAAU,GACR,OAAO,CAQnB;IAED;;OAEG;IACH,cAkBC;IAED;;;;;OAKG;IACH,UAJW,MAAM,KACN,MAAM,GACJ,OAAO,CA0CnB;IAED;;;;OAIG;IACH,mBAqBC;IAED;;;;OAIG;IACH,mBAaC;IAED;;;;;;OAMG;IACH,kBAIC;IAED;;;;;OAKG;IACH,aAJW,SAAS,YACT,MAAM,GACL,UAAU,CAgCrB;IAED;;;;;OAKG;IACH,YAJW,MAAM,KACN,MAAM,GACJ,OAAO,CAInB;IAED;;;;OAIG;IACH,cAHW,UAAU,GACT,OAAO,CAiClB;IAED;;;OAGG;IACH,UAFa,OAAO,CAyBnB;IAED;;;;OAIG;IACH,aAqGC;IAED;;OAEG;IACH,cA6BC;IAsDD;;OAEG;IACH,cAQC;CACJ;qCAzjBoC,2BAA2B;oBAN5C,kCAAkC;mBAFnC,0CAA0C;0BAMnC,yBAAyB;2BAGxB,iBAAiB;+BAbb,gDAAgD"}

package/src/engine/graphics/texture/atlas/TextureAtlas.js

@@ -359,7 +359,10 @@ export class TextureAtlas extends AbstractTextureAtlas {
             const patch = patches[i];
 
             if (patch.getFlag(AtlasPatchFlag.Packed)) {
-                patch.clearFlag(AtlasPatchFlag.Packed | AtlasPatchFlag.Packed);
+                // repacking moves patches, so whatever is painted at the old
+                // position is stale -- clearing Painted is what schedules the
+                // repaint at the new one
+                patch.clearFlag(AtlasPatchFlag.Packed | AtlasPatchFlag.Painted);
 
                 this.packer.remove(patch.packing);
             }

package/src/engine/graphics/texture/atlas/gpu/WebGLTextureAtlas.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"WebGLTextureAtlas.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/texture/atlas/gpu/WebGLTextureAtlas.js"],"names":[],"mappings":"AAeA;IACI;;;;;;;;OAgEC;IAvDG;;;;OAIG;IACH,kBAAmB;IAEnB;;;;OAIG;IACH,kBAAmB;IAEnB;;;;OAIG;IACH,cAAyB;IAEzB;;;;OAIG;IACH,gBAAgB;IAEhB;;;;OAIG;IACH,iBAAiB;IAEjB;;;;OAIG;IACH,qBAAqB;IAErB;;;;OAIG;IACH,mBAAuB;IAEvB;;;;OAIG;IACH,kBAAsK;IAG1K;;;;;;;;;OASG;IACH,+BAPW,MAAM,YACN,MAAM,gBACN,MAAM,iBACN,MAAM,gBACN,MAAM,iBACN,MAAM,cAiBhB;IAED,eAqCC;IAED;;;;OAIG;IACH,qCA0BC;CACJ;2BAvK0B,kBAAkB"}
+{"version":3,"file":"WebGLTextureAtlas.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/texture/atlas/gpu/WebGLTextureAtlas.js"],"names":[],"mappings":"AAeA;IACI;;;;;;;;OAgEC;IAvDG;;;;OAIG;IACH,kBAAmB;IAEnB;;;;OAIG;IACH,kBAAmB;IAEnB;;;;OAIG;IACH,cAAyB;IAEzB;;;;OAIG;IACH,gBAAgB;IAEhB;;;;OAIG;IACH,iBAAiB;IAEjB;;;;OAIG;IACH,qBAAqB;IAErB;;;;OAIG;IACH,mBAAuB;IAEvB;;;;OAIG;IACH,kBAAsK;IAG1K;;;;;;;;;OASG;IACH,+BAPW,MAAM,YACN,MAAM,gBACN,MAAM,iBACN,MAAM,gBACN,MAAM,iBACN,MAAM,cAuBhB;IAED,eA0CC;IAED;;;;OAIG;IACH,qCA0BC;CACJ;2BAlL0B,kBAAkB"}

package/src/engine/graphics/texture/atlas/gpu/WebGLTextureAtlas.js

@@ -96,6 +96,12 @@ export class WebGLTextureAtlas {
         const patch = new AtlasPatch();
         patch.id = id;
 
+        // layout() packs `patch.packing`, so the target dimensions have to be
+        // recorded here or every patch is a zero-sized rectangle at the origin
+        // and they all pack on top of one another
+        patch.size.set(target_width, target_height);
+        patch.packing.set(0, 0, target_width, target_height);
+
         this.__patches.push(patch);
         this.__sources[id] = source;
 
@@ -143,6 +149,11 @@ export class WebGLTextureAtlas {
             const patch = this.__patches[i];
 
             patch.packing.copy(aabb);
+
+            // build() paints through patch.position, so the packed origin has
+            // to land there too -- otherwise every patch is copied to (0,0)
+            // no matter where the packer placed it
+            patch.position.set(aabb.x0, aabb.y0);
         });
     }
 

package/src/engine/graphics/texture/cubemap/load_environment_map.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"load_environment_map.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/texture/cubemap/load_environment_map.js"],"names":[],"mappings":"AA8EA;;;;;;;GAOG;AACH,6EANW,MAAM,GAAC,MAAM,EAAE,GAIb;IAAC,QAAQ,CAAC,EAAC,MAAM,WAAW,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,WAAW,CAAA;CAAC,CA8EvE"}
+{"version":3,"file":"load_environment_map.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/texture/cubemap/load_environment_map.js"],"names":[],"mappings":"AAiFA;;;;;;;GAOG;AACH,6EANW,MAAM,GAAC,MAAM,EAAE,GAIb;IAAC,QAAQ,CAAC,EAAC,MAAM,WAAW,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,WAAW,CAAA;CAAC,CA8EvE"}

package/src/engine/graphics/texture/cubemap/load_environment_map.js

@@ -1,4 +1,4 @@
-import { CubeTextureLoader, LinearFilter, PMREMGenerator, sRGBEncoding, TextureLoader, UnsignedByteType } from "three";
+import { CubeTextureLoader, LinearFilter, PMREMGenerator, sRGBEncoding, TextureLoader } from "three";
 import { EXRLoader } from "three/examples/jsm/loaders/EXRLoader.js";
 import { HDRCubeTextureLoader } from "three/examples/jsm/loaders/HDRCubeTextureLoader.js";
 import { noop } from "../../../../core/function/noop.js";
@@ -53,8 +53,11 @@ function load_hdr_cube_texture(paths) {
  */
 function load_exr_texture(path) {
     return new Promise((resolve, reject) => {
+        // EXR is HDR data; EXRLoader only decodes into FloatType or HalfFloatType
+        // and defaults to HalfFloatType. Requesting UnsignedByteType left the
+        // decoder without an output buffer, so every .exr environment map failed
+        // to load. Match load_hdr_cube_texture and take the loader's default.
         new EXRLoader()
-            .setDataType(UnsignedByteType)
             .load(path, texture => {
                 resolve(texture);
             }, noop, reject);

package/src/engine/graphics/texture/sampler/Sampler2D.d.ts

@@ -299,9 +299,9 @@ export class Sampler2D {
      * @param {number} centerX
      * @param {number} centerY
      * @param {number} radius
-     * @param {function(x:number,y:number, sampler:Sampler2D)} visitor
+     * @param {(x: number, y: number, sampler: Sampler2D) => void} visitor
      */
-    traverseCircle(centerX: number, centerY: number, radius: number, visitor: any): void;
+    traverseCircle(centerX: number, centerY: number, radius: number, visitor: (x: number, y: number, sampler: Sampler2D) => void): void;
     /**
      *
      * @param {number} x

package/src/engine/graphics/texture/sampler/Sampler2D.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Sampler2D.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/texture/sampler/Sampler2D.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"Sampler2D.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/texture/sampler/Sampler2D.js"],"names":[],"mappings":"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"}

package/src/engine/graphics/texture/sampler/Sampler2D.js

@@ -748,7 +748,7 @@ export class Sampler2D {
      * @param {number} centerX
      * @param {number} centerY
      * @param {number} radius
-     * @param {function(x:number,y:number, sampler:Sampler2D)} visitor
+     * @param {(x: number, y: number, sampler: Sampler2D) => void} visitor
      */
     traverseCircle(centerX, centerY, radius, visitor) {
         let x, y;

package/src/engine/graphics/texture/sampler/distance/computeSignedDistanceField_Chamfer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"computeSignedDistanceField_Chamfer.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/texture/sampler/distance/computeSignedDistanceField_Chamfer.js"],"names":[],"mappings":"AAGA;;;;;;;;GAQG;AACH,4GALW,MAAM,MACN,MAAM,MACN,MAAM,mBAkIhB"}
+{"version":3,"file":"computeSignedDistanceField_Chamfer.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/texture/sampler/distance/computeSignedDistanceField_Chamfer.js"],"names":[],"mappings":"AAGA;;;;;;;;GAQG;AACH,4GALW,MAAM,MACN,MAAM,MACN,MAAM,mBA0IhB"}

package/src/engine/graphics/texture/sampler/distance/computeSignedDistanceField_Chamfer.js

@@ -69,62 +69,70 @@ export function computeSignedDistanceField_Chamfer(source, distanceField, emptyV
     for (y = 0; y < height; y++) {
         for (x = 0; x < width; x++) {
 
-            const v = getD(x, y);
+            // each candidate must be compared against the running minimum, not
+            // against the value the cell started with -- otherwise the *last*
+            // candidate that beat the original wins instead of the smallest.
+            // Accumulating and writing once is also fewer stores than before.
+            let best = getD(x, y);
 
             const v0 = getD(x - 1, y - 1) + d2;
 
-            if (v0 < v) {
-                setD(x, y, v0);
+            if (v0 < best) {
+                best = v0;
             }
 
             const v1 = getD(x, y - 1) + d1;
 
-            if (v1 < v) {
-                setD(x, y, v1);
+            if (v1 < best) {
+                best = v1;
             }
 
             const v2 = getD(x + 1, y - 1) + d2;
 
-            if (v2 < v) {
-                setD(x, y, v2);
+            if (v2 < best) {
+                best = v2;
             }
 
             const v3 = getD(x - 1, y) + d1;
 
-            if (v3 < v) {
-                setD(x, y, v3);
+            if (v3 < best) {
+                best = v3;
             }
+
+            setD(x, y, best);
         }
     }
 
     //second pass (backward)
     for (y = maxY; y >= 0; y--) {
         for (x = maxX; x >= 0; x--) {
-            const v = getD(x, y);
+            let best = getD(x, y);
 
             const v0 = getD(x + 1, y) + d1;
 
-            if (v0 < v) {
-                setD(x, y, v0);
+            if (v0 < best) {
+                best = v0;
             }
 
             const v1 = getD(x - 1, y + 1) + d2;
 
-            if (v1 < v) {
-                setD(x, y, v1);
+            if (v1 < best) {
+                best = v1;
             }
 
             const v2 = getD(x, y + 1) + d1;
 
-            if (v2 < v) {
-                setD(x, y, v2);
+            if (v2 < best) {
+                best = v2;
             }
 
             const v3 = getD(x + 1, y + 1) + d2;
 
-            if (v3 < v) {
-                setD(x, y, v3);
+            if (v3 < best) {
+                best = v3;
             }
+
+            setD(x, y, best);
         }
     }
 

package/src/engine/graphics/texture/sampler/filter/sampler2d_blur_gaussian.d.ts

@@ -1,9 +1,22 @@
 /**
+ * Separable gaussian blur.
+ *
+ * `size` is the full footprint width in pixels: every output pixel is gathered
+ * from `[-size/2, +size/2]` around itself along each axis, at `sample_count`
+ * evenly spaced taps. `quality` scales the tap count, trading cost against
+ * sampling density; it leaves both the footprint and the standard deviation in
+ * pixels unchanged.
+ *
+ * Below `quality = 1` the taps are spaced more than a pixel apart, so detail
+ * finer than that spacing aliases — an isolated bright pixel gets smeared into
+ * a ring of tap-spaced echoes rather than a smooth falloff. On smooth input the
+ * result is indistinguishable from the fully sampled filter, which is what the
+ * setting is for; do not turn it down on input with isolated highlights.
  *
  * @param {Sampler2D} output
  * @param {Sampler2D} input
- * @param {number} size
- * @param {number} [quality]
+ * @param {number} size footprint width, in pixels
+ * @param {number} [quality] taps per pixel of footprint; 1 gives roughly one tap per pixel
  */
 export function sampler2d_blur_gaussian(output: Sampler2D, input: Sampler2D, size: number, quality?: number): void;
 import { Sampler2D } from "../Sampler2D.js";

package/src/engine/graphics/texture/sampler/filter/sampler2d_blur_gaussian.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sampler2d_blur_gaussian.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/texture/sampler/filter/sampler2d_blur_gaussian.js"],"names":[],"mappings":"AAQA;;;;;;GAMG;AACH,gDALW,SAAS,SACT,SAAS,QACT,MAAM,YACN,MAAM,QAoFhB;0BA9FyB,iBAAiB"}
+{"version":3,"file":"sampler2d_blur_gaussian.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/texture/sampler/filter/sampler2d_blur_gaussian.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,gDALW,SAAS,SACT,SAAS,QACT,MAAM,YACN,MAAM,QAiGhB;0BAxHyB,iBAAiB"}