rapid-render 0.1.2 → 0.1.4

package/dist/tilemap.d.ts

@@ -1,24 +1,97 @@
-import { TilemapOptions } from "./interface";
 import Rapid from "./render";
+import { IRegisterTileOptions, ILayerRender } from "./interface";
 import { Texture } from "./texture";
-export declare class Tileset {
+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;
-    constructor(textures: Texture[]);
-    getTexture(index: number): Texture | null;
+    /** 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;
 }
-declare class Tilemap {
-    private tileset;
-    private tileIndices;
-    private tileWidth;
-    private tileHeight;
-    private columns;
-    private rows;
-    private type;
-    constructor(options: TilemapOptions);
-    getTileIndex(x: number, y: number): number | null;
-    render(rapid: Rapid, offsetX?: number, offsetY?: number): void;
-    private renderOrthogonal;
-    private renderHex;
-    private renderIsometric;
+/**
+ * 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);
+    /**
+     * Gets the y-sorted rows for rendering entities at specific y positions.
+     * @param ySortRow - Array of y-sort callbacks to process.
+     * @param height - Height of each tile.
+     * @param renderRow - Number of rows to render.
+     * @returns Array of y-sort callbacks grouped by 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;
+    /**
+     * 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 a row of y-sorted entities.
+     * @param rapid - The Rapid rendering instance.
+     * @param ySortRow - Array of y-sort callbacks to render.
+     * @private
+     */
+    private renderYSortRow;
+    /**
+     * 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: ILayerRender): 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: ILayerRender): 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: ILayerRender): Vec2;
 }
-export default Tilemap;

package/dist/utils.d.ts

@@ -0,0 +1 @@
+export declare const getSize: (obj: any) => number;

package/dist/webgl/glshader.d.ts

@@ -1,17 +1,20 @@
-import { IAttribute, UniformType } from "../interface";
+import { IAttribute, ShaderType } from "../interface";
 import Rapid from "../render";
+import { Uniform } from "./uniform";
 declare class GLShader {
     attributeLoc: Record<string, number>;
     uniformLoc: Record<string, WebGLUniformLocation>;
     program: WebGLProgram;
+    private attributes;
     private gl;
-    constructor(rapid: Rapid, vs: string, fs: string);
+    usedTexture: number;
+    constructor(rapid: Rapid, vs: string, fs: string, attributes?: IAttribute[], usedTexture?: 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, usedTextureUnit: number): number;
     private getUniform;
     /**
      * use this shader
@@ -19,9 +22,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, usedTexture?: number): GLShader;
 }
 export default GLShader;

package/dist/webgl/uniform.d.ts

@@ -0,0 +1,13 @@
+import { UniformType, WebGLContext } from '../interface';
+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, usedTextureUnit: number): number;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rapid-render",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "type": "module",
   "files": [
     "dist"