@2112-lab/central-plant 0.1.0 → 0.1.2

package/dist/esm/src/environmentManager.js

@@ -1,10 +1,51 @@
-import { createClass as _createClass, toConsumableArray as _toConsumableArray, asyncToGenerator as _asyncToGenerator, regenerator as _regenerator, classCallCheck as _classCallCheck, regeneratorValues as _regeneratorValues, createForOfIteratorHelper as _createForOfIteratorHelper } from '../_virtual/_rollupPluginBabelHelpers.js';
+import { createClass as _createClass, toConsumableArray as _toConsumableArray, asyncToGenerator as _asyncToGenerator, regenerator as _regenerator, classCallCheck as _classCallCheck, regeneratorValues as _regeneratorValues, createForOfIteratorHelper as _createForOfIteratorHelper, slicedToArray as _slicedToArray } from '../_virtual/_rollupPluginBabelHelpers.js';
 import * as THREE from 'three';
 import { logger } from './debugLogger.js';
 
 // We'll need to import RGBELoader from three examples
 var RGBELoader;
 
+/**
+ * Helper function to get asset paths that works in both bundled and modular contexts
+ * @param {string} assetPath - Relative path from the assets directory
+ * @returns {string} - The full path to the asset
+ */
+function getAssetPath(assetPath) {
+  // Strip leading slash if present
+  if (assetPath.startsWith('/')) {
+    assetPath = assetPath.substring(1);
+  }
+
+  // In browser context, check for different module formats
+  if (typeof window !== 'undefined') {
+    // For bundled version, assets should be in dist/bundle/assets/
+    // For ESM/CJS, assets should be in their respective folders
+
+    // Try to determine if we're using the bundled version or ESM/CJS
+    var isBundled = typeof CentralPlantUtils !== 'undefined';
+
+    // Check if we're running in a Nuxt.js environment (localhost:3000 is a common dev server)
+    var isNuxtEnv = window.location.hostname === 'localhost' && (window.location.port === '3000' || window.location.port === '3001');
+    if (isNuxtEnv) {
+      // In Nuxt.js environment, assets are likely in the /static directory at the root
+      return "/".concat(assetPath); // No /assets/ prefix in the URL path
+    } else if (isBundled) {
+      // Get the base URL for the module
+      var baseUrl = import.meta.url;
+      // In bundled format, assets are in the assets folder next to the bundle
+      return new URL("./assets/".concat(assetPath), baseUrl).href;
+    } else {
+      // Get the base URL for the module
+      var _baseUrl = import.meta.url;
+      // In ESM/CJS format, need to go up relative to current module path
+      return new URL("../assets/".concat(assetPath), _baseUrl).href;
+    }
+  }
+
+  // In Node.js context
+  return "assets/".concat(assetPath);
+}
+
 // Dynamic import for browser compatibility
 function importThreeLoaders() {
   return _importThreeLoaders.apply(this, arguments);
@@ -41,13 +82,17 @@ function _importThreeLoaders() {
   }));
   return _importThreeLoaders.apply(this, arguments);
 }
