@woosh/meep-engine 2.75.8 → 2.75.9

package/src/engine/ecs/systems/PhysicsSystem.js

@@ -1,89 +0,0 @@
-/**
- * Created by Alex on 01/04/2014.
- */
-import { System } from '../System.js';
-import PhysicalBody from '../components/PhysicalBody.js';
-import { Transform } from '../transform/Transform.js';
-import PhysicsWorld from '../../physics/ammo/World.js';
-
-
-class PhysicsSystem extends System {
-    constructor() {
-        super();
-
-        this.dependencies = [PhysicalBody];
-    }
-
-    rayTest(from, to, callback) {
-        this.physics.rayTest(from, to, callback);
-    }
-
-    startup(entityManager, readyCallback, errorCallback) {
-        this.entityManager = entityManager;
-        this.physics = new PhysicsWorld(readyCallback);
-    }
-
-    shutdown(entityManager, readyCallback, errorCallback) {
-        try {
-            this.physics = null;
-            readyCallback();
-        } catch (e) {
-            errorCallback(e);
-        }
-    }
-
-    add(component, entity) {
-        const body = component.body;
-        body.__entity = entity;
-        this.physics.addBody(body);
-        //collisions
-        if (component.notifyCollision) {
-            const entityManager = this.entityManager;
-
-            body.onCollision(function (other) {
-                entityManager.sendEvent(entity, "collision", other.__entity);
-            });
-        }
-    }
-
-    remove(component) {
-        const body = component.body;
-        this.physics.removeBody(body);
-    }
-
-    update(timeDelta) {
-        const entityManager = this.entityManager;
-        let signals = entityManager.eventManager.signals;
-        //set position to physical body
-        entityManager.traverseEntities([PhysicalBody, Transform], function (physicalBody, transform) {
-            //copy position into body
-            const body = physicalBody.body;
-            body.position.copy(transform.position);
-            body.rotation.copy(transform.rotation);
-        });
-
-
-        const stepFinishedCallback = function () {
-            //set position from physical body
-            entityManager.traverseEntities([PhysicalBody, Transform], function (physicalBody, transform, entity) {
-                //copy position from body
-                const body = physicalBody.body;
-                const previousPosition = transform.previousPosition;
-                const currentPosition = transform.position;
-                if (previousPosition.x != currentPosition.x || previousPosition.y != currentPosition.y || previousPosition.z != currentPosition.z) {
-                    //write previous position is the current position is different from before
-                    previousPosition.copy(currentPosition);
-                }
-                currentPosition.copy(body.position);
-                //                transform.rotation.copy(body.rotation);
-            });
-        };
-        this.physics.simulate(timeDelta, stepFinishedCallback);
-    }
-}
-
-
-function collisionHandler() {
-}
-
-export default PhysicsSystem;

package/src/engine/ecs/systems/PropertySetSystem.js

@@ -1,18 +0,0 @@
-/**
- * Created by Alex on 13/04/2017.
- */
-
-
-import { System } from '../System.js';
-import PropertySet from '../components/PropertySet.js';
-
-class PropertySetSystem extends System {
-    constructor() {
-        super();
-
-        this.dependencies = [PropertySet];
-    }
-}
-
-
-export default PropertySetSystem;

package/src/engine/ecs/systems/SteeringSystem.js

