@2112-lab/central-plant 0.1.0 → 0.1.2

package/dist/esm/src/pathfindingManager.js

@@ -1,21 +1,20 @@
-import { createClass as _createClass, classCallCheck as _classCallCheck, asyncToGenerator as _asyncToGenerator, regenerator as _regenerator } from '../_virtual/_rollupPluginBabelHelpers.js';
+import { createClass as _createClass, objectSpread2 as _objectSpread2, construct as _construct, toConsumableArray as _toConsumableArray, classCallCheck as _classCallCheck, createForOfIteratorHelper as _createForOfIteratorHelper, asyncToGenerator as _asyncToGenerator, regenerator as _regenerator } from '../_virtual/_rollupPluginBabelHelpers.js';
 import * as THREE from 'three';
-import Pathfinder from './Pathfinder.js';
-import { pathfinderLogger } from './debugLogger.js';
+import { Pathfinder } from '../node_modules/@2112-lab/pathfinder/dist/index.esm.js';
+import { logger, pathfinderLogger } from './debugLogger.js';
+import { generateUuidFromName } from './nameUtils.js';
 
 var PathfindingManager = /*#__PURE__*/function () {
   function PathfindingManager(component) {
     _classCallCheck(this, PathfindingManager);
     this.component = component;
+    this.pathfinder = null;
     this.crosscubeTextureSet = null;
     this.pathfinderVersionInfo = null;
-
-    // Initialize pathfinder
-    this.pathfinder = new Pathfinder(component === null || component === void 0 ? void 0 : component.sceneData);
   }
 
-  /**
-   * Get pathfinder version information
+  /**
+   * Get pathfinder version information
    */
   return _createClass(PathfindingManager, [{
     key: "getPathfinderVersionInfo",
@@ -46,8 +45,8 @@ var PathfindingManager = /*#__PURE__*/function () {
       }
       return getPathfinderVersionInfo;
     }()
-    /**
-     * Log pathfinder version information
+    /**
+     * Log pathfinder version information
      */
     )
   }, {
@@ -90,8 +89,8 @@ var PathfindingManager = /*#__PURE__*/function () {
       }
       return logPathfinderVersion;
     }()
-    /**
-     * Get path colors for visual distinction
+    /**
+     * Get path colors for visual distinction
      */
     )
   }, {
@@ -101,8 +100,8 @@ var PathfindingManager = /*#__PURE__*/function () {
       return colors[index % colors.length];
     }
 
-    /**
-     * Initialize pathfinder and create paths
+    /**
+     * Initialize pathfinder and create paths
      */
   }, {
     key: "initializePathfinder",
@@ -113,41 +112,27 @@ var PathfindingManager = /*#__PURE__*/function () {
         return _regenerator().w(function (_context3) {
           while (1) switch (_context3.n) {
             case 0:
-              if (Pathfinder) {
-                _context3.n = 1;
-                break;
-              }
-              _context3.n = 1;
-              return importPathfinder();
-            case 1:
               component = this.component;
               this.crosscubeTextureSet = crosscubeTextureSet;
 
               // Log pathfinder version information
-              _context3.n = 2;
+              _context3.n = 1;
               return this.logPathfinderVersion('Scene Loading');
-            case 2:
+            case 1:
               this.pathfinder = new Pathfinder(data);
-              if (component) component.pathfinder = this.pathfinder;
+              component.pathfinder = this.pathfinder;
 
               // Add debugging for pathfinder input
               console.log('🔍 PATHFINDER DEBUGGING:');
               console.log('🔗 Connections:', data.connections);
               console.log('🏗️ Scene structure:', JSON.parse(JSON.stringify((_data$scene = data.scene) === null || _data$scene === void 0 ? void 0 : _data$scene.object)));
-
-              // Ensure connections exist before finding paths
-              if (!(!data.connections || !Array.isArray(data.connections))) {
-                _context3.n = 3;
-                break;
-              }
-              console.warn('⚠️ No connections found in scene data, skipping path finding');
-              return _context3.a(2, []);
-            case 3:
               paths = this.pathfinder.findPaths();
               console.log('Found paths:', paths);
 
               // Create pipe paths with materials
-              return _context3.a(2, this.createPipePaths(paths, crosscubeTextureSet));
+              this.createPipePaths(paths, crosscubeTextureSet);
+            case 2:
+              return _context3.a(2);
           }
         }, _callee3, this);
       }));
