@woosh/meep-engine 2.75.8 → 2.75.9

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

@@ -0,0 +1,81 @@
+import { BlendingType } from "./BlendingType.js";
+
+/**
+ *
+ * @param {number[]} source
+ * @param {number[]} destination
+ * @param {Array} result
+ */
+function blendFunctionNormal(source, destination, result) {
+
+    const a1 = source[3] / 255;
+    const a0 = destination[3] / 255;
+
+    result[0] = source[0] * a1 + destination[0] * (1 - a1);
+    result[1] = source[1] * a1 + destination[1] * (1 - a1);
+    result[2] = source[2] * a1 + destination[2] * (1 - a1);
+    result[3] = (a1 + a0 * (1 - a1)) * 255;
+}
+
+/**
+ * Assumes both samplers are RGBA uint8 with values 0-255
+ * @param {Sampler2D} destination
+ * @param {Sampler2D} source
+ * @param {number} sourceX
+ * @param {number} sourceY
+ * @param {number} destinationX
+ * @param {number} destinationY
+ * @param {number} width
+ * @param {number} height
+ * @param {BlendingType} [blendMode]
+ */
+export function sampler2d_paint(
+    destination,
+    source,
+    sourceX, sourceY,
+    destinationX, destinationY,
+    width, height,
+    blendMode = BlendingType.Normal
+) {
+
+    let blendFunction;
+    if (blendMode === BlendingType.Normal) {
+        blendFunction = blendFunctionNormal;
+    } else {
+        throw new Error(`Unsupported blendType(=${blendMode})`);
+    }
+
+    const _w = Math.min(width, source.width - sourceX, destination.width - destinationX);
+    const _h = Math.min(height, source.height - sourceY, destination.height - destinationY);
+
+    const _x0 = Math.max(0, -destinationX);
+    const _y0 = Math.max(0, -destinationY);
+
+    const c0 = [0, 0, 0, 255];
+    const c1 = [0, 0, 0, 255];
+
+    const c3 = [];
+
+    let x, y;
+
+    for (y = _y0; y < _h; y++) {
+        for (x = _x0; x < _w; x++) {
+            const d_x = Math.round(x + destinationX);
+            const d_y = Math.round(y + destinationY);
+
+            destination.read(d_x, d_y, c0);
+
+            const s_x = Math.round(x + sourceY);
+            const s_y = Math.round(y + sourceY);
+
+            source.read(s_x, s_y, c1);
+
+            blendFunction(c1, c0, c3);
+
+            destination.set(d_x, d_y, c3);
+
+        }
+    }
+
+
+}

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

@@ -0,0 +1,50 @@
+import { assert } from "../../../../core/assert.js";
+
+/**
+ * Copy a patch from another sampler with the same itemSize
+ * @param {Sampler2D} destination
+ * @param {Sampler2D} source where to copy from
+ * @param {Number} sourceX where to start reading from, X coordinate
+ * @param {Number} sourceY where to start reading from, X coordinate
+ * @param {Number} destinationX where to start writing to, X coordinate
+ * @param {Number} destinationY where to start writing to, X coordinate
+ * @param {Number} width size of the patch that is to be copied
+ * @param {Number} height size of the patch that is to be copied
+ */
+export function sampler2d_sub_copy_same_item_size(destination, source, sourceX, sourceY, destinationX, destinationY, width, height) {
+    const itemSize = destination.itemSize;
+    const sItemSize = source.itemSize;
+
+    assert.equal(sItemSize, sItemSize, `source.itemSize(=${sItemSize}) != destination.itemSize(=${itemSize})`);
+
+    const _w = Math.min(width, source.width - sourceX, destination.width - destinationX);
+    const _h = Math.min(height, source.height - sourceY, destination.height - destinationY);
+
+
+    const dRowSize = itemSize * destination.width;
+    const sRowSize = itemSize * source.width;
+
+    const sData = source.data;
+    const dData = destination.data;
+
+    const patchRowSize = _w * itemSize;
+
+    let y, i;
+
+    for (y = 0; y < _h; y++) {
+        const dA = (y + destinationY) * dRowSize;
+        const sA = (y + sourceY) * sRowSize;
+
+        const dOffset = dA + destinationX * itemSize;
+        const sOffset = sA + sourceX * itemSize;
+
+        for (i = 0; i < patchRowSize; i++) {
+
+            dData[dOffset + i] = sData[sOffset + i];
+
+        }
+    }
+
+    // update destination version
+    destination.version++;
+}

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

