emeraldengine 2.0.0

package/imports/Texture.js

@@ -0,0 +1,67 @@
+import { initVertexBuffer } from "./GLUtils.js";
+import Drawable from "./Drawable.js";
+import GLManager from "./managers/GLManager.js";
+
+/**
+ * @class Texture
+ * @description Represents a texture component
+ * @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 the animation should play automatically
+ * @param {boolean} pixelart - Whether the texture is a pixel art texture
+ * @param {boolean} useLighting - Whether the texture should react to lighting
+ */
+class Texture extends Drawable {
+  constructor(
+    texturePath = {},
+    frameWidth = 0,
+    frameHeight = 0,
+    framesPerRow = 1,
+    totalFrames = 1,
+    animationSpeed = 1000,
+    autoPlay = true,
+    pixelart = true,
+    useLighting = true
+  ) {
+    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,
+      true,
+      texturePath,
+      frameWidth,
+      frameHeight,
+      framesPerRow,
+      totalFrames,
+      animationSpeed,
+      autoPlay,
+      pixelart,
+      useLighting
+    );
+  }
+}
+
+export default Texture;

package/imports/Time.js

@@ -0,0 +1,28 @@
+/**
+ * @class Time
+ * @description Represents the time
+ * @param {number} deltaTime - The delta time
+ */
+class Time {
+  static deltaTime = 0;
+
+  /**
+   * @method getDeltaTime
+   * @description Returns the delta time
+   * @returns {number} - The delta time
+   */
+  static getDeltaTime() {
+    return this.deltaTime;
+  }
+
+  /**
+   * @method setDeltaTime
+   * @description Sets the delta time
+   * @param {number} deltaTime - The delta time
+   */
+  static setDeltaTime(deltaTime) {
+    this.deltaTime = deltaTime;
+  }
+}
+
+export default Time;

package/imports/Transform.js

@@ -0,0 +1,59 @@
+/**
+ * @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
+ */
+class Transform {
+  constructor(position, rotation, scale) {
+    this.position = position;
+    this.rotation = rotation;
+    this.scale = scale;
+  }
+
+  /**
+   * @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) {
+    if (!other) return false;
+    if (!(other instanceof Transform)) return false;
+    return (
+      this.position.equals(other.position) &&
+      this.rotation === other.rotation &&
+      this.scale.equals(other.scale)
+    );
+  }
+
+  /**
+   * @method getPosition
+   * @description Returns the position of the transform
+   * @returns {Vector3} - The position of the transform
+   */
+  getPosition() {
+    return this.position;
+  }
+
+  /**
+   * @method getRotation
+   * @description Returns the rotation of the transform
+   * @returns {number} - The rotation of the transform
+   */
+  getRotation() {
+    return this.rotation;
+  }
+
+  /**
+   * @method getScale
+   * @description Returns the scale of the transform
+   * @returns {Vector2} - The scale of the transform
+   */
+  getScale() {
+    return this.scale;
+  }
+}
+
+export default Transform;

package/imports/components/BoxCollider.js

