@2112-lab/central-plant 0.3.21 → 0.3.22

package/dist/esm/src/managers/behaviors/IoAnimationManager.js

@@ -0,0 +1,398 @@
+import { inherits as _inherits, createClass as _createClass, createForOfIteratorHelper as _createForOfIteratorHelper, superPropGet as _superPropGet, toConsumableArray as _toConsumableArray, classCallCheck as _classCallCheck, callSuper as _callSuper } from '../../../_virtual/_rollupPluginBabelHelpers.js';
+import * as THREE from 'three';
+import { BaseDisposable } from '../../core/baseDisposable.js';
+
+var IoAnimationManager = /*#__PURE__*/function (_BaseDisposable) {
+  function IoAnimationManager(sceneViewer) {
+    var _this;
+    _classCallCheck(this, IoAnimationManager);
+    _this = _callSuper(this, IoAnimationManager);
+    _this.sceneViewer = sceneViewer;
+
+    /**
+     * Map: `${parentUuid}::${attachmentId}` → Array<{
+     *   anim: Object,
+     *   mesh: THREE.Object3D,
+     *   origPos: THREE.Vector3,
+     *   origRot: THREE.Euler
+     * }>
+     */
+    _this._entries = new Map();
+    return _this;
+  }
+
+  // ─────────────────────────────────────────────────────────────────────────
+  // PUBLIC API
+  // ─────────────────────────────────────────────────────────────────────────
+
+  /**
+   * Register animation entries for one attached I/O device.
+   * Should be called after the device GLB has been merged into the scene
+   * so that mesh references are live.
+   *
+   * @param {string} attachmentId - The attachment key (e.g. 'attch-switch-01')
+   * @param {Object|Array} animationConfig - Serialized config; either the full object
+   *   { animations: [...] } or a plain array of animation entries.
+   * @param {THREE.Object3D} deviceModelRoot - The device's root Object3D as added to the scene
+   * @param {string} parentUuid - UUID of the host component Object3D
+   */
+  _inherits(IoAnimationManager, _BaseDisposable);
+  return _createClass(IoAnimationManager, [{
+    key: "loadAnimations",
+    value: function loadAnimations(attachmentId, animationConfig, deviceModelRoot, parentUuid) {
+      var _animationConfig$anim;
+      if (!animationConfig || !deviceModelRoot) return;
+      var anims = Array.isArray(animationConfig) ? animationConfig : (_animationConfig$anim = animationConfig.animations) !== null && _animationConfig$anim !== void 0 ? _animationConfig$anim : [];
+      if (!anims.length) return;
+      var key = this._key(parentUuid, attachmentId);
+      var entries = [];
+      var _iterator = _createForOfIteratorHelper(anims),
+        _step;
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var anim = _step.value;
+          var mesh = this._resolveMesh(anim, deviceModelRoot);
+          if (!mesh) {
+            console.warn("[IoAnimationManager] Could not find mesh for animation \"".concat(anim.name || anim.stateVariable, "\" (uuid: ").concat(anim.meshUuid, ", name: \"").concat(anim.meshName, "\")"));
+            continue;
+          }
+          entries.push({
+            anim: anim,
+            mesh: mesh,
+            origPos: mesh.position.clone(),
+            origRot: mesh.rotation.clone()
+          });
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+      if (entries.length) {
+        this._entries.set(key, entries);
+        console.log("[IoAnimationManager] Loaded ".concat(entries.length, " animation(s) for attachment \"").concat(attachmentId, "\" (parent: ").concat(parentUuid, ")"));
+      }
+    }
+
+    /**
+     * Apply animations triggered by an IO device state change.
+     * Should be called in parallel with BehaviorManager.triggerState().
+     *
+     * @param {string} attachmentId - Raw attachment key (not scoped)
+     * @param {string} dataPointId  - The data point / state variable id that changed
+     * @param {*}      value        - New state value
+     * @param {string} parentUuid   - UUID of the host component
+     */
+  }, {
+    key: "triggerState",
+    value: function triggerState(attachmentId, dataPointId, value, parentUuid) {
+      var key = this._key(parentUuid, attachmentId);
+      var entries = this._entries.get(key);
+      if (!(entries !== null && entries !== void 0 && entries.length)) return;
+      var _iterator2 = _createForOfIteratorHelper(entries),
+        _step2;
+      try {
+        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+          var entry = _step2.value;
+          if (entry.anim.stateVariable !== dataPointId) continue;
+          this._applyAnimation(entry, value);
+        }
+      } catch (err) {
+        _iterator2.e(err);
+      } finally {
+        _iterator2.f();
+      }
+    }
+
+    /**
+     * Remove all animation entries associated with a given host component.
+     * Call when a component is removed from the scene.
+     *
+     * @param {string} parentUuid
+     */
+  }, {
+    key: "unloadForComponent",
+    value: function unloadForComponent(parentUuid) {
+      var prefix = "".concat(parentUuid, "::");
+      var _iterator3 = _createForOfIteratorHelper(this._entries.keys()),
+        _step3;
+      try {
+        for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+          var key = _step3.value;
+          if (key.startsWith(prefix)) {
+            this._entries.delete(key);
+          }
+        }
+      } catch (err) {
+        _iterator3.e(err);
+      } finally {
+        _iterator3.f();
+      }
+    }
+  }, {
+    key: "dispose",
+    value: function dispose() {
+      this._entries.clear();
+      _superPropGet(IoAnimationManager, "dispose", this, 3)([]);
+    }
+
+    // ─────────────────────────────────────────────────────────────────────────
+    // PRIVATE HELPERS
+    // ─────────────────────────────────────────────────────────────────────────
+  }, {
+    key: "_key",
+    value: function _key(parentUuid, attachmentId) {
+      return "".concat(parentUuid, "::").concat(attachmentId);
+    }
+
+    /**
+     * Find the mesh inside `root` using UUID first, then name as fallback.
+     * GLTFLoader assigns fresh UUIDs on every load, so name is the reliable key.
+     * @param {Object} anim
+     * @param {THREE.Object3D} root
+     * @returns {THREE.Object3D|null}
+     */
+  }, {
+    key: "_resolveMesh",
+    value: function _resolveMesh(anim, root) {
+      var found = null;
+      root.traverse(function (obj) {
+        if (found) return;
+
+        // Prefer UUID match (works when the device was cloned from a cached instance
+        // whose UUIDs were preserved)
+        if (anim.meshUuid && obj.uuid === anim.meshUuid) {
+          found = obj;
+          return;
+        }
+
+        // Reliable fallback: mesh name
+        if (anim.meshName && obj.name === anim.meshName) {
+          found = obj;
+        }
+      });
+      return found;
+    }
+
+    /**
+     * Resolve which mapping row to use and apply all declared transform types.
+     * @param {{ anim, mesh, origPos, origRot }} entry
+     * @param {*} value - Current state value
+     */
+  }, {
+    key: "_applyAnimation",
+    value: function _applyAnimation(entry, value) {
+      var anim = entry.anim,
+        mesh = entry.mesh,
+        origPos = entry.origPos,
+        origRot = entry.origRot;
+      var mapping = this._resolveMapping(anim, value);
+      if (!mapping) return;
+      var types = anim.transformTypes || [];
+      var _iterator4 = _createForOfIteratorHelper(types),
+        _step4;
+      try {
+        for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+          var type = _step4.value;
+          if (type === 'translation') {
+            this._applyTranslation(mesh, origPos, mapping.transform);
+          } else if (type === 'rotation') {
+            this._applyRotation(mesh, origPos, origRot, anim, mapping.rotationTransform);
+          } else if (type === 'color') {
+            this._applyColor(mesh, mapping.colorTransform);
+          }
+        }
+      } catch (err) {
+        _iterator4.e(err);
+      } finally {
+        _iterator4.f();
+      }
+    }
+
+    /**
+     * Find the mapping row that matches `value` for the given animation entry.
+     *
+     * - binary / enum: find where mapping.stateValue == value (loose equality so
+     *   JSON-deserialised "true" matches boolean true)
+     * - continuous: linear interpolation between ordered anchor points
+     *
+     * @returns {Object|null} The matched/interpolated mapping row, or null.
+     */
+  }, {
+    key: "_resolveMapping",
+    value: function _resolveMapping(anim, value) {
+      var stateType = anim.stateType,
+        mappings = anim.mappings;
+      if (!(mappings !== null && mappings !== void 0 && mappings.length)) return null;
+      if (stateType === 'binary' || stateType === 'enum') {
+        var _mappings$find;
+        // eslint-disable-next-line eqeqeq
+        return (_mappings$find = mappings.find(function (m) {
+          return m.stateValue == value;
+        })) !== null && _mappings$find !== void 0 ? _mappings$find : null;
+      }
+      if (stateType === 'continuous') {
+        var num = Number(value);
+        if (isNaN(num)) return null;
+
+        // Sort anchors by numeric stateValue
+        var sorted = _toConsumableArray(mappings).filter(function (m) {
+          return m.stateValue != null && !isNaN(Number(m.stateValue));
+        }).sort(function (a, b) {
+          return Number(a.stateValue) - Number(b.stateValue);
+        });
+        if (!sorted.length) return null;
+        if (sorted.length === 1) return sorted[0];
+
+        // Clamp to range
+        if (num <= Number(sorted[0].stateValue)) return sorted[0];
+        if (num >= Number(sorted[sorted.length - 1].stateValue)) return sorted[sorted.length - 1];
+
+        // Find surrounding anchors and interpolate
+        for (var i = 0; i < sorted.length - 1; i++) {
+          var lo = sorted[i];
+          var hi = sorted[i + 1];
+          var loVal = Number(lo.stateValue);
+          var hiVal = Number(hi.stateValue);
+          if (num >= loVal && num <= hiVal) {
+            var t = (num - loVal) / (hiVal - loVal);
+            return this._lerpMapping(lo, hi, t);
+          }
+        }
+      }
+      return null;
+    }
+
+    /**
+     * Linear-interpolate between two mapping rows.
+     * @param {Object} lo - lower anchor mapping
+     * @param {Object} hi - upper anchor mapping
+     * @param {number} t  - 0..1
+     */
+  }, {
+    key: "_lerpMapping",
+    value: function _lerpMapping(lo, hi, t) {
+      var _lo$transform$x, _lo$transform, _hi$transform$x, _hi$transform, _lo$transform$y, _lo$transform2, _hi$transform$y, _hi$transform2, _lo$transform$z, _lo$transform3, _hi$transform$z, _hi$transform3;
+      var lerp = function lerp(a, b) {
+        return a + (b - a) * t;
+      };
+      var transform = {
+        x: lerp((_lo$transform$x = (_lo$transform = lo.transform) === null || _lo$transform === void 0 ? void 0 : _lo$transform.x) !== null && _lo$transform$x !== void 0 ? _lo$transform$x : 0, (_hi$transform$x = (_hi$transform = hi.transform) === null || _hi$transform === void 0 ? void 0 : _hi$transform.x) !== null && _hi$transform$x !== void 0 ? _hi$transform$x : 0),
+        y: lerp((_lo$transform$y = (_lo$transform2 = lo.transform) === null || _lo$transform2 === void 0 ? void 0 : _lo$transform2.y) !== null && _lo$transform$y !== void 0 ? _lo$transform$y : 0, (_hi$transform$y = (_hi$transform2 = hi.transform) === null || _hi$transform2 === void 0 ? void 0 : _hi$transform2.y) !== null && _hi$transform$y !== void 0 ? _hi$transform$y : 0),
+        z: lerp((_lo$transform$z = (_lo$transform3 = lo.transform) === null || _lo$transform3 === void 0 ? void 0 : _lo$transform3.z) !== null && _lo$transform$z !== void 0 ? _lo$transform$z : 0, (_hi$transform$z = (_hi$transform3 = hi.transform) === null || _hi$transform3 === void 0 ? void 0 : _hi$transform3.z) !== null && _hi$transform$z !== void 0 ? _hi$transform$z : 0)
+      };
+      var rotationTransform = lerp(typeof lo.rotationTransform === 'number' ? lo.rotationTransform : 0, typeof hi.rotationTransform === 'number' ? hi.rotationTransform : 0);
+
+      // Color interpolation: convert hex → RGB components → lerp → back to hex
+      var colorTransform = this._lerpHex(lo.colorTransform, hi.colorTransform, t);
+      return {
+        stateValue: null,
+        transform: transform,
+        rotationTransform: rotationTransform,
+        colorTransform: colorTransform
+      };
+    }
+
+    /**
+     * Interpolate between two hex colour strings.
+     */
+  }, {
+    key: "_lerpHex",
+    value: function _lerpHex(hexA, hexB, t) {
+      try {
+        var ca = new THREE.Color(hexA);
+        var cb = new THREE.Color(hexB);
+        ca.lerp(cb, t);
+        return "#".concat(ca.getHexString());
+      } catch (_unused) {
+        return hexA !== null && hexA !== void 0 ? hexA : '#ffffff';
+      }
+    }
+
+    // ─────────────────────────────────────────────────────────────────────────
+    // TRANSFORM APPLIERS
+    // ─────────────────────────────────────────────────────────────────────────
+
+    /**
+     * Apply a position delta relative to the mesh's original position.
+     * @param {THREE.Object3D} mesh
+     * @param {THREE.Vector3} origPos
+     * @param {{ x, y, z }} transform - Deltas
+     */
+  }, {
+    key: "_applyTranslation",
+    value: function _applyTranslation(mesh, origPos, transform) {
+      var _transform$x, _transform$y, _transform$z;
+      if (!transform) return;
+      mesh.position.set(origPos.x + ((_transform$x = transform.x) !== null && _transform$x !== void 0 ? _transform$x : 0), origPos.y + ((_transform$y = transform.y) !== null && _transform$y !== void 0 ? _transform$y : 0), origPos.z + ((_transform$z = transform.z) !== null && _transform$z !== void 0 ? _transform$z : 0));
+    }
+
+    /**
+     * Apply a rotation around an arbitrary pivot point in device-local space,
+     * optionally also displacing the mesh position to simulate orbital motion.
+     *
+     * Math (all in device-local space):
+     *   pivot   = rotAxisOffset
+     *   delta   = origPos - pivot
+     *   newDelta = rotate(delta, angle, axis)
+     *   newPos  = pivot + newDelta
+     *   newRot[axis] = origRot[axis] + angle
+     *
+     * @param {THREE.Object3D} mesh
+     * @param {THREE.Vector3}  origPos
+     * @param {THREE.Euler}    origRot
+     * @param {Object}         anim
+     * @param {number}         angleDeg - Degrees
+     */
+  }, {
+    key: "_applyRotation",
+    value: function _applyRotation(mesh, origPos, origRot, anim, angleDeg) {
+      var _anim$rotAxis, _anim$rotAxisOffset, _off$x, _off$y, _off$z;
+      var angle = THREE.MathUtils.degToRad(typeof angleDeg === 'number' ? angleDeg : 0);
+      var axis = ((_anim$rotAxis = anim.rotAxis) !== null && _anim$rotAxis !== void 0 ? _anim$rotAxis : 'x').toLowerCase();
+      var off = (_anim$rotAxisOffset = anim.rotAxisOffset) !== null && _anim$rotAxisOffset !== void 0 ? _anim$rotAxisOffset : {
+        x: 0,
+        y: 0,
+        z: 0
+      };
+
+      // Unit vector for the chosen axis
+      var axisVec = new THREE.Vector3(axis === 'x' ? 1 : 0, axis === 'y' ? 1 : 0, axis === 'z' ? 1 : 0);
+      var pivot = new THREE.Vector3((_off$x = off.x) !== null && _off$x !== void 0 ? _off$x : 0, (_off$y = off.y) !== null && _off$y !== void 0 ? _off$y : 0, (_off$z = off.z) !== null && _off$z !== void 0 ? _off$z : 0);
+      var delta = origPos.clone().sub(pivot);
+      delta.applyAxisAngle(axisVec, angle);
+      mesh.position.copy(pivot).add(delta);
+      mesh.rotation[axis] = origRot[axis] + angle;
+    }
+
+    /**
+     * Apply a colour to all Mesh descendants of `mesh`.
+     * Creates a cloned material per mesh on first call to avoid shared-material
+     * cross-contamination between different device instances.
+     *
+     * @param {THREE.Object3D} mesh
+     * @param {string} colorHex - e.g. '#ff0000'
+     */
+  }, {
+    key: "_applyColor",
+    value: function _applyColor(mesh, colorHex) {
+      if (!colorHex) return;
+      mesh.traverse(function (obj) {
+        if (!obj.isMesh || !obj.material) return;
+
+        // Ensure this mesh has its own material instance
+        if (!obj.userData._materialCloned) {
+          obj.material = obj.material.clone();
+          obj.userData._materialCloned = true;
+        }
+        try {
+          obj.material.color.set(colorHex);
+        } catch (e) {
+          // Material may not have a color property (e.g. MeshDepthMaterial)
+        }
+      });
+    }
+  }]);
+}(BaseDisposable);
+
+export { IoAnimationManager };

