@woosh/meep-engine 2.156.0 → 2.157.0

package/src/core/math/lookup/ParameterLookupTable.js

@@ -0,0 +1,495 @@
+import { assert } from "../../assert.js";
+import { combine_hash } from "../../collection/array/combine_hash.js";
+import { isArrayEqualStrict } from "../../collection/array/isArrayEqualStrict.js";
+import { computeHashFloatArray } from "../hash/computeHashFloatArray.js";
+import { inverseLerp } from "../inverseLerp.js";
+import { max2 } from "../max2.js";
+import { min2 } from "../min2.js";
+import { computeHashFloat } from "../../primitives/numbers/computeHashFloat.js";
+import { ParameterLookupTableFlags } from "./ParameterLookupTableFlags.js";
+
+
+export class ParameterLookupTable {
+
+    /**
+     *
+     * @type {number[]|Float32Array}
+     */
+    data = [];
+
+    /**
+     *
+     * @type {number[]|Float32Array}
+     */
+    positions = [];
+
+    /**
+     * Transient value
+     * @type {number}
+     */
+    valueMin = 0;
+
+    /**
+     * Transient value
+     * @type {number}
+     */
+    valueMax = 0;
+
+    /**
+     * @private
+     * @type {number}
+     */
+    flags = ParameterLookupTableFlags.WriteMode;
+
+    /**
+     *
+     * @param {number} [itemSize]
+     * @constructor
+     */
+    constructor(itemSize = 1) {
+        assert.isNonNegativeInteger(itemSize, 'itemSize');
+
+        /**
+         *
+         * @type {number}
+         */
+        this.itemSize = itemSize;
+
+    }
+
+    /**
+     *
+     * @param {ParameterLookupTableFlags} f
+     */
+    setFlag(f) {
+        this.flags |= f;
+    }
+
+    /**
+     *
+     * @param {ParameterLookupTableFlags|number} f
+     */
+    clearFlag(f) {
+        this.flags &= ~f;
+    }
+
+    /**
+     *
+     * @param {ParameterLookupTableFlags} f
+     * @returns {boolean}
+     */
+    getFlag(f) {
+        return (this.flags & f) !== 0;
+    }
+
+    disableWriteMode() {
+        this.clearFlag(ParameterLookupTableFlags.WriteMode);
+    }
+
+    fromJSON(json) {
+        this.itemSize = json.itemSize;
+        this.write(json.data, json.positions);
+    }
+
+    toJSON() {
+        return {
+            itemSize: this.itemSize,
+            data: Array.from(this.data),
+            positions: Array.from(this.positions)
+        };
+    }
+
+    /**
+     *
+     * @deprecated Use serialization adapter instead
+     * @param {BinaryBuffer} buffer
+     */
+    toBinaryBuffer(buffer) {
+        const itemCount = this.positions.length;
+
+        const itemCountBitSize = Math.log2(itemCount);
+
+        let itemCountByteSize;
+
+        if (itemCountBitSize <= 8) {
+            itemCountByteSize = 1;
+        } else if (itemCountBitSize <= 16) {
+            itemCountByteSize = 2;
+        } else if (itemCountBitSize <= 32) {
+            itemCountByteSize = 4;
+        } else {
+            throw new Error(`Item count is too high`);
+        }
+
+        const itemSize = this.itemSize;
+        const header = itemSize | (itemCountByteSize << 4);
+
+        buffer.writeUint8(header);
+
+
+        //
+        if (itemCountByteSize === 1) {
+            buffer.writeUint8(itemCount);
+        } else if (itemCountByteSize === 2) {
+            buffer.writeUint16(itemCount);
+        } else if (itemCountByteSize === 4) {
+            buffer.writeUint32(itemCount);
+        }
+
+        const dataLength = itemCount * itemSize;
+
+        let i;
+
+        for (i = 0; i < dataLength; i++) {
+            buffer.writeFloat32(this.data[i]);
+        }
+
+        for (i = 0; i < itemCount; i++) {
+            buffer.writeFloat32(this.positions[i]);
+        }
+    }
+
+    /**
+     * @deprecated Use serialization adapter instead
+     * @param {BinaryBuffer} buffer
+     */
+    fromBinaryBuffer(buffer) {
+        const header = buffer.readUint8();
+
+        this.itemSize = header & 0xF;
+
+        const itemCountByteSize = (header >> 4) & 0xF;
+
+        let itemCount;
+
+        if (itemCountByteSize === 1) {
+            itemCount = buffer.readUint8();
+        } else if (itemCountByteSize === 2) {
+            itemCount = buffer.readUint16();
+        } else if (itemCountByteSize === 4) {
+            itemCount = buffer.readUint32();
+        } else {
+            throw new Error(`Unsupported itemCountByteSize '${itemCountByteSize}'`);
+        }
+
+        const dataLength = itemCount * this.itemSize;
+
+        /**
+         * Reserve a continuous chunk of memory for faster access
+         * @type {ArrayBuffer}
+         */
+        const array_buffer = new ArrayBuffer((dataLength + itemCount) * 4);
+
+        const data = new Float32Array(array_buffer, itemCount * 4, dataLength);
+        buffer.readFloat32Array(data, 0, dataLength);
+
+        const positions = new Float32Array(array_buffer, 0, itemCount);
+        buffer.readFloat32Array(positions, 0, itemCount);
+
+        this.write(data, positions);
+    }
+
+    /**
+     *
+     * @param {number} position
+     * @param {number[]|Float32Array|Float64Array} result
+     */
+    sample(position, result) {
+        assert.isNumber(position, 'position');
+        assert.notNaN(position, 'position');
+        // assert.greaterThanOrEqual(position, 0, 'position');
+        // assert.ok(position >= 0 && position <= 1, `position must be between 0 and 1, instead was ${position}`);
+
+        const itemSize = this.itemSize;
+        const data = this.data;
+        const numValues = data.length / itemSize;
+
+        let i;
+
+        const positions = this.positions;
+
+        let lowIndex = numValues - 1;
+        let highIndex = lowIndex;
+        let fraction = 0;
+
+        if (position <= positions[0]) {
+
+            // special case, seek position is at or before the start of the table
+            lowIndex = 0;
+            highIndex = 0;
+
+        } else {
+
+            //find position index
+            for (i = 1; i < numValues; i++) {
+                //NOTE: no complex search is used, since for small data sizes linear scan is typically faster
+                const p = positions[i];
+
+                if (p >= position) {
+                    // next position if over the seek position
+                    highIndex = i;
+                    lowIndex = i - 1;
+
+                    fraction = inverseLerp(positions[lowIndex], p, position);
+
+                    break;
+                }
+            }
+        }
+
+
+        const low_offset = lowIndex * itemSize;
+        const high_offset = highIndex * itemSize;
+
+        for (i = 0; i < itemSize; i++) {
+            const lowValue = data[low_offset + i];
+            const highValue = data[high_offset + i];
+
+            // inlined for speed: lerp(low, high, fraction)
+            const value = lowValue * (1 - fraction) + highValue * fraction;
+
+            result[i] = value;
+        }
+    }
+
+    computeUniformPositions() {
+        const numValues = this.data.length / this.itemSize;
+
+        const positions = [];
+
+        this.positions = positions;
+
+        for (let i = 0; i < numValues; i++) {
+            positions[i] = i / (numValues - 1);
+        }
+    }
+
+    /**
+     *
+     * @param {number[]|Float64Array|Float32Array|Uint8Array} values
+     * @param {number[]|Float64Array|Float32Array} [positions]
+     */
+    write(values, positions) {
+        if (!this.getFlag(ParameterLookupTableFlags.WriteMode)) {
+            throw new Error(`Cannot write, WriteMode disabled`);
+        }
+
+        assert.isArrayLike(values, 'values');
+
+        const numValues = values.length;
+
+        assert.equal(numValues % this.itemSize, 0, `number of elements in the array[=${numValues}] is not multiple of itemSize(=${this.itemSize})`);
+
+        this.data = values;
+
+        if (positions === undefined) {
+
+            //console.warn('positions are undefined, assuming uniform distribution');
+            this.computeUniformPositions();
+
+        } else {
+
+            assert.equal(numValues / this.itemSize, positions.length, `number of positions[=${positions.length}] is not equal to number of values[=${numValues / this.itemSize}]`);
+
+            this.positions = positions;
+        }
+
+        this.computeStatistics();
+    }
+
+    /**
+     *
+     * @param {number} position
+     * @param {number[]} value
+     */
+    addValue(position, value) {
+        if (!this.getFlag(ParameterLookupTableFlags.WriteMode)) {
+            throw new Error(`Cannot add value, WriteMode disabled`);
+        }
+
+        //insert operation cannot be done on a TypedArray, so we need to make sure we are working with dynamic array
+        if (!Array.isArray(this.positions)) {
+            this.positions = Array.from(this.positions);
+        }
+
+        if (!Array.isArray(this.data)) {
+            this.data = Array.from(this.data);
+        }
+
+        //find a place to insert the value at
+        const positions = this.positions;
+        const numValues = positions.length;
+
+        let i;
+
+        for (i = 0; i < numValues; i++) {
+            const p = positions[i];
+            if (p > position) {
+                break;
+            }
+        }
+
+
+        //insert value
+        positions.splice(i, 0, position);
+
+        const spliceArgs = value.slice();
+        spliceArgs.unshift(i * this.itemSize, 0);
+
+        Array.prototype.splice.apply(this.data, spliceArgs);
+    }
+
+    /**
+     * Populates statistics values
+     */
+    computeStatistics() {
+        //first find min and max values
+        let min = Number.POSITIVE_INFINITY, max = Number.NEGATIVE_INFINITY;
+
+
+        const numElements = this.data.length;
+
+        let i;
+
+        for (i = 0; i < numElements; i++) {
+            const inputElement = this.data[i];
+
+            min = min2(min, inputElement);
+            max = max2(max, inputElement);
+        }
+
+        this.valueMin = min;
+        this.valueMax = max;
+    }
+
+    hash() {
+        const valueMax = this.valueMax;
+        const valueMin = this.valueMin;
+        if (valueMin === valueMax) {
+            //special case, all values are the same
+            return computeHashFloat(valueMin);
+        } else {
+            const dataHash = computeHashFloatArray(this.data);
+            const positionHash = computeHashFloatArray(this.positions);
+
+            return combine_hash(
+                dataHash,
+                positionHash,
+                this.itemSize
+            );
+        }
+    }
+
+    /**
+     *
+     * @param {ParameterLookupTable} other
+     * @returns {boolean}
+     */
+    equals(other) {
+        if (this === other) {
+            // identity shortcut
+            return true;
+        }
+
+        if (this.itemSize !== other.itemSize) {
+            return false;
+        }
+
+        return isArrayEqualStrict(this.data, other.data)
+            && isArrayEqualStrict(this.positions, other.positions)
+            ;
+    }
+
+    validate() {
+        //check data size
+        const data = this.data;
+        const dataLength = data.length;
+
+        const positions = this.positions;
+        const positionLength = positions.length;
+
+        if ((dataLength / this.itemSize) !== positionLength) {
+            //number of samples between position and data doesn't match
+            return false;
+        }
+
+
+        //check position values
+        let prevPosition = Number.NEGATIVE_INFINITY;
+
+        for (let i = 0; i < positionLength; i++) {
+            const position = positions[i];
+
+            if (position < 0) {
+                //position value must be greater or equal to 0
+                return false;
+            }
+
+            if (position > 1) {
+                //position must be less than or equal to 1
+                return false;
+            }
+
+            if (position <= prevPosition) {
+                //position values must always increase
+                return false;
+            }
+
+            prevPosition = position;
+        }
+
+        //all is good
+        return true;
+    }
+
+    /**
+     *
+     * @param {number} itemSize
+     * @param {number[]} values
+     * @param {number[]} [positions]
+     */
+    static from(itemSize, values, positions) {
+        const r = new ParameterLookupTable(itemSize);
+
+        r.write(values, positions);
+
+        return r;
+    }
+
+    /**
+     *
+     * @param {Color} colors
+     * @returns {ParameterLookupTable}
+     */
+    static color_uint8_uniform(...colors) {
+        assert.defined(colors, 'colors');
+
+        const r = new ParameterLookupTable(4);
+
+        const length = colors.length;
+        const values = new Uint8Array(length * 4);
+
+        for (let i = 0; i < length; i++) {
+            const color = colors[i];
+
+            const i4 = i * 4;
+
+            values[i4] = Math.round(color.r * 255);
+            values[i4 + 1] = Math.round(color.g * 255);
+            values[i4 + 2] = Math.round(color.b * 255);
+            values[i4 + 3] = Math.round(color.a * 255);
+        }
+
+        r.write(values);
+
+        r.computeUniformPositions();
+
+        return r;
+    }
+}
+
+/**
+ * @readonly
+ * @type {boolean}
+ */
+ParameterLookupTable.prototype.isParameterLookupTable = true;