@@ -1,171 +0,0 @@
-/**
- * User: Alex Goldring
- * Date: 1/6/2014
- * Time: 08:37
- */
-import { max2 } from "../../../core/math/max2.js";
-import { min2 } from "../../../core/math/min2.js";
-import { System } from '../System.js';
-import PhysicalBody from '../components/PhysicalBody.js';
-import Motion from '../components/Motion.js';
-import { Transform } from '../transform/Transform.js';
-import Steering, { SteeringEvents, SteeringFlags } from '../components/Steering.js';
-import Vector3 from "../../../core/geom/Vector3.js";
-import { alignToVector } from "../terrain/ecs/cling/ClingToTerrainSystem.js";
-import { v3_dot } from "../../../core/geom/vec3/v3_dot.js";
-import { solveQuadratic } from "../../../core/math/solveQuadratic.js";
-
-/**
- *
- * @param {Vector3} result
- * @param {Vector3} source
- * @param {Vector3} target
- * @param {Vector3} targetVelocity
- * @param {number} sourceSpeed
- * @return {boolean}
- */
-function computeInterceptPoint(result, source, target, targetVelocity, sourceSpeed) {
-    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 ts = [];
-    const root_count = solveQuadratic(ts, 0, a, b, c); // See quad(), below
-
-    // Find smallest positive solution
-    if (root_count > 0) {
-        const t0 = ts[0], t1 = ts[1];
-        let t = Math.min(t0, t1);
-        if (t < 0) t = Math.max(t0, t1);
-
-        if (t > 0) {
-            result.copy(targetVelocity).multiplyScalar(t).add(target);
-            return true;
-        }
-
-    }
-    return false;
-}
-
-class SteeringSystem extends System {
-    constructor() {
-        super();
-
-        this.dependencies = [Steering];
-    }
-
-    update(timeDelta) {
-        const entityManager = this.entityManager;
-
-        const ecd = entityManager.dataset;
-
-        if (ecd === null) {
-            return;
-        }
-
-        /**
-         *
-         * @param {number} entity
-         * @param {Steering} steering
-         * @param {Transform} transform
-         * @param {Vector3} velocity
-         */
-        function process(entity, steering, transform, velocity) {
-            if (!steering.getFlag(SteeringFlags.Active)) {
-                //steering is inactive
-                return;
-            }
-
-            const destination = steering.destination;
-
-            const delta = destination.clone().sub(transform.position);
-            delta.normalize();
-
-            const distanceWithError = computeDistanceWithError(transform.position, destination, steering.targetMargin);
-
-            if (distanceWithError > 0) {
-                //not at the target yet
-                const d = steering.maxSpeed;
-
-                const angularLimit = steering.rotationSpeed * timeDelta;
-
-                alignToVector(transform.rotation, delta, angularLimit, Vector3.up, Vector3.forward);
-
-                //compute forward vector
-                const v = Vector3.forward.clone();
-                v.applyQuaternion(transform.rotation);
-                v.normalize();
-
-
-                //check old velocity to avoid flying past target
-                if (distanceWithError < d * timeDelta) {
-                    const distance = delta.length();
-                    const adjustedVelocity = min2(d, distance / timeDelta);
-                    v.multiplyScalar(adjustedVelocity);
-                } else {
-                    v.multiplyScalar(d);
-                }
-
-                velocity.copy(v);
-
-            } else {
-                //goal is reached, de-activate
-                steering.clearFlag(SteeringFlags.Active);
-
-                //drop velocity
-                velocity.set(0, 0, 0);
-
-                //dispatch
-                ecd.sendEvent(entity, SteeringEvents.DestinationReached, steering);
-            }
-        }
-
-        //Make sure physical bodies exist
-        if (ecd.isComponentTypeRegistered(PhysicalBody)) {
-
-            ecd.traverseEntities([Steering, PhysicalBody, Transform], function (steering, physicalBody, transform, entity) {
-
-                const body = physicalBody.body;
-
-                process(entity, steering, transform, body.linearVelocity);
-
-            });
-
-        }
-
-        ecd.traverseEntities([Steering, Motion, Transform], function (steering, motion, transform, entity) {
-            process(entity, steering, transform, motion.velocity);
-        });
-    }
-}
-
-/**
- *
- * @param {Vector3} v0
- * @param {Vector3} v1
- * @param {Vector3} error
- * @return {number}
- */
-function computeDistanceWithError(v0, v1, error) {
-    const absDelta = v0.clone().sub(v1).abs();
-
-    absDelta.set(
-        max2(absDelta.x - error.x, 0),
-        max2(absDelta.y - error.y, 0),
-        max2(absDelta.z - error.z, 0)
-    );
-
-    return absDelta.length();
-}
-
-export default SteeringSystem;

package/src/engine/ecs/systems/TagSystem.d.ts

@@ -1,5 +0,0 @@
-import {System} from "../System";
-
-export class TagSystem extends System {
-
-}

package/src/engine/ecs/systems/TagSystem.js

