emeraldengine 2.2.1 → 3.1.0

package/index.js

@@ -9,9 +9,42 @@ import { Physics, Vector2, Vector3 } from "./src/Physics.js";
 import Scene from "./src/Scene.js";
 import { Square2D, Triangle2D, Circle2D } from "./src/Shapes.js";
 import Storage from "./src/Storage.js";
+import EmeraldDB from "./src/EmeraldDB.js";
 import Texture from "./src/Texture.js";
 import Time from "./src/Time.js";
 import Transform from "./src/Transform.js";
+import MathUtils from "./src/MathUtils.js";
+import Pool from "./src/Pool.js";
+import Animator from "./src/Animator.js";
+import Tilemap from "./src/Tilemap.js";
+import CameraController from "./src/CameraController.js";
+import Camera from "./src/Camera.js";
+import Easing from "./src/Easing.js";
+import Tween from "./src/Tween.js";
+import Timer from "./src/Timer.js";
+import StateMachine from "./src/StateMachine.js";
+import SpatialGrid from "./src/SpatialGrid.js";
+import TextureAtlas from "./src/TextureAtlas.js";
+import CanvasText from "./src/CanvasText.js";
+import DebugOverlay from "./src/DebugOverlay.js";
+import Serializer from "./src/Serializer.js";
+import Coroutine from "./src/Coroutine.js";
+import Interpolator from "./src/Interpolator.js";
+import ScreenEffects from "./src/ScreenEffects.js";
+import SpriteBatch from "./src/SpriteBatch.js";
+import ParticleEmitter from "./src/ParticleEmitter.js";
+import CollisionLayers from "./src/CollisionLayers.js";
+import TiledMap from "./src/importers/TiledMap.js";
+import Aseprite from "./src/importers/Aseprite.js";
+import ForgeLevel from "./src/importers/ForgeLevel.js";
+import RenderTarget from "./src/RenderTarget.js";
+import RenderStats from "./src/managers/RenderStats.js";
+import PostProcessor, { PostEffect } from "./src/PostProcessor.js";
+import PostEffects, { BloomEffect } from "./src/PostEffects.js";
+import Material from "./src/Material.js";
+import UI from "./src/UI.js";
+import InputManager from "./src/managers/InputManager.js";
+import Gamepad from "./src/managers/Gamepad.js";
 import Particle from "./src/particlesystem/Particle.js";
 import Particles from "./src/particlesystem/Particles.js";
 import ParticleSettings from "./src/particlesystem/ParticleSettings.js";
@@ -19,15 +52,20 @@ import AudioManager from "./src/managers/AudioManager.js";
 import CameraManager from "./src/managers/CameraManager.js";
 import EventManager from "./src/managers/EventManager.js";
 import SceneManager from "./src/managers/SceneManager.js";
+import TextureManager from "./src/managers/TextureManager.js";
+import AssetManager from "./src/managers/AssetManager.js";
+import NetworkManager from "./src/managers/NetworkManager.js";
 import DirectionalLight from "./src/lights/DirectionalLight.js";
 import PointLight from "./src/lights/PointLight.js";
 import BoxCollider from "./src/components/BoxCollider.js";
 import BoxColliderDebug from "./src/components/BoxColliderDebug.js";
 import CircleCollider from "./src/components/CircleCollider.js";
 import CircleColliderDebug from "./src/components/CircleColliderDebug.js";
+import PolygonCollider from "./src/components/PolygonCollider.js";
 import Collider from "./src/components/Collider.js";
 import GameObject from "./src/components/GameObject.js";
 import RigidBody from "./src/components/RigidBody.js";
