2018-02-12 16:01:20 +00:00
|
|
|
/**
|
|
|
|
* @author Richard Davey <rich@photonstorm.com>
|
2020-01-15 12:07:09 +00:00
|
|
|
* @copyright 2020 Photon Storm Ltd.
|
2019-05-10 15:15:04 +00:00
|
|
|
* @license {@link https://opensource.org/licenses/MIT|MIT License}
|
2018-02-12 16:01:20 +00:00
|
|
|
*/
|
|
|
|
|
2018-07-12 14:07:45 +00:00
|
|
|
var SnapFloor = require('../../math/snap/SnapFloor');
|
|
|
|
var SnapCeil = require('../../math/snap/SnapCeil');
|
|
|
|
|
2017-11-26 15:05:19 +00:00
|
|
|
/**
|
2018-08-21 17:02:00 +00:00
|
|
|
* Returns the tiles in the given layer that are within the camera's viewport. This is used internally.
|
2017-11-26 15:05:19 +00:00
|
|
|
*
|
2018-02-08 01:08:59 +00:00
|
|
|
* @function Phaser.Tilemaps.Components.CullTiles
|
2018-04-16 14:25:22 +00:00
|
|
|
* @private
|
2018-02-08 01:08:59 +00:00
|
|
|
* @since 3.0.0
|
|
|
|
*
|
2018-02-08 02:02:37 +00:00
|
|
|
* @param {Phaser.Tilemaps.LayerData} layer - The Tilemap Layer to act upon.
|
|
|
|
* @param {Phaser.Cameras.Scene2D.Camera} [camera] - The Camera to run the cull check against.
|
2018-09-28 13:32:36 +00:00
|
|
|
* @param {array} [outputArray] - An optional array to store the Tile objects within.
|
2018-03-15 19:32:09 +00:00
|
|
|
*
|
2018-02-08 02:02:37 +00:00
|
|
|
* @return {Phaser.Tilemaps.Tile[]} An array of Tile objects.
|
2017-11-26 15:05:19 +00:00
|
|
|
*/
|
2018-08-21 17:02:00 +00:00
|
|
|
var CullTiles = function (layer, camera, outputArray, renderOrder)
|
2017-11-18 14:31:59 +00:00
|
|
|
{
|
|
|
|
if (outputArray === undefined) { outputArray = []; }
|
2018-08-21 17:02:00 +00:00
|
|
|
if (renderOrder === undefined) { renderOrder = 0; }
|
2017-11-18 14:31:59 +00:00
|
|
|
|
|
|
|
outputArray.length = 0;
|
2018-07-15 01:09:36 +00:00
|
|
|
|
2018-08-06 12:31:27 +00:00
|
|
|
var tilemap = layer.tilemapLayer.tilemap;
|
2018-07-15 01:09:36 +00:00
|
|
|
var tilemapLayer = layer.tilemapLayer;
|
2018-07-12 00:14:34 +00:00
|
|
|
|
2018-04-23 16:45:42 +00:00
|
|
|
var mapData = layer.data;
|
|
|
|
var mapWidth = layer.width;
|
|
|
|
var mapHeight = layer.height;
|
2018-07-12 00:14:34 +00:00
|
|
|
|
2018-08-06 12:31:27 +00:00
|
|
|
// We need to use the tile sizes defined for the map as a whole, not the layer,
|
|
|
|
// in order to calculate the bounds correctly. As different sized tiles may be
|
|
|
|
// placed on the grid and we cannot trust layer.baseTileWidth to give us the true size.
|
|
|
|
var tileW = Math.floor(tilemap.tileWidth * tilemapLayer.scaleX);
|
|
|
|
var tileH = Math.floor(tilemap.tileHeight * tilemapLayer.scaleY);
|
2018-07-15 01:09:36 +00:00
|
|
|
|
2018-07-18 14:06:56 +00:00
|
|
|
var drawLeft = 0;
|
2018-07-16 13:55:51 +00:00
|
|
|
var drawRight = mapWidth;
|
|
|
|
var drawTop = 0;
|
|
|
|
var drawBottom = mapHeight;
|
2020-02-06 10:02:44 +00:00
|
|
|
|
2020-02-08 10:55:33 +00:00
|
|
|
// we define the isometric culling function as a dummy early on for it to make sense in scope
|
2020-02-06 10:02:44 +00:00
|
|
|
var inIsoBounds = function () { return true; };
|
|
|
|
if (!tilemapLayer.skipCull && tilemapLayer.scrollFactorX === 1 && tilemapLayer.scrollFactorY === 1)
|
|
|
|
{
|
|
|
|
if (layer.orientation === 'orthogonal')
|
|
|
|
{
|
2020-02-04 03:57:28 +00:00
|
|
|
// Camera world view bounds, snapped for scaled tile size
|
|
|
|
// Cull Padding values are given in tiles, not pixels
|
|
|
|
|
2020-02-06 10:02:44 +00:00
|
|
|
var boundsLeft = SnapFloor(camera.worldView.x - tilemapLayer.x, tileW, 0, true) - tilemapLayer.cullPaddingX;
|
|
|
|
var boundsRight = SnapCeil(camera.worldView.right - tilemapLayer.x, tileW, 0, true) + tilemapLayer.cullPaddingX;
|
|
|
|
var boundsTop = SnapFloor(camera.worldView.y - tilemapLayer.y, tileH, 0, true) - tilemapLayer.cullPaddingY;
|
2020-02-04 03:57:28 +00:00
|
|
|
var boundsBottom = SnapCeil(camera.worldView.bottom - tilemapLayer.y, tileH, 0, true) + tilemapLayer.cullPaddingY;
|
|
|
|
|
|
|
|
drawLeft = Math.max(0, boundsLeft);
|
|
|
|
drawRight = Math.min(mapWidth, boundsRight);
|
|
|
|
drawTop = Math.max(0, boundsTop);
|
|
|
|
drawBottom = Math.min(mapHeight, boundsBottom);
|
|
|
|
}
|
2020-02-06 10:02:44 +00:00
|
|
|
else if (layer.orientation === 'isometric')
|
|
|
|
{
|
|
|
|
inIsoBounds = function (x,y)
|
|
|
|
{
|
2020-02-07 14:21:11 +00:00
|
|
|
var cullDistances = tilemapLayer.isoCullDistances;
|
2020-02-06 10:02:44 +00:00
|
|
|
var pos = tilemapLayer.tileToWorldXY(x,y,undefined,camera);
|
2020-02-07 14:31:15 +00:00
|
|
|
|
|
|
|
// we always subtract 1/2 of the tile's height/width to make the culling distance start from the center of the tiles.
|
2020-02-07 14:21:11 +00:00
|
|
|
return pos.x > camera.worldView.x + tilemapLayer.scaleX * layer.tileWidth * (- cullDistances.x - 1 / 2)
|
|
|
|
&& pos.x < camera.worldView.right + tilemapLayer.scaleX * layer.tileWidth * (cullDistances.x - 1 / 2)
|
|
|
|
&& pos.y > camera.worldView.y + tilemapLayer.scaleY * layer.tileHeight * (- cullDistances.y - 1 / 2)
|
|
|
|
&& pos.y < camera.worldView.bottom + tilemapLayer.scaleY * layer.tileHeight * (cullDistances.y - 1 / 2);
|
2020-02-06 10:02:44 +00:00
|
|
|
};
|
|
|
|
}
|
|
|
|
}
|
2018-08-21 17:02:00 +00:00
|
|
|
var x;
|
|
|
|
var y;
|
|
|
|
var tile;
|
|
|
|
|
|
|
|
|
2020-02-06 10:02:44 +00:00
|
|
|
if (layer.orientation === 'orthogonal')
|
|
|
|
{
|
2020-02-04 03:57:28 +00:00
|
|
|
|
|
|
|
if (renderOrder === 0)
|
2018-07-14 19:30:15 +00:00
|
|
|
{
|
2020-02-04 03:57:28 +00:00
|
|
|
// right-down
|
2018-10-15 18:31:46 +00:00
|
|
|
|
2020-02-04 03:57:28 +00:00
|
|
|
for (y = drawTop; y < drawBottom; y++)
|
|
|
|
{
|
|
|
|
for (x = drawLeft; mapData[y] && x < drawRight; x++)
|
2018-08-21 17:02:00 +00:00
|
|
|
{
|
2020-02-04 03:57:28 +00:00
|
|
|
tile = mapData[y][x];
|
2018-10-15 18:31:46 +00:00
|
|
|
|
2020-02-04 03:57:28 +00:00
|
|
|
if (!tile || tile.index === -1 || !tile.visible || tile.alpha === 0)
|
|
|
|
{
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
outputArray.push(tile);
|
|
|
|
}
|
2018-08-21 17:02:00 +00:00
|
|
|
}
|
|
|
|
}
|
2020-02-04 03:57:28 +00:00
|
|
|
else if (renderOrder === 1)
|
2018-08-21 17:02:00 +00:00
|
|
|
{
|
2020-02-04 03:57:28 +00:00
|
|
|
// left-down
|
2018-10-15 18:31:46 +00:00
|
|
|
|
2020-02-04 03:57:28 +00:00
|
|
|
for (y = drawTop; y < drawBottom; y++)
|
|
|
|
{
|
|
|
|
for (x = drawRight; mapData[y] && x >= drawLeft; x--)
|
2018-08-21 17:02:00 +00:00
|
|
|
{
|
2020-02-04 03:57:28 +00:00
|
|
|
tile = mapData[y][x];
|
2018-10-15 18:31:46 +00:00
|
|
|
|
2020-02-04 03:57:28 +00:00
|
|
|
if (!tile || tile.index === -1 || !tile.visible || tile.alpha === 0)
|
|
|
|
{
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
outputArray.push(tile);
|
|
|
|
}
|
2018-07-14 19:30:15 +00:00
|
|
|
}
|
2018-08-21 17:02:00 +00:00
|
|
|
}
|
2020-02-04 03:57:28 +00:00
|
|
|
else if (renderOrder === 2)
|
2018-08-21 17:02:00 +00:00
|
|
|
{
|
2020-02-04 03:57:28 +00:00
|
|
|
// right-up
|
2018-10-15 18:31:46 +00:00
|
|
|
|
2020-02-04 03:57:28 +00:00
|
|
|
for (y = drawBottom; y >= drawTop; y--)
|
|
|
|
{
|
|
|
|
for (x = drawLeft; mapData[y] && x < drawRight; x++)
|
2018-08-21 17:02:00 +00:00
|
|
|
{
|
2020-02-04 03:57:28 +00:00
|
|
|
tile = mapData[y][x];
|
|
|
|
|
|
|
|
if (!tile || tile.index === -1 || !tile.visible || tile.alpha === 0)
|
|
|
|
{
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
outputArray.push(tile);
|
2018-08-21 17:02:00 +00:00
|
|
|
}
|
2020-02-04 03:57:28 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (renderOrder === 3)
|
|
|
|
{
|
|
|
|
// left-up
|
|
|
|
|
|
|
|
for (y = drawBottom; y >= drawTop; y--)
|
|
|
|
{
|
|
|
|
for (x = drawRight; mapData[y] && x >= drawLeft; x--)
|
|
|
|
{
|
|
|
|
tile = mapData[y][x];
|
2018-10-15 18:31:46 +00:00
|
|
|
|
2020-02-04 03:57:28 +00:00
|
|
|
if (!tile || tile.index === -1 || !tile.visible || tile.alpha === 0)
|
|
|
|
{
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
outputArray.push(tile);
|
|
|
|
}
|
2018-08-21 17:02:00 +00:00
|
|
|
}
|
2018-07-14 19:30:15 +00:00
|
|
|
}
|
2020-02-06 10:02:44 +00:00
|
|
|
}
|
|
|
|
else if (layer.orientation === 'isometric')
|
|
|
|
{
|
|
|
|
if (renderOrder === 0)
|
2020-02-04 03:57:28 +00:00
|
|
|
{
|
|
|
|
// right-down
|
2018-08-21 17:02:00 +00:00
|
|
|
|
2020-02-04 03:57:28 +00:00
|
|
|
for (y = drawTop; y < drawBottom; y++)
|
|
|
|
{
|
|
|
|
for (x = drawLeft; mapData[y] && x < drawRight; x++)
|
|
|
|
{
|
2020-02-06 10:02:44 +00:00
|
|
|
if (inIsoBounds(x,y))
|
|
|
|
{
|
2020-02-04 03:57:28 +00:00
|
|
|
tile = mapData[y][x];
|
|
|
|
|
|
|
|
if (!tile || tile.index === -1 || !tile.visible || tile.alpha === 0)
|
|
|
|
{
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
outputArray.push(tile);
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (renderOrder === 1)
|
2018-08-21 17:02:00 +00:00
|
|
|
{
|
2020-02-04 03:57:28 +00:00
|
|
|
// left-down
|
|
|
|
|
|
|
|
for (y = drawTop; y < drawBottom; y++)
|
2018-08-21 17:02:00 +00:00
|
|
|
{
|
2020-02-04 03:57:28 +00:00
|
|
|
for (x = drawRight; mapData[y] && x >= drawLeft; x--)
|
|
|
|
{
|
2020-02-06 10:02:44 +00:00
|
|
|
if (inIsoBounds(x,y))
|
|
|
|
{
|
2020-02-04 03:57:28 +00:00
|
|
|
tile = mapData[y][x];
|
|
|
|
|
|
|
|
if (!tile || tile.index === -1 || !tile.visible || tile.alpha === 0)
|
|
|
|
{
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
outputArray.push(tile);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (renderOrder === 2)
|
|
|
|
{
|
|
|
|
// right-up
|
2018-10-15 18:31:46 +00:00
|
|
|
|
2020-02-04 03:57:28 +00:00
|
|
|
for (y = drawBottom; y >= drawTop; y--)
|
|
|
|
{
|
|
|
|
for (x = drawLeft; mapData[y] && x < drawRight; x++)
|
2018-08-21 17:02:00 +00:00
|
|
|
{
|
2020-02-06 10:02:44 +00:00
|
|
|
if (inIsoBounds(x,y))
|
|
|
|
{
|
2020-02-04 03:57:28 +00:00
|
|
|
tile = mapData[y][x];
|
|
|
|
|
|
|
|
if (!tile || tile.index === -1 || !tile.visible || tile.alpha === 0)
|
|
|
|
{
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
outputArray.push(tile);
|
|
|
|
}
|
2018-08-21 17:02:00 +00:00
|
|
|
}
|
2020-02-04 03:57:28 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (renderOrder === 3)
|
|
|
|
{
|
|
|
|
// left-up
|
2018-10-15 18:31:46 +00:00
|
|
|
|
2020-02-04 03:57:28 +00:00
|
|
|
for (y = drawBottom; y >= drawTop; y--)
|
|
|
|
{
|
|
|
|
for (x = drawRight; mapData[y] && x >= drawLeft; x--)
|
|
|
|
{
|
2020-02-06 10:02:44 +00:00
|
|
|
if (inIsoBounds(x,y))
|
|
|
|
{
|
2020-02-04 03:57:28 +00:00
|
|
|
tile = mapData[y][x];
|
|
|
|
|
|
|
|
if (!tile || tile.index === -1 || !tile.visible || tile.alpha === 0)
|
|
|
|
{
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
outputArray.push(tile);
|
|
|
|
}
|
|
|
|
}
|
2018-08-21 17:02:00 +00:00
|
|
|
}
|
|
|
|
}
|
2020-02-04 03:57:28 +00:00
|
|
|
|
2018-08-21 17:02:00 +00:00
|
|
|
}
|
|
|
|
|
2020-02-04 03:57:28 +00:00
|
|
|
|
2018-07-12 15:12:55 +00:00
|
|
|
tilemapLayer.tilesDrawn = outputArray.length;
|
|
|
|
tilemapLayer.tilesTotal = mapWidth * mapHeight;
|
2018-07-12 00:14:34 +00:00
|
|
|
|
2017-11-18 14:31:59 +00:00
|
|
|
return outputArray;
|
|
|
|
};
|
|
|
|
|
|
|
|
module.exports = CullTiles;
|