@woosh/meep-engine 2.33.60 → 2.33.64

package/engine/ecs/team/Team.js

@@ -0,0 +1,82 @@
+/**
+ * Created by Alex on 13/04/2016.
+ */
+import ObservedInteger from "../../../core/model/ObservedInteger.js";
+import { BinaryClassSerializationAdapter } from "../storage/binary/BinaryClassSerializationAdapter.js";
+
+class Team extends ObservedInteger {
+    /**
+     *
+     * @param value
+     * @constructor
+     */
+    constructor(value = 0) {
+        super(value);
+    }
+
+    clone() {
+        return new Team(this.getValue());
+    }
+
+    /**
+     *
+     * @param {object} json
+     * @returns {Team}
+     */
+    static fromJSON(json) {
+        const t = new Team();
+
+        t.fromJSON(json);
+
+        return t;
+    }
+}
+
+Team.typeName = "Team";
+
+
+export default Team;
+
+export class TeamSerializationAdapter extends BinaryClassSerializationAdapter{
+    constructor(){
+        super();
+
+        this.klass = Team;
+        this.version = 0;
+    }
+
+    /**
+     *
+     * @param {BinaryBuffer} buffer
+     * @param {Team} value
+     */
+    serialize(buffer, value) {
+        const v = value.getValue();
+
+        if (v === Infinity) {
+            buffer.writeInt32(2147483647);
+        } else if (v === -Infinity) {
+            buffer.writeInt32(-2147483648);
+        } else {
+            //TODO it's possible to write encoded Infinity values by accident
+            buffer.writeInt32(v);
+        }
+    }
+
+    /**
+     *
+     * @param {BinaryBuffer} buffer
+     * @param {Team} value
+     */
+    deserialize(buffer, value) {
+        const v = buffer.readInt32();
+
+        if (v === 2147483647) {
+            value.set(Infinity);
+        } else if (v === -2147483648) {
+            value.set(-Infinity);
+        } else {
+            value.set(v);
+        }
+    }
+}

package/engine/ecs/terrain/ecs/ClingToTerrainSystem.js

@@ -9,13 +9,13 @@ import { Transform } from '../../transform/Transform.js';
 import ClingToTerrain from './ClingToTerrain.js';
 
 import Vector3 from '../../../../core/geom/Vector3.js';
-import { obtainTerrain } from "../../../../../model/game/scenes/SceneUtils.js";
 import Quaternion from "../../../../core/geom/Quaternion.js";
-import { EPSILON} from "../../../../core/math/MathUtils.js";
+import { EPSILON } from "../../../../core/math/MathUtils.js";
 import { Matrix4 } from "three";
 import { assert } from "../../../../core/assert.js";
 import { SurfacePoint3 } from "../../../../core/geom/3d/SurfacePoint3.js";
 import { Deque } from "../../../../core/collection/queue/Deque.js";
