rapid-render 0.1.1 → 0.1.2-1.3

package/dist/texture.d.ts

@@ -1,12 +1,15 @@
-import Rapid from "./render";
-import { Images, ITextOptions } from "./interface";
+import { default as Rapid } from './render';
+import { Images, ITextTextureOptions, TextureWrapMode, WebGLContext } from './interface';
+import { Color } from './math';
 /**
  * texture manager
+ * @ignore
  */
 declare class TextureCache {
     private render;
     private cache;
-    constructor(render: Rapid);
+    private antialias;
+    constructor(render: Rapid, antialias: boolean);
     /**
      * create texture from url
      * Equivalent to {@link Texture.fromUrl} method
@@ -14,9 +17,46 @@ declare class TextureCache {
      * @param antialias
      * @returns
      */
-    textureFromUrl(url: string, antialias?: boolean): Promise<Texture>;
+    textureFromUrl(url: string, antialias?: boolean, wrapMode?: TextureWrapMode): Promise<Texture>;
+    /**
+     * Create a new `Texture` instance from a FrameBufferObject.
+     * @param fbo - The FrameBufferObject to create the texture from.
+     * @returns A new `Texture` instance created from the specified FrameBufferObject.
+     */
+    textureFromFrameBufferObject(fbo: FrameBufferObject): Texture;
+    /**
+     * Create a new `Texture` instance from an image source.
+     * @param source - The image source to create the texture from.
+     * @param antialias - Whether to enable antialiasing.
+     * @returns A new `Texture` instance created from the specified image source.
+     */
+    textureFromSource(source: Images, antialias?: boolean, wrapMode?: TextureWrapMode): Texture;
+    /**
+     * Load an image from the specified URL.
+     * @param url - The URL of the image to load.
+     * @returns A promise that resolves to the loaded HTMLImageElement.
+     */
     loadImage(url: string): Promise<HTMLImageElement>;
-    createText(options: ITextOptions): Text;
+    /**
+     * Create a new `Text` instance.
+     * @param options - The options for rendering the text, such as font, size, color, etc.
+     * @returns A new `Text` instance.
+     */
+    createText(options: ITextTextureOptions): Text;
+    /**
+     * Destroy the texture
+     * @param texture
+     */
+    destroy(texture: Texture | BaseTexture): void;
+    /**
+     * Create a new FrameBufferObject instance
+     * @param width - Width of the framebuffer
+     * @param height - Height of the framebuffer
+     * @param antialias - Whether to enable antialiasing
+     * @returns A new FrameBufferObject instance
+     */
+    createFrameBufferObject(width: number, height: number, antialias?: boolean): FrameBufferObject;
+    private removeCache;
 }
 /**
  * Each {@link Texture} references a baseTexture, and different textures may have the same baseTexture
@@ -25,8 +65,16 @@ declare class BaseTexture {
     texture: WebGLTexture;
     width: number;
     height: number;
-    constructor(texture: WebGLTexture, width: number, height: number);
-    static fromImageSource(r: Rapid, image: Images, antialias?: boolean): BaseTexture;
+    wrapMode: TextureWrapMode;
+    cacheKey: string | Images | null;
+    constructor(texture: WebGLTexture, width: number, height: number, wrapMode?: TextureWrapMode);
+    static fromImageSource(r: Rapid, image: Images, antialias?: boolean, wrapMode?: TextureWrapMode): BaseTexture;
+    /**
+     * Destroy the texture
+     * @param gl
+     * @ignore
+     */
+    destroy(gl: WebGLContext): void;
 }
 declare class Texture {
     /**
@@ -71,7 +119,7 @@ declare class Texture {
      * @param base
      * @param scale
      */
-    setBaseTextur(base?: BaseTexture): void;
+    setBaseTexture(base?: BaseTexture): void;
     /**
      * Sets the region of the texture to be used for rendering.
      * @param x - The x-coordinate of the top-left corner of the region.
@@ -79,7 +127,7 @@ declare class Texture {
      * @param w - The width of the region.
      * @param h - The height of the region.
      */
-    setClipRegion(x: number, y: number, w: number, h: number): void;
+    setClipRegion(x: number, y: number, w: number, h: number): this | undefined;
     /**
      * Creates a new `Texture` instance from the specified image source.
      * @param rapid - The Rapid instance to use.
@@ -88,31 +136,71 @@ declare class Texture {
      * @returns A new `Texture` instance created from the image source.
      */
     static fromImageSource(rapid: Rapid, image: Images, antialias?: boolean): Texture;
+    static fromFrameBufferObject(fbo: FrameBufferObject): Texture;
     /**
-     * Creates a new `Texture` instance from the specified URL.
+     * Converts the current texture into a spritesheet.
      * @param rapid - The Rapid instance to use.
-     * @param url - The URL of the image to create the texture from.
-     * @returns A new `Texture` instance created from the specified URL.
+     * @param spriteWidth - The width of each sprite in the spritesheet.
+     * @param spriteHeight - The height of each sprite in the spritesheet.
+     * @returns An array of `Texture` instances representing the sprites in the spritesheet.
+     */
+    createSpritesheet(spriteWidth: number, spriteHeight: number): Texture[];
+    /**
+     * Clone the current texture
+     * @returns A new `Texture` instance with the same base texture reference.
      */
-    static fromUrl(rapid: Rapid, url: string): Promise<Texture>;
+    clone(): Texture;
 }