@@ -3,23 +3,24 @@
  */
 
 
-import Vector3 from "../../../../core/geom/Vector3.js";
-
 import { CatmullRomCurve3 } from "three";
-import { clamp } from "../../../../core/math/clamp.js";
 import { assert } from "../../../../core/assert.js";
-import { RowFirstTableSpec } from "../../../../core/collection/table/RowFirstTableSpec.js";
 import { BinaryDataType } from "../../../../core/binary/type/BinaryDataType.js";
 import { RowFirstTable } from "../../../../core/collection/table/RowFirstTable.js";
-import { min2 } from "../../../../core/math/min2.js";
-import { computeNonuniformCatmullRomSplineSample } from "./computeNonuniformCatmullRomSplineSample.js";
-import { InterpolationType } from "./InterpolationType.js";
-import { v3_distance } from "../../../../core/geom/vec3/v3_distance.js";
+import { RowFirstTableSpec } from "../../../../core/collection/table/RowFirstTableSpec.js";
 import {
     line3_computeSegmentPointDistance_sqr
 } from "../../../../core/geom/3d/line/line3_computeSegmentPointDistance_sqr.js";
-import { VertexDataSpec } from "../../../graphics/geometry/VertexDataSpec.js";
+import { v3_distance } from "../../../../core/geom/vec3/v3_distance.js";
+import Vector3 from "../../../../core/geom/Vector3.js";
+import { clamp } from "../../../../core/math/clamp.js";
+import { min2 } from "../../../../core/math/min2.js";
+import {
+    computeNonuniformCatmullRomSplineSample
+} from "../../../../core/math/spline/computeNonuniformCatmullRomSplineSample.js";
 import { AttributeSpec } from "../../../graphics/geometry/AttributeSpec.js";
+import { VertexDataSpec } from "../../../graphics/geometry/VertexDataSpec.js";
+import { InterpolationType } from "./InterpolationType.js";
 
 const v3_a = new Vector3();
 const v3_b = new Vector3();

package/src/engine/physics/computeInterceptPoint.js

@@ -0,0 +1,44 @@
+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;
+}

package/src/engine/plugin/EnginePlugin.js

@@ -1,5 +1,5 @@
-import { BaseProcess } from "../../core/process/BaseProcess.js";
 import { assert } from "../../core/assert.js";
