bloody-engine 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Bloody Engine Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,92 @@
+# Bloody Engine
+
+A WebGL-based 2.5D graphics engine for isometric rendering, written in TypeScript. Designed for both browser and Node.js environments with full isomorphic support.
+
+## Features
+
+- **2.5D Rendering** - Optimized for isometric and dimetric projections
+- **Cross-Platform** - Works in browsers and Node.js (headless rendering)
+- **Batch Rendering** - Efficient sprite batching with GPU-accelerated transformations
+- **Resource Management** - Unified asset loading pipeline for textures and resources
+- **TypeScript** - Fully typed for excellent developer experience
+- **Depth Sorting** - Proper 2.5D occlusion handling
+
+## Installation
+
+```bash
+npm install bloody-engine
+```
+
+## Quick Start
+
+### Browser
+
+```typescript
+import { BloodyEngine } from 'bloody-engine';
+
+// Initialize engine
+const engine = new BloodyEngine({
+  width: 800,
+  height: 600
+});
+
+// Start rendering loop
+engine.start();
+```
+
+### Node.js
+
+```typescript
+import { BloodyEngine } from 'bloody-engine';
+
+// Initialize engine for headless rendering
+const engine = new BloodyEngine({
+  width: 800,
+  height: 600,
+  headless: true
+});
+
+// Render and capture output
+engine.renderFrame();
+const pixels = engine.getPixels();
+```
+
+## Documentation
+
+For detailed documentation and architecture, see [docs/README.MD](docs/README.MD).
+
+## Examples
+
+```typescript
+// Create a sprite batch renderer
+import { SpriteBatchRenderer, Texture } from 'bloody-engine';
+
+const batchRenderer = new SpriteBatchRenderer(gl, shader);
+
+// Add sprites
+batchRenderer.addQuad({
+  x: 100,
+  y: 100,
+  z: 0,
+  width: 64,
+  height: 64,
+  rotation: 0,
+  color: { r: 1, g: 1, b: 1, a: 1 },
+  uvRect: { uMin: 0, vMin: 0, uMax: 1, vMax: 1 }
+});
+
+// Render
+batchRenderer.render(camera);
+```
+
+## License
+
+MIT License - see [LICENSE](LICENSE) for details.
+
+## Repository
+
+[https://github.com/BLooDek/bloody-engine](https://github.com/BLooDek/bloody-engine)
+
+## Issues
+
+Report bugs and request features at: [https://github.com/BLooDek/bloody-engine/issues](https://github.com/BLooDek/bloody-engine/issues)

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

@@ -0,0 +1,308 @@
+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

@@ -0,0 +1,146 @@
+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
+};