emeraldengine 2.2.1 → 3.1.0

package/src/physics/index.js

@@ -0,0 +1,79 @@
+/**
+ * @file Emerald's built-in 2D rigid-body physics engine.
+ * @description A complete, dependency-free simulation: a dynamic AABB tree
+ * broadphase, SAT/GJK narrowphase, an impulse-based contact solver with warm
+ * starting and island sleeping, and conservative-advancement continuous
+ * collision detection.
+ *
+ * Everything here works in physics units (meters, radians, seconds). Games
+ * normally use {@link Physics}, {@link RigidBody}, {@link BoxCollider} and
+ * {@link CircleCollider} instead, which handle the pixel conversion; reach for
+ * this module directly only when you want a bare world.
+ *
+ * @example
+ * import { World, Box, Vec2 } from "emeraldengine/src/physics/index.js";
+ * const world = new World({ gravity: new Vec2(0, -10) });
+ * const ground = world.createBody({ type: "static", position: new Vec2(0, 0) });
+ * ground.createFixture(Box(50, 1), { friction: 0.4 });
+ * const crate = world.createBody({ type: "dynamic", position: new Vec2(0, 8) });
+ * crate.createFixture(Box(0.5, 0.5), { density: 1, friction: 0.3 });
+ * world.step(1 / 60);
+ */
+import World from "./World.js";
+import { Body, BodyType } from "./Body.js";
+import { Fixture } from "./Fixture.js";
+import { Contact, ContactManager, shouldCollide } from "./Contact.js";
+import {
+  Shape,
+  ShapeType,
+  CircleShape,
+  PolygonShape,
+  Box,
+  Circle,
+} from "./Shapes.js";
+import { Vec2, Rot, Transform2, Sweep } from "./Math2D.js";
+import AABB from "./AABB.js";
+import Settings from "./Settings.js";
+import { Manifold, ManifoldType, WorldManifold } from "./Collision.js";
+import { DistanceProxy, distance, testOverlap } from "./Distance.js";
+import { timeOfImpact, TOIState } from "./TimeOfImpact.js";
+import { BroadPhase, DynamicTree } from "./BroadPhase.js";
+import { Joint, JointType } from "./Joint.js";
+import DistanceJoint from "./DistanceJoint.js";
+import RevoluteJoint from "./RevoluteJoint.js";
+
+export {
+  World,
+  Body,
+  BodyType,
+  Fixture,
+  Contact,
+  ContactManager,
+  shouldCollide,
+  Shape,
+  ShapeType,
+  CircleShape,
+  PolygonShape,
+  Box,
+  Circle,
+  Vec2,
+  Rot,
+  Transform2,
+  Sweep,
+  AABB,
+  Settings,
+  Manifold,
+  ManifoldType,
+  WorldManifold,
+  DistanceProxy,
+  distance,
+  testOverlap,
+  timeOfImpact,
+  TOIState,
+  BroadPhase,
+  DynamicTree,
+  Joint,
+  JointType,
+  DistanceJoint,
+  RevoluteJoint,
+};

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/Physics.d.ts

@@ -1,139 +0,0 @@
-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
- */
-declare class Physics {
-    world: planck.World;
-    gravity: number;
-    scale: number;
-    constructor(gravity: number, scale: number, velocityThreshold?: number);
-    /**
-     * @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: string, position?: Vector2, fixedRotation?: boolean, attachFixture?: boolean, fixtureSize?: Vector2, density?: number, friction?: number, restitution?: number): planck.Body;
-    /**
-     * @method onCollisionEnter
-     * @description Handles the collision enter event
-     * @param {Function} callback - The callback function to handle the collision enter event
-     */
-    onCollisionEnter(callback: (bodyA: planck.Body, bodyB: planck.Body, contact: planck.Contact) => void): void;
-    /**
-     * @method onCollisionExit
-     * @description Handles the collision exit event
-     * @param {Function} callback - The callback function to handle the collision exit event
-     */
-    onCollisionExit(callback: (bodyA: planck.Body, bodyB: planck.Body, contact: planck.Contact) => void): void;
-    /**
-     * @method process
-     * @description Processes the physics engine
-     * @param {number} dt - The delta time
-     */
-    process(dt: number): void;
-    /**
-     * @method clear
-     * @description Clears the physics engine objects and resets the gravity
-     */
-    clear(): void;
-    /**
-     * @method getGravity
-     * @description Returns the gravity of the physics engine
-     * @returns {number} - The gravity of the physics engine
-     */
-    getGravity(): number;
-    /**
-     * @method getScale
-     * @description Returns the scale of the physics engine
-     * @returns {number} - The scale of the physics engine
-     */
-    getScale(): number;
-    /**
-     * @method scheduleAction
-     * @description Schedules an action to be executed as soon as possible
-     * @param {Function} callback - The callback function to execute
-     */
-    static scheduleAction(callback: () => void): void;
-}
-/**
- * @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
- */
-declare class Vector2 {
-    x: number;
-    y: number;
-    constructor(x: number, y: number);
-    /**
-     * @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: Vector2): boolean;
-    /**
-     * @method getX
-     * @description Returns the x coordinate of the vector
-     * @returns {number} - The x coordinate of the vector
-     */
-    getX(): number;
-    /**
-     * @method getY
-     * @description Returns the y coordinate of the vector
-     * @returns {number} - The y coordinate of the vector
-     */
-    getY(): number;
-}
-/**
- * @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
- */
-declare class Vector3 {
-    x: number;
-    y: number;
-    z: number;
-    constructor(x: number, y: number, z: number);
-    /**
-     * @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: Vector3): boolean;
-    /**
-     * @method getX
-     * @description Returns the x coordinate of the vector
-     * @returns {number} - The x coordinate of the vector
-     */
-    getX(): number;
-    /**
-     * @method getY
-     * @description Returns the y coordinate of the vector
-     * @returns {number} - The y coordinate of the vector
-     */
-    getY(): number;
-    /**
-     * @method getZ
-     * @description Returns the z coordinate of the vector
-     * @returns {number} - The z coordinate of the vector
-     */
-    getZ(): number;
-}
-export { Physics, Vector2, Vector3 };
-//# sourceMappingURL=Physics.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