@2112-lab/central-plant 0.1.77 → 0.1.78

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

@@ -3,6 +3,7 @@ import * as THREE from 'three';
 import { loadTextureSet } from '../environment/textureConfig.js';
 import { ModelManager } from './modelManager.js';
 import { SceneClearingUtility } from '../../utils/sceneClearingUtility.js';
+import { computeFilteredBoundingBox, computeIODeviceBoundingBoxes } from '../../utils/boundingBoxUtils.js';
 
 var _excluded = ["direction"],
   _excluded2 = ["direction"];
@@ -618,6 +619,8 @@ var SceneOperationsManager = /*#__PURE__*/function () {
 
     /**
      * Helper function to compute world bounding boxes
+     * For components: uses filtered bbox (excludes io-device and connector subtrees)
+     * For io-devices: computes separate bounding boxes and injects them as children
      */
   }, {
     key: "computeWorldBoundingBoxes",
@@ -656,12 +659,46 @@ var SceneOperationsManager = /*#__PURE__*/function () {
           };
           jsonObject = _findJsonObject(data.scene.children);
           if (jsonObject) {
-            // Compute world bounding box
-            var boundingBox = new THREE.Box3().setFromObject(object);
-
             // Store in JSON userData for pathfinder (skip for gateways - they're just routing points)
             if (!jsonObject.userData) jsonObject.userData = {};
-            if (jsonObject.userData.objectType !== 'gateway') {
+            if (jsonObject.userData.objectType === 'component') {
+              // For components: compute filtered bounding box (excludes io-device and connector subtrees)
+              var filteredBBox = computeFilteredBoundingBox(object, ['io-device', 'connector']);
+              jsonObject.userData.worldBoundingBox = {
+                min: filteredBBox.min.toArray(),
+                max: filteredBBox.max.toArray()
+              };
+              console.log("Added filtered world bounding box for component:", jsonObject.userData.worldBoundingBox);
+
+              // Compute and inject separate io-device bounding boxes as children
+              var ioDeviceBBoxes = computeIODeviceBoundingBoxes(object);
+              if (ioDeviceBBoxes.length > 0) {
+                if (!jsonObject.children) jsonObject.children = [];
+                ioDeviceBBoxes.forEach(function (deviceBBox) {
+                  var existingIndex = jsonObject.children.findIndex(function (c) {
+                    return c.uuid === deviceBBox.uuid;
+                  });
+                  if (existingIndex >= 0) {
+                    // Update existing entry
+                    if (!jsonObject.children[existingIndex].userData) jsonObject.children[existingIndex].userData = {};
+                    jsonObject.children[existingIndex].userData.objectType = 'io-device';
+                    jsonObject.children[existingIndex].userData.worldBoundingBox = deviceBBox.worldBoundingBox;
+                  } else {
+                    // Create new entry
+                    jsonObject.children.push({
+                      uuid: deviceBBox.uuid,
+                      userData: _objectSpread2(_objectSpread2({}, deviceBBox.userData), {}, {
+                        worldBoundingBox: deviceBBox.worldBoundingBox
+                      }),
+                      children: []
+                    });
+                  }
+                });
+                console.log("\uD83D\uDCE6 Injected ".concat(ioDeviceBBoxes.length, " io-device bbox(es) for component ").concat(jsonObject.uuid));
+              }
+            } else if (jsonObject.userData.objectType !== 'gateway') {
+              // For non-component, non-gateway objects: standard bounding box
+              var boundingBox = new THREE.Box3().setFromObject(object);
               jsonObject.userData.worldBoundingBox = {
                 min: boundingBox.min.toArray(),
                 max: boundingBox.max.toArray()

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

@@ -0,0 +1,329 @@
+import { createForOfIteratorHelper as _createForOfIteratorHelper } from '../../_virtual/_rollupPluginBabelHelpers.js';
+import * as THREE from '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.BufferGeometry();
+  geometry.setIndex(new THREE.BufferAttribute(indices, 1));
+  geometry.setAttribute('position', new THREE.BufferAttribute(positions, 3));
+  var helper = new THREE.LineSegments(geometry, new THREE.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.Box3();
+  var tempBox = new THREE.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.Vector3();
+    object.getWorldPosition(position);
+    box.setFromCenterAndSize(position, new THREE.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 = _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.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 = _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.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.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 = _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.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();
+  }
+}
+
+export { computeFilteredBoundingBox, computeIODeviceBoundingBoxes, createSelectionBoxHelpers, updateSelectionBoxHelpers };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@2112-lab/central-plant",
-  "version": "0.1.77",
+  "version": "0.1.78",
   "description": "Utility modules for the Central Plant Application",
   "main": "dist/bundle/index.js",
   "module": "dist/esm/index.js",