@woosh/meep-engine 2.45.2 → 2.46.1

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

@@ -1,1683 +0,0 @@
-/**
- * Created by Alex on 11/11/2014.
- */
-
-
-import { clamp } from "../../../../core/math/clamp.js";
-import { max2 } from "../../../../core/math/max2.js";
-import { min2 } from "../../../../core/math/min2.js";
-import { mix } from "../../../../core/math/mix.js";
-import { BlendingType } from "./BlendingType.js";
-import { assert } from "../../../../core/assert.js";
-import { typedArrayConstructorByInstance } from "./typedArrayConstructorByInstance.js";
-import { typedArrayToDataType } from "../../../../core/collection/array/typedArrayToDataType.js";
-import {
-    compute_typed_array_constructor_from_data_type
-} from "../../../../core/collection/table/DataType2TypedArrayConstructorMapping.js";
-import { Base64 } from "../../../../core/binary/Base64.js";
-import { computeStridedIntegerArrayHash } from "../../../computeStridedIntegerArrayHash.js";
-import { is_typed_array_equals } from "../../../../core/collection/array/typed/is_typed_array_equals.js";
-
-/**
- * @class
- */
-export class Sampler2D {
-    /**
-     *
-     * @param {ArrayLike<number>|number[]|Uint8ClampedArray|Uint8Array|Uint16Array|Uint32Array|Int8Array|Int16Array|Int32Array|Float32Array|Float64Array} data
-     * @param {number} itemSize
-     * @param {number} width
-     * @param {number} height
-     * @constructor
-     */
-    constructor(data = [], itemSize = 1, width = 0, height = 0) {
-        if (!Number.isInteger(itemSize) || itemSize < 0) {
-            throw new Error(`itemSize must be a non-negative integer, instead was ${itemSize}`);
-        }
-        if (!Number.isInteger(width) || itemSize < 0) {
-            throw new Error(`width must be a non-negative integer, instead was ${width}`);
-        }
-        if (!Number.isInteger(height) || itemSize < 0) {
-            throw new Error(`height must be a non-negative integer, instead was ${height}`);
-        }
-
-        if (data === undefined) {
-            throw new Error("data was undefined");
-        }
-
-        /**
-         *
-         * @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;
-    }
-
-    /**
-     * @param {number} [channel=0]
-     * @returns {{x: number, index: number, y: number, value: number}}
-     */
-    computeMax(channel = 0) {
-        const itemSize = this.itemSize;
-
-        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}`);
-
-        const data = this.data;
-
-        const l = data.length;
-
-        if (l === 0) {
-            //no data
-            return undefined;
-        }
-
-        let bestValue = data[channel];
-        let bestIndex = channel;
-
-        for (let i = channel + itemSize; i < l; i += itemSize) {
-            const value = data[i];
-
-            if (bestValue < value) {
-                bestValue = value;
-                bestIndex = i;
-            }
-
-        }
-
-        const width = this.width;
-
-        const itemIndex = (bestIndex / this.itemSize) | 0;
-
-        const x = itemIndex % width;
-        const y = (itemIndex / width) | 0;
-
-        return {
-            index: bestIndex,
-            value: bestValue,
-            x,
-            y
-        };
-    }
-
-    /**
-     * @param {number[]} result
-     * @param {number} [channel=0]
-     */
-    computeMinIndices(result, channel = 0) {
-        const itemSize = this.itemSize;
-
-        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 data = this.data;
-
-        const l = data.length;
-
-        if (l === 0) {
-            //no data
-            return undefined;
-        }
-
-        let bestValue = data[channel];
-
-        let resultCount = 0;
-
-        for (let i = channel + itemSize; i < l; i += itemSize) {
-            const value = data[i];
-
-            if (bestValue > value) {
-                bestValue = value;
-                //drop result
-                resultCount = 1;
-
-                result[0] = i;
-            } else if (value === bestValue) {
-                result[resultCount++] = i;
-            }
-
-        }
-
-        //crop results
-        if (resultCount < result.length) {
-            result.splice(resultCount, result.length - resultCount);
-        }
-
-        return;
-    }
-
-    /**
-     * @param {number} [channel=0]
-     * @returns {{x: number, index: number, y: number, value: number}}
-     */
-    computeMin(channel = 0) {
-        const itemSize = this.itemSize;
-
-        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}`);
-
-        const data = this.data;
-
-        const l = data.length;
-
-        if (l === 0) {
-            //no data
-            return undefined;
-        }
-
-        let bestValue = data[channel];
-        let bestIndex = channel;
-
-        for (let i = channel + itemSize; i < l; i += itemSize) {
-            const value = data[i];
-
-            if (bestValue > value) {
-                bestValue = value;
-                bestIndex = i;
-            }
-
-        }
-
-        const width = this.width;
-
-        const itemIndex = (bestIndex / this.itemSize) | 0;
-
-        const x = itemIndex % width;
-        const y = (itemIndex / width) | 0;
-
-        return {
-            index: bestIndex,
-            value: bestValue,
-            x,
-            y
-        };
-    }
-
-    /**
-     *
-     * @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");
-
-        const t = [];
-
-        this.sampleBilinear(x, y, t, 0);
-
-        if (result !== undefined) {
-            result.readFromArray(t, 0);
-            return result;
-        } else {
-            return t[0];
-        }
-    }
-
-    /**
-     *
-     * @param {number} u
-     * @param {number} v
-     * @param {number[]} result
-     */
-    sampleCatmullRomUV(u, v, result) {
-        const itemSize = this.itemSize;
-
-        for (let i = 0; i < itemSize; i++) {
-            result[i] = this.sampleChannelCatmullRomUV(u, v, i);
-        }
-    }
-
-    /**
-     *
-     * @param {number} u
-     * @param {number} v
-     * @param {number} channel
-     * @returns {number}
-     */
-    sampleChannelCatmullRomUV(u, v, channel) {
-        const x = u * (this.width - 1);
-        const y = v * (this.height - 1);
-
-        return this.sampleChannelCatmullRom(x, y, channel);
-    }
-
-    /**
-     *
-     * @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;
-
-        return result;
-    }
-
-    /**
-     *
-     * @param {number} u
-     * @param {number} v
-     * @param {number[]} result
-     */
-    sampleBicubicUV(u, v, result) {
-        const itemSize = this.itemSize;
-
-        for (let i = 0; i < itemSize; i++) {
-            result[i] = this.sampleChannelBicubicUV(u, v, i);
-        }
-    }
-
-    /**
-     *
-     * @param {number} u
-     * @param {number} v
-     * @param {number} channel
-     * @returns {number}
-     */
-    sampleChannelBicubicUV(u, v, channel) {
-        const x = u * (this.width - 1);
-        const y = v * (this.height - 1);
-
-        return this.sampleChannelBicubic(x - 0.5, y - 0.5, channel);
-    }
-
-    /**
-     * Bicubic-filtered sampling
-     * @param {number} x
-     * @param {number} y
-     * @param {number} channel
-     * @returns {number}
-     */
-    sampleChannelBicubic(x, y, channel) {
-
-        const itemSize = this.itemSize;
-
-        const width = this.width;
-        const height = this.height;
-
-        const data = this.data;
-
-        const rowSize = width * itemSize;
-
-        const x_max = width - 1;
-        const y_max = height - 1;
-
-        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;
-
-        const xd = clamped_x - x1;
-        const yd = clamped_y - y1;
-
-        const x0 = max2(0, x1 - 1);
-        const y0 = max2(0, y1 - 1);
-
-        const x2 = min2(x_max, x1 + 1);
-        const y2 = min2(y_max, y1 + 1);
-
-        const x3 = min2(x_max, x2 + 1);
-        const y3 = min2(y_max, y2 + 1);
-
-        // 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;
-
-        const col0_offset = x0 * itemSize;
-        const col1_offset = x1 * itemSize;
-        const col2_offset = x2 * itemSize;
-        const col3_offset = x3 * 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];
-
-        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];
-
-        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 bicubic(xd, yd,
-        //     vi0, vi1, vi2, vi3,
-        //     vj0, vj1, vj2, vj3,
-        //     vk0, vk1, vk2, vk3,
-        //     vl0, vl1, vl2, vl3,
-        // );
-
-
-        // perform filtering in X (rows)
-        const s0 = bicubic_terp(xd, vi0, vi1, vi2, vi3);
-        const s1 = bicubic_terp(xd, vj0, vj1, vj2, vj3);
-        const s2 = bicubic_terp(xd, vk0, vk1, vk2, vk3);
-        const s3 = bicubic_terp(xd, vl0, vl1, vl2, vl3);
-
-        // filter in Y (columns)
-        return bicubic_terp(yd, s0, s1, s2, s3);
-    }
-
-    /**
-     *
-     * @param {number} u
-     * @param {number} v
-     * @param {number[]} result
-     * @param {number} result_offset
-     */
-    sampleBilinearUV(u, v, result, result_offset = 0) {
-
-        const itemSize = this.itemSize;
-
-        for (let i = 0; i < itemSize; i++) {
-            result[i + result_offset] = this.sampleChannelBilinearUV(u, v, i);
-
-        }
-    }
-
-    /**
-     *
-     * @param {number} x
-     * @param {number} y
-     * @param {number[]} result
-     * @param {number} result_offset
-     */
-    sampleBilinear(x, y, result, result_offset = 0) {
-
-        const itemSize = this.itemSize;
-
-        for (let i = 0; i < itemSize; i++) {
-            //TODO this can be optimized greatly
-            result[i + result_offset] = this.sampleChannelBilinear(x, y, i);
-
-        }
-    }
-
-    /**
-     *
-     * @param {number} u
-     * @param {number} v
-     * @param {number} channel
-     * @return {number}
-     */
-    sampleChannelBilinearUV(u, v, channel) {
-        const x = u * (this.width - 1);
-        const y = v * (this.height - 1);
-
-        return this.sampleChannelBilinear(x, y, channel);
-    }
-
-    /**
-     *
-     * @param {number} x
-     * @param {number} y
-     * @param {number} channel
-     * @returns {number}
-     */
-    sampleChannelBilinear(x, y, channel) {
-        assert.isNonNegativeInteger(channel, 'channel');
-
-        const itemSize = this.itemSize;
-
-        const width = this.width;
-        const height = this.height;
-
-        const rowSize = width * itemSize;
-
-        //sample 4 points
-        const x_max = width - 1;
-        const y_max = height - 1;
-
-        const clamped_x = clamp(x, 0, x_max);
-        const clamped_y = clamp(y, 0, y_max);
-
-        const x0 = clamped_x | 0;
-        const y0 = clamped_y | 0;
-
-        //
-        const row0 = y0 * rowSize;
-        const col0_offset = x0 * itemSize + channel;
-
-        const i0 = row0 + col0_offset;
-
-        //
-        let x1, y1;
-
-        if (clamped_x === x0 || x0 >= x_max) {
-            x1 = x0;
-        } else {
-            x1 = x0 + 1;
-        }
-
-
-        if (clamped_y === y0 || y0 >= y_max) {
-            y1 = y0;
-        } else {
-            y1 = y0 + 1;
-        }
-
-        const data = this.data;
-
-        const q0 = data[i0];
-
-        if (x0 === x1 && y0 === y1) {
-            return q0;
-        }
-
-        //
-        const xd = clamped_x - x0;
-        const yd = clamped_y - y0;
-
-        const col1_offset = x1 * itemSize + channel;
-
-        const i1 = row0 + col1_offset;
-
-        const row1 = y1 * rowSize;
-
-        const j0 = row1 + col0_offset;
-        const j1 = row1 + col1_offset;
-
-        const q1 = data[i1];
-        const p0 = data[j0];
-        const p1 = data[j1];
-
-        // perform Bi-Linear interpolation
-        const s0 = mix(q0, q1, xd);
-        const s1 = mix(p0, p1, xd);
-
-        return mix(s0, s1, yd);
-    }
-
-    sampleNearestUV(u, v, result) {
-        const x = Math.round(u * (this.width - 1));
-        const y = Math.round(v * (this.height - 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");
-
-        assert.isNonNegativeInteger(channel, 'channel');
-
-        const index = (y * this.width + x) * this.itemSize + channel;
-
-        return this.data[index];
-    }
-
-    /**
-     *
-     * @param {number} x
-     * @param {number} y
-     * @param {number[]} result
-     */
-    read(x, y, result) {
-
-        const width = this.width;
-
-        const itemSize = this.itemSize;
-
-        const i0 = (y * width + x) * itemSize;
-
-        for (let i = 0; i < itemSize; i++) {
-            const v = this.data[i0 + i];
-
-            result[i] = v;
-        }
-    }
-
-    /**
-     *
-     * @param {number} u
-     * @param {number} v
-     * @param {Vector4|Vector3|Vector2} [result]
-     * @deprecated
-     */
-    sample(u, v, result) {
-        console.warn("Deprecated method, use sampleBilinear instead");
-
-        const temp = [];
-
-        this.sampleBilinear(u * (this.width - 1), v * (this.height - 1), temp, 0);
-
-        result.readFromArray(temp);
-
-        return temp[0];
-    }
-
-    /**
-     *
-     * @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);
-        }
-    }
-
-    /**
-     *
-     * @param {number} x
-     * @param {number} y
-     * @returns {number}
-     */
-    point2index(x, y) {
-        return x + y * this.width;
-    }
-
-    /**
-     *
-     * @param {number} index
-     * @param {Vector2} result
-     */
-    index2point(index, result) {
-        const width = this.width;
-
-        const x = index % width;
-        const y = (index / width) | 0;
-
-        result.set(x, y);
-    }
-
-    /**
-     *
-     * @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;
-        }
-
-        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;
-        }
-
-        function fillDD3(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] = 255;
-        }
-
-        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;
-        }
-
-        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);
-
-
-        const dRowSize = dItemSize * this.width;
-        const sRowSize = sItemSize * source.width;
-
-        const sData = source.data;
-        const dData = this.data;
-
-        let x, y, i, j;
-
-        let xMax, yMax;
-
-        let dA, sA, dOffset, sOffset;
-        //Write top-left corner
-        sOffset = sourceY * sRowSize + sourceX * dItemSize;
-        for (y = Math.max(0, destinationY - marginTop), yMax = destinationY; y < yMax; y++) {
-            dA = y * dRowSize;
-
-            for (x = Math.max(0, destinationX - marginLeft), xMax = destinationX; x < xMax; x++) {
-
-                dOffset = dA + x * dItemSize;
-
-                for (i = 0; i < _itemSize; i++) {
-                    dData[dOffset + i] = sData[sOffset + i];
-                }
-            }
-        }
-        //Write top margin
-        sA = sourceY * sRowSize;
-        for (y = Math.max(0, destinationY - marginTop), yMax = destinationY; y < yMax; y++) {
-            dA = y * dRowSize;
-
-            for (x = 0; x < width; x++) {
-
-                dOffset = dA + (x + destinationX) * dItemSize;
-                sOffset = sA + (x + sourceX) * dItemSize;
-                for (i = 0; i < _itemSize; i++) {
-                    dData[dOffset + i] = sData[sOffset + i];
-                }
-            }
-        }
-        //Write top-right corner
-        sOffset = sourceY * sRowSize + (sourceX + width - 1) * dItemSize;
-        for (y = Math.max(0, destinationY - marginTop), yMax = destinationY; y < yMax; y++) {
-            dA = y * dRowSize;
-
-            for (x = destinationX + width, xMax = Math.min(this.width, x + marginRight); x < xMax; x++) {
-
-                dOffset = dA + x * dItemSize;
-
-                for (i = 0; i < _itemSize; i++) {
-                    dData[dOffset + i] = sData[sOffset + i];
-                }
-            }
-        }
-        //Write left margin
-        for (y = 0; y < height; y++) {
-            dA = (y + destinationY) * dRowSize;
-            sA = (y + sourceY) * sRowSize;
-
-            sOffset = sA + (sourceX) * dItemSize;
-
-            for (x = Math.max(0, destinationX - marginLeft), xMax = destinationX; x < xMax; x++) {
-
-                dOffset = dA + x * dItemSize;
-
-                for (i = 0; i < _itemSize; i++) {
-                    dData[dOffset + i] = sData[sOffset + i];
-                }
-            }
-        }
-        //write actual patch
-        this.copy(source, sourceX, sourceY, destinationX, destinationY, width, height);
-
-        //Write right margin
-        for (y = 0; y < height; y++) {
-            dA = (y + destinationY) * dRowSize;
-            sA = (y + sourceY) * sRowSize;
-
-            sOffset = sA + (sourceX + width - 1) * dItemSize;
-
-            for (x = destinationX + width, xMax = Math.min(this.width, x + marginRight); x < xMax; x++) {
-
-                dOffset = dA + x * dItemSize;
-
-                for (i = 0; i < _itemSize; i++) {
-                    dData[dOffset + i] = sData[sOffset + i];
-                }
-            }
-        }
-
-        //Write Bottom-left margin
-        sOffset = (sourceY + height - 1) * sRowSize + sourceX * dItemSize;
-        for (y = destinationY + width, yMax = Math.min(this.height, y + marginBottom); y < yMax; y++) {
-            dA = y * dRowSize;
-
-            for (x = Math.max(0, destinationX - marginLeft), xMax = destinationX; x < xMax; x++) {
-
-                dOffset = dA + x * dItemSize;
-
-                for (i = 0; i < _itemSize; i++) {
-                    dData[dOffset + i] = sData[sOffset + i];
-                }
-            }
-        }
-        //Write Bottom margin
-        sA = (sourceY + height - 1) * sRowSize;
-        for (y = destinationY + width, yMax = Math.min(this.height, y + marginBottom); y < yMax; y++) {
-            dA = y * dRowSize;
-
-            for (x = 0; x < width; x++) {
-
-                dOffset = dA + (x + destinationX) * dItemSize;
-                sOffset = sA + (x + sourceX) * dItemSize;
-                for (i = 0; i < _itemSize; i++) {
-                    dData[dOffset + i] = sData[sOffset + i];
-                }
-            }
-        }
-        //Write Bottom-right margin
-        sOffset = (sourceY + height - 1) * sRowSize + (sourceX + width - 1) * dItemSize;
-        for (y = destinationY + width, yMax = Math.min(this.height, y + marginBottom); y < yMax; y++) {
-            dA = y * dRowSize;
-
-            for (x = destinationX + width, xMax = Math.min(this.width, x + marginRight); x < xMax; x++) {
-
-                dOffset = dA + x * dItemSize;
-
-                for (i = 0; i < _itemSize; i++) {
-                    dData[dOffset + i] = sData[sOffset + i];
-                }
-            }
-        }
-
-        this.version++;
-    }
-
-    /**
-     * Copy a patch from another sampler
-     * @param {Sampler2D} source where to copy from
-     * @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
-    ) {
-
-        assert.isNumber(sourceX, 'sourceX');
-        assert.isNumber(sourceY, 'sourceY');
-
-        assert.isNumber(destinationX, 'destinationX');
-        assert.isNumber(destinationY, 'destinationY');
-
-        assert.isNumber(width, 'width');
-        assert.isNumber(height, 'height');
-
-        const _w = Math.min(width, source.width - sourceX, this.width - destinationX);
-        const _h = Math.min(height, source.height - sourceY, this.height - destinationY);
-
-
-        const dItemSize = this.itemSize;
-        const sItemSize = source.itemSize;
-        const _itemSize = Math.min(dItemSize, sItemSize);
-
-
-        const dRowSize = dItemSize * this.width;
-        const sRowSize = sItemSize * source.width;
-
-        const sData = source.data;
-        const dData = this.data;
-
-        let x, y, i;
-
-        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
-     */
-    copy_sameItemSize(source, sourceX, sourceY, destinationX, destinationY, width, height) {
-        const itemSize = this.itemSize;
-        const sItemSize = source.itemSize;
-
-        assert.equal(sItemSize, sItemSize, `source.itemSize(=${sItemSize}) != this.itemSize(=${itemSize})`);
-
-        const _w = Math.min(width, source.width - sourceX, this.width - destinationX);
-        const _h = Math.min(height, source.height - sourceY, this.height - destinationY);
-
-
-        const dRowSize = itemSize * this.width;
-        const sRowSize = itemSize * source.width;
-
-        const sData = source.data;
-        const dData = this.data;
-
-        const patchRowSize = _w * itemSize;
-
-        let y, i;
-
-        for (y = 0; y < _h; y++) {
-            const dA = (y + destinationY) * dRowSize;
-            const sA = (y + sourceY) * sRowSize;
-
-            const dOffset = dA + destinationX * itemSize;
-            const sOffset = sA + sourceX * itemSize;
-
-            for (i = 0; i < patchRowSize; i++) {
-
-                dData[dOffset + i] = sData[sOffset + i];
-
-            }
-        }
-
-        this.version++;
-    }
-
-    /**
-     * Assumes both samplers are uint8 with values 0-255
-     * @param {Sampler2D} source
-     * @param sourceX
-     * @param sourceY
-     * @param destinationX
-     * @param destinationY
-     * @param width
-     * @param height
-     * @param {BlendingType} [blendMode]
-     */
-    paint(source, sourceX, sourceY, destinationX, destinationY, width, height, blendMode = BlendingType.Normal) {
-        let blendFunction;
-        if (blendMode === BlendingType.Normal) {
-            blendFunction = blendFunctionNormal;
-        } else {
-            throw new Error(`Unsupported blendType(=${blendMode})`);
-        }
-
-        const _w = Math.min(width, source.width - sourceX, this.width - destinationX);
-        const _h = Math.min(height, source.height - sourceY, this.height - destinationY);
-
-        const _x0 = Math.max(0, -destinationX);
-        const _y0 = Math.max(0, -destinationY);
-
-        const c0 = [0, 0, 0, 255];
-        const c1 = [0, 0, 0, 255];
-
-        const c3 = [];
-
-        let x, y;
-
-        for (y = _y0; y < _h; y++) {
-            for (x = _x0; x < _w; x++) {
-                const d_x = Math.round(x + destinationX);
-                const d_y = Math.round(y + destinationY);
-
-                this.read(d_x, d_y, c0);
-
-                const s_x = Math.round(x + sourceY);
-                const s_y = Math.round(y + sourceY);
-
-                source.read(s_x, s_y, c1);
-
-                blendFunction(c1, c0, c3);
-
-                this.set(d_x, d_y, c3);
-
-            }
-        }
-
-
-    }
-
-    /**
-     * Fill data values with zeros for a given area
-     * @param {Number} x
-     * @param {Number} y
-     * @param {Number} width
-     * @param {Number} height
-     */
-    zeroFill(x, y, width, height) {
-        assert.isNonNegativeInteger(width, 'width');
-        assert.isNonNegativeInteger(height, 'height');
-
-        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);
-
-        // console.log(`#zerofill x:${x}, y:${y}, width:${width}, height:${height} \t -> \t x0:${x0}, y0:${y0}, x1:${x1}, y1:${y1}`); // DEBUG
-
-        const data = this.data;
-        const itemSize = this.itemSize;
-
-        const rowSize = itemSize * this.width;
-
-        const clearRowOffset0 = x0 * itemSize;
-        const clearRowOffset1 = x1 * itemSize;
-
-        let _y;
-
-        for (_y = y0; _y < y1; _y++) {
-
-            const a = _y * rowSize;
-
-            data.fill(0, a + clearRowOffset0, a + clearRowOffset1);
-
-        }
-
-        this.version++;
-    }
-
-    /**
-     *
-     * @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++;
-    }
-
-    /**
-     *
-     * @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);
-
-        const data = this.data;
-        const itemSize = this.itemSize;
-
-        const rowSize = itemSize * _w;
-
-        let _y, _x, i;
-
-        for (_y = y0; _y < y1; _y++) {
-
-            const a = _y * rowSize;
-
-            for (_x = x0; _x < x1; _x++) {
-
-                const offset = a + _x * itemSize;
-
-                for (i = 0; i < itemSize; i++) {
-
-                    data[offset + i] = value[i];
-
-                }
-
-            }
-        }
-
-        this.version++;
-    }
-
-    /**
-     * 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");
-
-        assert.greaterThanOrEqual(x, 0);
-        assert.greaterThanOrEqual(y, 0);
-        assert.lessThan(x, this.width);
-        assert.lessThan(y, this.height);
-
-        const pointIndex = y * this.width + x;
-        const pointAddress = pointIndex * this.itemSize;
-        const channelAddress = pointAddress + channel;
-
-        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;
-
-        for (let i = 0; i < itemSize; i++) {
-            data[offset + i] = value[i];
-        }
-
-        this.version++;
-    }
-
-    /**
-     * 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;
-
-        //convert offsets to integers for safety
-        const offsetX = centerX | 0;
-        const offsetY = centerY | 0;
-
-        const r2 = radius * radius;
-
-        const radiusCeil = Math.ceil(radius);
-
-        for (y = -radiusCeil; y <= radiusCeil; y++) {
-            const y2 = y * y;
-
-            for (x = -radiusCeil; x <= radiusCeil; x++) {
-
-                if (x * x + y2 <= r2) {
-                    visitor(offsetX + x, offsetY + y, this);
-                }
-
-            }
-        }
-    }
-
-    /**
-     *
-     * @param {number} x
-     * @param {number} y
-     * @param {boolean} [preserveData=true]
-     */
-    resize(x, y, preserveData = true) {
-        assert.isNonNegativeInteger(x, 'x');
-        assert.isNonNegativeInteger(y, 'y');
-
-        const _w = this.width;
-        const _h = this.height;
-
-        if (_w === x && _h === y) {
-            // size didn't change
-            return;
-        }
-
-        const itemSize = this.itemSize;
-
-        const length = x * y * itemSize;
-
-        const oldData = this.data;
-
-        const Constructor = typedArrayConstructorByInstance(oldData);
-
-        const newData = new Constructor(length);
-
-        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);
-
-                const columnCount = min2(x, _w);
-
-                for (let i = 0; i < rowCount; i++) {
-                    for (let j = 0; j < columnCount; j++) {
-
-                        const targetItemAddress = (i * x + j) * itemSize;
-                        const sourceItemAddress = (i * _w + j) * itemSize;
-
-                        for (let k = 0; k < itemSize; k++) {
-
-                            newData[targetItemAddress + k] = oldData[sourceItemAddress + k];
-
-                        }
-                    }
-                }
-            }
-        }
-
-        this.width = x;
-        this.height = y;
-
-        this.data = newData;
-
-        this.version++;
-    }
-
-    /**
-     * Estimate memory requirement of the object
-     * @return {number}
-     */
-    computeByteSize() {
-        let dataSize;
-
-        if (Array.isArray(this.data)) {
-            dataSize = 8 * this.data.length;
-        } else {
-            dataSize = this.data.buffer.byteLength;
-        }
-
-        return dataSize + 280;
-    }
-
-    /**
-     * @deprecated Use {@link Sampler2DSerializationAdapter} adapter instead
-     * @param {BinaryBuffer} buffer
-     */
-    toBinaryBuffer(buffer) {
-        const width = this.width;
-        const height = this.height;
-
-        const itemSize = this.itemSize;
-
-        buffer.writeUint16(width);
-        buffer.writeUint16(height);
-
-        buffer.writeUint8(itemSize);
-
-        if (this.data instanceof Uint8Array) {
-            //data type
-            buffer.writeUint8(0);
-
-
-            const byteSize = width * height * itemSize;
-
-            buffer.writeBytes(this.data, 0, byteSize);
-
-        } else {
-            throw new TypeError(`Unsupported data type`);
-        }
-    }
-
-    /**
-     * @deprecated Use {@link Sampler2DSerializationAdapter} adapter instead
-     * @param {BinaryBuffer} buffer
-     */
-    fromBinaryBuffer(buffer) {
-        this.width = buffer.readUint16();
-        this.height = buffer.readUint16();
-
-        this.itemSize = buffer.readUint8();
-
-        const dataType = buffer.readUint8();
-
-        if (dataType === 0) {
-
-            const numBytes = this.height * this.width * this.itemSize;
-            this.data = new Uint8Array(numBytes);
-
-            buffer.readBytes(this.data, 0, numBytes);
-
-            this.version++;
-        } else {
-            throw new TypeError(`Unsupported data type (${dataType})`);
-        }
-    }
-
-    /**
-     *
-     * @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 index = this.point2index(x, y);
-
-        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);
-        }
-    }
-
-    /**
-     *
-     * @param {Sampler2D} other
-     * @return {boolean}
-     */
-    equals(other) {
-        if (
-            this.width !== other.width
-            || this.height !== other.height
-            || this.itemSize !== other.itemSize
-        ) {
-            return false;
-        }
-
-        return is_typed_array_equals(this.data, other.data);
-    }
-
-    /**
-     *
-     * @return {number}
-     */
-    hash() {
-        let hash = (((this.width & 0xFFFF) << 16) | (this.height & 0xFFFF)) ^ this.itemSize;
-
-        const length = this.data.length;
-
-        const stride = Math.max(1, Math.ceil(length / 509));
-
-        hash ^= computeStridedIntegerArrayHash(this.data, 0, length, stride);
-
-        return hash;
-    }
-
-
-    /**
-     * @returns {Sampler2D}
-     */
-    clone() {
-        let data_clone;
-
-        if (Array.isArray(this.data)) {
-            data_clone = this.data.slice();
-        } else {
-            // storage is a typed array
-            const T = this.data.constructor;
-
-            data_clone = new T(this.data);
-        }
-
-        return new Sampler2D(data_clone, this.itemSize, this.width, this.height);
-    }
-
-    toJSON() {
-        const encoded = Base64.encode(this.data.buffer);
-
-        return {
-            height: this.height,
-            width: this.width,
-            itemSize: this.itemSize,
-            type: typedArrayToDataType(this.data),
-            data: encoded
-        }
-    }
-
-    fromJSON({ height, width, itemSize, type, data }) {
-        const CTOR = compute_typed_array_constructor_from_data_type(type);
-
-        if (typeof data === "string") {
-
-            const decoded = Base64.decode(data);
-
-            this.data = new CTOR(decoded);
-
-        } else if (Array.isArray(data)) {
-            // deprecated
-            console.warn('Array JSON format is deprecated, please upgrade your data as soon as possible');
-
-            this.data = new CTOR(data);
-
-        } else {
-
-            throw new Error('Unsupported data format');
-
-        }
-
-        this.height = height;
-        this.width = width;
-        this.itemSize = 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;
-    }
-
-    /**
-     *
-     * @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;
-    }
-
-    /**
-     *
-     * @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;
-    }
-
-    /**
-     *
-     * @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;
-    }
-
-    /**
-     *
-     * @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;
-    }
-
-    /**
-     *
-     * @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;
-    }
-
-    /**
-     *
-     * @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;
-    }
-
-    /**
-     *
-     * @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;
-    }
-
-}
-
-
-/**
- * Based on code from reddit https://www.reddit.com/r/javascript/comments/jxa8x/bicubic_interpolation/
- * @param {number} t
- * @param {number} a
- * @param {number} b
- * @param {number} c
- * @param {number} d
- * @returns {number}
- */
-function bicubic_terp(t, a, b, c, d) {
-    return 0.5 * (c - a + (2.0 * a - 5.0 * b + 4.0 * c - d + (3.0 * (b - c) + d - a) * t) * t) * t + b;
-}
-
-
-/**
- *
- * @param {number[]} source
- * @param {number[]} destination
- * @param {Array} result
- */
-function blendFunctionNormal(source, destination, result) {
-
-    const a1 = source[3] / 255;
-    const a0 = destination[3] / 255;
-
-    result[0] = source[0] * a1 + destination[0] * (1 - a1);
-    result[1] = source[1] * a1 + destination[1] * (1 - a1);
-    result[2] = source[2] * a1 + destination[2] * (1 - a1);
-    result[3] = (a1 + a0 * (1 - a1)) * 255;
-}
-
-