Phaser API Documentation

  Version: 
Filter

A Dynamic Texture is a special texture that allows you to draw textures, frames and most kind of Game Objects directly to it.

You can take many complex objects and draw them to this one texture, which can then be used as the base texture for other Game Objects, such as Sprites. Should you then update this texture, all Game Objects using it will instantly be updated as well, reflecting the changes immediately.

It's a powerful way to generate dynamic textures at run-time that are WebGL friendly and don't invoke expensive GPU uploads on each change.

const t = this.textures.addDynamicTexture('player', 64, 128);
// draw objects to t
this.add.sprite(x, y, 'player');

Because this is a standard Texture within Phaser, you can add frames to it, meaning you can use it to generate sprite sheets, texture atlases or tile sets.

Under WebGL1, a FrameBuffer, which is what this Dynamic Texture uses internally, cannot be anti-aliased. This means that when drawing objects such as Shapes or Graphics instances to this texture, they may appear to be drawn with no aliasing around the edges. This is a technical limitation of WebGL1. To get around it, create your shape as a texture in an art package, then draw that to this texture.

Based on the assumption that you will be using this Dynamic Texture as a source for Sprites, it will automatically invert any drawing done to it on the y axis. If you do not require this, please call the setIsSpriteTexture() method and pass it false as its parameter. Do this before you start drawing to this texture, otherwise you will get vertically inverted frames under WebGL. This isn't required for Canvas.

Constructor:

new DynamicTexture(manager, key, [width], [height])

Parameters:

name type arguments Default description
manager Phaser.Textures.TextureManager

A reference to the Texture Manager this Texture belongs to.

key string

The unique string-based key of this Texture.

width number <optional> 256

The width of this Dymamic Texture in pixels. Defaults to 256 x 256.

height number <optional> 256

The height of this Dymamic Texture in pixels. Defaults to 256 x 256.

Since: 3.60.0

Extends


Members

<private> _eraseMode: boolean
Focus
Focus

Description:

Internal erase mode flag.

Type:
boolean
Since: 3.16.0
Focus
Focus

Description:

An internal Camera that can be used to move around this Dynamic Texture.

Control it just like you would any Scene Camera. The difference is that it only impacts the placement of Game Objects (not textures) that you then draw to this texture.

You can scroll, zoom and rotate this Camera.

Type:
Since: 3.12.0
Focus
Focus
canvas: HTMLCanvasElement
Focus
Focus

Description:

A reference to the Rendering Context belonging to the Canvas Element this Dynamic Texture is drawing to.

Type:
HTMLCanvasElement
Since: 3.2.0
Focus
Focus
<readonly> context: CanvasRenderingContext2D
Focus
Focus

Description:

The 2D Canvas Rendering Context.

Type:
CanvasRenderingContext2D
Since: 3.7.0
Focus
Focus
customData: object
Focus
Focus

Description:

Any additional data that was set in the source JSON (if any), or any extra data you'd like to store relating to this texture

Type:
object
Inherited from: Phaser.Textures.Texture#customData
Since: 3.0.0
Source: src/textures/Texture.js (Line 97)
Focus
Focus
dataSource: array
Focus
Focus

Description:

An array of TextureSource data instances. Used to store additional data images, such as normal maps or specular maps.

Type:
array
Inherited from: Phaser.Textures.Texture#dataSource
Since: 3.0.0
Source: src/textures/Texture.js (Line 78)
Focus
Focus
dirty: boolean
Focus
Focus

Description:

Is this Dynamic Texture dirty or not? If not it won't spend time clearing or filling itself.

Type:
boolean
Since: 3.12.0
Focus
Focus
firstFrame: string
Focus
Focus

Description:

The name of the first frame of the Texture.

Type:
string
Inherited from: Phaser.Textures.Texture#firstFrame
Since: 3.0.0
Source: src/textures/Texture.js (Line 107)
Focus
Focus
frameTotal: number
Focus
Focus

Description:

The total number of Frames in this Texture, including the __BASE frame.

A Texture will always contain at least 1 frame because every Texture contains a __BASE frame by default, in addition to any extra frames that have been added to it, such as when parsing a Sprite Sheet or Texture Atlas.

Type:
number
Default: 0
Inherited from: Phaser.Textures.Texture#frameTotal
Since: 3.0.0
Source: src/textures/Texture.js (Line 116)
Focus
Focus
frames: object
Focus
Focus

Description:

A key-value object pair associating the unique Frame keys with the Frames objects.

Type:
object
Inherited from: Phaser.Textures.Texture#frames
Since: 3.0.0
Source: src/textures/Texture.js (Line 88)
Focus
Focus
height: number
Focus
Focus

Description:

The height of this Dynamic Texture.

Treat this property as read-only. Use the setSize method to change the size.

Type:
number
Since: 3.60.0
Focus
Focus
<readonly> isDrawing: boolean
Focus
Focus

Description:

This flag is set to 'true' during beginDraw and reset to 'falseinendDraw`, allowing you to determine if this Dynamic Texture is batch drawing, or not.

Type:
boolean
Since: 3.60.0
Focus
Focus
isSpriteTexture: boolean
Focus
Focus

Description:

