@2112-lab/central-plant 0.1.76 → 0.1.78

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

@@ -1,4 +1,4 @@
-import { inherits as _inherits, createClass as _createClass, superPropGet as _superPropGet, classCallCheck as _classCallCheck, callSuper as _callSuper, asyncToGenerator as _asyncToGenerator, regenerator as _regenerator } from '../../../_virtual/_rollupPluginBabelHelpers.js';
+import { inherits as _inherits, createClass as _createClass, superPropGet as _superPropGet, classCallCheck as _classCallCheck, callSuper as _callSuper, asyncToGenerator as _asyncToGenerator, regenerator as _regenerator, slicedToArray as _slicedToArray } from '../../../_virtual/_rollupPluginBabelHelpers.js';
 import { BaseDisposable } from '../../core/baseDisposable.js';
 import * as THREE from 'three';
 
@@ -167,7 +167,7 @@ var ComponentDragManager = /*#__PURE__*/function (_BaseDisposable) {
               console.log("\uD83D\uDD0D ModelPreloader available:", !!modelPreloader);
               console.log("\uD83D\uDD0D ComponentDictionary available:", !!(modelPreloader !== null && modelPreloader !== void 0 && modelPreloader.componentDictionary));
               if (!(modelPreloader && modelPreloader.componentDictionary)) {
-                _context2.n = 13;
+                _context2.n = 14;
                 break;
               }
               console.log("\uD83D\uDCDA Available dictionary keys:", Object.keys(modelPreloader.componentDictionary));
@@ -183,7 +183,7 @@ var ComponentDragManager = /*#__PURE__*/function (_BaseDisposable) {
                 });
               }
               if (!(componentData && componentData.modelKey)) {
-                _context2.n = 11;
+                _context2.n = 12;
                 break;
               }
               // Try to get cached model first