-export declare const SCALEFACTOR = 2;
+/**
+ * @ignore
+ */
+export declare const SCALEFACTOR = 2.5;
 declare class Text extends Texture {
-    private options;
-    private rapid;
+    private readonly options;
+    private readonly rapid;
     protected scale: number;
     text: string;
-    /**
-     * Creates a new `Text` instance.
-     * @param options - The options for rendering the text, such as font, size, color, etc.
-     */
-    constructor(rapid: Rapid, options: ITextOptions);
+    constructor(rapid: Rapid, options: ITextTextureOptions);
     private updateTextImage;
     private createTextCanvas;
     /**
-     * Update the displayed text
-     * @param text
+     * Updates the displayed text. Re-renders the texture if the text has changed.
+     * @param text - The new text to display.
      */
     setText(text: string): void;
 }
-export { Text, Texture, BaseTexture, TextureCache };
+declare class FrameBufferObject extends BaseTexture {
+    private framebuffer;
+    private gl;
+    private readonly stencilBuffer;
+    /**
+     * Creates a new FrameBufferObject instance
+     * @param render - The Rapid instance to use
+     * @param width - Width of the framebuffer
+     * @param height - Height of the framebuffer
+     * @param antialias - Whether to enable antialiasing
+     */
+    constructor(render: Rapid, width: number, height: number, antialias?: boolean);
+    /**
+     * Bind the framebuffer for rendering
+     * @ignore
+     */
+    bind(bgColor: Color): void;
+    /**
+     * Unbind the framebuffer and restore default framebuffer
+     * @ignore
+     */
+    unbind(): void;
+    /**
+     * Resize the framebuffer
+     * @param width - New width
+     * @param height - New height
+     */
+    resize(width: number, height: number): void;
+    /**
+     * Override destroy method to clean up framebuffer resources
+     * @param gl - WebGL context
+     */
+    destroy(gl: WebGLContext): void;
+}
+export { Text, Texture, BaseTexture, TextureCache, FrameBufferObject };

package/dist/tilemap.d.ts

