bloody-engine 1.0.1 → 1.0.3

package/dist/node/batch-renderer-JqZ4TYcL.js

@@ -1,308 +0,0 @@
-class SpriteBatchRenderer {
-  /**
-   * Create a new sprite batch renderer (V2)
-   * @param gl WebGL rendering context
-   * @param shader Shader program to use (should be SHADERS_V2)
-   * @param maxQuads Maximum number of quads to batch (default 1000)
-   */
-  constructor(gl, shader, maxQuads = 1e3) {
-    this.vertexBuffer = null;
-    this.quads = [];
-    this.isDirty = false;
-    this.verticesPerQuad = 6;
-    this.floatsPerVertex = 10;
-    this.texture = null;
-    this.depthTestEnabled = true;
-    this.gl = gl;
-    this.shader = shader;
-    this.maxQuads = maxQuads;
-    const totalFloats = maxQuads * this.verticesPerQuad * this.floatsPerVertex;
-    this.vertexData = new Float32Array(totalFloats);
-    const buf = gl.createBuffer();
-    if (!buf) {
-      throw new Error("Failed to create vertex buffer");
-    }
-    this.vertexBuffer = buf;
-    gl.bindBuffer(gl.ARRAY_BUFFER, this.vertexBuffer);
-    gl.bufferData(gl.ARRAY_BUFFER, this.vertexData.byteLength, gl.DYNAMIC_DRAW);
-    gl.bindBuffer(gl.ARRAY_BUFFER, null);
-  }
-  /**
-   * Set the texture for batch rendering
-   * @param texture The texture to use when rendering
-   */
-  setTexture(texture) {
-    this.texture = texture;
-  }
-  /**
-   * Add a sprite quad to the batch
-   * @param quad Sprite quad instance to add
-   */
-  addQuad(quad) {
-    if (this.quads.length >= this.maxQuads) {
-      console.warn(`Sprite batch renderer at max capacity (${this.maxQuads})`);
-      return;
-    }
-    this.quads.push(quad);
-    this.isDirty = true;
-  }
-  /**
-   * Clear all quads from the batch
-   */
-  clear() {
-    this.quads = [];
-    this.isDirty = true;
-  }
-  /**
-   * Get number of quads currently in batch
-   */
-  getQuadCount() {
-    return this.quads.length;
-  }
-  /**
-   * Update the batch - rebuilds vertex buffer if quads changed
-   */
-  update() {
-    if (!this.isDirty || this.quads.length === 0) {
-      return;
-    }
-    let vertexIndex = 0;
-    for (const quad of this.quads) {
-      const {
-        x,
-        y,
-        z = 0,
-        width,
-        height,
-        rotation,
-        color = { r: 1, g: 1, b: 1, a: 1 },
-        uvRect = { uMin: 0, vMin: 0, uMax: 1, vMax: 1 },
-        texIndex = 0
-      } = quad;
-      const vertices = this.generateQuadVertices({
-        x,
-        y,
-        z,
-        width,
-        height,
-        rotation,
-        color,
-        uvRect,
-        texIndex
-      });
-      for (const vertex of vertices) {
-        this.vertexData[vertexIndex++] = vertex.x;
-        this.vertexData[vertexIndex++] = vertex.y;
-        this.vertexData[vertexIndex++] = vertex.z;
-        this.vertexData[vertexIndex++] = vertex.u;
-        this.vertexData[vertexIndex++] = vertex.v;
-        this.vertexData[vertexIndex++] = vertex.r;
-        this.vertexData[vertexIndex++] = vertex.g;
-        this.vertexData[vertexIndex++] = vertex.b;
-        this.vertexData[vertexIndex++] = vertex.a;
-        this.vertexData[vertexIndex++] = vertex.texIndex;
-      }
-    }
-    if (this.vertexBuffer) {
-      this.gl.bindBuffer(this.gl.ARRAY_BUFFER, this.vertexBuffer);
-      this.gl.bufferSubData(
-        this.gl.ARRAY_BUFFER,
-        0,
-        this.vertexData.subarray(0, vertexIndex)
-      );
-      this.gl.bindBuffer(this.gl.ARRAY_BUFFER, null);
-    }
-    this.isDirty = false;
-  }
-  /**
-   * Set whether depth testing is enabled
-   * When enabled, sprites with lower Z values appear behind sprites with higher Z values
-   * @param enabled Whether to enable depth testing (default true)
-   */
-  setDepthTestEnabled(enabled) {
-    this.depthTestEnabled = enabled;
-  }
-  /**
-   * Render the batch
-   * @param camera Optional camera for view transform (defaults to identity matrix)
-   */
-  render(camera) {
-    if (this.quads.length === 0) {
-      return;
-    }
-    this.update();
-    this.shader.use();
-    if (this.depthTestEnabled) {
-      this.gl.enable(this.gl.DEPTH_TEST);
-      this.gl.depthFunc(this.gl.LEQUAL);
-    } else {
-      this.gl.disable(this.gl.DEPTH_TEST);
-    }
-    if (this.vertexBuffer) {
-      this.gl.bindBuffer(this.gl.ARRAY_BUFFER, this.vertexBuffer);
-      const posAttr = this.shader.getAttributeLocation("aPosition");
-      const texCoordAttr = this.shader.getAttributeLocation("aTexCoord");
-      const colorAttr = this.shader.getAttributeLocation("aColor");
-      const texIndexAttr = this.shader.getAttributeLocation("aTexIndex");
-      const stride = this.floatsPerVertex * 4;
-      if (posAttr !== -1) {
-        this.gl.enableVertexAttribArray(posAttr);
-        this.gl.vertexAttribPointer(
-          posAttr,
-          3,
-          // 3 floats (x, y, z)
-          this.gl.FLOAT,
-          false,
-          stride,
-          0
-          // offset
-        );
-      }
-      if (texCoordAttr !== -1) {
-        this.gl.enableVertexAttribArray(texCoordAttr);
-        this.gl.vertexAttribPointer(
-          texCoordAttr,
-          2,
-          // 2 floats (u, v)
-          this.gl.FLOAT,
-          false,
-          stride,
-          3 * 4
-          // offset after position
-        );
-      }
-      if (colorAttr !== -1) {
-        this.gl.enableVertexAttribArray(colorAttr);
-        this.gl.vertexAttribPointer(
-          colorAttr,
-          4,
-          // 4 floats (r, g, b, a)
-          this.gl.FLOAT,
-          false,
-          stride,
-          5 * 4
-          // offset after texCoord
-        );
-      }
-      if (texIndexAttr !== -1) {
-        this.gl.enableVertexAttribArray(texIndexAttr);
-        this.gl.vertexAttribPointer(
-          texIndexAttr,
-          1,
-          // 1 float (texIndex)
-          this.gl.FLOAT,
-          false,
-          stride,
-          9 * 4
-          // offset after color
-        );
-      }
-      if (this.texture) {
-        this.texture.bind(0);
-        const textureUniform = this.shader.getUniformLocation("uTexture");
-        if (textureUniform !== null) {
-          this.gl.uniform1i(textureUniform, 0);
-        }
-      }
-      const matrixUniform = this.shader.getUniformLocation("uMatrix");
-      if (matrixUniform !== null) {
-        const matrix = camera ? camera.getViewMatrix() : new Float32Array([
-          1,
-          0,
-          0,
-          0,
-          0,
-          1,
-          0,
-          0,
-          0,
-          0,
-          1,
-          0,
-          0,
-          0,
-          0,
-          1
-        ]);
-        this.gl.uniformMatrix4fv(matrixUniform, false, matrix);
-      }
-      const vertexCount = this.quads.length * this.verticesPerQuad;
-      this.gl.drawArrays(this.gl.TRIANGLES, 0, vertexCount);
-      this.gl.bindBuffer(this.gl.ARRAY_BUFFER, null);
-    }
-  }
-  /**
-   * Generate vertices for a quad with rotation applied
-   * Returns 6 vertices (2 triangles)
-   * @private
-   */
-  generateQuadVertices(instance) {
-    const { x, y, z, width, height, rotation, color, uvRect, texIndex } = instance;
-    const halfW = width / 2;
-    const halfH = height / 2;
-    const cos = Math.cos(rotation);
-    const sin = Math.sin(rotation);
-    const rotatePoint = (px, py) => {
-      return [px * cos - py * sin, px * sin + py * cos];
-    };
-    const corners = [
-      [-halfW, -halfH],
-      // bottom-left
-      [halfW, -halfH],
-      // bottom-right
-      [halfW, halfH],
-      // top-right
-      [halfW, halfH],
-      // top-right (duplicate)
-      [-halfW, halfH],
-      // top-left
-      [-halfW, -halfH]
-      // bottom-left (duplicate)
-    ];
-    const texCoords = [
-      [uvRect.uMin, uvRect.vMin],
-      // bottom-left
-      [uvRect.uMax, uvRect.vMin],
-      // bottom-right
-      [uvRect.uMax, uvRect.vMax],
-      // top-right
-      [uvRect.uMax, uvRect.vMax],
-      // top-right
-      [uvRect.uMin, uvRect.vMax],
-      // top-left
-      [uvRect.uMin, uvRect.vMin]
-      // bottom-left
-    ];
-    const vertices = [];
-    for (let i = 0; i < corners.length; i++) {
-      const [localX, localY] = corners[i];
-      const [rotX, rotY] = rotatePoint(localX, localY);
-      const [u, v] = texCoords[i];
-      vertices.push({
-        x: x + rotX,
-        y: y + rotY,
-        z,
-        u,
-        v,
-        r: color.r,
-        g: color.g,
-        b: color.b,
-        a: color.a,
-        texIndex
-      });
-    }
-    return vertices;
-  }
-  /**
-   * Dispose resources
-   */
-  dispose() {
-    if (this.vertexBuffer) {
-      this.gl.deleteBuffer(this.vertexBuffer);
-      this.vertexBuffer = null;
-    }
-  }
-}
-export {
-  SpriteBatchRenderer
-};

