Mirrors/phaser
2
0
Fork 0
mirror of https://github.com/photonstorm/phaser synced 2024-11-23 21:24:09 +00:00
Code Issues Projects Releases Packages Wiki Activity

Merged final Pixi v2.1.0 release.

Browse source
This commit is contained in:
photonstorm 2014-11-11 23:02:57 +00:00
parent 7d0dc68a30
commit 1352b526c7
16 changed files with 219 additions and 64 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

27
README.md
View file

@ -75,6 +75,7 @@ Version 2.2.0 - "Bethal" - in development
### New Features
* Updated to Pixi v2.1.0 - see seprate change log entry below.
* Cache.getRenderTexture will retrieve a RenderTexture that is stored in the Phaser Cache. This method replaces Cache.getTexture which is now deprecated.
* Cache.autoResolveURL is a new boolean (default `false`) that automatically builds a cached map of all loaded assets vs. their absolute URLs, for use with Cache.getURL and Cache.checkURL. Note that in 2.1.3 and earlier this was enabled by default, but has since been moved behind this property which needs to be set to `true` *before* you load any assets to enable.
* You can now call Tween.to again on a Tween that has already completed. This will re-use the same tween, on the original object, without having to recreate the Tween again. This allows a single tween instance to be re-used multiple times, providing they are linked to the same object (thanks InsaneHero)
@ -142,7 +143,6 @@ Version 2.2.0 - "Bethal" - in development
* ArcadePhysics.skipQuadTree is now set to `true` by default. A QuadTree is a wonderful thing if the objects in your game are well spaced out. But in tightly packed games, especially those with tilemaps or single-screen games, they are a considerable performance drain and eat up CPU. We've taken the decision to disable the Arcade Physics QuadTree by default. It's all still in there and can be re-enabled via `game.physics.arcade.skipQuadTree = false`, but please only do so if you're sure your game benefits from this.
* Phaser.DOM now houses new DOM functions. Some have been moved over from ScaleManager as appropriate.
### Bug Fixes
* Tilemaps in WebGL wouldn't update after the first frame due to a subtle change in how Pixi uploads new textures to the GPU.
@ -161,6 +161,31 @@ Version 2.2.0 - "Bethal" - in development
* Lots of the Cache getters (such as `Cache.getbitmapData`) would return `undefined` if the asset couldn't be found. They now all consistently return `null` for missing entries (thanks @Matoking #1305)
* Phaser games should now work again from the CocoonJS Launcher.
### Pixi 2.1.0 New Features
* unloadFromGPU added to PIXI.BaseTexture
* PIXI.VideoTexture added
* PIXI.RoundedRectangle added
* Ensured all float32arrays use PIXI.Float32Array
* Removed the use of call in updateTransform (as its 10x faster to run the function directly)
* autoResize option added to renderer options (default is false). Pixi no longer automatically changes the style of the canvas.
* PIXI.RenderTexture.getCanvas optimized
### Pixi 2.1.0 Bug Fixes
* Fix destroy method of PIXI.WebGLRenderer
* Fixed Graphics.drawRoundedRectangle
* Fixed Graphics.arcTo issue
* Fixed Graphics.arc issue
* Fixed Graphics.cacheAsBitmap alpha issue
* Fixed PIXI.Strip alpha issue
* Fixed PIXI.DisplayObject.cacheAsBitmap alpha issue
* Fixed PIXI.RenderTexture Canvas Clear bug
* Fixed PIXI.DisplayObject.updateTransform issue
* Fixed webGL Shader textures issue
* Fixed PIXI.DisplayObject.getLocalPosition()
* Fixed CocoonJS crashing, when loading destroyed texture
* Fix eventTarget emit bug
For details about changes made in previous versions of Phaser see the full Change Log at https://github.com/photonstorm/phaser/blob/master/CHANGELOG.md

1
build/config.php
View file

@ -39,6 +39,7 @@
<script src="$path/src/pixi/Pixi.js"></script>
<script src="$path/src/pixi/geom/Matrix.js"></script>
<script src="$path/src/pixi/geom/Polygon.js"></script>
<script src="$path/src/pixi/geom/RoundedRectangle.js"></script>
<script src="$path/src/pixi/display/DisplayObject.js"></script>
<script src="$path/src/pixi/display/DisplayObjectContainer.js"></script>
<script src="$path/src/pixi/display/Sprite.js"></script>

2
src/Phaser.js
View file

