Added the Attractors and Wrap matter plugins. Fixed the Plugin register. Added silence option to stop plugin logging to the console.

v3/src/physics/matter-js/CustomMain.js

@@ -1,4 +1,4 @@
-var Matter = module.exports = require('./lib/core/Matter');
+var Matter = require('./lib/core/Matter');
 
 Matter.Body = require('./lib/body/Body');
 Matter.Composite = require('./lib/body/Composite');
@@ -38,3 +38,5 @@ Matter.World.addComposite = Matter.Composite.addComposite;
 Matter.World.addBody = Matter.Composite.addBody;
 Matter.World.addConstraint = Matter.Composite.addConstraint;
 Matter.World.clear = Matter.Composite.clear;
+
+module.exports = Matter;

v3/src/physics/matter-js/Matter.js

@@ -1,5 +1,10 @@
 var Class = require('../../utils/Class');
 var Factory = require('./Factory');
+var GetValue = require('../../utils/object/GetValue');
+var MatterAttractors = require('./lib/plugins/MatterAttractors');
+var MatterLib = require('./lib/core/Matter');
+var MatterWrap = require('./lib/plugins/MatterWrap');
+var Plugin = require('./lib/core/Plugin');
 var World = require('./World');
 
 var Matter = new Class({
@@ -15,6 +20,36 @@ var Matter = new Class({
         physicsManager.world = new World(physicsManager.scene, config);
 
         physicsManager.add = new Factory(physicsManager.world);
+
+        //  Matter plugins
+
+        if (GetValue(config, 'plugins.attractors', false))
+        {
+            Plugin.register(MatterAttractors);
+            Plugin.use(MatterLib, MatterAttractors);
+        }
+
+        if (GetValue(config, 'plugins.wrap', false))
+        {
+            Plugin.register(MatterWrap);
+            Plugin.use(MatterLib, MatterWrap);
+        }
+    },
+
+    enableAttractorPlugin: function ()
+    {
+        Plugin.register(MatterAttractors);
+        Plugin.use(MatterLib, MatterAttractors);
+
+        return this;
+    },
+
+    enableWrapPlugin: function ()
+    {
+        Plugin.register(MatterWrap);
+        Plugin.use(MatterLib, MatterWrap);
+
+        return this;
     }
 
 });

v3/src/physics/matter-js/lib/core/Matter.js

@@ -27,7 +27,7 @@ var Common = require('./Common');
      * @readOnly
      * @type {String}
      */
-    Matter.version = '@@VERSION@@';
+    Matter.version = '0.13.1';
 
     /**
      * A list of plugin dependencies to be installed. These are normally set and installed through `Matter.use`.

v3/src/physics/matter-js/lib/core/Plugin.js

@@ -171,7 +171,7 @@ var Common = require('./Common');
             module.used.push(plugin.name);
         }
 
-        if (status.length > 0) {
+        if (status.length > 0 && !plugin.silent) {
             Common.info(status.join('  '));
         }
     };

v3/src/physics/matter-js/lib/plugins/MatterAttractors.js

@@ -0,0 +1,136 @@
+var Matter = require('../../CustomMain');
+
+/**
+ * An attractors plugin for matter.js.
+ * See the readme for usage and examples.
+ * @module MatterAttractors
+ */
+var MatterAttractors = {
+  // plugin meta
+  name: 'matter-attractors', // PLUGIN_NAME
+  version: '0.1.7', // PLUGIN_VERSION
+  for: 'matter-js@^0.13.1',
+  silent: true, // no console log please
+
+  // installs the plugin where `base` is `Matter`
+  // you should not need to call this directly.
+  install: function(base) {
+    base.after('Body.create', function() {
+      MatterAttractors.Body.init(this);
+    });
+
+    base.before('Engine.update', function(engine) {
+      MatterAttractors.Engine.update(engine);
+    });
+  },
+
+  Body: {
+    /**
+     * Initialises the `body` to support attractors.
+     * This is called automatically by the plugin.
+     * @function MatterAttractors.Body.init
+     * @param {Matter.Body} body The body to init.
+     * @returns {void} No return value.
+     */
+    init: function(body) {
+      body.plugin.attractors = body.plugin.attractors || [];
+    }
+  },
+
+  Engine: {
+    /**
+     * Applies all attractors for all bodies in the `engine`.
+     * This is called automatically by the plugin.
+     * @function MatterAttractors.Engine.update
+     * @param {Matter.Engine} engine The engine to update.
+     * @returns {void} No return value.
+     */
+    update: function(engine) {
+      var world = engine.world,
+        bodies = Matter.Composite.allBodies(world);
+
+      for (var i = 0; i < bodies.length; i += 1) {
+        var bodyA = bodies[i],
+          attractors = bodyA.plugin.attractors;
+
+        if (attractors && attractors.length > 0) {
+          for (var j = i + 1; j < bodies.length; j += 1) {
+            var bodyB = bodies[j];
+
+            for (var k = 0; k < attractors.length; k += 1) {
+              var attractor = attractors[k],
+                forceVector = attractor;
+
+              if (Matter.Common.isFunction(attractor)) {
+                forceVector = attractor(bodyA, bodyB);
+              }
+              
+              if (forceVector) {
+                Matter.Body.applyForce(bodyB, bodyB.position, forceVector);
+              }
+            }
+          }
+        }
+      }
+    }
+  },
+  
+  /**
+   * Defines some useful common attractor functions that can be used 
+   * by pushing them to your body's `body.plugin.attractors` array.
+   * @namespace MatterAttractors.Attractors
+   * @property {number} gravityConstant The gravitational constant used by the gravity attractor.
+   */
+  Attractors: {
+    gravityConstant: 0.001,
+
+    /**
+     * An attractor function that applies Newton's law of gravitation.
+     * Use this by pushing `MatterAttractors.Attractors.gravity` to your body's `body.plugin.attractors` array.
+     * The gravitational constant defaults to `0.001` which you can change 
+     * at `MatterAttractors.Attractors.gravityConstant`.
+     * @function MatterAttractors.Attractors.gravity
+     * @param {Matter.Body} bodyA The first body.
+     * @param {Matter.Body} bodyB The second body.
+     * @returns {void} No return value.
+     */
+    gravity: function(bodyA, bodyB) {
+      // use Newton's law of gravitation
+      var bToA = Matter.Vector.sub(bodyB.position, bodyA.position),
+        distanceSq = Matter.Vector.magnitudeSquared(bToA) || 0.0001,
+        normal = Matter.Vector.normalise(bToA),
+        magnitude = -MatterAttractors.Attractors.gravityConstant * (bodyA.mass * bodyB.mass / distanceSq),
+        force = Matter.Vector.mult(normal, magnitude);
+
+      // to apply forces to both bodies
+      Matter.Body.applyForce(bodyA, bodyA.position, Matter.Vector.neg(force));
+      Matter.Body.applyForce(bodyB, bodyB.position, force);
+    }
+  }
+};
+
+module.exports = MatterAttractors;
+
+/**
+ * @namespace Matter.Body
+ * @see http://brm.io/matter-js/docs/classes/Body.html
+ */
+
+/**
+ * This plugin adds a new property `body.plugin.attractors` to instances of `Matter.Body`.  
+ * This is an array of callback functions that will be called automatically
+ * for every pair of bodies, on every engine update.
+ * @property {Function[]} body.plugin.attractors
+ * @memberof Matter.Body
+ */
+
+/**
+ * An attractor function calculates the force to be applied
+ * to `bodyB`, it should either:
+ * - return the force vector to be applied to `bodyB`
+ * - or apply the force to the body(s) itself
+ * @callback AttractorFunction
+ * @param {Matter.Body} bodyA
+ * @param {Matter.Body} bodyB
+ * @returns {Vector|undefined} a force vector (optional)
+ */

v3/src/physics/matter-js/lib/plugins/MatterWrap.js

@@ -0,0 +1,177 @@
+var Matter = require('../../CustomMain');
+
+/**
+ * A coordinate wrapping plugin for matter.js.
+ * See the readme for usage and examples.
+ * @module MatterWrap
+ */
+var MatterWrap = {
+  // plugin meta
+  name: 'matter-wrap', // PLUGIN_NAME
+  version: '0.1.4', // PLUGIN_VERSION
+  for: 'matter-js@^0.13.1',
+  silent: true, // no console log please
+
+  // installs the plugin where `base` is `Matter`
+  // you should not need to call this directly.
+  install: function(base) {
+    base.after('Engine.update', function() {
+      MatterWrap.Engine.update(this);
+    });
+  },
+
+  Engine: {
+    /**
+     * Updates the engine by wrapping bodies and composites inside `engine.world`.
+     * This is called automatically by the plugin.
+     * @function MatterWrap.Engine.update
+     * @param {Matter.Engine} engine The engine to update.
+     * @returns {void} No return value.
+     */
+    update: function(engine) {
+      var world = engine.world,
+        bodies = Matter.Composite.allBodies(world),
+        composites = Matter.Composite.allComposites(world);
+
+      for (var i = 0; i < bodies.length; i += 1) {
+        var body = bodies[i];
+
+        if (body.plugin.wrap) {
+          MatterWrap.Body.wrap(body, body.plugin.wrap);
+        }
+      }
+
+      for (i = 0; i < composites.length; i += 1) {
+        var composite = composites[i];
+
+        if (composite.plugin.wrap) {
+          MatterWrap.Composite.wrap(composite, composite.plugin.wrap);
+        }
+      }
+    }
+  },
+
+  Bounds: {
+    /**
+     * Returns a translation vector that wraps the `objectBounds` inside the `bounds`.
+     * @function MatterWrap.Bounds.wrap
+     * @param {Matter.Bounds} objectBounds The bounds of the object to wrap inside the bounds.
+     * @param {Matter.Bounds} bounds The bounds to wrap the body inside.
+     * @returns {?Matter.Vector} A translation vector (only if wrapping is required).
+     */
+    wrap: function(objectBounds, bounds) {
+      var x = null,
+        y = null;
+
+      if (typeof bounds.min.x !== 'undefined' && typeof bounds.max.x !== 'undefined') {
+        if (objectBounds.min.x > bounds.max.x) {
+          x = bounds.min.x - objectBounds.max.x;
+        } else if (objectBounds.max.x < bounds.min.x) {
+          x = bounds.max.x - objectBounds.min.x;
+        }
+      }
+
+      if (typeof bounds.min.y !== 'undefined' && typeof bounds.max.y !== 'undefined') {
+        if (objectBounds.min.y > bounds.max.y) {
+          y = bounds.min.y - objectBounds.max.y;
+        } else if (objectBounds.max.y < bounds.min.y) {
+          y = bounds.max.y - objectBounds.min.y;
+        }
+      }
+
+      if (x !== null || y !== null) {
+        return {
+          x: x || 0,
+          y: y || 0
+        };
+      }
+    }
+  },
+
+  Body: {
+    /**
+     * Wraps the `body` position such that it always stays within the given bounds. 
+     * Upon crossing a boundary the body will appear on the opposite side of the bounds, 
+     * while maintaining its velocity.
+     * This is called automatically by the plugin.
+     * @function MatterWrap.Body.wrap
+     * @param {Matter.Body} body The body to wrap.
+     * @param {Matter.Bounds} bounds The bounds to wrap the body inside.
+     * @returns {?Matter.Vector} The translation vector that was applied (only if wrapping was required).
+     */
+    wrap: function(body, bounds) {
+      var translation = MatterWrap.Bounds.wrap(body.bounds, bounds);
+
+      if (translation) {
+        Matter.Body.translate(body, translation);
+      }
+
+      return translation;
+    }
+  },
+
+  Composite: {
+    /**
+     * Returns the union of the bounds of all of the composite's bodies
+     * (not accounting for constraints).
+     * @function MatterWrap.Composite.bounds
+     * @param {Matter.Composite} composite The composite.
+     * @returns {Matter.Bounds} The composite bounds.
+     */
+    bounds: function(composite) {
+      var bodies = Matter.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 Matter.Bounds.create(vertices);
+    },
+
+    /**
+     * Wraps the `composite` position such that it always stays within the given bounds. 
+     * Upon crossing a boundary the composite will appear on the opposite side of the bounds, 
+     * while maintaining its velocity.
+     * This is called automatically by the plugin.
+     * @function MatterWrap.Composite.wrap
+     * @param {Matter.Composite} composite The composite to wrap.
+     * @param {Matter.Bounds} bounds The bounds to wrap the composite inside.
+     * @returns {?Matter.Vector} The translation vector that was applied (only if wrapping was required).
+     */
+    wrap: function(composite, bounds) {
+      var translation = MatterWrap.Bounds.wrap(
+        MatterWrap.Composite.bounds(composite), 
+        bounds
+      );
+
+      if (translation) {
+        Matter.Composite.translate(composite, translation);
+      }
+
+      return translation;
+    }
+  }
+};
+
+module.exports = MatterWrap;
+
+/**
+ * @namespace Matter.Body
+ * @see http://brm.io/matter-js/docs/classes/Body.html
+ */
+
+/**
+ * This plugin adds a new property `body.plugin.wrap` to instances of `Matter.Body`.  
+ * This is a `Matter.Bounds` instance that specifies the wrapping region.
+ * @property {Matter.Bounds} body.plugin.wrap
+ * @memberof Matter.Body
+ */
+
+/**
+ * This plugin adds a new property `composite.plugin.wrap` to instances of `Matter.Composite`.  
+ * This is a `Matter.Bounds` instance that specifies the wrapping region.
+ * @property {Matter.Bounds} composite.plugin.wrap
+ * @memberof Matter.Composite
+ */