Merge branch 'master' of https://github.com/photonstorm/phaser into types/group-classType

Author: samme

.github/FUNDING.yml

@@ -0,0 +1,5 @@
+# These are supported funding model platforms
+
+github: photonstorm
+patreon: photonstorm
+custom: https://phaser.io/community/donate

CHANGELOG.md

@@ -2,6 +2,60 @@
 
 ## Version 3.18.0 - Raphtalia - in dev
 
+### Input System Changes
+
+The old 'input queue' legacy system, which was deprecated in 3.16, has been removed entirely in order to tidy-up the API and keep input events consistent. This means the following changes:
+
+* Removed the `inputQueue` Game config property.
+* Removed the `useQueue`, `queue` and `_updatedThisFrame` properties from the Input Manager.
+* Removed the `legacyUpdate` and `update` methods from the Input Manager.
+* Removed the `ignoreEvents` property as this should now be handled on a per-event basis.
+* The Input Manager no longer listens for the `GameEvents.POST_STEP` event.
+
+As a result, all of the following Input Manager methods have been renamed:
+
+* `queueTouchStart` is now called `onTouchStart` and invoked by the Touch Manager.
+* `queueTouchMove` is now called `onTouchMove` and invoked by the Touch Manager.
+* `queueTouchEnd` is now called `onTouchEnd` and invoked by the Touch Manager.
+* `queueTouchCancel` is now called `onTouchCancel` and invoked by the Touch Manager.
+* `queueMouseDown` is now called `onMouseDown` and invoked by the Mouse Manager.
+* `queueMouseMove` is now called `onMouseMove` and invoked by the Mouse Manager.
+* `queueMouseUp` is now called `onMouseUp` and invoked by the Mouse Manager.
+
+Each of these handlers used to check the `enabled` state of the Input Manager, but this now handled directly in the Touch and Mouse Managers instead, leading to less branching and cleaner tests.
+
+Because the legacy queue mode is gone, there is no longer any need for the DOM Callbacks:
+
+* Removed the `_hasUpCallback`, `_hasDownCallback` and `_hasMoveCallback` properties from the Input Manager
+* Removed the `processDomCallbacks`, `addDownCallback`, `addUpCallback`, `addMoveCallback`, `domCallbacks`, `addDownCallback`, `addUpCallback` and `addMoveCallback` methods.
+
+Also, CSS cursors can now be set directly:
+
+* Cursors are now set and reset immediately on the canvas, leading to the removal of `_setCursor` and `_customCursor` properties.
+
+The following changes took place in the Input Plugin class:
+
+* The method `processDragEvents` has been removed as it's now split across smaller, more explicit methods.
+* `processDragDownEvent` is a new method that handles a down event for drag enabled Game Objects.
+* `processDragMoveEvent` is a new method that handles a move event for drag enabled Game Objects.
+* `processDragUpEvent` is a new method that handles an up event for drag enabled Game Objects.
+* `processDragStartList` is a new internal method that builds a drag list for a pointer.
+* `processDragThresholdEvent` is a new internal method that tests when a pointer with drag thresholds can drag.
+
+The following changes took place in the Pointer class:
+
+* `Pointer.dirty` has been removed as it's no longer required.
+* `Pointer.justDown` has been removed as it's not used internally and makes no sense under the DOM event system.
+* `Pointer.justUp` has been removed as it's not used internally and makes no sense under the DOM event system.
+* `Pointer.justMoved` has been removed as it's not used internally and makes no sense under the DOM event system.
+* The `Pointer.reset` method has been removed as it's no longer required internally.
+
+#### Input System Bug Fixes
+
+* Calling `setPollAlways()` would cause the `'pointerdown'` event to fire multiple times. Fix #4541 (thanks @Neyromantik)
+* The pointer events were intermittently not registered, causing `pointerup` to often fail. Fix #4538 (thanks @paulsymphony)
+* Due to a regression in 3.16 the drag events were not performing as fast as before, causing drags to feel lagged. Fix #4500 (thanks @aliblong)
+
 ### New Features
 
 * `Matter.Factory.velocity` is a new method that allows you to set the velocity on a Matter Body directly.
