@woosh/meep-engine 2.75.8 → 2.75.9

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

@@ -3,20 +3,20 @@
  */
 
 
-import { clamp } from "../../../../core/math/clamp.js";
-import { max2 } from "../../../../core/math/max2.js";
-import { min2 } from "../../../../core/math/min2.js";
-import { mix } from "../../../../core/math/mix.js";
-import { BlendingType } from "./BlendingType.js";
 import { assert } from "../../../../core/assert.js";
-import { typedArrayConstructorByInstance } from "./typedArrayConstructorByInstance.js";
-import { typedArrayToDataType } from "../../../../core/collection/array/typed/typedArrayToDataType.js";
+import { Base64 } from "../../../../core/binary/Base64.js";
 import {
     compute_typed_array_constructor_from_data_type
 } from "../../../../core/binary/type/DataType2TypedArrayConstructorMapping.js";
-import { Base64 } from "../../../../core/binary/Base64.js";
-import { computeStridedIntegerArrayHash } from "../../../../core/primitives/array/computeStridedIntegerArrayHash.js";
 import { is_typed_array_equals } from "../../../../core/collection/array/typed/is_typed_array_equals.js";
+import { typedArrayToDataType } from "../../../../core/collection/array/typed/typedArrayToDataType.js";
+import { clamp } from "../../../../core/math/clamp.js";
+import { max2 } from "../../../../core/math/max2.js";
+import { min2 } from "../../../../core/math/min2.js";
+import { mix } from "../../../../core/math/mix.js";
+import { interpolate_bicubic } from "../../../../core/math/spline/interpolate_bicubic.js";
+import { computeStridedIntegerArrayHash } from "../../../../core/primitives/array/computeStridedIntegerArrayHash.js";
+import { typedArrayConstructorByInstance } from "./typedArrayConstructorByInstance.js";
 
 /**
  * Data Texture class, providing an abstraction around 2d numerical arrays, mostly for sampling purposes
@@ -82,35 +82,6 @@ export class Sampler2D {
         this.version = 0;
     }
 
-    /**
-     * @deprecated
-     * @param {number} [channel=0]
-     * @returns {{x: number, index: number, y: number, value: number}}
-     */
-    computeMax(channel = 0) {
-        throw new Error("deprecated, use sampler2d_channel_compute_max");
-    }
-
-    /**
-     * @deprecated
-     * @param {number[]} result
-     * @param {number} result_offset
-     * @param {number} [channel=0]
-     * @returns {number} number of matches written to result array
-     */
-    computeMinIndices(result, result_offset = 0, channel = 0) {
-        throw new Error("deprecated, use sampler2d_channel_compute_min_indices")
-    }
-
-    /**
-     * @deprecated
-     * @param {number} [channel=0]
-     * @returns {{x: number, index: number, y: number, value: number}}
-     */
-    computeMin(channel = 0) {
-        throw new Error("deprecated, use sampler2d_channel_compute_min");
-    }
-
     /**
      *
      * @deprecated
@@ -120,18 +91,7 @@ export class Sampler2D {
      * @returns {number}
      */
     get(x, y, result) {
-        console.warn("Deprecated method, use sampleBilinear instead");
-
-        const t = [];
-
-        this.sampleBilinear(x, y, t, 0);
-
-        if (result !== undefined) {
-            result.readFromArray(t, 0);
-            return result;
-        } else {
-            return t[0];
-        }
+        throw new Error("Deprecated method, use sampleBilinear instead");
     }
 
     /**
@@ -334,23 +294,14 @@ export class Sampler2D {
         const vl2 = data[row3_address + col2_offset];
         const vl3 = data[row3_address + col3_offset];
 
-
-        // return bicubic(xd, yd,
-        //     vi0, vi1, vi2, vi3,
-        //     vj0, vj1, vj2, vj3,
-        //     vk0, vk1, vk2, vk3,
-        //     vl0, vl1, vl2, vl3,
-        // );
-
-
         // perform filtering in X (rows)
-        const s0 = bicubic_terp(xd, vi0, vi1, vi2, vi3);
-        const s1 = bicubic_terp(xd, vj0, vj1, vj2, vj3);
-        const s2 = bicubic_terp(xd, vk0, vk1, vk2, vk3);
-        const s3 = bicubic_terp(xd, vl0, vl1, vl2, vl3);
+        const s0 = interpolate_bicubic(xd, vi0, vi1, vi2, vi3);
+        const s1 = interpolate_bicubic(xd, vj0, vj1, vj2, vj3);
+        const s2 = interpolate_bicubic(xd, vk0, vk1, vk2, vk3);
+        const s3 = interpolate_bicubic(xd, vl0, vl1, vl2, vl3);
 
         // filter in Y (columns)
-        return bicubic_terp(yd, s0, s1, s2, s3);
+        return interpolate_bicubic(yd, s0, s1, s2, s3);
     }
 
     /**
@@ -589,162 +540,6 @@ export class Sampler2D {
         result.set(x, y);
     }
 
-    /**
-     * Copy a patch from another sampler with a margin.
-     * This is useful for texture rendering where filtering can cause bleeding along the edges of the patch.
-     * @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
-     * @param {Number} marginLeft
-     * @param {Number} marginRight
-     * @param {Number} marginTop
-     * @param {Number} marginBottom
-     */
-    copyWithMargin(source, sourceX, sourceY, destinationX, destinationY, width, height, marginLeft, marginRight, marginTop, marginBottom) {
-        const dItemSize = this.itemSize;
-        const sItemSize = source.itemSize;
-        const _itemSize = Math.min(dItemSize, sItemSize);
-
-
-        const dRowSize = dItemSize * this.width;
-        const sRowSize = sItemSize * source.width;
-
-        const sData = source.data;
-        const dData = this.data;
-
-        let x, y, i, j;
-
-        let xMax, yMax;
-
-        let dA, sA, dOffset, sOffset;
-        //Write top-left corner
-        sOffset = sourceY * sRowSize + sourceX * dItemSize;
-        for (y = Math.max(0, destinationY - marginTop), yMax = destinationY; y < yMax; y++) {
-            dA = y * dRowSize;
-
-            for (x = Math.max(0, destinationX - marginLeft), xMax = destinationX; x < xMax; x++) {
-
-                dOffset = dA + x * dItemSize;
-
-                for (i = 0; i < _itemSize; i++) {
-                    dData[dOffset + i] = sData[sOffset + i];
-                }
-            }
-        }
-        //Write top margin
-        sA = sourceY * sRowSize;
-        for (y = Math.max(0, destinationY - marginTop), yMax = destinationY; y < yMax; y++) {
-            dA = y * dRowSize;
-
-            for (x = 0; x < width; x++) {
-
-                dOffset = dA + (x + destinationX) * dItemSize;
-                sOffset = sA + (x + sourceX) * dItemSize;
-                for (i = 0; i < _itemSize; i++) {
-                    dData[dOffset + i] = sData[sOffset + i];
-                }
-            }
-        }
-        //Write top-right corner
-        sOffset = sourceY * sRowSize + (sourceX + width - 1) * dItemSize;
-        for (y = Math.max(0, destinationY - marginTop), yMax = destinationY; y < yMax; y++) {
-            dA = y * dRowSize;
-
-            for (x = destinationX + width, xMax = Math.min(this.width, x + marginRight); x < xMax; x++) {
-
-                dOffset = dA + x * dItemSize;
-
-                for (i = 0; i < _itemSize; i++) {
-                    dData[dOffset + i] = sData[sOffset + i];
-                }
-            }
-        }
-        //Write left margin
-        for (y = 0; y < height; y++) {
-            dA = (y + destinationY) * dRowSize;
-            sA = (y + sourceY) * sRowSize;
-
-            sOffset = sA + (sourceX) * dItemSize;
-
-            for (x = Math.max(0, destinationX - marginLeft), xMax = destinationX; x < xMax; x++) {
-
-                dOffset = dA + x * dItemSize;
-
-                for (i = 0; i < _itemSize; i++) {
-                    dData[dOffset + i] = sData[sOffset + i];
-                }
-            }
-        }
-        //write actual patch
-        this.copy(source, sourceX, sourceY, destinationX, destinationY, width, height);
-
-        //Write right margin
-        for (y = 0; y < height; y++) {
-            dA = (y + destinationY) * dRowSize;
-            sA = (y + sourceY) * sRowSize;
-
-            sOffset = sA + (sourceX + width - 1) * dItemSize;
-
-            for (x = destinationX + width, xMax = Math.min(this.width, x + marginRight); x < xMax; x++) {
-
-                dOffset = dA + x * dItemSize;
-
-                for (i = 0; i < _itemSize; i++) {
-                    dData[dOffset + i] = sData[sOffset + i];
-                }
-            }
-        }
-
-        //Write Bottom-left margin
-        sOffset = (sourceY + height - 1) * sRowSize + sourceX * dItemSize;
-        for (y = destinationY + width, yMax = Math.min(this.height, y + marginBottom); y < yMax; y++) {
-            dA = y * dRowSize;
-
-            for (x = Math.max(0, destinationX - marginLeft), xMax = destinationX; x < xMax; x++) {
-
-                dOffset = dA + x * dItemSize;
-
-                for (i = 0; i < _itemSize; i++) {
-                    dData[dOffset + i] = sData[sOffset + i];
-                }
-            }
-        }
-        //Write Bottom margin
-        sA = (sourceY + height - 1) * sRowSize;
-        for (y = destinationY + width, yMax = Math.min(this.height, y + marginBottom); y < yMax; y++) {
-            dA = y * dRowSize;
-
-            for (x = 0; x < width; x++) {
-
-                dOffset = dA + (x + destinationX) * dItemSize;
-                sOffset = sA + (x + sourceX) * dItemSize;
-                for (i = 0; i < _itemSize; i++) {
-                    dData[dOffset + i] = sData[sOffset + i];
-                }
-            }
-        }
-        //Write Bottom-right margin
-        sOffset = (sourceY + height - 1) * sRowSize + (sourceX + width - 1) * dItemSize;
-        for (y = destinationY + width, yMax = Math.min(this.height, y + marginBottom); y < yMax; y++) {
-            dA = y * dRowSize;
-
-            for (x = destinationX + width, xMax = Math.min(this.width, x + marginRight); x < xMax; x++) {
-
-                dOffset = dA + x * dItemSize;
-
-                for (i = 0; i < _itemSize; i++) {
-                    dData[dOffset + i] = sData[sOffset + i];
-                }
-            }
-        }
-
-        this.version++;
-    }
-
     /**
      * Copy a patch from another sampler
      * @param {Sampler2D} source where to copy from
@@ -801,106 +596,6 @@ export class Sampler2D {
         this.version++;
     }
 
-    /**
-     * Copy a patch from another sampler with the same itemSize
-     * @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_sameItemSize(source, sourceX, sourceY, destinationX, destinationY, width, height) {
-        const itemSize = this.itemSize;
-        const sItemSize = source.itemSize;
-
-        assert.equal(sItemSize, sItemSize, `source.itemSize(=${sItemSize}) != this.itemSize(=${itemSize})`);
-
-        const _w = Math.min(width, source.width - sourceX, this.width - destinationX);
-        const _h = Math.min(height, source.height - sourceY, this.height - destinationY);
-
-
-        const dRowSize = itemSize * this.width;
-        const sRowSize = itemSize * source.width;
-
-        const sData = source.data;
-        const dData = this.data;
-
-        const patchRowSize = _w * itemSize;
-
-        let y, i;
-
-        for (y = 0; y < _h; y++) {
-            const dA = (y + destinationY) * dRowSize;
-            const sA = (y + sourceY) * sRowSize;
-
-            const dOffset = dA + destinationX * itemSize;
-            const sOffset = sA + sourceX * itemSize;
-
-            for (i = 0; i < patchRowSize; i++) {
-
-                dData[dOffset + i] = sData[sOffset + i];
-
-            }
-        }
-
-        this.version++;
-    }
-
-    /**
-     * Assumes both samplers are uint8 with values 0-255
-     * @param {Sampler2D} source
-     * @param sourceX
-     * @param sourceY
-     * @param destinationX
-     * @param destinationY
-     * @param width
-     * @param height
-     * @param {BlendingType} [blendMode]
-     */
-    paint(source, sourceX, sourceY, destinationX, destinationY, width, height, blendMode = BlendingType.Normal) {
-        let blendFunction;
-        if (blendMode === BlendingType.Normal) {
-            blendFunction = blendFunctionNormal;
-        } else {
-            throw new Error(`Unsupported blendType(=${blendMode})`);
-        }
-
-        const _w = Math.min(width, source.width - sourceX, this.width - destinationX);
-        const _h = Math.min(height, source.height - sourceY, this.height - destinationY);
-
-        const _x0 = Math.max(0, -destinationX);
-        const _y0 = Math.max(0, -destinationY);
-
-        const c0 = [0, 0, 0, 255];
-        const c1 = [0, 0, 0, 255];
-
-        const c3 = [];
-
-        let x, y;
-
-        for (y = _y0; y < _h; y++) {
-            for (x = _x0; x < _w; x++) {
-                const d_x = Math.round(x + destinationX);
-                const d_y = Math.round(y + destinationY);
-
-                this.read(d_x, d_y, c0);
-
-                const s_x = Math.round(x + sourceY);
-                const s_y = Math.round(y + sourceY);
-
-                source.read(s_x, s_y, c1);
-
-                blendFunction(c1, c0, c3);
-
-                this.set(d_x, d_y, c3);
-
-            }
-        }
-
-
-    }
 
     /**
      * Fill data values with zeros for a given area
@@ -1161,22 +856,6 @@ export class Sampler2D {
         return dataSize + 280;
     }
 
-    /**
-     * @deprecated Use {@link Sampler2DSerializationAdapter} adapter instead
-     * @param {BinaryBuffer} buffer
-     */
-    toBinaryBuffer(buffer) {
-        throw new Error('Deprecated, use Sampler2DSerializationAdapter instead');
-    }
-
-    /**
-     * @deprecated Use {@link Sampler2DSerializationAdapter} adapter instead
-     * @param {BinaryBuffer} buffer
-     */
-    fromBinaryBuffer(buffer) {
-        throw new Error('Deprecated, use Sampler2DSerializationAdapter instead');
-    }
-
     /**
      *
      * @param {Sampler2D} other
@@ -1389,35 +1068,5 @@ Sampler2D.prototype.isSampler2D = true;
  */
 Sampler2D.typeName = "Sampler2D";
 
