Merge branch 'master' of https://github.com/photonstorm/phaser

Author: Upperfoot

CHANGELOG.md

@@ -32,7 +32,7 @@ var GetValue = require('../utils/object/GetValue');
  *
  * @property {string} key - The key that the animation will be associated with. i.e. sprite.animations.play(key)
  * @property {(string|number)} frame - [description]
- * @property {float} [duration=0] - [description]
+ * @property {number} [duration=0] - [description]
  * @property {boolean} [visible] - [description]
  */
 
@@ -545,7 +545,7 @@ var Animation = new Class({
      * @method Phaser.Animations.Animation#getFrameByProgress
      * @since 3.4.0
      *
-     * @param {float} value - A value between 0 and 1.
+     * @param {number} value - A value between 0 and 1.
      *
      * @return {Phaser.Animations.AnimationFrame} The frame closest to the given progress value.
      */

src/animations/Animation.js

@@ -324,24 +324,30 @@ var Config = new Class({
         var renderConfig = GetValue(config, 'render', config);
 
         /**
-         * @const {boolean} Phaser.Boot.Config#antialias - [description]
+         * @const {boolean} Phaser.Boot.Config#autoResize - [description]
          */
-        this.antialias = GetValue(renderConfig, 'antialias', true);
+        this.autoResize = GetValue(renderConfig, 'autoResize', false);
 
         /**
-         * @const {boolean} Phaser.Boot.Config#pixelArt - [description]
+         * @const {boolean} Phaser.Boot.Config#antialias - [description]
          */
-        this.pixelArt = GetValue(renderConfig, 'pixelArt', false);
+        this.antialias = GetValue(renderConfig, 'antialias', true);
 
         /**
-         * @const {boolean} Phaser.Boot.Config#autoResize - [description]
+         * @const {boolean} Phaser.Boot.Config#roundPixels - [description]
          */
-        this.autoResize = GetValue(renderConfig, 'autoResize', false);
+        this.roundPixels = GetValue(renderConfig, 'roundPixels', false);
 
         /**
-         * @const {boolean} Phaser.Boot.Config#roundPixels - [description]
+         * @const {boolean} Phaser.Boot.Config#pixelArt - [description]
          */
-        this.roundPixels = GetValue(renderConfig, 'roundPixels', false);
+        this.pixelArt = GetValue(renderConfig, 'pixelArt', false);
+
+        if (this.pixelArt)
+        {
+            this.antialias = false;
+            this.roundPixels = true;
+        }
 
         /**
          * @const {boolean} Phaser.Boot.Config#transparent - [description]

src/boot/Config.js

@@ -48,7 +48,7 @@ var CreateRenderer = function (game)
     }
 
     //  Pixel Art mode?
-    if (config.pixelArt)
+    if (!config.antialias)
     {
         CanvasPool.disableSmoothing();
     }
@@ -70,7 +70,7 @@ var CreateRenderer = function (game)
     }
 
     //  Pixel Art mode?
-    if (config.pixelArt)
+    if (!config.antialias)
     {
         CanvasInterpolation.setCrisp(game.canvas);
     }

src/boot/CreateRenderer.js

@@ -94,6 +94,17 @@ var Camera = new Class({
          */
         this.scene;
 
+        /**
+         * The Camera ID. Assigned by the Camera Manager and used to handle camera exclusion.
+         * This value is a bitmask.
+         *
+         * @name Phaser.Cameras.Scene2D.Camera#id
+         * @type {integer}
+         * @readOnly
+         * @since 3.11.0
+         */
+        this.id = 0;
+
         /**
          * The name of the Camera. This is left empty for your own use.
          *
@@ -251,7 +262,7 @@ var Camera = new Class({
          * Be careful to never set this value to zero.
          *
          * @name Phaser.Cameras.Scene2D.Camera#zoom
-         * @type {float}
+         * @type {number}
          * @default 1
          * @since 3.0.0
          */
@@ -302,6 +313,18 @@ var Camera = new Class({
          */
         this.backgroundColor = ValueToColor('rgba(0,0,0,0)');
 
+        /**
+         * The Camera alpha value. Setting this property impacts every single object that this Camera
+         * renders. You can either set the property directly, i.e. via a Tween, to fade a Camera in or out,
+         * or via the chainable `setAlpha` method instead.
+         *
+         * @name Phaser.Cameras.Scene2D.Camera#alpha
+         * @type {number}
+         * @default 1
+         * @since 3.11.0
+         */
+        this.alpha = 1;
+
         /**
          * The Camera Fade effect handler.
          * To fade this camera see the `Camera.fade` methods.
@@ -429,7 +452,7 @@ var Camera = new Class({
          * See `setOrigin` to set both origins in a single, chainable call.
          *
          * @name Phaser.Cameras.Scene2D.Camera#originX
-         * @type {float}
+         * @type {number}
          * @default 0.5
          * @since 3.11.0
          */
@@ -446,7 +469,7 @@ var Camera = new Class({
          * See `setOrigin` to set both origins in a single, chainable call.
          *
          * @name Phaser.Cameras.Scene2D.Camera#originY
-         * @type {float}
+         * @type {number}
          * @default 0.5
          * @since 3.11.0
          */
@@ -487,17 +510,26 @@ var Camera = new Class({
          * @since 3.0.0
          */
         this._follow = null;
+    },
 
-        /**
-         * Internal camera ID. Assigned by the Camera Manager and used in the camera pool.
-         *
-         * @name Phaser.Cameras.Scene2D.Camera#_id
-         * @type {integer}
-         * @private
-         * @default 0
-         * @since 3.0.0
-         */
-        this._id = 0;
+    /**
+     * Set the Alpha level of this Camera. The alpha controls the opacity of the Camera as it renders.
+     * Alpha values are provided as a float between 0, fully transparent, and 1, fully opaque.
+     *
+     * @method Phaser.GameObjects.Components.Origin#setAlpha
+     * @since 3.11.0
+     *
+     * @param {number} [value=1] - The Camera alpha value.
+     *
+     * @return {this} This Camera instance.
+     */
+    setAlpha: function (value)
+    {
+        if (value === undefined) { value = 1; }
+
+        this.alpha = value;
+
+        return this;
     },
 
     /**
@@ -1029,7 +1061,7 @@ var Camera = new Class({
      */
     ignore: function (gameObject)
     {
-        var id = this._id;
+        var id = this.id;
 
         if (Array.isArray(gameObject))
         {
@@ -1317,10 +1349,23 @@ var Camera = new Class({
     },
 
     /**
-     * Set the world bounds for this Camera.
-     *
-     * A Camera bounds controls where the camera can scroll to within the world. It does not limit
-     * rendering of the camera, or placement of the viewport within your game.
+     * Set the bounds of the Camera. The bounds are an axis-aligned rectangle.
+     * 
+     * The Camera bounds controls where the Camera can scroll to, stopping it from scrolling off the
+     * edges and into blank space. It does not limit the placement of Game Objects, or where
+     * the Camera viewport can be positioned.
+     * 
+     * Temporarily disable the bounds by changing the boolean `Camera.useBounds`.
+     * 
+     * Clear the bounds entirely by calling `Camera.removeBounds`.
+     * 
+     * If you set bounds that are smaller than the viewport it will stop the Camera from being
+     * able to scroll. The bounds can be positioned where-ever you wish. By default they are from
+     * 0x0 to the canvas width x height. This means that the coordinate 0x0 is the top left of
+     * the Camera bounds. However, you can position them anywhere. So if you wanted a game world
+     * that was 2048x2048 in size, with 0x0 being the center of it, you can set the bounds x/y
+     * to be -1024, -1024, with a width and height of 2048. Depending on your game you may find
+     * it easier for 0x0 to be the top-left of the bounds, or you may wish 0x0 to be the middle.
      *
      * @method Phaser.Cameras.Scene2D.Camera#setBounds
      * @since 3.0.0
@@ -1329,15 +1374,26 @@ var Camera = new Class({
      * @param {integer} y - The top-left y coordinate of the bounds.
      * @param {integer} width - The width of the bounds, in pixels.
      * @param {integer} height - The height of the bounds, in pixels.
+     * @param {boolean} [centerOn] - If `true` the Camera will automatically be centered on the new bounds.
      *
      * @return {Phaser.Cameras.Scene2D.Camera} This Camera instance.
      */
-    setBounds: function (x, y, width, height)
+    setBounds: function (x, y, width, height, centerOn)
     {
         this._bounds.setTo(x, y, width, height);
 
         this.useBounds = true;
 
+        if (centerOn)
+        {
+            this.centerToBounds();
+        }
+        else
+        {
+            this.scrollX = this.clampX(this.scrollX);
+            this.scrollY = this.clampY(this.scrollY);
+        }
+
         return this;
     },
 
@@ -1406,8 +1462,9 @@ var Camera = new Class({
     },
 
     /**
-     * Should the Camera round pixel values to whole integers when scrolling?
-     * In some types of game this is required to prevent sub-pixel aliasing.
+     * Should the Camera round pixel values to whole integers when rendering Game Objects?
+     * 
+     * In some types of game, especially with pixel art, this is required to prevent sub-pixel aliasing.
      *
      * @method Phaser.Cameras.Scene2D.Camera#setRoundPixels
      * @since 3.0.0
@@ -1534,7 +1591,7 @@ var Camera = new Class({
      * @method Phaser.Cameras.Scene2D.Camera#setZoom
      * @since 3.0.0
      *
-     * @param {float} [value=1] - The zoom value of the Camera. The minimum it can be is 0.001.
+     * @param {number} [value=1] - The zoom value of the Camera. The minimum it can be is 0.001.
      *
      * @return {Phaser.Cameras.Scene2D.Camera} This Camera instance.
      */
@@ -1590,8 +1647,8 @@ var Camera = new Class({
      *
      * @param {(Phaser.GameObjects.GameObject|object)} target - The target for the Camera to follow.
      * @param {boolean} [roundPixels=false] - Round the camera position to whole integers to avoid sub-pixel rendering?
-     * @param {float} [lerpX=1] - A value between 0 and 1. This value specifies the amount of linear interpolation to use when horizontally tracking the target. The closer the value to 1, the faster the camera will track.
-     * @param {float} [lerpY=1] - A value between 0 and 1. This value specifies the amount of linear interpolation to use when vertically tracking the target. The closer the value to 1, the faster the camera will track.
+     * @param {number} [lerpX=1] - A value between 0 and 1. This value specifies the amount of linear interpolation to use when horizontally tracking the target. The closer the value to 1, the faster the camera will track.
+     * @param {number} [lerpY=1] - A value between 0 and 1. This value specifies the amount of linear interpolation to use when vertically tracking the target. The closer the value to 1, the faster the camera will track.
      * @param {number} [offsetX=0] - The horizontal offset from the camera follow target.x position.
      * @param {number} [offsetY=0] - The vertical offset from the camera follow target.y position.
      *