@azerion/phaser/docs/pixi-jsdoc.js

A fast, free and fun HTML5 Game Framework for Desktop and Mobile web browsers.

/**
* @namespace PIXI
*/
/**
* @fileoverview
* @author Richard Davey <rich@photonstorm.com>
* @sourcefile D:\tools\phaser\src\pixi\display\DisplayObject.js
* @sourceline 1
*/
/**
* @class PIXI.PIXI.DisplayObject
* @description The base class for all objects that are rendered. Contains properties for position, scaling,
rotation, masks and cache handling.

This is an abstract class and should not be used on its own, rather it should be extended.

It is used internally by the likes of PIXI.Sprite.
* @sourcefile D:\tools\phaser\src\pixi\display\DisplayObject.js
* @sourceline 7
*/
/**
* @description The coordinates, in pixels, of this DisplayObject, relative to its parent container.

The value of this property does not reflect any positioning happening further up the display list.
To obtain that value please see the `worldPosition` property.
* @member PIXI.PIXI.DisplayObject#position
* @type {PIXIPoint}
* @default 
* @sourcefile D:\tools\phaser\src\pixi\display\DisplayObject.js
* @sourceline 20
*/
/**
* @description The scale of this DisplayObject. A scale of 1:1 represents the DisplayObject
at its default size. A value of 0.5 would scale this DisplayObject by half, and so on.

The value of this property does not reflect any scaling happening further up the display list.
To obtain that value please see the `worldScale` property.
* @member PIXI.PIXI.DisplayObject#scale
* @type {PIXIPoint}
* @default 
* @sourcefile D:\tools\phaser\src\pixi\display\DisplayObject.js
* @sourceline 31
*/
/**
* @description The pivot point of this DisplayObject that it rotates around. The values are expressed
in pixel values.
* @member PIXI.PIXI.DisplayObject#pivot
* @type {PIXIPoint}
* @default 
* @sourcefile D:\tools\phaser\src\pixi\display\DisplayObject.js
* @sourceline 43
*/
/**
* @description The rotation of this DisplayObject. The value is given, and expressed, in radians, and is based on
a right-handed orientation.

The value of this property does not reflect any rotation happening further up the display list.
To obtain that value please see the `worldRotation` property.
* @member PIXI.PIXI.DisplayObject#rotation
* @type {Number}
* @default 
* @sourcefile D:\tools\phaser\src\pixi\display\DisplayObject.js
* @sourceline 51
*/
/**
* @description The alpha value of this DisplayObject. A value of 1 is fully opaque. A value of 0 is transparent.
Please note that an object with an alpha value of 0 is skipped during the render pass.

The value of this property does not reflect any alpha values set further up the display list.
To obtain that value please see the `worldAlpha` property.
* @member PIXI.PIXI.DisplayObject#alpha
* @type {Number}
* @default 
* @sourcefile D:\tools\phaser\src\pixi\display\DisplayObject.js
* @sourceline 63
*/
/**
* @description The visibility of this DisplayObject. A value of `false` makes the object invisible.
A value of `true` makes it visible. Please note that an object with a visible value of
`false` is skipped during the render pass. Equally a DisplayObject with visible false will
not render any of its children.

The value of this property does not reflect any visible values set further up the display list.
To obtain that value please see the `worldVisible` property.
* @member PIXI.PIXI.DisplayObject#visible
* @type {Boolean}
* @default 
* @sourcefile D:\tools\phaser\src\pixi\display\DisplayObject.js
* @sourceline 75
*/
/**
* @description This is the defined area that will pick up mouse / touch events. It is null by default.
Setting it is a neat way of optimising the hitTest function that the interactionManager will use (as it will not need to hit test all the children)
* @member PIXI.PIXI.DisplayObject#hitArea
* @type {(Rectangle|Circle|Ellipse|Polygon)}
* @sourcefile D:\tools\phaser\src\pixi\display\DisplayObject.js
* @sourceline 89
*/
/**
* @description Should this DisplayObject be rendered by the renderer? An object with a renderable value of
`false` is skipped during the render pass.
* @member PIXI.PIXI.DisplayObject#renderable
* @type {Boolean}
* @default 
* @sourcefile D:\tools\phaser\src\pixi\display\DisplayObject.js
* @sourceline 98
*/
/**
* @description The parent DisplayObjectContainer that this DisplayObject is a child of.
All DisplayObjects must belong to a parent in order to be rendered.
The root parent is the Stage object. This property is set automatically when the
DisplayObject is added to, or removed from, a DisplayObjectContainer.
* @member PIXI.PIXI.DisplayObject#parent
* @type {PIXIDisplayObjectContainer}
* @readonly 
* @default 
* @sourcefile D:\tools\phaser\src\pixi\display\DisplayObject.js
* @sourceline 107
*/
/**
* @description The multiplied alpha value of this DisplayObject. A value of 1 is fully opaque. A value of 0 is transparent.
This value is the calculated total, based on the alpha values of all parents of this DisplayObjects 
in the display list.

To obtain, and set, the local alpha value, see the `alpha` property.

Note: This property is only updated at the end of the `updateTransform` call, once per render. Until 
that happens this property will contain values based on the previous frame. Be mindful of this if
accessing this property outside of the normal game flow, i.e. from an asynchronous event callback.
* @member PIXI.PIXI.DisplayObject#worldAlpha
* @type {Number}
* @readonly 
* @sourcefile D:\tools\phaser\src\pixi\display\DisplayObject.js
* @sourceline 119
*/
/**
* @description The current transform of this DisplayObject.

This property contains the calculated total, based on the transforms of all parents of this 
DisplayObject in the display list.

Note: This property is only updated at the end of the `updateTransform` call, once per render. Until 
that happens this property will contain values based on the previous frame. Be mindful of this if
accessing this property outside of the normal game flow, i.e. from an asynchronous event callback.
* @member PIXI.PIXI.DisplayObject#worldTransform
* @type {PIXIMatrix}
* @readonly 
* @sourcefile D:\tools\phaser\src\pixi\display\DisplayObject.js
* @sourceline 135
*/
/**
* @description The coordinates, in pixels, of this DisplayObject within the world.

This property contains the calculated total, based on the positions of all parents of this 
DisplayObject in the display list.

Note: This property is only updated at the end of the `updateTransform` call, once per render. Until 
that happens this property will contain values based on the previous frame. Be mindful of this if
accessing this property outside of the normal game flow, i.e. from an asynchronous event callback.
* @member PIXI.PIXI.DisplayObject#worldPosition
* @type {PIXIPoint}
* @readonly 
* @sourcefile D:\tools\phaser\src\pixi\display\DisplayObject.js
* @sourceline 150
*/
/**
* @description The global scale of this DisplayObject.

This property contains the calculated total, based on the scales of all parents of this 
DisplayObject in the display list.

Note: This property is only updated at the end of the `updateTransform` call, once per render. Until 
that happens this property will contain values based on the previous frame. Be mindful of this if
accessing this property outside of the normal game flow, i.e. from an asynchronous event callback.
* @member PIXI.PIXI.DisplayObject#worldScale
* @type {PIXIPoint}
* @readonly 
* @sourcefile D:\tools\phaser\src\pixi\display\DisplayObject.js
* @sourceline 165
*/
/**
* @description The rotation, in radians, of this DisplayObject.

This property contains the calculated total, based on the rotations of all parents of this 
DisplayObject in the display list.

Note: This property is only updated at the end of the `updateTransform` call, once per render. Until 
that happens this property will contain values based on the previous frame. Be mindful of this if
accessing this property outside of the normal game flow, i.e. from an asynchronous event callback.
* @member PIXI.PIXI.DisplayObject#worldRotation
* @type {Number}
* @readonly 
* @sourcefile D:\tools\phaser\src\pixi\display\DisplayObject.js
* @sourceline 180
*/
/**
* @description The rectangular area used by filters when rendering a shader for this DisplayObject.
* @member PIXI.PIXI.DisplayObject#filterArea
* @type {Rectangle}
* @default 
* @sourcefile D:\tools\phaser\src\pixi\display\DisplayObject.js
* @sourceline 195
*/
/**
* @member PIXI.PIXI.DisplayObject#_sr - Cached rotation value.
* @type {Number}
* @access private
* @sourcefile D:\tools\phaser\src\pixi\display\DisplayObject.js
* @sourceline 204
*/
/**
* @member PIXI.PIXI.DisplayObject#_cr - Cached rotation value.
* @type {Number}
* @access private
* @sourcefile D:\tools\phaser\src\pixi\display\DisplayObject.js
* @sourceline 210
*/
/**
* @member PIXI.PIXI.DisplayObject#_bounds - The cached bounds of this object.
* @type {PIXIRectangle}
* @access private
* @sourcefile D:\tools\phaser\src\pixi\display\DisplayObject.js
* @sourceline 216
*/
/**
* @member PIXI.PIXI.DisplayObject#_currentBounds - The most recently calculated bounds of this object.
* @type {PIXIRectangle}
* @access private
* @sourcefile D:\tools\phaser\src\pixi\display\DisplayObject.js
* @sourceline 222
*/
/**
* @member PIXI.PIXI.DisplayObject#_mask - The cached mask of this object.
* @type {PIXIRectangle}
* @access private
* @sourcefile D:\tools\phaser\src\pixi\display\DisplayObject.js
* @sourceline 228
*/
/**
* @member PIXI.PIXI.DisplayObject#_cacheAsBitmap - Internal cache as bitmap flag.
* @type {Boolean}
* @access private
* @sourcefile D:\tools\phaser\src\pixi\display\DisplayObject.js
* @sourceline 234
*/
/**
* @member PIXI.PIXI.DisplayObject#_cacheIsDirty - Internal dirty cache flag.
* @type {Boolean}
* @access private
* @sourcefile D:\tools\phaser\src\pixi\display\DisplayObject.js
* @sourceline 240
*/
/**
* @description Destroy this DisplayObject.

Removes any cached sprites, sets renderable flag to false, and nulls filters, bounds and mask.

Also iteratively calls `destroy` on any children.
* @method PIXI.PIXI.DisplayObject#PIXI.DisplayObject#destroy
* @sourcefile D:\tools\phaser\src\pixi\display\DisplayObject.js
* @sourceline 252
*/
/**
* @description To be overridden by classes that require it.
* @method PIXI.PIXI.DisplayObject#PIXI.DisplayObject#preUpdate
* @sourcefile D:\tools\phaser\src\pixi\display\DisplayObject.js
* @sourceline 403
*/
/**
* @description Generates a RenderTexture based on this DisplayObject, which can they be used to texture other Sprites.
This can be useful if your DisplayObject is static, or complicated, and needs to be reused multiple times.

Please note that no garbage collection takes place on old textures. It is up to you to destroy old textures,
and references to them, so they don't linger in memory.
* @method PIXI.PIXI.DisplayObject#PIXI.DisplayObject#generateTexture
* @param {Number} [resolution=1] - - The resolution of the texture being generated.
* @param {Number} [scaleMode=PIXI.scaleModes.DEFAULT] - - See {{#crossLink "PIXI/scaleModes:property"}}PIXI.scaleModes{{/crossLink}} for possible values.
* @param {(PIXICanvasRenderer|PIXIWebGLRenderer)} renderer - - The renderer used to generate the texture.
* @return {PIXIRenderTexture} - A RenderTexture containing an image of this DisplayObject at the time it was invoked.
* @sourcefile D:\tools\phaser\src\pixi\display\DisplayObject.js
* @sourceline 412
*/
/**
* @description If this DisplayObject has a cached Sprite, this method generates and updates it.
* @method PIXI.PIXI.DisplayObject#PIXI.DisplayObject#updateCache
* @return {PIXIDisplayObject} - A reference to this DisplayObject.
* @sourcefile D:\tools\phaser\src\pixi\display\DisplayObject.js
* @sourceline 440
*/
/**
* @description Calculates the global position of this DisplayObject, based on the position given.
* @method PIXI.PIXI.DisplayObject#PIXI.DisplayObject#toGlobal
* @param {PIXIPoint} position - - The global position to calculate from.
* @return {PIXIPoint} - A point object representing the position of this DisplayObject based on the global position given.
* @sourcefile D:\tools\phaser\src\pixi\display\DisplayObject.js
* @sourceline 454
*/
/**
* @description Calculates the local position of this DisplayObject, relative to another point.
* @method PIXI.PIXI.DisplayObject#PIXI.DisplayObject#toLocal
* @param {PIXIPoint} position - - The world origin to calculate from.
* @param {PIXIDisplayObject} [from] - - An optional DisplayObject to calculate the global position from.
* @return {PIXIPoint} - A point object representing the position of this DisplayObject based on the global position given.
* @sourcefile D:\tools\phaser\src\pixi\display\DisplayObject.js
* @sourceline 469
*/
/**
* @description Internal method.
* @method PIXI.PIXI.DisplayObject#PIXI.DisplayObject#_renderCachedSprite
* @param {Object} renderSession - - The render session
* @access private
* @sourcefile D:\tools\phaser\src\pixi\display\DisplayObject.js
* @sourceline 490
*/
/**
* @description Internal method.
* @method PIXI.PIXI.DisplayObject#PIXI.DisplayObject#_generateCachedSprite
* @access private
* @sourcefile D:\tools\phaser\src\pixi\display\DisplayObject.js
* @sourceline 512
*/
/**
* @description Destroys a cached Sprite.
* @method PIXI.PIXI.DisplayObject#PIXI.DisplayObject#_destroyCachedSprite
* @access private
* @sourcefile D:\tools\phaser\src\pixi\display\DisplayObject.js
* @sourceline 560
*/
/**
* @description The horizontal position of the DisplayObject, in pixels, relative to its parent.
If you need the world position of the DisplayObject, use `DisplayObject.worldPosition` instead.
* @member PIXI.PIXI.DisplayObject#x - The horizontal position of the DisplayObject, in pixels, relative to its parent.
* @type {Number}
* @sourcefile D:\tools\phaser\src\pixi\display\DisplayObject.js
* @sourceline 586
*/
/**
* @description The vertical position of the DisplayObject, in pixels, relative to its parent.
If you need the world position of the DisplayObject, use `DisplayObject.worldPosition` instead.
* @member PIXI.PIXI.DisplayObject#y - The vertical position of the DisplayObject, in pixels, relative to its parent.
* @type {Number}
* @sourcefile D:\tools\phaser\src\pixi\display\DisplayObject.js
* @sourceline 608
*/
/**
* @description Indicates if this DisplayObject is visible, based on it, and all of its parents, `visible` property values.
* @member PIXI.PIXI.DisplayObject#worldVisible - Indicates if this DisplayObject is visible, based on it, and all of its parents, `visible` property values.
* @type {Boolean}
* @sourcefile D:\tools\phaser\src\pixi\display\DisplayObject.js
* @sourceline 630
*/
/**
* @description Sets a mask for this DisplayObject. A mask is an instance of a Graphics object.
When applied it limits the visible area of this DisplayObject to the shape of the mask.
Under a Canvas renderer it uses shape clipping. Under a WebGL renderer it uses a Stencil Buffer.
To remove a mask, set this property to `null`.
* @member PIXI.PIXI.DisplayObject#mask - The mask applied to this DisplayObject. Set to `null` to remove an existing mask.
* @type {PIXIGraphics}
* @sourcefile D:\tools\phaser\src\pixi\display\DisplayObject.js
* @sourceline 673
*/
/**
* @description Sets the filters for this DisplayObject. This is a WebGL only feature, and is ignored by the Canvas
Renderer. A filter is a shader applied to this DisplayObject. You can modify the placement of the filter
using `DisplayObject.filterArea`.

To remove filters, set this property to `null`.

Note: You cannot have a filter set, and a MULTIPLY Blend Mode active, at the same time. Setting a 
filter will reset this DisplayObjects blend mode to NORMAL.
* @member PIXI.PIXI.DisplayObject#filters - An Array of PIXI.AbstractFilter objects, or objects that extend them.
* @type {Array}
* @sourcefile D:\tools\phaser\src\pixi\display\DisplayObject.js
* @sourceline 708
*/
/**
* @description Sets if this DisplayObject should be cached as a bitmap.

When invoked it will take a snapshot of the DisplayObject, as it is at that moment, and store it 
in a RenderTexture. This is then used whenever this DisplayObject is rendered. It can provide a
performance benefit for complex, but static, DisplayObjects. I.e. those with lots of children.

Cached Bitmaps do not track their parents. If you update a property of this DisplayObject, it will not
re-generate the cached bitmap automatically. To do that you need to call `DisplayObject.updateCache`.

To remove a cached bitmap, set this property to `null`.
* @member PIXI.PIXI.DisplayObject#cacheAsBitmap - Cache this DisplayObject as a Bitmap. Set to `null` to remove an existing cached bitmap.
* @type {Boolean}
* @sourcefile D:\tools\phaser\src\pixi\display\DisplayObject.js
* @sourceline 761
*/
/**
* @fileoverview
* @author Mat Groves http://matgroves.com/ @Doormat23
* @sourcefile D:\tools\phaser\src\pixi\display\DisplayObjectContainer.js
* @sourceline 1
*/
/**
* @class PIXI.DisplayObjectContainer
* @description A DisplayObjectContainer represents a collection of display objects.
It is the base class of all display objects that act as a container for other objects.
* @augments DisplayObject
* @sourcefile D:\tools\phaser\src\pixi\display\DisplayObjectContainer.js
* @sourceline 5
*/
/**
* @description [read-only] The array of children of this container.
* @member PIXI.DisplayObjectContainer#children
* @type {Array<DisplayObject>}
* @readonly 
* @sourcefile D:\tools\phaser\src\pixi\display\DisplayObjectContainer.js
* @sourceline 17
*/
/**
* @description If `ignoreChildInput`  is `false` it will allow this objects _children_ to be considered as valid for Input events.

If this property is `true` then the children will _not_ be considered as valid for Input events.

Note that this property isn't recursive: only immediate children are influenced, it doesn't scan further down.
* @member PIXI.DisplayObjectContainer#ignoreChildInput
* @type {Boolean}
* @default 
* @sourcefile D:\tools\phaser\src\pixi\display\DisplayObjectContainer.js
* @sourceline 26
*/
/**
* @description Adds a child to the container.
* @method PIXI.DisplayObjectContainer#addChild
* @param {DisplayObject} child - The DisplayObject to add to the container
* @return {DisplayObject} The child that was added.
* @sourcefile D:\tools\phaser\src\pixi\display\DisplayObjectContainer.js
* @sourceline 42
*/
/**
* @description Adds a child to the container at a specified index. If the index is out of bounds an error will be thrown
* @method PIXI.DisplayObjectContainer#addChildAt
* @param {DisplayObject} child - The child to add
* @param {Number} index - The index to place the child in
* @return {DisplayObject} The child that was added.
* @sourcefile D:\tools\phaser\src\pixi\display\DisplayObjectContainer.js
* @sourceline 55
*/
/**
* @description Swaps the position of 2 Display Objects within this container.
* @method PIXI.DisplayObjectContainer#swapChildren
* @param {DisplayObject} child - 
* @param {DisplayObject} child2 - 
* @sourcefile D:\tools\phaser\src\pixi\display\DisplayObjectContainer.js
* @sourceline 85
*/
/**
* @description Returns the index position of a child DisplayObject instance
* @method PIXI.DisplayObjectContainer#getChildIndex
* @param {DisplayObject} child - The DisplayObject instance to identify
* @return {Number} The index position of the child display object to identify
* @sourcefile D:\tools\phaser\src\pixi\display\DisplayObjectContainer.js
* @sourceline 112
*/
/**
* @description Changes the position of an existing child in the display object container
* @method PIXI.DisplayObjectContainer#setChildIndex
* @param {DisplayObject} child - The child DisplayObject instance for which you want to change the index number
* @param {Number} index - The resulting index number for the child display object
* @sourcefile D:\tools\phaser\src\pixi\display\DisplayObjectContainer.js
* @sourceline 132
*/
/**
* @description Returns the child at the specified index
* @method PIXI.DisplayObjectContainer#getChildAt
* @param {Number} index - The index to get the child from
* @return {DisplayObject} The child at the given index, if any.
* @sourcefile D:\tools\phaser\src\pixi\display\DisplayObjectContainer.js
* @sourceline 153
*/
/**
* @description Removes a child from the container.
* @method PIXI.DisplayObjectContainer#removeChild
* @param {DisplayObject} child - The DisplayObject to remove
* @return {DisplayObject} The child that was removed.
* @sourcefile D:\tools\phaser\src\pixi\display\DisplayObjectContainer.js
* @sourceline 171
*/
/**
* @description Removes a child from the specified index position.
* @method PIXI.DisplayObjectContainer#removeChildAt
* @param {Number} index - The index to get the child from
* @return {DisplayObject} The child that was removed.
* @sourcefile D:\tools\phaser\src\pixi\display\DisplayObjectContainer.js
* @sourceline 191
*/
/**
* @description Removes all children from this container that are within the begin and end indexes.
* @method PIXI.DisplayObjectContainer#removeChildren
* @param {Number} beginIndex - The beginning position. Default value is 0.
* @param {Number} endIndex - The ending position. Default value is size of the container.
* @sourcefile D:\tools\phaser\src\pixi\display\DisplayObjectContainer.js
* @sourceline 213
*/
/**
* @description Retrieves the global bounds of the displayObjectContainer as a rectangle. The bounds calculation takes all visible children into consideration.
* @method PIXI.DisplayObjectContainer#getBounds
* @param {(PIXIDisplayObject|PIXIMatrix)} [targetCoordinateSpace] - Returns a rectangle that defines the area of the display object relative to the coordinate system of the targetCoordinateSpace object.
* @return {Rectangle} The rectangular bounding area
* @sourcefile D:\tools\phaser\src\pixi\display\DisplayObjectContainer.js
* @sourceline 280
*/
/**
* @description Retrieves the non-global local bounds of the displayObjectContainer as a rectangle without any transformations. The calculation takes all visible children into consideration.
* @method PIXI.DisplayObjectContainer#getLocalBounds
* @return {Rectangle} The rectangular bounding area
* @sourcefile D:\tools\phaser\src\pixi\display\DisplayObjectContainer.js
* @sourceline 437
*/
/**
* @description Determines whether the specified display object is a child of the DisplayObjectContainer instance or the instance itself.
* @method PIXI.DisplayObjectContainer#contains
* @param {DisplayObject} child - 
* @return {Boolean} 
* @sourcefile D:\tools\phaser\src\pixi\display\DisplayObjectContainer.js
* @sourceline 449
*/
/**
* @description Renders the object using the WebGL renderer
* @method PIXI.DisplayObjectContainer#_renderWebGL
* @param {RenderSession} renderSession - 
* @access private
* @sourcefile D:\tools\phaser\src\pixi\display\DisplayObjectContainer.js
* @sourceline 472
*/
/**
* @description Renders the object using the Canvas renderer
* @method PIXI.DisplayObjectContainer#_renderCanvas
* @param {RenderSession} renderSession - 
* @access private
* @sourcefile D:\tools\phaser\src\pixi\display\DisplayObjectContainer.js
* @sourceline 534
*/
/**
* @description The width of the displayObjectContainer, setting this will actually modify the scale to achieve the value set
* @member PIXI.DisplayObjectContainer#width
* @type {Number}
* @sourcefile D:\tools\phaser\src\pixi\display\DisplayObjectContainer.js
* @sourceline 571
*/
/**
* @description The height of the displayObjectContainer, setting this will actually modify the scale to achieve the value set
* @member PIXI.DisplayObjectContainer#height
* @type {Number}
* @sourcefile D:\tools\phaser\src\pixi\display\DisplayObjectContainer.js
* @sourceline 600
*/
/**
* @fileoverview
* @author Mat Groves http://matgroves.com/ @Doormat23
* @sourcefile D:\tools\phaser\src\pixi\display\Sprite.js
* @sourceline 1
*/
/**
* @class PIXI.Sprite
* @description The Sprite object is the base for all textured objects that are rendered to the screen
* @augments PIXI.DisplayObjectContainer
* @param {PIXI.Texture} texture - The texture for this sprite
* @sourcefile D:\tools\phaser\src\pixi\display\Sprite.js
* @sourceline 5
*/
/**
* @description The anchor sets the origin point of the texture.
The default is 0,0 this means the texture's origin is the top left
Setting than anchor to 0.5,0.5 means the textures origin is centered
Setting the anchor to 1,1 would mean the textures origin points will be the bottom right corner
* @member PIXI.Sprite#anchor
* @type {Point}
* @sourcefile D:\tools\phaser\src\pixi\display\Sprite.js
* @sourceline 17
*/
/**
* @description The texture that the sprite is using
* @member PIXI.Sprite#texture
* @type {PIXI.Texture}
* @sourcefile D:\tools\phaser\src\pixi\display\Sprite.js
* @sourceline 28
*/
/**
* @description The width of the sprite (this is initially set by the texture)
* @member PIXI.Sprite#_width
* @type {Number}
* @access private
* @sourcefile D:\tools\phaser\src\pixi\display\Sprite.js
* @sourceline 36
*/
/**
* @description The height of the sprite (this is initially set by the texture)
* @member PIXI.Sprite#_height
* @type {Number}
* @access private
* @sourcefile D:\tools\phaser\src\pixi\display\Sprite.js
* @sourceline 45
*/
/**
* @description The tint applied to the sprite. This is a hex value. A value of 0xFFFFFF will remove any tint effect.
* @member PIXI.Sprite#tint
* @type {Number}
* @default 0xFFFFFF
* @sourcefile D:\tools\phaser\src\pixi\display\Sprite.js
* @sourceline 54
*/
/**
* @description The tint applied to the sprite. This is a hex value. A value of 0xFFFFFF will remove any tint effect.
* @member PIXI.Sprite#cachedTint
* @type {Number}
* @default -1
* @access private
* @sourcefile D:\tools\phaser\src\pixi\display\Sprite.js
* @sourceline 63
*/
/**
* @description A canvas that contains the tinted version of the Sprite (in Canvas mode, WebGL doesn't populate this)
* @member PIXI.Sprite#tintedTexture
* @type {Canvas}
* @default null
* @sourcefile D:\tools\phaser\src\pixi\display\Sprite.js
* @sourceline 73
*/
/**
* @description The blend mode to be applied to the sprite. Set to PIXI.blendModes.NORMAL to remove any blend mode.

Warning: You cannot have a blend mode and a filter active on the same Sprite. Doing so will render the sprite invisible.
* @member PIXI.Sprite#blendMode
* @type {Number}
* @default PIXI.blendModes.NORMAL;
* @sourcefile D:\tools\phaser\src\pixi\display\Sprite.js
* @sourceline 82
*/
/**
* @description The shader that will be used to render this Sprite.
Set to null to remove a current shader.
* @member PIXI.Sprite#shader
* @type {PIXI.AbstractFilter}
* @default null
* @sourcefile D:\tools\phaser\src\pixi\display\Sprite.js
* @sourceline 93
*/
/**
* @description Controls if this Sprite is processed by the core Phaser game loops and Group loops.
* @member PIXI.Sprite#exists
* @type {Boolean}
* @default true
* @sourcefile D:\tools\phaser\src\pixi\display\Sprite.js
* @sourceline 103
*/
/**
* @description The width of the sprite, setting this will actually modify the scale to achieve the value set
* @member PIXI.Sprite#width
* @type {Number}
* @sourcefile D:\tools\phaser\src\pixi\display\Sprite.js
* @sourceline 125
*/
/**
* @description The height of the sprite, setting this will actually modify the scale to achieve the value set
* @member PIXI.Sprite#height
* @type {Number}
* @sourcefile D:\tools\phaser\src\pixi\display\Sprite.js
* @sourceline 144
*/
/**
* @description Sets the texture of the sprite. Be warned that this doesn't remove or destroy the previous
texture this Sprite was using.
* @method PIXI.Sprite#setTexture
* @param {PIXI.Texture} texture - The PIXI texture that is displayed by the sprite
* @param {Boolean} [destroy=false] - Call Texture.destroy on the current texture before replacing it with the new one?
* @sourcefile D:\tools\phaser\src\pixi\display\Sprite.js
* @sourceline 163
*/
/**
* @description When the texture is updated, this event will fire to update the scale and frame
* @method PIXI.Sprite#onTextureUpdate
* @param {} event - 
* @access private
* @sourcefile D:\tools\phaser\src\pixi\display\Sprite.js
* @sourceline 185
*/
/**
* @description Returns the bounds of the Sprite as a rectangle.
The bounds calculation takes the worldTransform into account.

It is important to note that the transform is not updated when you call this method.
So if this Sprite is the child of a Display Object which has had its transform
updated since the last render pass, those changes will not yet have been applied
to this Sprites worldTransform. If you need to ensure that all parent transforms
are factored into this getBounds operation then you should call `updateTransform`
on the root most object in this Sprites display list first.
* @method PIXI.Sprite#getBounds
* @param {Matrix} matrix - the transformation matrix of the sprite
* @return {Rectangle} the framing rectangle
* @sourcefile D:\tools\phaser\src\pixi\display\Sprite.js
* @sourceline 199
*/
/**
* @description Retrieves the non-global local bounds of the Sprite as a rectangle. The calculation takes all visible children into consideration.
* @method PIXI.Sprite#getLocalBounds
* @return {Rectangle} The rectangular bounding area
* @sourcefile D:\tools\phaser\src\pixi\display\Sprite.js
* @sourceline 315
*/
/**
* @description Renders the object using the WebGL renderer
* @method PIXI.Sprite#_renderWebGL
* @param {RenderSession} renderSession - 
* @param {Matrix} [matrix] - - Optional matrix. If provided the Display Object will be rendered using this matrix, otherwise it will use its worldTransform.
* @access private
* @sourcefile D:\tools\phaser\src\pixi\display\Sprite.js
* @sourceline 345
*/
/**
* @description Renders the object using the Canvas renderer
* @method PIXI.Sprite#_renderCanvas
* @param {RenderSession} renderSession - 
* @param {Matrix} [matrix] - - Optional matrix. If provided the Display Object will be rendered using this matrix, otherwise it will use its worldTransform.
* @access private
* @sourcefile D:\tools\phaser\src\pixi\display\Sprite.js
* @sourceline 415
*/
/**
* @fileoverview
* @author Mat Groves http://matgroves.com/
* @sourcefile D:\tools\phaser\src\pixi\display\SpriteBatch.js
* @sourceline 1
*/
/**
* @class PIXI.SpriteBatch
* @description The SpriteBatch class is a really fast version of the DisplayObjectContainer 
built solely for speed, so use when you need a lot of sprites or particles.
And it's extremely easy to use : 

   var container = new PIXI.SpriteBatch();

   for(var i  = 0; i < 100; i++)
   {
       var sprite = new PIXI.Sprite.fromImage("myImage.png");
       container.addChild(sprite);
   }
And here you have a hundred sprites that will be renderer at the speed of light
* @param {PIXI.Texture} texture - 
* @sourcefile D:\tools\phaser\src\pixi\display\SpriteBatch.js
* @sourceline 5
*/
/**
* @description Renders the object using the WebGL renderer
* @method PIXI.SpriteBatch#_renderWebGL
* @param {RenderSession} renderSession - 
* @access private
* @sourcefile D:\tools\phaser\src\pixi\display\SpriteBatch.js
* @sourceline 62
*/
/**
* @description Renders the object using the Canvas renderer
* @method PIXI.SpriteBatch#_renderCanvas
* @param {RenderSession} renderSession - 
* @access private
* @sourcefile D:\tools\phaser\src\pixi\display\SpriteBatch.js
* @sourceline 94
*/
/**
* @fileoverview
* @author Mat Groves http://matgroves.com/ @Doormat23
* @sourcefile D:\tools\phaser\src\pixi\extras\Rope.js
* @sourceline 1
*/
/**
* @class PIXI.Rope
* @augments PIXI.Strip
* @param {PIXI.Texture} texture - - The texture to use on the rope.
* @param {Array} points - - An array of {PIXI.Point}.
* @sourcefile D:\tools\phaser\src\pixi\extras\Rope.js
* @sourceline 6
*/
/**
* @fileoverview
* @author Mat Groves http://matgroves.com/
* @sourcefile D:\tools\phaser\src\pixi\extras\Strip.js
* @sourceline 1
*/
/**
* @class PIXI.Strip
* @augments PIXI.DisplayObjectContainer
* @param {PIXI.Texture} texture - The texture to use
* @param {Number} width - the width
* @param {Number} height - the height
* @sourcefile D:\tools\phaser\src\pixi\extras\Strip.js
* @sourceline 5
*/
/**
* @description The texture of the strip
* @member PIXI.Strip#texture
* @type {PIXI.Texture}
* @sourcefile D:\tools\phaser\src\pixi\extras\Strip.js
* @sourceline 20
*/
/**
* @description Whether the strip is dirty or not
* @member PIXI.Strip#dirty
* @type {Boolean}
* @sourcefile D:\tools\phaser\src\pixi\extras\Strip.js
* @sourceline 43
*/
/**
* @description The blend mode to be applied to the sprite. Set to PIXI.blendModes.NORMAL to remove any blend mode.
* @member PIXI.Strip#blendMode
* @type {Number}
* @default PIXI.blendModes.NORMAL;
* @sourcefile D:\tools\phaser\src\pixi\extras\Strip.js
* @sourceline 51
*/
/**
* @description Triangles in canvas mode are automatically antialiased, use this value to force triangles to overlap a bit with each other.
* @member PIXI.Strip#canvasPadding
* @type {Number}
* @sourcefile D:\tools\phaser\src\pixi\extras\Strip.js
* @sourceline 60
*/
/**
* @description Renders a flat strip
* @method PIXI.Strip#renderStripFlat
* @param {PIXI.Strip} strip - The Strip to render
* @access private
* @sourcefile D:\tools\phaser\src\pixi\extras\Strip.js
* @sourceline 344
*/
/**
* @description When the texture is updated, this event will fire to update the scale and frame
* @method PIXI.Strip#onTextureUpdate
* @param {} event - 
* @access private
* @sourcefile D:\tools\phaser\src\pixi\extras\Strip.js
* @sourceline 392
*/
/**
* @description Returns the bounds of the mesh as a rectangle. The bounds calculation takes the worldTransform into account.
* @method PIXI.Strip#getBounds
* @param {Matrix} matrix - the transformation matrix of the sprite
* @return {Rectangle} the framing rectangle
* @sourcefile D:\tools\phaser\src\pixi\extras\Strip.js
* @sourceline 405
*/
/**
* @description Different drawing buffer modes supported
* @member PIXI.Strip.
* @type {{TRIANGLE_STRIP: number, TRIANGLES: number}}
* @sourcefile D:\tools\phaser\src\pixi\extras\Strip.js
* @sourceline 462
*/
/**
* @fileoverview
* @author Mat Groves http://matgroves.com/
* @sourcefile D:\tools\phaser\src\pixi\extras\TilingSprite.js
* @sourceline 1
*/
/**
* @class PIXI.TilingSprite
* @description A tiling sprite is a fast way of rendering a tiling image
* @augments PIXI.Sprite
* @param {PIXI.Texture} texture - the texture of the tiling sprite
* @param {Number} width - the width of the tiling sprite
* @param {Number} height - the height of the tiling sprite
* @sourcefile D:\tools\phaser\src\pixi\extras\TilingSprite.js
* @sourceline 5
*/
/**
* @description The width of the tiling sprite
* @member PIXI.TilingSprite#width
* @type {Number}
* @sourcefile D:\tools\phaser\src\pixi\extras\TilingSprite.js
* @sourceline 19
*/
/**
* @description The height of the tiling sprite
* @member PIXI.TilingSprite#height
* @type {Number}
* @sourcefile D:\tools\phaser\src\pixi\extras\TilingSprite.js
* @sourceline 27
*/
/**
* @description The scaling of the image that is being tiled
* @member PIXI.TilingSprite#tileScale
* @type {Point}
* @sourcefile D:\tools\phaser\src\pixi\extras\TilingSprite.js
* @sourceline 35
*/
/**
* @description A point that represents the scale of the texture object
* @member PIXI.TilingSprite#tileScaleOffset
* @type {Point}
* @sourcefile D:\tools\phaser\src\pixi\extras\TilingSprite.js
* @sourceline 43
*/
/**
* @description The offset position of the image that is being tiled
* @member PIXI.TilingSprite#tilePosition
* @type {Point}
* @sourcefile D:\tools\phaser\src\pixi\extras\TilingSprite.js
* @sourceline 51
*/
/**
* @description Whether this sprite is renderable or not
* @member PIXI.TilingSprite#renderable
* @type {Boolean}
* @default true
* @sourcefile D:\tools\phaser\src\pixi\extras\TilingSprite.js
* @sourceline 59
*/
/**
* @description The tint applied to the sprite. This is a hex value
* @member PIXI.TilingSprite#tint
* @type {Number}
* @default 0xFFFFFF
* @sourcefile D:\tools\phaser\src\pixi\extras\TilingSprite.js
* @sourceline 68
*/
/**
* @description If enabled a green rectangle will be drawn behind the generated tiling texture, allowing you to visually
debug the texture being used.
* @member PIXI.TilingSprite#textureDebug
* @type {Boolean}
* @sourcefile D:\tools\phaser\src\pixi\extras\TilingSprite.js
* @sourceline 77
*/
/**
* @description The blend mode to be applied to the sprite
* @member PIXI.TilingSprite#blendMode
* @type {Number}
* @default PIXI.blendModes.NORMAL;
* @sourcefile D:\tools\phaser\src\pixi\extras\TilingSprite.js
* @sourceline 86
*/
/**
* @description The CanvasBuffer object that the tiled texture is drawn to.
* @member PIXI.TilingSprite#canvasBuffer
* @type {PIXICanvasBuffer}
* @sourcefile D:\tools\phaser\src\pixi\extras\TilingSprite.js
* @sourceline 95
*/
/**
* @description An internal Texture object that holds the tiling texture that was generated from TilingSprite.texture.
* @member PIXI.TilingSprite#tilingTexture
* @type {PIXITexture}
* @sourcefile D:\tools\phaser\src\pixi\extras\TilingSprite.js
* @sourceline 103
*/
/**
* @description The Context fill pattern that is used to draw the TilingSprite in Canvas mode only (will be null in WebGL).
* @member PIXI.TilingSprite#tilePattern
* @type {PIXITexture}
* @sourcefile D:\tools\phaser\src\pixi\extras\TilingSprite.js
* @sourceline 111
*/
/**
* @description If true the TilingSprite will run generateTexture on its **next** render pass.
This is set by the likes of Phaser.LoadTexture.setFrame.
* @member PIXI.TilingSprite#refreshTexture
* @type {Boolean}
* @default true
* @sourcefile D:\tools\phaser\src\pixi\extras\TilingSprite.js
* @sourceline 119
*/
/**
* @description Renders the object using the WebGL renderer
* @method PIXI.TilingSprite#_renderWebGL
* @param {RenderSession} renderSession - 
* @access private
* @sourcefile D:\tools\phaser\src\pixi\extras\TilingSprite.js
* @sourceline 148
*/
/**
* @description Renders the object using the Canvas renderer
* @method PIXI.TilingSprite#_renderCanvas
* @param {RenderSession} renderSession - 
* @access private
* @sourcefile D:\tools\phaser\src\pixi\extras\TilingSprite.js
* @sourceline 216
*/
/**
* @description When the texture is updated, this event will fire to update the scale and frame
* @method PIXI.TilingSprite#onTextureUpdate
* @param {} event - 
* @access private
* @sourcefile D:\tools\phaser\src\pixi\extras\TilingSprite.js
* @sourceline 320
*/
/**
* @method PIXI.TilingSprite#generateTilingTexture
* @param {Boolean} forcePowerOfTwo - Whether we want to force the texture to be a power of two
* @param {RenderSession} renderSession - 
* @sourcefile D:\tools\phaser\src\pixi\extras\TilingSprite.js
* @sourceline 332
*/
/**
* @description Returns the framing rectangle of the sprite as a PIXI.Rectangle object
* @method PIXI.TilingSprite#getBounds
* @return {Rectangle} the framing rectangle
* @sourcefile D:\tools\phaser\src\pixi\extras\TilingSprite.js
* @sourceline 417
*/
/**
* @description The width of the sprite, setting this will actually modify the scale to achieve the value set
* @member PIXI.TilingSprite#width
* @type {Number}
* @sourcefile D:\tools\phaser\src\pixi\extras\TilingSprite.js
* @sourceline 517
*/
/**
* @description The height of the TilingSprite, setting this will actually modify the scale to achieve the value set
* @member PIXI.TilingSprite#height
* @type {Number}
* @sourcefile D:\tools\phaser\src\pixi\extras\TilingSprite.js
* @sourceline 535
*/
/**
* @fileoverview
* @author Mat Groves http://matgroves.com/ @Doormat23
* @sourcefile D:\tools\phaser\src\pixi\filters\AbstractFilter.js
* @sourceline 1
*/
/**
* @class PIXI.AbstractFilter
* @description This is the base class for creating a PIXI filter. Currently only webGL supports filters.
If you want to make a custom filter this should be your base class.
* @param {Array} fragmentSrc - The fragment source in an array of strings.
* @param {Object} uniforms - An object containing the uniforms for this filter.
* @sourcefile D:\tools\phaser\src\pixi\filters\AbstractFilter.js
* @sourceline 5
*/
/**
* @description An array of passes - some filters contain a few steps this array simply stores the steps in a liniear fashion.
For example the blur filter has two passes blurX and blurY.
* @member PIXI.AbstractFilter#passes
* @type {Array}
* @access private
* @sourcefile D:\tools\phaser\src\pixi\filters\AbstractFilter.js
* @sourceline 16
*/
/**
* @member PIXI.AbstractFilter#shaders
* @type {Array}
* @access private
* @sourcefile D:\tools\phaser\src\pixi\filters\AbstractFilter.js
* @sourceline 25
*/
/**
* @member PIXI.AbstractFilter#dirty
* @type {Boolean}
* @sourcefile D:\tools\phaser\src\pixi\filters\AbstractFilter.js
* @sourceline 32
*/
/**
* @member PIXI.AbstractFilter#padding
* @type {Number}
* @sourcefile D:\tools\phaser\src\pixi\filters\AbstractFilter.js
* @sourceline 38
*/
/**
* @member PIXI.AbstractFilter#uniforms
* @type {Object}
* @access private
* @sourcefile D:\tools\phaser\src\pixi\filters\AbstractFilter.js
* @sourceline 44
*/
/**
* @member PIXI.AbstractFilter#fragmentSrc
* @type {Array}
* @access private
* @sourcefile D:\tools\phaser\src\pixi\filters\AbstractFilter.js
* @sourceline 51
*/
/**
* @description Syncs the uniforms between the class object and the shaders.
* @method PIXI.AbstractFilter#syncUniforms
* @sourcefile D:\tools\phaser\src\pixi\filters\AbstractFilter.js
* @sourceline 61
*/
/**
* @fileoverview
* @author Mat Groves http://matgroves.com/ @Doormat23
* @sourcefile D:\tools\phaser\src\pixi\primitives\Graphics.js
* @sourceline 1
*/
/**
* @class PIXI.Graphics
* @description The Graphics class contains methods used to draw primitive shapes such as lines, circles and rectangles to the display, and color and fill them.
* @augments PIXI.DisplayObjectContainer
* @sourcefile D:\tools\phaser\src\pixi\primitives\Graphics.js
* @sourceline 5
*/
/**
* @description The alpha value used when filling the Graphics object.
* @member PIXI.Graphics#fillAlpha
* @type {Number}
* @sourcefile D:\tools\phaser\src\pixi\primitives\Graphics.js
* @sourceline 18
*/
/**
* @description The width (thickness) of any lines drawn.
* @member PIXI.Graphics#lineWidth
* @type {Number}
* @sourcefile D:\tools\phaser\src\pixi\primitives\Graphics.js
* @sourceline 26
*/
/**
* @description The color of any lines drawn.
* @member PIXI.Graphics#lineColor
* @type {String}
* @default 0
* @sourcefile D:\tools\phaser\src\pixi\primitives\Graphics.js
* @sourceline 34
*/
/**
* @description Graphics data
* @member PIXI.Graphics#graphicsData
* @type {Array}
* @access private
* @sourcefile D:\tools\phaser\src\pixi\primitives\Graphics.js
* @sourceline 43
*/
/**
* @description The tint applied to the graphic shape. This is a hex value. Apply a value of 0xFFFFFF to reset the tint.
* @member PIXI.Graphics#tint
* @type {Number}
* @default 0xFFFFFF
* @sourcefile D:\tools\phaser\src\pixi\primitives\Graphics.js
* @sourceline 52
*/
/**
* @description The blend mode to be applied to the graphic shape. Apply a value of PIXI.blendModes.NORMAL to reset the blend mode.
* @member PIXI.Graphics#blendMode
* @type {Number}
* @default PIXI.blendModes.NORMAL;
* @sourcefile D:\tools\phaser\src\pixi\primitives\Graphics.js
* @sourceline 61
*/
/**
* @description Current path
* @member PIXI.Graphics#currentPath
* @type {Object}
* @access private
* @sourcefile D:\tools\phaser\src\pixi\primitives\Graphics.js
* @sourceline 70
*/
/**
* @description Array containing some WebGL-related properties used by the WebGL renderer.
* @member PIXI.Graphics#_webGL
* @type {Array}
* @access private
* @sourcefile D:\tools\phaser\src\pixi\primitives\Graphics.js
* @sourceline 79
*/
/**
* @description Whether this shape is being used as a mask.
* @member PIXI.Graphics#isMask
* @type {Boolean}
* @sourcefile D:\tools\phaser\src\pixi\primitives\Graphics.js
* @sourceline 88
*/
/**
* @description The bounds' padding used for bounds calculation.
* @member PIXI.Graphics#boundsPadding
* @type {Number}
* @sourcefile D:\tools\phaser\src\pixi\primitives\Graphics.js
* @sourceline 96
*/
/**
* @description Used to detect if the graphics object has changed. If this is set to true then the graphics object will be recalculated.
* @member PIXI.Graphics#dirty
* @type {Boolean}
* @access private
* @sourcefile D:\tools\phaser\src\pixi\primitives\Graphics.js
* @sourceline 106
*/
/**
* @description Used to detect if the bounds have been invalidated, by this Graphics being cleared or drawn to.
If this is set to true then the updateLocalBounds is called once in the postUpdate method.
* @member PIXI.Graphics#_boundsDirty
* @type {Boolean}
* @access private
* @sourcefile D:\tools\phaser\src\pixi\primitives\Graphics.js
* @sourceline 115
*/
/**
* @description Used to detect if the webgl graphics object has changed. If this is set to true then the graphics object will be recalculated.
* @member PIXI.Graphics#webGLDirty
* @type {Boolean}
* @access private
* @sourcefile D:\tools\phaser\src\pixi\primitives\Graphics.js
* @sourceline 125
*/
/**
* @description Used to detect if the cached sprite object needs to be updated.
* @member PIXI.Graphics#cachedSpriteDirty
* @type {Boolean}
* @access private
* @sourcefile D:\tools\phaser\src\pixi\primitives\Graphics.js
* @sourceline 134
*/
/**
* @description Specifies the line style used for subsequent calls to Graphics methods such as the lineTo() method or the drawCircle() method.
* @method PIXI.Graphics#lineStyle
* @param {Number} lineWidth - width of the line to draw, will update the objects stored style
* @param {Number} color - color of the line to draw, will update the objects stored style
* @param {Number} alpha - alpha of the line to draw, will update the objects stored style
* @return {PIXI.Graphics} 
* @sourcefile D:\tools\phaser\src\pixi\primitives\Graphics.js
* @sourceline 149
*/
/**
* @description Moves the current drawing position to x, y.
* @method PIXI.Graphics#moveTo
* @param {Number} x - the X coordinate to move to
* @param {Number} y - the Y coordinate to move to
* @return {PIXI.Graphics} 
* @sourcefile D:\tools\phaser\src\pixi\primitives\Graphics.js
* @sourceline 183
*/
/**
* @description Draws a line using the current line style from the current drawing position to (x, y);
The current drawing position is then set to (x, y).
* @method PIXI.Graphics#lineTo
* @param {Number} x - the X coordinate to draw to
* @param {Number} y - the Y coordinate to draw to
* @return {PIXI.Graphics} 
* @sourcefile D:\tools\phaser\src\pixi\primitives\Graphics.js
* @sourceline 198
*/
/**
* @description Calculate the points for a quadratic bezier curve and then draws it.
Based on: https://stackoverflow.com/questions/785097/how-do-i-implement-a-bezier-curve-in-c
* @method PIXI.Graphics#quadraticCurveTo
* @param {Number} cpX - Control point x
* @param {Number} cpY - Control point y
* @param {Number} toX - Destination point x
* @param {Number} toY - Destination point y
* @return {PIXI.Graphics} 
* @sourcefile D:\tools\phaser\src\pixi\primitives\Graphics.js
* @sourceline 221
*/
/**
* @description Calculate the points for a bezier curve and then draws it.
* @method PIXI.Graphics#bezierCurveTo
* @param {Number} cpX - Control point x
* @param {Number} cpY - Control point y
* @param {Number} cpX2 - Second Control point x
* @param {Number} cpY2 - Second Control point y
* @param {Number} toX - Destination point x
* @param {Number} toY - Destination point y
* @return {PIXI.Graphics} 
* @sourcefile D:\tools\phaser\src\pixi\primitives\Graphics.js
* @sourceline 276
*/
/**
* @description The arc method creates an arc/curve (used to create circles, or parts of circles).
* @method PIXI.Graphics#arc
* @param {Number} cx - The x-coordinate of the center of the circle
* @param {Number} cy - The y-coordinate of the center of the circle
* @param {Number} radius - The radius of the circle
* @param {Number} startAngle - The starting angle, in radians (0 is at the 3 o'clock position of the arc's circle)
* @param {Number} endAngle - The ending angle, in radians
* @param {Boolean} anticlockwise - Optional. Specifies whether the drawing should be counterclockwise or clockwise. False is default, and indicates clockwise, while true indicates counter-clockwise.
* @param {Number} segments - Optional. The number of segments to use when calculating the arc. The default is 40. If you need more fidelity use a higher number.
* @return {PIXI.Graphics} 
* @sourcefile D:\tools\phaser\src\pixi\primitives\Graphics.js
* @sourceline 405
*/
/**
* @description Specifies a simple one-color fill that subsequent calls to other Graphics methods
(such as lineTo() or drawCircle()) use when drawing.
* @method PIXI.Graphics#beginFill
* @param {Number} color - the color of the fill
* @param {Number} alpha - the alpha of the fill
* @return {PIXI.Graphics} 
* @sourcefile D:\tools\phaser\src\pixi\primitives\Graphics.js
* @sourceline 491
*/
/**
* @description Applies a fill to the lines and shapes that were added since the last call to the beginFill()