emeraldengine 2.0.0

package/imports/Physics.js

@@ -0,0 +1,242 @@
+import * as planck from "planck";
+
+/**
+ * @class Physics
+ * @description Represents the physics engine
+ * @param {number} gravity - The gravity of the physics engine
+ * @param {number} scale - The scale of the physics engine
+ * @param {number} velocityThreshold - The velocity threshold of the physics engine
+ */
+class Physics {
+  constructor(gravity, scale, velocityThreshold = 0.1) {
+    this.world = new planck.World({
+      gravity: new planck.Vec2(0, gravity),
+    });
+    planck.Settings.velocityThreshold = velocityThreshold;
+    this.gravity = gravity;
+    this.scale = scale;
+  }
+
+  /**
+   * @method createBody
+   * @description Creates a body in the physics engine
+   * @param {string} type - The type of the body
+   * @param {Vector2} position - The position of the body
+   * @param {boolean} fixedRotation - Whether the body should have a fixed rotation
+   * @param {boolean} attachFixture - Whether the body should have a fixture
+   * @param {Vector2} fixtureSize - The size of the fixture
+   * @param {number} density - The density of the fixture
+   * @param {number} friction - The friction of the fixture
+   * @param {number} restitution - The restitution of the fixture
+   * @returns {Body} - The body
+   */
+  createBody(
+    type,
+    position = new Vector2(0, 0),
+    fixedRotation = false,
+    attachFixture = true,
+    fixtureSize = new Vector2(1, 1),
+    density = 0,
+    friction = 0,
+    restitution = 0
+  ) {
+    const bodyRef = this.world.createBody({
+      type: type,
+      position: new planck.Vec2(
+        position.x / this.scale,
+        position.y / this.scale
+      ),
+      fixedRotation: fixedRotation,
+    });
+
+    if (attachFixture) {
+      bodyRef.createFixture(new planck.Box(fixtureSize.x, fixtureSize.y), {
+        density: density,
+        friction: friction,
+        restitution: restitution,
+      });
+    }
+
+    return bodyRef;
+  }
+
+  /**
+   * @method onCollisionEnter
+   * @description Handles the collision enter event
+   * @param {Function} callback - The callback function to handle the collision enter event
+   */
+  onCollisionEnter(callback) {
+    this.world.on("begin-contact", (contact) => {
+      const fixtureA = contact.getFixtureA();
+      const fixtureB = contact.getFixtureB();
+
+      const bodyA = fixtureA.getBody();
+      const bodyB = fixtureB.getBody();
+
+      callback(bodyA, bodyB, contact);
+    });
+  }
+
+  /**
+   * @method onCollisionExit
+   * @description Handles the collision exit event
+   * @param {Function} callback - The callback function to handle the collision exit event
+   */
+  onCollisionExit(callback) {
+    this.world.on("end-contact", (contact) => {
+      const fixtureA = contact.getFixtureA();
+      const fixtureB = contact.getFixtureB();
+
+      const bodyA = fixtureA.getBody();
+      const bodyB = fixtureB.getBody();
+
+      callback(bodyA, bodyB, contact);
+    });
+  }
+
+  /**
+   * @method process
+   * @description Processes the physics engine
+   * @param {number} dt - The delta time
+   */
+  process(dt) {
+    this.world.step(dt);
+  }
+
+  /**
+   * @method clear
+   * @description Clears the physics engine objects and resets the gravity
+   */
+  clear() {
+    this.world = new planck.World({
+      gravity: new planck.Vec2(0, this.gravity),
+    });
+  }
+
+  /**
+   * @method getGravity
+   * @description Returns the gravity of the physics engine
+   * @returns {number} - The gravity of the physics engine
+   */
+  getGravity() {
+    return this.gravity;
+  }
+
+  /**
+   * @method getScale
+   * @description Returns the scale of the physics engine
+   * @returns {number} - The scale of the physics engine
+   */
+  getScale() {
+    return this.scale;
+  }
+
+  /**
+   * @method scheduleAction
+   * @description Schedules an action to be executed as soon as possible
+   * @param {Function} callback - The callback function to execute
+   */
+  static scheduleAction(callback) {
+    if (typeof callback === "function") {
+      setTimeout(() => {
+        callback();
+      }, 0);
+    }
+  }
+}
+
+/**
+ * @class Vector2
+ * @description Represents a 2D vector
+ * @param {number} x - The x coordinate of the vector
+ * @param {number} y - The y coordinate of the vector
+ */
+class Vector2 {
+  constructor(x, y) {
+    return new planck.Vec2(x, y);
+  }
+
+  /**
+   * @method equals
+   * @description Checks if the vector is equal to another vector
+   * @param {Vector2} other - The other vector
+   * @returns {boolean} - True if the vector is equal to the other vector
+   */
+  equals(other) {
+    if (!other) return false;
+    if (!(other instanceof Vector2)) return false;
+    return this.x === other.x && this.y === other.y;
+  }
+
+  /**
+   * @method getX
+   * @description Returns the x coordinate of the vector
+   * @returns {number} - The x coordinate of the vector
+   */
+  getX() {
+    return this.x;
+  }
+
+  /**
+   * @method getY
+   * @description Returns the y coordinate of the vector
+   * @returns {number} - The y coordinate of the vector
+   */
+  getY() {
+    return this.y;
+  }
+}
+
+/**
+ * @class Vector3
+ * @description Represents a 3D vector
+ * @param {number} x - The x coordinate of the vector
+ * @param {number} y - The y coordinate of the vector
+ * @param {number} z - The z coordinate of the vector
+ */
+class Vector3 {
+  constructor(x, y, z) {
+    return new planck.Vec3(x, y, z);
+  }
+
+  /**
+   * @method equals
+   * @description Checks if the vector is equal to another vector
+   * @param {Vector3} other - The other vector
+   * @returns {boolean} - True if the vector is equal to the other vector
+   */
+  equals(other) {
+    if (!other) return false;
+    if (!(other instanceof Vector3)) return false;
+    return this.x === other.x && this.y === other.y && this.z === other.z;
+  }
+
+  /**
+   * @method getX
+   * @description Returns the x coordinate of the vector
+   * @returns {number} - The x coordinate of the vector
+   */
+  getX() {
+    return this.x;
+  }
+
+  /**
+   * @method getY
+   * @description Returns the y coordinate of the vector
+   * @returns {number} - The y coordinate of the vector
+   */
+  getY() {
+    return this.y;
+  }
+
+  /**
+   * @method getZ
+   * @description Returns the z coordinate of the vector
+   * @returns {number} - The z coordinate of the vector
+   */
+  getZ() {
+    return this.z;
+  }
+}
+
+export { Physics, Vector2, Vector3 };

