emeraldengine 2.2.1 → 3.1.0

package/dist/types/src/Scene.d.ts

@@ -0,0 +1,62 @@
+export default Scene;
+/**
+ * @class Scene
+ * @description Represents a scene
+ * @param {Array} objects - The objects in the scene
+ */
+declare class Scene {
+    constructor(objects?: any[]);
+    objects: any[];
+    /**
+     * @method add
+     * @description Adds an object to the scene
+     * @param {GameObject} object - The object to add
+     */
+    add(object: GameObject): void;
+    /**
+     * @method remove
+     * @description Removes an object from the scene. By default the object's GPU
+     * resources stay alive so it can be re-added later; pass { dispose: true }
+     * to also destroy it (free GL buffers/textures, physics bodies) when it is
+     * being removed for good.
+     * @param {GameObject} object - The object to remove
+     * @param {Object} [options] - { dispose = false }
+     */
+    remove(object: GameObject, options?: any): void;
+    /**
+     * @method dispose
+     * @description Destroys every object in the scene (freeing their GPU
+     * resources and physics bodies) and empties it. Call when a level/screen is
+     * torn down for good; removing objects without disposing leaks GL buffers
+     * over repeated scene swaps.
+     */
+    dispose(): void;
+    /**
+     * @method update
+     * @description Ticks every active object's component lifecycle. Call once per
+     * frame (before or after drawScene) to drive Behaviour components.
+     * @param {number} deltaTime - Seconds since the previous frame
+     */
+    update(deltaTime: number): void;
+    /**
+     * @method setIsActive
+     * @description Sets the active state of the scene
+     * @param {boolean} bool - The active state
+     */
+    setIsActive(bool: boolean): void;
+    /**
+     * @method setActiveRecursive
+     * @description Sets the active state of the scene recursively
+     * @param {Object} object - The object to set the active state of
+     * @param {boolean} bool - The active state
+     */
+    setActiveRecursive(object: any, bool: boolean): void;
+    forEach(callback: any): void;
+    [Symbol.iterator](): {
+        next: () => {
+            value: any;
+            done: boolean;
+        };
+    };
+}
+import GameObject from "./components/GameObject.js";

package/dist/types/src/ScreenEffects.d.ts

