rapid-render 0.1.0 → 0.1.2-1.1

package/dist/tilemap.d.ts

@@ -0,0 +1,98 @@
+import Rapid from "./render";
+import { IRegisterTileOptions, ILayerRenderOptions } from "./interface";
+import { Texture } from "./texture";
+import { Vec2 } from "./math";
+/**
+ * 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);
+    /**
+     * 将需要 y-sort 的回调根据它们的 y 坐标分组到一个 Map 中。
+     * 使用 Map 是为了避免因地图坐标过大而创建稀疏数组，从而优化内存使用。
+     *
+     * @param ySortCallbacks - Array of y-sort callbacks to process.
+     * @param height - The effective height of a tile row, used for grouping.
+     * @returns A Map where keys are row indices (y) and values are arrays of y-sort callbacks for that row.
+     * @private
+     */
+    private getYSortRow;
+    /**
+     * 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;
+    /**
+     * Renders a row of y-sorted entities.
+     * @param rapid - The Rapid rendering instance.
+     * @param ySortRow - Array of y-sort callbacks to render.
+     * @private
+     */
+    private renderYSortRow;
+    /**
+     * 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.
+     *
+     * @param data - A 2D array representing the tilemap data.
+     * @param options - The rendering options for the tilemap layer.
+     * @returns
+     */
+    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;
+}

package/dist/utils.d.ts

@@ -0,0 +1,106 @@
+import 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/dist/webgl/glshader.d.ts

@@ -1,17 +1,21 @@
-import { IAttribute, UniformType } from "../interface";
+import { IAttribute, ShaderType } from "../interface";
 import Rapid from "../render";
+import { Uniform } from "./uniform";
+import RenderRegion from "../regions/region";
 declare class GLShader {
     attributeLoc: Record<string, number>;
     uniformLoc: Record<string, WebGLUniformLocation>;
     program: WebGLProgram;
+    textureUnitNum: number;
+    private attributes;
     private gl;
-    constructor(rapid: Rapid, vs: string, fs: string);
+    constructor(rapid: Rapid, vs: string, fs: string, attributes?: IAttribute[], textureUnitNum?: number);
     /**
      * Set the uniform of this shader
      * @param uniforms
      * @param usedTextureUnit How many texture units have been used
      */
-    setUniforms(uniforms: UniformType, usedTextureUnit: number): void;
+    setUniforms(uniform: Uniform, region: RenderRegion): void;
     private getUniform;
     /**
      * use this shader
@@ -19,9 +23,16 @@ declare class GLShader {
     use(): void;
     private parseShader;
     /**
-     * Set vertex attributes in glsl shader
+     * Set vertex attribute in glsl shader
      * @param element
      */
     setAttribute(element: IAttribute): void;
+    /**
+     * Set vertex attributes in glsl shader
+     * @param elements
+     */
+    setAttributes(elements: IAttribute[]): void;
+    updateAttributes(): void;
+    static createCostumShader(rapid: Rapid, vs: string, fs: string, type: ShaderType, textureUnitNum?: number): GLShader;
 }
 export default GLShader;

package/dist/webgl/uniform.d.ts

@@ -0,0 +1,14 @@
+import { UniformType, WebGLContext } from '../interface';
+import RenderRegion from '../regions/region';
+export declare class Uniform {
+    private data;
+    isDirty: boolean;
+    constructor(data: UniformType);
+    setUniform(key: string, data: UniformType[string]): void;
+    /**
+     * @ignore
+     */
+    clearDirty(): void;
+    getUnifromNames(): string[];
+    bind(gl: WebGLContext, uniformName: string, loc: WebGLUniformLocation, region: RenderRegion): void;
+}

package/dist/webgl/utils.d.ts

@@ -21,7 +21,17 @@ export declare const compileShader: (gl: WebGLContext, source: string, type: num
  * @returns
  */
 export declare const createShaderProgram: (gl: WebGLContext, vsSource: string, fsSource: string) => WebGLProgram;
-export declare function createTexture(gl: WebGLRenderingContext, image: TexImageSource, antialias: boolean): WebGLTexture;
+/**
+ * Creates a WebGL texture either from an image source or as a blank texture
+ * @param gl - The WebGL rendering context
+ * @param source - The image source or dimensions for a blank texture
+ * @param antialias - Whether to enable antialiasing
+ * @returns A WebGL texture
+ */
+export declare function createTexture(gl: WebGLContext, source: TexImageSource | {
+    width: number;
+    height: number;
+}, antialias: boolean, withSize?: boolean, flipY?: boolean, wrapMode?: 'repeat' | 'mirror' | 'clamp'): WebGLTexture;
 export declare function generateFragShader(fs: string, max: number): string;
 export declare const FLOAT = 5126;
 export declare const UNSIGNED_BYTE = 5121;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rapid-render",
-  "version": "0.1.0",
+  "version": "0.1.21.1",
   "type": "module",
   "files": [
     "dist"
@@ -14,22 +14,28 @@
     "require": "./dist/rapid.umd.cjs"
   },
   "scripts": {
-    "dev": "rollup -c rollup.config.dev.js -w",
+    "dev:build": "rollup -c rollup.config.dev.js -w",
+    "dev:serve": "node ./scripts/dev-server.js",
+    "dev": "concurrently \"npm run dev:build\" \"npm run dev:serve\"",
     "build": "rollup -c rollup.config.prod.js && tsc",
     "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",
+    "typedoc-theme-category-nav": "^0.0.3",
     "typescript": "^5.3.3"
   },
   "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"
   }
 }