@2112-lab/central-plant 0.3.49 → 0.3.51

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

@@ -1,11 +1,12 @@
 import { inherits as _inherits, createClass as _createClass, typeof as _typeof, classCallCheck as _classCallCheck, callSuper as _callSuper, asyncToGenerator as _asyncToGenerator, regenerator as _regenerator, objectSpread2 as _objectSpread2 } from '../../_virtual/_rollupPluginBabelHelpers.js';
-import 'three';
+import * as THREE from 'three';
 import { BaseDisposable } from './baseDisposable.js';
 import { DisposalUtilities } from '../utils/DisposalUtilities.js';
 import { CentralPlantInternals } from './centralPlantInternals.js';
 import '../rendering/modelPreloader.js';
 import { scanSceneIoEndpoints, applyCrossComponentBehaviors, loadCrossComponentBehaviors, reregisterSceneBehaviors } from '../utils/behaviorSceneUtils.js';
 import { getScopedAttachmentKey } from '../utils/behaviorDispatch.js';
+import { computeFilteredBoundingBox } from '../utils/boundingBoxUtils.js';
 
 // ─────────────────────────────────────────────────────────────────────────────
 // Flow-direction compatibility helper (module-level, no class dependency)
@@ -33,7 +34,7 @@ var CentralPlant = /*#__PURE__*/function (_BaseDisposable) {
    * Initialize the CentralPlant manager
    * 
    * @constructor
-   * @version 0.3.49
+   * @version 0.3.51
    * @updated 2025-10-22
    * 
    * @description Creates a new CentralPlant instance and initializes internal managers and utilities.
@@ -1909,6 +1910,98 @@ var CentralPlant = /*#__PURE__*/function (_BaseDisposable) {
       }
     }
 