@@ -223,7 +223,7 @@ var ComponentDragManager = /*#__PURE__*/function (_BaseDisposable) {
               console.warn("\u26A0\uFE0F Failed to preload model ".concat(componentData.modelKey, ":"), _t2);
             case 8:
               if (!cachedModel) {
-                _context2.n = 9;
+                _context2.n = 10;
                 break;
               }
               this.dragData.previewObject = cachedModel.clone();
@@ -234,6 +234,14 @@ var ComponentDragManager = /*#__PURE__*/function (_BaseDisposable) {
               // Store original colors BEFORE making transparent
               this._storeOriginalColors(this.dragData.previewObject);
 
+              // For smart components, load and attach IO device models to the preview
+              if (!(componentData.isSmart && componentData.attachedDevices)) {
+                _context2.n = 9;
+                break;
+              }
+              _context2.n = 9;
+              return this._attachIODeviceModelsToPreview(this.dragData.previewObject, componentData, modelPreloader);
+            case 9:
               // Make the preview semi-transparent
               this._setPreviewTransparency(this.dragData.previewObject, 0.5);
               this.dragData.previewObject.userData = {
@@ -247,19 +255,19 @@ var ComponentDragManager = /*#__PURE__*/function (_BaseDisposable) {
               this.sceneViewer.scene.add(this.dragData.previewObject);
               console.log("\u2705 Created ".concat(componentData.isS3Component ? 'S3' : 'static', " GLB preview object for: ").concat(componentId));
               return _context2.a(2);
-            case 9:
-              console.warn("\u26A0\uFE0F Failed to load model for ".concat(componentId, ", will use fallback"));
             case 10:
-              _context2.n = 12;
-              break;
+              console.warn("\u26A0\uFE0F Failed to load model for ".concat(componentId, ", will use fallback"));
             case 11:
-              console.warn("\u26A0\uFE0F No modelKey found for component ".concat(componentId));
-            case 12:
-              _context2.n = 14;
+              _context2.n = 13;
               break;
+            case 12:
+              console.warn("\u26A0\uFE0F No modelKey found for component ".concat(componentId));
             case 13:
-              console.warn("\u26A0\uFE0F ModelPreloader or component dictionary not available");
+              _context2.n = 15;
+              break;
             case 14:
+              console.warn("\u26A0\uFE0F ModelPreloader or component dictionary not available");
+            case 15:
               // Fallback: Create a simple preview mesh if model not available
               geometry = new THREE.BoxGeometry(1, 1, 1);
               material = new THREE.MeshPhysicalMaterial({
@@ -282,7 +290,7 @@ var ComponentDragManager = /*#__PURE__*/function (_BaseDisposable) {
               this.dragData.previewObject.position.set(1000, 1000, 1000);
               this.sceneViewer.scene.add(this.dragData.previewObject);
               console.log("\u26A0\uFE0F Created fallback wireframe preview for: ".concat(componentId));
-            case 15:
+            case 16:
               return _context2.a(2);
           }
         }, _callee2, this, [[5, 7], [1, 3]]);
@@ -292,6 +300,111 @@ var ComponentDragManager = /*#__PURE__*/function (_BaseDisposable) {
       }
       return _createPreviewObject;
     }()
+    /**
+     * Load and attach IO device models to a smart component preview
+     * @param {THREE.Object3D} parentObject - The parent preview object
+     * @param {Object} componentData - Component dictionary entry (must have attachedDevices)
+     * @param {Object} modelPreloader - ModelPreloader instance
+     * @private
+     */
+    )
+  }, {
+    key: "_attachIODeviceModelsToPreview",
+    value: (function () {
+      var _attachIODeviceModelsToPreview2 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee3(parentObject, componentData, modelPreloader) {
+        var _i, _Object$entries, _Object$entries$_i, attachmentId, attachment, _modelPreloader$compo, _attachment$attachmen, deviceData, cachedDevice, _modelPreloader$loadi, deviceModel, pos, _t3;
+        return _regenerator().w(function (_context3) {
+          while (1) switch (_context3.n) {
+            case 0:
+              if (componentData.attachedDevices) {
+                _context3.n = 1;
+                break;
+              }
+              return _context3.a(2);
+            case 1:
+              _i = 0, _Object$entries = Object.entries(componentData.attachedDevices);
+            case 2:
+              if (!(_i < _Object$entries.length)) {
+                _context3.n = 12;
+                break;
+              }
+              _Object$entries$_i = _slicedToArray(_Object$entries[_i], 2), attachmentId = _Object$entries$_i[0], attachment = _Object$entries$_i[1];
+              _context3.p = 3;
+              deviceData = (_modelPreloader$compo = modelPreloader.componentDictionary) === null || _modelPreloader$compo === void 0 ? void 0 : _modelPreloader$compo[attachment.deviceId];
+              if (!(!deviceData || !deviceData.modelKey)) {
+                _context3.n = 4;
+                break;
+              }
+              console.warn("\u26A0\uFE0F IO device ".concat(attachment.deviceId, " not found in dictionary for preview"));
+              return _context3.a(3, 11);
+            case 4:
+              // Ensure device model is loaded
+              cachedDevice = modelPreloader.getCachedModelWithDimensions(deviceData.modelKey, attachment.deviceId);
+              if (cachedDevice) {
+                _context3.n = 8;
+                break;
+              }
+              if (!((_modelPreloader$loadi = modelPreloader.loadingPromises) !== null && _modelPreloader$loadi !== void 0 && _modelPreloader$loadi.has(deviceData.modelKey))) {
+                _context3.n = 6;
+                break;
+              }
+              _context3.n = 5;
+              return modelPreloader.loadingPromises.get(deviceData.modelKey);
+            case 5:
+              _context3.n = 7;
+              break;
+            case 6:
+              _context3.n = 7;
+              return modelPreloader.preloadSingleModel(deviceData.modelKey);
+            case 7:
+              cachedDevice = modelPreloader.getCachedModelWithDimensions(deviceData.modelKey, attachment.deviceId);
+            case 8:
+              if (cachedDevice) {
+                _context3.n = 9;
+                break;
+              }
+              console.warn("\u26A0\uFE0F Could not load IO device model: ".concat(deviceData.modelKey));
+              return _context3.a(3, 11);
+            case 9:
+              deviceModel = cachedDevice.clone();
+              this._cloneMaterials(deviceModel);
+              this._storeOriginalColors(deviceModel);
+              deviceModel.userData = {
+                objectType: 'io-device',
+                deviceId: attachment.deviceId,
+                attachmentId: attachmentId,
+                attachmentLabel: attachment.attachmentLabel
+              };
+              if ((_attachment$attachmen = attachment.attachmentPoint) !== null && _attachment$attachmen !== void 0 && _attachment$attachmen.position) {
+                pos = attachment.attachmentPoint.position;
+                deviceModel.position.set(pos.x || 0, pos.y || 0, pos.z || 0);
+              }
+
+              // IO device models use their natural (1:1) scale — the stored
+              // attachmentPoint.scale value is for the connector marker sphere.
+              deviceModel.scale.setScalar(1);
+              parentObject.add(deviceModel);
+              console.log("\u2705 Attached IO device preview: ".concat(attachment.attachmentLabel || attachment.deviceId));
+              _context3.n = 11;
+              break;
+            case 10:
+              _context3.p = 10;
+              _t3 = _context3.v;
+              console.warn("\u26A0\uFE0F Could not attach IO device model ".concat(attachment.deviceId, " to preview:"), _t3);
+            case 11:
+              _i++;
+              _context3.n = 2;
+              break;
+            case 12:
+              return _context3.a(2);
+          }
+        }, _callee3, this, [[3, 10]]);
+      }));
+      function _attachIODeviceModelsToPreview(_x5, _x6, _x7) {
+        return _attachIODeviceModelsToPreview2.apply(this, arguments);
+      }
+      return _attachIODeviceModelsToPreview;
+    }()
     /**
      * Clone all materials in an object hierarchy to avoid shared material issues
      * @param {THREE.Object3D} object - The object to clone materials for
@@ -439,8 +552,8 @@ var ComponentDragManager = /*#__PURE__*/function (_BaseDisposable) {
       });
 
       // Check for overlaps