package/imports/Scene.js

@@ -0,0 +1,79 @@
+import GameObject from "./components/GameObject.js";
+
+/**
+ * @class Scene
+ * @description Represents a scene
+ * @param {Array} objects - The objects in the scene
+ */
+class Scene {
+  constructor(objects = []) {
+    this.objects = objects;
+  }
+
+  /**
+   * @method add
+   * @description Adds an object to the scene
+   * @param {GameObject} object - The object to add
+   */
+  add(object) {
+    if (!(object instanceof GameObject)) {
+      throw new Error("Object is not a GameObject");
+    }
+    object.setIsActive(true);
+    if (!this.objects.some((obj) => obj.id === object.id)) {
+      this.objects.push(object);
+    }
+  }
+
+  /**
+   * @method remove
+   * @description Removes an object from the scene
+   * @param {GameObject} object - The object to remove
+   */
+  remove(object) {
+    if (!(object instanceof GameObject)) {
+      throw new Error("Object is not a GameObject");
+    }
+    object.setIsActive(false);
+    this.objects = this.objects.filter((obj) => obj?.id !== object?.id);
+  }
+
+  /**
+   * @method setIsActive
+   * @description Sets the active state of the scene
+   * @param {boolean} bool - The active state
+   */
+  setIsActive(bool) {
+    for (let object of this.objects) {
+      this.setActiveRecursive(object, bool);
+    }
+  }
+
+  /**
+   * @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, bool) {
+    object.setIsActive(bool);
+  }
+
+  // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol/iterator
+  [Symbol.iterator]() {
+    let index = -1;
+    const data = this.objects;
+
+    return {
+      next: () => ({ value: data[++index], done: !(index in data) }),
+    };
+  }
+
+  forEach(callback) {
+    for (const obj of this.objects) {
+      callback(obj);
+    }
+  }
+}
+
+export default Scene;

package/imports/Shaders.js

@@ -0,0 +1,165 @@
+const STANDARD_VERTEX_SHADER = `
+  attribute vec4 aVertexPosition;
+  attribute vec2 aTextureCoord;
+  
+  // Instance matrix (each row as a separate attribute)
+  attribute vec4 aInstanceMatrix0;
+  attribute vec4 aInstanceMatrix1;
+  attribute vec4 aInstanceMatrix2;
+  attribute vec4 aInstanceMatrix3;
+  
+  // Per-instance texture coordinates (one for each vertex of the quad)
+  attribute vec2 aInstanceTexCoord0;
+  attribute vec2 aInstanceTexCoord1;
+  attribute vec2 aInstanceTexCoord2;
+  attribute vec2 aInstanceTexCoord3;
+  
+  uniform mat4 uModelViewMatrix;
+  uniform mat4 uInstancedModelViewMatrix;
+  uniform mat4 uProjectionMatrix;
+  uniform bool useInstances;
+
+  varying highp vec2 vTexCoord;
+  varying vec2 vFragPos;
+  
+  void main() {
+    // Construct the instance matrix
+    mat4 instanceMatrix = mat4(
+      aInstanceMatrix0,
+      aInstanceMatrix1,
+      aInstanceMatrix2,
+      aInstanceMatrix3
+    );
+    
+    // Apply the instance-specific transform, then the global transforms
+    if(useInstances) {
+        gl_Position = uProjectionMatrix * uInstancedModelViewMatrix * instanceMatrix * aVertexPosition;
+        vFragPos = (uInstancedModelViewMatrix * instanceMatrix * aVertexPosition).xy;
+        
+        // Use per-instance texture coordinates based on vertex index
+        // Vertex order: top-right, top-left, bottom-right, bottom-left
+        int vertexIndex = int(aVertexPosition.x > 0.0 ? (aVertexPosition.y > 0.0 ? 0 : 2) : (aVertexPosition.y > 0.0 ? 1 : 3));
+        
+        if(vertexIndex == 0) {
+            vTexCoord = aInstanceTexCoord0;
+        } else if(vertexIndex == 1) {
+            vTexCoord = aInstanceTexCoord1;
+        } else if(vertexIndex == 2) {
+            vTexCoord = aInstanceTexCoord2;
+        } else {
+            vTexCoord = aInstanceTexCoord3;
+        }
+    } else {
+        gl_Position = uProjectionMatrix * uModelViewMatrix * aVertexPosition;
+        vFragPos = (uModelViewMatrix * aVertexPosition).xy;
+        vTexCoord = aTextureCoord;
+    }
+  }
+`;
+
+const STANDARD_FRAGMENT_SHADER = `
+    #ifdef GL_ES
+    precision highp float;
+    #endif
+    uniform bool useTexture;
+    uniform vec4 uColor;
+    uniform sampler2D uSampler;
+    uniform float uOpacity; // Global opacity multiplier per GameObject
+
+    uniform vec2 uLightPosition[4]; // Support up to 4 lights
+    uniform vec3 uLightColor[4];    // RGB colors for each light
+    uniform float uLightIntensity[4]; // Intensity of each light
+    uniform float uLightRadius[4];  // Radius of each light
+    uniform int uActiveLights;      // Number of active lights
+    
+    // Directional lights
+    uniform vec2 uDirLightPosition[4]; // Position of directional lights
+    uniform vec2 uDirLightDirection[4]; // Direction of directional lights
+    uniform vec3 uDirLightColor[4];    // RGB colors for each directional light
+    uniform float uDirLightIntensity[4]; // Intensity of each directional light
+    uniform float uDirLightWidth[4];   // Width of each directional light beam
+    uniform int uActiveDirLights;      // Number of active directional lights
+    
+    uniform vec3 uAmbientLightValues; // Ambient light values
+    uniform bool uUseLighting;      // Whether to apply lighting to this object
+
+    varying vec2 vTexCoord;
+    varying vec2 vFragPos;
+
+    void main() {
+        vec4 ambientLight = vec4(uAmbientLightValues.xyz, 1.0); // Move ambient light here
+        
+        vec4 texColor;
+        if (useTexture) {
+            texColor = texture2D(uSampler, vTexCoord);
+            // Discard only fully or nearly fully transparent texels to keep soft edges
+            if (texColor.a < 0.01) discard;
+            // Apply color tint to texture
+            texColor *= uColor;
+        } else {
+            texColor = uColor;
+        }
+        
+        // Start with ambient light
+        vec3 lighting = ambientLight.rgb;
+        
+        // Calculate contribution from each point light
+        for(int i = 0; i < 4; i++) {
+            if(i >= uActiveLights) break;
+            
+            float distance = length(uLightPosition[i] - vFragPos);
+            
+            // Check if fragment is within light radius
+            if(distance < uLightRadius[i]) {
+                // Calculate attenuation (falloff)
+                float attenuation = 1.0 - distance / uLightRadius[i];
+                
+                // Add this light's contribution
+                lighting += uLightColor[i] * attenuation * uLightIntensity[i];
+            }
+        }
+        
+        // Calculate contribution from each directional light
+        for(int i = 0; i < 4; i++) {
+            if(i >= uActiveDirLights) break;
+            
+            vec2 lightPos = uDirLightPosition[i];
+            vec2 lightDir = normalize(uDirLightDirection[i]);
+            vec2 toFrag = vFragPos - lightPos;
+            
+            // Check if fragment is in front of the light
+            float projection = dot(toFrag, lightDir);
+            if(projection < 0.0) continue;
+            
+            // Calculate perpendicular distance from light beam center
+            float perpDistance = abs(dot(toFrag, vec2(-lightDir.y, lightDir.x)));
+            
+            // Check if fragment is within light beam width
+            if(perpDistance > uDirLightWidth[i] * 0.5) continue;
+            
+            // Simplified lighting without shadows for now
+            float widthFactor = 1.0 - (perpDistance / (uDirLightWidth[i] * 0.5));
+            
+            // Optional: Add distance attenuation
+            float distance = length(toFrag);
+            float maxDistance = 1000.0; // Maximum effective distance
+            float distanceFactor = max(0.0, 1.0 - (distance / maxDistance));
+            
+            // Add this directional light's contribution
+            lighting += uDirLightColor[i] * uDirLightIntensity[i] * widthFactor * distanceFactor;
+        }
+        
+        // Apply lighting to texture color only if lighting is enabled
+        vec4 outColor;
+        if (uUseLighting) {
+            outColor = vec4(texColor.rgb * lighting, texColor.a);
+        } else {
+            outColor = texColor;
+        }
+        // Apply global opacity multiplier
+        outColor.a *= clamp(uOpacity, 0.0, 1.0);
+        gl_FragColor = outColor;
+    }
+`;
+
+export { STANDARD_VERTEX_SHADER, STANDARD_FRAGMENT_SHADER };

package/imports/Shapes.js

@@ -0,0 +1,129 @@
+import { initVertexBuffer } from "./GLUtils.js";
+import Drawable from "./Drawable.js";
+import GLManager from "./managers/GLManager.js";
+
+/**
+ * @class Square2D
+ * @description Represents a square 2D shape
+ */
+class Square2D extends Drawable {
+  constructor() {
+    const vertices = [1.0, 1.0, -1.0, 1.0, 1.0, -1.0, -1.0, -1.0];
+    const verticesBuffer = initVertexBuffer(GLManager.getGL(), vertices);
+    const textureCoordinates = [
+      1.0,
+      1.0, // Top-right
+      0.0,
+      1.0, // Top-left
+      1.0,
+      0.0, // Bottom-right
+      0.0,
+      0.0, // Bottom-left
+    ];
+    const texCoordBuffer = initVertexBuffer(
+      GLManager.getGL(),
+      textureCoordinates
+    );
+
+    super(
+      GLManager.getGL(),
+      GLManager.getProgramInfo(),
+      verticesBuffer,
+      texCoordBuffer,
+      vertices,
+      false,
+      "",
+      0,
+      0,
+      0,
+      0,
+      0,
+      false
+    );
+  }
+}
+
+/**
+ * @class Triangle2D
+ * @description Represents a triangle 2D shape
+ */
+class Triangle2D extends Drawable {
+  constructor() {
+    const vertices = [0.0, 1.0, 1.0, -1.0, -1.0, -1.0];
+    const verticesBuffer = initVertexBuffer(GLManager.getGL(), vertices);
+
+    const textureCoordinates = [0.5, 1.0, 1.0, 0.0, 0.0, 0.0];
+    const texCoordBuffer = initVertexBuffer(
+      GLManager.getGL(),
+      textureCoordinates
+    );
+
+    super(
+      GLManager.getGL(),
+      GLManager.getProgramInfo(),
+      verticesBuffer,
+      texCoordBuffer,
+      vertices,
+      false,
+      "",
+      0,
+      0,
+      0,
+      0,
+      0,
+      false
+    );
+  }
+}
+
+/**
+ * @class Circle2D
+ * @description Represents a circle 2D shape
+ * @param {number} segments - The number of segments to use to draw the circle
+ */
+class Circle2D extends Drawable {
+  constructor(segments = 32) {
+    const radius = 1.0;
+    const vertices = [];
+    const textureCoordinates = [];
+
+    // Add center vertex
+    vertices.push(0, 0);
+    textureCoordinates.push(0.5, 0.5);
+
+    // Add perimeter vertices
+    for (let i = 0; i <= segments; i++) {
+      const angle = (i * 2 * Math.PI) / segments;
+      const x = radius * Math.cos(angle);
+      const y = radius * Math.sin(angle);
+      vertices.push(x, y);
+      textureCoordinates.push((x / radius + 1) / 2, (y / radius + 1) / 2);
+    }
+
+    const verticesBuffer = initVertexBuffer(GLManager.getGL(), vertices);
+    const texCoordBuffer = initVertexBuffer(
+      GLManager.getGL(),
+      textureCoordinates
+    );
+
+    super(
+      GLManager.getGL(),
+      GLManager.getProgramInfo(),
+      verticesBuffer,
+      texCoordBuffer,
+      vertices,
+      false,
+      "",
+      0,
+      0,
+      0,
+      0,
+      0,
+      false,
+      true,
+      false
+    );
+  }
+}
+
+export { Square2D, Triangle2D, Circle2D };

package/imports/Storage.js

@@ -0,0 +1,63 @@
+/**
+ * @class Storage
+ * @description Manages the storage of the game
+ */
+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, value) {
+        localStorage.setItem(key, JSON.stringify(value));
+    }
+
+    /**
+     * @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) {
+        return JSON.parse(localStorage.getItem(key));
+    }
+
+    /**
+     * @method clearLocalStorage
+     * @description Clears local storage
+     */
+    static clearLocalStorage() {
+        localStorage.clear();
+    }
+
+    /**
+     * @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, value) {
+        sessionStorage.setItem(key, JSON.stringify(value));
+    }
+
+    /**
+     * @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) {
+        return JSON.parse(sessionStorage.getItem(key));
+    }
+
+    /**
+     * @method clearSessionStorage
+     * @description Clears session storage
+     */
+    static clearSessionStorage() {
+        sessionStorage.clear();
+    }
+}
+
+export default Storage;