@woosh/meep-engine 2.43.3 → 2.43.5

package/core/binary/BinaryBuffer.js

@@ -343,7 +343,7 @@ export class BinaryBuffer {
      *
      * @param {number} destination_offset starting index in the destination array
      * @param {number} length number of elements to read
-     * @param {Uint32Array} destination
+     * @param {Uint32Array|number[]|ArrayLike<number>} destination
      */
     readUint32Array(destination, destination_offset, length) {
         for (let i = 0; i < length; i++) {
@@ -707,6 +707,18 @@ export class BinaryBuffer {
         this.position = end;
     }
 
+    /**
+     *
+     * @param {Uint32Array|number[]|ArrayLike<number>} source
+     * @param {number} source_offset
+     * @param {number} length
+     */
+    writeUint32Array(source, source_offset, length) {
+        for (let i = 0; i < length; i++) {
+            this.writeUint32(source[source_offset + i]);
+        }
+    }
+
     /**
      *
      * @param {Uint8Array|Uint8ClampedArray} array

package/core/binary/BitSet.js

@@ -403,9 +403,9 @@ BitSet.prototype.set = function (bitIndex, value) {
 
         if (bitIndex === this.__length - 1) {
             // trim down set size potentially
-            const newLastSetBit = this.previousSetBit(bitIndex);
+            // const newLastSetBit = this.previousSetBit(bitIndex);
 
-            this.__setLength(newLastSetBit + 1);
+            this.__setLength(bitIndex );
         }
     }
 

package/core/collection/array/array_range_equal_strict.js

@@ -0,0 +1,22 @@
+/**
+ * Checks that elements in supplied arrays are exactly equal within a certain range defined by a pair of offsets and element count (length)
+ * @template T
+ * @param {T[]} a
+ * @param {number} offset_a
+ * @param {T[]} b
+ * @param {number} offset_b
+ * @param {number} length
+ * @returns {boolean}
+ */
+export function array_range_equal_strict(a, offset_a, b, offset_b, length) {
+
+    for (let i = 0; i < length; i++) {
+
+        if (a[offset_a + i] !== b[offset_b + i]) {
+            return false;
+        }
+
+    }
+
+    return true;
+}

package/core/collection/map/AsyncMapWrapper.js

@@ -1,8 +1,20 @@
 import { AbstractAsyncMap } from "./AbstractAsyncMap.js";
 
+/**
+ * Wraps synchronous {@link Map}-implementing object
+ */
 export class AsyncMapWrapper extends AbstractAsyncMap {
-    constructor(source) {
+    /**
+     *
+     * @param {Map} [source]
+     */
+    constructor(source = new Map()) {
         super();
+        /**
+         *
+         * @type {Map}
+         * @private
+         */
         this._source = source;
     }
 

package/core/collection/map/CachedAsyncMap.js

@@ -1,10 +1,17 @@
 import { AbstractAsyncMap } from "./AbstractAsyncMap.js";
 
+/**
+ * Two-tier key-value storage. Intended to accelerate slow asynchronous
+ * storage with a fast but limited (in space and reliability) cache in front.
+ *
+ * First tier (volatile) is considered to be fast an unreliable,
+ * whereas second tier (persisted) is considered to be reliable, but slow.
+ */
 export class CachedAsyncMap extends AbstractAsyncMap {
     /**
      *
-     * @param {AbstractAsyncMap} volatile
-     * @param {AbstractAsyncMap} persisted
+     * @param {AbstractAsyncMap} volatile data here may be lost at any point, this is our "cache"
+     * @param {AbstractAsyncMap} persisted data here is stored reliably
      */
     constructor(volatile, persisted) {
         super();

package/core/collection/map/CachedAsyncMap.spec.js

@@ -0,0 +1,47 @@
+import { CachedAsyncMap } from "./CachedAsyncMap.js";
+import { AsyncMapWrapper } from "./AsyncMapWrapper.js";
+
+test("'get' retrieves data if it is available in volatile level", async () => {
+
+    const first = new Map();
+
+    const sut = new CachedAsyncMap(new AsyncMapWrapper(first), new AsyncMapWrapper());
+
+    first.set(1, 3);
+
+    expect(await sut.get(1)).toBe(3);
+});
+
+test("'get' retrieves data if it is available in persisted level", async () => {
+
+    const second = new Map();
+
+    const sut = new CachedAsyncMap(new AsyncMapWrapper(), new AsyncMapWrapper(second));
+
+    second.set(1, 3);
+
+    expect(await sut.get(1)).toBe(3);
+});
+
+test("'set' propagates data into volatile level", async () => {
+
+    const first = new Map();
+
+    const sut = new CachedAsyncMap(new AsyncMapWrapper(first), new AsyncMapWrapper());
+
+    await sut.set(1, 3);
+
+    expect(first.get(1)).toBe(3);
+});
+
+
+test("'set' propagates data into persisted level", async () => {
+
+    const second = new Map();
+
+    const sut = new CachedAsyncMap(new AsyncMapWrapper(), new AsyncMapWrapper(second));
+
+    await sut.set(1, 3);
+
+    expect(second.get(1)).toBe(3);
+});

package/core/color/sRGB_to_linear.js

@@ -1,4 +1,9 @@
-function convert(c) {
+/**
+ *
+ * @param {number} c
+ * @return {number|number}
+ */
+export function convert_channel_sRGB_to_linear(c) {
     return (c < 0.04045) ? c * 0.0773993808 : Math.pow(c * 0.9478672986 + 0.0521327014, 2.4);
 }
 
@@ -10,7 +15,7 @@ function convert(c) {
  * @param {number} input_offset
  */
 export function sRGB_to_linear(output, output_offset, input, input_offset) {
-    output[output_offset] = convert(input[input_offset]);
-    output[output_offset + 1] = convert(input[input_offset + 1]);
-    output[output_offset + 2] = convert(input[input_offset + 2]);
+    output[output_offset] = convert_channel_sRGB_to_linear(input[input_offset]);
+    output[output_offset + 1] = convert_channel_sRGB_to_linear(input[input_offset + 1]);
+    output[output_offset + 2] = convert_channel_sRGB_to_linear(input[input_offset + 2]);
 }

package/core/geom/3d/plane/orient3d_fast.js

@@ -1,4 +1,6 @@
 /**
+ * Non-robust
+ *
  * Return a positive value if the point pd lies below the
  * plane passing through pa, pb, and pc; "below" is defined so
  * that pa, pb, and pc appear in counterclockwise order when
@@ -43,3 +45,4 @@ export function orient3d_fast(points, a, b, c, d) {
         + bdx * (cdy * adz - cdz * ady)
         + cdx * (ady * bdz - adz * bdy);
 }
+

package/core/geom/3d/plane/orient3d_robust.js

@@ -0,0 +1,41 @@
+import { orient3d } from "robust-predicates";
+
+/**
+ *
+ * @param {number[]} points
+ * @param {number} a index of point a
+ * @param {number} b index of point b
+ * @param {number} c index of point c
+ * @param {number} d index of point d
+ * @returns {number}
+ */
+export function orient3d_robust(
+    points,
+    a, b, c, d
+) {
+
+
+    const a3 = a * 3;
+    const b3 = b * 3;
+    const c3 = c * 3;
+    const d3 = d * 3;
+
+    const ax = points[a3];
+    const ay = points[a3 + 1];
+    const az = points[a3 + 2];
+
+    const bx = points[b3];
+    const by = points[b3 + 1];
+    const bz = points[b3 + 2];
+
+    const cx = points[c3];
+    const cy = points[c3 + 1];
+    const cz = points[c3 + 2];
+
+    const dx = points[d3];
+    const dy = points[d3 + 1];
+    const dz = points[d3 + 2];
+
+
+    return orient3d(ax, ay, az, bx, by, bz, cx, cy, cz, dx, dy, dz);
+}

package/core/geom/3d/sphere/harmonics/README.md

@@ -0,0 +1,15 @@
+Tools for working with spherical harmonics. 
+
+Mostly intended for shading and global illumination.
+
+## De-ringing
+There are basically 3 approaches,
+* one is filtering using some kind of a smoothing function such as Lanczos
+* Optimization of the polynomial (generally to remove negative values)
+* Piece-wise reconstruction
+
+### References:
+
+---
+* 2008 - GDC - Stupid Spherical Harmonics (SH) Tricks by Peter-Pike Sloan
+* [Computing product of 2 sphecial harmonics](https://github.com/ruba/cortex-vfx/blob/c256b7274516a02fa64a0260351b86f1d6ebe8c2/include/IECore/SphericalHarmonicsAlgo.inl)

package/core/geom/3d/sphere/harmonics/sh3_add.js

@@ -0,0 +1,21 @@
+//
+
+/**
+ * Add two spherical harmonics with 3 bands (9 coefficients)
+ *
+ * @param {number[]} result
+ * @param {number} result_offset
+ * @param {number[]} input_0
+ * @param {number} input_0_offset
+ * @param {number[]} input_1
+ * @param {number} input_1_offset
+ * @param {number} dimension_count
+ */
+export function sh3_add(result, result_offset, input_0, input_0_offset, input_1, input_1_offset, dimension_count) {
+    const n = 9 * dimension_count;
+
+    for (let i = 0; i < n; i++) {
+        result[result_offset + i] = input_0[input_0_offset + i] + input_1[input_1_offset + i];
+    }
+
+}