Is this Dynamic Texture being used as the base texture for a Sprite Game Object?

This is enabled by default, as we expect that will be the core use for Dynamic Textures.

However, to disable it, call RenderTexture.setIsSpriteTexture(false).

You should do this before drawing to this texture, so that it correctly inverses the frames for WebGL rendering. Not doing so will result in vertically flipped frames.

This property is used in the endDraw method.

Type:
boolean
Since: 3.60.0
Focus
Focus
key: string
Focus
Focus

Description:

The unique string-based key of this Texture.

Type:
string
Inherited from: Phaser.Textures.Texture#key
Since: 3.0.0
Source: src/textures/Texture.js (Line 59)
Focus
Focus

Description:

A reference to the Texture Manager this Texture belongs to.

Type:
Inherited from: Phaser.Textures.Texture#manager
Since: 3.0.0
Source: src/textures/Texture.js (Line 50)
Focus
Focus

Description:

A reference to the WebGL Single Pipeline.

This property remains null under Canvas.

Type:
Since: 3.60.0
Focus
Focus

Description:

The Render Target that belongs to this Dynamic Texture.

A Render Target encapsulates a framebuffer and texture for the WebGL Renderer.

This property remains null under Canvas.

Type:
Since: 3.60.0
Focus
Focus

Description:

A reference to either the Canvas or WebGL Renderer that the Game instance is using.

Type:
Since: 3.2.0
Focus
Focus

Description:

An array of TextureSource instances. These are unique to this Texture and contain the actual Image (or Canvas) data.

Type:
Inherited from: Phaser.Textures.Texture#source
Since: 3.0.0
Source: src/textures/Texture.js (Line 68)
Focus
Focus
<readonly> type: string
Focus
Focus

Description:

The internal data type of this object.

Type:
string
Since: 3.60.0
Focus
Focus
width: number
Focus
Focus

Description:

The width of this Dynamic Texture.

Treat this property as read-only. Use the setSize method to change the size.

Type:
number
Since: 3.60.0
Focus
Focus

Methods

add(name, sourceIndex, x, y, width, height)
Focus
Focus

Description:

Adds a new Frame to this Texture.

A Frame is a rectangular region of a TextureSource with a unique index or string-based key.

The name given must be unique within this Texture. If it already exists, this method will return null.

Parameters:

name type description
name number | string

The name of this Frame. The name is unique within the Texture.

sourceIndex number

The index of the TextureSource that this Frame is a part of.

x number

The x coordinate of the top-left of this Frame.

y number

The y coordinate of the top-left of this Frame.

width number

The width of this Frame.

height number

The height of this Frame.

Returns:
Description:

The Frame that was added to this Texture, or null if the given name already exists.

Inherited from: Phaser.Textures.Texture#add
Since: 3.0.0
Source: src/textures/Texture.js (Line 136)
Focus
Focus
batchDraw(entries, [x], [y], [alpha], [tint])
Focus
Focus

Description:

Use this method if you have already called beginDraw and need to batch draw a large number of objects to this Dynamic Texture.

This method batches the drawing of the given objects to this texture, without causing a WebGL bind or batch flush for each one.

It is faster than calling draw, but you must be careful to manage the flow of code and remember to call endDraw(). If you don't need to draw large numbers of objects it's much safer and easier to use the draw method instead.

The flow should be:

// Call once:
DynamicTexture.beginDraw();

// repeat n times:
DynamicTexture.batchDraw();
// or
DynamicTexture.batchDrawFrame();

// Call once:
DynamicTexture.endDraw();

Do not call any methods other than batchDraw, batchDrawFrame, or endDraw once you have started a batch. Also, be very careful not to destroy this Dynamic Texture while the batch is still open. Doing so will cause a run-time error in the WebGL Renderer.

You can use the DynamicTexture.isDrawing boolean property to tell if a batch is currently open, or not.

This method can accept any of the following:

  • Any renderable Game Object, such as a Sprite, Text, Graphics or TileSprite.
  • Tilemap Layers.
  • A Group. The contents of which will be iterated and drawn in turn.
  • A Container. The contents of which will be iterated fully, and drawn in turn.
  • A Scene's Display List. Pass in Scene.children to draw the whole list.
  • Another Dynamic Texture or Render Texture.
  • A Texture Frame instance.
  • A string. This is used to look-up a texture from the Texture Manager.

Note: You cannot draw a Dynamic Texture to itself.

If passing in a Group or Container it will only draw children that return true when their willRender() method is called. I.e. a Container with 10 children, 5 of which have visible=false will only draw the 5 visible ones.

If passing in an array of Game Objects it will draw them all, regardless if they pass a willRender check or not.

You can pass in a string in which case it will look for a texture in the Texture Manager matching that string, and draw the base frame. If you need to specify exactly which frame to draw then use the method drawFrame instead.

You can pass in the x and y coordinates to draw the objects at. The use of the coordinates differ based on what objects are being drawn. If the object is a Group, Container or Display List, the coordinates are added to the positions of the children. For all other types of object, the coordinates are exact.

The alpha and tint values are only used by Texture Frames. Game Objects use their own alpha and tint values when being drawn.

Parameters:

name type arguments Default description
entries any

