Mirrors/phaser
2
0
Fork 0
mirror of https://github.com/photonstorm/phaser synced 2024-11-22 20:53:39 +00:00
Code Issues Projects Releases Packages Wiki Activity

The private methods TilemapLayer._fixX, _unfixX, _fixY and _unfixY have been moved to `Tilemap.

Browse source
This commit is contained in:
Richard Davey 2016-07-22 03:20:56 +01:00
parent ef9f53e350
commit be92e41366
5 changed files with 154 additions and 288 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
README.md
View file

@ -329,6 +329,7 @@ You can read all about the philosophy behind Lazer [here](http://phaser.io/news/
* TilemapLayer.getRayCastTiles has been moved to Tilemap.getRayCastTiles.
* TilemapLayer.rayStepRate has been moved to Tilemap.rayStepRate.
* TilemapLayer.getTiles has been moved to Tilemap.getTiles.
* The private methods `TilemapLayer._fixX`, `_unfixX`, `_fixY` and `_unfixY` have been moved to `Tilemap.
### Bug Fixes

6
src/pixi/extras/Tilemap.js
View file

@ -362,9 +362,9 @@ PIXI.Tilemap.prototype._renderWholeTilemap = function (renderSession) {
gl.uniform2f(shader.uOffset, renderSession.offset.x / this.game.width * 2, -renderSession.offset.y / this.game.height * 2);
// set the clipping limits
gl.uniform2f(shader.uClipOffset, this._offset.x / this.game.width * 2, this._offset.y / this.game.height * 2);
gl.uniform2f(shader.uClipLoc, this._offset.x, this._offset.y);
gl.uniform2f(shader.uClipLimit, this._offset.x + this._displayWidth, this.game.height - (this._offset.y + this._displayHeight));
gl.uniform2f(shader.uClipOffset, this.position.x / this.game.width * 2, this.position.y / this.game.height * 2);
gl.uniform2f(shader.uClipLoc, this.position.x, this.position.y);
gl.uniform2f(shader.uClipLimit, this.position.x + this._displayWidth, this.game.height - (this.position.y + this._displayHeight));
// set the offset in screen units to the center of the screen
// and flip the GL y coordinate to be zero at the top

144
src/tilemap/Tilemap.js
View file

@ -2107,6 +2107,150 @@ Phaser.Tilemap.prototype = {
},
/**
* Take an x coordinate that doesn't account for scrollFactorX and 'fix' it into a scrolled local space.
*
* @method Phaser.Tilemap#_fixX
* @private
* @param {number} x - x coordinate in camera space
* @return {number} x coordinate in scrollFactor-adjusted dimensions
*/
_fixX: function (x) {
var layer = this.layer;
if (layer.scrollFactorX === 1 || (layer.scrollFactorX === 0 && layer.position.x === 0))
{
return x;
}
// This executes if the scrollFactorX is 0 and the x position of the tilemap is off from standard.
if (layer.scrollFactorX === 0 && layer.position.x !== 0)
{
return x - layer.position.x;
}
return layer._scrollX + (x - (layer._scrollX / layer.scrollFactorX));
};
/**
* Take an x coordinate that _does_ account for scrollFactorX and 'unfix' it back to camera space.
*
* @method Phaser.Tilemap#_unfixX
* @private
* @param {number} x - x coordinate in scrollFactor-adjusted dimensions
* @return {number} x coordinate in camera space
*/
_unfixX: function (x) {
var layer = this.layer;
if (layer.scrollFactorX === 1)
{
return x;
}
return (layer._scrollX / layer.scrollFactorX) + (x - layer._scrollX);
},
/**
* Take a y coordinate that doesn't account for scrollFactorY and 'fix' it into a scrolled local space.
*
* @method Phaser.Tilemap#_fixY
* @private
* @param {number} y - y coordinate in camera space
* @return {number} y coordinate in scrollFactor-adjusted dimensions
*/
_fixY: function (y) {
var layer = this.layer;
if (layer.scrollFactorY === 1 || (layer.scrollFactorY === 0 && layer.position.y === 0))
{
return y;
}
// This executes if the scrollFactorY is 0 and the y position of the tilemap is off from standard.
if (layer.scrollFactorY === 0 && layer.position.y !== 0)
{
return y - layer.position.y;
}
return layer._scrollY + (y - (layer._scrollY / layer.scrollFactorY));
},
/**
* Take a y coordinate that _does_ account for scrollFactorY and 'unfix' it back to camera space.
*
* @method Phaser.Tilemap#_unfixY
* @private
* @param {number} y - y coordinate in scrollFactor-adjusted dimensions
* @return {number} y coordinate in camera space
*/
_unfixY: function (y) {
var layer = this.layer;
if (layer.scrollFactorY === 1)
{
return y;
}
return (layer._scrollY / layer.scrollFactorY) + (y - layer._scrollY);
},
/**
* Convert a pixel value to a tile coordinate.
*
* @method Phaser.Tilemap#getTileX
* @param {number} x - X position of the point in target tile (in pixels).
* @return {integer} The X map location of the tile.
*/
getTileX: function (x) {
var layer = this.layer;
return Math.floor(this._fixX(x) / layer._mc.tileWidth);
},
/**
* Convert a pixel value to a tile coordinate.
*
* @method Phaser.Tilemap#getTileY
* @param {number} y - Y position of the point in target tile (in pixels).
* @return {integer} The Y map location of the tile.
*/
getTileY: function (y) {
var layer = this.layer;
return Math.floor(this._fixY(y) / layer._mc.tileHeight);
},
/**
* Convert a pixel coordinate to a tile coordinate.
*
* @method Phaser.Tilemap#getTileXY
* @param {number} x - X position of the point in target tile (in pixels).
* @param {number} y - Y position of the point in target tile (in pixels).
* @param {(Phaser.Point|object)} point - The Point/object to update.
* @return {(Phaser.Point|object)} A Point/object with its `x` and `y` properties set.
*/
getTileXY: function (x, y, point) {
point.x = this.getTileX(x);
point.y = this.getTileY(y);
return point;
},
/**
* Removes all layer data from this tile map and nulls the game reference.
* Note: You are responsible for destroying any TilemapLayer objects you generated yourself, as Tilemap doesn't keep a reference to them.

138
src/tilemap/TilemapLayer.js
View file

@ -397,144 +397,6 @@ Phaser.TilemapLayer.prototype.resizeWorld = function () {
};
/**
* Take an x coordinate that doesn't account for scrollFactorX and 'fix' it into a scrolled local space.
*
* @method Phaser.TilemapLayer#_fixX
* @private
* @param {number} x - x coordinate in camera space
* @return {number} x coordinate in scrollFactor-adjusted dimensions
*/
Phaser.TilemapLayer.prototype._fixX = function (x) {
if (this.scrollFactorX === 1 || (this.scrollFactorX === 0 && this.position.x === 0))
{
return x;
}
// This executes if the scrollFactorX is 0 and the x position of the tilemap is off from standard.
if (this.scrollFactorX === 0 && this.position.x !== 0)
{
return x - this.position.x;
}
return this._scrollX + (x - (this._scrollX / this.scrollFactorX));
};
/**
* Take an x coordinate that _does_ account for scrollFactorX and 'unfix' it back to camera space.
*
* @method Phaser.TilemapLayer#_unfixX
* @private
* @param {number} x - x coordinate in scrollFactor-adjusted dimensions
* @return {number} x coordinate in camera space
*/
Phaser.TilemapLayer.prototype._unfixX = function (x) {
if (this.scrollFactorX === 1)
{
return x;
}
return (this._scrollX / this.scrollFactorX) + (x - this._scrollX);
};
/**
* Take a y coordinate that doesn't account for scrollFactorY and 'fix' it into a scrolled local space.
*
* @method Phaser.TilemapLayer#_fixY
* @private
* @param {number} y - y coordinate in camera space
* @return {number} y coordinate in scrollFactor-adjusted dimensions
*/
Phaser.TilemapLayer.prototype._fixY = function (y) {
if (this.scrollFactorY === 1 || (this.scrollFactorY === 0 && this.position.y === 0))
{
return y;
}
// This executes if the scrollFactorY is 0 and the y position of the tilemap is off from standard.
if (this.scrollFactorY === 0 && this.position.y !== 0)
{
return y - this.position.y;
}
return this._scrollY + (y - (this._scrollY / this.scrollFactorY));
};
/**
* Take a y coordinate that _does_ account for scrollFactorY and 'unfix' it back to camera space.
*
* @method Phaser.TilemapLayer#_unfixY
* @private
* @param {number} y - y coordinate in scrollFactor-adjusted dimensions
* @return {number} y coordinate in camera space
*/
Phaser.TilemapLayer.prototype._unfixY = function (y) {
if (this.scrollFactorY === 1)
{
return y;
}
return (this._scrollY / this.scrollFactorY) + (y - this._scrollY);
};
/**
* Convert a pixel value to a tile coordinate.
*
* @method Phaser.TilemapLayer#getTileX
* @public
* @param {number} x - X position of the point in target tile (in pixels).
* @return {integer} The X map location of the tile.
*/
Phaser.TilemapLayer.prototype.getTileX = function (x) {
// var tileWidth = this.tileWidth * this.scale.x;
return Math.floor(this._fixX(x) / this._mc.tileWidth);
};
/**
* Convert a pixel value to a tile coordinate.
*
* @method Phaser.TilemapLayer#getTileY
* @public
* @param {number} y - Y position of the point in target tile (in pixels).
* @return {integer} The Y map location of the tile.
*/
Phaser.TilemapLayer.prototype.getTileY = function (y) {
// var tileHeight = this.tileHeight * this.scale.y;
return Math.floor(this._fixY(y) / this._mc.tileHeight);
};
/**
* Convert a pixel coordinate to a tile coordinate.
*
* @method Phaser.TilemapLayer#getTileXY
* @public
* @param {number} x - X position of the point in target tile (in pixels).
* @param {number} y - Y position of the point in target tile (in pixels).
* @param {(Phaser.Point|object)} point - The Point/object to update.
* @return {(Phaser.Point|object)} A Point/object with its `x` and `y` properties set.
*/
Phaser.TilemapLayer.prototype.getTileXY = function (x, y, point) {
point.x = this.getTileX(x);
point.y = this.getTileY(y);
return point;
};
/**
* Returns the appropriate tileset for the index, updating the internal cache as required.
* This should only be called if `tilesets[index]` evaluates to undefined.

153
src/tilemap/TilemapLayerGL.js
View file

@ -29,14 +29,6 @@ Phaser.TilemapLayerGL = function (game, tilemap, index, width, height, tileset)
this.game = game;
/**
* The rendering offset.
*
* @property {Phaser.Point} _offset
* @private
*/
this._offset = new Phaser.Point();
/**
* An Array of any linked layers.
*
@ -309,139 +301,6 @@ Phaser.TilemapLayerGL.prototype.resizeWorld = function () {
};
/**
* Take an x coordinate that doesn't account for scrollFactorX and 'fix' it into a scrolled local space.
*
* @method Phaser.TilemapLayerGL#_fixX
* @private
* @param {number} x - x coordinate in camera space
* @return {number} x coordinate in scrollFactor-adjusted dimensions
*/
Phaser.TilemapLayerGL.prototype._fixX = function (x) {
if (x < 0)
{
x = 0;
}
if (this.scrollFactorX === 1)
{
return x;
}
return this._scrollX + (x - (this._scrollX / this.scrollFactorX));
};
/**
* Take an x coordinate that _does_ account for scrollFactorX and 'unfix' it back to camera space.
*
* @method Phaser.TilemapLayerGL#_unfixX
* @private
* @param {number} x - x coordinate in scrollFactor-adjusted dimensions
* @return {number} x coordinate in camera space
*/
Phaser.TilemapLayerGL.prototype._unfixX = function (x) {
if (this.scrollFactorX === 1)
{
return x;
}
return (this._scrollX / this.scrollFactorX) + (x - this._scrollX);
};
/**
* Take a y coordinate that doesn't account for scrollFactorY and 'fix' it into a scrolled local space.
*
* @method Phaser.TilemapLayerGL#_fixY
* @private
* @param {number} y - y coordinate in camera space
* @return {number} y coordinate in scrollFactor-adjusted dimensions
*/
Phaser.TilemapLayerGL.prototype._fixY = function (y) {
if (y < 0)
{
y = 0;
}
if (this.scrollFactorY === 1)
{
return y;
}
return this._scrollY + (y - (this._scrollY / this.scrollFactorY));
};
/**
* Take a y coordinate that _does_ account for scrollFactorY and 'unfix' it back to camera space.
*
* @method Phaser.TilemapLayerGL#_unfixY
* @private
* @param {number} y - y coordinate in scrollFactor-adjusted dimensions
* @return {number} y coordinate in camera space
*/
Phaser.TilemapLayerGL.prototype._unfixY = function (y) {
if (this.scrollFactorY === 1)
{
return y;
}
return (this._scrollY / this.scrollFactorY) + (y - this._scrollY);
};
/**
* Convert a pixel value to a tile coordinate.
*
* @method Phaser.TilemapLayerGL#getTileX
* @public
* @param {number} x - X position of the point in target tile (in pixels).
* @return {integer} The X map location of the tile.
*/
Phaser.TilemapLayerGL.prototype.getTileX = function (x) {
return Math.floor(this._fixX(x) / this._mc.tileWidth);
};
/**
* Convert a pixel value to a tile coordinate.
*
* @method Phaser.TilemapLayerGL#getTileY
* @public
* @param {number} y - Y position of the point in target tile (in pixels).
* @return {integer} The Y map location of the tile.
*/
Phaser.TilemapLayerGL.prototype.getTileY = function (y) {
return Math.floor(this._fixY(y) / this._mc.tileHeight);
};
/**
* Convert a pixel coordinate to a tile coordinate.
*
* @method Phaser.TilemapLayerGL#getTileXY
* @public
* @param {number} x - X position of the point in target tile (in pixels).
* @param {number} y - Y position of the point in target tile (in pixels).
* @param {(Phaser.Point|object)} point - The Point/object to update.
* @return {(Phaser.Point|object)} A Point/object with its `x` and `y` properties set.
*/
Phaser.TilemapLayerGL.prototype.getTileXY = function (x, y, point) {
point.x = this.getTileX(x);
point.y = this.getTileY(y);
return point;
};
/**
* The TilemapLayerGL caches tileset look-ups.
*
@ -668,17 +527,17 @@ Object.defineProperty(Phaser.TilemapLayerGL.prototype, "x", {
get: function () {
return this._offset.x;
return this.position.x;
},
set: function (value) {
this._offset.x = value;
this.position.x = value;
for (var i = 0; i < this.linkedLayers.length; i++)
{
this.linkedLayers[i]._offset.x = value;
this.linkedLayers[i].position.x = value;
}
this.dirty = true;
@ -691,17 +550,17 @@ Object.defineProperty(Phaser.TilemapLayerGL.prototype, "y", {
get: function () {
return this._offset.y;
return this.position.y;
},
set: function (value) {
this.offset.y = value;
this.position.y = value;
for (var i = 0; i < this.linkedLayers.length; i++)
{
this.linkedLayers[i]._offset.y = value;
this.linkedLayers[i].position.y = value;
}
this.dirty = true;