Merge pull request #5 from KBLLR/codex/implement-stage-and-lighting-manager

Implement stage and lighting managers

Author: KBLLR

src/core/managers/LightingManager.js

@@ -0,0 +1,65 @@
+import { LightHandler } from './handlers/LightHandler';
+
+// LightingManager manages creation and lifecycle of lights within a scene.
+export class LightingManager {
+  constructor(scene = null) {
+    this.scene = scene;
+    this.handler = new LightHandler();
+    this.lights = new Map();
+  }
+
+  setScene(scene) {
+    this.scene = scene;
+  }
+
+  /**
+   * Add a light of a registered type to the current scene.
+   * @param {string} name - Unique identifier for the light instance.
+   * @param {string} type - Registered light type handled by LightHandler.
+   * @param {object} params - Optional debug parameters to override defaults.
+   */
+  addLight(name, type, params = {}) {
+    const template = this.handler.get(type);
+    if (!template) throw new Error(`Unknown light type: ${type}`);
+
+    const light = template.clone ? template.clone() : template;
+    if (light.debugObject) {
+      Object.assign(light.debugObject, params);
+      if (light.updateFromDebug) {
+        light.updateFromDebug();
+      }
+    }
+
+    this.lights.set(name, light);
+    if (this.scene) {
+      this.scene.add(light);
+    }
+    return light;
+  }
+
+  removeLight(name) {
+    const light = this.lights.get(name);
+    if (!light) return;
+    if (this.scene) {
+      this.scene.remove(light);
+    }
+    if (light.dispose) {
+      light.dispose();
+    }
+    this.lights.delete(name);
+  }
+
+  update() {
+    this.lights.forEach((light) => {
+      light.updateFromDebug?.();
+    });
+  }
+
+  dispose() {
+    this.lights.forEach((light) => {
+      if (light.dispose) light.dispose();
+    });
+    this.lights.clear();
+    this.handler.dispose();
+  }
+}

src/core/managers/StageManager.js

@@ -0,0 +1,76 @@
+import { SceneManager } from './SceneManager';
+import { CameraManager } from './CameraManager';
+import { ComponentManager } from './ComponentManager';
+import { EnvironmentManager } from './EnvironmentManager';
+import { LightingManager } from './LightingManager';
+
+// StageManager ties together the lower level managers to provide
+// a simple interface for creating and controlling a complete stage.
+export class StageManager {
+  constructor(renderer, container) {
+    this.renderer = renderer;
+    this.container = container;
+
+    this.sceneManager = new SceneManager(renderer);
+    this.cameraManager = new CameraManager(renderer, container);
+    this.componentManager = new ComponentManager();
+
+    this.environmentManager = null;
+    this.lightingManager = null;
+  }
+
+  /**
+   * Create a new stage (scene) and set up environment and lighting managers.
+   */
+  createStage(name, options = {}) {
+    const scene = this.sceneManager.createScene(name, options);
+
+    this.environmentManager = new EnvironmentManager(this.renderer, scene);
+    this.lightingManager = new LightingManager(scene);
+
+    this.sceneManager.setManagers(
+      this.environmentManager,
+      this.cameraManager,
+      this.componentManager,
+    );
+
+    return scene;
+  }
+
+  /**
+   * Set the active stage for rendering.
+   */
+  setActiveStage(name) {
+    this.sceneManager.setActiveScene(name);
+    if (this.lightingManager) {
+      this.lightingManager.setScene(this.sceneManager.activeScene);
+    }
+  }
+
+  /** Add an object to the active stage. */
+  addToStage(object) {
+    if (this.sceneManager.activeScene) {
+      this.sceneManager.activeScene.add(object);
+    }
+  }
+
+  /** Update all managers each frame. */
+  update(deltaTime) {
+    this.sceneManager.update(deltaTime);
+    this.lightingManager?.update();
+  }
+
+  /** Handle resize events. */
+  resize(width, height) {
+    this.cameraManager.updateAspect(width, height);
+    this.renderer.setSize(width, height);
+  }
+
+  /** Dispose of all resources. */
+  dispose() {
+    this.lightingManager?.dispose();
+    this.environmentManager?.dispose();
+    this.componentManager.dispose();
+    this.sceneManager.dispose();
+  }
+}