bloody-engine 1.0.1 → 1.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bloody-engine",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "description": "A WebGL-based 2.5D graphics engine for isometric rendering",
   "license": "MIT",
   "type": "module",

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