@woosh/meep-engine 2.110.7 → 2.110.9

package/src/engine/animation/curve/AnimationCurve.spec.js

@@ -178,4 +178,71 @@ test("static constant constructor", () => {
     expect(curve.evaluate(4.9)).toBe(7);
 
     expect(curve.evaluate(3)).toBe(7);
+});
+
+test("equals method", () => {
+
+    expect(new AnimationCurve().equals(new AnimationCurve())).toBe(true);
+
+    // one frame
+    expect(
+        AnimationCurve.from([Keyframe.from(0, 0)])
+            .equals(AnimationCurve.from([Keyframe.from(0, 0)]))
+    ).toBe(true);
+
+    expect(
+        AnimationCurve.from([Keyframe.from(0, 1)])
+            .equals(AnimationCurve.from([Keyframe.from(0, 0)]))
+    ).toBe(false);
+
+    expect(
+        AnimationCurve.from([Keyframe.from(1, 0)])
+            .equals(AnimationCurve.from([Keyframe.from(0, 0)]))
+    ).toBe(false);
+
+    expect(
+        AnimationCurve.from([Keyframe.from(0, 0)])
+            .equals(AnimationCurve.from([Keyframe.from(0, 1)]))
+    ).toBe(false);
+
+    expect(
+        AnimationCurve.from([Keyframe.from(0, 0)])
+            .equals(AnimationCurve.from([Keyframe.from(0, 1)]))
+    ).toBe(false);
+
+    // different frame count
+
+    expect(
+        AnimationCurve.from([])
+            .equals(AnimationCurve.from([Keyframe.from(0, 0)]))
+    ).toBe(false);
+
+    expect(
+        AnimationCurve.from([Keyframe.from(0, 0)])
+            .equals(AnimationCurve.from([]))
+    ).toBe(false);
+
+});
+
+test("hash", () => {
+
+    expect(typeof AnimationCurve.from([Keyframe.from(0, 0)]).hash()).toBe("number")
+
+    expect(AnimationCurve.from([]).hash())
+        .toEqual(AnimationCurve.from([]).hash())
+
+});
+
+test("copy", () => {
+
+    const r = new AnimationCurve();
+
+    r.copy(AnimationCurve.from([Keyframe.from(1, -3, 5, -7)]))
+
+    expect(r.keys.length).toBe(1);
+    expect(r.keys[0].value).toBe(-3);
+    expect(r.keys[0].time).toBe(1);
+    expect(r.keys[0].inTangent).toBe(5);
+    expect(r.keys[0].outTangent).toBe(-7);
+
 });

package/src/engine/animation/curve/Keyframe.d.ts

