@woosh/meep-engine 2.37.16 → 2.37.19

package/core/assert.js

@@ -1,4 +1,5 @@
-import { isTypedArray } from "./json/JsonUtils.js";
+import { isArrayEqualStrict } from "./collection/array/isArrayEqualStrict.js";
+import { isTypedArray } from "./collection/array/typed/isTypedArray.js";
 
 function equal(a, b, m) {
     assert(a === b, m) // eslint-disable-line eqeqeq
@@ -164,6 +165,18 @@ function arrayHasNo(haystack, needle, message = 'Array contains the item') {
     assert.equal(haystack.indexOf(needle), -1, message);
 }
 
+/**
+ * @template T
+ * @param {T[]|ArrayLike<T>|Float32Array} a
+ * @param {T[]|ArrayLike<T>|Float32Array} b
+ * @param {string} [message]
+ */
+function arrayEqual(a, b, message = 'Arrays are not equal') {
+    if (!isArrayEqualStrict(a, b)) {
+        throw new Error(message);
+    }
+}
+
 /**
  * @template T
  * @param {T} value
@@ -195,6 +208,7 @@ assert.lessThanOrEqual = lessThanOrEqual;
 assert.typeOf = typeOf;
 assert.arrayHas = arrayHas;
 assert.arrayHasNo = arrayHasNo;
+assert.arrayEqual = arrayEqual;
 
 /**
  *
@@ -321,7 +335,7 @@ assert.defined = function (value, name = "value") {
  * @param {*} value
  * @param {String} [name]
  */
-assert.isNull = function (value, name){
+assert.isNull = function (value, name) {
     if (value !== null) {
         throw new Error(`${name} is NOT null`);
     }

package/core/collection/array/typed/isTypedArray.js

@@ -0,0 +1,20 @@
+/**
+ *
+ * @param o
+ * @returns {boolean}
+ */
+function isTypedArray(o) {
+    return (
+        o instanceof Int8Array ||
+        o instanceof Uint8Array ||
+        o instanceof Uint8ClampedArray ||
+        o instanceof Int16Array ||
+        o instanceof Uint16Array ||
+        o instanceof Int32Array ||
+        o instanceof Uint32Array ||
+        o instanceof Float32Array ||
+        o instanceof Float64Array
+    );
+}
+
+export { isTypedArray };

package/core/collection/array/typedArrayToDataType.js

@@ -6,10 +6,11 @@ import { DataType } from "../table/DataType.js";
  * @returns {DataType}
  */
 export function typedArrayToDataType(v) {
-    const ctor = v.__proto__.constructor;
+    const ctor = Object.getPrototypeOf(v).constructor;
 
     switch (ctor) {
         case Uint8Array:
+        case Uint8ClampedArray:
             return DataType.Uint8;
         case Uint16Array:
             return DataType.Uint16;

package/core/collection/table/RowFirstTable.js

@@ -6,6 +6,7 @@
 import { assert } from "../../assert.js";
 import Signal from "../../events/signal/Signal.js";
 import { max2 } from "../../math/max2.js";
+import { array_copy } from "../array/copyArray.js";
 
 /**
  *
@@ -414,6 +415,39 @@ RowFirstTable.prototype.setRow = function (index, record) {
     this.writeRowMethod(this.dataView, this.bytesPerRecord * index, record);
 }
 
+/**
+ * Reverse order of rows, row-0 will end up at and previously last row will become the first row etc.
+ */
+RowFirstTable.prototype.reverse_rows = function () {
+    const bpr = this.bytesPerRecord;
+    const copy_buffer = new Uint8Array(bpr);
+
+    const buffer = this.data;
+    const wrapper = new Uint8Array(buffer);
+
+    const length = this.length;
+
+    if (length <= 1) {
+        // need at least 2 rows for reversal to make any change
+        return;
+    }
+
+    const last_row_index = length - 1;
+
+
+    const traversal_limit = last_row_index >>> 1;
+    for (let i = 0; i <= traversal_limit; i++) {
+        const address = i * bpr;
+        array_copy(wrapper, address, copy_buffer, 0, bpr);
+
+        const swap_index = last_row_index - i;
+        const swap_address = swap_index * bpr;
+
+        wrapper.copyWithin(address, swap_address, swap_address + bpr)
+        wrapper.set(copy_buffer, swap_address);
+    }
+};
+
 /**
  * clear out all the data and free memory
  */

package/core/collection/table/RowFirstTable.spec.js

@@ -223,7 +223,65 @@ test('copy', () => {
     a.addRow([-11.3, 13]);
 
     const b = new RowFirstTable(spec);
-b.copy(a);
+    b.copy(a);
 
 
 });
+
+
+test('reverse_rows 3 rows (odd number)', () => {
+
+    const spec = new RowFirstTableSpec([DataType.Uint8]);
+
+    const a = new RowFirstTable(spec);
+    a.addRow([1]);
+    a.addRow([2]);
+    a.addRow([3]);
+
+    a.reverse_rows();
+
+    expect(a.readCellValue(0, 0)).toBeCloseTo(3);
+    expect(a.readCellValue(1, 0)).toBeCloseTo(2);
+    expect(a.readCellValue(2, 0)).toBeCloseTo(1);
+});
+
+test('reverse_rows 2 rows', () => {
+
+    const spec = new RowFirstTableSpec([DataType.Float64, DataType.Uint8]);
+
+    const a = new RowFirstTable(spec);
+    a.addRow([3.1, 7]);
+    a.addRow([-11.3, 13]);
+
+    a.reverse_rows();
+
+    expect(a.readCellValue(1, 0)).toBeCloseTo(3.1);
+    expect(a.readCellValue(1, 1)).toBeCloseTo(7);
+
+    expect(a.readCellValue(0, 0)).toBeCloseTo(-11.3);
+    expect(a.readCellValue(0, 1)).toBeCloseTo(13);
+});
+
+test('reverse_rows 1 row', () => {
+
+    const spec = new RowFirstTableSpec([DataType.Float64, DataType.Uint8]);
+
+    const a = new RowFirstTable(spec);
+
+    a.addRow([3.1, 7]);
+    a.reverse_rows();
+
+    expect(a.readCellValue(0, 0)).toBeCloseTo(3.1);
+    expect(a.readCellValue(0, 1)).toBeCloseTo(7);
+});
+
+test('reverse_rows empty', () => {
+
+    const spec = new RowFirstTableSpec([DataType.Float64, DataType.Uint8]);
+
+    const a = new RowFirstTable(spec);
+
+    a.reverse_rows();
+
+    expect(a.length).toBe(0);
+});

package/core/color/Color.js

@@ -9,6 +9,7 @@ import { computeHashFloat } from "../math/hash/computeHashFloat.js";
 import { rgb2hsv } from "./rgb2hsv.js";
 import { rgb2uint24 } from "./rgb2uint24.js";
 import { clamp01 } from "../math/clamp01.js";
+import { rgb2hex } from "./rgb2hex.js";
 
 /**
  * @class
@@ -346,6 +347,19 @@ export class Color {
         this.setRGB(r / 255, g / 255, b / 255);
     }
 
+    /**
+     * Returns color in CSS hex color format
+     * @example #FF0000
+     * @returns {string}
+     */
+    toHex() {
+        return '#' + rgb2hex(
+            Math.round(this.r),
+            Math.round(this.g),
+            Math.round(this.b)
+        );
+    }
+
     /**
      *
      * @param {Color} other

package/core/color/rgb2hex.js

@@ -1,5 +1,5 @@
 function dec2hex(c) {
-    const hex = c.toString(16);
+    const hex = Math.round(c).toString(16);
     return hex.length === 1 ? "0" + hex : hex;
 }
 

package/core/events/signal/Signal.js

@@ -240,7 +240,7 @@ export class Signal {
         // Copy handlers into a temp storage to preserve state during dispatch
         for (i = 0; i < length; i++) {
             //copy to proxy
-            dispatch_stack[stack_pointer + i] = handlers[i];
+            dispatch_stack[stack_pointer + i] = handlers[length - (i + 1)];
         }
 
         // Dispatch phase
@@ -292,7 +292,7 @@ export class Signal {
         // Copy handlers into a temp storage to preserve state during dispatch
         for (i = 0; i < length; i++) {
             //copy to proxy
-            dispatch_stack[stack_pointer + i] = handlers[i];
+            dispatch_stack[stack_pointer + i] = handlers[length - (i + 1)];
         }
 
         // Dispatch phase
@@ -343,7 +343,7 @@ export class Signal {
         // Copy handlers into a temp storage to preserve state during dispatch
         for (i = 0; i < length; i++) {
             //copy to proxy
-            dispatch_stack[stack_pointer + i] = handlers[i];
+            dispatch_stack[stack_pointer + i] = handlers[length - (i + 1)];
         }
 
         // Dispatch phase
@@ -395,7 +395,7 @@ export class Signal {
         // Copy handlers into a temp storage to preserve state during dispatch
         for (i = 0; i < length; i++) {
             //copy to proxy
-            dispatch_stack[stack_pointer + i] = handlers[i];
+            dispatch_stack[stack_pointer + i] = handlers[length - (i + 1)];
         }
 
         // Dispatch phase
@@ -448,7 +448,7 @@ export class Signal {
         // Copy handlers into a temp storage to preserve state during dispatch
         for (i = 0; i < length; i++) {
             //copy to proxy
-            dispatch_stack[stack_pointer + i] = handlers[i];
+            dispatch_stack[stack_pointer + i] = handlers[length - (i + 1)];
         }
 
         // Dispatch phase
@@ -503,7 +503,7 @@ export class Signal {
         // Copy handlers into a temp storage to preserve state during dispatch
         for (i = 0; i < length; i++) {
             //copy to proxy
-            dispatch_stack[stack_pointer + i] = handlers[i];
+            dispatch_stack[stack_pointer + i] = handlers[length - (i + 1)];
         }
 
         // Dispatch phase
@@ -560,7 +560,7 @@ export class Signal {
         // Copy handlers into a temp storage to preserve state during dispatch
         for (i = 0; i < length; i++) {
             //copy to proxy
-            dispatch_stack[stack_pointer + i] = handlers[i];
+            dispatch_stack[stack_pointer + i] = handlers[length - (i + 1)];
         }
 
         // Dispatch phase
@@ -731,7 +731,7 @@ export function dispatchViaProxy(handlers, args) {
     let i, h;
     for (i = 0; i < length; i++) {
         //copy to proxy
-        dispatch_stack[stack_pointer + i] = handlers[i];
+        dispatch_stack[stack_pointer + i] = handlers[length - (i + 1)];
     }
 
     for (i = stack_frame_end - 1; i >= stack_pointer; i--) {

package/core/events/signal/Signal.spec.js

@@ -147,3 +147,19 @@ test("handler context is properly setup during dispatch", () => {
 
     expect(handler).toHaveBeenCalled();
 });
+
+test("handlers should be executed in the order in which they are added", () => {
+    const signal = new Signal();
+
+    const marks = [];
+
+    const write_1 = jest.fn(() => marks.push(1));
+    const write_2 = jest.fn(() => marks.push(2));
+
+    signal.add(write_1);
+    signal.add(write_2);
+
+    signal.send0();
+
+    expect(marks).toEqual([1, 2]);
+});

package/core/geom/Quaternion.d.ts

@@ -24,4 +24,9 @@ export default class Quaternion {
     setFromRotationMatrix(m: Matrix4): void
 
     decodeFromUint32(uint: number): void
+
+
+    toEulerAnglesXYZ(v3: { set(x: number, y: number, z: number): any }): void
+
+    fromEulerAnglesXYZ(x: number, y: number, z: number): void
 }