bloody-engine 1.0.0 → 1.0.2

package/dist/node/index.js

@@ -0,0 +1,2364 @@
+import createGL from "gl";
+import * as fs from "fs/promises";
+import * as path from "path";
+class BrowserRenderingContext {
+  constructor(options) {
+    this.isBrowser = true;
+    if (!options.canvas) {
+      this.canvas = document.createElement("canvas");
+      document.body.appendChild(this.canvas);
+    } else {
+      this.canvas = options.canvas;
+    }
+    this.width = options.width;
+    this.height = options.height;
+    this.canvas.width = this.width;
+    this.canvas.height = this.height;
+    const contextAttributes = {
+      alpha: false,
+      ...options.contextAttributes
+    };
+    const glContext = this.canvas.getContext("webgl", contextAttributes);
+    if (!glContext) {
+      throw new Error("Failed to initialize WebGL context in browser");
+    }
+    this.glContext = glContext;
+  }
+  resize(width, height) {
+    this.width = width;
+    this.height = height;
+    this.canvas.width = width;
+    this.canvas.height = height;
+    this.glContext.viewport(0, 0, width, height);
+  }
+  getViewport() {
+    return { width: this.width, height: this.height };
+  }
+  clear(color) {
+    if (color) {
+      this.glContext.clearColor(color.r, color.g, color.b, color.a);
+    }
+    this.glContext.clear(
+      this.glContext.COLOR_BUFFER_BIT | this.glContext.DEPTH_BUFFER_BIT
+    );
+  }
+  present() {
+  }
+  dispose() {
+    if (this.canvas.parentElement) {
+      this.canvas.parentElement.removeChild(this.canvas);
+    }
+  }
+  /**
+   * Get the underlying canvas element (browser-specific)
+   */
+  getCanvas() {
+    return this.canvas;
+  }
+}
+class NodeRenderingContext {
+  constructor(options) {
+    this.isBrowser = false;
+    this.width = options.width;
+    this.height = options.height;
+    const glContext = createGL(this.width, this.height, {
+      preserveDrawingBuffer: options.preserveDrawingBuffer ?? true,
+      ...options.contextAttributes
+    });
+    if (!glContext) {
+      throw new Error("Failed to initialize WebGL context in Node.js");
+    }
+    this.glContext = glContext;
+  }
+  resize(width, height) {
+    this.width = width;
+    this.height = height;
+    console.warn(
+      "NodeRenderingContext: Resize requested but not supported. Consider recreating context."
+    );
+  }
+  getViewport() {
+    return { width: this.width, height: this.height };
+  }
+  clear(color) {
+    if (color) {
+      this.glContext.clearColor(color.r, color.g, color.b, color.a);
+    }
+    this.glContext.clear(
+      this.glContext.COLOR_BUFFER_BIT | this.glContext.DEPTH_BUFFER_BIT
+    );
+  }
+  present() {
+    this.glContext.flush();
+  }
+  dispose() {
+    this.glContext.flush();
+  }
+  /**
+   * Read the current framebuffer contents as RGBA pixel data
+   * Used for capturing frames for display or saving
+   */
+  readPixels() {
+    const pixelData = new Uint8Array(this.width * this.height * 4);
+    this.glContext.readPixels(
+      0,
+      0,
+      this.width,
+      this.height,
+      this.glContext.RGBA,
+      this.glContext.UNSIGNED_BYTE,
+      pixelData
+    );
+    return pixelData;
+  }
+}
+class RenderingContextFactory {
+  /**
+   * Detect if running in a browser environment
+   */
+  static isBrowserEnvironment() {
+    return typeof window !== "undefined" && typeof document !== "undefined";
+  }
+  /**
+   * Create a rendering context appropriate for the current environment
+   */
+  static createContext(options) {
+    if (this.isBrowserEnvironment()) {
+      return new BrowserRenderingContext(options);
+    } else {
+      return new NodeRenderingContext(options);
+    }
+  }
+  /**
+   * Create a browser-specific rendering context
+   */
+  static createBrowserContext(options) {
+    return new BrowserRenderingContext(options);
+  }
+  /**
+   * Create a Node.js-specific rendering context
+   */
+  static createNodeContext(options) {
+    return new NodeRenderingContext(options);
+  }
+}
+class Shader {
+  /**
+   * Create a new shader program
+   * @param gl WebGL rendering context
+   * @param vertexSource Raw vertex shader source code
+   * @param fragmentSource Raw fragment shader source code
+   * @param isBrowser Whether running in browser environment (affects precision header)
+   */
+  constructor(gl, vertexSource, fragmentSource, isBrowser) {
+    this.gl = gl;
+    const processedVertexSource = this.injectPrecisionHeader(
+      vertexSource,
+      isBrowser
+    );
+    const processedFragmentSource = this.injectPrecisionHeader(
+      fragmentSource,
+      isBrowser
+    );
+    this.vertexShader = this.compileShader(
+      processedVertexSource,
+      gl.VERTEX_SHADER
+    );
+    this.fragmentShader = this.compileShader(
+      processedFragmentSource,
+      gl.FRAGMENT_SHADER
+    );
+    this.program = this.linkProgram(this.vertexShader, this.fragmentShader);
+  }
+  /**
+   * Inject precision header for ES and desktop OpenGL differences
+   * @param source Original shader source
+   * @param isBrowser Whether in browser (WebGL ES) or Node (desktop OpenGL)
+   * @returns Processed shader source with precision header
+   */
+  injectPrecisionHeader(source, isBrowser) {
+    if (source.includes("#ifdef GL_ES") || source.includes("precision")) {
+      return source;
+    }
+    if (isBrowser) {
+      const precisionHeader = `#ifdef GL_ES
+precision highp float;
+#endif
+`;
+      return precisionHeader + source;
+    } else {
+      const precisionHeader = `#ifdef GL_ES
+precision highp float;
+#endif
+`;
+      return precisionHeader + source;
+    }
+  }
+  /**
+   * Compile a single shader (vertex or fragment)
+   * @param source Shader source code
+   * @param type gl.VERTEX_SHADER or gl.FRAGMENT_SHADER
+   * @returns Compiled shader
+   */
+  compileShader(source, type) {
+    const shader = this.gl.createShader(type);
+    if (!shader) {
+      throw new Error(`Failed to create shader of type ${type}`);
+    }
+    this.gl.shaderSource(shader, source);
+    this.gl.compileShader(shader);
+    const compiled = this.gl.getShaderParameter(shader, this.gl.COMPILE_STATUS);
+    if (!compiled) {
+      const infoLog = this.gl.getShaderInfoLog(shader);
+      const shaderType = type === this.gl.VERTEX_SHADER ? "vertex" : "fragment";
+      this.gl.deleteShader(shader);
+      throw new Error(
+        `Failed to compile ${shaderType} shader:
+${infoLog}
+
+Source:
+${source}`
+      );
+    }
+    return shader;
+  }
+  /**
+   * Link vertex and fragment shaders into a program
+   * @param vertexShader Compiled vertex shader
+   * @param fragmentShader Compiled fragment shader
+   * @returns Linked shader program
+   */
+  linkProgram(vertexShader, fragmentShader) {
+    const program = this.gl.createProgram();
+    if (!program) {
+      throw new Error("Failed to create shader program");
+    }
+    this.gl.attachShader(program, vertexShader);
+    this.gl.attachShader(program, fragmentShader);
+    this.gl.linkProgram(program);
+    const linked = this.gl.getProgramParameter(program, this.gl.LINK_STATUS);
+    if (!linked) {
+      const infoLog = this.gl.getProgramInfoLog(program);
+      this.gl.deleteProgram(program);
+      this.gl.deleteShader(vertexShader);
+      this.gl.deleteShader(fragmentShader);
+      throw new Error(`Failed to link shader program:
+${infoLog}`);
+    }
+    return program;
+  }
+  /**
+   * Get the compiled shader program
+   */
+  getProgram() {
+    return this.program;
+  }
+  /**
+   * Get uniform location by name
+   * @param name Uniform variable name
+   */
+  getUniformLocation(name) {
+    return this.gl.getUniformLocation(this.program, name);
+  }
+  /**
+   * Get attribute location by name
+   * @param name Attribute variable name
+   */
+  getAttributeLocation(name) {
+    return this.gl.getAttribLocation(this.program, name);
+  }
+  /**
+   * Use this shader program
+   */
+  use() {
+    this.gl.useProgram(this.program);
+  }
+  /**
+   * Clean up shader resources
+   */
+  dispose() {
+    this.gl.deleteProgram(this.program);
+    this.gl.deleteShader(this.vertexShader);
+    this.gl.deleteShader(this.fragmentShader);
+  }
+}
+class GraphicsDevice {
+  constructor(width, height) {
+    this.context = RenderingContextFactory.createContext({
+      width,
+      height,
+      preserveDrawingBuffer: true
+    });
+  }
+  /**
+   * Get the underlying WebGL rendering context
+   */
+  getGLContext() {
+    return this.context.glContext;
+  }
+  /**
+   * Get the rendering context
+   */
+  getRenderingContext() {
+    return this.context;
+  }
+  /**
+   * Get current width
+   */
+  getWidth() {
+    return this.context.width;
+  }
+  /**
+   * Get current height
+   */
+  getHeight() {
+    return this.context.height;
+  }
+  /**
+   * Get viewport dimensions
+   */
+  getViewport() {
+    return this.context.getViewport();
+  }
+  /**
+   * Check if running in browser
+   */
+  isBrowser() {
+    return this.context.isBrowser;
+  }
+  /**
+   * Resize the graphics device
+   */
+  resize(width, height) {
+    this.context.resize(width, height);
+  }
+  /**
+   * Clear the rendering surface
+   */
+  clear(color) {
+    this.context.clear(color);
+  }
+  /**
+   * Present the rendered frame
+   */
+  present() {
+    this.context.present();
+  }
+  /**
+   * Cleanup and release resources
+   */
+  dispose() {
+    this.context.dispose();
+  }
+  /**
+   * Create a shader program
+   * @param vertexSource Vertex shader source code
+   * @param fragmentSource Fragment shader source code
+   * @returns Compiled and linked shader program
+   */
+  createShader(vertexSource, fragmentSource) {
+    return new Shader(
+      this.context.glContext,
+      vertexSource,
+      fragmentSource,
+      this.context.isBrowser
+    );
+  }
+}
+class Texture {
+  /**
+   * Create a texture from pixel data
+   * @param gl WebGL context
+   * @param width Texture width
+   * @param height Texture height
+   * @param data Pixel data (Uint8Array RGBA)
+   */
+  constructor(gl, width, height, data) {
+    this.gl = gl;
+    this.width = width;
+    this.height = height;
+    const tex = gl.createTexture();
+    if (!tex) {
+      throw new Error("Failed to create texture");
+    }
+    this.texture = tex;
+    gl.bindTexture(gl.TEXTURE_2D, this.texture);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
+    if (data) {
+      gl.texImage2D(
+        gl.TEXTURE_2D,
+        0,
+        gl.RGBA,
+        width,
+        height,
+        0,
+        gl.RGBA,
+        gl.UNSIGNED_BYTE,
+        data
+      );
+    } else {
+      gl.texImage2D(
+        gl.TEXTURE_2D,
+        0,
+        gl.RGBA,
+        width,
+        height,
+        0,
+        gl.RGBA,
+        gl.UNSIGNED_BYTE,
+        null
+      );
+    }
+    gl.bindTexture(gl.TEXTURE_2D, null);
+  }
+  /**
+   * Create a solid color texture
+   * @param gl WebGL context
+   * @param width Texture width
+   * @param height Texture height
+   * @param r Red (0-255)
+   * @param g Green (0-255)
+   * @param b Blue (0-255)
+   * @param a Alpha (0-255)
+   */
+  static createSolid(gl, width, height, r, g, b, a = 255) {
+    const pixelCount = width * height;
+    const data = new Uint8Array(pixelCount * 4);
+    for (let i = 0; i < pixelCount; i++) {
+      const offset = i * 4;
+      data[offset] = r;
+      data[offset + 1] = g;
+      data[offset + 2] = b;
+      data[offset + 3] = a;
+    }
+    return new Texture(gl, width, height, data);
+  }
+  /**
+   * Create a checkerboard texture
+   * @param gl WebGL context
+   * @param width Texture width
+   * @param height Texture height
+   * @param squareSize Size of each square
+   */
+  static createCheckerboard(gl, width, height, squareSize = 32) {
+    const data = new Uint8Array(width * height * 4);
+    for (let y = 0; y < height; y++) {
+      for (let x = 0; x < width; x++) {
+        const squareX = Math.floor(x / squareSize);
+        const squareY = Math.floor(y / squareSize);
+        const isWhite = (squareX + squareY) % 2 === 0;
+        const offset = (y * width + x) * 4;
+        const color = isWhite ? 255 : 0;
+        data[offset] = color;
+        data[offset + 1] = color;
+        data[offset + 2] = color;
+        data[offset + 3] = 255;
+      }
+    }
+    return new Texture(gl, width, height, data);
+  }
+  /**
+   * Create a gradient texture
+   * @param gl WebGL context
+   * @param width Texture width
+   * @param height Texture height
+   */
+  static createGradient(gl, width, height) {
+    const data = new Uint8Array(width * height * 4);
+    for (let y = 0; y < height; y++) {
+      for (let x = 0; x < width; x++) {
+        const offset = (y * width + x) * 4;
+        data[offset] = Math.floor(x / width * 255);
+        data[offset + 1] = Math.floor(y / height * 255);
+        data[offset + 2] = 128;
+        data[offset + 3] = 255;
+      }
+    }
+    return new Texture(gl, width, height, data);
+  }
+  /**
+   * Bind this texture to a texture unit
+   * @param unit Texture unit (0-7 typically)
+   */
+  bind(unit = 0) {
+    this.gl.activeTexture(this.gl.TEXTURE0 + unit);
+    this.gl.bindTexture(this.gl.TEXTURE_2D, this.texture);
+  }
+  /**
+   * Unbind texture
+   */
+  unbind() {
+    this.gl.bindTexture(this.gl.TEXTURE_2D, null);
+  }
+  /**
+   * Get the underlying WebGL texture
+   */
+  getHandle() {
+    return this.texture;
+  }
+  /**
+   * Get texture dimensions
+   */
+  getDimensions() {
+    return { width: this.width, height: this.height };
+  }
+  /**
+   * Clean up texture resources
+   */
+  dispose() {
+    this.gl.deleteTexture(this.texture);
+  }
+}
+class VertexBuffer {
+  constructor(gl, data, stride = 0) {
+    this.gl = gl;
+    this.stride = stride;
+    const floatsPerVertex = stride > 0 ? stride / 4 : 3;
+    this.vertexCount = data.length / floatsPerVertex;
+    const buf = gl.createBuffer();
+    if (!buf) {
+      throw new Error("Failed to create vertex buffer");
+    }
+    this.buffer = buf;
+    gl.bindBuffer(gl.ARRAY_BUFFER, this.buffer);
+    gl.bufferData(gl.ARRAY_BUFFER, data, gl.STATIC_DRAW);
+    gl.bindBuffer(gl.ARRAY_BUFFER, null);
+  }
+  /**
+   * Bind buffer for rendering
+   */
+  bind() {
+    this.gl.bindBuffer(this.gl.ARRAY_BUFFER, this.buffer);
+  }
+  /**
+   * Unbind buffer
+   */
+  unbind() {
+    this.gl.bindBuffer(this.gl.ARRAY_BUFFER, null);
+  }
+  /**
+   * Get vertex count
+   */
+  getVertexCount() {
+    return this.vertexCount;
+  }
+  /**
+   * Get stride
+   */
+  getStride() {
+    return this.stride;
+  }
+  /**
+   * Clean up resources
+   */
+  dispose() {
+    this.gl.deleteBuffer(this.buffer);
+  }
+}
+class IndexBuffer {
+  constructor(gl, data) {
+    this.gl = gl;
+    this.indexCount = data.length;
+    const buf = gl.createBuffer();
+    if (!buf) {
+      throw new Error("Failed to create index buffer");
+    }
+    this.buffer = buf;
+    gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, this.buffer);
+    gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, data, gl.STATIC_DRAW);
+    gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, null);
+  }
+  /**
+   * Bind buffer for rendering
+   */
+  bind() {
+    this.gl.bindBuffer(this.gl.ELEMENT_ARRAY_BUFFER, this.buffer);
+  }
+  /**
+   * Unbind buffer
+   */
+  unbind() {
+    this.gl.bindBuffer(this.gl.ELEMENT_ARRAY_BUFFER, null);
+  }
+  /**
+   * Get index count
+   */
+  getIndexCount() {
+    return this.indexCount;
+  }
+  /**
+   * Clean up resources
+   */
+  dispose() {
+    this.gl.deleteBuffer(this.buffer);
+  }
+}
+const buffer = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  IndexBuffer,
+  VertexBuffer
+}, Symbol.toStringTag, { value: "Module" }));
+class BatchRenderer {
+  /**
+   * Create a new batch renderer (V1)
+   * @param gl WebGL rendering context
+   * @param shader Shader program to use
+   * @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 = 5;
+    this.texture = null;
+    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 quad to the batch
+   * @param quad Quad instance to add
+   */
+  addQuad(quad) {
+    if (this.quads.length >= this.maxQuads) {
+      console.warn(`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 vertices = this.generateQuadVertices(quad);
+      for (const vertex of vertices) {
+        this.vertexData[vertexIndex++] = vertex[0];
+        this.vertexData[vertexIndex++] = vertex[1];
+        this.vertexData[vertexIndex++] = vertex[2];
+        this.vertexData[vertexIndex++] = vertex[3];
+        this.vertexData[vertexIndex++] = vertex[4];
+      }
+    }
+    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;
+  }
+  /**
+   * 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.vertexBuffer) {
+      this.gl.bindBuffer(this.gl.ARRAY_BUFFER, this.vertexBuffer);
+      const posAttr = this.shader.getAttributeLocation("aPosition");
+      const texCoordAttr = this.shader.getAttributeLocation("aTexCoord");
+      if (posAttr !== -1) {
+        this.gl.enableVertexAttribArray(posAttr);
+        this.gl.vertexAttribPointer(
+          posAttr,
+          3,
+          // 3 floats (x, y, z)
+          this.gl.FLOAT,
+          false,
+          this.floatsPerVertex * 4,
+          // stride
+          0
+          // offset
+        );
+      }
+      if (texCoordAttr !== -1) {
+        this.gl.enableVertexAttribArray(texCoordAttr);
+        this.gl.vertexAttribPointer(
+          texCoordAttr,
+          2,
+          // 2 floats (u, v)
+          this.gl.FLOAT,
+          false,
+          this.floatsPerVertex * 4,
+          // stride
+          3 * 4
+          // offset after position
+        );
+      }
+      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(quad) {
+    const { x, y, width, height, rotation } = quad;
+    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 = [
+      [0, 0],
+      // bottom-left
+      [1, 0],
+      // bottom-right
+      [1, 1],
+      // top-right
+      [1, 1],
+      // top-right
+      [0, 1],
+      // top-left
+      [0, 0]
+      // 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 + rotX, y + rotY, 0, u, v]);
+    }
+    return vertices;
+  }
+  /**
+   * Dispose resources
+   */
+  dispose() {
+    if (this.vertexBuffer) {
+      this.gl.deleteBuffer(this.vertexBuffer);
+      this.vertexBuffer = null;
+    }
+  }
+}
+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;
+    }
+  }
+}
+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 };
+  }
+}
+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(path2) {
+    try {
+      if (path2.startsWith("http://") || path2.startsWith("https://")) {
+        return path2;
+      }
+      if (path2.startsWith("//")) {
+        return window.location.protocol + path2;
+      }
+      if (path2.startsWith("/")) {
+        return this.baseUrl + path2;
+      }
+      return `${this.baseUrl}/${path2}`;
+    } catch {
+      return path2;
+    }
+  }
+  /**
+   * 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(path2, options) {
+    const url = this.resolvePath(path2);
+    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 (path2) => {
+      try {
+        const data = await this.load(path2, options);
+        return {
+          data,
+          path: path2,
+          success: true
+        };
+      } catch (error) {
+        return {
+          data: "",
+          path: path2,
+          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(path2) {
+    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(path2);
+    return validPatterns.some((pattern) => pattern.test(path2)) || 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;
+  }
+}
+const browserResourceLoader = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  BrowserResourceLoader
+}, Symbol.toStringTag, { value: "Module" }));
+class NodeResourceLoader {
+  /**
+   * Create a new Node.js resource loader
+   * @param baseDir Optional base directory for resolving relative paths (defaults to current working directory)
+   */
+  constructor(baseDir = process.cwd()) {
+    this.baseDir = baseDir;
+  }
+  /**
+   * Resolve a relative path against the base directory
+   * @param filePath Relative or absolute file path
+   * @returns Resolved absolute file path
+   */
+  resolvePath(filePath) {
+    if (path.isAbsolute(filePath)) {
+      return path.normalize(filePath);
+    }
+    return path.normalize(path.join(this.baseDir, filePath));
+  }
+  /**
+   * Load a single resource from a file
+   * @param filePath File path (relative or absolute)
+   * @param options Optional loading configuration
+   * @returns Promise resolving to the file content
+   */
+  async load(filePath, options) {
+    const resolvedPath = this.resolvePath(filePath);
+    const encoding = options?.encoding || "utf-8";
+    try {
+      const content = await fs.readFile(resolvedPath, encoding);
+      return content;
+    } catch (error) {
+      if (error instanceof Error) {
+        const errorCode = error.code;
+        if (errorCode === "ENOENT") {
+          throw new Error(
+            `File not found: ${resolvedPath} (resolved from: ${filePath})`
+          );
+        }
+        if (errorCode === "EACCES") {
+          throw new Error(
+            `Permission denied reading file: ${resolvedPath}`
+          );
+        }
+        if (errorCode === "EISDIR") {
+          throw new Error(
+            `Path is a directory, not a file: ${resolvedPath}`
+          );
+        }
+        throw new Error(
+          `Failed to load resource from ${resolvedPath}: ${error.message}`
+        );
+      }
+      throw new Error(
+        `Failed to load resource from ${resolvedPath}: Unknown error`
+      );
+    }
+  }
+  /**
+   * Load multiple resources in parallel
+   * @param filePaths Array of file paths
+   * @param options Optional loading configuration
+   * @returns Promise resolving to array of load results
+   */
+  async loadMultiple(filePaths, options) {
+    const promises = filePaths.map(async (filePath) => {
+      try {
+        const data = await this.load(filePath, options);
+        return {
+          data,
+          path: filePath,
+          success: true
+        };
+      } catch (error) {
+        return {
+          data: "",
+          path: filePath,
+          success: false,
+          error: error instanceof Error ? error.message : String(error)
+        };
+      }
+    });
+    return Promise.all(promises);
+  }
+  /**
+   * Check if the path is valid for loading in Node.js
+   * @param filePath File path to check
+   * @returns true if the path can be loaded
+   */
+  canLoad(filePath) {
+    const validPatterns = [
+      /^\//,
+      // Unix absolute paths
+      /^[a-zA-Z]:/,
+      // Windows absolute paths (e.g., C:\)
+      /^\.\.?\//,
+      // Relative paths starting with ./ or ../
+      /^[^/\\]+\//
+      // Relative paths without explicit prefix (e.g., "shaders/")
+    ];
+    return validPatterns.some((pattern) => pattern.test(filePath));
+  }
+  /**
+   * Check if a file exists without loading it
+   * @param filePath File path to check
+   * @returns Promise resolving to true if file exists
+   */
+  async exists(filePath) {
+    const resolvedPath = this.resolvePath(filePath);
+    try {
+      await fs.access(resolvedPath, fs.constants.F_OK);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Get file statistics (size, modification time, etc.)
+   * @param filePath File path to check
+   * @returns Promise resolving to file stats
+   */
+  async getStats(filePath) {
+    const resolvedPath = this.resolvePath(filePath);
+    return fs.stat(resolvedPath);
+  }
+  /**
+   * Set a new base directory for resolving relative paths
+   * @param baseDir New base directory
+   */
+  setBaseDir(baseDir) {
+    this.baseDir = baseDir;
+  }
+  /**
+   * Get the current base directory
+   * @returns Current base directory
+   */
+  getBaseDir() {
+    return this.baseDir;
+  }
+  /**
+   * List all files in a directory
+   * @param dirPath Directory path to list
+   * @param recursive Whether to recursively list subdirectories (default: false)
+   * @returns Promise resolving to array of file paths
+   */
+  async listDirectory(dirPath, recursive = false) {
+    const resolvedPath = this.resolvePath(dirPath);
+    const entries = await fs.readdir(resolvedPath, { withFileTypes: true });
+    const files = [];
+    for (const entry of entries) {
+      const fullPath = path.join(resolvedPath, entry.name);
+      if (entry.isDirectory() && recursive) {
+        const subFiles = await this.listDirectory(fullPath, true);
+        files.push(...subFiles);
+      } else if (entry.isFile()) {
+        files.push(fullPath);
+      }
+    }
+    return files;
+  }
+}
+const nodeResourceLoader = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  NodeResourceLoader
+}, Symbol.toStringTag, { value: "Module" }));
+var Environment = /* @__PURE__ */ ((Environment2) => {
+  Environment2["BROWSER"] = "browser";
+  Environment2["NODE"] = "node";
+  Environment2["UNKNOWN"] = "unknown";
+  return Environment2;
+})(Environment || {});
+class ResourceLoaderFactory {
+  /**
+   * Detect the current runtime environment
+   * @returns The detected environment type
+   */
+  static detectEnvironment() {
+    if (typeof window !== "undefined" && typeof window.document !== "undefined" && typeof fetch !== "undefined") {
+      return "browser";
+    }
+    if (typeof process !== "undefined" && process.versions != null && process.versions.node != null) {
+      return "node";
+    }
+    return "unknown";
+  }
+  /**
+   * Check if the current environment is a browser
+   * @returns true if running in a browser
+   */
+  static isBrowser() {
+    return this.detectEnvironment() === "browser";
+  }
+  /**
+   * Check if the current environment is Node.js
+   * @returns true if running in Node.js
+   */
+  static isNode() {
+    return this.detectEnvironment() === "node";
+  }
+  /**
+   * Create a resource loader for the current environment
+   * @param options Optional factory configuration
+   * @returns A resource loader instance appropriate for the current platform
+   * @throws Error if the environment is not supported
+   */
+  static async create(options) {
+    const environment = options?.forceEnvironment || this.detectEnvironment();
+    switch (environment) {
+      case "browser":
+        return await this.createBrowserLoader(options);
+      case "node":
+        return await this.createNodeLoader(options);
+      case "unknown":
+        throw new Error(
+          "Unsupported environment: Unable to determine runtime environment. Please specify forceEnvironment in options."
+        );
+      default:
+        throw new Error(`Unsupported environment: ${environment}`);
+    }
+  }
+  /**
+   * Create a browser resource loader
+   * @param options Optional factory configuration
+   * @returns A browser resource loader instance
+   */
+  static async createBrowserLoader(options) {
+    const { BrowserResourceLoader: Loader } = await Promise.resolve().then(() => browserResourceLoader);
+    return new Loader(options?.baseUrl, options?.timeout);
+  }
+  /**
+   * Create a Node.js resource loader
+   * @param options Optional factory configuration
+   * @returns A Node.js resource loader instance
+   */
+  static async createNodeLoader(options) {
+    const { NodeResourceLoader: Loader } = await Promise.resolve().then(() => nodeResourceLoader);
+    return new Loader(options?.baseDir);
+  }
+  /**
+   * Create a resource loader with automatic fallback
+   * If the preferred loader is not available, falls back to the available loader
+   * @param preferredEnvironment Preferred environment
+   * @param options Optional factory configuration
+   * @returns A resource loader instance
+   */
+  static async createWithFallback(preferredEnvironment, options) {
+    try {
+      options = { ...options, forceEnvironment: preferredEnvironment };
+      return await this.create(options);
+    } catch {
+      return await this.create({ ...options, forceEnvironment: void 0 });
+    }
+  }
+}
+async function createResourceLoader(options) {
+  return await ResourceLoaderFactory.create(options);
+}
+const resourceLoaderFactory = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  Environment,
+  ResourceLoaderFactory,
+  createResourceLoader
+}, Symbol.toStringTag, { value: "Module" }));
+class ResourceCache {
+  constructor(enabled = true) {
+    this.cache = /* @__PURE__ */ new Map();
+    this.enabled = enabled;
+  }
+  get(key) {
+    if (!this.enabled) return void 0;
+    return this.cache.get(key);
+  }
+  set(key, value) {
+    if (this.enabled) {
+      this.cache.set(key, value);
+    }
+  }
+  has(key) {
+    if (!this.enabled) return false;
+    return this.cache.has(key);
+  }
+  clear() {
+    this.cache.clear();
+  }
+  size() {
+    return this.cache.size;
+  }
+  enable() {
+    this.enabled = true;
+  }
+  disable() {
+    this.enabled = false;
+  }
+}
+class ResourcePipeline {
+  /**
+   * Create a new resource loading pipeline
+   * @param loader Resource loader instance
+   * @param options Pipeline configuration options
+   */
+  constructor(loader, options) {
+    this.loader = loader;
+    this.concurrency = options?.concurrency ?? 10;
+    this.cache = new ResourceCache(options?.cache ?? true);
+  }
+  /**
+   * Load a single resource with caching support
+   * @param path Resource path or URL
+   * @param options Optional loading options
+   * @returns Promise resolving to the resource content
+   */
+  async load(path2, options) {
+    const cached = this.cache.get(path2);
+    if (cached !== void 0) {
+      return cached;
+    }
+    const content = await this.loader.load(path2, options);
+    this.cache.set(path2, content);
+    return content;
+  }
+  /**
+   * Load multiple resources with concurrency control
+   * @param paths Array of resource paths
+   * @param options Optional loading options
+   * @returns Promise resolving to batch load result
+   */
+  async loadBatch(paths, options) {
+    const succeeded = /* @__PURE__ */ new Map();
+    const failed = /* @__PURE__ */ new Map();
+    for (let i = 0; i < paths.length; i += this.concurrency) {
+      const batch = paths.slice(i, i + this.concurrency);
+      const results = await this.loader.loadMultiple(batch, options);
+      for (const result of results) {
+        if (result.success) {
+          succeeded.set(result.path, result.data);
+          this.cache.set(result.path, result.data);
+        } else {
+          failed.set(result.path, result.error || "Unknown error");
+        }
+      }
+    }
+    return {
+      succeeded,
+      failed,
+      total: paths.length,
+      successCount: succeeded.size,
+      failureCount: failed.size
+    };
+  }
+  /**
+   * Load a shader from separate vertex and fragment files
+   * @param vertexPath Path to vertex shader file
+   * @param fragmentPath Path to fragment shader file
+   * @param options Optional loading options
+   * @returns Promise resolving to shader source code
+   */
+  async loadShader(vertexPath, fragmentPath, options) {
+    const [vertex, fragment] = await Promise.all([
+      this.load(vertexPath, options),
+      this.load(fragmentPath, options)
+    ]);
+    return { vertex, fragment };
+  }
+  /**
+   * Load multiple shaders
+   * @param shaders Array of shader definitions
+   * @param options Optional loading options
+   * @returns Promise resolving to array of named shader sources
+   */
+  async loadShaders(shaders, options) {
+    const results = await Promise.all(
+      shaders.map(async (shader) => {
+        const source = await this.loadShader(
+          shader.vertex,
+          shader.fragment,
+          options
+        );
+        return {
+          name: shader.name,
+          ...source
+        };
+      })
+    );
+    return results;
+  }
+  /**
+   * Load resources from a manifest file
+   * @param manifestPath Path to JSON manifest file
+   * @param options Optional loading options
+   * @returns Promise resolving to batch load result
+   */
+  async loadFromManifest(manifestPath, options) {
+    const manifestContent = await this.load(manifestPath, options);
+    const manifest = JSON.parse(manifestContent);
+    return this.loadBatch(manifest.resources, options);
+  }
+  /**
+   * Preload resources for faster access later
+   * @param paths Array of resource paths to preload
+   * @param options Optional loading options
+   * @returns Promise resolving when all resources are loaded
+   */
+  async preload(paths, options) {
+    await this.loadBatch(paths, options);
+  }
+  /**
+   * Check if a resource is cached
+   * @param path Resource path
+   * @returns true if the resource is in the cache
+   */
+  isCached(path2) {
+    return this.cache.has(path2);
+  }
+  /**
+   * Get a resource from cache without loading
+   * @param path Resource path
+   * @returns Cached content or undefined if not cached
+   */
+  getCached(path2) {
+    return this.cache.get(path2);
+  }
+  /**
+   * Clear the resource cache
+   */
+  clearCache() {
+    this.cache.clear();
+  }
+  /**
+   * Get cache statistics
+   * @returns Number of cached resources
+   */
+  getCacheSize() {
+    return this.cache.size();
+  }
+  /**
+   * Enable caching
+   */
+  enableCache() {
+    this.cache.enable();
+  }
+  /**
+   * Disable caching
+   */
+  disableCache() {
+    this.cache.disable();
+  }
+  /**
+   * Set the maximum concurrency for batch operations
+   * @param concurrency Maximum concurrent loads
+   */
+  setConcurrency(concurrency) {
+    this.concurrency = Math.max(1, concurrency);
+  }
+  /**
+   * Get the underlying resource loader
+   * @returns The resource loader instance
+   */
+  getLoader() {
+    return this.loader;
+  }
+}
+async function createResourcePipeline(options) {
+  const { ResourceLoaderFactory: ResourceLoaderFactory2 } = await Promise.resolve().then(() => resourceLoaderFactory);
+  const loader = await ResourceLoaderFactory2.create({
+    baseUrl: options?.baseUrl,
+    baseDir: options?.baseDir,
+    timeout: options?.timeout
+  });
+  return new ResourcePipeline(loader, options);
+}
+const SCENE_CONFIG = {
+  width: 800,
+  height: 600
+};
+const GEOMETRY = {
+  quad: {
+    vertices: new Float32Array([
+      // Position               TexCoord
+      -0.5,
+      -0.5,
+      0,
+      0,
+      0,
+      // Bottom-left
+      0.5,
+      -0.5,
+      0,
+      1,
+      0,
+      // Bottom-right
+      0.5,
+      0.5,
+      0,
+      1,
+      1,
+      // Top-right
+      0.5,
+      0.5,
+      0,
+      1,
+      1,
+      // Top-right
+      -0.5,
+      0.5,
+      0,
+      0,
+      1,
+      // Top-left
+      -0.5,
+      -0.5,
+      0,
+      0,
+      0
+      // Bottom-left
+    ]),
+    stride: 5 * 4
+    // 5 floats per vertex × 4 bytes
+  }
+};
+const TEXTURE_CONFIG = {
+  size: 256
+};
+const DEMO_CONFIG = {
+  shaders: [
+    {
+      name: "basic",
+      vertex: "resources/shaders/basic.vert",
+      fragment: "resources/shaders/basic.frag"
+    },
+    {
+      name: "glow",
+      vertex: "resources/shaders/glow.vert",
+      fragment: "resources/shaders/glow.frag"
+    }
+  ],
+  // Additional resources to demonstrate batch loading
+  resources: [
+    "resources/shaders/basic.vert",
+    "resources/shaders/basic.frag",
+    "resources/shaders/glow.vert",
+    "resources/shaders/glow.frag"
+  ]
+};
+async function runBrowserResourceLoaderDemo() {
+  console.log("🩸 Bloody Engine - Resource Loader Demo");
+  console.log("==========================================\n");
+  const env = ResourceLoaderFactory.detectEnvironment();
+  console.log(`✓ Environment detected: ${env}`);
+  if (env !== Environment.BROWSER) {
+    console.warn("⚠ This demo is designed for browser environment");
+    return;
+  }
+  console.log("\n1. Creating Resource Pipeline...");
+  const pipeline = await createResourcePipeline({
+    concurrency: 5,
+    cache: true,
+    timeout: 1e4,
+    baseUrl: window.location.origin
+  });
+  console.log("✓ Resource pipeline created");
+  console.log(`  - Concurrency: 5`);
+  console.log(`  - Caching: enabled`);
+  console.log("\n2. Batch Loading Resources...");
+  console.log(`Loading ${DEMO_CONFIG.resources.length} resources...`);
+  const batchResult = await pipeline.loadBatch(DEMO_CONFIG.resources);
+  console.log(`✓ Batch loading complete`);
+  console.log(`  - Succeeded: ${batchResult.successCount}`);
+  console.log(`  - Failed: ${batchResult.failureCount}`);
+  if (batchResult.failureCount > 0) {
+    console.log("\n❌ Failed resources:");
+    for (const [path2, error] of batchResult.failed) {
+      console.log(`  - ${path2}: ${error}`);
+    }
+    console.log("\n⚠️ Falling back to inline shaders...");
+  }
+  console.log("\n3. Loading Shaders...");
+  const shaders = await pipeline.loadShaders(DEMO_CONFIG.shaders);
+  console.log(`✓ Loaded ${shaders.length} shaders:`);
+  for (const shader2 of shaders) {
+    console.log(`  - ${shader2.name}:`);
+    console.log(`    Vertex: ${shader2.vertex.length} chars`);
+    console.log(`    Fragment: ${shader2.fragment.length} chars`);
+  }
+  console.log("\n4. Testing Cache...");
+  const cachedSize = pipeline.getCacheSize();
+  console.log(`✓ Cache contains ${cachedSize} resources`);
+  for (const shaderConfig of DEMO_CONFIG.shaders) {
+    const vertexCached = pipeline.isCached(shaderConfig.vertex);
+    const fragmentCached = pipeline.isCached(shaderConfig.fragment);
+    console.log(`  - ${shaderConfig.name}:`);
+    console.log(`    Vertex cached: ${vertexCached}`);
+    console.log(`    Fragment cached: ${fragmentCached}`);
+  }
+  console.log("\n5. Initializing Graphics Device...");
+  const gdevice = new GraphicsDevice(SCENE_CONFIG.width, SCENE_CONFIG.height);
+  const gl = gdevice.getGLContext();
+  console.log("✓ Graphics device initialized");
+  console.log(`  - Resolution: ${SCENE_CONFIG.width}x${SCENE_CONFIG.height}`);
+  console.log("\n6. Creating Shader from Loaded Source...");
+  let glowShader = shaders.find((s) => s.name === "glow");
+  if (!glowShader || !glowShader.vertex || !glowShader.fragment) {
+    console.warn("⚠️ Glow shader not loaded or empty, using inline fallback");
+    glowShader = {
+      name: "glow",
+      vertex: `attribute vec3 aPosition;
+attribute vec2 aTexCoord;
+
+varying vec2 vTexCoord;
+varying float vDistance;
+
+uniform mat4 uMatrix;
+
+void main() {
+  gl_Position = uMatrix * vec4(aPosition, 1.0);
+  vTexCoord = aTexCoord;
+  vDistance = length(aTexCoord - vec2(0.5, 0.5));
+}`,
+      fragment: `precision mediump float;
+
+varying vec2 vTexCoord;
+varying float vDistance;
+uniform sampler2D uTexture;
+uniform vec3 uColor;
+uniform float uGlowIntensity;
+
+void main() {
+  vec4 texColor = texture2D(uTexture, vTexCoord);
+  // Better glow falloff - keeps minimum brightness
+  float glow = 1.0 - (vDistance * 0.7);
+  glow = max(0.5, glow);
+  vec3 glowColor = texColor.rgb * uColor * glow * uGlowIntensity;
+  gl_FragColor = vec4(glowColor, texColor.a);
+}`
+    };
+  }
+  const shader = gdevice.createShader(glowShader.vertex, glowShader.fragment);
+  console.log("✓ Shader compiled from loaded source code");
+  console.log(`  - Vertex shader: compiled`);
+  console.log(`  - Fragment shader: compiled`);
+  console.log(`  - Program: linked`);
+  console.log("\n7. Creating Texture...");
+  const texture = Texture.createGradient(
+    gl,
+    TEXTURE_CONFIG.size,
+    TEXTURE_CONFIG.size
+  );
+  console.log("✓ Gradient texture created");
+  console.log(`  - Size: ${TEXTURE_CONFIG.size}x${TEXTURE_CONFIG.size}`);
+  console.log("\n8. Creating Geometry Buffers...");
+  const { VertexBuffer: VertexBuffer2 } = await Promise.resolve().then(() => buffer);
+  const quadBuffer = new VertexBuffer2(
+    gl,
+    GEOMETRY.quad.vertices,
+    GEOMETRY.quad.stride
+  );
+  console.log("✓ Quad buffer created");
+  console.log(`  - Vertices: ${quadBuffer.getVertexCount()}`);
+  console.log("\n9. Setting up Rendering...");
+  shader.use();
+  const posAttr = shader.getAttributeLocation("aPosition");
+  const texCoordAttr = shader.getAttributeLocation("aTexCoord");
+  const textureUniform = shader.getUniformLocation("uTexture");
+  const matrixUniform = shader.getUniformLocation("uMatrix");
+  const colorUniform = shader.getUniformLocation("uColor");
+  const glowIntensityUniform = shader.getUniformLocation("uGlowIntensity");
+  quadBuffer.bind();
+  gl.enableVertexAttribArray(posAttr);
+  gl.vertexAttribPointer(posAttr, 3, gl.FLOAT, false, GEOMETRY.quad.stride, 0);
+  gl.enableVertexAttribArray(texCoordAttr);
+  gl.vertexAttribPointer(
+    texCoordAttr,
+    2,
+    gl.FLOAT,
+    false,
+    GEOMETRY.quad.stride,
+    3 * 4
+  );
+  console.log("✓ Vertex attributes configured");
+  texture.bind(0);
+  gl.uniform1i(textureUniform, 0);
+  console.log("✓ Texture bound to unit 0");
+  const renderingContext = gdevice.getRenderingContext();
+  const canvas = renderingContext.canvas;
+  if (canvas) {
+    canvas.style.display = "block";
+    canvas.style.margin = "0 auto";
+    canvas.style.border = "2px solid #333";
+    canvas.style.backgroundColor = "#1a1a1a";
+  }
+  document.body.style.margin = "0";
+  document.body.style.padding = "20px";
+  document.body.style.backgroundColor = "#0a0a0a";
+  document.body.style.fontFamily = "monospace";
+  document.body.style.color = "#aaa";
+  const title = document.createElement("h1");
+  title.textContent = "🩸 Resource Loader Demo";
+  title.style.textAlign = "center";
+  title.style.color = "#fff";
+  if (canvas && canvas.parentNode) {
+    canvas.parentNode.insertBefore(title, canvas);
+  } else {
+    document.body.insertBefore(title, document.body.firstChild);
+  }
+  const info = document.createElement("div");
+  info.style.textAlign = "center";
+  info.style.marginTop = "10px";
+  info.style.fontSize = "12px";
+  info.innerHTML = `
+    <div>Environment: <strong>${env}</strong></div>
+    <div>Shaders loaded: <strong>${shaders.length}</strong></div>
+    <div>Cached resources: <strong>${cachedSize}</strong></div>
+  `;
+  document.body.appendChild(info);
+  let frameCount = 0;
+  const startTime = Date.now();
+  function render() {
+    const now = Date.now();
+    const elapsedSeconds = (now - startTime) / 1e3;
+    gdevice.clear({ r: 0.1, g: 0.1, b: 0.1, a: 1 });
+    const quads = [
+      { x: -0.3, y: 0.3, color: [1, 0.2, 0.2], glow: 1.5 },
+      { x: 0.3, y: 0.3, color: [0.2, 1, 0.2], glow: 1.8 },
+      { x: -0.3, y: -0.3, color: [0.2, 0.5, 1], glow: 2 },
+      { x: 0.3, y: -0.3, color: [1, 1, 0.2], glow: 1.6 }
+    ];
+    for (const quad of quads) {
+      const matrix = createIdentityMatrix();
+      translateMatrix(matrix, quad.x, quad.y, 0);
+      scaleMatrix(matrix, 0.4, 0.4, 1);
+      if (matrixUniform) {
+        gl.uniformMatrix4fv(matrixUniform, false, matrix);
+      }
+      if (colorUniform) {
+        gl.uniform3f(
+          colorUniform,
+          quad.color[0],
+          quad.color[1],
+          quad.color[2]
+        );
+      }
+      if (glowIntensityUniform) {
+        const pulse = quad.glow + Math.sin(elapsedSeconds * 2) * 0.3;
+        gl.uniform1f(glowIntensityUniform, pulse);
+      }
+      gl.drawArrays(gl.TRIANGLES, 0, quadBuffer.getVertexCount());
+    }
+    gdevice.present();
+    frameCount++;
+    const totalTime = (now - startTime) / 1e3;
+    const fps = frameCount / totalTime;
+    info.innerHTML = `
+      <div>FPS: <strong>${fps.toFixed(1)}</strong> | Frame: <strong>${frameCount}</strong> | Elapsed: <strong>${totalTime.toFixed(2)}s</strong></div>
+      <div>Environment: <strong>${env}</strong> | Shaders loaded: <strong>${shaders.length}</strong> | Cached: <strong>${cachedSize}</strong></div>
+    `;
+    requestAnimationFrame(render);
+  }
+  console.log("\n✓ Demo started! Rendering animation...");
+  render();
+}
+function createIdentityMatrix() {
+  return new Float32Array([
+    1,
+    0,
+    0,
+    0,
+    0,
+    1,
+    0,
+    0,
+    0,
+    0,
+    1,
+    0,
+    0,
+    0,
+    0,
+    1
+  ]);
+}
+function translateMatrix(mat, x, y, z) {
+  mat[12] += x;
+  mat[13] += y;
+  mat[14] += z;
+}
+function scaleMatrix(mat, x, y, z) {
+  mat[0] *= x;
+  mat[5] *= y;
+  mat[10] *= z;
+}
+if (typeof window !== "undefined") {
+  runBrowserResourceLoaderDemo().catch((error) => {
+    console.error("❌ Demo failed:", error);
+  });
+}
+export {
+  BatchRenderer,
+  BrowserRenderingContext,
+  BrowserResourceLoader,
+  Camera,
+  Environment,
+  GraphicsDevice,
+  IndexBuffer,
+  Matrix4,
+  NodeRenderingContext,
+  NodeResourceLoader,
+  RenderingContextFactory,
+  ResourceLoaderFactory,
+  ResourcePipeline,
+  Shader,
+  SpriteBatchRenderer,
+  Texture,
+  VertexBuffer,
+  createResourceLoader,
+  createResourcePipeline,
+  runBrowserResourceLoaderDemo
+};