-/**
- * Based on code from reddit https://www.reddit.com/r/javascript/comments/jxa8x/bicubic_interpolation/
- * @param {number} t
- * @param {number} a
- * @param {number} b
- * @param {number} c
- * @param {number} d
- * @returns {number}
- */
-function bicubic_terp(t, a, b, c, d) {
-    return 0.5 * (c - a + (2.0 * a - 5.0 * b + 4.0 * c - d + (3.0 * (b - c) + d - a) * t) * t) * t + b;
-}
-
-
-/**
- *
- * @param {number[]} source
- * @param {number[]} destination
- * @param {Array} result
- */
-function blendFunctionNormal(source, destination, result) {
-
-    const a1 = source[3] / 255;
-    const a0 = destination[3] / 255;
-
-    result[0] = source[0] * a1 + destination[0] * (1 - a1);
-    result[1] = source[1] * a1 + destination[1] * (1 - a1);
-    result[2] = source[2] * a1 + destination[2] * (1 - a1);
-    result[3] = (a1 + a0 * (1 - a1)) * 255;
-}
 
 

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

@@ -222,34 +222,3 @@ describe("copy method", () => {
         expect(target.readChannel(1, 1, 0)).toBe(2);
     });
 });
-
-describe("copyWithMargin method", () => {
-    test("one texel patch with 1 texel margin all around", () => {
-        const target = Sampler2D.uint8(1, 3, 3);
-        target.data[0] = 1;
-
-        const source = Sampler2D.uint8(1, 1, 1);
-        source.data[0] = 2;
-
-        target.copyWithMargin(source, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1);
-
-        //top left
-        expect(target.readChannel(0, 0, 0)).toEqual(2);
-        //top
-        expect(target.readChannel(1, 0, 0)).toEqual(2);
-        //top right
-        expect(target.readChannel(2, 0, 0)).toEqual(2);
-        //left
-        expect(target.readChannel(0, 1, 0)).toEqual(2);
-        //copied region
-        expect(target.readChannel(1, 1, 0)).toEqual(2);
-        //right
-        expect(target.readChannel(2, 1, 0)).toEqual(2);
-        //bottom left
-        expect(target.readChannel(0, 2, 0)).toEqual(2);
-        //bottom
-        expect(target.readChannel(1, 2, 0)).toEqual(2);
-        //bottom right
-        expect(target.readChannel(2, 2, 0)).toEqual(2);
-    });
-});

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