@@ -1,31 +0,0 @@
-/**
- * Created by Alex on 23/04/2014.
- */
-import { System } from '../System.js';
-import Tag from '../components/Tag.js';
-
-
-class TagSystem extends System {
-
-    dependencies = [Tag];
-
-    /**
-     *
-     * @param {string} tag
-     * @param {EntityComponentDataset} ecd
-     * @returns  {number[]}
-     */
-    static find_entities_with_tag(tag, ecd) {
-        const r = [];
-        ecd.traverseComponents(Tag, (t, e) => {
-            if (t.contains(tag)) {
-                r.push(e);
-            }
-        });
-
-        return r;
-    }
-}
-
-
-export default TagSystem;

package/src/engine/graphics/texture/sampler/bicubic.js

@@ -1,59 +0,0 @@
-/**
- * @see https://github.com/hughsk/bicubic/blob/master/index.js
- * @param {number} xf
- * @param {number} yf
- * @param {number} p00
- * @param {number} p01
- * @param {number} p02
- * @param {number} p03
- * @param {number} p10
- * @param {number} p11
- * @param {number} p12
- * @param {number} p13
- * @param {number} p20
- * @param {number} p21
- * @param {number} p22
- * @param {number} p23
- * @param {number} p30
- * @param {number} p31
- * @param {number} p32
- * @param {number} p33
- * @returns {number}
- */
-export function bicubic(
-    xf, yf
-    , p00, p01, p02, p03
-    , p10, p11, p12, p13
-    , p20, p21, p22, p23
-    , p30, p31, p32, p33
-) {
-    var yf2 = yf * yf
-    var xf2 = xf * xf
-    var xf3 = xf * xf2
-
-    var x00 = p03 - p02 - p00 + p01
-    var x01 = p00 - p01 - x00
-    var x02 = p02 - p00
-    var x0 = x00 * xf3 + x01 * xf2 + x02 * xf + p01
-
-    var x10 = p13 - p12 - p10 + p11
-    var x11 = p10 - p11 - x10
-    var x12 = p12 - p10
-    var x1 = x10 * xf3 + x11 * xf2 + x12 * xf + p11
-
-    var x20 = p23 - p22 - p20 + p21
-    var x21 = p20 - p21 - x20
-    var x22 = p22 - p20
-    var x2 = x20 * xf3 + x21 * xf2 + x22 * xf + p21
-
-    var x30 = p33 - p32 - p30 + p31
-    var x31 = p30 - p31 - x30
-    var x32 = p32 - p30
-    var x3 = x30 * xf3 + x31 * xf2 + x32 * xf + p31
-
-    var y0 = x3 - x2 - x0 + x1
-    var y1 = x0 - x1 - y0
-    var y2 = x2 - x0
-
-    return y0 * yf * yf2 + y1 * yf2 + y2 * yf + x1
-}

package/src/engine/graphics/texture/sampler/bicubic.spec.js

@@ -1,13 +0,0 @@
-import { bicubic } from "./bicubic.js";
-
-test("sanity", () => {
-
-    expect(bicubic(
-        0.5, 0.5,
-        3, 3, 3, 3,
-        3, 3, 3, 3,
-        3, 3, 3, 3,
-        3, 3, 3, 3,
-    )).toBeCloseTo(3);
-
-});

package/src/engine/navigation/ecs/components/computeNonuniformCatmullRomSplineSample.js