@@ -0,0 +1,67 @@
+import * as planck from "planck";
+import BoxColliderDebug from "./BoxColliderDebug.js";
+import SceneManager from "../managers/SceneManager.js";
+import Collider from "./Collider.js";
+
+/**
+ * @class BoxCollider
+ * @extends Collider
+ * @param {Rigidbody} rigidbody - The rigidbody to attach the collider to
+ * @param {Vector2} fixtureSize - The size of the collider
+ * @param {number} density - The density of the collider
+ * @param {number} friction - The friction of the collider
+ * @param {number} restitution - The restitution of the collider
+ * @param {boolean} isSensor - Whether the collider is a sensor
+ * @param {GameObject} parentObject - The parent object of the collider
+ */
+class BoxCollider extends Collider {
+  constructor(
+    rigidbody,
+    fixtureSize,
+    density,
+    friction,
+    restitution,
+    isSensor = false,
+    parentObject = null
+  ) {
+    super(rigidbody, isSensor, parentObject);
+    this.collider = rigidbody
+      .getBody()
+      .createFixture(new planck.Box(fixtureSize.x, fixtureSize.y), {
+        density: density,
+        friction: friction,
+        restitution: restitution,
+        isSensor: isSensor,
+      });
+    this.fixtureSize = fixtureSize;
+    this.rigidbody.setCollider(this);
+    this.name = "BoxCollider" + this.id;
+    this.debugShape = new BoxColliderDebug(this.rigidbody);
+  }
+
+  /**
+   * @method showDebugShape
+   * @description Shows the debug shape of the collider
+   */
+  showDebugShape() {
+    SceneManager.getScene()?.add(this.debugShape.gameObject);
+  }
+
+  /**
+   * @method hideDebugShape
+   * @description Hides the debug shape of the collider
+   */
+  hideDebugShape() {
+    SceneManager.getScene().remove(this.debugShape.gameObject);
+  }
+
+  /**
+   * @method getFixtureSize
+   * @description Returns the size of the collider
+   */
+  getFixtureSize() {
+    return this.fixtureSize;
+  }
+}
+
+export default BoxCollider;

package/imports/components/BoxColliderDebug.js

@@ -0,0 +1,38 @@
+import Color from "../Color.js";
+import { Vector2, Vector3 } from "../Physics.js";
+import { Square2D } from "../Shapes.js";
+import GameObject from "./GameObject.js";
+
+/**
+ * @class BoxColliderDebug
+ * @param {Rigidbody} rigidbody - The rigidbody to attach the collider to
+ * @param {Color} color - The color of the collider
+ */
+class BoxColliderDebug {
+  constructor(rigidbody, color = null) {
+    this.rigidbody = rigidbody;
+    this.physics = this.rigidbody.physics;
+    this.scale = this.physics.getScale();
+    this.color = color || new Color(255, 0, 0, 255);
+    this.gameObject = new GameObject(
+      "BoxColliderDebug",
+      new Vector3(
+        this.rigidbody.getBody().getPosition().x *
+          this.rigidbody.getPhysics().getScale(),
+        this.rigidbody.getBody().getPosition().y *
+          this.rigidbody.getPhysics().getScale(),
+        100
+      ),
+      this.rigidbody.getAngle(),
+      new Vector2(
+        this.rigidbody.getCollider().getFixtureSize().x * this.scale,
+        this.rigidbody.getCollider().getFixtureSize().y * this.scale
+      )
+    );
+    this.gameObject.addComponent(new Square2D());
+    this.gameObject.getComponent(Square2D).setColor(this.color);
+    this.gameObject.setOpacity(0.3);
+  }
+}
+
+export default BoxColliderDebug;

package/imports/components/CircleCollider.js

@@ -0,0 +1,67 @@
+import * as planck from "planck";
+import SceneManager from "../managers/SceneManager.js";
+import CircleColliderDebug from "./CircleColliderDebug.js";
+import Collider from "./Collider.js";
+
+/**
+ * @class CircleCollider
+ * @extends Collider
+ * @param {Rigidbody} rigidbody - The rigidbody to attach the collider to
+ * @param {number} radius - The radius of the collider
+ * @param {number} density - The density of the collider
+ * @param {number} friction - The friction of the collider
+ * @param {number} restitution - The restitution of the collider
+ * @param {boolean} isSensor - Whether the collider is a sensor
+ * @param {GameObject} parentObject - The parent object of the collider
+ */
+class CircleCollider extends Collider {
+  constructor(
+    rigidbody,
+    radius,
+    density,
+    friction,
+    restitution,
+    isSensor = false,
+    parentObject = null
+  ) {
+    super(rigidbody, isSensor, parentObject);
+    this.collider = rigidbody
+      .getBody()
+      .createFixture(new planck.Circle(radius), {
+        density: density,
+        friction: friction,
+        restitution: restitution,
+        isSensor: isSensor,
+      });
+    this.radius = radius;
+    this.rigidbody.setCollider(this);
+    this.name = "CircleCollider" + this.id;
+    this.debugShape = new CircleColliderDebug(this.rigidbody);
+  }
+
+  /**
+   * @method showDebugShape
+   * @description Shows the debug shape of the collider
+   */
+  showDebugShape() {
+    SceneManager.getScene()?.add(this.debugShape.gameObject);
+  }
+
+  /**
+   * @method hideDebugShape
+   * @description Hides the debug shape of the collider
+   */
+  hideDebugShape() {
+    SceneManager.getScene()?.remove(this.debugShape.gameObject);
+  }
+
+  /**
+   * @method getRadius
+   * @description Returns the radius of the collider
+   */
+  getRadius() {
+    return this.radius;
+  }
+}
+
+export default CircleCollider;

