@2112-lab/central-plant 0.1.76 → 0.1.78

package/dist/cjs/src/utils/boundingBoxUtils.js

@@ -0,0 +1,356 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _rollupPluginBabelHelpers = require('../../_virtual/_rollupPluginBabelHelpers.js');
+var THREE = require('three');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n["default"] = e;
+  return Object.freeze(n);
+}
+
+var THREE__namespace = /*#__PURE__*/_interopNamespace(THREE);
+
+/**
+ * Creates a wireframe box helper (LineSegments) from a Box3, visually identical
+ * to THREE.BoxHelper but driven by an explicit Box3 instead of setFromObject().
+ * 
+ * @param {THREE.Box3} box3 - The bounding box to visualize
+ * @param {number} color - Line color (hex)
+ * @returns {THREE.LineSegments} A wireframe box matching BoxHelper's visual style
+ * @private
+ */
+function _createBoxHelperFromBox3(box3, color) {
+  var indices = new Uint16Array([0, 1, 1, 2, 2, 3, 3, 0, 4, 5, 5, 6, 6, 7, 7, 4, 0, 4, 1, 5, 2, 6, 3, 7]);
+  var positions = new Float32Array(8 * 3);
+  var geometry = new THREE__namespace.BufferGeometry();
+  geometry.setIndex(new THREE__namespace.BufferAttribute(indices, 1));
+  geometry.setAttribute('position', new THREE__namespace.BufferAttribute(positions, 3));
+  var helper = new THREE__namespace.LineSegments(geometry, new THREE__namespace.LineBasicMaterial({
+    color: color,
+    toneMapped: false
+  }));
+  helper.matrixAutoUpdate = false;
+
+  // Populate positions from box3
+  _updateBoxHelperPositions(helper, box3);
+  return helper;
+}
+
+/**
+ * Updates a box helper's geometry positions from a Box3.
+ * Matches the vertex layout used by THREE.BoxHelper.
+ * 
+ * @param {THREE.LineSegments} helper - The wireframe helper to update
+ * @param {THREE.Box3} box3 - The bounding box
+ * @private
+ */
+function _updateBoxHelperPositions(helper, box3) {
+  if (box3.isEmpty()) return;
+  var min = box3.min;
+  var max = box3.max;
+  var position = helper.geometry.attributes.position;
+  var array = position.array;
+
+  // Same vertex layout as THREE.BoxHelper
+  array[0] = max.x;
+  array[1] = max.y;
+  array[2] = max.z;
+  array[3] = min.x;
+  array[4] = max.y;
+  array[5] = max.z;
+  array[6] = min.x;
+  array[7] = min.y;
+  array[8] = max.z;
+  array[9] = max.x;
+  array[10] = min.y;
+  array[11] = max.z;
+  array[12] = max.x;
+  array[13] = max.y;
+  array[14] = min.z;
+  array[15] = min.x;
+  array[16] = max.y;
+  array[17] = min.z;
+  array[18] = min.x;
+  array[19] = min.y;
+  array[20] = min.z;
+  array[21] = max.x;
+  array[22] = min.y;
+  array[23] = min.z;
+  position.needsUpdate = true;
+  helper.geometry.computeBoundingSphere();
+}
+
+/**
+ * Computes a bounding box for a Three.js object, excluding descendant meshes
+ * that belong to subtrees rooted at objects with excluded objectTypes.
+ * 
+ * This mirrors what THREE.Box3.expandByObject() does internally, but with a
+ * filter predicate that skips meshes whose ancestry (up to the root object)
+ * includes any excluded objectType.
+ * 
+ * @param {THREE.Object3D} object - The root object to compute bbox for
+ * @param {string[]} excludeTypes - userData.objectType values to exclude (e.g., ['io-device', 'connector'])
+ * @returns {THREE.Box3} The filtered bounding box in world space
+ * 
+ * @example
+ * // Compute bbox for pump body only, excluding io-devices and connectors
+ * const pumpBodyBBox = computeFilteredBoundingBox(pumpModel, ['io-device', 'connector'])
+ */
+function computeFilteredBoundingBox(object) {
+  var excludeTypes = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+  var box = new THREE__namespace.Box3();
+  var tempBox = new THREE__namespace.Box3();
+  var hasGeometry = false;
+
+  // Build a Set for O(1) lookups
+  var excludeSet = new Set(excludeTypes);
+  object.updateWorldMatrix(false, true);
+  object.traverse(function (child) {
+    // Only process nodes with geometry (Mesh, SkinnedMesh, etc.)
+    if (!child.geometry) return;
+
+    // Walk up the ancestry from child to root object, checking for excluded types.
+    // If any ancestor (excluding the root object itself) has an excluded objectType,
+    // this mesh belongs to an excluded subtree — skip it.
+    var ancestor = child;
+    while (ancestor && ancestor !== object) {
+      var _ancestor$userData;
+      if ((_ancestor$userData = ancestor.userData) !== null && _ancestor$userData !== void 0 && _ancestor$userData.objectType && excludeSet.has(ancestor.userData.objectType)) {
+        return; // Skip — this mesh belongs to an excluded subtree
+      }
+      ancestor = ancestor.parent;
+    }
+
+    // Include this mesh's geometry in the bounding box
+    child.geometry.computeBoundingBox();
+    if (child.geometry.boundingBox) {
+      tempBox.copy(child.geometry.boundingBox);
+      tempBox.applyMatrix4(child.matrixWorld);
+      if (!hasGeometry) {
+        box.copy(tempBox);
+        hasGeometry = true;
+      } else {
+        box.union(tempBox);
+      }
+    }
+  });
+  if (!hasGeometry) {
+    // Fallback: return a zero-size box at the object's world position
+    var position = new THREE__namespace.Vector3();
+    object.getWorldPosition(position);
+    box.setFromCenterAndSize(position, new THREE__namespace.Vector3(0, 0, 0));
+    console.warn("[boundingBoxUtils] computeFilteredBoundingBox: No geometry found for ".concat(object.uuid, ", returning empty box"));
+  }
+  return box;
+}
+
+/**
+ * Computes individual world-space bounding boxes for each io-device child
+ * of a component. Uses standard THREE.Box3.setFromObject() on each io-device
+ * since io-devices don't have their own sub-devices that need filtering.
+ * 
+ * @param {THREE.Object3D} componentObject - The component's Three.js object
+ * @returns {Array<{uuid: string, userData: Object, worldBoundingBox: {min: number[], max: number[]}}>}
+ *   Array of io-device bounding box descriptors ready for injection into scene data
+ * 
+ * @example
+ * const ioDeviceBBoxes = computeIODeviceBoundingBoxes(pumpModel)
+ * // Returns: [{ uuid: 'signal-light-1', userData: {...}, worldBoundingBox: { min: [...], max: [...] } }]
+ */
+function computeIODeviceBoundingBoxes(componentObject) {
+  var results = [];
+  var _iterator = _rollupPluginBabelHelpers.createForOfIteratorHelper(componentObject.children),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var _child$userData;
+      var child = _step.value;
+      if (((_child$userData = child.userData) === null || _child$userData === void 0 ? void 0 : _child$userData.objectType) !== 'io-device') continue;
+      var bbox = new THREE__namespace.Box3().setFromObject(child);
+      if (!bbox.isEmpty()) {
+        results.push({
+          uuid: child.uuid,
+          userData: {
+            objectType: 'io-device',
+            deviceId: child.userData.deviceId || null,
+            attachmentId: child.userData.attachmentId || null,
+            parentComponentId: child.userData.parentComponentId || componentObject.uuid
+          },
+          worldBoundingBox: {
+            min: [bbox.min.x, bbox.min.y, bbox.min.z],
+            max: [bbox.max.x, bbox.max.y, bbox.max.z]
+          }
+        });
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  return results;
+}
+
+/**
+ * Creates bounding box helpers for a selected object. For smart components
+ * (components with io-device children), this produces:
+ * - One filtered helper for the component body (excluding io-devices and connectors)
+ * - One helper per io-device child
+ * 
+ * For non-smart components and other objects, produces a single standard BoxHelper.
+ * 
+ * Each helper is tagged with metadata in userData for update tracking:
+ * - `isBoundingBox: true`
+ * - `sourceObjectUuid: string` — the object this helper represents
+ * - `isFiltered: boolean` — whether filtered computation was used
+ * - `excludeTypes: string[]` — types excluded (for recomputation)
+ * 
+ * @param {THREE.Object3D} object - The selected scene object
+ * @param {number} color - Line color (hex), default green
+ * @returns {THREE.LineSegments[]} Array of box helpers to add to the scene
+ * 
+ * @example
+ * const helpers = createSelectionBoxHelpers(pumpModel, 0x00ff00)
+ * helpers.forEach(h => scene.add(h))
+ */
+function createSelectionBoxHelpers(object) {
+  var _object$children;
+  var color = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0x00ff00;
+  var helpers = [];
+  var excludeTypes = ['io-device', 'connector'];
+
+  // Check if this object has io-device children (smart component)
+  var hasIODevices = (_object$children = object.children) === null || _object$children === void 0 ? void 0 : _object$children.some(function (child) {
+    var _child$userData2;
+    return ((_child$userData2 = child.userData) === null || _child$userData2 === void 0 ? void 0 : _child$userData2.objectType) === 'io-device';
+  });
+  if (hasIODevices) {
+    // 1. Create filtered helper for the component body
+    var filteredBox = computeFilteredBoundingBox(object, excludeTypes);
+    var componentHelper = _createBoxHelperFromBox3(filteredBox, color);
+    componentHelper.isHelper = true;
+    componentHelper.userData = {
+      isBoundingBox: true,
+      sourceObjectUuid: object.uuid,
+      isFiltered: true,
+      excludeTypes: excludeTypes
+    };
+    helpers.push(componentHelper);
+
+    // 2. Create individual helpers for each io-device
+    var _iterator2 = _rollupPluginBabelHelpers.createForOfIteratorHelper(object.children),
+      _step2;
+    try {
+      for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+        var _child$userData3;
+        var child = _step2.value;
+        if (((_child$userData3 = child.userData) === null || _child$userData3 === void 0 ? void 0 : _child$userData3.objectType) !== 'io-device') continue;
+        var deviceBox = new THREE__namespace.Box3().setFromObject(child);
+        if (deviceBox.isEmpty()) continue;
+        var deviceHelper = _createBoxHelperFromBox3(deviceBox, color);
+        deviceHelper.isHelper = true;
+        deviceHelper.userData = {
+          isBoundingBox: true,
+          sourceObjectUuid: child.uuid,
+          isFiltered: false,
+          isIODevice: true,
+          parentComponentUuid: object.uuid
+        };
+        helpers.push(deviceHelper);
+      }
+    } catch (err) {
+      _iterator2.e(err);
+    } finally {
+      _iterator2.f();
+    }
+  } else {
+    // Standard BoxHelper for non-smart objects
+    var boxHelper = new THREE__namespace.BoxHelper(object, color);
+    boxHelper.isHelper = true;
+    boxHelper.userData = {
+      isBoundingBox: true,
+      sourceObjectUuid: object.uuid,
+      isFiltered: false
+    };
+    helpers.push(boxHelper);
+  }
+  return helpers;
+}
+
+/**
+ * Updates a set of bounding box helpers to reflect current object transforms.
+ * Handles both standard BoxHelpers and filtered/io-device helpers.
+ * 
+ * @param {THREE.LineSegments[]} helpers - Array of box helpers
+ * @param {THREE.Object3D[]} selectedObjects - The selected scene objects
+ * @param {THREE.Scene} scene - The scene (for finding objects by uuid)
+ */
+function updateSelectionBoxHelpers(helpers, selectedObjects, scene) {
+  var _iterator3 = _rollupPluginBabelHelpers.createForOfIteratorHelper(helpers),
+    _step3;
+  try {
+    var _loop = function _loop() {
+      var helper = _step3.value;
+      var _helper$userData = helper.userData,
+        sourceObjectUuid = _helper$userData.sourceObjectUuid,
+        isFiltered = _helper$userData.isFiltered,
+        excludeTypes = _helper$userData.excludeTypes,
+        isIODevice = _helper$userData.isIODevice,
+        parentComponentUuid = _helper$userData.parentComponentUuid;
+      var sourceObject;
+      if (isIODevice && parentComponentUuid) {
+        var _parent$children;
+        // Find the parent component first, then the io-device child
+        var parent = scene.getObjectByProperty('uuid', parentComponentUuid);
+        sourceObject = parent === null || parent === void 0 || (_parent$children = parent.children) === null || _parent$children === void 0 ? void 0 : _parent$children.find(function (c) {
+          return c.uuid === sourceObjectUuid;
+        });
+      } else {
+        sourceObject = selectedObjects.find(function (obj) {
+          return obj.uuid === sourceObjectUuid;
+        }) || scene.getObjectByProperty('uuid', sourceObjectUuid);
+      }
+      if (!sourceObject) return 1; // continue
+      sourceObject.updateMatrixWorld(true);
+      if (isFiltered && excludeTypes) {
+        // Recompute filtered bbox
+        var box = computeFilteredBoundingBox(sourceObject, excludeTypes);
+        _updateBoxHelperPositions(helper, box);
+      } else if (isIODevice) {
+        // Recompute io-device bbox
+        var _box = new THREE__namespace.Box3().setFromObject(sourceObject);
+        _updateBoxHelperPositions(helper, _box);
+      } else if (helper.update) {
+        // Standard BoxHelper — use built-in update
+        helper.update();
+      }
+    };
+    for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+      if (_loop()) continue;
+    }
+  } catch (err) {
+    _iterator3.e(err);
+  } finally {
+    _iterator3.f();
+  }
+}
+
+exports.computeFilteredBoundingBox = computeFilteredBoundingBox;
+exports.computeIODeviceBoundingBoxes = computeIODeviceBoundingBoxes;
+exports.createSelectionBoxHelpers = createSelectionBoxHelpers;
+exports.updateSelectionBoxHelpers = updateSelectionBoxHelpers;