+import { obtainTerrain } from "../util/obtainTerrain.js";
 
 
 /**

package/engine/ecs/terrain/ecs/Terrain.js

@@ -909,7 +909,7 @@ class Terrain {
 
         worker.setHeightSampler(s.data, s.itemSize, s.width, s.height);
 
-        worker.computeHeightRange()
+       return worker.computeHeightRange()
             .then(({ min, max }) => {
                 this.tiles.setHeightRange(min, max);
             });
@@ -1038,13 +1038,22 @@ class Terrain {
             heightSampler: this.samplerHeight
         });
 
+
         const result = promise.then(() => {
 
-            this.material.aoMap = true;
-            this.material.needsUpdate = true;
+            const ref = this.__material_reference;
+
+            let mat = this.material;
+
+            if (ref !== null && ref.getValue() !== null) {
+                mat = ref.getValue();
+            }
+
+            mat.aoMap = true;
+            mat.needsUpdate = true;
 
-            this.material.uniforms.aoMap.value = texture;
-            this.material.uniforms.aoMapIntensity.value = 0.7;
+            mat.uniforms.aoMap.value = texture;
+            mat.uniforms.aoMapIntensity.value = 0.7;
 
             return texture;
         });

package/engine/ecs/terrain/util/loadVisibleTerrainTiles.js

@@ -0,0 +1,112 @@
+import TopDownCameraControllerSystem from "../../../graphics/ecs/camera/topdown/TopDownCameraControllerSystem.js";
+import { Camera } from "../../../graphics/ecs/camera/Camera.js";
+import { obtainTerrain } from "./obtainTerrain.js";
+import { assert } from "../../../../core/assert.js";
+import TerrainSystem from "../ecs/TerrainSystem.js";
+import Task from "../../../../core/process/task/Task.js";
+import TaskSignal from "../../../../core/process/task/TaskSignal.js";
+
+/**
+ *
+ * @param {EntityManager} em
+ * @param {EntityComponentDataset} ecd
+ * @returns {Task}
+ */
+export function loadVisibleTerrainTiles(em, ecd) {
+
+    let totalTiles = 0;
+    let loadedTiles = 0;
+    let failedTiles = 0;
+
+    let attempt = 0;
+
+    let failureFlag = false;
+
+    function init() {
+        const attemptId = attempt;
+
+        //force update by camera controller, to ensure correct focus is set
+        em.getSystem(TopDownCameraControllerSystem).update(0);
+
+        ecd.traverseComponents(Camera, function (c) {
+            c.updateMatrices();
+        });
+
+        const tiles = [];
+
+        const terrain = obtainTerrain(ecd);
+
+        assert.notEqual(terrain, null, 'terrain not found');
+
+        TerrainSystem.traverseVisibleTiles(ecd, terrain, function (tile) {
+            tiles.push(tile);
+        });
+
+        totalTiles = tiles.length;
+        const tileManager = terrain.tiles;
+
+        function handleObtainedTile(t) {
+            if (attemptId !== attempt) {
+                return;
+            }
+
+            loadedTiles++;
+        }
+
+        function handleFailedTile(t) {
+            if (attemptId !== attempt) {
+                return;
+            }
+
+            attempt++;
+
+            failedTiles++;
+
+            if (attempt < 10) {
+                init();
+            } else {
+                failureFlag = true;
+            }
+        }
+
+        if (totalTiles !== 0) {
+            tiles.forEach(function (tile) {
+                tileManager.obtain(tile.gridPosition.x, tile.gridPosition.y).then(handleObtainedTile, handleFailedTile);
+            });
+        }
+    }
+
+    const task = new Task({
+        name: "Building visible terrain tiles",
+
+        initializer: init,
+
+        cycleFunction() {
+            if (failureFlag) {
+                return TaskSignal.EndFailure;
+            }
+
+            if (loadedTiles >= totalTiles) {
+                return TaskSignal.EndSuccess;
+            } else {
+                return TaskSignal.Yield;
+            }
+        },
+
+        computeProgress() {
+            if (totalTiles === 0) {
+                return 0;
+            }
+
+            const f = loadedTiles / totalTiles;
+
+            if (f >= 1) {
+                return 1;
+            }
+
+            return f;
+        }
+    });
+
+    return task;
+}

package/engine/ecs/terrain/util/obtainTerrain.js

@@ -0,0 +1,23 @@
+import { assert } from "../../../../core/assert.js";
+import Terrain from "../ecs/Terrain.js";
+
+/**
+ *
+ * @param {EntityComponentDataset} ecd
+ * @param {function(terrain:Terrain,entity:number)} [callback]
+ * @returns {Terrain|null}
+ */
+export function obtainTerrain(ecd, callback) {
+    assert.notEqual(ecd, null, 'ecd is null');
+    assert.notEqual(ecd, undefined, 'ecd is undefined');
+
+    const object = ecd.getAnyComponent(Terrain);
+
+    const terrain = object.component;
+
+    if (terrain !== null && typeof callback === "function") {
+        callback(terrain, object.entity);
+    }
+
+    return terrain;
+}

