rapid-render 0.1.0 → 0.1.2-1.1

package/dist/input.d.ts

@@ -0,0 +1,93 @@
+import { Vec2 } from "./math";
+import Rapid from "./render";
+import { Entity } from "./game";
+/**
+ * Manages user input for keyboard and mouse events.
+ * Tracks key and button states, including pressed/released states for the current and previous frames.
+ */
+export declare class InputManager {
+    private rapid;
+    private canvas;
+    private mousePosition;
+    private keysDown;
+    private keysDownLastFrame;
+    private buttonsDown;
+    private buttonsDownLastFrame;
+    /**
+     * Creates an instance of InputManager.
+     * @param rapid - The Rapid instance for rendering and coordinate conversion.
+     */
+    constructor(rapid: Rapid);
+    /**
+     * Attaches all necessary event listeners for keyboard and mouse input.
+     * @private
+     */
+    private attachEventListeners;
+    /**
+     * Updates the state of keys and buttons for the next frame.
+     */
+    updateNextFrame(): void;
+    /**
+     * Checks if a key is currently pressed (continuous detection).
+     * @param key - The key code (e.g., "KeyW", "Space").
+     * @returns True if the key is pressed, false otherwise.
+     */
+    isKeyDown(key: string): boolean;
+    /**
+     * Checks if a key is currently released.
+     * @param key - The key code (e.g., "KeyW", "Space").
+     * @returns True if the key is released, false otherwise.
+     */
+    isKeyUp(key: string): boolean;
+    /**
+     * Checks if a key was pressed in the current frame (single trigger).
+     * @param key - The key code (e.g., "KeyW", "Space").
+     * @returns True if the key was just pressed, false otherwise.
+     */
+    wasKeyPressed(key: string): boolean;
+    /**
+     * Checks if a key was released in the current frame (single trigger).
+     * @param key - The key code (e.g., "KeyW", "Space").
+     * @returns True if the key was just released, false otherwise.
+     */
+    wasKeyReleased(key: string): boolean;
+    /**
+     * Checks if a mouse button is currently pressed (continuous detection).
+     * @param button - The mouse button number (0: left, 1: middle, 2: right).
+     * @returns True if the button is pressed, false otherwise.
+     */
+    isButtonDown(button: number): boolean;
+    /**
+     * Checks if a mouse button is currently released.
+     * @param button - The mouse button number (0: left, 1: middle, 2: right).
+     * @returns True if the button is released, false otherwise.
+     */
+    isButtonUp(button: number): boolean;
+    /**
+     * Checks if a mouse button was pressed in the current frame (single trigger).
+     * @param button - The mouse button number (0: left, 1: middle, 2: right).
+     * @returns True if the button was just pressed, false otherwise.
+     */
+    wasButtonPressed(button: number): boolean;
+    /**
+     * Checks if a mouse button was released in the current frame (single trigger).
+     * @param button - The mouse button number (0: left, 1: middle, 2: right).
+     * @returns True if the button was just released, false otherwise.
+     */
+    wasButtonReleased(button: number): boolean;
+    /**
+     * Converts the mouse position to local coordinates relative to an entity.
+     * @param entity - The entity to convert coordinates for.
+     * @returns The mouse position in the entity's local coordinate system.
+     */
+    getMouseLocal(entity: Entity): Vec2;
+    /**
+     * Removes all event listeners and cleans up resources.
+     */
+    destroy(): void;
+    private handleMouseMove;
+    private handleKeyDown;
+    private handleKeyUp;
+    private handleMouseDown;
+    private handleMouseUp;
+}

package/dist/interface.d.ts

