@woosh/meep-engine 2.168.0 → 2.169.0

package/src/engine/graphics/load_and_set_cubemap_v0.js

@@ -1,21 +1,26 @@
-import { buildCubeURLs } from "./texture/cubemap/buildCubeURLs.js";
-import { load_environment_map } from "./texture/cubemap/load_environment_map.js";
-
-/**
- *
- * @param {GraphicsEngine} graphics
- * @param {string} folder_path
- * @param {string} file_extension
- */
-export async function load_and_set_cubemap_v0(graphics, folder_path, file_extension) {
-    const paths = buildCubeURLs(folder_path, file_extension);
-
-    const { filtered } = await load_environment_map({
-        path: paths,
-        renderer: graphics.renderer,
-        original: false,
-        filtered: true
-    });
-
-    graphics.scene.environment = filtered;
-}
+import { EnvironmentTextureProjection } from "./texture/EnvironmentTextureProjection.js";
+import { buildCubeURLs } from "./texture/cubemap/buildCubeURLs.js";
+import { load_environment_map } from "./texture/cubemap/load_environment_map.js";
+
+/**
+ * Loads a piece-wise cubemap and installs it as the scene's image-based-lighting source.
+ *
+ * The prefiltering (PMREM) is performed by the graphics engine rather than the loader, so that the
+ * engine keeps hold of the source texture and can repeat the bake - the prefiltered result lives in a
+ * render target and does not survive a WebGL context loss.
+ *
+ * @param {GraphicsEngine} graphics
+ * @param {string} folder_path
+ * @param {string} file_extension
+ */
+export async function load_and_set_cubemap_v0(graphics, folder_path, file_extension) {
+    const paths = buildCubeURLs(folder_path, file_extension);
+
+    const { original } = await load_environment_map({
+        path: paths,
+        original: true,
+        filtered: false
+    });
+
+    graphics.set_environment_map(original, EnvironmentTextureProjection.Cube);
+}