package/dist/esm/src/core/centralPlant.js

@@ -15,7 +15,7 @@ var CentralPlant = /*#__PURE__*/function (_BaseDisposable) {
    * Initialize the CentralPlant manager
    * 
    * @constructor
-   * @version 0.1.76
+   * @version 0.1.78
    * @updated 2025-10-22
    * 
    * @description Creates a new CentralPlant instance and initializes internal managers and utilities.

package/dist/esm/src/core/centralPlantInternals.js

@@ -1,4 +1,4 @@
-import { createClass as _createClass, objectSpread2 as _objectSpread2, createForOfIteratorHelper as _createForOfIteratorHelper, typeof as _typeof, classCallCheck as _classCallCheck, asyncToGenerator as _asyncToGenerator, regenerator as _regenerator } from '../../_virtual/_rollupPluginBabelHelpers.js';
+import { createClass as _createClass, objectSpread2 as _objectSpread2, createForOfIteratorHelper as _createForOfIteratorHelper, typeof as _typeof, slicedToArray as _slicedToArray, classCallCheck as _classCallCheck, asyncToGenerator as _asyncToGenerator, regenerator as _regenerator } from '../../_virtual/_rollupPluginBabelHelpers.js';
 import * as THREE from 'three';
 import { CentralPlantValidator } from './centralPlantValidator.js';
 import { createTransformControls } from '../managers/controls/transformControlsManager.js';
@@ -1031,6 +1031,11 @@ var CentralPlantInternals = /*#__PURE__*/function () {
           });
         }
 