@@ -14,17 +14,17 @@ export class Keyframe {
      */
     value: number;
     /**
-     *
+     * Timestamp
      * @type {number}
      */
     time: number;
     /**
-     *
+     * Incoming tangent
      * @type {number}
      */
     inTangent: number;
     /**
-     *
+     * Outgoing tangent
      * @type {number}
      */
     outTangent: number;
@@ -36,6 +36,27 @@ export class Keyframe {
      * @param {number} outTangent
      */
     set(time: number, value: number, inTangent: number, outTangent: number): void;
+    /**
+     *
+     * @param {Keyframe} other
+     * @returns {boolean}
+     */
+    equals(other: Keyframe): boolean;
+    /**
+     *
+     * @param {Keyframe} other
+     */
+    copy(other: Keyframe): void;
+    /**
+     *
+     * @return {Keyframe}
+     */
+    clone(): Keyframe;
+    /**
+     *
+     * @return {number}
+     */
+    hash(): number;
     toJSON(): {
         value: number;
         time: number;

package/src/engine/animation/curve/Keyframe.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Keyframe.d.ts","sourceRoot":"","sources":["../../../../../src/engine/animation/curve/Keyframe.js"],"names":[],"mappings":"AAEA;IAyBI;;;;;;;OAOG;IACH,kBANW,MAAM,SACN,MAAM,cACN,MAAM,eACN,MAAM,GACL,QAAQ,CAQnB;IAtCD;;;OAGG;IACH,OAFU,MAAM,CAEN;IAEV;;;OAGG;IACH,MAFU,MAAM,CAEP;IAET;;;OAGG;IACH,WAFU,MAAM,CAEF;IAEd;;;OAGG;IACH,YAFU,MAAM,CAED;IAkBf;;;;;;OAMG;IACH,UALW,MAAM,SACN,MAAM,aACN,MAAM,cACN,MAAM,QAmBhB;IAED;;;;;MAOC;IAED;;;;;aAQC;IAIL;;;OAGG;IACH,qBAFU,OAAO,CAEY;CAN5B"}
+{"version":3,"file":"Keyframe.d.ts","sourceRoot":"","sources":["../../../../../src/engine/animation/curve/Keyframe.js"],"names":[],"mappings":"AAGA;IAyBI;;;;;;;OAOG;IACH,kBANW,MAAM,SACN,MAAM,cACN,MAAM,eACN,MAAM,GACL,QAAQ,CAQnB;IAtCD;;;OAGG;IACH,OAFU,MAAM,CAEN;IAEV;;;OAGG;IACH,MAFU,MAAM,CAEP;IAET;;;OAGG;IACH,WAFU,MAAM,CAEF;IAEd;;;OAGG;IACH,YAFU,MAAM,CAED;IAkBf;;;;;;OAMG;IACH,UALW,MAAM,SACN,MAAM,aACN,MAAM,cACN,MAAM,QAmBhB;IAED;;;;OAIG;IACH,cAHW,QAAQ,GACN,OAAO,CAQnB;IAED;;;OAGG;IACH,YAFW,QAAQ,QAOlB;IAED;;;OAGG;IACH,SAFY,QAAQ,CAQnB;IAED;;;OAGG;IACH,QAFY,MAAM,CAKjB;IAED;;;;;MAOC;IAED;;;;;aAQC;IAIL;;;OAGG;IACH,qBAFU,OAAO,CAEY;CAN5B"}

package/src/engine/animation/curve/Keyframe.js

@@ -1,4 +1,5 @@
 import { assert } from "../../../core/assert.js";
+import { computeHashFloat } from "../../../core/primitives/numbers/computeHashFloat.js";
 
 export class Keyframe {
     /**
@@ -8,19 +9,19 @@ export class Keyframe {
     value = 0;
 
     /**
-     *
+     * Timestamp
      * @type {number}
      */
     time = 0;
 
     /**
-     *
+     * Incoming tangent
      * @type {number}
      */
     inTangent = 0;
 
     /**
-     *
+     * Outgoing tangent
      * @type {number}
      */
     outTangent = 0;
@@ -67,6 +68,51 @@ export class Keyframe {
         this.outTangent = outTangent;
     }
 
+    /**
+     *
+     * @param {Keyframe} other
+     * @returns {boolean}
+     */
+    equals(other) {
+        return this.time === other.time
+            && this.value === other.value
+            && this.inTangent === other.inTangent
+            && this.outTangent === other.outTangent;
+
+    }
+
+    /**
+     *
+     * @param {Keyframe} other
+     */
+    copy(other) {
+        this.time = other.time;
+        this.value = other.value;
+        this.inTangent = other.inTangent;
+        this.outTangent = other.outTangent;
+    }
+
+    /**
+     *
+     * @return {Keyframe}
+     */
+    clone() {
+        const r = new Keyframe();
+
+        r.copy(this);
+
+        return r;
+    }
+
+    /**
+     *
+     * @return {number}
+     */
+    hash() {
+        return computeHashFloat(this.time)
+            ^ computeHashFloat(this.value);
+    }
+
     toJSON() {
         return {
             value: this.value,

package/src/engine/animation/curve/Keyframe.spec.js

@@ -28,4 +28,15 @@ test("fromJSON", () => {
     expect(keyframe.inTangent).toEqual(5);
     expect(keyframe.outTangent).toEqual(7);
 
+});
+
+test("copy",()=>{
+    const keyframe = new Keyframe();
+
+    keyframe.copy(Keyframe.from(1, -3, 5, -7));
+
+    expect(keyframe.value).toBe(-3);
+    expect(keyframe.time).toBe(1);
+    expect(keyframe.inTangent).toBe(5);
+    expect(keyframe.outTangent).toBe(-7);
 });

package/src/engine/animation/curve/animation_curve_compute_aabb.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Compute bounding box for a given curve. X-axis is time, Y-axis is value.
+ * @param {AABB2} out
+ * @param {AnimationCurve} curve
+ */
+export function animation_curve_compute_aabb(out: AABB2, curve: AnimationCurve): void;
+//# sourceMappingURL=animation_curve_compute_aabb.d.ts.map

package/src/engine/animation/curve/animation_curve_compute_aabb.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"animation_curve_compute_aabb.d.ts","sourceRoot":"","sources":["../../../../../src/engine/animation/curve/animation_curve_compute_aabb.js"],"names":[],"mappings":"AAMA;;;;GAIG;AACH,sFAsCC"}

package/src/engine/animation/curve/{compute_curve_aabb.js → animation_curve_compute_aabb.js}

@@ -9,7 +9,7 @@ const temp_bounds = new Float32Array(4);
  * @param {AABB2} out
  * @param {AnimationCurve} curve
  */
-export function compute_curve_aabb(out, curve) {
+export function animation_curve_compute_aabb(out, curve) {
     let x0 = Number.POSITIVE_INFINITY;
     let x1 = Number.NEGATIVE_INFINITY;
     let y0 = Number.POSITIVE_INFINITY;

package/src/engine/animation/curve/animation_curve_optimize.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Will remove keyframes that do not affect shape of the curve significantly. The significance degree is determined by the error tolerance
+ * Intended to reduce complexity of a curve to improve performance and lower memory usage
+ * @param {AnimationCurve} curve
+ * @param {number} [error_tolerance] how much of a loss to accept, this is relative to normalized value bounds of the curve
+ */
+export function animation_curve_optimize(curve: AnimationCurve, error_tolerance?: number): void;
+//# sourceMappingURL=animation_curve_optimize.d.ts.map

package/src/engine/animation/curve/animation_curve_optimize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"animation_curve_optimize.d.ts","sourceRoot":"","sources":["../../../../../src/engine/animation/curve/animation_curve_optimize.js"],"names":[],"mappings":"AA0CA;;;;;GAKG;AACH,kFAFW,MAAM,QA0ChB"}

package/src/engine/animation/curve/animation_curve_optimize.js

@@ -0,0 +1,89 @@
+import { assert } from "../../../core/assert.js";
+import AABB2 from "../../../core/geom/2d/aabb/AABB2.js";
+import { animation_curve_compute_aabb } from "./animation_curve_compute_aabb.js";
+import { evaluate_two_key_curve } from "./evaluate_two_key_curve.js";
+
+const bounds = new AABB2();
+
+const NORMALIZED_CHECK_DISTANCE = 0.07;
+
+/**
+ * Compute value difference in the curve if the `middle` key between `previous` and `next` is removed
+ * @param {Keyframe} key_middle
+ * @param {Keyframe} key_previous
+ * @param {Keyframe} key_next
+ * @return {number} value delta if the middle frame is removed
+ */
+function compute_keyframe_value_effect(key_middle, key_previous, key_next) {
+    // check if this key contributes to the shape
+    const v1_actual = evaluate_two_key_curve(key_middle.time, key_previous, key_next);
+    const v1_expected = key_middle.value;
+
+    const v1_error = Math.abs(v1_actual - v1_expected);
+
+    // sample just before the current frame
+    const v0_time = key_middle.time - (key_middle.time - key_previous.time) * NORMALIZED_CHECK_DISTANCE;
+
+    const v0_actual = evaluate_two_key_curve(v0_time, key_previous, key_next);
+    const v0_expected = evaluate_two_key_curve(v0_time, key_previous, key_middle);
+
+    const v0_error = Math.abs(v0_actual - v0_expected);
+
+    // sample just after the current frame
+    const v2_time = key_middle.time + (key_next.time - key_middle.time) * NORMALIZED_CHECK_DISTANCE;
+
+    const v2_actual = evaluate_two_key_curve(v2_time, key_previous, key_next);
+    const v2_expected = evaluate_two_key_curve(v2_time, key_middle, key_next);
+
+    const v2_error = Math.abs(v2_actual - v2_expected);
+
+    return Math.max(v0_error, v1_error, v2_error);
+}
+
+/**
+ * Will remove keyframes that do not affect shape of the curve significantly. The significance degree is determined by the error tolerance
+ * Intended to reduce complexity of a curve to improve performance and lower memory usage
+ * @param {AnimationCurve} curve
+ * @param {number} [error_tolerance] how much of a loss to accept, this is relative to normalized value bounds of the curve
+ */
+export function animation_curve_optimize(curve, error_tolerance = 1e-3) {
+    assert.lessThan(error_tolerance, 1, 'error_tolerance must be less than 1');
+
+    animation_curve_compute_aabb(bounds, curve);
+
+    const absolute_error_tolerance = bounds.height * error_tolerance;
+
+    let key_count = curve.length;
+
+    const keyframes = curve.keys;
+
+    for (let i = 1; i < key_count; i++) {
+        const key_previous = keyframes[i - 1];
+        const key_current = keyframes[i];
+
+        let should_remove = false;
+
+        if (key_current.equals(key_previous)) {
+            // adds no semantic value
+            should_remove = true;
+        }
+
+        if (!should_remove && i < key_count - 1) {
+            const key_next = keyframes[i + 1];
+
+            const max_error = compute_keyframe_value_effect(key_current, key_previous, key_next);
+
+            if (max_error <= absolute_error_tolerance) {
+                // does not significantly affect the curve shape
+                should_remove = true;
+            }
+        }
+
+
+        if (should_remove) {
+            curve.remove(key_current);
+            i--;
+            key_count--;
+        }
+    }
+}

package/src/engine/animation/curve/animation_curve_optimize.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=animation_curve_optimize.spec.d.ts.map

package/src/engine/animation/curve/animation_curve_optimize.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"animation_curve_optimize.spec.d.ts","sourceRoot":"","sources":["../../../../../src/engine/animation/curve/animation_curve_optimize.spec.js"],"names":[],"mappings":""}

package/src/engine/animation/curve/animation_curve_optimize.spec.js

@@ -0,0 +1,50 @@
+import { animation_curve_optimize } from "./animation_curve_optimize.js";
+import { AnimationCurve } from "./AnimationCurve.js";
+import { Keyframe } from "./Keyframe.js";
+
+test("single key", () => {
+
+    const curve = AnimationCurve.from([
+        Keyframe.from(1, -2, 3, -5)
+    ]);
+
+    animation_curve_optimize(curve);
+
+    expect(curve.keys.length).toBe(1);
+});
+
+test("repeated key", () => {
+
+    const curve = AnimationCurve.from([
+        Keyframe.from(1, -2, 3, -5),
+        Keyframe.from(1, -2, 3, -5),
+        Keyframe.from(1, -2, 3, -5)
+    ]);
+
+    animation_curve_optimize(curve);
+
+    expect(curve.equals(
+        AnimationCurve.from([
+            Keyframe.from(1, -2, 3, -5)
+        ])
+    )).toBe(true);
+});
+
+test("linear curve", () => {
+
+    const curve = AnimationCurve.from([
+        Keyframe.from(0, 0, 1, 1),
+        Keyframe.from(1, 1, 1, 1),
+        Keyframe.from(2, 2, 1, 1),
+    ])
+
+    animation_curve_optimize(curve);
+
+    expect(curve.equals(
+        AnimationCurve.from([
+            Keyframe.from(0, 0, 1, 1),
+            Keyframe.from(2, 2, 1, 1)
+        ])
+    )).toBe(true);
+
+});

package/src/engine/animation/curve/draw/build_curve_editor.js

@@ -11,8 +11,8 @@ import { canvas2d_plot_data_line } from "../../../graphics/canvas/canvas2d_plot_
 import { MouseEvents } from "../../../input/devices/events/MouseEvents.js";
 import { readPositionFromMouseEvent } from "../../../input/devices/PointerDevice.js";
 import { DraggableAspect } from "../../../ui/DraggableAspect.js";
+import { animation_curve_compute_aabb } from "../animation_curve_compute_aabb.js";
 import { sample_animation_curve_to_float_array } from "../compression/sample_animation_curve_to_float_array.js";
-import { compute_curve_aabb } from "../compute_curve_aabb.js";
 import { Keyframe } from "../Keyframe.js";
 
 /**
@@ -106,7 +106,7 @@ export function build_curve_editor({
     });
 
     function handle_curve_update() {
-        compute_curve_aabb(frame, curve);
+        animation_curve_compute_aabb(frame, curve);
 
         frame_updated.send0();
 

package/src/engine/animation/curve/evaluate_two_key_curve.d.ts

@@ -0,0 +1,9 @@
+/**
+ *
+ * @param {number} time
+ * @param {Keyframe} keyframe0
+ * @param {Keyframe} keyframe1
+ * @return {number}
+ */
+export function evaluate_two_key_curve(time: number, keyframe0: Keyframe, keyframe1: Keyframe): number;
+//# sourceMappingURL=evaluate_two_key_curve.d.ts.map

package/src/engine/animation/curve/evaluate_two_key_curve.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"evaluate_two_key_curve.d.ts","sourceRoot":"","sources":["../../../../../src/engine/animation/curve/evaluate_two_key_curve.js"],"names":[],"mappings":"AAGA;;;;;;GAMG;AACH,6CALW,MAAM,aACN,QAAQ,aACR,QAAQ,GACP,MAAM,CAcjB"}

package/src/engine/animation/curve/evaluate_two_key_curve.js

@@ -0,0 +1,23 @@
+import { inverseLerp } from "../../../core/math/inverseLerp.js";
+import { spline_hermite3 } from "../../../core/math/spline/spline_hermite3.js";
+
+/**
+ *
+ * @param {number} time
+ * @param {Keyframe} keyframe0
+ * @param {Keyframe} keyframe1
+ * @return {number}
+ */
+export function evaluate_two_key_curve(time, keyframe0, keyframe1) {
+    // convert to 0..1 region
+    const normalized_time = inverseLerp(keyframe0.time, keyframe1.time, time);
+
+    const time_distance = keyframe1.time - keyframe0.time;
+
+    return spline_hermite3(
+        normalized_time,
+        keyframe0.value, keyframe1.value,
+        keyframe0.outTangent * time_distance,
+        keyframe1.inTangent * time_distance
+    );
+}

package/src/engine/animation/curve/prototypeGLTF.js

@@ -38,17 +38,17 @@ async function main(engine) {
         yaw: 3.123185307179593,
     });
     //
-    // make_sample('data/models/samples/InterpolationTest.glb',[
-    //     'Step Scale',
-    //     'Linear Scale',
-    //     'CubicSpline Scale',
-    //     'Step Rotation',
-    //     'CubicSpline Rotation',
-    //     'Linear Rotation',
-    //     'Step Translation',
-    //     'CubicSpline Translation',
-    //     'Linear Translation'
-    // ],engine.entityManager.dataset);
+    make_sample('data/models/samples/InterpolationTest.glb',[
+        'Step Scale',
+        'Linear Scale',
+        'CubicSpline Scale',
+        'Step Rotation',
+        'CubicSpline Rotation',
+        'Linear Rotation',
+        'Step Translation',
+        'CubicSpline Translation',
+        'Linear Translation'
+    ],engine.entityManager.dataset);
 
     // make_sample('data/models/samples/BoxAnimated.glb',[
     //    'animation_0'
@@ -61,9 +61,9 @@ async function main(engine) {
     // make_sample('moicon/Separated_Cardboard-Box-800x600x400_Roughness0/V1 Cardboard B.gltf', [
     //     'All Animations'
     // ], engine.entityManager.dataset);
-    make_sample('moicon/v26/v26.gltf', [
-        'All Animations'
-    ], engine.entityManager.dataset);
+    // make_sample('moicon/v26/v26.gltf', [
+    //     'All Animations'
+    // ], engine.entityManager.dataset);
 }
 
 /**

package/src/engine/asset/loaders/material/computeTextureEquality.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"computeTextureEquality.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/asset/loaders/material/computeTextureEquality.js"],"names":[],"mappings":"AAMA;;;;;GAKG;AACH,gEAFa,OAAO,CAoDnB;AAGD;;;;;GAKG;AACH,sCAJW,8DAAM,EAAE,GAAC;IAAC,KAAK,EAAC,MAAM,CAAC;IAAC,MAAM,EAAC,MAAM,CAAA;CAAC,KACtC,8DAAM,EAAE,GAAC;IAAC,KAAK,EAAC,MAAM,CAAC;IAAC,MAAM,EAAC,MAAM,CAAA;CAAC,GACpC,OAAO,CAmEnB"}
+{"version":3,"file":"computeTextureEquality.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/asset/loaders/material/computeTextureEquality.js"],"names":[],"mappings":"AAOA;;;;;GAKG;AACH,gEAFa,OAAO,CAoDnB;AAGD;;;;;GAKG;AACH,sCAJW,8DAAM,EAAE,GAAC;IAAC,KAAK,EAAC,MAAM,CAAC;IAAC,MAAM,EAAC,MAAM,CAAA;CAAC,KACtC,8DAAM,EAAE,GAAC;IAAC,KAAK,EAAC,MAAM,CAAC;IAAC,MAAM,EAAC,MAAM,CAAA;CAAC,GACpC,OAAO,CAgEnB"}

package/src/engine/asset/loaders/material/computeTextureEquality.js

@@ -1,5 +1,6 @@
 import { fastArrayEquals } from "../../../../core/collection/array/fastArrayEquals.js";
 import { isTypedArray } from "../../../../core/collection/array/typed/isTypedArray.js";
+import { isImageBitmap } from "../../../graphics/texture/isImageBitmap.js";
 import { computeImageBitmapEquality } from "./computeImageBitmapEquality.js";
 
 //
@@ -93,13 +94,10 @@ export function textureImagesEqual(a, b) {
         return false;
     }
 
-    if (
-        // check that browser/environment has the class at all to avoid potential exceptions
-        // Required for Safari below version 15.6
-        ImageBitmap !== undefined
-        && (a instanceof ImageBitmap && b instanceof ImageBitmap)
-    ) {
+    if (isImageBitmap(a) && isImageBitmap(b)) {
+
         return computeImageBitmapEquality(a, b);
+        
     }
 
     if (Array.isArray(a) && Array.isArray(b)) {

package/src/engine/asset/loaders/material/computeTextureHash.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"computeTextureHash.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/asset/loaders/material/computeTextureHash.js"],"names":[],"mappings":"AAuBA;;;;GAIG;AACH;;WAHoD,MAAM;YAAQ,MAAM;IAC5D,MAAM,CAuCjB;AA4CD;;;;GAIG;AACH,sCAHW,UAAQ,MAAM,OAAO,GACnB,MAAM,CAqClB"}
+{"version":3,"file":"computeTextureHash.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/asset/loaders/material/computeTextureHash.js"],"names":[],"mappings":"AAwBA;;;;GAIG;AACH;;WAHoD,MAAM;YAAQ,MAAM;IAC5D,MAAM,CAsCjB;AA4CD;;;;GAIG;AACH,sCAHW,UAAQ,MAAM,OAAO,GACnB,MAAM,CAqClB"}

package/src/engine/asset/loaders/material/computeTextureHash.js

@@ -2,6 +2,7 @@ import { computeHashIntegerArray } from "../../../../core/collection/array/compu
 import { murmur3_32 } from "../../../../core/math/hash/murmur3_32.js";
 import { computeHashFloat } from "../../../../core/primitives/numbers/computeHashFloat.js";
 import { computeStringHash } from "../../../../core/primitives/strings/computeStringHash.js";
+import { isImageBitmap } from "../../../graphics/texture/isImageBitmap.js";
 import { computeImageBitmapHash } from "./computeImageBitmapHash.js";
 
 /**
@@ -35,15 +36,14 @@ export function computeImageDataHash(image) {
 
     let result = 0;
 
-    if (
-        // check that browser/environment has the class at all to avoid potential exceptions
-        // Required for Safari below version 15.6
-        ImageBitmap !== undefined
-        && (image instanceof ImageBitmap)
-    ) {
+    if (isImageBitmap(image)) {
+
         result = computeImageBitmapHash(image);
+
     } else if (image instanceof HTMLImageElement) {
+
         result = computeStringHash(image.src);
+
     }
 
     let width = 0;

package/src/engine/ecs/dynamic_actions/rules/DynamicRuleDescription.d.ts

@@ -1,5 +1,9 @@
 export class DynamicRuleDescription {
-    id: number;
+    /**
+     *
+     * @type {UUID}
+     */
+    id: UUID;
     /**
      *
      * @type {ReactiveExpression}
@@ -51,5 +55,6 @@ export class DynamicRuleDescription {
         priority?: number;
     }): void;
 }
+import { UUID } from "../../guid/UUID.js";
 import { DynamicRuleCooldownDescription } from "./DynamicRuleCooldownDescription.js";
 //# sourceMappingURL=DynamicRuleDescription.d.ts.map

package/src/engine/ecs/dynamic_actions/rules/DynamicRuleDescription.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"DynamicRuleDescription.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/ecs/dynamic_actions/rules/DynamicRuleDescription.js"],"names":[],"mappings":"AAQA;IACI,WAAO;IACP;;;OAGG;IACH,8BAAiB;IACjB;;;OAGG;IACH,kCAAc;IACd;;;OAGG;IACH,YAFU,mBAAmB,CAEb;IAChB;;;OAGG;IACH,UAFU,MAAM,CAEH;IACb;;;OAGG;IACH,6BAAyB;IACzB;;;OAGG;IACH,kBAFU,8BAA8B,EAAE,CAEpB;IAEtB;;;;OAIG;IACH,cAHW,sBAAsB,GACpB,OAAO,CAInB;IAED;;;OAGG;IACH,0BAFa,MAAM,CAIlB;IAED,yCAEC;IAED,cA+BC;IAED;;;;;;aA2BC;CACJ;+CArH8C,qCAAqC"}
+{"version":3,"file":"DynamicRuleDescription.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/ecs/dynamic_actions/rules/DynamicRuleDescription.js"],"names":[],"mappings":"AAQA;IACI;;;OAGG;IACH,IAFU,IAAI,CAEC;IAEf;;;OAGG;IACH,8BAAiB;IACjB;;;OAGG;IACH,kCAAc;IACd;;;OAGG;IACH,YAFU,mBAAmB,CAEb;IAChB;;;OAGG;IACH,UAFU,MAAM,CAEH;IACb;;;OAGG;IACH,6BAAyB;IACzB;;;OAGG;IACH,kBAFU,8BAA8B,EAAE,CAEpB;IAEtB;;;;OAIG;IACH,cAHW,sBAAsB,GACpB,OAAO,CAInB;IAED;;;OAGG;IACH,0BAFa,MAAM,CAIlB;IAED,yCAEC;IAED,cA+BC;IAED;;;;;;aA2BC;CACJ;qBA5HoB,oBAAoB;+CAEM,qCAAqC"}

package/src/engine/ecs/dynamic_actions/rules/DynamicRuleDescription.js

@@ -1,13 +1,18 @@
-import UUID from "../../../../core/UUID.js";
 import { assert } from "../../../../core/assert.js";
+import { compileReactiveExpression } from "../../../../core/lang/reactive/compileReactiveExpression.js";
 import { inferReactiveExpressionTypes } from "../../../../core/model/reactive/transform/ReactiveTypeInferrence.js";
 import DataType from "../../../../core/parser/simple/DataType.js";
-import { compileReactiveExpression } from "../../../../core/lang/reactive/compileReactiveExpression.js";
+import { UUID } from "../../guid/UUID.js";
 import { deserializeActionFromJSON } from "../actions/definition/deserializeActionFromJSON.js";
 import { DynamicRuleCooldownDescription } from "./DynamicRuleCooldownDescription.js";
 
 export class DynamicRuleDescription {
-    id = 0;
+    /**
+     *
+     * @type {UUID}
+     */
+    id = UUID.v1();
+
     /**
      *
      * @type {ReactiveExpression}
@@ -45,7 +50,7 @@ export class DynamicRuleDescription {
      * @returns {boolean}
      */
     equals(other) {
-        return this.id === other.id;
+        return this.id.equals(other.id);
     }
 
     /**
@@ -94,7 +99,7 @@ export class DynamicRuleDescription {
     }
 
     fromJSON({
-                 id = UUID.generate(),
+                 id = UUID.v1().toString(),
                  condition,
                  action,
                  global_cooldowns = [],
@@ -113,7 +118,7 @@ export class DynamicRuleDescription {
 
         this.action = deserializeActionFromJSON(action);
 
-        this.id = id;
+        this.id.parse(id);
 
         this.priority = priority;