@woosh/meep-engine 2.133.3 → 2.133.5

package/package.json

@@ -5,7 +5,7 @@
   "description": "Pure JavaScript game engine. Fully featured and production ready.",
   "type": "module",
   "author": "Alexander Goldring",
-  "version": "2.133.3",
+  "version": "2.133.5",
   "main": "build/meep.module.js",
   "module": "build/meep.module.js",
   "exports": {
@@ -89,6 +89,6 @@
     "typescript"
   ],
   "engines": {
-    "node": ">=14"
+    "node": ">=24"
   }
 }

package/src/core/binary/BitSet.d.ts

@@ -183,6 +183,12 @@ export class BitSet {
      * Sets all the bits in this BitSet to false.
      */
     reset(): void;
+    /**
+     * Number of set bits in this BitSet.
+     * Also known as "Hamming weight" or "population count".
+     * @returns {number}
+     */
+    cardinality(): number;
     /**
      * Copy contents of another bit set into this one
      * @param {BitSet} other

package/src/core/binary/BitSet.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"BitSet.d.ts","sourceRoot":"","sources":["../../../../src/core/binary/BitSet.js"],"names":[],"mappings":"AAgCA;;;;;;;;;;;;;;GAcG;AACH;IAkjBI;;;;OAIG;IACH,oBAHW,MAAM,GACJ,MAAM,CAQlB;IA3jBD;;;OAGG;IACH,+BAFW,MAAM,EAgChB;IA3BG;;;;OAIG;IACH,iBAAiB;IAEjB;;;;;OAKG;IACH,mBAA4C;IAE5C;;;;OAIG;IACH,sBAA0D;IAE1D;;;OAGG;IACH,gBAFU,MAAM,CAE2B;IAG/C;;;;OAIG;IACH,iBAFa,IAAI,CAIhB;IAED;;;OAGG;IACH,mBAFW,MAAM,QAOhB;IACD;;;;;;OAMG;IACH,uBAJW,MAAM,GAEJ,IAAI,CAUhB;IAED;;;;OAIG;IACH,QAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,YAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,iBAsBC;IAED;;;OAGG;IACH,uBAMC;IAED;;;;;OAKG;IACH,oBAyBC;IAED;;;;OAIG;IACH,2BAHW,MAAM,GACJ,MAAM,CAuClB;IAED;;;;OAIG;IACH,uBAHW,MAAM,GACJ,MAAM,CAuDlB;IAED;;;;OAIG;IACH,yBAHW,MAAM,GACJ,MAAM,CAkDlB;IAED;;;;;OAKG;IACH,eAJW,MAAM,SACN,OAAO,GACL,IAAI,CAmChB;IAED;;;OAGG;IACH,iBAFW,MAAM,QAIhB;IAED;;;;OAIG;IACH,sBAHW,MAAM,aACN,MAAM,QAWhB;IAED;;;;OAIG;IACH,wBAHW,MAAM,aACN,MAAM,QAShB;IAED;;;;OAIG;IACH,qBAFa,OAAO,CAkBnB;IAED;;;;OAIG;IACH,iBAHW,MAAM,GACJ,OAAO,CAUnB;IAED;;;;OAIG;IACH,mBAHW,MAAM,GACJ,OAAO,CAUnB;IAED;;;;;OAKG;IACH,sBAJW,MAAM,eACN,MAAM,aACN,MAAM,QAShB;IAED;;;;;OAKG;IACH,qBAJW,MAAM,eACN,MAAM,aACN,MAAM,QAShB;IAED;;;;;OAKG;IACH,gBAJW,MAAM,eACN,MAAM,aACN,MAAM,QAQhB;IAED;;OAEG;IACH,cAgBC;IAED;;;OAGG;IACH,YAFW,MAAM,QAoChB;CAcJ"}
+{"version":3,"file":"BitSet.d.ts","sourceRoot":"","sources":["../../../../src/core/binary/BitSet.js"],"names":[],"mappings":"AAiCA;;;;;;;;;;;;;;GAcG;AACH;IAslBI;;;;OAIG;IACH,oBAHW,MAAM,GACJ,MAAM,CAQlB;IA/lBD;;;OAGG;IACH,+BAFW,MAAM,EAgChB;IA3BG;;;;OAIG;IACH,iBAAiB;IAEjB;;;;;OAKG;IACH,mBAA4C;IAE5C;;;;OAIG;IACH,sBAA0D;IAE1D;;;OAGG;IACH,gBAFU,MAAM,CAE2B;IAG/C;;;;OAIG;IACH,iBAFa,IAAI,CAIhB;IAED;;;OAGG;IACH,mBAFW,MAAM,QAOhB;IACD;;;;;;OAMG;IACH,uBAJW,MAAM,GAEJ,IAAI,CAUhB;IAED;;;;OAIG;IACH,QAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,YAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,iBAsBC;IAED;;;OAGG;IACH,uBAMC;IAED;;;;;OAKG;IACH,oBAyBC;IAED;;;;OAIG;IACH,2BAHW,MAAM,GACJ,MAAM,CAuClB;IAED;;;;OAIG;IACH,uBAHW,MAAM,GACJ,MAAM,CAuDlB;IAED;;;;OAIG;IACH,yBAHW,MAAM,GACJ,MAAM,CAkDlB;IAED;;;;;OAKG;IACH,eAJW,MAAM,SACN,OAAO,GACL,IAAI,CAmChB;IAED;;;OAGG;IACH,iBAFW,MAAM,QAIhB;IAED;;;;OAIG;IACH,sBAHW,MAAM,aACN,MAAM,QAWhB;IAED;;;;OAIG;IACH,wBAHW,MAAM,aACN,MAAM,QAShB;IAED;;;;OAIG;IACH,qBAFa,OAAO,CAkBnB;IAED;;;;OAIG;IACH,iBAHW,MAAM,GACJ,OAAO,CAUnB;IAED;;;;OAIG;IACH,mBAHW,MAAM,GACJ,OAAO,CAUnB;IAED;;;;;OAKG;IACH,sBAJW,MAAM,eACN,MAAM,aACN,MAAM,QAShB;IAED;;;;;OAKG;IACH,qBAJW,MAAM,eACN,MAAM,aACN,MAAM,QAShB;IAED;;;;;OAKG;IACH,gBAJW,MAAM,eACN,MAAM,aACN,MAAM,QAQhB;IAED;;OAEG;IACH,cAgBC;IAED;;;;OAIG;IACH,eAFa,MAAM,CA+BlB;IAED;;;OAGG;IACH,YAFW,MAAM,QAoChB;CAcJ"}

package/src/core/binary/BitSet.js

@@ -3,6 +3,7 @@ import { max3 } from "../math/max3.js";
 import { min2 } from "../math/min2.js";
 import { align_32 } from "./align_32.js";
 import { lsb_32 } from "./lsb_32.js";
+import { bitCount } from "./operations/bitCount.js";
 
 /**
  * Used for overallocating space when bit set needs to grow
@@ -567,6 +568,42 @@ export class BitSet {
         this.__length = 0;
     }
 
+    /**
+     * Number of set bits in this BitSet.
+     * Also known as "Hamming weight" or "population count".
+     * @returns {number}
+     */
+    cardinality(){
+        const length = this.__length;
+
+        if (length === 0) {
+            return 0;
+        }
+
+        const data = this.__data_uint32;
+        let count = 0;
+
+        // Number of fully utilized 32-bit words
+        const full_words = length >> 5;
+
+        // Count bits in all complete words
+        for (let i = 0; i < full_words; i++) {
+            count += bitCount(data[i]);
+        }
+
+        // Handle any remaining bits in the partial last word
+        const remainder_bits = length & 31;
+
+        if (remainder_bits > 0) {
+            // Create a mask to ignore any bits beyond __length
+            // e.g., if remainder is 3, mask is (1<<3)-1 = 7 (0b111)
+            const mask = (1 << remainder_bits) - 1;
+            count += bitCount(data[full_words] & mask);
+        }
+
+        return count;
+    }
+
     /**
      * Copy contents of another bit set into this one
      * @param {BitSet} other
@@ -619,4 +656,4 @@ export class BitSet {
 
         return r;
     }
-}
+}

package/src/core/binary/operations/bitCount.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bitCount.d.ts","sourceRoot":"","sources":["../../../../../src/core/binary/operations/bitCount.js"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,4BAHW,MAAM,GACJ,MAAM,CAalB"}
+{"version":3,"file":"bitCount.d.ts","sourceRoot":"","sources":["../../../../../src/core/binary/operations/bitCount.js"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,4BAHW,MAAM,GACJ,MAAM,CAkBlB"}

package/src/core/binary/operations/bitCount.js

@@ -7,11 +7,16 @@ export function bitCount(v) {
     // see https://stackoverflow.com/a/109025/3973586
     // see https://graphics.stanford.edu/%7Eseander/bithacks.html#CountBitsSetParallel
 
-    let i = v|0;
 
-    i = i - ((i >> 1) & 0x55555555);        // add pairs of bits
-    i = (i & 0x33333333) + ((i >> 2) & 0x33333333);  // quads
-    i = (i + (i >> 4)) & 0x0F0F0F0F;        // groups of 8
-    i *= 0x01010101;                        // horizontal sum of bytes
-    return  i >> 24;               // return just that top byte (after truncating to 32-bit even when int is wider than uint32_t)
+    // Force to a 32-bit unsigned integer
+    let i = v >>> 0;
+
+    i = i - ((i >>> 1) & 0x55555555);               // Add pairs of bits
+    i = (i & 0x33333333) + ((i >>> 2) & 0x33333333); // Quads
+    i = (i + (i >>> 4)) & 0x0F0F0F0F;               // Groups of 8
+
+    // horizontal sum of bytes
+    // return just that top byte (after truncating to 32-bit even when int is wider than uint32_t)
+    // Math.imul perfectly simulates C's 32-bit integer multiplication overflow
+    return (Math.imul(i, 0x01010101) >>> 24);
 }

package/src/core/geom/3d/aabb/AABB3.d.ts

@@ -215,10 +215,16 @@ export class AABB3 {
      * @returns {boolean}
      */
     _expandToFitPoint(x: number, y: number, z: number): boolean;
+    /**
+     *
+     * @param {AABB3} other
+     */
+    union(other: AABB3): void;
     /**
      *
      * @param {AABB3} box
      * @returns {boolean}
+     * @deprecated use {@link AABB3#union} instead
      */
     expandToFit(box: AABB3): boolean;
     /**
@@ -323,7 +329,7 @@ export class AABB3 {
     intersectRay(oX: any, oY: any, oZ: any, dX: any, dY: any, dZ: any): boolean;
     intersectSegment(startX: any, startY: any, startZ: any, endX: any, endY: any, endZ: any): boolean;
     /**
-     *
+     * @deprecated use {@link AABB3#_containsBox} instead
      * @param {THREE.Box} box
      * @returns {boolean}
      */

package/src/core/geom/3d/aabb/AABB3.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AABB3.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/aabb/AABB3.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"AABB3.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/aabb/AABB3.js"],"names":[],"mappings":"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"}

