bloody-engine 1.0.2 → 1.0.4

package/dist/web/rendering/camera.d.ts

@@ -0,0 +1,153 @@
+/**
+ * Camera System for 2D/2.5D Rendering
+ *
+ * Provides camera positioning (x, y), zoom control, and view matrix generation
+ * for offsetting global rendering position.
+ */
+/**
+ * Matrix4 utilities for 2D camera transformations
+ * Matrices are stored in column-major order (WebGL convention)
+ */
+export declare class Matrix4 {
+    /**
+     * Create an identity matrix
+     * @returns 4x4 identity matrix in column-major order
+     */
+    static identity(): Float32Array;
+    /**
+     * Create a translation matrix
+     * @param x Translation along X axis
+     * @param y Translation along Y axis
+     * @param z Translation along Z axis (default 0)
+     * @returns 4x4 translation matrix in column-major order
+     */
+    static translation(x: number, y: number, z?: number): Float32Array;
+    /**
+     * Create a scale matrix
+     * @param x Scale factor along X axis
+     * @param y Scale factor along Y axis
+     * @param z Scale factor along Z axis (default 1)
+     * @returns 4x4 scale matrix in column-major order
+     */
+    static scale(x: number, y: number, z?: number): Float32Array;
+    /**
+     * Multiply two matrices (result = a * b)
+     * @param a First matrix (left operand)
+     * @param b Second matrix (right operand)
+     * @returns Result of matrix multiplication in column-major order
+     */
+    static multiply(a: Float32Array, b: Float32Array): Float32Array;
+    /**
+     * Create a view matrix from camera position and zoom
+     * The view matrix transforms world coordinates to camera/eye coordinates
+     *
+     * View = Translation(-cameraX, -cameraY, 0) * Scale(zoom, zoom, 1)
+     *
+     * @param x Camera X position (translation will be negative)
+     * @param y Camera Y position (translation will be negative)
+     * @param zoom Camera zoom level (1.0 = no zoom, >1 = zoom in, <1 = zoom out)
+     * @returns 4x4 view matrix in column-major order
+     */
+    static createViewMatrix(x: number, y: number, zoom: number): Float32Array;
+}
+/**
+ * Camera for 2D/2.5D rendering
+ * Controls the viewport position and zoom level
+ */
+export declare class Camera {
+    private _x;
+    private _y;
+    private _zoom;
+    private _viewMatrix;
+    private _viewMatrixDirty;
+    /**
+     * Create a new camera
+     * @param x Initial X position (default 0)
+     * @param y Initial Y position (default 0)
+     * @param zoom Initial zoom level (default 1.0)
+     */
+    constructor(x?: number, y?: number, zoom?: number);
+    /**
+     * Get the camera X position
+     */
+    get x(): number;
+    /**
+     * Set the camera X position
+     */
+    set x(value: number);
+    /**
+     * Get the camera Y position
+     */
+    get y(): number;
+    /**
+     * Set the camera Y position
+     */
+    set y(value: number);
+    /**
+     * Get the camera zoom level
+     */
+    get zoom(): number;
+    /**
+     * Set the camera zoom level
+     * Values: 1.0 = no zoom, >1 = zoom in, <1 = zoom out
+     */
+    set zoom(value: number);
+    /**
+     * Set both X and Y position at once
+     * @param x New X position
+     * @param y New Y position
+     */
+    setPosition(x: number, y: number): void;
+    /**
+     * Move the camera by a relative offset
+     * @param dx X offset to add to current position
+     * @param dy Y offset to add to current position
+     */
+    move(dx: number, dy: number): void;
+    /**
+     * Scale the zoom by a factor
+     * @param factor Multiplier for current zoom (e.g., 1.1 to zoom in 10%)
+     */
+    zoomBy(factor: number): void;
+    /**
+     * Reset camera to default position and zoom
+     */
+    reset(): void;
+    /**
+     * 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(): Float32Array;
+    /**
+     * Convert screen coordinates to world coordinates
+     * Useful for mouse picking and interaction
+     *
+     * @param screenX Screen X coordinate (pixels)
+     * @param screenY Screen Y coordinate (pixels)
+     * @param viewportWidth Viewport width in pixels
+     * @param viewportHeight Viewport height in pixels
+     * @returns World coordinates {x, y}
+     */
+    screenToWorld(screenX: number, screenY: number, viewportWidth: number, viewportHeight: number): {
+        x: number;
+        y: number;
+    };
+    /**
+     * Convert world coordinates to screen coordinates
+     * Useful for UI positioning and debug rendering
+     *
+     * @param worldX World X coordinate
+     * @param worldY World Y coordinate
+     * @param viewportWidth Viewport width in pixels
+     * @param viewportHeight Viewport height in pixels
+     * @returns Screen coordinates {x, y} in pixels
+     */
+    worldToScreen(worldX: number, worldY: number, viewportWidth: number, viewportHeight: number): {
+        x: number;
+        y: number;
+    };
+}
+//# sourceMappingURL=camera.d.ts.map