@@ -14,13 +68,24 @@
 * The default `BaseShader` vertex shader has a new uniform `uResolution` which is set during the Shader init and load to be the size of the Game Object to which the shader is bound.
 * The default `BaseShader` vertex shader will now set the `fragCoord` varying to be the Game Object height minus the y inPosition. This will give the correct y axis in the fragment shader, causing 'inverted' shaders to display normally when using the default vertex code.
 * There was some test code left in the `DOMElementCSSRenderer` file that caused `getBoundingClientRect` to be called every render. This has been removed, which increases performance significantly for DOM heavy games.
+* The `TimeStep` will no longer set its `frame` property to zero in the `resetDelta` method. Instead, this property is incremented every step, no matter what, giving an accurate indication of exactly which frame something happened on internally.
+* The `TimeStep.step` method no longer uses the time value passed to the raf callback, as it's not actually the current point in time, but rather the time that the main thread began at. Which doesn't help if we're comparing it to event timestamps.
+* `TimeStep.now` is a new property that holds the exact `performance.now` value, as set at the start of the current game step.
 
 ### Bug Fixes
 
 * Tweens created in a paused state couldn't be started by a call to `play`. Fix #4525 (thanks @TonioParis)
 * If both Arcade Physics circle body positions and the delta equaled zero, the `separateCircle` function would cause the position to be set `NaN` (thanks @hizzd)
 * The `CameraManager` would incorrectly destroy the `default` Camera in its shutdown method, meaning that if you used a fixed mask camera and stopped then resumed a Scene, the masks would stop working. The default camera is now destroyed only in the `destroy` method. Fix #4520 (thanks @telinc1)
 * Passing a Frame object to `Bob.setFrame` would fail, as it expected a string or integer. It now checks the type of object, and if a Frame it checks to make sure it's a Frame belonging to the parent Blitter's texture, and if so sets it. Fix #4516 (thanks @NokFrt)
+* The ScaleManager full screen call had an arrow function in it. Despite being within a conditional block of code it still broke really old browsers like IE11, so has been removed. Fix #4530 (thanks @jorbascrumps @CNDW)
+* `Game.getTime` would return `NaN` because it incorrectly accessed the time value from the TimeStep.
+
+### Examples, Documentation and TypeScript
+
+My thanks to the following for helping with the Phaser 3 Examples, Docs and TypeScript definitions, either by reporting errors, fixing them or helping author the docs:
+
+@PhaserEditor2D @samme
 
 
 

src/core/Config.js

