@woosh/meep-engine 2.120.0 → 2.120.2

package/src/engine/ecs/terrain/ecs/splat/SplatMapping.js

@@ -107,23 +107,17 @@ export class SplatMapping {
 
         const dataOffset = index * width * height;
 
-        const sourceWidth = source.width;
-        const sourceHeight = source.height;
-
-        const source_max_y = sourceHeight - 1;
-        const source_max_x = sourceWidth - 1;
-
         for (let y = 0; y < height; y++) {
-            const v = y / height;
+            const v = (y + 0.5) / height;
 
             for (let x = 0; x < width; x++) {
 
-                const u = x / width;
+                const u = (x + 0.5) / width;
 
                 const targetIndex = y * width + x;
                 const targetAddress = dataOffset + targetIndex;
 
-                const value = source.sampleChannelBilinear(u * source_max_x, v * source_max_y, channel);
+                const value = source.sampleChannelBilinearUV(u , v , channel);
 
                 weightData[targetAddress] = value;
             }

package/src/engine/ecs/terrain/overlay/TerrainOverlay.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TerrainOverlay.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/ecs/terrain/overlay/TerrainOverlay.js"],"names":[],"mappings":"AA+CA;IACI;;;;OAIG;IACH,kBAHW,OAAO,EA8DjB;IA1DG;;;;OAIG;IACH,sBAHU,OAAO,CAGkB;IACnC;;;;OAIG;IACH,eAHU,OAAO,CAGsB;IAEvC;;;OAGG;IACH,WAFU,cAAc,CAEiC;IAEzD;;;OAGG;IACH,SAFU,SAAS,CAE8B;IAEjC,qBAAiD;IAiBjE;;;OAGG;IACH,OAFU,OAAO,EAAE,CAEJ;IAsBnB;;;OAGG;IACH,qBAFW,MAAM,EAQhB;IAlBD;;;OAGG;IACH,qBAFa,MAAM,CAIlB;IAcD;;OAEG;IACH,cAFa,iBAAiB,CAI7B;IAED;;OAEG;IACH,aASC;IAED;;OAEG;IACH,YAuBC;IAED,cAMC;IAED,eAEC;IAED;;;;;OAKG;IACH,aAJW,MAAM,KACN,MAAM,UACN,OAAO,QAQjB;IAED;;;;;OAKG;IACH,wBAJW,MAAM,KACN,MAAM,QACN,OAAO,QAmBjB;IAED;;;;OAIG;IACH,cAHW,MAAM,KACN,MAAM,QAIhB;IAED;;;;;OAKG;IACH,cAJW,MAAM,KACN,MAAM,QACN,OAAO,QAUjB;IAED;;;OAGG;IACH,gBAFW,UAAU,GAAC,MAAM,EAAE,QAuB7B;IAED;;;;;;;OAOG;IACH,kBANW,iBAAiB,MACjB,MAAM,MACN,MAAM,WACN,MAAM,YACN,MAAM,QAMhB;IAED;;;;;;;OAOG;IACH,qBANW,SAAS,MACT,MAAM,MACN,MAAM,UACN,MAAM,WACN,MAAM,QAWhB;CACJ;oBAxTmB,kCAAkC;oBAClC,kCAAkC;2BAE3B,0CAA0C;0BAG3C,gDAAgD;4BAZV,OAAO;AAgBvE;IACI;;;;;;OAMG;IACH,qBALW,SAAS,eACT,MAAM,aACN,MAAM,EAqBhB;IAjBG;;;OAGG;IACH,SAFU,SAAS,CAEG;IAEtB;;;OAGG;IACH,aAFU,MAAM,CAEc;IAE9B;;;OAGG;IACH,WAFU,MAAM,CAEU;CAEjC;oBAnCmB,kCAAkC"}
+{"version":3,"file":"TerrainOverlay.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/ecs/terrain/overlay/TerrainOverlay.js"],"names":[],"mappings":"AA+CA;IACI;;;;OAIG;IACH,kBAHW,OAAO,EAkEjB;IA9DG;;;;OAIG;IACH,sBAHU,OAAO,CAGkB;IACnC;;;;OAIG;IACH,eAHU,OAAO,CAGsB;IAEvC;;;OAGG;IACH,WAFU,cAAc,CAEiC;IAEzD;;;OAGG;IACH,SAFU,SAAS,CAE8B;IAEjC,qBAIf;IAiBD;;;OAGG;IACH,OAFU,OAAO,EAAE,CAEJ;IAsBnB;;;OAGG;IACH,qBAFW,MAAM,EAMhB;IAhBD;;;OAGG;IACH,qBAFa,MAAM,CAIlB;IAYD;;OAEG;IACH,cAFa,iBAAiB,CAI7B;IAED;;OAEG;IACH,aAaC;IAED;;OAEG;IACH,YAuBC;IAED,cAMC;IAED,eAEC;IAED;;;;;OAKG;IACH,aAJW,MAAM,KACN,MAAM,UACN,OAAO,QAQjB;IAED;;;;;OAKG;IACH,wBAJW,MAAM,KACN,MAAM,QACN,OAAO,QAmBjB;IAED;;;;OAIG;IACH,cAHW,MAAM,KACN,MAAM,QAIhB;IAED;;;;;OAKG;IACH,cAJW,MAAM,KACN,MAAM,QACN,OAAO,QAUjB;IAED;;;OAGG;IACH,gBAFW,UAAU,GAAC,MAAM,EAAE,QAuB7B;IAED;;;;;;;OAOG;IACH,kBANW,iBAAiB,MACjB,MAAM,MACN,MAAM,WACN,MAAM,YACN,MAAM,QAMhB;IAED;;;;;;;OAOG;IACH,qBANW,SAAS,MACT,MAAM,MACN,MAAM,UACN,MAAM,WACN,MAAM,QAWhB;CACJ;oBA9TmB,kCAAkC;oBAClC,kCAAkC;2BAE3B,0CAA0C;0BAG3C,gDAAgD;4BAZV,OAAO;AAgBvE;IACI;;;;;;OAMG;IACH,qBALW,SAAS,eACT,MAAM,aACN,MAAM,EAqBhB;IAjBG;;;OAGG;IACH,SAFU,SAAS,CAEG;IAEtB;;;OAGG;IACH,aAFU,MAAM,CAEc;IAE9B;;;OAGG;IACH,WAFU,MAAM,CAEU;CAEjC;oBAnCmB,kCAAkC"}

package/src/engine/ecs/terrain/overlay/TerrainOverlay.js

@@ -77,7 +77,11 @@ export class TerrainOverlay {
          */
         this.sampler = Sampler2D.uint8(4, size.x, size.y);
 
-        const texture = this.texture = new DataTexture(this.sampler.data);
+        const texture = this.texture = new DataTexture(
+            this.sampler.data,
+            size.x,
+            size.y,
+        );
 
         texture.wrapS = ClampToEdgeWrapping;
         texture.wrapT = ClampToEdgeWrapping;
@@ -117,7 +121,7 @@ export class TerrainOverlay {
      * @returns {string}
      */
     get baseTileImage() {
-        return this.stack.length === 0 ? this.tileImage.getValue() : this.stack[0].tileImage
+        return this.tileImage.getValue();
     }
 
     /**
@@ -125,11 +129,9 @@ export class TerrainOverlay {
      * @param {string} v
      */
     set baseTileImage(v) {
-        if (this.stack.length === 0) {
-            this.tileImage.set(v);
-        } else {
-            this.stack[0].tileImage = v;
-        }
+
+        this.tileImage.set(v);
+
     }
 
     /**
@@ -145,7 +147,11 @@ export class TerrainOverlay {
     push() {
         const sampler = this.sampler.clone();
 
-        const context = new Context(sampler, this.borderWidth.getValue(), this.tileImage.getValue());
+        const context = new Context(
+            sampler,
+            this.borderWidth.getValue(),
+            this.tileImage.getValue()
+        );
 
         this.stack.push(context);
 

package/src/engine/ecs/transform/Transform.d.ts

@@ -1,5 +1,9 @@
 /**
- * Described position/rotation/scale in 3d space
+ * A Transform represents the position, rotation, and scale of an object in 3D space.
+ * Think of it like the object's location, orientation, and size.
+ * It has properties for position (like coordinates), rotation (how it's turned), and scale (how big it is).
+ *
+ * It also uses a "matrix" (a table of numbers) internally to efficiently store and calculate transformations, but you usually interact with the position, rotation, and scale directly.
  * @class
  */
 export class Transform {

package/src/engine/ecs/transform/Transform.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Transform.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/transform/Transform.js"],"names":[],"mappings":"AAsBA;;;GAGG;AACH;IAwQI;;;;OAIG;IACH,4BAFa,SAAS,CAQrB;IAED;;;;OAIG;IACH,uBAHW,MAAM,EAAE,GAAC,YAAY,GACnB,SAAS,CAQrB;IAiED;;;;;OAKG;IACH,wCAJW,UAAU,gBACV,OAAO,wBAajB;IA/WD;;;OAGG;IACH,mBAHU,OAAO,CAGe;IAEhC;;;OAGG;IACH,mBAHU,UAAU,CAGkB;IAEtC;;;OAGG;IACH,gBAHU,OAAO,CAGY;IAE7B;;;;OAIG;IACH,iBAFU,YAAY,CAEC;IAEvB;;;;OAIG;IACH,OAFU,MAAM,CAEM;IAOtB;;;;OAIG;IACH,eAFa,OAAO,CAQnB;IAED;;;OAGG;IACH,UAFY,OAAO,CAQlB;IAED;;;OAGG;IACH,aAFY,OAAO,CAQlB;IAED;;;;OAIG;IACH,uCAFW,GAAC,QAMX;IAED;;;;OAIG;IACH,yCAFW,GAAC,QAMX;IAYD;;;;OAIG;IACH,cAHW,MAAM,GAAC,cAAc,GACnB,IAAI,CAIhB;IAED;;;;OAIG;IACH,gBAHW,MAAM,GAAC,cAAc,GACnB,IAAI,CAIhB;IAED;;;;OAIG;IACH,gBAHW,MAAM,GAAC,cAAc,SACrB,OAAO,QAQjB;IAED;;;;OAIG;IACH,cAHW,MAAM,GAAC,cAAc,GACnB,OAAO,CAInB;IAED;;OAEG;IACH,qBAEC;IAED;;;;OAIG;IACH,eAHW,OAAO,OACP,OAAO,QAmBjB;IAED,0BAwBC;IAED;;;;MAMC;IAED;;;OAGG;IACH,YAFW,SAAS,QAenB;IAED;;;OAGG;IACH,SAFa,SAAS,CAQrB;IAED;;;;OAIG;IACH,cAHW,SAAS,GACP,OAAO,CAMnB;IAED;;;OAGG;IACH,QAFa,MAAM,CAKlB;IA4BD;;;;OAIG;IACH,sBAHW,SAAS,KACT,SAAS,QAMnB;IAED;;;OAGG;IACH,oBAFW,IAAI,GAAC,MAAM,EAAE,GAAC,YAAY,QAgBpC;IAED;;;OAGG;IACH,kBAFW,MAAM,EAAE,GAAC,YAAY,QAI/B;IAED;;;;;OAKG;IACH,qBAEC;IAED;;;OAGG;IACH,cAFa,OAAO,CAMnB;IAED,mBAEC;IA2BL;;;OAGG;IACH,sBAFU,OAAO,CAEc;;CAZ9B;;kBAIS,MAAM;;oBAzYI,+BAA+B;uBAD5B,kCAAkC;+BAE1B,qBAAqB"}
+{"version":3,"file":"Transform.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/transform/Transform.js"],"names":[],"mappings":"AAsBA;;;;;;;GAOG;AACH;IAwQI;;;;OAIG;IACH,4BAFa,SAAS,CAQrB;IAED;;;;OAIG;IACH,uBAHW,MAAM,EAAE,GAAC,YAAY,GACnB,SAAS,CAQrB;IAiED;;;;;OAKG;IACH,wCAJW,UAAU,gBACV,OAAO,wBAajB;IA/WD;;;OAGG;IACH,mBAHU,OAAO,CAGe;IAEhC;;;OAGG;IACH,mBAHU,UAAU,CAGkB;IAEtC;;;OAGG;IACH,gBAHU,OAAO,CAGY;IAE7B;;;;OAIG;IACH,iBAFU,YAAY,CAEC;IAEvB;;;;OAIG;IACH,OAFU,MAAM,CAEM;IAOtB;;;;OAIG;IACH,eAFa,OAAO,CAQnB;IAED;;;OAGG;IACH,UAFY,OAAO,CAQlB;IAED;;;OAGG;IACH,aAFY,OAAO,CAQlB;IAED;;;;OAIG;IACH,uCAFW,GAAC,QAMX;IAED;;;;OAIG;IACH,yCAFW,GAAC,QAMX;IAYD;;;;OAIG;IACH,cAHW,MAAM,GAAC,cAAc,GACnB,IAAI,CAIhB;IAED;;;;OAIG;IACH,gBAHW,MAAM,GAAC,cAAc,GACnB,IAAI,CAIhB;IAED;;;;OAIG;IACH,gBAHW,MAAM,GAAC,cAAc,SACrB,OAAO,QAQjB;IAED;;;;OAIG;IACH,cAHW,MAAM,GAAC,cAAc,GACnB,OAAO,CAInB;IAED;;OAEG;IACH,qBAEC;IAED;;;;OAIG;IACH,eAHW,OAAO,OACP,OAAO,QAmBjB;IAED,0BAwBC;IAED;;;;MAMC;IAED;;;OAGG;IACH,YAFW,SAAS,QAenB;IAED;;;OAGG;IACH,SAFa,SAAS,CAQrB;IAED;;;;OAIG;IACH,cAHW,SAAS,GACP,OAAO,CAMnB;IAED;;;OAGG;IACH,QAFa,MAAM,CAKlB;IA4BD;;;;OAIG;IACH,sBAHW,SAAS,KACT,SAAS,QAMnB;IAED;;;OAGG;IACH,oBAFW,IAAI,GAAC,MAAM,EAAE,GAAC,YAAY,QAgBpC;IAED;;;OAGG;IACH,kBAFW,MAAM,EAAE,GAAC,YAAY,QAI/B;IAED;;;;;OAKG;IACH,qBAEC;IAED;;;OAGG;IACH,cAFa,OAAO,CAMnB;IAED,mBAEC;IA2BL;;;OAGG;IACH,sBAFU,OAAO,CAEc;;CAZ9B;;kBAIS,MAAM;;oBA7YI,+BAA+B;uBAD5B,kCAAkC;+BAE1B,qBAAqB"}

package/src/engine/ecs/transform/Transform.js

@@ -21,7 +21,11 @@ const scratch_matrix = new Float32Array(16);
 const FLAGS_DEFAULT = TransformFlags.AutomaticChangeDetection;
 
 /**
- * Described position/rotation/scale in 3d space
+ * A Transform represents the position, rotation, and scale of an object in 3D space.
+ * Think of it like the object's location, orientation, and size.
+ * It has properties for position (like coordinates), rotation (how it's turned), and scale (how big it is).
+ *
+ * It also uses a "matrix" (a table of numbers) internally to efficiently store and calculate transformations, but you usually interact with the position, rotation, and scale directly.
  * @class
  */
 export class Transform {

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

@@ -1,50 +1,349 @@
-import Vector2 from "../../../../core/geom/Vector2";
-
-export class Sampler2D {
-    constructor(data: ArrayLike<number>, itemSize?: number, width?: number, height?: number)
-
-    readonly height: number
-    readonly width: number
-
-    readonly itemSize: number
-
-    readonly data: ArrayLike<number>
-
-    version: number
-
-    readChannel(x: number, y: number, channel: number): number
-
-    writeChannel(x: number, y: number, channel: number, value: number): void
-
-    channelFill(channelIndex: number, value: number): void
-
-    sampleBilinear(x: number, y: number, result: ArrayLike<number>, result_offset?: number): void
-
-    sampleChannelBilinear(x: number, y: number, channel: number): number
-
-    sampleBicubic(x: number, y: number, result: ArrayLike<number>, result_offset?: number): void
-
-    sampleChannelBicubic(x: number, y: number, channel: number): number
-
-    resize(x: number, y: number, preserveData?: boolean): void
-
-    point2index(x: number, y: number): number
-
-    index2point(index: number, result: Vector2): void
-
-    static uint8clamped(itemSize: number, width: number, height: number): Sampler2D
-
-    static uint8(itemSize: number, width: number, height: number): Sampler2D
-
-    static uint16(itemSize: number, width: number, height: number): Sampler2D
-
-    static uint32(itemSize: number, width: number, height: number): Sampler2D
-
-    static int8(itemSize: number, width: number, height: number): Sampler2D
-
-    static int16(itemSize: number, width: number, height: number): Sampler2D
-
-    static int32(itemSize: number, width: number, height: number): Sampler2D
-
-    static float32(itemSize: number, width: number, height: number): Sampler2D
-}
+/**
+ * Data Texture class, providing an abstraction around 2d numerical arrays, mostly for sampling purposes
+ * Inspired by OpenGL's glsl sampler2d API
+ * @class
+ */
+export class Sampler2D {
+    /**
+     *
+     * @param {int} itemSize
+     * @param {int} width
+     * @param {int} height
+     * @return {Sampler2D}
+     */
+    static uint8clamped(itemSize: int, width: int, height: int): Sampler2D;
+    /**
+     *
+     * @param {int} itemSize
+     * @param {int} width
+     * @param {int} height
+     * @return {Sampler2D}
+     */
+    static uint8(itemSize: int, width: int, height: int): Sampler2D;
+    /**
+     *
+     * @param {int} itemSize
+     * @param {int} width
+     * @param {int} height
+     * @return {Sampler2D}
+     */
+    static uint16(itemSize: int, width: int, height: int): Sampler2D;
+    /**
+     *
+     * @param {int} itemSize
+     * @param {int} width
+     * @param {int} height
+     * @return {Sampler2D}
+     */
+    static uint32(itemSize: int, width: int, height: int): Sampler2D;
+    /**
+     *
+     * @param {int} itemSize
+     * @param {int} width
+     * @param {int} height
+     * @return {Sampler2D}
+     */
+    static int8(itemSize: int, width: int, height: int): Sampler2D;
+    /**
+     *
+     * @param {int} itemSize
+     * @param {int} width
+     * @param {int} height
+     * @return {Sampler2D}
+     */
+    static int16(itemSize: int, width: int, height: int): Sampler2D;
+    /**
+     *
+     * @param {int} itemSize
+     * @param {int} width
+     * @param {int} height
+     * @return {Sampler2D}
+     */
+    static int32(itemSize: int, width: int, height: int): Sampler2D;
+    /**
+     *
+     * @param {int} itemSize
+     * @param {int} width
+     * @param {int} height
+     * @return {Sampler2D}
+     */
+    static float32(itemSize: int, width: int, height: int): Sampler2D;
+    /**
+     *
+     * @param {int} itemSize
+     * @param {int} width
+     * @param {int} height
+     * @return {Sampler2D}
+     */
+    static float64(itemSize: int, width: int, height: int): Sampler2D;
+    /**
+     *
+     * @param {ArrayLike<number>|number[]|Uint8ClampedArray|Uint8Array|Uint16Array|Uint32Array|Int8Array|Int16Array|Int32Array|Float32Array|Float64Array} data
+     * @param {number} [itemSize]
+     * @param {number} [width]
+     * @param {number} [height]
+     * @constructor
+     */
+    constructor(data?: ArrayLike<number> | number[] | Uint8ClampedArray | Uint8Array | Uint16Array | Uint32Array | Int8Array | Int16Array | Int32Array | Float32Array | Float64Array, itemSize?: number, width?: number, height?: number);
+    /**
+     *
+     * @type {number}
+     */
+    width: number;
+    /**
+     *
+     * @type {number}
+     */
+    height: number;
+    /**
+     * Number of channels
+     * @type {number}
+     */
+    itemSize: number;
+    /**
+     *
+     * @type {number[]|Uint8ClampedArray|Uint8Array|Uint16Array|Uint32Array|Int8Array|Int16Array|Int32Array|Float32Array|Float64Array}
+     */
+    data: number[] | Uint8ClampedArray | Uint8Array | Uint16Array | Uint32Array | Int8Array | Int16Array | Int32Array | Float32Array | Float64Array;
+    /**
+     * Used to tracking changes
+     * @type {number}
+     */
+    version: number;
+    /**
+     *
+     * @param {number} u
+     * @param {number} v
+     * @param {number[]} result
+     */
+    sampleCatmullRomUV(u: number, v: number, result: number[]): void;
+    /**
+     *
+     * @param {number} u
+     * @param {number} v
+     * @param {number} channel
+     * @returns {number}
+     */
+    sampleChannelCatmullRomUV(u: number, v: number, channel: number): number;
+    /**
+     *
+     * @see https://gist.github.com/TheRealMJP/c83b8c0f46b63f3a88a5986f4fa982b1
+     * @param {number} x
+     * @param {number} y
+     * @param {number} channel
+     * @returns {number}
+     */
+    sampleChannelCatmullRom(x: number, y: number, channel: number): number;
+    /**
+     *
+     * @param {number} u
+     * @param {number} v
+     * @param {number[]} result
+     */
+    sampleBicubicUV(u: number, v: number, result: number[]): void;
+    /**
+     *
+     * @param {number} x
+     * @param {number} y
+     * @param {number[]|Float32Array|Float64Array} result
+     * @param {number} result_offset
+     */
+    sampleBicubic(x: number, y: number, result: number[] | Float32Array | Float64Array, result_offset: number): void;
+    /**
+     *
+     * @param {number} u
+     * @param {number} v
+     * @param {number} channel
+     * @returns {number}
+     */
+    sampleChannelBicubicUV(u: number, v: number, channel: number): number;
+    /**
+     *
+     * Bicubic-filtered sampling, note values can be negative due to the nature of the cubic curve
+     * @param {number} x
+     * @param {number} y
+     * @param {number} channel
+     * @returns {number}
+     */
+    sampleChannelBicubic(x: number, y: number, channel: number): number;
+    /**
+     *
+     * @param {number} u
+     * @param {number} v
+     * @param {number[]|Float32Array} result
+     * @param {number} result_offset
+     */
+    sampleBilinearUV(u: number, v: number, result: number[] | Float32Array, result_offset?: number): void;
+    /**
+     *
+     * @param {number} x
+     * @param {number} y
+     * @param {number[]|Float32Array|Float64Array} result
+     * @param {number} result_offset
+     */
+    sampleBilinear(x: number, y: number, result: number[] | Float32Array | Float64Array, result_offset?: number): void;
+    /**
+     *
+     * @param {number} u
+     * @param {number} v
+     * @param {number} channel
+     * @return {number}
+     */
+    sampleChannelBilinearUV(u: number, v: number, channel: number): number;
+    /**
+     *
+     * @param {number} x
+     * @param {number} y
+     * @param {number} channel
+     * @returns {number}
+     */
+    sampleChannelBilinear(x: number, y: number, channel: number): number;
+    /**
+     *
+     * @param {number} u
+     * @param {number} v
+     * @param {number[]|ArrayLike<number>} result
+     */
+    sampleNearestUV(u: number, v: number, result: number[] | ArrayLike<number>): void;
+    /**
+     *
+     * @param {number} x
+     * @param {number} y
+     * @param {number} channel
+     * @returns {number}
+     */
+    readChannel(x: number, y: number, channel: number): number;
+    /**
+     *
+     * @param {number} x
+     * @param {number} y
+     * @param {number[]} result
+     */
+    read(x: number, y: number, result: number[]): void;
+    /**
+     *
+     * @param {number} x
+     * @param {number} y
+     * @param {number[]|ArrayLike<number>} texel
+     */
+    write(x: number, y: number, texel: number[] | ArrayLike<number>): void;
+    /**
+     *
+     * @param {number} x
+     * @param {number} y
+     * @returns {number}
+     */
+    point2index(x: number, y: number): number;
+    /**
+     *
+     * @param {number} index
+     * @param {Vector2} result
+     */
+    index2point(index: number, result: Vector2): void;
+    /**
+     * Copy a patch from another sampler
+     * @param {Sampler2D} source where to copy from
+     * @param {Number} sourceX where to start reading from, X coordinate
+     * @param {Number} sourceY where to start reading from, X coordinate
+     * @param {Number} destinationX where to start writing to, X coordinate
+     * @param {Number} destinationY where to start writing to, X coordinate
+     * @param {Number} width size of the patch that is to be copied
+     * @param {Number} height size of the patch that is to be copied
+     */
+    copy(source: Sampler2D, sourceX: number, sourceY: number, destinationX: number, destinationY: number, width: number, height: number): void;
+    /**
+     * Fill data values with zeros for a given area
+     * Specialized version of `fill` method, optimized for speed
+     * @param {Number} x
+     * @param {Number} y
+     * @param {Number} width
+     * @param {Number} height
+     */
+    zeroFill(x: number, y: number, width: number, height: number): void;
+    /**
+     *
+     * @param {number} channel_index
+     * @param {number} value
+     */
+    channelFill(channel_index: number, value: number): void;
+    /**
+     *
+     * @param {number} x
+     * @param {number} y
+     * @param {number} width
+     * @param {number} height
+     * @param {Array.<number>} value
+     */
+    fill(x: number, y: number, width: number, height: number, value: Array<number>): void;
+    /**
+     * Set channel value of a specific texel
+     * @param {number} x
+     * @param {number} y
+     * @param {number} channel
+     * @param {number} value
+     */
+    writeChannel(x: number, y: number, channel: number, value: number): void;
+    /**
+     * Traverses area inside a circle
+     * NOTE: Based on palm3d answer on stack overflow: https://stackoverflow.com/questions/1201200/fast-algorithm-for-drawing-filled-circles
+     * @param {number} centerX
+     * @param {number} centerY
+     * @param {number} radius
+     * @param {function(x:number,y:number, sampler:Sampler2D)} visitor
+     */
+    traverseCircle(centerX: number, centerY: number, radius: number, visitor: any): void;
+    /**
+     *
+     * @param {number} x
+     * @param {number} y
+     * @param {boolean} [preserveData=true]
+     */
+    resize(x: number, y: number, preserveData?: boolean): void;
+    /**
+     * Estimate memory requirement of the object
+     * @return {number}
+     */
+    computeByteSize(): number;
+    /**
+     *
+     * @param {Sampler2D} other
+     * @return {boolean}
+     */
+    equals(other: Sampler2D): boolean;
+    /**
+     *
+     * @return {number}
+     */
+    hash(): number;
+    /**
+     * @returns {Sampler2D}
+     */
+    clone(): Sampler2D;
+    toJSON(): {
+        height: number;
+        width: number;
+        itemSize: number;
+        type: import("../../../../core/binary/type/BinaryDataType.js").BinaryDataType;
+        data: string;
+    };
+    fromJSON({ height, width, itemSize, type, data }: {
+        height: any;
+        width: any;
+        itemSize: any;
+        type: any;
+        data: any;
+    }): void;
+    /**
+     * @deprecated use {@link write} instead
+     */
+    set: (x: number, y: number, texel: number[] | ArrayLike<number>) => void;
+    /**
+     * @readonly
+     * @type {boolean}
+     */
+    readonly isSampler2D: boolean;
+}
+export namespace Sampler2D {
+    let typeName: string;
+}
+//# sourceMappingURL=Sampler2D.d.ts.map

package/src/engine/intelligence/behavior/ecs/DieBehavior.d.ts

@@ -1,3 +1,6 @@
+/**
+ * Makes the entity destroy itself
+ */
 export class DieBehavior extends EntityBehavior {
     static create(): DieBehavior;
     tick(timeDelta: any): BehaviorStatus;

package/src/engine/intelligence/behavior/ecs/DieBehavior.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"DieBehavior.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/intelligence/behavior/ecs/DieBehavior.js"],"names":[],"mappings":"AAGA;IAGI,6BAEC;IAED,qCASC;CACJ;+BAnB8B,qBAAqB;+BADrB,sBAAsB"}
+{"version":3,"file":"DieBehavior.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/intelligence/behavior/ecs/DieBehavior.js"],"names":[],"mappings":"AAGA;;GAEG;AACH;IAGI,6BAEC;IAED,qCASC;CACJ;+BAtB8B,qBAAqB;+BADrB,sBAAsB"}

package/src/engine/intelligence/behavior/ecs/DieBehavior.js

@@ -1,6 +1,9 @@
 import { BehaviorStatus } from "../BehaviorStatus.js";
 import { EntityBehavior } from "./EntityBehavior.js";
 
+/**
+ * Makes the entity destroy itself
+ */
 export class DieBehavior extends EntityBehavior {
 
 
@@ -19,3 +22,4 @@ export class DieBehavior extends EntityBehavior {
 
     }
 }
+

package/src/engine/intelligence/behavior/ecs/KillBehavior.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Causes another entity to be destroyed
+ * Will produce a {@link BehaviorStatus.Failed} if entity could not be destroyed, either because it doesn't exist or the reference is stale
+ */
+export class KillBehavior extends EntityBehavior {
+    /**
+     *
+     * @param {EntityReference} ref
+     * @returns {KillBehavior}
+     */
+    static create(ref: EntityReference): KillBehavior;
+    tick(timeDelta: any): BehaviorStatus.Succeeded | BehaviorStatus.Failed;
+    #private;
+}
+import { EntityBehavior } from "./EntityBehavior.js";
+import { BehaviorStatus } from "../BehaviorStatus.js";
+//# sourceMappingURL=KillBehavior.d.ts.map

package/src/engine/intelligence/behavior/ecs/KillBehavior.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"KillBehavior.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/intelligence/behavior/ecs/KillBehavior.js"],"names":[],"mappings":"AAIA;;;GAGG;AACH;IAOI;;;;OAIG;IACH,mBAHW,eAAe,GACb,YAAY,CAYxB;IAED,uEAaC;;CACJ;+BA5C8B,qBAAqB;+BADrB,sBAAsB"}

