@zylem/game-lib 0.6.4 → 0.7.0

package/dist/camera.js

@@ -1,1993 +0,0 @@
-// src/lib/camera/camera.ts
-import { Vector2 as Vector23, Vector3 as Vector37 } from "three";
-
-// src/lib/camera/zylem-camera.ts
-import { PerspectiveCamera as PerspectiveCamera2, Vector3 as Vector36, OrthographicCamera, WebGLRenderTarget as WebGLRenderTarget2, LinearFilter } from "three";
-
-// src/lib/camera/perspective.ts
-var Perspectives = {
-  FirstPerson: "first-person",
-  ThirdPerson: "third-person",
-  Isometric: "isometric",
-  Flat2D: "flat-2d",
-  Fixed2D: "fixed-2d",
-  TopDown: "top-down"
-};
-
-// src/lib/camera/camera-debug-delegate.ts
-import { Vector3 } from "three";
-import { OrbitControls } from "three/addons/controls/OrbitControls.js";
-var CameraOrbitController = class {
-  camera;
-  domElement;
-  cameraRig = null;
-  sceneRef = null;
-  orbitControls = null;
-  orbitTarget = null;
-  orbitTargetWorldPos = new Vector3();
-  debugDelegate = null;
-  debugUnsubscribe = null;
-  debugStateSnapshot = { enabled: false, selected: [] };
-  // Saved camera state for restoration when exiting debug mode
-  savedCameraPosition = null;
-  savedCameraQuaternion = null;
-  savedCameraZoom = null;
-  savedCameraLocalPosition = null;
-  // Saved debug camera state for restoration when re-entering debug mode
-  savedDebugCameraPosition = null;
-  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;
-    this.cameraRig = cameraRig ?? null;
-  }
-  /**
-   * Set the scene reference for adding/removing camera when detaching from rig.
-   */
-  setScene(scene) {
-    this.sceneRef = scene;
-  }
-  /**
-   * 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.
-   */
-  update() {
-    if (this.orbitControls && this.orbitTarget) {
-      this.orbitTarget.getWorldPosition(this.orbitTargetWorldPos);
-      this.orbitControls.target.copy(this.orbitTargetWorldPos);
-    }
-    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.
-   */
-  setDebugDelegate(delegate) {
-    if (this.debugDelegate === delegate) {
-      return;
-    }
-    this.detachDebugDelegate();
-    this.debugDelegate = delegate;
-    if (!delegate) {
-      this.applyDebugState({ enabled: false, selected: [] });
-      return;
-    }
-    const unsubscribe = delegate.subscribe((state) => {
-      this.applyDebugState(state);
-    });
-    this.debugUnsubscribe = () => {
-      unsubscribe?.();
-    };
-  }
-  /**
-   * Clean up resources.
-   */
-  dispose() {
-    this.disableOrbitControls();
-    this.detachDebugDelegate();
-  }
-  /**
-   * Get the current debug state snapshot.
-   */
-  get debugState() {
-    return this.debugStateSnapshot;
-  }
-  applyDebugState(state) {
-    const wasEnabled = this.debugStateSnapshot.enabled;
-    this.debugStateSnapshot = {
-      enabled: state.enabled,
-      selected: [...state.selected]
-    };
-    if (state.enabled && !wasEnabled) {
-      this.saveCameraState();
-      this.detachCameraFromRig();
-      this.enableOrbitControls();
-      this.restoreDebugCameraState();
-      this.updateOrbitTargetFromSelection(state.selected);
-    } else if (!state.enabled && wasEnabled) {
-      this.saveDebugCameraState();
-      this.orbitTarget = null;
-      if (!this._userOrbitEnabled) {
-        this.disableOrbitControls();
-      }
-      this.reattachCameraToRig();
-      this.restoreCameraState();
-    } else if (state.enabled) {
-      this.updateOrbitTargetFromSelection(state.selected);
-    }
-  }
-  enableOrbitControls() {
-    if (this.orbitControls) {
-      return;
-    }
-    this.orbitControls = new OrbitControls(this.camera, this.domElement);
-    this.orbitControls.enableDamping = true;
-    this.orbitControls.dampingFactor = 0.05;
-    this.orbitControls.screenSpacePanning = false;
-    this.orbitControls.minDistance = 1;
-    this.orbitControls.maxDistance = 500;
-    this.orbitControls.maxPolarAngle = Math.PI / 2;
-    this.orbitControls.target.set(0, 0, 0);
-  }
-  disableOrbitControls() {
-    if (!this.orbitControls) {
-      return;
-    }
-    this.orbitControls.dispose();
-    this.orbitControls = null;
-  }
-  updateOrbitTargetFromSelection(selected) {
-    if (!this.debugDelegate || selected.length === 0) {
-      this.orbitTarget = null;
-      if (this.orbitControls) {
-        this.orbitControls.target.set(0, 0, 0);
-      }
-      return;
-    }
-    for (let i = selected.length - 1; i >= 0; i -= 1) {
-      const uuid = selected[i];
-      const targetObject = this.debugDelegate.resolveTarget(uuid);
-      if (targetObject) {
-        this.orbitTarget = targetObject;
-        if (this.orbitControls) {
-          targetObject.getWorldPosition(this.orbitTargetWorldPos);
-          this.orbitControls.target.copy(this.orbitTargetWorldPos);
-        }
-        return;
-      }
-    }
-    this.orbitTarget = null;
-  }
-  detachDebugDelegate() {
-    if (this.debugUnsubscribe) {
-      try {
-        this.debugUnsubscribe();
-      } catch {
-      }
-    }
-    this.debugUnsubscribe = null;
-    this.debugDelegate = null;
-  }
-  /**
-   * Save camera position, rotation, and zoom before entering debug mode.
-   */
-  saveCameraState() {
-    this.savedCameraPosition = this.camera.position.clone();
-    this.savedCameraQuaternion = this.camera.quaternion.clone();
-    if ("zoom" in this.camera) {
-      this.savedCameraZoom = this.camera.zoom;
-    }
-  }
-  /**
-   * Restore camera position, rotation, and zoom when exiting debug mode.
-   */
-  restoreCameraState() {
-    if (this.savedCameraPosition) {
-      this.camera.position.copy(this.savedCameraPosition);
-      this.savedCameraPosition = null;
-    }
-    if (this.savedCameraQuaternion) {
-      this.camera.quaternion.copy(this.savedCameraQuaternion);
-      this.savedCameraQuaternion = null;
-    }
-    if (this.savedCameraZoom !== null && "zoom" in this.camera) {
-      this.camera.zoom = this.savedCameraZoom;
-      this.camera.updateProjectionMatrix?.();
-      this.savedCameraZoom = null;
-    }
-  }
-  /**
-   * Save debug camera state when exiting debug mode.
-   */
-  saveDebugCameraState() {
-    this.savedDebugCameraPosition = this.camera.position.clone();
-    this.savedDebugCameraQuaternion = this.camera.quaternion.clone();
-    if ("zoom" in this.camera) {
-      this.savedDebugCameraZoom = this.camera.zoom;
-    }
-    if (this.orbitControls) {
-      this.savedDebugOrbitTarget = this.orbitControls.target.clone();
-    }
-  }
-  /**
-   * Restore debug camera state when re-entering debug mode.
-   */
-  restoreDebugCameraState() {
-    if (this.savedDebugCameraPosition) {
-      this.camera.position.copy(this.savedDebugCameraPosition);
-    }
-    if (this.savedDebugCameraQuaternion) {
-      this.camera.quaternion.copy(this.savedDebugCameraQuaternion);
-    }
-    if (this.savedDebugCameraZoom !== null && "zoom" in this.camera) {
-      this.camera.zoom = this.savedDebugCameraZoom;
-      this.camera.updateProjectionMatrix?.();
-    }
-    if (this.savedDebugOrbitTarget && this.orbitControls) {
-      this.orbitControls.target.copy(this.savedDebugOrbitTarget);
-    }
-  }
-  /**
-   * Detach camera from its rig to allow free orbit movement in debug mode.
-   * Preserves the camera's world position.
-   */
-  detachCameraFromRig() {
-    if (!this.cameraRig || this.camera.parent !== this.cameraRig) {
-      return;
-    }
-    this.savedCameraLocalPosition = this.camera.position.clone();
-    const worldPos = new Vector3();
-    this.camera.getWorldPosition(worldPos);
-    this.cameraRig.remove(this.camera);
-    if (this.sceneRef) {
-      this.sceneRef.add(this.camera);
-    }
-    this.camera.position.copy(worldPos);
-  }
-  /**
-   * Reattach camera to its rig when exiting debug mode.
-   * Restores the camera's local position relative to the rig.
-   */
-  reattachCameraToRig() {
-    if (!this.cameraRig || this.camera.parent === this.cameraRig) {
-      return;
-    }
-    if (this.sceneRef && this.camera.parent === this.sceneRef) {
-      this.sceneRef.remove(this.camera);
-    }
-    this.cameraRig.add(this.camera);
-    if (this.savedCameraLocalPosition) {
-      this.camera.position.copy(this.savedCameraLocalPosition);
-      this.savedCameraLocalPosition = 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;
-  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 {
-    }
-  }
-};
-
-// 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._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).
-   */
-  isDebugModeActive() {
-    return this.orbitController?.isActive ?? false;
-  }
-  /**
-   * Enable user-configured orbital controls (not debug mode).
-   */
-  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);
-    }
-  }
-  /**
-   * 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.orbitController?.dispose();
-    } catch {
-    }
-    try {
-      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) ─────────────────────────────────
-  /**
-   * Directly set the camera position.
-   */
-  move(position) {
-    if (this._perspective === Perspectives.Flat2D || this._perspective === Perspectives.Fixed2D) {
-      this.frustumSize = position.z;
-    }
-    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;
-  }
-  /**
-   * 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) {
-    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 a Three.js camera based on perspective type.
-   */
-  createCameraForPerspective(aspectRatio) {
-    switch (this._perspective) {
-      case Perspectives.ThirdPerson:
-        return new PerspectiveCamera2(75, aspectRatio, 0.1, 1e3);
-      case Perspectives.FirstPerson:
-        return new PerspectiveCamera2(75, aspectRatio, 0.1, 1e3);
-      case Perspectives.Isometric:
-        return new OrthographicCamera(
-          this.frustumSize * aspectRatio / -2,
-          this.frustumSize * aspectRatio / 2,
-          this.frustumSize / 2,
-          this.frustumSize / -2,
-          1,
-          1e3
-        );
-      case Perspectives.Flat2D:
-      case Perspectives.Fixed2D:
-        return new OrthographicCamera(
-          this.frustumSize * aspectRatio / -2,
-          this.frustumSize * aspectRatio / 2,
-          this.frustumSize / 2,
-          this.frustumSize / -2,
-          1,
-          1e3
-        );
-      default:
-        return new PerspectiveCamera2(75, aspectRatio, 0.1, 1e3);
-    }
-  }
-};
-
-// src/lib/camera/camera.ts
-var CameraWrapper = class {
-  cameraRef;
-  constructor(camera) {
-    this.cameraRef = camera;
-  }
-  // ─── Target management ──────────────────────────────────────────────────
-  /**
-   * Add a target entity for the camera to follow/frame.
-   * With multiple targets, the camera auto-frames to include all of them.
-   */
-  addTarget(entity) {
-    this.cameraRef.addTarget(entity);
-  }
-  /**
-   * Remove a target entity from the camera.
-   */
-  removeTarget(entity) {
-    this.cameraRef.removeTarget(entity);
-  }
-  /**
-   * Clear all targets. Camera will look at world origin.
-   */
-  clearTargets() {
-    this.cameraRef.clearTargets();
-  }
-  // ─── Orbital controls ───────────────────────────────────────────────────
-  /**
-   * Enable orbital controls for this camera.
-   * Allows the user to orbit, pan, and zoom the camera.
-   */
-  enableOrbitalControls() {
-    this.cameraRef.enableOrbitalControls();
-  }
-  /**
-   * Disable orbital controls for this camera.
-   */
-  disableOrbitalControls() {
-    this.cameraRef.disableOrbitalControls();
-  }
-  // ─── 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);
-  }
-  // ─── 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);
-  }
-  /**
-   * Remove a behavior by key.
-   */
-  removeBehavior(key) {
-    return this.cameraRef.pipeline.removeBehavior(key);
-  }
-  // ─── 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);
-  }
-  // ─── 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));
-  }
-  /**
-   * 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);
-   */
-  getPerspective() {
-    return this.cameraRef.pipeline.perspective;
-  }
-  // ─── Pipeline: Debug state ──────────────────────────────────────────────
-  /**
-   * Return a debug snapshot of the camera pipeline state.
-   * Includes: active perspective, desired/final pose, behavior keys, action count.
-   */
-  getState() {
-    return this.cameraRef.pipeline.getState();
-  }
-  // ─── 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) {
-  const screenResolution = options.screenResolution || new Vector23(window.innerWidth, window.innerHeight);
-  let frustumSize = 10;
-  if (options.perspective === "fixed-2d") {
-    frustumSize = options.zoom || 10;
-  }
-  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,
-  isWebGPUSupported
-};
-//# sourceMappingURL=camera.js.map