@woosh/meep-engine 2.39.44 → 2.40.0

package/engine/ecs/terrain/tiles/TerrainTileManager.js

@@ -15,7 +15,6 @@ import { MeshPhongMaterial } from 'three';
 import { assert } from "../../../../core/assert.js";
 import { Color } from "../../../../core/color/Color.js";
 import { noop } from "../../../../core/function/Functions.js";
-import Vector3 from "../../../../core/geom/Vector3.js";
 import { SurfacePoint3 } from "../../../../core/geom/3d/SurfacePoint3.js";
 import { RaycastBVHVisitor } from "../../../../core/bvh2/traversal/RaycastBVHVisitor.js";
 import { FirstRayIntersectionTerrainBVHVisitor } from "./FirstRayIntersectionTerrainBVHVisitor.js";
@@ -24,6 +23,8 @@ import { aabb2_overlapExists } from "../../../../core/geom/AABB2.js";
 import ObservedInteger from "../../../../core/model/ObservedInteger.js";
 import { NumericInterval } from "../../../../core/math/interval/NumericInterval.js";
 import { randomFloatBetween } from "../../../../core/math/random/randomFloatBetween.js";
+import { mat4, vec3 } from "gl-matrix";
+import { isArrayEqualStrict } from "../../../../core/collection/array/isArrayEqualStrict.js";
 
 class TerrainTileManager {
     /**
@@ -105,7 +106,30 @@ class TerrainTileManager {
             this.traverse(this.assignTileMaterial, this);
         });
 
+        /**
+         *
+         * @type {Float32Array}
+         * @private
+         */
+        this.__transform = new Float32Array(16);
+
+    }
+
+    set transform(m4) {
+        if (isArrayEqualStrict(m4, this.__transform)) {
+            // no change
+            return;
+        }
+
+        mat4.copy(this.__transform, m4);
+
+        this.traverse(t => {
+            t.transform = m4;
+        });
+    }
 