-      for (var _i = 0, _sceneMeshes = sceneMeshes; _i < _sceneMeshes.length; _i++) {
-        var mesh = _sceneMeshes[_i];
+      for (var _i2 = 0, _sceneMeshes = sceneMeshes; _i2 < _sceneMeshes.length; _i2++) {
+        var mesh = _sceneMeshes[_i2];
         var meshBBox = new THREE.Box3().setFromObject(mesh);
         if (previewBBox.intersectsBox(meshBBox)) {
           console.log('⚠️ ComponentDragManager: Overlap detected with:', mesh.userData.objectType || mesh.name || mesh.uuid);
@@ -754,50 +867,50 @@ var ComponentDragManager = /*#__PURE__*/function (_BaseDisposable) {
       var _this3 = this;
       if (!element || !componentId) return;
       var handleMouseDown = /*#__PURE__*/function () {
-        var _ref = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee3(event) {
-          return _regenerator().w(function (_context3) {
-            while (1) switch (_context3.n) {
+        var _ref = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee4(event) {
+          return _regenerator().w(function (_context4) {
+            while (1) switch (_context4.n) {
               case 0:
                 if (!(event.button !== 0)) {
-                  _context3.n = 1;
+                  _context4.n = 1;
                   break;
                 }
-                return _context3.a(2);
+                return _context4.a(2);
               case 1:
                 // Only left mouse button
                 event.preventDefault();
-                _context3.n = 2;
+                _context4.n = 2;
                 return _this3.startComponentDrag(componentId, element, event);
               case 2:
-                return _context3.a(2);
+                return _context4.a(2);
             }
-          }, _callee3);
+          }, _callee4);
         }));
-        return function handleMouseDown(_x5) {
+        return function handleMouseDown(_x8) {
           return _ref.apply(this, arguments);
         };
       }();
       var handleTouchStart = /*#__PURE__*/function () {
-        var _ref2 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee4(event) {
-          return _regenerator().w(function (_context4) {
-            while (1) switch (_context4.n) {
+        var _ref2 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee5(event) {
+          return _regenerator().w(function (_context5) {
+            while (1) switch (_context5.n) {
               case 0:
                 if (!(event.touches.length !== 1)) {
-                  _context4.n = 1;
+                  _context5.n = 1;
                   break;
                 }
-                return _context4.a(2);
+                return _context5.a(2);
               case 1:
                 // Only single touch
                 event.preventDefault();
-                _context4.n = 2;
+                _context5.n = 2;
                 return _this3.startComponentDrag(componentId, element, event);
               case 2:
-                return _context4.a(2);
+                return _context5.a(2);
             }
-          }, _callee4);
+          }, _callee5);
         }));
-        return function handleTouchStart(_x6) {
+        return function handleTouchStart(_x9) {
           return _ref2.apply(this, arguments);
         };
       }();

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

@@ -2,6 +2,7 @@ import { createClass as _createClass, asyncToGenerator as _asyncToGenerator, reg
 import * as THREE from 'three';
 import { transformControls } from './transformControls.js';
 import { isSegment, isGateway } from '../../utils/objectTypes.js';
+import { createSelectionBoxHelpers, updateSelectionBoxHelpers } from '../../utils/boundingBoxUtils.js';
 
 var TransformControlsManager = /*#__PURE__*/function () {
   function TransformControlsManager(scene, camera, renderer) {
@@ -918,23 +919,16 @@ var TransformControlsManager = /*#__PURE__*/function () {
         return;
       }
       try {
-        // Create individual bounding boxes for each selected object
+        // Create bounding box helpers for each selected object
+        // Smart components get filtered helpers (component body + individual io-device boxes)
         this.selectedObjects.forEach(function (obj) {
-          var boundingBoxHelper = new THREE.BoxHelper(obj, _this5.config.boundingBoxColor);
-
-          // Mark it as a helper to avoid selection
-          boundingBoxHelper.isHelper = true;
-          boundingBoxHelper.userData = {
-            isBoundingBox: true
-          };
-
-          // Add to scene
-          _this5.scene.add(boundingBoxHelper);
-
-          // Store in array for later cleanup
-          _this5.boundingBoxHelpers.push(boundingBoxHelper);
+          var helpers = createSelectionBoxHelpers(obj, _this5.config.boundingBoxColor);
+          helpers.forEach(function (helper) {
+            _this5.scene.add(helper);
+            _this5.boundingBoxHelpers.push(helper);
+          });
         });
-        console.log("\uD83D\uDCE6 Bounding boxes created for ".concat(this.selectedObjects.length, " object(s)"));
+        console.log("\uD83D\uDCE6 Bounding boxes created for ".concat(this.selectedObjects.length, " object(s) (").concat(this.boundingBoxHelpers.length, " helpers)"));
       } catch (error) {
         console.warn('⚠️ Failed to create bounding boxes:', error);
       }
@@ -1065,21 +1059,19 @@ var TransformControlsManager = /*#__PURE__*/function () {
       // Update bounding boxes for all selected objects
       if (this.selectedObjects.length > 0 && this.boundingBoxHelpers.length > 0) {
         try {
-          // Update each bounding box helper
-          this.boundingBoxHelpers.forEach(function (helper, index) {
-            var obj = _this6.selectedObjects[index];
-            if (obj) {
-              // Force object matrix update to ensure correct bounding box
-              obj.updateMatrixWorld(true);
-
-              // Update bounding box
-              helper.update();
-
-              // Also update the cached bounding box if it exists
-              if (_this6.boundingBoxCache.has(obj)) {
-                var updatedBoundingBox = new THREE.Box3().setFromObject(obj);
-                _this6.boundingBoxCache.set(obj, updatedBoundingBox);
-              }
+          // Ensure all selected objects have up-to-date matrices
+          this.selectedObjects.forEach(function (obj) {
+            return obj.updateMatrixWorld(true);
+          });
+
+          // Use the centralized update function which handles filtered, io-device, and standard helpers
+          updateSelectionBoxHelpers(this.boundingBoxHelpers, this.selectedObjects, this.scene);
+
+          // Also update the cached bounding box if it exists
+          this.selectedObjects.forEach(function (obj) {
+            if (_this6.boundingBoxCache.has(obj)) {
+              var updatedBoundingBox = new THREE.Box3().setFromObject(obj);
+              _this6.boundingBoxCache.set(obj, updatedBoundingBox);
             }
           });
         } catch (error) {

package/dist/esm/src/managers/pathfinding/pathfindingManager.js

@@ -3,6 +3,7 @@ import * as THREE from 'three';
 import { Pathfinder } from '@2112-lab/pathfinder';
 import { BaseDisposable } from '../../core/baseDisposable.js';
 import { PathData } from '../../core/pathfindingData.js';
+import { computeFilteredBoundingBox, computeIODeviceBoundingBoxes } from '../../utils/boundingBoxUtils.js';
 import { SceneDataManager } from './sceneDataManager.js';
 import { PathRenderingManager } from './PathRenderingManager.js';
 import { ConnectorManager } from './ConnectorManager.js';
@@ -153,20 +154,63 @@ var PathfindingManager = /*#__PURE__*/function (_BaseDisposable) {
           // Find the actual component object in the scene
           var componentObject = _this3.sceneViewer.scene.getObjectByProperty('uuid', child.uuid);
           if (componentObject) {
-            // Compute world bounding box
-            var _worldBBox = new THREE.Box3().setFromObject(componentObject);
-            console.log("\uD83D\uDD04 Updated worldBoundingBox for component ".concat(child.uuid, ": min=[").concat(_worldBBox.min.x.toFixed(2), ", ").concat(_worldBBox.min.y.toFixed(2), ", ").concat(_worldBBox.min.z.toFixed(2), "], max=[").concat(_worldBBox.max.x.toFixed(2), ", ").concat(_worldBBox.max.y.toFixed(2), ", ").concat(_worldBBox.max.z.toFixed(2), "]"));
+            // Compute FILTERED bounding box — excludes io-device and connector subtrees
+            // so the component body bbox is tight-fitting and doesn't envelop attached devices
+            var filteredBBox = computeFilteredBoundingBox(componentObject, ['io-device', 'connector']);
+            console.log("\uD83D\uDD04 Updated worldBoundingBox for component ".concat(child.uuid, " (filtered): min=[").concat(filteredBBox.min.x.toFixed(2), ", ").concat(filteredBBox.min.y.toFixed(2), ", ").concat(filteredBBox.min.z.toFixed(2), "], max=[").concat(filteredBBox.max.x.toFixed(2), ", ").concat(filteredBBox.max.y.toFixed(2), ", ").concat(filteredBBox.max.z.toFixed(2), "]"));
 
-            // Return enriched component data with worldBoundingBox in userData
-            // Note: pathfinder expects arrays [x, y, z] format for min/max
-            return _objectSpread2(_objectSpread2({}, child), {}, {
+            // Build the enriched component entry
+            var enrichedChild = _objectSpread2(_objectSpread2({}, child), {}, {
               userData: _objectSpread2(_objectSpread2({}, child.userData), {}, {
                 worldBoundingBox: {
-                  min: [_worldBBox.min.x, _worldBBox.min.y, _worldBBox.min.z],
-                  max: [_worldBBox.max.x, _worldBBox.max.y, _worldBBox.max.z]
+                  min: [filteredBBox.min.x, filteredBBox.min.y, filteredBBox.min.z],
+                  max: [filteredBBox.max.x, filteredBBox.max.y, filteredBBox.max.z]
                 }
               })
             });
+
+            // Compute separate bounding boxes for each attached io-device
+            // These are injected as children so the pathfinder treats each as an independent obstacle
+            var ioDeviceBBoxes = computeIODeviceBoundingBoxes(componentObject);
+            if (ioDeviceBBoxes.length > 0) {
+              // Ensure children array exists (may already contain connectors)
+              if (!enrichedChild.children) {
+                enrichedChild.children = [];
+              }
+
+              // Inject io-device entries with their own worldBoundingBox
+              ioDeviceBBoxes.forEach(function (deviceBBox) {
+                // Check if this io-device already exists in scene data children
+                var existingIndex = enrichedChild.children.findIndex(function (c) {
+                  return c.uuid === deviceBBox.uuid;
+                });
+                if (existingIndex >= 0) {
+                  // Update existing entry with bounding box
+                  enrichedChild.children[existingIndex] = _objectSpread2(_objectSpread2({}, enrichedChild.children[existingIndex]), {}, {
+                    userData: _objectSpread2(_objectSpread2({}, enrichedChild.children[existingIndex].userData), {}, {
+                      objectType: 'io-device',
+                      worldBoundingBox: deviceBBox.worldBoundingBox
+                    })
+                  });
+                } else {
+                  // Create new entry for the io-device
+                  enrichedChild.children.push({
+                    uuid: deviceBBox.uuid,
+                    userData: _objectSpread2(_objectSpread2({}, deviceBBox.userData), {}, {
+                      worldBoundingBox: deviceBBox.worldBoundingBox
+                    }),
+                    children: []
+                  });
+                }
+                console.log("\uD83D\uDCE6 Injected io-device bbox for ".concat(deviceBBox.uuid, ": min=[").concat(deviceBBox.worldBoundingBox.min.map(function (v) {
+                  return v.toFixed(2);
+                }).join(', '), "], max=[").concat(deviceBBox.worldBoundingBox.max.map(function (v) {
+                  return v.toFixed(2);
+                }).join(', '), "]"));
+              });
+              console.log("\uD83D\uDCE6 Injected ".concat(ioDeviceBBoxes.length, " io-device bounding box(es) for component ").concat(child.uuid));
+            }
+            return enrichedChild;
           } else {
             console.warn("\u26A0\uFE0F Could not find component object in scene: ".concat(child.uuid));
           }

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()