@2112-lab/central-plant 0.1.0

package/dist/esm/src/sceneInitializationManager.js

@@ -0,0 +1,513 @@
+import { createClass as _createClass, asyncToGenerator as _asyncToGenerator, regenerator as _regenerator, classCallCheck as _classCallCheck } from '../_virtual/_rollupPluginBabelHelpers.js';
+import * as THREE from 'three';
+import { logger } from './debugLogger.js';
+
+// These will be loaded dynamically in browser environments
+var OrbitControls;
+var GLTFLoader;
+var PerformanceMonitor;
+var PerformanceUI;
+
+// Dynamic imports for browser compatibility
+function importThreeJSDependencies() {
+  return _importThreeJSDependencies.apply(this, arguments);
+}
+function _importThreeJSDependencies() {
+  _importThreeJSDependencies = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee4() {
+    var orbitModule, customModule, gltfModule, perfModule, _t, _t3, _t4;
+    return _regenerator().w(function (_context4) {
+      while (1) switch (_context4.n) {
+        case 0:
+          if (!(typeof window !== 'undefined')) {
+            _context4.n = 15;
+            break;
+          }
+          _context4.p = 1;
+          _context4.p = 2;
+          _context4.n = 3;
+          return import('../node_modules/three/examples/jsm/controls/OrbitControls.js');
+        case 3:
+          orbitModule = _context4.v;
+          OrbitControls = orbitModule.OrbitControls;
+          _context4.n = 9;
+          break;
+        case 4:
+          _context4.p = 4;
+          _t = _context4.v;
+          console.warn('OrbitControls not loaded:', _t.message);
+          // Fallback for OrbitControls - may be needed in some bundlers
+          _context4.p = 5;
+          if (!(typeof window.__orbitControlsCustomPath === 'string')) {
+            _context4.n = 7;
+            break;
+          }
+          _context4.n = 6;
+          return import(window.__orbitControlsCustomPath);
+        case 6:
+          customModule = _context4.v;
+          OrbitControls = customModule.OrbitControls;
+        case 7:
+          _context4.n = 9;
+          break;
+        case 8:
+          _context4.p = 8;
+          _context4.v;
+          console.warn('Failed to load OrbitControls from custom path');
+        case 9:
+          _context4.p = 9;
+          _context4.n = 10;
+          return import('../node_modules/three/examples/jsm/loaders/GLTFLoader.js');
+        case 10:
+          gltfModule = _context4.v;
+          GLTFLoader = gltfModule.GLTFLoader;
+          _context4.n = 12;
+          break;
+        case 11:
+          _context4.p = 11;
+          _t3 = _context4.v;
+          console.warn('GLTFLoader not loaded:', _t3.message);
+        case 12:
+          _context4.n = 13;
+          return import('./performanceMonitor.js');
+        case 13:
+          perfModule = _context4.v;
+          PerformanceMonitor = perfModule.PerformanceMonitor;
+          PerformanceUI = perfModule.PerformanceUI;
+          _context4.n = 15;
+          break;
+        case 14:
+          _context4.p = 14;
+          _t4 = _context4.v;
+          console.error('Failed to load Three.js dependencies:', _t4);
+        case 15:
+          return _context4.a(2);
+      }
+    }, _callee4, null, [[9, 11], [5, 8], [2, 4], [1, 14]]);
+  }));
+  return _importThreeJSDependencies.apply(this, arguments);
+}
+var SceneInitializationManager = /*#__PURE__*/function () {
+  function SceneInitializationManager(component) {
+    _classCallCheck(this, SceneInitializationManager);
+    this.component = component;
+    this.textureLoader = null;
+    this.gltfLoader = null;
+
+    // Initialize dependencies
+    importThreeJSDependencies();
+  }
+
+  /**
+   * Initialize the Three.js scene, camera, and renderer
+   */
+  return _createClass(SceneInitializationManager, [{
+    key: "initializeScene",
+    value: (function () {
+      var _initializeScene = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee() {
+        var _component$$refs, _component$$refs2;
+        var component, containerRect, containerWidth, containerHeight;
+        return _regenerator().w(function (_context) {
+          while (1) switch (_context.n) {
+            case 0:
+              component = this.component;
+              if (component) {
+                _context.n = 1;
+                break;
+              }
+              logger.error('Cannot initialize scene: component not available');
+              return _context.a(2);
+            case 1:
+              // Create scene
+              component.scene = new THREE.Scene();
+
+              // Create camera (default values, can be updated later)
+              containerRect = ((_component$$refs = component.$refs) === null || _component$$refs === void 0 || (_component$$refs = _component$$refs.container) === null || _component$$refs === void 0 ? void 0 : _component$$refs.getBoundingClientRect()) || {
+                width: 800,
+                height: 600
+              };
+              containerWidth = containerRect.width;
+              containerHeight = containerRect.height;
+              component.camera = new THREE.PerspectiveCamera(50, containerWidth / containerHeight, 0.01, 1000);
+              component.camera.position.set(-8, 4, 9);
+
+              // Setup renderer if container exists
+              if (!((_component$$refs2 = component.$refs) !== null && _component$$refs2 !== void 0 && _component$$refs2.container)) {
+                _context.n = 2;
+                break;
+              }
+              _context.n = 2;
+              return this.setupRenderer(component.$refs.container, containerWidth, containerHeight);
+            case 2:
+              logger.info('Scene and camera initialized');
+              return _context.a(2, {
+                scene: component.scene,
+                camera: component.camera
+              });
+          }
+        }, _callee, this);
+      }));
+      function initializeScene() {
+        return _initializeScene.apply(this, arguments);
+      }
+      return initializeScene;
+    }()
+    /**
+     * Setup the WebGL renderer
+     */
+    )
+  }, {
+    key: "setupRenderer",
+    value: (function () {
+      var _setupRenderer = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee2(container, width, height) {
+        var component, containerRect;
+        return _regenerator().w(function (_context2) {
+          while (1) switch (_context2.n) {
+            case 0:
+              component = this.component;
+              if (component) {
+                _context2.n = 1;
+                break;
+              }
+              logger.error('Cannot setup renderer: component not available');
+              return _context2.a(2, null);
+            case 1:
+              // Use provided dimensions or get from container
+              if (!width || !height) {
+                containerRect = container.getBoundingClientRect();
+                width = containerRect.width;
+                height = containerRect.height;
+              }
+
+              // Create renderer
+              component.renderer = new THREE.WebGLRenderer({
+                antialias: true
+              });
+              component.renderer.setSize(width, height);
+              component.renderer.setPixelRatio(Math.min(window.devicePixelRatio, 2));
+              component.renderer.shadowMap.enabled = true;
+              component.renderer.shadowMap.type = THREE.PCFSoftShadowMap;
+              component.renderer.physicallyCorrectLights = true;
+              component.renderer.outputColorSpace = THREE.SRGBColorSpace;
+              component.renderer.toneMapping = THREE.LinearToneMapping;
+              component.renderer.toneMappingExposure = 1.5;
+
+              // Add renderer to container
+              container.appendChild(component.renderer.domElement);
+
+              // Setup resize handler
+              this.setupResizeHandler();
+
+              // Create texture and model loaders
+              component.textureLoader = new THREE.TextureLoader();
+              this.textureLoader = component.textureLoader;
+
+              // Initialize GLTF loader if available
+              if (!GLTFLoader) {
+                _context2.n = 2;
+                break;
+              }
+              component.gltfLoader = new GLTFLoader();
+              this.gltfLoader = component.gltfLoader;
+              _context2.n = 4;
+              break;
+            case 2:
+              _context2.n = 3;
+              return importThreeJSDependencies();
+            case 3:
+              if (GLTFLoader) {
+                component.gltfLoader = new GLTFLoader();
+                this.gltfLoader = component.gltfLoader;
+              }
+            case 4:
+              logger.info('Renderer initialized');
+              return _context2.a(2, component.renderer);
+          }
+        }, _callee2, this);
+      }));
+      function setupRenderer(_x, _x2, _x3) {
+        return _setupRenderer.apply(this, arguments);
+      }
+      return setupRenderer;
+    }()
+    /**
+     * Setup orbit controls
+     */
+    )
+  }, {
+    key: "setupControls",
+    value: function setupControls(container) {
+      var _this = this;
+      var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+      var component = this.component;
+      if (!component || !component.camera || !component.renderer) {
+        logger.error('Cannot setup controls: camera or renderer not available');
+        return null;
+      }
+
+      // Initialize OrbitControls if available
+      if (!OrbitControls) {
+        logger.info('OrbitControls not available, will try to import');
+        importThreeJSDependencies().then(function () {
+          if (OrbitControls) {
+            _this.setupControlsInternal(container, options);
+          }
+        });
+        return null;
+      }
+      return this.setupControlsInternal(container, options);
+    }
+
+    /**
+     * Internal method to setup controls after dependencies are loaded
+     */
+  }, {
+    key: "setupControlsInternal",
+    value: function setupControlsInternal(container) {
+      var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+      var component = this.component;
+      var domElement = container || component.renderer.domElement;
+
+      // Create controls
+      component.controls = new OrbitControls(component.camera, domElement);
+
+      // Apply options
+      component.controls.enableDamping = options.enableDamping !== false;
+      component.controls.dampingFactor = options.dampingFactor || 0.05;
+      component.controls.screenSpacePanning = options.screenSpacePanning !== false;
+      component.controls.maxPolarAngle = options.maxPolarAngle || Math.PI / 1.5;
+      component.controls.minDistance = options.minDistance || 2;
+      component.controls.maxDistance = options.maxDistance || 50;
+
+      // Additional options if provided
+      if (options.target) {
+        component.controls.target.copy(options.target);
+      }
+      if (options.autoRotate) {
+        component.controls.autoRotate = true;
+        component.controls.autoRotateSpeed = options.autoRotateSpeed || 1.0;
+      }
+      logger.info('Orbit controls initialized');
+      return component.controls;
+    }
+
+    /**
+     * Initialize performance monitoring
+     */
+  }, {
+    key: "initializePerformanceMonitoring",
+    value: (function () {
+      var _initializePerformanceMonitoring = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee3() {
+        var _component$$refs3;
+        var component;
+        return _regenerator().w(function (_context3) {
+          while (1) switch (_context3.n) {
+            case 0:
+              component = this.component;
+              if (!(!component || !component.renderer)) {
+                _context3.n = 1;
+                break;
+              }
+              logger.error('Cannot initialize performance monitoring: renderer not available');
+              return _context3.a(2);
+            case 1:
+              if (PerformanceMonitor) {
+                _context3.n = 3;
+                break;
+              }
+              _context3.n = 2;
+              return importThreeJSDependencies();
+            case 2:
+              if (PerformanceMonitor) {
+                _context3.n = 3;
+                break;
+              }
+              logger.error('Performance monitoring not available');
+              return _context3.a(2);
+            case 3:
+              // Initialize performance monitoring
+              component.performanceMonitor = new PerformanceMonitor(component.renderer);
+              if ((_component$$refs3 = component.$refs) !== null && _component$$refs3 !== void 0 && _component$$refs3.container) {
+                component.performanceUI = new PerformanceUI(component.performanceMonitor, component.$refs.container, 'light');
+              }
+
+              // Setup performance monitoring callbacks
+              component.performanceMonitor.on('warning', function (warnings) {
+                // logger.warn('Performance warnings:', warnings);
+              });
+              component.performanceMonitor.start();
+              if (component.performanceUI) {
+                component.performanceUI.show();
+              }
+              this.exposePerformanceMonitoringGlobally();
+              logger.info('Performance monitoring initialized');
+              return _context3.a(2, {
+                monitor: component.performanceMonitor,
+                ui: component.performanceUI
+              });
+          }
+        }, _callee3, this);
+      }));
+      function initializePerformanceMonitoring() {
+        return _initializePerformanceMonitoring.apply(this, arguments);
+      }
+      return initializePerformanceMonitoring;
+    }()
+    /**
+     * Expose performance monitoring to global scope for debugging
+     */
+    )
+  }, {
+    key: "exposePerformanceMonitoringGlobally",
+    value: function exposePerformanceMonitoringGlobally() {
+      var component = this.component;
+      if (!component || !component.performanceMonitor) return;
+      if (typeof window !== 'undefined') {
+        window._performanceMonitor = component.performanceMonitor;
+        window._performanceUI = component.performanceUI;
+        window.performance3D = {
+          show: function show() {
+            var _component$performanc;
+            return (_component$performanc = component.performanceUI) === null || _component$performanc === void 0 ? void 0 : _component$performanc.show();
+          },
+          hide: function hide() {
+            var _component$performanc2;
+            return (_component$performanc2 = component.performanceUI) === null || _component$performanc2 === void 0 ? void 0 : _component$performanc2.hide();
+          },
+          toggle: function toggle() {
+            var _component$performanc3, _component$performanc4, _component$performanc5;
+            return (_component$performanc3 = component.performanceUI) !== null && _component$performanc3 !== void 0 && _component$performanc3.isVisible ? (_component$performanc4 = component.performanceUI) === null || _component$performanc4 === void 0 ? void 0 : _component$performanc4.hide() : (_component$performanc5 = component.performanceUI) === null || _component$performanc5 === void 0 ? void 0 : _component$performanc5.show();
+          },
+          setTheme: function setTheme(theme) {
+            var _component$performanc6;
+            return (_component$performanc6 = component.performanceUI) === null || _component$performanc6 === void 0 ? void 0 : _component$performanc6.setTheme(theme);
+          },
+          log: function log() {
+            var _component$performanc7;
+            return (_component$performanc7 = component.performanceMonitor) === null || _component$performanc7 === void 0 ? void 0 : _component$performanc7.logSummary();
+          },
+          reset: function reset() {
+            var _component$performanc8;
+            return (_component$performanc8 = component.performanceMonitor) === null || _component$performanc8 === void 0 ? void 0 : _component$performanc8.reset();
+          },
+          export: function _export() {
+            var _component$performanc9;
+            return (_component$performanc9 = component.performanceMonitor) === null || _component$performanc9 === void 0 ? void 0 : _component$performanc9.exportData();
+          },
+          help: function help() {
+            console.group('🔧 Performance Monitor Controls');
+            console.log('📊 performance3D.show() - Show performance UI');
+            console.log('🙈 performance3D.hide() - Hide performance UI');
+            console.log('🔄 performance3D.toggle() - Toggle performance UI');
+            console.log('🎨 performance3D.setTheme("light"|"dark") - Set UI theme');
+            console.log('📋 performance3D.log() - Log performance summary');
+            console.log('🔄 performance3D.reset() - Reset statistics');
+            console.log('💾 performance3D.export() - Export performance data');
+            console.log('❓ performance3D.help() - Show this help');
+            console.groupEnd();
+          }
+        };
+        logger.info('Performance monitoring exposed to global scope');
+      }
+    }
+
+    /**
+     * Setup resize handler for responsive rendering
+     */
+  }, {
+    key: "setupResizeHandler",
+    value: function setupResizeHandler() {
+      var _component$$refs4;
+      var component = this.component;
+      if (!component || !((_component$$refs4 = component.$refs) !== null && _component$$refs4 !== void 0 && _component$$refs4.container)) return;
+      var handleResize = function handleResize() {
+        if (!component.renderer || !component.camera) return;
+
+        // Get container dimensions
+        var container = component.$refs.container;
+        var width = container.clientWidth;
+        var height = container.clientHeight;
+
+        // Update camera
+        component.camera.aspect = width / height;
+        component.camera.updateProjectionMatrix();
+
+        // Update renderer
+        component.renderer.setSize(width, height);
+        component.renderer.setPixelRatio(Math.min(window.devicePixelRatio, 2));
+      };
+
+      // Initial setup
+      handleResize();
+
+      // Add event listener
+      window.addEventListener('resize', handleResize);
+
+      // Store resize handler for cleanup
+      this._resizeHandler = handleResize;
+      logger.info('Resize handler initialized');
+    }
+
+    /**
+     * Cleanup resize handler
+     */
+  }, {
+    key: "cleanupResizeHandler",
+    value: function cleanupResizeHandler() {
+      if (this._resizeHandler) {
+        window.removeEventListener('resize', this._resizeHandler);
+        this._resizeHandler = null;
+      }
+    }
+  }]);
+}();
+
+// Create a singleton instance
+var sceneInitializationManager = null;
+
+/**
+ * Get the global scene initialization manager instance
+ */
+function getSceneInitializationManager() {
+  var component = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
+  if (!sceneInitializationManager || component && sceneInitializationManager.component !== component) {
+    sceneInitializationManager = new SceneInitializationManager(component);
+  }
+  return sceneInitializationManager;
+}
+
+// Common initialization function
+function setupScene(_x4, _x5) {
+  return _setupScene.apply(this, arguments);
+}
+function _setupScene() {
+  _setupScene = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee5(component, container) {
+    var manager;
+    return _regenerator().w(function (_context5) {
+      while (1) switch (_context5.n) {
+        case 0:
+          manager = getSceneInitializationManager(component);
+          _context5.n = 1;
+          return manager.initializeScene();
+        case 1:
+          if (!container) {
+            _context5.n = 3;
+            break;
+          }
+          _context5.n = 2;
+          return manager.setupRenderer(container);
+        case 2:
+          manager.setupControls(container);
+        case 3:
+          return _context5.a(2, manager);
+      }
+    }, _callee5);
+  }));
+  return _setupScene.apply(this, arguments);
+}
+var sceneInitializationManager$1 = {
+  SceneInitializationManager: SceneInitializationManager,
+  getSceneInitializationManager: getSceneInitializationManager,
+  setupScene: setupScene
+};
+
+export { SceneInitializationManager, sceneInitializationManager$1 as default, getSceneInitializationManager, setupScene };