Mirrors/phaser
2
0
Fork 0
mirror of https://github.com/photonstorm/phaser synced 2025-02-16 14:08:28 +00:00
Code Issues Projects Releases Packages Wiki Activity

The Static and Dynamic Tilemap Layer objects have been removed and consolidated into the new TilemapLayer class.

Browse source
This commit is contained in:
Richard Davey 2020-10-12 11:40:40 +01:00
parent 63d2beb903
commit 0ba1f08f80
12 changed files with 1122 additions and 3074 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

532
src/tilemaps/Tilemap.js
View file

File diff suppressed because it is too large Load diff

1829
src/tilemaps/dynamiclayer/DynamicTilemapLayer.js → src/tilemaps/TilemapLayer.js
View file

File diff suppressed because it is too large Load diff

18
src/tilemaps/dynamiclayer/DynamicTilemapLayerCanvasRenderer.js → src/tilemaps/TilemapLayerCanvasRenderer.js
View file

@ -9,23 +9,23 @@
* The object will not render if any of its renderFlags are set or it is being actively filtered out by the Camera.
* This method should not be called directly. It is a utility function of the Render module.
*
* @method Phaser.Tilemaps.DynamicTilemapLayer#renderCanvas
* @since 3.0.0
* @method Phaser.Tilemaps.TilemapLayer#renderCanvas
* @since 3.50.0
* @private
*
* @param {Phaser.Renderer.Canvas.CanvasRenderer} renderer - A reference to the current active Canvas renderer.
* @param {Phaser.Tilemaps.DynamicTilemapLayer} src - The Game Object being rendered in this call.
* @param {Phaser.Tilemaps.TilemapLayer} src - The Game Object being rendered in this call.
* @param {Phaser.Cameras.Scene2D.Camera} camera - The Camera that is rendering the Game Object.
* @param {Phaser.GameObjects.Components.TransformMatrix} parentMatrix - This transform matrix is defined if the game object is nested
*/
var DynamicTilemapLayerCanvasRenderer = function (renderer, src, camera, parentMatrix)
var TilemapLayerCanvasRenderer = function (renderer, src, camera, parentMatrix)
{
src.cull(camera);
var renderTiles = src.cull(camera);
var renderTiles = src.culledTiles;
var tileCount = renderTiles.length;
var alpha = camera.alpha * src.alpha;
if (tileCount === 0)
if (tileCount === 0 || alpha <= 0)
{
return;
}
@ -65,8 +65,6 @@ var DynamicTilemapLayerCanvasRenderer = function (renderer, src, camera, parentM
layerMatrix.copyToContext(ctx);
}
var alpha = camera.alpha * src.alpha;
if (!renderer.antialias || src.scaleX > 1 || src.scaleY > 1)
{
ctx.imageSmoothingEnabled = false;
@ -122,4 +120,4 @@ var DynamicTilemapLayerCanvasRenderer = function (renderer, src, camera, parentM
ctx.restore();
};
module.exports = DynamicTilemapLayerCanvasRenderer;
module.exports = TilemapLayerCanvasRenderer;

4
src/tilemaps/staticlayer/StaticTilemapLayerRender.js → src/tilemaps/TilemapLayerRender.js
View file

@ -9,12 +9,12 @@ var renderCanvas = require('../../utils/NOOP');
if (typeof WEBGL_RENDERER)
{
renderWebGL = require('./StaticTilemapLayerWebGLRenderer');
renderWebGL = require('./TilemapLayerWebGLRenderer');
}
if (typeof CANVAS_RENDERER)
{
renderCanvas = require('./StaticTilemapLayerCanvasRenderer');
renderCanvas = require('./TilemapLayerCanvasRenderer');
}
module.exports = {

21
src/tilemaps/dynamiclayer/DynamicTilemapLayerWebGLRenderer.js → src/tilemaps/TilemapLayerWebGLRenderer.js
View file

@ -4,26 +4,25 @@
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
var Utils = require('../../renderer/webgl/Utils');
var Utils = require('../renderer/webgl/Utils');
/**
* Renders this Game Object with the WebGL Renderer to the given Camera.
* The object will not render if any of its renderFlags are set or it is being actively filtered out by the Camera.
* This method should not be called directly. It is a utility function of the Render module.
*
* @method Phaser.Tilemaps.DynamicTilemapLayer#renderWebGL
* @method Phaser.Tilemaps.TilemapLayer#renderWebGL
* @since 3.0.0
* @private
*
* @param {Phaser.Renderer.WebGL.WebGLRenderer} renderer - A reference to the current active WebGL renderer.
* @param {Phaser.Tilemaps.DynamicTilemapLayer} src - The Game Object being rendered in this call.
* @param {Phaser.Tilemaps.TilemapLayer} src - The Game Object being rendered in this call.
* @param {Phaser.Cameras.Scene2D.Camera} camera - The Camera that is rendering the Game Object.
*/
var DynamicTilemapLayerWebGLRenderer = function (renderer, src, camera)
var TilemapLayerWebGLRenderer = function (renderer, src, camera)
{
src.cull(camera);
var renderTiles = src.cull(camera);
var renderTiles = src.culledTiles;
var tileCount = renderTiles.length;
var alpha = camera.alpha * src.alpha;
@ -52,10 +51,6 @@ var DynamicTilemapLayerWebGLRenderer = function (renderer, src, camera)
var tileset = gidMap[tile.index];
var texture = tileset.glTexture;
var textureUnit = pipeline.setTexture2D(texture, src);
var tileTexCoords = tileset.getTileTextureCoordinates(tile.index);
if (tileTexCoords === null)
@ -63,6 +58,10 @@ var DynamicTilemapLayerWebGLRenderer = function (renderer, src, camera)
continue;
}
var texture = tileset.glTexture;
var textureUnit = pipeline.setTexture2D(texture, src);
var frameWidth = tileset.tileWidth;
var frameHeight = tileset.tileHeight;
@ -96,4 +95,4 @@ var DynamicTilemapLayerWebGLRenderer = function (renderer, src, camera)
}
};
module.exports = DynamicTilemapLayerWebGLRenderer;
module.exports = TilemapLayerWebGLRenderer;

25
src/tilemaps/dynamiclayer/DynamicTilemapLayerRender.js
View file

@ -1,25 +0,0 @@
/**
* @author Richard Davey <rich@photonstorm.com>
* @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
var renderWebGL = require('../../utils/NOOP');
var renderCanvas = require('../../utils/NOOP');
if (typeof WEBGL_RENDERER)
{
renderWebGL = require('./DynamicTilemapLayerWebGLRenderer');
}
if (typeof CANVAS_RENDERER)
{
renderCanvas = require('./DynamicTilemapLayerCanvasRenderer');
}
module.exports = {
renderWebGL: renderWebGL,
renderCanvas: renderCanvas
};

6
src/tilemaps/index.js
View file

@ -24,13 +24,11 @@ var PhaserTilemaps = {
TilemapCreator: require('./TilemapCreator'),
TilemapFactory: require('./TilemapFactory'),
Tileset: require('./Tileset'),
TilemapLayer: require('./TilemapLayer'),
LayerData: require('./mapdata/LayerData'),
MapData: require('./mapdata/MapData'),
ObjectLayer: require('./mapdata/ObjectLayer'),
DynamicTilemapLayer: require('./dynamiclayer/DynamicTilemapLayer'),
StaticTilemapLayer: require('./staticlayer/StaticTilemapLayer')
ObjectLayer: require('./mapdata/ObjectLayer')
};

4
src/tilemaps/mapdata/LayerData.js
View file

@ -11,7 +11,7 @@ var GetFastValue = require('../../utils/object/GetFastValue');
/**
* @classdesc
* A class for representing data about about a layer in a map. Maps are parsed from CSV, Tiled,
* etc. into this format. Tilemap, StaticTilemapLayer and DynamicTilemapLayer have a reference
* etc. into this format. Tilemap and TilemapLayer objects have a reference
* to this data and use it to look up and perform operations on tiles.
*
* @class LayerData
@ -213,7 +213,7 @@ var LayerData = new Class({
* A reference to the Tilemap layer that owns this data.
*
* @name Phaser.Tilemaps.LayerData#tilemapLayer
* @type {(Phaser.Tilemaps.DynamicTilemapLayer|Phaser.Tilemaps.StaticTilemapLayer)}
* @type {Phaser.Tilemaps.TilemapLayer}
* @since 3.0.0
*/
this.tilemapLayer = GetFastValue(config, 'tilemapLayer', null);

1538
src/tilemaps/staticlayer/StaticTilemapLayer.js
View file

File diff suppressed because it is too large Load diff

127
src/tilemaps/staticlayer/StaticTilemapLayerCanvasRenderer.js
View file

@ -1,127 +0,0 @@
/**
* @author Richard Davey <rich@photonstorm.com>
* @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
/**
* Renders this Game Object with the Canvas Renderer to the given Camera.
* The object will not render if any of its renderFlags are set or it is being actively filtered out by the Camera.
* This method should not be called directly. It is a utility function of the Render module.
*
* @method Phaser.Tilemaps.StaticTilemapLayer#renderCanvas
* @since 3.0.0
* @private
*
* @param {Phaser.Renderer.Canvas.CanvasRenderer} renderer - A reference to the current active Canvas renderer.
* @param {Phaser.Tilemaps.StaticTilemapLayer} src - The Game Object being rendered in this call.
* @param {Phaser.Cameras.Scene2D.Camera} camera - The Camera that is rendering the Game Object.
* @param {Phaser.GameObjects.Components.TransformMatrix} parentMatrix - This transform matrix is defined if the game object is nested
*/
var StaticTilemapLayerCanvasRenderer = function (renderer, src, camera, parentMatrix)
{
src.cull(camera);
var renderTiles = src.culledTiles;
var tileCount = renderTiles.length;
if (tileCount === 0)
{
return;
}
var camMatrix = renderer._tempMatrix1;
var layerMatrix = renderer._tempMatrix2;
var calcMatrix = renderer._tempMatrix3;
layerMatrix.applyITRS(src.x, src.y, src.rotation, src.scaleX, src.scaleY);
camMatrix.copyFrom(camera.matrix);
var ctx = renderer.currentContext;
var gidMap = src.gidMap;
ctx.save();
if (parentMatrix)
{
// Multiply the camera by the parent matrix
camMatrix.multiplyWithOffset(parentMatrix, -camera.scrollX * src.scrollFactorX, -camera.scrollY * src.scrollFactorY);
// Undo the camera scroll
layerMatrix.e = src.x;
layerMatrix.f = src.y;
camMatrix.multiply(layerMatrix, calcMatrix);
calcMatrix.copyToContext(ctx);
}
else
{
// Undo the camera scroll
layerMatrix.e -= camera.scrollX * src.scrollFactorX;
layerMatrix.f -= camera.scrollY * src.scrollFactorY;
layerMatrix.copyToContext(ctx);
}
var alpha = camera.alpha * src.alpha;
if (!renderer.antialias || src.scaleX > 1 || src.scaleY > 1)
{
ctx.imageSmoothingEnabled = false;
}
for (var i = 0; i < tileCount; i++)
{
var tile = renderTiles[i];
var tileset = gidMap[tile.index];
if (!tileset)
{
continue;
}
var image = tileset.image.getSourceImage();
var tileTexCoords = tileset.getTileTextureCoordinates(tile.index);
if (tileTexCoords)
{
var tileWidth = tileset.tileWidth;
var tileHeight = tileset.tileHeight;
var halfWidth = tileWidth / 2;
var halfHeight = tileHeight / 2;
ctx.save();
ctx.translate(tile.pixelX + halfWidth, tile.pixelY + halfHeight);
if (tile.rotation !== 0)
{
ctx.rotate(tile.rotation);
}
if (tile.flipX || tile.flipY)
{
ctx.scale((tile.flipX) ? -1 : 1, (tile.flipY) ? -1 : 1);
}
ctx.globalAlpha = alpha * tile.alpha;
ctx.drawImage(
image,
tileTexCoords.x, tileTexCoords.y,
tileWidth, tileHeight,
-halfWidth, -halfHeight,
tileWidth, tileHeight
);
ctx.restore();
}
}
ctx.restore();
};
module.exports = StaticTilemapLayerCanvasRenderer;

88
src/tilemaps/staticlayer/StaticTilemapLayerWebGLRenderer.js
View file

@ -1,88 +0,0 @@
/**
* @author Richard Davey <rich@photonstorm.com>
* @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
var Identity = require('../../renderer/webgl/mvp/Identity');
var Scale = require('../../renderer/webgl/mvp/Scale');
var Translate = require('../../renderer/webgl/mvp/Translate');
var ViewLoad2D = require('../../renderer/webgl/mvp/ViewLoad2D');
/**
* Renders this Game Object with the WebGL Renderer to the given Camera.
*
* The object will not render if any of its renderFlags are set or it is being actively filtered out by the Camera.
* This method should not be called directly. It is a utility function of the Render module.
*
* A Static Tilemap Layer renders immediately and does not use any batching.
*
* @method Phaser.Tilemaps.StaticTilemapLayer#renderWebGL
* @since 3.0.0
* @private
*
* @param {Phaser.Renderer.WebGL.WebGLRenderer} renderer - A reference to the current active WebGL renderer.
* @param {Phaser.Tilemaps.StaticTilemapLayer} src - The Game Object being rendered in this call.
* @param {Phaser.Cameras.Scene2D.Camera} camera - The Camera that is rendering the Game Object.
*/
var StaticTilemapLayerWebGLRenderer = function (renderer, src, camera)
{
var gl = renderer.gl;
var pipeline = src.pipeline;
renderer.flush();
// Restore when we're done
var pipelineVertexBuffer = pipeline.vertexBuffer;
Identity(src);
Translate(src, src.x - (camera.scrollX * src.scrollFactorX), src.y - (camera.scrollY * src.scrollFactorY), 0);
Scale(src, src.scaleX, src.scaleY, 1);
ViewLoad2D(src, camera.matrix.matrix);
renderer.pipelines.set(pipeline);
// The above alters the uniforms, so make sure we call it _after_ setting the MVP stuff above
renderer.setMatrix4(pipeline.program, 'uModelMatrix', false, src.modelMatrix);
renderer.setMatrix4(pipeline.program, 'uViewMatrix', false, src.viewMatrix);
renderer.setMatrix4(pipeline.program, 'uProjectionMatrix', false, pipeline.projectionMatrix);
for (var i = 0; i < src.tileset.length; i++)
{
var tileset = src.tileset[i];
var vertexCount = src.vertexCount[i];
src.upload(camera, i);
if (vertexCount > 0)
{
if (pipeline.forceZero)
{
// Light Pipeline, or similar
pipeline.setGameObject(src, tileset);
}
else
{
renderer.setTextureZero(tileset.glTexture);
}
gl.drawArrays(gl.TRIANGLES, 0, vertexCount);
}
}
renderer.resetTextures();
// Restore the pipeline buffer
pipeline.vertexBuffer = pipelineVertexBuffer;
renderer.currentVertexBuffer = pipelineVertexBuffer;
pipeline.setAttribPointers();
// Reset the uniforms
renderer.setMatrix4(pipeline.program, 'uModelMatrix', false, pipeline.modelMatrix);
renderer.setMatrix4(pipeline.program, 'uViewMatrix', false, pipeline.viewMatrix);
renderer.setMatrix4(pipeline.program, 'uProjectionMatrix', false, pipeline.projectionMatrix);
};
module.exports = StaticTilemapLayerWebGLRenderer;

4
src/tilemaps/typedefs/LayerDataConfig.js
View file

@ -1,7 +1,7 @@
/**
* @typedef {object} Phaser.Types.Tilemaps.LayerDataConfig
* @since 3.0.0
*
*
* @property {string} [name] - The name of the layer, if specified in Tiled.
* @property {number} [x=0] - The x offset of where to draw from the top left.
* @property {number} [y=0] - The y offset of where to draw from the top left.
@ -21,5 +21,5 @@
* @property {array} [callbacks] - An array of callbacks.
* @property {array} [bodies] - An array of physics bodies.
* @property {array} [data] - An array of the tile data indexes.
* @property {Phaser.Tilemaps.DynamicTilemapLayer|Phaser.Tilemaps.StaticTilemapLayer} [tilemapLayer] - A reference to the Tilemap layer that owns this data.
* @property {Phaser.Tilemaps.TilemapLayer} [tilemapLayer] - A reference to the Tilemap layer that owns this data.
*/