+    get transform() {
+        return this.__transform;
     }
 
     /**
@@ -156,74 +180,6 @@ class TerrainTileManager {
         this.initializeTiles();
     }
 
-    /**
-     *
-     * @param {Vector3} origin
-     * @param {Vector3} direction
-     * @param {function} callback
-     * @param {function} missCallback
-     */
-    raycast(origin, direction, callback, missCallback) {
-        assert.typeOf(callback, 'function', 'callback');
-        assert.typeOf(missCallback, 'function', 'missCallback');
-
-        let bestHit = null;
-        let bestNormal = null;
-        let bestGeometry = null;
-        let bestDistanceSqr = Number.POSITIVE_INFINITY;
-
-        let firstStageOver = false;
-
-        let tileCount = 0;
-
-        function tryReturn() {
-            if (tileCount === 0 && firstStageOver) {
-                callback(bestHit, bestNormal, bestGeometry);
-            }
-        }
-
-        function registerHit(hit, normal, geo) {
-            const d = hit.distanceSqrTo(origin);
-            if (d < bestDistanceSqr) {
-                bestDistanceSqr = d;
-                bestHit = hit;
-                bestNormal = normal;
-                bestGeometry = geo;
-            }
-        }
-
-
-        /**
-         *
-         * @param {TerrainTile} tile
-         */
-        function doCast(tile) {
-
-            tile.raycast(origin, direction, registerHit, missCallback);
-            tileCount--;
-            tryReturn();
-        }
-
-        this.bvh.traverseRayLeafIntersections(origin.x, origin.y, origin.z, direction.x, direction.y, direction.z, function (leaf) {
-            /**
-             *
-             * @type {TerrainTile}
-             */
-            const tile = leaf.object;
-
-            tileCount++;
-
-            if (tile.isBuilt) {
-                doCast(tile);
-            } else {
-                tile.onBuilt.addOne(doCast);
-            }
-        });
-
-        firstStageOver = true;
-        tryReturn();
-    }
-
     /**
      *
      * @param {TerrainTile} tile
@@ -378,7 +334,8 @@ class TerrainTileManager {
                 tile.scale.copy(this.scale);
                 tile.resolution.copy(this.resolution);
 
-                tile.createInitialBounds(this.heightRange.min, this.heightRange.max);
+                tile.setInitialHeightBounds(this.heightRange.min, this.heightRange.max);
+                tile.computeBoundingBox();
 
                 //hook for building
                 tile.ensureBuilt = ensureBuilt(x, y);
@@ -397,11 +354,8 @@ class TerrainTileManager {
      * @returns {number}
      */
     computeTileIndex(x, y) {
-        assert.ok(Number.isInteger(x), `x must be an integer, instead was ${x}`);
-        assert.ok(Number.isInteger(y), `x must be an integer, instead was ${y}`);
-
-        assert.ok(x >= 0, `x(=${x}) must be greater or equal to 0`);
-        assert.ok(y >= 0, `y(=${y}) must be greater or equal to 0`);
+        assert.isNonNegativeInteger(x, 'x');
+        assert.isNonNegativeInteger(y, 'y');
 
         const w = Math.ceil(this.totalSize.x / this.tileSize.x);
 
@@ -415,9 +369,16 @@ class TerrainTileManager {
      *
      * @param {number} x
      * @param {number} y
-     * @returns {TerrainTile}
+     * @returns {TerrainTile|undefined}
      */
     getRaw(x, y) {
+        if (
+            x < 0
+            || x >= Math.ceil(this.totalSize.x / this.tileSize.x)
+            || y < 0
+        ) {
+            return undefined;
+        }
 
         const tileIndex = this.computeTileIndex(x, y);
 
@@ -442,6 +403,43 @@ class TerrainTileManager {
         return this.getRaw(tileX, tileY);
     }
 
+    /**
+     * Given world coordinates in top-down plane, where X runs along X axis and Y runs along Z axis, returns terrain tile that overlaps that 2d region
+     * @param {number} x
+     * @param {number} y
+     * @return {TerrainTile|undefined}
+     */
+    getTileByWorldPosition2D(x, y) {
+        const v3 = vec3.fromValues(x, 0, y);
+
+        const world_inverse = mat4.create();
+
+        mat4.invert(world_inverse, this.transform);
+
+
+        vec3.transformMat4(v3, v3, world_inverse);
+
+        return this.getRawTileByPosition(v3.x, v3.z);
+    }
+
+    /**
+     * Builds and returns the tile from world coordinates
+     * @param {number} x
+     * @param {number} y
+     * @returns {Promise<TerrainTile>}
+     */
+    obtainTileAtWorldPosition2D(x, y) {
+        const tile = this.getTileByWorldPosition2D(x, y);
+
+        return this.obtain(tile.gridPosition.x, tile.gridPosition.y);
+    }
+
+    /**
+     * @deprecated use {@link #obtain instead}
+     * @param {number} x
+     * @param {number} y
+     * @param {function(TerrainTile):*} callback
+     */
     processTile(x, y, callback) {
         const tile = this.getRaw(x, y);
 
@@ -454,9 +452,10 @@ class TerrainTileManager {
 
     /**
      *
-     * @param {int} x
-     * @param {int} y
-     * @returns {Promise}
+     * @param {number} x coordinate
+     * @param {number} y coordinate
+     * @returns {Promise<TerrainTile>}
+     * @throws if no tile exists at given coordinates
      */
     obtain(x, y) {
         const tile = this.getRaw(x, y);
@@ -490,6 +489,10 @@ class TerrainTileManager {
      * @param {TerrainTile} tile
      */
     release(tile) {
+        if (tile.referenceCount <= 0) {
+            console.warn('Tile already has no references');
+        }
+
         tile.referenceCount--;
 
         if (tile.referenceCount <= 0) {
@@ -497,7 +500,7 @@ class TerrainTileManager {
             tile.dispose();
         }
 
-
+        // TODO check tile.isBuilt flag
         tile.onDestroyed.send1(tile);
     }
 
@@ -512,9 +515,17 @@ class TerrainTileManager {
         }
     }
 
+    /**
+     *
+     * @param {number} x
+     * @param {number} y
+     * @param {TerrainTile} tile
+     */
     stitchTile(x, y, tile) {
 
-        const gridSize = this.totalSize.clone().divide(this.tileSize).floor();
+        const gridSize = this.totalSize.clone();
+        gridSize.divide(this.tileSize);
+        gridSize.floor();
 
         const self = this;
         //normal stitching
@@ -569,6 +580,7 @@ class TerrainTileManager {
         directionZ
     ) {
 
+        // console.log('+ raycastFirstSync');
         raycastBVHVisitor.collector = firstRayIntersectionTerrainBVHVisitor;
         raycastBVHVisitor.setOrigin(originX, originY, originZ);
         raycastBVHVisitor.setDirection(directionX, directionY, directionZ);
@@ -579,6 +591,8 @@ class TerrainTileManager {
 
         traverseBinaryNodeUsingVisitor(this.bvh, raycastBVHVisitor);
 
+        // console.log('- raycastFirstSync');
+
         if (firstRayIntersectionTerrainBVHVisitor.closestDistance !== Number.POSITIVE_INFINITY) {
             result.copy(firstRayIntersectionTerrainBVHVisitor.closest);
 
@@ -588,41 +602,6 @@ class TerrainTileManager {
         return false;
     }
 
-    raycastVertical(x, y, successCallback, missCallback) {
-        assert.typeOf(missCallback, 'function', 'missCallback');
-
-        /**
-         *
-         * @param {TerrainTile} tile
-         */
-        function doCast(tile) {
-            tile.raycastVertical(x, y, successCallback, missCallback);
-        }
-
-
-        let miss = true;
-
-        this.bvh.traverseRayLeafIntersections(x, -10000, y, 0, 1, 0, function (leaf) {
-            /**
-             *
-             * @type {TerrainTile}
-             */
-            const tile = leaf.object;
-
-            miss = false;
-
-            if (tile.isBuilt) {
-                doCast(tile);
-            } else {
-                tile.onBuilt.addOne(doCast);
-            }
-        });
-
-        if (miss) {
-            missCallback();
-        }
-    }
-
     /**
      * TODO untested
      * @param {SurfacePoint3} contact
@@ -631,7 +610,10 @@ class TerrainTileManager {
      * @return {boolean}
      */
     raycastVerticalFirstSync(contact, x, y) {
-        return this.raycastFirstSync(contact, x, -10000, y, 0, 1, 0);
+        // console.log('+ raycastVerticalFirstSync');
+        const r = this.raycastFirstSync(contact, x, -10000, y, 0, 1, 0);
+        // console.log('- raycastVerticalFirstSync');
+        return r;
     }
 
     /**
@@ -697,14 +679,11 @@ class TerrainTileManager {
 
             // console.timeEnd(processName);
 
-            self.on.tileBuilt.dispatch(tile);
+            self.on.tileBuilt.send1(tile);
         }, reject);
     }
 }
 
-const v3_origin = new Vector3();
-const v3_direction = new Vector3();
-
 const raycastBVHVisitor = new RaycastBVHVisitor();
 const firstRayIntersectionTerrainBVHVisitor = new FirstRayIntersectionTerrainBVHVisitor();
 

package/engine/graphics/ecs/camera/Camera.js

@@ -33,7 +33,7 @@ export class Camera {
          * Whether clipping planes should be automatically calculated or not
          * @type {boolean}
          */
-        this.autoClip = true;
+        this.autoClip = false;
 
         /**
          * Tunable parameter to prevent clipping planes from thrashing. Clipping planes must move by a certain portion of the current span before frustum gets shrunken

package/engine/graphics/ecs/light/binding/fp/FPLightBinding.js

@@ -9,11 +9,11 @@ export class FPLightBinding extends LightBinding {
     }
 
     /**
-     *
+     * @param {LightContext} ctx
      * @return {ForwardPlusRenderingPlugin}
      * @private
      */
-    get __plugin(){
+    getPlugin(ctx) {
         return ctx.system.__plugin.getValue();
     }
 
@@ -22,7 +22,7 @@ export class FPLightBinding extends LightBinding {
          *
          * @type {ForwardPlusRenderingPlugin}
          */
-        const fp = this.__plugin;
+        const fp = this.getPlugin(ctx);
 
         const lightManager = fp.getLightManager();
 
@@ -52,7 +52,7 @@ export class FPLightBinding extends LightBinding {
          *
          * @type {ForwardPlusRenderingPlugin}
          */
-        const fp = this.__plugin;
+        const fp = this.getPlugin(ctx);
 
         const lightManager = fp.getLightManager();
 

package/engine/graphics/geometry/bvh/buffered/BVHGeometryRaycaster.js

@@ -71,25 +71,6 @@ function bindGeometryFaceNormal(indices, normals, index) {
     vNormal.set(nx, ny, nz);
 }
 
-function computeSampleFaceIndex(width, x, y) {
-
-    //get fraction of x and y
-    const xF = x % 1;
-    const yF = y % 1;
-
-    //get whole part of x and y
-    const xW = x | 0;
-    const yW = y | 0;
-
-    //figure out which quad it is in
-    const iQuad = yW * (width - 1) + xW;
-
-    //figure out triangle
-    const index = iQuad * 2 + ((xF + yF) | 0);
-
-    return index;
-}
-
 
 function extractFaceIndexFromLeaf_default(leaf) {
     return leaf.object;
@@ -172,65 +153,6 @@ export class BVHGeometryRaycaster {
         }
     }
 
-    /**
-     *
-     * @param {number} x
-     * @param {number} y
-     * @param callback
-     * @param missCallback
-     * @returns {boolean}
-     */
-    raycastVertical(x, y, callback, missCallback) {
-        const position = this.position;
-        const scale = this.scale;
-
-        //transform position to geometry coordinate system
-        const resolution = this.resolution;
-
-        const size = this.size;
-
-        const width = size.x * resolution;
-        const height = size.y * resolution;
-
-
-        const gX = ((x - position.x * scale.x) / scale.x) * resolution * ((width - 1) / width);
-        const gY = ((y - position.y * scale.y) / scale.y) * resolution * ((height - 1) / height);
-
-        const index = computeSampleFaceIndex(width, gX, gY);
-
-
-        const geometry = this.geometry;
-
-        const geometryIndices = geometry.getIndex().array;
-        const geometryVertices = geometry.getAttribute('position').array;
-        const geometryNormals = geometry.getAttribute('normal').array;
-
-
-        if (index * 3 >= geometryIndices.length) {
-            missCallback();
-            return false;
-        }
-
-        bindGeometryFace(geometryIndices, geometryVertices, index);
-
-
-        this.direction.set(0, -1, 0);
-        this.origin.set(x, 1000, y);
-
-        const hitFound = rayTriangleIntersection(hit, this.origin, this.direction, vA, vB, vC);
-
-        if (!hitFound) {
-            missCallback();
-            return false;
-        }
-
-        bindGeometryFaceNormal(geometryIndices, geometryNormals, index);
-
-        callback(hit, vNormal, geometry);
-
-        return true;
-    }
-
     /**
      *
      * @param {SurfacePoint3} hit

package/engine/graphics/geometry/optimization/merge/merge_geometry_hierarchy.js

@@ -6,8 +6,6 @@ import { array_copy } from "../../../../../core/collection/array/copyArray.js";
 import { mat4 } from "gl-matrix";
 import { Group, Matrix4, Mesh } from "three";
 import { mergeBufferGeometries } from "three/examples/jsm/utils/BufferGeometryUtils.js";
-import { groupArrayBy } from "../../../../../core/collection/ArrayUtils.js";
-import { collectIteratorValueToArray } from "../../../../../core/collection/IteratorUtils.js";
 
 class GeometryContext {
     constructor() {
@@ -299,13 +297,6 @@ export function merge_geometry_hierarchy(input, context = new Context()) {
         }
     });
 
-    const materials = collectIteratorValueToArray([], material_cache.materialCache.data.keys());
-
-    const color_groups = groupArrayBy(materials, (m => m.color.getHex()));
-
-    console.warn(color_groups);
-
-
     const contexts_merge_stage_0 = [];
 
     merge_by_material(contexts, contexts_merge_stage_0, 0);

package/engine/graphics/render/forward_plus/prototype/prototypeLightManager.js

@@ -1295,9 +1295,9 @@ function draw_camera_view_planes() {
 
 // prepare_scene_2();
 // prepare_scene_decal_0();
-// prepare_scene_decal_1();
+prepare_scene_decal_1();
 // prepare_scene_9();
-prepare_scene_2();
+// prepare_scene_2();
 // prepare_scene_0();
 animate();
 

package/engine/intelligence/behavior/util/LogMessageBehavior.js

@@ -0,0 +1,29 @@
+import { Behavior } from "../Behavior.js";
+import { BehaviorStatus } from "../BehaviorStatus.js";
+
+/**
+ * Prints given message into the console
+ */
+export class LogMessageBehavior extends Behavior {
+    constructor(message = "") {
+        super();
+
+        this.message = message;
+    }
+
+    /**
+     *
+     * @param {String} message
+     * @return {LogMessageBehavior}
+     */
+    static from(message) {
+        return new LogMessageBehavior(message);
+    }
+
+    tick(timeDelta) {
+        console.log(this.message);
+
+        // done
+        return BehaviorStatus.Succeeded;
+    }
+}

package/package.json

@@ -5,7 +5,7 @@
   "productName": "Meep",
   "description": "production-ready JavaScript game engine based on Entity Component System Architecture",
   "author": "Alexander Goldring",
-  "version": "2.39.44",
+  "version": "2.40.0",
   "dependencies": {
     "gl-matrix": "3.4.3",
     "fast-levenshtein": "2.0.6",