|
|
+ |
+
+
|
@@ -69,16 +73,18 @@
See how others are using matter.js physics
-- [Les métamorphoses de Mr. Kalia](http://lab212.org/Les-metamorphoses-de-Mr-Kalia) by Lab212 for Google
-- [4ify](http://pauliescanlon.io/4ify-channel-4-rebrand-2/) by Supernatural for Channel 4
-- [Adobe Analytics Live Stream](http://adobefirehose.mediarain.com/) by Rain for Adobe
-- [Blood Sweat & Tools Interactive](http://bloodsweatandtools.discovery.ca/gamebench/) by Jam3 for Discovery
-- [Oracle OpenWorld Experiment](http://theappslab.com/2016/10/10/how-i-attended-oracle-openworld-2016/) by Ed Jones for Oracle
-- [Pablo The Flamingo](http://pablotheflamingo.com/) by Nathan Gordon
-- [Goblins and Grottos](http://store.steampowered.com/app/389190) by Psychic Software
-- [masQueLaCara](https://www.instagram.com/p/BCFqCs6JNsq/) by Zach Lieberman for Art Blocks Houston
-- [#GIFMYLIVE](http://bonhommeparis.com/en/projects/arte-gifmylive) by Bonhomme for Arte
-- [Hype](http://tumult.com/hype/pro/) by Tumult
+- [Patrick Heng](https://patrickheng.com/) by Patrick Heng
+- [USELESS](https://useless.london/) by Nice and Serious
+- [Secret 7](https://secret-7.com/) by Goodness
+- [New Company](https://www.new.company/) by New Company
+- [Game of The Year](https://gameoftheyear.withgoogle.com/) by Google
+- [Pablo The Flamingo](https://pablotheflamingo.com/) by Nathan Gordon
+- [Les métamorphoses de Mr. Kalia](https://lab212.org/oeuvres/2:art/18/Les-metamorphoses-de-Mr-Kalia) by Lab212
+- [Phaser](https://phaser.io/) by Photon Storm
+- [Sorry I Have No Filter](https://sorryihavenofilter.com/pages/about/) by Jessica Walsh
+- [Fuse](https://fuse.blog/) by Fuse
+- [Glyphfinder](https://www.glyphfinder.com/) by überdosis
+- [Isolation](https://isolation.is/postcards/my-week) by sabato studio
- [more...](https://github.com/liabru/matter-js/wiki/Gallery)
### Features
@@ -111,15 +117,14 @@ See how others are using matter.js physics
### Install
-Download the [edge build (master)](https://github.com/liabru/matter-js/blob/master/build/matter.js) or get a [stable release](https://github.com/liabru/matter-js/releases) and include the script in your web page:
+You can install using package managers [npm](https://www.npmjs.org/package/matter-js) and [Yarn](https://yarnpkg.com/) using:
+
+ npm install matter-js
+
+Alternatively you can download a [stable release](https://github.com/liabru/matter-js/tags) or try the latest experimental [alpha build](https://github.com/liabru/matter-js/tree/master/build) (master) and include the script in your web page:
-You can also install using the package managers [Bower](http://bower.io/search/?q=matter-js) and [NPM](https://www.npmjs.org/package/matter-js).
-
- bower install matter-js
- npm install matter-js
-
### Usage
Visit the [Getting started](https://github.com/liabru/matter-js/wiki/Getting-started) wiki page for a minimal usage example which should work in both browsers and Node.js.
@@ -132,7 +137,7 @@ See the list of [tutorials](https://github.com/liabru/matter-js/wiki/Tutorials).
### Examples
See the [examples](https://github.com/liabru/matter-js/tree/master/examples) directory which contains the source for all [demos](#demos).
-There are even more examples on [codepen](http://codepen.io/collection/Fuagy/).
+There are even more examples on [codepen](https://codepen.io/collection/Fuagy/).
### Plugins
@@ -145,17 +150,17 @@ The engine can be extended through plugins, see these resources:
### Documentation
-See the [API Documentation](http://brm.io/matter-js/docs/) and the [wiki](https://github.com/liabru/matter-js/wiki)
+See the [API Documentation](https://brm.io/matter-js/docs/) and the [wiki](https://github.com/liabru/matter-js/wiki)
### Building and Contributing
-To build you must first install [node.js](http://nodejs.org/) and [gulp](http://gulpjs.com/), then run
+To build you must first install [node.js](https://nodejs.org/), then run
npm install
This will install the required build dependencies, then run
- gulp dev
+ npm run dev
to spawn a development server. For information on contributing see [CONTRIBUTING.md](https://github.com/liabru/matter-js/blob/master/CONTRIBUTING.md).
@@ -169,7 +174,7 @@ See the wiki page on [References](https://github.com/liabru/matter-js/wiki/Refer
### License
-Matter.js is licensed under [The MIT License (MIT)](http://opensource.org/licenses/MIT)
+Matter.js is licensed under [The MIT License (MIT)](https://opensource.org/licenses/MIT)
Copyright (c) 2014 Liam Brummitt
This license is also supplied with the release and source code.
diff --git a/RELEASE.md b/RELEASE.md
new file mode 100644
index 0000000..3ecfb0e
--- /dev/null
+++ b/RELEASE.md
@@ -0,0 +1,139 @@
+## ▲.● matter.js `0.17.0`
+
+Release notes for `0.17.0`. See the release [readme](https://github.com/liabru/matter-js/blob/0.17.0/README.md) for further information.
+
+### Highlights ✺
+
+- Added performance and stats monitoring overlays to `Matter.Render`
+ - See the [stats demo](https://brm.io/matter-js/demo/#stats) or enable [render.options.showPerformance](https://brm.io/matter-js/docs/classes/Render.html#property_options.showPerformance) and [render.options.showStats](https://brm.io/matter-js/docs/classes/Render.html#property_options.showStats)
+ - Stats shown include
+ - render frequency (e.g. `60 fps`)
+ - engine delta time (e.g. `16.66ms`)
+ - engine execution duration (e.g. `5.00ms`)
+ - render execution duration (e.g.` 0.40ms`)
+ - effective play speed (e.g. `1.00x` is real-time)
+ - various other engine internal stats for debugging
+- Improved [documentation](https://brm.io/matter-js/docs/) pages
+- Added [Common.setDecomp](https://brm.io/matter-js/docs/classes/Common.html#method_setDecomp) and [Common.getDecomp](https://brm.io/matter-js/docs/classes/Common.html#method_getDecomp) to fix [bundler issues](https://github.com/liabru/matter-js/issues/981)
+- Added docs for all [Matter.Render options](https://brm.io/matter-js/docs/classes/Render.html#properties)
+- Migrated usage of `Matter.World` over to `Matter.Composite` (more info in [docs](https://brm.io/matter-js/docs/classes/World.html))
+- Migrated, deprecated and removed various old functionality (see the [changelog](https://github.com/liabru/matter-js/blob/0.17.0/CHANGELOG.md) for details)
+
+### Changes ✲
+
+See the release [compare page](https://github.com/liabru/matter-js/compare/0.16.1...0.17.0) and the [changelog](https://github.com/liabru/matter-js/blob/0.17.0/CHANGELOG.md) for a detailed list of changes.
+
+### Comparison ⎄
+
+Differences in behaviour, quality and performance against the previous release `0.16.1`. For more information see [comparison method](https://github.com/liabru/matter-js/pull/794).
+
+```ocaml
+Output comparison of 37 examples against previous release matter-js@0.16.1
+
+Similarity 100% Performance +0.00% Overlap +0.00%
+
+airFriction · · avalanche · · ballPool · · bridge · · broadphase · · car · ·
+catapult · · chains · · circleStack · · cloth · · collisionFiltering · ·
+compound · · compoundStack · · constraints · · events · · friction · ·
+gyro · · manipulation · · mixed · · newtonsCradle · · pyramid · ·
+ragdoll · · restitution · · rounded · · sensors · · sleeping · ·
+slingshot · · softBody · · sprites · · stack · · staticFriction · ·
+stats · · stress · · stress2 · · timescale · · views · ·
+wreckingBall · ·
+where · no change ● extrinsics changed ◆ intrinsics changed
+
+```
+
+### Contributors ♥︎
+
+Many thanks to the [contributors](https://github.com/liabru/matter-js/compare/0.16.1...0.17.0) of this release, [past contributors](https://github.com/liabru/matter-js/graphs/contributors) as well those involved in the [community](https://github.com/liabru/matter-js/issues) for your input and support.
+
+---
+
+## ▲.● matter.js `0.16.0`
+
+Release notes for `0.16.0`. See the release [readme](https://github.com/liabru/matter-js/blob/0.16.0/README.md) for further information.
+
+### Highlights ✺
+
+- Changed external require method for `poly-decomp` ([882e07c](https://github.com/liabru/matter-js/commit/882e07c))
+- Improved `Bodies.fromVertices` decomposition quality using `removeDuplicatePoints` ([#639](https://github.com/liabru/matter-js/pull/639))
+- Added support for `>x.x.x` and `>=x.x.x` semver ranges in plugins ([0792716](https://github.com/liabru/matter-js/commit/0792716))
+- Changed demo example select background colour for Windows ([matter-tools #5](https://github.com/liabru/matter-tools/pull/5))
+- Updated demo to use latest [matter-tools](https://github.com/liabru/matter-tools) ([#33e8fe8](https://github.com/liabru/matter-js/commit/33e8fe8))
+- Updated SVG and terrain examples to use `fetch` ([5551cd5](https://github.com/liabru/matter-js/commit/5551cd5))
+
+### Changes ✲
+
+See the release [compare page](https://github.com/liabru/matter-js/compare/0.15.0...0.16.0) and the [changelog](https://github.com/liabru/matter-js/blob/0.16.0/CHANGELOG.md) for a detailed list of changes.
+
+### Comparison ⎄
+
+Differences in behaviour, quality and performance against the previous release `0.15.0`. For more information see [comparison method](https://github.com/liabru/matter-js/pull/794).
+
+```ocaml
+Output comparison of 41 examples against matter-js@0.15.0 build on last run
+
+Similarity 100% Performance +0.00% Overlap +0.00%
+
+airFriction · · avalanche · · ballPool · · bridge · · broadphase · · car · ·
+catapult · · chains · · circleStack · · cloth · · collisionFiltering · ·
+compositeManipulation · · compound · · compoundStack · · concave · · constraints · ·
+doublePendulum · · events · · friction · · gravity · · gyro · ·
+manipulation · · mixed · · newtonsCradle · · pyramid · · ragdoll · ·
+raycasting · · restitution · · rounded · · sensors · · sleeping · ·
+slingshot · · softBody · · sprites · · stack · · staticFriction · ·
+stress · · stress2 · · timescale · · views · · wreckingBall · ·
+
+where · no change ● extrinsics changed ◆ intrinsics changed
+
+```
+
+### Contributors ♥︎
+
+Many thanks to the [contributors](https://github.com/liabru/matter-js/compare/0.15.0...0.16.0) of this release, [past contributors](https://github.com/liabru/matter-js/graphs/contributors) as well those involved in the [community](https://github.com/liabru/matter-js/issues) for your input and support.
+
+---
+
+## ▲.● matter.js `0.15.0`
+
+Release notes for `0.15.0`. See the release [readme](https://github.com/liabru/matter-js/blob/0.15.0/README.md) for further information.
+
+### Highlights ✺
+
+- __Optimised performance up to ~30% boost vs. `0.14.2`__ ([#528](https://github.com/liabru/matter-js/pull/528)) ([#522](https://github.com/liabru/matter-js/pull/522)) ([#553](https://github.com/liabru/matter-js/pull/553))
+- Added `Body.setCentre` ([2ec247b](https://github.com/liabru/matter-js/commit/2ec247b))
+- Added `Constraint.pointAWorld` and `Constraint.pointBWorld` ([3c32969](https://github.com/liabru/matter-js/commit/3c32969))
+- Changed default colour scheme ([d258411](https://github.com/liabru/matter-js/commit/d258411)) ([6dd5ec5](https://github.com/liabru/matter-js/commit/6dd5ec5))
+- Fixed issues with decomp require ([0af1645](https://github.com/liabru/matter-js/commit/0af1645))
+- Fixed issues with render pixel ratio ([d577477](https://github.com/liabru/matter-js/commit/d577477))
+
+### Changes ✲
+
+See the release [compare page](https://github.com/liabru/matter-js/compare/0.14.2...0.15.0) and the [changelog](https://github.com/liabru/matter-js/blob/0.15.0/CHANGELOG.md) for a detailed list of all changes.
+
+### Comparison ⎄
+
+Differences in behaviour, quality and performance against the previous release `0.14.2`. For more information see [comparison method](https://github.com/liabru/matter-js/pull/794).
+
+```ocaml
+Output comparison of 41 examples against matter-js@0.14.2 build on last run
+
+Similarity 100% Performance +33.6% Overlap +0.00%
+
+airFriction · · avalanche · · ballPool · · bridge · · broadphase · · car · ·
+catapult · · chains · · circleStack · · cloth · · collisionFiltering · ·
+compositeManipulation · · compound · · compoundStack · · concave · · constraints · ·
+doublePendulum · · events · · friction · · gravity · · gyro · ·
+manipulation · · mixed · · newtonsCradle · · pyramid · · ragdoll · ·
+raycasting · · restitution · · rounded · · sensors · · sleeping · ·
+slingshot · · softBody · · sprites · · stack · · staticFriction · ·
+stress · · stress2 · · timescale · · views · · wreckingBall · ·
+
+where · no change ● extrinsics changed ◆ intrinsics changed
+
+```
+
+### Contributors ♥︎
+
+Many thanks to the [contributors](https://github.com/liabru/matter-js/compare/0.14.2...0.15.0) of this release, [past contributors](https://github.com/liabru/matter-js/graphs/contributors) as well those involved in the [community](https://github.com/liabru/matter-js/issues) for your input and support.
diff --git a/bower.json b/bower.json
deleted file mode 100644
index 1782d51..0000000
--- a/bower.json
+++ /dev/null
@@ -1,27 +0,0 @@
-{
- "name": "Matter",
- "version": "0.14.2",
- "homepage": "https://github.com/liabru/matter-js",
- "authors": [
- "Liam Brummitt (http://brm.io/)"
- ],
- "description": "a 2D rigid body physics engine for the web",
- "main": "build/matter.js",
- "keywords": [
- "javascript",
- "canvas",
- "html5",
- "physics",
- "physics engine",
- "game engine",
- "rigid body physics"
- ],
- "license": "MIT",
- "ignore": [
- "**/.*",
- "node_modules",
- "bower_components",
- "test",
- "tests"
- ]
-}
diff --git a/build/matter.js b/build/matter.js
index b36c3f5..b44b5db 100644
--- a/build/matter.js
+++ b/build/matter.js
@@ -1,10 +1,8 @@
-/**
-* matter-js 0.14.2 by @liabru 2018-06-11
-* http://brm.io/matter-js/
-* License MIT
-*/
-
-/**
+/*!
+ * matter-js 0.17.1 by @liabru
+ * http://brm.io/matter-js/
+ * License MIT
+ *
* The MIT License (MIT)
*
* Copyright (c) Liam Brummitt and contributors.
@@ -27,8 +25,2357 @@
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
+(function webpackUniversalModuleDefinition(root, factory) {
+ if(typeof exports === 'object' && typeof module === 'object')
+ module.exports = factory();
+ else if(typeof define === 'function' && define.amd)
+ define("Matter", [], factory);
+ else if(typeof exports === 'object')
+ exports["Matter"] = factory();
+ else
+ root["Matter"] = factory();
+})(this, function() {
+return /******/ (function(modules) { // webpackBootstrap
+/******/ // The module cache
+/******/ var installedModules = {};
+/******/
+/******/ // The require function
+/******/ function __webpack_require__(moduleId) {
+/******/
+/******/ // Check if module is in cache
+/******/ if(installedModules[moduleId]) {
+/******/ return installedModules[moduleId].exports;
+/******/ }
+/******/ // Create a new module (and put it into the cache)
+/******/ var module = installedModules[moduleId] = {
+/******/ i: moduleId,
+/******/ l: false,
+/******/ exports: {}
+/******/ };
+/******/
+/******/ // Execute the module function
+/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
+/******/
+/******/ // Flag the module as loaded
+/******/ module.l = true;
+/******/
+/******/ // Return the exports of the module
+/******/ return module.exports;
+/******/ }
+/******/
+/******/
+/******/ // expose the modules object (__webpack_modules__)
+/******/ __webpack_require__.m = modules;
+/******/
+/******/ // expose the module cache
+/******/ __webpack_require__.c = installedModules;
+/******/
+/******/ // define getter function for harmony exports
+/******/ __webpack_require__.d = function(exports, name, getter) {
+/******/ if(!__webpack_require__.o(exports, name)) {
+/******/ Object.defineProperty(exports, name, { enumerable: true, get: getter });
+/******/ }
+/******/ };
+/******/
+/******/ // define __esModule on exports
+/******/ __webpack_require__.r = function(exports) {
+/******/ if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
+/******/ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+/******/ }
+/******/ Object.defineProperty(exports, '__esModule', { value: true });
+/******/ };
+/******/
+/******/ // create a fake namespace object
+/******/ // mode & 1: value is a module id, require it
+/******/ // mode & 2: merge all properties of value into the ns
+/******/ // mode & 4: return value when already ns object
+/******/ // mode & 8|1: behave like require
+/******/ __webpack_require__.t = function(value, mode) {
+/******/ if(mode & 1) value = __webpack_require__(value);
+/******/ if(mode & 8) return value;
+/******/ if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;
+/******/ var ns = Object.create(null);
+/******/ __webpack_require__.r(ns);
+/******/ Object.defineProperty(ns, 'default', { enumerable: true, value: value });
+/******/ if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));
+/******/ return ns;
+/******/ };
+/******/
+/******/ // getDefaultExport function for compatibility with non-harmony modules
+/******/ __webpack_require__.n = function(module) {
+/******/ var getter = module && module.__esModule ?
+/******/ function getDefault() { return module['default']; } :
+/******/ function getModuleExports() { return module; };
+/******/ __webpack_require__.d(getter, 'a', getter);
+/******/ return getter;
+/******/ };
+/******/
+/******/ // Object.prototype.hasOwnProperty.call
+/******/ __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
+/******/
+/******/ // __webpack_public_path__
+/******/ __webpack_require__.p = "";
+/******/
+/******/
+/******/ // Load entry module and return exports
+/******/ return __webpack_require__(__webpack_require__.s = 22);
+/******/ })
+/************************************************************************/
+/******/ ([
+/* 0 */
+/***/ (function(module, exports) {
+
+/**
+* The `Matter.Common` module contains utility functions that are common to all modules.
+*
+* @class Common
+*/
+
+var Common = {};
+
+module.exports = Common;
+
+(function() {
+
+ Common._nextId = 0;
+ Common._seed = 0;
+ Common._nowStartTime = +(new Date());
+ Common._warnedOnce = {};
+ Common._decomp = null;
+
+ /**
+ * Extends the object in the first argument using the object in the second argument.
+ * @method extend
+ * @param {} obj
+ * @param {boolean} deep
+ * @return {} obj extended
+ */
+ Common.extend = function(obj, deep) {
+ var argsStart,
+ args,
+ deepClone;
+
+ if (typeof deep === 'boolean') {
+ argsStart = 2;
+ deepClone = deep;
+ } else {
+ argsStart = 1;
+ deepClone = true;
+ }
+
+ for (var i = argsStart; i < arguments.length; i++) {
+ var source = arguments[i];
+
+ if (source) {
+ for (var prop in source) {
+ if (deepClone && source[prop] && source[prop].constructor === Object) {
+ if (!obj[prop] || obj[prop].constructor === Object) {
+ obj[prop] = obj[prop] || {};
+ Common.extend(obj[prop], deepClone, source[prop]);
+ } else {
+ obj[prop] = source[prop];
+ }
+ } else {
+ obj[prop] = source[prop];
+ }
+ }
+ }
+ }
+
+ return obj;
+ };
+
+ /**
+ * Creates a new clone of the object, if deep is true references will also be cloned.
+ * @method clone
+ * @param {} obj
+ * @param {bool} deep
+ * @return {} obj cloned
+ */
+ Common.clone = function(obj, deep) {
+ return Common.extend({}, deep, obj);
+ };
+
+ /**
+ * Returns the list of keys for the given object.
+ * @method keys
+ * @param {} obj
+ * @return {string[]} keys
+ */
+ Common.keys = function(obj) {
+ if (Object.keys)
+ return Object.keys(obj);
+
+ // avoid hasOwnProperty for performance
+ var keys = [];
+ for (var key in obj)
+ keys.push(key);
+ return keys;
+ };
+
+ /**
+ * Returns the list of values for the given object.
+ * @method values
+ * @param {} obj
+ * @return {array} Array of the objects property values
+ */
+ Common.values = function(obj) {
+ var values = [];
+
+ if (Object.keys) {
+ var keys = Object.keys(obj);
+ for (var i = 0; i < keys.length; i++) {
+ values.push(obj[keys[i]]);
+ }
+ return values;
+ }
+
+ // avoid hasOwnProperty for performance
+ for (var key in obj)
+ values.push(obj[key]);
+ return values;
+ };
+
+ /**
+ * Gets a value from `base` relative to the `path` string.
+ * @method get
+ * @param {} obj The base object
+ * @param {string} path The path relative to `base`, e.g. 'Foo.Bar.baz'
+ * @param {number} [begin] Path slice begin
+ * @param {number} [end] Path slice end
+ * @return {} The object at the given path
+ */
+ Common.get = function(obj, path, begin, end) {
+ path = path.split('.').slice(begin, end);
+
+ for (var i = 0; i < path.length; i += 1) {
+ obj = obj[path[i]];
+ }
+
+ return obj;
+ };
+
+ /**
+ * Sets a value on `base` relative to the given `path` string.
+ * @method set
+ * @param {} obj The base object
+ * @param {string} path The path relative to `base`, e.g. 'Foo.Bar.baz'
+ * @param {} val The value to set
+ * @param {number} [begin] Path slice begin
+ * @param {number} [end] Path slice end
+ * @return {} Pass through `val` for chaining
+ */
+ Common.set = function(obj, path, val, begin, end) {
+ var parts = path.split('.').slice(begin, end);
+ Common.get(obj, path, 0, -1)[parts[parts.length - 1]] = val;
+ return val;
+ };
+
+ /**
+ * Shuffles the given array in-place.
+ * The function uses a seeded random generator.
+ * @method shuffle
+ * @param {array} array
+ * @return {array} array shuffled randomly
+ */
+ Common.shuffle = function(array) {
+ for (var i = array.length - 1; i > 0; i--) {
+ var j = Math.floor(Common.random() * (i + 1));
+ var temp = array[i];
+ array[i] = array[j];
+ array[j] = temp;
+ }
+ return array;
+ };
+
+ /**
+ * Randomly chooses a value from a list with equal probability.
+ * The function uses a seeded random generator.
+ * @method choose
+ * @param {array} choices
+ * @return {object} A random choice object from the array
+ */
+ Common.choose = function(choices) {
+ return choices[Math.floor(Common.random() * choices.length)];
+ };
+
+ /**
+ * Returns true if the object is a HTMLElement, otherwise false.
+ * @method isElement
+ * @param {object} obj
+ * @return {boolean} True if the object is a HTMLElement, otherwise false
+ */
+ Common.isElement = function(obj) {
+ if (typeof HTMLElement !== 'undefined') {
+ return obj instanceof HTMLElement;
+ }
+
+ return !!(obj && obj.nodeType && obj.nodeName);
+ };
+
+ /**
+ * Returns true if the object is an array.
+ * @method isArray
+ * @param {object} obj
+ * @return {boolean} True if the object is an array, otherwise false
+ */
+ Common.isArray = function(obj) {
+ return Object.prototype.toString.call(obj) === '[object Array]';
+ };
+
+ /**
+ * Returns true if the object is a function.
+ * @method isFunction
+ * @param {object} obj
+ * @return {boolean} True if the object is a function, otherwise false
+ */
+ Common.isFunction = function(obj) {
+ return typeof obj === "function";
+ };
+
+ /**
+ * Returns true if the object is a plain object.
+ * @method isPlainObject
+ * @param {object} obj
+ * @return {boolean} True if the object is a plain object, otherwise false
+ */
+ Common.isPlainObject = function(obj) {
+ return typeof obj === 'object' && obj.constructor === Object;
+ };
+
+ /**
+ * Returns true if the object is a string.
+ * @method isString
+ * @param {object} obj
+ * @return {boolean} True if the object is a string, otherwise false
+ */
+ Common.isString = function(obj) {
+ return toString.call(obj) === '[object String]';
+ };
+
+ /**
+ * Returns the given value clamped between a minimum and maximum value.
+ * @method clamp
+ * @param {number} value
+ * @param {number} min
+ * @param {number} max
+ * @return {number} The value clamped between min and max inclusive
+ */
+ Common.clamp = function(value, min, max) {
+ if (value < min)
+ return min;
+ if (value > max)
+ return max;
+ return value;
+ };
+
+ /**
+ * Returns the sign of the given value.
+ * @method sign
+ * @param {number} value
+ * @return {number} -1 if negative, +1 if 0 or positive
+ */
+ Common.sign = function(value) {
+ return value < 0 ? -1 : 1;
+ };
+
+ /**
+ * Returns the current timestamp since the time origin (e.g. from page load).
+ * The result is in milliseconds and will use high-resolution timing if available.
+ * @method now
+ * @return {number} the current timestamp in milliseconds
+ */
+ Common.now = function() {
+ if (typeof window !== 'undefined' && window.performance) {
+ if (window.performance.now) {
+ return window.performance.now();
+ } else if (window.performance.webkitNow) {
+ return window.performance.webkitNow();
+ }
+ }
+
+ if (Date.now) {
+ return Date.now();
+ }
+
+ return (new Date()) - Common._nowStartTime;
+ };
+
+ /**
+ * Returns a random value between a minimum and a maximum value inclusive.
+ * The function uses a seeded random generator.
+ * @method random
+ * @param {number} min
+ * @param {number} max
+ * @return {number} A random number between min and max inclusive
+ */
+ Common.random = function(min, max) {
+ min = (typeof min !== "undefined") ? min : 0;
+ max = (typeof max !== "undefined") ? max : 1;
+ return min + _seededRandom() * (max - min);
+ };
+
+ var _seededRandom = function() {
+ // https://en.wikipedia.org/wiki/Linear_congruential_generator
+ Common._seed = (Common._seed * 9301 + 49297) % 233280;
+ return Common._seed / 233280;
+ };
+
+ /**
+ * Converts a CSS hex colour string into an integer.
+ * @method colorToNumber
+ * @param {string} colorString
+ * @return {number} An integer representing the CSS hex string
+ */
+ Common.colorToNumber = function(colorString) {
+ colorString = colorString.replace('#','');
+
+ if (colorString.length == 3) {
+ colorString = colorString.charAt(0) + colorString.charAt(0)
+ + colorString.charAt(1) + colorString.charAt(1)
+ + colorString.charAt(2) + colorString.charAt(2);
+ }
+
+ return parseInt(colorString, 16);
+ };
+
+ /**
+ * The console logging level to use, where each level includes all levels above and excludes the levels below.
+ * The default level is 'debug' which shows all console messages.
+ *
+ * Possible level values are:
+ * - 0 = None
+ * - 1 = Debug
+ * - 2 = Info
+ * - 3 = Warn
+ * - 4 = Error
+ * @property Common.logLevel
+ * @type {Number}
+ * @default 1
+ */
+ Common.logLevel = 1;
+
+ /**
+ * Shows a `console.log` message only if the current `Common.logLevel` allows it.
+ * The message will be prefixed with 'matter-js' to make it easily identifiable.
+ * @method log
+ * @param ...objs {} The objects to log.
+ */
+ Common.log = function() {
+ if (console && Common.logLevel > 0 && Common.logLevel <= 3) {
+ console.log.apply(console, ['matter-js:'].concat(Array.prototype.slice.call(arguments)));
+ }
+ };
+
+ /**
+ * Shows a `console.info` message only if the current `Common.logLevel` allows it.
+ * The message will be prefixed with 'matter-js' to make it easily identifiable.
+ * @method info
+ * @param ...objs {} The objects to log.
+ */
+ Common.info = function() {
+ if (console && Common.logLevel > 0 && Common.logLevel <= 2) {
+ console.info.apply(console, ['matter-js:'].concat(Array.prototype.slice.call(arguments)));
+ }
+ };
+
+ /**
+ * Shows a `console.warn` message only if the current `Common.logLevel` allows it.
+ * The message will be prefixed with 'matter-js' to make it easily identifiable.
+ * @method warn
+ * @param ...objs {} The objects to log.
+ */
+ Common.warn = function() {
+ if (console && Common.logLevel > 0 && Common.logLevel <= 3) {
+ console.warn.apply(console, ['matter-js:'].concat(Array.prototype.slice.call(arguments)));
+ }
+ };
+
+ /**
+ * Uses `Common.warn` to log the given message one time only.
+ * @method warnOnce
+ * @param ...objs {} The objects to log.
+ */
+ Common.warnOnce = function() {
+ var message = Array.prototype.slice.call(arguments).join(' ');
+
+ if (!Common._warnedOnce[message]) {
+ Common.warn(message);
+ Common._warnedOnce[message] = true;
+ }
+ };
+
+ /**
+ * Shows a deprecated console warning when the function on the given object is called.
+ * The target function will be replaced with a new function that first shows the warning
+ * and then calls the original function.
+ * @method deprecated
+ * @param {object} obj The object or module
+ * @param {string} name The property name of the function on obj
+ * @param {string} warning The one-time message to show if the function is called
+ */
+ Common.deprecated = function(obj, prop, warning) {
+ obj[prop] = Common.chain(function() {
+ Common.warnOnce('🔅 deprecated 🔅', warning);
+ }, obj[prop]);
+ };
+
+ /**
+ * Returns the next unique sequential ID.
+ * @method nextId
+ * @return {Number} Unique sequential ID
+ */
+ Common.nextId = function() {
+ return Common._nextId++;
+ };
+
+ /**
+ * A cross browser compatible indexOf implementation.
+ * @method indexOf
+ * @param {array} haystack
+ * @param {object} needle
+ * @return {number} The position of needle in haystack, otherwise -1.
+ */
+ Common.indexOf = function(haystack, needle) {
+ if (haystack.indexOf)
+ return haystack.indexOf(needle);
+
+ for (var i = 0; i < haystack.length; i++) {
+ if (haystack[i] === needle)
+ return i;
+ }
+
+ return -1;
+ };
+
+ /**
+ * A cross browser compatible array map implementation.
+ * @method map
+ * @param {array} list
+ * @param {function} func
+ * @return {array} Values from list transformed by func.
+ */
+ Common.map = function(list, func) {
+ if (list.map) {
+ return list.map(func);
+ }
+
+ var mapped = [];
+
+ for (var i = 0; i < list.length; i += 1) {
+ mapped.push(func(list[i]));
+ }
+
+ return mapped;
+ };
+
+ /**
+ * Takes a directed graph and returns the partially ordered set of vertices in topological order.
+ * Circular dependencies are allowed.
+ * @method topologicalSort
+ * @param {object} graph
+ * @return {array} Partially ordered set of vertices in topological order.
+ */
+ Common.topologicalSort = function(graph) {
+ // https://github.com/mgechev/javascript-algorithms
+ // Copyright (c) Minko Gechev (MIT license)
+ // Modifications: tidy formatting and naming
+ var result = [],
+ visited = [],
+ temp = [];
+
+ for (var node in graph) {
+ if (!visited[node] && !temp[node]) {
+ Common._topologicalSort(node, visited, temp, graph, result);
+ }
+ }
+
+ return result;
+ };
+
+ Common._topologicalSort = function(node, visited, temp, graph, result) {
+ var neighbors = graph[node] || [];
+ temp[node] = true;
+
+ for (var i = 0; i < neighbors.length; i += 1) {
+ var neighbor = neighbors[i];
+
+ if (temp[neighbor]) {
+ // skip circular dependencies
+ continue;
+ }
+
+ if (!visited[neighbor]) {
+ Common._topologicalSort(neighbor, visited, temp, graph, result);
+ }
+ }
+
+ temp[node] = false;
+ visited[node] = true;
+
+ result.push(node);
+ };
+
+ /**
+ * Takes _n_ functions as arguments and returns a new function that calls them in order.
+ * The arguments applied when calling the new function will also be applied to every function passed.
+ * The value of `this` refers to the last value returned in the chain that was not `undefined`.
+ * Therefore if a passed function does not return a value, the previously returned value is maintained.
+ * After all passed functions have been called the new function returns the last returned value (if any).
+ * If any of the passed functions are a chain, then the chain will be flattened.
+ * @method chain
+ * @param ...funcs {function} The functions to chain.
+ * @return {function} A new function that calls the passed functions in order.
+ */
+ Common.chain = function() {
+ var funcs = [];
+
+ for (var i = 0; i < arguments.length; i += 1) {
+ var func = arguments[i];
+
+ if (func._chained) {
+ // flatten already chained functions
+ funcs.push.apply(funcs, func._chained);
+ } else {
+ funcs.push(func);
+ }
+ }
+
+ var chain = function() {
+ // https://github.com/GoogleChrome/devtools-docs/issues/53#issuecomment-51941358
+ var lastResult,
+ args = new Array(arguments.length);
+
+ for (var i = 0, l = arguments.length; i < l; i++) {
+ args[i] = arguments[i];
+ }
+
+ for (i = 0; i < funcs.length; i += 1) {
+ var result = funcs[i].apply(lastResult, args);
+
+ if (typeof result !== 'undefined') {
+ lastResult = result;
+ }
+ }
+
+ return lastResult;
+ };
+
+ chain._chained = funcs;
+
+ return chain;
+ };
+
+ /**
+ * Chains a function to excute before the original function on the given `path` relative to `base`.
+ * See also docs for `Common.chain`.
+ * @method chainPathBefore
+ * @param {} base The base object
+ * @param {string} path The path relative to `base`
+ * @param {function} func The function to chain before the original
+ * @return {function} The chained function that replaced the original
+ */
+ Common.chainPathBefore = function(base, path, func) {
+ return Common.set(base, path, Common.chain(
+ func,
+ Common.get(base, path)
+ ));
+ };
+
+ /**
+ * Chains a function to excute after the original function on the given `path` relative to `base`.
+ * See also docs for `Common.chain`.
+ * @method chainPathAfter
+ * @param {} base The base object
+ * @param {string} path The path relative to `base`
+ * @param {function} func The function to chain after the original
+ * @return {function} The chained function that replaced the original
+ */
+ Common.chainPathAfter = function(base, path, func) {
+ return Common.set(base, path, Common.chain(
+ Common.get(base, path),
+ func
+ ));
+ };
+
+ /**
+ * Provide the [poly-decomp](https://github.com/schteppe/poly-decomp.js) library module to enable
+ * concave vertex decomposition support when using `Bodies.fromVertices` e.g. `Common.setDecomp(require('poly-decomp'))`.
+ * @method setDecomp
+ * @param {} decomp The [poly-decomp](https://github.com/schteppe/poly-decomp.js) library module.
+ */
+ Common.setDecomp = function(decomp) {
+ Common._decomp = decomp;
+ };
+
+ /**
+ * Returns the [poly-decomp](https://github.com/schteppe/poly-decomp.js) library module provided through `Common.setDecomp`,
+ * otherwise returns the global `decomp` if set.
+ * @method getDecomp
+ * @return {} The [poly-decomp](https://github.com/schteppe/poly-decomp.js) library module if provided.
+ */
+ Common.getDecomp = function() {
+ // get user provided decomp if set
+ var decomp = Common._decomp;
+
+ try {
+ // otherwise from window global
+ if (!decomp && typeof window !== 'undefined') {
+ decomp = window.decomp;
+ }
+
+ // otherwise from node global
+ if (!decomp && typeof global !== 'undefined') {
+ decomp = global.decomp;
+ }
+ } catch (e) {
+ // decomp not available
+ decomp = null;
+ }
+
+ return decomp;
+ };
+})();
+
+
+/***/ }),
+/* 1 */
+/***/ (function(module, exports) {
+
+/**
+* The `Matter.Bounds` module contains methods for creating and manipulating axis-aligned bounding boxes (AABB).
+*
+* @class Bounds
+*/
+
+var Bounds = {};
+
+module.exports = Bounds;
+
+(function() {
+
+ /**
+ * Creates a new axis-aligned bounding box (AABB) for the given vertices.
+ * @method create
+ * @param {vertices} vertices
+ * @return {bounds} A new bounds object
+ */
+ Bounds.create = function(vertices) {
+ var bounds = {
+ min: { x: 0, y: 0 },
+ max: { x: 0, y: 0 }
+ };
+
+ if (vertices)
+ Bounds.update(bounds, vertices);
+
+ return bounds;
+ };
+
+ /**
+ * Updates bounds using the given vertices and extends the bounds given a velocity.
+ * @method update
+ * @param {bounds} bounds
+ * @param {vertices} vertices
+ * @param {vector} velocity
+ */
+ Bounds.update = function(bounds, vertices, velocity) {
+ bounds.min.x = Infinity;
+ bounds.max.x = -Infinity;
+ bounds.min.y = Infinity;
+ bounds.max.y = -Infinity;
+
+ for (var i = 0; i < vertices.length; i++) {
+ var vertex = vertices[i];
+ if (vertex.x > bounds.max.x) bounds.max.x = vertex.x;
+ if (vertex.x < bounds.min.x) bounds.min.x = vertex.x;
+ if (vertex.y > bounds.max.y) bounds.max.y = vertex.y;
+ if (vertex.y < bounds.min.y) bounds.min.y = vertex.y;
+ }
+
+ if (velocity) {
+ if (velocity.x > 0) {
+ bounds.max.x += velocity.x;
+ } else {
+ bounds.min.x += velocity.x;
+ }
+
+ if (velocity.y > 0) {
+ bounds.max.y += velocity.y;
+ } else {
+ bounds.min.y += velocity.y;
+ }
+ }
+ };
+
+ /**
+ * Returns true if the bounds contains the given point.
+ * @method contains
+ * @param {bounds} bounds
+ * @param {vector} point
+ * @return {boolean} True if the bounds contain the point, otherwise false
+ */
+ Bounds.contains = function(bounds, point) {
+ return point.x >= bounds.min.x && point.x <= bounds.max.x
+ && point.y >= bounds.min.y && point.y <= bounds.max.y;
+ };
+
+ /**
+ * Returns true if the two bounds intersect.
+ * @method overlaps
+ * @param {bounds} boundsA
+ * @param {bounds} boundsB
+ * @return {boolean} True if the bounds overlap, otherwise false
+ */
+ Bounds.overlaps = function(boundsA, boundsB) {
+ return (boundsA.min.x <= boundsB.max.x && boundsA.max.x >= boundsB.min.x
+ && boundsA.max.y >= boundsB.min.y && boundsA.min.y <= boundsB.max.y);
+ };
+
+ /**
+ * Translates the bounds by the given vector.
+ * @method translate
+ * @param {bounds} bounds
+ * @param {vector} vector
+ */
+ Bounds.translate = function(bounds, vector) {
+ bounds.min.x += vector.x;
+ bounds.max.x += vector.x;
+ bounds.min.y += vector.y;
+ bounds.max.y += vector.y;
+ };
+
+ /**
+ * Shifts the bounds to the given position.
+ * @method shift
+ * @param {bounds} bounds
+ * @param {vector} position
+ */
+ Bounds.shift = function(bounds, position) {
+ var deltaX = bounds.max.x - bounds.min.x,
+ deltaY = bounds.max.y - bounds.min.y;
+
+ bounds.min.x = position.x;
+ bounds.max.x = position.x + deltaX;
+ bounds.min.y = position.y;
+ bounds.max.y = position.y + deltaY;
+ };
+
+})();
+
+
+/***/ }),
+/* 2 */
+/***/ (function(module, exports) {
+
+/**
+* The `Matter.Vector` module contains methods for creating and manipulating vectors.
+* Vectors are the basis of all the geometry related operations in the engine.
+* A `Matter.Vector` object is of the form `{ x: 0, y: 0 }`.
+*
+* See the included usage [examples](https://github.com/liabru/matter-js/tree/master/examples).
+*
+* @class Vector
+*/
+
+// TODO: consider params for reusing vector objects
+
+var Vector = {};
+
+module.exports = Vector;
+
+(function() {
+
+ /**
+ * Creates a new vector.
+ * @method create
+ * @param {number} x
+ * @param {number} y
+ * @return {vector} A new vector
+ */
+ Vector.create = function(x, y) {
+ return { x: x || 0, y: y || 0 };
+ };
+
+ /**
+ * Returns a new vector with `x` and `y` copied from the given `vector`.
+ * @method clone
+ * @param {vector} vector
+ * @return {vector} A new cloned vector
+ */
+ Vector.clone = function(vector) {
+ return { x: vector.x, y: vector.y };
+ };
+
+ /**
+ * Returns the magnitude (length) of a vector.
+ * @method magnitude
+ * @param {vector} vector
+ * @return {number} The magnitude of the vector
+ */
+ Vector.magnitude = function(vector) {
+ return Math.sqrt((vector.x * vector.x) + (vector.y * vector.y));
+ };
+
+ /**
+ * Returns the magnitude (length) of a vector (therefore saving a `sqrt` operation).
+ * @method magnitudeSquared
+ * @param {vector} vector
+ * @return {number} The squared magnitude of the vector
+ */
+ Vector.magnitudeSquared = function(vector) {
+ return (vector.x * vector.x) + (vector.y * vector.y);
+ };
+
+ /**
+ * Rotates the vector about (0, 0) by specified angle.
+ * @method rotate
+ * @param {vector} vector
+ * @param {number} angle
+ * @param {vector} [output]
+ * @return {vector} The vector rotated about (0, 0)
+ */
+ Vector.rotate = function(vector, angle, output) {
+ var cos = Math.cos(angle), sin = Math.sin(angle);
+ if (!output) output = {};
+ var x = vector.x * cos - vector.y * sin;
+ output.y = vector.x * sin + vector.y * cos;
+ output.x = x;
+ return output;
+ };
+
+ /**
+ * Rotates the vector about a specified point by specified angle.
+ * @method rotateAbout
+ * @param {vector} vector
+ * @param {number} angle
+ * @param {vector} point
+ * @param {vector} [output]
+ * @return {vector} A new vector rotated about the point
+ */
+ Vector.rotateAbout = function(vector, angle, point, output) {
+ var cos = Math.cos(angle), sin = Math.sin(angle);
+ if (!output) output = {};
+ var x = point.x + ((vector.x - point.x) * cos - (vector.y - point.y) * sin);
+ output.y = point.y + ((vector.x - point.x) * sin + (vector.y - point.y) * cos);
+ output.x = x;
+ return output;
+ };
+
+ /**
+ * Normalises a vector (such that its magnitude is `1`).
+ * @method normalise
+ * @param {vector} vector
+ * @return {vector} A new vector normalised
+ */
+ Vector.normalise = function(vector) {
+ var magnitude = Vector.magnitude(vector);
+ if (magnitude === 0)
+ return { x: 0, y: 0 };
+ return { x: vector.x / magnitude, y: vector.y / magnitude };
+ };
+
+ /**
+ * Returns the dot-product of two vectors.
+ * @method dot
+ * @param {vector} vectorA
+ * @param {vector} vectorB
+ * @return {number} The dot product of the two vectors
+ */
+ Vector.dot = function(vectorA, vectorB) {
+ return (vectorA.x * vectorB.x) + (vectorA.y * vectorB.y);
+ };
+
+ /**
+ * Returns the cross-product of two vectors.
+ * @method cross
+ * @param {vector} vectorA
+ * @param {vector} vectorB
+ * @return {number} The cross product of the two vectors
+ */
+ Vector.cross = function(vectorA, vectorB) {
+ return (vectorA.x * vectorB.y) - (vectorA.y * vectorB.x);
+ };
+
+ /**
+ * Returns the cross-product of three vectors.
+ * @method cross3
+ * @param {vector} vectorA
+ * @param {vector} vectorB
+ * @param {vector} vectorC
+ * @return {number} The cross product of the three vectors
+ */
+ Vector.cross3 = function(vectorA, vectorB, vectorC) {
+ return (vectorB.x - vectorA.x) * (vectorC.y - vectorA.y) - (vectorB.y - vectorA.y) * (vectorC.x - vectorA.x);
+ };
+
+ /**
+ * Adds the two vectors.
+ * @method add
+ * @param {vector} vectorA
+ * @param {vector} vectorB
+ * @param {vector} [output]
+ * @return {vector} A new vector of vectorA and vectorB added
+ */
+ Vector.add = function(vectorA, vectorB, output) {
+ if (!output) output = {};
+ output.x = vectorA.x + vectorB.x;
+ output.y = vectorA.y + vectorB.y;
+ return output;
+ };
+
+ /**
+ * Subtracts the two vectors.
+ * @method sub
+ * @param {vector} vectorA
+ * @param {vector} vectorB
+ * @param {vector} [output]
+ * @return {vector} A new vector of vectorA and vectorB subtracted
+ */
+ Vector.sub = function(vectorA, vectorB, output) {
+ if (!output) output = {};
+ output.x = vectorA.x - vectorB.x;
+ output.y = vectorA.y - vectorB.y;
+ return output;
+ };
+
+ /**
+ * Multiplies a vector and a scalar.
+ * @method mult
+ * @param {vector} vector
+ * @param {number} scalar
+ * @return {vector} A new vector multiplied by scalar
+ */
+ Vector.mult = function(vector, scalar) {
+ return { x: vector.x * scalar, y: vector.y * scalar };
+ };
+
+ /**
+ * Divides a vector and a scalar.
+ * @method div
+ * @param {vector} vector
+ * @param {number} scalar
+ * @return {vector} A new vector divided by scalar
+ */
+ Vector.div = function(vector, scalar) {
+ return { x: vector.x / scalar, y: vector.y / scalar };
+ };
+
+ /**
+ * Returns the perpendicular vector. Set `negate` to true for the perpendicular in the opposite direction.
+ * @method perp
+ * @param {vector} vector
+ * @param {bool} [negate=false]
+ * @return {vector} The perpendicular vector
+ */
+ Vector.perp = function(vector, negate) {
+ negate = negate === true ? -1 : 1;
+ return { x: negate * -vector.y, y: negate * vector.x };
+ };
+
+ /**
+ * Negates both components of a vector such that it points in the opposite direction.
+ * @method neg
+ * @param {vector} vector
+ * @return {vector} The negated vector
+ */
+ Vector.neg = function(vector) {
+ return { x: -vector.x, y: -vector.y };
+ };
+
+ /**
+ * Returns the angle between the vector `vectorB - vectorA` and the x-axis in radians.
+ * @method angle
+ * @param {vector} vectorA
+ * @param {vector} vectorB
+ * @return {number} The angle in radians
+ */
+ Vector.angle = function(vectorA, vectorB) {
+ return Math.atan2(vectorB.y - vectorA.y, vectorB.x - vectorA.x);
+ };
+
+ /**
+ * Temporary vector pool (not thread-safe).
+ * @property _temp
+ * @type {vector[]}
+ * @private
+ */
+ Vector._temp = [
+ Vector.create(), Vector.create(),
+ Vector.create(), Vector.create(),
+ Vector.create(), Vector.create()
+ ];
+
+})();
+
+/***/ }),
+/* 3 */
+/***/ (function(module, exports, __webpack_require__) {
+
+/**
+* The `Matter.Vertices` module contains methods for creating and manipulating sets of vertices.
+* A set of vertices is an array of `Matter.Vector` with additional indexing properties inserted by `Vertices.create`.
+* A `Matter.Body` maintains a set of vertices to represent the shape of the object (its convex hull).
+*
+* See the included usage [examples](https://github.com/liabru/matter-js/tree/master/examples).
+*
+* @class Vertices
+*/
+
+var Vertices = {};
+
+module.exports = Vertices;
+
+var Vector = __webpack_require__(2);
+var Common = __webpack_require__(0);
+
+(function() {
+
+ /**
+ * Creates a new set of `Matter.Body` compatible vertices.
+ * The `points` argument accepts an array of `Matter.Vector` points orientated around the origin `(0, 0)`, for example:
+ *
+ * [{ x: 0, y: 0 }, { x: 25, y: 50 }, { x: 50, y: 0 }]
+ *
+ * The `Vertices.create` method returns a new array of vertices, which are similar to Matter.Vector objects,
+ * but with some additional references required for efficient collision detection routines.
+ *
+ * Vertices must be specified in clockwise order.
+ *
+ * Note that the `body` argument is not optional, a `Matter.Body` reference must be provided.
+ *
+ * @method create
+ * @param {vector[]} points
+ * @param {body} body
+ */
+ Vertices.create = function(points, body) {
+ var vertices = [];
+
+ for (var i = 0; i < points.length; i++) {
+ var point = points[i],
+ vertex = {
+ x: point.x,
+ y: point.y,
+ index: i,
+ body: body,
+ isInternal: false
+ };
+
+ vertices.push(vertex);
+ }
+
+ return vertices;
+ };
+
+ /**
+ * Parses a string containing ordered x y pairs separated by spaces (and optionally commas),
+ * into a `Matter.Vertices` object for the given `Matter.Body`.
+ * For parsing SVG paths, see `Svg.pathToVertices`.
+ * @method fromPath
+ * @param {string} path
+ * @param {body} body
+ * @return {vertices} vertices
+ */
+ Vertices.fromPath = function(path, body) {
+ var pathPattern = /L?\s*([-\d.e]+)[\s,]*([-\d.e]+)*/ig,
+ points = [];
+
+ path.replace(pathPattern, function(match, x, y) {
+ points.push({ x: parseFloat(x), y: parseFloat(y) });
+ });
+
+ return Vertices.create(points, body);
+ };
+
+ /**
+ * Returns the centre (centroid) of the set of vertices.
+ * @method centre
+ * @param {vertices} vertices
+ * @return {vector} The centre point
+ */
+ Vertices.centre = function(vertices) {
+ var area = Vertices.area(vertices, true),
+ centre = { x: 0, y: 0 },
+ cross,
+ temp,
+ j;
+
+ for (var i = 0; i < vertices.length; i++) {
+ j = (i + 1) % vertices.length;
+ cross = Vector.cross(vertices[i], vertices[j]);
+ temp = Vector.mult(Vector.add(vertices[i], vertices[j]), cross);
+ centre = Vector.add(centre, temp);
+ }
+
+ return Vector.div(centre, 6 * area);
+ };
+
+ /**
+ * Returns the average (mean) of the set of vertices.
+ * @method mean
+ * @param {vertices} vertices
+ * @return {vector} The average point
+ */
+ Vertices.mean = function(vertices) {
+ var average = { x: 0, y: 0 };
+
+ for (var i = 0; i < vertices.length; i++) {
+ average.x += vertices[i].x;
+ average.y += vertices[i].y;
+ }
+
+ return Vector.div(average, vertices.length);
+ };
+
+ /**
+ * Returns the area of the set of vertices.
+ * @method area
+ * @param {vertices} vertices
+ * @param {bool} signed
+ * @return {number} The area
+ */
+ Vertices.area = function(vertices, signed) {
+ var area = 0,
+ j = vertices.length - 1;
+
+ for (var i = 0; i < vertices.length; i++) {
+ area += (vertices[j].x - vertices[i].x) * (vertices[j].y + vertices[i].y);
+ j = i;
+ }
+
+ if (signed)
+ return area / 2;
+
+ return Math.abs(area) / 2;
+ };
+
+ /**
+ * Returns the moment of inertia (second moment of area) of the set of vertices given the total mass.
+ * @method inertia
+ * @param {vertices} vertices
+ * @param {number} mass
+ * @return {number} The polygon's moment of inertia
+ */
+ Vertices.inertia = function(vertices, mass) {
+ var numerator = 0,
+ denominator = 0,
+ v = vertices,
+ cross,
+ j;
+
+ // find the polygon's moment of inertia, using second moment of area
+ // from equations at http://www.physicsforums.com/showthread.php?t=25293
+ for (var n = 0; n < v.length; n++) {
+ j = (n + 1) % v.length;
+ cross = Math.abs(Vector.cross(v[j], v[n]));
+ numerator += cross * (Vector.dot(v[j], v[j]) + Vector.dot(v[j], v[n]) + Vector.dot(v[n], v[n]));
+ denominator += cross;
+ }
+
+ return (mass / 6) * (numerator / denominator);
+ };
+
+ /**
+ * Translates the set of vertices in-place.
+ * @method translate
+ * @param {vertices} vertices
+ * @param {vector} vector
+ * @param {number} scalar
+ */
+ Vertices.translate = function(vertices, vector, scalar) {
+ var i;
+ if (scalar) {
+ for (i = 0; i < vertices.length; i++) {
+ vertices[i].x += vector.x * scalar;
+ vertices[i].y += vector.y * scalar;
+ }
+ } else {
+ for (i = 0; i < vertices.length; i++) {
+ vertices[i].x += vector.x;
+ vertices[i].y += vector.y;
+ }
+ }
+
+ return vertices;
+ };
+
+ /**
+ * Rotates the set of vertices in-place.
+ * @method rotate
+ * @param {vertices} vertices
+ * @param {number} angle
+ * @param {vector} point
+ */
+ Vertices.rotate = function(vertices, angle, point) {
+ if (angle === 0)
+ return;
+
+ var cos = Math.cos(angle),
+ sin = Math.sin(angle);
+
+ for (var i = 0; i < vertices.length; i++) {
+ var vertice = vertices[i],
+ dx = vertice.x - point.x,
+ dy = vertice.y - point.y;
+
+ vertice.x = point.x + (dx * cos - dy * sin);
+ vertice.y = point.y + (dx * sin + dy * cos);
+ }
+
+ return vertices;
+ };
+
+ /**
+ * Returns `true` if the `point` is inside the set of `vertices`.
+ * @method contains
+ * @param {vertices} vertices
+ * @param {vector} point
+ * @return {boolean} True if the vertices contains point, otherwise false
+ */
+ Vertices.contains = function(vertices, point) {
+ for (var i = 0; i < vertices.length; i++) {
+ var vertice = vertices[i],
+ nextVertice = vertices[(i + 1) % vertices.length];
+ if ((point.x - vertice.x) * (nextVertice.y - vertice.y) + (point.y - vertice.y) * (vertice.x - nextVertice.x) > 0) {
+ return false;
+ }
+ }
+
+ return true;
+ };
+
+ /**
+ * Scales the vertices from a point (default is centre) in-place.
+ * @method scale
+ * @param {vertices} vertices
+ * @param {number} scaleX
+ * @param {number} scaleY
+ * @param {vector} point
+ */
+ Vertices.scale = function(vertices, scaleX, scaleY, point) {
+ if (scaleX === 1 && scaleY === 1)
+ return vertices;
+
+ point = point || Vertices.centre(vertices);
+
+ var vertex,
+ delta;
+
+ for (var i = 0; i < vertices.length; i++) {
+ vertex = vertices[i];
+ delta = Vector.sub(vertex, point);
+ vertices[i].x = point.x + delta.x * scaleX;
+ vertices[i].y = point.y + delta.y * scaleY;
+ }
+
+ return vertices;
+ };
+
+ /**
+ * Chamfers a set of vertices by giving them rounded corners, returns a new set of vertices.
+ * The radius parameter is a single number or an array to specify the radius for each vertex.
+ * @method chamfer
+ * @param {vertices} vertices
+ * @param {number[]} radius
+ * @param {number} quality
+ * @param {number} qualityMin
+ * @param {number} qualityMax
+ */
+ Vertices.chamfer = function(vertices, radius, quality, qualityMin, qualityMax) {
+ if (typeof radius === 'number') {
+ radius = [radius];
+ } else {
+ radius = radius || [8];
+ }
+
+ // quality defaults to -1, which is auto
+ quality = (typeof quality !== 'undefined') ? quality : -1;
+ qualityMin = qualityMin || 2;
+ qualityMax = qualityMax || 14;
+
+ var newVertices = [];
+
+ for (var i = 0; i < vertices.length; i++) {
+ var prevVertex = vertices[i - 1 >= 0 ? i - 1 : vertices.length - 1],
+ vertex = vertices[i],
+ nextVertex = vertices[(i + 1) % vertices.length],
+ currentRadius = radius[i < radius.length ? i : radius.length - 1];
+
+ if (currentRadius === 0) {
+ newVertices.push(vertex);
+ continue;
+ }
+
+ var prevNormal = Vector.normalise({
+ x: vertex.y - prevVertex.y,
+ y: prevVertex.x - vertex.x
+ });
+
+ var nextNormal = Vector.normalise({
+ x: nextVertex.y - vertex.y,
+ y: vertex.x - nextVertex.x
+ });
+
+ var diagonalRadius = Math.sqrt(2 * Math.pow(currentRadius, 2)),
+ radiusVector = Vector.mult(Common.clone(prevNormal), currentRadius),
+ midNormal = Vector.normalise(Vector.mult(Vector.add(prevNormal, nextNormal), 0.5)),
+ scaledVertex = Vector.sub(vertex, Vector.mult(midNormal, diagonalRadius));
+
+ var precision = quality;
+
+ if (quality === -1) {
+ // automatically decide precision
+ precision = Math.pow(currentRadius, 0.32) * 1.75;
+ }
+
+ precision = Common.clamp(precision, qualityMin, qualityMax);
+
+ // use an even value for precision, more likely to reduce axes by using symmetry
+ if (precision % 2 === 1)
+ precision += 1;
+
+ var alpha = Math.acos(Vector.dot(prevNormal, nextNormal)),
+ theta = alpha / precision;
+
+ for (var j = 0; j < precision; j++) {
+ newVertices.push(Vector.add(Vector.rotate(radiusVector, theta * j), scaledVertex));
+ }
+ }
+
+ return newVertices;
+ };
+
+ /**
+ * Sorts the input vertices into clockwise order in place.
+ * @method clockwiseSort
+ * @param {vertices} vertices
+ * @return {vertices} vertices
+ */
+ Vertices.clockwiseSort = function(vertices) {
+ var centre = Vertices.mean(vertices);
+
+ vertices.sort(function(vertexA, vertexB) {
+ return Vector.angle(centre, vertexA) - Vector.angle(centre, vertexB);
+ });
+
+ return vertices;
+ };
+
+ /**
+ * Returns true if the vertices form a convex shape (vertices must be in clockwise order).
+ * @method isConvex
+ * @param {vertices} vertices
+ * @return {bool} `true` if the `vertices` are convex, `false` if not (or `null` if not computable).
+ */
+ Vertices.isConvex = function(vertices) {
+ // http://paulbourke.net/geometry/polygonmesh/
+ // Copyright (c) Paul Bourke (use permitted)
+
+ var flag = 0,
+ n = vertices.length,
+ i,
+ j,
+ k,
+ z;
+
+ if (n < 3)
+ return null;
+
+ for (i = 0; i < n; i++) {
+ j = (i + 1) % n;
+ k = (i + 2) % n;
+ z = (vertices[j].x - vertices[i].x) * (vertices[k].y - vertices[j].y);
+ z -= (vertices[j].y - vertices[i].y) * (vertices[k].x - vertices[j].x);
+
+ if (z < 0) {
+ flag |= 1;
+ } else if (z > 0) {
+ flag |= 2;
+ }
+
+ if (flag === 3) {
+ return false;
+ }
+ }
+
+ if (flag !== 0){
+ return true;
+ } else {
+ return null;
+ }
+ };
+
+ /**
+ * Returns the convex hull of the input vertices as a new array of points.
+ * @method hull
+ * @param {vertices} vertices
+ * @return [vertex] vertices
+ */
+ Vertices.hull = function(vertices) {
+ // http://geomalgorithms.com/a10-_hull-1.html
+
+ var upper = [],
+ lower = [],
+ vertex,
+ i;
+
+ // sort vertices on x-axis (y-axis for ties)
+ vertices = vertices.slice(0);
+ vertices.sort(function(vertexA, vertexB) {
+ var dx = vertexA.x - vertexB.x;
+ return dx !== 0 ? dx : vertexA.y - vertexB.y;
+ });
+
+ // build lower hull
+ for (i = 0; i < vertices.length; i += 1) {
+ vertex = vertices[i];
+
+ while (lower.length >= 2
+ && Vector.cross3(lower[lower.length - 2], lower[lower.length - 1], vertex) <= 0) {
+ lower.pop();
+ }
+
+ lower.push(vertex);
+ }
+
+ // build upper hull
+ for (i = vertices.length - 1; i >= 0; i -= 1) {
+ vertex = vertices[i];
+
+ while (upper.length >= 2
+ && Vector.cross3(upper[upper.length - 2], upper[upper.length - 1], vertex) <= 0) {
+ upper.pop();
+ }
+
+ upper.push(vertex);
+ }
+
+ // concatenation of the lower and upper hulls gives the convex hull
+ // omit last points because they are repeated at the beginning of the other list
+ upper.pop();
+ lower.pop();
+
+ return upper.concat(lower);
+ };
+
+})();
+
+
+/***/ }),
+/* 4 */
+/***/ (function(module, exports, __webpack_require__) {
+
+/**
+* The `Matter.Events` module contains methods to fire and listen to events on other objects.
+*
+* See the included usage [examples](https://github.com/liabru/matter-js/tree/master/examples).
+*
+* @class Events
+*/
+
+var Events = {};
+
+module.exports = Events;
+
+var Common = __webpack_require__(0);
+
+(function() {
+
+ /**
+ * Subscribes a callback function to the given object's `eventName`.
+ * @method on
+ * @param {} object
+ * @param {string} eventNames
+ * @param {function} callback
+ */
+ Events.on = function(object, eventNames, callback) {
+ var names = eventNames.split(' '),
+ name;
+
+ for (var i = 0; i < names.length; i++) {
+ name = names[i];
+ object.events = object.events || {};
+ object.events[name] = object.events[name] || [];
+ object.events[name].push(callback);
+ }
+
+ return callback;
+ };
+
+ /**
+ * Removes the given event callback. If no callback, clears all callbacks in `eventNames`. If no `eventNames`, clears all events.
+ * @method off
+ * @param {} object
+ * @param {string} eventNames
+ * @param {function} callback
+ */
+ Events.off = function(object, eventNames, callback) {
+ if (!eventNames) {
+ object.events = {};
+ return;
+ }
+
+ // handle Events.off(object, callback)
+ if (typeof eventNames === 'function') {
+ callback = eventNames;
+ eventNames = Common.keys(object.events).join(' ');
+ }
+
+ var names = eventNames.split(' ');
+
+ for (var i = 0; i < names.length; i++) {
+ var callbacks = object.events[names[i]],
+ newCallbacks = [];
+
+ if (callback && callbacks) {
+ for (var j = 0; j < callbacks.length; j++) {
+ if (callbacks[j] !== callback)
+ newCallbacks.push(callbacks[j]);
+ }
+ }
+
+ object.events[names[i]] = newCallbacks;
+ }
+ };
+
+ /**
+ * Fires all the callbacks subscribed to the given object's `eventName`, in the order they subscribed, if any.
+ * @method trigger
+ * @param {} object
+ * @param {string} eventNames
+ * @param {} event
+ */
+ Events.trigger = function(object, eventNames, event) {
+ var names,
+ name,
+ callbacks,
+ eventClone;
+
+ var events = object.events;
+
+ if (events && Common.keys(events).length > 0) {
+ if (!event)
+ event = {};
+
+ names = eventNames.split(' ');
+
+ for (var i = 0; i < names.length; i++) {
+ name = names[i];
+ callbacks = events[name];
+
+ if (callbacks) {
+ eventClone = Common.clone(event, false);
+ eventClone.name = name;
+ eventClone.source = object;
+
+ for (var j = 0; j < callbacks.length; j++) {
+ callbacks[j].apply(object, [eventClone]);
+ }
+ }
+ }
+ }
+ };
+
+})();
+
+
+/***/ }),
+/* 5 */
+/***/ (function(module, exports, __webpack_require__) {
+
+/**
+* A composite is a collection of `Matter.Body`, `Matter.Constraint` and other `Matter.Composite` objects.
+*
+* They are a container that can represent complex objects made of multiple parts, even if they are not physically connected.
+* A composite could contain anything from a single body all the way up to a whole world.
+*
+* When making any changes to composites, use the included functions rather than changing their properties directly.
+*
+* See the included usage [examples](https://github.com/liabru/matter-js/tree/master/examples).
+*
+* @class Composite
+*/
+
+var Composite = {};
+
+module.exports = Composite;
+
+var Events = __webpack_require__(4);
+var Common = __webpack_require__(0);
+var Bounds = __webpack_require__(1);
+var Body = __webpack_require__(6);
+
+(function() {
+
+ /**
+ * Creates a new composite. The options parameter is an object that specifies any properties you wish to override the defaults.
+ * See the properites section below for detailed information on what you can pass via the `options` object.
+ * @method create
+ * @param {} [options]
+ * @return {composite} A new composite
+ */
+ Composite.create = function(options) {
+ return Common.extend({
+ id: Common.nextId(),
+ type: 'composite',
+ parent: null,
+ isModified: false,
+ bodies: [],
+ constraints: [],
+ composites: [],
+ label: 'Composite',
+ plugin: {}
+ }, options);
+ };
+
+ /**
+ * Sets the composite's `isModified` flag.
+ * If `updateParents` is true, all parents will be set (default: false).
+ * If `updateChildren` is true, all children will be set (default: false).
+ * @method setModified
+ * @param {composite} composite
+ * @param {boolean} isModified
+ * @param {boolean} [updateParents=false]
+ * @param {boolean} [updateChildren=false]
+ */
+ Composite.setModified = function(composite, isModified, updateParents, updateChildren) {
+ composite.isModified = isModified;
+
+ if (updateParents && composite.parent) {
+ Composite.setModified(composite.parent, isModified, updateParents, updateChildren);
+ }
+
+ if (updateChildren) {
+ for(var i = 0; i < composite.composites.length; i++) {
+ var childComposite = composite.composites[i];
+ Composite.setModified(childComposite, isModified, updateParents, updateChildren);
+ }
+ }
+ };
+
+ /**
+ * Generic single or multi-add function. Adds a single or an array of body(s), constraint(s) or composite(s) to the given composite.
+ * Triggers `beforeAdd` and `afterAdd` events on the `composite`.
+ * @method add
+ * @param {composite} composite
+ * @param {object|array} object A single or an array of body(s), constraint(s) or composite(s)
+ * @return {composite} The original composite with the objects added
+ */
+ Composite.add = function(composite, object) {
+ var objects = [].concat(object);
+
+ Events.trigger(composite, 'beforeAdd', { object: object });
+
+ for (var i = 0; i < objects.length; i++) {
+ var obj = objects[i];
+
+ switch (obj.type) {
+
+ case 'body':
+ // skip adding compound parts
+ if (obj.parent !== obj) {
+ Common.warn('Composite.add: skipped adding a compound body part (you must add its parent instead)');
+ break;
+ }
+
+ Composite.addBody(composite, obj);
+ break;
+ case 'constraint':
+ Composite.addConstraint(composite, obj);
+ break;
+ case 'composite':
+ Composite.addComposite(composite, obj);
+ break;
+ case 'mouseConstraint':
+ Composite.addConstraint(composite, obj.constraint);
+ break;
+
+ }
+ }
+
+ Events.trigger(composite, 'afterAdd', { object: object });
+
+ return composite;
+ };
+
+ /**
+ * Generic remove function. Removes one or many body(s), constraint(s) or a composite(s) to the given composite.
+ * Optionally searching its children recursively.
+ * Triggers `beforeRemove` and `afterRemove` events on the `composite`.
+ * @method remove
+ * @param {composite} composite
+ * @param {object|array} object
+ * @param {boolean} [deep=false]
+ * @return {composite} The original composite with the objects removed
+ */
+ Composite.remove = function(composite, object, deep) {
+ var objects = [].concat(object);
+
+ Events.trigger(composite, 'beforeRemove', { object: object });
+
+ for (var i = 0; i < objects.length; i++) {
+ var obj = objects[i];
+
+ switch (obj.type) {
+
+ case 'body':
+ Composite.removeBody(composite, obj, deep);
+ break;
+ case 'constraint':
+ Composite.removeConstraint(composite, obj, deep);
+ break;
+ case 'composite':
+ Composite.removeComposite(composite, obj, deep);
+ break;
+ case 'mouseConstraint':
+ Composite.removeConstraint(composite, obj.constraint);
+ break;
+
+ }
+ }
+
+ Events.trigger(composite, 'afterRemove', { object: object });
+
+ return composite;
+ };
+
+ /**
+ * Adds a composite to the given composite.
+ * @private
+ * @method addComposite
+ * @param {composite} compositeA
+ * @param {composite} compositeB
+ * @return {composite} The original compositeA with the objects from compositeB added
+ */
+ Composite.addComposite = function(compositeA, compositeB) {
+ compositeA.composites.push(compositeB);
+ compositeB.parent = compositeA;
+ Composite.setModified(compositeA, true, true, false);
+ return compositeA;
+ };
+
+ /**
+ * Removes a composite from the given composite, and optionally searching its children recursively.
+ * @private
+ * @method removeComposite
+ * @param {composite} compositeA
+ * @param {composite} compositeB
+ * @param {boolean} [deep=false]
+ * @return {composite} The original compositeA with the composite removed
+ */
+ Composite.removeComposite = function(compositeA, compositeB, deep) {
+ var position = Common.indexOf(compositeA.composites, compositeB);
+ if (position !== -1) {
+ Composite.removeCompositeAt(compositeA, position);
+ Composite.setModified(compositeA, true, true, false);
+ }
+
+ if (deep) {
+ for (var i = 0; i < compositeA.composites.length; i++){
+ Composite.removeComposite(compositeA.composites[i], compositeB, true);
+ }
+ }
+
+ return compositeA;
+ };
+
+ /**
+ * Removes a composite from the given composite.
+ * @private
+ * @method removeCompositeAt
+ * @param {composite} composite
+ * @param {number} position
+ * @return {composite} The original composite with the composite removed
+ */
+ Composite.removeCompositeAt = function(composite, position) {
+ composite.composites.splice(position, 1);
+ Composite.setModified(composite, true, true, false);
+ return composite;
+ };
+
+ /**
+ * Adds a body to the given composite.
+ * @private
+ * @method addBody
+ * @param {composite} composite
+ * @param {body} body
+ * @return {composite} The original composite with the body added
+ */
+ Composite.addBody = function(composite, body) {
+ composite.bodies.push(body);
+ Composite.setModified(composite, true, true, false);
+ return composite;
+ };
+
+ /**
+ * Removes a body from the given composite, and optionally searching its children recursively.
+ * @private
+ * @method removeBody
+ * @param {composite} composite
+ * @param {body} body
+ * @param {boolean} [deep=false]
+ * @return {composite} The original composite with the body removed
+ */
+ Composite.removeBody = function(composite, body, deep) {
+ var position = Common.indexOf(composite.bodies, body);
+ if (position !== -1) {
+ Composite.removeBodyAt(composite, position);
+ Composite.setModified(composite, true, true, false);
+ }
+
+ if (deep) {
+ for (var i = 0; i < composite.composites.length; i++){
+ Composite.removeBody(composite.composites[i], body, true);
+ }
+ }
+
+ return composite;
+ };
+
+ /**
+ * Removes a body from the given composite.
+ * @private
+ * @method removeBodyAt
+ * @param {composite} composite
+ * @param {number} position
+ * @return {composite} The original composite with the body removed
+ */
+ Composite.removeBodyAt = function(composite, position) {
+ composite.bodies.splice(position, 1);
+ Composite.setModified(composite, true, true, false);
+ return composite;
+ };
+
+ /**
+ * Adds a constraint to the given composite.
+ * @private
+ * @method addConstraint
+ * @param {composite} composite
+ * @param {constraint} constraint
+ * @return {composite} The original composite with the constraint added
+ */
+ Composite.addConstraint = function(composite, constraint) {
+ composite.constraints.push(constraint);
+ Composite.setModified(composite, true, true, false);
+ return composite;
+ };
+
+ /**
+ * Removes a constraint from the given composite, and optionally searching its children recursively.
+ * @private
+ * @method removeConstraint
+ * @param {composite} composite
+ * @param {constraint} constraint
+ * @param {boolean} [deep=false]
+ * @return {composite} The original composite with the constraint removed
+ */
+ Composite.removeConstraint = function(composite, constraint, deep) {
+ var position = Common.indexOf(composite.constraints, constraint);
+ if (position !== -1) {
+ Composite.removeConstraintAt(composite, position);
+ }
+
+ if (deep) {
+ for (var i = 0; i < composite.composites.length; i++){
+ Composite.removeConstraint(composite.composites[i], constraint, true);
+ }
+ }
+
+ return composite;
+ };
+
+ /**
+ * Removes a body from the given composite.
+ * @private
+ * @method removeConstraintAt
+ * @param {composite} composite
+ * @param {number} position
+ * @return {composite} The original composite with the constraint removed
+ */
+ Composite.removeConstraintAt = function(composite, position) {
+ composite.constraints.splice(position, 1);
+ Composite.setModified(composite, true, true, false);
+ return composite;
+ };
+
+ /**
+ * Removes all bodies, constraints and composites from the given composite.
+ * Optionally clearing its children recursively.
+ * @method clear
+ * @param {composite} composite
+ * @param {boolean} keepStatic
+ * @param {boolean} [deep=false]
+ */
+ Composite.clear = function(composite, keepStatic, deep) {
+ if (deep) {
+ for (var i = 0; i < composite.composites.length; i++){
+ Composite.clear(composite.composites[i], keepStatic, true);
+ }
+ }
+
+ if (keepStatic) {
+ composite.bodies = composite.bodies.filter(function(body) { return body.isStatic; });
+ } else {
+ composite.bodies.length = 0;
+ }
+
+ composite.constraints.length = 0;
+ composite.composites.length = 0;
+ Composite.setModified(composite, true, true, false);
+
+ return composite;
+ };
+
+ /**
+ * Returns all bodies in the given composite, including all bodies in its children, recursively.
+ * @method allBodies
+ * @param {composite} composite
+ * @return {body[]} All the bodies
+ */
+ Composite.allBodies = function(composite) {
+ var bodies = [].concat(composite.bodies);
+
+ for (var i = 0; i < composite.composites.length; i++)
+ bodies = bodies.concat(Composite.allBodies(composite.composites[i]));
+
+ return bodies;
+ };
+
+ /**
+ * Returns all constraints in the given composite, including all constraints in its children, recursively.
+ * @method allConstraints
+ * @param {composite} composite
+ * @return {constraint[]} All the constraints
+ */
+ Composite.allConstraints = function(composite) {
+ var constraints = [].concat(composite.constraints);
+
+ for (var i = 0; i < composite.composites.length; i++)
+ constraints = constraints.concat(Composite.allConstraints(composite.composites[i]));
+
+ return constraints;
+ };
+
+ /**
+ * Returns all composites in the given composite, including all composites in its children, recursively.
+ * @method allComposites
+ * @param {composite} composite
+ * @return {composite[]} All the composites
+ */
+ Composite.allComposites = function(composite) {
+ var composites = [].concat(composite.composites);
+
+ for (var i = 0; i < composite.composites.length; i++)
+ composites = composites.concat(Composite.allComposites(composite.composites[i]));
+
+ return composites;
+ };
+
+ /**
+ * Searches the composite recursively for an object matching the type and id supplied, null if not found.
+ * @method get
+ * @param {composite} composite
+ * @param {number} id
+ * @param {string} type
+ * @return {object} The requested object, if found
+ */
+ Composite.get = function(composite, id, type) {
+ var objects,
+ object;
+
+ switch (type) {
+ case 'body':
+ objects = Composite.allBodies(composite);
+ break;
+ case 'constraint':
+ objects = Composite.allConstraints(composite);
+ break;
+ case 'composite':
+ objects = Composite.allComposites(composite).concat(composite);
+ break;
+ }
+
+ if (!objects)
+ return null;
+
+ object = objects.filter(function(object) {
+ return object.id.toString() === id.toString();
+ });
+
+ return object.length === 0 ? null : object[0];
+ };
+
+ /**
+ * Moves the given object(s) from compositeA to compositeB (equal to a remove followed by an add).
+ * @method move
+ * @param {compositeA} compositeA
+ * @param {object[]} objects
+ * @param {compositeB} compositeB
+ * @return {composite} Returns compositeA
+ */
+ Composite.move = function(compositeA, objects, compositeB) {
+ Composite.remove(compositeA, objects);
+ Composite.add(compositeB, objects);
+ return compositeA;
+ };
+
+ /**
+ * Assigns new ids for all objects in the composite, recursively.
+ * @method rebase
+ * @param {composite} composite
+ * @return {composite} Returns composite
+ */
+ Composite.rebase = function(composite) {
+ var objects = Composite.allBodies(composite)
+ .concat(Composite.allConstraints(composite))
+ .concat(Composite.allComposites(composite));
+
+ for (var i = 0; i < objects.length; i++) {
+ objects[i].id = Common.nextId();
+ }
+
+ Composite.setModified(composite, true, true, false);
+
+ return composite;
+ };
+
+ /**
+ * Translates all children in the composite by a given vector relative to their current positions,
+ * without imparting any velocity.
+ * @method translate
+ * @param {composite} composite
+ * @param {vector} translation
+ * @param {bool} [recursive=true]
+ */
+ Composite.translate = function(composite, translation, recursive) {
+ var bodies = recursive ? Composite.allBodies(composite) : composite.bodies;
+
+ for (var i = 0; i < bodies.length; i++) {
+ Body.translate(bodies[i], translation);
+ }
+
+ Composite.setModified(composite, true, true, false);
+
+ return composite;
+ };
+
+ /**
+ * Rotates all children in the composite by a given angle about the given point, without imparting any angular velocity.
+ * @method rotate
+ * @param {composite} composite
+ * @param {number} rotation
+ * @param {vector} point
+ * @param {bool} [recursive=true]
+ */
+ Composite.rotate = function(composite, rotation, point, recursive) {
+ var cos = Math.cos(rotation),
+ sin = Math.sin(rotation),
+ bodies = recursive ? Composite.allBodies(composite) : composite.bodies;
+
+ for (var i = 0; i < bodies.length; i++) {
+ var body = bodies[i],
+ dx = body.position.x - point.x,
+ dy = body.position.y - point.y;
+
+ Body.setPosition(body, {
+ x: point.x + (dx * cos - dy * sin),
+ y: point.y + (dx * sin + dy * cos)
+ });
+
+ Body.rotate(body, rotation);
+ }
+
+ Composite.setModified(composite, true, true, false);
+
+ return composite;
+ };
+
+ /**
+ * Scales all children in the composite, including updating physical properties (mass, area, axes, inertia), from a world-space point.
+ * @method scale
+ * @param {composite} composite
+ * @param {number} scaleX
+ * @param {number} scaleY
+ * @param {vector} point
+ * @param {bool} [recursive=true]
+ */
+ Composite.scale = function(composite, scaleX, scaleY, point, recursive) {
+ var bodies = recursive ? Composite.allBodies(composite) : composite.bodies;
+
+ for (var i = 0; i < bodies.length; i++) {
+ var body = bodies[i],
+ dx = body.position.x - point.x,
+ dy = body.position.y - point.y;
+
+ Body.setPosition(body, {
+ x: point.x + dx * scaleX,
+ y: point.y + dy * scaleY
+ });
+
+ Body.scale(body, scaleX, scaleY);
+ }
+
+ Composite.setModified(composite, true, true, false);
+
+ return composite;
+ };
+
+ /**
+ * Returns the union of the bounds of all of the composite's bodies.
+ * @method bounds
+ * @param {composite} composite The composite.
+ * @returns {bounds} The composite bounds.
+ */
+ Composite.bounds = function(composite) {
+ var bodies = Composite.allBodies(composite),
+ vertices = [];
+
+ for (var i = 0; i < bodies.length; i += 1) {
+ var body = bodies[i];
+ vertices.push(body.bounds.min, body.bounds.max);
+ }
+
+ return Bounds.create(vertices);
+ };
+
+ /*
+ *
+ * Events Documentation
+ *
+ */
+
+ /**
+ * Fired when a call to `Composite.add` is made, before objects have been added.
+ *
+ * @event beforeAdd
+ * @param {} event An event object
+ * @param {} event.object The object(s) to be added (may be a single body, constraint, composite or a mixed array of these)
+ * @param {} event.source The source object of the event
+ * @param {} event.name The name of the event
+ */
+
+ /**
+ * Fired when a call to `Composite.add` is made, after objects have been added.
+ *
+ * @event afterAdd
+ * @param {} event An event object
+ * @param {} event.object The object(s) that have been added (may be a single body, constraint, composite or a mixed array of these)
+ * @param {} event.source The source object of the event
+ * @param {} event.name The name of the event
+ */
+
+ /**
+ * Fired when a call to `Composite.remove` is made, before objects have been removed.
+ *
+ * @event beforeRemove
+ * @param {} event An event object
+ * @param {} event.object The object(s) to be removed (may be a single body, constraint, composite or a mixed array of these)
+ * @param {} event.source The source object of the event
+ * @param {} event.name The name of the event
+ */
+
+ /**
+ * Fired when a call to `Composite.remove` is made, after objects have been removed.
+ *
+ * @event afterRemove
+ * @param {} event An event object
+ * @param {} event.object The object(s) that have been removed (may be a single body, constraint, composite or a mixed array of these)
+ * @param {} event.source The source object of the event
+ * @param {} event.name The name of the event
+ */
+
+ /*
+ *
+ * Properties Documentation
+ *
+ */
+
+ /**
+ * An integer `Number` uniquely identifying number generated in `Composite.create` by `Common.nextId`.
+ *
+ * @property id
+ * @type number
+ */
+
+ /**
+ * A `String` denoting the type of object.
+ *
+ * @property type
+ * @type string
+ * @default "composite"
+ * @readOnly
+ */
+
+ /**
+ * An arbitrary `String` name to help the user identify and manage composites.
+ *
+ * @property label
+ * @type string
+ * @default "Composite"
+ */
+
+ /**
+ * A flag that specifies whether the composite has been modified during the current step.
+ * Most `Matter.Composite` methods will automatically set this flag to `true` to inform the engine of changes to be handled.
+ * If you need to change it manually, you should use the `Composite.setModified` method.
+ *
+ * @property isModified
+ * @type boolean
+ * @default false
+ */
+
+ /**
+ * The `Composite` that is the parent of this composite. It is automatically managed by the `Matter.Composite` methods.
+ *
+ * @property parent
+ * @type composite
+ * @default null
+ */
+
+ /**
+ * An array of `Body` that are _direct_ children of this composite.
+ * To add or remove bodies you should use `Composite.add` and `Composite.remove` methods rather than directly modifying this property.
+ * If you wish to recursively find all descendants, you should use the `Composite.allBodies` method.
+ *
+ * @property bodies
+ * @type body[]
+ * @default []
+ */
+
+ /**
+ * An array of `Constraint` that are _direct_ children of this composite.
+ * To add or remove constraints you should use `Composite.add` and `Composite.remove` methods rather than directly modifying this property.
+ * If you wish to recursively find all descendants, you should use the `Composite.allConstraints` method.
+ *
+ * @property constraints
+ * @type constraint[]
+ * @default []
+ */
+
+ /**
+ * An array of `Composite` that are _direct_ children of this composite.
+ * To add or remove composites you should use `Composite.add` and `Composite.remove` methods rather than directly modifying this property.
+ * If you wish to recursively find all descendants, you should use the `Composite.allComposites` method.
+ *
+ * @property composites
+ * @type composite[]
+ * @default []
+ */
+
+ /**
+ * An object reserved for storing plugin-specific properties.
+ *
+ * @property plugin
+ * @type {}
+ */
+
+})();
+
+
+/***/ }),
+/* 6 */
+/***/ (function(module, exports, __webpack_require__) {
-(function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.Matter = f()}})(function(){var define,module,exports;return (function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c="function"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error("Cannot find module '"+i+"'");throw a.code="MODULE_NOT_FOUND",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u="function"==typeof require&&require,i=0;i 0 && body.motion < Sleeping._motionSleepThreshold * timeFactor) {
+ body.sleepCounter += 1;
- Body.setPosition(body, {
- x: point.x + (dx * cos - dy * sin),
- y: point.y + (dx * sin + dy * cos)
- });
-
- Body.rotate(body, rotation);
- }
-
- Composite.setModified(composite, true, true, false);
-
- return composite;
- };
-
- /**
- * Scales all children in the composite, including updating physical properties (mass, area, axes, inertia), from a world-space point.
- * @method scale
- * @param {composite} composite
- * @param {number} scaleX
- * @param {number} scaleY
- * @param {vector} point
- * @param {bool} [recursive=true]
- */
- Composite.scale = function(composite, scaleX, scaleY, point, recursive) {
- var bodies = recursive ? Composite.allBodies(composite) : composite.bodies;
-
- for (var i = 0; i < bodies.length; i++) {
- var body = bodies[i],
- dx = body.position.x - point.x,
- dy = body.position.y - point.y;
-
- Body.setPosition(body, {
- x: point.x + dx * scaleX,
- y: point.y + dy * scaleY
- });
-
- Body.scale(body, scaleX, scaleY);
- }
-
- Composite.setModified(composite, true, true, false);
-
- return composite;
- };
-
- /**
- * Returns the union of the bounds of all of the composite's bodies.
- * @method bounds
- * @param {composite} composite The composite.
- * @returns {bounds} The composite bounds.
- */
- Composite.bounds = function(composite) {
- var bodies = Composite.allBodies(composite),
- vertices = [];
-
- for (var i = 0; i < bodies.length; i += 1) {
- var body = bodies[i];
- vertices.push(body.bounds.min, body.bounds.max);
- }
-
- return Bounds.create(vertices);
- };
-
- /*
- *
- * Events Documentation
- *
- */
-
- /**
- * Fired when a call to `Composite.add` is made, before objects have been added.
- *
- * @event beforeAdd
- * @param {} event An event object
- * @param {} event.object The object(s) to be added (may be a single body, constraint, composite or a mixed array of these)
- * @param {} event.source The source object of the event
- * @param {} event.name The name of the event
- */
-
- /**
- * Fired when a call to `Composite.add` is made, after objects have been added.
- *
- * @event afterAdd
- * @param {} event An event object
- * @param {} event.object The object(s) that have been added (may be a single body, constraint, composite or a mixed array of these)
- * @param {} event.source The source object of the event
- * @param {} event.name The name of the event
- */
-
- /**
- * Fired when a call to `Composite.remove` is made, before objects have been removed.
- *
- * @event beforeRemove
- * @param {} event An event object
- * @param {} event.object The object(s) to be removed (may be a single body, constraint, composite or a mixed array of these)
- * @param {} event.source The source object of the event
- * @param {} event.name The name of the event
- */
-
- /**
- * Fired when a call to `Composite.remove` is made, after objects have been removed.
- *
- * @event afterRemove
- * @param {} event An event object
- * @param {} event.object The object(s) that have been removed (may be a single body, constraint, composite or a mixed array of these)
- * @param {} event.source The source object of the event
- * @param {} event.name The name of the event
- */
-
- /*
- *
- * Properties Documentation
- *
- */
-
- /**
- * An integer `Number` uniquely identifying number generated in `Composite.create` by `Common.nextId`.
- *
- * @property id
- * @type number
- */
-
- /**
- * A `String` denoting the type of object.
- *
- * @property type
- * @type string
- * @default "composite"
- * @readOnly
- */
-
- /**
- * An arbitrary `String` name to help the user identify and manage composites.
- *
- * @property label
- * @type string
- * @default "Composite"
- */
-
- /**
- * A flag that specifies whether the composite has been modified during the current step.
- * Most `Matter.Composite` methods will automatically set this flag to `true` to inform the engine of changes to be handled.
- * If you need to change it manually, you should use the `Composite.setModified` method.
- *
- * @property isModified
- * @type boolean
- * @default false
- */
-
- /**
- * The `Composite` that is the parent of this composite. It is automatically managed by the `Matter.Composite` methods.
- *
- * @property parent
- * @type composite
- * @default null
- */
-
- /**
- * An array of `Body` that are _direct_ children of this composite.
- * To add or remove bodies you should use `Composite.add` and `Composite.remove` methods rather than directly modifying this property.
- * If you wish to recursively find all descendants, you should use the `Composite.allBodies` method.
- *
- * @property bodies
- * @type body[]
- * @default []
- */
-
- /**
- * An array of `Constraint` that are _direct_ children of this composite.
- * To add or remove constraints you should use `Composite.add` and `Composite.remove` methods rather than directly modifying this property.
- * If you wish to recursively find all descendants, you should use the `Composite.allConstraints` method.
- *
- * @property constraints
- * @type constraint[]
- * @default []
- */
-
- /**
- * An array of `Composite` that are _direct_ children of this composite.
- * To add or remove composites you should use `Composite.add` and `Composite.remove` methods rather than directly modifying this property.
- * If you wish to recursively find all descendants, you should use the `Composite.allComposites` method.
- *
- * @property composites
- * @type composite[]
- * @default []
- */
-
- /**
- * An object reserved for storing plugin-specific properties.
- *
- * @property plugin
- * @type {}
- */
-
-})();
-
-},{"../core/Common":14,"../core/Events":16,"../geometry/Bounds":26,"./Body":1}],3:[function(_dereq_,module,exports){
-/**
-* The `Matter.World` module contains methods for creating and manipulating the world composite.
-* A `Matter.World` is a `Matter.Composite` body, which is a collection of `Matter.Body`, `Matter.Constraint` and other `Matter.Composite`.
-* A `Matter.World` has a few additional properties including `gravity` and `bounds`.
-* It is important to use the functions in the `Matter.Composite` module to modify the world composite, rather than directly modifying its properties.
-* There are also a few methods here that alias those in `Matter.Composite` for easier readability.
-*
-* See the included usage [examples](https://github.com/liabru/matter-js/tree/master/examples).
-*
-* @class World
-* @extends Composite
-*/
-
-var World = {};
-
-module.exports = World;
-
-var Composite = _dereq_('./Composite');
-var Constraint = _dereq_('../constraint/Constraint');
-var Common = _dereq_('../core/Common');
-
-(function() {
-
- /**
- * Creates a new world composite. The options parameter is an object that specifies any properties you wish to override the defaults.
- * See the properties section below for detailed information on what you can pass via the `options` object.
- * @method create
- * @constructor
- * @param {} options
- * @return {world} A new world
- */
- World.create = function(options) {
- var composite = Composite.create();
-
- var defaults = {
- label: 'World',
- gravity: {
- x: 0,
- y: 1,
- scale: 0.001
- },
- bounds: {
- min: { x: -Infinity, y: -Infinity },
- max: { x: Infinity, y: Infinity }
- }
- };
-
- return Common.extend(composite, defaults, options);
- };
-
- /*
- *
- * Properties Documentation
- *
- */
-
- /**
- * The gravity to apply on the world.
- *
- * @property gravity
- * @type object
- */
-
- /**
- * The gravity x component.
- *
- * @property gravity.x
- * @type object
- * @default 0
- */
-
- /**
- * The gravity y component.
- *
- * @property gravity.y
- * @type object
- * @default 1
- */
-
- /**
- * The gravity scale factor.
- *
- * @property gravity.scale
- * @type object
- * @default 0.001
- */
-
- /**
- * A `Bounds` object that defines the world bounds for collision detection.
- *
- * @property bounds
- * @type bounds
- * @default { min: { x: -Infinity, y: -Infinity }, max: { x: Infinity, y: Infinity } }
- */
-
- // World is a Composite body
- // see src/module/Outro.js for these aliases:
-
- /**
- * An alias for Composite.add
- * @method add
- * @param {world} world
- * @param {} object
- * @return {composite} The original world with the objects added
- */
-
- /**
- * An alias for Composite.remove
- * @method remove
- * @param {world} world
- * @param {} object
- * @param {boolean} [deep=false]
- * @return {composite} The original world with the objects removed
- */
-
- /**
- * An alias for Composite.clear
- * @method clear
- * @param {world} world
- * @param {boolean} keepStatic
- */
-
- /**
- * An alias for Composite.addComposite
- * @method addComposite
- * @param {world} world
- * @param {composite} composite
- * @return {world} The original world with the objects from composite added
- */
-
- /**
- * An alias for Composite.addBody
- * @method addBody
- * @param {world} world
- * @param {body} body
- * @return {world} The original world with the body added
- */
-
- /**
- * An alias for Composite.addConstraint
- * @method addConstraint
- * @param {world} world
- * @param {constraint} constraint
- * @return {world} The original world with the constraint added
- */
-
-})();
-
-},{"../constraint/Constraint":12,"../core/Common":14,"./Composite":2}],4:[function(_dereq_,module,exports){
-/**
-* The `Matter.Contact` module contains methods for creating and manipulating collision contacts.
-*
-* @class Contact
-*/
-
-var Contact = {};
-
-module.exports = Contact;
-
-(function() {
-
- /**
- * Creates a new contact.
- * @method create
- * @param {vertex} vertex
- * @return {contact} A new contact
- */
- Contact.create = function(vertex) {
- return {
- id: Contact.id(vertex),
- vertex: vertex,
- normalImpulse: 0,
- tangentImpulse: 0
- };
- };
-
- /**
- * Generates a contact id.
- * @method id
- * @param {vertex} vertex
- * @return {string} Unique contactID
- */
- Contact.id = function(vertex) {
- return vertex.body.id + '_' + vertex.index;
- };
-
-})();
-
-},{}],5:[function(_dereq_,module,exports){
-/**
-* The `Matter.Detector` module contains methods for detecting collisions given a set of pairs.
-*
-* @class Detector
-*/
-
-// TODO: speculative contacts
-
-var Detector = {};
-
-module.exports = Detector;
-
-var SAT = _dereq_('./SAT');
-var Pair = _dereq_('./Pair');
-var Bounds = _dereq_('../geometry/Bounds');
-
-(function() {
-
- /**
- * Finds all collisions given a list of pairs.
- * @method collisions
- * @param {pair[]} broadphasePairs
- * @param {engine} engine
- * @return {array} collisions
- */
- Detector.collisions = function(broadphasePairs, engine) {
- var collisions = [],
- pairsTable = engine.pairs.table;
-
-
- for (var i = 0; i < broadphasePairs.length; i++) {
- var bodyA = broadphasePairs[i][0],
- bodyB = broadphasePairs[i][1];
-
- if ((bodyA.isStatic || bodyA.isSleeping) && (bodyB.isStatic || bodyB.isSleeping))
- continue;
-
- if (!Detector.canCollide(bodyA.collisionFilter, bodyB.collisionFilter))
- continue;
-
-
- // mid phase
- if (Bounds.overlaps(bodyA.bounds, bodyB.bounds)) {
- for (var j = bodyA.parts.length > 1 ? 1 : 0; j < bodyA.parts.length; j++) {
- var partA = bodyA.parts[j];
-
- for (var k = bodyB.parts.length > 1 ? 1 : 0; k < bodyB.parts.length; k++) {
- var partB = bodyB.parts[k];
-
- if ((partA === bodyA && partB === bodyB) || Bounds.overlaps(partA.bounds, partB.bounds)) {
- // find a previous collision we could reuse
- var pairId = Pair.id(partA, partB),
- pair = pairsTable[pairId],
- previousCollision;
-
- if (pair && pair.isActive) {
- previousCollision = pair.collision;
- } else {
- previousCollision = null;
- }
-
- // narrow phase
- var collision = SAT.collides(partA, partB, previousCollision);
-
-
- if (collision.collided) {
- collisions.push(collision);
- }
- }
- }
- }
- }
- }
-
- return collisions;
- };
-
- /**
- * Returns `true` if both supplied collision filters will allow a collision to occur.
- * See `body.collisionFilter` for more information.
- * @method canCollide
- * @param {} filterA
- * @param {} filterB
- * @return {bool} `true` if collision can occur
- */
- Detector.canCollide = function(filterA, filterB) {
- if (filterA.group === filterB.group && filterA.group !== 0)
- return filterA.group > 0;
-
- return (filterA.mask & filterB.category) !== 0 && (filterB.mask & filterA.category) !== 0;
- };
-
-})();
-
-},{"../geometry/Bounds":26,"./Pair":7,"./SAT":11}],6:[function(_dereq_,module,exports){
-/**
-* The `Matter.Grid` module contains methods for creating and manipulating collision broadphase grid structures.
-*
-* @class Grid
-*/
-
-var Grid = {};
-
-module.exports = Grid;
-
-var Pair = _dereq_('./Pair');
-var Detector = _dereq_('./Detector');
-var Common = _dereq_('../core/Common');
-
-(function() {
-
- /**
- * Creates a new grid.
- * @method create
- * @param {} options
- * @return {grid} A new grid
- */
- Grid.create = function(options) {
- var defaults = {
- controller: Grid,
- detector: Detector.collisions,
- buckets: {},
- pairs: {},
- pairsList: [],
- bucketWidth: 48,
- bucketHeight: 48
- };
-
- return Common.extend(defaults, options);
- };
-
- /**
- * The width of a single grid bucket.
- *
- * @property bucketWidth
- * @type number
- * @default 48
- */
-
- /**
- * The height of a single grid bucket.
- *
- * @property bucketHeight
- * @type number
- * @default 48
- */
-
- /**
- * Updates the grid.
- * @method update
- * @param {grid} grid
- * @param {body[]} bodies
- * @param {engine} engine
- * @param {boolean} forceUpdate
- */
- Grid.update = function(grid, bodies, engine, forceUpdate) {
- var i, col, row,
- world = engine.world,
- buckets = grid.buckets,
- bucket,
- bucketId,
- gridChanged = false;
-
-
- for (i = 0; i < bodies.length; i++) {
- var body = bodies[i];
-
- if (body.isSleeping && !forceUpdate)
- continue;
-
- // don't update out of world bodies
- if (body.bounds.max.x < world.bounds.min.x || body.bounds.min.x > world.bounds.max.x
- || body.bounds.max.y < world.bounds.min.y || body.bounds.min.y > world.bounds.max.y)
- continue;
-
- var newRegion = Grid._getRegion(grid, body);
-
- // if the body has changed grid region
- if (!body.region || newRegion.id !== body.region.id || forceUpdate) {
-
-
- if (!body.region || forceUpdate)
- body.region = newRegion;
-
- var union = Grid._regionUnion(newRegion, body.region);
-
- // update grid buckets affected by region change
- // iterate over the union of both regions
- for (col = union.startCol; col <= union.endCol; col++) {
- for (row = union.startRow; row <= union.endRow; row++) {
- bucketId = Grid._getBucketId(col, row);
- bucket = buckets[bucketId];
-
- var isInsideNewRegion = (col >= newRegion.startCol && col <= newRegion.endCol
- && row >= newRegion.startRow && row <= newRegion.endRow);
-
- var isInsideOldRegion = (col >= body.region.startCol && col <= body.region.endCol
- && row >= body.region.startRow && row <= body.region.endRow);
-
- // remove from old region buckets
- if (!isInsideNewRegion && isInsideOldRegion) {
- if (isInsideOldRegion) {
- if (bucket)
- Grid._bucketRemoveBody(grid, bucket, body);
- }
- }
-
- // add to new region buckets
- if (body.region === newRegion || (isInsideNewRegion && !isInsideOldRegion) || forceUpdate) {
- if (!bucket)
- bucket = Grid._createBucket(buckets, bucketId);
- Grid._bucketAddBody(grid, bucket, body);
- }
- }
- }
-
- // set the new region
- body.region = newRegion;
-
- // flag changes so we can update pairs
- gridChanged = true;
- }
- }
-
- // update pairs list only if pairs changed (i.e. a body changed region)
- if (gridChanged)
- grid.pairsList = Grid._createActivePairsList(grid);
- };
-
- /**
- * Clears the grid.
- * @method clear
- * @param {grid} grid
- */
- Grid.clear = function(grid) {
- grid.buckets = {};
- grid.pairs = {};
- grid.pairsList = [];
- };
-
- /**
- * Finds the union of two regions.
- * @method _regionUnion
- * @private
- * @param {} regionA
- * @param {} regionB
- * @return {} region
- */
- Grid._regionUnion = function(regionA, regionB) {
- var startCol = Math.min(regionA.startCol, regionB.startCol),
- endCol = Math.max(regionA.endCol, regionB.endCol),
- startRow = Math.min(regionA.startRow, regionB.startRow),
- endRow = Math.max(regionA.endRow, regionB.endRow);
-
- return Grid._createRegion(startCol, endCol, startRow, endRow);
- };
-
- /**
- * Gets the region a given body falls in for a given grid.
- * @method _getRegion
- * @private
- * @param {} grid
- * @param {} body
- * @return {} region
- */
- Grid._getRegion = function(grid, body) {
- var bounds = body.bounds,
- startCol = Math.floor(bounds.min.x / grid.bucketWidth),
- endCol = Math.floor(bounds.max.x / grid.bucketWidth),
- startRow = Math.floor(bounds.min.y / grid.bucketHeight),
- endRow = Math.floor(bounds.max.y / grid.bucketHeight);
-
- return Grid._createRegion(startCol, endCol, startRow, endRow);
- };
-
- /**
- * Creates a region.
- * @method _createRegion
- * @private
- * @param {} startCol
- * @param {} endCol
- * @param {} startRow
- * @param {} endRow
- * @return {} region
- */
- Grid._createRegion = function(startCol, endCol, startRow, endRow) {
- return {
- id: startCol + ',' + endCol + ',' + startRow + ',' + endRow,
- startCol: startCol,
- endCol: endCol,
- startRow: startRow,
- endRow: endRow
- };
- };
-
- /**
- * Gets the bucket id at the given position.
- * @method _getBucketId
- * @private
- * @param {} column
- * @param {} row
- * @return {string} bucket id
- */
- Grid._getBucketId = function(column, row) {
- return 'C' + column + 'R' + row;
- };
-
- /**
- * Creates a bucket.
- * @method _createBucket
- * @private
- * @param {} buckets
- * @param {} bucketId
- * @return {} bucket
- */
- Grid._createBucket = function(buckets, bucketId) {
- var bucket = buckets[bucketId] = [];
- return bucket;
- };
-
- /**
- * Adds a body to a bucket.
- * @method _bucketAddBody
- * @private
- * @param {} grid
- * @param {} bucket
- * @param {} body
- */
- Grid._bucketAddBody = function(grid, bucket, body) {
- // add new pairs
- for (var i = 0; i < bucket.length; i++) {
- var bodyB = bucket[i];
-
- if (body.id === bodyB.id || (body.isStatic && bodyB.isStatic))
- continue;
-
- // keep track of the number of buckets the pair exists in
- // important for Grid.update to work
- var pairId = Pair.id(body, bodyB),
- pair = grid.pairs[pairId];
-
- if (pair) {
- pair[2] += 1;
- } else {
- grid.pairs[pairId] = [body, bodyB, 1];
- }
- }
-
- // add to bodies (after pairs, otherwise pairs with self)
- bucket.push(body);
- };
-
- /**
- * Removes a body from a bucket.
- * @method _bucketRemoveBody
- * @private
- * @param {} grid
- * @param {} bucket
- * @param {} body
- */
- Grid._bucketRemoveBody = function(grid, bucket, body) {
- // remove from bucket
- bucket.splice(Common.indexOf(bucket, body), 1);
-
- // update pair counts
- for (var i = 0; i < bucket.length; i++) {
- // keep track of the number of buckets the pair exists in
- // important for _createActivePairsList to work
- var bodyB = bucket[i],
- pairId = Pair.id(body, bodyB),
- pair = grid.pairs[pairId];
-
- if (pair)
- pair[2] -= 1;
- }
- };
-
- /**
- * Generates a list of the active pairs in the grid.
- * @method _createActivePairsList
- * @private
- * @param {} grid
- * @return [] pairs
- */
- Grid._createActivePairsList = function(grid) {
- var pairKeys,
- pair,
- pairs = [];
-
- // grid.pairs is used as a hashmap
- pairKeys = Common.keys(grid.pairs);
-
- // iterate over grid.pairs
- for (var k = 0; k < pairKeys.length; k++) {
- pair = grid.pairs[pairKeys[k]];
-
- // if pair exists in at least one bucket
- // it is a pair that needs further collision testing so push it
- if (pair[2] > 0) {
- pairs.push(pair);
- } else {
- delete grid.pairs[pairKeys[k]];
- }
- }
-
- return pairs;
- };
-
-})();
-
-},{"../core/Common":14,"./Detector":5,"./Pair":7}],7:[function(_dereq_,module,exports){
-/**
-* The `Matter.Pair` module contains methods for creating and manipulating collision pairs.
-*
-* @class Pair
-*/
-
-var Pair = {};
-
-module.exports = Pair;
-
-var Contact = _dereq_('./Contact');
-
-(function() {
-
- /**
- * Creates a pair.
- * @method create
- * @param {collision} collision
- * @param {number} timestamp
- * @return {pair} A new pair
- */
- Pair.create = function(collision, timestamp) {
- var bodyA = collision.bodyA,
- bodyB = collision.bodyB,
- parentA = collision.parentA,
- parentB = collision.parentB;
-
- var pair = {
- id: Pair.id(bodyA, bodyB),
- bodyA: bodyA,
- bodyB: bodyB,
- contacts: {},
- activeContacts: [],
- separation: 0,
- isActive: true,
- isSensor: bodyA.isSensor || bodyB.isSensor,
- timeCreated: timestamp,
- timeUpdated: timestamp,
- inverseMass: parentA.inverseMass + parentB.inverseMass,
- friction: Math.min(parentA.friction, parentB.friction),
- frictionStatic: Math.max(parentA.frictionStatic, parentB.frictionStatic),
- restitution: Math.max(parentA.restitution, parentB.restitution),
- slop: Math.max(parentA.slop, parentB.slop)
- };
-
- Pair.update(pair, collision, timestamp);
-
- return pair;
- };
-
- /**
- * Updates a pair given a collision.
- * @method update
- * @param {pair} pair
- * @param {collision} collision
- * @param {number} timestamp
- */
- Pair.update = function(pair, collision, timestamp) {
- var contacts = pair.contacts,
- supports = collision.supports,
- activeContacts = pair.activeContacts,
- parentA = collision.parentA,
- parentB = collision.parentB;
-
- pair.collision = collision;
- pair.inverseMass = parentA.inverseMass + parentB.inverseMass;
- pair.friction = Math.min(parentA.friction, parentB.friction);
- pair.frictionStatic = Math.max(parentA.frictionStatic, parentB.frictionStatic);
- pair.restitution = Math.max(parentA.restitution, parentB.restitution);
- pair.slop = Math.max(parentA.slop, parentB.slop);
- activeContacts.length = 0;
-
- if (collision.collided) {
- for (var i = 0; i < supports.length; i++) {
- var support = supports[i],
- contactId = Contact.id(support),
- contact = contacts[contactId];
-
- if (contact) {
- activeContacts.push(contact);
- } else {
- activeContacts.push(contacts[contactId] = Contact.create(support));
- }
- }
-
- pair.separation = collision.depth;
- Pair.setActive(pair, true, timestamp);
- } else {
- if (pair.isActive === true)
- Pair.setActive(pair, false, timestamp);
- }
- };
-
- /**
- * Set a pair as active or inactive.
- * @method setActive
- * @param {pair} pair
- * @param {bool} isActive
- * @param {number} timestamp
- */
- Pair.setActive = function(pair, isActive, timestamp) {
- if (isActive) {
- pair.isActive = true;
- pair.timeUpdated = timestamp;
- } else {
- pair.isActive = false;
- pair.activeContacts.length = 0;
- }
- };
-
- /**
- * Get the id for the given pair.
- * @method id
- * @param {body} bodyA
- * @param {body} bodyB
- * @return {string} Unique pairId
- */
- Pair.id = function(bodyA, bodyB) {
- if (bodyA.id < bodyB.id) {
- return 'A' + bodyA.id + 'B' + bodyB.id;
- } else {
- return 'A' + bodyB.id + 'B' + bodyA.id;
- }
- };
-
-})();
-
-},{"./Contact":4}],8:[function(_dereq_,module,exports){
-/**
-* The `Matter.Pairs` module contains methods for creating and manipulating collision pair sets.
-*
-* @class Pairs
-*/
-
-var Pairs = {};
-
-module.exports = Pairs;
-
-var Pair = _dereq_('./Pair');
-var Common = _dereq_('../core/Common');
-
-(function() {
-
- Pairs._pairMaxIdleLife = 1000;
-
- /**
- * Creates a new pairs structure.
- * @method create
- * @param {object} options
- * @return {pairs} A new pairs structure
- */
- Pairs.create = function(options) {
- return Common.extend({
- table: {},
- list: [],
- collisionStart: [],
- collisionActive: [],
- collisionEnd: []
- }, options);
- };
-
- /**
- * Updates pairs given a list of collisions.
- * @method update
- * @param {object} pairs
- * @param {collision[]} collisions
- * @param {number} timestamp
- */
- Pairs.update = function(pairs, collisions, timestamp) {
- var pairsList = pairs.list,
- pairsTable = pairs.table,
- collisionStart = pairs.collisionStart,
- collisionEnd = pairs.collisionEnd,
- collisionActive = pairs.collisionActive,
- activePairIds = [],
- collision,
- pairId,
- pair,
- i;
-
- // clear collision state arrays, but maintain old reference
- collisionStart.length = 0;
- collisionEnd.length = 0;
- collisionActive.length = 0;
-
- for (i = 0; i < collisions.length; i++) {
- collision = collisions[i];
-
- if (collision.collided) {
- pairId = Pair.id(collision.bodyA, collision.bodyB);
- activePairIds.push(pairId);
-
- pair = pairsTable[pairId];
-
- if (pair) {
- // pair already exists (but may or may not be active)
- if (pair.isActive) {
- // pair exists and is active
- collisionActive.push(pair);
- } else {
- // pair exists but was inactive, so a collision has just started again
- collisionStart.push(pair);
- }
-
- // update the pair
- Pair.update(pair, collision, timestamp);
- } else {
- // pair did not exist, create a new pair
- pair = Pair.create(collision, timestamp);
- pairsTable[pairId] = pair;
-
- // push the new pair
- collisionStart.push(pair);
- pairsList.push(pair);
- }
- }
- }
-
- // deactivate previously active pairs that are now inactive
- for (i = 0; i < pairsList.length; i++) {
- pair = pairsList[i];
- if (pair.isActive && Common.indexOf(activePairIds, pair.id) === -1) {
- Pair.setActive(pair, false, timestamp);
- collisionEnd.push(pair);
+ if (body.sleepCounter >= body.sleepThreshold)
+ Sleeping.set(body, true);
+ } else if (body.sleepCounter > 0) {
+ body.sleepCounter -= 1;
}
}
};
-
- /**
- * Finds and removes pairs that have been inactive for a set amount of time.
- * @method removeOld
- * @param {object} pairs
- * @param {number} timestamp
- */
- Pairs.removeOld = function(pairs, timestamp) {
- var pairsList = pairs.list,
- pairsTable = pairs.table,
- indexesToRemove = [],
- pair,
- collision,
- pairIndex,
- i;
-
- for (i = 0; i < pairsList.length; i++) {
- pair = pairsList[i];
- collision = pair.collision;
-
- // never remove sleeping pairs
- if (collision.bodyA.isSleeping || collision.bodyB.isSleeping) {
- pair.timeUpdated = timestamp;
- continue;
- }
-
- // if pair is inactive for too long, mark it to be removed
- if (timestamp - pair.timeUpdated > Pairs._pairMaxIdleLife) {
- indexesToRemove.push(i);
- }
- }
-
- // remove marked pairs
- for (i = 0; i < indexesToRemove.length; i++) {
- pairIndex = indexesToRemove[i] - i;
- pair = pairsList[pairIndex];
- delete pairsTable[pair.id];
- pairsList.splice(pairIndex, 1);
- }
- };
/**
- * Clears the given pairs structure.
- * @method clear
- * @param {pairs} pairs
- * @return {pairs} pairs
- */
- Pairs.clear = function(pairs) {
- pairs.table = {};
- pairs.list.length = 0;
- pairs.collisionStart.length = 0;
- pairs.collisionActive.length = 0;
- pairs.collisionEnd.length = 0;
- return pairs;
- };
-
-})();
-
-},{"../core/Common":14,"./Pair":7}],9:[function(_dereq_,module,exports){
-/**
-* The `Matter.Query` module contains methods for performing collision queries.
-*
-* See the included usage [examples](https://github.com/liabru/matter-js/tree/master/examples).
-*
-* @class Query
-*/
-
-var Query = {};
-
-module.exports = Query;
-
-var Vector = _dereq_('../geometry/Vector');
-var SAT = _dereq_('./SAT');
-var Bounds = _dereq_('../geometry/Bounds');
-var Bodies = _dereq_('../factory/Bodies');
-var Vertices = _dereq_('../geometry/Vertices');
-
-(function() {
-
- /**
- * Returns a list of collisions between `body` and `bodies`.
- * @method collides
- * @param {body} body
- * @param {body[]} bodies
- * @return {object[]} Collisions
- */
- Query.collides = function(body, bodies) {
- var collisions = [];
-
- for (var i = 0; i < bodies.length; i++) {
- var bodyA = bodies[i];
-
- if (Bounds.overlaps(bodyA.bounds, body.bounds)) {
- for (var j = bodyA.parts.length === 1 ? 0 : 1; j < bodyA.parts.length; j++) {
- var part = bodyA.parts[j];
-
- if (Bounds.overlaps(part.bounds, body.bounds)) {
- var collision = SAT.collides(part, body);
-
- if (collision.collided) {
- collisions.push(collision);
- break;
- }
- }
- }
- }
- }
-
- return collisions;
- };
-
- /**
- * Casts a ray segment against a set of bodies and returns all collisions, ray width is optional. Intersection points are not provided.
- * @method ray
- * @param {body[]} bodies
- * @param {vector} startPoint
- * @param {vector} endPoint
- * @param {number} [rayWidth]
- * @return {object[]} Collisions
- */
- Query.ray = function(bodies, startPoint, endPoint, rayWidth) {
- rayWidth = rayWidth || 1e-100;
-
- var rayAngle = Vector.angle(startPoint, endPoint),
- rayLength = Vector.magnitude(Vector.sub(startPoint, endPoint)),
- rayX = (endPoint.x + startPoint.x) * 0.5,
- rayY = (endPoint.y + startPoint.y) * 0.5,
- ray = Bodies.rectangle(rayX, rayY, rayLength, rayWidth, { angle: rayAngle }),
- collisions = Query.collides(ray, bodies);
-
- for (var i = 0; i < collisions.length; i += 1) {
- var collision = collisions[i];
- collision.body = collision.bodyB = collision.bodyA;
- }
-
- return collisions;
- };
-
- /**
- * Returns all bodies whose bounds are inside (or outside if set) the given set of bounds, from the given set of bodies.
- * @method region
- * @param {body[]} bodies
- * @param {bounds} bounds
- * @param {bool} [outside=false]
- * @return {body[]} The bodies matching the query
- */
- Query.region = function(bodies, bounds, outside) {
- var result = [];
-
- for (var i = 0; i < bodies.length; i++) {
- var body = bodies[i],
- overlaps = Bounds.overlaps(body.bounds, bounds);
- if ((overlaps && !outside) || (!overlaps && outside))
- result.push(body);
- }
-
- return result;
- };
-
- /**
- * Returns all bodies whose vertices contain the given point, from the given set of bodies.
- * @method point
- * @param {body[]} bodies
- * @param {vector} point
- * @return {body[]} The bodies matching the query
- */
- Query.point = function(bodies, point) {
- var result = [];
-
- for (var i = 0; i < bodies.length; i++) {
- var body = bodies[i];
-
- if (Bounds.contains(body.bounds, point)) {
- for (var j = body.parts.length === 1 ? 0 : 1; j < body.parts.length; j++) {
- var part = body.parts[j];
-
- if (Bounds.contains(part.bounds, point)
- && Vertices.contains(part.vertices, point)) {
- result.push(body);
- break;
- }
- }
- }
- }
-
- return result;
- };
-
-})();
-
-},{"../factory/Bodies":23,"../geometry/Bounds":26,"../geometry/Vector":28,"../geometry/Vertices":29,"./SAT":11}],10:[function(_dereq_,module,exports){
-/**
-* The `Matter.Resolver` module contains methods for resolving collision pairs.
-*
-* @class Resolver
-*/
-
-var Resolver = {};
-
-module.exports = Resolver;
-
-var Vertices = _dereq_('../geometry/Vertices');
-var Vector = _dereq_('../geometry/Vector');
-var Common = _dereq_('../core/Common');
-var Bounds = _dereq_('../geometry/Bounds');
-
-(function() {
-
- Resolver._restingThresh = 4;
- Resolver._restingThreshTangent = 6;
- Resolver._positionDampen = 0.9;
- Resolver._positionWarming = 0.8;
- Resolver._frictionNormalMultiplier = 5;
-
- /**
- * Prepare pairs for position solving.
- * @method preSolvePosition
- * @param {pair[]} pairs
- */
- Resolver.preSolvePosition = function(pairs) {
- var i,
- pair,
- activeCount;
-
- // find total contacts on each body
- for (i = 0; i < pairs.length; i++) {
- pair = pairs[i];
-
- if (!pair.isActive)
- continue;
-
- activeCount = pair.activeContacts.length;
- pair.collision.parentA.totalContacts += activeCount;
- pair.collision.parentB.totalContacts += activeCount;
- }
- };
-
- /**
- * Find a solution for pair positions.
- * @method solvePosition
+ * Given a set of colliding pairs, wakes the sleeping bodies involved.
+ * @method afterCollisions
* @param {pair[]} pairs
* @param {number} timeScale
*/
- Resolver.solvePosition = function(pairs, timeScale) {
- var i,
- pair,
- collision,
- bodyA,
- bodyB,
- normal,
- bodyBtoA,
- contactShare,
- positionImpulse,
- contactCount = {},
- tempA = Vector._temp[0],
- tempB = Vector._temp[1],
- tempC = Vector._temp[2],
- tempD = Vector._temp[3];
+ Sleeping.afterCollisions = function(pairs, timeScale) {
+ var timeFactor = timeScale * timeScale * timeScale;
- // find impulses required to resolve penetration
- for (i = 0; i < pairs.length; i++) {
- pair = pairs[i];
-
- if (!pair.isActive || pair.isSensor)
- continue;
-
- collision = pair.collision;
- bodyA = collision.parentA;
- bodyB = collision.parentB;
- normal = collision.normal;
-
- // get current separation between body edges involved in collision
- bodyBtoA = Vector.sub(Vector.add(bodyB.positionImpulse, bodyB.position, tempA),
- Vector.add(bodyA.positionImpulse,
- Vector.sub(bodyB.position, collision.penetration, tempB), tempC), tempD);
-
- pair.separation = Vector.dot(normal, bodyBtoA);
- }
-
- for (i = 0; i < pairs.length; i++) {
- pair = pairs[i];
-
- if (!pair.isActive || pair.isSensor)
- continue;
-
- collision = pair.collision;
- bodyA = collision.parentA;
- bodyB = collision.parentB;
- normal = collision.normal;
- positionImpulse = (pair.separation - pair.slop) * timeScale;
-
- if (bodyA.isStatic || bodyB.isStatic)
- positionImpulse *= 2;
-
- if (!(bodyA.isStatic || bodyA.isSleeping)) {
- contactShare = Resolver._positionDampen / bodyA.totalContacts;
- bodyA.positionImpulse.x += normal.x * positionImpulse * contactShare;
- bodyA.positionImpulse.y += normal.y * positionImpulse * contactShare;
- }
-
- if (!(bodyB.isStatic || bodyB.isSleeping)) {
- contactShare = Resolver._positionDampen / bodyB.totalContacts;
- bodyB.positionImpulse.x -= normal.x * positionImpulse * contactShare;
- bodyB.positionImpulse.y -= normal.y * positionImpulse * contactShare;
- }
- }
- };
-
- /**
- * Apply position resolution.
- * @method postSolvePosition
- * @param {body[]} bodies
- */
- Resolver.postSolvePosition = function(bodies) {
- for (var i = 0; i < bodies.length; i++) {
- var body = bodies[i];
-
- // reset contact count
- body.totalContacts = 0;
-
- if (body.positionImpulse.x !== 0 || body.positionImpulse.y !== 0) {
- // update body geometry
- for (var j = 0; j < body.parts.length; j++) {
- var part = body.parts[j];
- Vertices.translate(part.vertices, body.positionImpulse);
- Bounds.update(part.bounds, part.vertices, body.velocity);
- part.position.x += body.positionImpulse.x;
- part.position.y += body.positionImpulse.y;
- }
-
- // move the body without changing velocity
- body.positionPrev.x += body.positionImpulse.x;
- body.positionPrev.y += body.positionImpulse.y;
-
- if (Vector.dot(body.positionImpulse, body.velocity) < 0) {
- // reset cached impulse if the body has velocity along it
- body.positionImpulse.x = 0;
- body.positionImpulse.y = 0;
- } else {
- // warm the next iteration
- body.positionImpulse.x *= Resolver._positionWarming;
- body.positionImpulse.y *= Resolver._positionWarming;
- }
- }
- }
- };
-
- /**
- * Prepare pairs for velocity solving.
- * @method preSolveVelocity
- * @param {pair[]} pairs
- */
- Resolver.preSolveVelocity = function(pairs) {
- var i,
- j,
- pair,
- contacts,
- collision,
- bodyA,
- bodyB,
- normal,
- tangent,
- contact,
- contactVertex,
- normalImpulse,
- tangentImpulse,
- offset,
- impulse = Vector._temp[0],
- tempA = Vector._temp[1];
-
- for (i = 0; i < pairs.length; i++) {
- pair = pairs[i];
-
- if (!pair.isActive || pair.isSensor)
- continue;
-
- contacts = pair.activeContacts;
- collision = pair.collision;
- bodyA = collision.parentA;
- bodyB = collision.parentB;
- normal = collision.normal;
- tangent = collision.tangent;
-
- // resolve each contact
- for (j = 0; j < contacts.length; j++) {
- contact = contacts[j];
- contactVertex = contact.vertex;
- normalImpulse = contact.normalImpulse;
- tangentImpulse = contact.tangentImpulse;
-
- if (normalImpulse !== 0 || tangentImpulse !== 0) {
- // total impulse from contact
- impulse.x = (normal.x * normalImpulse) + (tangent.x * tangentImpulse);
- impulse.y = (normal.y * normalImpulse) + (tangent.y * tangentImpulse);
-
- // apply impulse from contact
- if (!(bodyA.isStatic || bodyA.isSleeping)) {
- offset = Vector.sub(contactVertex, bodyA.position, tempA);
- bodyA.positionPrev.x += impulse.x * bodyA.inverseMass;
- bodyA.positionPrev.y += impulse.y * bodyA.inverseMass;
- bodyA.anglePrev += Vector.cross(offset, impulse) * bodyA.inverseInertia;
- }
-
- if (!(bodyB.isStatic || bodyB.isSleeping)) {
- offset = Vector.sub(contactVertex, bodyB.position, tempA);
- bodyB.positionPrev.x -= impulse.x * bodyB.inverseMass;
- bodyB.positionPrev.y -= impulse.y * bodyB.inverseMass;
- bodyB.anglePrev -= Vector.cross(offset, impulse) * bodyB.inverseInertia;
- }
- }
- }
- }
- };
-
- /**
- * Find a solution for pair velocities.
- * @method solveVelocity
- * @param {pair[]} pairs
- * @param {number} timeScale
- */
- Resolver.solveVelocity = function(pairs, timeScale) {
- var timeScaleSquared = timeScale * timeScale,
- impulse = Vector._temp[0],
- tempA = Vector._temp[1],
- tempB = Vector._temp[2],
- tempC = Vector._temp[3],
- tempD = Vector._temp[4],
- tempE = Vector._temp[5];
-
+ // wake up bodies involved in collisions
for (var i = 0; i < pairs.length; i++) {
var pair = pairs[i];
- if (!pair.isActive || pair.isSensor)
+ // don't wake inactive pairs
+ if (!pair.isActive)
continue;
-
+
var collision = pair.collision,
- bodyA = collision.parentA,
- bodyB = collision.parentB,
- normal = collision.normal,
- tangent = collision.tangent,
- contacts = pair.activeContacts,
- contactShare = 1 / contacts.length;
+ bodyA = collision.bodyA.parent,
+ bodyB = collision.bodyB.parent;
+
+ // don't wake if at least one body is static
+ if ((bodyA.isSleeping && bodyB.isSleeping) || bodyA.isStatic || bodyB.isStatic)
+ continue;
+
+ if (bodyA.isSleeping || bodyB.isSleeping) {
+ var sleepingBody = (bodyA.isSleeping && !bodyA.isStatic) ? bodyA : bodyB,
+ movingBody = sleepingBody === bodyA ? bodyB : bodyA;
- // update body velocities
- bodyA.velocity.x = bodyA.position.x - bodyA.positionPrev.x;
- bodyA.velocity.y = bodyA.position.y - bodyA.positionPrev.y;
- bodyB.velocity.x = bodyB.position.x - bodyB.positionPrev.x;
- bodyB.velocity.y = bodyB.position.y - bodyB.positionPrev.y;
- bodyA.angularVelocity = bodyA.angle - bodyA.anglePrev;
- bodyB.angularVelocity = bodyB.angle - bodyB.anglePrev;
-
- // resolve each contact
- for (var j = 0; j < contacts.length; j++) {
- var contact = contacts[j],
- contactVertex = contact.vertex,
- offsetA = Vector.sub(contactVertex, bodyA.position, tempA),
- offsetB = Vector.sub(contactVertex, bodyB.position, tempB),
- velocityPointA = Vector.add(bodyA.velocity, Vector.mult(Vector.perp(offsetA), bodyA.angularVelocity), tempC),
- velocityPointB = Vector.add(bodyB.velocity, Vector.mult(Vector.perp(offsetB), bodyB.angularVelocity), tempD),
- relativeVelocity = Vector.sub(velocityPointA, velocityPointB, tempE),
- normalVelocity = Vector.dot(normal, relativeVelocity);
-
- var tangentVelocity = Vector.dot(tangent, relativeVelocity),
- tangentSpeed = Math.abs(tangentVelocity),
- tangentVelocityDirection = Common.sign(tangentVelocity);
-
- // raw impulses
- var normalImpulse = (1 + pair.restitution) * normalVelocity,
- normalForce = Common.clamp(pair.separation + normalVelocity, 0, 1) * Resolver._frictionNormalMultiplier;
-
- // coulomb friction
- var tangentImpulse = tangentVelocity,
- maxFriction = Infinity;
-
- if (tangentSpeed > pair.friction * pair.frictionStatic * normalForce * timeScaleSquared) {
- maxFriction = tangentSpeed;
- tangentImpulse = Common.clamp(
- pair.friction * tangentVelocityDirection * timeScaleSquared,
- -maxFriction, maxFriction
- );
+ if (!sleepingBody.isStatic && movingBody.motion > Sleeping._motionWakeThreshold * timeFactor) {
+ Sleeping.set(sleepingBody, false);
}
+ }
+ }
+ };
+
+ /**
+ * Set a body as sleeping or awake.
+ * @method set
+ * @param {body} body
+ * @param {boolean} isSleeping
+ */
+ Sleeping.set = function(body, isSleeping) {
+ var wasSleeping = body.isSleeping;
- // modify impulses accounting for mass, inertia and offset
- var oAcN = Vector.cross(offsetA, normal),
- oBcN = Vector.cross(offsetB, normal),
- share = contactShare / (bodyA.inverseMass + bodyB.inverseMass + bodyA.inverseInertia * oAcN * oAcN + bodyB.inverseInertia * oBcN * oBcN);
+ if (isSleeping) {
+ body.isSleeping = true;
+ body.sleepCounter = body.sleepThreshold;
- normalImpulse *= share;
- tangentImpulse *= share;
+ body.positionImpulse.x = 0;
+ body.positionImpulse.y = 0;
- // handle high velocity and resting collisions separately
- if (normalVelocity < 0 && normalVelocity * normalVelocity > Resolver._restingThresh * timeScaleSquared) {
- // high normal velocity so clear cached contact normal impulse
- contact.normalImpulse = 0;
- } else {
- // solve resting collision constraints using Erin Catto's method (GDC08)
- // impulse constraint tends to 0
- var contactNormalImpulse = contact.normalImpulse;
- contact.normalImpulse = Math.min(contact.normalImpulse + normalImpulse, 0);
- normalImpulse = contact.normalImpulse - contactNormalImpulse;
- }
+ body.positionPrev.x = body.position.x;
+ body.positionPrev.y = body.position.y;
- // handle high velocity and resting collisions separately
- if (tangentVelocity * tangentVelocity > Resolver._restingThreshTangent * timeScaleSquared) {
- // high tangent velocity so clear cached contact tangent impulse
- contact.tangentImpulse = 0;
- } else {
- // solve resting collision constraints using Erin Catto's method (GDC08)
- // tangent impulse tends to -tangentSpeed or +tangentSpeed
- var contactTangentImpulse = contact.tangentImpulse;
- contact.tangentImpulse = Common.clamp(contact.tangentImpulse + tangentImpulse, -maxFriction, maxFriction);
- tangentImpulse = contact.tangentImpulse - contactTangentImpulse;
- }
+ body.anglePrev = body.angle;
+ body.speed = 0;
+ body.angularSpeed = 0;
+ body.motion = 0;
- // total impulse from contact
- impulse.x = (normal.x * normalImpulse) + (tangent.x * tangentImpulse);
- impulse.y = (normal.y * normalImpulse) + (tangent.y * tangentImpulse);
-
- // apply impulse from contact
- if (!(bodyA.isStatic || bodyA.isSleeping)) {
- bodyA.positionPrev.x += impulse.x * bodyA.inverseMass;
- bodyA.positionPrev.y += impulse.y * bodyA.inverseMass;
- bodyA.anglePrev += Vector.cross(offsetA, impulse) * bodyA.inverseInertia;
- }
+ if (!wasSleeping) {
+ Events.trigger(body, 'sleepStart');
+ }
+ } else {
+ body.isSleeping = false;
+ body.sleepCounter = 0;
- if (!(bodyB.isStatic || bodyB.isSleeping)) {
- bodyB.positionPrev.x -= impulse.x * bodyB.inverseMass;
- bodyB.positionPrev.y -= impulse.y * bodyB.inverseMass;
- bodyB.anglePrev -= Vector.cross(offsetB, impulse) * bodyB.inverseInertia;
- }
+ if (wasSleeping) {
+ Events.trigger(body, 'sleepEnd');
}
}
};
})();
-},{"../core/Common":14,"../geometry/Bounds":26,"../geometry/Vector":28,"../geometry/Vertices":29}],11:[function(_dereq_,module,exports){
-/**
-* The `Matter.SAT` module contains methods for detecting collisions using the Separating Axis Theorem.
-*
-* @class SAT
-*/
-// TODO: true circles and curves
+/***/ }),
+/* 8 */
+/***/ (function(module, exports, __webpack_require__) {
-var SAT = {};
-
-module.exports = SAT;
-
-var Vertices = _dereq_('../geometry/Vertices');
-var Vector = _dereq_('../geometry/Vector');
-
-(function() {
-
- /**
- * Detect collision between two bodies using the Separating Axis Theorem.
- * @method collides
- * @param {body} bodyA
- * @param {body} bodyB
- * @param {collision} previousCollision
- * @return {collision} collision
- */
- SAT.collides = function(bodyA, bodyB, previousCollision) {
- var overlapAB,
- overlapBA,
- minOverlap,
- collision,
- canReusePrevCol = false;
-
- if (previousCollision) {
- // estimate total motion
- var parentA = bodyA.parent,
- parentB = bodyB.parent,
- motion = parentA.speed * parentA.speed + parentA.angularSpeed * parentA.angularSpeed
- + parentB.speed * parentB.speed + parentB.angularSpeed * parentB.angularSpeed;
-
- // we may be able to (partially) reuse collision result
- // but only safe if collision was resting
- canReusePrevCol = previousCollision && previousCollision.collided && motion < 0.2;
-
- // reuse collision object
- collision = previousCollision;
- } else {
- collision = { collided: false, bodyA: bodyA, bodyB: bodyB };
- }
-
- if (previousCollision && canReusePrevCol) {
- // if we can reuse the collision result
- // we only need to test the previously found axis
- var axisBodyA = collision.axisBody,
- axisBodyB = axisBodyA === bodyA ? bodyB : bodyA,
- axes = [axisBodyA.axes[previousCollision.axisNumber]];
-
- minOverlap = SAT._overlapAxes(axisBodyA.vertices, axisBodyB.vertices, axes);
- collision.reused = true;
-
- if (minOverlap.overlap <= 0) {
- collision.collided = false;
- return collision;
- }
- } else {
- // if we can't reuse a result, perform a full SAT test
-
- overlapAB = SAT._overlapAxes(bodyA.vertices, bodyB.vertices, bodyA.axes);
-
- if (overlapAB.overlap <= 0) {
- collision.collided = false;
- return collision;
- }
-
- overlapBA = SAT._overlapAxes(bodyB.vertices, bodyA.vertices, bodyB.axes);
-
- if (overlapBA.overlap <= 0) {
- collision.collided = false;
- return collision;
- }
-
- if (overlapAB.overlap < overlapBA.overlap) {
- minOverlap = overlapAB;
- collision.axisBody = bodyA;
- } else {
- minOverlap = overlapBA;
- collision.axisBody = bodyB;
- }
-
- // important for reuse later
- collision.axisNumber = minOverlap.axisNumber;
- }
-
- collision.bodyA = bodyA.id < bodyB.id ? bodyA : bodyB;
- collision.bodyB = bodyA.id < bodyB.id ? bodyB : bodyA;
- collision.collided = true;
- collision.depth = minOverlap.overlap;
- collision.parentA = collision.bodyA.parent;
- collision.parentB = collision.bodyB.parent;
-
- bodyA = collision.bodyA;
- bodyB = collision.bodyB;
-
- // ensure normal is facing away from bodyA
- if (Vector.dot(minOverlap.axis, Vector.sub(bodyB.position, bodyA.position)) < 0) {
- collision.normal = {
- x: minOverlap.axis.x,
- y: minOverlap.axis.y
- };
- } else {
- collision.normal = {
- x: -minOverlap.axis.x,
- y: -minOverlap.axis.y
- };
- }
-
- collision.tangent = Vector.perp(collision.normal);
-
- collision.penetration = collision.penetration || {};
- collision.penetration.x = collision.normal.x * collision.depth;
- collision.penetration.y = collision.normal.y * collision.depth;
-
- // find support points, there is always either exactly one or two
- var verticesB = SAT._findSupports(bodyA, bodyB, collision.normal),
- supports = [];
-
- // find the supports from bodyB that are inside bodyA
- if (Vertices.contains(bodyA.vertices, verticesB[0]))
- supports.push(verticesB[0]);
-
- if (Vertices.contains(bodyA.vertices, verticesB[1]))
- supports.push(verticesB[1]);
-
- // find the supports from bodyA that are inside bodyB
- if (supports.length < 2) {
- var verticesA = SAT._findSupports(bodyB, bodyA, Vector.neg(collision.normal));
-
- if (Vertices.contains(bodyB.vertices, verticesA[0]))
- supports.push(verticesA[0]);
-
- if (supports.length < 2 && Vertices.contains(bodyB.vertices, verticesA[1]))
- supports.push(verticesA[1]);
- }
-
- // account for the edge case of overlapping but no vertex containment
- if (supports.length < 1)
- supports = [verticesB[0]];
-
- collision.supports = supports;
-
- return collision;
- };
-
- /**
- * Find the overlap between two sets of vertices.
- * @method _overlapAxes
- * @private
- * @param {} verticesA
- * @param {} verticesB
- * @param {} axes
- * @return result
- */
- SAT._overlapAxes = function(verticesA, verticesB, axes) {
- var projectionA = Vector._temp[0],
- projectionB = Vector._temp[1],
- result = { overlap: Number.MAX_VALUE },
- overlap,
- axis;
-
- for (var i = 0; i < axes.length; i++) {
- axis = axes[i];
-
- SAT._projectToAxis(projectionA, verticesA, axis);
- SAT._projectToAxis(projectionB, verticesB, axis);
-
- overlap = Math.min(projectionA.max - projectionB.min, projectionB.max - projectionA.min);
-
- if (overlap <= 0) {
- result.overlap = overlap;
- return result;
- }
-
- if (overlap < result.overlap) {
- result.overlap = overlap;
- result.axis = axis;
- result.axisNumber = i;
- }
- }
-
- return result;
- };
-
- /**
- * Projects vertices on an axis and returns an interval.
- * @method _projectToAxis
- * @private
- * @param {} projection
- * @param {} vertices
- * @param {} axis
- */
- SAT._projectToAxis = function(projection, vertices, axis) {
- var min = Vector.dot(vertices[0], axis),
- max = min;
-
- for (var i = 1; i < vertices.length; i += 1) {
- var dot = Vector.dot(vertices[i], axis);
-
- if (dot > max) {
- max = dot;
- } else if (dot < min) {
- min = dot;
- }
- }
-
- projection.min = min;
- projection.max = max;
- };
-
- /**
- * Finds supporting vertices given two bodies along a given direction using hill-climbing.
- * @method _findSupports
- * @private
- * @param {} bodyA
- * @param {} bodyB
- * @param {} normal
- * @return [vector]
- */
- SAT._findSupports = function(bodyA, bodyB, normal) {
- var nearestDistance = Number.MAX_VALUE,
- vertexToBody = Vector._temp[0],
- vertices = bodyB.vertices,
- bodyAPosition = bodyA.position,
- distance,
- vertex,
- vertexA,
- vertexB;
-
- // find closest vertex on bodyB
- for (var i = 0; i < vertices.length; i++) {
- vertex = vertices[i];
- vertexToBody.x = vertex.x - bodyAPosition.x;
- vertexToBody.y = vertex.y - bodyAPosition.y;
- distance = -Vector.dot(normal, vertexToBody);
-
- if (distance < nearestDistance) {
- nearestDistance = distance;
- vertexA = vertex;
- }
- }
-
- // find next closest vertex using the two connected to it
- var prevIndex = vertexA.index - 1 >= 0 ? vertexA.index - 1 : vertices.length - 1;
- vertex = vertices[prevIndex];
- vertexToBody.x = vertex.x - bodyAPosition.x;
- vertexToBody.y = vertex.y - bodyAPosition.y;
- nearestDistance = -Vector.dot(normal, vertexToBody);
- vertexB = vertex;
-
- var nextIndex = (vertexA.index + 1) % vertices.length;
- vertex = vertices[nextIndex];
- vertexToBody.x = vertex.x - bodyAPosition.x;
- vertexToBody.y = vertex.y - bodyAPosition.y;
- distance = -Vector.dot(normal, vertexToBody);
- if (distance < nearestDistance) {
- vertexB = vertex;
- }
-
- return [vertexA, vertexB];
- };
-
-})();
-
-},{"../geometry/Vector":28,"../geometry/Vertices":29}],12:[function(_dereq_,module,exports){
/**
* The `Matter.Constraint` module contains methods for creating and manipulating constraints.
* Constraints are used for specifying that a fixed distance must be maintained between two bodies (or a body and a fixed world-space position).
@@ -3560,12 +3766,12 @@ var Constraint = {};
module.exports = Constraint;
-var Vertices = _dereq_('../geometry/Vertices');
-var Vector = _dereq_('../geometry/Vector');
-var Sleeping = _dereq_('../core/Sleeping');
-var Bounds = _dereq_('../geometry/Bounds');
-var Axes = _dereq_('../geometry/Axes');
-var Common = _dereq_('../core/Common');
+var Vertices = __webpack_require__(3);
+var Vector = __webpack_require__(2);
+var Sleeping = __webpack_require__(7);
+var Bounds = __webpack_require__(1);
+var Axes = __webpack_require__(10);
+var Common = __webpack_require__(0);
(function() {
@@ -3848,6 +4054,32 @@ var Common = _dereq_('../core/Common');
}
};
+ /**
+ * Returns the world-space position of `constraint.pointA`, accounting for `constraint.bodyA`.
+ * @method pointAWorld
+ * @param {constraint} constraint
+ * @returns {vector} the world-space position
+ */
+ Constraint.pointAWorld = function(constraint) {
+ return {
+ x: (constraint.bodyA ? constraint.bodyA.position.x : 0) + constraint.pointA.x,
+ y: (constraint.bodyA ? constraint.bodyA.position.y : 0) + constraint.pointA.y
+ };
+ };
+
+ /**
+ * Returns the world-space position of `constraint.pointB`, accounting for `constraint.bodyB`.
+ * @method pointBWorld
+ * @param {constraint} constraint
+ * @returns {vector} the world-space position
+ */
+ Constraint.pointBWorld = function(constraint) {
+ return {
+ x: (constraint.bodyB ? constraint.bodyB.position.x : 0) + constraint.pointB.x,
+ y: (constraint.bodyB ? constraint.bodyB.position.y : 0) + constraint.pointB.y
+ };
+ };
+
/*
*
* Properties Documentation
@@ -4000,1528 +4232,578 @@ var Common = _dereq_('../core/Common');
})();
-},{"../core/Common":14,"../core/Sleeping":22,"../geometry/Axes":25,"../geometry/Bounds":26,"../geometry/Vector":28,"../geometry/Vertices":29}],13:[function(_dereq_,module,exports){
+
+/***/ }),
+/* 9 */
+/***/ (function(module, exports, __webpack_require__) {
+
/**
-* The `Matter.MouseConstraint` module contains methods for creating mouse constraints.
-* Mouse constraints are used for allowing user interaction, providing the ability to move bodies via the mouse or touch.
+* The `Matter.Pair` module contains methods for creating and manipulating collision pairs.
*
-* See the included usage [examples](https://github.com/liabru/matter-js/tree/master/examples).
-*
-* @class MouseConstraint
+* @class Pair
*/
-var MouseConstraint = {};
+var Pair = {};
-module.exports = MouseConstraint;
+module.exports = Pair;
-var Vertices = _dereq_('../geometry/Vertices');
-var Sleeping = _dereq_('../core/Sleeping');
-var Mouse = _dereq_('../core/Mouse');
-var Events = _dereq_('../core/Events');
-var Detector = _dereq_('../collision/Detector');
-var Constraint = _dereq_('./Constraint');
-var Composite = _dereq_('../body/Composite');
-var Common = _dereq_('../core/Common');
-var Bounds = _dereq_('../geometry/Bounds');
+var Contact = __webpack_require__(17);
(function() {
-
+
/**
- * Creates a new mouse constraint.
- * All properties have default values, and many are pre-calculated automatically based on other properties.
- * See the properties section below for detailed information on what you can pass via the `options` object.
+ * Creates a pair.
* @method create
- * @param {engine} engine
- * @param {} options
- * @return {MouseConstraint} A new MouseConstraint
+ * @param {collision} collision
+ * @param {number} timestamp
+ * @return {pair} A new pair
*/
- MouseConstraint.create = function(engine, options) {
- var mouse = (engine ? engine.mouse : null) || (options ? options.mouse : null);
+ Pair.create = function(collision, timestamp) {
+ var bodyA = collision.bodyA,
+ bodyB = collision.bodyB,
+ parentA = collision.parentA,
+ parentB = collision.parentB;
- if (!mouse) {
- if (engine && engine.render && engine.render.canvas) {
- mouse = Mouse.create(engine.render.canvas);
- } else if (options && options.element) {
- mouse = Mouse.create(options.element);
- } else {
- mouse = Mouse.create();
- Common.warn('MouseConstraint.create: options.mouse was undefined, options.element was undefined, may not function as expected');
- }
- }
-
- var constraint = Constraint.create({
- label: 'Mouse Constraint',
- pointA: mouse.position,
- pointB: { x: 0, y: 0 },
- length: 0.01,
- stiffness: 0.1,
- angularStiffness: 1,
- render: {
- strokeStyle: '#90EE90',
- lineWidth: 3
- }
- });
-
- var defaults = {
- type: 'mouseConstraint',
- mouse: mouse,
- element: null,
- body: null,
- constraint: constraint,
- collisionFilter: {
- category: 0x0001,
- mask: 0xFFFFFFFF,
- group: 0
- }
+ var pair = {
+ id: Pair.id(bodyA, bodyB),
+ bodyA: bodyA,
+ bodyB: bodyB,
+ contacts: {},
+ activeContacts: [],
+ separation: 0,
+ isActive: true,
+ confirmedActive: true,
+ isSensor: bodyA.isSensor || bodyB.isSensor,
+ timeCreated: timestamp,
+ timeUpdated: timestamp,
+ inverseMass: parentA.inverseMass + parentB.inverseMass,
+ friction: Math.min(parentA.friction, parentB.friction),
+ frictionStatic: Math.max(parentA.frictionStatic, parentB.frictionStatic),
+ restitution: Math.max(parentA.restitution, parentB.restitution),
+ slop: Math.max(parentA.slop, parentB.slop)
};
- var mouseConstraint = Common.extend(defaults, options);
+ Pair.update(pair, collision, timestamp);
- Events.on(engine, 'beforeUpdate', function() {
- var allBodies = Composite.allBodies(engine.world);
- MouseConstraint.update(mouseConstraint, allBodies);
- MouseConstraint._triggerEvents(mouseConstraint);
- });
-
- return mouseConstraint;
+ return pair;
};
/**
- * Updates the given mouse constraint.
- * @private
+ * Updates a pair given a collision.
* @method update
- * @param {MouseConstraint} mouseConstraint
- * @param {body[]} bodies
+ * @param {pair} pair
+ * @param {collision} collision
+ * @param {number} timestamp
*/
- MouseConstraint.update = function(mouseConstraint, bodies) {
- var mouse = mouseConstraint.mouse,
- constraint = mouseConstraint.constraint,
- body = mouseConstraint.body;
+ Pair.update = function(pair, collision, timestamp) {
+ var contacts = pair.contacts,
+ supports = collision.supports,
+ activeContacts = pair.activeContacts,
+ parentA = collision.parentA,
+ parentB = collision.parentB;
+
+ pair.collision = collision;
+ pair.inverseMass = parentA.inverseMass + parentB.inverseMass;
+ pair.friction = Math.min(parentA.friction, parentB.friction);
+ pair.frictionStatic = Math.max(parentA.frictionStatic, parentB.frictionStatic);
+ pair.restitution = Math.max(parentA.restitution, parentB.restitution);
+ pair.slop = Math.max(parentA.slop, parentB.slop);
+ activeContacts.length = 0;
+
+ if (collision.collided) {
+ for (var i = 0; i < supports.length; i++) {
+ var support = supports[i],
+ contactId = Contact.id(support),
+ contact = contacts[contactId];
- if (mouse.button === 0) {
- if (!constraint.bodyB) {
- for (var i = 0; i < bodies.length; i++) {
- body = bodies[i];
- if (Bounds.contains(body.bounds, mouse.position)
- && Detector.canCollide(body.collisionFilter, mouseConstraint.collisionFilter)) {
- for (var j = body.parts.length > 1 ? 1 : 0; j < body.parts.length; j++) {
- var part = body.parts[j];
- if (Vertices.contains(part.vertices, mouse.position)) {
- constraint.pointA = mouse.position;
- constraint.bodyB = mouseConstraint.body = body;
- constraint.pointB = { x: mouse.position.x - body.position.x, y: mouse.position.y - body.position.y };
- constraint.angleB = body.angle;
-
- Sleeping.set(body, false);
- Events.trigger(mouseConstraint, 'startdrag', { mouse: mouse, body: body });
-
- break;
- }
- }
- }
+ if (contact) {
+ activeContacts.push(contact);
+ } else {
+ activeContacts.push(contacts[contactId] = Contact.create(support));
}
- } else {
- Sleeping.set(constraint.bodyB, false);
- constraint.pointA = mouse.position;
}
- } else {
- constraint.bodyB = mouseConstraint.body = null;
- constraint.pointB = null;
- if (body)
- Events.trigger(mouseConstraint, 'enddrag', { mouse: mouse, body: body });
+ pair.separation = collision.depth;
+ Pair.setActive(pair, true, timestamp);
+ } else {
+ if (pair.isActive === true)
+ Pair.setActive(pair, false, timestamp);
+ }
+ };
+
+ /**
+ * Set a pair as active or inactive.
+ * @method setActive
+ * @param {pair} pair
+ * @param {bool} isActive
+ * @param {number} timestamp
+ */
+ Pair.setActive = function(pair, isActive, timestamp) {
+ if (isActive) {
+ pair.isActive = true;
+ pair.timeUpdated = timestamp;
+ } else {
+ pair.isActive = false;
+ pair.activeContacts.length = 0;
}
};
/**
- * Triggers mouse constraint events.
- * @method _triggerEvents
- * @private
- * @param {mouse} mouseConstraint
+ * Get the id for the given pair.
+ * @method id
+ * @param {body} bodyA
+ * @param {body} bodyB
+ * @return {string} Unique pairId
*/
- MouseConstraint._triggerEvents = function(mouseConstraint) {
- var mouse = mouseConstraint.mouse,
- mouseEvents = mouse.sourceEvents;
-
- if (mouseEvents.mousemove)
- Events.trigger(mouseConstraint, 'mousemove', { mouse: mouse });
-
- if (mouseEvents.mousedown)
- Events.trigger(mouseConstraint, 'mousedown', { mouse: mouse });
-
- if (mouseEvents.mouseup)
- Events.trigger(mouseConstraint, 'mouseup', { mouse: mouse });
-
- // reset the mouse state ready for the next step
- Mouse.clearSourceEvents(mouse);
+ Pair.id = function(bodyA, bodyB) {
+ if (bodyA.id < bodyB.id) {
+ return 'A' + bodyA.id + 'B' + bodyB.id;
+ } else {
+ return 'A' + bodyB.id + 'B' + bodyA.id;
+ }
};
- /*
- *
- * Events Documentation
- *
- */
-
- /**
- * Fired when the mouse has moved (or a touch moves) during the last step
- *
- * @event mousemove
- * @param {} event An event object
- * @param {mouse} event.mouse The engine's mouse instance
- * @param {} event.source The source object of the event
- * @param {} event.name The name of the event
- */
-
- /**
- * Fired when the mouse is down (or a touch has started) during the last step
- *
- * @event mousedown
- * @param {} event An event object
- * @param {mouse} event.mouse The engine's mouse instance
- * @param {} event.source The source object of the event
- * @param {} event.name The name of the event
- */
-
- /**
- * Fired when the mouse is up (or a touch has ended) during the last step
- *
- * @event mouseup
- * @param {} event An event object
- * @param {mouse} event.mouse The engine's mouse instance
- * @param {} event.source The source object of the event
- * @param {} event.name The name of the event
- */
-
- /**
- * Fired when the user starts dragging a body
- *
- * @event startdrag
- * @param {} event An event object
- * @param {mouse} event.mouse The engine's mouse instance
- * @param {body} event.body The body being dragged
- * @param {} event.source The source object of the event
- * @param {} event.name The name of the event
- */
-
- /**
- * Fired when the user ends dragging a body
- *
- * @event enddrag
- * @param {} event An event object
- * @param {mouse} event.mouse The engine's mouse instance
- * @param {body} event.body The body that has stopped being dragged
- * @param {} event.source The source object of the event
- * @param {} event.name The name of the event
- */
-
- /*
- *
- * Properties Documentation
- *
- */
-
- /**
- * A `String` denoting the type of object.
- *
- * @property type
- * @type string
- * @default "constraint"
- * @readOnly
- */
-
- /**
- * The `Mouse` instance in use. If not supplied in `MouseConstraint.create`, one will be created.
- *
- * @property mouse
- * @type mouse
- * @default mouse
- */
-
- /**
- * The `Body` that is currently being moved by the user, or `null` if no body.
- *
- * @property body
- * @type body
- * @default null
- */
-
- /**
- * The `Constraint` object that is used to move the body during interaction.
- *
- * @property constraint
- * @type constraint
- */
-
- /**
- * An `Object` that specifies the collision filter properties.
- * The collision filter allows the user to define which types of body this mouse constraint can interact with.
- * See `body.collisionFilter` for more information.
- *
- * @property collisionFilter
- * @type object
- */
-
})();
-},{"../body/Composite":2,"../collision/Detector":5,"../core/Common":14,"../core/Events":16,"../core/Mouse":19,"../core/Sleeping":22,"../geometry/Bounds":26,"../geometry/Vertices":29,"./Constraint":12}],14:[function(_dereq_,module,exports){
-(function (global){
+
+/***/ }),
+/* 10 */
+/***/ (function(module, exports, __webpack_require__) {
+
/**
-* The `Matter.Common` module contains utility functions that are common to all modules.
+* The `Matter.Axes` module contains methods for creating and manipulating sets of axes.
*
-* @class Common
+* @class Axes
*/
-var Common = {};
+var Axes = {};
-module.exports = Common;
+module.exports = Axes;
+
+var Vector = __webpack_require__(2);
+var Common = __webpack_require__(0);
(function() {
- Common._nextId = 0;
- Common._seed = 0;
- Common._nowStartTime = +(new Date());
+ /**
+ * Creates a new set of axes from the given vertices.
+ * @method fromVertices
+ * @param {vertices} vertices
+ * @return {axes} A new axes from the given vertices
+ */
+ Axes.fromVertices = function(vertices) {
+ var axes = {};
+
+ // find the unique axes, using edge normal gradients
+ for (var i = 0; i < vertices.length; i++) {
+ var j = (i + 1) % vertices.length,
+ normal = Vector.normalise({
+ x: vertices[j].y - vertices[i].y,
+ y: vertices[i].x - vertices[j].x
+ }),
+ gradient = (normal.y === 0) ? Infinity : (normal.x / normal.y);
+
+ // limit precision
+ gradient = gradient.toFixed(3).toString();
+ axes[gradient] = normal;
+ }
+
+ return Common.values(axes);
+ };
/**
- * Extends the object in the first argument using the object in the second argument.
- * @method extend
- * @param {} obj
- * @param {boolean} deep
- * @return {} obj extended
+ * Rotates a set of axes by the given angle.
+ * @method rotate
+ * @param {axes} axes
+ * @param {number} angle
*/
- Common.extend = function(obj, deep) {
- var argsStart,
- args,
- deepClone;
-
- if (typeof deep === 'boolean') {
- argsStart = 2;
- deepClone = deep;
- } else {
- argsStart = 1;
- deepClone = true;
- }
-
- for (var i = argsStart; i < arguments.length; i++) {
- var source = arguments[i];
-
- if (source) {
- for (var prop in source) {
- if (deepClone && source[prop] && source[prop].constructor === Object) {
- if (!obj[prop] || obj[prop].constructor === Object) {
- obj[prop] = obj[prop] || {};
- Common.extend(obj[prop], deepClone, source[prop]);
- } else {
- obj[prop] = source[prop];
- }
- } else {
- obj[prop] = source[prop];
- }
- }
- }
- }
+ Axes.rotate = function(axes, angle) {
+ if (angle === 0)
+ return;
- return obj;
- };
+ var cos = Math.cos(angle),
+ sin = Math.sin(angle);
- /**
- * Creates a new clone of the object, if deep is true references will also be cloned.
- * @method clone
- * @param {} obj
- * @param {bool} deep
- * @return {} obj cloned
- */
- Common.clone = function(obj, deep) {
- return Common.extend({}, deep, obj);
- };
-
- /**
- * Returns the list of keys for the given object.
- * @method keys
- * @param {} obj
- * @return {string[]} keys
- */
- Common.keys = function(obj) {
- if (Object.keys)
- return Object.keys(obj);
-
- // avoid hasOwnProperty for performance
- var keys = [];
- for (var key in obj)
- keys.push(key);
- return keys;
- };
-
- /**
- * Returns the list of values for the given object.
- * @method values
- * @param {} obj
- * @return {array} Array of the objects property values
- */
- Common.values = function(obj) {
- var values = [];
-
- if (Object.keys) {
- var keys = Object.keys(obj);
- for (var i = 0; i < keys.length; i++) {
- values.push(obj[keys[i]]);
- }
- return values;
- }
-
- // avoid hasOwnProperty for performance
- for (var key in obj)
- values.push(obj[key]);
- return values;
- };
-
- /**
- * Gets a value from `base` relative to the `path` string.
- * @method get
- * @param {} obj The base object
- * @param {string} path The path relative to `base`, e.g. 'Foo.Bar.baz'
- * @param {number} [begin] Path slice begin
- * @param {number} [end] Path slice end
- * @return {} The object at the given path
- */
- Common.get = function(obj, path, begin, end) {
- path = path.split('.').slice(begin, end);
-
- for (var i = 0; i < path.length; i += 1) {
- obj = obj[path[i]];
- }
-
- return obj;
- };
-
- /**
- * Sets a value on `base` relative to the given `path` string.
- * @method set
- * @param {} obj The base object
- * @param {string} path The path relative to `base`, e.g. 'Foo.Bar.baz'
- * @param {} val The value to set
- * @param {number} [begin] Path slice begin
- * @param {number} [end] Path slice end
- * @return {} Pass through `val` for chaining
- */
- Common.set = function(obj, path, val, begin, end) {
- var parts = path.split('.').slice(begin, end);
- Common.get(obj, path, 0, -1)[parts[parts.length - 1]] = val;
- return val;
- };
-
- /**
- * Shuffles the given array in-place.
- * The function uses a seeded random generator.
- * @method shuffle
- * @param {array} array
- * @return {array} array shuffled randomly
- */
- Common.shuffle = function(array) {
- for (var i = array.length - 1; i > 0; i--) {
- var j = Math.floor(Common.random() * (i + 1));
- var temp = array[i];
- array[i] = array[j];
- array[j] = temp;
- }
- return array;
- };
-
- /**
- * Randomly chooses a value from a list with equal probability.
- * The function uses a seeded random generator.
- * @method choose
- * @param {array} choices
- * @return {object} A random choice object from the array
- */
- Common.choose = function(choices) {
- return choices[Math.floor(Common.random() * choices.length)];
- };
-
- /**
- * Returns true if the object is a HTMLElement, otherwise false.
- * @method isElement
- * @param {object} obj
- * @return {boolean} True if the object is a HTMLElement, otherwise false
- */
- Common.isElement = function(obj) {
- if (typeof HTMLElement !== 'undefined') {
- return obj instanceof HTMLElement;
- }
-
- return !!(obj && obj.nodeType && obj.nodeName);
- };
-
- /**
- * Returns true if the object is an array.
- * @method isArray
- * @param {object} obj
- * @return {boolean} True if the object is an array, otherwise false
- */
- Common.isArray = function(obj) {
- return Object.prototype.toString.call(obj) === '[object Array]';
- };
-
- /**
- * Returns true if the object is a function.
- * @method isFunction
- * @param {object} obj
- * @return {boolean} True if the object is a function, otherwise false
- */
- Common.isFunction = function(obj) {
- return typeof obj === "function";
- };
-
- /**
- * Returns true if the object is a plain object.
- * @method isPlainObject
- * @param {object} obj
- * @return {boolean} True if the object is a plain object, otherwise false
- */
- Common.isPlainObject = function(obj) {
- return typeof obj === 'object' && obj.constructor === Object;
- };
-
- /**
- * Returns true if the object is a string.
- * @method isString
- * @param {object} obj
- * @return {boolean} True if the object is a string, otherwise false
- */
- Common.isString = function(obj) {
- return toString.call(obj) === '[object String]';
- };
-
- /**
- * Returns the given value clamped between a minimum and maximum value.
- * @method clamp
- * @param {number} value
- * @param {number} min
- * @param {number} max
- * @return {number} The value clamped between min and max inclusive
- */
- Common.clamp = function(value, min, max) {
- if (value < min)
- return min;
- if (value > max)
- return max;
- return value;
- };
-
- /**
- * Returns the sign of the given value.
- * @method sign
- * @param {number} value
- * @return {number} -1 if negative, +1 if 0 or positive
- */
- Common.sign = function(value) {
- return value < 0 ? -1 : 1;
- };
-
- /**
- * Returns the current timestamp since the time origin (e.g. from page load).
- * The result will be high-resolution including decimal places if available.
- * @method now
- * @return {number} the current timestamp
- */
- Common.now = function() {
- if (window.performance) {
- if (window.performance.now) {
- return window.performance.now();
- } else if (window.performance.webkitNow) {
- return window.performance.webkitNow();
- }
- }
-
- return (new Date()) - Common._nowStartTime;
- };
-
- /**
- * Returns a random value between a minimum and a maximum value inclusive.
- * The function uses a seeded random generator.
- * @method random
- * @param {number} min
- * @param {number} max
- * @return {number} A random number between min and max inclusive
- */
- Common.random = function(min, max) {
- min = (typeof min !== "undefined") ? min : 0;
- max = (typeof max !== "undefined") ? max : 1;
- return min + _seededRandom() * (max - min);
- };
-
- var _seededRandom = function() {
- // https://en.wikipedia.org/wiki/Linear_congruential_generator
- Common._seed = (Common._seed * 9301 + 49297) % 233280;
- return Common._seed / 233280;
- };
-
- /**
- * Converts a CSS hex colour string into an integer.
- * @method colorToNumber
- * @param {string} colorString
- * @return {number} An integer representing the CSS hex string
- */
- Common.colorToNumber = function(colorString) {
- colorString = colorString.replace('#','');
-
- if (colorString.length == 3) {
- colorString = colorString.charAt(0) + colorString.charAt(0)
- + colorString.charAt(1) + colorString.charAt(1)
- + colorString.charAt(2) + colorString.charAt(2);
- }
-
- return parseInt(colorString, 16);
- };
-
- /**
- * The console logging level to use, where each level includes all levels above and excludes the levels below.
- * The default level is 'debug' which shows all console messages.
- *
- * Possible level values are:
- * - 0 = None
- * - 1 = Debug
- * - 2 = Info
- * - 3 = Warn
- * - 4 = Error
- * @property Common.logLevel
- * @type {Number}
- * @default 1
- */
- Common.logLevel = 1;
-
- /**
- * Shows a `console.log` message only if the current `Common.logLevel` allows it.
- * The message will be prefixed with 'matter-js' to make it easily identifiable.
- * @method log
- * @param ...objs {} The objects to log.
- */
- Common.log = function() {
- if (console && Common.logLevel > 0 && Common.logLevel <= 3) {
- console.log.apply(console, ['matter-js:'].concat(Array.prototype.slice.call(arguments)));
+ for (var i = 0; i < axes.length; i++) {
+ var axis = axes[i],
+ xx;
+ xx = axis.x * cos - axis.y * sin;
+ axis.y = axis.x * sin + axis.y * cos;
+ axis.x = xx;
}
};
- /**
- * Shows a `console.info` message only if the current `Common.logLevel` allows it.
- * The message will be prefixed with 'matter-js' to make it easily identifiable.
- * @method info
- * @param ...objs {} The objects to log.
- */
- Common.info = function() {
- if (console && Common.logLevel > 0 && Common.logLevel <= 2) {
- console.info.apply(console, ['matter-js:'].concat(Array.prototype.slice.call(arguments)));
- }
- };
-
- /**
- * Shows a `console.warn` message only if the current `Common.logLevel` allows it.
- * The message will be prefixed with 'matter-js' to make it easily identifiable.
- * @method warn
- * @param ...objs {} The objects to log.
- */
- Common.warn = function() {
- if (console && Common.logLevel > 0 && Common.logLevel <= 3) {
- console.warn.apply(console, ['matter-js:'].concat(Array.prototype.slice.call(arguments)));
- }
- };
-
- /**
- * Returns the next unique sequential ID.
- * @method nextId
- * @return {Number} Unique sequential ID
- */
- Common.nextId = function() {
- return Common._nextId++;
- };
-
- /**
- * A cross browser compatible indexOf implementation.
- * @method indexOf
- * @param {array} haystack
- * @param {object} needle
- * @return {number} The position of needle in haystack, otherwise -1.
- */
- Common.indexOf = function(haystack, needle) {
- if (haystack.indexOf)
- return haystack.indexOf(needle);
-
- for (var i = 0; i < haystack.length; i++) {
- if (haystack[i] === needle)
- return i;
- }
-
- return -1;
- };
-
- /**
- * A cross browser compatible array map implementation.
- * @method map
- * @param {array} list
- * @param {function} func
- * @return {array} Values from list transformed by func.
- */
- Common.map = function(list, func) {
- if (list.map) {
- return list.map(func);
- }
-
- var mapped = [];
-
- for (var i = 0; i < list.length; i += 1) {
- mapped.push(func(list[i]));
- }
-
- return mapped;
- };
-
- /**
- * Takes a directed graph and returns the partially ordered set of vertices in topological order.
- * Circular dependencies are allowed.
- * @method topologicalSort
- * @param {object} graph
- * @return {array} Partially ordered set of vertices in topological order.
- */
- Common.topologicalSort = function(graph) {
- // https://github.com/mgechev/javascript-algorithms
- // Copyright (c) Minko Gechev (MIT license)
- // Modifications: tidy formatting and naming
- var result = [],
- visited = [],
- temp = [];
-
- for (var node in graph) {
- if (!visited[node] && !temp[node]) {
- Common._topologicalSort(node, visited, temp, graph, result);
- }
- }
-
- return result;
- };
-
- Common._topologicalSort = function(node, visited, temp, graph, result) {
- var neighbors = graph[node] || [];
- temp[node] = true;
-
- for (var i = 0; i < neighbors.length; i += 1) {
- var neighbor = neighbors[i];
-
- if (temp[neighbor]) {
- // skip circular dependencies
- continue;
- }
-
- if (!visited[neighbor]) {
- Common._topologicalSort(neighbor, visited, temp, graph, result);
- }
- }
-
- temp[node] = false;
- visited[node] = true;
-
- result.push(node);
- };
-
- /**
- * Takes _n_ functions as arguments and returns a new function that calls them in order.
- * The arguments applied when calling the new function will also be applied to every function passed.
- * The value of `this` refers to the last value returned in the chain that was not `undefined`.
- * Therefore if a passed function does not return a value, the previously returned value is maintained.
- * After all passed functions have been called the new function returns the last returned value (if any).
- * If any of the passed functions are a chain, then the chain will be flattened.
- * @method chain
- * @param ...funcs {function} The functions to chain.
- * @return {function} A new function that calls the passed functions in order.
- */
- Common.chain = function() {
- var funcs = [];
-
- for (var i = 0; i < arguments.length; i += 1) {
- var func = arguments[i];
-
- if (func._chained) {
- // flatten already chained functions
- funcs.push.apply(funcs, func._chained);
- } else {
- funcs.push(func);
- }
- }
-
- var chain = function() {
- // https://github.com/GoogleChrome/devtools-docs/issues/53#issuecomment-51941358
- var lastResult,
- args = new Array(arguments.length);
-
- for (var i = 0, l = arguments.length; i < l; i++) {
- args[i] = arguments[i];
- }
-
- for (i = 0; i < funcs.length; i += 1) {
- var result = funcs[i].apply(lastResult, args);
-
- if (typeof result !== 'undefined') {
- lastResult = result;
- }
- }
-
- return lastResult;
- };
-
- chain._chained = funcs;
-
- return chain;
- };
-
- /**
- * Chains a function to excute before the original function on the given `path` relative to `base`.
- * See also docs for `Common.chain`.
- * @method chainPathBefore
- * @param {} base The base object
- * @param {string} path The path relative to `base`
- * @param {function} func The function to chain before the original
- * @return {function} The chained function that replaced the original
- */
- Common.chainPathBefore = function(base, path, func) {
- return Common.set(base, path, Common.chain(
- func,
- Common.get(base, path)
- ));
- };
-
- /**
- * Chains a function to excute after the original function on the given `path` relative to `base`.
- * See also docs for `Common.chain`.
- * @method chainPathAfter
- * @param {} base The base object
- * @param {string} path The path relative to `base`
- * @param {function} func The function to chain after the original
- * @return {function} The chained function that replaced the original
- */
- Common.chainPathAfter = function(base, path, func) {
- return Common.set(base, path, Common.chain(
- Common.get(base, path),
- func
- ));
- };
-
- /**
- * Used to require external libraries outside of the bundle.
- * It first looks for the `globalName` on the environment's global namespace.
- * If the global is not found, it will fall back to using the standard `require` using the `moduleName`.
- * @private
- * @method _requireGlobal
- * @param {string} globalName The global module name
- * @param {string} moduleName The fallback CommonJS module name
- * @return {} The loaded module
- */
- Common._requireGlobal = function(globalName, moduleName) {
- var obj = (typeof window !== 'undefined' ? window[globalName] : typeof global !== 'undefined' ? global[globalName] : null);
- return obj || _dereq_(moduleName);
- };
})();
-}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
-},{}],15:[function(_dereq_,module,exports){
+
+/***/ }),
+/* 11 */
+/***/ (function(module, exports, __webpack_require__) {
+
/**
-* The `Matter.Engine` module contains methods for creating and manipulating engines.
-* An engine is a controller that manages updating the simulation of the world.
-* See `Matter.Runner` for an optional game loop utility.
+* The `Matter.Bodies` module contains factory methods for creating rigid body models
+* with commonly used body configurations (such as rectangles, circles and other polygons).
*
* See the included usage [examples](https://github.com/liabru/matter-js/tree/master/examples).
*
-* @class Engine
+* @class Bodies
*/
-var Engine = {};
+// TODO: true circle bodies
-module.exports = Engine;
+var Bodies = {};
-var World = _dereq_('../body/World');
-var Sleeping = _dereq_('./Sleeping');
-var Resolver = _dereq_('../collision/Resolver');
-var Render = _dereq_('../render/Render');
-var Pairs = _dereq_('../collision/Pairs');
-var Metrics = _dereq_('./Metrics');
-var Grid = _dereq_('../collision/Grid');
-var Events = _dereq_('./Events');
-var Composite = _dereq_('../body/Composite');
-var Constraint = _dereq_('../constraint/Constraint');
-var Common = _dereq_('./Common');
-var Body = _dereq_('../body/Body');
+module.exports = Bodies;
+
+var Vertices = __webpack_require__(3);
+var Common = __webpack_require__(0);
+var Body = __webpack_require__(6);
+var Bounds = __webpack_require__(1);
+var Vector = __webpack_require__(2);
(function() {
/**
- * Creates a new engine. The options parameter is an object that specifies any properties you wish to override the defaults.
- * All properties have default values, and many are pre-calculated automatically based on other properties.
- * See the properties section below for detailed information on what you can pass via the `options` object.
- * @method create
+ * Creates a new rigid body model with a rectangle hull.
+ * The options parameter is an object that specifies any properties you wish to override the defaults.
+ * See the properties section of the `Matter.Body` module for detailed information on what you can pass via the `options` object.
+ * @method rectangle
+ * @param {number} x
+ * @param {number} y
+ * @param {number} width
+ * @param {number} height
* @param {object} [options]
- * @return {engine} engine
+ * @return {body} A new rectangle body
*/
- Engine.create = function(element, options) {
- // options may be passed as the first (and only) argument
- options = Common.isElement(element) ? options : element;
- element = Common.isElement(element) ? element : null;
+ Bodies.rectangle = function(x, y, width, height, options) {
options = options || {};
- if (element || options.render) {
- Common.warn('Engine.create: engine.render is deprecated (see docs)');
- }
-
- var defaults = {
- positionIterations: 6,
- velocityIterations: 4,
- constraintIterations: 2,
- enableSleeping: false,
- events: [],
- plugin: {},
- timing: {
- timestamp: 0,
- timeScale: 1
- },
- broadphase: {
- controller: Grid
- }
+ var rectangle = {
+ label: 'Rectangle Body',
+ position: { x: x, y: y },
+ vertices: Vertices.fromPath('L 0 0 L ' + width + ' 0 L ' + width + ' ' + height + ' L 0 ' + height)
};
- var engine = Common.extend(defaults, options);
-
- // @deprecated
- if (element || engine.render) {
- var renderDefaults = {
- element: element,
- controller: Render
- };
-
- engine.render = Common.extend(renderDefaults, engine.render);
+ if (options.chamfer) {
+ var chamfer = options.chamfer;
+ rectangle.vertices = Vertices.chamfer(rectangle.vertices, chamfer.radius,
+ chamfer.quality, chamfer.qualityMin, chamfer.qualityMax);
+ delete options.chamfer;
}
- // @deprecated
- if (engine.render && engine.render.controller) {
- engine.render = engine.render.controller.create(engine.render);
- }
-
- // @deprecated
- if (engine.render) {
- engine.render.engine = engine;
- }
-
- engine.world = options.world || World.create(engine.world);
- engine.pairs = Pairs.create();
- engine.broadphase = engine.broadphase.controller.create(engine.broadphase);
- engine.metrics = engine.metrics || { extended: false };
-
-
- return engine;
- };
-
- /**
- * Moves the simulation forward in time by `delta` ms.
- * The `correction` argument is an optional `Number` that specifies the time correction factor to apply to the update.
- * This can help improve the accuracy of the simulation in cases where `delta` is changing between updates.
- * The value of `correction` is defined as `delta / lastDelta`, i.e. the percentage change of `delta` over the last step.
- * Therefore the value is always `1` (no correction) when `delta` constant (or when no correction is desired, which is the default).
- * See the paper on Time Corrected Verlet for more information.
- *
- * Triggers `beforeUpdate` and `afterUpdate` events.
- * Triggers `collisionStart`, `collisionActive` and `collisionEnd` events.
- * @method update
- * @param {engine} engine
- * @param {number} [delta=16.666]
- * @param {number} [correction=1]
- */
- Engine.update = function(engine, delta, correction) {
- delta = delta || 1000 / 60;
- correction = correction || 1;
-
- var world = engine.world,
- timing = engine.timing,
- broadphase = engine.broadphase,
- broadphasePairs = [],
- i;
-
- // increment timestamp
- timing.timestamp += delta * timing.timeScale;
-
- // create an event object
- var event = {
- timestamp: timing.timestamp
- };
-
- Events.trigger(engine, 'beforeUpdate', event);
-
- // get lists of all bodies and constraints, no matter what composites they are in
- var allBodies = Composite.allBodies(world),
- allConstraints = Composite.allConstraints(world);
-
-
- // if sleeping enabled, call the sleeping controller
- if (engine.enableSleeping)
- Sleeping.update(allBodies, timing.timeScale);
-
- // applies gravity to all bodies
- Engine._bodiesApplyGravity(allBodies, world.gravity);
-
- // update all body position and rotation by integration
- Engine._bodiesUpdate(allBodies, delta, timing.timeScale, correction, world.bounds);
-
- // update all constraints (first pass)
- Constraint.preSolveAll(allBodies);
- for (i = 0; i < engine.constraintIterations; i++) {
- Constraint.solveAll(allConstraints, timing.timeScale);
- }
- Constraint.postSolveAll(allBodies);
-
- // broadphase pass: find potential collision pairs
- if (broadphase.controller) {
- // if world is dirty, we must flush the whole grid
- if (world.isModified)
- broadphase.controller.clear(broadphase);
-
- // update the grid buckets based on current bodies
- broadphase.controller.update(broadphase, allBodies, engine, world.isModified);
- broadphasePairs = broadphase.pairsList;
- } else {
- // if no broadphase set, we just pass all bodies
- broadphasePairs = allBodies;
- }
-
- // clear all composite modified flags
- if (world.isModified) {
- Composite.setModified(world, false, false, true);
- }
-
- // narrowphase pass: find actual collisions, then create or update collision pairs
- var collisions = broadphase.detector(broadphasePairs, engine);
-
- // update collision pairs
- var pairs = engine.pairs,
- timestamp = timing.timestamp;
- Pairs.update(pairs, collisions, timestamp);
- Pairs.removeOld(pairs, timestamp);
-
- // wake up bodies involved in collisions
- if (engine.enableSleeping)
- Sleeping.afterCollisions(pairs.list, timing.timeScale);
-
- // trigger collision events
- if (pairs.collisionStart.length > 0)
- Events.trigger(engine, 'collisionStart', { pairs: pairs.collisionStart });
-
- // iteratively resolve position between collisions
- Resolver.preSolvePosition(pairs.list);
- for (i = 0; i < engine.positionIterations; i++) {
- Resolver.solvePosition(pairs.list, timing.timeScale);
- }
- Resolver.postSolvePosition(allBodies);
-
- // update all constraints (second pass)
- Constraint.preSolveAll(allBodies);
- for (i = 0; i < engine.constraintIterations; i++) {
- Constraint.solveAll(allConstraints, timing.timeScale);
- }
- Constraint.postSolveAll(allBodies);
-
- // iteratively resolve velocity between collisions
- Resolver.preSolveVelocity(pairs.list);
- for (i = 0; i < engine.velocityIterations; i++) {
- Resolver.solveVelocity(pairs.list, timing.timeScale);
- }
-
- // trigger collision events
- if (pairs.collisionActive.length > 0)
- Events.trigger(engine, 'collisionActive', { pairs: pairs.collisionActive });
-
- if (pairs.collisionEnd.length > 0)
- Events.trigger(engine, 'collisionEnd', { pairs: pairs.collisionEnd });
-
-
- // clear force buffers
- Engine._bodiesClearForces(allBodies);
-
- Events.trigger(engine, 'afterUpdate', event);
-
- return engine;
+ return Body.create(Common.extend({}, rectangle, options));
};
/**
- * Merges two engines by keeping the configuration of `engineA` but replacing the world with the one from `engineB`.
- * @method merge
- * @param {engine} engineA
- * @param {engine} engineB
+ * Creates a new rigid body model with a trapezoid hull.
+ * The options parameter is an object that specifies any properties you wish to override the defaults.
+ * See the properties section of the `Matter.Body` module for detailed information on what you can pass via the `options` object.
+ * @method trapezoid
+ * @param {number} x
+ * @param {number} y
+ * @param {number} width
+ * @param {number} height
+ * @param {number} slope
+ * @param {object} [options]
+ * @return {body} A new trapezoid body
*/
- Engine.merge = function(engineA, engineB) {
- Common.extend(engineA, engineB);
+ Bodies.trapezoid = function(x, y, width, height, slope, options) {
+ options = options || {};
+
+ slope *= 0.5;
+ var roof = (1 - (slope * 2)) * width;
- if (engineB.world) {
- engineA.world = engineB.world;
+ var x1 = width * slope,
+ x2 = x1 + roof,
+ x3 = x2 + x1,
+ verticesPath;
- Engine.clear(engineA);
+ if (slope < 0.5) {
+ verticesPath = 'L 0 0 L ' + x1 + ' ' + (-height) + ' L ' + x2 + ' ' + (-height) + ' L ' + x3 + ' 0';
+ } else {
+ verticesPath = 'L 0 0 L ' + x2 + ' ' + (-height) + ' L ' + x3 + ' 0';
+ }
- var bodies = Composite.allBodies(engineA.world);
+ var trapezoid = {
+ label: 'Trapezoid Body',
+ position: { x: x, y: y },
+ vertices: Vertices.fromPath(verticesPath)
+ };
- for (var i = 0; i < bodies.length; i++) {
- var body = bodies[i];
- Sleeping.set(body, false);
- body.id = Common.nextId();
+ if (options.chamfer) {
+ var chamfer = options.chamfer;
+ trapezoid.vertices = Vertices.chamfer(trapezoid.vertices, chamfer.radius,
+ chamfer.quality, chamfer.qualityMin, chamfer.qualityMax);
+ delete options.chamfer;
+ }
+
+ return Body.create(Common.extend({}, trapezoid, options));
+ };
+
+ /**
+ * Creates a new rigid body model with a circle hull.
+ * The options parameter is an object that specifies any properties you wish to override the defaults.
+ * See the properties section of the `Matter.Body` module for detailed information on what you can pass via the `options` object.
+ * @method circle
+ * @param {number} x
+ * @param {number} y
+ * @param {number} radius
+ * @param {object} [options]
+ * @param {number} [maxSides]
+ * @return {body} A new circle body
+ */
+ Bodies.circle = function(x, y, radius, options, maxSides) {
+ options = options || {};
+
+ var circle = {
+ label: 'Circle Body',
+ circleRadius: radius
+ };
+
+ // approximate circles with polygons until true circles implemented in SAT
+ maxSides = maxSides || 25;
+ var sides = Math.ceil(Math.max(10, Math.min(maxSides, radius)));
+
+ // optimisation: always use even number of sides (half the number of unique axes)
+ if (sides % 2 === 1)
+ sides += 1;
+
+ return Bodies.polygon(x, y, sides, radius, Common.extend({}, circle, options));
+ };
+
+ /**
+ * Creates a new rigid body model with a regular polygon hull with the given number of sides.
+ * The options parameter is an object that specifies any properties you wish to override the defaults.
+ * See the properties section of the `Matter.Body` module for detailed information on what you can pass via the `options` object.
+ * @method polygon
+ * @param {number} x
+ * @param {number} y
+ * @param {number} sides
+ * @param {number} radius
+ * @param {object} [options]
+ * @return {body} A new regular polygon body
+ */
+ Bodies.polygon = function(x, y, sides, radius, options) {
+ options = options || {};
+
+ if (sides < 3)
+ return Bodies.circle(x, y, radius, options);
+
+ var theta = 2 * Math.PI / sides,
+ path = '',
+ offset = theta * 0.5;
+
+ for (var i = 0; i < sides; i += 1) {
+ var angle = offset + (i * theta),
+ xx = Math.cos(angle) * radius,
+ yy = Math.sin(angle) * radius;
+
+ path += 'L ' + xx.toFixed(3) + ' ' + yy.toFixed(3) + ' ';
+ }
+
+ var polygon = {
+ label: 'Polygon Body',
+ position: { x: x, y: y },
+ vertices: Vertices.fromPath(path)
+ };
+
+ if (options.chamfer) {
+ var chamfer = options.chamfer;
+ polygon.vertices = Vertices.chamfer(polygon.vertices, chamfer.radius,
+ chamfer.quality, chamfer.qualityMin, chamfer.qualityMax);
+ delete options.chamfer;
+ }
+
+ return Body.create(Common.extend({}, polygon, options));
+ };
+
+ /**
+ * Utility to create a compound body based on set(s) of vertices.
+ *
+ * _Note:_ To optionally enable automatic concave vertices decomposition the [poly-decomp](https://github.com/schteppe/poly-decomp.js)
+ * package must be first installed and provided see `Common.setDecomp`, otherwise the convex hull of each vertex set will be used.
+ *
+ * The resulting vertices are reorientated about their centre of mass,
+ * and offset such that `body.position` corresponds to this point.
+ *
+ * The resulting offset may be found if needed by subtracting `body.bounds` from the original input bounds.
+ * To later move the centre of mass see `Body.setCentre`.
+ *
+ * Note that automatic conconcave decomposition results are not always optimal.
+ * For best results, simplify the input vertices as much as possible first.
+ * By default this function applies some addtional simplification to help.
+ *
+ * Some outputs may also require further manual processing afterwards to be robust.
+ * In particular some parts may need to be overlapped to avoid collision gaps.
+ * Thin parts and sharp points should be avoided or removed where possible.
+ *
+ * The options parameter object specifies any `Matter.Body` properties you wish to override the defaults.
+ *
+ * See the properties section of the `Matter.Body` module for detailed information on what you can pass via the `options` object.
+ * @method fromVertices
+ * @param {number} x
+ * @param {number} y
+ * @param {array} vertexSets One or more arrays of vertex points e.g. `[[{ x: 0, y: 0 }...], ...]`.
+ * @param {object} [options] The body options.
+ * @param {bool} [flagInternal=false] Optionally marks internal edges with `isInternal`.
+ * @param {number} [removeCollinear=0.01] Threshold when simplifying vertices along the same edge.
+ * @param {number} [minimumArea=10] Threshold when removing small parts.
+ * @param {number} [removeDuplicatePoints=0.01] Threshold when simplifying nearby vertices.
+ * @return {body}
+ */
+ Bodies.fromVertices = function(x, y, vertexSets, options, flagInternal, removeCollinear, minimumArea, removeDuplicatePoints) {
+ var decomp = Common.getDecomp(),
+ canDecomp,
+ body,
+ parts,
+ isConvex,
+ isConcave,
+ vertices,
+ i,
+ j,
+ k,
+ v,
+ z;
+
+ // check decomp is as expected
+ canDecomp = Boolean(decomp && decomp.quickDecomp);
+
+ options = options || {};
+ parts = [];
+
+ flagInternal = typeof flagInternal !== 'undefined' ? flagInternal : false;
+ removeCollinear = typeof removeCollinear !== 'undefined' ? removeCollinear : 0.01;
+ minimumArea = typeof minimumArea !== 'undefined' ? minimumArea : 10;
+ removeDuplicatePoints = typeof removeDuplicatePoints !== 'undefined' ? removeDuplicatePoints : 0.01;
+
+ // ensure vertexSets is an array of arrays
+ if (!Common.isArray(vertexSets[0])) {
+ vertexSets = [vertexSets];
+ }
+
+ for (v = 0; v < vertexSets.length; v += 1) {
+ vertices = vertexSets[v];
+ isConvex = Vertices.isConvex(vertices);
+ isConcave = !isConvex;
+
+ if (isConcave && !canDecomp) {
+ Common.warnOnce(
+ 'Bodies.fromVertices: Install the \'poly-decomp\' library and use Common.setDecomp or provide \'decomp\' as a global to decompose concave vertices.'
+ );
}
- }
- };
- /**
- * Clears the engine including the world, pairs and broadphase.
- * @method clear
- * @param {engine} engine
- */
- Engine.clear = function(engine) {
- var world = engine.world;
-
- Pairs.clear(engine.pairs);
+ if (isConvex || !canDecomp) {
+ if (isConvex) {
+ vertices = Vertices.clockwiseSort(vertices);
+ } else {
+ // fallback to convex hull when decomposition is not possible
+ vertices = Vertices.hull(vertices);
+ }
- var broadphase = engine.broadphase;
- if (broadphase.controller) {
- var bodies = Composite.allBodies(world);
- broadphase.controller.clear(broadphase);
- broadphase.controller.update(broadphase, bodies, engine, true);
- }
- };
+ parts.push({
+ position: { x: x, y: y },
+ vertices: vertices
+ });
+ } else {
+ // initialise a decomposition
+ var concave = vertices.map(function(vertex) {
+ return [vertex.x, vertex.y];
+ });
- /**
- * Zeroes the `body.force` and `body.torque` force buffers.
- * @method _bodiesClearForces
- * @private
- * @param {body[]} bodies
- */
- Engine._bodiesClearForces = function(bodies) {
- for (var i = 0; i < bodies.length; i++) {
- var body = bodies[i];
+ // vertices are concave and simple, we can decompose into parts
+ decomp.makeCCW(concave);
+ if (removeCollinear !== false)
+ decomp.removeCollinearPoints(concave, removeCollinear);
+ if (removeDuplicatePoints !== false && decomp.removeDuplicatePoints)
+ decomp.removeDuplicatePoints(concave, removeDuplicatePoints);
- // reset force buffers
- body.force.x = 0;
- body.force.y = 0;
- body.torque = 0;
- }
- };
+ // use the quick decomposition algorithm (Bayazit)
+ var decomposed = decomp.quickDecomp(concave);
- /**
- * Applys a mass dependant force to all given bodies.
- * @method _bodiesApplyGravity
- * @private
- * @param {body[]} bodies
- * @param {vector} gravity
- */
- Engine._bodiesApplyGravity = function(bodies, gravity) {
- var gravityScale = typeof gravity.scale !== 'undefined' ? gravity.scale : 0.001;
+ // for each decomposed chunk
+ for (i = 0; i < decomposed.length; i++) {
+ var chunk = decomposed[i];
- if ((gravity.x === 0 && gravity.y === 0) || gravityScale === 0) {
- return;
- }
-
- for (var i = 0; i < bodies.length; i++) {
- var body = bodies[i];
+ // convert vertices into the correct structure
+ var chunkVertices = chunk.map(function(vertices) {
+ return {
+ x: vertices[0],
+ y: vertices[1]
+ };
+ });
- if (body.isStatic || body.isSleeping)
- continue;
+ // skip small chunks
+ if (minimumArea > 0 && Vertices.area(chunkVertices) < minimumArea)
+ continue;
- // apply gravity
- body.force.y += body.mass * gravity.y * gravityScale;
- body.force.x += body.mass * gravity.x * gravityScale;
- }
- };
-
- /**
- * Applys `Body.update` to all given `bodies`.
- * @method _bodiesUpdate
- * @private
- * @param {body[]} bodies
- * @param {number} deltaTime
- * The amount of time elapsed between updates
- * @param {number} timeScale
- * @param {number} correction
- * The Verlet correction factor (deltaTime / lastDeltaTime)
- * @param {bounds} worldBounds
- */
- Engine._bodiesUpdate = function(bodies, deltaTime, timeScale, correction, worldBounds) {
- for (var i = 0; i < bodies.length; i++) {
- var body = bodies[i];
-
- if (body.isStatic || body.isSleeping)
- continue;
-
- Body.update(body, deltaTime, timeScale, correction);
- }
- };
-
- /**
- * An alias for `Runner.run`, see `Matter.Runner` for more information.
- * @method run
- * @param {engine} engine
- */
-
- /**
- * Fired just before an update
- *
- * @event beforeUpdate
- * @param {} event An event object
- * @param {number} event.timestamp The engine.timing.timestamp of the event
- * @param {} event.source The source object of the event
- * @param {} event.name The name of the event
- */
-
- /**
- * Fired after engine update and all collision events
- *
- * @event afterUpdate
- * @param {} event An event object
- * @param {number} event.timestamp The engine.timing.timestamp of the event
- * @param {} event.source The source object of the event
- * @param {} event.name The name of the event
- */
-
- /**
- * Fired after engine update, provides a list of all pairs that have started to collide in the current tick (if any)
- *
- * @event collisionStart
- * @param {} event An event object
- * @param {} event.pairs List of affected pairs
- * @param {number} event.timestamp The engine.timing.timestamp of the event
- * @param {} event.source The source object of the event
- * @param {} event.name The name of the event
- */
-
- /**
- * Fired after engine update, provides a list of all pairs that are colliding in the current tick (if any)
- *
- * @event collisionActive
- * @param {} event An event object
- * @param {} event.pairs List of affected pairs
- * @param {number} event.timestamp The engine.timing.timestamp of the event
- * @param {} event.source The source object of the event
- * @param {} event.name The name of the event
- */
-
- /**
- * Fired after engine update, provides a list of all pairs that have ended collision in the current tick (if any)
- *
- * @event collisionEnd
- * @param {} event An event object
- * @param {} event.pairs List of affected pairs
- * @param {number} event.timestamp The engine.timing.timestamp of the event
- * @param {} event.source The source object of the event
- * @param {} event.name The name of the event
- */
-
- /*
- *
- * Properties Documentation
- *
- */
-
- /**
- * An integer `Number` that specifies the number of position iterations to perform each update.
- * The higher the value, the higher quality the simulation will be at the expense of performance.
- *
- * @property positionIterations
- * @type number
- * @default 6
- */
-
- /**
- * An integer `Number` that specifies the number of velocity iterations to perform each update.
- * The higher the value, the higher quality the simulation will be at the expense of performance.
- *
- * @property velocityIterations
- * @type number
- * @default 4
- */
-
- /**
- * An integer `Number` that specifies the number of constraint iterations to perform each update.
- * The higher the value, the higher quality the simulation will be at the expense of performance.
- * The default value of `2` is usually very adequate.
- *
- * @property constraintIterations
- * @type number
- * @default 2
- */
-
- /**
- * A flag that specifies whether the engine should allow sleeping via the `Matter.Sleeping` module.
- * Sleeping can improve stability and performance, but often at the expense of accuracy.
- *
- * @property enableSleeping
- * @type boolean
- * @default false
- */
-
- /**
- * An `Object` containing properties regarding the timing systems of the engine.
- *
- * @property timing
- * @type object
- */
-
- /**
- * A `Number` that specifies the global scaling factor of time for all bodies.
- * A value of `0` freezes the simulation.
- * A value of `0.1` gives a slow-motion effect.
- * A value of `1.2` gives a speed-up effect.
- *
- * @property timing.timeScale
- * @type number
- * @default 1
- */
-
- /**
- * A `Number` that specifies the current simulation-time in milliseconds starting from `0`.
- * It is incremented on every `Engine.update` by the given `delta` argument.
- *
- * @property timing.timestamp
- * @type number
- * @default 0
- */
-
- /**
- * An instance of a `Render` controller. The default value is a `Matter.Render` instance created by `Engine.create`.
- * One may also develop a custom renderer module based on `Matter.Render` and pass an instance of it to `Engine.create` via `options.render`.
- *
- * A minimal custom renderer object must define at least three functions: `create`, `clear` and `world` (see `Matter.Render`).
- * It is also possible to instead pass the _module_ reference via `options.render.controller` and `Engine.create` will instantiate one for you.
- *
- * @property render
- * @type render
- * @deprecated see Demo.js for an example of creating a renderer
- * @default a Matter.Render instance
- */
-
- /**
- * An instance of a broadphase controller. The default value is a `Matter.Grid` instance created by `Engine.create`.
- *
- * @property broadphase
- * @type grid
- * @default a Matter.Grid instance
- */
-
- /**
- * A `World` composite object that will contain all simulated bodies and constraints.
- *
- * @property world
- * @type world
- * @default a Matter.World instance
- */
-
- /**
- * An object reserved for storing plugin-specific properties.
- *
- * @property plugin
- * @type {}
- */
-
-})();
-
-},{"../body/Body":1,"../body/Composite":2,"../body/World":3,"../collision/Grid":6,"../collision/Pairs":8,"../collision/Resolver":10,"../constraint/Constraint":12,"../render/Render":31,"./Common":14,"./Events":16,"./Metrics":18,"./Sleeping":22}],16:[function(_dereq_,module,exports){
-/**
-* The `Matter.Events` module contains methods to fire and listen to events on other objects.
-*
-* See the included usage [examples](https://github.com/liabru/matter-js/tree/master/examples).
-*
-* @class Events
-*/
-
-var Events = {};
-
-module.exports = Events;
-
-var Common = _dereq_('./Common');
-
-(function() {
-
- /**
- * Subscribes a callback function to the given object's `eventName`.
- * @method on
- * @param {} object
- * @param {string} eventNames
- * @param {function} callback
- */
- Events.on = function(object, eventNames, callback) {
- var names = eventNames.split(' '),
- name;
-
- for (var i = 0; i < names.length; i++) {
- name = names[i];
- object.events = object.events || {};
- object.events[name] = object.events[name] || [];
- object.events[name].push(callback);
- }
-
- return callback;
- };
-
- /**
- * Removes the given event callback. If no callback, clears all callbacks in `eventNames`. If no `eventNames`, clears all events.
- * @method off
- * @param {} object
- * @param {string} eventNames
- * @param {function} callback
- */
- Events.off = function(object, eventNames, callback) {
- if (!eventNames) {
- object.events = {};
- return;
- }
-
- // handle Events.off(object, callback)
- if (typeof eventNames === 'function') {
- callback = eventNames;
- eventNames = Common.keys(object.events).join(' ');
- }
-
- var names = eventNames.split(' ');
-
- for (var i = 0; i < names.length; i++) {
- var callbacks = object.events[names[i]],
- newCallbacks = [];
-
- if (callback && callbacks) {
- for (var j = 0; j < callbacks.length; j++) {
- if (callbacks[j] !== callback)
- newCallbacks.push(callbacks[j]);
+ // create a compound part
+ parts.push({
+ position: Vertices.centre(chunkVertices),
+ vertices: chunkVertices
+ });
}
}
-
- object.events[names[i]] = newCallbacks;
}
- };
- /**
- * Fires all the callbacks subscribed to the given object's `eventName`, in the order they subscribed, if any.
- * @method trigger
- * @param {} object
- * @param {string} eventNames
- * @param {} event
- */
- Events.trigger = function(object, eventNames, event) {
- var names,
- name,
- callbacks,
- eventClone;
+ // create body parts
+ for (i = 0; i < parts.length; i++) {
+ parts[i] = Body.create(Common.extend(parts[i], options));
+ }
- if (object.events) {
- if (!event)
- event = {};
+ // flag internal edges (coincident part edges)
+ if (flagInternal) {
+ var coincident_max_dist = 5;
- names = eventNames.split(' ');
+ for (i = 0; i < parts.length; i++) {
+ var partA = parts[i];
- for (var i = 0; i < names.length; i++) {
- name = names[i];
- callbacks = object.events[name];
+ for (j = i + 1; j < parts.length; j++) {
+ var partB = parts[j];
- if (callbacks) {
- eventClone = Common.clone(event, false);
- eventClone.name = name;
- eventClone.source = object;
+ if (Bounds.overlaps(partA.bounds, partB.bounds)) {
+ var pav = partA.vertices,
+ pbv = partB.vertices;
+
+ // iterate vertices of both parts
+ for (k = 0; k < partA.vertices.length; k++) {
+ for (z = 0; z < partB.vertices.length; z++) {
+ // find distances between the vertices
+ var da = Vector.magnitudeSquared(Vector.sub(pav[(k + 1) % pav.length], pbv[z])),
+ db = Vector.magnitudeSquared(Vector.sub(pav[k], pbv[(z + 1) % pbv.length]));
+
+ // if both vertices are very close, consider the edge concident (internal)
+ if (da < coincident_max_dist && db < coincident_max_dist) {
+ pav[k].isInternal = true;
+ pbv[z].isInternal = true;
+ }
+ }
+ }
- for (var j = 0; j < callbacks.length; j++) {
- callbacks[j].apply(object, [eventClone]);
}
}
}
}
+
+ if (parts.length > 1) {
+ // create the parent body to be returned, that contains generated compound parts
+ body = Body.create(Common.extend({ parts: parts.slice(0) }, options));
+
+ // offset such that body.position is at the centre off mass
+ Body.setPosition(body, { x: x, y: y });
+
+ return body;
+ } else {
+ return parts[0];
+ }
};
})();
-},{"./Common":14}],17:[function(_dereq_,module,exports){
-/**
-* The `Matter` module is the top level namespace. It also includes a function for installing plugins on top of the library.
-*
-* @class Matter
-*/
-var Matter = {};
+/***/ }),
+/* 12 */
+/***/ (function(module, exports, __webpack_require__) {
-module.exports = Matter;
-
-var Plugin = _dereq_('./Plugin');
-var Common = _dereq_('./Common');
-
-(function() {
-
- /**
- * The library name.
- * @property name
- * @readOnly
- * @type {String}
- */
- Matter.name = 'matter-js';
-
- /**
- * The library version.
- * @property version
- * @readOnly
- * @type {String}
- */
- Matter.version = '0.14.2';
-
- /**
- * A list of plugin dependencies to be installed. These are normally set and installed through `Matter.use`.
- * Alternatively you may set `Matter.uses` manually and install them by calling `Plugin.use(Matter)`.
- * @property uses
- * @type {Array}
- */
- Matter.uses = [];
-
- /**
- * The plugins that have been installed through `Matter.Plugin.install`. Read only.
- * @property used
- * @readOnly
- * @type {Array}
- */
- Matter.used = [];
-
- /**
- * Installs the given plugins on the `Matter` namespace.
- * This is a short-hand for `Plugin.use`, see it for more information.
- * Call this function once at the start of your code, with all of the plugins you wish to install as arguments.
- * Avoid calling this function multiple times unless you intend to manually control installation order.
- * @method use
- * @param ...plugin {Function} The plugin(s) to install on `base` (multi-argument).
- */
- Matter.use = function() {
- Plugin.use(Matter, Array.prototype.slice.call(arguments));
- };
-
- /**
- * Chains a function to excute before the original function on the given `path` relative to `Matter`.
- * See also docs for `Common.chain`.
- * @method before
- * @param {string} path The path relative to `Matter`
- * @param {function} func The function to chain before the original
- * @return {function} The chained function that replaced the original
- */
- Matter.before = function(path, func) {
- path = path.replace(/^Matter./, '');
- return Common.chainPathBefore(Matter, path, func);
- };
-
- /**
- * Chains a function to excute after the original function on the given `path` relative to `Matter`.
- * See also docs for `Common.chain`.
- * @method after
- * @param {string} path The path relative to `Matter`
- * @param {function} func The function to chain after the original
- * @return {function} The chained function that replaced the original
- */
- Matter.after = function(path, func) {
- path = path.replace(/^Matter./, '');
- return Common.chainPathAfter(Matter, path, func);
- };
-
-})();
-
-},{"./Common":14,"./Plugin":20}],18:[function(_dereq_,module,exports){
-
-},{"../body/Composite":2,"./Common":14}],19:[function(_dereq_,module,exports){
/**
* The `Matter.Mouse` module contains methods for creating and manipulating mouse inputs.
*
@@ -5532,7 +4814,7 @@ var Mouse = {};
module.exports = Mouse;
-var Common = _dereq_('../core/Common');
+var Common = __webpack_require__(0);
(function() {
@@ -5558,7 +4840,7 @@ var Common = _dereq_('../core/Common');
mouse.scale = { x: 1, y: 1 };
mouse.wheelDelta = 0;
mouse.button = -1;
- mouse.pixelRatio = mouse.element.getAttribute('data-pixel-ratio') || 1;
+ mouse.pixelRatio = parseInt(mouse.element.getAttribute('data-pixel-ratio'), 10) || 1;
mouse.sourceEvents = {
mousemove: null,
@@ -5724,7 +5006,383 @@ var Common = _dereq_('../core/Common');
})();
-},{"../core/Common":14}],20:[function(_dereq_,module,exports){
+
+/***/ }),
+/* 13 */
+/***/ (function(module, exports, __webpack_require__) {
+
+/**
+* The `Matter.Detector` module contains methods for detecting collisions given a set of pairs.
+*
+* @class Detector
+*/
+
+// TODO: speculative contacts
+
+var Detector = {};
+
+module.exports = Detector;
+
+var SAT = __webpack_require__(14);
+var Pair = __webpack_require__(9);
+var Bounds = __webpack_require__(1);
+
+(function() {
+
+ /**
+ * Finds all collisions given a list of pairs.
+ * @method collisions
+ * @param {pair[]} broadphasePairs
+ * @param {engine} engine
+ * @return {array} collisions
+ */
+ Detector.collisions = function(broadphasePairs, engine) {
+ var collisions = [],
+ pairsTable = engine.pairs.table;
+
+ for (var i = 0; i < broadphasePairs.length; i++) {
+ var bodyA = broadphasePairs[i][0],
+ bodyB = broadphasePairs[i][1];
+
+ if ((bodyA.isStatic || bodyA.isSleeping) && (bodyB.isStatic || bodyB.isSleeping))
+ continue;
+
+ if (!Detector.canCollide(bodyA.collisionFilter, bodyB.collisionFilter))
+ continue;
+
+ // mid phase
+ if (Bounds.overlaps(bodyA.bounds, bodyB.bounds)) {
+ for (var j = bodyA.parts.length > 1 ? 1 : 0; j < bodyA.parts.length; j++) {
+ var partA = bodyA.parts[j];
+
+ for (var k = bodyB.parts.length > 1 ? 1 : 0; k < bodyB.parts.length; k++) {
+ var partB = bodyB.parts[k];
+
+ if ((partA === bodyA && partB === bodyB) || Bounds.overlaps(partA.bounds, partB.bounds)) {
+ // find a previous collision we could reuse
+ var pairId = Pair.id(partA, partB),
+ pair = pairsTable[pairId],
+ previousCollision;
+
+ if (pair && pair.isActive) {
+ previousCollision = pair.collision;
+ } else {
+ previousCollision = null;
+ }
+
+ // narrow phase
+ var collision = SAT.collides(partA, partB, previousCollision);
+
+ if (collision.collided) {
+ collisions.push(collision);
+ }
+ }
+ }
+ }
+ }
+ }
+
+ return collisions;
+ };
+
+ /**
+ * Returns `true` if both supplied collision filters will allow a collision to occur.
+ * See `body.collisionFilter` for more information.
+ * @method canCollide
+ * @param {} filterA
+ * @param {} filterB
+ * @return {bool} `true` if collision can occur
+ */
+ Detector.canCollide = function(filterA, filterB) {
+ if (filterA.group === filterB.group && filterA.group !== 0)
+ return filterA.group > 0;
+
+ return (filterA.mask & filterB.category) !== 0 && (filterB.mask & filterA.category) !== 0;
+ };
+
+})();
+
+
+/***/ }),
+/* 14 */
+/***/ (function(module, exports, __webpack_require__) {
+
+/**
+* The `Matter.SAT` module contains methods for detecting collisions using the Separating Axis Theorem.
+*
+* @class SAT
+*/
+
+// TODO: true circles and curves
+
+var SAT = {};
+
+module.exports = SAT;
+
+var Vertices = __webpack_require__(3);
+var Vector = __webpack_require__(2);
+
+(function() {
+
+ /**
+ * Detect collision between two bodies using the Separating Axis Theorem.
+ * @method collides
+ * @param {body} bodyA
+ * @param {body} bodyB
+ * @param {collision} previousCollision
+ * @return {collision} collision
+ */
+ SAT.collides = function(bodyA, bodyB, previousCollision) {
+ var overlapAB,
+ overlapBA,
+ minOverlap,
+ collision,
+ canReusePrevCol = false;
+
+ if (previousCollision) {
+ // estimate total motion
+ var parentA = bodyA.parent,
+ parentB = bodyB.parent,
+ motion = parentA.speed * parentA.speed + parentA.angularSpeed * parentA.angularSpeed
+ + parentB.speed * parentB.speed + parentB.angularSpeed * parentB.angularSpeed;
+
+ // we may be able to (partially) reuse collision result
+ // but only safe if collision was resting
+ canReusePrevCol = previousCollision && previousCollision.collided && motion < 0.2;
+
+ // reuse collision object
+ collision = previousCollision;
+ } else {
+ collision = { collided: false, bodyA: bodyA, bodyB: bodyB };
+ }
+
+ if (previousCollision && canReusePrevCol) {
+ // if we can reuse the collision result
+ // we only need to test the previously found axis
+ var axisBodyA = collision.axisBody,
+ axisBodyB = axisBodyA === bodyA ? bodyB : bodyA,
+ axes = [axisBodyA.axes[previousCollision.axisNumber]];
+
+ minOverlap = SAT._overlapAxes(axisBodyA.vertices, axisBodyB.vertices, axes);
+ collision.reused = true;
+
+ if (minOverlap.overlap <= 0) {
+ collision.collided = false;
+ return collision;
+ }
+ } else {
+ // if we can't reuse a result, perform a full SAT test
+
+ overlapAB = SAT._overlapAxes(bodyA.vertices, bodyB.vertices, bodyA.axes);
+
+ if (overlapAB.overlap <= 0) {
+ collision.collided = false;
+ return collision;
+ }
+
+ overlapBA = SAT._overlapAxes(bodyB.vertices, bodyA.vertices, bodyB.axes);
+
+ if (overlapBA.overlap <= 0) {
+ collision.collided = false;
+ return collision;
+ }
+
+ if (overlapAB.overlap < overlapBA.overlap) {
+ minOverlap = overlapAB;
+ collision.axisBody = bodyA;
+ } else {
+ minOverlap = overlapBA;
+ collision.axisBody = bodyB;
+ }
+
+ // important for reuse later
+ collision.axisNumber = minOverlap.axisNumber;
+ }
+
+ collision.bodyA = bodyA.id < bodyB.id ? bodyA : bodyB;
+ collision.bodyB = bodyA.id < bodyB.id ? bodyB : bodyA;
+ collision.collided = true;
+ collision.depth = minOverlap.overlap;
+ collision.parentA = collision.bodyA.parent;
+ collision.parentB = collision.bodyB.parent;
+
+ bodyA = collision.bodyA;
+ bodyB = collision.bodyB;
+
+ // ensure normal is facing away from bodyA
+ if (Vector.dot(minOverlap.axis, Vector.sub(bodyB.position, bodyA.position)) < 0) {
+ collision.normal = {
+ x: minOverlap.axis.x,
+ y: minOverlap.axis.y
+ };
+ } else {
+ collision.normal = {
+ x: -minOverlap.axis.x,
+ y: -minOverlap.axis.y
+ };
+ }
+
+ collision.tangent = Vector.perp(collision.normal);
+
+ collision.penetration = collision.penetration || {};
+ collision.penetration.x = collision.normal.x * collision.depth;
+ collision.penetration.y = collision.normal.y * collision.depth;
+
+ // find support points, there is always either exactly one or two
+ var verticesB = SAT._findSupports(bodyA, bodyB, collision.normal),
+ supports = [];
+
+ // find the supports from bodyB that are inside bodyA
+ if (Vertices.contains(bodyA.vertices, verticesB[0]))
+ supports.push(verticesB[0]);
+
+ if (Vertices.contains(bodyA.vertices, verticesB[1]))
+ supports.push(verticesB[1]);
+
+ // find the supports from bodyA that are inside bodyB
+ if (supports.length < 2) {
+ var verticesA = SAT._findSupports(bodyB, bodyA, Vector.neg(collision.normal));
+
+ if (Vertices.contains(bodyB.vertices, verticesA[0]))
+ supports.push(verticesA[0]);
+
+ if (supports.length < 2 && Vertices.contains(bodyB.vertices, verticesA[1]))
+ supports.push(verticesA[1]);
+ }
+
+ // account for the edge case of overlapping but no vertex containment
+ if (supports.length < 1)
+ supports = [verticesB[0]];
+
+ collision.supports = supports;
+
+ return collision;
+ };
+
+ /**
+ * Find the overlap between two sets of vertices.
+ * @method _overlapAxes
+ * @private
+ * @param {} verticesA
+ * @param {} verticesB
+ * @param {} axes
+ * @return result
+ */
+ SAT._overlapAxes = function(verticesA, verticesB, axes) {
+ var projectionA = Vector._temp[0],
+ projectionB = Vector._temp[1],
+ result = { overlap: Number.MAX_VALUE },
+ overlap,
+ axis;
+
+ for (var i = 0; i < axes.length; i++) {
+ axis = axes[i];
+
+ SAT._projectToAxis(projectionA, verticesA, axis);
+ SAT._projectToAxis(projectionB, verticesB, axis);
+
+ overlap = Math.min(projectionA.max - projectionB.min, projectionB.max - projectionA.min);
+
+ if (overlap <= 0) {
+ result.overlap = overlap;
+ return result;
+ }
+
+ if (overlap < result.overlap) {
+ result.overlap = overlap;
+ result.axis = axis;
+ result.axisNumber = i;
+ }
+ }
+
+ return result;
+ };
+
+ /**
+ * Projects vertices on an axis and returns an interval.
+ * @method _projectToAxis
+ * @private
+ * @param {} projection
+ * @param {} vertices
+ * @param {} axis
+ */
+ SAT._projectToAxis = function(projection, vertices, axis) {
+ var min = Vector.dot(vertices[0], axis),
+ max = min;
+
+ for (var i = 1; i < vertices.length; i += 1) {
+ var dot = Vector.dot(vertices[i], axis);
+
+ if (dot > max) {
+ max = dot;
+ } else if (dot < min) {
+ min = dot;
+ }
+ }
+
+ projection.min = min;
+ projection.max = max;
+ };
+
+ /**
+ * Finds supporting vertices given two bodies along a given direction using hill-climbing.
+ * @method _findSupports
+ * @private
+ * @param {} bodyA
+ * @param {} bodyB
+ * @param {} normal
+ * @return [vector]
+ */
+ SAT._findSupports = function(bodyA, bodyB, normal) {
+ var nearestDistance = Number.MAX_VALUE,
+ vertexToBody = Vector._temp[0],
+ vertices = bodyB.vertices,
+ bodyAPosition = bodyA.position,
+ distance,
+ vertex,
+ vertexA,
+ vertexB;
+
+ // find closest vertex on bodyB
+ for (var i = 0; i < vertices.length; i++) {
+ vertex = vertices[i];
+ vertexToBody.x = vertex.x - bodyAPosition.x;
+ vertexToBody.y = vertex.y - bodyAPosition.y;
+ distance = -Vector.dot(normal, vertexToBody);
+
+ if (distance < nearestDistance) {
+ nearestDistance = distance;
+ vertexA = vertex;
+ }
+ }
+
+ // find next closest vertex using the two connected to it
+ var prevIndex = vertexA.index - 1 >= 0 ? vertexA.index - 1 : vertices.length - 1;
+ vertex = vertices[prevIndex];
+ vertexToBody.x = vertex.x - bodyAPosition.x;
+ vertexToBody.y = vertex.y - bodyAPosition.y;
+ nearestDistance = -Vector.dot(normal, vertexToBody);
+ vertexB = vertex;
+
+ var nextIndex = (vertexA.index + 1) % vertices.length;
+ vertex = vertices[nextIndex];
+ vertexToBody.x = vertex.x - bodyAPosition.x;
+ vertexToBody.y = vertex.y - bodyAPosition.y;
+ distance = -Vector.dot(normal, vertexToBody);
+ if (distance < nearestDistance) {
+ vertexB = vertex;
+ }
+
+ return [vertexA, vertexB];
+ };
+
+})();
+
+
+/***/ }),
+/* 15 */
+/***/ (function(module, exports, __webpack_require__) {
+
/**
* The `Matter.Plugin` module contains functions for registering and installing plugins on modules.
*
@@ -5735,7 +5393,7 @@ var Plugin = {};
module.exports = Plugin;
-var Common = _dereq_('./Common');
+var Common = __webpack_require__(0);
(function() {
@@ -5993,6 +5651,8 @@ var Common = _dereq_('./Common');
* Only the following range types are supported:
* - Tilde ranges e.g. `~1.2.3`
* - Caret ranges e.g. `^1.2.3`
+ * - Greater than ranges e.g. `>1.2.3`
+ * - Greater than or equal ranges e.g. `>=1.2.3`
* - Exact version e.g. `1.2.3`
* - Any version `*`
* @method versionParse
@@ -6000,29 +5660,28 @@ var Common = _dereq_('./Common');
* @return {object} The version range parsed into its components.
*/
Plugin.versionParse = function(range) {
- var pattern = /^\*|[\^~]?\d+\.\d+\.\d+(-[0-9A-Za-z-]+)?$/;
+ var pattern = /^(\*)|(\^|~|>=|>)?\s*((\d+)\.(\d+)\.(\d+))(-[0-9A-Za-z-]+)?$/;
if (!pattern.test(range)) {
Common.warn('Plugin.versionParse:', range, 'is not a valid version or range.');
}
- var identifiers = range.split('-');
- range = identifiers[0];
-
- var isRange = isNaN(Number(range[0])),
- version = isRange ? range.substr(1) : range,
- parts = Common.map(version.split('.'), function(part) {
- return Number(part);
- });
+ var parts = pattern.exec(range);
+ var major = Number(parts[4]);
+ var minor = Number(parts[5]);
+ var patch = Number(parts[6]);
return {
- isRange: isRange,
- version: version,
+ isRange: Boolean(parts[1] || parts[2]),
+ version: parts[3],
range: range,
- operator: isRange ? range[0] : '',
- parts: parts,
- prerelease: identifiers[1],
- number: parts[0] * 1e8 + parts[1] * 1e4 + parts[2]
+ operator: parts[1] || parts[2] || '',
+ major: major,
+ minor: minor,
+ patch: patch,
+ parts: [major, minor, patch],
+ prerelease: parts[7],
+ number: major * 1e8 + minor * 1e4 + patch
};
};
@@ -6038,30 +5697,36 @@ var Common = _dereq_('./Common');
Plugin.versionSatisfies = function(version, range) {
range = range || '*';
- var rangeParsed = Plugin.versionParse(range),
- rangeParts = rangeParsed.parts,
- versionParsed = Plugin.versionParse(version),
- versionParts = versionParsed.parts;
+ var r = Plugin.versionParse(range),
+ v = Plugin.versionParse(version);
- if (rangeParsed.isRange) {
- if (rangeParsed.operator === '*' || version === '*') {
+ if (r.isRange) {
+ if (r.operator === '*' || version === '*') {
return true;
}
- if (rangeParsed.operator === '~') {
- return versionParts[0] === rangeParts[0] && versionParts[1] === rangeParts[1] && versionParts[2] >= rangeParts[2];
+ if (r.operator === '>') {
+ return v.number > r.number;
}
- if (rangeParsed.operator === '^') {
- if (rangeParts[0] > 0) {
- return versionParts[0] === rangeParts[0] && versionParsed.number >= rangeParsed.number;
+ if (r.operator === '>=') {
+ return v.number >= r.number;
+ }
+
+ if (r.operator === '~') {
+ return v.major === r.major && v.minor === r.minor && v.patch >= r.patch;
+ }
+
+ if (r.operator === '^') {
+ if (r.major > 0) {
+ return v.major === r.major && v.number >= r.number;
}
- if (rangeParts[1] > 0) {
- return versionParts[1] === rangeParts[1] && versionParts[2] >= rangeParts[2];
+ if (r.minor > 0) {
+ return v.minor === r.minor && v.patch >= r.patch;
}
- return versionParts[2] === rangeParts[2];
+ return v.patch === r.patch;
}
}
@@ -6070,2292 +5735,13 @@ var Common = _dereq_('./Common');
})();
-},{"./Common":14}],21:[function(_dereq_,module,exports){
+
+/***/ }),
+/* 16 */
+/***/ (function(module, exports, __webpack_require__) {
+
/**
-* The `Matter.Runner` module is an optional utility which provides a game loop,
-* that handles continuously updating a `Matter.Engine` for you within a browser.
-* It is intended for development and debugging purposes, but may also be suitable for simple games.
-* If you are using your own game loop instead, then you do not need the `Matter.Runner` module.
-* Instead just call `Engine.update(engine, delta)` in your own loop.
-*
-* See the included usage [examples](https://github.com/liabru/matter-js/tree/master/examples).
-*
-* @class Runner
-*/
-
-var Runner = {};
-
-module.exports = Runner;
-
-var Events = _dereq_('./Events');
-var Engine = _dereq_('./Engine');
-var Common = _dereq_('./Common');
-
-(function() {
-
- var _requestAnimationFrame,
- _cancelAnimationFrame;
-
- if (typeof window !== 'undefined') {
- _requestAnimationFrame = window.requestAnimationFrame || window.webkitRequestAnimationFrame
- || window.mozRequestAnimationFrame || window.msRequestAnimationFrame;
-
- _cancelAnimationFrame = window.cancelAnimationFrame || window.mozCancelAnimationFrame
- || window.webkitCancelAnimationFrame || window.msCancelAnimationFrame;
- }
-
- if (!_requestAnimationFrame) {
- var _frameTimeout;
-
- _requestAnimationFrame = function(callback){
- _frameTimeout = setTimeout(function() {
- callback(Common.now());
- }, 1000 / 60);
- };
-
- _cancelAnimationFrame = function() {
- clearTimeout(_frameTimeout);
- };
- }
-
- /**
- * Creates a new Runner. The options parameter is an object that specifies any properties you wish to override the defaults.
- * @method create
- * @param {} options
- */
- Runner.create = function(options) {
- var defaults = {
- fps: 60,
- correction: 1,
- deltaSampleSize: 60,
- counterTimestamp: 0,
- frameCounter: 0,
- deltaHistory: [],
- timePrev: null,
- timeScalePrev: 1,
- frameRequestId: null,
- isFixed: false,
- enabled: true
- };
-
- var runner = Common.extend(defaults, options);
-
- runner.delta = runner.delta || 1000 / runner.fps;
- runner.deltaMin = runner.deltaMin || 1000 / runner.fps;
- runner.deltaMax = runner.deltaMax || 1000 / (runner.fps * 0.5);
- runner.fps = 1000 / runner.delta;
-
- return runner;
- };
-
- /**
- * Continuously ticks a `Matter.Engine` by calling `Runner.tick` on the `requestAnimationFrame` event.
- * @method run
- * @param {engine} engine
- */
- Runner.run = function(runner, engine) {
- // create runner if engine is first argument
- if (typeof runner.positionIterations !== 'undefined') {
- engine = runner;
- runner = Runner.create();
- }
-
- (function render(time){
- runner.frameRequestId = _requestAnimationFrame(render);
-
- if (time && runner.enabled) {
- Runner.tick(runner, engine, time);
- }
- })();
-
- return runner;
- };
-
- /**
- * A game loop utility that updates the engine and renderer by one step (a 'tick').
- * Features delta smoothing, time correction and fixed or dynamic timing.
- * Triggers `beforeTick`, `tick` and `afterTick` events on the engine.
- * Consider just `Engine.update(engine, delta)` if you're using your own loop.
- * @method tick
- * @param {runner} runner
- * @param {engine} engine
- * @param {number} time
- */
- Runner.tick = function(runner, engine, time) {
- var timing = engine.timing,
- correction = 1,
- delta;
-
- // create an event object
- var event = {
- timestamp: timing.timestamp
- };
-
- Events.trigger(runner, 'beforeTick', event);
- Events.trigger(engine, 'beforeTick', event); // @deprecated
-
- if (runner.isFixed) {
- // fixed timestep
- delta = runner.delta;
- } else {
- // dynamic timestep based on wall clock between calls
- delta = (time - runner.timePrev) || runner.delta;
- runner.timePrev = time;
-
- // optimistically filter delta over a few frames, to improve stability
- runner.deltaHistory.push(delta);
- runner.deltaHistory = runner.deltaHistory.slice(-runner.deltaSampleSize);
- delta = Math.min.apply(null, runner.deltaHistory);
-
- // limit delta
- delta = delta < runner.deltaMin ? runner.deltaMin : delta;
- delta = delta > runner.deltaMax ? runner.deltaMax : delta;
-
- // correction for delta
- correction = delta / runner.delta;
-
- // update engine timing object
- runner.delta = delta;
- }
-
- // time correction for time scaling
- if (runner.timeScalePrev !== 0)
- correction *= timing.timeScale / runner.timeScalePrev;
-
- if (timing.timeScale === 0)
- correction = 0;
-
- runner.timeScalePrev = timing.timeScale;
- runner.correction = correction;
-
- // fps counter
- runner.frameCounter += 1;
- if (time - runner.counterTimestamp >= 1000) {
- runner.fps = runner.frameCounter * ((time - runner.counterTimestamp) / 1000);
- runner.counterTimestamp = time;
- runner.frameCounter = 0;
- }
-
- Events.trigger(runner, 'tick', event);
- Events.trigger(engine, 'tick', event); // @deprecated
-
- // if world has been modified, clear the render scene graph
- if (engine.world.isModified
- && engine.render
- && engine.render.controller
- && engine.render.controller.clear) {
- engine.render.controller.clear(engine.render); // @deprecated
- }
-
- // update
- Events.trigger(runner, 'beforeUpdate', event);
- Engine.update(engine, delta, correction);
- Events.trigger(runner, 'afterUpdate', event);
-
- // render
- // @deprecated
- if (engine.render && engine.render.controller) {
- Events.trigger(runner, 'beforeRender', event);
- Events.trigger(engine, 'beforeRender', event); // @deprecated
-
- engine.render.controller.world(engine.render);
-
- Events.trigger(runner, 'afterRender', event);
- Events.trigger(engine, 'afterRender', event); // @deprecated
- }
-
- Events.trigger(runner, 'afterTick', event);
- Events.trigger(engine, 'afterTick', event); // @deprecated
- };
-
- /**
- * Ends execution of `Runner.run` on the given `runner`, by canceling the animation frame request event loop.
- * If you wish to only temporarily pause the engine, see `engine.enabled` instead.
- * @method stop
- * @param {runner} runner
- */
- Runner.stop = function(runner) {
- _cancelAnimationFrame(runner.frameRequestId);
- };
-
- /**
- * Alias for `Runner.run`.
- * @method start
- * @param {runner} runner
- * @param {engine} engine
- */
- Runner.start = function(runner, engine) {
- Runner.run(runner, engine);
- };
-
- /*
- *
- * Events Documentation
- *
- */
-
- /**
- * Fired at the start of a tick, before any updates to the engine or timing
- *
- * @event beforeTick
- * @param {} event An event object
- * @param {number} event.timestamp The engine.timing.timestamp of the event
- * @param {} event.source The source object of the event
- * @param {} event.name The name of the event
- */
-
- /**
- * Fired after engine timing updated, but just before update
- *
- * @event tick
- * @param {} event An event object
- * @param {number} event.timestamp The engine.timing.timestamp of the event
- * @param {} event.source The source object of the event
- * @param {} event.name The name of the event
- */
-
- /**
- * Fired at the end of a tick, after engine update and after rendering
- *
- * @event afterTick
- * @param {} event An event object
- * @param {number} event.timestamp The engine.timing.timestamp of the event
- * @param {} event.source The source object of the event
- * @param {} event.name The name of the event
- */
-
- /**
- * Fired before update
- *
- * @event beforeUpdate
- * @param {} event An event object
- * @param {number} event.timestamp The engine.timing.timestamp of the event
- * @param {} event.source The source object of the event
- * @param {} event.name The name of the event
- */
-
- /**
- * Fired after update
- *
- * @event afterUpdate
- * @param {} event An event object
- * @param {number} event.timestamp The engine.timing.timestamp of the event
- * @param {} event.source The source object of the event
- * @param {} event.name The name of the event
- */
-
- /**
- * Fired before rendering
- *
- * @event beforeRender
- * @param {} event An event object
- * @param {number} event.timestamp The engine.timing.timestamp of the event
- * @param {} event.source The source object of the event
- * @param {} event.name The name of the event
- * @deprecated
- */
-
- /**
- * Fired after rendering
- *
- * @event afterRender
- * @param {} event An event object
- * @param {number} event.timestamp The engine.timing.timestamp of the event
- * @param {} event.source The source object of the event
- * @param {} event.name The name of the event
- * @deprecated
- */
-
- /*
- *
- * Properties Documentation
- *
- */
-
- /**
- * A flag that specifies whether the runner is running or not.
- *
- * @property enabled
- * @type boolean
- * @default true
- */
-
- /**
- * A `Boolean` that specifies if the runner should use a fixed timestep (otherwise it is variable).
- * If timing is fixed, then the apparent simulation speed will change depending on the frame rate (but behaviour will be deterministic).
- * If the timing is variable, then the apparent simulation speed will be constant (approximately, but at the cost of determininism).
- *
- * @property isFixed
- * @type boolean
- * @default false
- */
-
- /**
- * A `Number` that specifies the time step between updates in milliseconds.
- * If `engine.timing.isFixed` is set to `true`, then `delta` is fixed.
- * If it is `false`, then `delta` can dynamically change to maintain the correct apparent simulation speed.
- *
- * @property delta
- * @type number
- * @default 1000 / 60
- */
-
-})();
-
-},{"./Common":14,"./Engine":15,"./Events":16}],22:[function(_dereq_,module,exports){
-/**
-* The `Matter.Sleeping` module contains methods to manage the sleeping state of bodies.
-*
-* @class Sleeping
-*/
-
-var Sleeping = {};
-
-module.exports = Sleeping;
-
-var Events = _dereq_('./Events');
-
-(function() {
-
- Sleeping._motionWakeThreshold = 0.18;
- Sleeping._motionSleepThreshold = 0.08;
- Sleeping._minBias = 0.9;
-
- /**
- * Puts bodies to sleep or wakes them up depending on their motion.
- * @method update
- * @param {body[]} bodies
- * @param {number} timeScale
- */
- Sleeping.update = function(bodies, timeScale) {
- var timeFactor = timeScale * timeScale * timeScale;
-
- // update bodies sleeping status
- for (var i = 0; i < bodies.length; i++) {
- var body = bodies[i],
- motion = body.speed * body.speed + body.angularSpeed * body.angularSpeed;
-
- // wake up bodies if they have a force applied
- if (body.force.x !== 0 || body.force.y !== 0) {
- Sleeping.set(body, false);
- continue;
- }
-
- var minMotion = Math.min(body.motion, motion),
- maxMotion = Math.max(body.motion, motion);
-
- // biased average motion estimation between frames
- body.motion = Sleeping._minBias * minMotion + (1 - Sleeping._minBias) * maxMotion;
-
- if (body.sleepThreshold > 0 && body.motion < Sleeping._motionSleepThreshold * timeFactor) {
- body.sleepCounter += 1;
-
- if (body.sleepCounter >= body.sleepThreshold)
- Sleeping.set(body, true);
- } else if (body.sleepCounter > 0) {
- body.sleepCounter -= 1;
- }
- }
- };
-
- /**
- * Given a set of colliding pairs, wakes the sleeping bodies involved.
- * @method afterCollisions
- * @param {pair[]} pairs
- * @param {number} timeScale
- */
- Sleeping.afterCollisions = function(pairs, timeScale) {
- var timeFactor = timeScale * timeScale * timeScale;
-
- // wake up bodies involved in collisions
- for (var i = 0; i < pairs.length; i++) {
- var pair = pairs[i];
-
- // don't wake inactive pairs
- if (!pair.isActive)
- continue;
-
- var collision = pair.collision,
- bodyA = collision.bodyA.parent,
- bodyB = collision.bodyB.parent;
-
- // don't wake if at least one body is static
- if ((bodyA.isSleeping && bodyB.isSleeping) || bodyA.isStatic || bodyB.isStatic)
- continue;
-
- if (bodyA.isSleeping || bodyB.isSleeping) {
- var sleepingBody = (bodyA.isSleeping && !bodyA.isStatic) ? bodyA : bodyB,
- movingBody = sleepingBody === bodyA ? bodyB : bodyA;
-
- if (!sleepingBody.isStatic && movingBody.motion > Sleeping._motionWakeThreshold * timeFactor) {
- Sleeping.set(sleepingBody, false);
- }
- }
- }
- };
-
- /**
- * Set a body as sleeping or awake.
- * @method set
- * @param {body} body
- * @param {boolean} isSleeping
- */
- Sleeping.set = function(body, isSleeping) {
- var wasSleeping = body.isSleeping;
-
- if (isSleeping) {
- body.isSleeping = true;
- body.sleepCounter = body.sleepThreshold;
-
- body.positionImpulse.x = 0;
- body.positionImpulse.y = 0;
-
- body.positionPrev.x = body.position.x;
- body.positionPrev.y = body.position.y;
-
- body.anglePrev = body.angle;
- body.speed = 0;
- body.angularSpeed = 0;
- body.motion = 0;
-
- if (!wasSleeping) {
- Events.trigger(body, 'sleepStart');
- }
- } else {
- body.isSleeping = false;
- body.sleepCounter = 0;
-
- if (wasSleeping) {
- Events.trigger(body, 'sleepEnd');
- }
- }
- };
-
-})();
-
-},{"./Events":16}],23:[function(_dereq_,module,exports){
-/**
-* The `Matter.Bodies` module contains factory methods for creating rigid body models
-* with commonly used body configurations (such as rectangles, circles and other polygons).
-*
-* See the included usage [examples](https://github.com/liabru/matter-js/tree/master/examples).
-*
-* @class Bodies
-*/
-
-// TODO: true circle bodies
-
-var Bodies = {};
-
-module.exports = Bodies;
-
-var Vertices = _dereq_('../geometry/Vertices');
-var Common = _dereq_('../core/Common');
-var Body = _dereq_('../body/Body');
-var Bounds = _dereq_('../geometry/Bounds');
-var Vector = _dereq_('../geometry/Vector');
-var decomp;
-
-(function() {
-
- /**
- * Creates a new rigid body model with a rectangle hull.
- * The options parameter is an object that specifies any properties you wish to override the defaults.
- * See the properties section of the `Matter.Body` module for detailed information on what you can pass via the `options` object.
- * @method rectangle
- * @param {number} x
- * @param {number} y
- * @param {number} width
- * @param {number} height
- * @param {object} [options]
- * @return {body} A new rectangle body
- */
- Bodies.rectangle = function(x, y, width, height, options) {
- options = options || {};
-
- var rectangle = {
- label: 'Rectangle Body',
- position: { x: x, y: y },
- vertices: Vertices.fromPath('L 0 0 L ' + width + ' 0 L ' + width + ' ' + height + ' L 0 ' + height)
- };
-
- if (options.chamfer) {
- var chamfer = options.chamfer;
- rectangle.vertices = Vertices.chamfer(rectangle.vertices, chamfer.radius,
- chamfer.quality, chamfer.qualityMin, chamfer.qualityMax);
- delete options.chamfer;
- }
-
- return Body.create(Common.extend({}, rectangle, options));
- };
-
- /**
- * Creates a new rigid body model with a trapezoid hull.
- * The options parameter is an object that specifies any properties you wish to override the defaults.
- * See the properties section of the `Matter.Body` module for detailed information on what you can pass via the `options` object.
- * @method trapezoid
- * @param {number} x
- * @param {number} y
- * @param {number} width
- * @param {number} height
- * @param {number} slope
- * @param {object} [options]
- * @return {body} A new trapezoid body
- */
- Bodies.trapezoid = function(x, y, width, height, slope, options) {
- options = options || {};
-
- slope *= 0.5;
- var roof = (1 - (slope * 2)) * width;
-
- var x1 = width * slope,
- x2 = x1 + roof,
- x3 = x2 + x1,
- verticesPath;
-
- if (slope < 0.5) {
- verticesPath = 'L 0 0 L ' + x1 + ' ' + (-height) + ' L ' + x2 + ' ' + (-height) + ' L ' + x3 + ' 0';
- } else {
- verticesPath = 'L 0 0 L ' + x2 + ' ' + (-height) + ' L ' + x3 + ' 0';
- }
-
- var trapezoid = {
- label: 'Trapezoid Body',
- position: { x: x, y: y },
- vertices: Vertices.fromPath(verticesPath)
- };
-
- if (options.chamfer) {
- var chamfer = options.chamfer;
- trapezoid.vertices = Vertices.chamfer(trapezoid.vertices, chamfer.radius,
- chamfer.quality, chamfer.qualityMin, chamfer.qualityMax);
- delete options.chamfer;
- }
-
- return Body.create(Common.extend({}, trapezoid, options));
- };
-
- /**
- * Creates a new rigid body model with a circle hull.
- * The options parameter is an object that specifies any properties you wish to override the defaults.
- * See the properties section of the `Matter.Body` module for detailed information on what you can pass via the `options` object.
- * @method circle
- * @param {number} x
- * @param {number} y
- * @param {number} radius
- * @param {object} [options]
- * @param {number} [maxSides]
- * @return {body} A new circle body
- */
- Bodies.circle = function(x, y, radius, options, maxSides) {
- options = options || {};
-
- var circle = {
- label: 'Circle Body',
- circleRadius: radius
- };
-
- // approximate circles with polygons until true circles implemented in SAT
- maxSides = maxSides || 25;
- var sides = Math.ceil(Math.max(10, Math.min(maxSides, radius)));
-
- // optimisation: always use even number of sides (half the number of unique axes)
- if (sides % 2 === 1)
- sides += 1;
-
- return Bodies.polygon(x, y, sides, radius, Common.extend({}, circle, options));
- };
-
- /**
- * Creates a new rigid body model with a regular polygon hull with the given number of sides.
- * The options parameter is an object that specifies any properties you wish to override the defaults.
- * See the properties section of the `Matter.Body` module for detailed information on what you can pass via the `options` object.
- * @method polygon
- * @param {number} x
- * @param {number} y
- * @param {number} sides
- * @param {number} radius
- * @param {object} [options]
- * @return {body} A new regular polygon body
- */
- Bodies.polygon = function(x, y, sides, radius, options) {
- options = options || {};
-
- if (sides < 3)
- return Bodies.circle(x, y, radius, options);
-
- var theta = 2 * Math.PI / sides,
- path = '',
- offset = theta * 0.5;
-
- for (var i = 0; i < sides; i += 1) {
- var angle = offset + (i * theta),
- xx = Math.cos(angle) * radius,
- yy = Math.sin(angle) * radius;
-
- path += 'L ' + xx.toFixed(3) + ' ' + yy.toFixed(3) + ' ';
- }
-
- var polygon = {
- label: 'Polygon Body',
- position: { x: x, y: y },
- vertices: Vertices.fromPath(path)
- };
-
- if (options.chamfer) {
- var chamfer = options.chamfer;
- polygon.vertices = Vertices.chamfer(polygon.vertices, chamfer.radius,
- chamfer.quality, chamfer.qualityMin, chamfer.qualityMax);
- delete options.chamfer;
- }
-
- return Body.create(Common.extend({}, polygon, options));
- };
-
- /**
- * Creates a body using the supplied vertices (or an array containing multiple sets of vertices).
- * If the vertices are convex, they will pass through as supplied.
- * Otherwise if the vertices are concave, they will be decomposed if [poly-decomp.js](https://github.com/schteppe/poly-decomp.js) is available.
- * Note that this process is not guaranteed to support complex sets of vertices (e.g. those with holes may fail).
- * By default the decomposition will discard collinear edges (to improve performance).
- * It can also optionally discard any parts that have an area less than `minimumArea`.
- * If the vertices can not be decomposed, the result will fall back to using the convex hull.
- * The options parameter is an object that specifies any `Matter.Body` properties you wish to override the defaults.
- * See the properties section of the `Matter.Body` module for detailed information on what you can pass via the `options` object.
- * @method fromVertices
- * @param {number} x
- * @param {number} y
- * @param [[vector]] vertexSets
- * @param {object} [options]
- * @param {bool} [flagInternal=false]
- * @param {number} [removeCollinear=0.01]
- * @param {number} [minimumArea=10]
- * @return {body}
- */
- Bodies.fromVertices = function(x, y, vertexSets, options, flagInternal, removeCollinear, minimumArea) {
- if (!decomp) {
- decomp = Common._requireGlobal('decomp', 'poly-decomp');
- }
-
- var body,
- parts,
- isConvex,
- vertices,
- i,
- j,
- k,
- v,
- z;
-
- options = options || {};
- parts = [];
-
- flagInternal = typeof flagInternal !== 'undefined' ? flagInternal : false;
- removeCollinear = typeof removeCollinear !== 'undefined' ? removeCollinear : 0.01;
- minimumArea = typeof minimumArea !== 'undefined' ? minimumArea : 10;
-
- if (!decomp) {
- Common.warn('Bodies.fromVertices: poly-decomp.js required. Could not decompose vertices. Fallback to convex hull.');
- }
-
- // ensure vertexSets is an array of arrays
- if (!Common.isArray(vertexSets[0])) {
- vertexSets = [vertexSets];
- }
-
- for (v = 0; v < vertexSets.length; v += 1) {
- vertices = vertexSets[v];
- isConvex = Vertices.isConvex(vertices);
-
- if (isConvex || !decomp) {
- if (isConvex) {
- vertices = Vertices.clockwiseSort(vertices);
- } else {
- // fallback to convex hull when decomposition is not possible
- vertices = Vertices.hull(vertices);
- }
-
- parts.push({
- position: { x: x, y: y },
- vertices: vertices
- });
- } else {
- // initialise a decomposition
- var concave = vertices.map(function(vertex) {
- return [vertex.x, vertex.y];
- });
-
- // vertices are concave and simple, we can decompose into parts
- decomp.makeCCW(concave);
- if (removeCollinear !== false)
- decomp.removeCollinearPoints(concave, removeCollinear);
-
- // use the quick decomposition algorithm (Bayazit)
- var decomposed = decomp.quickDecomp(concave);
-
- // for each decomposed chunk
- for (i = 0; i < decomposed.length; i++) {
- var chunk = decomposed[i];
-
- // convert vertices into the correct structure
- var chunkVertices = chunk.map(function(vertices) {
- return {
- x: vertices[0],
- y: vertices[1]
- };
- });
-
- // skip small chunks
- if (minimumArea > 0 && Vertices.area(chunkVertices) < minimumArea)
- continue;
-
- // create a compound part
- parts.push({
- position: Vertices.centre(chunkVertices),
- vertices: chunkVertices
- });
- }
- }
- }
-
- // create body parts
- for (i = 0; i < parts.length; i++) {
- parts[i] = Body.create(Common.extend(parts[i], options));
- }
-
- // flag internal edges (coincident part edges)
- if (flagInternal) {
- var coincident_max_dist = 5;
-
- for (i = 0; i < parts.length; i++) {
- var partA = parts[i];
-
- for (j = i + 1; j < parts.length; j++) {
- var partB = parts[j];
-
- if (Bounds.overlaps(partA.bounds, partB.bounds)) {
- var pav = partA.vertices,
- pbv = partB.vertices;
-
- // iterate vertices of both parts
- for (k = 0; k < partA.vertices.length; k++) {
- for (z = 0; z < partB.vertices.length; z++) {
- // find distances between the vertices
- var da = Vector.magnitudeSquared(Vector.sub(pav[(k + 1) % pav.length], pbv[z])),
- db = Vector.magnitudeSquared(Vector.sub(pav[k], pbv[(z + 1) % pbv.length]));
-
- // if both vertices are very close, consider the edge concident (internal)
- if (da < coincident_max_dist && db < coincident_max_dist) {
- pav[k].isInternal = true;
- pbv[z].isInternal = true;
- }
- }
- }
-
- }
- }
- }
- }
-
- if (parts.length > 1) {
- // create the parent body to be returned, that contains generated compound parts
- body = Body.create(Common.extend({ parts: parts.slice(0) }, options));
- Body.setPosition(body, { x: x, y: y });
-
- return body;
- } else {
- return parts[0];
- }
- };
-
-})();
-
-},{"../body/Body":1,"../core/Common":14,"../geometry/Bounds":26,"../geometry/Vector":28,"../geometry/Vertices":29}],24:[function(_dereq_,module,exports){
-/**
-* The `Matter.Composites` module contains factory methods for creating composite bodies
-* with commonly used configurations (such as stacks and chains).
-*
-* See the included usage [examples](https://github.com/liabru/matter-js/tree/master/examples).
-*
-* @class Composites
-*/
-
-var Composites = {};
-
-module.exports = Composites;
-
-var Composite = _dereq_('../body/Composite');
-var Constraint = _dereq_('../constraint/Constraint');
-var Common = _dereq_('../core/Common');
-var Body = _dereq_('../body/Body');
-var Bodies = _dereq_('./Bodies');
-
-(function() {
-
- /**
- * Create a new composite containing bodies created in the callback in a grid arrangement.
- * This function uses the body's bounds to prevent overlaps.
- * @method stack
- * @param {number} xx
- * @param {number} yy
- * @param {number} columns
- * @param {number} rows
- * @param {number} columnGap
- * @param {number} rowGap
- * @param {function} callback
- * @return {composite} A new composite containing objects created in the callback
- */
- Composites.stack = function(xx, yy, columns, rows, columnGap, rowGap, callback) {
- var stack = Composite.create({ label: 'Stack' }),
- x = xx,
- y = yy,
- lastBody,
- i = 0;
-
- for (var row = 0; row < rows; row++) {
- var maxHeight = 0;
-
- for (var column = 0; column < columns; column++) {
- var body = callback(x, y, column, row, lastBody, i);
-
- if (body) {
- var bodyHeight = body.bounds.max.y - body.bounds.min.y,
- bodyWidth = body.bounds.max.x - body.bounds.min.x;
-
- if (bodyHeight > maxHeight)
- maxHeight = bodyHeight;
-
- Body.translate(body, { x: bodyWidth * 0.5, y: bodyHeight * 0.5 });
-
- x = body.bounds.max.x + columnGap;
-
- Composite.addBody(stack, body);
-
- lastBody = body;
- i += 1;
- } else {
- x += columnGap;
- }
- }
-
- y += maxHeight + rowGap;
- x = xx;
- }
-
- return stack;
- };
-
- /**
- * Chains all bodies in the given composite together using constraints.
- * @method chain
- * @param {composite} composite
- * @param {number} xOffsetA
- * @param {number} yOffsetA
- * @param {number} xOffsetB
- * @param {number} yOffsetB
- * @param {object} options
- * @return {composite} A new composite containing objects chained together with constraints
- */
- Composites.chain = function(composite, xOffsetA, yOffsetA, xOffsetB, yOffsetB, options) {
- var bodies = composite.bodies;
-
- for (var i = 1; i < bodies.length; i++) {
- var bodyA = bodies[i - 1],
- bodyB = bodies[i],
- bodyAHeight = bodyA.bounds.max.y - bodyA.bounds.min.y,
- bodyAWidth = bodyA.bounds.max.x - bodyA.bounds.min.x,
- bodyBHeight = bodyB.bounds.max.y - bodyB.bounds.min.y,
- bodyBWidth = bodyB.bounds.max.x - bodyB.bounds.min.x;
-
- var defaults = {
- bodyA: bodyA,
- pointA: { x: bodyAWidth * xOffsetA, y: bodyAHeight * yOffsetA },
- bodyB: bodyB,
- pointB: { x: bodyBWidth * xOffsetB, y: bodyBHeight * yOffsetB }
- };
-
- var constraint = Common.extend(defaults, options);
-
- Composite.addConstraint(composite, Constraint.create(constraint));
- }
-
- composite.label += ' Chain';
-
- return composite;
- };
-
- /**
- * Connects bodies in the composite with constraints in a grid pattern, with optional cross braces.
- * @method mesh
- * @param {composite} composite
- * @param {number} columns
- * @param {number} rows
- * @param {boolean} crossBrace
- * @param {object} options
- * @return {composite} The composite containing objects meshed together with constraints
- */
- Composites.mesh = function(composite, columns, rows, crossBrace, options) {
- var bodies = composite.bodies,
- row,
- col,
- bodyA,
- bodyB,
- bodyC;
-
- for (row = 0; row < rows; row++) {
- for (col = 1; col < columns; col++) {
- bodyA = bodies[(col - 1) + (row * columns)];
- bodyB = bodies[col + (row * columns)];
- Composite.addConstraint(composite, Constraint.create(Common.extend({ bodyA: bodyA, bodyB: bodyB }, options)));
- }
-
- if (row > 0) {
- for (col = 0; col < columns; col++) {
- bodyA = bodies[col + ((row - 1) * columns)];
- bodyB = bodies[col + (row * columns)];
- Composite.addConstraint(composite, Constraint.create(Common.extend({ bodyA: bodyA, bodyB: bodyB }, options)));
-
- if (crossBrace && col > 0) {
- bodyC = bodies[(col - 1) + ((row - 1) * columns)];
- Composite.addConstraint(composite, Constraint.create(Common.extend({ bodyA: bodyC, bodyB: bodyB }, options)));
- }
-
- if (crossBrace && col < columns - 1) {
- bodyC = bodies[(col + 1) + ((row - 1) * columns)];
- Composite.addConstraint(composite, Constraint.create(Common.extend({ bodyA: bodyC, bodyB: bodyB }, options)));
- }
- }
- }
- }
-
- composite.label += ' Mesh';
-
- return composite;
- };
-
- /**
- * Create a new composite containing bodies created in the callback in a pyramid arrangement.
- * This function uses the body's bounds to prevent overlaps.
- * @method pyramid
- * @param {number} xx
- * @param {number} yy
- * @param {number} columns
- * @param {number} rows
- * @param {number} columnGap
- * @param {number} rowGap
- * @param {function} callback
- * @return {composite} A new composite containing objects created in the callback
- */
- Composites.pyramid = function(xx, yy, columns, rows, columnGap, rowGap, callback) {
- return Composites.stack(xx, yy, columns, rows, columnGap, rowGap, function(x, y, column, row, lastBody, i) {
- var actualRows = Math.min(rows, Math.ceil(columns / 2)),
- lastBodyWidth = lastBody ? lastBody.bounds.max.x - lastBody.bounds.min.x : 0;
-
- if (row > actualRows)
- return;
-
- // reverse row order
- row = actualRows - row;
-
- var start = row,
- end = columns - 1 - row;
-
- if (column < start || column > end)
- return;
-
- // retroactively fix the first body's position, since width was unknown
- if (i === 1) {
- Body.translate(lastBody, { x: (column + (columns % 2 === 1 ? 1 : -1)) * lastBodyWidth, y: 0 });
- }
-
- var xOffset = lastBody ? column * lastBodyWidth : 0;
-
- return callback(xx + xOffset + column * columnGap, y, column, row, lastBody, i);
- });
- };
-
- /**
- * Creates a composite with a Newton's Cradle setup of bodies and constraints.
- * @method newtonsCradle
- * @param {number} xx
- * @param {number} yy
- * @param {number} number
- * @param {number} size
- * @param {number} length
- * @return {composite} A new composite newtonsCradle body
- */
- Composites.newtonsCradle = function(xx, yy, number, size, length) {
- var newtonsCradle = Composite.create({ label: 'Newtons Cradle' });
-
- for (var i = 0; i < number; i++) {
- var separation = 1.9,
- circle = Bodies.circle(xx + i * (size * separation), yy + length, size,
- { inertia: Infinity, restitution: 1, friction: 0, frictionAir: 0.0001, slop: 1 }),
- constraint = Constraint.create({ pointA: { x: xx + i * (size * separation), y: yy }, bodyB: circle });
-
- Composite.addBody(newtonsCradle, circle);
- Composite.addConstraint(newtonsCradle, constraint);
- }
-
- return newtonsCradle;
- };
-
- /**
- * Creates a composite with simple car setup of bodies and constraints.
- * @method car
- * @param {number} xx
- * @param {number} yy
- * @param {number} width
- * @param {number} height
- * @param {number} wheelSize
- * @return {composite} A new composite car body
- */
- Composites.car = function(xx, yy, width, height, wheelSize) {
- var group = Body.nextGroup(true),
- wheelBase = 20,
- wheelAOffset = -width * 0.5 + wheelBase,
- wheelBOffset = width * 0.5 - wheelBase,
- wheelYOffset = 0;
-
- var car = Composite.create({ label: 'Car' }),
- body = Bodies.rectangle(xx, yy, width, height, {
- collisionFilter: {
- group: group
- },
- chamfer: {
- radius: height * 0.5
- },
- density: 0.0002
- });
-
- var wheelA = Bodies.circle(xx + wheelAOffset, yy + wheelYOffset, wheelSize, {
- collisionFilter: {
- group: group
- },
- friction: 0.8
- });
-
- var wheelB = Bodies.circle(xx + wheelBOffset, yy + wheelYOffset, wheelSize, {
- collisionFilter: {
- group: group
- },
- friction: 0.8
- });
-
- var axelA = Constraint.create({
- bodyB: body,
- pointB: { x: wheelAOffset, y: wheelYOffset },
- bodyA: wheelA,
- stiffness: 1,
- length: 0
- });
-
- var axelB = Constraint.create({
- bodyB: body,
- pointB: { x: wheelBOffset, y: wheelYOffset },
- bodyA: wheelB,
- stiffness: 1,
- length: 0
- });
-
- Composite.addBody(car, body);
- Composite.addBody(car, wheelA);
- Composite.addBody(car, wheelB);
- Composite.addConstraint(car, axelA);
- Composite.addConstraint(car, axelB);
-
- return car;
- };
-
- /**
- * Creates a simple soft body like object.
- * @method softBody
- * @param {number} xx
- * @param {number} yy
- * @param {number} columns
- * @param {number} rows
- * @param {number} columnGap
- * @param {number} rowGap
- * @param {boolean} crossBrace
- * @param {number} particleRadius
- * @param {} particleOptions
- * @param {} constraintOptions
- * @return {composite} A new composite softBody
- */
- Composites.softBody = function(xx, yy, columns, rows, columnGap, rowGap, crossBrace, particleRadius, particleOptions, constraintOptions) {
- particleOptions = Common.extend({ inertia: Infinity }, particleOptions);
- constraintOptions = Common.extend({ stiffness: 0.2, render: { type: 'line', anchors: false } }, constraintOptions);
-
- var softBody = Composites.stack(xx, yy, columns, rows, columnGap, rowGap, function(x, y) {
- return Bodies.circle(x, y, particleRadius, particleOptions);
- });
-
- Composites.mesh(softBody, columns, rows, crossBrace, constraintOptions);
-
- softBody.label = 'Soft Body';
-
- return softBody;
- };
-
-})();
-
-},{"../body/Body":1,"../body/Composite":2,"../constraint/Constraint":12,"../core/Common":14,"./Bodies":23}],25:[function(_dereq_,module,exports){
-/**
-* The `Matter.Axes` module contains methods for creating and manipulating sets of axes.
-*
-* @class Axes
-*/
-
-var Axes = {};
-
-module.exports = Axes;
-
-var Vector = _dereq_('../geometry/Vector');
-var Common = _dereq_('../core/Common');
-
-(function() {
-
- /**
- * Creates a new set of axes from the given vertices.
- * @method fromVertices
- * @param {vertices} vertices
- * @return {axes} A new axes from the given vertices
- */
- Axes.fromVertices = function(vertices) {
- var axes = {};
-
- // find the unique axes, using edge normal gradients
- for (var i = 0; i < vertices.length; i++) {
- var j = (i + 1) % vertices.length,
- normal = Vector.normalise({
- x: vertices[j].y - vertices[i].y,
- y: vertices[i].x - vertices[j].x
- }),
- gradient = (normal.y === 0) ? Infinity : (normal.x / normal.y);
-
- // limit precision
- gradient = gradient.toFixed(3).toString();
- axes[gradient] = normal;
- }
-
- return Common.values(axes);
- };
-
- /**
- * Rotates a set of axes by the given angle.
- * @method rotate
- * @param {axes} axes
- * @param {number} angle
- */
- Axes.rotate = function(axes, angle) {
- if (angle === 0)
- return;
-
- var cos = Math.cos(angle),
- sin = Math.sin(angle);
-
- for (var i = 0; i < axes.length; i++) {
- var axis = axes[i],
- xx;
- xx = axis.x * cos - axis.y * sin;
- axis.y = axis.x * sin + axis.y * cos;
- axis.x = xx;
- }
- };
-
-})();
-
-},{"../core/Common":14,"../geometry/Vector":28}],26:[function(_dereq_,module,exports){
-/**
-* The `Matter.Bounds` module contains methods for creating and manipulating axis-aligned bounding boxes (AABB).
-*
-* @class Bounds
-*/
-
-var Bounds = {};
-
-module.exports = Bounds;
-
-(function() {
-
- /**
- * Creates a new axis-aligned bounding box (AABB) for the given vertices.
- * @method create
- * @param {vertices} vertices
- * @return {bounds} A new bounds object
- */
- Bounds.create = function(vertices) {
- var bounds = {
- min: { x: 0, y: 0 },
- max: { x: 0, y: 0 }
- };
-
- if (vertices)
- Bounds.update(bounds, vertices);
-
- return bounds;
- };
-
- /**
- * Updates bounds using the given vertices and extends the bounds given a velocity.
- * @method update
- * @param {bounds} bounds
- * @param {vertices} vertices
- * @param {vector} velocity
- */
- Bounds.update = function(bounds, vertices, velocity) {
- bounds.min.x = Infinity;
- bounds.max.x = -Infinity;
- bounds.min.y = Infinity;
- bounds.max.y = -Infinity;
-
- for (var i = 0; i < vertices.length; i++) {
- var vertex = vertices[i];
- if (vertex.x > bounds.max.x) bounds.max.x = vertex.x;
- if (vertex.x < bounds.min.x) bounds.min.x = vertex.x;
- if (vertex.y > bounds.max.y) bounds.max.y = vertex.y;
- if (vertex.y < bounds.min.y) bounds.min.y = vertex.y;
- }
-
- if (velocity) {
- if (velocity.x > 0) {
- bounds.max.x += velocity.x;
- } else {
- bounds.min.x += velocity.x;
- }
-
- if (velocity.y > 0) {
- bounds.max.y += velocity.y;
- } else {
- bounds.min.y += velocity.y;
- }
- }
- };
-
- /**
- * Returns true if the bounds contains the given point.
- * @method contains
- * @param {bounds} bounds
- * @param {vector} point
- * @return {boolean} True if the bounds contain the point, otherwise false
- */
- Bounds.contains = function(bounds, point) {
- return point.x >= bounds.min.x && point.x <= bounds.max.x
- && point.y >= bounds.min.y && point.y <= bounds.max.y;
- };
-
- /**
- * Returns true if the two bounds intersect.
- * @method overlaps
- * @param {bounds} boundsA
- * @param {bounds} boundsB
- * @return {boolean} True if the bounds overlap, otherwise false
- */
- Bounds.overlaps = function(boundsA, boundsB) {
- return (boundsA.min.x <= boundsB.max.x && boundsA.max.x >= boundsB.min.x
- && boundsA.max.y >= boundsB.min.y && boundsA.min.y <= boundsB.max.y);
- };
-
- /**
- * Translates the bounds by the given vector.
- * @method translate
- * @param {bounds} bounds
- * @param {vector} vector
- */
- Bounds.translate = function(bounds, vector) {
- bounds.min.x += vector.x;
- bounds.max.x += vector.x;
- bounds.min.y += vector.y;
- bounds.max.y += vector.y;
- };
-
- /**
- * Shifts the bounds to the given position.
- * @method shift
- * @param {bounds} bounds
- * @param {vector} position
- */
- Bounds.shift = function(bounds, position) {
- var deltaX = bounds.max.x - bounds.min.x,
- deltaY = bounds.max.y - bounds.min.y;
-
- bounds.min.x = position.x;
- bounds.max.x = position.x + deltaX;
- bounds.min.y = position.y;
- bounds.max.y = position.y + deltaY;
- };
-
-})();
-
-},{}],27:[function(_dereq_,module,exports){
-/**
-* The `Matter.Svg` module contains methods for converting SVG images into an array of vector points.
-*
-* To use this module you also need the SVGPathSeg polyfill: https://github.com/progers/pathseg
-*
-* See the included usage [examples](https://github.com/liabru/matter-js/tree/master/examples).
-*
-* @class Svg
-*/
-
-var Svg = {};
-
-module.exports = Svg;
-
-var Bounds = _dereq_('../geometry/Bounds');
-var Common = _dereq_('../core/Common');
-
-(function() {
-
- /**
- * Converts an SVG path into an array of vector points.
- * If the input path forms a concave shape, you must decompose the result into convex parts before use.
- * See `Bodies.fromVertices` which provides support for this.
- * Note that this function is not guaranteed to support complex paths (such as those with holes).
- * You must load the `pathseg.js` polyfill on newer browsers.
- * @method pathToVertices
- * @param {SVGPathElement} path
- * @param {Number} [sampleLength=15]
- * @return {Vector[]} points
- */
- Svg.pathToVertices = function(path, sampleLength) {
- if (typeof window !== 'undefined' && !('SVGPathSeg' in window)) {
- Common.warn('Svg.pathToVertices: SVGPathSeg not defined, a polyfill is required.');
- }
-
- // https://github.com/wout/svg.topoly.js/blob/master/svg.topoly.js
- var i, il, total, point, segment, segments,
- segmentsQueue, lastSegment,
- lastPoint, segmentIndex, points = [],
- lx, ly, length = 0, x = 0, y = 0;
-
- sampleLength = sampleLength || 15;
-
- var addPoint = function(px, py, pathSegType) {
- // all odd-numbered path types are relative except PATHSEG_CLOSEPATH (1)
- var isRelative = pathSegType % 2 === 1 && pathSegType > 1;
-
- // when the last point doesn't equal the current point add the current point
- if (!lastPoint || px != lastPoint.x || py != lastPoint.y) {
- if (lastPoint && isRelative) {
- lx = lastPoint.x;
- ly = lastPoint.y;
- } else {
- lx = 0;
- ly = 0;
- }
-
- var point = {
- x: lx + px,
- y: ly + py
- };
-
- // set last point
- if (isRelative || !lastPoint) {
- lastPoint = point;
- }
-
- points.push(point);
-
- x = lx + px;
- y = ly + py;
- }
- };
-
- var addSegmentPoint = function(segment) {
- var segType = segment.pathSegTypeAsLetter.toUpperCase();
-
- // skip path ends
- if (segType === 'Z')
- return;
-
- // map segment to x and y
- switch (segType) {
-
- case 'M':
- case 'L':
- case 'T':
- case 'C':
- case 'S':
- case 'Q':
- x = segment.x;
- y = segment.y;
- break;
- case 'H':
- x = segment.x;
- break;
- case 'V':
- y = segment.y;
- break;
- }
-
- addPoint(x, y, segment.pathSegType);
- };
-
- // ensure path is absolute
- Svg._svgPathToAbsolute(path);
-
- // get total length
- total = path.getTotalLength();
-
- // queue segments
- segments = [];
- for (i = 0; i < path.pathSegList.numberOfItems; i += 1)
- segments.push(path.pathSegList.getItem(i));
-
- segmentsQueue = segments.concat();
-
- // sample through path
- while (length < total) {
- // get segment at position
- segmentIndex = path.getPathSegAtLength(length);
- segment = segments[segmentIndex];
-
- // new segment
- if (segment != lastSegment) {
- while (segmentsQueue.length && segmentsQueue[0] != segment)
- addSegmentPoint(segmentsQueue.shift());
-
- lastSegment = segment;
- }
-
- // add points in between when curving
- // TODO: adaptive sampling
- switch (segment.pathSegTypeAsLetter.toUpperCase()) {
-
- case 'C':
- case 'T':
- case 'S':
- case 'Q':
- case 'A':
- point = path.getPointAtLength(length);
- addPoint(point.x, point.y, 0);
- break;
-
- }
-
- // increment by sample value
- length += sampleLength;
- }
-
- // add remaining segments not passed by sampling
- for (i = 0, il = segmentsQueue.length; i < il; ++i)
- addSegmentPoint(segmentsQueue[i]);
-
- return points;
- };
-
- Svg._svgPathToAbsolute = function(path) {
- // http://phrogz.net/convert-svg-path-to-all-absolute-commands
- // Copyright (c) Gavin Kistner
- // http://phrogz.net/js/_ReuseLicense.txt
- // Modifications: tidy formatting and naming
- var x0, y0, x1, y1, x2, y2, segs = path.pathSegList,
- x = 0, y = 0, len = segs.numberOfItems;
-
- for (var i = 0; i < len; ++i) {
- var seg = segs.getItem(i),
- segType = seg.pathSegTypeAsLetter;
-
- if (/[MLHVCSQTA]/.test(segType)) {
- if ('x' in seg) x = seg.x;
- if ('y' in seg) y = seg.y;
- } else {
- if ('x1' in seg) x1 = x + seg.x1;
- if ('x2' in seg) x2 = x + seg.x2;
- if ('y1' in seg) y1 = y + seg.y1;
- if ('y2' in seg) y2 = y + seg.y2;
- if ('x' in seg) x += seg.x;
- if ('y' in seg) y += seg.y;
-
- switch (segType) {
-
- case 'm':
- segs.replaceItem(path.createSVGPathSegMovetoAbs(x, y), i);
- break;
- case 'l':
- segs.replaceItem(path.createSVGPathSegLinetoAbs(x, y), i);
- break;
- case 'h':
- segs.replaceItem(path.createSVGPathSegLinetoHorizontalAbs(x), i);
- break;
- case 'v':
- segs.replaceItem(path.createSVGPathSegLinetoVerticalAbs(y), i);
- break;
- case 'c':
- segs.replaceItem(path.createSVGPathSegCurvetoCubicAbs(x, y, x1, y1, x2, y2), i);
- break;
- case 's':
- segs.replaceItem(path.createSVGPathSegCurvetoCubicSmoothAbs(x, y, x2, y2), i);
- break;
- case 'q':
- segs.replaceItem(path.createSVGPathSegCurvetoQuadraticAbs(x, y, x1, y1), i);
- break;
- case 't':
- segs.replaceItem(path.createSVGPathSegCurvetoQuadraticSmoothAbs(x, y), i);
- break;
- case 'a':
- segs.replaceItem(path.createSVGPathSegArcAbs(x, y, seg.r1, seg.r2, seg.angle, seg.largeArcFlag, seg.sweepFlag), i);
- break;
- case 'z':
- case 'Z':
- x = x0;
- y = y0;
- break;
-
- }
- }
-
- if (segType == 'M' || segType == 'm') {
- x0 = x;
- y0 = y;
- }
- }
- };
-
-})();
-},{"../core/Common":14,"../geometry/Bounds":26}],28:[function(_dereq_,module,exports){
-/**
-* The `Matter.Vector` module contains methods for creating and manipulating vectors.
-* Vectors are the basis of all the geometry related operations in the engine.
-* A `Matter.Vector` object is of the form `{ x: 0, y: 0 }`.
-*
-* See the included usage [examples](https://github.com/liabru/matter-js/tree/master/examples).
-*
-* @class Vector
-*/
-
-// TODO: consider params for reusing vector objects
-
-var Vector = {};
-
-module.exports = Vector;
-
-(function() {
-
- /**
- * Creates a new vector.
- * @method create
- * @param {number} x
- * @param {number} y
- * @return {vector} A new vector
- */
- Vector.create = function(x, y) {
- return { x: x || 0, y: y || 0 };
- };
-
- /**
- * Returns a new vector with `x` and `y` copied from the given `vector`.
- * @method clone
- * @param {vector} vector
- * @return {vector} A new cloned vector
- */
- Vector.clone = function(vector) {
- return { x: vector.x, y: vector.y };
- };
-
- /**
- * Returns the magnitude (length) of a vector.
- * @method magnitude
- * @param {vector} vector
- * @return {number} The magnitude of the vector
- */
- Vector.magnitude = function(vector) {
- return Math.sqrt((vector.x * vector.x) + (vector.y * vector.y));
- };
-
- /**
- * Returns the magnitude (length) of a vector (therefore saving a `sqrt` operation).
- * @method magnitudeSquared
- * @param {vector} vector
- * @return {number} The squared magnitude of the vector
- */
- Vector.magnitudeSquared = function(vector) {
- return (vector.x * vector.x) + (vector.y * vector.y);
- };
-
- /**
- * Rotates the vector about (0, 0) by specified angle.
- * @method rotate
- * @param {vector} vector
- * @param {number} angle
- * @param {vector} [output]
- * @return {vector} The vector rotated about (0, 0)
- */
- Vector.rotate = function(vector, angle, output) {
- var cos = Math.cos(angle), sin = Math.sin(angle);
- if (!output) output = {};
- var x = vector.x * cos - vector.y * sin;
- output.y = vector.x * sin + vector.y * cos;
- output.x = x;
- return output;
- };
-
- /**
- * Rotates the vector about a specified point by specified angle.
- * @method rotateAbout
- * @param {vector} vector
- * @param {number} angle
- * @param {vector} point
- * @param {vector} [output]
- * @return {vector} A new vector rotated about the point
- */
- Vector.rotateAbout = function(vector, angle, point, output) {
- var cos = Math.cos(angle), sin = Math.sin(angle);
- if (!output) output = {};
- var x = point.x + ((vector.x - point.x) * cos - (vector.y - point.y) * sin);
- output.y = point.y + ((vector.x - point.x) * sin + (vector.y - point.y) * cos);
- output.x = x;
- return output;
- };
-
- /**
- * Normalises a vector (such that its magnitude is `1`).
- * @method normalise
- * @param {vector} vector
- * @return {vector} A new vector normalised
- */
- Vector.normalise = function(vector) {
- var magnitude = Vector.magnitude(vector);
- if (magnitude === 0)
- return { x: 0, y: 0 };
- return { x: vector.x / magnitude, y: vector.y / magnitude };
- };
-
- /**
- * Returns the dot-product of two vectors.
- * @method dot
- * @param {vector} vectorA
- * @param {vector} vectorB
- * @return {number} The dot product of the two vectors
- */
- Vector.dot = function(vectorA, vectorB) {
- return (vectorA.x * vectorB.x) + (vectorA.y * vectorB.y);
- };
-
- /**
- * Returns the cross-product of two vectors.
- * @method cross
- * @param {vector} vectorA
- * @param {vector} vectorB
- * @return {number} The cross product of the two vectors
- */
- Vector.cross = function(vectorA, vectorB) {
- return (vectorA.x * vectorB.y) - (vectorA.y * vectorB.x);
- };
-
- /**
- * Returns the cross-product of three vectors.
- * @method cross3
- * @param {vector} vectorA
- * @param {vector} vectorB
- * @param {vector} vectorC
- * @return {number} The cross product of the three vectors
- */
- Vector.cross3 = function(vectorA, vectorB, vectorC) {
- return (vectorB.x - vectorA.x) * (vectorC.y - vectorA.y) - (vectorB.y - vectorA.y) * (vectorC.x - vectorA.x);
- };
-
- /**
- * Adds the two vectors.
- * @method add
- * @param {vector} vectorA
- * @param {vector} vectorB
- * @param {vector} [output]
- * @return {vector} A new vector of vectorA and vectorB added
- */
- Vector.add = function(vectorA, vectorB, output) {
- if (!output) output = {};
- output.x = vectorA.x + vectorB.x;
- output.y = vectorA.y + vectorB.y;
- return output;
- };
-
- /**
- * Subtracts the two vectors.
- * @method sub
- * @param {vector} vectorA
- * @param {vector} vectorB
- * @param {vector} [output]
- * @return {vector} A new vector of vectorA and vectorB subtracted
- */
- Vector.sub = function(vectorA, vectorB, output) {
- if (!output) output = {};
- output.x = vectorA.x - vectorB.x;
- output.y = vectorA.y - vectorB.y;
- return output;
- };
-
- /**
- * Multiplies a vector and a scalar.
- * @method mult
- * @param {vector} vector
- * @param {number} scalar
- * @return {vector} A new vector multiplied by scalar
- */
- Vector.mult = function(vector, scalar) {
- return { x: vector.x * scalar, y: vector.y * scalar };
- };
-
- /**
- * Divides a vector and a scalar.
- * @method div
- * @param {vector} vector
- * @param {number} scalar
- * @return {vector} A new vector divided by scalar
- */
- Vector.div = function(vector, scalar) {
- return { x: vector.x / scalar, y: vector.y / scalar };
- };
-
- /**
- * Returns the perpendicular vector. Set `negate` to true for the perpendicular in the opposite direction.
- * @method perp
- * @param {vector} vector
- * @param {bool} [negate=false]
- * @return {vector} The perpendicular vector
- */
- Vector.perp = function(vector, negate) {
- negate = negate === true ? -1 : 1;
- return { x: negate * -vector.y, y: negate * vector.x };
- };
-
- /**
- * Negates both components of a vector such that it points in the opposite direction.
- * @method neg
- * @param {vector} vector
- * @return {vector} The negated vector
- */
- Vector.neg = function(vector) {
- return { x: -vector.x, y: -vector.y };
- };
-
- /**
- * Returns the angle between the vector `vectorB - vectorA` and the x-axis in radians.
- * @method angle
- * @param {vector} vectorA
- * @param {vector} vectorB
- * @return {number} The angle in radians
- */
- Vector.angle = function(vectorA, vectorB) {
- return Math.atan2(vectorB.y - vectorA.y, vectorB.x - vectorA.x);
- };
-
- /**
- * Temporary vector pool (not thread-safe).
- * @property _temp
- * @type {vector[]}
- * @private
- */
- Vector._temp = [
- Vector.create(), Vector.create(),
- Vector.create(), Vector.create(),
- Vector.create(), Vector.create()
- ];
-
-})();
-},{}],29:[function(_dereq_,module,exports){
-/**
-* The `Matter.Vertices` module contains methods for creating and manipulating sets of vertices.
-* A set of vertices is an array of `Matter.Vector` with additional indexing properties inserted by `Vertices.create`.
-* A `Matter.Body` maintains a set of vertices to represent the shape of the object (its convex hull).
-*
-* See the included usage [examples](https://github.com/liabru/matter-js/tree/master/examples).
-*
-* @class Vertices
-*/
-
-var Vertices = {};
-
-module.exports = Vertices;
-
-var Vector = _dereq_('../geometry/Vector');
-var Common = _dereq_('../core/Common');
-
-(function() {
-
- /**
- * Creates a new set of `Matter.Body` compatible vertices.
- * The `points` argument accepts an array of `Matter.Vector` points orientated around the origin `(0, 0)`, for example:
- *
- * [{ x: 0, y: 0 }, { x: 25, y: 50 }, { x: 50, y: 0 }]
- *
- * The `Vertices.create` method returns a new array of vertices, which are similar to Matter.Vector objects,
- * but with some additional references required for efficient collision detection routines.
- *
- * Vertices must be specified in clockwise order.
- *
- * Note that the `body` argument is not optional, a `Matter.Body` reference must be provided.
- *
- * @method create
- * @param {vector[]} points
- * @param {body} body
- */
- Vertices.create = function(points, body) {
- var vertices = [];
-
- for (var i = 0; i < points.length; i++) {
- var point = points[i],
- vertex = {
- x: point.x,
- y: point.y,
- index: i,
- body: body,
- isInternal: false
- };
-
- vertices.push(vertex);
- }
-
- return vertices;
- };
-
- /**
- * Parses a string containing ordered x y pairs separated by spaces (and optionally commas),
- * into a `Matter.Vertices` object for the given `Matter.Body`.
- * For parsing SVG paths, see `Svg.pathToVertices`.
- * @method fromPath
- * @param {string} path
- * @param {body} body
- * @return {vertices} vertices
- */
- Vertices.fromPath = function(path, body) {
- var pathPattern = /L?\s*([\-\d\.e]+)[\s,]*([\-\d\.e]+)*/ig,
- points = [];
-
- path.replace(pathPattern, function(match, x, y) {
- points.push({ x: parseFloat(x), y: parseFloat(y) });
- });
-
- return Vertices.create(points, body);
- };
-
- /**
- * Returns the centre (centroid) of the set of vertices.
- * @method centre
- * @param {vertices} vertices
- * @return {vector} The centre point
- */
- Vertices.centre = function(vertices) {
- var area = Vertices.area(vertices, true),
- centre = { x: 0, y: 0 },
- cross,
- temp,
- j;
-
- for (var i = 0; i < vertices.length; i++) {
- j = (i + 1) % vertices.length;
- cross = Vector.cross(vertices[i], vertices[j]);
- temp = Vector.mult(Vector.add(vertices[i], vertices[j]), cross);
- centre = Vector.add(centre, temp);
- }
-
- return Vector.div(centre, 6 * area);
- };
-
- /**
- * Returns the average (mean) of the set of vertices.
- * @method mean
- * @param {vertices} vertices
- * @return {vector} The average point
- */
- Vertices.mean = function(vertices) {
- var average = { x: 0, y: 0 };
-
- for (var i = 0; i < vertices.length; i++) {
- average.x += vertices[i].x;
- average.y += vertices[i].y;
- }
-
- return Vector.div(average, vertices.length);
- };
-
- /**
- * Returns the area of the set of vertices.
- * @method area
- * @param {vertices} vertices
- * @param {bool} signed
- * @return {number} The area
- */
- Vertices.area = function(vertices, signed) {
- var area = 0,
- j = vertices.length - 1;
-
- for (var i = 0; i < vertices.length; i++) {
- area += (vertices[j].x - vertices[i].x) * (vertices[j].y + vertices[i].y);
- j = i;
- }
-
- if (signed)
- return area / 2;
-
- return Math.abs(area) / 2;
- };
-
- /**
- * Returns the moment of inertia (second moment of area) of the set of vertices given the total mass.
- * @method inertia
- * @param {vertices} vertices
- * @param {number} mass
- * @return {number} The polygon's moment of inertia
- */
- Vertices.inertia = function(vertices, mass) {
- var numerator = 0,
- denominator = 0,
- v = vertices,
- cross,
- j;
-
- // find the polygon's moment of inertia, using second moment of area
- // from equations at http://www.physicsforums.com/showthread.php?t=25293
- for (var n = 0; n < v.length; n++) {
- j = (n + 1) % v.length;
- cross = Math.abs(Vector.cross(v[j], v[n]));
- numerator += cross * (Vector.dot(v[j], v[j]) + Vector.dot(v[j], v[n]) + Vector.dot(v[n], v[n]));
- denominator += cross;
- }
-
- return (mass / 6) * (numerator / denominator);
- };
-
- /**
- * Translates the set of vertices in-place.
- * @method translate
- * @param {vertices} vertices
- * @param {vector} vector
- * @param {number} scalar
- */
- Vertices.translate = function(vertices, vector, scalar) {
- var i;
- if (scalar) {
- for (i = 0; i < vertices.length; i++) {
- vertices[i].x += vector.x * scalar;
- vertices[i].y += vector.y * scalar;
- }
- } else {
- for (i = 0; i < vertices.length; i++) {
- vertices[i].x += vector.x;
- vertices[i].y += vector.y;
- }
- }
-
- return vertices;
- };
-
- /**
- * Rotates the set of vertices in-place.
- * @method rotate
- * @param {vertices} vertices
- * @param {number} angle
- * @param {vector} point
- */
- Vertices.rotate = function(vertices, angle, point) {
- if (angle === 0)
- return;
-
- var cos = Math.cos(angle),
- sin = Math.sin(angle);
-
- for (var i = 0; i < vertices.length; i++) {
- var vertice = vertices[i],
- dx = vertice.x - point.x,
- dy = vertice.y - point.y;
-
- vertice.x = point.x + (dx * cos - dy * sin);
- vertice.y = point.y + (dx * sin + dy * cos);
- }
-
- return vertices;
- };
-
- /**
- * Returns `true` if the `point` is inside the set of `vertices`.
- * @method contains
- * @param {vertices} vertices
- * @param {vector} point
- * @return {boolean} True if the vertices contains point, otherwise false
- */
- Vertices.contains = function(vertices, point) {
- for (var i = 0; i < vertices.length; i++) {
- var vertice = vertices[i],
- nextVertice = vertices[(i + 1) % vertices.length];
- if ((point.x - vertice.x) * (nextVertice.y - vertice.y) + (point.y - vertice.y) * (vertice.x - nextVertice.x) > 0) {
- return false;
- }
- }
-
- return true;
- };
-
- /**
- * Scales the vertices from a point (default is centre) in-place.
- * @method scale
- * @param {vertices} vertices
- * @param {number} scaleX
- * @param {number} scaleY
- * @param {vector} point
- */
- Vertices.scale = function(vertices, scaleX, scaleY, point) {
- if (scaleX === 1 && scaleY === 1)
- return vertices;
-
- point = point || Vertices.centre(vertices);
-
- var vertex,
- delta;
-
- for (var i = 0; i < vertices.length; i++) {
- vertex = vertices[i];
- delta = Vector.sub(vertex, point);
- vertices[i].x = point.x + delta.x * scaleX;
- vertices[i].y = point.y + delta.y * scaleY;
- }
-
- return vertices;
- };
-
- /**
- * Chamfers a set of vertices by giving them rounded corners, returns a new set of vertices.
- * The radius parameter is a single number or an array to specify the radius for each vertex.
- * @method chamfer
- * @param {vertices} vertices
- * @param {number[]} radius
- * @param {number} quality
- * @param {number} qualityMin
- * @param {number} qualityMax
- */
- Vertices.chamfer = function(vertices, radius, quality, qualityMin, qualityMax) {
- if (typeof radius === 'number') {
- radius = [radius];
- } else {
- radius = radius || [8];
- }
-
- // quality defaults to -1, which is auto
- quality = (typeof quality !== 'undefined') ? quality : -1;
- qualityMin = qualityMin || 2;
- qualityMax = qualityMax || 14;
-
- var newVertices = [];
-
- for (var i = 0; i < vertices.length; i++) {
- var prevVertex = vertices[i - 1 >= 0 ? i - 1 : vertices.length - 1],
- vertex = vertices[i],
- nextVertex = vertices[(i + 1) % vertices.length],
- currentRadius = radius[i < radius.length ? i : radius.length - 1];
-
- if (currentRadius === 0) {
- newVertices.push(vertex);
- continue;
- }
-
- var prevNormal = Vector.normalise({
- x: vertex.y - prevVertex.y,
- y: prevVertex.x - vertex.x
- });
-
- var nextNormal = Vector.normalise({
- x: nextVertex.y - vertex.y,
- y: vertex.x - nextVertex.x
- });
-
- var diagonalRadius = Math.sqrt(2 * Math.pow(currentRadius, 2)),
- radiusVector = Vector.mult(Common.clone(prevNormal), currentRadius),
- midNormal = Vector.normalise(Vector.mult(Vector.add(prevNormal, nextNormal), 0.5)),
- scaledVertex = Vector.sub(vertex, Vector.mult(midNormal, diagonalRadius));
-
- var precision = quality;
-
- if (quality === -1) {
- // automatically decide precision
- precision = Math.pow(currentRadius, 0.32) * 1.75;
- }
-
- precision = Common.clamp(precision, qualityMin, qualityMax);
-
- // use an even value for precision, more likely to reduce axes by using symmetry
- if (precision % 2 === 1)
- precision += 1;
-
- var alpha = Math.acos(Vector.dot(prevNormal, nextNormal)),
- theta = alpha / precision;
-
- for (var j = 0; j < precision; j++) {
- newVertices.push(Vector.add(Vector.rotate(radiusVector, theta * j), scaledVertex));
- }
- }
-
- return newVertices;
- };
-
- /**
- * Sorts the input vertices into clockwise order in place.
- * @method clockwiseSort
- * @param {vertices} vertices
- * @return {vertices} vertices
- */
- Vertices.clockwiseSort = function(vertices) {
- var centre = Vertices.mean(vertices);
-
- vertices.sort(function(vertexA, vertexB) {
- return Vector.angle(centre, vertexA) - Vector.angle(centre, vertexB);
- });
-
- return vertices;
- };
-
- /**
- * Returns true if the vertices form a convex shape (vertices must be in clockwise order).
- * @method isConvex
- * @param {vertices} vertices
- * @return {bool} `true` if the `vertices` are convex, `false` if not (or `null` if not computable).
- */
- Vertices.isConvex = function(vertices) {
- // http://paulbourke.net/geometry/polygonmesh/
- // Copyright (c) Paul Bourke (use permitted)
-
- var flag = 0,
- n = vertices.length,
- i,
- j,
- k,
- z;
-
- if (n < 3)
- return null;
-
- for (i = 0; i < n; i++) {
- j = (i + 1) % n;
- k = (i + 2) % n;
- z = (vertices[j].x - vertices[i].x) * (vertices[k].y - vertices[j].y);
- z -= (vertices[j].y - vertices[i].y) * (vertices[k].x - vertices[j].x);
-
- if (z < 0) {
- flag |= 1;
- } else if (z > 0) {
- flag |= 2;
- }
-
- if (flag === 3) {
- return false;
- }
- }
-
- if (flag !== 0){
- return true;
- } else {
- return null;
- }
- };
-
- /**
- * Returns the convex hull of the input vertices as a new array of points.
- * @method hull
- * @param {vertices} vertices
- * @return [vertex] vertices
- */
- Vertices.hull = function(vertices) {
- // http://geomalgorithms.com/a10-_hull-1.html
-
- var upper = [],
- lower = [],
- vertex,
- i;
-
- // sort vertices on x-axis (y-axis for ties)
- vertices = vertices.slice(0);
- vertices.sort(function(vertexA, vertexB) {
- var dx = vertexA.x - vertexB.x;
- return dx !== 0 ? dx : vertexA.y - vertexB.y;
- });
-
- // build lower hull
- for (i = 0; i < vertices.length; i += 1) {
- vertex = vertices[i];
-
- while (lower.length >= 2
- && Vector.cross3(lower[lower.length - 2], lower[lower.length - 1], vertex) <= 0) {
- lower.pop();
- }
-
- lower.push(vertex);
- }
-
- // build upper hull
- for (i = vertices.length - 1; i >= 0; i -= 1) {
- vertex = vertices[i];
-
- while (upper.length >= 2
- && Vector.cross3(upper[upper.length - 2], upper[upper.length - 1], vertex) <= 0) {
- upper.pop();
- }
-
- upper.push(vertex);
- }
-
- // concatenation of the lower and upper hulls gives the convex hull
- // omit last points because they are repeated at the beginning of the other list
- upper.pop();
- lower.pop();
-
- return upper.concat(lower);
- };
-
-})();
-
-},{"../core/Common":14,"../geometry/Vector":28}],30:[function(_dereq_,module,exports){
-var Matter = module.exports = _dereq_('../core/Matter');
-
-Matter.Body = _dereq_('../body/Body');
-Matter.Composite = _dereq_('../body/Composite');
-Matter.World = _dereq_('../body/World');
-
-Matter.Contact = _dereq_('../collision/Contact');
-Matter.Detector = _dereq_('../collision/Detector');
-Matter.Grid = _dereq_('../collision/Grid');
-Matter.Pairs = _dereq_('../collision/Pairs');
-Matter.Pair = _dereq_('../collision/Pair');
-Matter.Query = _dereq_('../collision/Query');
-Matter.Resolver = _dereq_('../collision/Resolver');
-Matter.SAT = _dereq_('../collision/SAT');
-
-Matter.Constraint = _dereq_('../constraint/Constraint');
-Matter.MouseConstraint = _dereq_('../constraint/MouseConstraint');
-
-Matter.Common = _dereq_('../core/Common');
-Matter.Engine = _dereq_('../core/Engine');
-Matter.Events = _dereq_('../core/Events');
-Matter.Mouse = _dereq_('../core/Mouse');
-Matter.Runner = _dereq_('../core/Runner');
-Matter.Sleeping = _dereq_('../core/Sleeping');
-Matter.Plugin = _dereq_('../core/Plugin');
-
-
-Matter.Bodies = _dereq_('../factory/Bodies');
-Matter.Composites = _dereq_('../factory/Composites');
-
-Matter.Axes = _dereq_('../geometry/Axes');
-Matter.Bounds = _dereq_('../geometry/Bounds');
-Matter.Svg = _dereq_('../geometry/Svg');
-Matter.Vector = _dereq_('../geometry/Vector');
-Matter.Vertices = _dereq_('../geometry/Vertices');
-
-Matter.Render = _dereq_('../render/Render');
-Matter.RenderPixi = _dereq_('../render/RenderPixi');
-
-// aliases
-
-Matter.World.add = Matter.Composite.add;
-Matter.World.remove = Matter.Composite.remove;
-Matter.World.addComposite = Matter.Composite.addComposite;
-Matter.World.addBody = Matter.Composite.addBody;
-Matter.World.addConstraint = Matter.Composite.addConstraint;
-Matter.World.clear = Matter.Composite.clear;
-Matter.Engine.run = Matter.Runner.run;
-
-},{"../body/Body":1,"../body/Composite":2,"../body/World":3,"../collision/Contact":4,"../collision/Detector":5,"../collision/Grid":6,"../collision/Pair":7,"../collision/Pairs":8,"../collision/Query":9,"../collision/Resolver":10,"../collision/SAT":11,"../constraint/Constraint":12,"../constraint/MouseConstraint":13,"../core/Common":14,"../core/Engine":15,"../core/Events":16,"../core/Matter":17,"../core/Metrics":18,"../core/Mouse":19,"../core/Plugin":20,"../core/Runner":21,"../core/Sleeping":22,"../factory/Bodies":23,"../factory/Composites":24,"../geometry/Axes":25,"../geometry/Bounds":26,"../geometry/Svg":27,"../geometry/Vector":28,"../geometry/Vertices":29,"../render/Render":31,"../render/RenderPixi":32}],31:[function(_dereq_,module,exports){
-/**
-* The `Matter.Render` module is a simple HTML5 canvas based renderer for visualising instances of `Matter.Engine`.
+* The `Matter.Render` module is a simple canvas based renderer for visualising instances of `Matter.Engine`.
* It is intended for development and debugging purposes, but may also be suitable for simple games.
* It includes a number of drawing options including wireframe, vector with support for sprites and viewports.
*
@@ -8366,13 +5752,12 @@ var Render = {};
module.exports = Render;
-var Common = _dereq_('../core/Common');
-var Composite = _dereq_('../body/Composite');
-var Bounds = _dereq_('../geometry/Bounds');
-var Events = _dereq_('../core/Events');
-var Grid = _dereq_('../collision/Grid');
-var Vector = _dereq_('../geometry/Vector');
-var Mouse = _dereq_('../core/Mouse');
+var Common = __webpack_require__(0);
+var Composite = __webpack_require__(5);
+var Bounds = __webpack_require__(1);
+var Events = __webpack_require__(4);
+var Vector = __webpack_require__(2);
+var Mouse = __webpack_require__(12);
(function() {
@@ -8388,6 +5773,9 @@ var Mouse = _dereq_('../core/Mouse');
|| window.webkitCancelAnimationFrame || window.msCancelAnimationFrame;
}
+ Render._goodFps = 30;
+ Render._goodDelta = 1000 / 60;
+
/**
* Creates a new renderer. The options parameter is an object that specifies any properties you wish to override the defaults.
* All properties have default values, and many are pre-calculated automatically based on other properties.
@@ -8404,17 +5792,32 @@ var Mouse = _dereq_('../core/Mouse');
canvas: null,
mouse: null,
frameRequestId: null,
+ timing: {
+ historySize: 60,
+ delta: 0,
+ deltaHistory: [],
+ lastTime: 0,
+ lastTimestamp: 0,
+ lastElapsed: 0,
+ timestampElapsed: 0,
+ timestampElapsedHistory: [],
+ engineDeltaHistory: [],
+ engineElapsedHistory: [],
+ elapsedHistory: []
+ },
options: {
width: 800,
height: 600,
pixelRatio: 1,
- background: '#18181d',
- wireframeBackground: '#0f0f13',
+ background: '#14151f',
+ wireframeBackground: '#14151f',
hasBounds: !!options.bounds,
enabled: true,
wireframes: true,
showSleeping: true,
showDebug: false,
+ showStats: false,
+ showPerformance: false,
showBroadphase: false,
showBounds: false,
showVelocity: false,
@@ -8424,7 +5827,6 @@ var Mouse = _dereq_('../core/Mouse');
showPositions: false,
showAngleIndicator: false,
showIds: false,
- showShadows: false,
showVertexNumbers: false,
showConvexHulls: false,
showInternalEdges: false,
@@ -8477,7 +5879,18 @@ var Mouse = _dereq_('../core/Mouse');
Render.run = function(render) {
(function loop(time){
render.frameRequestId = _requestAnimationFrame(loop);
- Render.world(render);
+
+ _updateTiming(render, time);
+
+ Render.world(render, time);
+
+ if (render.options.showStats || render.options.showDebug) {
+ Render.stats(render, render.context, time);
+ }
+
+ if (render.options.showPerformance || render.options.showDebug) {
+ Render.performance(render, render.context, time);
+ }
})();
};
@@ -8511,7 +5924,6 @@ var Mouse = _dereq_('../core/Mouse');
canvas.height = options.height * pixelRatio;
canvas.style.width = options.width + 'px';
canvas.style.height = options.height + 'px';
- render.context.scale(pixelRatio, pixelRatio);
};
/**
@@ -8623,7 +6035,11 @@ var Mouse = _dereq_('../core/Mouse');
boundsScaleX = boundsWidth / render.options.width,
boundsScaleY = boundsHeight / render.options.height;
- render.context.scale(1 / boundsScaleX, 1 / boundsScaleY);
+ render.context.setTransform(
+ render.options.pixelRatio / boundsScaleX, 0, 0,
+ render.options.pixelRatio / boundsScaleY, 0, 0
+ );
+
render.context.translate(-render.bounds.min.x, -render.bounds.min.y);
};
@@ -8642,13 +6058,16 @@ var Mouse = _dereq_('../core/Mouse');
* @method world
* @param {render} render
*/
- Render.world = function(render) {
- var engine = render.engine,
+ Render.world = function(render, time) {
+ var startTime = Common.now(),
+ engine = render.engine,
world = engine.world,
canvas = render.canvas,
context = render.context,
options = render.options,
- allBodies = Composite.allBodies(world),
+ timing = render.timing;
+
+ var allBodies = Composite.allBodies(world),
allConstraints = Composite.allConstraints(world),
background = options.wireframes ? options.wireframeBackground : options.background,
bodies = [],
@@ -8704,8 +6123,8 @@ var Mouse = _dereq_('../core/Mouse');
// update mouse
if (render.mouse) {
Mouse.setScale(render.mouse, {
- x: (render.bounds.max.x - render.bounds.min.x) / render.canvas.width,
- y: (render.bounds.max.y - render.bounds.min.y) / render.canvas.height
+ x: (render.bounds.max.x - render.bounds.min.x) / render.options.width,
+ y: (render.bounds.max.y - render.bounds.min.y) / render.options.height
});
Mouse.setOffset(render.mouse, render.bounds.min);
@@ -8713,6 +6132,10 @@ var Mouse = _dereq_('../core/Mouse');
} else {
constraints = allConstraints;
bodies = allBodies;
+
+ if (render.options.pixelRatio !== 1) {
+ render.context.setTransform(render.options.pixelRatio, 0, 0, render.options.pixelRatio, 0, 0);
+ }
}
if (!options.wireframes || (engine.enableSleeping && options.showSleeping)) {
@@ -8755,11 +6178,8 @@ var Mouse = _dereq_('../core/Mouse');
Render.constraints(constraints, context);
- if (options.showBroadphase && engine.broadphase.controller === Grid)
- Render.grid(render, engine.broadphase, context);
-
- if (options.showDebug)
- Render.debug(render, context);
+ if (options.showBroadphase)
+ Render.grid(render, engine.grid, context);
if (options.hasBounds) {
// revert view transforms
@@ -8767,51 +6187,182 @@ var Mouse = _dereq_('../core/Mouse');
}
Events.trigger(render, 'afterRender', event);
+
+ // log the time elapsed computing this update
+ timing.lastElapsed = Common.now() - startTime;
};
/**
- * Description
+ * Renders statistics about the engine and world useful for debugging.
* @private
- * @method debug
+ * @method stats
+ * @param {render} render
+ * @param {RenderingContext} context
+ * @param {Number} time
+ */
+ Render.stats = function(render, context, time) {
+ var engine = render.engine,
+ world = engine.world,
+ bodies = Composite.allBodies(world),
+ parts = 0,
+ width = 55,
+ height = 44,
+ x = 0,
+ y = 0;
+
+ // count parts
+ for (var i = 0; i < bodies.length; i += 1) {
+ parts += bodies[i].parts.length;
+ }
+
+ // sections
+ var sections = {
+ 'Part': parts,
+ 'Body': bodies.length,
+ 'Cons': Composite.allConstraints(world).length,
+ 'Comp': Composite.allComposites(world).length,
+ 'Pair': engine.pairs.list.length
+ };
+
+ // background
+ context.fillStyle = '#0e0f19';
+ context.fillRect(x, y, width * 5.5, height);
+
+ context.font = '12px Arial';
+ context.textBaseline = 'top';
+ context.textAlign = 'right';
+
+ // sections
+ for (var key in sections) {
+ var section = sections[key];
+ // label
+ context.fillStyle = '#aaa';
+ context.fillText(key, x + width, y + 8);
+
+ // value
+ context.fillStyle = '#eee';
+ context.fillText(section, x + width, y + 26);
+
+ x += width;
+ }
+ };
+
+ /**
+ * Renders engine and render performance information.
+ * @private
+ * @method performance
* @param {render} render
* @param {RenderingContext} context
*/
- Render.debug = function(render, context) {
- var c = context,
- engine = render.engine,
- world = engine.world,
- metrics = engine.metrics,
- options = render.options,
- bodies = Composite.allBodies(world),
- space = " ";
+ Render.performance = function(render, context) {
+ var engine = render.engine,
+ timing = render.timing,
+ deltaHistory = timing.deltaHistory,
+ elapsedHistory = timing.elapsedHistory,
+ timestampElapsedHistory = timing.timestampElapsedHistory,
+ engineDeltaHistory = timing.engineDeltaHistory,
+ engineElapsedHistory = timing.engineElapsedHistory,
+ lastEngineDelta = engine.timing.lastDelta;
+
+ var deltaMean = _mean(deltaHistory),
+ elapsedMean = _mean(elapsedHistory),
+ engineDeltaMean = _mean(engineDeltaHistory),
+ engineElapsedMean = _mean(engineElapsedHistory),
+ timestampElapsedMean = _mean(timestampElapsedHistory),
+ rateMean = (timestampElapsedMean / deltaMean) || 0,
+ fps = (1000 / deltaMean) || 0;
- if (engine.timing.timestamp - (render.debugTimestamp || 0) >= 500) {
- var text = "";
+ var graphHeight = 4,
+ gap = 12,
+ width = 60,
+ height = 34,
+ x = 10,
+ y = 69;
- if (metrics.timing) {
- text += "fps: " + Math.round(metrics.timing.fps) + space;
- }
+ // background
+ context.fillStyle = '#0e0f19';
+ context.fillRect(0, 50, gap * 4 + width * 5 + 22, height);
+ // show FPS
+ Render.status(
+ context, x, y, width, graphHeight, deltaHistory.length,
+ Math.round(fps) + ' fps',
+ fps / Render._goodFps,
+ function(i) { return (deltaHistory[i] / deltaMean) - 1; }
+ );
- render.debugString = text;
- render.debugTimestamp = engine.timing.timestamp;
+ // show engine delta
+ Render.status(
+ context, x + gap + width, y, width, graphHeight, engineDeltaHistory.length,
+ lastEngineDelta.toFixed(2) + ' dt',
+ Render._goodDelta / lastEngineDelta,
+ function(i) { return (engineDeltaHistory[i] / engineDeltaMean) - 1; }
+ );
+
+ // show engine update time
+ Render.status(
+ context, x + (gap + width) * 2, y, width, graphHeight, engineElapsedHistory.length,
+ engineElapsedMean.toFixed(2) + ' ut',
+ 1 - (engineElapsedMean / Render._goodFps),
+ function(i) { return (engineElapsedHistory[i] / engineElapsedMean) - 1; }
+ );
+
+ // show render time
+ Render.status(
+ context, x + (gap + width) * 3, y, width, graphHeight, elapsedHistory.length,
+ elapsedMean.toFixed(2) + ' rt',
+ 1 - (elapsedMean / Render._goodFps),
+ function(i) { return (elapsedHistory[i] / elapsedMean) - 1; }
+ );
+
+ // show effective speed
+ Render.status(
+ context, x + (gap + width) * 4, y, width, graphHeight, timestampElapsedHistory.length,
+ rateMean.toFixed(2) + ' x',
+ rateMean * rateMean * rateMean,
+ function(i) { return (((timestampElapsedHistory[i] / deltaHistory[i]) / rateMean) || 0) - 1; }
+ );
+ };
+
+ /**
+ * Renders a label, indicator and a chart.
+ * @private
+ * @method status
+ * @param {RenderingContext} context
+ * @param {number} x
+ * @param {number} y
+ * @param {number} width
+ * @param {number} height
+ * @param {number} count
+ * @param {string} label
+ * @param {string} indicator
+ * @param {function} plotY
+ */
+ Render.status = function(context, x, y, width, height, count, label, indicator, plotY) {
+ // background
+ context.strokeStyle = '#888';
+ context.fillStyle = '#444';
+ context.lineWidth = 1;
+ context.fillRect(x, y + 7, width, 1);
+
+ // chart
+ context.beginPath();
+ context.moveTo(x, y + 7 - height * Common.clamp(0.4 * plotY(0), -2, 2));
+ for (var i = 0; i < width; i += 1) {
+ context.lineTo(x + i, y + 7 - (i < count ? height * Common.clamp(0.4 * plotY(i), -2, 2) : 0));
}
+ context.stroke();
- if (render.debugString) {
- c.font = "12px Arial";
+ // indicator
+ context.fillStyle = 'hsl(' + Common.clamp(25 + 95 * indicator, 0, 120) + ',100%,60%)';
+ context.fillRect(x, y - 7, 4, 4);
- if (options.wireframes) {
- c.fillStyle = 'rgba(255,255,255,0.5)';
- } else {
- c.fillStyle = 'rgba(0,0,0,0.5)';
- }
-
- var split = render.debugString.split('\n');
-
- for (var i = 0; i < split.length; i++) {
- c.fillText(split[i], 50, 50 + i * 18);
- }
- }
+ // label
+ context.font = '12px Arial';
+ context.textBaseline = 'middle';
+ context.textAlign = 'right';
+ context.fillStyle = '#eee';
+ context.fillText(label, x + width, y - 5);
};
/**
@@ -8891,55 +6442,6 @@ var Mouse = _dereq_('../core/Mouse');
}
};
- /**
- * Description
- * @private
- * @method bodyShadows
- * @param {render} render
- * @param {body[]} bodies
- * @param {RenderingContext} context
- */
- Render.bodyShadows = function(render, bodies, context) {
- var c = context,
- engine = render.engine;
-
- for (var i = 0; i < bodies.length; i++) {
- var body = bodies[i];
-
- if (!body.render.visible)
- continue;
-
- if (body.circleRadius) {
- c.beginPath();
- c.arc(body.position.x, body.position.y, body.circleRadius, 0, 2 * Math.PI);
- c.closePath();
- } else {
- c.beginPath();
- c.moveTo(body.vertices[0].x, body.vertices[0].y);
- for (var j = 1; j < body.vertices.length; j++) {
- c.lineTo(body.vertices[j].x, body.vertices[j].y);
- }
- c.closePath();
- }
-
- var distanceX = body.position.x - render.options.width * 0.5,
- distanceY = body.position.y - render.options.height * 0.2,
- distance = Math.abs(distanceX) + Math.abs(distanceY);
-
- c.shadowColor = 'rgba(0,0,0,0.15)';
- c.shadowOffsetX = 0.05 * distanceX;
- c.shadowOffsetY = 0.05 * distanceY;
- c.shadowBlur = 1 + 12 * Math.min(1, distance / 1000);
-
- c.fill();
-
- c.shadowColor = null;
- c.shadowOffsetX = null;
- c.shadowOffsetY = null;
- c.shadowBlur = null;
- }
- };
-
/**
* Description
* @private
@@ -9255,7 +6757,7 @@ var Mouse = _dereq_('../core/Mouse');
// render a single axis indicator
c.moveTo(part.position.x, part.position.y);
c.lineTo((part.vertices[0].x + part.vertices[part.vertices.length-1].x) / 2,
- (part.vertices[0].y + part.vertices[part.vertices.length-1].y) / 2);
+ (part.vertices[0].y + part.vertices[part.vertices.length-1].y) / 2);
}
}
}
@@ -9555,9 +7057,9 @@ var Mouse = _dereq_('../core/Mouse');
var region = bucketId.split(/C|R/);
c.rect(0.5 + parseInt(region[1], 10) * grid.bucketWidth,
- 0.5 + parseInt(region[2], 10) * grid.bucketHeight,
- grid.bucketWidth,
- grid.bucketHeight);
+ 0.5 + parseInt(region[2], 10) * grid.bucketHeight,
+ grid.bucketWidth,
+ grid.bucketHeight);
}
c.lineWidth = 1;
@@ -9604,7 +7106,7 @@ var Mouse = _dereq_('../core/Mouse');
bounds = item.bounds;
context.beginPath();
context.rect(Math.floor(bounds.min.x - 3), Math.floor(bounds.min.y - 3),
- Math.floor(bounds.max.x - bounds.min.x + 6), Math.floor(bounds.max.y - bounds.min.y + 6));
+ Math.floor(bounds.max.x - bounds.min.x + 6), Math.floor(bounds.max.y - bounds.min.y + 6));
context.closePath();
context.stroke();
@@ -9638,7 +7140,7 @@ var Mouse = _dereq_('../core/Mouse');
bounds = inspector.selectBounds;
context.beginPath();
context.rect(Math.floor(bounds.min.x), Math.floor(bounds.min.y),
- Math.floor(bounds.max.x - bounds.min.x), Math.floor(bounds.max.y - bounds.min.y));
+ Math.floor(bounds.max.x - bounds.min.x), Math.floor(bounds.max.y - bounds.min.y));
context.closePath();
context.stroke();
context.fill();
@@ -9650,7 +7152,56 @@ var Mouse = _dereq_('../core/Mouse');
};
/**
- * Description
+ * Updates render timing.
+ * @method _updateTiming
+ * @private
+ * @param {render} render
+ * @param {number} time
+ */
+ var _updateTiming = function(render, time) {
+ var engine = render.engine,
+ timing = render.timing,
+ historySize = timing.historySize,
+ timestamp = engine.timing.timestamp;
+
+ timing.delta = time - timing.lastTime || Render._goodDelta;
+ timing.lastTime = time;
+
+ timing.timestampElapsed = timestamp - timing.lastTimestamp || 0;
+ timing.lastTimestamp = timestamp;
+
+ timing.deltaHistory.unshift(timing.delta);
+ timing.deltaHistory.length = Math.min(timing.deltaHistory.length, historySize);
+
+ timing.engineDeltaHistory.unshift(engine.timing.lastDelta);
+ timing.engineDeltaHistory.length = Math.min(timing.engineDeltaHistory.length, historySize);
+
+ timing.timestampElapsedHistory.unshift(timing.timestampElapsed);
+ timing.timestampElapsedHistory.length = Math.min(timing.timestampElapsedHistory.length, historySize);
+
+ timing.engineElapsedHistory.unshift(engine.timing.lastElapsed);
+ timing.engineElapsedHistory.length = Math.min(timing.engineElapsedHistory.length, historySize);
+
+ timing.elapsedHistory.unshift(timing.lastElapsed);
+ timing.elapsedHistory.length = Math.min(timing.elapsedHistory.length, historySize);
+ };
+
+ /**
+ * Returns the mean value of the given numbers.
+ * @method _mean
+ * @private
+ * @param {Number[]} values
+ * @return {Number} the mean of given values
+ */
+ var _mean = function(values) {
+ var result = 0;
+ for (var i = 0; i < values.length; i += 1) {
+ result += values[i];
+ }
+ return (result / values.length) || 0;
+ };
+
+ /**
* @method _createCanvas
* @private
* @param {} width
@@ -9783,37 +7334,6 @@ var Mouse = _dereq_('../core/Mouse');
* @default null
*/
- /**
- * The configuration options of the renderer.
- *
- * @property options
- * @type {}
- */
-
- /**
- * The target width in pixels of the `render.canvas` to be created.
- *
- * @property options.width
- * @type number
- * @default 800
- */
-
- /**
- * The target height in pixels of the `render.canvas` to be created.
- *
- * @property options.height
- * @type number
- * @default 600
- */
-
- /**
- * A flag that specifies if `render.bounds` should be used when rendering.
- *
- * @property options.hasBounds
- * @type boolean
- * @default false
- */
-
/**
* A `Bounds` object that specifies the drawing view region.
* Rendering will be automatically transformed and scaled to fit within the canvas size (`render.options.width` and `render.options.height`).
@@ -9838,27 +7358,2559 @@ var Mouse = _dereq_('../core/Mouse');
* @type {}
*/
+ /**
+ * The mouse to render if `render.options.showMousePosition` is enabled.
+ *
+ * @property mouse
+ * @type mouse
+ * @default null
+ */
+
+ /**
+ * The configuration options of the renderer.
+ *
+ * @property options
+ * @type {}
+ */
+
+ /**
+ * The target width in pixels of the `render.canvas` to be created.
+ * See also the `options.pixelRatio` property to change render quality.
+ *
+ * @property options.width
+ * @type number
+ * @default 800
+ */
+
+ /**
+ * The target height in pixels of the `render.canvas` to be created.
+ * See also the `options.pixelRatio` property to change render quality.
+ *
+ * @property options.height
+ * @type number
+ * @default 600
+ */
+
+ /**
+ * The [pixel ratio](https://developer.mozilla.org/en-US/docs/Web/API/Window/devicePixelRatio) to use when rendering.
+ *
+ * @property options.pixelRatio
+ * @type number
+ * @default 1
+ */
+
+ /**
+ * A CSS background color string to use when `render.options.wireframes` is disabled.
+ * This may be also set to `'transparent'` or equivalent.
+ *
+ * @property options.background
+ * @type string
+ * @default '#14151f'
+ */
+
+ /**
+ * A CSS background color string to use when `render.options.wireframes` is enabled.
+ * This may be also set to `'transparent'` or equivalent.
+ *
+ * @property options.wireframeBackground
+ * @type string
+ * @default '#14151f'
+ */
+
+ /**
+ * A flag that specifies if `render.bounds` should be used when rendering.
+ *
+ * @property options.hasBounds
+ * @type boolean
+ * @default false
+ */
+
+ /**
+ * A flag to enable or disable all debug information overlays together.
+ * This includes and has priority over the values of:
+ *
+ * - `render.options.showStats`
+ * - `render.options.showPerformance`
+ *
+ * @property options.showDebug
+ * @type boolean
+ * @default false
+ */
+
+ /**
+ * A flag to enable or disable the engine stats info overlay.
+ * From left to right, the values shown are:
+ *
+ * - body parts total
+ * - body total
+ * - constraints total
+ * - composites total
+ * - collision pairs total
+ *
+ * @property options.showStats
+ * @type boolean
+ * @default false
+ */
+
+ /**
+ * A flag to enable or disable performance charts.
+ * From left to right, the values shown are:
+ *
+ * - average render frequency (e.g. 60 fps)
+ * - exact engine delta time used for last update (e.g. 16.66ms)
+ * - average engine execution duration (e.g. 5.00ms)
+ * - average render execution duration (e.g. 0.40ms)
+ * - average effective play speed (e.g. '1.00x' is 'real-time')
+ *
+ * Each value is recorded over a fixed sample of past frames (60 frames).
+ *
+ * A chart shown below each value indicates the variance from the average over the sample.
+ * The more stable or fixed the value is the flatter the chart will appear.
+ *
+ * @property options.showPerformance
+ * @type boolean
+ * @default false
+ */
+
+ /**
+ * A flag to enable or disable rendering entirely.
+ *
+ * @property options.enabled
+ * @type boolean
+ * @default false
+ */
+
+ /**
+ * A flag to toggle wireframe rendering otherwise solid fill rendering is used.
+ *
+ * @property options.wireframes
+ * @type boolean
+ * @default true
+ */
+
+ /**
+ * A flag to enable or disable sleeping bodies indicators.
+ *
+ * @property options.showSleeping
+ * @type boolean
+ * @default true
+ */
+
+ /**
+ * A flag to enable or disable the debug information overlay.
+ *
+ * @property options.showDebug
+ * @type boolean
+ * @default false
+ */
+
+ /**
+ * A flag to enable or disable the collision broadphase debug overlay.
+ *
+ * @property options.showBroadphase
+ * @type boolean
+ * @default false
+ */
+
+ /**
+ * A flag to enable or disable the body bounds debug overlay.
+ *
+ * @property options.showBounds
+ * @type boolean
+ * @default false
+ */
+
+ /**
+ * A flag to enable or disable the body velocity debug overlay.
+ *
+ * @property options.showVelocity
+ * @type boolean
+ * @default false
+ */
+
+ /**
+ * A flag to enable or disable the body collisions debug overlay.
+ *
+ * @property options.showCollisions
+ * @type boolean
+ * @default false
+ */
+
+ /**
+ * A flag to enable or disable the collision resolver separations debug overlay.
+ *
+ * @property options.showSeparations
+ * @type boolean
+ * @default false
+ */
+
+ /**
+ * A flag to enable or disable the body axes debug overlay.
+ *
+ * @property options.showAxes
+ * @type boolean
+ * @default false
+ */
+
+ /**
+ * A flag to enable or disable the body positions debug overlay.
+ *
+ * @property options.showPositions
+ * @type boolean
+ * @default false
+ */
+
+ /**
+ * A flag to enable or disable the body angle debug overlay.
+ *
+ * @property options.showAngleIndicator
+ * @type boolean
+ * @default false
+ */
+
+ /**
+ * A flag to enable or disable the body and part ids debug overlay.
+ *
+ * @property options.showIds
+ * @type boolean
+ * @default false
+ */
+
+ /**
+ * A flag to enable or disable the body vertex numbers debug overlay.
+ *
+ * @property options.showVertexNumbers
+ * @type boolean
+ * @default false
+ */
+
+ /**
+ * A flag to enable or disable the body convex hulls debug overlay.
+ *
+ * @property options.showConvexHulls
+ * @type boolean
+ * @default false
+ */
+
+ /**
+ * A flag to enable or disable the body internal edges debug overlay.
+ *
+ * @property options.showInternalEdges
+ * @type boolean
+ * @default false
+ */
+
+ /**
+ * A flag to enable or disable the mouse position debug overlay.
+ *
+ * @property options.showMousePosition
+ * @type boolean
+ * @default false
+ */
+
})();
-},{"../body/Composite":2,"../collision/Grid":6,"../core/Common":14,"../core/Events":16,"../core/Mouse":19,"../geometry/Bounds":26,"../geometry/Vector":28}],32:[function(_dereq_,module,exports){
+
+/***/ }),
+/* 17 */
+/***/ (function(module, exports) {
+
/**
-* The `Matter.RenderPixi` module is an example renderer using pixi.js.
-* See also `Matter.Render` for a canvas based renderer.
+* The `Matter.Contact` module contains methods for creating and manipulating collision contacts.
*
-* @class RenderPixi
-* @deprecated the Matter.RenderPixi module will soon be removed from the Matter.js core.
-* It will likely be moved to its own repository (but maintenance will be limited).
+* @class Contact
*/
-var RenderPixi = {};
+var Contact = {};
-module.exports = RenderPixi;
+module.exports = Contact;
-var Bounds = _dereq_('../geometry/Bounds');
-var Composite = _dereq_('../body/Composite');
-var Common = _dereq_('../core/Common');
-var Events = _dereq_('../core/Events');
-var Vector = _dereq_('../geometry/Vector');
+(function() {
+
+ /**
+ * Creates a new contact.
+ * @method create
+ * @param {vertex} vertex
+ * @return {contact} A new contact
+ */
+ Contact.create = function(vertex) {
+ return {
+ id: Contact.id(vertex),
+ vertex: vertex,
+ normalImpulse: 0,
+ tangentImpulse: 0
+ };
+ };
+
+ /**
+ * Generates a contact id.
+ * @method id
+ * @param {vertex} vertex
+ * @return {string} Unique contactID
+ */
+ Contact.id = function(vertex) {
+ return vertex.body.id + '_' + vertex.index;
+ };
+
+})();
+
+
+/***/ }),
+/* 18 */
+/***/ (function(module, exports, __webpack_require__) {
+
+/**
+* The `Matter.Engine` module contains methods for creating and manipulating engines.
+* An engine is a controller that manages updating the simulation of the world.
+* See `Matter.Runner` for an optional game loop utility.
+*
+* See the included usage [examples](https://github.com/liabru/matter-js/tree/master/examples).
+*
+* @class Engine
+*/
+
+var Engine = {};
+
+module.exports = Engine;
+
+var Sleeping = __webpack_require__(7);
+var Resolver = __webpack_require__(19);
+var Detector = __webpack_require__(13);
+var Pairs = __webpack_require__(20);
+var Grid = __webpack_require__(21);
+var Events = __webpack_require__(4);
+var Composite = __webpack_require__(5);
+var Constraint = __webpack_require__(8);
+var Common = __webpack_require__(0);
+var Body = __webpack_require__(6);
+
+(function() {
+
+ /**
+ * Creates a new engine. The options parameter is an object that specifies any properties you wish to override the defaults.
+ * All properties have default values, and many are pre-calculated automatically based on other properties.
+ * See the properties section below for detailed information on what you can pass via the `options` object.
+ * @method create
+ * @param {object} [options]
+ * @return {engine} engine
+ */
+ Engine.create = function(options) {
+ options = options || {};
+
+ var defaults = {
+ positionIterations: 6,
+ velocityIterations: 4,
+ constraintIterations: 2,
+ enableSleeping: false,
+ events: [],
+ plugin: {},
+ grid: null,
+ gravity: {
+ x: 0,
+ y: 1,
+ scale: 0.001
+ },
+ timing: {
+ timestamp: 0,
+ timeScale: 1,
+ lastDelta: 0,
+ lastElapsed: 0
+ }
+ };
+
+ var engine = Common.extend(defaults, options);
+
+ engine.world = options.world || Composite.create({ label: 'World' });
+ engine.grid = Grid.create(options.grid || options.broadphase);
+ engine.pairs = Pairs.create();
+
+ // temporary back compatibility
+ engine.world.gravity = engine.gravity;
+ engine.broadphase = engine.grid;
+ engine.metrics = {};
+
+ return engine;
+ };
+
+ /**
+ * Moves the simulation forward in time by `delta` ms.
+ * The `correction` argument is an optional `Number` that specifies the time correction factor to apply to the update.
+ * This can help improve the accuracy of the simulation in cases where `delta` is changing between updates.
+ * The value of `correction` is defined as `delta / lastDelta`, i.e. the percentage change of `delta` over the last step.
+ * Therefore the value is always `1` (no correction) when `delta` constant (or when no correction is desired, which is the default).
+ * See the paper on Time Corrected Verlet for more information.
+ *
+ * Triggers `beforeUpdate` and `afterUpdate` events.
+ * Triggers `collisionStart`, `collisionActive` and `collisionEnd` events.
+ * @method update
+ * @param {engine} engine
+ * @param {number} [delta=16.666]
+ * @param {number} [correction=1]
+ */
+ Engine.update = function(engine, delta, correction) {
+ var startTime = Common.now();
+
+ delta = delta || 1000 / 60;
+ correction = correction || 1;
+
+ var world = engine.world,
+ timing = engine.timing,
+ grid = engine.grid,
+ gridPairs = [],
+ i;
+
+ // increment timestamp
+ timing.timestamp += delta * timing.timeScale;
+ timing.lastDelta = delta * timing.timeScale;
+
+ // create an event object
+ var event = {
+ timestamp: timing.timestamp
+ };
+
+ Events.trigger(engine, 'beforeUpdate', event);
+
+ // get lists of all bodies and constraints, no matter what composites they are in
+ var allBodies = Composite.allBodies(world),
+ allConstraints = Composite.allConstraints(world);
+
+ // if sleeping enabled, call the sleeping controller
+ if (engine.enableSleeping)
+ Sleeping.update(allBodies, timing.timeScale);
+
+ // applies gravity to all bodies
+ Engine._bodiesApplyGravity(allBodies, engine.gravity);
+
+ // update all body position and rotation by integration
+ Engine._bodiesUpdate(allBodies, delta, timing.timeScale, correction, world.bounds);
+
+ // update all constraints (first pass)
+ Constraint.preSolveAll(allBodies);
+ for (i = 0; i < engine.constraintIterations; i++) {
+ Constraint.solveAll(allConstraints, timing.timeScale);
+ }
+ Constraint.postSolveAll(allBodies);
+
+ // broadphase pass: find potential collision pairs
+
+ // if world is dirty, we must flush the whole grid
+ if (world.isModified)
+ Grid.clear(grid);
+
+ // update the grid buckets based on current bodies
+ Grid.update(grid, allBodies, engine, world.isModified);
+ gridPairs = grid.pairsList;
+
+ // clear all composite modified flags
+ if (world.isModified) {
+ Composite.setModified(world, false, false, true);
+ }
+
+ // narrowphase pass: find actual collisions, then create or update collision pairs
+ var collisions = Detector.collisions(gridPairs, engine);
+
+ // update collision pairs
+ var pairs = engine.pairs,
+ timestamp = timing.timestamp;
+ Pairs.update(pairs, collisions, timestamp);
+ Pairs.removeOld(pairs, timestamp);
+
+ // wake up bodies involved in collisions
+ if (engine.enableSleeping)
+ Sleeping.afterCollisions(pairs.list, timing.timeScale);
+
+ // trigger collision events
+ if (pairs.collisionStart.length > 0)
+ Events.trigger(engine, 'collisionStart', { pairs: pairs.collisionStart });
+
+ // iteratively resolve position between collisions
+ Resolver.preSolvePosition(pairs.list);
+ for (i = 0; i < engine.positionIterations; i++) {
+ Resolver.solvePosition(pairs.list, timing.timeScale);
+ }
+ Resolver.postSolvePosition(allBodies);
+
+ // update all constraints (second pass)
+ Constraint.preSolveAll(allBodies);
+ for (i = 0; i < engine.constraintIterations; i++) {
+ Constraint.solveAll(allConstraints, timing.timeScale);
+ }
+ Constraint.postSolveAll(allBodies);
+
+ // iteratively resolve velocity between collisions
+ Resolver.preSolveVelocity(pairs.list);
+ for (i = 0; i < engine.velocityIterations; i++) {
+ Resolver.solveVelocity(pairs.list, timing.timeScale);
+ }
+
+ // trigger collision events
+ if (pairs.collisionActive.length > 0)
+ Events.trigger(engine, 'collisionActive', { pairs: pairs.collisionActive });
+
+ if (pairs.collisionEnd.length > 0)
+ Events.trigger(engine, 'collisionEnd', { pairs: pairs.collisionEnd });
+
+ // clear force buffers
+ Engine._bodiesClearForces(allBodies);
+
+ Events.trigger(engine, 'afterUpdate', event);
+
+ // log the time elapsed computing this update
+ engine.timing.lastElapsed = Common.now() - startTime;
+
+ return engine;
+ };
+
+ /**
+ * Merges two engines by keeping the configuration of `engineA` but replacing the world with the one from `engineB`.
+ * @method merge
+ * @param {engine} engineA
+ * @param {engine} engineB
+ */
+ Engine.merge = function(engineA, engineB) {
+ Common.extend(engineA, engineB);
+
+ if (engineB.world) {
+ engineA.world = engineB.world;
+
+ Engine.clear(engineA);
+
+ var bodies = Composite.allBodies(engineA.world);
+
+ for (var i = 0; i < bodies.length; i++) {
+ var body = bodies[i];
+ Sleeping.set(body, false);
+ body.id = Common.nextId();
+ }
+ }
+ };
+
+ /**
+ * Clears the engine including the world, pairs and broadphase.
+ * @method clear
+ * @param {engine} engine
+ */
+ Engine.clear = function(engine) {
+ var world = engine.world,
+ bodies = Composite.allBodies(world);
+
+ Pairs.clear(engine.pairs);
+ Grid.clear(engine.grid);
+ Grid.update(engine.grid, bodies, engine, true);
+ };
+
+ /**
+ * Zeroes the `body.force` and `body.torque` force buffers.
+ * @method _bodiesClearForces
+ * @private
+ * @param {body[]} bodies
+ */
+ Engine._bodiesClearForces = function(bodies) {
+ for (var i = 0; i < bodies.length; i++) {
+ var body = bodies[i];
+
+ // reset force buffers
+ body.force.x = 0;
+ body.force.y = 0;
+ body.torque = 0;
+ }
+ };
+
+ /**
+ * Applys a mass dependant force to all given bodies.
+ * @method _bodiesApplyGravity
+ * @private
+ * @param {body[]} bodies
+ * @param {vector} gravity
+ */
+ Engine._bodiesApplyGravity = function(bodies, gravity) {
+ var gravityScale = typeof gravity.scale !== 'undefined' ? gravity.scale : 0.001;
+
+ if ((gravity.x === 0 && gravity.y === 0) || gravityScale === 0) {
+ return;
+ }
+
+ for (var i = 0; i < bodies.length; i++) {
+ var body = bodies[i];
+
+ if (body.isStatic || body.isSleeping)
+ continue;
+
+ // apply gravity
+ body.force.y += body.mass * gravity.y * gravityScale;
+ body.force.x += body.mass * gravity.x * gravityScale;
+ }
+ };
+
+ /**
+ * Applys `Body.update` to all given `bodies`.
+ * @method _bodiesUpdate
+ * @private
+ * @param {body[]} bodies
+ * @param {number} deltaTime
+ * The amount of time elapsed between updates
+ * @param {number} timeScale
+ * @param {number} correction
+ * The Verlet correction factor (deltaTime / lastDeltaTime)
+ * @param {bounds} worldBounds
+ */
+ Engine._bodiesUpdate = function(bodies, deltaTime, timeScale, correction, worldBounds) {
+ for (var i = 0; i < bodies.length; i++) {
+ var body = bodies[i];
+
+ if (body.isStatic || body.isSleeping)
+ continue;
+
+ Body.update(body, deltaTime, timeScale, correction);
+ }
+ };
+
+ /**
+ * A deprecated alias for `Runner.run`, use `Matter.Runner.run(engine)` instead and see `Matter.Runner` for more information.
+ * @deprecated use Matter.Runner.run(engine) instead
+ * @method run
+ * @param {engine} engine
+ */
+
+ /**
+ * Fired just before an update
+ *
+ * @event beforeUpdate
+ * @param {} event An event object
+ * @param {number} event.timestamp The engine.timing.timestamp of the event
+ * @param {} event.source The source object of the event
+ * @param {} event.name The name of the event
+ */
+
+ /**
+ * Fired after engine update and all collision events
+ *
+ * @event afterUpdate
+ * @param {} event An event object
+ * @param {number} event.timestamp The engine.timing.timestamp of the event
+ * @param {} event.source The source object of the event
+ * @param {} event.name The name of the event
+ */
+
+ /**
+ * Fired after engine update, provides a list of all pairs that have started to collide in the current tick (if any)
+ *
+ * @event collisionStart
+ * @param {} event An event object
+ * @param {} event.pairs List of affected pairs
+ * @param {number} event.timestamp The engine.timing.timestamp of the event
+ * @param {} event.source The source object of the event
+ * @param {} event.name The name of the event
+ */
+
+ /**
+ * Fired after engine update, provides a list of all pairs that are colliding in the current tick (if any)
+ *
+ * @event collisionActive
+ * @param {} event An event object
+ * @param {} event.pairs List of affected pairs
+ * @param {number} event.timestamp The engine.timing.timestamp of the event
+ * @param {} event.source The source object of the event
+ * @param {} event.name The name of the event
+ */
+
+ /**
+ * Fired after engine update, provides a list of all pairs that have ended collision in the current tick (if any)
+ *
+ * @event collisionEnd
+ * @param {} event An event object
+ * @param {} event.pairs List of affected pairs
+ * @param {number} event.timestamp The engine.timing.timestamp of the event
+ * @param {} event.source The source object of the event
+ * @param {} event.name The name of the event
+ */
+
+ /*
+ *
+ * Properties Documentation
+ *
+ */
+
+ /**
+ * An integer `Number` that specifies the number of position iterations to perform each update.
+ * The higher the value, the higher quality the simulation will be at the expense of performance.
+ *
+ * @property positionIterations
+ * @type number
+ * @default 6
+ */
+
+ /**
+ * An integer `Number` that specifies the number of velocity iterations to perform each update.
+ * The higher the value, the higher quality the simulation will be at the expense of performance.
+ *
+ * @property velocityIterations
+ * @type number
+ * @default 4
+ */
+
+ /**
+ * An integer `Number` that specifies the number of constraint iterations to perform each update.
+ * The higher the value, the higher quality the simulation will be at the expense of performance.
+ * The default value of `2` is usually very adequate.
+ *
+ * @property constraintIterations
+ * @type number
+ * @default 2
+ */
+
+ /**
+ * A flag that specifies whether the engine should allow sleeping via the `Matter.Sleeping` module.
+ * Sleeping can improve stability and performance, but often at the expense of accuracy.
+ *
+ * @property enableSleeping
+ * @type boolean
+ * @default false
+ */
+
+ /**
+ * An `Object` containing properties regarding the timing systems of the engine.
+ *
+ * @property timing
+ * @type object
+ */
+
+ /**
+ * A `Number` that specifies the global scaling factor of time for all bodies.
+ * A value of `0` freezes the simulation.
+ * A value of `0.1` gives a slow-motion effect.
+ * A value of `1.2` gives a speed-up effect.
+ *
+ * @property timing.timeScale
+ * @type number
+ * @default 1
+ */
+
+ /**
+ * A `Number` that specifies the current simulation-time in milliseconds starting from `0`.
+ * It is incremented on every `Engine.update` by the given `delta` argument.
+ *
+ * @property timing.timestamp
+ * @type number
+ * @default 0
+ */
+
+ /**
+ * A `Number` that represents the total execution time elapsed during the last `Engine.update` in milliseconds.
+ * It is updated by timing from the start of the last `Engine.update` call until it ends.
+ *
+ * This value will also include the total execution time of all event handlers directly or indirectly triggered by the engine update.
+ *
+ * @property timing.lastElapsed
+ * @type number
+ * @default 0
+ */
+
+ /**
+ * A `Number` that represents the `delta` value used in the last engine update.
+ *
+ * @property timing.lastDelta
+ * @type number
+ * @default 0
+ */
+
+ /**
+ * A `Matter.Grid` instance.
+ *
+ * @property grid
+ * @type grid
+ * @default a Matter.Grid instance
+ */
+
+ /**
+ * Replaced by and now alias for `engine.grid`.
+ *
+ * @deprecated use `engine.grid`
+ * @property broadphase
+ * @type grid
+ * @default a Matter.Grid instance
+ */
+
+ /**
+ * The root `Matter.Composite` instance that will contain all bodies, constraints and other composites to be simulated by this engine.
+ *
+ * @property world
+ * @type composite
+ * @default a Matter.Composite instance
+ */
+
+ /**
+ * An object reserved for storing plugin-specific properties.
+ *
+ * @property plugin
+ * @type {}
+ */
+
+ /**
+ * The gravity to apply on all bodies in `engine.world`.
+ *
+ * @property gravity
+ * @type object
+ */
+
+ /**
+ * The gravity x component.
+ *
+ * @property gravity.x
+ * @type object
+ * @default 0
+ */
+
+ /**
+ * The gravity y component.
+ *
+ * @property gravity.y
+ * @type object
+ * @default 1
+ */
+
+ /**
+ * The gravity scale factor.
+ *
+ * @property gravity.scale
+ * @type object
+ * @default 0.001
+ */
+
+})();
+
+
+/***/ }),
+/* 19 */
+/***/ (function(module, exports, __webpack_require__) {
+
+/**
+* The `Matter.Resolver` module contains methods for resolving collision pairs.
+*
+* @class Resolver
+*/
+
+var Resolver = {};
+
+module.exports = Resolver;
+
+var Vertices = __webpack_require__(3);
+var Vector = __webpack_require__(2);
+var Common = __webpack_require__(0);
+var Bounds = __webpack_require__(1);
+
+(function() {
+
+ Resolver._restingThresh = 4;
+ Resolver._restingThreshTangent = 6;
+ Resolver._positionDampen = 0.9;
+ Resolver._positionWarming = 0.8;
+ Resolver._frictionNormalMultiplier = 5;
+
+ /**
+ * Prepare pairs for position solving.
+ * @method preSolvePosition
+ * @param {pair[]} pairs
+ */
+ Resolver.preSolvePosition = function(pairs) {
+ var i,
+ pair,
+ activeCount;
+
+ // find total contacts on each body
+ for (i = 0; i < pairs.length; i++) {
+ pair = pairs[i];
+
+ if (!pair.isActive)
+ continue;
+
+ activeCount = pair.activeContacts.length;
+ pair.collision.parentA.totalContacts += activeCount;
+ pair.collision.parentB.totalContacts += activeCount;
+ }
+ };
+
+ /**
+ * Find a solution for pair positions.
+ * @method solvePosition
+ * @param {pair[]} pairs
+ * @param {number} timeScale
+ */
+ Resolver.solvePosition = function(pairs, timeScale) {
+ var i,
+ pair,
+ collision,
+ bodyA,
+ bodyB,
+ normal,
+ bodyBtoA,
+ contactShare,
+ positionImpulse,
+ contactCount = {},
+ tempA = Vector._temp[0],
+ tempB = Vector._temp[1],
+ tempC = Vector._temp[2],
+ tempD = Vector._temp[3];
+
+ // find impulses required to resolve penetration
+ for (i = 0; i < pairs.length; i++) {
+ pair = pairs[i];
+
+ if (!pair.isActive || pair.isSensor)
+ continue;
+
+ collision = pair.collision;
+ bodyA = collision.parentA;
+ bodyB = collision.parentB;
+ normal = collision.normal;
+
+ // get current separation between body edges involved in collision
+ bodyBtoA = Vector.sub(Vector.add(bodyB.positionImpulse, bodyB.position, tempA),
+ Vector.add(bodyA.positionImpulse,
+ Vector.sub(bodyB.position, collision.penetration, tempB), tempC), tempD);
+
+ pair.separation = Vector.dot(normal, bodyBtoA);
+ }
+
+ for (i = 0; i < pairs.length; i++) {
+ pair = pairs[i];
+
+ if (!pair.isActive || pair.isSensor)
+ continue;
+
+ collision = pair.collision;
+ bodyA = collision.parentA;
+ bodyB = collision.parentB;
+ normal = collision.normal;
+ positionImpulse = (pair.separation - pair.slop) * timeScale;
+
+ if (bodyA.isStatic || bodyB.isStatic)
+ positionImpulse *= 2;
+
+ if (!(bodyA.isStatic || bodyA.isSleeping)) {
+ contactShare = Resolver._positionDampen / bodyA.totalContacts;
+ bodyA.positionImpulse.x += normal.x * positionImpulse * contactShare;
+ bodyA.positionImpulse.y += normal.y * positionImpulse * contactShare;
+ }
+
+ if (!(bodyB.isStatic || bodyB.isSleeping)) {
+ contactShare = Resolver._positionDampen / bodyB.totalContacts;
+ bodyB.positionImpulse.x -= normal.x * positionImpulse * contactShare;
+ bodyB.positionImpulse.y -= normal.y * positionImpulse * contactShare;
+ }
+ }
+ };
+
+ /**
+ * Apply position resolution.
+ * @method postSolvePosition
+ * @param {body[]} bodies
+ */
+ Resolver.postSolvePosition = function(bodies) {
+ for (var i = 0; i < bodies.length; i++) {
+ var body = bodies[i];
+
+ // reset contact count
+ body.totalContacts = 0;
+
+ if (body.positionImpulse.x !== 0 || body.positionImpulse.y !== 0) {
+ // update body geometry
+ for (var j = 0; j < body.parts.length; j++) {
+ var part = body.parts[j];
+ Vertices.translate(part.vertices, body.positionImpulse);
+ Bounds.update(part.bounds, part.vertices, body.velocity);
+ part.position.x += body.positionImpulse.x;
+ part.position.y += body.positionImpulse.y;
+ }
+
+ // move the body without changing velocity
+ body.positionPrev.x += body.positionImpulse.x;
+ body.positionPrev.y += body.positionImpulse.y;
+
+ if (Vector.dot(body.positionImpulse, body.velocity) < 0) {
+ // reset cached impulse if the body has velocity along it
+ body.positionImpulse.x = 0;
+ body.positionImpulse.y = 0;
+ } else {
+ // warm the next iteration
+ body.positionImpulse.x *= Resolver._positionWarming;
+ body.positionImpulse.y *= Resolver._positionWarming;
+ }
+ }
+ }
+ };
+
+ /**
+ * Prepare pairs for velocity solving.
+ * @method preSolveVelocity
+ * @param {pair[]} pairs
+ */
+ Resolver.preSolveVelocity = function(pairs) {
+ var i,
+ j,
+ pair,
+ contacts,
+ collision,
+ bodyA,
+ bodyB,
+ normal,
+ tangent,
+ contact,
+ contactVertex,
+ normalImpulse,
+ tangentImpulse,
+ offset,
+ impulse = Vector._temp[0],
+ tempA = Vector._temp[1];
+
+ for (i = 0; i < pairs.length; i++) {
+ pair = pairs[i];
+
+ if (!pair.isActive || pair.isSensor)
+ continue;
+
+ contacts = pair.activeContacts;
+ collision = pair.collision;
+ bodyA = collision.parentA;
+ bodyB = collision.parentB;
+ normal = collision.normal;
+ tangent = collision.tangent;
+
+ // resolve each contact
+ for (j = 0; j < contacts.length; j++) {
+ contact = contacts[j];
+ contactVertex = contact.vertex;
+ normalImpulse = contact.normalImpulse;
+ tangentImpulse = contact.tangentImpulse;
+
+ if (normalImpulse !== 0 || tangentImpulse !== 0) {
+ // total impulse from contact
+ impulse.x = (normal.x * normalImpulse) + (tangent.x * tangentImpulse);
+ impulse.y = (normal.y * normalImpulse) + (tangent.y * tangentImpulse);
+
+ // apply impulse from contact
+ if (!(bodyA.isStatic || bodyA.isSleeping)) {
+ offset = Vector.sub(contactVertex, bodyA.position, tempA);
+ bodyA.positionPrev.x += impulse.x * bodyA.inverseMass;
+ bodyA.positionPrev.y += impulse.y * bodyA.inverseMass;
+ bodyA.anglePrev += Vector.cross(offset, impulse) * bodyA.inverseInertia;
+ }
+
+ if (!(bodyB.isStatic || bodyB.isSleeping)) {
+ offset = Vector.sub(contactVertex, bodyB.position, tempA);
+ bodyB.positionPrev.x -= impulse.x * bodyB.inverseMass;
+ bodyB.positionPrev.y -= impulse.y * bodyB.inverseMass;
+ bodyB.anglePrev -= Vector.cross(offset, impulse) * bodyB.inverseInertia;
+ }
+ }
+ }
+ }
+ };
+
+ /**
+ * Find a solution for pair velocities.
+ * @method solveVelocity
+ * @param {pair[]} pairs
+ * @param {number} timeScale
+ */
+ Resolver.solveVelocity = function(pairs, timeScale) {
+ var timeScaleSquared = timeScale * timeScale,
+ impulse = Vector._temp[0],
+ tempA = Vector._temp[1],
+ tempB = Vector._temp[2],
+ tempC = Vector._temp[3],
+ tempD = Vector._temp[4],
+ tempE = Vector._temp[5];
+
+ for (var i = 0; i < pairs.length; i++) {
+ var pair = pairs[i];
+
+ if (!pair.isActive || pair.isSensor)
+ continue;
+
+ var collision = pair.collision,
+ bodyA = collision.parentA,
+ bodyB = collision.parentB,
+ normal = collision.normal,
+ tangent = collision.tangent,
+ contacts = pair.activeContacts,
+ contactShare = 1 / contacts.length;
+
+ // update body velocities
+ bodyA.velocity.x = bodyA.position.x - bodyA.positionPrev.x;
+ bodyA.velocity.y = bodyA.position.y - bodyA.positionPrev.y;
+ bodyB.velocity.x = bodyB.position.x - bodyB.positionPrev.x;
+ bodyB.velocity.y = bodyB.position.y - bodyB.positionPrev.y;
+ bodyA.angularVelocity = bodyA.angle - bodyA.anglePrev;
+ bodyB.angularVelocity = bodyB.angle - bodyB.anglePrev;
+
+ // resolve each contact
+ for (var j = 0; j < contacts.length; j++) {
+ var contact = contacts[j],
+ contactVertex = contact.vertex,
+ offsetA = Vector.sub(contactVertex, bodyA.position, tempA),
+ offsetB = Vector.sub(contactVertex, bodyB.position, tempB),
+ velocityPointA = Vector.add(bodyA.velocity, Vector.mult(Vector.perp(offsetA), bodyA.angularVelocity), tempC),
+ velocityPointB = Vector.add(bodyB.velocity, Vector.mult(Vector.perp(offsetB), bodyB.angularVelocity), tempD),
+ relativeVelocity = Vector.sub(velocityPointA, velocityPointB, tempE),
+ normalVelocity = Vector.dot(normal, relativeVelocity);
+
+ var tangentVelocity = Vector.dot(tangent, relativeVelocity),
+ tangentSpeed = Math.abs(tangentVelocity),
+ tangentVelocityDirection = Common.sign(tangentVelocity);
+
+ // raw impulses
+ var normalImpulse = (1 + pair.restitution) * normalVelocity,
+ normalForce = Common.clamp(pair.separation + normalVelocity, 0, 1) * Resolver._frictionNormalMultiplier;
+
+ // coulomb friction
+ var tangentImpulse = tangentVelocity,
+ maxFriction = Infinity;
+
+ if (tangentSpeed > pair.friction * pair.frictionStatic * normalForce * timeScaleSquared) {
+ maxFriction = tangentSpeed;
+ tangentImpulse = Common.clamp(
+ pair.friction * tangentVelocityDirection * timeScaleSquared,
+ -maxFriction, maxFriction
+ );
+ }
+
+ // modify impulses accounting for mass, inertia and offset
+ var oAcN = Vector.cross(offsetA, normal),
+ oBcN = Vector.cross(offsetB, normal),
+ share = contactShare / (bodyA.inverseMass + bodyB.inverseMass + bodyA.inverseInertia * oAcN * oAcN + bodyB.inverseInertia * oBcN * oBcN);
+
+ normalImpulse *= share;
+ tangentImpulse *= share;
+
+ // handle high velocity and resting collisions separately
+ if (normalVelocity < 0 && normalVelocity * normalVelocity > Resolver._restingThresh * timeScaleSquared) {
+ // high normal velocity so clear cached contact normal impulse
+ contact.normalImpulse = 0;
+ } else {
+ // solve resting collision constraints using Erin Catto's method (GDC08)
+ // impulse constraint tends to 0
+ var contactNormalImpulse = contact.normalImpulse;
+ contact.normalImpulse = Math.min(contact.normalImpulse + normalImpulse, 0);
+ normalImpulse = contact.normalImpulse - contactNormalImpulse;
+ }
+
+ // handle high velocity and resting collisions separately
+ if (tangentVelocity * tangentVelocity > Resolver._restingThreshTangent * timeScaleSquared) {
+ // high tangent velocity so clear cached contact tangent impulse
+ contact.tangentImpulse = 0;
+ } else {
+ // solve resting collision constraints using Erin Catto's method (GDC08)
+ // tangent impulse tends to -tangentSpeed or +tangentSpeed
+ var contactTangentImpulse = contact.tangentImpulse;
+ contact.tangentImpulse = Common.clamp(contact.tangentImpulse + tangentImpulse, -maxFriction, maxFriction);
+ tangentImpulse = contact.tangentImpulse - contactTangentImpulse;
+ }
+
+ // total impulse from contact
+ impulse.x = (normal.x * normalImpulse) + (tangent.x * tangentImpulse);
+ impulse.y = (normal.y * normalImpulse) + (tangent.y * tangentImpulse);
+
+ // apply impulse from contact
+ if (!(bodyA.isStatic || bodyA.isSleeping)) {
+ bodyA.positionPrev.x += impulse.x * bodyA.inverseMass;
+ bodyA.positionPrev.y += impulse.y * bodyA.inverseMass;
+ bodyA.anglePrev += Vector.cross(offsetA, impulse) * bodyA.inverseInertia;
+ }
+
+ if (!(bodyB.isStatic || bodyB.isSleeping)) {
+ bodyB.positionPrev.x -= impulse.x * bodyB.inverseMass;
+ bodyB.positionPrev.y -= impulse.y * bodyB.inverseMass;
+ bodyB.anglePrev -= Vector.cross(offsetB, impulse) * bodyB.inverseInertia;
+ }
+ }
+ }
+ };
+
+})();
+
+
+/***/ }),
+/* 20 */
+/***/ (function(module, exports, __webpack_require__) {
+
+/**
+* The `Matter.Pairs` module contains methods for creating and manipulating collision pair sets.
+*
+* @class Pairs
+*/
+
+var Pairs = {};
+
+module.exports = Pairs;
+
+var Pair = __webpack_require__(9);
+var Common = __webpack_require__(0);
+
+(function() {
+
+ Pairs._pairMaxIdleLife = 1000;
+
+ /**
+ * Creates a new pairs structure.
+ * @method create
+ * @param {object} options
+ * @return {pairs} A new pairs structure
+ */
+ Pairs.create = function(options) {
+ return Common.extend({
+ table: {},
+ list: [],
+ collisionStart: [],
+ collisionActive: [],
+ collisionEnd: []
+ }, options);
+ };
+
+ /**
+ * Updates pairs given a list of collisions.
+ * @method update
+ * @param {object} pairs
+ * @param {collision[]} collisions
+ * @param {number} timestamp
+ */
+ Pairs.update = function(pairs, collisions, timestamp) {
+ var pairsList = pairs.list,
+ pairsTable = pairs.table,
+ collisionStart = pairs.collisionStart,
+ collisionEnd = pairs.collisionEnd,
+ collisionActive = pairs.collisionActive,
+ collision,
+ pairId,
+ pair,
+ i;
+
+ // clear collision state arrays, but maintain old reference
+ collisionStart.length = 0;
+ collisionEnd.length = 0;
+ collisionActive.length = 0;
+
+ for (i = 0; i < pairsList.length; i++) {
+ pairsList[i].confirmedActive = false;
+ }
+
+ for (i = 0; i < collisions.length; i++) {
+ collision = collisions[i];
+
+ if (collision.collided) {
+ pairId = Pair.id(collision.bodyA, collision.bodyB);
+
+ pair = pairsTable[pairId];
+
+ if (pair) {
+ // pair already exists (but may or may not be active)
+ if (pair.isActive) {
+ // pair exists and is active
+ collisionActive.push(pair);
+ } else {
+ // pair exists but was inactive, so a collision has just started again
+ collisionStart.push(pair);
+ }
+
+ // update the pair
+ Pair.update(pair, collision, timestamp);
+ pair.confirmedActive = true;
+ } else {
+ // pair did not exist, create a new pair
+ pair = Pair.create(collision, timestamp);
+ pairsTable[pairId] = pair;
+
+ // push the new pair
+ collisionStart.push(pair);
+ pairsList.push(pair);
+ }
+ }
+ }
+
+ // deactivate previously active pairs that are now inactive
+ for (i = 0; i < pairsList.length; i++) {
+ pair = pairsList[i];
+ if (pair.isActive && !pair.confirmedActive) {
+ Pair.setActive(pair, false, timestamp);
+ collisionEnd.push(pair);
+ }
+ }
+ };
+
+ /**
+ * Finds and removes pairs that have been inactive for a set amount of time.
+ * @method removeOld
+ * @param {object} pairs
+ * @param {number} timestamp
+ */
+ Pairs.removeOld = function(pairs, timestamp) {
+ var pairsList = pairs.list,
+ pairsTable = pairs.table,
+ indexesToRemove = [],
+ pair,
+ collision,
+ pairIndex,
+ i;
+
+ for (i = 0; i < pairsList.length; i++) {
+ pair = pairsList[i];
+ collision = pair.collision;
+
+ // never remove sleeping pairs
+ if (collision.bodyA.isSleeping || collision.bodyB.isSleeping) {
+ pair.timeUpdated = timestamp;
+ continue;
+ }
+
+ // if pair is inactive for too long, mark it to be removed
+ if (timestamp - pair.timeUpdated > Pairs._pairMaxIdleLife) {
+ indexesToRemove.push(i);
+ }
+ }
+
+ // remove marked pairs
+ for (i = 0; i < indexesToRemove.length; i++) {
+ pairIndex = indexesToRemove[i] - i;
+ pair = pairsList[pairIndex];
+ delete pairsTable[pair.id];
+ pairsList.splice(pairIndex, 1);
+ }
+ };
+
+ /**
+ * Clears the given pairs structure.
+ * @method clear
+ * @param {pairs} pairs
+ * @return {pairs} pairs
+ */
+ Pairs.clear = function(pairs) {
+ pairs.table = {};
+ pairs.list.length = 0;
+ pairs.collisionStart.length = 0;
+ pairs.collisionActive.length = 0;
+ pairs.collisionEnd.length = 0;
+ return pairs;
+ };
+
+})();
+
+
+/***/ }),
+/* 21 */
+/***/ (function(module, exports, __webpack_require__) {
+
+/**
+* The `Matter.Grid` module contains methods for creating and manipulating collision broadphase grid structures.
+*
+* @class Grid
+*/
+
+var Grid = {};
+
+module.exports = Grid;
+
+var Pair = __webpack_require__(9);
+var Common = __webpack_require__(0);
+
+(function() {
+
+ /**
+ * Creates a new grid.
+ * @method create
+ * @param {} options
+ * @return {grid} A new grid
+ */
+ Grid.create = function(options) {
+ var defaults = {
+ buckets: {},
+ pairs: {},
+ pairsList: [],
+ bucketWidth: 48,
+ bucketHeight: 48
+ };
+
+ return Common.extend(defaults, options);
+ };
+
+ /**
+ * The width of a single grid bucket.
+ *
+ * @property bucketWidth
+ * @type number
+ * @default 48
+ */
+
+ /**
+ * The height of a single grid bucket.
+ *
+ * @property bucketHeight
+ * @type number
+ * @default 48
+ */
+
+ /**
+ * Updates the grid.
+ * @method update
+ * @param {grid} grid
+ * @param {body[]} bodies
+ * @param {engine} engine
+ * @param {boolean} forceUpdate
+ */
+ Grid.update = function(grid, bodies, engine, forceUpdate) {
+ var i, col, row,
+ world = engine.world,
+ buckets = grid.buckets,
+ bucket,
+ bucketId,
+ gridChanged = false;
+
+ for (i = 0; i < bodies.length; i++) {
+ var body = bodies[i];
+
+ if (body.isSleeping && !forceUpdate)
+ continue;
+
+ // temporary back compatibility bounds check
+ if (world.bounds && (body.bounds.max.x < world.bounds.min.x || body.bounds.min.x > world.bounds.max.x
+ || body.bounds.max.y < world.bounds.min.y || body.bounds.min.y > world.bounds.max.y))
+ continue;
+
+ var newRegion = Grid._getRegion(grid, body);
+
+ // if the body has changed grid region
+ if (!body.region || newRegion.id !== body.region.id || forceUpdate) {
+
+ if (!body.region || forceUpdate)
+ body.region = newRegion;
+
+ var union = Grid._regionUnion(newRegion, body.region);
+
+ // update grid buckets affected by region change
+ // iterate over the union of both regions
+ for (col = union.startCol; col <= union.endCol; col++) {
+ for (row = union.startRow; row <= union.endRow; row++) {
+ bucketId = Grid._getBucketId(col, row);
+ bucket = buckets[bucketId];
+
+ var isInsideNewRegion = (col >= newRegion.startCol && col <= newRegion.endCol
+ && row >= newRegion.startRow && row <= newRegion.endRow);
+
+ var isInsideOldRegion = (col >= body.region.startCol && col <= body.region.endCol
+ && row >= body.region.startRow && row <= body.region.endRow);
+
+ // remove from old region buckets
+ if (!isInsideNewRegion && isInsideOldRegion) {
+ if (isInsideOldRegion) {
+ if (bucket)
+ Grid._bucketRemoveBody(grid, bucket, body);
+ }
+ }
+
+ // add to new region buckets
+ if (body.region === newRegion || (isInsideNewRegion && !isInsideOldRegion) || forceUpdate) {
+ if (!bucket)
+ bucket = Grid._createBucket(buckets, bucketId);
+ Grid._bucketAddBody(grid, bucket, body);
+ }
+ }
+ }
+
+ // set the new region
+ body.region = newRegion;
+
+ // flag changes so we can update pairs
+ gridChanged = true;
+ }
+ }
+
+ // update pairs list only if pairs changed (i.e. a body changed region)
+ if (gridChanged)
+ grid.pairsList = Grid._createActivePairsList(grid);
+ };
+
+ /**
+ * Clears the grid.
+ * @method clear
+ * @param {grid} grid
+ */
+ Grid.clear = function(grid) {
+ grid.buckets = {};
+ grid.pairs = {};
+ grid.pairsList = [];
+ };
+
+ /**
+ * Finds the union of two regions.
+ * @method _regionUnion
+ * @private
+ * @param {} regionA
+ * @param {} regionB
+ * @return {} region
+ */
+ Grid._regionUnion = function(regionA, regionB) {
+ var startCol = Math.min(regionA.startCol, regionB.startCol),
+ endCol = Math.max(regionA.endCol, regionB.endCol),
+ startRow = Math.min(regionA.startRow, regionB.startRow),
+ endRow = Math.max(regionA.endRow, regionB.endRow);
+
+ return Grid._createRegion(startCol, endCol, startRow, endRow);
+ };
+
+ /**
+ * Gets the region a given body falls in for a given grid.
+ * @method _getRegion
+ * @private
+ * @param {} grid
+ * @param {} body
+ * @return {} region
+ */
+ Grid._getRegion = function(grid, body) {
+ var bounds = body.bounds,
+ startCol = Math.floor(bounds.min.x / grid.bucketWidth),
+ endCol = Math.floor(bounds.max.x / grid.bucketWidth),
+ startRow = Math.floor(bounds.min.y / grid.bucketHeight),
+ endRow = Math.floor(bounds.max.y / grid.bucketHeight);
+
+ return Grid._createRegion(startCol, endCol, startRow, endRow);
+ };
+
+ /**
+ * Creates a region.
+ * @method _createRegion
+ * @private
+ * @param {} startCol
+ * @param {} endCol
+ * @param {} startRow
+ * @param {} endRow
+ * @return {} region
+ */
+ Grid._createRegion = function(startCol, endCol, startRow, endRow) {
+ return {
+ id: startCol + ',' + endCol + ',' + startRow + ',' + endRow,
+ startCol: startCol,
+ endCol: endCol,
+ startRow: startRow,
+ endRow: endRow
+ };
+ };
+
+ /**
+ * Gets the bucket id at the given position.
+ * @method _getBucketId
+ * @private
+ * @param {} column
+ * @param {} row
+ * @return {string} bucket id
+ */
+ Grid._getBucketId = function(column, row) {
+ return 'C' + column + 'R' + row;
+ };
+
+ /**
+ * Creates a bucket.
+ * @method _createBucket
+ * @private
+ * @param {} buckets
+ * @param {} bucketId
+ * @return {} bucket
+ */
+ Grid._createBucket = function(buckets, bucketId) {
+ var bucket = buckets[bucketId] = [];
+ return bucket;
+ };
+
+ /**
+ * Adds a body to a bucket.
+ * @method _bucketAddBody
+ * @private
+ * @param {} grid
+ * @param {} bucket
+ * @param {} body
+ */
+ Grid._bucketAddBody = function(grid, bucket, body) {
+ // add new pairs
+ for (var i = 0; i < bucket.length; i++) {
+ var bodyB = bucket[i];
+
+ if (body.id === bodyB.id || (body.isStatic && bodyB.isStatic))
+ continue;
+
+ // keep track of the number of buckets the pair exists in
+ // important for Grid.update to work
+ var pairId = Pair.id(body, bodyB),
+ pair = grid.pairs[pairId];
+
+ if (pair) {
+ pair[2] += 1;
+ } else {
+ grid.pairs[pairId] = [body, bodyB, 1];
+ }
+ }
+
+ // add to bodies (after pairs, otherwise pairs with self)
+ bucket.push(body);
+ };
+
+ /**
+ * Removes a body from a bucket.
+ * @method _bucketRemoveBody
+ * @private
+ * @param {} grid
+ * @param {} bucket
+ * @param {} body
+ */
+ Grid._bucketRemoveBody = function(grid, bucket, body) {
+ // remove from bucket
+ bucket.splice(Common.indexOf(bucket, body), 1);
+
+ // update pair counts
+ for (var i = 0; i < bucket.length; i++) {
+ // keep track of the number of buckets the pair exists in
+ // important for _createActivePairsList to work
+ var bodyB = bucket[i],
+ pairId = Pair.id(body, bodyB),
+ pair = grid.pairs[pairId];
+
+ if (pair)
+ pair[2] -= 1;
+ }
+ };
+
+ /**
+ * Generates a list of the active pairs in the grid.
+ * @method _createActivePairsList
+ * @private
+ * @param {} grid
+ * @return [] pairs
+ */
+ Grid._createActivePairsList = function(grid) {
+ var pairKeys,
+ pair,
+ pairs = [];
+
+ // grid.pairs is used as a hashmap
+ pairKeys = Common.keys(grid.pairs);
+
+ // iterate over grid.pairs
+ for (var k = 0; k < pairKeys.length; k++) {
+ pair = grid.pairs[pairKeys[k]];
+
+ // if pair exists in at least one bucket
+ // it is a pair that needs further collision testing so push it
+ if (pair[2] > 0) {
+ pairs.push(pair);
+ } else {
+ delete grid.pairs[pairKeys[k]];
+ }
+ }
+
+ return pairs;
+ };
+
+})();
+
+
+/***/ }),
+/* 22 */
+/***/ (function(module, exports, __webpack_require__) {
+
+var Matter = module.exports = __webpack_require__(23);
+
+Matter.Axes = __webpack_require__(10);
+Matter.Bodies = __webpack_require__(11);
+Matter.Body = __webpack_require__(6);
+Matter.Bounds = __webpack_require__(1);
+Matter.Common = __webpack_require__(0);
+Matter.Composite = __webpack_require__(5);
+Matter.Composites = __webpack_require__(24);
+Matter.Constraint = __webpack_require__(8);
+Matter.Contact = __webpack_require__(17);
+Matter.Detector = __webpack_require__(13);
+Matter.Engine = __webpack_require__(18);
+Matter.Events = __webpack_require__(4);
+Matter.Grid = __webpack_require__(21);
+Matter.Mouse = __webpack_require__(12);
+Matter.MouseConstraint = __webpack_require__(25);
+Matter.Pair = __webpack_require__(9);
+Matter.Pairs = __webpack_require__(20);
+Matter.Plugin = __webpack_require__(15);
+Matter.Query = __webpack_require__(26);
+Matter.Render = __webpack_require__(16);
+Matter.Resolver = __webpack_require__(19);
+Matter.Runner = __webpack_require__(27);
+Matter.SAT = __webpack_require__(14);
+Matter.Sleeping = __webpack_require__(7);
+Matter.Svg = __webpack_require__(28);
+Matter.Vector = __webpack_require__(2);
+Matter.Vertices = __webpack_require__(3);
+Matter.World = __webpack_require__(29);
+
+// temporary back compatibility
+Matter.Engine.run = Matter.Runner.run;
+Matter.Common.deprecated(Matter.Engine, 'run', 'Engine.run ➤ use Matter.Runner.run(engine) instead');
+
+
+/***/ }),
+/* 23 */
+/***/ (function(module, exports, __webpack_require__) {
+
+/**
+* The `Matter` module is the top level namespace. It also includes a function for installing plugins on top of the library.
+*
+* @class Matter
+*/
+
+var Matter = {};
+
+module.exports = Matter;
+
+var Plugin = __webpack_require__(15);
+var Common = __webpack_require__(0);
+
+(function() {
+
+ /**
+ * The library name.
+ * @property name
+ * @readOnly
+ * @type {String}
+ */
+ Matter.name = 'matter-js';
+
+ /**
+ * The library version.
+ * @property version
+ * @readOnly
+ * @type {String}
+ */
+ Matter.version = true ? "0.17.1" : undefined;
+
+ /**
+ * A list of plugin dependencies to be installed. These are normally set and installed through `Matter.use`.
+ * Alternatively you may set `Matter.uses` manually and install them by calling `Plugin.use(Matter)`.
+ * @property uses
+ * @type {Array}
+ */
+ Matter.uses = [];
+
+ /**
+ * The plugins that have been installed through `Matter.Plugin.install`. Read only.
+ * @property used
+ * @readOnly
+ * @type {Array}
+ */
+ Matter.used = [];
+
+ /**
+ * Installs the given plugins on the `Matter` namespace.
+ * This is a short-hand for `Plugin.use`, see it for more information.
+ * Call this function once at the start of your code, with all of the plugins you wish to install as arguments.
+ * Avoid calling this function multiple times unless you intend to manually control installation order.
+ * @method use
+ * @param ...plugin {Function} The plugin(s) to install on `base` (multi-argument).
+ */
+ Matter.use = function() {
+ Plugin.use(Matter, Array.prototype.slice.call(arguments));
+ };
+
+ /**
+ * Chains a function to excute before the original function on the given `path` relative to `Matter`.
+ * See also docs for `Common.chain`.
+ * @method before
+ * @param {string} path The path relative to `Matter`
+ * @param {function} func The function to chain before the original
+ * @return {function} The chained function that replaced the original
+ */
+ Matter.before = function(path, func) {
+ path = path.replace(/^Matter./, '');
+ return Common.chainPathBefore(Matter, path, func);
+ };
+
+ /**
+ * Chains a function to excute after the original function on the given `path` relative to `Matter`.
+ * See also docs for `Common.chain`.
+ * @method after
+ * @param {string} path The path relative to `Matter`
+ * @param {function} func The function to chain after the original
+ * @return {function} The chained function that replaced the original
+ */
+ Matter.after = function(path, func) {
+ path = path.replace(/^Matter./, '');
+ return Common.chainPathAfter(Matter, path, func);
+ };
+
+})();
+
+
+/***/ }),
+/* 24 */
+/***/ (function(module, exports, __webpack_require__) {
+
+/**
+* The `Matter.Composites` module contains factory methods for creating composite bodies
+* with commonly used configurations (such as stacks and chains).
+*
+* See the included usage [examples](https://github.com/liabru/matter-js/tree/master/examples).
+*
+* @class Composites
+*/
+
+var Composites = {};
+
+module.exports = Composites;
+
+var Composite = __webpack_require__(5);
+var Constraint = __webpack_require__(8);
+var Common = __webpack_require__(0);
+var Body = __webpack_require__(6);
+var Bodies = __webpack_require__(11);
+var deprecated = Common.deprecated;
+
+(function() {
+
+ /**
+ * Create a new composite containing bodies created in the callback in a grid arrangement.
+ * This function uses the body's bounds to prevent overlaps.
+ * @method stack
+ * @param {number} xx
+ * @param {number} yy
+ * @param {number} columns
+ * @param {number} rows
+ * @param {number} columnGap
+ * @param {number} rowGap
+ * @param {function} callback
+ * @return {composite} A new composite containing objects created in the callback
+ */
+ Composites.stack = function(xx, yy, columns, rows, columnGap, rowGap, callback) {
+ var stack = Composite.create({ label: 'Stack' }),
+ x = xx,
+ y = yy,
+ lastBody,
+ i = 0;
+
+ for (var row = 0; row < rows; row++) {
+ var maxHeight = 0;
+
+ for (var column = 0; column < columns; column++) {
+ var body = callback(x, y, column, row, lastBody, i);
+
+ if (body) {
+ var bodyHeight = body.bounds.max.y - body.bounds.min.y,
+ bodyWidth = body.bounds.max.x - body.bounds.min.x;
+
+ if (bodyHeight > maxHeight)
+ maxHeight = bodyHeight;
+
+ Body.translate(body, { x: bodyWidth * 0.5, y: bodyHeight * 0.5 });
+
+ x = body.bounds.max.x + columnGap;
+
+ Composite.addBody(stack, body);
+
+ lastBody = body;
+ i += 1;
+ } else {
+ x += columnGap;
+ }
+ }
+
+ y += maxHeight + rowGap;
+ x = xx;
+ }
+
+ return stack;
+ };
+
+ /**
+ * Chains all bodies in the given composite together using constraints.
+ * @method chain
+ * @param {composite} composite
+ * @param {number} xOffsetA
+ * @param {number} yOffsetA
+ * @param {number} xOffsetB
+ * @param {number} yOffsetB
+ * @param {object} options
+ * @return {composite} A new composite containing objects chained together with constraints
+ */
+ Composites.chain = function(composite, xOffsetA, yOffsetA, xOffsetB, yOffsetB, options) {
+ var bodies = composite.bodies;
+
+ for (var i = 1; i < bodies.length; i++) {
+ var bodyA = bodies[i - 1],
+ bodyB = bodies[i],
+ bodyAHeight = bodyA.bounds.max.y - bodyA.bounds.min.y,
+ bodyAWidth = bodyA.bounds.max.x - bodyA.bounds.min.x,
+ bodyBHeight = bodyB.bounds.max.y - bodyB.bounds.min.y,
+ bodyBWidth = bodyB.bounds.max.x - bodyB.bounds.min.x;
+
+ var defaults = {
+ bodyA: bodyA,
+ pointA: { x: bodyAWidth * xOffsetA, y: bodyAHeight * yOffsetA },
+ bodyB: bodyB,
+ pointB: { x: bodyBWidth * xOffsetB, y: bodyBHeight * yOffsetB }
+ };
+
+ var constraint = Common.extend(defaults, options);
+
+ Composite.addConstraint(composite, Constraint.create(constraint));
+ }
+
+ composite.label += ' Chain';
+
+ return composite;
+ };
+
+ /**
+ * Connects bodies in the composite with constraints in a grid pattern, with optional cross braces.
+ * @method mesh
+ * @param {composite} composite
+ * @param {number} columns
+ * @param {number} rows
+ * @param {boolean} crossBrace
+ * @param {object} options
+ * @return {composite} The composite containing objects meshed together with constraints
+ */
+ Composites.mesh = function(composite, columns, rows, crossBrace, options) {
+ var bodies = composite.bodies,
+ row,
+ col,
+ bodyA,
+ bodyB,
+ bodyC;
+
+ for (row = 0; row < rows; row++) {
+ for (col = 1; col < columns; col++) {
+ bodyA = bodies[(col - 1) + (row * columns)];
+ bodyB = bodies[col + (row * columns)];
+ Composite.addConstraint(composite, Constraint.create(Common.extend({ bodyA: bodyA, bodyB: bodyB }, options)));
+ }
+
+ if (row > 0) {
+ for (col = 0; col < columns; col++) {
+ bodyA = bodies[col + ((row - 1) * columns)];
+ bodyB = bodies[col + (row * columns)];
+ Composite.addConstraint(composite, Constraint.create(Common.extend({ bodyA: bodyA, bodyB: bodyB }, options)));
+
+ if (crossBrace && col > 0) {
+ bodyC = bodies[(col - 1) + ((row - 1) * columns)];
+ Composite.addConstraint(composite, Constraint.create(Common.extend({ bodyA: bodyC, bodyB: bodyB }, options)));
+ }
+
+ if (crossBrace && col < columns - 1) {
+ bodyC = bodies[(col + 1) + ((row - 1) * columns)];
+ Composite.addConstraint(composite, Constraint.create(Common.extend({ bodyA: bodyC, bodyB: bodyB }, options)));
+ }
+ }
+ }
+ }
+
+ composite.label += ' Mesh';
+
+ return composite;
+ };
+
+ /**
+ * Create a new composite containing bodies created in the callback in a pyramid arrangement.
+ * This function uses the body's bounds to prevent overlaps.
+ * @method pyramid
+ * @param {number} xx
+ * @param {number} yy
+ * @param {number} columns
+ * @param {number} rows
+ * @param {number} columnGap
+ * @param {number} rowGap
+ * @param {function} callback
+ * @return {composite} A new composite containing objects created in the callback
+ */
+ Composites.pyramid = function(xx, yy, columns, rows, columnGap, rowGap, callback) {
+ return Composites.stack(xx, yy, columns, rows, columnGap, rowGap, function(x, y, column, row, lastBody, i) {
+ var actualRows = Math.min(rows, Math.ceil(columns / 2)),
+ lastBodyWidth = lastBody ? lastBody.bounds.max.x - lastBody.bounds.min.x : 0;
+
+ if (row > actualRows)
+ return;
+
+ // reverse row order
+ row = actualRows - row;
+
+ var start = row,
+ end = columns - 1 - row;
+
+ if (column < start || column > end)
+ return;
+
+ // retroactively fix the first body's position, since width was unknown
+ if (i === 1) {
+ Body.translate(lastBody, { x: (column + (columns % 2 === 1 ? 1 : -1)) * lastBodyWidth, y: 0 });
+ }
+
+ var xOffset = lastBody ? column * lastBodyWidth : 0;
+
+ return callback(xx + xOffset + column * columnGap, y, column, row, lastBody, i);
+ });
+ };
+
+ /**
+ * This has now moved to the [newtonsCradle example](https://github.com/liabru/matter-js/blob/master/examples/newtonsCradle.js), follow that instead as this function is deprecated here.
+ * @deprecated moved to newtonsCradle example
+ * @method newtonsCradle
+ * @param {number} xx
+ * @param {number} yy
+ * @param {number} number
+ * @param {number} size
+ * @param {number} length
+ * @return {composite} A new composite newtonsCradle body
+ */
+ Composites.newtonsCradle = function(xx, yy, number, size, length) {
+ var newtonsCradle = Composite.create({ label: 'Newtons Cradle' });
+
+ for (var i = 0; i < number; i++) {
+ var separation = 1.9,
+ circle = Bodies.circle(xx + i * (size * separation), yy + length, size,
+ { inertia: Infinity, restitution: 1, friction: 0, frictionAir: 0.0001, slop: 1 }),
+ constraint = Constraint.create({ pointA: { x: xx + i * (size * separation), y: yy }, bodyB: circle });
+
+ Composite.addBody(newtonsCradle, circle);
+ Composite.addConstraint(newtonsCradle, constraint);
+ }
+
+ return newtonsCradle;
+ };
+
+ deprecated(Composites, 'newtonsCradle', 'Composites.newtonsCradle ➤ moved to newtonsCradle example');
+
+ /**
+ * This has now moved to the [car example](https://github.com/liabru/matter-js/blob/master/examples/car.js), follow that instead as this function is deprecated here.
+ * @deprecated moved to car example
+ * @method car
+ * @param {number} xx
+ * @param {number} yy
+ * @param {number} width
+ * @param {number} height
+ * @param {number} wheelSize
+ * @return {composite} A new composite car body
+ */
+ Composites.car = function(xx, yy, width, height, wheelSize) {
+ var group = Body.nextGroup(true),
+ wheelBase = 20,
+ wheelAOffset = -width * 0.5 + wheelBase,
+ wheelBOffset = width * 0.5 - wheelBase,
+ wheelYOffset = 0;
+
+ var car = Composite.create({ label: 'Car' }),
+ body = Bodies.rectangle(xx, yy, width, height, {
+ collisionFilter: {
+ group: group
+ },
+ chamfer: {
+ radius: height * 0.5
+ },
+ density: 0.0002
+ });
+
+ var wheelA = Bodies.circle(xx + wheelAOffset, yy + wheelYOffset, wheelSize, {
+ collisionFilter: {
+ group: group
+ },
+ friction: 0.8
+ });
+
+ var wheelB = Bodies.circle(xx + wheelBOffset, yy + wheelYOffset, wheelSize, {
+ collisionFilter: {
+ group: group
+ },
+ friction: 0.8
+ });
+
+ var axelA = Constraint.create({
+ bodyB: body,
+ pointB: { x: wheelAOffset, y: wheelYOffset },
+ bodyA: wheelA,
+ stiffness: 1,
+ length: 0
+ });
+
+ var axelB = Constraint.create({
+ bodyB: body,
+ pointB: { x: wheelBOffset, y: wheelYOffset },
+ bodyA: wheelB,
+ stiffness: 1,
+ length: 0
+ });
+
+ Composite.addBody(car, body);
+ Composite.addBody(car, wheelA);
+ Composite.addBody(car, wheelB);
+ Composite.addConstraint(car, axelA);
+ Composite.addConstraint(car, axelB);
+
+ return car;
+ };
+
+ deprecated(Composites, 'car', 'Composites.car ➤ moved to car example');
+
+ /**
+ * This has now moved to the [softBody example](https://github.com/liabru/matter-js/blob/master/examples/softBody.js)
+ * and the [cloth example](https://github.com/liabru/matter-js/blob/master/examples/cloth.js), follow those instead as this function is deprecated here.
+ * @deprecated moved to softBody and cloth examples
+ * @method softBody
+ * @param {number} xx
+ * @param {number} yy
+ * @param {number} columns
+ * @param {number} rows
+ * @param {number} columnGap
+ * @param {number} rowGap
+ * @param {boolean} crossBrace
+ * @param {number} particleRadius
+ * @param {} particleOptions
+ * @param {} constraintOptions
+ * @return {composite} A new composite softBody
+ */
+ Composites.softBody = function(xx, yy, columns, rows, columnGap, rowGap, crossBrace, particleRadius, particleOptions, constraintOptions) {
+ particleOptions = Common.extend({ inertia: Infinity }, particleOptions);
+ constraintOptions = Common.extend({ stiffness: 0.2, render: { type: 'line', anchors: false } }, constraintOptions);
+
+ var softBody = Composites.stack(xx, yy, columns, rows, columnGap, rowGap, function(x, y) {
+ return Bodies.circle(x, y, particleRadius, particleOptions);
+ });
+
+ Composites.mesh(softBody, columns, rows, crossBrace, constraintOptions);
+
+ softBody.label = 'Soft Body';
+
+ return softBody;
+ };
+
+ deprecated(Composites, 'softBody', 'Composites.softBody ➤ moved to softBody and cloth examples');
+})();
+
+
+/***/ }),
+/* 25 */
+/***/ (function(module, exports, __webpack_require__) {
+
+/**
+* The `Matter.MouseConstraint` module contains methods for creating mouse constraints.
+* Mouse constraints are used for allowing user interaction, providing the ability to move bodies via the mouse or touch.
+*
+* See the included usage [examples](https://github.com/liabru/matter-js/tree/master/examples).
+*
+* @class MouseConstraint
+*/
+
+var MouseConstraint = {};
+
+module.exports = MouseConstraint;
+
+var Vertices = __webpack_require__(3);
+var Sleeping = __webpack_require__(7);
+var Mouse = __webpack_require__(12);
+var Events = __webpack_require__(4);
+var Detector = __webpack_require__(13);
+var Constraint = __webpack_require__(8);
+var Composite = __webpack_require__(5);
+var Common = __webpack_require__(0);
+var Bounds = __webpack_require__(1);
+
+(function() {
+
+ /**
+ * Creates a new mouse constraint.
+ * All properties have default values, and many are pre-calculated automatically based on other properties.
+ * See the properties section below for detailed information on what you can pass via the `options` object.
+ * @method create
+ * @param {engine} engine
+ * @param {} options
+ * @return {MouseConstraint} A new MouseConstraint
+ */
+ MouseConstraint.create = function(engine, options) {
+ var mouse = (engine ? engine.mouse : null) || (options ? options.mouse : null);
+
+ if (!mouse) {
+ if (engine && engine.render && engine.render.canvas) {
+ mouse = Mouse.create(engine.render.canvas);
+ } else if (options && options.element) {
+ mouse = Mouse.create(options.element);
+ } else {
+ mouse = Mouse.create();
+ Common.warn('MouseConstraint.create: options.mouse was undefined, options.element was undefined, may not function as expected');
+ }
+ }
+
+ var constraint = Constraint.create({
+ label: 'Mouse Constraint',
+ pointA: mouse.position,
+ pointB: { x: 0, y: 0 },
+ length: 0.01,
+ stiffness: 0.1,
+ angularStiffness: 1,
+ render: {
+ strokeStyle: '#90EE90',
+ lineWidth: 3
+ }
+ });
+
+ var defaults = {
+ type: 'mouseConstraint',
+ mouse: mouse,
+ element: null,
+ body: null,
+ constraint: constraint,
+ collisionFilter: {
+ category: 0x0001,
+ mask: 0xFFFFFFFF,
+ group: 0
+ }
+ };
+
+ var mouseConstraint = Common.extend(defaults, options);
+
+ Events.on(engine, 'beforeUpdate', function() {
+ var allBodies = Composite.allBodies(engine.world);
+ MouseConstraint.update(mouseConstraint, allBodies);
+ MouseConstraint._triggerEvents(mouseConstraint);
+ });
+
+ return mouseConstraint;
+ };
+
+ /**
+ * Updates the given mouse constraint.
+ * @private
+ * @method update
+ * @param {MouseConstraint} mouseConstraint
+ * @param {body[]} bodies
+ */
+ MouseConstraint.update = function(mouseConstraint, bodies) {
+ var mouse = mouseConstraint.mouse,
+ constraint = mouseConstraint.constraint,
+ body = mouseConstraint.body;
+
+ if (mouse.button === 0) {
+ if (!constraint.bodyB) {
+ for (var i = 0; i < bodies.length; i++) {
+ body = bodies[i];
+ if (Bounds.contains(body.bounds, mouse.position)
+ && Detector.canCollide(body.collisionFilter, mouseConstraint.collisionFilter)) {
+ for (var j = body.parts.length > 1 ? 1 : 0; j < body.parts.length; j++) {
+ var part = body.parts[j];
+ if (Vertices.contains(part.vertices, mouse.position)) {
+ constraint.pointA = mouse.position;
+ constraint.bodyB = mouseConstraint.body = body;
+ constraint.pointB = { x: mouse.position.x - body.position.x, y: mouse.position.y - body.position.y };
+ constraint.angleB = body.angle;
+
+ Sleeping.set(body, false);
+ Events.trigger(mouseConstraint, 'startdrag', { mouse: mouse, body: body });
+
+ break;
+ }
+ }
+ }
+ }
+ } else {
+ Sleeping.set(constraint.bodyB, false);
+ constraint.pointA = mouse.position;
+ }
+ } else {
+ constraint.bodyB = mouseConstraint.body = null;
+ constraint.pointB = null;
+
+ if (body)
+ Events.trigger(mouseConstraint, 'enddrag', { mouse: mouse, body: body });
+ }
+ };
+
+ /**
+ * Triggers mouse constraint events.
+ * @method _triggerEvents
+ * @private
+ * @param {mouse} mouseConstraint
+ */
+ MouseConstraint._triggerEvents = function(mouseConstraint) {
+ var mouse = mouseConstraint.mouse,
+ mouseEvents = mouse.sourceEvents;
+
+ if (mouseEvents.mousemove)
+ Events.trigger(mouseConstraint, 'mousemove', { mouse: mouse });
+
+ if (mouseEvents.mousedown)
+ Events.trigger(mouseConstraint, 'mousedown', { mouse: mouse });
+
+ if (mouseEvents.mouseup)
+ Events.trigger(mouseConstraint, 'mouseup', { mouse: mouse });
+
+ // reset the mouse state ready for the next step
+ Mouse.clearSourceEvents(mouse);
+ };
+
+ /*
+ *
+ * Events Documentation
+ *
+ */
+
+ /**
+ * Fired when the mouse has moved (or a touch moves) during the last step
+ *
+ * @event mousemove
+ * @param {} event An event object
+ * @param {mouse} event.mouse The engine's mouse instance
+ * @param {} event.source The source object of the event
+ * @param {} event.name The name of the event
+ */
+
+ /**
+ * Fired when the mouse is down (or a touch has started) during the last step
+ *
+ * @event mousedown
+ * @param {} event An event object
+ * @param {mouse} event.mouse The engine's mouse instance
+ * @param {} event.source The source object of the event
+ * @param {} event.name The name of the event
+ */
+
+ /**
+ * Fired when the mouse is up (or a touch has ended) during the last step
+ *
+ * @event mouseup
+ * @param {} event An event object
+ * @param {mouse} event.mouse The engine's mouse instance
+ * @param {} event.source The source object of the event
+ * @param {} event.name The name of the event
+ */
+
+ /**
+ * Fired when the user starts dragging a body
+ *
+ * @event startdrag
+ * @param {} event An event object
+ * @param {mouse} event.mouse The engine's mouse instance
+ * @param {body} event.body The body being dragged
+ * @param {} event.source The source object of the event
+ * @param {} event.name The name of the event
+ */
+
+ /**
+ * Fired when the user ends dragging a body
+ *
+ * @event enddrag
+ * @param {} event An event object
+ * @param {mouse} event.mouse The engine's mouse instance
+ * @param {body} event.body The body that has stopped being dragged
+ * @param {} event.source The source object of the event
+ * @param {} event.name The name of the event
+ */
+
+ /*
+ *
+ * Properties Documentation
+ *
+ */
+
+ /**
+ * A `String` denoting the type of object.
+ *
+ * @property type
+ * @type string
+ * @default "constraint"
+ * @readOnly
+ */
+
+ /**
+ * The `Mouse` instance in use. If not supplied in `MouseConstraint.create`, one will be created.
+ *
+ * @property mouse
+ * @type mouse
+ * @default mouse
+ */
+
+ /**
+ * The `Body` that is currently being moved by the user, or `null` if no body.
+ *
+ * @property body
+ * @type body
+ * @default null
+ */
+
+ /**
+ * The `Constraint` object that is used to move the body during interaction.
+ *
+ * @property constraint
+ * @type constraint
+ */
+
+ /**
+ * An `Object` that specifies the collision filter properties.
+ * The collision filter allows the user to define which types of body this mouse constraint can interact with.
+ * See `body.collisionFilter` for more information.
+ *
+ * @property collisionFilter
+ * @type object
+ */
+
+})();
+
+
+/***/ }),
+/* 26 */
+/***/ (function(module, exports, __webpack_require__) {
+
+/**
+* The `Matter.Query` module contains methods for performing collision queries.
+*
+* See the included usage [examples](https://github.com/liabru/matter-js/tree/master/examples).
+*
+* @class Query
+*/
+
+var Query = {};
+
+module.exports = Query;
+
+var Vector = __webpack_require__(2);
+var SAT = __webpack_require__(14);
+var Bounds = __webpack_require__(1);
+var Bodies = __webpack_require__(11);
+var Vertices = __webpack_require__(3);
+
+(function() {
+
+ /**
+ * Returns a list of collisions between `body` and `bodies`.
+ * @method collides
+ * @param {body} body
+ * @param {body[]} bodies
+ * @return {object[]} Collisions
+ */
+ Query.collides = function(body, bodies) {
+ var collisions = [];
+
+ for (var i = 0; i < bodies.length; i++) {
+ var bodyA = bodies[i];
+
+ if (Bounds.overlaps(bodyA.bounds, body.bounds)) {
+ for (var j = bodyA.parts.length === 1 ? 0 : 1; j < bodyA.parts.length; j++) {
+ var part = bodyA.parts[j];
+
+ if (Bounds.overlaps(part.bounds, body.bounds)) {
+ var collision = SAT.collides(part, body);
+
+ if (collision.collided) {
+ collisions.push(collision);
+ break;
+ }
+ }
+ }
+ }
+ }
+
+ return collisions;
+ };
+
+ /**
+ * Casts a ray segment against a set of bodies and returns all collisions, ray width is optional. Intersection points are not provided.
+ * @method ray
+ * @param {body[]} bodies
+ * @param {vector} startPoint
+ * @param {vector} endPoint
+ * @param {number} [rayWidth]
+ * @return {object[]} Collisions
+ */
+ Query.ray = function(bodies, startPoint, endPoint, rayWidth) {
+ rayWidth = rayWidth || 1e-100;
+
+ var rayAngle = Vector.angle(startPoint, endPoint),
+ rayLength = Vector.magnitude(Vector.sub(startPoint, endPoint)),
+ rayX = (endPoint.x + startPoint.x) * 0.5,
+ rayY = (endPoint.y + startPoint.y) * 0.5,
+ ray = Bodies.rectangle(rayX, rayY, rayLength, rayWidth, { angle: rayAngle }),
+ collisions = Query.collides(ray, bodies);
+
+ for (var i = 0; i < collisions.length; i += 1) {
+ var collision = collisions[i];
+ collision.body = collision.bodyB = collision.bodyA;
+ }
+
+ return collisions;
+ };
+
+ /**
+ * Returns all bodies whose bounds are inside (or outside if set) the given set of bounds, from the given set of bodies.
+ * @method region
+ * @param {body[]} bodies
+ * @param {bounds} bounds
+ * @param {bool} [outside=false]
+ * @return {body[]} The bodies matching the query
+ */
+ Query.region = function(bodies, bounds, outside) {
+ var result = [];
+
+ for (var i = 0; i < bodies.length; i++) {
+ var body = bodies[i],
+ overlaps = Bounds.overlaps(body.bounds, bounds);
+ if ((overlaps && !outside) || (!overlaps && outside))
+ result.push(body);
+ }
+
+ return result;
+ };
+
+ /**
+ * Returns all bodies whose vertices contain the given point, from the given set of bodies.
+ * @method point
+ * @param {body[]} bodies
+ * @param {vector} point
+ * @return {body[]} The bodies matching the query
+ */
+ Query.point = function(bodies, point) {
+ var result = [];
+
+ for (var i = 0; i < bodies.length; i++) {
+ var body = bodies[i];
+
+ if (Bounds.contains(body.bounds, point)) {
+ for (var j = body.parts.length === 1 ? 0 : 1; j < body.parts.length; j++) {
+ var part = body.parts[j];
+
+ if (Bounds.contains(part.bounds, point)
+ && Vertices.contains(part.vertices, point)) {
+ result.push(body);
+ break;
+ }
+ }
+ }
+ }
+
+ return result;
+ };
+
+})();
+
+
+/***/ }),
+/* 27 */
+/***/ (function(module, exports, __webpack_require__) {
+
+/**
+* The `Matter.Runner` module is an optional utility which provides a game loop,
+* that handles continuously updating a `Matter.Engine` for you within a browser.
+* It is intended for development and debugging purposes, but may also be suitable for simple games.
+* If you are using your own game loop instead, then you do not need the `Matter.Runner` module.
+* Instead just call `Engine.update(engine, delta)` in your own loop.
+*
+* See the included usage [examples](https://github.com/liabru/matter-js/tree/master/examples).
+*
+* @class Runner
+*/
+
+var Runner = {};
+
+module.exports = Runner;
+
+var Events = __webpack_require__(4);
+var Engine = __webpack_require__(18);
+var Common = __webpack_require__(0);
(function() {
@@ -9867,495 +9919,537 @@ var Vector = _dereq_('../geometry/Vector');
if (typeof window !== 'undefined') {
_requestAnimationFrame = window.requestAnimationFrame || window.webkitRequestAnimationFrame
- || window.mozRequestAnimationFrame || window.msRequestAnimationFrame
- || function(callback){ window.setTimeout(function() { callback(Common.now()); }, 1000 / 60); };
+ || window.mozRequestAnimationFrame || window.msRequestAnimationFrame;
_cancelAnimationFrame = window.cancelAnimationFrame || window.mozCancelAnimationFrame
|| window.webkitCancelAnimationFrame || window.msCancelAnimationFrame;
}
-
+
+ if (!_requestAnimationFrame) {
+ var _frameTimeout;
+
+ _requestAnimationFrame = function(callback){
+ _frameTimeout = setTimeout(function() {
+ callback(Common.now());
+ }, 1000 / 60);
+ };
+
+ _cancelAnimationFrame = function() {
+ clearTimeout(_frameTimeout);
+ };
+ }
+
/**
- * Creates a new Pixi.js WebGL renderer
+ * Creates a new Runner. The options parameter is an object that specifies any properties you wish to override the defaults.
* @method create
- * @param {object} options
- * @return {RenderPixi} A new renderer
- * @deprecated
+ * @param {} options
*/
- RenderPixi.create = function(options) {
- Common.warn('RenderPixi.create: Matter.RenderPixi is deprecated (see docs)');
-
+ Runner.create = function(options) {
var defaults = {
- controller: RenderPixi,
- engine: null,
- element: null,
+ fps: 60,
+ correction: 1,
+ deltaSampleSize: 60,
+ counterTimestamp: 0,
+ frameCounter: 0,
+ deltaHistory: [],
+ timePrev: null,
+ timeScalePrev: 1,
frameRequestId: null,
- canvas: null,
- renderer: null,
- container: null,
- spriteContainer: null,
- pixiOptions: null,
- options: {
- width: 800,
- height: 600,
- background: '#fafafa',
- wireframeBackground: '#222',
- hasBounds: false,
- enabled: true,
- wireframes: true,
- showSleeping: true,
- showDebug: false,
- showBroadphase: false,
- showBounds: false,
- showVelocity: false,
- showCollisions: false,
- showAxes: false,
- showPositions: false,
- showAngleIndicator: false,
- showIds: false,
- showShadows: false
- }
+ isFixed: false,
+ enabled: true
};
- var render = Common.extend(defaults, options),
- transparent = !render.options.wireframes && render.options.background === 'transparent';
+ var runner = Common.extend(defaults, options);
- // init pixi
- render.pixiOptions = render.pixiOptions || {
- view: render.canvas,
- transparent: transparent,
- antialias: true,
- backgroundColor: options.background
- };
+ runner.delta = runner.delta || 1000 / runner.fps;
+ runner.deltaMin = runner.deltaMin || 1000 / runner.fps;
+ runner.deltaMax = runner.deltaMax || 1000 / (runner.fps * 0.5);
+ runner.fps = 1000 / runner.delta;
- render.mouse = options.mouse;
- render.engine = options.engine;
- render.renderer = render.renderer || new PIXI.WebGLRenderer(render.options.width, render.options.height, render.pixiOptions);
- render.container = render.container || new PIXI.Container();
- render.spriteContainer = render.spriteContainer || new PIXI.Container();
- render.canvas = render.canvas || render.renderer.view;
- render.bounds = render.bounds || {
- min: {
- x: 0,
- y: 0
- },
- max: {
- x: render.options.width,
- y: render.options.height
- }
- };
-
- // event listeners
- Events.on(render.engine, 'beforeUpdate', function() {
- RenderPixi.clear(render);
- });
-
- // caches
- render.textures = {};
- render.sprites = {};
- render.primitives = {};
-
- // use a sprite batch for performance
- render.container.addChild(render.spriteContainer);
-
- // insert canvas
- if (Common.isElement(render.element)) {
- render.element.appendChild(render.canvas);
- } else {
- Common.warn('No "render.element" passed, "render.canvas" was not inserted into document.');
- }
-
- // prevent menus on canvas
- render.canvas.oncontextmenu = function() { return false; };
- render.canvas.onselectstart = function() { return false; };
-
- return render;
+ return runner;
};
/**
- * Continuously updates the render canvas on the `requestAnimationFrame` event.
+ * Continuously ticks a `Matter.Engine` by calling `Runner.tick` on the `requestAnimationFrame` event.
* @method run
- * @param {render} render
- * @deprecated
+ * @param {engine} engine
*/
- RenderPixi.run = function(render) {
- (function loop(time){
- render.frameRequestId = _requestAnimationFrame(loop);
- RenderPixi.world(render);
+ Runner.run = function(runner, engine) {
+ // create runner if engine is first argument
+ if (typeof runner.positionIterations !== 'undefined') {
+ engine = runner;
+ runner = Runner.create();
+ }
+
+ (function render(time){
+ runner.frameRequestId = _requestAnimationFrame(render);
+
+ if (time && runner.enabled) {
+ Runner.tick(runner, engine, time);
+ }
})();
+
+ return runner;
};
/**
- * Ends execution of `Render.run` on the given `render`, by canceling the animation frame request event loop.
+ * A game loop utility that updates the engine and renderer by one step (a 'tick').
+ * Features delta smoothing, time correction and fixed or dynamic timing.
+ * Consider just `Engine.update(engine, delta)` if you're using your own loop.
+ * @method tick
+ * @param {runner} runner
+ * @param {engine} engine
+ * @param {number} time
+ */
+ Runner.tick = function(runner, engine, time) {
+ var timing = engine.timing,
+ correction = 1,
+ delta;
+
+ // create an event object
+ var event = {
+ timestamp: timing.timestamp
+ };
+
+ Events.trigger(runner, 'beforeTick', event);
+
+ if (runner.isFixed) {
+ // fixed timestep
+ delta = runner.delta;
+ } else {
+ // dynamic timestep based on wall clock between calls
+ delta = (time - runner.timePrev) || runner.delta;
+ runner.timePrev = time;
+
+ // optimistically filter delta over a few frames, to improve stability
+ runner.deltaHistory.push(delta);
+ runner.deltaHistory = runner.deltaHistory.slice(-runner.deltaSampleSize);
+ delta = Math.min.apply(null, runner.deltaHistory);
+
+ // limit delta
+ delta = delta < runner.deltaMin ? runner.deltaMin : delta;
+ delta = delta > runner.deltaMax ? runner.deltaMax : delta;
+
+ // correction for delta
+ correction = delta / runner.delta;
+
+ // update engine timing object
+ runner.delta = delta;
+ }
+
+ // time correction for time scaling
+ if (runner.timeScalePrev !== 0)
+ correction *= timing.timeScale / runner.timeScalePrev;
+
+ if (timing.timeScale === 0)
+ correction = 0;
+
+ runner.timeScalePrev = timing.timeScale;
+ runner.correction = correction;
+
+ // fps counter
+ runner.frameCounter += 1;
+ if (time - runner.counterTimestamp >= 1000) {
+ runner.fps = runner.frameCounter * ((time - runner.counterTimestamp) / 1000);
+ runner.counterTimestamp = time;
+ runner.frameCounter = 0;
+ }
+
+ Events.trigger(runner, 'tick', event);
+
+ // update
+ Events.trigger(runner, 'beforeUpdate', event);
+ Engine.update(engine, delta, correction);
+ Events.trigger(runner, 'afterUpdate', event);
+
+ Events.trigger(runner, 'afterTick', event);
+ };
+
+ /**
+ * Ends execution of `Runner.run` on the given `runner`, by canceling the animation frame request event loop.
+ * If you wish to only temporarily pause the engine, see `engine.enabled` instead.
* @method stop
- * @param {render} render
- * @deprecated
+ * @param {runner} runner
*/
- RenderPixi.stop = function(render) {
- _cancelAnimationFrame(render.frameRequestId);
+ Runner.stop = function(runner) {
+ _cancelAnimationFrame(runner.frameRequestId);
};
/**
- * Clears the scene graph
- * @method clear
- * @param {RenderPixi} render
- * @deprecated
- */
- RenderPixi.clear = function(render) {
- var container = render.container,
- spriteContainer = render.spriteContainer;
-
- // clear stage container
- while (container.children[0]) {
- container.removeChild(container.children[0]);
- }
-
- // clear sprite batch
- while (spriteContainer.children[0]) {
- spriteContainer.removeChild(spriteContainer.children[0]);
- }
-
- var bgSprite = render.sprites['bg-0'];
-
- // clear caches
- render.textures = {};
- render.sprites = {};
- render.primitives = {};
-
- // set background sprite
- render.sprites['bg-0'] = bgSprite;
- if (bgSprite)
- container.addChildAt(bgSprite, 0);
-
- // add sprite batch back into container
- render.container.addChild(render.spriteContainer);
-
- // reset background state
- render.currentBackground = null;
-
- // reset bounds transforms
- container.scale.set(1, 1);
- container.position.set(0, 0);
- };
-
- /**
- * Sets the background of the canvas
- * @method setBackground
- * @param {RenderPixi} render
- * @param {string} background
- * @deprecated
- */
- RenderPixi.setBackground = function(render, background) {
- if (render.currentBackground !== background) {
- var isColor = background.indexOf && background.indexOf('#') !== -1,
- bgSprite = render.sprites['bg-0'];
-
- if (isColor) {
- // if solid background color
- var color = Common.colorToNumber(background);
- render.renderer.backgroundColor = color;
-
- // remove background sprite if existing
- if (bgSprite)
- render.container.removeChild(bgSprite);
- } else {
- // initialise background sprite if needed
- if (!bgSprite) {
- var texture = _getTexture(render, background);
-
- bgSprite = render.sprites['bg-0'] = new PIXI.Sprite(texture);
- bgSprite.position.x = 0;
- bgSprite.position.y = 0;
- render.container.addChildAt(bgSprite, 0);
- }
- }
-
- render.currentBackground = background;
- }
- };
-
- /**
- * Description
- * @method world
+ * Alias for `Runner.run`.
+ * @method start
+ * @param {runner} runner
* @param {engine} engine
- * @deprecated
*/
- RenderPixi.world = function(render) {
- var engine = render.engine,
- world = engine.world,
- renderer = render.renderer,
- container = render.container,
- options = render.options,
- bodies = Composite.allBodies(world),
- allConstraints = Composite.allConstraints(world),
- constraints = [],
- i;
-
- if (options.wireframes) {
- RenderPixi.setBackground(render, options.wireframeBackground);
- } else {
- RenderPixi.setBackground(render, options.background);
- }
-
- // handle bounds
- var boundsWidth = render.bounds.max.x - render.bounds.min.x,
- boundsHeight = render.bounds.max.y - render.bounds.min.y,
- boundsScaleX = boundsWidth / render.options.width,
- boundsScaleY = boundsHeight / render.options.height;
-
- if (options.hasBounds) {
- // Hide bodies that are not in view
- for (i = 0; i < bodies.length; i++) {
- var body = bodies[i];
- body.render.sprite.visible = Bounds.overlaps(body.bounds, render.bounds);
- }
-
- // filter out constraints that are not in view
- for (i = 0; i < allConstraints.length; i++) {
- var constraint = allConstraints[i],
- bodyA = constraint.bodyA,
- bodyB = constraint.bodyB,
- pointAWorld = constraint.pointA,
- pointBWorld = constraint.pointB;
-
- if (bodyA) pointAWorld = Vector.add(bodyA.position, constraint.pointA);
- if (bodyB) pointBWorld = Vector.add(bodyB.position, constraint.pointB);
-
- if (!pointAWorld || !pointBWorld)
- continue;
-
- if (Bounds.contains(render.bounds, pointAWorld) || Bounds.contains(render.bounds, pointBWorld))
- constraints.push(constraint);
- }
-
- // transform the view
- container.scale.set(1 / boundsScaleX, 1 / boundsScaleY);
- container.position.set(-render.bounds.min.x * (1 / boundsScaleX), -render.bounds.min.y * (1 / boundsScaleY));
- } else {
- constraints = allConstraints;
- }
-
- for (i = 0; i < bodies.length; i++)
- RenderPixi.body(render, bodies[i]);
-
- for (i = 0; i < constraints.length; i++)
- RenderPixi.constraint(render, constraints[i]);
-
- renderer.render(container);
+ Runner.start = function(runner, engine) {
+ Runner.run(runner, engine);
};
+ /*
+ *
+ * Events Documentation
+ *
+ */
/**
- * Description
- * @method constraint
- * @param {engine} engine
- * @param {constraint} constraint
- * @deprecated
- */
- RenderPixi.constraint = function(render, constraint) {
- var engine = render.engine,
- bodyA = constraint.bodyA,
- bodyB = constraint.bodyB,
- pointA = constraint.pointA,
- pointB = constraint.pointB,
- container = render.container,
- constraintRender = constraint.render,
- primitiveId = 'c-' + constraint.id,
- primitive = render.primitives[primitiveId];
-
- // initialise constraint primitive if not existing
- if (!primitive)
- primitive = render.primitives[primitiveId] = new PIXI.Graphics();
-
- // don't render if constraint does not have two end points
- if (!constraintRender.visible || !constraint.pointA || !constraint.pointB) {
- primitive.clear();
- return;
- }
-
- // add to scene graph if not already there
- if (Common.indexOf(container.children, primitive) === -1)
- container.addChild(primitive);
-
- // render the constraint on every update, since they can change dynamically
- primitive.clear();
- primitive.beginFill(0, 0);
- primitive.lineStyle(constraintRender.lineWidth, Common.colorToNumber(constraintRender.strokeStyle), 1);
-
- if (bodyA) {
- primitive.moveTo(bodyA.position.x + pointA.x, bodyA.position.y + pointA.y);
- } else {
- primitive.moveTo(pointA.x, pointA.y);
- }
-
- if (bodyB) {
- primitive.lineTo(bodyB.position.x + pointB.x, bodyB.position.y + pointB.y);
- } else {
- primitive.lineTo(pointB.x, pointB.y);
- }
-
- primitive.endFill();
- };
-
- /**
- * Description
- * @method body
- * @param {engine} engine
- * @param {body} body
- * @deprecated
- */
- RenderPixi.body = function(render, body) {
- var engine = render.engine,
- bodyRender = body.render;
-
- if (!bodyRender.visible)
- return;
-
- if (bodyRender.sprite && bodyRender.sprite.texture) {
- var spriteId = 'b-' + body.id,
- sprite = render.sprites[spriteId],
- spriteContainer = render.spriteContainer;
-
- // initialise body sprite if not existing
- if (!sprite)
- sprite = render.sprites[spriteId] = _createBodySprite(render, body);
-
- // add to scene graph if not already there
- if (Common.indexOf(spriteContainer.children, sprite) === -1)
- spriteContainer.addChild(sprite);
-
- // update body sprite
- sprite.position.x = body.position.x;
- sprite.position.y = body.position.y;
- sprite.rotation = body.angle;
- sprite.scale.x = bodyRender.sprite.xScale || 1;
- sprite.scale.y = bodyRender.sprite.yScale || 1;
- } else {
- var primitiveId = 'b-' + body.id,
- primitive = render.primitives[primitiveId],
- container = render.container;
-
- // initialise body primitive if not existing
- if (!primitive) {
- primitive = render.primitives[primitiveId] = _createBodyPrimitive(render, body);
- primitive.initialAngle = body.angle;
- }
-
- // add to scene graph if not already there
- if (Common.indexOf(container.children, primitive) === -1)
- container.addChild(primitive);
-
- // update body primitive
- primitive.position.x = body.position.x;
- primitive.position.y = body.position.y;
- primitive.rotation = body.angle - primitive.initialAngle;
- }
- };
+ * Fired at the start of a tick, before any updates to the engine or timing
+ *
+ * @event beforeTick
+ * @param {} event An event object
+ * @param {number} event.timestamp The engine.timing.timestamp of the event
+ * @param {} event.source The source object of the event
+ * @param {} event.name The name of the event
+ */
/**
- * Creates a body sprite
- * @method _createBodySprite
- * @private
- * @param {RenderPixi} render
- * @param {body} body
- * @return {PIXI.Sprite} sprite
- * @deprecated
- */
- var _createBodySprite = function(render, body) {
- var bodyRender = body.render,
- texturePath = bodyRender.sprite.texture,
- texture = _getTexture(render, texturePath),
- sprite = new PIXI.Sprite(texture);
-
- sprite.anchor.x = body.render.sprite.xOffset;
- sprite.anchor.y = body.render.sprite.yOffset;
-
- return sprite;
- };
+ * Fired after engine timing updated, but just before update
+ *
+ * @event tick
+ * @param {} event An event object
+ * @param {number} event.timestamp The engine.timing.timestamp of the event
+ * @param {} event.source The source object of the event
+ * @param {} event.name The name of the event
+ */
/**
- * Creates a body primitive
- * @method _createBodyPrimitive
- * @private
- * @param {RenderPixi} render
- * @param {body} body
- * @return {PIXI.Graphics} graphics
- * @deprecated
+ * Fired at the end of a tick, after engine update and after rendering
+ *
+ * @event afterTick
+ * @param {} event An event object
+ * @param {number} event.timestamp The engine.timing.timestamp of the event
+ * @param {} event.source The source object of the event
+ * @param {} event.name The name of the event
+ */
+
+ /**
+ * Fired before update
+ *
+ * @event beforeUpdate
+ * @param {} event An event object
+ * @param {number} event.timestamp The engine.timing.timestamp of the event
+ * @param {} event.source The source object of the event
+ * @param {} event.name The name of the event
+ */
+
+ /**
+ * Fired after update
+ *
+ * @event afterUpdate
+ * @param {} event An event object
+ * @param {number} event.timestamp The engine.timing.timestamp of the event
+ * @param {} event.source The source object of the event
+ * @param {} event.name The name of the event
+ */
+
+ /*
+ *
+ * Properties Documentation
+ *
+ */
+
+ /**
+ * A flag that specifies whether the runner is running or not.
+ *
+ * @property enabled
+ * @type boolean
+ * @default true
*/
- var _createBodyPrimitive = function(render, body) {
- var bodyRender = body.render,
- options = render.options,
- primitive = new PIXI.Graphics(),
- fillStyle = Common.colorToNumber(bodyRender.fillStyle),
- strokeStyle = Common.colorToNumber(bodyRender.strokeStyle),
- strokeStyleIndicator = Common.colorToNumber(bodyRender.strokeStyle),
- strokeStyleWireframe = Common.colorToNumber('#bbb'),
- strokeStyleWireframeIndicator = Common.colorToNumber('#CD5C5C'),
- part;
- primitive.clear();
+ /**
+ * A `Boolean` that specifies if the runner should use a fixed timestep (otherwise it is variable).
+ * If timing is fixed, then the apparent simulation speed will change depending on the frame rate (but behaviour will be deterministic).
+ * If the timing is variable, then the apparent simulation speed will be constant (approximately, but at the cost of determininism).
+ *
+ * @property isFixed
+ * @type boolean
+ * @default false
+ */
- // handle compound parts
- for (var k = body.parts.length > 1 ? 1 : 0; k < body.parts.length; k++) {
- part = body.parts[k];
+ /**
+ * A `Number` that specifies the time step between updates in milliseconds.
+ * If `engine.timing.isFixed` is set to `true`, then `delta` is fixed.
+ * If it is `false`, then `delta` can dynamically change to maintain the correct apparent simulation speed.
+ *
+ * @property delta
+ * @type number
+ * @default 1000 / 60
+ */
- if (!options.wireframes) {
- primitive.beginFill(fillStyle, 1);
- primitive.lineStyle(bodyRender.lineWidth, strokeStyle, 1);
- } else {
- primitive.beginFill(0, 0);
- primitive.lineStyle(1, strokeStyleWireframe, 1);
- }
+})();
- primitive.moveTo(part.vertices[0].x - body.position.x, part.vertices[0].y - body.position.y);
- for (var j = 1; j < part.vertices.length; j++) {
- primitive.lineTo(part.vertices[j].x - body.position.x, part.vertices[j].y - body.position.y);
- }
+/***/ }),
+/* 28 */
+/***/ (function(module, exports, __webpack_require__) {
- primitive.lineTo(part.vertices[0].x - body.position.x, part.vertices[0].y - body.position.y);
+/**
+* The `Matter.Svg` module contains methods for converting SVG images into an array of vector points.
+*
+* To use this module you also need the SVGPathSeg polyfill: https://github.com/progers/pathseg
+*
+* See the included usage [examples](https://github.com/liabru/matter-js/tree/master/examples).
+*
+* @class Svg
+*/
- primitive.endFill();
+var Svg = {};
- // angle indicator
- if (options.showAngleIndicator || options.showAxes) {
- primitive.beginFill(0, 0);
+module.exports = Svg;
- if (options.wireframes) {
- primitive.lineStyle(1, strokeStyleWireframeIndicator, 1);
+var Bounds = __webpack_require__(1);
+var Common = __webpack_require__(0);
+
+(function() {
+
+ /**
+ * Converts an SVG path into an array of vector points.
+ * If the input path forms a concave shape, you must decompose the result into convex parts before use.
+ * See `Bodies.fromVertices` which provides support for this.
+ * Note that this function is not guaranteed to support complex paths (such as those with holes).
+ * You must load the `pathseg.js` polyfill on newer browsers.
+ * @method pathToVertices
+ * @param {SVGPathElement} path
+ * @param {Number} [sampleLength=15]
+ * @return {Vector[]} points
+ */
+ Svg.pathToVertices = function(path, sampleLength) {
+ if (typeof window !== 'undefined' && !('SVGPathSeg' in window)) {
+ Common.warn('Svg.pathToVertices: SVGPathSeg not defined, a polyfill is required.');
+ }
+
+ // https://github.com/wout/svg.topoly.js/blob/master/svg.topoly.js
+ var i, il, total, point, segment, segments,
+ segmentsQueue, lastSegment,
+ lastPoint, segmentIndex, points = [],
+ lx, ly, length = 0, x = 0, y = 0;
+
+ sampleLength = sampleLength || 15;
+
+ var addPoint = function(px, py, pathSegType) {
+ // all odd-numbered path types are relative except PATHSEG_CLOSEPATH (1)
+ var isRelative = pathSegType % 2 === 1 && pathSegType > 1;
+
+ // when the last point doesn't equal the current point add the current point
+ if (!lastPoint || px != lastPoint.x || py != lastPoint.y) {
+ if (lastPoint && isRelative) {
+ lx = lastPoint.x;
+ ly = lastPoint.y;
} else {
- primitive.lineStyle(1, strokeStyleIndicator);
+ lx = 0;
+ ly = 0;
}
- primitive.moveTo(part.position.x - body.position.x, part.position.y - body.position.y);
- primitive.lineTo(((part.vertices[0].x + part.vertices[part.vertices.length-1].x) / 2 - body.position.x),
- ((part.vertices[0].y + part.vertices[part.vertices.length-1].y) / 2 - body.position.y));
+ var point = {
+ x: lx + px,
+ y: ly + py
+ };
- primitive.endFill();
+ // set last point
+ if (isRelative || !lastPoint) {
+ lastPoint = point;
+ }
+
+ points.push(point);
+
+ x = lx + px;
+ y = ly + py;
}
+ };
+
+ var addSegmentPoint = function(segment) {
+ var segType = segment.pathSegTypeAsLetter.toUpperCase();
+
+ // skip path ends
+ if (segType === 'Z')
+ return;
+
+ // map segment to x and y
+ switch (segType) {
+
+ case 'M':
+ case 'L':
+ case 'T':
+ case 'C':
+ case 'S':
+ case 'Q':
+ x = segment.x;
+ y = segment.y;
+ break;
+ case 'H':
+ x = segment.x;
+ break;
+ case 'V':
+ y = segment.y;
+ break;
+ }
+
+ addPoint(x, y, segment.pathSegType);
+ };
+
+ // ensure path is absolute
+ Svg._svgPathToAbsolute(path);
+
+ // get total length
+ total = path.getTotalLength();
+
+ // queue segments
+ segments = [];
+ for (i = 0; i < path.pathSegList.numberOfItems; i += 1)
+ segments.push(path.pathSegList.getItem(i));
+
+ segmentsQueue = segments.concat();
+
+ // sample through path
+ while (length < total) {
+ // get segment at position
+ segmentIndex = path.getPathSegAtLength(length);
+ segment = segments[segmentIndex];
+
+ // new segment
+ if (segment != lastSegment) {
+ while (segmentsQueue.length && segmentsQueue[0] != segment)
+ addSegmentPoint(segmentsQueue.shift());
+
+ lastSegment = segment;
+ }
+
+ // add points in between when curving
+ // TODO: adaptive sampling
+ switch (segment.pathSegTypeAsLetter.toUpperCase()) {
+
+ case 'C':
+ case 'T':
+ case 'S':
+ case 'Q':
+ case 'A':
+ point = path.getPointAtLength(length);
+ addPoint(point.x, point.y, 0);
+ break;
+
+ }
+
+ // increment by sample value
+ length += sampleLength;
}
- return primitive;
+ // add remaining segments not passed by sampling
+ for (i = 0, il = segmentsQueue.length; i < il; ++i)
+ addSegmentPoint(segmentsQueue[i]);
+
+ return points;
};
- /**
- * Gets the requested texture (a PIXI.Texture) via its path
- * @method _getTexture
- * @private
- * @param {RenderPixi} render
- * @param {string} imagePath
- * @return {PIXI.Texture} texture
- * @deprecated
- */
- var _getTexture = function(render, imagePath) {
- var texture = render.textures[imagePath];
+ Svg._svgPathToAbsolute = function(path) {
+ // http://phrogz.net/convert-svg-path-to-all-absolute-commands
+ // Copyright (c) Gavin Kistner
+ // http://phrogz.net/js/_ReuseLicense.txt
+ // Modifications: tidy formatting and naming
+ var x0, y0, x1, y1, x2, y2, segs = path.pathSegList,
+ x = 0, y = 0, len = segs.numberOfItems;
- if (!texture)
- texture = render.textures[imagePath] = PIXI.Texture.fromImage(imagePath);
+ for (var i = 0; i < len; ++i) {
+ var seg = segs.getItem(i),
+ segType = seg.pathSegTypeAsLetter;
- return texture;
+ if (/[MLHVCSQTA]/.test(segType)) {
+ if ('x' in seg) x = seg.x;
+ if ('y' in seg) y = seg.y;
+ } else {
+ if ('x1' in seg) x1 = x + seg.x1;
+ if ('x2' in seg) x2 = x + seg.x2;
+ if ('y1' in seg) y1 = y + seg.y1;
+ if ('y2' in seg) y2 = y + seg.y2;
+ if ('x' in seg) x += seg.x;
+ if ('y' in seg) y += seg.y;
+
+ switch (segType) {
+
+ case 'm':
+ segs.replaceItem(path.createSVGPathSegMovetoAbs(x, y), i);
+ break;
+ case 'l':
+ segs.replaceItem(path.createSVGPathSegLinetoAbs(x, y), i);
+ break;
+ case 'h':
+ segs.replaceItem(path.createSVGPathSegLinetoHorizontalAbs(x), i);
+ break;
+ case 'v':
+ segs.replaceItem(path.createSVGPathSegLinetoVerticalAbs(y), i);
+ break;
+ case 'c':
+ segs.replaceItem(path.createSVGPathSegCurvetoCubicAbs(x, y, x1, y1, x2, y2), i);
+ break;
+ case 's':
+ segs.replaceItem(path.createSVGPathSegCurvetoCubicSmoothAbs(x, y, x2, y2), i);
+ break;
+ case 'q':
+ segs.replaceItem(path.createSVGPathSegCurvetoQuadraticAbs(x, y, x1, y1), i);
+ break;
+ case 't':
+ segs.replaceItem(path.createSVGPathSegCurvetoQuadraticSmoothAbs(x, y), i);
+ break;
+ case 'a':
+ segs.replaceItem(path.createSVGPathSegArcAbs(x, y, seg.r1, seg.r2, seg.angle, seg.largeArcFlag, seg.sweepFlag), i);
+ break;
+ case 'z':
+ case 'Z':
+ x = x0;
+ y = y0;
+ break;
+
+ }
+ }
+
+ if (segType == 'M' || segType == 'm') {
+ x0 = x;
+ y0 = y;
+ }
+ }
};
})();
-},{"../body/Composite":2,"../core/Common":14,"../core/Events":16,"../geometry/Bounds":26,"../geometry/Vector":28}]},{},[30])(30)
-});
+/***/ }),
+/* 29 */
+/***/ (function(module, exports, __webpack_require__) {
+
+/**
+* This module has now been replaced by `Matter.Composite`.
+*
+* All usage should be migrated to the equivalent functions found on `Matter.Composite`.
+* For example `World.add(world, body)` now becomes `Composite.add(world, body)`.
+*
+* The property `world.gravity` has been moved to `engine.gravity`.
+*
+* For back-compatibility purposes this module will remain as a direct alias to `Matter.Composite` in the short term during migration.
+* Eventually this alias module will be marked as deprecated and then later removed in a future release.
+*
+* @class World
+*/
+
+var World = {};
+
+module.exports = World;
+
+var Composite = __webpack_require__(5);
+var Common = __webpack_require__(0);
+
+(function() {
+
+ /**
+ * See above, aliases for back compatibility only
+ */
+ World.create = Composite.create;
+ World.add = Composite.add;
+ World.remove = Composite.remove;
+ World.clear = Composite.clear;
+ World.addComposite = Composite.addComposite;
+ World.addBody = Composite.addBody;
+ World.addConstraint = Composite.addConstraint;
+
+})();
+
+
+/***/ })
+/******/ ]);
+});
\ No newline at end of file
diff --git a/build/matter.min.js b/build/matter.min.js
index 8255c59..da8f1e1 100644
--- a/build/matter.min.js
+++ b/build/matter.min.js
@@ -1,96 +1,6 @@
-/**
-* matter-js 0.14.2 by @liabru 2018-06-11
-* http://brm.io/matter-js/
-* License MIT
-*/
-!function(e){if("object"==typeof exports&&"undefined"!=typeof module)module.exports=e();else if("function"==typeof define&&define.amd)define([],e);else{var t;t="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof self?self:this,t.Matter=e()}}(function(){return function(){function e(t,n,o){function i(s,a){if(!n[s]){if(!t[s]){var l="function"==typeof require&&require;if(!a&&l)return l(s,!0);if(r)return r(s,!0);var c=new Error("Cannot find module '"+s+"'");throw c.code="MODULE_NOT_FOUND",c}var d=n[s]={exports:{}};t[s][0].call(d.exports,function(e){return i(t[s][1][e]||e)},d,d.exports,e,t,n,o)}return n[s].exports}for(var r="function"==typeof require&&require,s=0;s0&&r.rotateAbout(s.position,n,e.position,s.position)}},o.setVelocity=function(e,t){e.positionPrev.x=e.position.x-t.x,e.positionPrev.y=e.position.y-t.y,
-e.velocity.x=t.x,e.velocity.y=t.y,e.speed=r.magnitude(e.velocity)},o.setAngularVelocity=function(e,t){e.anglePrev=e.angle-t,e.angularVelocity=t,e.angularSpeed=Math.abs(e.angularVelocity)},o.translate=function(e,t){o.setPosition(e,r.add(e.position,t))},o.rotate=function(e,t,n){if(n){var i=Math.cos(t),r=Math.sin(t),s=e.position.x-n.x,a=e.position.y-n.y;o.setPosition(e,{x:n.x+(s*i-a*r),y:n.y+(s*r+a*i)}),o.setAngle(e,e.angle+t)}else o.setAngle(e,e.angle+t)},o.scale=function(e,t,n,r){var s=0,a=0;r=r||e.position;for(var d=0;d0&&(s+=u.area,a+=u.inertia),u.position.x=r.x+(u.position.x-r.x)*t,u.position.y=r.y+(u.position.y-r.y)*n,l.update(u.bounds,u.vertices,e.velocity)
-}e.parts.length>1&&(e.area=s,e.isStatic||(o.setMass(e,e.density*s),o.setInertia(e,a))),e.circleRadius&&(t===n?e.circleRadius*=t:e.circleRadius=null)},o.update=function(e,t,n,o){var s=Math.pow(t*n*e.timeScale,2),a=1-e.frictionAir*n*e.timeScale,d=e.position.x-e.positionPrev.x,u=e.position.y-e.positionPrev.y;e.velocity.x=d*a*o+e.force.x/e.mass*s,e.velocity.y=u*a*o+e.force.y/e.mass*s,e.positionPrev.x=e.position.x,e.positionPrev.y=e.position.y,e.position.x+=e.velocity.x,e.position.y+=e.velocity.y,e.angularVelocity=(e.angle-e.anglePrev)*a*o+e.torque/e.inertia*s,e.anglePrev=e.angle,e.angle+=e.angularVelocity,e.speed=r.magnitude(e.velocity),e.angularSpeed=Math.abs(e.angularVelocity);for(var p=0;p0&&(f.position.x+=e.velocity.x,f.position.y+=e.velocity.y),0!==e.angularVelocity&&(i.rotate(f.vertices,e.angularVelocity,e.position),c.rotate(f.axes,e.angularVelocity),
-p>0&&r.rotateAbout(f.position,e.angularVelocity,e.position,f.position)),l.update(f.bounds,f.vertices,e.velocity)}},o.applyForce=function(e,t,n){e.force.x+=n.x,e.force.y+=n.y;var o={x:t.x-e.position.x,y:t.y-e.position.y};e.torque+=o.x*n.y-o.y*n.x},o._totalProperties=function(e){for(var t={mass:0,area:0,inertia:0,centre:{x:0,y:0}},n=1===e.parts.length?0:1;n1?1:0;u1?1:0;f0:0!=(e.mask&t.category)&&0!=(t.mask&e.category)}}()},{"../geometry/Bounds":26,"./Pair":7,"./SAT":11}],6:[function(e,t,n){var o={};t.exports=o;var i=e("./Pair"),r=e("./Detector"),s=e("../core/Common");!function(){o.create=function(e){var t={controller:o,detector:r.collisions,buckets:{},pairs:{},pairsList:[],bucketWidth:48,bucketHeight:48};return s.extend(t,e)},o.update=function(e,t,n,i){
-var r,s,a,l,c,d=n.world,u=e.buckets,p=!1;for(r=0;rd.bounds.max.x||f.bounds.max.yd.bounds.max.y)){var m=o._getRegion(e,f);if(!f.region||m.id!==f.region.id||i){f.region&&!i||(f.region=m);var v=o._regionUnion(m,f.region);for(s=v.startCol;s<=v.endCol;s++)for(a=v.startRow;a<=v.endRow;a++){c=o._getBucketId(s,a),l=u[c];var y=s>=m.startCol&&s<=m.endCol&&a>=m.startRow&&a<=m.endRow,g=s>=f.region.startCol&&s<=f.region.endCol&&a>=f.region.startRow&&a<=f.region.endRow;!y&&g&&g&&l&&o._bucketRemoveBody(e,l,f),(f.region===m||y&&!g||i)&&(l||(l=o._createBucket(u,c)),o._bucketAddBody(e,l,f))}f.region=m,p=!0}}}p&&(e.pairsList=o._createActivePairsList(e))},o.clear=function(e){e.buckets={},e.pairs={},e.pairsList=[]},o._regionUnion=function(e,t){var n=Math.min(e.startCol,t.startCol),i=Math.max(e.endCol,t.endCol),r=Math.min(e.startRow,t.startRow),s=Math.max(e.endRow,t.endRow)
-;return o._createRegion(n,i,r,s)},o._getRegion=function(e,t){var n=t.bounds,i=Math.floor(n.min.x/e.bucketWidth),r=Math.floor(n.max.x/e.bucketWidth),s=Math.floor(n.min.y/e.bucketHeight),a=Math.floor(n.max.y/e.bucketHeight);return o._createRegion(i,r,s,a)},o._createRegion=function(e,t,n,o){return{id:e+","+t+","+n+","+o,startCol:e,endCol:t,startRow:n,endRow:o}},o._getBucketId=function(e,t){return"C"+e+"R"+t},o._createBucket=function(e,t){return e[t]=[]},o._bucketAddBody=function(e,t,n){for(var o=0;o0?o.push(n):delete e.pairs[t[i]];return o}}()},{"../core/Common":14,"./Detector":5,"./Pair":7}],
-7:[function(e,t,n){var o={};t.exports=o;var i=e("./Contact");!function(){o.create=function(e,t){var n=e.bodyA,i=e.bodyB,r=e.parentA,s=e.parentB,a={id:o.id(n,i),bodyA:n,bodyB:i,contacts:{},activeContacts:[],separation:0,isActive:!0,isSensor:n.isSensor||i.isSensor,timeCreated:t,timeUpdated:t,inverseMass:r.inverseMass+s.inverseMass,friction:Math.min(r.friction,s.friction),frictionStatic:Math.max(r.frictionStatic,s.frictionStatic),restitution:Math.max(r.restitution,s.restitution),slop:Math.max(r.slop,s.slop)};return o.update(a,e,t),a},o.update=function(e,t,n){var r=e.contacts,s=t.supports,a=e.activeContacts,l=t.parentA,c=t.parentB;if(e.collision=t,e.inverseMass=l.inverseMass+c.inverseMass,e.friction=Math.min(l.friction,c.friction),e.frictionStatic=Math.max(l.frictionStatic,c.frictionStatic),e.restitution=Math.max(l.restitution,c.restitution),e.slop=Math.max(l.slop,c.slop),a.length=0,t.collided){for(var d=0;do._pairMaxIdleLife&&c.push(s);for(s=0;sf.friction*f.frictionStatic*E*n&&(F=T,L=s.clamp(f.friction*R*n,-F,F));var O=r.cross(A,g),q=r.cross(P,g),W=b/(v.inverseMass+y.inverseMass+v.inverseInertia*O*O+y.inverseInertia*q*q);if(V*=W,L*=W,I<0&&I*I>o._restingThresh*n)S.normalImpulse=0;else{var D=S.normalImpulse;S.normalImpulse=Math.min(S.normalImpulse+V,0),V=S.normalImpulse-D}if(_*_>o._restingThreshTangent*n)S.tangentImpulse=0;else{var N=S.tangentImpulse;S.tangentImpulse=s.clamp(S.tangentImpulse+L,-F,F),L=S.tangentImpulse-N}i.x=g.x*V+x.x*L,i.y=g.y*V+x.y*L,v.isStatic||v.isSleeping||(v.positionPrev.x+=i.x*v.inverseMass,v.positionPrev.y+=i.y*v.inverseMass,
-v.anglePrev+=r.cross(A,i)*v.inverseInertia),y.isStatic||y.isSleeping||(y.positionPrev.x-=i.x*y.inverseMass,y.positionPrev.y-=i.y*y.inverseMass,y.anglePrev-=r.cross(P,i)*y.inverseInertia)}}}}}()},{"../core/Common":14,"../geometry/Bounds":26,"../geometry/Vector":28,"../geometry/Vertices":29}],11:[function(e,t,n){var o={};t.exports=o;var i=e("../geometry/Vertices"),r=e("../geometry/Vector");!function(){o.collides=function(e,t,n){var s,a,l,c,d=!1;if(n){var u=e.parent,p=t.parent,f=u.speed*u.speed+u.angularSpeed*u.angularSpeed+p.speed*p.speed+p.angularSpeed*p.angularSpeed;d=n&&n.collided&&f<.2,c=n}else c={collided:!1,bodyA:e,bodyB:t};if(n&&d){var m=c.axisBody,v=m===e?t:e,y=[m.axes[n.axisNumber]];if(l=o._overlapAxes(m.vertices,v.vertices,y),c.reused=!0,l.overlap<=0)return c.collided=!1,c}else{if(s=o._overlapAxes(e.vertices,t.vertices,e.axes),s.overlap<=0)return c.collided=!1,c;if(a=o._overlapAxes(t.vertices,e.vertices,t.axes),a.overlap<=0)return c.collided=!1,c;s.overlapi?i=a:a=0?s.index-1:d.length-1],c.x=i.x-u.x,c.y=i.y-u.y,l=-r.dot(n,c),a=i,i=d[(s.index+1)%d.length],c.x=i.x-u.x,c.y=i.y-u.y,o=-r.dot(n,c),o0?1:.7),t.damping=t.damping||0,t.angularStiffness=t.angularStiffness||0,t.angleA=t.bodyA?t.bodyA.angle:t.angleA,t.angleB=t.bodyB?t.bodyB.angle:t.angleB,t.plugin={};var s={visible:!0,lineWidth:2,strokeStyle:"#ffffff",type:"line",anchors:!0};return 0===t.length&&t.stiffness>.1?(s.type="pin",s.anchors=!1):t.stiffness<.9&&(s.type="spring"),t.render=c.extend(s,t.render),t},o.preSolveAll=function(e){for(var t=0;t0&&(u.position.x+=c.x,u.position.y+=c.y),0!==c.angle&&(i.rotate(u.vertices,c.angle,n.position),l.rotate(u.axes,c.angle),
-d>0&&r.rotateAbout(u.position,c.angle,n.position,u.position)),a.update(u.bounds,u.vertices,n.velocity)}c.angle*=o._warming,c.x*=o._warming,c.y*=o._warming}}}}()},{"../core/Common":14,"../core/Sleeping":22,"../geometry/Axes":25,"../geometry/Bounds":26,"../geometry/Vector":28,"../geometry/Vertices":29}],13:[function(e,t,n){var o={};t.exports=o;var i=e("../geometry/Vertices"),r=e("../core/Sleeping"),s=e("../core/Mouse"),a=e("../core/Events"),l=e("../collision/Detector"),c=e("./Constraint"),d=e("../body/Composite"),u=e("../core/Common"),p=e("../geometry/Bounds");!function(){o.create=function(e,t){var n=(e?e.mouse:null)||(t?t.mouse:null);n||(e&&e.render&&e.render.canvas?n=s.create(e.render.canvas):t&&t.element?n=s.create(t.element):(n=s.create(),u.warn("MouseConstraint.create: options.mouse was undefined, options.element was undefined, may not function as expected")));var i=c.create({label:"Mouse Constraint",pointA:n.position,pointB:{x:0,y:0},length:.01,stiffness:.1,angularStiffness:1,
-render:{strokeStyle:"#90EE90",lineWidth:3}}),r={type:"mouseConstraint",mouse:n,element:null,body:null,constraint:i,collisionFilter:{category:1,mask:4294967295,group:0}},l=u.extend(r,t);return a.on(e,"beforeUpdate",function(){var t=d.allBodies(e.world);o.update(l,t),o._triggerEvents(l)}),l},o.update=function(e,t){var n=e.mouse,o=e.constraint,s=e.body;if(0===n.button){if(o.bodyB)r.set(o.bodyB,!1),o.pointA=n.position;else for(var c=0;c1?1:0;d0;t--){var n=Math.floor(o.random()*(t+1)),i=e[t];e[t]=e[n],e[n]=i}return e},o.choose=function(e){return e[Math.floor(o.random()*e.length)]},o.isElement=function(e){return"undefined"!=typeof HTMLElement?e instanceof HTMLElement:!!(e&&e.nodeType&&e.nodeName)},o.isArray=function(e){return"[object Array]"===Object.prototype.toString.call(e)},o.isFunction=function(e){return"function"==typeof e},o.isPlainObject=function(e){return"object"==typeof e&&e.constructor===Object},o.isString=function(e){return"[object String]"===toString.call(e)},o.clamp=function(e,t,n){return en?n:e},o.sign=function(e){return e<0?-1:1},o.now=function(){
-if(window.performance){if(window.performance.now)return window.performance.now();if(window.performance.webkitNow)return window.performance.webkitNow()}return new Date-o._nowStartTime},o.random=function(e,n){return e=void 0!==e?e:0,n=void 0!==n?n:1,e+t()*(n-e)};var t=function(){return o._seed=(9301*o._seed+49297)%233280,o._seed/233280};o.colorToNumber=function(e){return e=e.replace("#",""),3==e.length&&(e=e.charAt(0)+e.charAt(0)+e.charAt(1)+e.charAt(1)+e.charAt(2)+e.charAt(2)),parseInt(e,16)},o.logLevel=1,o.log=function(){console&&o.logLevel>0&&o.logLevel<=3&&console.log.apply(console,["matter-js:"].concat(Array.prototype.slice.call(arguments)))},o.info=function(){console&&o.logLevel>0&&o.logLevel<=2&&console.info.apply(console,["matter-js:"].concat(Array.prototype.slice.call(arguments)))},o.warn=function(){console&&o.logLevel>0&&o.logLevel<=3&&console.warn.apply(console,["matter-js:"].concat(Array.prototype.slice.call(arguments)))},o.nextId=function(){return o._nextId++},
-o.indexOf=function(e,t){if(e.indexOf)return e.indexOf(t);for(var n=0;n0&&d.trigger(e,"collisionStart",{pairs:h.collisionStart}),s.preSolvePosition(h.list),i=0;i0&&d.trigger(e,"collisionActive",{pairs:h.collisionActive}),h.collisionEnd.length>0&&d.trigger(e,"collisionEnd",{pairs:h.collisionEnd}),o._bodiesClearForces(y),d.trigger(e,"afterUpdate",v),e},o.merge=function(e,t){if(f.extend(e,t),t.world){e.world=t.world,o.clear(e);for(var n=u.allBodies(e.world),i=0;ir?(i.warn("Plugin.register:",o.toString(t),"was upgraded to",o.toString(e)),o._registry[e.name]=e):n-1},o.isFor=function(e,t){var n=e.for&&o.dependencyParse(e.for)
-;return!e.for||t.name===n.name&&o.versionSatisfies(t.version,n.range)},o.use=function(e,t){if(e.uses=(e.uses||[]).concat(t||[]),0===e.uses.length)return void i.warn("Plugin.use:",o.toString(e),"does not specify any dependencies to install.");for(var n=o.dependencies(e),r=i.topologicalSort(n),s=[],a=0;a0&&i.info(s.join(" "))},o.dependencies=function(e,t){var n=o.dependencyParse(e),r=n.name;if(t=t||{},!(r in t)){e=o.resolve(e)||e,t[r]=i.map(e.uses||[],function(t){o.isPlugin(t)&&o.register(t);var r=o.dependencyParse(t),s=o.resolve(t)
-;return s&&!o.versionSatisfies(s.version,r.range)?(i.warn("Plugin.dependencies:",o.toString(s),"does not satisfy",o.toString(r),"used by",o.toString(n)+"."),s._warned=!0,e._warned=!0):s||(i.warn("Plugin.dependencies:",o.toString(t),"used by",o.toString(n),"could not be resolved."),e._warned=!0),r.name});for(var s=0;s=i[2];if("^"===n.operator)return i[0]>0?s[0]===i[0]&&r.number>=n.number:i[1]>0?s[1]===i[1]&&s[2]>=i[2]:s[2]===i[2]}return e===t||"*"===e}}()},{"./Common":14}],21:[function(e,t,n){var o={};t.exports=o;var i=e("./Events"),r=e("./Engine"),s=e("./Common");!function(){var e,t;if("undefined"!=typeof window&&(e=window.requestAnimationFrame||window.webkitRequestAnimationFrame||window.mozRequestAnimationFrame||window.msRequestAnimationFrame,t=window.cancelAnimationFrame||window.mozCancelAnimationFrame||window.webkitCancelAnimationFrame||window.msCancelAnimationFrame),!e){var n;e=function(e){n=setTimeout(function(){e(s.now())},1e3/60)},t=function(){clearTimeout(n)}}o.create=function(e){var t={fps:60,correction:1,deltaSampleSize:60,
-counterTimestamp:0,frameCounter:0,deltaHistory:[],timePrev:null,timeScalePrev:1,frameRequestId:null,isFixed:!1,enabled:!0},n=s.extend(t,e);return n.delta=n.delta||1e3/n.fps,n.deltaMin=n.deltaMin||1e3/n.fps,n.deltaMax=n.deltaMax||1e3/(.5*n.fps),n.fps=1e3/n.delta,n},o.run=function(t,n){return void 0!==t.positionIterations&&(n=t,t=o.create()),function i(r){t.frameRequestId=e(i),r&&t.enabled&&o.tick(t,n,r)}(),t},o.tick=function(e,t,n){var o,s=t.timing,a=1,l={timestamp:s.timestamp};i.trigger(e,"beforeTick",l),i.trigger(t,"beforeTick",l),e.isFixed?o=e.delta:(o=n-e.timePrev||e.delta,e.timePrev=n,e.deltaHistory.push(o),e.deltaHistory=e.deltaHistory.slice(-e.deltaSampleSize),o=Math.min.apply(null,e.deltaHistory),o=oe.deltaMax?e.deltaMax:o,a=o/e.delta,e.delta=o),0!==e.timeScalePrev&&(a*=s.timeScale/e.timeScalePrev),0===s.timeScale&&(a=0),e.timeScalePrev=s.timeScale,e.correction=a,e.frameCounter+=1,
-n-e.counterTimestamp>=1e3&&(e.fps=e.frameCounter*((n-e.counterTimestamp)/1e3),e.counterTimestamp=n,e.frameCounter=0),i.trigger(e,"tick",l),i.trigger(t,"tick",l),t.world.isModified&&t.render&&t.render.controller&&t.render.controller.clear&&t.render.controller.clear(t.render),i.trigger(e,"beforeUpdate",l),r.update(t,o,a),i.trigger(e,"afterUpdate",l),t.render&&t.render.controller&&(i.trigger(e,"beforeRender",l),i.trigger(t,"beforeRender",l),t.render.controller.world(t.render),i.trigger(e,"afterRender",l),i.trigger(t,"afterRender",l)),i.trigger(e,"afterTick",l),i.trigger(t,"afterTick",l)},o.stop=function(e){t(e.frameRequestId)},o.start=function(e,t){o.run(e,t)}}()},{"./Common":14,"./Engine":15,"./Events":16}],22:[function(e,t,n){var o={};t.exports=o;var i=e("./Events");!function(){o._motionWakeThreshold=.18,o._motionSleepThreshold=.08,o._minBias=.9,o.update=function(e,t){for(var n=t*t*t,i=0;i0&&r.motion=r.sleepThreshold&&o.set(r,!0)):r.sleepCounter>0&&(r.sleepCounter-=1)}else o.set(r,!1)}},o.afterCollisions=function(e,t){for(var n=t*t*t,i=0;io._motionWakeThreshold*n&&o.set(c,!1)}}}},o.set=function(e,t){var n=e.isSleeping;t?(e.isSleeping=!0,e.sleepCounter=e.sleepThreshold,e.positionImpulse.x=0,e.positionImpulse.y=0,e.positionPrev.x=e.position.x,e.positionPrev.y=e.position.y,e.anglePrev=e.angle,e.speed=0,e.angularSpeed=0,e.motion=0,n||i.trigger(e,"sleepStart")):(e.isSleeping=!1,e.sleepCounter=0,n&&i.trigger(e,"sleepEnd"))}}()},{
-"./Events":16}],23:[function(e,t,n){var o={};t.exports=o;var i,r=e("../geometry/Vertices"),s=e("../core/Common"),a=e("../body/Body"),l=e("../geometry/Bounds"),c=e("../geometry/Vector");!function(){o.rectangle=function(e,t,n,o,i){i=i||{};var l={label:"Rectangle Body",position:{x:e,y:t},vertices:r.fromPath("L 0 0 L "+n+" 0 L "+n+" "+o+" L 0 "+o)};if(i.chamfer){var c=i.chamfer;l.vertices=r.chamfer(l.vertices,c.radius,c.quality,c.qualityMin,c.qualityMax),delete i.chamfer}return a.create(s.extend({},l,i))},o.trapezoid=function(e,t,n,o,i,l){l=l||{},i*=.5;var c,d=(1-2*i)*n,u=n*i,p=u+d,f=p+u;c=i<.5?"L 0 0 L "+u+" "+-o+" L "+p+" "+-o+" L "+f+" 0":"L 0 0 L "+p+" "+-o+" L "+f+" 0";var m={label:"Trapezoid Body",position:{x:e,y:t},vertices:r.fromPath(c)};if(l.chamfer){var v=l.chamfer;m.vertices=r.chamfer(m.vertices,v.radius,v.quality,v.qualityMin,v.qualityMax),delete l.chamfer}return a.create(s.extend({},m,l))},o.circle=function(e,t,n,i,r){i=i||{};var a={label:"Circle Body",circleRadius:n};r=r||25
-;var l=Math.ceil(Math.max(10,Math.min(r,n)));return l%2==1&&(l+=1),o.polygon(e,t,l,n,s.extend({},a,i))},o.polygon=function(e,t,n,i,l){if(l=l||{},n<3)return o.circle(e,t,i,l);for(var c=2*Math.PI/n,d="",u=.5*c,p=0;p0&&r.area(P)1?(f=a.create(s.extend({parts:m.slice(0)},o)),a.setPosition(f,{x:e,y:t}),f):m[0]}}()},{"../body/Body":1,"../core/Common":14,"../geometry/Bounds":26,"../geometry/Vector":28,"../geometry/Vertices":29}],24:[function(e,t,n){var o={};t.exports=o
-;var i=e("../body/Composite"),r=e("../constraint/Constraint"),s=e("../core/Common"),a=e("../body/Body"),l=e("./Bodies");!function(){o.stack=function(e,t,n,o,r,s,l){for(var c,d=i.create({label:"Stack"}),u=e,p=t,f=0,m=0;mv&&(v=x),a.translate(g,{x:.5*h,y:.5*x}),u=g.bounds.max.x+r,i.addBody(d,g),c=g,f+=1}else u+=r}p+=v+s,u=e}return d},o.chain=function(e,t,n,o,a,l){for(var c=e.bodies,d=1;d0)for(c=0;c0&&(p=f[c-1+(l-1)*t],i.addConstraint(e,r.create(s.extend({bodyA:p,bodyB:u},a)))),o&&cp)){c=p-c;var m=c,v=n-1-c;if(!(sv)){1===u&&a.translate(d,{x:(s+(n%2==1?1:-1))*f,y:0});return l(e+(d?s*f:0)+s*r,o,s,c,d,u)}}})},o.newtonsCradle=function(e,t,n,o,s){for(var a=i.create({label:"Newtons Cradle"}),c=0;ce.max.x&&(e.max.x=i.x),i.xe.max.y&&(e.max.y=i.y),i.y0?e.max.x+=n.x:e.min.x+=n.x,n.y>0?e.max.y+=n.y:e.min.y+=n.y)},o.contains=function(e,t){return t.x>=e.min.x&&t.x<=e.max.x&&t.y>=e.min.y&&t.y<=e.max.y},o.overlaps=function(e,t){return e.min.x<=t.max.x&&e.max.x>=t.min.x&&e.max.y>=t.min.y&&e.min.y<=t.max.y},o.translate=function(e,t){e.min.x+=t.x,
-e.max.x+=t.x,e.min.y+=t.y,e.max.y+=t.y},o.shift=function(e,t){var n=e.max.x-e.min.x,o=e.max.y-e.min.y;e.min.x=t.x,e.max.x=t.x+n,e.min.y=t.y,e.max.y=t.y+o}}()},{}],27:[function(e,t,n){var o={};t.exports=o;var i=(e("../geometry/Bounds"),e("../core/Common"));!function(){o.pathToVertices=function(e,t){"undefined"==typeof window||"SVGPathSeg"in window||i.warn("Svg.pathToVertices: SVGPathSeg not defined, a polyfill is required.");var n,r,s,a,l,c,d,u,p,f,m,v,y=[],g=0,x=0,h=0;t=t||15;var b=function(e,t,n){var o=n%2==1&&n>1;if(!p||e!=p.x||t!=p.y){p&&o?(m=p.x,v=p.y):(m=0,v=0);var i={x:m+e,y:v+t};!o&&p||(p=i),y.push(i),x=m+e,h=v+t}},w=function(e){var t=e.pathSegTypeAsLetter.toUpperCase();if("Z"!==t){switch(t){case"M":case"L":case"T":case"C":case"S":case"Q":x=e.x,h=e.y;break;case"H":x=e.x;break;case"V":h=e.y}b(x,h,e.pathSegType)}};for(o._svgPathToAbsolute(e),s=e.getTotalLength(),c=[],n=0;n0)return!1}return!0},o.scale=function(e,t,n,r){if(1===t&&1===n)return e;r=r||o.centre(e);for(var s,a,l=0;l=0?l-1:e.length-1],d=e[l],u=e[(l+1)%e.length],p=t[l0&&(r|=2),3===r)return!1;return 0!==r||null},o.hull=function(e){var t,n,o=[],r=[];for(e=e.slice(0),e.sort(function(e,t){var n=e.x-t.x;return 0!==n?n:e.y-t.y}),n=0;n=2&&i.cross3(r[r.length-2],r[r.length-1],t)<=0;)r.pop();r.push(t)}for(n=e.length-1;n>=0;n-=1){for(t=e[n];o.length>=2&&i.cross3(o[o.length-2],o[o.length-1],t)<=0;)o.pop();o.push(t)}return o.pop(),r.pop(),o.concat(r)}}()},{"../core/Common":14,"../geometry/Vector":28}],30:[function(e,t,n){var o=t.exports=e("../core/Matter");o.Body=e("../body/Body"),o.Composite=e("../body/Composite"),
-o.World=e("../body/World"),o.Contact=e("../collision/Contact"),o.Detector=e("../collision/Detector"),o.Grid=e("../collision/Grid"),o.Pairs=e("../collision/Pairs"),o.Pair=e("../collision/Pair"),o.Query=e("../collision/Query"),o.Resolver=e("../collision/Resolver"),o.SAT=e("../collision/SAT"),o.Constraint=e("../constraint/Constraint"),o.MouseConstraint=e("../constraint/MouseConstraint"),o.Common=e("../core/Common"),o.Engine=e("../core/Engine"),o.Events=e("../core/Events"),o.Mouse=e("../core/Mouse"),o.Runner=e("../core/Runner"),o.Sleeping=e("../core/Sleeping"),o.Plugin=e("../core/Plugin"),o.Bodies=e("../factory/Bodies"),o.Composites=e("../factory/Composites"),o.Axes=e("../geometry/Axes"),o.Bounds=e("../geometry/Bounds"),o.Svg=e("../geometry/Svg"),o.Vector=e("../geometry/Vector"),o.Vertices=e("../geometry/Vertices"),o.Render=e("../render/Render"),o.RenderPixi=e("../render/RenderPixi"),o.World.add=o.Composite.add,o.World.remove=o.Composite.remove,
-o.World.addComposite=o.Composite.addComposite,o.World.addBody=o.Composite.addBody,o.World.addConstraint=o.Composite.addConstraint,o.World.clear=o.Composite.clear,o.Engine.run=o.Runner.run},{"../body/Body":1,"../body/Composite":2,"../body/World":3,"../collision/Contact":4,"../collision/Detector":5,"../collision/Grid":6,"../collision/Pair":7,"../collision/Pairs":8,"../collision/Query":9,"../collision/Resolver":10,"../collision/SAT":11,"../constraint/Constraint":12,"../constraint/MouseConstraint":13,"../core/Common":14,"../core/Engine":15,"../core/Events":16,"../core/Matter":17,"../core/Metrics":18,"../core/Mouse":19,"../core/Plugin":20,"../core/Runner":21,"../core/Sleeping":22,"../factory/Bodies":23,"../factory/Composites":24,"../geometry/Axes":25,"../geometry/Bounds":26,"../geometry/Svg":27,"../geometry/Vector":28,"../geometry/Vertices":29,"../render/Render":31,"../render/RenderPixi":32}],31:[function(e,t,n){var o={};t.exports=o
-;var i=e("../core/Common"),r=e("../body/Composite"),s=e("../geometry/Bounds"),a=e("../core/Events"),l=e("../collision/Grid"),c=e("../geometry/Vector"),d=e("../core/Mouse");!function(){var e,t;"undefined"!=typeof window&&(e=window.requestAnimationFrame||window.webkitRequestAnimationFrame||window.mozRequestAnimationFrame||window.msRequestAnimationFrame||function(e){window.setTimeout(function(){e(i.now())},1e3/60)},t=window.cancelAnimationFrame||window.mozCancelAnimationFrame||window.webkitCancelAnimationFrame||window.msCancelAnimationFrame),o.create=function(e){var t={controller:o,engine:null,element:null,canvas:null,mouse:null,frameRequestId:null,options:{width:800,height:600,pixelRatio:1,background:"#18181d",wireframeBackground:"#0f0f13",hasBounds:!!e.bounds,enabled:!0,wireframes:!0,showSleeping:!0,showDebug:!1,showBroadphase:!1,showBounds:!1,showVelocity:!1,showCollisions:!1,showSeparations:!1,showAxes:!1,showPositions:!1,showAngleIndicator:!1,showIds:!1,showShadows:!1,
-showVertexNumbers:!1,showConvexHulls:!1,showInternalEdges:!1,showMousePosition:!1}},r=i.extend(t,e);return r.canvas&&(r.canvas.width=r.options.width||r.canvas.width,r.canvas.height=r.options.height||r.canvas.height),r.mouse=e.mouse,r.engine=e.engine,r.canvas=r.canvas||n(r.options.width,r.options.height),r.context=r.canvas.getContext("2d"),r.textures={},r.bounds=r.bounds||{min:{x:0,y:0},max:{x:r.canvas.width,y:r.canvas.height}},1!==r.options.pixelRatio&&o.setPixelRatio(r,r.options.pixelRatio),i.isElement(r.element)?r.element.appendChild(r.canvas):r.canvas.parentNode||i.log("Render.create: options.element was undefined, render.canvas was created but not appended","warn"),r},o.run=function(t){!function n(i){t.frameRequestId=e(n),o.world(t)}()},o.stop=function(e){t(e.frameRequestId)},o.setPixelRatio=function(e,t){var n=e.options,o=e.canvas;"auto"===t&&(t=u(o)),n.pixelRatio=t,o.setAttribute("data-pixel-ratio",t),o.width=n.width*t,o.height=n.height*t,o.style.width=n.width+"px",
-o.style.height=n.height+"px",e.context.scale(t,t)},o.lookAt=function(e,t,n,o){o=void 0===o||o,t=i.isArray(t)?t:[t],n=n||{x:0,y:0};for(var r={min:{x:1/0,y:1/0},max:{x:-1/0,y:-1/0}},s=0;sr.max.x&&(r.max.x=c.x),l.yr.max.y&&(r.max.y=c.y))}var u=r.max.x-r.min.x+2*n.x,p=r.max.y-r.min.y+2*n.y,f=e.canvas.height,m=e.canvas.width,v=m/f,y=u/p,g=1,x=1;y>v?x=y/v:g=v/y,e.options.hasBounds=!0,e.bounds.min.x=r.min.x,e.bounds.max.x=r.min.x+u*g,e.bounds.min.y=r.min.y,e.bounds.max.y=r.min.y+p*x,o&&(e.bounds.min.x+=.5*u-u*g*.5,e.bounds.max.x+=.5*u-u*g*.5,e.bounds.min.y+=.5*p-p*x*.5,e.bounds.max.y+=.5*p-p*x*.5),e.bounds.min.x-=n.x,e.bounds.max.x-=n.x,e.bounds.min.y-=n.y,e.bounds.max.y-=n.y,e.mouse&&(d.setScale(e.mouse,{x:(e.bounds.max.x-e.bounds.min.x)/e.canvas.width,y:(e.bounds.max.y-e.bounds.min.y)/e.canvas.height}),
-d.setOffset(e.mouse,e.bounds.min))},o.startViewTransform=function(e){var t=e.bounds.max.x-e.bounds.min.x,n=e.bounds.max.y-e.bounds.min.y,o=t/e.options.width,i=n/e.options.height;e.context.scale(1/o,1/i),e.context.translate(-e.bounds.min.x,-e.bounds.min.y)},o.endViewTransform=function(e){e.context.setTransform(e.options.pixelRatio,0,0,e.options.pixelRatio,0,0)},o.world=function(e){var t,n=e.engine,i=n.world,u=e.canvas,p=e.context,m=e.options,v=r.allBodies(i),y=r.allConstraints(i),g=m.wireframes?m.wireframeBackground:m.background,x=[],h=[],b={timestamp:n.timing.timestamp};if(a.trigger(e,"beforeRender",b),e.currentBackground!==g&&f(e,g),p.globalCompositeOperation="source-in",p.fillStyle="transparent",p.fillRect(0,0,u.width,u.height),p.globalCompositeOperation="source-over",m.hasBounds){for(t=0;t=500){var l="";s.timing&&(l+="fps: "+Math.round(s.timing.fps)+" "),e.debugString=l,e.debugTimestamp=o.timing.timestamp}if(e.debugString){n.font="12px Arial",a.wireframes?n.fillStyle="rgba(255,255,255,0.5)":n.fillStyle="rgba(0,0,0,0.5)";for(var c=e.debugString.split("\n"),d=0;d1?1:0;s1?1:0;a1?1:0;r1?1:0;a1?1:0;r1?1:0;r1?1:0;i0)){var u=o.activeContacts[0].vertex.x,p=o.activeContacts[0].vertex.y;2===o.activeContacts.length&&(u=(o.activeContacts[0].vertex.x+o.activeContacts[1].vertex.x)/2,p=(o.activeContacts[0].vertex.y+o.activeContacts[1].vertex.y)/2),i.bodyB===i.supports[0].body||!0===i.bodyA.isStatic?a.moveTo(u-8*i.normal.x,p-8*i.normal.y):a.moveTo(u+8*i.normal.x,p+8*i.normal.y),a.lineTo(u,p)}
-l.wireframes?a.strokeStyle="rgba(255,165,0,0.7)":a.strokeStyle="orange",a.lineWidth=1,a.stroke()},o.separations=function(e,t,n){var o,i,r,s,a,l=n,c=e.options;for(l.beginPath(),a=0;a1?1:0;p0;t--){var i=Math.floor(n.random()*(t+1)),o=e[t];e[t]=e[i],e[i]=o}return e},n.choose=function(e){return e[Math.floor(n.random()*e.length)]},n.isElement=function(e){return"undefined"!=typeof HTMLElement?e instanceof HTMLElement:!!(e&&e.nodeType&&e.nodeName)},n.isArray=function(e){return"[object Array]"===Object.prototype.toString.call(e)},n.isFunction=function(e){return"function"==typeof e},n.isPlainObject=function(e){return"object"==typeof e&&e.constructor===Object},n.isString=function(e){return"[object String]"===toString.call(e)},n.clamp=function(e,t,n){return en?n:e},n.sign=function(e){return e<0?-1:1},n.now=function(){if("undefined"!=typeof window&&window.performance){if(window.performance.now)return window.performance.now();if(window.performance.webkitNow)return window.performance.webkitNow()}return Date.now?Date.now():new Date-n._nowStartTime},n.random=function(t,n){return n=void 0!==n?n:1,(t=void 0!==t?t:0)+e()*(n-t)};var e=function(){return n._seed=(9301*n._seed+49297)%233280,n._seed/233280};n.colorToNumber=function(e){return 3==(e=e.replace("#","")).length&&(e=e.charAt(0)+e.charAt(0)+e.charAt(1)+e.charAt(1)+e.charAt(2)+e.charAt(2)),parseInt(e,16)},n.logLevel=1,n.log=function(){console&&n.logLevel>0&&n.logLevel<=3&&console.log.apply(console,["matter-js:"].concat(Array.prototype.slice.call(arguments)))},n.info=function(){console&&n.logLevel>0&&n.logLevel<=2&&console.info.apply(console,["matter-js:"].concat(Array.prototype.slice.call(arguments)))},n.warn=function(){console&&n.logLevel>0&&n.logLevel<=3&&console.warn.apply(console,["matter-js:"].concat(Array.prototype.slice.call(arguments)))},n.warnOnce=function(){var e=Array.prototype.slice.call(arguments).join(" ");n._warnedOnce[e]||(n.warn(e),n._warnedOnce[e]=!0)},n.deprecated=function(e,t,i){e[t]=n.chain((function(){n.warnOnce("🔅 deprecated 🔅",i)}),e[t])},n.nextId=function(){return n._nextId++},n.indexOf=function(e,t){if(e.indexOf)return e.indexOf(t);for(var n=0;ne.max.x&&(e.max.x=o.x),o.xe.max.y&&(e.max.y=o.y),o.y0?e.max.x+=n.x:e.min.x+=n.x,n.y>0?e.max.y+=n.y:e.min.y+=n.y)},n.contains=function(e,t){return t.x>=e.min.x&&t.x<=e.max.x&&t.y>=e.min.y&&t.y<=e.max.y},n.overlaps=function(e,t){return e.min.x<=t.max.x&&e.max.x>=t.min.x&&e.max.y>=t.min.y&&e.min.y<=t.max.y},n.translate=function(e,t){e.min.x+=t.x,e.max.x+=t.x,e.min.y+=t.y,e.max.y+=t.y},n.shift=function(e,t){var n=e.max.x-e.min.x,i=e.max.y-e.min.y;e.min.x=t.x,e.max.x=t.x+n,e.min.y=t.y,e.max.y=t.y+i}},function(e,t){var n={};e.exports=n,n.create=function(e,t){return{x:e||0,y:t||0}},n.clone=function(e){return{x:e.x,y:e.y}},n.magnitude=function(e){return Math.sqrt(e.x*e.x+e.y*e.y)},n.magnitudeSquared=function(e){return e.x*e.x+e.y*e.y},n.rotate=function(e,t,n){var i=Math.cos(t),o=Math.sin(t);n||(n={});var r=e.x*i-e.y*o;return n.y=e.x*o+e.y*i,n.x=r,n},n.rotateAbout=function(e,t,n,i){var o=Math.cos(t),r=Math.sin(t);i||(i={});var a=n.x+((e.x-n.x)*o-(e.y-n.y)*r);return i.y=n.y+((e.x-n.x)*r+(e.y-n.y)*o),i.x=a,i},n.normalise=function(e){var t=n.magnitude(e);return 0===t?{x:0,y:0}:{x:e.x/t,y:e.y/t}},n.dot=function(e,t){return e.x*t.x+e.y*t.y},n.cross=function(e,t){return e.x*t.y-e.y*t.x},n.cross3=function(e,t,n){return(t.x-e.x)*(n.y-e.y)-(t.y-e.y)*(n.x-e.x)},n.add=function(e,t,n){return n||(n={}),n.x=e.x+t.x,n.y=e.y+t.y,n},n.sub=function(e,t,n){return n||(n={}),n.x=e.x-t.x,n.y=e.y-t.y,n},n.mult=function(e,t){return{x:e.x*t,y:e.y*t}},n.div=function(e,t){return{x:e.x/t,y:e.y/t}},n.perp=function(e,t){return{x:(t=!0===t?-1:1)*-e.y,y:t*e.x}},n.neg=function(e){return{x:-e.x,y:-e.y}},n.angle=function(e,t){return Math.atan2(t.y-e.y,t.x-e.x)},n._temp=[n.create(),n.create(),n.create(),n.create(),n.create(),n.create()]},function(e,t,n){var i={};e.exports=i;var o=n(2),r=n(0);i.create=function(e,t){for(var n=[],i=0;i0)return!1}return!0},i.scale=function(e,t,n,r){if(1===t&&1===n)return e;var a,s;r=r||i.centre(e);for(var l=0;l=0?l-1:e.length-1],u=e[l],d=e[(l+1)%e.length],p=t[l0&&(r|=2),3===r)return!1;return 0!==r||null},i.hull=function(e){var t,n,i=[],r=[];for((e=e.slice(0)).sort((function(e,t){var n=e.x-t.x;return 0!==n?n:e.y-t.y})),n=0;n=2&&o.cross3(r[r.length-2],r[r.length-1],t)<=0;)r.pop();r.push(t)}for(n=e.length-1;n>=0;n-=1){for(t=e[n];i.length>=2&&o.cross3(i[i.length-2],i[i.length-1],t)<=0;)i.pop();i.push(t)}return i.pop(),r.pop(),i.concat(r)}},function(e,t,n){var i={};e.exports=i;var o=n(0);i.on=function(e,t,n){for(var i,o=t.split(" "),r=0;r0){n||(n={}),i=t.split(" ");for(var c=0;c0&&r.rotateAbout(a.position,n,e.position,a.position)}},i.setVelocity=function(e,t){e.positionPrev.x=e.position.x-t.x,e.positionPrev.y=e.position.y-t.y,e.velocity.x=t.x,e.velocity.y=t.y,e.speed=r.magnitude(e.velocity)},i.setAngularVelocity=function(e,t){e.anglePrev=e.angle-t,e.angularVelocity=t,e.angularSpeed=Math.abs(e.angularVelocity)},i.translate=function(e,t){i.setPosition(e,r.add(e.position,t))},i.rotate=function(e,t,n){if(n){var o=Math.cos(t),r=Math.sin(t),a=e.position.x-n.x,s=e.position.y-n.y;i.setPosition(e,{x:n.x+(a*o-s*r),y:n.y+(a*r+s*o)}),i.setAngle(e,e.angle+t)}else i.setAngle(e,e.angle+t)},i.scale=function(e,t,n,r){var a=0,s=0;r=r||e.position;for(var u=0;u0&&(a+=d.area,s+=d.inertia),d.position.x=r.x+(d.position.x-r.x)*t,d.position.y=r.y+(d.position.y-r.y)*n,l.update(d.bounds,d.vertices,e.velocity)}e.parts.length>1&&(e.area=a,e.isStatic||(i.setMass(e,e.density*a),i.setInertia(e,s))),e.circleRadius&&(t===n?e.circleRadius*=t:e.circleRadius=null)},i.update=function(e,t,n,i){var a=Math.pow(t*n*e.timeScale,2),s=1-e.frictionAir*n*e.timeScale,u=e.position.x-e.positionPrev.x,d=e.position.y-e.positionPrev.y;e.velocity.x=u*s*i+e.force.x/e.mass*a,e.velocity.y=d*s*i+e.force.y/e.mass*a,e.positionPrev.x=e.position.x,e.positionPrev.y=e.position.y,e.position.x+=e.velocity.x,e.position.y+=e.velocity.y,e.angularVelocity=(e.angle-e.anglePrev)*s*i+e.torque/e.inertia*a,e.anglePrev=e.angle,e.angle+=e.angularVelocity,e.speed=r.magnitude(e.velocity),e.angularSpeed=Math.abs(e.angularVelocity);for(var p=0;p0&&(f.position.x+=e.velocity.x,f.position.y+=e.velocity.y),0!==e.angularVelocity&&(o.rotate(f.vertices,e.angularVelocity,e.position),c.rotate(f.axes,e.angularVelocity),p>0&&r.rotateAbout(f.position,e.angularVelocity,e.position,f.position)),l.update(f.bounds,f.vertices,e.velocity)}},i.applyForce=function(e,t,n){e.force.x+=n.x,e.force.y+=n.y;var i=t.x-e.position.x,o=t.y-e.position.y;e.torque+=i*n.y-o*n.x},i._totalProperties=function(e){for(var t={mass:0,area:0,inertia:0,centre:{x:0,y:0}},n=1===e.parts.length?0:1;n0&&r.motion=r.sleepThreshold&&i.set(r,!0)):r.sleepCounter>0&&(r.sleepCounter-=1)}else i.set(r,!1)}},i.afterCollisions=function(e,t){for(var n=t*t*t,o=0;oi._motionWakeThreshold*n&&i.set(c,!1)}}}},i.set=function(e,t){var n=e.isSleeping;t?(e.isSleeping=!0,e.sleepCounter=e.sleepThreshold,e.positionImpulse.x=0,e.positionImpulse.y=0,e.positionPrev.x=e.position.x,e.positionPrev.y=e.position.y,e.anglePrev=e.angle,e.speed=0,e.angularSpeed=0,e.motion=0,n||o.trigger(e,"sleepStart")):(e.isSleeping=!1,e.sleepCounter=0,n&&o.trigger(e,"sleepEnd"))}},function(e,t,n){var i={};e.exports=i;var o=n(3),r=n(2),a=n(7),s=n(1),l=n(10),c=n(0);i._warming=.4,i._torqueDampen=1,i._minLength=1e-6,i.create=function(e){var t=e;t.bodyA&&!t.pointA&&(t.pointA={x:0,y:0}),t.bodyB&&!t.pointB&&(t.pointB={x:0,y:0});var n=t.bodyA?r.add(t.bodyA.position,t.pointA):t.pointA,i=t.bodyB?r.add(t.bodyB.position,t.pointB):t.pointB,o=r.magnitude(r.sub(n,i));t.length=void 0!==t.length?t.length:o,t.id=t.id||c.nextId(),t.label=t.label||"Constraint",t.type="constraint",t.stiffness=t.stiffness||(t.length>0?1:.7),t.damping=t.damping||0,t.angularStiffness=t.angularStiffness||0,t.angleA=t.bodyA?t.bodyA.angle:t.angleA,t.angleB=t.bodyB?t.bodyB.angle:t.angleB,t.plugin={};var a={visible:!0,lineWidth:2,strokeStyle:"#ffffff",type:"line",anchors:!0};return 0===t.length&&t.stiffness>.1?(a.type="pin",a.anchors=!1):t.stiffness<.9&&(a.type="spring"),t.render=c.extend(a,t.render),t},i.preSolveAll=function(e){for(var t=0;t0&&(d.position.x+=c.x,d.position.y+=c.y),0!==c.angle&&(o.rotate(d.vertices,c.angle,n.position),l.rotate(d.axes,c.angle),u>0&&r.rotateAbout(d.position,c.angle,n.position,d.position)),s.update(d.bounds,d.vertices,n.velocity)}c.angle*=i._warming,c.x*=i._warming,c.y*=i._warming}}},i.pointAWorld=function(e){return{x:(e.bodyA?e.bodyA.position.x:0)+e.pointA.x,y:(e.bodyA?e.bodyA.position.y:0)+e.pointA.y}},i.pointBWorld=function(e){return{x:(e.bodyB?e.bodyB.position.x:0)+e.pointB.x,y:(e.bodyB?e.bodyB.position.y:0)+e.pointB.y}}},function(e,t,n){var i={};e.exports=i;var o=n(17);i.create=function(e,t){var n=e.bodyA,o=e.bodyB,r=e.parentA,a=e.parentB,s={id:i.id(n,o),bodyA:n,bodyB:o,contacts:{},activeContacts:[],separation:0,isActive:!0,confirmedActive:!0,isSensor:n.isSensor||o.isSensor,timeCreated:t,timeUpdated:t,inverseMass:r.inverseMass+a.inverseMass,friction:Math.min(r.friction,a.friction),frictionStatic:Math.max(r.frictionStatic,a.frictionStatic),restitution:Math.max(r.restitution,a.restitution),slop:Math.max(r.slop,a.slop)};return i.update(s,e,t),s},i.update=function(e,t,n){var r=e.contacts,a=t.supports,s=e.activeContacts,l=t.parentA,c=t.parentB;if(e.collision=t,e.inverseMass=l.inverseMass+c.inverseMass,e.friction=Math.min(l.friction,c.friction),e.frictionStatic=Math.max(l.frictionStatic,c.frictionStatic),e.restitution=Math.max(l.restitution,c.restitution),e.slop=Math.max(l.slop,c.slop),s.length=0,t.collided){for(var u=0;u0&&o.area(C)1?(v=a.create(r.extend({parts:m.slice(0)},i)),a.setPosition(v,{x:e,y:t}),v):m[0]}},function(e,t,n){var i={};e.exports=i;var o=n(0);i.create=function(e){var t={};return e||o.log("Mouse.create: element was undefined, defaulting to document.body","warn"),t.element=e||document.body,t.absolute={x:0,y:0},t.position={x:0,y:0},t.mousedownPosition={x:0,y:0},t.mouseupPosition={x:0,y:0},t.offset={x:0,y:0},t.scale={x:1,y:1},t.wheelDelta=0,t.button=-1,t.pixelRatio=parseInt(t.element.getAttribute("data-pixel-ratio"),10)||1,t.sourceEvents={mousemove:null,mousedown:null,mouseup:null,mousewheel:null},t.mousemove=function(e){var n=i._getRelativeMousePosition(e,t.element,t.pixelRatio);e.changedTouches&&(t.button=0,e.preventDefault()),t.absolute.x=n.x,t.absolute.y=n.y,t.position.x=t.absolute.x*t.scale.x+t.offset.x,t.position.y=t.absolute.y*t.scale.y+t.offset.y,t.sourceEvents.mousemove=e},t.mousedown=function(e){var n=i._getRelativeMousePosition(e,t.element,t.pixelRatio);e.changedTouches?(t.button=0,e.preventDefault()):t.button=e.button,t.absolute.x=n.x,t.absolute.y=n.y,t.position.x=t.absolute.x*t.scale.x+t.offset.x,t.position.y=t.absolute.y*t.scale.y+t.offset.y,t.mousedownPosition.x=t.position.x,t.mousedownPosition.y=t.position.y,t.sourceEvents.mousedown=e},t.mouseup=function(e){var n=i._getRelativeMousePosition(e,t.element,t.pixelRatio);e.changedTouches&&e.preventDefault(),t.button=-1,t.absolute.x=n.x,t.absolute.y=n.y,t.position.x=t.absolute.x*t.scale.x+t.offset.x,t.position.y=t.absolute.y*t.scale.y+t.offset.y,t.mouseupPosition.x=t.position.x,t.mouseupPosition.y=t.position.y,t.sourceEvents.mouseup=e},t.mousewheel=function(e){t.wheelDelta=Math.max(-1,Math.min(1,e.wheelDelta||-e.detail)),e.preventDefault()},i.setElement(t,t.element),t},i.setElement=function(e,t){e.element=t,t.addEventListener("mousemove",e.mousemove),t.addEventListener("mousedown",e.mousedown),t.addEventListener("mouseup",e.mouseup),t.addEventListener("mousewheel",e.mousewheel),t.addEventListener("DOMMouseScroll",e.mousewheel),t.addEventListener("touchmove",e.mousemove),t.addEventListener("touchstart",e.mousedown),t.addEventListener("touchend",e.mouseup)},i.clearSourceEvents=function(e){e.sourceEvents.mousemove=null,e.sourceEvents.mousedown=null,e.sourceEvents.mouseup=null,e.sourceEvents.mousewheel=null,e.wheelDelta=0},i.setOffset=function(e,t){e.offset.x=t.x,e.offset.y=t.y,e.position.x=e.absolute.x*e.scale.x+e.offset.x,e.position.y=e.absolute.y*e.scale.y+e.offset.y},i.setScale=function(e,t){e.scale.x=t.x,e.scale.y=t.y,e.position.x=e.absolute.x*e.scale.x+e.offset.x,e.position.y=e.absolute.y*e.scale.y+e.offset.y},i._getRelativeMousePosition=function(e,t,n){var i,o,r=t.getBoundingClientRect(),a=document.documentElement||document.body.parentNode||document.body,s=void 0!==window.pageXOffset?window.pageXOffset:a.scrollLeft,l=void 0!==window.pageYOffset?window.pageYOffset:a.scrollTop,c=e.changedTouches;return c?(i=c[0].pageX-r.left-s,o=c[0].pageY-r.top-l):(i=e.pageX-r.left-s,o=e.pageY-r.top-l),{x:i/(t.clientWidth/(t.width||t.clientWidth)*n),y:o/(t.clientHeight/(t.height||t.clientHeight)*n)}}},function(e,t,n){var i={};e.exports=i;var o=n(14),r=n(9),a=n(1);i.collisions=function(e,t){for(var n=[],s=t.pairs.table,l=0;l1?1:0;d1?1:0;f0:0!=(e.mask&t.category)&&0!=(t.mask&e.category)}},function(e,t,n){var i={};e.exports=i;var o=n(3),r=n(2);i.collides=function(e,t,n){var a,s,l,c,u=!1;if(n){var d=e.parent,p=t.parent,f=d.speed*d.speed+d.angularSpeed*d.angularSpeed+p.speed*p.speed+p.angularSpeed*p.angularSpeed;u=n&&n.collided&&f<.2,c=n}else c={collided:!1,bodyA:e,bodyB:t};if(n&&u){var v=c.axisBody,m=v===e?t:e,y=[v.axes[n.axisNumber]];if(l=i._overlapAxes(v.vertices,m.vertices,y),c.reused=!0,l.overlap<=0)return c.collided=!1,c}else{if((a=i._overlapAxes(e.vertices,t.vertices,e.axes)).overlap<=0)return c.collided=!1,c;if((s=i._overlapAxes(t.vertices,e.vertices,t.axes)).overlap<=0)return c.collided=!1,c;a.overlapo?o=s:s=0?a.index-1:u.length-1],c.x=o.x-d.x,c.y=o.y-d.y,l=-r.dot(n,c),s=o,o=u[(a.index+1)%u.length],c.x=o.x-d.x,c.y=o.y-d.y,(i=-r.dot(n,c))r?(o.warn("Plugin.register:",i.toString(t),"was upgraded to",i.toString(e)),i._registry[e.name]=e):n-1},i.isFor=function(e,t){var n=e.for&&i.dependencyParse(e.for);return!e.for||t.name===n.name&&i.versionSatisfies(t.version,n.range)},i.use=function(e,t){if(e.uses=(e.uses||[]).concat(t||[]),0!==e.uses.length){for(var n=i.dependencies(e),r=o.topologicalSort(n),a=[],s=0;s0&&o.info(a.join(" "))}else o.warn("Plugin.use:",i.toString(e),"does not specify any dependencies to install.")},i.dependencies=function(e,t){var n=i.dependencyParse(e),r=n.name;if(!(r in(t=t||{}))){e=i.resolve(e)||e,t[r]=o.map(e.uses||[],(function(t){i.isPlugin(t)&&i.register(t);var r=i.dependencyParse(t),a=i.resolve(t);return a&&!i.versionSatisfies(a.version,r.range)?(o.warn("Plugin.dependencies:",i.toString(a),"does not satisfy",i.toString(r),"used by",i.toString(n)+"."),a._warned=!0,e._warned=!0):a||(o.warn("Plugin.dependencies:",i.toString(t),"used by",i.toString(n),"could not be resolved."),e._warned=!0),r.name}));for(var a=0;a=|>)?\s*((\d+)\.(\d+)\.(\d+))(-[0-9A-Za-z-]+)?$/;t.test(e)||o.warn("Plugin.versionParse:",e,"is not a valid version or range.");var n=t.exec(e),i=Number(n[4]),r=Number(n[5]),a=Number(n[6]);return{isRange:Boolean(n[1]||n[2]),version:n[3],range:e,operator:n[1]||n[2]||"",major:i,minor:r,patch:a,parts:[i,r,a],prerelease:n[7],number:1e8*i+1e4*r+a}},i.versionSatisfies=function(e,t){t=t||"*";var n=i.versionParse(t),o=i.versionParse(e);if(n.isRange){if("*"===n.operator||"*"===e)return!0;if(">"===n.operator)return o.number>n.number;if(">="===n.operator)return o.number>=n.number;if("~"===n.operator)return o.major===n.major&&o.minor===n.minor&&o.patch>=n.patch;if("^"===n.operator)return n.major>0?o.major===n.major&&o.number>=n.number:n.minor>0?o.minor===n.minor&&o.patch>=n.patch:o.patch===n.patch}return e===t||"*"===e}},function(e,t,n){var i={};e.exports=i;var o=n(0),r=n(5),a=n(1),s=n(4),l=n(2),c=n(12);!function(){var e,t;"undefined"!=typeof window&&(e=window.requestAnimationFrame||window.webkitRequestAnimationFrame||window.mozRequestAnimationFrame||window.msRequestAnimationFrame||function(e){window.setTimeout((function(){e(o.now())}),1e3/60)},t=window.cancelAnimationFrame||window.mozCancelAnimationFrame||window.webkitCancelAnimationFrame||window.msCancelAnimationFrame),i._goodFps=30,i._goodDelta=1e3/60,i.create=function(e){var t={controller:i,engine:null,element:null,canvas:null,mouse:null,frameRequestId:null,timing:{historySize:60,delta:0,deltaHistory:[],lastTime:0,lastTimestamp:0,lastElapsed:0,timestampElapsed:0,timestampElapsedHistory:[],engineDeltaHistory:[],engineElapsedHistory:[],elapsedHistory:[]},options:{width:800,height:600,pixelRatio:1,background:"#14151f",wireframeBackground:"#14151f",hasBounds:!!e.bounds,enabled:!0,wireframes:!0,showSleeping:!0,showDebug:!1,showStats:!1,showPerformance:!1,showBroadphase:!1,showBounds:!1,showVelocity:!1,showCollisions:!1,showSeparations:!1,showAxes:!1,showPositions:!1,showAngleIndicator:!1,showIds:!1,showVertexNumbers:!1,showConvexHulls:!1,showInternalEdges:!1,showMousePosition:!1}},n=o.extend(t,e);return n.canvas&&(n.canvas.width=n.options.width||n.canvas.width,n.canvas.height=n.options.height||n.canvas.height),n.mouse=e.mouse,n.engine=e.engine,n.canvas=n.canvas||d(n.options.width,n.options.height),n.context=n.canvas.getContext("2d"),n.textures={},n.bounds=n.bounds||{min:{x:0,y:0},max:{x:n.canvas.width,y:n.canvas.height}},1!==n.options.pixelRatio&&i.setPixelRatio(n,n.options.pixelRatio),o.isElement(n.element)?n.element.appendChild(n.canvas):n.canvas.parentNode||o.log("Render.create: options.element was undefined, render.canvas was created but not appended","warn"),n},i.run=function(t){!function o(r){t.frameRequestId=e(o),n(t,r),i.world(t,r),(t.options.showStats||t.options.showDebug)&&i.stats(t,t.context,r),(t.options.showPerformance||t.options.showDebug)&&i.performance(t,t.context,r)}()},i.stop=function(e){t(e.frameRequestId)},i.setPixelRatio=function(e,t){var n=e.options,i=e.canvas;"auto"===t&&(t=p(i)),n.pixelRatio=t,i.setAttribute("data-pixel-ratio",t),i.width=n.width*t,i.height=n.height*t,i.style.width=n.width+"px",i.style.height=n.height+"px"},i.lookAt=function(e,t,n,i){i=void 0===i||i,t=o.isArray(t)?t:[t],n=n||{x:0,y:0};for(var r={min:{x:1/0,y:1/0},max:{x:-1/0,y:-1/0}},a=0;ar.max.x&&(r.max.x=u.x),l.yr.max.y&&(r.max.y=u.y))}var d=r.max.x-r.min.x+2*n.x,p=r.max.y-r.min.y+2*n.y,f=e.canvas.height,v=e.canvas.width/f,m=d/p,y=1,g=1;m>v?g=m/v:y=v/m,e.options.hasBounds=!0,e.bounds.min.x=r.min.x,e.bounds.max.x=r.min.x+d*y,e.bounds.min.y=r.min.y,e.bounds.max.y=r.min.y+p*g,i&&(e.bounds.min.x+=.5*d-d*y*.5,e.bounds.max.x+=.5*d-d*y*.5,e.bounds.min.y+=.5*p-p*g*.5,e.bounds.max.y+=.5*p-p*g*.5),e.bounds.min.x-=n.x,e.bounds.max.x-=n.x,e.bounds.min.y-=n.y,e.bounds.max.y-=n.y,e.mouse&&(c.setScale(e.mouse,{x:(e.bounds.max.x-e.bounds.min.x)/e.canvas.width,y:(e.bounds.max.y-e.bounds.min.y)/e.canvas.height}),c.setOffset(e.mouse,e.bounds.min))},i.startViewTransform=function(e){var t=e.bounds.max.x-e.bounds.min.x,n=e.bounds.max.y-e.bounds.min.y,i=t/e.options.width,o=n/e.options.height;e.context.setTransform(e.options.pixelRatio/i,0,0,e.options.pixelRatio/o,0,0),e.context.translate(-e.bounds.min.x,-e.bounds.min.y)},i.endViewTransform=function(e){e.context.setTransform(e.options.pixelRatio,0,0,e.options.pixelRatio,0,0)},i.world=function(e,t){var n,u=o.now(),d=e.engine,p=d.world,f=e.canvas,m=e.context,y=e.options,g=e.timing,x=r.allBodies(p),h=r.allConstraints(p),b=y.wireframes?y.wireframeBackground:y.background,S=[],w=[],A={timestamp:d.timing.timestamp};if(s.trigger(e,"beforeRender",A),e.currentBackground!==b&&v(e,b),m.globalCompositeOperation="source-in",m.fillStyle="transparent",m.fillRect(0,0,f.width,f.height),m.globalCompositeOperation="source-over",y.hasBounds){for(n=0;n1?1:0;a1?1:0;s1?1:0;r1?1:0;s1?1:0;r1?1:0;r1?1:0;o0)){var u=i.activeContacts[0].vertex.x,d=i.activeContacts[0].vertex.y;2===i.activeContacts.length&&(u=(i.activeContacts[0].vertex.x+i.activeContacts[1].vertex.x)/2,d=(i.activeContacts[0].vertex.y+i.activeContacts[1].vertex.y)/2),o.bodyB===o.supports[0].body||!0===o.bodyA.isStatic?s.moveTo(u-8*o.normal.x,d-8*o.normal.y):s.moveTo(u+8*o.normal.x,d+8*o.normal.y),s.lineTo(u,d)}l.wireframes?s.strokeStyle="rgba(255,165,0,0.7)":s.strokeStyle="orange",s.lineWidth=1,s.stroke()},i.separations=function(e,t,n){var i,o,r,a,s,l=n,c=e.options;for(l.beginPath(),s=0;s0&&c.trigger(e,"collisionStart",{pairs:A.collisionStart}),r.preSolvePosition(A.list),m=0;m0&&c.trigger(e,"collisionActive",{pairs:A.collisionActive}),A.collisionEnd.length>0&&c.trigger(e,"collisionEnd",{pairs:A.collisionEnd}),i._bodiesClearForces(b),c.trigger(e,"afterUpdate",h),e.timing.lastElapsed=p.now()-f,e},i.merge=function(e,t){if(p.extend(e,t),t.world){e.world=t.world,i.clear(e);for(var n=u.allBodies(e.world),r=0;rf.friction*f.frictionStatic*L*n&&(O=T,V=a.clamp(f.friction*R*n,-O,O));var F=r.cross(P,g),D=r.cross(M,g),H=b/(m.inverseMass+y.inverseMass+m.inverseInertia*F*F+y.inverseInertia*D*D);if(E*=H,V*=H,k<0&&k*k>i._restingThresh*n)w.normalImpulse=0;else{var j=w.normalImpulse;w.normalImpulse=Math.min(w.normalImpulse+E,0),E=w.normalImpulse-j}if(I*I>i._restingThreshTangent*n)w.tangentImpulse=0;else{var W=w.tangentImpulse;w.tangentImpulse=a.clamp(w.tangentImpulse+V,-O,O),V=w.tangentImpulse-W}o.x=g.x*E+x.x*V,o.y=g.y*E+x.y*V,m.isStatic||m.isSleeping||(m.positionPrev.x+=o.x*m.inverseMass,m.positionPrev.y+=o.y*m.inverseMass,m.anglePrev+=r.cross(P,o)*m.inverseInertia),y.isStatic||y.isSleeping||(y.positionPrev.x-=o.x*y.inverseMass,y.positionPrev.y-=o.y*y.inverseMass,y.anglePrev-=r.cross(M,o)*y.inverseInertia)}}}}},function(e,t,n){var i={};e.exports=i;var o=n(9),r=n(0);i._pairMaxIdleLife=1e3,i.create=function(e){return r.extend({table:{},list:[],collisionStart:[],collisionActive:[],collisionEnd:[]},e)},i.update=function(e,t,n){var i,r,a,s,l=e.list,c=e.table,u=e.collisionStart,d=e.collisionEnd,p=e.collisionActive;for(u.length=0,d.length=0,p.length=0,s=0;si._pairMaxIdleLife&&c.push(a);for(a=0;au.bounds.max.x||f.bounds.max.yu.bounds.max.y))){var v=i._getRegion(e,f);if(!f.region||v.id!==f.region.id||o){f.region&&!o||(f.region=v);var m=i._regionUnion(v,f.region);for(a=m.startCol;a<=m.endCol;a++)for(s=m.startRow;s<=m.endRow;s++){l=d[c=i._getBucketId(a,s)];var y=a>=v.startCol&&a<=v.endCol&&s>=v.startRow&&s<=v.endRow,g=a>=f.region.startCol&&a<=f.region.endCol&&s>=f.region.startRow&&s<=f.region.endRow;!y&&g&&g&&l&&i._bucketRemoveBody(e,l,f),(f.region===v||y&&!g||o)&&(l||(l=i._createBucket(d,c)),i._bucketAddBody(e,l,f))}f.region=v,p=!0}}}p&&(e.pairsList=i._createActivePairsList(e))},i.clear=function(e){e.buckets={},e.pairs={},e.pairsList=[]},i._regionUnion=function(e,t){var n=Math.min(e.startCol,t.startCol),o=Math.max(e.endCol,t.endCol),r=Math.min(e.startRow,t.startRow),a=Math.max(e.endRow,t.endRow);return i._createRegion(n,o,r,a)},i._getRegion=function(e,t){var n=t.bounds,o=Math.floor(n.min.x/e.bucketWidth),r=Math.floor(n.max.x/e.bucketWidth),a=Math.floor(n.min.y/e.bucketHeight),s=Math.floor(n.max.y/e.bucketHeight);return i._createRegion(o,r,a,s)},i._createRegion=function(e,t,n,i){return{id:e+","+t+","+n+","+i,startCol:e,endCol:t,startRow:n,endRow:i}},i._getBucketId=function(e,t){return"C"+e+"R"+t},i._createBucket=function(e,t){return e[t]=[]},i._bucketAddBody=function(e,t,n){for(var i=0;i0?i.push(n):delete e.pairs[t[o]];return i}},function(e,t,n){var i=e.exports=n(23);i.Axes=n(10),i.Bodies=n(11),i.Body=n(6),i.Bounds=n(1),i.Common=n(0),i.Composite=n(5),i.Composites=n(24),i.Constraint=n(8),i.Contact=n(17),i.Detector=n(13),i.Engine=n(18),i.Events=n(4),i.Grid=n(21),i.Mouse=n(12),i.MouseConstraint=n(25),i.Pair=n(9),i.Pairs=n(20),i.Plugin=n(15),i.Query=n(26),i.Render=n(16),i.Resolver=n(19),i.Runner=n(27),i.SAT=n(14),i.Sleeping=n(7),i.Svg=n(28),i.Vector=n(2),i.Vertices=n(3),i.World=n(29),i.Engine.run=i.Runner.run,i.Common.deprecated(i.Engine,"run","Engine.run ➤ use Matter.Runner.run(engine) instead")},function(e,t,n){var i={};e.exports=i;var o=n(15),r=n(0);i.name="matter-js",i.version="0.17.1",i.uses=[],i.used=[],i.use=function(){o.use(i,Array.prototype.slice.call(arguments))},i.before=function(e,t){return e=e.replace(/^Matter./,""),r.chainPathBefore(i,e,t)},i.after=function(e,t){return e=e.replace(/^Matter./,""),r.chainPathAfter(i,e,t)}},function(e,t,n){var i={};e.exports=i;var o=n(5),r=n(8),a=n(0),s=n(6),l=n(11),c=a.deprecated;i.stack=function(e,t,n,i,r,a,l){for(var c,u=o.create({label:"Stack"}),d=e,p=t,f=0,v=0;vm&&(m=x),s.translate(g,{x:.5*h,y:.5*x}),d=g.bounds.max.x+r,o.addBody(u,g),c=g,f+=1}else d+=r}p+=m+a,d=e}return u},i.chain=function(e,t,n,i,s,l){for(var c=e.bodies,u=1;u0)for(c=0;c0&&(p=f[c-1+(l-1)*t],o.addConstraint(e,r.create(a.extend({bodyA:p,bodyB:d},s)))),i&&cp||a<(c=p-c)||a>n-1-c))return 1===d&&s.translate(u,{x:(a+(n%2==1?1:-1))*f,y:0}),l(e+(u?a*f:0)+a*r,i,a,c,u,d)}))},i.newtonsCradle=function(e,t,n,i,a){for(var s=o.create({label:"Newtons Cradle"}),c=0;c1?1:0;ue.deltaMax?e.deltaMax:i)/e.delta,e.delta=i),0!==e.timeScalePrev&&(s*=a.timeScale/e.timeScalePrev),0===a.timeScale&&(s=0),e.timeScalePrev=a.timeScale,e.correction=s,e.frameCounter+=1,n-e.counterTimestamp>=1e3&&(e.fps=e.frameCounter*((n-e.counterTimestamp)/1e3),e.counterTimestamp=n,e.frameCounter=0),o.trigger(e,"tick",l),o.trigger(e,"beforeUpdate",l),r.update(t,i,s),o.trigger(e,"afterUpdate",l),o.trigger(e,"afterTick",l)},i.stop=function(e){t(e.frameRequestId)},i.start=function(e,t){i.run(e,t)}}()},function(e,t,n){var i={};e.exports=i;n(1);var o=n(0);i.pathToVertices=function(e,t){"undefined"==typeof window||"SVGPathSeg"in window||o.warn("Svg.pathToVertices: SVGPathSeg not defined, a polyfill is required.");var n,r,a,s,l,c,u,d,p,f,v,m=[],y=0,g=0,x=0;t=t||15;var h=function(e,t,n){var i=n%2==1&&n>1;if(!p||e!=p.x||t!=p.y){p&&i?(f=p.x,v=p.y):(f=0,v=0);var o={x:f+e,y:v+t};!i&&p||(p=o),m.push(o),g=f+e,x=v+t}},b=function(e){var t=e.pathSegTypeAsLetter.toUpperCase();if("Z"!==t){switch(t){case"M":case"L":case"T":case"C":case"S":case"Q":g=e.x,x=e.y;break;case"H":g=e.x;break;case"V":x=e.y}h(g,x,e.pathSegType)}};for(i._svgPathToAbsolute(e),a=e.getTotalLength(),c=[],n=0;n
-
Matter.js Demo
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
> *Matter.js* is a JavaScript 2D rigid body physics engine for the web
-[brm.io/matter-js](http://brm.io/matter-js/)
+[brm.io/matter-js](https://brm.io/matter-js/)
-[Demos](#demos) - [Gallery](#gallery) - [Features](#features) - [Plugins](#plugins) - [Install](#install) - [Usage](#usage) - [Examples](#examples) - [Docs](#documentation) - [Wiki](https://github.com/liabru/matter-js/wiki) - [References](#references) - [License](#license)
+[Demos](#demos) ・ [Gallery](#gallery) ・ [Features](#features) ・ [Plugins](#plugins) ・ [Install](#install) ・ [Usage](#usage) ・ [Examples](#examples) ・ [Docs](#documentation) ・ [Wiki](https://github.com/liabru/matter-js/wiki) ・ [References](#references) ・ [License](#license)
[](https://travis-ci.org/liabru/matter-js)
@@ -14,51 +14,55 @@