@ -10,7 +10,7 @@
*/
var Phaser = Phaser || {
VERSION: '2.2.0-RC3',
VERSION: '2.2.0-RC4',
GAMES: [],
AUTO: 0,

1
src/input/Input.js
View file

@ -776,6 +776,7 @@ Phaser.Input.prototype = {
for (var i = 0; i < this.pointers.length; i++)
{
var pointer = this.pointers[i];
if (pointer.pointerId === pointerId)
{
return pointer;

4
src/pixi/InteractionData.js
View file

@ -49,8 +49,8 @@ PIXI.InteractionData.prototype.getLocalPosition = function(displayObject, point)
var global = this.global;
// do a cheeky transform to get the mouse coords;
var a00 = worldTransform.a, a01 = worldTransform.b, a02 = worldTransform.tx,
a10 = worldTransform.c, a11 = worldTransform.d, a12 = worldTransform.ty,
var a00 = worldTransform.a, a01 = worldTransform.c, a02 = worldTransform.tx,
a10 = worldTransform.b, a11 = worldTransform.d, a12 = worldTransform.ty,
id = 1 / (a00 * a11 + a01 * -a10);
point = point || new PIXI.Point();

5
src/pixi/Pixi.js
View file

@ -16,7 +16,7 @@ PIXI.WEBGL_RENDERER = 0;
PIXI.CANVAS_RENDERER = 1;
// useful for testing against if your lib is using pixi.
PIXI.VERSION = "v2.0.0";
PIXI.VERSION = "v2.1.0";
// the various blend modes supported by pixi
@ -81,7 +81,8 @@ PIXI.defaultRenderOptions = {
antialias:false,
preserveDrawingBuffer:false,
resolution:1,
clearBeforeRender:true
clearBeforeRender:true,
autoResize:false
}
PIXI.sayHello = function (type)

16
src/pixi/display/DisplayObject.js
View file

@ -518,13 +518,14 @@ PIXI.DisplayObject.prototype.updateTransform = function()
// lets do the fast version as we know there is no rotation..
a = this.scale.x;
d = this.scale.y;
tx = this.position.x - this.pivot.x * a;
ty = this.position.y - this.pivot.y * d;
wt.a = pt.a * a;
wt.b = pt.b * d;
wt.c = pt.c * a;
wt.d = pt.d * d;
tx = this.position.x;
ty = this.position.y;
wt.a = a * pt.a;
wt.b = a * pt.b;
wt.c = d * pt.c;
wt.d = d * pt.d;
wt.tx = tx * pt.a + ty * pt.c + pt.tx;
wt.ty = tx * pt.b + ty * pt.d + pt.ty;
}
@ -540,6 +541,9 @@ PIXI.DisplayObject.prototype.updateTransform = function()
};
// performance increase to avoid using call.. (10x faster)
PIXI.DisplayObject.prototype.displayObjectUpdateTransform = PIXI.DisplayObject.prototype.updateTransform;
/**
* Retrieves the bounds of the displayObject as a rectangle object
*

11
src/pixi/display/DisplayObjectContainer.js
View file

@ -22,12 +22,16 @@ PIXI.DisplayObjectContainer = function()
* @readOnly
*/
this.children = [];
// fast access to update transform..
};
// constructor
PIXI.DisplayObjectContainer.prototype = Object.create( PIXI.DisplayObject.prototype );
PIXI.DisplayObjectContainer.prototype.constructor = PIXI.DisplayObjectContainer;
/**
* The width of the displayObjectContainer, setting this will actually modify the scale to achieve the value set
*
@ -280,7 +284,9 @@ PIXI.DisplayObjectContainer.prototype.updateTransform = function()
{
if(!this.visible)return;
PIXI.DisplayObject.prototype.updateTransform.call( this );
this.displayObjectUpdateTransform();
//PIXI.DisplayObject.prototype.updateTransform.call( this );
if(this._cacheAsBitmap)return;
@ -290,6 +296,9 @@ PIXI.DisplayObjectContainer.prototype.updateTransform = function()
}
};
// performance increase to avoid using call.. (10x faster)
PIXI.DisplayObjectContainer.prototype.displayObjectContainerUpdateTransform = PIXI.DisplayObjectContainer.prototype.updateTransform;
/**
* Retrieves the bounds of the displayObjectContainer as a rectangle. The bounds calculation takes all visible children into consideration.
*

94
src/pixi/geom/RoundedRectangle.js Normal file
View file

@ -0,0 +1,94 @@
/**
* @author Mat Groves http://matgroves.com/
*/
/**
* the Rounded Rectangle object is an area defined by its position and has nice rounded corners, as indicated by its top-left corner point (x, y) and by its width and its height.
*
* @class Rounded Rectangle
* @constructor
* @param x {Number} The X coordinate of the upper-left corner of the rounded rectangle
* @param y {Number} The Y coordinate of the upper-left corner of the rounded rectangle
* @param width {Number} The overall width of this rounded rectangle
* @param height {Number} The overall height of this rounded rectangle
* @param radius {Number} The overall radius of this corners of this rounded rectangle
*/
PIXI.RoundedRectangle = function(x, y, width, height, radius)
{
/**
* @property x
* @type Number
* @default 0
*/
this.x = x || 0;
/**
* @property y
* @type Number
* @default 0
*/
this.y = y || 0;
/**
* @property width
* @type Number
* @default 0
*/
this.width = width || 0;
/**
* @property height
* @type Number
* @default 0
*/
this.height = height || 0;
/**
* @property radius
* @type Number
* @default 20
*/
this.radius = radius || 20;
};
/**
* Creates a clone of this Rounded Rectangle
*
* @method clone
* @return {rounded Rectangle} a copy of the rounded rectangle
*/
PIXI.RoundedRectangle.prototype.clone = function()
{
return new PIXI.RoundedRectangle(this.x, this.y, this.width, this.height, this.radius);
};
/**
* Checks whether the x and y coordinates given are contained within this Rounded Rectangle
*
* @method contains
* @param x {Number} The X coordinate of the point to test
* @param y {Number} The Y coordinate of the point to test
* @return {Boolean} Whether the x/y coordinates are within this Rounded Rectangle
*/
PIXI.RoundedRectangle.prototype.contains = function(x, y)
{
if(this.width <= 0 || this.height <= 0)
return false;
var x1 = this.x;
if(x >= x1 && x <= x1 + this.width)
{
var y1 = this.y;
if(y >= y1 && y <= y1 + this.height)
{
return true;
}
}
return false;
};
// constructor
PIXI.RoundedRectangle.prototype.constructor = PIXI.RoundedRectangle;

60
src/pixi/primitives/Graphics.js
View file

@ -101,6 +101,8 @@ PIXI.Graphics = function()
*/
this.boundsPadding = 0;
this._localBounds = new PIXI.Rectangle(0,0,1,1);
/**
* Used to detect if the graphics object has changed. If this is set to true then the graphics object will be recalculated.
*
@ -355,17 +357,17 @@ PIXI.Graphics.prototype.arcTo = function(x1, y1, x2, y2, radius)
{
if( this.currentPath )
{
if(this.currentPath.shape.points.length === 0)this.currentPath.shape.points = [x1, y1];
if(this.currentPath.shape.points.length === 0)
{
this.currentPath.shape.points.push(x1, y1);
}
}
else
{
this.moveTo(x1, y1);
}
// check that path contains subpaths
if( this.currentPath.length === 0)this.moveTo(x1, y1);
var points = this.currentPath;
var points = this.currentPath.shape.points;
var fromX = points[points.length-2];
var fromY = points[points.length-1];
var a1 = fromY - y1;
@ -374,9 +376,14 @@ PIXI.Graphics.prototype.arcTo = function(x1, y1, x2, y2, radius)
var b2 = x2 - x1;
var mm = Math.abs(a1 * b2 - b1 * a2);
if (mm < 1.0e-8 || radius === 0)
{
points.push(x1, y1);
if( points[points.length-2] !== x1 || points[points.length-1] !== y1)
{
//console.log(">>")
points.push(x1, y1);
}
}
else
{
@ -420,15 +427,19 @@ PIXI.Graphics.prototype.arc = function(cx, cy, radius, startAngle, endAngle, ant
{
var startX = cx + Math.cos(startAngle) * radius;
var startY = cy + Math.sin(startAngle) * radius;
var points = this.currentPath.shape.points;
if(points.length !== 0 && points[points.length-2] !== startX || points[points.length-1] !== startY)
if(points.length === 0)
{
this.moveTo(startX, startY);
points = this.currentPath.shape.points;
}
else if( points[points.length-2] !== startX || points[points.length-1] !== startY)
{
points.push(startX, startY);
}
if (startAngle === endAngle)return this;
if( !anticlockwise && endAngle <= startAngle )
@ -543,7 +554,7 @@ PIXI.Graphics.prototype.drawRect = function( x, y, width, height )
*/
PIXI.Graphics.prototype.drawRoundedRect = function( x, y, width, height, radius )
{
this.drawShape({ points:[x, y, width, height, radius], type:PIXI.Graphics.RREC });
this.drawShape(new PIXI.RoundedRectangle(x, y, width, height, radius));
return this;
};
@ -804,13 +815,13 @@ PIXI.Graphics.prototype.getBounds = function( matrix )
if(this.dirty)
{
this.updateBounds();
this.updateLocalBounds();
this.webGLDirty = true;
this.cachedSpriteDirty = true;
this.dirty = false;
}
var bounds = this._bounds;
var bounds = this._localBounds;
var w0 = bounds.x;
var w1 = bounds.width + bounds.x;
@ -861,21 +872,21 @@ PIXI.Graphics.prototype.getBounds = function( matrix )
maxY = y3 > maxY ? y3 : maxY;
maxY = y4 > maxY ? y4 : maxY;
bounds.x = minX;
bounds.width = maxX - minX;
this._bounds.x = minX;
this._bounds.width = maxX - minX;
bounds.y = minY;
bounds.height = maxY - minY;
this._bounds.y = minY;
this._bounds.height = maxY - minY;
return bounds;
return this._bounds;
};
/**
* Update the bounds of the object
*
* @method updateBounds
* @method updateLocalBounds
*/
PIXI.Graphics.prototype.updateBounds = function()
PIXI.Graphics.prototype.updateLocalBounds = function()
{
var minX = Infinity;
var maxX = -Infinity;
@ -961,13 +972,12 @@ PIXI.Graphics.prototype.updateBounds = function()
}
var padding = this.boundsPadding;
var bounds = this._bounds;
bounds.x = minX - padding;
bounds.width = (maxX - minX) + padding * 2;
this._localBounds.x = minX - padding;
this._localBounds.width = (maxX - minX) + padding * 2;
bounds.y = minY - padding;
bounds.height = (maxY - minY) + padding * 2;
this._localBounds.y = minY - padding;
this._localBounds.height = (maxY - minY) + padding * 2;
};
/**
@ -1111,3 +1121,5 @@ PIXI.Polygon.prototype.type = PIXI.Graphics.POLY;
PIXI.Rectangle.prototype.type = PIXI.Graphics.RECT;
PIXI.Circle.prototype.type = PIXI.Graphics.CIRC;
PIXI.Ellipse.prototype.type = PIXI.Graphics.ELIP;
PIXI.RoundedRectangle.prototype.type = PIXI.Graphics.RREC;

11
src/pixi/renderers/canvas/CanvasGraphics.js
View file

@ -148,12 +148,11 @@ PIXI.CanvasGraphics.renderGraphics = function(graphics, context)
}
else if (data.type === PIXI.Graphics.RREC)
{
var pts = shape.points;
var rx = pts[0];
var ry = pts[1];
var width = pts[2];
var height = pts[3];
var radius = pts[4];
var rx = shape.x;
var ry = shape.y;
var width = shape.width;
var height = shape.height;
var radius = shape.radius;
var maxRadius = Math.min(width, height) / 2 | 0;
radius = radius > maxRadius ? maxRadius : radius;

20
src/pixi/renderers/webgl/WebGLRenderer.js
View file

@ -3,6 +3,7 @@
*/
PIXI.glContexts = []; // this is where we store the webGL contexts for easy access.
PIXI.instances = [];
/**
* The WebGLRenderer draws the stage and all its content onto a webGL enabled canvas. This renderer
@ -82,7 +83,7 @@ PIXI.WebGLRenderer = function(width, height, options)
* @type Boolean
*/
this.preserveDrawingBuffer = options.preserveDrawingBuffer;
/**
* This sets if the WebGLRenderer will clear the context texture or not before the new render pass. If true:
* If the Stage is NOT transparent, Pixi will clear to alpha (0, 0, 0, 0).
@ -94,7 +95,7 @@ PIXI.WebGLRenderer = function(width, height, options)
* @default
*/
this.clearBeforeRender = options.clearBeforeRender;
/**
* The width of the canvas view
*
@ -251,6 +252,8 @@ PIXI.WebGLRenderer.prototype.initContext = function()
PIXI.glContexts[this.glContextId] = gl;
PIXI.instances[this.glContextId] = this;
// set up the default pixi settings..
gl.disable(gl.DEPTH_TEST);
gl.disable(gl.CULL_FACE);
@ -295,7 +298,7 @@ PIXI.WebGLRenderer.prototype.render = function(stage)
stage.updateTransform();
var gl = this.gl;
// interaction
if(stage._interactive)
{
@ -331,10 +334,10 @@ PIXI.WebGLRenderer.prototype.render = function(stage)
{
gl.clearColor(stage.backgroundColorSplit[0],stage.backgroundColorSplit[1],stage.backgroundColorSplit[2], 1);
}
gl.clear (gl.COLOR_BUFFER_BIT);
}
this.renderDisplayObject( stage, this.projection );
};
@ -349,7 +352,7 @@ PIXI.WebGLRenderer.prototype.render = function(stage)
PIXI.WebGLRenderer.prototype.renderDisplayObject = function(displayObject, projection, buffer)
{
this.renderSession.blendModeManager.setBlendMode(PIXI.blendModes.NORMAL);
// reset the render session data..
this.renderSession.drawCount = 0;
@ -416,7 +419,7 @@ PIXI.WebGLRenderer.prototype.updateTexture = function(texture)
gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, texture.premultipliedAlpha);
gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, gl.RGBA, gl.UNSIGNED_BYTE, texture.source);
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, texture.scaleMode === PIXI.scaleModes.LINEAR ? gl.LINEAR : gl.NEAREST);
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, texture.scaleMode === PIXI.scaleModes.LINEAR ? gl.LINEAR : gl.NEAREST);
@ -467,7 +470,7 @@ PIXI.WebGLRenderer.prototype.handleContextRestored = function()
var texture = PIXI.TextureCache[key].baseTexture;
texture._glTextures = [];
}
this.contextLost = false;
};
@ -536,3 +539,4 @@ PIXI.WebGLRenderer.prototype.mapBlendModes = function()
};
PIXI.WebGLRenderer.glContextId = 0;
PIXI.WebGLRenderer.instances = [];

14
src/pixi/renderers/webgl/shaders/PixiShader.js
View file

@ -16,7 +16,7 @@ PIXI.PixiShader = function(gl)
* @private
*/
this._UID = PIXI._UID++;
/**
* @property gl
* @type WebGLContext
@ -82,7 +82,7 @@ PIXI.PixiShader.prototype.constructor = PIXI.PixiShader;
/**
* Initialises the shader.
*
*
* @method init
*/
PIXI.PixiShader.prototype.init = function()
@ -90,7 +90,7 @@ PIXI.PixiShader.prototype.init = function()
var gl = this.gl;
var program = PIXI.compileProgram(gl, this.vertexSrc || PIXI.PixiShader.defaultVertexSrc, this.fragmentSrc);
gl.useProgram(program);
// get and store the uniforms for the shader
@ -133,7 +133,7 @@ PIXI.PixiShader.prototype.init = function()
/**
* Initialises the shader uniform values.
*
*
* Uniforms are specified in the GLSL_ES Specification: http://www.khronos.org/registry/webgl/specs/latest/1.0/
* http://www.khronos.org/registry/gles/specs/2.0/GLSL_ES_Specification_1.0.17.pdf
*
@ -327,7 +327,7 @@ PIXI.PixiShader.prototype.syncUniforms = function()
if(uniform.value.baseTexture._dirty[gl.id])
{
PIXI.defaultRenderer.updateTexture(uniform.value.baseTexture);
PIXI.WebGLRenderer.instances[gl.id].updateTexture(uniform.value.baseTexture);
}
else
{
@ -350,7 +350,7 @@ PIXI.PixiShader.prototype.syncUniforms = function()
/**
* Destroys the shader.
*
*
* @method destroy
*/
PIXI.PixiShader.prototype.destroy = function()
@ -364,7 +364,7 @@ PIXI.PixiShader.prototype.destroy = function()
/**
* The Default Vertex shader source.
*
*
* @property defaultVertexSrc
* @type String
*/