@@ -0,0 +1,111 @@
+export default ScreenEffects;
+/**
+ * @class ScreenEffects
+ * @description In-engine full-screen camera/transition effects: fade to/from a
+ * color, screen flash, and cinematic letterbox bars. Everything is drawn with
+ * the engine's own screen-space quads (no DOM/CSS overlay), so it survives
+ * resolution changes, post-processing, and split-screen (the quads overfill
+ * every viewport and are clipped per camera).
+ *
+ * Add it to your scene's update loop by calling `update(dt)` each frame.
+ *
+ * @example
+ * const fx = new ScreenEffects(scene, { layer: 100000 });
+ * await fx.fadeOut(0.4, new Color(0,0,0,255));  // to black
+ * loadNextLevel();
+ * await fx.fadeIn(0.4);
+ * // bumps:
+ * fx.flash(new Color(255,255,255,255), 0.15);
+ * // in the loop, before drawScene: fx.update(dt);
+ */
+declare class ScreenEffects {
+    /**
+     * @param {Scene} scene - The scene to draw the overlays into
+     * @param {Object} [options] - { layer = 100000, size = 5000 }
+     */
+    constructor(scene: Scene, options?: any);
+    scene: Scene;
+    /** @private */
+    private _fade;
+    /** @private */
+    private _flashQuad;
+    /** @private */
+    private _barTop;
+    /** @private */
+    private _barBottom;
+    /** @private */
+    private _letterboxHeight;
+    /** @private */
+    private _letterboxTarget;
+    /** @private */
+    private _barHalf;
+    /** @private */
+    private _fadeAnim;
+    /** @private */
+    private _flashAnim;
+    /** @private */
+    private _makeQuad;
+    /** @private */
+    private _shapeOf;
+    /** @private */
+    private _setColor;
+    /**
+     * @method fadeOut
+     * @description Fades the screen to a solid color (opacity 0 -> 1).
+     * @param {number} duration - Seconds
+     * @param {Color} [color] - Target color (default black)
+     * @param {Function} [easing] - Easing function (default linear)
+     * @returns {Promise<void>} - Resolves when the fade completes
+     */
+    fadeOut(duration?: number, color?: Color, easing?: Function): Promise<void>;
+    /**
+     * @method fadeIn
+     * @description Fades the screen back in from the current overlay (opacity -> 0).
+     * @param {number} duration - Seconds
+     * @param {Function} [easing] - Easing function (default linear)
+     * @returns {Promise<void>}
+     */
+    fadeIn(duration?: number, easing?: Function): Promise<void>;
+    /** @private */
+    private _startFade;
+    /**
+     * @method flash
+     * @description Flashes a color that ramps to full then fades out.
+     * @param {Color} [color] - Flash color (default white)
+     * @param {number} duration - Total seconds for the flash
+     * @returns {Promise<void>}
+     */
+    flash(color?: Color, duration?: number): Promise<void>;
+    /**
+     * @method transition
+     * @description Fades the screen out to a color, runs a swap callback at the
+     * darkest point (e.g. tear down the old scene and build the new one), then
+     * fades back in. Requires `update(dt)` to be pumped each frame by your loop.
+     * @param {Function} swap - Called (and awaited) while the screen is covered
+     * @param {Object} [options] - { duration = 0.4, color = black, outDuration,
+     *   inDuration, easing }
+     * @returns {Promise<void>} - Resolves after the fade-in completes
+     */
+    transition(swap: Function, options?: any): Promise<void>;
+    /**
+     * @method setLetterbox
+     * @description Animates cinematic black bars to the given height (in pixels,
+     * per bar). Pass 0 to retract them.
+     * @param {number} heightPx - Target bar height in pixels
+     */
+    setLetterbox(heightPx: number): void;
+    /**
+     * @method update
+     * @description Advances all active transitions. Call once per frame.
+     * @param {number} dt - Seconds since last frame
+     */
+    update(dt: number): void;
+    /** @private */
+    private _screenHalfHeight;
+    /**
+     * @method destroy
+     * @description Removes all overlay objects from the scene.
+     */
+    destroy(): void;
+}
+import Color from "./Color.js";

package/dist/types/src/Serializer.d.ts

@@ -0,0 +1,86 @@
+export default Serializer;
+/**
+ * @class Serializer
+ * @description Saves/loads a scene to/from plain JSON. Because components hold
+ * live GL/physics handles that can't be serialized generically, reconstruction
+ * goes through registered factories keyed by a `prefabType`. Each object's
+ * transform, layer, opacity and an optional `serialize()` payload are captured.
+ *
+ * @example
+ * Serializer.register("coin", (data) => makeCoin(data.value));
+ * coin.prefabType = "coin";
+ * coin.serialize = () => ({ value: 5 });
+ *
+ * const json = Serializer.toJSON(scene);          // save
+ * Serializer.fromJSON(json, new Scene());          // load
+ */
+declare class Serializer {
+    /**
+     * @method register
+     * @description Registers a factory that rebuilds an object from its data.
+     * @param {string} type - The prefabType
+     * @param {(data:any, entry:any) => Object} factory - Returns a GameObject
+     */
+    static register(type: string, factory: (data: any, entry: any) => any): void;
+    /**
+     * @method serializeObject
+     * @description Captures a single object's serializable state.
+     */
+    static serializeObject(obj: any): {
+        type: any;
+        name: any;
+        layer: any;
+        opacity: any;
+        screenSpace: boolean;
+        transform: {
+            position: {
+                x: any;
+                y: any;
+                z: any;
+            };
+            rotation: any;
+            scale: {
+                x: any;
+                y: any;
+            };
+        };
+        data: any;
+    };
+    /**
+     * @method serializeScene
+     * @description Returns a plain object describing the scene.
+     */
+    static serializeScene(scene: any): {
+        objects: any;
+    };
+    /**
+     * @method applyState
+     * @description Applies a serialized entry's transform/layer/opacity to an object.
+     */
+    static applyState(obj: any, entry: any): void;
+    /**
+     * @method deserializeObject
+     * @description Rebuilds an object from an entry via its registered factory.
+     * @returns {Object|null}
+     */
+    static deserializeObject(entry: any): any | null;
+    /**
+     * @method deserializeScene
+     * @description Rebuilds objects into the given scene.
+     * @returns {Scene} - The populated scene
+     */
+    static deserializeScene(json: any, scene: any): Scene;
+    /**
+     * @method toJSON
+     * @description Serializes a scene to a JSON string.
+     */
+    static toJSON(scene: any): string;
+    /**
+     * @method fromJSON
+     * @description Loads a scene from a JSON string into the given scene.
+     */
+    static fromJSON(str: any, scene: any): Scene;
+}
+declare namespace Serializer {
+    let factories: Map<any, any>;
+}

