emeraldengine 2.0.0

package/imports/managers/ShaderManager.js

@@ -0,0 +1,133 @@
+/**
+ * @class ShaderManager
+ * @description Manages the shaders for the game
+ */
+export class ShaderManager {
+  constructor(gl) {
+    this.gl = gl;
+    this.shaders = new Map();
+    this.activeShader = null;
+  }
+
+  /**
+   * @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, vertexSource, fragmentSource) {
+    const vertexShader = this.compileShader(
+      vertexSource,
+      this.gl.VERTEX_SHADER
+    );
+    const fragmentShader = this.compileShader(
+      fragmentSource,
+      this.gl.FRAGMENT_SHADER
+    );
+
+    const shaderProgram = this.gl.createProgram();
+    this.gl.attachShader(shaderProgram, vertexShader);
+    this.gl.attachShader(shaderProgram, fragmentShader);
+    this.gl.linkProgram(shaderProgram);
+    if (!this.gl.getProgramParameter(shaderProgram, this.gl.LINK_STATUS)) {
+      console.error(
+        "Error linking shader program:",
+        this.gl.getProgramInfoLog(shaderProgram)
+      );
+      this.gl.deleteProgram(shaderProgram);
+      return null;
+    }
+
+    const programInfo = {
+      program: shaderProgram,
+      attribLocations: this.getAttributeLocations(shaderProgram),
+      uniformLocations: this.getUniformLocations(shaderProgram),
+    };
+
+    this.shaders.set(name, programInfo);
+
+    return programInfo;
+  }
+
+  /**
+   * @method compileShader
+   * @description Compiles a shader
+   * @param {string} source - The shader source
+   * @param {number} type - The type of shader
+   */
+  compileShader(source, type) {
+    const shader = this.gl.createShader(type);
+    this.gl.shaderSource(shader, source);
+    this.gl.compileShader(shader);
+
+    if (!this.gl.getShaderParameter(shader, this.gl.COMPILE_STATUS)) {
+      console.error(
+        "Shader compilation error:",
+        this.gl.getShaderInfoLog(shader)
+      );
+      this.gl.deleteShader(shader);
+      return null;
+    }
+
+    return shader;
+  }
+
+  /**
+   * @method useShader
+   * @description Uses a shader
+   * @param {string} name - The name of the shader
+   */
+  useShader(name) {
+    const shader = this.shaders.get(name);
+    if (shader) {
+      this.gl.useProgram(shader.program);
+      this.activeShader = shader;
+    } else {
+      console.warn(`Shader ${name} not found.`);
+    }
+
+    return shader;
+  }
+
+  /**
+   * @method getActiveShader
+   * @description Returns the active shader
+   * @returns {Object} - The active shader
+   */
+  getActiveShader() {
+    return this.activeShader;
+  }
+
+  /**
+   * @method getAttributeLocations
+   * @description Returns the attribute locations for a shader program
+   * @param {WebGLProgram} program - The shader program
+   * @returns {Object} - The attribute locations
+   */
+  getAttributeLocations(program) {
+    return {
+      vertexPosition: this.gl.getAttribLocation(program, "aVertexPosition"),
+      textureCoord: this.gl.getAttribLocation(program, "aTextureCoord"),
+      // Add other attributes as needed
+    };
+  }
+
+  /**
+   * @method getUniformLocations
+   * @description Returns the uniform locations for a shader program
+   * @param {WebGLProgram} program - The shader program
+   * @returns {Object} - The uniform locations
+   */
+  getUniformLocations(program) {
+    return {
+      projectionMatrix: this.gl.getUniformLocation(
+        program,
+        "uProjectionMatrix"
+      ),
+      modelViewMatrix: this.gl.getUniformLocation(program, "uModelViewMatrix"),
+      sampler: this.gl.getUniformLocation(program, "uSampler"),
+      // Add other uniforms as needed
+    };
+  }
+}

package/imports/particlesystem/Particle.js