package/src/core/math/lookup/ParameterLookupTableFlags.d.ts

@@ -0,0 +1,5 @@
+export type ParameterLookupTableFlags = number;
+export namespace ParameterLookupTableFlags {
+    let WriteMode: number;
+}
+//# sourceMappingURL=ParameterLookupTableFlags.d.ts.map

package/src/core/math/lookup/ParameterLookupTableFlags.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ParameterLookupTableFlags.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/lookup/ParameterLookupTableFlags.js"],"names":[],"mappings":"wCACU,MAAM"}

package/src/core/math/lookup/ParameterLookupTableFlags.js

@@ -0,0 +1,6 @@
+/**
+ * @enum {number}
+ */
+export const ParameterLookupTableFlags = {
+    WriteMode: 1
+};

package/src/core/math/physics/kinematics/computeInterceptPoint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"computeInterceptPoint.d.ts","sourceRoot":"","sources":["../../../../../../src/core/math/physics/kinematics/computeInterceptPoint.js"],"names":[],"mappings":"AASA;;;;;;;;;GASG;AACH,+HAHW,MAAM,GACL,OAAO,CA8DlB"}

package/src/{engine/physics → core/math/physics/kinematics}/computeInterceptPoint.js

@@ -1,80 +1,80 @@
-import { v3_dot } from "../../core/geom/vec3/v3_dot.js";
-import { solveQuadratic } from "../../core/math/solveQuadratic.js";
-
-/**
- *
- * @type {number[]}
- */
-const q_roots = [];
-
-/**
- * Given position of the source point, and target moving at a constant velocity, compute intercept.
- * Simple example would be {@link target} being enemy running, and {@link source} being position of our archer, given that the arrow speed is {@link sourceSpeed}, where should the archer aim at in order to hit the moving target?
- * @param {Vector3} result This is where the intercept point will be written if solution is found
- * @param {Vector3} source Where to launch a projectile from
- * @param {Vector3} target Where the target currently is
- * @param {Vector3} targetVelocity Target's current velocity vector
- * @param {number} sourceSpeed Speed of the projectile in question
- * @return {boolean} true iff there is at least one real solution
- */
-export function computeInterceptPoint(
-    result,
-    source,
-    target,
-    targetVelocity,
-    sourceSpeed
-) {
-
-    if (sourceSpeed < 0) {
-        // negative speed is invalid
-        return false;
-    }
-
-    const d_ts_x = target.x - source.x;
-    const d_ts_y = target.y - source.y;
-    const d_ts_z = target.z - source.z;
-
-    // Get quadratic equation components
-    const a = targetVelocity.dot(targetVelocity) - sourceSpeed * sourceSpeed;
-    const b = 2 * v3_dot(targetVelocity.x, targetVelocity.y, targetVelocity.z, d_ts_x, d_ts_y, d_ts_z);
-
-    const c = v3_dot(
-        d_ts_x, d_ts_y, d_ts_z,
-        d_ts_x, d_ts_y, d_ts_z
-    );
-
-    // Solve quadratic
-    const root_count = solveQuadratic(q_roots, 0, a, b, c); // See quad(), below
-
-    // Find smallest positive solution
-    if (root_count > 0) {
-        const root_0 = q_roots[0];
-        const root_1 = q_roots[1];
-
-        let t = Math.min(root_0, root_1);
-
-        if (t < 0) {
-            // one of the roots is negative, which would produce imaginary solution, so let's try to pick the other one
-            t = Math.max(root_0, root_1);
-        }
-
-        if (t >= 0) {
-
-            // Single write, computed from the inputs up front, so it is correct
-            // even when `result` aliases `target` (a copy-then-add would read
-            // `target` after overwriting it, doubling the velocity term).
-            result.set(
-                target.x + targetVelocity.x * t,
-                target.y + targetVelocity.y * t,
-                target.z + targetVelocity.z * t,
-            );
-
-            return true;
-
-        }
-
-        // if we got to this point, that means that both roots are imaginary, so there is no real solution
-
-    }
-    return false;
+import { v3_dot } from "../../../geom/vec3/v3_dot.js";
+import { solveQuadratic } from "../../solveQuadratic.js";
+
+/**
+ *
+ * @type {number[]}
+ */
+const q_roots = [];
+
+/**
+ * Given position of the source point, and target moving at a constant velocity, compute intercept.
+ * Simple example would be {@link target} being enemy running, and {@link source} being position of our archer, given that the arrow speed is {@link sourceSpeed}, where should the archer aim at in order to hit the moving target?
+ * @param {Vector3} result This is where the intercept point will be written if solution is found
+ * @param {Vector3} source Where to launch a projectile from
+ * @param {Vector3} target Where the target currently is
+ * @param {Vector3} targetVelocity Target's current velocity vector
+ * @param {number} sourceSpeed Speed of the projectile in question
+ * @return {boolean} true iff there is at least one real solution
+ */
+export function computeInterceptPoint(
+    result,
+    source,
+    target,
+    targetVelocity,
+    sourceSpeed
+) {
+
+    if (sourceSpeed < 0) {
+        // negative speed is invalid
+        return false;
+    }
+
+    const d_ts_x = target.x - source.x;
+    const d_ts_y = target.y - source.y;
+    const d_ts_z = target.z - source.z;
+
+    // Get quadratic equation components
+    const a = targetVelocity.dot(targetVelocity) - sourceSpeed * sourceSpeed;
+    const b = 2 * v3_dot(targetVelocity.x, targetVelocity.y, targetVelocity.z, d_ts_x, d_ts_y, d_ts_z);
+
+    const c = v3_dot(
+        d_ts_x, d_ts_y, d_ts_z,
+        d_ts_x, d_ts_y, d_ts_z
+    );
+
+    // Solve quadratic
+    const root_count = solveQuadratic(q_roots, 0, a, b, c); // See quad(), below
+
+    // Find smallest positive solution
+    if (root_count > 0) {
+        const root_0 = q_roots[0];
+        const root_1 = q_roots[1];
+
+        let t = Math.min(root_0, root_1);
+
+        if (t < 0) {
+            // one of the roots is negative, which would produce imaginary solution, so let's try to pick the other one
+            t = Math.max(root_0, root_1);
+        }
+
+        if (t >= 0) {
+
+            // Single write, computed from the inputs up front, so it is correct
+            // even when `result` aliases `target` (a copy-then-add would read
+            // `target` after overwriting it, doubling the velocity term).
+            result.set(
+                target.x + targetVelocity.x * t,
+                target.y + targetVelocity.y * t,
+                target.z + targetVelocity.z * t,
+            );
+
+            return true;
+
+        }
+
+        // if we got to this point, that means that both roots are imaginary, so there is no real solution
+
+    }
+    return false;
 }

package/src/core/math/physics/mie/ri_air.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ri_air.d.ts","sourceRoot":"","sources":["../../../../../../src/core/math/physics/mie/ri_air.js"],"names":[],"mappings":"AA4DA;;;;GAIG;AACH,+BAHW,MAAM,EAAE,iBACR,MAAM,QAKhB"}
+{"version":3,"file":"ri_air.d.ts","sourceRoot":"","sources":["../../../../../../src/core/math/physics/mie/ri_air.js"],"names":[],"mappings":"AA0DA;;;;GAIG;AACH,+BAHW,MAAM,EAAE,iBACR,MAAM,QAKhB"}

package/src/core/math/physics/mie/ri_air.js

@@ -1,6 +1,4 @@
-import {
-    ParameterLookupTable
-} from "../../../../engine/graphics/particles/particular/engine/parameter/ParameterLookupTable.js";
+import { ParameterLookupTable } from "../../lookup/ParameterLookupTable.js";
 
 /**
  * Values for standard air (15°C, 1 atm, 450 ppm CO₂)

package/src/core/math/physics/mie/ri_ammonium_sulfate.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ri_ammonium_sulfate.d.ts","sourceRoot":"","sources":["../../../../../../src/core/math/physics/mie/ri_ammonium_sulfate.js"],"names":[],"mappings":"AAoIA;;;;GAIG;AACH,4CAHW,MAAM,EAAE,iBACR,MAAM,QAIhB"}
+{"version":3,"file":"ri_ammonium_sulfate.d.ts","sourceRoot":"","sources":["../../../../../../src/core/math/physics/mie/ri_ammonium_sulfate.js"],"names":[],"mappings":"AAkIA;;;;GAIG;AACH,4CAHW,MAAM,EAAE,iBACR,MAAM,QAIhB"}