@woosh/meep-engine 2.33.19 → 2.33.23

package/engine/graphics/render/forward_plus/queryBVH_Frustum.js

@@ -1,7 +1,7 @@
-import { v3_distance_sqr } from "../../../../core/geom/Vector3.js";
 import { line3_computeSegmentPointDistance_sqr } from "../../../../core/geom/LineSegment.js";
 import { computeConePlaneSide } from "../../../../core/geom/3d/cone/computeConePlaneSide.js";
 import { aabb3_computeDistanceAbovePlane } from "../../../../core/geom/3d/aabb/aabb3_computeDistanceAbovePlane.js";
+import { v3_distance_sqr } from "../../../../core/geom/v3_distance_sqr.js";
 
 /**
  *
@@ -67,7 +67,11 @@ biplanar_edge_mapping[0b100010] = 5 | (7 << 3);
  * @param {number[]} points
  * @return {boolean}
  */
-function detailed_sphere_frustum_intersection_test(radius, light_x, light_y, light_z, outside_plane_count, outside_plane_bitfield, points) {
+function detailed_sphere_frustum_intersection_test(
+    radius, light_x, light_y, light_z,
+    outside_plane_count, outside_plane_bitfield,
+    points
+) {
 
     const radius_sqr = radius * radius;
 
@@ -201,7 +205,11 @@ function point_light_inside_volume(light, points, planes) {
     if (outside_plane_count < 2) {
         return true;
     } else {
-        return detailed_sphere_frustum_intersection_test(radius, light_x, light_y, light_z, outside_plane_count, outside_plane_bitfield, points);
+        return detailed_sphere_frustum_intersection_test(
+            radius, light_x, light_y, light_z,
+            outside_plane_count, outside_plane_bitfield,
+            points
+        );
     }
 }
 
@@ -246,7 +254,11 @@ function spot_light_inside_volume(light, points, planes) {
  * @param {number[]|Float32Array|Float64Array} points
  * @returns {number} number of items added to the destination, non-negative integer
  */
-export function queryBVH_Frustum(destination, destination_offset, root, planes, points) {
+export function queryBVH_Frustum(
+    destination,
+    destination_offset,
+    root, planes, points
+) {
     let i = 0;
     let j = 0;
     // read out points
@@ -258,7 +270,7 @@ export function queryBVH_Frustum(destination, destination_offset, root, planes,
 
     stack_loop:while (stackPointer-- > stackOffset) {
 
-        queryBVH_Frustum.iteration_count++;
+        // queryBVH_Frustum.iteration_count++;
 
         const n = stack[stackPointer];
 
@@ -282,7 +294,7 @@ export function queryBVH_Frustum(destination, destination_offset, root, planes,
                 if (distanceAbovePlane < 0) {
                     // node is below the plane
 
-                    queryBVH_Frustum.rejection_count++;
+                    // queryBVH_Frustum.rejection_count++;
 
                     continue stack_loop;
                 }

package/engine/graphics/render/layers/RenderLayerUtils.js

@@ -1,6 +1,5 @@
-import Vector3 from "../../../../core/geom/Vector3.js";
 import { computePointDistanceToPlane } from "../../../../core/geom/Plane.js";
-import { plane_three_computeConvex3PlaneIntersection } from "../../../../core/geom/3d/plane_computeConvex3PlaneIntersection.js";
+import { plane_three_computeConvex3PlaneIntersection } from "../../../../core/geom/3d/plane/plane_computeConvex3PlaneIntersection.js";
 
 /**
  *
@@ -10,7 +9,11 @@ import { plane_three_computeConvex3PlaneIntersection } from "../../../../core/ge
  */
 export function buildPlanarRenderLayerClipPlaneComputationMethod(traversePlanes, bias = 0) {
 
-    const p = new Vector3();
+    /**
+     *
+     * @type {number[]}
+     */
+    const p = [];
 
     const adjacentPlanePairs = [
         [],
@@ -38,7 +41,7 @@ export function buildPlanarRenderLayerClipPlaneComputationMethod(traversePlanes,
             const p0 = pair[0];
             const p1 = pair[1];
 
-            const planeIntersection = plane_three_computeConvex3PlaneIntersection(p, p0, p1, objectPlane);
+            const planeIntersection = plane_three_computeConvex3PlaneIntersection(p, 0, p0, p1, objectPlane);
 
             if (!planeIntersection) {
                 //no intersection
@@ -48,7 +51,7 @@ export function buildPlanarRenderLayerClipPlaneComputationMethod(traversePlanes,
 
             const plane_normal = nearPlane.normal;
 
-            const distanceToNearPlane = computePointDistanceToPlane(p.x, p.y, p.z, plane_normal.x, plane_normal.y, plane_normal.z, nearPlane.constant);
+            const distanceToNearPlane = computePointDistanceToPlane(p[0], p[1], p[2], plane_normal.x, plane_normal.y, plane_normal.z, nearPlane.constant);
 
             //update near and far plane distances
             if (distanceToNearPlane > 0 && distanceToNearPlane < range.near) {

package/engine/graphics/render/visibility/hiz/prototypeHiZ.js

@@ -112,7 +112,7 @@ function makeConfig(engine) {
         new ClingToTerrainSystem(),
         new TerrainSystem(graphics, assetManager),
         new WaterSystem(graphics),
-        new Trail2DSystem(graphics, assetManager),
+        new Trail2DSystem(engine),
         new Foliage2System(assetManager, graphics),
         new ViewportPositionSystem(graphics.viewport.size),
         new GridPosition2TransformSystem(),

package/engine/graphics/texture/atlas/AtlasPatch.js

@@ -5,12 +5,15 @@ import AABB2 from "../../../../core/geom/AABB2.js";
 export class AtlasPatch {
     constructor() {
         /**
-         *
+         * Position in the atlas where the raw patch data is found, excludes padding
+         * @readonly
          * @type {Vector2}
          */
         this.position = new Vector2(0, 0);
+
         /**
-         *
+         * Size in pixels of the patch, excludes padding
+         * @readonly
          * @type {Vector2}
          */
         this.size = new Vector2(0, 0);
@@ -34,11 +37,13 @@ export class AtlasPatch {
         this.sampler = null;
 
         /**
+         * @readonly
          * @type {Rectangle}
          */
         this.uv = new Rectangle(0, 0, 0, 0);
 
         /**
+         * Area in the atlas where patch along with the padding is packed into
          * Used for packing inside TextureAtlas. Do not modify manually
          * @readonly
          * @protected

package/engine/graphics/texture/atlas/TextureAtlas.js

@@ -82,8 +82,8 @@ export class TextureAtlas {
      * @returns {boolean}
      */
     contains(patch) {
-        assert.notEqual(patch, null, 'patch is null');
-        assert.notEqual(patch, undefined, 'patch is undefined');
+        assert.notNull(patch, 'patch');
+        assert.defined(patch, 'patch');
         assert.ok(patch.isAtlasPatch, 'patch argument is not an AtlasPatch');
 
         return this.patches.includes(patch);
@@ -116,28 +116,32 @@ export class TextureAtlas {
      *
      * @param {number} x
      * @param {number} y
-     * @returns {boolean}
+     * @returns {boolean} true if resizing successful, false otherwise
      */
     resize(x, y) {
         //check if any patches would be cut
         const patches = this.patches;
         const numPatches = patches.length;
-        const patchBoundsViolated = patches.some(patch => {
 
-            if (!patch.getFlag(AtlasPatchFlag.Packed)) {
+        //update patch UVs
+        for (let i = 0; i < numPatches; i++) {
+            const patch = patches[i];
+
+            if (patch.getFlag(AtlasPatchFlag.Packed)) {
                 //only care about packed patches
-                return false;
-            }
 
-            const x1 = patch.position.x + patch.size.x + patch.padding;
-            const y1 = patch.position.y + patch.size.y + patch.padding;
+                const pp = patch.position;
+                const ps = patch.size;
 
-            return x1 >= x || y1 >= y;
-        });
+                const x1 = pp.x + ps.x + patch.padding;
+                const y1 = pp.y + ps.y + patch.padding;
 
-        if (patchBoundsViolated) {
-            //Resizing atlas would result in some patches not fitting
-            return false;
+                if (x1 >= x || y1 >= y) {
+                    // patch bounds would violate the desired atlas extends
+                    //Resizing atlas would result in some patches not fitting
+                    return false;
+                }
+            }
         }
 
         //update patch UVs

package/engine/graphics/texture/sampler/Sampler2D.js

@@ -493,7 +493,7 @@ Sampler2D.prototype.get = function (x, y, result) {
 
     const t = [];
 
-    this.sampleBilinear(x, y, t);
+    this.sampleBilinear(x, y, t, 0);
 
     if (result !== undefined) {
         result.readFromArray(t, 0);
@@ -655,14 +655,15 @@ Sampler2D.prototype.sampleChannelBicubic = function (x, y, channel) {
  * @param {number} x
  * @param {number} y
  * @param {number[]} result
+ * @param {number} result_offset
  */
-Sampler2D.prototype.sampleBilinear = function (x, y, result) {
+Sampler2D.prototype.sampleBilinear = function (x, y, result, result_offset) {
 
     const itemSize = this.itemSize;
 
     for (let i = 0; i < itemSize; i++) {
         //TODO this can be optimized greatly
-        result[i] = this.sampleChannelBilinear(x, y, i);
+        result[i + result_offset] = this.sampleChannelBilinear(x, y, i);
 
     }
 };
@@ -809,7 +810,7 @@ Sampler2D.prototype.sample = function (u, v, result) {
 
     const temp = [];
 
-    this.sampleBilinear(u * (this.width - 1), v * (this.height - 1), temp);
+    this.sampleBilinear(u * (this.width - 1), v * (this.height - 1), temp, 0);
 
     result.readFromArray(temp);
 
@@ -888,7 +889,7 @@ Sampler2D.prototype.makeArrayFiller = function (scale, offset) {
     }
 
     function fillDD2(index, array, x, y) {
-        sampler.sampleBilinear(x, y, v4);
+        sampler.sampleBilinear(x, y, v4, 0);
         const val = (v4[0] + offset) * scale | 0;
         array.fill(val, index, index + 3);
         array[index + 3] = (v4[1] + offset) * scale | 0;
@@ -896,7 +897,7 @@ Sampler2D.prototype.makeArrayFiller = function (scale, offset) {
 
     function fillDD3(index, array, x, y) {
 
-        sampler.sampleBilinear(x, y, v4);
+        sampler.sampleBilinear(x, y, v4, 0);
 
         array[index] = (v4[0] + offset) * scale | 0;
         array[index + 1] = (v4[1] + offset) * scale | 0;
@@ -905,7 +906,7 @@ Sampler2D.prototype.makeArrayFiller = function (scale, offset) {
     }
 
     function fillDD4(index, array, x, y) {
-        sampler.sampleBilinear(x, y, v4);
+        sampler.sampleBilinear(x, y, v4, 0);
         array[index] = (v4[0] + offset) * scale | 0;
         array[index + 1] = (v4[1] + offset) * scale | 0;
         array[index + 2] = (v4[2] + offset) * scale | 0;

package/engine/graphics/texture/sampler/scaleSampler2D.js

@@ -7,6 +7,7 @@ import { assert } from "../../../../core/assert.js";
  */
 export function scaleSampler2D(source, target) {
     const targetItemSize = target.itemSize;
+
     assert.equal(source.itemSize, targetItemSize, 'both source and target must have the same number of channels');
 
     const targetWidth = target.width;
@@ -18,32 +19,28 @@ export function scaleSampler2D(source, target) {
     const target_data = target.data;
 
     if (sourceWidth === targetWidth && sourceHeight === targetHeight) {
-        // exact size match
+        // exact size match, nothing to do
         target_data.set(source.data);
         return;
     }
 
-    const sample = [];
-
     const targetRowSize = targetItemSize * targetWidth;
 
+    const source_scale_x = sourceWidth / targetWidth;
+    const source_scale_y = sourceHeight / targetHeight;
+
     for (let y = 0; y < targetHeight; y++) {
 
-        const v = y / targetHeight;
 
+        const sample_y = y * source_scale_y;
         const target_row_address = y * targetRowSize;
 
         for (let x = 0; x < targetWidth; x++) {
 
-            const u = x / targetWidth;
-
-            source.sampleBilinear(u * sourceWidth, v * sourceHeight, sample);
 
             const target_offset = target_row_address + x * targetItemSize;
 
-            for (let i = 0; i < targetItemSize; i++) {
-                target_data[target_offset + i] = sample[i];
-            }
+            source.sampleBilinear(x * source_scale_x, sample_y, target_data, target_offset);
 
         }
     }

package/engine/graphics/trail/x/RibbonMaterialX.js

@@ -106,11 +106,11 @@ export class RibbonMaterialX extends ShaderMaterial {
                 uDiffuse: {
                     type: 't',
                     value: null
-                },
-                defines: {
-                    USE_TEXTURE: false
                 }
             },
+            defines: {
+                USE_TEXTURE: false
+            },
             blending: NormalBlending,
             transparent: true,
             depthWrite: false,

package/engine/graphics/trail/x/RibbonX.js

@@ -36,7 +36,6 @@ export class RibbonX {
          */
         this.__data = new RowFirstTable(ribbon_attributes_spec);
 
-
         /**
          * Index into current geometry segment that is at the END of the ribbon
          * @type {number}
@@ -66,6 +65,10 @@ export class RibbonX {
         this.__count = 0;
     }
 
+    dispose() {
+        this.__geometry.dispose();
+    }
+
     /**
      *
      * @returns {BufferGeometry}
@@ -350,6 +353,11 @@ export class RibbonX {
         this.setPointAttribute_Vector3(index, RIBBON_ATTRIBUTE_ADDRESS_COLOR, r, g, b);
     }
 
+    /**
+     *
+     * @param {number} index
+     * @param {number} value
+     */
     setPointAlpha(index, value) {
         const i2 = index * 2;
 
@@ -359,7 +367,11 @@ export class RibbonX {
         this.__ib_float32.needsUpdate = true;
     }
 
-
+    /**
+     *
+     * @param {number} index
+     * @param {number} value
+     */
     setPointThickness(index, value) {
         const i2 = index * 2;
 
@@ -377,6 +389,9 @@ export class RibbonX {
         assert.greaterThanOrEqual(count, 2, 'number of points in the ribbon must be at least 2 (to produce at least a single quad)');
         assert.isNonNegativeInteger(count, 'count');
 
+        // dispose of existing geometry
+        this.__geometry.dispose();
+
         const point_count = count * 2;
 
         if (this.__data.length > point_count) {

package/engine/graphics/trail/x/RibbonXPlugin.js

@@ -1,15 +1,18 @@
 import { EnginePlugin } from "../../../plugin/EnginePlugin.js";
 import { RibbonMaterialX } from "./RibbonMaterialX.js";
-import { DoubleSide } from "three";
+import { DoubleSide, Vector2 } from "three";
 import { GameAssetType } from "../../../asset/GameAssetType.js";
 import { Cache } from "../../../../core/cache/Cache.js";
 import { invokeObjectEquals } from "../../../../core/model/object/invokeObjectEquals.js";
 import { invokeObjectHash } from "../../../../core/model/object/invokeObjectHash.js";
+import { MaterialManager } from "../../material/manager/MaterialManager.js";
 
 export class RibbonXPlugin extends EnginePlugin {
     initialize(engine) {
         super.initialize(engine);
 
+        this.id = 'ribbon-x-plugin';
+
         /**
          * @private
          * @readonly
@@ -21,6 +24,51 @@ export class RibbonXPlugin extends EnginePlugin {
             keyHashFunction: invokeObjectHash,
             keyEqualityFunction: invokeObjectEquals
         });
+
+        this.__shared_uniforms = {
+            resolution: {
+                value: new Vector2(1, 1)
+            }
+        };
+
+        /**
+         *
+         * @type {MaterialManager}
+         * @private
+         */
+        this.__materials = new MaterialManager();
+    }
+
+    __handle_viewport_size_change() {
+        const s = this.engine.graphics.viewport.size;
+
+        this.__shared_uniforms.resolution.value.set(s.x, s.y);
+    }
+
+    async startup() {
+        this.__handle_viewport_size_change();
+
+        this.engine.graphics.viewport.size.onChanged.add(this.__handle_viewport_size_change, this);
+
+        return super.startup();
+    }
+
+    async shutdown() {
+
+        this.engine.graphics.viewport.size.onChanged.remove(this.__handle_viewport_size_change, this);
+
+        return super.shutdown();
+    }
+
+    /**
+     *
+     * @param {RibbonXMaterialSpec} spec
+     * @return {Reference<Material>}
+     */
+    obtain_material_reference(spec) {
+        const mm = this.obtain_material_x(spec);
+
+        return this.__materials.obtain(mm);
     }
 
     /**
@@ -62,6 +110,8 @@ export class RibbonXPlugin extends EnginePlugin {
             }
         });
 
+        material.uniforms.resolution = this.__shared_uniforms.resolution;
+
         if (spec.diffuse !== null) {
             const am = this.engine.assetManager;
 

package/engine/graphics/util/projectSphere.js

@@ -1,6 +1,6 @@
 import { assert } from "../../../core/assert.js";
 import { v4_applyMatrix4 } from "../../../core/geom/Vector4.js";
-import { v3_dot } from "../../../core/geom/Vector3.js";
+import { v3_dot } from "../../../core/geom/v3_dot.js";
 
 const v4 = [];
 

package/engine/grid/components/GridObstacle.js

@@ -8,6 +8,7 @@ import { computeHashIntegerArray } from "../../../core/math/MathUtils.js";
 import { assert } from "../../../core/assert.js";
 import { BinaryClassSerializationAdapter } from "../../ecs/storage/binary/BinaryClassSerializationAdapter.js";
 import { computeIntegerArrayHash } from "../../../core/primitives/array/computeIntegerArrayHash.js";
+import { isArrayEqualStrict } from "../../../core/collection/array/isArrayEqualStrict.js";
 
 class GridObstacle {
     constructor() {
@@ -236,15 +237,7 @@ class GridObstacle {
             return false;
         }
 
-        const dataSize = this.size.x * this.size.y;
-
-        for (let i = 0; i < dataSize; i++) {
-            if (this.data[i] !== other.data[i]) {
-                return false;
-            }
-        }
-
-        return true;
+        return isArrayEqualStrict(this.data, other.data);
     }
 }
 

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

@@ -4,7 +4,7 @@
 
 
 import { line3_computeSegmentPointDistance_sqr } from "../../../../core/geom/LineSegment.js";
-import Vector3, { v3_distance } from "../../../../core/geom/Vector3.js";
+import Vector3 from "../../../../core/geom/Vector3.js";
 
 import { CatmullRomCurve3 } from "three";
 import { clamp } from "../../../../core/math/clamp.js";
@@ -17,6 +17,7 @@ import { max2 } from "../../../../core/math/max2.js";
 import { min2 } from "../../../../core/math/min2.js";
 import { computeNonuniformCatmullRomSplineSample } from "./computeNonuniformCatmullRomSplineSample.js";
 import { InterpolationType } from "./InterpolationType.js";
+import { v3_distance } from "../../../../core/geom/v3_distance.js";
 
 const v3_a = new Vector3();
 const v3_b = new Vector3();

package/engine/network/convertPathToURL.js

@@ -68,8 +68,8 @@ export function convertPathToURL(path) {
         */
 
         if (pathname.endsWith('/')) {
-            //path is to a directory
-            directoryPath = pathname;
+            //path is to a directory, strip last slash
+            directoryPath = pathname.substring(0, pathname.length - 1);
         } else {
             //path is to a file
             const i = pathname.lastIndexOf('/');

package/engine/reference/v2/Reference.js

@@ -81,3 +81,9 @@ export class Reference {
         this.__onReleased.send1(this);
     }
 }
+
+/**
+ * @readonly
+ * @type {Readonly<Reference>}
+ */
+Reference.NULL = Object.freeze(new Reference());

package/generation/filtering/numeric/complex/CellFilterAngleToNormal.js

@@ -1,6 +1,7 @@
 import { CellFilter } from "../../CellFilter.js";
-import Vector3, { v3_angleBetween } from "../../../../core/geom/Vector3.js";
+import Vector3 from "../../../../core/geom/Vector3.js";
 import { assert } from "../../../../core/assert.js";
+import { v3_angle_between } from "../../../../core/geom/v3_angle_between.js";
 
 /**
  * Builds surface normal of another filter, and then computes the angle to a fixed 3d vector
@@ -70,7 +71,7 @@ export class CellFilterAngleToNormal extends CellFilter {
 
         const reference = this.reference;
 
-        const angle = v3_angleBetween(reference.x, reference.y, reference.z, _x, _y, _z);
+        const angle = v3_angle_between(reference.x, reference.y, reference.z, _x, _y, _z);
 
         return angle;
     }

package/generation/markers/GridCellActionPlaceMarker.js

@@ -36,6 +36,12 @@ export class GridCellActionPlaceMarker extends GridCellAction {
          */
         this.transformers = [];
 
+        /**
+         *
+         * @type {number}
+         */
+        this.priority = 0;
+
         /**
          *
          * @type {Vector2}
@@ -91,6 +97,7 @@ export class GridCellActionPlaceMarker extends GridCellAction {
      * @param {string[]} [tags]
      * @param {Transform} [transform]
      * @param {*} [properties]
+     * @param priority
      * @return {GridCellActionPlaceMarker}
      */
     static from({
@@ -99,7 +106,8 @@ export class GridCellActionPlaceMarker extends GridCellAction {
                     transformers = [],
                     tags = [],
                     transform,
-                    properties
+                    properties,
+                    priority = 0
                 }) {
 
         assert.typeOf(type, 'string', 'type');
@@ -125,6 +133,8 @@ export class GridCellActionPlaceMarker extends GridCellAction {
             r.properties = properties;
         }
 
+        r.priority = priority;
+
         return r;
     }
 
@@ -183,6 +193,8 @@ export class GridCellActionPlaceMarker extends GridCellAction {
         //write properties
         Object.assign(node.properties, this.properties);
 
+        node.priority = this.priority;
+
         //apply transformations
         const transformers = this.transformers;
         const transformerCount = transformers.length;

package/generation/markers/MarkerNode.js

@@ -5,6 +5,12 @@ import { circleIntersectsCircle } from "../../core/geom/2d/circle/circleIntersec
 
 export class MarkerNode {
     constructor() {
+        /**
+         * Processing order, higher priority nodes are processed first
+         * @type {number}
+         */
+        this.priority = 0;
+
         /**
          *
          * @type {String}

package/generation/theme/ThemeEngine.js

@@ -337,7 +337,7 @@ export class ThemeEngine {
             const source_x = u * weights.width;
 
 
-            weights.sampleBilinear(source_x, source_y, weightSample);
+            weights.sampleBilinear(source_x, source_y, weightSample, 0);
 
             for (let i = 0; i < layer_count; i++) {
                 const targetAddress = (y * splatWidth + x) + i * splatLayerSize;
@@ -451,6 +451,9 @@ export class ThemeEngine {
         return new Task({
             initializer() {
                 grid.markers.getRawData(nodes);
+
+                // sort nodes by priority
+                nodes.sort((a, b) => b.priority - a.priority);
             },
             cycleFunction
         });

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.33.19",
+  "version": "2.33.23",
   "dependencies": {
     "fast-levenshtein": "2.0.6",
     "opentype.js": "1.3.3",
     "simplex-noise": "2.4.0",
-    "three": "0.132.2"
+    "three": "^0.132.2"
   },
   "devDependencies": {
     "babel-jest": "^26.6.3",
-    "@types/three": "0.132.2"
+    "@types/three": "^0.132.2"
   }
 }

package/view/View.js

@@ -677,10 +677,12 @@ class View {
 
         const classesToRemove = [];
 
-        for (let i = 0; i < classList.length; i++) {
+        const initial_class_count = classList.length;
+
+        for (let i = 0; i < initial_class_count; i++) {
             const className = classList[i];
 
-            if (className.startsWith('locale-')) {
+            if (className.search(rx) !== -1) {
                 classesToRemove.push(className);
             }
         }