bloody-engine 1.0.4 → 1.0.5

package/dist/node/index.js

@@ -1,4 +1,5 @@
 import createGL from "gl";
+import sdl from "@kmamal/sdl";
 import * as fs from "fs/promises";
 import * as path from "path";
 class BrowserRenderingContext {
@@ -365,6 +366,99 @@ class GraphicsDevice {
     );
   }
 }
+class SDLWindow {
+  constructor(width, height, title = "Bloody Engine") {
+    this.closed = false;
+    this.width = width;
+    this.height = height;
+    this.title = title;
+    try {
+      this.window = sdl.video.createWindow({
+        width: this.width,
+        height: this.height,
+        title: this.title
+      });
+      if (!this.window) {
+        throw new Error("Failed to create SDL window");
+      }
+      this.window.on("close", () => {
+        this.closed = true;
+      });
+      console.log(`✓ SDL Window created (${width}x${height}): "${title}"`);
+    } catch (error) {
+      this.cleanup();
+      throw new Error(`Window creation failed: ${error}`);
+    }
+  }
+  /**
+   * 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(pixels) {
+    if (!this.window || this.closed) {
+      return;
+    }
+    try {
+      const buffer2 = Buffer.from(pixels);
+      const stride = this.width * 4;
+      this.window.render(this.width, this.height, stride, "rgba32", buffer2);
+    } catch (error) {
+      console.error("Failed to update pixels:", error);
+    }
+  }
+  /**
+   * Register an event handler
+   */
+  on(eventName, handler) {
+    if (!this.window || this.closed) {
+      return;
+    }
+    try {
+      this.window.on(eventName, (event) => {
+        try {
+          handler(event);
+        } catch (error) {
+          console.error(`Error in ${eventName} handler:`, error);
+        }
+      });
+    } catch (error) {
+      console.error(`Error registering ${eventName} handler:`, error);
+    }
+  }
+  /**
+   * 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 (error) {
+        console.warn("Error destroying window:", error);
+      }
+      this.window = null;
+      this.closed = true;
+    }
+    console.log("✓ SDL Window cleaned up");
+  }
+  /**
+   * Destroy the window (alias for cleanup)
+   */
+  destroy() {
+    this.cleanup();
+  }
+}
 class Texture {
   /**
    * Create a texture from pixel data
@@ -1132,6 +1226,301 @@ class SpriteBatchRenderer {
     }
   }
 }
+class GPUBasedSpriteBatchRenderer {
+  /**
+   * 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(gl, shader, maxQuads = 1e3, tileSize = { width: 64, height: 32 }, zScale = 1) {
+    this.vertexBuffer = null;
+    this.quads = [];
+    this.isDirty = false;
+    this.verticesPerQuad = 6;
+    this.floatsPerVertex = 12;
+    this.texture = null;
+    this.depthTestEnabled = true;
+    this.gl = gl;
+    this.shader = shader;
+    this.maxQuads = maxQuads;
+    this.tileSize = tileSize;
+    this.zScale = zScale;
+    this.resolution = { width: gl.canvas.width, height: gl.canvas.height };
+    const totalFloats = maxQuads * this.verticesPerQuad * this.floatsPerVertex;
+    this.vertexData = new Float32Array(totalFloats);
+    const buf = gl.createBuffer();
+    if (!buf) {
+      throw new Error("Failed to create vertex buffer");
+    }
+    this.vertexBuffer = buf;
+    gl.bindBuffer(gl.ARRAY_BUFFER, this.vertexBuffer);
+    gl.bufferData(gl.ARRAY_BUFFER, this.vertexData.byteLength, gl.DYNAMIC_DRAW);
+    gl.bindBuffer(gl.ARRAY_BUFFER, null);
+  }
+  /**
+   * Set the texture for batch rendering
+   * @param texture The texture to use when rendering
+   */
+  setTexture(texture) {
+    this.texture = texture;
+  }
+  /**
+   * Add a sprite quad to the batch
+   * If gridX and gridY are provided, uses GPU transformation.
+   * Otherwise, converts x, y to grid coordinates.
+   * @param quad Sprite quad instance to add
+   */
+  addQuad(quad) {
+    if (this.quads.length >= this.maxQuads) {
+      console.warn(`Sprite batch renderer at max capacity (${this.maxQuads})`);
+      return;
+    }
+    this.quads.push(quad);
+    this.isDirty = true;
+  }
+  /**
+   * Clear all quads from the batch
+   */
+  clear() {
+    this.quads = [];
+    this.isDirty = true;
+  }
+  /**
+   * Get number of quads currently in batch
+   */
+  getQuadCount() {
+    return this.quads.length;
+  }
+  /**
+   * Update the batch - rebuilds vertex buffer if quads changed
+   */
+  update() {
+    if (!this.isDirty || this.quads.length === 0) {
+      return;
+    }
+    let vertexIndex = 0;
+    for (const quad of this.quads) {
+      const {
+        x,
+        y,
+        z = 0,
+        width,
+        height,
+        color = { r: 1, g: 1, b: 1, a: 1 },
+        uvRect = { uMin: 0, vMin: 0, uMax: 1, vMax: 1 },
+        texIndex = 0,
+        gridX,
+        gridY
+      } = quad;
+      let gx, gy;
+      if (gridX !== void 0 && gridY !== void 0) {
+        gx = gridX;
+        gy = gridY;
+      } else {
+        gx = (x / (this.tileSize.width * 0.5) + y / (this.tileSize.height * 0.5)) * 0.5;
+        gy = (y / (this.tileSize.height * 0.5) - x / (this.tileSize.width * 0.5)) * 0.5;
+      }
+      const halfW = width / 2;
+      const halfH = height / 2;
+      const corners = [
+        [-halfW, -halfH],
+        // bottom-left
+        [halfW, -halfH],
+        // bottom-right
+        [halfW, halfH],
+        // top-right
+        [halfW, halfH],
+        // top-right (duplicate)
+        [-halfH, halfH],
+        // top-left
+        [-halfW, -halfH]
+        // bottom-left (duplicate)
+      ];
+      const texCoords = [
+        [uvRect.uMin, uvRect.vMin],
+        [uvRect.uMax, uvRect.vMin],
+        [uvRect.uMax, uvRect.vMax],
+        [uvRect.uMax, uvRect.vMax],
+        [uvRect.uMin, uvRect.vMax],
+        [uvRect.uMin, uvRect.vMin]
+      ];
+      for (let i = 0; i < corners.length; i++) {
+        const [localX, localY] = corners[i];
+        const [u, v] = texCoords[i];
+        this.vertexData[vertexIndex++] = gx;
+        this.vertexData[vertexIndex++] = gy;
+        this.vertexData[vertexIndex++] = z;
+        this.vertexData[vertexIndex++] = localX;
+        this.vertexData[vertexIndex++] = localY;
+        this.vertexData[vertexIndex++] = u;
+        this.vertexData[vertexIndex++] = v;
+        this.vertexData[vertexIndex++] = color.r;
+        this.vertexData[vertexIndex++] = color.g;
+        this.vertexData[vertexIndex++] = color.b;
+        this.vertexData[vertexIndex++] = color.a;
+        this.vertexData[vertexIndex++] = texIndex;
+      }
+    }
+    if (this.vertexBuffer) {
+      this.gl.bindBuffer(this.gl.ARRAY_BUFFER, this.vertexBuffer);
+      this.gl.bufferSubData(
+        this.gl.ARRAY_BUFFER,
+        0,
+        this.vertexData.subarray(0, vertexIndex)
+      );
+      this.gl.bindBuffer(this.gl.ARRAY_BUFFER, null);
+    }
+    this.isDirty = false;
+  }
+  /**
+   * Set whether depth testing is enabled
+   * @param enabled Whether to enable depth testing (default true)
+   */
+  setDepthTestEnabled(enabled) {
+    this.depthTestEnabled = enabled;
+  }
+  /**
+   * Render the batch with GPU-based transformation
+   * @param camera Camera for view transform
+   */
+  render(camera) {
+    if (this.quads.length === 0) {
+      return;
+    }
+    this.update();
+    this.shader.use();
+    if (this.depthTestEnabled) {
+      this.gl.enable(this.gl.DEPTH_TEST);
+      this.gl.depthFunc(this.gl.LEQUAL);
+    } else {
+      this.gl.disable(this.gl.DEPTH_TEST);
+    }
+    if (this.vertexBuffer) {
+      this.gl.bindBuffer(this.gl.ARRAY_BUFFER, this.vertexBuffer);
+      const stride = this.floatsPerVertex * 4;
+      const attrs = {
+        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 (attrs.gridPosition !== -1) {
+        this.gl.enableVertexAttribArray(attrs.gridPosition);
+        this.gl.vertexAttribPointer(
+          attrs.gridPosition,
+          2,
+          this.gl.FLOAT,
+          false,
+          stride,
+          0
+        );
+      }
+      if (attrs.zPosition !== -1) {
+        this.gl.enableVertexAttribArray(attrs.zPosition);
+        this.gl.vertexAttribPointer(
+          attrs.zPosition,
+          1,
+          this.gl.FLOAT,
+          false,
+          stride,
+          2 * 4
+        );
+      }
+      if (attrs.localOffset !== -1) {
+        this.gl.enableVertexAttribArray(attrs.localOffset);
+        this.gl.vertexAttribPointer(
+          attrs.localOffset,
+          2,
+          this.gl.FLOAT,
+          false,
+          stride,
+          3 * 4
+        );
+      }
+      if (attrs.texCoord !== -1) {
+        this.gl.enableVertexAttribArray(attrs.texCoord);
+        this.gl.vertexAttribPointer(
+          attrs.texCoord,
+          2,
+          this.gl.FLOAT,
+          false,
+          stride,
+          5 * 4
+        );
+      }
+      if (attrs.color !== -1) {
+        this.gl.enableVertexAttribArray(attrs.color);
+        this.gl.vertexAttribPointer(
+          attrs.color,
+          4,
+          this.gl.FLOAT,
+          false,
+          stride,
+          7 * 4
+        );
+      }
+      if (attrs.texIndex !== -1) {
+        this.gl.enableVertexAttribArray(attrs.texIndex);
+        this.gl.vertexAttribPointer(
+          attrs.texIndex,
+          1,
+          this.gl.FLOAT,
+          false,
+          stride,
+          11 * 4
+        );
+      }
+      if (this.texture) {
+        this.texture.bind(0);
+        const textureUniform = this.shader.getUniformLocation("uTexture");
+        if (textureUniform !== null) {
+          this.gl.uniform1i(textureUniform, 0);
+        }
+      }
+      const tileSizeUniform = this.shader.getUniformLocation("uTileSize");
+      if (tileSizeUniform !== null) {
+        this.gl.uniform2f(tileSizeUniform, this.tileSize.width, this.tileSize.height);
+      }
+      const cameraUniform = this.shader.getUniformLocation("uCamera");
+      if (cameraUniform !== null) {
+        this.gl.uniform3f(cameraUniform, camera.x, camera.y, camera.zoom);
+      }
+      const zScaleUniform = this.shader.getUniformLocation("uZScale");
+      if (zScaleUniform !== null) {
+        this.gl.uniform1f(zScaleUniform, this.zScale);
+      }
+      const resolutionUniform = this.shader.getUniformLocation("uResolution");
+      if (resolutionUniform !== null) {
+        this.gl.uniform2f(resolutionUniform, this.resolution.width, this.resolution.height);
+      }
+      const rotationUniform = this.shader.getUniformLocation("uRotation");
+      if (rotationUniform !== null) {
+        this.gl.uniform1f(rotationUniform, 0);
+      }
+      const quadSizeUniform = this.shader.getUniformLocation("uQuadSize");
+      if (quadSizeUniform !== null) {
+        this.gl.uniform2f(quadSizeUniform, 1, 1);
+      }
+      const vertexCount = this.quads.length * this.verticesPerQuad;
+      this.gl.drawArrays(this.gl.TRIANGLES, 0, vertexCount);
+      this.gl.bindBuffer(this.gl.ARRAY_BUFFER, null);
+    }
+  }
+  /**
+   * Clean up GPU resources
+   */
+  dispose() {
+    if (this.vertexBuffer) {
+      this.gl.deleteBuffer(this.vertexBuffer);
+      this.vertexBuffer = null;
+    }
+  }
+}
 class Matrix4 {
   /**
    * Create an identity matrix
@@ -1399,6 +1788,14 @@ class Camera {
     return { x: screenX, y: screenY };
   }
 }
+class ProjectionConfig {
+  // Scale factor for height (vertical exaggeration)
+  constructor(tileWidth = 64, tileHeight = 32, zScale = 1) {
+    this.tileWidth = tileWidth;
+    this.tileHeight = tileHeight;
+    this.zScale = zScale;
+  }
+}
 class BrowserResourceLoader {
   /**
    * Create a new browser resource loader
@@ -2341,14 +2738,17 @@ export {
   BrowserResourceLoader,
   Camera,
   Environment,
+  GPUBasedSpriteBatchRenderer,
   GraphicsDevice,
   IndexBuffer,
   Matrix4,
   NodeRenderingContext,
   NodeResourceLoader,
+  ProjectionConfig,
   RenderingContextFactory,
   ResourceLoaderFactory,
   ResourcePipeline,
+  SDLWindow,
   Shader,
   SpriteBatchRenderer,
   Texture,