verbkit
Version:
verbkit game toolkit
1,475 lines (1,127 loc) • 61.5 kB
TypeScript
// Type definitions for Pixi.js v3.0.10-dev
// Project: https://github.com/GoodBoyDigital/pixi.js/
// Definitions by: clark-stevenson <https://github.com/pixijs/pixi-typescript>
// Definitions: https://github.com/borisyankov/DefinitelyTyped
declare module PIXI {
export var VERSION: string;
export var PI_2: number;
export var RAD_TO_DEG: number;
export var DEG_TO_RAD: number;
export var TARGET_FPMS: number;
export var RENDERER_TYPE: {
UNKNOWN: number;
WEBGL: number;
CANVAS: number;
};
export var BLEND_MODES: {
NORMAL: number;
ADD: number;
MULTIPLY: number;
SCREEN: number;
OVERLAY: number;
DARKEN: number;
LIGHTEN: number;
COLOR_DODGE: number;
COLOR_BURN: number;
HARD_LIGHT: number;
SOFT_LIGHT: number;
DIFFERENCE: number;
EXCLUSION: number;
HUE: number;
SATURATION: number;
COLOR: number;
LUMINOSITY: number;
};
export var DRAW_MODES: {
POINTS: number;
LINES: number;
LINE_LOOP: number;
LINE_STRIP: number;
TRIANGLES: number;
TRIANGLE_STRIP: number;
TRIANGLE_FAN: number;
};
export var SCALE_MODES: {
DEFAULT: number;
LINEAR: number;
NEAREST: number;
};
export var RETINA_PREFIX: string;
export var RESOLUTION: number;
export var FILTER_RESOLUTION: number;
export var DEFAULT_RENDER_OPTIONS: {
view: HTMLCanvasElement;
resolution: number;
antialias: boolean;
forceFXAA: boolean;
autoResize: boolean;
transparent: boolean;
backgroundColor: number;
clearBeforeRender: boolean;
preserveDrawingBuffer: boolean;
roundPixels: boolean;
};
export var SHAPES: {
POLY: number;
RECT: number;
CIRC: number;
ELIP: number;
RREC: number;
};
export var SPRITE_BATCH_SIZE: number;
export function autoDetectRenderer(width: number, height: number, options?: PIXI.RendererOptions, noWebGL?: boolean): PIXI.WebGLRenderer | PIXI.CanvasRenderer;
export var loader: PIXI.loaders.Loader;
//////////////////////////////////////////////////////////////////////////////
////////////////////////////////CORE//////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
//accessibility
export class AccessibilityManager {
protected div: HTMLElement;
protected pool: HTMLElement[];
protected renderId: number;
protected children: DisplayObject[];
protected isActive: boolean;
debug: boolean;
renderer: PIXI.SystemRenderer;
constructor(renderer: PIXI.SystemRenderer);
protected activate(): void;
protected deactivate(): void;
protected updateAccessibleObjects(displayObject: DisplayObject): void;
protected update(): void;
protected capHitArea(hitArea: any): void;
protected addChild(displayObject: DisplayObject): void;
destroy(): void;
}
export interface AccessibleTarget {
//TODO Not 100% here.
//src/accessibility/accessibleTarget.js
}
//display
export class DisplayObject extends utils.EventEmitter implements interaction.InteractiveTarget {
//begin extras.cacheAsBitmap see https://github.com/pixijs/pixi-typescript/commit/1207b7f4752d79a088d6a9a465a3ec799906b1db
protected _originalRenderWebGL: WebGLRenderer;
protected _originalRenderCanvas: CanvasRenderer;
protected _originalUpdateTransform: boolean;
protected _originalHitTest: any;
protected _cachedSprite: any;
protected _originalDestroy: any;
cacheAsBitmap: boolean;
protected _renderCachedWebGL(renderer: WebGLRenderer): void;
protected _initCachedDisplayObject(renderer: WebGLRenderer): void;
protected _renderCachedCanvas(renderer: CanvasRenderer): void;
protected _initCachedDisplayObjectCanvas(renderer: CanvasRenderer): void;
protected _getCachedBounds(): Rectangle;
protected _destroyCachedDisplayObject(): void;
protected _cacheAsBitmapDestroy(): void;
//end extras.cacheAsBitmap
protected _sr: number;
protected _cr: number;
protected _bounds: Rectangle;
protected _currentBounds: Rectangle;
protected _mask: Rectangle;
protected _cachedObject: any;
updateTransform(): void;
position: Point;
scale: Point;
pivot: Point;
rotation: number;
renderable: boolean;
skew: Point;
alpha: number;
visible: boolean;
parent: Container;
worldAlpha: number;
worldTransform: Matrix;
filterArea: Rectangle;
x: number;
y: number;
worldVisible: boolean;
mask: Graphics | Sprite;
filters: AbstractFilter[];
name: string;
getBounds(matrix?: Matrix): Rectangle;
getLocalBounds(): Rectangle;
toGlobal(position: Point): Point;
toLocal(position: Point, from?: DisplayObject, to?: Point): Point;
generateTexture(renderer: CanvasRenderer | WebGLRenderer, scaleMode: number, resolution: number): Texture;
setParent(container: Container): Container;
setTransform(x?: number, y?: number, scaleX?: number, scaleY?: number, rotation?: number, skewX?: number, skewY?: number, pivotX?: number, pivotY?: number): DisplayObject;
destroy(): void;
getChildByName(name: string): DisplayObject;
getGlobalPosition(point: Point): Point;
interactive: boolean;
buttonMode: boolean;
interactiveChildren: boolean;
defaultCursor: string;
hitArea: HitArea;
on(event: 'click', fn: (event: interaction.InteractionEvent) => void, context?: any): utils.EventEmitter;
on(event: 'mousedown', fn: (event: interaction.InteractionEvent) => void, context?: any): utils.EventEmitter;
on(event: 'mouseout', fn: (event: interaction.InteractionEvent) => void, context?: any): utils.EventEmitter;
on(event: 'mouseover', fn: (event: interaction.InteractionEvent) => void, context?: any): utils.EventEmitter;
on(event: 'mouseup', fn: (event: interaction.InteractionEvent) => void, context?: any): utils.EventEmitter;
on(event: 'mouseclick', fn: (event: interaction.InteractionEvent) => void, context?: any): utils.EventEmitter;
on(event: 'mouseupoutside', fn: (event: interaction.InteractionEvent) => void, context?: any): utils.EventEmitter;
on(event: 'rightclick', fn: (event: interaction.InteractionEvent) => void, context?: any): utils.EventEmitter;
on(event: 'rightdown', fn: (event: interaction.InteractionEvent) => void, context?: any): utils.EventEmitter;
on(event: 'rightup', fn: (event: interaction.InteractionEvent) => void, context?: any): utils.EventEmitter;
on(event: 'rightupoutside', fn: (event: interaction.InteractionEvent) => void, context?: any): utils.EventEmitter;
on(event: 'tap', fn: (event: interaction.InteractionEvent) => void, context?: any): utils.EventEmitter;
on(event: 'touchend', fn: (event: interaction.InteractionEvent) => void, context?: any): utils.EventEmitter;
on(event: 'touchendoutside', fn: (event: interaction.InteractionEvent) => void, context?: any): utils.EventEmitter;
on(event: 'touchmove', fn: (event: interaction.InteractionEvent) => void, context?: any): utils.EventEmitter;
on(event: 'touchstart', fn: (event: interaction.InteractionEvent) => void, context?: any): utils.EventEmitter;
on(event: string, fn: Function, context?: any): utils.EventEmitter;
once(event: 'click', fn: (event: interaction.InteractionEvent) => void, context?: any): utils.EventEmitter;
once(event: 'mousedown', fn: (event: interaction.InteractionEvent) => void, context?: any): utils.EventEmitter;
once(event: 'mouseout', fn: (event: interaction.InteractionEvent) => void, context?: any): utils.EventEmitter;
once(event: 'mouseover', fn: (event: interaction.InteractionEvent) => void, context?: any): utils.EventEmitter;
once(event: 'mouseup', fn: (event: interaction.InteractionEvent) => void, context?: any): utils.EventEmitter;
once(event: 'mouseclick', fn: (event: interaction.InteractionEvent) => void, context?: any): utils.EventEmitter;
once(event: 'mouseupoutside', fn: (event: interaction.InteractionEvent) => void, context?: any): utils.EventEmitter;
once(event: 'rightclick', fn: (event: interaction.InteractionEvent) => void, context?: any): utils.EventEmitter;
once(event: 'rightdown', fn: (event: interaction.InteractionEvent) => void, context?: any): utils.EventEmitter;
once(event: 'rightup', fn: (event: interaction.InteractionEvent) => void, context?: any): utils.EventEmitter;
once(event: 'rightupoutside', fn: (event: interaction.InteractionEvent) => void, context?: any): utils.EventEmitter;
once(event: 'tap', fn: (event: interaction.InteractionEvent) => void, context?: any): utils.EventEmitter;
once(event: 'touchend', fn: (event: interaction.InteractionEvent) => void, context?: any): utils.EventEmitter;
once(event: 'touchendoutside', fn: (event: interaction.InteractionEvent) => void, context?: any): utils.EventEmitter;
once(event: 'touchmove', fn: (event: interaction.InteractionEvent) => void, context?: any): utils.EventEmitter;
once(event: 'touchstart', fn: (event: interaction.InteractionEvent) => void, context?: any): utils.EventEmitter;
once(event: string, fn: Function, context?: any): utils.EventEmitter;
}
export class Container extends DisplayObject {
protected _renderWebGL(renderer: WebGLRenderer): void;
protected _renderCanvas(renderer: CanvasRenderer): void;
protected onChildrenChange: () => void;
children: DisplayObject[];
width: number;
height: number;
addChild(child: DisplayObject): DisplayObject;
addChildAt(child: DisplayObject, index: number): DisplayObject;
swapChildren(child: DisplayObject, child2: DisplayObject): void;
getChildIndex(child: DisplayObject): number;
setChildIndex(child: DisplayObject, index: number): void;
getChildAt(index: number): DisplayObject;
removeChild(child: DisplayObject): DisplayObject;
removeChildAt(index: number): DisplayObject;
removeChildren(beginIndex?: number, endIndex?: number): DisplayObject[];
destroy(destroyChildren?: boolean): void;
generateTexture(renderer: PIXI.CanvasRenderer | PIXI.WebGLRenderer, resolution?: number, scaleMode?: number): Texture;
renderWebGL(renderer: WebGLRenderer): void;
renderCanvas(renderer: CanvasRenderer): void;
once(event: 'added', fn: (event: interaction.InteractionEvent) => void, context?: any): utils.EventEmitter;
once(event: string, fn: Function, context?: any): utils.EventEmitter;
once(event: 'removed', fn: (event: interaction.InteractionEvent) => void, context?: any): utils.EventEmitter;
once(event: string, fn: Function, context?: any): utils.EventEmitter;
on(event: 'added', fn: (event: interaction.InteractionEvent) => void, context?: any): utils.EventEmitter;
on(event: string, fn: Function, context?: any): utils.EventEmitter;
on(event: 'removed', fn: (event: interaction.InteractionEvent) => void, context?: any): utils.EventEmitter;
on(event: string, fn: Function, context?: any): utils.EventEmitter;
}
//graphics
export class GraphicsData {
constructor(lineWidth: number, lineColor: number, lineAlpha: number, fillColor: number, fillAlpha: number, fill: boolean, shape: Circle | Rectangle | Ellipse | Polygon);
lineWidth: number;
lineColor: number;
lineAlpha: number;
fillColor: number;
fillAlpha: number;
fill: boolean;
shape: Circle | Rectangle | Ellipse | Polygon;
type: number;
clone(): GraphicsData;
protected _lineTint: number;
protected _fillTint: number;
}
export class Graphics extends Container {
protected boundsDirty: boolean;
protected dirty: boolean;
protected glDirty: boolean;
fillAlpha: number;
lineWidth: number;
lineColor: number;
tint: number;
blendMode: number;
isMask: boolean;
boundsPadding: number;
clone(): Graphics;
lineStyle(lineWidth?: number, color?: number, alpha?: number): Graphics;
moveTo(x: number, y: number): Graphics;
lineTo(x: number, y: number): Graphics;
quadraticCurveTo(cpX: number, cpY: number, toX: number, toY: number): Graphics;
bezierCurveTo(cpX: number, cpY: number, cpX2: number, cpY2: number, toX: number, toY: number): Graphics;
arcTo(x1: number, y1: number, x2: number, y2: number, radius: number): Graphics;
arc(cx: number, cy: number, radius: number, startAngle: number, endAngle: number, anticlockwise?: boolean): Graphics;
beginFill(color: number, alpha?: number): Graphics;
endFill(): Graphics;
drawRect(x: number, y: number, width: number, height: number): Graphics;
drawRoundedRect(x: number, y: number, width: number, height: number, radius: number): Graphics;
drawCircle(x: number, y: number, radius: number): Graphics;
drawEllipse(x: number, y: number, width: number, height: number): Graphics;
drawPolygon(path: number[] | Point[]): Graphics;
clear(): Graphics;
//todo
generateTexture(renderer: WebGLRenderer | CanvasRenderer, resolution?: number, scaleMode?: number): Texture;
getBounds(matrix?: Matrix): Rectangle;
containsPoint(point: Point): boolean;
updateLocalBounds(): void;
drawShape(shape: Circle | Rectangle | Ellipse | Polygon): GraphicsData;
}
export class GraphicsRenderer extends ObjectRenderer {
new(renderer: PIXI.WebGLRenderer);
buildCircle: (graphicsData: PIXI.Graphics, webGLData: Object) => void;
buildPoly: (graphicsData: PIXI.Graphics, webGLData: Object) => boolean;
buildRectangle: (graphicsData: PIXI.Graphics, webGLData: Object) => void;
buildComplexPoly: (graphicsData: PIXI.Graphics, webGLData: Object) => void;
buildLine: (graphicsData: PIXI.Graphics, webGLData: Object) => void;
updateGraphics: (graphics: PIXI.Graphics) => void;
buildRoundedRectangle: (graphicsData: PIXI.Graphics, webGLData: Object) => void;
quadraticBezierCurve: (fromX: number, fromY: number, cpX: number, cpY: number, toX: number, toY: number, out: any) => number[];
switchMode: (webGL: WebGLRenderingContext, type: number) => WebGLGraphicsData;
}
export class WebGLGraphicsData {
new(gl: WebGLRenderingContext);
upload: () => void;
reset: () => void;
destroy: () => void;
}
//math
export class Point {
x: number;
y: number;
constructor(x?: number, y?: number);
clone(): Point;
copy(p: Point): void;
equals(p: Point): boolean;
set(x?: number, y?: number): void;
}
export class Matrix {
a: number;
b: number;
c: number;
d: number;
tx: number;
ty: number;
fromArray(array: number[]): void;
toArray(transpose?: boolean, out?: number[]): number[];
apply(pos: Point, newPos?: Point): Point;
applyInverse(pos: Point, newPos?: Point): Point;
translate(x: number, y: number): Matrix;
scale(x: number, y: number): Matrix;
rotate(angle: number): Matrix;
append(matrix: Matrix): Matrix;
prepend(matrix: Matrix): Matrix;
invert(): Matrix;
identity(): Matrix;
clone(): Matrix;
copy(matrix: Matrix): Matrix;
set(a: number, b: number, c: number, d: number, tx: number, ty: number): Matrix;
setTransform(a: number, b: number, c: number, d: number, sr: number, cr: number, cy: number, sy: number, nsx: number, cs: number): PIXI.Matrix;
static IDENTITY: Matrix;
static TEMP_MATRIX: Matrix;
}
export interface HitArea {
contains(x: number, y: number): boolean;
}
export class Circle implements HitArea {
constructor(x?: number, y?: number, radius?: number);
x: number;
y: number;
radius: number;
type: number;
clone(): Circle;
contains(x: number, y: number): boolean;
getBounds(): Rectangle;
}
export class Ellipse implements HitArea {
constructor(x?: number, y?: number, width?: number, height?: number);
x: number;
y: number;
width: number;
height: number;
type: number;
clone(): Ellipse;
contains(x: number, y: number): boolean;
getBounds(): Rectangle;
}
export class Polygon implements HitArea {
constructor(points: Point[]);
constructor(points: number[]);
constructor(...points: Point[]);
constructor(...points: number[]);
closed: boolean;
points: number[];
type: number;
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;
type: number;
static EMPTY: Rectangle;
clone(): Rectangle;
contains(x: number, y: number): boolean;
}
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;
type: number;
static EMPTY: Rectangle;
clone(): Rectangle;
contains(x: number, y: number): boolean;
}
//particles
export interface ParticleContainerProperties {
scale?: boolean;
position?: boolean;
rotation?: boolean;
uvs?: boolean;
alpha?: boolean;
}
export class ParticleContainer extends Container {
constructor(size?: number, properties?: ParticleContainerProperties, batchSize?: number);
protected _maxSize: number;
protected _batchSize: number;
protected _properties: boolean[];
protected _buffers: WebGLBuffer[];
protected _bufferToUpdate: number;
protected onChildrenChange: (smallestChildIndex?: number) => void;
interactiveChildren: boolean;
blendMode: number;
roundPixels: boolean;
setProperties(properties: ParticleContainerProperties): void;
}
export interface ParticleBuffer {
gl: WebGLRenderingContext;
vertSize: number;
vertByteSize: number;
size: number;
dynamicProperties: any[];
staticProperties: any[];
staticStride: number;
staticBuffer: any;
staticData: any;
dynamicStride: number;
dynamicBuffer: any;
dynamicData: any;
initBuffers(): void;
bind(): void;
destroy(): void;
}
export class ParticleRenderer extends ObjectRenderer {
new(renderer: PIXI.WebGLRenderer);
buildCircle: (graphicsData: PIXI.Graphics, webGLData: WebGLGraphicsData) => void;
buildPoly: (graphicsData: PIXI.Graphics, webGLData: WebGLGraphicsData) => boolean;
buildRectangle: (graphicsData: PIXI.Graphics, webGLData: WebGLGraphicsData) => void;
buildComplexPoly: (graphicsData: PIXI.Graphics, webGLData: WebGLGraphicsData) => void;
buildLine: (graphicsData: PIXI.Graphics, webGLData: WebGLGraphicsData) => void;
updateGraphics: (graphics: PIXI.Graphics) => void;
buildRoundedRectangle: (graphicsData: PIXI.Graphics, webGLData: WebGLGraphicsData) => void;
quadraticBezierCurve: (fromX: number, fromY: number, cpX: number, cpY: number, toX: number, toY: number, out: number[]) => number[];
switchMode: (webGL: WebGLRenderingContext, type: number) => WebGLGraphicsData;
}
export interface ParticleShader {
}
//renderers
export interface RendererOptions {
view?: HTMLCanvasElement;
transparent?: boolean;
antialias?: boolean;
resolution?: number;
clearBeforeRendering?: boolean;
preserveDrawingBuffer?: boolean;
forceFXAA?: boolean;
roundPixels?: boolean;
backgroundColor?: number;
}
export class SystemRenderer extends utils.EventEmitter {
protected _backgroundColor: number;
protected _backgroundColorRgb: number[];
protected _backgroundColorString: string;
protected _tempDisplayObjectParent: any;
protected _lastObjectRendered: DisplayObject;
constructor(system: string, width?: number, height?: number, options?: RendererOptions);
type: number;
width: number;
height: number;
view: HTMLCanvasElement;
resolution: number;
transparent: boolean;
autoResize: boolean;
blendModes: any; //todo?
preserveDrawingBuffer: boolean;
clearBeforeRender: boolean;
roundPixels: boolean;
backgroundColor: number;
render(object: DisplayObject): void;
resize(width: number, height: number): void;
destroy(removeView?: boolean): void;
}
export class CanvasRenderer extends SystemRenderer {
protected renderDisplayObject(displayObject: DisplayObject, context: CanvasRenderingContext2D): void;
protected _mapBlendModes(): void;
constructor(width?: number, height?: number, options?: RendererOptions);
context: CanvasRenderingContext2D;
refresh: boolean;
maskManager: CanvasMaskManager;
roundPixels: boolean;
smoothProperty: string;
render(object: DisplayObject): void;
resize(w: number, h: number): void;
}
export class CanvasBuffer {
protected clear(): void;
constructor(width: number, height: number);
canvas: HTMLCanvasElement;
context: CanvasRenderingContext2D;
width: number;
height: number;
resize(width: number, height: number): void;
destroy(): void;
}
export class CanvasGraphics {
static renderGraphicsMask(graphics: Graphics, context: CanvasRenderingContext2D): void;
static updateGraphicsTint(graphics: Graphics): void;
static renderGraphics(graphics: Graphics, context: CanvasRenderingContext2D): void;
}
export class CanvasMaskManager {
pushMask(maskData: any, renderer: WebGLRenderer | CanvasRenderer): void;
popMask(renderer: WebGLRenderer | CanvasRenderer): void;
destroy(): void;
}
export class CanvasTinter {
static getTintedTexture(sprite: DisplayObject, color: number): HTMLCanvasElement;
static tintWithMultiply(texture: Texture, color: number, canvas: HTMLDivElement): void;
static tintWithOverlay(texture: Texture, color: number, canvas: HTMLCanvasElement): void;
static tintWithPerPixel(texture: Texture, color: number, canvas: HTMLCanvasElement): void;
static roundColor(color: number): number;
static cacheStepsPerColorChannel: number;
static convertTintToImage: boolean;
static vanUseMultiply: boolean;
static tintMethod: Function;
}
export class WebGLRenderer extends SystemRenderer {
protected _useFXAA: boolean;
protected _FXAAFilter: FXAAFilter;
protected _contextOptions: {
alpha: boolean;
antiAlias: boolean;
premultipliedAlpha: boolean;
stencil: boolean;
preseveDrawingBuffer: boolean;
};
protected _renderTargetStack: RenderTarget[];
protected _initContext(): void;
protected _createContext(): void;
protected handleContextLost: (event: WebGLContextEvent) => void;
protected _mapGlModes(): void;
protected _managedTextures: Texture[];
constructor(width?: number, height?: number, options?: RendererOptions);
drawCount: number;
shaderManager: ShaderManager;
maskManager: MaskManager;
stencilManager: StencilManager;
filterManager: FilterManager;
blendModeManager: BlendModeManager;
currentRenderTarget: RenderTarget;
currentRenderer: ObjectRenderer;
render(object: DisplayObject): void;
renderDisplayObject(displayObject: DisplayObject, renderTarget: RenderTarget, clear: boolean): void;
setObjectRenderer(objectRenderer: ObjectRenderer): void;
setRenderTarget(renderTarget: RenderTarget): void;
updateTexture(texture: BaseTexture | Texture): BaseTexture | Texture;
destroyTexture(texture: BaseTexture | Texture, _skipRemove?: boolean): void;
}
export class AbstractFilter {
protected vertexSrc: string[];
protected fragmentSrc: string[];
constructor(vertexSrc?: string | string[], fragmentSrc?: string | string[], uniforms?: any);
uniforms: any;
padding: number;
getShader(renderer: WebGLRenderer): Shader;
applyFilter(renderer: WebGLRenderer, input: RenderTarget, output: RenderTarget, clear?: boolean): void;
syncUniform(uniform: WebGLUniformLocation): void;
}
export class SpriteMaskFilter extends AbstractFilter {
constructor(sprite: Sprite);
maskSprite: Sprite;
maskMatrix: Matrix;
applyFilter(renderer: WebGLRenderbuffer, input: RenderTarget, output: RenderTarget): void;
map: Texture;
offset: Point;
}
export class FXAAFilter extends AbstractFilter {
applyFilter(renderer: WebGLRenderer, input: RenderTarget, output: RenderTarget): void;
}
export class BlendModeManager extends WebGLManager {
constructor(renderer: WebGLRenderer);
setBlendMode(blendMode: number): boolean;
}
export class FilterManager extends WebGLManager {
constructor(renderer: WebGLRenderer);
filterStack: any[];
renderer: WebGLRenderer;
texturePool: any[];
onContextChange: () => void;
setFilterStack(filterStack: any[]): void;
pushFilter(target: RenderTarget, filters: any[]): void;
popFilter(): AbstractFilter;
getRenderTarget(clear?: boolean): RenderTarget;
protected returnRenderTarget(renderTarget: RenderTarget): void;
applyFilter(shader: Shader | AbstractFilter, inputTarget: RenderTarget, outputTarget: RenderTarget, clear?: boolean): void;
calculateMappedMatrix(filterArea: Rectangle, sprite: Sprite, outputMatrix?: Matrix): Matrix;
capFilterArea(filterArea: Rectangle): void;
resize(width: number, height: number): void;
destroy(): void;
}
export class MaskManager extends WebGLManager {
stencilStack: StencilMaskStack;
reverse: boolean;
count: number;
alphaMaskPool: any[];
pushMask(target: RenderTarget, maskData: any): void;
popMask(target: RenderTarget, maskData: any): void;
pushSpriteMask(target: RenderTarget, maskData: any): void;
popSpriteMask(): void;
pushStencilMask(target: RenderTarget, maskData: any): void;
popStencilMask(target: RenderTarget, maskData: any): void;
}
export class ShaderManager extends WebGLManager {
protected _currentId: number;
protected currentShader: Shader;
constructor(renderer: WebGLRenderer);
maxAttibs: number;
attribState: any[];
tempAttribState: any[];
stack: any[];
setAttribs(attribs: any[]): void;
setShader(shader: Shader): boolean;
destroy(): void;
}
export class StencilManager extends WebGLManager {
constructor(renderer: WebGLRenderer);
setMaskStack(stencilMaskStack: StencilMaskStack): void;
pushStencil(graphics: Graphics, webGLData: WebGLGraphicsData): void;
bindGraphics(graphics: Graphics, webGLData: WebGLGraphicsData): void;
popStencil(graphics: Graphics, webGLData: WebGLGraphicsData): void;
destroy(): void;
pushMask(maskData: any[]): void;
popMask(maskData: any[]): void;
}
export class WebGLManager {
protected onContextChange: () => void;
constructor(renderer: WebGLRenderer);
renderer: WebGLRenderer;
destroy(): void;
}
export class Shader {
protected attributes: any;
protected textureCount: number;
protected uniforms: any;
protected _glCompile(type: any, src: any): Shader;
constructor(shaderManager: ShaderManager, vertexSrc: string, fragmentSrc: string, uniforms: any, attributes: any);
uuid: number;
gl: WebGLRenderingContext;
shaderManager: ShaderManager;
program: WebGLProgram;
vertexSrc: string;
fragmentSrc: string;
init(): void;
cacheUniformLocations(keys: string[]): void;
cacheAttributeLocations(keys: string[]): void;
compile(): WebGLProgram;
syncUniform(uniform: any): void;
syncUniforms(): void;
initSampler2D(uniform: any): void;
destroy(): void;
}
export class ComplexPrimitiveShader extends Shader {
constructor(shaderManager: ShaderManager);
}
export class PrimitiveShader extends Shader {
constructor(shaderManager: ShaderManager);
}
export class TextureShader extends Shader {
constructor(shaderManager: ShaderManager, vertexSrc?: string, fragmentSrc?: string, customUniforms?: any, customAttributes?: any);
}
export interface StencilMaskStack {
stencilStack: any[];
reverse: boolean;
count: number;
}
export class ObjectRenderer extends WebGLManager {
start(): void;
stop(): void;
flush(): void;
render(object?: any): void;
}
export class RenderTarget {
constructor(gl: WebGLRenderingContext, width: number, height: number, scaleMode: number, resolution: number, root: boolean);
gl: WebGLRenderingContext;
frameBuffer: WebGLFramebuffer;
texture: Texture;
size: Rectangle;
resolution: number;
projectionMatrix: Matrix;
transform: Matrix;
frame: Rectangle;
stencilBuffer: WebGLRenderbuffer;
stencilMaskStack: StencilMaskStack;
filterStack: any[];
scaleMode: number;
root: boolean;
clear(bind?: boolean): void;
attachStencilBuffer(): void;
activate(): void;
calculateProjection(protectionFrame: Matrix): void;
resize(width: number, height: number): void;
destroy(): void;
}
export interface Quad {
gl: WebGLRenderingContext;
vertices: number[];
uvs: number[];
colors: number[];
indices: number[];
vertexBuffer: WebGLBuffer;
indexBuffer: WebGLBuffer;
map(rect: Rectangle, rect2: Rectangle): void;
upload(): void;
destroy(): void;
}
//sprites
export class Sprite extends Container {
static fromFrame(frameId: string): Sprite;
static fromImage(imageId: string, crossorigin?: boolean, scaleMode?: number): Sprite;
protected _texture: Texture;
protected _width: number;
protected _height: number;
protected cachedTint: number;
protected _onTextureUpdate(): void;
constructor(texture?: Texture);
anchor: Point;
tint: number;
blendMode: number;
shader: Shader | AbstractFilter;
texture: Texture;
width: number;
height: number;
getBounds(matrix?: Matrix): Rectangle;
getLocalBounds(): Rectangle;
containsPoint(point: Point): boolean;
destroy(destroyTexture?: boolean, destroyBaseTexture?: boolean): void;
}
export class SpriteRenderer extends ObjectRenderer {
protected renderBatch(texture: Texture, size: number, startIndex: number): void;
vertSize: number;
vertByteSize: number;
size: number;
vertices: number[];
positions: number[];
colors: number[];
indices: number[];
currentBatchSize: number;
sprites: Sprite[];
shader: Shader | AbstractFilter;
render(sprite: Sprite): void;
flush(): void;
start(): void;
destroy(): void;
}
//text
export interface TextStyle {
font?: string;
fill?: string | number;
align?: string;
stroke?: string | number;
strokeThickness?: number;
wordWrap?: boolean;
wordWrapWidth?: number;
lineHeight?: number;
dropShadow?: boolean;
dropShadowColor?: string | number;
dropShadowAngle?: number;
dropShadowDistance?: number;
dropShadowBlur?: number;
padding?: number;
textBaseline?: string;
lineJoin?: string;
miterLimit?: number;
}
export class Text extends Sprite {
static fontPropertiesCache: any;
static fontPropertiesCanvas: HTMLCanvasElement;
static fontPropertiesContext: CanvasRenderingContext2D;
protected _text: string;
protected _style: TextStyle;
protected updateText(): void;
protected updateTexture(): void;
protected determineFontProperties(fontStyle: TextStyle): TextStyle;
protected wordWrap(text: string): boolean;
constructor(text?: string, style?: TextStyle, resolution?: number);
canvas: HTMLCanvasElement;
context: CanvasRenderingContext2D;
dirty: boolean;
resolution: number;
text: string;
style: TextStyle;
width: number;
height: number;
}
//textures
export class BaseTexture extends utils.EventEmitter {
static fromImage(imageUrl: string, crossorigin?: boolean, scaleMode?: number): BaseTexture;
static fromCanvas(canvas: HTMLCanvasElement, scaleMode?: number): BaseTexture;
protected _glTextures: any;
protected _sourceLoaded(): void;
constructor(source: HTMLImageElement | HTMLCanvasElement, scaleMode?: number, resolution?: number);
uuid: number;
resolution: number;
width: number;
height: number;
realWidth: number;
realHeight: number;
scaleMode: number;
hasLoaded: boolean;
isLoading: boolean;
source: HTMLImageElement | HTMLCanvasElement | HTMLVideoElement;
premultipliedAlpha: boolean;
imageUrl: string;
isPowerOfTwo: boolean;
mipmap: boolean;
update(): void;
loadSource(source: HTMLImageElement | HTMLCanvasElement): void;
destroy(): void;
dispose(): void;
updateSourceImage(newSrc: string): void;
on(event: 'dispose', fn: (baseTexture: BaseTexture) => void, context?: any): utils.EventEmitter;
on(event: 'error', fn: (baseTexture: BaseTexture) => void, context?: any): utils.EventEmitter;
on(event: 'loaded', fn: (baseTexture: BaseTexture) => void, context?: any): utils.EventEmitter;
on(event: 'update', fn: (baseTexture: BaseTexture) => void, context?: any): utils.EventEmitter;
on(event: string, fn: Function, context?: any): utils.EventEmitter;
once(event: 'dispose', fn: (baseTexture: BaseTexture) => void, context?: any): utils.EventEmitter;
once(event: 'error', fn: (baseTexture: BaseTexture) => void, context?: any): utils.EventEmitter;
once(event: 'loaded', fn: (baseTexture: BaseTexture) => void, context?: any): utils.EventEmitter;
once(event: 'update', fn: (baseTexture: BaseTexture) => void, context?: any): utils.EventEmitter;
once(event: string, fn: Function, context?: any): utils.EventEmitter;
}
export class RenderTexture extends Texture {
protected renderWebGL(displayObject: DisplayObject, matrix?: Matrix, clear?: boolean, updateTransform?: boolean): void;
protected renderCanvas(displayObject: DisplayObject, matrix?: Matrix, clear?: boolean, updateTransform?: boolean): void;
constructor(renderer: CanvasRenderer | WebGLRenderer, width?: number, height?: number, scaleMode?: number, resolution?: number);
width: number;
height: number;
resolution: number;
renderer: CanvasRenderer | WebGLRenderer;
valid: boolean;
render(displayObject: DisplayObject, matrix?: Matrix, clear?: boolean, updateTransform?: boolean): void;
resize(width: number, height: number, updateBase?: boolean): void;
clear(): void;
destroy(): void;
getImage(): HTMLImageElement;
getPixels(): number[];
getPixel(x: number, y: number): number[];
getBase64(): string;
getCanvas(): HTMLCanvasElement;
}
export class Texture extends BaseTexture {
static fromImage(imageUrl: string, crossOrigin?: boolean, scaleMode?: number): Texture;
static fromFrame(frameId: string): Texture;
static fromCanvas(canvas: HTMLCanvasElement, scaleMode?: number): Texture;
static fromVideo(video: HTMLVideoElement | string, scaleMode?: number): Texture;
static fromVideoUrl(videoUrl: string, scaleMode?: number): Texture;
static addTextureToCache(texture: Texture, id: string): void;
static removeTextureFromCache(id: string): Texture;
static EMPTY: Texture;
protected _frame: Rectangle;
protected _uvs: TextureUvs;
protected onBaseTextureUpdated(baseTexture: BaseTexture): void;
protected onBaseTextureLoaded(baseTexture: BaseTexture): void;
protected _updateUvs(): void;
constructor(baseTexture: BaseTexture, frame?: Rectangle, crop?: Rectangle, trim?: Rectangle, rotate?: boolean);
noFrame: boolean;
baseTexture: BaseTexture;
trim: Rectangle;
valid: boolean;
requiresUpdate: boolean;
width: number;
height: number;
crop: Rectangle;
rotate: number;
frame: Rectangle;
update(): void;
destroy(destroyBase?: boolean): void;
clone(): Texture;
}
export class TextureUvs {
x0: number;
y0: number;
x1: number;
y1: number;
x2: number;
y2: number;
x3: number;
y3: number;
set(frame: Rectangle, baseFrame: Rectangle, rotate: number): void;
}
export class VideoBaseTexture extends BaseTexture {
static fromVideo(video: HTMLVideoElement, scaleMode?: number): VideoBaseTexture;
static fromUrl(videoSrc: string | any | string[] | any[]): VideoBaseTexture;
protected _loaded: boolean;
protected _onUpdate(): void;
protected _onPlayStart(): void;
protected _onPlayStop(): void;
protected _onCanPlay(): void;
constructor(source: HTMLVideoElement, scaleMode?: number);
autoUpdate: boolean;
destroy(): void;
}
//utils
export module utils {
export function uuid(): number;
export function hex2rgb(hex: number, out?: number[]): number[];
export function hex2String(hex: number): string;
export function rgb2hex(rgb: Number[]): number;
export function canUseNewCanvasBlendModel(): boolean;
export function getNextPowerOfTwo(number: number): number;
export function isPowerOfTwo(width: number, height: number): boolean;
export function getResolutionOfUrl(url: string): number;
export function sayHello(type: string): void;
export function isWebGLSupported(): boolean;
export function sign(n: number): number;
export function removeItems<T>(arr: T[], startIdx: number, removeCount: number): void;
export var TextureCache: any;
export var BaseTextureCache: any;
//https://github.com/primus/eventemitter3
export class EventEmitter {
listeners(event: string): Function[];
emit(event: string, ...args: any[]): boolean;
on(event: string, fn: Function, context?: any): EventEmitter;
once(event: string, fn: Function, context?: any): EventEmitter;
removeListener(event: string, fn: Function, context?: any, once?: boolean): EventEmitter;
removeAllListeners(event: string): EventEmitter;
off(event: string, fn: Function, context?: any, once?: boolean): EventEmitter;
addListener(event: string, fn: Function, context?: any): EventEmitter;
}
}
//////////////////////////////////////////////////////////////////////////////
////////////////////////////EXTRAS////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
export module extras {
export interface BitmapTextStyle {
font?: string | {
name?: string;
size?: number;
};
align?: string;
tint?: number;
}
export class BitmapText extends Container {
static fonts: any;
protected _glyphs: Sprite[];
protected _font: string | {
tint: number;
align: string;
name: string;
size: number;
};
protected _text: string;
protected updateText(): void;
constructor(text: string, style?: BitmapTextStyle);
textWidth: number;
textHeight: number;
maxWidth: number;
maxLineHeight: number;
dirty: boolean;
tint: number;
align: string;
font: string | {
tint: number;
align: string;
name: string;
size: number;
};
text: string;
}
export class MovieClip extends Sprite {
static fromFrames(frame: string[]): MovieClip;
static fromImages(images: string[]): MovieClip;
protected _textures: Texture[];
protected _durations: number[];
protected _currentTime: number;
protected update(deltaTime: number): void;
constructor(textures: Texture[]);
animationSpeed: number;
loop: boolean;
onComplete: () => void;
currentFrame: number;
playing: boolean;
totalFrames: number;
textures: Texture[];
stop(): void;
play(): void;
gotoAndStop(frameName: number): void;
gotoAndPlay(frameName: number): void;
destroy(): void;
}
export class TilingSprite extends Sprite {
//This is really unclean but is the only way :(
//See http://stackoverflow.com/questions/29593905/typescript-declaration-extending-class-with-static-method/29595798#29595798
//Thanks bas!
static fromFrame(frameId: string): Sprite;
static fromImage(imageId: string, crossorigin?: boolean, scaleMode?: number): Sprite;
static fromFrame(frameId: string, width?: number, height?: number): TilingSprite;
static fromImage(imageId: string, width?: number, height?: number, crossorigin?: boolean, scaleMode?: number): TilingSprite;
protected _tileScaleOffset: Point;
protected _tilingTexture: boolean;
protected _refreshTexture: boolean;
protected _uvs: TextureUvs[];
constructor(texture: Texture, width: number, height: number);
tileScale: Point;
tilePosition: Point;
width: number;
height: number;
originalTexture: Texture;
getBounds(): Rectangle;
generateTilingTexture(renderer: WebGLRenderer | CanvasRenderer, texture: Texture, forcePowerOfTwo?: boolean): Texture;
containsPoint(point: Point): boolean;
destroy(): void;
}
}
//////////////////////////////////////////////////////////////////////////////
///////////////////////////////FILTERS////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
module filters {
export class AsciiFilter extends AbstractFilter {
size: number;
}
export class BloomFilter extends AbstractFilter {
blur: number;
blurX: number;
blurY: number;
}
export class BlurFilter extends AbstractFilter {
protected blurXFilter: BlurXFilter;
protected blurYFilter: BlurYFilter;
blur: number;
passes: number;
blurX: number;
blurY: number;
}
export class BlurXFilter extends AbstractFilter {
passes: number;
strength: number;
blur: number;
}
export class BlurYFilter extends AbstractFilter {
passes: number;
strength: number;
blur: number;
}
export class SmartBlurFilter extends AbstractFilter {
}
export class ColorMatrixFilter extends AbstractFilter {
protected _loadMatrix(matrix: number[], multiply: boolean): void;
protected _multiply(out: number[], a: number[], b: number[]): void;
protected _colorMatrix(matrix: number[]): void;
matrix: number[];
brightness(b: number, multiply?: boolean): void;
greyscale(scale: number, multiply?: boolean): void;
blackAndWhite(multiply?: boolean): void;
hue(rotation: number, multiply?: boolean): void;
contrast(amount: number, multiply?: boolean): void;
saturate(amount: number, multiply?: boolean): void;
desaturate(multiply?: boolean): void;
negative(multiply?: boolean): void;
sepia(multiply?: boolean): void;
technicolor(multiply?: boolean): void;
polaroid(multiply?: boolean): void;
toBGR(multiply?: boolean): void;
kodachrome(multiply?: boolean): void;
browni(multiply?: boolean): void;
vintage(multiply?: boolean): void;
colorTone(desaturation: number, toned: number, lightColor: string, darkColor: string, multiply?: boolean): void;
night(intensity: number, multiply?: boolean): void;
predator(amount: number, multiply?: boolean): void;
lsd(multiply?: boolean): void;
reset(): void;
}
export class ColorStepFilter extends AbstractFilter {
step: number;
}
export class ConvolutionFilter extends AbstractFilter {
constructor(matrix: number[], width: number, height: number);
matrix: number[];
width: number;
height: number;
}
export class CrossHatchFilter extends AbstractFilter {
}
export class DisplacementFilter extends AbstractFilter {
constructor(sprite: Sprite, scale?: number);
map: Texture;
scale: Point;
}
export class DotScreenFilter extends AbstractFilter {
scale: number;
angle: number;
}
export class BlurYTintFilter extends AbstractFilter {
blur: number;
}
export class DropShadowFilter extends AbstractFilter {
blur: number;
blurX: number;
blurY: number;
color: number;
alpha: number;
distance: number;
angle: number;
}
export class GrayFilter extends AbstractFilter {
gray: number;
}
export class InvertFilter extends AbstractFilter {
invert: number;
}
export class NoiseFilter extends AbstractFilter {
noise: number;
}
export class PixelateFilter extends AbstractFilter {
size: Point;
}
export class RGBSplitFilter extends AbstractFilter {
red: number;
green: number;
blue: number;
}
export class SepiaFilter extends AbstractFilter {
sepia: number;
}
export class ShockwaveFilter extends AbstractFilter {
center: number[];
params: any;
time: number;
}
export class TiltShiftAxisFilter extends AbstractFilter {
blur: number;
gradientBlur: number;
start: number;
end: number;
updateDelta(): void;
}
export class TiltShiftFilter extends AbstractFilter {
blur: number;
gradientBlur: number;
start: number;
end: number;
}
export class TiltShiftXFilter extends AbstractFilter {