package/dist/web/rendering/camera.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"camera.d.ts","sourceRoot":"","sources":["../../../src/rendering/camera.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH;;;GAGG;AACH,qBAAa,OAAO;IAClB;;;OAGG;IACH,MAAM,CAAC,QAAQ,IAAI,YAAY;IAS/B;;;;;;OAMG;IACH,MAAM,CAAC,WAAW,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,GAAE,MAAU,GAAG,YAAY;IASrE;;;;;;OAMG;IACH,MAAM,CAAC,KAAK,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,GAAE,MAAU,GAAG,YAAY;IAS/D;;;;;OAKG;IACH,MAAM,CAAC,QAAQ,CAAC,CAAC,EAAE,YAAY,EAAE,CAAC,EAAE,YAAY,GAAG,YAAY;IAmB/D;;;;;;;;;;OAUG;IACH,MAAM,CAAC,gBAAgB,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,YAAY;CAQ1E;AAED;;;GAGG;AACH,qBAAa,MAAM;IACjB,OAAO,CAAC,EAAE,CAAS;IACnB,OAAO,CAAC,EAAE,CAAS;IACnB,OAAO,CAAC,KAAK,CAAS;IACtB,OAAO,CAAC,WAAW,CAA6B;IAChD,OAAO,CAAC,gBAAgB,CAAiB;IAEzC;;;;;OAKG;gBACS,CAAC,GAAE,MAAU,EAAE,CAAC,GAAE,MAAU,EAAE,IAAI,GAAE,MAAY;IAM5D;;OAEG;IACH,IAAI,CAAC,IAAI,MAAM,CAEd;IAED;;OAEG;IACH,IAAI,CAAC,CAAC,KAAK,EAAE,MAAM,EAGlB;IAED;;OAEG;IACH,IAAI,CAAC,IAAI,MAAM,CAEd;IAED;;OAEG;IACH,IAAI,CAAC,CAAC,KAAK,EAAE,MAAM,EAGlB;IAED;;OAEG;IACH,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED;;;OAGG;IACH,IAAI,IAAI,CAAC,KAAK,EAAE,MAAM,EAGrB;IAED;;;;OAIG;IACH,WAAW,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI;IAMvC;;;;OAIG;IACH,IAAI,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,IAAI;IAMlC;;;OAGG;IACH,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAK5B;;OAEG;IACH,KAAK,IAAI,IAAI;IAOb;;;;;;OAMG;IACH,aAAa,IAAI,YAAY;IAQ7B;;;;;;;;;OASG;IACH,aAAa,CACX,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,EACf,aAAa,EAAE,MAAM,EACrB,cAAc,EAAE,MAAM,GACrB;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAE;IAY3B;;;;;;;;;OASG;IACH,aAAa,CACX,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,aAAa,EAAE,MAAM,EACrB,cAAc,EAAE,MAAM,GACrB;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAE;CAW5B"}

