@woosh/meep-engine 3.15.0 → 3.16.0

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

@@ -10,11 +10,15 @@ import { min2 } from "../../../../../core/math/min2.js";
 import { ResourceAccessKind } from "../../../../../core/model/ResourceAccessKind.js";
 import { ResourceAccessSpecification } from "../../../../../core/model/ResourceAccessSpecification.js";
 import { System } from '../../../System.js';
-import { Transform } from '../../../transform/Transform.js';
+import { Transform64 } from '../../../transform/Transform64.js';
 import { obtainTerrain } from "../../util/obtainTerrain.js";
 import Terrain from "../Terrain.js";
 
 import ClingToTerrain from './ClingToTerrain.js';
+import { EventType } from "../../../EventType.js";
+import { t64_announce_change } from "../../../transform/t64_announce_change.js";
+import { t64_read_rotation } from "../../../transform/t64_read_rotation.js";
+import { t64_read_translation } from "../../../transform/t64_read_translation.js";
 
 
 /**
@@ -24,16 +28,12 @@ import ClingToTerrain from './ClingToTerrain.js';
 const temp_sp = new SurfacePoint3();
 
 /**
- *
- * @param {{update:function,transform:Transform}} datum
+ * @param {{update:function,ecd:EntityComponentDataset,entity:number}} datum
  */
 function deregister(datum) {
-    const update = datum.update;
-
-    const transform = datum.transform;
-
-    transform.position.onChanged.remove(update);
-    transform.rotation.onChanged.remove(update);
+    datum.ecd.removeEntityEventListener(
+        datum.entity, EventType.ComponentChanged, datum.update
+    );
 }
 
 /**
@@ -47,11 +47,11 @@ const DEFAULT_UPDATE_LIMIT = 1024;
 class ClingToTerrainSystem extends System {
 
 
-    dependencies = [ClingToTerrain, Transform];
+    dependencies = [ClingToTerrain, Transform64];
 
 
     components_used = [
-        ResourceAccessSpecification.from(Transform, ResourceAccessKind.Read | ResourceAccessKind.Write),
+        ResourceAccessSpecification.from(Transform64, ResourceAccessKind.Read | ResourceAccessKind.Write),
         ResourceAccessSpecification.from(Terrain, ResourceAccessKind.Read)
     ];
 
@@ -82,29 +82,42 @@ class ClingToTerrainSystem extends System {
 
     /**
      *
-     * @param {Transform} transform
+     * @param {Transform64} transform
      * @param {ClingToTerrain} cling
      * @param {number} entityId
      */
     link(cling, transform, entityId) {
 
-        const update = () => this.requestUpdate(entityId);
+        const ecd = this.entityManager.dataset;
+
+        /*
+         The transform used to carry three signals and this listened to two of them. It carries
+         none now, so the interest is registered against the entity instead and filtered by class:
+         one listener where there were two, and it hears a write from anywhere - a spawner, a
+         script, a physics step - rather than only one that went through a sub-object.
+        */
+        const update = event => {
+            if (event.klass === Transform64) {
+                this.requestUpdate(entityId);
+            }
+        };
 
         this.data[entityId] = {
             update,
             transform,
-            component: cling
+            component: cling,
+            ecd,
+            entity: entityId
         };
 
-        transform.position.onChanged.add(update);
-        transform.rotation.onChanged.add(update);
+        ecd.addEntityEventListener(entityId, EventType.ComponentChanged, update);
 
-        update();
+        this.requestUpdate(entityId);
     }
 
     /**
      *
-     * @param {Transform} transform
+     * @param {Transform64} transform
      * @param {ClingToTerrain} cling
      * @param {number} entityId
      */
@@ -183,6 +196,18 @@ const v3_up = new Vector3();
 
 const q_temp = new Quaternion();
 
