# class

longname: Phaser.Animations.Animation
since: 3.0.0
name: Animation
memberof: Phaser.Animations
metafilename: Animation.js
metapath: animations
description:
A Frame based Animation.

Animations in Phaser consist of a sequence of `AnimationFrame` objects, which are managed by
this class, along with properties that impact playback, such as the animations frame rate
or delay.

This class contains all of the properties and methods needed to handle playback of the animation
directly to an `AnimationState` instance, which is owned by a Sprite, or similar Game Object.

You don't typically create an instance of this class directly, but instead go via
either the `AnimationManager` or the `AnimationState` and use their `create` methods,
depending on if you need a global animation, or local to a specific Sprite.


longname: Phaser.Animations.AnimationFrame
since: 3.0.0
name: AnimationFrame
memberof: Phaser.Animations
metafilename: AnimationFrame.js
metapath: animations
description:
A single frame in an Animation sequence.

An AnimationFrame consists of a reference to the Texture it uses for rendering, references to other
frames in the animation, and index data. It also has the ability to modify the animation timing.

AnimationFrames are generated automatically by the Animation class.


longname: Phaser.Animations.AnimationManager
since: 3.0.0
name: AnimationManager
memberof: Phaser.Animations
metafilename: AnimationManager.js
metapath: animations
description:
The Animation Manager.

Animations are managed by the global Animation Manager. This is a singleton class that is
responsible for creating and delivering animations and their corresponding data to all Game Objects.
Unlike plugins it is owned by the Game instance, not the Scene.

Sprites and other Game Objects get the data they need from the AnimationManager.


longname: Phaser.Animations.AnimationState
since: 3.0.0
name: AnimationState
memberof: Phaser.Animations
metafilename: AnimationState.js
metapath: animations
description:
The Animation State Component.

This component provides features to apply animations to Game Objects. It is responsible for
loading, queuing animations for later playback, mixing between animations and setting
the current animation frame to the Game Object that owns this component.

This component lives as an instance within any Game Object that has it defined, such as Sprites.

You can access its properties and methods via the `anims` property, i.e. `Sprite.anims`.

As well as playing animations stored in the global Animation Manager, this component
can also create animations that are stored locally within it. See the `create` method
for more details.

Prior to Phaser 3.50 this component was called just `Animation` and lived in the
`Phaser.GameObjects.Components` namespace. It was renamed to `AnimationState`
in 3.50 to help better identify its true purpose when browsing the documentation.


longname: Phaser.Cache.BaseCache
since: 3.0.0
name: BaseCache
memberof: Phaser.Cache
metafilename: BaseCache.js
metapath: cache
description:
The BaseCache is a base Cache class that can be used for storing references to any kind of data.

Data can be added, retrieved and removed based on the given keys.

Keys are string-based.


longname: Phaser.Cache.CacheManager
since: 3.0.0
name: CacheManager
memberof: Phaser.Cache
metafilename: CacheManager.js
metapath: cache
description:
The Cache Manager is the global cache owned and maintained by the Game instance.

Various systems, such as the file Loader, rely on this cache in order to store the files
it has loaded. The manager itself doesn't store any files, but instead owns multiple BaseCache
instances, one per type of file. You can also add your own custom caches.


longname: Phaser.Cameras.Scene2D.BaseCamera
since: 3.12.0
name: BaseCamera
memberof: Phaser.Cameras.Scene2D
metafilename: BaseCamera.js
metapath: cameras/2d
description:
A Base Camera class.

The Camera is the way in which all games are rendered in Phaser. They provide a view into your game world,
and can be positioned, rotated, zoomed and scrolled accordingly.

A Camera consists of two elements: The viewport and the scroll values.

The viewport is the physical position and size of the Camera within your game. Cameras, by default, are
created the same size as your game, but their position and size can be set to anything. This means if you
wanted to create a camera that was 320x200 in size, positioned in the bottom-right corner of your game,
you'd adjust the viewport to do that (using methods like `setViewport` and `setSize`).

If you wish to change where the Camera is looking in your game, then you scroll it. You can do this
via the properties `scrollX` and `scrollY` or the method `setScroll`. Scrolling has no impact on the
viewport, and changing the viewport has no impact on the scrolling.

By default a Camera will render all Game Objects it can see. You can change this using the `ignore` method,
allowing you to filter Game Objects out on a per-Camera basis.

The Base Camera is extended by the Camera class, which adds in special effects including Fade,
Flash and Camera Shake, as well as the ability to follow Game Objects.

The Base Camera was introduced in Phaser 3.12. It was split off from the Camera class, to allow
you to isolate special effects as needed. Therefore the 'since' values for properties of this class relate
to when they were added to the Camera class.


longname: Phaser.Cameras.Scene2D.Camera
since: 3.0.0
name: Camera
memberof: Phaser.Cameras.Scene2D
metafilename: Camera.js
metapath: cameras/2d
description:
A Camera.

The Camera is the way in which all games are rendered in Phaser. They provide a view into your game world,
and can be positioned, rotated, zoomed and scrolled accordingly.

A Camera consists of two elements: The viewport and the scroll values.

The viewport is the physical position and size of the Camera within your game. Cameras, by default, are
created the same size as your game, but their position and size can be set to anything. This means if you
wanted to create a camera that was 320x200 in size, positioned in the bottom-right corner of your game,
you'd adjust the viewport to do that (using methods like `setViewport` and `setSize`).

If you wish to change where the Camera is looking in your game, then you scroll it. You can do this
via the properties `scrollX` and `scrollY` or the method `setScroll`. Scrolling has no impact on the
viewport, and changing the viewport has no impact on the scrolling.

By default a Camera will render all Game Objects it can see. You can change this using the `ignore` method,
allowing you to filter Game Objects out on a per-Camera basis.

A Camera also has built-in special effects including Fade, Flash and Camera Shake.


longname: Phaser.Cameras.Scene2D.CameraManager
since: 3.0.0
name: CameraManager
memberof: Phaser.Cameras.Scene2D
metafilename: CameraManager.js
metapath: cameras/2d
description:
The Camera Manager is a plugin that belongs to a Scene and is responsible for managing all of the Scene Cameras.

By default you can access the Camera Manager from within a Scene using `this.cameras`, although this can be changed
in your game config.

Create new Cameras using the `add` method. Or extend the Camera class with your own addition code and then add
the new Camera in using the `addExisting` method.

Cameras provide a view into your game world, and can be positioned, rotated, zoomed and scrolled accordingly.

A Camera consists of two elements: The viewport and the scroll values.

The viewport is the physical position and size of the Camera within your game. Cameras, by default, are
created the same size as your game, but their position and size can be set to anything. This means if you
wanted to create a camera that was 320x200 in size, positioned in the bottom-right corner of your game,
you'd adjust the viewport to do that (using methods like `setViewport` and `setSize`).

If you wish to change where the Camera is looking in your game, then you scroll it. You can do this
via the properties `scrollX` and `scrollY` or the method `setScroll`. Scrolling has no impact on the
viewport, and changing the viewport has no impact on the scrolling.

By default a Camera will render all Game Objects it can see. You can change this using the `ignore` method,
allowing you to filter Game Objects out on a per-Camera basis. The Camera Manager can manage up to 31 unique
'Game Object ignore capable' Cameras. Any Cameras beyond 31 that you create will all be given a Camera ID of
zero, meaning that they cannot be used for Game Object exclusion. This means if you need your Camera to ignore
Game Objects, make sure it's one of the first 31 created.

A Camera also has built-in special effects including Fade, Flash, Camera Shake, Pan and Zoom.


longname: Phaser.Cameras.Scene2D.Effects.Fade
since: 3.5.0
name: Fade
memberof: Phaser.Cameras.Scene2D.Effects
metafilename: Fade.js
metapath: cameras/2d/effects
description:
A Camera Fade effect.

This effect will fade the camera viewport to the given color, over the duration specified.

Only the camera viewport is faded. None of the objects it is displaying are impacted, i.e. their colors do
not change.

The effect will dispatch several events on the Camera itself and you can also specify an `onUpdate` callback,
which is invoked each frame for the duration of the effect, if required.


longname: Phaser.Cameras.Scene2D.Effects.Flash
since: 3.5.0
name: Flash
memberof: Phaser.Cameras.Scene2D.Effects
metafilename: Flash.js
metapath: cameras/2d/effects
description:
A Camera Flash effect.

This effect will flash the camera viewport to the given color, over the duration specified.

Only the camera viewport is flashed. None of the objects it is displaying are impacted, i.e. their colors do
not change.

The effect will dispatch several events on the Camera itself and you can also specify an `onUpdate` callback,
which is invoked each frame for the duration of the effect, if required.


longname: Phaser.Cameras.Scene2D.Effects.Pan
since: 3.11.0
name: Pan
memberof: Phaser.Cameras.Scene2D.Effects
metafilename: Pan.js
metapath: cameras/2d/effects
description:
A Camera Pan effect.

This effect will scroll the Camera so that the center of its viewport finishes at the given destination,
over the duration and with the ease specified.

Only the camera scroll is moved. None of the objects it is displaying are impacted, i.e. their positions do
not change.

The effect will dispatch several events on the Camera itself and you can also specify an `onUpdate` callback,
which is invoked each frame for the duration of the effect if required.


longname: Phaser.Cameras.Scene2D.Effects.RotateTo
since: 3.23.0
name: RotateTo
memberof: Phaser.Cameras.Scene2D.Effects
metafilename: RotateTo.js
metapath: cameras/2d/effects
description:
A Camera Rotate effect.

This effect will rotate the Camera so that the its viewport finishes at the given angle in radians,
over the duration and with the ease specified.

Camera rotation always takes place based on the Camera viewport. By default, rotation happens
in the center of the viewport. You can adjust this with the `originX` and `originY` properties.

Rotation influences the rendering of _all_ Game Objects visible by this Camera. However, it does not
rotate the Camera viewport itself, which always remains an axis-aligned rectangle.

Only the camera is rotates. None of the objects it is displaying are impacted, i.e. their positions do
not change.

The effect will dispatch several events on the Camera itself and you can also specify an `onUpdate` callback,
which is invoked each frame for the duration of the effect if required.


longname: Phaser.Cameras.Scene2D.Effects.Shake
since: 3.5.0
name: Shake
memberof: Phaser.Cameras.Scene2D.Effects
metafilename: Shake.js
metapath: cameras/2d/effects
description:
A Camera Shake effect.

This effect will shake the camera viewport by a random amount, bounded by the specified intensity, each frame.

Only the camera viewport is moved. None of the objects it is displaying are impacted, i.e. their positions do
not change.

The effect will dispatch several events on the Camera itself and you can also specify an `onUpdate` callback,
which is invoked each frame for the duration of the effect if required.


longname: Phaser.Cameras.Scene2D.Effects.Zoom
since: 3.11.0
name: Zoom
memberof: Phaser.Cameras.Scene2D.Effects
metafilename: Zoom.js
metapath: cameras/2d/effects
description:
A Camera Zoom effect.

This effect will zoom the Camera to the given scale, over the duration and with the ease specified.

The effect will dispatch several events on the Camera itself and you can also specify an `onUpdate` callback,
which is invoked each frame for the duration of the effect if required.


longname: Phaser.Cameras.Controls.FixedKeyControl
since: 3.0.0
name: FixedKeyControl
memberof: Phaser.Cameras.Controls
metafilename: FixedKeyControl.js
metapath: cameras/controls
description:
A Fixed Key Camera Control.

This allows you to control the movement and zoom of a camera using the defined keys.

```javascript
var camControl = new FixedKeyControl({
    camera: this.cameras.main,
    left: cursors.left,
    right: cursors.right,
    speed: float OR { x: 0, y: 0 }
});
```

Movement is precise and has no 'smoothing' applied to it.

You must call the `update` method of this controller every frame.


longname: Phaser.Cameras.Controls.SmoothedKeyControl
since: 3.0.0
name: SmoothedKeyControl
memberof: Phaser.Cameras.Controls
metafilename: SmoothedKeyControl.js
metapath: cameras/controls
description:
A Smoothed Key Camera Control.

This allows you to control the movement and zoom of a camera using the defined keys.
Unlike the Fixed Camera Control you can also provide physics values for acceleration, drag and maxSpeed for smoothing effects.

```javascript
var controlConfig = {
    camera: this.cameras.main,
    left: cursors.left,
    right: cursors.right,
    up: cursors.up,
    down: cursors.down,
    zoomIn: this.input.keyboard.addKey(Phaser.Input.Keyboard.KeyCodes.Q),
    zoomOut: this.input.keyboard.addKey(Phaser.Input.Keyboard.KeyCodes.E),
    zoomSpeed: 0.02,
    acceleration: 0.06,
    drag: 0.0005,
    maxSpeed: 1.0
};
```

You must call the `update` method of this controller every frame.


longname: Phaser.Core.Config
since: 3.0.0
name: Config
memberof: Phaser.Core
metafilename: Config.js
metapath: core
description:
The active game configuration settings, parsed from a [Phaser.Types.Core.GameConfig](Phaser.Types.Core.GameConfig) object.


longname: Phaser.Game
since: 3.0.0
name: Game
memberof: Phaser
metafilename: Game.js
metapath: core
description:
The Phaser.Game instance is the main controller for the entire Phaser game. It is responsible
for handling the boot process, parsing the configuration values, creating the renderer,
and setting-up all of the global Phaser systems, such as sound and input.
Once that is complete it will start the Scene Manager and then begin the main game loop.

You should generally avoid accessing any of the systems created by Game, and instead use those
made available to you via the Phaser.Scene Systems class instead.


longname: Phaser.Core.TimeStep
since: 3.0.0
name: TimeStep
memberof: Phaser.Core
metafilename: TimeStep.js
metapath: core
description:
The core runner class that Phaser uses to handle the game loop. It can use either Request Animation Frame,
or SetTimeout, based on browser support and config settings, to create a continuous loop within the browser.

Each time the loop fires, `TimeStep.step` is called and this is then passed onto the core Game update loop,
it is the core heartbeat of your game. It will fire as often as Request Animation Frame is capable of handling
on the target device.

Note that there are lots of situations where a browser will stop updating your game. Such as if the player
switches tabs, or covers up the browser window with another application. In these cases, the 'heartbeat'
of your game will pause, and only resume when focus is returned to it by the player. There is no way to avoid
this situation, all you can do is use the visibility events the browser, and Phaser, provide to detect when
it has happened and then gracefully recover.


longname: Phaser.Curves.Curve
since: 3.0.0
name: Curve
memberof: Phaser.Curves
metafilename: Curve.js
metapath: curves
description:
A Base Curve class, which all other curve types extend.