package/dist/web/rendering/projection.d.ts

@@ -0,0 +1,108 @@
+/**
+ * 2.5D Isometric Projection Mathematics
+ *
+ * Converts between grid coordinates (xgrid, ygrid, zheight) and screen coordinates (xscreen, yscreen).
+ * This is the mathematical core for 2.5D rendering with isometric perspective.
+ *
+ * Coordinate Systems:
+ * - Grid space: (xgrid, ygrid, zheight) - logical game world coordinates
+ * - Screen space: (xscreen, yscreen) - pixel coordinates on display
+ */
+export interface GridCoord {
+    xgrid: number;
+    ygrid: number;
+    zheight: number;
+}
+export interface ScreenCoord {
+    xscreen: number;
+    yscreen: number;
+}
+export interface FractionalGridCoord {
+    xgrid: number;
+    ygrid: number;
+    zheight: number;
+}
+/**
+ * Projection configuration for isometric view
+ */
+export declare class ProjectionConfig {
+    readonly tileWidth: number;
+    readonly tileHeight: number;
+    readonly zScale: number;
+    constructor(tileWidth?: number, tileHeight?: number, zScale?: number);
+}
+/**
+ * Projects grid coordinates to screen coordinates using isometric projection.
+ *
+ * Formula:
+ * xscreen = (xgrid - ygrid) × (tileWidth / 2)
+ * yscreen = (xgrid + ygrid) × (tileHeight / 2) - (zheight × zScale)
+ *
+ * @param gridCoord Grid-space coordinate
+ * @param config Projection configuration
+ * @returns Screen-space coordinate in pixels
+ */
+export declare function gridToScreen(gridCoord: GridCoord, config: ProjectionConfig): ScreenCoord;
+/**
+ * Converts screen coordinates back to fractional grid coordinates.
+ * This is the inverse transformation, used for mouse picking.
+ *
+ * The isometric projection matrix is:
+ * [xscreen]   [tileWidth/2   -tileWidth/2 ] [xgrid]
+ * [yscreen] = [tileHeight/2   tileHeight/2] [ygrid]  - [0, zheight * zScale]^T
+ *
+ * Inverting this 2x2 matrix:
+ * A = [[tw/2, -tw/2], [th/2, th/2]]
+ * det(A) = (tw/2)(th/2) - (-tw/2)(th/2) = tw*th/4 + tw*th/4 = tw*th/2
+ *
+ * A^-1 = (1 / det(A)) * [[th/2, tw/2], [-th/2, tw/2]]
+ *      = (2 / (tw*th)) * [[th/2, tw/2], [-th/2, tw/2]]
+ *      = [[1/tw, 1/th], [-1/tw, 1/th]]
+ *
+ * Therefore:
+ * xgrid = (xscreen / (tileWidth/2) - yscreen / (tileHeight/2)) / 2
+ * ygrid = (-xscreen / (tileWidth/2) + yscreen / (tileHeight/2)) / 2
+ *
+ * Simplified:
+ * xgrid = xscreen / tileWidth + yscreen / tileHeight
+ * ygrid = -xscreen / tileWidth + yscreen / tileHeight
+ *
+ * @param screenCoord Screen-space coordinate in pixels
+ * @param config Projection configuration
+ * @param zheight Optional height to add back to yscreen before inversion
+ * @returns Fractional grid-space coordinate
+ */
+export declare function screenToGrid(screenCoord: ScreenCoord, config: ProjectionConfig, zheight?: number): FractionalGridCoord;
+/**
+ * Converts screen coordinates to grid coordinates with automatic height detection.
+ * Assumes zheight = 0 (picking at ground level).
+ *
+ * @param screenCoord Screen-space coordinate in pixels
+ * @param config Projection configuration
+ * @returns Grid-space coordinate at ground level (zheight = 0)
+ */
+export declare function screenToGridAtGroundLevel(screenCoord: ScreenCoord, config: ProjectionConfig): GridCoord;
+/**
+ * Calculates the offset from a grid cell to the center of that cell in screen space.
+ * Useful for positioning entities at cell centers.
+ *
+ * @param config Projection configuration
+ * @returns Offset to cell center in screen coordinates
+ */
+export declare function getCellCenterOffset(config: ProjectionConfig): ScreenCoord;
+/**
+ * Validates if a grid coordinate is within typical bounds.
+ *
+ * @param gridCoord Grid-space coordinate
+ * @param maxGridSize Maximum size of grid (assumes square grid)
+ * @returns True if coordinate is within bounds
+ */
+export declare function isGridCoordValid(gridCoord: GridCoord, maxGridSize?: number): boolean;
+/**
+ * Creates a default projection configuration suitable for most 2.5D games.
+ * Uses standard tile dimensions.
+ *
+ * @returns Default ProjectionConfig
+ */
+export declare function createDefaultProjection(): ProjectionConfig;
+//# sourceMappingURL=projection.d.ts.map

