rapid-render 0.1.2-1.1 → 0.1.2-1.3

package/dist/assets.d.ts

@@ -1,7 +1,7 @@
-import { AudioPlayer } from "./audio";
-import { Game } from "./game";
-import { IAsset as IAsset, IAssets } from "./interface";
-import EventEmitter from "eventemitter3";
+import { AudioPlayer } from './audio';
+import { Game } from './game';
+import { IAsset, IAssets } from './interface';
+import { default as EventEmitter } from 'eventemitter3';
 /**
  * Events emitted by AssetsLoader.
  */
@@ -35,17 +35,18 @@ declare class AssetsLoader extends EventEmitter<AssetsLoaderEvents> {
      */
     loadJson(name: string, url: string): void;
     /**
-     * Loads an audio file asynchronously.
+     * Loads an audio file asynchronously using the AudioManager.
+     * The AudioManager will handle fetching and caching.
      * @param name - The unique identifier for the audio asset.
      * @param url - The URL of the audio file.
      */
-    loadAudio(name: string, url: string): void;
+    loadAudio(name: string, url: string): Promise<void>;
     /**
-     * Loads an image file asynchronously.
+     * Loads an image file asynchronously using the TextureManager.
      * @param name - The unique identifier for the image asset.
      * @param url - The URL of the image file.
      */
-    loadImage(name: string, url: string): void;
+    loadImage(name: string, url: string): Promise<void>;
     /**
      * Loads multiple assets from a list.
      * @param assetList - Array of assets to load.

package/dist/audio.d.ts

@@ -1,4 +1,4 @@
-import EventEmitter from "eventemitter3";
+import { default as EventEmitter } from 'eventemitter3';
 /**
  * Events emitted by AudioPlayer.
  */
@@ -6,54 +6,76 @@ interface AudioPlayerEvents {
     ended: () => void;
 }
 /**
- * Audio class for managing individual audio elements.
- * Encapsulates an HTMLAudioElement and its Web Audio API nodes.
+ * Represents a single, playable audio instance.
+ * Created by the AudioManager.
  */
 export declare class AudioPlayer extends EventEmitter<AudioPlayerEvents> {
-    element: HTMLAudioElement;
-    source: AudioNode | null;
-    gainNode: GainNode;
     private audioContext;
+    private audioBuffer;
+    private sourceNode;
+    private gainNode;
+    private _volume;
+    private _loop;
+    private _isPlaying;
+    constructor(audioContext: AudioContext, audioBuffer: AudioBuffer);
     /**
-     * Creates an instance of Audio.
-     * @param audioElement - The HTMLAudioElement to manage.
-     * @param audioContext - The Web Audio API context.
+     * Plays the audio. If already playing, it will stop the current playback and start over.
      */
-    constructor(audioElement: HTMLAudioElement, audioContext: AudioContext);
+    play(): void;
     /**
-     * Handles the 'ended' event when audio playback completes.
+     * Stops the audio playback immediately.
      */
-    private handleEnded;
+    stop(): void;
     /**
-     * Plays the audio with optional looping.
-     * @param loop - Whether the audio should loop (default: false).
+     * Gets the volume of the audio, from 0.0 to 1.0.
      */
-    play(loop?: boolean): Promise<void>;
+    get volume(): number;
     /**
-     * Pauses the audio.
+     * Sets the volume of the audio.
+     * @param value - The volume, from 0.0 (silent) to 1.0 (full).
      */
-    pause(): void;
+    set volume(value: number);
     /**
-     * Stops the audio and resets playback position.
+     * Gets whether the audio will loop.
      */
-    stop(): void;
+    get loop(): boolean;
     /**
-     * Sets the volume for the audio.
-     * @param volume - Volume level (0.0 to 1.0).
+     * Sets whether the audio should loop.
+     * Can be changed while the audio is playing.
      */
-    setVolume(volume: number): void;
+    set loop(value: boolean);
     /**
-     * Cleans up resources associated with the audio.
+     * Gets whether the audio is currently playing.
+     */
+    get isPlaying(): boolean;
+    /**
+     * Stops playback, disconnects audio nodes, and removes all event listeners.
+     * This makes the AudioPlayer instance unusable.
      */
     destroy(): void;
 }
 /**
- * AudioManager class for managing game audio, including background music (BGM) and sound effects (SFX).
- * Delegates audio-specific responsibilities to AudioPlayer instances.
+ * Manages loading, decoding, and caching of audio assets.
+ * This is analogous to your TextureCache.
  */
-declare class AudioManager {
-    audioContext: AudioContext;
+export declare class AudioManager {
+    private audioContext;
+    private cache;
     constructor();
+    /**
+     * Creates an AudioPlayer from a URL.
+     * It fetches, decodes, and caches the audio data. If the URL is already cached,
+     * it skips the network request and uses the cached data.
+     *
+     * @param url - The URL of the audio file.
+     * @returns A Promise that resolves to a new AudioPlayer instance.
+     */
+    audioFromUrl(url: string): Promise<AudioPlayer>;
+    /**
+     * Destroys the AudioManager, clears the audio cache, and closes the AudioContext.
+     * This releases all associated audio resources. After calling this, the AudioManager
+     * and any AudioPlayers created by it will be unusable.
+     */
     destroy(): void;
 }
 export default AudioManager;

package/dist/game.d.ts

@@ -1,12 +1,11 @@
-import AssetsLoader from "./assets";
-import AudioManager from "./audio";
-import { InputManager } from "./input";
-import { IEntityTilemapLayerOptions, IEntityTransformOptions, IGameOptions, IMathObject, ISpriteRenderOptions, TilemapShape, YSortCallback } from "./interface";
-import { MatrixStack, Vec2 } from "./math";
-import Rapid from "./render";
-import { TextureCache } from "./texture";
-import { TileSet } from "./tilemap";
-import { EasingFunction, Timer, Tween } from "./utils";
+import { default as AssetsLoader } from './assets';
+import { default as AudioManager } from './audio';
+import { InputManager } from './input';
+import { IAnimation, ICameraOptions, IEntityTransformOptions, IGameOptions, ILabelEntityOptions, IMathObject, ISpriteOptions } from './interface';
+import { Color, MatrixStack, Vec2 } from './math';
+import { default as Rapid } from './render';
+import { Text, Texture, TextureCache } from './texture';
+import { EasingFunction, Timer, Tween } from './utils';
 /**
  * Base class for game entities with transform and rendering capabilities.
  */
@@ -32,6 +31,7 @@ export declare class Entity {
      * @param options - Configuration options for position, scale, rotation, and tags.
      */
     constructor(game: Game, options?: IEntityTransformOptions);
+    getScene(): Scene | null;
     /**
      * Gets the parent transform or the renderer's matrix stack if no parent exists.
      * @returns The transform matrix stack.
@@ -57,7 +57,7 @@ export declare class Entity {
      * Prepares the entity's transform before rendering.
      * @ignore
      */
-    beforOnRender(): void;
+    beforeOnRender(): void;
     /**
      * Hook for custom rendering logic.
      * @param render - The rendering engine instance.
@@ -100,90 +100,46 @@ export declare class Entity {
      * Hook for custom cleanup logic before disposal.
      */
     protected postDispose(): void;
+    getMouseLocalPosition(): Vec2;
+    getMouseGlobalPosition(): Vec2;
 }
 /**
- * Camera entity for managing the view transform in the game.
+ * A layer that renders its children directly to the screen, ignoring any camera transforms.
+ * Ideal for UI elements like HUDs, menus, and scores.
+ *
+ * CanvasLayer 是一个特殊的层，它会直接将其子节点渲染到屏幕上，忽略任何摄像机的变换。
+ * 非常适合用于UI元素，如HUD（状态栏）、菜单和分数显示。
  */
-export declare class Camera extends Entity {
-    /**
-     * Updates the camera's transform to center the view and apply transformations.
-     */
+export declare class CanvasLayer extends Entity {
+    constructor(game: Game, options: IEntityTransformOptions);
     updateTransform(): void;
 }
 /**
- * Tilemap entity for rendering tiled maps.
+ * Camera entity for managing the view transform in the game.
  */
-export declare class Tilemap extends Entity {
-    static readonly DEFAULT_ERROR = 0;
-    static readonly EMPTY_TILE = -1;
-    error: Vec2;
-    shape: TilemapShape;
-    tileSet: TileSet;
-    data: (number | string)[][];
-    eachTile?: (tileId: string | number, mapX: number, mapY: number) => ISpriteRenderOptions | undefined | void;
-    ySortCallback: YSortCallback[];
-    /**
-     * Creates a tilemap entity.
-     * @param game - The game instance this tilemap belongs to.
-     * @param options - Configuration options for the tilemap.
-     */
-    constructor(game: Game, options: IEntityTilemapLayerOptions);
-    /**
-     * Collects renderable entities, excluding children unless they override onRender.
-     * @param queue - The array to collect renderable entities.
-     */
-    collectRenderables(queue: Entity[]): void;
-    /**
-     * Sets a tile at the specified map coordinates.
-     * @param x - The X coordinate (column) on the map.
-     * @param y - The Y coordinate (row) on the map.
-     * @param tileId - The tile ID to set (number or string).
-     * @returns True if the tile was set successfully, false if coordinates are out of bounds.
-     */
-    setTile(x: number, y: number, tileId: number | string): boolean;
-    /**
-     * Gets the tile ID at the specified map coordinates.
-     * @param x - The X coordinate (column) on the map.
-     * @param y - The Y coordinate (row) on the map.
-     * @returns The tile ID (number or string) or undefined if coordinates are out of bounds.
-     */
-    getTile(x: number, y: number): number | string | undefined;
-    /**
-     * Removes a tile at the specified map coordinates (sets it to EMPTY_TILE).
-     * @param x - The X coordinate (column) on the map.
-     * @param y - The Y coordinate (row) on the map.
-     * @returns True if the tile was removed successfully, false if coordinates are out of bounds.
-     */
-    removeTile(x: number, y: number): boolean;
-    /**
-     * Fills a rectangular area with a specified tile ID.
-     * @param tileId - The tile ID to use for filling.
-     * @param startX - The starting X coordinate.
-     * @param startY - The starting Y coordinate.
-     * @param width - The width of the fill area.
-     * @param height - The height of the fill area.
-     */
-    fill(tileId: number | string, startX: number, startY: number, width: number, height: number): void;
-    /**
-     * Replaces the entire tilemap data and updates dimensions.
-     * @param newData - The new 2D array of tile data.
-     */
-    setData(newData: (number | string)[][]): void;
+export declare class Camera extends Entity {
+    enable: boolean;
+    center: boolean;
+    positionSmoothingSpeed: number;
+    rotationSmoothingSpeed: number;
+    private _currentRenderPosition;
+    private _currentRenderRotation;
     /**
-     * Converts local coordinates to map coordinates.
-     * @param local - The local coordinates to convert.
+     * 设置此摄像机是否为当前场景的主摄像机。
+     * @param isEnable
      */
-    localToMap(local: Vec2): void;
+    setEnable(isEnable: boolean): void;
+    constructor(game: Game, options?: ICameraOptions);
     /**
-     * Converts map coordinates to local coordinates.
-     * @param local - The map coordinates to convert.
+     * 每帧更新，用于平滑摄像机的【局部】变换属性。
+     * @param deltaTime
      */
-    mapToLocal(local: Vec2): void;
+    onUpdate(deltaTime: number): void;
     /**
-     * Renders the tilemap layer.
-     * @param render - The rendering engine instance.
+     * 根据摄像机的【全局】变换计算最终的视图矩阵。
+     * 这个方法现在正确地处理了父子关系。
      */
-    onRender(render: Rapid): void;
+    updateTransform(): void;
 }
 /**
  * Scene class representing a game scene with entities.
@@ -208,12 +164,16 @@ export declare class Game {
     private lastTime;
     private tweens;
     private timers;
+    mainCamera: Camera | null;
     renderQueue: Entity[];
+    worldTransform: MatrixStack;
     /**
      * Creates a new game instance.
      * @param options - Configuration options for the game.
      */
     constructor(options: IGameOptions);
+    getMainScene(): Scene | null;
+    setMainCamera(camera: Camera | null): void;
     /**
      * Switches to a new scene, disposing of the current one.
      * @param newScene - The new scene to switch to.
@@ -290,3 +250,75 @@ export declare class Game {
      */
     private updateTweens;
 }
+/**
+ * An entity that displays a texture (a "sprite") and can play animations.
+ * Animations are defined as a sequence of textures.
+ */
+export declare class Sprite extends Entity {
+    /** The current texture being displayed. This can be a static texture or a frame from an animation. */
+    texture: Texture | null;
+    /** Whether the sprite is flipped horizontally. */
+    flipX: boolean;
+    /** Whether the sprite is flipped vertically. */
+    flipY: boolean;
+    color: Color;
+    offset: Vec2;
+    private animations;
+    private currentAnimation;
+    private currentFrame;
+    private frameTimer;
+    private isPlaying;
+    /**
+     * Creates a new Sprite entity.
+     * @param game - The game instance.
+     * @param options - Configuration for the sprite's transform and initial texture.
+     */
+    constructor(game: Game, options?: ISpriteOptions);
+    setAnimations(animations: IAnimation): void;
+    /**
+     * Defines a new animation sequence.
+     * @param name - A unique name for the animation (e.g., "walk", "jump").
+     * @param frames - An array of Textures to use as frames.
+     * @param fps - The playback speed in frames per second.
+     * @param loop - Whether the animation should repeat.
+     */
+    addAnimation(name: string, frames: Texture[], fps?: number, loop?: boolean): void;
+    /**
+     * Plays an animation that has been previously defined with `addAnimation`.
+     * @param name - The name of the animation to play.
+     * @param forceRestart - If true, the animation will restart from the first frame even if it's already playing.
+     */
+    play(name: string, forceRestart?: boolean): void;
+    /**
+     * Stops the currently playing animation.
+     * The sprite will remain on the current frame.
+     */
+    stop(): void;
+    /**
+     * Updates the animation frame based on the elapsed time.
+     * @param deltaTime - Time in seconds since the last frame.
+     * @override
+     */
+    onUpdate(deltaTime: number): void;
+    /**
+     * Renders the sprite's current texture to the screen.
+     * @param render - The Rapid rendering instance.
+     * @override
+     */
+    onRender(render: Rapid): void;
+}
+/**
+ * An entity designed specifically to display text on the screen.
+ * It encapsulates a `Text` texture, giving it position, scale, rotation,
+ * and other entity-based properties.
+ */
+export declare class Label extends Entity {
+    text: Text;
+    constructor(game: Game, options: ILabelEntityOptions);
+    onRender(render: Rapid): void;
+    /**
+     * Updates the displayed text. Re-renders the texture if the text has changed.
+     * @param text - The new text to display.
+     */
+    setText(text: string): void;
+}

package/dist/index.d.ts

@@ -1,16 +1,16 @@
-import Rapid from "./render";
-import GLShader from "./webgl/glshader";
-import { Text } from "./texture";
-import { TileMapRender, TileSet } from "./tilemap";
-import { Uniform } from "./webgl/uniform";
-import { spriteAttributes, graphicAttributes } from "./regions/attributes";
-import { ParticleEmitter } from "./particle";
+import { default as Rapid } from './render';
+import { default as GLShader } from './webgl/glshader';
+import { Text } from './texture';
+import { TileMapRender, TileSet } from './tilemap';
+import { Uniform } from './webgl/uniform';
+import { spriteAttributes, graphicAttributes } from './regions/attributes';
+import { ParticleEmitter } from './particle';
 export { Text, Rapid, GLShader, TileMapRender, TileSet, Uniform, ParticleEmitter, graphicAttributes, spriteAttributes, };
-export * from "./math";
-export * from "./interface";
-export * from "./texture";
-export * from "./render";
-export * from "./particle";
-export * from "./game";
-export * from "./input";
-export * from "./assets";
+export * from './math';
+export * from './interface';
+export * from './texture';
+export * from './render';
+export * from './particle';
+export * from './game';
+export * from './input';
+export * from './assets';

package/dist/input.d.ts

@@ -1,6 +1,6 @@
-import { Vec2 } from "./math";
-import Rapid from "./render";
-import { Entity } from "./game";
+import { Vec2 } from './math';
+import { default as 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.
@@ -8,7 +8,7 @@ import { Entity } from "./game";
 export declare class InputManager {
     private rapid;
     private canvas;
-    private mousePosition;
+    mousePosition: Vec2;
     private keysDown;
     private keysDownLastFrame;
     private buttonsDown;
@@ -81,6 +81,8 @@ export declare class InputManager {
      * @returns The mouse position in the entity's local coordinate system.
      */
     getMouseLocal(entity: Entity): Vec2;
+    getAxis(negativeAction: string, positiveAction: string): number;
+    getVector(negativeX: string, positiveX: string, negativeY: string, positiveY: string): Vec2;
     /**
      * Removes all event listeners and cleans up resources.
      */

package/dist/interface.d.ts

@@ -1,10 +1,10 @@
-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";
+import { AudioPlayer } from './audio';
+import { Entity } from './game';
+import { Color, Vec2 } from './math';
+import { Texture } from './texture';
+import { TileSet } from './tilemap';
+import { default as GLShader } from './webgl/glshader';
+import { Uniform } from './webgl/uniform';
 /**
  * @ignore
  */
@@ -114,7 +114,7 @@ export interface ITextTextureOptions {
      * The color of the text.
      * Default is '#000000' (black).
      */
-    color?: string;
+    color?: Color;
     /**
      * The alignment of the text.
      * Possible values: 'left', 'right', 'center', 'start', 'end'.
@@ -182,6 +182,7 @@ export interface YSortCallback {
     renderSprite?: ISpriteRenderOptions;
 }
 export interface IEntityTilemapLayerOptions extends ITilemapLayerOptions, IEntityTransformOptions {
+    enableYsort: boolean;
 }
 export interface ITilemapLayerOptions {
     error?: number | Vec2;
@@ -226,6 +227,9 @@ export interface ILightRenderOptions {
 }
 export interface ICameraOptions extends ITransformOptions {
     center?: boolean;
+    enable?: boolean;
+    positionSmoothingSpeed?: number;
+    rotationSmoothingSpeed?: number;
 }
 /**
  * Defines particle emitter shape types
@@ -362,12 +366,9 @@ export type ParticleAttributeData<T extends ParticleAttributeTypes> = {
      */
     damping?: number;
 };
-export interface IGameOptions extends IRapidOptions {
+export interface IParticleEmitterOptions extends IParticleOptions, IEntityTransformOptions {
 }
-export interface ISound {
-    element: HTMLAudioElement;
-    source: MediaElementAudioSourceNode | null;
-    gainNode: GainNode;
+export interface IGameOptions extends IRapidOptions {
 }
 /**
  * Interface for an asset to be loaded.
@@ -391,3 +392,18 @@ export interface IAssets {
         [key: string]: Texture;
     };
 }
+export interface IAnimation {
+    /** The name of the animation, used to play it. */
+    name: string;
+    /** An array of Textures that make up the frames of the animation. */
+    frames: Texture[];
+    /** The speed of the animation in frames per second (FPS). */
+    fps: number;
+    /** Whether the animation should loop back to the first frame when it ends. */
+    loop: boolean;
+}
+export interface ISpriteOptions extends IEntityTransformOptions, ISpriteRenderOptions {
+    animations?: IAnimation;
+}
+export interface ILabelEntityOptions extends ITextTextureOptions, IEntityTransformOptions {
+}

package/dist/light.d.ts

@@ -1,5 +1,5 @@
-import { Vec2 } from "./math";
-import Rapid from "./render";
+import { Vec2 } from './math';
+import { default as Rapid } from './render';
 export declare class LightManager {
     render: Rapid;
     constructor(render: Rapid);

package/dist/line.d.ts

@@ -1,5 +1,5 @@
-import { ILineStyleOptions } from "./interface";
-import { Vec2 } from "./math";
+import { ILineStyleOptions } from './interface';
+import { Vec2 } from './math';
 /**
  * @ignore
  */

package/dist/math.d.ts

@@ -1,4 +1,4 @@
-import { IMathObject, ITransformOptions, WebGLContext } from "./interface";
+import { IMathObject, ITransformOptions, WebGLContext } from './interface';
 /**
  * @ignore
  */
@@ -21,7 +21,7 @@ export declare class DynamicArrayBuffer {
     private float32?;
     private uint16?;
     constructor(arrayType: ArrayType);
-    getArrayType(arrayType: ArrayType): Uint16ArrayConstructor | Uint32ArrayConstructor | Float32ArrayConstructor;
+    getArrayType(arrayType: ArrayType): Float32ArrayConstructor | Uint32ArrayConstructor | Uint16ArrayConstructor;
     updateTypedArray(): void;
     clear(): void;
     /**
@@ -45,7 +45,7 @@ export declare class DynamicArrayBuffer {
      * @param end
      * @returns
      */
-    getArray(begin?: number, end?: number): Uint16Array | Uint32Array | Float32Array;
+    getArray(begin?: number, end?: number): Uint32Array | Float32Array | Uint16Array;
     /**
      * length of the array
      */
@@ -265,6 +265,12 @@ export declare class Color implements IMathObject<Color> {
      * @returns A new `Color` instance with the same RGBA values.
      */
     clone(): Color;
+    /**
+     * Converts the color to a hexadecimal string representation (e.g., '#RRGGBBAA').
+     * @param includeAlpha - Whether to include the alpha channel in the hex string.
+     * @returns The hexadecimal string representation of the color.
+     */
+    toHexString(includeAlpha?: boolean): string;
     /**
      * Checks if the current color is equal to another color.
      * @param color - The color to compare with.
@@ -455,6 +461,7 @@ export declare class Vec2 implements IMathObject<Vec2> {
      * @returns The angle between the two vectors in radians.
      */
     angleBetween(v: Vec2): number;
+    lerp(target: Vec2, factor: number): Vec2;
 }
 /**
  * Provides utility methods for mathematical conversions.