rapid-render 1.0.6 → 1.0.8

package/README.md

@@ -24,8 +24,8 @@ Rapid is a focused WebGL 2D rendering engine for games and visual tools. lightwe
 
 ## Highlights
 
-- **Automatic batching**  
-  Rapid automatically batches compatible draw work. Multi-texture batching binds different textures into a single draw call, eliminating manual grouping.
+- **Rendering speed**  
+  An efficient batching system significantly reduces draw calls, allowing Rapid.js to maintain smooth, stable performance even when rendering large numbers of sprites at once.
 
 - **Powerful custom shaders**  
   Add sprite and geometry effects through shader hooks while still using Rapid's normal renderer, transforms, textures, and draw APIs.
@@ -68,7 +68,6 @@ Performance Comparison: Rapid vs. Other Renderers and Game Engines
 <p align="center">
   <a href="https://nightre.github.io/Rapid.js/benchmark/">
     <img src="./docs/benchmark/benchmark.png" alt="Benchmark Result">
-    <img src="./docs/benchmark/benchmark2.png" alt="Benchmark Result">
   </a>
 </p>
 

package/dist/buffer.d.ts

@@ -49,6 +49,7 @@ export declare class DynamicArrayBuffer {
      * Resets the element usage count to zero. The underlying memory capacity is preserved.
      */
     clear(): void;
+    static removeAtIndices(indices: number[], targets: DynamicArrayBuffer[]): number;
     /**
      * Checks if the buffer has enough space for additional elements and resizes the buffer if necessary.
      * @param size - The number of new elements that need to be accommodated.

package/dist/color.d.ts

@@ -104,6 +104,8 @@ export declare class Color {
     static FromHSL(h: number, s: number, l: number): Color;
     static FromRGB(r: number, g: number, b: number): Color;
     static fromNorm(r: number, g: number, b: number, a?: number): Color;
+    static clampColorByte(value: number): number;
+    static packColor(r: number, g: number, b: number, a: number, premultipliedAlpha: boolean): number;
     /**
      * Creates a Color instance from a hexadecimal color string.
      * @param hexString - The hexadecimal color string, e.g., '#RRGGBB' or '#RRGGBBAA'.

package/dist/draw.d.ts

@@ -10,25 +10,26 @@ export type DrawPoint = Vec2 | {
     x: number;
     y: number;
 };
-export interface IDrawOptions extends ITransformOptions {
+export interface IDrawOptions extends ITransformOptions, IDisplayOptions {
+}
+export interface IDisplayOptions {
     shader?: DrawShader;
     customMatrix?: number;
 }
-export interface IDrawParticleBatchOptions {
-    shader?: DrawShader;
+export interface IDrawParticleBatchOptions extends IDisplayOptions {
     texture: Texture;
-    x: Array<number>;
-    y: Array<number>;
-    rotation: Array<number>;
-    color: Array<Color>;
+    x: ArrayLike<number>;
+    y: ArrayLike<number>;
+    rotation?: ArrayLike<number> | number;
+    color?: ArrayLike<Color> | ArrayLike<number> | number;
     count?: number;
-    scaleX?: number;
-    scaleY?: number;
+    scaleX?: ArrayLike<number>;
+    scaleY?: ArrayLike<number>;
     originX?: number;
     originY?: number;
     flipX?: boolean;
     flipY?: boolean;
-    isRotated?: boolean;
+    reverseOrder?: boolean;
 }
 export interface ISpriteOptions extends IDrawOptions {
     texture: Texture;
@@ -60,7 +61,7 @@ export interface ICircleOptions extends IDrawOptions {
     color?: Color;
     segments?: number;
 }
-export declare const drawSpriteRaw: (rapid: Rapid, options: ISpriteOptions) => void;
+export declare const getColorUint32: (premultipliedAlpha: boolean, color?: Color) => number;
 export declare const drawSprite: (rapid: Rapid, options: ISpriteOptions) => void;
 export declare const drawParticles: (rapid: Rapid, options: IDrawParticleBatchOptions) => void;
 export declare const drawGraphic: (rapid: Rapid, options: IGraphicOptions) => void;

package/dist/matrix-engine.d.ts

@@ -3,9 +3,7 @@ import { Vec2 } from './math';
 import { Rapid } from './render';
 export interface ITransformOptions {
     /** Whether to push a save before applying transforms. Default: true. */
-    saveTransform?: boolean;
-    /** Called immediately after the save (if any). */
-    afterSave?: () => void;
+    modifyStack?: boolean;
     x?: number;
     y?: number;
     position?: Vec2;
@@ -28,6 +26,7 @@ export declare class MatrixStore {
     buffer: DynamicArrayBuffer;
     /** The raw floating-point data of all matrices. */
     data: Float32Array;
+    temporary: number;
     /**
      * Creates a new MatrixStore.
      * @param capacity - The initial capacity of the matrix store (default is 10).
@@ -203,6 +202,7 @@ export declare class MatrixStore {
      */
     setMatrix(index: number, f: Float32Array | number[]): void;
     multiplyAffineInPlace(index: number, a: number, b: number, c: number, dValue: number, tx: number, ty: number): void;
+    multiplyAffine(indexIn: number, indexOut: number, a: number, b: number, c: number, dValue: number, tx: number, ty: number): void;
 }
 /**
  * A highly performant MatrixStack useful for hierarchal scene graphs.
@@ -355,7 +355,7 @@ export declare class MatrixStack {
     };
     /**
      * Applies a transform options object to the current matrix state.
-     * Optionally saves the matrix first (saveTransform defaults to true).
+     * Optionally saves the matrix first
      */
-    applyTransform(transform: ITransformOptions, width?: number, height?: number): void;
+    applyTransform(transform: ITransformOptions, width?: number, height?: number, customMatrix?: number): void;
 }