@@ -1,242 +0,0 @@
-/**
- *
- * @param {number[]} p0
- * @param {number[]} p1
- * @param {number} dimensions
- * @param {number} half_alpha between 0..0.5
- * @returns {number}
- */
-function getT(p0, p1, dimensions, half_alpha) {
-    let a = 0;
-
-    for (let i = 0; i < dimensions; i++) {
-        const dx = p0[i] - p1[i];
-
-        a += dx * dx;
-    }
-
-    return Math.pow(a, half_alpha);
-}
-
-/**
- * Based on wiki article: https://en.wikipedia.org/wiki/Centripetal_Catmull%E2%80%93Rom_spline#Code_example_in_Python
- * @param {number[]} result
- * @param {number[]} p0 spline point 0
- * @param {number[]} p1 spline point 1
- * @param {number[]} p2 spline point 2
- * @param {number[]} p3 spline point 3
- * @param {number} dimensions number of dimensions in the input and output vectors
- * @param {number} f between 0..1
- * @param {number} alpha between 0..1
- */
-export function computeNonuniformCatmullRomSplineSample(result, p0, p1, p2, p3, dimensions, f, alpha) {
-    const half_alpha = alpha * 0.5;
-
-    // calculate T
-    const t0 = 0;
-    let t_01 = getT(p0, p1, dimensions, half_alpha);
-    let t_02 = getT(p1, p2, dimensions, half_alpha);
-    let t_03 = getT(p2, p3, dimensions, half_alpha);
-
-    // safety check for repeated points, to prevent division by 0
-    if (t_01 < 1e-4) {
-        t_01 = 1;
-    }
-    if (t_02 < 1e-4) {
-        t_02 = t_01;
-    }
-    if (t_03 < 1e-4) {
-        t_03 = t_02;
-    }
-
-    const t1 = t_01 + t0;
-    const t2 = t_02 + t1;
-    const t3 = t_03 + t2;
-
-    /**
-     * Interpolation between points 1 and 2
-     * @type {number}
-     */
-    const t = t1 * (1 - f) + t2 * f;
-
-    /*
-            Vector2 A1 = (t1-t)/(t1-t0)*p0 + (t-t0)/(t1-t0)*p1;
-		    Vector2 A2 = (t2-t)/(t2-t1)*p1 + (t-t1)/(t2-t1)*p2;
-		    Vector2 A3 = (t3-t)/(t3-t2)*p2 + (t-t2)/(t3-t2)*p3;
-
-		    Vector2 B1 = (t2-t)/(t2-t0)*A1 + (t-t0)/(t2-t0)*A2;
-		    Vector2 B2 = (t3-t)/(t3-t1)*A2 + (t-t1)/(t3-t1)*A3;
-
-		    Vector2 C = (t2-t)/(t2-t1)*B1 + (t-t1)/(t2-t1)*B2;
-     */
-
-    const d_t1_t0 = t1 - t0;
-
-    const m_A1_0 = (t1 - t) / d_t1_t0;
-    const m_A1_1 = (t - t0) / d_t1_t0;
-
-    const d_t2_t1 = t2 - t1;
-
-    const m_A2_0 = (t2 - t) / d_t2_t1;
-
-    const d_t_t1 = t - t1;
-
-    const m_A2_1 = d_t_t1 / d_t2_t1;
-
-    const d_t3_t2 = t3 - t2;
-
-    const d_t3_t = t3 - t;
-
-    const m_A3_0 = d_t3_t / d_t3_t2;
-    const m_A3_1 = (t - t2) / d_t3_t2;
-
-    const d_t2_t0 = t2 - t0;
-
-    const m_B1_0 = (t2 - t) / d_t2_t0;
-    const m_B1_1 = (t - t0) / d_t2_t0;
-
-    const d_t3_t1 = t3 - t1;
-
-    const m_B2_0 = d_t3_t / d_t3_t1;
-    const m_B2_1 = d_t_t1 / d_t3_t1;
-
-    const m_C_0 = (t2 - t) / d_t2_t1;
-    const m_C_1 = d_t_t1 / d_t2_t1;
-
-    for (let i = 0; i < dimensions; i++) {
-        // read vector values for the dimension
-        const v0 = p0[i];
-        const v1 = p1[i];
-        const v2 = p2[i];
-        const v3 = p3[i];
-
-        // compute resulting value in this dimension
-        const A1 = m_A1_0 * v0 + m_A1_1 * v1;
-        const A2 = m_A2_0 * v1 + m_A2_1 * v2;
-        const A3 = m_A3_0 * v2 + m_A3_1 * v3;
-
-        const B1 = m_B1_0 * A1 + m_B1_1 * A2;
-        const B2 = m_B2_0 * A2 + m_B2_1 * A3;
-
-        const C = m_C_0 * B1 + m_C_1 * B2;
-
-        result[i] = C;
-    }
-}
-
-
-/**
- * Alpha assumed to be 0.5
- * @param {number} f
- * @param {number} p0
- * @param {number} p1
- * @param {number} p2
- * @param {number} p3
- * @returns {number}
- */
-function catmullrom_1d(f, p0, p1, p2, p3) {
-    const half_alpha = 0.25;
-
-    /**
-     *
-     * @param {number} p0
-     * @param {number} p1
-     * @param {number} half_alpha between 0..0.5
-     * @returns {number}
-     */
-    function getT(p0, p1, half_alpha) {
-        const dx = p0 - p1;
-
-        const a = dx * dx;
-
-        return Math.pow(a, half_alpha);
-    }
-
-    // calculate T
-    const t0 = 0;
-    let t_01 = getT(p0, p1, half_alpha);
-    let t_02 = getT(p1, p2, half_alpha);
-    let t_03 = getT(p2, p3, half_alpha);
-
-    // safety check for repeated points, to prevent division by 0
-    if (t_01 < 1e-5) {
-        t_01 = 1;
-    }
-    if (t_02 < 1e-5) {
-        t_02 = t_01;
-    }
-    if (t_03 < 1e-5) {
-        t_03 = t_02;
-    }
-
-    const t1 = t_01 + t0;
-    const t2 = t_02 + t1;
-    const t3 = t_03 + t2;
-
-    /**
-     * Interpolation between points 1 and 2
-     * @type {number}
-     */
-    const t = t1 * (1 - f) + t2 * f;
-
-    /*
-            Vector2 A1 = (t1-t)/(t1-t0)*p0 + (t-t0)/(t1-t0)*p1;
-		    Vector2 A2 = (t2-t)/(t2-t1)*p1 + (t-t1)/(t2-t1)*p2;
-		    Vector2 A3 = (t3-t)/(t3-t2)*p2 + (t-t2)/(t3-t2)*p3;
-
-		    Vector2 B1 = (t2-t)/(t2-t0)*A1 + (t-t0)/(t2-t0)*A2;
-		    Vector2 B2 = (t3-t)/(t3-t1)*A2 + (t-t1)/(t3-t1)*A3;
-
-		    Vector2 C = (t2-t)/(t2-t1)*B1 + (t-t1)/(t2-t1)*B2;
-     */
-
-    const d_t1_t0 = t1 - t0;
-
-    const m_A1_0 = (t1 - t) / d_t1_t0;
-    const m_A1_1 = (t - t0) / d_t1_t0;
-
-    const d_t2_t1 = t2 - t1;
-
-    const m_A2_0 = (t2 - t) / d_t2_t1;
-
-    const d_t_t1 = t - t1;
-
-    const m_A2_1 = d_t_t1 / d_t2_t1;
-
-    const d_t3_t2 = t3 - t2;
-
-    const d_t3_t = t3 - t;
-
-    const m_A3_0 = d_t3_t / d_t3_t2;
-    const m_A3_1 = (t - t2) / d_t3_t2;
-
-    const d_t2_t0 = t2 - t0;
-
-    const m_B1_0 = (t2 - t) / d_t2_t0;
-    const m_B1_1 = (t - t0) / d_t2_t0;
-
-    const d_t3_t1 = t3 - t1;
-
-    const m_B2_0 = d_t3_t / d_t3_t1;
-    const m_B2_1 = d_t_t1 / d_t3_t1;
-
-    const m_C_0 = (t2 - t) / d_t2_t1;
-    const m_C_1 = d_t_t1 / d_t2_t1;
-
-    // read vector values for the dimension
-    const v0 = p0;
-    const v1 = p1;
-    const v2 = p2;
-    const v3 = p3;
-
-    // compute resulting value in this dimension
-    const A1 = m_A1_0 * v0 + m_A1_1 * v1;
-    const A2 = m_A2_0 * v1 + m_A2_1 * v2;
-    const A3 = m_A3_0 * v2 + m_A3_1 * v3;
-
-    const B1 = m_B1_0 * A1 + m_B1_1 * A2;
-    const B2 = m_B2_0 * A2 + m_B2_1 * A3;
-
-    return m_C_0 * B1 + m_C_1 * B2;
-
-}