melonjs 10.3.0 → 10.5.1

package/src/physics/bounds.js

@@ -4,18 +4,18 @@ import Polygon from "./../geometries/poly.js";
 /**
  * @classdesc
  * a bound object contains methods for creating and manipulating axis-aligned bounding boxes (AABB).
- * @class Bounds
- * @memberof me
- * @param {me.Vector2d[]} [vertices] an array of me.Vector2d points
- * @returns {me.Bounds} A new bounds object
  */
-
 class Bounds {
-
+    /**
+     * @param {Vector2d[]} [vertices] an array of me.Vector2d points
+     */
     constructor(vertices) {
         this.onResetEvent(vertices);
     }
 
+    /**
+     * @ignore
+     */
     onResetEvent(vertices) {
         if (typeof this.min === "undefined") {
             this.min = { x: Infinity,  y: Infinity };
@@ -34,7 +34,7 @@ class Bounds {
     /**
      * reset the bound
      * @name clear
-     * @memberof me.Bounds
+     * @memberof Bounds
      * @function
      */
     clear() {
@@ -45,7 +45,7 @@ class Bounds {
     /**
      * sets the bounds to the given min and max value
      * @name setMinMax
-     * @memberof me.Bounds
+     * @memberof Bounds
      * @function
      * @param {number} minX
      * @param {number} minY
@@ -65,7 +65,7 @@ class Bounds {
      * @public
      * @type {number}
      * @name x
-     * @memberof me.Bounds
+     * @memberof Bounds
      */
     get x() {
         return this.min.x;
@@ -82,7 +82,7 @@ class Bounds {
      * @public
      * @type {number}
      * @name y
-     * @memberof me.Bounds
+     * @memberof Bounds
      */
     get y() {
         return this.min.y;
@@ -100,7 +100,7 @@ class Bounds {
      * @public
      * @type {number}
      * @name width
-     * @memberof me.Bounds
+     * @memberof Bounds
      */
     get width() {
         return this.max.x - this.min.x;
@@ -115,7 +115,7 @@ class Bounds {
      * @public
      * @type {number}
      * @name width
-     * @memberof me.Bounds
+     * @memberof Bounds
      */
     get height() {
         return this.max.y - this.min.y;
@@ -130,7 +130,7 @@ class Bounds {
      * @public
      * @type {number}
      * @name left
-     * @memberof me.Bounds
+     * @memberof Bounds
      */
     get left() {
         return this.min.x;
@@ -141,7 +141,7 @@ class Bounds {
      * @public
      * @type {number}
      * @name right
-     * @memberof me.Bounds
+     * @memberof Bounds
      */
     get right() {
         return this.max.x;
@@ -152,7 +152,7 @@ class Bounds {
      * @public
      * @type {number}
      * @name top
-     * @memberof me.Bounds
+     * @memberof Bounds
      */
     get top() {
         return this.min.y;
@@ -163,7 +163,7 @@ class Bounds {
      * @public
      * @type {number}
      * @name bottom
-     * @memberof me.Bounds
+     * @memberof Bounds
      */
     get bottom() {
         return this.max.y;
@@ -174,7 +174,7 @@ class Bounds {
      * @public
      * @type {number}
      * @name centerX
-     * @memberof me.Bounds
+     * @memberof Bounds
      */
     get centerX() {
         return this.min.x + (this.width / 2);
@@ -185,7 +185,7 @@ class Bounds {
      * @public
      * @type {number}
      * @name centerY
-     * @memberof me.Bounds
+     * @memberof Bounds
      */
     get centerY() {
         return this.min.y + (this.height / 2);
@@ -194,9 +194,9 @@ class Bounds {
     /**
      * return the center position of the bound
      * @public
-     * @type {me.Vector2d}
+     * @type {Vector2d}
      * @name center
-     * @memberof me.Bounds
+     * @memberof Bounds
      */
     get center() {
         return this._center.set(this.centerX, this.centerY);
@@ -205,9 +205,9 @@ class Bounds {
     /**
      * Updates bounds using the given vertices
      * @name update
-     * @memberof me.Bounds
+     * @memberof Bounds
      * @function
-     * @param {me.Vector2d[]} vertices an array of me.Vector2d points
+     * @param {Vector2d[]} vertices an array of me.Vector2d points
      */
     update(vertices) {
         this.add(vertices, true);
@@ -216,9 +216,9 @@ class Bounds {
     /**
      * add the given vertices to the bounds definition.
      * @name add
-     * @memberof me.Bounds
+     * @memberof Bounds
      * @function
-     * @param {me.Vector2d[]} vertices an array of me.Vector2d points
+     * @param {Vector2d[]} vertices an array of me.Vector2d points
      * @param {boolean} [clear=false] either to reset the bounds before adding the new vertices
      */
     add(vertices, clear = false) {
@@ -237,9 +237,9 @@ class Bounds {
     /**
      * add the given bounds to the bounds definition.
      * @name addBounds
-     * @memberof me.Bounds
+     * @memberof Bounds
      * @function
-     * @param {me.Bounds} bounds
+     * @param {Bounds} bounds
      * @param {boolean} [clear=false] either to reset the bounds before adding the new vertices
      */
     addBounds(bounds, clear = false) {
@@ -256,10 +256,10 @@ class Bounds {
     /**
      * add the given point to the bounds definition.
      * @name addPoint
-     * @memberof me.Bounds
+     * @memberof Bounds
      * @function
-     * @param {me.Vector2d} v
-     * @param {me.Matrix2d} [m] an optional transform to apply to the given point
+     * @param {Vector2d} v
+     * @param {Matrix2d} [m] an optional transform to apply to the given point
      */
     addPoint(v, m) {
         if (typeof m !== "undefined") {
@@ -274,13 +274,13 @@ class Bounds {
     /**
      * add the given quad coordinates to this bound definition, multiplied by the given matrix
      * @name addFrame
-     * @memberof me.Bounds
+     * @memberof Bounds
      * @function
      * @param {number} x0 - left X coordinates of the quad
      * @param {number} y0 - top Y coordinates of the quad
      * @param {number} x1 - right X coordinates of the quad
      * @param {number} y1 - bottom y coordinates of the quad
-     * @param {me.Matrix2d} [m] an optional transform to apply to the given frame coordinates
+     * @param {Matrix2d} [m] an optional transform to apply to the given frame coordinates
      */
     addFrame(x0, y0, x1, y1, m) {
         var v = me.pool.pull("Vector2d");
@@ -297,15 +297,15 @@ class Bounds {
     /**
      * Returns true if the bounds contains the given point.
      * @name contains
-     * @memberof me.Bounds
+     * @memberof Bounds
      * @function
-     * @param {me.Vector2d} point
+     * @param {Vector2d} point
      * @returns {boolean} True if the bounds contain the point, otherwise false
      */
     /**
      * Returns true if the bounds contains the given point.
      * @name contains
-     * @memberof me.Bounds
+     * @memberof Bounds
      * @function
      * @param {number} x
      * @param {number} y
@@ -339,9 +339,9 @@ class Bounds {
     /**
      * Returns true if the two bounds intersect.
      * @name overlaps
-     * @memberof me.Bounds
+     * @memberof Bounds
      * @function
-     * @param {me.Bounds|me.Rect} bounds
+     * @param {Bounds|Rect} bounds
      * @returns {boolean} True if the bounds overlap, otherwise false
      */
     overlaps(bounds) {
@@ -352,7 +352,7 @@ class Bounds {
     /**
      * determines whether all coordinates of this bounds are finite numbers.
      * @name isFinite
-     * @memberof me.Bounds
+     * @memberof Bounds
      * @function
      * @returns {boolean} false if all coordinates are positive or negative Infinity or NaN; otherwise, true.
      */
@@ -363,14 +363,14 @@ class Bounds {
     /**
      * Translates the bounds by the given vector.
      * @name translate
-     * @memberof me.Bounds
+     * @memberof Bounds
      * @function
-     * @param {me.Vector2d} vector
+     * @param {Vector2d} vector
      */
     /**
      * Translates the bounds by x on the x axis, and y on the y axis
      * @name translate
-     * @memberof me.Bounds
+     * @memberof Bounds
      * @function
      * @param {number} x
      * @param {number} y
@@ -395,14 +395,14 @@ class Bounds {
     /**
      * Shifts the bounds to the given position vector.
      * @name shift
-     * @memberof me.Bounds
+     * @memberof Bounds
      * @function
-     * @param {me.Vector2d} position
+     * @param {Vector2d} position
      */
     /**
      * Shifts the bounds to the given x, y position.
      * @name shift
-     * @memberof me.Bounds
+     * @memberof Bounds
      * @function
      * @param {number} x
      * @param {number} y
@@ -432,9 +432,9 @@ class Bounds {
     /**
      * clone this bounds
      * @name clone
-     * @memberof me.Bounds
+     * @memberof Bounds
      * @function
-     * @returns {me.Bounds}
+     * @returns {Bounds}
      */
     clone() {
         var bounds = new Bounds();
@@ -445,9 +445,9 @@ class Bounds {
     /**
      * Returns a polygon whose edges are the same as this bounds.
      * @name toPolygon
-     * @memberof me.Bounds
+     * @memberof Bounds
      * @function
-     * @returns {me.Polygon} a new Polygon that represents this bounds.
+     * @returns {Polygon} a new Polygon that represents this bounds.
      */
     toPolygon () {
         return new Polygon(this.x, this.y, [

package/src/physics/collision.js

@@ -4,7 +4,6 @@ import { rayCast, globalResponse } from "./detector.js";
  * Collision detection (and projection-based collision response) of 2D shapes.<br>
  * Based on the Separating Axis Theorem and supports detecting collisions between simple Axis-Aligned Boxes, convex polygons and circles based shapes.
  * @namespace collision
- * @memberof me
  */
 
 var collision = {
@@ -12,22 +11,22 @@ var collision = {
      /**
       * The maximum number of children that a quadtree node can contain before it is split into sub-nodes.
       * @name maxChildren
-      * @memberof me.collision
+      * @memberof collision
       * @public
       * @type {number}
       * @default 8
-      * @see me.game.world.broadphase
+      * @see game.world.broadphase
       */
      maxChildren : 8,
 
      /**
       * The maximum number of levels that the quadtree will create.
       * @name maxDepth
-      * @memberof me.collision
+      * @memberof collision
       * @public
       * @type {number}
       * @default 4
-      * @see me.game.world.broadphase
+      * @see game.world.broadphase
       */
      maxDepth : 4,
 
@@ -46,9 +45,9 @@ var collision = {
      * @readonly
      * @enum {number}
      * @name types
-     * @memberof me.collision
-     * @see me.body.setCollisionMask
-     * @see me.body.collisionType
+     * @memberof collision
+     * @see Body.setCollisionMask
+     * @see Body.collisionType
      * @example
      * // set the body collision type
      * myEntity.body.collisionType = me.collision.types.PLAYER_OBJECT;
@@ -97,21 +96,21 @@ var collision = {
      * a global instance of a response object used for collision detection <br>
      * this object will be reused amongst collision detection call if not user-defined response is specified
      * @name response
-     * @memberof me.collision
+     * @memberof collision
      * @public
-     * @type {me.collision.ResponseObject}
+     * @type {collision.ResponseObject}
      */
     response : globalResponse,
 
     /**
      * Checks for object colliding with the given line
      * @name rayCast
-     * @memberof me.collision
+     * @memberof collision
      * @public
      * @function
-     * @param {me.Line} line line to be tested for collision
-     * @param {Array.<me.Renderable>} [result] a user defined array that will be populated with intersecting physic objects.
-     * @returns {Array.<me.Renderable>} an array of intersecting physic objects
+     * @param {Line} line line to be tested for collision
+     * @param {Array.<Renderable>} [result] a user defined array that will be populated with intersecting physic objects.
+     * @returns {Array.<Renderable>} an array of intersecting physic objects
      * @example
      *    // define a line accross the viewport
      *    var ray = new me.Line(

package/src/physics/detector.js

@@ -17,17 +17,18 @@ var dummyObj = {
  * a function used to determine if two objects should collide (based on both respective objects collision mask and type).<br>
  * you can redefine this function if you need any specific rules over what should collide with what.
  * @name shouldCollide
- * @memberof me.collision
+ * @memberof collision
  * @ignore
  * @function
- * @param {me.Renderable} a a reference to the object A.
- * @param {me.Renderable} b a reference to the object B.
+ * @param {Renderable} a a reference to the object A.
+ * @param {Renderable} b a reference to the object B.
  * @returns {boolean} true if they should collide, false otherwise
  */
 function shouldCollide(a, b) {
     return (
         a.isKinematic !== true && b.isKinematic !== true &&
-        a.body && b.body &&
+        typeof a.body === "object" && typeof b.body === "object" &&
+        !(a.body.isStatic === true && b.body.isStatic === true) &&
         (a.body.collisionMask & b.body.collisionType) !== 0 &&
         (a.body.collisionType & b.body.collisionMask) !== 0
     );
@@ -36,17 +37,17 @@ function shouldCollide(a, b) {
 /**
  * @classdesc
  * An object representing the result of an intersection.
- * @property {me.Renderable} a The first object participating in the intersection
- * @property {me.Renderable} b The second object participating in the intersection
+ * @property {Renderable} a The first object participating in the intersection
+ * @property {Renderable} b The second object participating in the intersection
  * @property {number} overlap Magnitude of the overlap on the shortest colliding axis
- * @property {me.Vector2d} overlapV The overlap vector (i.e. `overlapN.scale(overlap, overlap)`). If this vector is subtracted from the position of a, a and b will no longer be colliding
- * @property {me.Vector2d} overlapN The shortest colliding axis (unit-vector)
+ * @property {Vector2d} overlapV The overlap vector (i.e. `overlapN.scale(overlap, overlap)`). If this vector is subtracted from the position of a, a and b will no longer be colliding
+ * @property {Vector2d} overlapN The shortest colliding axis (unit-vector)
  * @property {boolean} aInB Whether the first object is entirely inside the second
  * @property {boolean} bInA Whether the second object is entirely inside the first
  * @property {number} indexShapeA The index of the colliding shape for the object a body
  * @property {number} indexShapeB The index of the colliding shape for the object b body
  * @name ResponseObject
- * @memberof me.collision
+ * @memberof collision
  * @public
  */
 class ResponseObject {
@@ -68,7 +69,7 @@ class ResponseObject {
      * Response object for multiple intersection tests <br>
      * (recommended as it will avoid allocating extra memory) <br>
      * @name clear
-     * @memberof me.collision.ResponseObject
+     * @memberof collision.ResponseObject
      * @public
      * @function
      * @returns {object} this object for chaining
@@ -91,8 +92,8 @@ export var globalResponse = new ResponseObject();
  * @name collisionCheck
  * @ignore
  * @function
- * @param {me.Renderable} objA object to be tested for collision
- * @param {me.collision.ResponseObject} [response=me.collision.response] a user defined response object that will be populated if they intersect.
+ * @param {Renderable} objA object to be tested for collision
+ * @param {collision.ResponseObject} [response=collision.response] a user defined response object that will be populated if they intersect.
  * @returns {boolean} in case of collision, false otherwise
  */
 export function collisionCheck(objA, response = globalResponse) {
@@ -141,10 +142,10 @@ export function collisionCheck(objA, response = globalResponse) {
                         response.indexShapeB = indexB;
 
                         // execute the onCollision callback
-                        if (objA.onCollision && objA.onCollision(response, objB) !== false) {
+                        if (objA.onCollision && objA.onCollision(response, objB) !== false && objA.body.isStatic === false) {
                             objA.body.respondToCollision.call(objA.body, response);
                         }
-                        if (objB.onCollision && objB.onCollision(response, objA) !== false) {
+                        if (objB.onCollision && objB.onCollision(response, objA) !== false && objB.body.isStatic === false) {
                             objB.body.respondToCollision.call(objB.body, response);
                         }
                     }
@@ -163,9 +164,9 @@ export function collisionCheck(objA, response = globalResponse) {
  * @name rayCast
  * @ignore
  * @function
- * @param {me.Line} line line to be tested for collision
- * @param {Array.<me.Renderable>} [result] a user defined array that will be populated with intersecting physic objects.
- * @returns {Array.<me.Renderable>} an array of intersecting physic objects
+ * @param {Line} line line to be tested for collision
+ * @param {Array.<Renderable>} [result] a user defined array that will be populated with intersecting physic objects.
+ * @returns {Array.<Renderable>} an array of intersecting physic objects
  * @example
  *    // define a line accross the viewport
  *    var ray = new me.Line(

package/src/physics/quadtree.js

@@ -51,17 +51,15 @@ var QT_VECTOR = new Vector2d();
 /**
  * @classdesc
  * a QuadTree implementation in JavaScript, a 2d spatial subdivision algorithm.
- * @class
- * @name QuadTree
- * @memberof me
- * @see me.game.world.broadphase
- * @param {me.Bounds} bounds bounds of the node
- * @param {number} [max_objects=4] max objects a node can hold before splitting into 4 subnodes
- * @param {number} [max_levels=4] total max levels inside root Quadtree
- * @param {number} [level] deepth level, required for subnodes
+ * @see game.world.broadphase
  */
 class QuadTree {
-
+    /**
+     * @param {Bounds} bounds bounds of the node
+     * @param {number} [max_objects=4] max objects a node can hold before splitting into 4 subnodes
+     * @param {number} [max_levels=4] total max levels inside root Quadtree
+     * @param {number} [level] deepth level, required for subnodes
+     */
     constructor(bounds, max_objects = 4, max_levels = 4, level = 0) {
         this.max_objects = max_objects;
         this.max_levels  = max_levels;
@@ -118,7 +116,7 @@ class QuadTree {
 
     /*
      * Determine which node the object belongs to
-     * @param {me.Rect} rect bounds of the area to be checked
+     * @param {Rect} rect bounds of the area to be checked
      * @returns Integer index of the subnode (0-3), or -1 if rect cannot completely fit within a subnode and is part of the parent node
      */
     getIndex(item) {
@@ -166,9 +164,9 @@ class QuadTree {
     /**
      * Insert the given object container into the node.
      * @name insertContainer
-     * @memberof me.QuadTree
+     * @memberof QuadTree
      * @function
-     * @param {me.Container} container group of objects to be added
+     * @param {Container} container group of objects to be added
      */
     insertContainer(container) {
         for (var i = container.children.length, child; i--, (child = container.children[i]);) {
@@ -195,7 +193,7 @@ class QuadTree {
      * exceeds the capacity, it will split and add all
      * objects to their corresponding subnodes.
      * @name insert
-     * @memberof me.QuadTree
+     * @memberof QuadTree
      * @function
      * @param {object} item object to be added
      */
@@ -240,7 +238,7 @@ class QuadTree {
     /**
      * Return all objects that could collide with the given object
      * @name retrieve
-     * @memberof me.QuadTree
+     * @memberof QuadTree
      * @function
      * @param {object} item object to be checked against
      * @param {object} [fn] a sorting function for the returned array
@@ -276,7 +274,7 @@ class QuadTree {
      * Remove the given item from the quadtree.
      * (this function won't recalculate the impacted node)
      * @name remove
-     * @memberof me.QuadTree
+     * @memberof QuadTree
      * @function
      * @param {object} item object to be removed
      * @returns {boolean} true if the item was found and removed.
@@ -317,7 +315,7 @@ class QuadTree {
     /**
      * return true if the node is prunable
      * @name isPrunable
-     * @memberof me.QuadTree
+     * @memberof QuadTree
      * @function
      * @returns {boolean} true if the node is prunable
      */
@@ -328,7 +326,7 @@ class QuadTree {
     /**
      * return true if the node has any children
      * @name hasChildren
-     * @memberof me.QuadTree
+     * @memberof QuadTree
      * @function
      * @returns {boolean} true if the node has any children
      */
@@ -345,9 +343,9 @@ class QuadTree {
     /**
      * clear the quadtree
      * @name clear
-     * @memberof me.QuadTree
+     * @memberof QuadTree
      * @function
-     * @param {me.Bounds} [bounds=this.bounds] the bounds to be cleared
+     * @param {Bounds} [bounds=this.bounds] the bounds to be cleared
      */
     clear(bounds) {
         this.objects.length = 0;

package/src/physics/sat.js

@@ -26,7 +26,7 @@ var RIGHT_VORNOI_REGION = 1;
 
 /**
  * A pool of `Vector` objects that are used in calculations to avoid allocating memory.
- * @type {Array.<me.Vector2d>}
+ * @type {Array.<Vector2d>}
  * @ignore
  */
 var T_VECTORS = [];
@@ -46,8 +46,8 @@ for (var a = 0; a < 5; a++) { T_ARRAYS.push([]); }
  * resulting in a one dimensional range of the minimum and
  * maximum value on that axis.
  * @ignore
- * @param {Array.<me.Vector2d>} points The points to flatten.
- * @param {me.Vector2d} normal The unit vector axis to flatten on.
+ * @param {Array.<Vector2d>} points The points to flatten.
+ * @param {Vector2d} normal The unit vector axis to flatten on.
  * @param {Array.<number>} result An array.  After calling this function,
  *   result[0] will be the minimum value,
  *   result[1] will be the maximum value.
@@ -70,11 +70,11 @@ function flattenPointsOn(points, normal, result) {
  * Check whether two convex polygons are separated by the specified
  * axis (must be a unit vector).
  * @ignore
- * @param {me.Vector2d} aPos The position of the first polygon.
- * @param {me.Vector2d} bPos The position of the second polygon.
- * @param {Array.<me.Vector2d>} aPoints The points in the first polygon.
- * @param {Array.<me.Vector2d>} bPoints The points in the second polygon.
- * @param {me.Vector2d} axis The axis (unit sized) to test against.  The points of both polygons
+ * @param {Vector2d} aPos The position of the first polygon.
+ * @param {Vector2d} bPos The position of the second polygon.
+ * @param {Array.<Vector2d>} aPoints The points in the first polygon.
+ * @param {Array.<Vector2d>} bPoints The points in the second polygon.
+ * @param {Vector2d} axis The axis (unit sized) to test against.  The points of both polygons
  *   will be projected onto this axis.
  * @param {Response=} response A Response object (optional) which will be populated
  *   if the axis is not a separating axis.
@@ -161,8 +161,8 @@ function isSeparatingAxis(aPos, bPos, aPoints, bPoints, axis, response) {
  * </pre>
  *
  * @ignore
- * @param {me.Vector2d} line The line segment.
- * @param {me.Vector2d} point The point.
+ * @param {Vector2d} line The line segment.
+ * @param {Vector2d} point The point.
  * @returns  {number} LEFT_VORNOI_REGION (-1) if it is the left region,
  *          MIDDLE_VORNOI_REGION (0) if it is the middle region,
  *          RIGHT_VORNOI_REGION (1) if it is the right region.
@@ -187,10 +187,10 @@ function vornoiRegion(line, point) {
 /**
  * Checks whether polygons collide.
  * @ignore
- * @param {me.Renderable} a a reference to the object A.
- * @param {me.Polygon} polyA a reference to the object A Polygon to be tested
- * @param {me.Renderable} b a reference to the object B.
- * @param {me.Polygon} polyB a reference to the object B Polygon to be tested
+ * @param {Renderable} a a reference to the object A.
+ * @param {Polygon} polyA a reference to the object A Polygon to be tested
+ * @param {Renderable} b a reference to the object B.
+ * @param {Polygon} polyB a reference to the object B Polygon to be tested
  * @param {Response=} response Response object (optional) that will be populated if they intersect.
  * @returns {boolean} true if they intersect, false if they don't.
  */
@@ -241,10 +241,10 @@ export function testPolygonPolygon(a, polyA, b, polyB, response) {
 /**
  * Check if two Ellipse collide.
  * @ignore
- * @param {me.Renderable} a a reference to the object A.
- * @param {me.Ellipse} ellipseA a reference to the object A Ellipse to be tested
- * @param {me.Renderable} b a reference to the object B.
- * @param {me.Ellipse} ellipseB a reference to the object B Ellipse to be tested
+ * @param {Renderable} a a reference to the object A.
+ * @param {Ellipse} ellipseA a reference to the object A Ellipse to be tested
+ * @param {Renderable} b a reference to the object B.
+ * @param {Ellipse} ellipseB a reference to the object B Ellipse to be tested
  * @param {Response=} response Response object (optional) that will be populated if
  *   the circles intersect.
  * @returns {boolean} true if the circles intersect, false if they don't.
@@ -282,10 +282,10 @@ export function testEllipseEllipse(a, ellipseA, b, ellipseB, response) {
 /**
  * Check if a polygon and an ellipse collide.
  * @ignore
- * @param {me.Renderable} a a reference to the object A.
- * @param {me.Polygon} polyA a reference to the object A Polygon to be tested
- * @param {me.Renderable} b a reference to the object B.
- * @param {me.Ellipse} ellipseB a reference to the object B Ellipse to be tested
+ * @param {Renderable} a a reference to the object A.
+ * @param {Polygon} polyA a reference to the object A Polygon to be tested
+ * @param {Renderable} b a reference to the object B.
+ * @param {Ellipse} ellipseB a reference to the object B Ellipse to be tested
  * @param {Response=} response Response object (optional) that will be populated if they intersect.
  * @returns {boolean} true if they intersect, false if they don't.
  */
@@ -448,10 +448,10 @@ export function testPolygonEllipse(a, polyA, b, ellipseB, response) {
  * **NOTE:** This is slightly less efficient than testPolygonEllipse as it just
  * runs testPolygonEllipse and reverses the response at the end.
  * @ignore
- * @param {me.Renderable} a a reference to the object A.
- * @param {me.Ellipse} ellipseA a reference to the object A Ellipse to be tested
- * @param {me.Renderable} b a reference to the object B.
- * @param {me.Polygon} polyB a reference to the object B Polygon to be tested
+ * @param {Renderable} a a reference to the object A.
+ * @param {Ellipse} ellipseA a reference to the object A Ellipse to be tested
+ * @param {Renderable} b a reference to the object B.
+ * @param {Polygon} polyB a reference to the object B Polygon to be tested
  * @param {Response=} response Response object (optional) that will be populated if
  *   they intersect.
  * @returns {boolean} true if they intersect, false if they don't.