bloody-engine 1.0.3 → 1.0.5

package/dist/web/index.js

@@ -1,25 +1,26 @@
-import X from "gl";
+import Q from "gl";
+import W from "@kmamal/sdl";
 import * as p 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 = {
+import * as C from "path";
+class O {
+  constructor(t) {
+    this.isBrowser = !0, t.canvas ? this.canvas = t.canvas : (this.canvas = document.createElement("canvas"), document.body.appendChild(this.canvas)), this.width = t.width, this.height = t.height, this.canvas.width = this.width, this.canvas.height = this.height;
+    const e = {
       alpha: !1,
-      ...e.contextAttributes
-    }, r = this.canvas.getContext("webgl", t);
+      ...t.contextAttributes
+    }, r = this.canvas.getContext("webgl", e);
     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);
+  resize(t, e) {
+    this.width = t, this.height = e, this.canvas.width = t, this.canvas.height = e, this.glContext.viewport(0, 0, t, e);
   }
   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(
+  clear(t) {
+    t && this.glContext.clearColor(t.r, t.g, t.b, t.a), this.glContext.clear(
       this.glContext.COLOR_BUFFER_BIT | this.glContext.DEPTH_BUFFER_BIT
     );
   }
@@ -35,27 +36,27 @@ class Y {
     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
+class q {
+  constructor(t) {
+    this.isBrowser = !1, this.width = t.width, this.height = t.height;
+    const e = Q(this.width, this.height, {
+      preserveDrawingBuffer: t.preserveDrawingBuffer ?? !0,
+      ...t.contextAttributes
     });
-    if (!t)
+    if (!e)
       throw new Error("Failed to initialize WebGL context in Node.js");
-    this.glContext = t;
+    this.glContext = e;
   }
-  resize(e, t) {
-    this.width = e, this.height = t, console.warn(
+  resize(t, e) {
+    this.width = t, this.height = e, 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(
+  clear(t) {
+    t && this.glContext.clearColor(t.r, t.g, t.b, t.a), this.glContext.clear(
       this.glContext.COLOR_BUFFER_BIT | this.glContext.DEPTH_BUFFER_BIT
     );
   }
@@ -70,7 +71,7 @@ class G {
    * Used for capturing frames for display or saving
    */
   readPixels() {
-    const e = new Uint8Array(this.width * this.height * 4);
+    const t = new Uint8Array(this.width * this.height * 4);
     return this.glContext.readPixels(
       0,
       0,
@@ -78,11 +79,11 @@ class G {
       this.height,
       this.glContext.RGBA,
       this.glContext.UNSIGNED_BYTE,
-      e
-    ), e;
+      t
+    ), t;
   }
 }
-class k {
+class X {
   /**
    * Detect if running in a browser environment
    */
@@ -92,20 +93,20 @@ class k {
   /**
    * Create a rendering context appropriate for the current environment
    */
-  static createContext(e) {
-    return this.isBrowserEnvironment() ? new Y(e) : new G(e);
+  static createContext(t) {
+    return this.isBrowserEnvironment() ? new O(t) : new q(t);
   }
   /**
    * Create a browser-specific rendering context
    */
-  static createBrowserContext(e) {
-    return new Y(e);
+  static createBrowserContext(t) {
+    return new O(t);
   }
   /**
    * Create a Node.js-specific rendering context
    */
-  static createNodeContext(e) {
-    return new G(e);
+  static createNodeContext(t) {
+    return new q(t);
   }
 }
 class H {
@@ -116,21 +117,21 @@ class H {
    * @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
+  constructor(t, e, r, i) {
+    this.gl = t;
+    const s = this.injectPrecisionHeader(
+      e,
+      i
     ), o = this.injectPrecisionHeader(
       r,
-      s
+      i
     );
     this.vertexShader = this.compileShader(
-      i,
-      e.VERTEX_SHADER
+      s,
+      t.VERTEX_SHADER
     ), this.fragmentShader = this.compileShader(
       o,
-      e.FRAGMENT_SHADER
+      t.FRAGMENT_SHADER
     ), this.program = this.linkProgram(this.vertexShader, this.fragmentShader);
   }
   /**
@@ -139,11 +140,11 @@ class H {
    * @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
+  injectPrecisionHeader(t, e) {
+    return t.includes("#ifdef GL_ES") || t.includes("precision") ? t : `#ifdef GL_ES
 precision highp float;
 #endif
-` + e;
+` + t;
   }
   /**
    * Compile a single shader (vertex or fragment)
@@ -151,18 +152,18 @@ precision highp float;
    * @param type gl.VERTEX_SHADER or gl.FRAGMENT_SHADER
    * @returns Compiled shader
    */
-  compileShader(e, t) {
-    const r = this.gl.createShader(t);
+  compileShader(t, e) {
+    const r = this.gl.createShader(e);
     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 new Error(`Failed to create shader of type ${e}`);
+    if (this.gl.shaderSource(r, t), this.gl.compileShader(r), !this.gl.getShaderParameter(r, this.gl.COMPILE_STATUS)) {
+      const s = this.gl.getShaderInfoLog(r), o = e === this.gl.VERTEX_SHADER ? "vertex" : "fragment";
       throw this.gl.deleteShader(r), new Error(
         `Failed to compile ${o} shader:
-${i}
+${s}
 
 Source:
-${e}`
+${t}`
       );
     }
     return r;
@@ -173,14 +174,14 @@ ${e}`
    * @param fragmentShader Compiled fragment shader
    * @returns Linked shader program
    */
-  linkProgram(e, t) {
+  linkProgram(t, e) {
     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}`);
+    if (this.gl.attachShader(r, t), this.gl.attachShader(r, e), this.gl.linkProgram(r), !this.gl.getProgramParameter(r, this.gl.LINK_STATUS)) {
+      const s = this.gl.getProgramInfoLog(r);
+      throw this.gl.deleteProgram(r), this.gl.deleteShader(t), this.gl.deleteShader(e), new Error(`Failed to link shader program:
+${s}`);
     }
     return r;
   }
@@ -194,15 +195,15 @@ ${i}`);
    * Get uniform location by name
    * @param name Uniform variable name
    */
-  getUniformLocation(e) {
-    return this.gl.getUniformLocation(this.program, e);
+  getUniformLocation(t) {
+    return this.gl.getUniformLocation(this.program, t);
   }
   /**
    * Get attribute location by name
    * @param name Attribute variable name
    */
-  getAttributeLocation(e) {
-    return this.gl.getAttribLocation(this.program, e);
+  getAttributeLocation(t) {
+    return this.gl.getAttribLocation(this.program, t);
   }
   /**
    * Use this shader program
@@ -217,11 +218,11 @@ ${i}`);
     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,
+class k {
+  constructor(t, e) {
+    this.context = X.createContext({
+      width: t,
+      height: e,
       preserveDrawingBuffer: !0
     });
   }
@@ -264,14 +265,14 @@ class W {
   /**
    * Resize the graphics device
    */
-  resize(e, t) {
-    this.context.resize(e, t);
+  resize(t, e) {
+    this.context.resize(t, e);
   }
   /**
    * Clear the rendering surface
    */
-  clear(e) {
-    this.context.clear(e);
+  clear(t) {
+    this.context.clear(t);
   }
   /**
    * Present the rendered frame
@@ -291,16 +292,96 @@ class W {
    * @param fragmentSource Fragment shader source code
    * @returns Compiled and linked shader program
    */
-  createShader(e, t) {
+  createShader(t, e) {
     return new H(
       this.context.glContext,
-      e,
       t,
+      e,
       this.context.isBrowser
     );
   }
 }
-class B {
+class ft {
+  constructor(t, e, r = "Bloody Engine") {
+    this.closed = !1, this.width = t, this.height = e, this.title = r;
+    try {
+      if (this.window = W.video.createWindow({
+        width: this.width,
+        height: this.height,
+        title: this.title
+      }), !this.window)
+        throw new Error("Failed to create SDL window");
+      this.window.on("close", () => {
+        this.closed = !0;
+      }), console.log(`✓ SDL Window created (${t}x${e}): "${r}"`);
+    } catch (i) {
+      throw this.cleanup(), new Error(`Window creation failed: ${i}`);
+    }
+  }
+  /**
+   * Get window dimensions
+   */
+  getDimensions() {
+    return { width: this.width, height: this.height };
+  }
+  /**
+   * Display pixel data in the window
+   * @param pixels Uint8Array of RGBA pixel data
+   */
+  updatePixels(t) {
+    if (!(!this.window || this.closed))
+      try {
+        const e = Buffer.from(t), r = this.width * 4;
+        this.window.render(this.width, this.height, r, "rgba32", e);
+      } catch (e) {
+        console.error("Failed to update pixels:", e);
+      }
+  }
+  /**
+   * Register an event handler
+   */
+  on(t, e) {
+    if (!(!this.window || this.closed))
+      try {
+        this.window.on(t, (r) => {
+          try {
+            e(r);
+          } catch (i) {
+            console.error(`Error in ${t} handler:`, i);
+          }
+        });
+      } catch (r) {
+        console.error(`Error registering ${t} handler:`, r);
+      }
+  }
+  /**
+   * Check if window is still open
+   */
+  isOpen() {
+    return this.window !== null && !this.closed;
+  }
+  /**
+   * Cleanup and close window
+   */
+  cleanup() {
+    if (this.window && !this.closed) {
+      try {
+        this.window.destroy();
+      } catch (t) {
+        console.warn("Error destroying window:", t);
+      }
+      this.window = null, this.closed = !0;
+    }
+    console.log("✓ SDL Window cleaned up");
+  }
+  /**
+   * Destroy the window (alias for cleanup)
+   */
+  destroy() {
+    this.cleanup();
+  }
+}
+class _ {
   /**
    * Create a texture from pixel data
    * @param gl WebGL context
@@ -308,32 +389,32 @@ class B {
    * @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)
+  constructor(t, e, r, i) {
+    this.gl = t, this.width = e, this.height = r;
+    const s = t.createTexture();
+    if (!s)
       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,
+    this.texture = s, t.bindTexture(t.TEXTURE_2D, this.texture), t.texParameteri(t.TEXTURE_2D, t.TEXTURE_WRAP_S, t.CLAMP_TO_EDGE), t.texParameteri(t.TEXTURE_2D, t.TEXTURE_WRAP_T, t.CLAMP_TO_EDGE), t.texParameteri(t.TEXTURE_2D, t.TEXTURE_MIN_FILTER, t.LINEAR), t.texParameteri(t.TEXTURE_2D, t.TEXTURE_MAG_FILTER, t.LINEAR), i ? t.texImage2D(
+      t.TEXTURE_2D,
       0,
-      e.RGBA,
-      t,
+      t.RGBA,
+      e,
       r,
       0,
-      e.RGBA,
-      e.UNSIGNED_BYTE,
-      s
-    ) : e.texImage2D(
-      e.TEXTURE_2D,
+      t.RGBA,
+      t.UNSIGNED_BYTE,
+      i
+    ) : t.texImage2D(
+      t.TEXTURE_2D,
       0,
-      e.RGBA,
-      t,
+      t.RGBA,
+      e,
       r,
       0,
-      e.RGBA,
-      e.UNSIGNED_BYTE,
+      t.RGBA,
+      t.UNSIGNED_BYTE,
       null
-    ), e.bindTexture(e.TEXTURE_2D, null);
+    ), t.bindTexture(t.TEXTURE_2D, null);
   }
   /**
    * Create a solid color texture
@@ -345,13 +426,13 @@ class B {
    * @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;
+  static createSolid(t, e, r, i, s, o, n = 255) {
+    const a = e * r, h = new Uint8Array(a * 4);
+    for (let g = 0; g < a; g++) {
+      const l = g * 4;
+      h[l] = i, h[l + 1] = s, h[l + 2] = o, h[l + 3] = n;
     }
-    return new B(e, t, r, h);
+    return new _(t, e, r, h);
   }
   /**
    * Create a checkerboard texture
@@ -360,14 +441,14 @@ class B {
    * @param height Texture height
    * @param squareSize Size of each square
    */
-  static createCheckerboard(e, t, r, s = 32) {
-    const i = new Uint8Array(t * r * 4);
+  static createCheckerboard(t, e, r, i = 32) {
+    const s = new Uint8Array(e * 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;
+      for (let n = 0; n < e; n++) {
+        const a = Math.floor(n / i), h = Math.floor(o / i), g = (a + h) % 2 === 0, l = (o * e + n) * 4, f = g ? 255 : 0;
+        s[l] = f, s[l + 1] = f, s[l + 2] = f, s[l + 3] = 255;
       }
-    return new B(e, t, r, i);
+    return new _(t, e, r, s);
   }
   /**
    * Create a gradient texture
@@ -375,21 +456,21 @@ class B {
    * @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;
+  static createGradient(t, e, r) {
+    const i = new Uint8Array(e * r * 4);
+    for (let s = 0; s < r; s++)
+      for (let o = 0; o < e; o++) {
+        const n = (s * e + o) * 4;
+        i[n] = Math.floor(o / e * 255), i[n + 1] = Math.floor(s / r * 255), i[n + 2] = 128, i[n + 3] = 255;
       }
-    return new B(e, t, r, s);
+    return new _(t, e, r, i);
   }
   /**
    * 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);
+  bind(t = 0) {
+    this.gl.activeTexture(this.gl.TEXTURE0 + t), this.gl.bindTexture(this.gl.TEXTURE_2D, this.texture);
   }
   /**
    * Unbind texture
@@ -416,15 +497,15 @@ class B {
     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)
+class j {
+  constructor(t, e, r = 0) {
+    this.gl = t, this.stride = r;
+    const i = r > 0 ? r / 4 : 3;
+    this.vertexCount = e.length / i;
+    const s = t.createBuffer();
+    if (!s)
       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);
+    this.buffer = s, t.bindBuffer(t.ARRAY_BUFFER, this.buffer), t.bufferData(t.ARRAY_BUFFER, e, t.STATIC_DRAW), t.bindBuffer(t.ARRAY_BUFFER, null);
   }
   /**
    * Bind buffer for rendering
@@ -457,13 +538,13 @@ class Q {
     this.gl.deleteBuffer(this.buffer);
   }
 }
-class j {
-  constructor(e, t) {
-    this.gl = e, this.indexCount = t.length;
-    const r = e.createBuffer();
+class K {
+  constructor(t, e) {
+    this.gl = t, this.indexCount = e.length;
+    const r = t.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);
+    this.buffer = r, t.bindBuffer(t.ELEMENT_ARRAY_BUFFER, this.buffer), t.bufferData(t.ELEMENT_ARRAY_BUFFER, e, t.STATIC_DRAW), t.bindBuffer(t.ELEMENT_ARRAY_BUFFER, null);
   }
   /**
    * Bind buffer for rendering
@@ -490,44 +571,44 @@ class j {
     this.gl.deleteBuffer(this.buffer);
   }
 }
-const K = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+const Z = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
-  IndexBuffer: j,
-  VertexBuffer: Q
+  IndexBuffer: K,
+  VertexBuffer: j
 }, Symbol.toStringTag, { value: "Module" }));
-class ue {
+class gt {
   /**
    * 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)
+  constructor(t, e, r = 1e3) {
+    this.vertexBuffer = null, this.quads = [], this.isDirty = !1, this.verticesPerQuad = 6, this.floatsPerVertex = 5, this.texture = null, this.gl = t, this.shader = e, this.maxQuads = r;
+    const i = r * this.verticesPerQuad * this.floatsPerVertex;
+    this.vertexData = new Float32Array(i);
+    const s = t.createBuffer();
+    if (!s)
       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);
+    this.vertexBuffer = s, t.bindBuffer(t.ARRAY_BUFFER, this.vertexBuffer), t.bufferData(t.ARRAY_BUFFER, this.vertexData.byteLength, t.DYNAMIC_DRAW), t.bindBuffer(t.ARRAY_BUFFER, null);
   }
   /**
    * Set the texture for batch rendering
    * @param texture The texture to use when rendering
    */
-  setTexture(e) {
-    this.texture = e;
+  setTexture(t) {
+    this.texture = t;
   }
   /**
    * Add a quad to the batch
    * @param quad Quad instance to add
    */
-  addQuad(e) {
+  addQuad(t) {
     if (this.quads.length >= this.maxQuads) {
       console.warn(`Batch renderer at max capacity (${this.maxQuads})`);
       return;
     }
-    this.quads.push(e), this.isDirty = !0;
+    this.quads.push(t), this.isDirty = !0;
   }
   /**
    * Clear all quads from the batch
@@ -547,28 +628,28 @@ class ue {
   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];
+    let t = 0;
+    for (const e of this.quads) {
+      const r = this.generateQuadVertices(e);
+      for (const i of r)
+        this.vertexData[t++] = i[0], this.vertexData[t++] = i[1], this.vertexData[t++] = i[2], this.vertexData[t++] = i[3], this.vertexData[t++] = i[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.vertexData.subarray(0, t)
     ), 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) {
+  render(t) {
     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,
+      const e = this.shader.getAttributeLocation("aPosition"), r = this.shader.getAttributeLocation("aTexCoord");
+      if (e !== -1 && (this.gl.enableVertexAttribArray(e), this.gl.vertexAttribPointer(
+        e,
         3,
         // 3 floats (x, y, z)
         this.gl.FLOAT,
@@ -592,9 +673,9 @@ class ue {
         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([
+      const i = this.shader.getUniformLocation("uMatrix");
+      if (i !== null) {
+        const o = t ? t.getViewMatrix() : new Float32Array([
           1,
           0,
           0,
@@ -612,10 +693,10 @@ class ue {
           0,
           1
         ]);
-        this.gl.uniformMatrix4fv(s, !1, o);
+        this.gl.uniformMatrix4fv(i, !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);
+      const s = this.quads.length * this.verticesPerQuad;
+      this.gl.drawArrays(this.gl.TRIANGLES, 0, s), this.gl.bindBuffer(this.gl.ARRAY_BUFFER, null);
     }
   }
   /**
@@ -623,8 +704,8 @@ class ue {
    * 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, w) => [m * h - w * x, m * x + w * h], d = [
+  generateQuadVertices(t) {
+    const { x: e, y: r, width: i, height: s, rotation: o } = t, n = i / 2, a = s / 2, h = Math.cos(o), g = Math.sin(o), l = (x, w) => [x * h - w * g, x * g + w * h], f = [
       [-n, -a],
       // bottom-left
       [n, -a],
@@ -637,7 +718,7 @@ class ue {
       // top-left
       [-n, -a]
       // bottom-left (duplicate)
-    ], f = [
+    ], d = [
       [0, 0],
       // bottom-left
       [1, 0],
@@ -650,12 +731,12 @@ class ue {
       // top-left
       [0, 0]
       // bottom-left
-    ], y = [];
-    for (let m = 0; m < d.length; m++) {
-      const [w, E] = d[m], [A, u] = l(w, E), [v, b] = f[m];
-      y.push([t + A, r + u, 0, v, b]);
+    ], A = [];
+    for (let x = 0; x < f.length; x++) {
+      const [w, y] = f[x], [E, u] = l(w, y), [m, b] = d[x];
+      A.push([e + E, r + u, 0, m, b]);
     }
-    return y;
+    return A;
   }
   /**
    * Dispose resources
@@ -664,39 +745,39 @@ class ue {
     this.vertexBuffer && (this.gl.deleteBuffer(this.vertexBuffer), this.vertexBuffer = null);
   }
 }
-class de {
+class xt {
   /**
    * 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)
+  constructor(t, e, r = 1e3) {
+    this.vertexBuffer = null, this.quads = [], this.isDirty = !1, this.verticesPerQuad = 6, this.floatsPerVertex = 10, this.texture = null, this.depthTestEnabled = !0, this.gl = t, this.shader = e, this.maxQuads = r;
+    const i = r * this.verticesPerQuad * this.floatsPerVertex;
+    this.vertexData = new Float32Array(i);
+    const s = t.createBuffer();
+    if (!s)
       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);
+    this.vertexBuffer = s, t.bindBuffer(t.ARRAY_BUFFER, this.vertexBuffer), t.bufferData(t.ARRAY_BUFFER, this.vertexData.byteLength, t.DYNAMIC_DRAW), t.bindBuffer(t.ARRAY_BUFFER, null);
   }
   /**
    * Set the texture for batch rendering
    * @param texture The texture to use when rendering
    */
-  setTexture(e) {
-    this.texture = e;
+  setTexture(t) {
+    this.texture = t;
   }
   /**
    * Add a sprite quad to the batch
    * @param quad Sprite quad instance to add
    */
-  addQuad(e) {
+  addQuad(t) {
     if (this.quads.length >= this.maxQuads) {
       console.warn(`Sprite batch renderer at max capacity (${this.maxQuads})`);
       return;
     }
-    this.quads.push(e), this.isDirty = !0;
+    this.quads.push(t), this.isDirty = !0;
   }
   /**
    * Clear all quads from the batch
@@ -716,36 +797,36 @@ class de {
   update() {
     if (!this.isDirty || this.quads.length === 0)
       return;
-    let e = 0;
-    for (const t of this.quads) {
+    let t = 0;
+    for (const e of this.quads) {
       const {
         x: r,
-        y: s,
-        z: i = 0,
+        y: i,
+        z: s = 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 },
+        uvRect: g = { uMin: 0, vMin: 0, uMax: 1, vMax: 1 },
         texIndex: l = 0
-      } = t, d = this.generateQuadVertices({
+      } = e, f = this.generateQuadVertices({
         x: r,
-        y: s,
-        z: i,
+        y: i,
+        z: s,
         width: o,
         height: n,
         rotation: a,
         color: h,
-        uvRect: x,
+        uvRect: g,
         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;
+      for (const d of f)
+        this.vertexData[t++] = d.x, this.vertexData[t++] = d.y, this.vertexData[t++] = d.z, this.vertexData[t++] = d.u, this.vertexData[t++] = d.v, this.vertexData[t++] = d.r, this.vertexData[t++] = d.g, this.vertexData[t++] = d.b, this.vertexData[t++] = d.a, this.vertexData[t++] = d.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.vertexData.subarray(0, t)
     ), this.gl.bindBuffer(this.gl.ARRAY_BUFFER, null)), this.isDirty = !1;
   }
   /**
@@ -753,19 +834,19 @@ class de {
    * 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;
+  setDepthTestEnabled(t) {
+    this.depthTestEnabled = t;
   }
   /**
    * Render the batch
    * @param camera Optional camera for view transform (defaults to identity matrix)
    */
-  render(e) {
+  render(t) {
     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,
+      const e = this.shader.getAttributeLocation("aPosition"), r = this.shader.getAttributeLocation("aTexCoord"), i = this.shader.getAttributeLocation("aColor"), s = this.shader.getAttributeLocation("aTexIndex"), o = this.floatsPerVertex * 4;
+      if (e !== -1 && (this.gl.enableVertexAttribArray(e), this.gl.vertexAttribPointer(
+        e,
         3,
         // 3 floats (x, y, z)
         this.gl.FLOAT,
@@ -782,8 +863,8 @@ class de {
         o,
         12
         // offset after position
-      )), s !== -1 && (this.gl.enableVertexAttribArray(s), this.gl.vertexAttribPointer(
-        s,
+      )), i !== -1 && (this.gl.enableVertexAttribArray(i), this.gl.vertexAttribPointer(
+        i,
         4,
         // 4 floats (r, g, b, a)
         this.gl.FLOAT,
@@ -791,8 +872,8 @@ class de {
         o,
         20
         // offset after texCoord
-      )), i !== -1 && (this.gl.enableVertexAttribArray(i), this.gl.vertexAttribPointer(
-        i,
+      )), s !== -1 && (this.gl.enableVertexAttribArray(s), this.gl.vertexAttribPointer(
+        s,
         1,
         // 1 float (texIndex)
         this.gl.FLOAT,
@@ -807,7 +888,7 @@ class de {
       }
       const n = this.shader.getUniformLocation("uMatrix");
       if (n !== null) {
-        const h = e ? e.getViewMatrix() : new Float32Array([
+        const h = t ? t.getViewMatrix() : new Float32Array([
           1,
           0,
           0,
@@ -836,21 +917,21 @@ class de {
    * 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, v) => [u * f - v * y, u * y + v * f], w = [
-      [-l, -d],
+  generateQuadVertices(t) {
+    const { x: e, y: r, z: i, width: s, height: o, rotation: n, color: a, uvRect: h, texIndex: g } = t, l = s / 2, f = o / 2, d = Math.cos(n), A = Math.sin(n), x = (u, m) => [u * d - m * A, u * A + m * d], w = [
+      [-l, -f],
       // bottom-left
-      [l, -d],
+      [l, -f],
       // bottom-right
-      [l, d],
+      [l, f],
       // top-right
-      [l, d],
+      [l, f],
       // top-right (duplicate)
-      [-l, d],
+      [-l, f],
       // top-left
-      [-l, -d]
+      [-l, -f]
       // bottom-left (duplicate)
-    ], E = [
+    ], y = [
       [h.uMin, h.vMin],
       // bottom-left
       [h.uMax, h.vMin],
@@ -863,23 +944,23 @@ class de {
       // top-left
       [h.uMin, h.vMin]
       // bottom-left
-    ], A = [];
+    ], E = [];
     for (let u = 0; u < w.length; u++) {
-      const [v, b] = w[u], [_, D] = m(v, b), [U, g] = E[u];
-      A.push({
-        x: t + _,
-        y: r + D,
-        z: s,
-        u: U,
-        v: g,
+      const [m, b] = w[u], [R, B] = x(m, b), [L, v] = y[u];
+      E.push({
+        x: e + R,
+        y: r + B,
+        z: i,
+        u: L,
+        v,
         r: a.r,
         g: a.g,
         b: a.b,
         a: a.a,
-        texIndex: x
+        texIndex: g
       });
     }
-    return A;
+    return E;
   }
   /**
    * Dispose resources
@@ -888,7 +969,203 @@ class de {
     this.vertexBuffer && (this.gl.deleteBuffer(this.vertexBuffer), this.vertexBuffer = null);
   }
 }
-class F {
+class wt {
+  /**
+   * Create a new GPU-based sprite batch renderer (V3)
+   * @param gl WebGL rendering context
+   * @param shader Shader program to use (should be SHADERS_V3)
+   * @param maxQuads Maximum number of quads to batch (default 1000)
+   * @param tileSize Tile size for isometric projection (default {width: 64, height: 32})
+   * @param zScale Scale factor for Z height (default 1.0)
+   */
+  constructor(t, e, r = 1e3, i = { width: 64, height: 32 }, s = 1) {
+    this.vertexBuffer = null, this.quads = [], this.isDirty = !1, this.verticesPerQuad = 6, this.floatsPerVertex = 12, this.texture = null, this.depthTestEnabled = !0, this.gl = t, this.shader = e, this.maxQuads = r, this.tileSize = i, this.zScale = s, this.resolution = { width: t.canvas.width, height: t.canvas.height };
+    const o = r * this.verticesPerQuad * this.floatsPerVertex;
+    this.vertexData = new Float32Array(o);
+    const n = t.createBuffer();
+    if (!n)
+      throw new Error("Failed to create vertex buffer");
+    this.vertexBuffer = n, t.bindBuffer(t.ARRAY_BUFFER, this.vertexBuffer), t.bufferData(t.ARRAY_BUFFER, this.vertexData.byteLength, t.DYNAMIC_DRAW), t.bindBuffer(t.ARRAY_BUFFER, null);
+  }
+  /**
+   * Set the texture for batch rendering
+   * @param texture The texture to use when rendering
+   */
+  setTexture(t) {
+    this.texture = t;
+  }
+  /**
+   * Add a sprite quad to the batch
+   * If gridX and gridY are provided, uses GPU transformation.
+   * Otherwise, converts x, y to grid coordinates.
+   * @param quad Sprite quad instance to add
+   */
+  addQuad(t) {
+    if (this.quads.length >= this.maxQuads) {
+      console.warn(`Sprite batch renderer at max capacity (${this.maxQuads})`);
+      return;
+    }
+    this.quads.push(t), 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 t = 0;
+    for (const e of this.quads) {
+      const {
+        x: r,
+        y: i,
+        z: s = 0,
+        width: o,
+        height: n,
+        color: a = { r: 1, g: 1, b: 1, a: 1 },
+        uvRect: h = { uMin: 0, vMin: 0, uMax: 1, vMax: 1 },
+        texIndex: g = 0,
+        gridX: l,
+        gridY: f
+      } = e;
+      let d, A;
+      l !== void 0 && f !== void 0 ? (d = l, A = f) : (d = (r / (this.tileSize.width * 0.5) + i / (this.tileSize.height * 0.5)) * 0.5, A = (i / (this.tileSize.height * 0.5) - r / (this.tileSize.width * 0.5)) * 0.5);
+      const x = o / 2, w = n / 2, y = [
+        [-x, -w],
+        // bottom-left
+        [x, -w],
+        // bottom-right
+        [x, w],
+        // top-right
+        [x, w],
+        // top-right (duplicate)
+        [-w, w],
+        // top-left
+        [-x, -w]
+        // bottom-left (duplicate)
+      ], E = [
+        [h.uMin, h.vMin],
+        [h.uMax, h.vMin],
+        [h.uMax, h.vMax],
+        [h.uMax, h.vMax],
+        [h.uMin, h.vMax],
+        [h.uMin, h.vMin]
+      ];
+      for (let u = 0; u < y.length; u++) {
+        const [m, b] = y[u], [R, B] = E[u];
+        this.vertexData[t++] = d, this.vertexData[t++] = A, this.vertexData[t++] = s, this.vertexData[t++] = m, this.vertexData[t++] = b, this.vertexData[t++] = R, this.vertexData[t++] = B, this.vertexData[t++] = a.r, this.vertexData[t++] = a.g, this.vertexData[t++] = a.b, this.vertexData[t++] = a.a, this.vertexData[t++] = g;
+      }
+    }
+    this.vertexBuffer && (this.gl.bindBuffer(this.gl.ARRAY_BUFFER, this.vertexBuffer), this.gl.bufferSubData(
+      this.gl.ARRAY_BUFFER,
+      0,
+      this.vertexData.subarray(0, t)
+    ), this.gl.bindBuffer(this.gl.ARRAY_BUFFER, null)), this.isDirty = !1;
+  }
+  /**
+   * Set whether depth testing is enabled
+   * @param enabled Whether to enable depth testing (default true)
+   */
+  setDepthTestEnabled(t) {
+    this.depthTestEnabled = t;
+  }
+  /**
+   * Render the batch with GPU-based transformation
+   * @param camera Camera for view transform
+   */
+  render(t) {
+    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 e = this.floatsPerVertex * 4, r = {
+        gridPosition: this.shader.getAttributeLocation("aGridPosition"),
+        zPosition: this.shader.getAttributeLocation("aZPosition"),
+        localOffset: this.shader.getAttributeLocation("aLocalOffset"),
+        texCoord: this.shader.getAttributeLocation("aTexCoord"),
+        color: this.shader.getAttributeLocation("aColor"),
+        texIndex: this.shader.getAttributeLocation("aTexIndex")
+      };
+      if (r.gridPosition !== -1 && (this.gl.enableVertexAttribArray(r.gridPosition), this.gl.vertexAttribPointer(
+        r.gridPosition,
+        2,
+        this.gl.FLOAT,
+        !1,
+        e,
+        0
+      )), r.zPosition !== -1 && (this.gl.enableVertexAttribArray(r.zPosition), this.gl.vertexAttribPointer(
+        r.zPosition,
+        1,
+        this.gl.FLOAT,
+        !1,
+        e,
+        8
+      )), r.localOffset !== -1 && (this.gl.enableVertexAttribArray(r.localOffset), this.gl.vertexAttribPointer(
+        r.localOffset,
+        2,
+        this.gl.FLOAT,
+        !1,
+        e,
+        12
+      )), r.texCoord !== -1 && (this.gl.enableVertexAttribArray(r.texCoord), this.gl.vertexAttribPointer(
+        r.texCoord,
+        2,
+        this.gl.FLOAT,
+        !1,
+        e,
+        20
+      )), r.color !== -1 && (this.gl.enableVertexAttribArray(r.color), this.gl.vertexAttribPointer(
+        r.color,
+        4,
+        this.gl.FLOAT,
+        !1,
+        e,
+        28
+      )), r.texIndex !== -1 && (this.gl.enableVertexAttribArray(r.texIndex), this.gl.vertexAttribPointer(
+        r.texIndex,
+        1,
+        this.gl.FLOAT,
+        !1,
+        e,
+        44
+      )), this.texture) {
+        this.texture.bind(0);
+        const l = this.shader.getUniformLocation("uTexture");
+        l !== null && this.gl.uniform1i(l, 0);
+      }
+      const i = this.shader.getUniformLocation("uTileSize");
+      i !== null && this.gl.uniform2f(i, this.tileSize.width, this.tileSize.height);
+      const s = this.shader.getUniformLocation("uCamera");
+      s !== null && this.gl.uniform3f(s, t.x, t.y, t.zoom);
+      const o = this.shader.getUniformLocation("uZScale");
+      o !== null && this.gl.uniform1f(o, this.zScale);
+      const n = this.shader.getUniformLocation("uResolution");
+      n !== null && this.gl.uniform2f(n, this.resolution.width, this.resolution.height);
+      const a = this.shader.getUniformLocation("uRotation");
+      a !== null && this.gl.uniform1f(a, 0);
+      const h = this.shader.getUniformLocation("uQuadSize");
+      h !== null && this.gl.uniform2f(h, 1, 1);
+      const g = this.quads.length * this.verticesPerQuad;
+      this.gl.drawArrays(this.gl.TRIANGLES, 0, g), this.gl.bindBuffer(this.gl.ARRAY_BUFFER, null);
+    }
+  }
+  /**
+   * Clean up GPU resources
+   */
+  dispose() {
+    this.vertexBuffer && (this.gl.deleteBuffer(this.vertexBuffer), this.vertexBuffer = null);
+  }
+}
+class D {
   /**
    * Create an identity matrix
    * @returns 4x4 identity matrix in column-major order
@@ -924,7 +1201,7 @@ class F {
    * @param z Translation along Z axis (default 0)
    * @returns 4x4 translation matrix in column-major order
    */
-  static translation(e, t, r = 0) {
+  static translation(t, e, r = 0) {
     return new Float32Array([
       1,
       0,
@@ -941,8 +1218,8 @@ class F {
       1,
       0,
       // column 2
-      e,
       t,
+      e,
       r,
       1
       // column 3
@@ -955,15 +1232,15 @@ class F {
    * @param z Scale factor along Z axis (default 1)
    * @returns 4x4 scale matrix in column-major order
    */
-  static scale(e, t, r = 1) {
+  static scale(t, e, r = 1) {
     return new Float32Array([
-      e,
+      t,
       0,
       0,
       0,
       // column 0
       0,
-      t,
+      e,
       0,
       0,
       // column 1
@@ -985,14 +1262,14 @@ class F {
    * @param b Second matrix (right operand)
    * @returns Result of matrix multiplication in column-major order
    */
-  static multiply(e, t) {
+  static multiply(t, e) {
     const r = new Float32Array(16);
-    for (let s = 0; s < 4; s++)
-      for (let i = 0; i < 4; i++) {
+    for (let i = 0; i < 4; i++)
+      for (let s = 0; s < 4; s++) {
         let o = 0;
         for (let n = 0; n < 4; n++)
-          o += e[n * 4 + i] * t[s * 4 + n];
-        r[s * 4 + i] = o;
+          o += t[n * 4 + s] * e[i * 4 + n];
+        r[i * 4 + s] = o;
       }
     return r;
   }
@@ -1007,20 +1284,20 @@ class F {
    * @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);
+  static createViewMatrix(t, e, r) {
+    const i = D.translation(-t, -e, 0), s = D.scale(r, r, 1);
+    return D.multiply(i, s);
   }
 }
-class fe {
+class vt {
   /**
    * 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;
+  constructor(t = 0, e = 0, r = 1) {
+    this._viewMatrix = null, this._viewMatrixDirty = !0, this._x = t, this._y = e, this._zoom = r;
   }
   /**
    * Get the camera X position
@@ -1031,8 +1308,8 @@ class fe {
   /**
    * Set the camera X position
    */
-  set x(e) {
-    this._x = e, this._viewMatrixDirty = !0;
+  set x(t) {
+    this._x = t, this._viewMatrixDirty = !0;
   }
   /**
    * Get the camera Y position
@@ -1043,8 +1320,8 @@ class fe {
   /**
    * Set the camera Y position
    */
-  set y(e) {
-    this._y = e, this._viewMatrixDirty = !0;
+  set y(t) {
+    this._y = t, this._viewMatrixDirty = !0;
   }
   /**
    * Get the camera zoom level
@@ -1056,31 +1333,31 @@ class fe {
    * 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 zoom(t) {
+    this._zoom = Math.max(1e-3, t), 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;
+  setPosition(t, e) {
+    this._x = t, this._y = e, 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;
+  move(t, e) {
+    this._x += t, this._y += e, 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;
+  zoomBy(t) {
+    this._zoom = Math.max(1e-3, this._zoom * t), this._viewMatrixDirty = !0;
   }
   /**
    * Reset camera to default position and zoom
@@ -1096,7 +1373,7 @@ class fe {
    * @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;
+    return (this._viewMatrixDirty || this._viewMatrix === null) && (this._viewMatrix = D.createViewMatrix(this._x, this._y, this._zoom), this._viewMatrixDirty = !1), this._viewMatrix;
   }
   /**
    * Convert screen coordinates to world coordinates
@@ -1108,8 +1385,8 @@ class fe {
    * @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;
+  screenToWorld(t, e, r, i) {
+    const s = t - r / 2, o = e - i / 2, n = s / this._zoom + this._x, a = o / this._zoom + this._y;
     return { x: n, y: a };
   }
   /**
@@ -1122,19 +1399,25 @@ class fe {
    * @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;
+  worldToScreen(t, e, r, i) {
+    const s = (t - this._x) * this._zoom, o = (e - this._y) * this._zoom, n = s + r / 2, a = o + i / 2;
     return { x: n, y: a };
   }
 }
+class mt {
+  // Scale factor for height (vertical exaggeration)
+  constructor(t = 64, e = 32, r = 1) {
+    this.tileWidth = t, this.tileHeight = e, this.zScale = r;
+  }
+}
 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;
+  constructor(t = "", e = 1e4) {
+    this.baseUrl = t || this.getCurrentOrigin(), this.defaultTimeout = e;
   }
   /**
    * Get the current origin (protocol + host + port)
@@ -1147,11 +1430,11 @@ class J {
    * @param path Relative or absolute path
    * @returns Resolved absolute URL
    */
-  resolvePath(e) {
+  resolvePath(t) {
     try {
-      return e.startsWith("http://") || e.startsWith("https://") ? e : e.startsWith("//") ? window.location.protocol + e : e.startsWith("/") ? this.baseUrl + e : `${this.baseUrl}/${e}`;
+      return t.startsWith("http://") || t.startsWith("https://") ? t : t.startsWith("//") ? window.location.protocol + t : t.startsWith("/") ? this.baseUrl + t : `${this.baseUrl}/${t}`;
     } catch {
-      return e;
+      return t;
     }
   }
   /**
@@ -1160,25 +1443,25 @@ class J {
    * @param options Optional loading configuration
    * @returns Promise resolving to the resource content
    */
-  async load(e, t) {
-    const r = this.resolvePath(e);
+  async load(t, e) {
+    const r = this.resolvePath(t);
     try {
-      const s = {
-        credentials: t?.credentials || "same-origin"
+      const i = {
+        credentials: e?.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);
+      e?.headers && (i.headers = e.headers);
+      const s = new AbortController(), o = setTimeout(() => s.abort(), this.defaultTimeout);
+      i.signal = s.signal;
+      const n = await fetch(r, i);
       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(
+    } catch (i) {
+      throw i instanceof Error ? i.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`);
+      ) : new Error(`Failed to load resource from ${r}: ${i.message}`) : new Error(`Failed to load resource from ${r}: Unknown error`);
     }
   }
   /**
@@ -1187,20 +1470,20 @@ class J {
    * @param options Optional loading configuration
    * @returns Promise resolving to array of load results
    */
-  async loadMultiple(e, t) {
-    const r = e.map(async (s) => {
+  async loadMultiple(t, e) {
+    const r = t.map(async (i) => {
       try {
         return {
-          data: await this.load(s, t),
-          path: s,
+          data: await this.load(i, e),
+          path: i,
           success: !0
         };
-      } catch (i) {
+      } catch (s) {
         return {
           data: "",
-          path: s,
+          path: i,
           success: !1,
-          error: i instanceof Error ? i.message : String(i)
+          error: s instanceof Error ? s.message : String(s)
         };
       }
     });
@@ -1211,8 +1494,8 @@ class J {
    * @param path URL or path to check
    * @returns true if the path can be loaded
    */
-  canLoad(e) {
-    const t = [
+  canLoad(t) {
+    const e = [
       /^https?:\/\//i,
       // Absolute HTTP(S) URLs
       /^\/\//,
@@ -1221,15 +1504,15 @@ class J {
       // Absolute paths
       /^\.\.?\//
       // Relative paths starting with ./ or ../
-    ], r = /\.[a-z0-9]+$/i.test(e);
-    return t.some((s) => s.test(e)) || r;
+    ], r = /\.[a-z0-9]+$/i.test(t);
+    return e.some((i) => i.test(t)) || r;
   }
   /**
    * Set a new base URL for resolving relative paths
    * @param baseUrl New base URL
    */
-  setBaseUrl(e) {
-    this.baseUrl = e;
+  setBaseUrl(t) {
+    this.baseUrl = t;
   }
   /**
    * Get the current base URL
@@ -1242,29 +1525,29 @@ class J {
    * Set the default request timeout
    * @param timeout Timeout in milliseconds
    */
-  setTimeout(e) {
-    this.defaultTimeout = e;
+  setTimeout(t) {
+    this.defaultTimeout = t;
   }
 }
-const Z = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+const tt = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
   BrowserResourceLoader: J
 }, Symbol.toStringTag, { value: "Module" }));
-class ee {
+class et {
   /**
    * 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;
+  constructor(t = process.cwd()) {
+    this.baseDir = t;
   }
   /**
    * 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));
+  resolvePath(t) {
+    return C.isAbsolute(t) ? C.normalize(t) : C.normalize(C.join(this.baseDir, t));
   }
   /**
    * Load a single resource from a file
@@ -1272,21 +1555,21 @@ class ee {
    * @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";
+  async load(t, e) {
+    const r = this.resolvePath(t), i = e?.encoding || "utf-8";
     try {
-      return await p.readFile(r, s);
-    } catch (i) {
-      if (i instanceof Error) {
-        const o = i.code;
+      return await p.readFile(r, i);
+    } catch (s) {
+      if (s instanceof Error) {
+        const o = s.code;
         throw o === "ENOENT" ? new Error(
-          `File not found: ${r} (resolved from: ${e})`
+          `File not found: ${r} (resolved from: ${t})`
         ) : 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}`
+          `Failed to load resource from ${r}: ${s.message}`
         );
       }
       throw new Error(
@@ -1300,20 +1583,20 @@ class ee {
    * @param options Optional loading configuration
    * @returns Promise resolving to array of load results
    */
-  async loadMultiple(e, t) {
-    const r = e.map(async (s) => {
+  async loadMultiple(t, e) {
+    const r = t.map(async (i) => {
       try {
         return {
-          data: await this.load(s, t),
-          path: s,
+          data: await this.load(i, e),
+          path: i,
           success: !0
         };
-      } catch (i) {
+      } catch (s) {
         return {
           data: "",
-          path: s,
+          path: i,
           success: !1,
-          error: i instanceof Error ? i.message : String(i)
+          error: s instanceof Error ? s.message : String(s)
         };
       }
     });
@@ -1324,7 +1607,7 @@ class ee {
    * @param filePath File path to check
    * @returns true if the path can be loaded
    */
-  canLoad(e) {
+  canLoad(t) {
     return [
       /^\//,
       // Unix absolute paths
@@ -1334,17 +1617,17 @@ class ee {
       // Relative paths starting with ./ or ../
       /^[^/\\]+\//
       // Relative paths without explicit prefix (e.g., "shaders/")
-    ].some((r) => r.test(e));
+    ].some((r) => r.test(t));
   }
   /**
    * 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);
+  async exists(t) {
+    const e = this.resolvePath(t);
     try {
-      return await p.access(t, p.constants.F_OK), !0;
+      return await p.access(e, p.constants.F_OK), !0;
     } catch {
       return !1;
     }
@@ -1354,16 +1637,16 @@ class ee {
    * @param filePath File path to check
    * @returns Promise resolving to file stats
    */
-  async getStats(e) {
-    const t = this.resolvePath(e);
-    return p.stat(t);
+  async getStats(t) {
+    const e = this.resolvePath(t);
+    return p.stat(e);
   }
   /**
    * Set a new base directory for resolving relative paths
    * @param baseDir New base directory
    */
-  setBaseDir(e) {
-    this.baseDir = e;
+  setBaseDir(t) {
+    this.baseDir = t;
   }
   /**
    * Get the current base directory
@@ -1378,24 +1661,24 @@ class ee {
    * @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 p.readdir(r, { withFileTypes: !0 }), i = [];
-    for (const o of s) {
-      const n = T.join(r, o.name);
-      if (o.isDirectory() && t) {
+  async listDirectory(t, e = !1) {
+    const r = this.resolvePath(t), i = await p.readdir(r, { withFileTypes: !0 }), s = [];
+    for (const o of i) {
+      const n = C.join(r, o.name);
+      if (o.isDirectory() && e) {
         const a = await this.listDirectory(n, !0);
-        i.push(...a);
-      } else o.isFile() && i.push(n);
+        s.push(...a);
+      } else o.isFile() && s.push(n);
     }
-    return i;
+    return s;
   }
 }
-const te = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+const rt = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
-  NodeResourceLoader: ee
+  NodeResourceLoader: et
 }, Symbol.toStringTag, { value: "Module" }));
 var I = /* @__PURE__ */ ((c) => (c.BROWSER = "browser", c.NODE = "node", c.UNKNOWN = "unknown", c))(I || {});
-class N {
+class Y {
   /**
    * Detect the current runtime environment
    * @returns The detected environment type
@@ -1423,19 +1706,19 @@ class N {
    * @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) {
+  static async create(t) {
+    const e = t?.forceEnvironment || this.detectEnvironment();
+    switch (e) {
       case "browser":
-        return await this.createBrowserLoader(e);
+        return await this.createBrowserLoader(t);
       case "node":
-        return await this.createNodeLoader(e);
+        return await this.createNodeLoader(t);
       case "unknown":
         throw new Error(
           "Unsupported environment: Unable to determine runtime environment. Please specify forceEnvironment in options."
         );
       default:
-        throw new Error(`Unsupported environment: ${t}`);
+        throw new Error(`Unsupported environment: ${e}`);
     }
   }
   /**
@@ -1443,18 +1726,18 @@ class N {
    * @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);
+  static async createBrowserLoader(t) {
+    const { BrowserResourceLoader: e } = await Promise.resolve().then(() => tt);
+    return new e(t?.baseUrl, t?.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);
+  static async createNodeLoader(t) {
+    const { NodeResourceLoader: e } = await Promise.resolve().then(() => rt);
+    return new e(t?.baseDir);
   }
   /**
    * Create a resource loader with automatic fallback
@@ -1463,36 +1746,36 @@ class N {
    * @param options Optional factory configuration
    * @returns A resource loader instance
    */
-  static async createWithFallback(e, t) {
+  static async createWithFallback(t, e) {
     try {
-      return t = { ...t, forceEnvironment: e }, await this.create(t);
+      return e = { ...e, forceEnvironment: t }, await this.create(e);
     } catch {
-      return await this.create({ ...t, forceEnvironment: void 0 });
+      return await this.create({ ...e, forceEnvironment: void 0 });
     }
   }
 }
-async function re(c) {
-  return await N.create(c);
+async function it(c) {
+  return await Y.create(c);
 }
-const se = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+const st = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
   Environment: I,
-  ResourceLoaderFactory: N,
-  createResourceLoader: re
+  ResourceLoaderFactory: Y,
+  createResourceLoader: it
 }, Symbol.toStringTag, { value: "Module" }));
-class ie {
-  constructor(e = !0) {
-    this.cache = /* @__PURE__ */ new Map(), this.enabled = e;
+class ot {
+  constructor(t = !0) {
+    this.cache = /* @__PURE__ */ new Map(), this.enabled = t;
   }
-  get(e) {
+  get(t) {
     if (this.enabled)
-      return this.cache.get(e);
+      return this.cache.get(t);
   }
-  set(e, t) {
-    this.enabled && this.cache.set(e, t);
+  set(t, e) {
+    this.enabled && this.cache.set(t, e);
   }
-  has(e) {
-    return this.enabled ? this.cache.has(e) : !1;
+  has(t) {
+    return this.enabled ? this.cache.has(t) : !1;
   }
   clear() {
     this.cache.clear();
@@ -1507,14 +1790,14 @@ class ie {
     this.enabled = !1;
   }
 }
-class oe {
+class nt {
   /**
    * 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);
+  constructor(t, e) {
+    this.loader = t, this.concurrency = e?.concurrency ?? 10, this.cache = new ot(e?.cache ?? !0);
   }
   /**
    * Load a single resource with caching support
@@ -1522,12 +1805,12 @@ class oe {
    * @param options Optional loading options
    * @returns Promise resolving to the resource content
    */
-  async load(e, t) {
-    const r = this.cache.get(e);
+  async load(t, e) {
+    const r = this.cache.get(t);
     if (r !== void 0)
       return r;
-    const s = await this.loader.load(e, t);
-    return this.cache.set(e, s), s;
+    const i = await this.loader.load(t, e);
+    return this.cache.set(t, i), i;
   }
   /**
    * Load multiple resources with concurrency control
@@ -1535,19 +1818,19 @@ class oe {
    * @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);
+  async loadBatch(t, e) {
+    const r = /* @__PURE__ */ new Map(), i = /* @__PURE__ */ new Map();
+    for (let s = 0; s < t.length; s += this.concurrency) {
+      const o = t.slice(s, s + this.concurrency), n = await this.loader.loadMultiple(o, e);
       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");
+        a.success ? (r.set(a.path, a.data), this.cache.set(a.path, a.data)) : i.set(a.path, a.error || "Unknown error");
     }
     return {
       succeeded: r,
-      failed: s,
-      total: e.length,
+      failed: i,
+      total: t.length,
       successCount: r.size,
-      failureCount: s.size
+      failureCount: i.size
     };
   }
   /**
@@ -1557,12 +1840,12 @@ class oe {
    * @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)
+  async loadShader(t, e, r) {
+    const [i, s] = await Promise.all([
+      this.load(t, r),
+      this.load(e, r)
     ]);
-    return { vertex: s, fragment: i };
+    return { vertex: i, fragment: s };
   }
   /**
    * Load multiple shaders
@@ -1570,17 +1853,17 @@ class oe {
    * @param options Optional loading options
    * @returns Promise resolving to array of named shader sources
    */
-  async loadShaders(e, t) {
+  async loadShaders(t, e) {
     return await Promise.all(
-      e.map(async (s) => {
-        const i = await this.loadShader(
-          s.vertex,
-          s.fragment,
-          t
+      t.map(async (i) => {
+        const s = await this.loadShader(
+          i.vertex,
+          i.fragment,
+          e
         );
         return {
-          name: s.name,
-          ...i
+          name: i.name,
+          ...s
         };
       })
     );
@@ -1591,9 +1874,9 @@ class oe {
    * @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);
+  async loadFromManifest(t, e) {
+    const r = await this.load(t, e), i = JSON.parse(r);
+    return this.loadBatch(i.resources, e);
   }
   /**
    * Preload resources for faster access later
@@ -1601,24 +1884,24 @@ class oe {
    * @param options Optional loading options
    * @returns Promise resolving when all resources are loaded
    */
-  async preload(e, t) {
-    await this.loadBatch(e, t);
+  async preload(t, e) {
+    await this.loadBatch(t, e);
   }
   /**
    * 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);
+  isCached(t) {
+    return this.cache.has(t);
   }
   /**
    * 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);
+  getCached(t) {
+    return this.cache.get(t);
   }
   /**
    * Clear the resource cache
@@ -1649,8 +1932,8 @@ class oe {
    * Set the maximum concurrency for batch operations
    * @param concurrency Maximum concurrent loads
    */
-  setConcurrency(e) {
-    this.concurrency = Math.max(1, e);
+  setConcurrency(t) {
+    this.concurrency = Math.max(1, t);
   }
   /**
    * Get the underlying resource loader
@@ -1660,18 +1943,18 @@ class oe {
     return this.loader;
   }
 }
-async function ne(c) {
-  const { ResourceLoaderFactory: e } = await Promise.resolve().then(() => se), t = await e.create({
+async function at(c) {
+  const { ResourceLoaderFactory: t } = await Promise.resolve().then(() => st), e = await t.create({
     baseUrl: c?.baseUrl,
     baseDir: c?.baseDir,
     timeout: c?.timeout
   });
-  return new oe(t, c);
+  return new nt(e, c);
 }
-const L = {
+const P = {
   width: 800,
   height: 600
-}, P = {
+}, U = {
   quad: {
     vertices: new Float32Array([
       // Position               TexCoord
@@ -1738,17 +2021,17 @@ const L = {
     "resources/shaders/glow.frag"
   ]
 };
-async function ge() {
+async function bt() {
   console.log("🩸 Bloody Engine - Resource Loader Demo"), console.log(`==========================================
 `);
-  const c = N.detectEnvironment();
+  const c = Y.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({
+  const t = await at({
     concurrency: 5,
     cache: !0,
     timeout: 1e4,
@@ -1756,35 +2039,35 @@ async function ge() {
   });
   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) {
+  const e = await t.loadBatch(M.resources);
+  if (console.log("✓ Batch loading complete"), console.log(`  - Succeeded: ${e.successCount}`), console.log(`  - Failed: ${e.failureCount}`), e.failureCount > 0) {
     console.log(`
 ❌ Failed resources:`);
-    for (const [g, C] of t.failed)
-      console.log(`  - ${g}: ${C}`);
+    for (const [v, T] of e.failed)
+      console.log(`  - ${v}: ${T}`);
     console.log(`
 ⚠️ Falling back to inline shaders...`);
   }
   console.log(`
 3. Loading Shaders...`);
-  const r = await e.loadShaders(M.shaders);
+  const r = await t.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`);
+  for (const v of r)
+    console.log(`  - ${v.name}:`), console.log(`    Vertex: ${v.vertex.length} chars`), console.log(`    Fragment: ${v.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 C = e.isCached(g.vertex), $ = e.isCached(g.fragment);
-    console.log(`  - ${g.name}:`), console.log(`    Vertex cached: ${C}`), console.log(`    Fragment cached: ${$}`);
+  const i = t.getCacheSize();
+  console.log(`✓ Cache contains ${i} resources`);
+  for (const v of M.shaders) {
+    const T = t.isCached(v.vertex), z = t.isCached(v.fragment);
+    console.log(`  - ${v.name}:`), console.log(`    Vertex cached: ${T}`), console.log(`    Fragment cached: ${z}`);
   }
   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(`
+  const s = new k(P.width, P.height), o = s.getGLContext();
+  console.log("✓ Graphics device initialized"), console.log(`  - Resolution: ${P.width}x${P.height}`), console.log(`
 6. Creating Shader from Loaded Source...`);
-  let n = r.find((g) => g.name === "glow");
+  let n = r.find((v) => v.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;
@@ -1817,77 +2100,77 @@ void main() {
   gl_FragColor = vec4(glowColor, texColor.a);
 }`
   });
-  const a = i.createShader(n.vertex, n.fragment);
+  const a = s.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(
+  const h = _.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(
+  const { VertexBuffer: g } = await Promise.resolve().then(() => Z), l = new g(
     o,
-    P.quad.vertices,
-    P.quad.stride
+    U.quad.vertices,
+    U.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"), w = 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,
+  const f = a.getAttributeLocation("aPosition"), d = a.getAttributeLocation("aTexCoord"), A = a.getUniformLocation("uTexture"), x = a.getUniformLocation("uMatrix"), w = a.getUniformLocation("uColor"), y = a.getUniformLocation("uGlowIntensity");
+  l.bind(), o.enableVertexAttribArray(f), o.vertexAttribPointer(f, 3, o.FLOAT, !1, U.quad.stride, 0), o.enableVertexAttribArray(d), o.vertexAttribPointer(
+    d,
     2,
     o.FLOAT,
     !1,
-    P.quad.stride,
+    U.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;
+  ), console.log("✓ Vertex attributes configured"), h.bind(0), o.uniform1i(A, 0), console.log("✓ Texture bound to unit 0");
+  const u = s.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 v = document.createElement("h1");
-  v.textContent = "🩸 Resource Loader Demo", v.style.textAlign = "center", v.style.color = "#fff", u && u.parentNode ? u.parentNode.insertBefore(v, u) : document.body.insertBefore(v, document.body.firstChild);
+  const m = document.createElement("h1");
+  m.textContent = "🩸 Resource Loader Demo", m.style.textAlign = "center", m.style.color = "#fff", u && u.parentNode ? u.parentNode.insertBefore(m, u) : document.body.insertBefore(m, 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>
+    <div>Cached resources: <strong>${i}</strong></div>
   `, document.body.appendChild(b);
-  let _ = 0;
-  const D = Date.now();
-  function U() {
-    const g = Date.now(), C = (g - D) / 1e3;
-    i.clear({ r: 0.1, g: 0.1, b: 0.1, a: 1 });
-    const $ = [
+  let R = 0;
+  const B = Date.now();
+  function L() {
+    const v = Date.now(), T = (v - B) / 1e3;
+    s.clear({ r: 0.1, g: 0.1, b: 0.1, a: 1 });
+    const z = [
       { 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 = ae();
-      if (ce(z, R.x, R.y, 0), he(z, 0.4, 0.4, 1), m && o.uniformMatrix4fv(m, !1, z), w && o.uniform3f(
+    for (const F of z) {
+      const $ = ht();
+      if (ct($, F.x, F.y, 0), lt($, 0.4, 0.4, 1), x && o.uniformMatrix4fv(x, !1, $), w && o.uniform3f(
         w,
-        R.color[0],
-        R.color[1],
-        R.color[2]
-      ), E) {
-        const q = R.glow + Math.sin(C * 2) * 0.3;
-        o.uniform1f(E, q);
+        F.color[0],
+        F.color[1],
+        F.color[2]
+      ), y) {
+        const G = F.glow + Math.sin(T * 2) * 0.3;
+        o.uniform1f(y, G);
       }
       o.drawArrays(o.TRIANGLES, 0, l.getVertexCount());
     }
-    i.present(), _++;
-    const V = (g - D) / 1e3, O = _ / V;
+    s.present(), R++;
+    const V = (v - B) / 1e3, N = R / 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);
+      <div>FPS: <strong>${N.toFixed(1)}</strong> | Frame: <strong>${R}</strong> | Elapsed: <strong>${V.toFixed(2)}s</strong></div>
+      <div>Environment: <strong>${c}</strong> | Shaders loaded: <strong>${r.length}</strong> | Cached: <strong>${i}</strong></div>
+    `, requestAnimationFrame(L);
   }
   console.log(`
-✓ Demo started! Rendering animation...`), U();
+✓ Demo started! Rendering animation...`), L();
 }
-function ae() {
+function ht() {
   return new Float32Array([
     1,
     0,
@@ -1907,31 +2190,34 @@ function ae() {
     1
   ]);
 }
-function ce(c, e, t, r) {
-  c[12] += e, c[13] += t, c[14] += r;
+function ct(c, t, e, r) {
+  c[12] += t, c[13] += e, c[14] += r;
 }
-function he(c, e, t, r) {
-  c[0] *= e, c[5] *= t, c[10] *= r;
+function lt(c, t, e, r) {
+  c[0] *= t, c[5] *= e, c[10] *= r;
 }
 export {
-  ue as BatchRenderer,
-  Y as BrowserRenderingContext,
+  gt as BatchRenderer,
+  O as BrowserRenderingContext,
   J as BrowserResourceLoader,
-  fe as Camera,
+  vt 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,
+  wt as GPUBasedSpriteBatchRenderer,
+  k as GraphicsDevice,
+  K as IndexBuffer,
+  D as Matrix4,
+  q as NodeRenderingContext,
+  et as NodeResourceLoader,
+  mt as ProjectionConfig,
+  X as RenderingContextFactory,
+  Y as ResourceLoaderFactory,
+  nt as ResourcePipeline,
+  ft as SDLWindow,
   H as Shader,
-  de as SpriteBatchRenderer,
-  B as Texture,
-  Q as VertexBuffer,
-  re as createResourceLoader,
-  ne as createResourcePipeline,
-  ge as runBrowserResourceLoaderDemo
+  xt as SpriteBatchRenderer,
+  _ as Texture,
+  j as VertexBuffer,
+  it as createResourceLoader,
+  at as createResourcePipeline,
+  bt as runBrowserResourceLoaderDemo
 };