@@ -0,0 +1,166 @@
+/**
+ * Copy a patch from another sampler with a margin.
+ * This is useful for texture rendering where filtering can cause bleeding along the edges of the patch.
+ * @param {Sampler2D} destination
+ * @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
+ * @param {Number} marginLeft
+ * @param {Number} marginRight
+ * @param {Number} marginTop
+ * @param {Number} marginBottom
+ */
+export function sampler2d_copy_with_margins(
+    destination,
+    source,
+    sourceX, sourceY,
+    destinationX, destinationY,
+    width, height,
+    marginLeft,
+    marginRight,
+    marginTop,
+    marginBottom
+) {
+    const dItemSize = destination.itemSize;
+    const sItemSize = source.itemSize;
+    const _itemSize = Math.min(dItemSize, sItemSize);
+
+
+    const dRowSize = dItemSize * destination.width;
+    const sRowSize = sItemSize * source.width;
+
+    const sData = source.data;
+    const dData = destination.data;
+
+    let x, y, i;
+
+    let xMax, yMax;
+
+    let dA, sA, dOffset, sOffset;
+    //Write top-left corner
+    sOffset = sourceY * sRowSize + sourceX * dItemSize;
+    for (y = Math.max(0, destinationY - marginTop), yMax = destinationY; y < yMax; y++) {
+        dA = y * dRowSize;
+
+        for (x = Math.max(0, destinationX - marginLeft), xMax = destinationX; x < xMax; x++) {
+
+            dOffset = dA + x * dItemSize;
+
+            for (i = 0; i < _itemSize; i++) {
+                dData[dOffset + i] = sData[sOffset + i];
+            }
+        }
+    }
+    //Write top margin
+    sA = sourceY * sRowSize;
+    for (y = Math.max(0, destinationY - marginTop), yMax = destinationY; y < yMax; y++) {
+        dA = y * dRowSize;
+
+        for (x = 0; x < width; x++) {
+
+            dOffset = dA + (x + destinationX) * dItemSize;
+            sOffset = sA + (x + sourceX) * dItemSize;
+            for (i = 0; i < _itemSize; i++) {
+                dData[dOffset + i] = sData[sOffset + i];
+            }
+        }
+    }
+    //Write top-right corner
+    sOffset = sourceY * sRowSize + (sourceX + width - 1) * dItemSize;
+    for (y = Math.max(0, destinationY - marginTop), yMax = destinationY; y < yMax; y++) {
+        dA = y * dRowSize;
+
+        for (x = destinationX + width, xMax = Math.min(destination.width, x + marginRight); x < xMax; x++) {
+
+            dOffset = dA + x * dItemSize;
+
+            for (i = 0; i < _itemSize; i++) {
+                dData[dOffset + i] = sData[sOffset + i];
+            }
+        }
+    }
+    //Write left margin
+    for (y = 0; y < height; y++) {
+        dA = (y + destinationY) * dRowSize;
+        sA = (y + sourceY) * sRowSize;
+
+        sOffset = sA + (sourceX) * dItemSize;
+
+        for (x = Math.max(0, destinationX - marginLeft), xMax = destinationX; x < xMax; x++) {
+
+            dOffset = dA + x * dItemSize;
+
+            for (i = 0; i < _itemSize; i++) {
+                dData[dOffset + i] = sData[sOffset + i];
+            }
+        }
+    }
+    //write actual patch
+    destination.copy(source, sourceX, sourceY, destinationX, destinationY, width, height);
+
+    //Write right margin
+    for (y = 0; y < height; y++) {
+        dA = (y + destinationY) * dRowSize;
+        sA = (y + sourceY) * sRowSize;
+
+        sOffset = sA + (sourceX + width - 1) * dItemSize;
+
+        for (x = destinationX + width, xMax = Math.min(destination.width, x + marginRight); x < xMax; x++) {
+
+            dOffset = dA + x * dItemSize;
+
+            for (i = 0; i < _itemSize; i++) {
+                dData[dOffset + i] = sData[sOffset + i];
+            }
+        }
+    }
+
+    //Write Bottom-left margin
+    sOffset = (sourceY + height - 1) * sRowSize + sourceX * dItemSize;
+    for (y = destinationY + width, yMax = Math.min(destination.height, y + marginBottom); y < yMax; y++) {
+        dA = y * dRowSize;
+
+        for (x = Math.max(0, destinationX - marginLeft), xMax = destinationX; x < xMax; x++) {
+
+            dOffset = dA + x * dItemSize;
+
+            for (i = 0; i < _itemSize; i++) {
+                dData[dOffset + i] = sData[sOffset + i];
+            }
+        }
+    }
+    //Write Bottom margin
+    sA = (sourceY + height - 1) * sRowSize;
+    for (y = destinationY + width, yMax = Math.min(destination.height, y + marginBottom); y < yMax; y++) {
+        dA = y * dRowSize;
+
+        for (x = 0; x < width; x++) {
+
+            dOffset = dA + (x + destinationX) * dItemSize;
+            sOffset = sA + (x + sourceX) * dItemSize;
+            for (i = 0; i < _itemSize; i++) {
+                dData[dOffset + i] = sData[sOffset + i];
+            }
+        }
+    }
+    //Write Bottom-right margin
+    sOffset = (sourceY + height - 1) * sRowSize + (sourceX + width - 1) * dItemSize;
+    for (y = destinationY + width, yMax = Math.min(destination.height, y + marginBottom); y < yMax; y++) {
+        dA = y * dRowSize;
+
+        for (x = destinationX + width, xMax = Math.min(destination.width, x + marginRight); x < xMax; x++) {
+
+            dOffset = dA + x * dItemSize;
+
+            for (i = 0; i < _itemSize; i++) {
+                dData[dOffset + i] = sData[sOffset + i];
+            }
+        }
+    }
+
+    destination.version++;
+}

