From 3748811d11fcc77f4e4d17d7aa42c57f83ced5dd Mon Sep 17 00:00:00 2001 From: photonstorm Date: Thu, 6 Feb 2014 19:34:05 +0000 Subject: [PATCH] Testing new Image object. --- README.md | 1 + build/config.php | 1 + examples/wip/image1.js | 45 +++ examples/wip/image2.js | 39 +++ src/animation/Frame.js | 22 ++ src/gameobjects/GameObjectFactory.js | 19 + src/gameobjects/Image.js | 500 +++++++++++++++++++++++++++ src/gameobjects/Sprite.js | 78 ++--- 8 files changed, 665 insertions(+), 40 deletions(-) create mode 100644 examples/wip/image1.js create mode 100644 examples/wip/image2.js create mode 100644 src/gameobjects/Image.js diff --git a/README.md b/README.md index f4453f92..972e94ca 100644 --- a/README.md +++ b/README.md @@ -67,6 +67,7 @@ Significant API changes: * PIXI.Point is now aliased to Phaser.Point - saves on code duplication and works exactly the same. * PIXI.Rectangle is now aliased to Phaser.Rectangle - saves on code duplication and works exactly the same. * PIXI.Circle is now aliased to Phaser.Circle - saves on code duplication and works exactly the same. +* Sprite.deltaX and deltaY swapped to functions: Sprite.deltaX() and Sprite.deltaY() New features: diff --git a/build/config.php b/build/config.php index 9129af4a..7b047258 100644 --- a/build/config.php +++ b/build/config.php @@ -129,6 +129,7 @@ + diff --git a/examples/wip/image1.js b/examples/wip/image1.js new file mode 100644 index 00000000..aada00c2 --- /dev/null +++ b/examples/wip/image1.js @@ -0,0 +1,45 @@ + +var game = new Phaser.Game(800, 600, Phaser.CANVAS, 'phaser-example', { preload: preload, create: create, update: update, render: render }); + +function preload() { + + game.load.image('pic', 'assets/pics/backscroll.png'); + +} + +var image; +var sprite; + +function create() { + +console.log('wtf'); + + image = game.add.image(game.world.centerX, game.world.centerY, 'pic'); + image.anchor.set(0.5); + + // sprite = game.add.sprite(game.world.centerX, game.world.centerY, 'pic'); + // sprite.anchor.set(0.5); + + game.input.onDown.add(tint, this); + +} + +function tint() { + + image.tint = Math.random() * 0xFFFFFF; + // sprite.tint = Math.random() * 0xFFFFFF; + +} + +function update() { + + image.angle += 1; + // sprite.angle += 1; + +} + +function render() { + + // game.debug.renderText(sprite.position.y, 32, 32); + +} diff --git a/examples/wip/image2.js b/examples/wip/image2.js new file mode 100644 index 00000000..15560680 --- /dev/null +++ b/examples/wip/image2.js @@ -0,0 +1,39 @@ + +var game = new Phaser.Game(800, 600, Phaser.CANVAS, 'phaser-example', { preload: preload, create: create, update: update, render: render }); + +function preload() { + + game.load.image('pic', 'assets/pics/backscroll.png'); + +} + +var image; +var image2; + +function create() { + + image = game.add.image(32, 50, 'pic'); + + image2 = game.add.image(32, 250, 'pic'); + + game.input.onDown.add(tint, this); + +} + +function tint() { + + image.tint = Math.random() * 0xFFFFFF; + +} + +function update() { + + // image.angle += 1; + +} + +function render() { + + // game.debug.renderText(sprite.position.y, 32, 32); + +} diff --git a/src/animation/Frame.js b/src/animation/Frame.js index c7cc3ff6..a650d090 100644 --- a/src/animation/Frame.js +++ b/src/animation/Frame.js @@ -155,6 +155,28 @@ Phaser.Frame.prototype = { this.spriteSourceSizeH = destHeight; } + }, + + /** + * Returns a Rectangle set to the dimensions of this Frame. + * + * @method Phaser.Frame#getRect + * @param {Phaser.Rectangle} [out] - A rectangle to copy the frame dimensions to. + * @return {Phaser.Rectangle} A rectangle. + */ + getRect: function (out) { + + if (typeof out === 'undefined') + { + out = new Phaser.Rectangle(this.x, this.y, this.width, this.height); + } + else + { + out.setTo(this.x, this.y, this.width, this.height); + } + + return out; + } }; diff --git a/src/gameobjects/GameObjectFactory.js b/src/gameobjects/GameObjectFactory.js index 485f0087..955d7cd0 100644 --- a/src/gameobjects/GameObjectFactory.js +++ b/src/gameobjects/GameObjectFactory.js @@ -39,6 +39,25 @@ Phaser.GameObjectFactory.prototype = { }, + /** + * Create a new Image at the given coordinates, using the cache key and frame if set. + * + * @method Phaser.GameObjectFactory#image + * @param {number} x - X position of the image. + * @param {number} y - Y position of the image. + * @param {string|Phaser.RenderTexture|PIXI.Texture} key - This is the image or texture used by the Sprite during rendering. It can be a string which is a reference to the Cache entry, or an instance of a RenderTexture or PIXI.Texture. + * @param {string|number} [frame] - If the sprite uses an image from a texture atlas or sprite sheet you can pass the frame here. Either a number for a frame ID or a string for a frame name. + * @param {Phaser.Group} [group] - Optional Group to add the object to. If not specified it will be added to the World group. + * @returns {Phaser.Sprite} the newly created sprite object. + */ + image: function (x, y, key, frame, group) { + + if (typeof group === 'undefined') { group = this.world; } + + return group.add(new Phaser.Image(this.game, x, y, key, frame)); + + }, + /** * Create a new Sprite with specific position and sprite sheet key. * diff --git a/src/gameobjects/Image.js b/src/gameobjects/Image.js new file mode 100644 index 00000000..f78dc678 --- /dev/null +++ b/src/gameobjects/Image.js @@ -0,0 +1,500 @@ +/** +* @author Richard Davey +* @copyright 2014 Photon Storm Ltd. +* @license {@link https://github.com/photonstorm/phaser/blob/master/license.txt|MIT License} +*/ + +/** +* @class Phaser.Image +* +* @classdesc Create a new `Image` object. +* +* At its most basic a Sprite consists of a set of coordinates and a texture that is rendered to the canvas. +* +* @constructor +* @param {Phaser.Game} game - A reference to the currently running game. +* @param {number} x - The x coordinate (in world space) to position the Sprite at. +* @param {number} y - The y coordinate (in world space) to position the Sprite at. +* @param {string|Phaser.RenderTexture|Phaser.BitmapData|PIXI.Texture} key - This is the image or texture used by the Sprite during rendering. It can be a string which is a reference to the Cache entry, or an instance of a RenderTexture or PIXI.Texture. +* @param {string|number} frame - If this Sprite is using part of a sprite sheet or texture atlas you can specify the exact frame to use by giving a string or numeric index. +*/ +Phaser.Image = function (game, x, y, key, frame) { + + x = x || 0; + y = y || 0; + key = key || null; + frame = frame || null; + + /** + * @property {Phaser.Game} game - A reference to the currently running Game. + */ + this.game = game; + + /** + * @property {boolean} exists - If exists = false then the Sprite isn't updated by the core game loop or physics subsystem at all. + * @default + */ + this.exists = true; + + /** + * @property {string} name - The user defined name given to this Sprite. + * @default + */ + this.name = ''; + + /** + * @property {number} type - The const type of this object. + * @readonly + */ + this.type = Phaser.IMAGE; + + /** + * @property {Phaser.Events} events - The Events you can subscribe to that are dispatched when certain things happen on this Sprite or its components. + */ + this.events = new Phaser.Events(this); + + /** + * @property {string|Phaser.RenderTexture|Phaser.BitmapData|PIXI.Texture} key - This is the image or texture used by the Sprite during rendering. It can be a string which is a reference to the Cache entry, or an instance of a RenderTexture, BitmapData or PIXI.Texture. + */ + this.key = key; + + this.currentFrame = new Phaser.Rectangle(); + + if (key instanceof Phaser.RenderTexture) + { + PIXI.Sprite.call(this, key); + + this.currentFrame = this.game.cache.getTextureFrame(key.name); + } + else if (key instanceof Phaser.BitmapData) + { + PIXI.Sprite.call(this, key.texture, key.textureFrame); + + this.currentFrame = key.textureFrame; + } + else if (key instanceof PIXI.Texture) + { + PIXI.Sprite.call(this, key); + + this.currentFrame = frame; + } + else + { + if (key === null || typeof key === 'undefined') + { + key = '__default'; + this.key = key; + } + else if (typeof key === 'string' && this.game.cache.checkImageKey(key) === false) + { + key = '__missing'; + this.key = key; + } + + PIXI.Sprite.call(this, PIXI.TextureCache[key]); + + if (this.game.cache.isSpriteSheet(key)) + { + this.animations.loadFrameData(this.game.cache.getFrameData(key)); + + if (frame !== null) + { + if (typeof frame === 'string') + { + this.frameName = frame; + } + else + { + this.frame = frame; + } + } + } + else + { + this.currentFrame = this.game.cache.getFrame(key); + } + } + + // this.loadTexture(key, frame); + + /** + * The rectangular area from the texture that will be rendered. + * @property {Phaser.Rectangle} textureRegion + */ + // this.textureRegion = new Phaser.Rectangle(this.texture.frame.x, this.texture.frame.y, this.texture.frame.width, this.texture.frame.height); + + this.position.x = x; + this.position.y = y; + + /** + * @property {Phaser.Point} world - The world coordinates of this Sprite. This differs from the x/y coordinates which are relative to the Sprites container. + */ + this.world = new Phaser.Point(x, y); + + /** + * Should this Sprite be automatically culled if out of range of the camera? + * A culled sprite has its renderable property set to 'false'. + * Be advised this is quite an expensive operation, as it has to calculate the bounds of the object every frame, so only enable it if you really need it. + * + * @property {boolean} autoCull - A flag indicating if the Sprite should be automatically camera culled or not. + * @default + */ + this.autoCull = false; + + /** + * A Sprite that is fixed to the camera ignores the position of any ancestors in the display list and uses its x/y coordinates as offsets from the top left of the camera. + * @property {boolean} fixedToCamera - Fixes this Sprite to the Camera. + * @default + */ + this.fixedToCamera = false; + + /** + * @property {Phaser.Point} cameraOffset - If this Sprite is fixed to the camera then use this Point to specify how far away from the Camera x/y it's rendered. + */ + // this.cameraOffset = new Phaser.Point(x, y); + +}; + +Phaser.Image.prototype = Object.create(PIXI.Sprite.prototype); +Phaser.Image.prototype.constructor = Phaser.Image; + +/** +* Automatically called by World.preUpdate. Handles cache updates, lifespan checks, animation updates and physics updates. +* +* @method Phaser.Image#preUpdate +* @memberof Phaser.Image +*/ +Phaser.Image.prototype.preUpdate = function() { + + if (!this.exists || !this.parent.exists) + { + return false; + } + + if (this.autoCull) + { + // Won't get rendered but will still get its transform updated + this.renderable = this.game.world.camera.screenView.intersects(this.getBounds()); + } + + return true; + +}; + +/** +* Checks if the Image bounds are within the game world, otherwise false if fully outside of it. +* +* @method Phaser.Image#inWorld +* @memberof Phaser.Image +* @return {boolean} True if the Image bounds is within the game world, otherwise false if fully outside of it. +*/ +Phaser.Image.prototype.inWorld = function() { + + return this.game.world.bounds.intersects(this.getBounds()); + +}; + +/** +* Resets the Sprite.crop value back to the frame dimensions. +* +* @method Phaser.Image#resetCrop +* @memberof Phaser.Image +Phaser.Image.prototype.resetCrop = function() { + + this.crop = new Phaser.Rectangle(0, 0, this._cache.width, this._cache.height); + this.texture.setFrame(this.crop); + this.cropEnabled = false; + +}; +*/ + +/** +* Internal function called by the World postUpdate cycle. +* +* @method Phaser.Image#postUpdate +* @memberof Phaser.Image +*/ +Phaser.Image.prototype.postUpdate = function() { + + if (this.key instanceof Phaser.BitmapData && this.key._dirty) + { + this.key.render(); + } + + if (this.exists) + { + // if (this.body) + // { + // this.body.postUpdate(); + // } + + if (this.fixedToCamera) + { + this.position.x = this.game.camera.view.x + this.cameraOffset.x; + this.position.y = this.game.camera.view.y + this.cameraOffset.y; + } + + } + +}; + +/** +* Changes the Texture the Sprite is using entirely. The old texture is removed and the new one is referenced or fetched from the Cache. +* This causes a WebGL texture update, so use sparingly or in low-intensity portions of your game. +* +* @method Phaser.Image#loadTexture +* @memberof Phaser.Image +* @param {string|Phaser.RenderTexture|Phaser.BitmapData|PIXI.Texture} key - This is the image or texture used by the Sprite during rendering. It can be a string which is a reference to the Cache entry, or an instance of a RenderTexture, BitmapData or PIXI.Texture. +* @param {string|number} frame - If this Sprite is using part of a sprite sheet or texture atlas you can specify the exact frame to use by giving a string or numeric index. +*/ +Phaser.Image.prototype.loadTexture = function (key, frame) { + + console.log('loadTexture'); + + this.key = key; + + if (key instanceof Phaser.RenderTexture) + { + this.game.cache.getTextureFrame(key.name).clone(this.currentFrame); + } + else if (key instanceof Phaser.BitmapData) + { + this.setTexture(key.texture); + this.currentFrame = key.textureFrame; + } + else if (key instanceof PIXI.Texture) + { + // this.currentFrame = frame; + frame.clone(this.currentFrame); + console.log('loadTexture 2'); + } + else + { + if (typeof key === 'undefined' || this.game.cache.checkImageKey(key) === false) + { + key = '__default'; + this.key = key; + } + + if (this.game.cache.isSpriteSheet(key)) + { + // this.animations.loadFrameData(this.game.cache.getFrameData(key)); + + // if (typeof frame !== 'undefined') + // { + // if (typeof frame === 'string') + // { + // this.frameName = frame; + // } + // else + // { + // this.frame = frame; + // } + // } + } + else + { + console.log('loadTexture 1', this.game.cache.getFrame(key)); + + this.game.cache.getFrame(key).getRect(this.currentFrame); + + console.log('loadTexture 1', this.currentFrame); + + this.setTexture(PIXI.TextureCache[key]); + } + } + +}; + +/** +* Moves the sprite so its center is located on the given x and y coordinates. +* Doesn't change the anchor point of the sprite. +* +* @method Phaser.Image#centerOn +* @memberof Phaser.Image +* @param {number} x - The x coordinate (in world space) to position the Sprite at. +* @param {number} y - The y coordinate (in world space) to position the Sprite at. +* @return (Phaser.Image) This instance. +Phaser.Image.prototype.centerOn = function(x, y) { + + if (this.fixedToCamera) + { + this.cameraOffset.x = x + (this.cameraOffset.x - this.center.x); + this.cameraOffset.y = y + (this.cameraOffset.y - this.center.y); + } + else + { + this.x = x + (this.x - this.center.x); + this.y = y + (this.y - this.center.y); + } + + return this; + +}; +*/ + +/** +* Brings a 'dead' Sprite back to life, optionally giving it the health value specified. +* A resurrected Sprite has its alive, exists and visible properties all set to true. +* It will dispatch the onRevived event, you can listen to Sprite.events.onRevived for the signal. +* +* @method Phaser.Image#revive +* @memberof Phaser.Image +* @return (Phaser.Image) This instance. +*/ +Phaser.Image.prototype.revive = function() { + + this.alive = true; + this.exists = true; + this.visible = true; + + if (this.events) + { + this.events.onRevived.dispatch(this); + } + + return this; + +}; + +/** +* Kills a Sprite. A killed Sprite has its alive, exists and visible properties all set to false. +* It will dispatch the onKilled event, you can listen to Sprite.events.onKilled for the signal. +* Note that killing a Sprite is a way for you to quickly recycle it in a Sprite pool, it doesn't free it up from memory. +* If you don't need this Sprite any more you should call Sprite.destroy instead. +* +* @method Phaser.Image#kill +* @memberof Phaser.Image +* @return (Phaser.Image) This instance. +*/ +Phaser.Image.prototype.kill = function() { + + this.alive = false; + this.exists = false; + this.visible = false; + + if (this.events) + { + this.events.onKilled.dispatch(this); + } + + return this; + +}; + +/** +* Destroys the Sprite. This removes it from its parent group, destroys the input, event and animation handlers if present +* and nulls its reference to game, freeing it up for garbage collection. +* +* @method Phaser.Image#destroy +* @memberof Phaser.Image +*/ +Phaser.Image.prototype.destroy = function() { + + if (this.filters) + { + this.filters = null; + } + + if (this.parent) + { + this.parent.remove(this); + } + + if (this.events) + { + this.events.destroy(); + } + + this.alive = false; + this.exists = false; + this.visible = false; + + this.game = null; + +}; + +/** +* Resets the Sprite. This places the Sprite at the given x/y world coordinates and then +* sets alive, exists, visible and renderable all to true. Also resets the outOfBounds state and health values. +* If the Sprite has a physics body that too is reset. +* +* @method Phaser.Image#reset +* @memberof Phaser.Image +* @param {number} x - The x coordinate (in world space) to position the Sprite at. +* @param {number} y - The y coordinate (in world space) to position the Sprite at. +* @return (Phaser.Image) This instance. +*/ +Phaser.Image.prototype.reset = function(x, y) { + + this.world.setTo(x, y); + this.position.x = x; + this.position.y = y; + this.alive = true; + this.exists = true; + this.visible = true; + this.renderable = true; + this._outOfBoundsFired = false; + + return this; + +}; + +/** +* Brings the Sprite to the top of the display list it is a child of. Sprites that are members of a Phaser.Group are only +* bought to the top of that Group, not the entire display list. +* +* @method Phaser.Image#bringToTop +* @memberof Phaser.Image +* @return (Phaser.Image) This instance. +*/ +Phaser.Image.prototype.bringToTop = function(child) { + + if (typeof child === 'undefined') + { + if (this.parent) + { + this.parent.bringToTop(this); + } + } + else + { + + } + + return this; + +}; + +/** +* Indicates the rotation of the Sprite, in degrees, from its original orientation. Values from 0 to 180 represent clockwise rotation; values from 0 to -180 represent counterclockwise rotation. +* Values outside this range are added to or subtracted from 360 to obtain a value within the range. For example, the statement player.angle = 450 is the same as player.angle = 90. +* If you wish to work in radians instead of degrees use the property Sprite.rotation instead. +* @name Phaser.Image#angle +* @property {number} angle - Gets or sets the Sprites angle of rotation in degrees. +*/ +Object.defineProperty(Phaser.Image.prototype, 'angle', { + + get: function() { + return Phaser.Math.wrapAngle(Phaser.Math.radToDeg(this.rotation)); + }, + + set: function(value) { + this.rotation = Phaser.Math.degToRad(Phaser.Math.wrapAngle(value)); + } + +}); + +/** +* @name Phaser.Image#inCamera +* @property {boolean} inCamera - Is this sprite visible to the camera or not? +* @readonly +*/ +Object.defineProperty(Phaser.Image.prototype, "inCamera", { + + get: function () { + return this._cache.cameraVisible; + } + +}); + diff --git a/src/gameobjects/Sprite.js b/src/gameobjects/Sprite.js index 27f27c83..0b98feb1 100644 --- a/src/gameobjects/Sprite.js +++ b/src/gameobjects/Sprite.js @@ -946,8 +946,8 @@ Phaser.Sprite.prototype.reset = function(x, y, health) { if (typeof health === 'undefined') { health = 1; } - this.x = x; - this.y = y; + // this.x = x; + // this.y = y; this.world.setTo(x, y); this.position.x = this.x; this.position.y = this.y; @@ -978,9 +978,9 @@ Phaser.Sprite.prototype.reset = function(x, y, health) { */ Phaser.Sprite.prototype.bringToTop = function() { - if (this.group) + if (this.parent) { - this.group.bringToTop(this); + this.parent.bringToTop(this); } else { @@ -1014,31 +1014,29 @@ Phaser.Sprite.prototype.play = function (name, frameRate, loop, killOnComplete) /** * Returns the delta x value. The difference between Sprite.x now and in the previous step. -* @name Phaser.Sprite#deltaX -* @property {number} deltaX - The delta value. Positive if the motion was to the right, negative if to the left. -* @readonly +* +* @method Phaser.Sprite#deltaX +* @memberof Phaser.Sprite +* @return {number} The delta value. Positive if the motion was to the right, negative if to the left. */ -Object.defineProperty(Phaser.Sprite.prototype, 'deltaX', { +Phaser.Sprite.prototype.deltaX = function () { - get: function() { - return this.world.x - this._cache.prevX; - } + return this.world.x - this._cache.prevX; -}); +}; /** * Returns the delta x value. The difference between Sprite.y now and in the previous step. -* @name Phaser.Sprite#deltaY -* @property {number} deltaY - The delta value. Positive if the motion was downwards, negative if upwards. -* @readonly +* +* @method Phaser.Sprite#deltaY +* @memberof Phaser.Sprite +* @return {number} The delta value. Positive if the motion was downwards, negative if upwards. */ -Object.defineProperty(Phaser.Sprite.prototype, 'deltaY', { +Phaser.Sprite.prototype.deltaY = function () { - get: function() { - return this.world.y - this._cache.prevY; - } + return this.world.y - this._cache.prevY; -}); +}; /** * Indicates the rotation of the Sprite, in degrees, from its original orientation. Values from 0 to 180 represent clockwise rotation; values from 0 to -180 represent counterclockwise rotation. @@ -1137,21 +1135,21 @@ Object.defineProperty(Phaser.Sprite.prototype, "worldCenterY", { * @name Phaser.Sprite#width * @property {number} width - The width of the Sprite in pixels. */ -Object.defineProperty(Phaser.Sprite.prototype, 'width', { +// Object.defineProperty(Phaser.Sprite.prototype, 'width', { - get: function() { - return this.scale.x * this.currentFrame.width; - }, +// get: function() { +// return this.scale.x * this.currentFrame.width; +// }, - set: function(value) { +// set: function(value) { - this.scale.x = value / this.currentFrame.width; - this._cache.scaleX = value / this.currentFrame.width; - this._width = value; +// this.scale.x = value / this.currentFrame.width; +// this._cache.scaleX = value / this.currentFrame.width; +// this._width = value; - } +// } -}); +// }); /** * The height of the sprite in pixels, setting this will actually modify the scale to acheive the value desired. @@ -1160,21 +1158,21 @@ Object.defineProperty(Phaser.Sprite.prototype, 'width', { * @name Phaser.Sprite#height * @property {number} height - The height of the Sprite in pixels. */ -Object.defineProperty(Phaser.Sprite.prototype, 'height', { +// Object.defineProperty(Phaser.Sprite.prototype, 'height', { - get: function() { - return this.scale.y * this.currentFrame.height; - }, +// get: function() { +// return this.scale.y * this.currentFrame.height; +// }, - set: function(value) { +// set: function(value) { - this.scale.y = value / this.currentFrame.height; - this._cache.scaleY = value / this.currentFrame.height; - this._height = value; +// this.scale.y = value / this.currentFrame.height; +// this._cache.scaleY = value / this.currentFrame.height; +// this._height = value; - } +// } -}); +// }); /** * By default a Sprite won't process any input events at all. By setting inputEnabled to true the Phaser.InputHandler is