13
src/pixi/renderers/webgl/utils/WebGLGraphics.js
View file

@ -309,12 +309,13 @@ PIXI.WebGLGraphics.buildRectangle = function(graphicsData, webGLData)
*/
PIXI.WebGLGraphics.buildRoundedRectangle = function(graphicsData, webGLData)
{
var points = graphicsData.shape.points;
var x = points[0];
var y = points[1];
var width = points[2];
var height = points[3];
var radius = points[4];
var rrectData = graphicsData.shape;
var x = rrectData.x;
var y = rrectData.y;
var width = rrectData.width;
var height = rrectData.height;
var radius = rrectData.radius;
var recPoints = [];
recPoints.push(x, y + radius);

3
src/pixi/textures/Texture.js
View file

@ -324,3 +324,6 @@ PIXI.TextureUvs = function()
this.x3 = 0;
this.y3 = 0;
};
PIXI.Texture.emptyTexture = new PIXI.Texture(new PIXI.BaseTexture());

1
tasks/manifests/pixi.json
View file

@ -3,6 +3,7 @@
"src/pixi/Pixi.js",
"src/pixi/geom/Polygon.js",
"src/pixi/geom/Matrix.js",
"src/pixi/geom/RoundedRectangle.js",
"src/pixi/display/DisplayObject.js",
"src/pixi/display/DisplayObjectContainer.js",
"src/pixi/display/Sprite.js",