Any renderable Game Object, or Group, Container, Display List, other Dynamic or Texture, Texture Frame or an array of any of these.

x number <optional> 0

The x position to draw the Frame at, or the offset applied to the object.

y number <optional> 0

The y position to draw the Frame at, or the offset applied to the object.

alpha number <optional> 1

The alpha value. Only used when drawing Texture Frames to this texture. Game Objects use their own alpha.

tint number <optional> 0xffffff

The tint color value. Only used when drawing Texture Frames to this texture. Game Objects use their own tint. WebGL only.

Returns:
Description:

This Dynamic Texture instance.

Since: 3.50.0
Focus
Focus
batchDrawFrame(key, [frame], [x], [y], [alpha], [tint])
Focus
Focus

Description:

Use this method if you have already called beginDraw and need to batch draw a large number of texture frames to this Dynamic Texture.

This method batches the drawing of the given frames to this Dynamic Texture, without causing a WebGL bind or batch flush for each one.

It is faster than calling drawFrame, but you must be careful to manage the flow of code and remember to call endDraw(). If you don't need to draw large numbers of frames it's much safer and easier to use the drawFrame method instead.

The flow should be:

// Call once:
DynamicTexture.beginDraw();

// repeat n times:
DynamicTexture.batchDraw();
// or
DynamicTexture.batchDrawFrame();

// Call once:
DynamicTexture.endDraw();

Do not call any methods other than batchDraw, batchDrawFrame, or endDraw once you have started a batch. Also, be very careful not to destroy this Dynamic Texture while the batch is still open. Doing so will cause a run-time error in the WebGL Renderer.

You can use the DynamicTexture.isDrawing boolean property to tell if a batch is currently open, or not.

Textures are referenced by their string-based keys, as stored in the Texture Manager.

You can optionally provide a position, alpha and tint value to apply to the frame before it is drawn.

Parameters:

name type arguments Default description
key string

The key of the texture to be used, as stored in the Texture Manager.

frame string | number <optional>

The name or index of the frame within the Texture.

x number <optional> 0

The x position to draw the frame at.

y number <optional> 0

The y position to draw the frame at.

alpha number <optional> 1

The alpha value. Only used when drawing Texture Frames to this texture. Game Objects use their own alpha.

tint number <optional> 0xffffff

The tint color value. Only used when drawing Texture Frames to this texture. Game Objects use their own tint. WebGL only.

Returns:
Description:

This Dynamic Texture instance.

Since: 3.50.0
Focus
Focus
<private> batchGameObject(gameObject, [x], [y])
Focus
Focus

Description:

Internal method that handles drawing a single Phaser Game Object to this Dynamic Texture.

Parameters:

name type arguments description
gameObject Phaser.GameObjects.GameObject

The Game Object to draw.

x number <optional>

The x position to draw the Game Object at.

y number <optional>

The y position to draw the Game Object at.

Since: 3.12.0
Focus
Focus
<private> batchGroup(children, [x], [y])
Focus
Focus

Description:

Internal method that handles drawing the contents of a Phaser Group to this Dynamic Texture.

Parameters:

name type arguments description
children array

The array of Game Objects to draw.

x number <optional>

The x position to offset the Game Objects by.

y number <optional>

The y position to offset the Game Objects by.

Since: 3.12.0
Focus
Focus
<private> batchList(children, [x], [y], [alpha], [tint])
Focus
Focus

Description:

Internal method that handles the drawing of an array of children.

Parameters:

name type arguments Default description
children array

The array of Game Objects, Textures or Frames to draw.

x number <optional> 0

The x position to offset the Game Object by.

y number <optional> 0

The y position to offset the Game Object by.

alpha number <optional> 1

The alpha value. Only used when drawing Texture Frames to this texture. Game Objects use their own alpha.

tint number <optional> 0xffffff

The tint color value. Only used when drawing Texture Frames to this texture. Game Objects use their own tint. WebGL only.

Since: 3.12.0
Focus
Focus
<private> batchTextureFrame(textureFrame, [x], [y], [alpha], [tint])
Focus
Focus

Description:

Internal method that handles the drawing of a Texture Frame to this Dynamic Texture.

Parameters:

name type arguments Default description
textureFrame Phaser.Textures.Frame

The Texture Frame to draw.

x number <optional> 0

The x position to draw the Frame at.

y number <optional> 0

The y position to draw the Frame at.

alpha number <optional> 1

The alpha value. Only used when drawing Texture Frames to this texture. Game Objects use their own alpha.

tint number <optional> 0xffffff

The tint color value. Only used when drawing Texture Frames to this texture. Game Objects use their own tint. WebGL only.

Since: 3.12.0
Focus
Focus
<private> batchTextureFrameKey(key, [frame], [x], [y], [alpha], [tint])
Focus
Focus

Description:

Internal method that handles the drawing a Texture Frame based on its key.

Parameters:

name type arguments Default description
key string

The key of the texture to be used, as stored in the Texture Manager.

frame string | number <optional>

The name or index of the frame within the Texture.

x number <optional> 0

The x position to offset the Game Object by.

y number <optional> 0

The y position to offset the Game Object by.

alpha number <optional> 1

