bloody-engine 1.0.1 → 1.0.2

package/dist/node/camera-A8EGrk7U.js

@@ -1,271 +0,0 @@
-class Matrix4 {
-  /**
-   * Create an identity matrix
-   * @returns 4x4 identity matrix in column-major order
-   */
-  static identity() {
-    return new Float32Array([
-      1,
-      0,
-      0,
-      0,
-      // column 0
-      0,
-      1,
-      0,
-      0,
-      // column 1
-      0,
-      0,
-      1,
-      0,
-      // column 2
-      0,
-      0,
-      0,
-      1
-      // column 3
-    ]);
-  }
-  /**
-   * Create a translation matrix
-   * @param x Translation along X axis
-   * @param y Translation along Y axis
-   * @param z Translation along Z axis (default 0)
-   * @returns 4x4 translation matrix in column-major order
-   */
-  static translation(x, y, z = 0) {
-    return new Float32Array([
-      1,
-      0,
-      0,
-      0,
-      // column 0
-      0,
-      1,
-      0,
-      0,
-      // column 1
-      0,
-      0,
-      1,
-      0,
-      // column 2
-      x,
-      y,
-      z,
-      1
-      // column 3
-    ]);
-  }
-  /**
-   * Create a scale matrix
-   * @param x Scale factor along X axis
-   * @param y Scale factor along Y axis
-   * @param z Scale factor along Z axis (default 1)
-   * @returns 4x4 scale matrix in column-major order
-   */
-  static scale(x, y, z = 1) {
-    return new Float32Array([
-      x,
-      0,
-      0,
-      0,
-      // column 0
-      0,
-      y,
-      0,
-      0,
-      // column 1
-      0,
-      0,
-      z,
-      0,
-      // column 2
-      0,
-      0,
-      0,
-      1
-      // column 3
-    ]);
-  }
-  /**
-   * Multiply two matrices (result = a * b)
-   * @param a First matrix (left operand)
-   * @param b Second matrix (right operand)
-   * @returns Result of matrix multiplication in column-major order
-   */
-  static multiply(a, b) {
-    const result = new Float32Array(16);
-    for (let col = 0; col < 4; col++) {
-      for (let row = 0; row < 4; row++) {
-        let sum = 0;
-        for (let k = 0; k < 4; k++) {
-          sum += a[k * 4 + row] * b[col * 4 + k];
-        }
-        result[col * 4 + row] = sum;
-      }
-    }
-    return result;
-  }
-  /**
-   * Create a view matrix from camera position and zoom
-   * The view matrix transforms world coordinates to camera/eye coordinates
-   *
-   * View = Translation(-cameraX, -cameraY, 0) * Scale(zoom, zoom, 1)
-   *
-   * @param x Camera X position (translation will be negative)
-   * @param y Camera Y position (translation will be negative)
-   * @param zoom Camera zoom level (1.0 = no zoom, >1 = zoom in, <1 = zoom out)
-   * @returns 4x4 view matrix in column-major order
-   */
-  static createViewMatrix(x, y, zoom) {
-    const translation = Matrix4.translation(-x, -y, 0);
-    const scale = Matrix4.scale(zoom, zoom, 1);
-    return Matrix4.multiply(translation, scale);
-  }
-}
-class Camera {
-  /**
-   * Create a new camera
-   * @param x Initial X position (default 0)
-   * @param y Initial Y position (default 0)
-   * @param zoom Initial zoom level (default 1.0)
-   */
-  constructor(x = 0, y = 0, zoom = 1) {
-    this._viewMatrix = null;
-    this._viewMatrixDirty = true;
-    this._x = x;
-    this._y = y;
-    this._zoom = zoom;
-  }
-  /**
-   * Get the camera X position
-   */
-  get x() {
-    return this._x;
-  }
-  /**
-   * Set the camera X position
-   */
-  set x(value) {
-    this._x = value;
-    this._viewMatrixDirty = true;
-  }
-  /**
-   * Get the camera Y position
-   */
-  get y() {
-    return this._y;
-  }
-  /**
-   * Set the camera Y position
-   */
-  set y(value) {
-    this._y = value;
-    this._viewMatrixDirty = true;
-  }
-  /**
-   * Get the camera zoom level
-   */
-  get zoom() {
-    return this._zoom;
-  }
-  /**
-   * Set the camera zoom level
-   * Values: 1.0 = no zoom, >1 = zoom in, <1 = zoom out
-   */
-  set zoom(value) {
-    this._zoom = Math.max(1e-3, value);
-    this._viewMatrixDirty = true;
-  }
-  /**
-   * Set both X and Y position at once
-   * @param x New X position
-   * @param y New Y position
-   */
-  setPosition(x, y) {
-    this._x = x;
-    this._y = y;
-    this._viewMatrixDirty = true;
-  }
-  /**
-   * Move the camera by a relative offset
-   * @param dx X offset to add to current position
-   * @param dy Y offset to add to current position
-   */
-  move(dx, dy) {
-    this._x += dx;
-    this._y += dy;
-    this._viewMatrixDirty = true;
-  }
-  /**
-   * Scale the zoom by a factor
-   * @param factor Multiplier for current zoom (e.g., 1.1 to zoom in 10%)
-   */
-  zoomBy(factor) {
-    this._zoom = Math.max(1e-3, this._zoom * factor);
-    this._viewMatrixDirty = true;
-  }
-  /**
-   * Reset camera to default position and zoom
-   */
-  reset() {
-    this._x = 0;
-    this._y = 0;
-    this._zoom = 1;
-    this._viewMatrixDirty = true;
-  }
-  /**
-   * Get the view matrix for this camera
-   * The view matrix transforms world coordinates to camera space
-   * Caches the result until camera properties change
-   *
-   * @returns 4x4 view matrix in column-major order
-   */
-  getViewMatrix() {
-    if (this._viewMatrixDirty || this._viewMatrix === null) {
-      this._viewMatrix = Matrix4.createViewMatrix(this._x, this._y, this._zoom);
-      this._viewMatrixDirty = false;
-    }
-    return this._viewMatrix;
-  }
-  /**
-   * Convert screen coordinates to world coordinates
-   * Useful for mouse picking and interaction
-   *
-   * @param screenX Screen X coordinate (pixels)
-   * @param screenY Screen Y coordinate (pixels)
-   * @param viewportWidth Viewport width in pixels
-   * @param viewportHeight Viewport height in pixels
-   * @returns World coordinates {x, y}
-   */
-  screenToWorld(screenX, screenY, viewportWidth, viewportHeight) {
-    const centeredX = screenX - viewportWidth / 2;
-    const centeredY = screenY - viewportHeight / 2;
-    const worldX = centeredX / this._zoom + this._x;
-    const worldY = centeredY / this._zoom + this._y;
-    return { x: worldX, y: worldY };
-  }
-  /**
-   * Convert world coordinates to screen coordinates
-   * Useful for UI positioning and debug rendering
-   *
-   * @param worldX World X coordinate
-   * @param worldY World Y coordinate
-   * @param viewportWidth Viewport width in pixels
-   * @param viewportHeight Viewport height in pixels
-   * @returns Screen coordinates {x, y} in pixels
-   */
-  worldToScreen(worldX, worldY, viewportWidth, viewportHeight) {
-    const centeredX = (worldX - this._x) * this._zoom;
-    const centeredY = (worldY - this._y) * this._zoom;
-    const screenX = centeredX + viewportWidth / 2;
-    const screenY = centeredY + viewportHeight / 2;
-    return { x: screenX, y: screenY };
-  }
-}
-export {
-  Camera,
-  Matrix4
-};