melonjs 15.2.1 → 15.4.0

package/dist/types/math/matrix3.d.ts

@@ -14,41 +14,28 @@ export default class Matrix3d {
     val: Float32Array | undefined;
     /**
      * tx component of the matrix
-     * @public
      * @type {number}
-     * @name tx
-     * @memberof Matrix3d
      */
-    public get tx(): number;
+    get tx(): number;
     /**
      * ty component of the matrix
-     * @public
      * @type {number}
-     * @name ty
-     * @memberof Matrix3d
      */
-    public get ty(): number;
+    get ty(): number;
     /**
      * ty component of the matrix
-     * @public
      * @type {number}
-     * @name tz
-     * @memberof Matrix3d
      */
-    public get tz(): number;
+    get tz(): number;
     /**
      * reset the transformation matrix to the identity matrix (no transformation).<br>
      * the identity matrix and parameters position : <br>
      * <img src="images/identity-matrix_2x.png"/>
-     * @name identity
-     * @memberof Matrix3d
      * @returns {Matrix3d} Reference to this object for method chaining
      */
     identity(): Matrix3d;
     /**
      * set the matrix to the specified value
-     * @name setTransform
-     * @memberof Matrix3d
      * @param {number} m00
      * @param {number} m01
      * @param {number} m02
@@ -70,63 +57,47 @@ export default class Matrix3d {
     setTransform(m00: number, m01: number, m02: number, m03: number, m10: number, m11: number, m12: number, m13: number, m20: number, m21: number, m22: number, m23: number, m30: number, m31: number, m32: number, m33: number): Matrix3d;
     /**
      * Copies over the values from another me.Matrix3d.
-     * @name copy
-     * @memberof Matrix3d
      * @param {Matrix3d} m - the matrix object to copy from
      * @returns {Matrix3d} Reference to this object for method chaining
      */
     copy(m: Matrix3d): Matrix3d;
     /**
      * Copies over the upper-left 2x2 values from the given me.Matrix2d
-     * @name fromMat2d
-     * @memberof Matrix3d
      * @param {Matrix2d} m - the matrix object to copy from
      * @returns {Matrix2d} Reference to this object for method chaining
      */
     fromMat2d(m: Matrix2d): Matrix2d;
     /**
      * multiply both matrix
-     * @name multiply
-     * @memberof Matrix3d
      * @param {Matrix3d} m - Other matrix
      * @returns {Matrix3d} Reference to this object for method chaining
      */
     multiply(m: Matrix3d): Matrix3d;
     /**
      * Transpose the value of this matrix.
-     * @name transpose
-     * @memberof Matrix3d
      * @returns {Matrix3d} Reference to this object for method chaining
      */
     transpose(): Matrix3d;
     /**
      * invert this matrix, causing it to apply the opposite transformation.
-     * @name invert
-     * @memberof Matrix3d
      * @returns {Matrix3d} Reference to this object for method chaining
      */
     invert(): Matrix3d;
     /**
      * apply the current transform to the given 2d or 3d vector
-     * @name apply
-     * @memberof Matrix3d
      * @param {Vector2d|Vector3d} v - the vector object to be transformed
      * @returns {Vector2d|Vector3d} result vector object.
      */
     apply(v: Vector2d | Vector3d): Vector2d | Vector3d;
     /**
-     * apply the inverted current transform to the given 2d or 3d vector
-     * @name applyInverse
-     * @memberof Matrix3d
-     * @param {Vector2d|Vector3d} v - the vector object to be transformed
-     * @returns {Vector2d|Vector3d} result vector object.
-     */
+      * apply the inverted current transform to the given 2d or 3d vector
+      * @param {Vector2d|Vector3d} v - the vector object to be transformed
+      * @returns {Vector2d|Vector3d} result vector object.
+      */
     applyInverse(v: Vector2d | Vector3d): Vector2d | Vector3d;
     /**
      * generate an orthogonal projection matrix, with the result replacing the current matrix
      * <img src="images/glOrtho.gif"/><br>
-     * @name ortho
-     * @memberof Matrix3d
      * @param {number} left - farthest left on the x-axis
      * @param {number} right - farthest right on the x-axis
      * @param {number} bottom - farthest down on the y-axis
@@ -138,8 +109,6 @@ export default class Matrix3d {
     ortho(left: number, right: number, bottom: number, top: number, near: number, far: number): Matrix3d;
     /**
      * scale the matrix
-     * @name scale
-     * @memberof Matrix3d
      * @param {number} x - a number representing the abscissa of the scaling vector.
      * @param {number} [y=x] - a number representing the ordinate of the scaling vector.
      * @param {number} [z=0] - a number representing the depth vector
@@ -148,32 +117,24 @@ export default class Matrix3d {
     scale(x: number, y?: number | undefined, z?: number | undefined): Matrix3d;
     /**
      * adds a 2D scaling transformation.
-     * @name scaleV
-     * @memberof Matrix3d
      * @param {Vector2d|Vector3d} v - scaling vector
      * @returns {Matrix3d} Reference to this object for method chaining
      */
     scaleV(v: Vector2d | Vector3d): Matrix3d;
     /**
      * specifies a 2D scale operation using the [sx, 1] scaling vector
-     * @name scaleX
-     * @memberof Matrix3d
      * @param {number} x - x scaling vector
      * @returns {Matrix3d} Reference to this object for method chaining
      */
     scaleX(x: number): Matrix3d;
     /**
      * specifies a 2D scale operation using the [1,sy] scaling vector
-     * @name scaleY
-     * @memberof Matrix3d
      * @param {number} y - y scaling vector
      * @returns {Matrix3d} Reference to this object for method chaining
      */
     scaleY(y: number): Matrix3d;
     /**
      * rotate this matrix (counter-clockwise) by the specified angle (in radians).
-     * @name rotate
-     * @memberof Matrix3d
      * @param {number} angle - Rotation angle in radians.
      * @param {Vector3d} v - the axis to rotate around
      * @returns {Matrix3d} Reference to this object for method chaining
@@ -181,55 +142,35 @@ export default class Matrix3d {
     rotate(angle: number, v: Vector3d): Matrix3d;
     /**
      * translate the matrix position using the given vector
-     * @name translate
-     * @memberof Matrix3d
-     * @method
-     * @param {number} x - a number representing the abscissa of the vector.
-     * @param {number} [y=x] - a number representing the ordinate of the vector.
+     * @param {number|Vector2d|Vector3d} x - a number representing the abscissa of the vector, or a vector object
+     * @param {number} [y] - a number representing the ordinate of the vector.
      * @param {number} [z=0] - a number representing the depth of the vector
      * @returns {Matrix3d} Reference to this object for method chaining
      */
-    /**
-     * translate the matrix by a vector on the horizontal and vertical axis
-     * @name translateV
-     * @memberof Matrix3d
-     * @param {Vector2d|Vector3d} v - the vector to translate the matrix by
-     * @returns {Matrix3d} Reference to this object for method chaining
-     */
     translate(...args: any[]): Matrix3d;
     /**
      * returns true if the matrix is an identity matrix.
-     * @name isIdentity
-     * @memberof Matrix3d
      * @returns {boolean}
      */
     isIdentity(): boolean;
     /**
      * return true if the two matrices are identical
-     * @name equals
-     * @memberof Matrix3d
      * @param {Matrix3d} m - the other matrix
      * @returns {boolean} true if both are equals
      */
     equals(m: Matrix3d): boolean;
     /**
      * Clone the Matrix
-     * @name clone
-     * @memberof Matrix3d
      * @returns {Matrix3d}
      */
     clone(): Matrix3d;
     /**
      * return an array representation of this Matrix
-     * @name toArray
-     * @memberof Matrix3d
      * @returns {Float32Array}
      */
     toArray(): Float32Array;
     /**
      * convert the object to a string representation
-     * @name toString
-     * @memberof Matrix3d
      * @returns {string}
      */
     toString(): string;

package/dist/types/math/observable_vector2.d.ts

@@ -18,7 +18,7 @@ export default class ObservableVector2d extends Vector2d {
     /**
      * @ignore
      */
-    onResetEvent(x: number | undefined, y: number | undefined, settings: any): ObservableVector2d;
+    onResetEvent(x: number | undefined, y: number | undefined, settings: any): this;
     public set x(arg: number);
     /**
      * x value of the vector
@@ -40,7 +40,7 @@ export default class ObservableVector2d extends Vector2d {
     public get y(): number;
     _y: any;
     /** @ignore */
-    _set(x: any, y: any): ObservableVector2d;
+    _set(x: any, y: any): this;
     /**
      * set the vector value without triggering the callback
      * @name setMuted

package/dist/types/math/observable_vector3.d.ts

@@ -19,7 +19,7 @@ export default class ObservableVector3d extends Vector3d {
     /**
      * @ignore
      */
-    onResetEvent(x: number | undefined, y: number | undefined, z: number | undefined, settings: any): ObservableVector3d;
+    onResetEvent(x: number | undefined, y: number | undefined, z: number | undefined, settings: any): this;
     public set x(arg: number);
     /**
      * x value of the vector
@@ -53,7 +53,7 @@ export default class ObservableVector3d extends Vector3d {
     /**
      * @ignore
      */
-    _set(x: any, y: any, z: any): ObservableVector3d;
+    _set(x: any, y: any, z: any): this;
     /**
      * set the vector value without triggering the callback
      * @name setMuted

package/dist/types/math/vector2.d.ts

@@ -11,17 +11,15 @@ export default class Vector2d {
     /**
      * @ignore
      */
-    onResetEvent(x?: number, y?: number): Vector2d;
+    onResetEvent(x?: number, y?: number): this;
     x: any;
     y: any;
     /**
      * @ignore
      */
-    _set(x: any, y: any): Vector2d;
+    _set(x: any, y: any): this;
     /**
      * set the Vector x and y properties to the given values<br>
-     * @name set
-     * @memberof Vector2d
      * @param {number} x
      * @param {number} y
      * @returns {Vector2d} Reference to this object for method chaining
@@ -29,39 +27,29 @@ export default class Vector2d {
     set(x: number, y: number): Vector2d;
     /**
      * set the Vector x and y properties to 0
-     * @name setZero
-     * @memberof Vector2d
      * @returns {Vector2d} Reference to this object for method chaining
      */
     setZero(): Vector2d;
     /**
      * set the Vector x and y properties using the passed vector
-     * @name setV
-     * @memberof Vector2d
      * @param {Vector2d} v
      * @returns {Vector2d} Reference to this object for method chaining
      */
     setV(v: Vector2d): Vector2d;
     /**
      * Add the passed vector to this vector
-     * @name add
-     * @memberof Vector2d
      * @param {Vector2d} v
      * @returns {Vector2d} Reference to this object for method chaining
      */
     add(v: Vector2d): Vector2d;
     /**
      * Substract the passed vector to this vector
-     * @name sub
-     * @memberof Vector2d
      * @param {Vector2d} v
      * @returns {Vector2d} Reference to this object for method chaining
      */
     sub(v: Vector2d): Vector2d;
     /**
      * Multiply this vector values by the given scalar
-     * @name scale
-     * @memberof Vector2d
      * @param {number} x
      * @param {number} [y=x]
      * @returns {Vector2d} Reference to this object for method chaining
@@ -69,45 +57,33 @@ export default class Vector2d {
     scale(x: number, y?: number | undefined): Vector2d;
     /**
      * Convert this vector into isometric coordinate space
-     * @name toIso
-     * @memberof Vector2d
      * @returns {Vector2d} Reference to this object for method chaining
      */
     toIso(): Vector2d;
     /**
      * Convert this vector into 2d coordinate space
-     * @name to2d
-     * @memberof Vector2d
      * @returns {Vector2d} Reference to this object for method chaining
      */
     to2d(): Vector2d;
     /**
      * Multiply this vector values by the passed vector
-     * @name scaleV
-     * @memberof Vector2d
      * @param {Vector2d} v
      * @returns {Vector2d} Reference to this object for method chaining
      */
     scaleV(v: Vector2d): Vector2d;
     /**
      * Divide this vector values by the passed value
-     * @name div
-     * @memberof Vector2d
      * @param {number} n - the value to divide the vector by
      * @returns {Vector2d} Reference to this object for method chaining
      */
     div(n: number): Vector2d;
     /**
      * Update this vector values to absolute values
-     * @name abs
-     * @memberof Vector2d
      * @returns {Vector2d} Reference to this object for method chaining
      */
     abs(): Vector2d;
     /**
      * Clamp the vector value within the specified value range
-     * @name clamp
-     * @memberof Vector2d
      * @param {number} low
      * @param {number} high
      * @returns {Vector2d} new me.Vector2d
@@ -115,8 +91,6 @@ export default class Vector2d {
     clamp(low: number, high: number): Vector2d;
     /**
      * Clamp this vector value within the specified value range
-     * @name clampSelf
-     * @memberof Vector2d
      * @param {number} low
      * @param {number} high
      * @returns {Vector2d} Reference to this object for method chaining
@@ -124,106 +98,72 @@ export default class Vector2d {
     clampSelf(low: number, high: number): Vector2d;
     /**
      * Update this vector with the minimum value between this and the passed vector
-     * @name minV
-     * @memberof Vector2d
      * @param {Vector2d} v
      * @returns {Vector2d} Reference to this object for method chaining
      */
     minV(v: Vector2d): Vector2d;
     /**
      * Update this vector with the maximum value between this and the passed vector
-     * @name maxV
-     * @memberof Vector2d
      * @param {Vector2d} v
      * @returns {Vector2d} Reference to this object for method chaining
      */
     maxV(v: Vector2d): Vector2d;
     /**
      * Floor the vector values
-     * @name floor
-     * @memberof Vector2d
      * @returns {Vector2d} new me.Vector2d
      */
     floor(): Vector2d;
     /**
      * Floor this vector values
-     * @name floorSelf
-     * @memberof Vector2d
      * @returns {Vector2d} Reference to this object for method chaining
      */
     floorSelf(): Vector2d;
     /**
      * Ceil the vector values
-     * @name ceil
-     * @memberof Vector2d
      * @returns {Vector2d} new me.Vector2d
      */
     ceil(): Vector2d;
     /**
      * Ceil this vector values
-     * @name ceilSelf
-     * @memberof Vector2d
      * @returns {Vector2d} Reference to this object for method chaining
      */
     ceilSelf(): Vector2d;
     /**
      * Negate the vector values
-     * @name negate
-     * @memberof Vector2d
      * @returns {Vector2d} new me.Vector2d
      */
     negate(): Vector2d;
     /**
      * Negate this vector values
-     * @name negateSelf
-     * @memberof Vector2d
      * @returns {Vector2d} Reference to this object for method chaining
      */
     negateSelf(): Vector2d;
     /**
      * Copy the x,y values of the passed vector to this one
-     * @name copy
-     * @memberof Vector2d
      * @param {Vector2d} v
      * @returns {Vector2d} Reference to this object for method chaining
      */
     copy(v: Vector2d): Vector2d;
     /**
-     * return true if the two vectors are the same
-     * @name equals
-     * @memberof Vector2d
-     * @method
-     * @param {Vector2d} v
-     * @returns {boolean}
-     */
-    /**
-     * return true if this vector is equal to the given values
-     * @name equals
-     * @memberof Vector2d
-     * @param {number} x
-     * @param {number} y
+     * return true if this vector is equal to the given values or vector
+     * @param {number|Vector2d|ObservableVector2d} x
+     * @param {number} [y]
      * @returns {boolean}
      */
     equals(...args: any[]): boolean;
     /**
      * normalize this vector (scale the vector so that its magnitude is 1)
-     * @name normalize
-     * @memberof Vector2d
      * @returns {Vector2d} Reference to this object for method chaining
      */
     normalize(): Vector2d;
     /**
      * change this vector to be perpendicular to what it was before.<br>
      * (Effectively rotates it 90 degrees in a clockwise direction)
-     * @name perp
-     * @memberof Vector2d
      * @returns {Vector2d} Reference to this object for method chaining
      */
     perp(): Vector2d;
     /**
      * Rotate this vector (counter-clockwise) by the specified angle (in radians).
-     * @name rotate
-     * @memberof Vector2d
      * @param {number} angle - The angle to rotate (in radians)
      * @param {Vector2d|ObservableVector2d} [v] - an optional point to rotate around
      * @returns {Vector2d} Reference to this object for method chaining
@@ -231,38 +171,28 @@ export default class Vector2d {
     rotate(angle: number, v?: Vector2d | ObservableVector2d): Vector2d;
     /**
      * return the dot product of this vector and the passed one
-     * @name dot
-     * @memberof Vector2d
      * @param {Vector2d} v
      * @returns {number} The dot product.
      */
     dot(v: Vector2d): number;
     /**
      * return the cross product of this vector and the passed one
-     * @name cross
-     * @memberof Vector2d
      * @param {Vector2d} v
      * @returns {number} The cross product.
      */
     cross(v: Vector2d): number;
     /**
-     * return the square length of this vector
-     * @name length2
-     * @memberof Vector2d
-     * @returns {number} The length^2 of this vector.
-     */
+    * return the square length of this vector
+    * @returns {number} The length^2 of this vector.
+    */
     length2(): number;
     /**
      * return the length (magnitude) of this vector
-     * @name length
-     * @memberof Vector2d
      * @returns {number} the length of this vector
      */
     length(): number;
     /**
      * Linearly interpolate between this vector and the given one.
-     * @name lerp
-     * @memberof Vector2d
      * @param {Vector2d} v
      * @param {number} alpha - distance along the line (alpha = 0 will be this vector, and alpha = 1 will be the given one).
      * @returns {Vector2d} Reference to this object for method chaining
@@ -270,8 +200,6 @@ export default class Vector2d {
     lerp(v: Vector2d, alpha: number): Vector2d;
     /**
      * interpolate the position of this vector towards the given one by the given maximum step.
-     * @name moveTowards
-     * @memberof Vector2d
      * @param {Vector2d} target
      * @param {number} step - the maximum step per iteration (Negative values will push the vector away from the target)
      * @returns {Vector2d} Reference to this object for method chaining
@@ -279,24 +207,18 @@ export default class Vector2d {
     moveTowards(target: Vector2d, step: number): Vector2d;
     /**
      * return the distance between this vector and the passed one
-     * @name distance
-     * @memberof Vector2d
      * @param {Vector2d} v
      * @returns {number}
      */
     distance(v: Vector2d): number;
     /**
      * return the angle between this vector and the passed one
-     * @name angle
-     * @memberof Vector2d
      * @param {Vector2d} v
      * @returns {number} angle in radians
      */
     angle(v: Vector2d): number;
     /**
      * project this vector on to another vector.
-     * @name project
-     * @memberof Vector2d
      * @param {Vector2d} v - The vector to project onto.
      * @returns {Vector2d} Reference to this object for method chaining
      */
@@ -304,23 +226,17 @@ export default class Vector2d {
     /**
      * Project this vector onto a vector of unit length.<br>
      * This is slightly more efficient than `project` when dealing with unit vectors.
-     * @name projectN
-     * @memberof Vector2d
      * @param {Vector2d} v - The unit vector to project onto.
      * @returns {Vector2d} Reference to this object for method chaining
      */
     projectN(v: Vector2d): Vector2d;
     /**
      * return a clone copy of this vector
-     * @name clone
-     * @memberof Vector2d
      * @returns {Vector2d} new me.Vector2d
      */
     clone(): Vector2d;
     /**
      * convert the object to a string representation
-     * @name toString
-     * @memberof Vector2d
      * @returns {string}
      */
     toString(): string;