@woosh/meep-engine 2.43.13 → 2.43.14

package/core/math/MathUtils.js

@@ -1,247 +0,0 @@
-/**
- * @author Alex Goldring
- * @copyright Alex Goldring 17/04/2016.
- */
-
-import { assert } from "../assert.js";
-import { min2 } from "./min2.js";
-
-/**
- * @template T
- * @param {T[]} sequence
- * @returns {function(): T}
- */
-export function makeSequenceLoop(sequence) {
-    let i = 0;
-
-    const data = sequence.slice();
-    const n = data.length;
-
-
-    return function sequenceLoop() {
-        const datum = data[i % n];
-
-        i++;
-
-        return datum;
-    }
-}
-
-/**
- * Compute lowest positive integer divisor of a given "product" value
- * @param {number} product
- * @param {number} limit
- * @returns {number}
- */
-export function computeWholeDivisorLow(product, limit) {
-    assert.typeOf(product, 'number', 'product');
-    assert.typeOf(limit, 'number', 'limit');
-
-
-    assert.ok(Number.isInteger(product), `expected product to be an integer, instead got '${product}'`);
-    assert.ok(Number.isInteger(limit), `expected limit to be an integer, instead got '${limit}'`);
-
-    let i = limit;
-
-    while (i > 1) {
-
-        if (product % i === 0) {
-            break;
-        }
-
-        i--;
-
-    }
-
-    return i;
-}
-
-
-/**
- *
- * @param {Number} t
- * @param {Number} p0
- * @param {Number} p1
- * @param {Number} p2
- * @return {number}
- */
-export function quadraticCurve(t, p0, p1, p2) {
-    return (1 - t) * (1 - t) * p0 + 2 * (1 - t) * t * p1 + t * t * p2;
-}
-
-/**
- *
- * @param {Number} p0
- * @param {Number} p1
- * @param {Number} p2
- * @param {Number} p3
- * @return {function(number): Number}
- */
-export function makeCubicCurve(p0, p1, p2, p3) {
-    return function (v) {
-        return cubicCurve(v, p0, p1, p2, p3);
-    }
-}
-
-/**
- *
- * @param {Number} t
- * @param {Number} p0
- * @param {Number} p1
- * @param {Number} p2
- * @param {Number} p3
- * @return {Number}
- */
-export function cubicCurve(t, p0, p1, p2, p3) {
-    /**
-     *
-     * @type {number}
-     */
-    const cX = 3 * (p1 - p0);
-
-    /**
-     *
-     * @type {number}
-     */
-    const bX = 3 * (p2 - p1) - cX;
-
-    /**
-     *
-     * @type {number}
-     */
-    const aX = p3 - p0 - cX - bX;
-
-    const t_2 = t * t;
-
-    const t_3 = t_2 * t;
-
-    return (aX * t_3) + (bX * t_2) + (cX * t) + p0;
-}
-
-/**
- * 3-rd degree bezier curve
- * @param {number} t
- * @param {number} p0 start point
- * @param {number} p1 control point
- * @param {number} p2 control point
- * @param {number} p3 end point
- * @returns {number}
- */
-function bezierCurve(t, p0, p1, p2, p3) {
-    const nt = 1 - t;
-
-    const nt_2 = nt * nt;
-
-    const nt_3 = nt_2 * nt;
-
-    const t_2 = t * t;
-
-    const t_3 = t_2 * t;
-
-    return nt_3 * p0 + 3 * nt_2 * t * p1 + 3 * nt * t_2 * p2 + t_3 * p3;
-}
-
-
-/**
- *
- * @param {number} a
- * @param {number} b
- * @returns {number}
- */
-export function computeGreatestCommonDivisor(a, b) {
-    assert.typeOf(a, 'number', 'a');
-    assert.typeOf(b, 'number', 'b');
-
-    const start = min2(a, b);
-
-    let result = start;
-
-    while (result > 1) {
-        if (a % result === 0 && b % result === 0) {
-            break;
-        }
-
-        result--;
-    }
-
-    return result;
-}
-
-
-/**
- *
- * @param {number} side length of the side
- * @param {number} base length of the base
- * @returns {number}
- */
-export function computeIsoscelesTriangleApexAngle(side, base) {
-    const b2 = base * base;
-    const s2 = side * side;
-
-    const upper = (2 * s2 - b2);
-    const lower = (2 * s2);
-
-    const cosAlpha = upper / lower;
-
-    return Math.acos(cosAlpha);
-}
-
-/**
- * Comparison of two numbers with a given tolerance
- * @param {number} a
- * @param {number} b
- * @param {number} tolerance
- * @returns {boolean}
- */
-export function epsilonEquals(a, b, tolerance) {
-    assert.isNumber(a, 'a');
-    assert.isNumber(b, 'b');
-    assert.isNumber(tolerance, 'tolerance');
-
-    return Math.abs(a - b) <= tolerance;
-}
-
-/**
- * Assuming the input is an N-dimension vector, normalizes the vector to magnitude of 1
- * @param {number[]|Float32Array} result
- * @param {number[]|Float32Array} data
- * @param {number} [length]
- */
-export function normalizeArrayVector(result, data, length = data.length) {
-
-    let magnitude2 = 0;
-
-    for (let i = 0; i < length; i++) {
-        const value = data[i];
-
-        const value2 = value * value;
-
-        magnitude2 += value2;
-    }
-
-    const magnitude_inv = 1 / Math.sqrt(magnitude2);
-
-    for (let i = 0; i < length; i++) {
-        result[i] = data[i] * magnitude_inv;
-    }
-
-}
-
-/**
- * Pi*2
- * @type {number}
- */
-export const PI2 = Math.PI * 2;
-
-/**
- * Pi/2
- * @type {number}
- */
-export const PI_HALF = Math.PI / 2;
-
-/**
- * Very small value, used for comparison when compensation for rounding error is required
- * @type {number}
- */
-export const EPSILON = 0.000001;
-

