@2112-lab/central-plant 0.1.13 → 0.1.15

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

@@ -0,0 +1,678 @@
+import { createClass as _createClass, classCallCheck as _classCallCheck, asyncToGenerator as _asyncToGenerator, regenerator as _regenerator } from '../../_virtual/_rollupPluginBabelHelpers.js';
+import * as THREE from 'three';
+import { mergeGeometries, mergeVertices } from '../../node_modules/three/examples/jsm/utils/BufferGeometryUtils.js';
+
+var ObjProcessor = /*#__PURE__*/function () {
+  function ObjProcessor() {
+    _classCallCheck(this, ObjProcessor);
+    this.indexedGeometryCache = new Map(); // Cache for indexed geometries
+    this.geometrySizeCache = new Map(); // Cache for geometry sizes
+    this.idbSupported = this.checkIndexedDBSupport();
+    this.dbName = 'CentralPlantGeometryDB';
+    this.dbVersion = 1;
+    this.storeName = 'indexedGeometries';
+    console.log('🔧 ObjProcessor initialized');
+    console.log("\uD83D\uDCE6 IndexedDB supported: ".concat(this.idbSupported));
+  }
+
+  /**
+   * Check if IndexedDB is supported
+   * @returns {boolean} True if IndexedDB is supported
+   */
+  return _createClass(ObjProcessor, [{
+    key: "checkIndexedDBSupport",
+    value: function checkIndexedDBSupport() {
+      if (typeof window === 'undefined') return false;
+      return 'indexedDB' in window && window.indexedDB !== null;
+    }
+
+    /**
+     * Initialize IndexedDB for geometry storage
+     * @returns {Promise<IDBDatabase>} Promise that resolves to the database
+     */
+  }, {
+    key: "initializeIDB",
+    value: (function () {
+      var _initializeIDB = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee() {
+        var _this = this;
+        return _regenerator().w(function (_context) {
+          while (1) switch (_context.n) {
+            case 0:
+              if (this.idbSupported) {
+                _context.n = 1;
+                break;
+              }
+              throw new Error('IndexedDB not supported');
+            case 1:
+              return _context.a(2, new Promise(function (resolve, reject) {
+                var request = indexedDB.open(_this.dbName, _this.dbVersion);
+                request.onerror = function () {
+                  console.error('❌ Failed to open IndexedDB');
+                  reject(request.error);
+                };
+                request.onsuccess = function () {
+                  console.log('✅ IndexedDB opened successfully');
+                  resolve(request.result);
+                };
+                request.onupgradeneeded = function (event) {
+                  console.log('🔄 Upgrading IndexedDB schema');
+                  var db = event.target.result;
+
+                  // Create object store for indexed geometries
+                  if (!db.objectStoreNames.contains(_this.storeName)) {
+                    var store = db.createObjectStore(_this.storeName, {
+                      keyPath: 'modelKey'
+                    });
+                    store.createIndex('modelType', 'modelType', {
+                      unique: false
+                    });
+                    store.createIndex('sizeKB', 'sizeKB', {
+                      unique: false
+                    });
+                    console.log('📦 Created geometry object store');
+                  }
+                };
+              }));
+          }
+        }, _callee, this);
+      }));
+      function initializeIDB() {
+        return _initializeIDB.apply(this, arguments);
+      }
+      return initializeIDB;
+    }()
+    /**
+     * Convert OBJ object to indexed BufferGeometry
+     * @param {THREE.Object3D} objObject - The loaded OBJ object from THREE.OBJLoader
+     * @param {string} modelKey - The model key for identification
+     * @returns {Object} Object containing indexed geometry and metadata
+     */
+    )
+  }, {
+    key: "objToIndexedBufferGeometry",
+    value: function objToIndexedBufferGeometry(objObject, modelKey) {
+      var _this2 = this;
+      console.log("\uD83D\uDD04 Converting OBJ to indexed BufferGeometry: ".concat(modelKey));
+      var geometries = [];
+      var materials = [];
+
+      // Traverse the OBJ object and collect all geometries
+      objObject.traverse(function (child) {
+        if (child.isMesh && child.geometry) {
+          // Clone the geometry to avoid modifying the original
+          var geometry = child.geometry.clone();
+
+          // Ensure the geometry has proper attributes
+          if (!geometry.attributes.position) {
+            console.warn("\u26A0\uFE0F Geometry missing position attribute: ".concat(modelKey));
+            return;
+          }
+
+          // Compute normals if missing
+          if (!geometry.attributes.normal) {
+            geometry.computeVertexNormals();
+            console.log("\uD83D\uDCD0 Computed normals for geometry: ".concat(modelKey));
+          }
+
+          // Compute UVs if missing (simple planar mapping)
+          if (!geometry.attributes.uv) {
+            _this2.computeSimpleUVs(geometry);
+            console.log("\uD83D\uDDFA\uFE0F Computed UVs for geometry: ".concat(modelKey));
+          }
+          geometries.push(geometry);
+          materials.push(child.material);
+        }
+      });
+      if (geometries.length === 0) {
+        console.warn("\u26A0\uFE0F No valid geometries found in OBJ: ".concat(modelKey));
+        return null;
+      }
+
+      // Merge all geometries into one
+      var mergedGeometry;
+      if (geometries.length === 1) {
+        mergedGeometry = geometries[0];
+      } else {
+        console.log("\uD83D\uDD17 Merging ".concat(geometries.length, " geometries for: ").concat(modelKey));
+        mergedGeometry = mergeGeometries(geometries);
+      }
+
+      // Convert to indexed geometry if not already indexed
+      var indexedGeometry = mergedGeometry;
+      var originalGeometry = mergedGeometry; // Keep reference to original for comparison
+
+      if (!mergedGeometry.index) {
+        console.log("\uD83D\uDCCA Converting to indexed geometry: ".concat(modelKey));
+        indexedGeometry = mergeVertices(mergedGeometry);
+      }
+
+      // Calculate geometry statistics with original geometry for comparison
+      var stats = this.calculateGeometryStats(indexedGeometry, modelKey, originalGeometry);
+
+      // Prepare serializable data for storage
+      var geometryData = this.serializeGeometry(indexedGeometry, modelKey, stats);
+      console.log("\u2705 Successfully converted OBJ to indexed BufferGeometry: ".concat(modelKey));
+      console.log("\uD83D\uDCCA Vertices: ".concat(stats.vertexCount, ", Faces: ").concat(stats.faceCount));
+      console.log("\uD83D\uDCBE Indexed Size: ".concat(stats.indexedSizeKB, "KB"));
+      if (stats.nonIndexedSizeKB > 0) {
+        console.log("\uD83D\uDCBE Non-Indexed Size: ".concat(stats.nonIndexedSizeKB, "KB"));
+        console.log("\uD83D\uDD04 Memory Reduction: ".concat(stats.memoryReduction, "% (").concat(stats.compressionRatio, "x smaller)"));
+      }
+      return {
+        geometry: indexedGeometry,
+        geometryData: geometryData,
+        stats: stats,
+        materials: materials[0] || new THREE.MeshStandardMaterial({
+          color: 0x888888
+        })
+      };
+    }
+
+    /**
+     * Compute simple planar UVs for geometry
+     * @param {THREE.BufferGeometry} geometry - The geometry to compute UVs for
+     */
+  }, {
+    key: "computeSimpleUVs",
+    value: function computeSimpleUVs(geometry) {
+      var positions = geometry.attributes.position;
+      var uvs = new Float32Array(positions.count * 2);
+
+      // Simple planar projection on XZ plane
+      for (var i = 0; i < positions.count; i++) {
+        var x = positions.getX(i);
+        var z = positions.getZ(i);
+
+        // Normalize to 0-1 range (simple box projection)
+        uvs[i * 2] = (x + 1) * 0.5;
+        uvs[i * 2 + 1] = (z + 1) * 0.5;
+      }
+      geometry.setAttribute('uv', new THREE.BufferAttribute(uvs, 2));
+    }
+
+    /**
+     * Calculate geometry statistics
+     * @param {THREE.BufferGeometry} geometry - The geometry to analyze
+     * @param {string} modelKey - The model key for logging
+     * @param {THREE.BufferGeometry} originalGeometry - Optional original non-indexed geometry for comparison
+     * @returns {Object} Statistics object
+     */
+  }, {
+    key: "calculateGeometryStats",
+    value: function calculateGeometryStats(geometry, modelKey) {
+      var originalGeometry = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
+      var vertexCount = geometry.attributes.position.count;
+      var faceCount = geometry.index ? geometry.index.count / 3 : vertexCount / 3;
+
+      // Calculate indexed geometry memory usage
+      var indexedBytes = 0;
+
+      // Position attribute (3 floats per vertex)
+      if (geometry.attributes.position) {
+        indexedBytes += geometry.attributes.position.array.byteLength;
+      }
+
+      // Normal attribute (3 floats per vertex)
+      if (geometry.attributes.normal) {
+        indexedBytes += geometry.attributes.normal.array.byteLength;
+      }
+
+      // UV attribute (2 floats per vertex)
+      if (geometry.attributes.uv) {
+        indexedBytes += geometry.attributes.uv.array.byteLength;
+      }
+
+      // Index buffer (if indexed)
+      if (geometry.index) {
+        indexedBytes += geometry.index.array.byteLength;
+      }
+      var indexedSizeKB = (indexedBytes / 1024).toFixed(2);
+
+      // Calculate non-indexed geometry memory usage for comparison
+      var nonIndexedBytes = 0;
+      var nonIndexedSizeKB = 0;
+      var memoryReduction = 0;
+      var compressionRatio = 1;
+      if (originalGeometry) {
+        // Calculate what the memory would be without indexing
+        var originalVertexCount = originalGeometry.attributes.position ? originalGeometry.attributes.position.count : vertexCount;
+
+        // Position: 3 floats per vertex
+        nonIndexedBytes += originalVertexCount * 3 * 4; // 4 bytes per float32
+
+        // Normals: 3 floats per vertex (if present)
+        if (originalGeometry.attributes.normal || geometry.attributes.normal) {
+          nonIndexedBytes += originalVertexCount * 3 * 4;
+        }
+
+        // UVs: 2 floats per vertex (if present)
+        if (originalGeometry.attributes.uv || geometry.attributes.uv) {
+          nonIndexedBytes += originalVertexCount * 2 * 4;
+        }
+        nonIndexedSizeKB = (nonIndexedBytes / 1024).toFixed(2);
+        memoryReduction = ((nonIndexedBytes - indexedBytes) / nonIndexedBytes * 100).toFixed(1);
+        compressionRatio = (nonIndexedBytes / indexedBytes).toFixed(2);
+      } else if (geometry.index) {
+        // Estimate non-indexed size based on face count
+        var estimatedNonIndexedVertices = faceCount * 3; // Each face has 3 vertices
+
+        // Position: 3 floats per vertex
+        nonIndexedBytes += estimatedNonIndexedVertices * 3 * 4;
+
+        // Normals: 3 floats per vertex (if present)
+        if (geometry.attributes.normal) {
+          nonIndexedBytes += estimatedNonIndexedVertices * 3 * 4;
+        }
+
+        // UVs: 2 floats per vertex (if present)
+        if (geometry.attributes.uv) {
+          nonIndexedBytes += estimatedNonIndexedVertices * 2 * 4;
+        }
+        nonIndexedSizeKB = (nonIndexedBytes / 1024).toFixed(2);
+        memoryReduction = ((nonIndexedBytes - indexedBytes) / nonIndexedBytes * 100).toFixed(1);
+        compressionRatio = (nonIndexedBytes / indexedBytes).toFixed(2);
+      }
+      var stats = {
+        modelKey: modelKey,
+        vertexCount: vertexCount,
+        faceCount: faceCount,
+        // Indexed geometry stats
+        indexedBytes: indexedBytes,
+        indexedSizeKB: parseFloat(indexedSizeKB),
+        // Non-indexed geometry stats (for comparison)
+        nonIndexedBytes: nonIndexedBytes,
+        nonIndexedSizeKB: parseFloat(nonIndexedSizeKB),
+        // Compression metrics
+        memoryReduction: parseFloat(memoryReduction),
+        // Percentage reduction
+        compressionRatio: parseFloat(compressionRatio),
+        // How many times smaller
+        // Legacy compatibility
+        totalBytes: indexedBytes,
+        // Keep for backward compatibility
+        sizeKB: parseFloat(indexedSizeKB),
+        // Keep for backward compatibility
+        // Features
+        indexed: !!geometry.index,
+        hasNormals: !!geometry.attributes.normal,
+        hasUVs: !!geometry.attributes.uv,
+        timestamp: Date.now()
+      };
+
+      // Cache the size info
+      this.geometrySizeCache.set(modelKey, stats);
+      return stats;
+    }
+
+    /**
+     * Serialize geometry for storage
+     * @param {THREE.BufferGeometry} geometry - The geometry to serialize
+     * @param {string} modelKey - The model key
+     * @param {Object} stats - The geometry statistics
+     * @returns {Object} Serializable geometry data
+     */
+  }, {
+    key: "serializeGeometry",
+    value: function serializeGeometry(geometry, modelKey, stats) {
+      var data = {
+        modelKey: modelKey,
+        modelType: 'obj',
+        stats: stats,
+        attributes: {}
+      };
+
+      // Serialize position attribute
+      if (geometry.attributes.position) {
+        data.attributes.position = {
+          array: Array.from(geometry.attributes.position.array),
+          itemSize: geometry.attributes.position.itemSize,
+          normalized: geometry.attributes.position.normalized
+        };
+      }
+
+      // Serialize normal attribute
+      if (geometry.attributes.normal) {
+        data.attributes.normal = {
+          array: Array.from(geometry.attributes.normal.array),
+          itemSize: geometry.attributes.normal.itemSize,
+          normalized: geometry.attributes.normal.normalized
+        };
+      }
+
+      // Serialize UV attribute
+      if (geometry.attributes.uv) {
+        data.attributes.uv = {
+          array: Array.from(geometry.attributes.uv.array),
+          itemSize: geometry.attributes.uv.itemSize,
+          normalized: geometry.attributes.uv.normalized
+        };
+      }
+
+      // Serialize index
+      if (geometry.index) {
+        data.index = {
+          array: Array.from(geometry.index.array),
+          itemSize: 1
+        };
+      }
+      return data;
+    }
+
+    /**
+     * Deserialize geometry data back to BufferGeometry
+     * @param {Object} geometryData - The serialized geometry data
+     * @returns {THREE.BufferGeometry} The reconstructed geometry
+     */
+  }, {
+    key: "deserializeGeometry",
+    value: function deserializeGeometry(geometryData) {
+      var geometry = new THREE.BufferGeometry();
+
+      // Restore attributes
+      Object.keys(geometryData.attributes).forEach(function (attributeName) {
+        var attrData = geometryData.attributes[attributeName];
+        var array = new Float32Array(attrData.array);
+        var attribute = new THREE.BufferAttribute(array, attrData.itemSize, attrData.normalized);
+        geometry.setAttribute(attributeName, attribute);
+      });
+
+      // Restore index if present
+      if (geometryData.index) {
+        var indexArray = new Uint32Array(geometryData.index.array);
+        geometry.setIndex(new THREE.BufferAttribute(indexArray, 1));
+      }
+      return geometry;
+    }
+
+    /**
+     * Store indexed geometry in IndexedDB
+     * @param {Object} geometryData - The serialized geometry data
+     * @returns {Promise} Promise that resolves when stored
+     */
+  }, {
+    key: "storeGeometryInIDB",
+    value: (function () {
+      var _storeGeometryInIDB = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee2(geometryData) {
+        var _this3 = this;
+        var db, _t;
+        return _regenerator().w(function (_context2) {
+          while (1) switch (_context2.n) {
+            case 0:
+              if (this.idbSupported) {
+                _context2.n = 1;
+                break;
+              }
+              console.warn('⚠️ IndexedDB not supported, skipping storage');
+              return _context2.a(2);
+            case 1:
+              _context2.p = 1;
+              _context2.n = 2;
+              return this.initializeIDB();
+            case 2:
+              db = _context2.v;
+              return _context2.a(2, new Promise(function (resolve, reject) {
+                var transaction = db.transaction([_this3.storeName], 'readwrite');
+                var store = transaction.objectStore(_this3.storeName);
+                var request = store.put(geometryData);
+                request.onsuccess = function () {
+                  console.log("\uD83D\uDCBE Stored geometry in IndexedDB: ".concat(geometryData.modelKey));
+                  resolve();
+                };
+                request.onerror = function () {
+                  console.error("\u274C Failed to store geometry: ".concat(geometryData.modelKey));
+                  reject(request.error);
+                };
+              }));
+            case 3:
+              _context2.p = 3;
+              _t = _context2.v;
+              console.error('❌ Error storing geometry in IndexedDB:', _t);
+              throw _t;
+            case 4:
+              return _context2.a(2);
+          }
+        }, _callee2, this, [[1, 3]]);
+      }));
+      function storeGeometryInIDB(_x) {
+        return _storeGeometryInIDB.apply(this, arguments);
+      }
+      return storeGeometryInIDB;
+    }()
+    /**
+     * Load indexed geometry from IndexedDB
+     * @param {string} modelKey - The model key to load
+     * @returns {Promise<Object>} Promise that resolves to geometry data
+     */
+    )
+  }, {
+    key: "loadGeometryFromIDB",
+    value: (function () {
+      var _loadGeometryFromIDB = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee3(modelKey) {
+        var _this4 = this;
+        var db, _t2;
+        return _regenerator().w(function (_context3) {
+          while (1) switch (_context3.n) {
+            case 0:
+              if (this.idbSupported) {
+                _context3.n = 1;
+                break;
+              }
+              console.warn('⚠️ IndexedDB not supported, cannot load');
+              return _context3.a(2, null);
+            case 1:
+              _context3.p = 1;
+              _context3.n = 2;
+              return this.initializeIDB();
+            case 2:
+              db = _context3.v;
+              return _context3.a(2, new Promise(function (resolve, reject) {
+                var transaction = db.transaction([_this4.storeName], 'readonly');
+                var store = transaction.objectStore(_this4.storeName);
+                var request = store.get(modelKey);
+                request.onsuccess = function () {
+                  if (request.result) {
+                    console.log("\uD83D\uDCE6 Loaded geometry from IndexedDB: ".concat(modelKey));
+                    resolve(request.result);
+                  } else {
+                    console.log("\uD83D\uDCED No geometry found in IndexedDB: ".concat(modelKey));
+                    resolve(null);
+                  }
+                };
+                request.onerror = function () {
+                  console.error("\u274C Failed to load geometry: ".concat(modelKey));
+                  reject(request.error);
+                };
+              }));
+            case 3:
+              _context3.p = 3;
+              _t2 = _context3.v;
+              console.error('❌ Error loading geometry from IndexedDB:', _t2);
+              throw _t2;
+            case 4:
+              return _context3.a(2);
+          }
+        }, _callee3, this, [[1, 3]]);
+      }));
+      function loadGeometryFromIDB(_x2) {
+        return _loadGeometryFromIDB.apply(this, arguments);
+      }
+      return loadGeometryFromIDB;
+    }()
+    /**
+     * Create a custom mesh from indexed geometry
+     * @param {string} modelKey - The model key
+     * @param {THREE.Material} material - Optional material to use
+     * @returns {THREE.Mesh|null} The created mesh or null if not found
+     */
+    )
+  }, {
+    key: "createCustomMesh",
+    value: function createCustomMesh(modelKey) {
+      var material = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+      if (this.indexedGeometryCache.has(modelKey)) {
+        var cachedData = this.indexedGeometryCache.get(modelKey);
+        var geometry = cachedData.geometry.clone();
+        var defaultMaterial = new THREE.MeshStandardMaterial({
+          color: 0x888888,
+          side: THREE.DoubleSide,
+          wireframe: false
+        });
+        var mesh = new THREE.Mesh(geometry, material || defaultMaterial);
+        mesh.userData.modelKey = modelKey;
+        mesh.userData.stats = cachedData.stats;
+        mesh.userData.isCustomGeometry = true;
+        console.log("\uD83C\uDFAF Created custom mesh from indexed geometry: ".concat(modelKey));
+        return mesh;
+      }
+      console.warn("\u26A0\uFE0F Indexed geometry not found in cache: ".concat(modelKey));
+      return null;
+    }
+
+    /**
+     * Process an OBJ object and store the result
+     * @param {THREE.Object3D} objObject - The loaded OBJ object
+     * @param {string} modelKey - The model key
+     * @param {boolean} storeInIDB - Whether to store in IndexedDB
+     * @returns {Promise<Object>} Promise that resolves to the processed result
+     */
+  }, {
+    key: "processObjObject",
+    value: (function () {
+      var _processObjObject = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee4(objObject, modelKey) {
+        var storeInIDB,
+          result,
+          _args4 = arguments,
+          _t3;
+        return _regenerator().w(function (_context4) {
+          while (1) switch (_context4.n) {
+            case 0:
+              storeInIDB = _args4.length > 2 && _args4[2] !== undefined ? _args4[2] : true;
+              _context4.p = 1;
+              // Convert to indexed BufferGeometry
+              result = this.objToIndexedBufferGeometry(objObject, modelKey);
+              if (result) {
+                _context4.n = 2;
+                break;
+              }
+              throw new Error("Failed to convert OBJ to indexed geometry: ".concat(modelKey));
+            case 2:
+              // Cache the result
+              this.indexedGeometryCache.set(modelKey, result);
+
+              // Store in IndexedDB if requested
+              if (!(storeInIDB && result.geometryData)) {
+                _context4.n = 3;
+                break;
+              }
+              _context4.n = 3;
+              return this.storeGeometryInIDB(result.geometryData);
+            case 3:
+              console.log("\u2705 Successfully processed OBJ: ".concat(modelKey));
+              return _context4.a(2, result);
+            case 4:
+              _context4.p = 4;
+              _t3 = _context4.v;
+              console.error("\u274C Error processing OBJ: ".concat(modelKey), _t3);
+              throw _t3;
+            case 5:
+              return _context4.a(2);
+          }
+        }, _callee4, this, [[1, 4]]);
+      }));
+      function processObjObject(_x3, _x4) {
+        return _processObjObject.apply(this, arguments);
+      }
+      return processObjObject;
+    }()
+    /**
+     * Get all processed geometry statistics
+     * @returns {Array} Array of geometry statistics
+     */
+    )
+  }, {
+    key: "getAllGeometryStats",
+    value: function getAllGeometryStats() {
+      var stats = [];
+      this.geometrySizeCache.forEach(function (stat, modelKey) {
+        stats.push(stat);
+      });
+      return stats.sort(function (a, b) {
+        return b.sizeKB - a.sizeKB;
+      }); // Sort by size descending
+    }
+
+    /**
+     * Get total memory usage of cached geometries
+     * @returns {Object} Memory usage statistics
+     */
+  }, {
+    key: "getMemoryUsage",
+    value: function getMemoryUsage() {
+      var totalIndexedBytes = 0;
+      var totalNonIndexedBytes = 0;
+      var totalGeometries = 0;
+      this.geometrySizeCache.forEach(function (stats) {
+        totalIndexedBytes += stats.indexedBytes;
+        totalNonIndexedBytes += stats.nonIndexedBytes;
+        totalGeometries++;
+      });
+      var totalMemoryReduction = totalNonIndexedBytes > 0 ? ((totalNonIndexedBytes - totalIndexedBytes) / totalNonIndexedBytes * 100).toFixed(1) : 0;
+      var totalCompressionRatio = totalIndexedBytes > 0 ? (totalNonIndexedBytes / totalIndexedBytes).toFixed(2) : 1;
+      return {
+        totalGeometries: totalGeometries,
+        // Indexed geometry stats
+        indexedBytes: totalIndexedBytes,
+        indexedKB: (totalIndexedBytes / 1024).toFixed(2),
+        indexedMB: (totalIndexedBytes / (1024 * 1024)).toFixed(3),
+        // Non-indexed geometry stats
+        nonIndexedBytes: totalNonIndexedBytes,
+        nonIndexedKB: (totalNonIndexedBytes / 1024).toFixed(2),
+        nonIndexedMB: (totalNonIndexedBytes / (1024 * 1024)).toFixed(3),
+        // Compression stats
+        memoryReduction: parseFloat(totalMemoryReduction),
+        compressionRatio: parseFloat(totalCompressionRatio),
+        // Legacy compatibility
+        totalBytes: totalIndexedBytes,
+        totalKB: (totalIndexedBytes / 1024).toFixed(2),
+        totalMB: (totalIndexedBytes / (1024 * 1024)).toFixed(2)
+      };
+    }
+
+    /**
+     * Clear all caches
+     */
+  }, {
+    key: "clearCaches",
+    value: function clearCaches() {
+      console.log('🧹 Clearing OBJ processor caches...');
+
+      // Dispose of cached geometries
+      this.indexedGeometryCache.forEach(function (data, modelKey) {
+        if (data.geometry) {
+          data.geometry.dispose();
+        }
+        console.log("\uD83D\uDDD1\uFE0F Disposed cached geometry: ".concat(modelKey));
+      });
+      this.indexedGeometryCache.clear();
+      this.geometrySizeCache.clear();
+      console.log('✅ OBJ processor caches cleared');
+    }
+
+    /**
+     * Get processing status
+     * @returns {Object} Status information
+     */
+  }, {
+    key: "getStatus",
+    value: function getStatus() {
+      return {
+        cachedGeometries: Array.from(this.indexedGeometryCache.keys()),
+        totalCached: this.indexedGeometryCache.size,
+        idbSupported: this.idbSupported,
+        memoryUsage: this.getMemoryUsage()
+      };
+    }
+  }]);
+}(); // Export the class
+
+export { ObjProcessor, ObjProcessor as default };