package/src/engine/intelligence/behavior/ecs/KillBehavior.js

@@ -0,0 +1,47 @@
+import { assert } from "../../../../core/assert.js";
+import { BehaviorStatus } from "../BehaviorStatus.js";
+import { EntityBehavior } from "./EntityBehavior.js";
+
+/**
+ * Causes another entity to be destroyed
+ * Will produce a {@link BehaviorStatus.Failed} if entity could not be destroyed, either because it doesn't exist or the reference is stale
+ */
+export class KillBehavior extends EntityBehavior {
+
+    /**
+     * @type {EntityReference}
+     */
+    #ref;
+
+    /**
+     *
+     * @param {EntityReference} ref
+     * @returns {KillBehavior}
+     */
+    static create(ref) {
+        assert.defined(ref, 'ref');
+        assert.isObject(ref, 'ref');
+        assert.equal(ref.isEntityReference, true, 'ref.isEntityReference !== true');
+
+        const r = new KillBehavior();
+
+        r.#ref = ref;
+
+        return r;
+    }
+
+    tick(timeDelta) {
+
+        const ecd = this.ecd;
+
+        if (this.#ref.destroy(ecd)) {
+
+            return BehaviorStatus.Succeeded;
+
+        } else {
+            // couldn't find
+            return BehaviorStatus.Failed;
+
+        }
+    }
+}