Based on the three.js Curve classes created by [zz85](http://www.lab4games.net/zz85/blog)


longname: Phaser.Curves.Ellipse
since: 3.0.0
name: Ellipse
memberof: Phaser.Curves
metafilename: EllipseCurve.js
metapath: curves
description:
An Elliptical Curve derived from the Base Curve class.

See [https://en.wikipedia.org/wiki/Elliptic_curve](https://en.wikipedia.org/wiki/Elliptic_curve) for more details.


longname: Phaser.Curves.MoveTo
since: 3.0.0
name: MoveTo
memberof: Phaser.Curves
metafilename: MoveTo.js
metapath: curves/path
description:
A MoveTo Curve is a very simple curve consisting of only a single point.
Its intended use is to move the ending point in a Path.


longname: Phaser.Curves.Path
since: 3.0.0
name: Path
memberof: Phaser.Curves
metafilename: Path.js
metapath: curves/path
description:
A Path combines multiple Curves into one continuous compound curve.
It does not matter how many Curves are in the Path or what type they are.

A Curve in a Path does not have to start where the previous Curve ends - that is to say, a Path does not
have to be an uninterrupted curve. Only the order of the Curves influences the actual points on the Path.


longname: Phaser.Data.DataManager
since: 3.0.0
name: DataManager
memberof: Phaser.Data
metafilename: DataManager.js
metapath: data
description:
The Data Manager Component features a means to store pieces of data specific to a Game Object, System or Plugin.
You can then search, query it, and retrieve the data. The parent must either extend EventEmitter,
or have a property called `events` that is an instance of it.


longname: Phaser.Data.DataManagerPlugin
since: 3.0.0
name: DataManagerPlugin
memberof: Phaser.Data
metafilename: DataManagerPlugin.js
metapath: data
description:
The Data Component features a means to store pieces of data specific to a Game Object, System or Plugin.
You can then search, query it, and retrieve the data. The parent must either extend EventEmitter,
or have a property called `events` that is an instance of it.


longname: Phaser.Display.ColorMatrix
since: 3.50.0
name: ColorMatrix
memberof: Phaser.Display
metafilename: ColorMatrix.js
metapath: display
description:
The ColorMatrix class creates a 5x4 matrix that can be used in shaders and graphics
operations. It provides methods required to modify the color values, such as adjusting
the brightness, setting a sepia tone, hue rotation and more.

Use the method `getData` to return a Float32Array containing the current color values.


longname: Phaser.Display.Masks.BitmapMask
since: 3.0.0
name: BitmapMask
memberof: Phaser.Display.Masks
metafilename: BitmapMask.js
metapath: display/mask
description:
A Bitmap Mask combines the alpha (opacity) of a masked pixel with the alpha of another pixel.
Unlike the Geometry Mask, which is a clipping path, a Bitmap Mask behaves like an alpha mask,
not a clipping path. It is only available when using the WebGL Renderer.

A Bitmap Mask can use any Game Object to determine the alpha of each pixel of the masked Game Object(s).
For any given point of a masked Game Object's texture, the pixel's alpha will be multiplied by the alpha
of the pixel at the same position in the Bitmap Mask's Game Object. The color of the pixel from the
Bitmap Mask doesn't matter.

For example, if a pure blue pixel with an alpha of 0.95 is masked with a pure red pixel with an
alpha of 0.5, the resulting pixel will be pure blue with an alpha of 0.475. Naturally, this means
that a pixel in the mask with an alpha of 0 will hide the corresponding pixel in all masked Game Objects
 A pixel with an alpha of 1 in the masked Game Object will receive the same alpha as the
corresponding pixel in the mask.

Note: You cannot combine Bitmap Masks and Blend Modes on the same Game Object. You can, however,
combine Geometry Masks and Blend Modes together.

The Bitmap Mask's location matches the location of its Game Object, not the location of the
masked objects. Moving or transforming the underlying Game Object will change the mask
(and affect the visibility of any masked objects), whereas moving or transforming a masked object
will not affect the mask.

The Bitmap Mask will not render its Game Object by itself. If the Game Object is not in a
Scene's display list, it will only be used for the mask and its full texture will not be directly
visible. Adding the underlying Game Object to a Scene will not cause any problems - it will
render as a normal Game Object and will also serve as a mask.


longname: Phaser.Display.Masks.GeometryMask
since: 3.0.0
name: GeometryMask
memberof: Phaser.Display.Masks
metafilename: GeometryMask.js
metapath: display/mask
description:
A Geometry Mask can be applied to a Game Object to hide any pixels of it which don't intersect
a visible pixel from the geometry mask. The mask is essentially a clipping path which can only
make a masked pixel fully visible or fully invisible without changing its alpha (opacity).

A Geometry Mask uses a Graphics Game Object to determine which pixels of the masked Game Object(s)
should be clipped. For any given point of a masked Game Object's texture, the pixel will only be displayed
if the Graphics Game Object of the Geometry Mask has a visible pixel at the same position. The color and
alpha of the pixel from the Geometry Mask do not matter.

The Geometry Mask's location matches the location of its Graphics object, not the location of the masked objects.
Moving or transforming the underlying Graphics object will change the mask (and affect the visibility
of any masked objects), whereas moving or transforming a masked object will not affect the mask.
You can think of the Geometry Mask (or rather, of its Graphics object) as an invisible curtain placed
in front of all masked objects which has its own visual properties and, naturally, respects the camera's
visual properties, but isn't affected by and doesn't follow the masked objects by itself.


longname: Phaser.Display.RGB
since: 3.50.0
name: RGB
memberof: Phaser.Display
metafilename: RGB.js
metapath: display
description:
The RGB class holds a single color value and allows for easy modification and reading of it,
with optional on-change callback notification and a dirty flag.


longname: Phaser.Display.BaseShader
since: 3.17.0
name: BaseShader
memberof: Phaser.Display
metafilename: BaseShader.js
metapath: display/shader
description:
A BaseShader is a small resource class that contains the data required for a WebGL Shader to be created.

It contains the raw source code to the fragment and vertex shader, as well as an object that defines
the uniforms the shader requires, if any.

BaseShaders are stored in the Shader Cache, available in a Scene via `this.cache.shaders` and are referenced
by a unique key-based string. Retrieve them via `this.cache.shaders.get(key)`.

BaseShaders are created automatically by the GLSL File Loader when loading an external shader resource.
They can also be created at runtime, allowing you to use dynamically generated shader source code.

Default fragment and vertex source is used if not provided in the constructor, setting-up a basic shader,
suitable for debug rendering.


longname: Phaser.DOM.RequestAnimationFrame
since: 3.0.0
name: RequestAnimationFrame
memberof: Phaser.DOM
metafilename: RequestAnimationFrame.js
metapath: dom
description:
Abstracts away the use of RAF or setTimeOut for the core game update loop.
This is invoked automatically by the Phaser.Game instance.


longname: Phaser.GameObjects.DynamicBitmapText
since: 3.0.0
name: DynamicBitmapText
memberof: Phaser.GameObjects
metafilename: DynamicBitmapText.js
metapath: gameobjects/bitmaptext/dynamic
description:
BitmapText objects work by taking a texture file and an XML or JSON file that describes the font structure.

During rendering for each letter of the text is rendered to the display, proportionally spaced out and aligned to
match the font structure.

Dynamic Bitmap Text objects are different from Static Bitmap Text in that they invoke a callback for each
letter being rendered during the render pass. This callback allows you to manipulate the properties of
each letter being rendered, such as its position, scale or tint, allowing you to create interesting effects
like jiggling text, which can't be done with Static text. This means that Dynamic Text takes more processing
time, so only use them if you require the callback ability they have.

BitmapText objects are less flexible than Text objects, in that they have less features such as shadows, fills and the ability
to use Web Fonts, however you trade this flexibility for rendering speed. You can also create visually compelling BitmapTexts by
processing the font texture in an image editor, applying fills and any other effects required.

To create multi-line text insert \r, \n or \r\n escape codes into the text string.

To create a BitmapText data files you need a 3rd party app such as:

BMFont (Windows, free): [http://www.angelcode.com/products/bmfont/](http://www.angelcode.com/products/bmfont/)
Glyph Designer (OS X, commercial): [http://www.71squared.com/en/glyphdesigner](http://www.71squared.com/en/glyphdesigner)
Littera (Web-based, free): [http://kvazars.com/littera/](http://kvazars.com/littera/)

For most use cases it is recommended to use XML. If you wish to use JSON, the formatting should be equal to the result of
converting a valid XML file through the popular X2JS library. An online tool for conversion can be found here: [http://codebeautify.org/xmltojson](http://codebeautify.org/xmltojson)


longname: Phaser.GameObjects.BitmapText
since: 3.0.0
name: BitmapText
memberof: Phaser.GameObjects
metafilename: BitmapText.js
metapath: gameobjects/bitmaptext/static
description:
BitmapText objects work by taking a texture file and an XML or JSON file that describes the font structure.

During rendering for each letter of the text is rendered to the display, proportionally spaced out and aligned to
match the font structure.

BitmapText objects are less flexible than Text objects, in that they have less features such as shadows, fills and the ability
to use Web Fonts, however you trade this flexibility for rendering speed. You can also create visually compelling BitmapTexts by
processing the font texture in an image editor, applying fills and any other effects required.

To create multi-line text insert \r, \n or \r\n escape codes into the text string.

To create a BitmapText data files you need a 3rd party app such as:

BMFont (Windows, free): [http://www.angelcode.com/products/bmfont/](http://www.angelcode.com/products/bmfont/)
Glyph Designer (OS X, commercial): [http://www.71squared.com/en/glyphdesigner](http://www.71squared.com/en/glyphdesigner)
Littera (Web-based, free): [http://kvazars.com/littera/](http://kvazars.com/littera/)

For most use cases it is recommended to use XML. If you wish to use JSON, the formatting should be equal to the result of
converting a valid XML file through the popular X2JS library. An online tool for conversion can be found here: [http://codebeautify.org/xmltojson](http://codebeautify.org/xmltojson)


longname: Phaser.GameObjects.Blitter
since: 3.0.0
name: Blitter
memberof: Phaser.GameObjects
metafilename: Blitter.js
metapath: gameobjects/blitter
description:
A Blitter Game Object.

The Blitter Game Object is a special kind of container that creates, updates and manages Bob objects.
Bobs are designed for rendering speed rather than flexibility. They consist of a texture, or frame from a texture,
a position and an alpha value. You cannot scale or rotate them. They use a batched drawing method for speed
during rendering.

A Blitter Game Object has one texture bound to it. Bobs created by the Blitter can use any Frame from this
Texture to render with, but they cannot use any other Texture. It is this single texture-bind that allows
them their speed.

If you have a need to blast a large volume of frames around the screen then Blitter objects are well worth
investigating. They are especially useful for using as a base for your own special effects systems.


longname: Phaser.GameObjects.Bob
since: 3.0.0
name: Bob
memberof: Phaser.GameObjects
metafilename: Bob.js
metapath: gameobjects/blitter
description:
A Bob Game Object.

A Bob belongs to a Blitter Game Object. The Blitter is responsible for managing and rendering this object.

A Bob has a position, alpha value and a frame from a texture that it uses to render with. You can also toggle
the flipped and visible state of the Bob. The Frame the Bob uses to render can be changed dynamically, but it
must be a Frame within the Texture used by the parent Blitter.

Bob positions are relative to the Blitter parent. So if you move the Blitter parent, all Bob children will
have their positions impacted by this change as well.

You can manipulate Bob objects directly from your game code, but the creation and destruction of them should be
handled via the Blitter parent.


longname: Phaser.GameObjects.Components.TransformMatrix
since: 3.0.0
name: TransformMatrix
memberof: Phaser.GameObjects.Components
metafilename: TransformMatrix.js
metapath: gameobjects/components
description:
A Matrix used for display transformations for rendering.

It is represented like so:

```
| a | c | tx |
| b | d | ty |
| 0 | 0 | 1  |
```


longname: Phaser.GameObjects.Container
since: 3.4.0
name: Container
memberof: Phaser.GameObjects
metafilename: Container.js
metapath: gameobjects/container
description:
A Container Game Object.

A Container, as the name implies, can 'contain' other types of Game Object.
When a Game Object is added to a Container, the Container becomes responsible for the rendering of it.
By default it will be removed from the Display List and instead added to the Containers own internal list.

The position of the Game Object automatically becomes relative to the position of the Container.

The transform point of a Container is 0x0 (in local space) and that cannot be changed. The children you add to the
Container should be positioned with this value in mind. I.e. you should treat 0x0 as being the center of
the Container, and position children positively and negative around it as required.

When the Container is rendered, all of its children are rendered as well, in the order in which they exist
within the Container. Container children can be repositioned using methods such as `MoveUp`, `MoveDown` and `SendToBack`.

If you modify a transform property of the Container, such as `Container.x` or `Container.rotation` then it will
automatically influence all children as well.

Containers can include other Containers for deeply nested transforms.

Containers can have masks set on them and can be used as a mask too. However, Container children cannot be masked.
The masks do not 'stack up'. Only a Container on the root of the display list will use its mask.

Containers can be enabled for input. Because they do not have a texture you need to provide a shape for them
to use as their hit area. Container children can also be enabled for input, independent of the Container.

If input enabling a _child_ you should not set both the `origin` and a **negative** scale factor on the child,
or the input area will become misaligned.

Containers can be given a physics body for either Arcade Physics, Impact Physics or Matter Physics. However,
if Container _children_ are enabled for physics you may get unexpected results, such as offset bodies,
if the Container itself, or any of its ancestors, is positioned anywhere other than at 0 x 0. Container children
with physics do not factor in the Container due to the excessive extra calculations needed. Please structure
your game to work around this.

It's important to understand the impact of using Containers. They add additional processing overhead into
every one of their children. The deeper you nest them, the more the cost escalates. This is especially true
for input events. You also loose the ability to set the display depth of Container children in the same
flexible manner as those not within them. In short, don't use them for the sake of it. You pay a small cost
every time you create one, try to structure your game around avoiding that where possible.


longname: Phaser.GameObjects.DisplayList
since: 3.0.0
name: DisplayList
memberof: Phaser.GameObjects
metafilename: DisplayList.js
metapath: gameobjects
description:
The Display List plugin.

Display Lists belong to a Scene and maintain the list of Game Objects to render every frame.

Some of these Game Objects may also be part of the Scene's [Update List](Phaser.GameObjects.UpdateList), for updating.


longname: Phaser.GameObjects.DOMElement
since: 3.17.0
name: DOMElement
memberof: Phaser.GameObjects
metafilename: DOMElement.js
metapath: gameobjects/domelement
description:
DOM Element Game Objects are a way to control and manipulate HTML Elements over the top of your game.

In order for DOM Elements to display you have to enable them by adding the following to your game
configuration object:

```javascript
dom {
  createContainer: true
}
```

When this is added, Phaser will automatically create a DOM Container div that is positioned over the top
of the game canvas. This div is sized to match the canvas, and if the canvas size changes, as a result of
settings within the Scale Manager, the dom container is resized accordingly.

If you have not already done so, you have to provide a `parent` in the Game Configuration, or the DOM
Container will fail to be created.

You can create a DOM Element by either passing in DOMStrings, or by passing in a reference to an existing
Element that you wish to be placed under the control of Phaser. For example:

```javascript
this.add.dom(x, y, 'div', 'background-color: lime; width: 220px; height: 100px; font: 48px Arial', 'Phaser');
```

The above code will insert a div element into the DOM Container at the given x/y coordinate. The DOMString in
the 4th argument sets the initial CSS style of the div and the final argument is the inner text. In this case,
it will create a lime colored div that is 220px by 100px in size with the text Phaser in it, in an Arial font.

You should nearly always, without exception, use explicitly sized HTML Elements, in order to fully control
alignment and positioning of the elements next to regular game content.

Rather than specify the CSS and HTML directly you can use the `load.html` File Loader to load it into the
cache and then use the `createFromCache` method instead. You can also use `createFromHTML` and various other
methods available in this class to help construct your elements.

Once the element has been created you can then control it like you would any other Game Object. You can set its
position, scale, rotation, alpha and other properties. It will move as the main Scene Camera moves and be clipped
at the edge of the canvas. It's important to remember some limitations of DOM Elements: The obvious one is that
they appear above or below your game canvas. You cannot blend them into the display list, meaning you cannot have
a DOM Element, then a Sprite, then another DOM Element behind it.

They also cannot be enabled for input. To do that, you have to use the `addListener` method to add native event
listeners directly. The final limitation is to do with cameras. The DOM Container is sized to match the game canvas
entirely and clipped accordingly. DOM Elements respect camera scrolling and scrollFactor settings, but if you
change the size of the camera so it no longer matches the size of the canvas, they won't be clipped accordingly.

Also, all DOM Elements are inserted into the same DOM Container, regardless of which Scene they are created in.

Note that you should only have DOM Elements in a Scene with a _single_ Camera. If you require multiple cameras,
use parallel scenes to achieve this.

DOM Elements are a powerful way to align native HTML with your Phaser Game Objects. For example, you can insert
a login form for a multiplayer game directly into your title screen. Or a text input box for a highscore table.
Or a banner ad from a 3rd party service. Or perhaps you'd like to use them for high resolution text display and
UI. The choice is up to you, just remember that you're dealing with standard HTML and CSS floating over the top
of your game, and should treat it accordingly.


longname: Phaser.GameObjects.Extern
since: 3.16.0
name: Extern
memberof: Phaser.GameObjects
metafilename: Extern.js
metapath: gameobjects/extern
description:
An Extern Game Object is a special type of Game Object that allows you to pass
rendering off to a 3rd party.

When you create an Extern and place it in the display list of a Scene, the renderer will
process the list as usual. When it finds an Extern it will flush the current batch,
clear down the pipeline and prepare a transform matrix which your render function can
take advantage of, if required.

The WebGL context is then left in a 'clean' state, ready for you to bind your own shaders,
or draw to it, whatever you wish to do. This should all take place in the `render` method.
The correct way to deploy an Extern object is to create a class that extends it, then
override the `render` (and optionally `preUpdate`) methods and pass off control to your
3rd party libraries or custom WebGL code there.

Once you've finished, you should free-up any of your resources.
The Extern will then rebind the Phaser pipeline and carry on rendering the display list.

Although this object has lots of properties such as Alpha, Blend Mode and Tint, none of
them are used during rendering unless you take advantage of them in your own render code.


longname: Phaser.GameObjects.GameObject
since: 3.0.0
name: GameObject
memberof: Phaser.GameObjects
metafilename: GameObject.js
metapath: gameobjects
description:
The base class that all Game Objects extend.
You don't create GameObjects directly and they cannot be added to the display list.
Instead, use them as the base for your own custom classes.


longname: Phaser.GameObjects.GameObjectCreator
since: 3.0.0
name: GameObjectCreator
memberof: Phaser.GameObjects
metafilename: GameObjectCreator.js
metapath: gameobjects
description:
The Game Object Creator is a Scene plugin that allows you to quickly create many common
types of Game Objects and return them. Unlike the Game Object Factory, they are not automatically
added to the Scene.

Game Objects directly register themselves with the Creator and inject their own creation
methods into the class.


longname: Phaser.GameObjects.GameObjectFactory
since: 3.0.0
name: GameObjectFactory
memberof: Phaser.GameObjects
metafilename: GameObjectFactory.js
metapath: gameobjects
description:
The Game Object Factory is a Scene plugin that allows you to quickly create many common
types of Game Objects and have them automatically registered with the Scene.

Game Objects directly register themselves with the Factory and inject their own creation
methods into the class.


longname: Phaser.GameObjects.Graphics
since: 3.0.0
name: Graphics
memberof: Phaser.GameObjects
metafilename: Graphics.js
metapath: gameobjects/graphics
description:
A Graphics object is a way to draw primitive shapes to your game. Primitives include forms of geometry, such as
Rectangles, Circles, and Polygons. They also include lines, arcs and curves. When you initially create a Graphics
object it will be empty.

To draw to it you must first specify a line style or fill style (or both), draw shapes using paths, and finally
fill or stroke them. For example:

```javascript
graphics.lineStyle(5, 0xFF00FF, 1.0);
graphics.beginPath();
graphics.moveTo(100, 100);
graphics.lineTo(200, 200);
graphics.closePath();
graphics.strokePath();
```

There are also many helpful methods that draw and fill/stroke common shapes for you.

```javascript
graphics.lineStyle(5, 0xFF00FF, 1.0);
graphics.fillStyle(0xFFFFFF, 1.0);
graphics.fillRect(50, 50, 400, 200);
graphics.strokeRect(50, 50, 400, 200);
```

When a Graphics object is rendered it will render differently based on if the game is running under Canvas or WebGL.
Under Canvas it will use the HTML Canvas context drawing operations to draw the path.
Under WebGL the graphics data is decomposed into polygons. Both of these are expensive processes, especially with
complex shapes.

If your Graphics object doesn't change much (or at all) once you've drawn your shape to it, then you will help
performance by calling [Phaser.GameObjects.Graphics#generateTexture](Phaser.GameObjects.Graphics#generateTexture). This will 'bake' the Graphics object into
a Texture, and return it. You can then use this Texture for Sprites or other display objects. If your Graphics object
updates frequently then you should avoid doing this, as it will constantly generate new textures, which will consume
memory.

As you can tell, Graphics objects are a bit of a trade-off. While they are extremely useful, you need to be careful
in their complexity and quantity of them in your game.


longname: Phaser.GameObjects.Group
since: 3.0.0
name: Group
memberof: Phaser.GameObjects
metafilename: Group.js
metapath: gameobjects/group
description:
A Group is a way for you to create, manipulate, or recycle similar Game Objects.

Group membership is non-exclusive. A Game Object can belong to several groups, one group, or none.

Groups themselves aren't displayable, and can't be positioned, rotated, scaled, or hidden.


longname: Phaser.GameObjects.Image
since: 3.0.0
name: Image
memberof: Phaser.GameObjects
metafilename: Image.js
metapath: gameobjects/image
description:
An Image Game Object.

An Image is a light-weight Game Object useful for the display of static images in your game,
such as logos, backgrounds, scenery or other non-animated elements. Images can have input
events and physics bodies, or be tweened, tinted or scrolled. The main difference between an
Image and a Sprite is that you cannot animate an Image as they do not have the Animation component.


longname: Phaser.GameObjects.Layer
since: 3.50.0
name: Layer
memberof: Phaser.GameObjects
metafilename: Layer.js
metapath: gameobjects/layer
description:
A Layer Game Object.

A Layer is a special type of Game Object that acts as a Display List. You can add any type of Game Object
to a Layer, just as you would to a Scene. Layers can be used to visually group together 'layers' of Game
Objects:

```javascript
const spaceman = this.add.sprite(150, 300, 'spaceman');
const bunny = this.add.sprite(400, 300, 'bunny');
const elephant = this.add.sprite(650, 300, 'elephant');

const layer = this.add.layer();

layer.add([ spaceman, bunny, elephant ]);
```

The 3 sprites in the example above will now be managed by the Layer they were added to. Therefore,
if you then set `layer.setVisible(false)` they would all vanish from the display.

You can also control the depth of the Game Objects within the Layer. For example, calling the
`setDepth` method of a child of a Layer will allow you to adjust the depth of that child _within the
Layer itself_, rather than the whole Scene. The Layer, too, can have its depth set as well.

The Layer class also offers many different methods for manipulating the list, such as the
methods `moveUp`, `moveDown`, `sendToBack`, `bringToTop` and so on. These allow you to change the
display list position of the Layers children, causing it to adjust the order in which they are
rendered. Using `setDepth` on a child allows you to override this.

Layers can have Post FX Pipelines set, which allows you to easily enable a post pipeline across
a whole range of children, which, depending on the effect, can often be far more efficient that doing so
on a per-child basis.

Layers have no position or size within the Scene. This means you cannot enable a Layer for
physics or input, or change the position, rotation or scale of a Layer. They also have no scroll
factor, texture, tint, origin, crop or bounds.

If you need those kind of features then you should use a Container instead. Containers can be added
to Layers, but Layers cannot be added to Containers.

However, you can set the Alpha, Blend Mode, Depth, Mask and Visible state of a Layer. These settings
will impact all children being rendered by the Layer.


longname: Phaser.GameObjects.Light
since: 3.0.0
name: Light
memberof: Phaser.GameObjects
metafilename: Light.js
metapath: gameobjects/lights
description:
A 2D point light.

These are typically created by a [Phaser.GameObjects.LightsManager](Phaser.GameObjects.LightsManager), available from within a scene via `this.lights`.

Any Game Objects using the Light2D pipeline will then be affected by these Lights as long as they have a normal map.

They can also simply be used to represent a point light for your own purposes.


longname: Phaser.GameObjects.LightsPlugin
since: 3.0.0
name: LightsPlugin
memberof: Phaser.GameObjects
metafilename: LightsPlugin.js
metapath: gameobjects/lights
description:
A Scene plugin that provides a [Phaser.GameObjects.LightsManager](Phaser.GameObjects.LightsManager) for the Light2D pipeline.

Available from within a Scene via `this.lights`.

Add Lights using the [Phaser.GameObjects.LightsManager#addLight](Phaser.GameObjects.LightsManager#addLight) method:

```javascript
// Enable the Lights Manager because it is disabled by default
this.lights.enable();

// Create a Light at [400, 300] with a radius of 200
this.lights.addLight(400, 300, 200);
```

For Game Objects to be affected by the Lights when rendered, you will need to set them to use the `Light2D` pipeline like so:

```javascript
sprite.setPipeline('Light2D');
```

Note that you cannot use this pipeline on Graphics Game Objects or Shape Game Objects.


longname: Phaser.GameObjects.Mesh
since: 3.0.0
name: Mesh
memberof: Phaser.GameObjects
metafilename: Mesh.js
metapath: gameobjects/mesh
description:
A Mesh Game Object.

The Mesh Game Object allows you to render a group of textured vertices and manipulate
the view of those vertices, such as rotation, translation or scaling.

Support for generating mesh data from grids, model data or Wavefront OBJ Files is included.

Although you can use this to render 3D objects, its primary use is for displaying more complex
Sprites, or Sprites where you need fine-grained control over the vertex positions in order to
achieve special effects in your games. Note that rendering still takes place using Phaser's
orthographic camera (after being transformed via `projectionMesh`, see `setPerspective`,
`setOrtho`, and `panZ` methods). As a result, all depth and face tests are done in an eventually
orthographic space.

The rendering process will iterate through the faces of this Mesh and render out each face
that is considered as being in view of the camera. No depth buffer is used, and because of this,
you should be careful not to use model data with too many vertices, or overlapping geometry,
or you'll probably encounter z-depth fighting. The Mesh was designed to allow for more advanced
2D layouts, rather than displaying 3D objects, even though it can do this to a degree.

In short, if you want to remake Crysis, use a 3D engine, not a Mesh. However, if you want
to easily add some small fun 3D elements into your game, or create some special effects involving
vertex warping, this is the right object for you. Mesh data becomes part of the WebGL batch,
just like standard Sprites, so doesn't introduce any additional shader overhead. Because
the Mesh just generates vertices into the WebGL batch, like any other Sprite, you can use all of
the common Game Object components on a Mesh too, such as a custom pipeline, mask, blend mode
or texture.

Note that the Mesh object is WebGL only and does not have a Canvas counterpart.

The Mesh origin is always 0.5 x 0.5 and cannot be changed.


longname: Phaser.GameObjects.Particles.EmitterOp
since: 3.0.0
name: EmitterOp
memberof: Phaser.GameObjects.Particles
metafilename: EmitterOp.js
metapath: gameobjects/particles
description:
A Particle Emitter property.

Facilitates changing Particle properties as they are emitted and throughout their lifetime.


longname: Phaser.GameObjects.Particles.GravityWell
since: 3.0.0
name: GravityWell
memberof: Phaser.GameObjects.Particles
metafilename: GravityWell.js
metapath: gameobjects/particles
description:
The GravityWell action applies a force on the particle to draw it towards, or repel it from, a single point.

The force applied is inversely proportional to the square of the distance from the particle to the point, in accordance with Newton's law of gravity.

This simulates the effect of gravity over large distances (as between planets, for example).


longname: Phaser.GameObjects.Particles.Particle
since: 3.0.0
name: Particle
memberof: Phaser.GameObjects.Particles
metafilename: Particle.js
metapath: gameobjects/particles
description:
A Particle is a simple Game Object controlled by a Particle Emitter and Manager, and rendered by the Manager.
It uses its own lightweight physics system, and can interact only with its Emitter's bounds and zones.


longname: Phaser.GameObjects.Particles.ParticleEmitter
since: 3.0.0
name: ParticleEmitter
memberof: Phaser.GameObjects.Particles
metafilename: ParticleEmitter.js
metapath: gameobjects/particles
description:
A particle emitter represents a single particle stream.
It controls a pool of [Particles](Phaser.GameObjects.Particles.Particle) and is controlled by a [Particle](Phaser.GameObjects.Particles.ParticleEmitterManager).


longname: Phaser.GameObjects.Particles.ParticleEmitterManager
since: 3.0.0
name: ParticleEmitterManager
memberof: Phaser.GameObjects.Particles
metafilename: ParticleEmitterManager.js
metapath: gameobjects/particles
description:
A Particle Emitter Manager creates and controls [Particle](Phaser.GameObjects.Particles.ParticleEmitter) and [Gravity](Phaser.GameObjects.Particles.GravityWell).


longname: Phaser.GameObjects.Particles.Zones.DeathZone
since: 3.0.0
name: DeathZone
memberof: Phaser.GameObjects.Particles.Zones
metafilename: DeathZone.js
metapath: gameobjects/particles/zones
description:
A Death Zone.

A Death Zone is a special type of zone that will kill a Particle as soon as it either enters, or leaves, the zone.

The zone consists of a `source` which could be a Geometric shape, such as a Rectangle or Ellipse, or your own
object as long as it includes a `contains` method for which the Particles can be tested against.


longname: Phaser.GameObjects.PathFollower
since: 3.0.0
name: PathFollower
memberof: Phaser.GameObjects
metafilename: PathFollower.js
metapath: gameobjects/pathfollower
description:
A PathFollower Game Object.

A PathFollower is a Sprite Game Object with some extra helpers to allow it to follow a Path automatically.

Anything you can do with a standard Sprite can be done with this PathFollower, such as animate it, tint it,
scale it and so on.

PathFollowers are bound to a single Path at any one time and can traverse the length of the Path, from start
to finish, forwards or backwards, or from any given point on the Path to its end. They can optionally rotate
to face the direction of the path, be offset from the path coordinates or rotate independently of the Path.


longname: Phaser.GameObjects.PointLight
since: 3.50.0
name: PointLight
memberof: Phaser.GameObjects
metafilename: PointLight.js
metapath: gameobjects/pointlight
description:
The Point Light Game Object provides a way to add a point light effect into your game,
without the expensive shader processing requirements of the traditional Light Game Object.

The difference is that the Point Light renders using a custom shader, designed to give the
impression of a point light source, of variable radius, intensity and color, in your game.
However, unlike the Light Game Object, it does not impact any other Game Objects, or use their
normal maps for calcuations. This makes them extremely fast to render compared to Lights
and perfect for special effects, such as flickering torches or muzzle flashes.

For maximum performance you should batch Point Light Game Objects together. This means
ensuring they follow each other consecutively on the display list. Ideally, use a Layer
Game Object and then add just Point Lights to it, so that it can batch together the rendering
of the lights. You don't _have_ to do this, and if you've only a handful of Point Lights in
your game then it's perfectly safe to mix them into the dislay list as normal. However, if
you're using a large number of them, please consider how they are mixed into the display list.

The renderer will automatically cull Point Lights. Those with a radius that does not intersect
with the Camera will be skipped in the rendering list. This happens automatically and the
culled state is refreshed every frame, for every camera.

The origin of a Point Light is always 0.5 and it cannot be changed.

Point Lights are a WebGL only feature and do not have a Canvas counterpart.


longname: Phaser.GameObjects.RenderTexture
since: 3.2.0
name: RenderTexture
memberof: Phaser.GameObjects
metafilename: RenderTexture.js
metapath: gameobjects/rendertexture
description:
A Render Texture.

A Render Texture is a special texture that allows any number of Game Objects to be drawn to it. You can take many complex objects and
draw them all to this one texture, which can they be used as the texture for other Game Object's. It's a way to generate dynamic
textures at run-time that are WebGL friendly and don't invoke expensive GPU uploads.

Note that under WebGL a FrameBuffer, which is what the Render Texture uses internally, cannot be anti-aliased. This means
that when drawing objects such as Shapes to a Render Texture they will appear to be drawn with no aliasing, however this
is a technical limitation of WebGL. To get around it, create your shape as a texture in an art package, then draw that
to the Render Texture.


longname: Phaser.GameObjects.Rope
since: 3.23.0
name: Rope
memberof: Phaser.GameObjects
metafilename: Rope.js
metapath: gameobjects/rope
description:
A Rope Game Object.

The Rope object is WebGL only and does not have a Canvas counterpart.

A Rope is a special kind of Game Object that has a texture that repeats along its entire length.
Unlike a Sprite, it isn't restricted to using just a quad and can have as many vertices as you define
when creating it. The vertices can be arranged in a horizontal or vertical strip and have their own
color and alpha values as well.

A Ropes origin is always 0.5 x 0.5 and cannot be changed.


longname: Phaser.GameObjects.Shader
since: 3.17.0
name: Shader
memberof: Phaser.GameObjects
metafilename: Shader.js
metapath: gameobjects/shader
description:
A Shader Game Object.

This Game Object allows you to easily add a quad with its own shader into the display list, and manipulate it
as you would any other Game Object, including scaling, rotating, positioning and adding to Containers. Shaders
can be masked with either Bitmap or Geometry masks and can also be used as a Bitmap Mask for a Camera or other
Game Object. They can also be made interactive and used for input events.

It works by taking a reference to a `Phaser.Display.BaseShader` instance, as found in the Shader Cache. These can
be created dynamically at runtime, or loaded in via the GLSL File Loader:

```javascript
function preload ()
{
    this.load.glsl('fire', 'shaders/fire.glsl.js');
}

function create ()
{
    this.add.shader('fire', 400, 300, 512, 512);
}
```

Please see the Phaser 3 Examples GitHub repo for examples of loading and creating shaders dynamically.

Due to the way in which they work, you cannot directly change the alpha or blend mode of a Shader. This should
be handled via exposed uniforms in the shader code itself.

By default a Shader will be created with a standard set of uniforms. These were added to match those
found on sites such as ShaderToy or GLSLSandbox, and provide common functionality a shader may need,
such as the timestamp, resolution or pointer position. You can replace them by specifying your own uniforms
in the Base Shader.

These Shaders work by halting the current pipeline during rendering, creating a viewport matched to the
size of this Game Object and then renders a quad using the bound shader. At the end, the pipeline is restored.

Because it blocks the pipeline it means it will interrupt any batching that is currently going on, so you should
use these Game Objects sparingly. If you need to have a fully batched custom shader, then please look at using
a custom pipeline instead. However, for background or special masking effects, they are extremely effective.


longname: Phaser.GameObjects.Arc
since: 3.13.0
name: Arc
memberof: Phaser.GameObjects
metafilename: Arc.js
metapath: gameobjects/shape/arc
description:
The Arc Shape is a Game Object that can be added to a Scene, Group or Container. You can
treat it like any other Game Object in your game, such as tweening it, scaling it, or enabling
it for input or physics. It provides a quick and easy way for you to render this shape in your
game without using a texture, while still taking advantage of being fully batched in WebGL.

This shape supports both fill and stroke colors.

When it renders it displays an arc shape. You can control the start and end angles of the arc,
as well as if the angles are winding clockwise or anti-clockwise. With the default settings
it renders as a complete circle. By changing the angles you can create other arc shapes,
such as half-circles.

Arcs also have an `iterations` property and corresponding `setIterations` method. This allows
you to control how smooth the shape renders in WebGL, by controlling the number of iterations
that take place during construction.


longname: Phaser.GameObjects.Curve
since: 3.13.0
name: Curve
memberof: Phaser.GameObjects
metafilename: Curve.js
metapath: gameobjects/shape/curve
description:
The Curve Shape is a Game Object that can be added to a Scene, Group or Container. You can
treat it like any other Game Object in your game, such as tweening it, scaling it, or enabling
it for input or physics. It provides a quick and easy way for you to render this shape in your
game without using a texture, while still taking advantage of being fully batched in WebGL.

This shape supports both fill and stroke colors.

To render a Curve Shape you must first create a `Phaser.Curves.Curve` object, then pass it to
the Curve Shape in the constructor.

The Curve shape also has a `smoothness` property and corresponding `setSmoothness` method.
This allows you to control how smooth the shape renders in WebGL, by controlling the number of iterations
that take place during construction. Increase and decrease the default value for smoother, or more
jagged, shapes.


longname: Phaser.GameObjects.Ellipse
since: 3.13.0
name: Ellipse
memberof: Phaser.GameObjects
metafilename: Ellipse.js
metapath: gameobjects/shape/ellipse
description:
The Ellipse Shape is a Game Object that can be added to a Scene, Group or Container. You can
treat it like any other Game Object in your game, such as tweening it, scaling it, or enabling
it for input or physics. It provides a quick and easy way for you to render this shape in your
game without using a texture, while still taking advantage of being fully batched in WebGL.

This shape supports both fill and stroke colors.

When it renders it displays an ellipse shape. You can control the width and height of the ellipse.
If the width and height match it will render as a circle. If the width is less than the height,
it will look more like an egg shape.

The Ellipse shape also has a `smoothness` property and corresponding `setSmoothness` method.
This allows you to control how smooth the shape renders in WebGL, by controlling the number of iterations
that take place during construction. Increase and decrease the default value for smoother, or more
jagged, shapes.


longname: Phaser.GameObjects.Grid
since: 3.13.0
name: Grid
memberof: Phaser.GameObjects
metafilename: Grid.js
metapath: gameobjects/shape/grid
description:
The Grid Shape is a Game Object that can be added to a Scene, Group or Container. You can
treat it like any other Game Object in your game, such as tweening it, scaling it, or enabling
it for input or physics. It provides a quick and easy way for you to render this shape in your
game without using a texture, while still taking advantage of being fully batched in WebGL.

This shape supports only fill colors and cannot be stroked.

A Grid Shape allows you to display a grid in your game, where you can control the size of the
grid as well as the width and height of the grid cells. You can set a fill color for each grid
cell as well as an alternate fill color. When the alternate fill color is set then the grid
cells will alternate the fill colors as they render, creating a chess-board effect. You can
also optionally have an outline fill color. If set, this draws lines between the grid cells
in the given color. If you specify an outline color with an alpha of zero, then it will draw
the cells spaced out, but without the lines between them.


longname: Phaser.GameObjects.IsoBox
since: 3.13.0
name: IsoBox
memberof: Phaser.GameObjects
metafilename: IsoBox.js
metapath: gameobjects/shape/isobox
description:
The IsoBox Shape is a Game Object that can be added to a Scene, Group or Container. You can
treat it like any other Game Object in your game, such as tweening it, scaling it, or enabling
it for input or physics. It provides a quick and easy way for you to render this shape in your
game without using a texture, while still taking advantage of being fully batched in WebGL.

This shape supports only fill colors and cannot be stroked.

An IsoBox is an 'isometric' rectangle. Each face of it has a different fill color. You can set
the color of the top, left and right faces of the rectangle respectively. You can also choose
which of the faces are rendered via the `showTop`, `showLeft` and `showRight` properties.

You cannot view an IsoBox from under-neath, however you can change the 'angle' by setting
the `projection` property.


longname: Phaser.GameObjects.IsoTriangle
since: 3.13.0
name: IsoTriangle
memberof: Phaser.GameObjects
metafilename: IsoTriangle.js
metapath: gameobjects/shape/isotriangle
description:
The IsoTriangle Shape is a Game Object that can be added to a Scene, Group or Container. You can
treat it like any other Game Object in your game, such as tweening it, scaling it, or enabling
it for input or physics. It provides a quick and easy way for you to render this shape in your
game without using a texture, while still taking advantage of being fully batched in WebGL.

This shape supports only fill colors and cannot be stroked.

An IsoTriangle is an 'isometric' triangle. Think of it like a pyramid. Each face has a different
fill color. You can set the color of the top, left and right faces of the triangle respectively
You can also choose which of the faces are rendered via the `showTop`, `showLeft` and `showRight` properties.

You cannot view an IsoTriangle from under-neath, however you can change the 'angle' by setting
the `projection` property. The `reversed` property controls if the IsoTriangle is rendered upside
down or not.


longname: Phaser.GameObjects.Line
since: 3.13.0
name: Line
memberof: Phaser.GameObjects
metafilename: Line.js
metapath: gameobjects/shape/line
description:
The Line Shape is a Game Object that can be added to a Scene, Group or Container. You can
treat it like any other Game Object in your game, such as tweening it, scaling it, or enabling
it for input or physics. It provides a quick and easy way for you to render this shape in your
game without using a texture, while still taking advantage of being fully batched in WebGL.

This shape supports only stroke colors and cannot be filled.

A Line Shape allows you to draw a line between two points in your game. You can control the
stroke color and thickness of the line. In WebGL only you can also specify a different
thickness for the start and end of the line, allowing you to render lines that taper-off.

If you need to draw multiple lines in a sequence you may wish to use the Polygon Shape instead.

Be aware that as with all Game Objects the default origin is 0.5. If you need to draw a Line
between two points and want the x1/y1 values to match the x/y values, then set the origin to 0.


longname: Phaser.GameObjects.Polygon
since: 3.13.0
name: Polygon
memberof: Phaser.GameObjects
metafilename: Polygon.js
metapath: gameobjects/shape/polygon
description:
The Polygon Shape is a Game Object that can be added to a Scene, Group or Container. You can
treat it like any other Game Object in your game, such as tweening it, scaling it, or enabling
it for input or physics. It provides a quick and easy way for you to render this shape in your
game without using a texture, while still taking advantage of being fully batched in WebGL.

This shape supports both fill and stroke colors.

The Polygon Shape is created by providing a list of points, which are then used to create an
internal Polygon geometry object. The points can be set from a variety of formats:

- A string containing paired values separated by a single space: `'40 0 40 20 100 20 100 80 40 80 40 100 0 50'`
- An array of Point or Vector2 objects: `[new Phaser.Math.Vector2(x1, y1), ...]`
- An array of objects with public x/y properties: `[obj1, obj2, ...]`
- An array of paired numbers that represent point coordinates: `[x1,y1, x2,y2, ...]`
- An array of arrays with two elements representing x/y coordinates: `[[x1, y1], [x2, y2], ...]`

By default the `x` and `y` coordinates of this Shape refer to the center of it. However, depending
on the coordinates of the points provided, the final shape may be rendered offset from its origin.


longname: Phaser.GameObjects.Rectangle
since: 3.13.0
name: Rectangle
memberof: Phaser.GameObjects
metafilename: Rectangle.js
metapath: gameobjects/shape/rectangle
description:
The Rectangle Shape is a Game Object that can be added to a Scene, Group or Container. You can
treat it like any other Game Object in your game, such as tweening it, scaling it, or enabling
it for input or physics. It provides a quick and easy way for you to render this shape in your
game without using a texture, while still taking advantage of being fully batched in WebGL.

This shape supports both fill and stroke colors.

You can change the size of the rectangle by changing the `width` and `height` properties.


longname: Phaser.GameObjects.Shape
since: 3.13.0
name: Shape
memberof: Phaser.GameObjects
metafilename: Shape.js
metapath: gameobjects/shape
description:
The Shape Game Object is a base class for the various different shapes, such as the Arc, Star or Polygon.
You cannot add a Shape directly to your Scene, it is meant as a base for your own custom Shape classes.


longname: Phaser.GameObjects.Star
since: 3.13.0
name: Star
memberof: Phaser.GameObjects
metafilename: Star.js
metapath: gameobjects/shape/star
description:
The Star Shape is a Game Object that can be added to a Scene, Group or Container. You can
treat it like any other Game Object in your game, such as tweening it, scaling it, or enabling
it for input or physics. It provides a quick and easy way for you to render this shape in your
game without using a texture, while still taking advantage of being fully batched in WebGL.

This shape supports both fill and stroke colors.

As the name implies, the Star shape will display a star in your game. You can control several
aspects of it including the number of points that constitute the star. The default is 5. If
you change it to 4 it will render as a diamond. If you increase them, you'll get a more spiky
star shape.

You can also control the inner and outer radius, which is how 'long' each point of the star is.
Modify these values to create more interesting shapes.


longname: Phaser.GameObjects.Triangle
since: 3.13.0
name: Triangle
memberof: Phaser.GameObjects
metafilename: Triangle.js
metapath: gameobjects/shape/triangle
description:
The Triangle Shape is a Game Object that can be added to a Scene, Group or Container. You can
treat it like any other Game Object in your game, such as tweening it, scaling it, or enabling
it for input or physics. It provides a quick and easy way for you to render this shape in your
game without using a texture, while still taking advantage of being fully batched in WebGL.

This shape supports both fill and stroke colors.

The Triangle consists of 3 lines, joining up to form a triangular shape. You can control the
position of each point of these lines. The triangle is always closed and cannot have an open
face. If you require that, consider using a Polygon instead.


longname: Phaser.GameObjects.Sprite
since: 3.0.0
name: Sprite
memberof: Phaser.GameObjects
metafilename: Sprite.js
metapath: gameobjects/sprite
description:
A Sprite Game Object.

A Sprite Game Object is used for the display of both static and animated images in your game.
Sprites can have input events and physics bodies. They can also be tweened, tinted, scrolled
and animated.

The main difference between a Sprite and an Image Game Object is that you cannot animate Images.
As such, Sprites take a fraction longer to process and have a larger API footprint due to the Animation
Component. If you do not require animation then you can safely use Images to replace Sprites in all cases.


longname: Phaser.GameObjects.Text
since: 3.0.0
name: Text
memberof: Phaser.GameObjects
metafilename: Text.js
metapath: gameobjects/text
description:
A Text Game Object.

Text objects work by creating their own internal hidden Canvas and then renders text to it using
the standard Canvas `fillText` API. It then creates a texture from this canvas which is rendered
to your game during the render pass.

Because it uses the Canvas API you can take advantage of all the features this offers, such as
applying gradient fills to the text, or strokes, shadows and more. You can also use custom fonts
loaded externally, such as Google or TypeKit Web fonts.

**Important:** The font name must be quoted if it contains certain combinations of digits or
special characters, either when creating the Text object, or when setting the font via `setFont`
or `setFontFamily`, e.g.:

```javascript
this.add.text(0, 0, 'Hello World', { fontFamily: 'Georgia, "Goudy Bookletter 1911", Times, serif' });
```

```javascript
this.add.text(0, 0, 'Hello World', { font: '"Press Start 2P"' });
```

You can only display fonts that are currently loaded and available to the browser: therefore fonts must
be pre-loaded. Phaser does not do ths for you, so you will require the use of a 3rd party font loader,
or have the fonts ready available in the CSS on the page in which your Phaser game resides.

See [this](http://www.jordanm.co.uk/tinytype) for the available default fonts
across mobile browsers.

A note on performance: Every time the contents of a Text object changes, i.e. changing the text being
displayed, or the style of the text, it needs to remake the Text canvas, and if on WebGL, re-upload the
new texture to the GPU. This can be an expensive operation if used often, or with large quantities of
Text objects in your game. If you run into performance issues you would be better off using Bitmap Text
instead, as it benefits from batching and avoids expensive Canvas API calls.


longname: Phaser.GameObjects.TextStyle
since: 3.0.0
name: TextStyle
memberof: Phaser.GameObjects
metafilename: TextStyle.js
metapath: gameobjects/text
description:
A TextStyle class manages all of the style settings for a Text object.

Text Game Objects create a TextStyle instance automatically, which is
accessed via the `Text.style` property. You do not normally need to
instantiate one yourself.


longname: Phaser.GameObjects.TileSprite
since: 3.0.0
name: TileSprite
memberof: Phaser.GameObjects
metafilename: TileSprite.js
metapath: gameobjects/tilesprite
description:
A TileSprite is a Sprite that has a repeating texture.

The texture can be scrolled and scaled independently of the TileSprite itself. Textures will automatically wrap and
are designed so that you can create game backdrops using seamless textures as a source.

You shouldn't ever create a TileSprite any larger than your actual canvas size. If you want to create a large repeating background
that scrolls across the whole map of your game, then you create a TileSprite that fits the canvas size and then use the `tilePosition`
property to scroll the texture as the player moves. If you create a TileSprite that is thousands of pixels in size then it will
consume huge amounts of memory and cause performance issues. Remember: use `tilePosition` to scroll your texture and `tileScale` to
adjust the scale of the texture - don't resize the sprite itself or make it larger than it needs.

An important note about Tile Sprites and NPOT textures: Internally, TileSprite textures use GL_REPEAT to provide
seamless repeating of the textures. This, combined with the way in which the textures are handled in WebGL, means
they need to be POT (power-of-two) sizes in order to wrap. If you provide a NPOT (non power-of-two) texture to a
TileSprite it will generate a POT sized canvas and draw your texture to it, scaled up to the POT size. It's then
scaled back down again during rendering to the original dimensions. While this works, in that it allows you to use
any size texture for a Tile Sprite, it does mean that NPOT textures are going to appear anti-aliased when rendered,
due to the interpolation that took place when it was resized into a POT texture. This is especially visible in
pixel art graphics. If you notice it and it becomes an issue, the only way to avoid it is to ensure that you
provide POT textures for Tile Sprites.


longname: Phaser.GameObjects.UpdateList
since: 3.0.0
name: UpdateList
memberof: Phaser.GameObjects
metafilename: UpdateList.js
metapath: gameobjects
description:
The Update List plugin.

Update Lists belong to a Scene and maintain the list Game Objects to be updated every frame.

Some or all of these Game Objects may also be part of the Scene's [Display List](Phaser.GameObjects.DisplayList), for Rendering.


longname: Phaser.GameObjects.Video
since: 3.20.0
name: Video
memberof: Phaser.GameObjects
metafilename: Video.js
metapath: gameobjects/video
description:
A Video Game Object.

This Game Object is capable of handling playback of a previously loaded video from the Phaser Video Cache,
or playing a video based on a given URL. Videos can be either local, or streamed.

```javascript
preload () {
  this.load.video('pixar', 'nemo.mp4');
}

create () {
  this.add.video(400, 300, 'pixar');
}
```

To all intents and purposes, a video is a standard Game Object, just like a Sprite. And as such, you can do
all the usual things to it, such as scaling, rotating, cropping, tinting, making interactive, giving a
physics body, etc.

Transparent videos are also possible via the WebM file format. Providing the video file has was encoded with
an alpha channel, and providing the browser supports WebM playback (not all of them do), then it will render
in-game with full transparency.

### Autoplaying Videos

Videos can only autoplay if the browser has been unlocked with an interaction, or satisfies the MEI settings.
The policies that control autoplaying are vast and vary between browser.
You can, and should, read more about it here: [https://developer.mozilla.org/en-US/docs/Web/Media/Autoplay_guide](https://developer.mozilla.org/en-US/docs/Web/Media/Autoplay_guide)

If your video doesn't contain any audio, then set the `noAudio` parameter to `true` when the video is _loaded_,
and it will often allow the video to play immediately:

```javascript
preload () {
  this.load.video('pixar', 'nemo.mp4', 'loadeddata', false, true);
}
```

The 5th parameter in the load call tells Phaser that the video doesn't contain any audio tracks. Video without
audio can autoplay without requiring a user interaction. Video with audio cannot do this unless it satisfies
the browsers MEI settings. See the MDN Autoplay Guide for further details.

Note that due to a bug in IE11 you cannot play a video texture to a Sprite in WebGL. For IE11 force Canvas mode.

More details about video playback and the supported media formats can be found on MDN:

[https://developer.mozilla.org/en-US/docs/Web/API/HTMLVideoElement](https://developer.mozilla.org/en-US/docs/Web/API/HTMLVideoElement)
[https://developer.mozilla.org/en-US/docs/Web/Media/Formats](https://developer.mozilla.org/en-US/docs/Web/Media/Formats)


longname: Phaser.GameObjects.Zone
since: 3.0.0
name: Zone
memberof: Phaser.GameObjects
metafilename: Zone.js
metapath: gameobjects/zone
description:
A Zone Game Object.

A Zone is a non-rendering rectangular Game Object that has a position and size.
It has no texture and never displays, but does live on the display list and
can be moved, scaled and rotated like any other Game Object.

Its primary use is for creating Drop Zones and Input Hit Areas and it has a couple of helper methods
specifically for this. It is also useful for object overlap checks, or as a base for your own
non-displaying Game Objects.
The default origin is 0.5, the center of the Zone, the same as with Game Objects.


longname: Phaser.Geom.Circle
since: 3.0.0
name: Circle
memberof: Phaser.Geom
metafilename: Circle.js
metapath: geom/circle
description:
A Circle object.

This is a geometry object, containing numerical values and related methods to inspect and modify them.
It is not a Game Object, in that you cannot add it to the display list, and it has no texture.
To render a Circle you should look at the capabilities of the Graphics class.


longname: Phaser.Geom.Ellipse
since: 3.0.0
name: Ellipse
memberof: Phaser.Geom
metafilename: Ellipse.js
metapath: geom/ellipse
description:
An Ellipse object.

This is a geometry object, containing numerical values and related methods to inspect and modify them.
It is not a Game Object, in that you cannot add it to the display list, and it has no texture.
To render an Ellipse you should look at the capabilities of the Graphics class.


longname: Phaser.Geom.Mesh.Face
since: 3.50.0
name: Face
memberof: Phaser.Geom.Mesh
metafilename: Face.js
metapath: geom/mesh
description:
A Face Geometry Object.

A Face is used by the Mesh Game Object. A Mesh consists of one, or more, faces that are
used to render the Mesh Game Objects in WebGL.

A Face consists of 3 Vertex instances, for the 3 corners of the face and methods to help
you modify and test them.


longname: Phaser.Geom.Mesh.Vertex
since: 3.50.0
name: Vertex
memberof: Phaser.Geom.Mesh
metafilename: Vertex.js
metapath: geom/mesh
description:
A Vertex Geometry Object.

This class consists of all the information required for a single vertex within a Face Geometry Object.

Faces, and thus Vertex objects, are used by the Mesh Game Object in order to render objects in WebGL.


longname: Phaser.Geom.Polygon
since: 3.0.0
name: Polygon
memberof: Phaser.Geom
metafilename: Polygon.js
metapath: geom/polygon
description:
A Polygon object

The polygon is a closed shape consists of a series of connected straight lines defined by list of ordered points.
Several formats are supported to define the list of points, check the setTo method for details.
This is a geometry object allowing you to define and inspect the shape.
It is not a Game Object, in that you cannot add it to the display list, and it has no texture.
To render a Polygon you should look at the capabilities of the Graphics class.


longname: Phaser.Geom.Rectangle
since: 3.0.0
name: Rectangle
memberof: Phaser.Geom
metafilename: Rectangle.js
metapath: geom/rectangle
description:
Encapsulates a 2D rectangle defined by its corner point in the top-left and its extends in x (width) and y (height)


longname: Phaser.Geom.Triangle
since: 3.0.0
name: Triangle
memberof: Phaser.Geom
metafilename: Triangle.js
metapath: geom/triangle
description:
A triangle is a plane created by connecting three points.
The first two arguments specify the first point, the middle two arguments
specify the second point, and the last two arguments specify the third point.


longname: Phaser.Input.Gamepad.Axis
since: 3.0.0
name: Axis
memberof: Phaser.Input.Gamepad
metafilename: Axis.js
metapath: input/gamepad
description:
Contains information about a specific Gamepad Axis.
Axis objects are created automatically by the Gamepad as they are needed.


longname: Phaser.Input.Gamepad.Button
since: 3.0.0
name: Button
memberof: Phaser.Input.Gamepad
metafilename: Button.js
metapath: input/gamepad
description:
Contains information about a specific button on a Gamepad.
Button objects are created automatically by the Gamepad as they are needed.


longname: Phaser.Input.Gamepad.GamepadPlugin
since: 3.10.0
name: GamepadPlugin
memberof: Phaser.Input.Gamepad
metafilename: GamepadPlugin.js
metapath: input/gamepad
description:
The Gamepad Plugin is an input plugin that belongs to the Scene-owned Input system.

Its role is to listen for native DOM Gamepad Events and then process them.

You do not need to create this class directly, the Input system will create an instance of it automatically.

You can access it from within a Scene using `this.input.gamepad`.

To listen for a gamepad being connected:

```javascript
this.input.gamepad.once('connected', function (pad) {
    //   'pad' is a reference to the gamepad that was just connected
});
```

Note that the browser may require you to press a button on a gamepad before it will allow you to access it,
this is for security reasons. However, it may also trust the page already, in which case you won't get the
'connected' event and instead should check `GamepadPlugin.total` to see if it thinks there are any gamepads
already connected.

Once you have received the connected event, or polled the gamepads and found them enabled, you can access
them via the built-in properties `GamepadPlugin.pad1` to `pad4`, for up to 4 game pads. With a reference
to the gamepads you can poll its buttons and axis sticks. See the properties and methods available on
the `Gamepad` class for more details.

As of September 2020 Chrome, and likely other browsers, will soon start to require that games requesting
access to the Gamepad API are running under SSL. They will actively block API access if they are not.

For more information about Gamepad support in browsers see the following resources:

[https://developer.mozilla.org/en-US/docs/Web/API/Gamepad_API](https://developer.mozilla.org/en-US/docs/Web/API/Gamepad_API)
[https://developer.mozilla.org/en-US/docs/Web/API/Gamepad_API/Using_the_Gamepad_API](https://developer.mozilla.org/en-US/docs/Web/API/Gamepad_API/Using_the_Gamepad_API)
[https://www.smashingmagazine.com/2015/11/gamepad-api-in-web-games/](https://www.smashingmagazine.com/2015/11/gamepad-api-in-web-games/)
[http://html5gamepad.com/](http://html5gamepad.com/)


longname: Phaser.Input.InputManager
since: 3.0.0
name: InputManager
memberof: Phaser.Input
metafilename: InputManager.js
metapath: input
description:
The Input Manager is responsible for handling the pointer related systems in a single Phaser Game instance.

Based on the Game Config it will create handlers for mouse and touch support.

Keyboard and Gamepad are plugins, handled directly by the InputPlugin class.

It then manages the events, pointer creation and general hit test related operations.

You rarely need to interact with the Input Manager directly, and as such, all of its properties and methods
should be considered private. Instead, you should use the Input Plugin, which is a Scene level system, responsible
for dealing with all input events for a Scene.


longname: Phaser.Input.InputPlugin
since: 3.0.0
name: InputPlugin
memberof: Phaser.Input
metafilename: InputPlugin.js
metapath: input
description:
The Input Plugin belongs to a Scene and handles all input related events and operations for it.

You can access it from within a Scene using `this.input`.

It emits events directly. For example, you can do:

```javascript
this.input.on('pointerdown', callback, context);
```

To listen for a pointer down event anywhere on the game canvas.

Game Objects can be enabled for input by calling their `setInteractive` method. After which they
will directly emit input events:

```javascript
var sprite = this.add.sprite(x, y, texture);
sprite.setInteractive();
sprite.on('pointerdown', callback, context);
```

There are lots of game configuration options available relating to input.
See the [Input Config object](code Phaser.Types.Core.InputConfig) for more details, including how to deal with Phaser
listening for input events outside of the canvas, how to set a default number of pointers, input
capture settings and more.

Please also see the Input examples and tutorials for further information.

**Incorrect input coordinates with Angular**

If you are using Phaser within Angular, and use nglf or the router, to make the component in which the Phaser game resides
change state (i.e. appear or disappear) then you'll need to notify the Scale Manager about this, as Angular will mess with
the DOM in a way in which Phaser can't detect directly. Call `this.scale.updateBounds()` as part of your game init in order
to refresh the canvas DOM bounds values, which Phaser uses for input point position calculations.


longname: Phaser.Input.Keyboard.KeyCombo
since: 3.0.0
name: KeyCombo
memberof: Phaser.Input.Keyboard
metafilename: KeyCombo.js
metapath: input/keyboard/combo
description:
A KeyCombo will listen for a specific string of keys from the Keyboard, and when it receives them
it will emit a `keycombomatch` event from the Keyboard Manager.

The keys to be listened for can be defined as:

A string (i.e. 'ATARI')
An array of either integers (key codes) or strings, or a mixture of both
An array of objects (such as Key objects) with a public 'keyCode' property

For example, to listen for the Konami code (up, up, down, down, left, right, left, right, b, a, enter)
you could pass the following array of key codes:

```javascript
this.input.keyboard.createCombo([ 38, 38, 40, 40, 37, 39, 37, 39, 66, 65, 13 ], { resetOnMatch: true });

this.input.keyboard.on('keycombomatch', function (event) {
    console.log('Konami Code entered!');
});
```

Or, to listen for the user entering the word PHASER:

```javascript
this.input.keyboard.createCombo('PHASER');
```


longname: Phaser.Input.Keyboard.KeyboardManager
since: 3.16.0
name: KeyboardManager
memberof: Phaser.Input.Keyboard
metafilename: KeyboardManager.js
metapath: input/keyboard
description:
The Keyboard Manager is a helper class that belongs to the global Input Manager.

Its role is to listen for native DOM Keyboard Events and then store them for further processing by the Keyboard Plugin.

You do not need to create this class directly, the Input Manager will create an instance of it automatically if keyboard
input has been enabled in the Game Config.


longname: Phaser.Input.Keyboard.KeyboardPlugin
since: 3.10.0
name: KeyboardPlugin
memberof: Phaser.Input.Keyboard
metafilename: KeyboardPlugin.js
metapath: input/keyboard
description:
The Keyboard Plugin is an input plugin that belongs to the Scene-owned Input system.

Its role is to listen for native DOM Keyboard Events and then process them.

You do not need to create this class directly, the Input system will create an instance of it automatically.

You can access it from within a Scene using `this.input.keyboard`. For example, you can do:

```javascript
this.input.keyboard.on('keydown', callback, context);
```

Or, to listen for a specific key:

```javascript
this.input.keyboard.on('keydown-A', callback, context);
```

You can also create Key objects, which you can then poll in your game loop:

```javascript
var spaceBar = this.input.keyboard.addKey(Phaser.Input.Keyboard.KeyCodes.SPACE);
```

If you have multiple parallel Scenes, each trying to get keyboard input, be sure to disable capture on them to stop them from
stealing input from another Scene in the list. You can do this with `this.input.keyboard.enabled = false` within the
Scene to stop all input, or `this.input.keyboard.preventDefault = false` to stop a Scene halting input on another Scene.

_Note_: Many keyboards are unable to process certain combinations of keys due to hardware limitations known as ghosting.
See [http://www.html5gamedevs.com/topic/4876-impossible-to-use-more-than-2-keyboard-input-buttons-at-the-same-time/](http://www.html5gamedevs.com/topic/4876-impossible-to-use-more-than-2-keyboard-input-buttons-at-the-same-time/) for more details.

Also please be aware that certain browser extensions can disable or override Phaser keyboard handling.
For example the Chrome extension vimium is known to disable Phaser from using the D key, while EverNote disables the backtick key.
And there are others. So, please check your extensions before opening Phaser issues about keys that don't work.


longname: Phaser.Input.Keyboard.Key
since: 3.0.0
name: Key
memberof: Phaser.Input.Keyboard
metafilename: Key.js
metapath: input/keyboard/keys
description:
A generic Key object which can be passed to the Process functions (and so on)
keycode must be an integer


longname: Phaser.Input.Mouse.MouseManager
since: 3.0.0
name: MouseManager
memberof: Phaser.Input.Mouse
metafilename: MouseManager.js
metapath: input/mouse
description:
The Mouse Manager is a helper class that belongs to the Input Manager.

Its role is to listen for native DOM Mouse Events and then pass them onto the Input Manager for further processing.

You do not need to create this class directly, the Input Manager will create an instance of it automatically.


longname: Phaser.Input.Pointer
since: 3.0.0
name: Pointer
memberof: Phaser.Input
metafilename: Pointer.js
metapath: input
description:
A Pointer object encapsulates both mouse and touch input within Phaser.

By default, Phaser will create 2 pointers for your game to use. If you require more, i.e. for a multi-touch
game, then use the `InputPlugin.addPointer` method to do so, rather than instantiating this class directly,
otherwise it won't be managed by the input system.

You can reference the current active pointer via `InputPlugin.activePointer`. You can also use the properties
`InputPlugin.pointer1` through to `pointer10`, for each pointer you have enabled in your game.

The properties of this object are set by the Input Plugin during processing. This object is then sent in all
input related events that the Input Plugin emits, so you can reference properties from it directly in your
callbacks.


longname: Phaser.Input.Touch.TouchManager
since: 3.0.0
name: TouchManager
memberof: Phaser.Input.Touch
metafilename: TouchManager.js
metapath: input/touch
description:
The Touch Manager is a helper class that belongs to the Input Manager.

Its role is to listen for native DOM Touch Events and then pass them onto the Input Manager for further processing.

You do not need to create this class directly, the Input Manager will create an instance of it automatically.


longname: Phaser.Loader.File
since: 3.0.0
name: File
memberof: Phaser.Loader
metafilename: File.js
metapath: loader
description:
The base File class used by all File Types that the Loader can support.
You shouldn't create an instance of a File directly, but should extend it with your own class, setting a custom type and processing methods.


longname: Phaser.Loader.FileTypes.AnimationJSONFile
since: 3.0.0
name: AnimationJSONFile
memberof: Phaser.Loader.FileTypes
metafilename: AnimationJSONFile.js
metapath: loader/filetypes
description:
A single Animation JSON File suitable for loading by the Loader.

These are created when you use the Phaser.Loader.LoaderPlugin#animation method and are not typically created directly.

For documentation about what all the arguments and configuration options mean please see Phaser.Loader.LoaderPlugin#animation.


longname: Phaser.Loader.FileTypes.AsepriteFile
since: 3.50.0
name: AsepriteFile
memberof: Phaser.Loader.FileTypes
metafilename: AsepriteFile.js
metapath: loader/filetypes
description:
A single JSON based Texture Atlas File suitable for loading by the Loader.

These are created when you use the Phaser.Loader.LoaderPlugin#atlas method and are not typically created directly.

For documentation about what all the arguments and configuration options mean please see Phaser.Loader.LoaderPlugin#atlas.

[https://www.codeandweb.com/texturepacker/tutorials/how-to-create-sprite-sheets-for-phaser3?source=photonstorm](https://www.codeandweb.com/texturepacker/tutorials/how-to-create-sprite-sheets-for-phaser3?source=photonstorm)


longname: Phaser.Loader.FileTypes.AtlasXMLFile
since: 3.7.0
name: AtlasXMLFile
memberof: Phaser.Loader.FileTypes
metafilename: AtlasXMLFile.js
metapath: loader/filetypes
description:
A single XML based Texture Atlas File suitable for loading by the Loader.

These are created when you use the Phaser.Loader.LoaderPlugin#atlasXML method and are not typically created directly.

For documentation about what all the arguments and configuration options mean please see Phaser.Loader.LoaderPlugin#atlasXML.


longname: Phaser.Loader.FileTypes.AudioFile
since: 3.0.0
name: AudioFile
memberof: Phaser.Loader.FileTypes
metafilename: AudioFile.js
metapath: loader/filetypes
description:
A single Audio File suitable for loading by the Loader.

These are created when you use the Phaser.Loader.LoaderPlugin#audio method and are not typically created directly.

For documentation about what all the arguments and configuration options mean please see Phaser.Loader.LoaderPlugin#audio.


longname: Phaser.Loader.FileTypes.AudioSpriteFile
since: 3.7.0
name: AudioSpriteFile
memberof: Phaser.Loader.FileTypes
metafilename: AudioSpriteFile.js
metapath: loader/filetypes
description:
An Audio Sprite File suitable for loading by the Loader.

These are created when you use the Phaser.Loader.LoaderPlugin#audioSprite method and are not typically created directly.

For documentation about what all the arguments and configuration options mean please see Phaser.Loader.LoaderPlugin#audioSprite.


longname: Phaser.Loader.FileTypes.BinaryFile
since: 3.0.0
name: BinaryFile
memberof: Phaser.Loader.FileTypes
metafilename: BinaryFile.js
metapath: loader/filetypes
description:
A single Binary File suitable for loading by the Loader.

These are created when you use the Phaser.Loader.LoaderPlugin#binary method and are not typically created directly.

For documentation about what all the arguments and configuration options mean please see Phaser.Loader.LoaderPlugin#binary.


longname: Phaser.Loader.FileTypes.BitmapFontFile
since: 3.0.0
name: BitmapFontFile
memberof: Phaser.Loader.FileTypes
metafilename: BitmapFontFile.js
metapath: loader/filetypes
description:
A single Bitmap Font based File suitable for loading by the Loader.

These are created when you use the Phaser.Loader.LoaderPlugin#bitmapFont method and are not typically created directly.

For documentation about what all the arguments and configuration options mean please see Phaser.Loader.LoaderPlugin#bitmapFont.


longname: Phaser.Loader.FileTypes.CSSFile
since: 3.17.0
name: CSSFile
memberof: Phaser.Loader.FileTypes
metafilename: CSSFile.js
metapath: loader/filetypes
description:
A single CSS File suitable for loading by the Loader.

These are created when you use the Phaser.Loader.LoaderPlugin#css method and are not typically created directly.

For documentation about what all the arguments and configuration options mean please see Phaser.Loader.LoaderPlugin#css.


longname: Phaser.Loader.FileTypes.GLSLFile
since: 3.0.0
name: GLSLFile
memberof: Phaser.Loader.FileTypes
metafilename: GLSLFile.js
metapath: loader/filetypes
description:
A single GLSL File suitable for loading by the Loader.

These are created when you use the Phaser.Loader.LoaderPlugin#glsl method and are not typically created directly.

For documentation about what all the arguments and configuration options mean please see Phaser.Loader.LoaderPlugin#glsl.


longname: Phaser.Loader.FileTypes.HTMLFile
since: 3.12.0
name: HTMLFile
memberof: Phaser.Loader.FileTypes
metafilename: HTMLFile.js
metapath: loader/filetypes
description:
A single HTML File suitable for loading by the Loader.

These are created when you use the Phaser.Loader.LoaderPlugin#html method and are not typically created directly.

For documentation about what all the arguments and configuration options mean please see Phaser.Loader.LoaderPlugin#html.


longname: Phaser.Loader.FileTypes.HTMLTextureFile
since: 3.12.0
name: HTMLTextureFile
memberof: Phaser.Loader.FileTypes
metafilename: HTMLTextureFile.js
metapath: loader/filetypes
description:
A single HTML File suitable for loading by the Loader.

These are created when you use the Phaser.Loader.LoaderPlugin#htmlTexture method and are not typically created directly.

For documentation about what all the arguments and configuration options mean please see Phaser.Loader.LoaderPlugin#htmlTexture.


longname: Phaser.Loader.FileTypes.ImageFile
since: 3.0.0
name: ImageFile
memberof: Phaser.Loader.FileTypes
metafilename: ImageFile.js
metapath: loader/filetypes
description:
A single Image File suitable for loading by the Loader.

These are created when you use the Phaser.Loader.LoaderPlugin#image method and are not typically created directly.

For documentation about what all the arguments and configuration options mean please see Phaser.Loader.LoaderPlugin#image.


longname: Phaser.Loader.FileTypes.JSONFile
since: 3.0.0
name: JSONFile
memberof: Phaser.Loader.FileTypes
metafilename: JSONFile.js
metapath: loader/filetypes
description:
A single JSON File suitable for loading by the Loader.

These are created when you use the Phaser.Loader.LoaderPlugin#json method and are not typically created directly.

For documentation about what all the arguments and configuration options mean please see Phaser.Loader.LoaderPlugin#json.


longname: Phaser.Loader.FileTypes.MultiAtlasFile
since: 3.7.0
name: MultiAtlasFile
memberof: Phaser.Loader.FileTypes
metafilename: MultiAtlasFile.js
metapath: loader/filetypes
description:
A single Multi Texture Atlas File suitable for loading by the Loader.

These are created when you use the Phaser.Loader.LoaderPlugin#multiatlas method and are not typically created directly.

For documentation about what all the arguments and configuration options mean please see Phaser.Loader.LoaderPlugin#multiatlas.


longname: Phaser.Loader.FileTypes.MultiScriptFile
since: 3.17.0
name: MultiScriptFile
memberof: Phaser.Loader.FileTypes
metafilename: MultiScriptFile.js
metapath: loader/filetypes
description:
A Multi Script File suitable for loading by the Loader.

These are created when you use the Phaser.Loader.LoaderPlugin#scripts method and are not typically created directly.

For documentation about what all the arguments and configuration options mean please see Phaser.Loader.LoaderPlugin#scripts.


longname: Phaser.Loader.FileTypes.OBJFile
since: 3.50.0
name: OBJFile
memberof: Phaser.Loader.FileTypes
metafilename: OBJFile.js
metapath: loader/filetypes
description:
A single Wavefront OBJ File suitable for loading by the Loader.

These are created when you use the Phaser.Loader.LoaderPlugin#obj method and are not typically created directly.

For documentation about what all the arguments and configuration options mean please see Phaser.Loader.LoaderPlugin#obj.


longname: Phaser.Loader.FileTypes.PackFile
since: 3.7.0
name: PackFile
memberof: Phaser.Loader.FileTypes
metafilename: PackFile.js
metapath: loader/filetypes
description:
A single JSON Pack File suitable for loading by the Loader.

These are created when you use the Phaser.Loader.LoaderPlugin#pack method and are not typically created directly.

For documentation about what all the arguments and configuration options mean please see Phaser.Loader.LoaderPlugin#pack.


longname: Phaser.Loader.FileTypes.PluginFile
since: 3.0.0
name: PluginFile
memberof: Phaser.Loader.FileTypes
metafilename: PluginFile.js
metapath: loader/filetypes
description:
A single Plugin Script File suitable for loading by the Loader.

These are created when you use the Phaser.Loader.LoaderPlugin#plugin method and are not typically created directly.

For documentation about what all the arguments and configuration options mean please see Phaser.Loader.LoaderPlugin#plugin.


longname: Phaser.Loader.FileTypes.SceneFile
since: 3.16.0
name: SceneFile
memberof: Phaser.Loader.FileTypes
metafilename: SceneFile.js
metapath: loader/filetypes
description:
An external Scene JavaScript File suitable for loading by the Loader.

These are created when you use the Phaser.Loader.LoaderPlugin#sceneFile method and are not typically created directly.

For documentation about what all the arguments and configuration options mean please see Phaser.Loader.LoaderPlugin#sceneFile.


longname: Phaser.Loader.FileTypes.ScenePluginFile
since: 3.8.0
name: ScenePluginFile
memberof: Phaser.Loader.FileTypes
metafilename: ScenePluginFile.js
metapath: loader/filetypes
description:
A single Scene Plugin Script File suitable for loading by the Loader.

These are created when you use the Phaser.Loader.LoaderPlugin#scenePlugin method and are not typically created directly.

For documentation about what all the arguments and configuration options mean please see Phaser.Loader.LoaderPlugin#scenePlugin.


longname: Phaser.Loader.FileTypes.ScriptFile
since: 3.0.0
name: ScriptFile
memberof: Phaser.Loader.FileTypes
metafilename: ScriptFile.js
metapath: loader/filetypes
description:
A single Script File suitable for loading by the Loader.

These are created when you use the Phaser.Loader.LoaderPlugin#script method and are not typically created directly.

For documentation about what all the arguments and configuration options mean please see Phaser.Loader.LoaderPlugin#script.


longname: Phaser.Loader.FileTypes.SpriteSheetFile
since: 3.0.0
name: SpriteSheetFile
memberof: Phaser.Loader.FileTypes
metafilename: SpriteSheetFile.js
metapath: loader/filetypes
description:
A single Sprite Sheet Image File suitable for loading by the Loader.

These are created when you use the Phaser.Loader.LoaderPlugin#spritesheet method and are not typically created directly.

For documentation about what all the arguments and configuration options mean please see Phaser.Loader.LoaderPlugin#spritesheet.


longname: Phaser.Loader.FileTypes.SVGFile
since: 3.0.0
name: SVGFile
memberof: Phaser.Loader.FileTypes
metafilename: SVGFile.js
metapath: loader/filetypes
description:
A single SVG File suitable for loading by the Loader.

These are created when you use the Phaser.Loader.LoaderPlugin#svg method and are not typically created directly.

For documentation about what all the arguments and configuration options mean please see Phaser.Loader.LoaderPlugin#svg.


longname: Phaser.Loader.FileTypes.TextFile
since: 3.0.0
name: TextFile
memberof: Phaser.Loader.FileTypes
metafilename: TextFile.js
metapath: loader/filetypes
description:
A single Text File suitable for loading by the Loader.

These are created when you use the Phaser.Loader.LoaderPlugin#text method and are not typically created directly.

For documentation about what all the arguments and configuration options mean please see Phaser.Loader.LoaderPlugin#text.


longname: Phaser.Loader.FileTypes.TilemapCSVFile
since: 3.0.0
name: TilemapCSVFile
memberof: Phaser.Loader.FileTypes
metafilename: TilemapCSVFile.js
metapath: loader/filetypes
description:
A single Tilemap CSV File suitable for loading by the Loader.

These are created when you use the Phaser.Loader.LoaderPlugin#tilemapCSV method and are not typically created directly.

For documentation about what all the arguments and configuration options mean please see Phaser.Loader.LoaderPlugin#tilemapCSV.


longname: Phaser.Loader.FileTypes.TilemapImpactFile
since: 3.7.0
name: TilemapImpactFile
memberof: Phaser.Loader.FileTypes
metafilename: TilemapImpactFile.js
metapath: loader/filetypes
description:
A single Impact.js Tilemap JSON File suitable for loading by the Loader.

These are created when you use the Phaser.Loader.LoaderPlugin#tilemapImpact method and are not typically created directly.

For documentation about what all the arguments and configuration options mean please see Phaser.Loader.LoaderPlugin#tilemapImpact.


longname: Phaser.Loader.FileTypes.TilemapJSONFile
since: 3.0.0
name: TilemapJSONFile
memberof: Phaser.Loader.FileTypes
metafilename: TilemapJSONFile.js
metapath: loader/filetypes
description:
A single Tiled Tilemap JSON File suitable for loading by the Loader.

These are created when you use the Phaser.Loader.LoaderPlugin#tilemapTiledJSON method and are not typically created directly.

For documentation about what all the arguments and configuration options mean please see Phaser.Loader.LoaderPlugin#tilemapTiledJSON.


longname: Phaser.Loader.FileTypes.UnityAtlasFile
since: 3.0.0
name: UnityAtlasFile
memberof: Phaser.Loader.FileTypes
metafilename: UnityAtlasFile.js
metapath: loader/filetypes
description:
A single text file based Unity Texture Atlas File suitable for loading by the Loader.

These are created when you use the Phaser.Loader.LoaderPlugin#unityAtlas method and are not typically created directly.

For documentation about what all the arguments and configuration options mean please see Phaser.Loader.LoaderPlugin#unityAtlas.


longname: Phaser.Loader.FileTypes.VideoFile
since: 3.20.0
name: VideoFile
memberof: Phaser.Loader.FileTypes
metafilename: VideoFile.js
metapath: loader/filetypes
description:
A single Video File suitable for loading by the Loader.

These are created when you use the Phaser.Loader.LoaderPlugin#video method and are not typically created directly.

For documentation about what all the arguments and configuration options mean please see Phaser.Loader.LoaderPlugin#video.


longname: Phaser.Loader.FileTypes.XMLFile
since: 3.0.0
name: XMLFile
memberof: Phaser.Loader.FileTypes
metafilename: XMLFile.js
metapath: loader/filetypes
description:
A single XML File suitable for loading by the Loader.

These are created when you use the Phaser.Loader.LoaderPlugin#xml method and are not typically created directly.

For documentation about what all the arguments and configuration options mean please see Phaser.Loader.LoaderPlugin#xml.


longname: Phaser.Loader.LoaderPlugin
since: 3.0.0
name: LoaderPlugin
memberof: Phaser.Loader
metafilename: LoaderPlugin.js
metapath: loader
description:
The Loader handles loading all external content such as Images, Sounds, Texture Atlases and data files.
You typically interact with it via `this.load` in your Scene. Scenes can have a `preload` method, which is always
called before the Scenes `create` method, allowing you to preload assets that the Scene may need.

If you call any `this.load` methods from outside of `Scene.preload` then you need to start the Loader going
yourself by calling `Loader.start()`. It's only automatically started during the Scene preload.

The Loader uses a combination of tag loading (eg. Audio elements) and XHR and provides progress and completion events.
Files are loaded in parallel by default. The amount of concurrent connections can be controlled in your Game Configuration.

Once the Loader has started loading you are still able to add files to it. These can be injected as a result of a loader
event, the type of file being loaded (such as a pack file) or other external events. As long as the Loader hasn't finished
simply adding a new file to it, while running, will ensure it's added into the current queue.

Every Scene has its own instance of the Loader and they are bound to the Scene in which they are created. However,
assets loaded by the Loader are placed into global game-level caches. For example, loading an XML file will place that
file inside `Game.cache.xml`, which is accessible from every Scene in your game, no matter who was responsible
for loading it. The same is true of Textures. A texture loaded in one Scene is instantly available to all other Scenes
in your game.

The Loader works by using custom File Types. These are stored in the FileTypesManager, which injects them into the Loader
when it's instantiated. You can create your own custom file types by extending either the File or MultiFile classes.
See those files for more details.


longname: Phaser.Loader.MultiFile
since: 3.7.0
name: MultiFile
memberof: Phaser.Loader
metafilename: MultiFile.js
metapath: loader
description:
A MultiFile is a special kind of parent that contains two, or more, Files as children and looks after
the loading and processing of them all. It is commonly extended and used as a base class for file types such as AtlasJSON or BitmapFont.

You shouldn't create an instance of a MultiFile directly, but should extend it with your own class, setting a custom type and processing methods.


longname: Phaser.Math.Matrix4
since: 3.0.0
name: Matrix4
memberof: Phaser.Math
metafilename: Matrix4.js
metapath: math
description:
A four-dimensional matrix.

Adapted from [gl-matrix](https://github.com/toji/gl-matrix) by toji
and [vecmath](https://github.com/mattdesl/vecmath) by mattdesl


longname: Phaser.Math.RandomDataGenerator
since: 3.0.0
name: RandomDataGenerator
memberof: Phaser.Math
metafilename: RandomDataGenerator.js
metapath: math/random-data-generator
description:
A seeded Random Data Generator.

Access via `Phaser.Math.RND` which is an instance of this class pre-defined
by Phaser. Or, create your own instance to use as you require.

The `Math.RND` generator is seeded by the Game Config property value `seed`.
If no such config property exists, a random number is used.

If you create your own instance of this class you should provide a seed for it.
If no seed is given it will use a 'random' one based on Date.now.


longname: Phaser.Physics.Arcade.Image
since: 3.0.0
name: Image
memberof: Phaser.Physics.Arcade
metafilename: ArcadeImage.js
metapath: physics/arcade
description:
An Arcade Physics Image is an Image with an Arcade Physics body and related components.
The body can be dynamic or static.

The main difference between an Arcade Image and an Arcade Sprite is that you cannot animate an Arcade Image.


longname: Phaser.Physics.Arcade.ArcadePhysics
since: 3.0.0
name: ArcadePhysics
memberof: Phaser.Physics.Arcade
metafilename: ArcadePhysics.js
metapath: physics/arcade
description:
The Arcade Physics Plugin belongs to a Scene and sets up and manages the Scene's physics simulation.
It also holds some useful methods for moving and rotating Arcade Physics Bodies.

You can access it from within a Scene using `this.physics`.

Arcade Physics uses the Projection Method of collision resolution and separation. While it's fast and suitable
for 'arcade' style games it lacks stability when multiple objects are in close proximity or resting upon each other.
The separation that stops two objects penetrating may create a new penetration against a different object. If you
require a high level of stability please consider using an alternative physics system, such as Matter.js.


longname: Phaser.Physics.Arcade.Sprite
since: 3.0.0
name: Sprite
memberof: Phaser.Physics.Arcade
metafilename: ArcadeSprite.js
metapath: physics/arcade
description:
An Arcade Physics Sprite is a Sprite with an Arcade Physics body and related components.
The body can be dynamic or static.

The main difference between an Arcade Sprite and an Arcade Image is that you cannot animate an Arcade Image.
If you do not require animation then you can safely use Arcade Images instead of Arcade Sprites.


longname: Phaser.Physics.Arcade.Body
since: 3.0.0
name: Body
memberof: Phaser.Physics.Arcade
metafilename: Body.js
metapath: physics/arcade
description:
A Dynamic Arcade Body.

Its static counterpart is [Phaser.Physics.Arcade.StaticBody](Phaser.Physics.Arcade.StaticBody).


longname: Phaser.Physics.Arcade.Collider
since: 3.0.0
name: Collider
memberof: Phaser.Physics.Arcade
metafilename: Collider.js
metapath: physics/arcade
description:
An Arcade Physics Collider will automatically check for collision, or overlaps, between two objects
every step. If a collision, or overlap, occurs it will invoke the given callbacks.


longname: Phaser.Physics.Arcade.Factory
since: 3.0.0
name: Factory
memberof: Phaser.Physics.Arcade
metafilename: Factory.js
metapath: physics/arcade
description:
The Arcade Physics Factory allows you to easily create Arcade Physics enabled Game Objects.
Objects that are created by this Factory are automatically added to the physics world.


longname: Phaser.Physics.Arcade.Group
since: 3.0.0
name: Group
memberof: Phaser.Physics.Arcade
metafilename: PhysicsGroup.js
metapath: physics/arcade
description:
An Arcade Physics Group object.

The primary use of a Physics Group is a way to collect together physics enable objects
that share the same intrinsic structure into a single pool. They can they be easily
compared against other Groups, or Game Objects.

All Game Objects created by, or added to this Group will automatically be given **dynamic**
Arcade Physics bodies (if they have no body already) and the bodies will receive the
Groups [default](Phaser.Physics.Arcade.Group#defaults).

You should not pass objects into this Group that should not receive a body. For example,
do not add basic Geometry or Tilemap Layers into a Group, as they will not behave in the
way you may expect. Groups should all ideally have objects of the same type in them.

If you wish to create a Group filled with Static Bodies, please see [Phaser.Physics.Arcade.StaticGroup](Phaser.Physics.Arcade.StaticGroup).


longname: Phaser.Physics.Arcade.StaticBody
since: 3.0.0
name: StaticBody
memberof: Phaser.Physics.Arcade
metafilename: StaticBody.js
metapath: physics/arcade
description:
A Static Arcade Physics Body.

A Static Body never moves, and isn't automatically synchronized with its parent Game Object.
That means if you make any change to the parent's origin, position, or scale after creating or adding the body, you'll need to update the Static Body manually.

A Static Body can collide with other Bodies, but is never moved by collisions.

Its dynamic counterpart is [Phaser.Physics.Arcade.Body](Phaser.Physics.Arcade.Body).


longname: Phaser.Physics.Arcade.StaticGroup
since: 3.0.0
name: StaticGroup
memberof: Phaser.Physics.Arcade
metafilename: StaticPhysicsGroup.js
metapath: physics/arcade
description:
An Arcade Physics Static Group object.

All Game Objects created by or added to this Group will automatically be given static Arcade Physics bodies, if they have no body.

Its dynamic counterpart is [Phaser.Physics.Arcade.Group](Phaser.Physics.Arcade.Group).


longname: Phaser.Physics.Arcade.World
since: 3.0.0
name: World
memberof: Phaser.Physics.Arcade
metafilename: World.js
metapath: physics/arcade
description:
The Arcade Physics World.

The World is responsible for creating, managing, colliding and updating all of the bodies within it.

An instance of the World belongs to a Phaser.Scene and is accessed via the property `physics.world`.


longname: Phaser.Physics.Matter.BodyBounds
since: 3.22.0
name: BodyBounds
memberof: Phaser.Physics.Matter
metafilename: BodyBounds.js
metapath: physics/matter-js
description:
The Body Bounds class contains methods to help you extract the world coordinates from various points around
the bounds of a Matter Body. Because Matter bodies are positioned based on their center of mass, and not a
dimension based center, you often need to get the bounds coordinates in order to properly align them in the world.

You can access this class via the MatterPhysics class from a Scene, i.e.:

```javascript
this.matter.bodyBounds.getTopLeft(body);
```

See also the `MatterPhysics.alignBody` method.


longname: Phaser.Physics.Matter.Factory
since: 3.0.0
name: Factory
memberof: Phaser.Physics.Matter
metafilename: Factory.js
metapath: physics/matter-js
description:
The Matter Factory is responsible for quickly creating a variety of different types of
bodies, constraints and Game Objects and adding them into the physics world.

You access the factory from within a Scene using `add`:

```javascript
this.matter.add.rectangle(x, y, width, height);
```

Use of the Factory is optional. All of the objects it creates can also be created
directly via your own code or constructors. It is provided as a means to keep your
code concise.


longname: Phaser.Physics.Matter.Image
since: 3.0.0
name: Image
memberof: Phaser.Physics.Matter
metafilename: MatterImage.js
metapath: physics/matter-js
description:
A Matter Physics Image Game Object.

An Image is a light-weight Game Object useful for the display of static images in your game,
such as logos, backgrounds, scenery or other non-animated elements. Images can have input
events and physics bodies, or be tweened, tinted or scrolled. The main difference between an
Image and a Sprite is that you cannot animate an Image as they do not have the Animation component.


longname: Phaser.Physics.Matter.MatterPhysics
since: 3.0.0
name: MatterPhysics
memberof: Phaser.Physics.Matter
metafilename: MatterPhysics.js
metapath: physics/matter-js
description:
The Phaser Matter plugin provides the ability to use the Matter JS Physics Engine within your Phaser games.

Unlike Arcade Physics, the other physics system provided with Phaser, Matter JS is a full-body physics system.
It features:

* Rigid bodies
* Compound bodies
* Composite bodies
* Concave and convex hulls
* Physical properties (mass, area, density etc.)
* Restitution (elastic and inelastic collisions)
* Collisions (broad-phase, mid-phase and narrow-phase)
* Stable stacking and resting
* Conservation of momentum
* Friction and resistance
* Constraints
* Gravity
* Sleeping and static bodies
* Rounded corners (chamfering)
* Views (translate, zoom)
* Collision queries (raycasting, region tests)
* Time scaling (slow-mo, speed-up)

Configuration of Matter is handled via the Matter World Config object, which can be passed in either the
Phaser Game Config, or Phaser Scene Config. Here is a basic example:

```js
physics: {
    default: 'matter',
    matter: {
        enableSleeping: true,
        gravity: {
            y: 0
        },
        debug: {
            showBody: true,
            showStaticBody: true
        }
    }
}
```

This class acts as an interface between a Phaser Scene and a single instance of the Matter Engine.

Use it to access the most common Matter features and helper functions.

You can find details, documentation and examples on the Matter JS website: [https://brm.io/matter-js/](https://brm.io/matter-js/)


longname: Phaser.Physics.Matter.Sprite
since: 3.0.0
name: Sprite
memberof: Phaser.Physics.Matter
metafilename: MatterSprite.js
metapath: physics/matter-js
description:
A Matter Physics Sprite Game Object.

A Sprite Game Object is used for the display of both static and animated images in your game.
Sprites can have input events and physics bodies. They can also be tweened, tinted, scrolled
and animated.

The main difference between a Sprite and an Image Game Object is that you cannot animate Images.
As such, Sprites take a fraction longer to process and have a larger API footprint due to the Animation
Component. If you do not require animation then you can safely use Images to replace Sprites in all cases.


longname: Phaser.Physics.Matter.TileBody
since: 3.0.0
name: TileBody
memberof: Phaser.Physics.Matter
metafilename: MatterTileBody.js
metapath: physics/matter-js
description:
A wrapper around a Tile that provides access to a corresponding Matter body. A tile can only
have one Matter body associated with it. You can either pass in an existing Matter body for
the tile or allow the constructor to create the corresponding body for you. If the Tile has a
collision group (defined in Tiled), those shapes will be used to create the body. If not, the
tile's rectangle bounding box will be used.

The corresponding body will be accessible on the Tile itself via Tile.physics.matterBody.

Note: not all Tiled collision shapes are supported. See
Phaser.Physics.Matter.TileBody#setFromTileCollision for more information.


longname: Phaser.Physics.Matter.PointerConstraint
since: 3.0.0
name: PointerConstraint
memberof: Phaser.Physics.Matter
metafilename: PointerConstraint.js
metapath: physics/matter-js
description:
A Pointer Constraint is a special type of constraint that allows you to click
and drag bodies in a Matter World. It monitors the active Pointers in a Scene,
and when one is pressed down it checks to see if that hit any part of any active
body in the world. If it did, and the body has input enabled, it will begin to
drag it until either released, or you stop it via the `stopDrag` method.

You can adjust the stiffness, length and other properties of the constraint via
the `options` object on creation.


longname: Phaser.Physics.Matter.World
since: 3.0.0
name: World
memberof: Phaser.Physics.Matter
metafilename: World.js
metapath: physics/matter-js
description:
The Matter World class is responsible for managing one single instance of a Matter Physics World for Phaser.

Access this via `this.matter.world` from within a Scene.

This class creates a Matter JS World Composite along with the Matter JS Engine during instantiation. It also
handles delta timing, bounds, body and constraint creation and debug drawing.

If you wish to access the Matter JS World object directly, see the `localWorld` property.
If you wish to access the Matter Engine directly, see the `engine` property.

This class is an Event Emitter and will proxy _all_ Matter JS events, as they are received.


longname: Phaser.Plugins.BasePlugin
since: 3.8.0
name: BasePlugin
memberof: Phaser.Plugins
metafilename: BasePlugin.js
metapath: plugins
description:
A Global Plugin is installed just once into the Game owned Plugin Manager.
It can listen for Game events and respond to them.


longname: Phaser.Plugins.PluginManager
since: 3.0.0
name: PluginManager
memberof: Phaser.Plugins
metafilename: PluginManager.js
metapath: plugins
description:
The PluginManager is responsible for installing and adding plugins to Phaser.

It is a global system and therefore belongs to the Game instance, not a specific Scene.

It works in conjunction with the PluginCache. Core internal plugins automatically register themselves
with the Cache, but it's the Plugin Manager that is responsible for injecting them into the Scenes.

There are two types of plugin:

1. A Global Plugin
2. A Scene Plugin

A Global Plugin is a plugin that lives within the Plugin Manager rather than a Scene. You can get
access to it by calling `PluginManager.get` and providing a key. Any Scene that requests a plugin in
this way will all get access to the same plugin instance, allowing you to use a single plugin across
multiple Scenes.

A Scene Plugin is a plugin dedicated to running within a Scene. These are different to Global Plugins
in that their instances do not live within the Plugin Manager, but within the Scene Systems class instead.
And that every Scene created is given its own unique instance of a Scene Plugin. Examples of core Scene
Plugins include the Input Plugin, the Tween Plugin and the physics Plugins.

You can add a plugin to Phaser in three different ways:

1. Preload it
2. Include it in your source code and install it via the Game Config
3. Include it in your source code and install it within a Scene

For examples of all of these approaches please see the Phaser 3 Examples Repo `plugins` folder.

For information on creating your own plugin please see the Phaser 3 Plugin Template.


longname: Phaser.Plugins.ScenePlugin
since: 3.8.0
name: ScenePlugin
memberof: Phaser.Plugins
metafilename: ScenePlugin.js
metapath: plugins
description:
A Scene Level Plugin is installed into every Scene and belongs to that Scene.
It can listen for Scene events and respond to them.
It can map itself to a Scene property, or into the Scene Systems, or both.


longname: Phaser.Renderer.Canvas.CanvasRenderer
since: 3.0.0
name: CanvasRenderer
memberof: Phaser.Renderer.Canvas
metafilename: CanvasRenderer.js
metapath: renderer/canvas
description:
The Canvas Renderer is responsible for managing 2D canvas rendering contexts,
including the one used by the Games canvas. It tracks the internal state of a
given context and can renderer textured Game Objects to it, taking into
account alpha, blending, and scaling.


longname: Phaser.Renderer.WebGL.PipelineManager
since: 3.50.0
name: PipelineManager
memberof: Phaser.Renderer.WebGL
metafilename: PipelineManager.js
metapath: renderer/webgl
description:
The Pipeline Manager is responsible for the creation, activation, running and destruction
of WebGL Pipelines and Post FX Pipelines in Phaser 3.

The `WebGLRenderer` owns a single instance of the Pipeline Manager, which you can access
via the `WebGLRenderer.pipelines` property.

By default, there are 8 pipelines installed into the Pipeline Manager when Phaser boots:

1. The Multi Pipeline. Responsible for all multi-texture rendering, i.e. Sprites and Tilemaps.
2. The Graphics Pipeline. Responsible for rendering Graphics and Shape objects.
3. The Rope Pipeline. Responsible for rendering the Rope Game Object.
4. The Light Pipeline. Responsible for rendering the Light Game Object.
5. The Point Light Pipeline. Responsible for rendering the Point Light Game Object.
6. The Single Pipeline. Responsible for rendering Game Objects that explicitly require one bound texture.
7. The Bitmap Mask Pipeline. Responsible for Bitmap Mask rendering.
8. The Utility Pipeline. Responsible for providing lots of handy texture manipulation functions.

You can add your own custom pipeline via the `PipelineManager.add` method. Pipelines are
identified by unique string-based keys.


longname: Phaser.Renderer.WebGL.Pipelines.BitmapMaskPipeline
since: 3.0.0
name: BitmapMaskPipeline
memberof: Phaser.Renderer.WebGL.Pipelines
metafilename: BitmapMaskPipeline.js
metapath: renderer/webgl/pipelines
description:
The Bitmap Mask Pipeline handles all of the bitmap mask rendering in WebGL for applying
alpha masks to Game Objects. It works by sampling two texture on the fragment shader and
using the fragments alpha to clip the region.

The fragment shader it uses can be found in `shaders/src/BitmapMask.frag`.
The vertex shader it uses can be found in `shaders/src/BitmapMask.vert`.

The default shader attributes for this pipeline are:

`inPosition` (vec2, offset 0)

The default shader uniforms for this pipeline are:

`uResolution` (vec2)
`uMainSampler` (sampler2D)
`uMaskSampler` (sampler2D)
`uInvertMaskAlpha` (bool)


longname: Phaser.Renderer.WebGL.Pipelines.GraphicsPipeline
since: 3.50.0
name: GraphicsPipeline
memberof: Phaser.Renderer.WebGL.Pipelines
metafilename: GraphicsPipeline.js
metapath: renderer/webgl/pipelines
description:
The Graphics Pipeline is the rendering pipeline used by Phaser in WebGL when drawing
primitive geometry objects, such as the Graphics Game Object, or the Shape Game Objects
such as Arc, Line, Rectangle and Star. It handles the preperation and batching of related vertices.

Prior to Phaser v3.50 the functions of this pipeline were merged with the `TextureTintPipeline`.

The fragment shader it uses can be found in `shaders/src/Graphics.frag`.
The vertex shader it uses can be found in `shaders/src/Graphics.vert`.

The default shader attributes for this pipeline are:

`inPosition` (vec2)
`inColor` (vec4, normalized)

The default shader uniforms for this pipeline are:

`uProjectionMatrix` (mat4)


longname: Phaser.Renderer.WebGL.Pipelines.LightPipeline
since: 3.50.0
name: LightPipeline
memberof: Phaser.Renderer.WebGL.Pipelines
metafilename: LightPipeline.js
metapath: renderer/webgl/pipelines
description:
The Light Pipeline is an extension of the Multi Pipeline and uses a custom shader
designed to handle forward diffused rendering of 2D lights in a Scene.

The shader works in tandem with Light Game Objects, and optionally texture normal maps,
to provide an ambient illumination effect.

If you wish to provide your own shader, you can use the `%LIGHT_COUNT%` declaration in the source,
and it will be automatically replaced at run-time with the total number of configured lights.

The maximum number of lights can be set in the Render Config `maxLights` property and defaults to 10.

Prior to Phaser v3.50 this pipeline was called the `ForwardDiffuseLightPipeline`.

The fragment shader it uses can be found in `shaders/src/Light.frag`.
The vertex shader it uses can be found in `shaders/src/Multi.vert`.

The default shader attributes for this pipeline are:

`inPosition` (vec2, offset 0)
`inTexCoord` (vec2, offset 8)
`inTexId` (float, offset 16)
`inTintEffect` (float, offset 20)
`inTint` (vec4, offset 24, normalized)

The default shader uniforms for this pipeline are those from the Multi Pipeline, plus:

`uMainSampler` (sampler2D)
`uNormSampler` (sampler2D)
`uCamera` (vec4)
`uResolution` (vec2)
`uAmbientLightColor` (vec3)
`uInverseRotationMatrix` (mat3)
`uLights` (Light struct)


longname: Phaser.Renderer.WebGL.Pipelines.MultiPipeline
since: 3.50.0
name: MultiPipeline
memberof: Phaser.Renderer.WebGL.Pipelines
metafilename: MultiPipeline.js
metapath: renderer/webgl/pipelines
description:
The Multi Pipeline is the core 2D texture rendering pipeline used by Phaser in WebGL.
Virtually all Game Objects use this pipeline by default, including Sprites, Graphics
and Tilemaps. It handles the batching of quads and tris, as well as methods for
drawing and batching geometry data.

Prior to Phaser v3.50 this pipeline was called the `TextureTintPipeline`.

In previous versions of Phaser only one single texture unit was supported at any one time.
The Multi Pipeline is an evolution of the old Texture Tint Pipeline, updated to support
multi-textures for increased performance.

The fragment shader it uses can be found in `shaders/src/Multi.frag`.
The vertex shader it uses can be found in `shaders/src/Multi.vert`.

The default shader attributes for this pipeline are:

`inPosition` (vec2, offset 0)
`inTexCoord` (vec2, offset 8)
`inTexId` (float, offset 16)
`inTintEffect` (float, offset 20)
`inTint` (vec4, offset 24, normalized)

The default shader uniforms for this pipeline are:

`uProjectionMatrix` (mat4)
`uMainSampler` (sampler2D array)

If you wish to create a custom pipeline extending from this one, you can use two string
declarations in your fragment shader source: `%count%` and `%forloop%`, where `count` is
used to set the number of `sampler2Ds` available, and `forloop` is a block of GLSL code
that will get the currently bound texture unit.

This pipeline will automatically inject that code for you, should those values exist
in your shader source. If you wish to handle this yourself, you can also use the
function `Utils.parseFragmentShaderMaxTextures`.

If you wish to create a pipeline that works from a single texture, or that doesn't have
internal texture iteration, please see the `SinglePipeline` instead.


longname: Phaser.Renderer.WebGL.Pipelines.PointLightPipeline
since: 3.50.0
name: PointLightPipeline
memberof: Phaser.Renderer.WebGL.Pipelines
metafilename: PointLightPipeline.js
metapath: renderer/webgl/pipelines
description:
The Point Light Pipeline handles rendering the Point Light Game Objects in WebGL.

The fragment shader it uses can be found in `shaders/src/PointLight.frag`.
The vertex shader it uses can be found in `shaders/src/PointLight.vert`.

The default shader attributes for this pipeline are:

`inPosition` (vec2)
`inLightPosition` (vec2)
`inLightRadius` (float)
`inLightAttenuation` (float)
`inLightColor` (vec4)

The default shader uniforms for this pipeline are:

`uProjectionMatrix` (mat4)
`uResolution` (vec2)
`uCameraZoom` (sampler2D)


longname: Phaser.Renderer.WebGL.Pipelines.PostFXPipeline
since: 3.50.0
name: PostFXPipeline
memberof: Phaser.Renderer.WebGL.Pipelines
metafilename: PostFXPipeline.js
metapath: renderer/webgl/pipelines
description:
The Post FX Pipeline is a special kind of pipeline specifically for handling post
processing effects. Where-as a standard Pipeline allows you to control the process
of rendering Game Objects by configuring the shaders and attributes used to draw them,
a Post FX Pipeline is designed to allow you to apply processing _after_ the Game Object/s
have been rendered. Typical examples of post processing effects are bloom filters,
blurs, light effects and color manipulation.

The pipeline works by creating a tiny vertex buffer with just one single hard-coded quad
in it. Game Objects can have a Post Pipeline set on them. Those objects are then rendered
using their standard pipeline, but are redirected to the Render Targets owned by the
post pipeline, which can then apply their own shaders and effects, before passing them
back to the main renderer.

Please see the Phaser 3 examples for further details on this extensive subject.

The default fragment shader it uses can be found in `shaders/src/PostFX.frag`.
The default vertex shader it uses can be found in `shaders/src/Quad.vert`.

The default shader attributes for this pipeline are:

`inPosition` (vec2, offset 0)
`inTexCoord` (vec2, offset 8)

The vertices array layout is:

-1,  1   B----C   1,  1
 0,  1   |   /|   1,  1
         |  / |
         | /  |
         |/   |
-1, -1   A----D   1, -1
 0,  0            1,  0

A = -1, -1 (pos) and 0, 0 (uv)
B = -1,  1 (pos) and 0, 1 (uv)
C =  1,  1 (pos) and 1, 1 (uv)
D =  1, -1 (pos) and 1, 0 (uv)

First tri: A, B, C
Second tri: A, C, D

Array index:

0  = Tri 1 - Vert A - x pos
1  = Tri 1 - Vert A - y pos
2  = Tri 1 - Vert A - uv u
3  = Tri 1 - Vert A - uv v

4  = Tri 1 - Vert B - x pos
5  = Tri 1 - Vert B - y pos
6  = Tri 1 - Vert B - uv u
7  = Tri 1 - Vert B - uv v

8  = Tri 1 - Vert C - x pos
9  = Tri 1 - Vert C - y pos
10 = Tri 1 - Vert C - uv u
11 = Tri 1 - Vert C - uv v

12 = Tri 2 - Vert A - x pos
13 = Tri 2 - Vert A - y pos
14 = Tri 2 - Vert A - uv u
15 = Tri 2 - Vert A - uv v

16 = Tri 2 - Vert C - x pos
17 = Tri 2 - Vert C - y pos
18 = Tri 2 - Vert C - uv u
19 = Tri 2 - Vert C - uv v

20 = Tri 2 - Vert D - x pos
21 = Tri 2 - Vert D - y pos
22 = Tri 2 - Vert D - uv u
23 = Tri 2 - Vert D - uv v


longname: Phaser.Renderer.WebGL.Pipelines.RopePipeline
since: 3.50.0
name: RopePipeline
memberof: Phaser.Renderer.WebGL.Pipelines
metafilename: RopePipeline.js
metapath: renderer/webgl/pipelines
description:
The Rope Pipeline is a variation of the Multi Pipeline that uses a `TRIANGLE_STRIP` for
its topology, instead of TRIANGLES. This is primarily used by the Rope Game Object,
or anything that extends it.

Prior to Phaser v3.50 this pipeline was called the `TextureTintStripPipeline`.

The fragment shader it uses can be found in `shaders/src/Multi.frag`.
The vertex shader it uses can be found in `shaders/src/Multi.vert`.

The default shader attributes for this pipeline are:

`inPosition` (vec2, offset 0)
`inTexCoord` (vec2, offset 8)
`inTexId` (float, offset 16)
`inTintEffect` (float, offset 20)
`inTint` (vec4, offset 24, normalized)

The default shader uniforms for this pipeline are:

`uProjectionMatrix` (mat4)
`uMainSampler` (sampler2D array)

The pipeline is structurally identical to the Multi Pipeline and should be treated as such.


longname: Phaser.Renderer.WebGL.Pipelines.SinglePipeline
since: 3.50.0
name: SinglePipeline
memberof: Phaser.Renderer.WebGL.Pipelines
metafilename: SinglePipeline.js
metapath: renderer/webgl/pipelines
description:
The Single Pipeline is a special version of the Multi Pipeline that only ever
uses one texture, bound to texture unit zero. Although not as efficient as the
Multi Pipeline, it provides an easier way to create custom pipelines that only require
a single bound texture.

Prior to Phaser v3.50 this pipeline didn't exist, but could be compared to the old `TextureTintPipeline`.

The fragment shader it uses can be found in `shaders/src/Single.frag`.
The vertex shader it uses can be found in `shaders/src/Single.vert`.

The default shader attributes for this pipeline are:

`inPosition` (vec2, offset 0)
`inTexCoord` (vec2, offset 8)
`inTexId` (float, offset 16) - this value is always zero in the Single Pipeline
`inTintEffect` (float, offset 20)
`inTint` (vec4, offset 24, normalized)

The default shader uniforms for this pipeline are:

`uProjectionMatrix` (mat4)
`uMainSampler` (sampler2D)


longname: Phaser.Renderer.WebGL.Pipelines.UtilityPipeline
since: 3.50.0
name: UtilityPipeline
memberof: Phaser.Renderer.WebGL.Pipelines
metafilename: UtilityPipeline.js
metapath: renderer/webgl/pipelines
description:
The Utility Pipeline is a special-use pipeline that belongs to the Pipeline Manager.

It provides 4 shaders and handy associated methods:

1) Copy Shader. A fast texture to texture copy shader with optional brightness setting.
2) Additive Blend Mode Shader. Blends two textures using an additive blend mode.
3) Linear Blend Mode Shader. Blends two textures using a linear blend mode.
4) Color Matrix Copy Shader. Draws a texture to a target using a Color Matrix.

You do not extend this pipeline, but instead get a reference to it from the Pipeline
Manager via the `setUtility` method. You can also access methods such as `copyFrame`
directly from the Pipeline Manager.

This pipeline provides methods for manipulating framebuffer backed textures, such as
copying or blending one texture to another, copying a portion of a texture, additively
blending two textures, flipping textures and more.

The default shader attributes for this pipeline are:

`inPosition` (vec2, offset 0)
`inTexCoord` (vec2, offset 8)

This pipeline has a hard-coded batch size of 1 and a hard coded set of vertices.


longname: Phaser.Renderer.WebGL.RenderTarget
since: 3.50.0
name: RenderTarget
memberof: Phaser.Renderer.WebGL
metafilename: RenderTarget.js
metapath: renderer/webgl
description:
A Render Target encapsulates a WebGL framebuffer and the WebGL Texture that displays it.

Instances of this class are typically created by, and belong to WebGL Pipelines, however
other Game Objects and classes can take advantage of Render Targets as well.


longname: Phaser.Renderer.WebGL.WebGLPipeline
since: 3.0.0
name: WebGLPipeline
memberof: Phaser.Renderer.WebGL
metafilename: WebGLPipeline.js
metapath: renderer/webgl
description:
The `WebGLPipeline` is a base class used by all of the core Phaser pipelines.

It describes the way elements will be rendered in WebGL. Internally, it handles
compiling the shaders, creating vertex buffers, assigning primitive topology and
binding vertex attributes, all based on the given configuration data.

The pipeline is configured by passing in a `WebGLPipelineConfig` object. Please
see the documentation for this type to fully understand the configuration options
available to you.

Usually, you would not extend from this class directly, but would instead extend
from one of the core pipelines, such as the Multi Pipeline.

The pipeline flow per render-step is as follows:

1) onPreRender - called once at the start of the render step
2) onRender - call for each Scene Camera that needs to render (so can be multiple times per render step)
3) Internal flow:
3a)   bind (only called if a Game Object is using this pipeline and it's not currently active)
3b)   onBind (called for every Game Object that uses this pipeline)
3c)   flush (can be called by a Game Object, internal method or from outside by changing pipeline)
4) onPostRender - called once at the end of the render step


longname: Phaser.Renderer.WebGL.WebGLRenderer
since: 3.0.0
name: WebGLRenderer
memberof: Phaser.Renderer.WebGL
metafilename: WebGLRenderer.js
metapath: renderer/webgl
description:
WebGLRenderer is a class that contains the needed functionality to keep the
WebGLRenderingContext state clean. The main idea of the WebGLRenderer is to keep track of
any context change that happens for WebGL rendering inside of Phaser. This means
if raw webgl functions are called outside the WebGLRenderer of the Phaser WebGL
rendering ecosystem they might pollute the current WebGLRenderingContext state producing
unexpected behavior. It's recommended that WebGL interaction is done through
WebGLRenderer and/or WebGLPipeline.


longname: Phaser.Renderer.WebGL.WebGLShader
since: 3.50.0
name: WebGLShader
memberof: Phaser.Renderer.WebGL
metafilename: WebGLShader.js
metapath: renderer/webgl
description:
Instances of the WebGLShader class belong to the WebGL Pipeline classes. When the pipeline is
created it will create an instance of this class for each one of its shaders, as defined in
the pipeline configuration.

This class encapsulates everything needed to manage a shader in a pipeline, including the
shader attributes and uniforms, as well as lots of handy methods such as `set2f`, for setting
uniform values on this shader.

Typically, you do not create an instance of this class directly, as it works in unison with
the pipeline to which it belongs. You can gain access to this class via a pipeline's `shaders`
array, post-creation.


longname: Phaser.Scale.ScaleManager
since: 3.16.0
name: ScaleManager
memberof: Phaser.Scale
metafilename: ScaleManager.js
metapath: scale
description:
The Scale Manager handles the scaling, resizing and alignment of the game canvas.

The way scaling is handled is by setting the game canvas to a fixed size, which is defined in the
game configuration. You also define the parent container in the game config. If no parent is given,
it will default to using the document body. The Scale Manager will then look at the available space
within the _parent_ and scale the canvas accordingly. Scaling is handled by setting the canvas CSS
width and height properties, leaving the width and height of the canvas element itself untouched.
Scaling is therefore achieved by keeping the core canvas the same size and 'stretching'
it via its CSS properties. This gives the same result and speed as using the `transform-scale` CSS
property, without the need for browser prefix handling.

The calculations for the scale are heavily influenced by the bounding parent size, which is the computed
dimensions of the canvas's parent. The CSS rules of the parent element play an important role in the
operation of the Scale Manager. For example, if the parent has no defined width or height, then actions
like auto-centering will fail to achieve the required result. The Scale Manager works in tandem with the
CSS you set-up on the page hosting your game, rather than taking control of it.

#### Parent and Display canvas containment guidelines:

- Style the Parent element (of the game canvas) to control the Parent size and thus the games size and layout.

- The Parent element's CSS styles should _effectively_ apply maximum (and minimum) bounding behavior.

- The Parent element should _not_ apply a padding as this is not accounted for.
  If a padding is required apply it to the Parent's parent or apply a margin to the Parent.
  If you need to add a border, margin or any other CSS around your game container, then use a parent element and
  apply the CSS to this instead, otherwise you'll be constantly resizing the shape of the game container.

- The Display canvas layout CSS styles (i.e. margins, size) should not be altered / specified as
  they may be updated by the Scale Manager.

#### Scale Modes

The way the scaling is handled is determined by the `scaleMode` property. The default is `NONE`,
which prevents Phaser from scaling or touching the canvas, or its parent, at all. In this mode, you are
responsible for all scaling. The other scaling modes afford you automatic scaling.

If you wish to scale your game so that it always fits into the available space within the parent, you
should use the scale mode `FIT`. Look at the documentation for other scale modes to see what options are
available. Here is a basic config showing how to set this scale mode:

```javascript
scale: {
    parent: 'yourgamediv',
    mode: Phaser.Scale.FIT,
    width: 800,
    height: 600
}
```

Place the `scale` config object within your game config.

If you wish for the canvas to be resized directly, so that the canvas itself fills the available space
(i.e. it isn't scaled, it's resized) then use the `RESIZE` scale mode. This will give you a 1:1 mapping
of canvas pixels to game size. In this mode CSS isn't used to scale the canvas, it's literally adjusted
to fill all available space within the parent. You should be extremely careful about the size of the
canvas you're creating when doing this, as the larger the area, the more work the GPU has to do and it's
very easy to hit fill-rate limits quickly.

For complex, custom-scaling requirements, you should probably consider using the `RESIZE` scale mode,
with your own limitations in place re: canvas dimensions and managing the scaling with the game scenes
yourself. For the vast majority of games, however, the `FIT` mode is likely to be the most used.

Please appreciate that the Scale Manager cannot perform miracles. All it does is scale your game canvas
as best it can, based on what it can infer from its surrounding area. There are all kinds of environments
where it's up to you to guide and help the canvas position itself, especially when built into rendering
frameworks like React and Vue. If your page requires meta tags to prevent user scaling gestures, or such
like, then it's up to you to ensure they are present in the html.

#### Centering

You can also have the game canvas automatically centered. Again, this relies heavily on the parent being
properly configured and styled, as the centering offsets are based entirely on the available space
within the parent element. Centering is disabled by default, or can be applied horizontally, vertically,
or both. Here's an example:

```javascript
scale: {
    parent: 'yourgamediv',
    autoCenter: Phaser.Scale.CENTER_BOTH,
    width: 800,
    height: 600
}
```

#### Fullscreen API

If the browser supports it, you can send your game into fullscreen mode. In this mode, the game will fill
the entire display, removing all browser UI and anything else present on the screen. It will remain in this
mode until your game either disables it, or until the user tabs out or presses ESCape if on desktop. It's a
great way to achieve a desktop-game like experience from the browser, but it does require a modern browser
to handle it. Some mobile browsers also support this.


longname: Phaser.Scene
since: 3.0.0
name: Scene
memberof: Phaser
metafilename: Scene.js
metapath: scene
description:
A base Phaser.Scene class which can be extended for your own use.

You can also define the optional methods [init()](Phaser.Types.Scenes.SceneInitCallback), [preload()](Phaser.Types.Scenes.ScenePreloadCallback), and [create()](Phaser.Types.Scenes.SceneCreateCallback).


longname: Phaser.Scenes.SceneManager
since: 3.0.0
name: SceneManager
memberof: Phaser.Scenes
metafilename: SceneManager.js
metapath: scene
description:
The Scene Manager.

The Scene Manager is a Game level system, responsible for creating, processing and updating all of the
Scenes in a Game instance.

You should not usually interact directly with the Scene Manager at all. Instead, you should use
the Scene Plugin, which is available from every Scene in your game via the `this.scene` property.

Using methods in this Scene Manager directly will break queued operations and can cause runtime
errors. Instead, go via the Scene Plugin. Every feature this Scene Manager provides is also
available via the Scene Plugin.


longname: Phaser.Scenes.ScenePlugin
since: 3.0.0
name: ScenePlugin
memberof: Phaser.Scenes
metafilename: ScenePlugin.js
metapath: scene
description:
The Scene Plugin is the main interface to the Scene Manager and allows you to control
any Scene running in your game. You should always use this plugin. By default, it is
mapped to the Scene property `this.scene`. Meaning, from within a Scene, you can call
methods such as `this.scene.start()`.

Note that nearly all methods in this class are run on a queue-basis and not
immediately. For example, calling `this.scene.launch('SceneB')` will try to
launch SceneB when the Scene Manager next updates, which is at the start of the game
step. All operations are queued and run in the order in which they are invoked here.


longname: Phaser.Scenes.Systems
since: 3.0.0
name: Systems
memberof: Phaser.Scenes
metafilename: Systems.js
metapath: scene
description:
The Scene Systems class.

This class is available from within a Scene under the property `sys`.
It is responsible for managing all of the plugins a Scene has running, including the display list, and
handling the update step and renderer. It also contains references to global systems belonging to Game.


longname: Phaser.Sound.BaseSound
since: 3.0.0
name: BaseSound
memberof: Phaser.Sound
metafilename: BaseSound.js
metapath: sound
description:
Class containing all the shared state and behavior of a sound object, independent of the implementation.


longname: Phaser.Sound.NoAudioSound
since: 3.0.0
name: NoAudioSound
memberof: Phaser.Sound
metafilename: NoAudioSound.js
metapath: sound/noaudio
description:
No audio implementation of the sound. It is used if audio has been
disabled in the game config or the device doesn't support any audio.

It represents a graceful degradation of sound logic that provides
minimal functionality and prevents Phaser projects that use audio from
breaking on devices that don't support any audio playback technologies.


longname: Phaser.Sound.NoAudioSoundManager
since: 3.0.0
name: NoAudioSoundManager
memberof: Phaser.Sound
metafilename: NoAudioSoundManager.js
metapath: sound/noaudio
description:
No-audio implementation of the Sound Manager. It is used if audio has been
disabled in the game config or the device doesn't support any audio.

It represents a graceful degradation of Sound Manager logic that provides
minimal functionality and prevents Phaser projects that use audio from
breaking on devices that don't support any audio playback technologies.


longname: Phaser.Sound.WebAudioSoundManager
since: 3.0.0
name: WebAudioSoundManager
memberof: Phaser.Sound
metafilename: WebAudioSoundManager.js
metapath: sound/webaudio
description:
Web Audio API implementation of the Sound Manager.

Not all browsers can play all audio formats.

There is a good guide to what's supported: [Cross-browser audio basics: Audio codec support](https://developer.mozilla.org/en-US/Apps/Fundamentals/Audio_and_video_delivery/Cross-browser_audio_basics#Audio_Codec_Support).


longname: Phaser.Structs.List
since: 3.0.0
name: List
memberof: Phaser.Structs
metafilename: List.js
metapath: structs
description:
List is a generic implementation of an ordered list which contains utility methods for retrieving, manipulating, and iterating items.


longname: Phaser.Structs.Map
since: 3.0.0
name: Map
memberof: Phaser.Structs
metafilename: Map.js
metapath: structs
description:
The keys of a Map can be arbitrary values.

```javascript
var map = new Map([
   [ 1, 'one' ],
   [ 2, 'two' ],
   [ 3, 'three' ]
]);
```


longname: Phaser.Structs.ProcessQueue
since: 3.0.0
name: ProcessQueue
memberof: Phaser.Structs
metafilename: ProcessQueue.js
metapath: structs
description:
A Process Queue maintains three internal lists.

The `pending` list is a selection of items which are due to be made 'active' in the next update.
The `active` list is a selection of items which are considered active and should be updated.
The `destroy` list is a selection of items that were active and are awaiting being destroyed in the next update.

When new items are added to a Process Queue they are put in the pending list, rather than being added
immediately the active list. Equally, items that are removed are put into the destroy list, rather than
being destroyed immediately. This allows the Process Queue to carefully process each item at a specific, fixed
time, rather than at the time of the request from the API.


longname: Phaser.Structs.RTree
since: 3.0.0
name: RTree
memberof: Phaser.Structs
metafilename: RTree.js
metapath: structs
description:
RBush is a high-performance JavaScript library for 2D spatial indexing of points and rectangles.
It's based on an optimized R-tree data structure with bulk insertion support.

Spatial index is a special data structure for points and rectangles that allows you to perform queries like
"all items within this bounding box" very efficiently (e.g. hundreds of times faster than looping over all items).

This version of RBush uses a fixed min/max accessor structure of `[ '.left', '.top', '.right', '.bottom' ]`.
This is to avoid the eval like function creation that the original library used, which caused CSP policy violations.

rbush is forked from [https://github.com/mourner/rbush](https://github.com/mourner/rbush) by Vladimir Agafonkin


longname: Phaser.Structs.Size
since: 3.16.0
name: Size
memberof: Phaser.Structs
metafilename: Size.js
metapath: structs
description:
The Size component allows you to set `width` and `height` properties and define the relationship between them.

The component can automatically maintain the aspect ratios between the two values, and clamp them
to a defined min-max range. You can also control the dominant axis. When dimensions are given to the Size component
that would cause it to exceed its min-max range, the dimensions are adjusted based on the dominant axis.


longname: Phaser.Textures.CanvasTexture
since: 3.7.0
name: CanvasTexture
memberof: Phaser.Textures
metafilename: CanvasTexture.js
metapath: textures
description:
A Canvas Texture is a special kind of Texture that is backed by an HTML Canvas Element as its source.

You can use the properties of this texture to draw to the canvas element directly, using all of the standard
canvas operations available in the browser. Any Game Object can be given this texture and will render with it.

Note: When running under WebGL the Canvas Texture needs to re-generate its base WebGLTexture and reupload it to
the GPU every time you modify it, otherwise the changes you make to this texture will not be visible. To do this
you should call `CanvasTexture.refresh()` once you are finished with your changes to the canvas. Try and keep
this to a minimum, especially on large canvas sizes, or you may inadvertently thrash the GPU by constantly uploading
texture data to it. This restriction does not apply if using the Canvas Renderer.

It starts with only one frame that covers the whole of the canvas. You can add further frames, that specify
sections of the canvas using the `add` method.

Should you need to resize the canvas use the `setSize` method so that it accurately updates all of the underlying
texture data as well. Forgetting to do this (i.e. by changing the canvas size directly from your code) could cause
graphical errors.


longname: Phaser.Textures.Texture
since: 3.0.0
name: Texture
memberof: Phaser.Textures
metafilename: Texture.js
metapath: textures
description:
A Texture consists of a source, usually an Image from the Cache, and a collection of Frames.
The Frames represent the different areas of the Texture. For example a texture atlas
may have many Frames, one for each element within the atlas. Where-as a single image would have
just one frame, that encompasses the whole image.

Every Texture, no matter where it comes from, always has at least 1 frame called the `__BASE` frame.
This frame represents the entirety of the source image.

Textures are managed by the global TextureManager. This is a singleton class that is
responsible for creating and delivering Textures and their corresponding Frames to Game Objects.

Sprites and other Game Objects get the texture data they need from the TextureManager.


longname: Phaser.Textures.TextureManager
since: 3.0.0
name: TextureManager
memberof: Phaser.Textures
metafilename: TextureManager.js
metapath: textures
description:
Textures are managed by the global TextureManager. This is a singleton class that is
responsible for creating and delivering Textures and their corresponding Frames to Game Objects.

Sprites and other Game Objects get the texture data they need from the TextureManager.

Access it via `scene.textures`.


longname: Phaser.Textures.TextureSource
since: 3.0.0
name: TextureSource
memberof: Phaser.Textures
metafilename: TextureSource.js
metapath: textures
description:
A Texture Source is the encapsulation of the actual source data for a Texture.

This is typically an Image Element, loaded from the file system or network, a Canvas Element or a Video Element.

A Texture can contain multiple Texture Sources, which only happens when a multi-atlas is loaded.


longname: Phaser.Tilemaps.ImageCollection
since: 3.0.0
name: ImageCollection
memberof: Phaser.Tilemaps
metafilename: ImageCollection.js
metapath: tilemaps
description:
An Image Collection is a special Tile Set containing multiple images, with no slicing into each image.

Image Collections are normally created automatically when Tiled data is loaded.


longname: Phaser.Tilemaps.LayerData
since: 3.0.0
name: LayerData
memberof: Phaser.Tilemaps
metafilename: LayerData.js
metapath: tilemaps/mapdata
description:
A class for representing data about about a layer in a map. Maps are parsed from CSV, Tiled,
etc. into this format. Tilemap and TilemapLayer objects have a reference
to this data and use it to look up and perform operations on tiles.


longname: Phaser.Tilemaps.MapData
since: 3.0.0
name: MapData
memberof: Phaser.Tilemaps
metafilename: MapData.js
metapath: tilemaps/mapdata
description:
A class for representing data about a map. Maps are parsed from CSV, Tiled, etc. into this
format. A Tilemap object get a copy of this data and then unpacks the needed properties into
itself.


longname: Phaser.Tilemaps.ObjectLayer
since: 3.0.0
name: ObjectLayer
memberof: Phaser.Tilemaps
metafilename: ObjectLayer.js
metapath: tilemaps/mapdata
description:
A class for representing a Tiled object layer in a map. This mirrors the structure of a Tiled
object layer, except:
 - "x" & "y" properties are ignored since these cannot be changed in Tiled.
 - "offsetx" & "offsety" are applied to the individual object coordinates directly, so they
   are ignored as well.
 - "draworder" is ignored.


longname: Phaser.Tilemaps.Tile
since: 3.0.0
name: Tile
memberof: Phaser.Tilemaps
metafilename: Tile.js
metapath: tilemaps
description:
A Tile is a representation of a single tile within the Tilemap. This is a lightweight data
representation, so its position information is stored without factoring in scroll, layer
scale or layer position.


longname: Phaser.Tilemaps.Tilemap
since: 3.0.0
name: Tilemap
memberof: Phaser.Tilemaps
metafilename: Tilemap.js
metapath: tilemaps
description:
A Tilemap is a container for Tilemap data. This isn't a display object, rather, it holds data
about the map and allows you to add tilesets and tilemap layers to it. A map can have one or
more tilemap layers, which are the display objects that actually render the tiles.

The Tilemap data can be parsed from a Tiled JSON file, a CSV file or a 2D array. Tiled is a free
software package specifically for creating tile maps, and is available from:
[http://www.mapeditor.org](http://www.mapeditor.org)

As of Phaser 3.50.0 the Tilemap API now supports the following types of map:

1) Orthogonal
2) Isometric
3) Hexagonal
4) Staggered

Prior to this release, only orthogonal maps were supported.

Another large change in 3.50 was the consolidation of Tilemap Layers. Previously, you created
either a Static or Dynamic Tilemap Layer. However, as of 3.50 the features of both have been
merged and the API simplified, so now there is just the single `TilemapLayer` class.

A Tilemap has handy methods for getting and manipulating the tiles within a layer, allowing
you to build or modify the tilemap data at runtime.

Note that all Tilemaps use a base tile size to calculate dimensions from, but that a
TilemapLayer may have its own unique tile size that overrides this.

As of Phaser 3.21.0, if your tilemap includes layer groups (a feature of Tiled 1.2.0+) these
will be traversed and the following properties will impact children:

- Opacity (blended with parent) and visibility (parent overrides child)
- Vertical and horizontal offset

The grouping hierarchy is not preserved and all layers will be flattened into a single array.

Group layers are parsed during Tilemap construction but are discarded after parsing so dynamic
layers will NOT continue to be affected by a parent.

To avoid duplicate layer names, a layer that is a child of a group layer will have its parent
group name prepended with a '/'.  For example, consider a group called 'ParentGroup' with a
child called 'Layer 1'. In the Tilemap object, 'Layer 1' will have the name
'ParentGroup/Layer 1'.


longname: Phaser.Tilemaps.TilemapLayer
since: 3.50.0
name: TilemapLayer
memberof: Phaser.Tilemaps
metafilename: TilemapLayer.js
metapath: tilemaps
description:
A Tilemap Layer is a Game Object that renders LayerData from a Tilemap when used in combination
with one, or more, Tilesets.


longname: Phaser.Tilemaps.Tileset
since: 3.0.0
name: Tileset
memberof: Phaser.Tilemaps
metafilename: Tileset.js
metapath: tilemaps
description:
A Tileset is a combination of an image containing the tiles and a container for data about
each tile.


longname: Phaser.Time.TimerEvent
since: 3.0.0
name: TimerEvent
memberof: Phaser.Time
metafilename: TimerEvent.js
metapath: time
description:
A Timer Event represents a delayed function call. It's managed by a Scene's [Clock](Clock) and will call its function after a set amount of time has passed. The Timer Event can optionally repeat - i.e. call its function multiple times before finishing, or loop indefinitely.

Because it's managed by a Clock, a Timer Event is based on game time, will be affected by its Clock's time scale, and will pause if its Clock pauses.


longname: Phaser.Tweens.Timeline
since: 3.0.0
name: Timeline
memberof: Phaser.Tweens
metafilename: Timeline.js
metapath: tweens
description:
A Timeline combines multiple Tweens into one. Its overall behavior is otherwise similar to a single Tween.

The Timeline updates all of its Tweens simultaneously. Its methods allow you to easily build a sequence
of Tweens (each one starting after the previous one) or run multiple Tweens at once during given parts of the Timeline.


longname: Phaser.Tweens.Tween
since: 3.0.0
name: Tween
memberof: Phaser.Tweens
metafilename: Tween.js
metapath: tweens/tween
description:
A Tween is able to manipulate the properties of one or more objects to any given value, based
on a duration and type of ease. They are rarely instantiated directly and instead should be
created via the TweenManager.


longname: Phaser.FacebookInstantGamesPlugin
since: 3.13.0
name: FacebookInstantGamesPlugin
memberof: Phaser
metafilename: FacebookInstantGamesPlugin.js
description:
The Facebook Instant Games Plugin for Phaser 3 provides a seamless bridge between Phaser
and the Facebook Instant Games API version 6.2.

You can access this plugin via the `facebook` property in a Scene, i.e:

```javascript
this.facebook.getPlatform();
```

If this is unavailable please check to make sure you're using a build of Phaser that has
this plugin within it. You can quickly check this by looking at the dev tools console
header - the Phaser version number will have `-FB` after it if this plugin is loaded.

If you are building your own version of Phaser then use this Webpack DefinePlugin flag:

`"typeof PLUGIN_FBINSTANT": JSON.stringify(true)`

You will find that every Instant Games API method has a mapping in this plugin.
For a full list please consult either the plugin documentation, or the 6.2 SDK documentation
at [https://developers.facebook.com/docs/games/instant-games/sdk/fbinstant6.2](https://developers.facebook.com/docs/games/instant-games/sdk/fbinstant6.2)

Internally this plugin uses its own Data Manager to handle seamless user data updates and provides
handy functions for advertisement displaying, opening share dialogs, logging, leaderboards, purchase API requests,
loader integration and more.

To get started with Facebook Instant Games you will need to register on Facebook and create a new Instant
Game app that has its own unique app ID. Facebook have also provided a dashboard interface for setting up
various features for your game, including leaderboards, ad requests and the payments API. There are lots
of guides on the Facebook Developers portal to assist with setting these
various systems up: [https://developers.facebook.com/docs/games/instant-games/guides](https://developers.facebook.com/docs/games/instant-games/guides)

For more details follow the Quick Start guide here: [https://developers.facebook.com/docs/games/instant-games](https://developers.facebook.com/docs/games/instant-games)


longname: Phaser.FacebookInstantGamesLeaderboard
since: 3.13.0
name: FacebookInstantGamesLeaderboard
memberof: Phaser
metafilename: Leaderboard.js
description:
This class represents one single Leaderboard that belongs to a Facebook Instant Game.

You do not need to instantiate this class directly, it will be created when you use the
`getLeaderboard()` method of the main plugin.


# event

longname: Phaser.Animations.Events.ADD_ANIMATION
since: 3.0.0
name: ADD_ANIMATION
memberof: Phaser.Animations.Events
metafilename: ADD_ANIMATION_EVENT.js
metapath: animations/events
description:
The Add Animation Event.

This event is dispatched when a new animation is added to the global Animation Manager.

This can happen either as a result of an animation instance being added to the Animation Manager,
or the Animation Manager creating a new animation directly.


longname: Phaser.Animations.Events.ANIMATION_COMPLETE
since: 3.50.0
name: ANIMATION_COMPLETE
memberof: Phaser.Animations.Events
metafilename: ANIMATION_COMPLETE_EVENT.js
metapath: animations/events
description:
The Animation Complete Event.

This event is dispatched by a Sprite when an animation playing on it completes playback.
This happens when the animation gets to the end of its sequence, factoring in any delays
or repeats it may have to process.

An animation that is set to loop, or repeat forever, will never fire this event, because
it never actually completes. If you need to handle this, listen for the `ANIMATION_STOP`
event instead, as this is emitted when the animation is stopped directly.

Listen for it on the Sprite using `sprite.on('animationcomplete', listener)`

The animation event flow is as follows:

1. `ANIMATION_START`
2. `ANIMATION_UPDATE` (repeated for however many frames the animation has)
3. `ANIMATION_REPEAT` (only if the animation is set to repeat, it then emits more update events after this)
4. `ANIMATION_COMPLETE` (only if there is a finite, or zero, repeat count)
5. `ANIMATION_COMPLETE_KEY` (only if there is a finite, or zero, repeat count)

If the animation is stopped directly, the `ANIMATION_STOP` event is dispatched instead of `ANIMATION_COMPLETE`.

If the animation is restarted while it is already playing, `ANIMATION_RESTART` is emitted.


longname: Phaser.Animations.Events.ANIMATION_COMPLETE_KEY
since: 3.50.0
name: ANIMATION_COMPLETE_KEY
memberof: Phaser.Animations.Events
metafilename: ANIMATION_COMPLETE_KEY_EVENT.js
metapath: animations/events
description:
The Animation Complete Dynamic Key Event.

This event is dispatched by a Sprite when an animation playing on it completes playback.
This happens when the animation gets to the end of its sequence, factoring in any delays
or repeats it may have to process.

An animation that is set to loop, or repeat forever, will never fire this event, because
it never actually completes. If you need to handle this, listen for the `ANIMATION_STOP`
event instead, as this is emitted when the animation is stopped directly.

The difference between this and the `ANIMATION_COMPLETE` event is that this one has a
dynamic event name that contains the name of the animation within it. For example,
if you had an animation called `explode` you could listen for the completion of that
specific animation by using: `sprite.on('animationcomplete-explode', listener)`. Or, if you
wish to use types: `sprite.on(Phaser.Animations.Events.ANIMATION_COMPLETE_KEY + 'explode', listener)`.

The animation event flow is as follows:

1. `ANIMATION_START`
2. `ANIMATION_UPDATE` (repeated for however many frames the animation has)
3. `ANIMATION_REPEAT` (only if the animation is set to repeat, it then emits more update events after this)
4. `ANIMATION_COMPLETE` (only if there is a finite, or zero, repeat count)
5. `ANIMATION_COMPLETE_KEY` (only if there is a finite, or zero, repeat count)

If the animation is stopped directly, the `ANIMATION_STOP` event is dispatched instead of `ANIMATION_COMPLETE`.

If the animation is restarted while it is already playing, `ANIMATION_RESTART` is emitted.


longname: Phaser.Animations.Events.ANIMATION_REPEAT
since: 3.50.0
name: ANIMATION_REPEAT
memberof: Phaser.Animations.Events
metafilename: ANIMATION_REPEAT_EVENT.js
metapath: animations/events
description:
The Animation Repeat Event.

This event is dispatched by a Sprite when an animation repeats playing on it.
This happens if the animation was created, or played, with a `repeat` value specified.

An animation will repeat when it reaches the end of its sequence.

Listen for it on the Sprite using `sprite.on('animationrepeat', listener)`

The animation event flow is as follows:

1. `ANIMATION_START`
2. `ANIMATION_UPDATE` (repeated for however many frames the animation has)
3. `ANIMATION_REPEAT` (only if the animation is set to repeat, it then emits more update events after this)
4. `ANIMATION_COMPLETE` (only if there is a finite, or zero, repeat count)
5. `ANIMATION_COMPLETE_KEY` (only if there is a finite, or zero, repeat count)

If the animation is stopped directly, the `ANIMATION_STOP` event is dispatched instead of `ANIMATION_COMPLETE`.

If the animation is restarted while it is already playing, `ANIMATION_RESTART` is emitted.


longname: Phaser.Animations.Events.ANIMATION_RESTART
since: 3.50.0
name: ANIMATION_RESTART
memberof: Phaser.Animations.Events
metafilename: ANIMATION_RESTART_EVENT.js
metapath: animations/events
description:
The Animation Restart Event.

This event is dispatched by a Sprite when an animation restarts playing on it.
This only happens when the `Sprite.anims.restart` method is called.

Listen for it on the Sprite using `sprite.on('animationrestart', listener)`

The animation event flow is as follows:

1. `ANIMATION_START`
2. `ANIMATION_UPDATE` (repeated for however many frames the animation has)
3. `ANIMATION_REPEAT` (only if the animation is set to repeat, it then emits more update events after this)
4. `ANIMATION_COMPLETE` (only if there is a finite, or zero, repeat count)
5. `ANIMATION_COMPLETE_KEY` (only if there is a finite, or zero, repeat count)

If the animation is stopped directly, the `ANIMATION_STOP` event is dispatched instead of `ANIMATION_COMPLETE`.

If the animation is restarted while it is already playing, `ANIMATION_RESTART` is emitted.


longname: Phaser.Animations.Events.ANIMATION_START
since: 3.50.0
name: ANIMATION_START
memberof: Phaser.Animations.Events
metafilename: ANIMATION_START_EVENT.js
metapath: animations/events
description:
The Animation Start Event.

This event is dispatched by a Sprite when an animation starts playing on it.
This happens when the animation is played, factoring in any delay that may have been specified.
This event happens after the delay has expired and prior to the first update event.

Listen for it on the Sprite using `sprite.on('animationstart', listener)`

The animation event flow is as follows:

1. `ANIMATION_START`
2. `ANIMATION_UPDATE` (repeated for however many frames the animation has)
3. `ANIMATION_REPEAT` (only if the animation is set to repeat, it then emits more update events after this)
4. `ANIMATION_COMPLETE` (only if there is a finite, or zero, repeat count)
5. `ANIMATION_COMPLETE_KEY` (only if there is a finite, or zero, repeat count)

If the animation is stopped directly, the `ANIMATION_STOP` event is dispatched instead of `ANIMATION_COMPLETE`.

If the animation is restarted while it is already playing, `ANIMATION_RESTART` is emitted.


longname: Phaser.Animations.Events.ANIMATION_STOP
since: 3.50.0
name: ANIMATION_STOP
memberof: Phaser.Animations.Events
metafilename: ANIMATION_STOP_EVENT.js
metapath: animations/events
description:
The Animation Stop Event.

This event is dispatched by a Sprite when an animation is stopped on it. An animation
will only be stopeed if a method such as `Sprite.stop` or `Sprite.anims.stopAfterDelay`
is called. It can also be emitted if a new animation is started before the current one completes.

Listen for it on the Sprite using `sprite.on('animationstop', listener)`

The animation event flow is as follows:

1. `ANIMATION_START`
2. `ANIMATION_UPDATE` (repeated for however many frames the animation has)
3. `ANIMATION_REPEAT` (only if the animation is set to repeat, it then emits more update events after this)
4. `ANIMATION_COMPLETE` (only if there is a finite, or zero, repeat count)
5. `ANIMATION_COMPLETE_KEY` (only if there is a finite, or zero, repeat count)

If the animation is stopped directly, the `ANIMATION_STOP` event is dispatched instead of `ANIMATION_COMPLETE`.

If the animation is restarted while it is already playing, `ANIMATION_RESTART` is emitted.


longname: Phaser.Animations.Events.ANIMATION_UPDATE
since: 3.50.0
name: ANIMATION_UPDATE
memberof: Phaser.Animations.Events
metafilename: ANIMATION_UPDATE_EVENT.js
metapath: animations/events
description:
The Animation Update Event.

This event is dispatched by a Sprite when an animation playing on it updates. This happens when the animation changes frame.
An animation will change frame based on the frme rate and other factors like `timeScale` and `delay`. It can also change
frame when stopped or restarted.

Listen for it on the Sprite using `sprite.on('animationupdate', listener)`

If an animation is playing faster than the game frame-rate can handle, it's entirely possible for it to emit several
update events in a single game frame, so please be aware of this in your code. The **final** event received that frame
is the one that is rendered to the game.

The animation event flow is as follows:

1. `ANIMATION_START`
2. `ANIMATION_UPDATE` (repeated for however many frames the animation has)
3. `ANIMATION_REPEAT` (only if the animation is set to repeat, it then emits more update events after this)
4. `ANIMATION_COMPLETE` (only if there is a finite, or zero, repeat count)
5. `ANIMATION_COMPLETE_KEY` (only if there is a finite, or zero, repeat count)

If the animation is stopped directly, the `ANIMATION_STOP` event is dispatched instead of `ANIMATION_COMPLETE`.

If the animation is restarted while it is already playing, `ANIMATION_RESTART` is emitted.


longname: Phaser.Animations.Events.PAUSE_ALL
since: 3.0.0
name: PAUSE_ALL
memberof: Phaser.Animations.Events
metafilename: PAUSE_ALL_EVENT.js
metapath: animations/events
description:
The Pause All Animations Event.

This event is dispatched when the global Animation Manager is told to pause.

When this happens all current animations will stop updating, although it doesn't necessarily mean
that the game has paused as well.


longname: Phaser.Animations.Events.REMOVE_ANIMATION
since: 3.0.0
name: REMOVE_ANIMATION
memberof: Phaser.Animations.Events
metafilename: REMOVE_ANIMATION_EVENT.js
metapath: animations/events
description:
The Remove Animation Event.

This event is dispatched when an animation is removed from the global Animation Manager.


longname: Phaser.Animations.Events.RESUME_ALL
since: 3.0.0
name: RESUME_ALL
memberof: Phaser.Animations.Events
metafilename: RESUME_ALL_EVENT.js
metapath: animations/events
description:
The Resume All Animations Event.

This event is dispatched when the global Animation Manager resumes, having been previously paused.

When this happens all current animations will continue updating again.


longname: Phaser.Cache.Events.ADD
since: 3.0.0
name: ADD
memberof: Phaser.Cache.Events
metafilename: ADD_EVENT.js
metapath: cache/events
description:
The Cache Add Event.

This event is dispatched by any Cache that extends the BaseCache each time a new object is added to it.


longname: Phaser.Cache.Events.REMOVE
since: 3.0.0
name: REMOVE
memberof: Phaser.Cache.Events
metafilename: REMOVE_EVENT.js
metapath: cache/events
description:
The Cache Remove Event.

This event is dispatched by any Cache that extends the BaseCache each time an object is removed from it.


longname: Phaser.Cameras.Scene2D.Events.DESTROY
since: 3.0.0
name: DESTROY
memberof: Phaser.Cameras.Scene2D.Events
metafilename: DESTROY_EVENT.js
metapath: cameras/2d/events
description:
The Destroy Camera Event.

This event is dispatched by a Camera instance when it is destroyed by the Camera Manager.


longname: Phaser.Cameras.Scene2D.Events.FADE_IN_COMPLETE
since: 3.3.0
name: FADE_IN_COMPLETE
memberof: Phaser.Cameras.Scene2D.Events
metafilename: FADE_IN_COMPLETE_EVENT.js
metapath: cameras/2d/events
description:
The Camera Fade In Complete Event.

This event is dispatched by a Camera instance when the Fade In Effect completes.

Listen to it from a Camera instance using `Camera.on('camerafadeincomplete', listener)`.


longname: Phaser.Cameras.Scene2D.Events.FADE_IN_START
since: 3.3.0
name: FADE_IN_START
memberof: Phaser.Cameras.Scene2D.Events
metafilename: FADE_IN_START_EVENT.js
metapath: cameras/2d/events
description:
The Camera Fade In Start Event.

This event is dispatched by a Camera instance when the Fade In Effect starts.

Listen to it from a Camera instance using `Camera.on('camerafadeinstart', listener)`.


longname: Phaser.Cameras.Scene2D.Events.FADE_OUT_COMPLETE
since: 3.3.0
name: FADE_OUT_COMPLETE
memberof: Phaser.Cameras.Scene2D.Events
metafilename: FADE_OUT_COMPLETE_EVENT.js
metapath: cameras/2d/events
description:
The Camera Fade Out Complete Event.

This event is dispatched by a Camera instance when the Fade Out Effect completes.

Listen to it from a Camera instance using `Camera.on('camerafadeoutcomplete', listener)`.


longname: Phaser.Cameras.Scene2D.Events.FADE_OUT_START
since: 3.3.0
name: FADE_OUT_START
memberof: Phaser.Cameras.Scene2D.Events
metafilename: FADE_OUT_START_EVENT.js
metapath: cameras/2d/events
description:
The Camera Fade Out Start Event.

This event is dispatched by a Camera instance when the Fade Out Effect starts.

Listen to it from a Camera instance using `Camera.on('camerafadeoutstart', listener)`.


longname: Phaser.Cameras.Scene2D.Events.FLASH_COMPLETE
since: 3.3.0
name: FLASH_COMPLETE
memberof: Phaser.Cameras.Scene2D.Events
metafilename: FLASH_COMPLETE_EVENT.js
metapath: cameras/2d/events
description:
The Camera Flash Complete Event.

This event is dispatched by a Camera instance when the Flash Effect completes.


longname: Phaser.Cameras.Scene2D.Events.FLASH_START
since: 3.3.0
name: FLASH_START
memberof: Phaser.Cameras.Scene2D.Events
metafilename: FLASH_START_EVENT.js
metapath: cameras/2d/events
description:
The Camera Flash Start Event.

This event is dispatched by a Camera instance when the Flash Effect starts.


longname: Phaser.Cameras.Scene2D.Events.FOLLOW_UPDATE
since: 3.50.0
name: FOLLOW_UPDATE
memberof: Phaser.Cameras.Scene2D.Events
metafilename: FOLLOW_UPDATE_EVENT.js
metapath: cameras/2d/events
description:
The Camera Follower Update Event.

This event is dispatched by a Camera instance when it is following a
Game Object and the Camera position has been updated as a result of
that following.

Listen to it from a Camera instance using: `camera.on('followupdate', listener)`.


longname: Phaser.Cameras.Scene2D.Events.PAN_COMPLETE
since: 3.3.0
name: PAN_COMPLETE
memberof: Phaser.Cameras.Scene2D.Events
metafilename: PAN_COMPLETE_EVENT.js
metapath: cameras/2d/events
description:
The Camera Pan Complete Event.

This event is dispatched by a Camera instance when the Pan Effect completes.


longname: Phaser.Cameras.Scene2D.Events.PAN_START
since: 3.3.0
name: PAN_START
memberof: Phaser.Cameras.Scene2D.Events
metafilename: PAN_START_EVENT.js
metapath: cameras/2d/events
description:
The Camera Pan Start Event.

This event is dispatched by a Camera instance when the Pan Effect starts.


longname: Phaser.Cameras.Scene2D.Events.POST_RENDER
since: 3.0.0
name: POST_RENDER
memberof: Phaser.Cameras.Scene2D.Events
metafilename: POST_RENDER_EVENT.js
metapath: cameras/2d/events
description:
The Camera Post-Render Event.

This event is dispatched by a Camera instance after is has finished rendering.
It is only dispatched if the Camera is rendering to a texture.

Listen to it from a Camera instance using: `camera.on('postrender', listener)`.


longname: Phaser.Cameras.Scene2D.Events.PRE_RENDER
since: 3.0.0
name: PRE_RENDER
memberof: Phaser.Cameras.Scene2D.Events
metafilename: PRE_RENDER_EVENT.js
metapath: cameras/2d/events
description:
The Camera Pre-Render Event.

This event is dispatched by a Camera instance when it is about to render.
It is only dispatched if the Camera is rendering to a texture.

Listen to it from a Camera instance using: `camera.on('prerender', listener)`.


longname: Phaser.Cameras.Scene2D.Events.ROTATE_COMPLETE
since: 3.23.0
name: ROTATE_COMPLETE
memberof: Phaser.Cameras.Scene2D.Events
metafilename: ROTATE_COMPLETE_EVENT.js
metapath: cameras/2d/events
description:
The Camera Rotate Complete Event.

This event is dispatched by a Camera instance when the Rotate Effect completes.


longname: Phaser.Cameras.Scene2D.Events.ROTATE_START
since: 3.23.0
name: ROTATE_START
memberof: Phaser.Cameras.Scene2D.Events
metafilename: ROTATE_START_EVENT.js
metapath: cameras/2d/events
description:
The Camera Rotate Start Event.

This event is dispatched by a Camera instance when the Rotate Effect starts.


longname: Phaser.Cameras.Scene2D.Events.SHAKE_COMPLETE
since: 3.3.0
name: SHAKE_COMPLETE
memberof: Phaser.Cameras.Scene2D.Events
metafilename: SHAKE_COMPLETE_EVENT.js
metapath: cameras/2d/events
description:
The Camera Shake Complete Event.

This event is dispatched by a Camera instance when the Shake Effect completes.


longname: Phaser.Cameras.Scene2D.Events.SHAKE_START
since: 3.3.0
name: SHAKE_START
memberof: Phaser.Cameras.Scene2D.Events
metafilename: SHAKE_START_EVENT.js
metapath: cameras/2d/events
description:
The Camera Shake Start Event.

This event is dispatched by a Camera instance when the Shake Effect starts.


longname: Phaser.Cameras.Scene2D.Events.ZOOM_COMPLETE
since: 3.3.0
name: ZOOM_COMPLETE
memberof: Phaser.Cameras.Scene2D.Events
metafilename: ZOOM_COMPLETE_EVENT.js
metapath: cameras/2d/events
description:
The Camera Zoom Complete Event.

This event is dispatched by a Camera instance when the Zoom Effect completes.


longname: Phaser.Cameras.Scene2D.Events.ZOOM_START
since: 3.3.0
name: ZOOM_START
memberof: Phaser.Cameras.Scene2D.Events
metafilename: ZOOM_START_EVENT.js
metapath: cameras/2d/events
description:
The Camera Zoom Start Event.

This event is dispatched by a Camera instance when the Zoom Effect starts.


longname: Phaser.Core.Events.BLUR
since: 3.0.0
name: BLUR
memberof: Phaser.Core.Events
metafilename: BLUR_EVENT.js
metapath: core/events
description:
The Game Blur Event.

This event is dispatched by the Game Visibility Handler when the window in which the Game instance is embedded
enters a blurred state. The blur event is raised when the window loses focus. This can happen if a user swaps
tab, or if they simply remove focus from the browser to another app.


longname: Phaser.Core.Events.BOOT
since: 3.0.0
name: BOOT
memberof: Phaser.Core.Events
metafilename: BOOT_EVENT.js
metapath: core/events
description:
The Game Boot Event.

This event is dispatched when the Phaser Game instance has finished booting, but before it is ready to start running.
The global systems use this event to know when to set themselves up, dispatching their own `ready` events as required.


longname: Phaser.Core.Events.CONTEXT_LOST
since: 3.19.0
name: CONTEXT_LOST
memberof: Phaser.Core.Events
metafilename: CONTEXT_LOST_EVENT.js
metapath: core/events
description:
The Game Context Lost Event.

This event is dispatched by the Game if the WebGL Renderer it is using encounters a WebGL Context Lost event from the browser.

The partner event is `CONTEXT_RESTORED`.


longname: Phaser.Core.Events.CONTEXT_RESTORED
since: 3.19.0
name: CONTEXT_RESTORED
memberof: Phaser.Core.Events
metafilename: CONTEXT_RESTORED_EVENT.js
metapath: core/events
description:
The Game Context Restored Event.

This event is dispatched by the Game if the WebGL Renderer it is using encounters a WebGL Context Restored event from the browser.

The partner event is `CONTEXT_LOST`.


longname: Phaser.Core.Events.DESTROY
since: 3.0.0
name: DESTROY
memberof: Phaser.Core.Events
metafilename: DESTROY_EVENT.js
metapath: core/events
description:
The Game Destroy Event.

This event is dispatched when the game instance has been told to destroy itself.
Lots of internal systems listen to this event in order to clear themselves out.
Custom plugins and game code should also do the same.


longname: Phaser.Core.Events.FOCUS
since: 3.0.0
name: FOCUS
memberof: Phaser.Core.Events
metafilename: FOCUS_EVENT.js
metapath: core/events
description:
The Game Focus Event.

This event is dispatched by the Game Visibility Handler when the window in which the Game instance is embedded
enters a focused state. The focus event is raised when the window re-gains focus, having previously lost it.


longname: Phaser.Core.Events.HIDDEN
since: 3.0.0
name: HIDDEN
memberof: Phaser.Core.Events
metafilename: HIDDEN_EVENT.js
metapath: core/events
description:
The Game Hidden Event.

This event is dispatched by the Game Visibility Handler when the document in which the Game instance is embedded
enters a hidden state. Only browsers that support the Visibility API will cause this event to be emitted.

In most modern browsers, when the document enters a hidden state, the Request Animation Frame and setTimeout, which
control the main game loop, will automatically pause. There is no way to stop this from happening. It is something
your game should account for in its own code, should the pause be an issue (i.e. for multiplayer games)


longname: Phaser.Core.Events.PAUSE
since: 3.0.0
name: PAUSE
memberof: Phaser.Core.Events
metafilename: PAUSE_EVENT.js
metapath: core/events
description:
The Game Pause Event.

This event is dispatched when the Game loop enters a paused state, usually as a result of the Visibility Handler.


longname: Phaser.Core.Events.POST_RENDER
since: 3.0.0
name: POST_RENDER
memberof: Phaser.Core.Events
metafilename: POST_RENDER_EVENT.js
metapath: core/events
description:
The Game Post-Render Event.

This event is dispatched right at the end of the render process.

Every Scene will have rendered and been drawn to the canvas by the time this event is fired.
Use it for any last minute post-processing before the next game step begins.


longname: Phaser.Core.Events.POST_STEP
since: 3.0.0
name: POST_STEP
memberof: Phaser.Core.Events
metafilename: POST_STEP_EVENT.js
metapath: core/events
description:
The Game Post-Step Event.

This event is dispatched after the Scene Manager has updated.
Hook into it from plugins or systems that need to do things before the render starts.


longname: Phaser.Core.Events.PRE_RENDER
since: 3.0.0
name: PRE_RENDER
memberof: Phaser.Core.Events
metafilename: PRE_RENDER_EVENT.js
metapath: core/events
description:
The Game Pre-Render Event.

This event is dispatched immediately before any of the Scenes have started to render.

The renderer will already have been initialized this frame, clearing itself and preparing to receive the Scenes for rendering, but it won't have actually drawn anything yet.


longname: Phaser.Core.Events.PRE_STEP
since: 3.0.0
name: PRE_STEP
memberof: Phaser.Core.Events
metafilename: PRE_STEP_EVENT.js
metapath: core/events
description:
The Game Pre-Step Event.

This event is dispatched before the main Game Step starts. By this point in the game cycle none of the Scene updates have yet happened.
Hook into it from plugins or systems that need to update before the Scene Manager does.


longname: Phaser.Core.Events.READY
since: 3.0.0
name: READY
memberof: Phaser.Core.Events
metafilename: READY_EVENT.js
metapath: core/events
description:
The Game Ready Event.

This event is dispatched when the Phaser Game instance has finished booting, the Texture Manager is fully ready,
and all local systems are now able to start.


longname: Phaser.Core.Events.RESUME
since: 3.0.0
name: RESUME
memberof: Phaser.Core.Events
metafilename: RESUME_EVENT.js
metapath: core/events
description:
The Game Resume Event.

This event is dispatched when the game loop leaves a paused state and resumes running.


longname: Phaser.Core.Events.STEP
since: 3.0.0
name: STEP
memberof: Phaser.Core.Events
metafilename: STEP_EVENT.js
metapath: core/events
description:
The Game Step Event.

This event is dispatched after the Game Pre-Step and before the Scene Manager steps.
Hook into it from plugins or systems that need to update before the Scene Manager does, but after the core Systems have.


longname: Phaser.Core.Events.VISIBLE
since: 3.0.0
name: VISIBLE
memberof: Phaser.Core.Events
metafilename: VISIBLE_EVENT.js
metapath: core/events
description:
The Game Visible Event.

This event is dispatched by the Game Visibility Handler when the document in which the Game instance is embedded
enters a visible state, previously having been hidden.

Only browsers that support the Visibility API will cause this event to be emitted.


longname: Phaser.Data.Events.CHANGE_DATA
since: 3.0.0
name: CHANGE_DATA
memberof: Phaser.Data.Events
metafilename: CHANGE_DATA_EVENT.js
metapath: data/events
description:
The Change Data Event.

This event is dispatched by a Data Manager when an item in the data store is changed.

Game Objects with data enabled have an instance of a Data Manager under the `data` property. So, to listen for
a change data event from a Game Object you would use: `sprite.data.on('changedata', listener)`.

This event is dispatched for all items that change in the Data Manager.
To listen for the change of a specific item, use the `CHANGE_DATA_KEY_EVENT` event.


longname: Phaser.Data.Events.CHANGE_DATA_KEY
since: 3.16.1
name: CHANGE_DATA_KEY
memberof: Phaser.Data.Events
metafilename: CHANGE_DATA_KEY_EVENT.js
metapath: data/events
description:
The Change Data Key Event.

This event is dispatched by a Data Manager when an item in the data store is changed.

Game Objects with data enabled have an instance of a Data Manager under the `data` property. So, to listen for
the change of a specific data item from a Game Object you would use: `sprite.data.on('changedata-key', listener)`,
where `key` is the unique string key of the data item. For example, if you have a data item stored called `gold`
then you can listen for `sprite.data.on('changedata-gold')`.


longname: Phaser.Data.Events.DESTROY
since: 3.50.0
name: DESTROY
memberof: Phaser.Data.Events
metafilename: DESTROY_EVENT.js
metapath: data/events
description:
The Data Manager Destroy Event.

The Data Manager will listen for the destroy event from its parent, and then close itself down.


longname: Phaser.Data.Events.REMOVE_DATA
since: 3.0.0
name: REMOVE_DATA
memberof: Phaser.Data.Events
metafilename: REMOVE_DATA_EVENT.js
metapath: data/events
description:
The Remove Data Event.

This event is dispatched by a Data Manager when an item is removed from it.

Game Objects with data enabled have an instance of a Data Manager under the `data` property. So, to listen for
the removal of a data item on a Game Object you would use: `sprite.data.on('removedata', listener)`.


longname: Phaser.Data.Events.SET_DATA
since: 3.0.0
name: SET_DATA
memberof: Phaser.Data.Events
metafilename: SET_DATA_EVENT.js
metapath: data/events
description:
The Set Data Event.

This event is dispatched by a Data Manager when a new item is added to the data store.

Game Objects with data enabled have an instance of a Data Manager under the `data` property. So, to listen for
the addition of a new data item on a Game Object you would use: `sprite.data.on('setdata', listener)`.


longname: Phaser.GameObjects.Events.ADDED_TO_SCENE
since: 3.50.0
name: ADDED_TO_SCENE
memberof: Phaser.GameObjects.Events
metafilename: ADDED_TO_SCENE_EVENT.js
metapath: gameobjects/events
description:
The Game Object Added to Scene Event.

This event is dispatched when a Game Object is added to a Scene.

Listen for it on a Game Object instance using `GameObject.on('addedtoscene', listener)`.


longname: Phaser.GameObjects.Events.DESTROY
since: 3.0.0
name: DESTROY
memberof: Phaser.GameObjects.Events
metafilename: DESTROY_EVENT.js
metapath: gameobjects/events
description:
The Game Object Destroy Event.

This event is dispatched when a Game Object instance is being destroyed.

Listen for it on a Game Object instance using `GameObject.on('destroy', listener)`.


longname: Phaser.GameObjects.Events.REMOVED_FROM_SCENE
since: 3.50.0
name: REMOVED_FROM_SCENE
memberof: Phaser.GameObjects.Events
metafilename: REMOVED_FROM_SCENE_EVENT.js
metapath: gameobjects/events
description:
The Game Object Removed from Scene Event.

This event is dispatched when a Game Object is removed from a Scene.

Listen for it on a Game Object instance using `GameObject.on('removedfromscene', listener)`.


longname: Phaser.GameObjects.Events.VIDEO_COMPLETE
since: 3.20.0
name: VIDEO_COMPLETE
memberof: Phaser.GameObjects.Events
metafilename: VIDEO_COMPLETE_EVENT.js
metapath: gameobjects/events
description:
The Video Game Object Complete Event.

This event is dispatched when a Video finishes playback by reaching the end of its duration. It
is also dispatched if a video marker sequence is being played and reaches the end.

Note that not all videos can fire this event. Live streams, for example, have no fixed duration,
so never technically 'complete'.

If a video is stopped from playback, via the `Video.stop` method, it will emit the
`VIDEO_STOP` event instead of this one.

Listen for it from a Video Game Object instance using `Video.on('complete', listener)`.


longname: Phaser.GameObjects.Events.VIDEO_CREATED
since: 3.20.0
name: VIDEO_CREATED
memberof: Phaser.GameObjects.Events
metafilename: VIDEO_CREATED_EVENT.js
metapath: gameobjects/events
description:
The Video Game Object Created Event.

This event is dispatched when the texture for a Video has been created. This happens
when enough of the video source has been loaded that the browser is able to render a
frame from it.

Listen for it from a Video Game Object instance using `Video.on('created', listener)`.


longname: Phaser.GameObjects.Events.VIDEO_ERROR
since: 3.20.0
name: VIDEO_ERROR
memberof: Phaser.GameObjects.Events
metafilename: VIDEO_ERROR_EVENT.js
metapath: gameobjects/events
description:
The Video Game Object Error Event.

This event is dispatched when a Video tries to play a source that does not exist, or is the wrong file type.

Listen for it from a Video Game Object instance using `Video.on('error', listener)`.


longname: Phaser.GameObjects.Events.VIDEO_LOOP
since: 3.20.0
name: VIDEO_LOOP
memberof: Phaser.GameObjects.Events
metafilename: VIDEO_LOOP_EVENT.js
metapath: gameobjects/events
description:
The Video Game Object Loop Event.

This event is dispatched when a Video that is currently playing has looped. This only
happens if the `loop` parameter was specified, or the `setLoop` method was called,
and if the video has a fixed duration. Video streams, for example, cannot loop, as
they have no duration.

Looping is based on the result of the Video `timeupdate` event. This event is not
frame-accurate, due to the way browsers work, so please do not rely on this loop
event to be time or frame precise.

Listen for it from a Video Game Object instance using `Video.on('loop', listener)`.


longname: Phaser.GameObjects.Events.VIDEO_PLAY
since: 3.20.0
name: VIDEO_PLAY
memberof: Phaser.GameObjects.Events
metafilename: VIDEO_PLAY_EVENT.js
metapath: gameobjects/events
description:
The Video Game Object Play Event.

This event is dispatched when a Video begins playback. For videos that do not require
interaction unlocking, this is usually as soon as the `Video.play` method is called.
However, for videos that require unlocking, it is fired once playback begins after
they've been unlocked.

Listen for it from a Video Game Object instance using `Video.on('play', listener)`.


longname: Phaser.GameObjects.Events.VIDEO_SEEKED
since: 3.20.0
name: VIDEO_SEEKED
memberof: Phaser.GameObjects.Events
metafilename: VIDEO_SEEKED_EVENT.js
metapath: gameobjects/events
description:
The Video Game Object Seeked Event.

This event is dispatched when a Video completes seeking to a new point in its timeline.

Listen for it from a Video Game Object instance using `Video.on('seeked', listener)`.


longname: Phaser.GameObjects.Events.VIDEO_SEEKING
since: 3.20.0
name: VIDEO_SEEKING
memberof: Phaser.GameObjects.Events
metafilename: VIDEO_SEEKING_EVENT.js
metapath: gameobjects/events
description:
The Video Game Object Seeking Event.

This event is dispatched when a Video _begins_ seeking to a new point in its timeline.
When the seek is complete, it will dispatch the `VIDEO_SEEKED` event to conclude.

Listen for it from a Video Game Object instance using `Video.on('seeking', listener)`.


longname: Phaser.GameObjects.Events.VIDEO_STOP
since: 3.20.0
name: VIDEO_STOP
memberof: Phaser.GameObjects.Events
metafilename: VIDEO_STOP_EVENT.js
metapath: gameobjects/events
description:
The Video Game Object Stopped Event.

This event is dispatched when a Video is stopped from playback via a call to the `Video.stop` method,
either directly via game code, or indirectly as the result of changing a video source or destroying it.

Listen for it from a Video Game Object instance using `Video.on('stop', listener)`.


longname: Phaser.GameObjects.Events.VIDEO_TIMEOUT
since: 3.20.0
name: VIDEO_TIMEOUT
memberof: Phaser.GameObjects.Events
metafilename: VIDEO_TIMEOUT_EVENT.js
metapath: gameobjects/events
description:
The Video Game Object Timeout Event.

This event is dispatched when a Video has exhausted its allocated time while trying to connect to a video
source to start playback.

Listen for it from a Video Game Object instance using `Video.on('timeout', listener)`.


longname: Phaser.GameObjects.Events.VIDEO_UNLOCKED
since: 3.20.0
name: VIDEO_UNLOCKED
memberof: Phaser.GameObjects.Events
metafilename: VIDEO_UNLOCKED_EVENT.js
metapath: gameobjects/events
description:
The Video Game Object Unlocked Event.

This event is dispatched when a Video that was prevented from playback due to the browsers
Media Engagement Interaction policy, is unlocked by a user gesture.

Listen for it from a Video Game Object instance using `Video.on('unlocked', listener)`.


longname: Phaser.Input.Events.BOOT
since: 3.0.0
name: BOOT
memberof: Phaser.Input.Events
metafilename: BOOT_EVENT.js
metapath: input/events
description:
The Input Plugin Boot Event.

This internal event is dispatched by the Input Plugin when it boots, signalling to all of its systems to create themselves.


longname: Phaser.Input.Events.DESTROY
since: 3.0.0
name: DESTROY
memberof: Phaser.Input.Events
metafilename: DESTROY_EVENT.js
metapath: input/events
description:
The Input Plugin Destroy Event.

This internal event is dispatched by the Input Plugin when it is destroyed, signalling to all of its systems to destroy themselves.


longname: Phaser.Input.Events.DRAG_END
since: 3.0.0
name: DRAG_END
memberof: Phaser.Input.Events
metafilename: DRAG_END_EVENT.js
metapath: input/events
description:
The Pointer Drag End Input Event.

This event is dispatched by the Input Plugin belonging to a Scene if a pointer stops dragging a Game Object.

Listen to this event from within a Scene using: `this.input.on('dragend', listener)`.

To listen for this event from a _specific_ Game Object, use the [``GAMEOBJECT_DRAG_END``](Phaser.Input.Events#event:GAMEOBJECT_DRAG_END) event instead.


longname: Phaser.Input.Events.DRAG_ENTER
since: 3.0.0
name: DRAG_ENTER
memberof: Phaser.Input.Events
metafilename: DRAG_ENTER_EVENT.js
metapath: input/events
description:
The Pointer Drag Enter Input Event.

This event is dispatched by the Input Plugin belonging to a Scene if a pointer drags a Game Object into a Drag Target.

Listen to this event from within a Scene using: `this.input.on('dragenter', listener)`.

A Pointer can only drag a single Game Object at once.

To listen for this event from a _specific_ Game Object, use the [``GAMEOBJECT_DRAG_ENTER``](Phaser.Input.Events#event:GAMEOBJECT_DRAG_ENTER) event instead.


longname: Phaser.Input.Events.DRAG
since: 3.0.0
name: DRAG
memberof: Phaser.Input.Events
metafilename: DRAG_EVENT.js
metapath: input/events
description:
The Pointer Drag Input Event.

This event is dispatched by the Input Plugin belonging to a Scene if a pointer moves while dragging a Game Object.

Listen to this event from within a Scene using: `this.input.on('drag', listener)`.

A Pointer can only drag a single Game Object at once.

To listen for this event from a _specific_ Game Object, use the [``GAMEOBJECT_DRAG``](Phaser.Input.Events#event:GAMEOBJECT_DRAG) event instead.


longname: Phaser.Input.Events.DRAG_LEAVE
since: 3.0.0
name: DRAG_LEAVE
memberof: Phaser.Input.Events
metafilename: DRAG_LEAVE_EVENT.js
metapath: input/events
description:
The Pointer Drag Leave Input Event.

This event is dispatched by the Input Plugin belonging to a Scene if a pointer drags a Game Object out of a Drag Target.

Listen to this event from within a Scene using: `this.input.on('dragleave', listener)`.

A Pointer can only drag a single Game Object at once.

To listen for this event from a _specific_ Game Object, use the [``GAMEOBJECT_DRAG_LEAVE``](Phaser.Input.Events#event:GAMEOBJECT_DRAG_LEAVE) event instead.


longname: Phaser.Input.Events.DRAG_OVER
since: 3.0.0
name: DRAG_OVER
memberof: Phaser.Input.Events
metafilename: DRAG_OVER_EVENT.js
metapath: input/events
description:
The Pointer Drag Over Input Event.

This event is dispatched by the Input Plugin belonging to a Scene if a pointer drags a Game Object over a Drag Target.

When the Game Object first enters the drag target it will emit a `dragenter` event. If it then moves while within
the drag target, it will emit this event instead.

Listen to this event from within a Scene using: `this.input.on('dragover', listener)`.

A Pointer can only drag a single Game Object at once.

To listen for this event from a _specific_ Game Object, use the [``GAMEOBJECT_DRAG_OVER``](Phaser.Input.Events#event:GAMEOBJECT_DRAG_OVER) event instead.


longname: Phaser.Input.Events.DRAG_START
since: 3.0.0
name: DRAG_START
memberof: Phaser.Input.Events
metafilename: DRAG_START_EVENT.js
metapath: input/events
description:
The Pointer Drag Start Input Event.

This event is dispatched by the Input Plugin belonging to a Scene if a pointer starts to drag any Game Object.

Listen to this event from within a Scene using: `this.input.on('dragstart', listener)`.

A Pointer can only drag a single Game Object at once.

To listen for this event from a _specific_ Game Object, use the [``GAMEOBJECT_DRAG_START``](Phaser.Input.Events#event:GAMEOBJECT_DRAG_START) event instead.


longname: Phaser.Input.Events.DROP
since: 3.0.0
name: DROP
memberof: Phaser.Input.Events
metafilename: DROP_EVENT.js
metapath: input/events
description:
The Pointer Drop Input Event.

This event is dispatched by the Input Plugin belonging to a Scene if a pointer drops a Game Object on a Drag Target.

Listen to this event from within a Scene using: `this.input.on('drop', listener)`.

To listen for this event from a _specific_ Game Object, use the [``GAMEOBJECT_DROP``](Phaser.Input.Events#event:GAMEOBJECT_DROP) event instead.


longname: Phaser.Input.Events.GAMEOBJECT_DOWN
since: 3.0.0
name: GAMEOBJECT_DOWN
memberof: Phaser.Input.Events
metafilename: GAMEOBJECT_DOWN_EVENT.js
metapath: input/events
description:
The Game Object Down Input Event.

This event is dispatched by the Input Plugin belonging to a Scene if a pointer is pressed down on _any_ interactive Game Object.

Listen to this event from within a Scene using: `this.input.on('gameobjectdown', listener)`.

To receive this event, the Game Objects must have been set as interactive.
See [GameObject.setInteractive](Phaser.GameObjects.GameObject#setInteractive) for more details.

To listen for this event from a _specific_ Game Object, use the [``GAMEOBJECT_POINTER_DOWN``](Phaser.Input.Events#event:GAMEOBJECT_POINTER_DOWN) event instead.

The event hierarchy is as follows:

1. [``GAMEOBJECT_POINTER_DOWN``](Phaser.Input.Events#event:GAMEOBJECT_POINTER_DOWN)
2. [``GAMEOBJECT_DOWN``](Phaser.Input.Events#event:GAMEOBJECT_DOWN)
3. [``POINTER_DOWN``](Phaser.Input.Events#event:POINTER_DOWN) or [``POINTER_DOWN_OUTSIDE``](Phaser.Input.Events#event:POINTER_DOWN_OUTSIDE)

With the top event being dispatched first and then flowing down the list. Note that higher-up event handlers can stop
the propagation of this event.


longname: Phaser.Input.Events.GAMEOBJECT_DRAG_END
since: 3.0.0
name: GAMEOBJECT_DRAG_END
memberof: Phaser.Input.Events
metafilename: GAMEOBJECT_DRAG_END_EVENT.js
metapath: input/events
description:
The Game Object Drag End Event.

This event is dispatched by an interactive Game Object if a pointer stops dragging it.

Listen to this event from a Game Object using: `gameObject.on('dragend', listener)`.
Note that the scope of the listener is automatically set to be the Game Object instance itself.

To receive this event, the Game Object must have been set as interactive and enabled for drag.
See [GameObject.setInteractive](Phaser.GameObjects.GameObject#setInteractive) for more details.


longname: Phaser.Input.Events.GAMEOBJECT_DRAG_ENTER
since: 3.0.0
name: GAMEOBJECT_DRAG_ENTER
memberof: Phaser.Input.Events
metafilename: GAMEOBJECT_DRAG_ENTER_EVENT.js
metapath: input/events
description:
The Game Object Drag Enter Event.

This event is dispatched by an interactive Game Object if a pointer drags it into a drag target.

Listen to this event from a Game Object using: `gameObject.on('dragenter', listener)`.
Note that the scope of the listener is automatically set to be the Game Object instance itself.

To receive this event, the Game Object must have been set as interactive and enabled for drag.
See [GameObject.setInteractive](Phaser.GameObjects.GameObject#setInteractive) for more details.


longname: Phaser.Input.Events.GAMEOBJECT_DRAG
since: 3.0.0
name: GAMEOBJECT_DRAG
memberof: Phaser.Input.Events
metafilename: GAMEOBJECT_DRAG_EVENT.js
metapath: input/events
description:
The Game Object Drag Event.

This event is dispatched by an interactive Game Object if a pointer moves while dragging it.

Listen to this event from a Game Object using: `gameObject.on('drag', listener)`.
Note that the scope of the listener is automatically set to be the Game Object instance itself.

To receive this event, the Game Object must have been set as interactive and enabled for drag.
See [GameObject.setInteractive](Phaser.GameObjects.GameObject#setInteractive) for more details.


longname: Phaser.Input.Events.GAMEOBJECT_DRAG_LEAVE
since: 3.0.0
name: GAMEOBJECT_DRAG_LEAVE
memberof: Phaser.Input.Events
metafilename: GAMEOBJECT_DRAG_LEAVE_EVENT.js
metapath: input/events
description:
The Game Object Drag Leave Event.

This event is dispatched by an interactive Game Object if a pointer drags it out of a drag target.

Listen to this event from a Game Object using: `gameObject.on('dragleave', listener)`.
Note that the scope of the listener is automatically set to be the Game Object instance itself.

To receive this event, the Game Object must have been set as interactive and enabled for drag.
See [GameObject.setInteractive](Phaser.GameObjects.GameObject#setInteractive) for more details.


longname: Phaser.Input.Events.GAMEOBJECT_DRAG_OVER
since: 3.0.0
name: GAMEOBJECT_DRAG_OVER
memberof: Phaser.Input.Events
metafilename: GAMEOBJECT_DRAG_OVER_EVENT.js
metapath: input/events
description:
The Game Object Drag Over Event.

This event is dispatched by an interactive Game Object if a pointer drags it over a drag target.

When the Game Object first enters the drag target it will emit a `dragenter` event. If it then moves while within
the drag target, it will emit this event instead.

Listen to this event from a Game Object using: `gameObject.on('dragover', listener)`.
Note that the scope of the listener is automatically set to be the Game Object instance itself.

To receive this event, the Game Object must have been set as interactive and enabled for drag.
See [GameObject.setInteractive](Phaser.GameObjects.GameObject#setInteractive) for more details.


longname: Phaser.Input.Events.GAMEOBJECT_DRAG_START
since: 3.0.0
name: GAMEOBJECT_DRAG_START
memberof: Phaser.Input.Events
metafilename: GAMEOBJECT_DRAG_START_EVENT.js
metapath: input/events
description:
The Game Object Drag Start Event.

This event is dispatched by an interactive Game Object if a pointer starts to drag it.

Listen to this event from a Game Object using: `gameObject.on('dragstart', listener)`.
Note that the scope of the listener is automatically set to be the Game Object instance itself.

To receive this event, the Game Object must have been set as interactive and enabled for drag.
See [GameObject.setInteractive](Phaser.GameObjects.GameObject#setInteractive) for more details.

There are lots of useful drag related properties that are set within the Game Object when dragging occurs.
For example, `gameObject.input.dragStartX`, `dragStartY` and so on.


longname: Phaser.Input.Events.GAMEOBJECT_DROP
since: 3.0.0
name: GAMEOBJECT_DROP
memberof: Phaser.Input.Events
metafilename: GAMEOBJECT_DROP_EVENT.js
metapath: input/events
description:
The Game Object Drop Event.

This event is dispatched by an interactive Game Object if a pointer drops it on a Drag Target.

Listen to this event from a Game Object using: `gameObject.on('drop', listener)`.
Note that the scope of the listener is automatically set to be the Game Object instance itself.

To receive this event, the Game Object must have been set as interactive and enabled for drag.
See [GameObject.setInteractive](Phaser.GameObjects.GameObject#setInteractive) for more details.


longname: Phaser.Input.Events.GAMEOBJECT_MOVE
since: 3.0.0
name: GAMEOBJECT_MOVE
memberof: Phaser.Input.Events
metafilename: GAMEOBJECT_MOVE_EVENT.js
metapath: input/events
description:
The Game Object Move Input Event.

This event is dispatched by the Input Plugin belonging to a Scene if a pointer is moved across _any_ interactive Game Object.

Listen to this event from within a Scene using: `this.input.on('gameobjectmove', listener)`.

To receive this event, the Game Objects must have been set as interactive.
See [GameObject.setInteractive](Phaser.GameObjects.GameObject#setInteractive) for more details.

To listen for this event from a _specific_ Game Object, use the [``GAMEOBJECT_POINTER_MOVE``](Phaser.Input.Events#event:GAMEOBJECT_POINTER_MOVE) event instead.

The event hierarchy is as follows:

1. [``GAMEOBJECT_POINTER_MOVE``](Phaser.Input.Events#event:GAMEOBJECT_POINTER_MOVE)
2. [``GAMEOBJECT_MOVE``](Phaser.Input.Events#event:GAMEOBJECT_MOVE)
3. [``POINTER_MOVE``](Phaser.Input.Events#event:POINTER_MOVE)

With the top event being dispatched first and then flowing down the list. Note that higher-up event handlers can stop
the propagation of this event.


longname: Phaser.Input.Events.GAMEOBJECT_OUT
since: 3.0.0
name: GAMEOBJECT_OUT
memberof: Phaser.Input.Events
metafilename: GAMEOBJECT_OUT_EVENT.js
metapath: input/events
description:
The Game Object Out Input Event.

This event is dispatched by the Input Plugin belonging to a Scene if a pointer moves out of _any_ interactive Game Object.

Listen to this event from within a Scene using: `this.input.on('gameobjectout', listener)`.

To receive this event, the Game Objects must have been set as interactive.
See [GameObject.setInteractive](Phaser.GameObjects.GameObject#setInteractive) for more details.

To listen for this event from a _specific_ Game Object, use the [``GAMEOBJECT_POINTER_OUT``](Phaser.Input.Events#event:GAMEOBJECT_POINTER_OUT) event instead.

The event hierarchy is as follows:

1. [``GAMEOBJECT_POINTER_OUT``](Phaser.Input.Events#event:GAMEOBJECT_POINTER_OUT)
2. [``GAMEOBJECT_OUT``](Phaser.Input.Events#event:GAMEOBJECT_OUT)
3. [``POINTER_OUT``](Phaser.Input.Events#event:POINTER_OUT)

With the top event being dispatched first and then flowing down the list. Note that higher-up event handlers can stop
the propagation of this event.


longname: Phaser.Input.Events.GAMEOBJECT_OVER
since: 3.0.0
name: GAMEOBJECT_OVER
memberof: Phaser.Input.Events
metafilename: GAMEOBJECT_OVER_EVENT.js
metapath: input/events
description:
The Game Object Over Input Event.

This event is dispatched by the Input Plugin belonging to a Scene if a pointer moves over _any_ interactive Game Object.

Listen to this event from within a Scene using: `this.input.on('gameobjectover', listener)`.

To receive this event, the Game Objects must have been set as interactive.
See [GameObject.setInteractive](Phaser.GameObjects.GameObject#setInteractive) for more details.

To listen for this event from a _specific_ Game Object, use the [``GAMEOBJECT_POINTER_OVER``](Phaser.Input.Events#event:GAMEOBJECT_POINTER_OVER) event instead.

The event hierarchy is as follows:

1. [``GAMEOBJECT_POINTER_OVER``](Phaser.Input.Events#event:GAMEOBJECT_POINTER_OVER)
2. [``GAMEOBJECT_OVER``](Phaser.Input.Events#event:GAMEOBJECT_OVER)
3. [``POINTER_OVER``](Phaser.Input.Events#event:POINTER_OVER)

With the top event being dispatched first and then flowing down the list. Note that higher-up event handlers can stop
the propagation of this event.


longname: Phaser.Input.Events.GAMEOBJECT_POINTER_DOWN
since: 3.0.0
name: GAMEOBJECT_POINTER_DOWN
memberof: Phaser.Input.Events
metafilename: GAMEOBJECT_POINTER_DOWN_EVENT.js
metapath: input/events
description:
The Game Object Pointer Down Event.

This event is dispatched by an interactive Game Object if a pointer is pressed down on it.

Listen to this event from a Game Object using: `gameObject.on('pointerdown', listener)`.
Note that the scope of the listener is automatically set to be the Game Object instance itself.

To receive this event, the Game Object must have been set as interactive.
See [GameObject.setInteractive](Phaser.GameObjects.GameObject#setInteractive) for more details.

The event hierarchy is as follows:

1. [``GAMEOBJECT_POINTER_DOWN``](Phaser.Input.Events#event:GAMEOBJECT_POINTER_DOWN)
2. [``GAMEOBJECT_DOWN``](Phaser.Input.Events#event:GAMEOBJECT_DOWN)
3. [``POINTER_DOWN``](Phaser.Input.Events#event:POINTER_DOWN) or [``POINTER_DOWN_OUTSIDE``](Phaser.Input.Events#event:POINTER_DOWN_OUTSIDE)

With the top event being dispatched first and then flowing down the list. Note that higher-up event handlers can stop
the propagation of this event.


longname: Phaser.Input.Events.GAMEOBJECT_POINTER_MOVE
since: 3.0.0
name: GAMEOBJECT_POINTER_MOVE
memberof: Phaser.Input.Events
metafilename: GAMEOBJECT_POINTER_MOVE_EVENT.js
metapath: input/events
description:
The Game Object Pointer Move Event.

This event is dispatched by an interactive Game Object if a pointer is moved while over it.

Listen to this event from a Game Object using: `gameObject.on('pointermove', listener)`.
Note that the scope of the listener is automatically set to be the Game Object instance itself.

To receive this event, the Game Object must have been set as interactive.
See [GameObject.setInteractive](Phaser.GameObjects.GameObject#setInteractive) for more details.

The event hierarchy is as follows:

1. [``GAMEOBJECT_POINTER_MOVE``](Phaser.Input.Events#event:GAMEOBJECT_POINTER_MOVE)
2. [``GAMEOBJECT_MOVE``](Phaser.Input.Events#event:GAMEOBJECT_MOVE)
3. [``POINTER_MOVE``](Phaser.Input.Events#event:POINTER_MOVE)

With the top event being dispatched first and then flowing down the list. Note that higher-up event handlers can stop
the propagation of this event.


longname: Phaser.Input.Events.GAMEOBJECT_POINTER_OUT
since: 3.0.0
name: GAMEOBJECT_POINTER_OUT
memberof: Phaser.Input.Events
metafilename: GAMEOBJECT_POINTER_OUT_EVENT.js
metapath: input/events
description:
The Game Object Pointer Out Event.

This event is dispatched by an interactive Game Object if a pointer moves out of it.

Listen to this event from a Game Object using: `gameObject.on('pointerout', listener)`.
Note that the scope of the listener is automatically set to be the Game Object instance itself.

To receive this event, the Game Object must have been set as interactive.
See [GameObject.setInteractive](Phaser.GameObjects.GameObject#setInteractive) for more details.

The event hierarchy is as follows:

1. [``GAMEOBJECT_POINTER_OUT``](Phaser.Input.Events#event:GAMEOBJECT_POINTER_OUT)
2. [``GAMEOBJECT_OUT``](Phaser.Input.Events#event:GAMEOBJECT_OUT)
3. [``POINTER_OUT``](Phaser.Input.Events#event:POINTER_OUT)

With the top event being dispatched first and then flowing down the list. Note that higher-up event handlers can stop
the propagation of this event.


longname: Phaser.Input.Events.GAMEOBJECT_POINTER_OVER
since: 3.0.0
name: GAMEOBJECT_POINTER_OVER
memberof: Phaser.Input.Events
metafilename: GAMEOBJECT_POINTER_OVER_EVENT.js
metapath: input/events
description:
The Game Object Pointer Over Event.

This event is dispatched by an interactive Game Object if a pointer moves over it.

Listen to this event from a Game Object using: `gameObject.on('pointerover', listener)`.
Note that the scope of the listener is automatically set to be the Game Object instance itself.

To receive this event, the Game Object must have been set as interactive.
See [GameObject.setInteractive](Phaser.GameObjects.GameObject#setInteractive) for more details.

The event hierarchy is as follows:

1. [``GAMEOBJECT_POINTER_OVER``](Phaser.Input.Events#event:GAMEOBJECT_POINTER_OVER)
2. [``GAMEOBJECT_OVER``](Phaser.Input.Events#event:GAMEOBJECT_OVER)
3. [``POINTER_OVER``](Phaser.Input.Events#event:POINTER_OVER)

With the top event being dispatched first and then flowing down the list. Note that higher-up event handlers can stop
the propagation of this event.


longname: Phaser.Input.Events.GAMEOBJECT_POINTER_UP
since: 3.0.0
name: GAMEOBJECT_POINTER_UP
memberof: Phaser.Input.Events
metafilename: GAMEOBJECT_POINTER_UP_EVENT.js
metapath: input/events
description:
The Game Object Pointer Up Event.

This event is dispatched by an interactive Game Object if a pointer is released while over it.

Listen to this event from a Game Object using: `gameObject.on('pointerup', listener)`.
Note that the scope of the listener is automatically set to be the Game Object instance itself.

To receive this event, the Game Object must have been set as interactive.
See [GameObject.setInteractive](Phaser.GameObjects.GameObject#setInteractive) for more details.

The event hierarchy is as follows:

1. [``GAMEOBJECT_POINTER_UP``](Phaser.Input.Events#event:GAMEOBJECT_POINTER_UP)
2. [``GAMEOBJECT_UP``](Phaser.Input.Events#event:GAMEOBJECT_UP)
3. [``POINTER_UP``](Phaser.Input.Events#event:POINTER_UP) or [``POINTER_UP_OUTSIDE``](Phaser.Input.Events#event:POINTER_UP_OUTSIDE)

With the top event being dispatched first and then flowing down the list. Note that higher-up event handlers can stop
the propagation of this event.


longname: Phaser.Input.Events.GAMEOBJECT_POINTER_WHEEL
since: 3.18.0
name: GAMEOBJECT_POINTER_WHEEL
memberof: Phaser.Input.Events
metafilename: GAMEOBJECT_POINTER_WHEEL_EVENT.js
metapath: input/events
description:
The Game Object Pointer Wheel Event.

This event is dispatched by an interactive Game Object if a pointer has its wheel moved while over it.

Listen to this event from a Game Object using: `gameObject.on('wheel', listener)`.
Note that the scope of the listener is automatically set to be the Game Object instance itself.

To receive this event, the Game Object must have been set as interactive.
See [GameObject.setInteractive](Phaser.GameObjects.GameObject#setInteractive) for more details.

The event hierarchy is as follows:

1. [``GAMEOBJECT_POINTER_WHEEL``](Phaser.Input.Events#event:GAMEOBJECT_POINTER_WHEEL)
2. [``GAMEOBJECT_WHEEL``](Phaser.Input.Events#event:GAMEOBJECT_WHEEL)
3. [``POINTER_WHEEL``](Phaser.Input.Events#event:POINTER_WHEEL)

With the top event being dispatched first and then flowing down the list. Note that higher-up event handlers can stop
the propagation of this event.


longname: Phaser.Input.Events.GAMEOBJECT_UP
since: 3.0.0
name: GAMEOBJECT_UP
memberof: Phaser.Input.Events
metafilename: GAMEOBJECT_UP_EVENT.js
metapath: input/events
description:
The Game Object Up Input Event.

This event is dispatched by the Input Plugin belonging to a Scene if a pointer is released while over _any_ interactive Game Object.

Listen to this event from within a Scene using: `this.input.on('gameobjectup', listener)`.

To receive this event, the Game Objects must have been set as interactive.
See [GameObject.setInteractive](Phaser.GameObjects.GameObject#setInteractive) for more details.

To listen for this event from a _specific_ Game Object, use the [``GAMEOBJECT_POINTER_UP``](Phaser.Input.Events#event:GAMEOBJECT_POINTER_UP) event instead.

The event hierarchy is as follows:

1. [``GAMEOBJECT_POINTER_UP``](Phaser.Input.Events#event:GAMEOBJECT_POINTER_UP)
2. [``GAMEOBJECT_UP``](Phaser.Input.Events#event:GAMEOBJECT_UP)
3. [``POINTER_UP``](Phaser.Input.Events#event:POINTER_UP) or [``POINTER_UP_OUTSIDE``](Phaser.Input.Events#event:POINTER_UP_OUTSIDE)

With the top event being dispatched first and then flowing down the list. Note that higher-up event handlers can stop
the propagation of this event.


longname: Phaser.Input.Events.GAMEOBJECT_WHEEL
since: 3.18.0
name: GAMEOBJECT_WHEEL
memberof: Phaser.Input.Events
metafilename: GAMEOBJECT_WHEEL_EVENT.js
metapath: input/events
description:
The Game Object Wheel Input Event.

This event is dispatched by the Input Plugin belonging to a Scene if a pointer has its wheel moved while over _any_ interactive Game Object.

Listen to this event from within a Scene using: `this.input.on('gameobjectwheel', listener)`.

To receive this event, the Game Objects must have been set as interactive.
See [GameObject.setInteractive](Phaser.GameObjects.GameObject#setInteractive) for more details.

To listen for this event from a _specific_ Game Object, use the [``GAMEOBJECT_POINTER_WHEEL``](Phaser.Input.Events#event:GAMEOBJECT_POINTER_WHEEL) event instead.

The event hierarchy is as follows:

1. [``GAMEOBJECT_POINTER_WHEEL``](Phaser.Input.Events#event:GAMEOBJECT_POINTER_WHEEL)
2. [``GAMEOBJECT_WHEEL``](Phaser.Input.Events#event:GAMEOBJECT_WHEEL)
3. [``POINTER_WHEEL``](Phaser.Input.Events#event:POINTER_WHEEL)

With the top event being dispatched first and then flowing down the list. Note that higher-up event handlers can stop
the propagation of this event.


longname: Phaser.Input.Events.GAME_OUT
since: 3.16.1
name: GAME_OUT
memberof: Phaser.Input.Events
metafilename: GAME_OUT_EVENT.js
metapath: input/events
description:
The Input Plugin Game Out Event.

This event is dispatched by the Input Plugin if the active pointer leaves the game canvas and is now
outside of it, elsewhere on the web page.

Listen to this event from within a Scene using: `this.input.on('gameout', listener)`.


longname: Phaser.Input.Events.GAME_OVER
since: 3.16.1
name: GAME_OVER
memberof: Phaser.Input.Events
metafilename: GAME_OVER_EVENT.js
metapath: input/events
description:
The Input Plugin Game Over Event.

This event is dispatched by the Input Plugin if the active pointer enters the game canvas and is now
over of it, having previously been elsewhere on the web page.

Listen to this event from within a Scene using: `this.input.on('gameover', listener)`.


longname: Phaser.Input.Events.MANAGER_BOOT
since: 3.0.0
name: MANAGER_BOOT
memberof: Phaser.Input.Events
metafilename: MANAGER_BOOT_EVENT.js
metapath: input/events
description:
The Input Manager Boot Event.

This internal event is dispatched by the Input Manager when it boots.


longname: Phaser.Input.Events.MANAGER_PROCESS
since: 3.0.0
name: MANAGER_PROCESS
memberof: Phaser.Input.Events
metafilename: MANAGER_PROCESS_EVENT.js
metapath: input/events
description:
The Input Manager Process Event.

This internal event is dispatched by the Input Manager when not using the legacy queue system,
and it wants the Input Plugins to update themselves.


longname: Phaser.Input.Events.MANAGER_UPDATE
since: 3.0.0
name: MANAGER_UPDATE
memberof: Phaser.Input.Events
metafilename: MANAGER_UPDATE_EVENT.js
metapath: input/events
description:
The Input Manager Update Event.

This internal event is dispatched by the Input Manager as part of its update step.


longname: Phaser.Input.Events.POINTERLOCK_CHANGE
since: 3.0.0
name: POINTERLOCK_CHANGE
memberof: Phaser.Input.Events
metafilename: POINTERLOCK_CHANGE_EVENT.js
metapath: input/events
description:
The Input Manager Pointer Lock Change Event.

This event is dispatched by the Input Manager when it is processing a native Pointer Lock Change DOM Event.


longname: Phaser.Input.Events.POINTER_DOWN
since: 3.0.0
name: POINTER_DOWN
memberof: Phaser.Input.Events
metafilename: POINTER_DOWN_EVENT.js
metapath: input/events
description:
The Pointer Down Input Event.

This event is dispatched by the Input Plugin belonging to a Scene if a pointer is pressed down anywhere.

Listen to this event from within a Scene using: `this.input.on('pointerdown', listener)`.

The event hierarchy is as follows:

1. [``GAMEOBJECT_POINTER_DOWN``](Phaser.Input.Events#event:GAMEOBJECT_POINTER_DOWN)
2. [``GAMEOBJECT_DOWN``](Phaser.Input.Events#event:GAMEOBJECT_DOWN)
3. [``POINTER_DOWN``](Phaser.Input.Events#event:POINTER_DOWN) or [``POINTER_DOWN_OUTSIDE``](Phaser.Input.Events#event:POINTER_DOWN_OUTSIDE)

With the top event being dispatched first and then flowing down the list. Note that higher-up event handlers can stop
the propagation of this event.


longname: Phaser.Input.Events.POINTER_DOWN_OUTSIDE
since: 3.16.1
name: POINTER_DOWN_OUTSIDE
memberof: Phaser.Input.Events
metafilename: POINTER_DOWN_OUTSIDE_EVENT.js
metapath: input/events
description:
The Pointer Down Outside Input Event.

This event is dispatched by the Input Plugin belonging to a Scene if a pointer is pressed down anywhere outside of the game canvas.

Listen to this event from within a Scene using: `this.input.on('pointerdownoutside', listener)`.

The event hierarchy is as follows:

1. [``GAMEOBJECT_POINTER_DOWN``](Phaser.Input.Events#event:GAMEOBJECT_POINTER_DOWN)
2. [``GAMEOBJECT_DOWN``](Phaser.Input.Events#event:GAMEOBJECT_DOWN)
3. [``POINTER_DOWN``](Phaser.Input.Events#event:POINTER_DOWN) or [``POINTER_DOWN_OUTSIDE``](Phaser.Input.Events#event:POINTER_DOWN_OUTSIDE)

With the top event being dispatched first and then flowing down the list. Note that higher-up event handlers can stop
the propagation of this event.


longname: Phaser.Input.Events.POINTER_MOVE
since: 3.0.0
name: POINTER_MOVE
memberof: Phaser.Input.Events
metafilename: POINTER_MOVE_EVENT.js
metapath: input/events
description:
The Pointer Move Input Event.

This event is dispatched by the Input Plugin belonging to a Scene if a pointer is moved anywhere.

Listen to this event from within a Scene using: `this.input.on('pointermove', listener)`.

The event hierarchy is as follows:

1. [``GAMEOBJECT_POINTER_MOVE``](Phaser.Input.Events#event:GAMEOBJECT_POINTER_MOVE)
2. [``GAMEOBJECT_MOVE``](Phaser.Input.Events#event:GAMEOBJECT_MOVE)
3. [``POINTER_MOVE``](Phaser.Input.Events#event:POINTER_MOVE)

With the top event being dispatched first and then flowing down the list. Note that higher-up event handlers can stop
the propagation of this event.


longname: Phaser.Input.Events.POINTER_OUT
since: 3.0.0
name: POINTER_OUT
memberof: Phaser.Input.Events
metafilename: POINTER_OUT_EVENT.js
metapath: input/events
description:
The Pointer Out Input Event.

This event is dispatched by the Input Plugin belonging to a Scene if a pointer moves out of any interactive Game Object.

Listen to this event from within a Scene using: `this.input.on('pointerout', listener)`.

The event hierarchy is as follows:

1. [``GAMEOBJECT_POINTER_OUT``](Phaser.Input.Events#event:GAMEOBJECT_POINTER_OUT)
2. [``GAMEOBJECT_OUT``](Phaser.Input.Events#event:GAMEOBJECT_OUT)
3. [``POINTER_OUT``](Phaser.Input.Events#event:POINTER_OUT)

With the top event being dispatched first and then flowing down the list. Note that higher-up event handlers can stop
the propagation of this event.


longname: Phaser.Input.Events.POINTER_OVER
since: 3.0.0
name: POINTER_OVER
memberof: Phaser.Input.Events
metafilename: POINTER_OVER_EVENT.js
metapath: input/events
description:
The Pointer Over Input Event.

This event is dispatched by the Input Plugin belonging to a Scene if a pointer moves over any interactive Game Object.

Listen to this event from within a Scene using: `this.input.on('pointerover', listener)`.

The event hierarchy is as follows:

1. [``GAMEOBJECT_POINTER_OVER``](Phaser.Input.Events#event:GAMEOBJECT_POINTER_OVER)
2. [``GAMEOBJECT_OVER``](Phaser.Input.Events#event:GAMEOBJECT_OVER)
3. [``POINTER_OVER``](Phaser.Input.Events#event:POINTER_OVER)

With the top event being dispatched first and then flowing down the list. Note that higher-up event handlers can stop
the propagation of this event.


longname: Phaser.Input.Events.POINTER_UP
since: 3.0.0
name: POINTER_UP
memberof: Phaser.Input.Events
metafilename: POINTER_UP_EVENT.js
metapath: input/events
description:
The Pointer Up Input Event.

This event is dispatched by the Input Plugin belonging to a Scene if a pointer is released anywhere.

Listen to this event from within a Scene using: `this.input.on('pointerup', listener)`.

The event hierarchy is as follows:

1. [``GAMEOBJECT_POINTER_UP``](Phaser.Input.Events#event:GAMEOBJECT_POINTER_UP)
2. [``GAMEOBJECT_UP``](Phaser.Input.Events#event:GAMEOBJECT_UP)
3. [``POINTER_UP``](Phaser.Input.Events#event:POINTER_UP) or [``POINTER_UP_OUTSIDE``](Phaser.Input.Events#event:POINTER_UP_OUTSIDE)

With the top event being dispatched first and then flowing down the list. Note that higher-up event handlers can stop
the propagation of this event.


longname: Phaser.Input.Events.POINTER_UP_OUTSIDE
since: 3.16.1
name: POINTER_UP_OUTSIDE
memberof: Phaser.Input.Events
metafilename: POINTER_UP_OUTSIDE_EVENT.js
metapath: input/events
description:
The Pointer Up Outside Input Event.

This event is dispatched by the Input Plugin belonging to a Scene if a pointer is released anywhere outside of the game canvas.

Listen to this event from within a Scene using: `this.input.on('pointerupoutside', listener)`.

The event hierarchy is as follows:

1. [``GAMEOBJECT_POINTER_UP``](Phaser.Input.Events#event:GAMEOBJECT_POINTER_UP)
2. [``GAMEOBJECT_UP``](Phaser.Input.Events#event:GAMEOBJECT_UP)
3. [``POINTER_UP``](Phaser.Input.Events#event:POINTER_UP) or [``POINTER_UP_OUTSIDE``](Phaser.Input.Events#event:POINTER_UP_OUTSIDE)

With the top event being dispatched first and then flowing down the list. Note that higher-up event handlers can stop
the propagation of this event.


longname: Phaser.Input.Events.POINTER_WHEEL
since: 3.18.0
name: POINTER_WHEEL
memberof: Phaser.Input.Events
metafilename: POINTER_WHEEL_EVENT.js
metapath: input/events
description:
The Pointer Wheel Input Event.

This event is dispatched by the Input Plugin belonging to a Scene if a pointer has its wheel updated.

Listen to this event from within a Scene using: `this.input.on('wheel', listener)`.

The event hierarchy is as follows:

1. [``GAMEOBJECT_POINTER_WHEEL``](Phaser.Input.Events#event:GAMEOBJECT_POINTER_WHEEL)
2. [``GAMEOBJECT_WHEEL``](Phaser.Input.Events#event:GAMEOBJECT_WHEEL)
3. [``POINTER_WHEEL``](Phaser.Input.Events#event:POINTER_WHEEL)

With the top event being dispatched first and then flowing down the list. Note that higher-up event handlers can stop
the propagation of this event.


longname: Phaser.Input.Events.PRE_UPDATE
since: 3.0.0
name: PRE_UPDATE
memberof: Phaser.Input.Events
metafilename: PRE_UPDATE_EVENT.js
metapath: input/events
description:
The Input Plugin Pre-Update Event.

This internal event is dispatched by the Input Plugin at the start of its `preUpdate` method.
This hook is designed specifically for input plugins, but can also be listened to from user-land code.


longname: Phaser.Input.Events.SHUTDOWN
since: 3.0.0
name: SHUTDOWN
memberof: Phaser.Input.Events
metafilename: SHUTDOWN_EVENT.js
metapath: input/events
description:
The Input Plugin Shutdown Event.

This internal event is dispatched by the Input Plugin when it shuts down, signalling to all of its systems to shut themselves down.


longname: Phaser.Input.Events.START
since: 3.0.0
name: START
memberof: Phaser.Input.Events
metafilename: START_EVENT.js
metapath: input/events
description:
The Input Plugin Start Event.

This internal event is dispatched by the Input Plugin when it has finished setting-up,
signalling to all of its internal systems to start.


longname: Phaser.Input.Events.UPDATE
since: 3.0.0
name: UPDATE
memberof: Phaser.Input.Events
metafilename: UPDATE_EVENT.js
metapath: input/events
description:
The Input Plugin Update Event.

This internal event is dispatched by the Input Plugin at the start of its `update` method.
This hook is designed specifically for input plugins, but can also be listened to from user-land code.


longname: Phaser.Input.Gamepad.Events.BUTTON_DOWN
since: 3.10.0
name: BUTTON_DOWN
memberof: Phaser.Input.Gamepad.Events
metafilename: BUTTON_DOWN_EVENT.js
metapath: input/gamepad/events
description:
The Gamepad Button Down Event.

This event is dispatched by the Gamepad Plugin when a button has been pressed on any active Gamepad.

Listen to this event from within a Scene using: `this.input.gamepad.on('down', listener)`.

You can also listen for a DOWN event from a Gamepad instance. See the [``GAMEPAD_BUTTON_DOWN``](Phaser.Input.Gamepad.Events#event:GAMEPAD_BUTTON_DOWN) event for details.


longname: Phaser.Input.Gamepad.Events.BUTTON_UP
since: 3.10.0
name: BUTTON_UP
memberof: Phaser.Input.Gamepad.Events
metafilename: BUTTON_UP_EVENT.js
metapath: input/gamepad/events
description:
The Gamepad Button Up Event.

This event is dispatched by the Gamepad Plugin when a button has been released on any active Gamepad.

Listen to this event from within a Scene using: `this.input.gamepad.on('up', listener)`.

You can also listen for an UP event from a Gamepad instance. See the [``GAMEPAD_BUTTON_UP``](Phaser.Input.Gamepad.Events#event:GAMEPAD_BUTTON_UP) event for details.


longname: Phaser.Input.Gamepad.Events.CONNECTED
since: 3.0.0
name: CONNECTED
memberof: Phaser.Input.Gamepad.Events
metafilename: CONNECTED_EVENT.js
metapath: input/gamepad/events
description:
The Gamepad Connected Event.

This event is dispatched by the Gamepad Plugin when a Gamepad has been connected.

Listen to this event from within a Scene using: `this.input.gamepad.once('connected', listener)`.

Note that the browser may require you to press a button on a gamepad before it will allow you to access it,
this is for security reasons. However, it may also trust the page already, in which case you won't get the
'connected' event and instead should check `GamepadPlugin.total` to see if it thinks there are any gamepads
already connected.


longname: Phaser.Input.Gamepad.Events.DISCONNECTED
since: 3.0.0
name: DISCONNECTED
memberof: Phaser.Input.Gamepad.Events
metafilename: DISCONNECTED_EVENT.js
metapath: input/gamepad/events
description:
The Gamepad Disconnected Event.

This event is dispatched by the Gamepad Plugin when a Gamepad has been disconnected.

Listen to this event from within a Scene using: `this.input.gamepad.once('disconnected', listener)`.


longname: Phaser.Input.Gamepad.Events.GAMEPAD_BUTTON_DOWN
since: 3.10.0
name: GAMEPAD_BUTTON_DOWN
memberof: Phaser.Input.Gamepad.Events
metafilename: GAMEPAD_BUTTON_DOWN_EVENT.js
metapath: input/gamepad/events
description:
The Gamepad Button Down Event.

This event is dispatched by a Gamepad instance when a button has been pressed on it.

Listen to this event from a Gamepad instance. Once way to get this is from the `pad1`, `pad2`, etc properties on the Gamepad Plugin:
`this.input.gamepad.pad1.on('down', listener)`.

Note that you will not receive any Gamepad button events until the browser considers the Gamepad as being 'connected'.

You can also listen for a DOWN event from the Gamepad Plugin. See the [``BUTTON_DOWN``](Phaser.Input.Gamepad.Events#event:BUTTON_DOWN) event for details.


longname: Phaser.Input.Gamepad.Events.GAMEPAD_BUTTON_UP
since: 3.10.0
name: GAMEPAD_BUTTON_UP
memberof: Phaser.Input.Gamepad.Events
metafilename: GAMEPAD_BUTTON_UP_EVENT.js
metapath: input/gamepad/events
description:
The Gamepad Button Up Event.

This event is dispatched by a Gamepad instance when a button has been released on it.

Listen to this event from a Gamepad instance. Once way to get this is from the `pad1`, `pad2`, etc properties on the Gamepad Plugin:
`this.input.gamepad.pad1.on('up', listener)`.

Note that you will not receive any Gamepad button events until the browser considers the Gamepad as being 'connected'.

You can also listen for an UP event from the Gamepad Plugin. See the [``BUTTON_UP``](Phaser.Input.Gamepad.Events#event:BUTTON_UP) event for details.


longname: Phaser.Input.Keyboard.Events.ANY_KEY_DOWN
since: 3.0.0
name: ANY_KEY_DOWN
memberof: Phaser.Input.Keyboard.Events
metafilename: ANY_KEY_DOWN_EVENT.js
metapath: input/keyboard/events
description:
The Global Key Down Event.

This event is dispatched by the Keyboard Plugin when any key on the keyboard is pressed down.

Listen to this event from within a Scene using: `this.input.keyboard.on('keydown', listener)`.

You can also listen for a specific key being pressed. See [``Keyboard.Events.KEY_DOWN``](Phaser.Input.Keyboard.Events#event:KEY_DOWN) for details.

Finally, you can create Key objects, which you can also listen for events from. See [``Keyboard.Events.DOWN``](Phaser.Input.Keyboard.Events#event:DOWN) for details.

_Note_: Many keyboards are unable to process certain combinations of keys due to hardware limitations known as ghosting.
Read [this article on ghosting]{@link [http://www.html5gamedevs.com/topic/4876-impossible-to-use-more-than-2-keyboard-input-buttons-at-the-same-time/](http://www.html5gamedevs.com/topic/4876-impossible-to-use-more-than-2-keyboard-input-buttons-at-the-same-time/)} for details.

Also, please be aware that some browser extensions can disable or override Phaser keyboard handling.
For example, the Chrome extension vimium is known to disable Phaser from using the D key, while EverNote disables the backtick key.
There are others. So, please check your extensions if you find you have specific keys that don't work.


longname: Phaser.Input.Keyboard.Events.ANY_KEY_UP
since: 3.0.0
name: ANY_KEY_UP
memberof: Phaser.Input.Keyboard.Events
metafilename: ANY_KEY_UP_EVENT.js
metapath: input/keyboard/events
description:
The Global Key Up Event.

This event is dispatched by the Keyboard Plugin when any key on the keyboard is released.

Listen to this event from within a Scene using: `this.input.keyboard.on('keyup', listener)`.

You can also listen for a specific key being released. See [``Keyboard.Events.KEY_UP``](Phaser.Input.Keyboard.Events#event:KEY_UP) for details.

Finally, you can create Key objects, which you can also listen for events from. See [``Keyboard.Events.UP``](Phaser.Input.Keyboard.Events#event:UP) for details.


longname: Phaser.Input.Keyboard.Events.COMBO_MATCH
since: 3.0.0
name: COMBO_MATCH
memberof: Phaser.Input.Keyboard.Events
metafilename: COMBO_MATCH_EVENT.js
metapath: input/keyboard/events
description:
The Key Combo Match Event.

This event is dispatched by the Keyboard Plugin when a [Key Combo](Phaser.Input.Keyboard.KeyCombo) is matched.

Listen for this event from the Key Plugin after a combo has been created:

```javascript
this.input.keyboard.createCombo([ 38, 38, 40, 40, 37, 39, 37, 39, 66, 65, 13 ], { resetOnMatch: true });

this.input.keyboard.on('keycombomatch', function (event) {
    console.log('Konami Code entered!');
});
```


longname: Phaser.Input.Keyboard.Events.DOWN
since: 3.0.0
name: DOWN
memberof: Phaser.Input.Keyboard.Events
metafilename: DOWN_EVENT.js
metapath: input/keyboard/events
description:
The Key Down Event.

This event is dispatched by a [Key](Phaser.Input.Keyboard.Key) object when it is pressed.

Listen for this event from the Key object instance directly:

```javascript
var spaceBar = this.input.keyboard.addKey(Phaser.Input.Keyboard.KeyCodes.SPACE);

spaceBar.on('down', listener)
```

You can also create a generic 'global' listener. See [``Keyboard.Events.ANY_KEY_DOWN``](Phaser.Input.Keyboard.Events#event:ANY_KEY_DOWN) for details.


longname: Phaser.Input.Keyboard.Events.KEY_DOWN
since: 3.0.0
name: KEY_DOWN
memberof: Phaser.Input.Keyboard.Events
metafilename: KEY_DOWN_EVENT.js
metapath: input/keyboard/events
description:
The Key Down Event.

This event is dispatched by the Keyboard Plugin when any key on the keyboard is pressed down.

Unlike the `ANY_KEY_DOWN` event, this one has a special dynamic event name. For example, to listen for the `A` key being pressed
use the following from within a Scene: `this.input.keyboard.on('keydown-A', listener)`. You can replace the `-A` part of the event
name with any valid [Key Code string](Phaser.Input.Keyboard.KeyCodes). For example, this will listen for the space bar: 
`this.input.keyboard.on('keydown-SPACE', listener)`.

You can also create a generic 'global' listener. See [``Keyboard.Events.ANY_KEY_DOWN``](Phaser.Input.Keyboard.Events#event:ANY_KEY_DOWN) for details.

Finally, you can create Key objects, which you can also listen for events from. See [``Keyboard.Events.DOWN``](Phaser.Input.Keyboard.Events#event:DOWN) for details.

_Note_: Many keyboards are unable to process certain combinations of keys due to hardware limitations known as ghosting.
Read [this article on ghosting]{@link http://www.html5gamedevs.com/topic/4876-impossible-to-use-more-than-2-keyboard-input-buttons-at-the-same-time/} for details.

Also, please be aware that some browser extensions can disable or override Phaser keyboard handling.
For example, the Chrome extension vimium is known to disable Phaser from using the D key, while EverNote disables the backtick key.
There are others. So, please check your extensions if you find you have specific keys that don't work.


longname: Phaser.Input.Keyboard.Events.KEY_UP
since: 3.0.0
name: KEY_UP
memberof: Phaser.Input.Keyboard.Events
metafilename: KEY_UP_EVENT.js
metapath: input/keyboard/events
description:
The Key Up Event.

This event is dispatched by the Keyboard Plugin when any key on the keyboard is released.

Unlike the `ANY_KEY_UP` event, this one has a special dynamic event name. For example, to listen for the `A` key being released
use the following from within a Scene: `this.input.keyboard.on('keyup-A', listener)`. You can replace the `-A` part of the event
name with any valid [Key Code string](Phaser.Input.Keyboard.KeyCodes). For example, this will listen for the space bar: 
`this.input.keyboard.on('keyup-SPACE', listener)`.

You can also create a generic 'global' listener. See [``Keyboard.Events.ANY_KEY_UP``](Phaser.Input.Keyboard.Events#event:ANY_KEY_UP) for details.

Finally, you can create Key objects, which you can also listen for events from. See [``Keyboard.Events.UP``](Phaser.Input.Keyboard.Events#event:UP) for details.


longname: Phaser.Input.Keyboard.Events.UP
since: 3.0.0
name: UP
memberof: Phaser.Input.Keyboard.Events
metafilename: UP_EVENT.js
metapath: input/keyboard/events
description:
The Key Up Event.

This event is dispatched by a [Key](Phaser.Input.Keyboard.Key) object when it is released.

Listen for this event from the Key object instance directly:

```javascript
var spaceBar = this.input.keyboard.addKey(Phaser.Input.Keyboard.KeyCodes.SPACE);

spaceBar.on('up', listener)
```

You can also create a generic 'global' listener. See [``Keyboard.Events.ANY_KEY_UP``](Phaser.Input.Keyboard.Events#event:ANY_KEY_UP) for details.


longname: Phaser.Loader.Events.ADD
since: 3.0.0
name: ADD
memberof: Phaser.Loader.Events
metafilename: ADD_EVENT.js
metapath: loader/events
description:
The Loader Plugin Add File Event.

This event is dispatched when a new file is successfully added to the Loader and placed into the load queue.

Listen to it from a Scene using: `this.load.on('addfile', listener)`.

If you add lots of files to a Loader from a `preload` method, it will dispatch this event for each one of them.


longname: Phaser.Loader.Events.COMPLETE
since: 3.0.0
name: COMPLETE
memberof: Phaser.Loader.Events
metafilename: COMPLETE_EVENT.js
metapath: loader/events
description:
The Loader Plugin Complete Event.

This event is dispatched when the Loader has fully processed everything in the load queue.
By this point every loaded file will now be in its associated cache and ready for use.

Listen to it from a Scene using: `this.load.on('complete', listener)`.


longname: Phaser.Loader.Events.FILE_COMPLETE
since: 3.0.0
name: FILE_COMPLETE
memberof: Phaser.Loader.Events
metafilename: FILE_COMPLETE_EVENT.js
metapath: loader/events
description:
The File Load Complete Event.

This event is dispatched by the Loader Plugin when any file in the queue finishes loading.

Listen to it from a Scene using: `this.load.on('filecomplete', listener)`.

You can also listen for the completion of a specific file. See the [``FILE_KEY_COMPLETE``](Phaser.Loader.Events#event:FILE_KEY_COMPLETE) event.


longname: Phaser.Loader.Events.FILE_KEY_COMPLETE
since: 3.0.0
name: FILE_KEY_COMPLETE
memberof: Phaser.Loader.Events
metafilename: FILE_KEY_COMPLETE_EVENT.js
metapath: loader/events
description:
The File Load Complete Event.

This event is dispatched by the Loader Plugin when any file in the queue finishes loading.

It uses a special dynamic event name constructed from the key and type of the file.

For example, if you have loaded an `image` with a key of `monster`, you can listen for it
using the following:

```javascript
this.load.on('filecomplete-image-monster', function (key, type, data) {
    // Your handler code
});
```

Or, if you have loaded a texture `atlas` with a key of `Level1`:

```javascript
this.load.on('filecomplete-atlas-Level1', function (key, type, data) {
    // Your handler code
});
```

Or, if you have loaded a sprite sheet with a key of `Explosion` and a prefix of `GAMEOVER`:

```javascript
this.load.on('filecomplete-spritesheet-GAMEOVERExplosion', function (key, type, data) {
    // Your handler code
});
```

You can also listen for the generic completion of files. See the [``FILE_COMPLETE``](Phaser.Loader.Events#event:FILE_COMPLETE) event.


longname: Phaser.Loader.Events.FILE_LOAD_ERROR
since: 3.0.0
name: FILE_LOAD_ERROR
memberof: Phaser.Loader.Events
metafilename: FILE_LOAD_ERROR_EVENT.js
metapath: loader/events
description:
The File Load Error Event.

This event is dispatched by the Loader Plugin when a file fails to load.

Listen to it from a Scene using: `this.load.on('loaderror', listener)`.


longname: Phaser.Loader.Events.FILE_LOAD
since: 3.0.0
name: FILE_LOAD
memberof: Phaser.Loader.Events
metafilename: FILE_LOAD_EVENT.js
metapath: loader/events
description:
The File Load Event.

This event is dispatched by the Loader Plugin when a file finishes loading,
but _before_ it is processed and added to the internal Phaser caches.

Listen to it from a Scene using: `this.load.on('load', listener)`.


longname: Phaser.Loader.Events.FILE_PROGRESS
since: 3.0.0
name: FILE_PROGRESS
memberof: Phaser.Loader.Events
metafilename: FILE_PROGRESS_EVENT.js
metapath: loader/events
description:
The File Load Progress Event.

This event is dispatched by the Loader Plugin during the load of a file, if the browser receives a DOM ProgressEvent and
the `lengthComputable` event property is true. Depending on the size of the file and browser in use, this may, or may not happen.

Listen to it from a Scene using: `this.load.on('fileprogress', listener)`.


longname: Phaser.Loader.Events.POST_PROCESS
since: 3.0.0
name: POST_PROCESS
memberof: Phaser.Loader.Events
metafilename: POST_PROCESS_EVENT.js
metapath: loader/events
description:
The Loader Plugin Post Process Event.

This event is dispatched by the Loader Plugin when the Loader has finished loading everything in the load queue.
It is dispatched before the internal lists are cleared and each File is destroyed.

Use this hook to perform any last minute processing of files that can only happen once the
Loader has completed, but prior to it emitting the `complete` event.

Listen to it from a Scene using: `this.load.on('postprocess', listener)`.


longname: Phaser.Loader.Events.PROGRESS
since: 3.0.0
name: PROGRESS
memberof: Phaser.Loader.Events
metafilename: PROGRESS_EVENT.js
metapath: loader/events
description:
The Loader Plugin Progress Event.

This event is dispatched when the Loader updates its load progress, typically as a result of a file having completed loading.

Listen to it from a Scene using: `this.load.on('progress', listener)`.


longname: Phaser.Loader.Events.START
since: 3.0.0
name: START
memberof: Phaser.Loader.Events
metafilename: START_EVENT.js
metapath: loader/events
description:
The Loader Plugin Start Event.

This event is dispatched when the Loader starts running. At this point load progress is zero.

This event is dispatched even if there aren't any files in the load queue.

Listen to it from a Scene using: `this.load.on('start', listener)`.


longname: Phaser.Physics.Arcade.Events.COLLIDE
since: 3.0.0
name: COLLIDE
memberof: Phaser.Physics.Arcade.Events
metafilename: COLLIDE_EVENT.js
metapath: physics/arcade/events
description:
The Arcade Physics World Collide Event.

This event is dispatched by an Arcade Physics World instance if two bodies collide _and_ at least
one of them has their [onCollide](Phaser.Physics.Arcade.Body#onCollide) property set to `true`.

It provides an alternative means to handling collide events rather than using the callback approach.

Listen to it from a Scene using: `this.physics.world.on('collide', listener)`.

Please note that 'collide' and 'overlap' are two different things in Arcade Physics.


longname: Phaser.Physics.Arcade.Events.OVERLAP
since: 3.0.0
name: OVERLAP
memberof: Phaser.Physics.Arcade.Events
metafilename: OVERLAP_EVENT.js
metapath: physics/arcade/events
description:
The Arcade Physics World Overlap Event.

This event is dispatched by an Arcade Physics World instance if two bodies overlap _and_ at least
one of them has their [onOverlap](Phaser.Physics.Arcade.Body#onOverlap) property set to `true`.

It provides an alternative means to handling overlap events rather than using the callback approach.

Listen to it from a Scene using: `this.physics.world.on('overlap', listener)`.

Please note that 'collide' and 'overlap' are two different things in Arcade Physics.


longname: Phaser.Physics.Arcade.Events.PAUSE
since: 3.0.0
name: PAUSE
memberof: Phaser.Physics.Arcade.Events
metafilename: PAUSE_EVENT.js
metapath: physics/arcade/events
description:
The Arcade Physics World Pause Event.

This event is dispatched by an Arcade Physics World instance when it is paused.

Listen to it from a Scene using: `this.physics.world.on('pause', listener)`.


longname: Phaser.Physics.Arcade.Events.RESUME
since: 3.0.0
name: RESUME
memberof: Phaser.Physics.Arcade.Events
metafilename: RESUME_EVENT.js
metapath: physics/arcade/events
description:
The Arcade Physics World Resume Event.

This event is dispatched by an Arcade Physics World instance when it resumes from a paused state.

Listen to it from a Scene using: `this.physics.world.on('resume', listener)`.


longname: Phaser.Physics.Arcade.Events.TILE_COLLIDE
since: 3.16.1
name: TILE_COLLIDE
memberof: Phaser.Physics.Arcade.Events
metafilename: TILE_COLLIDE_EVENT.js
metapath: physics/arcade/events
description:
The Arcade Physics Tile Collide Event.

This event is dispatched by an Arcade Physics World instance if a body collides with a Tile _and_
has its [onCollide](Phaser.Physics.Arcade.Body#onCollide) property set to `true`.

It provides an alternative means to handling collide events rather than using the callback approach.

Listen to it from a Scene using: `this.physics.world.on('tilecollide', listener)`.

Please note that 'collide' and 'overlap' are two different things in Arcade Physics.


longname: Phaser.Physics.Arcade.Events.TILE_OVERLAP
since: 3.16.1
name: TILE_OVERLAP
memberof: Phaser.Physics.Arcade.Events
metafilename: TILE_OVERLAP_EVENT.js
metapath: physics/arcade/events
description:
The Arcade Physics Tile Overlap Event.

This event is dispatched by an Arcade Physics World instance if a body overlaps with a Tile _and_
has its [onOverlap](Phaser.Physics.Arcade.Body#onOverlap) property set to `true`.

It provides an alternative means to handling overlap events rather than using the callback approach.

Listen to it from a Scene using: `this.physics.world.on('tileoverlap', listener)`.

Please note that 'collide' and 'overlap' are two different things in Arcade Physics.


longname: Phaser.Physics.Arcade.Events.WORLD_BOUNDS
since: 3.0.0
name: WORLD_BOUNDS
memberof: Phaser.Physics.Arcade.Events
metafilename: WORLD_BOUNDS_EVENT.js
metapath: physics/arcade/events
description:
The Arcade Physics World Bounds Event.

This event is dispatched by an Arcade Physics World instance if a body makes contact with the world bounds _and_
it has its [onWorldBounds](Phaser.Physics.Arcade.Body#onWorldBounds) property set to `true`.

It provides an alternative means to handling collide events rather than using the callback approach.

Listen to it from a Scene using: `this.physics.world.on('worldbounds', listener)`.


longname: Phaser.Physics.Arcade.Events.WORLD_STEP
since: 3.18.0
name: WORLD_STEP
memberof: Phaser.Physics.Arcade.Events
metafilename: WORLD_STEP_EVENT.js
metapath: physics/arcade/events
description:
The Arcade Physics World Step Event.

This event is dispatched by an Arcade Physics World instance whenever a physics step is run.
It is emitted _after_ the bodies and colliders have been updated.

In high framerate settings this can be multiple times per game frame.

Listen to it from a Scene using: `this.physics.world.on('worldstep', listener)`.


longname: Phaser.Physics.Matter.Events.AFTER_ADD
since: 3.22.0
name: AFTER_ADD
memberof: Phaser.Physics.Matter.Events
metafilename: AFTER_ADD_EVENT.js
metapath: physics/matter-js/events
description:
The Matter Physics After Add Event.

This event is dispatched by a Matter Physics World instance at the end of the process when a new Body
or Constraint has just been added to the world.

Listen to it from a Scene using: `this.matter.world.on('afteradd', listener)`.


longname: Phaser.Physics.Matter.Events.AFTER_REMOVE
since: 3.22.0
name: AFTER_REMOVE
memberof: Phaser.Physics.Matter.Events
metafilename: AFTER_REMOVE_EVENT.js
metapath: physics/matter-js/events
description:
The Matter Physics After Remove Event.

This event is dispatched by a Matter Physics World instance at the end of the process when a 
Body or Constraint was removed from the world.

Listen to it from a Scene using: `this.matter.world.on('afterremove', listener)`.


longname: Phaser.Physics.Matter.Events.AFTER_UPDATE
since: 3.0.0
name: AFTER_UPDATE
memberof: Phaser.Physics.Matter.Events
metafilename: AFTER_UPDATE_EVENT.js
metapath: physics/matter-js/events
description:
The Matter Physics After Update Event.

This event is dispatched by a Matter Physics World instance after the engine has updated and all collision events have resolved.

Listen to it from a Scene using: `this.matter.world.on('afterupdate', listener)`.


longname: Phaser.Physics.Matter.Events.BEFORE_ADD
since: 3.22.0
name: BEFORE_ADD
memberof: Phaser.Physics.Matter.Events
metafilename: BEFORE_ADD_EVENT.js
metapath: physics/matter-js/events
description:
The Matter Physics Before Add Event.

This event is dispatched by a Matter Physics World instance at the start of the process when a new Body
or Constraint is being added to the world.

Listen to it from a Scene using: `this.matter.world.on('beforeadd', listener)`.


longname: Phaser.Physics.Matter.Events.BEFORE_REMOVE
since: 3.22.0
name: BEFORE_REMOVE
memberof: Phaser.Physics.Matter.Events
metafilename: BEFORE_REMOVE_EVENT.js
metapath: physics/matter-js/events
description:
The Matter Physics Before Remove Event.

This event is dispatched by a Matter Physics World instance at the start of the process when a 
Body or Constraint is being removed from the world.

Listen to it from a Scene using: `this.matter.world.on('beforeremove', listener)`.


longname: Phaser.Physics.Matter.Events.BEFORE_UPDATE
since: 3.0.0
name: BEFORE_UPDATE
memberof: Phaser.Physics.Matter.Events
metafilename: BEFORE_UPDATE_EVENT.js
metapath: physics/matter-js/events
description:
The Matter Physics Before Update Event.

This event is dispatched by a Matter Physics World instance right before all the collision processing takes place.

Listen to it from a Scene using: `this.matter.world.on('beforeupdate', listener)`.


longname: Phaser.Physics.Matter.Events.COLLISION_ACTIVE
since: 3.0.0
name: COLLISION_ACTIVE
memberof: Phaser.Physics.Matter.Events
metafilename: COLLISION_ACTIVE_EVENT.js
metapath: physics/matter-js/events
description:
The Matter Physics Collision Active Event.

This event is dispatched by a Matter Physics World instance after the engine has updated.
It provides a list of all pairs that are colliding in the current tick (if any).

Listen to it from a Scene using: `this.matter.world.on('collisionactive', listener)`.


longname: Phaser.Physics.Matter.Events.COLLISION_END
since: 3.0.0
name: COLLISION_END
memberof: Phaser.Physics.Matter.Events
metafilename: COLLISION_END_EVENT.js
metapath: physics/matter-js/events
description:
The Matter Physics Collision End Event.

This event is dispatched by a Matter Physics World instance after the engine has updated.
It provides a list of all pairs that have finished colliding in the current tick (if any).

Listen to it from a Scene using: `this.matter.world.on('collisionend', listener)`.


longname: Phaser.Physics.Matter.Events.COLLISION_START
since: 3.0.0
name: COLLISION_START
memberof: Phaser.Physics.Matter.Events
metafilename: COLLISION_START_EVENT.js
metapath: physics/matter-js/events
description:
The Matter Physics Collision Start Event.

This event is dispatched by a Matter Physics World instance after the engine has updated.
It provides a list of all pairs that have started to collide in the current tick (if any).

Listen to it from a Scene using: `this.matter.world.on('collisionstart', listener)`.


longname: Phaser.Physics.Matter.Events.DRAG_END
since: 3.16.2
name: DRAG_END
memberof: Phaser.Physics.Matter.Events
metafilename: DRAG_END_EVENT.js
metapath: physics/matter-js/events
description:
The Matter Physics Drag End Event.

This event is dispatched by a Matter Physics World instance when a Pointer Constraint
stops dragging a body.

Listen to it from a Scene using: `this.matter.world.on('dragend', listener)`.


longname: Phaser.Physics.Matter.Events.DRAG
since: 3.16.2
name: DRAG
memberof: Phaser.Physics.Matter.Events
metafilename: DRAG_EVENT.js
metapath: physics/matter-js/events
description:
The Matter Physics Drag Event.

This event is dispatched by a Matter Physics World instance when a Pointer Constraint
is actively dragging a body. It is emitted each time the pointer moves.

Listen to it from a Scene using: `this.matter.world.on('drag', listener)`.


longname: Phaser.Physics.Matter.Events.DRAG_START
since: 3.16.2
name: DRAG_START
memberof: Phaser.Physics.Matter.Events
metafilename: DRAG_START_EVENT.js
metapath: physics/matter-js/events
description:
The Matter Physics Drag Start Event.

This event is dispatched by a Matter Physics World instance when a Pointer Constraint
starts dragging a body.

Listen to it from a Scene using: `this.matter.world.on('dragstart', listener)`.


longname: Phaser.Physics.Matter.Events.PAUSE
since: 3.0.0
name: PAUSE
memberof: Phaser.Physics.Matter.Events
metafilename: PAUSE_EVENT.js
metapath: physics/matter-js/events
description:
The Matter Physics World Pause Event.

This event is dispatched by an Matter Physics World instance when it is paused.

Listen to it from a Scene using: `this.matter.world.on('pause', listener)`.


longname: Phaser.Physics.Matter.Events.RESUME
since: 3.0.0
name: RESUME
memberof: Phaser.Physics.Matter.Events
metafilename: RESUME_EVENT.js
metapath: physics/matter-js/events
description:
The Matter Physics World Resume Event.

This event is dispatched by an Matter Physics World instance when it resumes from a paused state.

Listen to it from a Scene using: `this.matter.world.on('resume', listener)`.


longname: Phaser.Physics.Matter.Events.SLEEP_END
since: 3.0.0
name: SLEEP_END
memberof: Phaser.Physics.Matter.Events
metafilename: SLEEP_END_EVENT.js
metapath: physics/matter-js/events
description:
The Matter Physics Sleep End Event.

This event is dispatched by a Matter Physics World instance when a Body stop sleeping.

Listen to it from a Scene using: `this.matter.world.on('sleepend', listener)`.


longname: Phaser.Physics.Matter.Events.SLEEP_START
since: 3.0.0
name: SLEEP_START
memberof: Phaser.Physics.Matter.Events
metafilename: SLEEP_START_EVENT.js
metapath: physics/matter-js/events
description:
The Matter Physics Sleep Start Event.

This event is dispatched by a Matter Physics World instance when a Body goes to sleep.

Listen to it from a Scene using: `this.matter.world.on('sleepstart', listener)`.


longname: Phaser.Renderer.Events.POST_RENDER
since: 3.50.0
name: POST_RENDER
memberof: Phaser.Renderer.Events
metafilename: POST_RENDER_EVENT.js
metapath: renderer/events
description:
The Post-Render Event.

This event is dispatched by the Renderer when all rendering, for all cameras in all Scenes,
has completed, but before any pending snap shots have been taken.


longname: Phaser.Renderer.Events.PRE_RENDER
since: 3.50.0
name: PRE_RENDER
memberof: Phaser.Renderer.Events
metafilename: PRE_RENDER_EVENT.js
metapath: renderer/events
description:
The Pre-Render Event.

This event is dispatched by the Phaser Renderer. This happens right at the start of the render
process, after the context has been cleared, the scissors enabled (WebGL only) and everything has been
reset ready for the render.


longname: Phaser.Renderer.Events.RENDER
since: 3.50.0
name: RENDER
memberof: Phaser.Renderer.Events
metafilename: RENDER_EVENT.js
metapath: renderer/events
description:
The Render Event.

This event is dispatched by the Phaser Renderer for every camera in every Scene.

It is dispatched before any of the children in the Scene have been rendered.


longname: Phaser.Renderer.Events.RESIZE
since: 3.50.0
name: RESIZE
memberof: Phaser.Renderer.Events
metafilename: RESIZE_EVENT.js
metapath: renderer/events
description:
The Renderer Resize Event.

This event is dispatched by the Phaser Renderer when it is resized, usually as a result
of the Scale Manager resizing.


longname: Phaser.Renderer.WebGL.Pipelines.Events.AFTER_FLUSH
since: 3.50.0
name: AFTER_FLUSH
memberof: Phaser.Renderer.WebGL.Pipelines.Events
metafilename: AFTER_FLUSH_EVENT.js
metapath: renderer/webgl/pipelines/events
description:
The WebGLPipeline After Flush Event.

This event is dispatched by a WebGLPipeline right after it has issued a drawArrays command
and cleared its vertex count.


longname: Phaser.Renderer.WebGL.Pipelines.Events.BEFORE_FLUSH
since: 3.50.0
name: BEFORE_FLUSH
memberof: Phaser.Renderer.WebGL.Pipelines.Events
metafilename: BEFORE_FLUSH_EVENT.js
metapath: renderer/webgl/pipelines/events
description:
The WebGLPipeline Before Flush Event.

This event is dispatched by a WebGLPipeline right before it is about to
flush and issue a bufferData and drawArrays command.


longname: Phaser.Renderer.WebGL.Pipelines.Events.BIND
since: 3.50.0
name: BIND
memberof: Phaser.Renderer.WebGL.Pipelines.Events
metafilename: BIND_EVENT.js
metapath: renderer/webgl/pipelines/events
description:
The WebGLPipeline Bind Event.

This event is dispatched by a WebGLPipeline when it is bound by the Pipeline Manager.


longname: Phaser.Renderer.WebGL.Pipelines.Events.BOOT
since: 3.50.0
name: BOOT
memberof: Phaser.Renderer.WebGL.Pipelines.Events
metafilename: BOOT_EVENT.js
metapath: renderer/webgl/pipelines/events
description:
The WebGLPipeline Boot Event.

This event is dispatched by a WebGLPipeline when it has completed its `boot` phase.


longname: Phaser.Renderer.WebGL.Pipelines.Events.DESTROY
since: 3.50.0
name: DESTROY
memberof: Phaser.Renderer.WebGL.Pipelines.Events
metafilename: DESTROY_EVENT.js
metapath: renderer/webgl/pipelines/events
description:
The WebGLPipeline Destroy Event.

This event is dispatched by a WebGLPipeline when it is starting its destroy process.


longname: Phaser.Renderer.WebGL.Pipelines.Events.REBIND
since: 3.50.0
name: REBIND
memberof: Phaser.Renderer.WebGL.Pipelines.Events
metafilename: REBIND_EVENT.js
metapath: renderer/webgl/pipelines/events
description:
The WebGLPipeline ReBind Event.

This event is dispatched by a WebGLPipeline when it is re-bound by the Pipeline Manager.


longname: Phaser.Renderer.WebGL.Pipelines.Events.RESIZE
since: 3.50.0
name: RESIZE
memberof: Phaser.Renderer.WebGL.Pipelines.Events
metafilename: RESIZE_EVENT.js
metapath: renderer/webgl/pipelines/events
description:
The WebGLPipeline Resize Event.

This event is dispatched by a WebGLPipeline when it is resized, usually as a result
of the Renderer resizing.


longname: Phaser.Scale.Events.LEAVE_FULLSCREEN
since: 3.16.1
name: LEAVE_FULLSCREEN
memberof: Phaser.Scale.Events
metafilename: LEAVE_FULLSCREEN_EVENT.js
metapath: scale/events
description:
The Scale Manager was in fullscreen mode, but has since left, either directly via game code,
or via a user gestured, such as pressing the ESC key.


longname: Phaser.Scale.Events.ORIENTATION_CHANGE
since: 3.16.1
name: ORIENTATION_CHANGE
memberof: Phaser.Scale.Events
metafilename: ORIENTATION_CHANGE_EVENT.js
metapath: scale/events
description:
The Scale Manager Orientation Change Event.

This event is dispatched whenever the Scale Manager detects an orientation change event from the browser.


longname: Phaser.Scale.Events.RESIZE
since: 3.16.1
name: RESIZE
memberof: Phaser.Scale.Events
metafilename: RESIZE_EVENT.js
metapath: scale/events
description:
The Scale Manager Resize Event.

This event is dispatched whenever the Scale Manager detects a resize event from the browser.
It sends three parameters to the callback, each of them being Size components. You can read
the `width`, `height`, `aspectRatio` and other properties of these components to help with
scaling your own game content.


longname: Phaser.Scenes.Events.ADDED_TO_SCENE
since: 3.50.0
name: ADDED_TO_SCENE
memberof: Phaser.Scenes.Events
metafilename: ADDED_TO_SCENE_EVENT.js
metapath: scene/events
description:
The Game Object Added to Scene Event.

This event is dispatched when a Game Object is added to a Scene.

Listen for it from a Scene using `this.events.on('addedtoscene', listener)`.


longname: Phaser.Scenes.Events.BOOT
since: 3.0.0
name: BOOT
memberof: Phaser.Scenes.Events
metafilename: BOOT_EVENT.js
metapath: scene/events
description:
The Scene Systems Boot Event.

This event is dispatched by a Scene during the Scene Systems boot process. Primarily used by Scene Plugins.

Listen to it from a Scene using `this.events.on('boot', listener)`.


longname: Phaser.Scenes.Events.CREATE
since: 3.17.0
name: CREATE
memberof: Phaser.Scenes.Events
metafilename: CREATE_EVENT.js
metapath: scene/events
description:
The Scene Create Event.

This event is dispatched by a Scene after it has been created by the Scene Manager.

If a Scene has a `create` method then this event is emitted _after_ that has run.

If there is a transition, this event will be fired after the `TRANSITION_START` event.

Listen to it from a Scene using `this.events.on('create', listener)`.


longname: Phaser.Scenes.Events.DESTROY
since: 3.0.0
name: DESTROY
memberof: Phaser.Scenes.Events
metafilename: DESTROY_EVENT.js
metapath: scene/events
description:
The Scene Systems Destroy Event.

This event is dispatched by a Scene during the Scene Systems destroy process.

Listen to it from a Scene using `this.events.on('destroy', listener)`.

You should destroy any resources that may be in use by your Scene in this event handler.


longname: Phaser.Scenes.Events.PAUSE
since: 3.0.0
name: PAUSE
memberof: Phaser.Scenes.Events
metafilename: PAUSE_EVENT.js
metapath: scene/events
description:
The Scene Systems Pause Event.

This event is dispatched by a Scene when it is paused, either directly via the `pause` method, or as an
action from another Scene.

Listen to it from a Scene using `this.events.on('pause', listener)`.


longname: Phaser.Scenes.Events.POST_UPDATE
since: 3.0.0
name: POST_UPDATE
memberof: Phaser.Scenes.Events
metafilename: POST_UPDATE_EVENT.js
metapath: scene/events
description:
The Scene Systems Post Update Event.

This event is dispatched by a Scene during the main game loop step.

The event flow for a single step of a Scene is as follows:

1. [``PRE_UPDATE``](Phaser.Scenes.Events#event:PRE_UPDATE)
2. [``UPDATE``](Phaser.Scenes.Events#event:UPDATE)
3. The `Scene.update` method is called, if it exists
4. [``POST_UPDATE``](Phaser.Scenes.Events#event:POST_UPDATE)
5. [``PRE_RENDER``](Phaser.Scenes.Events#event:PRE_RENDER)
6. [``RENDER``](Phaser.Scenes.Events#event:RENDER)

Listen to it from a Scene using `this.events.on('postupdate', listener)`.

A Scene will only run its step if it is active.


longname: Phaser.Scenes.Events.PRE_RENDER
since: 3.53.0
name: PRE_RENDER
memberof: Phaser.Scenes.Events
metafilename: PRE_RENDER_EVENT.js
metapath: scene/events
description:
The Scene Systems Pre-Render Event.

This event is dispatched by a Scene during the main game loop step.

The event flow for a single step of a Scene is as follows:

1. [``PRE_UPDATE``](Phaser.Scenes.Events#event:PRE_UPDATE)
2. [``UPDATE``](Phaser.Scenes.Events#event:UPDATE)
3. The `Scene.update` method is called, if it exists
4. [``POST_UPDATE``](Phaser.Scenes.Events#event:POST_UPDATE)
5. [``PRE_RENDER``](Phaser.Scenes.Events#event:PRE_RENDER)
6. [``RENDER``](Phaser.Scenes.Events#event:RENDER)

Listen to this event from a Scene using `this.events.on('prerender', listener)`.

A Scene will only render if it is visible.

This event is dispatched after the Scene Display List is sorted and before the Scene is rendered.


longname: Phaser.Scenes.Events.PRE_UPDATE
since: 3.0.0
name: PRE_UPDATE
memberof: Phaser.Scenes.Events
metafilename: PRE_UPDATE_EVENT.js
metapath: scene/events
description:
The Scene Systems Pre Update Event.

This event is dispatched by a Scene during the main game loop step.

The event flow for a single step of a Scene is as follows:

1. [``PRE_UPDATE``](Phaser.Scenes.Events#event:PRE_UPDATE)
2. [``UPDATE``](Phaser.Scenes.Events#event:UPDATE)
3. The `Scene.update` method is called, if it exists
4. [``POST_UPDATE``](Phaser.Scenes.Events#event:POST_UPDATE)
5. [``PRE_RENDER``](Phaser.Scenes.Events#event:PRE_RENDER)
6. [``RENDER``](Phaser.Scenes.Events#event:RENDER)

Listen to it from a Scene using `this.events.on('preupdate', listener)`.

A Scene will only run its step if it is active.


longname: Phaser.Scenes.Events.READY
since: 3.0.0
name: READY
memberof: Phaser.Scenes.Events
metafilename: READY_EVENT.js
metapath: scene/events
description:
The Scene Systems Ready Event.

This event is dispatched by a Scene during the Scene Systems start process.
By this point in the process the Scene is now fully active and rendering.
This event is meant for your game code to use, as all plugins have responded to the earlier 'start' event.

Listen to it from a Scene using `this.events.on('ready', listener)`.


longname: Phaser.Scenes.Events.REMOVED_FROM_SCENE
since: 3.50.0
name: REMOVED_FROM_SCENE
memberof: Phaser.Scenes.Events
metafilename: REMOVED_FROM_SCENE_EVENT.js
metapath: scene/events
description:
The Game Object Removed from Scene Event.

This event is dispatched when a Game Object is removed from a Scene.

Listen for it from a Scene using `this.events.on('removedfromscene', listener)`.


longname: Phaser.Scenes.Events.RENDER
since: 3.0.0
name: RENDER
memberof: Phaser.Scenes.Events
metafilename: RENDER_EVENT.js
metapath: scene/events
description:
The Scene Systems Render Event.

This event is dispatched by a Scene during the main game loop step.

The event flow for a single step of a Scene is as follows:

1. [``PRE_UPDATE``](Phaser.Scenes.Events#event:PRE_UPDATE)
2. [``UPDATE``](Phaser.Scenes.Events#event:UPDATE)
3. The `Scene.update` method is called, if it exists
4. [``POST_UPDATE``](Phaser.Scenes.Events#event:POST_UPDATE)
5. [``PRE_RENDER``](Phaser.Scenes.Events#event:PRE_RENDER)
6. [``RENDER``](Phaser.Scenes.Events#event:RENDER)

Listen to it from a Scene using `this.events.on('render', listener)`.

A Scene will only render if it is visible.

By the time this event is dispatched, the Scene will have already been rendered.


longname: Phaser.Scenes.Events.RESUME
since: 3.0.0
name: RESUME
memberof: Phaser.Scenes.Events
metafilename: RESUME_EVENT.js
metapath: scene/events
description:
The Scene Systems Resume Event.

This event is dispatched by a Scene when it is resumed from a paused state, either directly via the `resume` method,
or as an action from another Scene.

Listen to it from a Scene using `this.events.on('resume', listener)`.


longname: Phaser.Scenes.Events.SHUTDOWN
since: 3.0.0
name: SHUTDOWN
memberof: Phaser.Scenes.Events
metafilename: SHUTDOWN_EVENT.js
metapath: scene/events
description:
The Scene Systems Shutdown Event.

This event is dispatched by a Scene during the Scene Systems shutdown process.

Listen to it from a Scene using `this.events.on('shutdown', listener)`.

You should free-up any resources that may be in use by your Scene in this event handler, on the understanding
that the Scene may, at any time, become active again. A shutdown Scene is not 'destroyed', it's simply not
currently active. Use the [``DESTROY``](Phaser.Scenes.Events#event:DESTROY) event to completely clear resources.


longname: Phaser.Scenes.Events.SLEEP
since: 3.0.0
name: SLEEP
memberof: Phaser.Scenes.Events
metafilename: SLEEP_EVENT.js
metapath: scene/events
description:
The Scene Systems Sleep Event.

This event is dispatched by a Scene when it is sent to sleep, either directly via the `sleep` method,
or as an action from another Scene.

Listen to it from a Scene using `this.events.on('sleep', listener)`.


longname: Phaser.Scenes.Events.START
since: 3.0.0
name: START
memberof: Phaser.Scenes.Events
metafilename: START_EVENT.js
metapath: scene/events
description:
The Scene Systems Start Event.

This event is dispatched by a Scene during the Scene Systems start process. Primarily used by Scene Plugins.

Listen to it from a Scene using `this.events.on('start', listener)`.


longname: Phaser.Scenes.Events.TRANSITION_COMPLETE
since: 3.5.0
name: TRANSITION_COMPLETE
memberof: Phaser.Scenes.Events
metafilename: TRANSITION_COMPLETE_EVENT.js
metapath: scene/events
description:
The Scene Transition Complete Event.

This event is dispatched by the Target Scene of a transition.

It happens when the transition process has completed. This occurs when the duration timer equals or exceeds the duration
of the transition.

Listen to it from a Scene using `this.events.on('transitioncomplete', listener)`.

The Scene Transition event flow is as follows:

1. [``TRANSITION_OUT``](Phaser.Scenes.Events#event:TRANSITION_OUT) - the Scene that started the transition will emit this event.
2. [``TRANSITION_INIT``](Phaser.Scenes.Events#event:TRANSITION_INIT) - the Target Scene will emit this event if it has an `init` method.
3. [``TRANSITION_START``](Phaser.Scenes.Events#event:TRANSITION_START) - the Target Scene will emit this event after its `create` method is called, OR ...
4. [``TRANSITION_WAKE``](Phaser.Scenes.Events#event:TRANSITION_WAKE) - the Target Scene will emit this event if it was asleep and has been woken-up to be transitioned to.
5. [``TRANSITION_COMPLETE``](Phaser.Scenes.Events#event:TRANSITION_COMPLETE) - the Target Scene will emit this event when the transition finishes.


longname: Phaser.Scenes.Events.TRANSITION_INIT
since: 3.5.0
name: TRANSITION_INIT
memberof: Phaser.Scenes.Events
metafilename: TRANSITION_INIT_EVENT.js
metapath: scene/events
description:
The Scene Transition Init Event.

This event is dispatched by the Target Scene of a transition.

It happens immediately after the `Scene.init` method is called. If the Scene does not have an `init` method,
this event is not dispatched.

Listen to it from a Scene using `this.events.on('transitioninit', listener)`.

The Scene Transition event flow is as follows:

1. [``TRANSITION_OUT``](Phaser.Scenes.Events#event:TRANSITION_OUT) - the Scene that started the transition will emit this event.
2. [``TRANSITION_INIT``](Phaser.Scenes.Events#event:TRANSITION_INIT) - the Target Scene will emit this event if it has an `init` method.
3. [``TRANSITION_START``](Phaser.Scenes.Events#event:TRANSITION_START) - the Target Scene will emit this event after its `create` method is called, OR ...
4. [``TRANSITION_WAKE``](Phaser.Scenes.Events#event:TRANSITION_WAKE) - the Target Scene will emit this event if it was asleep and has been woken-up to be transitioned to.
5. [``TRANSITION_COMPLETE``](Phaser.Scenes.Events#event:TRANSITION_COMPLETE) - the Target Scene will emit this event when the transition finishes.


longname: Phaser.Scenes.Events.TRANSITION_OUT
since: 3.5.0
name: TRANSITION_OUT
memberof: Phaser.Scenes.Events
metafilename: TRANSITION_OUT_EVENT.js
metapath: scene/events
description:
The Scene Transition Out Event.

This event is dispatched by a Scene when it initiates a transition to another Scene.

Listen to it from a Scene using `this.events.on('transitionout', listener)`.

The Scene Transition event flow is as follows:

1. [``TRANSITION_OUT``](Phaser.Scenes.Events#event:TRANSITION_OUT) - the Scene that started the transition will emit this event.
2. [``TRANSITION_INIT``](Phaser.Scenes.Events#event:TRANSITION_INIT) - the Target Scene will emit this event if it has an `init` method.
3. [``TRANSITION_START``](Phaser.Scenes.Events#event:TRANSITION_START) - the Target Scene will emit this event after its `create` method is called, OR ...
4. [``TRANSITION_WAKE``](Phaser.Scenes.Events#event:TRANSITION_WAKE) - the Target Scene will emit this event if it was asleep and has been woken-up to be transitioned to.
5. [``TRANSITION_COMPLETE``](Phaser.Scenes.Events#event:TRANSITION_COMPLETE) - the Target Scene will emit this event when the transition finishes.


longname: Phaser.Scenes.Events.TRANSITION_START
since: 3.5.0
name: TRANSITION_START
memberof: Phaser.Scenes.Events
metafilename: TRANSITION_START_EVENT.js
metapath: scene/events
description:
The Scene Transition Start Event.

This event is dispatched by the Target Scene of a transition, only if that Scene was not asleep.

It happens immediately after the `Scene.create` method is called. If the Scene does not have a `create` method,
this event is dispatched anyway.

If the Target Scene was sleeping then the [``TRANSITION_WAKE``](Phaser.Scenes.Events#event:TRANSITION_WAKE) event is
dispatched instead of this event.

Listen to it from a Scene using `this.events.on('transitionstart', listener)`.

The Scene Transition event flow is as follows:

1. [``TRANSITION_OUT``](Phaser.Scenes.Events#event:TRANSITION_OUT) - the Scene that started the transition will emit this event.
2. [``TRANSITION_INIT``](Phaser.Scenes.Events#event:TRANSITION_INIT) - the Target Scene will emit this event if it has an `init` method.
3. [``TRANSITION_START``](Phaser.Scenes.Events#event:TRANSITION_START) - the Target Scene will emit this event after its `create` method is called, OR ...
4. [``TRANSITION_WAKE``](Phaser.Scenes.Events#event:TRANSITION_WAKE) - the Target Scene will emit this event if it was asleep and has been woken-up to be transitioned to.
5. [``TRANSITION_COMPLETE``](Phaser.Scenes.Events#event:TRANSITION_COMPLETE) - the Target Scene will emit this event when the transition finishes.


longname: Phaser.Scenes.Events.TRANSITION_WAKE
since: 3.5.0
name: TRANSITION_WAKE
memberof: Phaser.Scenes.Events
metafilename: TRANSITION_WAKE_EVENT.js
metapath: scene/events
description:
The Scene Transition Wake Event.

This event is dispatched by the Target Scene of a transition, only if that Scene was asleep before
the transition began. If the Scene was not asleep the [``TRANSITION_START``](Phaser.Scenes.Events#event:TRANSITION_START) event is dispatched instead.

Listen to it from a Scene using `this.events.on('transitionwake', listener)`.

The Scene Transition event flow is as follows:

1. [``TRANSITION_OUT``](Phaser.Scenes.Events#event:TRANSITION_OUT) - the Scene that started the transition will emit this event.
2. [``TRANSITION_INIT``](Phaser.Scenes.Events#event:TRANSITION_INIT) - the Target Scene will emit this event if it has an `init` method.
3. [``TRANSITION_START``](Phaser.Scenes.Events#event:TRANSITION_START) - the Target Scene will emit this event after its `create` method is called, OR ...
4. [``TRANSITION_WAKE``](Phaser.Scenes.Events#event:TRANSITION_WAKE) - the Target Scene will emit this event if it was asleep and has been woken-up to be transitioned to.
5. [``TRANSITION_COMPLETE``](Phaser.Scenes.Events#event:TRANSITION_COMPLETE) - the Target Scene will emit this event when the transition finishes.


longname: Phaser.Scenes.Events.UPDATE
since: 3.0.0
name: UPDATE
memberof: Phaser.Scenes.Events
metafilename: UPDATE_EVENT.js
metapath: scene/events
description:
The Scene Systems Update Event.

This event is dispatched by a Scene during the main game loop step.

The event flow for a single step of a Scene is as follows:

1. [``PRE_UPDATE``](Phaser.Scenes.Events#event:PRE_UPDATE)
2. [``UPDATE``](Phaser.Scenes.Events#event:UPDATE)
3. The `Scene.update` method is called, if it exists
4. [``POST_UPDATE``](Phaser.Scenes.Events#event:POST_UPDATE)
5. [``PRE_RENDER``](Phaser.Scenes.Events#event:PRE_RENDER)
6. [``RENDER``](Phaser.Scenes.Events#event:RENDER)

Listen to it from a Scene using `this.events.on('update', listener)`.

A Scene will only run its step if it is active.


longname: Phaser.Scenes.Events.WAKE
since: 3.0.0
name: WAKE
memberof: Phaser.Scenes.Events
metafilename: WAKE_EVENT.js
metapath: scene/events
description:
The Scene Systems Wake Event.

This event is dispatched by a Scene when it is woken from sleep, either directly via the `wake` method,
or as an action from another Scene.

Listen to it from a Scene using `this.events.on('wake', listener)`.


longname: Phaser.Sound.Events.COMPLETE
since: 3.16.1
name: COMPLETE
memberof: Phaser.Sound.Events
metafilename: COMPLETE_EVENT.js
metapath: sound/events
description:
The Sound Complete Event.

This event is dispatched by both Web Audio and HTML5 Audio Sound objects when they complete playback.

Listen to it from a Sound instance using `Sound.on('complete', listener)`, i.e.:

```javascript
var music = this.sound.add('key');
music.on('complete', listener);
music.play();
```


longname: Phaser.Sound.Events.DECODED_ALL
since: 3.18.0
name: DECODED_ALL
memberof: Phaser.Sound.Events
metafilename: DECODED_ALL_EVENT.js
metapath: sound/events
description:
The Audio Data Decoded All Event.

This event is dispatched by the Web Audio Sound Manager as a result of calling the `decodeAudio` method,
once all files passed to the method have been decoded (or errored).

Use `Phaser.Sound.Events#DECODED` to listen for single sounds being decoded, and `DECODED_ALL` to
listen for them all completing.

Listen to it from the Sound Manager in a Scene using `this.sound.on('decodedall', listener)`, i.e.:

```javascript
this.sound.once('decodedall', handler);
this.sound.decodeAudio([ audioFiles ]);
```


longname: Phaser.Sound.Events.DECODED
since: 3.18.0
name: DECODED
memberof: Phaser.Sound.Events
metafilename: DECODED_EVENT.js
metapath: sound/events
description:
The Audio Data Decoded Event.

This event is dispatched by the Web Audio Sound Manager as a result of calling the `decodeAudio` method.

Listen to it from the Sound Manager in a Scene using `this.sound.on('decoded', listener)`, i.e.:

```javascript
this.sound.on('decoded', handler);
this.sound.decodeAudio(key, audioData);
```


longname: Phaser.Sound.Events.DESTROY
since: 3.0.0
name: DESTROY
memberof: Phaser.Sound.Events
metafilename: DESTROY_EVENT.js
metapath: sound/events
description:
The Sound Destroy Event.

This event is dispatched by both Web Audio and HTML5 Audio Sound objects when they are destroyed, either
directly or via a Sound Manager.

Listen to it from a Sound instance using `Sound.on('destroy', listener)`, i.e.:

```javascript
var music = this.sound.add('key');
music.on('destroy', listener);
music.destroy();
```


longname: Phaser.Sound.Events.DETUNE
since: 3.0.0
name: DETUNE
memberof: Phaser.Sound.Events
metafilename: DETUNE_EVENT.js
metapath: sound/events
description:
The Sound Detune Event.

This event is dispatched by both Web Audio and HTML5 Audio Sound objects when their detune value changes.

Listen to it from a Sound instance using `Sound.on('detune', listener)`, i.e.:

```javascript
var music = this.sound.add('key');
music.on('detune', listener);
music.play();
music.setDetune(200);
```


longname: Phaser.Sound.Events.GLOBAL_DETUNE
since: 3.0.0
name: GLOBAL_DETUNE
memberof: Phaser.Sound.Events
metafilename: GLOBAL_DETUNE_EVENT.js
metapath: sound/events
description:
The Sound Manager Global Detune Event.

This event is dispatched by the Base Sound Manager, or more typically, an instance of the Web Audio Sound Manager,
or the HTML5 Audio Manager. It is dispatched when the `detune` property of the Sound Manager is changed, which globally
adjusts the detuning of all active sounds.

Listen to it from a Scene using: `this.sound.on('rate', listener)`.


longname: Phaser.Sound.Events.GLOBAL_MUTE
since: 3.0.0
name: GLOBAL_MUTE
memberof: Phaser.Sound.Events
metafilename: GLOBAL_MUTE_EVENT.js
metapath: sound/events
description:
The Sound Manager Global Mute Event.

This event is dispatched by the Sound Manager when its `mute` property is changed, either directly
or via the `setMute` method. This changes the mute state of all active sounds.

Listen to it from a Scene using: `this.sound.on('mute', listener)`.


longname: Phaser.Sound.Events.GLOBAL_RATE
since: 3.0.0
name: GLOBAL_RATE
memberof: Phaser.Sound.Events
metafilename: GLOBAL_RATE_EVENT.js
metapath: sound/events
description:
The Sound Manager Global Rate Event.

This event is dispatched by the Base Sound Manager, or more typically, an instance of the Web Audio Sound Manager,
or the HTML5 Audio Manager. It is dispatched when the `rate` property of the Sound Manager is changed, which globally
adjusts the playback rate of all active sounds.

Listen to it from a Scene using: `this.sound.on('rate', listener)`.


longname: Phaser.Sound.Events.GLOBAL_VOLUME
since: 3.0.0
name: GLOBAL_VOLUME
memberof: Phaser.Sound.Events
metafilename: GLOBAL_VOLUME_EVENT.js
metapath: sound/events
description:
The Sound Manager Global Volume Event.

This event is dispatched by the Sound Manager when its `volume` property is changed, either directly
or via the `setVolume` method. This changes the volume of all active sounds.

Listen to it from a Scene using: `this.sound.on('volume', listener)`.


longname: Phaser.Sound.Events.LOOPED
since: 3.0.0
name: LOOPED
memberof: Phaser.Sound.Events
metafilename: LOOPED_EVENT.js
metapath: sound/events
description:
The Sound Looped Event.

This event is dispatched by both Web Audio and HTML5 Audio Sound objects when they loop during playback.

Listen to it from a Sound instance using `Sound.on('looped', listener)`, i.e.:

```javascript
var music = this.sound.add('key');
music.on('looped', listener);
music.setLoop(true);
music.play();
```

This is not to be confused with the [``LOOP``](Phaser.Sound.Events#event:LOOP) event, which only emits when the loop state of a Sound is changed.


longname: Phaser.Sound.Events.LOOP
since: 3.0.0
name: LOOP
memberof: Phaser.Sound.Events
metafilename: LOOP_EVENT.js
metapath: sound/events
description:
The Sound Loop Event.

This event is dispatched by both Web Audio and HTML5 Audio Sound objects when their loop state is changed.

Listen to it from a Sound instance using `Sound.on('loop', listener)`, i.e.:

```javascript
var music = this.sound.add('key');
music.on('loop', listener);
music.setLoop(true);
```

This is not to be confused with the [``LOOPED``](Phaser.Sound.Events#event:LOOPED) event, which emits each time a Sound loops during playback.


longname: Phaser.Sound.Events.MUTE
since: 3.0.0
name: MUTE
memberof: Phaser.Sound.Events
metafilename: MUTE_EVENT.js
metapath: sound/events
description:
The Sound Mute Event.

This event is dispatched by both Web Audio and HTML5 Audio Sound objects when their mute state changes.

Listen to it from a Sound instance using `Sound.on('mute', listener)`, i.e.:

```javascript
var music = this.sound.add('key');
music.on('mute', listener);
music.play();
music.setMute(true);
```


longname: Phaser.Sound.Events.PAN
since: 3.50.0
name: PAN
memberof: Phaser.Sound.Events
metafilename: PAN_EVENT.js
metapath: sound/events
description:
The Sound Pan Event.

This event is dispatched by both Web Audio and HTML5 Audio Sound objects when their pan changes.

Listen to it from a Sound instance using `Sound.on('pan', listener)`, i.e.:

```javascript
var sound = this.sound.add('key');
sound.on('pan', listener);
sound.play();
sound.setPan(0.5);
```


longname: Phaser.Sound.Events.PAUSE_ALL
since: 3.0.0
name: PAUSE_ALL
memberof: Phaser.Sound.Events
metafilename: PAUSE_ALL_EVENT.js
metapath: sound/events
description:
The Pause All Sounds Event.

This event is dispatched by the Base Sound Manager, or more typically, an instance of the Web Audio Sound Manager,
or the HTML5 Audio Manager. It is dispatched when the `pauseAll` method is invoked and after all current Sounds
have been paused.

Listen to it from a Scene using: `this.sound.on('pauseall', listener)`.


longname: Phaser.Sound.Events.PAUSE
since: 3.0.0
name: PAUSE
memberof: Phaser.Sound.Events
metafilename: PAUSE_EVENT.js
metapath: sound/events
description:
The Sound Pause Event.

This event is dispatched by both Web Audio and HTML5 Audio Sound objects when they are paused.

Listen to it from a Sound instance using `Sound.on('pause', listener)`, i.e.:

```javascript
var music = this.sound.add('key');
music.on('pause', listener);
music.play();
music.pause();
```


longname: Phaser.Sound.Events.PLAY
since: 3.0.0
name: PLAY
memberof: Phaser.Sound.Events
metafilename: PLAY_EVENT.js
metapath: sound/events
description:
The Sound Play Event.

This event is dispatched by both Web Audio and HTML5 Audio Sound objects when they are played.

Listen to it from a Sound instance using `Sound.on('play', listener)`, i.e.:

```javascript
var music = this.sound.add('key');
music.on('play', listener);
music.play();
```


longname: Phaser.Sound.Events.RATE
since: 3.0.0
name: RATE
memberof: Phaser.Sound.Events
metafilename: RATE_EVENT.js
metapath: sound/events
description:
The Sound Rate Change Event.

This event is dispatched by both Web Audio and HTML5 Audio Sound objects when their rate changes.

Listen to it from a Sound instance using `Sound.on('rate', listener)`, i.e.:

```javascript
var music = this.sound.add('key');
music.on('rate', listener);
music.play();
music.setRate(0.5);
```


longname: Phaser.Sound.Events.RESUME_ALL
since: 3.0.0
name: RESUME_ALL
memberof: Phaser.Sound.Events
metafilename: RESUME_ALL_EVENT.js
metapath: sound/events
description:
The Resume All Sounds Event.

This event is dispatched by the Base Sound Manager, or more typically, an instance of the Web Audio Sound Manager,
or the HTML5 Audio Manager. It is dispatched when the `resumeAll` method is invoked and after all current Sounds
have been resumed.

Listen to it from a Scene using: `this.sound.on('resumeall', listener)`.


longname: Phaser.Sound.Events.RESUME
since: 3.0.0
name: RESUME
memberof: Phaser.Sound.Events
metafilename: RESUME_EVENT.js
metapath: sound/events
description:
The Sound Resume Event.

This event is dispatched by both Web Audio and HTML5 Audio Sound objects when they are resumed from a paused state.

Listen to it from a Sound instance using `Sound.on('resume', listener)`, i.e.:

```javascript
var music = this.sound.add('key');
music.on('resume', listener);
music.play();
music.pause();
music.resume();
```


longname: Phaser.Sound.Events.SEEK
since: 3.0.0
name: SEEK
memberof: Phaser.Sound.Events
metafilename: SEEK_EVENT.js
metapath: sound/events
description:
The Sound Seek Event.

This event is dispatched by both Web Audio and HTML5 Audio Sound objects when they are seeked to a new position.

Listen to it from a Sound instance using `Sound.on('seek', listener)`, i.e.:

```javascript
var music = this.sound.add('key');
music.on('seek', listener);
music.play();
music.setSeek(5000);
```


longname: Phaser.Sound.Events.STOP_ALL
since: 3.0.0
name: STOP_ALL
memberof: Phaser.Sound.Events
metafilename: STOP_ALL_EVENT.js
metapath: sound/events
description:
The Stop All Sounds Event.

This event is dispatched by the Base Sound Manager, or more typically, an instance of the Web Audio Sound Manager,
or the HTML5 Audio Manager. It is dispatched when the `stopAll` method is invoked and after all current Sounds
have been stopped.

Listen to it from a Scene using: `this.sound.on('stopall', listener)`.


longname: Phaser.Sound.Events.STOP
since: 3.0.0
name: STOP
memberof: Phaser.Sound.Events
metafilename: STOP_EVENT.js
metapath: sound/events
description:
The Sound Stop Event.

This event is dispatched by both Web Audio and HTML5 Audio Sound objects when they are stopped.

Listen to it from a Sound instance using `Sound.on('stop', listener)`, i.e.:

```javascript
var music = this.sound.add('key');
music.on('stop', listener);
music.play();
music.stop();
```


longname: Phaser.Sound.Events.UNLOCKED
since: 3.0.0
name: UNLOCKED
memberof: Phaser.Sound.Events
metafilename: UNLOCKED_EVENT.js
metapath: sound/events
description:
The Sound Manager Unlocked Event.

This event is dispatched by the Base Sound Manager, or more typically, an instance of the Web Audio Sound Manager,
or the HTML5 Audio Manager. It is dispatched during the update loop when the Sound Manager becomes unlocked. For
Web Audio this is on the first user gesture on the page.

Listen to it from a Scene using: `this.sound.on('unlocked', listener)`.


longname: Phaser.Sound.Events.VOLUME
since: 3.0.0
name: VOLUME
memberof: Phaser.Sound.Events
metafilename: VOLUME_EVENT.js
metapath: sound/events
description:
The Sound Volume Event.

This event is dispatched by both Web Audio and HTML5 Audio Sound objects when their volume changes.

Listen to it from a Sound instance using `Sound.on('volume', listener)`, i.e.:

```javascript
var music = this.sound.add('key');
music.on('volume', listener);
music.play();
music.setVolume(0.5);
```


longname: Phaser.Structs.Events.PROCESS_QUEUE_ADD
since: 3.20.0
name: PROCESS_QUEUE_ADD
memberof: Phaser.Structs.Events
metafilename: PROCESS_QUEUE_ADD_EVENT.js
metapath: structs/events
description:
The Process Queue Add Event.

This event is dispatched by a Process Queue when a new item is successfully moved to its active list.

You will most commonly see this used by a Scene's Update List when a new Game Object has been added.

In that instance, listen to this event from within a Scene using: `this.sys.updateList.on('add', listener)`.


longname: Phaser.Structs.Events.PROCESS_QUEUE_REMOVE
since: 3.20.0
name: PROCESS_QUEUE_REMOVE
memberof: Phaser.Structs.Events
metafilename: PROCESS_QUEUE_REMOVE_EVENT.js
metapath: structs/events
description:
The Process Queue Remove Event.

This event is dispatched by a Process Queue when a new item is successfully removed from its active list.

You will most commonly see this used by a Scene's Update List when a Game Object has been removed.

In that instance, listen to this event from within a Scene using: `this.sys.updateList.on('remove', listener)`.


longname: Phaser.Textures.Events.ADD
since: 3.0.0
name: ADD
memberof: Phaser.Textures.Events
metafilename: ADD_EVENT.js
metapath: textures/events
description:
The Texture Add Event.

This event is dispatched by the Texture Manager when a texture is added to it.

Listen to this event from within a Scene using: `this.textures.on('addtexture', listener)`.


longname: Phaser.Textures.Events.ERROR
since: 3.0.0
name: ERROR
memberof: Phaser.Textures.Events
metafilename: ERROR_EVENT.js
metapath: textures/events
description:
The Texture Load Error Event.

This event is dispatched by the Texture Manager when a texture it requested to load failed.
This only happens when base64 encoded textures fail. All other texture types are loaded via the Loader Plugin.

Listen to this event from within a Scene using: `this.textures.on('onerror', listener)`.


longname: Phaser.Textures.Events.LOAD
since: 3.0.0
name: LOAD
memberof: Phaser.Textures.Events
metafilename: LOAD_EVENT.js
metapath: textures/events
description:
The Texture Load Event.

This event is dispatched by the Texture Manager when a texture has finished loading on it.
This only happens for base64 encoded textures. All other texture types are loaded via the Loader Plugin.

Listen to this event from within a Scene using: `this.textures.on('onload', listener)`.

This event is dispatched after the [``ADD``](Phaser.Textures.Events#event:ADD) event.


longname: Phaser.Textures.Events.READY
since: 3.16.1
name: READY
memberof: Phaser.Textures.Events
metafilename: READY_EVENT.js
metapath: textures/events
description:
This internal event signifies that the Texture Manager is now ready and the Game can continue booting.

When a Phaser Game instance is booting for the first time, the Texture Manager has to wait on a couple of non-blocking
async events before it's fully ready to carry on. When those complete the Texture Manager emits this event via the Game
instance, which tells the Game to carry on booting.


longname: Phaser.Textures.Events.REMOVE
since: 3.0.0
name: REMOVE
memberof: Phaser.Textures.Events
metafilename: REMOVE_EVENT.js
metapath: textures/events
description:
The Texture Remove Event.

This event is dispatched by the Texture Manager when a texture is removed from it.

Listen to this event from within a Scene using: `this.textures.on('removetexture', listener)`.

If you have any Game Objects still using the removed texture, they will start throwing
errors the next time they try to render. Be sure to clear all use of the texture in this event handler.


longname: Phaser.Tweens.Events.TIMELINE_COMPLETE
since: 3.0.0
name: TIMELINE_COMPLETE
memberof: Phaser.Tweens.Events
metafilename: TIMELINE_COMPLETE_EVENT.js
metapath: tweens/events
description:
The Timeline Complete Event.

This event is dispatched by a Tween Timeline when it completes playback.

Listen to it from a Timeline instance using `Timeline.on('complete', listener)`, i.e.:

```javascript
var timeline = this.tweens.timeline({
    targets: image,
    ease: 'Power1',
    duration: 3000,
    tweens: [ { x: 600 }, { y: 500 }, { x: 100 }, { y: 100 } ]
});
timeline.on('complete', listener);
timeline.play();
```


longname: Phaser.Tweens.Events.TIMELINE_LOOP
since: 3.0.0
name: TIMELINE_LOOP
memberof: Phaser.Tweens.Events
metafilename: TIMELINE_LOOP_EVENT.js
metapath: tweens/events
description:
The Timeline Loop Event.

This event is dispatched by a Tween Timeline every time it loops.

Listen to it from a Timeline instance using `Timeline.on('loop', listener)`, i.e.:

```javascript
var timeline = this.tweens.timeline({
    targets: image,
    ease: 'Power1',
    duration: 3000,
    loop: 4,
    tweens: [ { x: 600 }, { y: 500 }, { x: 100 }, { y: 100 } ]
});
timeline.on('loop', listener);
timeline.play();
```


longname: Phaser.Tweens.Events.TIMELINE_PAUSE
since: 3.0.0
name: TIMELINE_PAUSE
memberof: Phaser.Tweens.Events
metafilename: TIMELINE_PAUSE_EVENT.js
metapath: tweens/events
description:
The Timeline Pause Event.

This event is dispatched by a Tween Timeline when it is paused.

Listen to it from a Timeline instance using `Timeline.on('pause', listener)`, i.e.:

```javascript
var timeline = this.tweens.timeline({
    targets: image,
    ease: 'Power1',
    duration: 3000,
    tweens: [ { x: 600 }, { y: 500 }, { x: 100 }, { y: 100 } ]
});
timeline.on('pause', listener);
// At some point later ...
timeline.pause();
```


longname: Phaser.Tweens.Events.TIMELINE_RESUME
since: 3.0.0
name: TIMELINE_RESUME
memberof: Phaser.Tweens.Events
metafilename: TIMELINE_RESUME_EVENT.js
metapath: tweens/events
description:
The Timeline Resume Event.

This event is dispatched by a Tween Timeline when it is resumed from a paused state.

Listen to it from a Timeline instance using `Timeline.on('resume', listener)`, i.e.:

```javascript
var timeline = this.tweens.timeline({
    targets: image,
    ease: 'Power1',
    duration: 3000,
    tweens: [ { x: 600 }, { y: 500 }, { x: 100 }, { y: 100 } ]
});
timeline.on('resume', listener);
// At some point later ...
timeline.resume();
```


longname: Phaser.Tweens.Events.TIMELINE_START
since: 3.0.0
name: TIMELINE_START
memberof: Phaser.Tweens.Events
metafilename: TIMELINE_START_EVENT.js
metapath: tweens/events
description:
The Timeline Start Event.

This event is dispatched by a Tween Timeline when it starts.

Listen to it from a Timeline instance using `Timeline.on('start', listener)`, i.e.:

```javascript
var timeline = this.tweens.timeline({
    targets: image,
    ease: 'Power1',
    duration: 3000,
    tweens: [ { x: 600 }, { y: 500 }, { x: 100 }, { y: 100 } ]
});
timeline.on('start', listener);
timeline.play();
```


longname: Phaser.Tweens.Events.TIMELINE_UPDATE
since: 3.0.0
name: TIMELINE_UPDATE
memberof: Phaser.Tweens.Events
metafilename: TIMELINE_UPDATE_EVENT.js
metapath: tweens/events
description:
The Timeline Update Event.

This event is dispatched by a Tween Timeline every time it updates, which can happen a lot of times per second,
so be careful about listening to this event unless you absolutely require it.

Listen to it from a Timeline instance using `Timeline.on('update', listener)`, i.e.:

```javascript
var timeline = this.tweens.timeline({
    targets: image,
    ease: 'Power1',
    duration: 3000,
    tweens: [ { x: 600 }, { y: 500 }, { x: 100 }, { y: 100 } ]
});
timeline.on('update', listener);
timeline.play();
```


longname: Phaser.Tweens.Events.TWEEN_ACTIVE
since: 3.19.0
name: TWEEN_ACTIVE
memberof: Phaser.Tweens.Events
metafilename: TWEEN_ACTIVE_EVENT.js
metapath: tweens/events
description:
The Tween Active Event.

This event is dispatched by a Tween when it becomes active within the Tween Manager.

An 'active' Tween is one that is now progressing, although it may not yet be updating
any target properties, due to settings such as `delay`. If you need an event for when
the Tween starts actually updating its first property, see `TWEEN_START`.

Listen to it from a Tween instance using `Tween.on('active', listener)`, i.e.:

```javascript
var tween = this.tweens.add({
    targets: image,
    x: 500,
    ease: 'Power1',
    duration: 3000
});
tween.on('active', listener);
```


longname: Phaser.Tweens.Events.TWEEN_COMPLETE
since: 3.19.0
name: TWEEN_COMPLETE
memberof: Phaser.Tweens.Events
metafilename: TWEEN_COMPLETE_EVENT.js
metapath: tweens/events
description:
The Tween Complete Event.

This event is dispatched by a Tween when it completes playback entirely, factoring in repeats and loops.

If the Tween has been set to loop or repeat infinitely, this event will not be dispatched
unless the `Tween.stop` method is called.

If a Tween has a `completeDelay` set, this event will fire after that delay expires.

Listen to it from a Tween instance using `Tween.on('complete', listener)`, i.e.:

```javascript
var tween = this.tweens.add({
    targets: image,
    x: 500,
    ease: 'Power1',
    duration: 3000
});
tween.on('complete', listener);
```


longname: Phaser.Tweens.Events.TWEEN_LOOP
since: 3.19.0
name: TWEEN_LOOP
memberof: Phaser.Tweens.Events
metafilename: TWEEN_LOOP_EVENT.js
metapath: tweens/events
description:
The Tween Loop Event.

This event is dispatched by a Tween when it loops.

This event will only be dispatched if the Tween has a loop count set.

If a Tween has a `loopDelay` set, this event will fire after that delay expires.

The difference between `loop` and `repeat` is that `repeat` is a property setting,
where-as `loop` applies to the entire Tween.

Listen to it from a Tween instance using `Tween.on('loop', listener)`, i.e.:

```javascript
var tween = this.tweens.add({
    targets: image,
    x: 500,
    ease: 'Power1',
    duration: 3000,
    loop: 6
});
tween.on('loop', listener);
```


longname: Phaser.Tweens.Events.TWEEN_REPEAT
since: 3.19.0
name: TWEEN_REPEAT
memberof: Phaser.Tweens.Events
metafilename: TWEEN_REPEAT_EVENT.js
metapath: tweens/events
description:
The Tween Repeat Event.

This event is dispatched by a Tween when one of the properties it is tweening repeats.

This event will only be dispatched if the Tween has a property with a repeat count set.

If a Tween has a `repeatDelay` set, this event will fire after that delay expires.

The difference between `loop` and `repeat` is that `repeat` is a property setting,
where-as `loop` applies to the entire Tween.

Listen to it from a Tween instance using `Tween.on('repeat', listener)`, i.e.:

```javascript
var tween = this.tweens.add({
    targets: image,
    x: 500,
    ease: 'Power1',
    duration: 3000,
    repeat: 4
});
tween.on('repeat', listener);
```


longname: Phaser.Tweens.Events.TWEEN_START
since: 3.19.0
name: TWEEN_START
memberof: Phaser.Tweens.Events
metafilename: TWEEN_START_EVENT.js
metapath: tweens/events
description:
The Tween Start Event.

This event is dispatched by a Tween when it starts tweening its first property.

A Tween will only emit this event once, as it can only start once.

If a Tween has a `delay` set, this event will fire after that delay expires.

Listen to it from a Tween instance using `Tween.on('start', listener)`, i.e.:

```javascript
var tween = this.tweens.add({
    targets: image,
    x: 500,
    ease: 'Power1',
    duration: 3000
});
tween.on('start', listener);
```


longname: Phaser.Tweens.Events.TWEEN_STOP
since: 3.24.0
name: TWEEN_STOP
memberof: Phaser.Tweens.Events
metafilename: TWEEN_STOP_EVENT.js
metapath: tweens/events
description:
The Tween Stop Event.

This event is dispatched by a Tween when it is stopped.

Listen to it from a Tween instance using `Tween.on('stop', listener)`, i.e.:

```javascript
var tween = this.tweens.add({
    targets: image,
    x: 500,
    ease: 'Power1',
    duration: 3000
});
tween.on('stop', listener);
```


longname: Phaser.Tweens.Events.TWEEN_UPDATE
since: 3.19.0
name: TWEEN_UPDATE
memberof: Phaser.Tweens.Events
metafilename: TWEEN_UPDATE_EVENT.js
metapath: tweens/events
description:
The Tween Update Event.

This event is dispatched by a Tween every time it updates _any_ of the properties it is tweening.

A Tween that is changing 3 properties of a target will emit this event 3 times per change, once per property.

**Note:** This is a very high frequency event and may be dispatched multiple times, every single frame.

Listen to it from a Tween instance using `Tween.on('update', listener)`, i.e.:

```javascript
var tween = this.tweens.add({
    targets: image,
    x: 500,
    ease: 'Power1',
    duration: 3000,
});
tween.on('update', listener);
```


longname: Phaser.Tweens.Events.TWEEN_YOYO
since: 3.19.0
name: TWEEN_YOYO
memberof: Phaser.Tweens.Events
metafilename: TWEEN_YOYO_EVENT.js
metapath: tweens/events
description:
The Tween Yoyo Event.

This event is dispatched by a Tween whenever a property it is tweening yoyos.

This event will only be dispatched if the Tween has a property with `yoyo` set.

If the Tween has a `hold` value, this event is dispatched when the hold expires.

This event is dispatched for every property, and for every target, that yoyos.
For example, if a Tween was updating 2 properties and had 10 targets, this event
would be dispatched 20 times (twice per target). So be careful how you use it!

Listen to it from a Tween instance using `Tween.on('yoyo', listener)`, i.e.:

```javascript
var tween = this.tweens.add({
    targets: image,
    x: 500,
    ease: 'Power1',
    duration: 3000,
    yoyo: true
});
tween.on('yoyo', listener);
```