package/dist/web/rendering/projection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"projection.d.ts","sourceRoot":"","sources":["../../../src/rendering/projection.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,MAAM,WAAW,SAAS;IACxB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,WAAW;IAC1B,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,mBAAmB;IAClC,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;GAEG;AACH,qBAAa,gBAAgB;IAC3B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;gBAGtB,SAAS,GAAE,MAAW,EACtB,UAAU,GAAE,MAAW,EACvB,MAAM,GAAE,MAAY;CAMvB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,YAAY,CAC1B,SAAS,EAAE,SAAS,EACpB,MAAM,EAAE,gBAAgB,GACvB,WAAW,CAUb;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,YAAY,CAC1B,WAAW,EAAE,WAAW,EACxB,MAAM,EAAE,gBAAgB,EACxB,OAAO,GAAE,MAAU,GAClB,mBAAmB,CAiBrB;AAED;;;;;;;GAOG;AACH,wBAAgB,yBAAyB,CACvC,WAAW,EAAE,WAAW,EACxB,MAAM,EAAE,gBAAgB,GACvB,SAAS,CAOX;AAED;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,gBAAgB,GAAG,WAAW,CASzE;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAC9B,SAAS,EAAE,SAAS,EACpB,WAAW,GAAE,MAAa,GACzB,OAAO,CAQT;AAED;;;;;GAKG;AACH,wBAAgB,uBAAuB,IAAI,gBAAgB,CAE1D"}

package/dist/web/rendering/rendering-context-factory.d.ts

@@ -0,0 +1,24 @@
+import { RenderingContext, RenderingContextOptions } from '../rendering/rendering-context';
+/**
+ * Factory for creating environment-appropriate rendering contexts
+ * Abstracts environment detection from the application code
+ */
+export declare class RenderingContextFactory {
+    /**
+     * Detect if running in a browser environment
+     */
+    static isBrowserEnvironment(): boolean;
+    /**
+     * Create a rendering context appropriate for the current environment
+     */
+    static createContext(options: RenderingContextOptions): RenderingContext;
+    /**
+     * Create a browser-specific rendering context
+     */
+    static createBrowserContext(options: RenderingContextOptions): RenderingContext;
+    /**
+     * Create a Node.js-specific rendering context
+     */
+    static createNodeContext(options: RenderingContextOptions): RenderingContext;
+}
+//# sourceMappingURL=rendering-context-factory.d.ts.map

