melonjs 10.7.1 → 10.8.0

package/dist/melonjs.js

@@ -1,5 +1,5 @@
 /*!
- * melonJS Game Engine - v10.7.1
+ * melonJS Game Engine - v10.8.0
  * http://www.melonjs.org
  * melonjs is licensed under the MIT License.
  * http://www.opensource.org/licenses/mit-license
@@ -323,10 +323,10 @@
 	(shared$3.exports = function (key, value) {
 	  return store$2[key] || (store$2[key] = value !== undefined ? value : {});
 	})('versions', []).push({
-	  version: '3.22.4',
+	  version: '3.22.5',
 	  mode: 'global',
 	  copyright: '© 2014-2022 Denis Pushkarev (zloirock.ru)',
-	  license: 'https://github.com/zloirock/core-js/blob/v3.22.4/LICENSE',
+	  license: 'https://github.com/zloirock/core-js/blob/v3.22.5/LICENSE',
 	  source: 'https://github.com/zloirock/core-js'
 	});
 
@@ -436,19 +436,19 @@
 	  return EXISTS$1 ? document$1.createElement(it) : {};
 	};
 
-	var DESCRIPTORS$5 = descriptors;
+	var DESCRIPTORS$6 = descriptors;
 	var fails$3 = fails$8;
 	var createElement = documentCreateElement;
 
 	// Thanks to IE8 for its funny defineProperty
-	var ie8DomDefine = !DESCRIPTORS$5 && !fails$3(function () {
+	var ie8DomDefine = !DESCRIPTORS$6 && !fails$3(function () {
 	  // eslint-disable-next-line es-x/no-object-defineproperty -- required for testing
 	  return Object.defineProperty(createElement('div'), 'a', {
 	    get: function () { return 7; }
 	  }).a != 7;
 	});
 
-	var DESCRIPTORS$4 = descriptors;
+	var DESCRIPTORS$5 = descriptors;
 	var call = functionCall;
 	var propertyIsEnumerableModule = objectPropertyIsEnumerable;
 	var createPropertyDescriptor$1 = createPropertyDescriptor$2;
@@ -462,7 +462,7 @@
 
 	// `Object.getOwnPropertyDescriptor` method
 	// https://tc39.es/ecma262/#sec-object.getownpropertydescriptor
-	objectGetOwnPropertyDescriptor.f = DESCRIPTORS$4 ? $getOwnPropertyDescriptor$1 : function getOwnPropertyDescriptor(O, P) {
+	objectGetOwnPropertyDescriptor.f = DESCRIPTORS$5 ? $getOwnPropertyDescriptor$1 : function getOwnPropertyDescriptor(O, P) {
 	  O = toIndexedObject$2(O);
 	  P = toPropertyKey$1(P);
 	  if (IE8_DOM_DEFINE$1) { try {
@@ -473,12 +473,12 @@
 
 	var objectDefineProperty = {};
 
-	var DESCRIPTORS$3 = descriptors;
+	var DESCRIPTORS$4 = descriptors;
 	var fails$2 = fails$8;
 
 	// V8 ~ Chrome 36-
 	// https://bugs.chromium.org/p/v8/issues/detail?id=3334
-	var v8PrototypeDefineBug = DESCRIPTORS$3 && fails$2(function () {
+	var v8PrototypeDefineBug = DESCRIPTORS$4 && fails$2(function () {
 	  // eslint-disable-next-line es-x/no-object-defineproperty -- required for testing
 	  return Object.defineProperty(function () { /* empty */ }, 'prototype', {
 	    value: 42,
@@ -499,7 +499,7 @@
 	};
 
 	var global$6 = global$m;
-	var DESCRIPTORS$2 = descriptors;
+	var DESCRIPTORS$3 = descriptors;
 	var IE8_DOM_DEFINE = ie8DomDefine;
 	var V8_PROTOTYPE_DEFINE_BUG = v8PrototypeDefineBug;
 	var anObject$1 = anObject$2;
@@ -516,7 +516,7 @@
 
 	// `Object.defineProperty` method
 	// https://tc39.es/ecma262/#sec-object.defineproperty