package/src/engine/graphics/particles/particular/group/ParticleGroup.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ParticleGroup.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/particles/particular/group/ParticleGroup.js"],"names":[],"mappings":"AAoBA;IACI;;;;;OAKG;IACH,qDAHW,OAAO,EA8CjB;IA1CG,mBAA0B;IAC1B;;;OAGG;IACH,4BAAgB;IAEhB,kBAAoB;IAEpB;;;OAGG;IACH,cAAuC;IAEvC;;;OAGG;IACH,UAAa;IAEb;;;OAGG;IACH,cAAmB;IAEnB,mBAAqB;IACrB,qBAAuB;IAEvB,oCAAqC;IACrC,4BAA8B;IAE9B;;;OAGG;IACH,cAFU,MAAO,SAAS,CAAC,CAEL;IAEtB,sBAAiC;IAKrC;;;;;OAKG;IACH,+BAJW,YAAY,GAAC,YAAY,GAAC,WAAW,GAAC,WAAW,GAAC,UAAU,GAAC,UAAU,GAAC,UAAU,GAAC,SAAS,kBAE1F,wBAAwB,GAAC,eAAe,CAQpD;IAED;;;OAGG;IACH,oBAFa,uBAAuB,GAAC,cAAc,CAUlD;IAED,cAmCC;IAED;;OAEG;IACH,gCAcC;IAED,cASC;IAED;;;OAGG;IACH,UAFa,OAAO,CAanB;IAED,6BAEC;IAED;;;OAGG;IACH,mBAFW,MAAM,QAMhB;IAED;;;OAGG;IACH,UAFa,MAAM,CASlB;IAED;;OAEG;IACH,6BAEC;IAED;;;OAGG;IACH,kCAEC;IAED,uCAIC;IAED;;;;;OAKG;IACH,2DAFW,MAAO,MAAM,CAAC,QAIxB;IAED;;;;;OAKG;IACH,4BAJW,MAAM,kBACN,MAAM,UACN,QAAM,YAAY,GAAC,YAAY,GAAC,UAAU,QAapD;IAED,sEAKC;IAED;;;;OAIG;IACH,wBAHW,MAAM,GACJ,MAAM,CAIlB;IAED,0BAKC;IAED,2CAaC;IAED,8CAkBC;IAED;;;;;OAKG;IACH,2EAFW,MAAM,EAAE,QAclB;IAED;;;;;OAKG;IACH,kFAFW,MAAM,QAahB;IAED;;;;;;;OAOG;IACH,0GAiBC;IAED;;;;;;;;OAQG;IACH,kHAkBC;IAED;;;OAGG;IACH,4BAFW,SAAS,QA+BnB;IAED;;;OAGG;IACH,uBAFW,UAAW,QAgFrB;IAED;;;;OAIG;IACH,4BAHW,MAAM,UACN,MAAM,QAiChB;IAED;;;;OAIG;IACH,aAHW,MAAM,UACN,MAAM,QAahB;IAED;;;OAGG;IACH,0BAKC;IAED,kCAMC;IAED,mCAaC;IAED;;;OAGG;IACH,4BAIC;CACJ;0BA1mByB,gBAAgB;mBAHvB,+BAA+B;yCAD3C,OAAO;gCAAP,OAAO;wCAAP,OAAO;+BAAP,OAAO"}
+{"version":3,"file":"ParticleGroup.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/particles/particular/group/ParticleGroup.js"],"names":[],"mappings":"AAoBA;IACI;;;;;OAKG;IACH,qDAHW,OAAO,EA8CjB;IA1CG,mBAA0B;IAC1B;;;OAGG;IACH,4BAAgB;IAEhB,kBAAoB;IAEpB;;;OAGG;IACH,cAAuC;IAEvC;;;OAGG;IACH,UAAa;IAEb;;;OAGG;IACH,cAAmB;IAEnB,mBAAqB;IACrB,qBAAuB;IAEvB,oCAAqC;IACrC,4BAA8B;IAE9B;;;OAGG;IACH,cAFU,MAAO,SAAS,CAAC,CAEL;IAEtB,sBAAiC;IAKrC;;;;;OAKG;IACH,+BAJW,YAAY,GAAC,YAAY,GAAC,WAAW,GAAC,WAAW,GAAC,UAAU,GAAC,UAAU,GAAC,UAAU,GAAC,SAAS,kBAE1F,wBAAwB,GAAC,eAAe,CAQpD;IAED;;;OAGG;IACH,oBAFa,uBAAuB,GAAC,cAAc,CAUlD;IAED,cAmCC;IAED;;OAEG;IACH,gCAcC;IAED,cASC;IAED;;;OAGG;IACH,UAFa,OAAO,CAanB;IAED,6BAEC;IAED;;;OAGG;IACH,mBAFW,MAAM,QAMhB;IAED;;;OAGG;IACH,UAFa,MAAM,CASlB;IAED;;OAEG;IACH,6BAEC;IAED;;;OAGG;IACH,kCAEC;IAED,uCAIC;IAED;;;;;OAKG;IACH,2DAFW,MAAO,MAAM,CAAC,QAIxB;IAED;;;;;OAKG;IACH,4BAJW,MAAM,kBACN,MAAM,UACN,QAAM,YAAY,GAAC,YAAY,GAAC,UAAU,QAapD;IAED,sEAKC;IAED;;;;OAIG;IACH,wBAHW,MAAM,GACJ,MAAM,CAIlB;IAED,0BAKC;IAED,2CAaC;IAED,8CAkBC;IAED;;;;;OAKG;IACH,2EAFW,MAAM,EAAE,QAclB;IAED;;;;;OAKG;IACH,kFAFW,MAAM,QAahB;IAED;;;;;;;OAOG;IACH,0GAiBC;IAED;;;;;;;;OAQG;IACH,kHAkBC;IAED;;;OAGG;IACH,4BAFW,SAAS,QA+BnB;IAED;;;OAGG;IACH,uBAFW,UAAW,QA2FrB;IAED;;;;OAIG;IACH,4BAHW,MAAM,UACN,MAAM,QAiChB;IAED;;;;OAIG;IACH,aAHW,MAAM,UACN,MAAM,QAahB;IAED;;;OAGG;IACH,0BAKC;IAED,kCAMC;IAED,mCAaC;IAED;;;OAGG;IACH,4BAIC;CACJ;0BArnByB,gBAAgB;mBAHvB,+BAA+B;yCAD3C,OAAO;gCAAP,OAAO;wCAAP,OAAO;+BAAP,OAAO"}

package/src/engine/graphics/particles/particular/group/ParticleGroup.js

