@2112-lab/central-plant 0.1.39 → 0.1.41

package/dist/esm/src/managers/pathfinding/PathRenderingManager.js

@@ -0,0 +1,377 @@
+import { inherits as _inherits, createClass as _createClass, toConsumableArray as _toConsumableArray, objectSpread2 as _objectSpread2, construct as _construct, superPropGet as _superPropGet, classCallCheck as _classCallCheck, callSuper as _callSuper } from '../../../_virtual/_rollupPluginBabelHelpers.js';
+import * as THREE from 'three';
+import { BaseDisposable } from '../../core/baseDisposable.js';
+
+var PathRenderingManager = /*#__PURE__*/function (_BaseDisposable) {
+  function PathRenderingManager(sceneViewer) {
+    var _this;
+    _classCallCheck(this, PathRenderingManager);
+    _this = _callSuper(this, PathRenderingManager);
+    _this.sceneViewer = sceneViewer;
+
+    // Shared gateway resources to prevent memory leaks
+    _this._gatewayGeometry = new THREE.SphereGeometry(0.15, 16, 16);
+    _this._gatewayMaterial = new THREE.MeshStandardMaterial({
+      color: 0xFFFFFF,
+      roughness: 0.7,
+      metalness: 0.3,
+      emissive: 0
+    });
+    _this.registerDisposable(_this._gatewayGeometry, _this._gatewayMaterial);
+    return _this;
+  }
+
+  /**
+   * Get path colors for visual distinction
+   * @param {number} index - Path index
+   * @returns {string} Hex color string
+   */
+  _inherits(PathRenderingManager, _BaseDisposable);
+  return _createClass(PathRenderingManager, [{
+    key: "getPathColor",
+    value: function getPathColor(index) {
+      var colors = [
+      // '#468e49',
+      '#245e29'
+      // '#2e80d2',
+      // '#1d51a1'
+      ];
+      return colors[index % colors.length];
+    }
+
+    /**
+     * Create gateways in the scene from pathfinding results
+     * @param {Object} pathfindingResult - Result object from pathfinder containing gateways
+     */
+  }, {
+    key: "createGateways",
+    value: function createGateways(pathfindingResult) {
+      var _this2 = this;
+      pathfindingResult.gateways.forEach(function (gateway) {
+        if (!gateway.position) {
+          console.warn("\u26A0\uFE0F Gateway ".concat(gateway.id, " missing position, skipping creation"));
+          return;
+        }
+
+        // Check if gateway already exists in scene (prevent duplicates)
+        var existingGateway = _this2.sceneViewer.scene.getObjectByProperty('uuid', gateway.id);
+        if (existingGateway) {
+          console.log("\u2139\uFE0F Gateway ".concat(gateway.id, " already exists, skipping creation"));
+          return;
+        }
+
+        // Create gateway mesh using shared geometry and material
+        var gatewayMesh = new THREE.Mesh(_this2._gatewayGeometry, _this2._gatewayMaterial);
+
+        // Handle position format: pathfinder returns {x,y,z} object or [x,y,z] array
+        if (Array.isArray(gateway.position)) {
+          gatewayMesh.position.fromArray(gateway.position);
+        } else if (gateway.position.x !== undefined) {
+          gatewayMesh.position.set(gateway.position.x, gateway.position.y, gateway.position.z);
+        } else {
+          console.error("\u274C Invalid gateway position format for ".concat(gateway.id, ":"), gateway.position);
+          return;
+        }
+        gatewayMesh.uuid = gateway.id;
+
+        // Set userData to make gateways selectable
+        gatewayMesh.userData = {
+          objectType: 'gateway',
+          isDeclared: false,
+          gatewayId: gateway.id,
+          originalUuid: gateway.id,
+          // Deep copy connections to prevent mutations affecting pathfinder's internal state
+          connections: gateway.connections ? {
+            removed: gateway.connections.removed ? _toConsumableArray(gateway.connections.removed) : [],
+            added: gateway.connections.added ? _toConsumableArray(gateway.connections.added) : []
+          } : {
+            removed: [],
+            added: []
+          }
+        };
+
+        // Add to scene
+        _this2.sceneViewer.scene.add(gatewayMesh);
+        console.log("\uD83D\uDD27 Created gateway: ".concat(gateway.id, " at [").concat(gatewayMesh.position.x.toFixed(2), ", ").concat(gatewayMesh.position.y.toFixed(2), ", ").concat(gatewayMesh.position.z.toFixed(2), "]"));
+      });
+    }
+
+    /**
+     * Material factory function for pipe materials
+     * @param {Object} crosscubeTextureSet - Texture set for pipe materials
+     * @returns {THREE.Material} Pipe material
+     */
+  }, {
+    key: "createPipeMaterial",
+    value: function createPipeMaterial(crosscubeTextureSet) {
+      if (crosscubeTextureSet) {
+        var materialProps = _objectSpread2(_objectSpread2({}, crosscubeTextureSet.config.materialProps), {}, {
+          color: this.getPathColor(0),
+          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
+          // transparent: true,
+          // opacity: 0.75
+        });
+
+        // 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(0),
+          metalness: 0.9,
+          roughness: 0.7,
+          clearcoat: 0.1,
+          clearcoatRoughness: 0.3,
+          envMapIntensity: 1.5,
+          reflectivity: 0.3
+        });
+      }
+    }
+
+    /**
+     * Create pipe paths from pathfinding results
+     * @param {Array} paths - Array of path objects from pathfinder
+     * @param {Object} crosscubeTextureSet - Texture set for pipe materials
+     */
+  }, {
+    key: "createPipePaths",
+    value: function createPipePaths(paths, crosscubeTextureSet) {
+      var _this3 = this;
+      var sceneViewer = this.sceneViewer;
+      var globalSegmentIndex = 0; // Counter for globally unique segment indices
+
+      paths.forEach(function (pathData, index) {
+        if (pathData.path && pathData.path.length >= 2) {
+          var pipeRadius = 0.1;
+          var pipeMaterial = _this3.createPipeMaterial(crosscubeTextureSet);
+
+          // Convert path points to Vector3 objects for consistent handling
+          var pathPoints = pathData.path.map(function (point) {
+            if (point instanceof THREE.Vector3) {
+              return point.clone();
+            } else if (Array.isArray(point)) {
+              return new THREE.Vector3().fromArray(point);
+            } else if (point.x !== undefined && point.y !== undefined && point.z !== undefined) {
+              return new THREE.Vector3(point.x, point.y, point.z);
+            } else {
+              console.warn('Unknown point format in createPipePaths:', point);
+              return new THREE.Vector3(0, 0, 0);
+            }
+          });
+
+          // Create one cylinder per segment (after colinear optimization, this should be minimal segments)
+          for (var j = 0; j < pathPoints.length - 1; j++) {
+            var start = pathPoints[j];
+            var end = pathPoints[j + 1];
+            var direction = new THREE.Vector3().subVectors(end, start);
+            var length = direction.length();
+
+            // Skip zero-length segments
+            if (length < 1e-6) {
+              console.warn("Skipping zero-length segment in path ".concat(pathData.from, "-").concat(pathData.to));
+              continue;
+            }
+            var cylinderGeometry = new THREE.CylinderGeometry(pipeRadius, pipeRadius, length, 16, 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.clone().normalize());
+            cylinder.quaternion.copy(quaternion);
+            cylinder.castShadow = true;
+            cylinder.receiveShadow = true;
+
+            // Set UUID to SEGMENT-{globalSegmentIndex} format
+            cylinder.uuid = "SEGMENT-".concat(globalSegmentIndex);
+
+            // Make pipe segments selectable and add identifying data
+            var segmentId = cylinder.uuid;
+
+            // Add userData to make pipe segments selectable and for tooltip display
+            cylinder.userData = {
+              objectType: 'segment',
+              segmentId: segmentId,
+              segmentIndex: globalSegmentIndex,
+              pathFrom: pathData.from,
+              pathTo: pathData.to
+            };
+
+            // Increment global segment counter
+            globalSegmentIndex++;
+
+            // Add segment directly to scene instead of to polyline
+            sceneViewer.scene.add(cylinder);
+
+            // Add smooth elbow joints only at actual direction changes (not at every point)
+            _this3.createAndAddElbowIfNeeded(pathPoints, j, pipeRadius, pipeMaterial, pathData, index, sceneViewer.scene // Pass scene instead of polyline
+            );
+          }
+          console.log("\u2705 Created pipe path ".concat(pathData.from, "-").concat(pathData.to, " with ").concat(pathPoints.length - 1, " segments"));
+        }
+      });
+    }
+
+    /**
+     * Create and add elbow joint if there's a direction change at the current segment
+     * @param {Array<THREE.Vector3>} pathPoints - Array of path points
+     * @param {number} j - Current segment index
+     * @param {number} pipeRadius - Radius of the pipe
+     * @param {THREE.Material} pipeMaterial - Material for the elbow
+     * @param {Object} pathData - Path data object with from/to information
+     * @param {number} index - Path index for naming
+     * @param {THREE.Scene} scene - Scene object to add elbow to directly
+     */
+  }, {
+    key: "createAndAddElbowIfNeeded",
+    value: function createAndAddElbowIfNeeded(pathPoints, j, pipeRadius, pipeMaterial, pathData, index, scene) {
+      // Only check if there are at least 2 more points ahead
+      if (j >= pathPoints.length - 2) {
+        return;
+      }
+      var currentSegment = pathPoints[j + 1].clone().sub(pathPoints[j]).normalize();
+      var nextSegment = pathPoints[j + 2].clone().sub(pathPoints[j + 1]).normalize();
+
+      // Check if there's actually a direction change (not just continuing straight)
+      var angle = currentSegment.angleTo(nextSegment);
+      var minAngle = Math.PI / 36; // 5 degrees minimum for creating an elbow
+
+      if (angle <= minAngle) {
+        return; // No significant direction change
+      }
+      var elbowGeometry = this.createElbowGeometry(pathPoints[j], pathPoints[j + 1], pathPoints[j + 2], pipeRadius);
+      if (!elbowGeometry) {
+        return; // Failed to create geometry
+      }
+      var elbow = new THREE.Mesh(elbowGeometry, pipeMaterial);
+      elbow.castShadow = true;
+      elbow.receiveShadow = true;
+
+      // Make elbows selectable as well
+      var elbowId = "pipe-elbow-".concat(pathData.from, "-").concat(pathData.to, "-").concat(j);
+      elbow.uuid = "Pipe Elbow ".concat(j + 1, ": ").concat(pathData.from, "-").concat(pathData.to);
+
+      // Add userData for elbows too
+      elbow.userData = {
+        isPipeElbow: true,
+        elbowId: elbowId,
+        elbowIndex: j,
+        pathFrom: pathData.from,
+        pathTo: pathData.to,
+        angle: (angle * 180 / Math.PI).toFixed(1),
+        // Add component data for tooltips
+        component: {
+          type: 'PipeElbow',
+          attributes: {
+            angle: {
+              key: 'Bend Angle',
+              value: (angle * 180 / Math.PI).toFixed(1),
+              unit: '°'
+            }
+          }
+        }
+      };
+      scene.add(elbow);
+    }
+
+    /**
+     * Create smooth elbow geometry to connect two pipe segments (optimized for 90-degree angles)
+     * @param {THREE.Vector3} point1 - First point (before the joint)
+     * @param {THREE.Vector3} point2 - Joint point (center of the elbow)
+     * @param {THREE.Vector3} point3 - Third point (after the joint)
+     * @param {number} radius - Pipe radius
+     * @returns {THREE.BufferGeometry} Elbow geometry
+     */
+  }, {
+    key: "createElbowGeometry",
+    value: function createElbowGeometry(point1, point2, point3, radius) {
+      try {
+        // Fixed elbow radius for 90-degree bends (simplified)
+        var elbowRadius = radius * 3;
+
+        // Create a curve for the 90-degree elbow
+        var curve = this.createElbowCurve(point1, point2, point3, elbowRadius);
+
+        // Fixed tubular segments for 90-degree bends (quarter circle)
+        var tubularSegments = 12; // Good balance for smooth 90° curves
+        var radialSegments = 16;
+        var closed = false;
+        var elbowGeometry = new THREE.TubeGeometry(curve, tubularSegments, radius, radialSegments, closed);
+        return elbowGeometry;
+      } catch (error) {
+        console.warn('Failed to create elbow geometry:', error);
+        return null;
+      }
+    }
+
+    /**
+     * Create a smooth curve for the 90-degree elbow joint (simplified)
+     * @param {THREE.Vector3} point1 - First point
+     * @param {THREE.Vector3} point2 - Joint point
+     * @param {THREE.Vector3} point3 - Third point
+     * @param {number} elbowRadius - Radius of the elbow curve
+     * @returns {THREE.Curve} Curve for the elbow
+     */
+  }, {
+    key: "createElbowCurve",
+    value: function createElbowCurve(point1, point2, point3, elbowRadius) {
+      // Calculate direction vectors
+      var dir1 = point2.clone().sub(point1).normalize();
+      var dir2 = point3.clone().sub(point2).normalize();
+
+      // For 90-degree bends, we can use a simpler approach with a quarter circle
+      // The curve radius is proportional to the elbow radius
+      var curveRadius = elbowRadius * 0.001;
+
+      // Calculate the offset distance from the joint point
+      var offset = curveRadius;
+
+      // Calculate start and end points of the curve (offset from the joint)
+      var curveStart = point2.clone().sub(dir1.clone().multiplyScalar(offset));
+      var curveEnd = point2.clone().add(dir2.clone().multiplyScalar(offset));
+
+      // For a 90-degree bend, the control point is at the corner
+      // We can use a quadratic bezier curve for simplicity
+      var controlPoint = point2.clone();
+
+      // Create a quadratic bezier curve (simpler than cubic for 90° bends)
+      var curve = new THREE.QuadraticBezierCurve3(curveStart, controlPoint, curveEnd);
+      return curve;
+    }
+
+    /**
+     * Dispose of rendering resources
+     */
+  }, {
+    key: "dispose",
+    value: function dispose() {
+      console.log('🗑️ Disposing PathRenderingManager...');
+
+      // Call parent dispose to clean up registered resources (shared gateway geometry/material)
+      _superPropGet(PathRenderingManager, "dispose", this, 3)([]);
+
+      // Nullify properties
+      this.sceneViewer = null;
+      console.log('✅ PathRenderingManager disposed');
+    }
+  }]);
+}(BaseDisposable);
+
+export { PathRenderingManager };