@@ -270,11 +270,6 @@ var Config = new Class({
          */
         this.inputSmoothFactor = GetValue(config, 'input.smoothFactor', 0);
 
-        /**
-         * @const {boolean} Phaser.Core.Config#inputQueue - Should Phaser use a queued input system for native DOM Events or not?
-         */
-        this.inputQueue = GetValue(config, 'input.queue', false);
-
         /**
          * @const {boolean} Phaser.Core.Config#inputWindowEvents - Should Phaser listen for input events on the Window? If you disable this, events like 'POINTER_UP_OUTSIDE' will no longer fire.
          */

src/core/Game.js

@@ -604,6 +604,7 @@ var Game = new Class({
 
     /**
      * Returns the current game frame.
+     * 
      * When the game starts running, the frame is incremented every time Request Animation Frame, or Set Timeout, fires.
      *
      * @method Phaser.Game#getFrame
@@ -617,8 +618,7 @@ var Game = new Class({
     },
 
     /**
-     * Returns the current game timestamp.
-     * When the game starts running, the frame is incremented every time Request Animation Frame, or Set Timeout, fires.
+     * Returns the time that the current game step started at, as based on `performance.now`.
      *
      * @method Phaser.Game#getTime
      * @since 3.16.0
@@ -627,7 +627,7 @@ var Game = new Class({
      */
     getTime: function ()
     {
-        return this.loop.frame.time;
+        return this.loop.now;
     },
 
     /**

src/core/TimeStep.js

@@ -185,37 +185,39 @@ var TimeStep = new Class({
         this.forceSetTimeOut = GetValue(config, 'forceSetTimeOut', false);
 
         /**
-         * [description]
+         * The time, calculated at the start of the current step, as smoothed by the delta value.
          *
          * @name Phaser.Core.TimeStep#time
-         * @type {integer}
+         * @type {number}
          * @default 0
          * @since 3.0.0
          */
         this.time = 0;
 
         /**
-         * [description]
+         * The time at which the game started running. This value is adjusted if the game is then
+         * paused and resumes.
          *
          * @name Phaser.Core.TimeStep#startTime
-         * @type {integer}
+         * @type {number}
          * @default 0
          * @since 3.0.0
          */
         this.startTime = 0;
 
         /**
-         * [description]
+         * The time, as returned by `performance.now` of the previous step.
          *
          * @name Phaser.Core.TimeStep#lastTime
-         * @type {integer}
+         * @type {number}
          * @default 0
          * @since 3.0.0
          */
         this.lastTime = 0;
 
         /**
-         * [description]
+         * The current frame the game is on. This counter is incremented once every game step, regardless of how much
+         * time has passed and is unaffected by delta smoothing.
          *
          * @name Phaser.Core.TimeStep#frame
          * @type {integer}
@@ -226,7 +228,8 @@ var TimeStep = new Class({
         this.frame = 0;
 
         /**
-         * [description]
+         * Is the browser currently considered in focus by the Page Visibility API?
+         * This value is set in the `blur` method, which is called automatically by the Game instance.
          *
          * @name Phaser.Core.TimeStep#inFocus
          * @type {boolean}
@@ -237,18 +240,18 @@ var TimeStep = new Class({
         this.inFocus = true;
 
         /**
-         * [description]
+         * The timestamp at which the game became paused, as determined by the Page Visibility API.
          *
          * @name Phaser.Core.TimeStep#_pauseTime
-         * @type {integer}
+         * @type {number}
          * @private
          * @default 0
          * @since 3.0.0
          */
         this._pauseTime = 0;
 
         /**
-         * [description]
+         * An internal counter to allow for the browser 'cooling down' after coming back into focus.
          *
          * @name Phaser.Core.TimeStep#_coolDown
          * @type {integer}
@@ -259,7 +262,7 @@ var TimeStep = new Class({
         this._coolDown = 0;
 
         /**
-         * [description]
+         * The delta time, in ms, since the last game step. This is a clamped and smoothed average value.
          *
          * @name Phaser.Core.TimeStep#delta
          * @type {integer}
@@ -269,7 +272,7 @@ var TimeStep = new Class({
         this.delta = 0;
 
         /**
-         * [description]
+         * Internal index of the delta history position.
          *
          * @name Phaser.Core.TimeStep#deltaIndex
          * @type {integer}
@@ -279,7 +282,7 @@ var TimeStep = new Class({
         this.deltaIndex = 0;
 
         /**
-         * [description]
+         * Internal array holding the previous delta values, used for delta smoothing.
          *
          * @name Phaser.Core.TimeStep#deltaHistory
          * @type {integer[]}
@@ -288,7 +291,9 @@ var TimeStep = new Class({
         this.deltaHistory = [];
 
         /**
-         * [description]
+         * The maximum number of delta values that are retained in order to calculate a smoothed moving average.
+         * 
+         * This can be changed in the Game Config via the `fps.deltaHistory` property. The default is 10.
          *
          * @name Phaser.Core.TimeStep#deltaSmoothingMax
          * @type {integer}
@@ -298,7 +303,10 @@ var TimeStep = new Class({
         this.deltaSmoothingMax = GetValue(config, 'deltaHistory', 10);
 
         /**
-         * [description]
+         * The number of frames that the cooldown is set to after the browser panics over the FPS rate, usually
+         * as a result of switching tabs and regaining focus.
+         * 
+         * This can be changed in the Game Config via the `fps.panicMax` property. The default is 120.
          *
          * @name Phaser.Core.TimeStep#panicMax
          * @type {integer}
@@ -309,19 +317,31 @@ var TimeStep = new Class({
 
         /**
          * The actual elapsed time in ms between one update and the next.
-         * Unlike with `delta` no smoothing, capping, or averaging is applied to this value.
-         * So please be careful when using this value in calculations.
+         * 
+         * Unlike with `delta`, no smoothing, capping, or averaging is applied to this value.
+         * So please be careful when using this value in math calculations.
          *
          * @name Phaser.Core.TimeStep#rawDelta
          * @type {number}
          * @default 0
          * @since 3.0.0
          */
         this.rawDelta = 0;
+
+        /**
+         * The time, as returned by `performance.now` at the very start of the current step.
+         * This can differ from the `time` value in that it isn't calculated based on the delta value.
+         *
+         * @name Phaser.Core.TimeStep#now
+         * @type {number}
+         * @default 0
+         * @since 3.18.0
+         */
+        this.now = 0;
     },
 
     /**
-     * Called when the DOM window.onBlur event triggers.
+     * Called by the Game instance when the DOM window.onBlur event triggers.
      *
      * @method Phaser.Core.TimeStep#blur
      * @since 3.0.0
@@ -332,7 +352,7 @@ var TimeStep = new Class({
     },
 
     /**
-     * Called when the DOM window.onFocus event triggers.
+     * Called by the Game instance when the DOM window.onFocus event triggers.
      *
      * @method Phaser.Core.TimeStep#focus
      * @since 3.0.0
@@ -369,7 +389,8 @@ var TimeStep = new Class({
     },
 
     /**
-     * [description]
+     * Resets the time, lastTime, fps averages and delta history.
+     * Called automatically when a browser sleeps them resumes.
      *
      * @method Phaser.Core.TimeStep#resetDelta
      * @since 3.0.0
@@ -382,7 +403,6 @@ var TimeStep = new Class({
         this.lastTime = now;
         this.nextFpsUpdate = now + 1000;
         this.framesThisSecond = 0;
-        this.frame = 0;
 
         //  Pre-populate smoothing array
 
@@ -437,11 +457,17 @@ var TimeStep = new Class({
      *
      * @method Phaser.Core.TimeStep#step
      * @since 3.0.0
-     * 
-     * @param {number} time - The current time. Either a High Resolution Timer value if it comes from Request Animation Frame, or Date.now if using SetTimeout.
      */
-    step: function (time)
+    step: function ()
     {
+        //  Because the timestamp passed in from raf represents the beginning of the main thread frame that we’re currently in,
+        //  not the actual time now. As we want to compare this time value against Event timeStamps and the like, we need a
+        //  more accurate one:
+
+        var time = window.performance.now();
+
+        this.now = time;
+
         var before = time - this.lastTime;
 
         if (before < 0)
@@ -556,14 +582,14 @@ var TimeStep = new Class({
     },
 
     /**
-     * Manually calls TimeStep.step, passing in the performance.now value to it.
+     * Manually calls `TimeStep.step`.
      *
      * @method Phaser.Core.TimeStep#tick
      * @since 3.0.0
      */
     tick: function ()
     {
-        this.step(window.performance.now());
+        this.step();
     },
 
     /**
@@ -606,7 +632,7 @@ var TimeStep = new Class({
 
         this.running = true;
 
-        this.step(window.performance.now());
+        this.step();
     },
 
     /**

src/core/typedefs/InputConfig.js

@@ -8,6 +8,5 @@
  * @property {(boolean|Phaser.Types.Core.GamepadInputConfig)} [gamepad=false] - Gamepad input configuration. `true` enables gamepad input.
  * @property {integer} [activePointers=1] - The maximum number of touch pointers. See {@link Phaser.Input.InputManager#pointers}.
  * @property {number} [smoothFactor=0] - The smoothing factor to apply during Pointer movement. See {@link Phaser.Input.Pointer#smoothFactor}.
- * @property {boolean} [inputQueue=false] - Should Phaser use a queued input system for native DOM Events or not?
  * @property {boolean} [windowEvents=true] - Should Phaser listen for input events on the Window? If you disable this, events like 'POINTER_UP_OUTSIDE' will no longer fire.
  */

src/gameobjects/group/typedefs/GroupCreateConfig.js

@@ -3,18 +3,16 @@
  *
  *     key.length * frame.length * frameQuantity * (yoyo ? 2 : 1) * (1 + repeat)
  *
- * In the simplest case, 1 + `repeat` objects will be created.
- *
- * If `max` is positive, then the total created will not exceed `max`.
+ * If `max` is nonzero, then the total created will not exceed `max`.
  *
  * `key` is required. {@link Phaser.GameObjects.Group#defaultKey} is not used.
- * 
+ *
  * @typedef {object} Phaser.Types.GameObjects.Group.GroupCreateConfig
  * @since 3.0.0
  *
  * @property {?Function} [classType] - The class of each new Game Object.
- * @property {string} [key] - The texture key of each new Game Object.
- * @property {?(string|integer)} [frame=null] - The texture frame of each new Game Object.
+ * @property {(string|string[])} [key] - The texture key of each new Game Object.
+ * @property {?(string|string[]|integer|integer[])} [frame=null] - The texture frame of each new Game Object.
  * @property {?boolean} [visible=true] - The visible state of each new Game Object.
  * @property {?boolean} [active=true] - The active state of each new Game Object.
  * @property {?number} [repeat=0] - The number of times each `key` × `frame` combination will be *repeated* (after the first combination).