package/core/math/MathUtils.spec.js

@@ -1,232 +0,0 @@
-import { clamp } from "./clamp.js";
-import { copysign } from "./copysign.js";
-import { inverseLerp } from "./inverseLerp.js";
-import { lerp } from "./lerp.js";
-import { computeWholeDivisorLow, cubicCurve, makeCubicCurve, quadraticCurve } from "./MathUtils.js";
-import { max2 } from "./max2.js";
-import { max3 } from "./max3.js";
-import { min2 } from "./min2.js";
-import { min3 } from "./min3.js";
-import { sign } from "./sign.js";
-import { isValueBetween } from "./isValueBetween.js";
-import { isValueBetweenInclusive } from "./isValueBetweenInclusive.js";
-import { overlap1D } from "./overlap1D.js";
-import { computeHashFloat } from "./hash/computeHashFloat.js";
-
-test('min2', () => {
-    expect(min2(0, 0)).toBe(0);
-
-    expect(min2(2, 1)).toBe(1);
-
-    expect(min2(1, 2)).toBe(1);
-
-    expect(min2(-1, 1)).toBe(-1);
-
-    expect(min2(1, -1)).toBe(-1);
-});
-
-test('max2', () => {
-    expect(max2(0, 0)).toBe(0);
-
-    expect(max2(2, 1)).toBe(2);
-
-    expect(max2(1, 2)).toBe(2);
-
-    expect(max2(-1, 1)).toBe(1);
-
-    expect(max2(1, -1)).toBe(1);
-});
-
-test("max3", () => {
-    expect(max3(-1, -3, 1)).toBe(1);
-
-    expect(max3(-3, -1, 1)).toBe(1);
-
-    expect(max3(-3, 1, -1)).toBe(1);
-
-    expect(max3(-1, 1, -3)).toBe(1);
-
-    expect(max3(1, -1, -3)).toBe(1);
-
-    expect(max3(1, -3, -1)).toBe(1);
-
-    expect(max3(-3, 1, 1)).toBe(1);
-
-    expect(max3(3, 1, 1)).toBe(3);
-
-    expect(max3(3, 3, -1)).toBe(3);
-
-    expect(max3(3, 3, 4)).toBe(4);
-
-    expect(max3(3, 0, 3)).toBe(3);
-
-    expect(max3(3, 4, 3)).toBe(4);
-});
-
-test("min3", () => {
-    expect(min3(-1, -3, 1)).toBe(-3);
-
-    expect(min3(-3, -1, 1)).toBe(-3);
-
-    expect(min3(-1, 1, -3)).toBe(-3);
-
-    expect(min3(1, -3, -1)).toBe(-3);
-
-    expect(min3(-3, 1, -1)).toBe(-3);
-
-    expect(min3(1, -1, -3)).toBe(-3);
-
-    expect(min3(-3, 1, 1)).toBe(-3);
-
-    expect(min3(2, 1, 1)).toBe(1);
-
-    expect(min3(3, 3, -1)).toBe(-1);
-
-    expect(min3(3, 3, 4)).toBe(3);
-
-    expect(min3(3, 0, 3)).toBe(0);
-
-    expect(min3(3, 4, 3)).toBe(3);
-});
-
-test("quadratiCurve", () => {
-    expect(quadraticCurve(2, 0.1, 0.2, 3)).toBe(11.3);
-
-    expect(quadraticCurve(1, -1, -2, -3)).toBe(-3);
-
-    expect(quadraticCurve(-1, -1, 0, 0)).toBe(-4);
-
-    expect(quadraticCurve(-1, -1, 1, 0)).toBe(-8);
-
-    expect(quadraticCurve(-1, 0, 0, 0)).toBe(0);
-});
-
-test("cubicCurve", () => {
-    expect(cubicCurve(0, 1, 2, 3, 4)).toBe(1);
-
-    expect(cubicCurve(0, 2, 3, 4, 5)).toBe(2);
-
-    expect(cubicCurve(1, 2, 3, 4, 5)).toBe(5);
-
-    expect(cubicCurve(1, 3, 4, 5, 6)).toBe(6);
-
-    expect(cubicCurve(2, 2, 2, 2, 3)).toBe(10);
-});
-
-test("makeCubicCurve", () => {
-    const f = makeCubicCurve(1, 2, 3, 4);
-    expect(f(0)).toBe(1);
-
-    expect(f(1)).toBe(4);
-});
-
-test("computeHashFloat", () => {
-    expect(computeHashFloat(500)).toEqual(computeHashFloat(500));
-
-    expect(computeHashFloat(500)).not.toEqual(computeHashFloat(400))
-});
-
-
-test('sign', () => {
-    expect(sign(1)).toBe(1);
-
-    expect(sign(-1)).toBe(-1);
-
-    expect(sign(0)).toBe(0);
-
-    expect(sign(2)).toBe(1);
-
-    expect(sign(-2)).toBe(-1);
-});
-
-test('lerp', () => {
-    expect(lerp(0, 5, 0.1)).toBe(0.5);
-
-    expect(lerp(-5, 5, 0.5)).toBe(0);
-
-    expect(lerp(0, 0, 0)).toBe(0);
-
-    expect(lerp(0, 0, 1)).toBe(0);
-
-    expect(lerp(1, 2, 0)).toBe(1);
-
-    expect(lerp(1, 2, 1)).toBe(2);
-});
-
-test('inverseLerp', () => {
-    expect(inverseLerp(0, 5, 0.5)).toBe(0.1);
-
-    expect(inverseLerp(-5, 5, 0)).toBe(0.5);
-
-    expect(inverseLerp(0, 0, 0)).toBe(0);
-
-    expect(inverseLerp(1, 2, 1)).toBe(0);
-
-    expect(inverseLerp(1, 2, 2)).toBe(1);
-});
-
-test('clamp', () => {
-    expect(clamp(0, 0, 0)).toBe(0);
-
-    expect(clamp(0, 1, 1)).toBe(1);
-
-    expect(clamp(0, -1, -1)).toBe(-1);
-
-    expect(clamp(3, 1, 2)).toBe(2);
-
-    expect(clamp(0, 1, 2)).toBe(1);
-
-    expect(clamp(2, 1, 3)).toBe(2);
-});
-
-test('copysign', () => {
-    expect(copysign(1, 2)).toBe(1);
-    expect(copysign(2, 1)).toBe(2);
-
-    expect(copysign(2, -1)).toBe(-2);
-    expect(copysign(-2, 1)).toBe(2);
-    expect(copysign(-2, -1)).toBe(-2);
-
-    expect(copysign(3, 7)).toBe(3);
-    expect(copysign(3, -7)).toBe(-3);
-});
-
-test('computeWholeDivisorLow 1/1', () => {
-    expect(computeWholeDivisorLow(1, 1)).toEqual(1);
-});
-
-test('computeWholeDivisorLow 16/5', () => {
-    expect(computeWholeDivisorLow(16, 5)).toEqual(4);
-});
-
-test("isValueBetween", () => {
-    expect(isValueBetween(0, 1, 2)).toBe(false);
-});
-
-test("isValueBetween", () => {
-    expect(isValueBetween(1, -1, 2)).toBe(true);
-
-    expect(isValueBetween(1, 2, -1)).toBe(true);
-});
-
-test("isValueBetweenInclusive", () => {
-    expect(isValueBetweenInclusive(1, 1, 2)).toBe(true);
-
-    expect(isValueBetweenInclusive(2, 1, 2)).toBe(true);
-
-    expect(isValueBetweenInclusive(1.5, 1, 2)).toBe(true);
-
-    expect(isValueBetweenInclusive(0.5, 1, 2)).toBe(false);
-
-    expect(isValueBetweenInclusive(3, 1, 2)).toBe(false);
-});
-
-
-test('overlap1D', () => {
-    expect(overlap1D(0, 0, 0, 0)).toBe(false);
-    expect(overlap1D(-3, -1, -2, -0.5)).toBe(true);
-    expect(overlap1D(-1, 2, 1, 1)).toBe(true);
-    expect(overlap1D(1, 1, -1, 2)).toBe(true);
-
-    expect(overlap1D(1, 2, 2, 3)).toBe(false);
-});

