emeraldengine 2.2.1 → 3.0.0

package/src/particlesystem/Particles.js

@@ -34,8 +34,8 @@ export default class Particles {
     this.rotation = this.settings.rotation;
     this.scale = this.settings.scale;
     this.particles = [];
-    this.duration = duration; // How long the effect lasts in seconds
-    this.offset = this.settings.offset; // Distance from center
+    this.duration = duration;
+    this.offset = this.settings.offset;
     this.elapsed = 0;
     this.active = false;
     this.instanceCount = this.settings.amount;
@@ -56,12 +56,14 @@ export default class Particles {
       framesPerRow,
       totalFrames,
       this.settings.animation ? this.settings.animation.speed : 0,
-      this.settings.animation ? true : false,
+      this.settings.animation ? true : false
     );
-    this.instancedTexture.clearInstances(); // Ensure clean state on creation
+    this.instancedTexture.clearInstances();
     this.gameObject.addComponent(this.instancedTexture);
-    
-    // Initialize clean state
+
+    /** @private */
+    this._pool = [];
+
     this.particles = [];
     this.active = false;
     this.elapsed = 0;
@@ -85,10 +87,8 @@ export default class Particles {
     this.stopped = false;
     this.lastEmitPosition = newPosition;
     if (this.settings.emissionRate === Infinity) {
-      // One-shot: emit all at once
       this.emitParticles(this.settings.amount, newPosition);
     }
-    // For continuous, particles will be emitted in update()
   }
 
   /**
@@ -113,27 +113,78 @@ export default class Particles {
         x: Math.cos(finalAngle) * speed,
         y: Math.sin(finalAngle) * speed,
       };
-      const offsetVariation = (Math.random() - 0.5) * this.offset * 0.5;
+      const spawn = this._spawnOffset(finalAngle);
       const pos = new Vector3(
-        position.x + Math.cos(finalAngle) * (this.offset + offsetVariation),
-        position.y + Math.sin(finalAngle) * (this.offset + offsetVariation),
+        position.x + spawn.x,
+        position.y + spawn.y,
         position.z
       );
-      const particleSettings = new ParticleSettings({
-        ...this.settings,
-        velocity,
-      });
-      if(this.particles.length < this.instanceCount) {
-        let particle = new Particle(
-          this.instancedTexture,
-          pos,
-          this.rotation,
-          this.scale,
-          particleSettings
-        );
+      if (this.particles.length < this.instanceCount) {
+        let particle = this._pool.pop();
+        if (particle) {
+          particle.reset(
+            this.instancedTexture,
+            pos,
+            this.rotation,
+            this.scale,
+            this.settings,
+            velocity
+          );
+        } else {
+          particle = new Particle(
+            this.instancedTexture,
+            pos,
+            this.rotation,
+            this.scale,
+            this.settings,
+            velocity
+          );
+        }
         this.particles.push(particle);
       }
-      
+    }
+  }
+
+  /**
+   * @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
+   */
+  _spawnOffset(finalAngle) {
+    const s = this.settings;
+    const radius = s.shapeRadius || 0;
+    switch (s.shape) {
+      case "point":
+        return { x: 0, y: 0 };
+      case "circle": {
+        const a = Math.random() * Math.PI * 2;
+        const r = Math.sqrt(Math.random()) * radius;
+        return { x: Math.cos(a) * r, y: Math.sin(a) * r };
+      }
+      case "ring": {
+        const a = Math.random() * Math.PI * 2;
+        return { x: Math.cos(a) * radius, y: Math.sin(a) * radius };
+      }
+      case "box": {
+        const w = s.shapeSize ? s.shapeSize.x : 0;
+        const h = s.shapeSize ? s.shapeSize.y : 0;
+        return {
+          x: (Math.random() - 0.5) * w,
+          y: (Math.random() - 0.5) * h,
+        };
+      }
+      case "cone":
+      default: {
+        const baseOffset = this.offset || 0;
+        const offsetVariation = (Math.random() - 0.5) * baseOffset * 0.5;
+        const dist = baseOffset + offsetVariation;
+        return {
+          x: Math.cos(finalAngle) * dist,
+          y: Math.sin(finalAngle) * dist,
+        };
+      }
     }
   }
 
@@ -145,7 +196,6 @@ export default class Particles {
   update(deltaTime) {
     if (!this.active || this.stopped) return;
     this.elapsed += deltaTime;
-    // Continuous emission
     if (
       this.settings.emissionRate !== Infinity &&
       this.elapsed <= this.duration
@@ -164,25 +214,24 @@ export default class Particles {
         this.emittedParticles += toEmit;
       }
     }
-    // Update all particles and remove dead ones
     this.particles = this.particles.filter((particle) => {
       particle.update(deltaTime);
       if (!particle.isAlive()) {
         particle.destroy();
+        this._pool.push(particle);
         return false;
       }
       return true;
     });
-    if (
-      this.elapsed >= this.duration &&
-      this.settings.emissionRate !== Infinity
-    ) {
+    const pastDuration = this.elapsed >= this.duration;
+    if (pastDuration && this.settings.emissionRate !== Infinity) {
       this.stopped = true;
     }
-    if (this.stopped && this.particles.length === 0) {
+    if ((this.stopped || pastDuration) && this.particles.length === 0) {
       this.instancedTexture.clearInstances();
       this.particles = [];
       this.active = false;
+      this.stopped = true;
     }
   }
 

package/dist/types/Drawable.d.ts

@@ -1,157 +0,0 @@
-import Color from "./Color";
-import { mat4 } from "gl-matrix";
-import GameObject from "./components/GameObject";
-/**
- * @class Drawable
- * @description A class that represents a drawable object
- * @param {WebGLRenderingContext} gl - The WebGL rendering context
- * @param {Object} programInfo - The program information
- * @param {WebGLBuffer} verticesBuffer - The vertices buffer
- * @param {WebGLBuffer} texCoordBuffer - The texture coordinate buffer
- * @param {Array} vertices - The vertices of the object
- * @param {boolean} useTexture - Whether to use a texture
- * @param {string} texturePath - The path to the texture
- * @param {number} frameWidth - The width of the frame
- * @param {number} frameHeight - The height of the frame
- * @param {number} framesPerRow - The number of frames per row
- * @param {number} totalFrames - The total number of frames
- * @param {number} animationSpeed - The speed of the animation
- * @param {boolean} autoplay - Whether to autoplay the animation
- * @param {boolean} pixelart - Whether to use pixel art
- * @param {boolean} useLighting - Whether to use lighting
- */
-declare class Drawable {
-    gl: WebGL2RenderingContext;
-    programInfo: any;
-    id: string;
-    verticesBuffer: WebGLBuffer;
-    texCoordBuffer: WebGLBuffer;
-    vertices: number[];
-    color: Color;
-    texturePath: string;
-    texture: WebGLTexture | null;
-    useTexture: boolean;
-    frameWidth: number;
-    frameHeight: number;
-    framesPerRow: number;
-    totalFrames: number;
-    currentFrame: number;
-    animationSpeed: number;
-    lastFrameTime: number;
-    textureWidth: number;
-    textureHeight: number;
-    isPlaying: boolean;
-    playOnce: boolean;
-    originalTexture: WebGLTexture | null;
-    mirrored: boolean;
-    animationType: string;
-    currentAnimationArray: number[];
-    currentAnimationIndex: number;
-    shouldRevertAfterPlayingOnce: boolean;
-    revertAnimation: number[];
-    parentObject: any;
-    isActive: boolean;
-    isWireframe: boolean;
-    callbackFunction: () => void;
-    pixelart: boolean;
-    useLighting: boolean;
-    constructor(gl: WebGL2RenderingContext, programInfo: any, verticesBuffer: WebGLBuffer, texCoordBuffer: WebGLBuffer, vertices: number[], useTexture: boolean, texturePath: string, frameWidth?: number, frameHeight?: number, framesPerRow?: number, totalFrames?: number, animationSpeed?: number, autoplay?: boolean, pixelart?: boolean, useLighting?: boolean);
-    /**
-     * @method setIsWireframe
-     * @description Sets the wireframe mode
-     * @param {boolean} bool - Whether to enable wireframe mode
-     */
-    setIsWireframe(bool: boolean): void;
-    /**
-     * @method setUseLighting
-     * @description Sets the lighting mode
-     * @param {boolean} useLighting - Whether to enable lighting reaction
-     */
-    setUseLighting(useLighting: boolean): void;
-    /**
-     * @method setIsActive
-     * @description Sets the active state
-     * @param {boolean} bool - Whether to enable the active state
-     */
-    setIsActive(bool: boolean): void;
-    /**
-     * @method setParent
-     * @description Sets the parent object
-     * @param {Object} parent - The parent object
-     */
-    setParent(parent: GameObject): void;
-    /**
-     * @method getParent
-     * @description Gets the parent object
-     * @returns {Object} - The parent object
-     */
-    getParent(): GameObject | null;
-    /**
-     * @method setColor
-     * @description Sets the color of the object
-     * @param {Color} color - The color to set
-     */
-    setColor(color: Color): void;
-    /**
-     * @method initTexture
-     * @description Initializes the texture
-     */
-    initTexture(): Promise<void>;
-    /**
-     * @method updateAnimation
-     * @description Updates the animation
-     * @param {number} currentTime - The current time
-     */
-    updateAnimation(currentTime: number): void;
-    /**
-     * @method getAnimation
-     * @description Gets the animation
-     * @returns {Array} - The animation
-     */
-    getAnimation(): number[] | string | null;
-    /**
-     * @method playAnimation
-     * @description Plays an animation
-     * @param {Array} animation - The animation to play
-     * @param {number} animationSpeed - The speed of the animation
-     */
-    playAnimation(animation: number[], animationSpeed?: number): void;
-    /**
-     * @method setFrame
-     * @description Sets the frame
-     * @param {number} frame - The frame to set
-     */
-    setFrame(frame: number): void;
-    /**
-     * @method playAnimationOnce
-     * @description Plays an animation once
-     * @param {Array} animation - The animation to play
-     * @param {Array} defaultAnimation - The default animation
-     * @param {number} animationSpeed - The speed of the animation
-     * @param {function} callbackFunction - The callback function
-     */
-    playAnimationOnce(animation: number[], defaultAnimation?: number[] | null, animationSpeed?: number, callbackFunction?: (() => void) | null): void;
-    /**
-     * @method stopAnimation
-     * @description Stops the animation
-     */
-    stopAnimation(): void;
-    /**
-     * @method draw
-     * @description Draws the object
-     * @param {mat4} globalViewMatrix - The global view matrix
-     * @param {WebGLUniformLocation} uniformLocation - The uniform location
-     * @param {number} currentTime - The current time
-     * @param {Object} objectTransform - The object transform
-     */
-    draw(globalViewMatrix: mat4, uniformLocation: WebGLUniformLocation, currentTime: number, objectTransform: any): void;
-    /**
-     * @method loadImage
-     * @description Loads an image
-     * @param {string} path - The path to the image
-     * @returns {Promise} - The promise
-     */
-    loadImage: (path: string) => Promise<unknown>;
-}
-export default Drawable;
-//# sourceMappingURL=Drawable.d.ts.map

package/dist/types/Emerald.d.ts

@@ -1,73 +0,0 @@
-import Color from "./Color";
-import { Vector3 } from "./Physics";
-import PointLight from "./lights/PointLight";
-import DirectionalLight from "./lights/DirectionalLight";
-import Scene from "./Scene";
-/**
- * @class Emerald
- * @description A class that represents the Emerald engine
- * @param {HTMLCanvasElement} canvas - The canvas element
- */
-declare class Emerald {
-    shaderProgram: WebGLProgram;
-    gl: WebGL2RenderingContext;
-    programInfo: any;
-    camera: any;
-    ambientLight: Vector3;
-    pointLights: PointLight[];
-    directionalLights: DirectionalLight[];
-    debugLogged: boolean;
-    backgroundColor: {
-        r: number;
-        g: number;
-        b: number;
-        a: number;
-    };
-    constructor(canvas: HTMLCanvasElement);
-    /**
-     * @method setAmbientLight
-     * @description Sets the ambient light for the scene
-     * @param {Vector3} vector3 - The ambient light color as a Vector3 instance
-     */
-    setAmbientLight(vector3: Vector3): void;
-    /**
-     * @method resize
-     * @description Resizes the canvas
-     * @param {number} width - The width of the canvas
-     * @param {number} height - The height of the canvas
-     */
-    resize(width: number, height: number): void;
-    /**
-     * @method addPointLight
-     * @description Adds a point light to the scene
-     * @param {PointLight} pointLight - The point light to add
-     */
-    addPointLight(pointLight: PointLight): void;
-    /**
-     * @method addDirectionalLight
-     * @description Adds a directional light to the scene
-     * @param {DirectionalLight} directionalLight - The directional light to add
-     */
-    addDirectionalLight(directionalLight: DirectionalLight): void;
-    /**
-     * @method removeDirectionalLight
-     * @description Removes a directional light from the scene
-     * @param {DirectionalLight} directionalLight - The directional light to remove
-     */
-    removeDirectionalLight(directionalLight: DirectionalLight): void;
-    /**
-     * @method setBackgroundColor
-     * @description Sets the background color of the scene
-     * @param {Color} color - The background color
-     */
-    setBackgroundColor(color: Color): void;
-    /**
-     * @method drawScene
-     * @description Draws the scene
-     * @param {Scene} scene - The scene to draw
-     * @param {number} deltaTime - The delta time
-     */
-    drawScene(scene: Scene, deltaTime: number): void;
-}
-export default Emerald;
-//# sourceMappingURL=Emerald.d.ts.map

package/dist/types/GLUtils.d.ts

@@ -1,6 +0,0 @@
-declare function initShaderProgram(gl: WebGL2RenderingContext, vShader: string, fShader: string): WebGLProgram | null;
-declare function loadShader(gl: WebGL2RenderingContext, type: number, source: string): WebGLShader | null;
-declare const initVertexBuffer: (gl: WebGL2RenderingContext, vertices: number[]) => WebGLBuffer | null;
-declare function initInstancedBuffer(gl: WebGL2RenderingContext, data: Float32Array, itemSize: number): WebGLBuffer | null;
-export { initShaderProgram, loadShader, initVertexBuffer, initInstancedBuffer };
-//# sourceMappingURL=GLUtils.d.ts.map

package/dist/types/Scene.d.ts

@@ -1,39 +0,0 @@
-import GameObject from "./components/GameObject";
-/**
- * @class Scene
- * @description Represents a scene
- * @param {Array} objects - The objects in the scene
- */
-declare class Scene {
-    objects: GameObject[];
-    constructor(objects?: GameObject[]);
-    /**
-     * @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
-     * @param {GameObject} object - The object to remove
-     */
-    remove(object: GameObject): 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: GameObject, bool: boolean): void;
-    [Symbol.iterator](): Iterator<GameObject>;
-    forEach(callback: (object: GameObject) => void): void;
-}
-export default Scene;
-//# sourceMappingURL=Scene.d.ts.map

package/dist/types/Shaders.d.ts

@@ -1,4 +0,0 @@
-declare const STANDARD_VERTEX_SHADER: string;
-declare const STANDARD_FRAGMENT_SHADER: string;
-export { STANDARD_VERTEX_SHADER, STANDARD_FRAGMENT_SHADER };
-//# sourceMappingURL=Shaders.d.ts.map

package/dist/types/Storage.d.ts

@@ -1,46 +0,0 @@
-/**
- * @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;
-}
-export default Storage;
-//# sourceMappingURL=Storage.d.ts.map

package/dist/types/Time.d.ts

@@ -1,22 +0,0 @@
-/**
- * @class Time
- * @description Represents the time
- * @param {number} deltaTime - The delta time
- */
-declare class Time {
-    static deltaTime: number;
-    /**
-     * @method getDeltaTime
-     * @description Returns the delta time
-     * @returns {number} - The delta time
-     */
-    static getDeltaTime(): number;
-    /**
-     * @method setDeltaTime
-     * @description Sets the delta time
-     * @param {number} deltaTime - The delta time
-     */
-    static setDeltaTime(deltaTime: number): void;
-}
-export default Time;
-//# sourceMappingURL=Time.d.ts.map

package/dist/types/Transform.d.ts

@@ -1,41 +0,0 @@
-import { Vector2, Vector3 } from "./Physics";
-/**
- * @class Transform
- * @description Represents a transform
- * @param {Vector3} position - The position of the transform
- * @param {number} rotation - The rotation of the transform
- * @param {Vector2} scale - The scale of the transform
- */
-declare class Transform {
-    position: Vector3;
-    rotation: number;
-    scale: Vector2;
-    constructor(position: Vector3, rotation: number, scale: Vector2);
-    /**
-     * @method equals
-     * @description Checks if the transform is equal to another transform
-     * @param {Transform} other - The other transform
-     * @returns {boolean} - True if the transform is equal to the other transform
-     */
-    equals(other: Transform): boolean;
-    /**
-     * @method getPosition
-     * @description Returns the position of the transform
-     * @returns {Vector3} - The position of the transform
-     */
-    getPosition(): Vector3;
-    /**
-     * @method getRotation
-     * @description Returns the rotation of the transform
-     * @returns {number} - The rotation of the transform
-     */
-    getRotation(): number;
-    /**
-     * @method getScale
-     * @description Returns the scale of the transform
-     * @returns {Vector2} - The scale of the transform
-     */
-    getScale(): Vector2;
-}
-export default Transform;
-//# sourceMappingURL=Transform.d.ts.map

package/dist/types/components/BoxColliderDebug.d.ts

@@ -1,19 +0,0 @@
-import Color from "../Color";
-import { Physics } from "../Physics";
-import GameObject from "./GameObject";
-import RigidBody from "./RigidBody";
-/**
- * @class BoxColliderDebug
- * @param {Rigidbody} rigidbody - The rigidbody to attach the collider to
- * @param {Color} color - The color of the collider
- */
-declare class BoxColliderDebug {
-    rigidbody: RigidBody;
-    physics: Physics;
-    scale: number;
-    color: Color;
-    gameObject: GameObject;
-    constructor(rigidbody: RigidBody, color?: Color | null);
-}
-export default BoxColliderDebug;
-//# sourceMappingURL=BoxColliderDebug.d.ts.map

package/dist/types/components/CircleColliderDebug.d.ts

@@ -1,19 +0,0 @@
-import Color from "../Color";
-import { Physics } from "../Physics";
-import GameObject from "./GameObject";
-import RigidBody from "./RigidBody";
-/**
- * @class CircleColliderDebug
- * @param {Rigidbody} rigidbody - The rigidbody to attach the collider to
- * @param {Color} color - The color of the collider
- */
-declare class CircleColliderDebug {
-    rigidbody: RigidBody;
-    physics: Physics;
-    scale: number;
-    color: Color;
-    gameObject: GameObject;
-    constructor(rigidbody: RigidBody, color?: Color | null);
-}
-export default CircleColliderDebug;
-//# sourceMappingURL=CircleColliderDebug.d.ts.map

package/dist/types/components/Collider.d.ts

@@ -1,53 +0,0 @@
-import { Vector2 } from "../Physics";
-import GameObject from "./GameObject";
-import RigidBody from "./RigidBody";
-import * as planck from "planck";
-/**
- * @class Collider
- * @param {Rigidbody} rigidbody - The rigidbody to attach the collider to
- * @param {boolean} isSensor - Whether the collider is a sensor
- * @param {GameObject} parentObject - The parent object of the collider
- */
-declare class Collider {
-    rigidbody: RigidBody;
-    parentObject: GameObject | null;
-    isSensor: boolean;
-    id: string;
-    name: string;
-    collider: planck.Fixture | null;
-    fixtureSize: Vector2 | null;
-    radius: number | null;
-    constructor(rigidbody: RigidBody, isSensor?: boolean, parentObject?: GameObject | null);
-    /**
-     * @method getRigidBody
-     * @description Returns the rigidbody of the collider
-     */
-    getRigidBody(): RigidBody;
-    /**
-     * @method setParent
-     * @description Sets the parent object of the collider
-     */
-    setParent(parent: GameObject): void;
-    /**
-     * @method getCollider
-     * @description Returns the collider
-     */
-    getCollider(): planck.Fixture | null;
-    /**
-     * @method getFixtureSize
-     * @description Returns the size of the collider
-     */
-    getFixtureSize(): Vector2 | null;
-    /**
-     * @method getRadius
-     * @description Returns the radius of the collider
-     */
-    getRadius(): number | null;
-    /**
-     * @method getParent
-     * @description Returns the parent object of the collider
-     */
-    getParent(): GameObject | null;
-}
-export default Collider;
-//# sourceMappingURL=Collider.d.ts.map