@@ -0,0 +1,75 @@
+import Instance from "../Instance.js";
+
+/**
+ * @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
+ */
+class Particle {
+  constructor(instancedTexture, position, rotation, scale, settings) {
+    this.settings = settings;
+    this.lifetime = settings.lifetime;
+    this.age = 0;
+    this.velocity = { ...settings.velocity };
+    this.gravity = { ...settings.gravity };
+    this.instance = new Instance(
+      `Particle at ${position.x}, ${position.y}`,
+      position,
+      scale,
+      rotation,
+      settings.frame
+    );
+    this.instancedTexture = instancedTexture;
+    if(this.settings.animation) {
+      this.instance.playAnimation(
+        this.settings.animation.frames,
+        this.settings.animation.speed
+      );
+    }
+    instancedTexture.addInstance(this.instance);
+  }
+
+  /**
+   * @method update
+   * @description Updates the particle
+   * @param {number} dt - The delta time
+   */
+  update(dt) {
+    this.age += dt;
+    // Apply gravity
+    this.velocity.x += this.gravity.x * dt;
+    this.velocity.y += this.gravity.y * dt;
+    // Update position
+    this.instance.transform.position.x += this.velocity.x * dt;
+    this.instance.transform.position.y += this.velocity.y * dt;
+  }
+
+  /**
+   * @method isAlive
+   * @description Checks if the particle is alive
+   * @returns {boolean} - True if the particle is alive
+   */
+  isAlive() {
+    return this.age < this.lifetime;
+  }
+
+  /**
+   * @method destroy
+   * @description Destroys the particle
+   */
+  destroy() {
+    if (this.instancedTexture && this.instance) {
+      if (this.instancedTexture.instances.length > 0) {
+        if(this.instancedTexture.getInstanceWithId(this.instance.id)) {
+          this.instancedTexture.removeInstance(this.instance.id);
+        }
+      }
+    }
+  }
+}
+
+export default Particle;

package/imports/particlesystem/ParticleSettings.js

@@ -0,0 +1,49 @@
+import { Vector2 } from "../Physics.js";
+
+/**
+ * @class ParticleSettings
+ * @description Represents the settings for a particle system
+ * @param {number} lifetime - The lifetime of the particle
+ * @param {Vector2} velocity - The velocity of the particle
+ * @param {Vector2} gravity - The gravity of the particle
+ * @param {number} amount - The amount of particles
+ * @param {Vector2} direction - The direction of the particle
+ * @param {number} spread - The spread of the particle
+ * @param {number} emissionRate - The emission rate of the particle
+ * @param {number} frame - The frame of the particle
+ * @param {number} offset - The offset of the particle
+ * @param {number} rotation - The rotation of the particle
+ * @param {Vector2} scale - The scale of the particle
+ * @param {Array} animation - The animation of the particle
+ */
+class ParticleSettings {
+  constructor({
+    lifetime = 1.0,
+    velocity = new Vector2(0, 0),
+    gravity = new Vector2(0, 0),
+    amount = 10,
+    direction = new Vector2(1, 0),
+    spread = Math.PI / 4,
+    emissionRate = Infinity, // particles per second
+    frame,
+    offset,
+    rotation,
+    scale,
+    animation
+  } = {}) {
+    this.lifetime = lifetime;
+    this.velocity = velocity;
+    this.gravity = gravity;
+    this.amount = amount;
+    this.direction = direction;
+    this.spread = spread;
+    this.emissionRate = emissionRate;
+    this.frame = frame;
+    this.offset = offset;
+    this.rotation = rotation;
+    this.scale = scale;
+    this.animation = animation;
+  }
+}
+
+export default ParticleSettings; 

package/imports/particlesystem/Particles.js