package/src/engine/intelligence/blackboard/BlackboardStack.d.ts

@@ -1,6 +1,6 @@
 /**
  * Cascading blackboard interface. Allows composition of multiple blackboard to be used to represent a single whole
- * Access is always done from top to bottom. If a value is not found at the top of the stack, a lower slot will be considered until the end. In which case value will be created in the blackboard identified by "write_slot"
+ * The access is always done from top to bottom. If a value is not found at the top of the stack, a lower slot will be considered until the end. In which case value will be created in the blackboard identified by "write_slot"
  */
 export class BlackboardStack extends AbstractBlackboard {
     /**

package/src/engine/intelligence/blackboard/BlackboardStack.js

@@ -2,7 +2,7 @@ import { AbstractBlackboard } from "./AbstractBlackboard.js";
 
 /**
  * Cascading blackboard interface. Allows composition of multiple blackboard to be used to represent a single whole
- * Access is always done from top to bottom. If a value is not found at the top of the stack, a lower slot will be considered until the end. In which case value will be created in the blackboard identified by "write_slot"
+ * The access is always done from top to bottom. If a value is not found at the top of the stack, a lower slot will be considered until the end. In which case value will be created in the blackboard identified by "write_slot"
  */
 export class BlackboardStack extends AbstractBlackboard {
     constructor() {

package/src/engine/navigation/ecs/path_following/PathFollowerSerializationAdapter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"PathFollowerSerializationAdapter.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/navigation/ecs/path_following/PathFollowerSerializationAdapter.js"],"names":[],"mappings":"AAGA;IAEI,2BAAqB;IAGrB;;;;OAIG;IACH,kBAHW,YAAY,SACZ,YAAY,QAStB;IAED;;;;OAIG;IACH,oBAHW,YAAY,SACZ,YAAY,QAStB;CACJ;gDAnC+C,gEAAgE;yBACvF,mBAAmB"}
+{"version":3,"file":"PathFollowerSerializationAdapter.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/navigation/ecs/path_following/PathFollowerSerializationAdapter.js"],"names":[],"mappings":"AAGA;IAEI,2BAAqB;IAGrB;;;;OAIG;IACH,kBAHW,YAAY,SACZ,YAAY,QAUtB;IAED;;;;OAIG;IACH,oBAHW,YAAY,SACZ,YAAY,QAUtB;CACJ;gDArC+C,gEAAgE;yBACvF,mBAAmB"}

