@woosh/meep-engine 2.39.0 → 2.39.3

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

@@ -10,1651 +10,1677 @@ 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/typedArrayToDataType.js";
+import {
+    compute_typed_array_constructor_from_data_type
+} from "../../../../core/collection/table/DataType2TypedArrayConstructorMapping.js";
 
 /**
- *
- * @param {ArrayLike<number>|number[]|Uint8ClampedArray|Uint8Array|Uint16Array|Uint32Array|Int8Array|Int16Array|Int32Array|Float32Array|Float64Array} data
- * @param {int} itemSize
- * @param {int} width
- * @param {int} height
- * @constructor
+ * @class
  */
-export function Sampler2D(data = [], itemSize = 1, width = 0, height = 0) {
-    if (!Number.isInteger(itemSize)) {
-        throw new Error(`itemSize must be integer, instead was ${itemSize}`);
-    }
-    if (!Number.isInteger(width)) {
-        throw new Error(`width must be integer, instead was ${width}`);
-    }
-    if (!Number.isInteger(height)) {
-        throw new Error(`height must be integer, instead was ${height}`);
-    }
-
-    if (data === undefined) {
-        throw new Error("data was undefined");
-    }
-
-    /**
-     *
-     * @type {Number}
-     */
-    this.width = width;
-
+export class Sampler2D {
     /**
      *
-     * @type {Number}
+     * @param {ArrayLike<number>|number[]|Uint8ClampedArray|Uint8Array|Uint16Array|Uint32Array|Int8Array|Int16Array|Int32Array|Float32Array|Float64Array} data
+     * @param {int} itemSize
+     * @param {int} width
+     * @param {int} height
+     * @constructor
      */
-    this.height = height;
+    constructor(data = [], itemSize = 1, width = 0, height = 0) {
+        if (!Number.isInteger(itemSize)) {
+            throw new Error(`itemSize must be integer, instead was ${itemSize}`);
+        }
+        if (!Number.isInteger(width)) {
+            throw new Error(`width must be integer, instead was ${width}`);
+        }
+        if (!Number.isInteger(height)) {
+            throw new Error(`height must be integer, instead was ${height}`);
+        }
 
-    /**
-     * Number of channels
-     * @type {Number}
-     */
-    this.itemSize = itemSize;
+        if (data === undefined) {
+            throw new Error("data was undefined");
+        }
 
-    /**
-     *
-     * @type {number[]|Uint8ClampedArray|Uint8Array|Uint16Array|Uint32Array|Int8Array|Int16Array|Int32Array|Float32Array|Float64Array}
-     */
-    this.data = data;
+        /**
+         *
+         * @type {Number}
+         */
+        this.width = width;
+
+        /**
+         *
+         * @type {Number}
+         */
+        this.height = height;
+
+        /**
+         * Number of channels
+         * @type {Number}
+         */
+        this.itemSize = itemSize;
+
+        /**
+         *
+         * @type {number[]|Uint8ClampedArray|Uint8Array|Uint16Array|Uint32Array|Int8Array|Int16Array|Int32Array|Float32Array|Float64Array}
+         */
+        this.data = data;
+
+        /**
+         * Used to tracking changes
+         * @type {number}
+         */
+        this.version = 0;
+        /**
+         * @readonly
+         * @type {boolean}
+         */
+        this.isSampler2D = true;
+    }
 
     /**
-     * Used to tracking changes
-     * @type {number}
+     * @param {number} [channel=0]
+     * @returns {{x: number, index: number, y: number, value: number}}
      */
-    this.version = 0;
-}
-
-/**
- *
- * @param {int} itemSize
- * @param {int} width
- * @param {int} height
- * @return {Sampler2D}
- */
-Sampler2D.uint8clamped = function (itemSize, width, height) {
-    const data = new Uint8ClampedArray(width * height * itemSize);
-    const sampler = new Sampler2D(data, itemSize, width, height);
-    return sampler;
-};
-
-/**
- *
- * @param {int} itemSize
- * @param {int} width
- * @param {int} height
- * @return {Sampler2D}
- */
-Sampler2D.uint8 = function (itemSize, width, height) {
-    const data = new Uint8Array(width * height * itemSize);
-    const sampler = new Sampler2D(data, itemSize, width, height);
-    return sampler;
-};
-
-/**
- *
- * @param {int} itemSize
- * @param {int} width
- * @param {int} height
- * @return {Sampler2D}
- */
-Sampler2D.uint16 = function (itemSize, width, height) {
-    const data = new Uint16Array(width * height * itemSize);
-    const sampler = new Sampler2D(data, itemSize, width, height);
-    return sampler;
-};
-
-/**
- *
- * @param {int} itemSize
- * @param {int} width
- * @param {int} height
- * @return {Sampler2D}
- */
-Sampler2D.uint32 = function (itemSize, width, height) {
-    const data = new Uint32Array(width * height * itemSize);
-    const sampler = new Sampler2D(data, itemSize, width, height);
-    return sampler;
-};
+    computeMax(channel = 0) {
+        const itemSize = this.itemSize;
 
-/**
- *
- * @param {int} itemSize
- * @param {int} width
- * @param {int} height
- * @return {Sampler2D}
- */
-Sampler2D.int8 = function (itemSize, width, height) {
-    const data = new Int8Array(width * height * itemSize);
-    const sampler = new Sampler2D(data, itemSize, width, height);
-    return sampler;
-};
-
-/**
- *
- * @param {int} itemSize
- * @param {int} width
- * @param {int} height
- * @return {Sampler2D}
- */
-Sampler2D.int16 = function (itemSize, width, height) {
-    const data = new Int16Array(width * height * itemSize);
-    const sampler = new Sampler2D(data, itemSize, width, height);
-    return sampler;
-};
-/**
- *
- * @param {int} itemSize
- * @param {int} width
- * @param {int} height
- * @return {Sampler2D}
- */
-Sampler2D.int32 = function (itemSize, width, height) {
-    const data = new Int32Array(width * height * itemSize);
-    const sampler = new Sampler2D(data, itemSize, width, height);
-    return sampler;
-};
+        assert.typeOf(channel, "number", "channel");
+        assert.ok(channel >= 0, `channel must be >= 0, was ${channel}`);
+        assert.ok(channel < itemSize, `channel must be less than itemSize(=${itemSize}), was ${channel}`);
 
-/**
- *
- * @param {int} itemSize
- * @param {int} width
- * @param {int} height
- * @return {Sampler2D}
- */
-Sampler2D.float32 = function (itemSize, width, height) {
-    const data = new Float32Array(width * height * itemSize);
-    const sampler = new Sampler2D(data, itemSize, width, height);
-    return sampler;
-};
-/**
- *
- * @param {int} itemSize
- * @param {int} width
- * @param {int} height
- * @return {Sampler2D}
- */
-Sampler2D.float64 = function (itemSize, width, height) {
-    const data = new Float64Array(width * height * itemSize);
-    const sampler = new Sampler2D(data, itemSize, width, height);
-    return sampler;
-};
+        const data = this.data;
 
-/**
- *
- * @param {Sampler2D} input0
- * @param {Sampler2D} input1
- * @param {Sampler2D} result
- * @param {function( value0 : number[], value1 : number[], result : number[], index : number) : void} operation
- */
-Sampler2D.combine = function (input0, input1, result, operation) {
-    assert.notEqual(input0, undefined, "input0 is undefined");
-    assert.notEqual(input1, undefined, "input1 is undefined");
-    assert.notEqual(result, undefined, "result is undefined");
+        const l = data.length;
 
-    assert.typeOf(operation, "function", "operation");
+        if (l === 0) {
+            //no data
+            return undefined;
+        }
 
-    assert.equal(input0.width, input1.width, `input0.width(=${input0.width}) is not equal to input1.width(=${input1.width})`);
-    assert.equal(input0.height, input1.height, `input0.height(=${input0.height}) is not equal to input1.height(=${input1.height})`);
+        let bestValue = data[channel];
+        let bestIndex = channel;
 
-    assert.equal(input0.width, result.width, `input width(=${input0.width}) is not equal to result.width(=${result.width})`);
-    assert.equal(input0.height, result.height, `input height(=${input0.height}) is not equal to result.height(=${result.height})`);
+        for (let i = channel + itemSize; i < l; i += itemSize) {
+            const value = data[i];
 
-    const width = input0.width;
-    const height = input0.height;
+            if (bestValue < value) {
+                bestValue = value;
+                bestIndex = i;
+            }
 
-    const length = width * height;
+        }
 
-    const arg0 = [];
-    const arg1 = [];
-    const res = [];
+        const width = this.width;
 
-    const itemSize0 = input0.itemSize;
-    const itemSize1 = input1.itemSize;
-    const itemSizeR = result.itemSize;
+        const itemIndex = (bestIndex / this.itemSize) | 0;
 
-    const data0 = input0.data;
-    const data1 = input1.data;
-    const dataR = result.data;
+        const x = itemIndex % width;
+        const y = (itemIndex / width) | 0;
 
+        return {
+            index: bestIndex,
+            value: bestValue,
+            x,
+            y
+        };
+    }
 
-    let i, j;
+    /**
+     * @param {number[]} result
+     * @param {number} [channel=0]
+     */
+    computeMinIndices(result, channel = 0) {
+        const itemSize = this.itemSize;
 
-    for (i = 0; i < length; i++) {
+        assert.typeOf(channel, "number", "channel");
+        assert.ok(channel >= 0, `channel must be >= 0, was ${channel}`);
+        assert.ok(channel < itemSize, `channel must be less than itemSize(=${itemSize}), was ${channel}`);
 
-        // read input 0
-        for (j = 0; j < itemSize0; j++) {
-            arg0[j] = data0[j + i * itemSize0];
-        }
+        assert.ok(Array.isArray(result), "result is not an array");
 
-        // read input 1
-        for (j = 0; j < itemSize0; j++) {
-            arg1[j] = data1[j + i * itemSize1];
-        }
+        const data = this.data;
 
-        //perform operation
-        operation(arg0, arg1, res, i);
+        const l = data.length;
 
-        //write result
-        for (j = 0; j < itemSizeR; j++) {
-            dataR[j + i * itemSizeR] = res[j];
+        if (l === 0) {
+            //no data
+            return undefined;
         }
 
-    }
+        let bestValue = data[channel];
 
-    result.version++;
-};
+        let resultCount = 0;
 
+        for (let i = channel + itemSize; i < l; i += itemSize) {
+            const value = data[i];
 
-/**
- * @param {number} [channel=0]
- * @returns {{x: number, index: number, y: number, value: number}}
- */
-Sampler2D.prototype.computeMax = function (channel = 0) {
-    const itemSize = this.itemSize;
+            if (bestValue > value) {
+                bestValue = value;
+                //drop result
+                resultCount = 1;
 
-    assert.typeOf(channel, "number", "channel");
-    assert.ok(channel >= 0, `channel must be >= 0, was ${channel}`);
-    assert.ok(channel < itemSize, `channel must be less than itemSize(=${itemSize}), was ${channel}`);
+                result[0] = i;
+            } else if (value === bestValue) {
+                result[resultCount++] = i;
+            }
 
-    const data = this.data;
+        }
 
-    const l = data.length;
+        //crop results
+        if (resultCount < result.length) {
+            result.splice(resultCount, result.length - resultCount);
+        }
 
-    if (l === 0) {
-        //no data
-        return undefined;
+        return;
     }
 
-    let bestValue = data[channel];
-    let bestIndex = channel;
+    /**
+     * @param {number} [channel=0]
+     * @returns {{x: number, index: number, y: number, value: number}}
+     */
+    computeMin(channel = 0) {
+        const itemSize = this.itemSize;
 
-    for (let i = channel + itemSize; i < l; i += itemSize) {
-        const value = data[i];
+        assert.typeOf(channel, "number", "channel");
+        assert.ok(channel >= 0, `channel must be >= 0, was ${channel}`);
+        assert.ok(channel < itemSize, `channel must be less than itemSize(=${itemSize}), was ${channel}`);
 
-        if (bestValue < value) {
-            bestValue = value;
-            bestIndex = i;
-        }
+        const data = this.data;
 
-    }
+        const l = data.length;
 
-    const width = this.width;
-
-    const itemIndex = (bestIndex / this.itemSize) | 0;
+        if (l === 0) {
+            //no data
+            return undefined;
+        }
 
-    const x = itemIndex % width;
-    const y = (itemIndex / width) | 0;
+        let bestValue = data[channel];
+        let bestIndex = channel;
 
-    return {
-        index: bestIndex,
-        value: bestValue,
-        x,
-        y
-    };
-};
+        for (let i = channel + itemSize; i < l; i += itemSize) {
+            const value = data[i];
 
-/**
- * @param {number[]} result
- * @param {number} [channel=0]
- */
-Sampler2D.prototype.computeMinIndices = function (result, channel = 0) {
-    const itemSize = this.itemSize;
+            if (bestValue > value) {
+                bestValue = value;
+                bestIndex = i;
+            }
 
-    assert.typeOf(channel, "number", "channel");
-    assert.ok(channel >= 0, `channel must be >= 0, was ${channel}`);
-    assert.ok(channel < itemSize, `channel must be less than itemSize(=${itemSize}), was ${channel}`);
+        }
 
-    assert.ok(Array.isArray(result), "result is not an array");
+        const width = this.width;
 
-    const data = this.data;
+        const itemIndex = (bestIndex / this.itemSize) | 0;
 
-    const l = data.length;
+        const x = itemIndex % width;
+        const y = (itemIndex / width) | 0;
 
-    if (l === 0) {
-        //no data
-        return undefined;
+        return {
+            index: bestIndex,
+            value: bestValue,
+            x,
+            y
+        };
     }
 
-    let bestValue = data[channel];
-
-    let resultCount = 0;
+    /**
+     *
+     * @deprecated
+     * @param {number} x
+     * @param {number}y
+     * @param {Vector1|Vector2|Vector3|Vector4} result
+     * @returns {number}
+     */
+    get(x, y, result) {
+        console.warn("Deprecated method, use sampleBilinear instead");
 
-    for (let i = channel + itemSize; i < l; i += itemSize) {
-        const value = data[i];
+        const t = [];
 
-        if (bestValue > value) {
-            bestValue = value;
-            //drop result
-            resultCount = 1;
+        this.sampleBilinear(x, y, t, 0);
 
-            result[0] = i;
-        } else if (value === bestValue) {
-            result[resultCount++] = i;
+        if (result !== undefined) {
+            result.readFromArray(t, 0);
+            return result;
+        } else {
+            return t[0];
         }
-
-    }
-
-    //crop results
-    if (resultCount < result.length) {
-        result.splice(resultCount, result.length - resultCount);
     }
 
-    return;
-};
+    /**
+     *
+     * @param {number} u
+     * @param {number} v
+     * @param {number[]} result
+     */
+    sampleCatmullRomUV(u, v, result) {
+        const itemSize = this.itemSize;
 
-/**
- * @param {number} [channel=0]
- * @returns {{x: number, index: number, y: number, value: number}}
- */
-Sampler2D.prototype.computeMin = function (channel = 0) {
-    const itemSize = this.itemSize;
+        for (let i = 0; i < itemSize; i++) {
+            result[i] = this.sampleChannelCatmullRomUV(u, v, i);
+        }
+    }
 
-    assert.typeOf(channel, "number", "channel");
-    assert.ok(channel >= 0, `channel must be >= 0, was ${channel}`);
-    assert.ok(channel < itemSize, `channel must be less than itemSize(=${itemSize}), was ${channel}`);
+    /**
+     *
+     * @param {number} u
+     * @param {number} v
+     * @param {number} channel
+     * @returns {number}
+     */
+    sampleChannelCatmullRomUV(u, v, channel) {
+        const x = u * (this.width);
+        const y = v * (this.height);
 
-    const data = this.data;
+        return this.sampleChannelCatmullRom(x - 0.5, y - 0.5, channel);
+    }
 
-    const l = data.length;
+    /**
+     *
+     * @see https://gist.github.com/TheRealMJP/c83b8c0f46b63f3a88a5986f4fa982b1
+     * @param {number} x
+     * @param {number} y
+     * @param {number} channel
+     * @returns {number}
+     */
+    sampleChannelCatmullRom(x, y, channel) {
+        // We're going to sample a a 4x4 grid of texels surrounding the target UV coordinate. We'll do this by rounding
+        // down the sample location to get the exact center of our "starting" texel. The starting texel will be at
+        // location [1, 1] in the grid, where [0, 0] is the top-left corner.
+        const texPos1_x = Math.floor(x - 0.5) + 0.5;
+        const texPos1_y = Math.floor(y - 0.5) + 0.5;
+
+        // Compute the fractional offset from our starting texel to our original sample location, which we'll
+        // feed into the Catmull-Rom spline function to get our filter weights.
+        const f_x = x - texPos1_x;
+        const f_y = y - texPos1_y;
+
+        // Compute the Catmull-Rom weights using the fractional offset that we calculated earlier.
+        // These equations are pre-expanded based on our knowledge of where the texels will be located,
+        // which lets us avoid having to evaluate a piece-wise function.
+        const w0_x = f_x * (-0.5 + f_x * (1.0 - 0.5 * f_x));
+        const w0_y = f_y * (-0.5 + f_y * (1.0 - 0.5 * f_y));
+
+        const w1_x = 1.0 + f_x * f_x * (-2.5 + 1.5 * f_x);
+        const w1_y = 1.0 + f_y * f_y * (-2.5 + 1.5 * f_y);
+
+        const w2_x = f_x * (0.5 + f_x * (2.0 - 1.5 * f_x));
+        const w2_y = f_y * (0.5 + f_y * (2.0 - 1.5 * f_y));
+
+        const w3_x = f_x * f_x * (-0.5 + 0.5 * f_x);
+        const w3_y = f_y * f_y * (-0.5 + 0.5 * f_y);
+
+        // Work out weighting factors and sampling offsets that will let us use bilinear filtering to
+        // simultaneously evaluate the middle 2 samples from the 4x4 grid.
+        const w12_x = w1_x + w2_x;
+        const w12_y = w1_y + w2_y;
+        const offset12_x = w2_x / w12_x;
+        const offset12_y = w2_y / w12_y;
+
+        // Compute the final coordinates we'll use for sampling the texture
+        const texPos0_x = texPos1_x - 1;
+        const texPos0_y = texPos1_y - 1;
+        const texPos3_x = texPos1_x + 2;
+        const texPos3_y = texPos1_y + 2;
+        const texPos12_x = texPos1_x + offset12_x;
+        const texPos12_y = texPos1_y + offset12_y;
+
+
+        let result = 0.0;
+        result += this.sampleChannelBilinear(texPos0_x, texPos0_y, channel) * w0_x * w0_y;
+        result += this.sampleChannelBilinear(texPos12_x, texPos0_y, channel) * w12_x * w0_y;
+        result += this.sampleChannelBilinear(texPos3_x, texPos0_y, channel) * w3_x * w0_y;
+
+        result += this.sampleChannelBilinear(texPos0_x, texPos12_y, channel) * w0_x * w12_y;
+        result += this.sampleChannelBilinear(texPos12_x, texPos12_y, channel) * w12_x * w12_y;
+        result += this.sampleChannelBilinear(texPos3_x, texPos12_y, channel) * w3_x * w12_y;
+
+        result += this.sampleChannelBilinear(texPos0_x, texPos3_y, channel) * w0_x * w3_y;
+        result += this.sampleChannelBilinear(texPos12_x, texPos3_y, channel) * w12_x * w3_y;
+        result += this.sampleChannelBilinear(texPos3_x, texPos3_y, channel) * w3_x * w3_y;
 
-    if (l === 0) {
-        //no data
-        return undefined;
+        return result;
     }
 
-    let bestValue = data[channel];
-    let bestIndex = channel;
-
-    for (let i = channel + itemSize; i < l; i += itemSize) {
-        const value = data[i];
+    /**
+     *
+     * @param {number} u
+     * @param {number} v
+     * @param {number[]} result
+     */
+    sampleBicubicUV(u, v, result) {
+        const itemSize = this.itemSize;
 
-        if (bestValue > value) {
-            bestValue = value;
-            bestIndex = i;
+        for (let i = 0; i < itemSize; i++) {
+            result[i] = this.sampleChannelBicubicUV(u, v, i);
         }
-
     }
 
-    const width = this.width;
-
-    const itemIndex = (bestIndex / this.itemSize) | 0;
+    /**
+     *
+     * @param {number} u
+     * @param {number} v
+     * @param {number} channel
+     * @returns {number}
+     */
+    sampleChannelBicubicUV(u, v, channel) {
+        const x = u * (this.width);
+        const y = v * (this.height);
 
-    const x = itemIndex % width;
-    const y = (itemIndex / width) | 0;
+        return this.sampleChannelBicubic(x - 0.5, y - 0.5, channel);
+    }
 
-    return {
-        index: bestIndex,
-        value: bestValue,
-        x,
-        y
-    };
-};
+    /**
+     * Bicubic-filtered sampling
+     * @param {number} x
+     * @param {number} y
+     * @param {number} channel
+     * @returns {number}
+     */
+    sampleChannelBicubic(x, y, channel) {
 
-/**
- *
- * @deprecated
- * @param {number} x
- * @param {number}y
- * @param {Vector1|Vector2|Vector3|Vector4} result
- * @returns {number}
- */
-Sampler2D.prototype.get = function (x, y, result) {
-    console.warn("Deprecated method, use sampleBilinear instead");
+        const itemSize = this.itemSize;
 
-    const t = [];
+        const width = this.width;
+        const height = this.height;
 
-    this.sampleBilinear(x, y, t, 0);
+        const data = this.data;
 
-    if (result !== undefined) {
-        result.readFromArray(t, 0);
-        return result;
-    } else {
-        return t[0];
-    }
-};
+        const rowSize = width * itemSize;
 
-/**
- *
- * @param {number} u
- * @param {number} v
- * @param {number[]} result
- */
-Sampler2D.prototype.sampleCatmullRomUV = function (u, v, result) {
-    const itemSize = this.itemSize;
+        const x_max = width - 1;
+        const y_max = height - 1;
 
-    for (let i = 0; i < itemSize; i++) {
-        result[i] = this.sampleChannelCatmullRomUV(u, v, i);
-    }
-};
+        const clamped_x = clamp(x, 0, x_max)
+        const clamped_y = clamp(y, 0, y_max)
 
-/**
- *
- * @param {number} u
- * @param {number} v
- * @param {number} channel
- * @returns {number}
- */
-Sampler2D.prototype.sampleChannelCatmullRomUV = function (u, v, channel) {
-    const x = u * (this.width);
-    const y = v * (this.height);
+        // fractional texel position (from the nearest low texel)
+        const x1 = clamped_x | 0;
+        const y1 = clamped_y | 0;
 
-    return this.sampleChannelCatmullRom(x - 0.5, y - 0.5, channel);
-};
+        const xd = clamped_x - x1;
+        const yd = clamped_y - y1;
 
-/**
- *
- * @see https://gist.github.com/TheRealMJP/c83b8c0f46b63f3a88a5986f4fa982b1
- * @param {number} x
- * @param {number} y
- * @param {number} channel
- * @returns {number}
- */
-Sampler2D.prototype.sampleChannelCatmullRom = function (x, y, channel) {
-    // We're going to sample a a 4x4 grid of texels surrounding the target UV coordinate. We'll do this by rounding
-    // down the sample location to get the exact center of our "starting" texel. The starting texel will be at
-    // location [1, 1] in the grid, where [0, 0] is the top-left corner.
-    const texPos1_x = Math.floor(x - 0.5) + 0.5;
-    const texPos1_y = Math.floor(y - 0.5) + 0.5;
-
-    // Compute the fractional offset from our starting texel to our original sample location, which we'll
-    // feed into the Catmull-Rom spline function to get our filter weights.
-    const f_x = x - texPos1_x;
-    const f_y = y - texPos1_y;
-
-    // Compute the Catmull-Rom weights using the fractional offset that we calculated earlier.
-    // These equations are pre-expanded based on our knowledge of where the texels will be located,
-    // which lets us avoid having to evaluate a piece-wise function.
-    const w0_x = f_x * (-0.5 + f_x * (1.0 - 0.5 * f_x));
-    const w0_y = f_y * (-0.5 + f_y * (1.0 - 0.5 * f_y));
-
-    const w1_x = 1.0 + f_x * f_x * (-2.5 + 1.5 * f_x);
-    const w1_y = 1.0 + f_y * f_y * (-2.5 + 1.5 * f_y);
-
-    const w2_x = f_x * (0.5 + f_x * (2.0 - 1.5 * f_x));
-    const w2_y = f_y * (0.5 + f_y * (2.0 - 1.5 * f_y));
-
-    const w3_x = f_x * f_x * (-0.5 + 0.5 * f_x);
-    const w3_y = f_y * f_y * (-0.5 + 0.5 * f_y);
-
-    // Work out weighting factors and sampling offsets that will let us use bilinear filtering to
-    // simultaneously evaluate the middle 2 samples from the 4x4 grid.
-    const w12_x = w1_x + w2_x;
-    const w12_y = w1_y + w2_y;
-    const offset12_x = w2_x / w12_x;
-    const offset12_y = w2_y / w12_y;
-
-    // Compute the final coordinates we'll use for sampling the texture
-    const texPos0_x = texPos1_x - 1;
-    const texPos0_y = texPos1_y - 1;
-    const texPos3_x = texPos1_x + 2;
-    const texPos3_y = texPos1_y + 2;
-    const texPos12_x = texPos1_x + offset12_x;
-    const texPos12_y = texPos1_y + offset12_y;
-
-
-    let result = 0.0;
-    result += this.sampleChannelBilinear(texPos0_x, texPos0_y, channel) * w0_x * w0_y;
-    result += this.sampleChannelBilinear(texPos12_x, texPos0_y, channel) * w12_x * w0_y;
-    result += this.sampleChannelBilinear(texPos3_x, texPos0_y, channel) * w3_x * w0_y;
-
-    result += this.sampleChannelBilinear(texPos0_x, texPos12_y, channel) * w0_x * w12_y;
-    result += this.sampleChannelBilinear(texPos12_x, texPos12_y, channel) * w12_x * w12_y;
-    result += this.sampleChannelBilinear(texPos3_x, texPos12_y, channel) * w3_x * w12_y;
-
-    result += this.sampleChannelBilinear(texPos0_x, texPos3_y, channel) * w0_x * w3_y;
-    result += this.sampleChannelBilinear(texPos12_x, texPos3_y, channel) * w12_x * w3_y;
-    result += this.sampleChannelBilinear(texPos3_x, texPos3_y, channel) * w3_x * w3_y;
-
-    return result;
-}
+        const x0 = max2(0, x1 - 1);
+        const y0 = max2(0, y1 - 1);
 
-/**
- * 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;
-}
+        const x2 = min2(x_max, x1 + 1);
+        const y2 = min2(y_max, y1 + 1);
 
-/**
- *
- * @param {number} u
- * @param {number} v
- * @param {number[]} result
- */
-Sampler2D.prototype.sampleBicubicUV = function (u, v, result) {
-    const itemSize = this.itemSize;
+        const x3 = min2(x_max, x2 + 1);
+        const y3 = min2(y_max, y2 + 1);
 
-    for (let i = 0; i < itemSize; i++) {
-        result[i] = this.sampleChannelBicubicUV(u, v, i);
-    }
-};
+        // compute row offsets
+        const row0 = y0 * rowSize;
+        const row1 = y1 * rowSize;
+        const row2 = y2 * rowSize;
+        const row3 = y3 * rowSize;
 
-/**
- *
- * @param {number} u
- * @param {number} v
- * @param {number} channel
- * @returns {number}
- */
-Sampler2D.prototype.sampleChannelBicubicUV = function (u, v, channel) {
-    const x = u * (this.width);
-    const y = v * (this.height);
+        const row0_address = row0 + channel;
+        const row1_address = row1 + channel;
+        const row2_address = row2 + channel;
+        const row3_address = row3 + channel;
 
-    return this.sampleChannelBicubic(x - 0.5, y - 0.5, channel);
-};
+        const col0_offset = x0 * itemSize;
+        const col1_offset = x1 * itemSize;
+        const col2_offset = x2 * itemSize;
+        const col3_offset = x3 * itemSize;
 
-/**
- * Bicubic-filtered sampling
- * @param {number} x
- * @param {number} y
- * @param {number} channel
- * @returns {number}
- */
-Sampler2D.prototype.sampleChannelBicubic = function (x, y, channel) {
+        // read samples
+        const vi0 = data[row0_address + col0_offset];
+        const vi1 = data[row0_address + col1_offset];
+        const vi2 = data[row0_address + col2_offset];
+        const vi3 = data[row0_address + col3_offset];
 
-    const itemSize = this.itemSize;
+        const vj0 = data[row1_address + col0_offset];
+        const vj1 = data[row1_address + col1_offset];
+        const vj2 = data[row1_address + col2_offset];
+        const vj3 = data[row1_address + col3_offset];
 
-    const width = this.width;
-    const height = this.height;
+        const vk0 = data[row2_address + col0_offset];
+        const vk1 = data[row2_address + col1_offset];
+        const vk2 = data[row2_address + col2_offset];
+        const vk3 = data[row2_address + col3_offset];
 
-    const data = this.data;
+        const vl0 = data[row3_address + col0_offset];
+        const vl1 = data[row3_address + col1_offset];
+        const vl2 = data[row3_address + col2_offset];
+        const vl3 = data[row3_address + col3_offset];
 
-    const rowSize = width * itemSize;
 
-    const x_max = width - 1;
-    const y_max = height - 1;
+        // return bicubic(xd, yd,
+        //     vi0, vi1, vi2, vi3,
+        //     vj0, vj1, vj2, vj3,
+        //     vk0, vk1, vk2, vk3,
+        //     vl0, vl1, vl2, vl3,
+        // );
 
-    const clamped_x = clamp(x, 0, x_max)
-    const clamped_y = clamp(y, 0, y_max)
 
-    // fractional texel position (from the nearest low texel)
-    const x1 = clamped_x | 0;
-    const y1 = clamped_y | 0;
+        // 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 xd = clamped_x - x1;
-    const yd = clamped_y - y1;
+        // filter in Y (columns)
+        return bicubic_terp(yd, s0, s1, s2, s3);
+    }
 
-    const x0 = max2(0, x1 - 1);
-    const y0 = max2(0, y1 - 1);
+    /**
+     *
+     * @param {number} u
+     * @param {number} v
+     * @param {number[]} result
+     * @param {number} result_offset
+     */
+    sampleBilinearUV(u, v, result, result_offset = 0) {
 
-    const x2 = min2(x_max, x1 + 1);
-    const y2 = min2(y_max, y1 + 1);
+        const itemSize = this.itemSize;
 
-    const x3 = min2(x_max, x2 + 1);
-    const y3 = min2(y_max, y2 + 1);
+        for (let i = 0; i < itemSize; i++) {
+            result[i + result_offset] = this.sampleChannelBilinearUV(u, v, i);
 
-    // compute row offsets
-    const row0 = y0 * rowSize;
-    const row1 = y1 * rowSize;
-    const row2 = y2 * rowSize;
-    const row3 = y3 * rowSize;
+        }
+    }
 
-    const row0_address = row0 + channel;
-    const row1_address = row1 + channel;
-    const row2_address = row2 + channel;
-    const row3_address = row3 + channel;
+    /**
+     *
+     * @param {number} x
+     * @param {number} y
+     * @param {number[]} result
+     * @param {number} result_offset
+     */
+    sampleBilinear(x, y, result, result_offset = 0) {
 
-    const col0_offset = x0 * itemSize;
-    const col1_offset = x1 * itemSize;
-    const col2_offset = x2 * itemSize;
-    const col3_offset = x3 * itemSize;
+        const itemSize = this.itemSize;
 
-    // read samples
-    const vi0 = data[row0_address + col0_offset];
-    const vi1 = data[row0_address + col1_offset];
-    const vi2 = data[row0_address + col2_offset];
-    const vi3 = data[row0_address + col3_offset];
+        for (let i = 0; i < itemSize; i++) {
+            //TODO this can be optimized greatly
+            result[i + result_offset] = this.sampleChannelBilinear(x, y, i);
 
-    const vj0 = data[row1_address + col0_offset];
-    const vj1 = data[row1_address + col1_offset];
-    const vj2 = data[row1_address + col2_offset];
-    const vj3 = data[row1_address + col3_offset];
+        }
+    }
 
-    const vk0 = data[row2_address + col0_offset];
-    const vk1 = data[row2_address + col1_offset];
-    const vk2 = data[row2_address + col2_offset];
-    const vk3 = data[row2_address + col3_offset];
+    /**
+     *
+     * @param {number} u
+     * @param {number} v
+     * @param {number} channel
+     * @return {number}
+     */
+    sampleChannelBilinearUV(u, v, channel) {
+        const x = u * (this.width);
+        const y = v * (this.height);
 
-    const vl0 = data[row3_address + col0_offset];
-    const vl1 = data[row3_address + col1_offset];
-    const vl2 = data[row3_address + col2_offset];
-    const vl3 = data[row3_address + col3_offset];
+        return this.sampleChannelBilinear(x - 0.5, y - 0.5, channel);
+    }
 
+    /**
+     *
+     * @param {number} x
+     * @param {number} y
+     * @param {number} channel
+     * @returns {number}
+     */
+    sampleChannelBilinear(x, y, channel) {
 
-    // return bicubic(xd, yd,
-    //     vi0, vi1, vi2, vi3,
-    //     vj0, vj1, vj2, vj3,
-    //     vk0, vk1, vk2, vk3,
-    //     vl0, vl1, vl2, vl3,
-    // );
+        const itemSize = this.itemSize;
 
+        const width = this.width;
+        const height = this.height;
 
-    // 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 rowSize = width * itemSize;
 
-    // filter in Y (columns)
-    return bicubic_terp(yd, s0, s1, s2, s3);
-};
+        //sample 4 points
+        const x_max = width - 1;
+        const y_max = height - 1;
 
-/**
- *
- * @param {number} u
- * @param {number} v
- * @param {number[]} result
- * @param {number} result_offset
- */
-Sampler2D.prototype.sampleBilinearUV = function (u, v, result, result_offset = 0) {
+        const clamped_x = clamp(x, 0, x_max);
+        const clamped_y = clamp(y, 0, y_max);
 
-    const itemSize = this.itemSize;
+        const x0 = clamped_x | 0;
+        const y0 = clamped_y | 0;
 
-    for (let i = 0; i < itemSize; i++) {
-        result[i + result_offset] = this.sampleChannelBilinearUV(u, v, i);
+        //
+        const row0 = y0 * rowSize;
+        const col0_offset = x0 * itemSize + channel;
 
-    }
-}
+        const i0 = row0 + col0_offset;
 
-/**
- *
- * @param {number} x
- * @param {number} y
- * @param {number[]} result
- * @param {number} result_offset
- */
-Sampler2D.prototype.sampleBilinear = function (x, y, result, result_offset = 0) {
+        //
+        let x1, y1;
 
-    const itemSize = this.itemSize;
+        if (clamped_x === x0 || x0 >= x_max) {
+            x1 = x0;
+        } else {
+            x1 = x0 + 1;
+        }
 
-    for (let i = 0; i < itemSize; i++) {
-        //TODO this can be optimized greatly
-        result[i + result_offset] = this.sampleChannelBilinear(x, y, i);
 
-    }
-};
+        if (clamped_y === y0 || y0 >= y_max) {
+            y1 = y0;
+        } else {
+            y1 = y0 + 1;
+        }
 
-/**
- *
- * @param {number} u
- * @param {number} v
- * @param {number} channel
- * @return {number}
- */
-Sampler2D.prototype.sampleChannelBilinearUV = function (u, v, channel) {
-    const x = u * (this.width);
-    const y = v * (this.height);
+        const data = this.data;
 
-    return this.sampleChannelBilinear(x - 0.5, y - 0.5, channel);
-};
+        const q0 = data[i0];
 
-/**
- *
- * @param {number} x
- * @param {number} y
- * @param {number} channel
- * @returns {number}
- */
-Sampler2D.prototype.sampleChannelBilinear = function (x, y, channel) {
+        if (x0 === x1 && y0 === y1) {
+            return q0;
+        }
 
-    const itemSize = this.itemSize;
+        //
+        const xd = clamped_x - x0;
+        const yd = clamped_y - y0;
 
-    const width = this.width;
-    const height = this.height;
+        const col1_offset = x1 * itemSize + channel;
 
-    const rowSize = width * itemSize;
+        const i1 = row0 + col1_offset;
 
-    //sample 4 points
-    const x_max = width - 1;
-    const y_max = height - 1;
+        const row1 = y1 * rowSize;
 
-    const clamped_x = clamp(x, 0, x_max);
-    const clamped_y = clamp(y, 0, y_max);
+        const j0 = row1 + col0_offset;
+        const j1 = row1 + col1_offset;
 
-    const x0 = clamped_x | 0;
-    const y0 = clamped_y | 0;
+        const q1 = data[i1];
+        const p0 = data[j0];
+        const p1 = data[j1];
 
-    //
-    const row0 = y0 * rowSize;
-    const col0_offset = x0 * itemSize + channel;
+        // perform Bi-Linear interpolation
+        const s0 = mix(q0, q1, xd);
+        const s1 = mix(p0, p1, xd);
 
-    const i0 = row0 + col0_offset;
+        return mix(s0, s1, yd);
+    }
 
-    //
-    let x1, y1;
+    sampleNearestUV(u, v, result) {
+        const x = Math.round(u * (this.width) - 0.5);
+        const y = Math.round(v * (this.height) - 0.5);
 
-    if (clamped_x === x0 || x0 >= x_max) {
-        x1 = x0;
-    } else {
-        x1 = x0 + 1;
+        this.read(min2(x, this.width - 1), min2(y, this.height - 1), result);
     }
 
+    /**
+     *
+     * @param {number} x
+     * @param {number} y
+     * @param {number} channel
+     * @returns {number}
+     */
+    readChannel(x, y, channel) {
+        assert.isNumber(x, "x");
+        assert.isNumber(y, "y");
+        assert.isNumber(channel, "channel");
 
-    if (clamped_y === y0 || y0 >= y_max) {
-        y1 = y0;
-    } else {
-        y1 = y0 + 1;
+        assert.isNonNegativeInteger(channel, 'channel');
+
+        const index = (y * this.width + x) * this.itemSize + channel;
+
+        return this.data[index];
     }
 
-    const data = this.data;
+    /**
+     *
+     * @param {number} x
+     * @param {number} y
+     * @param {number[]} result
+     */
+    read(x, y, result) {
 
-    const q0 = data[i0];
+        const width = this.width;
 
-    if (x0 === x1 && y0 === y1) {
-        return q0;
-    }
+        const itemSize = this.itemSize;
 
-    //
-    const xd = clamped_x - x0;
-    const yd = clamped_y - y0;
+        const i0 = (y * width + x) * itemSize;
 
-    const col1_offset = x1 * itemSize + channel;
+        for (let i = 0; i < itemSize; i++) {
+            const v = this.data[i0 + i];
 
-    const i1 = row0 + col1_offset;
+            result[i] = v;
+        }
+    }
 
-    const row1 = y1 * rowSize;
+    /**
+     *
+     * @param {number} u
+     * @param {number} v
+     * @param {Vector4|Vector3|Vector2} [result]
+     * @deprecated
+     */
+    sample(u, v, result) {
+        console.warn("Deprecated method, use sampleBilinear instead");
 
-    const j0 = row1 + col0_offset;
-    const j1 = row1 + col1_offset;
+        const temp = [];
 
-    const q1 = data[i1];
-    const p0 = data[j0];
-    const p1 = data[j1];
+        this.sampleBilinear(u * (this.width - 1), v * (this.height - 1), temp, 0);
 
-    // perform Bi-Linear interpolation
-    const s0 = mix(q0, q1, xd);
-    const s1 = mix(p0, p1, xd);
+        result.readFromArray(temp);
 
-    return mix(s0, s1, yd);
-};
+        return temp[0];
+    }
 
-Sampler2D.prototype.sampleNearestUV = function (u, v, result) {
-    const x = Math.round(u * (this.width) - 0.5);
-    const y = Math.round(v * (this.height) - 0.5);
+    /**
+     *
+     * @param {number} index
+     * @param {number[]} result
+     */
+    computeNeighbors(index, result) {
+        const width = this.width;
+        const height = this.height;
+
+        const x = index % width;
+        const y = (index / width) | 0;
+        if (x > 0) {
+            result.push(index - 1);
+        }
+        if (x < width - 1) {
+            result.push(index + 1);
+        }
+        if (y > 0) {
+            result.push(index - width);
+        }
+        if (y < height - 1) {
+            result.push(index + width);
+        }
+    }
 
-    this.read(min2(x, this.width - 1), min2(y, this.height - 1), result);
-}
+    /**
+     *
+     * @param {number} x
+     * @param {number} y
+     * @returns {number}
+     */
+    point2index(x, y) {
+        return x + y * this.width;
+    }
 
-/**
- *
- * @param {number} x
- * @param {number} y
- * @param {number} channel
- * @returns {number}
- */
-Sampler2D.prototype.readChannel = function (x, y, channel) {
-    assert.isNumber(x, "x");
-    assert.isNumber(y, "y");
-    assert.isNumber(channel, "channel");
+    /**
+     *
+     * @param {number} index
+     * @param {Vector2} result
+     */
+    index2point(index, result) {
+        const width = this.width;
 
-    assert.isNonNegativeInteger(channel, 'channel');
+        const x = index % width;
+        const y = (index / width) | 0;
 
-    const index = (y * this.width + x) * this.itemSize + channel;
+        result.set(x, y);
+    }
 
-    return this.data[index];
-};
+    /**
+     *
+     * @param {number} scale
+     * @param {number} offset
+     * @return {function(index:int, array:ArrayLike, x:int, y:int)}
+     */
+    makeArrayFiller(scale, offset) {
+        scale = scale || 255;
+        offset = offset || 0;
+
+        const sampler = this;
+        const v4 = [1 / scale, 1 / scale, 1 / scale, 1 / scale];
+
+        //
+        function fillDD1(index, array, x, y) {
+            const val = (sampler.sampleChannelBilinear(x, y, 0) + offset) * scale | 0;
+            array[index] = val;
+            array[index + 1] = val;
+            array[index + 2] = val;
+            array[index + 3] = 255;
+        }
 
-/**
- *
- * @param {number} x
- * @param {number} y
- * @param {number[]} result
- */
-Sampler2D.prototype.read = function (x, y, result) {
+        function fillDD2(index, array, x, y) {
+            sampler.sampleBilinear(x, y, v4, 0);
+            const val = (v4[0] + offset) * scale | 0;
+            array.fill(val, index, index + 3);
+            array[index + 3] = (v4[1] + offset) * scale | 0;
+        }
 
-    const width = this.width;
+        function fillDD3(index, array, x, y) {
 
-    const itemSize = this.itemSize;
+            sampler.sampleBilinear(x, y, v4, 0);
 
-    const i0 = (y * width + x) * itemSize;
+            array[index] = (v4[0] + offset) * scale | 0;
+            array[index + 1] = (v4[1] + offset) * scale | 0;
+            array[index + 2] = (v4[2] + offset) * scale | 0;
+            array[index + 3] = 255;
+        }
 
-    for (let i = 0; i < itemSize; i++) {
-        const v = this.data[i0 + i];
+        function fillDD4(index, array, x, y) {
+            sampler.sampleBilinear(x, y, v4, 0);
+            array[index] = (v4[0] + offset) * scale | 0;
+            array[index + 1] = (v4[1] + offset) * scale | 0;
+            array[index + 2] = (v4[2] + offset) * scale | 0;
+            array[index + 3] = (v4[3] + offset) * scale | 0;
+        }
 
-        result[i] = v;
+        let fillDD;
+        switch (sampler.itemSize) {
+            case 1:
+                fillDD = fillDD1;
+                break;
+            case 2:
+                fillDD = fillDD2;
+                break;
+            case 3:
+                fillDD = fillDD3;
+                break;
+            case 4:
+                fillDD = fillDD4;
+                break;
+            default :
+                throw new Error("unsupported item size");
+                break;
+        }
+        return fillDD;
     }
-};
 
+    /**
+     * 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);
 
-/**
- *
- * @param {number} u
- * @param {number} v
- * @param {Vector4|Vector3|Vector2} [result]
- * @deprecated
- */
-Sampler2D.prototype.sample = function (u, v, result) {
-    console.warn("Deprecated method, use sampleBilinear instead");
 
-    const temp = [];
+        const dRowSize = dItemSize * this.width;
+        const sRowSize = sItemSize * source.width;
 
-    this.sampleBilinear(u * (this.width - 1), v * (this.height - 1), temp, 0);
+        const sData = source.data;
+        const dData = this.data;
 
-    result.readFromArray(temp);
+        let x, y, i, j;
 
-    return temp[0];
-};
+        let xMax, yMax;
 
-/**
- *
- * @param {number} index
- * @param {number[]} result
- */
-Sampler2D.prototype.computeNeighbors = function (index, result) {
-    const width = this.width;
-    const height = this.height;
-
-    const x = index % width;
-    const y = (index / width) | 0;
-    if (x > 0) {
-        result.push(index - 1);
-    }
-    if (x < width - 1) {
-        result.push(index + 1);
-    }
-    if (y > 0) {
-        result.push(index - width);
-    }
-    if (y < height - 1) {
-        result.push(index + width);
-    }
-};
+        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;
 
-/**
- *
- * @param {number} x
- * @param {number} y
- * @returns {number}
- */
-Sampler2D.prototype.point2index = function (x, y) {
-    return x + y * this.width;
-};
+            for (x = Math.max(0, destinationX - marginLeft), xMax = destinationX; x < xMax; x++) {
 
-/**
- *
- * @param {number} index
- * @param {Vector2} result
- */
-Sampler2D.prototype.index2point = function (index, result) {
-    const width = this.width;
+                dOffset = dA + x * dItemSize;
 
-    const x = index % width;
-    const y = (index / width) | 0;
+                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;
 
-    result.set(x, y);
-};
+            for (x = 0; x < width; x++) {
 
-/**
- *
- * @param {number} scale
- * @param {number} offset
- * @return {function(index:int, array:ArrayLike, x:int, y:int)}
- */
-Sampler2D.prototype.makeArrayFiller = function (scale, offset) {
-    scale = scale || 255;
-    offset = offset || 0;
-
-    const sampler = this;
-    const v4 = [1 / scale, 1 / scale, 1 / scale, 1 / scale];
-
-    //
-    function fillDD1(index, array, x, y) {
-        const val = (sampler.sampleChannelBilinear(x, y, 0) + offset) * scale | 0;
-        array[index] = val;
-        array[index + 1] = val;
-        array[index + 2] = val;
-        array[index + 3] = 255;
-    }
+                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;
 
-    function fillDD2(index, array, x, y) {
-        sampler.sampleBilinear(x, y, v4, 0);
-        const val = (v4[0] + offset) * scale | 0;
-        array.fill(val, index, index + 3);
-        array[index + 3] = (v4[1] + offset) * scale | 0;
-    }
+            for (x = destinationX + width, xMax = Math.min(this.width, x + marginRight); x < xMax; x++) {
 
-    function fillDD3(index, array, x, y) {
+                dOffset = dA + x * dItemSize;
 
-        sampler.sampleBilinear(x, y, v4, 0);
+                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;
 
-        array[index] = (v4[0] + offset) * scale | 0;
-        array[index + 1] = (v4[1] + offset) * scale | 0;
-        array[index + 2] = (v4[2] + offset) * scale | 0;
-        array[index + 3] = 255;
-    }
+            sOffset = sA + (sourceX) * dItemSize;
 
-    function fillDD4(index, array, x, y) {
-        sampler.sampleBilinear(x, y, v4, 0);
-        array[index] = (v4[0] + offset) * scale | 0;
-        array[index + 1] = (v4[1] + offset) * scale | 0;
-        array[index + 2] = (v4[2] + offset) * scale | 0;
-        array[index + 3] = (v4[3] + offset) * scale | 0;
-    }
+            for (x = Math.max(0, destinationX - marginLeft), xMax = destinationX; x < xMax; x++) {
 
-    let fillDD;
-    switch (sampler.itemSize) {
-        case 1:
-            fillDD = fillDD1;
-            break;
-        case 2:
-            fillDD = fillDD2;
-            break;
-        case 3:
-            fillDD = fillDD3;
-            break;
-        case 4:
-            fillDD = fillDD4;
-            break;
-        default :
-            throw new Error("unsupported item size");
-            break;
-    }
-    return fillDD;
-};
+                dOffset = dA + x * dItemSize;
 
-/**
- * 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
- */
-Sampler2D.prototype.copyWithMargin = function (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);
+                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;
 
-    const dRowSize = dItemSize * this.width;
-    const sRowSize = sItemSize * source.width;
+            sOffset = sA + (sourceX + width - 1) * dItemSize;
 
-    const sData = source.data;
-    const dData = this.data;
+            for (x = destinationX + width, xMax = Math.min(this.width, x + marginRight); x < xMax; x++) {
 
-    let x, y, i, j;
+                dOffset = dA + x * dItemSize;
 
-    let xMax, yMax;
+                for (i = 0; i < _itemSize; i++) {
+                    dData[dOffset + i] = sData[sOffset + i];
+                }
+            }
+        }
 
-    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;
+        //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++) {
+            for (x = Math.max(0, destinationX - marginLeft), xMax = destinationX; x < xMax; x++) {
 
-            dOffset = dA + x * dItemSize;
+                dOffset = dA + x * dItemSize;
 
-            for (i = 0; i < _itemSize; i++) {
-                dData[dOffset + i] = sData[sOffset + i];
+                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;
+        //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++) {
+            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];
+                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;
+        //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++) {
+            for (x = destinationX + width, xMax = Math.min(this.width, x + marginRight); x < xMax; x++) {
 
-            dOffset = dA + x * dItemSize;
+                dOffset = dA + x * dItemSize;
 
-            for (i = 0; i < _itemSize; i++) {
-                dData[dOffset + i] = sData[sOffset + i];
+                for (i = 0; i < _itemSize; i++) {
+                    dData[dOffset + i] = sData[sOffset + i];
+                }
             }
         }
+
+        this.version++;
     }
-    //Write left margin
-    for (y = 0; y < height; y++) {
-        dA = (y + destinationY) * dRowSize;
-        sA = (y + sourceY) * sRowSize;
 
-        sOffset = sA + (sourceX) * dItemSize;
+    /**
+     * 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, sourceX, sourceY,
+        destinationX, destinationY, width, height
+    ) {
 
-        for (x = Math.max(0, destinationX - marginLeft), xMax = destinationX; x < xMax; x++) {
+        assert.isNumber(sourceX, 'sourceX');
+        assert.isNumber(sourceY, 'sourceY');
 
-            dOffset = dA + x * dItemSize;
+        assert.isNumber(destinationX, 'destinationX');
+        assert.isNumber(destinationY, 'destinationY');
 
-            for (i = 0; i < _itemSize; i++) {
-                dData[dOffset + i] = sData[sOffset + i];
-            }
-        }
-    }
-    //write actual patch
-    this.copy(source, sourceX, sourceY, destinationX, destinationY, width, height);
+        assert.isNumber(width, 'width');
+        assert.isNumber(height, 'height');
 
-    //Write right margin
-    for (y = 0; y < height; y++) {
-        dA = (y + destinationY) * dRowSize;
-        sA = (y + sourceY) * sRowSize;
+        const _w = Math.min(width, source.width - sourceX, this.width - destinationX);
+        const _h = Math.min(height, source.height - sourceY, this.height - destinationY);
 
-        sOffset = sA + (sourceX + width - 1) * dItemSize;
 
-        for (x = destinationX + width, xMax = Math.min(this.width, x + marginRight); x < xMax; x++) {
+        const dItemSize = this.itemSize;
+        const sItemSize = source.itemSize;
+        const _itemSize = Math.min(dItemSize, sItemSize);
 
-            dOffset = dA + x * dItemSize;
 
-            for (i = 0; i < _itemSize; i++) {
-                dData[dOffset + i] = sData[sOffset + i];
+        const dRowSize = dItemSize * this.width;
+        const sRowSize = sItemSize * source.width;
+
+        const sData = source.data;
+        const dData = this.data;
+
+        let x, y, i;
+
+        for (y = 0; y < _h; y++) {
+            const dA = (y + destinationY) * dRowSize;
+            const sA = (y + sourceY) * sRowSize;
+            for (x = 0; x < _w; x++) {
+                const dOffset = dA + (x + destinationX) * dItemSize;
+                const sOffset = sA + (x + sourceX) * sItemSize;
+                for (i = 0; i < _itemSize; i++) {
+                    dData[dOffset + i] = sData[sOffset + i];
+                }
             }
         }
+
+        this.version++;
     }
 
-    //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;
+    /**
+     * 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;
 
-        for (x = Math.max(0, destinationX - marginLeft), xMax = destinationX; x < xMax; x++) {
+        assert.equal(sItemSize, sItemSize, `source.itemSize(=${sItemSize}) != this.itemSize(=${itemSize})`);
 
-            dOffset = dA + x * dItemSize;
+        const _w = Math.min(width, source.width - sourceX, this.width - destinationX);
+        const _h = Math.min(height, source.height - sourceY, this.height - destinationY);
 
-            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++) {
+        const dRowSize = itemSize * this.width;
+        const sRowSize = itemSize * source.width;
 
-            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;
+        const sData = source.data;
+        const dData = this.data;
 
-        for (x = destinationX + width, xMax = Math.min(this.width, x + marginRight); x < xMax; x++) {
+        const patchRowSize = _w * itemSize;
 
-            dOffset = dA + x * dItemSize;
+        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++) {
 
-            for (i = 0; i < _itemSize; i++) {
                 dData[dOffset + i] = sData[sOffset + i];
+
             }
         }
+
+        this.version++;
     }
 
-    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})`);
+        }
 
-/**
- * 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
- */
-Sampler2D.prototype.copy = function (
-    source, sourceX, sourceY,
-    destinationX, destinationY, width, height
-) {
+        const _w = Math.min(width, source.width - sourceX, this.width - destinationX);
+        const _h = Math.min(height, source.height - sourceY, this.height - destinationY);
 
-    assert.isNumber(sourceX, 'sourceX');
-    assert.isNumber(sourceY, 'sourceY');
+        const _x0 = Math.max(0, -destinationX);
+        const _y0 = Math.max(0, -destinationY);
 
-    assert.isNumber(destinationX, 'destinationX');
-    assert.isNumber(destinationY, 'destinationY');
+        const c0 = [0, 0, 0, 255];
+        const c1 = [0, 0, 0, 255];
 
-    assert.isNumber(width, 'width');
-    assert.isNumber(height, 'height');
+        const c3 = [];
 
-    const _w = Math.min(width, source.width - sourceX, this.width - destinationX);
-    const _h = Math.min(height, source.height - sourceY, this.height - destinationY);
+        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);
 
-    const dItemSize = this.itemSize;
-    const sItemSize = source.itemSize;
-    const _itemSize = Math.min(dItemSize, sItemSize);
+                this.read(d_x, d_y, c0);
 
+                const s_x = Math.round(x + sourceY);
+                const s_y = Math.round(y + sourceY);
 
-    const dRowSize = dItemSize * this.width;
-    const sRowSize = sItemSize * source.width;
+                source.read(s_x, s_y, c1);
 
-    const sData = source.data;
-    const dData = this.data;
+                blendFunction(c1, c0, c3);
 
-    let x, y, i;
+                this.set(d_x, d_y, c3);
 
-    for (y = 0; y < _h; y++) {
-        const dA = (y + destinationY) * dRowSize;
-        const sA = (y + sourceY) * sRowSize;
-        for (x = 0; x < _w; x++) {
-            const dOffset = dA + (x + destinationX) * dItemSize;
-            const sOffset = sA + (x + sourceX) * sItemSize;
-            for (i = 0; i < _itemSize; i++) {
-                dData[dOffset + i] = sData[sOffset + i];
             }
         }
-    }
 
-    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
- */
-Sampler2D.prototype.copy_sameItemSize = function (source, sourceX, sourceY, destinationX, destinationY, width, height) {
-    const itemSize = this.itemSize;
-    const sItemSize = source.itemSize;
+    /**
+     * Fill data values with zeros for a given area
+     * @param {Number} x
+     * @param {Number} y
+     * @param {Number} width
+     * @param {Number} height
+     */
+    zeroFill(x, y, width, height) {
 
-    assert.equal(sItemSize, sItemSize, `source.itemSize(=${sItemSize}) != this.itemSize(=${itemSize})`);
+        const x0 = clamp(x, 0, this.width);
+        const y0 = clamp(y, 0, this.height);
+        const x1 = clamp(x + width, 0, this.width);
+        const y1 = clamp(y + height, 0, this.height);
 
-    const _w = Math.min(width, source.width - sourceX, this.width - destinationX);
-    const _h = Math.min(height, source.height - sourceY, this.height - destinationY);
+        const data = this.data;
+        const itemSize = this.itemSize;
 
+        const rowSize = itemSize * this.width;
 
-    const dRowSize = itemSize * this.width;
-    const sRowSize = itemSize * source.width;
+        const clearRowOffset0 = x0 * itemSize;
+        const clearRowOffset1 = x1 * itemSize;
 
-    const sData = source.data;
-    const dData = this.data;
+        let _y;
 
-    const patchRowSize = _w * itemSize;
+        for (_y = y0; _y < y1; _y++) {
 
-    let y, i;
+            const a = _y * rowSize;
 
-    for (y = 0; y < _h; y++) {
-        const dA = (y + destinationY) * dRowSize;
-        const sA = (y + sourceY) * sRowSize;
+            data.fill(0, a + clearRowOffset0, a + clearRowOffset1);
 
-        const dOffset = dA + destinationX * itemSize;
-        const sOffset = sA + sourceX * itemSize;
+        }
 
-        for (i = 0; i < patchRowSize; i++) {
+        this.version++;
+    }
 
-            dData[dOffset + i] = sData[sOffset + i];
+    /**
+     *
+     * @param {number} channel_index
+     * @param {number} value
+     */
+    fill_channel(channel_index, value) {
+        const itemSize = this.itemSize;
+        const data = this.data;
+        const length = data.length;
 
+        for (let i = channel_index; i < length; i += itemSize) {
+            data[i] = value;
         }
+
+        this.version++;
     }
 
-    this.version++;
-};
+    /**
+     *
+     * @param {Number} x
+     * @param {Number} y
+     * @param {Number} width
+     * @param {Number} height
+     * @param {Array.<Number>} value
+     */
+    fill(x, y, width, height, value) {
+
+        const _w = this.width;
+        const _h = this.height;
 
+        const x0 = clamp(x, 0, _w);
+        const y0 = clamp(y, 0, _h);
+        const x1 = clamp(x + width, 0, _w);
+        const y1 = clamp(y + height, 0, _h);
 
-/**
- *
- * @param {number[]} source
- * @param {number[]} destination
- * @param {Array} result
- */
-function blendFunctionNormal(source, destination, result) {
+        const data = this.data;
+        const itemSize = this.itemSize;
 
-    const a1 = source[3] / 255;
-    const a0 = destination[3] / 255;
+        const rowSize = itemSize * _w;
 
-    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;
-}
+        let _y, _x, i;
 
-/**
- * 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]
- */
-Sampler2D.prototype.paint = function (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})`);
-    }
+        for (_y = y0; _y < y1; _y++) {
 
-    const _w = Math.min(width, source.width - sourceX, this.width - destinationX);
-    const _h = Math.min(height, source.height - sourceY, this.height - destinationY);
+            const a = _y * rowSize;
 
-    const _x0 = Math.max(0, -destinationX);
-    const _y0 = Math.max(0, -destinationY);
+            for (_x = x0; _x < x1; _x++) {
 
-    const c0 = [0, 0, 0, 255];
-    const c1 = [0, 0, 0, 255];
+                const offset = a + _x * itemSize;
 
-    const c3 = [];
+                for (i = 0; i < itemSize; i++) {
 
-    let x, y;
+                    data[offset + i] = value[i];
 
-    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);
+        this.version++;
+    }
 
-            const s_x = Math.round(x + sourceY);
-            const s_y = Math.round(y + sourceY);
+    /**
+     * Set channel value of a specific texel
+     * @param {number} x
+     * @param {number} y
+     * @param {number} channel
+     * @param {number} value
+     */
+    writeChannel(x, y, channel, value) {
+        assert.isNumber(x, "x");
+        assert.isNumber(y, "y");
 
-            source.read(s_x, s_y, c1);
+        assert.greaterThanOrEqual(x, 0);
+        assert.greaterThanOrEqual(y, 0);
+        assert.lessThan(x, this.width);
+        assert.lessThan(y, this.height);
 
-            blendFunction(c1, c0, c3);
+        const pointIndex = y * this.width + x;
+        const pointAddress = pointIndex * this.itemSize;
+        const channelAddress = pointAddress + channel;
 
-            this.set(d_x, d_y, c3);
+        this.data[channelAddress] = value;
 
-        }
+        this.version++;
     }
 
+    /**
+     *
+     * @param {number} x
+     * @param {number} y
+     * @param {number[]} value
+     */
+    set(x, y, value) {
+        const data = this.data;
+        const itemSize = this.itemSize;
+
+        const rowSize = itemSize * this.width;
 
-};
+        const offset = (rowSize * y) + x * itemSize;
 
-/**
- * Fill data values with zeros for a given area
- * @param {Number} x
- * @param {Number} y
- * @param {Number} width
- * @param {Number} height
- */
-Sampler2D.prototype.zeroFill = function (x, y, width, height) {
+        for (let i = 0; i < itemSize; i++) {
+            data[offset + i] = value[i];
+        }
 
-    const x0 = clamp(x, 0, this.width);
-    const y0 = clamp(y, 0, this.height);
-    const x1 = clamp(x + width, 0, this.width);
-    const y1 = clamp(y + height, 0, this.height);
+        this.version++;
+    }
 
-    const data = this.data;
-    const itemSize = this.itemSize;
+    /**
+     * 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, centerY, radius, visitor) {
+        let x, y;
 
-    const rowSize = itemSize * this.width;
+        //convert offsets to integers for safety
+        const offsetX = centerX | 0;
+        const offsetY = centerY | 0;
 
-    const clearRowOffset0 = x0 * itemSize;
-    const clearRowOffset1 = x1 * itemSize;
+        const r2 = radius * radius;
 
-    let _y;
+        const radiusCeil = Math.ceil(radius);
 
-    for (_y = y0; _y < y1; _y++) {
+        for (y = -radiusCeil; y <= radiusCeil; y++) {
+            const y2 = y * y;
 
-        const a = _y * rowSize;
+            for (x = -radiusCeil; x <= radiusCeil; x++) {
 
-        data.fill(0, a + clearRowOffset0, a + clearRowOffset1);
+                if (x * x + y2 <= r2) {
+                    visitor(offsetX + x, offsetY + y, this);
+                }
 
+            }
+        }
     }
 
-    this.version++;
-};
+    /**
+     *
+     * @param {number} x
+     * @param {number} y
+     * @param {boolean} [preserveData=true]
+     */
+    resize(x, y, preserveData = true) {
+        assert.isNonNegativeInteger(x, 'x');
+        assert.isNonNegativeInteger(y, 'y');
 
-/**
- *
- * @param {number} channel_index
- * @param {number} value
- */
-Sampler2D.prototype.fill_channel = function (channel_index, value) {
-    const itemSize = this.itemSize;
-    const data = this.data;
-    const length = data.length;
+        const _w = this.width;
+        const _h = this.height;
 
-    for (let i = channel_index; i < length; i += itemSize) {
-        data[i] = value;
-    }
+        if (_w === x && _h === y) {
+            // size didn't change
+            return;
+        }
 
-    this.version++;
-};
+        const itemSize = this.itemSize;
 
-/**
- *
- * @param {Number} x
- * @param {Number} y
- * @param {Number} width
- * @param {Number} height
- * @param {Array.<Number>} value
- */
-Sampler2D.prototype.fill = function (x, y, width, height, value) {
+        const length = x * y * itemSize;
 
-    const _w = this.width;
-    const _h = this.height;
+        const oldData = this.data;
 
-    const x0 = clamp(x, 0, _w);
-    const y0 = clamp(y, 0, _h);
-    const x1 = clamp(x + width, 0, _w);
-    const y1 = clamp(y + height, 0, _h);
+        const Constructor = typedArrayConstructorByInstance(oldData);
 
-    const data = this.data;
-    const itemSize = this.itemSize;
+        const newData = new Constructor(length);
 
-    const rowSize = itemSize * _w;
+        if (preserveData) {
+            //copy old data
+            if (x === _w) {
+                // number of columns is preserved, we can just copy the old data across
+                newData.set(oldData.subarray(0, Math.min(oldData.length, length)));
+            } else {
+                //we need to copy new data row-by-row
+                const rowCount = min2(y, _h);
 
-    let _y, _x, i;
+                const columnCount = min2(x, _w);
 
-    for (_y = y0; _y < y1; _y++) {
+                for (let i = 0; i < rowCount; i++) {
+                    for (let j = 0; j < columnCount; j++) {
 
-        const a = _y * rowSize;
+                        const targetItemAddress = (i * x + j) * itemSize;
+                        const sourceItemAddress = (i * _w + j) * itemSize;
 
-        for (_x = x0; _x < x1; _x++) {
+                        for (let k = 0; k < itemSize; k++) {
 
-            const offset = a + _x * itemSize;
+                            newData[targetItemAddress + k] = oldData[sourceItemAddress + k];
 
-            for (i = 0; i < itemSize; i++) {
+                        }
+                    }
+                }
+            }
+        }
 
-                data[offset + i] = value[i];
+        this.width = x;
+        this.height = y;
 
-            }
+        this.data = newData;
 
-        }
+        this.version++;
     }
 
-    this.version++;
-};
+    /**
+     * Estimate memory requirement of the object
+     * @return {number}
+     */
+    computeByteSize() {
+        let dataSize;
 
-/**
- * Set channel value of a specific texel
- * @param {number} x
- * @param {number} y
- * @param {number} channel
- * @param {number} value
- */
-Sampler2D.prototype.writeChannel = function (x, y, channel, value) {
-    assert.isNumber(x, "x");
-    assert.isNumber(y, "y");
+        if (Array.isArray(this.data)) {
+            dataSize = 8 * this.data.length;
+        } else {
+            dataSize = this.data.buffer.byteLength;
+        }
 
-    assert.greaterThanOrEqual(x, 0);
-    assert.greaterThanOrEqual(y, 0);
-    assert.lessThan(x, this.width);
-    assert.lessThan(y, this.height);
+        return dataSize + 280;
+    }
 
-    const pointIndex = y * this.width + x;
-    const pointAddress = pointIndex * this.itemSize;
-    const channelAddress = pointAddress + channel;
+    /**
+     * @deprecated Use {@link Sampler2DSerializationAdapter} adapter instead
+     * @param {BinaryBuffer} buffer
+     */
+    toBinaryBuffer(buffer) {
+        const width = this.width;
+        const height = this.height;
 
-    this.data[channelAddress] = value;
+        const itemSize = this.itemSize;
 
-    this.version++;
-};
+        buffer.writeUint16(width);
+        buffer.writeUint16(height);
 
-/**
- *
- * @param {number} x
- * @param {number} y
- * @param {number[]} value
- */
-Sampler2D.prototype.set = function (x, y, value) {
-    const data = this.data;
-    const itemSize = this.itemSize;
+        buffer.writeUint8(itemSize);
 
-    const rowSize = itemSize * this.width;
+        if (this.data instanceof Uint8Array) {
+            //data type
+            buffer.writeUint8(0);
 
-    const offset = (rowSize * y) + x * itemSize;
 
-    for (let i = 0; i < itemSize; i++) {
-        data[offset + i] = value[i];
-    }
+            const byteSize = width * height * itemSize;
 
-    this.version++;
-};
+            buffer.writeBytes(this.data, 0, byteSize);
 
-/**
- * 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
- */
-Sampler2D.prototype.traverseCircle = function (centerX, centerY, radius, visitor) {
-    let x, y;
+        } else {
+            throw new TypeError(`Unsupported data type`);
+        }
+    }
 
-    //convert offsets to integers for safety
-    const offsetX = centerX | 0;
-    const offsetY = centerY | 0;
+    /**
+     * @deprecated Use {@link Sampler2DSerializationAdapter} adapter instead
+     * @param {BinaryBuffer} buffer
+     */
+    fromBinaryBuffer(buffer) {
+        this.width = buffer.readUint16();
+        this.height = buffer.readUint16();
 
-    const r2 = radius * radius;
+        this.itemSize = buffer.readUint8();
 
-    const radiusCeil = Math.ceil(radius);
+        const dataType = buffer.readUint8();
 
-    for (y = -radiusCeil; y <= radiusCeil; y++) {
-        const y2 = y * y;
+        if (dataType === 0) {
 
-        for (x = -radiusCeil; x <= radiusCeil; x++) {
+            const numBytes = this.height * this.width * this.itemSize;
+            this.data = new Uint8Array(numBytes);
 
-            if (x * x + y2 <= r2) {
-                visitor(offsetX + x, offsetY + y, this);
-            }
+            buffer.readBytes(this.data, 0, numBytes);
 
+            this.version++;
+        } else {
+            throw new TypeError(`Unsupported data type (${dataType})`);
         }
     }
-};
 
-/**
- *
- * @param {number} x
- * @param {number} y
- * @param {boolean} [preserveData=true]
- */
-Sampler2D.prototype.resize = function (x, y, preserveData = true) {
-    assert.isNonNegativeInteger(x, 'x');
-    assert.isNonNegativeInteger(y, 'y');
+    /**
+     *
+     * @param {number} x
+     * @param {number} y
+     * @param {function(x:number, y:number, value:number, index:number):boolean?} visitor
+     * @param {*} [thisArg]
+     */
+    traverseOrthogonalNeighbours(x, y, visitor, thisArg) {
+        const width = this.width;
+        const height = this.height;
 
-    const _w = this.width;
-    const _h = this.height;
+        const index = this.point2index(x, y);
 
-    if (_w === x && _h === y) {
-        // size didn't change
-        return;
+        let i = 0;
+        const data = this.data;
+        if (x > 0) {
+            i = index - 1;
+            visitor.call(thisArg, x - 1, y, data[i], i);
+        }
+        if (x < width - 1) {
+            i = index + 1;
+            visitor.call(thisArg, x + 1, y, data[i], i);
+        }
+        if (y > 0) {
+            i = index - width;
+            visitor.call(thisArg, x, y - 1, data[i], i);
+        }
+        if (y < height - 1) {
+            i = index + width;
+            visitor.call(thisArg, x, y + 1, data[i], i);
+        }
     }
 
-    const itemSize = this.itemSize;
-
-    const length = x * y * itemSize;
+    /**
+     * @returns {Sampler2D}
+     */
+    clone() {
+        let data_clone;
 
-    const oldData = this.data;
+        if (Array.isArray(this.data)) {
+            data_clone = this.data.slice();
+        } else {
+            // storage is a typed array
+            const T = this.data.constructor;
 
-    const Constructor = typedArrayConstructorByInstance(oldData);
+            data_clone = new T(this.data);
+        }
 
-    const newData = new Constructor(length);
+        return new Sampler2D(data_clone, this.itemSize, this.width, this.height);
+    }
 
-    if (preserveData) {
-        //copy old data
-        if (x === _w) {
-            // number of columns is preserved, we can just copy the old data across
-            newData.set(oldData.subarray(0, Math.min(oldData.length, length)));
-        } else {
-            //we need to copy new data row-by-row
-            const rowCount = min2(y, _h);
+    toJSON() {
+        return {
+            height: this.height,
+            width: this.width,
+            itemSize: this.itemSize,
+            type: typedArrayToDataType(this.data),
+            data: Array.from(this.data)
+        }
+    }
 
-            const columnCount = min2(x, _w);
+    fromJSON({ height, width, itemSize, type, data }) {
+        const CTOR = compute_typed_array_constructor_from_data_type(type);
 
-            for (let i = 0; i < rowCount; i++) {
-                for (let j = 0; j < columnCount; j++) {
+        this.data = new CTOR(data);
+        this.height = height;
+        this.width = width;
+        this.itemSize = itemSize;
+    }
 
-                    const targetItemAddress = (i * x + j) * itemSize;
-                    const sourceItemAddress = (i * _w + j) * itemSize;
+    /**
+     *
+     * @param {int} itemSize
+     * @param {int} width
+     * @param {int} height
+     * @return {Sampler2D}
+     */
+    static uint8clamped(itemSize, width, height) {
+        const data = new Uint8ClampedArray(width * height * itemSize);
+        const sampler = new Sampler2D(data, itemSize, width, height);
+        return sampler;
+    }
 
-                    for (let k = 0; k < itemSize; k++) {
+    /**
+     *
+     * @param {int} itemSize
+     * @param {int} width
+     * @param {int} height
+     * @return {Sampler2D}
+     */
+    static uint8(itemSize, width, height) {
+        const data = new Uint8Array(width * height * itemSize);
+        const sampler = new Sampler2D(data, itemSize, width, height);
+        return sampler;
+    }
 
-                        newData[targetItemAddress + k] = oldData[sourceItemAddress + k];
+    /**
+     *
+     * @param {int} itemSize
+     * @param {int} width
+     * @param {int} height
+     * @return {Sampler2D}
+     */
+    static uint16(itemSize, width, height) {
+        const data = new Uint16Array(width * height * itemSize);
+        const sampler = new Sampler2D(data, itemSize, width, height);
+        return sampler;
+    }
 
-                    }
-                }
-            }
-        }
+    /**
+     *
+     * @param {int} itemSize
+     * @param {int} width
+     * @param {int} height
+     * @return {Sampler2D}
+     */
+    static uint32(itemSize, width, height) {
+        const data = new Uint32Array(width * height * itemSize);
+        const sampler = new Sampler2D(data, itemSize, width, height);
+        return sampler;
     }
 
-    this.width = x;
-    this.height = y;
+    /**
+     *
+     * @param {int} itemSize
+     * @param {int} width
+     * @param {int} height
+     * @return {Sampler2D}
+     */
+    static int8(itemSize, width, height) {
+        const data = new Int8Array(width * height * itemSize);
+        const sampler = new Sampler2D(data, itemSize, width, height);
+        return sampler;
+    }
 
-    this.data = newData;
+    /**
+     *
+     * @param {int} itemSize
+     * @param {int} width
+     * @param {int} height
+     * @return {Sampler2D}
+     */
+    static int16(itemSize, width, height) {
+        const data = new Int16Array(width * height * itemSize);
+        const sampler = new Sampler2D(data, itemSize, width, height);
+        return sampler;
+    }
 
-    this.version++;
-};
+    /**
+     *
+     * @param {int} itemSize
+     * @param {int} width
+     * @param {int} height
+     * @return {Sampler2D}
+     */
+    static int32(itemSize, width, height) {
+        const data = new Int32Array(width * height * itemSize);
+        const sampler = new Sampler2D(data, itemSize, width, height);
+        return sampler;
+    }
 
-/**
- * Estimate memory requirement of the object
- * @return {number}
- */
-Sampler2D.prototype.computeByteSize = function () {
-    let dataSize;
+    /**
+     *
+     * @param {int} itemSize
+     * @param {int} width
+     * @param {int} height
+     * @return {Sampler2D}
+     */
+    static float32(itemSize, width, height) {
+        const data = new Float32Array(width * height * itemSize);
+        const sampler = new Sampler2D(data, itemSize, width, height);
+        return sampler;
+    }
 
-    if (Array.isArray(this.data)) {
-        dataSize = 8 * this.data.length;
-    } else {
-        dataSize = this.data.buffer.byteLength;
+    /**
+     *
+     * @param {int} itemSize
+     * @param {int} width
+     * @param {int} height
+     * @return {Sampler2D}
+     */
+    static float64(itemSize, width, height) {
+        const data = new Float64Array(width * height * itemSize);
+        const sampler = new Sampler2D(data, itemSize, width, height);
+        return sampler;
     }
 
-    return dataSize + 280;
-};
+    /**
+     *
+     * @param {Sampler2D} input0
+     * @param {Sampler2D} input1
+     * @param {Sampler2D} result
+     * @param {function( value0 : number[], value1 : number[], result : number[], index : number) : void} operation
+     */
+    static combine(input0, input1, result, operation) {
+        assert.notEqual(input0, undefined, "input0 is undefined");
+        assert.notEqual(input1, undefined, "input1 is undefined");
+        assert.notEqual(result, undefined, "result is undefined");
 
+        assert.typeOf(operation, "function", "operation");
 
-/**
- * @deprecated Use {@link Sampler2DSerializationAdapter} adapter instead
- * @param {BinaryBuffer} buffer
- */
-Sampler2D.prototype.toBinaryBuffer = function (buffer) {
-    const width = this.width;
-    const height = this.height;
+        assert.equal(input0.width, input1.width, `input0.width(=${input0.width}) is not equal to input1.width(=${input1.width})`);
+        assert.equal(input0.height, input1.height, `input0.height(=${input0.height}) is not equal to input1.height(=${input1.height})`);
 
-    const itemSize = this.itemSize;
+        assert.equal(input0.width, result.width, `input width(=${input0.width}) is not equal to result.width(=${result.width})`);
+        assert.equal(input0.height, result.height, `input height(=${input0.height}) is not equal to result.height(=${result.height})`);
 
-    buffer.writeUint16(width);
-    buffer.writeUint16(height);
+        const width = input0.width;
+        const height = input0.height;
 
-    buffer.writeUint8(itemSize);
+        const length = width * height;
 
-    if (this.data instanceof Uint8Array) {
-        //data type
-        buffer.writeUint8(0);
+        const arg0 = [];
+        const arg1 = [];
+        const res = [];
 
+        const itemSize0 = input0.itemSize;
+        const itemSize1 = input1.itemSize;
+        const itemSizeR = result.itemSize;
 
-        const byteSize = width * height * itemSize;
+        const data0 = input0.data;
+        const data1 = input1.data;
+        const dataR = result.data;
 
-        buffer.writeBytes(this.data, 0, byteSize);
 
-    } else {
-        throw new TypeError(`Unsupported data type`);
-    }
-};
+        let i, j;
 
-/**
- * @deprecated Use {@link Sampler2DSerializationAdapter} adapter instead
- * @param {BinaryBuffer} buffer
- */
-Sampler2D.prototype.fromBinaryBuffer = function (buffer) {
-    this.width = buffer.readUint16();
-    this.height = buffer.readUint16();
+        for (i = 0; i < length; i++) {
 
-    this.itemSize = buffer.readUint8();
+            // read input 0
+            for (j = 0; j < itemSize0; j++) {
+                arg0[j] = data0[j + i * itemSize0];
+            }
 
-    const dataType = buffer.readUint8();
+            // read input 1
+            for (j = 0; j < itemSize0; j++) {
+                arg1[j] = data1[j + i * itemSize1];
+            }
 
-    if (dataType === 0) {
+            //perform operation
+            operation(arg0, arg1, res, i);
 
-        const numBytes = this.height * this.width * this.itemSize;
-        this.data = new Uint8Array(numBytes);
+            //write result
+            for (j = 0; j < itemSizeR; j++) {
+                dataR[j + i * itemSizeR] = res[j];
+            }
 
-        buffer.readBytes(this.data, 0, numBytes);
+        }
 
-        this.version++;
-    } else {
-        throw new TypeError(`Unsupported data type (${dataType})`);
+        result.version++;
     }
-};
+}
+
 
 /**
- *
- * @param {number} x
- * @param {number} y
- * @param {function(x:number, y:number, value:number, index:number):boolean?} visitor
- * @param {*} [thisArg]
+ * 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}
  */
-Sampler2D.prototype.traverseOrthogonalNeighbours = function (x, y, visitor, thisArg) {
-    const width = this.width;
-    const height = this.height;
-
-    const index = this.point2index(x, y);
+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;
+}
 
-    let i = 0;
-    const data = this.data;
-    if (x > 0) {
-        i = index - 1;
-        visitor.call(thisArg, x - 1, y, data[i], i);
-    }
-    if (x < width - 1) {
-        i = index + 1;
-        visitor.call(thisArg, x + 1, y, data[i], i);
-    }
-    if (y > 0) {
-        i = index - width;
-        visitor.call(thisArg, x, y - 1, data[i], i);
-    }
-    if (y < height - 1) {
-        i = index + width;
-        visitor.call(thisArg, x, y + 1, data[i], i);
-    }
-};
 
 /**
- * @returns {Sampler2D}
+ *
+ * @param {number[]} source
+ * @param {number[]} destination
+ * @param {Array} result
  */
-Sampler2D.prototype.clone = function () {
-    let data_clone;
-
-    if (Array.isArray(this.data)) {
-        data_clone = this.data.slice();
-    } else {
-        // storage is a typed array
-        const T = this.data.constructor;
+function blendFunctionNormal(source, destination, result) {
 
-        data_clone = new T(this.data);
-    }
+    const a1 = source[3] / 255;
+    const a0 = destination[3] / 255;
 
-    return new Sampler2D(data_clone, this.itemSize, this.width, this.height);
-};
+    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;
+}
 
-/**
- * @readonly
- * @type {boolean}
- */
-Sampler2D.prototype.isSampler2D = true;