@woosh/meep-engine 2.37.17 → 2.37.20

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

@@ -10,131 +10,11 @@ import { mix } from "../../../../core/math/mix.js";
 import { BlendingType } from "./BlendingType.js";
 import { assert } from "../../../../core/assert.js";
 import { typedArrayConstructorByInstance } from "./typedArrayConstructorByInstance.js";
-import { fract } from "../../../../core/math/fract.js";
-
-function v2CrossMag(ax, ay, bx, by) {
-    return ax * by - ay * bx;
-}
-
-
-function sampleTriangleM2(f2_x, f2_y, f3_x, f3_y, f1_x, f1_y, p1, p2, p3) {
-    const a = 0.5; // main triangle cross product
-    const a1 = v2CrossMag(f2_x, f2_y, f3_x, f3_y) / a;
-    const a2 = v2CrossMag(f3_x, f3_y, f1_x, f1_y) / a;
-    const a3 = v2CrossMag(f1_x, f1_y, f2_x, f2_y) / a;
-    return p1 * a1 + p2 * a2 + p3 * a3;
-}
-
-function interpolateVectors1(v_0_0, v_1_0, v_0_1, v_1_1, xd, yd, result) {
-    return filterFunctionBilinear(v_0_0, v_1_0, v_0_1, v_1_1, xd, yd);
-}
-
-//
-function interpolateVectors2(v_0_0, v_1_0, v_0_1, v_1_1, xd, yd, result) {
-    result.x = filterFunctionBilinear(v_0_0.x, v_1_0.x, v_0_1.x, v_1_1.x, xd, yd);
-    result.y = filterFunctionBilinear(v_0_0.y, v_1_0.y, v_0_1.y, v_1_1.y, xd, yd);
-    return result;
-}
-
-function interpolateVectors3(v_0_0, v_1_0, v_0_1, v_1_1, xd, yd, result) {
-    result.x = filterFunctionBilinear(v_0_0.x, v_1_0.x, v_0_1.x, v_1_1.x, xd, yd);
-    result.y = filterFunctionBilinear(v_0_0.y, v_1_0.y, v_0_1.y, v_1_1.y, xd, yd);
-    result.z = filterFunctionBilinear(v_0_0.z, v_1_0.z, v_0_1.z, v_1_1.z, xd, yd);
-    return result;
-}
-
-function interpolateVectors4(v_0_0, v_1_0, v_0_1, v_1_1, xd, yd, result) {
-    result.x = filterFunctionBilinear(v_0_0.x, v_1_0.x, v_0_1.x, v_1_1.x, xd, yd);
-    result.y = filterFunctionBilinear(v_0_0.y, v_1_0.y, v_0_1.y, v_1_1.y, xd, yd);
-    result.z = filterFunctionBilinear(v_0_0.z, v_1_0.z, v_0_1.z, v_1_1.z, xd, yd);
-    result.w = filterFunctionBilinear(v_0_0.w, v_1_0.w, v_0_1.w, v_1_1.w, xd, yd);
-    return result;
-}
 
 
-/**
- * Quad interpolation
- * @param {number} q0
- * @param {number} q1
- * @param {number} p0
- * @param {number} p1
- * @param {number} xd
- * @param {number} yd
- * @returns {number}
- */
-function filterFunction_(q0, q1, p0, p1, xd, yd) {
-    //
-    const s0 = mix(q0, q1, xd);
-    const s1 = mix(p0, p1, xd);
-    const t0 = mix(q0, p0, yd);
-    const t1 = mix(q1, p1, yd);
-    //
-    const u = mix(s0, s1, yd);
-    const v = mix(t0, t1, xd);
-    //
-    const total = u + v;
-    return total / 2;
-}
-
-/**
- * Bi-Linear interpolation
- * @param q0
- * @param q1
- * @param p0
- * @param p1
- * @param xd
- * @param yd
- * @returns {*}
- */
-function filterFunctionBilinear(q0, q1, p0, p1, xd, yd) {
-
-    const s0 = mix(q0, q1, xd);
-    const s1 = mix(p0, p1, xd);
-
-    return mix(s0, s1, yd);
-}
-
-function filterFunctionSQRT(q0, q1, p0, p1, xd, yd) {
-    function sd(v, x, y) {
-        return v * Math.sqrt(x * x + y * y);
-    }
-
-    return sd(q0, 1 - xd, 1 - yd) + sd(q1, xd, 1 - yd) + sd(p0, 1 - xd, yd) + sd(p1, xd, yd);
-}
-
-function sampleTriangleTopLeft(p1, p2, p3, dx, dy) {
-
-    // calculate vectors from point f to vertices p1, p2 and p3:
-    const f1_x = -dx;
-    const f1_y = -dy;
-
-    const f2_x = 1 - dx;
-    const f2_y = -dy;
-
-    const f3_x = -dx;
-    const f3_y = 1 - dy;
-    // calculate the areas (parameters order is essential in this case):
-    return sampleTriangleM2(f2_x, f2_y, f3_x, f3_y, f1_x, f1_y, p1, p2, p3);
-}
-
-function sampleTriangleBottomRight(p1, p2, p3, dx, dy) {
-
-    // calculate vectors from point f to vertices p1, p2 and p3:
-    const f1_x = 1 - dx;
-    const f1_y = -dy;
-
-    const f2_x = 1 - dx;
-    const f2_y = 1 - dy;
-
-    const f3_x = -dx;
-    const f3_y = 1 - dy;
-    // calculate the areas (parameters order is essential in this case):
-    return sampleTriangleM2(f2_x, f2_y, f3_x, f3_y, f1_x, f1_y, p1, p2, p3);
-}
-
 /**
  *
- * @param {ArrayLike<number>|number[]|Uint8ClampedArray|Uint8Array|Uint16Array|Int8Array|Int16Array|Int32Array|Float32Array|Float64Array} data
+ * @param {ArrayLike<number>|number[]|Uint8ClampedArray|Uint8Array|Uint16Array|Uint32Array|Int8Array|Int16Array|Int32Array|Float32Array|Float64Array} data
  * @param {int} itemSize
  * @param {int} width
  * @param {int} height
@@ -160,6 +40,7 @@ export function Sampler2D(data = [], itemSize = 1, width = 0, height = 0) {
      * @type {Number}
      */
     this.width = width;
