collider2d
Version:
A 2D collision checker for modern JavaScript games.
488 lines (411 loc) • 42.3 kB
JavaScript
'use strict';
Object.defineProperty(exports, "__esModule", {
value: true
});
exports["default"] = void 0;
var _vector = _interopRequireDefault(require("./vector"));
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
/**
* Represents a *convex* polygon with any number of points (specified in counter-clockwise order).
*
* Note: Do _not_ manually change the `points`, `angle`, or `offset` properties. Use the provided setters.
* Otherwise the calculated properties will not be updated correctly.
*
* The `pos` property can be changed directly.
*/
var Polygon = /*#__PURE__*/function () {
/**
* A vector representing the origin of this polygon (all other points are relative to this one).
*
* @private
*
* @property {Vector}
*/
/**
* An array of vectors representing the points in the polygon, in counter-clockwise order.
*
* @private
*
* @property {Array<Vector>}
*/
/**
* An Array of the points of this polygon as numbers instead of Vectors.
*
* @private
*
* @property {Array<number>}
*/
/**
* The angle of this polygon.
*
* @private
*
* @property {number}
*/
/**
* The offset of this polygon.
*
* @private
*
* @property {Vector}
*/
/**
* The calculated points of this polygon.
*
* @private
*
* @property {Array<Vector>}
*/
/**
* The edges of this polygon.
*
* @private
*
* @property {Array<Vector>}
*/
/**
* The normals of this polygon.
*
* @private
*
* @property {Array<Vector>}
*/
/**
* Create a new polygon, passing in a position vector, and an array of points (represented by vectors
* relative to the position vector). If no position is passed in, the position of the polygon will be `(0,0)`.
*
* @param {Vector} [position=Vector] A vector representing the origin of the polygon (all other points are relative to this one)
* @param {Array<Vector>} [points=[]] An array of vectors representing the points in the polygon, in counter-clockwise order.
*/
function Polygon() {
var position = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : new _vector["default"]();
var points = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
_classCallCheck(this, Polygon);
_defineProperty(this, "_position", new _vector["default"]());
_defineProperty(this, "_points", []);
_defineProperty(this, "_pointsGeneric", []);
_defineProperty(this, "_angle", 0);
_defineProperty(this, "_offset", new _vector["default"]());
_defineProperty(this, "_calcPoints", []);
_defineProperty(this, "_edges", []);
_defineProperty(this, "_normals", []);
this._position = position;
this.setPoints(points);
}
/**
* Returns the position of this polygon.
*
* @returns {Vector}
*/
_createClass(Polygon, [{
key: "position",
get: function get() {
return this._position;
}
/**
* **Note:** Not sure if this will be kept or not but for now it's disabled.
*
* Sets a new position for this polygon and recalculates the points.
*
* @param {Vector} position A Vector representing the new position of this polygon.
*/
// set position(position: Vector) {
// const diffX: number = -(this._position.x - position.x);
// const diffY: number = -(this._position.y - position.y);
// const diffPoint: Vector = new Vector(diffX, diffY);
// const points: Array<Vector> = [];
// this._points.map((point: Vector) => {
// const tempX: number = point.x;
// const tempY: number = point.y;
// const tempPoint: Vector = new Vector(tempX, tempY);
// const calculatedPoint: Vector = tempPoint.add(diffPoint);
// points.push(calculatedPoint);
// });
// this.setPoints(points, true);
// }
/**
* Returns the points of this polygon.
*
* @returns {Array<Vector>}
*/
}, {
key: "points",
get: function get() {
return this._points;
}
/**
* Returns the points of this polygon as numbers instead of Vectors.
*
* @returns {Array<number>}
*/
}, {
key: "pointsGeneric",
get: function get() {
return this._pointsGeneric;
}
/**
* Returns the calculated points of this polygon.
*
* @returns {Array<Vector>}
*/
}, {
key: "calcPoints",
get: function get() {
return this._calcPoints;
}
/**
* Returns the offset of this polygon.
*
* @returns {Vector}
*/
}, {
key: "offset",
get: function get() {
return this._offset;
}
/**
* Returns the angle of this polygon.
*
* @returns {number}
*/
}, {
key: "angle",
get: function get() {
return this._angle;
}
/**
* Returns the edges of this polygon.
*
* @returns {Array<Vector>}
*/
}, {
key: "edges",
get: function get() {
return this._edges;
}
/**
* Returns the normals of this polygon.
*
* @returns {Array<Vector>}
*/
}, {
key: "normals",
get: function get() {
return this._normals;
}
/**
* Set the points of the polygon. Any consecutive duplicate points will be combined.
*
* Note: The points are counter-clockwise *with respect to the coordinate system*. If you directly draw the points on a screen
* that has the origin at the top-left corner it will _appear_ visually that the points are being specified clockwise. This is
* just because of the inversion of the Y-axis when being displayed.
*
* @param {Array<Vector>} points An array of vectors representing the points in the polygon, in counter-clockwise order.
* *
* @returns {Polygon} Returns this for chaining.
*/
}, {
key: "setPoints",
value: function setPoints(points) {
// Only re-allocate if this is a new polygon or the number of points has changed.
var lengthChanged = !this.points || this.points.length !== points.length;
if (lengthChanged) {
var i;
var calcPoints = this._calcPoints = [];
var edges = this._edges = [];
var normals = this._normals = []; // Allocate the vector arrays for the calculated properties
for (i = 0; i < points.length; i++) {
// Remove consecutive duplicate points
var p1 = points[i];
var p2 = i < points.length - 1 ? points[i + 1] : points[0]; // Push the points to the generic points Array.
this._pointsGeneric.push(points[i].x, points[i].y);
if (p1 !== p2 && p1.x === p2.x && p1.y === p2.y) {
points.splice(i, 1);
i -= 1;
continue;
}
calcPoints.push(new _vector["default"]());
edges.push(new _vector["default"]());
normals.push(new _vector["default"]());
}
}
this._points = points;
this._recalc();
return this;
}
/**
* Set the current rotation angle of the polygon.
*
* @param {number} angle The current rotation angle (in radians).
*
* @returns {Polygon} Returns this for chaining.
*/
}, {
key: "setAngle",
value: function setAngle(angle) {
this._angle = angle;
this._recalc();
return this;
}
/**
* Set the current offset to apply to the `points` before applying the `angle` rotation.
*
* @param {Vector} offset The new offset Vector.
*
* @returns {Polygon} Returns this for chaining.
*/
}, {
key: "setOffset",
value: function setOffset(offset) {
this._offset = offset;
this._recalc();
return this;
}
/**
* Rotates this Polygon counter-clockwise around the origin of *its local coordinate system* (i.e. `position`).
*
* Note: This changes the **original** points (so any `angle` will be applied on top of this rotation).
*
* @param {number} angle The angle to rotate (in radians).
*
* @returns {Polygon} Returns this for chaining.
*/
}, {
key: "rotate",
value: function rotate(angle) {
var points = this.points;
var len = points.length;
for (var i = 0; i < len; i++) {
points[i].rotate(angle);
}
this._recalc();
return this;
}
/**
* Translates the points of this polygon by a specified amount relative to the origin of *its own coordinate system* (i.e. `position`).
*
* Note: This changes the **original** points (so any `offset` will be applied on top of this translation)
*
* @param {number} x The horizontal amount to translate.
* @param {number} y The vertical amount to translate.
*
* @returns {Polygon} Returns this for chaining.
*/
}, {
key: "translate",
value: function translate(x, y) {
var points = this.points;
var len = points.length;
for (var i = 0; i < len; i++) {
points[i].x += x;
points[i].y += y;
}
this._recalc();
return this;
}
/**
* Computes the calculated collision Polygon.
*
* This applies the `angle` and `offset` to the original points then recalculates the edges and normals of the collision Polygon.
*
* @private
*
* @returns {Polygon} Returns this for chaining.
*/
}, {
key: "_recalc",
value: function _recalc() {
// Calculated points - this is what is used for underlying collisions and takes into account
// the angle/offset set on the polygon.
var calcPoints = this.calcPoints; // The edges here are the direction of the `n`th edge of the polygon, relative to
// the `n`th point. If you want to draw a given edge from the edge value, you must
// first translate to the position of the starting point.
var edges = this._edges; // The normals here are the direction of the normal for the `n`th edge of the polygon, relative
// to the position of the `n`th point. If you want to draw an edge normal, you must first
// translate to the position of the starting point.
var normals = this._normals; // Copy the original points array and apply the offset/angle
var points = this.points;
var offset = this.offset;
var angle = this.angle;
var len = points.length;
var i;
for (i = 0; i < len; i++) {
var calcPoint = calcPoints[i].copy(points[i]);
calcPoint.x += offset.x;
calcPoint.y += offset.y;
if (angle !== 0) calcPoint.rotate(angle);
} // Calculate the edges/normals
for (i = 0; i < len; i++) {
var p1 = calcPoints[i];
var p2 = i < len - 1 ? calcPoints[i + 1] : calcPoints[0];
var e = edges[i].copy(p2).sub(p1);
normals[i].copy(e).perp().normalize();
}
return this;
}
/**
* Compute the axis-aligned bounding box.
*
* Any current state (translations/rotations) will be applied before constructing the AABB.
*
* Note: Returns a _new_ `Polygon` each time you call this.
*
* @returns {Polygon} Returns this for chaining.
*/
}, {
key: "getAABB",
value: function getAABB() {
var points = this.calcPoints;
var len = points.length;
var xMin = points[0].x;
var yMin = points[0].y;
var xMax = points[0].x;
var yMax = points[0].y;
for (var i = 1; i < len; i++) {
var point = points[i];
if (point["x"] < xMin) xMin = point["x"];else if (point["x"] > xMax) xMax = point["x"];
if (point["y"] < yMin) yMin = point["y"];else if (point["y"] > yMax) yMax = point["y"];
}
return new Polygon(this._position.clone().add(new _vector["default"](xMin, yMin)), [new _vector["default"](), new _vector["default"](xMax - xMin, 0), new _vector["default"](xMax - xMin, yMax - yMin), new _vector["default"](0, yMax - yMin)]);
}
/**
* Compute the centroid (geometric center) of the Polygon.
*
* Any current state (translations/rotations) will be applied before computing the centroid.
*
* See https://en.wikipedia.org/wiki/Centroid#Centroid_of_a_polygon
*
* Note: Returns a _new_ `Vector` each time you call this.
*
* @returns {Vector} Returns a Vector that contains the coordinates of the centroid.
*/
}, {
key: "getCentroid",
value: function getCentroid() {
var points = this.calcPoints;
var len = points.length;
var cx = 0;
var cy = 0;
var ar = 0;
for (var i = 0; i < len; i++) {
var p1 = points[i];
var p2 = i === len - 1 ? points[0] : points[i + 1]; // Loop around if last point
var a = p1["x"] * p2["y"] - p2["x"] * p1["y"];
cx += (p1["x"] + p2["x"]) * a;
cy += (p1["y"] + p2["y"]) * a;
ar += a;
}
ar = ar * 3; // we want 1 / 6 the area and we currently have 2*area
cx = cx / ar;
cy = cy / ar;
return new _vector["default"](cx, cy);
}
}]);
return Polygon;
}();
exports["default"] = Polygon;
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/geometry/polygon.ts"],"names":["Polygon","position","Vector","points","_position","setPoints","_points","_pointsGeneric","_calcPoints","_offset","_angle","_edges","_normals","lengthChanged","length","i","calcPoints","edges","normals","p1","p2","push","x","y","splice","_recalc","angle","offset","len","rotate","calcPoint","copy","e","sub","perp","normalize","xMin","yMin","xMax","yMax","point","clone","add","cx","cy","ar","a"],"mappings":"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","sourcesContent":["'use strict'\r\n\r\nimport Vector from './vector';\r\n\r\n/**\r\n * Represents a *convex* polygon with any number of points (specified in counter-clockwise order).\r\n * \r\n * Note: Do _not_ manually change the `points`, `angle`, or `offset` properties. Use the provided  setters. \r\n * Otherwise the calculated properties will not be updated correctly.\r\n * \r\n * The `pos` property can be changed directly.\r\n */\r\nexport default class Polygon {\r\n  /**\r\n   * A vector representing the origin of this polygon (all other points are relative to this one).\r\n   * \r\n   * @private\r\n   * \r\n   * @property {Vector}\r\n   */\r\n  private _position: Vector = new Vector();\r\n\r\n  /**\r\n   * An array of vectors representing the points in the polygon, in counter-clockwise order.\r\n   * \r\n   * @private\r\n   * \r\n   * @property {Array<Vector>}\r\n   */\r\n  private _points: Array<Vector> = [];\r\n\r\n  /**\r\n   * An Array of the points of this polygon as numbers instead of Vectors.\r\n   * \r\n   * @private\r\n   * \r\n   * @property {Array<number>}\r\n   */\r\n  private _pointsGeneric: Array<number> = []\r\n\r\n  /**\r\n   * The angle of this polygon.\r\n   * \r\n   * @private\r\n   * \r\n   * @property {number}\r\n   */\r\n  private _angle: number = 0;\r\n\r\n  /**\r\n   * The offset of this polygon.\r\n   * \r\n   * @private\r\n   * \r\n   * @property {Vector}\r\n   */\r\n  private _offset: Vector = new Vector();\r\n\r\n  /**\r\n   * The calculated points of this polygon.\r\n   * \r\n   * @private\r\n   * \r\n   * @property {Array<Vector>}\r\n   */\r\n  private _calcPoints: Array<Vector> = [];\r\n\r\n  /**\r\n   * The edges of this polygon.\r\n   * \r\n   * @private\r\n   * \r\n   * @property {Array<Vector>}\r\n   */\r\n  private _edges: Array<Vector> = [];\r\n\r\n  /**\r\n   * The normals of this polygon.\r\n   * \r\n   * @private\r\n   * \r\n   * @property {Array<Vector>}\r\n   */\r\n  private _normals: Array<Vector> = [];\r\n\r\n  /**\r\n   * Create a new polygon, passing in a position vector, and an array of points (represented by vectors \r\n   * relative to the position vector). If no position is passed in, the position of the polygon will be `(0,0)`.\r\n   * \r\n   * @param {Vector} [position=Vector] A vector representing the origin of the polygon (all other points are relative to this one)\r\n   * @param {Array<Vector>} [points=[]] An array of vectors representing the points in the polygon, in counter-clockwise order.\r\n   */\r\n  constructor(position: Vector = new Vector(), points: Array<Vector> = []) {\r\n    this._position = position;\r\n    this.setPoints(points);\r\n  }\r\n\r\n  /**\r\n   * Returns the position of this polygon.\r\n   * \r\n   * @returns {Vector}\r\n   */\r\n  get position(): Vector { return this._position; }\r\n\r\n  /**\r\n   * **Note:** Not sure if this will be kept or not but for now it's disabled.\r\n   * \r\n   * Sets a new position for this polygon and recalculates the points.\r\n   * \r\n   * @param {Vector} position A Vector representing the new position of this polygon.\r\n   */\r\n  // set position(position: Vector) {\r\n  //   const diffX: number = -(this._position.x - position.x);\r\n  //   const diffY: number = -(this._position.y - position.y);\r\n\r\n  //   const diffPoint: Vector = new Vector(diffX, diffY);\r\n\r\n  //   const points: Array<Vector> = [];\r\n\r\n  //   this._points.map((point: Vector) => {\r\n  //     const tempX: number = point.x;\r\n  //     const tempY: number = point.y;\r\n\r\n  //     const tempPoint: Vector = new Vector(tempX, tempY);\r\n\r\n  //     const calculatedPoint: Vector = tempPoint.add(diffPoint);\r\n\r\n  //     points.push(calculatedPoint);\r\n  //   });\r\n\r\n  //   this.setPoints(points, true);\r\n  // }\r\n\r\n  /**\r\n   * Returns the points of this polygon.\r\n   * \r\n   * @returns {Array<Vector>}\r\n   */\r\n  get points(): Array<Vector> { return this._points; }\r\n\r\n  /**\r\n   * Returns the points of this polygon as numbers instead of Vectors.\r\n   * \r\n   * @returns {Array<number>}\r\n   */\r\n  get pointsGeneric(): Array<number> { return this._pointsGeneric; }\r\n\r\n  /**\r\n   * Returns the calculated points of this polygon.\r\n   * \r\n   * @returns {Array<Vector>}\r\n   */\r\n  get calcPoints(): Array<Vector> { return this._calcPoints; }\r\n\r\n  /**\r\n   * Returns the offset of this polygon.\r\n   * \r\n   * @returns {Vector}\r\n   */\r\n  get offset(): Vector { return this._offset; }\r\n\r\n  /**\r\n   * Returns the angle of this polygon.\r\n   * \r\n   * @returns {number}\r\n   */\r\n  get angle(): number { return this._angle; }\r\n\r\n  /**\r\n   * Returns the edges of this polygon.\r\n   * \r\n   * @returns {Array<Vector>}\r\n   */\r\n  get edges(): Array<Vector> { return this._edges; }\r\n\r\n  /**\r\n   * Returns the normals of this polygon.\r\n   * \r\n   * @returns {Array<Vector>}\r\n   */\r\n  get normals(): Array<Vector> { return this._normals; }\r\n\r\n  /**\r\n   * Set the points of the polygon. Any consecutive duplicate points will be combined.\r\n   * \r\n   * Note: The points are counter-clockwise *with respect to the coordinate system*. If you directly draw the points on a screen \r\n   * that has the origin at the top-left corner it will _appear_ visually that the points are being specified clockwise. This is \r\n   * just because of the inversion of the Y-axis when being displayed.\r\n   * \r\n   * @param {Array<Vector>} points An array of vectors representing the points in the polygon, in counter-clockwise order.\r\n   *    * \r\n   * @returns {Polygon} Returns this for chaining.\r\n   */\r\n  setPoints(points: Array<Vector>): Polygon {\r\n    // Only re-allocate if this is a new polygon or the number of points has changed.\r\n    const lengthChanged: boolean = !this.points || this.points.length !== points.length;\r\n\r\n    if (lengthChanged) {\r\n      let i: number;\r\n\r\n      const calcPoints: Array<Vector> = this._calcPoints = [];\r\n      const edges: Array<Vector> = this._edges = [];\r\n      const normals: Array<Vector> = this._normals = [];\r\n\r\n      // Allocate the vector arrays for the calculated properties\r\n      for (i = 0; i < points.length; i++) {\r\n        // Remove consecutive duplicate points\r\n        const p1: Vector = points[i];\r\n        const p2: Vector = i < points.length - 1 ? points[i + 1] : points[0];\r\n\r\n        // Push the points to the generic points Array.\r\n        this._pointsGeneric.push(points[i].x, points[i].y);\r\n\r\n        if (p1 !== p2 && p1.x === p2.x && p1.y === p2.y) {\r\n          points.splice(i, 1);\r\n          i -= 1;\r\n          continue;\r\n        }\r\n\r\n        calcPoints.push(new Vector());\r\n        edges.push(new Vector());\r\n        normals.push(new Vector());\r\n      }\r\n    }\r\n\r\n    this._points = points;\r\n\r\n    this._recalc();\r\n\r\n    return this;\r\n  }\r\n\r\n  /**\r\n   * Set the current rotation angle of the polygon.\r\n   * \r\n   * @param {number} angle The current rotation angle (in radians).\r\n   * \r\n   * @returns {Polygon} Returns this for chaining.\r\n   */\r\n  setAngle(angle: number): Polygon {\r\n    this._angle = angle;\r\n\r\n    this._recalc();\r\n\r\n    return this;\r\n  }\r\n\r\n  /**\r\n   * Set the current offset to apply to the `points` before applying the `angle` rotation.\r\n   * \r\n   * @param {Vector} offset The new offset Vector.\r\n   * \r\n   * @returns {Polygon} Returns this for chaining.\r\n   */\r\n  setOffset(offset: Vector): Polygon {\r\n    this._offset = offset;\r\n\r\n    this._recalc();\r\n\r\n    return this;\r\n  }\r\n\r\n  /**\r\n   * Rotates this Polygon counter-clockwise around the origin of *its local coordinate system* (i.e. `position`).\r\n   * \r\n   * Note: This changes the **original** points (so any `angle` will be applied on top of this rotation).\r\n   * \r\n   * @param {number} angle The angle to rotate (in radians).\r\n   * \r\n   * @returns {Polygon} Returns this for chaining.\r\n   */\r\n  rotate(angle: number): Polygon {\r\n    const points: Array<Vector> = this.points;\r\n    const len: number = points.length;\r\n\r\n    for (let i = 0; i < len; i++) points[i].rotate(angle);\r\n\r\n    this._recalc();\r\n\r\n    return this;\r\n  }\r\n\r\n  /**\r\n   * Translates the points of this polygon by a specified amount relative to the origin of *its own coordinate system* (i.e. `position`).\r\n   * \r\n   * Note: This changes the **original** points (so any `offset` will be applied on top of this translation)\r\n   * \r\n   * @param {number} x The horizontal amount to translate.\r\n   * @param {number} y The vertical amount to translate.\r\n   * \r\n   * @returns {Polygon} Returns this for chaining.\r\n   */\r\n  translate(x: number, y: number): Polygon {\r\n    const points: Array<Vector> = this.points;\r\n    const len: number = points.length;\r\n\r\n    for (let i: number = 0; i < len; i++) {\r\n      points[i].x += x;\r\n      points[i].y += y;\r\n    }\r\n\r\n    this._recalc();\r\n\r\n    return this;\r\n  }\r\n\r\n  /**\r\n   * Computes the calculated collision Polygon.\r\n   * \r\n   * This applies the `angle` and `offset` to the original points then recalculates the edges and normals of the collision Polygon.\r\n   * \r\n   * @private\r\n   * \r\n   * @returns {Polygon} Returns this for chaining.\r\n   */\r\n  private _recalc(): Polygon {\r\n    // Calculated points - this is what is used for underlying collisions and takes into account\r\n    // the angle/offset set on the polygon.\r\n    const calcPoints: Array<Vector> = this.calcPoints;\r\n\r\n    // The edges here are the direction of the `n`th edge of the polygon, relative to\r\n    // the `n`th point. If you want to draw a given edge from the edge value, you must\r\n    // first translate to the position of the starting point.\r\n    const edges: Array<Vector> = this._edges;\r\n\r\n    // The normals here are the direction of the normal for the `n`th edge of the polygon, relative\r\n    // to the position of the `n`th point. If you want to draw an edge normal, you must first\r\n    // translate to the position of the starting point.\r\n    const normals: Array<Vector> = this._normals;\r\n\r\n    // Copy the original points array and apply the offset/angle\r\n    const points: Array<Vector> = this.points;\r\n    const offset: Vector = this.offset;\r\n    const angle: number = this.angle;\r\n\r\n    const len: number = points.length;\r\n    let i: number;\r\n\r\n    for (i = 0; i < len; i++) {\r\n      const calcPoint: Vector = calcPoints[i].copy(points[i]);\r\n\r\n      calcPoint.x += offset.x;\r\n      calcPoint.y += offset.y;\r\n\r\n      if (angle !== 0) calcPoint.rotate(angle);\r\n    }\r\n\r\n    // Calculate the edges/normals\r\n    for (i = 0; i < len; i++) {\r\n      const p1: Vector = calcPoints[i];\r\n      const p2: Vector = i < len - 1 ? calcPoints[i + 1] : calcPoints[0];\r\n\r\n      const e: Vector = edges[i].copy(p2).sub(p1);\r\n\r\n      normals[i].copy(e).perp().normalize();\r\n    }\r\n\r\n    return this;\r\n  }\r\n\r\n  /**\r\n   * Compute the axis-aligned bounding box.\r\n   * \r\n   * Any current state (translations/rotations) will be applied before constructing the AABB.\r\n   * \r\n   * Note: Returns a _new_ `Polygon` each time you call this.\r\n   * \r\n   * @returns {Polygon} Returns this for chaining.\r\n   */\r\n  getAABB(): Polygon {\r\n    const points: Array<Vector> = this.calcPoints;\r\n    const len: number = points.length;\r\n\r\n    let xMin: number = points[0].x;\r\n    let yMin: number = points[0].y;\r\n\r\n    let xMax: number = points[0].x;\r\n    let yMax: number = points[0].y;\r\n\r\n    for (let i: number = 1; i < len; i++) {\r\n      const point: Vector = points[i];\r\n\r\n      if (point[\"x\"] < xMin) xMin = point[\"x\"];\r\n      else if (point[\"x\"] > xMax) xMax = point[\"x\"];\r\n\r\n      if (point[\"y\"] < yMin) yMin = point[\"y\"];\r\n      else if (point[\"y\"] > yMax) yMax = point[\"y\"];\r\n\r\n    }\r\n\r\n    return new Polygon(this._position.clone().add(new Vector(xMin, yMin)), [\r\n      new Vector(), new Vector(xMax - xMin, 0),\r\n      new Vector(xMax - xMin, yMax - yMin), new Vector(0, yMax - yMin)\r\n    ]);\r\n  }\r\n\r\n  /**\r\n   * Compute the centroid (geometric center) of the Polygon.\r\n   * \r\n   * Any current state (translations/rotations) will be applied before computing the centroid.\r\n   * \r\n   * See https://en.wikipedia.org/wiki/Centroid#Centroid_of_a_polygon\r\n   * \r\n   * Note: Returns a _new_ `Vector` each time you call this.\r\n   * \r\n   * @returns {Vector} Returns a Vector that contains the coordinates of the centroid.\r\n   */\r\n  getCentroid(): Vector {\r\n    const points: Array<Vector> = this.calcPoints;\r\n    const len: number = points.length;\r\n\r\n    let cx: number = 0;\r\n    let cy: number = 0;\r\n    let ar: number = 0;\r\n\r\n    for (var i: number = 0; i < len; i++) {\r\n      const p1: Vector = points[i];\r\n      const p2: Vector = i === len - 1 ? points[0] : points[i + 1]; // Loop around if last point\r\n\r\n      const a: number = p1[\"x\"] * p2[\"y\"] - p2[\"x\"] * p1[\"y\"];\r\n\r\n      cx += (p1[\"x\"] + p2[\"x\"]) * a;\r\n      cy += (p1[\"y\"] + p2[\"y\"]) * a;\r\n      ar += a;\r\n    }\r\n\r\n    ar = ar * 3; // we want 1 / 6 the area and we currently have 2*area\r\n    cx = cx / ar;\r\n    cy = cy / ar;\r\n\r\n    return new Vector(cx, cy);\r\n  }\r\n}"]}