@2112-lab/central-plant 0.1.4 → 0.1.6

package/dist/esm/src/rendering/modelPreloader.js

@@ -1 +1,364 @@
-import{createClass as t,classCallCheck as e,asyncToGenerator as i,regenerator as n,typeof as r}from"../../_virtual/_rollupPluginBabelHelpers.js";import"three";import{GLTFLoader as s}from"../../node_modules/three/examples/jsm/loaders/GLTFLoader.js";var o=function(){return t(function t(){e(this,t),this.modelCache=new Map,this.loadingPromises=new Map,this.gltfLoader=new s,this.isPreloading=!1,this.preloadingPromise=null,this.componentDictionary=null},[{key:"preloadAllModels",value:(a=i(n().m(function t(e){var i,s,o=this;return n().w(function(t){for(;;)switch(t.n){case 0:if(!this.isPreloading){t.n=1;break}return t.a(2,this.preloadingPromise);case 1:if(e&&"object"===r(e)){t.n=2;break}return t.a(2,Promise.reject(new Error("Invalid component dictionary")));case 2:return this.componentDictionary=e,this.isPreloading=!0,i=[],s=[],Object.keys(e).forEach(function(t){var n=e[t];n&&n.modelKey&&(i.includes(n.modelKey)||i.push(n.modelKey))}),i.forEach(function(t){s.push(o.preloadSingleModel(t))}),this.preloadingPromise=Promise.allSettled(s).then(function(t){var e=t.filter(function(t){return"fulfilled"===t.status}).length,n=t.filter(function(t){return"rejected"===t.status}).length;return o.isPreloading=!1,{successful:e,failed:n,total:i.length,cache:o.modelCache}}),t.a(2,this.preloadingPromise)}},t,this)})),function(t){return a.apply(this,arguments)})},{key:"preloadSingleModel",value:(u=i(n().m(function t(e){var i,r=this;return n().w(function(t){for(;;)switch(t.n){case 0:if(!this.modelCache.has(e)){t.n=1;break}return t.a(2,this.modelCache.get(e));case 1:if(!this.loadingPromises.has(e)){t.n=2;break}return t.a(2,this.loadingPromises.get(e));case 2:return i=new Promise(function(t,i){r.gltfLoader.load("/library/models/".concat(e),function(i){r.modelCache.set(e,i.scene),r.loadingPromises.delete(e),t(i.scene)},function(t){t.loaded,t.total},function(t){r.loadingPromises.delete(e),i(t)})}),this.loadingPromises.set(e,i),t.a(2,i)}},t,this)})),function(t){return u.apply(this,arguments)})},{key:"getCachedModel",value:function(t){return this.modelCache.has(t)?this.modelCache.get(t).clone():null}},{key:"getCachedModelWithDimensions",value:function(t){var e=arguments.length>1&&void 0!==arguments[1]?arguments[1]:null;if(this.modelCache.has(t)){var i=this.modelCache.get(t).clone();if(e&&this.componentDictionary){var n=this.componentDictionary[e];n&&n.boundingBox&&(i.userData||(i.userData={}),i.userData.dimensions={x:n.boundingBox.x,y:n.boundingBox.y,z:n.boundingBox.z})}return i}return null}},{key:"addDimensionsToModel",value:function(t,e){if(!t||!e)return t;if(this.componentDictionary){var i=this.componentDictionary[e];i&&i.boundingBox&&(t.userData||(t.userData={}),t.userData.dimensions={x:i.boundingBox.x,y:i.boundingBox.y,z:i.boundingBox.z})}return t}},{key:"getStatus",value:function(){return{isPreloading:this.isPreloading,cachedModels:Array.from(this.modelCache.keys()),totalCached:this.modelCache.size,currentlyLoading:Array.from(this.loadingPromises.keys())}}},{key:"reloadModel",value:(o=i(n().m(function t(e){return n().w(function(t){for(;;)if(0===t.n)return this.modelCache.delete(e),this.loadingPromises.delete(e),t.a(2,this.preloadSingleModel(e))},t,this)})),function(t){return o.apply(this,arguments)})},{key:"clearCache",value:function(){this.modelCache.forEach(function(t,e){t&&t.traverse&&t.traverse(function(t){t.geometry&&t.geometry.dispose(),t.material&&(Array.isArray(t.material)?t.material.forEach(function(t){return t.dispose()}):t.material.dispose())})}),this.modelCache.clear(),this.loadingPromises.clear(),this.isPreloading=!1,this.preloadingPromise=null}},{key:"getCacheStats",value:function(){var t={totalModels:this.modelCache.size,loadingModels:this.loadingPromises.size,isPreloading:this.isPreloading,memoryUsage:0};return this.modelCache.forEach(function(e){e&&e.traverse&&e.traverse(function(e){var i;e.geometry&&(t.memoryUsage+=12*((null===(i=e.geometry.attributes.position)||void 0===i?void 0:i.count)||0))})}),t}}]);var o,u,a}(),u=new o;export{o as ModelPreloader,u as default};
+import { createClass as _createClass, classCallCheck as _classCallCheck, asyncToGenerator as _asyncToGenerator, regenerator as _regenerator, typeof as _typeof } from '../../_virtual/_rollupPluginBabelHelpers.js';
+import 'three';
+import { GLTFLoader } from '../../node_modules/three/examples/jsm/loaders/GLTFLoader.js';
+
+var ModelPreloader = /*#__PURE__*/function () {
+  function ModelPreloader() {
+    _classCallCheck(this, ModelPreloader);
+    this.modelCache = new Map(); // Cache for loaded GLB models
+    this.loadingPromises = new Map(); // Track ongoing loads to prevent duplicates
+    this.gltfLoader = new GLTFLoader();
+    this.isPreloading = false;
+    this.preloadingPromise = null;
+    this.componentDictionary = null;
+    console.log('🚀 ModelPreloader initialized');
+  }
+
+  /**
+   * Preload all models from the component dictionary
+   * @param {Object} componentDictionary - The component dictionary object
+   * @returns {Promise} Promise that resolves when all models are loaded
+   */
+  return _createClass(ModelPreloader, [{
+    key: "preloadAllModels",
+    value: (function () {
+      var _preloadAllModels = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee(componentDictionary) {
+        var _this = this;
+        var modelKeys, preloadPromises;
+        return _regenerator().w(function (_context) {
+          while (1) switch (_context.n) {
+            case 0:
+              if (!this.isPreloading) {
+                _context.n = 1;
+                break;
+              }
+              console.log('⏳ Preloading already in progress, returning existing promise');
+              return _context.a(2, this.preloadingPromise);
+            case 1:
+              if (!(!componentDictionary || _typeof(componentDictionary) !== 'object')) {
+                _context.n = 2;
+                break;
+              }
+              console.error('❌ Invalid component dictionary provided to preloader');
+              return _context.a(2, Promise.reject(new Error('Invalid component dictionary')));
+            case 2:
+              this.componentDictionary = componentDictionary;
+              this.isPreloading = true;
+              console.log('🔄 Starting to preload all models from component dictionary...');
+              modelKeys = [];
+              preloadPromises = []; // Extract all unique model keys from the component dictionary
+              Object.keys(componentDictionary).forEach(function (componentType) {
+                var component = componentDictionary[componentType];
+                if (component && component.modelKey) {
+                  if (!modelKeys.includes(component.modelKey)) {
+                    modelKeys.push(component.modelKey);
+                  }
+                }
+              });
+              console.log("\uD83C\uDFAF Found ".concat(modelKeys.length, " unique models to preload:"), modelKeys);
+
+              // Create preload promises for each model
+              modelKeys.forEach(function (modelKey) {
+                preloadPromises.push(_this.preloadSingleModel(modelKey));
+              });
+
+              // Wait for all models to load (or fail)
+              this.preloadingPromise = Promise.allSettled(preloadPromises).then(function (results) {
+                var successful = results.filter(function (result) {
+                  return result.status === 'fulfilled';
+                }).length;
+                var failed = results.filter(function (result) {
+                  return result.status === 'rejected';
+                }).length;
+                console.log("\u2705 Preloading completed: ".concat(successful, " successful, ").concat(failed, " failed"));
+                if (failed > 0) {
+                  console.warn('⚠️ Some models failed to preload:', results.filter(function (result) {
+                    return result.status === 'rejected';
+                  }).map(function (result) {
+                    return result.reason;
+                  }));
+                }
+                _this.isPreloading = false;
+                return {
+                  successful: successful,
+                  failed: failed,
+                  total: modelKeys.length,
+                  cache: _this.modelCache
+                };
+              });
+              return _context.a(2, this.preloadingPromise);
+          }
+        }, _callee, this);
+      }));
+      function preloadAllModels(_x) {
+        return _preloadAllModels.apply(this, arguments);
+      }
+      return preloadAllModels;
+    }()
+    /**
+     * Preload a single model
+     * @param {string} modelKey - The model key (filename)
+     * @returns {Promise} Promise that resolves with the loaded model
+     */
+    )
+  }, {
+    key: "preloadSingleModel",
+    value: (function () {
+      var _preloadSingleModel = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee2(modelKey) {
+        var _this2 = this;
+        var loadPromise;
+        return _regenerator().w(function (_context2) {
+          while (1) switch (_context2.n) {
+            case 0:
+              if (!this.modelCache.has(modelKey)) {
+                _context2.n = 1;
+                break;
+              }
+              console.log("\uD83C\uDFAF Model ".concat(modelKey, " already cached, skipping"));
+              return _context2.a(2, this.modelCache.get(modelKey));
+            case 1:
+              if (!this.loadingPromises.has(modelKey)) {
+                _context2.n = 2;
+                break;
+              }
+              console.log("\u23F3 Model ".concat(modelKey, " already loading, waiting for completion"));
+              return _context2.a(2, this.loadingPromises.get(modelKey));
+            case 2:
+              console.log("\uD83D\uDD04 Starting preload of model: ".concat(modelKey));
+              loadPromise = new Promise(function (resolve, reject) {
+                _this2.gltfLoader.load("/library/models/".concat(modelKey), function (gltf) {
+                  console.log("\u2705 Successfully preloaded model: ".concat(modelKey));
+                  // Cache the scene for future use
+                  _this2.modelCache.set(modelKey, gltf.scene);
+                  // Remove from loading promises
+                  _this2.loadingPromises.delete(modelKey);
+                  resolve(gltf.scene);
+                }, function (progress) {
+                  // Optional: track loading progress
+                  var percentage = progress.loaded / progress.total * 100;
+                  if (percentage % 25 === 0) {
+                    // Log every 25%
+                    console.log("\uD83D\uDCCA Loading ".concat(modelKey, ": ").concat(percentage.toFixed(0), "%"));
+                  }
+                }, function (error) {
+                  console.error("\u274C Failed to preload model ".concat(modelKey, ":"), error);
+                  // Remove from loading promises
+                  _this2.loadingPromises.delete(modelKey);
+                  reject(error);
+                });
+              }); // Cache the loading promise
+              this.loadingPromises.set(modelKey, loadPromise);
+              return _context2.a(2, loadPromise);
+          }
+        }, _callee2, this);
+      }));
+      function preloadSingleModel(_x2) {
+        return _preloadSingleModel.apply(this, arguments);
+      }
+      return preloadSingleModel;
+    }()
+    /**
+     * Get a cached model (cloned for use)
+     * @param {string} modelKey - The model key
+     * @returns {THREE.Object3D|null} Cloned model or null if not found
+     */
+    )
+  }, {
+    key: "getCachedModel",
+    value: function getCachedModel(modelKey) {
+      if (this.modelCache.has(modelKey)) {
+        console.log("\uD83C\uDFAF Returning cached model: ".concat(modelKey));
+        return this.modelCache.get(modelKey).clone();
+      }
+      console.warn("\u26A0\uFE0F Model ".concat(modelKey, " not found in cache"));
+      return null;
+    }
+
+    /**
+     * Get a cached model (cloned for use) with dimensions from component dictionary
+     * @param {string} modelKey - The model key
+     * @param {string} libraryId - The library ID to look up dimensions
+     * @returns {THREE.Object3D|null} Cloned model with dimensions or null if not found
+     */
+  }, {
+    key: "getCachedModelWithDimensions",
+    value: function getCachedModelWithDimensions(modelKey) {
+      var libraryId = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+      if (this.modelCache.has(modelKey)) {
+        console.log("\uD83C\uDFAF Returning cached model with dimensions: ".concat(modelKey));
+        var clonedModel = this.modelCache.get(modelKey).clone();
+
+        // Add dimensions from component dictionary if available
+        if (libraryId && this.componentDictionary) {
+          var componentData = this.componentDictionary[libraryId];
+          if (componentData && componentData.boundingBox) {
+            if (!clonedModel.userData) {
+              clonedModel.userData = {};
+            }
+
+            // Add dimensions to userData
+            clonedModel.userData.dimensions = {
+              x: componentData.boundingBox.x,
+              y: componentData.boundingBox.y,
+              z: componentData.boundingBox.z
+            };
+            console.log("\uD83D\uDCCF Added dimensions to model userData for ".concat(libraryId, ":"), clonedModel.userData.dimensions);
+          } else {
+            console.warn("\u26A0\uFE0F No bounding box found for ".concat(libraryId, " in component dictionary"));
+          }
+        } else {
+          console.warn("\u26A0\uFE0F No libraryId provided or component dictionary not available for dimensions lookup");
+        }
+        return clonedModel;
+      }
+      console.warn("\u26A0\uFE0F Model ".concat(modelKey, " not found in cache"));
+      return null;
+    }
+
+    /**
+     * Add dimensions to an existing model from component dictionary
+     * @param {THREE.Object3D} model - The model to add dimensions to
+     * @param {string} libraryId - The library ID to look up dimensions
+     * @returns {THREE.Object3D} The model with dimensions added
+     */
+  }, {
+    key: "addDimensionsToModel",
+    value: function addDimensionsToModel(model, libraryId) {
+      if (!model || !libraryId) {
+        console.warn("\u26A0\uFE0F Invalid model or libraryId provided for dimensions");
+        return model;
+      }
+      if (this.componentDictionary) {
+        var componentData = this.componentDictionary[libraryId];
+        if (componentData && componentData.boundingBox) {
+          if (!model.userData) {
+            model.userData = {};
+          }
+
+          // Add dimensions to userData
+          model.userData.dimensions = {
+            x: componentData.boundingBox.x,
+            y: componentData.boundingBox.y,
+            z: componentData.boundingBox.z
+          };
+          console.log("\uD83D\uDCCF Added dimensions to existing model userData for ".concat(libraryId, ":"), model.userData.dimensions);
+        } else {
+          console.warn("\u26A0\uFE0F No bounding box found for ".concat(libraryId, " in component dictionary"));
+        }
+      } else {
+        console.warn("\u26A0\uFE0F Component dictionary not available for dimensions lookup");
+      }
+      return model;
+    }
+
+    /**
+     * Get preloading status
+     * @returns {Object} Status object
+     */
+  }, {
+    key: "getStatus",
+    value: function getStatus() {
+      return {
+        isPreloading: this.isPreloading,
+        cachedModels: Array.from(this.modelCache.keys()),
+        totalCached: this.modelCache.size,
+        currentlyLoading: Array.from(this.loadingPromises.keys())
+      };
+    }
+
+    /**
+     * Force reload a specific model
+     * @param {string} modelKey - The model key to reload
+     * @returns {Promise} Promise that resolves with the reloaded model
+     */
+  }, {
+    key: "reloadModel",
+    value: (function () {
+      var _reloadModel = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee3(modelKey) {
+        return _regenerator().w(function (_context3) {
+          while (1) switch (_context3.n) {
+            case 0:
+              console.log("\uD83D\uDD04 Force reloading model: ".concat(modelKey));
+
+              // Remove from cache and loading promises
+              this.modelCache.delete(modelKey);
+              this.loadingPromises.delete(modelKey);
+
+              // Preload again
+              return _context3.a(2, this.preloadSingleModel(modelKey));
+          }
+        }, _callee3, this);
+      }));
+      function reloadModel(_x3) {
+        return _reloadModel.apply(this, arguments);
+      }
+      return reloadModel;
+    }()
+    /**
+     * Clear all cached models (for cleanup)
+     */
+    )
+  }, {
+    key: "clearCache",
+    value: function clearCache() {
+      console.log('🧹 Clearing model preloader cache...');
+
+      // Dispose of all cached models
+      this.modelCache.forEach(function (model, modelKey) {
+        console.log("\uD83D\uDDD1\uFE0F Disposing cached model: ".concat(modelKey));
+        if (model && model.traverse) {
+          model.traverse(function (child) {
+            if (child.geometry) {
+              child.geometry.dispose();
+            }
+            if (child.material) {
+              if (Array.isArray(child.material)) {
+                child.material.forEach(function (material) {
+                  return material.dispose();
+                });
+              } else {
+                child.material.dispose();
+              }
+            }
+          });
+        }
+      });
+      this.modelCache.clear();
+      this.loadingPromises.clear();
+      this.isPreloading = false;
+      this.preloadingPromise = null;
+      console.log('✅ Model preloader cache cleared');
+    }
+
+    /**
+     * Get cache statistics
+     * @returns {Object} Cache statistics
+     */
+  }, {
+    key: "getCacheStats",
+    value: function getCacheStats() {
+      var stats = {
+        totalModels: this.modelCache.size,
+        loadingModels: this.loadingPromises.size,
+        isPreloading: this.isPreloading,
+        memoryUsage: 0
+      };
+
+      // Estimate memory usage (rough calculation)
+      this.modelCache.forEach(function (model) {
+        if (model && model.traverse) {
+          model.traverse(function (child) {
+            if (child.geometry) {
+              var _child$geometry$attri;
+              stats.memoryUsage += (((_child$geometry$attri = child.geometry.attributes.position) === null || _child$geometry$attri === void 0 ? void 0 : _child$geometry$attri.count) || 0) * 12; // Rough estimate
+            }
+          });
+        }
+      });
+      return stats;
+    }
+  }]);
+}(); // Create singleton instance
+var modelPreloader = new ModelPreloader();
+
+export { ModelPreloader, modelPreloader as default };