rapid-render 0.1.0 → 0.1.2-1.1

package/dist/regions/attributes.d.ts

@@ -0,0 +1,44 @@
+export 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 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;
+} | {
+    name: string;
+    size: number;
+    type: number;
+    stride: number;
+    offset: number;
+    normalized?: undefined;
+})[];

package/dist/regions/graphic_region.d.ts

@@ -1,28 +1,15 @@
-import { Rapid } from "..";
+import type Rapid from "../render";
+import { Uniform } from "../webgl/uniform";
 import RenderRegion from "./region";
+import { Texture } from "../texture";
 declare class GraphicRegion extends RenderRegion {
     private vertex;
+    private texture?;
+    private offset;
     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;
+    startRender(offsetX: number, offsetY: number, texture?: Texture, uniforms?: Uniform): void;
+    addVertex(x: number, y: number, u: number, v: 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

@@ -2,24 +2,40 @@ import { IAttribute, WebGLContext } from "../interface";
 import { WebglBufferArray } from "../math";
 import Rapid from "../render";
 import GLShader from "../webgl/glshader";
+import { Uniform } from "../webgl/uniform";
 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 shaders: Map<string, GLShader>;
+    protected isCostumShader: boolean;
+    private costumUnifrom?;
+    private defaultShader?;
+    private maxTextureUnits;
+    protected freeTextureUnitNum: number;
+    constructor(rapid: Rapid);
+    getTextureUnitList(): number[];
     protected addVertex(x: number, y: number, ..._: unknown[]): void;
-    protected useTexture(texture: WebGLTexture): number;
+    /**
+     * 使用纹理，必须在渲染操作之前
+     * @param texture
+     * @returns
+     */
+    useTexture(texture: WebGLTexture): [number, boolean];
     enterRegion(customShader?: GLShader): void;
+    updateProjection(): void;
+    isUnifromChanged(newCurrentUniform?: Uniform): boolean;
+    setCurrentUniform(newCurrentUniform: Uniform): void;
     exitRegion(): void;
-    protected initDefaultShader(vs: string, fs: string): void;
+    protected initDefaultShader(vs: string, fs: string, attributes?: IAttribute[]): void;
+    setShader(name: string, vs: string, fs: string, attributes?: IAttribute[]): void;
+    getShader(name: string): GLShader | undefined;
     render(): void;
     protected executeRender(): void;
     protected initializeForNextRender(): void;
+    hasPendingContent(): boolean;
+    isShaderChanged(shader?: GLShader): boolean;
 }
 export default RenderRegion;

package/dist/regions/sprite_region.d.ts

@@ -1,39 +1,18 @@
 import RenderRegion from "./region";
 import Rapid from "../render";
-import { UniformType } from "../interface";
 import GLShader from "../webgl/glshader";
+import { Uniform } from "../webgl/uniform";
 declare class SpriteRegion extends RenderRegion {
     private batchSprite;
     private indexBuffer;
-    protected readonly MAX_BATCH: number;
+    private spriteTextureUnits;
+    private spriteTextureUnitIndexOffset;
     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;
+    renderSprite(texture: WebGLTexture, width: number, height: number, u0: number, v0: number, u1: number, v1: number, offsetX: number, offsetY: number, color: number, uniforms?: Uniform, flipX?: boolean, flipY?: boolean, additionalTexturenit?: number): void;
     protected executeRender(): void;
     enterRegion(customShader?: GLShader | undefined): void;
     protected initializeForNextRender(): void;
+    hasPendingContent(): boolean;
 }
-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/render.d.ts

@@ -1,8 +1,11 @@
-import { IGraphicOptions, IRapiadOptions, IRenderLineOptions, IRenderSpriteOptions, WebGLContext } from "./interface";
+import { ICircleRenderOptions, IGraphicRenderOptions, ILayerRenderOptions, IRapidOptions, IRectRenderOptions, IRenderLineOptions, ISpriteRenderOptions, ShaderType as ShaderType, MaskType, WebGLContext, BlendMode, ILightRenderOptions, IParticleOptions, IPolygonGraphicRenderOptions } from "./interface";
+import { LightManager } from "./light";
 import { Color, MatrixStack, Vec2 } from "./math";
 import RenderRegion from "./regions/region";
-import { Texture, TextureCache } from "./texture";
+import { FrameBufferObject, Texture, TextureCache } from "./texture";
+import { TileMapRender, TileSet } from "./tilemap";
 import GLShader from "./webgl/glshader";
+import { ParticleEmitter } from "./particle";
 /**
  * The `Rapid` class provides a WebGL-based rendering engine.
  */
@@ -12,27 +15,49 @@ declare class Rapid {
     projection: Float32Array;
     projectionDirty: boolean;
     matrixStack: MatrixStack;
-    textures: TextureCache;
+    texture: TextureCache;
+    tileMap: TileMapRender;
+    light: LightManager;
     width: number;
     height: number;
     backgroundColor: Color;
-    readonly devicePixelRatio: number;
+    devicePixelRatio: number;
+    private physicsWidth;
+    private physicsHeight;
+    logicWidth: number;
+    logicHeight: number;
+    private scaleEnable;
+    private scaleRadio;
     readonly maxTextureUnits: number;
     private readonly defaultColor;
-    private readonly defaultColorBlack;
     private currentRegion?;
     private currentRegionName?;
     private regions;
+    private currentMaskType;
+    private currentTransform;
+    private currentFBO;
+    private lastTime;
     /**
      * Constructs a new `Rapid` instance with the given options.
      * @param options - Options for initializing the `Rapid` instance.
      */
-    constructor(options: IRapiadOptions);
+    constructor(options: IRapidOptions);
+    /**
+     * @param displayWdith css px size
+     * @param displayHeight css px size
+     */
+    updateDisplaySize(displayWdith: number, displayHeight: number): void;
+    private resizeSize;
+    private updateProjection;
     /**
      * Initializes WebGL context settings.
      * @param gl - The WebGL context.
      */
     private initWebgl;
+    /**
+     * @ignore
+     */
+    clearTextureUnit(): void;
     /**
      * Registers built-in regions such as sprite and graphic regions.
      */
@@ -43,10 +68,12 @@ declare class Rapid {
      * @param regionClass - The class of the region to register.
      */
     registerRegion(name: string, regionClass: typeof RenderRegion): void;
+    private quitCurrentRegion;
     /**
      * Sets the current render region by name and optionally a custom shader.
      * @param regionName - The name of the region to set as current.
      * @param customShader - An optional custom shader to use with the region.
+     * @param hasUnifrom - have costum unifrom
      */
     setRegion(regionName: string, customShader?: GLShader): void;
     /**
@@ -57,69 +84,95 @@ declare class Rapid {
      * Restores the matrix state from the stack.
      */
     restore(): void;
+    /**
+     * Executes a callback function within a saved and restored matrix state scope.
+     * @param cb - The callback function to execute within the saved and restored matrix state scope.
+     */
+    withTransform(cb: () => void): void;
     /**
      * Starts the rendering process, resetting the matrix stack and clearing the current region.
      * @param clear - Whether to clear the matrix stack. Defaults to true.
      */
-    startRender(clear?: boolean): void;
+    startRender(clear?: boolean): number;
     /**
      * Ends the rendering process by rendering the current region.
      */
     endRender(): void;
     /**
-     * Renders a sprite with the specified texture, offset, and options.
-     * @param texture - The texture to render.
-     * @param offsetX - The X offset for the sprite. Defaults to 0.
-     * @param offsetY - The Y offset for the sprite. Defaults to 0.
-     * @param options - Rendering options including color and custom shader.
+     * Render
+     * @param cb - The function to render.
      */
-    renderSprite(texture: Texture, offsetX?: number, offsetY?: number, options?: IRenderSpriteOptions | Color): void;
+    render(cb: (dt: number) => void): void;
     /**
-     * Renders a line with the specified options.
+     * Render a tile map layer.
+     * @param data - The map data to render.
+     * @param options - The options for rendering the tile map layer.
+     */
+    renderTileMapLayer(data: (number | string)[][], options: ILayerRenderOptions | TileSet): void;
+    /**
+     * Renders a sprite with the specified options.
      *
-     * @param offsetX - The X offset to apply when rendering the line. Defaults to 0.
-     * @param offsetY - The Y offset to apply when rendering the line. Defaults to 0.
-     * @param options - The options for rendering the line, including points and color.
+     * @param options - The rendering options for the sprite, including texture, position, color, and shader.
      */
-    renderLine(offsetX: number | undefined, offsetY: number | undefined, options: IRenderLineOptions): void;
+    renderSprite(options: ISpriteRenderOptions): void;
+    renderParticles(particleEmitter: ParticleEmitter): void;
     /**
-     * Renders graphics based on the provided options or array of Vec2 points.
+     * Renders a texture directly without additional options.
+     * This is a convenience method that calls renderSprite with just the texture.
      *
-     * @param offsetX - The X offset to apply when rendering the graphics. Defaults to 0.
-     * @param offsetY - The Y offset to apply when rendering the graphics. Defaults to 0.
-     * @param options - Either an object containing graphic options or an array of Vec2 points.
+     * @param texture - The texture to render at the current transformation position.
+     */
+    renderTexture(texture: Texture): void;
+    /**
+     * Renders a line with the specified options.
      *
-     * @remarks
-     * If `options` is an array of `Vec2`, it will be converted to an object with `points` property.
-     * If `options` is an object, it should contain `points` (array of `Vec2`) and optionally `color` and `drawType`.
+     * @param options - The options for rendering the line, including points, color, width, and join/cap types.
      */
-    renderGraphic(offsetX: number | undefined, offsetY: number | undefined, options: IGraphicOptions | Vec2[]): void;
+    renderLine(options: IRenderLineOptions): void;
     /**
-     * Starts a graphic drawing process with an optional custom shader.
-     * @param customShader - An optional custom shader to use.
+     * Renders graphics based on the provided options.
+     *
+     * @param options - The options for rendering the graphic, including points, color, texture, and draw type.
+     */
+    renderGraphic(options: IPolygonGraphicRenderOptions): void;
+    /**
+     * Starts the graphic drawing process.
+     *
+     * @param options - The options for the graphic drawing, including shader, texture, and draw type.
      */
-    startGraphicDraw(customShader?: GLShader): void;
+    startGraphicDraw(options: IGraphicRenderOptions): void;
     /**
-     * Adds a vertex to the current graphic drawing with a specified position and color.
-     * @param x - The X position of the vertex.
-     * @param y - The Y position of the vertex.
-     * @param color - The color of the vertex.
+     * Adds a vertex to the current graphic being drawn.
+     *
+     * @param offsetX - The X coordinate of the vertex.
+     * @param offsetY - The Y coordinate of the vertex.
+     * @param uv - The texture UV coordinates for the vertex.
+     * @param color - The color of the vertex. Defaults to the renderer's default color.
      */
-    addGraphicVertex(x: number | Vec2, y?: number | Color, color?: Color): void;
+    addGraphicVertex(offsetX: number, offsetY: number, uv: Vec2, color?: Color): void;
     /**
-     * Ends the graphic drawing process by rendering the current graphic region.
+     * Completes the graphic drawing process and renders the result.
      */
     endGraphicDraw(): void;
+    private startDraw;
+    private afterDraw;
     /**
-     * Resizes the canvas and updates the viewport and projection matrix.
-     * @param width - The new width of the canvas.
-     * @param height - The new height of the canvas.
+     * Renders a rectangle with the specified options.
+     *
+     * @param options - The options for rendering the rectangle, including width, height, position, and color.
+     */
+    renderRect(options: IRectRenderOptions): void;
+    /**
+     * Renders a circle with the specified options.
+     *
+     * @param options - The options for rendering the circle, including radius, position, color, and segment count.
      */
-    resize(width: number, height: number): void;
+    renderCircle(options: ICircleRenderOptions): void;
     /**
      * Clears the canvas with the background color.
+     * @param bgColor - The background color to clear the canvas with.
      */
-    clear(): void;
+    clear(bgColor?: Color): void;
     /**
      * Creates an orthogonal projection matrix.
      * @param left - The left bound of the projection.
@@ -130,11 +183,72 @@ declare class Rapid {
      */
     private createOrthMatrix;
     /**
-     * Transforms a point by applying the current matrix stack.
-     * @param x - The X coordinate of the point.
-     * @param y - The Y coordinate of the point.
-     * @returns The transformed point as an array `[newX, newY]`.
+     * Draw a mask. Automatically calls startDrawMask.
+     * @param type - The type of mask to draw.
+     * @param cb - The callback function to execute.
+     */
+    drawMask(type: MaskType | undefined, cb: () => void): void;
+    /**
+     * Start drawing a mask using the stencil buffer.
+     * This method configures the WebGL context to begin defining a mask area.
+     */
+    startDrawMask(type?: MaskType): void;
+    /**
+     * End the mask drawing process.
+     * This method configures the WebGL context to use the defined mask for subsequent rendering.
+     */
+    endDrawMask(): void;
+    /**
+     * Set the mask type for rendering
+     * @param type - The mask type to apply
+     * @param start - Whether this is the start of mask drawing
+     */
+    private setMaskType;
+    /**
+     * Clear the current mask by clearing the stencil buffer.
+     * This effectively removes any previously defined mask.
+     */
+    clearMask(): void;
+    /**
+     * Creates a custom shader.
+     * @param vs - Vertex shader code.
+     * @param fs - Fragment shader code.
+     * @param type - Shader type.
+     * @returns The created shader object.
+     */
+    createCostumShader(vs: string, fs: string, type: ShaderType, textureUnitNum?: number): GLShader;
+    /**
+     * Starts rendering to a Frame Buffer Object (FBO)
+     * Sets up the FBO for rendering by binding it, adjusting viewport size and projection
+     * @param fbo - The Frame Buffer Object to render to
+     */
+    startFBO(fbo: FrameBufferObject): void;
+    /**
+     * Ends rendering to a Frame Buffer Object
+     * Restores the default framebuffer and original viewport settings
+     * @param fbo - The Frame Buffer Object to unbind
+     */
+    endFBO(): void;
+    /**
+     * Convenience method to render to a Frame Buffer Object
+     * Handles starting and ending the FBO rendering automatically
+     * @param fbo - The Frame Buffer Object to render to
+     * @param cb - Callback function containing render commands to execute on the FBO
+     */
+    drawToFBO(fbo: FrameBufferObject, cb: () => void): void;
+    /**
+     * Set the blend mode for rendering
+     * @param mode - The blend mode to apply
+     */
+    setBlendMode(mode: BlendMode): void;
+    /**
+     * Render light shadow
+     * @param occlusion - The occlusion polygon
+     * @param lightSource - The light source position
      */
-    transformPoint(x: number, y: number): number[] | Vec2;
+    drawLightShadowMask(options: ILightRenderOptions): void;
+    createParticleEmitter(options: IParticleOptions): ParticleEmitter;
+    cssToGameCoords(x: number | Vec2, y?: number): Vec2;
+    gameToCssCoords(x: number | Vec2, y?: number): Vec2;
 }
 export default Rapid;

package/dist/texture.d.ts

@@ -1,12 +1,14 @@
 import Rapid from "./render";
-import { Images, ITextOptions } from "./interface";
+import { Images, ITextTextureOptions, TextureWrapMode, WebGLContext } from "./interface";
 /**
  * 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 +16,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 +64,15 @@ 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;
+    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 {
     /**
@@ -79,7 +125,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.
@@ -89,13 +135,22 @@ declare class Texture {
      */
     static fromImageSource(rapid: Rapid, image: Images, antialias?: boolean): 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;
 }
+/**
+ * @ignore
+ */
 export declare const SCALEFACTOR = 2;
 declare class Text extends Texture {
     private options;
@@ -106,8 +161,12 @@ declare class Text extends Texture {
      * 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;
+    /**
+     * Creates a canvas element for rendering text.
+     * @returns HTMLCanvasElement - The created canvas element.
+     */
     private createTextCanvas;
     /**
      * Update the displayed text
@@ -115,4 +174,37 @@ declare class Text extends Texture {
      */
     setText(text: string): void;
 }
-export { Text, Texture, BaseTexture, TextureCache };
+declare class FrameBufferObject extends BaseTexture {
+    private framebuffer;
+    private gl;
+    /**
+     * 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(): 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 };