package/engine/ecs/tooltip/TooltipComponentSystem.js

@@ -2,10 +2,10 @@ import { System } from "../System.js";
 import { TooltipComponent } from "./TooltipComponent.js";
 import Vector3 from "../../../core/geom/Vector3.js";
 import { MeshSystem } from "../../graphics/ecs/mesh/MeshSystem.js";
-import { modelHitTest } from "../../../../model/game/util/ScreenGridPicker.js";
 import { SurfacePoint3 } from "../../../core/geom/3d/SurfacePoint3.js";
 import { VisualTip } from "../../../view/tooltip/VisualTip.js";
 import Rectangle from "../../../core/geom/Rectangle.js";
+import { modelHitTest } from "../../graphics/util/modelHitTest.js";
 
 const ray_source = new Vector3();
 const ray_direction = new Vector3();

package/engine/graphics/GraphicsEngine.js

@@ -585,6 +585,7 @@ GraphicsEngine.prototype.renderOpaque = function () {
 GraphicsEngine.prototype.renderTransparent = function () {
     const scene = this.scene;
 
+    // clear background, as transparent pass is drawn on top, the background should already be composited
     const _background = scene.background;
     scene.background = null;
 
@@ -596,8 +597,6 @@ GraphicsEngine.prototype.renderTransparent = function () {
 
     // restore background
     scene.background = _background;
-
-    // TODO render transparent objects into a buffer, to be able to apply post-fx
 };
 
 /**

package/engine/graphics/camera/testClippingPlaneComputation.js

@@ -8,8 +8,6 @@ import PathFollowingSystem from "../../navigation/ecs/path_following/PathFollowi
 import SteeringSystem from "../../ecs/systems/SteeringSystem.js";
 import MotionSystem from "../../ecs/systems/MotionSystem.js";
 import TagSystem from "../../ecs/systems/TagSystem.js";
-import { AttachmentSocketsSystem } from "../../ecs/sockets/AttachmentSocketsSystem.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";
@@ -84,8 +82,6 @@ function makeConfig(engine) {
         new SteeringSystem(),
         new MotionSystem(),
         new TagSystem(),
-        new AttachmentSocketsSystem(),
-        new AttachmentSystem(),
         new SoundEmitterSystem(assetManager, sound.destination, sound.context),
         new SoundControllerSystem(),
         new SoundListenerSystem(sound.context),

package/engine/graphics/ecs/camera/topdown/TopDownCameraLanderSystem.js

@@ -2,11 +2,11 @@ import { clamp } from "../../../../../core/math/clamp.js";
 import { System } from "../../../../ecs/System.js";
 import { TopDownCameraLander } from "./TopDownCameraLander.js";
 import { Cache } from "../../../../../core/cache/Cache.js";
-import { obtainTerrain } from "../../../../../../model/game/scenes/SceneUtils.js";
 import { buildCameraTargetSampler } from "../../../../input/ecs/util/TerrainCameraTargetSampler.js";
 import TopDownCameraController from "./TopDownCameraController.js";
 import Vector2 from "../../../../../core/geom/Vector2.js";
 import { SignalBinding } from "../../../../../core/events/signal/SignalBinding.js";
+import { obtainTerrain } from "../../../../ecs/terrain/util/obtainTerrain.js";
 
 
 /**

package/engine/graphics/ecs/light/LightSystem.js

@@ -26,7 +26,7 @@ class LightSystem extends AbstractContextSystem {
      * @param settings
      * @constructor
      */
-    constructor(engine, settings) {
+    constructor(engine, settings = {}) {
         super(LightContext);
 
         /**

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

@@ -39,6 +39,35 @@ export class ShadedGeometry {
          * @private
          */
         this.__bvh_leaf = new LeafNode(this, 0, 0, 0, 0, 0, 0);
+
+        /**
+         * Transient, assigned in the system
+         * @type {number}
+         * @private
+         */
+        this.__entity = -1;
+        /**
+         * Transform matrix
+         * Transient, assigned in the system
+         * @type {number[]|null}
+         * @private
+         */
+        this.__transform = null;
+    }
+
+    /**
+     * Global transform matrix
+     * 4x4 matrix
+     * @return {null|number[]}
+     */
+    get transform() {
+        if (this.__transform !== null) {
+            return this.__transform;
+        } else if (this.__cached_object !== null) {
+            return this.__cached_object.matrix.elements;
+        } else {
+            return null;
+        }
     }
 
     __build_object() {

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

@@ -1,6 +1,27 @@
 import { ShadedGeometry } from "./ShadedGeometry.js";
 import { Transform } from "../../../ecs/transform/Transform.js";
 import { System } from "../../../ecs/System.js";
+import { intersectRay } from "../../../../core/bvh2/aabb3/AABB3Math.js";
+import { GeometrySpatialQueryAccelerator } from "../../geometry/buffered/query/GeometrySpatialQueryAccelerator.js";
+import { SurfacePoint3 } from "../../../../core/geom/3d/SurfacePoint3.js";
+import { v3_distance_sqr } from "../../../../core/geom/v3_distance_sqr.js";
+import { mat4 } from "gl-matrix";
+import { returnTrue } from "../../../../core/function/Functions.js";
+
+const traversal_stack = [];
+let traversal_cursor = 0;
+
+/**
+ *
+ * @type {SurfacePoint3}
+ */
+const scratch_point = new SurfacePoint3();
+
+/**
+ *
+ * @type {Float32Array|mat4}
+ */
+const scratch_m4 = new Float32Array(16);
 
 export class ShadedGeometrySystem extends System {
     /**
@@ -49,7 +70,12 @@ export class ShadedGeometrySystem extends System {
 
         sg.applyTransform(t);
 
-        this.__render_layer.bvh.insertNode(sg.bvh);
+        const leaf_node = sg.bvh;
+
+        // remember entity for lookups
+        sg.__entity = entity;
+
+        this.__render_layer.bvh.insertNode(leaf_node);
     }
 
     /**
@@ -65,4 +91,135 @@ export class ShadedGeometrySystem extends System {
 
         sg.bvh.disconnect();
     }
+
+    /**
+     *
+     * @param {SurfacePoint3} contact
+     * @param {number} origin_x
+     * @param {number} origin_y
+     * @param {number} origin_z
+     * @param {number} direction_x
+     * @param {number} direction_y
+     * @param {number} direction_z
+     * @param {function(entity:number, mesh:ShadedGeometry)} [filter_function]
+     * @param {*} [filter_function_context]
+     * @returns {{entity:number, mesh:ShadedGeometry}|undefined}
+     */
+    raycastNearest(
+        contact,
+        origin_x, origin_y, origin_z,
+        direction_x, direction_y, direction_z,
+        filter_function = returnTrue, filter_function_context
+    ) {
+        const root_bvh = this.__render_layer.bvh;
+        const stack_frame_address = traversal_cursor;
+
+        traversal_stack[traversal_cursor++] = root_bvh;
+
+        let best_distance = Infinity;
+        let found_hit = false;
+        let best_result = null;
+
+        while (traversal_cursor > stack_frame_address) {
+            traversal_cursor--;
+
+            /**
+             *
+             * @type {BinaryNode|LeafNode<ShadedGeometry>}
+             */
+            const node = traversal_stack[traversal_cursor];
+
+            // test node against the ray
+            const intersects = intersectRay(
+                node.x0, node.y0, node.z0,
+                node.x1, node.y1, node.z1,
+                origin_x, origin_y, origin_z,
+                direction_x, direction_y, direction_z
+            );
+
+            if (!intersects) {
+                continue;
+            }
+
+            if (node.isBinaryNode) {
+                if (node.right !== null) {
+                    traversal_stack[traversal_cursor++] = node.right;
+                }
+                if (node.left !== null) {
+                    traversal_stack[traversal_cursor++] = node.left;
+                }
+            } else {
+                // leaf node
+
+                /**
+                 *
+                 * @type {ShadedGeometry}
+                 */
+                const sg = node.object;
+
+                const entity = sg.__entity;
+
+                if (!filter_function.call(filter_function_context, entity, sg)) {
+                    // filtered out
+                    continue;
+                }
+
+                const m4 = sg.transform;
+
+                // get transform in local space
+                mat4.invert(scratch_m4, m4);
+
+                // transform ray to local space
+                const local_origin_x = scratch_m4[0] * origin_x + scratch_m4[4] * origin_y + scratch_m4[8] * origin_z + scratch_m4[12];
+                const local_origin_y = scratch_m4[1] * origin_x + scratch_m4[5] * origin_y + scratch_m4[9] * origin_z + scratch_m4[13];
+                const local_origin_z = scratch_m4[2] * origin_x + scratch_m4[6] * origin_y + scratch_m4[10] * origin_z + scratch_m4[14];
+
+                const local_direction_x = scratch_m4[0] * direction_x + scratch_m4[4] * direction_y + scratch_m4[8] * direction_z;
+                const local_direction_y = scratch_m4[1] * direction_x + scratch_m4[5] * direction_y + scratch_m4[9] * direction_z;
+                const local_direction_z = scratch_m4[2] * direction_x + scratch_m4[6] * direction_y + scratch_m4[10] * direction_z;
+                // NOTE: direction is not normalized
+
+                const geometry_hit_found = GeometrySpatialQueryAccelerator.INSTANCE.queryRaycastNearest_primitive(
+                    scratch_point,
+                    sg.geometry,
+                    local_origin_x, local_origin_y, local_origin_z,
+                    local_direction_x, local_direction_y, local_direction_z
+                );
+
+                if (!geometry_hit_found) {
+                    continue;
+                }
+
+                // transform hit contact into global space
+                scratch_point.applyMatrix4(m4);
+
+                found_hit = true;
+
+                const hit_position = scratch_point.position;
+
+                const distance_sqr = v3_distance_sqr(
+                    hit_position.x, hit_position.y, hit_position.z,
+                    origin_x, origin_y, origin_z
+                );
+
+                if (distance_sqr >= best_distance) {
+                    // further than best found
+                    continue;
+                }
+
+                contact.copy(scratch_point);
+                best_result = sg;
+            }
+        }
+
+        // drop stack frame
+        traversal_cursor = stack_frame_address;
+
+        if (found_hit) {
+            return {
+                entity: best_result.__entity,
+                mesh: best_result
+            };
+        }
+    }
 }

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

@@ -19,7 +19,6 @@ import PathFollowingSystem from "../../../navigation/ecs/path_following/PathFoll
 import SteeringSystem from "../../../ecs/systems/SteeringSystem.js";
 import MotionSystem from "../../../ecs/systems/MotionSystem.js";
 import TagSystem from "../../../ecs/systems/TagSystem.js";
-import { AttachmentSocketsSystem } from "../../../ecs/sockets/AttachmentSocketsSystem.js";
 import { AttachmentSystem } from "../../../ecs/attachment/AttachmentSystem.js";
 import { SoundEmitterSystem } from "../../../sound/ecs/emitter/SoundEmitterSystem.js";
 import SoundControllerSystem from "../../../sound/ecs/SoundControllerSystem.js";
@@ -95,7 +94,6 @@ function makeConfig(engine) {
         new SteeringSystem(),
         new MotionSystem(),
         new TagSystem(),
-        new AttachmentSocketsSystem(),
         new AttachmentSystem(),
         new SoundEmitterSystem(assetManager, sound.destination, sound.context),
         new SoundControllerSystem(),

package/engine/graphics/ecs/water/WaterSystem.js

@@ -8,10 +8,10 @@ import { LeafNode } from '../../../../core/bvh2/LeafNode.js';
 import { buildPlanarRenderLayerClipPlaneComputationMethod } from "../../render/layers/RenderLayerUtils.js";
 import ThreeFactory from "../../three/ThreeFactory.js";
 import { RenderPassType } from "../../render/RenderPassType.js";
-import { obtainTerrain } from "../../../../../model/game/scenes/SceneUtils.js";
 import { makeAlexWaterMaterial } from "../water2/shader/AlexWaterShader.js";
 import { threeUpdateTransform } from "../../util/threeUpdateTransform.js";
 import { StandardFrameBuffers } from "../../StandardFrameBuffers.js";
+import { obtainTerrain } from "../../../ecs/terrain/util/obtainTerrain.js";
 
 const WATER_SIZE = 800;
 

package/engine/graphics/ecs/water2/shader/testWaterShader.js

@@ -1,4 +1,3 @@
-import { obtainTerrain } from "../../../../../../model/game/scenes/SceneUtils.js";
 import { seededRandom } from "../../../../../core/math/random/seededRandom.js";
 import { EngineConfiguration } from "../../../../EngineConfiguration.js";
 import ScriptSystem from "../../../../ecs/systems/ScriptSystem.js";
@@ -28,6 +27,7 @@ import { EngineHarness } from "../../../../EngineHarness.js";
 import Vector2 from "../../../../../core/geom/Vector2.js";
 import Vector3 from "../../../../../core/geom/Vector3.js";
 import SimplexNoise from 'simplex-noise';
+import { obtainTerrain } from "../../../../ecs/terrain/util/obtainTerrain.js";
 
 const engineHarness = new EngineHarness();
 

package/engine/graphics/geometry/AttributeSpec.d.ts

@@ -0,0 +1,8 @@
+import {DataType} from "../../../core/parser/simple/DataType";
+
+export class AttributeSpec {
+    readonly name: string
+    readonly type: DataType
+    readonly itemSize: number
+    readonly normalized: boolean
+}

package/engine/graphics/geometry/VertexDataSpec.d.ts

@@ -0,0 +1,15 @@
+import {AttributeSpec} from "./AttributeSpec";
+
+export class VertexDataSpec {
+    readonly attributes: AttributeSpec[]
+
+    getAttributeByName(name: string): AttributeSpec | undefined
+
+    add(attribute: AttributeSpec): this
+
+    setAttributes(attributes: AttributeSpec[]): void
+
+    equals(other: VertexDataSpec): boolean
+
+    hash(): number
+}

package/engine/graphics/geometry/buffered/deinterleaveBufferAttribute.js

@@ -0,0 +1,39 @@
+import { BufferAttribute } from "three";
+
+
+/**
+ *
+ * @param {THREE.InterleavedBufferAttribute|THREE.BufferAttribute} source_attribute
+ * @returns {THREE.BufferAttribute}
+ */
+export function deinterleaveBufferAttribute(source_attribute) {
+    if (source_attribute.isInterleavedBufferAttribute !== true && source_attribute.isBufferAttribute) {
+        return source_attribute;
+    }
+
+    const source_data = source_attribute.data;
+    const source_data_array = source_data.array;
+    const stride = source_data.stride;
+
+    const item_count = source_attribute.count;
+    const itemSize = source_attribute.itemSize;
+    const array_size = item_count * itemSize;
+
+    const offset = source_attribute.offset;
+
+    const destination_array = new source_data_array.constructor(array_size);
+
+    const attribute = new BufferAttribute(destination_array, itemSize);
+
+    attribute.normalized = source_attribute.normalized;
+    attribute.name = source_attribute.name;
+
+    // copy data
+    for (let i = 0; i < item_count; i++) {
+        for (let j = 0; j < itemSize; j++) {
+            destination_array[i * itemSize + j] = source_data_array[i * stride + offset + j];
+        }
+    }
+
+    return attribute;
+}