@2112-lab/central-plant 0.1.4 → 0.1.6

package/dist/cjs/src/managers/controls/keyboardControlsManager.js

@@ -1 +1,395 @@
-"use strict";Object.defineProperty(exports,"t",{value:!0});var e=require("../../../_virtual/_rollupPluginBabelHelpers.js"),n=require("three"),t=require("../../core/debugLogger.js");function i(e){if(e&&e.t)return e;var n=Object.create(null);return e&&Object.keys(e).forEach(function(t){if("default"!==t){var i=Object.getOwnPropertyDescriptor(e,t);Object.defineProperty(n,t,i.get?i:{enumerable:!0,get:function(){return e[t]}})}}),n.default=e,Object.freeze(n)}var r=i(n),a=function(){return e.createClass(function n(t){e.classCallCheck(this,n),this.sceneViewer=t,this.handleKeyDown=null},[{key:"setupKeyboardControls",value:function(){var e=this;this.handleKeyDown=function(n){if(n.ctrlKey&&("z"===n.key.toLowerCase()||"KeyZ"===n.code))return n.preventDefault(),n.stopPropagation(),void e.undoTransform();if(n.altKey&&("r"===n.key.toLowerCase()||"KeyR"===n.code))return n.preventDefault(),n.stopPropagation(),void e.toggleShouldUpdatePaths();switch(n.key.toLowerCase()){case"p":e.togglePerformanceUI();break;case"l":e.logPerformanceSummary();break;case"r":e.resetPerformanceStats();break;case"a":e.toggleAutoRotation();break;case"e":e.cycleToneMapping();break;case"=":case"+":e.increaseExposure();break;case"-":e.decreaseExposure();break;case"h":e.showHelpInfo()}},window.addEventListener("keydown",this.handleKeyDown,!0),window._performanceKeyHandler=this.handleKeyDown,this.overrideTransformControlsKeyboard(),t.logger.info("Keyboard controls initialized with Ctrl+Z undo override")}},{key:"togglePerformanceUI",value:function(){var e=this.sceneViewer;e.performanceUI&&(e.performanceUI.isVisible?e.performanceUI.hide():e.performanceUI.show())}},{key:"logPerformanceSummary",value:function(){var e=this.sceneViewer;e.performanceMonitor&&e.performanceMonitor.logSummary()}},{key:"resetPerformanceStats",value:function(){var e=this.sceneViewer;e.performanceMonitor&&e.performanceMonitor.reset()}},{key:"cycleToneMapping",value:function(){var e=this.sceneViewer;if(e.renderer){var n=[{type:r.NoToneMapping,name:"None"},{type:r.LinearToneMapping,name:"Linear"},{type:r.ReinhardToneMapping,name:"Reinhard"},{type:r.CineonToneMapping,name:"Cineon"},{type:r.ACESFilmicToneMapping,name:"ACES Filmic"}],t=n.findIndex(function(n){return n.type===e.renderer.toneMapping}),i=(t+1)%n.length,a=(n[t],n[i]);e.renderer.toneMapping=a.type}}},{key:"increaseExposure",value:function(){var e=this.sceneViewer;e.renderer&&(e.renderer.toneMappingExposure=Math.min(e.renderer.toneMappingExposure+.1,3))}},{key:"decreaseExposure",value:function(){var e=this.sceneViewer;e.renderer&&(e.renderer.toneMappingExposure=Math.max(e.renderer.toneMappingExposure-.1,.1))}},{key:"showHelpInfo",value:function(){}},{key:"toggleShouldUpdatePaths",value:function(){var e=this.sceneViewer;e&&"function"==typeof e.toggleShouldUpdatePaths&&e.toggleShouldUpdatePaths()}},{key:"toggleAutoRotation",value:function(){var e=this.sceneViewer;if(e.sceneInitializationManager){var n=e.sceneInitializationManager.toggleAutoRotation();void 0!==e.isAutoRotating&&(e.isAutoRotating=n)}}},{key:"setupResizeHandler",value:function(){var e=this.sceneViewer;e.handleResize=function(){if(e.$refs.container&&e.camera&&e.renderer){var n=e.$refs.container.getBoundingClientRect(),t=n.width,i=n.height;e.camera.aspect=t/i,e.camera.updateProjectionMatrix(),e.renderer.setSize(t,i),e.composer&&(e.composer.setSize(t,i),e.ssaoPass&&e.ssaoPass.setSize(t,i),e.bloomPass&&e.bloomPass.resolution.set(t,i)),e.tooltipsManager&&e.tooltipsManager.resize()}},e.resizeObserver=new ResizeObserver(e.handleResize),e.resizeObserver.observe(e.$refs.container),window.addEventListener("resize",e.handleResize),t.logger.info("Resize handler initialized")}},{key:"cleanup",value:function(){this.handleKeyDown&&(window.removeEventListener("keydown",this.handleKeyDown,!0),this.handleKeyDown=null),window._performanceKeyHandler&&(window.removeEventListener("keydown",window._performanceKeyHandler,!0),delete window._performanceKeyHandler);var e=this.sceneViewer;e.handleResize&&(window.removeEventListener("resize",e.handleResize),e.handleResize=null),e.resizeObserver&&(e.resizeObserver.disconnect(),e.resizeObserver=null),t.logger.info("Keyboard controls cleanup completed")}},{key:"undoTransform",value:function(){var e=this.sceneViewer;e.centralPlant&&("function"==typeof e.centralPlant.undoTransform&&e.centralPlant.undoTransform()&&(e.sceneHelper&&"function"==typeof e.sceneHelper.requestRender&&e.sceneHelper.requestRender(),e.renderer&&e.renderer.render(e.scene,e.camera),e.updateComponentPositions&&"function"==typeof e.updateComponentPositions&&e.updateComponentPositions()))}},{key:"overrideTransformControlsKeyboard",value:function(){var e=this.sceneViewer;if(e.transformManager&&e.transformManager.eventHandlers&&e.transformManager.eventHandlers.keydown){var n=e.transformManager.eventHandlers.keydown;e.transformManager.eventHandlers.keydown=function(e){(!e.ctrlKey||"z"!==e.key.toLowerCase()&&"KeyZ"!==e.code)&&n(e)}}}}])}();exports.KeyboardControlsManager=a;
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _rollupPluginBabelHelpers = require('../../../_virtual/_rollupPluginBabelHelpers.js');
+var THREE = require('three');
+var debugLogger = require('../../core/debugLogger.js');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n["default"] = e;
+  return Object.freeze(n);
+}
+
+var THREE__namespace = /*#__PURE__*/_interopNamespace(THREE);
+
+var KeyboardControlsManager = /*#__PURE__*/function () {
+  function KeyboardControlsManager(sceneViewer) {
+    _rollupPluginBabelHelpers.classCallCheck(this, KeyboardControlsManager);
+    this.sceneViewer = sceneViewer;
+    this.handleKeyDown = null;
+  }
+
+  /**
+   * Setup keyboard event handlers
+   */
+  return _rollupPluginBabelHelpers.createClass(KeyboardControlsManager, [{
+    key: "setupKeyboardControls",
+    value: function setupKeyboardControls() {
+      var _this = this;
+      this.handleKeyDown = function (event) {
+        // Handle Ctrl+Z for undo with high priority
+        if (event.ctrlKey && (event.key.toLowerCase() === 'z' || event.code === 'KeyZ')) {
+          event.preventDefault();
+          event.stopPropagation();
+          _this.undoTransform();
+          return;
+        }
+
+        // Handle Alt+R for toggling auto-repathing
+        if (event.altKey && (event.key.toLowerCase() === 'r' || event.code === 'KeyR')) {
+          event.preventDefault();
+          event.stopPropagation();
+          _this.toggleShouldUpdatePaths();
+          return;
+        }
+        switch (event.key.toLowerCase()) {
+          case 'p':
+            _this.togglePerformanceUI();
+            break;
+          case 'l':
+            _this.logPerformanceSummary();
+            break;
+          case 'r':
+            _this.resetPerformanceStats();
+            break;
+          case 'a':
+            _this.toggleAutoRotation();
+            break;
+          case 'e':
+            _this.cycleToneMapping();
+            break;
+          case '=':
+          case '+':
+            _this.increaseExposure();
+            break;
+          case '-':
+            _this.decreaseExposure();
+            break;
+          case 'h':
+            _this.showHelpInfo();
+            break;
+        }
+      };
+
+      // Add with capture phase for higher priority
+      window.addEventListener('keydown', this.handleKeyDown, true);
+      window._performanceKeyHandler = this.handleKeyDown;
+
+      // Override transform controls keyboard handling
+      this.overrideTransformControlsKeyboard();
+      debugLogger.logger.info('Keyboard controls initialized with Ctrl+Z undo override');
+    }
+
+    /**
+     * Toggle performance UI visibility
+     */
+  }, {
+    key: "togglePerformanceUI",
+    value: function togglePerformanceUI() {
+      var component = this.sceneViewer;
+      if (component.performanceUI) {
+        if (component.performanceUI.isVisible) {
+          component.performanceUI.hide();
+          console.log('📊 Performance UI hidden');
+        } else {
+          component.performanceUI.show();
+          console.log('📊 Performance UI shown');
+        }
+      }
+    }
+
+    /**
+     * Log performance summary to console
+     */
+  }, {
+    key: "logPerformanceSummary",
+    value: function logPerformanceSummary() {
+      var component = this.sceneViewer;
+      if (component.performanceMonitor) {
+        component.performanceMonitor.logSummary();
+      }
+    }
+
+    /**
+     * Reset performance statistics
+     */
+  }, {
+    key: "resetPerformanceStats",
+    value: function resetPerformanceStats() {
+      var component = this.sceneViewer;
+      if (component.performanceMonitor) {
+        component.performanceMonitor.reset();
+      }
+    }
+
+    /**
+     * Cycle through different tone mapping types
+     */
+  }, {
+    key: "cycleToneMapping",
+    value: function cycleToneMapping() {
+      var component = this.sceneViewer;
+      if (!component.renderer) {
+        console.warn('⚠️ Renderer not initialized yet');
+        return;
+      }
+      var toneMappings = [{
+        type: THREE__namespace.NoToneMapping,
+        name: 'None'
+      }, {
+        type: THREE__namespace.LinearToneMapping,
+        name: 'Linear'
+      }, {
+        type: THREE__namespace.ReinhardToneMapping,
+        name: 'Reinhard'
+      }, {
+        type: THREE__namespace.CineonToneMapping,
+        name: 'Cineon'
+      }, {
+        type: THREE__namespace.ACESFilmicToneMapping,
+        name: 'ACES Filmic'
+      }];
+      var currentIndex = toneMappings.findIndex(function (tm) {
+        return tm.type === component.renderer.toneMapping;
+      });
+      var nextIndex = (currentIndex + 1) % toneMappings.length;
+      var previousMapping = toneMappings[currentIndex] || {
+        name: 'Unknown'
+      };
+      var newMapping = toneMappings[nextIndex];
+      component.renderer.toneMapping = newMapping.type;
+      console.group('🎨 Tone Mapping Changed');
+      console.log("Previous: ".concat(previousMapping.name));
+      console.log("Current:  ".concat(newMapping.name));
+      console.log("Exposure: ".concat(component.renderer.toneMappingExposure.toFixed(1)));
+      console.groupEnd();
+    }
+
+    /**
+     * Increase renderer exposure
+     */
+  }, {
+    key: "increaseExposure",
+    value: function increaseExposure() {
+      var component = this.sceneViewer;
+      if (component.renderer) {
+        component.renderer.toneMappingExposure = Math.min(component.renderer.toneMappingExposure + 0.1, 3.0);
+        console.log("\u2600\uFE0F Exposure increased to: ".concat(component.renderer.toneMappingExposure.toFixed(1)));
+      }
+    }
+
+    /**
+     * Decrease renderer exposure
+     */
+  }, {
+    key: "decreaseExposure",
+    value: function decreaseExposure() {
+      var component = this.sceneViewer;
+      if (component.renderer) {
+        component.renderer.toneMappingExposure = Math.max(component.renderer.toneMappingExposure - 0.1, 0.1);
+        console.log("\uD83C\uDF19 Exposure decreased to: ".concat(component.renderer.toneMappingExposure.toFixed(1)));
+      }
+    }
+
+    /**
+     * Show help information for keyboard controls
+     */
+  }, {
+    key: "showHelpInfo",
+    value: function showHelpInfo() {
+      console.group('🎮 3D Scene Controls');
+      console.log('↩️ Ctrl+Z - Undo last transform');
+      console.log('🔄 Alt+R - Toggle auto-repathing after transforms');
+      console.log('📊 P - Toggle performance UI');
+      console.log('📝 L - Log performance summary');
+      console.log('🔄 R - Reset performance statistics');
+      console.log('🔄 A - Toggle auto-rotation');
+      console.log('🎨 E - Cycle tone mapping types');
+      console.log('☀️ + / = - Increase exposure');
+      console.log('🌙 - - Decrease exposure');
+      console.log('❓ H - Show this help');
+      console.groupEnd();
+    }
+    /**
+     * Toggle shouldRepath setting in the scene viewer
+     */
+  }, {
+    key: "toggleShouldUpdatePaths",
+    value: function toggleShouldUpdatePaths() {
+      var component = this.sceneViewer;
+      if (component && typeof component.toggleShouldUpdatePaths === 'function') {
+        component.toggleShouldUpdatePaths();
+      } else {
+        console.warn('⚠️ toggleShouldUpdatePaths method not available on scene viewer');
+      }
+    }
+
+    /**
+     * Toggle auto-rotation of the camera
+     */
+  }, {
+    key: "toggleAutoRotation",
+    value: function toggleAutoRotation() {
+      var component = this.sceneViewer;
+      if (component.sceneInitializationManager) {
+        var isEnabled = component.sceneInitializationManager.toggleAutoRotation();
+        console.log("\uD83D\uDD04 Auto-rotation ".concat(isEnabled ? 'enabled' : 'disabled'));
+
+        // Update the component's isAutoRotating state for UI sync
+        if (component.isAutoRotating !== undefined) {
+          component.isAutoRotating = isEnabled;
+        }
+      } else {
+        console.warn('⚠️ Scene initialization manager not available, cannot toggle auto-rotation');
+      }
+    }
+
+    /**
+     * Setup resize handler for responsive design
+     */
+  }, {
+    key: "setupResizeHandler",
+    value: function setupResizeHandler() {
+      var component = this.sceneViewer;
+      component.handleResize = function () {
+        if (!component.$refs.container || !component.camera || !component.renderer) return;
+        var containerRect = component.$refs.container.getBoundingClientRect();
+        var containerWidth = containerRect.width;
+        var containerHeight = containerRect.height;
+        component.camera.aspect = containerWidth / containerHeight;
+        component.camera.updateProjectionMatrix();
+        component.renderer.setSize(containerWidth, containerHeight);
+        if (component.composer) {
+          component.composer.setSize(containerWidth, containerHeight);
+          if (component.ssaoPass) {
+            component.ssaoPass.setSize(containerWidth, containerHeight);
+          }
+          if (component.bloomPass) {
+            component.bloomPass.resolution.set(containerWidth, containerHeight);
+          }
+        }
+
+        // Update tooltip renderer if it exists
+        if (component.tooltipsManager) {
+          component.tooltipsManager.resize();
+        }
+      };
+
+      // Set up ResizeObserver for better container size tracking
+      component.resizeObserver = new ResizeObserver(component.handleResize);
+      component.resizeObserver.observe(component.$refs.container);
+
+      // Also listen for window resize as fallback
+      window.addEventListener('resize', component.handleResize);
+      debugLogger.logger.info('Resize handler initialized');
+    }
+
+    /**
+     * Cleanup event listeners
+     */
+  }, {
+    key: "cleanup",
+    value: function cleanup() {
+      if (this.handleKeyDown) {
+        window.removeEventListener('keydown', this.handleKeyDown, true);
+        this.handleKeyDown = null;
+      }
+      if (window._performanceKeyHandler) {
+        window.removeEventListener('keydown', window._performanceKeyHandler, true);
+        delete window._performanceKeyHandler;
+      }
+      var component = this.sceneViewer;
+      if (component.handleResize) {
+        window.removeEventListener('resize', component.handleResize);
+        component.handleResize = null;
+      }
+      if (component.resizeObserver) {
+        component.resizeObserver.disconnect();
+        component.resizeObserver = null;
+      }
+      debugLogger.logger.info('Keyboard controls cleanup completed');
+    }
+
+    /**
+     * Undo the last transform operation
+     */
+  }, {
+    key: "undoTransform",
+    value: function undoTransform() {
+      var component = this.sceneViewer;
+
+      // Check if CentralPlant instance exists and has the undoTransform method
+      if (!component.centralPlant) {
+        console.warn('⚠️ CentralPlant instance not available for undo operation');
+        return;
+      }
+      if (typeof component.centralPlant.undoTransform !== 'function') {
+        console.warn('⚠️ undoTransform method not available on CentralPlant instance');
+        return;
+      }
+      var success = component.centralPlant.undoTransform();
+      if (success) {
+        console.log('✅ Transform undone via keyboard shortcut (Ctrl+Z)');
+
+        // If there's a scene helper, trigger a render update
+        if (component.sceneHelper && typeof component.sceneHelper.requestRender === 'function') {
+          component.sceneHelper.requestRender();
+        }
+
+        // If there's a renderer, trigger a render
+        if (component.renderer) {
+          component.renderer.render(component.scene, component.camera);
+        }
+
+        // Update any UI elements that might be affected
+        if (component.updateComponentPositions && typeof component.updateComponentPositions === 'function') {
+          component.updateComponentPositions();
+        }
+      } else {
+        console.log('⚠️ No transform to undo');
+      }
+    }
+
+    /**
+     * Override transform controls keyboard handling to ensure Ctrl+Z undo works
+     */
+  }, {
+    key: "overrideTransformControlsKeyboard",
+    value: function overrideTransformControlsKeyboard() {
+      var component = this.sceneViewer;
+
+      // If transform controls manager exists, ensure it doesn't interfere with Ctrl+Z
+      if (component.transformManager && component.transformManager.eventHandlers && component.transformManager.eventHandlers.keydown) {
+        var originalHandler = component.transformManager.eventHandlers.keydown;
+
+        // Create a new handler that checks for Ctrl+Z first
+        component.transformManager.eventHandlers.keydown = function (event) {
+          // If it's Ctrl+Z, don't handle it in transform controls
+          if (event.ctrlKey && (event.key.toLowerCase() === 'z' || event.code === 'KeyZ')) {
+            return; // Let our undo handler take care of it
+          }
+
+          // Otherwise, use the original handler
+          originalHandler(event);
+        };
+        console.log('✅ Transform controls keyboard handling overridden for Ctrl+Z');
+      }
+    }
+  }]);
+}();
+
+exports.KeyboardControlsManager = KeyboardControlsManager;