package/engine/ecs/terrain/ecs/ClingToTerrain.js

@@ -1,100 +0,0 @@
-/**
- * Created by Alex on 13/05/2016.
- */
-import Vector3 from "../../../../core/geom/Vector3.js";
-import Quaternion from "../../../../core/geom/Quaternion.js";
-import { BinaryClassSerializationAdapter } from "../../storage/binary/BinaryClassSerializationAdapter.js";
-
-const ClingToTerrain = function (options) {
-    if (options === undefined) {
-        options = {};
-    }
-
-    /**
-     * @type {boolean}
-     */
-    this.normalAlign = options.normalAlign !== undefined ? options.normalAlign : false;
-
-    /**
-     * Used internally for caching updates
-     * @type {Vector3}
-     */
-    this.__lastPosition = new Vector3(0, 0, 0);
-    /**
-     *
-     * @type {Quaternion}
-     */
-    this.__lastRotation = new Quaternion(0, 0, 0, 1);
-
-    /**
-     * Speed in Rad/s (Radians/second) by which rotation can change
-     * @type {number}
-     */
-    this.rotationSpeed = 3;
-};
-
-ClingToTerrain.typeName = "ClingToTerrain";
-
-/**
- *
- * @param json
- * @returns {ClingToTerrain}
- */
-ClingToTerrain.fromJSON = function (json) {
-    const r = new ClingToTerrain();
-
-    r.fromJSON(json);
-
-    return r;
-};
-
-
-ClingToTerrain.prototype.toJSON = function () {
-    return {
-        normalAlign: this.normalAlign,
-        rotationSpeed: this.rotationSpeed
-    };
-};
-
-ClingToTerrain.prototype.fromJSON = function (
-    {
-        normalAlign = false,
-        rotationSpeed = Number.POSITIVE_INFINITY
-    }
-) {
-    this.normalAlign = normalAlign;
-    this.rotationSpeed = rotationSpeed;
-};
-
-
-export default ClingToTerrain;
-
-
-export class ClingToTerrainSerializationAdapter extends BinaryClassSerializationAdapter{
-    constructor(){
-        super();
-
-        this.klass = ClingToTerrain;
-        this.version = 0;
-    }
-
-    /**
-     *
-     * @param {BinaryBuffer} buffer
-     * @param {ClingToTerrain} value
-     */
-    serialize(buffer, value) {
-        //TODO serialize rotation speed
-        buffer.writeUint8(value.normalAlign ? 1 : 0);
-    }
-
-    /**
-     *
-     * @param {BinaryBuffer} buffer
-     * @param {ClingToTerrain} value
-     */
-    deserialize(buffer, value) {
-        //TODO deserialize rotation speed
-        value.normalAlign = buffer.readUint8() !== 0;
-    }
-}