emeraldengine 2.2.1 → 3.1.0

package/dist/types/src/managers/SceneManager.d.ts

@@ -0,0 +1,44 @@
+export default SceneManager;
+/**
+ * @class SceneManager
+ * @description Manages the scene for the game
+ */
+declare class SceneManager {
+    /**
+     * @method setScene
+     * @description Sets the scene
+     * @param {Scene} scene - The scene to set
+     */
+    static setScene(scene: Scene): void;
+    /**
+     * @method getScene
+     * @description Returns the scene
+     * @returns {Scene} - The scene
+     */
+    static getScene(): Scene;
+    /**
+     * @method transitionTo
+     * @description Switches the active scene, optionally behind a ScreenEffects
+     * fade. With `screenEffects` provided the screen fades out, the scene is
+     * swapped (and your optional `onSwap` runs) while covered, then fades back in.
+     * Without it the swap happens immediately.
+     *
+     * @param {Scene} scene - The scene to make active
+     * @param {Object} [options]
+     * @param {ScreenEffects} [options.screenEffects] - Effects layer to fade with
+     * @param {Function} [options.onSwap] - `(scene) => void|Promise`, run during
+     *   the covered swap (e.g. (re)build the new scene's contents)
+     * @param {number} [options.duration] - Fade duration (seconds)
+     * @param {Color} [options.color] - Fade color
+     * @returns {Promise<Scene>} - Resolves with the new scene
+     */
+    static transitionTo(scene: Scene, options?: {
+        screenEffects?: ScreenEffects;
+        onSwap?: Function;
+        duration?: number;
+        color?: Color;
+    }): Promise<Scene>;
+}
+declare namespace SceneManager {
+    let scene: any;
+}

package/dist/types/src/managers/ShaderManager.d.ts

@@ -0,0 +1,55 @@
+/**
+ * @class ShaderManager
+ * @description Manages the shaders for the game
+ */
+export class ShaderManager {
+    constructor(gl: any);
+    gl: any;
+    shaders: Map<any, any>;
+    activeShader: any;
+    /**
+     * @method createShader
+     * @description Creates a shader
+     * @param {string} name - The name of the shader
+     * @param {string} vertexSource - The vertex shader source
+     * @param {string} fragmentSource - The fragment shader source
+     */
+    createShader(name: string, vertexSource: string, fragmentSource: string): {
+        program: any;
+        attribLocations: any;
+        uniformLocations: any;
+    };
+    /**
+     * @method compileShader
+     * @description Compiles a shader
+     * @param {string} source - The shader source
+     * @param {number} type - The type of shader
+     */
+    compileShader(source: string, type: number): any;
+    /**
+     * @method useShader
+     * @description Uses a shader
+     * @param {string} name - The name of the shader
+     */
+    useShader(name: string): any;
+    /**
+     * @method getActiveShader
+     * @description Returns the active shader
+     * @returns {Object} - The active shader
+     */
+    getActiveShader(): any;
+    /**
+     * @method getAttributeLocations
+     * @description Returns the attribute locations for a shader program
+     * @param {WebGLProgram} program - The shader program
+     * @returns {Object} - The attribute locations
+     */
+    getAttributeLocations(program: WebGLProgram): any;
+    /**
+     * @method getUniformLocations
+     * @description Returns the uniform locations for a shader program
+     * @param {WebGLProgram} program - The shader program
+     * @returns {Object} - The uniform locations
+     */
+    getUniformLocations(program: WebGLProgram): any;
+}

package/dist/types/src/managers/TextureManager.d.ts

