Mirrors/phaser
2
0
Fork 0
mirror of https://github.com/photonstorm/phaser synced 2024-12-18 00:53:42 +00:00
Code Issues Projects Releases Packages Wiki Activity
phaser/typescript/pixi.comments.d.ts
photonstorm 858ad51610 Phaser 2.4 release.
2015-07-22 15:31:30 +01:00

3698 lines
102 KiB
TypeScript
Raw Blame History

// Type definitions for PIXI with Phaser Deviations.
declare module PIXI {
export var WEBGL_RENDERER: number;
export var CANVAS_RENDERER: number;
export var VERSION: string;
export enum blendModes {
NORMAL,
ADD,
MULTIPLY,
SCREEN,
OVERLAY,
DARKEN,
LIGHTEN,
COLOR_DODGE,
COLOR_BURN,
HARD_LIGHT,
SOFT_LIGHT,
DIFFERENCE,
EXCLUSION,
HUE,
SATURATION,
COLOR,
LUMINOSITY
}
export enum scaleModes {
DEFAULT,
LINEAR,
NEAREST
}
export var defaultRenderOptions: PixiRendererOptions;
export var INTERACTION_REQUENCY: number;
export var AUTO_PREVENT_DEFAULT: boolean;
export var PI_2: number;
export var RAD_TO_DEG: number;
export var DEG_TO_RAD: number;
export var RETINA_PREFIX: string;
export var identityMatrix: Matrix;
export var glContexts: WebGLRenderingContext[];
export var instances: any[];
export var BaseTextureCache: { [key: string]: BaseTexture };
export var TextureCache: { [key: string]: Texture };
export var TextureSilentFail: boolean;
export var BitmapText: { fonts: {} };
export function isPowerOfTwo(width: number, height: number): boolean;
export function rgb2hex(rgb: number[]): string;
export function hex2rgb(hex: string): number[];
export function autoDetectRenderer(width?: number, height?: number, options?: PixiRendererOptions): PixiRenderer;
export function autoDetectRecommendedRenderer(width?: number, height?: number, options?: PixiRendererOptions): PixiRenderer;
export function canUseNewCanvasBlendModes(): boolean;
export function getNextPowerOfTwo(number: number): number;
export function AjaxRequest(): XMLHttpRequest;
export function CompileFragmentShader(gl: WebGLRenderingContext, shaderSrc: string[]): any;
export function CompileProgram(gl: WebGLRenderingContext, vertexSrc: string[], fragmentSrc: string[]): any;
export interface IEventCallback {
(e?: IEvent): void
}
export interface IEvent {
type: string;
content: any;
}
export interface HitArea {
contains(x: number, y: number): boolean;
}
export interface IInteractionDataCallback {
(interactionData: InteractionData): void
}
export interface PixiRenderer {
autoResize: boolean;
clearBeforeRender: boolean;
height: number;
resolution: number;
transparent: boolean;
type: number;
view: HTMLCanvasElement;
width: number;
destroy(): void;
render(stage: Stage): void;
resize(width: number, height: number): void;
}
export interface PixiRendererOptions {
autoResize?: boolean;
antialias?: boolean;
clearBeforeRender?: boolean;
preserveDrawingBuffer?: boolean;
resolution?: number;
transparent?: boolean;
view?: HTMLCanvasElement;
}
export interface BitmapTextStyle {
font?: string;
align?: string;
tint?: string;
}
export interface TextStyle {
align?: string;
dropShadow?: boolean;
dropShadowColor?: string;
dropShadowAngle?: number;
dropShadowDistance?: number;
fill?: string;
font?: string;
lineJoin?: string;
stroke?: string;
strokeThickness?: number;
wordWrap?: boolean;
wordWrapWidth?: number;
}
export interface Loader {
load(): void;
}
export interface MaskData {
alpha: number;
worldTransform: number[];
}
export interface RenderSession {
context: CanvasRenderingContext2D;
maskManager: CanvasMaskManager;
scaleMode: scaleModes;
smoothProperty: string;
roundPixels: boolean;
}
export interface ShaderAttribute {
// TODO: Find signature of shader attributes
}
export interface FilterBlock {
visible: boolean;
renderable: boolean;
}
/**
* 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.
*/
export class AbstractFilter {
/**
* 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 fragmentSrc The fragment source in an array of strings.
* @param uniforms An object containing the uniforms for this filter.
*/
constructor(fragmentSrc: string | string[], uniforms: any);
dirty: boolean;
padding: number;
uniforms: any;
fragmentSrc: string | string[];
apply(frameBuffer: WebGLFramebuffer): void;
/**
* Syncs the uniforms between the class object and the shaders.
*/
syncUniforms(): void;
}
export class AlphaMaskFilter extends AbstractFilter {
constructor(texture: Texture);
map: Texture;
onTextureLoaded(): void;
}
export class AsciiFilter extends AbstractFilter {
size: number;
}
export class AssetLoader implements Mixin {
assetURLs: string[];
crossorigin: boolean;
loadersByType: { [key: string]: Loader };
constructor(assetURLs: string[], crossorigin: boolean);
listeners(eventName: string): Function[];
emit(eventName: string, data?: any): boolean;
dispatchEvent(eventName: string, data?: any): boolean;
on(eventName: string, fn: Function): Function;
addEventListener(eventName: string, fn: Function): Function;
once(eventName: string, fn: Function): Function;
off(eventName: string, fn: Function): Function;
removeAllEventListeners(eventName: string): void;
load(): void;
}
export class AtlasLoader implements Mixin {
url: string;
baseUrl: string;
crossorigin: boolean;
loaded: boolean;
constructor(url: string, crossorigin: boolean);
listeners(eventName: string): Function[];
emit(eventName: string, data?: any): boolean;
dispatchEvent(eventName: string, data?: any): boolean;
on(eventName: string, fn: Function): Function;
addEventListener(eventName: string, fn: Function): Function;
once(eventName: string, fn: Function): Function;
off(eventName: string, fn: Function): Function;
removeAllEventListeners(eventName: string): void;
load(): void;
}
/**
* A texture stores the information that represents an image. All textures have a base texture.
*/
export class BaseTexture implements Mixin {
/**
* Helper function that creates a base texture from the given image url.
* If the image is not in the base texture cache it will be created and loaded.
*
* @param imageUrl The image url of the texture
* @param crossorigin -
* @param scaleMode See {{#crossLink "PIXI/scaleModes:property"}}PIXI.scaleModes{{/crossLink}} for possible values
* @return BaseTexture
*/
static fromImage(imageUrl: string, crossorigin?: boolean, scaleMode?: scaleModes): BaseTexture;
/**
* Helper function that creates a base texture from the given canvas element.
*
* @param canvas The canvas element source of the texture
* @param scaleMode See {{#crossLink "PIXI/scaleModes:property"}}PIXI.scaleModes{{/crossLink}} for possible values
* @return BaseTexture
*/
static fromCanvas(canvas: HTMLCanvasElement, scaleMode?: scaleModes): BaseTexture;
/**
* A texture stores the information that represents an image. All textures have a base texture.
*
* @param source the source object (image or canvas)
* @param scaleMode See {{#crossLink "PIXI/scaleModes:property"}}PIXI.scaleModes{{/crossLink}} for possible values
*/
constructor(source: HTMLImageElement, scaleMode: scaleModes);
/**
* A texture stores the information that represents an image. All textures have a base texture.
*
* @param source the source object (image or canvas)
* @param scaleMode See {{#crossLink "PIXI/scaleModes:property"}}PIXI.scaleModes{{/crossLink}} for possible values
*/
constructor(source: HTMLCanvasElement, scaleMode: scaleModes);
/**
* [read-only] The height of the base texture set when the image has loaded
*/
height: number;
/**
* [read-only] Set to true once the base texture has loaded
*/
hasLoaded: boolean;
/**
* Set this to true if a mipmap of this texture needs to be generated. This value needs to be set before the texture is used
* Also the texture must be a power of two size to work
*/
mipmap: boolean;
/**
* Controls if RGB channels should be pre-multiplied by Alpha (WebGL only)
* Default: true
*/
premultipliedAlpha: boolean;
/**
* The Resolution of the texture.
*/
resolution: number;
/**
* The scale mode to apply when scaling this texture
* Default: PIXI.scaleModes.LINEAR
*/
scaleMode: scaleModes;
/**
* The image source that is used to create the texture.
*/
source: HTMLImageElement;
/**
* [read-only] The width of the base texture set when the image has loaded
*/
width: number;
listeners(eventName: string): Function[];
emit(eventName: string, data?: any): boolean;
dispatchEvent(eventName: string, data?: any): boolean;
on(eventName: string, fn: Function): Function;
addEventListener(eventName: string, fn: Function): Function;
once(eventName: string, fn: Function): Function;
off(eventName: string, fn: Function): Function;
removeAllEventListeners(eventName: string): void;
/**
* Forces this BaseTexture to be set as loaded, with the given width and height.
* Then calls BaseTexture.dirty.
* Important for when you don't want to modify the source object by forcing in `complete` or dimension properties it may not have.
*
* @param width - The new width to force the BaseTexture to be.
* @param height - The new height to force the BaseTexture to be.
*/
forceLoaded(width: number, height: number): void;
/**
* Destroys this base texture
*/
destroy(): void;
/**
* Sets all glTextures to be dirty.
*/
dirty(): void;
/**
* Changes the source image of the texture
*
* @param newSrc the path of the image
*/
updateSourceImage(newSrc: string): void;
/**
* Removes the base texture from the GPU, useful for managing resources on the GPU.
* Atexture is still 100% usable and will simply be reuploaded if there is a sprite on screen that is using it.
*/
unloadFromGPU(): void;
}
export class BitmapFontLoader implements Mixin {
constructor(url: string, crossorigin: boolean);
baseUrl: string;
crossorigin: boolean;
texture: Texture;
url: string;
listeners(eventName: string): Function[];
emit(eventName: string, data?: any): boolean;
dispatchEvent(eventName: string, data?: any): boolean;
on(eventName: string, fn: Function): Function;
addEventListener(eventName: string, fn: Function): Function;
once(eventName: string, fn: Function): Function;
off(eventName: string, fn: Function): Function;
removeAllEventListeners(eventName: string): void;
load(): void;
}
export class BlurFilter extends AbstractFilter {
blur: number;
blurX: number;
blurY: number;
}
export class BlurXFilter extends AbstractFilter {
blur: number;
}
export class BlurYFilter extends AbstractFilter {
blur: number;
}
/**
* Creates a Canvas element of the given size.
*/
export class CanvasBuffer {
/**
* Creates a Canvas element of the given size.
*
* @param width the width for the newly created canvas
* @param height the height for the newly created canvas
*/
constructor(width: number, height: number);
/**
* The Canvas object that belongs to this CanvasBuffer.
*/
canvas: HTMLCanvasElement;
/**
* A CanvasRenderingContext2D object representing a two-dimensional rendering context.
*/
context: CanvasRenderingContext2D;
/**
* The height of the Canvas in pixels.
*/
height: number;
/**
* The width of the Canvas in pixels.
*/
width: number;
/**
* Clears the canvas that was created by the CanvasBuffer class.
*/
clear(): void;
/**
* Resizes the canvas to the specified width and height.
*
* @param width the new width of the canvas
* @param height the new height of the canvas
*/
resize(width: number, height: number): void;
}
/**
* A set of functions used to handle masking.
*/
export class CanvasMaskManager {
/**
* This method adds it to the current stack of masks.
*
* @param maskData the maskData that will be pushed
* @param renderSession The renderSession whose context will be used for this mask manager.
*/
pushMask(maskData: MaskData, renderSession: RenderSession): void;
/**
* Restores the current drawing context to the state it was before the mask was applied.
*
* @param renderSession The renderSession whose context will be used for this mask manager.
*/
popMask(renderSession: RenderSession): void;
}
/**
* The CanvasRenderer draws the Stage and all its content onto a 2d canvas. This renderer should be used for browsers that do not support webGL.
* Don't forget to add the CanvasRenderer.view to your DOM or you will not see anything :)
*/
export class CanvasRenderer implements PixiRenderer {
/**
* The CanvasRenderer draws the Stage and all its content onto a 2d canvas. This renderer should be used for browsers that do not support webGL.
* Don't forget to add the CanvasRenderer.view to your DOM or you will not see anything :)
*
* @param width the width of the canvas view - Default: 800
* @param height the height of the canvas view - Default: 600
* @param options The optional renderer parameters
*/
constructor(width?: number, height?: number, options?: PixiRendererOptions);
/**
* Whether the render view should be resized automatically
*/
autoResize: boolean;
/**
* This sets if the CanvasRenderer will clear the canvas or not before the new render pass.
* If the Stage is NOT transparent Pixi will use a canvas sized fillRect operation every frame to set the canvas background color.
* If the Stage is transparent Pixi will use clearRect to clear the canvas every frame.
* Disable this by setting this to false. For example if your game has a canvas filling background image you often don't need this set.
*/
clearBeforeRender: boolean;
/**
* The canvas 2d context that everything is drawn with
*/
context: CanvasRenderingContext2D;
/**
* Internal var.
*/
count: number;
/**
* The height of the canvas view
* Default: 600
*/
height: number;
maskManager: CanvasMaskManager;
/**
* Boolean flag controlling canvas refresh.
*/
refresh: boolean;
/**
* The render session is just a bunch of parameter used for rendering
*/
renderSession: RenderSession;
/**
* The resolution of the canvas.
*/
resolution: number;
/**
* Whether the render view is transparent
*/
transparent: boolean;
/**
* The renderer type.
*/
type: number;
/**
* The canvas element that everything is drawn to.
*/
view: HTMLCanvasElement;
/**
* The width of the canvas view
* Default: 800
*/
width: number;
/**
* Removes everything from the renderer and optionally removes the Canvas DOM element.
*
* @param removeView Removes the Canvas element from the DOM. - Default: true
*/
destroy(removeView?: boolean): void;
/**
* Renders the Stage to this canvas view
*
* @param stage the Stage element to be rendered
*/
render(stage: Stage): void;
/**
* Resizes the canvas view to the specified width and height
*
* @param width the new width of the canvas view
* @param height the new height of the canvas view
*/
resize(width: number, height: number): void;
}
/**
* Utility methods for Sprite/Texture tinting.
*/
export class CanvasTinter {
/**
* Basically this method just needs a sprite and a color and tints the sprite with the given color.
*
* @param sprite the sprite to tint
* @param color the color to use to tint the sprite with
* @return The tinted canvas
*/
static getTintedTexture(sprite: Sprite, color: number): HTMLCanvasElement;
/**
* Tint a texture using the "multiply" operation.
*
* @param texture the texture to tint
* @param color the color to use to tint the sprite with
* @param canvas the current canvas
*/
static tintWithMultiply(texture: Texture, color: number, canvas: HTMLCanvasElement): void;
static tintWithOverlay(texture: Texture, color: number, canvas: HTMLCanvasElement): void;
static tintWithPerPixel(texture: Texture, color: number, canvas: HTMLCanvasElement): void;
/**
* Whether or not the Canvas BlendModes are supported, consequently the ability to tint using the multiply method.
*/
static canUseMultiply: boolean;
static tintMethod: any;
}
export class Circle implements HitArea {
constructor(x: number, y: number, radius: number);
x: number;
y: number;
radius: number;
clone(): Circle;
contains(x: number, y: number): boolean;
getBounds(): Rectangle;
}
export class ColorMatrixFilter extends AbstractFilter {
matrix: Matrix;
}
export class ColorStepFilter extends AbstractFilter {
step: number;
}
export class ConvolutionFilter extends AbstractFilter {
constructor(matrix: number[], width: number, height: number);
matrix: Matrix;
width: number;
height: number;
}
export class CrossHatchFilter extends AbstractFilter {
blur: number;
}
export class DisplacementFilter extends AbstractFilter {
constructor(texture: Texture);
map: Texture;
offset: Point;
scale: Point;
}
export class DotScreenFilter extends AbstractFilter {
angle: number;
scale: Point;
}
/**
* The base class for all objects that are rendered on the screen.
* This is an abstract class and should not be used on its own rather it should be extended.
*/
export class DisplayObject {
/**
* The opacity of the object.
*/
alpha: number;
buttonMode: boolean;
/**
* Set if this display object is cached as a bitmap.
* This basically takes a snap shot of the display object as it is at that moment. It can provide a performance benefit for complex static displayObjects.
* To remove simply set this property to 'null'
*/
cacheAsBitmap: boolean;
defaultCursor: string;
/**
* The area the filter is applied to like the hitArea this is used as more of an optimisation
* rather than figuring out the dimensions of the displayObject each frame you can set this rectangle
*/
filterArea: Rectangle;
/**
* Sets the filters for the displayObject.
* IMPORTANT: This is a webGL only feature and will be ignored by the canvas renderer.
* To remove filters simply set this property to 'null'
*/
filters: AbstractFilter[];
/**
* 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)
*/
hitArea: HitArea;
interactive: boolean;
/**
* Sets a mask for the displayObject. A mask is an object that limits the visibility of an object to the shape of the mask applied to it.
* In PIXI a regular mask must be a PIXI.Graphics object. This allows for much faster masking in canvas as it utilises shape clipping.
* To remove a mask, set this property to null.
*/
mask: Graphics;
/**
* [read-only] The display object container that contains this display object.
*/
parent: DisplayObjectContainer;
/**
* The pivot point of the displayObject that it rotates around
*/
pivot: Point;
/**
* The coordinate of the object relative to the local coordinates of the parent.
*/
position: Point;
/**
* Can this object be rendered
*/
renderable: boolean;
/**
* The rotation of the object in radians.
*/
rotation: number;
/**
* The scale factor of the object.
*/
scale: Point;
/**
* [read-only] The stage the display object is connected to, or undefined if it is not connected to the stage.
*/
stage: Stage;
/**
* The visibility of the object.
*/
visible: boolean;
/**
* [read-only] The multiplied alpha of the displayObject
*/
worldAlpha: number;
/**
* The position of the Display Object based on the world transform.
* This value is updated at the end of updateTransform and takes all parent transforms into account.
*/
worldPosition: PIXI.Point;
/**
* The scale of the Display Object based on the world transform.
* This value is updated at the end of updateTransform and takes all parent transforms into account.
*/
worldScale: PIXI.Point;
/**
* The rotation of the Display Object, in radians, based on the world transform.
* This value is updated at the end of updateTransform and takes all parent transforms into account.
*/
worldRotation: number;
/**
* [read-only] Indicates if the sprite is globally visible.
*/
worldVisible: boolean;
/**
* The position of the displayObject on the x axis relative to the local coordinates of the parent.
*/
x: number;
/**
* The position of the displayObject on the y axis relative to the local coordinates of the parent.
*/
y: number;
click(e: InteractionData): void;
displayObjectUpdateTransform(): void;
/**
* Retrieves the bounds of the displayObject as a rectangle object
*
* @param matrix -
* @return the rectangular bounding area
*/
getBounds(matrix?: Matrix): Rectangle;
/**
* Retrieves the local bounds of the displayObject as a rectangle object
* @return the rectangular bounding area
*/
getLocalBounds(): Rectangle;
/**
* Useful function that returns a texture of the displayObject object that can then be used to create sprites
* This can be quite useful if your displayObject is static / complicated and needs to be reused multiple times.
*
* @param resolution The resolution of the texture being generated
* @param scaleMode See {{#crossLink "PIXI/scaleModes:property"}}PIXI.scaleModes{{/crossLink}} for possible values
* @param renderer The renderer used to generate the texture.
* @return a texture of the graphics object
*/
generateTexture(resolution?: number, scaleMode?: number, renderer?: PixiRenderer): Texture;
mousedown(e: InteractionData): void;
mouseout(e: InteractionData): void;
mouseover(e: InteractionData): void;
mouseup(e: InteractionData): void;
mousemove(e: InteractionData): void;
mouseupoutside(e: InteractionData): void;
rightclick(e: InteractionData): void;
rightdown(e: InteractionData): void;
rightup(e: InteractionData): void;
rightupoutside(e: InteractionData): void;
/**
* Sets the object's stage reference, the stage this object is connected to
*
* @param stage the stage that the object will have as its current stage reference
*/
setStageReference(stage: Stage): void;
tap(e: InteractionData): void;
/**
* Calculates the global position of the display object
*
* @param position The world origin to calculate from
* @return A point object representing the position of this object
*/
toGlobal(position: Point): Point;
/**
* Calculates the local position of the display object relative to another point
*
* @param position The world origin to calculate from
* @param from The DisplayObject to calculate the global position from
* @return A point object representing the position of this object
*/
toLocal(position: Point, from: DisplayObject): Point;
touchend(e: InteractionData): void;
touchendoutside(e: InteractionData): void;
touchstart(e: InteractionData): void;
touchmove(e: InteractionData): void;
updateTransform(parent?: PIXI.DisplayObjectContainer): void;
}
/**
* 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.
*/
export class DisplayObjectContainer extends DisplayObject {
/**
* 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.
*/
constructor();
/**
* [read-only] The array of children of this container.
*/
children: DisplayObject[];
/**
* The height of the displayObjectContainer, setting this will actually modify the scale to achieve the value set
*/
height: number;
/**
* The width of the displayObjectContainer, setting this will actually modify the scale to achieve the value set
*/
width: number;
/**
* Adds a child to the container.
*
* @param child The DisplayObject to add to the container
* @return The child that was added.
*/
addChild(child: DisplayObject): DisplayObject;
/**
* Adds a child to the container at a specified index. If the index is out of bounds an error will be thrown
*
* @param child The child to add
* @param index The index to place the child in
* @return The child that was added.
*/
addChildAt(child: DisplayObject, index: number): DisplayObject;
/**
* Retrieves the bounds of the displayObjectContainer as a rectangle. The bounds calculation takes all visible children into consideration.
* @return The rectangular bounding area
*/
getBounds(): Rectangle;
/**
* Returns the child at the specified index
*
* @param index The index to get the child from
* @return The child at the given index, if any.
*/
getChildAt(index: number): DisplayObject;
/**
* Returns the index position of a child DisplayObject instance
*
* @param child The DisplayObject instance to identify
* @return The index position of the child display object to identify
*/
getChildIndex(child: DisplayObject): number;
/**
* Retrieves the non-global local bounds of the displayObjectContainer as a rectangle. The calculation takes all visible children into consideration.
* @return The rectangular bounding area
*/
getLocalBounds(): Rectangle;
/**
* Removes a child from the container.
*
* @param child The DisplayObject to remove
* @return The child that was removed.
*/
removeChild(child: DisplayObject): DisplayObject;
/**
* Removes a child from the specified index position.
*
* @param index The index to get the child from
* @return The child that was removed.
*/
removeChildAt(index: number): DisplayObject;
/**
* Removes all children from this container that are within the begin and end indexes.
*
* @param beginIndex The beginning position. Default value is 0.
* @param endIndex The ending position. Default value is size of the container.
*/
removeChildren(beginIndex?: number, endIndex?: number): DisplayObject[];
/**
* Removes the current stage reference from the container and all of its children.
*/
removeStageReference(): void;
/**
* Changes the position of an existing child in the display object container
*
* @param child The child DisplayObject instance for which you want to change the index number
* @param index The resulting index number for the child display object
*/
setChildIndex(child: DisplayObject, index: number): void;
/**
* Swaps the position of 2 Display Objects within this container.
*
* @param child -
* @param child2 -
*/
swapChildren(child: DisplayObject, child2: DisplayObject): void;
}
export class Ellipse implements HitArea {
constructor(x: number, y: number, width: number, height: number);
x: number;
y: number;
width: number;
height: number;
clone(): Ellipse;
contains(x: number, y: number): boolean;
getBounds(): Rectangle;
}
/**
* Creates an homogenous object for tracking events so users can know what to expect.
*/
export class Event {
/**
* Creates an homogenous object for tracking events so users can know what to expect.
*
* @param target The target object that the event is called on
* @param name The string name of the event that was triggered
* @param data Arbitrary event data to pass along
*/
constructor(target: any, name: string, data: any);
/**
* The original target the event triggered on.
*/
target: any;
/**
* The string name of the event that this represents.
*/
type: string;
/**
* The data that was passed in with this event.
*/
data: any;
/**
* The timestamp when the event occurred.
*/
timeStamp: number;
/**
* Stops the propagation of events up the scene graph (prevents bubbling).
*/
stopPropagation(): void;
preventDefault(): void;
/**
* Stops the propagation of events to sibling listeners (no longer calls any listeners).
*/
stopImmediatePropagation(): void;
}
/**
* Mixins event emitter functionality to a class
*/
export class EventTarget {
/**
* Mixes in the properties of the EventTarget prototype onto another object
*
* @param object The obj to mix into
*/
static mixin(obj: any): void;
}
export class FilterTexture {
/**
*
*
* @param gl the current WebGL drawing context
* @param width the horizontal range of the filter
* @param height the vertical range of the filter
* @param scaleMode See {{#crossLink "PIXI/scaleModes:property"}}PIXI.scaleModes{{/crossLink}} for possible values
*/
constructor(gl: WebGLRenderingContext, width: number, height: number, scaleMode: scaleModes);
fragmentSrc: string[];
frameBuffer: WebGLFramebuffer;
gl: WebGLRenderingContext;
program: WebGLProgram;
scaleMode: number;
texture: WebGLTexture;
/**
* Clears the filter texture.
*/
clear(): void;
/**
* Resizes the texture to the specified width and height
*
* @param width the new width of the texture
* @param height the new height of the texture
*/
resize(width: number, height: number): void;
/**
* Destroys the filter texture.
*/
destroy(): void;
}
/**
* A GraphicsData object.
*/
export class GraphicsData {
/**
* A GraphicsData object.
*/
constructor(lineWidth?: number, lineColor?: number, lineAlpha?: number, fillColor?: number, fillAlpha?: number, fill?: boolean, shape?: any);
lineWidth: number;
lineColor: number;
lineAlpha: number;
fillColor: number;
fillAlpha: number;
fill: boolean;
shape: any;
type: number;
}
/**
* The Graphics class contains methods used to draw primitive shapes such as lines, circles and rectangles to the display, and color and fill them.
*/
export class Graphics extends DisplayObjectContainer {
static POLY: number;
static RECT: number;
static CIRC: number;
static ELIP: number;
static RREC: number;
/**
* The blend mode to be applied to the graphic shape. Apply a value of PIXI.blendModes.NORMAL to reset the blend mode.
* Default: PIXI.blendModes.NORMAL;
*/
blendMode: number;
/**
* The bounds' padding used for bounds calculation.
*/
boundsPadding: number;
/**
* The alpha value used when filling the Graphics object.
*/
fillAlpha: number;
/**
* Whether this shape is being used as a mask.
*/
isMask: boolean;
/**
* The width (thickness) of any lines drawn.
*/
lineWidth: number;
/**
* The color of any lines drawn.
* Default: 0
*/
lineColor: number;
/**
* The tint applied to the graphic shape. This is a hex value. Apply a value of 0xFFFFFF to reset the tint.
* Default: 0xFFFFFF
*/
tint: number;
/**
* [read-only] The multiplied alpha of the displayObject
*/
worldAlpha: number;
/**
* The arc method creates an arc/curve (used to create circles, or parts of circles).
*
* @param cx The x-coordinate of the center of the circle
* @param cy The y-coordinate of the center of the circle
* @param radius The radius of the circle
* @param startAngle The starting angle, in radians (0 is at the 3 o'clock position of the arc's circle)
* @param endAngle The ending angle, in radians
* @param anticlockwise Optional. Specifies whether the drawing should be counterclockwise or clockwise. False is default, and indicates clockwise, while true indicates counter-clockwise.
*/
arc(cx: number, cy: number, radius: number, startAngle: number, endAngle: number, anticlockwise: boolean): Graphics;
arcTo(x1: number, y1: number, x2: number, y2: number, radius: number): Graphics;
/**
* Specifies a simple one-color fill that subsequent calls to other Graphics methods
* (such as lineTo() or drawCircle()) use when drawing.
*
* @param color the color of the fill
* @param alpha the alpha of the fill
*/
beginFill(color?: number, alpha?: number): Graphics;
/**
* Calculate the points for a bezier curve and then draws it.
*
* @param cpX Control point x
* @param cpY Control point y
* @param cpX2 Second Control point x
* @param cpY2 Second Control point y
* @param toX Destination point x
* @param toY Destination point y
*/
bezierCurveTo(cpX: number, cpY: number, cpX2: number, cpY2: number, toX: number, toY: number): Graphics;
/**
* Clears the graphics that were drawn to this Graphics object, and resets fill and line style settings.
*/
clear(): Graphics;
/**
* Destroys a previous cached sprite.
*/
destroyCachedSprite(): void;
/**
* Draws a circle.
*
* @param x The X coordinate of the center of the circle
* @param y The Y coordinate of the center of the circle
* @param diameter The diameter of the circle
*/
drawCircle(x: number, y: number, diameter: number): Graphics;
/**
* Draws an ellipse.
*
* @param x The X coordinate of the center of the ellipse
* @param y The Y coordinate of the center of the ellipse
* @param width The half width of the ellipse
* @param height The half height of the ellipse
*/
drawEllipse(x: number, y: number, width: number, height: number): Graphics;
/**
* Draws a polygon using the given path.
*
* @param path The path data used to construct the polygon. Can either be an array of points or a Phaser.Polygon object.
*/
drawPolygon(...path: any[]): Graphics;
/**
*
*
* @param x The X coord of the top-left of the rectangle
* @param y The Y coord of the top-left of the rectangle
* @param width The width of the rectangle
* @param height The height of the rectangle
*/
drawRect(x: number, y: number, width: number, height: number): Graphics;
/**
*
*
* @param x The X coord of the top-left of the rectangle
* @param y The Y coord of the top-left of the rectangle
* @param width The width of the rectangle
* @param height The height of the rectangle
* @param radius Radius of the rectangle corners. In WebGL this must be a value between 0 and 9.
*/
drawRoundedRect(x: number, y: number, width: number, height: number, radius: number): Graphics;
/**
* Draws the given shape to this Graphics object. Can be any of Circle, Rectangle, Ellipse, Line or Polygon.
*
* @param shape The Shape object to draw.
* @return The generated GraphicsData object.
*/
drawShape(shape: Circle): GraphicsData;
/**
* Draws the given shape to this Graphics object. Can be any of Circle, Rectangle, Ellipse, Line or Polygon.
*
* @param shape The Shape object to draw.
* @return The generated GraphicsData object.
*/
drawShape(shape: Rectangle): GraphicsData;
/**
* Draws the given shape to this Graphics object. Can be any of Circle, Rectangle, Ellipse, Line or Polygon.
*
* @param shape The Shape object to draw.
* @return The generated GraphicsData object.
*/
drawShape(shape: Ellipse): GraphicsData;
/**
* Draws the given shape to this Graphics object. Can be any of Circle, Rectangle, Ellipse, Line or Polygon.
*
* @param shape The Shape object to draw.
* @return The generated GraphicsData object.
*/
drawShape(shape: Polygon): GraphicsData;
/**
* Applies a fill to the lines and shapes that were added since the last call to the beginFill() method.
*/
endFill(): Graphics;
/**
* Useful function that returns a texture of the graphics object that can then be used to create sprites
* This can be quite useful if your geometry is complicated and needs to be reused multiple times.
*
* @param resolution The resolution of the texture being generated
* @param scaleMode Should be one of the PIXI.scaleMode consts
* @return a texture of the graphics object
*/
generateTexture(resolution?: number, scaleMode?: number): Texture;
/**
* Specifies the line style used for subsequent calls to Graphics methods such as the lineTo() method or the drawCircle() method.
*
* @param lineWidth width of the line to draw, will update the objects stored style
* @param color color of the line to draw, will update the objects stored style
* @param alpha alpha of the line to draw, will update the objects stored style
*/
lineStyle(lineWidth?: number, color?: number, alpha?: number): Graphics;
/**
* 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).
*
* @param x the X coordinate to draw to
* @param y the Y coordinate to draw to
*/
lineTo(x: number, y: number): Graphics;
/**
* Moves the current drawing position to x, y.
*
* @param x the X coordinate to move to
* @param y the Y coordinate to move to
*/
moveTo(x: number, y: number): Graphics;
/**
* 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
*
* @param cpX Control point x
* @param cpY Control point y
* @param toX Destination point x
* @param toY Destination point y
*/
quadraticCurveTo(cpX: number, cpY: number, toX: number, toY: number): Graphics;
}
export class GrayFilter extends AbstractFilter {
gray: number;
}
export class ImageLoader implements Mixin {
constructor(url: string, crossorigin?: boolean);
texture: Texture;
listeners(eventName: string): Function[];
emit(eventName: string, data?: any): boolean;
dispatchEvent(eventName: string, data?: any): boolean;
on(eventName: string, fn: Function): Function;
addEventListener(eventName: string, fn: Function): Function;
once(eventName: string, fn: Function): Function;
off(eventName: string, fn: Function): Function;
removeAllEventListeners(eventName: string): void;
load(): void;
loadFramedSpriteSheet(frameWidth: number, frameHeight: number, textureName: string): void;
}
export class InteractionData {
global: Point;
target: Sprite;
originalEvent: Event;
getLocalPosition(displayObject: DisplayObject, point?: Point, globalPos?: Point): Point;
}
export class InteractionManager {
currentCursorStyle: string;
last: number;
mouse: InteractionData;
mouseOut: boolean;
mouseoverEnabled: boolean;
onMouseMove: Function;
onMouseDown: Function;
onMouseOut: Function;
onMouseUp: Function;
onTouchStart: Function;
onTouchEnd: Function;
onTouchMove: Function;
pool: InteractionData[];
resolution: number;
stage: Stage;
touches: { [id: string]: InteractionData };
constructor(stage: Stage);
}
export class InvertFilter extends AbstractFilter {
invert: number;
}
export class JsonLoader implements Mixin {
constructor(url: string, crossorigin?: boolean);
baseUrl: string;
crossorigin: boolean;
loaded: boolean;
url: string;
listeners(eventName: string): Function[];
emit(eventName: string, data?: any): boolean;
dispatchEvent(eventName: string, data?: any): boolean;
on(eventName: string, fn: Function): Function;
addEventListener(eventName: string, fn: Function): Function;
once(eventName: string, fn: Function): Function;
off(eventName: string, fn: Function): Function;
removeAllEventListeners(eventName: string): void;
load(): void;
}
export class Matrix {
a: number;
b: number;
c: number;
d: number;
tx: number;
ty: number;
append(matrix: Matrix): Matrix;
apply(pos: Point, newPos: Point): Point;
applyInverse(pos: Point, newPos: Point): Point;
determineMatrixArrayType(): number[];
identity(): Matrix;
rotate(angle: number): Matrix;
fromArray(array: number[]): void;
translate(x: number, y: number): Matrix;
toArray(transpose: boolean): number[];
scale(x: number, y: number): Matrix;
}
export interface Mixin {
listeners(eventName: string): Function[];
emit(eventName: string, data?: any): boolean;
dispatchEvent(eventName: string, data?: any): boolean;
on(eventName: string, fn: Function): Function;
addEventListener(eventName: string, fn: Function): Function;
once(eventName: string, fn: Function): Function;
off(eventName: string, fn: Function): Function;
removeAllEventListeners(eventName: string): void;
}
export class MovieClip extends Sprite {
static fromFrames(frames: string[]): MovieClip;
static fromImages(images: HTMLImageElement[]): HTMLImageElement;
constructor(textures: Texture[]);
animationSpeed: number;
currentFrame: number;
loop: boolean;
playing: boolean;
textures: Texture[];
totalFrames: number;
gotoAndPlay(frameNumber: number): void;
gotoAndStop(frameNumber: number): void;
onComplete(): void;
play(): void;
stop(): void;
}
export class NoiseFilter extends AbstractFilter {
noise: number;
}
export class NormalMapFilter extends AbstractFilter {
map: Texture;
offset: Point;
scale: Point;
}
export class PixelateFilter extends AbstractFilter {
size: number;
}
export interface IPixiShader {
fragmentSrc: string[];
gl: WebGLRenderingContext;
program: WebGLProgram;
vertexSrc: string[];
destroy(): void;
init(): void;
}
export class PixiShader implements IPixiShader {
/**
*
*
* @param gl the current WebGL drawing context
*/
constructor(gl: WebGLRenderingContext);
/**
* Uniform attributes cache.
*/
attributes: ShaderAttribute[];
/**
* The Default Vertex shader source.
*/
defaultVertexSrc: string[];
/**
* A dirty flag
*/
dirty: boolean;
/**
* A local flag
*/
firstRun: boolean;
/**
* A local texture counter for multi-texture shaders.
*/
textureCount: number;
/**
* The fragment shader.
*/
fragmentSrc: string[];
gl: WebGLRenderingContext;
/**
* The WebGL program.
*/
program: WebGLProgram;
vertexSrc: string[];
/**
* Initialises a Sampler2D uniform (which may only be available later on after initUniforms once the texture has loaded)
*/
initSampler2D(): void;
/**
* Initialises the shader uniform values.
*
* Uniforms are specified in the GLSL_ES Specification: http://www.khronos.org/registry/webgl/specs/latest/1.0/
* http://www.khronos.org/registry/gles/specs/2.0/GLSL_ES_Specification_1.0.17.pdf
*/
initUniforms(): void;
/**
* Updates the shader uniform values.
*/
syncUniforms(): void;
/**
* Destroys the shader.
*/
destroy(): void;
/**
* Initialises the shader.
*/
init(): void;
}
export class PixiFastShader implements IPixiShader {
/**
*
*
* @param gl the current WebGL drawing context
*/
constructor(gl: WebGLRenderingContext);
/**
* A local texture counter for multi-texture shaders.
*/
textureCount: number;
/**
* The fragment shader.
*/
fragmentSrc: string[];
gl: WebGLRenderingContext;
/**
* The WebGL program.
*/
program: WebGLProgram;
/**
* The vertex shader.
*/
vertexSrc: string[];
/**
* Destroys the shader.
*/
destroy(): void;
/**
* Initialises the shader.
*/
init(): void;
}
export class PrimitiveShader implements IPixiShader {
/**
*
*
* @param gl the current WebGL drawing context
*/
constructor(gl: WebGLRenderingContext);
/**
* The fragment shader.
*/
fragmentSrc: string[];
gl: WebGLRenderingContext;
/**
* The WebGL program.
*/
program: WebGLProgram;
/**
* The vertex shader.
*/
vertexSrc: string[];
/**
* Destroys the shader.
*/
destroy(): void;
/**
* Initialises the shader.
*/
init(): void;
}
export class ComplexPrimitiveShader implements IPixiShader {
/**
*
*
* @param gl the current WebGL drawing context
*/
constructor(gl: WebGLRenderingContext);
/**
* The fragment shader.
*/
fragmentSrc: string[];
gl: WebGLRenderingContext;
/**
* The WebGL program.
*/
program: WebGLProgram;
/**
* The vertex shader.
*/
vertexSrc: string[];
/**
* Destroys the shader.
*/
destroy(): void;
/**
* Initialises the shader.
*/
init(): void;
}
export class StripShader implements IPixiShader {
/**
*
*
* @param gl the current WebGL drawing context
*/
constructor(gl: WebGLRenderingContext);
/**
* The fragment shader.
*/
fragmentSrc: string[];
gl: WebGLRenderingContext;
/**
* The WebGL program.
*/
program: WebGLProgram;
/**
* The vertex shader.
*/
vertexSrc: string[];
/**
* Destroys the shader.
*/
destroy(): void;
/**
* Initialises the shader.
*/
init(): void;
}
export class Point {
constructor(x?: number, y?: number);
x: number;
y: number;
clone(): Point;
set(x: number, y: number): void;
}
export class Polygon implements HitArea {
constructor(points: Point[]);
constructor(points: number[]);
constructor(...points: Point[]);
constructor(...points: number[]);
points: any[]; //number[] Point[]
clone(): Polygon;
contains(x: number, y: number): boolean;
}
export class Rectangle implements HitArea {
constructor(x?: number, y?: number, width?: number, height?: number);
x: number;
y: number;
width: number;
height: number;
clone(): Rectangle;
contains(x: number, y: number): boolean;
}
export class RGBSplitFilter extends AbstractFilter {
red: Point;
green: Point;
blue: Point;
}
export class Rope extends Strip {
points: Point[];
vertices: number[];
/**
*
*
* @param texture - The texture to use on the rope.
* @param points - An array of {PIXI.Point}.
*/
constructor(texture: Texture, points: Point[]);
refresh(): void;
setTexture(texture: Texture): void;
}
export class RoundedRectangle implements HitArea {
constructor(x?: number, y?: number, width?: number, height?: number, radius?: number);
x: number;
y: number;
width: number;
height: number;
radius: number;
clone(): RoundedRectangle;
contains(x: number, y: number): boolean;
}
export class SepiaFilter extends AbstractFilter {
sepia: number;
}
export class SmartBlurFilter extends AbstractFilter {
blur: number;
}
export class SpineLoader implements Mixin {
url: string;
crossorigin: boolean;
loaded: boolean;
constructor(url: string, crossOrigin: boolean);
listeners(eventName: string): Function[];
emit(eventName: string, data?: any): boolean;
dispatchEvent(eventName: string, data?: any): boolean;
on(eventName: string, fn: Function): Function;
addEventListener(eventName: string, fn: Function): Function;
once(eventName: string, fn: Function): Function;
off(eventName: string, fn: Function): Function;
removeAllEventListeners(eventName: string): void;
load(): void;
}
export class SpineTextureLoader {
constructor(basePath: string, crossorigin: boolean);
load(page: AtlasPage, file: string): void;
unload(texture: BaseTexture): void;
}
/**
* The Sprite object is the base for all textured objects that are rendered to the screen
*/
export class Sprite extends DisplayObjectContainer {
/**
* Helper function that creates a sprite that will contain a texture from the TextureCache based on the frameId
* The frame ids are created when a Texture packer file has been loaded
*
* @param frameId The frame Id of the texture in the cache
* @return A new Sprite using a texture from the texture cache matching the frameId
*/
static fromFrame(frameId: string): Sprite;
/**
* Helper function that creates a sprite that will contain a texture based on an image url
* If the image is not in the texture cache it will be loaded
*
* @param imageId The image url of the texture
* @return A new Sprite using a texture from the texture cache matching the image id
*/
static fromImage(url: string, crossorigin?: boolean, scaleMode?: scaleModes): Sprite;
/**
* The Sprite object is the base for all textured objects that are rendered to the screen
*
* @param texture The texture for this sprite
*
* A sprite can be created directly from an image like this :
* var sprite = new PIXI.Sprite.fromImage('assets/image.png');
* yourStage.addChild(sprite);
* then obviously don't forget to add it to the stage you have already created
*/
constructor(texture: Texture);
/**
* 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
*/
anchor: Point;
/**
* The blend mode to be applied to the sprite. Set to PIXI.blendModes.NORMAL to remove any blend mode.
* Default: PIXI.blendModes.NORMAL;
*/
blendMode: blendModes;
/**
* The shader that will be used to render the texture to the stage. Set to null to remove a current shader.
* Default: null
*/
shader: IPixiShader;
/**
* The texture that the sprite is using
*/
texture: Texture;
/**
* The tint applied to the sprite. This is a hex value. A value of 0xFFFFFF will remove any tint effect.
* Default: 0xFFFFFF
*/
tint: number;
/**
* Sets the texture of the sprite
*
* @param texture The PIXI texture that is displayed by the sprite
*/
setTexture(texture: Texture): void;
}
/**
* 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();
*
* stage.addChild(container);
*
* 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
*/
export class SpriteBatch extends DisplayObjectContainer {
/**
* 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();
*
* stage.addChild(container);
*
* 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 texture -
*/
constructor(texture?: Texture);
ready: boolean;
textureThing: Texture;
initWebGL(gl: WebGLRenderingContext): void;
}
export class SpriteSheetLoader implements Mixin {
constructor(url: string, crossorigin?: boolean);
baseUrl: string;
crossorigin: boolean;
frames: any;
texture: Texture;
url: string;
listeners(eventName: string): Function[];
emit(eventName: string, data?: any): boolean;
dispatchEvent(eventName: string, data?: any): boolean;
on(eventName: string, fn: Function): Function;
addEventListener(eventName: string, fn: Function): Function;
once(eventName: string, fn: Function): Function;
off(eventName: string, fn: Function): Function;
removeAllEventListeners(eventName: string): void;
load(): void;
}
/**
* A Stage represents the root of the display tree. Everything connected to the stage is rendered
*/
export class Stage extends DisplayObjectContainer {
/**
* A Stage represents the root of the display tree. Everything connected to the stage is rendered
*
* @param backgroundColor the background color of the stage, you have to pass this in is in hex format
* like: 0xFFFFFF for white
*
* Creating a stage is a mandatory process when you use Pixi, which is as simple as this :
* var stage = new PIXI.Stage(0xFFFFFF);
* where the parameter given is the background colour of the stage, in hex
* you will use this stage instance to add your sprites to it and therefore to the renderer
* Here is how to add a sprite to the stage :
* stage.addChild(sprite);
*/
constructor(backgroundColor: number);
interactionManager: InteractionManager;
getMousePosition(): Point;
/**
* Sets the background color for the stage
*
* @param backgroundColor the color of the background, easiest way to pass this in is in hex format
* like: 0xFFFFFF for white
*/
setBackgroundColor(backgroundColor: number): void;
setInteractionDelegate(domElement: HTMLElement): void;
}
export class Strip extends DisplayObjectContainer {
static DrawModes: {
TRIANGLE_STRIP: number;
TRIANGLES: number;
}
/**
*
*
* @param texture The texture to use
* @param width the width
* @param height the height
*/
constructor(texture: Texture);
/**
* The blend mode to be applied to the sprite. Set to PIXI.blendModes.NORMAL to remove any blend mode.
* Default: PIXI.blendModes.NORMAL;
*/
blendMode: number;
colors: number[];
/**
* Whether the strip is dirty or not
*/
dirty: boolean;
indices: number[];
/**
* Triangles in canvas mode are automatically antialiased, use this value to force triangles to overlap a bit with each other.
*/
canvasPadding: number;
/**
* The texture of the strip
*/
texture: Texture;
uvs: number[];
vertices: number[];
/**
* Returns the bounds of the mesh as a rectangle. The bounds calculation takes the worldTransform into account.
*
* @param matrix the transformation matrix of the sprite
* @return the framing rectangle
*/
getBounds(matrix?: Matrix): Rectangle;
}
/**
* A texture stores the information that represents an image or part of an image. It cannot be added
* to the display list directly. Instead use it as the texture for a PIXI.Sprite. If no frame is provided then the whole image is used.
*/
export class Texture implements Mixin {
static emptyTexture: Texture;
/**
* Helper function that creates a new a Texture based on the given canvas element.
*
* @param canvas The canvas element source of the texture
* @param scaleMode See {{#crossLink "PIXI/scaleModes:property"}}PIXI.scaleModes{{/crossLink}} for possible values
* @return Texture
*/
static fromCanvas(canvas: HTMLCanvasElement, scaleMode?: scaleModes): Texture;
/**
* Helper function that returns a Texture objected based on the given frame id.
* If the frame id is not in the texture cache an error will be thrown.
*
* @param frameId The frame id of the texture
* @return Texture
*/
static fromFrame(frameId: string): Texture;
/**
* Helper function that creates a Texture object from the given image url.
* If the image is not in the texture cache it will be created and loaded.
*
* @param imageUrl The image url of the texture
* @param crossorigin Whether requests should be treated as crossorigin
* @param scaleMode See {{#crossLink "PIXI/scaleModes:property"}}PIXI.scaleModes{{/crossLink}} for possible values
* @return Texture
*/
static fromImage(imageUrl: string, crossorigin?: boolean, scaleMode?: scaleModes): Texture;
/**
* Adds a texture to the global PIXI.TextureCache. This cache is shared across the whole PIXI object.
*
* @param texture The Texture to add to the cache.
* @param id The id that the texture will be stored against.
*/
static addTextureToCache(texture: Texture, id: string): void;
/**
* Remove a texture from the global PIXI.TextureCache.
*
* @param id The id of the texture to be removed
* @return The texture that was removed
*/
static removeTextureFromCache(id: string): Texture;
/**
* A texture stores the information that represents an image or part of an image. It cannot be added
* to the display list directly. Instead use it as the texture for a PIXI.Sprite. If no frame is provided then the whole image is used.
*
* @param baseTexture The base texture source to create the texture from
* @param frame The rectangle frame of the texture to show
* @param crop The area of original texture
* @param trim Trimmed texture rectangle
*/
constructor(baseTexture: BaseTexture, frame?: Rectangle, crop?: Rectangle, trim?: Rectangle);
/**
* The base texture that this texture uses.
*/
baseTexture: BaseTexture;
/**
* This is the area of the BaseTexture image to actually copy to the Canvas / WebGL when rendering,
* irrespective of the actual frame size or placement (which can be influenced by trimmed texture atlases)
*/
crop: Rectangle;
/**
* The frame specifies the region of the base texture that this texture uses
*/
frame: Rectangle;
/**
* The height of the Texture in pixels.
*/
height: number;
/**
* Does this Texture have any frame data assigned to it?
*/
noFrame: boolean;
/**
* This will let a renderer know that a texture has been updated (used mainly for webGL uv updates)
*/
requiresUpdate: boolean;
/**
* The texture trim data.
*/
trim: Point;
/**
* The width of the Texture in pixels.
*/
width: number;
scope: any;
/**
* This will let the renderer know if the texture is valid. If it's not then it cannot be rendered.
*/
valid: boolean;
listeners(eventName: string): Function[];
emit(eventName: string, data?: any): boolean;
dispatchEvent(eventName: string, data?: any): boolean;
on(eventName: string, fn: Function): Function;
addEventListener(eventName: string, fn: Function): Function;
once(eventName: string, fn: Function): Function;
off(eventName: string, fn: Function): Function;
removeAllEventListeners(eventName: string): void;
/**
* Destroys this texture
*
* @param destroyBase Whether to destroy the base texture as well
*/
destroy(destroyBase: boolean): void;
/**
* Specifies the region of the baseTexture that this texture will use.
*
* @param frame The frame of the texture to set it to
*/
setFrame(frame: Rectangle): void;
}
/**
* A tiling sprite is a fast way of rendering a tiling image
*/
export class TilingSprite extends Sprite {
/**
* A tiling sprite is a fast way of rendering a tiling image
*
* @param texture the texture of the tiling sprite
* @param width the width of the tiling sprite
* @param height the height of the tiling sprite
*/
constructor(texture: Texture, width: number, height: number);
/**
* The CanvasBuffer object that the tiled texture is drawn to.
*/
canvasBuffer: PIXI.CanvasBuffer;
/**
* The blend mode to be applied to the sprite
* Default: PIXI.blendModes.NORMAL;
*/
blendMode: number;
/**
* If true the TilingSprite will run generateTexture on its **next** render pass.
* This is set by the likes of Phaser.LoadTexture.setFrame.
* Default: true
*/
refreshTexture: boolean;
/**
* The texture that the sprite is using
*/
texture: Texture;
/**
* If enabled a green rectangle will be drawn behind the generated tiling texture, allowing you to visually
* debug the texture being used.
*/
textureDebug: boolean;
/**
* The tint applied to the sprite. This is a hex value
* Default: 0xFFFFFF
*/
tint: number;
/**
* The offset position of the image that is being tiled
*/
tilePosition: Point;
/**
* The Context fill pattern that is used to draw the TilingSprite in Canvas mode only (will be null in WebGL).
*/
tilePattern: PIXI.Texture;
/**
* The scaling of the image that is being tiled
*/
tileScale: Point;
/**
* A point that represents the scale of the texture object
*/
tileScaleOffset: Point;
/**
* Destroy this DisplayObject.
* Removes all references to transformCallbacks, its parent, the stage, filters, bounds, mask and cached Sprites.
*/
destroy(): void;
/**
*
*
* @param forcePowerOfTwo Whether we want to force the texture to be a power of two
*/
generateTilingTexture(forcePowerOfTwo?: boolean): void;
/**
* Sets the texture of the sprite
*
* @param texture The PIXI texture that is displayed by the sprite
*/
setTexture(texture: Texture): void;
}
export class TiltShiftFilter extends AbstractFilter {
blur: number;
gradientBlur: number;
start: number;
end: number;
}
export class TiltShiftXFilter extends AbstractFilter {
blur: number;
gradientBlur: number;
start: number;
end: number;
updateDelta(): void;
}
export class TiltShiftYFilter extends AbstractFilter {
blur: number;
gradientBlur: number;
start: number;
end: number;
updateDelta(): void;
}
export class TwistFilter extends AbstractFilter {
angle: number;
offset: Point;
radius: number;
}
export class VideoTexture extends BaseTexture {
static baseTextureFromVideo(video: HTMLVideoElement, scaleMode: number): BaseTexture;
static textureFromVideo(video: HTMLVideoElement, scaleMode: number): Texture;
static fromUrl(videoSrc: string, scaleMode?: number, autoPlay?: boolean, type?: string, loop?: boolean): Texture;
controls: boolean;
autoUpdate: boolean;
type: string;
changeSource(src: string, type: string, loop: boolean): void;
play(): void;
stop(): void;
destroy(): void;
updateBound(): void;
onPlayStart: () => void;
onPlayStop: () => void;
onCanPlay: (event: any) => void;
}
export class WebGLBlendModeManager {
currentBlendMode: number;
/**
* Destroys this object.
*/
destroy(): void;
/**
* Sets-up the given blendMode from WebGL's point of view.
*
* @param blendMode the blendMode, should be a Pixi const, such as PIXI.BlendModes.ADD
*/
setBlendMode(blendMode: number): boolean;
/**
* Sets the WebGL Context.
*
* @param gl the current WebGL drawing context
*/
setContext(gl: WebGLRenderingContext): void;
}
export class WebGLFastSpriteBatch {
constructor(gl: CanvasRenderingContext2D);
currentBatchSize: number;
currentBaseTexture: BaseTexture;
currentBlendMode: number;
renderSession: RenderSession;
drawing: boolean;
indexBuffer: any;
/**
* Index data
*/
indices: number[];
lastIndexCount: number;
matrix: Matrix;
maxSize: number;
shader: IPixiShader;
size: number;
vertexBuffer: any;
/**
* Vertex data
*/
vertices: number[];
vertSize: number;
end(): void;
/**
*
*
* @param spriteBatch -
* @param renderSession -
*/
begin(spriteBatch: SpriteBatch, renderSession: RenderSession): void;
destroy(removeView?: boolean): void;
flush(): void;
/**
*
*
* @param spriteBatch -
*/
render(spriteBatch: SpriteBatch): void;
/**
*
*
* @param sprite -
*/
renderSprite(sprite: Sprite): void;
/**
* Sets the WebGL Context.
*
* @param gl the current WebGL drawing context
*/
setContext(gl: WebGLRenderingContext): void;
start(): void;
stop(): void;
}
export class WebGLFilterManager {
filterStack: AbstractFilter[];
transparent: boolean;
offsetX: number;
offsetY: number;
/**
* Applies the filter to the specified area.
*
* @param filter the filter that needs to be applied
* @param filterArea TODO - might need an update
* @param width the horizontal range of the filter
* @param height the vertical range of the filter
*/
applyFilterPass(filter: AbstractFilter, filterArea: Texture, width: number, height: number): void;
/**
*
*
* @param renderSession -
* @param buffer -
*/
begin(renderSession: RenderSession, buffer: ArrayBuffer): void;
/**
* Destroys the filter and removes it from the filter stack.
*/
destroy(): void;
/**
* Initialises the shader buffers.
*/
initShaderBuffers(): void;
/**
* Removes the last filter from the filter stack and doesn't return it.
*/
popFilter(): void;
/**
* Applies the filter and adds it to the current filter stack.
*
* @param filterBlock the filter that will be pushed to the current filter stack
*/
pushFilter(filterBlock: FilterBlock): void;
/**
* Initialises the context and the properties.
*
* @param gl the current WebGL drawing context
*/
setContext(gl: WebGLRenderingContext): void;
}
/**
* A set of functions used by the webGL renderer to draw the primitive graphics data
*/
export class WebGLGraphics {
static graphicsDataPool: any[];
/**
* Renders the graphics object
*
* @param graphics -
* @param renderSession -
*/
static renderGraphics(graphics: Graphics, renderRession: RenderSession): void;
/**
* Updates the graphics object
*
* @param graphicsData The graphics object to update
* @param gl the current WebGL drawing context
*/
static updateGraphics(graphics: Graphics, gl: WebGLRenderingContext): void;
/**
*
*
* @param webGL -
* @param type -
*/
static switchMode(webGL: WebGLRenderingContext, type: number): any; //WebGLData
/**
* Builds a rectangle to draw
*
* @param graphicsData The graphics object containing all the necessary properties
* @param webGLData -
*/
static buildRectangle(graphicsData: GraphicsData, webGLData: any): void;
/**
* Builds a rounded rectangle to draw
*
* @param graphicsData The graphics object containing all the necessary properties
* @param webGLData -
*/
static buildRoundedRectangle(graphicsData: GraphicsData, webGLData: any): void;
/**
* Calculate the points for a quadratic bezier curve. (helper function..)
* Based on: https://stackoverflow.com/questions/785097/how-do-i-implement-a-bezier-curve-in-c
*
* @param fromX Origin point x
* @param fromY Origin point x
* @param cpX Control point x
* @param cpY Control point y
* @param toX Destination point x
* @param toY Destination point y
*/
static quadraticBezierCurve(fromX: number, fromY: number, cpX: number, cpY: number, toX: number, toY: number): number[];
/**
* Builds a circle to draw
*
* @param graphicsData The graphics object to draw
* @param webGLData -
*/
static buildCircle(graphicsData: GraphicsData, webGLData: any): void;
/**
* Builds a line to draw
*
* @param graphicsData The graphics object containing all the necessary properties
* @param webGLData -
*/
static buildLine(graphicsData: GraphicsData, webGLData: any): void;
/**
* Builds a complex polygon to draw
*
* @param graphicsData The graphics object containing all the necessary properties
* @param webGLData -
*/
static buildComplexPoly(graphicsData: GraphicsData, webGLData: any): void;
/**
* Builds a polygon to draw
*
* @param graphicsData The graphics object containing all the necessary properties
* @param webGLData -
*/
static buildPoly(graphicsData: GraphicsData, webGLData: any): boolean;
reset(): void;
upload(): void;
}
export class WebGLGraphicsData {
constructor(gl: WebGLRenderingContext);
gl: WebGLRenderingContext;
glPoints: any[];
color: number[];
points: any[];
indices: any[];
buffer: WebGLBuffer;
indexBuffer: WebGLBuffer;
mode: number;
alpha: number;
dirty: boolean;
reset(): void;
upload(): void;
}
export class WebGLMaskManager {
/**
* Destroys the mask stack.
*/
destroy(): void;
/**
* Removes the last filter from the filter stack and doesn't return it.
*
* @param maskData -
* @param renderSession an object containing all the useful parameters
*/
popMask(renderSession: RenderSession): void;
/**
* Applies the Mask and adds it to the current filter stack.
*
* @param maskData -
* @param renderSession -
*/
pushMask(maskData: any[], renderSession: RenderSession): void;
/**
* Sets the drawing context to the one given in parameter.
*
* @param gl the current WebGL drawing context
*/
setContext(gl: WebGLRenderingContext): void;
}
/**
* The WebGLRenderer draws the stage and all its content onto a webGL enabled canvas. This renderer
* should be used for browsers that support webGL. This Render works by automatically managing webGLBatchs.
* So no need for Sprite Batches or Sprite Clouds.
* Don't forget to add the view to your DOM or you will not see anything :)
*/
export class WebGLRenderer implements PixiRenderer {
static createWebGLTexture(texture: Texture, gl: WebGLRenderingContext): void;
/**
* The WebGLRenderer draws the stage and all its content onto a webGL enabled canvas. This renderer
* should be used for browsers that support webGL. This Render works by automatically managing webGLBatchs.
* So no need for Sprite Batches or Sprite Clouds.
* Don't forget to add the view to your DOM or you will not see anything :)
*
* @param width the width of the canvas view - Default: 0
* @param height the height of the canvas view - Default: 0
* @param options The optional renderer parameters
*/
constructor(width?: number, height?: number, options?: PixiRendererOptions);
/**
* Whether the render view should be resized automatically
*/
autoResize: boolean;
/**
* This sets if the WebGLRenderer will clear the context texture or not before the new render pass. If true:
* If the Stage is NOT transparent, Pixi will clear to alpha (0, 0, 0, 0).
* If the Stage is transparent, Pixi will clear to the target Stage's background color.
* Disable this by setting this to false. For example: if your game has a canvas filling background image, you often don't need this set.
*/
clearBeforeRender: boolean;
contextLost: boolean;
contextLostBound: Function;
contextRestoreLost: boolean;
contextRestoredBound: Function;
/**
* The height of the canvas view
* Default: 600
*/
height: number;
gl: WebGLRenderingContext;
offset: Point;
/**
* The value of the preserveDrawingBuffer flag affects whether or not the contents of the stencil buffer is retained after rendering.
*/
preserveDrawingBuffer: boolean;
projection: Point;
/**
* The resolution of the renderer
* Default: 1
*/
resolution: number;
/**
* TODO remove
*/
renderSession: RenderSession;
/**
* Deals with managing the shader programs and their attribs
*/
shaderManager: WebGLShaderManager;
/**
* Manages the rendering of sprites
*/
spriteBatch: WebGLSpriteBatch;
/**
* Manages the masks using the stencil buffer
*/
maskManager: WebGLMaskManager;
/**
* Manages the filters
*/
filterManager: WebGLFilterManager;
/**
* Manages the stencil buffer
*/
stencilManager: WebGLStencilManager;
/**
* Manages the blendModes
*/
blendModeManager: WebGLBlendModeManager;
/**
* Whether the render view is transparent
*/
transparent: boolean;
type: number;
/**
* The canvas element that everything is drawn to
*/
view: HTMLCanvasElement;
/**
* The width of the canvas view
* Default: 800
*/
width: number;
/**
* Removes everything from the renderer (event listeners, spritebatch, etc...)
*/
destroy(): void;
initContext(): void;
/**
* Maps Pixi blend modes to WebGL blend modes.
*/
mapBlendModes(): void;
/**
* Renders the stage to its webGL view
*
* @param stage the Stage element to be rendered
*/
render(stage: Stage): void;
/**
* Renders a Display Object.
*
* @param displayObject The DisplayObject to render
* @param projection The projection
* @param buffer a standard WebGL buffer
*/
renderDisplayObject(displayObject: DisplayObject, projection: Point, buffer: WebGLBuffer): void;
/**
* Resizes the webGL view to the specified width and height.
*
* @param width the new width of the webGL view
* @param height the new height of the webGL view
*/
resize(width: number, height: number): void;
/**
* Updates and Creates a WebGL texture for the renderers context.
*
* @param texture the texture to update
*/
updateTexture(texture: Texture): void;
}
export class WebGLShaderManager {
maxAttibs: number;
attribState: any[];
stack: any[];
tempAttribState: any[];
/**
* Destroys this object.
*/
destroy(): void;
/**
* Takes the attributes given in parameters.
*
* @param attribs attribs
*/
setAttribs(attribs: ShaderAttribute[]): void;
/**
* Initialises the context and the properties.
*
* @param gl the current WebGL drawing context
*/
setContext(gl: WebGLRenderingContext): void;
/**
* Sets the current shader.
*
* @param shader -
*/
setShader(shader: IPixiShader): boolean;
}
export class WebGLStencilManager {
stencilStack: any[];
reverse: boolean;
count: number;
/**
* TODO this does not belong here!
*
* @param graphics -
* @param webGLData -
* @param renderSession -
*/
bindGraphics(graphics: Graphics, webGLData: any[], renderSession: RenderSession): void;
/**
* Destroys the mask stack.
*/
destroy(): void;
/**
*
*
* @param graphics -
* @param webGLData -
* @param renderSession -
*/
popStencil(graphics: Graphics, webGLData: any[], renderSession: RenderSession): void;
pushStencil(graphics: Graphics, webGLData: any[], renderSession: RenderSession): void;
/**
* Sets the drawing context to the one given in parameter.
*
* @param gl the current WebGL drawing context
*/
setContext(gl: WebGLRenderingContext): void;
}
export class WebGLSpriteBatch {
blendModes: number[];
/**
* View on the vertices as a Uint32Array
*/
colors: number[];
currentBatchSize: number;
currentBaseTexture: Texture;
defaultShader: AbstractFilter;
dirty: boolean;
drawing: boolean;
/**
* Holds the indices
*/
indices: number[];
lastIndexCount: number;
/**
* View on the vertices as a Float32Array
*/
positions: number[];
textures: Texture[];
shaders: IPixiShader[];
/**
* The number of images in the SpriteBatch before it flushes
*/
size: number;
sprites: any[]; //todo Sprite[]?
/**
* Holds the vertices
*/
vertices: number[];
vertSize: number;
/**
*
*
* @param renderSession The RenderSession object
*/
begin(renderSession: RenderSession): void;
/**
* Destroys the SpriteBatch.
*/
destroy(): void;
end(): void;
/**
* Renders the content and empties the current batch.
*/
flush(shader?: IPixiShader): void;
/**
*
*
* @param sprite the sprite to render when using this spritebatch
* @param matrix - Optional matrix. If provided the Display Object will be rendered using this matrix, otherwise it will use its worldTransform.
*/
render(sprite: Sprite): void;
/**
*
*
* @param texture -
* @param size -
* @param startIndex -
*/
renderBatch(texture: Texture, size: number, startIndex: number): void;
/**
* Renders a TilingSprite using the spriteBatch.
*
* @param sprite the sprite to render
*/
renderTilingSprite(sprite: TilingSprite): void;
setBlendMode(blendMode: blendModes): void;
/**
*
*
* @param gl the current WebGL drawing context
*/
setContext(gl: WebGLRenderingContext): void;
start(): void;
stop(): void;
}
/**
* A RenderTexture is a special texture that allows any Pixi display object to be rendered to it.
*
* __Hint__: All DisplayObjects (i.e. Sprites) that render to a RenderTexture should be preloaded otherwise black rectangles will be drawn instead.
*
* A RenderTexture takes a snapshot of any Display Object given to its render method. The position and rotation of the given Display Objects is ignored. For example:
*
* var renderTexture = new PIXI.RenderTexture(800, 600);
* var sprite = PIXI.Sprite.fromImage("spinObj_01.png");
* sprite.position.x = 800/2;
* sprite.position.y = 600/2;
* sprite.anchor.x = 0.5;
* sprite.anchor.y = 0.5;
* renderTexture.render(sprite);
*
* The Sprite in this case will be rendered to a position of 0,0. To render this sprite at its actual position a DisplayObjectContainer should be used:
*
* var doc = new PIXI.DisplayObjectContainer();
* doc.addChild(sprite);
* renderTexture.render(doc); // Renders to center of renderTexture
*/
export class RenderTexture extends Texture {
/**
* A RenderTexture is a special texture that allows any Pixi display object to be rendered to it.
*
* __Hint__: All DisplayObjects (i.e. Sprites) that render to a RenderTexture should be preloaded otherwise black rectangles will be drawn instead.
*
* A RenderTexture takes a snapshot of any Display Object given to its render method. The position and rotation of the given Display Objects is ignored. For example:
*
* var renderTexture = new PIXI.RenderTexture(800, 600);
* var sprite = PIXI.Sprite.fromImage("spinObj_01.png");
* sprite.position.x = 800/2;
* sprite.position.y = 600/2;
* sprite.anchor.x = 0.5;
* sprite.anchor.y = 0.5;
* renderTexture.render(sprite);
*
* The Sprite in this case will be rendered to a position of 0,0. To render this sprite at its actual position a DisplayObjectContainer should be used:
*
* var doc = new PIXI.DisplayObjectContainer();
* doc.addChild(sprite);
* renderTexture.render(doc); // Renders to center of renderTexture
*
* @param width The width of the render texture
* @param height The height of the render texture
* @param renderer The renderer used for this RenderTexture
* @param scaleMode See {{#crossLink "PIXI/scaleModes:property"}}PIXI.scaleModes{{/crossLink}} for possible values
* @param resolution The resolution of the texture being generated
*/
constructor(width?: number, height?: number, renderer?: PixiRenderer, scaleMode?: scaleModes, resolution?: number);
/**
* The framing rectangle of the render texture
*/
frame: Rectangle;
/**
* The base texture object that this texture uses
*/
baseTexture: BaseTexture;
/**
* The renderer this RenderTexture uses. A RenderTexture can only belong to one renderer at the moment if its webGL.
*/
renderer: PixiRenderer;
/**
* The Resolution of the texture.
*/
resolution: number;
valid: boolean;
/**
* Clears the RenderTexture.
*/
clear(): void;
/**
* Will return a base64 encoded string of this texture. It works by calling RenderTexture.getCanvas and then running toDataURL on that.
* @return A base64 encoded string of the texture.
*/
getBase64(): string;
/**
* Creates a Canvas element, renders this RenderTexture to it and then returns it.
* @return A Canvas element with the texture rendered on.
*/
getCanvas(): HTMLCanvasElement;
/**
* Will return a HTML Image of the texture
*/
getImage(): HTMLImageElement;
/**
* Resizes the RenderTexture.
*
* @param width The width to resize to.
* @param height The height to resize to.
* @param updateBase Should the baseTexture.width and height values be resized as well?
*/
resize(width: number, height: number, updateBase: boolean): void;
render(displayObject: DisplayObject, matrix?: Matrix, clear?: boolean): void;
}
//SPINE
export class BoneData {
constructor(name: string, parent?: any);
name: string;
parent: any;
length: number;
x: number;
y: number;
rotation: number;
scaleX: number;
scaleY: number;
}
export class SlotData {
constructor(name: string, boneData: BoneData);
name: string;
boneData: BoneData;
r: number;
g: number;
b: number;
a: number;
attachmentName: string;
}
export class Bone {
constructor(boneData: BoneData, parent?: any);
data: BoneData;
parent: any;
yDown: boolean;
x: number;
y: number;
rotation: number;
scaleX: number;
scaleY: number;
worldRotation: number;
worldScaleX: number;
worldScaleY: number;
updateWorldTransform(flipX: boolean, flip: boolean): void;
setToSetupPose(): void;
}
export class Slot {
constructor(slotData: SlotData, skeleton: Skeleton, bone: Bone);
data: SlotData;
skeleton: Skeleton;
bone: Bone;
r: number;
g: number;
b: number;
a: number;
attachment: RegionAttachment;
setAttachment(attachment: RegionAttachment): void;
setAttachmentTime(time: number): void;
getAttachmentTime(): number;
setToSetupPose(): void;
}
export class Skin {
constructor(name: string);
name: string;
attachments: any;
addAttachment(slotIndex: number, name: string, attachment: RegionAttachment): void;
getAttachment(slotIndex: number, name: string): void;
}
export class Animation {
constructor(name: string, timelines: ISpineTimeline[], duration: number);
name: string;
timelines: ISpineTimeline[];
duration: number;
apply(skeleton: Skeleton, time: number, loop: boolean): void;
min(skeleton: Skeleton, time: number, loop: boolean, alpha: number): void;
}
export class Curves {
constructor(frameCount: number);
curves: number[];
setLinear(frameIndex: number): void;
setStepped(frameIndex: number): void;
setCurve(frameIndex: number, cx1: number, cy1: number, cx2: number, cy2: number): void;
getCurvePercent(frameIndex: number, percent: number): number;
}
export interface ISpineTimeline {
curves: Curves;
frames: number[];
getFrameCount(): number;
apply(skeleton: Skeleton, time: number, alpha: number): void;
}
export class RotateTimeline implements ISpineTimeline {
constructor(frameCount: number);
curves: Curves;
frames: number[];
boneIndex: number;
getFrameCount(): number;
setFrame(frameIndex: number, time: number, angle: number): void;
apply(skeleton: Skeleton, time: number, alpha: number): void;
}
export class TranslateTimeline implements ISpineTimeline {
constructor(frameCount: number);
curves: Curves;
frames: number[];
boneIndex: number;
getFrameCount(): number;
setFrame(frameIndex: number, time: number, x: number, y: number): void;
apply(skeleton: Skeleton, time: number, alpha: number): void;
}
export class ScaleTimeline implements ISpineTimeline {
constructor(frameCount: number);
curves: Curves;
frames: number[];
boneIndex: number;
getFrameCount(): number;
setFrame(frameIndex: number, time: number, x: number, y: number): void;
apply(skeleton: Skeleton, time: number, alpha: number): void;
}
export class ColorTimeline implements ISpineTimeline {
constructor(frameCount: number);
curves: Curves;
frames: number[];
boneIndex: number;
getFrameCount(): number;
setFrame(frameIndex: number, time: number, r: number, g: number, b: number, a: number): void;
apply(skeleton: Skeleton, time: number, alpha: number): void;
}
export class AttachmentTimeline implements ISpineTimeline {
constructor(frameCount: number);
curves: Curves;
frames: number[];
attachmentNames: string[];
slotIndex: number;
getFrameCount(): number;
setFrame(frameIndex: number, time: number, attachmentName: string): void;
apply(skeleton: Skeleton, time: number, alpha: number): void;
}
export class SkeletonData {
bones: Bone[];
slots: Slot[];
skins: Skin[];
animations: Animation[];
defaultSkin: Skin;
findBone(boneName: string): Bone;
findBoneIndex(boneName: string): number;
findSlot(slotName: string): Slot;
findSlotIndex(slotName: string): number;
findSkin(skinName: string): Skin;
findAnimation(animationName: string): Animation;
}
export class Skeleton {
constructor(skeletonData: SkeletonData);
data: SkeletonData;
bones: Bone[];
slots: Slot[];
drawOrder: any[];
x: number;
y: number;
skin: Skin;
r: number;
g: number;
b: number;
a: number;
time: number;
flipX: boolean;
flipY: boolean;
updateWorldTransform(): void;
setToSetupPose(): void;
setBonesToSetupPose(): void;
setSlotsToSetupPose(): void;
getRootBone(): Bone;
findBone(boneName: string): Bone;
fineBoneIndex(boneName: string): number;
findSlot(slotName: string): Slot;
findSlotIndex(slotName: string): number;
setSkinByName(skinName: string): void;
setSkin(newSkin: Skin): void;
getAttachmentBySlotName(slotName: string, attachmentName: string): RegionAttachment;
getAttachmentBySlotIndex(slotIndex: number, attachmentName: string): RegionAttachment;
setAttachment(slotName: string, attachmentName: string): void;
update(data: number): void;
}
export class RegionAttachment {
offset: number[];
uvs: number[];
x: number;
y: number;
rotation: number;
scaleX: number;
scaleY: number;
width: number;
height: number;
rendererObject: any;
regionOffsetX: number;
regionOffsetY: number;
regionWidth: number;
regionHeight: number;
regionOriginalWidth: number;
regionOriginalHeight: number;
setUVs(u: number, v: number, u2: number, v2: number, rotate: number): void;
updateOffset(): void;
computeVertices(x: number, y: number, bone: Bone, vertices: number[]): void;
}
export class AnimationStateData {
constructor(skeletonData: SkeletonData);
skeletonData: SkeletonData;
animationToMixTime: any;
defaultMix: number;
setMixByName(fromName: string, toName: string, duration: number): void;
setMix(from: string, to: string): number;
}
export class AnimationState {
constructor(stateData: any);
animationSpeed: number;
current: any;
previous: any;
currentTime: number;
previousTime: number;
currentLoop: boolean;
previousLoop: boolean;
mixTime: number;
mixDuration: number;
queue: Animation[];
update(delta: number): void;
apply(skeleton: any): void;
clearAnimation(): void;
setAnimation(animation: any, loop: boolean): void;
setAnimationByName(animationName: string, loop: boolean): void;
addAnimationByName(animationName: string, loop: boolean, delay: number): void;
addAnimation(animation: any, loop: boolean, delay: number): void;
isComplete(): number;
}
export class SkeletonJson {
constructor(attachmentLoader: AtlasAttachmentLoader);
attachmentLoader: AtlasAttachmentLoader;
scale: number;
readSkeletonData(root: any): SkeletonData;
readAttachment(skin: Skin, name: string, map: any): RegionAttachment;
readAnimation(name: string, map: any, skeletonData: SkeletonData): void;
readCurve(timeline: ISpineTimeline, frameIndex: number, valueMap: any): void;
toColor(hexString: string, colorIndex: number): number;
}
export class Atlas {
static FORMAT: {
alpha: number;
intensity: number;
luminanceAlpha: number;
rgb565: number;
rgba4444: number;
rgb888: number;
rgba8888: number;
}
static TextureFilter: {
nearest: number;
linear: number;
mipMap: number;
mipMapNearestNearest: number;
mipMapLinearNearest: number;
mipMapNearestLinear: number;
mipMapLinearLinear: number;
}
static textureWrap: {
mirroredRepeat: number;
clampToEdge: number;
repeat: number;
}
constructor(atlasText: string, textureLoader: AtlasLoader);
textureLoader: AtlasLoader;
pages: AtlasPage[];
regions: AtlasRegion[];
findRegion(name: string): AtlasRegion;
dispose(): void;
updateUVs(page: AtlasPage): void;
}
export class AtlasPage {
name: string;
format: number;
minFilter: number;
magFilter: number;
uWrap: number;
vWrap: number;
rendererObject: any;
width: number;
height: number;
}
export class AtlasRegion {
page: AtlasPage;
name: string;
x: number;
y: number;
width: number;
height: number;
u: number;
v: number;
u2: number;
v2: number;
offsetX: number;
offsetY: number;
originalWidth: number;
originalHeight: number;
index: number;
rotate: boolean;
splits: any[];
pads: any[];
}
export class AtlasReader {
constructor(text: string);
lines: string[];
index: number;
trim(value: string): string;
readLine(): string;
readValue(): string;
readTuple(tuple: number): number;
}
export class AtlasAttachmentLoader {
constructor(atlas: Atlas);
atlas: Atlas;
newAttachment(skin: Skin, type: number, name: string): RegionAttachment;
}
export class Spine extends DisplayObjectContainer {
constructor(url: string);
autoUpdate: boolean;
spineData: any;
skeleton: Skeleton;
stateData: AnimationStateData;
state: AnimationState;
slotContainers: DisplayObjectContainer[];
createSprite(slot: Slot, descriptor: { name: string }): Sprite[];
update(dt: number): void;
}
}
declare function requestAnimFrame(callback: Function): void;
declare module PIXI.PolyK {
export function Triangulate(p: number[]): number[];
}
Reference in a new issue View git blame Copy permalink