phaser/src/renderer/webgl/PipelineManager.js

542 lines
16 KiB
JavaScript
Raw Normal View History

2020-09-09 10:38:45 +00:00
/**
* @author Richard Davey <rich@photonstorm.com>
* @copyright 2020 Photon Storm Ltd.
* @license {@link https://opensource.org/licenses/MIT|MIT License}
*/
var Class = require('../../utils/Class');
var CustomMap = require('../../structs/Map');
var CONST = require('./pipelines/const');
// Default Phaser 3 Pipelines
var BitmapMaskPipeline = require('./pipelines/BitmapMaskPipeline');
2020-10-28 17:39:54 +00:00
var GraphicsPipeline = require('./pipelines/GraphicsPipeline');
2020-09-09 10:38:45 +00:00
var LightPipeline = require('./pipelines/LightPipeline');
var MultiPipeline = require('./pipelines/MultiPipeline');
var RopePipeline = require('./pipelines/RopePipeline');
var SinglePipeline = require('./pipelines/SinglePipeline');
/**
* @classdesc
2020-09-22 10:33:40 +00:00
* The Pipeline Manager is responsible for the creation, activation, running and destruction
* of WebGL Pipelines in Phaser 3.
2020-09-09 10:38:45 +00:00
*
2020-09-22 10:33:40 +00:00
* The `WebGLRenderer` owns a single instance of the Pipeline Manager, which you can access
* via the `WebGLRenderer.pipelines` property.
*
* By default, there are 5 pipelines installed into the Pipeline Manager when Phaser boots:
2020-09-22 10:33:40 +00:00
*
* 1. The Multi Pipeline. Responsible for all multi-texture rendering, i.e. Sprites, Shapes.
* 2. The Single Pipeline. Responsible for rendering Game Objects that explicitly require one bound texture.
* 3. The Rope Pipeline. Responsible for rendering the Rope Game Object.
* 4. The Light Pipeline. Responsible for rendering the Light Game Object.
* 5. The Bitmap Mask Pipeline. Responsible for Bitmap Mask rendering.
2020-09-22 10:33:40 +00:00
*
* You can add your own custom pipeline via the `PipelineManager.add` method. Pipelines are
* identified by unique string-based keys.
2020-09-09 10:38:45 +00:00
*
* @class PipelineManager
* @memberof Phaser.Renderer.WebGL
* @constructor
* @since 3.50.0
*
2020-09-09 12:04:45 +00:00
* @param {Phaser.Renderer.WebGL.WebGLRenderer} renderer - A reference to the WebGL Renderer that owns this Pipeline Manager.
2020-09-09 10:38:45 +00:00
*/
var PipelineManager = new Class({
initialize:
2020-09-09 12:04:45 +00:00
function PipelineManager (renderer)
2020-09-09 10:38:45 +00:00
{
/**
* A reference to the Game instance.
*
* @name Phaser.Renderer.WebGL.PipelineManager#game
* @type {Phaser.Game}
* @since 3.50.0
*/
2020-09-09 12:04:45 +00:00
this.game = renderer.game;
2020-09-09 10:38:45 +00:00
/**
* A reference to the WebGL Renderer instance.
*
* @name Phaser.Renderer.WebGL.PipelineManager#renderer
* @type {Phaser.Renderer.WebGL.WebGLRenderer}
* @since 3.50.0
*/
2020-09-09 12:04:45 +00:00
this.renderer = renderer;
2020-09-09 10:38:45 +00:00
/**
* This map stores all pipeline instances in this manager.
*
* This is populated with the default pipelines in the `boot` method.
*
* @name Phaser.Renderer.WebGL.PipelineManager#pipelines
2020-09-09 10:38:45 +00:00
* @type {Phaser.Structs.Map.<string, Phaser.Renderer.WebGL.WebGLPipeline>}
* @since 3.50.0
*/
this.pipelines = new CustomMap();
/**
* Current pipeline in use by the WebGLRenderer.
*
2020-09-09 12:04:45 +00:00
* @name Phaser.Renderer.WebGL.PipelineManager#current
2020-09-09 10:38:45 +00:00
* @type {Phaser.Renderer.WebGL.WebGLPipeline}
* @default null
* @since 3.50.0
*/
2020-09-09 12:04:45 +00:00
this.current = null;
2020-09-09 10:38:45 +00:00
/**
* The previous WebGLPipeline that was in use.
*
* This is set when `clearPipeline` is called and restored in `rebindPipeline` if none is given.
*
2020-09-09 12:04:45 +00:00
* @name Phaser.Renderer.WebGL.PipelineManager#previous
2020-09-09 10:38:45 +00:00
* @type {Phaser.Renderer.WebGL.WebGLPipeline}
* @default null
* @since 3.50.0
*/
2020-09-09 12:04:45 +00:00
this.previous = null;
/**
* A constant-style reference to the Multi Pipeline Instance.
*
* This is the default Phaser 3 pipeline and is used by the WebGL Renderer to manage
* camera effects and more. This property is set during the `boot` method.
*
* @name Phaser.Renderer.WebGL.PipelineManager#MULTI_PIPELINE
* @type {Phaser.Renderer.WebGL.Pipelines.MultiPipeline}
* @default null
* @since 3.50.0
*/
this.MULTI_PIPELINE = null;
/**
* A constant-style reference to the Bitmap Mask Pipeline Instance.
*
* This is the default Phaser 3 mask pipeline and is used Game Objects using
* a Bitmap Mask. This property is set during the `boot` method.
*
* @name Phaser.Renderer.WebGL.PipelineManager#BITMAPMASK_PIPELINE
* @type {Phaser.Renderer.WebGL.Pipelines.BitmapMaskPipeline}
* @default null
* @since 3.50.0
*/
this.BITMAPMASK_PIPELINE = null;
2020-09-09 10:38:45 +00:00
},
/**
* Internal boot handler, called by the WebGLRenderer durings its boot process.
*
* Adds all of the default pipelines, based on the game config, and then calls
* the `boot` method on each one of them.
*
* Finally, the default pipeline is set.
*
* @method Phaser.Renderer.WebGL.PipelineManager#boot
* @since 3.50.0
*/
boot: function ()
{
var game = this.game;
2020-09-09 12:04:45 +00:00
this.MULTI_PIPELINE = this.add(CONST.MULTI_PIPELINE, new MultiPipeline({ game: game }));
this.BITMAPMASK_PIPELINE = this.add(CONST.BITMAPMASK_PIPELINE, new BitmapMaskPipeline({ game: game }));
2020-09-09 10:38:45 +00:00
this.add(CONST.SINGLE_PIPELINE, new SinglePipeline({ game: game }));
this.add(CONST.ROPE_PIPELINE, new RopePipeline({ game: game }));
this.add(CONST.LIGHT_PIPELINE, new LightPipeline({ game: game }));
2020-10-28 17:39:54 +00:00
this.add(CONST.GRAPHICS_PIPELINE, new GraphicsPipeline({ game: game }));
2020-09-09 10:38:45 +00:00
},
/**
* Adds a pipeline instance to this Pipeline Manager.
*
* The name of the instance must be unique within this manager.
*
* Make sure to pass an instance to this method, not a base class.
*
* For example, you should pass it like this:
*
* ```javascript
* this.add('yourName', new CustomPipeline());`
* ```
*
* and **not** like this:
2020-09-09 10:38:45 +00:00
*
* ```javascript
* this.add('yourName', CustomPipeline);`
2020-09-09 10:38:45 +00:00
* ```
*
* @method Phaser.Renderer.WebGL.PipelineManager#addPipeline
* @since 3.50.0
*
* @param {string} name - A unique string-based key for the pipeline within the manager.
* @param {Phaser.Renderer.WebGL.WebGLPipeline} pipeline - A pipeline _instance_ which must extend `WebGLPipeline`.
*
* @return {Phaser.Renderer.WebGL.WebGLPipeline} The pipeline instance that was passed.
*/
add: function (name, pipeline)
{
var pipelines = this.pipelines;
var renderer = this.renderer;
if (!pipelines.has(name))
{
pipeline.name = name;
2020-09-09 10:38:45 +00:00
pipelines.set(name, pipeline);
}
else
{
console.warn('Pipeline exists: ' + name);
}
if (renderer.width !== 0 && renderer.height !== 0)
{
pipeline.resize(renderer.width, renderer.height);
}
2020-09-09 10:38:45 +00:00
if (!pipeline.hasBooted)
{
pipeline.boot();
}
return pipeline;
},
/**
* Resizes handler.
*
* This is called automatically by the `WebGLRenderer` when the game resizes.
*
* @method Phaser.Renderer.WebGL.PipelineManager#resize
* @since 3.50.0
*
* @param {number} [width] - The new width of the renderer.
* @param {number} [height] - The new height of the renderer.
*/
resize: function (width, height)
2020-09-09 10:38:45 +00:00
{
var pipelines = this.pipelines;
pipelines.each(function (pipelineName, pipelineInstance)
{
pipelineInstance.resize(width, height);
2020-09-09 10:38:45 +00:00
});
},
2020-09-09 12:04:45 +00:00
/**
* Calls the `onPreRender` method on each pipeline in this manager.
*
* This is called automatically by the `WebGLRenderer.preRender` method.
*
* @method Phaser.Renderer.WebGL.PipelineManager#preRender
* @since 3.50.0
*/
preRender: function ()
{
var pipelines = this.pipelines;
pipelines.each(function (pipelineName, pipelineInstance)
{
pipelineInstance.onPreRender();
});
},
/**
* Calls the `onRender` method on each pipeline in this manager.
*
* This is called automatically by the `WebGLRenderer.render` method.
*
* @method Phaser.Renderer.WebGL.PipelineManager#render
* @since 3.50.0
*
* @param {Phaser.Scene} scene - The Scene to render.
* @param {Phaser.Cameras.Scene2D.Camera} camera - The Scene Camera to render with.
*/
render: function (scene, camera)
{
var pipelines = this.pipelines;
pipelines.each(function (pipelineName, pipelineInstance)
{
pipelineInstance.onRender(scene, camera);
});
},
/**
* Calls the `onPostRender` method on each pipeline in this manager.
*
* This is called automatically by the `WebGLRenderer.postRender` method.
*
* @method Phaser.Renderer.WebGL.PipelineManager#postRender
* @since 3.50.0
*/
postRender: function ()
{
2020-10-27 18:06:28 +00:00
this.flush();
2020-09-09 12:04:45 +00:00
var pipelines = this.pipelines;
pipelines.each(function (pipelineName, pipelineInstance)
{
pipelineInstance.onPostRender();
});
},
2020-09-09 10:38:45 +00:00
/**
* Flushes the current pipeline, if one is bound.
*
* @method Phaser.Renderer.WebGL.PipelineManager#flush
* @since 3.50.0
*/
flush: function ()
{
2020-09-09 12:21:38 +00:00
if (this.current)
2020-09-09 10:38:45 +00:00
{
2020-09-09 12:21:38 +00:00
this.current.flush();
2020-09-09 10:38:45 +00:00
}
},
/**
2020-10-27 14:05:48 +00:00
* Checks if a pipeline is present in this Pipeline Manager.
2020-09-09 10:38:45 +00:00
*
* @method Phaser.Renderer.WebGL.PipelineManager#has
* @since 3.50.0
*
2020-10-27 14:05:48 +00:00
* @param {(string|Phaser.Renderer.WebGL.WebGLPipeline)} pipeline - Either the string-based name of the pipeline to get, or a pipeline instance to look-up.
2020-09-09 10:38:45 +00:00
*
* @return {boolean} `true` if the given pipeline is loaded, otherwise `false`.
*/
2020-10-27 14:05:48 +00:00
has: function (pipeline)
2020-09-09 10:38:45 +00:00
{
2020-10-27 14:05:48 +00:00
var pipelines = this.pipelines;
if (typeof pipeline === 'string')
{
return pipelines.has(pipeline);
}
else if (pipelines.contains(pipeline))
{
return true;
}
return false;
2020-09-09 10:38:45 +00:00
},
/**
2020-10-27 14:05:48 +00:00
* Returns the pipeline instance based on the given name, or instance.
2020-09-09 10:38:45 +00:00
*
2020-10-27 14:05:48 +00:00
* If no instance, or matching name, exists in this manager, it returns `undefined`.
2020-09-09 10:38:45 +00:00
*
* @method Phaser.Renderer.WebGL.PipelineManager#get
* @since 3.50.0
*
2020-10-27 14:05:48 +00:00
* @param {(string|Phaser.Renderer.WebGL.WebGLPipeline)} pipeline - Either the string-based name of the pipeline to get, or a pipeline instance to look-up.
2020-09-09 10:38:45 +00:00
*
* @return {Phaser.Renderer.WebGL.WebGLPipeline} The pipeline instance, or `undefined` if not found.
*/
2020-10-27 14:05:48 +00:00
get: function (pipeline)
2020-09-09 10:38:45 +00:00
{
2020-10-27 14:05:48 +00:00
var pipelines = this.pipelines;
if (typeof pipeline === 'string')
{
return pipelines.get(pipeline);
}
else if (pipelines.contains(pipeline))
{
return pipeline;
}
2020-09-09 10:38:45 +00:00
},
/**
* Removes a pipeline based on the given name.
*
* If no pipeline matches the name, this method does nothing.
*
* Note that the pipeline will not be flushed or destroyed, it's simply removed from
* this manager.
*
* @method Phaser.Renderer.WebGL.PipelineManager#remove
* @since 3.50.0
*
* @param {string} name - The name of the pipeline to be removed.
*/
remove: function (name)
{
this.pipelines.delete(name);
},
/**
* Sets the current pipeline to be used by the `WebGLRenderer`.
*
* This method accepts a pipeline instance as its parameter, not the name.
*
* If the pipeline isn't already the current one, it will also call `resetTextures` on
* the `WebGLRenderer`. After this, `WebGLPipeline.bind` and then `onBind` are called.
*
* @method Phaser.Renderer.WebGL.PipelineManager#set
* @since 3.50.0
*
* @param {Phaser.Renderer.WebGL.WebGLPipeline} pipeline - The pipeline instance to be set as current.
* @param {Phaser.GameObjects.GameObject} [gameObject] - The Game Object that invoked this pipeline, if any.
*
* @return {Phaser.Renderer.WebGL.WebGLPipeline} The pipeline that was set.
*/
set: function (pipeline, gameObject)
{
var renderer = this.renderer;
2020-09-09 12:04:45 +00:00
var current = this.current;
2020-09-09 10:38:45 +00:00
if (
current !== pipeline ||
current.vertexBuffer !== renderer.currentVertexBuffer ||
current.currentShader.program !== renderer.currentProgram
2020-09-09 10:38:45 +00:00
)
{
renderer.resetTextures();
2020-09-09 12:04:45 +00:00
this.current = pipeline;
2020-09-09 10:38:45 +00:00
pipeline.bind();
}
pipeline.onBind(gameObject);
return pipeline;
},
2020-09-09 12:09:25 +00:00
/**
* Sets the Multi Pipeline to be the currently bound pipeline.
*
* This is the default Phaser 3 rendering pipeline.
*
* @method Phaser.Renderer.WebGL.PipelineManager#setMulti
* @since 3.50.0
*
* @return {Phaser.Renderer.WebGL.Pipelines.MultiPipeline} The Multi Pipeline instance.
*/
2020-09-09 12:04:45 +00:00
setMulti: function ()
{
return this.set(this.MULTI_PIPELINE);
},
2020-09-09 10:38:45 +00:00
/**
* Use this to reset the gl context to the state that Phaser requires to continue rendering.
*
* Calling this will:
*
* * Disable `DEPTH_TEST`, `CULL_FACE` and `STENCIL_TEST`.
* * Clear the depth buffer and stencil buffers.
* * Reset the viewport size.
* * Reset the blend mode.
* * Bind a blank texture as the active texture on texture unit zero.
* * Rebinds the given pipeline instance.
*
* You should call this if you have previously called `clear`, and then wish to return
* rendering control to Phaser again.
*
* @method Phaser.Renderer.WebGL.PipelineManager#rebind
* @since 3.50.0
*
* @param {Phaser.Renderer.WebGL.WebGLPipeline} [pipeline] - The pipeline instance to be rebound. If not given, the previous pipeline will be bound.
*/
rebind: function (pipeline)
{
2020-09-09 12:04:45 +00:00
if (pipeline === undefined && this.previous)
2020-09-09 10:38:45 +00:00
{
2020-09-09 12:04:45 +00:00
pipeline = this.previous;
2020-09-09 10:38:45 +00:00
}
if (!pipeline)
{
return;
}
var renderer = this.renderer;
2020-09-09 12:33:25 +00:00
var gl = renderer.gl;
2020-09-09 10:38:45 +00:00
gl.disable(gl.DEPTH_TEST);
gl.disable(gl.CULL_FACE);
if (renderer.hasActiveStencilMask())
{
gl.clear(gl.DEPTH_BUFFER_BIT);
}
else
{
// If there wasn't a stencil mask set before this call, we can disable it safely
gl.disable(gl.STENCIL_TEST);
gl.clear(gl.DEPTH_BUFFER_BIT | gl.STENCIL_BUFFER_BIT);
}
gl.viewport(0, 0, renderer.width, renderer.height);
renderer.currentProgram = null;
renderer.currentVertexBuffer = null;
renderer.currentIndexBuffer = null;
renderer.setBlendMode(0, true);
renderer.resetTextures();
2020-09-09 12:04:45 +00:00
this.current = pipeline;
2020-09-09 10:38:45 +00:00
pipeline.bind(true);
pipeline.onBind();
},
/**
* Flushes the current pipeline being used and then clears it, along with the
* the current shader program and vertex buffer from the `WebGLRenderer`.
*
* Then resets the blend mode to NORMAL.
*
* Call this before jumping to your own gl context handler, and then call `rebind` when
* you wish to return control to Phaser again.
*
* @method Phaser.Renderer.WebGL.PipelineManager#clear
* @since 3.50.0
*/
2020-09-09 12:04:45 +00:00
clear: function ()
2020-09-09 10:38:45 +00:00
{
var renderer = this.renderer;
this.flush();
2020-09-09 12:04:45 +00:00
this.previous = this.current;
this.current = null;
2020-09-09 10:38:45 +00:00
renderer.currentProgram = null;
renderer.currentVertexBuffer = null;
renderer.currentIndexBuffer = null;
renderer.setBlendMode(0, true);
},
/**
* Destroy the Pipeline Manager, cleaning up all related resources and references.
*
* @method Phaser.Renderer.WebGL.PipelineManager#destroy
* @since 3.50.0
*/
destroy: function ()
{
this.flush();
this.pipelines.clear();
this.renderer = null;
this.game = null;
this.pipelines = null;
2020-09-09 12:04:45 +00:00
this.current = null;
this.previous = null;
2020-09-09 10:38:45 +00:00
}
});
module.exports = PipelineManager;