@@ -0,0 +1,159 @@
+import { default as Rapid } from './render';
+import { IRegisterTileOptions, ILayerRenderOptions, YSortCallback, TilemapShape, ISpriteRenderOptions, IEntityTilemapLayerOptions } from './interface';
+import { Texture } from './texture';
+import { Vec2 } from './math';
+import { Entity, Game } from './game';
+/**
+ * Represents a tileset that manages tile textures and their properties.
+ */
+export declare class TileSet {
+    /** Map storing tile textures and their associated options */
+    private textures;
+    /** Width of each tile in the tileset */
+    width: number;
+    /** Height of each tile in the tileset */
+    height: number;
+    /**
+     * Creates a new TileSet instance.
+     * @param width - The width of each tile in pixels
+     * @param height - The height of each tile in pixels
+     */
+    constructor(width: number, height: number);
+    /**
+     * Registers a new tile with the given ID and options.
+     * @param id - The unique identifier for the tile
+     * @param options - The tile options or texture to register
+     */
+    setTile(id: string | number, options: IRegisterTileOptions | Texture): void;
+    /**
+     * Retrieves the registered tile options for the given ID.
+     * @param id - The unique identifier of the tile to retrieve
+     * @returns The registered tile options, or undefined if not found
+     */
+    getTile(id: string | number): IRegisterTileOptions | undefined;
+}
+/**
+ * Represents a tilemap renderer that handles rendering of tile-based maps.
+ */
+export declare class TileMapRender {
+    private rapid;
+    /**
+     * Creates a new TileMapRender instance.
+     * @param rapid - The Rapid rendering instance to use.
+     */
+    constructor(rapid: Rapid);
+    /**
+     * Calculates the error offset values for tile rendering.
+     * @param options - Layer rendering options containing error values.
+     * @returns Object containing x and y error offsets.
+     * @private
+     */
+    private getOffset;
+    /**
+     * Calculates tile rendering data based on the viewport and tileset.
+     * @param tileSet - The tileset to use for rendering.
+     * @param options - Layer rendering options.
+     * @returns Object containing calculated tile rendering data.
+     * @private
+     */
+    private getTileData;
+    /**
+     * Renders the tilemap layer based on the provided data and options.
+     * This method collects all visible tiles and y-sortable objects into a single queue,
+     * sorts them once by their y-coordinate, and then renders them in the correct order.
+     *
+     * @param data - A 2D array representing the tilemap data.
+     * @param options - The rendering options for the tilemap layer.
+     */
+    renderLayer(data: (number | string)[][], options: ILayerRenderOptions): void;
+    /**
+     * Converts local coordinates to map coordinates.
+     * @param local - The local coordinates.
+     * @param options - The rendering options.
+     * @returns The map coordinates.
+     */
+    localToMap(local: Vec2, options: ILayerRenderOptions): Vec2;
+    /**
+     * Converts map coordinates to local coordinates.
+     * @param map - The map coordinates.
+     * @param options - The rendering options.
+     * @returns The local coordinates.
+     */
+    mapToLocal(map: Vec2, options: ILayerRenderOptions): Vec2;
+}
+/**
+ * Tilemap entity for rendering tiled maps.
+ */
+export declare class Tilemap extends Entity {
+    static readonly DEFAULT_ERROR = 0;
+    static readonly EMPTY_TILE = -1;
+    error: Vec2;
+    shape: TilemapShape;
+    tileSet: TileSet;
+    data: (number | string)[][];
+    eachTile?: (tileId: string | number, mapX: number, mapY: number) => ISpriteRenderOptions | undefined | void;
+    ySortCallback: YSortCallback[];
+    enableYsort: boolean;
+    /**
+     * Creates a tilemap entity.
+     * @param game - The game instance this tilemap belongs to.
+     * @param options - Configuration options for the tilemap.
+     */
+    constructor(game: Game, options: IEntityTilemapLayerOptions);
+    /**
+     * Collects renderable entities, excluding children unless they override onRender.
+     * @param queue - The array to collect renderable entities.
+     */
+    collectRenderables(queue: Entity[]): void;
+    /**
+     * Sets a tile at the specified map coordinates.
+     * @param x - The X coordinate (column) on the map.
+     * @param y - The Y coordinate (row) on the map.
+     * @param tileId - The tile ID to set (number or string).
+     * @returns True if the tile was set successfully, false if coordinates are out of bounds.
+     */
+    setTile(x: number, y: number, tileId: number | string): boolean;
+    /**
+     * Gets the tile ID at the specified map coordinates.
+     * @param x - The X coordinate (column) on the map.
+     * @param y - The Y coordinate (row) on the map.
+     * @returns The tile ID (number or string) or undefined if coordinates are out of bounds.
+     */
+    getTile(x: number, y: number): number | string | undefined;
+    /**
+     * Removes a tile at the specified map coordinates (sets it to EMPTY_TILE).
+     * @param x - The X coordinate (column) on the map.
+     * @param y - The Y coordinate (row) on the map.
+     * @returns True if the tile was removed successfully, false if coordinates are out of bounds.
+     */
+    removeTile(x: number, y: number): boolean;
+    /**
+     * Fills a rectangular area with a specified tile ID.
+     * @param tileId - The tile ID to use for filling.
+     * @param startX - The starting X coordinate.
+     * @param startY - The starting Y coordinate.
+     * @param width - The width of the fill area.
+     * @param height - The height of the fill area.
+     */
+    fill(tileId: number | string, startX: number, startY: number, width: number, height: number): void;
+    /**
+     * Replaces the entire tilemap data and updates dimensions.
+     * @param newData - The new 2D array of tile data.
+     */
+    setData(newData: (number | string)[][]): void;
+    /**
+     * Converts local coordinates to map coordinates.
+     * @param local - The local coordinates to convert.
+     */
+    localToMap(local: Vec2): void;
+    /**
+     * Converts map coordinates to local coordinates.
+     * @param local - The map coordinates to convert.
+     */
+    mapToLocal(local: Vec2): void;
+    /**
+     * Renders the tilemap layer.
+     * @param render - The rendering engine instance.
+     */
+    onRender(render: Rapid): void;
+}

