#

API Docs for: 1.0.0
Show: Inherited Protected Private Deprecated

# File: src/pixi/textures/Texture.js

    /**
     * @author Mat Groves http://matgroves.com/ @Doormat23
     */

    PIXI.TextureCache = {};
    PIXI.FrameCache = {};

    /**
     * A texture stores the information that represents an image or part of an image. It cannot be added to the display list directly. To do this use PIXI.Sprite. If no frame is provided then the whole image is used
     * @class Texture
     * @extends EventTarget
     * @constructor
     * @param baseTexture {BaseTexture}
     * @param frmae {Rectangle}
     */
    PIXI.Texture = function(baseTexture, frame)
    {
    	PIXI.EventTarget.call( this );

    	if(!frame)
    	{
    		this.noFrame = true;
    		frame = new PIXI.Rectangle(0,0,1,1);
    	}

    	this.trim = new PIXI.Point();

    	if(baseTexture instanceof PIXI.Texture)
    		baseTexture = baseTexture.baseTexture;

    	/**
    	 * The base texture of this texture
    	 * @property baseTexture
    	 * @type BaseTexture
    	 */
    	this.baseTexture = baseTexture;

    	/**
    	 * The frame specifies the region of the base texture that this texture uses
    	 * @property frame
    	 * @type #Rectangle
    	 */
    	this.frame = frame;

    	this.scope = this;

    	if(baseTexture.hasLoaded)
    	{
    		if(this.noFrame)frame = new PIXI.Rectangle(0,0, baseTexture.width, baseTexture.height);
    		//console.log(frame)

    		this.setFrame(frame);
    	}
    	else
    	{
    		var scope = this;
    		baseTexture.addEventListener( 'loaded', function(){ scope.onBaseTextureLoaded()} );
    	}
    }

    PIXI.Texture.constructor = PIXI.Texture;

    PIXI.Texture.prototype.onBaseTextureLoaded = function(event)
    {
    	var baseTexture = this.baseTexture;
    	baseTexture.removeEventListener( 'loaded', this.onLoaded );

    	if(this.noFrame)this.frame = new PIXI.Rectangle(0,0, baseTexture.width, baseTexture.height);
    	this.noFrame = false;
    	this.width = this.frame.width;
    	this.height = this.frame.height;

    	this.scope.dispatchEvent( { type: 'update', content: this } );
    }

    PIXI.Texture.prototype.destroy = function(destroyBase)
    {
    	if(destroyBase)this.baseTexture.destroy();
    }

    /**
     * Specifies the rectangle region of the baseTexture
     * @method setFrame
     * @param frame {Rectangle}
     */
    PIXI.Texture.prototype.setFrame = function(frame)
    {
    	this.frame = frame;
    	this.width = frame.width;
    	this.height = frame.height;

    	if(frame.x + frame.width > this.baseTexture.width || frame.y + frame.height > this.baseTexture.height)
    	{
    		throw new Error("Texture Error: frame does not fit inside the base Texture dimensions " + this);
    	}

    	this.updateFrame = true;

    	PIXI.Texture.frameUpdates.push(this);
    	//this.dispatchEvent( { type: 'update', content: this } );
    }

    /**
     *
     * Helper function that returns a texture based on an image url
     * If the image is not in the texture cache it will be  created and loaded
     * @static
     * @method fromImage
     * @param imageUrl {String} The image url of the texture
     * @return Texture
     */
    PIXI.Texture.fromImage = function(imageUrl, crossorigin)
    {
    	var texture = PIXI.TextureCache[imageUrl];

    	if(!texture)
    	{
    		texture = new PIXI.Texture(PIXI.BaseTexture.fromImage(imageUrl, crossorigin));
    		PIXI.TextureCache[imageUrl] = texture;
    	}

    	return texture;
    }

    /**
     *
     * Helper function that returns a texture based on a frame id
     * If the frame id is not in the texture cache an error will be thrown
     * @method fromFrame
     * @param frameId {String} The frame id of the texture
     * @return Texture
     */
    PIXI.Texture.fromFrame = function(frameId)
    {
    	var texture = PIXI.TextureCache[frameId];
    	if(!texture)throw new Error("The frameId '"+ frameId +"' does not exist in the texture cache " + this);
    	return texture;
    }

    /**
     *
     * Helper function that returns a texture based on a canvas element
     * If the canvas is not in the texture cache it will be  created and loaded
     * @static
     * @method fromCanvas
     * @param canvas {Canvas} The canvas element source of the texture
     * @return Texture
     */
    PIXI.Texture.fromCanvas = function(canvas)
    {
    	var	baseTexture = new PIXI.BaseTexture(canvas);
    	return new PIXI.Texture(baseTexture);
    }

    /**
     *
     * Adds a texture to the textureCache.
     * @static
     * @method addTextureToCache
     * @param texture {Texture}
     * @param id {String} the id that the texture will be stored against.
     */
    PIXI.Texture.addTextureToCache = function(texture, id)
    {
    	PIXI.TextureCache[id] = texture;
    }

    /**
     *
     * Remove a texture from the textureCache.
     * @static
     * @method removeTextureFromCache
     * @param id {String} the id of the texture to be removed
     * @return {Texture} the texture that was removed
     */
    PIXI.Texture.removeTextureFromCache = function(id)
    {
    	var texture = PIXI.TextureCache[id]
    	PIXI.TextureCache[id] = null;
    	return texture;
    }

    // this is more for webGL.. it contains updated frames..
    PIXI.Texture.frameUpdates = [];