package/src/engine/navigation/ecs/path_following/PathFollowerSerializationAdapter.js

@@ -4,7 +4,7 @@ import PathFollower from "./PathFollower.js";
 export class PathFollowerSerializationAdapter extends BinaryClassSerializationAdapter {
 
     klass = PathFollower;
-    version = 3;
+    version = 4;
 
     /**
      *
@@ -18,6 +18,7 @@ export class PathFollowerSerializationAdapter extends BinaryClassSerializationAd
         buffer.writeFloat32(value.rotationSpeed.getValue());
 
         buffer.writeFloat32(value.maxMoveDistance);
+        buffer.writeFloat32(value.position); // Serialize position
     }
 
     /**
@@ -32,5 +33,6 @@ export class PathFollowerSerializationAdapter extends BinaryClassSerializationAd
         value.rotationSpeed.set(buffer.readFloat32());
 
         value.maxMoveDistance = buffer.readFloat32();
+        value.position = buffer.readFloat32(); // Deserialize position
     }
 }

package/src/engine/navigation/ecs/path_following/PathFollowerSerializationUpgrader_2_3.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"PathFollowerSerializationUpgrader_2_3.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/navigation/ecs/path_following/PathFollowerSerializationUpgrader_2_3.js"],"names":[],"mappings":"AAGA;IAQI,wCAWC;CACJ;oCAvBmC,oDAAoD"}
+{"version":3,"file":"PathFollowerSerializationUpgrader_2_3.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/navigation/ecs/path_following/PathFollowerSerializationUpgrader_2_3.js"],"names":[],"mappings":"AAGA;IAII,wCAWC;CACJ;oCAlBmC,oDAAoD"}