+/**
+ * The pose of whichever entity is being clung right now, read out of its transform.
+ *
+ * @type {Vector3}
+ */
+const scratch_position = new Vector3();
+
+/**
+ * @type {Quaternion}
+ */
+const scratch_rotation = new Quaternion();
+
 /**
  * TODO look into "swing-twist decomposition"
  * @param {Quaternion} rotation
@@ -231,19 +256,19 @@ export function alignToVector(rotation, direction, angularLimit, up = Vector3.up
 /**
  *
  * @param {Vector3} point
- * @param {Transform} t
+ * @param {Transform64} t
  * @param {Vector3} normal
  * @param {ClingToTerrain} cling
  * @param {number} timeDelta
  */
-function processRaycastHit(point, t, normal, cling, timeDelta) {
+function processRaycastHit(point, t, normal, cling, timeDelta, el) {
     assert.defined(point, 'point');
     assert.equal(point.isVector3, true, 'point.isVector3 !== true');
     assert.isNumber(timeDelta, 'timeDelta');
 
-    const position = t.position;
-
-    const rotation = t.rotation;
+    // filled by the caller, which had to read them to decide there was anything to do
+    const position = scratch_position;
+    const rotation = scratch_rotation;
 
     const hitDistance = position.distanceTo(point);
 
@@ -251,8 +276,12 @@ function processRaycastHit(point, t, normal, cling, timeDelta) {
     cling.__lastPosition.copy(position);
     cling.__lastRotation.copy(rotation);
 
+    let moved = false;
+
     if (hitDistance > EPSILON) {
-        position.setY(point.y);
+        t.setTranslation(position.x, point.y, position.z);
+
+        moved = true;
     }
 
     let angularLimit;
@@ -265,8 +294,28 @@ function processRaycastHit(point, t, normal, cling, timeDelta) {
 
     if (cling.normalAlign) {
         alignToVector(rotation, normal, angularLimit);
+
+        if (
+            rotation.x !== t.rotation_x || rotation.y !== t.rotation_y
+            || rotation.z !== t.rotation_z || rotation.w !== t.rotation_w
+        ) {
+            t.setRotation(rotation.x, rotation.y, rotation.z, rotation.w);
+
+            // the rotation is the only write that leaves the matrix behind
+            t.updateMatrix();
+
+            moved = true;
+        }
     }
 
+    /*
+     Announced only when something actually changed. The system is listening to this entity itself,
+     so an announcement it did not earn would queue the entity again, find nothing to do, and queue
+     it again - a spin that never settles.
+    */
+    if (moved) {
+        t64_announce_change(el.ecd, el.entity, t);
+    }
 }
 
 /**
@@ -284,30 +333,29 @@ function doCling(el, terrain, timeDelta) {
 
     /**
      *
-     * @type {Transform}
+     * @type {Transform64}
      */
     const t = el.transform;
 
-    /**
-     *
-     * @type {Vector3}
-     */
-    const position = t.position;
-
-    const rotation = t.rotation;
+    // read out once; the comparison, the cast and the write below all want the same numbers, and
+    // reading them through the component's view accessors would allocate two arrays per entity
+    t64_read_translation(scratch_position, t);
+    t64_read_rotation(scratch_rotation, t);
 
     if (
-        cling.__lastPosition.roughlyEquals(position, 0.001)
-        && cling.__lastRotation.roughlyEquals(rotation, 0.0001)
+        cling.__lastPosition.roughlyEquals(scratch_position, 0.001)
+        && cling.__lastRotation.roughlyEquals(scratch_rotation, 0.0001)
     ) {
         //do nothing, cached position matches with existing position
         return false;
     }
 
-    const hit_found = terrain.raycastVerticalFirstSync(temp_sp, position.x, position.z);
+    const hit_found = terrain.raycastVerticalFirstSync(
+        temp_sp, scratch_position.x, scratch_position.z
+    );
 
     if (hit_found) {
-        processRaycastHit(temp_sp.position, t, temp_sp.normal, cling, timeDelta);
+        processRaycastHit(temp_sp.position, t, temp_sp.normal, cling, timeDelta, el);
     }
 
     return hit_found;