rapid-render 0.1.2 → 0.1.4

package/README.md

@@ -1,128 +1,64 @@
-# 🚀 Rapid.js
+# Rapid.js
 
-A highly efficient and lightweight WebGL renderer
+A highly efficient [stress-test](https://nightre.github.io/Rapid.js/docs/examples.htm) and lightweight WebGL-based 2D rendering engine focused on rendering capabilities.
 
-## [API Docs](https://nightre.github.io/Rapid.js/docs/)
+### [Website](https://nightre.github.io/Rapid.js/docs/index.html)
 
-[stress test demo](https://nightre.github.io/Rapid.js/demo/) ( [source code](./demo/index.js) )
+#### [Document](https://nightre.github.io/Rapid.js/docs/docs.html) | [API Docs](https://nightre.github.io/Rapid.js/docs/api/index.html) | [Examples](https://nightre.github.io/Rapid.js/docs/examples.html)
 
-[render demo](https://nightre.github.io/Rapid.js/demo/matrix_stack.html) ( [source code](./demo/matrix_stack.js) )
+## Features
 
-[custom shader demo](https://nightre.github.io/Rapid.js/demo/custom-shader.html) ( [source code](./demo/custom-shader.js) )
-
-[mask demo](https://nightre.github.io/Rapid.js/demo/mask.html) ( [source code](./demo/mask.js) )
-
-
-# Features
-* **Fast Rendering**: Render 10,000 sprites at 60fps
-* **Multi-Texture Support**: Batch rendering using GPU's maximum texture units
+* **Fast Rendering**
+* **TileMap** - YSort, isometric
 * **Graphics Drawing**
-* **Matrix Stack**
 * **Text Rendering**
 * **Line Drawing**
 * **Custom Shaders**
-* **Texture Clipping**
 * **Mask**
 
-# Install
+## Install
 
-```
+```bash
 npm i rapid-render
 ```
 
-Or use unpkg
+Or via CDN:
 
 ```html
 <script src="https://unpkg.com/rapid-render/dist/rapid.umd.cjs"></script>
 ```
 
-# Import
+## Quick Start
 
 ```js
-import { Rapid } from "rapid-render"
+import { Rapid, Color, Vec2 } from "rapid-render"
+
+// Initialize
+const rapid = new Rapid({
+    canvas: document.getElementById("gameCanvas"),
+    backgroundColor: Color.fromHex("E6F0FF")
+})
+
+// Render example
+rapid.render(() => {
+    rapid.renderRect({ 
+        offset: new Vec2(100, 100), 
+        width: 50, 
+        height: 50, 
+        color: Color.Red 
+    })
+})
 ```
 
-# Useage
-
-```js
-let rapid = new Rapid({
-    canvas: document.getElementById("game"),
-    backgroundColor: Color.fromHex("FFFFFF")
-});
-
-// Create texture
-const cat = await rapid.textures.textureFromUrl("./cat.png");
-//                      R   G   B   A
-const color = new Color(255, 255, 255, 255); // Or use Color.fromHex
-
-// Call before rendering
-rapid.startRender();
-
-// Render here...
+For more examples and detailed documentation, visit our [website](https://nightre.github.io/Rapid.js/docs/index.html).
 
-// Call after rendering
-rapid.endRender();
+## Roadmap
 
-// Set canvas size
-rapid.resize(100, 100);
-```
-
-# Render
+* Frame Buffer Object (FBO)
+* Light System
+* Line Texture
+* Particle System
 
-```js
-const text = rapid.textures.createText({ text: "Hello!", fontSize: 30 })
-
-rapid.save() // Save state
-rapid.matrixStack.translate(0,0)
-rapid.matrixStack.scale(1)
-rapid.matrixStack.rotate(0)
-
-// Render Sprit
-rapid.renderSprite(cat, 0, 0, color) // or rapid.renderSprite(cat, 0, 0, { color })
-
-// Rendr Graphic
-const path = Vec2.FormArray([[0, 0], [100, 0], [100, 100]])
-rapid.renderGraphic(0,0,{points:path, color:green})
-// or
-// rapid.startGraphicDraw()
-// rapid.addGraphicVertex(0, 0, color)
-// rapid.endGraphicDraw()
-
-// Render Text
-rapid.renderSprite(text, 200, 0)
-text.setText("time:" + Math.round(time))
-
-rapid.restore() // back to the previous saved state
-```
-
-# Custom Shader
-
-View demo and watch detailed shader code [custom shader demo](https://nightre.github.io/Rapid.js/demo/custom-shader.html) ( [source code](./demo/custom-shader.js) )
-
-```js
-const vertexShaderSource = `...`
-const fragmentShaderSource = `...`
-
-const customShader = new GLShader(rapid, vertexShaderSource, fragmentShaderSource)
-rapid.startRender()
-
-rapid.renderSprite(plane, 100, 100, {
-    shader: customShader, // shader
-    uniforms: {
-        // Set custom uniform (You can set mat3, vec2, and so on here)
-        uCustomUniform: Number(costumUniformValue)
-        //  uVec2Uniform: [0,2] // recognized as vec2
-        //  uMat3Uniform: [
-        //     [0,0,0],
-        //     [0,0,0],
-        //     [0,0,0],
-        //  ]
-        // recognized as mat3
-    }
-});
-
-rapid.endRender()
-```
-# Screen Shot
+## Contributing
 
-![screen](./screenshot/screen.png)
+Issues and PRs are welcome!

package/dist/depth.d.ts

@@ -0,0 +1,8 @@
+declare class DepthScaler {
+    private max;
+    private min;
+    constructor();
+    getDepth(depth?: number): number | undefined;
+}
+declare const _default: DepthScaler;
+export default _default;

package/dist/index.d.ts

@@ -1,9 +1,10 @@
-import { graphicAttributes } from "./regions/graphic_region";
-import { spriteAttributes } from "./regions/sprite_region";
 import Rapid from "./render";
 import GLShader from "./webgl/glshader";
 import { Text } from "./texture";
-export { Text, Rapid, GLShader, spriteAttributes, graphicAttributes, };
+import { TileMapRender, TileSet } from "./tilemap";
+import { Uniform } from "./webgl/uniform";
+import { spriteAttributes, graphicAttributes } from "./regions/attributes";
+export { Text, Rapid, GLShader, TileMapRender, TileSet, Uniform, graphicAttributes, spriteAttributes, };
 export * from "./math";
 export * from "./interface";
 export * from "./texture";

package/dist/interface.d.ts

@@ -1,13 +1,26 @@
 import { Color, Vec2 } from "./math";
 import { Texture } from "./texture";
+import { TileSet } from "./tilemap";
 import GLShader from "./webgl/glshader";
+import { Uniform } from "./webgl/uniform";
+/**
+ * @ignore
+ */
 export type WebGLContext = WebGL2RenderingContext | WebGLRenderingContext;
-export interface IRapiadOptions {
+/**
+ * @ignore
+ */
+export interface IMathStruct<T> {
+    clone(obj: T): T;
+    copy(obj: T): void;
+    equal(obj: T): boolean;
+}
+export interface IRapidOptions {
     canvas: HTMLCanvasElement;
-    pixelDensity?: number;
     width?: number;
     height?: number;
     backgroundColor?: Color;
+    antialias?: boolean;
 }
 export interface IAttribute {
     name: string;
@@ -17,16 +30,33 @@ export interface IAttribute {
     stride: number;
     offset?: number;
 }
-export interface IRenderSpriteOptions {
+export interface ITransform {
+    position?: Vec2;
+    scale?: Vec2 | number;
+    rotation?: number;
+    flipX?: boolean;
+    flipY?: boolean;
+    offset?: Vec2;
+    x?: number;
+    y?: number;
+    offsetX?: number;
+    offsetY?: number;
+    origin?: Vec2 | number;
+    restoreTransform?: boolean;
+    saveTransform?: boolean;
+    afterSave?(): unknown;
+    beforRestore?(): unknown;
+}
+export interface IRenderSpriteOptions extends ITransform, IShader {
     color?: Color;
-    shader?: GLShader;
-    uniforms?: UniformType;
+    texture?: Texture;
+    offset?: Vec2;
 }
 export interface ITextOptions {
     /**
      * The text string to be rendered.
      */
-    text: string;
+    text?: string;
     /**
      * The font size for the text.
      * Default is 16.
@@ -54,47 +84,66 @@ export interface ITextOptions {
      * Default is 'top'.
      */
     textBaseline?: CanvasTextBaseline;
-    /**
-     * Whether to apply antialiasing to the texture.
-     * Default is `false`.
-     */
-    antialias?: boolean;
-}
-export declare enum JoinTyps {
-    BEVEL = 0,
-    ROUND = 1,
-    MITER = 2
-}
-export declare enum CapTyps {
-    BUTT = 0,
-    ROUND = 1,
-    SQUARE = 2
 }
 export interface ILineOptions {
-    cap?: CapTyps;
-    join?: JoinTyps;
     width?: number;
-    miterLimit?: number;
-}
-export interface IRenderLineOptions extends ILineOptions {
+    closed?: boolean;
     points: Vec2[];
+    roundCap?: boolean;
     color?: Color;
 }
-export interface IGraphicOptions {
+export interface IRenderLineOptions extends ILineOptions, ITransform {
+}
+export interface IGraphicOptions extends ITransform, IShader {
     points: Vec2[];
     color?: Color | Color[];
     drawType?: number;
     uv?: Vec2[];
     texture?: Texture;
-    shader?: GLShader;
 }
-export declare enum RenderStatus {
-    NORMAL = 0,
-    MASK = 1
+export interface ICircleOptions extends IGraphicOptions {
+    radius: number;
+    segments?: number;
+}
+export interface IRectOptions extends IGraphicOptions {
+    width: number;
+    height: number;
 }
 export declare enum MaskType {
-    Normal = "normal",
-    Inverse = "inverse"
+    Include = "normal",
+    Exclude = "inverse"
 }
-export type UniformType = Record<string, number | Array<any> | boolean>;
+export type UniformType = Record<string, number | Array<any> | boolean | Texture>;
 export type Images = ImageBitmap | ImageData | HTMLImageElement | HTMLCanvasElement | HTMLVideoElement | OffscreenCanvas;
+export interface IRegisterTileOptions extends IRenderSpriteOptions {
+    texture: Texture;
+    offsetX?: number;
+    offsetY?: number;
+    ySortOffset?: number;
+}
+export interface YSortCallback {
+    ySort: number;
+    render?: () => void;
+    renderSprite?: IRenderSpriteOptions;
+}
+export interface ILayerRender extends ITransform {
+    error?: number | Vec2;
+    errorX?: number;
+    errorY?: number;
+    ySortCallback?: Array<YSortCallback>;
+    shape?: TilemapShape;
+    tileSet: TileSet;
+    eachTile?: (tileId: string | number, mapX: number, mapY: number) => IRenderSpriteOptions | undefined | void;
+}
+export interface IShader {
+    shader?: GLShader;
+    uniforms?: Uniform;
+}
+export declare enum TilemapShape {
+    SQUARE = "square",
+    ISOMETRIC = "isometric"
+}
+export declare enum ShaderType {
+    SPRITE = "sprite",
+    GRAPHIC = "graphic"
+}

package/dist/line.d.ts

@@ -1,3 +1,10 @@
 import { ILineOptions } from "./interface";
 import { Vec2 } from "./math";
-export declare const getStrokeGeometry: (points: Vec2[], attrs: ILineOptions) => Vec2[];
+/**
+ * @ignore
+ */
+export declare const getLineNormal: (points: Vec2[], closed?: boolean) => {
+    normal: Vec2;
+    miters: number;
+}[];
+export declare const getLineGeometry: (options: ILineOptions) => Vec2[];

package/dist/log.d.ts

@@ -0,0 +1,2 @@
+declare const warn: (text: string) => void;
+export default warn;