package/dist/web/rendering/rendering-context-factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rendering-context-factory.d.ts","sourceRoot":"","sources":["../../../src/rendering/rendering-context-factory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,gBAAgB,EAChB,uBAAuB,EACxB,MAAM,gCAAgC,CAAC;AAIxC;;;GAGG;AACH,qBAAa,uBAAuB;IAClC;;OAEG;IACH,MAAM,CAAC,oBAAoB,IAAI,OAAO;IAItC;;OAEG;IACH,MAAM,CAAC,aAAa,CAAC,OAAO,EAAE,uBAAuB,GAAG,gBAAgB;IAQxE;;OAEG;IACH,MAAM,CAAC,oBAAoB,CACzB,OAAO,EAAE,uBAAuB,GAC/B,gBAAgB;IAInB;;OAEG;IACH,MAAM,CAAC,iBAAiB,CAAC,OAAO,EAAE,uBAAuB,GAAG,gBAAgB;CAG7E"}

package/dist/web/rendering/rendering-context.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Standardized rendering context interface
+ * Abstracts away environment-specific (DOM vs Node.js) details
+ * Ensures the engine core never directly references DOM APIs
+ */
+export interface RenderingContext {
+    /**
+     * The underlying WebGL rendering context
+     */
+    glContext: WebGLRenderingContext;
+    /**
+     * Canvas/drawable surface width in pixels
+     */
+    width: number;
+    /**
+     * Canvas/drawable surface height in pixels
+     */
+    height: number;
+    /**
+     * Whether this context is in a browser environment
+     */
+    isBrowser: boolean;
+    /**
+     * Resize the rendering context
+     */
+    resize(width: number, height: number): void;
+    /**
+     * Get the current viewport dimensions
+     */
+    getViewport(): {
+        width: number;
+        height: number;
+    };
+    /**
+     * Clear the rendering context (prepare for new frame)
+     */
+    clear(color?: {
+        r: number;
+        g: number;
+        b: number;
+        a: number;
+    }): void;
+    /**
+     * Present/swap the rendering buffers (if applicable)
+     */
+    present(): void;
+    /**
+     * Cleanup and release resources
+     */
+    dispose(): void;
+}
+/**
+ * Context creation options
+ */
+export interface RenderingContextOptions {
+    /**
+     * Canvas element (browser only)
+     */
+    canvas?: HTMLCanvasElement;
+    /**
+     * WebGL context creation options
+     */
+    contextAttributes?: WebGLContextAttributes;
+    /**
+     * Whether to preserve drawing buffer between frames
+     */
+    preserveDrawingBuffer?: boolean;
+    /**
+     * Canvas width in pixels
+     */
+    width: number;
+    /**
+     * Canvas height in pixels
+     */
+    height: number;
+}
+//# sourceMappingURL=rendering-context.d.ts.map

package/dist/web/rendering/rendering-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rendering-context.d.ts","sourceRoot":"","sources":["../../../src/rendering/rendering-context.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,MAAM,WAAW,gBAAgB;IAC/B;;OAEG;IACH,SAAS,EAAE,qBAAqB,CAAC;IAEjC;;OAEG;IACH,KAAK,EAAE,MAAM,CAAC;IAEd;;OAEG;IACH,MAAM,EAAE,MAAM,CAAC;IAEf;;OAEG;IACH,SAAS,EAAE,OAAO,CAAC;IAEnB;;OAEG;IACH,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IAE5C;;OAEG;IACH,WAAW,IAAI;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC;IAEjD;;OAEG;IACH,KAAK,CAAC,KAAK,CAAC,EAAE;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAC;IAEpE;;OAEG;IACH,OAAO,IAAI,IAAI,CAAC;IAEhB;;OAEG;IACH,OAAO,IAAI,IAAI,CAAC;CACjB;AAED;;GAEG;AACH,MAAM,WAAW,uBAAuB;IACtC;;OAEG;IACH,MAAM,CAAC,EAAE,iBAAiB,CAAC;IAE3B;;OAEG;IACH,iBAAiB,CAAC,EAAE,sBAAsB,CAAC;IAE3C;;OAEG;IACH,qBAAqB,CAAC,EAAE,OAAO,CAAC;IAEhC;;OAEG;IACH,KAAK,EAAE,MAAM,CAAC;IAEd;;OAEG;IACH,MAAM,EAAE,MAAM,CAAC;CAChB"}

