mirror of
https://github.com/logsol/chuck.js.git
synced 2026-05-12 02:57:34 +00:00
updated pixi to v2
This commit is contained in:
logsol
parent
a5b3d2f671
commit
58b83f7297
95 changed files with 44677 additions and 3522 deletions
305
app/Lib/Vendor/src/pixi/textures/BaseTexture.js
vendored
Normal file
305
app/Lib/Vendor/src/pixi/textures/BaseTexture.js
vendored
Normal file
|
|
@ -0,0 +1,305 @@
|
|||
/**
|
||||
* @author Mat Groves http://matgroves.com/ @Doormat23
|
||||
*/
|
||||
|
||||
PIXI.BaseTextureCache = {};
|
||||
|
||||
PIXI.BaseTextureCacheIdGenerator = 0;
|
||||
|
||||
/**
|
||||
* A texture stores the information that represents an image. All textures have a base texture.
|
||||
*
|
||||
* @class BaseTexture
|
||||
* @uses EventTarget
|
||||
* @constructor
|
||||
* @param source {String} the source object (image or canvas)
|
||||
* @param scaleMode {Number} See {{#crossLink "PIXI/scaleModes:property"}}PIXI.scaleModes{{/crossLink}} for possible values
|
||||
*/
|
||||
PIXI.BaseTexture = function(source, scaleMode)
|
||||
{
|
||||
/**
|
||||
* The Resolution of the texture.
|
||||
*
|
||||
* @property resolution
|
||||
* @type Number
|
||||
*/
|
||||
this.resolution = 1;
|
||||
|
||||
/**
|
||||
* [read-only] The width of the base texture set when the image has loaded
|
||||
*
|
||||
* @property width
|
||||
* @type Number
|
||||
* @readOnly
|
||||
*/
|
||||
this.width = 100;
|
||||
|
||||
/**
|
||||
* [read-only] The height of the base texture set when the image has loaded
|
||||
*
|
||||
* @property height
|
||||
* @type Number
|
||||
* @readOnly
|
||||
*/
|
||||
this.height = 100;
|
||||
|
||||
/**
|
||||
* The scale mode to apply when scaling this texture
|
||||
*
|
||||
* @property scaleMode
|
||||
* @type {Number}
|
||||
* @default PIXI.scaleModes.LINEAR
|
||||
*/
|
||||
this.scaleMode = scaleMode || PIXI.scaleModes.DEFAULT;
|
||||
|
||||
/**
|
||||
* [read-only] Set to true once the base texture has loaded
|
||||
*
|
||||
* @property hasLoaded
|
||||
* @type Boolean
|
||||
* @readOnly
|
||||
*/
|
||||
this.hasLoaded = false;
|
||||
|
||||
/**
|
||||
* The image source that is used to create the texture.
|
||||
*
|
||||
* @property source
|
||||
* @type Image
|
||||
*/
|
||||
this.source = source;
|
||||
|
||||
this._UID = PIXI._UID++;
|
||||
|
||||
/**
|
||||
* Controls if RGB channels should be pre-multiplied by Alpha (WebGL only)
|
||||
*
|
||||
* @property premultipliedAlpha
|
||||
* @type Boolean
|
||||
* @default true
|
||||
*/
|
||||
this.premultipliedAlpha = true;
|
||||
|
||||
// used for webGL
|
||||
|
||||
/**
|
||||
* @property _glTextures
|
||||
* @type Array
|
||||
* @private
|
||||
*/
|
||||
this._glTextures = [];
|
||||
|
||||
/**
|
||||
*
|
||||
* 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
|
||||
*
|
||||
* @property mipmap
|
||||
* @type {Boolean}
|
||||
*/
|
||||
this.mipmap = false;
|
||||
|
||||
// used for webGL texture updating...
|
||||
// TODO - this needs to be addressed
|
||||
|
||||
/**
|
||||
* @property _dirty
|
||||
* @type Array
|
||||
* @private
|
||||
*/
|
||||
this._dirty = [true, true, true, true];
|
||||
|
||||
if(!source)return;
|
||||
|
||||
if((this.source.complete || this.source.getContext) && this.source.width && this.source.height)
|
||||
{
|
||||
this.hasLoaded = true;
|
||||
this.width = this.source.naturalWidth || this.source.width;
|
||||
this.height = this.source.naturalHeight || this.source.height;
|
||||
this.dirty();
|
||||
}
|
||||
else
|
||||
{
|
||||
var scope = this;
|
||||
|
||||
this.source.onload = function() {
|
||||
|
||||
scope.hasLoaded = true;
|
||||
scope.width = scope.source.naturalWidth || scope.source.width;
|
||||
scope.height = scope.source.naturalHeight || scope.source.height;
|
||||
|
||||
scope.dirty();
|
||||
|
||||
// add it to somewhere...
|
||||
scope.dispatchEvent( { type: 'loaded', content: scope } );
|
||||
};
|
||||
|
||||
this.source.onerror = function() {
|
||||
scope.dispatchEvent( { type: 'error', content: scope } );
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* @property imageUrl
|
||||
* @type String
|
||||
*/
|
||||
this.imageUrl = null;
|
||||
|
||||
/**
|
||||
* @property _powerOf2
|
||||
* @type Boolean
|
||||
* @private
|
||||
*/
|
||||
this._powerOf2 = false;
|
||||
|
||||
};
|
||||
|
||||
PIXI.BaseTexture.prototype.constructor = PIXI.BaseTexture;
|
||||
|
||||
PIXI.EventTarget.mixin(PIXI.BaseTexture.prototype);
|
||||
|
||||
/**
|
||||
* Destroys this base texture
|
||||
*
|
||||
* @method destroy
|
||||
*/
|
||||
PIXI.BaseTexture.prototype.destroy = function()
|
||||
{
|
||||
if(this.imageUrl)
|
||||
{
|
||||
delete PIXI.BaseTextureCache[this.imageUrl];
|
||||
delete PIXI.TextureCache[this.imageUrl];
|
||||
this.imageUrl = null;
|
||||
if (!navigator.isCocoonJS) this.source.src = '';
|
||||
}
|
||||
else if (this.source && this.source._pixiId)
|
||||
{
|
||||
delete PIXI.BaseTextureCache[this.source._pixiId];
|
||||
}
|
||||
this.source = null;
|
||||
|
||||
this.unloadFromGPU();
|
||||
};
|
||||
|
||||
/**
|
||||
* Changes the source image of the texture
|
||||
*
|
||||
* @method updateSourceImage
|
||||
* @param newSrc {String} the path of the image
|
||||
*/
|
||||
PIXI.BaseTexture.prototype.updateSourceImage = function(newSrc)
|
||||
{
|
||||
this.hasLoaded = false;
|
||||
this.source.src = null;
|
||||
this.source.src = newSrc;
|
||||
};
|
||||
|
||||
/**
|
||||
* Sets all glTextures to be dirty.
|
||||
*
|
||||
* @method dirty
|
||||
*/
|
||||
PIXI.BaseTexture.prototype.dirty = function()
|
||||
{
|
||||
for (var i = 0; i < this._glTextures.length; i++)
|
||||
{
|
||||
this._dirty[i] = true;
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* 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.
|
||||
*
|
||||
* @method unloadFromGPU
|
||||
*/
|
||||
PIXI.BaseTexture.prototype.unloadFromGPU = function()
|
||||
{
|
||||
this.dirty();
|
||||
|
||||
// delete the webGL textures if any.
|
||||
for (var i = this._glTextures.length - 1; i >= 0; i--)
|
||||
{
|
||||
var glTexture = this._glTextures[i];
|
||||
var gl = PIXI.glContexts[i];
|
||||
|
||||
if(gl && glTexture)
|
||||
{
|
||||
gl.deleteTexture(glTexture);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
this._glTextures.length = 0;
|
||||
|
||||
this.dirty();
|
||||
};
|
||||
|
||||
/**
|
||||
* 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.
|
||||
*
|
||||
* @static
|
||||
* @method fromImage
|
||||
* @param imageUrl {String} The image url of the texture
|
||||
* @param crossorigin {Boolean}
|
||||
* @param scaleMode {Number} See {{#crossLink "PIXI/scaleModes:property"}}PIXI.scaleModes{{/crossLink}} for possible values
|
||||
* @return BaseTexture
|
||||
*/
|
||||
PIXI.BaseTexture.fromImage = function(imageUrl, crossorigin, scaleMode)
|
||||
{
|
||||
var baseTexture = PIXI.BaseTextureCache[imageUrl];
|
||||
|
||||
if(crossorigin === undefined && imageUrl.indexOf('data:') === -1) crossorigin = true;
|
||||
|
||||
if(!baseTexture)
|
||||
{
|
||||
// new Image() breaks tex loading in some versions of Chrome.
|
||||
// See https://code.google.com/p/chromium/issues/detail?id=238071
|
||||
var image = new Image();//document.createElement('img');
|
||||
if (crossorigin)
|
||||
{
|
||||
image.crossOrigin = '';
|
||||
}
|
||||
|
||||
image.src = imageUrl;
|
||||
baseTexture = new PIXI.BaseTexture(image, scaleMode);
|
||||
baseTexture.imageUrl = imageUrl;
|
||||
PIXI.BaseTextureCache[imageUrl] = baseTexture;
|
||||
|
||||
// if there is an @2x at the end of the url we are going to assume its a highres image
|
||||
if( imageUrl.indexOf(PIXI.RETINA_PREFIX + '.') !== -1)
|
||||
{
|
||||
baseTexture.resolution = 2;
|
||||
}
|
||||
}
|
||||
|
||||
return baseTexture;
|
||||
};
|
||||
|
||||
/**
|
||||
* Helper function that creates a base texture from the given canvas element.
|
||||
*
|
||||
* @static
|
||||
* @method fromCanvas
|
||||
* @param canvas {Canvas} The canvas element source of the texture
|
||||
* @param scaleMode {Number} See {{#crossLink "PIXI/scaleModes:property"}}PIXI.scaleModes{{/crossLink}} for possible values
|
||||
* @return BaseTexture
|
||||
*/
|
||||
PIXI.BaseTexture.fromCanvas = function(canvas, scaleMode)
|
||||
{
|
||||
if(!canvas._pixiId)
|
||||
{
|
||||
canvas._pixiId = 'canvas_' + PIXI.TextureCacheIdGenerator++;
|
||||
}
|
||||
|
||||
var baseTexture = PIXI.BaseTextureCache[canvas._pixiId];
|
||||
|
||||
if(!baseTexture)
|
||||
{
|
||||
baseTexture = new PIXI.BaseTexture(canvas, scaleMode);
|
||||
PIXI.BaseTextureCache[canvas._pixiId] = baseTexture;
|
||||
}
|
||||
|
||||
return baseTexture;
|
||||
};
|
||||
336
app/Lib/Vendor/src/pixi/textures/RenderTexture.js
vendored
Normal file
336
app/Lib/Vendor/src/pixi/textures/RenderTexture.js
vendored
Normal file
|
|
@ -0,0 +1,336 @@
|
|||
/**
|
||||
* @author Mat Groves http://matgroves.com/ @Doormat23
|
||||
*/
|
||||
|
||||
/**
|
||||
* 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
|
||||
*
|
||||
* @class RenderTexture
|
||||
* @extends Texture
|
||||
* @constructor
|
||||
* @param width {Number} The width of the render texture
|
||||
* @param height {Number} The height of the render texture
|
||||
* @param renderer {CanvasRenderer|WebGLRenderer} The renderer used for this RenderTexture
|
||||
* @param scaleMode {Number} See {{#crossLink "PIXI/scaleModes:property"}}PIXI.scaleModes{{/crossLink}} for possible values
|
||||
* @param resolution {Number} The resolution of the texture being generated
|
||||
*/
|
||||
PIXI.RenderTexture = function(width, height, renderer, scaleMode, resolution)
|
||||
{
|
||||
/**
|
||||
* The with of the render texture
|
||||
*
|
||||
* @property width
|
||||
* @type Number
|
||||
*/
|
||||
this.width = width || 100;
|
||||
|
||||
/**
|
||||
* The height of the render texture
|
||||
*
|
||||
* @property height
|
||||
* @type Number
|
||||
*/
|
||||
this.height = height || 100;
|
||||
|
||||
/**
|
||||
* The Resolution of the texture.
|
||||
*
|
||||
* @property resolution
|
||||
* @type Number
|
||||
*/
|
||||
this.resolution = resolution || 1;
|
||||
|
||||
/**
|
||||
* The framing rectangle of the render texture
|
||||
*
|
||||
* @property frame
|
||||
* @type Rectangle
|
||||
*/
|
||||
this.frame = new PIXI.Rectangle(0, 0, this.width * this.resolution, this.height * this.resolution);
|
||||
|
||||
/**
|
||||
* 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)
|
||||
*
|
||||
* @property crop
|
||||
* @type Rectangle
|
||||
*/
|
||||
this.crop = new PIXI.Rectangle(0, 0, this.width * this.resolution, this.height * this.resolution);
|
||||
|
||||
/**
|
||||
* The base texture object that this texture uses
|
||||
*
|
||||
* @property baseTexture
|
||||
* @type BaseTexture
|
||||
*/
|
||||
this.baseTexture = new PIXI.BaseTexture();
|
||||
this.baseTexture.width = this.width * this.resolution;
|
||||
this.baseTexture.height = this.height * this.resolution;
|
||||
this.baseTexture._glTextures = [];
|
||||
this.baseTexture.resolution = this.resolution;
|
||||
|
||||
this.baseTexture.scaleMode = scaleMode || PIXI.scaleModes.DEFAULT;
|
||||
|
||||
this.baseTexture.hasLoaded = true;
|
||||
|
||||
PIXI.Texture.call(this,
|
||||
this.baseTexture,
|
||||
new PIXI.Rectangle(0, 0, this.width, this.height)
|
||||
);
|
||||
|
||||
/**
|
||||
* The renderer this RenderTexture uses. A RenderTexture can only belong to one renderer at the moment if its webGL.
|
||||
*
|
||||
* @property renderer
|
||||
* @type CanvasRenderer|WebGLRenderer
|
||||
*/
|
||||
this.renderer = renderer || PIXI.defaultRenderer;
|
||||
|
||||
if(this.renderer.type === PIXI.WEBGL_RENDERER)
|
||||
{
|
||||
var gl = this.renderer.gl;
|
||||
this.baseTexture._dirty[gl.id] = false;
|
||||
|
||||
this.textureBuffer = new PIXI.FilterTexture(gl, this.width * this.resolution, this.height * this.resolution, this.baseTexture.scaleMode);
|
||||
this.baseTexture._glTextures[gl.id] = this.textureBuffer.texture;
|
||||
|
||||
this.render = this.renderWebGL;
|
||||
this.projection = new PIXI.Point(this.width*0.5, -this.height*0.5);
|
||||
}
|
||||
else
|
||||
{
|
||||
this.render = this.renderCanvas;
|
||||
this.textureBuffer = new PIXI.CanvasBuffer(this.width* this.resolution, this.height* this.resolution);
|
||||
this.baseTexture.source = this.textureBuffer.canvas;
|
||||
}
|
||||
|
||||
/**
|
||||
* @property valid
|
||||
* @type Boolean
|
||||
*/
|
||||
this.valid = true;
|
||||
|
||||
this._updateUvs();
|
||||
};
|
||||
|
||||
PIXI.RenderTexture.prototype = Object.create(PIXI.Texture.prototype);
|
||||
PIXI.RenderTexture.prototype.constructor = PIXI.RenderTexture;
|
||||
|
||||
/**
|
||||
* Resizes the RenderTexture.
|
||||
*
|
||||
* @method resize
|
||||
* @param width {Number} The width to resize to.
|
||||
* @param height {Number} The height to resize to.
|
||||
* @param updateBase {Boolean} Should the baseTexture.width and height values be resized as well?
|
||||
*/
|
||||
PIXI.RenderTexture.prototype.resize = function(width, height, updateBase)
|
||||
{
|
||||
if (width === this.width && height === this.height)return;
|
||||
|
||||
this.valid = (width > 0 && height > 0);
|
||||
|
||||
this.width = this.frame.width = this.crop.width = width;
|
||||
this.height = this.frame.height = this.crop.height = height;
|
||||
|
||||
if (updateBase)
|
||||
{
|
||||
this.baseTexture.width = this.width;
|
||||
this.baseTexture.height = this.height;
|
||||
}
|
||||
|
||||
if (this.renderer.type === PIXI.WEBGL_RENDERER)
|
||||
{
|
||||
this.projection.x = this.width / 2;
|
||||
this.projection.y = -this.height / 2;
|
||||
}
|
||||
|
||||
if(!this.valid)return;
|
||||
|
||||
this.textureBuffer.resize(this.width * this.resolution, this.height * this.resolution);
|
||||
};
|
||||
|
||||
/**
|
||||
* Clears the RenderTexture.
|
||||
*
|
||||
* @method clear
|
||||
*/
|
||||
PIXI.RenderTexture.prototype.clear = function()
|
||||
{
|
||||
if(!this.valid)return;
|
||||
|
||||
if (this.renderer.type === PIXI.WEBGL_RENDERER)
|
||||
{
|
||||
this.renderer.gl.bindFramebuffer(this.renderer.gl.FRAMEBUFFER, this.textureBuffer.frameBuffer);
|
||||
}
|
||||
|
||||
this.textureBuffer.clear();
|
||||
};
|
||||
|
||||
/**
|
||||
* This function will draw the display object to the texture.
|
||||
*
|
||||
* @method renderWebGL
|
||||
* @param displayObject {DisplayObject} The display object to render this texture on
|
||||
* @param [matrix] {Matrix} Optional matrix to apply to the display object before rendering.
|
||||
* @param [clear] {Boolean} If true the texture will be cleared before the displayObject is drawn
|
||||
* @private
|
||||
*/
|
||||
PIXI.RenderTexture.prototype.renderWebGL = function(displayObject, matrix, clear)
|
||||
{
|
||||
if(!this.valid)return;
|
||||
//TOOD replace position with matrix..
|
||||
|
||||
//Lets create a nice matrix to apply to our display object. Frame buffers come in upside down so we need to flip the matrix
|
||||
var wt = displayObject.worldTransform;
|
||||
wt.identity();
|
||||
wt.translate(0, this.projection.y * 2);
|
||||
if(matrix)wt.append(matrix);
|
||||
wt.scale(1,-1);
|
||||
|
||||
// setWorld Alpha to ensure that the object is renderer at full opacity
|
||||
displayObject.worldAlpha = 1;
|
||||
|
||||
// Time to update all the children of the displayObject with the new matrix..
|
||||
var children = displayObject.children;
|
||||
|
||||
for(var i=0,j=children.length; i<j; i++)
|
||||
{
|
||||
children[i].updateTransform();
|
||||
}
|
||||
|
||||
// time for the webGL fun stuff!
|
||||
var gl = this.renderer.gl;
|
||||
|
||||
gl.viewport(0, 0, this.width * this.resolution, this.height * this.resolution);
|
||||
|
||||
gl.bindFramebuffer(gl.FRAMEBUFFER, this.textureBuffer.frameBuffer );
|
||||
|
||||
if(clear)this.textureBuffer.clear();
|
||||
|
||||
this.renderer.spriteBatch.dirty = true;
|
||||
|
||||
this.renderer.renderDisplayObject(displayObject, this.projection, this.textureBuffer.frameBuffer);
|
||||
|
||||
this.renderer.spriteBatch.dirty = true;
|
||||
};
|
||||
|
||||
|
||||
/**
|
||||
* This function will draw the display object to the texture.
|
||||
*
|
||||
* @method renderCanvas
|
||||
* @param displayObject {DisplayObject} The display object to render this texture on
|
||||
* @param [matrix] {Matrix} Optional matrix to apply to the display object before rendering.
|
||||
* @param [clear] {Boolean} If true the texture will be cleared before the displayObject is drawn
|
||||
* @private
|
||||
*/
|
||||
PIXI.RenderTexture.prototype.renderCanvas = function(displayObject, matrix, clear)
|
||||
{
|
||||
if(!this.valid)return;
|
||||
|
||||
var wt = displayObject.worldTransform;
|
||||
wt.identity();
|
||||
if(matrix)wt.append(matrix);
|
||||
|
||||
// setWorld Alpha to ensure that the object is renderer at full opacity
|
||||
displayObject.worldAlpha = 1;
|
||||
|
||||
// Time to update all the children of the displayObject with the new matrix..
|
||||
var children = displayObject.children;
|
||||
|
||||
for(var i = 0, j = children.length; i < j; i++)
|
||||
{
|
||||
children[i].updateTransform();
|
||||
}
|
||||
|
||||
if(clear)this.textureBuffer.clear();
|
||||
|
||||
var context = this.textureBuffer.context;
|
||||
|
||||
var realResolution = this.renderer.resolution;
|
||||
|
||||
this.renderer.resolution = this.resolution;
|
||||
|
||||
this.renderer.renderDisplayObject(displayObject, context);
|
||||
|
||||
this.renderer.resolution = realResolution;
|
||||
};
|
||||
|
||||
/**
|
||||
* Will return a HTML Image of the texture
|
||||
*
|
||||
* @method getImage
|
||||
* @return {Image}
|
||||
*/
|
||||
PIXI.RenderTexture.prototype.getImage = function()
|
||||
{
|
||||
var image = new Image();
|
||||
image.src = this.getBase64();
|
||||
return image;
|
||||
};
|
||||
|
||||
/**
|
||||
* Will return a a base64 encoded string of this texture. It works by calling RenderTexture.getCanvas and then running toDataURL on that.
|
||||
*
|
||||
* @method getBase64
|
||||
* @return {String} A base64 encoded string of the texture.
|
||||
*/
|
||||
PIXI.RenderTexture.prototype.getBase64 = function()
|
||||
{
|
||||
return this.getCanvas().toDataURL();
|
||||
};
|
||||
|
||||
/**
|
||||
* Creates a Canvas element, renders this RenderTexture to it and then returns it.
|
||||
*
|
||||
* @method getCanvas
|
||||
* @return {HTMLCanvasElement} A Canvas element with the texture rendered on.
|
||||
*/
|
||||
PIXI.RenderTexture.prototype.getCanvas = function()
|
||||
{
|
||||
if (this.renderer.type === PIXI.WEBGL_RENDERER)
|
||||
{
|
||||
var gl = this.renderer.gl;
|
||||
var width = this.textureBuffer.width;
|
||||
var height = this.textureBuffer.height;
|
||||
|
||||
var webGLPixels = new Uint8Array(4 * width * height);
|
||||
|
||||
gl.bindFramebuffer(gl.FRAMEBUFFER, this.textureBuffer.frameBuffer);
|
||||
gl.readPixels(0, 0, width, height, gl.RGBA, gl.UNSIGNED_BYTE, webGLPixels);
|
||||
gl.bindFramebuffer(gl.FRAMEBUFFER, null);
|
||||
|
||||
var tempCanvas = new PIXI.CanvasBuffer(width, height);
|
||||
var canvasData = tempCanvas.context.getImageData(0, 0, width, height);
|
||||
canvasData.data.set(webGLPixels);
|
||||
|
||||
tempCanvas.context.putImageData(canvasData, 0, 0);
|
||||
|
||||
return tempCanvas.canvas;
|
||||
}
|
||||
else
|
||||
{
|
||||
return this.textureBuffer.canvas;
|
||||
}
|
||||
};
|
||||
|
||||
PIXI.RenderTexture.tempMatrix = new PIXI.Matrix();
|
||||
329
app/Lib/Vendor/src/pixi/textures/Texture.js
vendored
Normal file
329
app/Lib/Vendor/src/pixi/textures/Texture.js
vendored
Normal file
|
|
@ -0,0 +1,329 @@
|
|||
/**
|
||||
* @author Mat Groves http://matgroves.com/ @Doormat23
|
||||
*/
|
||||
|
||||
PIXI.TextureCache = {};
|
||||
PIXI.FrameCache = {};
|
||||
|
||||
PIXI.TextureCacheIdGenerator = 0;
|
||||
|
||||
/**
|
||||
* 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.
|
||||
*
|
||||
* @class Texture
|
||||
* @uses EventTarget
|
||||
* @constructor
|
||||
* @param baseTexture {BaseTexture} The base texture source to create the texture from
|
||||
* @param frame {Rectangle} The rectangle frame of the texture to show
|
||||
* @param [crop] {Rectangle} The area of original texture
|
||||
* @param [trim] {Rectangle} Trimmed texture rectangle
|
||||
*/
|
||||
PIXI.Texture = function(baseTexture, frame, crop, trim)
|
||||
{
|
||||
/**
|
||||
* Does this Texture have any frame data assigned to it?
|
||||
*
|
||||
* @property noFrame
|
||||
* @type Boolean
|
||||
*/
|
||||
this.noFrame = false;
|
||||
|
||||
if (!frame)
|
||||
{
|
||||
this.noFrame = true;
|
||||
frame = new PIXI.Rectangle(0,0,1,1);
|
||||
}
|
||||
|
||||
if (baseTexture instanceof PIXI.Texture)
|
||||
{
|
||||
baseTexture = baseTexture.baseTexture;
|
||||
}
|
||||
|
||||
/**
|
||||
* The base texture that this texture uses.
|
||||
*
|
||||
* @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;
|
||||
|
||||
/**
|
||||
* The texture trim data.
|
||||
*
|
||||
* @property trim
|
||||
* @type Rectangle
|
||||
*/
|
||||
this.trim = trim;
|
||||
|
||||
/**
|
||||
* This will let the renderer know if the texture is valid. If it's not then it cannot be rendered.
|
||||
*
|
||||
* @property valid
|
||||
* @type Boolean
|
||||
*/
|
||||
this.valid = false;
|
||||
|
||||
/**
|
||||
* This will let a renderer know that a texture has been updated (used mainly for webGL uv updates)
|
||||
*
|
||||
* @property requiresUpdate
|
||||
* @type Boolean
|
||||
*/
|
||||
this.requiresUpdate = false;
|
||||
|
||||
/**
|
||||
* The WebGL UV data cache.
|
||||
*
|
||||
* @property _uvs
|
||||
* @type Object
|
||||
* @private
|
||||
*/
|
||||
this._uvs = null;
|
||||
|
||||
/**
|
||||
* The width of the Texture in pixels.
|
||||
*
|
||||
* @property width
|
||||
* @type Number
|
||||
*/
|
||||
this.width = 0;
|
||||
|
||||
/**
|
||||
* The height of the Texture in pixels.
|
||||
*
|
||||
* @property height
|
||||
* @type Number
|
||||
*/
|
||||
this.height = 0;
|
||||
|
||||
/**
|
||||
* 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)
|
||||
*
|
||||
* @property crop
|
||||
* @type Rectangle
|
||||
*/
|
||||
this.crop = crop || new PIXI.Rectangle(0, 0, 1, 1);
|
||||
|
||||
if (baseTexture.hasLoaded)
|
||||
{
|
||||
if (this.noFrame) frame = new PIXI.Rectangle(0, 0, baseTexture.width, baseTexture.height);
|
||||
this.setFrame(frame);
|
||||
}
|
||||
else
|
||||
{
|
||||
baseTexture.addEventListener('loaded', this.onBaseTextureLoaded.bind(this));
|
||||
}
|
||||
};
|
||||
|
||||
PIXI.Texture.prototype.constructor = PIXI.Texture;
|
||||
PIXI.EventTarget.mixin(PIXI.Texture.prototype);
|
||||
|
||||
/**
|
||||
* Called when the base texture is loaded
|
||||
*
|
||||
* @method onBaseTextureLoaded
|
||||
* @private
|
||||
*/
|
||||
PIXI.Texture.prototype.onBaseTextureLoaded = function()
|
||||
{
|
||||
var baseTexture = this.baseTexture;
|
||||
baseTexture.removeEventListener('loaded', this.onLoaded);
|
||||
|
||||
if (this.noFrame) this.frame = new PIXI.Rectangle(0, 0, baseTexture.width, baseTexture.height);
|
||||
|
||||
this.setFrame(this.frame);
|
||||
|
||||
this.dispatchEvent( { type: 'update', content: this } );
|
||||
};
|
||||
|
||||
/**
|
||||
* Destroys this texture
|
||||
*
|
||||
* @method destroy
|
||||
* @param destroyBase {Boolean} Whether to destroy the base texture as well
|
||||
*/
|
||||
PIXI.Texture.prototype.destroy = function(destroyBase)
|
||||
{
|
||||
if (destroyBase) this.baseTexture.destroy();
|
||||
|
||||
this.valid = false;
|
||||
};
|
||||
|
||||
/**
|
||||
* Specifies the region of the baseTexture that this texture will use.
|
||||
*
|
||||
* @method setFrame
|
||||
* @param frame {Rectangle} The frame of the texture to set it to
|
||||
*/
|
||||
PIXI.Texture.prototype.setFrame = function(frame)
|
||||
{
|
||||
this.noFrame = false;
|
||||
|
||||
this.frame = frame;
|
||||
this.width = frame.width;
|
||||
this.height = frame.height;
|
||||
|
||||
this.crop.x = frame.x;
|
||||
this.crop.y = frame.y;
|
||||
this.crop.width = frame.width;
|
||||
this.crop.height = frame.height;
|
||||
|
||||
if (!this.trim && (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.valid = frame && frame.width && frame.height && this.baseTexture.source && this.baseTexture.hasLoaded;
|
||||
|
||||
if (this.trim)
|
||||
{
|
||||
this.width = this.trim.width;
|
||||
this.height = this.trim.height;
|
||||
this.frame.width = this.trim.width;
|
||||
this.frame.height = this.trim.height;
|
||||
}
|
||||
|
||||
if (this.valid) this._updateUvs();
|
||||
|
||||
};
|
||||
|
||||
/**
|
||||
* Updates the internal WebGL UV cache.
|
||||
*
|
||||
* @method _updateUvs
|
||||
* @private
|
||||
*/
|
||||
PIXI.Texture.prototype._updateUvs = function()
|
||||
{
|
||||
if(!this._uvs)this._uvs = new PIXI.TextureUvs();
|
||||
|
||||
var frame = this.crop;
|
||||
var tw = this.baseTexture.width;
|
||||
var th = this.baseTexture.height;
|
||||
|
||||
this._uvs.x0 = frame.x / tw;
|
||||
this._uvs.y0 = frame.y / th;
|
||||
|
||||
this._uvs.x1 = (frame.x + frame.width) / tw;
|
||||
this._uvs.y1 = frame.y / th;
|
||||
|
||||
this._uvs.x2 = (frame.x + frame.width) / tw;
|
||||
this._uvs.y2 = (frame.y + frame.height) / th;
|
||||
|
||||
this._uvs.x3 = frame.x / tw;
|
||||
this._uvs.y3 = (frame.y + frame.height) / th;
|
||||
};
|
||||
|
||||
/**
|
||||
* 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.
|
||||
*
|
||||
* @static
|
||||
* @method fromImage
|
||||
* @param imageUrl {String} The image url of the texture
|
||||
* @param crossorigin {Boolean} Whether requests should be treated as crossorigin
|
||||
* @param scaleMode {Number} See {{#crossLink "PIXI/scaleModes:property"}}PIXI.scaleModes{{/crossLink}} for possible values
|
||||
* @return Texture
|
||||
*/
|
||||
PIXI.Texture.fromImage = function(imageUrl, crossorigin, scaleMode)
|
||||
{
|
||||
var texture = PIXI.TextureCache[imageUrl];
|
||||
|
||||
if(!texture)
|
||||
{
|
||||
texture = new PIXI.Texture(PIXI.BaseTexture.fromImage(imageUrl, crossorigin, scaleMode));
|
||||
PIXI.TextureCache[imageUrl] = texture;
|
||||
}
|
||||
|
||||
return 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.
|
||||
*
|
||||
* @static
|
||||
* @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 ');
|
||||
return texture;
|
||||
};
|
||||
|
||||
/**
|
||||
* Helper function that creates a new a Texture based on the given canvas element.
|
||||
*
|
||||
* @static
|
||||
* @method fromCanvas
|
||||
* @param canvas {Canvas} The canvas element source of the texture
|
||||
* @param scaleMode {Number} See {{#crossLink "PIXI/scaleModes:property"}}PIXI.scaleModes{{/crossLink}} for possible values
|
||||
* @return Texture
|
||||
*/
|
||||
PIXI.Texture.fromCanvas = function(canvas, scaleMode)
|
||||
{
|
||||
var baseTexture = PIXI.BaseTexture.fromCanvas(canvas, scaleMode);
|
||||
|
||||
return new PIXI.Texture( baseTexture );
|
||||
|
||||
};
|
||||
|
||||
/**
|
||||
* Adds a texture to the global PIXI.TextureCache. This cache is shared across the whole PIXI object.
|
||||
*
|
||||
* @static
|
||||
* @method addTextureToCache
|
||||
* @param texture {Texture} The Texture to add to the cache.
|
||||
* @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 global PIXI.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];
|
||||
delete PIXI.TextureCache[id];
|
||||
delete PIXI.BaseTextureCache[id];
|
||||
return texture;
|
||||
};
|
||||
|
||||
PIXI.TextureUvs = function()
|
||||
{
|
||||
this.x0 = 0;
|
||||
this.y0 = 0;
|
||||
|
||||
this.x1 = 0;
|
||||
this.y1 = 0;
|
||||
|
||||
this.x2 = 0;
|
||||
this.y2 = 0;
|
||||
|
||||
this.x3 = 0;
|
||||
this.y3 = 0;
|
||||
};
|
||||
|
||||
PIXI.Texture.emptyTexture = new PIXI.Texture(new PIXI.BaseTexture());
|
||||
|
||||
168
app/Lib/Vendor/src/pixi/textures/VideoTexture.js
vendored
Normal file
168
app/Lib/Vendor/src/pixi/textures/VideoTexture.js
vendored
Normal file
|
|
@ -0,0 +1,168 @@
|
|||
/**
|
||||
* A texture of a [playing] Video.
|
||||
*
|
||||
* See the ["deus" demo](http://www.goodboydigital.com/pixijs/examples/deus/).
|
||||
*
|
||||
* @class VideoTexture
|
||||
* @extends BaseTexture
|
||||
* @constructor
|
||||
* @param source {HTMLVideoElement}
|
||||
* @param scaleMode {Number} See {{#crossLink "PIXI/scaleModes:property"}}PIXI.scaleModes{{/crossLink}} for possible values
|
||||
*/
|
||||
PIXI.VideoTexture = function( source, scaleMode )
|
||||
{
|
||||
if( !source ){
|
||||
throw new Error( 'No video source element specified.' );
|
||||
}
|
||||
|
||||
// hook in here to check if video is already available.
|
||||
// PIXI.BaseTexture looks for a source.complete boolean, plus width & height.
|
||||
|
||||
if( (source.readyState === source.HAVE_ENOUGH_DATA || source.readyState === source.HAVE_FUTURE_DATA ) && source.width && source.height )
|
||||
{
|
||||
source.complete = true;
|
||||
}
|
||||
|
||||
PIXI.BaseTexture.call( this, source, scaleMode );
|
||||
|
||||
this.autoUpdate = false;
|
||||
this.updateBound = this._onUpdate.bind(this);
|
||||
|
||||
if( !source.complete )
|
||||
{
|
||||
this._onCanPlay = this.onCanPlay.bind(this);
|
||||
|
||||
source.addEventListener( 'canplay', this._onCanPlay );
|
||||
source.addEventListener( 'canplaythrough', this._onCanPlay );
|
||||
|
||||
// started playing..
|
||||
source.addEventListener( 'play', this.onPlayStart.bind(this) );
|
||||
source.addEventListener( 'pause', this.onPlayStop.bind(this) );
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
PIXI.VideoTexture.prototype = Object.create( PIXI.BaseTexture.prototype );
|
||||
|
||||
PIXI.VideoTexture.constructor = PIXI.VideoTexture;
|
||||
|
||||
PIXI.VideoTexture.prototype._onUpdate = function()
|
||||
{
|
||||
if(this.autoUpdate)
|
||||
{
|
||||
window.requestAnimationFrame(this.updateBound);
|
||||
this.dirty();
|
||||
}
|
||||
};
|
||||
|
||||
PIXI.VideoTexture.prototype.onPlayStart = function()
|
||||
{
|
||||
if(!this.autoUpdate)
|
||||
{
|
||||
window.requestAnimationFrame(this.updateBound);
|
||||
this.autoUpdate = true;
|
||||
}
|
||||
};
|
||||
|
||||
PIXI.VideoTexture.prototype.onPlayStop = function()
|
||||
{
|
||||
this.autoUpdate = false;
|
||||
};
|
||||
|
||||
PIXI.VideoTexture.prototype.onCanPlay = function()
|
||||
{
|
||||
if( event.type === 'canplaythrough' )
|
||||
{
|
||||
this.hasLoaded = true;
|
||||
|
||||
|
||||
if( this.source )
|
||||
{
|
||||
this.source.removeEventListener( 'canplay', this._onCanPlay );
|
||||
this.source.removeEventListener( 'canplaythrough', this._onCanPlay );
|
||||
|
||||
this.width = this.source.videoWidth;
|
||||
this.height = this.source.videoHeight;
|
||||
|
||||
// prevent multiple loaded dispatches..
|
||||
if( !this.__loaded ){
|
||||
this.__loaded = true;
|
||||
this.dispatchEvent( { type: 'loaded', content: this } );
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
PIXI.VideoTexture.prototype.destroy = function()
|
||||
{
|
||||
if( this.source && this.source._pixiId )
|
||||
{
|
||||
PIXI.BaseTextureCache[ this.source._pixiId ] = null;
|
||||
delete PIXI.BaseTextureCache[ this.source._pixiId ];
|
||||
|
||||
this.source._pixiId = null;
|
||||
delete this.source._pixiId;
|
||||
}
|
||||
|
||||
PIXI.BaseTexture.prototype.destroy.call( this );
|
||||
};
|
||||
|
||||
/**
|
||||
* Mimic Pixi BaseTexture.from.... method.
|
||||
*
|
||||
* @static
|
||||
* @method baseTextureFromVideo
|
||||
* @param video {HTMLVideoElement}
|
||||
* @param scaleMode {Number} See {{#crossLink "PIXI/scaleModes:property"}}PIXI.scaleModes{{/crossLink}} for possible values
|
||||
* @return {VideoTexture}
|
||||
*/
|
||||
PIXI.VideoTexture.baseTextureFromVideo = function( video, scaleMode )
|
||||
{
|
||||
if( !video._pixiId )
|
||||
{
|
||||
video._pixiId = 'video_' + PIXI.TextureCacheIdGenerator++;
|
||||
}
|
||||
|
||||
var baseTexture = PIXI.BaseTextureCache[ video._pixiId ];
|
||||
|
||||
if( !baseTexture )
|
||||
{
|
||||
baseTexture = new PIXI.VideoTexture( video, scaleMode );
|
||||
PIXI.BaseTextureCache[ video._pixiId ] = baseTexture;
|
||||
}
|
||||
|
||||
return baseTexture;
|
||||
};
|
||||
|
||||
/**
|
||||
* Mimic Pixi BaseTexture.from.... method.
|
||||
*
|
||||
* @static
|
||||
* @method textureFromVideo
|
||||
* @param video {HTMLVideoElement}
|
||||
* @param scaleMode {Number} See {{#crossLink "PIXI/scaleModes:property"}}PIXI.scaleModes{{/crossLink}} for possible values
|
||||
* @return {Texture} A Texture, but not a VideoTexture.
|
||||
*/
|
||||
PIXI.VideoTexture.textureFromVideo = function( video, scaleMode )
|
||||
{
|
||||
var baseTexture = PIXI.VideoTexture.baseTextureFromVideo( video, scaleMode );
|
||||
return new PIXI.Texture( baseTexture );
|
||||
};
|
||||
|
||||
/**
|
||||
* Mimic Pixi BaseTexture.from.... method.
|
||||
*
|
||||
* @static
|
||||
* @method fromUrl
|
||||
* @param videoSrc {String} The URL for the video.
|
||||
* @param scaleMode {Number} See {{#crossLink "PIXI/scaleModes:property"}}PIXI.scaleModes{{/crossLink}} for possible values
|
||||
* @return {VideoTexture}
|
||||
*/
|
||||
PIXI.VideoTexture.fromUrl = function( videoSrc, scaleMode )
|
||||
{
|
||||
var video = document.createElement('video');
|
||||
video.src = videoSrc;
|
||||
video.autoPlay = true;
|
||||
video.play();
|
||||
return PIXI.VideoTexture.textureFromVideo( video, scaleMode);
|
||||
};
|
||||
Loading…
Add table
Add a link
Reference in a new issue