@woosh/meep-engine 2.39.38 → 2.39.41

package/core/binary/Base64.js

@@ -3,13 +3,21 @@
  * @author Jameson Little
  */
 
-var lookup = [];
-var revLookup = [];
-var Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array;
+/**
+ *
+ * @type {string[]}
+ */
+const lookup = [];
+/**
+ *
+ * @type {number[]}
+ */
+const revLookup = [];
+const Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array;
 
-var code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+const code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
 
-for (var i = 0, len = code.length; i < len; ++i) {
+for (let i = 0, len = code.length; i < len; ++i) {
     lookup[i] = code[i];
     revLookup[code.charCodeAt(i)] = i;
 }
@@ -19,6 +27,11 @@ for (var i = 0, len = code.length; i < len; ++i) {
 revLookup['-'.charCodeAt(0)] = 62;
 revLookup['_'.charCodeAt(0)] = 63;
 
+/**
+ *
+ * @param {string} b64
+ * @return {number[]}
+ */
 function getLens(b64) {
     var len = b64.length;
 
@@ -41,12 +54,6 @@ function getLens(b64) {
 }
 
 // base64 is 4/3 + up to two characters of the original data
-function byteLength(b64) {
-    var lens = getLens(b64);
-    var validLen = lens[0];
-    var placeHoldersLen = lens[1];
-    return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen;
-}
 
 function _byteLength(b64, validLen, placeHoldersLen) {
     return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen;
@@ -99,37 +106,57 @@ function toByteArray(b64) {
 }
 
 function tripletToBase64(num) {
-    return lookup[num >> 18 & 0x3F] +
-        lookup[num >> 12 & 0x3F] +
-        lookup[num >> 6 & 0x3F] +
-        lookup[num & 0x3F];
+    return lookup[num >> 18 & 0x3F]
+        + lookup[num >> 12 & 0x3F]
+        + lookup[num >> 6 & 0x3F]
+        + lookup[num & 0x3F]
+        ;
 }
 
+/**
+ *
+ * @param {Uint8Array} uint8
+ * @param {number} start
+ * @param {number} end
+ * @return {string}
+ */
 function encodeChunk(uint8, start, end) {
-    var tmp;
-    var output = [];
-    for (var i = start; i < end; i += 3) {
-        tmp =
-            ((uint8[i] << 16) & 0xFF0000) +
-            ((uint8[i + 1] << 8) & 0xFF00) +
-            (uint8[i + 2] & 0xFF);
+    const output = [];
+
+    for (let i = start; i < end; i += 3) {
+
+        const tmp = ((uint8[i] << 16) & 0xFF0000)
+            + ((uint8[i + 1] << 8) & 0xFF00)
+            + (uint8[i + 2] & 0xFF);
+
         output.push(tripletToBase64(tmp));
     }
+
     return output.join('');
 }
 
+/**
+ *
+ * @param {Uint8Array} uint8
+ * @return {string}
+ */
 function fromByteArray(uint8) {
-    var tmp;
-    var len = uint8.length;
-    var extraBytes = len % 3; // if we have 1 byte left, pad 2 bytes
-    var parts = [];
-    var maxChunkLength = 16383; // must be multiple of 3
+    let tmp;
+
+    const len = uint8.length;
+    const extraBytes = len % 3; // if we have 1 byte left, pad 2 bytes
+    const parts = [];
+    const maxChunkLength = 16383; // must be multiple of 3
 
     // go through the array every three bytes, we'll deal with trailing stuff later
-    for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) {
-        parts.push(encodeChunk(
-            uint8, i, (i + maxChunkLength) > len2 ? len2 : (i + maxChunkLength)
-        ));
+    const len2 = len - extraBytes;
+
+    for (let i = 0; i < len2; i += maxChunkLength) {
+        const end = (i + maxChunkLength) > len2 ? len2 : (i + maxChunkLength);
+
+        const chunk = encodeChunk(uint8, i, end);
+
+        parts.push(chunk);
     }
 
     // pad the end with zeros, but make sure to not forget the extra bytes

package/core/binary/Base64.spec.js

@@ -0,0 +1,14 @@
+import { Base64 } from "./Base64.js";
+
+test("to/from consistency", () => {
+    const source = new Uint8Array(256);
+    for (let i = 0; i < source.length; i++) {
+        source[i] = i;
+    }
+
+    const encoded = Base64.encode(source.buffer);
+
+    const decoded = Base64.decode(encoded);
+
+    expect(Array.from(new Uint8Array(decoded))).toEqual(Array.from(source));
+});

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/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/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;
@@ -301,18 +304,21 @@ export class Color {
      * @param {number} v 0..1
      */
     setHSV(h, s, v) {
-        let _h = h % 1;
+        let _h = h;
 
         if (_h < 0) {
-            _h = h + 1;
+            // move into positive range
+            _h = _h + Math.ceil(Math.abs(_h));
         }
 
+        _h = _h % 1
+
         const _s = clamp01(s);
         const _v = clamp01(v);
 
         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);
@@ -409,7 +415,8 @@ export class Color {
      * @param {Color} other
      */
     copy(other) {
-        this.setRGB(this.r, this.g, this.b);
+        this.a = other.a;
+        this.setRGB(other.r, other.g, other.b);
     }
 
     /**
@@ -530,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()