@woosh/meep-engine 2.37.19 → 2.37.20

package/core/binary/float2uint8.js

@@ -0,0 +1,8 @@
+/**
+ *
+ * @param {number} v
+ * @returns {number}
+ */
+export function float2uint8(v) {
+    return Math.round(v * 255);
+}

package/core/binary/uint82float.js

@@ -0,0 +1,8 @@
+/**
+ *
+ * @param {number} v
+ * @returns {number}
+ */
+export function uint82float(v) {
+    return v / 255;
+}

package/core/bvh2/bvh3/ExplicitBinaryBoundingVolumeHierarchy.js

@@ -619,20 +619,22 @@ export class ExplicitBinaryBoundingVolumeHierarchy {
         while (index !== NULL_NODE) {
             index = this.balance(index);
 
-            const child1 = uint32[index * ELEMENT_WORD_COUNT + COLUMN_CHILD_1];
-            const child2 = uint32[index * ELEMENT_WORD_COUNT + COLUMN_CHILD_2];
+            const node_address = index * ELEMENT_WORD_COUNT;
+
+            const child1 = uint32[node_address + COLUMN_CHILD_1];
+            const child2 = uint32[node_address + COLUMN_CHILD_2];
 
             assert.notEqual(child1, NULL_NODE, 'child1 is null');
             assert.notEqual(child2, NULL_NODE, 'child2 is null');
 
-            uint32[index * ELEMENT_WORD_COUNT + COLUMN_HEIGHT] = 1 + max2(
+            uint32[node_address + COLUMN_HEIGHT] = 1 + max2(
                 uint32[child1 * ELEMENT_WORD_COUNT + COLUMN_HEIGHT],
                 uint32[child2 * ELEMENT_WORD_COUNT + COLUMN_HEIGHT],
             );
 
             this.node_set_combined_aabb(index, child1, child2);
 
-            index = uint32[index * ELEMENT_WORD_COUNT + COLUMN_PARENT];
+            index = uint32[node_address + COLUMN_PARENT];
         }
     }
 

package/core/collection/list/List.d.ts

@@ -5,7 +5,7 @@ export default class List<T> {
 
     on: {
         added: Signal<T>,
-        removed: Signal<T>
+        removed: Signal<T, number>
     }
 
     constructor(elements?: T[])

package/core/color/Color.js

@@ -10,6 +10,8 @@ import { rgb2hsv } from "./rgb2hsv.js";
 import { rgb2uint24 } from "./rgb2uint24.js";
 import { clamp01 } from "../math/clamp01.js";
 import { rgb2hex } from "./rgb2hex.js";
+import { linear_to_sRGB } from "./linear_to_sRGB.js";
+import { sRGB_to_linear } from "./sRGB_to_linear.js";
 
 /**
  * @class
@@ -487,5 +489,71 @@ export class Color {
         r.parse(str);
 
         return r;
-    };
+    }
+
+    /**
+     *
+     * @param {Color} input
+     * @param {Color} output
+     */
+    static from_linear_to_sRGB(input, output) {
+        linear_to_sRGB(output, 0, input, 0);
+    }
+
+    /**
+     *
+     * @param {Color} input
+     * @param {Color} output
+     */
+    static from_sRGB_to_linear(input, output) {
+        sRGB_to_linear(output, 0, input, 0);
+    }
 }
+
+/**
+ * @readonly
+ * @type {Readonly<Color>}
+ */
+Color.red = Object.freeze(new Color(1, 0, 0));
+
+/**
+ * @readonly
+ * @type {Readonly<Color>}
+ */
+Color.green = Object.freeze(new Color(0, 1, 0));
+
+/**
+ * @readonly
+ * @type {Readonly<Color>}
+ */
+Color.blue = Object.freeze(new Color(0, 0, 1));
+
+/**
+ * @readonly
+ * @type {Readonly<Color>}
+ */
+Color.yellow = Object.freeze(new Color(1, 1, 0));
+
+/**
+ * @readonly
+ * @type {Readonly<Color>}
+ */
+Color.cyan = Object.freeze(new Color(0, 1, 1));
+
+/**
+ * @readonly
+ * @type {Readonly<Color>}
+ */
+Color.magenta = Object.freeze(new Color(1, 0, 1));
+
+/**
+ * @readonly
+ * @type {Readonly<Color>}
+ */
+Color.white = Object.freeze(new Color(1, 1, 1));
+
+/**
+ * @readonly
+ * @type {Readonly<Color>}
+ */
+Color.black = Object.freeze(new Color(0, 0, 0));

package/core/color/YCbCr_to_rgb_uint24.js

@@ -1,3 +1,5 @@
+import { rgb2uint24 } from "./rgb2uint24.js";
+
 /**
  * @see https://en.wikipedia.org/wiki/YUV
  * @param {number} Y
@@ -13,8 +15,5 @@ export function YCbCr_to_rgb_uint24(Y, Cb, Cr) {
     const g = Y - ((_Cb >> 2) + (_Cb >> 4) + (_Cb >> 5)) - ((_Cr >> 1) + (_Cr >> 3) + (_Cr >> 4) + (_Cr >> 5));
     const b = Y + _Cb + (_Cb >> 1) + (_Cb >> 2) + (_Cb >> 6);
 
-    return (b & 0xFF)
-        | (g & 0xFF) << 8
-        | (r & 0xFF) << 16
-        ;
+    return rgb2uint24(r, g, b);
 }

package/core/color/hsv2rgb.js

@@ -1,4 +1,5 @@
 import { clamp01 } from "../math/clamp01.js";
+import { float2uint8 } from "../binary/float2uint8.js";
 
 /**
  *
@@ -46,9 +47,9 @@ export function hsv2rgb(h, s, v) {
             break;
     }
     return {
-        r: Math.round(r * 255),
-        g: Math.round(g * 255),
-        b: Math.round(b * 255)
+        r: float2uint8(r),
+        g: float2uint8(g),
+        b: float2uint8(b)
     };
 }
 

package/core/color/linear_to_sRGB.js

@@ -1,13 +1,12 @@
-
-function convert(c){
-    return ( c < 0.0031308 ) ? c * 12.92 : 1.055 * ( Math.pow( c, 0.41666 ) ) - 0.055;
+function convert(c) {
+    return (c < 0.0031308) ? c * 12.92 : 1.055 * (Math.pow(c, 0.41666)) - 0.055;
 }
 
 /**
  *
- * @param {number[]} output
+ * @param {number[]|ArrayLike<number>} output
  * @param {number} output_offset
- * @param {number[]} input
+ * @param {number[]|ArrayLike<number>} input
  * @param {number} input_offset
  */
 export function linear_to_sRGB(output, output_offset, input, input_offset) {

package/core/color/rgb2uint24.js

@@ -1,3 +1,5 @@
+import { float2uint8 } from "../binary/float2uint8.js";
+
 /**
  *
  * @param {number} r
@@ -5,10 +7,10 @@
  * @param {number} b
  * @returns {number}
  */
-export function rgb2uint24(r,g,b){
-    const _r = Math.round(r * 255);
-    const _g = Math.round(g * 255);
-    const _b = Math.round(b * 255);
+export function rgb2uint24(r, g, b) {
+    const _r = float2uint8(r);
+    const _g = float2uint8(g);
+    const _b = float2uint8(b);
 
     return (_b & 0xFF)
         | (_g & 0xFF) << 8

package/core/color/rgb_to_YCbCr_uint24.js

@@ -1,18 +1,16 @@
-/**
- *
- * @see https://en.wikipedia.org/wiki/YUV
- * @param {number} r
- * @param {number} g
- * @param {number} b
- * @returns {number}
- */
+import { rgb2uint24 } from "./rgb2uint24.js";
+
 export function rgb_to_YCbCr_uint24(r, g, b) {
     const Y = 0.299 * r + 0.587 * g + 0.114 * b;
     const Cb = -0.169 * r - 0.331 * g + 0.499 * b + 128;
     const Cr = 0.499 * g - 0.418 * g - 0.0813 * b + 128;
-
-    return (Cr & 0xFF)
-        | (Cb & 0xFF) << 8
-        | (Y & 0xFF) << 16
-        ;
+    /**
+     *
+     * @see https://en.wikipedia.org/wiki/YUV
+     * @param {number} r
+     * @param {number} g
+     * @param {number} b
+     * @returns {number}
+     */
+    return rgb2uint24(Y,Cb,Cr);
 }

package/core/events/signal/Signal.d.ts

@@ -5,9 +5,9 @@ export default class Signal<A = any, B = any, C = any, D = any, E = any, F = any
     add(listener: (a: A, b: B, c: C) => any, thisArg?: any): void
     add(listener: (a: A, b: B, c: C, d: D) => any, thisArg?: any): void
     add(listener: (a: A, b: B, c: C, d: D, e: E) => any, thisArg?: any): void
-    add(listener: (a: A, b: B, c: C, d: D, e: E,f: F) => any, thisArg?: any): void
-    add(listener: (a: A, b: B, c: C, d: D, e: E,f: F, g: G) => any, thisArg?: any): void
-    add(listener: (a: A, b: B, c: C, d: D, e: E,f: F, g: G, h: H) => any, thisArg?: any): void
+    add(listener: (a: A, b: B, c: C, d: D, e: E, f: F) => any, thisArg?: any): void
+    add(listener: (a: A, b: B, c: C, d: D, e: E, f: F, g: G) => any, thisArg?: any): void
+    add(listener: (a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H) => any, thisArg?: any): void
 
     addOne(listener: () => any, thisArg?: any): void
     addOne(listener: (a: A) => any, thisArg?: any): void
@@ -15,9 +15,9 @@ export default class Signal<A = any, B = any, C = any, D = any, E = any, F = any
     addOne(listener: (a: A, b: B, c: C) => any, thisArg?: any): void
     addOne(listener: (a: A, b: B, c: C, d: D) => any, thisArg?: any): void
     addOne(listener: (a: A, b: B, c: C, d: D, e: E) => any, thisArg?: any): void
-    addOne(listener: (a: A, b: B, c: C, d: D, e: E,f: F) => any, thisArg?: any): void
-    addOne(listener: (a: A, b: B, c: C, d: D, e: E,f: F, g: G) => any, thisArg?: any): void
-    addOne(listener: (a: A, b: B, c: C, d: D, e: E,f: F, g: G, h: H) => any, thisArg?: any): void
+    addOne(listener: (a: A, b: B, c: C, d: D, e: E, f: F) => any, thisArg?: any): void
+    addOne(listener: (a: A, b: B, c: C, d: D, e: E, f: F, g: G) => any, thisArg?: any): void
+    addOne(listener: (a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H) => any, thisArg?: any): void
 
     remove(listener: () => any, thisArg?: any): void
     remove(listener: (a: A) => any, thisArg?: any): void
@@ -25,9 +25,9 @@ export default class Signal<A = any, B = any, C = any, D = any, E = any, F = any
     remove(listener: (a: A, b: B, c: C) => any, thisArg?: any): void
     remove(listener: (a: A, b: B, c: C, d: D) => any, thisArg?: any): void
     remove(listener: (a: A, b: B, c: C, d: D, e: E) => any, thisArg?: any): void
-    remove(listener: (a: A, b: B, c: C, d: D, e: E,f: F) => any, thisArg?: any): void
-    remove(listener: (a: A, b: B, c: C, d: D, e: E,f: F, g: G) => any, thisArg?: any): void
-    remove(listener: (a: A, b: B, c: C, d: D, e: E,f: F, g: G, h: H) => any, thisArg?: any): void
+    remove(listener: (a: A, b: B, c: C, d: D, e: E, f: F) => any, thisArg?: any): void
+    remove(listener: (a: A, b: B, c: C, d: D, e: E, f: F, g: G) => any, thisArg?: any): void
+    remove(listener: (a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H) => any, thisArg?: any): void
 
     send0(): void
 
@@ -47,4 +47,6 @@ export default class Signal<A = any, B = any, C = any, D = any, E = any, F = any
      * @deprecated use strongly typed dispatch methods instead (send0, send1 etc)
      */
     dispatch(...params: any[]): void
+
+    removeAll(): void
 }

package/core/geom/2d/quad-tree/qt_collect_by_circle.js

@@ -0,0 +1,67 @@
+import { aabb2_sqrDistanceToPoint } from "../AABB2Math.js";
+
+/**
+ *
+ * @type {QuadTreeNode[]}
+ */
+const node_stack = [];
+
+/**
+ * @template T
+ * @param {QuadTreeDatum<T>[]} result
+ * @param {number} result_offset
+ * @param {QuadTreeNode<T>} tree
+ * @param {number} x
+ * @param {number} y
+ * @param {number} radius
+ * @returns {number}
+ */
+export function qt_collect_by_circle(
+    result, result_offset,
+    tree,
+    x, y, radius
+) {
+    let result_cursor = result_offset;
+
+    let stack_pointer = 0;
+
+    const r2 = radius * radius;
+
+    node_stack[stack_pointer] = tree;
+    stack_pointer++;
+
+    while (stack_pointer > 0) {
+
+        --stack_pointer;
+        const node = node_stack[stack_pointer];
+
+        const d2 = aabb2_sqrDistanceToPoint(node.x0, node.y0, node.x1, node.y1, x, y);
+
+        if (d2 > r2) {
+            // not a match
+            continue;
+        }
+
+        const data = node.data;
+        const data_count = data.length;
+
+        for (let i = 0; i < data_count; i++) {
+            const datum = data[i];
+
+            const d2_to_datum = aabb2_sqrDistanceToPoint(datum.x0, datum.y0, datum.x1, datum.y1, x, y);
+
+            if (d2_to_datum <= r2) {
+                result[result_cursor++] = datum;
+            }
+        }
+
+        if (node.isSplit()) {
+            node_stack[stack_pointer++] = node.topLeft;
+            node_stack[stack_pointer++] = node.bottomLeft;
+            node_stack[stack_pointer++] = node.topRight;
+            node_stack[stack_pointer++] = node.bottomRight;
+        }
+    }
+
+    return result_cursor - result_offset;
+}

package/core/geom/Quaternion.d.ts

@@ -1,5 +1,6 @@
 import Signal from "../events/signal/Signal";
 import {Matrix4, Quaternion as ThreeQuaternion} from "three";
+import Vector3 from "./Vector3";
 
 export default class Quaternion {
     public x: number
@@ -7,7 +8,7 @@ export default class Quaternion {
     public z: number
     public w: number
 
-    public get onChanged(): Signal;
+    readonly onChanged: Signal<number, number, number, number, number, number, number, number>;
 
     set(x: number, y: number, z: number, w: number): void
 
@@ -15,6 +16,10 @@ export default class Quaternion {
     copy(other: ThreeQuaternion): void
     copy(other: { x: number, y: number, z: number, w: number }): void
 
+    equals(other: { x: number, y: number, z: number, w: number }): boolean
+
+    normalize(): void
+
     __setThreeEuler(threeEuler: any): void
 
     __setFromEuler(x: number, y: number, z: number, order?: string): void
@@ -29,4 +34,14 @@ export default class Quaternion {
     toEulerAnglesXYZ(v3: { set(x: number, y: number, z: number): any }): void
 
     fromEulerAnglesXYZ(x: number, y: number, z: number): void
+
+    fromAxisAngle(axis: Vector3 | { x: number, y: number, z: number }, angle: number): void
+
+    computeTwistAngle(axis: Vector3): number
+
+    multiplyQuaternions(a: Quaternion, b: Quaternion): void
+
+    toJSON(): any
+
+    fromJSON(j: any): void
 }