@woosh/meep-engine 2.38.2 → 2.39.1

package/core/geom/Quaternion.js

@@ -26,6 +26,76 @@ function normalizeAngle(v) {
     return v % PI2;
 }
 
+/**
+ *
+ * @param {number[]|Float32Array} out
+ * @param {number} fx
+ * @param {number} fy
+ * @param {number} fz
+ * @param {number} ux
+ * @param {number} uy
+ * @param {number} uz
+ */
+export function quat_array_from_look(out, fx, fy, fz, ux, uy, uz) {
+    forward.set(fx, fy, fz);
+    forward.normalize();
+
+    right._crossVectors(ux, uy, uz, forward.x, forward.y, forward.z);
+    right.normalize();
+
+    up.crossVectors(forward, right);
+
+    var m00 = right.x;
+    var m01 = right.y;
+    var m02 = right.z;
+    var m10 = up.x;
+    var m11 = up.y;
+    var m12 = up.z;
+    var m20 = forward.x;
+    var m21 = forward.y;
+    var m22 = forward.z;
+
+
+    const num8 = (m00 + m11) + m22;
+
+    let _x, _y, _z, _w;
+
+    if (num8 > 0) {
+        let num = Math.sqrt(num8 + 1);
+        _w = num * 0.5;
+        num = 0.5 / num;
+        _x = (m12 - m21) * num;
+        _y = (m20 - m02) * num;
+        _z = (m01 - m10) * num;
+    } else if ((m00 >= m11) && (m00 >= m22)) {
+        var num7 = Math.sqrt(((1 + m00) - m11) - m22);
+        var num4 = 0.5 / num7;
+        _x = 0.5 * num7;
+        _y = (m01 + m10) * num4;
+        _z = (m02 + m20) * num4;
+        _w = (m12 - m21) * num4;
+    } else if (m11 > m22) {
+        var num6 = Math.sqrt(((1 + m11) - m00) - m22);
+        var num3 = 0.5 / num6;
+        _x = (m10 + m01) * num3;
+        _y = 0.5 * num6;
+        _z = (m21 + m12) * num3;
+        _w = (m20 - m02) * num3;
+    } else {
+        var num5 = Math.sqrt(((1 + m22) - m00) - m11);
+        var num2 = 0.5 / num5;
+        _x = (m20 + m02) * num2;
+        _y = (m21 + m12) * num2;
+        _z = 0.5 * num5;
+        _w = (m01 - m10) * num2;
+    }
+
+    out[0] = _x;
+    out[1] = _y;
+    out[2] = _z;
+    out[3] = _w;
+}
+
 /**
  * just in case you need that function also
  * @param {Vector3} axis

package/core/geom/Vector2.js

@@ -662,6 +662,23 @@ export function v2_angleBetween(x0, y0, x1, y1) {
     return Math.acos(theta);
 }
 
+/**
+ * https://math.stackexchange.com/questions/1596513/find-the-bearing-angle-between-two-points-in-a-2d-space
+ * @param {number} x0
+ * @param {number} y0
+ * @param {number} x1
+ * @param {number} y1
+ * @returns {number}
+ */
+export function v2_bearing_angle_towards(x0, y0, x1, y1) {
+    const TWOPI = 6.2831853071795865;
+    // if (a1 = b1 and a2 = b2) throw an error
+    let theta = Math.atan2(x1 - x0, y0 - y1);
+    if (theta < 0.0)
+        theta += TWOPI;
+    return theta;
+}
+
 /**
  *
  * @param {number} x0

package/core/geom/v3_angle_between.js

@@ -13,6 +13,22 @@ import { clamp } from "../math/clamp.js";
  * @returns {number}
  */
 export function v3_angle_between(x0, y0, z0, x1, y1, z1) {
+    const theta = v3_angle_cos_between(x0, y0, z0, x1, y1, z1);
+
+    return Math.acos(theta);
+}
+
+/**
+ *
+ * @param {number} x0
+ * @param {number} y0
+ * @param {number} z0
+ * @param {number} x1
+ * @param {number} y1
+ * @param {number} z1
+ * @returns {number}
+ */
+export function v3_angle_cos_between(x0, y0, z0, x1, y1, z1){
     const d = v3_dot(x0, y0, z0, x1, y1, z1);
 
     const magnitude_0 = v3_length(x0, y0, z0);
@@ -25,9 +41,7 @@ export function v3_angle_between(x0, y0, z0, x1, y1, z1) {
         return 0;
     }
 
-    const theta = clamp(d / l, -1, 1);
-
-    return Math.acos(theta);
+    return clamp(d / l, -1, 1);
 }
 
 /**

package/engine/ecs/EntityBuilder.d.ts

@@ -6,7 +6,7 @@ interface Type<T> extends Function {
 
 export default class EntityBuilder {
     public entity: number;
-    
+
     add<T>(component: T): EntityBuilder
 
     removeComponent<T>(componentType: Type<T>): T | null
@@ -15,6 +15,8 @@ export default class EntityBuilder {
 
     getComponentSafe<T>(componentType: Type<T>): T
 
+    hasComponent<T>(componentType: Type<T>): boolean
+
     build(dataset: EntityComponentDataset): number
 
     destroy(): boolean

package/engine/ecs/EntityBuilder.js

@@ -132,7 +132,7 @@ class EntityBuilder {
             throw new Error("Can not add " + componentInstance + " to EntityBuilder");
         }
 
-        assert.notOk(this.getComponent(Object.getPrototypeOf(componentInstance).constructor) !== null, 'Component of this type already exists');
+        assert.notOk(this.hasComponent(Object.getPrototypeOf(componentInstance).constructor) , 'Component of this type already exists');
 
         this.element.push(componentInstance);
 
@@ -144,6 +144,15 @@ class EntityBuilder {
         return this;
     }
 
+    /**
+     * @template T
+     * @param {T} klass
+     * @returns {boolean}
+     */
+    hasComponent(klass) {
+        return this.getComponent(klass) !== null;
+    }
+
     /**
      * @template T
      * @param {Class<T>} klass

package/engine/ecs/EntityComponentDataset.js

@@ -1467,7 +1467,7 @@ export class EntityComponentDataset {
      * Registers an event listener to a specific entity and event type, specified by eventName string.
      * @param {number} entity
      * @param {string} eventName
-     * @param {function|Function} listener
+     * @param {function()} listener
      * @param {*} [thisArg]
      */
     addEntityEventListener(entity, eventName, listener, thisArg) {

package/engine/ecs/parent/ChildEntities.d.ts

@@ -0,0 +1,3 @@
+export class ChildEntities {
+    readonly entities: number[]
+}

package/engine/ecs/parent/ChildEntities.js

@@ -0,0 +1,41 @@
+import { assert } from "../../../core/assert.js";
+
+export class ChildEntities {
+    constructor() {
+        /**
+         * Directly attached children, must have to relevant {@link ParentEntity} components in children as well
+         * @readonly
+         * @type {number[]}
+         */
+        this.entities = [];
+    }
+
+    /**
+     *
+     * @param {number[]} elements
+     * @returns {ChildEntities}
+     */
+    static from(elements) {
+        assert.isArrayLike(elements, 'elements');
+
+        const r = new ChildEntities();
+
+        Array.prototype.push.apply(r.entities, elements);
+
+        return r;
+    }
+
+    toJSON() {
+        return {
+            entities: this.entities
+        };
+    }
+
+    /**
+     *
+     * @param {number[]} entities
+     */
+    fromJSON({ entities = [] }) {
+        this.entities = entities;
+    }
+}

package/engine/ecs/system/AbstractContextSystem.js

@@ -16,7 +16,7 @@ export class AbstractContextSystem extends System {
 
         assert.defined(ContextClass, 'ContextClass');
         assert.notNull(ContextClass, 'ContextClass');
-        assert.typeOf(ContextClass, 'function', 'ContextClass');
+        assert.isFunction(ContextClass, 'ContextClass');
 
         /**
          *
@@ -60,10 +60,12 @@ export class AbstractContextSystem extends System {
     /**
      *
      * @param entity
-     * @return {T}
+     * @return {T|undefined}
      * @protected
      */
     __getEntityContext(entity) {
+        assert.isNumber(entity, 'entity');
+
         return this.__live_contexts[entity];
     }
 

package/engine/graphics/ecs/mesh-v2/sg_hierarchy_compute_bounding_box_via_parent_entity.js

@@ -18,7 +18,7 @@ export function sg_hierarchy_compute_bounding_box_via_parent_entity(result, root
          */
         const sg = ecd.getComponent(root_entity, ShadedGeometry);
 
-        if (sg !== null) {
+        if (sg !== undefined) {
             sg.getBoundingBox(scratch_aabb3);
 
             result.expandToFit(scratch_aabb3);

package/engine/graphics/ecs/path/PathDisplayEvents.js

@@ -3,5 +3,6 @@
  * @enum {string}
  */
 export const PathDisplayEvents = {
-    Changed: "@ecd-component-PathDisplay/changed"
-}
+    Changed: "@ecd-component-PathDisplay/changed",
+    BuildComplete: "@ecd-component-PathDisplay/build-complete"
+}

package/engine/graphics/ecs/path/PathDisplaySystem.js

@@ -139,6 +139,11 @@ class PathDisplayContext extends SystemEntityContext {
         }
 
         this.__build_existing_entities();
+
+        const ecd = this.getDataset();
+
+        // signal completion of build
+        ecd.sendEvent(this.entity, PathDisplayEvents.BuildComplete, ownedEntities);
     }
 
     __build_existing_entities() {

package/engine/graphics/ecs/path/highlight/PathDisplayHighlightSystem.d.ts

@@ -0,0 +1,7 @@
+import {System} from "../../../../ecs/System";
+import {PathDisplay} from "../PathDisplay";
+import Highlight from "../../highlight/Highlight";
+
+export class PathDisplayHighlightSystem extends System<PathDisplay, Highlight> {
+
+}

package/engine/graphics/ecs/path/highlight/PathDisplayHighlightSystem.js

@@ -0,0 +1,141 @@
+import { System } from "../../../../ecs/System.js";
+import { PathDisplay } from "../PathDisplay.js";
+import Highlight from "../../highlight/Highlight.js";
+import { PathDisplayEvents } from "../PathDisplayEvents.js";
+import { PathDisplaySystem } from "../PathDisplaySystem.js";
+
+export class PathDisplayHighlightSystem extends System {
+    constructor() {
+        super();
+
+        this.dependencies = [PathDisplay, Highlight];
+    }
+
+    /**
+     *
+     * @param {number} entity
+     * @returns {PathDisplayContext|undefined}
+     * @private
+     */
+    __getPathDisplayContext(entity) {
+
+        /**
+         *
+         * @type {PathDisplaySystem}
+         */
+        const pds = this.entityManager.getSystem(PathDisplaySystem);
+
+        if (pds === null) {
+            console.warn('PathDisplaySystem not registered');
+            return;
+        }
+        /**
+         *
+         * @type {PathDisplayContext}
+         */
+        const ctx = pds.__getEntityContext(entity);
+
+        return ctx;
+    }
+
+    /**
+     *
+     * @param _
+     * @param {number} entity
+     * @private
+     */
+    __apply_to_entity(_, entity) {
+        const ecd = this.entityManager.dataset;
+
+        const highlight = ecd.getComponent(entity, Highlight);
+
+        if (highlight === undefined) {
+            console.error(`Entity ${entity} no longer has a Highlight`);
+            return;
+        }
+
+        const ctx = this.__getPathDisplayContext(entity);
+
+        if (ctx === undefined) {
+            // no context
+            return;
+        }
+
+        /**
+         *
+         * @type {EntityBuilder[]}
+         */
+        const ownedEntities = ctx.__owned_entities;
+
+        for (let i = 0; i < ownedEntities.length; i++) {
+            const eb = ownedEntities[i];
+
+            if (eb.hasComponent(Highlight)) {
+                //already has a highlight
+                console.warn(`Owned entity ${eb.entity} of PathDisplay entity ${entity} already has a Highlight component attached. Keeping existing Highlight.`);
+                continue;
+            }
+
+            eb.add(highlight);
+        }
+    }
+
+    /**
+     *
+     * @param _
+     * @param {number} entity
+     * @private
+     */
+    __remove_from_entity(_, entity) {
+        const ecd = this.entityManager.dataset;
+
+        const highlight = ecd.getComponent(entity, Highlight);
+
+        if (highlight === undefined) {
+            console.error(`Entity ${entity} no longer has a Highlight`);
+            return;
+        }
+
+        const ctx = this.__getPathDisplayContext(entity);
+
+        if (ctx === undefined) {
+            // no context
+            return;
+        }
+
+        /**
+         *
+         * @type {EntityBuilder[]}
+         */
+        const ownedEntities = ctx.__owned_entities;
+
+        for (let i = 0; i < ownedEntities.length; i++) {
+            const eb = ownedEntities[i];
+
+            const hl = eb.getComponent(Highlight);
+
+            if (hl !== highlight) {
+                // has a different highlight, leave alone
+                continue;
+            }
+
+            eb.removeComponent(Highlight);
+        }
+    }
+
+    link(display, highlight, entity) {
+        this.__apply_to_entity(null, entity);
+
+        const ecd = this.entityManager.dataset;
+
+        ecd.addEntityEventListener(entity, PathDisplayEvents.BuildComplete, this.__apply_to_entity, this);
+    }
+
+    unlink(display, highlight, entity) {
+        const ecd = this.entityManager.dataset;
+
+        ecd.removeEntityEventListener(entity, PathDisplayEvents.BuildComplete, this.__apply_to_entity, this);
+
+        this.__remove_from_entity(null, entity);
+    }
+}

package/engine/graphics/ecs/path/testPathDisplaySystem.js

@@ -19,9 +19,6 @@ import SteeringSystem from "../../../ecs/systems/SteeringSystem.js";
 import MotionSystem from "../../../ecs/systems/MotionSystem.js";
 import TagSystem from "../../../ecs/systems/TagSystem.js";
 import { AttachmentSystem } from "../../../ecs/attachment/AttachmentSystem.js";
-import { SoundEmitterSystem } from "../../../sound/ecs/emitter/SoundEmitterSystem.js";
-import SoundControllerSystem from "../../../sound/ecs/SoundControllerSystem.js";
-import SoundListenerSystem from "../../../sound/ecs/SoundListenerSystem.js";
 import TimerSystem from "../../../ecs/systems/TimerSystem.js";
 import AnimationSystem from "../../../ecs/systems/AnimationSystem.js";
 import TopDownCameraControllerSystem from "../camera/topdown/TopDownCameraControllerSystem.js";
@@ -34,11 +31,6 @@ import WaterSystem from "../water/WaterSystem.js";
 import Trail2DSystem from "../trail2d/Trail2DSystem.js";
 import { Foliage2System } from "../../../ecs/foliage/ecs/Foliage2System.js";
 import ViewportPositionSystem from "../../../ecs/gui/position/ViewportPositionSystem.js";
-import { GridPosition2TransformSystem } from "../../../grid/systems/GridPosition2TransformSystem.js";
-import { Transform2GridPositionSystem } from "../../../grid/transform2grid/Transform2GridPositionSystem.js";
-import SynchronizePositionSystem from "../../../ecs/systems/SynchronizePositionSystem.js";
-import GridObstacleSystem from "../../../grid/systems/GridObstacleSystem.js";
-import GridPositionSystem from "../../../grid/systems/GridPositionSystem.js";
 import InputControllerSystem from "../../../input/ecs/systems/InputControllerSystem.js";
 import { InputSystem } from "../../../input/ecs/systems/InputSystem.js";
 import MeshHighlightSystem from "../highlight/system/MeshHighlightSystem.js";
@@ -58,7 +50,9 @@ import { GameAssetType } from "../../../asset/GameAssetType.js";
 import { GLTFAssetLoader } from "../../../asset/loaders/GLTFAssetLoader.js";
 import { JsonAssetLoader } from "../../../asset/loaders/JsonAssetLoader.js";
 import { ImageRGBADataLoader } from "../../../asset/loaders/image/ImageRGBADataLoader.js";
-import { AmbientOcclusionPostProcessEffect } from "../../render/buffer/simple-fx/ao/AmbientOcclusionPostProcessEffect.js";
+import {
+    AmbientOcclusionPostProcessEffect
+} from "../../render/buffer/simple-fx/ao/AmbientOcclusionPostProcessEffect.js";
 import { CanvasView } from "../../../../view/elements/CanvasView.js";
 import { computeCatmullRomSpline } from "../../../navigation/ecs/components/computeCatmullRomSpline.js";
 import { PathDisplaySpec } from "./PathDisplaySpec.js";
@@ -68,6 +62,11 @@ import { TubeMaterialType } from "./tube/TubeMaterialType.js";
 import { MatcapMaterialDefinition } from "./tube/MatcapMaterialDefinition.js";
 import { TextureAssetLoader } from "../../../asset/loaders/texture/TextureAssetLoader.js";
 import { ShadedGeometrySystem } from "../mesh-v2/ShadedGeometrySystem.js";
+import { CapType } from "./tube/CapType.js";
+import { StandardMaterialDefinition } from "./tube/StandardMaterialDefinition.js";
+import { PathDisplayHighlightSystem } from "./highlight/PathDisplayHighlightSystem.js";
+import { ShadedGeometryHighlightSystem } from "../highlight/system/ShadedGeometryHighlightSystem.js";
+import { BasicMaterialDefinition } from "./tube/BasicMaterialDefinition.js";
 
 const engineHarness = new EngineHarness();
 
@@ -95,9 +94,6 @@ function makeConfig(engine) {
         new MotionSystem(),
         new TagSystem(),
         new AttachmentSystem(),
-        new SoundEmitterSystem(assetManager, sound.destination, sound.context),
-        new SoundControllerSystem(),
-        new SoundListenerSystem(sound.context),
         new TimerSystem(),
         guiSystem,
         new AnimationSystem(graphics.viewport.size),
@@ -111,11 +107,6 @@ function makeConfig(engine) {
         new Trail2DSystem(engine),
         new Foliage2System(assetManager, graphics),
         new ViewportPositionSystem(graphics.viewport.size),
-        new GridPosition2TransformSystem(),
-        new Transform2GridPositionSystem(),
-        new SynchronizePositionSystem(),
-        new GridObstacleSystem(),
-        new GridPositionSystem(),
         new InputControllerSystem(devices),
         new InputSystem(devices),
         new MeshHighlightSystem(engine),
@@ -128,7 +119,9 @@ function makeConfig(engine) {
         new BehaviorSystem(engine),
         new SerializationMetadataSystem(),
         new InverseKinematicsSystem(),
+        new ShadedGeometryHighlightSystem(engine),
         new PathDisplaySystem(engine),
+        new PathDisplayHighlightSystem()
     );
 
     // Plugins
@@ -309,17 +302,74 @@ function sample_style_tube() {
     const style = new TubePathStyle();
 
     style.color.setRGB(1, 1, 1);
-    style.material_type = TubeMaterialType.Matcap;
-    style.material = new MatcapMaterialDefinition();
-    // style.material.texture = 'data/textures/matcap/matcap-porcelain-white.jpg';
-    style.material.texture = "data/textures/matcap/nidorx/3E2335_D36A1B_8E4A2E_2842A5.jpg";
 
-    style.width = 0.1;
+    function make_matcap(style) {
+
+        style.material_type = TubeMaterialType.Matcap;
+        style.material = new MatcapMaterialDefinition();
+        // style.material.texture = 'data/textures/matcap/matcap-porcelain-white.jpg';
+        style.material.texture = "data/textures/matcap/nidorx/3E2335_D36A1B_8E4A2E_2842A5.jpg";
+
+    }
+
+    function make_standard(style) {
+
+        style.material_type = TubeMaterialType.Standard;
+        style.material = new StandardMaterialDefinition();
+        // style.material.texture = 'data/textures/matcap/matcap-porcelain-white.jpg';
+        // style.material.texture = "data/textures/matcap/nidorx/3E2335_D36A1B_8E4A2E_2842A5.jpg";
+
+        style.color.setHSV(0, 1, 0.9);
+    }
+
+    function make_basic(style){
+        style.material_type = TubeMaterialType.Basic;
+        style.material  = new BasicMaterialDefinition();
+
+        style.color.setHSV(0, 1, 0.9);
+    }
+
+    make_basic(style);
+
+    style.width = 0.5;
+    style.cast_shadow = true;
+
+    style.cap_type = CapType.Round;
+    // style.cap_type = CapType.None;
+
+    // style.path_mask = [
+    //     0.1, 0.12,
+    //     0.3,  1
+    // ];
+
+    //
+    // style.shape = [
+    //     0.1, -0.5,
+    //     0.1, 0.5,
+    //     -0.1, 0.5,
+    //     -0.1, -0.5,
+    // ];
+
+    // style.shape = [
+    //     -0.5, -0.1,
+    //     0.5, -0.1,
+    //     0.5, 0.1,
+    //     -0.5, 0.1,
+    // ];
+    //
+    style.shape = [
+        -0.5, -0.1,
+        -0.45, -0.15,
+        0.45, -0.15,
+        0.5, -0.1,
+        0.5, 0.1,
+        0.45, 0.15,
+        -0.45, 0.15,
+        -0.5, 0.1
+    ];
 
     style.path_mask = [
-        0.1, 0.12,
-        0.3, 0.8,
-        0.9, 1
+        0, 1
     ];
 
     return style;
@@ -352,6 +402,16 @@ function main(engine) {
     ]);
 
 
+    // _p.setPositionsFromVectorArray([
+    //     new Vector3(1, 1, 3),
+    //     new Vector3(3, 1, 3),
+    //     new Vector3(3, 1, 7),
+    //     new Vector3(7, 1, 7),
+    //     new Vector3(7, 1, 3),
+    //     new Vector3(8, 1, 3),
+    // ]);
+    // _p.reverse();
+
     const trailPathStyle = new RibbonPathStyle();
     trailPathStyle.material.diffuse = "data/textures/trail/Circle_04.png";
     trailPathStyle.resolution = 10;
@@ -377,6 +437,7 @@ function main(engine) {
     new EntityBuilder()
         .add(_p)
         .add(pathDisplay)
+        .add(Highlight.fromOne(0, 1, 1, 1))
         .build(engine.entityManager.dataset);
 }
 

package/engine/graphics/ecs/path/tube/BasicMaterialDefinition.d.ts

@@ -0,0 +1,3 @@
+export class BasicMaterialDefinition {
+
+}

package/engine/graphics/ecs/path/tube/BasicMaterialDefinition.js

@@ -0,0 +1,8 @@
+export class BasicMaterialDefinition {
+    constructor() {
+    }
+
+    fromJSON() {
+        
+    }
+}

package/engine/graphics/ecs/path/tube/TubeMaterialType.d.ts

@@ -1,5 +1,6 @@
 export enum TubeMaterialType {
     Unknown = 'unknown',
+    Basic = 'basic',
     Standard = 'standard',
     Matcap = 'matcap'
 }

package/engine/graphics/ecs/path/tube/TubeMaterialType.js

@@ -1,5 +1,6 @@
 export const TubeMaterialType = {
     Unknown: 'unknown',
+    Basic:'basic',
     Standard: 'standard',
     Matcap: 'matcap'
 }

package/engine/graphics/ecs/path/tube/TubePathStyle.d.ts

@@ -11,7 +11,19 @@ export class TubePathStyle {
     public opacity: number
     public width: number
     public resolution: number
+    /**
+     * @deprecated
+     */
     public radial_resolution: number
+    /**
+     * Profile shape of the path, such as a circle or a square
+     * Defined as a sequence of 2d points: [x0,y0,x1,y1, ... xN, yN]
+     */
+    public shape: ArrayLike<number>
+    /**
+     * Optional, contains 2d normals of the profile shape, if not set - smooth normals will be automatically computed
+     */
+    public shape_normals: ArrayLike<number>
     public cast_shadow: boolean
     public receive_shadow: boolean
     public path_mask: number[]