@2112-lab/central-plant 0.1.0

package/dist/esm/src/transformControlsManager.js

@@ -0,0 +1,827 @@
+import { createClass as _createClass, classCallCheck as _classCallCheck, asyncToGenerator as _asyncToGenerator, regenerator as _regenerator } from '../_virtual/_rollupPluginBabelHelpers.js';
+
+/**
+ * Transform Controls Manager for Three.js
+ * Provides modular object transformation capabilities with position, rotation, and scale controls
+ */
+
+var THREE;
+var TransformControls;
+
+/**
+ * Dynamically import ThreeJS and TransformControls when in browser environment
+ */
+function importDependencies() {
+  return _importDependencies.apply(this, arguments);
+}
+/**
+ * Class for managing object transform controls in a 3D scene
+ */
+function _importDependencies() {
+  _importDependencies = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee2() {
+    var transformModule, customModule, _t2;
+    return _regenerator().w(function (_context2) {
+      while (1) switch (_context2.n) {
+        case 0:
+          if (!(typeof window !== 'undefined')) {
+            _context2.n = 9;
+            break;
+          }
+          _context2.p = 1;
+          _context2.n = 2;
+          return import('three');
+        case 2:
+          THREE = _context2.v;
+          _context2.p = 3;
+          _context2.n = 4;
+          return import('../node_modules/three/examples/jsm/controls/TransformControls.js');
+        case 4:
+          transformModule = _context2.v;
+          TransformControls = transformModule.TransformControls;
+          _context2.n = 7;
+          break;
+        case 5:
+          _context2.p = 5;
+          _context2.v;
+          console.log('Using fallback path for TransformControls');
+          // Fallback to the custom plugin path if available
+          if (!(typeof window.__transformControlsCustomPath === 'string')) {
+            _context2.n = 7;
+            break;
+          }
+          _context2.n = 6;
+          return import(window.__transformControlsCustomPath);
+        case 6:
+          customModule = _context2.v;
+          TransformControls = customModule.TransformControls;
+        case 7:
+          _context2.n = 9;
+          break;
+        case 8:
+          _context2.p = 8;
+          _t2 = _context2.v;
+          console.error('Failed to load Transform Controls dependencies:', _t2);
+          throw new Error('TransformControlsManager: Required dependencies could not be loaded');
+        case 9:
+          return _context2.a(2);
+      }
+    }, _callee2, null, [[3, 5], [1, 8]]);
+  }));
+  return _importDependencies.apply(this, arguments);
+}
+var TransformControlsManager = /*#__PURE__*/function () {
+  /**
+   * Create a TransformControlsManager
+   * @param {THREE.Scene} scene - The Three.js scene
+   * @param {THREE.Camera} camera - The Three.js camera
+   * @param {THREE.WebGLRenderer} renderer - The Three.js renderer
+   * @param {THREE.OrbitControls} orbitControls - Optional orbit controls for camera
+   */
+  function TransformControlsManager(scene, camera, renderer) {
+    var _this = this;
+    var orbitControls = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;
+    _classCallCheck(this, TransformControlsManager);
+    this.scene = scene;
+    this.camera = camera;
+    this.renderer = renderer;
+    this.orbitControls = orbitControls;
+
+    // Transform control instance
+    this.transformControls = null;
+
+    // Bounding box helper for visual feedback
+    this.boundingBoxHelper = null;
+
+    // Cache for object bounding boxes to improve performance
+    this.boundingBoxCache = new WeakMap();
+
+    // Currently selected object
+    this.selectedObject = null;
+
+    // Transform mode: 'translate', 'rotate', 'scale'
+    this.currentMode = 'translate';
+
+    // Transform space: 'world' or 'local'
+    this.currentSpace = 'world';
+
+    // Flag to force controls to stay invisible (used during scene loading)
+    this.forceInvisible = false;
+
+    // Event handlers storage
+    this.eventHandlers = {
+      keydown: null,
+      pointerdown: null,
+      pointerup: null,
+      transformStart: null,
+      transformEnd: null,
+      transforming: null
+    };
+
+    // Transform state tracking
+    this.transformState = {
+      isTransforming: false,
+      initialTransform: null,
+      currentTransform: null
+    };
+
+    // Configuration options
+    this.config = {
+      size: 1,
+      enabled: true,
+      showX: true,
+      showY: true,
+      showZ: true,
+      snap: null,
+      // Snap value for transformations
+      translationSnap: null,
+      rotationSnap: null,
+      scaleSnap: null,
+      showBoundingBox: true,
+      // Show bounding box on selection
+      boundingBoxColor: 0x00ff00,
+      // Green bounding box by default
+      useBoundingBoxSelection: true // Use bounding box-based selection instead of mesh selection
+    };
+
+    // Callbacks for external event handling
+    this.callbacks = {
+      onObjectSelect: null,
+      onTransformStart: null,
+      onTransform: null,
+      onTransformEnd: null,
+      onModeChange: null
+    };
+
+    // Initialize asynchronously if needed
+    if (typeof window !== 'undefined') {
+      importDependencies().then(function () {
+        return _this.init();
+      });
+    }
+  }
+
+  /**
+   * Initialize the transform controls
+   */
+  return _createClass(TransformControlsManager, [{
+    key: "init",
+    value: (function () {
+      var _init = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee() {
+        return _regenerator().w(function (_context) {
+          while (1) switch (_context.n) {
+            case 0:
+              if (!(typeof window !== 'undefined' && !THREE)) {
+                _context.n = 1;
+                break;
+              }
+              _context.n = 1;
+              return importDependencies();
+            case 1:
+              this.createTransformControls();
+              this.setupEventListeners();
+              this.setupKeyboardControls();
+            case 2:
+              return _context.a(2);
+          }
+        }, _callee, this);
+      }));
+      function init() {
+        return _init.apply(this, arguments);
+      }
+      return init;
+    }()
+    /**
+     * Register event callbacks
+     * @param {Object} callbacks - Object containing callback functions
+     */
+    )
+  }, {
+    key: "on",
+    value: function on(callbacks) {
+      if (callbacks.onObjectSelect) {
+        this.callbacks.onObjectSelect = callbacks.onObjectSelect;
+      }
+      if (callbacks.onTransformStart) {
+        this.callbacks.onTransformStart = callbacks.onTransformStart;
+      }
+      if (callbacks.onTransform) {
+        this.callbacks.onTransform = callbacks.onTransform;
+      }
+      if (callbacks.onTransformEnd) {
+        this.callbacks.onTransformEnd = callbacks.onTransformEnd;
+      }
+      if (callbacks.onModeChange) {
+        this.callbacks.onModeChange = callbacks.onModeChange;
+      }
+    }
+
+    /**
+     * Create transform controls and add to scene
+     */
+  }, {
+    key: "createTransformControls",
+    value: function createTransformControls() {
+      // Ensure THREE and TransformControls are available
+      if (!THREE || !TransformControls) {
+        console.warn('TransformControls cannot be created - THREE.js not loaded');
+        return;
+      }
+
+      // Create transform controls if they don't exist
+      if (!this.transformControls) {
+        this.transformControls = new TransformControls(this.camera, this.renderer.domElement);
+        this.transformControls.size = this.config.size;
+        this.transformControls.enabled = this.config.enabled;
+        this.transformControls.visible = this.config.enabled && !this.forceInvisible;
+
+        // Set initial mode
+        this.transformControls.setMode(this.currentMode);
+        this.transformControls.setSpace(this.currentSpace);
+
+        // Mark with userData for easy identification
+        this.transformControls.userData = {
+          isTransformControls: true
+        };
+
+        // Add to scene
+        this.scene.add(this.transformControls);
+        console.log('✅ Transform controls created and added to scene');
+      }
+    }
+
+    /**
+     * Set up event listeners for transform controls
+     */
+  }, {
+    key: "setupEventListeners",
+    value: function setupEventListeners() {
+      var _this2 = this;
+      if (!this.transformControls) return;
+
+      // Clean up any existing listeners to avoid duplicates
+      this.removeEventListeners();
+
+      // Event handler for transform start
+      this.eventHandlers.transformStart = function (event) {
+        _this2.transformState.isTransforming = true;
+        if (_this2.selectedObject) {
+          // Store initial transform for history/undo purposes
+          _this2.transformState.initialTransform = _this2.captureObjectTransform(_this2.selectedObject);
+
+          // Notify via callback if registered
+          if (_this2.callbacks.onTransformStart) {
+            _this2.callbacks.onTransformStart(_this2.selectedObject, _this2.transformState.initialTransform);
+          }
+        }
+      };
+
+      // Event handler for transform changes
+      this.eventHandlers.transforming = function (event) {
+        if (_this2.selectedObject && _this2.transformState.isTransforming) {
+          // Capture current transform
+          _this2.transformState.currentTransform = _this2.captureObjectTransform(_this2.selectedObject);
+
+          // Notify via callback if registered
+          if (_this2.callbacks.onTransform) {
+            _this2.callbacks.onTransform(_this2.selectedObject, _this2.transformState.currentTransform, _this2.transformState.initialTransform);
+          }
+
+          // Update bounding box if shown
+          _this2.updateBoundingBox();
+        }
+      };
+
+      // Event handler for transform end
+      this.eventHandlers.transformEnd = function (event) {
+        if (_this2.selectedObject) {
+          // Capture final transform
+          var finalTransform = _this2.captureObjectTransform(_this2.selectedObject);
+
+          // Notify via callback if registered
+          if (_this2.callbacks.onTransformEnd) {
+            _this2.callbacks.onTransformEnd(_this2.selectedObject, finalTransform, _this2.transformState.initialTransform);
+          }
+        }
+        _this2.transformState.isTransforming = false;
+      };
+
+      // Attach event listeners to transform controls
+      this.transformControls.addEventListener('mouseDown', this.eventHandlers.transformStart);
+      this.transformControls.addEventListener('objectChange', this.eventHandlers.transforming);
+      this.transformControls.addEventListener('mouseUp', this.eventHandlers.transformEnd);
+
+      // Disable orbit controls during transform (if orbit controls provided)
+      if (this.orbitControls) {
+        this.transformControls.addEventListener('dragging-changed', function (event) {
+          _this2.orbitControls.enabled = !event.value;
+        });
+      }
+    }
+
+    /**
+     * Set up keyboard controls for transform operations
+     */
+  }, {
+    key: "setupKeyboardControls",
+    value: function setupKeyboardControls() {
+      var _this3 = this;
+      // Skip if not in browser environment
+      if (typeof window === 'undefined' || typeof document === 'undefined') {
+        return;
+      }
+
+      // Clean up any existing listeners first
+      if (this.eventHandlers.keydown) {
+        document.removeEventListener('keydown', this.eventHandlers.keydown);
+      }
+
+      // Keydown handler for keyboard shortcuts
+      this.eventHandlers.keydown = function (event) {
+        if (!_this3.config.enabled || !_this3.selectedObject) return;
+        switch (event.key.toLowerCase()) {
+          case 'g':
+            // Translate mode (grab)
+            _this3.setMode('translate');
+            break;
+          case 'r':
+            // Rotate mode
+            _this3.setMode('rotate');
+            break;
+          case 's':
+            // Scale mode
+            _this3.setMode('scale');
+            break;
+          case ' ':
+            // Toggle visibility
+            _this3.toggleVisibility();
+            break;
+          case 'escape':
+            // Deselect object
+            _this3.deselectObject();
+            break;
+          case 'x':
+            // X-axis constraint
+            if (event.shiftKey) {
+              // Shift + X to toggle X controls
+              _this3.config.showX = !_this3.config.showX;
+              _this3.updateAxisVisibility();
+            } else {
+              _this3.transformControls.showX = true;
+              _this3.transformControls.showY = false;
+              _this3.transformControls.showZ = false;
+            }
+            break;
+          case 'y':
+            // Y-axis constraint
+            if (event.shiftKey) {
+              // Shift + Y to toggle Y controls
+              _this3.config.showY = !_this3.config.showY;
+              _this3.updateAxisVisibility();
+            } else {
+              _this3.transformControls.showX = false;
+              _this3.transformControls.showY = true;
+              _this3.transformControls.showZ = false;
+            }
+            break;
+          case 'z':
+            // Z-axis constraint
+            if (event.shiftKey) {
+              // Shift + Z to toggle Z controls
+              _this3.config.showZ = !_this3.config.showZ;
+              _this3.updateAxisVisibility();
+            } else {
+              _this3.transformControls.showX = false;
+              _this3.transformControls.showY = false;
+              _this3.transformControls.showZ = true;
+            }
+            break;
+          case 'q':
+            // Toggle world/local space
+            _this3.toggleSpace();
+            break;
+        }
+      };
+
+      // Add keyboard event listener
+      document.addEventListener('keydown', this.eventHandlers.keydown);
+    }
+
+    /**
+     * Remove all event listeners
+     */
+  }, {
+    key: "removeEventListeners",
+    value: function removeEventListeners() {
+      if (this.transformControls) {
+        // Remove transform control event listeners
+        this.transformControls.removeEventListener('mouseDown', this.eventHandlers.transformStart);
+        this.transformControls.removeEventListener('objectChange', this.eventHandlers.transforming);
+        this.transformControls.removeEventListener('mouseUp', this.eventHandlers.transformEnd);
+      }
+
+      // Remove document event listeners if in browser
+      if (typeof document !== 'undefined') {
+        if (this.eventHandlers.keydown) {
+          document.removeEventListener('keydown', this.eventHandlers.keydown);
+        }
+      }
+    }
+
+    /**
+     * Select an object for transformation
+     * @param {THREE.Object3D} object - The object to transform
+     */
+  }, {
+    key: "selectObject",
+    value: function selectObject(object) {
+      if (!this.config.enabled || !this.transformControls || !object) return;
+
+      // Deselect current object if any
+      this.deselectObject();
+
+      // Set new selected object
+      this.selectedObject = object;
+      this.transformControls.attach(object);
+
+      // Show bounding box if enabled
+      if (this.config.showBoundingBox) {
+        this.showBoundingBox(object);
+      }
+
+      // Notify via callback if registered
+      if (this.callbacks.onObjectSelect) {
+        this.callbacks.onObjectSelect(object, true);
+      }
+
+      // Make controls visible if not forced invisible
+      if (!this.forceInvisible) {
+        this.transformControls.visible = true;
+      }
+      return object;
+    }
+
+    /**
+     * Deselect the currently selected object
+     */
+  }, {
+    key: "deselectObject",
+    value: function deselectObject() {
+      if (this.selectedObject) {
+        // Detach from transform controls
+        if (this.transformControls) {
+          this.transformControls.detach();
+        }
+
+        // Hide bounding box
+        this.hideBoundingBox();
+
+        // Notify via callback if registered
+        if (this.callbacks.onObjectSelect) {
+          this.callbacks.onObjectSelect(this.selectedObject, false);
+        }
+
+        // Clear selection
+        var previousSelection = this.selectedObject;
+        this.selectedObject = null;
+
+        // Ensure transform controls are removed from scene
+        this.ensureSceneAttachment(false);
+        return previousSelection;
+      }
+      return null;
+    }
+
+    /**
+     * Set transformation mode
+     * @param {string} mode - The transform mode ('translate', 'rotate', or 'scale')
+     */
+  }, {
+    key: "setMode",
+    value: function setMode(mode) {
+      if (!this.transformControls) return;
+      if (['translate', 'rotate', 'scale'].includes(mode)) {
+        this.currentMode = mode;
+        this.transformControls.setMode(mode);
+
+        // Update snap values based on mode
+        switch (mode) {
+          case 'translate':
+            this.transformControls.setTranslationSnap(this.config.translationSnap);
+            break;
+          case 'rotate':
+            this.transformControls.setRotationSnap(this.config.rotationSnap);
+            break;
+          case 'scale':
+            this.transformControls.setScaleSnap(this.config.scaleSnap);
+            break;
+        }
+
+        // Notify via callback if registered
+        if (this.callbacks.onModeChange) {
+          this.callbacks.onModeChange(mode);
+        }
+      }
+    }
+
+    /**
+     * Toggle coordinate space between world and local
+     */
+  }, {
+    key: "toggleSpace",
+    value: function toggleSpace() {
+      if (!this.transformControls) return;
+      this.currentSpace = this.currentSpace === 'world' ? 'local' : 'world';
+      this.transformControls.setSpace(this.currentSpace);
+    }
+
+    /**
+     * Toggle visibility of transform controls
+     */
+  }, {
+    key: "toggleVisibility",
+    value: function toggleVisibility() {
+      if (!this.transformControls) return;
+      if (!this.forceInvisible) {
+        this.transformControls.visible = !this.transformControls.visible;
+      }
+    }
+
+    /**
+     * Set enabled state of transform controls
+     * @param {boolean} enabled - Whether transform controls should be enabled
+     */
+  }, {
+    key: "setEnabled",
+    value: function setEnabled(enabled) {
+      this.config.enabled = enabled;
+      if (this.transformControls) {
+        this.transformControls.enabled = enabled;
+        if (!enabled) {
+          this.deselectObject();
+          this.transformControls.visible = false;
+        } else if (this.selectedObject && !this.forceInvisible) {
+          this.transformControls.visible = true;
+        }
+      }
+    }
+
+    /**
+     * Update axis visibility based on config
+     */
+  }, {
+    key: "updateAxisVisibility",
+    value: function updateAxisVisibility() {
+      if (!this.transformControls) return;
+      this.transformControls.showX = this.config.showX;
+      this.transformControls.showY = this.config.showY;
+      this.transformControls.showZ = this.config.showZ;
+    }
+
+    /**
+     * Show bounding box for an object
+     * @param {THREE.Object3D} object - The object to show bounding box for
+     */
+  }, {
+    key: "showBoundingBox",
+    value: function showBoundingBox(object) {
+      if (!object || !THREE) return;
+      this.hideBoundingBox();
+
+      // Get bounding box (from cache or compute it)
+      var boundingBox = this.boundingBoxCache.get(object);
+      if (!boundingBox) {
+        boundingBox = new THREE.Box3().setFromObject(object);
+        this.boundingBoxCache.set(object, boundingBox);
+      }
+
+      // Create helper if needed
+      if (!this.boundingBoxHelper) {
+        this.boundingBoxHelper = new THREE.Box3Helper(boundingBox, this.config.boundingBoxColor);
+        this.scene.add(this.boundingBoxHelper);
+      } else {
+        this.boundingBoxHelper.box = boundingBox;
+      }
+
+      // Store bounding box in object userData for easy access
+      object.userData.worldBoundingBox = boundingBox;
+    }
+
+    /**
+     * Hide bounding box helper
+     */
+  }, {
+    key: "hideBoundingBox",
+    value: function hideBoundingBox() {
+      if (this.boundingBoxHelper) {
+        this.scene.remove(this.boundingBoxHelper);
+        this.boundingBoxHelper = null;
+      }
+    }
+
+    /**
+     * Update bounding box for selected object
+     */
+  }, {
+    key: "updateBoundingBox",
+    value: function updateBoundingBox() {
+      if (this.selectedObject && this.config.showBoundingBox) {
+        // Update bounding box to reflect current transform
+        var boundingBox = new THREE.Box3().setFromObject(this.selectedObject);
+
+        // Update cache
+        this.boundingBoxCache.set(this.selectedObject, boundingBox);
+
+        // Update helper if exists
+        if (this.boundingBoxHelper) {
+          this.boundingBoxHelper.box = boundingBox;
+        }
+
+        // Update userData
+        this.selectedObject.userData.worldBoundingBox = boundingBox;
+      }
+    }
+
+    /**
+     * Capture object transformation data
+     * @param {THREE.Object3D} object - The object to capture transform from
+     * @returns {Object} Object containing position, rotation and scale data
+     */
+  }, {
+    key: "captureObjectTransform",
+    value: function captureObjectTransform(object) {
+      if (!object) return null;
+      return {
+        position: {
+          x: object.position.x,
+          y: object.position.y,
+          z: object.position.z
+        },
+        rotation: {
+          x: object.rotation.x,
+          y: object.rotation.y,
+          z: object.rotation.z
+        },
+        scale: {
+          x: object.scale.x,
+          y: object.scale.y,
+          z: object.scale.z
+        }
+      };
+    }
+
+    /**
+     * Set snap values for transformations
+     * @param {Object} options - Snap options
+     * @param {number} options.translation - Translation snap value
+     * @param {number} options.rotation - Rotation snap value in degrees
+     * @param {number} options.scale - Scale snap value
+     */
+  }, {
+    key: "setSnapValues",
+    value: function setSnapValues() {
+      var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+      if (!this.transformControls) return;
+      if (options.translation !== undefined) {
+        this.config.translationSnap = options.translation;
+        if (this.currentMode === 'translate') {
+          this.transformControls.setTranslationSnap(options.translation);
+        }
+      }
+      if (options.rotation !== undefined) {
+        // Convert degrees to radians for rotation snap
+        var rotationSnapRadians = options.rotation * (Math.PI / 180);
+        this.config.rotationSnap = rotationSnapRadians;
+        if (this.currentMode === 'rotate') {
+          this.transformControls.setRotationSnap(rotationSnapRadians);
+        }
+      }
+      if (options.scale !== undefined) {
+        this.config.scaleSnap = options.scale;
+        if (this.currentMode === 'scale') {
+          this.transformControls.setScaleSnap(options.scale);
+        }
+      }
+    }
+
+    /**
+     * Set size of transform controls
+     * @param {number} size - The size factor for transform controls
+     */
+  }, {
+    key: "setSize",
+    value: function setSize(size) {
+      this.config.size = size;
+      if (this.transformControls) {
+        this.transformControls.size = size;
+      }
+    }
+
+    /**
+     * Clean up resources and remove event listeners
+     */
+  }, {
+    key: "dispose",
+    value: function dispose() {
+      this.removeEventListeners();
+      this.hideBoundingBox();
+      if (this.transformControls) {
+        this.transformControls.detach();
+        this.scene.remove(this.transformControls);
+        this.transformControls = null;
+      }
+
+      // Clear references
+      this.selectedObject = null;
+      this.boundingBoxCache = new WeakMap();
+      console.log('🧹 TransformControlsManager disposed');
+    }
+
+    /**
+     * Ensures transform controls are properly attached to the scene
+     * @param {boolean} allowVisible - Whether to allow controls to be visible when reattached
+     * @returns {boolean} - True if controls were reattached, false if already attached
+     */
+  }, {
+    key: "ensureSceneAttachment",
+    value: function ensureSceneAttachment() {
+      var allowVisible = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
+      if (!this.transformControls || !this.scene) return false;
+
+      // Check if the controls are already in the scene
+      var isInScene = this.scene.children.includes(this.transformControls);
+      if (!isInScene) {
+        // Reattach to scene
+        this.scene.add(this.transformControls);
+
+        // Set visibility based on allowVisible parameter and forceInvisible flag
+        this.transformControls.visible = allowVisible && !this.forceInvisible && this.config.enabled;
+        return true; // Controls were reattached
+      }
+      return false; // Already properly attached
+    }
+
+    /**
+     * Get current transform data for the selected object
+     * @returns {Object|null} Object containing position, rotation, scale, and world coordinates
+     */
+  }, {
+    key: "getTransformData",
+    value: function getTransformData() {
+      if (!this.selectedObject) return null;
+      var worldPosition = new THREE.Vector3();
+      this.selectedObject.getWorldPosition(worldPosition);
+      var worldQuaternion = new THREE.Quaternion();
+      this.selectedObject.getWorldQuaternion(worldQuaternion);
+      var worldEuler = new THREE.Euler().setFromQuaternion(worldQuaternion);
+      var worldScale = new THREE.Vector3();
+      this.selectedObject.getWorldScale(worldScale);
+      return {
+        uuid: this.selectedObject.uuid,
+        position: {
+          x: this.selectedObject.position.x,
+          y: this.selectedObject.position.y,
+          z: this.selectedObject.position.z
+        },
+        rotation: {
+          x: this.selectedObject.rotation.x,
+          y: this.selectedObject.rotation.y,
+          z: this.selectedObject.rotation.z
+        },
+        scale: {
+          x: this.selectedObject.scale.x,
+          y: this.selectedObject.scale.y,
+          z: this.selectedObject.scale.z
+        },
+        worldPosition: {
+          x: worldPosition.x,
+          y: worldPosition.y,
+          z: worldPosition.z
+        },
+        worldRotation: {
+          x: worldEuler.x,
+          y: worldEuler.y,
+          z: worldEuler.z
+        },
+        worldScale: {
+          x: worldScale.x,
+          y: worldScale.y,
+          z: worldScale.z
+        }
+      };
+    }
+  }]);
+}();
+
+/**
+ * Factory function to get TransformControlsManager instance
+ * @param {THREE.Scene} scene - The Three.js scene
+ * @param {THREE.Camera} camera - The Three.js camera
+ * @param {THREE.WebGLRenderer} renderer - The Three.js renderer
+ * @param {THREE.OrbitControls} orbitControls - Optional orbit controls for camera
+ * @returns {TransformControlsManager} TransformControlsManager instance
+ */
+function getTransformControlsManager(scene, camera, renderer, orbitControls) {
+  return new TransformControlsManager(scene, camera, renderer, orbitControls);
+}
+
+export { TransformControlsManager, TransformControlsManager as default, getTransformControlsManager };