@@ -0,0 +1,102 @@
+export default TextureManager;
+/**
+ * @class TextureManager
+ * @description Caches loaded images and GL textures so that many drawables
+ * sharing the same texture path download and upload the image only once.
+ *
+ * Textures are immutable after upload in this engine, so the same GL texture
+ * object can safely be bound by any number of objects. The GL-texture cache is
+ * keyed by path *and* filter mode, because pixel-art (NEAREST) and smooth
+ * (LINEAR) sampling require separate texture objects.
+ */
+declare class TextureManager {
+    /**
+     * @method loadImage
+     * @description Loads (and caches) an HTMLImageElement for a given path.
+     * Concurrent requests for the same path share a single in-flight load.
+     * @param {string} path - The path (or data URL) of the image
+     * @returns {Promise<HTMLImageElement>} - The loaded image
+     */
+    static loadImage(path: string): Promise<HTMLImageElement>;
+    /**
+     * @method getTexture
+     * @description Returns a cached GL texture for the given path, creating and
+     * uploading it on first request. Subsequent calls reuse the same texture.
+     * @param {string} path - The path (or data URL) of the texture
+     * @param {boolean} pixelart - Whether to sample with NEAREST (pixel art) filtering
+     * @returns {Promise<{texture: WebGLTexture, width: number, height: number}>}
+     */
+    static getTexture(path: string, pixelart?: boolean): Promise<{
+        texture: WebGLTexture;
+        width: number;
+        height: number;
+    }>;
+    /**
+     * @method _upload
+     * @description Loads the image (via the shared image cache) and uploads it
+     * as a GL texture with the requested filtering.
+     * @private
+     */
+    private static _upload;
+    /**
+     * @method restoreAll
+     * @description Re-uploads every cached texture after a WebGL context loss.
+     * The image cache survives the loss, so this is upload-only (no network).
+     * Reference counts are untouched: they track logical ownership by
+     * drawables, which still exist.
+     */
+    static restoreAll(): void;
+    /**
+     * @method preload
+     * @description Eagerly loads a list of texture paths so they are ready (and
+     * cached) before the first frame that needs them.
+     * @param {string[]} paths - The texture paths to preload
+     * @param {boolean} pixelart - Whether to use pixel-art filtering
+     * @returns {Promise<void>}
+     */
+    static preload(paths: string[], pixelart?: boolean): Promise<void>;
+    /**
+     * @method has
+     * @description Checks whether a GL texture is already cached for a path
+     * @param {string} path - The texture path
+     * @param {boolean} pixelart - Whether the pixel-art variant is meant
+     * @returns {boolean}
+     */
+    static has(path: string, pixelart?: boolean): boolean;
+    /**
+     * @method retain
+     * @description Increments the reference count for a cached texture. Every
+     * Drawable that resolves a texture through getTexture() retains it; when the
+     * last user releases it, the GL texture is freed. Call retain/release in
+     * pairs (Drawable.dispose does the release for you).
+     * @param {string} path - The texture path
+     * @param {boolean} pixelart - Whether the pixel-art variant is meant
+     */
+    static retain(path: string, pixelart?: boolean): void;
+    /**
+     * @method release
+     * @description Decrements a texture's reference count; when it reaches zero
+     * the GL texture is deleted and dropped from the cache (the CPU-side image
+     * cache is kept so a later reload is cheap).
+     * @param {string} path - The texture path
+     * @param {boolean} pixelart - Whether the pixel-art variant is meant
+     */
+    static release(path: string, pixelart?: boolean): void;
+    /**
+     * @method refCount
+     * @description Current reference count for a texture (0 if uncached).
+     * @returns {number}
+     */
+    static refCount(path: any, pixelart?: boolean): number;
+    /**
+     * @method clear
+     * @description Deletes all cached GL textures and clears the image cache.
+     * Useful when tearing down a context or freeing memory between levels.
+     */
+    static clear(): void;
+}
+declare namespace TextureManager {
+    let images: Map<any, any>;
+    let textures: Map<any, any>;
+    let refs: Map<any, any>;
+}

package/dist/types/src/particlesystem/Particle.d.ts

@@ -0,0 +1,64 @@
+export default Particle;
+/**
+ * @class Particle
+ * @description Represents a particle in the particle system
+ * @param {InstancedTexture} instancedTexture - The instanced texture
+ * @param {Vector3} position - The position of the particle
+ * @param {number} rotation - The rotation of the particle
+ * @param {Vector2} scale - The scale of the particle
+ * @param {ParticleSettings} settings - The settings for the particle
+ */
+declare class Particle {
+    /** @private */
+    private static _normColor;
+    constructor(instancedTexture: any, position: any, rotation: any, scale: any, settings: any, velocity: any);
+    /**
+     * @method reset
+     * @description (Re)initializes the particle. Used by the pool so particle
+     * objects can be reused without allocating. `velocity` overrides
+     * settings.velocity when provided (avoids a ParticleSettings allocation per
+     * particle).
+     */
+    reset(instancedTexture: any, position: any, rotation: any, scale: any, settings: any, velocity: any): void;
+    settings: any;
+    lifetime: any;
+    age: number;
+    velocity: {
+        x: any;
+        y: any;
+    };
+    gravity: {
+        x: any;
+        y: any;
+    };
+    instance: Instance;
+    /** @private */
+    private _baseScaleX;
+    /** @private */
+    private _baseScaleY;
+    /** @private */
+    private _colFrom;
+    /** @private */
+    private _colTo;
+    instancedTexture: any;
+    /** @private */
+    private _applyOverLife;
+    /**
+     * @method update
+     * @description Updates the particle
+     * @param {number} dt - The delta time
+     */
+    update(dt: number): void;
+    /**
+     * @method isAlive
+     * @description Checks if the particle is alive
+     * @returns {boolean} - True if the particle is alive
+     */
+    isAlive(): boolean;
+    /**
+     * @method destroy
+     * @description Destroys the particle
+     */
+    destroy(): void;
+}
+import Instance from "../Instance.js";