package/dist/esm/src/managers/scene/componentTooltipManager.js

@@ -105,7 +105,7 @@ var ComponentTooltipManager = /*#__PURE__*/function (_BaseDisposable) {
   }, {
     key: "toggleIODeviceBinaryState",
     value: function toggleIODeviceBinaryState(ioDeviceObject) {
-      var _ref, _this$sceneViewer;
+      var _ref, _this$sceneViewer, _this$sceneViewer2;
       if (!ioDeviceObject || !this._stateAdapter) return;
       var ud = ioDeviceObject.userData;
       var attachmentId = ud === null || ud === void 0 ? void 0 : ud.attachmentId;
@@ -140,6 +140,7 @@ var ComponentTooltipManager = /*#__PURE__*/function (_BaseDisposable) {
       var newVal = !Boolean(currentVal);
       this._stateAdapter.setState(scopedAttachmentId, dpId, newVal);
       (_this$sceneViewer = this.sceneViewer) === null || _this$sceneViewer === void 0 || (_this$sceneViewer = _this$sceneViewer.managers) === null || _this$sceneViewer === void 0 || (_this$sceneViewer = _this$sceneViewer.behaviorManager) === null || _this$sceneViewer === void 0 || _this$sceneViewer.triggerState(attachmentId, dpId, newVal, parentUuid);
+      (_this$sceneViewer2 = this.sceneViewer) === null || _this$sceneViewer2 === void 0 || (_this$sceneViewer2 = _this$sceneViewer2.managers) === null || _this$sceneViewer2 === void 0 || (_this$sceneViewer2 = _this$sceneViewer2.ioAnimationManager) === null || _this$sceneViewer2 === void 0 || _this$sceneViewer2.triggerState(attachmentId, dpId, newVal, parentUuid);
       console.log("\uD83D\uDD04 [IODevice] Toggled ".concat(scopedAttachmentId, ".").concat(dpId, ": ").concat(currentVal, " \u2192 ").concat(newVal));
     }
 
@@ -413,11 +414,11 @@ var ComponentTooltipManager = /*#__PURE__*/function (_BaseDisposable) {
   }, {
     key: "_positionTooltip",
     value: function _positionTooltip() {
-      var _this$sceneViewer2, _this$sceneViewer3;
+      var _this$sceneViewer3, _this$sceneViewer4;
       if (!this.tooltipEl || !this.selectedObject) return;
       var container = this._getContainer();
-      var camera = (_this$sceneViewer2 = this.sceneViewer) === null || _this$sceneViewer2 === void 0 ? void 0 : _this$sceneViewer2.camera;
-      var renderer = (_this$sceneViewer3 = this.sceneViewer) === null || _this$sceneViewer3 === void 0 ? void 0 : _this$sceneViewer3.renderer;
+      var camera = (_this$sceneViewer3 = this.sceneViewer) === null || _this$sceneViewer3 === void 0 ? void 0 : _this$sceneViewer3.camera;
+      var renderer = (_this$sceneViewer4 = this.sceneViewer) === null || _this$sceneViewer4 === void 0 ? void 0 : _this$sceneViewer4.renderer;
       if (!container || !camera || !renderer) return;
 
       // Compute bounding box to position above the component
@@ -454,8 +455,8 @@ var ComponentTooltipManager = /*#__PURE__*/function (_BaseDisposable) {
   }, {
     key: "_getContainer",
     value: function _getContainer() {
-      var _this$sceneViewer4;
-      return ((_this$sceneViewer4 = this.sceneViewer) === null || _this$sceneViewer4 === void 0 || (_this$sceneViewer4 = _this$sceneViewer4.renderer) === null || _this$sceneViewer4 === void 0 || (_this$sceneViewer4 = _this$sceneViewer4.domElement) === null || _this$sceneViewer4 === void 0 ? void 0 : _this$sceneViewer4.parentElement) || null;
+      var _this$sceneViewer5;
+      return ((_this$sceneViewer5 = this.sceneViewer) === null || _this$sceneViewer5 === void 0 || (_this$sceneViewer5 = _this$sceneViewer5.renderer) === null || _this$sceneViewer5 === void 0 || (_this$sceneViewer5 = _this$sceneViewer5.domElement) === null || _this$sceneViewer5 === void 0 ? void 0 : _this$sceneViewer5.parentElement) || null;
     }
 
     // -----------------------------------------------------------------------
@@ -495,7 +496,7 @@ var ComponentTooltipManager = /*#__PURE__*/function (_BaseDisposable) {
       var currentVal = (_ref2 = (_this$_stateAdapter$g = (_this$_stateAdapter = this._stateAdapter) === null || _this$_stateAdapter === void 0 ? void 0 : _this$_stateAdapter.getState(scopedAttachmentId, dpId)) !== null && _this$_stateAdapter$g !== void 0 ? _this$_stateAdapter$g : dp.defaultValue) !== null && _ref2 !== void 0 ? _ref2 : null;
       if (isInput) {
         var ctrl = this._buildInputControl(dp, currentVal, function (newVal) {
-          var _this4$_stateAdapter, _this4$selectedObject, _this4$sceneViewer;
+          var _this4$_stateAdapter, _this4$selectedObject, _this4$sceneViewer, _this4$sceneViewer2;
           (_this4$_stateAdapter = _this4._stateAdapter) === null || _this4$_stateAdapter === void 0 || _this4$_stateAdapter.setState(scopedAttachmentId, dpId, newVal);
           // Also fire BehaviorManager so any wired behaviors react immediately.
           // Pass the parent component UUID so behaviors scoped to a specific instance
@@ -503,6 +504,7 @@ var ComponentTooltipManager = /*#__PURE__*/function (_BaseDisposable) {
           // Use originalAttachmentId for behavior triggering as behaviors are keyed by original ID
           var parentUuid = ((_this4$selectedObject = _this4.selectedObject) === null || _this4$selectedObject === void 0 ? void 0 : _this4$selectedObject.uuid) || null;
           (_this4$sceneViewer = _this4.sceneViewer) === null || _this4$sceneViewer === void 0 || (_this4$sceneViewer = _this4$sceneViewer.managers) === null || _this4$sceneViewer === void 0 || (_this4$sceneViewer = _this4$sceneViewer.behaviorManager) === null || _this4$sceneViewer === void 0 || _this4$sceneViewer.triggerState(originalAttachmentId || scopedAttachmentId, dpId, newVal, parentUuid);
+          (_this4$sceneViewer2 = _this4.sceneViewer) === null || _this4$sceneViewer2 === void 0 || (_this4$sceneViewer2 = _this4$sceneViewer2.managers) === null || _this4$sceneViewer2 === void 0 || (_this4$sceneViewer2 = _this4$sceneViewer2.ioAnimationManager) === null || _this4$sceneViewer2 === void 0 || _this4$sceneViewer2.triggerState(originalAttachmentId || scopedAttachmentId, dpId, newVal, parentUuid);
         });
         row.appendChild(ctrl);
         this._stateElements.set(key, {