@2112-lab/central-plant 0.1.13 → 0.1.15

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

@@ -2,6 +2,7 @@ import { createClass as _createClass, typeof as _typeof, classCallCheck as _clas
 import * as THREE from 'three';
 import { GLTFLoader } from '../../node_modules/three/examples/jsm/loaders/GLTFLoader.js';
 import { OBJLoader } from '../../node_modules/three/examples/jsm/loaders/OBJLoader.js';
+import ObjProcessor from './objProcessor.js';
 
 var ModelPreloader = /*#__PURE__*/function () {
   function ModelPreloader() {
@@ -10,10 +11,12 @@ var ModelPreloader = /*#__PURE__*/function () {
     this.loadingPromises = new Map(); // Track ongoing loads to prevent duplicates
     this.gltfLoader = new GLTFLoader();
     this.objLoader = new OBJLoader();
+    this.objProcessor = new ObjProcessor(); // Initialize OBJ processor
     this.isPreloading = false;
     this.preloadingPromise = null;
     this.componentDictionary = null;
     console.log('🚀 ModelPreloader initialized with GLB and OBJ support');
+    console.log('🔧 OBJ Processor integrated for indexed BufferGeometry conversion');
   }
 
   /**
@@ -119,93 +122,110 @@ var ModelPreloader = /*#__PURE__*/function () {
   }, {
     key: "preloadSingleModel",
     value: (function () {
-      var _preloadSingleModel = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee2(modelKey) {
+      var _preloadSingleModel = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee3(modelKey) {
         var _this2 = this;
         var modelType,
           loadPromise,
-          _args2 = arguments;
-        return _regenerator().w(function (_context2) {
-          while (1) switch (_context2.n) {
+          _args3 = arguments;
+        return _regenerator().w(function (_context3) {
+          while (1) switch (_context3.n) {
             case 0:
-              modelType = _args2.length > 1 && _args2[1] !== undefined ? _args2[1] : 'glb';
+              modelType = _args3.length > 1 && _args3[1] !== undefined ? _args3[1] : 'glb';
               if (!this.modelCache.has(modelKey)) {
-                _context2.n = 1;
+                _context3.n = 1;
                 break;
               }
               console.log("\uD83C\uDFAF Model ".concat(modelKey, " already cached, skipping"));
-              return _context2.a(2, this.modelCache.get(modelKey));
+              return _context3.a(2, this.modelCache.get(modelKey));
             case 1:
               if (!this.loadingPromises.has(modelKey)) {
-                _context2.n = 2;
+                _context3.n = 2;
                 break;
               }
               console.log("\u23F3 Model ".concat(modelKey, " already loading, waiting for completion"));
-              return _context2.a(2, this.loadingPromises.get(modelKey));
+              return _context3.a(2, this.loadingPromises.get(modelKey));
             case 2:
               console.log("\uD83D\uDD04 Starting preload of ".concat(modelType.toUpperCase(), " model: ").concat(modelKey));
               loadPromise = new Promise(function (resolve, reject) {
                 var modelPath = "/library/models/".concat(modelKey);
                 if (modelType === 'obj') {
-                  // Load OBJ model
-                  _this2.objLoader.load(modelPath, function (object) {
-                    console.log("\u2705 Successfully preloaded OBJ model: ".concat(modelKey));
-
-                    // Apply double-sided materials to OBJ models with both solid and wireframe
-                    object.traverse(function (child) {
-                      if (child.isMesh) {
-                        // Create a solid material first
-                        var solidMaterial = new THREE.MeshStandardMaterial({
-                          color: child.material.color || 0x888888,
-                          side: THREE.DoubleSide,
-                          wireframe: false
-                        });
-
-                        // Set the solid material
-                        child.material = solidMaterial;
-
-                        // Create wireframe overlay by cloning the geometry
-                        var wireframeGeometry = child.geometry.clone();
-                        var wireframeMaterial = new THREE.MeshBasicMaterial({
-                          color: 0x000000,
-                          wireframe: true,
-                          transparent: true,
-                          opacity: 0.8
-                        });
-
-                        // Create wireframe mesh with same geometry
-                        var wireframeMesh = new THREE.Mesh(wireframeGeometry, wireframeMaterial);
-                        wireframeMesh.name = child.name + '_wireframe';
-
-                        // Position wireframe slightly forward to avoid z-fighting
-                        wireframeMesh.position.copy(child.position);
-                        wireframeMesh.rotation.copy(child.rotation);
-                        wireframeMesh.scale.copy(child.scale);
-                        wireframeMesh.scale.multiplyScalar(1.001); // Slightly larger to sit on top
-
-                        // Add wireframe as sibling to the parent
-                        if (child.parent) {
-                          child.parent.add(wireframeMesh);
+                  // Load OBJ model with advanced processing
+                  _this2.objLoader.load(modelPath, /*#__PURE__*/function () {
+                    var _ref = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee2(object) {
+                      var processedResult, modelData, _t;
+                      return _regenerator().w(function (_context2) {
+                        while (1) switch (_context2.n) {
+                          case 0:
+                            _context2.p = 0;
+                            console.log("\u2705 Successfully loaded OBJ model: ".concat(modelKey));
+
+                            // Process OBJ with the new processor for indexed BufferGeometry
+                            _context2.n = 1;
+                            return _this2.objProcessor.processObjObject(object, modelKey, true);
+                          case 1:
+                            processedResult = _context2.v;
+                            if (!processedResult) {
+                              _context2.n = 2;
+                              break;
+                            }
+                            console.log("\uD83D\uDD27 OBJ processed to indexed BufferGeometry: ".concat(modelKey));
+                            console.log("\uD83D\uDCCA Geometry stats:", processedResult.stats);
+
+                            // Apply double-sided materials to original OBJ for compatibility
+                            object.traverse(function (child) {
+                              if (child.isMesh) {
+                                var solidMaterial = new THREE.MeshStandardMaterial({
+                                  color: child.material.color || 0x888888,
+                                  side: THREE.DoubleSide,
+                                  wireframe: false
+                                });
+                                child.material = solidMaterial;
+                              }
+                            });
+
+                            // Store both the original object and processed data
+                            modelData = {
+                              originalObject: object,
+                              processedGeometry: processedResult.geometry,
+                              geometryStats: processedResult.stats,
+                              materials: processedResult.materials,
+                              isObjModel: true
+                            }; // Cache the model data
+                            _this2.modelCache.set(modelKey, modelData);
+                            _this2.loadingPromises.delete(modelKey);
+                            resolve(modelData);
+                            _context2.n = 3;
+                            break;
+                          case 2:
+                            throw new Error('Failed to process OBJ to indexed geometry');
+                          case 3:
+                            _context2.n = 5;
+                            break;
+                          case 4:
+                            _context2.p = 4;
+                            _t = _context2.v;
+                            console.error("\u274C Error processing OBJ model ".concat(modelKey, ":"), _t);
+                            // Fallback: cache the original object without processing
+                            _this2.modelCache.set(modelKey, object);
+                            _this2.loadingPromises.delete(modelKey);
+                            resolve(object);
+                          case 5:
+                            return _context2.a(2);
                         }
-                      }
-                    });
-
-                    // Cache the object for future use
-                    _this2.modelCache.set(modelKey, object);
-                    // Remove from loading promises
-                    _this2.loadingPromises.delete(modelKey);
-                    resolve(object);
-                  }, function (progress) {
-                    // Optional: track loading progress
+                      }, _callee2, null, [[0, 4]]);
+                    }));
+                    return function (_x3) {
+                      return _ref.apply(this, arguments);
+                    };
+                  }(), function (progress) {
                     if (progress.lengthComputable) {
                       var percentage = progress.loaded / progress.total * 100;
                       if (percentage % 25 === 0) {
-                        // Log every 25%
                         console.log("\uD83D\uDCCA Loading OBJ ".concat(modelKey, ": ").concat(percentage.toFixed(0), "%"));
                       }
                     }
                   }, function (error) {
                     console.error("\u274C Failed to preload OBJ model ".concat(modelKey, ":"), error);
-                    // Remove from loading promises
                     _this2.loadingPromises.delete(modelKey);
                     reject(error);
                   });
@@ -236,9 +256,9 @@ var ModelPreloader = /*#__PURE__*/function () {
                 }
               }); // Cache the loading promise
               this.loadingPromises.set(modelKey, loadPromise);
-              return _context2.a(2, loadPromise);
+              return _context3.a(2, loadPromise);
           }
-        }, _callee2, this);
+        }, _callee3, this);
       }));
       function preloadSingleModel(_x2) {
         return _preloadSingleModel.apply(this, arguments);
@@ -248,18 +268,42 @@ var ModelPreloader = /*#__PURE__*/function () {
     /**
      * Get a cached model (cloned for use)
      * @param {string} modelKey - The model key
+     * @param {boolean} useIndexedGeometry - Whether to use indexed geometry for OBJ models
      * @returns {THREE.Object3D|null} Cloned model or null if not found
      */
     )
   }, {
     key: "getCachedModel",
     value: function getCachedModel(modelKey) {
+      var useIndexedGeometry = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
       if (this.modelCache.has(modelKey)) {
         console.log("\uD83C\uDFAF Returning cached model: ".concat(modelKey));
-        var clonedModel = this.modelCache.get(modelKey).clone();
+        var cachedData = this.modelCache.get(modelKey);
+
+        // Handle OBJ models with processed geometry
+        if (cachedData && cachedData.isObjModel && useIndexedGeometry && cachedData.processedGeometry) {
+          console.log("\uD83D\uDD27 Using indexed BufferGeometry for OBJ: ".concat(modelKey));
+
+          // Create a mesh from the processed indexed geometry
+          var mesh = new THREE.Mesh(cachedData.processedGeometry.clone(), cachedData.materials.clone());
+
+          // Add metadata
+          mesh.userData.modelKey = modelKey;
+          mesh.userData.geometryStats = cachedData.geometryStats;
+          mesh.userData.isIndexedGeometry = true;
+          mesh.userData.originalSizeKB = cachedData.geometryStats.sizeKB;
+          return mesh;
+        }
+
+        // Handle regular models or OBJ models without indexed geometry
+        var modelToClone = cachedData.isObjModel ? cachedData.originalObject : cachedData;
+        var clonedModel = modelToClone.clone();
 
-        // Determine model type from the modelKey extension
-        modelKey.toLowerCase().endsWith('.obj') ? 'obj' : 'glb';
+        // Add OBJ stats if available
+        if (cachedData.isObjModel && cachedData.geometryStats) {
+          clonedModel.userData.geometryStats = cachedData.geometryStats;
+          clonedModel.userData.isObjModel = true;
+        }
         return clonedModel;
       }
       console.warn("\u26A0\uFE0F Model ".concat(modelKey, " not found in cache"));
@@ -367,41 +411,41 @@ var ModelPreloader = /*#__PURE__*/function () {
   }, {
     key: "reloadModel",
     value: (function () {
-      var _reloadModel = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee3(modelKey) {
+      var _reloadModel = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee4(modelKey) {
         var modelType,
           _i,
           _Object$keys,
           componentType,
           component,
-          _args3 = arguments;
-        return _regenerator().w(function (_context3) {
-          while (1) switch (_context3.n) {
+          _args4 = arguments;
+        return _regenerator().w(function (_context4) {
+          while (1) switch (_context4.n) {
             case 0:
-              modelType = _args3.length > 1 && _args3[1] !== undefined ? _args3[1] : null;
+              modelType = _args4.length > 1 && _args4[1] !== undefined ? _args4[1] : null;
               console.log("\uD83D\uDD04 Force reloading model: ".concat(modelKey));
 
               // Try to determine model type from component dictionary if not provided
               if (!(!modelType && this.componentDictionary)) {
-                _context3.n = 3;
+                _context4.n = 3;
                 break;
               }
               _i = 0, _Object$keys = Object.keys(this.componentDictionary);
             case 1:
               if (!(_i < _Object$keys.length)) {
-                _context3.n = 3;
+                _context4.n = 3;
                 break;
               }
               componentType = _Object$keys[_i];
               component = this.componentDictionary[componentType];
               if (!(component && component.modelKey === modelKey)) {
-                _context3.n = 2;
+                _context4.n = 2;
                 break;
               }
               modelType = component.modelType || 'glb';
-              return _context3.a(3, 3);
+              return _context4.a(3, 3);
             case 2:
               _i++;
-              _context3.n = 1;
+              _context4.n = 1;
               break;
             case 3:
               // Default to GLB if still not determined
@@ -412,11 +456,11 @@ var ModelPreloader = /*#__PURE__*/function () {
               this.loadingPromises.delete(modelKey);
 
               // Preload again
-              return _context3.a(2, this.preloadSingleModel(modelKey, modelType));
+              return _context4.a(2, this.preloadSingleModel(modelKey, modelType));
           }
-        }, _callee3, this);
+        }, _callee4, this);
       }));
-      function reloadModel(_x3) {
+      function reloadModel(_x4) {
         return _reloadModel.apply(this, arguments);
       }
       return reloadModel;
@@ -433,7 +477,42 @@ var ModelPreloader = /*#__PURE__*/function () {
       // 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) {
+        if (model && model.isObjModel) {
+          // Handle OBJ model data structure
+          if (model.originalObject && model.originalObject.traverse) {
+            model.originalObject.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();
+                }
+              }
+            });
+          }
+
+          // Dispose processed geometry
+          if (model.processedGeometry) {
+            model.processedGeometry.dispose();
+          }
+
+          // Dispose materials
+          if (model.materials) {
+            if (Array.isArray(model.materials)) {
+              model.materials.forEach(function (material) {
+                return material.dispose();
+              });
+            } else {
+              model.materials.dispose();
+            }
+          }
+        } else if (model && model.traverse) {
+          // Handle regular model
           model.traverse(function (child) {
             if (child.geometry) {
               child.geometry.dispose();
@@ -454,6 +533,9 @@ var ModelPreloader = /*#__PURE__*/function () {
       this.loadingPromises.clear();
       this.isPreloading = false;
       this.preloadingPromise = null;
+
+      // Clear OBJ processor caches
+      this.objProcessor.clearCaches();
       console.log('✅ Model preloader cache cleared');
     }
 
@@ -562,13 +644,15 @@ var ModelPreloader = /*#__PURE__*/function () {
         totalModels: this.modelCache.size,
         loadingModels: this.loadingPromises.size,
         isPreloading: this.isPreloading,
-        memoryUsage: 0
+        memoryUsage: 0,
+        objProcessorStats: this.objProcessor.getStatus()
       };
 
       // Estimate memory usage (rough calculation)
       this.modelCache.forEach(function (model) {
         if (model && model.traverse) {
-          model.traverse(function (child) {
+          var modelToAnalyze = model.isObjModel ? model.originalObject : model;
+          modelToAnalyze.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
@@ -578,6 +662,82 @@ var ModelPreloader = /*#__PURE__*/function () {
       });
       return stats;
     }
+
+    /**
+     * Get all OBJ geometry statistics
+     * @returns {Array} Array of OBJ geometry statistics
+     */
+  }, {
+    key: "getObjGeometryStats",
+    value: function getObjGeometryStats() {
+      return this.objProcessor.getAllGeometryStats();
+    }
+
+    /**
+     * Get OBJ processor memory usage
+     * @returns {Object} Memory usage statistics
+     */
+  }, {
+    key: "getObjMemoryUsage",
+    value: function getObjMemoryUsage() {
+      return this.objProcessor.getMemoryUsage();
+    }
+
+    /**
+     * Create a custom mesh from indexed OBJ geometry
+     * @param {string} modelKey - The model key (must be an OBJ)
+     * @param {THREE.Material} material - Optional material to use
+     * @returns {THREE.Mesh|null} The created mesh or null if not found
+     */
+  }, {
+    key: "createCustomObjMesh",
+    value: function createCustomObjMesh(modelKey) {
+      var material = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+      return this.objProcessor.createCustomMesh(modelKey, material);
+    }
+
+    /**
+     * Get indexed geometry directly from processor
+     * @param {string} modelKey - The model key
+     * @returns {THREE.BufferGeometry|null} The indexed geometry or null
+     */
+  }, {
+    key: "getIndexedGeometry",
+    value: function getIndexedGeometry(modelKey) {
+      var result = this.objProcessor.indexedGeometryCache.get(modelKey);
+      return result ? result.geometry.clone() : null;
+    }
+
+    /**
+     * Force reload and reprocess an OBJ model
+     * @param {string} modelKey - The model key to reload
+     * @returns {Promise} Promise that resolves with the reloaded model
+     */
+  }, {
+    key: "reloadObjModel",
+    value: (function () {
+      var _reloadObjModel = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee5(modelKey) {
+        return _regenerator().w(function (_context5) {
+          while (1) switch (_context5.n) {
+            case 0:
+              console.log("\uD83D\uDD04 Force reloading OBJ model: ".concat(modelKey));
+
+              // Clear from both caches
+              this.modelCache.delete(modelKey);
+              this.loadingPromises.delete(modelKey);
+              this.objProcessor.indexedGeometryCache.delete(modelKey);
+              this.objProcessor.geometrySizeCache.delete(modelKey);
+
+              // Reload with OBJ processing
+              return _context5.a(2, this.preloadSingleModel(modelKey, 'obj'));
+          }
+        }, _callee5, this);
+      }));
+      function reloadObjModel(_x5) {
+        return _reloadObjModel.apply(this, arguments);
+      }
+      return reloadObjModel;
+    }())
   }]);
 }(); // Create singleton instance
 var modelPreloader = new ModelPreloader();