package/dist/types/src/Shaders.d.ts

@@ -0,0 +1,2 @@
+export const STANDARD_VERTEX_SHADER: "\n  attribute vec4 aVertexPosition;\n  attribute vec2 aTextureCoord;\n\n  attribute vec4 aInstanceMatrix0;\n  attribute vec4 aInstanceMatrix1;\n  attribute vec4 aInstanceMatrix2;\n  attribute vec4 aInstanceMatrix3;\n\n  attribute vec2 aInstanceTexCoord0;\n  attribute vec2 aInstanceTexCoord1;\n  attribute vec2 aInstanceTexCoord2;\n  attribute vec2 aInstanceTexCoord3;\n\n  attribute vec4 aInstanceColor;\n\n  uniform mat4 uModelViewMatrix;\n  uniform mat4 uInstancedModelViewMatrix;\n  uniform mat4 uProjectionMatrix;\n  uniform bool useInstances;\n\n  varying highp vec2 vTexCoord;\n  varying vec2 vFragPos;\n  varying vec4 vInstanceColor;\n\n  void main() {\n    mat4 instanceMatrix = mat4(\n      aInstanceMatrix0,\n      aInstanceMatrix1,\n      aInstanceMatrix2,\n      aInstanceMatrix3\n    );\n\n    if(useInstances) {\n        gl_Position = uProjectionMatrix * uInstancedModelViewMatrix * instanceMatrix * aVertexPosition;\n        vFragPos = (uInstancedModelViewMatrix * instanceMatrix * aVertexPosition).xy;\n        vInstanceColor = aInstanceColor;\n\n        int vertexIndex = int(aVertexPosition.x > 0.0 ? (aVertexPosition.y > 0.0 ? 0 : 2) : (aVertexPosition.y > 0.0 ? 1 : 3));\n\n        if(vertexIndex == 0) {\n            vTexCoord = aInstanceTexCoord0;\n        } else if(vertexIndex == 1) {\n            vTexCoord = aInstanceTexCoord1;\n        } else if(vertexIndex == 2) {\n            vTexCoord = aInstanceTexCoord2;\n        } else {\n            vTexCoord = aInstanceTexCoord3;\n        }\n    } else {\n        gl_Position = uProjectionMatrix * uModelViewMatrix * aVertexPosition;\n        vFragPos = (uModelViewMatrix * aVertexPosition).xy;\n        vTexCoord = aTextureCoord;\n        vInstanceColor = vec4(1.0);\n    }\n  }\n";
+export const STANDARD_FRAGMENT_SHADER: "\n    #ifdef GL_ES\n    precision highp float;\n    #endif\n    uniform bool useTexture;\n    uniform vec4 uColor;\n    uniform sampler2D uSampler;\n    uniform float uOpacity;\n\n    uniform vec2 uLightPosition[4];\n    uniform vec3 uLightColor[4];\n    uniform float uLightIntensity[4];\n    uniform float uLightRadius[4];\n    uniform int uActiveLights;\n\n    uniform vec2 uDirLightPosition[4];\n    uniform vec2 uDirLightDirection[4];\n    uniform vec3 uDirLightColor[4];\n    uniform float uDirLightIntensity[4];\n    uniform float uDirLightWidth[4];\n    uniform int uActiveDirLights;\n\n    uniform vec3 uAmbientLightValues;\n    uniform bool uUseLighting;\n\n    varying vec2 vTexCoord;\n    varying vec2 vFragPos;\n    varying vec4 vInstanceColor;\n\n    void main() {\n        vec4 ambientLight = vec4(uAmbientLightValues.xyz, 1.0);\n\n        vec4 texColor;\n        if (useTexture) {\n            texColor = texture2D(uSampler, vTexCoord);\n            if (texColor.a < 0.01) discard;\n            texColor *= uColor;\n        } else {\n            texColor = uColor;\n        }\n\n        texColor *= vInstanceColor;\n\n        vec3 lighting = ambientLight.rgb;\n\n        for(int i = 0; i < 4; i++) {\n            if(i >= uActiveLights) break;\n\n            float distance = length(uLightPosition[i] - vFragPos);\n\n            if(distance < uLightRadius[i]) {\n                float attenuation = 1.0 - distance / uLightRadius[i];\n\n                lighting += uLightColor[i] * attenuation * uLightIntensity[i];\n            }\n        }\n\n        for(int i = 0; i < 4; i++) {\n            if(i >= uActiveDirLights) break;\n\n            vec2 lightPos = uDirLightPosition[i];\n            vec2 lightDir = normalize(uDirLightDirection[i]);\n            vec2 toFrag = vFragPos - lightPos;\n\n            float projection = dot(toFrag, lightDir);\n            if(projection < 0.0) continue;\n\n            float perpDistance = abs(dot(toFrag, vec2(-lightDir.y, lightDir.x)));\n\n            if(perpDistance > uDirLightWidth[i] * 0.5) continue;\n\n            float widthFactor = 1.0 - (perpDistance / (uDirLightWidth[i] * 0.5));\n\n            float distance = length(toFrag);\n            float maxDistance = 1000.0;\n            float distanceFactor = max(0.0, 1.0 - (distance / maxDistance));\n\n            lighting += uDirLightColor[i] * uDirLightIntensity[i] * widthFactor * distanceFactor;\n        }\n\n        vec4 outColor;\n        if (uUseLighting) {\n            outColor = vec4(texColor.rgb * lighting, texColor.a);\n        } else {\n            outColor = texColor;\n        }\n        outColor.a *= clamp(uOpacity, 0.0, 1.0);\n        gl_FragColor = outColor;\n    }\n";

