@woosh/meep-engine 2.39.39 → 2.39.42

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/aabb3/AABB3.js

@@ -553,12 +553,12 @@ export class AABB3 {
 
     /**
      * @source http://stackoverflow.com/questions/3106666/intersection-of-line-segment-with-axis-aligned-box-in-c-sharp
-     * @param startX
-     * @param startY
-     * @param startZ
-     * @param endX
-     * @param endY
-     * @param endZ
+     * @param {number} startX
+     * @param {number} startY
+     * @param {number} startZ
+     * @param {number} endX
+     * @param {number} endY
+     * @param {number} endZ
      * @returns {boolean}
      */
     intersectSegment2(startX, startY, startZ, endX, endY, endZ) {

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/bvh_query_user_data_nearest_to_point.js

@@ -41,7 +41,7 @@ export function bvh_query_user_data_nearest_to_point(bvh, x, y, z, max_distance
     traversal_stack[traversal_cursor++] = root;
 
     let best_leaf_data = -1;
-    let best_distance = max_distance;
+    let best_distance_sqr = max_distance * max_distance;
 
     while (traversal_cursor > stack_frame_address) {
         traversal_cursor--;
@@ -55,13 +55,13 @@ export function bvh_query_user_data_nearest_to_point(bvh, x, y, z, max_distance
         bvh.node_get_aabb(node, scratch_aabb);
 
         // compute distance to box
-        const distance = max2(0, aabb3_signed_distance_sqr_to_point(
+        const distance_sqr = max2(0, aabb3_signed_distance_sqr_to_point(
             scratch_aabb[0], scratch_aabb[1], scratch_aabb[2],
             scratch_aabb[3], scratch_aabb[4], scratch_aabb[5],
             x, y, z
         ));
 
-        if (distance > best_distance) {
+        if (distance_sqr > best_distance_sqr) {
             // node is too far
             continue;
         }
@@ -81,8 +81,8 @@ export function bvh_query_user_data_nearest_to_point(bvh, x, y, z, max_distance
         } else {
 
             // leaf node
-            if (distance < best_distance) {
-                best_distance = distance;
+            if (distance_sqr < best_distance_sqr) {
+                best_distance_sqr = distance_sqr;
                 best_leaf_data = bvh.node_get_user_data(node);
             }
 

package/core/bvh2/bvh3/bvh_query_user_data_nearest_to_point.spec.js

@@ -0,0 +1,70 @@
+import { ExplicitBinaryBoundingVolumeHierarchy } from "./ExplicitBinaryBoundingVolumeHierarchy.js";
+import { bvh_query_user_data_nearest_to_point } from "./bvh_query_user_data_nearest_to_point.js";
+
+/**
+ *
+ * @param {number[]} boxes
+ * @return {ExplicitBinaryBoundingVolumeHierarchy}
+ */
+function makeBvh(...boxes) {
+    const r = new ExplicitBinaryBoundingVolumeHierarchy();
+
+    for (let i = 0; i < boxes.length; i++) {
+        const box = boxes[i];
+
+        const node = r.allocate_node();
+
+        r.node_set_aabb(node, box);
+        r.node_set_user_data(node, i);
+
+        r.insert_leaf(node);
+    }
+
+    return r;
+}
+
+test('no data, infinite distance', () => {
+    const bvh = makeBvh();
+
+    const result = bvh_query_user_data_nearest_to_point(bvh, 0, 0, 0, Infinity);
+
+    expect(result).toBe(-1);
+});
+
+test('single point, distance too short', () => {
+    const bvh = makeBvh([1, 0, 0, 1, 0, 0]);
+
+    const result = bvh_query_user_data_nearest_to_point(bvh, 0, 0, 0, 0.5);
+
+    expect(result).toBe(-1);
+});
+
+test('single point, distance sufficient', () => {
+    const bvh = makeBvh([1, 0, 0, 1, 0, 0]);
+
+    const result = bvh_query_user_data_nearest_to_point(bvh, 0, 0, 0, 1.5);
+
+    expect(result).not.toBe(-1);
+});
+
+test('two point, distance sufficient to one', () => {
+    const bvh = makeBvh(
+        [1, 0, 0, 1, 0, 0],
+        [2, 0, 0, 2, 0, 0],
+    );
+
+    const result = bvh_query_user_data_nearest_to_point(bvh, 0, 0, 0, 1.5);
+
+    expect(result).toBe(0);
+});
+
+test('two point, distance sufficient to both', () => {
+    const bvh = makeBvh(
+        [1, 0, 0, 1, 0, 0],
+        [2, 0, 0, 2, 0, 0],
+    );
+
+    const result = bvh_query_user_data_nearest_to_point(bvh, 0, 0, 0, 2.5);
+
+    expect(result).toBe(0);
+});

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/cache/Cache.js

@@ -264,6 +264,12 @@ export class Cache {
              */
             const weightTarget = this.maxWeight - elementWeight;
 
+            if (weightTarget < 0) {
+                // Special case
+                // element does not fit into cache, attempting to insert it forcibly would result in a full flush and overflow
+                return;
+            }
+
             //evict elements until there is enough space for the element
             this.evictUntilWeight(weightTarget);
 

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/ecs/component/editors/ecs/terrain/TerrainEditor.js

@@ -27,20 +27,26 @@ export class TerrainEditor extends ObjectEditor {
 
             // splats
             view.bindSignal(terrain.layers.layers.on.added, () => {
-                terrain.splat.addWeightLayer();
-                updateLayers();
+                if (terrain.getFlag(TerrainFlags.Built)) {
+                    terrain.splat.addWeightLayer();
+                    updateLayers();
+                }
             });
             view.bindSignal(terrain.layers.layers.on.removed, (a, index) => {
-                terrain.splat.removeWeightLayer(index);
+                if (terrain.getFlag(TerrainFlags.Built)) {
+                    terrain.splat.removeWeightLayer(index);
 
-                updateLayers();
+                    updateLayers();
+                }
             });
 
             // mapping sizes
             view.bindSignal(terrain.splat.size.onChanged, (x, y) => {
-                terrain.splat.resize(x, y, terrain.splat.depth);
+                if (terrain.getFlag(TerrainFlags.Built)) {
+                    terrain.splat.resize(x, y, terrain.splat.depth);
 
-                terrain.updateMaterial();
+                    terrain.updateMaterial();
+                }
             });
         }
 

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 (