@zylem/game-lib 0.5.1 → 0.6.2

package/dist/camera.js

@@ -1,9 +1,8 @@
 // src/lib/camera/camera.ts
-import { Vector2 as Vector23, Vector3 as Vector33 } from "three";
+import { Vector2 as Vector23, Vector3 as Vector34 } from "three";
 
 // src/lib/camera/zylem-camera.ts
-import { PerspectiveCamera, Vector3 as Vector32, Object3D, OrthographicCamera, WebGLRenderer as WebGLRenderer3 } from "three";
-import { OrbitControls } from "three/addons/controls/OrbitControls.js";
+import { PerspectiveCamera, Vector3 as Vector33, Object3D as Object3D2, OrthographicCamera, WebGLRenderer as WebGLRenderer3 } from "three";
 
 // src/lib/camera/perspective.ts
 var Perspectives = {
@@ -29,11 +28,11 @@ var ThirdPersonCamera = class {
    * Setup the third person camera controller
    */
   setup(params) {
-    const { screenResolution, renderer, scene, camera: camera2 } = params;
+    const { screenResolution, renderer, scene, camera } = params;
     this.screenResolution = screenResolution;
     this.renderer = renderer;
     this.scene = scene;
-    this.cameraRef = camera2;
+    this.cameraRef = camera;
   }
   /**
    * Update the third person camera
@@ -74,11 +73,11 @@ var Fixed2DCamera = class {
    * Setup the fixed 2D camera controller
    */
   setup(params) {
-    const { screenResolution, renderer, scene, camera: camera2 } = params;
+    const { screenResolution, renderer, scene, camera } = params;
     this.screenResolution = screenResolution;
     this.renderer = renderer;
     this.scene = scene;
-    this.cameraRef = camera2;
+    this.cameraRef = camera;
     this.cameraRef.camera.position.set(0, 0, 10);
     this.cameraRef.camera.lookAt(0, 0, 0);
   }
@@ -104,11 +103,33 @@ import { EffectComposer } from "three/examples/jsm/postprocessing/EffectComposer
 // src/lib/graphics/render-pass.ts
 import * as THREE from "three";
 
-// src/lib/graphics/shaders/fragment/standard.glsl
-var standard_default = "uniform sampler2D tDiffuse;\nvarying vec2 vUv;\n\nvoid main() {\n	vec4 texel = texture2D( tDiffuse, vUv );\n\n	gl_FragColor = texel;\n}";
+// 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/vertex/standard.glsl
-var standard_default2 = "varying vec2 vUv;\n\nvoid main() {\n	vUv = uv;\n	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );\n}";
+// 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";
@@ -121,12 +142,12 @@ var RenderPass = class extends Pass {
   rgbRenderTarget;
   normalRenderTarget;
   normalMaterial;
-  constructor(resolution, scene, camera2) {
+  constructor(resolution, scene, camera) {
     super();
     this.resolution = resolution;
     this.fsQuad = new FullScreenQuad(this.material());
     this.scene = scene;
-    this.camera = camera2;
+    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();
@@ -167,8 +188,8 @@ var RenderPass = class extends Pass {
           )
         }
       },
-      vertexShader: standard_default2,
-      fragmentShader: standard_default
+      vertexShader: standardShader.vertex,
+      fragmentShader: standardShader.fragment
     });
   }
   dispose() {
@@ -188,25 +209,275 @@ var RenderPass = class extends Pass {
   }
 };
 