package/dist/types/{Shapes.d.ts → src/Shapes.d.ts}

@@ -1,16 +1,15 @@
-import Drawable from "./Drawable";
 /**
  * @class Square2D
  * @description Represents a square 2D shape
  */
-declare class Square2D extends Drawable {
+export class Square2D extends Drawable {
     constructor();
 }
 /**
  * @class Triangle2D
  * @description Represents a triangle 2D shape
  */
-declare class Triangle2D extends Drawable {
+export class Triangle2D extends Drawable {
     constructor();
 }
 /**
@@ -18,8 +17,7 @@ declare class Triangle2D extends Drawable {
  * @description Represents a circle 2D shape
  * @param {number} segments - The number of segments to use to draw the circle
  */
-declare class Circle2D extends Drawable {
+export class Circle2D extends Drawable {
     constructor(segments?: number);
 }
-export { Square2D, Triangle2D, Circle2D };
-//# sourceMappingURL=Shapes.d.ts.map
+import Drawable from "./Drawable.js";

package/dist/types/src/SpatialGrid.d.ts

@@ -0,0 +1,50 @@
+export default SpatialGrid;
+/**
+ * @class SpatialGrid
+ * @description A uniform spatial hash grid for fast 2D neighbor queries (picking,
+ * proximity, broadphase). Rebuild it each frame (or as objects move) with
+ * clear()/insert(), then query by radius or rectangle.
+ *
+ * @example
+ * const grid = new SpatialGrid(64);
+ * grid.clear();
+ * for (const e of enemies) grid.insert(e, e.transform.position.x, e.transform.position.y);
+ * const near = grid.queryRadius(player.x, player.y, 100);
+ */
+declare class SpatialGrid {
+    /**
+     * @param {number} cellSize - World units per cell
+     */
+    constructor(cellSize?: number);
+    cellSize: number;
+    cells: Map<any, any>;
+    /** @private */
+    private _key;
+    /** @private */
+    private _cell;
+    /**
+     * @method clear
+     * @description Empties the grid.
+     */
+    clear(): void;
+    /**
+     * @method insert
+     * @description Inserts an item at a world position.
+     * @param {*} item - The item to store
+     * @param {number} x - World x
+     * @param {number} y - World y
+     */
+    insert(item: any, x: number, y: number): void;
+    /**
+     * @method queryRect
+     * @description Returns items whose stored position lies within a rectangle.
+     * @returns {Array} - Matching items
+     */
+    queryRect(minX: any, minY: any, maxX: any, maxY: any): any[];
+    /**
+     * @method queryRadius
+     * @description Returns items within a radius of a point.
+     * @returns {Array} - Matching items
+     */
+    queryRadius(x: any, y: any, radius: any): any[];
+}

package/dist/types/src/SpriteBatch.d.ts

@@ -0,0 +1,89 @@
+export default SpriteBatch;
+/**
+ * @class SpriteBatch
+ * @description A dynamic batched sprite renderer. Instead of one draw call per
+ * sprite (as ordinary Drawables incur), it accumulates many sprites that share a
+ * texture into a single interleaved buffer and submits them in one
+ * `drawElements` call. Batches are flushed automatically when the texture
+ * changes or the buffer fills, so for content that shares a texture/atlas this
+ * collapses hundreds of draw calls into a handful.
+ *
+ * It uses its own minimal shader program (position + uv + per-vertex color), so
+ * it is independent of the main render pipeline.
+ *
+ * @example
+ * const batch = new SpriteBatch();
+ * batch.begin(projectionMatrix, viewMatrix); // gl-matrix mat4s
+ * for (const e of entities) {
+ *   batch.draw({ texture: atlasTex, x: e.x, y: e.y, w: 32, h: 32,
+ *                u0: e.u0, v0: e.v0, u1: e.u1, v1: e.v1 });
+ * }
+ * batch.end();
+ */
+declare class SpriteBatch {
+    /**
+     * @method _writeQuad
+     * @description Pure helper that writes one quad's 4 interleaved vertices
+     * (position, uv, color) into `out` at `offset`. Positions are rotated around
+     * the quad center (cx, cy). Exposed (and side-effect free) for testing.
+     * @private
+     */
+    private static _writeQuad;
+    /**
+     * @param {Object} [options] - { maxQuads = 2000 }
+     */
+    constructor(options?: any);
+    gl: WebGLRenderingContext;
+    maxQuads: any;
+    program: any;
+    attribs: {
+        pos: number;
+        uv: number;
+        color: number;
+    };
+    uniforms: {
+        projection: WebGLUniformLocation;
+        view: WebGLUniformLocation;
+        sampler: WebGLUniformLocation;
+    };
+    vertexData: Float32Array<ArrayBuffer>;
+    vertexBuffer: WebGLBuffer;
+    indexBuffer: WebGLBuffer;
+    /** @private */
+    private _quadCount;
+    /** @private */
+    private _currentTexture;
+    /** @private */
+    private _projection;
+    /** @private */
+    private _view;
+    drawCalls: number;
+    /**
+     * @method begin
+     * @description Starts a batch with the given projection and view matrices
+     * (gl-matrix mat4 / Float32Array(16)).
+     */
+    begin(projectionMatrix: any, viewMatrix: any): void;
+    /**
+     * @method draw
+     * @description Queues one sprite. Flushes first if the texture changed or the
+     * batch is full.
+     * @param {Object} sprite - {
+     *   texture, x, y, w, h,
+     *   rotation = 0, originX = 0.5, originY = 0.5,
+     *   u0 = 0, v0 = 0, u1 = 1, v1 = 1,
+     *   r = 1, g = 1, b = 1, a = 1
+     * }
+     */
+    draw(sprite: any): void;
+    /**
+     * @method end
+     * @description Flushes any remaining sprites.
+     */
+    end(): void;
+    /**
+     * @method flush
+     * @description Uploads and draws the currently staged quads.
+     */
+    flush(): void;
+}

package/dist/types/src/StateMachine.d.ts

@@ -0,0 +1,59 @@
+export default StateMachine;
+/**
+ * @class StateMachine
+ * @description A lightweight finite state machine for entity AI, animation
+ * states, game flow, etc. Each state can define `enter`, `update(dt)`, and
+ * `exit` handlers. Drive it from a Behaviour's update().
+ *
+ * @example
+ * const fsm = new StateMachine();
+ * fsm.add("idle", {
+ *   update: (dt, sm) => { if (seesPlayer) sm.set("chase"); },
+ * });
+ * fsm.add("chase", {
+ *   enter: () => playRoarSound(),
+ *   update: (dt, sm) => moveTowardPlayer(dt),
+ * });
+ * fsm.set("idle");
+ * // in update(dt): fsm.update(dt);
+ */
+declare class StateMachine {
+    states: Map<any, any>;
+    current: any;
+    currentName: any;
+    previousName: any;
+    /**
+     * @method add
+     * @description Registers a state.
+     * @param {string} name - State name
+     * @param {{enter?:Function, update?:Function, exit?:Function}} handlers
+     * @returns {StateMachine} - this
+     */
+    add(name: string, handlers: {
+        enter?: Function;
+        update?: Function;
+        exit?: Function;
+    }): StateMachine;
+    /**
+     * @method set
+     * @description Transitions to a state, running exit/enter handlers. Re-entering
+     * the same state is a no-op unless `force` is true.
+     * @param {string} name - Target state name
+     * @param {boolean} [force] - Allow re-entering the current state
+     * @returns {StateMachine} - this
+     */
+    set(name: string, force?: boolean): StateMachine;
+    /**
+     * @method update
+     * @description Runs the current state's update handler.
+     * @param {number} dt - Seconds since the last frame
+     */
+    update(dt: number): void;
+    /**
+     * @method is
+     * @description Whether the given state is current.
+     * @param {string} name
+     * @returns {boolean}
+     */
+    is(name: string): boolean;
+}

package/dist/types/src/Storage.d.ts

@@ -0,0 +1,89 @@
+export default Storage;
+/**
+ * @class Storage
+ * @description Manages the storage of the game
+ */
+declare class Storage {
+    /**
+     * @method writeToLocalStorage
+     * @description Writes to local storage
+     * @param {string} key - The key to write to
+     * @param {any} value - The value to write to
+     */
+    static writeToLocalStorage(key: string, value: any): void;
+    /**
+     * @method readFromLocalStorage
+     * @description Reads from local storage
+     * @param {string} key - The key to read from
+     * @returns {any} - The value read from local storage
+     */
+    static readFromLocalStorage(key: string): any;
+    /**
+     * @method clearLocalStorage
+     * @description Clears local storage
+     */
+    static clearLocalStorage(): void;
+    /**
+     * @method writeToSessionStorage
+     * @description Writes to session storage
+     * @param {string} key - The key to write to
+     * @param {any} value - The value to write to
+     */
+    static writeToSessionStorage(key: string, value: any): void;
+    /**
+     * @method readFromSessionStorage
+     * @description Reads from session storage
+     * @param {string} key - The key to read from
+     * @returns {any} - The value read from session storage
+     */
+    static readFromSessionStorage(key: string): any;
+    /**
+     * @method clearSessionStorage
+     * @description Clears session storage
+     */
+    static clearSessionStorage(): void;
+    /**
+     * @method save
+     * @description Writes a versioned save under `key`. The payload is wrapped in
+     * an envelope `{ v, t, data }` so it can be migrated later, and the previous
+     * value is mirrored to `key + ".bak"` for corruption recovery. Quota and
+     * serialization errors are caught and reported rather than thrown.
+     * @param {string} key - The storage key
+     * @param {any} data - The data to persist (must be JSON-serializable)
+     * @param {Object} [options] - { version = 1, backup = true }
+     * @returns {boolean} - Whether the write succeeded
+     */
+    static save(key: string, data: any, options?: any): boolean;
+    /**
+     * @method _unwrap
+     * @description Parses a stored string into a `{ v, data }` envelope, treating
+     * a plain (pre-versioning) value as version 0. Returns undefined for missing
+     * data and throws for malformed JSON.
+     * @private
+     */
+    private static _unwrap;
+    /**
+     * @method load
+     * @description Reads a versioned save written by `save`. If the primary value
+     * is corrupt it falls back to the `.bak` copy; if that fails too it returns
+     * `fallback`. When the stored version differs from `version` and a `migrate`
+     * function is given, the data is upgraded (and rewritten unless disabled).
+     * @param {string} key - The storage key
+     * @param {Object} [options] - { version = 1, fallback = null, migrate, rewrite = true }
+     * @returns {any} - The (possibly migrated) saved data, or `fallback`
+     */
+    static load(key: string, options?: any): any;
+    /**
+     * @method hasSave
+     * @description Returns whether a save (or its backup) exists for `key`.
+     * @param {string} key - The storage key
+     * @returns {boolean}
+     */
+    static hasSave(key: string): boolean;
+    /**
+     * @method removeSave
+     * @description Deletes a save and its backup.
+     * @param {string} key - The storage key
+     */
+    static removeSave(key: string): void;
+}

package/dist/types/{Texture.d.ts → src/Texture.d.ts}

@@ -1,4 +1,4 @@
-import Drawable from "./Drawable";
+export default Texture;
 /**
  * @class Texture
  * @description Represents a texture component
@@ -13,7 +13,6 @@ import Drawable from "./Drawable";
  * @param {boolean} useLighting - Whether the texture should react to lighting
  */
 declare class Texture extends Drawable {
-    constructor(texturePath?: string, frameWidth?: number, frameHeight?: number, framesPerRow?: number, totalFrames?: number, animationSpeed?: number, autoPlay?: boolean, pixelart?: boolean, useLighting?: boolean);
+    constructor(texturePath?: {}, frameWidth?: number, frameHeight?: number, framesPerRow?: number, totalFrames?: number, animationSpeed?: number, autoPlay?: boolean, pixelart?: boolean, useLighting?: boolean);
 }
-export default Texture;
-//# sourceMappingURL=Texture.d.ts.map
+import Drawable from "./Drawable.js";

package/dist/types/src/TextureAtlas.d.ts

@@ -0,0 +1,55 @@
+export default TextureAtlas;
+/**
+ * @class TextureAtlas
+ * @description Loads a packed sprite atlas (image + frame rectangles) and applies
+ * named frames to Drawables as normalized UV regions. Accepts TexturePacker
+ * JSON (hash or array `frames`) or a plain `{ name: {x,y,w,h} }` map.
+ *
+ * @example
+ * const atlas = await TextureAtlas.load("sheet.png", sheetJson, true);
+ * const sprite = new Texture(atlas.texturePath, 0, 0, 1, 1, 0, false, true);
+ * obj.addComponent(sprite);
+ * atlas.applyTo(sprite, "player_idle_0");
+ */
+declare class TextureAtlas {
+    /**
+     * @method load
+     * @description Loads the atlas image (caching its GL texture) and parses frames.
+     * @param {string} texturePath
+     * @param {Object} atlasJson - Atlas description
+     * @param {boolean} [pixelart] - Filter mode for the cached texture
+     * @returns {Promise<TextureAtlas>}
+     */
+    static load(texturePath: string, atlasJson: any, pixelart?: boolean): Promise<TextureAtlas>;
+    /** @private */
+    private static _parse;
+    constructor(texturePath: any, frames: any, width: any, height: any);
+    texturePath: any;
+    frames: any;
+    width: any;
+    height: any;
+    /**
+     * @method getFrame
+     * @description Returns the pixel rect { x, y, w, h } for a frame name.
+     */
+    getFrame(name: any): any;
+    /**
+     * @method getRegion
+     * @description Returns the normalized UV region for a frame name.
+     * @returns {{left,top,right,bottom}|null}
+     */
+    getRegion(name: any): {
+        left: any;
+        top: any;
+        right: any;
+        bottom: any;
+    } | null;
+    /**
+     * @method applyTo
+     * @description Applies a frame's UV region to a Drawable.
+     * @param {Drawable} drawable
+     * @param {string} name - Frame name
+     * @returns {TextureAtlas} - this
+     */
+    applyTo(drawable: Drawable, name: string): TextureAtlas;
+}