package/src/core/geom/3d/aabb/AABB3.js

@@ -491,10 +491,19 @@ export class AABB3 {
         return expanded;
     }
 
+    /**
+     *
+     * @param {AABB3} other
+     */
+    union(other) {
+        this._expandToFit(other.x0, other.y0, other.z0, other.x1, other.y1, other.z1);
+    }
+
     /**
      *
      * @param {AABB3} box
      * @returns {boolean}
+     * @deprecated use {@link AABB3#union} instead
      */
     expandToFit(box) {
         return this._expandToFit(box.x0, box.y0, box.z0, box.x1, box.y1, box.z1);
@@ -710,7 +719,7 @@ export class AABB3 {
     }
 
     /**
-     *
+     * @deprecated use {@link AABB3#_containsBox} instead
      * @param {THREE.Box} box
      * @returns {boolean}
      */
@@ -961,6 +970,10 @@ export class AABB3 {
      * @param {number} extra
      */
     grow(extra) {
+        assert.isNumber(extra, 'extra');
+        assert.notNaN(extra, 'extra');
+        assert.isFinite(extra, 'extra');
+
         this.x0 -= extra;
         this.y0 -= extra;
         this.z0 -= extra;

package/src/engine/ecs/terrain/ecs/Terrain.d.ts.map

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

package/src/engine/ecs/terrain/ecs/Terrain.js

@@ -586,7 +586,12 @@ class Terrain {
 
         uniforms.splatWeightMap.value = this.splat.weightTexture;
 
-        uniforms.splatLayerCount.value = this.layers.count();
+        // Update layer count as a compile-time define (AMD GLSL 300 ES requires constant loop bounds)
+        const layerCount = this.layers.count();
+        if (m.defines.SPLAT_LAYER_COUNT !== layerCount) {
+            m.defines.SPLAT_LAYER_COUNT = layerCount;
+            m.needsUpdate = true;
+        }
 
         uniforms.materialScalesMap.value = this.layers.scalesTexture;
 

package/src/engine/ecs/terrain/ecs/layers/TerrainLayer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TerrainLayer.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/ecs/terrain/ecs/layers/TerrainLayer.js"],"names":[],"mappings":"AA2BA;IA+CI;;;;;OAKG;IACH,iBAJW,MAAM,SACN,MAAM,UACN,MAAM,gBAShB;IAED;;;;OAIG;IACH,oDAFa,YAAY,CAQxB;IAvED;;;OAGG;IACH,0BAAuB;IAEvB;;;OAGG;IACH,SAFU,SAAS,CAEgB;IAEnC;;;OAGG;IACH,MAFU,OAAO,CAEQ;IAEzB;;;OAGG;IACH,WAAW;IAEX;;;OAGG;IACH,WAFU,MAAM,CAES;IAGzB;;;;;;;MAMC;IAED;;;;aAIC;IA8BD;;;;OAIG;IACH,0DAwDC;IAGL;;;OAGG;IACH,yBAFU,OAAO,CAEoB;CANpC;0BA9JyB,mDAAmD;oBAJzD,qCAAqC;mBADtC,6CAA6C"}
+{"version":3,"file":"TerrainLayer.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/ecs/terrain/ecs/layers/TerrainLayer.js"],"names":[],"mappings":"AA2BA;IA+CI;;;;;OAKG;IACH,iBAJW,MAAM,SACN,MAAM,UACN,MAAM,gBAShB;IAED;;;;OAIG;IACH,oDAFa,YAAY,CAQxB;IAvED;;;OAGG;IACH,0BAAuB;IAEvB;;;OAGG;IACH,SAFU,SAAS,CAEgB;IAEnC;;;OAGG;IACH,MAFU,OAAO,CAEQ;IAEzB;;;OAGG;IACH,WAAW;IAEX;;;OAGG;IACH,WAFU,MAAM,CAES;IAGzB;;;;;;;MAMC;IAED;;;;aAIC;IA8BD;;;;OAIG;IACH,0DAyDC;IAGL;;;OAGG;IACH,yBAFU,OAAO,CAEoB;CANpC;0BA/JyB,mDAAmD;oBAJzD,qCAAqC;mBADtC,6CAA6C"}

package/src/engine/ecs/terrain/ecs/layers/TerrainLayer.js

@@ -5,7 +5,7 @@ import { computeStringHash } from "../../../../../core/primitives/strings/comput
 import { string_compute_byte_size } from "../../../../../core/primitives/strings/string_compute_byte_size.js";
 import { GameAssetType } from "../../../../asset/GameAssetType.js";
 import { Sampler2D } from "../../../../graphics/texture/sampler/Sampler2D.js";
-import { sampler2d_transfer_data } from "../../../../graphics/texture/sampler/sampler2d_transfer_data.js";
+import { sampler2d_ensure_uint8_RGBA } from "../../../../graphics/texture/sampler/sampler2d_ensure_uint8_RGBA.js";
 
 /**
  *
@@ -37,7 +37,7 @@ export class TerrainLayer {
      *
      * @type {Sampler2D}
      */
-    diffuse = Sampler2D.uint8(3, 1, 1);
+    diffuse = Sampler2D.uint8(4, 1, 1);
 
     /**
      *
@@ -135,21 +135,22 @@ export class TerrainLayer {
             .then(assert => {
                 const image = assert.create();
 
+                const source_data = image.data;
                 const source_item_size = image.itemSize;
 
-                const source_data = image.data;
+                // RGBA (4 channels) for AMD GPU compatibility
+                const destination_item_size = 4;
+
+                const source = new Sampler2D(source_data, source_item_size, image.width, image.height);
 
-                // RGB
-                const destination_item_size = 3;
+                // Convert to uint8 RGBA, handling any source format
+                const rgba = sampler2d_ensure_uint8_RGBA(source);
 
                 if (this.diffuse === null || this.diffuse.width !== image.width || this.diffuse.height !== image.height) {
-                    // loaded image does not match the side of the layer
                     this.diffuse = Sampler2D.uint8(destination_item_size, image.width, image.height);
                 }
 
-                const source = new Sampler2D(source_data, source_item_size, image.width, image.height);
-
-                sampler2d_transfer_data(source, this.diffuse);
+                this.diffuse.data.set(rgba.data);
 
                 this.onChanged.send0();
 

package/src/engine/ecs/terrain/ecs/layers/TerrainLayers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TerrainLayers.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/ecs/terrain/ecs/layers/TerrainLayers.js"],"names":[],"mappings":"AA6EA;IAGQ;;;OAGG;IACH,QAFU,KAAK,YAAY,CAAC,CAEJ;IAExB;;;OAGG;IACH,YAFU,OAAO,CAEoD;IAMrE;;;OAGG;IACH,SAFU,kBAAkB,CAE8B;IAiB1D,2BAAsF;IAc1F;;;;;;MAKC;IAED;;;aAGC;IAED;;;;OAIG;IACH,gCAHW,MAAM,iBACN,MAAM,QAuChB;IAED;;;;OAIG;IACH,0DAyBC;IAED,sCAIC;IAED;;;;OAIG;IACH,WAHW,MAAM,GACL,YAAY,CAIvB;IAED;;;;OAIG;IACH,8DAFa,MAAM,CAqBlB;IAED;;;;OAIG;IACH,kCAHW,MAAM,GACJ,MAAM,CAMlB;IAED;;;OAGG;IACH,SAFY,MAAM,CAIjB;IAED;;;;OAIG;IACH,gBAHW,YAAY,GACV,MAAM,CAWlB;IAED;;;;OAIG;IACH,mBAHW,YAAY,GACX,OAAO,CAIlB;IAED;;;;;;OAMG;IACH,0CA8BC;IAED;;;OAGG;IACH,iCAFW,MAAM,QAgChB;IAED,gBAGC;IAED,cAEC;IAGD,qBAsCC;CACJ;iBA5ZgB,6CAA6C;6BAQjC,mBAAmB;oBAP5B,qCAAqC;mCALlD,OAAO;4BAAP,OAAO"}
+{"version":3,"file":"TerrainLayers.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/ecs/terrain/ecs/layers/TerrainLayers.js"],"names":[],"mappings":"AA8EA;IAGQ;;;OAGG;IACH,QAFU,KAAK,YAAY,CAAC,CAEJ;IAExB;;;OAGG;IACH,YAFU,OAAO,CAEoD;IAMrE;;;OAGG;IACH,SAFU,kBAAkB,CAE8B;IAiB1D,2BAAsF;IAc1F;;;;;;MAKC;IAED;;;aAGC;IAED;;;;OAIG;IACH,gCAHW,MAAM,iBACN,MAAM,QAuChB;IAED;;;;OAIG;IACH,0DAyBC;IAED,sCAIC;IAED;;;;OAIG;IACH,WAHW,MAAM,GACL,YAAY,CAIvB;IAED;;;;OAIG;IACH,8DAFa,MAAM,CAqBlB;IAED;;;;OAIG;IACH,kCAHW,MAAM,GACJ,MAAM,CAMlB;IAED;;;OAGG;IACH,SAFY,MAAM,CAIjB;IAED;;;;OAIG;IACH,gBAHW,YAAY,GACV,MAAM,CAWlB;IAED;;;;OAIG;IACH,mBAHW,YAAY,GACX,OAAO,CAIlB;IAED;;;;;;OAMG;IACH,0CAgCC;IAED;;;OAGG;IACH,iCAFW,MAAM,QAgChB;IAED,gBAGC;IAED,cAEC;IAGD,qBAsCC;CACJ;iBA9ZgB,6CAA6C;6BAQjC,mBAAmB;oBAP5B,qCAAqC;mCALlD,OAAO;4BAAP,OAAO"}

package/src/engine/ecs/terrain/ecs/layers/TerrainLayers.js

@@ -8,6 +8,7 @@ import {
     LinearMipMapLinearFilter,
     NearestFilter,
     RepeatWrapping,
+    RGBAFormat,
     RGFormat,
     UnsignedByteType
 } from "three";
@@ -19,9 +20,9 @@ import Vector2 from "../../../../../core/geom/Vector2.js";
 import { invokeObjectEquals } from "../../../../../core/model/object/invokeObjectEquals.js";
 import { invokeObjectHash } from "../../../../../core/model/object/invokeObjectHash.js";
 import { computeStringHash } from "../../../../../core/primitives/strings/computeStringHash.js";
-import { GL_RGBFormat } from "../../../../graphics/texture/GL_RGBFormat.js";
 import { sampler2d_scale } from "../../../../graphics/texture/sampler/resize/sampler2d_scale.js";
 import { Sampler2D } from "../../../../graphics/texture/sampler/Sampler2D.js";
+import { sampler2d_ensure_uint8_RGBA } from "../../../../graphics/texture/sampler/sampler2d_ensure_uint8_RGBA.js";
 import { TerrainLayer } from "./TerrainLayer.js";
 
 class ScaledTextureKey {
@@ -91,7 +92,7 @@ export class TerrainLayers {
         this.resolution = new Vector2(DEFAULT_RESOLUTION, DEFAULT_RESOLUTION);
 
 
-        const layer_data = new Uint8Array(3);
+        const layer_data = new Uint8Array(4);
         layer_data.fill(255); //pre-fill with white
 
         /**
@@ -99,7 +100,7 @@ export class TerrainLayers {
          * @type {DataTexture2DArray}
          */
         this.texture = new DataTexture2DArray(layer_data, 1, 1, 1);
-        this.texture.format = GL_RGBFormat;
+        this.texture.format = RGBAFormat;
         this.texture.type = UnsignedByteType;
 
         this.texture.wrapS = RepeatWrapping;
@@ -112,7 +113,7 @@ export class TerrainLayers {
 
         this.texture.generateMipmaps = true;
         this.texture.encoding = LinearEncoding;
-        this.texture.internalFormat = 'RGB8';
+        this.texture.internalFormat = 'RGBA8';
         this.texture.needsUpdate = true;
 
         this.scalesTexture = new DataTexture(new Float32Array(64), 32, 1, RGFormat, FloatType);
@@ -312,7 +313,7 @@ export class TerrainLayers {
     __obtain_layer_data_at_resolution(layer, resolution) {
         const layerSampler = layer.diffuse;
 
-        assert.equal(layerSampler.itemSize, 3, 'layer sampler must have 3 channels');
+        assert.equal(layerSampler.itemSize, 4, 'layer sampler must have 4 channels');
 
         const resolution_x = resolution.x;
         const resolution_y = resolution.y;
@@ -330,14 +331,16 @@ export class TerrainLayers {
                 return existing;
             }
 
-            const scaledLayerSampler = Sampler2D.uint8(3, resolution_x, resolution_y);
+            const scaledLayerSampler = Sampler2D.uint8(4, resolution_x, resolution_y);
 
             sampler2d_scale(layerSampler, scaledLayerSampler);
 
-            // write scaled texture into the cache
-            scaled_texture_cache.put(key, scaledLayerSampler);
+            // Ensure result is uint8 RGBA
+            const rgba = sampler2d_ensure_uint8_RGBA(scaledLayerSampler);
 
-            return scaledLayerSampler;
+            scaled_texture_cache.put(key, rgba);
+
+            return rgba;
         }
     }
 
@@ -359,7 +362,7 @@ export class TerrainLayers {
 
         const resolution = this.resolution;
 
-        const single_layer_byte_size = resolution.x * resolution.y * 3;
+        const single_layer_byte_size = resolution.x * resolution.y * 4;
 
         if (arrayData.length < single_layer_byte_size * index) {
             throw new Error('Texture data is too small, make sure you rebuild texture data before attempting to write');
@@ -411,7 +414,7 @@ export class TerrainLayers {
         texture.dispose();
 
         //build an array to hold texture array
-        const arrayData = new Uint8Array(size_x * size_y * 3 * layerCount);
+        const arrayData = new Uint8Array(size_x * size_y * 4 * layerCount);
         arrayData.fill(255); // fill with white
 
         if (image.width === size_x && image.height === size_y) {

package/src/engine/graphics/ecs/water/WaterSystem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"WaterSystem.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/ecs/water/WaterSystem.js"],"names":[],"mappings":";AAWA;IAyBI;;;;OAIG;IACH,sCAYC;IAzCD,+BAAuB;IAEvB;;;OAGG;IACH,cAFU,GAAG,CAEG;IAGhB,cAAY;IAEZ;;;OAGG;IACH,aAFU,KAAK,EAAE,CAEA;IAEjB;;;;OAIG;IACH,qBAAiB;IAWb,+BAA8B;IAE9B;;;OAGG;IACH,aAFU,cAAY,IAAI,CAEH;IAK3B,4CAMC;IAED,2CA0DC;IAED;;;;OAIG;IACH,gBAHW,KAAK,UACL,MAAM,QAsDhB;IAED;;;;OAIG;IACH,kBAHW,KAAK,UACL,MAAM,QAgBhB;IAED,2BAgCC;IAED;;;;;OAKG;IACH,0BAUC;IAED,6BAcC;CACJ;;;;uBA7QsB,wBAAwB;kBAM7B,YAAY;oBAPV,mCAAmC"}
+{"version":3,"file":"WaterSystem.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/graphics/ecs/water/WaterSystem.js"],"names":[],"mappings":";AAYA;IAyBI;;;;OAIG;IACH,sCAYC;IAzCD,+BAAuB;IAEvB;;;OAGG;IACH,cAFU,GAAG,CAEG;IAGhB,cAAY;IAEZ;;;OAGG;IACH,aAFU,KAAK,EAAE,CAEA;IAEjB;;;;OAIG;IACH,qBAAiB;IAWb,+BAA8B;IAE9B;;;OAGG;IACH,aAFU,cAAY,IAAI,CAEH;IAK3B,4CAMC;IAED,2CA4DC;IAED;;;;OAIG;IACH,gBAHW,KAAK,UACL,MAAM,QAsDhB;IAED;;;;OAIG;IACH,kBAHW,KAAK,UACL,MAAM,QAgBhB;IAED,2BAgCC;IAED;;;;;OAKG;IACH,0BAUC;IAED,6BAcC;CACJ;;;;uBA/QsB,wBAAwB;kBAM7B,YAAY;oBAPV,mCAAmC"}

package/src/engine/graphics/ecs/water/WaterSystem.js

@@ -1,4 +1,5 @@
 import { BackSide, PlaneBufferGeometry } from 'three';
+import { assert } from "../../../../core/assert.js";
 import { BVH } from "../../../../core/bvh2/bvh3/BVH.js";
 import { System } from '../../../ecs/System.js';
 import { obtainTerrain } from "../../../ecs/terrain/util/obtainTerrain.js";
@@ -76,6 +77,8 @@ class WaterSystem extends System {
             (destination, offset, entity, ecd) => {
                 const component = ecd.getComponent(entity, Water);
 
+                assert.defined(component, 'component');
+
                 const mesh = component.__threeObject;
 
                 if (mesh === null) {

package/src/engine/graphics/material/SplatMaterial.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SplatMaterial.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics/material/SplatMaterial.js"],"names":[],"mappings":"AAgBA;;;;;;;;GAQG;AACH,oFAPW,OAAO,GAIN,cAAc,CAkIzB;;IAxID;;;;;;;;OAQG;IACH,kEAPW,OAAO,EAsIjB;;wBA5IM,OAAO;+BAAP,OAAO"}
+{"version":3,"file":"SplatMaterial.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics/material/SplatMaterial.js"],"names":[],"mappings":"AAgBA;;;;;;;;GAQG;AACH,oFAPW,OAAO,GAIN,cAAc,CAgIzB;;IAtID;;;;;;;;OAQG;IACH,kEAPW,OAAO,EAoIjB;;wBA1IM,OAAO;+BAAP,OAAO"}

package/src/engine/graphics/material/SplatMaterial.js

@@ -47,10 +47,7 @@ export function SplatMaterial(
                 type: "t",
                 value: null
             },
-            "splatLayerCount": {
-                type: "f",
-                value: 4
-            },
+
             "splatResolution": {
                 type: 'v2',
                 value: new Vector2(1, 1)
@@ -115,6 +112,7 @@ export function SplatMaterial(
         transparent: false,
         lights: true,
         defines: {
+            SPLAT_LAYER_COUNT: 4,
             SHADOWMAP_CLOUDS: false,
             DIFFUSE_GRAIN: false
         },

package/src/engine/graphics/shaders/TerrainShader.js

@@ -95,7 +95,7 @@ function fragment() {
     precision highp sampler2DArray;
     
     uniform sampler2DArray splatWeightMap;
-    uniform int splatLayerCount;
+    // SPLAT_LAYER_COUNT is injected as a #define from the material defines
     
     uniform vec2 splatResolution;
    
@@ -240,14 +240,7 @@ function fragment() {
         return hsv2rgb(hsv);
     }
     
-    vec3 brighten2(const in vec3 color, in float factor, float p){
-        vec3 yiq = rgb2yiq*color;
-        
-        yiq.x *= p;
-        yiq.x = pow(yiq.x,factor);
-        
-        return yiq2rgb * yiq;
-    }
+
     
     vec4 computeGridOverlayTexel(const in vec2 grid_uv, const in vec2 grid_resolution){
         vec2 grid_texel = vGridPosition + 0.5;
@@ -276,7 +269,7 @@ function fragment() {
         float weightSum = 0.0;
         vec4 colorSum = vec4(0.0);
         
-        for( int i = 0; i < splatLayerCount; i++){
+        for( int i = 0; i < SPLAT_LAYER_COUNT; i++){
                
             vec2 scale = texelFetch(materialScalesMap, ivec2(i, 0), 0 ).xy;
             
@@ -290,7 +283,7 @@ function fragment() {
             colorSum += diffuseData*weight;
         }
         
-        return colorSum / weightSum;  
+        return weightSum > 0.0 ? colorSum / weightSum : vec4(0.0);  
     }
     
     ${ShaderChunks.clouds_pars_fragment}

package/src/engine/physics/gjk/gjk.d.ts

@@ -0,0 +1,16 @@
+/**
+ * GJK intersection test for two convex shapes.
+ *
+ * Determines whether two convex shapes overlap by iteratively building a simplex
+ * in the Minkowski difference space. If the origin is enclosed by the simplex,
+ * the shapes intersect.
+ *
+ * Adapted from https://github.com/kevinmoran/GJK/blob/master/GJK.h
+ *
+ * @param {number[]|Float32Array} simplex Working buffer for simplex vertices (4 vec3s). Must have length >= 12.
+ * @param {AbstractShape3D} shape_a
+ * @param {AbstractShape3D} shape_b
+ * @returns {boolean} true if the shapes intersect
+ */
+export function gjk(simplex: number[] | Float32Array, shape_a: AbstractShape3D, shape_b: AbstractShape3D): boolean;
+//# sourceMappingURL=gjk.d.ts.map

package/src/engine/physics/gjk/gjk.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gjk.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/gjk/gjk.js"],"names":[],"mappings":"AAmDA;;;;;;;;;;;;;GAaG;AACH,6BALW,MAAM,EAAE,GAAC,YAAY,uDAGnB,OAAO,CAkGnB"}

package/src/engine/physics/gjk/gjk.js

@@ -0,0 +1,378 @@
+import { v3_dot } from "../../../core/geom/vec3/v3_dot.js";
+import { v3_length } from "../../../core/geom/vec3/v3_length.js";
+
+const GJK_MAX_ITERATIONS = 64;
+
+/**
+ * Module-level scratch buffers to avoid per-call allocations.
+ */
+const scratch_support_a = new Float32Array(3);
+const scratch_support_b = new Float32Array(3);
+const scratch_dir = new Float32Array(3);
+
+/**
+ * Compute the Minkowski difference support point for two shapes.
+ * support(A-B, d) = support(A, d) - support(B, -d)
+ *
+ * The direction is normalized before being passed to the shape support
+ * functions, since {@link AbstractShape3D#support} assumes a unit vector.
+ *
+ * @param {number[]|Float32Array} result
+ * @param {number} result_offset
+ * @param {AbstractShape3D} shape_a
+ * @param {AbstractShape3D} shape_b
+ * @param {number} dir_x
+ * @param {number} dir_y
+ * @param {number} dir_z
+ */
+function minkowski_support(
+    result, result_offset,
+    shape_a,
+    shape_b,
+    dir_x, dir_y, dir_z
+) {
+    // Normalize direction — support() contract requires a unit vector
+    const len = v3_length(dir_x, dir_y, dir_z);
+
+    if (len > 0) {
+        const inv = 1 / len;
+        dir_x *= inv;
+        dir_y *= inv;
+        dir_z *= inv;
+    }
+
+    shape_a.support(scratch_support_a, 0, dir_x, dir_y, dir_z);
+    shape_b.support(scratch_support_b, 0, -dir_x, -dir_y, -dir_z);
+
+    result[result_offset] = scratch_support_a[0] - scratch_support_b[0];
+    result[result_offset + 1] = scratch_support_a[1] - scratch_support_b[1];
+    result[result_offset + 2] = scratch_support_a[2] - scratch_support_b[2];
+}
+
+/**
+ * GJK intersection test for two convex shapes.
+ *
+ * Determines whether two convex shapes overlap by iteratively building a simplex
+ * in the Minkowski difference space. If the origin is enclosed by the simplex,
+ * the shapes intersect.
+ *
+ * Adapted from https://github.com/kevinmoran/GJK/blob/master/GJK.h
+ *
+ * @param {number[]|Float32Array} simplex Working buffer for simplex vertices (4 vec3s). Must have length >= 12.
+ * @param {AbstractShape3D} shape_a
+ * @param {AbstractShape3D} shape_b
+ * @returns {boolean} true if the shapes intersect
+ */
+export function gjk(simplex, shape_a, shape_b) {
+
+    const dir = scratch_dir;
+
+    // Initial search direction — arbitrary, (1,0,0)
+
+    // Get initial support point (simplex point C)
+    minkowski_support(
+        simplex, 6,
+        shape_a, shape_b,
+        1, 0, 0
+    );
+
+    // Search toward the origin from C
+    dir[0] = -simplex[6];
+    dir[1] = -simplex[7];
+    dir[2] = -simplex[8];
+
+    if (dir[0] === 0 && dir[1] === 0 && dir[2] === 0) {
+        // Origin is exactly on the first support point — intersection
+        return true;
+    }
+
+    // Get second support point (simplex point B)
+    minkowski_support(simplex, 3, shape_a, shape_b, dir[0], dir[1], dir[2]);
+
+    // B didn't pass the origin — no intersection possible
+    if (v3_dot(simplex[3], simplex[4], simplex[5], dir[0], dir[1], dir[2]) < 0) {
+        return false;
+    }
+
+    // Line case: compute direction perpendicular to line segment BC toward origin
+    // CB = C - B
+    const cb_x = simplex[6] - simplex[3];
+    const cb_y = simplex[7] - simplex[4];
+    const cb_z = simplex[8] - simplex[5];
+
+    // BO = -B (origin - B)
+    const bo_x = -simplex[3];
+    const bo_y = -simplex[4];
+    const bo_z = -simplex[5];
+
+    // dir = CB × BO × CB (triple cross product)
+    triple_cross_product(dir, cb_x, cb_y, cb_z, bo_x, bo_y, bo_z);
+
+    // Handle degenerate case where origin is on the line segment
+    if (dir[0] === 0 && dir[1] === 0 && dir[2] === 0) {
+        // Origin is on the line segment — pick any perpendicular direction
+        // Use the cross product of CB with an arbitrary axis
+        // CB × (1,0,0)
+        dir[0] = cb_y;
+        dir[1] = -cb_x;
+        dir[2] = 0;
+
+        if (dir[0] === 0 && dir[1] === 0 && dir[2] === 0) {
+            // CB is parallel to (1,0,0), use (0,1,0)
+            dir[0] = -cb_z;
+            dir[1] = 0;
+            dir[2] = cb_x;
+        }
+    }
+
+    let simplex_size = 2; // we have B and C
+
+    for (let iterations = 0; iterations < GJK_MAX_ITERATIONS; iterations++) {
+        // Get new support point A
+        minkowski_support(simplex, 0, shape_a, shape_b, dir[0], dir[1], dir[2]);
+
+        const a_x = simplex[0];
+        const a_y = simplex[1];
+        const a_z = simplex[2];
+
+        // Check if A passed the origin
+        if (v3_dot(a_x, a_y, a_z, dir[0], dir[1], dir[2]) < 0) {
+            return false; // no intersection
+        }
+
+        simplex_size++;
+
+        if (simplex_size === 3) {
+            // Triangle case
+            update_simplex_triangle(dir, simplex);
+        } else {
+            // Tetrahedron case
+            if (update_simplex_tetrahedron(dir, simplex)) {
+                // Origin is inside the tetrahedron — intersection!
+                return true;
+            }
+
+            // The simplex was reduced to a triangle, so keep size at 3
+            simplex_size = 3;
+        }
+    }
+
+    // Did not converge — assume no intersection
+    return false;
+}
+
+/**
+ * Compute the triple cross product: (a × b) × a
+ *
+ * @param {number[]|Float32Array} result output vec3
+ * @param {number} ax
+ * @param {number} ay
+ * @param {number} az
+ * @param {number} bx
+ * @param {number} by
+ * @param {number} bz
+ */
+function triple_cross_product(result, ax, ay, az, bx, by, bz) {
+    // First: t = a × b
+    const tx = ay * bz - az * by;
+    const ty = az * bx - ax * bz;
+    const tz = ax * by - ay * bx;
+
+    // Then: t × a
+    result[0] = ty * az - tz * ay;
+    result[1] = tz * ax - tx * az;
+    result[2] = tx * ay - ty * ax;
+}
+
+/**
+ * Update simplex for the triangle case (3 points: A, B, C).
+ *
+ * Determines the Voronoi region of the origin relative to triangle ABC
+ * and updates the search direction accordingly.
+ *
+ * simplex layout: [A(0-2), B(3-5), C(6-8)]
+ *
+ * @param {number[]|Float32Array} search_dir output: next search direction
+ * @param {Float32Array} simplex
+ */
+function update_simplex_triangle(search_dir, simplex) {
+    const a_x = simplex[0], a_y = simplex[1], a_z = simplex[2];
+    const b_x = simplex[3], b_y = simplex[4], b_z = simplex[5];
+    const c_x = simplex[6], c_y = simplex[7], c_z = simplex[8];
+
+    // AB = B - A
+    const ab_x = b_x - a_x;
+    const ab_y = b_y - a_y;
+    const ab_z = b_z - a_z;
+
+    // AC = C - A
+    const ac_x = c_x - a_x;
+    const ac_y = c_y - a_y;
+    const ac_z = c_z - a_z;
+
+    // AO = -A (origin - A)
+    const ao_x = -a_x;
+    const ao_y = -a_y;
+    const ao_z = -a_z;
+
+    // Normal of triangle ABC
+    const abc_x = ab_y * ac_z - ab_z * ac_y;
+    const abc_y = ab_z * ac_x - ab_x * ac_z;
+    const abc_z = ab_x * ac_y - ab_y * ac_x;
+
+    // Test edge AC
+    // ABC × AC
+    const abc_cross_ac_x = abc_y * ac_z - abc_z * ac_y;
+    const abc_cross_ac_y = abc_z * ac_x - abc_x * ac_z;
+    const abc_cross_ac_z = abc_x * ac_y - abc_y * ac_x;
+
+    if (v3_dot(abc_cross_ac_x, abc_cross_ac_y, abc_cross_ac_z, ao_x, ao_y, ao_z) > 0) {
+        // Origin is on the AC side
+        // Reduce simplex to line AC (A stays as A, C moves to B position)
+        simplex[3] = c_x;
+        simplex[4] = c_y;
+        simplex[5] = c_z;
+
+        // New direction: AC × AO × AC
+        triple_cross_product(search_dir, ac_x, ac_y, ac_z, ao_x, ao_y, ao_z);
+        return;
+    }
+
+    // Test edge AB
+    // AB × ABC
+    const ab_cross_abc_x = ab_y * abc_z - ab_z * abc_y;
+    const ab_cross_abc_y = ab_z * abc_x - ab_x * abc_z;
+    const ab_cross_abc_z = ab_x * abc_y - ab_y * abc_x;
+
+    if (v3_dot(ab_cross_abc_x, ab_cross_abc_y, ab_cross_abc_z, ao_x, ao_y, ao_z) > 0) {
+        // Origin is on the AB side
+        // Keep simplex as line AB (C slot is cleared by not using it)
+        simplex[6] = simplex[3];
+        simplex[7] = simplex[4];
+        simplex[8] = simplex[5];
+
+        // New direction: AB × AO × AB
+        triple_cross_product(search_dir, ab_x, ab_y, ab_z, ao_x, ao_y, ao_z);
+        return;
+    }
+
+    // Origin is above or below the triangle
+    if (v3_dot(abc_x, abc_y, abc_z, ao_x, ao_y, ao_z) > 0) {
+        // Origin is above — search in normal direction
+        // Simplex stays as A, B, C
+        search_dir[0] = abc_x;
+        search_dir[1] = abc_y;
+        search_dir[2] = abc_z;
+    } else {
+        // Origin is below — swap B and C, search in -normal
+        const tmp_x = simplex[3], tmp_y = simplex[4], tmp_z = simplex[5];
+        simplex[3] = simplex[6];
+        simplex[4] = simplex[7];
+        simplex[5] = simplex[8];
+        simplex[6] = tmp_x;
+        simplex[7] = tmp_y;
+        simplex[8] = tmp_z;
+
+        search_dir[0] = -abc_x;
+        search_dir[1] = -abc_y;
+        search_dir[2] = -abc_z;
+    }
+}
+
+/**
+ * Update simplex for the tetrahedron case (4 points: A, B, C, D).
+ *
+ * Tests which face of the tetrahedron is closest to the origin and
+ * reduces the simplex accordingly. Returns true if the origin is
+ * inside the tetrahedron.
+ *
+ * simplex layout: [A(0-2), B(3-5), C(6-8), D(9-11)]
+ *
+ * @param {number[]|Float32Array} search_dir output: next search direction (only written when returning false)
+ * @param {Float32Array} simplex
+ * @returns {boolean} true if origin is inside the tetrahedron
+ */
+function update_simplex_tetrahedron(search_dir, simplex) {
+    const a_x = simplex[0], a_y = simplex[1], a_z = simplex[2];
+    const b_x = simplex[3], b_y = simplex[4], b_z = simplex[5];
+    const c_x = simplex[6], c_y = simplex[7], c_z = simplex[8];
+    const d_x = simplex[9], d_y = simplex[10], d_z = simplex[11];
+
+    // AB, AC, AD vectors
+    const ab_x = b_x - a_x, ab_y = b_y - a_y, ab_z = b_z - a_z;
+    const ac_x = c_x - a_x, ac_y = c_y - a_y, ac_z = c_z - a_z;
+    const ad_x = d_x - a_x, ad_y = d_y - a_y, ad_z = d_z - a_z;
+
+    // AO = origin - A = -A
+    const ao_x = -a_x, ao_y = -a_y, ao_z = -a_z;
+
+    // Face normals (outward-facing from A's perspective)
+    // ABC normal
+    const abc_x = ab_y * ac_z - ab_z * ac_y;
+    const abc_y = ab_z * ac_x - ab_x * ac_z;
+    const abc_z = ab_x * ac_y - ab_y * ac_x;
+
+    // ACD normal
+    const acd_x = ac_y * ad_z - ac_z * ad_y;
+    const acd_y = ac_z * ad_x - ac_x * ad_z;
+    const acd_z = ac_x * ad_y - ac_y * ad_x;
+
+    // ADB normal
+    const adb_x = ad_y * ab_z - ad_z * ab_y;
+    const adb_y = ad_z * ab_x - ad_x * ab_z;
+    const adb_z = ad_x * ab_y - ad_y * ab_x;
+
+    // Test each face to see if the origin is on the outside
+
+    // Check face ABC (opposite to D)
+    const abc_test = v3_dot(abc_x, abc_y, abc_z, ao_x, ao_y, ao_z);
+    // Make sure normal points away from D
+    const abc_d_side = v3_dot(abc_x, abc_y, abc_z, ad_x, ad_y, ad_z);
+
+    if (abc_test * abc_d_side < 0) {
+        // Origin is on the opposite side of ABC from D
+        // Reduce to triangle ABC: D is dropped
+        // simplex = [A, B, C] — A(0), B(3), C(6) already in place
+        update_simplex_triangle(search_dir, simplex);
+        return false;
+    }
+
+    // Check face ACD (opposite to B)
+    const acd_test = v3_dot(acd_x, acd_y, acd_z, ao_x, ao_y, ao_z);
+    const acd_b_side = v3_dot(acd_x, acd_y, acd_z, ab_x, ab_y, ab_z);
+
+    if (acd_test * acd_b_side < 0) {
+        // Origin is outside face ACD
+        // Reduce to triangle ACD: replace B with D
+        simplex[3] = c_x;
+        simplex[4] = c_y;
+        simplex[5] = c_z;
+        simplex[6] = d_x;
+        simplex[7] = d_y;
+        simplex[8] = d_z;
+
+        update_simplex_triangle(search_dir, simplex);
+        return false;
+    }
+
+    // Check face ADB (opposite to C)
+    const adb_test = v3_dot(adb_x, adb_y, adb_z, ao_x, ao_y, ao_z);
+    const adb_c_side = v3_dot(adb_x, adb_y, adb_z, ac_x, ac_y, ac_z);
+
+    if (adb_test * adb_c_side < 0) {
+        // Origin is outside face ADB
+        // Reduce to triangle ADB: replace C with B, B with D
+        simplex[6] = b_x;
+        simplex[7] = b_y;
+        simplex[8] = b_z;
+        simplex[3] = d_x;
+        simplex[4] = d_y;
+        simplex[5] = d_z;
+
+        update_simplex_triangle(search_dir, simplex);
+        return false;
+    }
+
+    // Origin is inside the tetrahedron
+    return true;
+}