The alpha value. Only used when drawing Texture Frames to this texture. Game Objects use their own alpha.

tint number <optional> 0xffffff

The tint color value. Only used when drawing Texture Frames to this texture. Game Objects use their own tint. WebGL only.

Since: 3.12.0
Focus
Focus
beginDraw()
Focus
Focus

Description:

Use this method if you need to batch draw a large number of Game Objects to this Dynamic Texture in a single pass, or on a frequent basis. This is especially useful under WebGL, however, if your game is using Canvas only, it will not make any speed difference in that situation.

This method starts the beginning of a batched draw, unless one is already open.

Batched drawing is faster than calling draw in loop, but you must be careful to manage the flow of code and remember to call endDraw() when you're finished.

If you don't need to draw large numbers of objects it's much safer and easier to use the draw method instead.

The flow should be:

// Call once:
DynamicTexture.beginDraw();

// repeat n times:
DynamicTexture.batchDraw();
// or
DynamicTexture.batchDrawFrame();

// Call once:
DynamicTexture.endDraw();

Do not call any methods other than batchDraw, batchDrawFrame, or endDraw once you have started a batch. Also, be very careful not to destroy this Dynamic Texture while the batch is still open. Doing so will cause a run-time error in the WebGL Renderer.

You can use the DynamicTexture.isDrawing boolean property to tell if a batch is currently open, or not.

Returns:
Description:

This Dynamic Texture instance.

Since: 3.50.0
Focus
Focus
clear([x], [y], [width], [height])
Focus
Focus

Description:

Clears a portion or everything from this Dynamic Texture by erasing it and resetting it back to a blank, transparent, texture. To clear an area, specify the x, y, width and height.

Parameters:

name type arguments Default description
x number <optional> 0

The left coordinate of the fill rectangle.

y number <optional> 0

The top coordinate of the fill rectangle.

width number <optional> this.width

The width of the fill rectangle.

height number <optional> this.height

The height of the fill rectangle.

Returns:
Description:

This Dynamic Texture instance.

Since: 3.2.0
Focus
Focus
destroy()
Focus
Focus

Description:

Destroys this Texture and releases references to its sources and frames.

Overrides: Phaser.Textures.Texture#destroy
Since: 3.60.0
Focus
Focus
draw(entries, [x], [y], [alpha], [tint])
Focus
Focus

Description:

Draws the given object, or an array of objects, to this Dynamic Texture.

It can accept any of the following:

  • Any renderable Game Object, such as a Sprite, Text, Graphics or TileSprite.
  • Tilemap Layers.
  • A Group. The contents of which will be iterated and drawn in turn.
  • A Container. The contents of which will be iterated fully, and drawn in turn.
  • A Scene Display List. Pass in Scene.children to draw the whole list.
  • Another Dynamic Texture, or a Render Texture.
  • A Texture Frame instance.
  • A string. This is used to look-up the texture from the Texture Manager.

Note 1: You cannot draw a Dynamic Texture to itself.

Note 2: For Game Objects that have Post FX Pipelines, the pipeline cannot be used when drawn to this texture.

If passing in a Group or Container it will only draw children that return true when their willRender() method is called. I.e. a Container with 10 children, 5 of which have visible=false will only draw the 5 visible ones.

If passing in an array of Game Objects it will draw them all, regardless if they pass a willRender check or not.

You can pass in a string in which case it will look for a texture in the Texture Manager matching that string, and draw the base frame. If you need to specify exactly which frame to draw then use the method drawFrame instead.

You can pass in the x and y coordinates to draw the objects at. The use of the coordinates differ based on what objects are being drawn. If the object is a Group, Container or Display List, the coordinates are added to the positions of the children. For all other types of object, the coordinates are exact.

The alpha and tint values are only used by Texture Frames. Game Objects use their own alpha and tint values when being drawn.

Calling this method causes the WebGL batch to flush, so it can write the texture data to the framebuffer being used internally. The batch is flushed at the end, after the entries have been iterated. So if you've a bunch of objects to draw, try and pass them in an array in one single call, rather than making lots of separate calls.

If you are not planning on using this Dynamic Texture as a base texture for Sprite Game Objects, then you should set DynamicTexture.isSpriteTexture = false before calling this method, otherwise you will get vertically inverted frames in WebGL.

Parameters:

name type arguments Default description
entries any

Any renderable Game Object, or Group, Container, Display List, other Render Texture, Texture Frame or an array of any of these.

x number <optional> 0

The x position to draw the Frame at, or the offset applied to the object.

y number <optional> 0

The y position to draw the Frame at, or the offset applied to the object.

alpha number <optional> 1

The alpha value. Only used when drawing Texture Frames to this texture. Game Objects use their own alpha.

tint number <optional> 0xffffff

The tint color value. Only used when drawing Texture Frames to this texture. Game Objects use their own tint. WebGL only.

Returns:
Description:

This Dynamic Texture instance.

Since: 3.2.0
Focus
Focus
drawFrame(key, [frame], [x], [y], [alpha], [tint])
Focus
Focus

Description:

Draws the Texture Frame to the Render Texture at the given position.

Textures are referenced by their string-based keys, as stored in the Texture Manager.