package/dist/utils.d.ts

@@ -0,0 +1,106 @@
+import { default as EventEmitter } from 'eventemitter3';
+import { IMathObject } from './interface';
+interface TweenrEvents {
+    complete: () => void;
+}
+/**
+ * Manages the interpolation of a property on a target object over a specific duration.
+ * @template T - The type of the value being tweened (e.g., number, Vec2, Color).
+ */
+export declare class Tween<T extends IMathObject<T> | number> extends EventEmitter<TweenrEvents> {
+    private target;
+    private property;
+    private to;
+    private from;
+    private duration;
+    private easing;
+    private elapsed;
+    isRunning: boolean;
+    isFinished: boolean;
+    /**
+     * Creates an instance of Tween.
+     * @param target - The object whose property will be animated.
+     * @param property - The name of the property to animate.
+     * @param to - The target value of the property.
+     * @param duration - The duration of the animation in seconds.
+     * @param easing - The easing function to use for the animation.
+     */
+    constructor(target: any, property: string, to: T, duration: number, easing: EasingFunction);
+    /**
+     * Starts the tween animation.
+     * It captures the initial state of the property.
+     */
+    start(): void;
+    /**
+     * Updates the tween's state. This should be called every frame.
+     * @param deltaTime - The time elapsed since the last frame, in seconds.
+     */
+    update(deltaTime: number): void;
+}
+export declare const isPlainObject: (obj: any) => boolean;
+/**
+ * A type definition for an easing function.
+ * It takes a progress ratio (0 to 1) and returns a modified ratio.
+ * @param t - The linear progress of the animation, from 0 to 1.
+ * @returns The eased progress, typically also from 0 to 1.
+ */
+export type EasingFunction = (t: number) => number;
+/**
+ * A collection of common easing functions for tweening.
+ * Reference: https://easings.net/
+ */
+export declare class Easing {
+    static Linear: EasingFunction;
+    static EaseInQuad: EasingFunction;
+    static EaseOutQuad: EasingFunction;
+    static EaseInOutQuad: EasingFunction;
+    static EaseInCubic: EasingFunction;
+    static EaseOutCubic: EasingFunction;
+    static EaseInOutCubic: EasingFunction;
+    static EaseInQuart: EasingFunction;
+    static EaseOutQuart: EasingFunction;
+    static EaseInOutQuart: EasingFunction;
+}
+interface TimerEvents {
+    timeout: () => void;
+}
+/**
+ * Represents a timer that executes a callback after a specified duration.
+ * The timer can be set to repeat. It is managed and updated by the Game's main loop.
+ */
+export declare class Timer extends EventEmitter<TimerEvents> {
+    private duration;
+    private repeat;
+    private elapsedTime;
+    /** Indicates whether the timer is currently active and counting down. */
+    isRunning: boolean;
+    /** Indicates whether the timer has finished its lifecycle (for non-repeating timers). */
+    isFinished: boolean;
+    /**
+     * Creates an instance of a Timer.
+     * @param duration - The duration of the timer in seconds.
+     * @param onComplete - The callback function to execute when the timer completes a cycle.
+     * @param repeat - Whether the timer should restart automatically after completion. Defaults to false.
+     */
+    constructor(duration: number, repeat?: boolean);
+    /**
+     * Starts or resumes the timer.
+     */
+    start(): void;
+    /**
+     * Stops (pauses) the timer. It can be resumed with start().
+     */
+    stop(): void;
+    /**
+     * Updates the timer's state. This is called by the Game loop every frame.
+     * @param deltaTime - The time elapsed since the last frame, in seconds.
+     * @internal
+     */
+    update(deltaTime: number): void;
+    /**
+     * Immediately stops the timer and marks it as finished, preventing any further execution.
+     * This is used for cleanup to avoid memory leaks from stale callbacks.
+     */
+    destroy(): void;
+}
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rapid-render",
-  "version": "0.1.1",
+  "version": "0.1.21.3",
   "type": "module",
   "files": [
     "dist"
@@ -14,22 +14,30 @@
     "require": "./dist/rapid.umd.cjs"
   },
   "scripts": {
-    "dev": "rollup -c rollup.config.dev.js -w",
-    "build": "rollup -c rollup.config.prod.js && tsc",
+    "dev": "vite",
+    "build": "vite build",
     "docs": "typedoc"
   },
   "devDependencies": {
+    "express": "^4.18.2",
     "rollup": "^4.12.0",
     "rollup-plugin-dts": "^6.1.0",
-    "rollup-plugin-server": "^0.7.0",
     "rollup-plugin-string": "^3.0.0",
     "rollup-plugin-terser": "^7.0.2",
     "rollup-plugin-typescript2": "^0.36.0",
     "tslib": "^2.6.2",
-    "typedoc": "^0.26.6",
-    "typescript": "^5.3.3"
+    "typedoc-theme-category-nav": "^0.0.3",
+    "typescript": "^5.3.3",
+    "unplugin-dts": "^1.0.0-beta.0",
+    "vite-plugin-dts": "^4.5.4"
   },
   "dependencies": {
-    "typedoc-theme-category-nav": "^0.0.3"
+    "@rollup/plugin-commonjs": "^28.0.6",
+    "@rollup/plugin-node-resolve": "^16.0.1",
+    "concurrently": "^9.1.2",
+    "eventemitter3": "^5.0.1",
+    "typedoc": "^0.28.3",
+    "vite": "^7.1.2",
+    "vite-plugin-string": "^1.2.3"
   }
 }

