@woosh/meep-engine 2.39.40 → 2.39.41

package/core/binary/operations/ceilPowerOfTwo.spec.js

@@ -0,0 +1,17 @@
+import { ceilPowerOfTwo } from "./ceilPowerOfTwo.js";
+
+test('test', () => {
+    expect(ceilPowerOfTwo(1)).toBe(1);
+
+    expect(ceilPowerOfTwo(2)).toBe(2);
+
+    expect(ceilPowerOfTwo(3)).toBe(4);
+    expect(ceilPowerOfTwo(4)).toBe(4);
+
+    expect(ceilPowerOfTwo(5)).toBe(8);
+    expect(ceilPowerOfTwo(7)).toBe(8);
+    expect(ceilPowerOfTwo(8)).toBe(8);
+
+    expect(ceilPowerOfTwo(9)).toBe(16);
+    expect(ceilPowerOfTwo(15)).toBe(16);
+});

package/core/bvh2/binary/2/BinaryUint32BVH.js

@@ -201,7 +201,13 @@ export class BinaryUint32BVH {
 
         const twoLeafLimit = ceilPowerOfTwo(count);
 
-        this.__node_count_binary = twoLeafLimit - 1;
+        if (count <= 1) {
+            // special case
+            this.__node_count_binary = twoLeafLimit;
+        } else {
+            this.__node_count_binary = twoLeafLimit - 1;
+        }
+
     }
 
     /**

package/core/bvh2/binary/2/BinaryUint32BVH.spec.js

@@ -12,6 +12,36 @@ test('1 leaf build does not throw', () => {
     bvh.build();
 });
 
+test('0 leaf tree must have a no binary nodes', () => {
+    const bvh = new BinaryUint32BVH();
+
+    bvh.setLeafCount(0);
+    bvh.initialize_structure();
+    bvh.build();
+
+    expect(bvh.getBinaryNodeCount()).toBe(0);
+});
+
+test('1 leaf tree must have a single binary node', () => {
+    const bvh = new BinaryUint32BVH();
+
+    bvh.setLeafCount(1);
+    bvh.initialize_structure();
+    bvh.build();
+
+    expect(bvh.getBinaryNodeCount()).toBe(1);
+});
+
+test('4 leaf tree must have a 3 binary nodes', () => {
+    const bvh = new BinaryUint32BVH();
+
+    bvh.setLeafCount(4);
+    bvh.initialize_structure();
+    bvh.build();
+
+    expect(bvh.getBinaryNodeCount()).toBe(3);
+});
+
 test('read/write 1 leaf', () => {
     const bvh = new BinaryUint32BVH();
 
@@ -23,7 +53,7 @@ test('read/write 1 leaf', () => {
     expect(bvh.readLeafPayload(0)).toBe(7);
 
     const bounds = [];
-    bvh.readBounds(0, bounds, 0);
+    bvh.readBounds(bvh.getLeafBlockAddress(), bounds, 0);
 
     expect(bounds[0]).toBeCloseTo(-3);
     expect(bounds[1]).toBeCloseTo(-7);

package/core/bvh2/bvh3/query/compute_tight_near_far_clipping_planes.spec.js

@@ -13,7 +13,7 @@ function orthographic_frustum(left, right, up, down, near, far) {
     ]);
 }
 
-test('Empty', () => {
+test('Empty does not throw', () => {
     const bvh = new ExplicitBinaryBoundingVolumeHierarchy();
 
     const res = [];
@@ -23,7 +23,7 @@ test('Empty', () => {
     compute_tight_near_far_clipping_planes(res, 0, 0b000011, bvh, frustum);
 });
 
-test('Axis-aligned, orthographic tight fit around a single small node', () => {
+test.skip('Axis-aligned, orthographic tight fit around a single small node', () => {
     const frustum = orthographic_frustum(-1, 1, -1, 1, -1, 1);
 
     const bvh = new ExplicitBinaryBoundingVolumeHierarchy();

package/core/collection/IteratorUtils.js

@@ -13,4 +13,5 @@ export function collectIteratorValueToArray(result, iterator) {
         result.push(it.value);
     }
 
+    return result;
 }

package/core/collection/queue/Deque.js

@@ -200,11 +200,14 @@ export class Deque {
      */
     __index_of(e) {
         const size = this.size();
-        const capacity = this.__data.length;
+
+        const data = this.__data;
+        const capacity = data.length;
+
         for (let i = 0; i < size; i++) {
             const index = (this.__head + i) % capacity;
 
-            const el = this.__data[index];
+            const el = data[index];
 
             if (el === e) {
                 return i;

package/core/color/Color.js

@@ -157,7 +157,8 @@ export class Color {
         let _h = h % 1;
 
         if (_h < 0) {
-            _h = h + 1;
+            // move into positive range
+            _h = _h + Math.ceil(Math.abs(_h));
         }
 
         const k_r = (_h * 12) % 12;
@@ -184,7 +185,8 @@ export class Color {
         let _h = h % 1;
 
         if (_h < 0) {
-            _h = h + 1;
+            // move into positive range
+            _h = _h + Math.ceil(Math.abs(_h));
         }
 
         const h_face = _h * 6;
@@ -244,7 +246,8 @@ export class Color {
         let _h = h % 1;
 
         if (_h < 0) {
-            _h = h + 1;
+            // move into positive range
+            _h = _h + Math.ceil(Math.abs(_h));
         }
 
         const h_face = _h * 6;
@@ -315,7 +318,7 @@ export class Color {
 
         let r, g, b;
 
-        const i = Math.floor(h * 6);
+        const i = Math.floor(_h * 6);
         const f = _h * 6 - i;
         const p = _v * (1 - _s);
         const q = _v * (1 - f * _s);
@@ -534,6 +537,21 @@ export class Color {
         return new Color(r, g, b);
     }
 
+    /**
+     *
+     * @param {number} h
+     * @param {number} s
+     * @param {number} v
+     * @return {Color}
+     */
+    static fromHSV(h, s, v) {
+        const color = new Color();
+
+        color.setHSV(h, s, v);
+
+        return color;
+    }
+
 
     /**
      *

package/core/color/hsluv/HSLuv.js

@@ -0,0 +1,187 @@
+/**
+ * @see https://github.com/hsluv/hsluv-c/blob/master/src/hsluv.c
+ */
+
+const temp_0 = new Float32Array(3);
+const temp_1 = new Float32Array(3);
+/* for RGB */
+const m = new Float32Array([
+    3.24096994190452134377, -1.53738317757009345794, -0.49861076029300328366,
+    -0.96924363628087982613, 1.87596750150772066772, 0.04155505740717561247,
+    0.05563007969699360846, -0.20397695888897656435, 1.05697151424287856072
+]);
+
+/* for XYZ */
+const m_inv = new Float32Array([
+    0.41239079926595948129, 0.35758433938387796373, 0.18048078840183428751,
+    0.21263900587151035754, 0.71516867876775592746, 0.07219231536073371500,
+    0.01933081871559185069, 0.11919477979462598791, 0.95053215224966058086
+]);
+
+function dot_product(t1, offset_1, t2, offset_2) {
+    return t1[offset_1] * t2[offset_2] + t1[offset_1 + 1] * t2[offset_2 + 1] + t1[offset_1 + 2] * t2[offset_2 + 2];
+}
+
+/* Used for rgb conversions */
+
+function from_linear(c) {
+    if (c <= 0.0031308)
+        return 12.92 * c;
+    else
+        return 1.055 * Math.pow(c, 1.0 / 2.4) - 0.055;
+}
+
+function to_linear(c) {
+    if (c > 0.04045)
+        return Math.pow((c + 0.055) / 1.055, 2.4);
+    else
+        return c / 12.92;
+}
+
+const ref_u = 0.19783000664283680764;
+const ref_v = 0.46831999493879100370;
+
+const kappa = 903.29629629629629629630;
+const epsilon = 0.00885645167903563082;
+
+
+/**
+ *
+ * @param {number} theta
+ * @param {number[]|Float32Array} line
+ * @param {number} line_address
+ * @return {number}
+ */
+function ray_length_until_intersect(theta, line, line_address) {
+    return line[line_address + 1] / (Math.sin(theta) - line[line_address] * Math.cos(theta));
+}
+
+function get_bounds( l, bounds)
+{
+    const tl = l + 16.0;
+    const sub1 = (tl * tl * tl) / 1560896.0;
+    const sub2 = (sub1 > epsilon ? sub1 : (l / kappa));
+    let channel;
+    let t;
+
+    for(channel = 0; channel < 3; channel++) {
+        const ch3 = channel*3;
+        let m1 = m[ch3];
+        let m2 = m[ch3+1];
+        let m3 = m[ch3+2];
+
+        for (t = 0; t < 2; t++) {
+            const top1 = (284517.0 * m1 - 94839.0 * m3) * sub2;
+            const top2 = (838422.0 * m3 + 769860.0 * m2 + 731718.0 * m1) * l * sub2 -  769860.0 * t * l;
+            const bottom = (632260.0 * m3 - 126452.0 * m2) * sub2 + 126452.0 * t;
+
+            const bounds_index = channel * 2 + t;
+            const bounds_address = bounds_index*2;
+
+            bounds[bounds_address] = top1 / bottom;
+            bounds[bounds_address] = top2 / bottom;
+        }
+    }
+}
+
+function max_chroma_for_lh(l, h) {
+    let min_len = Infinity;
+    const hrad = h * 0.01745329251994329577; /* (2 * pi / 360) */
+    const bounds = new Float32Array(12);
+    let i;
+
+    get_bounds(l, bounds);
+
+    for (i = 0; i < 6; i++) {
+        const len = ray_length_until_intersect(hrad, bounds, i * 2);
+
+        if (len >= 0 && len < min_len)
+            min_len = len;
+    }
+
+    return min_len;
+}
+
+function hsluv2lch(input, output) {
+    let h = input[0];
+    const s = input[1];
+    const l = input[2];
+    let c;
+
+    /* White and black: disambiguate chroma */
+    if (l > 99.9999999 || l < 0.00000001)
+        c = 0.0;
+    else
+        c = max_chroma_for_lh(l, h) / 100.0 * s;
+
+    /* Grays: disambiguate hue */
+    if (s < 0.00000001)
+        h = 0.0;
+
+    output[0] = l;
+    output[1] = c;
+    output[2] = h;
+}
+
+function lch2luv(input, output) {
+
+}
+
+function luv2xyz(input, output) {
+
+}
+
+function xyz2rgb(input, output) {
+    const r = from_linear(dot_product(m, 0, input, 0));
+
+    const g = from_linear(dot_product(m, 3, input, 0));
+
+    const b = from_linear(dot_product(m, 6, input, 0));
+
+    output[0] = r;
+    output[1] = g;
+    output[2] = b;
+}
+
+function rgb2xyz(input, output) {
+
+}
+
+function xyz2luv(input, output) {
+
+}
+
+function luv2lch(input, output) {
+
+}
+
+function lch2hsluv(input, output) {
+
+}
+
+
+/**
+ *
+ * @param {number[]} input
+ * @param {number[]} output
+ */
+export function rgb2hsluv(input, output) {
+    rgb2xyz(input, temp_0);
+    xyz2luv(temp_0, temp_1);
+    luv2lch(temp_1, temp_0);
+    lch2hsluv(temp_0, output);
+}
+
+/**
+ *
+ * @param {number[]} input
+ * @param {number[]} output
+ */
+export function hsluv2rgb(input, output) {
+    hsluv2lch(input, temp_0);
+    lch2luv(temp_0, temp_1);
+    luv2xyz(temp_1, temp_0);
+    xyz2rgb(temp_0, output);
+}
+
+

package/core/geom/3d/aabb/aabb3_matrix4_project.js

@@ -1,5 +1,6 @@
 /**
  * NOTE: Based on Transforming Axis-Aligned Bounding Boxes by Jim Arvo from "Graphics Gems", Academic Press, 1990
+ * NOTE: {@link result} and {@link aabb} must be different objects
  * @param {ArrayLike<number>|number[]|Float32Array} result
  * @param {ArrayLike<number>|number[]|Float32Array} aabb
  * @param {number[]} matrix 4x4 matrix

package/core/geom/3d/topology/simplify/simplifyTopoMesh2.js

@@ -52,7 +52,7 @@ export function edge_collapse_reduce_face_count(mesh, num_faces_to_remove, heap,
     const target_face_count = max2(0, mesh_faces.size - num_faces_to_remove);
 
     let cycle_count = 0;
-    let cycle_limit = max2(heap.size, num_faces_to_remove * 4);
+    let cycle_limit = max2(heap.size, num_faces_to_remove * 10) + 10;
 
     while (
         !heap.is_empty()

package/core/primitives/strings/compareStrings.js

@@ -5,6 +5,28 @@
  * @returns {number}
  */
 export function compareStrings(a, b) {
+    // null check
+    if (a === null) {
+        if (b === null) {
+            return 0;
+        } else {
+            return 1;
+        }
+    } else if (b === null) {
+        return -1;
+    }
+
+    // undefined check
+    if (a === undefined) {
+        if (b === undefined) {
+            return 0;
+        } else {
+            return 1;
+        }
+    } else if (b === undefined) {
+        return -1;
+    }
+
     const n = a.length;
 
     const m = b.length;

package/editor/Editor.js

@@ -69,6 +69,8 @@ import Signal from "../core/events/signal/Signal.js";
 import ObservedInteger from "../core/model/ObservedInteger.js";
 import { ObservedIntegerEditor } from "./ecs/component/editors/ObservedIntegerEditor.js";
 
+import '../../../../css/editor/EntityEditorView.scss';
+import '../../../../css/editor/EditorView.scss';
 
 /**
  * @template T

package/editor/tools/v2/BlenderCameraOrientationGizmo.js

@@ -217,7 +217,7 @@ export class BlenderCameraOrientationGizmo extends CanvasView {
          *
          * @type {Vector3|null}
          */
-        this.mouse = null;
+        this.input_pointer_position = null;
 
         this.center = new Vector3(this.options.size / 2, this.options.size / 2, 0);
         this.selectedAxis = null;
@@ -240,16 +240,18 @@ export class BlenderCameraOrientationGizmo extends CanvasView {
         super.link();
 
         const el = this.el;
-        el.addEventListener('mousemove', this.onMouseMove, false);
-        el.addEventListener('mouseout', this.onMouseOut, false);
-        el.addEventListener('click', this.onMouseClick, false);
+
+        el.addEventListener('mousemove', this.onMouseMove);
+        el.addEventListener('mouseout', this.onMouseOut);
+        el.addEventListener('click', this.onMouseClick);
     }
 
     unlink() {
         const el = this.el;
-        el.removeEventListener('mousemove', this.onMouseMove, false);
-        el.removeEventListener('mouseout', this.onMouseOut, false);
-        el.removeEventListener('click', this.onMouseClick, false);
+
+        el.removeEventListener('mousemove', this.onMouseMove);
+        el.removeEventListener('mouseout', this.onMouseOut);
+        el.removeEventListener('click', this.onMouseClick);
 
         super.unlink();
     }
@@ -259,10 +261,19 @@ export class BlenderCameraOrientationGizmo extends CanvasView {
      * @param {MouseEvent} evt
      */
     onMouseMove(evt) {
+        this._setPointerPositionFromEvent(evt);
+    }
+
+    /**
+     *
+     * @param {MouseEvent} evt
+     * @private
+     */
+    _setPointerPositionFromEvent(evt) {
         const v2 = new Vector2();
         readPositionFromMouseEvent(v2, evt);
 
-        this.mouse = new Vector3(v2.x, v2.y, 0);
+        this.input_pointer_position = new Vector3(v2.x, v2.y, 0);
     }
 
     /**
@@ -270,7 +281,7 @@ export class BlenderCameraOrientationGizmo extends CanvasView {
      * @param {MouseEvent} evt
      */
     onMouseOut(evt) {
-        this.mouse = null;
+        this.input_pointer_position = null;
     }
 
     /**
@@ -362,13 +373,13 @@ export class BlenderCameraOrientationGizmo extends CanvasView {
         // If the mouse is over the gizmo, find the closest axis and highlight it
         this.selectedAxis = null;
 
-        if (this.mouse) {
+        if (this.input_pointer_position) {
             let closestDist = Infinity;
             let closestZ = -Infinity;
 
             // Loop through each layer
             for (let bubble of layers) {
-                const distance = v2_distance(this.mouse.x, this.mouse.y, bubble.position.x, bubble.position.y);
+                const distance = v2_distance(this.input_pointer_position.x, this.input_pointer_position.y, bubble.position.x, bubble.position.y);
 
                 // Only select the axis if its closer to the mouse than the previous or if its within its bubble circle
                 if (

package/engine/EngineHarness.js

@@ -27,6 +27,8 @@ import { JsonAssetLoader } from "./asset/loaders/JsonAssetLoader.js";
 import { logger } from "./logging/GlobalLogger.js";
 import { ConsoleLoggerBackend } from "./logging/ConsoleLoggerBackend.js";
 import { noop } from "../core/function/Functions.js";
+import SoundListenerSystem from "./sound/ecs/SoundListenerSystem.js";
+import SoundListener from "./sound/ecs/SoundListener.js";
 
 /**
  *
@@ -174,6 +176,10 @@ export class EngineHarness {
             em.addSystem(new CameraSystem(engine.graphics.scene, engine.graphics))
         }
 
+        if (em.getSystem(SoundListenerSystem) === null) {
+            em.addSystem(new SoundListenerSystem(engine.sound.context));
+        }
+
         if (!ecd.isComponentTypeRegistered(Tag)) {
             ecd.registerComponentType(Tag);
         }
@@ -199,6 +205,7 @@ export class EngineHarness {
             .add(transform)
             .add(cameraController)
             .add(camera)
+            .add(new SoundListener())
             .add(Tag.fromJSON(["Camera"]))
             .build(ecd);
 

package/engine/asset/loaders/geometry/geometry/computeBufferAttributeHash.js

@@ -1,3 +1,5 @@
+import { computeStridedIntegerArrayHash } from "../../../../computeStridedIntegerArrayHash.js";
+
 /**
  *
  * @param {THREE.BufferAttribute} attribute
@@ -15,14 +17,11 @@ export function computeBufferAttributeHash(attribute) {
         // compute stride so that we don't have to iterate over the entire buffer, instead picking at most X(509) values to consider
         const stride = Math.max(1, Math.ceil(index_data_size / 509));
 
-        for (let i = 0; i < index_data_size; i += stride) {
-            const value = index_data[i];
-
-            result = ((result * 31) + value) | 0;
-
-        }
+        result ^= computeStridedIntegerArrayHash(index_data, 0, index_data_size, stride);
 
     }
 
     return result;
 }
+
+

package/engine/asset/loaders/image/codec/Codec.js

@@ -7,4 +7,13 @@ export class Codec {
     async decode(data) {
         throw  new Error('Unsupported Operation');
     }
+
+    /**
+     * Whether codec is able to decode this data, typically checks headers in the data
+     * @param {Uint8Array} data
+     * @return {Promise<boolean>} true if able, false otherwise
+     */
+    async test(data) {
+        return true;
+    }
 }

package/engine/asset/loaders/image/codec/CodecWithFallback.js

@@ -1,28 +1,69 @@
 import { Codec } from "./Codec.js";
-import { logger } from "../../../../logging/GlobalLogger.js";
 
 export class CodecWithFallback extends Codec {
     /**
      *
-     * @param {Codec} main
-     * @param {Codec} fallback
+     * @param {Codec} codecs
      */
-    constructor(main, fallback) {
+    constructor(...codecs) {
         super();
 
-        this.main = main;
-        this.fallback = fallback;
+        this.children = codecs.slice();
+
+        if (this.children.length < 1) {
+            throw new Error('At least one codec must be provided');
+        }
+    }
+
+    async test(data) {
+        const codecs = this.children;
+        const codec_count = codecs.length;
+
+        for (let i = 0; i < codec_count; i++) {
+            const codec = codecs[i];
+
+            if (codec.test(data)) {
+                return true;
+            }
+        }
+
+        return false;
     }
 
     async decode(data) {
 
-        try {
-            return await this.main.decode(data);
-        } catch (e) {
-            logger.warn(`Main codec failed, will attempt fallback. Error: ${e}`);
+        const codecs = this.children;
+        const codec_count = codecs.length;
 
-            return this.fallback.decode(data);
+        const errors = [];
+
+        let result;
+
+        for (let i = 0; i < codec_count; i++) {
+            const codec = codecs[i];
+
+            if (!codec.test(data)) {
+                errors.push({
+                    index: i, error: "Codec doesn't support this data"
+                });
+                continue;
+            }
+
+            try {
+                result = await codec.decode(data);
+            } catch (e) {
+
+                errors.push({
+                    index: i, error: e
+                });
+
+                continue;
+            }
+
+            return result;
         }
 
+        throw new Error(`All codecs failed, errors: ${errors.map(a => JSON.stringify(a)).join('\n')}`);
+
     }
 }

package/engine/asset/loaders/image/codec/ThreadedImageDecoder.js

@@ -1,6 +1,7 @@
 import { Codec } from "./Codec.js";
 import WorkerBuilder from "../../../../../core/process/worker/WorkerBuilder.js";
 import { OnDemandWorkerManager } from "../../../../../core/process/worker/OnDemandWorkerManager.js";
+import { PNG_HEADER_BYTES } from "../png/PNG_HEADER_BYTES.js";
 
 export class ThreadedImageDecoder extends Codec {
     constructor() {
@@ -23,6 +24,17 @@ export class ThreadedImageDecoder extends Codec {
         this.worker.setTimeout(200);
     }
 
+    async test(data) {
+
+        for (let i = 0; i < PNG_HEADER_BYTES.length; i++) {
+            if (data[i] !== PNG_HEADER_BYTES[i]) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
     async decode(data) {
         const result = await this.worker.request('decode', [data.buffer]);
         return result;