@@ -1,12 +1,58 @@
+import { AudioPlayer } from "./audio";
+import { Entity } from "./game";
 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 {
+/**
+ * Defines the required mathematical operations for an object to be tweenable.
+ */
+export interface IMathObject<T> {
+    /**
+     * Creates a new object that is a copy of the current instance.
+     * @returns A new instance of the object.
+     */
+    clone(): IMathObject<T>;
+    /**
+     * Adds another object's values to this one.
+     * @param other - The object to add.
+     * @returns A new object with the result of the addition.
+     */
+    add(other: IMathObject<T>): IMathObject<T>;
+    /**
+     * Subtracts another object's values from this one.
+     * @param other - The object to subtract.
+     * @returns A new object with the result of the subtraction.
+     */
+    subtract(other: IMathObject<T>): IMathObject<T>;
+    /**
+     * Multiplies the object's values by a scalar.
+     * @param scalar - The number to multiply by.
+     * @returns A new object with the result of the multiplication.
+     */
+    multiply(scalar: number | IMathObject<T>): IMathObject<T>;
+}
+export declare enum ScaleRadio {
+    KEEP = "keep",
+    KEEP_H = "keep_h",
+    KEEP_W = "keep_w",
+    IGNORE = "ignore",
+    EXPAND = "expand"
+}
+export interface IRapidOptions {
     canvas: HTMLCanvasElement;
-    pixelDensity?: number;
     width?: number;
     height?: number;
     backgroundColor?: Color;
+    antialias?: boolean;
+    devicePixelRatio?: number;
+    scaleEnable?: boolean;
+    scaleRadio?: ScaleRadio;
 }
 export interface IAttribute {
     name: string;
@@ -16,16 +62,44 @@ export interface IAttribute {
     stride: number;
     offset?: number;
 }
-export interface IRenderSpriteOptions {
+export interface IEntityTransformOptions {
+    position?: Vec2;
+    scale?: Vec2 | number;
+    rotation?: number;
+    x?: number;
+    y?: number;
+    tags?: string[];
+}
+export interface ITilemapEntityOptions extends IEntityTransformOptions {
+    tileset: TileSet;
+}
+export interface ITransformOptions {
+    restoreTransform?: boolean;
+    saveTransform?: boolean;
+    position?: Vec2;
+    scale?: Vec2 | number;
+    rotation?: number;
+    x?: number;
+    y?: number;
+    offset?: Vec2;
+    offsetX?: number;
+    offsetY?: number;
+    origin?: Vec2 | number;
+    afterSave?(): unknown;
+    beforRestore?(): unknown;
+}
+export interface ISpriteRenderOptions extends ITransformOptions, IShaderRenderOptions {
     color?: Color;
-    shader?: GLShader;
-    uniforms?: UniformType;
+    texture?: Texture;
+    offset?: Vec2;
+    flipX?: boolean;
+    flipY?: boolean;
 }
-export interface ITextOptions {
+export interface ITextTextureOptions {
     /**
      * The text string to be rendered.
      */
-    text: string;
+    text?: string;
     /**
      * The font size for the text.
      * Default is 16.
@@ -53,36 +127,267 @@ 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 interface ILineStyleOptions extends IGraphicRenderOptions {
+    width?: number;
+    closed?: boolean;
+    roundCap?: boolean;
+    textureMode?: LineTextureMode;
+    points: Vec2[];
 }
-export declare enum CapTyps {
-    BUTT = 0,
-    ROUND = 1,
-    SQUARE = 2
+export declare enum LineTextureMode {
+    STRETCH = "stretch",
+    REPEAT = "repeat"
 }
-export interface ILineOptions {
-    cap?: CapTyps;
-    join?: JoinTyps;
-    width?: number;
-    miterLimit?: number;
+export declare enum TextureWrapMode {
+    REPEAT = "repeat",
+    CLAMP = "clamp",
+    MIRROR = "mirror"
 }
-export interface IRenderLineOptions extends ILineOptions {
-    points: Vec2[];
-    color?: Color;
+export interface IRenderLineOptions extends ILineStyleOptions, ITransformOptions {
 }
-export interface IGraphicOptions {
-    points: Vec2[];
-    color?: Color;
+export interface IGraphicRenderOptions extends ITransformOptions, IShaderRenderOptions {
+    color?: Color | Color[];
     drawType?: number;
+    uv?: Vec2[];
+    texture?: Texture;
+}
+export interface IPolygonGraphicRenderOptions extends IGraphicRenderOptions {
+    points: Vec2[];
+}
+export interface ICircleRenderOptions extends IGraphicRenderOptions {
+    radius: number;
+    segments?: number;
+}
+export interface IRectRenderOptions extends IGraphicRenderOptions {
+    width: number;
+    height: number;
 }
-export type UniformType = Record<string, number | Array<any>>;
+export declare enum MaskType {
+    Include = "normal",
+    Exclude = "inverse"
+}
+export type UniformType = Record<string, number | Array<any> | boolean | Texture>;
 export type Images = ImageBitmap | ImageData | HTMLImageElement | HTMLCanvasElement | HTMLVideoElement | OffscreenCanvas;
+export interface IRegisterTileOptions extends ISpriteRenderOptions {
+    texture: Texture;
+    offsetX?: number;
+    offsetY?: number;
+    ySortOffset?: number;
+}
+export interface YSortCallback {
+    ySort: number;
+    render?: () => void;
+    entity?: Entity;
+    renderSprite?: ISpriteRenderOptions;
+}
+export interface IEntityTilemapLayerOptions extends ITilemapLayerOptions, IEntityTransformOptions {
+}
+export interface ITilemapLayerOptions {
+    error?: number | Vec2;
+    errorX?: number;
+    errorY?: number;
+    ySortCallback?: Array<YSortCallback>;
+    shape?: TilemapShape;
+    tileSet: TileSet;
+    eachTile?: (tileId: string | number, mapX: number, mapY: number) => ISpriteRenderOptions | undefined | void;
+}
+export interface ILayerRenderOptions extends ITransformOptions, ITilemapLayerOptions {
+}
+export interface IShaderRenderOptions {
+    shader?: GLShader;
+    uniforms?: Uniform;
+}
+export declare enum TilemapShape {
+    SQUARE = "square",
+    ISOMETRIC = "isometric"
+}
+export declare enum ShaderType {
+    SPRITE = "sprite",
+    GRAPHIC = "graphic"
+}
+export declare enum BlendMode {
+    Additive = "additive",
+    Subtractive = "subtractive",
+    Mix = "mix"
+}
+/**
+ * Interface for light rendering options
+ */
+export interface ILightRenderOptions {
+    /** Position of the light source */
+    lightSource: Vec2;
+    /** Array of vertex arrays for occlusion objects, each occlusion object is defined by a set of vertices */
+    occlusion: Vec2[][];
+    /** Base projection length that controls shadow length */
+    baseProjectionLength?: number;
+    /** Type of mask to apply */
+    type?: MaskType;
+}
+export interface ICameraOptions extends ITransformOptions {
+    center?: boolean;
+}
+/**
+ * Defines particle emitter shape types
+ */
+export declare enum ParticleShape {
+    /**
+     * Point emitter, emits particles from a single point
+     */
+    POINT = "point",
+    /**
+     * Circle emitter, emits particles randomly from a circular area
+     */
+    CIRCLE = "circle",
+    /**
+     * Rectangle emitter, emits particles randomly from a rectangular area
+     */
+    RECT = "rect"
+}
+/**
+ * Defines particle attribute animation
+ * @template T Attribute type, can be number, vector or color
+ */
+export interface ParticleAttribute<T extends number | Vec2 | Color> {
+    /**
+     * Damping coefficient, controls attribute decay rate over time
+     */
+    damping?: number;
+    /**
+     * Initial attribute value
+     */
+    start: T;
+    /**
+     * Final attribute value, uses initial value if not specified
+     */
+    end?: T;
+    /**
+     * Attribute change rate, automatically calculated from start and end if not specified
+     */
+    delta?: T;
+}
+/**
+ * Particle system configuration options
+ */
+export interface IParticleOptions extends ITransformOptions, IShaderRenderOptions {
+    /**
+     * Particle texture, can be a single texture, array of textures, or weighted texture array
+     */
+    texture: Texture | Texture[] | [Texture, number][];
+    /**
+     * Particle emission rate (particles per second)
+     */
+    emitRate?: number;
+    /**
+     * Emission time interval in seconds
+     */
+    emitTime?: number;
+    /**
+     * Maximum number of particles limit
+     */
+    maxParticles?: number;
+    /**
+     * Particle lifetime in seconds, can be fixed value or range
+     */
+    life?: number | [number, number];
+    /**
+     * Particle animation properties collection
+     */
+    animation: {
+        /**
+         * Velocity vector, controls particle movement direction and speed
+         */
+        velocity?: ParticleAttribute<Vec2>;
+        /**
+         * Acceleration vector, controls particle velocity changes
+         */
+        acceleration?: ParticleAttribute<Vec2>;
+        /**
+         * Speed scalar, used in combination with rotation direction
+         */
+        speed?: ParticleAttribute<number>;
+        /**
+         * Scale factor, controls particle size
+         */
+        scale?: ParticleAttribute<number>;
+        /**
+         * Rotation angle (in radians)
+         */
+        rotation?: ParticleAttribute<number>;
+        /**
+         * Color and transparency
+         */
+        color?: ParticleAttribute<Color>;
+    };
+    /**
+     * Emitter shape
+     */
+    emitShape?: ParticleShape;
+    /**
+     * Circular emitter radius
+     */
+    emitRadius?: number;
+    /**
+     * Rectangular emitter dimensions
+     */
+    emitRect?: {
+        width: number;
+        height: number;
+    };
+    /**
+     * Whether to use local coordinate system, true means particles are relative to emitter position,
+     * false means using global coordinates
+     */
+    localSpace?: boolean;
+}
+/**
+ * Particle attribute data types
+ */
+export type ParticleAttributeTypes = number | Vec2 | Color;
+/**
+ * Particle attribute runtime data
+ * @template T Attribute type
+ */
+export type ParticleAttributeData<T extends ParticleAttributeTypes> = {
+    /**
+     * Attribute change rate per second
+     */
+    delta?: T;
+    /**
+     * Current attribute value
+     */
+    value: T;
+    /**
+     * Damping coefficient
+     */
+    damping?: number;
+};
+export interface IGameOptions extends IRapidOptions {
+}
+export interface ISound {
+    element: HTMLAudioElement;
+    source: MediaElementAudioSourceNode | null;
+    gainNode: GainNode;
+}
+/**
+ * Interface for an asset to be loaded.
+ */
+export interface IAsset {
+    type: 'json' | 'audio' | 'image';
+    name: string;
+    url: string;
+}
+/**
+ * Interface for the assets storage structure.
+ */
+export interface IAssets {
+    json: {
+        [key: string]: any;
+    };
+    audio: {
+        [key: string]: AudioPlayer;
+    };
+    images: {
+        [key: string]: Texture;
+    };
+}

package/dist/light.d.ts

@@ -0,0 +1,7 @@
+import { Vec2 } from "./math";
+import Rapid from "./render";
+export declare class LightManager {
+    render: Rapid;
+    constructor(render: Rapid);
+    createLightShadowMaskPolygon(occlusion: Vec2[][], lightSource: Vec2, baseProjectionLength?: number): Vec2[][];
+}

package/dist/line.d.ts

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

package/dist/log.d.ts

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