+    /**
+     * Get the world-space axis-aligned bounding box for a scene object.
+     * @param {string|THREE.Object3D} objectOrId - The object's UUID/name, or the Three.js object itself
+     * @param {Object} [options={}] - Bounding box options
+     * @param {boolean} [options.filtered=true] - When true, exclude connector and io-device
+     *   subtrees so the box reflects the component body footprint. When false, the box
+     *   envelops all descendants (equivalent to THREE.Box3.setFromObject).
+     * @param {string[]} [options.excludeTypes] - Override the userData.objectType values to
+     *   exclude (defaults to ['io-device', 'connector'] when filtered is true).
+     * @returns {{min: {x,y,z}, max: {x,y,z}, size: {x,y,z}, center: {x,y,z}}|null}
+     *   The bounding box descriptor in world space, or null if the object can't be found
+     *   or has no geometry.
+     * @description Computes a tight world-space bounding box for a component (or any scene
+     * object). By default the component body is measured independently of its attached
+     * connectors and io-devices, which is useful for layout and spacing operations.
+     * @example
+     * // Component body bounding box (excludes connectors / io-devices)
+     * const bbox = centralPlant.getBoundingBox('PUMP-1');
+     * console.log(bbox.size.x, bbox.size.y, bbox.size.z);
+     *
+     * @example
+     * // Full bounding box including connectors and io-devices
+     * const fullBox = centralPlant.getBoundingBox('PUMP-1', { filtered: false });
+     *
+     * @since 0.3.50
+     */
+  }, {
+    key: "getBoundingBox",
+    value: function getBoundingBox(objectOrId) {
+      var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+      if (!this.sceneViewer || !this.sceneViewer.scene) {
+        console.warn('⚠️ getBoundingBox(): Scene viewer or scene not available');
+        return null;
+      }
+      var _options$filtered = options.filtered,
+        filtered = _options$filtered === void 0 ? true : _options$filtered,
+        excludeTypes = options.excludeTypes;
+
+      // Resolve the target object
+      var object = objectOrId;
+      if (typeof objectOrId === 'string') {
+        object = this.sceneViewer.scene.getObjectByProperty('uuid', objectOrId) || this.sceneViewer.scene.getObjectByProperty('name', objectOrId);
+        if (!object) {
+          // Fall back to a full traverse (matches translate's lookup by originalUuid)
+          this.sceneViewer.scene.traverse(function (child) {
+            var _child$userData2;
+            if (!object && ((_child$userData2 = child.userData) === null || _child$userData2 === void 0 ? void 0 : _child$userData2.originalUuid) === objectOrId) {
+              object = child;
+            }
+          });
+        }
+      }
+      if (!object || typeof object.traverse !== 'function') {
+        console.warn("\u26A0\uFE0F getBoundingBox(): Object '".concat(objectOrId, "' not found in scene"));
+        return null;
+      }
+      try {
+        var typesToExclude = filtered ? excludeTypes || ['io-device', 'connector'] : [];
+        var box = computeFilteredBoundingBox(object, typesToExclude);
+        if (box.isEmpty()) {
+          return null;
+        }
+        var size = box.getSize(new THREE.Vector3());
+        var center = box.getCenter(new THREE.Vector3());
+        return {
+          min: {
+            x: box.min.x,
+            y: box.min.y,
+            z: box.min.z
+          },
+          max: {
+            x: box.max.x,
+            y: box.max.y,
+            z: box.max.z
+          },
+          size: {
+            x: size.x,
+            y: size.y,
+            z: size.z
+          },
+          center: {
+            x: center.x,
+            y: center.y,
+            z: center.z
+          }
+        };
+      } catch (error) {
+        console.error('❌ getBoundingBox(): Error computing bounding box:', error);
+        return null;
+      }
+    }
+
     /**
      * Get available component categories
      * @returns {Array<Object>} Array of category objects with id, label, icon, and description
@@ -2143,8 +2236,8 @@ var CentralPlant = /*#__PURE__*/function (_BaseDisposable) {
       var componentDictionary = ((_this$managers$compon = this.managers.componentDataManager) === null || _this$managers$compon === void 0 ? void 0 : _this$managers$compon.componentDictionary) || {};
       var missingIds = [];
       sceneData.scene.children.forEach(function (child) {
-        var _child$userData2;
-        var libraryId = (_child$userData2 = child.userData) === null || _child$userData2 === void 0 ? void 0 : _child$userData2.libraryId;
+        var _child$userData3;
+        var libraryId = (_child$userData3 = child.userData) === null || _child$userData3 === void 0 ? void 0 : _child$userData3.libraryId;
         if (libraryId && !componentDictionary[libraryId]) {
           // Only add unique IDs
           if (!missingIds.includes(libraryId)) {
@@ -2222,8 +2315,8 @@ var CentralPlant = /*#__PURE__*/function (_BaseDisposable) {
       // If still not found, try finding by originalUuid in userData
       if (!targetObject) {
         this.sceneViewer.scene.traverse(function (child) {
-          var _child$userData3;
-          if (((_child$userData3 = child.userData) === null || _child$userData3 === void 0 ? void 0 : _child$userData3.originalUuid) === objectId) {
+          var _child$userData4;
+          if (((_child$userData4 = child.userData) === null || _child$userData4 === void 0 ? void 0 : _child$userData4.originalUuid) === objectId) {
             targetObject = child;
             return;
           }

package/dist/esm/src/index.js

@@ -24,7 +24,7 @@ export { SnapshotManager } from './managers/pathfinding/SnapshotManager.js';
 export { ComponentDataManager } from './managers/components/componentDataManager.js';
 export { createTransformControls } from './managers/controls/transformControlsManager.js';
 export { KeyboardControlsManager } from './managers/controls/keyboardControlsManager.js';
-export { CameraControlsManager } from './managers/controls/cameraControlsManager.js';
+export { CameraControlsManager, DEFAULT_HOME_VIEW_DIRECTION, HOME_EMPTY_CAMERA_HEIGHT_ABOVE_GROUND } from './managers/controls/cameraControlsManager.js';
 export { ComponentDragManager } from './managers/controls/componentDragManager.js';
 export { EnvironmentManager } from './managers/environment/environmentManager.js';
 export { loadTextureSetAndCreateMaterial } from './managers/environment/textureConfig.js';

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

@@ -1,10 +1,28 @@
-import { createClass as _createClass, classCallCheck as _classCallCheck } from '../../../_virtual/_rollupPluginBabelHelpers.js';
+import { createClass as _createClass, objectSpread2 as _objectSpread2, classCallCheck as _classCallCheck, createForOfIteratorHelper as _createForOfIteratorHelper } from '../../../_virtual/_rollupPluginBabelHelpers.js';
+import * as THREE from 'three';
 
-/**
- * CameraControlsManager
- * Handles camera movement, rotation, and other camera-specific controls
- */
+/** Default horizontal orbit bearing (target → camera, XY plane). */
+var DEFAULT_HOME_VIEW_DIRECTION = {
+  x: -8,
+  y: -9,
+  z: 0
+};
 
+/** Downward pitch from camera to the bottom-center look-at target (degrees). */
+var HOME_DOWNWARD_PITCH_DEG = 13;
+
+/** Minimum camera height above the bbox floor (world units). */
+var HOME_CAMERA_MIN_HEIGHT = 0.8;
+
+/** Ground plane height in world space (Z-up). */
+var WORLD_GROUND_Z = 0;
+
+/** Camera height above the ground when the scene has no components. */
+var HOME_EMPTY_CAMERA_HEIGHT_ABOVE_GROUND = 2.5;
+
+/** Default horizontal distance from world origin when the scene is empty. */
+var HOME_EMPTY_SCENE_DISTANCE = Math.hypot(DEFAULT_HOME_VIEW_DIRECTION.x, DEFAULT_HOME_VIEW_DIRECTION.y);
+var WORLD_ORIGIN = new THREE.Vector3(0, 0, 0);
 var CameraControlsManager = /*#__PURE__*/function () {
   function CameraControlsManager(component) {
     _classCallCheck(this, CameraControlsManager);
@@ -14,11 +32,317 @@ var CameraControlsManager = /*#__PURE__*/function () {
   }
 
   /**
-   * Toggle camera auto-rotation on/off
-   * 
-   * @returns {boolean} The new auto-rotation state
+   * Frame the camera so that every component in the scene fits perfectly in view.
+   *
+   * Computes the combined bounding box of all scene components, then moves the
+   * (perspective) camera along its current viewing direction to the distance
+   * required to fit that bounding sphere within the frustum. The orbit target,
+   * clipping planes and distance limits are updated to match.
+   *
+   * @param {Object} [options]
+   * @param {number} [options.padding=1.04] - Multiplier on the fit distance (>1 leaves margin).
+   * @param {THREE.Vector3|{x:number,y:number,z:number}} [options.direction] - Override viewing
+   *   direction (target -> camera). When omitted, the current orbit angle is preserved.
+   * @param {boolean} [options.groundLevel] - Pin camera low with a downward pitch toward
+   *   the bottom-center of the assembly. Defaults to true when a home direction is used.
+   * @returns {boolean} True if the camera was reframed, false if there was nothing to frame.
    */
   return _createClass(CameraControlsManager, [{
+    key: "fitCameraToScene",
+    value: function fitCameraToScene() {
+      var _options$padding, _options$groundLevel;
+      var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+      var component = this.sceneViewer;
+      var camera = component === null || component === void 0 ? void 0 : component.camera;
+      var scene = component === null || component === void 0 ? void 0 : component.scene;
+      var controls = component === null || component === void 0 ? void 0 : component.controls;
+      if (!camera || !scene || !camera.isPerspectiveCamera) {
+        console.warn('⚠️ fitCameraToScene: missing perspective camera or scene');
+        return false;
+      }
+      var padding = (_options$padding = options.padding) !== null && _options$padding !== void 0 ? _options$padding : 1.04;
+
+      // Make sure world matrices are current before measuring bounds
+      scene.updateMatrixWorld(true);
+      var box = this._collectSceneBounds(scene);
+      if (!box) {
+        return this._aimCameraAtWorldCenter(camera, controls, options);
+      }
+      var useGroundLevel = (_options$groundLevel = options.groundLevel) !== null && _options$groundLevel !== void 0 ? _options$groundLevel : this._isHomeDirection(options.direction);
+      if (useGroundLevel) {
+        return this._fitCameraGroundLevel(box, camera, controls, options, padding);
+      }
+      return this._fitCameraFromCenter(box, camera, controls, options, padding);
+    }
+
+    /**
+     * Aim the camera at world origin when there are no components to frame.
+     * @private
+     */
+  }, {
+    key: "_aimCameraAtWorldCenter",
+    value: function _aimCameraAtWorldCenter(camera, controls) {
+      var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+      var frameTarget = WORLD_ORIGIN.clone();
+      var distance = HOME_EMPTY_SCENE_DISTANCE;
+      var horizDir = new THREE.Vector3();
+      if (options.direction) {
+        horizDir.set(options.direction.x, options.direction.y, 0);
+      } else {
+        horizDir.set(DEFAULT_HOME_VIEW_DIRECTION.x, DEFAULT_HOME_VIEW_DIRECTION.y, 0);
+      }
+      if (horizDir.lengthSq() < 1e-6) {
+        horizDir.set(DEFAULT_HOME_VIEW_DIRECTION.x, DEFAULT_HOME_VIEW_DIRECTION.y, 0);
+      }
+      horizDir.normalize();
+      var cameraHeight = WORLD_GROUND_Z + HOME_EMPTY_CAMERA_HEIGHT_ABOVE_GROUND;
+      var camPos = new THREE.Vector3(frameTarget.x + horizDir.x * distance, frameTarget.y + horizDir.y * distance, cameraHeight);
+      camera.position.copy(camPos);
+      camera.near = 0.01;
+      camera.far = 1000;
+      camera.updateProjectionMatrix();
+      camera.lookAt(frameTarget);
+      if (controls) {
+        controls.target.copy(frameTarget);
+        controls.minDistance = 1;
+        controls.maxDistance = 20;
+        controls.update();
+      }
+      console.log('🎥 Camera aimed at world origin (empty scene)');
+      return true;
+    }
+
+    /**
+     * @private
+     */
+  }, {
+    key: "_collectSceneBounds",
+    value: function _collectSceneBounds(scene) {
+      var includeTypes = ['component', 'gateway', 'segment'];
+      var box = new THREE.Box3();
+      var found = false;
+      scene.traverse(function (obj) {
+        var _obj$userData;
+        if (includeTypes.includes((_obj$userData = obj.userData) === null || _obj$userData === void 0 ? void 0 : _obj$userData.objectType)) {
+          var objBox = new THREE.Box3().setFromObject(obj);
+          if (!objBox.isEmpty()) {
+            box.union(objBox);
+            found = true;
+          }
+        }
+      });
+      return found && !box.isEmpty() ? box : null;
+    }
+
+    /**
+     * @private
+     */
+  }, {
+    key: "_isHomeDirection",
+    value: function _isHomeDirection(direction) {
+      if (!direction) return false;
+      var horiz = Math.hypot(direction.x, direction.y);
+      if (horiz < 1e-6) return false;
+      var dx = direction.x / horiz - DEFAULT_HOME_VIEW_DIRECTION.x / Math.hypot(DEFAULT_HOME_VIEW_DIRECTION.x, DEFAULT_HOME_VIEW_DIRECTION.y);
+      var dy = direction.y / horiz - DEFAULT_HOME_VIEW_DIRECTION.y / Math.hypot(DEFAULT_HOME_VIEW_DIRECTION.x, DEFAULT_HOME_VIEW_DIRECTION.y);
+      return Math.hypot(dx, dy) < 0.05 && Math.abs(direction.z) < 0.5;
+    }
+
+    /**
+     * Ground-hugging camera: horizontal offset with a fixed downward pitch toward
+     * the bottom-center of the component group.
+     * @private
+     */
+  }, {
+    key: "_fitCameraGroundLevel",
+    value: function _fitCameraGroundLevel(box, camera, controls, options, padding) {
+      var size = box.getSize(new THREE.Vector3());
+      var frameTarget = this._getBoxBottomCenter(box);
+      var downwardPitch = THREE.MathUtils.degToRad(HOME_DOWNWARD_PITCH_DEG);
+      var horizDir = new THREE.Vector3();
+      if (options.direction) {
+        horizDir.set(options.direction.x, options.direction.y, 0);
+      } else {
+        horizDir.set(DEFAULT_HOME_VIEW_DIRECTION.x, DEFAULT_HOME_VIEW_DIRECTION.y, 0);
+      }
+      if (horizDir.lengthSq() < 1e-6) {
+        horizDir.set(DEFAULT_HOME_VIEW_DIRECTION.x, DEFAULT_HOME_VIEW_DIRECTION.y, 0);
+      }
+      horizDir.normalize();
+      var corners = this._getBoxCorners(box);
+      var vFov = THREE.MathUtils.degToRad(camera.fov);
+      var aspect = camera.aspect || 1;
+      var tanHalfV = Math.tan(vFov / 2);
+      var tanHalfH = tanHalfV * aspect;
+      var fitsAtDistance = function fitsAtDistance(distance) {
+        var cameraHeight = Math.max(frameTarget.z + distance * Math.tan(downwardPitch), box.min.z + HOME_CAMERA_MIN_HEIGHT);
+        var camPos = new THREE.Vector3(frameTarget.x + horizDir.x * distance, frameTarget.y + horizDir.y * distance, cameraHeight);
+        var forward = new THREE.Vector3().subVectors(frameTarget, camPos).normalize();
+        var worldUp = camera.up.clone().normalize();
+        var right = new THREE.Vector3().crossVectors(forward, worldUp);
+        if (right.lengthSq() < 1e-6) {
+          right = new THREE.Vector3().crossVectors(forward, new THREE.Vector3(1, 0, 0));
+        }
+        right.normalize();
+        var up = new THREE.Vector3().crossVectors(right, forward).normalize();
+        var _iterator = _createForOfIteratorHelper(corners),
+          _step;
+        try {
+          for (_iterator.s(); !(_step = _iterator.n()).done;) {
+            var corner = _step.value;
+            var rel = new THREE.Vector3().subVectors(corner, camPos);
+            var depth = rel.dot(forward);
+            if (depth <= 0.01) return false;
+            if (Math.abs(rel.dot(right)) / depth > tanHalfH) return false;
+            if (Math.abs(rel.dot(up)) / depth > tanHalfV) return false;
+          }
+        } catch (err) {
+          _iterator.e(err);
+        } finally {
+          _iterator.f();
+        }
+        return true;
+      };
+      var fitDistance = 0.5;
+      while (!fitsAtDistance(fitDistance) && fitDistance < 500) {
+        fitDistance *= 1.15;
+      }
+      if (fitDistance >= 500) {
+        console.warn('⚠️ fitCameraToScene: could not frame scene from ground level');
+        return false;
+      }
+
+      // Tighten to the closest distance that still fits, then apply padding.
+      var lo = 0.01;
+      var hi = fitDistance;
+      while (hi - lo > 0.1) {
+        var mid = (lo + hi) / 2;
+        if (fitsAtDistance(mid)) hi = mid;else lo = mid;
+      }
+      fitDistance = hi * padding;
+      var cameraHeight = Math.max(frameTarget.z + fitDistance * Math.tan(downwardPitch), box.min.z + HOME_CAMERA_MIN_HEIGHT);
+      var camPos = new THREE.Vector3(frameTarget.x + horizDir.x * fitDistance, frameTarget.y + horizDir.y * fitDistance, cameraHeight);
+      camera.position.copy(camPos);
+      var span = size.length();
+      camera.near = Math.max(fitDistance / 1000, 0.01);
+      camera.far = Math.max(fitDistance + span * 4, 1000);
+      camera.updateProjectionMatrix();
+      camera.lookAt(frameTarget);
+      if (controls) {
+        controls.target.copy(frameTarget);
+        controls.minDistance = Math.max(span * 0.1, 0.1);
+        controls.maxDistance = fitDistance * 4;
+        controls.update();
+      }
+      console.log("\uD83C\uDFA5 Camera framed to scene at ground level (distance: ".concat(fitDistance.toFixed(2), ", height: ").concat(cameraHeight.toFixed(2), ")"));
+      return true;
+    }
+
+    /**
+     * Bottom-center of a bounding box (centered in X/Y, at the floor in Z).
+     * @private
+     */
+  }, {
+    key: "_getBoxBottomCenter",
+    value: function _getBoxBottomCenter(box) {
+      var center = box.getCenter(new THREE.Vector3());
+      return new THREE.Vector3(center.x, center.y, box.min.z);
+    }
+
+    /**
+     * @private
+     */
+  }, {
+    key: "_getBoxCorners",
+    value: function _getBoxCorners(box) {
+      var min = box.min,
+        max = box.max;
+      var corners = [];
+      for (var i = 0; i < 8; i++) {
+        corners.push(new THREE.Vector3(i & 1 ? max.x : min.x, i & 2 ? max.y : min.y, i & 4 ? max.z : min.z));
+      }
+      return corners;
+    }
+
+    /**
+     * @private
+     */
+  }, {
+    key: "_fitCameraFromCenter",
+    value: function _fitCameraFromCenter(box, camera, controls, options, padding) {
+      var center = box.getCenter(new THREE.Vector3());
+      var target = controls !== null && controls !== void 0 && controls.target ? controls.target.clone() : new THREE.Vector3();
+      var direction = new THREE.Vector3();
+      if (options.direction) {
+        direction.set(options.direction.x, options.direction.y, options.direction.z);
+      } else {
+        direction.subVectors(camera.position, target);
+      }
+      if (direction.lengthSq() < 1e-6) {
+        direction.set(DEFAULT_HOME_VIEW_DIRECTION.x, DEFAULT_HOME_VIEW_DIRECTION.y, DEFAULT_HOME_VIEW_DIRECTION.z);
+      }
+      direction.normalize();
+      var forward = direction.clone().negate();
+      var worldUp = camera.up.clone().normalize();
+      var right = new THREE.Vector3().crossVectors(forward, worldUp);
+      if (right.lengthSq() < 1e-6) {
+        right = new THREE.Vector3().crossVectors(forward, new THREE.Vector3(1, 0, 0));
+      }
+      right.normalize();
+      var up = new THREE.Vector3().crossVectors(right, forward).normalize();
+      var vFov = THREE.MathUtils.degToRad(camera.fov);
+      var aspect = camera.aspect || 1;
+      var tanHalfV = Math.tan(vFov / 2);
+      var tanHalfH = tanHalfV * aspect;
+      var min = box.min;
+      var max = box.max;
+      var fitDistance = 0.01;
+      for (var i = 0; i < 8; i++) {
+        var v = new THREE.Vector3(i & 1 ? max.x : min.x, i & 2 ? max.y : min.y, i & 4 ? max.z : min.z).sub(center);
+        var vForward = v.dot(forward);
+        var vRight = Math.abs(v.dot(right));
+        var vUp = Math.abs(v.dot(up));
+        var cornerDistance = Math.max(vRight / tanHalfH - vForward, vUp / tanHalfV - vForward, -vForward + 0.01);
+        fitDistance = Math.max(fitDistance, cornerDistance);
+      }
+      fitDistance *= padding;
+      camera.position.copy(center).addScaledVector(direction, fitDistance);
+      var span = box.getSize(new THREE.Vector3()).length();
+      camera.near = Math.max(fitDistance / 1000, 0.01);
+      camera.far = Math.max(fitDistance + span * 4, 1000);
+      camera.updateProjectionMatrix();
+      camera.lookAt(center);
+      if (controls) {
+        controls.target.copy(center);
+        controls.minDistance = Math.max(span * 0.1, 0.1);
+        controls.maxDistance = fitDistance * 4;
+        controls.update();
+      }
+      console.log("\uD83C\uDFA5 Camera framed to scene (distance: ".concat(fitDistance.toFixed(2), ")"));
+      return true;
+    }
+
+    /**
+     * Frame the scene using the default low, ground-level home viewing angle.
+     * @param {Object} [options] - Passed to fitCameraToScene (padding, etc.)
+     * @returns {boolean}
+     */
+  }, {
+    key: "fitCameraToSceneHome",
+    value: function fitCameraToSceneHome() {
+      var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+      return this.fitCameraToScene(_objectSpread2(_objectSpread2({}, options), {}, {
+        direction: DEFAULT_HOME_VIEW_DIRECTION,
+        groundLevel: true
+      }));
+    }
+
+    /**
+     * Toggle camera auto-rotation on/off
+     * 
+     * @returns {boolean} The new auto-rotation state
+     */
+  }, {
     key: "toggleCameraRotation",
     value: function toggleCameraRotation() {
       var component = this.sceneViewer;
@@ -76,4 +400,4 @@ var CameraControlsManager = /*#__PURE__*/function () {
   }]);
 }();
 
-export { CameraControlsManager };
+export { CameraControlsManager, DEFAULT_HOME_VIEW_DIRECTION, HOME_EMPTY_CAMERA_HEIGHT_ABOVE_GROUND };

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

@@ -1,4 +1,4 @@
-import { inherits as _inherits, createClass as _createClass, superPropGet as _superPropGet, classCallCheck as _classCallCheck, callSuper as _callSuper, objectSpread2 as _objectSpread2, toConsumableArray as _toConsumableArray, createForOfIteratorHelper as _createForOfIteratorHelper } from '../../../_virtual/_rollupPluginBabelHelpers.js';
+import { defineProperty as _defineProperty, inherits as _inherits, createClass as _createClass, objectSpread2 as _objectSpread2, createForOfIteratorHelper as _createForOfIteratorHelper, superPropGet as _superPropGet, classCallCheck as _classCallCheck, callSuper as _callSuper } from '../../../_virtual/_rollupPluginBabelHelpers.js';
 import * as THREE from 'three';
 
 // Reusable objects to avoid garbage collection
@@ -64,6 +64,11 @@ var transformControls = /*#__PURE__*/function (_THREE$Object3D) {
     _this.showY = true;
     _this.showZ = true;
 
+    // Axis interactivity (pickers). Visual handles can remain visible when false.
+    _this.pickX = true;
+    _this.pickY = true;
+    _this.pickZ = true;
+
     // Click timing for interaction delays
     _this.clickDelay = null;
     _this.lastInteractionTime = 0;
@@ -217,6 +222,9 @@ var transformControls = /*#__PURE__*/function (_THREE$Object3D) {
         this.lastInteractionTime = currentTime;
       }
       if (this.axis !== null) {
+        if (!this._isAxisPickable(this.axis)) {
+          return;
+        }
         _raycaster.setFromCamera(pointer, this.camera);
         var planeIntersect = this._intersectObjectWithRay(this._plane, _raycaster, true);
         if (planeIntersect) {
@@ -487,10 +495,19 @@ var transformControls = /*#__PURE__*/function (_THREE$Object3D) {
     value: function getMode() {
       return this.mode;
     }
+  }, {
+    key: "_isAxisPickable",
+    value: function _isAxisPickable(axisName) {
+      if (!axisName) return false;
+      if (axisName.indexOf('X') !== -1) return this.pickX !== false;
+      if (axisName.indexOf('Y') !== -1) return this.pickY !== false;
+      if (axisName.indexOf('Z') !== -1) return this.pickZ !== false;
+      return true;
+    }
   }, {
     key: "setMode",
     value: function setMode(mode) {
-      if (mode !== 'translate') {
+      if (mode !== 'translate' && mode !== 'rotate') {
         console.warn("transformControls: ".concat(mode, " mode is disabled. Locking to translate."));
         mode = 'translate';
       }
@@ -731,6 +748,7 @@ var SimpleTransformGizmo = /*#__PURE__*/function (_THREE$Object3D2) {
   }, {
     key: "updateGizmoState",
     value: function updateGizmoState(controls) {
+      var _this$gizmo$controls$, _this$gizmo$controls$2, _this$picker$controls, _this$picker$controls2;
       // Show only the gizmo for current mode
       this.gizmo['translate'].visible = controls.mode === 'translate';
       this.gizmo['rotate'].visible = controls.mode === 'rotate';
@@ -748,43 +766,62 @@ var SimpleTransformGizmo = /*#__PURE__*/function (_THREE$Object3D2) {
       // Force maximum render priority for all gizmo objects
       this._forceMaxRenderOrder();
 
-      // Update all handles for the current mode
-      var handles = [].concat(_toConsumableArray(this.picker[controls.mode].children), _toConsumableArray(this.gizmo[controls.mode].children));
+      // Scale based on camera distance
+      var factor;
+      if (controls.camera.isOrthographicCamera) {
+        factor = (controls.camera.top - controls.camera.bottom) / controls.camera.zoom;
+      } else {
+        factor = controls.worldPosition.distanceTo(controls.cameraPosition) * Math.min(1.9 * Math.tan(Math.PI * controls.camera.fov / 360) / controls.camera.zoom, 7);
+      }
+      this.scale.setScalar(factor * controls.size / 4);
+      this._updateModeHandles(controls, (_this$gizmo$controls$ = (_this$gizmo$controls$2 = this.gizmo[controls.mode]) === null || _this$gizmo$controls$2 === void 0 ? void 0 : _this$gizmo$controls$2.children) !== null && _this$gizmo$controls$ !== void 0 ? _this$gizmo$controls$ : [], false);
+      this._updateModeHandles(controls, (_this$picker$controls = (_this$picker$controls2 = this.picker[controls.mode]) === null || _this$picker$controls2 === void 0 ? void 0 : _this$picker$controls2.children) !== null && _this$picker$controls !== void 0 ? _this$picker$controls : [], true);
+    }
+  }, {
+    key: "_isAxisShown",
+    value: function _isAxisShown(controls, axisName) {
+      if (axisName.indexOf('X') !== -1 && !controls.showX) return false;
+      if (axisName.indexOf('Y') !== -1 && !controls.showY) return false;
+      if (axisName.indexOf('Z') !== -1 && !controls.showZ) return false;
+      return true;
+    }
+  }, {
+    key: "_isAxisPickable",
+    value: function _isAxisPickable(controls, axisName) {
+      if (axisName.indexOf('X') !== -1) return controls.pickX !== false;
+      if (axisName.indexOf('Y') !== -1) return controls.pickY !== false;
+      if (axisName.indexOf('Z') !== -1) return controls.pickZ !== false;
+      return true;
+    }
+  }, {
+    key: "_updateModeHandles",
+    value: function _updateModeHandles(controls, handles, isPicker) {
       var _iterator = _createForOfIteratorHelper(handles),
         _step;
       try {
         for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var _handle$material$_ori;
           var handle = _step.value;
-          handle.visible = true;
-
-          // Scale based on camera distance
-          var factor = void 0;
-          if (controls.camera.isOrthographicCamera) {
-            factor = (controls.camera.top - controls.camera.bottom) / controls.camera.zoom;
-          } else {
-            factor = controls.worldPosition.distanceTo(controls.cameraPosition) * Math.min(1.9 * Math.tan(Math.PI * controls.camera.fov / 360) / controls.camera.zoom, 7);
+          var axisName = handle.name;
+          var shown = this._isAxisShown(controls, axisName);
+          var pickable = this._isAxisPickable(controls, axisName);
+          if (isPicker) {
+            handle.visible = shown && pickable;
+            continue;
           }
-
-          // Apply scale to the entire gizmo, not individual handles
-          this.scale.setScalar(factor * controls.size / 4);
-
-          // Apply axis visibility constraints
-          if (handle.name.indexOf('X') !== -1 && !controls.showX) handle.visible = false;
-          if (handle.name.indexOf('Y') !== -1 && !controls.showY) handle.visible = false;
-          if (handle.name.indexOf('Z') !== -1 && !controls.showZ) handle.visible = false;
-
-          // Highlight selected axis
-          if (handle.material) {
-            handle.material._originalColor = handle.material._originalColor || handle.material.color.clone();
-            handle.material._originalOpacity = handle.material._originalOpacity || handle.material.opacity;
+          handle.visible = shown;
+          if (!handle.material) continue;
+          handle.material._originalColor = handle.material._originalColor || handle.material.color.clone();
+          handle.material._originalOpacity = (_handle$material$_ori = handle.material._originalOpacity) !== null && _handle$material$_ori !== void 0 ? _handle$material$_ori : handle.material.opacity;
+          if (shown && pickable && controls.enabled && controls.axis === axisName) {
+            handle.material.color.setHex(0xffff00);
+            handle.material.opacity = 1.0;
+          } else if (shown && !pickable) {
+            handle.material.color.copy(handle.material._originalColor);
+            handle.material.opacity = SimpleTransformGizmo.DISABLED_AXIS_OPACITY;
+          } else {
             handle.material.color.copy(handle.material._originalColor);
             handle.material.opacity = handle.material._originalOpacity;
-            if (controls.enabled && controls.axis) {
-              if (handle.name === controls.axis) {
-                handle.material.color.setHex(0xffff00);
-                handle.material.opacity = 1.0;
-              }
-            }
           }
         }
       } catch (err) {
@@ -834,6 +871,7 @@ var SimpleTransformGizmo = /*#__PURE__*/function (_THREE$Object3D2) {
  * Optimized plane for transformation interactions
  * Simplified geometry and material for better performance
  */
+_defineProperty(SimpleTransformGizmo, "DISABLED_AXIS_OPACITY", 0.3);
 var SimpleTransformPlane = /*#__PURE__*/function (_THREE$Mesh) {
   function SimpleTransformPlane() {
     var _this4;