@2112-lab/central-plant 0.1.0

package/dist/esm/src/sceneOperationsManager.js

@@ -0,0 +1,536 @@
+import { createClass as _createClass, objectSpread2 as _objectSpread2, classCallCheck as _classCallCheck, asyncToGenerator as _asyncToGenerator, regenerator as _regenerator } from '../_virtual/_rollupPluginBabelHelpers.js';
+import { findObjectByHardcodedUuid } from './nameUtils.js';
+
+/**
+ * SceneOperationsManager
+ * Handles scene loading, clearing, and object management operations
+ */
+
+var THREE;
+
+/**
+ * Dynamically import ThreeJS when in browser environment
+ */
+function importDependencies() {
+  return _importDependencies.apply(this, arguments);
+}
+function _importDependencies() {
+  _importDependencies = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee() {
+    var _t;
+    return _regenerator().w(function (_context) {
+      while (1) switch (_context.n) {
+        case 0:
+          if (!(typeof window !== 'undefined')) {
+            _context.n = 4;
+            break;
+          }
+          _context.p = 1;
+          _context.n = 2;
+          return import('three');
+        case 2:
+          THREE = _context.v;
+          _context.n = 4;
+          break;
+        case 3:
+          _context.p = 3;
+          _t = _context.v;
+          console.error('Failed to load Three.js:', _t);
+          throw new Error('SceneOperationsManager: Required dependencies could not be loaded');
+        case 4:
+          return _context.a(2);
+      }
+    }, _callee, null, [[1, 3]]);
+  }));
+  return _importDependencies.apply(this, arguments);
+}
+
+/**
+ * Class for managing scene operations like loading, clearing, and object management
+ */
+var SceneOperationsManager = /*#__PURE__*/function () {
+  /**
+   * Create a SceneOperationsManager
+   * @param {Object} component - The component with scene, camera, renderer, etc.
+   */
+  function SceneOperationsManager(component) {
+    _classCallCheck(this, SceneOperationsManager);
+    this.component = component;
+
+    // Initialize if in browser environment
+    if (typeof window !== 'undefined') {
+      importDependencies();
+    }
+  }
+
+  /**
+   * Clear scene objects while preserving base environment
+   */
+  return _createClass(SceneOperationsManager, [{
+    key: "clearSceneObjects",
+    value: function clearSceneObjects() {
+      var component = this.component;
+      console.log('🧹 Starting scene clear operation...');
+
+      // First, deselect any currently selected object
+      this.deselectObject();
+
+      // Store reference to transform controls to ensure it's not removed
+      var transformControlsRef = null;
+      if (component.transformManager && component.transformManager.transformControls) {
+        // Explicitly disable transform controls before clearing
+        console.log('🔧 Disabling transform controls before scene clear');
+        component.transformManager.setEnabled(false);
+        component.transformManager.transformControls.visible = false;
+        transformControlsRef = component.transformManager.transformControls;
+        console.log('🔧 Stored reference to existing transform controls');
+      }
+      var objectsToRemove = [];
+      var transformControlsFound = 0;
+      var totalChildren = 0;
+      component.scene.traverse(function (child) {
+        var _child$userData, _child$userData2, _child$userData3, _child$userData4, _child$geometry;
+        totalChildren++;
+
+        // Check for transform controls using multiple detection methods
+        var isTransformControl = child === transformControlsRef || ((_child$userData = child.userData) === null || _child$userData === void 0 ? void 0 : _child$userData.isTransformControls) || child.isTransformControls || child.type && child.type.includes('TransformControls');
+        if (isTransformControl) {
+          transformControlsFound++;
+          console.log('🔧 Found transform controls, preserving:', child.uuid);
+        }
+
+        // Remove imported scene objects but preserve base ground, walls, lights, and transform controls
+        if (child !== component.scene && !((_child$userData2 = child.userData) !== null && _child$userData2 !== void 0 && _child$userData2.isBrickWall) && !((_child$userData3 = child.userData) !== null && _child$userData3 !== void 0 && _child$userData3.isBaseGround) && !((_child$userData4 = child.userData) !== null && _child$userData4 !== void 0 && _child$userData4.isBaseGrid) && !isTransformControl && !child.isLight && ((_child$geometry = child.geometry) === null || _child$geometry === void 0 ? void 0 : _child$geometry.type) !== 'PlaneGeometry') {
+          objectsToRemove.push(child);
+        }
+      });
+      console.log("\uD83D\uDCCA Scene analysis: ".concat(totalChildren, " total children, ").concat(transformControlsFound, " transform controls found, ").concat(objectsToRemove.length, " objects to remove"));
+      objectsToRemove.forEach(function (obj) {
+        component.scene.remove(obj);
+
+        // Dispose of geometry and materials to prevent memory leaks
+        if (obj.geometry) obj.geometry.dispose();
+        if (obj.material) {
+          if (Array.isArray(obj.material)) {
+            obj.material.forEach(function (mat) {
+              return mat.dispose();
+            });
+          } else {
+            obj.material.dispose();
+          }
+        }
+      });
+
+      // Clear any references to removed objects
+      component.selectedObjectForTransform = null;
+      if (component.transformHistory) {
+        component.transformHistory = [];
+      }
+
+      // Make sure transform controls exist after clearing
+      if (!component.transformManager || !component.transformManager.transformControls) {
+        console.log('🔧 Transform controls missing after scene clear, reinitializing...');
+        if (typeof component.initTransformControls === 'function') {
+          component.initTransformControls();
+        }
+      }
+
+      // Ensure transform controls are still properly attached after scene operations
+      this.ensureTransformControlsAttached(false);
+      console.log('✅ Scene clear operation completed');
+    }
+
+    /**
+     * Ensure transform controls remain properly attached after scene operations
+     * @param {boolean} attachToSelected - Whether to attach to selected object
+     */
+  }, {
+    key: "ensureTransformControlsAttached",
+    value: function ensureTransformControlsAttached() {
+      var attachToSelected = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
+      var component = this.component;
+      if (component.transformManager) {
+        // Re-enable transform controls after scene operations
+        component.transformManager.setEnabled(true);
+
+        // Reattach to selected object if one exists and flag is true
+        if (attachToSelected && component.selectedObjectForTransform) {
+          component.transformManager.selectObject(component.selectedObjectForTransform);
+        }
+      }
+    }
+
+    /**
+     * Deselect any selected object
+     */
+  }, {
+    key: "deselectObject",
+    value: function deselectObject() {
+      var component = this.component;
+      if (component.transformManager && component.selectedObjectForTransform) {
+        component.transformManager.deselectObject();
+        component.selectedObjectForTransform = null;
+      }
+    }
+
+    /**
+     * Load scene data from JSON
+     * @param {Object|string} sceneData - Scene data object or JSON string
+     */
+  }, {
+    key: "loadSceneData",
+    value: function loadSceneData(sceneData) {
+      var component = this.component;
+      console.log('📥 Starting scene load operation...');
+
+      // Parse JSON if string provided
+      var parsedData = sceneData;
+      if (typeof sceneData === 'string') {
+        try {
+          parsedData = JSON.parse(sceneData);
+        } catch (e) {
+          console.error('❌ Failed to parse scene data:', e);
+          return false;
+        }
+      }
+
+      // Validate scene data format
+      if (!parsedData || !parsedData.scene || !parsedData.scene.object) {
+        console.error('❌ Invalid scene data format');
+        return false;
+      }
+
+      // Store reference to scene data
+      component.currentSceneData = parsedData;
+
+      // Clear existing scene objects
+      this.clearSceneObjects();
+
+      // Load scene objects
+      this._loadSceneObjects(parsedData.scene.object);
+
+      // Load connections if applicable
+      if (parsedData.connections && Array.isArray(parsedData.connections)) {
+        this._loadConnections(parsedData.connections);
+      }
+      console.log('✅ Scene load completed');
+      return true;
+    }
+
+    /**
+     * Load scene objects from parsed scene data
+     * @param {Object} sceneObject - The root scene object from parsed data
+     * @private
+     */
+  }, {
+    key: "_loadSceneObjects",
+    value: function _loadSceneObjects(sceneObject) {
+      var _this = this;
+      var component = this.component;
+
+      // Recursively process all object children
+      if (sceneObject.children && Array.isArray(sceneObject.children)) {
+        sceneObject.children.forEach(function (childData) {
+          var childObject = _this._createObjectFromData(childData);
+          if (childObject) {
+            component.scene.add(childObject);
+          }
+        });
+      }
+    }
+
+    /**
+     * Create a Three.js object from object data
+     * @param {Object} objectData - The object data from parsed scene
+     * @returns {THREE.Object3D} The created object or null if invalid
+     * @private
+     */
+  }, {
+    key: "_createObjectFromData",
+    value: function _createObjectFromData(objectData) {
+      var _this2 = this;
+      // Ensure THREE is loaded
+      if (!THREE) {
+        console.warn('⚠️ THREE.js not loaded, cannot create objects');
+        return null;
+      }
+
+      // Create base object
+      var object = new THREE.Object3D();
+
+      // Set UUID (use hardcoded UUID if possible)
+      if (objectData.uuid) {
+        object.uuid = objectData.uuid;
+      }
+
+      // Set name
+      object.name = objectData.name || 'Unnamed';
+
+      // Set position
+      if (objectData.position) {
+        object.position.set(objectData.position.x || 0, objectData.position.y || 0, objectData.position.z || 0);
+      }
+
+      // Set rotation (convert from degrees to radians)
+      if (objectData.rotation) {
+        object.rotation.set((objectData.rotation.x || 0) * (Math.PI / 180), (objectData.rotation.y || 0) * (Math.PI / 180), (objectData.rotation.z || 0) * (Math.PI / 180));
+      }
+
+      // Set scale
+      if (objectData.scale) {
+        object.scale.set(objectData.scale.x || 1, objectData.scale.y || 1, objectData.scale.z || 1);
+      }
+
+      // Set userData
+      if (objectData.userData) {
+        object.userData = _objectSpread2({}, objectData.userData);
+      }
+
+      // Special handling for different object types
+      this._setupObjectByType(object, objectData);
+
+      // Process children recursively
+      if (objectData.children && Array.isArray(objectData.children)) {
+        objectData.children.forEach(function (childData) {
+          var childObject = _this2._createObjectFromData(childData);
+          if (childObject) {
+            object.add(childObject);
+          }
+        });
+      }
+      return object;
+    }
+
+    /**
+     * Set up object properties based on type
+     * @param {THREE.Object3D} object - The object to set up
+     * @param {Object} objectData - The object data
+     * @private
+     */
+  }, {
+    key: "_setupObjectByType",
+    value: function _setupObjectByType(object, objectData) {
+      var _objectData$userData, _objectData$userData2;
+      // Handle library component objects
+      if ((_objectData$userData = objectData.userData) !== null && _objectData$userData !== void 0 && _objectData$userData.componentType && (_objectData$userData2 = objectData.userData) !== null && _objectData$userData2 !== void 0 && _objectData$userData2.libraryId) {
+        // If model preloader is available, attempt to load model
+        if (this.component.modelPreloader) {
+          this.component.modelPreloader.loadComponentById(objectData.userData.libraryId, function (model) {
+            if (model) {
+              // Copy model but preserve our object's transform and userData
+              var position = object.position.clone();
+              var rotation = object.rotation.clone();
+              var scale = object.scale.clone();
+              var userData = _objectSpread2({}, object.userData);
+
+              // Copy model properties to our object
+              object.copy(model);
+
+              // Restore transform and userData
+              object.position.copy(position);
+              object.rotation.copy(rotation);
+              object.scale.copy(scale);
+              object.userData = userData;
+              console.log("\u2705 Loaded model for ".concat(objectData.name, " (").concat(objectData.userData.libraryId, ")"));
+            }
+          });
+        }
+      }
+
+      // Handle primitive geometry
+      if (objectData.geometry) {
+        var geometry;
+
+        // Create appropriate geometry based on type hint
+        if (objectData.geometry === 'CONNECTOR-GEO') {
+          geometry = new THREE.SphereGeometry(0.5, 16, 16);
+        } else if (objectData.geometry === 'GATEWAY-GEO') {
+          geometry = new THREE.CylinderGeometry(0.5, 0.5, 1, 16);
+        } else {
+          // Default to box geometry for other types
+          geometry = new THREE.BoxGeometry(1, 1, 1);
+        }
+
+        // Create mesh with geometry and basic material
+        var material = new THREE.MeshStandardMaterial({
+          color: 0x999999,
+          transparent: true,
+          opacity: 0.7
+        });
+        var mesh = new THREE.Mesh(geometry, material);
+
+        // Copy transform from parent
+        mesh.position.copy(object.position);
+        mesh.rotation.copy(object.rotation);
+        mesh.scale.copy(object.scale);
+
+        // Reset parent transform since the mesh now has it
+        object.position.set(0, 0, 0);
+        object.rotation.set(0, 0, 0);
+        object.scale.set(1, 1, 1);
+
+        // Add mesh as child of parent
+        object.add(mesh);
+      }
+    }
+
+    /**
+     * Load connections from scene data
+     * @param {Array} connections - Array of connection objects
+     * @private
+     */
+  }, {
+    key: "_loadConnections",
+    value: function _loadConnections(connections) {
+      var component = this.component;
+      if (!component.pathfindingManager) {
+        console.warn('⚠️ Cannot load connections: pathfindingManager not available');
+        return;
+      }
+
+      // Clear existing connections
+      if (component.pathfindingManager.clearAllPaths) {
+        component.pathfindingManager.clearAllPaths();
+      }
+
+      // Process each connection
+      connections.forEach(function (connection) {
+        if (!connection.source || !connection.target) {
+          return;
+        }
+
+        // Find source and target objects
+        var sourceObj = findObjectByHardcodedUuid(component.scene, connection.source);
+        var targetObj = findObjectByHardcodedUuid(component.scene, connection.target);
+        if (sourceObj && targetObj) {
+          // Create connection if objects found
+          component.pathfindingManager.createConnection(sourceObj, targetObj, connection.type || 'default');
+        } else {
+          console.warn("\u26A0\uFE0F Could not create connection: objects not found (".concat(connection.source, " -> ").concat(connection.target, ")"));
+        }
+      });
+    }
+
+    /**
+     * Find object in scene by name
+     * @param {string} name - The name to search for
+     * @returns {THREE.Object3D|null} The found object or null
+     */
+  }, {
+    key: "findObjectByName",
+    value: function findObjectByName(name) {
+      if (!name || !this.component.scene) {
+        return null;
+      }
+      var foundObject = null;
+      this.component.scene.traverse(function (child) {
+        if (child.name === name) {
+          foundObject = child;
+        }
+      });
+      return foundObject;
+    }
+
+    /**
+     * Find object in scene by UUID
+     * @param {string} uuid - The UUID to search for
+     * @returns {THREE.Object3D|null} The found object or null
+     */
+  }, {
+    key: "findObjectByUuid",
+    value: function findObjectByUuid(uuid) {
+      if (!uuid || !this.component.scene) {
+        return null;
+      }
+      var foundObject = null;
+      this.component.scene.traverse(function (child) {
+        if (child.uuid === uuid) {
+          foundObject = child;
+        }
+      });
+      return foundObject;
+    }
+
+    /**
+     * Remove an object from the scene
+     * @param {THREE.Object3D} object - The object to remove
+     */
+  }, {
+    key: "removeObject",
+    value: function removeObject(object) {
+      if (!object || !this.component.scene) {
+        return false;
+      }
+
+      // Deselect if this is the selected object
+      if (this.component.selectedObjectForTransform === object) {
+        this.deselectObject();
+      }
+
+      // Remove from scene
+      this.component.scene.remove(object);
+
+      // Dispose resources
+      if (object.geometry) object.geometry.dispose();
+      if (object.material) {
+        if (Array.isArray(object.material)) {
+          object.material.forEach(function (mat) {
+            return mat.dispose();
+          });
+        } else {
+          object.material.dispose();
+        }
+      }
+      return true;
+    }
+
+    /**
+     * Duplicate an object in the scene
+     * @param {THREE.Object3D} sourceObject - The object to duplicate
+     * @param {Object} [options] - Options for duplication
+     * @param {THREE.Vector3} [options.positionOffset] - Position offset for the duplicate
+     * @returns {THREE.Object3D|null} The duplicated object or null if failed
+     */
+  }, {
+    key: "duplicateObject",
+    value: function duplicateObject(sourceObject) {
+      var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+      if (!sourceObject || !this.component.scene) {
+        return null;
+      }
+
+      // Create clone of source object
+      var clonedObject = sourceObject.clone();
+
+      // Generate new UUID to ensure uniqueness
+      clonedObject.uuid = THREE.MathUtils.generateUUID();
+
+      // Update name to indicate it's a copy
+      if (!clonedObject.name.includes('_copy')) {
+        clonedObject.name = "".concat(clonedObject.name, "_copy");
+      }
+
+      // Apply position offset if specified
+      if (options.positionOffset) {
+        clonedObject.position.add(options.positionOffset);
+      } else {
+        // Default offset if none provided
+        clonedObject.position.x += 2;
+      }
+
+      // Add to scene
+      this.component.scene.add(clonedObject);
+      return clonedObject;
+    }
+  }]);
+}();
+
+/**
+ * Factory function to get SceneOperationsManager instance
+ * @param {CentralPlantComponent} component - The component instance 
+ * @returns {SceneOperationsManager} SceneOperationsManager instance
+ */
+function getSceneOperationsManager(component) {
+  return new SceneOperationsManager(component);
+}
+
+export { SceneOperationsManager, SceneOperationsManager as default, getSceneOperationsManager };