var rt = this.add.renderTexture(0, 0, 800, 600);
rt.drawFrame(key, frame);

You can optionally provide a position, alpha and tint value to apply to the frame before it is drawn.

Calling this method will cause a batch flush, so if you've got a stack of things to draw in a tight loop, try using the draw method instead.

If you need to draw a Sprite to this Render Texture, use the draw method instead.

If you are not planning on using this Dynamic Texture as a base texture for Sprite Game Objects, then you should set DynamicTexture.isSpriteTexture = false before calling this method, otherwise you will get vertically inverted frames in WebGL.

Parameters:

name type arguments Default description
key string

The key of the texture to be used, as stored in the Texture Manager.

frame string | number <optional>

The name or index of the frame within the Texture. Set to null to skip this argument if not required.

x number <optional> 0

The x position to draw the frame at.

y number <optional> 0

The y position to draw the frame at.

alpha number <optional> 1

The alpha value. Only used when drawing Texture Frames to this texture.

tint number <optional> 0xffffff

The tint color value. Only used when drawing Texture Frames to this texture. WebGL only.

Returns:
Description:

This Dynamic Texture instance.

Since: 3.12.0
Focus
Focus
endDraw([erase])
Focus
Focus

Description:

Use this method to finish batch drawing to this Dynamic Texture.

Doing so will stop the WebGL Renderer from capturing draws and then blit the framebuffer to the Render Target owned by this texture.

Calling this method without first calling beginDraw will have no effect.

Batch drawing is faster than calling draw, but you must be careful to manage the flow of code and remember to call endDraw() when you're finished.

If you don't need to draw large numbers of objects it's much safer and easier to use the draw method instead.

The flow should be:

// Call once:
DynamicTexture.beginDraw();

// repeat n times:
DynamicTexture.batchDraw();
// or
DynamicTexture.batchDrawFrame();

// Call once:
DynamicTexture.endDraw();

Do not call any methods other than batchDraw, batchDrawFrame, or endDraw once you have started a batch. Also, be very careful not to destroy this Dynamic Texture while the batch is still open. Doing so will cause a run-time error in the WebGL Renderer.

You can use the DynamicTexture.isDrawing boolean property to tell if a batch is currently open, or not.

Parameters:

name type arguments Default description
erase boolean <optional> false

Draws all objects in this batch using a blend mode of ERASE. This has the effect of erasing any filled pixels in the objects being drawn.

Returns:
Description:

This Dynamic Texture instance.

Since: 3.50.0
Focus
Focus
erase(entries, [x], [y])
Focus
Focus

Description:

Draws the given object, or an array of objects, to this Dynamic Texture using a blend mode of ERASE. This has the effect of erasing any filled pixels present in the objects from this texture.

It can accept any of the following:

  • Any renderable Game Object, such as a Sprite, Text, Graphics or TileSprite.
  • Tilemap Layers.
  • A Group. The contents of which will be iterated and drawn in turn.
  • A Container. The contents of which will be iterated fully, and drawn in turn.
  • A Scene Display List. Pass in Scene.children to draw the whole list.
  • Another Dynamic Texture, or a Render Texture.
  • A Texture Frame instance.
  • A string. This is used to look-up the texture from the Texture Manager.

Note: You cannot erase a Dynamic Texture from itself.

If passing in a Group or Container it will only draw children that return true when their willRender() method is called. I.e. a Container with 10 children, 5 of which have visible=false will only draw the 5 visible ones.

If passing in an array of Game Objects it will draw them all, regardless if they pass a willRender check or not.

You can pass in a string in which case it will look for a texture in the Texture Manager matching that string, and draw the base frame.

You can pass in the x and y coordinates to draw the objects at. The use of the coordinates differ based on what objects are being drawn. If the object is a Group, Container or Display List, the coordinates are added to the positions of the children. For all other types of object, the coordinates are exact.

Calling this method causes the WebGL batch to flush, so it can write the texture data to the framebuffer being used internally. The batch is flushed at the end, after the entries have been iterated. So if you've a bunch of objects to draw, try and pass them in an array in one single call, rather than making lots of separate calls.

If you are not planning on using this Dynamic Texture as a base texture for Sprite Game Objects, then you should set DynamicTexture.isSpriteTexture = false before calling this method, otherwise you will get vertically inverted frames in WebGL.

Parameters:

name type arguments description
entries any

Any renderable Game Object, or Group, Container, Display List, Render Texture, Texture Frame, or an array of any of these.

x number <optional>

The x position to draw the Frame at, or the offset applied to the object.

y number <optional>

The y position to draw the Frame at, or the offset applied to the object.

Returns:
Description:

This Dynamic Texture instance.

Since: 3.16.0
Focus
Focus
fill(rgb, [alpha], [x], [y], [width], [height])
Focus
Focus

Description:

Fills this Dynamic Texture with the given color.

By default it will fill the entire texture, however you can set it to fill a specific rectangular area by using the x, y, width and height arguments.

The color should be given in hex format, i.e. 0xff0000 for red, 0x00ff00 for green, etc.

Parameters:

name type arguments Default description
rgb number

The color to fill this Dynamic Texture with, such as 0xff0000 for red.

