@woosh/meep-engine 2.27.0 → 2.30.0

package/engine/graphics/particles/particular/engine/simulator/update_parameters.js

@@ -0,0 +1,41 @@
+import { ParticleParameters } from "../emitter/ParticleParameters.js";
+import {
+    PARTICLE_ATTRIBUTE_COLOR,
+    PARTICLE_ATTRIBUTE_SIZE,
+    PARTICLE_ATTRIBUTE_SIZE_INITIAL
+} from "../emitter/PARTICLE_ATTRIBUTES.js";
+
+const v4 = new Float32Array(4);
+
+/**
+ *
+ * @param {number} particle_index
+ * @param {ParticlePool} particles
+ * @param {ParticleLayer} layer
+ * @param {number} normalized_age
+ */
+export function update_parameters(particle_index, particles, layer, normalized_age) {
+    const tracks = layer.parameterTracks;
+
+    // update color
+    const param_color = tracks.getTrackByName(ParticleParameters.Color);
+
+    if (param_color !== undefined) {
+        param_color.track.sample(normalized_age, v4);
+        particles.writeAttributeVector4(particle_index, PARTICLE_ATTRIBUTE_COLOR, v4[0], v4[1], v4[2], v4[3]);
+    }
+
+    // update size
+    const param_scale = tracks.getTrackByName(ParticleParameters.Scale);
+
+    const initial_size = particles.readAttributeScalar(particle_index, PARTICLE_ATTRIBUTE_SIZE_INITIAL);
+
+    if (param_scale !== undefined) {
+        param_scale.track.sample(normalized_age, v4);
+
+        const scale = v4[0];
+        particles.writeAttributeScalar(particle_index, PARTICLE_ATTRIBUTE_SIZE, scale * initial_size);
+    } else {
+        particles.writeAttributeScalar(particle_index, PARTICLE_ATTRIBUTE_SIZE, initial_size);
+    }
+}

package/engine/graphics/render/buffer/FrameBufferManager.js