@@ -471,24 +471,35 @@ export class ParticleGroup {
 
         let numSwapElements = 0;
         const swaps = [];
-        let swapDestination = this.size - 1;
 
         let i, j;
 
-        for (i = deleteCount - 1; i >= 0; i--) {
+        //Compaction: every hole below the new size is backfilled with a live
+        //element taken from the tail block that is about to be discarded. Each
+        //backfill must consume a *different* source -- reusing one duplicates
+        //that particle into several slots and silently drops the others.
+        let source = oldSize - 1;
+        let tailVictim = deleteCount - 1;
+
+        for (i = 0; i < deleteCount; i++) {
             const victim = indices[i];
 
-            if (swapDestination === victim) {
-                swapDestination--;
+            if (victim >= newSize) {
+                //indices ascend, so this and everything after it already sits
+                //inside the discarded tail and needs no backfill
+                break;
             }
 
-            if (victim >= newSize) {
-                //is beyond the end of the new array and will be removed anyway, no need to swap
-                continue;
+            //a tail slot that is itself being deleted is not a live source
+            while (tailVictim >= 0 && indices[tailVictim] === source) {
+                tailVictim--;
+                source--;
             }
 
-            swaps.push(victim, swapDestination);
+            swaps.push(victim, source);
             numSwapElements += 2;
+
+            source--;
         }
 
 

package/src/engine/graphics/particles/particular/group/optimizeCommandQueue.js

@@ -140,7 +140,7 @@ export function optimizeCommandQueue(queue) {
             //it's important that Add and Remove operations are sorted to the front of the queue, before Write operations
             if (operatorA < operatorB) {
                 return -1;
-            } else if (operatorB > operatorA) {
+            } else if (operatorA > operatorB) {
                 return 1;
             }
 

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/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"}

package/src/engine/graphics/texture/sampler/filter/sampler2d_blur_gaussian.js

@@ -7,17 +7,43 @@ import { Sampler2D } from "../Sampler2D.js";
 let temp_data = new Float64Array(1);
 
 /**
+ * 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, input, size, quality = 1) {
 
-    const sigma = size * 3;
     const sample_count = max2(3, nextOdd(Math.round(size * quality)));
 
+    // `build_gaussian_kernel_1d` places taps one unit apart, so its sigma is in
+    // TAP units, whereas the footprint is in pixels -- the two are related by
+    // `local_u_scale` below. Working in tap units, the outermost tap sits at
+    // (sample_count - 1) / 2, and we want the kernel truncated there at three
+    // standard deviations: beyond 3 sigma a gaussian carries ~0.3% of its mass,
+    // so cutting it there is visually lossless while keeping the taps busy.
+    //
+    // This previously read `size * 3`, which is the same expression with the
+    // ratio inverted and the wrong unit. That put every tap inside ±(1/6) of a
+    // standard deviation, where a gaussian is flat: the outermost tap carried
+    // ~99% of the weight of the centre one, so the filter was a box blur and
+    // `size` had no influence on the shape of the falloff at all.
+    const sigma = (sample_count - 1) / 6;
+
     const kernel = new Float32Array(sample_count);
 
     build_gaussian_kernel_1d(kernel, sample_count, sigma);

package/src/engine/graphics/texture/sampler/resize/sampler2d_scale_down_lanczos.d.ts

@@ -1,5 +1,15 @@
 /**
- * Good for down-sampling
+ * Good for down-sampling.
+ *
+ * The kernel is separable and evaluated in destination-pixel units: a source
+ * texel's distance from the destination pixel's centre is divided by the
+ * scaling ratio, which is what stretches the filter's support to cover the
+ * whole footprint being averaged.
+ *
+ * Negative lobes are kept. They are the entire point of Lanczos -- discarding
+ * them removes the sharpening and, when every sample in the footprint happens
+ * to land in a negative lobe, leaves a zero weight sum and a NaN result.
+ *
  * @param {Sampler2D} source
  * @param {Sampler2D} destination
  * @param {number} [lobes]

package/src/engine/graphics/texture/sampler/resize/sampler2d_scale_down_lanczos.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sampler2d_scale_down_lanczos.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/texture/sampler/resize/sampler2d_scale_down_lanczos.js"],"names":[],"mappings":"AAkEA;;;;;GAKG;AACH,gGAFW,MAAM,QAoGhB"}
+{"version":3,"file":"sampler2d_scale_down_lanczos.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/graphics/texture/sampler/resize/sampler2d_scale_down_lanczos.js"],"names":[],"mappings":"AAiCA;;;;;;;;;;;;;;;GAeG;AACH,gGAFW,MAAM,QA8GhB"}