diff --git a/pixi/pixi-tests.ts b/pixi/pixi-tests.ts
index de452f72e..6600bb121 100644
--- a/pixi/pixi-tests.ts
+++ b/pixi/pixi-tests.ts
@@ -1,5 +1,4 @@
 ///<reference path="pixi.d.ts"/>
-///<reference path="webgl.d.ts"/>
 
 function PixiTests()
 {
diff --git a/pixi/pixi.d.ts b/pixi/pixi.d.ts
index d5daba948..c86c1bd47 100644
--- a/pixi/pixi.d.ts
+++ b/pixi/pixi.d.ts
@@ -3,435 +3,436 @@
 // Definitions by: xperiments <http://github.com/xperiments>
 // Definitions: https://github.com/borisyankov/DefinitelyTyped
 
-///<reference path="webgl.d.ts"/>
 declare module PIXI
 {
 
-	/* STATICS */
-	export var gl:WebGLRenderingContext;
-	export var BaseTextureCache: {};
-	export var texturesToUpdate: BaseTexture[];
-	export var texturesToDestroy: BaseTexture[];
-	export var TextureCache: {};
-	export var FrameCache: {};
-	export var blendModes:{ NORMAL:number; SCREEN:number; };
+    /* STATICS */
+    export var gl:WebGLRenderingContext;
+    export var BaseTextureCache: {};
+    export var texturesToUpdate: BaseTexture[];
+    export var texturesToDestroy: BaseTexture[];
+    export var TextureCache: {};
+    export var FrameCache: {};
+    export var blendModes:{ NORMAL:number; SCREEN:number; };
 
 
-	/* MODULE FUNCTIONS */
-	export function autoDetectRenderer(width: number, height: number, view?: HTMLCanvasElement, transparent?: boolean, antialias?: boolean): IPixiRenderer;
-	export function FilterBlock( mask:Graphics ):void;
-	export function MaskFilter( graphics:Graphics ):void;
+    /* MODULE FUNCTIONS */
+    export function autoDetectRenderer(width: number, height: number, view?: HTMLCanvasElement, transparent?: boolean, antialias?: boolean): IPixiRenderer;
+    export function FilterBlock( mask:Graphics ):void;
+    export function MaskFilter( graphics:Graphics ):void;
 
 
-	/* DEBUG METHODS */
+    /* DEBUG METHODS */
 
-	export function runList( x ):void;
+    export function runList( x ):void;
 
-		/*INTERFACES*/
+    /*INTERFACES*/
 
-	export interface IBasicCallback
-	{
-		():void
-	}
+    export interface IBasicCallback
+    {
+        ():void
+    }
 
-	export interface IEvent
-	{
-		type: string;
-		content: any;
-	}
+    export interface IEvent
+    {
+        type: string;
+        content: any;
+    }
 
-	export interface IHitArea
-	{
-		contains(x: number, y: number):boolean;
-	}
+    export interface IHitArea
+    {
+        contains(x: number, y: number):boolean;
+    }
 
-	export interface IInteractionDataCallback
-	{
-		(interactionData: InteractionData):void
-	}
+    export interface IInteractionDataCallback
+    {
+        (interactionData: InteractionData):void
+    }
 
-	export interface IPixiRenderer
-	{
-		view: HTMLCanvasElement;
-		render(stage: Stage): void;
-	}
+    export interface IPixiRenderer
+    {
+        view: HTMLCanvasElement;
+        render(stage: Stage): void;
+    }
 
-	export interface IBitmapTextStyle
-	{
-		font?: string;
-		align?: string;
-	}
+    export interface IBitmapTextStyle
+    {
+        font?: string;
+        align?: string;
+    }
 
-	export interface ITextStyle
-	{
-		font?: string;
-		stroke?: string;
-		fill?: string;
-		align?: string;
-		strokeThickness?: number;
-		wordWrap?: boolean;
-		wordWrapWidth?:number;
-	}
+    export interface ITextStyle
+    {
+        font?: string;
+        stroke?: string;
+        fill?: string;
+        align?: string;
+        strokeThickness?: number;
+        wordWrap?: boolean;
+        wordWrapWidth?:number;
+    }
 
 
 
-	/* CLASES */
+    /* CLASES */
 
-	export class AssetLoader extends EventTarget
-	{
-		assetURLs: string[];
-		onComplete: IBasicCallback;
-		onProgress: IBasicCallback;
-		constructor(assetURLs: string[], crossorigin?:boolean );
-		load(): void;
-	}
+    export class AssetLoader extends EventTarget
+    {
+        assetURLs: string[];
+        onComplete: IBasicCallback;
+        onProgress: IBasicCallback;
+        constructor(assetURLs: string[], crossorigin?:boolean );
+        load(): void;
+    }
 
-	export class BaseTexture extends EventTarget
-	{
-		height: number;
-		width: number;
-		source: string;
+    export class BaseTexture extends EventTarget
+    {
+        height: number;
+        width: number;
+        source: string;
 
-		constructor(source: HTMLImageElement);
-		constructor(source: HTMLCanvasElement);
-		destroy():void;
+        constructor(source: HTMLImageElement);
+        constructor(source: HTMLCanvasElement);
+        destroy():void;
 
-		static fromImage(imageUrl: string, crossorigin?:boolean ): BaseTexture;
-	}
+        static fromImage(imageUrl: string, crossorigin?:boolean ): BaseTexture;
+    }
 
-	export class BitmapFontLoader extends EventTarget
-	{
-		baseUrl:string;
-		crossorigin:boolean;
-		texture:Texture;
-		url:string;
-		constructor(url: string, crossorigin?: boolean);
-		load():void;
-	}
+    export class BitmapFontLoader extends EventTarget
+    {
+        baseUrl:string;
+        crossorigin:boolean;
+        texture:Texture;
+        url:string;
+        constructor(url: string, crossorigin?: boolean);
+        load():void;
+    }
 
-	export class BitmapText extends DisplayObjectContainer
-	{
-		width:number;
-		height:number;
-		constructor(text: string, style: IBitmapTextStyle);
-		setStyle(style: IBitmapTextStyle): void;
-		setText(text: string): void;
-	}
+    export class BitmapText extends DisplayObjectContainer
+    {
+        width:number;
+        height:number;
+        constructor(text: string, style: IBitmapTextStyle);
+        setStyle(style: IBitmapTextStyle): void;
+        setText(text: string): void;
+    }
 
-	export class CanvasRenderer implements IPixiRenderer
-	{
-		context: CanvasRenderingContext2D;
-		height: number;
-		view: HTMLCanvasElement;
-		width: number;
-		constructor(width: number, height: number, view?: HTMLCanvasElement, transparent?: boolean);
-		render(stage: Stage): void;
-		resize(width: number, height: number):void;
-	}
+    export class CanvasRenderer implements IPixiRenderer
+    {
+        context: CanvasRenderingContext2D;
+        height: number;
+        view: HTMLCanvasElement;
+        width: number;
+        constructor(width: number, height: number, view?: HTMLCanvasElement, transparent?: boolean);
+        render(stage: Stage): void;
+        resize(width: number, height: number):void;
+    }
 
-	export class Circle implements IHitArea
-	{
-		x: number;
-		y: number;
-		radius: number;
-		constructor(x: number, y: number, radius: number);
-		clone(): Circle;
-		contains(x: number, y: number):boolean;
-	}
+    export class Circle implements IHitArea
+    {
+        x: number;
+        y: number;
+        radius: number;
+        constructor(x: number, y: number, radius: number);
+        clone(): Circle;
+        contains(x: number, y: number):boolean;
+    }
 
-	// TODO what is renderGroup
-	export class CustomRenderable extends DisplayObject
-	{
-		constructor();
-		renderCanvas(renderer: CanvasRenderer): void;
-		initWebGL(renderer: WebGLRenderer): void;
-		renderWebGL(renderGroup: any, projectionMatrix: any): void;
-	}
+    // TODO what is renderGroup
+    export class CustomRenderable extends DisplayObject
+    {
+        constructor();
+        renderCanvas(renderer: CanvasRenderer): void;
+        initWebGL(renderer: WebGLRenderer): void;
+        renderWebGL(renderGroup: any, projectionMatrix: any): void;
+    }
 
-	export class DisplayObject
-	{
-		alpha: number;
-		buttonMode: boolean;
-		filter:boolean;
-		hitArea: IHitArea;
-		parent: DisplayObjectContainer;
-		pivot: Point;
-		position: Point;
-		rotation: number;
-		renderable: boolean;
-		scale: Point;
-		stage: Stage;
-		visible: boolean;
-		worldAlpha: number;
-		constructor();
-		static autoDetectRenderer(width: number, height: number, view?: HTMLCanvasElement, transparent?: boolean): IPixiRenderer;
-		click: IInteractionDataCallback;
-		mousedown: IInteractionDataCallback;
-		mouseout: IInteractionDataCallback;
-		mouseover: IInteractionDataCallback;
-		mouseup: IInteractionDataCallback;
-		mouseupoutside: IInteractionDataCallback;
-		mousemove: IInteractionDataCallback;
-		tap: IInteractionDataCallback;
-		touchend: IInteractionDataCallback;
-		touchendoutside: IInteractionDataCallback;
-		touchstart: IInteractionDataCallback;
-		touchmove: IInteractionDataCallback;
+    export class DisplayObject
+    {
+        x: number;
+        y: number;
+        alpha: number;
+        buttonMode: boolean;
+        filter:boolean;
+        hitArea: IHitArea;
+        parent: DisplayObjectContainer;
+        pivot: Point;
+        position: Point;
+        rotation: number;
+        renderable: boolean;
+        scale: Point;
+        stage: Stage;
+        visible: boolean;
+        worldAlpha: number;
+        constructor();
+        static autoDetectRenderer(width: number, height: number, view?: HTMLCanvasElement, transparent?: boolean): IPixiRenderer;
+        click: IInteractionDataCallback;
+        mousedown: IInteractionDataCallback;
+        mouseout: IInteractionDataCallback;
+        mouseover: IInteractionDataCallback;
+        mouseup: IInteractionDataCallback;
+        mouseupoutside: IInteractionDataCallback;
+        mousemove: IInteractionDataCallback;
+        tap: IInteractionDataCallback;
+        touchend: IInteractionDataCallback;
+        touchendoutside: IInteractionDataCallback;
+        touchstart: IInteractionDataCallback;
+        touchmove: IInteractionDataCallback;
 
-		//deprecated
-		setInteractive(interactive: boolean): void;
+        //deprecated
+        setInteractive(interactive: boolean): void;
 
-		// getters setters
-		interactive:boolean;
-		mask:Graphics;
-	}
+        // getters setters
+        interactive:boolean;
+        mask:Graphics;
+    }
 
-	export class DisplayObjectContainer extends DisplayObject
-	{
-		children: DisplayObject[];
-		constructor();
+    export class DisplayObjectContainer extends DisplayObject
+    {
+        children: DisplayObject[];
+        constructor();
 
-		addChild(child: DisplayObject): void;
-		addChildAt(child: DisplayObject, index: number): void;
-		getChildAt(index:number):DisplayObject;
-		removeChild(child: DisplayObject): void;
-		swapChildren(child: DisplayObject, child2: DisplayObject): void;
-	}
+        addChild(child: DisplayObject): void;
+        addChildAt(child: DisplayObject, index: number): void;
+        getChildAt(index:number):DisplayObject;
+        removeChild(child: DisplayObject): void;
+        swapChildren(child: DisplayObject, child2: DisplayObject): void;
+    }
 
-	export class Ellipse implements IHitArea
-	{
-		x: number;
-		y: number;
-		width: number;
-		height: number;
+    export class Ellipse implements IHitArea
+    {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
 
-		constructor(x: number, y: number, width: number, height: number);
-		clone(): Ellipse;
-		contains(x: number, y: number):boolean;
-		getBounds():Rectangle;
-	}
+        constructor(x: number, y: number, width: number, height: number);
+        clone(): Ellipse;
+        contains(x: number, y: number):boolean;
+        getBounds():Rectangle;
+    }
 
-	export class EventTarget
-	{
-		addEventListener(type: string, listener: (event: IEvent) => void );
-		removeEventListener(type: string, listener: (event: IEvent) => void );
-		dispatchEvent(event: IEvent);
-	}
+    export class EventTarget
+    {
+        addEventListener(type: string, listener: (event: IEvent) => void );
+        removeEventListener(type: string, listener: (event: IEvent) => void );
+        dispatchEvent(event: IEvent);
+    }
 
-	export class Graphics extends DisplayObjectContainer
-	{
-		lineWidth:number;
-		lineColor:string;
-		constructor();
+    export class Graphics extends DisplayObjectContainer
+    {
+        lineWidth:number;
+        lineColor:string;
+        constructor();
 
-		beginFill(color?: number, alpha?: number): void;
-		clear(): void;
-		drawCircle(x: number, y: number, radius: number): void;
-		drawElipse(x: number, y: number, width: number, height: number): void;
-		drawRect(x: number, y: number, width: number, height: number): void;
-		endFill(): void;
-		lineStyle(lineWidth?: number, color?: number, alpha?: number ): void;
-		lineTo(x: number, y: number): void;
-		moveTo(x: number, y: number): void;
+        beginFill(color?: number, alpha?: number): void;
+        clear(): void;
+        drawCircle(x: number, y: number, radius: number): void;
+        drawElipse(x: number, y: number, width: number, height: number): void;
+        drawRect(x: number, y: number, width: number, height: number): void;
+        endFill(): void;
+        lineStyle(lineWidth?: number, color?: number, alpha?: number ): void;
+        lineTo(x: number, y: number): void;
+        moveTo(x: number, y: number): void;
 
-		static POLY:number;
-		static RECT:number;
-		static CIRC:number;
-		static ELIP:number;
-	}
+        static POLY:number;
+        static RECT:number;
+        static CIRC:number;
+        static ELIP:number;
+    }
 
-	export class ImageLoader extends EventTarget
-	{
-		texture:Texture;
-		constructor(url: string, crossorigin?: boolean);
-		load(): void;
-	}
+    export class ImageLoader extends EventTarget
+    {
+        texture:Texture;
+        constructor(url: string, crossorigin?: boolean);
+        load(): void;
+    }
 
-	/* TODO determine type of originalEvent*/
-	export class InteractionData
-	{
-		global: Point;
-		target: Sprite;
-		constructor();
-		originalEvent:any;
-		getLocalPosition(displayObject: DisplayObject): Point;
-	}
+    /* TODO determine type of originalEvent*/
+    export class InteractionData
+    {
+        global: Point;
+        target: Sprite;
+        constructor();
+        originalEvent:any;
+        getLocalPosition(displayObject: DisplayObject): Point;
+    }
 
-	export class InteractionManager
-	{
-		mouse: InteractionData;
-		stage: Stage;
-		touchs:{ [id:string]:InteractionData };
-		constructor(stage: Stage);
-	}
+    export class InteractionManager
+    {
+        mouse: InteractionData;
+        stage: Stage;
+        touchs:{ [id:string]:InteractionData };
+        constructor(stage: Stage);
+    }
 
-	export class JsonLoader extends EventTarget
-	{
-		url:string;
-		crossorigin: boolean;
-		baseUrl:string;
-		loaded:boolean;
-		constructor(url: string, crossorigin?: boolean);
-		load(): void;
-	}
+    export class JsonLoader extends EventTarget
+    {
+        url:string;
+        crossorigin: boolean;
+        baseUrl:string;
+        loaded:boolean;
+        constructor(url: string, crossorigin?: boolean);
+        load(): void;
+    }
 
-	export class MovieClip extends Sprite
-	{
-		animationSpeed: number;
-		currentFrame:number;
-		loop: boolean;
-		playing: boolean;
-		textures: Texture[];
-		constructor(textures: Texture[]);
-		onComplete:IBasicCallback;
-		gotoAndPlay(frameNumber: number): void;
-		gotoAndStop(frameNumber: number): void;
-		play(): void;
-		stop(): void;
-	}
+    export class MovieClip extends Sprite
+    {
+        animationSpeed: number;
+        currentFrame:number;
+        loop: boolean;
+        playing: boolean;
+        textures: Texture[];
+        constructor(textures: Texture[]);
+        onComplete:IBasicCallback;
+        gotoAndPlay(frameNumber: number): void;
+        gotoAndStop(frameNumber: number): void;
+        play(): void;
+        stop(): void;
+    }
 
-	export class Point
-	{
-		x: number;
-		y: number;
-		constructor(x: number, y: number);
-		clone(): Point;
-	}
+    export class Point
+    {
+        x: number;
+        y: number;
+        constructor(x: number, y: number);
+        clone(): Point;
+    }
 
-	export class Polygon implements IHitArea
-	{
-		points: Point[];
+    export class Polygon implements IHitArea
+    {
+        points: Point[];
 
-		constructor(points: Point[]);
-		constructor(points: number[]);
-		constructor(...points: Point[]);
-		constructor(...points: number[]);
+        constructor(points: Point[]);
+        constructor(points: number[]);
+        constructor(...points: Point[]);
+        constructor(...points: number[]);
 
-		clone(): Polygon;
-		contains( x:number, y:number ):boolean;
-	}
+        clone(): Polygon;
+        contains( x:number, y:number ):boolean;
+    }
 
-	export class Rectangle implements IHitArea
-	{
-		x: number;
-		y: number;
-		width: number;
-		height: number;
-		constructor(x: number, y: number, width: number, height: number);
-		clone(): Rectangle;
-		contains(x: number, y: number):boolean
-	}
+    export class Rectangle implements IHitArea
+    {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+        constructor(x: number, y: number, width: number, height: number);
+        clone(): Rectangle;
+        contains(x: number, y: number):boolean;
+    }
 
-	export class RenderTexture extends Texture
-	{
-		constructor(width: number, height: number);
-		resize(width: number, height: number): void;
-	}
+    export class RenderTexture extends Texture
+    {
+        constructor(width: number, height: number);
+        resize(width: number, height: number): void;
+    }
 
-	export class Sprite extends DisplayObjectContainer
-	{
-		anchor: Point;
-		blendMode: number;
-		texture: Texture;
+    export class Sprite extends DisplayObjectContainer
+    {
+        anchor: Point;
+        blendMode: number;
+        texture: Texture;
 
-		//getters setters
-		height: number;
-		width: number;
+        //getters setters
+        height: number;
+        width: number;
 
-		constructor(texture: Texture);
+        constructor(texture: Texture);
 
-		static fromFrame(frameId: string): Sprite;
-		static fromImage(url: string): Sprite;
-		setTexture(texture: Texture): void;
-	}
+        static fromFrame(frameId: string): Sprite;
+        static fromImage(url: string): Sprite;
+        setTexture(texture: Texture): void;
+    }
 
-	/* TODO determine type of frames */
-	export class SpriteSheetLoader extends EventTarget
-	{
-		url:string;
-		crossorigin:boolean;
-		baseUrl:string;
-		texture:Texture;
-		frames:Object;
-		constructor(url: string, crossorigin?: boolean);
-		load();
-	}
+    /* TODO determine type of frames */
+    export class SpriteSheetLoader extends EventTarget
+    {
+        url:string;
+        crossorigin:boolean;
+        baseUrl:string;
+        texture:Texture;
+        frames:Object;
+        constructor(url: string, crossorigin?: boolean);
+        load();
+    }
 
-	export class Stage extends DisplayObjectContainer
-	{
-		interactive:boolean;
-		interactionManager:InteractionManager;
-		constructor(backgroundColor: number, interactive?: boolean);
-		getMousePosition(): Point;
-		setBackgroundColor(backgroundColor: number): void;
-	}
+    export class Stage extends DisplayObjectContainer
+    {
+        interactive:boolean;
+        interactionManager:InteractionManager;
+        constructor(backgroundColor: number, interactive?: boolean);
+        getMousePosition(): Point;
+        setBackgroundColor(backgroundColor: number): void;
+    }
 
-	export class Text extends Sprite
-	{
-		constructor(text: string, style: ITextStyle);
-		destroy(destroyTexture:boolean):void;
-		setText(text: string): void;
-		setStyle(style: ITextStyle): void;
-	}
+    export class Text extends Sprite
+    {
+        constructor(text: string, style: ITextStyle);
+        destroy(destroyTexture:boolean):void;
+        setText(text: string): void;
+        setStyle(style: ITextStyle): void;
+    }
 
-	export class Texture extends EventTarget
-	{
-		baseTexture: BaseTexture;
-		frame: Rectangle;
-		trim:Point;
-		render( displayObject:DisplayObject, position:Point, clear:boolean ):void;
-		constructor(baseTexture: BaseTexture, frame?: Rectangle);
-		destroy(destroyBase:boolean):void;
-		setFrame(frame: Rectangle): void;
+    export class Texture extends EventTarget
+    {
+        baseTexture: BaseTexture;
+        frame: Rectangle;
+        trim:Point;
+        render( displayObject:DisplayObject, position:Point, clear:boolean ):void;
+        constructor(baseTexture: BaseTexture, frame?: Rectangle);
+        destroy(destroyBase:boolean):void;
+        setFrame(frame: Rectangle): void;
 
-		static addTextureToCache(texture: Texture, id: string): void;
-		static fromCanvas(canvas: HTMLCanvasElement): Texture;
-		static fromFrame(frameId: string): Texture;
-		static fromImage(imageUrl: string, crossorigin?: boolean): Texture;
-		static removeTextureFromCache(id: any): Texture;
-	}
+        static addTextureToCache(texture: Texture, id: string): void;
+        static fromCanvas(canvas: HTMLCanvasElement): Texture;
+        static fromFrame(frameId: string): Texture;
+        static fromImage(imageUrl: string, crossorigin?: boolean): Texture;
+        static removeTextureFromCache(id: any): Texture;
+    }
 
-	export class TilingSprite extends DisplayObjectContainer
-	{
-		width:number;
-		height:number;
-		texture:Texture;
-		tilePosition: Point;
-		tileScale: Point;
-		constructor(texture: Texture, width: number, height: number);
-		setTexture( texture: Texture ):void;
-	}
+    export class TilingSprite extends DisplayObjectContainer
+    {
+        width:number;
+        height:number;
+        texture:Texture;
+        tilePosition: Point;
+        tileScale: Point;
+        constructor(texture: Texture, width: number, height: number);
+        setTexture( texture: Texture ):void;
+    }
 
-	export class WebGLBatch
-	{
-		constructor(webGLContext: WebGLRenderingContext);
-		clean():void;
-		restoreLostContext(gl:WebGLRenderingContext)
-		init(sprite: Sprite): void;
-		insertAfter(sprite: Sprite, previousSprite: Sprite): void;
-		insertBefore(sprite: Sprite, nextSprite: Sprite): void;
-		growBatch(): void;
-		merge(batch: WebGLBatch): void;
-		refresh(): void;
-		remove(sprite: Sprite): void;
-		render(): void;
-		split(sprite: Sprite): WebGLBatch;
-		update(): void;
-	}
+    export class WebGLBatch
+    {
+        constructor(webGLContext: WebGLRenderingContext);
+        clean():void;
+        restoreLostContext(gl:WebGLRenderingContext);
+        init(sprite: Sprite): void;
+        insertAfter(sprite: Sprite, previousSprite: Sprite): void;
+        insertBefore(sprite: Sprite, nextSprite: Sprite): void;
+        growBatch(): void;
+        merge(batch: WebGLBatch): void;
+        refresh(): void;
+        remove(sprite: Sprite): void;
+        render(): void;
+        split(sprite: Sprite): WebGLBatch;
+        update(): void;
+    }
 
-	/* Determine type of Object */
-	export class WebGLRenderGroup
-	{
-		render(projection:Object):void;
-	}
+    /* Determine type of Object */
+    export class WebGLRenderGroup
+    {
+        render(projection:Object):void;
+    }
 
-	export class WebGLRenderer implements IPixiRenderer
-	{
-		view: HTMLCanvasElement;
-		constructor(width: number, height: number, view?: HTMLCanvasElement, transparent?: boolean, antialias?:boolean );
-		render(stage: Stage): void;
-		resize(width: number, height: number): void;
-	}
+    export class WebGLRenderer implements IPixiRenderer
+    {
+        view: HTMLCanvasElement;
+        constructor(width: number, height: number, view?: HTMLCanvasElement, transparent?: boolean, antialias?:boolean );
+        render(stage: Stage): void;
+        resize(width: number, height: number): void;
+    }
 
 }
 
@@ -440,7 +441,7 @@ declare function requestAnimFrame( animate: PIXI.IBasicCallback );
 
 declare module PIXI.PolyK
 {
-	export function Triangulate( p:number[]):number[];
+    export function Triangulate( p:number[]):number[];
 }
 
 
diff --git a/pixi/webgl.d.ts b/pixi/webgl.d.ts
deleted file mode 100644
index ebf1204dc..000000000
--- a/pixi/webgl.d.ts
+++ /dev/null
@@ -1,227 +0,0 @@
-// Type definitions for WebGL
-// Project: https://www.khronos.org/webgl/
-// Definitions by: xperiments <http://github.com/xperiments/>
-// Definitions: https://github.com/borisyankov/DefinitelyTyped
-
-interface WebGLObject {
-	$__dummyprop__WebGLObject : any;
-}
-
-interface WebGLBuffer extends WebGLObject {
-	$__dummyprop__WebGLBuffer : any;
-}
-
-interface WebGLFramebuffer extends WebGLObject {
-	$__dummyprop__WebGLFramebuffer : any;
-}
-
-interface WebGLProgram extends WebGLObject {
-	$__dummyprop__WebGLProgram : any;
-}
-
-interface WebGLRenderbuffer extends WebGLObject {
-	$__dummyprop__WebGLRenderbuffer : any;
-}
-
-interface WebGLShader extends WebGLObject {
-	$__dummyprop__WebGLShader : any;
-}
-
-interface WebGLTexture extends WebGLObject {
-	$__dummyprop__WebGLTexture : any;
-}
-
-interface WebGLUniformLocation {
-	$__dummyprop__WebGLUniformLocation : any;
-}
-
-interface WebGLRenderingContext {
-	NUM_COMPRESSED_TEXTURE_FORMATS : number;
-	ACTIVE_UNIFORM_MAX_LENGTH : number;
-	INFO_LOG_LENGTH : number;
-	SHADER_SOURCE_LENGTH : number;
-	getContextAttributes() : WebGLContextAttributes;
-	isContextLost() : boolean;
-	getSupportedExtensions() : string[];
-	getExtension(name : string) : any;
-	activeTexture(texture : number) : void;
-	attachShader(program : WebGLProgram, shader : WebGLShader) : void;
-	bindAttribLocation(program : WebGLProgram, index : number, name : string) : void;
-	bindBuffer(target : number, buffer : WebGLBuffer) : void;
-	bindFramebuffer(target : number, framebuffer : WebGLFramebuffer) : void;
-	bindRenderbuffer(target : number, renderbuffer : WebGLRenderbuffer) : void;
-	bindTexture(target : number, texture : WebGLTexture) : void;
-	blendColor(red : number, green : number, blue : number, alpha : number) : void;
-	blendEquation(mode : number) : void;
-	blendEquationSeparate(modeRGB : number, modeAlpha : number) : void;
-	blendFunc(sfactor : number, dfactor : number) : void;
-	blendFuncSeparate(srcRGB : number, dstRGB : number, srcAlpha : number, dstAlpha : number) : void;
-	bufferData(target : number, size : number, usage : number) : void;
-	bufferData(target : number, data : ArrayBufferView, usage : number) : void;
-	bufferData(target : number, data : ArrayBuffer, usage : number) : void;
-	bufferSubData(target : number, offset : number, data : ArrayBufferView) : void;
-	bufferSubData(target : number, offset : number, data : ArrayBuffer) : void;
-	checkFramebufferStatus(target : number) : number;
-	clear(mask : number) : void;
-	clearColor(red : number, green : number, blue : number, alpha : number) : void;
-	clearDepth(depth : number) : void;
-	clearStencil(s : number) : void;
-	colorMask(red : boolean, green : boolean, blue : boolean, alpha : boolean) : void;
-	compileShader(shader : WebGLShader) : void;
-	copyTexImage2D(target : number, level : number, internalformat : number, x : number, y : number, width : number, height : number, border : number) : void;
-	copyTexSubImage2D(target : number, level : number, xoffset : number, yoffset : number, x : number, y : number, width : number, height : number) : void;
-	createBuffer() : WebGLBuffer;
-	createFramebuffer() : WebGLFramebuffer;
-	createProgram() : WebGLProgram;
-	createRenderbuffer() : WebGLRenderbuffer;
-	createShader(type : number) : WebGLShader;
-	createTexture() : WebGLTexture;
-	cullFace(mode : number) : void;
-	deleteBuffer(buffer : WebGLBuffer) : void;
-	deleteFramebuffer(framebuffer : WebGLFramebuffer) : void;
-	deleteProgram(program : WebGLProgram) : void;
-	deleteRenderbuffer(renderbuffer : WebGLRenderbuffer) : void;
-	deleteShader(shader : WebGLShader) : void;
-	deleteTexture(texture : WebGLTexture) : void;
-	depthFunc(func : number) : void;
-	depthMask(flag : boolean) : void;
-	depthRange(zNear : number, zFar : number) : void;
-	detachShader(program : WebGLProgram, shader : WebGLShader) : void;
-	disable(cap : number) : void;
-	disableVertexAttribArray(index : number) : void;
-	drawArrays(mode : number, first : number, count : number) : void;
-	drawElements(mode : number, count : number, type : number, offset : number) : void;
-	enable(cap : number) : void;
-	enableVertexAttribArray(index : number) : void;
-	finish() : void;
-	flush() : void;
-	framebufferRenderbuffer(target : number, attachment : number, renderbuffertarget : number, renderbuffer : WebGLRenderbuffer) : void;
-	framebufferTexture2D(target : number, attachment : number, textarget : number, texture : WebGLTexture, level : number) : void;
-	frontFace(mode : number) : void;
-	generateMipmap(target : number) : void;
-	getActiveAttrib(program : WebGLProgram, index : number) : WebGLActiveInfo;
-	getActiveUniform(program : WebGLProgram, index : number) : WebGLActiveInfo;
-	getAttachedShaders(program : WebGLProgram) : WebGLShader[];
-	getAttribLocation(program : WebGLProgram, name : string) : number;
-	getParameter(pname : number) : any;
-	getBufferParameter(target : number, pname : number) : any;
-	getError() : number;
-	getFramebufferAttachmentParameter(target : number, attachment : number, pname : number) : any;
-	getProgramParameter(program : WebGLProgram, pname : number) : any;
-	getProgramInfoLog(program : WebGLProgram) : string;
-	getRenderbufferParameter(target : number, pname : number) : any;
-	getShaderParameter(shader : WebGLShader, pname : number) : any;
-	getShaderInfoLog(shader : WebGLShader) : string;
-	getShaderSource(shader : WebGLShader) : string;
-	getTexParameter(target : number, pname : number) : any;
-	getUniform(program : WebGLProgram, location : WebGLUniformLocation) : any;
-	getUniformLocation(program : WebGLProgram, name : string) : WebGLUniformLocation;
-	getVertexAttrib(index : number, pname : number) : any;
-	getVertexAttribOffset(index : number, pname : number) : number;
-	hint(target : number, mode : number) : void;
-	isBuffer(buffer : WebGLBuffer) : boolean;
-	isEnabled(cap : number) : boolean;
-	isFramebuffer(framebuffer : WebGLFramebuffer) : boolean;
-	isProgram(program : WebGLProgram) : boolean;
-	isRenderbuffer(renderbuffer : WebGLRenderbuffer) : boolean;
-	isShader(shader : WebGLShader) : boolean;
-	isTexture(texture : WebGLTexture) : boolean;
-	lineWidth(width : number) : void;
-	linkProgram(program : WebGLProgram) : void;
-	pixelStorei(pname : number, param : number) : void;
-	polygonOffset(factor : number, units : number) : void;
-	readPixels(x : number, y : number, width : number, height : number, format : number, type : number, pixels : ArrayBufferView) : void;
-	renderbufferStorage(target : number, internalformat : number, width : number, height : number) : void;
-	sampleCoverage(value : number, invert : boolean) : void;
-	scissor(x : number, y : number, width : number, height : number) : void;
-	shaderSource(shader : WebGLShader, source : string) : void;
-	stencilFunc(func : number, ref : number, mask : number) : void;
-	stencilFuncSeparate(face : number, func : number, ref : number, mask : number) : void;
-	stencilMask(mask : number) : void;
-	stencilMaskSeparate(face : number, mask : number) : void;
-	stencilOp(fail : number, zfail : number, zpass : number) : void;
-	stencilOpSeparate(face : number, fail : number, zfail : number, zpass : number) : void;
-	texImage2D(target : number, level : number, internalformat : number, width : number, height : number, border : number, format : number, type : number, pixels : ArrayBufferView) : void;
-	texImage2D(target : number, level : number, internalformat : number, format : number, type : number, pixels : ImageData) : void;
-	texImage2D(target : number, level : number, internalformat : number, format : number, type : number, image : HTMLImageElement) : void;
-	texImage2D(target : number, level : number, internalformat : number, format : number, type : number, canvas : HTMLCanvasElement) : void;
-	texImage2D(target : number, level : number, internalformat : number, format : number, type : number, video : HTMLVideoElement) : void;
-	texParameterf(target : number, pname : number, param : number) : void;
-	texParameteri(target : number, pname : number, param : number) : void;
-	texSubImage2D(target : number, level : number, xoffset : number, yoffset : number, width : number, height : number, format : number, type : number, pixels : ArrayBufferView) : void;
-	texSubImage2D(target : number, level : number, xoffset : number, yoffset : number, format : number, type : number, pixels : ImageData) : void;
-	texSubImage2D(target : number, level : number, xoffset : number, yoffset : number, format : number, type : number, image : HTMLImageElement) : void;
-	texSubImage2D(target : number, level : number, xoffset : number, yoffset : number, format : number, type : number, canvas : HTMLCanvasElement) : void;
-	texSubImage2D(target : number, level : number, xoffset : number, yoffset : number, format : number, type : number, video : HTMLVideoElement) : void;
-	uniform1f(location : WebGLUniformLocation, x : number) : void;
-	uniform1fv(location : WebGLUniformLocation, v : Float32Array) : void;
-	uniform1fv(location : WebGLUniformLocation, v : number[]) : void;
-	uniform1i(location : WebGLUniformLocation, x : number) : void;
-	uniform1iv(location : WebGLUniformLocation, v : Int32Array) : void;
-	uniform1iv(location : WebGLUniformLocation, v : number[]) : void;
-	uniform2f(location : WebGLUniformLocation, x : number, y : number) : void;
-	uniform2fv(location : WebGLUniformLocation, v : Float32Array) : void;
-	uniform2fv(location : WebGLUniformLocation, v : number[]) : void;
-	uniform2i(location : WebGLUniformLocation, x : number, y : number) : void;
-	uniform2iv(location : WebGLUniformLocation, v : Int32Array) : void;
-	uniform2iv(location : WebGLUniformLocation, v : number[]) : void;
-	uniform3f(location : WebGLUniformLocation, x : number, y : number, z : number) : void;
-	uniform3fv(location : WebGLUniformLocation, v : Float32Array) : void;
-	uniform3fv(location : WebGLUniformLocation, v : number[]) : void;
-	uniform3i(location : WebGLUniformLocation, x : number, y : number, z : number) : void;
-	uniform3iv(location : WebGLUniformLocation, v : Int32Array) : void;
-	uniform3iv(location : WebGLUniformLocation, v : number[]) : void;
-	uniform4f(location : WebGLUniformLocation, x : number, y : number, z : number, w : number) : void;
-	uniform4fv(location : WebGLUniformLocation, v : Float32Array) : void;
-	uniform4fv(location : WebGLUniformLocation, v : number[]) : void;
-	uniform4i(location : WebGLUniformLocation, x : number, y : number, z : number, w : number) : void;
-	uniform4iv(location : WebGLUniformLocation, v : Int32Array) : void;
-	uniform4iv(location : WebGLUniformLocation, v : number[]) : void;
-	uniformMatrix2fv(location : WebGLUniformLocation, transpose : boolean, value : Float32Array) : void;
-	uniformMatrix2fv(location : WebGLUniformLocation, transpose : boolean, value : number[]) : void;
-	uniformMatrix3fv(location : WebGLUniformLocation, transpose : boolean, value : Float32Array) : void;
-	uniformMatrix3fv(location : WebGLUniformLocation, transpose : boolean, value : number[]) : void;
-	uniformMatrix4fv(location : WebGLUniformLocation, transpose : boolean, value : Float32Array) : void;
-	uniformMatrix4fv(location : WebGLUniformLocation, transpose : boolean, value : number[]) : void;
-	useProgram(program : WebGLProgram) : void;
-	validateProgram(program : WebGLProgram) : void;
-	vertexAttrib1f(indx : number, x : number) : void;
-	vertexAttrib1fv(indx : number, values : Float32Array) : void;
-	vertexAttrib1fv(indx : number, values : number[]) : void;
-	vertexAttrib2f(indx : number, x : number, y : number) : void;
-	vertexAttrib2fv(indx : number, values : Float32Array) : void;
-	vertexAttrib2fv(indx : number, values : number[]) : void;
-	vertexAttrib3f(indx : number, x : number, y : number, z : number) : void;
-	vertexAttrib3fv(indx : number, values : Float32Array) : void;
-	vertexAttrib3fv(indx : number, values : number[]) : void;
-	vertexAttrib4f(indx : number, x : number, y : number, z : number, w : number) : void;
-	vertexAttrib4fv(indx : number, values : Float32Array) : void;
-	vertexAttrib4fv(indx : number, values : number[]) : void;
-	vertexAttribPointer(indx : number, size : number, type : number, normalized : boolean, stride : number, offset : number) : void;
-	viewport(x : number, y : number, width : number, height : number) : void;
-}
-
-interface WebGLContextEvent extends Event {
-	initWebGLContextEvent(typeArg : string, canBubbleArg : boolean, cancelableArg : boolean, statusMessageArg : string) : void;
-}
-
-//Extend the window object with cross Browser callbacks so TS will not complain 
-//Also add the (non-standard) Canvas Element parameter for performance improvement 
-interface WindowAnimationTiming {
-	requestAnimationFrame(callback: FrameRequestCallback, canvas ?: HTMLCanvasElement): number;
-	//msRequestAnimationFrame(callback: FrameRequestCallback, canvas ?: HTMLCanvasElement): number;
-	mozRequestAnimationFrame(callback: FrameRequestCallback, canvas ?: HTMLCanvasElement): number;
-	webkitRequestAnimationFrame(callback: FrameRequestCallback, canvas ?: HTMLCanvasElement): number;
-	oRequestAnimationFrame(callback: FrameRequestCallback, canvas ?: HTMLCanvasElement): number;	 
-
-	cancelRequestAnimationFrame(handle: number): void;
-	//msCancelRequestAnimationFrame(handle: number): void;
-	mozCancelRequestAnimationFrame(handle: number): void;
-	webkitCancelRequestAnimationFrame(handle: number): void;
-	oCancelRequestAnimationFrame(handle: number): void;
-}
-
-//To make WebGL work 
-interface HTMLCanvasElement {
-	getContext(contextId: string, params : {}): WebGLRenderingContext;
-}