+import Behaviour from "./src/components/Behaviour.js";
 
 export {
   Emerald,
@@ -45,9 +83,44 @@ export {
   Triangle2D,
   Circle2D,
   Storage,
+  EmeraldDB,
   Texture,
   Time,
   Transform,
+  MathUtils,
+  Pool,
+  Animator,
+  Tilemap,
+  CameraController,
+  Camera,
+  Easing,
+  Tween,
+  Timer,
+  StateMachine,
+  SpatialGrid,
+  TextureAtlas,
+  CanvasText,
+  DebugOverlay,
+  Serializer,
+  Coroutine,
+  Interpolator,
+  ScreenEffects,
+  SpriteBatch,
+  ParticleEmitter,
+  CollisionLayers,
+  TiledMap,
+  Aseprite,
+  ForgeLevel,
+  RenderTarget,
+  RenderStats,
+  PostProcessor,
+  PostEffect,
+  PostEffects,
+  BloomEffect,
+  Material,
+  UI,
+  InputManager,
+  Gamepad,
   Particle,
   Particles,
   ParticleSettings,
@@ -55,13 +128,18 @@ export {
   CameraManager,
   EventManager,
   SceneManager,
+  TextureManager,
+  AssetManager,
+  NetworkManager,
   DirectionalLight,
   PointLight,
   BoxCollider,
   BoxColliderDebug,
   CircleCollider,
   CircleColliderDebug,
+  PolygonCollider,
   Collider,
   GameObject,
   RigidBody,
+  Behaviour,
 };

package/package.json

@@ -1,62 +1,75 @@
 {
-    "name": "emeraldengine",
-    "version": "2.2.1",
-    "description": "2D graphics library for Web",
-    "type": "module",
-    "main": "index.js",
-    "module": "index.js",
-    "types": "dist/types/index.d.ts",
-    "exports": {
-        ".": {
-            "types": "./dist/types/index.d.ts",
-            "import": "./index.js",
-            "default": "./index.js"
-        }
-    },
-    "files": [
-        "index.js",
-        "src",
-        "dist/types"
-    ],
-    "sideEffects": false,
-    "engines": {
-        "node": ">=12.0.0"
-    },
-    "keywords": [
-        "2D",
-        "graphics",
-        "game",
-        "engine",
-        "webgl",
-        "webgl2",
-        "canvas",
-        "gamedev",
-        "rendering",
-        "sprite",
-        "particle-system",
-        "physics"
-    ],
-    "dependencies": {
-        "gl-matrix": "^3.4.3",
-        "planck": "^1.4.2"
-    },
-    "peerDependencies": {
-        "colyseus.js": "^0.16.16"
-    },
-    "peerDependenciesMeta": {
-        "colyseus.js": {
-            "optional": true
-        }
-    },
-    "author": "vahan-gev",
-    "license": "MIT",
-    "homepage": "https://github.com/vahan-gev/emeraldengine#readme",
-    "bugs": {
-        "url": "https://github.com/vahan-gev/emeraldengine/issues"
-    },
-    "repository": {
-        "type": "git",
-        "url": "git+https://github.com/vahan-gev/emeraldengine.git"
-    },
-    "devDependencies": {}
+  "name": "emeraldengine",
+  "version": "3.1.0",
+  "description": "2D graphics library for Web",
+  "type": "module",
+  "main": "index.js",
+  "module": "index.js",
+  "types": "dist/types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/types/index.d.ts",
+      "import": "./index.js",
+      "default": "./index.js"
+    }
+  },
+  "files": [
+    "index.js",
+    "src",
+    "dist/types"
+  ],
+  "sideEffects": false,
+  "engines": {
+    "node": ">=12.0.0"
+  },
+  "keywords": [
+    "2D",
+    "graphics",
+    "game",
+    "engine",
+    "webgl",
+    "webgl2",
+    "canvas",
+    "gamedev",
+    "rendering",
+    "sprite",
+    "particle-system",
+    "physics"
+  ],
+  "dependencies": {
+    "gl-matrix": "^3.4.3"
+  },
+  "peerDependencies": {
+    "colyseus.js": "^0.16.16"
+  },
+  "peerDependenciesMeta": {
+    "colyseus.js": {
+      "optional": true
+    }
+  },
+  "author": "vahan-gev",
+  "license": "MIT",
+  "homepage": "https://github.com/vahan-gev/emeraldengine#readme",
+  "bugs": {
+    "url": "https://github.com/vahan-gev/emeraldengine/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/vahan-gev/emeraldengine.git"
+  },
+  "scripts": {
+    "test": "node --test test/*.test.mjs",
+    "types": "tsc -p tsconfig.json",
+    "prepublishOnly": "npm run types && npm test",
+    "format": "prettier --write \"src/**/*.js\" \"test/**/*.mjs\" index.js",
+    "format:check": "prettier --check \"src/**/*.js\" index.js"
+  },
+  "devDependencies": {
+    "@colyseus/schema": "^3.0.76",
+    "colyseus": "^0.16.5",
+    "colyseus.js": "^0.16.22",
+    "prettier": "^3.3.0",
+    "typescript": "^5.9.3",
+    "vite": "^5.4.0"
+  }
 }

package/src/Animator.js