package/imports/components/CircleColliderDebug.js

@@ -0,0 +1,36 @@
+import  Color from "../Color.js";
+import { Vector2, Vector3 } from "../Physics.js";
+import { Circle2D } from "../Shapes.js";
+import GameObject from "./GameObject.js";
+
+/**
+ * @class CircleColliderDebug
+ * @param {Rigidbody} rigidbody - The rigidbody to attach the collider to
+ * @param {Color} color - The color of the collider
+ */
+class CircleColliderDebug {
+    constructor(rigidbody, color = null) {
+        this.rigidbody = rigidbody;
+        this.physics = this.rigidbody.physics;
+        this.scale = this.physics.getScale();
+        this.color = color || new Color(255, 0, 0, 255);
+        this.gameObject = new GameObject(
+            "CircleColliderDebug",
+            new Vector3(
+                this.rigidbody.getBody().getPosition().x * this.scale,
+                this.rigidbody.getBody().getPosition().y * this.scale,
+                100
+            ),
+            this.rigidbody.getAngle(),
+            new Vector2(
+                this.rigidbody.getCollider().getRadius() * this.scale,
+                this.rigidbody.getCollider().getRadius() * this.scale
+            )
+        );
+        this.gameObject.addComponent(new Circle2D());
+        this.gameObject.getComponent(Circle2D).setColor(this.color);
+        this.gameObject.setOpacity(0.3);
+    }
+}
+
+export default CircleColliderDebug;

package/imports/components/Collider.js

@@ -0,0 +1,51 @@
+import IDManager from "../managers/IDManager.js";
+
+/**
+ * @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
+ */
+class Collider {
+    constructor(rigidbody, isSensor = false, parentObject = null) {
+        this.rigidbody = rigidbody;
+        this.parentObject = parentObject;
+        this.isSensor = isSensor;
+        this.id = IDManager.generateUniqueID();
+        this.name = "Collider" + this.id;
+    }
+
+    /**
+     * @method getRigidBody
+     * @description Returns the rigidbody of the collider
+     */
+    getRigidBody() {
+        return this.rigidbody;
+    }
+
+    /**
+     * @method getCollider
+     * @description Returns the collider
+     */
+    getCollider() {
+        return this.collider;
+    }
+
+    /**
+     * @method setParent
+     * @description Sets the parent object of the collider
+     */
+    setParent(parent) {
+        this.parentObject = parent;
+    }
+
+    /**
+     * @method getParent
+     * @description Returns the parent object of the collider
+     */
+    getParent() {
+        return this.parentObject;
+    }
+}
+
+export default Collider;

package/imports/components/GameObject.js

