diff --git a/CM2030 Graphics Programming/Topic 4/4.2.3/index.html b/CM2030 Graphics Programming/Topic 4/4.2.3/index.html
new file mode 100644
index 0000000..3f16bcd
--- /dev/null
+++ b/CM2030 Graphics Programming/Topic 4/4.2.3/index.html
@@ -0,0 +1,16 @@
+
+
+
+
+ graphicsProgramming - Coursera
+
+
+
+
+
+
+
+
+
+
+
diff --git a/CM2030 Graphics Programming/Topic 4/4.2.3/libraries/.DS_Store b/CM2030 Graphics Programming/Topic 4/4.2.3/libraries/.DS_Store
new file mode 100644
index 0000000..5008ddf
Binary files /dev/null and b/CM2030 Graphics Programming/Topic 4/4.2.3/libraries/.DS_Store differ
diff --git a/CM2030 Graphics Programming/Topic 4/4.2.3/libraries/matter.js b/CM2030 Graphics Programming/Topic 4/4.2.3/libraries/matter.js
new file mode 100644
index 0000000..b36c3f5
--- /dev/null
+++ b/CM2030 Graphics Programming/Topic 4/4.2.3/libraries/matter.js
@@ -0,0 +1,10361 @@
+/**
+* matter-js 0.14.2 by @liabru 2018-06-11
+* http://brm.io/matter-js/
+* License MIT
+*/
+
+/**
+ * The MIT License (MIT)
+ *
+ * Copyright (c) Liam Brummitt and contributors.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+(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) {
+ Vector.rotateAbout(part.position, delta, body.position, part.position);
+ }
+ }
+ };
+
+ /**
+ * Sets the linear velocity of the body instantly. Position, angle, force etc. are unchanged. See also `Body.applyForce`.
+ * @method setVelocity
+ * @param {body} body
+ * @param {vector} velocity
+ */
+ Body.setVelocity = function(body, velocity) {
+ body.positionPrev.x = body.position.x - velocity.x;
+ body.positionPrev.y = body.position.y - velocity.y;
+ body.velocity.x = velocity.x;
+ body.velocity.y = velocity.y;
+ body.speed = Vector.magnitude(body.velocity);
+ };
+
+ /**
+ * Sets the angular velocity of the body instantly. Position, angle, force etc. are unchanged. See also `Body.applyForce`.
+ * @method setAngularVelocity
+ * @param {body} body
+ * @param {number} velocity
+ */
+ Body.setAngularVelocity = function(body, velocity) {
+ body.anglePrev = body.angle - velocity;
+ body.angularVelocity = velocity;
+ body.angularSpeed = Math.abs(body.angularVelocity);
+ };
+
+ /**
+ * Moves a body by a given vector relative to its current position, without imparting any velocity.
+ * @method translate
+ * @param {body} body
+ * @param {vector} translation
+ */
+ Body.translate = function(body, translation) {
+ Body.setPosition(body, Vector.add(body.position, translation));
+ };
+
+ /**
+ * Rotates a body by a given angle relative to its current angle, without imparting any angular velocity.
+ * @method rotate
+ * @param {body} body
+ * @param {number} rotation
+ * @param {vector} [point]
+ */
+ Body.rotate = function(body, rotation, point) {
+ if (!point) {
+ Body.setAngle(body, body.angle + rotation);
+ } else {
+ var cos = Math.cos(rotation),
+ sin = Math.sin(rotation),
+ 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.setAngle(body, body.angle + rotation);
+ }
+ };
+
+ /**
+ * Scales the body, including updating physical properties (mass, area, axes, inertia), from a world-space point (default is body centre).
+ * @method scale
+ * @param {body} body
+ * @param {number} scaleX
+ * @param {number} scaleY
+ * @param {vector} [point]
+ */
+ Body.scale = function(body, scaleX, scaleY, point) {
+ var totalArea = 0,
+ totalInertia = 0;
+
+ point = point || body.position;
+
+ for (var i = 0; i < body.parts.length; i++) {
+ var part = body.parts[i];
+
+ // scale vertices
+ Vertices.scale(part.vertices, scaleX, scaleY, point);
+
+ // update properties
+ part.axes = Axes.fromVertices(part.vertices);
+ part.area = Vertices.area(part.vertices);
+ Body.setMass(part, body.density * part.area);
+
+ // update inertia (requires vertices to be at origin)
+ Vertices.translate(part.vertices, { x: -part.position.x, y: -part.position.y });
+ Body.setInertia(part, Body._inertiaScale * Vertices.inertia(part.vertices, part.mass));
+ Vertices.translate(part.vertices, { x: part.position.x, y: part.position.y });
+
+ if (i > 0) {
+ totalArea += part.area;
+ totalInertia += part.inertia;
+ }
+
+ // scale position
+ part.position.x = point.x + (part.position.x - point.x) * scaleX;
+ part.position.y = point.y + (part.position.y - point.y) * scaleY;
+
+ // update bounds
+ Bounds.update(part.bounds, part.vertices, body.velocity);
+ }
+
+ // handle parent body
+ if (body.parts.length > 1) {
+ body.area = totalArea;
+
+ if (!body.isStatic) {
+ Body.setMass(body, body.density * totalArea);
+ Body.setInertia(body, totalInertia);
+ }
+ }
+
+ // handle circles
+ if (body.circleRadius) {
+ if (scaleX === scaleY) {
+ body.circleRadius *= scaleX;
+ } else {
+ // body is no longer a circle
+ body.circleRadius = null;
+ }
+ }
+ };
+
+ /**
+ * Performs a simulation step for the given `body`, including updating position and angle using Verlet integration.
+ * @method update
+ * @param {body} body
+ * @param {number} deltaTime
+ * @param {number} timeScale
+ * @param {number} correction
+ */
+ Body.update = function(body, deltaTime, timeScale, correction) {
+ var deltaTimeSquared = Math.pow(deltaTime * timeScale * body.timeScale, 2);
+
+ // from the previous step
+ var frictionAir = 1 - body.frictionAir * timeScale * body.timeScale,
+ velocityPrevX = body.position.x - body.positionPrev.x,
+ velocityPrevY = body.position.y - body.positionPrev.y;
+
+ // update velocity with Verlet integration
+ body.velocity.x = (velocityPrevX * frictionAir * correction) + (body.force.x / body.mass) * deltaTimeSquared;
+ body.velocity.y = (velocityPrevY * frictionAir * correction) + (body.force.y / body.mass) * deltaTimeSquared;
+
+ body.positionPrev.x = body.position.x;
+ body.positionPrev.y = body.position.y;
+ body.position.x += body.velocity.x;
+ body.position.y += body.velocity.y;
+
+ // update angular velocity with Verlet integration
+ body.angularVelocity = ((body.angle - body.anglePrev) * frictionAir * correction) + (body.torque / body.inertia) * deltaTimeSquared;
+ body.anglePrev = body.angle;
+ body.angle += body.angularVelocity;
+
+ // track speed and acceleration
+ body.speed = Vector.magnitude(body.velocity);
+ body.angularSpeed = Math.abs(body.angularVelocity);
+
+ // transform the body geometry
+ for (var i = 0; i < body.parts.length; i++) {
+ var part = body.parts[i];
+
+ Vertices.translate(part.vertices, body.velocity);
+
+ if (i > 0) {
+ part.position.x += body.velocity.x;
+ part.position.y += body.velocity.y;
+ }
+
+ if (body.angularVelocity !== 0) {
+ Vertices.rotate(part.vertices, body.angularVelocity, body.position);
+ Axes.rotate(part.axes, body.angularVelocity);
+ if (i > 0) {
+ Vector.rotateAbout(part.position, body.angularVelocity, body.position, part.position);
+ }
+ }
+
+ Bounds.update(part.bounds, part.vertices, body.velocity);
+ }
+ };
+
+ /**
+ * Applies a force to a body from a given world-space position, including resulting torque.
+ * @method applyForce
+ * @param {body} body
+ * @param {vector} position
+ * @param {vector} force
+ */
+ Body.applyForce = function(body, position, force) {
+ body.force.x += force.x;
+ body.force.y += force.y;
+ var offset = { x: position.x - body.position.x, y: position.y - body.position.y };
+ body.torque += offset.x * force.y - offset.y * force.x;
+ };
+
+ /**
+ * Returns the sums of the properties of all compound parts of the parent body.
+ * @method _totalProperties
+ * @private
+ * @param {body} body
+ * @return {}
+ */
+ Body._totalProperties = function(body) {
+ // from equations at:
+ // https://ecourses.ou.edu/cgi-bin/ebook.cgi?doc=&topic=st&chap_sec=07.2&page=theory
+ // http://output.to/sideway/default.asp?qno=121100087
+
+ var properties = {
+ mass: 0,
+ area: 0,
+ inertia: 0,
+ centre: { x: 0, y: 0 }
+ };
+
+ // sum the properties of all compound parts of the parent body
+ for (var i = body.parts.length === 1 ? 0 : 1; i < body.parts.length; i++) {
+ var part = body.parts[i],
+ mass = part.mass !== Infinity ? part.mass : 1;
+
+ properties.mass += mass;
+ properties.area += part.area;
+ properties.inertia += part.inertia;
+ properties.centre = Vector.add(properties.centre, Vector.mult(part.position, mass));
+ }
+
+ properties.centre = Vector.div(properties.centre, properties.mass);
+
+ return properties;
+ };
+
+ /*
+ *
+ * Events Documentation
+ *
+ */
+
+ /**
+ * Fired when a body starts sleeping (where `this` is the body).
+ *
+ * @event sleepStart
+ * @this {body} The body that has started sleeping
+ * @param {} event An event object
+ * @param {} event.source The source object of the event
+ * @param {} event.name The name of the event
+ */
+
+ /**
+ * Fired when a body ends sleeping (where `this` is the body).
+ *
+ * @event sleepEnd
+ * @this {body} The body that has ended sleeping
+ * @param {} event An event object
+ * @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 `Body.create` by `Common.nextId`.
+ *
+ * @property id
+ * @type number
+ */
+
+ /**
+ * A `String` denoting the type of object.
+ *
+ * @property type
+ * @type string
+ * @default "body"
+ * @readOnly
+ */
+
+ /**
+ * An arbitrary `String` name to help the user identify and manage bodies.
+ *
+ * @property label
+ * @type string
+ * @default "Body"
+ */
+
+ /**
+ * An array of bodies that make up this body.
+ * The first body in the array must always be a self reference to the current body instance.
+ * All bodies in the `parts` array together form a single rigid compound body.
+ * Parts are allowed to overlap, have gaps or holes or even form concave bodies.
+ * Parts themselves should never be added to a `World`, only the parent body should be.
+ * Use `Body.setParts` when setting parts to ensure correct updates of all properties.
+ *
+ * @property parts
+ * @type body[]
+ */
+
+ /**
+ * An object reserved for storing plugin-specific properties.
+ *
+ * @property plugin
+ * @type {}
+ */
+
+ /**
+ * A self reference if the body is _not_ a part of another body.
+ * Otherwise this is a reference to the body that this is a part of.
+ * See `body.parts`.
+ *
+ * @property parent
+ * @type body
+ */
+
+ /**
+ * A `Number` specifying the angle of the body, in radians.
+ *
+ * @property angle
+ * @type number
+ * @default 0
+ */
+
+ /**
+ * An array of `Vector` objects that specify the convex hull of the rigid body.
+ * These should be provided about the origin `(0, 0)`. E.g.
+ *
+ * [{ x: 0, y: 0 }, { x: 25, y: 50 }, { x: 50, y: 0 }]
+ *
+ * When passed via `Body.create`, the vertices are translated relative to `body.position` (i.e. world-space, and constantly updated by `Body.update` during simulation).
+ * The `Vector` objects are also augmented with additional properties required for efficient collision detection.
+ *
+ * Other properties such as `inertia` and `bounds` are automatically calculated from the passed vertices (unless provided via `options`).
+ * Concave hulls are not currently supported. The module `Matter.Vertices` contains useful methods for working with vertices.
+ *
+ * @property vertices
+ * @type vector[]
+ */
+
+ /**
+ * A `Vector` that specifies the current world-space position of the body.
+ *
+ * @property position
+ * @type vector
+ * @default { x: 0, y: 0 }
+ */
+
+ /**
+ * A `Vector` that specifies the force to apply in the current step. It is zeroed after every `Body.update`. See also `Body.applyForce`.
+ *
+ * @property force
+ * @type vector
+ * @default { x: 0, y: 0 }
+ */
+
+ /**
+ * A `Number` that specifies the torque (turning force) to apply in the current step. It is zeroed after every `Body.update`.
+ *
+ * @property torque
+ * @type number
+ * @default 0
+ */
+
+ /**
+ * A `Number` that _measures_ the current speed of the body after the last `Body.update`. It is read-only and always positive (it's the magnitude of `body.velocity`).
+ *
+ * @readOnly
+ * @property speed
+ * @type number
+ * @default 0
+ */
+
+ /**
+ * A `Number` that _measures_ the current angular speed of the body after the last `Body.update`. It is read-only and always positive (it's the magnitude of `body.angularVelocity`).
+ *
+ * @readOnly
+ * @property angularSpeed
+ * @type number
+ * @default 0
+ */
+
+ /**
+ * A `Vector` that _measures_ the current velocity of the body after the last `Body.update`. It is read-only.
+ * If you need to modify a body's velocity directly, you should either apply a force or simply change the body's `position` (as the engine uses position-Verlet integration).
+ *
+ * @readOnly
+ * @property velocity
+ * @type vector
+ * @default { x: 0, y: 0 }
+ */
+
+ /**
+ * A `Number` that _measures_ the current angular velocity of the body after the last `Body.update`. It is read-only.
+ * If you need to modify a body's angular velocity directly, you should apply a torque or simply change the body's `angle` (as the engine uses position-Verlet integration).
+ *
+ * @readOnly
+ * @property angularVelocity
+ * @type number
+ * @default 0
+ */
+
+ /**
+ * A flag that indicates whether a body is considered static. A static body can never change position or angle and is completely fixed.
+ * If you need to set a body as static after its creation, you should use `Body.setStatic` as this requires more than just setting this flag.
+ *
+ * @property isStatic
+ * @type boolean
+ * @default false
+ */
+
+ /**
+ * A flag that indicates whether a body is a sensor. Sensor triggers collision events, but doesn't react with colliding body physically.
+ *
+ * @property isSensor
+ * @type boolean
+ * @default false
+ */
+
+ /**
+ * A flag that indicates whether the body is considered sleeping. A sleeping body acts similar to a static body, except it is only temporary and can be awoken.
+ * If you need to set a body as sleeping, you should use `Sleeping.set` as this requires more than just setting this flag.
+ *
+ * @property isSleeping
+ * @type boolean
+ * @default false
+ */
+
+ /**
+ * A `Number` that _measures_ the amount of movement a body currently has (a combination of `speed` and `angularSpeed`). It is read-only and always positive.
+ * It is used and updated by the `Matter.Sleeping` module during simulation to decide if a body has come to rest.
+ *
+ * @readOnly
+ * @property motion
+ * @type number
+ * @default 0
+ */
+
+ /**
+ * A `Number` that defines the number of updates in which this body must have near-zero velocity before it is set as sleeping by the `Matter.Sleeping` module (if sleeping is enabled by the engine).
+ *
+ * @property sleepThreshold
+ * @type number
+ * @default 60
+ */
+
+ /**
+ * A `Number` that defines the density of the body, that is its mass per unit area.
+ * If you pass the density via `Body.create` the `mass` property is automatically calculated for you based on the size (area) of the object.
+ * This is generally preferable to simply setting mass and allows for more intuitive definition of materials (e.g. rock has a higher density than wood).
+ *
+ * @property density
+ * @type number
+ * @default 0.001
+ */
+
+ /**
+ * A `Number` that defines the mass of the body, although it may be more appropriate to specify the `density` property instead.
+ * If you modify this value, you must also modify the `body.inverseMass` property (`1 / mass`).
+ *
+ * @property mass
+ * @type number
+ */
+
+ /**
+ * A `Number` that defines the inverse mass of the body (`1 / mass`).
+ * If you modify this value, you must also modify the `body.mass` property.
+ *
+ * @property inverseMass
+ * @type number
+ */
+
+ /**
+ * A `Number` that defines the moment of inertia (i.e. second moment of area) of the body.
+ * It is automatically calculated from the given convex hull (`vertices` array) and density in `Body.create`.
+ * If you modify this value, you must also modify the `body.inverseInertia` property (`1 / inertia`).
+ *
+ * @property inertia
+ * @type number
+ */
+
+ /**
+ * A `Number` that defines the inverse moment of inertia of the body (`1 / inertia`).
+ * If you modify this value, you must also modify the `body.inertia` property.
+ *
+ * @property inverseInertia
+ * @type number
+ */
+
+ /**
+ * A `Number` that defines the restitution (elasticity) of the body. The value is always positive and is in the range `(0, 1)`.
+ * A value of `0` means collisions may be perfectly inelastic and no bouncing may occur.
+ * A value of `0.8` means the body may bounce back with approximately 80% of its kinetic energy.
+ * Note that collision response is based on _pairs_ of bodies, and that `restitution` values are _combined_ with the following formula:
+ *
+ * Math.max(bodyA.restitution, bodyB.restitution)
+ *
+ * @property restitution
+ * @type number
+ * @default 0
+ */
+
+ /**
+ * A `Number` that defines the friction of the body. The value is always positive and is in the range `(0, 1)`.
+ * A value of `0` means that the body may slide indefinitely.
+ * A value of `1` means the body may come to a stop almost instantly after a force is applied.
+ *
+ * The effects of the value may be non-linear.
+ * High values may be unstable depending on the body.
+ * The engine uses a Coulomb friction model including static and kinetic friction.
+ * Note that collision response is based on _pairs_ of bodies, and that `friction` values are _combined_ with the following formula:
+ *
+ * Math.min(bodyA.friction, bodyB.friction)
+ *
+ * @property friction
+ * @type number
+ * @default 0.1
+ */
+
+ /**
+ * A `Number` that defines the static friction of the body (in the Coulomb friction model).
+ * A value of `0` means the body will never 'stick' when it is nearly stationary and only dynamic `friction` is used.
+ * The higher the value (e.g. `10`), the more force it will take to initially get the body moving when nearly stationary.
+ * This value is multiplied with the `friction` property to make it easier to change `friction` and maintain an appropriate amount of static friction.
+ *
+ * @property frictionStatic
+ * @type number
+ * @default 0.5
+ */
+
+ /**
+ * A `Number` that defines the air friction of the body (air resistance).
+ * A value of `0` means the body will never slow as it moves through space.
+ * The higher the value, the faster a body slows when moving through space.
+ * The effects of the value are non-linear.
+ *
+ * @property frictionAir
+ * @type number
+ * @default 0.01
+ */
+
+ /**
+ * An `Object` that specifies the collision filtering properties of this body.
+ *
+ * Collisions between two bodies will obey the following rules:
+ * - If the two bodies have the same non-zero value of `collisionFilter.group`,
+ * they will always collide if the value is positive, and they will never collide
+ * if the value is negative.
+ * - If the two bodies have different values of `collisionFilter.group` or if one
+ * (or both) of the bodies has a value of 0, then the category/mask rules apply as follows:
+ *
+ * Each body belongs to a collision category, given by `collisionFilter.category`. This
+ * value is used as a bit field and the category should have only one bit set, meaning that
+ * the value of this property is a power of two in the range [1, 2^31]. Thus, there are 32
+ * different collision categories available.
+ *
+ * Each body also defines a collision bitmask, given by `collisionFilter.mask` which specifies
+ * the categories it collides with (the value is the bitwise AND value of all these categories).
+ *
+ * Using the category/mask rules, two bodies `A` and `B` collide if each includes the other's
+ * category in its mask, i.e. `(categoryA & maskB) !== 0` and `(categoryB & maskA) !== 0`
+ * are both true.
+ *
+ * @property collisionFilter
+ * @type object
+ */
+
+ /**
+ * An Integer `Number`, that specifies the collision group this body belongs to.
+ * See `body.collisionFilter` for more information.
+ *
+ * @property collisionFilter.group
+ * @type object
+ * @default 0
+ */
+
+ /**
+ * A bit field that specifies the collision category this body belongs to.
+ * The category value should have only one bit set, for example `0x0001`.
+ * This means there are up to 32 unique collision categories available.
+ * See `body.collisionFilter` for more information.
+ *
+ * @property collisionFilter.category
+ * @type object
+ * @default 1
+ */
+
+ /**
+ * A bit mask that specifies the collision categories this body may collide with.
+ * See `body.collisionFilter` for more information.
+ *
+ * @property collisionFilter.mask
+ * @type object
+ * @default -1
+ */
+
+ /**
+ * A `Number` that specifies a tolerance on how far a body is allowed to 'sink' or rotate into other bodies.
+ * Avoid changing this value unless you understand the purpose of `slop` in physics engines.
+ * The default should generally suffice, although very large bodies may require larger values for stable stacking.
+ *
+ * @property slop
+ * @type number
+ * @default 0.05
+ */
+
+ /**
+ * A `Number` that allows per-body time scaling, e.g. a force-field where bodies inside are in slow-motion, while others are at full speed.
+ *
+ * @property timeScale
+ * @type number
+ * @default 1
+ */
+
+ /**
+ * An `Object` that defines the rendering properties to be consumed by the module `Matter.Render`.
+ *
+ * @property render
+ * @type object
+ */
+
+ /**
+ * A flag that indicates if the body should be rendered.
+ *
+ * @property render.visible
+ * @type boolean
+ * @default true
+ */
+
+ /**
+ * Sets the opacity to use when rendering.
+ *
+ * @property render.opacity
+ * @type number
+ * @default 1
+ */
+
+ /**
+ * An `Object` that defines the sprite properties to use when rendering, if any.
+ *
+ * @property render.sprite
+ * @type object
+ */
+
+ /**
+ * An `String` that defines the path to the image to use as the sprite texture, if any.
+ *
+ * @property render.sprite.texture
+ * @type string
+ */
+
+ /**
+ * A `Number` that defines the scaling in the x-axis for the sprite, if any.
+ *
+ * @property render.sprite.xScale
+ * @type number
+ * @default 1
+ */
+
+ /**
+ * A `Number` that defines the scaling in the y-axis for the sprite, if any.
+ *
+ * @property render.sprite.yScale
+ * @type number
+ * @default 1
+ */
+
+ /**
+ * A `Number` that defines the offset in the x-axis for the sprite (normalised by texture width).
+ *
+ * @property render.sprite.xOffset
+ * @type number
+ * @default 0
+ */
+
+ /**
+ * A `Number` that defines the offset in the y-axis for the sprite (normalised by texture height).
+ *
+ * @property render.sprite.yOffset
+ * @type number
+ * @default 0
+ */
+
+ /**
+ * A `Number` that defines the line width to use when rendering the body outline (if a sprite is not defined).
+ * A value of `0` means no outline will be rendered.
+ *
+ * @property render.lineWidth
+ * @type number
+ * @default 0
+ */
+
+ /**
+ * A `String` that defines the fill style to use when rendering the body (if a sprite is not defined).
+ * It is the same as when using a canvas, so it accepts CSS style property values.
+ *
+ * @property render.fillStyle
+ * @type string
+ * @default a random colour
+ */
+
+ /**
+ * A `String` that defines the stroke style to use when rendering the body outline (if a sprite is not defined).
+ * It is the same as when using a canvas, so it accepts CSS style property values.
+ *
+ * @property render.strokeStyle
+ * @type string
+ * @default a random colour
+ */
+
+ /**
+ * An array of unique axis vectors (edge normals) used for collision detection.
+ * These are automatically calculated from the given convex hull (`vertices` array) in `Body.create`.
+ * They are constantly updated by `Body.update` during the simulation.
+ *
+ * @property axes
+ * @type vector[]
+ */
+
+ /**
+ * A `Number` that _measures_ the area of the body's convex hull, calculated at creation by `Body.create`.
+ *
+ * @property area
+ * @type string
+ * @default
+ */
+
+ /**
+ * A `Bounds` object that defines the AABB region for the body.
+ * It is automatically calculated from the given convex hull (`vertices` array) in `Body.create` and constantly updated by `Body.update` during simulation.
+ *
+ * @property bounds
+ * @type bounds
+ */
+
+})();
+
+},{"../core/Common":14,"../core/Sleeping":22,"../geometry/Axes":25,"../geometry/Bounds":26,"../geometry/Vector":28,"../geometry/Vertices":29,"../render/Render":31}],2:[function(_dereq_,module,exports){
+/**
+* The `Matter.Composite` module contains methods for creating and manipulating composite bodies.
+* A composite body is a collection of `Matter.Body`, `Matter.Constraint` and other `Matter.Composite`, therefore composites form a tree structure.
+* It is important to use the functions in this module to modify composites, rather than directly modifying their properties.
+* Note that the `Matter.World` object is also a type of `Matter.Composite` and as such all composite methods here can also operate on a `Matter.World`.
+*
+* See the included usage [examples](https://github.com/liabru/matter-js/tree/master/examples).
+*
+* @class Composite
+*/
+
+var Composite = {};
+
+module.exports = Composite;
+
+var Events = _dereq_('../core/Events');
+var Common = _dereq_('../core/Common');
+var Bounds = _dereq_('../geometry/Bounds');
+var Body = _dereq_('./Body');
+
+(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 add function. Adds one or many body(s), constraint(s) or a composite(s) to the given composite.
+ * Triggers `beforeAdd` and `afterAdd` events on the `composite`.
+ * @method add
+ * @param {composite} composite
+ * @param {} object
+ * @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
+ * @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 {}
+ */
+
+})();
+
+},{"../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);
+ }
+ }
+ };
+
+ /**
+ * 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
+ * @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;
+ }
+ }
+ }
+ };
+
+})();
+
+},{"../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
+
+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).
+* The stiffness of constraints can be modified to create springs or elastic.
+*
+* See the included usage [examples](https://github.com/liabru/matter-js/tree/master/examples).
+*
+* @class Constraint
+*/
+
+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');
+
+(function() {
+
+ Constraint._warming = 0.4;
+ Constraint._torqueDampen = 1;
+ Constraint._minLength = 0.000001;
+
+ /**
+ * Creates a new constraint.
+ * All properties have default values, and many are pre-calculated automatically based on other properties.
+ * To simulate a revolute constraint (or pin joint) set `length: 0` and a high `stiffness` value (e.g. `0.7` or above).
+ * If the constraint is unstable, try lowering the `stiffness` value and / or increasing `engine.constraintIterations`.
+ * For compound bodies, constraints must be applied to the parent body (not one of its parts).
+ * See the properties section below for detailed information on what you can pass via the `options` object.
+ * @method create
+ * @param {} options
+ * @return {constraint} constraint
+ */
+ Constraint.create = function(options) {
+ var constraint = options;
+
+ // if bodies defined but no points, use body centre
+ if (constraint.bodyA && !constraint.pointA)
+ constraint.pointA = { x: 0, y: 0 };
+ if (constraint.bodyB && !constraint.pointB)
+ constraint.pointB = { x: 0, y: 0 };
+
+ // calculate static length using initial world space points
+ var initialPointA = constraint.bodyA ? Vector.add(constraint.bodyA.position, constraint.pointA) : constraint.pointA,
+ initialPointB = constraint.bodyB ? Vector.add(constraint.bodyB.position, constraint.pointB) : constraint.pointB,
+ length = Vector.magnitude(Vector.sub(initialPointA, initialPointB));
+
+ constraint.length = typeof constraint.length !== 'undefined' ? constraint.length : length;
+
+ // option defaults
+ constraint.id = constraint.id || Common.nextId();
+ constraint.label = constraint.label || 'Constraint';
+ constraint.type = 'constraint';
+ constraint.stiffness = constraint.stiffness || (constraint.length > 0 ? 1 : 0.7);
+ constraint.damping = constraint.damping || 0;
+ constraint.angularStiffness = constraint.angularStiffness || 0;
+ constraint.angleA = constraint.bodyA ? constraint.bodyA.angle : constraint.angleA;
+ constraint.angleB = constraint.bodyB ? constraint.bodyB.angle : constraint.angleB;
+ constraint.plugin = {};
+
+ // render
+ var render = {
+ visible: true,
+ lineWidth: 2,
+ strokeStyle: '#ffffff',
+ type: 'line',
+ anchors: true
+ };
+
+ if (constraint.length === 0 && constraint.stiffness > 0.1) {
+ render.type = 'pin';
+ render.anchors = false;
+ } else if (constraint.stiffness < 0.9) {
+ render.type = 'spring';
+ }
+
+ constraint.render = Common.extend(render, constraint.render);
+
+ return constraint;
+ };
+
+ /**
+ * Prepares for solving by constraint warming.
+ * @private
+ * @method preSolveAll
+ * @param {body[]} bodies
+ */
+ Constraint.preSolveAll = function(bodies) {
+ for (var i = 0; i < bodies.length; i += 1) {
+ var body = bodies[i],
+ impulse = body.constraintImpulse;
+
+ if (body.isStatic || (impulse.x === 0 && impulse.y === 0 && impulse.angle === 0)) {
+ continue;
+ }
+
+ body.position.x += impulse.x;
+ body.position.y += impulse.y;
+ body.angle += impulse.angle;
+ }
+ };
+
+ /**
+ * Solves all constraints in a list of collisions.
+ * @private
+ * @method solveAll
+ * @param {constraint[]} constraints
+ * @param {number} timeScale
+ */
+ Constraint.solveAll = function(constraints, timeScale) {
+ // Solve fixed constraints first.
+ for (var i = 0; i < constraints.length; i += 1) {
+ var constraint = constraints[i],
+ fixedA = !constraint.bodyA || (constraint.bodyA && constraint.bodyA.isStatic),
+ fixedB = !constraint.bodyB || (constraint.bodyB && constraint.bodyB.isStatic);
+
+ if (fixedA || fixedB) {
+ Constraint.solve(constraints[i], timeScale);
+ }
+ }
+
+ // Solve free constraints last.
+ for (i = 0; i < constraints.length; i += 1) {
+ constraint = constraints[i];
+ fixedA = !constraint.bodyA || (constraint.bodyA && constraint.bodyA.isStatic);
+ fixedB = !constraint.bodyB || (constraint.bodyB && constraint.bodyB.isStatic);
+
+ if (!fixedA && !fixedB) {
+ Constraint.solve(constraints[i], timeScale);
+ }
+ }
+ };
+
+ /**
+ * Solves a distance constraint with Gauss-Siedel method.
+ * @private
+ * @method solve
+ * @param {constraint} constraint
+ * @param {number} timeScale
+ */
+ Constraint.solve = function(constraint, timeScale) {
+ var bodyA = constraint.bodyA,
+ bodyB = constraint.bodyB,
+ pointA = constraint.pointA,
+ pointB = constraint.pointB;
+
+ if (!bodyA && !bodyB)
+ return;
+
+ // update reference angle
+ if (bodyA && !bodyA.isStatic) {
+ Vector.rotate(pointA, bodyA.angle - constraint.angleA, pointA);
+ constraint.angleA = bodyA.angle;
+ }
+
+ // update reference angle
+ if (bodyB && !bodyB.isStatic) {
+ Vector.rotate(pointB, bodyB.angle - constraint.angleB, pointB);
+ constraint.angleB = bodyB.angle;
+ }
+
+ var pointAWorld = pointA,
+ pointBWorld = pointB;
+
+ if (bodyA) pointAWorld = Vector.add(bodyA.position, pointA);
+ if (bodyB) pointBWorld = Vector.add(bodyB.position, pointB);
+
+ if (!pointAWorld || !pointBWorld)
+ return;
+
+ var delta = Vector.sub(pointAWorld, pointBWorld),
+ currentLength = Vector.magnitude(delta);
+
+ // prevent singularity
+ if (currentLength < Constraint._minLength) {
+ currentLength = Constraint._minLength;
+ }
+
+ // solve distance constraint with Gauss-Siedel method
+ var difference = (currentLength - constraint.length) / currentLength,
+ stiffness = constraint.stiffness < 1 ? constraint.stiffness * timeScale : constraint.stiffness,
+ force = Vector.mult(delta, difference * stiffness),
+ massTotal = (bodyA ? bodyA.inverseMass : 0) + (bodyB ? bodyB.inverseMass : 0),
+ inertiaTotal = (bodyA ? bodyA.inverseInertia : 0) + (bodyB ? bodyB.inverseInertia : 0),
+ resistanceTotal = massTotal + inertiaTotal,
+ torque,
+ share,
+ normal,
+ normalVelocity,
+ relativeVelocity;
+
+ if (constraint.damping) {
+ var zero = Vector.create();
+ normal = Vector.div(delta, currentLength);
+
+ relativeVelocity = Vector.sub(
+ bodyB && Vector.sub(bodyB.position, bodyB.positionPrev) || zero,
+ bodyA && Vector.sub(bodyA.position, bodyA.positionPrev) || zero
+ );
+
+ normalVelocity = Vector.dot(normal, relativeVelocity);
+ }
+
+ if (bodyA && !bodyA.isStatic) {
+ share = bodyA.inverseMass / massTotal;
+
+ // keep track of applied impulses for post solving
+ bodyA.constraintImpulse.x -= force.x * share;
+ bodyA.constraintImpulse.y -= force.y * share;
+
+ // apply forces
+ bodyA.position.x -= force.x * share;
+ bodyA.position.y -= force.y * share;
+
+ // apply damping
+ if (constraint.damping) {
+ bodyA.positionPrev.x -= constraint.damping * normal.x * normalVelocity * share;
+ bodyA.positionPrev.y -= constraint.damping * normal.y * normalVelocity * share;
+ }
+
+ // apply torque
+ torque = (Vector.cross(pointA, force) / resistanceTotal) * Constraint._torqueDampen * bodyA.inverseInertia * (1 - constraint.angularStiffness);
+ bodyA.constraintImpulse.angle -= torque;
+ bodyA.angle -= torque;
+ }
+
+ if (bodyB && !bodyB.isStatic) {
+ share = bodyB.inverseMass / massTotal;
+
+ // keep track of applied impulses for post solving
+ bodyB.constraintImpulse.x += force.x * share;
+ bodyB.constraintImpulse.y += force.y * share;
+
+ // apply forces
+ bodyB.position.x += force.x * share;
+ bodyB.position.y += force.y * share;
+
+ // apply damping
+ if (constraint.damping) {
+ bodyB.positionPrev.x += constraint.damping * normal.x * normalVelocity * share;
+ bodyB.positionPrev.y += constraint.damping * normal.y * normalVelocity * share;
+ }
+
+ // apply torque
+ torque = (Vector.cross(pointB, force) / resistanceTotal) * Constraint._torqueDampen * bodyB.inverseInertia * (1 - constraint.angularStiffness);
+ bodyB.constraintImpulse.angle += torque;
+ bodyB.angle += torque;
+ }
+
+ };
+
+ /**
+ * Performs body updates required after solving constraints.
+ * @private
+ * @method postSolveAll
+ * @param {body[]} bodies
+ */
+ Constraint.postSolveAll = function(bodies) {
+ for (var i = 0; i < bodies.length; i++) {
+ var body = bodies[i],
+ impulse = body.constraintImpulse;
+
+ if (body.isStatic || (impulse.x === 0 && impulse.y === 0 && impulse.angle === 0)) {
+ continue;
+ }
+
+ Sleeping.set(body, false);
+
+ // update geometry and reset
+ for (var j = 0; j < body.parts.length; j++) {
+ var part = body.parts[j];
+
+ Vertices.translate(part.vertices, impulse);
+
+ if (j > 0) {
+ part.position.x += impulse.x;
+ part.position.y += impulse.y;
+ }
+
+ if (impulse.angle !== 0) {
+ Vertices.rotate(part.vertices, impulse.angle, body.position);
+ Axes.rotate(part.axes, impulse.angle);
+ if (j > 0) {
+ Vector.rotateAbout(part.position, impulse.angle, body.position, part.position);
+ }
+ }
+
+ Bounds.update(part.bounds, part.vertices, body.velocity);
+ }
+
+ // dampen the cached impulse for warming next step
+ impulse.angle *= Constraint._warming;
+ impulse.x *= Constraint._warming;
+ impulse.y *= Constraint._warming;
+ }
+ };
+
+ /*
+ *
+ * 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 "constraint"
+ * @readOnly
+ */
+
+ /**
+ * An arbitrary `String` name to help the user identify and manage bodies.
+ *
+ * @property label
+ * @type string
+ * @default "Constraint"
+ */
+
+ /**
+ * An `Object` that defines the rendering properties to be consumed by the module `Matter.Render`.
+ *
+ * @property render
+ * @type object
+ */
+
+ /**
+ * A flag that indicates if the constraint should be rendered.
+ *
+ * @property render.visible
+ * @type boolean
+ * @default true
+ */
+
+ /**
+ * A `Number` that defines the line width to use when rendering the constraint outline.
+ * A value of `0` means no outline will be rendered.
+ *
+ * @property render.lineWidth
+ * @type number
+ * @default 2
+ */
+
+ /**
+ * A `String` that defines the stroke style to use when rendering the constraint outline.
+ * It is the same as when using a canvas, so it accepts CSS style property values.
+ *
+ * @property render.strokeStyle
+ * @type string
+ * @default a random colour
+ */
+
+ /**
+ * A `String` that defines the constraint rendering type.
+ * The possible values are 'line', 'pin', 'spring'.
+ * An appropriate render type will be automatically chosen unless one is given in options.
+ *
+ * @property render.type
+ * @type string
+ * @default 'line'
+ */
+
+ /**
+ * A `Boolean` that defines if the constraint's anchor points should be rendered.
+ *
+ * @property render.anchors
+ * @type boolean
+ * @default true
+ */
+
+ /**
+ * The first possible `Body` that this constraint is attached to.
+ *
+ * @property bodyA
+ * @type body
+ * @default null
+ */
+
+ /**
+ * The second possible `Body` that this constraint is attached to.
+ *
+ * @property bodyB
+ * @type body
+ * @default null
+ */
+
+ /**
+ * A `Vector` that specifies the offset of the constraint from center of the `constraint.bodyA` if defined, otherwise a world-space position.
+ *
+ * @property pointA
+ * @type vector
+ * @default { x: 0, y: 0 }
+ */
+
+ /**
+ * A `Vector` that specifies the offset of the constraint from center of the `constraint.bodyB` if defined, otherwise a world-space position.
+ *
+ * @property pointB
+ * @type vector
+ * @default { x: 0, y: 0 }
+ */
+
+ /**
+ * A `Number` that specifies the stiffness of the constraint, i.e. the rate at which it returns to its resting `constraint.length`.
+ * A value of `1` means the constraint should be very stiff.
+ * A value of `0.2` means the constraint acts like a soft spring.
+ *
+ * @property stiffness
+ * @type number
+ * @default 1
+ */
+
+ /**
+ * A `Number` that specifies the damping of the constraint,
+ * i.e. the amount of resistance applied to each body based on their velocities to limit the amount of oscillation.
+ * Damping will only be apparent when the constraint also has a very low `stiffness`.
+ * A value of `0.1` means the constraint will apply heavy damping, resulting in little to no oscillation.
+ * A value of `0` means the constraint will apply no damping.
+ *
+ * @property damping
+ * @type number
+ * @default 0
+ */
+
+ /**
+ * A `Number` that specifies the target resting length of the constraint.
+ * It is calculated automatically in `Constraint.create` from initial positions of the `constraint.bodyA` and `constraint.bodyB`.
+ *
+ * @property length
+ * @type number
+ */
+
+ /**
+ * An object reserved for storing plugin-specific properties.
+ *
+ * @property plugin
+ * @type {}
+ */
+
+})();
+
+},{"../core/Common":14,"../core/Sleeping":22,"../geometry/Axes":25,"../geometry/Bounds":26,"../geometry/Vector":28,"../geometry/Vertices":29}],13:[function(_dereq_,module,exports){
+/**
+* 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 = _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');
+
+(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
+ */
+
+})();
+
+},{"../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){
+/**
+* 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());
+
+ /**
+ * 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 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)));
+ }
+ };
+
+ /**
+ * 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){
+/**
+* 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 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');
+
+(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(element, options) {
+ // options may be passed as the first (and only) argument
+ options = Common.isElement(element) ? options : element;
+ element = Common.isElement(element) ? element : null;
+ 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 engine = Common.extend(defaults, options);
+
+ // @deprecated
+ if (element || engine.render) {
+ var renderDefaults = {
+ element: element,
+ controller: Render
+ };
+
+ engine.render = Common.extend(renderDefaults, engine.render);
+ }
+
+ // @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;
+ };
+
+ /**
+ * 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;
+
+ Pairs.clear(engine.pairs);
+
+ var broadphase = engine.broadphase;
+ if (broadphase.controller) {
+ var bodies = Composite.allBodies(world);
+ broadphase.controller.clear(broadphase);
+ broadphase.controller.update(broadphase, 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);
+ }
+ };
+
+ /**
+ * 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]);
+ }
+ }
+
+ 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;
+
+ if (object.events) {
+ if (!event)
+ event = {};
+
+ names = eventNames.split(' ');
+
+ for (var i = 0; i < names.length; i++) {
+ name = names[i];
+ callbacks = object.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]);
+ }
+ }
+ }
+ }
+ };
+
+})();
+
+},{"./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 = {};
+
+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.
+*
+* @class Mouse
+*/
+
+var Mouse = {};
+
+module.exports = Mouse;
+
+var Common = _dereq_('../core/Common');
+
+(function() {
+
+ /**
+ * Creates a mouse input.
+ * @method create
+ * @param {HTMLElement} element
+ * @return {mouse} A new mouse
+ */
+ Mouse.create = function(element) {
+ var mouse = {};
+
+ if (!element) {
+ Common.log('Mouse.create: element was undefined, defaulting to document.body', 'warn');
+ }
+
+ mouse.element = element || document.body;
+ mouse.absolute = { x: 0, y: 0 };
+ mouse.position = { x: 0, y: 0 };
+ mouse.mousedownPosition = { x: 0, y: 0 };
+ mouse.mouseupPosition = { x: 0, y: 0 };
+ mouse.offset = { x: 0, y: 0 };
+ mouse.scale = { x: 1, y: 1 };
+ mouse.wheelDelta = 0;
+ mouse.button = -1;
+ mouse.pixelRatio = mouse.element.getAttribute('data-pixel-ratio') || 1;
+
+ mouse.sourceEvents = {
+ mousemove: null,
+ mousedown: null,
+ mouseup: null,
+ mousewheel: null
+ };
+
+ mouse.mousemove = function(event) {
+ var position = Mouse._getRelativeMousePosition(event, mouse.element, mouse.pixelRatio),
+ touches = event.changedTouches;
+
+ if (touches) {
+ mouse.button = 0;
+ event.preventDefault();
+ }
+
+ mouse.absolute.x = position.x;
+ mouse.absolute.y = position.y;
+ mouse.position.x = mouse.absolute.x * mouse.scale.x + mouse.offset.x;
+ mouse.position.y = mouse.absolute.y * mouse.scale.y + mouse.offset.y;
+ mouse.sourceEvents.mousemove = event;
+ };
+
+ mouse.mousedown = function(event) {
+ var position = Mouse._getRelativeMousePosition(event, mouse.element, mouse.pixelRatio),
+ touches = event.changedTouches;
+
+ if (touches) {
+ mouse.button = 0;
+ event.preventDefault();
+ } else {
+ mouse.button = event.button;
+ }
+
+ mouse.absolute.x = position.x;
+ mouse.absolute.y = position.y;
+ mouse.position.x = mouse.absolute.x * mouse.scale.x + mouse.offset.x;
+ mouse.position.y = mouse.absolute.y * mouse.scale.y + mouse.offset.y;
+ mouse.mousedownPosition.x = mouse.position.x;
+ mouse.mousedownPosition.y = mouse.position.y;
+ mouse.sourceEvents.mousedown = event;
+ };
+
+ mouse.mouseup = function(event) {
+ var position = Mouse._getRelativeMousePosition(event, mouse.element, mouse.pixelRatio),
+ touches = event.changedTouches;
+
+ if (touches) {
+ event.preventDefault();
+ }
+
+ mouse.button = -1;
+ mouse.absolute.x = position.x;
+ mouse.absolute.y = position.y;
+ mouse.position.x = mouse.absolute.x * mouse.scale.x + mouse.offset.x;
+ mouse.position.y = mouse.absolute.y * mouse.scale.y + mouse.offset.y;
+ mouse.mouseupPosition.x = mouse.position.x;
+ mouse.mouseupPosition.y = mouse.position.y;
+ mouse.sourceEvents.mouseup = event;
+ };
+
+ mouse.mousewheel = function(event) {
+ mouse.wheelDelta = Math.max(-1, Math.min(1, event.wheelDelta || -event.detail));
+ event.preventDefault();
+ };
+
+ Mouse.setElement(mouse, mouse.element);
+
+ return mouse;
+ };
+
+ /**
+ * Sets the element the mouse is bound to (and relative to).
+ * @method setElement
+ * @param {mouse} mouse
+ * @param {HTMLElement} element
+ */
+ Mouse.setElement = function(mouse, element) {
+ mouse.element = element;
+
+ element.addEventListener('mousemove', mouse.mousemove);
+ element.addEventListener('mousedown', mouse.mousedown);
+ element.addEventListener('mouseup', mouse.mouseup);
+
+ element.addEventListener('mousewheel', mouse.mousewheel);
+ element.addEventListener('DOMMouseScroll', mouse.mousewheel);
+
+ element.addEventListener('touchmove', mouse.mousemove);
+ element.addEventListener('touchstart', mouse.mousedown);
+ element.addEventListener('touchend', mouse.mouseup);
+ };
+
+ /**
+ * Clears all captured source events.
+ * @method clearSourceEvents
+ * @param {mouse} mouse
+ */
+ Mouse.clearSourceEvents = function(mouse) {
+ mouse.sourceEvents.mousemove = null;
+ mouse.sourceEvents.mousedown = null;
+ mouse.sourceEvents.mouseup = null;
+ mouse.sourceEvents.mousewheel = null;
+ mouse.wheelDelta = 0;
+ };
+
+ /**
+ * Sets the mouse position offset.
+ * @method setOffset
+ * @param {mouse} mouse
+ * @param {vector} offset
+ */
+ Mouse.setOffset = function(mouse, offset) {
+ mouse.offset.x = offset.x;
+ mouse.offset.y = offset.y;
+ mouse.position.x = mouse.absolute.x * mouse.scale.x + mouse.offset.x;
+ mouse.position.y = mouse.absolute.y * mouse.scale.y + mouse.offset.y;
+ };
+
+ /**
+ * Sets the mouse position scale.
+ * @method setScale
+ * @param {mouse} mouse
+ * @param {vector} scale
+ */
+ Mouse.setScale = function(mouse, scale) {
+ mouse.scale.x = scale.x;
+ mouse.scale.y = scale.y;
+ mouse.position.x = mouse.absolute.x * mouse.scale.x + mouse.offset.x;
+ mouse.position.y = mouse.absolute.y * mouse.scale.y + mouse.offset.y;
+ };
+
+ /**
+ * Gets the mouse position relative to an element given a screen pixel ratio.
+ * @method _getRelativeMousePosition
+ * @private
+ * @param {} event
+ * @param {} element
+ * @param {number} pixelRatio
+ * @return {}
+ */
+ Mouse._getRelativeMousePosition = function(event, element, pixelRatio) {
+ var elementBounds = element.getBoundingClientRect(),
+ rootNode = (document.documentElement || document.body.parentNode || document.body),
+ scrollX = (window.pageXOffset !== undefined) ? window.pageXOffset : rootNode.scrollLeft,
+ scrollY = (window.pageYOffset !== undefined) ? window.pageYOffset : rootNode.scrollTop,
+ touches = event.changedTouches,
+ x, y;
+
+ if (touches) {
+ x = touches[0].pageX - elementBounds.left - scrollX;
+ y = touches[0].pageY - elementBounds.top - scrollY;
+ } else {
+ x = event.pageX - elementBounds.left - scrollX;
+ y = event.pageY - elementBounds.top - scrollY;
+ }
+
+ return {
+ x: x / (element.clientWidth / (element.width || element.clientWidth) * pixelRatio),
+ y: y / (element.clientHeight / (element.height || element.clientHeight) * pixelRatio)
+ };
+ };
+
+})();
+
+},{"../core/Common":14}],20:[function(_dereq_,module,exports){
+/**
+* The `Matter.Plugin` module contains functions for registering and installing plugins on modules.
+*
+* @class Plugin
+*/
+
+var Plugin = {};
+
+module.exports = Plugin;
+
+var Common = _dereq_('./Common');
+
+(function() {
+
+ Plugin._registry = {};
+
+ /**
+ * Registers a plugin object so it can be resolved later by name.
+ * @method register
+ * @param plugin {} The plugin to register.
+ * @return {object} The plugin.
+ */
+ Plugin.register = function(plugin) {
+ if (!Plugin.isPlugin(plugin)) {
+ Common.warn('Plugin.register:', Plugin.toString(plugin), 'does not implement all required fields.');
+ }
+
+ if (plugin.name in Plugin._registry) {
+ var registered = Plugin._registry[plugin.name],
+ pluginVersion = Plugin.versionParse(plugin.version).number,
+ registeredVersion = Plugin.versionParse(registered.version).number;
+
+ if (pluginVersion > registeredVersion) {
+ Common.warn('Plugin.register:', Plugin.toString(registered), 'was upgraded to', Plugin.toString(plugin));
+ Plugin._registry[plugin.name] = plugin;
+ } else if (pluginVersion < registeredVersion) {
+ Common.warn('Plugin.register:', Plugin.toString(registered), 'can not be downgraded to', Plugin.toString(plugin));
+ } else if (plugin !== registered) {
+ Common.warn('Plugin.register:', Plugin.toString(plugin), 'is already registered to different plugin object');
+ }
+ } else {
+ Plugin._registry[plugin.name] = plugin;
+ }
+
+ return plugin;
+ };
+
+ /**
+ * Resolves a dependency to a plugin object from the registry if it exists.
+ * The `dependency` may contain a version, but only the name matters when resolving.
+ * @method resolve
+ * @param dependency {string} The dependency.
+ * @return {object} The plugin if resolved, otherwise `undefined`.
+ */
+ Plugin.resolve = function(dependency) {
+ return Plugin._registry[Plugin.dependencyParse(dependency).name];
+ };
+
+ /**
+ * Returns a pretty printed plugin name and version.
+ * @method toString
+ * @param plugin {} The plugin.
+ * @return {string} Pretty printed plugin name and version.
+ */
+ Plugin.toString = function(plugin) {
+ return typeof plugin === 'string' ? plugin : (plugin.name || 'anonymous') + '@' + (plugin.version || plugin.range || '0.0.0');
+ };
+
+ /**
+ * Returns `true` if the object meets the minimum standard to be considered a plugin.
+ * This means it must define the following properties:
+ * - `name`
+ * - `version`
+ * - `install`
+ * @method isPlugin
+ * @param obj {} The obj to test.
+ * @return {boolean} `true` if the object can be considered a plugin otherwise `false`.
+ */
+ Plugin.isPlugin = function(obj) {
+ return obj && obj.name && obj.version && obj.install;
+ };
+
+ /**
+ * Returns `true` if a plugin with the given `name` been installed on `module`.
+ * @method isUsed
+ * @param module {} The module.
+ * @param name {string} The plugin name.
+ * @return {boolean} `true` if a plugin with the given `name` been installed on `module`, otherwise `false`.
+ */
+ Plugin.isUsed = function(module, name) {
+ return module.used.indexOf(name) > -1;
+ };
+
+ /**
+ * Returns `true` if `plugin.for` is applicable to `module` by comparing against `module.name` and `module.version`.
+ * If `plugin.for` is not specified then it is assumed to be applicable.
+ * The value of `plugin.for` is a string of the format `'module-name'` or `'module-name@version'`.
+ * @method isFor
+ * @param plugin {} The plugin.
+ * @param module {} The module.
+ * @return {boolean} `true` if `plugin.for` is applicable to `module`, otherwise `false`.
+ */
+ Plugin.isFor = function(plugin, module) {
+ var parsed = plugin.for && Plugin.dependencyParse(plugin.for);
+ return !plugin.for || (module.name === parsed.name && Plugin.versionSatisfies(module.version, parsed.range));
+ };
+
+ /**
+ * Installs the plugins by calling `plugin.install` on each plugin specified in `plugins` if passed, otherwise `module.uses`.
+ * For installing plugins on `Matter` see the convenience function `Matter.use`.
+ * Plugins may be specified either by their name or a reference to the plugin object.
+ * Plugins themselves may specify further dependencies, but each plugin is installed only once.
+ * Order is important, a topological sort is performed to find the best resulting order of installation.
+ * This sorting attempts to satisfy every dependency's requested ordering, but may not be exact in all cases.
+ * This function logs the resulting status of each dependency in the console, along with any warnings.
+ * - A green tick ✅ indicates a dependency was resolved and installed.
+ * - An orange diamond 🔶 indicates a dependency was resolved but a warning was thrown for it or one if its dependencies.
+ * - A red cross ❌ indicates a dependency could not be resolved.
+ * Avoid calling this function multiple times on the same module unless you intend to manually control installation order.
+ * @method use
+ * @param module {} The module install plugins on.
+ * @param [plugins=module.uses] {} The plugins to install on module (optional, defaults to `module.uses`).
+ */
+ Plugin.use = function(module, plugins) {
+ module.uses = (module.uses || []).concat(plugins || []);
+
+ if (module.uses.length === 0) {
+ Common.warn('Plugin.use:', Plugin.toString(module), 'does not specify any dependencies to install.');
+ return;
+ }
+
+ var dependencies = Plugin.dependencies(module),
+ sortedDependencies = Common.topologicalSort(dependencies),
+ status = [];
+
+ for (var i = 0; i < sortedDependencies.length; i += 1) {
+ if (sortedDependencies[i] === module.name) {
+ continue;
+ }
+
+ var plugin = Plugin.resolve(sortedDependencies[i]);
+
+ if (!plugin) {
+ status.push('❌ ' + sortedDependencies[i]);
+ continue;
+ }
+
+ if (Plugin.isUsed(module, plugin.name)) {
+ continue;
+ }
+
+ if (!Plugin.isFor(plugin, module)) {
+ Common.warn('Plugin.use:', Plugin.toString(plugin), 'is for', plugin.for, 'but installed on', Plugin.toString(module) + '.');
+ plugin._warned = true;
+ }
+
+ if (plugin.install) {
+ plugin.install(module);
+ } else {
+ Common.warn('Plugin.use:', Plugin.toString(plugin), 'does not specify an install function.');
+ plugin._warned = true;
+ }
+
+ if (plugin._warned) {
+ status.push('🔶 ' + Plugin.toString(plugin));
+ delete plugin._warned;
+ } else {
+ status.push('✅ ' + Plugin.toString(plugin));
+ }
+
+ module.used.push(plugin.name);
+ }
+
+ if (status.length > 0) {
+ Common.info(status.join(' '));
+ }
+ };
+
+ /**
+ * Recursively finds all of a module's dependencies and returns a flat dependency graph.
+ * @method dependencies
+ * @param module {} The module.
+ * @return {object} A dependency graph.
+ */
+ Plugin.dependencies = function(module, tracked) {
+ var parsedBase = Plugin.dependencyParse(module),
+ name = parsedBase.name;
+
+ tracked = tracked || {};
+
+ if (name in tracked) {
+ return;
+ }
+
+ module = Plugin.resolve(module) || module;
+
+ tracked[name] = Common.map(module.uses || [], function(dependency) {
+ if (Plugin.isPlugin(dependency)) {
+ Plugin.register(dependency);
+ }
+
+ var parsed = Plugin.dependencyParse(dependency),
+ resolved = Plugin.resolve(dependency);
+
+ if (resolved && !Plugin.versionSatisfies(resolved.version, parsed.range)) {
+ Common.warn(
+ 'Plugin.dependencies:', Plugin.toString(resolved), 'does not satisfy',
+ Plugin.toString(parsed), 'used by', Plugin.toString(parsedBase) + '.'
+ );
+
+ resolved._warned = true;
+ module._warned = true;
+ } else if (!resolved) {
+ Common.warn(
+ 'Plugin.dependencies:', Plugin.toString(dependency), 'used by',
+ Plugin.toString(parsedBase), 'could not be resolved.'
+ );
+
+ module._warned = true;
+ }
+
+ return parsed.name;
+ });
+
+ for (var i = 0; i < tracked[name].length; i += 1) {
+ Plugin.dependencies(tracked[name][i], tracked);
+ }
+
+ return tracked;
+ };
+
+ /**
+ * Parses a dependency string into its components.
+ * The `dependency` is a string of the format `'module-name'` or `'module-name@version'`.
+ * See documentation for `Plugin.versionParse` for a description of the format.
+ * This function can also handle dependencies that are already resolved (e.g. a module object).
+ * @method dependencyParse
+ * @param dependency {string} The dependency of the format `'module-name'` or `'module-name@version'`.
+ * @return {object} The dependency parsed into its components.
+ */
+ Plugin.dependencyParse = function(dependency) {
+ if (Common.isString(dependency)) {
+ var pattern = /^[\w-]+(@(\*|[\^~]?\d+\.\d+\.\d+(-[0-9A-Za-z-]+)?))?$/;
+
+ if (!pattern.test(dependency)) {
+ Common.warn('Plugin.dependencyParse:', dependency, 'is not a valid dependency string.');
+ }
+
+ return {
+ name: dependency.split('@')[0],
+ range: dependency.split('@')[1] || '*'
+ };
+ }
+
+ return {
+ name: dependency.name,
+ range: dependency.range || dependency.version
+ };
+ };
+
+ /**
+ * Parses a version string into its components.
+ * Versions are strictly of the format `x.y.z` (as in [semver](http://semver.org/)).
+ * Versions may optionally have a prerelease tag in the format `x.y.z-alpha`.
+ * Ranges are a strict subset of [npm ranges](https://docs.npmjs.com/misc/semver#advanced-range-syntax).
+ * Only the following range types are supported:
+ * - Tilde ranges e.g. `~1.2.3`
+ * - Caret ranges e.g. `^1.2.3`
+ * - Exact version e.g. `1.2.3`
+ * - Any version `*`
+ * @method versionParse
+ * @param range {string} The version string.
+ * @return {object} The version range parsed into its components.
+ */
+ Plugin.versionParse = function(range) {
+ var pattern = /^\*|[\^~]?\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);
+ });
+
+ return {
+ isRange: isRange,
+ version: version,
+ range: range,
+ operator: isRange ? range[0] : '',
+ parts: parts,
+ prerelease: identifiers[1],
+ number: parts[0] * 1e8 + parts[1] * 1e4 + parts[2]
+ };
+ };
+
+ /**
+ * Returns `true` if `version` satisfies the given `range`.
+ * See documentation for `Plugin.versionParse` for a description of the format.
+ * If a version or range is not specified, then any version (`*`) is assumed to satisfy.
+ * @method versionSatisfies
+ * @param version {string} The version string.
+ * @param range {string} The range string.
+ * @return {boolean} `true` if `version` satisfies `range`, otherwise `false`.
+ */
+ Plugin.versionSatisfies = function(version, range) {
+ range = range || '*';
+
+ var rangeParsed = Plugin.versionParse(range),
+ rangeParts = rangeParsed.parts,
+ versionParsed = Plugin.versionParse(version),
+ versionParts = versionParsed.parts;
+
+ if (rangeParsed.isRange) {
+ if (rangeParsed.operator === '*' || version === '*') {
+ return true;
+ }
+
+ if (rangeParsed.operator === '~') {
+ return versionParts[0] === rangeParts[0] && versionParts[1] === rangeParts[1] && versionParts[2] >= rangeParts[2];
+ }
+
+ if (rangeParsed.operator === '^') {
+ if (rangeParts[0] > 0) {
+ return versionParts[0] === rangeParts[0] && versionParsed.number >= rangeParsed.number;
+ }
+
+ if (rangeParts[1] > 0) {
+ return versionParts[1] === rangeParts[1] && versionParts[2] >= rangeParts[2];
+ }
+
+ return versionParts[2] === rangeParts[2];
+ }
+ }
+
+ return version === range || version === '*';
+ };
+
+})();
+
+},{"./Common":14}],21:[function(_dereq_,module,exports){
+/**
+* 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`.
+* 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.
+*
+* @class Render
+*/
+
+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');
+
+(function() {
+
+ var _requestAnimationFrame,
+ _cancelAnimationFrame;
+
+ if (typeof window !== 'undefined') {
+ _requestAnimationFrame = window.requestAnimationFrame || window.webkitRequestAnimationFrame
+ || window.mozRequestAnimationFrame || window.msRequestAnimationFrame
+ || function(callback){ window.setTimeout(function() { callback(Common.now()); }, 1000 / 60); };
+
+ _cancelAnimationFrame = window.cancelAnimationFrame || window.mozCancelAnimationFrame
+ || window.webkitCancelAnimationFrame || window.msCancelAnimationFrame;
+ }
+
+ /**
+ * 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.
+ * See the properties section below for detailed information on what you can pass via the `options` object.
+ * @method create
+ * @param {object} [options]
+ * @return {render} A new renderer
+ */
+ Render.create = function(options) {
+ var defaults = {
+ controller: Render,
+ engine: null,
+ element: null,
+ canvas: null,
+ mouse: null,
+ frameRequestId: null,
+ options: {
+ width: 800,
+ height: 600,
+ pixelRatio: 1,
+ background: '#18181d',
+ wireframeBackground: '#0f0f13',
+ hasBounds: !!options.bounds,
+ enabled: true,
+ wireframes: true,
+ showSleeping: true,
+ showDebug: false,
+ showBroadphase: false,
+ showBounds: false,
+ showVelocity: false,
+ showCollisions: false,
+ showSeparations: false,
+ showAxes: false,
+ showPositions: false,
+ showAngleIndicator: false,
+ showIds: false,
+ showShadows: false,
+ showVertexNumbers: false,
+ showConvexHulls: false,
+ showInternalEdges: false,
+ showMousePosition: false
+ }
+ };
+
+ var render = Common.extend(defaults, options);
+
+ if (render.canvas) {
+ render.canvas.width = render.options.width || render.canvas.width;
+ render.canvas.height = render.options.height || render.canvas.height;
+ }
+
+ render.mouse = options.mouse;
+ render.engine = options.engine;
+ render.canvas = render.canvas || _createCanvas(render.options.width, render.options.height);
+ render.context = render.canvas.getContext('2d');
+ render.textures = {};
+
+ render.bounds = render.bounds || {
+ min: {
+ x: 0,
+ y: 0
+ },
+ max: {
+ x: render.canvas.width,
+ y: render.canvas.height
+ }
+ };
+
+ if (render.options.pixelRatio !== 1) {
+ Render.setPixelRatio(render, render.options.pixelRatio);
+ }
+
+ if (Common.isElement(render.element)) {
+ render.element.appendChild(render.canvas);
+ } else if (!render.canvas.parentNode) {
+ Common.log('Render.create: options.element was undefined, render.canvas was created but not appended', 'warn');
+ }
+
+ return render;
+ };
+
+ /**
+ * Continuously updates the render canvas on the `requestAnimationFrame` event.
+ * @method run
+ * @param {render} render
+ */
+ Render.run = function(render) {
+ (function loop(time){
+ render.frameRequestId = _requestAnimationFrame(loop);
+ Render.world(render);
+ })();
+ };
+
+ /**
+ * Ends execution of `Render.run` on the given `render`, by canceling the animation frame request event loop.
+ * @method stop
+ * @param {render} render
+ */
+ Render.stop = function(render) {
+ _cancelAnimationFrame(render.frameRequestId);
+ };
+
+ /**
+ * Sets the pixel ratio of the renderer and updates the canvas.
+ * To automatically detect the correct ratio, pass the string `'auto'` for `pixelRatio`.
+ * @method setPixelRatio
+ * @param {render} render
+ * @param {number} pixelRatio
+ */
+ Render.setPixelRatio = function(render, pixelRatio) {
+ var options = render.options,
+ canvas = render.canvas;
+
+ if (pixelRatio === 'auto') {
+ pixelRatio = _getPixelRatio(canvas);
+ }
+
+ options.pixelRatio = pixelRatio;
+ canvas.setAttribute('data-pixel-ratio', pixelRatio);
+ canvas.width = options.width * pixelRatio;
+ canvas.height = options.height * pixelRatio;
+ canvas.style.width = options.width + 'px';
+ canvas.style.height = options.height + 'px';
+ render.context.scale(pixelRatio, pixelRatio);
+ };
+
+ /**
+ * Positions and sizes the viewport around the given object bounds.
+ * Objects must have at least one of the following properties:
+ * - `object.bounds`
+ * - `object.position`
+ * - `object.min` and `object.max`
+ * - `object.x` and `object.y`
+ * @method lookAt
+ * @param {render} render
+ * @param {object[]} objects
+ * @param {vector} [padding]
+ * @param {bool} [center=true]
+ */
+ Render.lookAt = function(render, objects, padding, center) {
+ center = typeof center !== 'undefined' ? center : true;
+ objects = Common.isArray(objects) ? objects : [objects];
+ padding = padding || {
+ x: 0,
+ y: 0
+ };
+
+ // find bounds of all objects
+ var bounds = {
+ min: { x: Infinity, y: Infinity },
+ max: { x: -Infinity, y: -Infinity }
+ };
+
+ for (var i = 0; i < objects.length; i += 1) {
+ var object = objects[i],
+ min = object.bounds ? object.bounds.min : (object.min || object.position || object),
+ max = object.bounds ? object.bounds.max : (object.max || object.position || object);
+
+ if (min && max) {
+ if (min.x < bounds.min.x)
+ bounds.min.x = min.x;
+
+ if (max.x > bounds.max.x)
+ bounds.max.x = max.x;
+
+ if (min.y < bounds.min.y)
+ bounds.min.y = min.y;
+
+ if (max.y > bounds.max.y)
+ bounds.max.y = max.y;
+ }
+ }
+
+ // find ratios
+ var width = (bounds.max.x - bounds.min.x) + 2 * padding.x,
+ height = (bounds.max.y - bounds.min.y) + 2 * padding.y,
+ viewHeight = render.canvas.height,
+ viewWidth = render.canvas.width,
+ outerRatio = viewWidth / viewHeight,
+ innerRatio = width / height,
+ scaleX = 1,
+ scaleY = 1;
+
+ // find scale factor
+ if (innerRatio > outerRatio) {
+ scaleY = innerRatio / outerRatio;
+ } else {
+ scaleX = outerRatio / innerRatio;
+ }
+
+ // enable bounds
+ render.options.hasBounds = true;
+
+ // position and size
+ render.bounds.min.x = bounds.min.x;
+ render.bounds.max.x = bounds.min.x + width * scaleX;
+ render.bounds.min.y = bounds.min.y;
+ render.bounds.max.y = bounds.min.y + height * scaleY;
+
+ // center
+ if (center) {
+ render.bounds.min.x += width * 0.5 - (width * scaleX) * 0.5;
+ render.bounds.max.x += width * 0.5 - (width * scaleX) * 0.5;
+ render.bounds.min.y += height * 0.5 - (height * scaleY) * 0.5;
+ render.bounds.max.y += height * 0.5 - (height * scaleY) * 0.5;
+ }
+
+ // padding
+ render.bounds.min.x -= padding.x;
+ render.bounds.max.x -= padding.x;
+ render.bounds.min.y -= padding.y;
+ render.bounds.max.y -= padding.y;
+
+ // 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
+ });
+
+ Mouse.setOffset(render.mouse, render.bounds.min);
+ }
+ };
+
+ /**
+ * Applies viewport transforms based on `render.bounds` to a render context.
+ * @method startViewTransform
+ * @param {render} render
+ */
+ Render.startViewTransform = function(render) {
+ 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;
+
+ render.context.scale(1 / boundsScaleX, 1 / boundsScaleY);
+ render.context.translate(-render.bounds.min.x, -render.bounds.min.y);
+ };
+
+ /**
+ * Resets all transforms on the render context.
+ * @method endViewTransform
+ * @param {render} render
+ */
+ Render.endViewTransform = function(render) {
+ render.context.setTransform(render.options.pixelRatio, 0, 0, render.options.pixelRatio, 0, 0);
+ };
+
+ /**
+ * Renders the given `engine`'s `Matter.World` object.
+ * This is the entry point for all rendering and should be called every time the scene changes.
+ * @method world
+ * @param {render} render
+ */
+ Render.world = function(render) {
+ var engine = render.engine,
+ world = engine.world,
+ canvas = render.canvas,
+ context = render.context,
+ options = render.options,
+ allBodies = Composite.allBodies(world),
+ allConstraints = Composite.allConstraints(world),
+ background = options.wireframes ? options.wireframeBackground : options.background,
+ bodies = [],
+ constraints = [],
+ i;
+
+ var event = {
+ timestamp: engine.timing.timestamp
+ };
+
+ Events.trigger(render, 'beforeRender', event);
+
+ // apply background if it has changed
+ if (render.currentBackground !== background)
+ _applyBackground(render, background);
+
+ // clear the canvas with a transparent fill, to allow the canvas background to show
+ context.globalCompositeOperation = 'source-in';
+ context.fillStyle = "transparent";
+ context.fillRect(0, 0, canvas.width, canvas.height);
+ context.globalCompositeOperation = 'source-over';
+
+ // handle bounds
+ if (options.hasBounds) {
+ // filter out bodies that are not in view
+ for (i = 0; i < allBodies.length; i++) {
+ var body = allBodies[i];
+ if (Bounds.overlaps(body.bounds, render.bounds))
+ bodies.push(body);
+ }
+
+ // 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
+ Render.startViewTransform(render);
+
+ // 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
+ });
+
+ Mouse.setOffset(render.mouse, render.bounds.min);
+ }
+ } else {
+ constraints = allConstraints;
+ bodies = allBodies;
+ }
+
+ if (!options.wireframes || (engine.enableSleeping && options.showSleeping)) {
+ // fully featured rendering of bodies
+ Render.bodies(render, bodies, context);
+ } else {
+ if (options.showConvexHulls)
+ Render.bodyConvexHulls(render, bodies, context);
+
+ // optimised method for wireframes only
+ Render.bodyWireframes(render, bodies, context);
+ }
+
+ if (options.showBounds)
+ Render.bodyBounds(render, bodies, context);
+
+ if (options.showAxes || options.showAngleIndicator)
+ Render.bodyAxes(render, bodies, context);
+
+ if (options.showPositions)
+ Render.bodyPositions(render, bodies, context);
+
+ if (options.showVelocity)
+ Render.bodyVelocity(render, bodies, context);
+
+ if (options.showIds)
+ Render.bodyIds(render, bodies, context);
+
+ if (options.showSeparations)
+ Render.separations(render, engine.pairs.list, context);
+
+ if (options.showCollisions)
+ Render.collisions(render, engine.pairs.list, context);
+
+ if (options.showVertexNumbers)
+ Render.vertexNumbers(render, bodies, context);
+
+ if (options.showMousePosition)
+ Render.mousePosition(render, render.mouse, context);
+
+ 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.hasBounds) {
+ // revert view transforms
+ Render.endViewTransform(render);
+ }
+
+ Events.trigger(render, 'afterRender', event);
+ };
+
+ /**
+ * Description
+ * @private
+ * @method debug
+ * @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 = " ";
+
+ if (engine.timing.timestamp - (render.debugTimestamp || 0) >= 500) {
+ var text = "";
+
+ if (metrics.timing) {
+ text += "fps: " + Math.round(metrics.timing.fps) + space;
+ }
+
+
+ render.debugString = text;
+ render.debugTimestamp = engine.timing.timestamp;
+ }
+
+ if (render.debugString) {
+ c.font = "12px Arial";
+
+ 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);
+ }
+ }
+ };
+
+ /**
+ * Description
+ * @private
+ * @method constraints
+ * @param {constraint[]} constraints
+ * @param {RenderingContext} context
+ */
+ Render.constraints = function(constraints, context) {
+ var c = context;
+
+ for (var i = 0; i < constraints.length; i++) {
+ var constraint = constraints[i];
+
+ if (!constraint.render.visible || !constraint.pointA || !constraint.pointB)
+ continue;
+
+ var bodyA = constraint.bodyA,
+ bodyB = constraint.bodyB,
+ start,
+ end;
+
+ if (bodyA) {
+ start = Vector.add(bodyA.position, constraint.pointA);
+ } else {
+ start = constraint.pointA;
+ }
+
+ if (constraint.render.type === 'pin') {
+ c.beginPath();
+ c.arc(start.x, start.y, 3, 0, 2 * Math.PI);
+ c.closePath();
+ } else {
+ if (bodyB) {
+ end = Vector.add(bodyB.position, constraint.pointB);
+ } else {
+ end = constraint.pointB;
+ }
+
+ c.beginPath();
+ c.moveTo(start.x, start.y);
+
+ if (constraint.render.type === 'spring') {
+ var delta = Vector.sub(end, start),
+ normal = Vector.perp(Vector.normalise(delta)),
+ coils = Math.ceil(Common.clamp(constraint.length / 5, 12, 20)),
+ offset;
+
+ for (var j = 1; j < coils; j += 1) {
+ offset = j % 2 === 0 ? 1 : -1;
+
+ c.lineTo(
+ start.x + delta.x * (j / coils) + normal.x * offset * 4,
+ start.y + delta.y * (j / coils) + normal.y * offset * 4
+ );
+ }
+ }
+
+ c.lineTo(end.x, end.y);
+ }
+
+ if (constraint.render.lineWidth) {
+ c.lineWidth = constraint.render.lineWidth;
+ c.strokeStyle = constraint.render.strokeStyle;
+ c.stroke();
+ }
+
+ if (constraint.render.anchors) {
+ c.fillStyle = constraint.render.strokeStyle;
+ c.beginPath();
+ c.arc(start.x, start.y, 3, 0, 2 * Math.PI);
+ c.arc(end.x, end.y, 3, 0, 2 * Math.PI);
+ c.closePath();
+ c.fill();
+ }
+ }
+ };
+
+ /**
+ * 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
+ * @method bodies
+ * @param {render} render
+ * @param {body[]} bodies
+ * @param {RenderingContext} context
+ */
+ Render.bodies = function(render, bodies, context) {
+ var c = context,
+ engine = render.engine,
+ options = render.options,
+ showInternalEdges = options.showInternalEdges || !options.wireframes,
+ body,
+ part,
+ i,
+ k;
+
+ for (i = 0; i < bodies.length; i++) {
+ body = bodies[i];
+
+ if (!body.render.visible)
+ continue;
+
+ // handle compound parts
+ for (k = body.parts.length > 1 ? 1 : 0; k < body.parts.length; k++) {
+ part = body.parts[k];
+
+ if (!part.render.visible)
+ continue;
+
+ if (options.showSleeping && body.isSleeping) {
+ c.globalAlpha = 0.5 * part.render.opacity;
+ } else if (part.render.opacity !== 1) {
+ c.globalAlpha = part.render.opacity;
+ }
+
+ if (part.render.sprite && part.render.sprite.texture && !options.wireframes) {
+ // part sprite
+ var sprite = part.render.sprite,
+ texture = _getTexture(render, sprite.texture);
+
+ c.translate(part.position.x, part.position.y);
+ c.rotate(part.angle);
+
+ c.drawImage(
+ texture,
+ texture.width * -sprite.xOffset * sprite.xScale,
+ texture.height * -sprite.yOffset * sprite.yScale,
+ texture.width * sprite.xScale,
+ texture.height * sprite.yScale
+ );
+
+ // revert translation, hopefully faster than save / restore
+ c.rotate(-part.angle);
+ c.translate(-part.position.x, -part.position.y);
+ } else {
+ // part polygon
+ if (part.circleRadius) {
+ c.beginPath();
+ c.arc(part.position.x, part.position.y, part.circleRadius, 0, 2 * Math.PI);
+ } else {
+ c.beginPath();
+ c.moveTo(part.vertices[0].x, part.vertices[0].y);
+
+ for (var j = 1; j < part.vertices.length; j++) {
+ if (!part.vertices[j - 1].isInternal || showInternalEdges) {
+ c.lineTo(part.vertices[j].x, part.vertices[j].y);
+ } else {
+ c.moveTo(part.vertices[j].x, part.vertices[j].y);
+ }
+
+ if (part.vertices[j].isInternal && !showInternalEdges) {
+ c.moveTo(part.vertices[(j + 1) % part.vertices.length].x, part.vertices[(j + 1) % part.vertices.length].y);
+ }
+ }
+
+ c.lineTo(part.vertices[0].x, part.vertices[0].y);
+ c.closePath();
+ }
+
+ if (!options.wireframes) {
+ c.fillStyle = part.render.fillStyle;
+
+ if (part.render.lineWidth) {
+ c.lineWidth = part.render.lineWidth;
+ c.strokeStyle = part.render.strokeStyle;
+ c.stroke();
+ }
+
+ c.fill();
+ } else {
+ c.lineWidth = 1;
+ c.strokeStyle = '#bbb';
+ c.stroke();
+ }
+ }
+
+ c.globalAlpha = 1;
+ }
+ }
+ };
+
+ /**
+ * Optimised method for drawing body wireframes in one pass
+ * @private
+ * @method bodyWireframes
+ * @param {render} render
+ * @param {body[]} bodies
+ * @param {RenderingContext} context
+ */
+ Render.bodyWireframes = function(render, bodies, context) {
+ var c = context,
+ showInternalEdges = render.options.showInternalEdges,
+ body,
+ part,
+ i,
+ j,
+ k;
+
+ c.beginPath();
+
+ // render all bodies
+ for (i = 0; i < bodies.length; i++) {
+ body = bodies[i];
+
+ if (!body.render.visible)
+ continue;
+
+ // handle compound parts
+ for (k = body.parts.length > 1 ? 1 : 0; k < body.parts.length; k++) {
+ part = body.parts[k];
+
+ c.moveTo(part.vertices[0].x, part.vertices[0].y);
+
+ for (j = 1; j < part.vertices.length; j++) {
+ if (!part.vertices[j - 1].isInternal || showInternalEdges) {
+ c.lineTo(part.vertices[j].x, part.vertices[j].y);
+ } else {
+ c.moveTo(part.vertices[j].x, part.vertices[j].y);
+ }
+
+ if (part.vertices[j].isInternal && !showInternalEdges) {
+ c.moveTo(part.vertices[(j + 1) % part.vertices.length].x, part.vertices[(j + 1) % part.vertices.length].y);
+ }
+ }
+
+ c.lineTo(part.vertices[0].x, part.vertices[0].y);
+ }
+ }
+
+ c.lineWidth = 1;
+ c.strokeStyle = '#bbb';
+ c.stroke();
+ };
+
+ /**
+ * Optimised method for drawing body convex hull wireframes in one pass
+ * @private
+ * @method bodyConvexHulls
+ * @param {render} render
+ * @param {body[]} bodies
+ * @param {RenderingContext} context
+ */
+ Render.bodyConvexHulls = function(render, bodies, context) {
+ var c = context,
+ body,
+ part,
+ i,
+ j,
+ k;
+
+ c.beginPath();
+
+ // render convex hulls
+ for (i = 0; i < bodies.length; i++) {
+ body = bodies[i];
+
+ if (!body.render.visible || body.parts.length === 1)
+ continue;
+
+ c.moveTo(body.vertices[0].x, body.vertices[0].y);
+
+ for (j = 1; j < body.vertices.length; j++) {
+ c.lineTo(body.vertices[j].x, body.vertices[j].y);
+ }
+
+ c.lineTo(body.vertices[0].x, body.vertices[0].y);
+ }
+
+ c.lineWidth = 1;
+ c.strokeStyle = 'rgba(255,255,255,0.2)';
+ c.stroke();
+ };
+
+ /**
+ * Renders body vertex numbers.
+ * @private
+ * @method vertexNumbers
+ * @param {render} render
+ * @param {body[]} bodies
+ * @param {RenderingContext} context
+ */
+ Render.vertexNumbers = function(render, bodies, context) {
+ var c = context,
+ i,
+ j,
+ k;
+
+ for (i = 0; i < bodies.length; i++) {
+ var parts = bodies[i].parts;
+ for (k = parts.length > 1 ? 1 : 0; k < parts.length; k++) {
+ var part = parts[k];
+ for (j = 0; j < part.vertices.length; j++) {
+ c.fillStyle = 'rgba(255,255,255,0.2)';
+ c.fillText(i + '_' + j, part.position.x + (part.vertices[j].x - part.position.x) * 0.8, part.position.y + (part.vertices[j].y - part.position.y) * 0.8);
+ }
+ }
+ }
+ };
+
+ /**
+ * Renders mouse position.
+ * @private
+ * @method mousePosition
+ * @param {render} render
+ * @param {mouse} mouse
+ * @param {RenderingContext} context
+ */
+ Render.mousePosition = function(render, mouse, context) {
+ var c = context;
+ c.fillStyle = 'rgba(255,255,255,0.8)';
+ c.fillText(mouse.position.x + ' ' + mouse.position.y, mouse.position.x + 5, mouse.position.y - 5);
+ };
+
+ /**
+ * Draws body bounds
+ * @private
+ * @method bodyBounds
+ * @param {render} render
+ * @param {body[]} bodies
+ * @param {RenderingContext} context
+ */
+ Render.bodyBounds = function(render, bodies, context) {
+ var c = context,
+ engine = render.engine,
+ options = render.options;
+
+ c.beginPath();
+
+ for (var i = 0; i < bodies.length; i++) {
+ var body = bodies[i];
+
+ if (body.render.visible) {
+ var parts = bodies[i].parts;
+ for (var j = parts.length > 1 ? 1 : 0; j < parts.length; j++) {
+ var part = parts[j];
+ c.rect(part.bounds.min.x, part.bounds.min.y, part.bounds.max.x - part.bounds.min.x, part.bounds.max.y - part.bounds.min.y);
+ }
+ }
+ }
+
+ if (options.wireframes) {
+ c.strokeStyle = 'rgba(255,255,255,0.08)';
+ } else {
+ c.strokeStyle = 'rgba(0,0,0,0.1)';
+ }
+
+ c.lineWidth = 1;
+ c.stroke();
+ };
+
+ /**
+ * Draws body angle indicators and axes
+ * @private
+ * @method bodyAxes
+ * @param {render} render
+ * @param {body[]} bodies
+ * @param {RenderingContext} context
+ */
+ Render.bodyAxes = function(render, bodies, context) {
+ var c = context,
+ engine = render.engine,
+ options = render.options,
+ part,
+ i,
+ j,
+ k;
+
+ c.beginPath();
+
+ for (i = 0; i < bodies.length; i++) {
+ var body = bodies[i],
+ parts = body.parts;
+
+ if (!body.render.visible)
+ continue;
+
+ if (options.showAxes) {
+ // render all axes
+ for (j = parts.length > 1 ? 1 : 0; j < parts.length; j++) {
+ part = parts[j];
+ for (k = 0; k < part.axes.length; k++) {
+ var axis = part.axes[k];
+ c.moveTo(part.position.x, part.position.y);
+ c.lineTo(part.position.x + axis.x * 20, part.position.y + axis.y * 20);
+ }
+ }
+ } else {
+ for (j = parts.length > 1 ? 1 : 0; j < parts.length; j++) {
+ part = parts[j];
+ for (k = 0; k < part.axes.length; k++) {
+ // 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);
+ }
+ }
+ }
+ }
+
+ if (options.wireframes) {
+ c.strokeStyle = 'indianred';
+ c.lineWidth = 1;
+ } else {
+ c.strokeStyle = 'rgba(255, 255, 255, 0.4)';
+ c.globalCompositeOperation = 'overlay';
+ c.lineWidth = 2;
+ }
+
+ c.stroke();
+ c.globalCompositeOperation = 'source-over';
+ };
+
+ /**
+ * Draws body positions
+ * @private
+ * @method bodyPositions
+ * @param {render} render
+ * @param {body[]} bodies
+ * @param {RenderingContext} context
+ */
+ Render.bodyPositions = function(render, bodies, context) {
+ var c = context,
+ engine = render.engine,
+ options = render.options,
+ body,
+ part,
+ i,
+ k;
+
+ c.beginPath();
+
+ // render current positions
+ for (i = 0; i < bodies.length; i++) {
+ body = bodies[i];
+
+ if (!body.render.visible)
+ continue;
+
+ // handle compound parts
+ for (k = 0; k < body.parts.length; k++) {
+ part = body.parts[k];
+ c.arc(part.position.x, part.position.y, 3, 0, 2 * Math.PI, false);
+ c.closePath();
+ }
+ }
+
+ if (options.wireframes) {
+ c.fillStyle = 'indianred';
+ } else {
+ c.fillStyle = 'rgba(0,0,0,0.5)';
+ }
+ c.fill();
+
+ c.beginPath();
+
+ // render previous positions
+ for (i = 0; i < bodies.length; i++) {
+ body = bodies[i];
+ if (body.render.visible) {
+ c.arc(body.positionPrev.x, body.positionPrev.y, 2, 0, 2 * Math.PI, false);
+ c.closePath();
+ }
+ }
+
+ c.fillStyle = 'rgba(255,165,0,0.8)';
+ c.fill();
+ };
+
+ /**
+ * Draws body velocity
+ * @private
+ * @method bodyVelocity
+ * @param {render} render
+ * @param {body[]} bodies
+ * @param {RenderingContext} context
+ */
+ Render.bodyVelocity = function(render, bodies, context) {
+ var c = context;
+
+ c.beginPath();
+
+ for (var i = 0; i < bodies.length; i++) {
+ var body = bodies[i];
+
+ if (!body.render.visible)
+ continue;
+
+ c.moveTo(body.position.x, body.position.y);
+ c.lineTo(body.position.x + (body.position.x - body.positionPrev.x) * 2, body.position.y + (body.position.y - body.positionPrev.y) * 2);
+ }
+
+ c.lineWidth = 3;
+ c.strokeStyle = 'cornflowerblue';
+ c.stroke();
+ };
+
+ /**
+ * Draws body ids
+ * @private
+ * @method bodyIds
+ * @param {render} render
+ * @param {body[]} bodies
+ * @param {RenderingContext} context
+ */
+ Render.bodyIds = function(render, bodies, context) {
+ var c = context,
+ i,
+ j;
+
+ for (i = 0; i < bodies.length; i++) {
+ if (!bodies[i].render.visible)
+ continue;
+
+ var parts = bodies[i].parts;
+ for (j = parts.length > 1 ? 1 : 0; j < parts.length; j++) {
+ var part = parts[j];
+ c.font = "12px Arial";
+ c.fillStyle = 'rgba(255,255,255,0.5)';
+ c.fillText(part.id, part.position.x + 10, part.position.y - 10);
+ }
+ }
+ };
+
+ /**
+ * Description
+ * @private
+ * @method collisions
+ * @param {render} render
+ * @param {pair[]} pairs
+ * @param {RenderingContext} context
+ */
+ Render.collisions = function(render, pairs, context) {
+ var c = context,
+ options = render.options,
+ pair,
+ collision,
+ corrected,
+ bodyA,
+ bodyB,
+ i,
+ j;
+
+ c.beginPath();
+
+ // render collision positions
+ for (i = 0; i < pairs.length; i++) {
+ pair = pairs[i];
+
+ if (!pair.isActive)
+ continue;
+
+ collision = pair.collision;
+ for (j = 0; j < pair.activeContacts.length; j++) {
+ var contact = pair.activeContacts[j],
+ vertex = contact.vertex;
+ c.rect(vertex.x - 1.5, vertex.y - 1.5, 3.5, 3.5);
+ }
+ }
+
+ if (options.wireframes) {
+ c.fillStyle = 'rgba(255,255,255,0.7)';
+ } else {
+ c.fillStyle = 'orange';
+ }
+ c.fill();
+
+ c.beginPath();
+
+ // render collision normals
+ for (i = 0; i < pairs.length; i++) {
+ pair = pairs[i];
+
+ if (!pair.isActive)
+ continue;
+
+ collision = pair.collision;
+
+ if (pair.activeContacts.length > 0) {
+ var normalPosX = pair.activeContacts[0].vertex.x,
+ normalPosY = pair.activeContacts[0].vertex.y;
+
+ if (pair.activeContacts.length === 2) {
+ normalPosX = (pair.activeContacts[0].vertex.x + pair.activeContacts[1].vertex.x) / 2;
+ normalPosY = (pair.activeContacts[0].vertex.y + pair.activeContacts[1].vertex.y) / 2;
+ }
+
+ if (collision.bodyB === collision.supports[0].body || collision.bodyA.isStatic === true) {
+ c.moveTo(normalPosX - collision.normal.x * 8, normalPosY - collision.normal.y * 8);
+ } else {
+ c.moveTo(normalPosX + collision.normal.x * 8, normalPosY + collision.normal.y * 8);
+ }
+
+ c.lineTo(normalPosX, normalPosY);
+ }
+ }
+
+ if (options.wireframes) {
+ c.strokeStyle = 'rgba(255,165,0,0.7)';
+ } else {
+ c.strokeStyle = 'orange';
+ }
+
+ c.lineWidth = 1;
+ c.stroke();
+ };
+
+ /**
+ * Description
+ * @private
+ * @method separations
+ * @param {render} render
+ * @param {pair[]} pairs
+ * @param {RenderingContext} context
+ */
+ Render.separations = function(render, pairs, context) {
+ var c = context,
+ options = render.options,
+ pair,
+ collision,
+ corrected,
+ bodyA,
+ bodyB,
+ i,
+ j;
+
+ c.beginPath();
+
+ // render separations
+ for (i = 0; i < pairs.length; i++) {
+ pair = pairs[i];
+
+ if (!pair.isActive)
+ continue;
+
+ collision = pair.collision;
+ bodyA = collision.bodyA;
+ bodyB = collision.bodyB;
+
+ var k = 1;
+
+ if (!bodyB.isStatic && !bodyA.isStatic) k = 0.5;
+ if (bodyB.isStatic) k = 0;
+
+ c.moveTo(bodyB.position.x, bodyB.position.y);
+ c.lineTo(bodyB.position.x - collision.penetration.x * k, bodyB.position.y - collision.penetration.y * k);
+
+ k = 1;
+
+ if (!bodyB.isStatic && !bodyA.isStatic) k = 0.5;
+ if (bodyA.isStatic) k = 0;
+
+ c.moveTo(bodyA.position.x, bodyA.position.y);
+ c.lineTo(bodyA.position.x + collision.penetration.x * k, bodyA.position.y + collision.penetration.y * k);
+ }
+
+ if (options.wireframes) {
+ c.strokeStyle = 'rgba(255,165,0,0.5)';
+ } else {
+ c.strokeStyle = 'orange';
+ }
+ c.stroke();
+ };
+
+ /**
+ * Description
+ * @private
+ * @method grid
+ * @param {render} render
+ * @param {grid} grid
+ * @param {RenderingContext} context
+ */
+ Render.grid = function(render, grid, context) {
+ var c = context,
+ options = render.options;
+
+ if (options.wireframes) {
+ c.strokeStyle = 'rgba(255,180,0,0.1)';
+ } else {
+ c.strokeStyle = 'rgba(255,180,0,0.5)';
+ }
+
+ c.beginPath();
+
+ var bucketKeys = Common.keys(grid.buckets);
+
+ for (var i = 0; i < bucketKeys.length; i++) {
+ var bucketId = bucketKeys[i];
+
+ if (grid.buckets[bucketId].length < 2)
+ continue;
+
+ 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);
+ }
+
+ c.lineWidth = 1;
+ c.stroke();
+ };
+
+ /**
+ * Description
+ * @private
+ * @method inspector
+ * @param {inspector} inspector
+ * @param {RenderingContext} context
+ */
+ Render.inspector = function(inspector, context) {
+ var engine = inspector.engine,
+ selected = inspector.selected,
+ render = inspector.render,
+ options = render.options,
+ bounds;
+
+ if (options.hasBounds) {
+ 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;
+
+ context.scale(1 / boundsScaleX, 1 / boundsScaleY);
+ context.translate(-render.bounds.min.x, -render.bounds.min.y);
+ }
+
+ for (var i = 0; i < selected.length; i++) {
+ var item = selected[i].data;
+
+ context.translate(0.5, 0.5);
+ context.lineWidth = 1;
+ context.strokeStyle = 'rgba(255,165,0,0.9)';
+ context.setLineDash([1,2]);
+
+ switch (item.type) {
+
+ case 'body':
+
+ // render body selections
+ 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));
+ context.closePath();
+ context.stroke();
+
+ break;
+
+ case 'constraint':
+
+ // render constraint selections
+ var point = item.pointA;
+ if (item.bodyA)
+ point = item.pointB;
+ context.beginPath();
+ context.arc(point.x, point.y, 10, 0, 2 * Math.PI);
+ context.closePath();
+ context.stroke();
+
+ break;
+
+ }
+
+ context.setLineDash([]);
+ context.translate(-0.5, -0.5);
+ }
+
+ // render selection region
+ if (inspector.selectStart !== null) {
+ context.translate(0.5, 0.5);
+ context.lineWidth = 1;
+ context.strokeStyle = 'rgba(255,165,0,0.6)';
+ context.fillStyle = 'rgba(255,165,0,0.1)';
+ 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));
+ context.closePath();
+ context.stroke();
+ context.fill();
+ context.translate(-0.5, -0.5);
+ }
+
+ if (options.hasBounds)
+ context.setTransform(1, 0, 0, 1, 0, 0);
+ };
+
+ /**
+ * Description
+ * @method _createCanvas
+ * @private
+ * @param {} width
+ * @param {} height
+ * @return canvas
+ */
+ var _createCanvas = function(width, height) {
+ var canvas = document.createElement('canvas');
+ canvas.width = width;
+ canvas.height = height;
+ canvas.oncontextmenu = function() { return false; };
+ canvas.onselectstart = function() { return false; };
+ return canvas;
+ };
+
+ /**
+ * Gets the pixel ratio of the canvas.
+ * @method _getPixelRatio
+ * @private
+ * @param {HTMLElement} canvas
+ * @return {Number} pixel ratio
+ */
+ var _getPixelRatio = function(canvas) {
+ var context = canvas.getContext('2d'),
+ devicePixelRatio = window.devicePixelRatio || 1,
+ backingStorePixelRatio = context.webkitBackingStorePixelRatio || context.mozBackingStorePixelRatio
+ || context.msBackingStorePixelRatio || context.oBackingStorePixelRatio
+ || context.backingStorePixelRatio || 1;
+
+ return devicePixelRatio / backingStorePixelRatio;
+ };
+
+ /**
+ * Gets the requested texture (an Image) via its path
+ * @method _getTexture
+ * @private
+ * @param {render} render
+ * @param {string} imagePath
+ * @return {Image} texture
+ */
+ var _getTexture = function(render, imagePath) {
+ var image = render.textures[imagePath];
+
+ if (image)
+ return image;
+
+ image = render.textures[imagePath] = new Image();
+ image.src = imagePath;
+
+ return image;
+ };
+
+ /**
+ * Applies the background to the canvas using CSS.
+ * @method applyBackground
+ * @private
+ * @param {render} render
+ * @param {string} background
+ */
+ var _applyBackground = function(render, background) {
+ var cssBackground = background;
+
+ if (/(jpg|gif|png)$/.test(background))
+ cssBackground = 'url(' + background + ')';
+
+ render.canvas.style.background = cssBackground;
+ render.canvas.style.backgroundSize = "contain";
+ render.currentBackground = background;
+ };
+
+ /*
+ *
+ * Events Documentation
+ *
+ */
+
+ /**
+ * 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
+ */
+
+ /**
+ * 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
+ */
+
+ /*
+ *
+ * Properties Documentation
+ *
+ */
+
+ /**
+ * A back-reference to the `Matter.Render` module.
+ *
+ * @property controller
+ * @type render
+ */
+
+ /**
+ * A reference to the `Matter.Engine` instance to be used.
+ *
+ * @property engine
+ * @type engine
+ */
+
+ /**
+ * A reference to the element where the canvas is to be inserted (if `render.canvas` has not been specified)
+ *
+ * @property element
+ * @type HTMLElement
+ * @default null
+ */
+
+ /**
+ * The canvas element to render to. If not specified, one will be created if `render.element` has been specified.
+ *
+ * @property canvas
+ * @type HTMLCanvasElement
+ * @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`).
+ * This allows for creating views that can pan or zoom around the scene.
+ * You must also set `render.options.hasBounds` to `true` to enable bounded rendering.
+ *
+ * @property bounds
+ * @type bounds
+ */
+
+ /**
+ * The 2d rendering context from the `render.canvas` element.
+ *
+ * @property context
+ * @type CanvasRenderingContext2D
+ */
+
+ /**
+ * The sprite texture cache.
+ *
+ * @property textures
+ * @type {}
+ */
+
+})();
+
+},{"../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){
+/**
+* The `Matter.RenderPixi` module is an example renderer using pixi.js.
+* See also `Matter.Render` for a canvas based renderer.
+*
+* @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).
+*/
+
+var RenderPixi = {};
+
+module.exports = RenderPixi;
+
+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() {
+
+ var _requestAnimationFrame,
+ _cancelAnimationFrame;
+
+ if (typeof window !== 'undefined') {
+ _requestAnimationFrame = window.requestAnimationFrame || window.webkitRequestAnimationFrame
+ || window.mozRequestAnimationFrame || window.msRequestAnimationFrame
+ || function(callback){ window.setTimeout(function() { callback(Common.now()); }, 1000 / 60); };
+
+ _cancelAnimationFrame = window.cancelAnimationFrame || window.mozCancelAnimationFrame
+ || window.webkitCancelAnimationFrame || window.msCancelAnimationFrame;
+ }
+
+ /**
+ * Creates a new Pixi.js WebGL renderer
+ * @method create
+ * @param {object} options
+ * @return {RenderPixi} A new renderer
+ * @deprecated
+ */
+ RenderPixi.create = function(options) {
+ Common.warn('RenderPixi.create: Matter.RenderPixi is deprecated (see docs)');
+
+ var defaults = {
+ controller: RenderPixi,
+ engine: null,
+ element: null,
+ 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
+ }
+ };
+
+ var render = Common.extend(defaults, options),
+ transparent = !render.options.wireframes && render.options.background === 'transparent';
+
+ // init pixi
+ render.pixiOptions = render.pixiOptions || {
+ view: render.canvas,
+ transparent: transparent,
+ antialias: true,
+ backgroundColor: options.background
+ };
+
+ 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;
+ };
+
+ /**
+ * Continuously updates the render canvas on the `requestAnimationFrame` event.
+ * @method run
+ * @param {render} render
+ * @deprecated
+ */
+ RenderPixi.run = function(render) {
+ (function loop(time){
+ render.frameRequestId = _requestAnimationFrame(loop);
+ RenderPixi.world(render);
+ })();
+ };
+
+ /**
+ * Ends execution of `Render.run` on the given `render`, by canceling the animation frame request event loop.
+ * @method stop
+ * @param {render} render
+ * @deprecated
+ */
+ RenderPixi.stop = function(render) {
+ _cancelAnimationFrame(render.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
+ * @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);
+ };
+
+
+ /**
+ * 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;
+ }
+ };
+
+ /**
+ * 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;
+ };
+
+ /**
+ * Creates a body primitive
+ * @method _createBodyPrimitive
+ * @private
+ * @param {RenderPixi} render
+ * @param {body} body
+ * @return {PIXI.Graphics} graphics
+ * @deprecated
+ */
+ 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();
+
+ // handle compound parts
+ for (var k = body.parts.length > 1 ? 1 : 0; k < body.parts.length; k++) {
+ part = body.parts[k];
+
+ 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);
+ }
+
+ primitive.lineTo(part.vertices[0].x - body.position.x, part.vertices[0].y - body.position.y);
+
+ primitive.endFill();
+
+ // angle indicator
+ if (options.showAngleIndicator || options.showAxes) {
+ primitive.beginFill(0, 0);
+
+ if (options.wireframes) {
+ primitive.lineStyle(1, strokeStyleWireframeIndicator, 1);
+ } else {
+ primitive.lineStyle(1, strokeStyleIndicator);
+ }
+
+ 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));
+
+ primitive.endFill();
+ }
+ }
+
+ return primitive;
+ };
+
+ /**
+ * 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];
+
+ if (!texture)
+ texture = render.textures[imagePath] = PIXI.Texture.fromImage(imagePath);
+
+ return texture;
+ };
+
+})();
+
+},{"../body/Composite":2,"../core/Common":14,"../core/Events":16,"../geometry/Bounds":26,"../geometry/Vector":28}]},{},[30])(30)
+});
diff --git a/CM2030 Graphics Programming/Topic 4/4.2.3/libraries/p5.min.js b/CM2030 Graphics Programming/Topic 4/4.2.3/libraries/p5.min.js
new file mode 100644
index 0000000..4eaaad2
--- /dev/null
+++ b/CM2030 Graphics Programming/Topic 4/4.2.3/libraries/p5.min.js
@@ -0,0 +1,3 @@
+/*! p5.js v0.10.2 October 14, 2019 */
+
+!function(e){if("object"==typeof exports&&"undefined"!=typeof module)module.exports=e();else if("function"==typeof define&&define.amd)define([],e);else{("undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof self?self:this).p5=e()}}(function(){return function n(o,s,l){function u(t,e){if(!s[t]){if(!o[t]){var r="function"==typeof require&&require;if(!e&&r)return r(t,!0);if(h)return h(t,!0);var i=new Error("Cannot find module '"+t+"'");throw i.code="MODULE_NOT_FOUND",i}var a=s[t]={exports:{}};o[t][0].call(a.exports,function(e){return u(o[t][1][e]||e)},a,a.exports,n,o,s,l)}return s[t].exports}for(var h="function"==typeof require&&require,e=0;e>16&255,n[o++]=t>>8&255,n[o++]=255&t;var u,h;2===a&&(t=d[e.charCodeAt(l)]<<2|d[e.charCodeAt(l+1)]>>4,n[o++]=255&t);1===a&&(t=d[e.charCodeAt(l)]<<10|d[e.charCodeAt(l+1)]<<4|d[e.charCodeAt(l+2)]>>2,n[o++]=t>>8&255,n[o++]=255&t);return n},r.fromByteArray=function(e){for(var t,r=e.length,i=r%3,a=[],n=0,o=r-i;n>2]+s[t<<4&63]+"==")):2===i&&(t=(e[r-2]<<8)+e[r-1],a.push(s[t>>10]+s[t>>4&63]+s[t<<2&63]+"="));return a.join("")};for(var s=[],d=[],c="undefined"!=typeof Uint8Array?Uint8Array:Array,i="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/",a=0,n=i.length;a>18&63]+s[a>>12&63]+s[a>>6&63]+s[63&a]);return n.join("")}d["-".charCodeAt(0)]=62,d["_".charCodeAt(0)]=63},{}],2:[function(e,t,r){},{}],3:[function(e,t,r){"use strict";var i=e("base64-js"),n=e("ieee754");r.Buffer=d,r.SlowBuffer=function(e){+e!=e&&(e=0);return d.alloc(+e)},r.INSPECT_MAX_BYTES=50;var a=2147483647;function o(e){if(a>>1;case"base64":return I(e).length;default:if(a)return i?-1:A(e).length;t=(""+t).toLowerCase(),a=!0}}function p(e,t,r){var i=e[t];e[t]=e[r],e[r]=i}function m(e,t,r,i,a){if(0===e.length)return-1;if("string"==typeof r?(i=r,r=0):2147483647=e.length){if(a)return-1;r=e.length-1}else if(r<0){if(!a)return-1;r=0}if("string"==typeof t&&(t=d.from(t,i)),d.isBuffer(t))return 0===t.length?-1:v(e,t,r,i,a);if("number"==typeof t)return t&=255,"function"==typeof Uint8Array.prototype.indexOf?a?Uint8Array.prototype.indexOf.call(e,t,r):Uint8Array.prototype.lastIndexOf.call(e,t,r):v(e,[t],r,i,a);throw new TypeError("val must be string, number or Buffer")}function v(e,t,r,i,a){var n,o=1,s=e.length,l=t.length;if(void 0!==i&&("ucs2"===(i=String(i).toLowerCase())||"ucs-2"===i||"utf16le"===i||"utf-16le"===i)){if(e.length<2||t.length<2)return-1;s/=o=2,l/=2,r/=2}function u(e,t){return 1===o?e[t]:e.readUInt16BE(t*o)}if(a){var h=-1;for(n=r;n>>10&1023|55296),h=56320|1023&h),i.push(h),a+=d}return function(e){var t=e.length;if(t<=x)return String.fromCharCode.apply(String,e);var r="",i=0;for(;ithis.length)return"";if((void 0===r||r>this.length)&&(r=this.length),r<=0)return"";if((r>>>=0)<=(t>>>=0))return"";for(e||(e="utf8");;)switch(e){case"hex":return M(this,t,r);case"utf8":case"utf-8":return b(this,t,r);case"ascii":return w(this,t,r);case"latin1":case"binary":return S(this,t,r);case"base64":return _(this,t,r);case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return E(this,t,r);default:if(i)throw new TypeError("Unknown encoding: "+e);e=(e+"").toLowerCase(),i=!0}}.apply(this,arguments)},d.prototype.equals=function(e){if(!d.isBuffer(e))throw new TypeError("Argument must be a Buffer");return this===e||0===d.compare(this,e)},d.prototype.inspect=function(){var e="",t=r.INSPECT_MAX_BYTES;return e=this.toString("hex",0,t).replace(/(.{2})/g,"$1 ").trim(),this.length>t&&(e+=" ... "),""},d.prototype.compare=function(e,t,r,i,a){if(U(e,Uint8Array)&&(e=d.from(e,e.offset,e.byteLength)),!d.isBuffer(e))throw new TypeError('The "target" argument must be one of type Buffer or Uint8Array. Received type '+typeof e);if(void 0===t&&(t=0),void 0===r&&(r=e?e.length:0),void 0===i&&(i=0),void 0===a&&(a=this.length),t<0||r>e.length||i<0||a>this.length)throw new RangeError("out of range index");if(a<=i&&r<=t)return 0;if(a<=i)return-1;if(r<=t)return 1;if(this===e)return 0;for(var n=(a>>>=0)-(i>>>=0),o=(r>>>=0)-(t>>>=0),s=Math.min(n,o),l=this.slice(i,a),u=e.slice(t,r),h=0;h>>=0,isFinite(r)?(r>>>=0,void 0===i&&(i="utf8")):(i=r,r=void 0)}var a=this.length-t;if((void 0===r||athis.length)throw new RangeError("Attempt to write outside buffer bounds");i||(i="utf8");for(var n,o,s,l,u,h,d,c,f,p=!1;;)switch(i){case"hex":return g(this,e,t,r);case"utf8":case"utf-8":return c=t,f=r,k(A(e,(d=this).length-c),d,c,f);case"ascii":return y(this,e,t,r);case"latin1":case"binary":return y(this,e,t,r);case"base64":return l=this,u=t,h=r,k(I(e),l,u,h);case"ucs2":case"ucs-2":case"utf16le":case"utf-16le":return o=t,s=r,k(function(e,t){for(var r,i,a,n=[],o=0;o>8,a=r%256,n.push(a),n.push(i);return n}(e,(n=this).length-o),n,o,s);default:if(p)throw new TypeError("Unknown encoding: "+i);i=(""+i).toLowerCase(),p=!0}},d.prototype.toJSON=function(){return{type:"Buffer",data:Array.prototype.slice.call(this._arr||this,0)}};var x=4096;function w(e,t,r){var i="";r=Math.min(e.length,r);for(var a=t;ae.length)throw new RangeError("Index out of range")}function P(e,t,r,i,a,n){if(r+i>e.length)throw new RangeError("Index out of range");if(r<0)throw new RangeError("Index out of range")}function L(e,t,r,i,a){return t=+t,r>>>=0,a||P(e,0,r,4),n.write(e,t,r,i,23,4),r+4}function R(e,t,r,i,a){return t=+t,r>>>=0,a||P(e,0,r,8),n.write(e,t,r,i,52,8),r+8}d.prototype.slice=function(e,t){var r=this.length;(e=~~e)<0?(e+=r)<0&&(e=0):r>>=0,t>>>=0,r||T(e,t,this.length);for(var i=this[e],a=1,n=0;++n>>=0,t>>>=0,r||T(e,t,this.length);for(var i=this[e+--t],a=1;0>>=0,t||T(e,1,this.length),this[e]},d.prototype.readUInt16LE=function(e,t){return e>>>=0,t||T(e,2,this.length),this[e]|this[e+1]<<8},d.prototype.readUInt16BE=function(e,t){return e>>>=0,t||T(e,2,this.length),this[e]<<8|this[e+1]},d.prototype.readUInt32LE=function(e,t){return e>>>=0,t||T(e,4,this.length),(this[e]|this[e+1]<<8|this[e+2]<<16)+16777216*this[e+3]},d.prototype.readUInt32BE=function(e,t){return e>>>=0,t||T(e,4,this.length),16777216*this[e]+(this[e+1]<<16|this[e+2]<<8|this[e+3])},d.prototype.readIntLE=function(e,t,r){e>>>=0,t>>>=0,r||T(e,t,this.length);for(var i=this[e],a=1,n=0;++n>>=0,t>>>=0,r||T(e,t,this.length);for(var i=t,a=1,n=this[e+--i];0>>=0,t||T(e,1,this.length),128&this[e]?-1*(255-this[e]+1):this[e]},d.prototype.readInt16LE=function(e,t){e>>>=0,t||T(e,2,this.length);var r=this[e]|this[e+1]<<8;return 32768&r?4294901760|r:r},d.prototype.readInt16BE=function(e,t){e>>>=0,t||T(e,2,this.length);var r=this[e+1]|this[e]<<8;return 32768&r?4294901760|r:r},d.prototype.readInt32LE=function(e,t){return e>>>=0,t||T(e,4,this.length),this[e]|this[e+1]<<8|this[e+2]<<16|this[e+3]<<24},d.prototype.readInt32BE=function(e,t){return e>>>=0,t||T(e,4,this.length),this[e]<<24|this[e+1]<<16|this[e+2]<<8|this[e+3]},d.prototype.readFloatLE=function(e,t){return e>>>=0,t||T(e,4,this.length),n.read(this,e,!0,23,4)},d.prototype.readFloatBE=function(e,t){return e>>>=0,t||T(e,4,this.length),n.read(this,e,!1,23,4)},d.prototype.readDoubleLE=function(e,t){return e>>>=0,t||T(e,8,this.length),n.read(this,e,!0,52,8)},d.prototype.readDoubleBE=function(e,t){return e>>>=0,t||T(e,8,this.length),n.read(this,e,!1,52,8)},d.prototype.writeUIntLE=function(e,t,r,i){(e=+e,t>>>=0,r>>>=0,i)||C(this,e,t,r,Math.pow(2,8*r)-1,0);var a=1,n=0;for(this[t]=255&e;++n>>=0,r>>>=0,i)||C(this,e,t,r,Math.pow(2,8*r)-1,0);var a=r-1,n=1;for(this[t+a]=255&e;0<=--a&&(n*=256);)this[t+a]=e/n&255;return t+r},d.prototype.writeUInt8=function(e,t,r){return e=+e,t>>>=0,r||C(this,e,t,1,255,0),this[t]=255&e,t+1},d.prototype.writeUInt16LE=function(e,t,r){return e=+e,t>>>=0,r||C(this,e,t,2,65535,0),this[t]=255&e,this[t+1]=e>>>8,t+2},d.prototype.writeUInt16BE=function(e,t,r){return e=+e,t>>>=0,r||C(this,e,t,2,65535,0),this[t]=e>>>8,this[t+1]=255&e,t+2},d.prototype.writeUInt32LE=function(e,t,r){return e=+e,t>>>=0,r||C(this,e,t,4,4294967295,0),this[t+3]=e>>>24,this[t+2]=e>>>16,this[t+1]=e>>>8,this[t]=255&e,t+4},d.prototype.writeUInt32BE=function(e,t,r){return e=+e,t>>>=0,r||C(this,e,t,4,4294967295,0),this[t]=e>>>24,this[t+1]=e>>>16,this[t+2]=e>>>8,this[t+3]=255&e,t+4},d.prototype.writeIntLE=function(e,t,r,i){if(e=+e,t>>>=0,!i){var a=Math.pow(2,8*r-1);C(this,e,t,r,a-1,-a)}var n=0,o=1,s=0;for(this[t]=255&e;++n>0)-s&255;return t+r},d.prototype.writeIntBE=function(e,t,r,i){if(e=+e,t>>>=0,!i){var a=Math.pow(2,8*r-1);C(this,e,t,r,a-1,-a)}var n=r-1,o=1,s=0;for(this[t+n]=255&e;0<=--n&&(o*=256);)e<0&&0===s&&0!==this[t+n+1]&&(s=1),this[t+n]=(e/o>>0)-s&255;return t+r},d.prototype.writeInt8=function(e,t,r){return e=+e,t>>>=0,r||C(this,e,t,1,127,-128),e<0&&(e=255+e+1),this[t]=255&e,t+1},d.prototype.writeInt16LE=function(e,t,r){return e=+e,t>>>=0,r||C(this,e,t,2,32767,-32768),this[t]=255&e,this[t+1]=e>>>8,t+2},d.prototype.writeInt16BE=function(e,t,r){return e=+e,t>>>=0,r||C(this,e,t,2,32767,-32768),this[t]=e>>>8,this[t+1]=255&e,t+2},d.prototype.writeInt32LE=function(e,t,r){return e=+e,t>>>=0,r||C(this,e,t,4,2147483647,-2147483648),this[t]=255&e,this[t+1]=e>>>8,this[t+2]=e>>>16,this[t+3]=e>>>24,t+4},d.prototype.writeInt32BE=function(e,t,r){return e=+e,t>>>=0,r||C(this,e,t,4,2147483647,-2147483648),e<0&&(e=4294967295+e+1),this[t]=e>>>24,this[t+1]=e>>>16,this[t+2]=e>>>8,this[t+3]=255&e,t+4},d.prototype.writeFloatLE=function(e,t,r){return L(this,e,t,!0,r)},d.prototype.writeFloatBE=function(e,t,r){return L(this,e,t,!1,r)},d.prototype.writeDoubleLE=function(e,t,r){return R(this,e,t,!0,r)},d.prototype.writeDoubleBE=function(e,t,r){return R(this,e,t,!1,r)},d.prototype.copy=function(e,t,r,i){if(!d.isBuffer(e))throw new TypeError("argument should be a Buffer");if(r||(r=0),i||0===i||(i=this.length),t>=e.length&&(t=e.length),t||(t=0),0=this.length)throw new RangeError("Index out of range");if(i<0)throw new RangeError("sourceEnd out of bounds");i>this.length&&(i=this.length),e.length-t>>=0,r=void 0===r?this.length:r>>>0,e||(e=0),"number"==typeof e)for(n=t;n>6|192,63&r|128)}else if(r<65536){if((t-=3)<0)break;n.push(r>>12|224,r>>6&63|128,63&r|128)}else{if(!(r<1114112))throw new Error("Invalid code point");if((t-=4)<0)break;n.push(r>>18|240,r>>12&63|128,r>>6&63|128,63&r|128)}}return n}function I(e){return i.toByteArray(function(e){if((e=(e=e.split("=")[0]).trim().replace(O,"")).length<2)return"";for(;e.length%4!=0;)e+="=";return e}(e))}function k(e,t,r,i){for(var a=0;a=t.length||a>=e.length);++a)t[a+r]=e[a];return a}function U(e,t){return e instanceof t||null!=e&&null!=e.constructor&&null!=e.constructor.name&&e.constructor.name===t.name}function F(e){return e!=e}},{"base64-js":1,ieee754:8}],4:[function(e,t,r){"use strict";t.exports=e("./").polyfill()},{"./":5}],5:[function(V,r,i){(function(G,j){var e,t;e=this,t=function(){"use strict";function u(e){return"function"==typeof e}var r=Array.isArray?Array.isArray:function(e){return"[object Array]"===Object.prototype.toString.call(e)},i=0,t=void 0,a=void 0,s=function(e,t){c[i]=e,c[i+1]=t,2===(i+=2)&&(a?a(f):y())};var e="undefined"!=typeof window?window:void 0,n=e||{},o=n.MutationObserver||n.WebKitMutationObserver,l="undefined"==typeof self&&void 0!==G&&"[object process]"==={}.toString.call(G),h="undefined"!=typeof Uint8ClampedArray&&"undefined"!=typeof importScripts&&"undefined"!=typeof MessageChannel;function d(){var e=setTimeout;return function(){return e(f,1)}}var c=new Array(1e3);function f(){for(var e=0;e>1,h=-7,d=r?a-1:0,c=r?-1:1,f=e[t+d];for(d+=c,n=f&(1<<-h)-1,f>>=-h,h+=s;0>=-h,h+=i;0>1,c=23===a?Math.pow(2,-24)-Math.pow(2,-77):0,f=i?0:n-1,p=i?1:-1,m=t<0||0===t&&1/t<0?1:0;for(t=Math.abs(t),isNaN(t)||t===1/0?(s=isNaN(t)?1:0,o=h):(o=Math.floor(Math.log(t)/Math.LN2),t*(l=Math.pow(2,-o))<1&&(o--,l*=2),2<=(t+=1<=o+d?c/l:c*Math.pow(2,1-d))*l&&(o++,l/=2),h<=o+d?(s=0,o=h):1<=o+d?(s=(t*l-1)*Math.pow(2,a),o+=d):(s=t*Math.pow(2,d-1)*Math.pow(2,a),o=0));8<=a;e[r+f]=255&s,f+=p,s/=256,a-=8);for(o=o<Math.abs(e[0])&&(t=1),Math.abs(e[2])>Math.abs(e[t])&&(t=2),t}var C=4e150;function P(e,t){e.f+=t.f,e.b.f+=t.b.f}function u(e,t,r){return e=e.a,t=t.a,r=r.a,t.b.a===e?r.b.a===e?g(t.a,r.a)?_(r.b.a,t.a,r.a)<=0:0<=_(t.b.a,r.a,t.a):_(r.b.a,e,r.a)<=0:r.b.a===e?0<=_(t.b.a,e,t.a):(t=y(t.b.a,e,t.a),(e=y(r.b.a,e,r.a))<=t)}function L(e){e.a.i=null;var t=e.e;t.a.c=t.c,t.c.a=t.a,e.e=null}function h(e,t){d(e.a),e.c=!1,(e.a=t).i=e}function R(e){for(var t=e.a.a;(e=ce(e)).a.a===t;);return e.c&&(h(e,t=c(de(e).a.b,e.a.e)),e=ce(e)),e}function O(e,t,r){var i=new he;return i.a=r,i.e=W(e.f,t.e,i),r.i=i}function D(e,t){switch(e.s){case 100130:return 0!=(1&t);case 100131:return 0!==t;case 100132:return 0>1]],s[o[u]])?le(r,u):ue(r,u)),s[n]=null,l[n]=r.b,r.b=n}else for(r.c[-(n+1)]=null;0Math.max(o.a,l.a))return!1;if(g(n,o)){if(0<_(l,n,o))return!1}else if(_(s,o,n)<0)return!1;var h,d,c=s,f=n,p=l,m=o;if(g(c,f)||(h=c,c=f,f=h),g(p,m)||(h=p,p=m,m=h),g(c,p)||(h=c,c=p,p=h,h=f,f=m,m=h),g(p,f)?g(f,m)?((h=y(c,p,f))+(d=y(p,f,m))<0&&(h=-h,d=-d),u.b=S(h,p.b,d,f.b)):((h=_(c,p,f))+(d=-_(c,m,f))<0&&(h=-h,d=-d),u.b=S(h,p.b,d,m.b)):u.b=(p.b+f.b)/2,b(c,f)||(h=c,c=f,f=h),b(p,m)||(h=p,p=m,m=h),b(c,p)||(h=c,c=p,p=h,h=f,f=m,m=h),b(p,f)?b(f,m)?((h=x(c,p,f))+(d=x(p,f,m))<0&&(h=-h,d=-d),u.a=S(h,p.a,d,f.a)):((h=w(c,p,f))+(d=-w(c,m,f))<0&&(h=-h,d=-d),u.a=S(h,p.a,d,m.a)):u.a=(p.a+f.a)/2,g(u,e.a)&&(u.b=e.a.b,u.a=e.a.a),g(c=g(n,o)?n:o,u)&&(u.b=c.b,u.a=c.a),v(u,n)||v(u,o))return B(e,t),!1;if(!v(s,e.a)&&0<=_(s,e.a,u)||!v(l,e.a)&&_(l,e.a,u)<=0){if(l===e.a)return E(i.b),M(a.b,i),i=de(t=R(t)).a,I(e,de(t),r),k(e,t,J(i),i,i,!0),!0;if(s!==e.a)return 0<=_(s,e.a,u)&&(ce(t).b=t.b=!0,E(i.b),i.a.b=e.a.b,i.a.a=e.a.a),_(l,e.a,u)<=0&&(t.b=r.b=!0,E(a.b),a.a.b=e.a.b,a.a.a=e.a.a),!1;for(E(a.b),M(i.e,J(a)),o=(n=r=t).a.b.a;(n=ce(n)).a.b.a===o;);return n=de(t=n).a.b.c,r.a=J(a),k(e,t,(a=I(e,r,null)).c,i.b.c,n,!0),!0}return E(i.b),E(a.b),M(J(a),i),i.a.b=u.b,i.a.a=u.a,i.a.h=re(e.e,i.a),i=i.a,a=[0,0,0,0],u=[n.d,s.d,o.d,l.d],i.g[0]=i.g[1]=i.g[2]=0,N(i,n,s,a,0),N(i,o,l,a,2),U(e,i,u,a,!0),ce(t).b=t.b=r.b=!0,!1}function j(e,t){for(var r=de(t);;){for(;r.b;)r=de(t=r);if(!t.b&&(null===(t=ce(r=t))||!t.b))break;t.b=!1;var i,a=t.a,n=r.a;if(i=a.b.a!==n.b.a)e:{var o=de(i=t),s=i.a,l=o.a,u=void 0;if(g(s.b.a,l.b.a)){if(_(s.b.a,l.b.a,s.a)<0){i=!1;break e}ce(i).b=i.b=!0,u=E(s),M(l.b,u),u.d.c=i.d}else{if(0<_(l.b.a,s.b.a,l.a)){i=!1;break e}i.b=o.b=!0,u=E(l),M(s.e,l.b),u.b.d.c=i.d}i=!0}if(i&&(r.c?(L(r),d(n),n=(r=de(t)).a):t.c&&(L(t),d(a),a=(t=ce(r)).a)),a.a!==n.a)if(a.b.a===n.b.a||t.c||r.c||a.b.a!==e.a&&n.b.a!==e.a)B(e,t);else if(G(e,t))break;a.a===n.a&&a.b.a===n.b.a&&(P(n,a),L(t),d(a),t=ce(r))}}function V(e,t){for(var r=(e.a=t).c;null===r.i;)if((r=r.c)===t.c){r=e;var i=t;(o=new he).a=i.c.b;for(var a=(l=r.f).a;null!==(a=a.a).b&&!l.c(l.b,o,a.b););var n=de(l=a.b),o=l.a;a=n.a;if(0===_(o.b.a,i,o.a))v((o=l.a).a,i)||v(o.b.a,i)||(E(o.b),l.c&&(d(o.c),l.c=!1),M(i.c,o),V(r,i));else{var s=g(a.b.a,o.b.a)?l:n;n=void 0;l.d||s.c?(n=s===l?c(i.c.b,o.e):c(a.b.c.b,i.c).b,s.c?h(s,n):((l=O(o=r,l,n)).f=ce(l).f+l.a.f,l.d=D(o,l.f)),V(r,i)):k(r,l,i.c,i.c,null,!0)}return}if(l=(o=de(r=R(r.i))).a,(o=I(e,o,null)).c===l){o=(l=o).c,a=de(r),n=r.a,s=a.a;var l,u=!1;n.b.a!==s.b.a&&G(e,r),v(n.a,e.a)&&(M(J(o),n),o=de(r=R(r)).a,I(e,de(r),a),u=!0),v(s.a,e.a)&&(M(l,J(s)),l=I(e,a,null),u=!0),u?k(e,r,l.c,o,o,!0):(i=g(s.a,n.a)?J(s):n,k(e,r,i=c(l.c.b,i),i.c,i.c,!1),i.b.i.c=!0,j(e,r))}else k(e,r,o.c,l,l,!0)}function z(e,t){var r=new he,i=o(e.b);i.a.b=C,i.a.a=t,i.b.a.b=-C,i.b.a.a=t,e.a=i.b.a,r.a=i,r.f=0,r.d=!1,r.c=!1,r.h=!0,r.b=!1,i=W(i=e.f,i.a,r),r.e=i}function H(e){this.a=new X,this.b=e,this.c=u}function W(e,t,r){for(;null!==(t=t.c).b&&!e.c(e.b,t.b,r););return e=new X(r,t.a,t),t.a.c=e,t.a=e}function X(e,t,r){this.b=e||null,this.a=t||this,this.c=r||this}function q(){this.d=0,this.p=this.b=this.q=null,this.j=[0,0,0],this.s=100130,this.n=!1,this.o=this.a=this.e=this.f=null,this.m=!1,this.c=this.r=this.i=this.k=this.l=this.h=null}function Y(e,t){if(e.d!==t)for(;e.d!==t;)if(e.di.f&&(i.f*=2,i.c=ne(i.c,i.f+1)),0===i.b?r=a:(r=i.b,i.b=i.c[i.b]),i.e[r]=t,i.c[r]=a,i.d[a]=r,i.h&&ue(i,a),r}return i=e.a++,e.c[i]=t,-(i+1)}function ie(e){if(0===e.a)return se(e.b);var t=e.c[e.d[e.a-1]];if(0!==e.b.a&&g(oe(e.b),t))return se(e.b);for(;--e.a,0e.a||g(i[o],i[l])){a[r[n]=o]=n;break}a[r[n]=l]=n,n=s}}function ue(e,t){for(var r=e.d,i=e.e,a=e.c,n=t,o=r[n];;){var s=n>>1,l=r[s];if(0===s||g(i[l],i[o])){a[r[n]=o]=n;break}a[r[n]=l]=n,n=s}}function he(){this.e=this.a=null,this.f=0,this.c=this.b=this.h=this.d=!1}function de(e){return e.e.c.b}function ce(e){return e.e.a.b}(i=q.prototype).x=function(){Y(this,0)},i.B=function(e,t){switch(e){case 100142:return;case 100140:switch(t){case 100130:case 100131:case 100132:case 100133:case 100134:return void(this.s=t)}break;case 100141:return void(this.m=!!t);default:return void Z(this,100900)}Z(this,100901)},i.y=function(e){switch(e){case 100142:return 0;case 100140:return this.s;case 100141:return this.m;default:Z(this,100900)}return!1},i.A=function(e,t,r){this.j[0]=e,this.j[1]=t,this.j[2]=r},i.z=function(e,t){var r=t||null;switch(e){case 100100:case 100106:this.h=r;break;case 100104:case 100110:this.l=r;break;case 100101:case 100107:this.k=r;break;case 100102:case 100108:this.i=r;break;case 100103:case 100109:this.p=r;break;case 100105:case 100111:this.o=r;break;case 100112:this.r=r;break;default:Z(this,100900)}},i.C=function(e,t){var r=!1,i=[0,0,0];Y(this,2);for(var a=0;a<3;++a){var n=e[a];n<-1e150&&(n=-1e150,r=!0),1e150a[u]&&(a[u]=h,o[u]=l)}if(l=0,a[1]-n[1]>a[0]-n[0]&&(l=1),a[2]-n[2]>a[l]-n[l]&&(l=2),n[l]>=a[l])i[0]=0,i[1]=0,i[2]=1;else{for(a=0,n=s[l],o=o[l],s=[0,0,0],n=[n.g[0]-o.g[0],n.g[1]-o.g[1],n.g[2]-o.g[2]],u=[0,0,0],l=r.e;l!==r;l=l.e)u[0]=l.g[0]-o.g[0],u[1]=l.g[1]-o.g[1],u[2]=l.g[2]-o.g[2],s[0]=n[1]*u[2]-n[2]*u[1],s[1]=n[2]*u[0]-n[0]*u[2],s[2]=n[0]*u[1]-n[1]*u[0],a<(h=s[0]*s[0]+s[1]*s[1]+s[2]*s[2])&&(a=h,i[0]=s[0],i[1]=s[1],i[2]=s[2]);a<=0&&(i[0]=i[1]=i[2]=0,i[T(n)]=1)}r=!0}for(s=T(i),l=this.b.c,a=(s+1)%3,o=(s+2)%3,s=0>=l,h-=l,v!==n){if(v===o)break;for(var g=v>8,++y;var b=_;if(i>=8;null!==m&&s<4096&&(p[s++]=m<<8|b,u+1<=s&&l<12&&(++l,u=u<<1|1)),m=v}else s=o+1,u=(1<<(l=a+1))-1,m=null}return c!==i&&console.log("Warning, gif stream shorter than expected."),r}try{r.GifWriter=function(g,e,t,r){var y=0,i=void 0===(r=void 0===r?{}:r).loop?null:r.loop,_=void 0===r.palette?null:r.palette;if(e<=0||t<=0||65535>=1;)++a;if(o=1<>8&255,g[y++]=255&t,g[y++]=t>>8&255,g[y++]=(null!==_?128:0)|a,g[y++]=n,g[y++]=0,null!==_)for(var s=0,l=_.length;s>16&255,g[y++]=u>>8&255,g[y++]=255&u}if(null!==i){if(i<0||65535>8&255,g[y++]=0}var x=!1;this.addFrame=function(e,t,r,i,a,n){if(!0===x&&(--y,x=!1),n=void 0===n?{}:n,e<0||t<0||65535>=1;)++u;l=1<>8&255,g[y++]=f,g[y++]=0),g[y++]=44,g[y++]=255&e,g[y++]=e>>8&255,g[y++]=255&t,g[y++]=t>>8&255,g[y++]=255&r,g[y++]=r>>8&255,g[y++]=255&i,g[y++]=i>>8&255,g[y++]=!0===o?128|u-1:0,!0===o)for(var p=0,m=s.length;p>16&255,g[y++]=v>>8&255,g[y++]=255&v}return y=function(t,r,e,i){t[r++]=e;var a=r++,n=1<>=8,h-=8,r===a+256&&(t[a]=255,a=r++)}function f(e){d|=e<>=8,h-=8,r===a+256&&(t[a]=255,a=r++);4096===l?(f(n),l=s+1,u=e+1,m={}):(1<>7,a=1<<1+(7&r);x[e++],x[e++];var n=null,o=null;i&&(n=e,e+=3*(o=a));var s=!0,l=[],u=0,h=null,d=0,c=null;for(this.width=w,this.height=t;s&&e>2&7,e++;break;case 254:for(;;){if(!(0<=(C=x[e++])))throw Error("Invalid block size");if(0===C)break;e+=C}break;default:throw new Error("Unknown graphic control label: 0x"+x[e-1].toString(16))}break;case 44:var p=x[e++]|x[e++]<<8,m=x[e++]|x[e++]<<8,v=x[e++]|x[e++]<<8,g=x[e++]|x[e++]<<8,y=x[e++],_=y>>6&1,b=1<<1+(7&y),S=n,M=o,E=!1;y>>7&&(E=!0,S=e,e+=3*(M=b));var T=e;for(e++;;){var C;if(!(0<=(C=x[e++])))throw Error("Invalid block size");if(0===C)break;e+=C}l.push({x:p,y:m,width:v,height:g,has_local_palette:E,palette_offset:S,palette_size:M,data_offset:T,data_length:e-T,transparent_index:h,interlaced:!!_,delay:u,disposal:d});break;case 59:s=!1;break;default:throw new Error("Unknown gif block: 0x"+x[e-1].toString(16))}this.numFrames=function(){return l.length},this.loopCount=function(){return c},this.frameInfo=function(e){if(e<0||e>=l.length)throw new Error("Frame index out of range.");return l[e]},this.decodeAndBlitFrameBGRA=function(e,t){var r=this.frameInfo(e),i=r.width*r.height,a=new Uint8Array(i);P(x,r.data_offset,a,i);var n=r.palette_offset,o=r.transparent_index;null===o&&(o=256);var s=r.width,l=w-s,u=s,h=4*(r.y*w+r.x),d=4*((r.y+r.height)*w+r.x),c=h,f=4*l;!0===r.interlaced&&(f+=4*w*7);for(var p=8,m=0,v=a.length;m>=1)),g===o)c+=4;else{var y=x[n+3*g],_=x[n+3*g+1],b=x[n+3*g+2];t[c++]=b,t[c++]=_,t[c++]=y,t[c++]=255}--u}},this.decodeAndBlitFrameRGBA=function(e,t){var r=this.frameInfo(e),i=r.width*r.height,a=new Uint8Array(i);P(x,r.data_offset,a,i);var n=r.palette_offset,o=r.transparent_index;null===o&&(o=256);var s=r.width,l=w-s,u=s,h=4*(r.y*w+r.x),d=4*((r.y+r.height)*w+r.x),c=h,f=4*l;!0===r.interlaced&&(f+=4*w*7);for(var p=8,m=0,v=a.length;m>=1)),g===o)c+=4;else{var y=x[n+3*g],_=x[n+3*g+1],b=x[n+3*g+2];t[c++]=y,t[c++]=_,t[c++]=b,t[c++]=255}--u}}}}catch(e){}},{}],11:[function(jr,t,r){(function(Gr){var e;e=this,function(E){"use strict";var e,t;String.prototype.codePointAt||(e=function(){try{var e={},t=Object.defineProperty,r=t(e,e,e)&&t}catch(e){}return r}(),t=function(e){if(null==this)throw TypeError();var t=String(this),r=t.length,i=e?Number(e):0;if(i!=i&&(i=0),!(i<0||r<=i)){var a,n=t.charCodeAt(i);return 55296<=n&&n<=56319&&i+1>>=1,t}function b(e,t,r){if(!t)return r;for(;e.bitcount<24;)e.tag|=e.source[e.sourceIndex++]<>>16-t;return e.tag>>>=t,e.bitcount-=t,i+r}function x(e,t){for(;e.bitcount<24;)e.tag|=e.source[e.sourceIndex++]<>>=1,++a,r+=t.table[a],0<=(i-=t.table[a]););return e.tag=n,e.bitcount-=a,t.trans[r+i]}function w(e,t,r){var i,a,n,o,s,l;for(i=b(e,5,257),a=b(e,5,1),n=b(e,4,4),o=0;o<19;++o)v[o]=0;for(o=0;othis.x2&&(this.x2=e)),"number"==typeof t&&((isNaN(this.y1)||isNaN(this.y2))&&(this.y1=t,this.y2=t),tthis.y2&&(this.y2=t))},C.prototype.addX=function(e){this.addPoint(e,null)},C.prototype.addY=function(e){this.addPoint(null,e)},C.prototype.addBezier=function(e,t,r,i,a,n,o,s){var l=this,u=[e,t],h=[r,i],d=[a,n],c=[o,s];this.addPoint(e,t),this.addPoint(o,s);for(var f=0;f<=1;f++){var p=6*u[f]-12*h[f]+6*d[f],m=-3*u[f]+9*h[f]-9*d[f]+3*c[f],v=3*h[f]-3*u[f];if(0!==m){var g=Math.pow(p,2)-4*v*m;if(!(g<0)){var y=(-p+Math.sqrt(g))/(2*m);0>8&255,255&e]},I.USHORT=U(2),A.SHORT=function(e){return 32768<=e&&(e=-(65536-e)),[e>>8&255,255&e]},I.SHORT=U(2),A.UINT24=function(e){return[e>>16&255,e>>8&255,255&e]},I.UINT24=U(3),A.ULONG=function(e){return[e>>24&255,e>>16&255,e>>8&255,255&e]},I.ULONG=U(4),A.LONG=function(e){return O<=e&&(e=-(2*O-e)),[e>>24&255,e>>16&255,e>>8&255,255&e]},I.LONG=U(4),A.FIXED=A.ULONG,I.FIXED=I.ULONG,A.FWORD=A.SHORT,I.FWORD=I.SHORT,A.UFWORD=A.USHORT,I.UFWORD=I.USHORT,A.LONGDATETIME=function(e){return[0,0,0,0,e>>24&255,e>>16&255,e>>8&255,255&e]},I.LONGDATETIME=U(8),A.TAG=function(e){return R.argument(4===e.length,"Tag should be exactly 4 ASCII characters."),[e.charCodeAt(0),e.charCodeAt(1),e.charCodeAt(2),e.charCodeAt(3)]},I.TAG=U(4),A.Card8=A.BYTE,I.Card8=I.BYTE,A.Card16=A.USHORT,I.Card16=I.USHORT,A.OffSize=A.BYTE,I.OffSize=I.BYTE,A.SID=A.USHORT,I.SID=I.USHORT,A.NUMBER=function(e){return-107<=e&&e<=107?[e+139]:108<=e&&e<=1131?[247+((e-=108)>>8),255&e]:-1131<=e&&e<=-108?[251+((e=-e-108)>>8),255&e]:-32768<=e&&e<=32767?A.NUMBER16(e):A.NUMBER32(e)},I.NUMBER=function(e){return A.NUMBER(e).length},A.NUMBER16=function(e){return[28,e>>8&255,255&e]},I.NUMBER16=U(3),A.NUMBER32=function(e){return[29,e>>24&255,e>>16&255,e>>8&255,255&e]},I.NUMBER32=U(5),A.REAL=function(e){var t=e.toString(),r=/\.(\d*?)(?:9{5,20}|0{5,20})\d{0,2}(?:e(.+)|$)/.exec(t);if(r){var i=parseFloat("1e"+((r[2]?+r[2]:0)+r[1].length));t=(Math.round(e*i)/i).toString()}for(var a="",n=0,o=t.length;n>8&255,t[t.length]=255&i}return t},I.UTF16=function(e){return 2*e.length};var F={"x-mac-croatian":"ÄÅÇÉÑÖÜáàâäãåçéèêëíìîïñóòôöõúùûü†°¢£§•¶ß®Š™´¨≠ŽØ∞±≤≥∆µ∂∑∏š∫ªºΩžø¿¡¬√ƒ≈Ć«Č… ÀÃÕŒœĐ—“”‘’÷◊©⁄€‹›Æ»–·‚„‰ÂćÁčÈÍÎÏÌÓÔđÒÚÛÙıˆ˜¯πË˚¸Êæˇ","x-mac-cyrillic":"АБВГДЕЖЗИЙКЛМНОПРСТУФХЦЧШЩЪЫЬЭЮЯ†°Ґ£§•¶І®©™Ђђ≠Ѓѓ∞±≤≥іµґЈЄєЇїЉљЊњјЅ¬√ƒ≈∆«»… ЋћЌќѕ–—“”‘’÷„ЎўЏџ№Ёёяабвгдежзийклмнопрстуфхцчшщъыьэю","x-mac-gaelic":"ÄÅÇÉÑÖÜáàâäãåçéèêëíìîïñóòôöõúùûü†°¢£§•¶ß®©™´¨≠ÆØḂ±≤≥ḃĊċḊḋḞḟĠġṀæøṁṖṗɼƒſṠ«»… ÀÃÕŒœ–—“”‘’ṡẛÿŸṪ€‹›Ŷŷṫ·Ỳỳ⁊ÂÊÁËÈÍÎÏÌÓÔ♣ÒÚÛÙıÝýŴŵẄẅẀẁẂẃ","x-mac-greek":"Ĺ²É³ÖÜ΅àâä΄¨çéèê룙î‰ôö¦€ùûü†ΓΔΘΛΞΠß®©ΣΪ§≠°·Α±≤≥¥ΒΕΖΗΙΚΜΦΫΨΩάΝ¬ΟΡ≈Τ«»… ΥΧΆΈœ–―“”‘’÷ΉΊΌΎέήίόΏύαβψδεφγηιξκλμνοπώρστθωςχυζϊϋΐΰ","x-mac-icelandic":"ÄÅÇÉÑÖÜáàâäãåçéèêëíìîïñóòôöõúùûüÝ°¢£§•¶ß®©™´¨≠ÆØ∞±≤≥¥µ∂∑∏π∫ªºΩæø¿¡¬√ƒ≈∆«»… ÀÃÕŒœ–—“”‘’÷◊ÿŸ⁄€ÐðÞþý·‚„‰ÂÊÁËÈÍÎÏÌÓÔÒÚÛÙıˆ˜¯˘˙˚¸˝˛ˇ","x-mac-inuit":"ᐃᐄᐅᐆᐊᐋᐱᐲᐳᐴᐸᐹᑉᑎᑏᑐᑑᑕᑖᑦᑭᑮᑯᑰᑲᑳᒃᒋᒌᒍᒎᒐᒑ°ᒡᒥᒦ•¶ᒧ®©™ᒨᒪᒫᒻᓂᓃᓄᓅᓇᓈᓐᓯᓰᓱᓲᓴᓵᔅᓕᓖᓗᓘᓚᓛᓪᔨᔩᔪᔫᔭ… ᔮᔾᕕᕖᕗ–—“”‘’ᕘᕙᕚᕝᕆᕇᕈᕉᕋᕌᕐᕿᖀᖁᖂᖃᖄᖅᖏᖐᖑᖒᖓᖔᖕᙱᙲᙳᙴᙵᙶᖖᖠᖡᖢᖣᖤᖥᖦᕼŁł","x-mac-ce":"ÄĀāÉĄÖÜáąČäčĆć鏟ĎíďĒēĖóėôöõúĚěü†°Ę£§•¶ß®©™ę¨≠ģĮįĪ≤≥īĶ∂∑łĻļĽľĹĺŅņѬ√ńŇ∆«»… ňŐÕőŌ–—“”‘’÷◊ōŔŕŘ‹›řŖŗŠ‚„šŚśÁŤťÍŽžŪÓÔūŮÚůŰűŲųÝýķŻŁżĢˇ",macintosh:"ÄÅÇÉÑÖÜáàâäãåçéèêëíìîïñóòôöõúùûü†°¢£§•¶ß®©™´¨≠ÆØ∞±≤≥¥µ∂∑∏π∫ªºΩæø¿¡¬√ƒ≈∆«»… ÀÃÕŒœ–—“”‘’÷◊ÿŸ⁄€‹›fifl‡·‚„‰ÂÊÁËÈÍÎÏÌÓÔÒÚÛÙıˆ˜¯˘˙˚¸˝˛ˇ","x-mac-romanian":"ÄÅÇÉÑÖÜáàâäãåçéèêëíìîïñóòôöõúùûü†°¢£§•¶ß®©™´¨≠ĂȘ∞±≤≥¥µ∂∑∏π∫ªºΩăș¿¡¬√ƒ≈∆«»… ÀÃÕŒœ–—“”‘’÷◊ÿŸ⁄€‹›Țț‡·‚„‰ÂÊÁËÈÍÎÏÌÓÔÒÚÛÙıˆ˜¯˘˙˚¸˝˛ˇ","x-mac-turkish":"ÄÅÇÉÑÖÜáàâäãåçéèêëíìîïñóòôöõúùûü†°¢£§•¶ß®©™´¨≠ÆØ∞±≤≥¥µ∂∑∏π∫ªºΩæø¿¡¬√ƒ≈∆«»… ÀÃÕŒœ–—“”‘’÷◊ÿŸĞğİıŞş‡·‚„‰ÂÊÁËÈÍÎÏÌÓÔÒÚÛÙˆ˜¯˘˙˚¸˝˛ˇ"};D.MACSTRING=function(e,t,r,i){var a=F[i];if(void 0!==a){for(var n="",o=0;o>8&255,l+256&255)}return n}A.MACSTRING=function(e,t){var r=function(e){if(!N)for(var t in N={},F)N[t]=new String(t);var r=N[e];if(void 0!==r){if(B){var i=B.get(r);if(void 0!==i)return i}var a=F[e];if(void 0!==a){for(var n={},o=0;o>8,t[d+1]=255&c,t=t.concat(i[h])}return t},I.TABLE=function(e){for(var t=0,r=e.fields.length,i=0;i>1,t.skip("uShort",3),e.glyphIndexMap={};for(var o=new se.Parser(r,i+a+14),s=new se.Parser(r,i+a+16+2*n),l=new se.Parser(r,i+a+16+4*n),u=new se.Parser(r,i+a+16+6*n),h=i+a+16+8*n,d=0;d>4,n=15&i;if(15===a)break;if(t+=r[a],15===n)break;t+=r[n]}return parseFloat(t)}(e);if(32<=t&&t<=246)return t-139;if(247<=t&&t<=250)return 256*(t-247)+e.parseByte()+108;if(251<=t&&t<=254)return 256*-(t-251)-e.parseByte()-108;throw new Error("Invalid b0 "+t)}function Te(e,t,r){t=void 0!==t?t:0;var i=new se.Parser(e,t),a=[],n=[];for(r=void 0!==r?r:e.length;i.relativeOffset>1,T.length=0,P=!0}return function e(t){for(var r,i,a,n,o,s,l,u,h,d,c,f,p=0;pMath.abs(f-O)?R=c+T.shift():O=f+T.shift(),E.curveTo(y,_,b,x,l,u),E.curveTo(h,d,c,f,R,O);break;default:console.log("Glyph "+g.index+": unknown operator 1200"+m),T.length=0}break;case 14:0>3;break;case 21:2>16),p+=2;break;case 29:o=T.pop()+v.gsubrsBias,(s=v.gsubrs[o])&&e(s);break;case 30:for(;0=r.begin&&e=ce.length){var o=i.parseChar();r.names.push(i.parseString(o))}break;case 2.5:r.numberOfGlyphs=i.parseUShort(),r.offset=new Array(r.numberOfGlyphs);for(var s=0;st.value.tag?1:-1}),t.fields=t.fields.concat(i),t.fields=t.fields.concat(a),t}function vt(e,t,r){for(var i=0;i 123 are reserved for internal usage");f|=1<>>1,n=e[a].tag;if(n===t)return a;n>>1,n=e[a];if(n===t)return a;n>>1,o=(r=e[n]).start;if(o===t)return r;o(r=e[i-1]).end?0:r}function xt(e,t){this.font=e,this.tableName=t}function wt(e){xt.call(this,e,"gpos")}function St(e){xt.call(this,e,"gsub")}function Mt(e,t){var r=e.length;if(r!==t.length)return!1;for(var i=0;it.points.length-1||i.matchedPoints[1]>a.points.length-1)throw Error("Matched points out of range in "+t.name);var o=t.points[i.matchedPoints[0]],s=a.points[i.matchedPoints[1]],l={xScale:i.xScale,scale01:i.scale01,scale10:i.scale10,yScale:i.yScale,dx:0,dy:0};s=Rt([s],l)[0],l.dx=o.x-s.x,l.dy=o.y-s.y,n=Rt(a.points,l)}t.points=t.points.concat(n)}}return Ot(t.points)}(wt.prototype=xt.prototype={searchTag:yt,binSearch:_t,getTable:function(e){var t=this.font.tables[this.tableName];return!t&&e&&(t=this.font.tables[this.tableName]=this.createDefaultTable()),t},getScriptNames:function(){var e=this.getTable();return e?e.scripts.map(function(e){return e.tag}):[]},getDefaultScriptName:function(){var e=this.getTable();if(e){for(var t=!1,r=0;r=s[u-1].tag,"Features must be added in alphabetical order."),n={tag:r,feature:{params:0,lookupListIndexes:[]}},s.push(n),o.push(u),n.feature}}},getLookupTables:function(e,t,r,i,a){var n=this.getFeatureTable(e,t,r,a),o=[];if(n){for(var s,l=n.lookupListIndexes,u=this.font.tables[this.tableName].lookups,h=0;h",s),t.stack.push(Math.round(64*s))}function gr(e,t){var r=t.stack,i=r.pop(),a=t.fv,n=t.pv,o=t.ppem,s=t.deltaBase+16*(e-1),l=t.deltaShift,u=t.z0;E.DEBUG&&console.log(t.step,"DELTAP["+e+"]",i,r);for(var h=0;h>4)===o){var f=(15&c)-8;0<=f&&f++,E.DEBUG&&console.log(t.step,"DELTAPFIX",d,"by",f*l);var p=u[d];a.setRelative(p,p,f*l,n)}}}function yr(e,t){var r=t.stack,i=r.pop();E.DEBUG&&console.log(t.step,"ROUND[]"),r.push(64*t.round(i/64))}function _r(e,t){var r=t.stack,i=r.pop(),a=t.ppem,n=t.deltaBase+16*(e-1),o=t.deltaShift;E.DEBUG&&console.log(t.step,"DELTAC["+e+"]",i,r);for(var s=0;s>4)===a){var h=(15&u)-8;0<=h&&h++;var d=h*o;E.DEBUG&&console.log(t.step,"DELTACFIX",l,"by",d),t.cvt[l]+=d}}}function br(e,t){var r,i,a=t.stack,n=a.pop(),o=a.pop(),s=t.z2[n],l=t.z1[o];E.DEBUG&&console.log(t.step,"SDPVTL["+e+"]",n,o),i=e?(r=s.y-l.y,l.x-s.x):(r=l.x-s.x,l.y-s.y),t.dpv=Zt(r,i)}function xr(e,t){var r=t.stack,i=t.prog,a=t.ip;E.DEBUG&&console.log(t.step,"PUSHB["+e+"]");for(var n=0;n":"_")+(i?"R":"_")+(0===a?"Gr":1===a?"Bl":2===a?"Wh":"")+"]",e?d+"("+n.cvt[d]+","+u+")":"",c,"(d =",o,"->",l*s,")"),n.rp1=n.rp0,n.rp2=c,t&&(n.rp0=c)}Nt.prototype.exec=function(e,t){if("number"!=typeof t)throw new Error("Point size is not a number!");if(!(2",i),s.interpolate(d,n,o,l),s.touch(d)}e.loop=1},fr.bind(void 0,0),fr.bind(void 0,1),function(e){for(var t=e.stack,r=e.rp0,i=e.z0[r],a=e.loop,n=e.fv,o=e.pv,s=e.z1;a--;){var l=t.pop(),u=s[l];E.DEBUG&&console.log(e.step,(1=o.width||t>=o.height?[0,0,0,0]:this._getPixel(e,t);var s=new l.default.Image(r,i);return s.canvas.getContext("2d").drawImage(o,e,t,r*n,i*n,0,0,r,i),s},l.default.Renderer.prototype.textLeading=function(e){return"number"==typeof e?(this._setProperty("_textLeading",e),this._pInst):this._textLeading},l.default.Renderer.prototype.textSize=function(e){return"number"==typeof e?(this._setProperty("_textSize",e),this._setProperty("_textLeading",e*y._DEFAULT_LEADMULT),this._applyTextProperties()):this._textSize},l.default.Renderer.prototype.textStyle=function(e){return e?(e!==y.NORMAL&&e!==y.ITALIC&&e!==y.BOLD&&e!==y.BOLDITALIC||this._setProperty("_textStyle",e),this._applyTextProperties()):this._textStyle},l.default.Renderer.prototype.textAscent=function(){return null===this._textAscent&&this._updateTextMetrics(),this._textAscent},l.default.Renderer.prototype.textDescent=function(){return null===this._textDescent&&this._updateTextMetrics(),this._textDescent},l.default.Renderer.prototype.textAlign=function(e,t){return void 0!==e?(this._setProperty("_textAlign",e),void 0!==t&&this._setProperty("_textBaseline",t),this._applyTextProperties()):{horizontal:this._textAlign,vertical:this._textBaseline}},l.default.Renderer.prototype.text=function(e,t,r,i,a){var n,o,s,l,u,h,d,c,f=this._pInst,p=Number.MAX_VALUE;if((this._doFill||this._doStroke)&&void 0!==e){if("string"!=typeof e&&(e=e.toString()),n=(e=e.replace(/(\t)/g," ")).split("\n"),void 0!==i){for(s=c=0;so.HALF_PI&&e<=3*o.HALF_PI?Math.atan(r/i*Math.tan(e))+o.PI:Math.atan(r/i*Math.tan(e))+o.TWO_PI,t=t<=o.HALF_PI?Math.atan(r/i*Math.tan(t)):t>o.HALF_PI&&t<=3*o.HALF_PI?Math.atan(r/i*Math.tan(t))+o.PI:Math.atan(r/i*Math.tan(t))+o.TWO_PI),tg||Math.abs(this.accelerationY-this.pAccelerationY)>g||Math.abs(this.accelerationZ-this.pAccelerationZ)>g)&&e();var t=this.deviceTurned||window.deviceTurned;if("function"==typeof t){var r=this.rotationX+180,i=this.pRotationX+180,a=d+180;0>>24],i+=x[(16711680&C)>>16],a+=x[(65280&C)>>8],n+=x[255&C],r+=R[b],s++}w[l=T+y]=o/r,S[l]=i/r,M[l]=a/r,E[l]=n/r}T+=f}for(h=(u=-P)*f,_=T=0;_>>16,e[r+1]=(65280&t[i])>>>8,e[r+2]=255&t[i],e[r+3]=(4278190080&t[i])>>>24},D._toImageData=function(e){return e instanceof ImageData?e:e.getContext("2d").getImageData(0,0,e.width,e.height)},D._createImageData=function(e,t){return D._tmpCanvas=document.createElement("canvas"),D._tmpCtx=D._tmpCanvas.getContext("2d"),this._tmpCtx.createImageData(e,t)},D.apply=function(e,t,r){var i=e.getContext("2d"),a=i.getImageData(0,0,e.width,e.height),n=t(a,r);n instanceof ImageData?i.putImageData(n,0,0,0,0,e.width,e.height):i.putImageData(a,0,0,0,0,e.width,e.height)},D.threshold=function(e,t){var r=D._toPixels(e);void 0===t&&(t=.5);for(var i=Math.floor(255*t),a=0;a>8)/i,r[a+1]=255*(o*t>>8)/i,r[a+2]=255*(s*t>>8)/i}},D.dilate=function(e){for(var t,r,i,a,n,o,s,l,u,h,d,c,f,p,m,v,g,y=D._toPixels(e),_=0,b=y.length?y.length/4:0,x=new Int32Array(b);_>16&255)+151*(i>>8&255)+28*(255&i))<(m=77*(d>>16&255)+151*(d>>8&255)+28*(255&d))&&(a=d,n=m),n<(p=77*((h=D._getARGB(y,o))>>16&255)+151*(h>>8&255)+28*(255&h))&&(a=h,n=p),n<(v=77*(c>>16&255)+151*(c>>8&255)+28*(255&c))&&(a=c,n=v),n<(g=77*(f>>16&255)+151*(f>>8&255)+28*(255&f))&&(a=f,n=g),x[_++]=a;D._setPixels(y,x)},D.erode=function(e){for(var t,r,i,a,n,o,s,l,u,h,d,c,f,p,m,v,g,y=D._toPixels(e),_=0,b=y.length?y.length/4:0,x=new Int32Array(b);_>16&255)+151*(d>>8&255)+28*(255&d))<(n=77*(i>>16&255)+151*(i>>8&255)+28*(255&i))&&(a=d,n=m),(p=77*((h=D._getARGB(y,o))>>16&255)+151*(h>>8&255)+28*(255&h))>16&255)+151*(c>>8&255)+28*(255&c))>16&255)+151*(f>>8&255)+28*(255&f))=t.delay){var r=Math.floor(t.timeDisplayed/t.delay);if(t.timeDisplayed=0,t.displayIndex+=r,t.loopCount=Math.floor(t.displayIndex/t.numFrames),null!==t.loopLimit&&t.loopCount>=t.loopLimit)t.playing=!1;else{var i=t.displayIndex%t.numFrames;this.drawingContext.putImageData(t.frames[i],0,0),t.displayIndex=i,this.setModified(!0)}}},a.default.Image.prototype._setProperty=function(e,t){this[e]=t,this.setModified(!0)},a.default.Image.prototype.loadPixels=function(){a.default.Renderer2D.prototype.loadPixels.call(this),this.setModified(!0)},a.default.Image.prototype.updatePixels=function(e,t,r,i){a.default.Renderer2D.prototype.updatePixels.call(this,e,t,r,i),this.setModified(!0)},a.default.Image.prototype.get=function(e,t,r,i){return a.default._validateParameters("p5.Image.get",arguments),a.default.Renderer2D.prototype.get.apply(this,arguments)},a.default.Image.prototype._getPixel=a.default.Renderer2D.prototype._getPixel,a.default.Image.prototype.set=function(e,t,r){a.default.Renderer2D.prototype.set.call(this,e,t,r),this.setModified(!0)},a.default.Image.prototype.resize=function(e,t){0===e&&0===t?(e=this.canvas.width,t=this.canvas.height):0===e?e=this.canvas.width*t/this.canvas.height:0===t&&(t=this.canvas.height*e/this.canvas.width),e=Math.floor(e),t=Math.floor(t);var r=document.createElement("canvas");if(r.width=e,r.height=t,this.gifProperties)for(var i=this.gifProperties,a=function(e,t){for(var r=0,i=0;i/g,">").replace(/"/g,""").replace(/'/g,"'")}function l(e,t){t&&!0!==t&&"true"!==t||(t=""),e||(e="untitled");var r="";return e&&e.includes(".")&&(r=e.split(".").pop()),t&&r!==t&&(r=t,e="".concat(e,".").concat(r)),[e,r]}e("../core/error_helpers"),g.default.prototype.loadJSON=function(){for(var e=arguments.length,t=new Array(e),r=0;r"),a.print("");if('="text/html;charset=utf-8" />',a.print(' '),a.print(""),a.print(""),a.print(" "),"0"!==n[0]){a.print(" ");for(var h=0;h".concat(d)),a.print(" ")}a.print("
")}for(var c=0;c");for(var f=0;f".concat(p)),a.print(" ")}a.print(" ")}a.print("
"),a.print(""),a.print("