package/dist/particle.d.ts

@@ -2,12 +2,13 @@ import { Color } from './color';
 import { Vec2 } from './math';
 import { Rapid } from './render';
 import { Texture } from './texture';
-export type ParticleAttributeTypes = number | Vec2 | Color;
+import { DynamicArrayBuffer } from './buffer';
+import { CustomGlShader } from './webgl/glshader';
 /**
  * Describes an animated attribute: it transitions from `start` to `end`
  * over the particle's lifetime, optionally with a per-second damping factor.
  */
-export interface ParticleAttribute<T extends ParticleAttributeTypes> {
+export interface ParticleAttribute<T = number> {
     /** Starting value (scalar, range tuple, or fixed value). */
     start?: T | [T, T];
     /** Ending value. Defaults to `start` if omitted (no change over time). */
@@ -24,7 +25,7 @@ export interface ParticleAttribute<T extends ParticleAttributeTypes> {
     delta?: T;
 }
 /** Internal resolved state of one animated attribute. */
-export interface ParticleAttributeData<T extends ParticleAttributeTypes> {
+export interface ParticleAttributeData<T = number> {
     value: T;
     delta?: T;
     damping?: number;
@@ -48,7 +49,8 @@ export interface IParticleAnimation {
 }
 export interface IParticleOptions {
     /** Texture(s) to pick from. Pass a weighted tuple `[Texture, weight][]` for weighted random. */
-    texture: Texture | Texture[] | [Texture, number][];
+    texture: Texture;
+    shader: CustomGlShader;
     /** Particle lifetime in seconds, or a [min, max] range. */
     life: number | [number, number];
     /** Animation / per-attribute configuration. */
@@ -73,37 +75,22 @@ export interface IParticleOptions {
     emitTime?: number;
     /** Whether particles are positioned relative to the emitter (default: true). */
     localSpace?: boolean;
-    /** World-space position of the emitter (used when localSpace is false). */
-    position?: Vec2;
     origin?: Vec2;
 }
-export declare class Particle {
-    private life;
-    private maxLife;
-    private texture;
-    private options;
-    private position;
-    private datas;
-    private rapid;
-    constructor(rapid: Rapid, options: IParticleOptions);
-    private processAttribute;
-    private updateNumberAttribute;
-    private updateVec2Attribute;
-    private updateColorAttribute;
-    private updateAttributes;
-    private getDelta;
-    /**
-     * Updates particle state.
-     * @param deltaTime - Seconds elapsed since last frame
-     * @returns `true` while the particle is alive, `false` when it should be removed
-     */
-    update(deltaTime: number): boolean;
-    /**
-     * Renders the particle using the Rapid engine's matrixStack + drawSprite.
-     * The emitter is responsible for calling save/restore around a batch of particles.
-     */
-    render(): void;
-    private initializePosition;
+type ParticleAttributeValue = number | Vec2 | Color;
+declare class ParticleAttributeStore {
+    readonly components: {
+        value: DynamicArrayBuffer;
+        delta: DynamicArrayBuffer;
+        damping: DynamicArrayBuffer;
+    }[];
+    constructor(size?: number);
+    getArrayBuffer(): DynamicArrayBuffer[];
+    update(deltaTime: number): void;
+    get(particleIndex: number, componentIndex?: number): number;
+    private getComponent;
+    private resolveComponent;
+    create<T extends ParticleAttributeValue>(attribute: ParticleAttribute<T> | T | undefined, defaultData: T, lifeTime?: number): number;
 }
 /**
  * Creates and manages a pool of Particle instances.
@@ -119,7 +106,6 @@ export declare class Particle {
  * ```
  */
 export declare class ParticleEmitter {
-    private particles;
     private options;
     private emitting;
     private emitTimer;
@@ -128,16 +114,28 @@ export declare class ParticleEmitter {
     private emitTimeCounter;
     /** Whether spawned particles are positioned in local emitter space (default: true). */
     localSpace: boolean;
-    /** World position of the emitter. Used for both local-space transform and world-space spawn offset. */
-    position: Vec2;
     private rapid;
-    gameObject?: unknown;
+    x: DynamicArrayBuffer;
+    y: DynamicArrayBuffer;
+    scaleX: DynamicArrayBuffer;
+    scaleY: DynamicArrayBuffer;
+    rotation: DynamicArrayBuffer;
+    color: DynamicArrayBuffer;
+    animations: {
+        speed: ParticleAttributeStore;
+        rotation: ParticleAttributeStore;
+        scale: ParticleAttributeStore;
+        color: ParticleAttributeStore;
+        velocity: ParticleAttributeStore;
+    };
+    count: number;
     /**
      * Creates a new particle emitter.
      * @param rapid   - The Rapid renderer instance
      * @param options - Emitter configuration options
      */
     constructor(rapid: Rapid, options: IParticleOptions);
+    getAllArrayBuffer(): DynamicArrayBuffer[];
     /** Replaces the emitter's texture at runtime. */
     setTexture(texture: Texture): void;
     /**
@@ -160,18 +158,18 @@ export declare class ParticleEmitter {
      * Respects `maxParticles` if set.
      */
     emit(count: number): void;
+    createParticle(): void;
     /**
      * Updates the emitter and all live particles.
      * @param deltaTime - Seconds elapsed since last frame
      */
     update(deltaTime: number): void;
+    updateParticle(deltaTime: number): number[];
     /**
      * Renders all live particles.
      * In local-space mode the emitter's own transform is applied around the batch.
      */
     render(): void;
-    /** Returns the current number of live particles. */
-    getParticleCount(): number;
     /** Returns `true` if the emitter is running or still has live particles. */
     isActive(): boolean;
     /**
@@ -179,3 +177,4 @@ export declare class ParticleEmitter {
      */
     oneShot(): void;
 }
+export {};