@@ -0,0 +1,160 @@
+import IDManager from "../managers/IDManager.js";
+import { Vector2, Vector3 } from "../Physics.js";
+import Transform from "../Transform.js";
+import RigidBody from "./RigidBody.js";
+import Collider from "./Collider.js";
+import Drawable from "../Drawable.js";
+
+/**
+ * @class GameObject
+ * @param {string} name - The name of the game object
+ * @param {Vector3} position - The position of the game object
+ * @param {number} rotation - The rotation of the game object
+ * @param {Vector2} scale - The scale of the game object
+ */
+class GameObject {
+  constructor(
+    name,
+    position = new Vector3(0, 0, 0),
+    rotation = 0,
+    scale = new Vector2(1, 1)
+  ) {
+    this.name = name;
+    this.components = [];
+    this.id = IDManager.generateUniqueID();
+    this.isActive = false;
+    this.transform = new Transform(position, rotation, scale);
+    this.opacity = 1.0; // 0..1 opacity multiplier for this GameObject
+  }
+
+  /**
+   * @method addComponent
+   * @description Adds a component to the game object
+   * @param {Component} componentInstance - The component to add
+   */
+  addComponent(componentInstance) {
+    const componentType = componentInstance.constructor;
+    if (this.components.some((comp) => comp instanceof componentType)) {
+      throw new Error(
+        `Component ${componentType.name} already exists in ${this.name}`
+      );
+    }
+    this.components.push(componentInstance);
+    componentInstance.setParent(this);
+  }
+
+  /**
+   * @method removeComponent
+   * @description Removes a component from the game object
+   * @param {Component} component - The component to remove
+   */
+  removeComponent(component) {
+    if(!component || !this.components.includes(component)) {
+      throw new Error(`Component ${component.name} not found in ${this.name}`);
+    }
+    if (component instanceof RigidBody) {
+      component.destroy();
+    }
+    this.components = this.components.filter(
+      (comp) => comp.id !== component.id
+    );
+  }
+
+  /**
+   * @method setIsActive
+   * @description Sets the active state of the game object
+   * @param {boolean} bool - The active state
+   */
+  setIsActive(bool) {
+    this.isActive = bool;
+  }
+
+  /**
+   * @method setOpacity
+   * @description Sets the opacity of the game object (0..1)
+   * @param {number} value - The opacity value between 0 and 1
+   */
+  setOpacity(value) {
+    const num = Number(value);
+    if (Number.isNaN(num)) return;
+    this.opacity = Math.max(0, Math.min(1, num));
+  }
+
+  /**
+   * @method getOpacity
+   * @description Gets the opacity of the game object
+   * @returns {number} - The opacity value between 0 and 1
+   */
+  getOpacity() {
+    return this.opacity;
+  }
+
+  /**
+   * @method getComponent
+   * @description Returns a component from the game object
+   * @param {Component} componentType - The type of component to return
+   */
+  getComponent(componentType) {
+    return this.components.find((comp) => comp instanceof componentType);
+  }
+
+  /**
+   * @method getRigidBodyAtPosition
+   * @description Returns the rigidbody at a position
+   * @param {Vector2} position - The position to check
+   */
+  getRigidBodyAtPosition(position) {
+    for (let component of this.components) {
+      if (component instanceof RigidBody) {
+        if (
+          component.getPosition().x === position.x &&
+          component.getPosition().y === position.y
+        ) {
+          return component;
+        }
+      }
+    }
+
+    return null;
+  }
+
+  /**
+   * @method draw
+   * @description Draws the game object
+   * @param {Matrix4} globalViewMatrix - The global view matrix
+   * @param {WebGLUniformLocation} uniformLocation - The uniform location
+   * @param {number} currentTime - The current time
+   */
+  draw(globalViewMatrix, uniformLocation, currentTime) {
+    const drawable = this.getComponent(Drawable);
+    const rigidBody = this.getComponent(RigidBody);
+    const collider = this.getComponent(Collider);
+    if (rigidBody && rigidBody?.getType() === "dynamic") {
+      const updatedPos = rigidBody.getBody().getPosition();
+      const rigidBodyOffset = rigidBody.getOffset();
+      const physicsScale = rigidBody.getPhysics().getScale();
+
+      this.transform.position.x =
+        updatedPos.x * physicsScale - rigidBodyOffset.x;
+      this.transform.position.y =
+        updatedPos.y * physicsScale - rigidBodyOffset.y;
+
+      if (collider) {
+        collider.debugShape.gameObject.transform.position.x =
+        this.transform.position.x;
+        collider.debugShape.gameObject.transform.position.y =
+          this.transform.position.y;
+      }
+    }
+    if (drawable) {
+      drawable.draw(
+        globalViewMatrix,
+        uniformLocation,
+        currentTime,
+        this.transform
+      );
+    }
+  }
+}
+
+export default GameObject;