alpha number <optional> 1

The alpha value used by the fill.

x number <optional> 0

The left coordinate of the fill rectangle.

y number <optional> 0

The top coordinate of the fill rectangle.

width number <optional> this.width

The width of the fill rectangle.

height number <optional> this.height

The height of the fill rectangle.

Returns:
Description:

This Dynamic Texture instance.

Since: 3.2.0
Focus
Focus
get([name])
Focus
Focus

Description:

Gets a Frame from this Texture based on either the key or the index of the Frame.

In a Texture Atlas Frames are typically referenced by a key. In a Sprite Sheet Frames are referenced by an index. Passing no value for the name returns the base texture.

Parameters:

name type arguments description
name string | number <optional>

The string-based name, or integer based index, of the Frame to get from this Texture.

Returns:
Description:

The Texture Frame.

Inherited from: Phaser.Textures.Texture#get
Since: 3.0.0
Source: src/textures/Texture.js (Line 224)
Focus
Focus
getDataSourceImage([name])
Focus
Focus

Description:

Given a Frame name, return the data source image it uses to render with. You can use this to get the normal map for an image for example.

This will return the actual DOM Image.

Parameters:

name type arguments description
name string | number <optional>

The string-based name, or integer based index, of the Frame to get from this Texture.

Returns:
Description:

The DOM Image or Canvas Element.

Type:
  • HTMLImageElement
  • HTMLCanvasElement
Inherited from: Phaser.Textures.Texture#getDataSourceImage
Since: 3.7.0
Source: src/textures/Texture.js (Line 439)
Focus
Focus
getFrameBounds([sourceIndex])
Focus
Focus

Description:

Based on the given Texture Source Index, this method will get all of the Frames using that source and then work out the bounds that they encompass, returning them in an object.

This is useful if this Texture is, for example, a sprite sheet within an Atlas, and you need to know the total bounds of the sprite sheet.

Parameters:

name type arguments description
sourceIndex number <optional>

The index of the TextureSource to get the Frame bounds from.

Returns:
Description:

An object containing the bounds of the Frames using the given Texture Source Index.

Inherited from: Phaser.Textures.Texture#getFrameBounds
Since: 3.80.0
Source: src/textures/Texture.js (Line 319)
Focus
Focus
getFrameNames([includeBase])
Focus
Focus

Description:

Returns an array with all of the names of the Frames in this Texture.

Useful if you want to randomly assign a Frame to a Game Object, as you can pick a random element from the returned array.

Parameters:

name type arguments Default description
includeBase boolean <optional> false

Include the __BASE Frame in the output array?

Returns:
Description:

An array of all Frame names in this Texture.

Type:
  • Array.<string>
Inherited from: Phaser.Textures.Texture#getFrameNames
Since: 3.0.0
Source: src/textures/Texture.js (Line 374)
Focus
Focus
getFramesFromTextureSource(sourceIndex, [includeBase])
Focus
Focus

Description:

Returns an array of all the Frames in the given TextureSource.

Parameters:

name type arguments Default description
sourceIndex number

The index of the TextureSource to get the Frames from.

includeBase boolean <optional> false

Include the __BASE Frame in the output array?

Returns:
Description:

An array of Texture Frames.

Type:
Inherited from: Phaser.Textures.Texture#getFramesFromTextureSource
Since: 3.0.0
Source: src/textures/Texture.js (Line 284)
Focus
Focus
getSourceImage([name])
Focus
Focus

Description:

Given a Frame name, return the source image it uses to render with.

This will return the actual DOM Image or Canvas element.

Parameters:

name type arguments description
name string | number <optional>

The string-based name, or integer based index, of the Frame to get from this Texture.

Returns:
Description:

The DOM Image, Canvas Element or Render Texture.

Type:
Inherited from: Phaser.Textures.Texture#getSourceImage
Since: 3.0.0
Source: src/textures/Texture.js (Line 406)
Focus
Focus
getTextureSourceIndex(source)
Focus
Focus

Description:

Takes the given TextureSource and returns the index of it within this Texture. If it's not in this Texture, it returns -1. Unless this Texture has multiple TextureSources, such as with a multi-atlas, this method will always return zero or -1.

Parameters:

name type description
source Phaser.Textures.TextureSource

The TextureSource to check.

Returns:
Description:

The index of the TextureSource within this Texture, or -1 if not in this Texture.

Type:
  • number
Inherited from: Phaser.Textures.Texture#getTextureSourceIndex
Since: 3.0.0
Source: src/textures/Texture.js (Line 258)
Focus
Focus
getWebGLTexture()
Focus
Focus

Description:

Returns the underlying WebGLTextureWrapper, if not running in Canvas mode.

Returns:
Description:

The underlying WebGLTextureWrapper, if not running in Canvas mode.

Since: 3.60.0
Focus
Focus
has(name)
Focus
Focus

Description:

Checks to see if a Frame matching the given key exists within this Texture.

Parameters:

name type description
name string

The key of the Frame to check for.

Returns:
Description:

True if a Frame with the matching key exists in this Texture.

Type:
  • boolean
Inherited from: Phaser.Textures.Texture#has
Since: 3.0.0
Source: src/textures/Texture.js (Line 209)
Focus
Focus
remove(name)
Focus
Focus