package/dist/regions/graphic_region.d.ts

@@ -1,28 +0,0 @@
-import { Rapid } from "..";
-import RenderRegion from "./region";
-declare class GraphicRegion extends RenderRegion {
-    private vertex;
-    drawType: number;
-    constructor(rapid: Rapid);
-    startRender(): void;
-    addVertex(x: number, y: number, color: number): void;
-    drawCircle(x: number, y: number, radius: number, color: number): void;
-    protected executeRender(): void;
-}
-declare const graphicAttributes: ({
-    name: string;
-    size: number;
-    type: number;
-    stride: number;
-    offset?: undefined;
-    normalized?: undefined;
-} | {
-    name: string;
-    size: number;
-    type: number;
-    stride: number;
-    offset: number;
-    normalized: boolean;
-})[];
-export { graphicAttributes };
-export default GraphicRegion;

package/dist/regions/region.d.ts

@@ -1,25 +0,0 @@
-import { IAttribute, WebGLContext } from "../interface";
-import { WebglBufferArray } from "../math";
-import Rapid from "../render";
-import GLShader from "../webgl/glshader";
-declare class RenderRegion {
-    currentShader?: GLShader;
-    protected defaultShader: GLShader;
-    protected attribute: IAttribute[];
-    protected webglArrayBuffer: WebglBufferArray;
-    protected rapid: Rapid;
-    protected gl: WebGLContext;
-    protected usedTextures: WebGLTexture[];
-    protected readonly TEXTURE_UNITS_ARRAY: number[];
-    protected needBind: Set<number>;
-    constructor(rapid: Rapid, attributes?: IAttribute[]);
-    protected addVertex(x: number, y: number, ..._: unknown[]): void;
-    protected useTexture(texture: WebGLTexture): number;
-    enterRegion(customShader?: GLShader): void;
-    exitRegion(): void;
-    protected initDefaultShader(vs: string, fs: string): void;
-    render(): void;
-    protected executeRender(): void;
-    protected initializeForNextRender(): void;
-}
-export default RenderRegion;