package/dist/esm/src/textureConfig.js

@@ -0,0 +1,168 @@
+import { asyncToGenerator as _asyncToGenerator, regenerator as _regenerator, objectSpread2 as _objectSpread2 } from '../_virtual/_rollupPluginBabelHelpers.js';
+import * as THREE from 'three';
+
+var TEXTURE_SETS = {
+  // Light metallic texture using the gravel_embedded_concrete with metallic properties
+  light_metal: {
+    path: 'https://central-plant-assets.s3.us-east-1.amazonaws.com/textures/gravel_embedded_concrete_1k',
+    files: {
+      diffuse: 'diffuse.jpg',
+      normal: 'normal.jpg',
+      roughness: 'rough.jpg'
+    },
+    repeat: {
+      x: 2,
+      y: 2
+    },
+    // Moderate tiling for surface detail
+    materialProps: {
+      color: 0xb8b8b8,
+      // Light metallic base color
+      metalness: 0.3,
+      roughness: 0.3,
+      normalScale: [0.4, 0.4],
+      // Subtle surface detail
+      clearcoat: 0.3,
+      clearcoatRoughness: 0.2,
+      envMapIntensity: 1.6,
+      reflectivity: 0.5
+    }
+  },
+  brick: {
+    path: 'https://central-plant-assets.s3.us-east-1.amazonaws.com/textures/pavement_03_1k',
+    files: {
+      diffuse: 'diffuse.jpg',
+      normal: 'normal.jpg',
+      roughness: 'rough.jpg'
+    },
+    repeat: {
+      x: 7.5,
+      y: 0.75
+    },
+    // Adjust for proper brick scale
+    materialProps: {
+      color: 0x998888,
+      roughness: 0.9,
+      metalness: 0.1,
+      normalScale: [1.5, 1.5],
+      bumpScale: 0.05,
+      clearcoat: 0.05,
+      clearcoatRoughness: 0.4
+    }
+  },
+  gravel_embedded_concrete: {
+    path: 'https://central-plant-assets.s3.us-east-1.amazonaws.com/textures/gravel_embedded_concrete_1k',
+    files: {
+      diffuse: 'diffuse.jpg',
+      normal: 'normal.jpg',
+      roughness: 'rough.jpg'
+    },
+    repeat: {
+      x: 3,
+      y: 3
+    },
+    materialProps: {
+      color: 0xffffff,
+      roughness: 0.9,
+      metalness: 0.1,
+      normalScale: [1.0, 1.0],
+      bumpScale: 0.1
+    }
+  }
+};
+
+/**
+ * Create a Three.js texture with appropriate settings
+ */
+function createTexture(textureLoader, url) {
+  var repeat = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {
+    x: 1,
+    y: 1
+  };
+  if (!textureLoader) {
+    textureLoader = new THREE.TextureLoader();
+  }
+  try {
+    var texture = textureLoader.load(url);
+    texture.wrapS = THREE.RepeatWrapping;
+    texture.wrapT = THREE.RepeatWrapping;
+    texture.repeat.set(repeat.x, repeat.y);
+    texture.colorSpace = THREE.SRGBColorSpace;
+    return texture;
+  } catch (error) {
+    console.error("Failed to load texture: ".concat(url), error);
+    return null;
+  }
+}
+
+/**
+ * Load a texture set and create a material
+ */
+function loadTextureSetAndCreateMaterial(_x, _x2) {
+  return _loadTextureSetAndCreateMaterial.apply(this, arguments);
+}
+function _loadTextureSetAndCreateMaterial() {
+  _loadTextureSetAndCreateMaterial = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee(component, textureSetName) {
+    var textureSet, textureLoader, repeat, loadedTextures, loadTexture, material;
+    return _regenerator().w(function (_context) {
+      while (1) switch (_context.n) {
+        case 0:
+          if (component) {
+            _context.n = 1;
+            break;
+          }
+          console.warn('Component is required for texture loading');
+          return _context.a(2, new THREE.MeshStandardMaterial({
+            color: 0xaaaaaa
+          }));
+        case 1:
+          textureSet = TEXTURE_SETS[textureSetName];
+          if (textureSet) {
+            _context.n = 2;
+            break;
+          }
+          console.warn("Texture set not found: ".concat(textureSetName));
+          return _context.a(2, new THREE.MeshStandardMaterial({
+            color: 0xaaaaaa
+          }));
+        case 2:
+          textureLoader = component.textureLoader || new THREE.TextureLoader();
+          repeat = textureSet.repeat || {
+            x: 1,
+            y: 1
+          };
+          loadedTextures = {}; // Function to load a specific texture from the set
+          loadTexture = function loadTexture(type) {
+            if (!textureSet.files[type]) return null;
+            var url = "".concat(textureSet.path, "/").concat(textureSet.files[type]);
+            return createTexture(textureLoader, url, repeat);
+          }; // Load all textures in the set
+          Object.keys(textureSet.files).forEach(function (type) {
+            loadedTextures[type] = loadTexture(type);
+          });
+
+          // Create material with textures and properties
+          material = new THREE.MeshStandardMaterial(_objectSpread2({
+            map: loadedTextures.diffuse,
+            normalMap: loadedTextures.normal,
+            roughnessMap: loadedTextures.roughness,
+            metalnessMap: loadedTextures.metalness,
+            aoMap: loadedTextures.ao,
+            displacementMap: loadedTextures.displacement
+          }, textureSet.materialProps)); // Add the environment map if available from the component
+          if (component.scene && component.scene.environment) {
+            material.envMap = component.scene.environment;
+          }
+          return _context.a(2, material);
+      }
+    }, _callee);
+  }));
+  return _loadTextureSetAndCreateMaterial.apply(this, arguments);
+}
+var textureConfig = {
+  TEXTURE_SETS: TEXTURE_SETS,
+  createTexture: createTexture,
+  loadTextureSetAndCreateMaterial: loadTextureSetAndCreateMaterial
+};
+
+export { TEXTURE_SETS, createTexture, textureConfig as default, loadTextureSetAndCreateMaterial };