package/dist/web/rendering/vertex.d.ts

@@ -0,0 +1,98 @@
+/**
+ * 2.5D Sprite Vertex Structure
+ *
+ * Defines the vertex format for 2.5D sprites with support for:
+ * - Position (x, y, z)
+ * - Texture coordinates (u, v)
+ * - Color tint (r, g, b, a)
+ * - Texture index (for texture atlases)
+ *
+ * Vertex Layout (9 floats per vertex):
+ * [0-2] Position:    x, y, z
+ * [3-4] TexCoord:    u, v
+ * [5-8] Color:       r, g, b, a
+ * [9]   TexIndex:    texture index (integer passed as float)
+ */
+/**
+ * Represents a single vertex with all 2.5D sprite attributes
+ */
+export interface SpriteVertex {
+    /** Position in world space */
+    x: number;
+    y: number;
+    z: number;
+    /** Texture coordinates */
+    u: number;
+    v: number;
+    /** Color tint (0-1 range) */
+    r: number;
+    g: number;
+    b: number;
+    a: number;
+    /** Texture index for texture atlas selection */
+    texIndex: number;
+}
+/**
+ * Float layout per vertex in the vertex buffer
+ * Total: 10 floats per vertex
+ */
+export declare const VERTEX_LAYOUT: {
+    readonly FLOATS_PER_VERTEX: 10;
+    readonly POSITION_OFFSET: 0;
+    readonly TEXCOORD_OFFSET: 3;
+    readonly COLOR_OFFSET: 5;
+    readonly TEXINDEX_OFFSET: 9;
+    readonly STRIDE: number;
+};
+/**
+ * Convert a SpriteVertex to a Float32Array segment
+ * Useful for building vertex buffers
+ */
+export declare function spriteVertexToArray(vertex: SpriteVertex): Float32Array;
+/**
+ * Create a default sprite vertex
+ * Useful for initialization
+ */
+export declare function createDefaultSpriteVertex(): SpriteVertex;
+/**
+ * Sprite quad instance data for batch rendering
+ * Extends the basic QuadInstance with 2.5D sprite features
+ */
+export interface SpriteQuadInstance {
+    /** Position in 2.5D space */
+    x: number;
+    y: number;
+    z: number;
+    /** Width and height */
+    width: number;
+    height: number;
+    /** Rotation in radians */
+    rotation: number;
+    /** Color tint (0-1 range, default white) */
+    color?: {
+        r: number;
+        g: number;
+        b: number;
+        a: number;
+    };
+    /** Texture coordinates (UV region in texture atlas) */
+    uvRect?: {
+        uMin: number;
+        vMin: number;
+        uMax: number;
+        vMax: number;
+    };
+    /** Texture index for atlas selection */
+    texIndex?: number;
+    /** Grid position for GPU-based transformation (optional) */
+    gridX?: number;
+    gridY?: number;
+}
+/**
+ * Generate 6 vertices (2 triangles) for a quad with the specified properties
+ *
+ * @param instance The sprite quad instance data
+ * @returns Array of 6 vertices forming the quad
+ */
+export declare function generateQuadVertices(instance: SpriteQuadInstance): SpriteVertex[];
+//# sourceMappingURL=vertex.d.ts.map