-var loadTextureSetAndCreateMaterial;
+var textureConfig = {
+  loadTextureSetAndCreateMaterial: null,
+  checkThreeJSCompatibility: null,
+  forceUpdateMaterials: null
+};
 function importTextureConfig() {
   return _importTextureConfig.apply(this, arguments);
 }
 function _importTextureConfig() {
   _importTextureConfig = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee9() {
-    var module, _t1;
+    var module, importedFunctions, _t1;
     return _regenerator().w(function (_context1) {
       while (1) switch (_context1.n) {
         case 0:
@@ -61,8 +106,28 @@ function _importTextureConfig() {
           return import('./textureConfig.js');
         case 2:
           module = _context1.v;
-          loadTextureSetAndCreateMaterial = module.loadTextureSetAndCreateMaterial;
-          console.log('✅ TextureConfig imported successfully:', loadTextureSetAndCreateMaterial ? 'Available' : 'Undefined');
+          // Store all exported functions
+          textureConfig.loadTextureSetAndCreateMaterial = module.loadTextureSetAndCreateMaterial;
+          textureConfig.checkThreeJSCompatibility = module.checkThreeJSCompatibility;
+          textureConfig.forceUpdateMaterials = module.forceUpdateMaterials;
+
+          // Check what was successfully imported
+          importedFunctions = Object.entries(textureConfig).filter(function (_ref2) {
+            var _ref3 = _slicedToArray(_ref2, 2);
+              _ref3[0];
+              var fn = _ref3[1];
+            return typeof fn === 'function';
+          }).map(function (_ref4) {
+            var _ref5 = _slicedToArray(_ref4, 1),
+              name = _ref5[0];
+            return name;
+          });
+          console.log("\u2705 TextureConfig imported successfully with functions: ".concat(importedFunctions.join(', ')));
+
+          // Run compatibility check if available
+          if (typeof textureConfig.checkThreeJSCompatibility === 'function') {
+            textureConfig.checkThreeJSCompatibility();
+          }
           return _context1.a(2, true);
         case 3:
           _context1.p = 3;
@@ -118,15 +183,15 @@ var EnvironmentManager = /*#__PURE__*/function () {
       }
       return initLoaders;
     }()
-    /**
-     * Create skybox with HDR environment mapping
+    /**
+     * Create skybox with HDR environment mapping
      */
   }, {
     key: "createSkybox",
     value: (function () {
       var _createSkybox = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee2() {
         var _this = this;
-        var component, isContextLost, pmremGenerator, loaders, applyEnvironmentMap, _loop, _ret, _i, _loaders, _t4, _t5, _t6;
+        var component, isContextLost, pmremGenerator, hdrPath1, hdrPath2, jpgPath, loaders, applyEnvironmentMap, _loop, _ret, _i, _loaders, _t4, _t5, _t6;
         return _regenerator().w(function (_context4) {
           while (1) switch (_context4.n) {
             case 0:
@@ -193,22 +258,23 @@ var EnvironmentManager = /*#__PURE__*/function () {
               this.createFallbackEnvironment();
               return _context4.a(2);
             case 9:
+              // Get resolved paths for better debugging
+              hdrPath1 = getAssetPath('skyboxes/kloofendal_48d_partly_cloudy_puresky_2k.hdr');
+              hdrPath2 = getAssetPath('skyboxes/kloofendal_48d_partly_cloudy_puresky_1k.hdr');
+              jpgPath = getAssetPath('skyboxes/sky_fallback.jpg');
+              console.log('🔍 Resolved HDR paths:', {
+                hdr2k: hdrPath1,
+                hdr1k: hdrPath2,
+                jpg: jpgPath
+              });
               loaders = [{
                 type: 'hdr',
                 loader: new RGBELoader(),
-                paths: [
-                // Try local paths first
-                '/skyboxes/kloofendal_48d_partly_cloudy_puresky_2k.hdr', '/skyboxes/kloofendal_48d_partly_cloudy_puresky_1k.hdr',
-                // Fall back to S3 paths
-                'https://central-plant-assets.s3.us-east-1.amazonaws.com/skyboxes/kloofendal_48d_partly_cloudy_puresky_2k.hdr', 'https://central-plant-assets.s3.us-east-1.amazonaws.com/skyboxes/kloofendal_48d_partly_cloudy_puresky_1k.hdr']
+                paths: [hdrPath1, hdrPath2]
               }, {
                 type: 'jpeg',
                 loader: component.textureLoader || new THREE.TextureLoader(),
-                paths: [
-                // Try local paths first
-                '/skyboxes/sky_fallback.jpg',
-                // Fall back to S3 path
-                'https://central-plant-assets.s3.us-east-1.amazonaws.com/skyboxes/sky_fallback.jpg']
+                paths: [jpgPath]
               }]; // Configure texture loaders with CORS settings
               loaders.forEach(function (_ref) {
                 var loader = _ref.loader;
@@ -275,7 +341,7 @@ var EnvironmentManager = /*#__PURE__*/function () {
                             case 0:
                               path = _step.value;
                               _context2.p = 1;
-                              if (!path.startsWith('/')) {
+                              if (!(path.startsWith('/') && !path.includes('://'))) {
                                 _context2.n = 3;
                                 break;
                               }
@@ -415,8 +481,8 @@ var EnvironmentManager = /*#__PURE__*/function () {
       }
       return createSkybox;
     }()
-    /**
-     * Create a fallback environment when renderer issues occur
+    /**
+     * Create a fallback environment when renderer issues occur
      */
     )
   }, {
@@ -436,8 +502,8 @@ var EnvironmentManager = /*#__PURE__*/function () {
       component.scene.background = new THREE.Color(0x87CEEB);
     }
 
-    /**
-     * Create procedural sky when textures fail to load
+    /**
+     * Create procedural sky when textures fail to load
      */
   }, {
     key: "createProceduralSky",
@@ -477,8 +543,8 @@ var EnvironmentManager = /*#__PURE__*/function () {
       }
     }
 
-    /**
-     * Setup scene lighting
+    /**
+     * Setup scene lighting
      */
   }, {
     key: "setupLighting",
@@ -527,8 +593,8 @@ var EnvironmentManager = /*#__PURE__*/function () {
       logger.info('Scene lighting setup complete');
     }
 
-    /**
-     * Create ground plane
+    /**
+     * Create ground plane
      */
   }, {
     key: "createGround",
@@ -562,8 +628,8 @@ var EnvironmentManager = /*#__PURE__*/function () {
       return ground;
     }
 
-    /**
-     * Create walls for the environment
+    /**
+     * Create walls for the environment
      */
   }, {
     key: "createWalls",
@@ -627,8 +693,8 @@ var EnvironmentManager = /*#__PURE__*/function () {
       return walls;
     }
 
-    /**
-     * Set fog in the scene
+    /**
+     * Set fog in the scene
      */
   }, {
     key: "setFog",
@@ -642,15 +708,15 @@ var EnvironmentManager = /*#__PURE__*/function () {
       }
       component.scene.fog = new THREE.FogExp2(color, density);
       logger.info('Scene fog applied');
-    }
-    /**
-     * Initialize the default environment
-     */
+    } /**
+      * Initialize the default environment
+      */
   }, {
     key: "initializeEnvironment",
     value: (function () {
       var _initializeEnvironment = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee3() {
-        var component, loadersReady, textureConfigReady, _t7;
+        var _this2 = this;
+        var component, loadersReady, textureConfigReady, ground, walls, _t7;
         return _regenerator().w(function (_context5) {
           while (1) switch (_context5.n) {
             case 0:
@@ -676,39 +742,91 @@ var EnvironmentManager = /*#__PURE__*/function () {
               _t7 = _context5.v;
               console.warn('⚠️ Error initializing environment loaders:', _t7);
             case 5:
-              // Configure renderer for proper HDR rendering if it exists
-              if (component && component.renderer) {
-                // Ensure proper tone mapping is set for HDR
+              if (component) {
+                _context5.n = 6;
+                break;
+              }
+              logger.error('❌ Cannot initialize environment: component is null');
+              return _context5.a(2);
+            case 6:
+              if (component.renderer) {
+                _context5.n = 7;
+                break;
+              }
+              logger.error('❌ Cannot initialize environment: renderer is null');
+              return _context5.a(2);
+            case 7:
+              // Configure renderer for proper HDR rendering
+              console.log('🎨 Configuring renderer for environment...');
+
+              // Don't override existing settings from sceneInitializationManager
+              // Just ensure we have reasonable values set
+              if (!component.renderer.toneMapping) {
                 component.renderer.toneMapping = THREE.ACESFilmicToneMapping;
-                component.renderer.toneMappingExposure = 1.0;
-                // For all Three.js versions from r152+
-                if (component.renderer.outputColorSpace !== undefined) {
-                  component.renderer.outputColorSpace = THREE.SRGBColorSpace;
-                }
-                // For older Three.js versions (legacy support)
-                else if (component.renderer.outputEncoding !== undefined) {
-                  component.renderer.outputEncoding = THREE.sRGBEncoding;
-                }
-                logger.info("Renderer configured for HDR:\n        - Tone mapping: ".concat(component.renderer.toneMapping, "\n        - Color space: ").concat(component.renderer.outputColorSpace || component.renderer.outputEncoding));
               }
+              component.renderer.toneMappingExposure = 1.0;
+
+              // Ensure correct color space is set based on Three.js version
+              if (component.renderer.outputColorSpace !== undefined) {
+                component.renderer.outputColorSpace = THREE.SRGBColorSpace; // For newer Three.js
+                console.log('✅ Set SRGBColorSpace for renderer (newer Three.js)');
+              } else if (component.renderer.outputEncoding !== undefined) {
+                component.renderer.outputEncoding = THREE.sRGBEncoding; // For older Three.js
+                console.log('✅ Set sRGBEncoding for renderer (older Three.js)');
+              }
+              logger.info("Renderer configured for HDR:\n      - Tone mapping: ".concat(component.renderer.toneMapping, "\n      - Color space: ").concat(component.renderer.outputColorSpace || component.renderer.outputEncoding));
 
               // Create skybox (includes base lighting)
-              _context5.n = 6;
+              _context5.n = 8;
               return this.createSkybox();
-            case 6:
+            case 8:
               // Add additional lighting
               this.setupLighting();
 
               // Use textured ground instead of basic ground
-              _context5.n = 7;
+              console.log('🌍 Creating ground with texture...');
+              _context5.n = 9;
               return this.addTexturedGround();
-            case 7:
-              // No walls or fog by default
-              // await this.addBrickWalls();
-              // this.addHorizonFog();
+            case 9:
+              ground = _context5.v;
+              if (!ground) {
+                logger.error('❌ Failed to create textured ground');
+              } else {
+                logger.info('✅ Ground created successfully');
+              }
 
-              logger.info('Environment initialization complete');
-            case 8:
+              // Add walls with textures
+              console.log('🧱 Creating walls with textures...');
+              _context5.n = 10;
+              return this.addBrickWalls();
+            case 10:
+              walls = _context5.v;
+              if (!walls || walls.length === 0) {
+                logger.warn('⚠️ No walls were created');
+              } else {
+                logger.info("\u2705 Created ".concat(walls.length, " walls"));
+              }
+
+              // Add atmospheric fog
+              this.addHorizonFog();
+              logger.info('Environment initialization complete'); // Force material refresh to ensure textures are applied correctly
+              this.forceRefreshMaterials();
+
+              // Force renderer refresh
+              if (component.renderer && component.scene && component.camera) {
+                component.renderer.render(component.scene, component.camera);
+                console.log('🔄 Forced initial render to refresh scene');
+
+                // Schedule another render after a short delay to catch any async texture loading
+                setTimeout(function () {
+                  if (component.renderer && !component.isDestroyed) {
+                    _this2.forceRefreshMaterials();
+                    component.renderer.render(component.scene, component.camera);
+                    console.log('🔄 Performed delayed render to catch async texture loads');
+                  }
+                }, 1000);
+              }
+            case 11:
               return _context5.a(2);
           }
         }, _callee3, this, [[1, 4]]);
@@ -718,74 +836,149 @@ var EnvironmentManager = /*#__PURE__*/function () {
       }
       return initializeEnvironment;
     }()
-    /**
-     * Add textured ground with materials from textureConfig
+    /**
+     * Add textured ground with materials from textureConfig
      */
     )
   }, {
     key: "addTexturedGround",
     value: (function () {
       var _addTexturedGround = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee4() {
-        var component, groundMaterial, groundGeometry, ground, _t8;
+        var component, groundMaterial, debugMaterial, groundGeometry, ground, debugGround, errorGeometry, errorMaterial, errorGround, _t8;
         return _regenerator().w(function (_context6) {
           while (1) switch (_context6.n) {
             case 0:
-              if (loadTextureSetAndCreateMaterial) {
-                _context6.n = 1;
+              if (textureConfig.loadTextureSetAndCreateMaterial) {
+                _context6.n = 2;
                 break;
               }
+              console.log('🔄 TextureConfig module not yet loaded, importing now...');
               _context6.n = 1;
               return importTextureConfig();
             case 1:
+              if (textureConfig.loadTextureSetAndCreateMaterial) {
+                _context6.n = 2;
+                break;
+              }
+              console.error('❌ Failed to load textureConfig module, falling back to basic ground');
+              return _context6.a(2, this.createGround());
+            case 2:
               component = this.component;
               if (!(!component || !component.scene)) {
-                _context6.n = 2;
+                _context6.n = 3;
                 break;
               }
               logger.warn('Cannot create textured ground: component or scene not available');
               return _context6.a(2, null);
-            case 2:
+            case 3:
+              // Force texture loading with crossOrigin support
+              if (!component.textureLoader) {
+                console.log('🔄 Creating texture loader in component');
+                component.textureLoader = new THREE.TextureLoader();
+                component.textureLoader.setCrossOrigin('anonymous');
+              }
+
               // Remove existing ground if present
               component.scene.traverse(function (object) {
                 if (object.userData && object.userData.type === 'ground') {
                   component.scene.remove(object);
                 }
               });
-              _context6.p = 3;
-              _context6.n = 4;
-              return loadTextureSetAndCreateMaterial(component, 'gravel_embedded_concrete');
-            case 4:
+              _context6.p = 4;
+              console.log('🌍 Creating textured ground plane...');
+              // Use the gravel_embedded_concrete texture set
+              console.log('🔄 Loading ground material textures...');
+              _context6.n = 5;
+              return textureConfig.loadTextureSetAndCreateMaterial(component, 'gravel_embedded_concrete');
+            case 5:
               groundMaterial = _context6.v;
-              groundGeometry = new THREE.PlaneGeometry(100, 100);
+              if (groundMaterial) {
+                _context6.n = 6;
+                break;
+              }
+              throw new Error('Failed to create ground material');
+            case 6:
+              console.log('✅ Ground material created');
+
+              // First create a colored material to verify the mesh creation works
+              debugMaterial = new THREE.MeshBasicMaterial({
+                color: 0x22ff22,
+                // Bright green for visibility 
+                wireframe: false,
+                side: THREE.DoubleSide
+              }); // Create a composite ground with both materials
+              groundGeometry = new THREE.PlaneGeometry(100, 100); // Create the main ground mesh
               ground = new THREE.Mesh(groundGeometry, groundMaterial);
               ground.rotation.x = -Math.PI / 2; // Rotate to be horizontal
               ground.position.y = -0.01; // Slightly below origin
               ground.receiveShadow = true;
 
+              // Create a debug ground mesh slightly below the main ground
+              debugGround = new THREE.Mesh(groundGeometry, debugMaterial);
+              debugGround.rotation.x = -Math.PI / 2;
+              debugGround.position.y = -0.02; // Below the main ground
+              debugGround.visible = false; // Hide by default
+
               // Set user data for identification
               ground.userData = {
                 isEnvironmentObject: true,
+                isBaseGround: true,
                 type: 'ground'
               };
+              debugGround.userData = {
+                isEnvironmentObject: true,
+                type: 'ground-debug'
+              };
+
+              // Add both to scene
               component.scene.add(ground);
+              component.scene.add(debugGround);
+
+              // Log some properties about the created ground
+              console.log('🌍 Textured ground created with properties:', {
+                material: groundMaterial.type,
+                hasMap: !!groundMaterial.map,
+                hasNormalMap: !!groundMaterial.normalMap,
+                hasRoughnessMap: !!groundMaterial.roughnessMap,
+                hasMetalnessMap: !!groundMaterial.metalnessMap,
+                hasAoMap: !!groundMaterial.aoMap,
+                hasBumpMap: !!groundMaterial.bumpMap,
+                materialColor: groundMaterial.color ? "#".concat(groundMaterial.color.getHexString()) : 'none'
+              });
               logger.info('Textured ground created');
               return _context6.a(2, ground);
-            case 5:
-              _context6.p = 5;
+            case 7:
+              _context6.p = 7;
               _t8 = _context6.v;
               logger.error('Error creating textured ground:', _t8);
-              // Fallback to simple ground
-              return _context6.a(2, this.createGround());
+              // Create a bright colored ground so it's obvious something was wrong
+              errorGeometry = new THREE.PlaneGeometry(100, 100);
+              errorMaterial = new THREE.MeshBasicMaterial({
+                color: 0xff0000,
+                wireframe: true,
+                side: THREE.DoubleSide
+              });
+              errorGround = new THREE.Mesh(errorGeometry, errorMaterial);
+              errorGround.rotation.x = -Math.PI / 2;
+              errorGround.position.y = -0.01;
+              errorGround.userData = {
+                isEnvironmentObject: true,
+                isBaseGround: true,
+                type: 'ground-error'
+              };
+              component.scene.add(errorGround);
+              console.error('⚠️ Fallback to error ground (red wireframe) due to texture loading failure:', _t8);
+              return _context6.a(2, errorGround);
           }
-        }, _callee4, this, [[3, 5]]);
+        }, _callee4, this, [[4, 7]]);
       }));
       function addTexturedGround() {
         return _addTexturedGround.apply(this, arguments);
       }
       return addTexturedGround;
     }()
-    /**
-     * Add brick walls with materials from textureConfig
+    /**
+     * Add brick walls with materials from textureConfig
      */
     )
   }, {
@@ -796,31 +989,41 @@ var EnvironmentManager = /*#__PURE__*/function () {
         return _regenerator().w(function (_context7) {
           while (1) switch (_context7.n) {
             case 0:
-              if (loadTextureSetAndCreateMaterial) {
-                _context7.n = 1;
+              if (textureConfig.loadTextureSetAndCreateMaterial) {
+                _context7.n = 2;
                 break;
               }
+              console.log('🔄 TextureConfig module not yet loaded for brick walls, importing now...');
               _context7.n = 1;
               return importTextureConfig();
             case 1:
+              if (textureConfig.loadTextureSetAndCreateMaterial) {
+                _context7.n = 2;
+                break;
+              }
+              console.error('❌ Failed to load textureConfig module for brick walls');
+              return _context7.a(2, this.createWalls());
+            case 2:
               component = this.component;
               if (!(!component || !component.scene)) {
-                _context7.n = 2;
+                _context7.n = 3;
                 break;
               }
               logger.warn('Cannot create brick walls: component or scene not available');
               return _context7.a(2, []);
-            case 2:
+            case 3:
               // Remove existing walls if present
               component.scene.traverse(function (object) {
                 if (object.userData && object.userData.type === 'wall') {
                   component.scene.remove(object);
                 }
               });
-              _context7.p = 3;
-              _context7.n = 4;
-              return loadTextureSetAndCreateMaterial(component, 'brick');
-            case 4:
+              _context7.p = 4;
+              // Use the brick texture set
+              console.log('🧱 Loading brick wall material textures...');
+              _context7.n = 5;
+              return textureConfig.loadTextureSetAndCreateMaterial(component, 'brick');
+            case 5:
               wallMaterial = _context7.v;
               walls = [];
               wallHeight = 20;
@@ -860,22 +1063,22 @@ var EnvironmentManager = /*#__PURE__*/function () {
               }
               logger.info('Textured environment walls created');
               return _context7.a(2, walls);
-            case 5:
-              _context7.p = 5;
+            case 6:
+              _context7.p = 6;
               _t9 = _context7.v;
               logger.error('Error creating brick walls:', _t9);
               // Fallback to simple walls
               return _context7.a(2, this.createWalls());
           }
-        }, _callee5, this, [[3, 5]]);
+        }, _callee5, this, [[4, 6]]);
       }));
       function addBrickWalls() {
         return _addBrickWalls.apply(this, arguments);
       }
       return addBrickWalls;
     }()
-    /**
-     * Add horizon fog effect
+    /**
+     * Add horizon fog effect
      */
     )
   }, {
@@ -895,10 +1098,10 @@ var EnvironmentManager = /*#__PURE__*/function () {
       logger.info('Horizon fog applied');
     }
 
-    /**
-     * Helper to check if a texture exists locally in static directory
-     * @param {string} path - Relative path to texture in static directory
-     * @returns {Promise<boolean>}
+    /**
+     * Helper to check if a texture exists locally in static directory
+     * @param {string} path - Relative path to texture in static directory
+     * @returns {Promise<boolean>}
      */
   }, {
     key: "checkLocalTextureExists",
@@ -926,9 +1129,8 @@ var EnvironmentManager = /*#__PURE__*/function () {
                   return resolve(false);
                 };
 
-                // Create full path relative to app root
-                var fullPath = window.location.origin + '/' + path;
-                img.src = fullPath;
+                // Use the path directly - it should already be processed by getAssetPath
+                img.src = path;
 
                 // Set a timeout in case the image load hangs
                 setTimeout(function () {
@@ -944,15 +1146,106 @@ var EnvironmentManager = /*#__PURE__*/function () {
         return _checkLocalTextureExists.apply(this, arguments);
       }
       return checkLocalTextureExists;
-    }())
+    }()
+    /**
+    * Force refresh all materials in the scene
+    * Helpful for ensuring textures are correctly displayed
+    */
+    )
+  }, {
+    key: "forceRefreshMaterials",
+    value: function forceRefreshMaterials() {
+      var component = this.component;
+      if (!component || !component.scene) {
+        logger.warn('Cannot refresh materials: component or scene not available');
+        return;
+      }
+      console.log('🔄 Forcing material refresh for all objects...');
+      var updatedMaterials = 0;
+      var textureFixes = 0;
+
+      // Import helper functions if available
+      var hasValidImageData = textureConfig.hasValidImageData || function (texture) {
+        return texture && texture.image;
+      };
+      var createPlaceholderTexture = textureConfig.createPlaceholderTexture || function () {
+        return null;
+      };
+
+      // Traverse all meshes in the scene
+      component.scene.traverse(function (object) {
+        if (object.isMesh && object.material) {
+          // Handle both single materials and material arrays
+          var materials = Array.isArray(object.material) ? object.material : [object.material];
+          materials.forEach(function (material) {
+            if (material) {
+              // Update material properties
+              material.needsUpdate = true;
+
+              // Ensure color values are properly set
+              if (material.color) {
+                if (typeof material.color.convertSRGBToLinear === 'function') {
+                  material.color.convertSRGBToLinear();
+                }
+              }
+
+              // Check for maps and ensure they're correctly configured
+              var maps = ['map', 'normalMap', 'roughnessMap', 'metalnessMap', 'aoMap', 'bumpMap'];
+              maps.forEach(function (mapType) {
+                var map = material[mapType];
+                if (map) {
+                  // Check if this texture might trigger the warning
+                  var hasValidData = hasValidImageData(map);
+                  if (!hasValidData) {
+                    console.warn("\u26A0\uFE0F Found texture without valid image data in ".concat(mapType, " for object ").concat(object.name || object.uuid));
+
+                    // Create and use a placeholder texture for now
+                    if (createPlaceholderTexture) {
+                      var placeholderColor = mapType === 'normalMap' ? 0x8080ff : 0xcccccc;
+                      var placeholder = createPlaceholderTexture(placeholderColor);
+                      if (placeholder) {
+                        material[mapType] = placeholder;
+                        textureFixes++;
+                        console.log("\uD83D\uDD04 Replaced missing image texture with placeholder for ".concat(mapType));
+                      }
+                    }
+                  } else {
+                    map.needsUpdate = true;
+
+                    // Ensure correct color space for diffuse maps
+                    if (mapType === 'map' && map.colorSpace !== undefined) {
+                      map.colorSpace = THREE.SRGBColorSpace;
+                    } else if (mapType === 'map' && map.encoding !== undefined) {
+                      map.encoding = THREE.sRGBEncoding;
+                    }
+                  }
+                }
+              });
+              updatedMaterials++;
+            }
+          });
+        }
+      });
+
+      // Use the dedicated function from textureConfig if available
+      if (textureConfig.forceUpdateMaterials) {
+        textureConfig.forceUpdateMaterials(component.scene);
+      }
+      console.log("\u2705 Refreshed ".concat(updatedMaterials, " materials, fixed ").concat(textureFixes, " texture warnings"));
+
+      // Force a renderer update if possible
+      if (component.renderer && component.camera) {
+        component.renderer.render(component.scene, component.camera);
+      }
+    }
   }]);
 }();
 
 // Create a singleton instance
 var environmentManager = null;
 
-/**
- * Get the global environment manager instance
+/**
+ * Get the global environment manager instance
  */
 function getEnvironmentManager() {
   var component = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;