+import { BaseProcess } from "../../core/process/BaseProcess.js";
 
 export class EnginePlugin extends BaseProcess {
 
@@ -16,7 +16,6 @@ export class EnginePlugin extends BaseProcess {
      */
     engine = null;
 
-
     attach() {
         /**
          * Must be unique for each plugin

package/src/engine/ecs/components/AlignToVelocity.js

@@ -1,9 +0,0 @@
-/**
- * Created by Alex on 19/03/2015.
- */
-
-function AlignToVelocity(options) {
-    this.angularSpeed = options !== void 0 ? options : Number.POSITIVE_INFINITY;
-}
-
-export default AlignToVelocity;

package/src/engine/ecs/components/CharacterController.js

@@ -1,31 +0,0 @@
-/**
- * FPS-style character controller
- * @author Alex Goldring
- * @copyright Alex Goldring 7/4/2014
- */
-class CharacterController {
-    height = 4;
-    onSolidSurface = false;
-    lockedTimeout = 0;
-    //
-    forward = false;
-    back = false;
-    left = false;
-    right = false;
-    sprinting = false;
-    attacking = false;
-    aim = null;
-    //
-    movementSpeed = 1;
-    sprintingMultiplier = 1;
-
-    constructor({
-                    movementSpeed = 1,
-                    sprintingMultiplier = 1.2
-                } = {}) {
-        this.movementSpeed = movementSpeed;
-        this.sprintingMultiplier = sprintingMultiplier;
-    }
-}
-
-export default CharacterController;

package/src/engine/ecs/components/PhysicalBody.js

@@ -1,51 +0,0 @@
-/**
- * Created by Alex on 01/04/2014.
- */
-import Vector3 from "../../../core/geom/Vector3.js";
-
-let Shape = function () {
-    this.type = void 0;
-};
-const BoxShape = function (options) {
-    this.type = "box";
-    const s = options.size;
-    this.size = new Vector3(s.x, s.y, s.z);
-};
-const SphereShape = function (options) {
-    this.type = "sphere";
-    this.radius = options.radius;
-};
-
-function makeShape(desc) {
-    switch (desc.type) {
-        case "box":
-            return new BoxShape(desc);
-        case "sphere":
-            return new SphereShape(desc);
-        default:
-            return desc;
-    }
-}
-
-function PhysicalBody(options) {
-    this.shape = makeShape(options.shape);
-    this.velocity = new Vector3();
-    this.linearDamping = options.linearDamping !== void 0 ? options.linearDamping : 0;
-    this.angularVelocity = new Vector3();
-    this.rotationAxis = new Vector3();
-    //this.friction = options.friction !== void 0 ? options.friction : 0;
-    if (options.rotationAxis !== void 0) {
-        this.rotationAxis.copy(options.rotationAxis);
-    }
-    this.mass = options.mass !== void 0 ? options.mass : 0;
-    this.collisionResponse = options.collisionResponse !== void 0 ? options.collisionResponse : true;
-    //
-    if (options.velocity !== void 0) {
-        this.velocity.copy(options.velocity);
-    }
-    if (options.angularVelocity !== void 0) {
-        this.angularVelocity.copy(options.angularVelocity);
-    }
-}
-
-export default PhysicalBody;

package/src/engine/ecs/components/Steering.js

@@ -1,111 +0,0 @@
-/**
- * User: Alex Goldring
- * Date: 1/6/2014
- * Time: 08:37
- */
-
-
-import Vector3 from '../../../core/geom/Vector3.js';
-
-/**
- * @readonly
- * @enum {String}
- */
-export const SteeringEvents = {
-    DestinationReached: "steeringDestinationReached"
-};
-
-/**
- * @readonly
- * @enum {number}
- */
-export const SteeringFlags = {
-    Active: 1
-};
-
-class Steering {
-    constructor() {
-        this.maxSpeed = 1;
-
-        /**
-         * @readonly
-         * @type {Vector3}
-         */
-        this.destination = new Vector3();
-
-        this.targetMargin = new Vector3(0.001, 0.001, 0.001);
-
-        this.rotationSpeed = Math.PI / 2;
-
-        /**
-         *
-         * @type {number}
-         */
-        this.flags = 0;
-    }
-
-    /**
-     *
-     * @param {number|SteeringFlags} flag
-     * @returns {void}
-     */
-    setFlag(flag) {
-        this.flags |= flag;
-    }
-
-    /**
-     *
-     * @param {number|SteeringFlags} flag
-     * @returns {void}
-     */
-    clearFlag(flag) {
-        this.flags &= ~flag;
-    }
-
-    /**
-     *
-     * @param {number|SteeringFlags} flag
-     * @param {boolean} value
-     */
-    writeFlag(flag, value) {
-        if (value) {
-            this.setFlag(flag);
-        } else {
-            this.clearFlag(flag);
-        }
-    }
-
-    /**
-     *
-     * @param {number|SteeringFlags} flag
-     * @returns {boolean}
-     */
-    getFlag(flag) {
-        return (this.flags & flag) === flag;
-    }
-
-    fromJSON(json) {
-        if (json.maxSpeed !== undefined) {
-            this.maxSpeed = json.maxSpeed;
-        }
-        if (json.rotationSpeed !== undefined) {
-            this.rotationSpeed = json.rotationSpeed;
-        }
-        if (json.targetMargin !== undefined) {
-            this.targetMargin.fromJSON(json.targetMargin);
-        }
-    }
-
-    toJSON() {
-        return {
-            maxSpeed: this.maxSpeed,
-            rotationSpeed: this.rotationSpeed,
-            targetMargin: this.targetMargin.toJSON()
-        };
-    }
-}
-
-Steering.typeName = "Steering";
-
-export default Steering;
-

package/src/engine/ecs/components/SteeringSerializationAdapter.js

@@ -1,34 +0,0 @@
-import { BinaryClassSerializationAdapter } from "../storage/binary/BinaryClassSerializationAdapter.js";
-import Steering from "./Steering.js";
-
-export class SteeringSerializationAdapter extends BinaryClassSerializationAdapter {
-
-    klass = Steering;
-    version = 0;
-
-    /**
-     *
-     * @param {BinaryBuffer} buffer
-     * @param {Steering} value
-     */
-    serialize(buffer, value) {
-        buffer.writeFloat32(value.maxSpeed);
-        buffer.writeFloat32(value.rotationSpeed);
-
-        value.destination.toBinaryBufferFloat32(buffer);
-        value.targetMargin.toBinaryBufferFloat32_EqualityEncoded(buffer);
-    }
-
-    /**
-     *
-     * @param {BinaryBuffer} buffer
-     * @param {Steering} value
-     */
-    deserialize(buffer, value) {
-        value.maxSpeed = buffer.readFloat32();
-        value.rotationSpeed = buffer.readFloat32();
-
-        value.destination.fromBinaryBufferFloat32(buffer);
-        value.targetMargin.fromBinaryBufferFloat32_EqualityEncoded(buffer);
-    }
-}

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

@@ -1,51 +0,0 @@
-/**
- * Created by Alex on 19/03/2015.
- */
-import { System } from '../System.js';
-import AlignToVelocity from '../components/AlignToVelocity.js';
-import { Transform } from '../transform/Transform.js';
-import Motion from '../components/Motion.js';
-import Vector3 from "../../../core/geom/Vector3.js";
-
-
-class AlignToVelocitySystem extends System {
-    constructor() {
-        super();
-
-        this.dependencies = [AlignToVelocity];
-    }
-
-    add(aabb, entity) {
-
-    }
-
-    remove(component) {
-    }
-
-    update(timeDelta) {
-        const em = this.entityManager;
-        const MotionType = em.getOwnerSystemIdByComponentClass(Motion);
-        const PhysicsBodyType = em.getOwnerSystemIdByComponentClass(PhysicsBody);
-        const velocity = new Vector3();
-        em.traverseEntities([AlignToVelocity, Transform], function (align, transform, entity) {
-            //find velocity
-            const motion = em.getComponentByType(entity, MotionType);
-            if (motion !== null) {
-                velocity.copy(motion.velocity);
-            } else {
-                const body = em.getComponentByType(entity, PhysicsBodyType);
-                if (body !== null) {
-                    velocity.copy(body.velocity);
-                } else {
-                    return;
-                }
-            }
-            const delta = velocity.sub(transform.position);
-            //set transform rotation based on velocity
-            Transform.adjustRotation(transform.rotation, delta, align.angularSpeed * timeDelta);
-        });
-    }
-}
-
-
-export default AlignToVelocitySystem;

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

@@ -1,134 +0,0 @@
-/**
- * User: Alex Goldring
- * Date: 7/4/2014
- * Time: 09:17
- */
-import { System } from '../System.js';
-import CharacterController from '../components/CharacterController.js';
-import { Transform } from '../transform/Transform.js';
-import PhysicalBody from '../components/PhysicalBody.js';
-import Vector3 from "../../../core/geom/Vector3.js";
-
-
-class CharacterControlSystem extends System {
-    constructor() {
-        super();
-        //
-        this.entityManager = null;
-
-        this.dependencies = [CharacterController];
-    }
-
-    remove(component) {
-    }
-
-    add(component) {
-    }
-
-    update(timeDelta) {
-        const entityManager = this.entityManager;
-        const PhysicsSystemType = entityManager.getSystemIdByComponentClass(PhysicalBody);
-        const physicsSystem = entityManager.systems[PhysicsSystemType];
-        entityManager.traverseEntities([CharacterController, PhysicalBody, Transform], function (controller, physicalBody, transform) {
-            if (controller.lockedTimeout > 0) {
-                //controlls are locked - can't do anything
-                controller.lockedTimeout -= timeDelta;
-                if (controller.lockedTieout < 0) {
-                    controller.lockedTimeout = 0;
-                }
-            } else {
-                //controls aren't locked
-                setOnSolidSurface(transform, controller, physicsSystem);
-                updatePosition(controller, physicalBody.body, transform, physicsSystem);
-                if (controller.attacking) {
-                    console.log("pow!");
-                }
-            }
-        });
-
-    }
-}
-
-
-function setOnSolidSurface(transform, controller, physicsSystem) {
-    const from = transform.position.clone();
-    const to = from.clone().add(new Vector3(0, -100, 0));
-    physicsSystem.rayTest(from, to, function (success, point) {
-        if (success) {
-            const v = new Vector3();
-            v.copy(point);
-            const number = v.distanceTo(from);
-            if (number <= controller.height / 2 + 0.06) {
-                controller.onSolidSurface = true;
-            } else {
-                controller.onSolidSurface = false;
-            }
-        } else {
-            controller.onSolidSurface = false;
-        }
-    });
-}
-
-function updatePosition(controls, body, transform) {
-    let z = 0;
-    let x = 0;
-    if (controls.forward) {
-        z -= 1;
-    }
-    if (controls.back) {
-        z += 1;
-    }
-    if (controls.right) {
-        x += 1;
-    }
-    if (controls.left) {
-        x -= 1;
-    }
-    const moving = (x !== 0 || z !== 0);
-    let vector;
-    const notTakingOff = body.linearVelocity.y <= 0.00001;
-    if (controls.onSolidSurface && notTakingOff) {
-        if (moving) {
-            const y = body.linearVelocity.y;
-            //obtain facing direction
-            const euler = new THREE.Euler();
-            euler.setFromQuaternion(transform.rotation);
-            //vector pointing in the direction of travel
-            vector = new THREE.Vector3(x, 0, z);
-            const rotationMatrix = new THREE.Matrix4().makeRotationFromQuaternion(transform.rotation);
-            vector.applyMatrix4(rotationMatrix);
-            vector.y = y;
-            //enforce movement speed
-            let scalar = controls.movementSpeed;
-            if (controls.sprinting) {
-                //apply sprinting multiplier
-                scalar *= controls.sprintingMultiplier;
-            }
-            //scale facing direction vector by the movement speed
-            vector.normalize().multiplyScalar(scalar);
-            //write the property
-            body.linearVelocity.copy(vector);
-        } else {
-            //when on ground and not moving - stand still
-            const v = body.linearVelocity;
-            if (v.x !== 0 || v.z !== 0) {
-                v.set(0, 0, 0);
-            }
-        }
-        if (controls.jump) {
-            //perform jump
-            const up = new Vector3(0, 1, 0);
-            const magnitude = (8 * body.mass);
-            const force = up.scale(magnitude);
-            body.applyCentralImpulse(force);
-
-            controls.onSolidSurface = false;  //prevent further jumps
-            controls.lockedTimeout = 0.1; //lock controls to prevent some race conditions
-        }
-    }
-
-    //set jump to false
-    controls.jump = false;
-}
-
-export default CharacterControlSystem;