+
     /**
      *
      * @type {Number}
@@ -174,9 +55,15 @@ export function Sampler2D(data = [], itemSize = 1, width = 0, height = 0) {
 
     /**
      *
-     * @type {Array<number>|Uint8Array|Uint16Array|Int8Array|Float32Array|Float64Array}
+     * @type {number[]|Uint8ClampedArray|Uint8Array|Uint16Array|Uint32Array|Int8Array|Int16Array|Int32Array|Float32Array|Float64Array}
      */
     this.data = data;
+
+    /**
+     * Used to tracking changes
+     * @type {number}
+     */
+    this.version = 0;
 }
 
 /**
@@ -355,6 +242,8 @@ Sampler2D.combine = function (input0, input1, result, operation) {
         }
 
     }
+
+    result.version++;
 };
 
 
@@ -429,7 +318,6 @@ Sampler2D.prototype.computeMinIndices = function (result, channel = 0) {
     }
 
     let bestValue = data[channel];
-    let bestIndex = channel;
 
     let resultCount = 0;
 
@@ -504,9 +392,6 @@ Sampler2D.prototype.computeMin = function (channel = 0) {
     };
 };
 
-Sampler2D.prototype.initialize = function () {
-};
-
 /**
  *
  * @deprecated
@@ -552,75 +437,81 @@ Sampler2D.prototype.sampleCatmullRomUV = function (u, v, result) {
  * @returns {number}
  */
 Sampler2D.prototype.sampleChannelCatmullRomUV = function (u, v, channel) {
-    const x = u * (this.width - 1);
-    const y = v * (this.height - 1);
+    const x = u * (this.width);
+    const y = v * (this.height);
 
-    return this.sampleChannelCatmullRom(x, y, channel);
+    return this.sampleChannelCatmullRom(x - 0.5, y - 0.5, channel);
 };
 
 /**
  *
- * @see https://www.shadertoy.com/view/NsBfRG
- * @see https://www.decarpentier.nl/2d-catmull-rom-in-4-samples
+ * @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) {
-    // Based on the standard Catmull-Rom spline: w1*C1+w2*C2+w3*C3+w4*C4, where
-    // w1 = ((-0.5*f + 1.0)*f - 0.5)*f, w2 = (1.5*f - 2.5)*f*f + 1.0,
-    // w3 = ((-1.5*f + 2.0)*f + 0.5)*f and w4 = (0.5*f - 0.5)*f*f with f as the
-    // normalized interpolation position between C2 (at f=0) and C3 (at f=1).
-
-    // half_f is a sort of sub-pixelquad fraction, -1 <= half_f < 1.
-    const half_f_x = 2.0 * fract(0.5 * x - 0.25) - 1.0;
-    const half_f_y = 2.0 * fract(0.5 * y - 0.25) - 1.0;
-
-    // f is the regular sub-pixel fraction, 0 <= f < 1. This is equivalent to
-    // fract(uv * texSize - 0.5), but based on half_f to prevent rounding issues.
-    const f_x = fract(half_f_x);
-    const f_y = fract(half_f_y);
-
-    const s1_x = (0.5 * f_x - 0.5) * f_x;            // = w1 / (1 - f)
-    const s1_y = (0.5 * f_y - 0.5) * f_y;            // = w1 / (1 - f)
-
-    const s12_x = (-2.0 * f_x + 1.5) * f_x + 1.0;      // = (w2 - w1) / (1 - f)
-    const s12_y = (-2.0 * f_y + 1.5) * f_y + 1.0;      // = (w2 - w1) / (1 - f)
-
-    const s34_x = (2.0 * f_x - 2.5) * f_x - 0.5;      // = (w4 - w3) / f
-    const s34_y = (2.0 * f_y - 2.5) * f_y - 0.5;      // = (w4 - w3) / f
-
-    // positions is equivalent to: (floor(uv * texSize - 0.5).xyxy + 0.5 +
-    // vec4(-1.0 + w2 / (w2 - w1), 1.0 + w4 / (w4 - w3))) / texSize.xyxy.
-    const positions_x = (-f_x * s12_x + s1_x) / (s12_x) + x;
-    const positions_y = (-f_y * s12_y + s1_y) / (s12_y) + y;
-    const positions_z = (-f_x * s34_x + s1_x + s34_x) / (s34_x) + x;
-    const positions_w = (-f_y * s34_y + s1_y + s34_y) / (s34_y) + y;
-
-    // Determine if the output needs to be sign-flipped. Equivalent to .x*.y of
-    // (1.0 - 2.0 * floor(t - 2.0 * floor(0.5 * t))), where t is uv * texSize - 0.5.
-    const sign_flip = half_f_x * half_f_y > 0.0 ? 1.0 : -1.0;
-
-    // = (w2 - w1, w4 - w3)
-    const w_x = -f_x * s12_x + s12_x;
-    const w_y = -f_y * s12_y + s12_y;
-    const w_z = s34_x * f_x
-    const w_w = s34_y * f_y
-
-    const weights_x = w_x * w_y * sign_flip;
-    const weights_y = w_z * w_y * sign_flip;
-    const weights_z = w_x * w_w * sign_flip;
-    const weights_w = w_z * w_w * sign_flip;
-
-    return this.sampleChannelBilinear(positions_x, positions_y, channel) * weights_x +
-        this.sampleChannelBilinear(positions_z, positions_y, channel) * weights_y +
-        this.sampleChannelBilinear(positions_x, positions_w, channel) * weights_z +
-        this.sampleChannelBilinear(positions_z, positions_w, channel) * weights_w;
+    // 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;
 }
 
 /**
- * Based on code from From reddit https://www.reddit.com/r/javascript/comments/jxa8x/bicubic_interpolation/
+ * Based on code from reddit https://www.reddit.com/r/javascript/comments/jxa8x/bicubic_interpolation/
  * @param {number} t
  * @param {number} a
  * @param {number} b
@@ -654,10 +545,10 @@ Sampler2D.prototype.sampleBicubicUV = function (u, v, result) {
  * @returns {number}
  */
 Sampler2D.prototype.sampleChannelBicubicUV = function (u, v, channel) {
-    const x = u * (this.width - 1);
-    const y = v * (this.height - 1);
+    const x = u * (this.width);
+    const y = v * (this.height);
 
-    return this.sampleChannelBicubic(x, y, channel);
+    return this.sampleChannelBicubic(x - 0.5, y - 0.5, channel);
 };
 
 /**
@@ -681,12 +572,15 @@ Sampler2D.prototype.sampleChannelBicubic = function (x, y, channel) {
     const x_max = width - 1;
     const y_max = height - 1;
 
-    const x1 = clamp(x, 0, x_max) | 0;
-    const y1 = clamp(y, 0, y_max) | 0;
+    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 xd = x - x1;
-    const yd = y - y1;
+    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);
@@ -735,6 +629,14 @@ Sampler2D.prototype.sampleChannelBicubic = function (x, y, channel) {
     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);
@@ -745,6 +647,23 @@ Sampler2D.prototype.sampleChannelBicubic = function (x, y, channel) {
     return bicubic_terp(yd, s0, s1, s2, s3);
 };
 
+/**
+ *
+ * @param {number} u
+ * @param {number} v
+ * @param {number[]} result
+ * @param {number} result_offset
+ */
+Sampler2D.prototype.sampleBilinearUV = function (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
@@ -752,7 +671,7 @@ Sampler2D.prototype.sampleChannelBicubic = function (x, y, channel) {
  * @param {number[]} result
  * @param {number} result_offset
  */
-Sampler2D.prototype.sampleBilinear = function (x, y, result, result_offset) {
+Sampler2D.prototype.sampleBilinear = function (x, y, result, result_offset = 0) {
 
     const itemSize = this.itemSize;
 
@@ -771,10 +690,10 @@ Sampler2D.prototype.sampleBilinear = function (x, y, result, result_offset) {
  * @return {number}
  */
 Sampler2D.prototype.sampleChannelBilinearUV = function (u, v, channel) {
-    const x = u * (this.width - 1);
-    const y = v * (this.height - 1);
+    const x = u * (this.width);
+    const y = v * (this.height);
 
-    return this.sampleChannelBilinear(x, y, channel);
+    return this.sampleChannelBilinear(x - 0.5, y - 0.5, channel);
 };
 
 /**
@@ -850,9 +769,20 @@ Sampler2D.prototype.sampleChannelBilinear = function (x, y, channel) {
     const p0 = data[j0];
     const p1 = data[j1];
 
-    return filterFunctionBilinear(q0, q1, p0, p1, xd, yd);
+    // perform Bi-Linear interpolation
+    const s0 = mix(q0, q1, xd);
+    const s1 = mix(p0, p1, xd);
+
+    return mix(s0, s1, yd);
 };
 
+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);
+
+    this.read(min2(x, this.width - 1), min2(y, this.height - 1), result);
+}
+
 /**
  *
  * @param {number} x
@@ -865,6 +795,8 @@ Sampler2D.prototype.readChannel = function (x, y, channel) {
     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];
@@ -1180,6 +1112,8 @@ Sampler2D.prototype.copyWithMargin = function (source, sourceX, sourceY, destina
             }
         }
     }
+
+    this.version++;
 };
 
 /**
@@ -1192,7 +1126,19 @@ Sampler2D.prototype.copyWithMargin = function (source, sourceX, sourceY, destina
  * @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) {
+Sampler2D.prototype.copy = function (
+    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);
@@ -1222,6 +1168,8 @@ Sampler2D.prototype.copy = function (source, sourceX, sourceY, destinationX, des
             }
         }
     }
+
+    this.version++;
 };
 
 
@@ -1268,6 +1216,8 @@ Sampler2D.prototype.copy_sameItemSize = function (source, sourceX, sourceY, dest
 
         }
     }
+
+    this.version++;
 };
 
 
@@ -1297,9 +1247,9 @@ function blendFunctionNormal(source, destination, result) {
  * @param destinationY
  * @param width
  * @param height
- * @param {BlendingType} blendMode
+ * @param {BlendingType} [blendMode]
  */
-Sampler2D.prototype.paint = function (source, sourceX, sourceY, destinationX, destinationY, width, height, blendMode) {
+Sampler2D.prototype.paint = function (source, sourceX, sourceY, destinationX, destinationY, width, height, blendMode = BlendingType.Normal) {
     let blendFunction;
     if (blendMode === BlendingType.Normal) {
         blendFunction = blendFunctionNormal;
@@ -1310,6 +1260,8 @@ Sampler2D.prototype.paint = function (source, sourceX, sourceY, destinationX, de
     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];
@@ -1318,14 +1270,21 @@ Sampler2D.prototype.paint = function (source, sourceX, sourceY, destinationX, de
 
     let x, y;
 
-    for (y = 0; y < _h; y++) {
-        for (x = 0; x < _w; x++) {
-            this.read(x + destinationX, y + destinationY, c0);
-            source.read(x + sourceY, y + sourceY, c1);
+    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(x, y, c3);
+            this.set(d_x, d_y, c3);
 
         }
     }
@@ -1364,6 +1323,25 @@ Sampler2D.prototype.zeroFill = function (x, y, width, height) {
         data.fill(0, a + clearRowOffset0, a + clearRowOffset1);
 
     }
+
+    this.version++;
+};
+
+/**
+ *
+ * @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;
+
+    for (let i = channel_index; i < length; i += itemSize) {
+        data[i] = value;
+    }
+
+    this.version++;
 };
 
 /**
@@ -1407,6 +1385,8 @@ Sampler2D.prototype.fill = function (x, y, width, height, value) {
 
         }
     }
+
+    this.version++;
 };
 
 /**
@@ -1430,6 +1410,8 @@ Sampler2D.prototype.writeChannel = function (x, y, channel, value) {
     const channelAddress = pointAddress + channel;
 
     this.data[channelAddress] = value;
+
+    this.version++;
 };
 
 /**
@@ -1449,6 +1431,8 @@ Sampler2D.prototype.set = function (x, y, value) {
     for (let i = 0; i < itemSize; i++) {
         data[offset + i] = value[i];
     }
+
+    this.version++;
 };
 
 /**
@@ -1542,6 +1526,8 @@ Sampler2D.prototype.resize = function (x, y, preserveData = true) {
     this.height = y;
 
     this.data = newData;
+
+    this.version++;
 };
 
 /**
@@ -1609,6 +1595,7 @@ Sampler2D.prototype.fromBinaryBuffer = function (buffer) {
 
         buffer.readBytes(this.data, 0, numBytes);
 
+        this.version++;
     } else {
         throw new TypeError(`Unsupported data type (${dataType})`);
     }
@@ -1647,6 +1634,24 @@ Sampler2D.prototype.traverseOrthogonalNeighbours = function (x, y, visitor, this
     }
 };
 
+/**
+ * @returns {Sampler2D}
+ */
+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;
+
+        data_clone = new T(this.data);
+    }
+
+    return new Sampler2D(data_clone, this.itemSize, this.width, this.height);
+};
+
 /**
  * @readonly
  * @type {boolean}