package/dist/node/browser-resource-loader-D51BD3k_.js

@@ -1,146 +0,0 @@
-class BrowserResourceLoader {
-  /**
-   * Create a new browser resource loader
-   * @param baseUrl Optional base URL for resolving relative paths (defaults to current origin)
-   * @param timeout Default timeout for requests in milliseconds (default: 10000)
-   */
-  constructor(baseUrl = "", timeout = 1e4) {
-    this.baseUrl = baseUrl || this.getCurrentOrigin();
-    this.defaultTimeout = timeout;
-  }
-  /**
-   * Get the current origin (protocol + host + port)
-   */
-  getCurrentOrigin() {
-    return typeof window !== "undefined" ? window.location.origin : "http://localhost";
-  }
-  /**
-   * Resolve a relative path against the base URL
-   * @param path Relative or absolute path
-   * @returns Resolved absolute URL
-   */
-  resolvePath(path) {
-    try {
-      if (path.startsWith("http://") || path.startsWith("https://")) {
-        return path;
-      }
-      if (path.startsWith("//")) {
-        return window.location.protocol + path;
-      }
-      if (path.startsWith("/")) {
-        return this.baseUrl + path;
-      }
-      return `${this.baseUrl}/${path}`;
-    } catch {
-      return path;
-    }
-  }
-  /**
-   * Load a single resource from a URL
-   * @param path URL or relative path to the resource
-   * @param options Optional loading configuration
-   * @returns Promise resolving to the resource content
-   */
-  async load(path, options) {
-    const url = this.resolvePath(path);
-    try {
-      const fetchOptions = {
-        credentials: options?.credentials || "same-origin"
-      };
-      if (options?.headers) {
-        fetchOptions.headers = options.headers;
-      }
-      const controller = new AbortController();
-      const timeoutId = setTimeout(() => controller.abort(), this.defaultTimeout);
-      fetchOptions.signal = controller.signal;
-      const response = await fetch(url, fetchOptions);
-      clearTimeout(timeoutId);
-      if (!response.ok) {
-        throw new Error(
-          `HTTP ${response.status}: ${response.statusText} for URL: ${url}`
-        );
-      }
-      const text = await response.text();
-      return text;
-    } catch (error) {
-      if (error instanceof Error) {
-        if (error.name === "AbortError") {
-          throw new Error(
-            `Request timeout after ${this.defaultTimeout}ms for URL: ${url}`
-          );
-        }
-        throw new Error(`Failed to load resource from ${url}: ${error.message}`);
-      }
-      throw new Error(`Failed to load resource from ${url}: Unknown error`);
-    }
-  }
-  /**
-   * Load multiple resources in parallel
-   * @param paths Array of URLs or paths
-   * @param options Optional loading configuration
-   * @returns Promise resolving to array of load results
-   */
-  async loadMultiple(paths, options) {
-    const promises = paths.map(async (path) => {
-      try {
-        const data = await this.load(path, options);
-        return {
-          data,
-          path,
-          success: true
-        };
-      } catch (error) {
-        return {
-          data: "",
-          path,
-          success: false,
-          error: error instanceof Error ? error.message : String(error)
-        };
-      }
-    });
-    return Promise.all(promises);
-  }
-  /**
-   * Check if the path is valid for loading in the browser
-   * @param path URL or path to check
-   * @returns true if the path can be loaded
-   */
-  canLoad(path) {
-    const validPatterns = [
-      /^https?:\/\//i,
-      // Absolute HTTP(S) URLs
-      /^\/\//,
-      // Protocol-relative URLs
-      /^\//,
-      // Absolute paths
-      /^\.\.?\//
-      // Relative paths starting with ./ or ../
-    ];
-    const hasFileExtension = /\.[a-z0-9]+$/i.test(path);
-    return validPatterns.some((pattern) => pattern.test(path)) || hasFileExtension;
-  }
-  /**
-   * Set a new base URL for resolving relative paths
-   * @param baseUrl New base URL
-   */
-  setBaseUrl(baseUrl) {
-    this.baseUrl = baseUrl;
-  }
-  /**
-   * Get the current base URL
-   * @returns Current base URL
-   */
-  getBaseUrl() {
-    return this.baseUrl;
-  }
-  /**
-   * Set the default request timeout
-   * @param timeout Timeout in milliseconds
-   */
-  setTimeout(timeout) {
-    this.defaultTimeout = timeout;
-  }
-}
-export {
-  BrowserResourceLoader
-};

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
-};