package/dist/web/rendering/vertex.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vertex.d.ts","sourceRoot":"","sources":["../../../src/rendering/vertex.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,8BAA8B;IAC9B,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,0BAA0B;IAC1B,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,6BAA6B;IAC7B,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,gDAAgD;IAChD,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED;;;GAGG;AACH,eAAO,MAAM,aAAa;;;;;;;CAOhB,CAAC;AAEX;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,YAAY,GAAG,YAAY,CAatE;AAED;;;GAGG;AACH,wBAAgB,yBAAyB,IAAI,YAAY,CAaxD;AAED;;;GAGG;AACH,MAAM,WAAW,kBAAkB;IACjC,6BAA6B;IAC7B,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,uBAAuB;IACvB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,0BAA0B;IAC1B,QAAQ,EAAE,MAAM,CAAC;IACjB,4CAA4C;IAC5C,KAAK,CAAC,EAAE;QACN,CAAC,EAAE,MAAM,CAAC;QACV,CAAC,EAAE,MAAM,CAAC;QACV,CAAC,EAAE,MAAM,CAAC;QACV,CAAC,EAAE,MAAM,CAAC;KACX,CAAC;IACF,uDAAuD;IACvD,MAAM,CAAC,EAAE;QACP,IAAI,EAAE,MAAM,CAAC;QACb,IAAI,EAAE,MAAM,CAAC;QACb,IAAI,EAAE,MAAM,CAAC;QACb,IAAI,EAAE,MAAM,CAAC;KACd,CAAC;IACF,wCAAwC;IACxC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,4DAA4D;IAC5D,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,kBAAkB,GAC3B,YAAY,EAAE,CAmEhB"}

package/dist/web/scene/scene.d.ts

@@ -0,0 +1,139 @@
+import { ProjectionConfig, GridCoord } from '../rendering/projection';
+/**
+ * Scene configuration and constants
+ * Shared between Node.js and Browser rendering
+ */
+export declare const SCENE_CONFIG: {
+    width: number;
+    height: number;
+    targetFPS: number;
+};
+export declare const PROJECTION_CONFIG: ProjectionConfig;
+/**
+ * Entity for visualization (used in projection demo)
+ */
+export interface VisualizationEntity {
+    id: string;
+    name: string;
+    gridPos: GridCoord;
+    color: [number, number, number];
+    size: number;
+}
+/**
+ * Projection visualization entities to render
+ */
+export declare const PROJECTION_ENTITIES: VisualizationEntity[];
+export declare const GEOMETRY: {
+    quad: {
+        name: string;
+        vertices: Float32Array<ArrayBuffer>;
+        stride: number;
+    };
+    triangle: {
+        name: string;
+        vertices: Float32Array<ArrayBuffer>;
+        stride: number;
+    };
+};
+export declare const SHADERS_V1: {
+    vertex: string;
+    fragment: string;
+};
+export declare const SHADERS_V2: {
+    vertex: string;
+    fragment: string;
+};
+export declare const SHADERS: {
+    vertex: string;
+    fragment: string;
+};
+/**
+ * SHADERS_V3 - GPU-Based 2.5D Transformation
+ *
+ * This version moves the isometric projection from CPU to GPU.
+ * The vertex shader receives grid coordinates and transforms them to screen space.
+ *
+ * Attributes:
+ * - aGridPosition: Grid position (x, y) in world space
+ * - aZPosition: Z position for depth layering
+ * - aLocalOffset: Local offset from quad center (for rotation)
+ * - aTexCoord: Texture coordinates
+ * - aColor: Color tint
+ * - aTexIndex: Texture atlas index
+ *
+ * Uniforms:
+ * - uTileSize: Size of tiles (width, height) for isometric projection
+ * - uCamera: Camera position (x, y) and zoom
+ * - uRotation: Rotation angle in radians
+ * - uQuadSize: Size of the quad (width, height)
+ * - uZScale: Scale factor for Z height (vertical exaggeration)
+ * - uResolution: Screen resolution for NDC conversion
+ */
+export declare const SHADERS_V3: {
+    vertex: string;
+    fragment: string;
+};
+export declare const TEXTURE_CONFIG: {
+    size: number;
+    type: string;
+};
+export declare const ANIMATION_CONFIG: {
+    background: {
+        offsetR: number;
+        amplitudeR: number;
+        speedR: number;
+        offsetG: number;
+        amplitudeG: number;
+        speedG: number;
+        offsetB: number;
+        amplitudeB: number;
+        speedB: number;
+    };
+    quads: {
+        count: number;
+        scale: number;
+        baseRadius: number;
+        radiusVariation: number;
+        radiusSpeed: number;
+        orbitalSpeed: number;
+        rotationSpeed: number;
+        colors: number[][];
+    };
+    triangles: {
+        count: number;
+        scale: number;
+        baseRadius: number;
+        radiusVariation: number;
+        radiusSpeed: number;
+        orbitalSpeed: number;
+        rotationSpeed: number;
+        rotationDirection: number;
+        colors: number[][];
+    };
+};
+/**
+ * Calculate background color for a given elapsed time
+ */
+export declare function getBackgroundColor(elapsedSeconds: number): {
+    r: number;
+    g: number;
+    b: number;
+    a: number;
+};
+/**
+ * Calculate quad transformations for animation
+ */
+export declare function getQuadTransforms(elapsedSeconds: number): {
+    matrix: Float32Array<ArrayBuffer>;
+    color: number[];
+    index: number;
+}[];
+/**
+ * Calculate triangle transformations for animation
+ */
+export declare function getTriangleTransforms(elapsedSeconds: number): {
+    matrix: Float32Array<ArrayBuffer>;
+    color: number[];
+    index: number;
+}[];
+//# sourceMappingURL=scene.d.ts.map