package/src/engine/graphics/texture/sampler/sampler2d_copy_with_margins.spec.js

@@ -0,0 +1,31 @@
+import { Sampler2D } from "./Sampler2D.js";
+import { sampler2d_copy_with_margins } from "./sampler2d_copy_with_margins.js";
+
+test("one texel patch with 1 texel margin all around", () => {
+    const target = Sampler2D.uint8(1, 3, 3);
+    target.data[0] = 1;
+
+    const source = Sampler2D.uint8(1, 1, 1);
+    source.data[0] = 2;
+
+    sampler2d_copy_with_margins(target, source, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1);
+
+    //top left
+    expect(target.readChannel(0, 0, 0)).toEqual(2);
+    //top
+    expect(target.readChannel(1, 0, 0)).toEqual(2);
+    //top right
+    expect(target.readChannel(2, 0, 0)).toEqual(2);
+    //left
+    expect(target.readChannel(0, 1, 0)).toEqual(2);
+    //copied region
+    expect(target.readChannel(1, 1, 0)).toEqual(2);
+    //right
+    expect(target.readChannel(2, 1, 0)).toEqual(2);
+    //bottom left
+    expect(target.readChannel(0, 2, 0)).toEqual(2);
+    //bottom
+    expect(target.readChannel(1, 2, 0)).toEqual(2);
+    //bottom right
+    expect(target.readChannel(2, 2, 0)).toEqual(2);
+});