@2112-lab/central-plant 0.1.13 → 0.1.16

package/dist/bundle/index.js

@@ -4315,6 +4315,465 @@ var SceneExportManager = /*#__PURE__*/function () {
   }]);
 }();
 
+/**
+ * Merges a set of geometries into a single instance. All geometries must have compatible attributes.
+ *
+ * @param {Array<BufferGeometry>} geometries - The geometries to merge.
+ * @param {boolean} [useGroups=false] - Whether to use groups or not.
+ * @return {?BufferGeometry} The merged geometry. Returns `null` if the merge does not succeed.
+ */
+function mergeGeometries( geometries, useGroups = false ) {
+
+	const isIndexed = geometries[ 0 ].index !== null;
+
+	const attributesUsed = new Set( Object.keys( geometries[ 0 ].attributes ) );
+	const morphAttributesUsed = new Set( Object.keys( geometries[ 0 ].morphAttributes ) );
+
+	const attributes = {};
+	const morphAttributes = {};
+
+	const morphTargetsRelative = geometries[ 0 ].morphTargetsRelative;
+
+	const mergedGeometry = new THREE.BufferGeometry();
+
+	let offset = 0;
+
+	for ( let i = 0; i < geometries.length; ++ i ) {
+
+		const geometry = geometries[ i ];
+		let attributesCount = 0;
+
+		// ensure that all geometries are indexed, or none
+
+		if ( isIndexed !== ( geometry.index !== null ) ) {
+
+			console.error( 'THREE.BufferGeometryUtils: .mergeGeometries() failed with geometry at index ' + i + '. All geometries must have compatible attributes; make sure index attribute exists among all geometries, or in none of them.' );
+			return null;
+
+		}
+
+		// gather attributes, exit early if they're different
+
+		for ( const name in geometry.attributes ) {
+
+			if ( ! attributesUsed.has( name ) ) {
+
+				console.error( 'THREE.BufferGeometryUtils: .mergeGeometries() failed with geometry at index ' + i + '. All geometries must have compatible attributes; make sure "' + name + '" attribute exists among all geometries, or in none of them.' );
+				return null;
+
+			}
+
+			if ( attributes[ name ] === undefined ) attributes[ name ] = [];
+
+			attributes[ name ].push( geometry.attributes[ name ] );
+
+			attributesCount ++;
+
+		}
+
+		// ensure geometries have the same number of attributes
+
+		if ( attributesCount !== attributesUsed.size ) {
+
+			console.error( 'THREE.BufferGeometryUtils: .mergeGeometries() failed with geometry at index ' + i + '. Make sure all geometries have the same number of attributes.' );
+			return null;
+
+		}
+
+		// gather morph attributes, exit early if they're different
+
+		if ( morphTargetsRelative !== geometry.morphTargetsRelative ) {
+
+			console.error( 'THREE.BufferGeometryUtils: .mergeGeometries() failed with geometry at index ' + i + '. .morphTargetsRelative must be consistent throughout all geometries.' );
+			return null;
+
+		}
+
+		for ( const name in geometry.morphAttributes ) {
+
+			if ( ! morphAttributesUsed.has( name ) ) {
+
+				console.error( 'THREE.BufferGeometryUtils: .mergeGeometries() failed with geometry at index ' + i + '.  .morphAttributes must be consistent throughout all geometries.' );
+				return null;
+
+			}
+
+			if ( morphAttributes[ name ] === undefined ) morphAttributes[ name ] = [];
+
+			morphAttributes[ name ].push( geometry.morphAttributes[ name ] );
+
+		}
+
+		if ( useGroups ) {
+
+			let count;
+
+			if ( isIndexed ) {
+
+				count = geometry.index.count;
+
+			} else if ( geometry.attributes.position !== undefined ) {
+
+				count = geometry.attributes.position.count;
+
+			} else {
+
+				console.error( 'THREE.BufferGeometryUtils: .mergeGeometries() failed with geometry at index ' + i + '. The geometry must have either an index or a position attribute' );
+				return null;
+
+			}
+
+			mergedGeometry.addGroup( offset, count, i );
+
+			offset += count;
+
+		}
+
+	}
+
+	// merge indices
+
+	if ( isIndexed ) {
+
+		let indexOffset = 0;
+		const mergedIndex = [];
+
+		for ( let i = 0; i < geometries.length; ++ i ) {
+
+			const index = geometries[ i ].index;
+
+			for ( let j = 0; j < index.count; ++ j ) {
+
+				mergedIndex.push( index.getX( j ) + indexOffset );
+
+			}
+
+			indexOffset += geometries[ i ].attributes.position.count;
+
+		}
+
+		mergedGeometry.setIndex( mergedIndex );
+
+	}
+
+	// merge attributes
+
+	for ( const name in attributes ) {
+
+		const mergedAttribute = mergeAttributes( attributes[ name ] );
+
+		if ( ! mergedAttribute ) {
+
+			console.error( 'THREE.BufferGeometryUtils: .mergeGeometries() failed while trying to merge the ' + name + ' attribute.' );
+			return null;
+
+		}
+
+		mergedGeometry.setAttribute( name, mergedAttribute );
+
+	}
+
+	// merge morph attributes
+
+	for ( const name in morphAttributes ) {
+
+		const numMorphTargets = morphAttributes[ name ][ 0 ].length;
+
+		if ( numMorphTargets === 0 ) break;
+
+		mergedGeometry.morphAttributes = mergedGeometry.morphAttributes || {};
+		mergedGeometry.morphAttributes[ name ] = [];
+
+		for ( let i = 0; i < numMorphTargets; ++ i ) {
+
+			const morphAttributesToMerge = [];
+
+			for ( let j = 0; j < morphAttributes[ name ].length; ++ j ) {
+
+				morphAttributesToMerge.push( morphAttributes[ name ][ j ][ i ] );
+
+			}
+
+			const mergedMorphAttribute = mergeAttributes( morphAttributesToMerge );
+
+			if ( ! mergedMorphAttribute ) {
+
+				console.error( 'THREE.BufferGeometryUtils: .mergeGeometries() failed while trying to merge the ' + name + ' morphAttribute.' );
+				return null;
+
+			}
+
+			mergedGeometry.morphAttributes[ name ].push( mergedMorphAttribute );
+
+		}
+
+	}
+
+	return mergedGeometry;
+
+}
+
+/**
+ * Merges a set of attributes into a single instance. All attributes must have compatible properties and types.
+ * Instances of {@link InterleavedBufferAttribute} are not supported.
+ *
+ * @param {Array<BufferAttribute>} attributes - The attributes to merge.
+ * @return {?BufferAttribute} The merged attribute. Returns `null` if the merge does not succeed.
+ */
+function mergeAttributes( attributes ) {
+
+	let TypedArray;
+	let itemSize;
+	let normalized;
+	let gpuType = - 1;
+	let arrayLength = 0;
+
+	for ( let i = 0; i < attributes.length; ++ i ) {
+
+		const attribute = attributes[ i ];
+
+		if ( TypedArray === undefined ) TypedArray = attribute.array.constructor;
+		if ( TypedArray !== attribute.array.constructor ) {
+
+			console.error( 'THREE.BufferGeometryUtils: .mergeAttributes() failed. BufferAttribute.array must be of consistent array types across matching attributes.' );
+			return null;
+
+		}
+
+		if ( itemSize === undefined ) itemSize = attribute.itemSize;
+		if ( itemSize !== attribute.itemSize ) {
+
+			console.error( 'THREE.BufferGeometryUtils: .mergeAttributes() failed. BufferAttribute.itemSize must be consistent across matching attributes.' );
+			return null;
+
+		}
+
+		if ( normalized === undefined ) normalized = attribute.normalized;
+		if ( normalized !== attribute.normalized ) {
+
+			console.error( 'THREE.BufferGeometryUtils: .mergeAttributes() failed. BufferAttribute.normalized must be consistent across matching attributes.' );
+			return null;
+
+		}
+
+		if ( gpuType === - 1 ) gpuType = attribute.gpuType;
+		if ( gpuType !== attribute.gpuType ) {
+
+			console.error( 'THREE.BufferGeometryUtils: .mergeAttributes() failed. BufferAttribute.gpuType must be consistent across matching attributes.' );
+			return null;
+
+		}
+
+		arrayLength += attribute.count * itemSize;
+
+	}
+
+	const array = new TypedArray( arrayLength );
+	const result = new THREE.BufferAttribute( array, itemSize, normalized );
+	let offset = 0;
+
+	for ( let i = 0; i < attributes.length; ++ i ) {
+
+		const attribute = attributes[ i ];
+		if ( attribute.isInterleavedBufferAttribute ) {
+
+			const tupleOffset = offset / itemSize;
+			for ( let j = 0, l = attribute.count; j < l; j ++ ) {
+
+				for ( let c = 0; c < itemSize; c ++ ) {
+
+					const value = attribute.getComponent( j, c );
+					result.setComponent( j + tupleOffset, c, value );
+
+				}
+
+			}
+
+		} else {
+
+			array.set( attribute.array, offset );
+
+		}
+
+		offset += attribute.count * itemSize;
+
+	}
+
+	if ( gpuType !== undefined ) {
+
+		result.gpuType = gpuType;
+
+	}
+
+	return result;
+
+}
+
+/**
+ * Returns a new geometry with vertices for which all similar vertex attributes (within tolerance) are merged.
+ *
+ * @param {BufferGeometry} geometry - The geometry to merge vertices for.
+ * @param {number} [tolerance=1e-4] - The tolerance value.
+ * @return {BufferGeometry} - The new geometry with merged vertices.
+ */
+function mergeVertices( geometry, tolerance = 1e-4 ) {
+
+	tolerance = Math.max( tolerance, Number.EPSILON );
+
+	// Generate an index buffer if the geometry doesn't have one, or optimize it
+	// if it's already available.
+	const hashToIndex = {};
+	const indices = geometry.getIndex();
+	const positions = geometry.getAttribute( 'position' );
+	const vertexCount = indices ? indices.count : positions.count;
+
+	// next value for triangle indices
+	let nextIndex = 0;
+
+	// attributes and new attribute arrays
+	const attributeNames = Object.keys( geometry.attributes );
+	const tmpAttributes = {};
+	const tmpMorphAttributes = {};
+	const newIndices = [];
+	const getters = [ 'getX', 'getY', 'getZ', 'getW' ];
+	const setters = [ 'setX', 'setY', 'setZ', 'setW' ];
+
+	// Initialize the arrays, allocating space conservatively. Extra
+	// space will be trimmed in the last step.
+	for ( let i = 0, l = attributeNames.length; i < l; i ++ ) {
+
+		const name = attributeNames[ i ];
+		const attr = geometry.attributes[ name ];
+
+		tmpAttributes[ name ] = new attr.constructor(
+			new attr.array.constructor( attr.count * attr.itemSize ),
+			attr.itemSize,
+			attr.normalized
+		);
+
+		const morphAttributes = geometry.morphAttributes[ name ];
+		if ( morphAttributes ) {
+
+			if ( ! tmpMorphAttributes[ name ] ) tmpMorphAttributes[ name ] = [];
+			morphAttributes.forEach( ( morphAttr, i ) => {
+
+				const array = new morphAttr.array.constructor( morphAttr.count * morphAttr.itemSize );
+				tmpMorphAttributes[ name ][ i ] = new morphAttr.constructor( array, morphAttr.itemSize, morphAttr.normalized );
+
+			} );
+
+		}
+
+	}
+
+	// convert the error tolerance to an amount of decimal places to truncate to
+	const halfTolerance = tolerance * 0.5;
+	const exponent = Math.log10( 1 / tolerance );
+	const hashMultiplier = Math.pow( 10, exponent );
+	const hashAdditive = halfTolerance * hashMultiplier;
+	for ( let i = 0; i < vertexCount; i ++ ) {
+
+		const index = indices ? indices.getX( i ) : i;
+
+		// Generate a hash for the vertex attributes at the current index 'i'
+		let hash = '';
+		for ( let j = 0, l = attributeNames.length; j < l; j ++ ) {
+
+			const name = attributeNames[ j ];
+			const attribute = geometry.getAttribute( name );
+			const itemSize = attribute.itemSize;
+
+			for ( let k = 0; k < itemSize; k ++ ) {
+
+				// double tilde truncates the decimal value
+				hash += `${ ~ ~ ( attribute[ getters[ k ] ]( index ) * hashMultiplier + hashAdditive ) },`;
+
+			}
+
+		}
+
+		// Add another reference to the vertex if it's already
+		// used by another index
+		if ( hash in hashToIndex ) {
+
+			newIndices.push( hashToIndex[ hash ] );
+
+		} else {
+
+			// copy data to the new index in the temporary attributes
+			for ( let j = 0, l = attributeNames.length; j < l; j ++ ) {
+
+				const name = attributeNames[ j ];
+				const attribute = geometry.getAttribute( name );
+				const morphAttributes = geometry.morphAttributes[ name ];
+				const itemSize = attribute.itemSize;
+				const newArray = tmpAttributes[ name ];
+				const newMorphArrays = tmpMorphAttributes[ name ];
+
+				for ( let k = 0; k < itemSize; k ++ ) {
+
+					const getterFunc = getters[ k ];
+					const setterFunc = setters[ k ];
+					newArray[ setterFunc ]( nextIndex, attribute[ getterFunc ]( index ) );
+
+					if ( morphAttributes ) {
+
+						for ( let m = 0, ml = morphAttributes.length; m < ml; m ++ ) {
+
+							newMorphArrays[ m ][ setterFunc ]( nextIndex, morphAttributes[ m ][ getterFunc ]( index ) );
+
+						}
+
+					}
+
+				}
+
+			}
+
+			hashToIndex[ hash ] = nextIndex;
+			newIndices.push( nextIndex );
+			nextIndex ++;
+
+		}
+
+	}
+
+	// generate result BufferGeometry
+	const result = geometry.clone();
+	for ( const name in geometry.attributes ) {
+
+		const tmpAttribute = tmpAttributes[ name ];
+
+		result.setAttribute( name, new tmpAttribute.constructor(
+			tmpAttribute.array.slice( 0, nextIndex * tmpAttribute.itemSize ),
+			tmpAttribute.itemSize,
+			tmpAttribute.normalized,
+		) );
+
+		if ( ! ( name in tmpMorphAttributes ) ) continue;
+
+		for ( let j = 0; j < tmpMorphAttributes[ name ].length; j ++ ) {
+
+			const tmpMorphAttribute = tmpMorphAttributes[ name ][ j ];
+
+			result.morphAttributes[ name ][ j ] = new tmpMorphAttribute.constructor(
+				tmpMorphAttribute.array.slice( 0, nextIndex * tmpMorphAttribute.itemSize ),
+				tmpMorphAttribute.itemSize,
+				tmpMorphAttribute.normalized,
+			);
+
+		}
+
+	}
+
+	// indices
+
+	result.setIndex( newIndices );
+
+	return result;
+
+}
+
 /**
  * Returns a new indexed geometry based on `TrianglesDrawMode` draw mode.
  * This mode corresponds to the `gl.TRIANGLES` primitive in WebGL.
@@ -10167,17 +10626,692 @@ class OBJLoader extends THREE.Loader {
 
 }
 
-var ModelPreloader = /*#__PURE__*/function () {
-  function ModelPreloader() {
-    _classCallCheck(this, ModelPreloader);
-    this.modelCache = new Map(); // Cache for loaded models
-    this.loadingPromises = new Map(); // Track ongoing loads to prevent duplicates
-    this.gltfLoader = new GLTFLoader();
-    this.objLoader = new OBJLoader();
-    this.isPreloading = false;
-    this.preloadingPromise = null;
+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__namespace.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__namespace.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__namespace.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__namespace.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__namespace.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__namespace.MeshStandardMaterial({
+          color: 0x888888,
+          side: THREE__namespace.DoubleSide,
+          wireframe: false
+        });
+        var mesh = new THREE__namespace.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
+
+var ModelPreloader = /*#__PURE__*/function () {
+  function ModelPreloader() {
+    _classCallCheck(this, ModelPreloader);
+    this.modelCache = new Map(); // Cache for loaded models
+    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');
   }
 
   /**
@@ -10283,93 +11417,137 @@ 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__namespace.MeshStandardMaterial({
-                          color: child.material.color || 0x888888,
-                          side: THREE__namespace.DoubleSide,
-                          wireframe: false
-                        });
-
-                        // Set the solid material
-                        child.material = solidMaterial;
+                if (modelType === 'obj') {
+                  // 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 with solid + wireframe overlay
+                            object.traverse(function (child) {
+                              if (child.isMesh) {
+                                // Create solid material
+                                var solidMaterial = new THREE__namespace.MeshStandardMaterial({
+                                  color: child.material.color || 0x888888,
+                                  side: THREE__namespace.DoubleSide,
+                                  wireframe: false
+                                  // transparent: true,
+                                  // opacity: 0.8 // Slightly transparent to show wireframe better
+                                });
 
-                        // Create wireframe overlay by cloning the geometry
-                        var wireframeGeometry = child.geometry.clone();
-                        var wireframeMaterial = new THREE__namespace.MeshBasicMaterial({
-                          color: 0x000000,
-                          wireframe: true,
-                          transparent: true,
-                          opacity: 0.8
-                        });
+                                // Create wireframe material
+                                var wireframeMaterial = new THREE__namespace.MeshBasicMaterial({
+                                  color: 0x000000,
+                                  // Black wireframe
+                                  wireframe: true,
+                                  // transparent: true,
+                                  // opacity: 0.6,
+                                  side: THREE__namespace.DoubleSide
+                                });
 
-                        // Create wireframe mesh with same geometry
-                        var wireframeMesh = new THREE__namespace.Mesh(wireframeGeometry, wireframeMaterial);
-                        wireframeMesh.name = child.name + '_wireframe';
+                                // Apply solid material to the original mesh
+                                child.material = solidMaterial;
 
-                        // 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
+                                // Create a wireframe mesh clone and add it as a child
+                                var wireframeMesh = new THREE__namespace.Mesh(child.geometry, wireframeMaterial);
+                                wireframeMesh.position.copy(child.position);
+                                wireframeMesh.rotation.copy(child.rotation);
+                                wireframeMesh.scale.copy(child.scale);
+                                wireframeMesh.name = child.name + '_wireframe';
+                                wireframeMesh.userData.isWireframeOverlay = true;
 
-                        // Add wireframe as sibling to the parent
-                        if (child.parent) {
-                          child.parent.add(wireframeMesh);
+                                // Add wireframe mesh to the same parent
+                                if (child.parent) {
+                                  child.parent.add(wireframeMesh);
+                                }
+                              }
+                            });
+                            // 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);
                   });
@@ -10400,9 +11578,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);
@@ -10412,18 +11590,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__namespace.Mesh(cachedData.processedGeometry.clone(), cachedData.materials.clone());
 
-        // Determine model type from the modelKey extension
-        modelKey.toLowerCase().endsWith('.obj') ? 'obj' : 'glb';
+          // 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();
+
+        // 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"));
@@ -10442,7 +11644,26 @@ var ModelPreloader = /*#__PURE__*/function () {
       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();
+        var cachedData = this.modelCache.get(modelKey);
+
+        // Handle OBJ models with processed geometry structure
+        var clonedModel;
+        if (cachedData && cachedData.isObjModel) {
+          // Clone the original OBJ object
+          clonedModel = cachedData.originalObject.clone();
+
+          // Add OBJ stats if available
+          if (cachedData.geometryStats) {
+            if (!clonedModel.userData) {
+              clonedModel.userData = {};
+            }
+            clonedModel.userData.geometryStats = cachedData.geometryStats;
+            clonedModel.userData.isObjModel = true;
+          }
+        } else {
+          // Handle regular GLB models
+          clonedModel = cachedData.clone();
+        }
 
         // Add dimensions from component dictionary if available
         if (libraryId && this.componentDictionary) {
@@ -10531,41 +11752,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
@@ -10576,11 +11797,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;
@@ -10597,7 +11818,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();
@@ -10618,6 +11874,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');
     }
 
@@ -10690,7 +11949,24 @@ var ModelPreloader = /*#__PURE__*/function () {
       console.log("\uD83D\uDD04 Loading model for library ID ".concat(libraryId, ": ").concat(modelKey, " (").concat(modelType.toUpperCase(), ")"));
       this.preloadSingleModel(modelKey, modelType).then(function (model) {
         if (model) {
-          var _clonedModel = model.clone();
+          // Handle OBJ models with processed geometry structure
+          var _clonedModel;
+          if (model && model.isObjModel) {
+            // Clone the original OBJ object
+            _clonedModel = model.originalObject.clone();
+
+            // Add OBJ stats if available
+            if (model.geometryStats) {
+              if (!_clonedModel.userData) {
+                _clonedModel.userData = {};
+              }
+              _clonedModel.userData.geometryStats = model.geometryStats;
+              _clonedModel.userData.isObjModel = true;
+            }
+          } else {
+            // Handle regular GLB models
+            _clonedModel = model.clone();
+          }
 
           // Add dimensions if available
           if (componentData.boundingBox) {
@@ -10726,13 +12002,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
@@ -10742,6 +12020,124 @@ 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;
+    }
+
+    /**
+     * Toggle wireframe visibility on an OBJ model
+     * @param {THREE.Object3D} model - The model to toggle wireframe on
+     * @param {boolean} visible - Whether wireframe should be visible
+     */
+  }, {
+    key: "toggleWireframe",
+    value: function toggleWireframe(model) {
+      var visible = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+      if (!model) return;
+      model.traverse(function (child) {
+        if (child.userData && child.userData.isWireframeOverlay) {
+          child.visible = visible;
+        }
+      });
+    }
+
+    /**
+     * Update wireframe appearance on an OBJ model
+     * @param {THREE.Object3D} model - The model to update
+     * @param {Object} options - Wireframe options {color, opacity, visible}
+     */
+  }, {
+    key: "updateWireframeAppearance",
+    value: function updateWireframeAppearance(model) {
+      var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+      if (!model) return;
+      var _options$color = options.color,
+        color = _options$color === void 0 ? 0x000000 : _options$color,
+        _options$opacity = options.opacity,
+        opacity = _options$opacity === void 0 ? 0.6 : _options$opacity,
+        _options$visible = options.visible,
+        visible = _options$visible === void 0 ? true : _options$visible;
+      model.traverse(function (child) {
+        if (child.userData && child.userData.isWireframeOverlay && child.material) {
+          child.material.color.setHex(color);
+          child.material.opacity = opacity;
+          child.visible = visible;
+        }
+      });
+    }
+
+    /**
+     * 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();
@@ -35283,6 +36679,250 @@ var testing = /*#__PURE__*/Object.freeze({
   Testing: Testing
 });
 
+var ObjProcessingDemo = /*#__PURE__*/function () {
+  function ObjProcessingDemo() {
+    _classCallCheck(this, ObjProcessingDemo);
+    this.objProcessor = new ObjProcessor();
+    this.componentDictionary = null;
+    this.processedResults = new Map();
+  }
+
+  /**
+   * Load component dictionary
+   * @returns {Promise<Object>} Component dictionary
+   */
+  return _createClass(ObjProcessingDemo, [{
+    key: "loadComponentDictionary",
+    value: (function () {
+      var _loadComponentDictionary = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee() {
+        var response, _t;
+        return _regenerator().w(function (_context) {
+          while (1) switch (_context.n) {
+            case 0:
+              _context.p = 0;
+              _context.n = 1;
+              return fetch('/library/component-dictionary.json');
+            case 1:
+              response = _context.v;
+              _context.n = 2;
+              return response.json();
+            case 2:
+              this.componentDictionary = _context.v;
+              return _context.a(2, this.componentDictionary);
+            case 3:
+              _context.p = 3;
+              _t = _context.v;
+              throw _t;
+            case 4:
+              return _context.a(2);
+          }
+        }, _callee, this, [[0, 3]]);
+      }));
+      function loadComponentDictionary() {
+        return _loadComponentDictionary.apply(this, arguments);
+      }
+      return loadComponentDictionary;
+    }()
+    /**
+     * Get all OBJ models from component dictionary
+     * @returns {Array} Array of OBJ model configurations
+     */
+    )
+  }, {
+    key: "getObjModels",
+    value: function getObjModels() {
+      var _this = this;
+      if (!this.componentDictionary) {
+        return [];
+      }
+      var objModels = [];
+      Object.keys(this.componentDictionary).forEach(function (componentId) {
+        var component = _this.componentDictionary[componentId];
+        if (component.modelType === 'obj') {
+          objModels.push({
+            componentId: componentId,
+            modelKey: component.modelKey,
+            name: component.name,
+            boundingBox: component.boundingBox
+          });
+        }
+      });
+      return objModels;
+    }
+
+    /**
+     * Process all OBJ models and store in IndexedDB
+     * @returns {Promise<Array>} Array of processing results
+     */
+  }, {
+    key: "processAllObjModels",
+    value: (function () {
+      var _processAllObjModels = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee2() {
+        var objModels, processingResults, _iterator, _step, objModel, cachedModelData, result, serializedData, _t3;
+        return _regenerator().w(function (_context2) {
+          while (1) switch (_context2.n) {
+            case 0:
+              if (this.componentDictionary) {
+                _context2.n = 1;
+                break;
+              }
+              _context2.n = 1;
+              return this.loadComponentDictionary();
+            case 1:
+              // Get all OBJ models
+              objModels = this.getObjModels();
+              if (!(objModels.length === 0)) {
+                _context2.n = 2;
+                break;
+              }
+              return _context2.a(2, []);
+            case 2:
+              _context2.n = 3;
+              return modelPreloader.preloadAllModels(this.componentDictionary);
+            case 3:
+              if (!this.objProcessor.idbSupported) {
+                _context2.n = 4;
+                break;
+              }
+              _context2.n = 4;
+              return this.objProcessor.initializeIDB();
+            case 4:
+              processingResults = []; // Process each OBJ model
+              _iterator = _createForOfIteratorHelper(objModels);
+              _context2.p = 5;
+              _iterator.s();
+            case 6:
+              if ((_step = _iterator.n()).done) {
+                _context2.n = 12;
+                break;
+              }
+              objModel = _step.value;
+              _context2.p = 7;
+              // Get the cached model from preloader
+              cachedModelData = modelPreloader.modelCache.get(objModel.modelKey);
+              if (!(!cachedModelData || !cachedModelData.isObjModel)) {
+                _context2.n = 8;
+                break;
+              }
+              return _context2.a(3, 11);
+            case 8:
+              // Extract processing results
+              result = {
+                componentId: objModel.componentId,
+                modelKey: objModel.modelKey,
+                name: objModel.name,
+                boundingBox: objModel.boundingBox,
+                stats: cachedModelData.geometryStats,
+                originalObject: cachedModelData.originalObject,
+                processedGeometry: cachedModelData.processedGeometry,
+                materials: cachedModelData.materials
+              };
+              processingResults.push(result);
+              this.processedResults.set(objModel.modelKey, result);
+
+              // Store in IndexedDB if supported
+              if (!(this.objProcessor.idbSupported && result.processedGeometry)) {
+                _context2.n = 9;
+                break;
+              }
+              serializedData = this.objProcessor.serializeGeometry(result.processedGeometry);
+              _context2.n = 9;
+              return this.objProcessor.storeGeometryInIDB(objModel.modelKey, serializedData);
+            case 9:
+              _context2.n = 11;
+              break;
+            case 10:
+              _context2.p = 10;
+              _context2.v;
+              return _context2.a(3, 11);
+            case 11:
+              _context2.n = 6;
+              break;
+            case 12:
+              _context2.n = 14;
+              break;
+            case 13:
+              _context2.p = 13;
+              _t3 = _context2.v;
+              _iterator.e(_t3);
+            case 14:
+              _context2.p = 14;
+              _iterator.f();
+              return _context2.f(14);
+            case 15:
+              return _context2.a(2, processingResults);
+          }
+        }, _callee2, this, [[7, 10], [5, 13, 14, 15]]);
+      }));
+      function processAllObjModels() {
+        return _processAllObjModels.apply(this, arguments);
+      }
+      return processAllObjModels;
+    }()
+    /**
+     * Run the simplified demo - process and store in IndexedDB
+     * @returns {Promise<Object>} Demo results
+     */
+    )
+  }, {
+    key: "run",
+    value: (function () {
+      var _run = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee3() {
+        var processingResults, _t4;
+        return _regenerator().w(function (_context3) {
+          while (1) switch (_context3.n) {
+            case 0:
+              _context3.p = 0;
+              _context3.n = 1;
+              return this.processAllObjModels();
+            case 1:
+              processingResults = _context3.v;
+              return _context3.a(2, {
+                processingResults: processingResults,
+                totalModelsProcessed: processingResults.length,
+                success: true
+              });
+            case 2:
+              _context3.p = 2;
+              _t4 = _context3.v;
+              return _context3.a(2, {
+                processingResults: [],
+                totalModelsProcessed: 0,
+                success: false,
+                error: _t4.message
+              });
+          }
+        }, _callee3, this, [[0, 2]]);
+      }));
+      function run() {
+        return _run.apply(this, arguments);
+      }
+      return run;
+    }()
+    /**
+     * Get processing results for external use
+     * @returns {Map} Map of processing results
+     */
+    )
+  }, {
+    key: "getResults",
+    value: function getResults() {
+      return this.processedResults;
+    }
+
+    /**
+     * Get geometry by model key
+     * @param {string} modelKey - The model key
+     * @returns {Object|null} Processing result or null
+     */
+  }, {
+    key: "getGeometry",
+    value: function getGeometry(modelKey) {
+      return this.processedResults.get(modelKey) || null;
+    }
+  }]);
+}(); // Export for use
+
 exports.Analysis = analysis;
 exports.AnimationManager = AnimationManager;
 exports.CameraControlsManager = CameraControlsManager;
@@ -35298,6 +36938,8 @@ exports.ImportUtils = _import;
 exports.KeyboardControlsManager = KeyboardControlsManager;
 exports.MathUtils = MathUtils;
 exports.Numerics = numerics;
+exports.ObjProcessingDemo = ObjProcessingDemo;
+exports.ObjProcessor = ObjProcessor;
 exports.PathfindingManager = PathfindingManager;
 exports.PerformanceMonitor = PerformanceMonitor;
 exports.Rendering2D = rendering2D;