Description:

Removes the given Frame from this Texture. The Frame is destroyed immediately.

Any Game Objects using this Frame should stop using it before you remove it, as it does not happen automatically.

Parameters:

name type description
name string

The key of the Frame to remove.

Returns:
Description:

True if a Frame with the matching key was removed from this Texture.

Type:
  • boolean
Inherited from: Phaser.Textures.Texture#remove
Since: 3.19.0
Source: src/textures/Texture.js (Line 180)
Focus
Focus
renderCanvas(renderer, mask, camera)
Focus
Focus

Description:

This is a NOOP method. Bitmap Masks are not supported by the Canvas Renderer.

Parameters:

name type description
renderer Phaser.Renderer.Canvas.CanvasRenderer | Phaser.Renderer.WebGL.WebGLRenderer

The Canvas Renderer which would be rendered to.

mask Phaser.GameObjects.GameObject

The masked Game Object which would be rendered.

camera Phaser.Cameras.Scene2D.Camera

The Camera to render to.

Since: 3.60.0
Focus
Focus
renderWebGL(renderer, src, camera, parentMatrix)
Focus
Focus

Description:

Renders this Dynamic Texture onto the Stamp Game Object as a BitmapMask.

Parameters:

name type description
renderer Phaser.Renderer.WebGL.WebGLRenderer

A reference to the current active WebGL renderer.

src Phaser.GameObjects.Image

The Game Object being rendered in this call.

camera Phaser.Cameras.Scene2D.Camera

The Camera that is rendering the Game Object.

parentMatrix Phaser.GameObjects.Components.TransformMatrix

This transform matrix is defined if the game object is nested

Since: 3.60.0
Focus
Focus
repeat(key, [frame], [x], [y], [width], [height], [alpha], [tint], [skipBatch])
Focus
Focus

Description:

Takes the given Texture Frame and draws it to this Dynamic Texture as a fill pattern, i.e. in a grid-layout based on the frame dimensions.

Textures are referenced by their string-based keys, as stored in the Texture Manager.

You can optionally provide a position, width, height, alpha and tint value to apply to the frames before they are drawn. The position controls the top-left where the repeating fill will start from. The width and height control the size of the filled area.

The position can be negative if required, but the dimensions cannot.

Calling this method will cause a batch flush by default. Use the skipBatch argument to disable this if this call is part of a larger batch draw.

If you are not planning on using this Dynamic Texture as a base texture for Sprite Game Objects, then you should set DynamicTexture.isSpriteTexture = false before calling this method, otherwise you will get vertically inverted frames in WebGL.

Parameters:

name type arguments Default description
key string

The key of the texture to be used, as stored in the Texture Manager.

frame string | number <optional>

The name or index of the frame within the Texture. Set to null to skip this argument if not required.

x number <optional> 0

The x position to start drawing the frames from (can be negative to offset).

y number <optional> 0

The y position to start drawing the frames from (can be negative to offset).

width number <optional> this.width

The width of the area to repeat the frame within. Defaults to the width of this Dynamic Texture.

height number <optional> this.height

The height of the area to repeat the frame within. Defaults to the height of this Dynamic Texture.

alpha number <optional> 1

The alpha to use. Defaults to 1, no alpha.

tint number <optional> 0xffffff

WebGL only. The tint color to use. Leave as undefined, or 0xffffff to have no tint.

skipBatch boolean <optional> false

Skip beginning and ending a batch with this call. Use if this is part of a bigger batched draw.

Returns:
Description:

This Dynamic Texture instance.

Since: 3.60.0
Focus
Focus
setDataSource(data)
Focus
Focus

Description:

Adds a data source image to this Texture.

An example of a data source image would be a normal map, where all of the Frames for this Texture equally apply to the normal map.

Parameters:

name type description
data HTMLImageElement | HTMLCanvasElement | Array.<HTMLImageElement> | Array.<HTMLCanvasElement>

The source image.

Inherited from: Phaser.Textures.Texture#setDataSource
Since: 3.0.0
Source: src/textures/Texture.js (Line 476)
Focus
Focus
setFilter(filterMode)
Focus
Focus

Description:

Sets the Filter Mode for this Texture.

The mode can be either Linear, the default, or Nearest.

For pixel-art you should use Nearest.

The mode applies to the entire Texture, not just a specific Frame of it.

Parameters:

name type description
filterMode Phaser.Textures.FilterMode

The Filter Mode.

Inherited from: Phaser.Textures.Texture#setFilter
Since: 3.0.0
Source: src/textures/Texture.js (Line 502)
Focus
Focus
setFromRenderTarget()
Focus
Focus

Description:

Links the WebGL Textures used by this Dynamic Texture to its Render Target.

This method is called internally by the Dynamic Texture when it is first created, or if you change its size.

Returns:
Description:

This Dynamic Texture instance.

Since: 3.70.0
Focus
Focus
setIsSpriteTexture(value)
Focus
Focus

Description:

If you are planning on using this Render Texture as a base texture for Sprite Game Objects, then you should call this method with a value of true before drawing anything to it, otherwise you will get inverted frames in WebGL.

Parameters:

name type description
value boolean

Is this Render Target being used as a Sprite Texture, or not?

Returns:
Description:

This Dynamic Texture instance.

Since: 3.60.0
Focus
Focus
setSize(width, [height])
Focus
Focus

Description:

Resizes this Dynamic Texture to the new dimensions given.

In WebGL it will destroy and then re-create the frame buffer being used by this Dynamic Texture. In Canvas it will resize the underlying canvas DOM element.

Both approaches will erase everything currently drawn to this texture.

If the dimensions given are the same as those already being used, calling this method will do nothing.

Parameters:

name type arguments Default description
width number

The new width of this Dynamic Texture.

height number <optional> width

The new height of this Dynamic Texture. If not specified, will be set the same as the width.

Returns:
Description:

This Dynamic Texture.

Since: 3.10.0
Focus
Focus
snapshot(callback, [type], [encoderOptions])
Focus
Focus

Description:

Takes a snapshot of the whole of this Dynamic Texture.

The snapshot is taken immediately, but the results are returned via the given callback.

To capture a portion of this Dynamic Texture see the snapshotArea method. To capture just a specific pixel, see the snapshotPixel method.

Snapshots work by using the WebGL readPixels feature to grab every pixel from the frame buffer into an ArrayBufferView. It then parses this, copying the contents to a temporary Canvas and finally creating an Image object from it, which is the image returned to the callback provided.

All in all, this is a computationally expensive and blocking process, which gets more expensive the larger the resolution this Dynamic Texture has, so please be careful how you employ this in your game.

Parameters:

name type arguments Default description
callback Phaser.Types.Renderer.Snapshot.SnapshotCallback

The Function to invoke after the snapshot image is created.

type string <optional> 'image/png'

The format of the image to create, usually image/png or image/jpeg.

encoderOptions number <optional> 0.92

The image quality, between 0 and 1. Used for image formats with lossy compression, such as image/jpeg.

Returns:
Description:

This Dynamic Texture instance.

Since: 3.19.0
Focus
Focus
snapshotArea(x, y, width, height, callback, [type], [encoderOptions])
Focus
Focus

Description:

Takes a snapshot of the given area of this Dynamic Texture.

The snapshot is taken immediately, but the results are returned via the given callback.

To capture the whole Dynamic Texture see the snapshot method. To capture just a specific pixel, see the snapshotPixel method.

Snapshots work by using the WebGL readPixels feature to grab every pixel from the frame buffer into an ArrayBufferView. It then parses this, copying the contents to a temporary Canvas and finally creating an Image object from it, which is the image returned to the callback provided.

All in all, this is a computationally expensive and blocking process, which gets more expensive the larger the resolution this Dynamic Texture has, so please be careful how you employ this in your game.

Parameters:

name type arguments Default description
x number

The x coordinate to grab from.

y number

The y coordinate to grab from.

width number

The width of the area to grab.

height number

The height of the area to grab.

callback Phaser.Types.Renderer.Snapshot.SnapshotCallback

The Function to invoke after the snapshot image is created.

type string <optional> 'image/png'

The format of the image to create, usually image/png or image/jpeg.

encoderOptions number <optional> 0.92

The image quality, between 0 and 1. Used for image formats with lossy compression, such as image/jpeg.

Returns:
Description:

This Dynamic Texture instance.

Since: 3.19.0
Focus
Focus
snapshotPixel(x, y, callback)
Focus
Focus

Description:

Takes a snapshot of the given pixel from this Dynamic Texture.

The snapshot is taken immediately, but the results are returned via the given callback.

To capture the whole Dynamic Texture see the snapshot method. To capture a portion of this Dynamic Texture see the snapshotArea method.

Unlike the two other snapshot methods, this one will send your callback a Color object containing the color data for the requested pixel. It doesn't need to create an internal Canvas or Image object, so is a lot faster to execute, using less memory than the other snapshot methods.

Parameters:

name type description
x number

The x coordinate of the pixel to get.

y number

The y coordinate of the pixel to get.

callback Phaser.Types.Renderer.Snapshot.SnapshotCallback

The Function to invoke after the snapshot pixel data is extracted.

Returns:
Description:

This Dynamic Texture instance.

Since: 3.19.0
Focus
Focus
stamp(key, [frame], [x], [y], [config])
Focus
Focus

Description:

Takes the given texture key and frame and then stamps it at the given x and y coordinates. You can use the optional 'config' argument to provide lots more options about how the stamp is applied, including the alpha, tint, angle, scale and origin.

By default, the frame will stamp on the x/y coordinates based on its center.

If you wish to stamp from the top-left, set the config originX and originY properties both to zero.

Parameters:

name type arguments description
key string

The key of the texture to be used, as stored in the Texture Manager.

frame string | number <optional>

The name or index of the frame within the Texture. Set to null to skip this argument if not required.

x number <optional>

The x position to draw the frame at.

y number <optional>

The y position to draw the frame at.

config Phaser.Types.Textures.StampConfig <optional>

The stamp configuration object, allowing you to set the alpha, tint, angle, scale and origin of the stamp.

Returns:
Description:

This Dynamic Texture instance.

Since: 3.60.0
Focus
Focus