package/dist/web/scene/scene.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scene.d.ts","sourceRoot":"","sources":["../../../src/scene/scene.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,KAAK,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAE3E;;;GAGG;AAEH,eAAO,MAAM,YAAY;;;;CAIxB,CAAC;AAMF,eAAO,MAAM,iBAAiB,kBAI7B,CAAC;AAEF;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,SAAS,CAAC;IACnB,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IAChC,IAAI,EAAE,MAAM,CAAC;CACd;AAED;;GAEG;AACH,eAAO,MAAM,mBAAmB,EAAE,mBAAmB,EAoCpD,CAAC;AAGF,eAAO,MAAM,QAAQ;;;;;;;;;;;CA6DpB,CAAC;AAKF,eAAO,MAAM,UAAU;;;CA2BtB,CAAC;AAKF,eAAO,MAAM,UAAU;;;CAsCtB,CAAC;AAGF,eAAO,MAAM,OAAO;;;CAAa,CAAC;AAElC;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,UAAU;;;CAgFtB,CAAC;AAGF,eAAO,MAAM,cAAc;;;CAG1B,CAAC;AAGF,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4C5B,CAAC;AAEF;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,cAAc,EAAE,MAAM;;;;;EAQxD;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,cAAc,EAAE,MAAM;;;;IA6CvD;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,cAAc,EAAE,MAAM;;;;IA8C3D"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bloody-engine",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "description": "A WebGL-based 2.5D graphics engine for isometric rendering",
   "license": "MIT",
   "type": "module",
@@ -39,8 +39,8 @@
   "scripts": {
     "dev": "vite",
     "build": "npm run build:web && npm run build:node",
-    "build:web": "vite build --config vite.config.web.ts",
-    "build:node": "vite build --config vite.config.node.ts",
+    "build:web": "tsc --emitDeclarationOnly --declaration --declarationMap --outDir dist/web && vite build --config vite.config.web.ts",
+    "build:node": "tsc --emitDeclarationOnly --declaration --declarationMap --outDir dist/node && vite build --config vite.config.node.ts",
     "build:demo": "vite build --config vite.config.demo.ts",
     "preview": "vite preview",
     "demo": "npm run build:demo && node dist/demo/index.js"
@@ -49,7 +49,8 @@
     "@types/gl": "^6.0.5",
     "@types/node": "^20.10.6",
     "typescript": "^5.3.3",
-    "vite": "^7.3.0"
+    "vite": "^7.3.0",
+    "vite-plugin-dts": "^4.5.4"
   },
   "dependencies": {
     "@kmamal/sdl": "^0.11.13",