phaser/src/renderer/webgl/WebGLPipeline.js

687 lines
20 KiB
JavaScript
Raw Normal View History

2018-02-12 16:01:20 +00:00
/**
* @author Richard Davey <rich@photonstorm.com>
2018-04-05 08:02:36 +00:00
* @author Felipe Alfonso <@bitnenfer>
2018-02-12 16:01:20 +00:00
* @copyright 2018 Photon Storm Ltd.
* @license {@link https://github.com/photonstorm/phaser/blob/master/license.txt|MIT License}
*/
2018-01-10 20:03:01 +00:00
var Class = require('../../utils/Class');
2018-01-22 22:51:15 +00:00
var Utils = require('./Utils');
2018-02-09 19:19:21 +00:00
/**
* @classdesc
2018-04-25 22:52:20 +00:00
* WebGLPipeline is a class that describes the way elements will be rendererd
* in WebGL, specially focused on batching vertices (batching is not provided).
* Pipelines are mostly used for describing 2D rendering passes but it's
* flexible enough to be used for any type of rendering including 3D.
* Internally WebGLPipeline will handle things like compiling shaders,
* creating vertex buffers, assigning primitive topology and binding
* vertex attributes.
*
* The config properties are:
* - game: Current game instance.
* - renderer: Current WebGL renderer.
* - gl: Current WebGL context.
* - topology: This indicates how the primitives are rendered. The default value is GL_TRIANGLES.
* Here is the full list of rendering primitives (https://developer.mozilla.org/en-US/docs/Web/API/WebGL_API/Constants).
* - vertShader: Source for vertex shader as a string.
* - fragShader: Source for fragment shader as a string.
* - vertexCapacity: The amount of vertices that shall be allocated
* - vertexSize: The size of a single vertex in bytes.
* - vertices: An optional buffer of vertices
* - attributes: An array describing the vertex attributes
*
* The vertex attributes properties are:
* - name : String - Name of the attribute in the vertex shader
* - size : integer - How many components describe the attribute. For ex: vec3 = size of 3, float = size of 1
* - type : GLenum - WebGL type (gl.BYTE, gl.SHORT, gl.UNSIGNED_BYTE, gl.UNSIGNED_SHORT, gl.FLOAT)
* - normalized : boolean - Is the attribute normalized
* - offset : integer - The offset in bytes to the current attribute in the vertex. Equivalent to offsetof(vertex, attrib) in C
* Here you can find more information of how to describe an attribute:
* - https://developer.mozilla.org/en-US/docs/Web/API/WebGLRenderingContext/vertexAttribPointer
2018-02-09 19:19:21 +00:00
*
* @class WebGLPipeline
* @memberOf Phaser.Renderer.WebGL
* @constructor
* @since 3.0.0
*
* @param {object} config - [description]
*/
2018-01-17 21:25:43 +00:00
var WebGLPipeline = new Class({
2018-02-09 19:19:21 +00:00
initialize:
2018-01-10 20:03:01 +00:00
2018-02-09 19:19:21 +00:00
function WebGLPipeline (config)
2018-01-10 20:03:01 +00:00
{
2018-02-09 19:19:21 +00:00
/**
2018-04-25 22:52:20 +00:00
* Name of the Pipeline. Used for identifying
2018-02-09 19:19:21 +00:00
*
* @name Phaser.Renderer.WebGL.WebGLPipeline#name
* @type {string}
* @since 3.0.0
*/
2018-01-30 22:46:43 +00:00
this.name = 'WebGLPipeline';
2018-02-09 19:19:21 +00:00
/**
* [description]
*
* @name Phaser.Renderer.WebGL.WebGLPipeline#game
* @type {Phaser.Game}
* @since 3.0.0
*/
2018-01-10 20:03:01 +00:00
this.game = config.game;
2018-02-09 19:19:21 +00:00
/**
* [description]
*
* @name Phaser.Renderer.WebGL.WebGLPipeline#view
* @type {HTMLCanvasElement}
* @since 3.0.0
*/
2018-01-10 20:03:01 +00:00
this.view = config.game.canvas;
2018-02-09 19:19:21 +00:00
/**
2018-04-25 22:52:20 +00:00
* Used to store the current game resolution
2018-02-09 19:19:21 +00:00
*
* @name Phaser.Renderer.WebGL.WebGLPipeline#resolution
* @type {number}
* @since 3.0.0
*/
2018-01-10 20:03:01 +00:00
this.resolution = config.game.config.resolution;
2018-02-09 19:19:21 +00:00
/**
2018-04-25 22:52:20 +00:00
* Width of the current viewport
2018-02-09 19:19:21 +00:00
*
* @name Phaser.Renderer.WebGL.WebGLPipeline#width
* @type {number}
* @since 3.0.0
*/
2018-01-10 20:03:01 +00:00
this.width = config.game.config.width * this.resolution;
2018-02-09 19:19:21 +00:00
/**
2018-04-25 22:52:20 +00:00
* Height of the current viewport
2018-02-09 19:19:21 +00:00
*
* @name Phaser.Renderer.WebGL.WebGLPipeline#height
* @type {number}
* @since 3.0.0
*/
2018-01-10 20:03:01 +00:00
this.height = config.game.config.height * this.resolution;
2018-02-09 19:19:21 +00:00
/**
* [description]
*
* @name Phaser.Renderer.WebGL.WebGLPipeline#gl
2018-02-13 00:12:17 +00:00
* @type {WebGLRenderingContext}
2018-02-09 19:19:21 +00:00
* @since 3.0.0
*/
2018-01-10 20:03:01 +00:00
this.gl = config.gl;
2018-02-09 19:19:21 +00:00
/**
2018-04-25 22:52:20 +00:00
* How many vertices have been fed to the current pipeline.
2018-02-09 19:19:21 +00:00
*
* @name Phaser.Renderer.WebGL.WebGLPipeline#vertexCount
* @type {number}
* @default 0
* @since 3.0.0
*/
2018-01-10 20:03:01 +00:00
this.vertexCount = 0;
2018-02-09 19:19:21 +00:00
/**
2018-04-25 22:52:20 +00:00
* The limit of vertices that the pipeline can hold
2018-02-09 19:19:21 +00:00
*
* @name Phaser.Renderer.WebGL.WebGLPipeline#vertexCapacity
* @type {integer}
* @since 3.0.0
*/
2018-01-10 20:03:01 +00:00
this.vertexCapacity = config.vertexCapacity;
2018-02-09 19:19:21 +00:00
/**
* [description]
*
* @name Phaser.Renderer.WebGL.WebGLPipeline#renderer
* @type {Phaser.Renderer.WebGL.WebGLRenderer}
* @since 3.0.0
*/
2018-01-20 04:05:56 +00:00
this.renderer = config.renderer;
2018-02-09 19:19:21 +00:00
/**
2018-04-25 22:52:20 +00:00
* Raw byte buffer of vertices.
2018-02-09 19:19:21 +00:00
*
* @name Phaser.Renderer.WebGL.WebGLPipeline#vertexData
2018-02-13 00:12:17 +00:00
* @type {ArrayBuffer}
2018-02-09 19:19:21 +00:00
* @since 3.0.0
*/
this.vertexData = (config.vertices ? config.vertices : new ArrayBuffer(config.vertexCapacity * config.vertexSize));
2018-02-09 19:19:21 +00:00
/**
2018-04-25 22:52:20 +00:00
* The handle to a WebGL vertex buffer object.
2018-02-09 19:19:21 +00:00
*
* @name Phaser.Renderer.WebGL.WebGLPipeline#vertexBuffer
2018-02-13 00:12:17 +00:00
* @type {WebGLBuffer}
2018-02-09 19:19:21 +00:00
* @since 3.0.0
*/
this.vertexBuffer = this.renderer.createVertexBuffer((config.vertices ? config.vertices : this.vertexData.byteLength), this.gl.STREAM_DRAW);
2018-02-09 19:19:21 +00:00
/**
2018-04-25 22:52:20 +00:00
* The handle to a WebGL program
2018-02-09 19:19:21 +00:00
*
* @name Phaser.Renderer.WebGL.WebGLPipeline#program
2018-02-13 00:12:17 +00:00
* @type {WebGLProgram}
2018-02-09 19:19:21 +00:00
* @since 3.0.0
*/
2018-01-22 22:51:15 +00:00
this.program = this.renderer.createProgram(config.vertShader, config.fragShader);
2018-02-09 19:19:21 +00:00
/**
2018-04-25 22:52:20 +00:00
* Array of objects that describe the vertex attributes
2018-02-09 19:19:21 +00:00
*
* @name Phaser.Renderer.WebGL.WebGLPipeline#attributes
2018-02-13 00:12:17 +00:00
* @type {object}
2018-02-09 19:19:21 +00:00
* @since 3.0.0
*/
2018-01-20 04:05:56 +00:00
this.attributes = config.attributes;
2018-02-09 19:19:21 +00:00
/**
2018-04-25 22:52:20 +00:00
* The size in bytes of the vertex
2018-02-09 19:19:21 +00:00
*
* @name Phaser.Renderer.WebGL.WebGLPipeline#vertexSize
2018-02-16 18:07:49 +00:00
* @type {integer}
2018-02-09 19:19:21 +00:00
* @since 3.0.0
*/
2018-01-10 20:03:01 +00:00
this.vertexSize = config.vertexSize;
2018-02-09 19:19:21 +00:00
/**
2018-04-25 22:52:20 +00:00
* The primitive topology which the pipeline will use to submit draw calls
2018-02-09 19:19:21 +00:00
*
* @name Phaser.Renderer.WebGL.WebGLPipeline#topology
2018-02-16 18:07:49 +00:00
* @type {integer}
2018-02-09 19:19:21 +00:00
* @since 3.0.0
*/
2018-01-10 20:03:01 +00:00
this.topology = config.topology;
2018-02-09 19:19:21 +00:00
/**
2018-04-25 22:52:20 +00:00
* Uint8 view to the vertex raw buffer. Used for uploading vertex buffer resources
* to the GPU.
2018-02-09 19:19:21 +00:00
*
* @name Phaser.Renderer.WebGL.WebGLPipeline#bytes
* @type {Uint8Array}
* @since 3.0.0
*/
2018-01-22 21:21:47 +00:00
this.bytes = new Uint8Array(this.vertexData);
2018-02-09 19:19:21 +00:00
/**
* This will store the amount of components of 32 bit length
*
* @name Phaser.Renderer.WebGL.WebGLPipeline#vertexComponentCount
2018-02-16 18:07:49 +00:00
* @type {integer}
2018-02-09 19:19:21 +00:00
* @since 3.0.0
*/
this.vertexComponentCount = Utils.getComponentCount(config.attributes, this.gl);
/**
* Indicates if the current pipeline is flushing the contents to the GPU.
* When the variable is set the flush function will be locked.
*
* @name Phaser.Renderer.WebGL.WebGLPipeline#flushLocked
* @type {boolean}
2018-02-15 14:31:15 +00:00
* @since 3.1.0
*/
this.flushLocked = false;
/**
* Indicates if the current pipeline is active or not for this frame only.
* Reset in the onRender method.
*
* @name Phaser.Renderer.WebGL.WebGLPipeline#active
* @type {boolean}
* @since 3.10.0
*/
this.active = false;
2018-01-10 20:03:01 +00:00
},
2018-07-13 10:13:46 +00:00
/**
* Called when the Game has fully booted and the Renderer has finished setting up.
*
* By this stage all Game level systems are now in place and you can perform any final
* tasks that the pipeline may need that relied on game systems such as the Texture Manager.
*
* @method Phaser.Renderer.WebGL.WebGLPipeline#boot
* @since 3.11.0
*/
boot: function ()
{
},
/**
2018-04-25 22:52:20 +00:00
* Adds a description of vertex attribute to the pipeline
*
* @method Phaser.Renderer.WebGL.WebGLPipeline#addAttribute
* @since 3.2.0
*
2018-04-25 22:52:20 +00:00
* @param {string} name - Name of the vertex attribute
* @param {integer} size - Vertex component size
* @param {integer} type - Type of the attribute
* @param {boolean} normalized - Is the value normalized to a range
* @param {integer} offset - Byte offset to the beginning of the first element in the vertex
*
* @return {Phaser.Renderer.WebGL.WebGLPipeline} [description]
*/
2018-03-05 21:49:08 +00:00
addAttribute: function (name, size, type, normalized, offset)
{
this.attributes.push({
name: name,
size: size,
type: this.renderer.glFormats[type],
normalized: normalized,
offset: offset
});
return this;
},
2018-02-09 19:19:21 +00:00
/**
2018-04-25 22:52:20 +00:00
* Check if the current batch of vertices is full.
2018-02-09 19:19:21 +00:00
*
* @method Phaser.Renderer.WebGL.WebGLPipeline#shouldFlush
* @since 3.0.0
*
* @return {boolean} [description]
*/
2018-01-10 20:03:01 +00:00
shouldFlush: function ()
{
2018-02-09 19:19:21 +00:00
return (this.vertexCount >= this.vertexCapacity);
2018-01-10 20:03:01 +00:00
},
2018-02-09 19:19:21 +00:00
/**
2018-04-25 22:52:20 +00:00
* Resizes the properties used to describe the viewport
2018-02-09 19:19:21 +00:00
*
* @method Phaser.Renderer.WebGL.WebGLPipeline#resize
* @since 3.0.0
*
* @param {number} width - [description]
* @param {number} height - [description]
* @param {number} resolution - [description]
*
* @return {Phaser.Renderer.WebGL.WebGLPipeline} [description]
*/
2018-01-10 20:03:01 +00:00
resize: function (width, height, resolution)
{
2018-01-17 21:25:43 +00:00
this.width = width * resolution;
this.height = height * resolution;
2018-01-10 20:03:01 +00:00
return this;
},
2018-02-09 19:19:21 +00:00
/**
2018-04-25 22:52:20 +00:00
* Binds the pipeline resources, including programs, vertex buffers and binds attributes
2018-02-09 19:19:21 +00:00
*
* @method Phaser.Renderer.WebGL.WebGLPipeline#bind
* @since 3.0.0
*
* @return {Phaser.Renderer.WebGL.WebGLPipeline} [description]
*/
2018-01-30 03:38:31 +00:00
bind: function ()
2018-01-10 20:03:01 +00:00
{
2018-01-20 04:05:56 +00:00
var gl = this.gl;
var vertexBuffer = this.vertexBuffer;
var attributes = this.attributes;
2018-01-30 03:38:31 +00:00
var program = this.program;
2018-01-20 04:05:56 +00:00
var renderer = this.renderer;
var vertexSize = this.vertexSize;
2018-01-10 20:03:01 +00:00
2018-01-20 04:05:56 +00:00
renderer.setProgram(program);
renderer.setVertexBuffer(vertexBuffer);
for (var index = 0; index < attributes.length; ++index)
{
var element = attributes[index];
var location = gl.getAttribLocation(program, element.name);
if (location >= 0)
{
gl.enableVertexAttribArray(location);
gl.vertexAttribPointer(location, element.size, element.type, element.normalized, vertexSize, element.offset);
}
else
{
gl.disableVertexAttribArray(location);
}
}
2018-01-10 20:03:01 +00:00
return this;
},
2018-02-09 19:19:21 +00:00
/**
* [description]
*
* @method Phaser.Renderer.WebGL.WebGLPipeline#onBind
* @since 3.0.0
*
* @return {Phaser.Renderer.WebGL.WebGLPipeline} [description]
*/
2018-01-25 05:26:14 +00:00
onBind: function ()
{
// This is for updating uniform data it's called on each bind attempt.
return this;
},
2018-02-09 19:19:21 +00:00
/**
* [description]
*
* @method Phaser.Renderer.WebGL.WebGLPipeline#onPreRender
* @since 3.0.0
*
* @return {Phaser.Renderer.WebGL.WebGLPipeline} [description]
*/
2018-01-26 23:17:11 +00:00
onPreRender: function ()
{
// called once every frame
return this;
},
2018-02-09 19:19:21 +00:00
/**
* [description]
*
* @method Phaser.Renderer.WebGL.WebGLPipeline#onRender
* @since 3.0.0
*
* @param {Phaser.Scene} scene - [description]
* @param {Phaser.Cameras.Scene2D.Camera} camera - [description]
*
* @return {Phaser.Renderer.WebGL.WebGLPipeline} [description]
*/
2018-02-16 18:44:07 +00:00
onRender: function ()
2018-01-29 21:46:48 +00:00
{
// called for each camera
return this;
},
2018-02-09 19:19:21 +00:00
/**
* [description]
*
* @method Phaser.Renderer.WebGL.WebGLPipeline#onPostRender
* @since 3.0.0
*
* @return {Phaser.Renderer.WebGL.WebGLPipeline} [description]
*/
2018-01-26 23:17:11 +00:00
onPostRender: function ()
{
// called once every frame
return this;
},
2018-02-09 19:19:21 +00:00
/**
2018-04-25 22:52:20 +00:00
* Uploads the vertex data and emits a draw call
* for the current batch of vertices.
2018-02-09 19:19:21 +00:00
*
* @method Phaser.Renderer.WebGL.WebGLPipeline#flush
* @since 3.0.0
*
* @return {Phaser.Renderer.WebGL.WebGLPipeline} [description]
*/
2018-01-10 20:03:01 +00:00
flush: function ()
{
2018-02-16 18:17:51 +00:00
if (this.flushLocked) { return this; }
2018-02-16 18:44:07 +00:00
this.flushLocked = true;
2018-01-10 20:03:01 +00:00
var gl = this.gl;
var vertexCount = this.vertexCount;
var topology = this.topology;
2018-01-22 21:21:47 +00:00
var vertexSize = this.vertexSize;
2018-01-10 20:03:01 +00:00
2018-02-16 18:17:51 +00:00
if (vertexCount === 0)
{
this.flushLocked = false;
return;
}
2018-02-16 18:44:07 +00:00
2018-01-22 21:21:47 +00:00
gl.bufferSubData(gl.ARRAY_BUFFER, 0, this.bytes.subarray(0, vertexCount * vertexSize));
2018-01-10 20:03:01 +00:00
gl.drawArrays(topology, 0, vertexCount);
this.vertexCount = 0;
this.flushLocked = false;
2018-01-10 20:03:01 +00:00
2018-01-17 21:25:43 +00:00
return this;
},
2018-02-09 19:19:21 +00:00
/**
* [description]
*
* @method Phaser.Renderer.WebGL.WebGLPipeline#destroy
* @since 3.0.0
*
* @return {Phaser.Renderer.WebGL.WebGLPipeline} [description]
*/
2018-01-17 21:25:43 +00:00
destroy: function ()
{
2018-01-20 04:05:56 +00:00
var gl = this.gl;
2018-01-17 21:25:43 +00:00
gl.deleteProgram(this.program);
2018-01-20 04:05:56 +00:00
gl.deleteBuffer(this.vertexBuffer);
2018-01-17 21:25:43 +00:00
delete this.program;
delete this.vertexBuffer;
delete this.gl;
2018-01-10 20:03:01 +00:00
return this;
},
/**
2018-04-25 22:52:20 +00:00
* Set a uniform value of the current pipeline program.
*
* @method Phaser.Renderer.WebGL.WebGLPipeline#setFloat1
* @since 3.2.0
*
* @param {string} name - [description]
* @param {number} x - [description]
*
* @return {Phaser.Renderer.WebGL.WebGLPipeline} [description]
*/
setFloat1: function (name, x)
{
this.renderer.setFloat1(this.program, name, x);
2018-08-07 15:26:22 +00:00
return this;
},
/**
2018-04-25 22:52:20 +00:00
* Set a uniform value of the current pipeline program.
*
* @method Phaser.Renderer.WebGL.WebGLPipeline#setFloat2
* @since 3.2.0
*
* @param {string} name - [description]
* @param {number} x - [description]
* @param {number} y - [description]
*
* @return {Phaser.Renderer.WebGL.WebGLPipeline} [description]
*/
setFloat2: function (name, x, y)
{
this.renderer.setFloat2(this.program, name, x, y);
2018-08-07 15:26:22 +00:00
return this;
},
/**
2018-04-25 22:52:20 +00:00
* Set a uniform value of the current pipeline program.
*
* @method Phaser.Renderer.WebGL.WebGLPipeline#setFloat3
* @since 3.2.0
*
* @param {string} name - [description]
* @param {number} x - [description]
* @param {number} y - [description]
* @param {number} z - [description]
*
* @return {Phaser.Renderer.WebGL.WebGLPipeline} [description]
*/
setFloat3: function (name, x, y, z)
{
this.renderer.setFloat3(this.program, name, x, y, z);
2018-08-07 15:26:22 +00:00
return this;
},
/**
2018-04-25 22:52:20 +00:00
* Set a uniform value of the current pipeline program.
*
* @method Phaser.Renderer.WebGL.WebGLPipeline#setFloat4
* @since 3.2.0
*
2018-04-25 22:52:20 +00:00
* @param {string} name - Name of the uniform
* @param {number} x - X component of the uniform
* @param {number} y - Y component of the uniform
* @param {number} z - Z component of the uniform
* @param {number} w - W component of the uniform
*
* @return {Phaser.Renderer.WebGL.WebGLPipeline} [description]
*/
setFloat4: function (name, x, y, z, w)
{
this.renderer.setFloat4(this.program, name, x, y, z, w);
2018-08-07 15:26:22 +00:00
return this;
},
/**
2018-04-25 22:52:20 +00:00
* Set a uniform value of the current pipeline program.
*
* @method Phaser.Renderer.WebGL.WebGLPipeline#setInt1
* @since 3.2.0
*
* @param {string} name - [description]
2018-03-19 13:45:00 +00:00
* @param {integer} x - [description]
*
* @return {Phaser.Renderer.WebGL.WebGLPipeline} [description]
*/
setInt1: function (name, x)
{
this.renderer.setInt1(this.program, name, x);
2018-08-07 15:26:22 +00:00
return this;
},
/**
2018-04-25 22:52:20 +00:00
* Set a uniform value of the current pipeline program.
*
* @method Phaser.Renderer.WebGL.WebGLPipeline#setInt2
* @since 3.2.0
*
* @param {string} name - [description]
2018-03-19 13:45:00 +00:00
* @param {integer} x - [description]
* @param {integer} y - [description]
*
* @return {Phaser.Renderer.WebGL.WebGLPipeline} [description]
*/
setInt2: function (name, x, y)
{
this.renderer.setInt2(this.program, name, x, y);
2018-08-07 15:26:22 +00:00
return this;
},
/**
2018-04-25 22:52:20 +00:00
* Set a uniform value of the current pipeline program.
*
* @method Phaser.Renderer.WebGL.WebGLPipeline#setInt3
* @since 3.2.0
*
* @param {string} name - [description]
2018-03-19 13:45:00 +00:00
* @param {integer} x - [description]
* @param {integer} y - [description]
* @param {integer} z - [description]
*
* @return {Phaser.Renderer.WebGL.WebGLPipeline} [description]
*/
setInt3: function (name, x, y, z)
{
this.renderer.setInt3(this.program, name, x, y, z);
2018-08-07 15:26:22 +00:00
return this;
},
/**
2018-04-25 22:52:20 +00:00
* Set a uniform value of the current pipeline program.
*
* @method Phaser.Renderer.WebGL.WebGLPipeline#setInt4
* @since 3.2.0
*
2018-04-25 22:52:20 +00:00
* @param {string} name - Name of the uniform
* @param {integer} x - X component of the uniform
* @param {integer} y - Y component of the uniform
* @param {integer} z - Z component of the uniform
* @param {integer} w - W component of the uniform
*
* @return {Phaser.Renderer.WebGL.WebGLPipeline} [description]
*/
setInt4: function (name, x, y, z, w)
{
this.renderer.setInt4(this.program, name, x, y, z, w);
2018-08-07 15:26:22 +00:00
return this;
},
/**
2018-04-25 22:52:20 +00:00
* Set a uniform value of the current pipeline program.
* [description]
*
* @method Phaser.Renderer.WebGL.WebGLPipeline#setMatrix2
* @since 3.2.0
*
* @param {string} name - [description]
* @param {boolean} transpose - [description]
* @param {Float32Array} matrix - [description]
*
* @return {Phaser.Renderer.WebGL.WebGLPipeline} [description]
*/
setMatrix2: function (name, transpose, matrix)
{
2018-03-05 21:49:08 +00:00
this.renderer.setMatrix2(this.program, name, transpose, matrix);
2018-08-07 15:26:22 +00:00
return this;
},
/**
2018-04-25 22:52:20 +00:00
* Set a uniform value of the current pipeline program.
* [description]
* [description]
*
* @method Phaser.Renderer.WebGL.WebGLPipeline#setMatrix3
* @since 3.2.0
*
* @param {string} name - [description]
* @param {boolean} transpose - [description]
* @param {Float32Array} matrix - [description]
*
* @return {Phaser.Renderer.WebGL.WebGLPipeline} [description]
*/
setMatrix3: function (name, transpose, matrix)
{
2018-03-05 21:49:08 +00:00
this.renderer.setMatrix3(this.program, name, transpose, matrix);
2018-08-07 15:26:22 +00:00
return this;
},
/**
2018-04-25 22:52:20 +00:00
* Set a uniform value of the current pipeline program.
*
* @method Phaser.Renderer.WebGL.WebGLPipeline#setMatrix4
* @since 3.2.0
*
2018-04-25 22:52:20 +00:00
* @param {string} name - Name of the uniform
* @param {boolean} transpose - Should the matrix be transpose
* @param {Float32Array} matrix - Matrix data
*
* @return {Phaser.Renderer.WebGL.WebGLPipeline} [description]
*/
setMatrix4: function (name, transpose, matrix)
{
2018-03-05 21:49:08 +00:00
this.renderer.setMatrix4(this.program, name, transpose, matrix);
2018-08-07 15:26:22 +00:00
2018-01-10 20:03:01 +00:00
return this;
}
});
2018-01-17 21:25:43 +00:00
module.exports = WebGLPipeline;