@2112-lab/central-plant 0.1.0

package/dist/esm/src/environmentManager.js

@@ -0,0 +1,989 @@
+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 * as THREE from 'three';
+import { logger } from './debugLogger.js';
+
+// We'll need to import RGBELoader from three examples
+var RGBELoader;
+
+// Dynamic import for browser compatibility
+function importThreeLoaders() {
+  return _importThreeLoaders.apply(this, arguments);
+} // This will be imported once textureConfig is created
+function _importThreeLoaders() {
+  _importThreeLoaders = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee8() {
+    var module, _t0;
+    return _regenerator().w(function (_context0) {
+      while (1) switch (_context0.n) {
+        case 0:
+          if (!(typeof window !== 'undefined')) {
+            _context0.n = 4;
+            break;
+          }
+          _context0.p = 1;
+          console.log('📦 Attempting to dynamically import RGBELoader...');
+          // Dynamic import for browser
+          _context0.n = 2;
+          return import('../node_modules/three/examples/jsm/loaders/RGBELoader.js');
+        case 2:
+          module = _context0.v;
+          RGBELoader = module.RGBELoader;
+          console.log('✅ RGBELoader imported successfully:', RGBELoader ? 'Available' : 'Undefined');
+          return _context0.a(2, true);
+        case 3:
+          _context0.p = 3;
+          _t0 = _context0.v;
+          console.error('Failed to load Three.js loaders:', _t0);
+          throw new Error('Failed to load Three.js loaders');
+        case 4:
+          return _context0.a(2, false);
+      }
+    }, _callee8, null, [[1, 3]]);
+  }));
+  return _importThreeLoaders.apply(this, arguments);
+}
+var loadTextureSetAndCreateMaterial;
+function importTextureConfig() {
+  return _importTextureConfig.apply(this, arguments);
+}
+function _importTextureConfig() {
+  _importTextureConfig = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee9() {
+    var module, _t1;
+    return _regenerator().w(function (_context1) {
+      while (1) switch (_context1.n) {
+        case 0:
+          if (!(typeof window !== 'undefined')) {
+            _context1.n = 4;
+            break;
+          }
+          _context1.p = 1;
+          console.log('📦 Attempting to dynamically import textureConfig...');
+          _context1.n = 2;
+          return import('./textureConfig.js');
+        case 2:
+          module = _context1.v;
+          loadTextureSetAndCreateMaterial = module.loadTextureSetAndCreateMaterial;
+          console.log('✅ TextureConfig imported successfully:', loadTextureSetAndCreateMaterial ? 'Available' : 'Undefined');
+          return _context1.a(2, true);
+        case 3:
+          _context1.p = 3;
+          _t1 = _context1.v;
+          console.error('Failed to load texture config:', _t1);
+          return _context1.a(2, false);
+        case 4:
+          return _context1.a(2, false);
+      }
+    }, _callee9, null, [[1, 3]]);
+  }));
+  return _importTextureConfig.apply(this, arguments);
+}
+var EnvironmentManager = /*#__PURE__*/function () {
+  function EnvironmentManager(component) {
+    _classCallCheck(this, EnvironmentManager);
+    this.component = component;
+
+    // Track loader status
+    this.loadersInitialized = false;
+
+    // Initialize loaders immediately 
+    this.initLoaders();
+  }
+  return _createClass(EnvironmentManager, [{
+    key: "initLoaders",
+    value: function () {
+      var _initLoaders = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee() {
+        var _t;
+        return _regenerator().w(function (_context) {
+          while (1) switch (_context.n) {
+            case 0:
+              console.log('🔄 Pre-initializing loaders in EnvironmentManager constructor...');
+              _context.p = 1;
+              _context.n = 2;
+              return Promise.all([importThreeLoaders(), importTextureConfig()]);
+            case 2:
+              this.loadersInitialized = true;
+              console.log('✅ EnvironmentManager loaders pre-initialized successfully');
+              _context.n = 4;
+              break;
+            case 3:
+              _context.p = 3;
+              _t = _context.v;
+              console.warn('⚠️ Error pre-initializing loaders:', _t);
+            case 4:
+              return _context.a(2);
+          }
+        }, _callee, this, [[1, 3]]);
+      }));
+      function initLoaders() {
+        return _initLoaders.apply(this, arguments);
+      }
+      return initLoaders;
+    }()
+    /**
+     * 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;
+        return _regenerator().w(function (_context4) {
+          while (1) switch (_context4.n) {
+            case 0:
+              component = this.component;
+              if (!(!component || !component.renderer || !component.scene)) {
+                _context4.n = 1;
+                break;
+              }
+              logger.warn('Cannot create skybox: component, renderer or scene not available');
+              return _context4.a(2);
+            case 1:
+              console.log('🌍 Starting skybox creation process...');
+
+              // Make sure RGBELoader is available
+              if (RGBELoader) {
+                _context4.n = 5;
+                break;
+              }
+              console.log('⏳ RGBELoader not loaded yet, initializing now...');
+              _context4.p = 2;
+              _context4.n = 3;
+              return importThreeLoaders();
+            case 3:
+              console.log('✅ RGBELoader loaded on demand');
+              _context4.n = 5;
+              break;
+            case 4:
+              _context4.p = 4;
+              _t4 = _context4.v;
+              console.error('❌ Failed to load RGBELoader:', _t4);
+              this.createFallbackEnvironment();
+              return _context4.a(2);
+            case 5:
+              _context4.p = 5;
+              // Check if renderer is valid - safely check for context loss
+              isContextLost = component.renderer.context && typeof component.renderer.context.isContextLost === 'function' ? component.renderer.context.isContextLost() : false;
+              console.log('🔍 WebGL context check:', isContextLost ? 'Context lost' : 'Context valid');
+              if (!(!component.renderer.capabilities || isContextLost)) {
+                _context4.n = 6;
+                break;
+              }
+              logger.warn('WebGL context is lost or invalid, using fallback environment');
+              this.createFallbackEnvironment();
+              return _context4.a(2);
+            case 6:
+              _context4.p = 6;
+              pmremGenerator = new THREE.PMREMGenerator(component.renderer);
+
+              // Check if the generator was created successfully
+              if (pmremGenerator) {
+                _context4.n = 7;
+                break;
+              }
+              throw new Error('PMREMGenerator could not be created');
+            case 7:
+              // Attempt to compile the shader - this can fail if the context is limited
+              pmremGenerator.compileEquirectangularShader();
+              _context4.n = 9;
+              break;
+            case 8:
+              _context4.p = 8;
+              _t5 = _context4.v;
+              logger.warn('Failed to initialize PMREMGenerator:', _t5);
+              this.createFallbackEnvironment();
+              return _context4.a(2);
+            case 9:
+              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']
+              }, {
+                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']
+              }]; // Configure texture loaders with CORS settings
+              loaders.forEach(function (_ref) {
+                var loader = _ref.loader;
+                if (loader && typeof loader.setCrossOrigin === 'function') {
+                  loader.setCrossOrigin('anonymous');
+                }
+              });
+              console.log('🔄 Configured loaders with CORS settings and fallback paths');
+              applyEnvironmentMap = function applyEnvironmentMap(envTexture, type) {
+                try {
+                  var _component$scene$envi, _component$scene$back;
+                  // Set proper mapping
+                  envTexture.mapping = THREE.EquirectangularReflectionMapping;
+                  // Ensure a valid color space is set for the texture
+                  if (envTexture.colorSpace !== undefined) {
+                    // For Three.js >= r152 (current version)
+                    envTexture.colorSpace = component.renderer.outputColorSpace || THREE.SRGBColorSpace;
+                  } else if (envTexture.encoding !== undefined) {
+                    // For older versions (legacy support)
+                    envTexture.encoding = component.renderer.outputEncoding || THREE.sRGBEncoding;
+                  }
+
+                  // Generate processed environment map
+                  var processedEnvMap = pmremGenerator.fromEquirectangular(envTexture).texture;
+
+                  // Diagnostic logging
+                  logger.info("Generating environment map:\n            - Type: ".concat(type, "\n            - Texture valid: ").concat(envTexture !== null, "\n            - Processed map valid: ").concat(processedEnvMap !== null, "\n            - Renderer encoding: ").concat(component.renderer.outputEncoding || component.renderer.outputColorSpace, "\n            - Texture encoding: ").concat(envTexture.encoding || envTexture.colorSpace));
+
+                  // Clean up previous environment/background
+                  if ((_component$scene$envi = component.scene.environment) !== null && _component$scene$envi !== void 0 && _component$scene$envi.dispose) component.scene.environment.dispose();
+                  if ((_component$scene$back = component.scene.background) !== null && _component$scene$back !== void 0 && _component$scene$back.dispose) component.scene.background.dispose();
+
+                  // Apply to scene
+                  component.scene.environment = processedEnvMap;
+                  component.scene.background = processedEnvMap;
+
+                  // Clean up original texture
+                  envTexture.dispose();
+
+                  // Force a renderer update
+                  if (component.renderer) {
+                    component.renderer.toneMappingExposure = 1.0;
+                    component.renderer.render(component.scene, component.camera);
+                  }
+                  logger.info("Environment map (".concat(type, ") applied successfully"));
+                  return true;
+                } catch (error) {
+                  logger.warn("Failed to apply ".concat(type, " environment map:"), error);
+                  return false;
+                }
+              };
+              _loop = /*#__PURE__*/_regenerator().m(function _loop() {
+                var _loaders$_i, type, loader, paths, _iterator, _step, _loop2, _ret2, _t3;
+                return _regenerator().w(function (_context3) {
+                  while (1) switch (_context3.n) {
+                    case 0:
+                      _loaders$_i = _loaders[_i], type = _loaders$_i.type, loader = _loaders$_i.loader, paths = _loaders$_i.paths;
+                      _iterator = _createForOfIteratorHelper(paths);
+                      _context3.p = 1;
+                      _loop2 = /*#__PURE__*/_regenerator().m(function _loop2() {
+                        var path, exists, texture, _t2;
+                        return _regenerator().w(function (_context2) {
+                          while (1) switch (_context2.n) {
+                            case 0:
+                              path = _step.value;
+                              _context2.p = 1;
+                              if (!path.startsWith('/')) {
+                                _context2.n = 3;
+                                break;
+                              }
+                              _context2.n = 2;
+                              return _this.checkLocalTextureExists(path);
+                            case 2:
+                              exists = _context2.v;
+                              console.log("\uD83D\uDD0D Local texture check for ".concat(path, ": ").concat(exists ? 'Available' : 'Not found'));
+                              if (exists) {
+                                _context2.n = 3;
+                                break;
+                              }
+                              return _context2.a(2, 0);
+                            case 3:
+                              logger.info("Attempting to load ".concat(type, " texture: ").concat(path));
+                              _context2.n = 4;
+                              return new Promise(function (resolve, reject) {
+                                var timeout = setTimeout(function () {
+                                  return reject(new Error("Timeout loading ".concat(path)));
+                                }, 10000);
+
+                                // Add event listeners for better diagnostics
+                                var onProgress = function onProgress(event) {
+                                  if (event.lengthComputable) {
+                                    var percentComplete = event.loaded / event.total * 100;
+                                    console.log("Loading ".concat(path, ": ").concat(Math.round(percentComplete), "% complete"));
+                                  }
+                                };
+                                loader.load(path, function (tex) {
+                                  clearTimeout(timeout);
+                                  console.log("\u2705 Successfully loaded ".concat(type, " texture: ").concat(path));
+                                  resolve(tex);
+                                }, onProgress, function (err) {
+                                  clearTimeout(timeout);
+                                  console.warn("\u274C Failed to load ".concat(path, ":"), err.message);
+                                  reject(err);
+                                });
+                              });
+                            case 4:
+                              texture = _context2.v;
+                              if (!applyEnvironmentMap(texture, type)) {
+                                _context2.n = 5;
+                                break;
+                              }
+                              pmremGenerator.dispose();
+                              return _context2.a(2, {
+                                v: {
+                                  v: void 0
+                                }
+                              });
+                            case 5:
+                              _context2.n = 7;
+                              break;
+                            case 6:
+                              _context2.p = 6;
+                              _t2 = _context2.v;
+                              logger.warn("Failed to load ".concat(path, ":"), _t2.message);
+                            case 7:
+                              return _context2.a(2);
+                          }
+                        }, _loop2, null, [[1, 6]]);
+                      });
+                      _iterator.s();
+                    case 2:
+                      if ((_step = _iterator.n()).done) {
+                        _context3.n = 6;
+                        break;
+                      }
+                      return _context3.d(_regeneratorValues(_loop2()), 3);
+                    case 3:
+                      _ret2 = _context3.v;
+                      if (!(_ret2 === 0)) {
+                        _context3.n = 4;
+                        break;
+                      }
+                      return _context3.a(3, 5);
+                    case 4:
+                      if (!_ret2) {
+                        _context3.n = 5;
+                        break;
+                      }
+                      return _context3.a(2, _ret2.v);
+                    case 5:
+                      _context3.n = 2;
+                      break;
+                    case 6:
+                      _context3.n = 8;
+                      break;
+                    case 7:
+                      _context3.p = 7;
+                      _t3 = _context3.v;
+                      _iterator.e(_t3);
+                    case 8:
+                      _context3.p = 8;
+                      _iterator.f();
+                      return _context3.f(8);
+                    case 9:
+                      return _context3.a(2);
+                  }
+                }, _loop, null, [[1, 7, 8, 9]]);
+              });
+              _i = 0, _loaders = loaders;
+            case 10:
+              if (!(_i < _loaders.length)) {
+                _context4.n = 13;
+                break;
+              }
+              return _context4.d(_regeneratorValues(_loop()), 11);
+            case 11:
+              _ret = _context4.v;
+              if (!_ret) {
+                _context4.n = 12;
+                break;
+              }
+              return _context4.a(2, _ret.v);
+            case 12:
+              _i++;
+              _context4.n = 10;
+              break;
+            case 13:
+              // If we reached here, all texture attempts failed - use procedural sky
+              this.createProceduralSky(pmremGenerator);
+              _context4.n = 15;
+              break;
+            case 14:
+              _context4.p = 14;
+              _t6 = _context4.v;
+              logger.error('Error creating skybox:', _t6);
+              this.createFallbackEnvironment();
+            case 15:
+              return _context4.a(2);
+          }
+        }, _callee2, this, [[6, 8], [5, 14], [2, 4]]);
+      }));
+      function createSkybox() {
+        return _createSkybox.apply(this, arguments);
+      }
+      return createSkybox;
+    }()
+    /**
+     * Create a fallback environment when renderer issues occur
+     */
+    )
+  }, {
+    key: "createFallbackEnvironment",
+    value: function createFallbackEnvironment() {
+      var component = this.component;
+      if (!component || !component.scene) return;
+      logger.info('Creating basic fallback environment');
+      // Add simple ambient and directional light
+      var ambientLight = new THREE.AmbientLight(0xffffff, 0.6);
+      component.scene.add(ambientLight);
+      var directionalLight = new THREE.DirectionalLight(0xffffff, 0.8);
+      directionalLight.position.set(1, 2, 3);
+      component.scene.add(directionalLight);
+
+      // Set a simple background color
+      component.scene.background = new THREE.Color(0x87CEEB);
+    }
+
+    /**
+     * Create procedural sky when textures fail to load
+     */
+  }, {
+    key: "createProceduralSky",
+    value: function createProceduralSky(pmremGenerator) {
+      var component = this.component;
+      if (!component || !component.scene) return;
+      logger.info('Using procedural sky fallback');
+      var ambientLight = new THREE.AmbientLight(0xffffff, 0.6);
+      component.scene.add(ambientLight);
+
+      // Add a directional light for better illumination
+      var directionalLight = new THREE.DirectionalLight(0xffffff, 0.8);
+      directionalLight.position.set(1, 1, 1);
+      component.scene.add(directionalLight);
+      try {
+        // Only attempt PMREM generation if we have a valid pmremGenerator
+        if (pmremGenerator && typeof pmremGenerator.fromScene === 'function') {
+          var skyScene = new THREE.Scene();
+          skyScene.add(new THREE.HemisphereLight(0x87CEEB, 0x444477, 1));
+
+          // Generate environment map from scene
+          var envMap = pmremGenerator.fromScene(skyScene);
+          if (envMap && envMap.texture) {
+            component.scene.environment = envMap.texture;
+          }
+        }
+
+        // Always set a background color as fallback
+        component.scene.background = new THREE.Color(0x87CEEB);
+      } catch (error) {
+        logger.warn('Failed to create procedural sky, using simple background', error);
+        component.scene.background = new THREE.Color(0x87CEEB);
+      } finally {
+        if (pmremGenerator && typeof pmremGenerator.dispose === 'function') {
+          pmremGenerator.dispose();
+        }
+      }
+    }
+
+    /**
+     * Setup scene lighting
+     */
+  }, {
+    key: "setupLighting",
+    value: function setupLighting() {
+      var component = this.component;
+      if (!component || !component.scene) {
+        logger.warn('Cannot setup lighting: component or scene not available');
+        return;
+      }
+
+      // Remove existing lights first
+      var existingLights = [];
+      component.scene.traverse(function (object) {
+        if (object instanceof THREE.Light) {
+          existingLights.push(object);
+        }
+      });
+      existingLights.forEach(function (light) {
+        component.scene.remove(light);
+      });
+
+      // Main directional light (sun)
+      var directionalLight = new THREE.DirectionalLight(0xffffff, 0.8);
+      directionalLight.position.set(5, 10, 7);
+      directionalLight.castShadow = true;
+
+      // Optimize shadow map
+      directionalLight.shadow.mapSize.width = 1024;
+      directionalLight.shadow.mapSize.height = 1024;
+      directionalLight.shadow.camera.near = 1;
+      directionalLight.shadow.camera.far = 30;
+      directionalLight.shadow.camera.left = -10;
+      directionalLight.shadow.camera.right = 10;
+      directionalLight.shadow.camera.top = 10;
+      directionalLight.shadow.camera.bottom = -10;
+      directionalLight.shadow.bias = -0.001;
+      component.scene.add(directionalLight);
+
+      // Ambient light for general illumination
+      var ambientLight = new THREE.AmbientLight(0xffffff, 0.3);
+      component.scene.add(ambientLight);
+
+      // Hemisphere light to simulate sky/ground reflection
+      var hemisphereLight = new THREE.HemisphereLight(0xffffff, 0x444477, 0.3);
+      component.scene.add(hemisphereLight);
+      logger.info('Scene lighting setup complete');
+    }
+
+    /**
+     * Create ground plane
+     */
+  }, {
+    key: "createGround",
+    value: function createGround() {
+      var component = this.component;
+      if (!component || !component.scene) {
+        logger.warn('Cannot create ground: component or scene not available');
+        return null;
+      }
+
+      // Create a ground plane
+      var groundGeometry = new THREE.PlaneGeometry(100, 100);
+      var groundMaterial = new THREE.MeshStandardMaterial({
+        color: 0xcccccc,
+        roughness: 0.8,
+        metalness: 0.2,
+        side: THREE.DoubleSide
+      });
+      var 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;
+
+      // Set user data for identification
+      ground.userData = {
+        isEnvironmentObject: true,
+        type: 'ground'
+      };
+      component.scene.add(ground);
+      logger.info('Ground plane created');
+      return ground;
+    }
+
+    /**
+     * Create walls for the environment
+     */
+  }, {
+    key: "createWalls",
+    value: function createWalls() {
+      var component = this.component;
+      if (!component || !component.scene) {
+        logger.warn('Cannot create walls: component or scene not available');
+        return [];
+      }
+      var walls = [];
+      var wallHeight = 20;
+      var roomSize = 50;
+      var wallThickness = 1;
+      var wallColor = 0xdddddd;
+
+      // Wall materials
+      var wallMaterial = new THREE.MeshStandardMaterial({
+        color: wallColor,
+        roughness: 0.9,
+        metalness: 0.1,
+        side: THREE.DoubleSide
+      });
+
+      // Create walls (north, east, south, west)
+      var wallGeometries = [new THREE.BoxGeometry(roomSize, wallHeight, wallThickness),
+      // North
+      new THREE.BoxGeometry(wallThickness, wallHeight, roomSize),
+      // East
+      new THREE.BoxGeometry(roomSize, wallHeight, wallThickness),
+      // South
+      new THREE.BoxGeometry(wallThickness, wallHeight, roomSize) // West
+      ];
+      var wallPositions = [[0, wallHeight / 2, -roomSize / 2],
+      // North
+      [roomSize / 2, wallHeight / 2, 0],
+      // East
+      [0, wallHeight / 2, roomSize / 2],
+      // South
+      [-roomSize / 2, wallHeight / 2, 0] // West
+      ];
+      var wallNames = ['north-wall', 'east-wall', 'south-wall', 'west-wall'];
+
+      // Create each wall
+      for (var i = 0; i < 4; i++) {
+        var _wall$position;
+        var wall = new THREE.Mesh(wallGeometries[i], wallMaterial);
+        (_wall$position = wall.position).set.apply(_wall$position, _toConsumableArray(wallPositions[i]));
+        wall.receiveShadow = true;
+        wall.castShadow = true;
+
+        // Set user data for identification
+        wall.userData = {
+          isEnvironmentObject: true,
+          type: 'wall',
+          name: wallNames[i]
+        };
+        component.scene.add(wall);
+        walls.push(wall);
+      }
+      logger.info('Environment walls created');
+      return walls;
+    }
+
+    /**
+     * Set fog in the scene
+     */
+  }, {
+    key: "setFog",
+    value: function setFog() {
+      var color = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0xcccccc;
+      var density = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0.01;
+      var component = this.component;
+      if (!component || !component.scene) {
+        logger.warn('Cannot set fog: component or scene not available');
+        return;
+      }
+      component.scene.fog = new THREE.FogExp2(color, density);
+      logger.info('Scene fog applied');
+    }
+    /**
+     * Initialize the default environment
+     */
+  }, {
+    key: "initializeEnvironment",
+    value: (function () {
+      var _initializeEnvironment = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee3() {
+        var component, loadersReady, textureConfigReady, _t7;
+        return _regenerator().w(function (_context5) {
+          while (1) switch (_context5.n) {
+            case 0:
+              component = this.component; // Make sure loaders are initialized first
+              console.log('🚀 Initializing loaders for environment...');
+              _context5.p = 1;
+              _context5.n = 2;
+              return importThreeLoaders();
+            case 2:
+              loadersReady = _context5.v;
+              _context5.n = 3;
+              return importTextureConfig();
+            case 3:
+              textureConfigReady = _context5.v;
+              console.log('✅ Environment loaders initialized:', {
+                loaders: loadersReady ? 'Ready' : 'Failed',
+                textureConfig: textureConfigReady ? 'Ready' : 'Failed'
+              });
+              _context5.n = 5;
+              break;
+            case 4:
+              _context5.p = 4;
+              _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
+                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));
+              }
+
+              // Create skybox (includes base lighting)
+              _context5.n = 6;
+              return this.createSkybox();
+            case 6:
+              // Add additional lighting
+              this.setupLighting();
+
+              // Use textured ground instead of basic ground
+              _context5.n = 7;
+              return this.addTexturedGround();
+            case 7:
+              // No walls or fog by default
+              // await this.addBrickWalls();
+              // this.addHorizonFog();
+
+              logger.info('Environment initialization complete');
+            case 8:
+              return _context5.a(2);
+          }
+        }, _callee3, this, [[1, 4]]);
+      }));
+      function initializeEnvironment() {
+        return _initializeEnvironment.apply(this, arguments);
+      }
+      return initializeEnvironment;
+    }()
+    /**
+     * 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;
+        return _regenerator().w(function (_context6) {
+          while (1) switch (_context6.n) {
+            case 0:
+              if (loadTextureSetAndCreateMaterial) {
+                _context6.n = 1;
+                break;
+              }
+              _context6.n = 1;
+              return importTextureConfig();
+            case 1:
+              component = this.component;
+              if (!(!component || !component.scene)) {
+                _context6.n = 2;
+                break;
+              }
+              logger.warn('Cannot create textured ground: component or scene not available');
+              return _context6.a(2, null);
+            case 2:
+              // 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:
+              groundMaterial = _context6.v;
+              groundGeometry = new THREE.PlaneGeometry(100, 100);
+              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;
+
+              // Set user data for identification
+              ground.userData = {
+                isEnvironmentObject: true,
+                type: 'ground'
+              };
+              component.scene.add(ground);
+              logger.info('Textured ground created');
+              return _context6.a(2, ground);
+            case 5:
+              _context6.p = 5;
+              _t8 = _context6.v;
+              logger.error('Error creating textured ground:', _t8);
+              // Fallback to simple ground
+              return _context6.a(2, this.createGround());
+          }
+        }, _callee4, this, [[3, 5]]);
+      }));
+      function addTexturedGround() {
+        return _addTexturedGround.apply(this, arguments);
+      }
+      return addTexturedGround;
+    }()
+    /**
+     * Add brick walls with materials from textureConfig
+     */
+    )
+  }, {
+    key: "addBrickWalls",
+    value: (function () {
+      var _addBrickWalls = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee5() {
+        var component, wallMaterial, walls, wallHeight, roomSize, wallThickness, wallGeometries, wallPositions, wallNames, i, _wall$position2, wall, _t9;
+        return _regenerator().w(function (_context7) {
+          while (1) switch (_context7.n) {
+            case 0:
+              if (loadTextureSetAndCreateMaterial) {
+                _context7.n = 1;
+                break;
+              }
+              _context7.n = 1;
+              return importTextureConfig();
+            case 1:
+              component = this.component;
+              if (!(!component || !component.scene)) {
+                _context7.n = 2;
+                break;
+              }
+              logger.warn('Cannot create brick walls: component or scene not available');
+              return _context7.a(2, []);
+            case 2:
+              // 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:
+              wallMaterial = _context7.v;
+              walls = [];
+              wallHeight = 20;
+              roomSize = 50;
+              wallThickness = 1; // Create walls (north, east, south, west)
+              wallGeometries = [new THREE.BoxGeometry(roomSize, wallHeight, wallThickness),
+              // North
+              new THREE.BoxGeometry(wallThickness, wallHeight, roomSize),
+              // East
+              new THREE.BoxGeometry(roomSize, wallHeight, wallThickness),
+              // South
+              new THREE.BoxGeometry(wallThickness, wallHeight, roomSize) // West
+              ];
+              wallPositions = [[0, wallHeight / 2, -roomSize / 2],
+              // North
+              [roomSize / 2, wallHeight / 2, 0],
+              // East
+              [0, wallHeight / 2, roomSize / 2],
+              // South
+              [-roomSize / 2, wallHeight / 2, 0] // West
+              ];
+              wallNames = ['north-wall', 'east-wall', 'south-wall', 'west-wall']; // Create each wall
+              for (i = 0; i < 4; i++) {
+                wall = new THREE.Mesh(wallGeometries[i], wallMaterial);
+                (_wall$position2 = wall.position).set.apply(_wall$position2, _toConsumableArray(wallPositions[i]));
+                wall.receiveShadow = true;
+                wall.castShadow = true;
+
+                // Set user data for identification
+                wall.userData = {
+                  isEnvironmentObject: true,
+                  type: 'wall',
+                  name: wallNames[i]
+                };
+                component.scene.add(wall);
+                walls.push(wall);
+              }
+              logger.info('Textured environment walls created');
+              return _context7.a(2, walls);
+            case 5:
+              _context7.p = 5;
+              _t9 = _context7.v;
+              logger.error('Error creating brick walls:', _t9);
+              // Fallback to simple walls
+              return _context7.a(2, this.createWalls());
+          }
+        }, _callee5, this, [[3, 5]]);
+      }));
+      function addBrickWalls() {
+        return _addBrickWalls.apply(this, arguments);
+      }
+      return addBrickWalls;
+    }()
+    /**
+     * Add horizon fog effect
+     */
+    )
+  }, {
+    key: "addHorizonFog",
+    value: function addHorizonFog() {
+      var component = this.component;
+      if (!component || !component.scene) {
+        logger.warn('Cannot set horizon fog: component or scene not available');
+        return;
+      }
+
+      // Light blue-ish fog color
+      var fogColor = 0xd8e0ff;
+      // Less dense than the default fog
+      var fogDensity = 0.005;
+      component.scene.fog = new THREE.FogExp2(fogColor, fogDensity);
+      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>}
+     */
+  }, {
+    key: "checkLocalTextureExists",
+    value: (function () {
+      var _checkLocalTextureExists = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee6(path) {
+        return _regenerator().w(function (_context8) {
+          while (1) switch (_context8.n) {
+            case 0:
+              // Remove leading slash if present
+              if (path.startsWith('/')) {
+                path = path.substring(1);
+              }
+
+              // For browser environment
+              if (!(typeof window !== 'undefined')) {
+                _context8.n = 1;
+                break;
+              }
+              return _context8.a(2, new Promise(function (resolve) {
+                var img = new Image();
+                img.onload = function () {
+                  return resolve(true);
+                };
+                img.onerror = function () {
+                  return resolve(false);
+                };
+
+                // Create full path relative to app root
+                var fullPath = window.location.origin + '/' + path;
+                img.src = fullPath;
+
+                // Set a timeout in case the image load hangs
+                setTimeout(function () {
+                  return resolve(false);
+                }, 2000);
+              }));
+            case 1:
+              return _context8.a(2, false);
+          }
+        }, _callee6);
+      }));
+      function checkLocalTextureExists(_x) {
+        return _checkLocalTextureExists.apply(this, arguments);
+      }
+      return checkLocalTextureExists;
+    }())
+  }]);
+}();
+
+// Create a singleton instance
+var environmentManager = null;
+
+/**
+ * Get the global environment manager instance
+ */
+function getEnvironmentManager() {
+  var component = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
+  if (!environmentManager || component && environmentManager.component !== component) {
+    environmentManager = new EnvironmentManager(component);
+  }
+  return environmentManager;
+}
+var environmentManager$1 = {
+  EnvironmentManager: EnvironmentManager,
+  getEnvironmentManager: getEnvironmentManager,
+  // Default initialization method for ease of use
+  initializeEnvironment: function () {
+    var _initializeEnvironment2 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee7(component) {
+      var manager;
+      return _regenerator().w(function (_context9) {
+        while (1) switch (_context9.n) {
+          case 0:
+            manager = getEnvironmentManager(component);
+            _context9.n = 1;
+            return manager.initializeEnvironment();
+          case 1:
+            return _context9.a(2, manager);
+        }
+      }, _callee7);
+    }));
+    function initializeEnvironment(_x2) {
+      return _initializeEnvironment2.apply(this, arguments);
+    }
+    return initializeEnvironment;
+  }()
+};
+
+export { EnvironmentManager, environmentManager$1 as default, getEnvironmentManager };