@zylem/game-lib 0.6.2 → 0.6.4

package/dist/camera.js

@@ -1,8 +1,8 @@
 // src/lib/camera/camera.ts
-import { Vector2 as Vector23, Vector3 as Vector34 } from "three";
+import { Vector2 as Vector23, Vector3 as Vector37 } from "three";
 
 // src/lib/camera/zylem-camera.ts
-import { PerspectiveCamera, Vector3 as Vector33, Object3D as Object3D2, OrthographicCamera, WebGLRenderer as WebGLRenderer3 } from "three";
+import { PerspectiveCamera as PerspectiveCamera2, Vector3 as Vector36, OrthographicCamera, WebGLRenderTarget as WebGLRenderTarget2, LinearFilter } from "three";
 
 // src/lib/camera/perspective.ts
 var Perspectives = {
@@ -10,207 +10,12 @@ var Perspectives = {
   ThirdPerson: "third-person",
   Isometric: "isometric",
   Flat2D: "flat-2d",
-  Fixed2D: "fixed-2d"
-};
-
-// src/lib/camera/third-person.ts
-import { Vector3 } from "three";
-var ThirdPersonCamera = class {
-  distance;
-  screenResolution = null;
-  renderer = null;
-  scene = null;
-  cameraRef = null;
-  constructor() {
-    this.distance = new Vector3(0, 5, 8);
-  }
-  /**
-   * Setup the third person camera controller
-   */
-  setup(params) {
-    const { screenResolution, renderer, scene, camera } = params;
-    this.screenResolution = screenResolution;
-    this.renderer = renderer;
-    this.scene = scene;
-    this.cameraRef = camera;
-  }
-  /**
-   * Update the third person camera
-   */
-  update(delta) {
-    if (!this.cameraRef.target) {
-      return;
-    }
-    const desiredCameraPosition = this.cameraRef.target.group.position.clone().add(this.distance);
-    this.cameraRef.camera.position.lerp(desiredCameraPosition, 0.1);
-    this.cameraRef.camera.lookAt(this.cameraRef.target.group.position);
-  }
-  /**
-   * Handle resize events
-   */
-  resize(width, height) {
-    if (this.screenResolution) {
-      this.screenResolution.set(width, height);
-    }
-  }
-  /**
-   * Set the distance from the target
-   */
-  setDistance(distance) {
-    this.distance = distance;
-  }
-};
-
-// src/lib/camera/fixed-2d.ts
-var Fixed2DCamera = class {
-  screenResolution = null;
-  renderer = null;
-  scene = null;
-  cameraRef = null;
-  constructor() {
-  }
-  /**
-   * Setup the fixed 2D camera controller
-   */
-  setup(params) {
-    const { screenResolution, renderer, scene, camera } = params;
-    this.screenResolution = screenResolution;
-    this.renderer = renderer;
-    this.scene = scene;
-    this.cameraRef = camera;
-    this.cameraRef.camera.position.set(0, 0, 10);
-    this.cameraRef.camera.lookAt(0, 0, 0);
-  }
-  /**
-   * Update the fixed 2D camera
-   * Fixed cameras don't need to update position/rotation automatically
-   */
-  update(delta) {
-  }
-  /**
-   * Handle resize events for 2D camera
-   */
-  resize(width, height) {
-    if (this.screenResolution) {
-      this.screenResolution.set(width, height);
-    }
-  }
-};
-
-// src/lib/camera/zylem-camera.ts
-import { EffectComposer } from "three/examples/jsm/postprocessing/EffectComposer.js";
-
-// src/lib/graphics/render-pass.ts
-import * as THREE from "three";
-
-// src/lib/graphics/shaders/vertex/object.shader.ts
-var objectVertexShader = `
-uniform vec2 uvScale;
-varying vec2 vUv;
-
-void main() {
-	vUv = uv;
-	vec4 mvPosition = modelViewMatrix * vec4( position, 1.0 );
-	gl_Position = projectionMatrix * mvPosition;
-}
-`;
-
-// src/lib/graphics/shaders/standard.shader.ts
-var fragment = `
-uniform sampler2D tDiffuse;
-varying vec2 vUv;
-
-void main() {
-	vec4 texel = texture2D( tDiffuse, vUv );
-
-	gl_FragColor = texel;
-}
-`;
-var standardShader = {
-  vertex: objectVertexShader,
-  fragment
-};
-
-// src/lib/graphics/render-pass.ts
-import { WebGLRenderTarget } from "three";
-import { Pass, FullScreenQuad } from "three/addons/postprocessing/Pass.js";
-var RenderPass = class extends Pass {
-  fsQuad;
-  resolution;
-  scene;
-  camera;
-  rgbRenderTarget;
-  normalRenderTarget;
-  normalMaterial;
-  constructor(resolution, scene, camera) {
-    super();
-    this.resolution = resolution;
-    this.fsQuad = new FullScreenQuad(this.material());
-    this.scene = scene;
-    this.camera = camera;
-    this.rgbRenderTarget = new WebGLRenderTarget(resolution.x * 4, resolution.y * 4);
-    this.normalRenderTarget = new WebGLRenderTarget(resolution.x * 4, resolution.y * 4);
-    this.normalMaterial = new THREE.MeshNormalMaterial();
-  }
-  render(renderer, writeBuffer) {
-    renderer.setRenderTarget(this.rgbRenderTarget);
-    renderer.render(this.scene, this.camera);
-    const overrideMaterial_old = this.scene.overrideMaterial;
-    renderer.setRenderTarget(this.normalRenderTarget);
-    this.scene.overrideMaterial = this.normalMaterial;
-    renderer.render(this.scene, this.camera);
-    this.scene.overrideMaterial = overrideMaterial_old;
-    const uniforms = this.fsQuad.material.uniforms;
-    uniforms.tDiffuse.value = this.rgbRenderTarget.texture;
-    uniforms.tDepth.value = this.rgbRenderTarget.depthTexture;
-    uniforms.tNormal.value = this.normalRenderTarget.texture;
-    uniforms.iTime.value += 0.01;
-    if (this.renderToScreen) {
-      renderer.setRenderTarget(null);
-    } else {
-      renderer.setRenderTarget(writeBuffer);
-    }
-    this.fsQuad.render(renderer);
-  }
-  material() {
-    return new THREE.ShaderMaterial({
-      uniforms: {
-        iTime: { value: 0 },
-        tDiffuse: { value: null },
-        tDepth: { value: null },
-        tNormal: { value: null },
-        resolution: {
-          value: new THREE.Vector4(
-            this.resolution.x,
-            this.resolution.y,
-            1 / this.resolution.x,
-            1 / this.resolution.y
-          )
-        }
-      },
-      vertexShader: standardShader.vertex,
-      fragmentShader: standardShader.fragment
-    });
-  }
-  dispose() {
-    try {
-      this.fsQuad?.dispose?.();
-    } catch {
-    }
-    try {
-      this.rgbRenderTarget?.dispose?.();
-      this.normalRenderTarget?.dispose?.();
-    } catch {
-    }
-    try {
-      this.normalMaterial?.dispose?.();
-    } catch {
-    }
-  }
+  Fixed2D: "fixed-2d",
+  TopDown: "top-down"
 };
 
 // src/lib/camera/camera-debug-delegate.ts
-import { Vector3 as Vector32 } from "three";
+import { Vector3 } from "three";
 import { OrbitControls } from "three/addons/controls/OrbitControls.js";
 var CameraOrbitController = class {
   camera;
@@ -219,7 +24,7 @@ var CameraOrbitController = class {
   sceneRef = null;
   orbitControls = null;
   orbitTarget = null;
-  orbitTargetWorldPos = new Vector32();
+  orbitTargetWorldPos = new Vector3();
   debugDelegate = null;
   debugUnsubscribe = null;
   debugStateSnapshot = { enabled: false, selected: [] };
@@ -233,6 +38,8 @@ var CameraOrbitController = class {
   savedDebugCameraQuaternion = null;
   savedDebugCameraZoom = null;
   savedDebugOrbitTarget = null;
+  /** Whether user-configured orbital controls are enabled (independent of debug) */
+  _userOrbitEnabled = false;
   constructor(camera, domElement, cameraRig) {
     this.camera = camera;
     this.domElement = domElement;
@@ -245,11 +52,17 @@ var CameraOrbitController = class {
     this.sceneRef = scene;
   }
   /**
-   * Check if debug mode is currently active (orbit controls enabled).
+   * Check if debug mode is currently active (orbit controls enabled via debug system).
    */
   get isActive() {
     return this.debugStateSnapshot.enabled;
   }
+  /**
+   * Check if any orbit controls are currently active (debug or user).
+   */
+  get isOrbitActive() {
+    return this.debugStateSnapshot.enabled || this._userOrbitEnabled;
+  }
   /**
    * Update orbit controls each frame.
    * Should be called from the camera's update loop.
@@ -261,6 +74,26 @@ var CameraOrbitController = class {
     }
     this.orbitControls?.update();
   }
+  /**
+   * Enable user-configured orbital controls (not debug mode).
+   * These orbit controls persist until explicitly disabled.
+   */
+  enableUserOrbitControls() {
+    this._userOrbitEnabled = true;
+    if (!this.orbitControls) {
+      this.enableOrbitControls();
+    }
+  }
+  /**
+   * Disable user-configured orbital controls.
+   * Will not disable orbit controls if debug mode is active.
+   */
+  disableUserOrbitControls() {
+    this._userOrbitEnabled = false;
+    if (!this.debugStateSnapshot.enabled) {
+      this.disableOrbitControls();
+    }
+  }
   /**
    * Attach a delegate to react to debug state changes.
    */
@@ -309,7 +142,9 @@ var CameraOrbitController = class {
     } else if (!state.enabled && wasEnabled) {
       this.saveDebugCameraState();
       this.orbitTarget = null;
-      this.disableOrbitControls();
+      if (!this._userOrbitEnabled) {
+        this.disableOrbitControls();
+      }
       this.reattachCameraToRig();
       this.restoreCameraState();
     } else if (state.enabled) {
@@ -436,7 +271,7 @@ var CameraOrbitController = class {
       return;
     }
     this.savedCameraLocalPosition = this.camera.position.clone();
-    const worldPos = new Vector32();
+    const worldPos = new Vector3();
     this.camera.getWorldPosition(worldPos);
     this.cameraRig.remove(this.camera);
     if (this.sceneRef) {
@@ -463,240 +298,1401 @@ var CameraOrbitController = class {
   }
 };
 
-// src/lib/camera/zylem-camera.ts
-var ZylemCamera = class {
-  cameraRig = null;
+// src/lib/camera/renderer-manager.ts
+import { Vector2, WebGLRenderer as WebGLRenderer2 } from "three";
+import { WebGPURenderer } from "three/webgpu";
+import { EffectComposer } from "three/examples/jsm/postprocessing/EffectComposer.js";
+
+// src/lib/graphics/render-pass.ts
+import * as THREE from "three";
+
+// src/lib/graphics/shaders/vertex/object.shader.ts
+var objectVertexShader = `
+uniform vec2 uvScale;
+varying vec2 vUv;
+
+void main() {
+	vUv = uv;
+	vec4 mvPosition = modelViewMatrix * vec4( position, 1.0 );
+	gl_Position = projectionMatrix * mvPosition;
+}
+`;
+
+// src/lib/graphics/shaders/standard.shader.ts
+var fragment = `
+uniform sampler2D tDiffuse;
+varying vec2 vUv;
+
+void main() {
+	vec4 texel = texture2D( tDiffuse, vUv );
+
+	gl_FragColor = texel;
+}
+`;
+var standardShader = {
+  vertex: objectVertexShader,
+  fragment
+};
+
+// src/lib/graphics/render-pass.ts
+import { WebGLRenderTarget } from "three";
+import { Pass, FullScreenQuad } from "three/addons/postprocessing/Pass.js";
+var RenderPass = class extends Pass {
+  fsQuad;
+  resolution;
+  scene;
   camera;
-  screenResolution;
-  renderer;
-  composer;
-  _perspective;
-  target = null;
-  sceneRef = null;
-  frustumSize = 10;
-  // Perspective controller delegation
-  perspectiveController = null;
-  // Debug/orbit controls delegation
-  orbitController = null;
-  constructor(perspective, screenResolution, frustumSize = 10) {
-    this._perspective = perspective;
-    this.screenResolution = screenResolution;
-    this.frustumSize = frustumSize;
-    this.renderer = new WebGLRenderer3({ antialias: false, alpha: true });
-    this.renderer.setSize(screenResolution.x, screenResolution.y);
-    this.renderer.shadowMap.enabled = true;
-    this.composer = new EffectComposer(this.renderer);
-    const aspectRatio = screenResolution.x / screenResolution.y;
-    this.camera = this.createCameraForPerspective(aspectRatio);
-    if (this.needsRig()) {
-      this.cameraRig = new Object3D2();
-      this.cameraRig.position.set(0, 3, 10);
-      this.cameraRig.add(this.camera);
-      this.camera.lookAt(new Vector33(0, 2, 0));
-    } else {
-      this.camera.position.set(0, 0, 10);
-      this.camera.lookAt(new Vector33(0, 0, 0));
-    }
-    this.initializePerspectiveController();
-    this.orbitController = new CameraOrbitController(this.camera, this.renderer.domElement, this.cameraRig);
-  }
-  /**
-   * Setup the camera with a scene
-   */
-  async setup(scene) {
-    this.sceneRef = scene;
-    let renderResolution = this.screenResolution.clone().divideScalar(2);
-    renderResolution.x |= 0;
-    renderResolution.y |= 0;
-    const pass = new RenderPass(renderResolution, scene, this.camera);
-    this.composer.addPass(pass);
-    if (this.perspectiveController) {
-      this.perspectiveController.setup({
-        screenResolution: this.screenResolution,
-        renderer: this.renderer,
-        scene,
-        camera: this
-      });
-    }
-    this.orbitController?.setScene(scene);
-    this.renderer.setAnimationLoop((delta) => {
-      this.update(delta || 0);
-    });
+  rgbRenderTarget;
+  normalRenderTarget;
+  normalMaterial;
+  constructor(resolution, scene, camera) {
+    super();
+    this.resolution = resolution;
+    this.fsQuad = new FullScreenQuad(this.material());
+    this.scene = scene;
+    this.camera = camera;
+    this.rgbRenderTarget = new WebGLRenderTarget(resolution.x * 4, resolution.y * 4);
+    this.normalRenderTarget = new WebGLRenderTarget(resolution.x * 4, resolution.y * 4);
+    this.normalMaterial = new THREE.MeshNormalMaterial();
   }
-  /**
-   * Update camera and render
-   */
-  update(delta) {
-    this.orbitController?.update();
-    if (this.perspectiveController && !this.isDebugModeActive()) {
-      this.perspectiveController.update(delta);
+  render(renderer, writeBuffer) {
+    renderer.setRenderTarget(this.rgbRenderTarget);
+    renderer.render(this.scene, this.camera);
+    const overrideMaterial_old = this.scene.overrideMaterial;
+    renderer.setRenderTarget(this.normalRenderTarget);
+    this.scene.overrideMaterial = this.normalMaterial;
+    renderer.render(this.scene, this.camera);
+    this.scene.overrideMaterial = overrideMaterial_old;
+    const uniforms = this.fsQuad.material.uniforms;
+    uniforms.tDiffuse.value = this.rgbRenderTarget.texture;
+    uniforms.tDepth.value = this.rgbRenderTarget.depthTexture;
+    uniforms.tNormal.value = this.normalRenderTarget.texture;
+    uniforms.iTime.value += 0.01;
+    if (this.renderToScreen) {
+      renderer.setRenderTarget(null);
+    } else {
+      renderer.setRenderTarget(writeBuffer);
+    }
+    this.fsQuad.render(renderer);
+  }
+  material() {
+    return new THREE.ShaderMaterial({
+      uniforms: {
+        iTime: { value: 0 },
+        tDiffuse: { value: null },
+        tDepth: { value: null },
+        tNormal: { value: null },
+        resolution: {
+          value: new THREE.Vector4(
+            this.resolution.x,
+            this.resolution.y,
+            1 / this.resolution.x,
+            1 / this.resolution.y
+          )
+        }
+      },
+      vertexShader: standardShader.vertex,
+      fragmentShader: standardShader.fragment
+    });
+  }
+  dispose() {
+    try {
+      this.fsQuad?.dispose?.();
+    } catch {
+    }
+    try {
+      this.rgbRenderTarget?.dispose?.();
+      this.normalRenderTarget?.dispose?.();
+    } catch {
+    }
+    try {
+      this.normalMaterial?.dispose?.();
+    } catch {
+    }
+  }
+};
+
+// src/lib/camera/renderer-manager.ts
+var DEFAULT_VIEWPORT = { x: 0, y: 0, width: 1, height: 1 };
+async function isWebGPUSupported() {
+  if (!("gpu" in navigator)) return false;
+  try {
+    const adapter = await navigator.gpu.requestAdapter();
+    return adapter !== null;
+  } catch {
+    return false;
+  }
+}
+var RendererManager = class {
+  renderer;
+  composer;
+  screenResolution;
+  rendererType;
+  _isWebGPU = false;
+  _initialized = false;
+  _sceneRef = null;
+  _lastAnimationTimestamp = null;
+  constructor(screenResolution, rendererType = "webgl") {
+    this.screenResolution = screenResolution || new Vector2(window.innerWidth, window.innerHeight);
+    this.rendererType = rendererType;
+  }
+  /**
+   * Check if the renderer has been initialized
+   */
+  get initialized() {
+    return this._initialized;
+  }
+  /**
+   * Check if using WebGPU renderer
+   */
+  get isWebGPU() {
+    return this._isWebGPU;
+  }
+  /**
+   * Initialize the renderer (must be called before rendering).
+   * Async because WebGPU requires async initialization.
+   */
+  async initRenderer() {
+    if (this._initialized) return;
+    let useWebGPU = false;
+    if (this.rendererType === "webgpu") {
+      useWebGPU = true;
+    } else if (this.rendererType === "auto") {
+      useWebGPU = await isWebGPUSupported();
+    }
+    if (useWebGPU) {
+      try {
+        this.renderer = new WebGPURenderer({ antialias: true });
+        await this.renderer.init();
+        this._isWebGPU = true;
+        console.log("RendererManager: Using WebGPU renderer");
+      } catch (e) {
+        console.warn("RendererManager: WebGPU init failed, falling back to WebGL", e);
+        this.renderer = new WebGLRenderer2({ antialias: false, alpha: true });
+        this._isWebGPU = false;
+      }
+    } else {
+      this.renderer = new WebGLRenderer2({ antialias: false, alpha: true });
+      this._isWebGPU = false;
+      console.log("RendererManager: Using WebGL renderer");
+    }
+    this.renderer.setSize(this.screenResolution.x, this.screenResolution.y);
+    if (this.renderer instanceof WebGLRenderer2) {
+      this.renderer.shadowMap.enabled = true;
+    }
+    if (!this._isWebGPU) {
+      this.composer = new EffectComposer(this.renderer);
+    }
+    this._initialized = true;
+  }
+  /**
+   * Set the current scene reference for rendering.
+   */
+  setScene(scene) {
+    this._sceneRef = scene;
+  }
+  /**
+   * Setup post-processing render pass for a camera (WebGL only).
+   */
+  setupRenderPass(scene, camera) {
+    if (this._isWebGPU || !this.composer) return;
+    if (this.composer.passes.length > 0) {
+      this.composer.passes.forEach((p) => {
+        try {
+          p.dispose?.();
+        } catch {
+        }
+      });
+      this.composer.passes.length = 0;
+    }
+    const renderResolution = this.screenResolution.clone().divideScalar(2);
+    renderResolution.x |= 0;
+    renderResolution.y |= 0;
+    const pass = new RenderPass(renderResolution, scene, camera);
+    this.composer.addPass(pass);
+  }
+  /**
+   * Start the render loop. Calls the provided callback each frame.
+   */
+  startRenderLoop(onFrame) {
+    this._lastAnimationTimestamp = null;
+    this.renderer.setAnimationLoop((timestamp) => {
+      const deltaSeconds = this._lastAnimationTimestamp === null ? 0 : Math.max(0, (timestamp - this._lastAnimationTimestamp) / 1e3);
+      this._lastAnimationTimestamp = timestamp;
+      onFrame(deltaSeconds);
+    });
+  }
+  /**
+   * Stop the render loop.
+   */
+  stopRenderLoop() {
+    this._lastAnimationTimestamp = null;
+    try {
+      this.renderer.setAnimationLoop(null);
+    } catch {
+    }
+  }
+  /**
+   * Render a scene from a single camera's perspective.
+   * Sets the viewport based on the camera's viewport config.
+   */
+  renderCamera(scene, camera) {
+    const vp = camera.viewport;
+    const w = this.screenResolution.x;
+    const h = this.screenResolution.y;
+    const pixelX = Math.floor(vp.x * w);
+    const pixelY = Math.floor(vp.y * h);
+    const pixelW = Math.floor(vp.width * w);
+    const pixelH = Math.floor(vp.height * h);
+    if (this.renderer instanceof WebGLRenderer2) {
+      this.renderer.setViewport(pixelX, pixelY, pixelW, pixelH);
+      this.renderer.setScissor(pixelX, pixelY, pixelW, pixelH);
+      this.renderer.setScissorTest(true);
+    }
+    if (this._isWebGPU) {
+      this.renderer.render(scene, camera.camera);
+    } else if (this.composer) {
+      this.composer.render(0);
+    }
+  }
+  /**
+   * Render a camera to its offscreen render target (WebGL only).
+   * Bypasses the EffectComposer since post-processing is not needed
+   * for render-to-texture output.
+   *
+   * The camera must have a non-null renderTarget.
+   */
+  renderCameraToTarget(scene, camera) {
+    if (!camera.renderTarget) return;
+    if (this.renderer instanceof WebGLRenderer2) {
+      const prevTarget = this.renderer.getRenderTarget();
+      this.renderer.setRenderTarget(camera.renderTarget);
+      this.renderer.clear();
+      this.renderer.render(scene, camera.camera);
+      this.renderer.setRenderTarget(prevTarget);
+    } else {
+      console.warn("RendererManager: Render-to-texture is not yet supported for WebGPU");
+    }
+  }
+  /**
+   * Render a scene from multiple cameras, each with their own viewport.
+   * Cameras are rendered in order (first = bottom layer, last = top layer).
+   */
+  renderCameras(scene, cameras) {
+    if (!scene || cameras.length === 0) return;
+    if (this.renderer instanceof WebGLRenderer2) {
+      this.renderer.setScissorTest(false);
+      this.renderer.clear();
+    }
+    for (const cam of cameras) {
+      this.renderCamera(scene, cam);
+    }
+    if (this.renderer instanceof WebGLRenderer2) {
+      this.renderer.setScissorTest(false);
+    }
+  }
+  /**
+   * Simple single-camera render (backwards compatible).
+   * Uses the full viewport for a single camera.
+   */
+  render(scene, camera) {
+    if (this._isWebGPU) {
+      this.renderer.render(scene, camera);
+    } else if (this.composer) {
+      this.composer.render(0);
+    }
+  }
+  /**
+   * Resize the renderer and update resolution.
+   */
+  resize(width, height) {
+    this.screenResolution.set(width, height);
+    this.renderer.setSize(width, height, false);
+    if (this.composer) {
+      this.composer.setSize(width, height);
+    }
+  }
+  /**
+   * Update renderer pixel ratio (DPR).
+   */
+  setPixelRatio(dpr) {
+    const safe = Math.max(1, Number.isFinite(dpr) ? dpr : 1);
+    this.renderer.setPixelRatio(safe);
+  }
+  /**
+   * Get the DOM element for the renderer.
+   */
+  getDomElement() {
+    return this.renderer.domElement;
+  }
+  /**
+   * Dispose renderer, composer, and related resources.
+   */
+  dispose() {
+    this.stopRenderLoop();
+    try {
+      this.composer?.passes?.forEach((p) => p.dispose?.());
+      this.composer?.dispose?.();
+    } catch {
+    }
+    try {
+      this.renderer.dispose();
+    } catch {
+    }
+    this._sceneRef = null;
+    this._initialized = false;
+  }
+};
+
+// src/lib/camera/smoothing.ts
+import { Vector3 as Vector32, Quaternion as Quaternion2, MathUtils } from "three";
+function defaultPose() {
+  return {
+    position: new Vector32(0, 0, 10),
+    rotation: new Quaternion2(),
+    fov: 75,
+    zoom: 1,
+    near: 0.1,
+    far: 1e3
+  };
+}
+function clonePose(pose) {
+  return {
+    position: pose.position.clone(),
+    rotation: pose.rotation.clone(),
+    fov: pose.fov,
+    zoom: pose.zoom,
+    near: pose.near,
+    far: pose.far,
+    lookAt: pose.lookAt?.clone()
+  };
+}
+function applyDelta(pose, delta) {
+  const result = clonePose(pose);
+  if (delta.position) {
+    result.position.add(delta.position);
+  }
+  if (delta.rotation) {
+    result.rotation.multiply(delta.rotation);
+  }
+  if (delta.fov != null && result.fov != null) {
+    result.fov += delta.fov;
+  }
+  if (delta.zoom != null && result.zoom != null) {
+    result.zoom += delta.zoom;
+  }
+  return result;
+}
+function smoothPose(current, target, damping, dt) {
+  const t = 1 - Math.pow(1 - MathUtils.clamp(damping, 0, 1), dt * 60);
+  const result = clonePose(current);
+  result.position.lerp(target.position, t);
+  result.rotation.slerp(target.rotation, t);
+  if (target.fov != null && result.fov != null) {
+    result.fov = MathUtils.lerp(result.fov, target.fov, t);
+  }
+  if (target.zoom != null && result.zoom != null) {
+    result.zoom = MathUtils.lerp(result.zoom, target.zoom, t);
+  }
+  if (target.near != null) {
+    result.near = target.near;
+  }
+  if (target.far != null) {
+    result.far = target.far;
+  }
+  result.lookAt = target.lookAt?.clone();
+  return result;
+}
+
+// src/lib/camera/camera-pipeline.ts
+var CameraPipeline = class {
+  /** Active perspective (exactly one at a time). */
+  perspective = null;
+  /** Keyed behaviors, sorted by priority each frame. */
+  behaviors = /* @__PURE__ */ new Map();
+  /** Active transient actions. Expired actions are auto-removed. */
+  actions = [];
+  /** The desired pose after perspective + behaviors + actions. */
+  _desiredPose = defaultPose();
+  /** The smoothed final pose committed to the Three.js camera. */
+  _finalPose = defaultPose();
+  /** Whether the pipeline has run at least once (prevents lerp from origin on first frame). */
+  _initialized = false;
+  /** Smoothing factor: 0 = no movement, 1 = instant snap. */
+  damping = 0.15;
+  constructor(perspective) {
+    if (perspective) {
+      this.perspective = perspective;
+      if (perspective.defaults?.damping != null) {
+        this.damping = perspective.defaults.damping;
+      }
+    }
+  }
+  /**
+   * Run the full pipeline for one frame.
+   * Returns the final pose that should be committed to the Three.js camera.
+   */
+  run(ctx) {
+    let pose = this.perspective ? this.perspective.getBasePose(ctx) : defaultPose();
+    const sorted = this.getSortedBehaviors();
+    for (const behavior of sorted) {
+      if (behavior.enabled === false) continue;
+      pose = behavior.update(ctx, pose);
+    }
+    this._desiredPose = clonePose(pose);
+    for (let i = this.actions.length - 1; i >= 0; i--) {
+      const action = this.actions[i];
+      const delta = action.update(ctx);
+      pose = applyDelta(pose, delta);
+      if (action.isDone(ctx)) {
+        this.actions.splice(i, 1);
+      }
+    }
+    if (!this._initialized) {
+      this._finalPose = clonePose(pose);
+      this._initialized = true;
+    } else {
+      this._finalPose = smoothPose(this._finalPose, pose, this.damping, ctx.dt);
+    }
+    return this._finalPose;
+  }
+  // ─── Behavior management ───────────────────────────────────────────────
+  /**
+   * Add or replace a behavior by key (idempotent).
+   * Calls onDetach on the old behavior and onAttach on the new one.
+   */
+  addBehavior(key, behavior, ctx) {
+    const existing = this.behaviors.get(key);
+    if (existing?.onDetach && ctx) {
+      existing.onDetach(ctx);
+    }
+    this.behaviors.set(key, behavior);
+    if (behavior.onAttach && ctx) {
+      behavior.onAttach(ctx);
+    }
+  }
+  /**
+   * Remove a behavior by key. Calls onDetach if a context is provided.
+   */
+  removeBehavior(key, ctx) {
+    const existing = this.behaviors.get(key);
+    if (!existing) return false;
+    if (existing.onDetach && ctx) {
+      existing.onDetach(ctx);
+    }
+    return this.behaviors.delete(key);
+  }
+  /**
+   * Check whether a behavior with the given key exists.
+   */
+  hasBehavior(key) {
+    return this.behaviors.has(key);
+  }
+  // ─── Action management ─────────────────────────────────────────────────
+  /**
+   * Add a transient action. Actions self-expire via isDone().
+   */
+  addAction(action) {
+    this.actions.push(action);
+  }
+  // ─── State inspection ──────────────────────────────────────────────────
+  /**
+   * Return a debug snapshot of the pipeline state.
+   */
+  getState() {
+    return {
+      perspectiveId: this.perspective?.id ?? null,
+      desiredPose: this._desiredPose ? clonePose(this._desiredPose) : null,
+      finalPose: this._finalPose ? clonePose(this._finalPose) : null,
+      activeBehaviors: Array.from(this.behaviors.keys()),
+      activeActionCount: this.actions.length
+    };
+  }
+  /**
+   * Set a new perspective. Resets the pipeline initialization flag so the
+   * first frame with the new perspective snaps instead of lerping from the old pose.
+   */
+  setPerspective(perspective) {
+    this.perspective = perspective;
+    this._initialized = false;
+    if (perspective.defaults?.damping != null) {
+      this.damping = perspective.defaults.damping;
+    }
+  }
+  // ─── Internal helpers ──────────────────────────────────────────────────
+  getSortedBehaviors() {
+    return Array.from(this.behaviors.values()).sort(
+      (a, b) => (a.priority ?? 0) - (b.priority ?? 0)
+    );
+  }
+};
+
+// src/lib/camera/perspectives/third-person-perspective.ts
+import { Vector3 as Vector33, Quaternion as Quaternion3 } from "three";
+var DEFAULTS = {
+  distance: 8,
+  height: 5,
+  shoulderOffset: 0,
+  targetKey: "primary",
+  fov: 75,
+  paddingFactor: 1.5,
+  minDistance: 5
+};
+var ThirdPersonPerspective = class {
+  id = "third-person";
+  defaults = { damping: 0.15 };
+  opts;
+  initialPosition;
+  initialLookAt;
+  constructor(options) {
+    const { initialPosition, initialLookAt, ...rest } = options ?? {};
+    this.opts = { ...DEFAULTS, ...rest };
+    this.initialPosition = initialPosition;
+    this.initialLookAt = initialLookAt;
+  }
+  getBasePose(ctx) {
+    const targetKeys = Object.keys(ctx.targets);
+    const primary = ctx.targets[this.opts.targetKey];
+    if (targetKeys.length === 0 || !primary) {
+      return this.staticPose();
+    }
+    if (targetKeys.length === 1) {
+      return this.singleTargetPose(primary.position);
+    }
+    return this.multiTargetPose(ctx);
+  }
+  /**
+   * No targets: use the user-specified initial position if available,
+   * otherwise fall back to a default pose behind the origin.
+   */
+  staticPose() {
+    if (this.initialPosition) {
+      return {
+        position: this.initialPosition.clone(),
+        rotation: new Quaternion3(),
+        fov: this.opts.fov,
+        zoom: 1,
+        near: 0.1,
+        far: 1e3,
+        lookAt: this.initialLookAt?.clone() ?? new Vector33(0, 0, 0)
+      };
+    }
+    const position = new Vector33(
+      this.opts.shoulderOffset,
+      this.opts.height,
+      this.opts.distance
+    );
+    return {
+      position,
+      rotation: new Quaternion3(),
+      fov: this.opts.fov,
+      zoom: 1,
+      near: 0.1,
+      far: 1e3,
+      lookAt: new Vector33(0, 0, 0)
+    };
+  }
+  /**
+   * Single target: position = target + offset, lookAt = target.
+   */
+  singleTargetPose(targetPos) {
+    const position = new Vector33(
+      targetPos.x + this.opts.shoulderOffset,
+      targetPos.y + this.opts.height,
+      targetPos.z + this.opts.distance
+    );
+    return {
+      position,
+      rotation: new Quaternion3(),
+      fov: this.opts.fov,
+      zoom: 1,
+      near: 0.1,
+      far: 1e3,
+      lookAt: targetPos.clone()
+    };
+  }
+  /**
+   * Multi-target: compute centroid and adjust distance to frame all targets.
+   */
+  multiTargetPose(ctx) {
+    const targets = Object.values(ctx.targets);
+    const centroid = new Vector33();
+    for (const t of targets) {
+      centroid.add(t.position);
+    }
+    centroid.divideScalar(targets.length);
+    let maxDist = 0;
+    for (const t of targets) {
+      const d = centroid.distanceTo(t.position);
+      if (d > maxDist) maxDist = d;
+    }
+    const dynamicDistance = Math.max(
+      maxDist * this.opts.paddingFactor,
+      this.opts.minDistance
+    );
+    const baseOffset = new Vector33(
+      this.opts.shoulderOffset,
+      this.opts.height,
+      this.opts.distance
+    );
+    const baseLen = baseOffset.length();
+    const dir = baseLen > 0 ? baseOffset.clone().normalize() : new Vector33(0, 0.5, 1).normalize();
+    const position = centroid.clone().add(dir.multiplyScalar(dynamicDistance));
+    if (baseLen > 0) {
+      const heightRatio = this.opts.height / baseLen;
+      position.y = centroid.y + dynamicDistance * heightRatio;
+    }
+    return {
+      position,
+      rotation: new Quaternion3(),
+      fov: this.opts.fov,
+      zoom: 1,
+      near: 0.1,
+      far: 1e3,
+      lookAt: centroid.clone()
+    };
+  }
+};
+
+// src/lib/camera/perspectives/fixed-2d-perspective.ts
+import { Vector3 as Vector34, Quaternion as Quaternion4 } from "three";
+var DEFAULTS2 = {
+  position: { x: 0, y: 0, z: 10 },
+  zoom: 10
+};
+var Fixed2DPerspective = class {
+  id = "fixed-2d";
+  defaults = { damping: 1 };
+  opts;
+  constructor(options) {
+    this.opts = { ...DEFAULTS2, ...options };
+  }
+  getBasePose(_ctx) {
+    return {
+      position: new Vector34(
+        this.opts.position.x,
+        this.opts.position.y,
+        this.opts.position.z
+      ),
+      rotation: new Quaternion4(),
+      zoom: this.opts.zoom,
+      near: 1,
+      far: 1e3,
+      lookAt: new Vector34(this.opts.position.x, this.opts.position.y, 0)
+    };
+  }
+};
+
+// src/lib/camera/perspectives/first-person-perspective.ts
+import { Vector3 as Vector35, Quaternion as Quaternion5, Euler, MathUtils as MathUtils2 } from "three";
+var DEFAULTS3 = {
+  eyeHeight: 1.7,
+  defaultFov: 75,
+  pitchLimit: Math.PI / 2 - 0.01,
+  lookAtLerpSpeed: 5,
+  fovLerpSpeed: 8,
+  targetKey: "primary"
+};
+var FirstPersonPerspective = class {
+  id = "first-person";
+  defaults = { damping: 1 };
+  opts;
+  /** Fallback position when no target entity is attached. Mutate directly for manual movement. */
+  initialPosition;
+  initialLookAt;
+  // --- Look state ---
+  _yaw = 0;
+  _pitch = 0;
+  // --- FOV zoom state ---
+  _currentFov;
+  _targetFov;
+  // --- Look-at target state ---
+  _lookAtTarget = null;
+  _lookAtLerpSpeed;
+  _currentRotation = new Quaternion5();
+  _rotationInitialized = false;
+  constructor(options) {
+    const { initialPosition, initialLookAt, ...rest } = options ?? {};
+    this.opts = { ...DEFAULTS3, ...rest };
+    this.initialPosition = initialPosition;
+    this.initialLookAt = initialLookAt;
+    this._currentFov = this.opts.defaultFov;
+    this._targetFov = this.opts.defaultFov;
+    this._lookAtLerpSpeed = this.opts.lookAtLerpSpeed;
+    if (initialPosition && initialLookAt) {
+      this.deriveYawPitchFromLookAt(initialPosition, initialLookAt);
+    }
+  }
+  // --- Public API (called by game code / FPS behavior) ---
+  /** Accumulate yaw and pitch deltas. Pitch is clamped to the configured limit. */
+  look(deltaYaw, deltaPitch) {
+    this._yaw += deltaYaw;
+    this._pitch = MathUtils2.clamp(
+      this._pitch + deltaPitch,
+      -this.opts.pitchLimit,
+      this.opts.pitchLimit
+    );
+  }
+  /** Set absolute yaw and pitch. Pitch is clamped to the configured limit. */
+  setLook(yaw, pitch) {
+    this._yaw = yaw;
+    this._pitch = MathUtils2.clamp(pitch, -this.opts.pitchLimit, this.opts.pitchLimit);
+  }
+  /** Current yaw in radians. */
+  get yaw() {
+    return this._yaw;
+  }
+  /** Current pitch in radians. */
+  get pitch() {
+    return this._pitch;
+  }
+  /** Set the target FOV for a smooth zoom transition (e.g. sniper scope). */
+  zoom(fov) {
+    this._targetFov = fov;
+  }
+  /** Return to the default FOV. */
+  resetZoom() {
+    this._targetFov = this.opts.defaultFov;
+  }
+  /** Current field of view. */
+  get currentFov() {
+    return this._currentFov;
+  }
+  /**
+   * Enable smooth look-at toward a world position.
+   * The camera will slerp from the current rotation toward the look-at direction.
+   */
+  lookAt(target, lerpSpeed) {
+    this._lookAtTarget = target;
+    if (lerpSpeed != null) {
+      this._lookAtLerpSpeed = lerpSpeed;
+    }
+  }
+  /** Disable look-at and return to manual yaw/pitch control. */
+  clearLookAt() {
+    if (this._lookAtTarget) {
+      this.deriveYawPitchFromQuaternion(this._currentRotation);
+    }
+    this._lookAtTarget = null;
+  }
+  // --- CameraPerspective interface ---
+  getBasePose(ctx) {
+    const position = this.computePosition(ctx);
+    const rotation = this.computeRotation(position, ctx.dt);
+    this._currentFov = this.lerpFov(ctx.dt);
+    return {
+      position,
+      rotation,
+      fov: this._currentFov,
+      near: 0.1,
+      far: 1e3
+    };
+  }
+  // --- Private helpers ---
+  computePosition(ctx) {
+    const target = ctx.targets[this.opts.targetKey];
+    if (target) {
+      return new Vector35(
+        target.position.x,
+        target.position.y + this.opts.eyeHeight,
+        target.position.z
+      );
+    }
+    if (this.initialPosition) {
+      return this.initialPosition.clone();
+    }
+    return new Vector35(0, this.opts.eyeHeight, 0);
+  }
+  computeRotation(eyePosition, dt) {
+    const yawPitchQuat = new Quaternion5().setFromEuler(
+      new Euler(this._pitch, this._yaw, 0, "YXZ")
+    );
+    if (!this._rotationInitialized) {
+      this._currentRotation.copy(yawPitchQuat);
+      this._rotationInitialized = true;
+    }
+    if (this._lookAtTarget) {
+      const dir = _vec3.copy(this._lookAtTarget).sub(eyePosition);
+      if (dir.lengthSq() > 1e-4) {
+        dir.normalize();
+        const desiredYaw = Math.atan2(-dir.x, -dir.z);
+        const desiredPitch = Math.asin(MathUtils2.clamp(dir.y, -1, 1));
+        const desiredQuat = _quat.setFromEuler(
+          _euler.set(desiredPitch, desiredYaw, 0, "YXZ")
+        );
+        const t = 1 - Math.pow(1 - Math.min(this._lookAtLerpSpeed * dt, 1), 1);
+        this._currentRotation.slerp(desiredQuat, MathUtils2.clamp(t, 0, 1));
+        return this._currentRotation.clone();
+      }
+    }
+    this._currentRotation.copy(yawPitchQuat);
+    return yawPitchQuat;
+  }
+  lerpFov(dt) {
+    if (Math.abs(this._currentFov - this._targetFov) < 0.01) {
+      return this._targetFov;
+    }
+    const t = 1 - Math.pow(1 - Math.min(this.opts.fovLerpSpeed * dt, 1), 1);
+    return MathUtils2.lerp(this._currentFov, this._targetFov, MathUtils2.clamp(t, 0, 1));
+  }
+  deriveYawPitchFromLookAt(from, to) {
+    const dir = _vec3.copy(to).sub(from).normalize();
+    this._yaw = Math.atan2(-dir.x, -dir.z);
+    this._pitch = Math.asin(MathUtils2.clamp(dir.y, -1, 1));
+  }
+  deriveYawPitchFromQuaternion(q) {
+    const euler = _euler.setFromQuaternion(q, "YXZ");
+    this._yaw = euler.y;
+    this._pitch = MathUtils2.clamp(euler.x, -this.opts.pitchLimit, this.opts.pitchLimit);
+  }
+};
+var _vec3 = new Vector35();
+var _quat = new Quaternion5();
+var _euler = new Euler();
+
+// src/lib/camera/perspectives/index.ts
+function createPerspective(type, options) {
+  switch (type) {
+    case "third-person":
+      return new ThirdPersonPerspective(options);
+    case "first-person":
+      return new FirstPersonPerspective(options);
+    case "isometric":
+      return new ThirdPersonPerspective({
+        distance: 10,
+        height: 10,
+        ...options
+      });
+    case "flat-2d":
+      return new Fixed2DPerspective(options);
+    case "fixed-2d":
+      return new Fixed2DPerspective(options);
+    default:
+      return new ThirdPersonPerspective(options);
+  }
+}
+
+// src/lib/camera/zylem-camera.ts
+var ZylemCamera = class {
+  /**
+   * @deprecated No longer used. Kept as null for backward compatibility
+   * with code that checks `camera.cameraRig` (e.g. scene graph insertion).
+   */
+  cameraRig = null;
+  camera;
+  screenResolution;
+  _perspective;
+  frustumSize = 10;
+  rendererType;
+  sceneRef = null;
+  /** Name for camera manager lookup. */
+  name = "";
+  /**
+   * Viewport in normalized coordinates (0-1).
+   * Default is fullscreen: { x: 0, y: 0, width: 1, height: 1 }
+   */
+  viewport = { ...DEFAULT_VIEWPORT };
+  /**
+   * Multiple targets for the camera to follow/frame.
+   */
+  targets = [];
+  /**
+   * The camera pose pipeline.
+   * Exposed so CameraWrapper can delegate addBehavior/addAction/getState.
+   */
+  pipeline;
+  /**
+   * Offscreen render target for render-to-texture (RTT) cameras.
+   * When set, the camera renders to this target instead of the screen viewport.
+   * Created via createRenderTarget() or automatically by setCameraFeed().
+   */
+  renderTarget = null;
+  /**
+   * @deprecated Use `targets` array instead. Kept for backward compatibility.
+   */
+  get target() {
+    return this.targets.length > 0 ? this.targets[0] : null;
+  }
+  set target(entity) {
+    if (entity) {
+      if (this.targets.length === 0) {
+        this.targets.push(entity);
+      } else {
+        this.targets[0] = entity;
+      }
+    } else {
+      this.targets = [];
+    }
+  }
+  // Orbit controls
+  orbitController = null;
+  _useOrbitalControls = false;
+  /** When true, debug-mode orbital controls are not attached to this camera. */
+  _skipDebugOrbit = false;
+  /** Reference to the shared renderer manager (set during setup). */
+  _rendererManager = null;
+  /** Elapsed time tracker for CameraContext. */
+  _elapsedTime = 0;
+  constructor(perspective, screenResolution, frustumSize = 10, rendererType = "webgl") {
+    this._perspective = perspective;
+    this.screenResolution = screenResolution;
+    this.frustumSize = frustumSize;
+    this.rendererType = rendererType;
+    const aspectRatio = screenResolution.x / screenResolution.y;
+    this.camera = this.createCameraForPerspective(aspectRatio);
+    this.camera.position.set(0, 0, 10);
+    this.camera.lookAt(new Vector36(0, 0, 0));
+    const perspectiveImpl = createPerspective(perspective);
+    this.pipeline = new CameraPipeline(perspectiveImpl);
+  }
+  /**
+   * Setup the camera with a scene and renderer manager.
+   */
+  async setup(scene, rendererManager) {
+    this.sceneRef = scene;
+    if (rendererManager) {
+      this._rendererManager = rendererManager;
+    }
+    if (this._rendererManager && !this._rendererManager.initialized) {
+      await this._rendererManager.initRenderer();
+    }
+    if (this._rendererManager) {
+      this.orbitController = new CameraOrbitController(
+        this.camera,
+        this._rendererManager.renderer.domElement,
+        null
+        // no camera rig
+      );
+      this.orbitController.setScene(scene);
+      if (this._useOrbitalControls) {
+        this.orbitController.enableUserOrbitControls();
+      }
+    }
+  }
+  /**
+   * Legacy setup method for backward compatibility.
+   * Creates a temporary RendererManager internally.
+   * @deprecated Use setup(scene, rendererManager) instead.
+   */
+  async setupLegacy(scene) {
+    if (!this._rendererManager) {
+      this._rendererManager = new RendererManager(this.screenResolution, this.rendererType);
+      await this._rendererManager.initRenderer();
+      this._rendererManager.setupRenderPass(scene, this.camera);
+      this._rendererManager.startRenderLoop((delta) => {
+        this.update(delta);
+        if (this._rendererManager && this.sceneRef) {
+          this._rendererManager.render(this.sceneRef, this.camera);
+        }
+      });
+    }
+    await this.setup(scene, this._rendererManager);
+  }
+  /**
+   * Update the camera each frame.
+   *
+   * When orbit/debug controls are active, the pipeline is skipped and
+   * orbit controls manage the camera directly. Otherwise, the pipeline
+   * runs: Perspective -> Behaviors -> Actions -> Smoothing -> Commit.
+   */
+  update(delta) {
+    this.orbitController?.update();
+    if (this.isDebugModeActive() || this._useOrbitalControls) {
+      return;
     }
-    this.composer.render(delta);
+    this._elapsedTime += delta;
+    const ctx = this.buildContext(delta);
+    const finalPose = this.pipeline.run(ctx);
+    this.commitPose(finalPose);
   }
   /**
-   * Check if debug mode is active (orbit controls taking over camera)
+   * Check if debug mode is active (orbit controls taking over camera).
    */
   isDebugModeActive() {
     return this.orbitController?.isActive ?? false;
   }
   /**
-   * Dispose renderer, composer, controls, and detach from scene
+   * Enable user-configured orbital controls (not debug mode).
    */
-  destroy() {
-    try {
-      this.renderer.setAnimationLoop(null);
-    } catch {
+  enableOrbitalControls() {
+    this._useOrbitalControls = true;
+    this.orbitController?.enableUserOrbitControls();
+  }
+  /**
+   * Disable user-configured orbital controls.
+   */
+  disableOrbitalControls() {
+    this._useOrbitalControls = false;
+    this.orbitController?.disableUserOrbitControls();
+  }
+  /**
+   * Whether user orbital controls are enabled.
+   */
+  get useOrbitalControls() {
+    return this._useOrbitalControls;
+  }
+  // ─── Target management ──────────────────────────────────────────────────
+  /**
+   * Add a target entity for the camera to follow/frame.
+   */
+  addTarget(entity) {
+    if (!this.targets.includes(entity)) {
+      this.targets.push(entity);
     }
-    try {
-      this.orbitController?.dispose();
-    } catch {
+  }
+  /**
+   * Remove a target entity.
+   */
+  removeTarget(entity) {
+    const index = this.targets.indexOf(entity);
+    if (index !== -1) {
+      this.targets.splice(index, 1);
+    }
+  }
+  /**
+   * Clear all targets.
+   */
+  clearTargets() {
+    this.targets = [];
+  }
+  // ─── Viewport & resize ──────────────────────────────────────────────────
+  /**
+   * Set the viewport for this camera (normalized 0-1 coordinates).
+   */
+  setViewport(x, y, width, height) {
+    this.viewport = { x, y, width, height };
+  }
+  /**
+   * Resize camera projection.
+   */
+  resize(width, height) {
+    this.screenResolution.set(width, height);
+    if (this.camera instanceof PerspectiveCamera2) {
+      this.camera.aspect = width / height;
+      this.camera.updateProjectionMatrix();
+    }
+    if (this.camera instanceof OrthographicCamera) {
+      const aspect = width / height;
+      this.camera.left = this.frustumSize * aspect / -2;
+      this.camera.right = this.frustumSize * aspect / 2;
+      this.camera.top = this.frustumSize / 2;
+      this.camera.bottom = this.frustumSize / -2;
+      this.camera.updateProjectionMatrix();
+    }
+  }
+  // ─── Render-to-texture ─────────────────────────────────────────────────
+  /**
+   * Create an offscreen render target for this camera.
+   * When a render target is present, CameraManager renders this camera
+   * to the target instead of the screen viewport.
+   *
+   * @param width  Texture width in pixels (default 512)
+   * @param height Texture height in pixels (default 512)
+   */
+  createRenderTarget(width = 512, height = 512) {
+    if (this.renderTarget) {
+      this.renderTarget.dispose();
     }
+    this.renderTarget = new WebGLRenderTarget2(width, height, {
+      minFilter: LinearFilter,
+      magFilter: LinearFilter
+    });
+    return this.renderTarget;
+  }
+  /**
+   * Get the texture from the render target (for applying to a mesh material).
+   * Returns null if no render target has been created.
+   */
+  getRenderTexture() {
+    return this.renderTarget?.texture ?? null;
+  }
+  // ─── Lifecycle ──────────────────────────────────────────────────────────
+  /**
+   * Dispose camera resources.
+   */
+  destroy() {
     try {
-      this.composer?.passes?.forEach((p) => p.dispose?.());
-      this.composer?.dispose?.();
+      this.orbitController?.dispose();
     } catch {
     }
     try {
-      this.renderer.dispose();
+      this.renderTarget?.dispose();
     } catch {
     }
+    this.renderTarget = null;
     this.sceneRef = null;
+    this.targets = [];
+    this._rendererManager = null;
   }
+  // ─── Debug delegate ─────────────────────────────────────────────────────
   /**
    * Attach a delegate to react to debug state changes.
+   * Skipped when _skipDebugOrbit is true so the pipeline always runs.
    */
   setDebugDelegate(delegate) {
+    if (this._skipDebugOrbit) return;
     this.orbitController?.setDebugDelegate(delegate);
   }
+  // ─── Movement helpers (backward compat) ─────────────────────────────────
   /**
-   * Resize camera and renderer
+   * Directly set the camera position.
    */
-  resize(width, height) {
-    this.screenResolution.set(width, height);
-    this.renderer.setSize(width, height, false);
-    this.composer.setSize(width, height);
-    if (this.camera instanceof PerspectiveCamera) {
-      this.camera.aspect = width / height;
-      this.camera.updateProjectionMatrix();
+  move(position) {
+    if (this._perspective === Perspectives.Flat2D || this._perspective === Perspectives.Fixed2D) {
+      this.frustumSize = position.z;
     }
-    if (this.perspectiveController) {
-      this.perspectiveController.resize(width, height);
+    this.camera.position.set(position.x, position.y, position.z);
+  }
+  /**
+   * Apply incremental rotation to the camera.
+   */
+  rotate(pitch, yaw, roll) {
+    this.camera.rotateX(pitch);
+    this.camera.rotateY(yaw);
+    this.camera.rotateZ(roll);
+  }
+  // ─── Renderer manager access ────────────────────────────────────────────
+  /**
+   * Get the DOM element for the renderer.
+   * @deprecated Access via RendererManager instead.
+   */
+  getDomElement() {
+    if (this._rendererManager) {
+      return this._rendererManager.getDomElement();
     }
+    throw new Error("ZylemCamera: No renderer manager available. Call setup() first.");
+  }
+  /**
+   * Get the renderer manager reference.
+   */
+  getRendererManager() {
+    return this._rendererManager;
   }
   /**
-   * Update renderer pixel ratio (DPR)
+   * Set the renderer manager reference (used by CameraManager during setup).
    */
+  setRendererManager(manager) {
+    this._rendererManager = manager;
+  }
+  // ─── Legacy compatibility methods ────────────────────────────────────────
+  /** @deprecated Renderer is now owned by RendererManager */
+  get renderer() {
+    return this._rendererManager?.renderer;
+  }
+  /** @deprecated Composer is now owned by RendererManager */
+  get composer() {
+    return this._rendererManager?.composer;
+  }
+  /** @deprecated Use RendererManager.setPixelRatio() instead */
   setPixelRatio(dpr) {
-    const safe = Math.max(1, Number.isFinite(dpr) ? dpr : 1);
-    this.renderer.setPixelRatio(safe);
+    this._rendererManager?.setPixelRatio(dpr);
+  }
+  // ─── Private helpers ────────────────────────────────────────────────────
+  /**
+   * Build a CameraContext from current ZylemCamera state.
+   * Converts StageEntity[] targets into Record<string, TransformLike>.
+   */
+  buildContext(delta) {
+    const targets = {};
+    for (let i = 0; i < this.targets.length; i++) {
+      const entity = this.targets[i];
+      const key = i === 0 ? "primary" : `target_${i}`;
+      if (entity.group) {
+        targets[key] = {
+          position: entity.group.position,
+          rotation: entity.group.quaternion
+        };
+      }
+    }
+    return {
+      dt: delta,
+      time: this._elapsedTime,
+      viewport: {
+        width: this.screenResolution.x,
+        height: this.screenResolution.y,
+        aspect: this.screenResolution.x / this.screenResolution.y
+      },
+      targets
+    };
+  }
+  /**
+   * Apply the final pipeline pose to the Three.js camera.
+   */
+  commitPose(pose) {
+    this.camera.position.copy(pose.position);
+    if (pose.lookAt) {
+      this.camera.lookAt(pose.lookAt);
+    } else {
+      this.camera.quaternion.copy(pose.rotation);
+    }
+    if (this.camera instanceof PerspectiveCamera2) {
+      if (pose.fov != null) this.camera.fov = pose.fov;
+      if (pose.near != null) this.camera.near = pose.near;
+      if (pose.far != null) this.camera.far = pose.far;
+      this.camera.updateProjectionMatrix();
+    }
+    if (this.camera instanceof OrthographicCamera) {
+      if (pose.zoom != null) {
+        const aspect = this.screenResolution.x / this.screenResolution.y;
+        const size = pose.zoom;
+        this.camera.left = -size * aspect / 2;
+        this.camera.right = size * aspect / 2;
+        this.camera.top = size / 2;
+        this.camera.bottom = -size / 2;
+      }
+      if (pose.near != null) this.camera.near = pose.near;
+      if (pose.far != null) this.camera.far = pose.far;
+      this.camera.updateProjectionMatrix();
+    }
   }
   /**
-   * Create camera based on perspective type
+   * Create a Three.js camera based on perspective type.
    */
   createCameraForPerspective(aspectRatio) {
     switch (this._perspective) {
       case Perspectives.ThirdPerson:
-        return this.createThirdPersonCamera(aspectRatio);
+        return new PerspectiveCamera2(75, aspectRatio, 0.1, 1e3);
       case Perspectives.FirstPerson:
-        return this.createFirstPersonCamera(aspectRatio);
+        return new PerspectiveCamera2(75, aspectRatio, 0.1, 1e3);
       case Perspectives.Isometric:
-        return this.createIsometricCamera(aspectRatio);
+        return new OrthographicCamera(
+          this.frustumSize * aspectRatio / -2,
+          this.frustumSize * aspectRatio / 2,
+          this.frustumSize / 2,
+          this.frustumSize / -2,
+          1,
+          1e3
+        );
       case Perspectives.Flat2D:
-        return this.createFlat2DCamera(aspectRatio);
       case Perspectives.Fixed2D:
-        return this.createFixed2DCamera(aspectRatio);
+        return new OrthographicCamera(
+          this.frustumSize * aspectRatio / -2,
+          this.frustumSize * aspectRatio / 2,
+          this.frustumSize / 2,
+          this.frustumSize / -2,
+          1,
+          1e3
+        );
       default:
-        return this.createThirdPersonCamera(aspectRatio);
+        return new PerspectiveCamera2(75, aspectRatio, 0.1, 1e3);
     }
   }
+};
+
+// src/lib/camera/camera.ts
+var CameraWrapper = class {
+  cameraRef;
+  constructor(camera) {
+    this.cameraRef = camera;
+  }
+  // ─── Target management ──────────────────────────────────────────────────
   /**
-   * Initialize perspective-specific controller
+   * Add a target entity for the camera to follow/frame.
+   * With multiple targets, the camera auto-frames to include all of them.
    */
-  initializePerspectiveController() {
-    switch (this._perspective) {
-      case Perspectives.ThirdPerson:
-        this.perspectiveController = new ThirdPersonCamera();
-        break;
-      case Perspectives.Fixed2D:
-        this.perspectiveController = new Fixed2DCamera();
-        break;
-      default:
-        this.perspectiveController = new ThirdPersonCamera();
-    }
+  addTarget(entity) {
+    this.cameraRef.addTarget(entity);
+  }
+  /**
+   * Remove a target entity from the camera.
+   */
+  removeTarget(entity) {
+    this.cameraRef.removeTarget(entity);
   }
-  createThirdPersonCamera(aspectRatio) {
-    return new PerspectiveCamera(75, aspectRatio, 0.1, 1e3);
+  /**
+   * Clear all targets. Camera will look at world origin.
+   */
+  clearTargets() {
+    this.cameraRef.clearTargets();
   }
-  createFirstPersonCamera(aspectRatio) {
-    return new PerspectiveCamera(75, aspectRatio, 0.1, 1e3);
+  // ─── Orbital controls ───────────────────────────────────────────────────
+  /**
+   * Enable orbital controls for this camera.
+   * Allows the user to orbit, pan, and zoom the camera.
+   */
+  enableOrbitalControls() {
+    this.cameraRef.enableOrbitalControls();
   }
-  createIsometricCamera(aspectRatio) {
-    return new OrthographicCamera(
-      this.frustumSize * aspectRatio / -2,
-      this.frustumSize * aspectRatio / 2,
-      this.frustumSize / 2,
-      this.frustumSize / -2,
-      1,
-      1e3
-    );
+  /**
+   * Disable orbital controls for this camera.
+   */
+  disableOrbitalControls() {
+    this.cameraRef.disableOrbitalControls();
   }
-  createFlat2DCamera(aspectRatio) {
-    return new OrthographicCamera(
-      this.frustumSize * aspectRatio / -2,
-      this.frustumSize * aspectRatio / 2,
-      this.frustumSize / 2,
-      this.frustumSize / -2,
-      1,
-      1e3
-    );
+  // ─── Viewport ───────────────────────────────────────────────────────────
+  /**
+   * Set the viewport for this camera (normalized 0-1 coordinates).
+   * @param x Left edge (0 = left of canvas)
+   * @param y Bottom edge (0 = bottom of canvas)
+   * @param width Width as fraction of canvas
+   * @param height Height as fraction of canvas
+   */
+  setViewport(x, y, width, height) {
+    this.cameraRef.setViewport(x, y, width, height);
   }
-  createFixed2DCamera(aspectRatio) {
-    return this.createFlat2DCamera(aspectRatio);
+  // ─── Pipeline: Behaviors ────────────────────────────────────────────────
+  /**
+   * Add or replace a behavior by key (idempotent).
+   * Behaviors modify the desired camera pose each frame.
+   *
+   * @param key   Unique key for this behavior (used for replacement/removal).
+   * @param behavior  The CameraBehavior implementation.
+   */
+  addBehavior(key, behavior) {
+    this.cameraRef.pipeline.addBehavior(key, behavior);
   }
-  // Movement methods
-  moveCamera(position) {
-    if (this._perspective === Perspectives.Flat2D || this._perspective === Perspectives.Fixed2D) {
-      this.frustumSize = position.z;
-    }
-    if (this.cameraRig) {
-      this.cameraRig.position.set(position.x, position.y, position.z);
-    } else {
-      this.camera.position.set(position.x, position.y, position.z);
-    }
+  /**
+   * Remove a behavior by key.
+   */
+  removeBehavior(key) {
+    return this.cameraRef.pipeline.removeBehavior(key);
   }
-  move(position) {
-    this.moveCamera(position);
+  // ─── Pipeline: Actions ──────────────────────────────────────────────────
+  /**
+   * Add a transient action (screenshake, recoil, etc.).
+   * Actions apply additive deltas and self-expire when isDone() returns true.
+   */
+  addAction(action) {
+    this.cameraRef.pipeline.addAction(action);
   }
-  rotate(pitch, yaw, roll) {
-    if (this.cameraRig) {
-      this.cameraRig.rotateX(pitch);
-      this.cameraRig.rotateY(yaw);
-      this.cameraRig.rotateZ(roll);
-    } else {
-      this.camera.rotateX(pitch);
-      this.camera.rotateY(yaw);
-      this.camera.rotateZ(roll);
-    }
+  // ─── Pipeline: Perspective ──────────────────────────────────────────────
+  /**
+   * Switch the camera's active perspective at runtime.
+   * The first frame after switching snaps to the new pose (no lerp).
+   *
+   * @param type     Perspective type string (e.g. Perspectives.ThirdPerson).
+   * @param options  Perspective-specific options (distance, height, zoom, etc.).
+   */
+  setPerspective(type, options) {
+    this.cameraRef.pipeline.setPerspective(createPerspective(type, options));
   }
   /**
-   * Check if this perspective type needs a camera rig
+   * Retrieve the active perspective instance, cast to the desired type.
+   * Useful for calling perspective-specific methods (e.g. FirstPersonPerspective.look()).
+   *
+   * @example
+   * const fps = camera.getPerspective<FirstPersonPerspective>();
+   * fps.look(dx, dy);
    */
-  needsRig() {
-    return this._perspective === Perspectives.ThirdPerson;
+  getPerspective() {
+    return this.cameraRef.pipeline.perspective;
   }
+  // ─── Pipeline: Debug state ──────────────────────────────────────────────
   /**
-   * Get the DOM element for the renderer
+   * Return a debug snapshot of the camera pipeline state.
+   * Includes: active perspective, desired/final pose, behavior keys, action count.
    */
-  getDomElement() {
-    return this.renderer.domElement;
+  getState() {
+    return this.cameraRef.pipeline.getState();
   }
-};
-
-// src/lib/camera/camera.ts
-var CameraWrapper = class {
-  cameraRef;
-  constructor(camera) {
-    this.cameraRef = camera;
+  // ─── Render-to-texture ─────────────────────────────────────────────────
+  /**
+   * Get the offscreen render texture for this camera.
+   * Returns null if the camera was not created with renderToTexture.
+   * Use with setCameraFeed() or apply directly to a mesh material.
+   */
+  getRenderTexture() {
+    return this.cameraRef.getRenderTexture();
   }
 };
 function createCamera(options) {
@@ -705,13 +1701,293 @@ function createCamera(options) {
   if (options.perspective === "fixed-2d") {
     frustumSize = options.zoom || 10;
   }
-  const zylemCamera = new ZylemCamera(options.perspective || "third-person", screenResolution, frustumSize);
-  zylemCamera.move(options.position || new Vector34(0, 0, 0));
-  zylemCamera.camera.lookAt(options.target || new Vector34(0, 0, 0));
+  const zylemCamera = new ZylemCamera(
+    options.perspective || "third-person",
+    screenResolution,
+    frustumSize,
+    options.rendererType || "webgl"
+  );
+  if (options.name) {
+    zylemCamera.name = options.name;
+  }
+  const position = options.position ? options.position instanceof Vector37 ? options.position : new Vector37(options.position.x, options.position.y, options.position.z) : new Vector37(0, 0, 0);
+  const target = options.target ? options.target instanceof Vector37 ? options.target : new Vector37(options.target.x, options.target.y, options.target.z) : new Vector37(0, 0, 0);
+  zylemCamera.move(position);
+  zylemCamera.camera.lookAt(target);
+  const perspType = options.perspective || "third-person";
+  if (perspType === "fixed-2d" || perspType === "flat-2d") {
+    zylemCamera.pipeline.setPerspective(
+      createPerspective(perspType, { zoom: frustumSize })
+    );
+  } else {
+    zylemCamera.pipeline.setPerspective(
+      createPerspective(perspType, {
+        initialPosition: position.clone(),
+        initialLookAt: target.clone()
+      })
+    );
+  }
+  if (options.viewport) {
+    zylemCamera.viewport = { ...options.viewport };
+  }
+  if (options.useOrbitalControls) {
+    zylemCamera._useOrbitalControls = true;
+  }
+  if (options.skipDebugOrbit) {
+    zylemCamera._skipDebugOrbit = true;
+  }
+  if (options.damping != null) {
+    zylemCamera.pipeline.damping = options.damping;
+  }
+  if (options.behaviors) {
+    for (const [key, behavior] of Object.entries(options.behaviors)) {
+      zylemCamera.pipeline.addBehavior(key, behavior);
+    }
+  }
+  if (options.renderToTexture) {
+    const { width = 512, height = 512 } = options.renderToTexture;
+    zylemCamera.createRenderTarget(width, height);
+  }
   return new CameraWrapper(zylemCamera);
 }
+
+// src/lib/camera/camera-manager.ts
+import { Vector2 as Vector24 } from "three";
+var CameraManager = class {
+  /** Named camera registry */
+  cameras = /* @__PURE__ */ new Map();
+  /** Currently active cameras, ordered by render layer (first = bottom) */
+  _activeCameras = [];
+  /** Auto-created debug camera with orbit controls */
+  _debugCamera = null;
+  /** Reference to the shared renderer manager */
+  _rendererManager = null;
+  /** Scene reference */
+  _sceneRef = null;
+  /** Counter for auto-generated camera names */
+  _autoNameCounter = 0;
+  constructor() {
+  }
+  /**
+   * Get the list of currently active cameras.
+   */
+  get activeCameras() {
+    return this._activeCameras;
+  }
+  /**
+   * Get the primary active camera (first in the active list).
+   */
+  get primaryCamera() {
+    return this._activeCameras.length > 0 ? this._activeCameras[0] : null;
+  }
+  /**
+   * Get the debug camera.
+   */
+  get debugCamera() {
+    return this._debugCamera;
+  }
+  /**
+   * Get all registered cameras.
+   */
+  get allCameras() {
+    return Array.from(this.cameras.values());
+  }
+  /**
+   * Add a camera to the manager.
+   * If no name is provided, one is auto-generated.
+   * The first camera added becomes the active camera.
+   *
+   * @param camera The ZylemCamera instance to add
+   * @param name Optional name for lookup
+   * @returns The assigned name
+   */
+  addCamera(camera, name) {
+    const resolvedName = name || camera.name || `camera_${this._autoNameCounter++}`;
+    camera.name = resolvedName;
+    this.cameras.set(resolvedName, camera);
+    if (this._activeCameras.length === 0) {
+      this._activeCameras.push(camera);
+    }
+    return resolvedName;
+  }
+  /**
+   * Remove a camera by name or reference.
+   * Cannot remove the debug camera via this method.
+   */
+  removeCamera(nameOrRef) {
+    let name;
+    if (typeof nameOrRef === "string") {
+      name = nameOrRef;
+    } else {
+      for (const [key, cam] of this.cameras.entries()) {
+        if (cam === nameOrRef) {
+          name = key;
+          break;
+        }
+      }
+    }
+    if (!name) return false;
+    const camera = this.cameras.get(name);
+    if (!camera) return false;
+    if (camera === this._debugCamera) {
+      console.warn("CameraManager: Cannot remove the debug camera");
+      return false;
+    }
+    this.cameras.delete(name);
+    const activeIndex = this._activeCameras.indexOf(camera);
+    if (activeIndex !== -1) {
+      this._activeCameras.splice(activeIndex, 1);
+    }
+    return true;
+  }
+  /**
+   * Set a camera as the primary active camera (replaces all active cameras
+   * except additional viewport cameras).
+   *
+   * @param nameOrRef Camera name or reference to activate
+   */
+  setActiveCamera(nameOrRef) {
+    const camera = this.resolveCamera(nameOrRef);
+    if (!camera) {
+      console.warn(`CameraManager: Camera not found: ${nameOrRef}`);
+      return false;
+    }
+    const pipCameras = this._activeCameras.filter((c) => {
+      return c !== this._activeCameras[0] && c.viewport.width < 1;
+    });
+    this._activeCameras = [camera, ...pipCameras];
+    return true;
+  }
+  /**
+   * Add a camera as an additional active camera (for split-screen or PiP).
+   */
+  addActiveCamera(nameOrRef) {
+    const camera = this.resolveCamera(nameOrRef);
+    if (!camera) return false;
+    if (!this._activeCameras.includes(camera)) {
+      this._activeCameras.push(camera);
+    }
+    return true;
+  }
+  /**
+   * Remove a camera from the active render list (does not remove from registry).
+   */
+  deactivateCamera(nameOrRef) {
+    const camera = this.resolveCamera(nameOrRef);
+    if (!camera) return false;
+    const index = this._activeCameras.indexOf(camera);
+    if (index !== -1) {
+      this._activeCameras.splice(index, 1);
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Get a camera by name.
+   */
+  getCamera(name) {
+    return this.cameras.get(name) ?? null;
+  }
+  /**
+   * Setup all cameras with the given scene and renderer manager.
+   * Also creates the debug camera.
+   */
+  async setup(scene, rendererManager) {
+    this._sceneRef = scene;
+    this._rendererManager = rendererManager;
+    this.createDebugCamera(rendererManager.screenResolution);
+    for (const camera of this.cameras.values()) {
+      camera.setRendererManager(rendererManager);
+      await camera.setup(scene, rendererManager);
+    }
+    if (this._debugCamera) {
+      this._debugCamera.setRendererManager(rendererManager);
+      await this._debugCamera.setup(scene, rendererManager);
+    }
+  }
+  /**
+   * Update all active cameras' controllers.
+   */
+  update(delta) {
+    for (const camera of this._activeCameras) {
+      camera.update(delta);
+    }
+  }
+  /**
+   * Render all active cameras through the renderer manager.
+   * RTT cameras (those with a renderTarget) are rendered first to their
+   * offscreen textures, then viewport cameras are rendered to the screen.
+   */
+  render(scene) {
+    if (!this._rendererManager || this._activeCameras.length === 0) return;
+    const rttCameras = [];
+    const viewportCameras = [];
+    for (const cam of this._activeCameras) {
+      if (cam.renderTarget) {
+        rttCameras.push(cam);
+      } else {
+        viewportCameras.push(cam);
+      }
+    }
+    for (const cam of rttCameras) {
+      this._rendererManager.renderCameraToTarget(scene, cam);
+    }
+    if (viewportCameras.length > 0) {
+      this._rendererManager.renderCameras(scene, viewportCameras);
+    }
+  }
+  /**
+   * Create a default third-person camera if no cameras have been added.
+   */
+  ensureDefaultCamera() {
+    if (this.cameras.size === 0 || this._activeCameras.length === 0) {
+      const screenRes = this._rendererManager?.screenResolution || new Vector24(window.innerWidth, window.innerHeight);
+      const defaultCam = new ZylemCamera(Perspectives.ThirdPerson, screenRes);
+      this.addCamera(defaultCam, "default");
+      return defaultCam;
+    }
+    return this._activeCameras[0];
+  }
+  /**
+   * Dispose all cameras and cleanup.
+   */
+  dispose() {
+    for (const camera of this.cameras.values()) {
+      camera.destroy();
+    }
+    this._debugCamera?.destroy();
+    this.cameras.clear();
+    this._activeCameras = [];
+    this._debugCamera = null;
+    this._rendererManager = null;
+    this._sceneRef = null;
+  }
+  /**
+   * Create the always-available debug camera with orbit controls.
+   */
+  createDebugCamera(screenResolution) {
+    this._debugCamera = new ZylemCamera(Perspectives.ThirdPerson, screenResolution);
+    this._debugCamera.name = "__debug__";
+    this._debugCamera.enableOrbitalControls();
+  }
+  /**
+   * Resolve a camera from a name or reference.
+   */
+  resolveCamera(nameOrRef) {
+    if (typeof nameOrRef === "string") {
+      return this.cameras.get(nameOrRef) ?? null;
+    }
+    for (const cam of this.cameras.values()) {
+      if (cam === nameOrRef) return cam;
+    }
+    return null;
+  }
+};
 export {
+  CameraManager,
+  CameraWrapper,
   Perspectives,
-  createCamera
+  createCamera,
+  isWebGPUSupported
 };
 //# sourceMappingURL=camera.js.map