@@ -125,6 +125,8 @@ FrameBufferManager.prototype.computeRenderOrder = function () {
  * @returns {FrameBuffer|undefined}
  */
 FrameBufferManager.prototype.getById = function (id) {
+    assert.isString(id, 'id');
+
     return this.buffers.find(function (buffer) {
         return buffer.id === id;
     });

package/engine/graphics/render/visibility/IncrementalDeltaSet.js

@@ -102,6 +102,11 @@ export class IncrementalDeltaSet {
     }
 
     clear() {
+        if (this.size === 0) {
+            // already empty
+            return;
+        }
+
         this.elements.splice(0, this.size);
         this.size = 0;
         this.flags.reset();

package/engine/graphics/render/visibility/VisibilityComputer.js

@@ -3,6 +3,11 @@ import { frustumFromCamera } from "../../ecs/camera/CameraSystem.js";
 import { assert } from "../../../../core/assert.js";
 
 const frustum = new Frustum();
+/**
+ *
+ * @type {VisibilityFilter[]}
+ */
+const objectFilters = [];
 
 export class VisibilityComputer {
     constructor() {
@@ -104,11 +109,6 @@ export class VisibilityComputer {
         //clear visible set
         layer.visibleSet.initializeUpdate();
 
-        /**
-         *
-         * @type {VisibilityFilter[]}
-         */
-        const objectFilters = [];
         /**
          *
          * @type {function[]}
@@ -124,7 +124,7 @@ export class VisibilityComputer {
             const f = filters[i];
 
             if (f.enabled && f.layerPredicate(layer)) {
-                objectFilters.push(f);
+                objectFilters[objectFilterCount] = f;
                 objectFilterExecutors.push(f.objectPredicateExecute);
 
                 objectFilterCount++;

package/engine/graphics/render/visibility/VisibilityFilter.js

@@ -1,4 +1,5 @@
 import { noop, returnTrue } from "../../../../core/function/Functions.js";
+import { assert } from "../../../../core/assert.js";
 
 export class VisibilityFilter {
     constructor({
@@ -9,12 +10,21 @@ export class VisibilityFilter {
                     layerPredicate = returnTrue
                 }) {
 
+        assert.isString(name, 'name');
+
+        /**
+         * @type {string}
+         */
         this.name = name;
 
         this.objectPredicateExecute = objectPredicateExecute;
         this.objectPredicateInitialize = objectPredicateInitialize;
         this.objectPredicateFinalize = objectPredicateFinalize;
 
+        /**
+         *
+         * @type {function(RenderLayer): boolean}
+         */
         this.layerPredicate = layerPredicate;
 
         /**

package/engine/navigation/ecs/components/Path.d.ts

@@ -3,11 +3,18 @@ import {InterpolationType} from "./InterpolationType";
 
 export default class Path {
     public interpolation: InterpolationType
+    /**
+     * Absolute length of the path
+     */
+    public readonly length: number
 
     public isEmpty(): boolean
 
     public clear(): void
 
+    /**
+     * Number of points that make up this path
+     */
     public getPointCount(): number
 
     public setPointCount(v: number): void

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

@@ -4,7 +4,7 @@
 
 
 import { line3_computeSegmentPointDistance_sqr } from "../../../../core/geom/LineSegment.js";
-import Vector3 from "../../../../core/geom/Vector3.js";
+import Vector3, { v3_distance } from "../../../../core/geom/Vector3.js";
 
 import { CatmullRomCurve3 } from "three";
 import { clamp } from "../../../../core/math/clamp.js";
@@ -21,6 +21,9 @@ import { InterpolationType } from "./InterpolationType.js";
 const v3_a = new Vector3();
 const v3_b = new Vector3();
 
+const scratch_v3_a = new Float32Array(3);
+const scratch_v3_b = new Float32Array(3);
+
 /**
  *
  * @type {number[]}
@@ -58,29 +61,6 @@ class Path {
          */
         this.__data = new RowFirstTable(DEFAULT_SPEC);
 
-        /**
-         * TODO this needs to be moved to PathFollower
-         * Distance offset from the previous vertex on the path
-         * @type {number}
-         * @deprecated
-         */
-        this.markerOffset = 0;
-        /**
-         * TODO this needs to be moved to PathFollower
-         * Index of the previous vertex on the path
-         * @type {number}
-         * @deprecated
-         */
-        this.markerIndex = 0;
-
-        /**
-         * TODO this needs to be moved to PathFollower
-         * Distance to the next vertex on the path
-         * @type {number}
-         * @deprecated
-         */
-        this.markerDistanceToNext = 0;
-
         /**
          *
          * @type {InterpolationType|number}
@@ -95,21 +75,16 @@ class Path {
         this.__length = -1;
     }
 
-    /**
-     * TODO this needs to be moved to PathFollower
-     * @deprecated
-     */
-    terminateAtCurrentPosition() {
-        console.warn('deprecated');
-        const endIndex = this.markerIndex + 1;
-
-        this.getCurrentPosition(v3_a);
-        this.setPosition(endIndex, v3_a.x, v3_a.y, v3_a.z);
+    get markerOffset() {
+        throw new Error('deprecated, use PathFollower instead');
+    }
 
-        this.setPointCount(endIndex);
+    get markerIndex() {
+        throw new Error('deprecated, use PathFollower instead');
+    }
 
-        this.markerOffset = 0;
-        this.markerDistanceToNext = 0;
+    get markerDistanceToNext() {
+        throw new Error('deprecated, use PathFollower instead');
     }
 
     /**
@@ -245,7 +220,7 @@ class Path {
     /**
      *
      * @param {number} index
-     * @param {number[]} result
+     * @param {ArrayLike<number>|number[]|Float32Array|Float64Array} result
      * @param {number} result_offset
      */
     readPositionToArray(index, result, result_offset) {
@@ -506,16 +481,19 @@ class Path {
 
         let cursor = 0;
 
-        let current = v3_a;
-        let previous = v3_b;
+        let current = scratch_v3_a;
+        let previous = scratch_v3_b;
         let distance = 0;
 
-        this.getPosition(0, previous);
+        this.readPositionToArray(0, previous, 0);
 
         for (let i = 1; i < pointCount; i++) {
-            this.getPosition(i, current);
+            this.readPositionToArray(i, current, 0);
 
-            distance = previous.distanceTo(current);
+            distance = v3_distance(
+                previous[0], previous[1], previous[2],
+                current[0], current[1], current[2]
+            );
 
             if (cursor + distance > absolute_distance) {
                 // we found v1
@@ -867,17 +845,23 @@ class Path {
         }
 
         let r = 0;
-        let p0 = v3_a;
-        let p1 = v3_b;
 
-        this.getPosition(0, p0);
+        let p0 = scratch_v3_a;
+        let p1 = scratch_v3_b;
+        let distance = 0;
+
+        this.readPositionToArray(0, p1, 0);
 
         for (let i = 1; i < n; i++) {
-            this.getPosition(i, p1);
+            this.readPositionToArray(i, p0, 0);
+
+            distance = v3_distance(
+                p1[0], p1[1], p1[2],
+                p0[0], p0[1], p0[2]
+            );
 
-            const d = p0.distanceTo(p1);
 
-            r += d;
+            r += distance;
 
             // perform variable swap
             const swap_t = p0;

package/engine/navigation/ecs/path_following/PathFollower.d.ts

@@ -1,32 +1,22 @@
-import {BooleanVector3} from "../../../../core/model/BooleanVector3";
 import Vector1 from "../../../../core/geom/Vector1";
 import {PathFollowerFlags} from "./PathFollowerFlags";
 
 export default class PathFollower {
-    constructor()
-
-    /**
-     *
-     * On which axis to write rotation
-     */
-    readonly rotationAlignment: BooleanVector3
-
-    /**
-     *
-     * On which axis to write position
-     */
-    readonly positionWriting: BooleanVector3
-
     /**
      * Movement speed along the path in world units per second
      */
     readonly speed: Vector1
+
     /**
      *
      * Speed at which path follower can adjust rotation in Rad/s
      */
     readonly rotationSpeed: Vector1
 
+    /**
+     *
+     * Absolute position along the path
+     */
     position: number
 
     flags: number

package/package.json

@@ -4,15 +4,15 @@
   "productName": "Meep",
   "description": "production-ready JavaScript game engine based on Entity Component System Architecture",
   "author": "Alexander Goldring",
-  "version": "2.27.0",
+  "version": "2.30.0",
   "dependencies": {
     "fast-levenshtein": "2.0.6",
     "opentype.js": "1.3.3",
     "simplex-noise": "2.4.0",
-    "three": "^0.129.0"
+    "three": "^0.132.2"
   },
   "devDependencies": {
     "babel-jest": "^26.6.3",
-    "@types/three": "^0.128.0"
+    "@types/three": "^0.131.1"
   }
 }

package/view/elements/progress/segmented/SegmentedResourceBarView.js

@@ -137,6 +137,12 @@ export class SegmentedResourceBarView extends View {
     }
 
     __updateSize() {
+
+        if (this.__sizeObserver.dimensions.size.distanceSqrTo(this.__v_segments.size) < 0.5) {
+            // change too small, ignore
+            return;
+        }
+
         this.updateSegments();
     }
 
@@ -152,6 +158,7 @@ export class SegmentedResourceBarView extends View {
          */
         const size = this.__sizeObserver.dimensions.size;
 
+
         this.__v_segments.size.copy(size);
 
         const vSegments = this.__v_segments;

package/view/minimap/Minimap.js

@@ -143,7 +143,7 @@ class MinimapView extends View {
             updateWorldScale();
         });
 
-        const pointer = this.pointer = new PointerDevice(this.el);
+        const pointer = this.pointer = new PointerDevice(vWorld.el);
 
         function focus(x, y) {
             const worldX = (x / worldScale.x) + world.position.x;

package/view/util/DomSizeObserver.js

@@ -45,6 +45,9 @@ export function resizeAABB2ToFitBoundingClientRect(el, depth, aabb) {
 
 const aabb = new AABB2();
 
+/**
+ * Size observer of a DOM element
+ */
 export class DomSizeObserver {
     /**
      *
@@ -72,19 +75,47 @@ export class DomSizeObserver {
          */
         this.element = null;
 
+        /**
+         * @private
+         * @type {boolean}
+         */
         this.running = false;
 
-        const cycle = () => {
-            if (this.running) {
-                this.update();
-                requestAnimationFrame(cycle);
-            }
-        }
+        /**
+         *
+         * @type {ResizeObserver}
+         * @private
+         */
+        this.__dom_resize_observer = new ResizeObserver(this.__dom_resize_observer_callback.bind(this));
+    }
+
+    /**
+     *
+     * @param {ResizeObserverEntry[]} entries
+     * @param {ResizeObserver} observer
+     * @private
+     */
+    __dom_resize_observer_callback(entries, observer) {
+        const first_entry = entries[0];
+
+        /**
+         *
+         * @type {ClientRect | DOMRect}
+         */
+        const rect = first_entry.contentRect;
+
 
-        this.cycle = cycle;
+        aabb.setNegativelyInfiniteBounds();
+
+        resizeAABB2ToFitBoundingClientRect(this.element, this.__depth, aabb);
+
+        const rectangle = this.dimensions;
+
+        rectangle.position.set(aabb.x0, aabb.y0);
+        rectangle.size.set(rect.width, rect.height);
     }
 
-    update() {
+    synchronize() {
         aabb.setNegativelyInfiniteBounds();
 
         resizeAABB2ToFitBoundingClientRect(this.element, this.__depth, aabb);
@@ -103,7 +134,12 @@ export class DomSizeObserver {
 
         this.running = true;
 
-        this.cycle();
+        // perform an immediate update
+        this.synchronize();
+
+        if (this.element !== null) {
+            this.__dom_resize_observer.observe(this.element);
+        }
     }
 
     /**
@@ -112,10 +148,24 @@ export class DomSizeObserver {
      */
     attach(element) {
         this.element = element;
+
+        if (this.running) {
+            this.__dom_resize_observer.unobserve(this.element);
+        }
     }
 
     stop() {
+
+        if (!this.running) {
+            // not running
+            return;
+        }
+
         this.running = false;
+
+        if (this.element !== null) {
+            this.__dom_resize_observer.unobserve(this.element);
+        }
     }
 
     /**
@@ -144,6 +194,5 @@ export class DomSizeObserver {
 
         view.on.linked.remove(this.start, this);
         view.on.unlinked.remove(this.stop, this);
-
     }
 }