package/dist/regions/sprite_region.d.ts

@@ -1,39 +0,0 @@
-import RenderRegion from "./region";
-import Rapid from "../render";
-import { UniformType } from "../interface";
-import GLShader from "../webgl/glshader";
-declare class SpriteRegion extends RenderRegion {
-    private batchSprite;
-    private indexBuffer;
-    protected readonly MAX_BATCH: number;
-    constructor(rapid: Rapid);
-    protected addVertex(x: number, y: number, u: number, v: number, textureUnit: number, color: number): void;
-    renderSprite(texture: WebGLTexture, width: number, height: number, u0: number, v0: number, u1: number, v1: number, offsetX: number, offsetY: number, color: number, uniforms?: UniformType): void;
-    protected executeRender(): void;
-    enterRegion(customShader?: GLShader | undefined): void;
-    protected initializeForNextRender(): void;
-}
-declare const spriteAttributes: ({
-    name: string;
-    size: number;
-    type: number;
-    stride: number;
-    offset?: undefined;
-    normalized?: undefined;
-} | {
-    name: string;
-    size: number;
-    type: number;
-    stride: number;
-    offset: number;
-    normalized?: undefined;
-} | {
-    name: string;
-    size: number;
-    type: number;
-    stride: number;
-    offset: number;
-    normalized: boolean;
-})[];
-export { spriteAttributes };
-export default SpriteRegion;

package/dist/webgl/glshader.d.ts

@@ -1,27 +0,0 @@
-import { IAttribute, UniformType } from "../interface";
-import Rapid from "../render";
-declare class GLShader {
-    attributeLoc: Record<string, number>;
-    uniformLoc: Record<string, WebGLUniformLocation>;
-    program: WebGLProgram;
-    private gl;
-    constructor(rapid: Rapid, vs: string, fs: string);
-    /**
-     * Set the uniform of this shader
-     * @param uniforms
-     * @param usedTextureUnit How many texture units have been used
-     */
-    setUniforms(uniforms: UniformType, usedTextureUnit: number): void;
-    private getUniform;
-    /**
-     * use this shader
-     */
-    use(): void;
-    private parseShader;
-    /**
-     * Set vertex attributes in glsl shader
-     * @param element
-     */
-    setAttribute(element: IAttribute): void;
-}
-export default GLShader;

package/dist/webgl/utils.d.ts

@@ -1,27 +0,0 @@
-import { WebGLContext } from "../interface";
-/**
- * get webgl rendering context
- * @param canvas
- * @returns webgl1 or webgl2
- */
-export declare const getContext: (canvas: HTMLCanvasElement) => WebGLContext;
-/**
- * compile string to webgl shader
- * @param gl
- * @param source
- * @param type
- * @returns
- */
-export declare const compileShader: (gl: WebGLContext, source: string, type: number) => WebGLShader;
-/**
- * create webgl program by shader string
- * @param gl
- * @param vsSource
- * @param fsSource
- * @returns
- */
-export declare const createShaderProgram: (gl: WebGLContext, vsSource: string, fsSource: string) => WebGLProgram;
-export declare function createTexture(gl: WebGLRenderingContext, image: TexImageSource, antialias: boolean): WebGLTexture;
-export declare function generateFragShader(fs: string, max: number): string;
-export declare const FLOAT = 5126;
-export declare const UNSIGNED_BYTE = 5121;