+        // Add attached IO device models for smart components
+        if (componentData.isSmart && componentData.attachedDevices) {
+          this._attachIODevicesToComponent(componentModel, componentData, modelPreloader, componentId);
+        }
+
         // Notify the component manager about the new component
         if (componentManager.registerComponent) {
           componentManager.registerComponent(componentModel);
@@ -1081,6 +1086,74 @@ var CentralPlantInternals = /*#__PURE__*/function () {
       }
     }
 
+    /**
+     * Attach IO device models to a smart component from cached models.
+     * Each device referenced in componentData.attachedDevices is looked up
+     * in the model preloader cache, cloned, positioned, and added as a child.
+     * @param {THREE.Object3D} componentModel - The parent component model
+     * @param {Object} componentData - Component dictionary entry (has attachedDevices)
+     * @param {Object} modelPreloader - ModelPreloader instance
+     * @param {string} parentComponentId - The parent component's UUID
+     * @private
+     */
+  }, {
+    key: "_attachIODevicesToComponent",
+    value: function _attachIODevicesToComponent(componentModel, componentData, modelPreloader, parentComponentId) {
+      var attachedDevices = componentData.attachedDevices;
+      console.log("\uD83D\uDD0C addComponent(): Attaching ".concat(Object.keys(attachedDevices).length, " IO devices to smart component"));
+      for (var _i = 0, _Object$entries = Object.entries(attachedDevices); _i < _Object$entries.length; _i++) {
+        var _Object$entries$_i = _slicedToArray(_Object$entries[_i], 2),
+          attachmentId = _Object$entries$_i[0],
+          attachment = _Object$entries$_i[1];
+        try {
+          var _modelPreloader$compo, _attachment$attachmen;
+          var deviceData = (_modelPreloader$compo = modelPreloader.componentDictionary) === null || _modelPreloader$compo === void 0 ? void 0 : _modelPreloader$compo[attachment.deviceId];
+          if (!deviceData || !deviceData.modelKey) {
+            console.warn("\u26A0\uFE0F IO device ".concat(attachment.deviceId, " not found in dictionary, skipping"));
+            continue;
+          }
+          var deviceModel = modelPreloader.getCachedModelWithDimensions(deviceData.modelKey, attachment.deviceId);
+          if (!deviceModel) {
+            console.warn("\u26A0\uFE0F IO device model not in cache: ".concat(deviceData.modelKey, ", skipping"));
+            continue;
+          }
+
+          // Name the device model
+          deviceModel.name = "".concat(attachment.attachmentLabel || 'IO Device', " (").concat(attachmentId, ")");
+
+          // Set user data for identification
+          deviceModel.userData = {
+            objectType: 'io-device',
+            deviceId: attachment.deviceId,
+            attachmentId: attachmentId,
+            attachmentLabel: attachment.attachmentLabel,
+            parentComponentId: parentComponentId
+          };
+
+          // Position at the attachment point
+          if ((_attachment$attachmen = attachment.attachmentPoint) !== null && _attachment$attachmen !== void 0 && _attachment$attachmen.position) {
+            var pos = attachment.attachmentPoint.position;
+            deviceModel.position.set(pos.x || 0, pos.y || 0, pos.z || 0);
+          }
+
+          // IO device models are authored at the same real-world unit scale
+          // as the host component, so keep them at their natural (1:1) size.
+          // Note: attachmentPoint.scale is the connector marker sphere size,
+          // NOT a desired device model scale.
+          deviceModel.scale.setScalar(1);
+
+          // Add as child of the component
+          componentModel.add(deviceModel);
+          console.log("\u2705 Attached IO device: ".concat(attachment.attachmentLabel || attachment.deviceId, " at"), {
+            position: deviceModel.position,
+            scale: deviceModel.scale
+          });
+        } catch (err) {
+          console.error("\u274C Error attaching IO device ".concat(attachment.deviceId, ":"), err);
+        }
+      }
+    }
+
     /**
      * Delete a component from the scene by componentId (internal implementation)
      * @param {string} componentId - The UUID of the component to delete