@@ -0,0 +1,95 @@
+import Behaviour from "./components/Behaviour.js";
+import Drawable from "./Drawable.js";
+
+/**
+ * @class Animator
+ * @description A component that manages named animation clips for a Texture (or
+ * any Drawable) on the same GameObject. Register clips once, then switch between
+ * them by name, handy for character states like idle/run/jump.
+ *
+ * @example
+ * const anim = new Animator();
+ * anim.addClip("idle", [0, 1, 2, 3], { speed: 150 });
+ * anim.addClip("jump", [8, 9], { speed: 100, loop: false });
+ * obj.addComponent(texture);
+ * obj.addComponent(anim);
+ * anim.play("idle");
+ */
+class Animator extends Behaviour {
+  constructor() {
+    super();
+    this.clips = new Map();
+    this.current = null;
+    this.drawable = null;
+  }
+
+  /**
+   * @method addClip
+   * @description Registers a named clip.
+   * @param {string} name - The clip name
+   * @param {number[]} frames - Frame indices to play
+   * @param {Object} [options] - { speed = 100, loop = true }
+   * @returns {Animator} - this
+   */
+  addClip(name, frames, options = {}) {
+    const { speed = 100, loop = true } = options;
+    this.clips.set(name, { frames, speed, loop });
+    return this;
+  }
+
+  start() {
+    this._resolveDrawable();
+  }
+
+  /** @private */
+  _resolveDrawable() {
+    if (!this.drawable && this.gameObject && this.gameObject.getComponent) {
+      this.drawable = this.gameObject.getComponent(Drawable);
+    }
+    return this.drawable;
+  }
+
+  /**
+   * @method play
+   * @description Plays a registered clip. No-op if it's already current.
+   * @param {string} name - The clip name
+   * @returns {Animator} - this
+   */
+  play(name) {
+    if (this.current === name) return this;
+    const clip = this.clips.get(name);
+    const drawable = this._resolveDrawable();
+    if (!clip || !drawable) return this;
+
+    this.current = name;
+    if (clip.loop) {
+      drawable.playAnimation(clip.frames, clip.speed);
+    } else {
+      drawable.playAnimationOnce(clip.frames, null, clip.speed, () => {
+        if (this.current === name) this.current = null;
+      });
+    }
+    return this;
+  }
+
+  /**
+   * @method stop
+   * @description Stops the current animation.
+   */
+  stop() {
+    const drawable = this._resolveDrawable();
+    if (drawable) drawable.stopAnimation();
+    this.current = null;
+  }
+
+  /**
+   * @method getCurrent
+   * @description Returns the name of the currently playing clip (or null).
+   * @returns {string|null}
+   */
+  getCurrent() {
+    return this.current;
+  }
+}
+
+export default Animator;

package/src/BitmapText.js