@@ -0,0 +1,226 @@
+import GameObject from "../components/GameObject.js";
+import InstancedTexture from "../InstancedTexture.js";
+import { Vector3 } from "../Physics.js";
+import Particle from "./Particle.js";
+import ParticleSettings from "./ParticleSettings.js";
+
+/**
+ * @class Particles
+ * @description Represents a particle system
+ * @param {string} name - The name of the particle system
+ * @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} duration - The duration of the particle system
+ * @param {ParticleSettings} settings - The settings for the particle system
+ */
+export default class Particles {
+  constructor(
+    name,
+    texturePath,
+    frameWidth,
+    frameHeight,
+    framesPerRow,
+    totalFrames,
+    duration = 0.2,
+    settings = null
+  ) {
+    this.settings = settings
+      ? new ParticleSettings(settings)
+      : new ParticleSettings();
+    this.position = new Vector3(0, 0, 0);
+    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.elapsed = 0;
+    this.active = false;
+    this.instanceCount = this.settings.amount;
+    this.emissionTimer = 0;
+    this.emittedParticles = 0;
+    this.stopped = false;
+    this.gameObject = new GameObject(
+      name,
+      this.position,
+      this.settings.rotation,
+      this.settings.scale
+    );
+    this.instancedTexture = new InstancedTexture(
+      texturePath,
+      this.instanceCount,
+      frameWidth,
+      frameHeight,
+      framesPerRow,
+      totalFrames,
+      this.settings.animation ? this.settings.animation.speed : 0,
+      this.settings.animation ? true : false,
+    );
+    this.instancedTexture.clearInstances(); // Ensure clean state on creation
+    this.gameObject.addComponent(this.instancedTexture);
+    
+    // Initialize clean state
+    this.particles = [];
+    this.active = false;
+    this.elapsed = 0;
+    this.emissionTimer = 0;
+    this.emittedParticles = 0;
+    this.stopped = false;
+  }
+
+  /**
+   * @method play
+   * @description Plays the particle system
+   * @param {Vector3} newPosition - The position to play the particle system at
+   */
+  play(newPosition) {
+    this.instancedTexture.clearInstances();
+    this.particles = [];
+    this.elapsed = 0;
+    this.active = true;
+    this.emissionTimer = 0;
+    this.emittedParticles = 0;
+    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()
+  }
+
+  /**
+   * @method emitParticles
+   * @description Emits particles
+   * @param {number} count - The number of particles to emit
+   * @param {Vector3} position - The position to emit the particles at
+   */
+  emitParticles(count, position) {
+    const numberOfParticles = count;
+    const baseDirection = this.settings.direction;
+    const baseVelocity = this.settings.velocity;
+    const speed = Math.sqrt(
+      baseVelocity.x * baseVelocity.x + baseVelocity.y * baseVelocity.y
+    );
+    for (let i = 0; i < numberOfParticles; i++) {
+      let angle = Math.atan2(baseDirection.y, baseDirection.x);
+      let spread = this.settings.spread;
+      const angleVariation = (Math.random() - 0.5) * spread;
+      const finalAngle = angle + angleVariation;
+      const velocity = {
+        x: Math.cos(finalAngle) * speed,
+        y: Math.sin(finalAngle) * speed,
+      };
+      const offsetVariation = (Math.random() - 0.5) * this.offset * 0.5;
+      const pos = new Vector3(
+        position.x + Math.cos(finalAngle) * (this.offset + offsetVariation),
+        position.y + Math.sin(finalAngle) * (this.offset + offsetVariation),
+        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
+        );
+        this.particles.push(particle);
+      }
+      
+    }
+  }
+
+  /**
+   * @method update
+   * @description Updates the particle system
+   * @param {number} deltaTime - The delta time
+   */
+  update(deltaTime) {
+    if (!this.active || this.stopped) return;
+    this.elapsed += deltaTime;
+    // Continuous emission
+    if (
+      this.settings.emissionRate !== Infinity &&
+      this.elapsed <= this.duration
+    ) {
+      this.emissionTimer += deltaTime;
+      const particlesPerSecond = this.settings.emissionRate;
+      let toEmit = 0;
+      if (particlesPerSecond > 0) {
+        const expectedTotal = Math.floor(
+          this.emissionTimer * particlesPerSecond
+        );
+        toEmit = expectedTotal - this.emittedParticles;
+      }
+      if (toEmit > 0) {
+        this.emitParticles(toEmit, this.lastEmitPosition);
+        this.emittedParticles += toEmit;
+      }
+    }
+    // Update all particles and remove dead ones
+    this.particles = this.particles.filter((particle) => {
+      particle.update(deltaTime);
+      if (!particle.isAlive()) {
+        particle.destroy();
+        return false;
+      }
+      return true;
+    });
+    if (
+      this.elapsed >= this.duration &&
+      this.settings.emissionRate !== Infinity
+    ) {
+      this.stopped = true;
+    }
+    if (this.stopped && this.particles.length === 0) {
+      this.instancedTexture.clearInstances();
+      this.particles = [];
+      this.active = false;
+    }
+  }
+
+  /**
+   * @method stop
+   * @description Stops the particle system
+   */
+  stop() {
+    this.stopped = true;
+    this.instancedTexture.clearInstances();
+    this.particles = [];
+    this.active = false;
+  }
+
+  /**
+   * @method destroy
+   * @description Destroys the particle system
+   */
+  destroy() {
+    this.stop();
+    if (this.instancedTexture) {
+      this.instancedTexture.clearInstances();
+    }
+    this.particles = [];
+    this.active = false;
+  }
+
+  /**
+   * @method reset
+   * @description Resets the particle system
+   */
+  reset() {
+    this.stop();
+    this.particles = [];
+    this.active = false;
+    this.elapsed = 0;
+    this.emissionTimer = 0;
+    this.emittedParticles = 0;
+    this.stopped = false;
+  }
+}