+// src/lib/camera/camera-debug-delegate.ts
+import { Vector3 as Vector32 } 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 Vector32();
+  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;
+  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).
+   */
+  get isActive() {
+    return this.debugStateSnapshot.enabled;
+  }
+  /**
+   * 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();
+  }
+  /**
+   * 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;
+      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 Vector32();
+    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/zylem-camera.ts
 var ZylemCamera = class {
-  cameraRig;
+  cameraRig = null;
   camera;
   screenResolution;
   renderer;
   composer;
   _perspective;
-  orbitControls = null;
   target = null;
   sceneRef = null;
   frustumSize = 10;
   // Perspective controller delegation
   perspectiveController = null;
-  debugDelegate = null;
-  debugUnsubscribe = null;
-  debugStateSnapshot = { enabled: false, selected: [] };
-  orbitTarget = null;
-  orbitTargetWorldPos = new Vector32();
+  // Debug/orbit controls delegation
+  orbitController = null;
   constructor(perspective, screenResolution, frustumSize = 10) {
     this._perspective = perspective;
     this.screenResolution = screenResolution;
@@ -217,26 +488,23 @@ var ZylemCamera = class {
     this.composer = new EffectComposer(this.renderer);
     const aspectRatio = screenResolution.x / screenResolution.y;
     this.camera = this.createCameraForPerspective(aspectRatio);
-    this.cameraRig = new Object3D();
-    this.cameraRig.position.set(0, 3, 10);
-    this.cameraRig.add(this.camera);
-    this.camera.lookAt(new Vector32(0, 2, 0));
+    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;
-    if (this.orbitControls === null) {
-      this.orbitControls = new OrbitControls(this.camera, this.renderer.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;
-    }
     let renderResolution = this.screenResolution.clone().divideScalar(2);
     renderResolution.x |= 0;
     renderResolution.y |= 0;
@@ -250,6 +518,7 @@ var ZylemCamera = class {
         camera: this
       });
     }
+    this.orbitController?.setScene(scene);
     this.renderer.setAnimationLoop((delta) => {
       this.update(delta || 0);
     });
@@ -258,16 +527,18 @@ var ZylemCamera = class {
    * Update camera and render
    */
   update(delta) {
-    if (this.orbitControls && this.orbitTarget) {
-      this.orbitTarget.getWorldPosition(this.orbitTargetWorldPos);
-      this.orbitControls.target.copy(this.orbitTargetWorldPos);
-    }
-    this.orbitControls?.update();
-    if (this.perspectiveController) {
+    this.orbitController?.update();
+    if (this.perspectiveController && !this.isDebugModeActive()) {
       this.perspectiveController.update(delta);
     }
     this.composer.render(delta);
   }
+  /**
+   * 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
    */
@@ -277,7 +548,7 @@ var ZylemCamera = class {
     } catch {
     }
     try {
-      this.disableOrbitControls();
+      this.orbitController?.dispose();
     } catch {
     }
     try {
@@ -289,28 +560,13 @@ var ZylemCamera = class {
       this.renderer.dispose();
     } catch {
     }
-    this.detachDebugDelegate();
     this.sceneRef = null;
   }
   /**
    * 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?.();
-    };
+    this.orbitController?.setDebugDelegate(delegate);
   }
   /**
    * Resize camera and renderer
@@ -402,15 +658,31 @@ var ZylemCamera = class {
     if (this._perspective === Perspectives.Flat2D || this._perspective === Perspectives.Fixed2D) {
       this.frustumSize = position.z;
     }
-    this.cameraRig.position.set(position.x, position.y, 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);
+    }
   }
   move(position) {
     this.moveCamera(position);
   }
   rotate(pitch, yaw, roll) {
-    this.cameraRig.rotateX(pitch);
-    this.cameraRig.rotateY(yaw);
-    this.cameraRig.rotateZ(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);
+    }
+  }
+  /**
+   * Check if this perspective type needs a camera rig
+   */
+  needsRig() {
+    return this._perspective === Perspectives.ThirdPerson;
   }
   /**
    * Get the DOM element for the renderer
@@ -418,89 +690,28 @@ var ZylemCamera = class {
   getDomElement() {
     return this.renderer.domElement;
   }
-  applyDebugState(state) {
-    this.debugStateSnapshot = {
-      enabled: state.enabled,
-      selected: [...state.selected]
-    };
-    if (state.enabled) {
-      this.enableOrbitControls();
-      this.updateOrbitTargetFromSelection(state.selected);
-    } else {
-      this.orbitTarget = null;
-      this.disableOrbitControls();
-    }
-  }
-  enableOrbitControls() {
-    if (this.orbitControls) {
-      return;
-    }
-    this.orbitControls = new OrbitControls(this.camera, this.renderer.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;
-  }
-  disableOrbitControls() {
-    if (!this.orbitControls) {
-      return;
-    }
-    this.orbitControls.dispose();
-    this.orbitControls = null;
-  }
-  updateOrbitTargetFromSelection(selected) {
-    if (!this.debugDelegate || selected.length === 0) {
-      this.orbitTarget = null;
-      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;
-  }
 };
 
 // src/lib/camera/camera.ts
 var CameraWrapper = class {
   cameraRef;
-  constructor(camera2) {
-    this.cameraRef = camera2;
+  constructor(camera) {
+    this.cameraRef = camera;
   }
 };
-function camera(options) {
+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);
-  zylemCamera.move(options.position || new Vector33(0, 0, 0));
-  zylemCamera.camera.lookAt(options.target || new Vector33(0, 0, 0));
+  zylemCamera.move(options.position || new Vector34(0, 0, 0));
+  zylemCamera.camera.lookAt(options.target || new Vector34(0, 0, 0));
   return new CameraWrapper(zylemCamera);
 }
 export {
   Perspectives,
-  camera
+  createCamera
 };
 //# sourceMappingURL=camera.js.map