-	objectDefineProperty.f = DESCRIPTORS$2 ? V8_PROTOTYPE_DEFINE_BUG ? function defineProperty(O, P, Attributes) {
+	objectDefineProperty.f = DESCRIPTORS$3 ? V8_PROTOTYPE_DEFINE_BUG ? function defineProperty(O, P, Attributes) {
 	  anObject$1(O);
 	  P = toPropertyKey(P);
 	  anObject$1(Attributes);
@@ -543,11 +543,11 @@
 	  return O;
 	};
 
-	var DESCRIPTORS$1 = descriptors;
+	var DESCRIPTORS$2 = descriptors;
 	var definePropertyModule$1 = objectDefineProperty;
 	var createPropertyDescriptor = createPropertyDescriptor$2;
 
-	var createNonEnumerableProperty$3 = DESCRIPTORS$1 ? function (object, key, value) {
+	var createNonEnumerableProperty$3 = DESCRIPTORS$2 ? function (object, key, value) {
 	  return definePropertyModule$1.f(object, key, createPropertyDescriptor(1, value));
 	} : function (object, key, value) {
 	  object[key] = value;
@@ -556,17 +556,17 @@
 
 	var makeBuiltIn$2 = {exports: {}};
 
-	var DESCRIPTORS = descriptors;
+	var DESCRIPTORS$1 = descriptors;
 	var hasOwn$4 = hasOwnProperty_1;
 
 	var FunctionPrototype = Function.prototype;
 	// eslint-disable-next-line es-x/no-object-getownpropertydescriptor -- safe
-	var getDescriptor = DESCRIPTORS && Object.getOwnPropertyDescriptor;
+	var getDescriptor = DESCRIPTORS$1 && Object.getOwnPropertyDescriptor;
 
 	var EXISTS = hasOwn$4(FunctionPrototype, 'name');
 	// additional protection from minified / mangled / dropped function names
 	var PROPER = EXISTS && (function something() { /* empty */ }).name === 'something';
-	var CONFIGURABLE = EXISTS && (!DESCRIPTORS || (DESCRIPTORS && getDescriptor(FunctionPrototype, 'name').configurable));
+	var CONFIGURABLE = EXISTS && (!DESCRIPTORS$1 || (DESCRIPTORS$1 && getDescriptor(FunctionPrototype, 'name').configurable));
 
 	var functionName = {
 	  EXISTS: EXISTS,
@@ -681,15 +681,17 @@
 	var fails$1 = fails$8;
 	var isCallable$2 = isCallable$a;
 	var hasOwn$2 = hasOwnProperty_1;
-	var defineProperty = objectDefineProperty.f;
+	var DESCRIPTORS = descriptors;
 	var CONFIGURABLE_FUNCTION_NAME = functionName.CONFIGURABLE;
 	var inspectSource = inspectSource$2;
 	var InternalStateModule = internalState;
 
 	var enforceInternalState = InternalStateModule.enforce;
 	var getInternalState = InternalStateModule.get;
+	// eslint-disable-next-line es-x/no-object-defineproperty -- safe
+	var defineProperty = Object.defineProperty;
 
-	var CONFIGURABLE_LENGTH = !fails$1(function () {
+	var CONFIGURABLE_LENGTH = DESCRIPTORS && !fails$1(function () {
 	  return defineProperty(function () { /* empty */ }, 'length', { value: 8 }).length !== 8;
 	});
 
@@ -707,6 +709,11 @@
 	  if (CONFIGURABLE_LENGTH && options && hasOwn$2(options, 'arity') && value.length !== options.arity) {
 	    defineProperty(value, 'length', { value: options.arity });
 	  }
+	  if (options && hasOwn$2(options, 'constructor') && options.constructor) {
+	    if (DESCRIPTORS) { try {
+	      defineProperty(value, 'prototype', { writable: false });
+	    } catch (error) { /* empty */ } }
+	  } else { value.prototype = undefined; }
 	  var state = enforceInternalState(value);
 	  if (!hasOwn$2(state, 'source')) {
 	    state.source = TEMPLATE.join(typeof name == 'string' ? name : '');
@@ -828,17 +835,17 @@
 	var indexOf = arrayIncludes.indexOf;
 	var hiddenKeys$1 = hiddenKeys$3;
 
-	var push$1 = uncurryThis$1([].push);
+	var push = uncurryThis$1([].push);
 
 	var objectKeysInternal = function (object, names) {
 	  var O = toIndexedObject(object);
 	  var i = 0;
 	  var result = [];
 	  var key;
-	  for (key in O) { !hasOwn$1(hiddenKeys$1, key) && hasOwn$1(O, key) && push$1(result, key); }
+	  for (key in O) { !hasOwn$1(hiddenKeys$1, key) && hasOwn$1(O, key) && push(result, key); }
 	  // Don't enum bug & hidden keys
 	  while (names.length > i) { if (hasOwn$1(O, key = names[i++])) {
-	    ~indexOf(result, key) || push$1(result, key);
+	    ~indexOf(result, key) || push(result, key);
 	  } }
 	  return result;
 	};
@@ -1600,10 +1607,8 @@
 		throttle: throttle
 	});
 
-	var objectClass = {};
-	var instance_counter = 0;
-
 	/**
+	 * @classdesc
 	 * This object is used for object pooling - a technique that might speed up your game if used properly.<br>
 	 * If some of your classes will be instantiated and removed a lot at a time, it is a
 	 * good idea to add the class to this object pool. A separate pool for that class
@@ -1614,43 +1619,46 @@
 	 * which means, that on level loading the engine will try to instantiate every object
 	 * found in the map, based on the user defined name in each Object Properties<br>
 	 * <img src="images/object_properties.png"/><br>
-	 * @namespace pool
+	 * @see {@link pool} a default global instance of ObjectPool
 	 */
+	var ObjectPool = function ObjectPool() {
+	    this.objectClass = {};
+	    this.instance_counter = 0;
+	};
 
 	/**
 	 * register an object to the pool. <br>
 	 * Pooling must be set to true if more than one such objects will be created. <br>
 	 * (Note: for an object to be poolable, it must implements a `onResetEvent` method)
-	 * @function pool.register
 	 * @param {string} className as defined in the Name field of the Object Properties (in Tiled)
 	 * @param {object} classObj corresponding Class to be instantiated
 	 * @param {boolean} [recycling=false] enables object recycling for the specified class
 	 * @example
 	 * // implement CherryEntity
 	 * class CherryEntity extends Spritesheet {
-	 *    onResetEvent() {
-	 *        // reset object mutable properties
-	 *        this.lifeBar = 100;
-	 *    }
+	 *onResetEvent() {
+	 *    // reset object mutable properties
+	 *    this.lifeBar = 100;
+	 *}
 	 * };
 	 * // add our users defined entities in the object pool and enable object recycling
 	 * me.pool.register("cherryentity", CherryEntity, true);
 	 */
-	function register(className, classObj, recycling) {
-	     if ( recycling === void 0 ) recycling = false;
+	ObjectPool.prototype.register = function register (className, classObj, recycling) {
+	         if ( recycling === void 0 ) recycling = false;
 
 	     if (typeof (classObj) !== "undefined") {
-	         objectClass[className] = {
+	         this.objectClass[className] = {
 	             "class" : classObj,
 	             "pool" : (recycling ? [] : undefined)
 	         };
 	     } else {
 	         throw new Error("Cannot register object '" + className + "', invalid class");
 	     }
-	 }
+	 };
+
 	/**
 	 * Pull a new instance of the requested object (if added into the object pool)
-	 * @function pool.pull
 	 * @param {string} name as used in {@link pool.register}
 	 * @param {object} [...arguments] arguments to be passed when instantiating/reinitializing the object
 	 * @returns {object} the instance of the requested object
@@ -1670,14 +1678,14 @@
 	 * me.game.world.removeChild(enemy);
 	 * me.game.world.removeChild(bullet);
 	 */
-	function pull(name) {
-	    var arguments$1 = arguments;
+	ObjectPool.prototype.pull = function pull (name) {
+	        var arguments$1 = arguments;
 
 	    var args = new Array(arguments.length);
 	    for (var i = 0; i < arguments.length; i++) {
 	        args[i] = arguments$1[i];
 	    }
-	    var className = objectClass[name];
+	    var className = this.objectClass[name];
 	    if (className) {
 	        var proto = className["class"],
 	            poolArray = className.pool,
@@ -1690,7 +1698,7 @@
 	            if (typeof(obj.onResetEvent) === "function") {
 	                obj.onResetEvent.apply(obj, args);
 	            }
-	            instance_counter--;
+	            this.instance_counter--;
 	        }
 	        else {
 	            // create a new instance
@@ -1703,36 +1711,36 @@
 	        return obj;
 	    }
 	    throw new Error("Cannot instantiate object of type '" + name + "'");
-	}
+	};
+
 	/**
 	 * purge the object pool from any inactive object <br>
 	 * Object pooling must be enabled for this function to work<br>
 	 * note: this will trigger the garbage collector
-	 * @function pool.purge
 	 */
-	function purge() {
-	    for (var className in objectClass) {
-	        if (objectClass[className]) {
-	            objectClass[className].pool = [];
+	ObjectPool.prototype.purge = function purge () {
+	    for (var className in this.objectClass) {
+	        if (this.objectClass[className]) {
+	            this.objectClass[className].pool = [];
 	        }
 	    }
-	    instance_counter = 0;
-	}
+	    this.instance_counter = 0;
+	};
+
 	/**
 	 * Push back an object instance into the object pool <br>
 	 * Object pooling for the object class must be enabled,
 	 * and object must have been instantiated using {@link pool#pull},
 	 * otherwise this function won't work
-	 * @function pool.push
 	 * @throws will throw an error if the object cannot be recycled
 	 * @param {object} obj instance to be recycled
 	 * @param {boolean} [throwOnError=true] throw an exception if the object cannot be recycled
 	 * @returns {boolean} true if the object was successfully recycled in the object pool
 	 */
-	function push(obj, throwOnError) {
-	    if ( throwOnError === void 0 ) throwOnError = true;
+	ObjectPool.prototype.push = function push (obj, throwOnError) {
+	        if ( throwOnError === void 0 ) throwOnError = true;
 
-	    if (!poolable(obj)) {
+	    if (!this.poolable(obj)) {
 	        if (throwOnError === true ) {
 	            throw new Error("me.pool: object " + obj + " cannot be recycled");
 	        } else {
@@ -1741,59 +1749,53 @@
 	    }
 
 	    // store back the object instance for later recycling
-	    objectClass[obj.className].pool.push(obj);
-	    instance_counter++;
+	    this.objectClass[obj.className].pool.push(obj);
+	    this.instance_counter++;
 
 	    return true;
-	}
+	};
+
 	/**
 	 * Check if an object with the provided name is registered
-	 * @function pool.exists
 	 * @param {string} name of the registered object class
 	 * @returns {boolean} true if the classname is registered
 	 */
-	function exists(name) {
-	    return name in objectClass;
-	}
+	ObjectPool.prototype.exists = function exists (name) {
+	    return name in this.objectClass;
+	};
 	/**
 	 * Check if an object is poolable
 	 * (was properly registered with the recycling feature enable)
-	 * @function pool.poolable
-	 * @see pool.register
+	 * @see register
 	 * @param {object} obj object to be checked
 	 * @returns {boolean} true if the object is poolable
 	 * @example
 	 * if (!me.pool.poolable(myCherryEntity)) {
-	 *     // object was not properly registered
+	 * // object was not properly registered
 	 * }
 	 */
-	function poolable(obj) {
+	ObjectPool.prototype.poolable = function poolable (obj) {
 	    var className = obj.className;
 	    return (typeof className !== "undefined") &&
 	            (typeof obj.onResetEvent === "function") &&
-	            (className in objectClass) &&
-	            (objectClass[className].pool !== "undefined");
+	            (className in this.objectClass) &&
+	            (this.objectClass[className].pool !== "undefined");
+
+	};
 
-	}
 	/**
 	 * returns the amount of object instance currently in the pool
-	 * @function pool.getInstanceCount
 	 * @returns {number} amount of object instance
 	 */
-	function getInstanceCount() {
-	    return instance_counter;
-	}
-
-	var pooling = /*#__PURE__*/Object.freeze({
-		__proto__: null,
-		register: register,
-		pull: pull,
-		purge: purge,
-		push: push,
-		exists: exists,
-		poolable: poolable,
-		getInstanceCount: getInstanceCount
-	});
+	ObjectPool.prototype.getInstanceCount = function getInstanceCount () {
+	    return this.instance_counter;
+	};
+	/**
+	 * a default global object pool instance
+	 * @public
+	 * @type {ObjectPool}
+	 */
+	var pool$1 = new ObjectPool();
 
 	/**
 	 * @classdesc
@@ -2310,7 +2312,7 @@
 	  * @returns {Vector2d} new me.Vector2d
 	  */
 	 Vector2d.prototype.clone = function clone () {
-	     return pull("Vector2d", this.x, this.y);
+	     return pool$1.pull("Vector2d", this.x, this.y);
 	 };
 
 	 /**
@@ -2610,7 +2612,7 @@
 	 * @returns {Color} Reference to the newly cloned object
 	 */
 	Color.prototype.clone = function clone () {
-	    return pull("Color").copy(this);
+	    return pool$1.pull("Color").copy(this);
 	};
 
 	/**
@@ -3290,12 +3292,12 @@
 	  */
 	 Matrix3d.prototype.applyInverse = function applyInverse (v) {
 	     // invert the current matrix
-	     var im = pull("Matrix3d", this).invert();
+	     var im = pool$1.pull("Matrix3d", this).invert();
 
 	     // apply the inverted matrix
 	     im.apply(v);
 
-	     push(im);
+	     pool$1.push(im);
 
 	     return v;
 	 };
@@ -3602,7 +3604,7 @@
 	 * @returns {Matrix3d}
 	 */
 	Matrix3d.prototype.clone = function clone () {
-	    return pull("Matrix3d", this);
+	    return pool$1.pull("Matrix3d", this);
 	};
 
 	/**
@@ -4111,7 +4113,7 @@
 	  * @returns {Matrix2d}
 	  */
 	 Matrix2d.prototype.clone = function clone () {
-	     return pull("Matrix2d", this);
+	     return pool$1.pull("Matrix2d", this);
 	 };
 
 	 /**
@@ -8711,7 +8713,7 @@
 	     * @returns {ObservableVector2d} new me.ObservableVector2d
 	     */
 	    ObservableVector2d.prototype.clone = function clone () {
-	        return pull("ObservableVector2d", this._x, this._y, {onUpdate: this.onUpdate, scope: this.scope});
+	        return pool$1.pull("ObservableVector2d", this._x, this._y, {onUpdate: this.onUpdate, scope: this.scope});
 	    };
 
 	    /**
@@ -8722,7 +8724,7 @@
 	     * @returns {Vector2d} new me.Vector2d
 	     */
 	    ObservableVector2d.prototype.toVector2d = function toVector2d () {
-	        return pull("Vector2d", this._x, this._y);
+	        return pool$1.pull("Vector2d", this._x, this._y);
 	    };
 
 	    /**
@@ -9297,7 +9299,7 @@
 	  * @returns {Vector3d} new me.Vector3d
 	  */
 	 Vector3d.prototype.clone = function clone () {
-	     return pull("Vector3d", this.x, this.y, this.z);
+	     return pool$1.pull("Vector3d", this.x, this.y, this.z);
 	 };
 
 	 /**
@@ -9836,7 +9838,7 @@
 	     * @returns {ObservableVector3d} new me.ObservableVector3d
 	     */
 	    ObservableVector3d.prototype.clone = function clone () {
-	        return pull("ObservableVector3d",
+	        return pool$1.pull("ObservableVector3d",
 	            this._x,
 	            this._y,
 	            this._z,
@@ -9852,7 +9854,7 @@
 	     * @returns {Vector3d} new me.Vector3d
 	     */
 	    ObservableVector3d.prototype.toVector3d = function toVector3d () {
-	        return pull("Vector3d", this._x, this._y, this._z);
+	        return pool$1.pull("Vector3d", this._x, this._y, this._z);
 	    };
 
 	    /**
@@ -10572,16 +10574,16 @@
 	     * @public
 	     * @type {Vector2d}
 	     * @name pos
-	     * @memberof Polygon#
+	     * @memberof Polygon.prototype
 	     */
-	    this.pos = new Vector2d();
+	    this.pos = pool$1.pull("Vector2d");
 
 	    /**
 	     * The bounding rectangle for this shape
 	     * @ignore
 	     * @type {Bounds}
 	     * @name _bounds
-	     * @memberof Polygon#
+	     * @memberof Polygon.prototype
 	     */
 	    this._bounds;
 
@@ -10591,7 +10593,7 @@
 	     * @public
 	     * @type {Vector2d[]}
 	     * @name points
-	     * @memberof Polygon#
+	     * @memberof Polygon.prototype
 	     */
 	    this.points = [];
 
@@ -10666,13 +10668,13 @@
 	        if (typeof vertices[0] === "object") {
 	            // array of {x,y} object
 	            vertices.forEach(function (vertice) {
-	               this$1$1.points.push(new Vector2d(vertice.x, vertice.y));
+	               this$1$1.points.push(pool$1.pull("Vector2d", vertice.x, vertice.y));
 	            });
 
 	        } else {
 	            // it's a flat array
 	            for (var p = 0; p < vertices.length; p += 2) {
-	                this.points.push(new Vector2d(vertices[p], vertices[p + 1]));
+	                this.points.push(pool$1.pull("Vector2d", vertices[p], vertices[p + 1]));
 	            }
 	        }
 	    } else {
@@ -10807,12 +10809,12 @@
 	    // Calculate the edges/normals
 	    for (i = 0; i < len; i++) {
 	        if (edges[i] === undefined) {
-	            edges[i] = new Vector2d();
+	            edges[i] = pool$1.pull("Vector2d");
 	        }
 	        edges[i].copy(points[(i + 1) % len]).sub(points[i]);
 
 	        if (normals[i] === undefined) {
-	            normals[i] = new Vector2d();
+	            normals[i] = pool$1.pull("Vector2d");
 	        }
 	        normals[i].copy(edges[i]).perp().normalize();
 	    }
@@ -10928,14 +10930,14 @@
 	/**
 	 * Shifts the Polygon to the given position vector.
 	 * @name shift
-	 * @memberof Polygon
+	 * @memberof Polygon.prototype
 	 * @function
 	 * @param {Vector2d} position
 	 */
 	/**
 	 * Shifts the Polygon to the given x, y position.
 	 * @name shift
-	 * @memberof Polygon
+	 * @memberof Polygon.prototype
 	 * @function
 	 * @param {number} x
 	 * @param {number} y
@@ -11016,7 +11018,7 @@
 	 */
 	Polygon.prototype.getBounds = function getBounds () {
 	    if (typeof this._bounds === "undefined") {
-	        this._bounds = pull("Bounds");
+	        this._bounds = pool$1.pull("Bounds");
 	    }
 	    return this._bounds;
 	};
@@ -11062,10 +11064,10 @@
 	    function Rect(x, y, w, h) {
 	        // parent constructor
 	        Polygon.call(this, x, y, [
-	            new Vector2d(0, 0), // 0, 0
-	            new Vector2d(w, 0), // 1, 0
-	            new Vector2d(w, h), // 1, 1
-	            new Vector2d(0, h) ]);
+	            pool$1.pull("Vector2d", 0, 0), // 0, 0
+	            pool$1.pull("Vector2d", w, 0), // 1, 0
+	            pool$1.pull("Vector2d", w, h), // 1, 1
+	            pool$1.pull("Vector2d", 0, h) ]);
 	        this.shapeType = "Rectangle";
 	    }
 
@@ -11114,7 +11116,7 @@
 	     * @public
 	     * @type {number}
 	     * @name left
-	     * @memberof Rect
+	     * @memberof Rect.prototype
 	     */
 	    prototypeAccessors.left.get = function () {
 	        return this.pos.x;
@@ -11125,7 +11127,7 @@
 	     * @public
 	     * @type {number}
 	     * @name right
-	     * @memberof Rect
+	     * @memberof Rect.prototype
 	     */
 	    prototypeAccessors.right.get = function () {
 	        var w = this.width;
@@ -11137,7 +11139,7 @@
 	     * @public
 	     * @type {number}
 	     * @name top
-	     * @memberof Rect
+	     * @memberof Rect.prototype
 	     */
 	    prototypeAccessors.top.get = function () {
 	        return this.pos.y;
@@ -11148,7 +11150,7 @@
 	     * @public
 	     * @type {number}
 	     * @name bottom
-	     * @memberof Rect
+	     * @memberof Rect.prototype
 	     */
 	    prototypeAccessors.bottom.get = function () {
 	        var h = this.height;
@@ -11160,7 +11162,7 @@
 	     * @public
 	     * @type {number}
 	     * @name width
-	     * @memberof Rect
+	     * @memberof Rect.prototype
 	     */
 	    prototypeAccessors.width.get = function () {
 	        return this.points[2].x;
@@ -11176,7 +11178,7 @@
 	     * @public
 	     * @type {number}
 	     * @name height
-	     * @memberof Rect
+	     * @memberof Rect.prototype
 	     */
 	    prototypeAccessors.height.get = function () {
 	        return this.points[2].y;
@@ -11192,7 +11194,7 @@
 	     * @public
 	     * @type {number}
 	     * @name centerX
-	     * @memberof Rect
+	     * @memberof Rect.prototype
 	     */
 	    prototypeAccessors.centerX.get = function () {
 	        if (isFinite(this.width)) {
@@ -11210,7 +11212,7 @@
 	     * @public
 	     * @type {number}
 	     * @name centerY
-	     * @memberof Rect
+	     * @memberof Rect.prototype
 	     */
 	    prototypeAccessors.centerY.get = function () {
 	        if (isFinite(this.height)) {
@@ -11354,7 +11356,7 @@
 	    /**
 	     * Returns true if the rectangle contains the given point
 	     * @name contains
-	     * @memberof Rect
+	     * @memberof Rect.prototype
 	     * @function
 	     * @param {Vector2d} point
 	     * @returns {boolean} true if contains
@@ -11423,7 +11425,7 @@
 	     * @returns {Polygon} a new Polygon that represents this rectangle.
 	     */
 	    Rect.prototype.toPolygon = function toPolygon () {
-	        return new Polygon(
+	        return pool$1.pull("Polygon",
 	            this.pos.x, this.pos.y, this.points
 	        );
 	    };
@@ -11899,6 +11901,8 @@
 	 * a bound object contains methods for creating and manipulating axis-aligned bounding boxes (AABB).
 	 */
 	var Bounds$1 = function Bounds(vertices) {
+	    // @ignore
+	    this._center = new Vector2d();
 	    this.onResetEvent(vertices);
 	};
 
@@ -11917,9 +11921,6 @@
 	    if (typeof vertices !== "undefined") {
 	        this.update(vertices);
 	    }
-
-	    // @ignore
-	    this._center = new Vector2d();
 	};
 
 	/**
@@ -12345,11 +12346,11 @@
 	 * @returns {Polygon} a new Polygon that represents this bounds.
 	 */
 	Bounds$1.prototype.toPolygon = function toPolygon () {
-	    return new Polygon(this.x, this.y, [
-	        new Vector2d(0,      0),
-	        new Vector2d(this.width, 0),
-	        new Vector2d(this.width, this.height),
-	        new Vector2d(0,      this.height)
+	    return pool$1.pull("Polygon", this.x, this.y, [
+	        pool$1.pull("Vector2d", 0,      0),
+	        pool$1.pull("Vector2d", this.width, 0),
+	        pool$1.pull("Vector2d", this.width, this.height),
+	        pool$1.pull("Vector2d", 0,      this.height)
 	    ]);
 	};
 
@@ -13058,11 +13059,11 @@
 	                if (typeof region.currentTransform !== "undefined") {
 	                    if (!region.currentTransform.isIdentity()) {
 	                        var invV = region.currentTransform.applyInverse(
-	                            pull("Vector2d", gameX, gameY)
+	                            pool$1.pull("Vector2d", gameX, gameY)
 	                        );
 	                        gameX = invV.x;
 	                        gameY = invV.y;
-	                        push(invV);
+	                        pool$1.push(invV);
 	                    }
 	                }
 	                eventInBounds = bounds.contains(gameX, gameY);
@@ -13291,7 +13292,7 @@
 	 * };
 	 */
 	function globalToLocal(x, y, v) {
-	    v = v || pull("Vector2d");
+	    v = v || pool$1.pull("Vector2d");
 	    var rect = device$1.getElementBounds(renderer.getScreenCanvas());
 	    var pixelRatio = device$1.devicePixelRatio;
 	    x -= rect.left + (globalThis.pageXOffset || 0);
@@ -14165,7 +14166,7 @@
 	             * @name currentTransform
 	             * @memberof Renderable#
 	             */
-	            this.currentTransform = pull("Matrix2d");
+	            this.currentTransform = pool$1.pull("Matrix2d");
 	        }
 	        this.currentTransform.identity();
 
@@ -14254,7 +14255,7 @@
 	             * @name anchorPoint
 	             * @memberof Renderable#
 	             */
-	            this.anchorPoint = pull("ObservableVector2d", 0.5, 0.5, { onUpdate: this.onAnchorUpdate, scope: this });
+	            this.anchorPoint = pool$1.pull("ObservableVector2d", 0.5, 0.5, { onUpdate: this.onAnchorUpdate, scope: this });
 	        }
 
 	        /**
@@ -14339,7 +14340,7 @@
 	         * // remove the tint
 	         * this.tint.setColor(255, 255, 255);
 	         */
-	        this.tint = pull("Color", 255, 255, 255, 1.0);
+	        this.tint = pool$1.pull("Color", 255, 255, 255, 1.0);
 
 	        /**
 	         * the blend mode to be applied to this renderable (see renderer setBlendMode for available blend mode)
@@ -14373,7 +14374,7 @@
 	             * @name pos
 	             * @memberof Renderable#
 	             */
-	            this.pos = pull("ObservableVector3d", x, y, 0, { onUpdate: this.updateBoundsPos, scope: this});
+	            this.pos = pool$1.pull("ObservableVector3d", x, y, 0, { onUpdate: this.updateBoundsPos, scope: this});
 	        }
 
 	        /**
@@ -14754,7 +14755,7 @@
 	      */
 	      Renderable.prototype.getAbsolutePosition = function getAbsolutePosition () {
 	          if (typeof this._absPos === "undefined") {
-	              this._absPos = pull("Vector2d");
+	              this._absPos = pool$1.pull("Vector2d");
 	          }
 	          // XXX Cache me or something
 	          this._absPos.set(this.pos.x, this.pos.y);
@@ -14909,32 +14910,32 @@
 	     */
 	    Renderable.prototype.destroy = function destroy () {
 	        // allow recycling object properties
-	        push(this.currentTransform);
+	        pool$1.push(this.currentTransform);
 	        this.currentTransform = undefined;
 
-	        push(this.anchorPoint);
+	        pool$1.push(this.anchorPoint);
 	        this.anchorPoint = undefined;
 
-	        push(this.pos);
+	        pool$1.push(this.pos);
 	        this.pos = undefined;
 
 	        if (typeof this._absPos !== "undefined") {
-	            push(this._absPos);
+	            pool$1.push(this._absPos);
 	            this._absPos = undefined;
 	        }
 
-	        push(this._bounds);
+	        pool$1.push(this._bounds);
 	        this._bounds = undefined;
 
 	        this.onVisibilityChange = undefined;
 
 	        if (typeof this.mask !== "undefined") {
-	            push(this.mask);
+	            pool$1.push(this.mask);
 	            this.mask = undefined;
 	        }
 
 	        if (typeof this.tint !== "undefined") {
-	            push(this.tint);
+	            pool$1.push(this.tint);
 	            this.tint = undefined;
 	        }
 
@@ -14979,9 +14980,9 @@
 	     * @public
 	     * @type {Vector2d}
 	     * @name pos
-	     * @memberof Ellipse#
+	     * @memberof Ellipse.prototype
 	     */
-	    this.pos = new Vector2d();
+	    this.pos = pool$1.pull("Vector2d");
 
 	    /**
 	     * The bounding rectangle for this shape
@@ -14994,7 +14995,7 @@
 	     * @public
 	     * @type {number}
 	     * @name radius
-	     * @memberof Ellipse
+	     * @memberof Ellipse.prototype
 	     */
 	    this.radius = NaN;
 
@@ -15003,27 +15004,27 @@
 	     * @public
 	     * @type {Vector2d}
 	     * @name radiusV
-	     * @memberof Ellipse#
+	     * @memberof Ellipse.prototype
 	     */
-	    this.radiusV = new Vector2d();
+	    this.radiusV = pool$1.pull("Vector2d");
 
 	    /**
 	     * Radius squared, for pythagorean theorom
 	     * @public
 	     * @type {Vector2d}
 	     * @name radiusSq
-	     * @memberof Ellipse#
+	     * @memberof Ellipse.prototype
 	     */
-	    this.radiusSq = new Vector2d();
+	    this.radiusSq = pool$1.pull("Vector2d");
 
 	    /**
 	     * x/y scaling ratio for ellipse
 	     * @public
 	     * @type {Vector2d}
 	     * @name ratio
-	     * @memberof Ellipse#
+	     * @memberof Ellipse.prototype
 	     */
-	    this.ratio = new Vector2d();
+	    this.ratio = pool$1.pull("Vector2d");
 
 	    // the shape type
 	    this.shapeType = "Ellipse";
@@ -15213,7 +15214,7 @@
 	 */
 	Ellipse.prototype.getBounds = function getBounds () {
 	    if (typeof this._bounds === "undefined") {
-	        this._bounds = pull("Bounds");
+	        this._bounds = pool$1.pull("Bounds");
 	    }
 	    return this._bounds;
 	};
@@ -16100,7 +16101,7 @@
 	         * @public
 	         * @type {Bounds}
 	         */
-	        this.bounds = new Bounds$1();
+	        this.bounds = pool$1.pull("Bounds");
 	    }
 
 	    if (typeof this.shapes === "undefined") {
@@ -16134,55 +16135,54 @@
 	     */
 	    this.collisionType = collision.types.ENEMY_OBJECT;
 
-	    /**
-	     * body velocity
-	     * @public
-	     * @type {Vector2d}
-	     * @default <0,0>
-	     */
 	    if (typeof this.vel === "undefined") {
-	        this.vel = new Vector2d();
+	        /**
+	         * body velocity
+	         * @public
+	         * @type {Vector2d}
+	         * @default <0,0>
+	         */
+	        this.vel = pool$1.pull("Vector2d");
 	    }
 	    this.vel.set(0, 0);
 
-	    /**
-	     * body force or acceleration (automatically) applied to the body.
-	     * when defining a force, user should also define a max velocity
-	     * @public
-	     * @type {Vector2d}
-	     * @default <0,0>
-	     * @see Body.setMaxVelocity
-	     * @example
-	     * // define a default maximum acceleration, initial force and friction
-	     * this.body.force.set(0, 0);
-	     * this.body.friction.set(0.4, 0);
-	     * this.body.setMaxVelocity(3, 15);
-	     *
-	     * // apply a postive or negative force when pressing left of right key
-	     * update(dt) {
-	     * if (me.input.isKeyPressed("left")){
-	     *      this.body.force.x = -this.body.maxVel.x;
-	     *  } else if (me.input.isKeyPressed("right")) {
-	     *     this.body.force.x = this.body.maxVel.x;
-	     * } else {
-	     *     this.body.force.x = 0;
-	     * }
-	     * }
-	     */
 	    if (typeof this.force === "undefined") {
-	        this.force = new Vector2d();
+	        /**
+	         * body force or acceleration (automatically) applied to the body.
+	         * when defining a force, user should also define a max velocity
+	         * @public
+	         * @type {Vector2d}
+	         * @default <0,0>
+	         * @see Body.setMaxVelocity
+	         * @example
+	         * // define a default maximum acceleration, initial force and friction
+	         * this.body.force.set(0, 0);
+	         * this.body.friction.set(0.4, 0);
+	         * this.body.setMaxVelocity(3, 15);
+	         *
+	         * // apply a postive or negative force when pressing left of right key
+	         * update(dt) {
+	         * if (me.input.isKeyPressed("left")){
+	         *      this.body.force.x = -this.body.maxVel.x;
+	         *  } else if (me.input.isKeyPressed("right")) {
+	         *     this.body.force.x = this.body.maxVel.x;
+	         * } else {
+	         *     this.body.force.x = 0;
+	         * }
+	         * }
+	         */
+	        this.force = pool$1.pull("Vector2d");
 	    }
 	    this.force.set(0, 0);
 
-
-	    /**
-	     * body friction
-	     * @public
-	     * @type {Vector2d}
-	     * @default <0,0>
-	     */
 	    if (typeof this.friction === "undefined") {
-	        this.friction = new Vector2d();
+	        /**
+	         * body friction
+	         * @public
+	         * @type {Vector2d}
+	         * @default <0,0>
+	         */
+	        this.friction = pool$1.pull("Vector2d");
 	    }
 	    this.friction.set(0, 0);
 
@@ -16203,14 +16203,14 @@
 	     */
 	    this.mass = 1;
 
-	    /**
-	     * max velocity (to limit body velocity)
-	     * @public
-	     * @type {Vector2d}
-	     * @default <490,490>
-	     */
 	    if (typeof this.maxVel === "undefined") {
-	        this.maxVel = new Vector2d();
+	        /**
+	         * max velocity (to limit body velocity)
+	         * @public
+	         * @type {Vector2d}
+	         * @default <490,490>
+	         */
+	        this.maxVel = pool$1.pull("Vector2d");
 	    }
 	    // cap by default to half the default gravity force
 	    this.maxVel.set(490, 490);
@@ -16365,7 +16365,7 @@
 	        polygon.setShape(0, 0, vertices);
 	    } else {
 	        // this will replace any other non polygon shape type if defined
-	        this.shapes[index] = new Polygon(0, 0, vertices);
+	        this.shapes[index] = pool$1.pull("Polygon", 0, 0, vertices);
 	    }
 
 	    // update the body bounds to take in account the new vertices
@@ -16763,11 +16763,28 @@
 	 * @ignore
 	 */
 	Body.prototype.destroy = function destroy () {
+	    // push back instance into object pool
+	    pool$1.push(this.bounds);
+	    pool$1.push(this.vel);
+	    pool$1.push(this.force);
+	    pool$1.push(this.friction);
+	    pool$1.push(this.maxVel);
+	    this.shapes.forEach(function (shape) {
+	        pool$1.push(shape);
+	    });
+
+	    // set to undefined
 	    this.onBodyUpdate = undefined;
 	    this.ancestor = undefined;
 	    this.bounds = undefined;
-	    this.setStatic(false);
+	    this.vel = undefined;
+	    this.force = undefined;
+	    this.friction = undefined;
+	    this.maxVel = undefined;
 	    this.shapes.length = 0;
+
+	    // reset some variable to default
+	    this.setStatic(false);
 	};
 
 	/**
@@ -16894,7 +16911,7 @@
 	         * // add a red background color to this container
 	         * this.backgroundColor.setColor(255, 0, 0);
 	         */
-	        this.backgroundColor = pull("Color", 0, 0, 0, 0.0);
+	        this.backgroundColor = pool$1.pull("Color", 0, 0, 0, 0.0);
 
 	        /**
 	         * Used by the debug panel plugin
@@ -17460,7 +17477,7 @@
 
 	            if (!keepalive) {
 	                // attempt at recycling the object
-	                if (push(child, false) === false ) {
+	                if (pool$1.push(child, false) === false ) {
 	                    //  else just destroy it
 	                    if (typeof child.destroy === "function") {
 	                        child.destroy();
@@ -18223,7 +18240,7 @@
 	         * @name bodies
 	         * @memberof World
 	         * @public
-	         * @type {Set}
+	         * @type {Set<Body>}
 	         */
 	        this.bodies = new Set();
 
@@ -18630,7 +18647,7 @@
 	         * @name bounds
 	         * @memberof Camera2d
 	         */
-	        this.bounds = pull("Bounds");
+	        this.bounds = pool$1.pull("Bounds");
 
 	        /**
 	         * enable or disable damping
@@ -19127,8 +19144,8 @@
 	    Camera2d.prototype.fadeOut = function fadeOut (color, duration, onComplete) {
 	        if ( duration === void 0 ) duration = 1000;
 
-	        this._fadeOut.color = pull("Color").copy(color);
-	        this._fadeOut.tween = pull("Tween", this._fadeOut.color)
+	        this._fadeOut.color = pool$1.pull("Color").copy(color);
+	        this._fadeOut.tween = pool$1.pull("Tween", this._fadeOut.color)
 	            .to({ alpha: 0.0 }, duration)
 	            .onComplete(onComplete || null);
 	        this._fadeOut.tween.isPersistent = true;
@@ -19151,10 +19168,10 @@
 	    Camera2d.prototype.fadeIn = function fadeIn (color, duration, onComplete) {
 	        if ( duration === void 0 ) duration = 1000;
 
-	        this._fadeIn.color = pull("Color").copy(color);
+	        this._fadeIn.color = pool$1.pull("Color").copy(color);
 	        var _alpha = this._fadeIn.color.alpha;
 	        this._fadeIn.color.alpha = 0.0;
-	        this._fadeIn.tween = pull("Tween", this._fadeIn.color)
+	        this._fadeIn.tween = pool$1.pull("Tween", this._fadeIn.color)
 	            .to({ alpha: _alpha }, duration)
 	            .onComplete(onComplete || null);
 	        this._fadeIn.tween.isPersistent = true;
@@ -19210,7 +19227,7 @@
 	     */
 	    Camera2d.prototype.localToWorld = function localToWorld (x, y, v) {
 	        // TODO memoization for one set of coords (multitouch)
-	        v = v || pull("Vector2d");
+	        v = v || pool$1.pull("Vector2d");
 	        v.set(x, y).add(this.pos).sub(world.pos);
 	        if (!this.currentTransform.isIdentity()) {
 	            this.invCurrentTransform.apply(v);
@@ -19231,7 +19248,7 @@
 	     */
 	    Camera2d.prototype.worldToLocal = function worldToLocal (x, y, v) {
 	        // TODO memoization for one set of coords (multitouch)
-	        v = v || pull("Vector2d");
+	        v = v || pool$1.pull("Vector2d");
 	        v.set(x, y);
 	        if (!this.currentTransform.isIdentity()) {
 	            this.currentTransform.apply(v);
@@ -19256,7 +19273,7 @@
 	            // remove the tween if over
 	            if (this._fadeIn.color.alpha === 1.0) {
 	                this._fadeIn.tween = null;
-	                push(this._fadeIn.color);
+	                pool$1.push(this._fadeIn.color);
 	                this._fadeIn.color = null;
 	            }
 	        }
@@ -19273,7 +19290,7 @@
 	            // remove the tween if over
 	            if (this._fadeOut.color.alpha === 0.0) {
 	                this._fadeOut.tween = null;
-	                push(this._fadeOut.color);
+	                pool$1.push(this._fadeOut.color);
 	                this._fadeOut.color = null;
 	            }
 	        }
@@ -19344,7 +19361,7 @@
 	     * Cameras will be renderered based on this order defined in this list.
 	     * Only the "default" camera will be resized when the window or canvas is resized.
 	     * @public
-	     * @type {Map}
+	     * @type {Map<Camera2d>}
 	     * @name cameras
 	     * @memberof Stage
 	     */
@@ -19618,7 +19635,7 @@
 
 	        ), 2);
 
-	        var logo1 = pull("Text",
+	        var logo1 = pool$1.pull("Text",
 	            renderer.getWidth() / 2,
 	            (renderer.getHeight() / 2) + 16, {
 	                font: "century gothic",
@@ -19632,7 +19649,7 @@
 	        );
 	        logo1.anchorPoint.set(0, 0);
 
-	        var logo2 = pull("Text",
+	        var logo2 = pool$1.pull("Text",
 	            renderer.getWidth() / 2,
 	            (renderer.getHeight() / 2) + 16, {
 	                font: "century gothic",
@@ -20175,7 +20192,7 @@
 	            // if fading effect
 	            if (_fade.duration && _stages[state].transition) {
 	                /** @ignore */
-	                _onSwitchComplete = function() {
+	                _onSwitchComplete = function () {
 	                    viewport.fadeOut(_fade.color, _fade.duration);
 	                };
 	                viewport.fadeIn(
@@ -21331,7 +21348,7 @@
 	     var height = image.height;
 
 	     // calculate the sprite count (line, col)
-	     var spritecount = pull("Vector2d",
+	     var spritecount = pool$1.pull("Vector2d",
 	         ~~((width - margin + spacing) / (data.framewidth + spacing)),
 	         ~~((height - margin + spacing) / (data.frameheight + spacing))
 	     );
@@ -21374,7 +21391,7 @@
 	         this.addUVs(atlas, name, width, height);
 	     }
 
-	     push(spritecount);
+	     pool$1.push(spritecount);
 
 	     return atlas;
 	 };
@@ -21549,7 +21566,7 @@
 	        if ( nineSlice === void 0 ) nineSlice = false;
 
 	     // instantiate a new sprite object
-	     return pull(
+	     return pool$1.pull(
 	         nineSlice === true ? "me.NineSliceSprite" : "me.Sprite",
 	         0, 0,
 	         Object.assign({
@@ -21657,7 +21674,7 @@
 	         * @name offset
 	         * @memberof Sprite#
 	         */
-	        this.offset = pull("Vector2d", 0, 0);
+	        this.offset = pool$1.pull("Vector2d", 0, 0);
 
 	        /**
 	         * The source texture object this sprite object is using
@@ -21682,7 +21699,7 @@
 	            // length of the current animation name
 	            length : 0,
 	            //current frame texture offset
-	            offset : new Vector2d(),
+	            offset : pool$1.pull("Vector2d"),
 	            // current frame size
 	            width : 0,
 	            height : 0,
@@ -22178,7 +22195,7 @@
 	     * @ignore
 	     */
 	    Sprite.prototype.destroy = function destroy () {
-	        push(this.offset);
+	        pool$1.push(this.offset);
 	        this.offset = undefined;
 	        Renderable.prototype.destroy.call(this);
 	    };
@@ -22420,6 +22437,75 @@
 	    return Tile;
 	}(Bounds$1));
 
+	// https://developer.chrome.com/blog/canvas2d/#round-rect
+
+	/**
+	 * @classdesc
+	 * a rectangle object with rounded corners
+	 * @augments Rect
+	 */
+	var RoundRect = /*@__PURE__*/(function (Rect) {
+	    function RoundRect(x, y, width, height, radius) {
+	        if ( radius === void 0 ) radius = 20;
+
+	        // parent constructor
+	        Rect.call(this, x, y, width, height);
+
+	        // set the corner radius
+	        this.radius = radius;
+	    }
+
+	    if ( Rect ) RoundRect.__proto__ = Rect;
+	    RoundRect.prototype = Object.create( Rect && Rect.prototype );
+	    RoundRect.prototype.constructor = RoundRect;
+
+	    var prototypeAccessors = { radius: { configurable: true } };
+
+	    /** @ignore */
+	    RoundRect.prototype.onResetEvent = function onResetEvent (x, y, w, h, radius) {
+	        Rect.prototype.setShape.call(this, x, y, w, h);
+	        this.radius = radius;
+	    };
+
+
+	    /**
+	     * the radius of the rounded corner
+	     * @public
+	     * @type {number}
+	     * @default 20
+	     * @name radius
+	     * @memberof RoundRect.prototype
+	     */
+	    prototypeAccessors.radius.get = function () {
+	        return this._radius;
+	    };
+	    prototypeAccessors.radius.set = function (value) {
+	        // verify the rectangle is at least as wide and tall as the rounded corners.
+	        if (this.width < 2 * value) {
+	            value = this.width / 2;
+	        }
+	        if (this.height < 2 * value) {
+	            value = this.height / 2;
+	        }
+	        this._radius = value;
+	    };
+
+	    /**
+	     * clone this RoundRect
+	     * @name clone
+	     * @memberof RoundRect.prototype
+	     * @function
+	     * @returns {RoundRect} new RoundRect
+	     */
+	    RoundRect.prototype.clone = function clone () {
+	        return new RoundRect(this.pos.x, this.pos.y, this.width, this.height, this.radius);
+	    };
+
+	    Object.defineProperties( RoundRect.prototype, prototypeAccessors );
+
+	    return RoundRect;
+	}(Rect));
+
 	/**
 	 * @classdesc
 	 * a line segment Object
@@ -22484,11 +22570,11 @@
 
 	        // Calculate the edges/normals
 	        if (edges[0] === undefined) {
-	            edges[0] = new Vector2d();
+	            edges[0] = pool$1.pull("Vector2d");
 	        }
 	        edges[0].copy(points[1]).sub(points[0]);
 	        if (normals[0] === undefined) {
-	            normals[0] = new Vector2d();
+	            normals[0] = pool$1.pull("Vector2d");
 	        }
 	        normals[0].copy(edges[0]).perp().normalize();
 
@@ -22517,6 +22603,323 @@
 	    return Line;
 	}(Polygon));
 
+	/**
+	 * @classdesc
+	 * a simplified path2d implementation, supporting only one path
+	 */
+	var Path2D = function Path2D() {
+	    /**
+	     * the points defining the current path
+	     * @public
+	     * @type {Vector2d[]}
+	     * @name points
+	     * @memberof Path2D#
+	     */
+	    this.points = [];
+
+	    /**
+	     * space between interpolated points for quadratic and bezier curve approx. in pixels.
+	     * @public
+	     * @type {number}
+	     * @name arcResolution
+	     * @default 5
+	     * @memberof Path2D#
+	     */
+	    this.arcResolution = 5;
+
+	    /* @ignore */
+	    this.vertices = [];
+	};
+
+	/**
+	 * begin a new path
+	 * @name beginPath
+	 * @memberof Path2D.prototype
+	 * @function
+	 */
+	Path2D.prototype.beginPath = function beginPath () {
+	    // empty the cache and recycle all vectors
+	    this.points.forEach(function (point) {
+	        pool$1.push(point);
+	    });
+	    this.points.length = 0;
+	};
+
+	/**
+	 * causes the point of the pen to move back to the start of the current path.
+	 * It tries to draw a straight line from the current point to the start.
+	 * If the shape has already been closed or has only one point, this function does nothing.
+	 * @name closePath
+	 * @memberof Path2D.prototype
+	 * @function
+	 */
+	Path2D.prototype.closePath = function closePath () {
+	    var points = this.points;
+	    if (points.length > 1 && !points[points.length-1].equals(points[0])) {
+	        points.push(pool$1.pull("Vector2d", points[0].x, points[0].y));
+	    }
+	};
+
+	/**
+	 * triangulate the shape defined by this path into an array of triangles
+	 * @name triangulatePath
+	 * @memberof Path2D.prototype
+	 * @function
+	 * @returns {Vector2d[]}
+	 */
+	Path2D.prototype.triangulatePath = function triangulatePath () {
+	    var i = 0;
+	    var points = this.points;
+	    var vertices = this.vertices;
+	    var indices = earcut$1.exports(points.flatMap(function (p) { return [p.x, p.y]; }));
+
+	    // calculate all vertices
+	    for (i = 0; i < indices.length; i++ ) {
+	        if (typeof vertices[i] === "undefined") {
+	            // increase cache buffer if necessary
+	            vertices[i] = pool$1.pull("Vector2d");
+	        }
+	        vertices[i].set(points[indices[i]].x, points[indices[i]].y);
+	    }
+
+	    // recycle overhead from a previous triangulation
+	    while (vertices.length > indices.length) {
+	        pool$1.push(vertices[vertices.length-1]);
+	        vertices.length -= 1;
+	    }
+
+	    return vertices;
+	};
+
+	/**
+	 * moves the starting point of the current path to the (x, y) coordinates.
+	 * @name moveTo
+	 * @memberof Path2D.prototype
+	 * @function
+	 * @param {number} x the x-axis (horizontal) coordinate of the point.
+	 * @param {number} y the y-axis (vertical) coordinate of the point.
+	 */
+	Path2D.prototype.moveTo = function moveTo (x, y) {
+	  this.points.push(pool$1.pull("Vector2d", x, y));
+	};
+
+	/**
+	 * connects the last point in the current patch to the (x, y) coordinates with a straight line.
+	 * @name lineTo
+	 * @memberof Path2D.prototype
+	 * @function
+	 * @param {number} x the x-axis coordinate of the line's end point.
+	 * @param {number} y the y-axis coordinate of the line's end point.
+	 */
+	Path2D.prototype.lineTo = function lineTo (x, y) {
+	    this.points.push(pool$1.pull("Vector2d", x, y));
+	};
+
+	/**
+	 * adds an arc to the current path which is centered at (x, y) position with the given radius,
+	 * starting at startAngle and ending at endAngle going in the given direction by counterclockwise (defaulting to clockwise).
+	 * @name arc
+	 * @memberof Path2D.prototype
+	 * @function
+	 * @param {number} x the horizontal coordinate of the arc's center.
+	 * @param {number} y the vertical coordinate of the arc's center.
+	 * @param {number} radius the arc's radius. Must be positive.
+	 * @param {number} startAngle the angle at which the arc starts in radians, measured from the positive x-axis.
+	 * @param {number} endAngle the angle at which the arc ends in radians, measured from the positive x-axis.
+	 * @param {boolean} [anticlockwise=false] an optional boolean value. If true, draws the arc counter-clockwise between the start and end angles.
+	 */
+	Path2D.prototype.arc = function arc (x, y, radius, startAngle, endAngle, anticlockwise) {
+	        if ( anticlockwise === void 0 ) anticlockwise = false;
+
+	    var points = this.points;
+	    // based on from https://github.com/karellodewijk/canvas-webgl/blob/master/canvas-webgl.js
+	    //bring angles all in [0, 2*PI] range
+	    if (startAngle === endAngle) { return; }
+	    var fullCircle = anticlockwise ? Math.abs(startAngle-endAngle) >= (TAU) : Math.abs(endAngle-startAngle) >= (TAU);
+
+	    startAngle = startAngle % (TAU);
+	    endAngle = endAngle % (TAU);
+
+	    if (startAngle < 0) { startAngle += TAU; }
+	    if (endAngle < 0) { endAngle += TAU; }
+
+	    if (startAngle >= endAngle) {
+	        endAngle+= TAU;
+	    }
+
+	    var diff = endAngle - startAngle;
+	    var direction = 1;
+	    if (anticlockwise) {
+	        direction = -1;
+	        diff = TAU - diff;
+	    }
+
+	    if (fullCircle) { diff = TAU; }
+
+	    var length = diff * radius;
+	    var nr_of_interpolation_points = length / this.arcResolution;
+	    var dangle = diff / nr_of_interpolation_points;
+
+	    var angle = startAngle;
+	    for (var j = 0; j < nr_of_interpolation_points; j++) {
+	        points.push(pool$1.pull("Vector2d", x + radius * Math.cos(angle), y + radius * Math.sin(angle)));
+	        angle += direction * dangle;
+	    }
+	    points.push(pool$1.pull("Vector2d", x + radius * Math.cos(endAngle), y + radius * Math.sin(endAngle)));
+	};
+
+	/**
+	 * adds a circular arc to the path with the given control points and radius, connected to the previous point by a straight line.
+	 * @name arcTo
+	 * @memberof Path2D.prototype
+	 * @function
+	 * @param {number} x the x-axis coordinate of the first control point.
+	 * @param {number} y the y-axis coordinate of the first control point.
+	 * @param {number} x the x-axis coordinate of the second control point.
+	 * @param {number} y the y-axis coordinate of the second control point.
+	 * @param {number} radius the arc's radius. Must be positive.
+	 */
+	Path2D.prototype.arcTo = function arcTo (x1, y1, x2, y2, radius) {
+	    var points = this.points;
+	    // based on from https://github.com/karellodewijk/canvas-webgl/blob/master/canvas-webgl.js
+	    var x0 = points[points.length-1].x, y0 = points[points.length-1].y;
+
+	    //a = -incoming vector, b = outgoing vector to x1, y1
+	    var a = [x0 - x1, y0 - y1];
+	    var b = [x2 - x1, y2 - y1];
+
+	    //normalize
+	    var l_a = Math.sqrt(Math.pow(a[0], 2) + Math.pow(a[1], 2));
+	    var l_b = Math.sqrt(Math.pow(b[0], 2) + Math.pow(b[1], 2));
+	    a[0] /= l_a; a[1] /= l_a; b[0] /= l_b; b[1] /= l_b;
+	    var angle = Math.atan2(a[1], a[0]) - Math.atan2(b[1], b[0]);
+
+	    //work out tangent points using tan(θ) = opposite / adjacent; angle/2 because hypotenuse is the bisection of a,b
+	    var tan_angle_div2 = Math.tan(angle/2);
+	    var adj_l = (radius/tan_angle_div2);
+
+	    var tangent_point1 =  [x1 + a[0] * adj_l, y1 + a[1] * adj_l];
+	    var tangent_point2 =  [x1 + b[0] * adj_l, y1 + b[1] * adj_l];
+
+	    points.push(pool$1.pull("Vector2d", tangent_point1[0], tangent_point1[1]));
+
+	    var bisec = [(a[0] + b[0]) / 2.0, (a[1] + b[1]) / 2.0];
+	    var bisec_l = Math.sqrt(Math.pow(bisec[0], 2) + Math.pow(bisec[1], 2));
+	    bisec[0] /= bisec_l; bisec[1] /= bisec_l;
+
+	    var hyp_l = Math.sqrt(Math.pow(radius, 2) + Math.pow(adj_l, 2));
+	    var center = [x1 + hyp_l * bisec[0], y1 + hyp_l * bisec[1]];
+
+	    var startAngle = Math.atan2(tangent_point1[1] - center[1], tangent_point1[0] - center[0]);
+	    var endAngle = Math.atan2(tangent_point2[1] - center[1], tangent_point2[0] - center[0]);
+
+	    this.arc(center[0], center[1], radius, startAngle, endAngle);
+	};
+
+	/**
+	 * adds an elliptical arc to the path which is centered at (x, y) position with the radii radiusX and radiusY
+	 * starting at startAngle and ending at endAngle going in the given direction by counterclockwise.
+	 * @name ellipse
+	 * @memberof Path2D.prototype
+	 * @function
+	 * @param {number} x the x-axis (horizontal) coordinate of the ellipse's center.
+	 * @param {number} y the  y-axis (vertical) coordinate of the ellipse's center.
+	 * @param {number} radiusX the ellipse's major-axis radius. Must be non-negative.
+	 * @param {number} radiusY the ellipse's minor-axis radius. Must be non-negative.
+	 * @param {number} rotation the rotation of the ellipse, expressed in radians.
+	 * @param {number} startAngle the angle at which the ellipse starts, measured clockwise from the positive x-axis and expressed in radians.
+	 * @param {number} endAngle the angle at which the ellipse ends, measured clockwise from the positive x-axis and expressed in radians.
+	 * @param {boolean} [anticlockwise=false] an optional boolean value which, if true, draws the ellipse counterclockwise (anticlockwise).
+	 */
+	Path2D.prototype.ellipse = function ellipse (x, y, radiusX, radiusY, rotation, startAngle, endAngle, anticlockwise) {
+	        if ( anticlockwise === void 0 ) anticlockwise = false;
+
+	    var points = this.points;
+	    // based on from https://github.com/karellodewijk/canvas-webgl/blob/master/canvas-webgl.js
+	    if (startAngle === endAngle) { return; }
+	    var fullCircle = anticlockwise ? Math.abs(startAngle-endAngle) >= (TAU) : Math.abs(endAngle-startAngle) >= (TAU);
+
+	    //bring angles all in [0, 2*PI] range
+	    startAngle = startAngle % (TAU);
+	    endAngle = endAngle % (TAU);
+	    if (startAngle < 0) { startAngle += TAU; }
+	    if (endAngle < 0) { endAngle += TAU; }
+
+	    if (startAngle>=endAngle) {
+	        endAngle += TAU;
+	    }
+
+	    var diff = endAngle - startAngle;
+
+	    var direction = 1;
+	    if (anticlockwise) {
+	        direction = -1;
+	        diff = TAU - diff;
+	    }
+
+	    if (fullCircle) { diff = TAU; }
+
+	    var length = (diff * radiusX + diff * radiusY) / 2;
+	    var nr_of_interpolation_points = length / this.arcResolution;
+	    var dangle = diff / nr_of_interpolation_points;
+
+	    var angle = startAngle;
+	    var cos_rotation = Math.cos(rotation);
+	    var sin_rotation = Math.sin(rotation);
+	    for (var j = 0; j < nr_of_interpolation_points; j++) {
+	        var _x1 = radiusX * Math.cos(angle);
+	        var _y1 = radiusY * Math.sin(angle);
+	        var _x2 = x + _x1 * cos_rotation - _y1 * sin_rotation;
+	        var _y2 = y + _x1 * sin_rotation + _y1 * cos_rotation;
+	        points.push(pool$1.pull("Vector2d", _x2, _y2));
+	        angle += direction * dangle;
+	    }
+	    //var x1 = radiusX * Math.cos(endAngle);
+	    //var y1 = radiusY * Math.sin(endAngle);
+	    //points.push(pool.pull("Vector2d", x + x1 * cos_rotation - y1 * sin_rotation, y + x1 * sin_rotation + y1 * cos_rotation));
+	};
+
+	/**
+	 * creates a path for a rectangle at position (x, y) with a size that is determined by width and height.
+	 * @name rect
+	 * @memberof Path2D.prototype
+	 * @function
+	 * @param {number} x the x-axis coordinate of the rectangle's starting point.
+	 * @param {number} y the y-axis coordinate of the rectangle's starting point.
+	 * @param {number} width the rectangle's width. Positive values are to the right, and negative to the left.
+	 * @param {number} height the rectangle's height. Positive values are down, and negative are up.
+	 */
+	Path2D.prototype.rect = function rect (x, y, width, height) {
+	    this.moveTo(x, y);
+	    this.lineTo(x + width, y);
+	    this.lineTo(x + width, y + height);
+	    this.lineTo(x, y + height);
+	    this.lineTo(x, y);
+	};
+
+	/**
+	 * adds an rounded rectangle to the current path.
+	 * @name roundRect
+	 * @memberof Path2D.prototype
+	 * @function
+	 * @param {number} x the x-axis coordinate of the rectangle's starting point.
+	 * @param {number} y the y-axis coordinate of the rectangle's starting point.
+	 * @param {number} width the rectangle's width. Positive values are to the right, and negative to the left.
+	 * @param {number} height the rectangle's height. Positive values are down, and negative are up.
+	 * @param {number} radius the arc's radius to draw the borders. Must be positive.
+	 */
+	 Path2D.prototype.roundRect = function roundRect (x, y, width, height, radius) {
+	    this.moveTo(x + radius, y);
+	    this.lineTo(x + width - radius, y);
+	    this.arcTo(x + width, y, x + width, y + radius, radius);
+	    this.lineTo(x + width, y + height - radius);
+	    this.arcTo(x + width, y + height, x + width - radius, y + height, radius);
+	    this.lineTo(x + radius, y + height);
+	    this.arcTo(x, y + height, x, y + height - radius, radius);
+	    this.lineTo(x, y + radius);
+	    this.arcTo(x, y, x + radius, y, radius);
+	};
+
 	/**
 	 * @classdesc
 	 * a base renderer object
@@ -22534,12 +22937,20 @@
 	    /**
 	     * true if the current rendering context is valid
 	     * @name isContextValid
-	     * @memberof Renderer
+	     * @memberof Renderer#
 	     * @default true
 	     * type {boolean}
 	     */
 	    this.isContextValid = true;
 
+	    /**
+	     * The Path2D instance used by the renderer to draw primitives
+	     * @name path2D
+	     * @type {Path2D}
+	     * @memberof Renderer#
+	     */
+	    this.path2D = new Path2D();
+
 	    /**
 	     * @ignore
 	     */
@@ -22822,11 +23233,13 @@
 	 * @name stroke
 	 * @memberof Renderer.prototype
 	 * @function
-	 * @param {Rect|Polygon|Line|Ellipse} shape a shape object to stroke
+	 * @param {Rect|RoundRect|Polygon|Line|Ellipse} shape a shape object to stroke
 	 * @param {boolean} [fill=false] fill the shape with the current color if true
 	 */
 	Renderer.prototype.stroke = function stroke (shape, fill) {
-	    if (shape instanceof Rect || shape instanceof Bounds$1) {
+	    if (shape instanceof RoundRect) {
+	        this.strokeRoundRect(shape.left, shape.top, shape.width, shape.height, shape.radius, fill);
+	    } else if (shape instanceof Rect || shape instanceof Bounds$1) {
 	        this.strokeRect(shape.left, shape.top, shape.width, shape.height, fill);
 	    } else if (shape instanceof Line || shape instanceof Polygon) {
 	        this.strokePolygon(shape, fill);
@@ -22841,6 +23254,17 @@
 	    }
 	};
 
+	/**
+	 * fill the given shape
+	 * @name fill
+	 * @memberof Renderer.prototype
+	 * @function
+	 * @param {Rect|Polygon|Line|Ellipse} shape a shape object to fill
+	 */
+	Renderer.prototype.fill = function fill (shape) {
+	    this.stroke(shape, true);
+	};
+
 	/**
 	 * tint the given image or canvas using the given color
 	 * @name tint
@@ -22870,17 +23294,6 @@
 	    return canvas;
 	};
 
-	/**
-	 * fill the given shape
-	 * @name fill
-	 * @memberof Renderer.prototype
-	 * @function
-	 * @param {Rect|Polygon|Line|Ellipse} shape a shape object to fill
-	 */
-	Renderer.prototype.fill = function fill (shape) {
-	    this.stroke(shape, true);
-	};
-
 	/**
 	 * A mask limits rendering elements to the shape and position of the given mask object.
 	 * So, if the renderable is larger than the mask, only the intersecting part of the renderable will be visible.
@@ -23115,7 +23528,7 @@
 	     * @param {number} height The rectangle's height.
 	     */
 	    CanvasRenderer.prototype.clearRect = function clearRect (x, y, width, height) {
-	        this.backBufferContext2D.clearRect(x, y, width, height);
+	        this.getContext().clearRect(x, y, width, height);
 	    };
 
 	    /**
@@ -23134,7 +23547,7 @@
 	     * var basic      = renderer.createPattern(image, "no-repeat");
 	     */
 	    CanvasRenderer.prototype.createPattern = function createPattern (image, repeat) {
-	        return this.backBufferContext2D.createPattern(image, repeat);
+	        return this.getContext().createPattern(image, repeat);
 	    };
 
 	    /**
@@ -23160,10 +23573,11 @@
 	     * renderer.drawImage(image, sx, sy, sWidth, sHeight, dx, dy, dWidth, dHeight);
 	     */
 	    CanvasRenderer.prototype.drawImage = function drawImage (image, sx, sy, sw, sh, dx, dy, dw, dh) {
-	        if (this.backBufferContext2D.globalAlpha < 1 / 255) {
+	        if (this.getGlobalAlpha() < 1 / 255) {
 	            // Fast path: don't draw fully transparent
 	            return;
 	        }
+	        var context = this.getContext();
 
 	        if (typeof sw === "undefined") {
 	            sw = dw = image.width;
@@ -23197,7 +23611,7 @@
 	            // get a tinted version of this image from the texture cache
 	            source = this.cache.tint(image, this.currentTint.toRGB());
 	        }
-	        this.backBufferContext2D.drawImage(source, sx, sy, sw, sh, dx, dy, dw, dh);
+	        context.drawImage(source, sx, sy, sw, sh, dx, dy, dw, dh);
 	    };
 
 	    /**
@@ -23213,14 +23627,15 @@
 	     * @see CanvasRenderer#createPattern
 	     */
 	    CanvasRenderer.prototype.drawPattern = function drawPattern (pattern, x, y, width, height) {
-	        if (this.backBufferContext2D.globalAlpha < 1 / 255) {
+	        if (this.getGlobalAlpha() < 1 / 255) {
 	            // Fast path: don't draw fully transparent
 	            return;
 	        }
-	        var fillStyle = this.backBufferContext2D.fillStyle;
-	        this.backBufferContext2D.fillStyle = pattern;
-	        this.backBufferContext2D.fillRect(x, y, width, height);
-	        this.backBufferContext2D.fillStyle = fillStyle;
+	        var context = this.getContext();
+	        var fillStyle = context.fillStyle;
+	        context.fillStyle = pattern;
+	        context.fillRect(x, y, width, height);
+	        context.fillStyle = fillStyle;
 	    };
 
 	    /**
@@ -23239,12 +23654,12 @@
 	    CanvasRenderer.prototype.strokeArc = function strokeArc (x, y, radius, start, end, antiClockwise, fill) {
 	        if ( fill === void 0 ) fill = false;
 
-	        var context = this.backBufferContext2D;
-
-	        if (context.globalAlpha < 1 / 255) {
+	        if (this.getGlobalAlpha() < 1 / 255) {
 	            // Fast path: don't draw fully transparent
 	            return;
 	        }
+	        var context = this.getContext();
+
 	        context.translate(x, y);
 	        context.beginPath();
 	        context.arc(0, 0, radius, start, end, antiClockwise || false);
@@ -23282,12 +23697,11 @@
 	    CanvasRenderer.prototype.strokeEllipse = function strokeEllipse (x, y, w, h, fill) {
 	        if ( fill === void 0 ) fill = false;
 
-	        var context = this.backBufferContext2D;
-
-	        if (context.globalAlpha < 1 / 255) {
+	        if (this.getGlobalAlpha() < 1 / 255) {
 	            // Fast path: don't draw fully transparent
 	            return;
 	        }
+	        var context = this.getContext();
 
 	        var hw = w,
 	            hh = h,
@@ -23338,9 +23752,7 @@
 	     * @param {number} endY the end y coordinate
 	     */
 	    CanvasRenderer.prototype.strokeLine = function strokeLine (startX, startY, endX, endY) {
-	        var context = this.backBufferContext2D;
-
-	        if (context < 1 / 255) {
+	        if (this.getGlobalAlpha() < 1 / 255) {
 	            // Fast path: don't draw fully transparent
 	            return;
 	        }
@@ -23376,12 +23788,11 @@
 	    CanvasRenderer.prototype.strokePolygon = function strokePolygon (poly, fill) {
 	        if ( fill === void 0 ) fill = false;
 
-	        var context = this.backBufferContext2D;
-
-	        if (context.globalAlpha < 1 / 255) {
+	        if (this.getGlobalAlpha() < 1 / 255) {
 	            // Fast path: don't draw fully transparent
 	            return;
 	        }
+	        var context = this.getContext();
 
 	        this.translate(poly.pos.x, poly.pos.y);
 	        context.beginPath();
@@ -23422,15 +23833,13 @@
 	    CanvasRenderer.prototype.strokeRect = function strokeRect (x, y, width, height, fill) {
 	        if ( fill === void 0 ) fill = false;
 
-	        if (fill === true ) {
-	            this.fillRect(x, y, width, height);
-	        } else {
-	            if (this.backBufferContext2D.globalAlpha < 1 / 255) {
-	                // Fast path: don't draw fully transparent
-	                return;
-	            }
-	            this.backBufferContext2D.strokeRect(x, y, width, height);
+	        if (this.getGlobalAlpha() < 1 / 255) {
+	            // Fast path: don't draw fully transparent
+	            return;
 	        }
+	        var context = this.getContext();
+
+	        context[fill === true ? "fillRect" : "strokeRect"](x, y, width, height);
 	    };
 
 	    /**
@@ -23444,11 +23853,61 @@
 	     * @param {number} height
 	     */
 	    CanvasRenderer.prototype.fillRect = function fillRect (x, y, width, height) {
-	        if (this.backBufferContext2D.globalAlpha < 1 / 255) {
+	        this.strokeRect(x, y, width, height, true);
+	    };
+
+	    /**
+	     * Stroke a rounded rectangle at the specified coordinates
+	     * @name strokeRoundRect
+	     * @memberof CanvasRenderer.prototype
+	     * @function
+	     * @param {number} x
+	     * @param {number} y
+	     * @param {number} width
+	     * @param {number} height
+	     * @param {number} radius
+	     * @param {boolean} [fill=false] also fill the shape with the current color if true
+	     */
+	    CanvasRenderer.prototype.strokeRoundRect = function strokeRoundRect (x, y, width, height, radius, fill) {
+	        if ( fill === void 0 ) fill = false;
+
+	        if (this.getGlobalAlpha() < 1 / 255) {
 	            // Fast path: don't draw fully transparent
 	            return;
 	        }
-	        this.backBufferContext2D.fillRect(x, y, width, height);
+	        var context = this.getContext();
+
+	        context.beginPath();
+	        if (typeof context.roundRect === "function") {
+	            //https://developer.chrome.com/blog/canvas2d/#round-rect
+	            context.roundRect(x, y, width, height, radius);
+	        } else {
+	            context.moveTo(x + radius, y);
+	            context.lineTo(x + width - radius, y);
+	            context.arcTo(x + width, y, x + width, y + radius, radius);
+	            context.lineTo(x + width, y + height - radius);
+	            context.arcTo(x + width, y + height, x + width - radius, y + height, radius);
+	            context.lineTo(x + radius, y + height);
+	            context.arcTo(x, y + height, x, y + height - radius, radius);
+	            context.lineTo(x, y + radius);
+	            context.arcTo(x, y, x + radius, y, radius);
+	        }
+	        context[fill === true ? "fill" : "stroke"]();
+	    };
+
+	    /**
+	     * Draw a rounded filled rectangle at the specified coordinates
+	     * @name fillRoundRect
+	     * @memberof CanvasRenderer.prototype
+	     * @function
+	     * @param {number} x
+	     * @param {number} y
+	     * @param {number} width
+	     * @param {number} height
+	     * @param {number} radius
+	     */
+	    CanvasRenderer.prototype.fillRoundRect = function fillRoundRect (x, y, width, height, radius) {
+	        this.strokeRoundRect(x, y, width, height, radius, true);
 	    };
 
 
@@ -23490,7 +23949,7 @@
 	     */
 	    CanvasRenderer.prototype.restore = function restore () {
 	        this.backBufferContext2D.restore();
-	        this.currentColor.glArray[3] = this.backBufferContext2D.globalAlpha;
+	        this.currentColor.glArray[3] = this.getGlobalAlpha();
 	        this.currentScissor[0] = 0;
 	        this.currentScissor[1] = 0;
 	        this.currentScissor[2] = this.backBufferCanvas.width;
@@ -23538,7 +23997,7 @@
 	    };
 
 	    /**
-	     * Set the global alpha on the canvas context
+	     * Set the global alpha
 	     * @name setGlobalAlpha
 	     * @memberof CanvasRenderer.prototype
 	     * @function
@@ -23548,6 +24007,17 @@
 	        this.backBufferContext2D.globalAlpha = this.currentColor.glArray[3] = alpha;
 	    };
 
+	    /**
+	     * Return the global alpha
+	     * @name getGlobalAlpha
+	     * @memberof CanvasRenderer.prototype
+	     * @function
+	     * @returns {number} global alpha value
+	     */
+	    CanvasRenderer.prototype.getGlobalAlpha = function getGlobalAlpha () {
+	        return this.backBufferContext2D.globalAlpha;
+	    };
+
 	    /**
 	     * Set the line width on the context
 	     * @name setLineWidth
@@ -23657,7 +24127,7 @@
 	     * @param {Rect|Polygon|Line|Ellipse} [mask] the shape defining the mask to be applied
 	     */
 	    CanvasRenderer.prototype.setMask = function setMask (mask) {
-	        var context = this.backBufferContext2D;
+	        var context = this.getContext();
 	        var _x = mask.pos.x, _y = mask.pos.y;
 
 	        context.save();
@@ -24000,9 +24470,9 @@
 	        var tile = null;
 
 	        if (this.contains(x, y)) {
-	            var coord = this.getRenderer().pixelToTileCoords(x, y, pull("Vector2d"));
+	            var coord = this.getRenderer().pixelToTileCoords(x, y, pool$1.pull("Vector2d"));
 	            tile = this.cellAt(coord.x, coord.y);
-	            push(coord);
+	            pool$1.push(coord);
 	        }
 	        return tile;
 	    };
@@ -24142,6 +24612,8 @@
 	 * a bound object contains methods for creating and manipulating axis-aligned bounding boxes (AABB).
 	 */
 	var Bounds = function Bounds(vertices) {
+	    // @ignore
+	    this._center = new Vector2d();
 	    this.onResetEvent(vertices);
 	};
 
@@ -24160,9 +24632,6 @@
 	    if (typeof vertices !== "undefined") {
 	        this.update(vertices);
 	    }
-
-	    // @ignore
-	    this._center = new Vector2d();
 	};
 
 	/**
@@ -24588,11 +25057,11 @@
 	 * @returns {Polygon} a new Polygon that represents this bounds.
 	 */
 	Bounds.prototype.toPolygon = function toPolygon () {
-	    return new Polygon(this.x, this.y, [
-	        new Vector2d(0,      0),
-	        new Vector2d(this.width, 0),
-	        new Vector2d(this.width, this.height),
-	        new Vector2d(0,      this.height)
+	    return pool$1.pull("Polygon", this.x, this.y, [
+	        pool$1.pull("Vector2d", 0,      0),
+	        pool$1.pull("Vector2d", this.width, 0),
+	        pool$1.pull("Vector2d", this.width, this.height),
+	        pool$1.pull("Vector2d", 0,      this.height)
 	    ]);
 	};
 
@@ -24642,7 +25111,7 @@
 	 * @returns {Bounds}
 	 */
 	TMXRenderer.prototype.getBounds = function getBounds (layer) {
-	    var bounds = layer instanceof TMXLayer ? pull("Bounds") : this.bounds;
+	    var bounds = layer instanceof TMXLayer ? pool$1.pull("Bounds") : this.bounds;
 	    bounds.setMinMax(
 	        0, 0,
 	        this.cols * this.tilewidth,
@@ -24800,13 +25269,13 @@
 	        var start = this.pixelToTileCoords(
 	            Math.max(rect.pos.x - (layer.maxTileSize.width - layer.tilewidth), 0),
 	            Math.max(rect.pos.y - (layer.maxTileSize.height - layer.tileheight), 0),
-	            pull("Vector2d")
+	            pool$1.pull("Vector2d")
 	        ).floorSelf();
 
 	        var end = this.pixelToTileCoords(
 	            rect.pos.x + rect.width + this.tilewidth,
 	            rect.pos.y + rect.height + this.tileheight,
-	            pull("Vector2d")
+	            pool$1.pull("Vector2d")
 	        ).ceilSelf();
 
 	        //ensure we are in the valid tile range
@@ -24844,8 +25313,8 @@
 	            }
 	        }
 
-	        push(start);
-	        push(end);
+	        pool$1.push(start);
+	        pool$1.push(end);
 	    };
 
 	    return TMXOrthogonalRenderer;
@@ -24894,7 +25363,7 @@
 	     * @returns {Bounds}
 	     */
 	    TMXIsometricRenderer.prototype.getBounds = function getBounds (layer) {
-	        var bounds = layer instanceof TMXLayer ? pull("Bounds") : this.bounds;
+	        var bounds = layer instanceof TMXLayer ? pool$1.pull("Bounds") : this.bounds;
 	        bounds.setMinMax(
 	            0, 0,
 	            (this.cols + this.rows) * (this.tilewidth / 2),
@@ -24935,14 +25404,14 @@
 	    TMXIsometricRenderer.prototype.adjustPosition = function adjustPosition (obj) {
 	        var tileX = obj.x / this.hTilewidth;
 	        var tileY = obj.y / this.tileheight;
-	        var isoPos = pull("Vector2d");
+	        var isoPos = pool$1.pull("Vector2d");
 
 	        this.tileToPixelCoords(tileX, tileY, isoPos);
 
 	        obj.x = isoPos.x;
 	        obj.y = isoPos.y;
 
-	        push(isoPos);
+	        pool$1.push(isoPos);
 	    };
 
 	    /**
@@ -24972,18 +25441,18 @@
 	        var rowItr = this.pixelToTileCoords(
 	            rect.pos.x - tileset.tilewidth,
 	            rect.pos.y - tileset.tileheight,
-	            pull("Vector2d")
+	            pool$1.pull("Vector2d")
 	        ).floorSelf();
 	        var tileEnd = this.pixelToTileCoords(
 	            rect.pos.x + rect.width + tileset.tilewidth,
 	            rect.pos.y + rect.height + tileset.tileheight,
-	            pull("Vector2d")
+	            pool$1.pull("Vector2d")
 	        ).ceilSelf();
 
-	        var rectEnd = this.tileToPixelCoords(tileEnd.x, tileEnd.y, pull("Vector2d"));
+	        var rectEnd = this.tileToPixelCoords(tileEnd.x, tileEnd.y, pool$1.pull("Vector2d"));
 
 	        // Determine the tile and pixel coordinates to start at
-	        var startPos = this.tileToPixelCoords(rowItr.x, rowItr.y, pull("Vector2d"));
+	        var startPos = this.tileToPixelCoords(rowItr.x, rowItr.y, pool$1.pull("Vector2d"));
 	        startPos.x -= this.hTilewidth;
 	        startPos.y += this.tileheight;
 
@@ -25050,11 +25519,11 @@
 	            }
 	        }
 
-	        push(columnItr);
-	        push(rowItr);
-	        push(tileEnd);
-	        push(rectEnd);
-	        push(startPos);
+	        pool$1.push(columnItr);
+	        pool$1.push(rowItr);
+	        pool$1.push(tileEnd);
+	        pool$1.push(rectEnd);
+	        pool$1.push(startPos);
 	    };
 
 	    return TMXIsometricRenderer;
@@ -25142,7 +25611,7 @@
 	     * @returns {Bounds}
 	     */
 	    TMXHexagonalRenderer.prototype.getBounds = function getBounds (layer) {
-	        var bounds = layer instanceof TMXLayer ? pull("Bounds") : this.bounds;
+	        var bounds = layer instanceof TMXLayer ? pool$1.pull("Bounds") : this.bounds;
 
 	        // The map size is the same regardless of which indexes are shifted.
 	        if (this.staggerX) {
@@ -25293,13 +25762,13 @@
 	        }
 
 	        // Start with the coordinates of a grid-aligned tile
-	        var referencePoint = pull("Vector2d",
+	        var referencePoint = pool$1.pull("Vector2d",
 	            Math.floor(x / (this.columnwidth * 2)),
 	            Math.floor((y / (this.rowheight * 2)))
 	        );
 
 	        // Relative x and y position on the base square of the grid-aligned tile
-	        var rel = pull("Vector2d",
+	        var rel = pool$1.pull("Vector2d",
 	            x - referencePoint.x * (this.columnwidth * 2),
 	            y - referencePoint.y * (this.rowheight * 2)
 	        );
@@ -25358,8 +25827,8 @@
 	            referencePoint.y + offsets[nearest].y
 	        );
 
-	        push(referencePoint);
-	        push(rel);
+	        pool$1.push(referencePoint);
+	        pool$1.push(rel);
 
 	        return ret;
 	    };
@@ -25410,7 +25879,7 @@
 	     */
 	    TMXHexagonalRenderer.prototype.drawTile = function drawTile (renderer, x, y, tmxTile) {
 	        var tileset = tmxTile.tileset;
-	        var point = this.tileToPixelCoords(x, y, pull("Vector2d"));
+	        var point = this.tileToPixelCoords(x, y, pool$1.pull("Vector2d"));
 
 	        // draw the tile
 	        tileset.drawTile(
@@ -25420,7 +25889,7 @@
 	            tmxTile
 	        );
 
-	        push(point);
+	        pool$1.push(point);
 	    };
 
 	    /**
@@ -25434,7 +25903,7 @@
 	        var startTile = this.pixelToTileCoords(
 	            rect.pos.x,
 	            rect.pos.y,
-	            pull("Vector2d")
+	            pool$1.pull("Vector2d")
 	        );
 
 	        // Compensate for the layer position
@@ -25444,7 +25913,7 @@
 	        var startPos = this.tileToPixelCoords(
 	            startTile.x + layer.pos.x,
 	            startTile.y + layer.pos.y,
-	            pull("Vector2d")
+	            pool$1.pull("Vector2d")
 	        );
 
 	        var rowTile = startTile.clone();
@@ -25507,8 +25976,8 @@
 
 	                startPos.y += this.rowheight;
 	            }
-	            push(rowTile);
-	            push(rowPos);
+	            pool$1.push(rowTile);
+	            pool$1.push(rowPos);
 
 	        } else {
 	            //ensure we are in the valid tile range
@@ -25544,12 +26013,12 @@
 	                }
 	                startPos.y += this.rowheight;
 	            }
-	            push(rowTile);
-	            push(rowPos);
+	            pool$1.push(rowTile);
+	            pool$1.push(rowPos);
 	        }
 
-	        push(startTile);
-	        push(startPos);
+	        pool$1.push(startTile);
+	        pool$1.push(startPos);
 	    };
 
 	    return TMXHexagonalRenderer;
@@ -25593,7 +26062,7 @@
 	        }
 
 	        // Start with the coordinates of a grid-aligned tile
-	        var referencePoint = pull("Vector2d",
+	        var referencePoint = pool$1.pull("Vector2d",
 	            Math.floor(alignedX / this.tilewidth),
 	            Math.floor(alignedY / this.tileheight)
 	        );
@@ -25612,7 +26081,7 @@
 	        }
 
 	        // Relative x and y position on the base square of the grid-aligned tile
-	        var rel = pull("Vector2d",
+	        var rel = pool$1.pull("Vector2d",
 	            alignedX - referencePoint.x * this.tilewidth,
 	            alignedY - referencePoint.y * this.tileheight
 	        );
@@ -25645,8 +26114,8 @@
 
 	        ret.div(this.tilewidth / Math.sqrt(2)).rotate(degToRad(-45)).add(referencePoint);
 
-	        push(referencePoint);
-	        push(rel);
+	        pool$1.push(referencePoint);
+	        pool$1.push(rel);
 
 	        return ret;
 	    };
@@ -26266,7 +26735,7 @@
 	    // add an ellipse shape
 	    if (this.isEllipse === true) {
 	        // ellipse coordinates are the center position, so set default to the corresonding radius
-	        shapes.push((new Ellipse(
+	        shapes.push((pool$1.pull("Ellipse",
 	            this.width / 2,
 	            this.height / 2,
 	            this.width,
@@ -26276,7 +26745,7 @@
 
 	        // add a polygon
 	        if (this.isPolygon === true) {
-	            var _polygon = new Polygon(0, 0, this.points);
+	            var _polygon = pool$1.pull("Polygon", 0, 0, this.points);
 	            // make sure it's a convex polygon
 	            if (_polygon.isConvex() === false ) {
 	                throw new Error("collision polygones in Tiled should be defined as Convex");
@@ -26292,22 +26761,22 @@
 	            for (i = 0; i < segments; i++) {
 	                // clone the value before, as [i + 1]
 	                // is reused later by the next segment
-	                p1 = new Vector2d(p[i].x, p[i].y);
-	                p2 = new Vector2d(p[i + 1].x, p[i + 1].y);
+	                p1 = pool$1.pull("Vector2d", p[i].x, p[i].y);
+	                p2 = pool$1.pull("Vector2d", p[i + 1].x, p[i + 1].y);
 	                if (this.rotation !== 0) {
 	                    p1 = p1.rotate(this.rotation);
 	                    p2 = p2.rotate(this.rotation);
 	                }
-	                shapes.push(new Line(0, 0, [ p1, p2 ]));
+	                shapes.push(pool$1.pull("Line", 0, 0, [ p1, p2 ]));
 	            }
 	        }
 
 	        // it's a rectangle, returns a polygon object anyway
 	        else {
-	            shapes.push((new Polygon(
+	            shapes.push((pool$1.pull("Polygon",
 	                0, 0, [
-	                    new Vector2d(), new Vector2d(this.width, 0),
-	                    new Vector2d(this.width, this.height), new Vector2d(0, this.height)
+	                    pool$1.pull("Vector2d"),  pool$1.pull("Vector2d", this.width, 0),
+	                    pool$1.pull("Vector2d", this.width, this.height), pool$1.pull("Vector2d", 0, this.height)
 	                ]
 	            )).rotate(this.rotation));
 	        }
@@ -26499,16 +26968,16 @@
 	    applyTMXProperties(data.properties, data);
 
 	    // create the layer
-	    var imageLayer = pull("ImageLayer",
+	    var imageLayer = pool$1.pull("ImageLayer",
 	        // x/y is deprecated since 0.15 and replace by offsetx/y
 	        +data.offsetx || +data.x || 0,
 	        +data.offsety || +data.y || 0,
 	        Object.assign({
 	            name: data.name,
 	            image: data.image,
-	            ratio : pull("Vector2d", +data.parallaxx || 1.0, +data.parallaxy || 1.0),
+	            ratio : pool$1.pull("Vector2d", +data.parallaxx || 1.0, +data.parallaxy || 1.0),
 	            // convert to melonJS color format (note: this should be done earlier when parsing data)
-	            tint : typeof (data.tintcolor) !== "undefined" ? (pull("Color")).parseHex(data.tintcolor, true) : undefined,
+	            tint : typeof (data.tintcolor) !== "undefined" ? (pool$1.pull("Color")).parseHex(data.tintcolor, true) : undefined,
 	            z: z
 	        }, data.properties)
 	    );
@@ -26740,7 +27209,7 @@
 	    if (this.background_image) {
 	        // add a new image layer
 	        this.layers.push(
-	            pull("ImageLayer",
+	            pool$1.pull("ImageLayer",
 	                0, 0, {
 	                    name : "background_image",
 	                    image : this.background_image,
@@ -26900,6 +27369,8 @@
 	            var settings = group.objects[o];
 	            // reference to the instantiated object
 	            var obj;
+	            // a reference to the default shape
+	            var shape;
 
 	            // Tiled uses 0,0 by default
 	            if (typeof (settings.anchorPoint) === "undefined") {
@@ -26907,7 +27378,7 @@
 	            }
 	            // convert to melonJS renderable argument name
 	            if (typeof (settings.tintcolor) !== "undefined") {
-	                settings.tint = pull("Color");
+	                settings.tint = pool$1.pull("Color");
 	                settings.tint.parseHex(settings.tintcolor, true);
 	            }
 
@@ -26925,39 +27396,57 @@
 	                    settings.text.anchorPoint = settings.anchorPoint;
 	                }
 	                if (settings.text.bitmap === true) {
-	                    obj = pull("BitmapText", settings.x, settings.y, settings.text);
+	                    obj = pool$1.pull("BitmapText", settings.x, settings.y, settings.text);
 	                } else {
-	                    obj = pull("Text", settings.x, settings.y, settings.text);
+	                    obj = pool$1.pull("Text", settings.x, settings.y, settings.text);
 	                }
 	                // set the obj z order
 	                obj.pos.z = settings.z;
 	            } else if (typeof settings.tile === "object") {
+	                // create a default shape if none is specified
+	                shape = settings.shapes;
+	                if (typeof shape === "undefined") {
+	                    shape = pool$1.pull("Polygon", 0, 0, [
+	                        pool$1.pull("Vector2d", 0,      0),
+	                        pool$1.pull("Vector2d", this.width, 0),
+	                        pool$1.pull("Vector2d", this.width, this.height)
+	                    ]);
+	                }
 	                // check if a me.Tile object is embedded
 	                obj = settings.tile.getRenderable(settings);
-	                obj.body = new Body(obj, settings.shapes || new Rect(0, 0, this.width, this.height));
+	                obj.body = new Body(obj, shape);
 	                obj.body.setStatic(true);
 	                // set the obj z order
 	                obj.pos.setMuted(settings.x, settings.y, settings.z);
 	            } else {
 	                // pull the corresponding object from the object pool
 	                if (typeof settings.name !== "undefined" && settings.name !== "") {
-	                    obj = pull(
+	                    obj = pool$1.pull(
 	                        settings.name,
 	                        settings.x, settings.y,
 	                        settings
 	                    );
 	                } else {
 	                    // unnamed shape object
-	                    obj = pull(
+	                    obj = pool$1.pull(
 	                        "Renderable",
 	                        settings.x, settings.y,
 	                        settings.width, settings.height
 	                    );
+	                    // create a default shape if none is specified
+	                    shape = settings.shapes;
+	                    if (typeof shape === "undefined") {
+	                        shape = pool$1.pull("Polygon", 0, 0, [
+	                            pool$1.pull("Vector2d", 0,      0),
+	                            pool$1.pull("Vector2d", this.width, 0),
+	                            pool$1.pull("Vector2d", this.width, this.height)
+	                        ]);
+	                    }
 	                    obj.anchorPoint.set(0, 0);
 	                    obj.name = settings.name;
 	                    obj.type = settings.type;
 	                    obj.id = settings.id;
-	                    obj.body = new Body(obj, settings.shapes || new Rect(0, 0, obj.width, obj.height));
+	                    obj.body = new Body(obj, shape);
 	                    obj.body.setStatic(true);
 	                    obj.resize(obj.body.getBounds().width, obj.body.getBounds().height);
 	                }
@@ -27356,7 +27845,7 @@
 	        }
 	    }
 	    else {
-	        timerId$1 = setTimeout(function() {
+	        timerId$1 = setTimeout(function () {
 	            checkLoadStatus(onload);
 	        }, 100);
 	    }
@@ -27393,7 +27882,7 @@
 	function preloadFontFace(data, onload, onerror) {
 	    var font = new FontFace(data.name, data.src);
 	    // loading promise
-	    font.load().then(function() {
+	    font.load().then(function () {
 	        // apply the font after the font has finished downloading
 	        document.fonts.add(font);
 	        document.body.style.fontFamily = data.name;
@@ -27582,12 +28071,12 @@
 	    }
 	    script.defer = true;
 
-	    script.onload = function() {
+	    script.onload = function () {
 	        // callback
 	        onload();
 	    };
 
-	    script.onerror = function() {
+	    script.onerror = function () {
 	        // callback
 	        onerror(data.name);
 	    };
@@ -28845,12 +29334,6 @@
 	    // detect device type/platform
 	    _detectDevice();
 
-	    // Mobile browser hacks
-	    if (device.isMobile) {
-	        // Prevent the webview from moving on a swipe
-	        device.enableSwipe(false);
-	    }
-
 	    // Touch/Gesture Event feature detection
 	    device.TouchEvent = !!("ontouchstart" in globalThis);
 	    device.PointerEvent = !!globalThis.PointerEvent;
@@ -28972,6 +29455,13 @@
 	            );
 	        }
 	    }
+
+	    // Mobile browser hacks
+	    if (device.isMobile) {
+	        // Prevent the webview from moving on a swipe
+	        device.enableSwipe(false);
+	    }
+
 	}
 
 	// Initialize me.timer on Boot event
@@ -29408,13 +29898,14 @@
 	     * @param {boolean} [enable=true] enable or disable swipe.
 	     */
 	    enableSwipe: function enableSwipe(enable) {
+	        var moveEvent = device.PointerEvent ? "pointermove" : (device.TouchEvent ? "touchmove" : "mousemove");
 	        if (enable !== false) {
 	            if (swipeEnabled === false) {
-	                globalThis.document.removeEventListener("touchmove", _disableSwipeFn, false);
+	                globalThis.document.removeEventListener(moveEvent, _disableSwipeFn);
 	                swipeEnabled = true;
 	            }
 	        } else if (swipeEnabled === true) {
-	            globalThis.document.addEventListener("touchmove", _disableSwipeFn, false);
+	            globalThis.document.addEventListener(moveEvent, _disableSwipeFn, { passive: false });
 	            swipeEnabled = false;
 	        }
 	    },
@@ -29904,6 +30395,29 @@
 
 	var device$1 = device;
 
+	/**
+	 * Hash map of GLSL data types to WebGL Uniform methods
+	 * @ignore
+	 */
+	var fnHash = {
+	    "bool"      : "1i",
+	    "int"       : "1i",
+	    "float"     : "1f",
+	    "vec2"      : "2fv",
+	    "vec3"      : "3fv",
+	    "vec4"      : "4fv",
+	    "bvec2"     : "2iv",
+	    "bvec3"     : "3iv",
+	    "bvec4"     : "4iv",
+	    "ivec2"     : "2iv",
+	    "ivec3"     : "3iv",
+	    "ivec4"     : "4iv",
+	    "mat2"      : "Matrix2fv",
+	    "mat3"      : "Matrix3fv",
+	    "mat4"      : "Matrix4fv",
+	    "sampler2D" : "1i"
+	};
+
 	/**
 	 * @ignore
 	 */
@@ -29967,6 +30481,7 @@
 
 	    return uniforms;
 	}
+
 	/**
 	 * @ignore
 	 */
@@ -29983,6 +30498,7 @@
 
 	    return attributes;
 	}
+
 	/**
 	 * @ignore
 	 */
@@ -30041,29 +30557,6 @@
 	    return program;
 	}
 
-	/**
-	 * Hash map of GLSL data types to WebGL Uniform methods
-	 * @ignore
-	 */
-	var fnHash = {
-	    "bool"      : "1i",
-	    "int"       : "1i",
-	    "float"     : "1f",
-	    "vec2"      : "2fv",
-	    "vec3"      : "3fv",
-	    "vec4"      : "4fv",
-	    "bvec2"     : "2iv",
-	    "bvec3"     : "3iv",
-	    "bvec4"     : "4iv",
-	    "ivec2"     : "2iv",
-	    "ivec3"     : "3iv",
-	    "ivec4"     : "4iv",
-	    "mat2"      : "Matrix2fv",
-	    "mat3"      : "Matrix3fv",
-	    "mat4"      : "Matrix4fv",
-	    "sampler2D" : "1i"
-	};
-
 	/**
 	 * set precision for the fiven shader source
 	 * won't do anything if the precision is already specified
@@ -30075,6 +30568,7 @@
 	    }
 	    return src;
 	}
+
 	/**
 	 * clean the given source from space, comments, etc...
 	 * @ignore
@@ -30091,6 +30585,7 @@
 
 	    return src;
 	}
+
 	/**
 	 * @classdesc
 	 * a base GL Shader object
@@ -30206,6 +30701,30 @@
 	    }
 	};
 
+	/**
+	 * activate the given vertex attribute for this shader
+	 * @name setVertexAttributes
+	 * @memberof GLShader
+	 * @function
+	 * @param {WebGLRenderingContext} gl the current WebGL rendering context
+	 * @param {object[]} attributes an array of vertex attributes
+	 * @param {number} vertexByteSize the size of a single vertex in bytes
+	 */
+	GLShader.prototype.setVertexAttributes = function setVertexAttributes (gl, attributes, vertexByteSize) {
+	    // set the vertex attributes
+	    for (var index = 0; index < attributes.length; ++index) {
+	        var element = attributes[index];
+	        var location = this.getAttribLocation(element.name);
+
+	        if (location !== -1) {
+	            gl.enableVertexAttribArray(location);
+	            gl.vertexAttribPointer(location, element.size, element.type, element.normalized, vertexByteSize, element.offset);
+	        } else {
+	            gl.disableVertexAttribArray(index);
+	        }
+	    }
+	};
+
 	/**
 	 * destroy this shader objects resources (program, attributes, uniforms)
 	 * @name destroy
@@ -30741,20 +31260,7 @@
 	        this.activeShader = shader;
 	        this.activeShader.bind();
 	        this.activeShader.setUniform("uProjectionMatrix", this.renderer.projectionMatrix);
-
-	        // set the vertex attributes
-	        for (var index = 0; index < this.attributes.length; ++index) {
-	            var gl = this.gl;
-	            var element = this.attributes[index];
-	            var location = this.activeShader.getAttribLocation(element.name);
-
-	            if (location !== -1) {
-	                gl.enableVertexAttribArray(location);
-	                gl.vertexAttribPointer(location, element.size, element.type, element.normalized, this.vertexByteSize, element.offset);
-	            } else {
-	                gl.disableVertexAttribArray(index);
-	            }
-	        }
+	        this.activeShader.setVertexAttributes(this.gl, this.attributes, this.vertexByteSize);
 	    }
 	};
 
@@ -30917,7 +31423,7 @@
 	        /**
 	         * The WebGL version used by this renderer (1 or 2)
 	         * @name WebGLVersion
-	         * @memberof WebGLRenderer
+	         * @memberof WebGLRenderer#
 	         * @type {number}
 	         * @default 1
 	         * @readonly
@@ -30927,7 +31433,7 @@
 	        /**
 	         * The vendor string of the underlying graphics driver.
 	         * @name GPUVendor
-	         * @memberof WebGLRenderer
+	         * @memberof WebGLRenderer#
 	         * @type {string}
 	         * @default null
 	         * @readonly
@@ -30937,7 +31443,7 @@
 	        /**
 	         * The renderer string of the underlying graphics driver.
 	         * @name GPURenderer
-	         * @memberof WebGLRenderer
+	         * @memberof WebGLRenderer#
 	         * @type {string}
 	         * @default null
 	         * @readonly
@@ -30947,7 +31453,7 @@
 	        /**
 	         * The WebGL context
 	         * @name gl
-	         * @memberof WebGLRenderer
+	         * @memberof WebGLRenderer#
 	         * type {WebGLRenderingContext}
 	         */
 	        this.context = this.gl = this.getContextGL(this.getScreenCanvas(), options.transparent);
@@ -30955,7 +31461,7 @@
 	        /**
 	         * Maximum number of texture unit supported under the current context
 	         * @name maxTextures
-	         * @memberof WebGLRenderer
+	         * @memberof WebGLRenderer#
 	         * @type {number}
 	         * @readonly
 	         */
@@ -30981,16 +31487,6 @@
 	         */
 	        this._blendStack = [];
 
-	        /**
-	         * @ignore
-	         */
-	        this._glPoints = [
-	            new Vector2d(),
-	            new Vector2d(),
-	            new Vector2d(),
-	            new Vector2d()
-	        ];
-
 	        /**
 	         * The current transformation matrix used for transformations on the overall scene
 	         * @name currentTransform
@@ -31010,7 +31506,7 @@
 	        /**
 	         * The list of active compositors
 	         * @name compositors
-	         * @type {Map}
+	         * @type {Map<WebGLCompositor>}
 	         * @memberof WebGLRenderer#
 	         */
 	        this.compositors = new Map();
@@ -31235,10 +31731,10 @@
 	        if (color instanceof Color) {
 	            glArray = color.toArray();
 	        } else {
-	            var _color = pull("me.Color");
+	            var _color = pool$1.pull("me.Color");
 	            // reuse temporary the renderer default color object
 	            glArray = _color.parseCSS(color).toArray();
-	            push(_color);
+	            pool$1.push(_color);
 	        }
 	        // clear gl context with the specified color
 	        this.currentCompositor.clearColor(glArray[0], glArray[1], glArray[2], (opaque === true) ? 1.0 : glArray[3]);
@@ -31533,8 +32029,8 @@
 	            this.setBlendMode(this._blendStack.pop());
 
 	            // recycle objects
-	            push(color);
-	            push(matrix);
+	            pool$1.push(color);
+	            pool$1.push(matrix);
 	        }
 
 	        if (this._scissorStack.length !== 0) {
@@ -31611,6 +32107,17 @@
 	        this.currentColor.alpha = alpha;
 	    };
 
+	    /**
+	     * Return the global alpha
+	     * @name getGlobalAlpha
+	     * @memberof WebGLRenderer.prototype
+	     * @function
+	     * @returns {number} global alpha value
+	     */
+	    WebGLRenderer.prototype.getGlobalAlpha = function getGlobalAlpha () {
+	        return this.currentColor.alpha;
+	    };
+
 	    /**
 	     * Set the current fill & stroke style color.
 	     * By default, or upon reset, the value is set to #000000.
@@ -31651,34 +32158,19 @@
 	     */
 	    WebGLRenderer.prototype.strokeArc = function strokeArc (x, y, radius, start, end, antiClockwise, fill) {
 	        if ( antiClockwise === void 0 ) antiClockwise = false;
+	        if ( fill === void 0 ) fill = false;
 
-	        if (fill === true ) {
-	            this.fillArc(x, y, radius, start, end, antiClockwise);
+	        if (this.getGlobalAlpha() < 1 / 255) {
+	            // Fast path: don't draw fully transparent
+	            return;
+	        }
+	        this.path2D.beginPath();
+	        this.path2D.arc(x, y, radius, start, end, antiClockwise);
+	        if (fill === false) {
+	            this.currentCompositor.drawVertices(this.gl.LINE_STRIP, this.path2D.points);
 	        } else {
-	            // XXX to be optimzed using a specific shader
-	            var points = this._glPoints;
-	            var i, len = Math.floor(24 * Math.sqrt(radius * 2));
-	            var theta = (end - start) / (len * 2);
-	            var theta2 = theta * 2;
-	            var cos_theta = Math.cos(theta);
-	            var sin_theta = Math.sin(theta);
-
-	            // Grow internal points buffer if necessary
-	            for (i = points.length; i < len + 1; i++) {
-	                points.push(new Vector2d());
-	            }
-
-	            // calculate and draw all segments
-	            for (i = 0; i < len; i++) {
-	                var angle = ((theta) + start + (theta2 * i));
-	                var cos = Math.cos(angle);
-	                var sin = -Math.sin(angle);
-
-	                points[i].x = x + (((cos_theta * cos) + (sin_theta * sin)) * radius);
-	                points[i].y = y + (((cos_theta * -sin) + (sin_theta * cos)) * radius);
-	            }
-	            // batch draw all lines
-	            this.currentCompositor.drawVertices(this.gl.LINE_STRIP, points, len);
+	            this.path2D.closePath();
+	            this.currentCompositor.drawVertices(this.gl.TRIANGLES, this.path2D.triangulatePath());
 	        }
 	    };
 
@@ -31694,35 +32186,10 @@
 	     * @param {number} end end angle in radians
 	     * @param {boolean} [antiClockwise=false] draw arc anti-clockwise
 	     */
-	    WebGLRenderer.prototype.fillArc = function fillArc (x, y, radius, start, end /*, antiClockwise = false*/) {
-	        // XXX to be optimzed using a specific shader
-	        var points = this._glPoints;
-	        var i, index = 0;
-	        var len = Math.floor(24 * Math.sqrt(radius * 2));
-	        var theta = (end - start) / (len * 2);
-	        var theta2 = theta * 2;
-	        var cos_theta = Math.cos(theta);
-	        var sin_theta = Math.sin(theta);
-
-	        // Grow internal points buffer if necessary
-	        for (i = points.length; i < len * 2; i++) {
-	            points.push(new Vector2d());
-	        }
-
-	        // calculate and draw all segments
-	        for (i = 0; i < len - 1; i++) {
-	            var angle = ((theta) + start + (theta2 * i));
-	            var cos = Math.cos(angle);
-	            var sin = -Math.sin(angle);
-
-	            points[index++].set(x, y);
-	            points[index++].set(
-	                x - (((cos_theta * cos) + (sin_theta * sin)) * radius),
-	                y - (((cos_theta * -sin) + (sin_theta * cos)) * radius)
-	            );
-	        }
-	        // batch draw all triangles
-	        this.currentCompositor.drawVertices(this.gl.TRIANGLE_STRIP, points, index);
+	    WebGLRenderer.prototype.fillArc = function fillArc (x, y, radius, start, end, antiClockwise) {
+	        if ( antiClockwise === void 0 ) antiClockwise = false;
+
+	        this.strokeArc(x, y, radius, start, end, antiClockwise, true);
 	    };
 
 	    /**
@@ -31739,28 +32206,17 @@
 	    WebGLRenderer.prototype.strokeEllipse = function strokeEllipse (x, y, w, h, fill) {
 	        if ( fill === void 0 ) fill = false;
 
-	        if (fill === true ) {
-	            this.fillEllipse(x, y, w, h);
+	        if (this.getGlobalAlpha() < 1 / 255) {
+	            // Fast path: don't draw fully transparent
+	            return;
+	        }
+	        this.path2D.beginPath();
+	        this.path2D.ellipse(x, y, w, h, 0, 0, 360);
+	        this.path2D.closePath();
+	        if (fill === false) {
+	            this.currentCompositor.drawVertices(this.gl.LINE_LOOP, this.path2D.points);
 	        } else {
-	            // XXX to be optimzed using a specific shader
-	            var len = Math.floor(24 * Math.sqrt(w)) ||
-	                      Math.floor(12 * Math.sqrt(w + h));
-	            var segment = (TAU) / len;
-	            var points = this._glPoints,
-	                i;
-
-	            // Grow internal points buffer if necessary
-	            for (i = points.length; i < len; i++) {
-	                points.push(new Vector2d());
-	            }
-
-	            // calculate and draw all segments
-	            for (i = 0; i < len; i++) {
-	                points[i].x = x + (Math.sin(segment * -i) * w);
-	                points[i].y = y + (Math.cos(segment * -i) * h);
-	            }
-	            // batch draw all lines
-	            this.currentCompositor.drawVertices(this.gl.LINE_LOOP, points, len);
+	            this.currentCompositor.drawVertices(this.gl.TRIANGLES, this.path2D.triangulatePath());
 	        }
 	    };
 
@@ -31775,28 +32231,7 @@
 	     * @param {number} h vertical radius of the ellipse
 	     */
 	    WebGLRenderer.prototype.fillEllipse = function fillEllipse (x, y, w, h) {
-	        // XXX to be optimzed using a specific shader
-	        var len = Math.floor(24 * Math.sqrt(w)) ||
-	                  Math.floor(12 * Math.sqrt(w + h));
-	        var segment = (TAU) / len;
-	        var points = this._glPoints;
-	        var index = 0, i;
-
-	        // Grow internal points buffer if necessary
-	        for (i = points.length; i < (len + 1) * 2; i++) {
-	            points.push(new Vector2d());
-	        }
-
-	        // draw all vertices vertex coordinates
-	        for (i = 0; i < len + 1; i++) {
-	            points[index++].set(x, y);
-	            points[index++].set(
-	                x + (Math.sin(segment * i) * w),
-	                y + (Math.cos(segment * i) * h)
-	            );
-	        }
-	        // batch draw all triangles
-	        this.currentCompositor.drawVertices(this.gl.TRIANGLE_STRIP, points, index);
+	        this.strokeEllipse(x, y, w, h, false);
 	    };
 
 	    /**
@@ -31810,12 +32245,14 @@
 	     * @param {number} endY the end y coordinate
 	     */
 	    WebGLRenderer.prototype.strokeLine = function strokeLine (startX, startY, endX, endY) {
-	        var points = this._glPoints;
-	        points[0].x = startX;
-	        points[0].y = startY;
-	        points[1].x = endX;
-	        points[1].y = endY;
-	        this.currentCompositor.drawVertices(this.gl.LINE_STRIP, points, 2);
+	        if (this.getGlobalAlpha() < 1 / 255) {
+	            // Fast path: don't draw fully transparent
+	            return;
+	        }
+	        this.path2D.beginPath();
+	        this.path2D.moveTo(startX, startY);
+	        this.path2D.lineTo(endX, endY);
+	        this.currentCompositor.drawVertices(this.gl.LINE_STRIP, this.path2D.points);
 	    };
 
 
@@ -31844,25 +32281,27 @@
 	    WebGLRenderer.prototype.strokePolygon = function strokePolygon (poly, fill) {
 	        if ( fill === void 0 ) fill = false;
 
-	        if (fill === true ) {
-	            this.fillPolygon(poly);
+	        if (this.getGlobalAlpha() < 1 / 255) {
+	            // Fast path: don't draw fully transparent
+	            return;
+	        }
+	        this.translate(poly.pos.x, poly.pos.y);
+	        this.path2D.beginPath();
+	        this.path2D.moveTo(poly.points[0].x, poly.points[0].y);
+	        var point;
+	        for (var i = 1; i < poly.points.length; i++) {
+	            point = poly.points[i];
+	            this.path2D.lineTo(point.x, point.y);
+	        }
+	        this.path2D.lineTo(poly.points[0].x, poly.points[0].y);
+	        this.path2D.closePath();
+	        if (fill === false) {
+	            this.currentCompositor.drawVertices(this.gl.LINE_LOOP, this.path2D.points);
 	        } else {
-	            var len = poly.points.length,
-	                points = this._glPoints,
-	                i;
-
-	            // Grow internal points buffer if necessary
-	            for (i = points.length; i < len; i++) {
-	                points.push(new Vector2d());
-	            }
-
-	            // calculate and draw all segments
-	            for (i = 0; i < len; i++) {
-	                points[i].x = poly.pos.x + poly.points[i].x;
-	                points[i].y = poly.pos.y + poly.points[i].y;
-	            }
-	            this.currentCompositor.drawVertices(this.gl.LINE_LOOP, points, len);
+	            // draw all triangles
+	            this.currentCompositor.drawVertices(this.gl.TRIANGLES, this.path2D.triangulatePath());
 	        }
+	        this.translate(-poly.pos.x, -poly.pos.y);
 	    };
 
 	    /**
@@ -31873,24 +32312,7 @@
 	     * @param {Polygon} poly the shape to draw
 	     */
 	    WebGLRenderer.prototype.fillPolygon = function fillPolygon (poly) {
-	        var points = poly.points;
-	        var glPoints = this._glPoints;
-	        var indices = poly.getIndices();
-	        var x = poly.pos.x, y = poly.pos.y;
-	        var i;
-
-	        // Grow internal points buffer if necessary
-	        for (i = glPoints.length; i < indices.length; i++) {
-	            glPoints.push(new Vector2d());
-	        }
-
-	        // calculate all vertices
-	        for (i = 0; i < indices.length; i++ ) {
-	            glPoints[i].set(x + points[indices[i]].x, y + points[indices[i]].y);
-	        }
-
-	        // draw all triangle
-	        this.currentCompositor.drawVertices(this.gl.TRIANGLES, glPoints, indices.length);
+	        this.strokePolygon(poly, true);
 	    };
 
 	    /**
@@ -31907,19 +32329,16 @@
 	    WebGLRenderer.prototype.strokeRect = function strokeRect (x, y, width, height, fill) {
 	        if ( fill === void 0 ) fill = false;
 
-	        if (fill === true ) {
-	            this.fillRect(x, y, width, height);
+	        if (this.getGlobalAlpha() < 1 / 255) {
+	            // Fast path: don't draw fully transparent
+	            return;
+	        }
+	        this.path2D.beginPath();
+	        this.path2D.rect(x, y, width, height);
+	        if (fill === false) {
+	            this.currentCompositor.drawVertices(this.gl.LINE_LOOP, this.path2D.points);
 	        } else {
-	            var points = this._glPoints;
-	            points[0].x = x;
-	            points[0].y = y;
-	            points[1].x = x + width;
-	            points[1].y = y;
-	            points[2].x = x + width;
-	            points[2].y = y + height;
-	            points[3].x = x;
-	            points[3].y = y + height;
-	            this.currentCompositor.drawVertices(this.gl.LINE_LOOP, points, 4);
+	            this.currentCompositor.drawVertices(this.gl.TRIANGLES, this.path2D.triangulatePath());
 	        }
 	    };
 
@@ -31934,16 +32353,51 @@
 	     * @param {number} height
 	     */
 	    WebGLRenderer.prototype.fillRect = function fillRect (x, y, width, height) {
-	        var glPoints = this._glPoints;
-	        glPoints[0].x = x + width;
-	        glPoints[0].y = y;
-	        glPoints[1].x = x;
-	        glPoints[1].y = y;
-	        glPoints[2].x = x + width;
-	        glPoints[2].y = y + height;
-	        glPoints[3].x = x;
-	        glPoints[3].y = y + height;
-	        this.currentCompositor.drawVertices(this.gl.TRIANGLE_STRIP, glPoints, 4);
+	        this.strokeRect(x, y, width, height, true);
+	    };
+
+	    /**
+	     * Stroke a rounded rectangle at the specified coordinates
+	     * @name strokeRoundRect
+	     * @memberof WebGLRenderer.prototype
+	     * @function
+	     * @param {number} x
+	     * @param {number} y
+	     * @param {number} width
+	     * @param {number} height
+	     * @param {number} radius
+	     * @param {boolean} [fill=false] also fill the shape with the current color if true
+	     */
+	    WebGLRenderer.prototype.strokeRoundRect = function strokeRoundRect (x, y, width, height, radius, fill) {
+	        if ( fill === void 0 ) fill = false;
+
+	        if (this.getGlobalAlpha() < 1 / 255) {
+	            // Fast path: don't draw fully transparent
+	            return;
+	        }
+	        this.path2D.beginPath();
+	        this.path2D.roundRect(x, y, width, height, radius);
+	        if (fill === false) {
+	            this.currentCompositor.drawVertices(this.gl.LINE_LOOP, this.path2D.points);
+	        } else {
+	            this.path2D.closePath();
+	            this.currentCompositor.drawVertices(this.gl.TRIANGLES, this.path2D.triangulatePath());
+	        }
+	    };
+
+	    /**
+	     * Draw a rounded filled rectangle at the specified coordinates
+	     * @name fillRoundRect
+	     * @memberof WebGLRenderer.prototype
+	     * @function
+	     * @param {number} x
+	     * @param {number} y
+	     * @param {number} width
+	     * @param {number} height
+	     * @param {number} radius
+	     */
+	    WebGLRenderer.prototype.fillRoundRect = function fillRoundRect (x, y, width, height, radius) {
+	        this.strokeRoundRect(x, y, width, height, radius, true);
 	    };
 
 	    /**
@@ -33042,10 +33496,10 @@
 	     * this can be overridden by the plugin
 	     * @public
 	     * @type {string}
-	     * @default "10.7.1"
+	     * @default "10.8.0"
 	     * @name plugin.Base#version
 	     */
-	    this.version = "10.7.1";
+	    this.version = "10.8.0";
 	};
 
 	/**
@@ -34286,10 +34740,10 @@
 	                this.fillStyle = settings.fillStyle;
 	            } else {
 	                // string (#RGB, #ARGB, #RRGGBB, #AARRGGBB)
-	                this.fillStyle = pull("Color").parseCSS(settings.fillStyle);
+	                this.fillStyle = pool$1.pull("Color").parseCSS(settings.fillStyle);
 	            }
 	        } else {
-	            this.fillStyle = pull("Color", 0, 0, 0);
+	            this.fillStyle = pool$1.pull("Color", 0, 0, 0);
 	        }
 
 	        /**
@@ -34303,10 +34757,10 @@
 	                 this.strokeStyle = settings.strokeStyle;
 	             } else {
 	                 // string (#RGB, #ARGB, #RRGGBB, #AARRGGBB)
-	                 this.strokeStyle = pull("Color").parseCSS(settings.strokeStyle);
+	                 this.strokeStyle = pool$1.pull("Color").parseCSS(settings.strokeStyle);
 	             }
 	         } else {
-	             this.strokeStyle = pull("Color", 0, 0, 0);
+	             this.strokeStyle = pool$1.pull("Color", 0, 0, 0);
 	         }
 
 	        /**
@@ -34657,8 +35111,8 @@
 	     * @ignore
 	     */
 	    Text.prototype.destroy = function destroy () {
-	        push(this.fillStyle);
-	        push(this.strokeStyle);
+	        pool$1.push(this.fillStyle);
+	        pool$1.push(this.strokeStyle);
 	        this.fillStyle = this.strokeStyle = undefined;
 	        this.metrics = undefined;
 	        this._text.length = 0;
@@ -34724,7 +35178,7 @@
 	         * scaled font size
 	         * @private
 	         */
-	        this.fontScale = pull("Vector2d", 1.0, 1.0);
+	        this.fontScale = pool$1.pull("Vector2d", 1.0, 1.0);
 
 	        /**
 	         * font image
@@ -34738,9 +35192,9 @@
 	             * @private
 	             */
 	            // use settings.font to retreive the data from the loader
-	            this.fontData = pull("BitmapTextData", loader.getBinary(settings.font));
+	            this.fontData = pool$1.pull("BitmapTextData", loader.getBinary(settings.font));
 	        } else {
-	            this.fontData = pull("BitmapTextData",
+	            this.fontData = pool$1.pull("BitmapTextData",
 	                // if starting/includes "info face" the whole data string was passed as parameter
 	                (settings.fontData.includes("info face")) ? settings.fontData : loader.getBinary(settings.fontData)
 	            );
@@ -34979,9 +35433,9 @@
 	     * @ignore
 	     */
 	    BitmapText.prototype.destroy = function destroy () {
-	        push(this.fontScale);
+	        pool$1.push(this.fontScale);
 	        this.fontScale = undefined;
-	        push(this.fontData);
+	        pool$1.push(this.fontData);
 	        this.fontData = undefined;
 	        this._text.length = 0;
 	        this.metrics = undefined;
@@ -35246,7 +35700,7 @@
 	         * @name color
 	         * @memberof ColorLayer#
 	         */
-	         this.color = pull("Color").parseCSS(color);
+	         this.color = pool$1.pull("Color").parseCSS(color);
 
 	         this.onResetEvent(name, color, z);
 
@@ -35287,7 +35741,7 @@
 	     * @ignore
 	     */
 	    ColorLayer.prototype.destroy = function destroy () {
-	        push(this.color);
+	        pool$1.push(this.color);
 	        this.color = undefined;
 	        Renderable.prototype.destroy.call(this);
 	    };
@@ -35323,7 +35777,7 @@
 	         * @default <1.0,1.0>
 	         * @name ImageLayer#ratio
 	         */
-	        this.ratio = pull("Vector2d", 1.0, 1.0);
+	        this.ratio = pool$1.pull("Vector2d", 1.0, 1.0);
 
 	        if (typeof(settings.ratio) !== "undefined") {
 	            // little hack for backward compatiblity
@@ -35572,7 +36026,7 @@
 	     * @ignore
 	     */
 	    ImageLayer.prototype.destroy = function destroy () {
-	        push(this.ratio);
+	        pool$1.push(this.ratio);
 	        this.ratio = undefined;
 	        off(ONCONTEXT_RESTORED, this.createPattern);
 	        Sprite.prototype.destroy.call(this);
@@ -36007,7 +36461,15 @@
 	        this.id = settings.id;
 
 	        // add and configure the physic body
-	        this.body = new Body(this, settings.shapes || new Rect(0, 0, this.width, this.height));
+	        var shape = settings.shapes;
+	        if (typeof shape === "undefined") {
+	            shape = pool.pull("Polygon", 0, 0, [
+	                pool.pull("Vector2d", 0,          0),
+	                pool.pull("Vector2d", this.width, 0),
+	                pool.pull("Vector2d", this.width, this.height)
+	            ]);
+	        }
+	        this.body = new Body(this, shape);
 	        this.body.collisionType = collision.types.COLLECTABLE_OBJECT;
 	        // by default only collides with PLAYER_OBJECT
 	        this.body.setCollisionMask(collision.types.PLAYER_OBJECT);
@@ -36067,9 +36529,16 @@
 	            }
 	        }.bind(this));
 
-
-	        // physic body to check for collision against
-	        this.body = new Body(this, settings.shapes || new Rect(0, 0, this.width, this.height));
+	        // add and configure the physic body
+	        var shape = settings.shapes;
+	        if (typeof shape === "undefined") {
+	            shape = pool.pull("Polygon", 0, 0, [
+	                pool.pull("Vector2d", 0,          0),
+	                pool.pull("Vector2d", this.width, 0),
+	                pool.pull("Vector2d", this.width, this.height)
+	            ]);
+	        }
+	        this.body = new Body(this, shape);
 	        this.body.collisionType = collision.types.ACTION_OBJECT;
 	        // by default only collides with PLAYER_OBJECT
 	        this.body.setCollisionMask(collision.types.PLAYER_OBJECT);
@@ -36703,6 +37172,15 @@
 	            settings.height | 1
 	        );
 
+	        /**
+	         * the current (active) emitter settings
+	         * @public
+	         * @type {ParticleEmitterSettings}
+	         * @name settings
+	         * @memberof ParticleEmitter
+	         */
+	        this.settings = {};
+
 	        // center the emitter around the given coordinates
 	        this.centerOn(x, y);
 
@@ -36733,9 +37211,6 @@
 	        // count the updates
 	        this._updateCount = 0;
 
-	        // the emitter settings
-	        this.settings = {};
-
 	        // internally store how much time was skipped when frames are skipped
 	        this._dt = 0;
 
@@ -36751,7 +37226,7 @@
 
 	    /**
 	     * Reset the emitter with particle emitter settings.
-	     * @param {object} settings [optional] object with emitter settings. See {@link ParticleEmitterSettings}
+	     * @param {ParticleEmitterSettings} settings [optional] object with emitter settings. See {@link ParticleEmitterSettings}
 	     */
 	    ParticleEmitter.prototype.reset = function reset (settings) {
 	        if ( settings === void 0 ) settings = {};
@@ -36787,9 +37262,9 @@
 	    // Add count particles in the game world
 	    /** @ignore */
 	    ParticleEmitter.prototype.addParticles = function addParticles (count) {
-	        for (var i = 0; i < ~~count; i++) {
+	        for (var i = 0; i < count; i++) {
 	            // Add particle to the container
-	            this.addChild(pull("Particle", this), this.pos.z);
+	            this.addChild(pool$1.pull("Particle", this), this.pos.z);
 	        }
 	        this.isDirty = true;
 	    };
@@ -36933,9 +37408,10 @@
 	                emitter.settings.image.width,
 	                emitter.settings.image.height
 	            );
+	            this.currentTransform.identity();
 	        } else {
 	            // particle velocity
-	            this.vel = new Vector2d();
+	            this.vel = pool$1.pull("Vector2d");
 	        }
 
 	        this.image = emitter.settings.image;
@@ -37154,11 +37630,11 @@
 	         */
 	        // initialize the default body
 	        if (typeof settings.shapes === "undefined") {
-	            settings.shapes = new Polygon(0, 0, [
-	                new Vector2d(0,          0),
-	                new Vector2d(this.width, 0),
-	                new Vector2d(this.width, this.height),
-	                new Vector2d(0,          this.height)
+	            settings.shapes = pool$1.pull("Polygon", 0, 0, [
+	                pool$1.pull("Vector2d", 0,          0),
+	                pool$1.pull("Vector2d", this.width, 0),
+	                pool$1.pull("Vector2d", this.width, this.height),
+	                pool$1.pull("Vector2d", 0,          this.height)
 	            ]);
 	        }
 	        this.body = new Body(this, settings.shapes, this.onBodyUpdate.bind(this));
@@ -37374,7 +37850,7 @@
 	/**
 	 * @public
 	 * @name Texture
-	 * @memberof Renderer
+	 * @memberof Renderer#
 	 * @deprecated since 10.4.0
 	 * @see TextureAtlas
 	 */
@@ -37439,7 +37915,7 @@
 	 * @name version
 	 * @type {string}
 	 */
-	var version = "10.7.1";
+	var version = "10.8.0";
 
 
 	/**
@@ -37474,58 +37950,60 @@
 	    }
 
 	    // register all built-ins objects into the object pool
-	    register("me.Entity", Entity);
-	    register("me.Collectable", Collectable);
-	    register("me.Trigger", Trigger);
-	    register("me.Tween", Tween, true);
-	    register("me.Color", Color, true);
-	    register("me.Particle", Particle, true);
-	    register("me.Sprite", Sprite);
-	    register("me.NineSliceSprite", NineSliceSprite);
-	    register("me.Renderable", Renderable);
-	    register("me.Text", Text, true);
-	    register("me.BitmapText", BitmapText);
-	    register("me.BitmapTextData", BitmapTextData, true);
-	    register("me.ImageLayer", ImageLayer);
-	    register("me.ColorLayer", ColorLayer, true);
-	    register("me.Vector2d", Vector2d, true);
-	    register("me.Vector3d", Vector3d, true);
-	    register("me.ObservableVector2d", ObservableVector2d, true);
-	    register("me.ObservableVector3d", ObservableVector3d, true);
-	    register("me.Matrix2d", Matrix2d, true);
-	    register("me.Matrix3d", Matrix3d, true);
-	    register("me.Rect", Rect, true);
-	    register("me.Polygon", Polygon, true);
-	    register("me.Line", Line, true);
-	    register("me.Ellipse", Ellipse, true);
-	    register("me.Bounds", Bounds$1, true);
+	    pool$1.register("me.Entity", Entity);
+	    pool$1.register("me.Collectable", Collectable);
+	    pool$1.register("me.Trigger", Trigger);
+	    pool$1.register("me.Tween", Tween, true);
+	    pool$1.register("me.Color", Color, true);
+	    pool$1.register("me.Particle", Particle, true);
+	    pool$1.register("me.Sprite", Sprite);
+	    pool$1.register("me.NineSliceSprite", NineSliceSprite);
+	    pool$1.register("me.Renderable", Renderable);
+	    pool$1.register("me.Text", Text, true);
+	    pool$1.register("me.BitmapText", BitmapText);
+	    pool$1.register("me.BitmapTextData", BitmapTextData, true);
+	    pool$1.register("me.ImageLayer", ImageLayer);
+	    pool$1.register("me.ColorLayer", ColorLayer, true);
+	    pool$1.register("me.Vector2d", Vector2d, true);
+	    pool$1.register("me.Vector3d", Vector3d, true);
+	    pool$1.register("me.ObservableVector2d", ObservableVector2d, true);
+	    pool$1.register("me.ObservableVector3d", ObservableVector3d, true);
+	    pool$1.register("me.Matrix2d", Matrix2d, true);
+	    pool$1.register("me.Matrix3d", Matrix3d, true);
+	    pool$1.register("me.Rect", Rect, true);
+	    pool$1.register("me.RoundRect", RoundRect, true);
+	    pool$1.register("me.Polygon", Polygon, true);
+	    pool$1.register("me.Line", Line, true);
+	    pool$1.register("me.Ellipse", Ellipse, true);
+	    pool$1.register("me.Bounds", Bounds$1, true);
 
 	    // duplicate all entries if use with no namespace (e.g. es6)
-	    register("Entity", Entity);
-	    register("Collectable", Collectable);
-	    register("Trigger", Trigger);
-	    register("Tween", Tween, true);
-	    register("Color", Color, true);
-	    register("Particle", Particle, true);
-	    register("Sprite", Sprite);
-	    register("NineSliceSprite", NineSliceSprite);
-	    register("Renderable", Renderable);
-	    register("Text", Text, true);
-	    register("BitmapText", BitmapText);
-	    register("BitmapTextData", BitmapTextData, true);
-	    register("ImageLayer", ImageLayer);
-	    register("ColorLayer", ColorLayer, true);
-	    register("Vector2d", Vector2d, true);
-	    register("Vector3d", Vector3d, true);
-	    register("ObservableVector2d", ObservableVector2d, true);
-	    register("ObservableVector3d", ObservableVector3d, true);
-	    register("Matrix2d", Matrix2d, true);
-	    register("Matrix3d", Matrix3d, true);
-	    register("Rect", Rect, true);
-	    register("Polygon", Polygon, true);
-	    register("Line", Line, true);
-	    register("Ellipse", Ellipse, true);
-	    register("Bounds", Bounds$1, true);
+	    pool$1.register("Entity", Entity);
+	    pool$1.register("Collectable", Collectable);
+	    pool$1.register("Trigger", Trigger);
+	    pool$1.register("Tween", Tween, true);
+	    pool$1.register("Color", Color, true);
+	    pool$1.register("Particle", Particle, true);
+	    pool$1.register("Sprite", Sprite);
+	    pool$1.register("NineSliceSprite", NineSliceSprite);
+	    pool$1.register("Renderable", Renderable);
+	    pool$1.register("Text", Text, true);
+	    pool$1.register("BitmapText", BitmapText);
+	    pool$1.register("BitmapTextData", BitmapTextData, true);
+	    pool$1.register("ImageLayer", ImageLayer);
+	    pool$1.register("ColorLayer", ColorLayer, true);
+	    pool$1.register("Vector2d", Vector2d, true);
+	    pool$1.register("Vector3d", Vector3d, true);
+	    pool$1.register("ObservableVector2d", ObservableVector2d, true);
+	    pool$1.register("ObservableVector3d", ObservableVector3d, true);
+	    pool$1.register("Matrix2d", Matrix2d, true);
+	    pool$1.register("Matrix3d", Matrix3d, true);
+	    pool$1.register("Rect", Rect, true);
+	    pool$1.register("RoundRect", RoundRect, true);
+	    pool$1.register("Polygon", Polygon, true);
+	    pool$1.register("Line", Line, true);
+	    pool$1.register("Ellipse", Ellipse, true);
+	    pool$1.register("Bounds", Bounds$1, true);
 
 	    // publish Boot notification
 	    emit(BOOT);
@@ -37581,6 +38059,7 @@
 	exports.Rect = Rect;
 	exports.Renderable = Renderable;
 	exports.Renderer = Renderer;
+	exports.RoundRect = RoundRect;
 	exports.Sprite = Sprite;
 	exports.Stage = Stage;
 	exports.TMXHexagonalRenderer = TMXHexagonalRenderer;
@@ -37613,7 +38092,7 @@
 	exports.loader = loader;
 	exports.plugin = plugin;
 	exports.plugins = plugins;
-	exports.pool = pooling;
+	exports.pool = pool$1;
 	exports.save = save;
 	exports.skipAutoInit = skipAutoInit;
 	exports.state = state;