package/index.js

@@ -0,0 +1,67 @@
+import Emerald from "./imports/Emerald.js";
+import BitmapText from "./imports/BitmapText.js";
+import Color from "./imports/Color.js";
+import Drawable from "./imports/Drawable.js";
+import FPSCounter from "./imports/FPSCounter.js";
+import Instance from "./imports/Instance.js";
+import InstancedTexture from "./imports/InstancedTexture.js";
+import { Physics, Vector2, Vector3 } from "./imports/Physics.js";
+import Scene from "./imports/Scene.js";
+import { Square2D, Triangle2D, Circle2D } from "./imports/Shapes.js";
+import Storage from "./imports/Storage.js";
+import Texture from "./imports/Texture.js";
+import Time from "./imports/Time.js";
+import Transform from "./imports/Transform.js";
+import Particle from "./imports/particlesystem/Particle.js";
+import Particles from "./imports/particlesystem/Particles.js";
+import ParticleSettings from "./imports/particlesystem/ParticleSettings.js";
+import AudioManager from "./imports/managers/AudioManager.js";
+import CameraManager from "./imports/managers/CameraManager.js";
+import EventManager from "./imports/managers/EventManager.js";
+import SceneManager from "./imports/managers/SceneManager.js";
+import DirectionalLight from "./imports/lights/DirectionalLight.js";
+import PointLight from "./imports/lights/PointLight.js";
+import BoxCollider from "./imports/components/BoxCollider.js";
+import BoxColliderDebug from "./imports/components/BoxColliderDebug.js";
+import CircleCollider from "./imports/components/CircleCollider.js";
+import CircleColliderDebug from "./imports/components/CircleColliderDebug.js";
+import Collider from "./imports/components/Collider.js";
+import GameObject from "./imports/components/GameObject.js";
+import RigidBody from "./imports/components/RigidBody.js";
+
+export {
+  Emerald,
+  BitmapText,
+  Color,
+  Drawable,
+  FPSCounter,
+  Instance,
+  InstancedTexture,
+  Physics,
+  Vector2,
+  Vector3,
+  Scene,
+  Square2D,
+  Triangle2D,
+  Circle2D,
+  Storage,
+  Texture,
+  Time,
+  Transform,
+  Particle,
+  Particles,
+  ParticleSettings,
+  AudioManager,
+  CameraManager,
+  EventManager,
+  SceneManager,
+  DirectionalLight,
+  PointLight,
+  BoxCollider,
+  BoxColliderDebug,
+  CircleCollider,
+  CircleColliderDebug,
+  Collider,
+  GameObject,
+  RigidBody,
+};

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "emeraldengine",
+  "version": "2.0.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",
+      "require": "./index.js",
+      "default": "./index.js"
+    }
+  },
+  "files": [
+    "index.js",
+    "imports",
+    "dist/types"
+  ],
+  "keywords": [
+    "2D",
+    "graphics",
+    "game",
+    "engine",
+    "webgl",
+    "canvas"
+  ],
+  "dependencies": {
+    "gl-matrix": "^3.4.3",
+    "planck": "^1.4.2",
+    "colyseus.js": "^0.16.16"
+  },
+  "author": "vahan-gev",
+  "license": "MIT",
+  "devDependencies": {}
+}