bloody-engine 1.0.0

package/dist/web/index.js

@@ -0,0 +1,1940 @@
+import X from "gl";
+import * as C from "fs/promises";
+import * as T from "path";
+class Y {
+  constructor(e) {
+    this.isBrowser = !0, e.canvas ? this.canvas = e.canvas : (this.canvas = document.createElement("canvas"), document.body.appendChild(this.canvas)), this.width = e.width, this.height = e.height, this.canvas.width = this.width, this.canvas.height = this.height;
+    const t = {
+      alpha: !1,
+      ...e.contextAttributes
+    }, r = this.canvas.getContext("webgl", t);
+    if (!r)
+      throw new Error("Failed to initialize WebGL context in browser");
+    this.glContext = r;
+  }
+  resize(e, t) {
+    this.width = e, this.height = t, this.canvas.width = e, this.canvas.height = t, this.glContext.viewport(0, 0, e, t);
+  }
+  getViewport() {
+    return { width: this.width, height: this.height };
+  }
+  clear(e) {
+    e && this.glContext.clearColor(e.r, e.g, e.b, e.a), this.glContext.clear(
+      this.glContext.COLOR_BUFFER_BIT | this.glContext.DEPTH_BUFFER_BIT
+    );
+  }
+  present() {
+  }
+  dispose() {
+    this.canvas.parentElement && this.canvas.parentElement.removeChild(this.canvas);
+  }
+  /**
+   * Get the underlying canvas element (browser-specific)
+   */
+  getCanvas() {
+    return this.canvas;
+  }
+}
+class G {
+  constructor(e) {
+    this.isBrowser = !1, this.width = e.width, this.height = e.height;
+    const t = X(this.width, this.height, {
+      preserveDrawingBuffer: e.preserveDrawingBuffer ?? !0,
+      ...e.contextAttributes
+    });
+    if (!t)
+      throw new Error("Failed to initialize WebGL context in Node.js");
+    this.glContext = t;
+  }
+  resize(e, t) {
+    this.width = e, this.height = t, console.warn(
+      "NodeRenderingContext: Resize requested but not supported. Consider recreating context."
+    );
+  }
+  getViewport() {
+    return { width: this.width, height: this.height };
+  }
+  clear(e) {
+    e && this.glContext.clearColor(e.r, e.g, e.b, e.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 e = new Uint8Array(this.width * this.height * 4);
+    return this.glContext.readPixels(
+      0,
+      0,
+      this.width,
+      this.height,
+      this.glContext.RGBA,
+      this.glContext.UNSIGNED_BYTE,
+      e
+    ), e;
+  }
+}
+class k {
+  /**
+   * Detect if running in a browser environment
+   */
+  static isBrowserEnvironment() {
+    return typeof window < "u" && typeof document < "u";
+  }
+  /**
+   * Create a rendering context appropriate for the current environment
+   */
+  static createContext(e) {
+    return this.isBrowserEnvironment() ? new Y(e) : new G(e);
+  }
+  /**
+   * Create a browser-specific rendering context
+   */
+  static createBrowserContext(e) {
+    return new Y(e);
+  }
+  /**
+   * Create a Node.js-specific rendering context
+   */
+  static createNodeContext(e) {
+    return new G(e);
+  }
+}
+class H {
+  /**
+   * 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(e, t, r, s) {
+    this.gl = e;
+    const i = this.injectPrecisionHeader(
+      t,
+      s
+    ), o = this.injectPrecisionHeader(
+      r,
+      s
+    );
+    this.vertexShader = this.compileShader(
+      i,
+      e.VERTEX_SHADER
+    ), this.fragmentShader = this.compileShader(
+      o,
+      e.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(e, t) {
+    return e.includes("#ifdef GL_ES") || e.includes("precision") ? e : `#ifdef GL_ES
+precision highp float;
+#endif
+` + e;
+  }
+  /**
+   * 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(e, t) {
+    const r = this.gl.createShader(t);
+    if (!r)
+      throw new Error(`Failed to create shader of type ${t}`);
+    if (this.gl.shaderSource(r, e), this.gl.compileShader(r), !this.gl.getShaderParameter(r, this.gl.COMPILE_STATUS)) {
+      const i = this.gl.getShaderInfoLog(r), o = t === this.gl.VERTEX_SHADER ? "vertex" : "fragment";
+      throw this.gl.deleteShader(r), new Error(
+        `Failed to compile ${o} shader:
+${i}
+
+Source:
+${e}`
+      );
+    }
+    return r;
+  }
+  /**
+   * Link vertex and fragment shaders into a program
+   * @param vertexShader Compiled vertex shader
+   * @param fragmentShader Compiled fragment shader
+   * @returns Linked shader program
+   */
+  linkProgram(e, t) {
+    const r = this.gl.createProgram();
+    if (!r)
+      throw new Error("Failed to create shader program");
+    if (this.gl.attachShader(r, e), this.gl.attachShader(r, t), this.gl.linkProgram(r), !this.gl.getProgramParameter(r, this.gl.LINK_STATUS)) {
+      const i = this.gl.getProgramInfoLog(r);
+      throw this.gl.deleteProgram(r), this.gl.deleteShader(e), this.gl.deleteShader(t), new Error(`Failed to link shader program:
+${i}`);
+    }
+    return r;
+  }
+  /**
+   * Get the compiled shader program
+   */
+  getProgram() {
+    return this.program;
+  }
+  /**
+   * Get uniform location by name
+   * @param name Uniform variable name
+   */
+  getUniformLocation(e) {
+    return this.gl.getUniformLocation(this.program, e);
+  }
+  /**
+   * Get attribute location by name
+   * @param name Attribute variable name
+   */
+  getAttributeLocation(e) {
+    return this.gl.getAttribLocation(this.program, e);
+  }
+  /**
+   * 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 W {
+  constructor(e, t) {
+    this.context = k.createContext({
+      width: e,
+      height: t,
+      preserveDrawingBuffer: !0
+    });
+  }
+  /**
+   * 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(e, t) {
+    this.context.resize(e, t);
+  }
+  /**
+   * Clear the rendering surface
+   */
+  clear(e) {
+    this.context.clear(e);
+  }
+  /**
+   * 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(e, t) {
+    return new H(
+      this.context.glContext,
+      e,
+      t,
+      this.context.isBrowser
+    );
+  }
+}
+class B {
+  /**
+   * 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(e, t, r, s) {
+    this.gl = e, this.width = t, this.height = r;
+    const i = e.createTexture();
+    if (!i)
+      throw new Error("Failed to create texture");
+    this.texture = i, e.bindTexture(e.TEXTURE_2D, this.texture), e.texParameteri(e.TEXTURE_2D, e.TEXTURE_WRAP_S, e.CLAMP_TO_EDGE), e.texParameteri(e.TEXTURE_2D, e.TEXTURE_WRAP_T, e.CLAMP_TO_EDGE), e.texParameteri(e.TEXTURE_2D, e.TEXTURE_MIN_FILTER, e.LINEAR), e.texParameteri(e.TEXTURE_2D, e.TEXTURE_MAG_FILTER, e.LINEAR), s ? e.texImage2D(
+      e.TEXTURE_2D,
+      0,
+      e.RGBA,
+      t,
+      r,
+      0,
+      e.RGBA,
+      e.UNSIGNED_BYTE,
+      s
+    ) : e.texImage2D(
+      e.TEXTURE_2D,
+      0,
+      e.RGBA,
+      t,
+      r,
+      0,
+      e.RGBA,
+      e.UNSIGNED_BYTE,
+      null
+    ), e.bindTexture(e.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(e, t, r, s, i, o, n = 255) {
+    const a = t * r, h = new Uint8Array(a * 4);
+    for (let x = 0; x < a; x++) {
+      const l = x * 4;
+      h[l] = s, h[l + 1] = i, h[l + 2] = o, h[l + 3] = n;
+    }
+    return new B(e, t, r, h);
+  }
+  /**
+   * Create a checkerboard texture
+   * @param gl WebGL context
+   * @param width Texture width
+   * @param height Texture height
+   * @param squareSize Size of each square
+   */
+  static createCheckerboard(e, t, r, s = 32) {
+    const i = new Uint8Array(t * r * 4);
+    for (let o = 0; o < r; o++)
+      for (let n = 0; n < t; n++) {
+        const a = Math.floor(n / s), h = Math.floor(o / s), x = (a + h) % 2 === 0, l = (o * t + n) * 4, d = x ? 255 : 0;
+        i[l] = d, i[l + 1] = d, i[l + 2] = d, i[l + 3] = 255;
+      }
+    return new B(e, t, r, i);
+  }
+  /**
+   * Create a gradient texture
+   * @param gl WebGL context
+   * @param width Texture width
+   * @param height Texture height
+   */
+  static createGradient(e, t, r) {
+    const s = new Uint8Array(t * r * 4);
+    for (let i = 0; i < r; i++)
+      for (let o = 0; o < t; o++) {
+        const n = (i * t + o) * 4;
+        s[n] = Math.floor(o / t * 255), s[n + 1] = Math.floor(i / r * 255), s[n + 2] = 128, s[n + 3] = 255;
+      }
+    return new B(e, t, r, s);
+  }
+  /**
+   * Bind this texture to a texture unit
+   * @param unit Texture unit (0-7 typically)
+   */
+  bind(e = 0) {
+    this.gl.activeTexture(this.gl.TEXTURE0 + e), 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 Q {
+  constructor(e, t, r = 0) {
+    this.gl = e, this.stride = r;
+    const s = r > 0 ? r / 4 : 3;
+    this.vertexCount = t.length / s;
+    const i = e.createBuffer();
+    if (!i)
+      throw new Error("Failed to create vertex buffer");
+    this.buffer = i, e.bindBuffer(e.ARRAY_BUFFER, this.buffer), e.bufferData(e.ARRAY_BUFFER, t, e.STATIC_DRAW), e.bindBuffer(e.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 j {
+  constructor(e, t) {
+    this.gl = e, this.indexCount = t.length;
+    const r = e.createBuffer();
+    if (!r)
+      throw new Error("Failed to create index buffer");
+    this.buffer = r, e.bindBuffer(e.ELEMENT_ARRAY_BUFFER, this.buffer), e.bufferData(e.ELEMENT_ARRAY_BUFFER, t, e.STATIC_DRAW), e.bindBuffer(e.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 K = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  IndexBuffer: j,
+  VertexBuffer: Q
+}, Symbol.toStringTag, { value: "Module" }));
+class de {
+  /**
+   * 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(e, t, r = 1e3) {
+    this.vertexBuffer = null, this.quads = [], this.isDirty = !1, this.verticesPerQuad = 6, this.floatsPerVertex = 5, this.texture = null, this.gl = e, this.shader = t, this.maxQuads = r;
+    const s = r * this.verticesPerQuad * this.floatsPerVertex;
+    this.vertexData = new Float32Array(s);
+    const i = e.createBuffer();
+    if (!i)
+      throw new Error("Failed to create vertex buffer");
+    this.vertexBuffer = i, e.bindBuffer(e.ARRAY_BUFFER, this.vertexBuffer), e.bufferData(e.ARRAY_BUFFER, this.vertexData.byteLength, e.DYNAMIC_DRAW), e.bindBuffer(e.ARRAY_BUFFER, null);
+  }
+  /**
+   * Set the texture for batch rendering
+   * @param texture The texture to use when rendering
+   */
+  setTexture(e) {
+    this.texture = e;
+  }
+  /**
+   * Add a quad to the batch
+   * @param quad Quad instance to add
+   */
+  addQuad(e) {
+    if (this.quads.length >= this.maxQuads) {
+      console.warn(`Batch renderer at max capacity (${this.maxQuads})`);
+      return;
+    }
+    this.quads.push(e), this.isDirty = !0;
+  }
+  /**
+   * Clear all quads from the batch
+   */
+  clear() {
+    this.quads = [], this.isDirty = !0;
+  }
+  /**
+   * 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 e = 0;
+    for (const t of this.quads) {
+      const r = this.generateQuadVertices(t);
+      for (const s of r)
+        this.vertexData[e++] = s[0], this.vertexData[e++] = s[1], this.vertexData[e++] = s[2], this.vertexData[e++] = s[3], this.vertexData[e++] = s[4];
+    }
+    this.vertexBuffer && (this.gl.bindBuffer(this.gl.ARRAY_BUFFER, this.vertexBuffer), this.gl.bufferSubData(
+      this.gl.ARRAY_BUFFER,
+      0,
+      this.vertexData.subarray(0, e)
+    ), this.gl.bindBuffer(this.gl.ARRAY_BUFFER, null)), this.isDirty = !1;
+  }
+  /**
+   * Render the batch
+   * @param camera Optional camera for view transform (defaults to identity matrix)
+   */
+  render(e) {
+    if (this.quads.length !== 0 && (this.update(), this.shader.use(), this.vertexBuffer)) {
+      this.gl.bindBuffer(this.gl.ARRAY_BUFFER, this.vertexBuffer);
+      const t = this.shader.getAttributeLocation("aPosition"), r = this.shader.getAttributeLocation("aTexCoord");
+      if (t !== -1 && (this.gl.enableVertexAttribArray(t), this.gl.vertexAttribPointer(
+        t,
+        3,
+        // 3 floats (x, y, z)
+        this.gl.FLOAT,
+        !1,
+        this.floatsPerVertex * 4,
+        // stride
+        0
+        // offset
+      )), r !== -1 && (this.gl.enableVertexAttribArray(r), this.gl.vertexAttribPointer(
+        r,
+        2,
+        // 2 floats (u, v)
+        this.gl.FLOAT,
+        !1,
+        this.floatsPerVertex * 4,
+        // stride
+        12
+        // offset after position
+      )), this.texture) {
+        this.texture.bind(0);
+        const o = this.shader.getUniformLocation("uTexture");
+        o !== null && this.gl.uniform1i(o, 0);
+      }
+      const s = this.shader.getUniformLocation("uMatrix");
+      if (s !== null) {
+        const o = e ? e.getViewMatrix() : new Float32Array([
+          1,
+          0,
+          0,
+          0,
+          0,
+          1,
+          0,
+          0,
+          0,
+          0,
+          1,
+          0,
+          0,
+          0,
+          0,
+          1
+        ]);
+        this.gl.uniformMatrix4fv(s, !1, o);
+      }
+      const i = this.quads.length * this.verticesPerQuad;
+      this.gl.drawArrays(this.gl.TRIANGLES, 0, i), this.gl.bindBuffer(this.gl.ARRAY_BUFFER, null);
+    }
+  }
+  /**
+   * Generate vertices for a quad with rotation applied
+   * Returns 6 vertices (2 triangles)
+   * @private
+   */
+  generateQuadVertices(e) {
+    const { x: t, y: r, width: s, height: i, rotation: o } = e, n = s / 2, a = i / 2, h = Math.cos(o), x = Math.sin(o), l = (m, v) => [m * h - v * x, m * x + v * h], d = [
+      [-n, -a],
+      // bottom-left
+      [n, -a],
+      // bottom-right
+      [n, a],
+      // top-right
+      [n, a],
+      // top-right (duplicate)
+      [-n, a],
+      // top-left
+      [-n, -a]
+      // bottom-left (duplicate)
+    ], f = [
+      [0, 0],
+      // bottom-left
+      [1, 0],
+      // bottom-right
+      [1, 1],
+      // top-right
+      [1, 1],
+      // top-right
+      [0, 1],
+      // top-left
+      [0, 0]
+      // bottom-left
+    ], y = [];
+    for (let m = 0; m < d.length; m++) {
+      const [v, E] = d[m], [A, u] = l(v, E), [w, b] = f[m];
+      y.push([t + A, r + u, 0, w, b]);
+    }
+    return y;
+  }
+  /**
+   * Dispose resources
+   */
+  dispose() {
+    this.vertexBuffer && (this.gl.deleteBuffer(this.vertexBuffer), this.vertexBuffer = null);
+  }
+}
+class fe {
+  /**
+   * 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(e, t, r = 1e3) {
+    this.vertexBuffer = null, this.quads = [], this.isDirty = !1, this.verticesPerQuad = 6, this.floatsPerVertex = 10, this.texture = null, this.depthTestEnabled = !0, this.gl = e, this.shader = t, this.maxQuads = r;
+    const s = r * this.verticesPerQuad * this.floatsPerVertex;
+    this.vertexData = new Float32Array(s);
+    const i = e.createBuffer();
+    if (!i)
+      throw new Error("Failed to create vertex buffer");
+    this.vertexBuffer = i, e.bindBuffer(e.ARRAY_BUFFER, this.vertexBuffer), e.bufferData(e.ARRAY_BUFFER, this.vertexData.byteLength, e.DYNAMIC_DRAW), e.bindBuffer(e.ARRAY_BUFFER, null);
+  }
+  /**
+   * Set the texture for batch rendering
+   * @param texture The texture to use when rendering
+   */
+  setTexture(e) {
+    this.texture = e;
+  }
+  /**
+   * Add a sprite quad to the batch
+   * @param quad Sprite quad instance to add
+   */
+  addQuad(e) {
+    if (this.quads.length >= this.maxQuads) {
+      console.warn(`Sprite batch renderer at max capacity (${this.maxQuads})`);
+      return;
+    }
+    this.quads.push(e), this.isDirty = !0;
+  }
+  /**
+   * Clear all quads from the batch
+   */
+  clear() {
+    this.quads = [], this.isDirty = !0;
+  }
+  /**
+   * 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 e = 0;
+    for (const t of this.quads) {
+      const {
+        x: r,
+        y: s,
+        z: i = 0,
+        width: o,
+        height: n,
+        rotation: a,
+        color: h = { r: 1, g: 1, b: 1, a: 1 },
+        uvRect: x = { uMin: 0, vMin: 0, uMax: 1, vMax: 1 },
+        texIndex: l = 0
+      } = t, d = this.generateQuadVertices({
+        x: r,
+        y: s,
+        z: i,
+        width: o,
+        height: n,
+        rotation: a,
+        color: h,
+        uvRect: x,
+        texIndex: l
+      });
+      for (const f of d)
+        this.vertexData[e++] = f.x, this.vertexData[e++] = f.y, this.vertexData[e++] = f.z, this.vertexData[e++] = f.u, this.vertexData[e++] = f.v, this.vertexData[e++] = f.r, this.vertexData[e++] = f.g, this.vertexData[e++] = f.b, this.vertexData[e++] = f.a, this.vertexData[e++] = f.texIndex;
+    }
+    this.vertexBuffer && (this.gl.bindBuffer(this.gl.ARRAY_BUFFER, this.vertexBuffer), this.gl.bufferSubData(
+      this.gl.ARRAY_BUFFER,
+      0,
+      this.vertexData.subarray(0, e)
+    ), this.gl.bindBuffer(this.gl.ARRAY_BUFFER, null)), this.isDirty = !1;
+  }
+  /**
+   * 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(e) {
+    this.depthTestEnabled = e;
+  }
+  /**
+   * Render the batch
+   * @param camera Optional camera for view transform (defaults to identity matrix)
+   */
+  render(e) {
+    if (this.quads.length !== 0 && (this.update(), this.shader.use(), this.depthTestEnabled ? (this.gl.enable(this.gl.DEPTH_TEST), this.gl.depthFunc(this.gl.LEQUAL)) : this.gl.disable(this.gl.DEPTH_TEST), this.vertexBuffer)) {
+      this.gl.bindBuffer(this.gl.ARRAY_BUFFER, this.vertexBuffer);
+      const t = this.shader.getAttributeLocation("aPosition"), r = this.shader.getAttributeLocation("aTexCoord"), s = this.shader.getAttributeLocation("aColor"), i = this.shader.getAttributeLocation("aTexIndex"), o = this.floatsPerVertex * 4;
+      if (t !== -1 && (this.gl.enableVertexAttribArray(t), this.gl.vertexAttribPointer(
+        t,
+        3,
+        // 3 floats (x, y, z)
+        this.gl.FLOAT,
+        !1,
+        o,
+        0
+        // offset
+      )), r !== -1 && (this.gl.enableVertexAttribArray(r), this.gl.vertexAttribPointer(
+        r,
+        2,
+        // 2 floats (u, v)
+        this.gl.FLOAT,
+        !1,
+        o,
+        12
+        // offset after position
+      )), s !== -1 && (this.gl.enableVertexAttribArray(s), this.gl.vertexAttribPointer(
+        s,
+        4,
+        // 4 floats (r, g, b, a)
+        this.gl.FLOAT,
+        !1,
+        o,
+        20
+        // offset after texCoord
+      )), i !== -1 && (this.gl.enableVertexAttribArray(i), this.gl.vertexAttribPointer(
+        i,
+        1,
+        // 1 float (texIndex)
+        this.gl.FLOAT,
+        !1,
+        o,
+        36
+        // offset after color
+      )), this.texture) {
+        this.texture.bind(0);
+        const h = this.shader.getUniformLocation("uTexture");
+        h !== null && this.gl.uniform1i(h, 0);
+      }
+      const n = this.shader.getUniformLocation("uMatrix");
+      if (n !== null) {
+        const h = e ? e.getViewMatrix() : new Float32Array([
+          1,
+          0,
+          0,
+          0,
+          0,
+          1,
+          0,
+          0,
+          0,
+          0,
+          1,
+          0,
+          0,
+          0,
+          0,
+          1
+        ]);
+        this.gl.uniformMatrix4fv(n, !1, h);
+      }
+      const a = this.quads.length * this.verticesPerQuad;
+      this.gl.drawArrays(this.gl.TRIANGLES, 0, a), this.gl.bindBuffer(this.gl.ARRAY_BUFFER, null);
+    }
+  }
+  /**
+   * Generate vertices for a quad with rotation applied
+   * Returns 6 vertices (2 triangles)
+   * @private
+   */
+  generateQuadVertices(e) {
+    const { x: t, y: r, z: s, width: i, height: o, rotation: n, color: a, uvRect: h, texIndex: x } = e, l = i / 2, d = o / 2, f = Math.cos(n), y = Math.sin(n), m = (u, w) => [u * f - w * y, u * y + w * f], v = [
+      [-l, -d],
+      // bottom-left
+      [l, -d],
+      // bottom-right
+      [l, d],
+      // top-right
+      [l, d],
+      // top-right (duplicate)
+      [-l, d],
+      // top-left
+      [-l, -d]
+      // bottom-left (duplicate)
+    ], E = [
+      [h.uMin, h.vMin],
+      // bottom-left
+      [h.uMax, h.vMin],
+      // bottom-right
+      [h.uMax, h.vMax],
+      // top-right
+      [h.uMax, h.vMax],
+      // top-right
+      [h.uMin, h.vMax],
+      // top-left
+      [h.uMin, h.vMin]
+      // bottom-left
+    ], A = [];
+    for (let u = 0; u < v.length; u++) {
+      const [w, b] = v[u], [_, D] = m(w, b), [U, g] = E[u];
+      A.push({
+        x: t + _,
+        y: r + D,
+        z: s,
+        u: U,
+        v: g,
+        r: a.r,
+        g: a.g,
+        b: a.b,
+        a: a.a,
+        texIndex: x
+      });
+    }
+    return A;
+  }
+  /**
+   * Dispose resources
+   */
+  dispose() {
+    this.vertexBuffer && (this.gl.deleteBuffer(this.vertexBuffer), this.vertexBuffer = null);
+  }
+}
+class F {
+  /**
+   * 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(e, t, r = 0) {
+    return new Float32Array([
+      1,
+      0,
+      0,
+      0,
+      // column 0
+      0,
+      1,
+      0,
+      0,
+      // column 1
+      0,
+      0,
+      1,
+      0,
+      // column 2
+      e,
+      t,
+      r,
+      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(e, t, r = 1) {
+    return new Float32Array([
+      e,
+      0,
+      0,
+      0,
+      // column 0
+      0,
+      t,
+      0,
+      0,
+      // column 1
+      0,
+      0,
+      r,
+      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(e, t) {
+    const r = new Float32Array(16);
+    for (let s = 0; s < 4; s++)
+      for (let i = 0; i < 4; i++) {
+        let o = 0;
+        for (let n = 0; n < 4; n++)
+          o += e[n * 4 + i] * t[s * 4 + n];
+        r[s * 4 + i] = o;
+      }
+    return r;
+  }
+  /**
+   * 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(e, t, r) {
+    const s = F.translation(-e, -t, 0), i = F.scale(r, r, 1);
+    return F.multiply(s, i);
+  }
+}
+class ge {
+  /**
+   * 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(e = 0, t = 0, r = 1) {
+    this._viewMatrix = null, this._viewMatrixDirty = !0, this._x = e, this._y = t, this._zoom = r;
+  }
+  /**
+   * Get the camera X position
+   */
+  get x() {
+    return this._x;
+  }
+  /**
+   * Set the camera X position
+   */
+  set x(e) {
+    this._x = e, this._viewMatrixDirty = !0;
+  }
+  /**
+   * Get the camera Y position
+   */
+  get y() {
+    return this._y;
+  }
+  /**
+   * Set the camera Y position
+   */
+  set y(e) {
+    this._y = e, this._viewMatrixDirty = !0;
+  }
+  /**
+   * 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(e) {
+    this._zoom = Math.max(1e-3, e), this._viewMatrixDirty = !0;
+  }
+  /**
+   * Set both X and Y position at once
+   * @param x New X position
+   * @param y New Y position
+   */
+  setPosition(e, t) {
+    this._x = e, this._y = t, this._viewMatrixDirty = !0;
+  }
+  /**
+   * 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(e, t) {
+    this._x += e, this._y += t, this._viewMatrixDirty = !0;
+  }
+  /**
+   * Scale the zoom by a factor
+   * @param factor Multiplier for current zoom (e.g., 1.1 to zoom in 10%)
+   */
+  zoomBy(e) {
+    this._zoom = Math.max(1e-3, this._zoom * e), this._viewMatrixDirty = !0;
+  }
+  /**
+   * Reset camera to default position and zoom
+   */
+  reset() {
+    this._x = 0, this._y = 0, this._zoom = 1, this._viewMatrixDirty = !0;
+  }
+  /**
+   * 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() {
+    return (this._viewMatrixDirty || this._viewMatrix === null) && (this._viewMatrix = F.createViewMatrix(this._x, this._y, this._zoom), this._viewMatrixDirty = !1), 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(e, t, r, s) {
+    const i = e - r / 2, o = t - s / 2, n = i / this._zoom + this._x, a = o / this._zoom + this._y;
+    return { x: n, y: a };
+  }
+  /**
+   * 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(e, t, r, s) {
+    const i = (e - this._x) * this._zoom, o = (t - this._y) * this._zoom, n = i + r / 2, a = o + s / 2;
+    return { x: n, y: a };
+  }
+}
+class J {
+  /**
+   * 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(e = "", t = 1e4) {
+    this.baseUrl = e || this.getCurrentOrigin(), this.defaultTimeout = t;
+  }
+  /**
+   * Get the current origin (protocol + host + port)
+   */
+  getCurrentOrigin() {
+    return typeof window < "u" ? window.location.origin : "http://localhost";
+  }
+  /**
+   * Resolve a relative path against the base URL
+   * @param path Relative or absolute path
+   * @returns Resolved absolute URL
+   */
+  resolvePath(e) {
+    try {
+      return e.startsWith("http://") || e.startsWith("https://") ? e : e.startsWith("//") ? window.location.protocol + e : e.startsWith("/") ? this.baseUrl + e : `${this.baseUrl}/${e}`;
+    } catch {
+      return e;
+    }
+  }
+  /**
+   * 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(e, t) {
+    const r = this.resolvePath(e);
+    try {
+      const s = {
+        credentials: t?.credentials || "same-origin"
+      };
+      t?.headers && (s.headers = t.headers);
+      const i = new AbortController(), o = setTimeout(() => i.abort(), this.defaultTimeout);
+      s.signal = i.signal;
+      const n = await fetch(r, s);
+      if (clearTimeout(o), !n.ok)
+        throw new Error(
+          `HTTP ${n.status}: ${n.statusText} for URL: ${r}`
+        );
+      return await n.text();
+    } catch (s) {
+      throw s instanceof Error ? s.name === "AbortError" ? new Error(
+        `Request timeout after ${this.defaultTimeout}ms for URL: ${r}`
+      ) : new Error(`Failed to load resource from ${r}: ${s.message}`) : new Error(`Failed to load resource from ${r}: 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(e, t) {
+    const r = e.map(async (s) => {
+      try {
+        return {
+          data: await this.load(s, t),
+          path: s,
+          success: !0
+        };
+      } catch (i) {
+        return {
+          data: "",
+          path: s,
+          success: !1,
+          error: i instanceof Error ? i.message : String(i)
+        };
+      }
+    });
+    return Promise.all(r);
+  }
+  /**
+   * 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(e) {
+    const t = [
+      /^https?:\/\//i,
+      // Absolute HTTP(S) URLs
+      /^\/\//,
+      // Protocol-relative URLs
+      /^\//,
+      // Absolute paths
+      /^\.\.?\//
+      // Relative paths starting with ./ or ../
+    ], r = /\.[a-z0-9]+$/i.test(e);
+    return t.some((s) => s.test(e)) || r;
+  }
+  /**
+   * Set a new base URL for resolving relative paths
+   * @param baseUrl New base URL
+   */
+  setBaseUrl(e) {
+    this.baseUrl = e;
+  }
+  /**
+   * Get the current base URL
+   * @returns Current base URL
+   */
+  getBaseUrl() {
+    return this.baseUrl;
+  }
+  /**
+   * Set the default request timeout
+   * @param timeout Timeout in milliseconds
+   */
+  setTimeout(e) {
+    this.defaultTimeout = e;
+  }
+}
+const Z = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  BrowserResourceLoader: J
+}, Symbol.toStringTag, { value: "Module" }));
+class ee {
+  /**
+   * Create a new Node.js resource loader
+   * @param baseDir Optional base directory for resolving relative paths (defaults to current working directory)
+   */
+  constructor(e = process.cwd()) {
+    this.baseDir = e;
+  }
+  /**
+   * Resolve a relative path against the base directory
+   * @param filePath Relative or absolute file path
+   * @returns Resolved absolute file path
+   */
+  resolvePath(e) {
+    return T.isAbsolute(e) ? T.normalize(e) : T.normalize(T.join(this.baseDir, e));
+  }
+  /**
+   * 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(e, t) {
+    const r = this.resolvePath(e), s = t?.encoding || "utf-8";
+    try {
+      return await C.readFile(r, s);
+    } catch (i) {
+      if (i instanceof Error) {
+        const o = i.code;
+        throw o === "ENOENT" ? new Error(
+          `File not found: ${r} (resolved from: ${e})`
+        ) : o === "EACCES" ? new Error(
+          `Permission denied reading file: ${r}`
+        ) : o === "EISDIR" ? new Error(
+          `Path is a directory, not a file: ${r}`
+        ) : new Error(
+          `Failed to load resource from ${r}: ${i.message}`
+        );
+      }
+      throw new Error(
+        `Failed to load resource from ${r}: 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(e, t) {
+    const r = e.map(async (s) => {
+      try {
+        return {
+          data: await this.load(s, t),
+          path: s,
+          success: !0
+        };
+      } catch (i) {
+        return {
+          data: "",
+          path: s,
+          success: !1,
+          error: i instanceof Error ? i.message : String(i)
+        };
+      }
+    });
+    return Promise.all(r);
+  }
+  /**
+   * 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(e) {
+    return [
+      /^\//,
+      // 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/")
+    ].some((r) => r.test(e));
+  }
+  /**
+   * Check if a file exists without loading it
+   * @param filePath File path to check
+   * @returns Promise resolving to true if file exists
+   */
+  async exists(e) {
+    const t = this.resolvePath(e);
+    try {
+      return await C.access(t, C.constants.F_OK), !0;
+    } catch {
+      return !1;
+    }
+  }
+  /**
+   * Get file statistics (size, modification time, etc.)
+   * @param filePath File path to check
+   * @returns Promise resolving to file stats
+   */
+  async getStats(e) {
+    const t = this.resolvePath(e);
+    return C.stat(t);
+  }
+  /**
+   * Set a new base directory for resolving relative paths
+   * @param baseDir New base directory
+   */
+  setBaseDir(e) {
+    this.baseDir = e;
+  }
+  /**
+   * 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(e, t = !1) {
+    const r = this.resolvePath(e), s = await C.readdir(r, { withFileTypes: !0 }), i = [];
+    for (const o of s) {
+      const n = T.join(r, o.name);
+      if (o.isDirectory() && t) {
+        const a = await this.listDirectory(n, !0);
+        i.push(...a);
+      } else o.isFile() && i.push(n);
+    }
+    return i;
+  }
+}
+const te = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  NodeResourceLoader: ee
+}, Symbol.toStringTag, { value: "Module" }));
+var I = /* @__PURE__ */ ((c) => (c.BROWSER = "browser", c.NODE = "node", c.UNKNOWN = "unknown", c))(I || {});
+class N {
+  /**
+   * Detect the current runtime environment
+   * @returns The detected environment type
+   */
+  static detectEnvironment() {
+    return typeof window < "u" && typeof window.document < "u" && typeof fetch < "u" ? "browser" : typeof process < "u" && process.versions != null && process.versions.node != null ? "node" : "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(e) {
+    const t = e?.forceEnvironment || this.detectEnvironment();
+    switch (t) {
+      case "browser":
+        return await this.createBrowserLoader(e);
+      case "node":
+        return await this.createNodeLoader(e);
+      case "unknown":
+        throw new Error(
+          "Unsupported environment: Unable to determine runtime environment. Please specify forceEnvironment in options."
+        );
+      default:
+        throw new Error(`Unsupported environment: ${t}`);
+    }
+  }
+  /**
+   * Create a browser resource loader
+   * @param options Optional factory configuration
+   * @returns A browser resource loader instance
+   */
+  static async createBrowserLoader(e) {
+    const { BrowserResourceLoader: t } = await Promise.resolve().then(() => Z);
+    return new t(e?.baseUrl, e?.timeout);
+  }
+  /**
+   * Create a Node.js resource loader
+   * @param options Optional factory configuration
+   * @returns A Node.js resource loader instance
+   */
+  static async createNodeLoader(e) {
+    const { NodeResourceLoader: t } = await Promise.resolve().then(() => te);
+    return new t(e?.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(e, t) {
+    try {
+      return t = { ...t, forceEnvironment: e }, await this.create(t);
+    } catch {
+      return await this.create({ ...t, forceEnvironment: void 0 });
+    }
+  }
+}
+async function re(c) {
+  return await N.create(c);
+}
+const se = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  Environment: I,
+  ResourceLoaderFactory: N,
+  createResourceLoader: re
+}, Symbol.toStringTag, { value: "Module" }));
+class ie {
+  constructor(e = !0) {
+    this.cache = /* @__PURE__ */ new Map(), this.enabled = e;
+  }
+  get(e) {
+    if (this.enabled)
+      return this.cache.get(e);
+  }
+  set(e, t) {
+    this.enabled && this.cache.set(e, t);
+  }
+  has(e) {
+    return this.enabled ? this.cache.has(e) : !1;
+  }
+  clear() {
+    this.cache.clear();
+  }
+  size() {
+    return this.cache.size;
+  }
+  enable() {
+    this.enabled = !0;
+  }
+  disable() {
+    this.enabled = !1;
+  }
+}
+class oe {
+  /**
+   * Create a new resource loading pipeline
+   * @param loader Resource loader instance
+   * @param options Pipeline configuration options
+   */
+  constructor(e, t) {
+    this.loader = e, this.concurrency = t?.concurrency ?? 10, this.cache = new ie(t?.cache ?? !0);
+  }
+  /**
+   * 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(e, t) {
+    const r = this.cache.get(e);
+    if (r !== void 0)
+      return r;
+    const s = await this.loader.load(e, t);
+    return this.cache.set(e, s), s;
+  }
+  /**
+   * 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(e, t) {
+    const r = /* @__PURE__ */ new Map(), s = /* @__PURE__ */ new Map();
+    for (let i = 0; i < e.length; i += this.concurrency) {
+      const o = e.slice(i, i + this.concurrency), n = await this.loader.loadMultiple(o, t);
+      for (const a of n)
+        a.success ? (r.set(a.path, a.data), this.cache.set(a.path, a.data)) : s.set(a.path, a.error || "Unknown error");
+    }
+    return {
+      succeeded: r,
+      failed: s,
+      total: e.length,
+      successCount: r.size,
+      failureCount: s.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(e, t, r) {
+    const [s, i] = await Promise.all([
+      this.load(e, r),
+      this.load(t, r)
+    ]);
+    return { vertex: s, fragment: i };
+  }
+  /**
+   * 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(e, t) {
+    return await Promise.all(
+      e.map(async (s) => {
+        const i = await this.loadShader(
+          s.vertex,
+          s.fragment,
+          t
+        );
+        return {
+          name: s.name,
+          ...i
+        };
+      })
+    );
+  }
+  /**
+   * 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(e, t) {
+    const r = await this.load(e, t), s = JSON.parse(r);
+    return this.loadBatch(s.resources, t);
+  }
+  /**
+   * 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(e, t) {
+    await this.loadBatch(e, t);
+  }
+  /**
+   * Check if a resource is cached
+   * @param path Resource path
+   * @returns true if the resource is in the cache
+   */
+  isCached(e) {
+    return this.cache.has(e);
+  }
+  /**
+   * Get a resource from cache without loading
+   * @param path Resource path
+   * @returns Cached content or undefined if not cached
+   */
+  getCached(e) {
+    return this.cache.get(e);
+  }
+  /**
+   * 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(e) {
+    this.concurrency = Math.max(1, e);
+  }
+  /**
+   * Get the underlying resource loader
+   * @returns The resource loader instance
+   */
+  getLoader() {
+    return this.loader;
+  }
+}
+async function ne(c) {
+  const { ResourceLoaderFactory: e } = await Promise.resolve().then(() => se), t = await e.create({
+    baseUrl: c?.baseUrl,
+    baseDir: c?.baseDir,
+    timeout: c?.timeout
+  });
+  return new oe(t, c);
+}
+const L = {
+  width: 800,
+  height: 600
+}, P = {
+  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: 20
+    // 5 floats per vertex × 4 bytes
+  }
+}, S = {
+  size: 256
+}, M = {
+  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 ae() {
+  console.log("🩸 Bloody Engine - Resource Loader Demo"), console.log(`==========================================
+`);
+  const c = N.detectEnvironment();
+  if (console.log(`✓ Environment detected: ${c}`), c !== I.BROWSER) {
+    console.warn("⚠ This demo is designed for browser environment");
+    return;
+  }
+  console.log(`
+1. Creating Resource Pipeline...`);
+  const e = await ne({
+    concurrency: 5,
+    cache: !0,
+    timeout: 1e4,
+    baseUrl: window.location.origin
+  });
+  console.log("✓ Resource pipeline created"), console.log("  - Concurrency: 5"), console.log("  - Caching: enabled"), console.log(`
+2. Batch Loading Resources...`), console.log(`Loading ${M.resources.length} resources...`);
+  const t = await e.loadBatch(M.resources);
+  if (console.log("✓ Batch loading complete"), console.log(`  - Succeeded: ${t.successCount}`), console.log(`  - Failed: ${t.failureCount}`), t.failureCount > 0) {
+    console.log(`
+❌ Failed resources:`);
+    for (const [g, p] of t.failed)
+      console.log(`  - ${g}: ${p}`);
+    console.log(`
+⚠️ Falling back to inline shaders...`);
+  }
+  console.log(`
+3. Loading Shaders...`);
+  const r = await e.loadShaders(M.shaders);
+  console.log(`✓ Loaded ${r.length} shaders:`);
+  for (const g of r)
+    console.log(`  - ${g.name}:`), console.log(`    Vertex: ${g.vertex.length} chars`), console.log(`    Fragment: ${g.fragment.length} chars`);
+  console.log(`
+4. Testing Cache...`);
+  const s = e.getCacheSize();
+  console.log(`✓ Cache contains ${s} resources`);
+  for (const g of M.shaders) {
+    const p = e.isCached(g.vertex), $ = e.isCached(g.fragment);
+    console.log(`  - ${g.name}:`), console.log(`    Vertex cached: ${p}`), console.log(`    Fragment cached: ${$}`);
+  }
+  console.log(`
+5. Initializing Graphics Device...`);
+  const i = new W(L.width, L.height), o = i.getGLContext();
+  console.log("✓ Graphics device initialized"), console.log(`  - Resolution: ${L.width}x${L.height}`), console.log(`
+6. Creating Shader from Loaded Source...`);
+  let n = r.find((g) => g.name === "glow");
+  (!n || !n.vertex || !n.fragment) && (console.warn("⚠️ Glow shader not loaded or empty, using inline fallback"), n = {
+    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 a = i.createShader(n.vertex, n.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(`
+7. Creating Texture...`);
+  const h = B.createGradient(
+    o,
+    S.size,
+    S.size
+  );
+  console.log("✓ Gradient texture created"), console.log(`  - Size: ${S.size}x${S.size}`), console.log(`
+8. Creating Geometry Buffers...`);
+  const { VertexBuffer: x } = await Promise.resolve().then(() => K), l = new x(
+    o,
+    P.quad.vertices,
+    P.quad.stride
+  );
+  console.log("✓ Quad buffer created"), console.log(`  - Vertices: ${l.getVertexCount()}`), console.log(`
+9. Setting up Rendering...`), a.use();
+  const d = a.getAttributeLocation("aPosition"), f = a.getAttributeLocation("aTexCoord"), y = a.getUniformLocation("uTexture"), m = a.getUniformLocation("uMatrix"), v = a.getUniformLocation("uColor"), E = a.getUniformLocation("uGlowIntensity");
+  l.bind(), o.enableVertexAttribArray(d), o.vertexAttribPointer(d, 3, o.FLOAT, !1, P.quad.stride, 0), o.enableVertexAttribArray(f), o.vertexAttribPointer(
+    f,
+    2,
+    o.FLOAT,
+    !1,
+    P.quad.stride,
+    12
+  ), console.log("✓ Vertex attributes configured"), h.bind(0), o.uniform1i(y, 0), console.log("✓ Texture bound to unit 0");
+  const u = i.getRenderingContext().canvas;
+  u && (u.style.display = "block", u.style.margin = "0 auto", u.style.border = "2px solid #333", u.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 w = document.createElement("h1");
+  w.textContent = "🩸 Resource Loader Demo", w.style.textAlign = "center", w.style.color = "#fff", u && u.parentNode ? u.parentNode.insertBefore(w, u) : document.body.insertBefore(w, document.body.firstChild);
+  const b = document.createElement("div");
+  b.style.textAlign = "center", b.style.marginTop = "10px", b.style.fontSize = "12px", b.innerHTML = `
+    <div>Environment: <strong>${c}</strong></div>
+    <div>Shaders loaded: <strong>${r.length}</strong></div>
+    <div>Cached resources: <strong>${s}</strong></div>
+  `, document.body.appendChild(b);
+  let _ = 0;
+  const D = Date.now();
+  function U() {
+    const g = Date.now(), p = (g - D) / 1e3;
+    i.clear({ r: 0.1, g: 0.1, b: 0.1, a: 1 });
+    const $ = [
+      { 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 R of $) {
+      const z = ce();
+      if (he(z, R.x, R.y, 0), le(z, 0.4, 0.4, 1), m && o.uniformMatrix4fv(m, !1, z), v && o.uniform3f(
+        v,
+        R.color[0],
+        R.color[1],
+        R.color[2]
+      ), E) {
+        const q = R.glow + Math.sin(p * 2) * 0.3;
+        o.uniform1f(E, q);
+      }
+      o.drawArrays(o.TRIANGLES, 0, l.getVertexCount());
+    }
+    i.present(), _++;
+    const V = (g - D) / 1e3, O = _ / V;
+    b.innerHTML = `
+      <div>FPS: <strong>${O.toFixed(1)}</strong> | Frame: <strong>${_}</strong> | Elapsed: <strong>${V.toFixed(2)}s</strong></div>
+      <div>Environment: <strong>${c}</strong> | Shaders loaded: <strong>${r.length}</strong> | Cached: <strong>${s}</strong></div>
+    `, requestAnimationFrame(U);
+  }
+  console.log(`
+✓ Demo started! Rendering animation...`), U();
+}
+function ce() {
+  return new Float32Array([
+    1,
+    0,
+    0,
+    0,
+    0,
+    1,
+    0,
+    0,
+    0,
+    0,
+    1,
+    0,
+    0,
+    0,
+    0,
+    1
+  ]);
+}
+function he(c, e, t, r) {
+  c[12] += e, c[13] += t, c[14] += r;
+}
+function le(c, e, t, r) {
+  c[0] *= e, c[5] *= t, c[10] *= r;
+}
+typeof window < "u" && ae().catch((c) => {
+  console.error("❌ Demo failed:", c);
+});
+export {
+  de as BatchRenderer,
+  Y as BrowserRenderingContext,
+  J as BrowserResourceLoader,
+  ge as Camera,
+  I as Environment,
+  W as GraphicsDevice,
+  j as IndexBuffer,
+  F as Matrix4,
+  G as NodeRenderingContext,
+  ee as NodeResourceLoader,
+  k as RenderingContextFactory,
+  N as ResourceLoaderFactory,
+  oe as ResourcePipeline,
+  H as Shader,
+  fe as SpriteBatchRenderer,
+  B as Texture,
+  Q as VertexBuffer,
+  re as createResourceLoader,
+  ne as createResourcePipeline,
+  ae as runBrowserResourceLoaderDemo
+};