@@ -35,7 +35,7 @@ class BitmapText {
     color,
     position,
     rotation,
-    useLighting = false // Default to false for text as it's typically UI
+    useLighting = false
   ) {
     this.text = text;
     this.texturePath = texturePath;
@@ -61,7 +61,6 @@ class BitmapText {
     for (let i = 0; i < letters.length; i++) {
       this.letterDictionary[letters[i]] = i;
     }
-    // Initialize the bitmap font texture
     this.texture = new InstancedTexture(
       this.texturePath,
       text.length,
@@ -75,14 +74,14 @@ class BitmapText {
       this.useLighting
     );
 
-    // Apply the color to the texture if provided
     if (this.color) {
       this.texture.setColor(this.color);
     }
 
-    // Apply the lighting setting to the texture
     this.texture.setUseLighting(this.useLighting);
 
+    this.texture.setStatic(true);
+
     this.gameObject.addComponent(this.texture);
     for (let i = 0; i < text.length; i++) {
       const letter = text[i];
@@ -163,7 +162,6 @@ class BitmapText {
    * @param {Vector3} position - The position to set
    */
   setPosition(position) {
-    // Vector3
     this.position = position;
     this.gameObject.transform.position = position;
 
@@ -184,6 +182,7 @@ class BitmapText {
         instanceIndex++;
       }
     }
+    this.texture.markDirty();
   }
 
   /**
@@ -212,6 +211,7 @@ class BitmapText {
         instanceIndex++;
       }
     }
+    this.texture.markDirty();
   }
 
   /**
@@ -239,6 +239,7 @@ class BitmapText {
         instanceIndex++;
       }
     }
+    this.texture.markDirty();
   }
 }
 

package/src/Camera.js

@@ -0,0 +1,183 @@
+import Transform from "./Transform.js";
+import { Vector2, Vector3 } from "./Physics.js";
+
+/**
+ * @class Camera
+ * @description A view into the scene with its own transform (position, zoom,
+ * rotation) and a viewport rectangle. Multiple cameras can be added to an
+ * Emerald instance to render split-screen or picture-in-picture. The viewport
+ * is expressed in normalized [0..1] coordinates with the origin at the
+ * bottom-left of the canvas (matching WebGL).
+ *
+ * Backward compatible with the previous inline camera: position is stored
+ * negated internally, and setPosition/getPosition/setZoom/getZoom behave the
+ * same, so EventManager and CameraController are unaffected.
+ *
+ * @example
+ * const left = new Camera({ viewport: { x: 0, y: 0, width: 0.5, height: 1 } });
+ * const right = new Camera({ viewport: { x: 0.5, y: 0, width: 0.5, height: 1 } });
+ * emerald.setCameras([left, right]);
+ */
+class Camera {
+  constructor(options = {}) {
+    this.transform = new Transform(new Vector3(0, 0, 0), 0, new Vector2(1, 1));
+
+    const vp = options.viewport || {};
+    this.viewport = {
+      x: vp.x ?? 0,
+      y: vp.y ?? 0,
+      width: vp.width ?? 1,
+      height: vp.height ?? 1,
+    };
+
+    this.active = options.active !== false;
+    this.clearColor = options.clearColor || null;
+
+    this.ignoreLayers = new Set(options.ignoreLayers || []);
+
+    this.onlyLayers = options.onlyLayers ? new Set(options.onlyLayers) : null;
+
+    this.excludeFromPost = options.excludeFromPost === true;
+
+    this.pixelSnap = options.pixelSnap === true;
+  }
+
+  /**
+   * @method setPixelSnap
+   * @description When true, the camera's rendered position is rounded to whole
+   * screen pixels each frame (the stored position stays smooth). Use it for
+   * pixel-art games to eliminate sub-pixel shimmer and tile seams while a
+   * smooth-follow camera moves. Ignored while the camera is rotated.
+   * @param {boolean} snap
+   * @returns {Camera} - this
+   */
+  setPixelSnap(snap) {
+    this.pixelSnap = snap !== false;
+    return this;
+  }
+
+  /**
+   * @method setExcludeFromPost
+   * @description When true, this camera renders straight to the screen AFTER the
+   * post-processing pass instead of into the post-processed scene buffer. Use it
+   * for HUD/UI cameras so effects like bloom don't affect the interface.
+   * @param {boolean} exclude
+   * @returns {Camera} - this
+   */
+  setExcludeFromPost(exclude) {
+    this.excludeFromPost = exclude !== false;
+    return this;
+  }
+
+  /**
+   * @method setOnlyLayers
+   * @description Restricts the camera to rendering only the given layers (or
+   * pass null to clear the restriction).
+   * @param {number[]|null} layers
+   * @returns {Camera} - this
+   */
+  setOnlyLayers(layers) {
+    this.onlyLayers = layers ? new Set(layers) : null;
+    return this;
+  }
+
+  /**
+   * @method setIgnoreLayers
+   * @description Replaces the set of layers this camera skips when rendering.
+   * @param {number[]} layers - Layer indices to ignore
+   * @returns {Camera} - this
+   */
+  setIgnoreLayers(layers) {
+    this.ignoreLayers = new Set(layers);
+    return this;
+  }
+
+  /**
+   * @method ignoreLayer
+   * @description Adds a single layer to the ignore set.
+   * @param {number} layer
+   * @returns {Camera} - this
+   */
+  ignoreLayer(layer) {
+    this.ignoreLayers.add(layer);
+    return this;
+  }
+
+  /**
+   * @method setPosition
+   * @description Sets the world-space center of the camera.
+   */
+  setPosition(x, y, z = 0) {
+    this.transform.position.x = -x;
+    this.transform.position.y = -y;
+    this.transform.position.z = -z;
+  }
+
+  /**
+   * @method getPosition
+   * @description Returns the world-space center of the camera.
+   */
+  getPosition() {
+    return {
+      x: -this.transform.position.x,
+      y: -this.transform.position.y,
+      z: -this.transform.position.z,
+    };
+  }
+
+  /**
+   * @method setZoom
+   * @description Sets the zoom (1 = default, >1 zooms in).
+   */
+  setZoom(zoom) {
+    const z = Math.max(0.0001, zoom);
+    this.transform.scale.x = z;
+    this.transform.scale.y = z;
+  }
+
+  /**
+   * @method getZoom
+   * @returns {number}
+   */
+  getZoom() {
+    return this.transform.scale.x;
+  }
+
+  /**
+   * @method setRotation
+   * @description Sets the camera rotation in radians.
+   */
+  setRotation(radians) {
+    this.transform.rotation = radians;
+  }
+
+  /**
+   * @method getRotation
+   * @returns {number}
+   */
+  getRotation() {
+    return this.transform.rotation;
+  }
+
+  /**
+   * @method setViewport
+   * @description Sets the normalized viewport rectangle (origin bottom-left).
+   * @returns {Camera} - this
+   */
+  setViewport(x, y, width, height) {
+    this.viewport = { x, y, width, height };
+    return this;
+  }
+
+  /**
+   * @method setActive
+   * @description Enables/disables rendering of this camera.
+   * @returns {Camera} - this
+   */
+  setActive(active) {
+    this.active = active;
+    return this;
+  }
+}
+
+export default Camera;