package/dist/types/{particlesystem → src/particlesystem}/ParticleSettings.d.ts

@@ -1,18 +1,4 @@
-import { Vector2 } from "../Physics";
-interface ParticleSettingsConfig {
-    lifetime?: number;
-    velocity?: Vector2;
-    gravity?: Vector2;
-    amount?: number;
-    direction?: Vector2;
-    spread?: number;
-    emissionRate?: number;
-    frame?: number;
-    offset?: number;
-    rotation?: number;
-    scale?: Vector2;
-    animation?: any;
-}
+export default ParticleSettings;
 /**
  * @class ParticleSettings
  * @description Represents the settings for a particle system
@@ -30,6 +16,23 @@ interface ParticleSettingsConfig {
  * @param {Array} animation - The animation of the particle
  */
 declare class ParticleSettings {
+    constructor({ lifetime, velocity, gravity, amount, direction, spread, emissionRate, frame, offset, rotation, scale, animation, shape, shapeRadius, shapeSize, scaleOverLife, alphaOverLife, colorOverLife, rotationSpeed, drag, }?: {
+        lifetime?: number;
+        velocity?: Vector2;
+        gravity?: Vector2;
+        amount?: number;
+        direction?: Vector2;
+        spread?: number;
+        emissionRate?: number;
+        shape?: string;
+        shapeRadius?: number;
+        shapeSize?: Vector2;
+        scaleOverLife?: any;
+        alphaOverLife?: any;
+        colorOverLife?: any;
+        rotationSpeed?: number;
+        drag?: number;
+    });
     lifetime: number;
     velocity: Vector2;
     gravity: Vector2;
@@ -37,13 +40,18 @@ declare class ParticleSettings {
     direction: Vector2;
     spread: number;
     emissionRate: number;
-    frame?: number;
-    offset?: number;
-    rotation?: number;
-    scale?: Vector2;
-    animation?: any;
-    constructor({ lifetime, velocity, gravity, amount, direction, spread, emissionRate, // particles per second
-    frame, offset, rotation, scale, animation }?: ParticleSettingsConfig);
+    frame: any;
+    offset: any;
+    rotation: any;
+    scale: any;
+    animation: any;
+    shape: string;
+    shapeRadius: number;
+    shapeSize: Vector2;
+    scaleOverLife: any;
+    alphaOverLife: any;
+    colorOverLife: any;
+    rotationSpeed: number;
+    drag: number;
 }
-export default ParticleSettings;
-//# sourceMappingURL=ParticleSettings.d.ts.map
+import { Vector2 } from "../Physics.js";

package/dist/types/{particlesystem → src/particlesystem}/Particles.d.ts

@@ -1,8 +1,3 @@
-import GameObject from "../components/GameObject";
-import InstancedTexture from "../InstancedTexture";
-import { Vector2, Vector3 } from "../Physics";
-import Particle from "./Particle";
-import ParticleSettings from "./ParticleSettings";
 /**
  * @class Particles
  * @description Represents a particle system
@@ -16,13 +11,14 @@ import ParticleSettings from "./ParticleSettings";
  * @param {ParticleSettings} settings - The settings for the particle system
  */
 export default class Particles {
+    constructor(name: any, texturePath: any, frameWidth: any, frameHeight: any, framesPerRow: any, totalFrames: any, duration?: number, settings?: any);
     settings: ParticleSettings;
     position: Vector3;
-    rotation: number;
-    scale: Vector2;
-    particles: Particle[];
+    rotation: any;
+    scale: any;
+    particles: any[];
     duration: number;
-    offset: number;
+    offset: any;
     elapsed: number;
     active: boolean;
     instanceCount: number;
@@ -31,14 +27,15 @@ export default class Particles {
     stopped: boolean;
     gameObject: GameObject;
     instancedTexture: InstancedTexture;
-    lastEmitPosition: Vector3;
-    constructor(name: string, texturePath: string, frameWidth: number, frameHeight: number, framesPerRow: number, totalFrames: number, duration?: number, settings?: ParticleSettings | null);
+    /** @private */
+    private _pool;
     /**
      * @method play
      * @description Plays the particle system
      * @param {Vector3} newPosition - The position to play the particle system at
      */
     play(newPosition: Vector3): void;
+    lastEmitPosition: Vector3;
     /**
      * @method emitParticles
      * @description Emits particles
@@ -46,6 +43,14 @@ export default class Particles {
      * @param {Vector3} position - The position to emit the particles at
      */
     emitParticles(count: number, position: Vector3): void;
+    /**
+     * @method _spawnOffset
+     * @description Returns a spawn offset { x, y } from the emitter center based on
+     * the configured emitter shape.
+     * @param {number} finalAngle - The chosen emission angle (for the cone shape)
+     * @private
+     */
+    private _spawnOffset;
     /**
      * @method update
      * @description Updates the particle system
@@ -68,4 +73,7 @@ export default class Particles {
      */
     reset(): void;
 }
-//# sourceMappingURL=Particles.d.ts.map
+import ParticleSettings from "./ParticleSettings.js";
+import { Vector3 } from "../Physics.js";
+import GameObject from "../components/GameObject.js";
+import InstancedTexture from "../InstancedTexture.js";

package/dist/types/src/physics/AABB.d.ts

@@ -0,0 +1,92 @@
+export default AABB;
+/**
+ * @class AABB
+ * @description An axis-aligned bounding box in physics space. Used by the
+ * broadphase to reject pairs long before any real collision maths runs.
+ */
+declare class AABB {
+    /**
+     * @method testOverlap
+     * @description True when two boxes overlap.
+     * @param {AABB} a
+     * @param {AABB} b
+     * @returns {boolean}
+     */
+    static testOverlap(a: AABB, b: AABB): boolean;
+    constructor(lowerX?: number, lowerY?: number, upperX?: number, upperY?: number);
+    lowerBound: Vec2;
+    upperBound: Vec2;
+    /**
+     * @method set
+     * @description Sets all four bounds in place.
+     * @param {number} lx
+     * @param {number} ly
+     * @param {number} ux
+     * @param {number} uy
+     * @returns {AABB} - this
+     */
+    set(lx: number, ly: number, ux: number, uy: number): AABB;
+    /**
+     * @method copy
+     * @description Copies another AABB.
+     * @param {AABB} other
+     * @returns {AABB} - this
+     */
+    copy(other: AABB): AABB;
+    /**
+     * @method getCenter
+     * @description Returns the box center.
+     * @returns {Vec2}
+     */
+    getCenter(): Vec2;
+    /**
+     * @method getExtents
+     * @description Returns the box half-extents.
+     * @returns {Vec2}
+     */
+    getExtents(): Vec2;
+    /**
+     * @method getPerimeter
+     * @description Perimeter of the box, the cost function the AABB tree
+     * minimizes when choosing where to insert a leaf.
+     * @returns {number}
+     */
+    getPerimeter(): number;
+    /**
+     * @method combine
+     * @description Sets this box to the union of two others.
+     * @param {AABB} a
+     * @param {AABB} b
+     * @returns {AABB} - this
+     */
+    combine(a: AABB, b: AABB): AABB;
+    /**
+     * @method extend
+     * @description Grows the box by `amount` on every side.
+     * @param {number} amount
+     * @returns {AABB} - this
+     */
+    extend(amount: number): AABB;
+    /**
+     * @method contains
+     * @description True when `other` lies entirely inside this box.
+     * @param {AABB} other
+     * @returns {boolean}
+     */
+    contains(other: AABB): boolean;
+    /**
+     * @method containsPoint
+     * @description True when a point lies inside this box.
+     * @param {Object} p - `{ x, y }`
+     * @returns {boolean}
+     */
+    containsPoint(p: any): boolean;
+    /**
+     * @method rayCast
+     * @description Slab test of a ray against this box.
+     * @param {Object} input - `{ p1, p2, maxFraction }`
+     * @returns {boolean} - True if the ray hits the box within maxFraction
+     */
+    rayCast(input: any): boolean;
+}
+import { Vec2 } from "./Math2D.js";