@@ -156,140 +141,339 @@ var PathfindingManager = /*#__PURE__*/function () {
       }
       return initializePathfinder;
     }()
-    /**
-     * Remove all existing paths from the scene
+    /**
+       /**
+     * Remove all existing paths from the scene
      */
     )
   }, {
     key: "removeAllPaths",
     value: function removeAllPaths() {
       var component = this.component;
-      if (!component || !component.scene) {
-        return;
-      }
       console.log("removeAllPaths started");
       var objectsToRemove = [];
-
-      // Find all path objects in the scene
-      component.scene.traverse(function (child) {
-        if (child.userData && child.userData.isPathObject) {
-          objectsToRemove.push(child);
+      component.scene.traverse(function (obj) {
+        // Check the name property instead of uuid, as UUIDs are auto-generated
+        if (obj.name && obj.name.includes("Polyline")) {
+          console.log("removeAllPaths ".concat(obj.name, " (uuid: ").concat(obj.uuid, ") found"));
+          objectsToRemove.push(obj);
         }
       });
-
-      // Remove all found path objects
-      objectsToRemove.forEach(function (object) {
-        object.parent.remove(object);
-
-        // Dispose of geometries and materials
-        if (object.geometry) {
-          object.geometry.dispose();
-        }
-        if (object.material) {
-          if (Array.isArray(object.material)) {
-            object.material.forEach(function (material) {
-              return material.dispose();
+      for (var _i = 0, _objectsToRemove = objectsToRemove; _i < _objectsToRemove.length; _i++) {
+        var obj = _objectsToRemove[_i];
+        component.scene.remove(obj);
+        if (obj.geometry) obj.geometry.dispose();
+        if (obj.material) {
+          if (Array.isArray(obj.material)) {
+            obj.material.forEach(function (mat) {
+              return mat.dispose();
             });
           } else {
-            object.material.dispose();
+            obj.material.dispose();
           }
         }
-      });
-      console.log("Removed ".concat(objectsToRemove.length, " path objects"));
+      }
+      console.log("\u2705 Removed ".concat(objectsToRemove.length, " polyline objects from scene"));
     }
 
-    /**
-     * Material factory function to reduce duplication
+    /**
+     * Material factory function to reduce duplication
      */
   }, {
     key: "createPipeMaterial",
     value: function createPipeMaterial(crosscubeTextureSet, pathIndex) {
-      var color = this.getPathColor(pathIndex);
-      var material = new THREE.MeshStandardMaterial({
-        color: new THREE.Color(color),
-        roughness: 0.3,
-        metalness: 0.8,
-        envMap: crosscubeTextureSet ? crosscubeTextureSet.envMap : null
-      });
-      return material;
+      if (crosscubeTextureSet) {
+        var materialProps = _objectSpread2(_objectSpread2({}, crosscubeTextureSet.config.materialProps), {}, {
+          color: this.getPathColor(pathIndex),
+          map: crosscubeTextureSet.textures.diffuse,
+          normalMap: crosscubeTextureSet.textures.normal,
+          roughnessMap: crosscubeTextureSet.textures.roughness,
+          metalness: 0.2,
+          roughness: 0.9,
+          clearcoat: 0.2,
+          clearcoatRoughness: 0.2,
+          envMapIntensity: 0.6,
+          reflectivity: 0.4
+        });
+
+        // Handle normalScale conversion to Vector2
+        if (materialProps.normalScale && Array.isArray(materialProps.normalScale)) {
+          materialProps.normalScale = _construct(THREE.Vector2, _toConsumableArray(materialProps.normalScale));
+        }
+        var material = new THREE.MeshPhysicalMaterial(materialProps);
+
+        // Configure texture wrapping and repeat
+        var pipeTextures = [material.map, material.normalMap, material.roughnessMap].filter(Boolean);
+        pipeTextures.forEach(function (texture) {
+          texture.wrapS = texture.wrapT = THREE.RepeatWrapping;
+          texture.repeat.set(crosscubeTextureSet.config.repeat.x * 2, crosscubeTextureSet.config.repeat.y * 2);
+        });
+        return material;
+      } else {
+        return new THREE.MeshPhysicalMaterial({
+          color: this.getPathColor(pathIndex),
+          metalness: 0.9,
+          roughness: 0.7,
+          clearcoat: 0.1,
+          clearcoatRoughness: 0.3,
+          envMapIntensity: 1.5,
+          reflectivity: 0.3
+        });
+      }
     }
 
-    /**
-     * Helper function to create pipe paths
+    /**
+     * Helper function to create pipe paths
      */
   }, {
     key: "createPipePaths",
     value: function createPipePaths(paths, crosscubeTextureSet) {
       var _this = this;
       var component = this.component;
-      if (!component || !component.scene) {
-        console.warn('Cannot create pipe paths: component or scene not available');
-        return [];
-      }
+      paths.forEach(function (pathData, index) {
+        if (pathData.path) {
+          var polyline = new THREE.Object3D();
+          polyline.name = "Polyline ".concat(pathData.from, "-").concat(pathData.to);
+          var pipeRadius = 0.1;
+          var pipeMaterial = _this.createPipeMaterial(crosscubeTextureSet, index);
+          for (var j = 0; j < pathData.path.length - 1; j++) {
+            var start = pathData.path[j];
+            var end = pathData.path[j + 1];
+            var direction = new THREE.Vector3().subVectors(end, start);
+            var length = direction.length();
+            var cylinderGeometry = new THREE.CylinderGeometry(pipeRadius, pipeRadius, length, 8, 1, false);
+            var cylinder = new THREE.Mesh(cylinderGeometry, pipeMaterial);
+            cylinder.position.copy(start).add(end).multiplyScalar(0.5);
+            var quaternion = new THREE.Quaternion();
+            var up = new THREE.Vector3(0, 1, 0);
+            quaternion.setFromUnitVectors(up, direction.normalize());
+            cylinder.quaternion.copy(quaternion);
+            cylinder.castShadow = true;
+            cylinder.receiveShadow = true;
+            polyline.add(cylinder);
 
-      // Remove existing paths before creating new ones
-      this.removeAllPaths();
-      var pipeObjects = [];
-      paths.forEach(function (path, pathIndex) {
-        if (!path || !path.points || path.points.length < 2) {
-          console.warn('Invalid path data, skipping:', path);
-          return;
+            // Add junction spheres at 90-degree turns
+            if (j < pathData.path.length - 2) {
+              var nextStart = pathData.path[j + 1];
+              var nextEnd = pathData.path[j + 2];
+              var currentDir = direction.normalize();
+              var nextDir = new THREE.Vector3().subVectors(nextEnd, nextStart).normalize();
+              var angle = Math.acos(currentDir.dot(nextDir));
+              if (Math.abs(angle - Math.PI / 2) < 0.1) {
+                var sphereGeometry = new THREE.SphereGeometry(pipeRadius, 16, 16);
+                var sphere = new THREE.Mesh(sphereGeometry, pipeMaterial);
+                sphere.position.copy(end);
+                sphere.castShadow = true;
+                sphere.receiveShadow = true;
+                polyline.add(sphere);
+              }
+            }
+          }
+          polyline.name = "Polyline";
+          component.scene.add(polyline);
         }
-        try {
-          var material = _this.createPipeMaterial(crosscubeTextureSet, pathIndex);
+      });
+    }
 
-          // Create a path from the points
-          var points = path.points.map(function (point) {
-            return new THREE.Vector3(point.x, point.y, point.z);
-          });
-          var curve = new THREE.CatmullRomCurve3(points);
+    /**
+     * Recompute world bounding boxes after transforms
+     */
+  }, {
+    key: "recomputeWorldBoundingBoxes",
+    value: function recomputeWorldBoundingBoxes(currentSceneData) {
+      var component = this.component;
+      component.scene.traverse(function (object) {
+        if (object.isMesh) {
+          // Find the corresponding JSON object
+          var jsonObject = null;
+          var _findJsonObject = function findJsonObject(children) {
+            var _iterator = _createForOfIteratorHelper(children),
+              _step;
+            try {
+              for (_iterator.s(); !(_step = _iterator.n()).done;) {
+                var _object$userData, _child$userData;
+                var child = _step.value;
+                // Enhanced matching logic with hardcoded UUID priority
+
+                // Strategy 1: Direct hardcoded UUID match (HIGHEST PRIORITY)
+                if (child.uuid === object.uuid || child.uuid === ((_object$userData = object.userData) === null || _object$userData === void 0 ? void 0 : _object$userData.originalUuid) || object.uuid === ((_child$userData = child.userData) === null || _child$userData === void 0 ? void 0 : _child$userData.originalUuid)) {
+                  return child;
+                }
 
-          // Create the pipe geometry
-          var pipeRadius = 0.15;
-          var radialSegments = 8;
-          var tubularSegments = points.length * 3;
-          var geometry = new THREE.TubeGeometry(curve, tubularSegments, pipeRadius, radialSegments, false);
+                // Strategy 2: Name-based UUID match (FALLBACK)
+                if (object.name && child.name) {
+                  var objectGeneratedUuid = generateUuidFromName(object.name);
+                  var childGeneratedUuid = generateUuidFromName(child.name);
+                  if (objectGeneratedUuid === childGeneratedUuid || objectGeneratedUuid === child.uuid || childGeneratedUuid === object.uuid) {
+                    return child;
+                  }
+                }
 
-          // Create the mesh
-          var pipe = new THREE.Mesh(geometry, material);
+                // Strategy 3: Name match
+                if (object.name && child.name && object.name === child.name) {
+                  return child;
+                }
 
-          // Add metadata
-          pipe.userData = {
-            isPathObject: true,
-            pathIndex: pathIndex,
-            connectionId: path.connectionId,
-            startComponentId: path.startComponentId,
-            endComponentId: path.endComponentId
+                // Recursively search children
+                if (child.children) {
+                  console.log("child children found in:", child);
+                  var found = _findJsonObject(child.children);
+                  if (found) return found;
+                }
+              }
+            } catch (err) {
+              _iterator.e(err);
+            } finally {
+              _iterator.f();
+            }
+            return null;
           };
+          jsonObject = _findJsonObject(currentSceneData.scene.object.children);
+          if (jsonObject) {
+            // Compute world bounding box
+            var boundingBox = new THREE.Box3().setFromObject(object);
 
-          // Add to scene
-          component.scene.add(pipe);
-          pipeObjects.push(pipe);
-        } catch (error) {
-          console.error('Error creating pipe for path:', path, error);
+            // Store in JSON userData for pathfinder
+            if (!jsonObject.userData) jsonObject.userData = {};
+            jsonObject.userData.worldBoundingBox = {
+              min: boundingBox.min.toArray(),
+              max: boundingBox.max.toArray()
+            };
+            console.log("Added world bounding box for ".concat(jsonObject.name, ":"), jsonObject.userData.worldBoundingBox);
+          }
         }
       });
-      return pipeObjects;
     }
-  }]);
-}();
+    /**
+     * Update pathfinding with new connections data
+     */
+  }, {
+    key: "updatePathfindingWithConnections",
+    value: (function () {
+      var _updatePathfindingWithConnections = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee4(newConnections) {
+        var _component$currentSce, _component$currentSce2, _component$currentSce3, _updatedSceneData$sce;
+        var component, updatedSceneData, paths;
+        return _regenerator().w(function (_context4) {
+          while (1) switch (_context4.n) {
+            case 0:
+              component = this.component; // Check if we have current scene data to work with
+              if (component.currentSceneData) {
+                _context4.n = 1;
+                break;
+              }
+              console.warn('⚠️ No current scene data available for pathfinder update');
+              return _context4.a(2, false);
+            case 1:
+              // Remove all existing paths from the scene
+              this.removeAllPaths();
+              console.log('🔄 Updating pathfinder with new connections:', newConnections);
+              console.log('🔍 Current scene data structure:', {
+                hasConnections: !!component.currentSceneData.connections,
+                connectionsCount: ((_component$currentSce = component.currentSceneData.connections) === null || _component$currentSce === void 0 ? void 0 : _component$currentSce.length) || 0,
+                hasScene: !!component.currentSceneData.scene,
+                hasSceneObject: !!((_component$currentSce2 = component.currentSceneData.scene) !== null && _component$currentSce2 !== void 0 && _component$currentSce2.object),
+                childrenCount: ((_component$currentSce3 = component.currentSceneData.scene) === null || _component$currentSce3 === void 0 || (_component$currentSce3 = _component$currentSce3.object) === null || _component$currentSce3 === void 0 || (_component$currentSce3 = _component$currentSce3.children) === null || _component$currentSce3 === void 0 ? void 0 : _component$currentSce3.length) || 0
+              });
 
-// Create a singleton instance
-var pathfindingManager = null;
+              // Create a deep copy of the current scene data to avoid mutations
+              updatedSceneData = JSON.parse(JSON.stringify(component.currentSceneData)); // Update the connections in the copied scene data
+              updatedSceneData.connections = _toConsumableArray(newConnections);
+              console.log('🔍 Updated scene data for pathfinder:', {
+                connectionsCount: updatedSceneData.connections.length,
+                connections: updatedSceneData.connections,
+                hasScene: !!updatedSceneData.scene,
+                childrenCount: ((_updatedSceneData$sce = updatedSceneData.scene) === null || _updatedSceneData$sce === void 0 || (_updatedSceneData$sce = _updatedSceneData$sce.object) === null || _updatedSceneData$sce === void 0 || (_updatedSceneData$sce = _updatedSceneData$sce.children) === null || _updatedSceneData$sce === void 0 ? void 0 : _updatedSceneData$sce.length) || 0
+              });
 
-/**
- * Get the global pathfinding manager instance
- */
-function getPathfindingManager() {
-  var component = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
-  if (!pathfindingManager || component && pathfindingManager.component !== component) {
-    pathfindingManager = new PathfindingManager(component);
-  }
-  return pathfindingManager;
-}
-var pathfindingManager$1 = {
-  PathfindingManager: PathfindingManager,
-  getPathfindingManager: getPathfindingManager
-};
+              // Log pathfinder version for connection updates
+              _context4.n = 2;
+              return this.logPathfinderVersion('Connections Update');
+            case 2:
+              // Create new pathfinder instance with updated data
+              this.pathfinder = new Pathfinder(updatedSceneData);
+              component.pathfinder = this.pathfinder;
+
+              // Find new paths with updated connections
+              paths = this.pathfinder.findPaths();
+              console.log('🔍 Found paths with updated connections:', {
+                pathCount: paths.length,
+                paths: paths.map(function (p) {
+                  var _p$path;
+                  return {
+                    from: p.from,
+                    to: p.to,
+                    hasPath: !!p.path,
+                    pathLength: ((_p$path = p.path) === null || _p$path === void 0 ? void 0 : _p$path.length) || 0
+                  };
+                })
+              });
+
+              // Create pipe paths with materials
+              this.createPipePaths(paths, this.crosscubeTextureSet);
+
+              // Update the component's current scene data to reflect the changes
+              component.currentSceneData = updatedSceneData;
+              console.log('✅ Pathfinding updated successfully with new connections');
+              return _context4.a(2, true);
+          }
+        }, _callee4, this);
+      }));
+      function updatePathfindingWithConnections(_x3) {
+        return _updatePathfindingWithConnections.apply(this, arguments);
+      }
+      return updatePathfindingWithConnections;
+    }()
+    /**
+     * Update pathfinding after object transforms
+     */
+    )
+  }, {
+    key: "updatePathfindingAfterTransform",
+    value: (function () {
+      var _updatePathfindingAfterTransform = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee5(currentSceneData) {
+        var paths;
+        return _regenerator().w(function (_context5) {
+          while (1) switch (_context5.n) {
+            case 0:
+              // Remove all existing paths from the scene
+              this.removeAllPaths();
+              console.log('🔄 Starting pathfinding with updated scene data...');
+
+              // Log pathfinder version for transform updates
+              _context5.n = 1;
+              return this.logPathfinderVersion('Transform Update');
+            case 1:
+              this.pathfinder = new Pathfinder(currentSceneData);
+              this.component.pathfinder = this.pathfinder;
+              paths = this.pathfinder.findPaths();
+              console.log('Found paths:', paths);
+
+              // Create pipe paths with materials
+              this.createPipePaths(paths, this.crosscubeTextureSet);
+            case 2:
+              return _context5.a(2);
+          }
+        }, _callee5, this);
+      }));
+      function updatePathfindingAfterTransform(_x4) {
+        return _updatePathfindingAfterTransform.apply(this, arguments);
+      }
+      return updatePathfindingAfterTransform;
+    }()
+    /**
+     * Dispose of pathfinding resources
+     */
+    )
+  }, {
+    key: "dispose",
+    value: function dispose() {
+      this.removeAllPaths();
+      this.pathfinder = null;
+      this.crosscubeTextureSet = null;
+      this.pathfinderVersionInfo = null;
+      logger.info('PathfindingManager disposed');
+    }
+  }]);
+}();
 
-export { PathfindingManager, pathfindingManager$1 as default, getPathfindingManager };
+export { PathfindingManager };