emeraldengine 2.2.1 → 3.1.0

package/dist/types/src/components/Collider.d.ts

@@ -0,0 +1,102 @@
+export default Collider;
+/**
+ * @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
+ */
+declare class Collider {
+    constructor(rigidbody: any, isSensor?: boolean, parentObject?: any);
+    rigidbody: any;
+    parentObject: any;
+    isSensor: boolean;
+    id: string;
+    name: string;
+    /** @private */
+    private _debugShape;
+    /**
+     * @method syncDebugShape
+     * @description Mirrors a transform onto the debug shape, but only if one has
+     * already been created. Never forces lazy creation.
+     *
+     * The rigidbody's spawn offset is added back, because the collider sits at
+     * `transform + offset` while the transform tracks the renderable. Without it
+     * the debug shape would drift away from the collider it is supposed to be
+     * showing on any body built with an offset.
+     *
+     * @param {Transform} transform - The source transform
+     */
+    syncDebugShape(transform: Transform): void;
+    /**
+     * @method setFilter
+     * @description Sets the raw collision filter on this collider's
+     * fixture. Two fixtures collide only when each one's category bit is present
+     * in the other's mask. Subclasses must have created `this.collider`
+     * (the fixture) first.
+     * @param {Object} filter - { category, mask, group }
+     * @param {number} [filter.category=0x0001] - This fixture's category bits
+     * @param {number} [filter.mask=0xFFFF] - Bits this fixture collides with
+     * @param {number} [filter.group=0] - Group index (>0 always collide, <0 never)
+     * @returns {Collider} - this
+     */
+    setFilter({ category, mask, group }?: {
+        category?: number;
+        mask?: number;
+        group?: number;
+    }): Collider;
+    /** @private */
+    private _filter;
+    /**
+     * @method setCategory
+     * @description Sets which named layer this collider belongs to (its category
+     * bits), preserving the current mask/group. See {@link CollisionLayers}.
+     * @param {string|number} layer - Layer name or raw category bits
+     * @returns {Collider} - this
+     */
+    setCategory(layer: string | number): Collider;
+    /**
+     * @method setCollidesWith
+     * @description Sets which layers this collider can collide with (its mask),
+     * preserving the current category/group.
+     * @param {string|string[]|number} layers - Layer name(s) or raw mask bits
+     * @returns {Collider} - this
+     */
+    setCollidesWith(layers: string | string[] | number): Collider;
+    /**
+     * @method getFilter
+     * @description Returns the last applied filter, or null if none was set.
+     * @returns {{category:number, mask:number, group:number}|null}
+     */
+    getFilter(): {
+        category: number;
+        mask: number;
+        group: number;
+    } | null;
+    /**
+     * @method _applyFilterSpec
+     * @description Applies a friendly filter spec from a constructor, accepting
+     * layer names or raw bits. Spec: { category, collidesWith, group }.
+     * @private
+     */
+    private _applyFilterSpec;
+    /**
+     * @method getRigidBody
+     * @description Returns the rigidbody of the collider
+     */
+    getRigidBody(): any;
+    /**
+     * @method getCollider
+     * @description Returns the collider
+     */
+    getCollider(): any;
+    /**
+     * @method setParent
+     * @description Sets the parent object of the collider
+     */
+    setParent(parent: any): void;
+    /**
+     * @method getParent
+     * @description Returns the parent object of the collider
+     */
+    getParent(): any;
+}

package/dist/types/src/components/GameObject.d.ts

