@2112-lab/central-plant 0.3.45 → 0.3.46

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

@@ -17,6 +17,7 @@ import { KeyboardControlsManager } from '../managers/controls/keyboardControlsMa
 import { PathfindingManager } from '../managers/pathfinding/pathfindingManager.js';
 import { PathFlowManager } from '../managers/pathfinding/PathFlowManager.js';
 import { SceneOperationsManager } from '../managers/scene/sceneOperationsManager.js';
+import { CollisionManager } from '../managers/scene/collisionManager.js';
 import { AnimationManager } from '../managers/scene/animationManager.js';
 import { CameraControlsManager } from '../managers/controls/cameraControlsManager.js';
 import { ComponentDragManager } from '../managers/controls/componentDragManager.js';
@@ -145,6 +146,7 @@ var CentralPlantInternals = /*#__PURE__*/function () {
       this.centralPlant.managers.keyboardControlsManager = new KeyboardControlsManager(this.centralPlant.sceneViewer);
       this.centralPlant.managers.pathfindingManager = new PathfindingManager(this.centralPlant.sceneViewer);
       this.centralPlant.managers.pathFlowManager = new PathFlowManager(this.centralPlant.sceneViewer);
+      this.centralPlant.managers.collisionManager = new CollisionManager(this.centralPlant.sceneViewer);
       this.centralPlant.managers.sceneOperationsManager = new SceneOperationsManager(this.centralPlant.sceneViewer);
       this.centralPlant.managers.animationManager = new AnimationManager(this.centralPlant.sceneViewer);
       this.centralPlant.managers.cameraControlsManager = new CameraControlsManager(this.centralPlant.sceneViewer);

package/dist/esm/src/managers/controls/componentDragManager.js

@@ -643,6 +643,7 @@ var ComponentDragManager = /*#__PURE__*/function (_BaseDisposable) {
       // Find intersection with ground plane
       var intersection = this.raycaster.ray.intersectPlane(this.dropPlane, this.dropIntersection);
       if (intersection) {
+        var _this$sceneViewer$col;
         // Apply 0.5 unit transform snapping to intersection point
         var snappedPosition = this._applyTransformSnap(intersection);
         this.dragData.previewObject.position.copy(snappedPosition);
@@ -650,7 +651,7 @@ var ComponentDragManager = /*#__PURE__*/function (_BaseDisposable) {
 
         // Check for overlap and update color accordingly
         var wasOverlapping = this.dragData.isOverlapping;
-        this.dragData.isOverlapping = this._checkBoundingBoxOverlap();
+        this.dragData.isOverlapping = !!((_this$sceneViewer$col = this.sceneViewer.collisionManager) !== null && _this$sceneViewer$col !== void 0 && _this$sceneViewer$col.checkCollision(this.dragData.previewObject));
 
         // Update color if overlap state changed
         if (wasOverlapping !== this.dragData.isOverlapping) {

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

@@ -0,0 +1,119 @@
+import { createClass as _createClass, createForOfIteratorHelper as _createForOfIteratorHelper, classCallCheck as _classCallCheck } from '../../../_virtual/_rollupPluginBabelHelpers.js';
+import * as THREE from 'three';
+
+var CollisionManager = /*#__PURE__*/function () {
+  /**
+   * @param {Object} sceneViewer - The scene viewer instance
+   */
+  function CollisionManager(sceneViewer) {
+    _classCallCheck(this, CollisionManager);
+    this.sceneViewer = sceneViewer;
+  }
+
+  /**
+   * Check if a given object overlaps with any other relevant objects in the scene.
+   * @param {THREE.Object3D} object - The object to check for collisions
+   * @param {Array<string>} excludeTypes - Object types to exclude from checking (e.g. ['ground'])
+   * @returns {Object|null} Collision info {object, objectType} if collision detected, null otherwise
+   */
+  return _createClass(CollisionManager, [{
+    key: "checkCollision",
+    value: function checkCollision(object) {
+      var _this$sceneViewer,
+        _this = this;
+      var excludeTypes = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : ['isBaseGround', 'isBaseGrid', 'isBrickWall'];
+      if (!((_this$sceneViewer = this.sceneViewer) !== null && _this$sceneViewer !== void 0 && _this$sceneViewer.scene) || !object) return null;
+
+      // Compute high-quality bounding box for the object being checked
+      // We use setFromObject here because the target object just moved
+      var objectBBox = new THREE.Box3().setFromObject(object);
+
+      // Narrow down potential colliders
+      var collisionDetected = null;
+
+      // Optimization: Only check the root-level CP objects to avoid O(N^2) complexity with meshes
+      this.sceneViewer.scene.traverse(function (child) {
+        var _child$userData, _child$userData2, _child$userData3, _child$userData4, _child$userData5;
+        if (collisionDetected) return; // Short circuit
+
+        // Skip the object itself and its descendants
+        if (child === object || _this._isDescendantOf(object, child)) return;
+
+        // Filter by CP object types at the root level (skip internal meshes during traverse)
+        var isCPRootObject = ((_child$userData = child.userData) === null || _child$userData === void 0 ? void 0 : _child$userData.objectType) === 'component' || ((_child$userData2 = child.userData) === null || _child$userData2 === void 0 ? void 0 : _child$userData2.objectType) === 'segment' || ((_child$userData3 = child.userData) === null || _child$userData3 === void 0 ? void 0 : _child$userData3.objectType) === 'gateway' || ((_child$userData4 = child.userData) === null || _child$userData4 === void 0 ? void 0 : _child$userData4.objectType) === 'connector' || ((_child$userData5 = child.userData) === null || _child$userData5 === void 0 ? void 0 : _child$userData5.ioConfig); // IO Device
+
+        if (isCPRootObject && !_this._shouldExclude(child, excludeTypes)) {
+          // Use cached worldBoundingBox if available, otherwise compute it (and cache it)
+          var childBBox;
+          if (child.userData.worldBoundingBox && !child.userData.isMoving) {
+            var _min$x, _min$y, _min$z, _max$x, _max$y, _max$z;
+            // Use stored worldBoundingBox (handles array or Box3 format)
+            var min = child.userData.worldBoundingBox.min;
+            var max = child.userData.worldBoundingBox.max;
+            childBBox = new THREE.Box3(new THREE.Vector3((_min$x = min.x) !== null && _min$x !== void 0 ? _min$x : min[0], (_min$y = min.y) !== null && _min$y !== void 0 ? _min$y : min[1], (_min$z = min.z) !== null && _min$z !== void 0 ? _min$z : min[2]), new THREE.Vector3((_max$x = max.x) !== null && _max$x !== void 0 ? _max$x : max[0], (_max$y = max.y) !== null && _max$y !== void 0 ? _max$y : max[1], (_max$z = max.z) !== null && _max$z !== void 0 ? _max$z : max[2]));
+          } else {
+            // Fallback to high-quality computation for moving objects or first-time checks
+            childBBox = new THREE.Box3().setFromObject(child);
+
+            // Cache the result for next time (non-moving objects)
+            if (!child.userData.isMoving) {
+              child.userData.worldBoundingBox = {
+                min: [childBBox.min.x, childBBox.min.y, childBBox.min.z],
+                max: [childBBox.max.x, childBBox.max.y, childBBox.max.z]
+              };
+            }
+          }
+          if (objectBBox.intersectsBox(childBBox)) {
+            collisionDetected = {
+              object: child,
+              objectType: child.userData.objectType,
+              uuid: child.uuid,
+              name: child.name || child.userData.libraryId || child.uuid
+            };
+          }
+        }
+      });
+      return collisionDetected;
+    }
+
+    /**
+     * Helper to check if a node is a descendant of a specific parent
+     * @private
+     */
+  }, {
+    key: "_isDescendantOf",
+    value: function _isDescendantOf(parent, child) {
+      var node = child.parent;
+      while (node !== null) {
+        if (node === parent) return true;
+        node = node.parent;
+      }
+      return false;
+    }
+
+    /**
+     * Helper to determine if an object should be excluded from collision checking
+     * @private
+     */
+  }, {
+    key: "_shouldExclude",
+    value: function _shouldExclude(object, excludeTypes) {
+      if (object.userData.isPreview) return true;
+      var _iterator = _createForOfIteratorHelper(excludeTypes),
+        _step;
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var type = _step.value;
+          if (object.userData[type]) return true;
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+      return false;
+    }
+  }]);
+}();
+
+export { CollisionManager };

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

@@ -145,6 +145,8 @@ var SceneExportManager = /*#__PURE__*/function () {
           // Internal tracking - not needed in export
           'initialPosition',
           // Internal tracking - not needed in export
+          'attachedDevices',
+          // Stored in smart component dictionary, not scene JSON
           // Exclude internal segment tracking properties
           'segmentId',
           // Internal tracking

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

@@ -1309,55 +1309,20 @@ var SceneOperationsManager = /*#__PURE__*/function () {
             y: componentModel.scale.y,
             z: componentModel.scale.z
           },
-          userData: _objectSpread2(_objectSpread2({}, componentModel.userData), {}, {
+          userData: _objectSpread2(_objectSpread2({}, function () {
+            var ud = _objectSpread2({}, componentModel.userData);
+            delete ud.attachedDevices; // Instance data belongs in dictionary, not scene JSON
+            delete ud.isDeclared; // Runtime flag
+            delete ud.originalUuid; // Runtime tracking
+            return ud;
+          }()), {}, {
             worldBoundingBox: {
               min: boundingBox.min.toArray(),
               max: boundingBox.max.toArray()
             }
-          }),
-          children: []
+          })
         };
 
-        // Process children (connectors, etc.) if they exist
-        if (componentModel.children && componentModel.children.length > 0) {
-          componentModel.children.forEach(function (child) {
-            var _child$userData0, _child$userData1;
-            var childType = ((_child$userData0 = child.userData) === null || _child$userData0 === void 0 ? void 0 : _child$userData0.objectType) || ((_child$userData1 = child.userData) === null || _child$userData1 === void 0 ? void 0 : _child$userData1.objectType);
-            if (childType === 'connector') {
-              var _child$geometry;
-              var childBoundingBox = new THREE.Box3().setFromObject(child);
-              var childSceneData = {
-                uuid: child.uuid,
-                name: child.name,
-                type: child.type,
-                position: {
-                  x: child.position.x,
-                  y: child.position.y,
-                  z: child.position.z
-                },
-                rotation: {
-                  x: THREE.MathUtils.radToDeg(child.rotation.x),
-                  y: THREE.MathUtils.radToDeg(child.rotation.y),
-                  z: THREE.MathUtils.radToDeg(child.rotation.z)
-                },
-                scale: {
-                  x: child.scale.x,
-                  y: child.scale.y,
-                  z: child.scale.z
-                },
-                userData: _objectSpread2(_objectSpread2({}, child.userData), {}, {
-                  worldBoundingBox: {
-                    min: childBoundingBox.min.toArray(),
-                    max: childBoundingBox.max.toArray()
-                  }
-                }),
-                geometry: ((_child$geometry = child.geometry) === null || _child$geometry === void 0 ? void 0 : _child$geometry.uuid) || 'CONNECTOR-GEO'
-              };
-              componentSceneData.children.push(childSceneData);
-            }
-          });
-        }
-
         // Add the component to the scene data
         if (!currentSceneData.scene.children) {
           currentSceneData.scene.children = [];
@@ -1366,7 +1331,6 @@ var SceneOperationsManager = /*#__PURE__*/function () {
         console.log('✅ addComponentToSceneData: Component added to scene data successfully', {
           componentId: componentModel.uuid,
           libraryId: (_componentModel$userD = componentModel.userData) === null || _componentModel$userD === void 0 ? void 0 : _componentModel$userD.libraryId,
-          childrenCount: componentSceneData.children.length,
           totalSceneChildren: currentSceneData.scene.children.length
         });
         return true;
@@ -1407,8 +1371,8 @@ var SceneOperationsManager = /*#__PURE__*/function () {
       if (segment.children && segment.children.length > 0) {
         var childrenToRemove = _toConsumableArray(segment.children);
         childrenToRemove.forEach(function (child) {
-          var _child$userData10;
-          if ((_child$userData10 = child.userData) !== null && _child$userData10 !== void 0 && _child$userData10.isPipeElbow) {
+          var _child$userData0;
+          if ((_child$userData0 = child.userData) !== null && _child$userData0 !== void 0 && _child$userData0.isPipeElbow) {
             console.log("\uD83D\uDDD1\uFE0F Removing elbow child from segment before manualization: ".concat(child.uuid));
             segment.remove(child);
             if (child.geometry) child.geometry.dispose();

package/package.json

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