@@ -0,0 +1,135 @@
+export default GameObject;
+/**
+ * @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
+ */
+declare class GameObject {
+    constructor(name: any, position?: Vector3, rotation?: number, scale?: Vector2);
+    name: any;
+    components: any[];
+    id: string;
+    isActive: boolean;
+    transform: Transform;
+    opacity: number;
+    layer: number;
+    screenSpace: boolean;
+    /**
+     * @method setLayer
+     * @description Sets the render layer. Objects are drawn by layer first, then
+     * by z within a layer.
+     * @param {number} layer - The layer index
+     * @returns {GameObject} - this
+     */
+    setLayer(layer: number): GameObject;
+    /**
+     * @method setScreenSpace
+     * @description When true, the object ignores the camera (fixed on screen),
+     * useful for HUD/UI. Position is then in pixels from the viewport center.
+     * Note: not supported for InstancedTexture-based objects.
+     * @param {boolean} value
+     * @returns {GameObject} - this
+     */
+    setScreenSpace(value: boolean): GameObject;
+    /**
+     * @method addComponent
+     * @description Adds a component to the game object
+     * @param {Component} componentInstance - The component to add
+     */
+    addComponent(componentInstance: Component): void;
+    /**
+     * @method removeComponent
+     * @description Removes a component from the game object
+     * @param {Component} component - The component to remove
+     */
+    removeComponent(component: Component): void;
+    /**
+     * @method update
+     * @description Ticks the lifecycle of Behaviour components on this object.
+     * Only Behaviours are ticked here so component types with their own update
+     * signature (e.g. InstancedTexture) are left untouched.
+     * @param {number} deltaTime - Seconds since the previous frame (time-scaled)
+     */
+    update(deltaTime: number): void;
+    /**
+     * @method setParent
+     * @description Parents this object to another GameObject (or detaches with
+     * null). The object's transform then composes on top of the parent's, so
+     * moving/rotating/scaling the parent moves its children.
+     * @param {GameObject|null} parent - The parent GameObject, or null
+     * @returns {GameObject} - this
+     */
+    setParent(parent: GameObject | null): GameObject;
+    /**
+     * @method addChild
+     * @description Parents another GameObject to this one.
+     * @param {GameObject} child - The child GameObject
+     * @returns {GameObject} - this
+     */
+    addChild(child: GameObject): GameObject;
+    /**
+     * @method setIsActive
+     * @description Sets the active state of the game object
+     * @param {boolean} bool - The active state
+     */
+    setIsActive(bool: boolean): void;
+    /**
+     * @method setOpacity
+     * @description Sets the opacity of the game object (0..1)
+     * @param {number} value - The opacity value between 0 and 1
+     */
+    setOpacity(value: number): void;
+    /**
+     * @method getOpacity
+     * @description Gets the opacity of the game object
+     * @returns {number} - The opacity value between 0 and 1
+     */
+    getOpacity(): number;
+    /**
+     * @method getComponent
+     * @description Returns a component from the game object
+     * @param {Component} componentType - The type of component to return
+     */
+    getComponent(componentType: Component): any;
+    /**
+     * @method getRigidBodyAtPosition
+     * @description Returns the rigidbody at a position
+     * @param {Vector2} position - The position to check
+     */
+    getRigidBodyAtPosition(position: Vector2): RigidBody;
+    /**
+     * @method syncPhysics
+     * @description Copies simulation state (position + rotation) from this
+     * object's dynamic rigidbody onto its transform, and mirrors it onto any
+     * visible collider debug shape. Called once per frame from the render loop so
+     * draw() stays read-only and physics isn't re-applied per camera. Also
+     * forwards to components that own their own physics-driven content (e.g.
+     * InstancedTexture).
+     */
+    syncPhysics(): void;
+    /**
+     * @method destroy
+     * @description Permanently tears the object down: disposes every Drawable's
+     * GPU resources, destroys physics bodies, and runs Behaviour.onDestroy().
+     * Use it (or Scene.remove(obj, { dispose: true })) when an object will not
+     * be re-added: plain Scene.remove() keeps GPU resources alive for re-use.
+     * Safe to call twice.
+     */
+    destroy(): void;
+    /** @private */
+    private _destroyed;
+    /**
+     * @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: Matrix4, uniformLocation: WebGLUniformLocation, currentTime: number): void;
+}
+import Transform from "../Transform.js";
+import { Vector2 } from "../Physics.js";
+import RigidBody from "./RigidBody.js";
+import { Vector3 } from "../Physics.js";

package/dist/types/src/components/PolygonCollider.d.ts

@@ -0,0 +1,33 @@
+export default PolygonCollider;
+/**
+ * @class PolygonCollider
+ * @extends Collider
+ * @description A convex-polygon fixture, for collision shapes a box or
+ * circle can't approximate, like ramps, wedges, or arbitrary tile outlines (see
+ * {@link ForgeLevel}). Points outside the convex hull of what you pass are
+ * dropped automatically; a concave shape needs more than one collider.
+ * @param {Rigidbody} rigidbody - The rigidbody to attach the collider to
+ * @param {Array<{x:number,y:number}>} points - Local-space points, in
+ *   physics units, in any order
+ * @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=false] - Whether the collider is a sensor
+ * @param {GameObject} [parentObject=null] - The parent object of the collider
+ * @param {Object} [filter=null] - Collision filter spec, see {@link Collider#setFilter}
+ */
+declare class PolygonCollider extends Collider {
+    constructor(rigidbody: any, points: any, density: any, friction: any, restitution: any, isSensor?: boolean, parentObject?: any, filter?: any);
+    collider: any;
+    points: any;
+    /**
+     * @method getPoints
+     * @description Returns the local-space points this collider was built from
+     * @returns {Array<{x:number,y:number}>}
+     */
+    getPoints(): Array<{
+        x: number;
+        y: number;
+    }>;
+}
+import Collider from "./Collider.js";