phaser/src/renderer/webgl/Utils.js

209 lines
5.9 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>
* @author Matthew Groves <@doormat>
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
*/
/**
* Generate shader source to test maximum ifs.
*
* @private
* @param {number} maxIfs - The number of if statements to generate
*/
function GenerateSrc (maxIfs)
{
var src = '';
for (var i = 0; i < maxIfs; ++i)
{
if (i > 0)
{
src += '\nelse ';
}
if (i < maxIfs - 1)
{
src += 'if(test == ' + i + '.0){}';
}
}
return src;
}
2018-02-12 22:16:18 +00:00
/**
* @namespace Phaser.Renderer.WebGL.Utils
* @since 3.0.0
*/
2018-01-09 21:00:56 +00:00
module.exports = {
2018-02-12 22:16:18 +00:00
/**
2018-04-25 16:17:33 +00:00
* Packs four floats on a range from 0.0 to 1.0 into a single Uint32
2018-02-12 22:16:18 +00:00
*
* @function Phaser.Renderer.WebGL.Utils.getTintFromFloats
* @since 3.0.0
*
* @param {number} r - Red component in a range from 0.0 to 1.0
2018-10-22 11:12:31 +00:00
* @param {number} g - Green component in a range from 0.0 to 1.0
* @param {number} b - Blue component in a range from 0.0 to 1.0
2018-04-25 16:17:33 +00:00
* @param {number} a - Alpha component in a range from 0.0 to 1.0
*
2020-02-04 17:30:27 +00:00
* @return {number} The packed RGBA values as a Uint32.
2018-02-12 22:16:18 +00:00
*/
getTintFromFloats: function (r, g, b, a)
{
var ur = ((r * 255.0)|0) & 0xFF;
var ug = ((g * 255.0)|0) & 0xFF;
var ub = ((b * 255.0)|0) & 0xFF;
var ua = ((a * 255.0)|0) & 0xFF;
2018-01-09 21:00:56 +00:00
2018-01-26 03:55:05 +00:00
return ((ua << 24) | (ur << 16) | (ug << 8) | ub) >>> 0;
},
2018-01-09 21:00:56 +00:00
2018-02-12 22:16:18 +00:00
/**
2018-04-25 16:17:33 +00:00
* Packs a Uint24, representing RGB components, with a Float32, representing
* the alpha component, with a range between 0.0 and 1.0 and return a Uint32
2018-02-12 22:16:18 +00:00
*
* @function Phaser.Renderer.WebGL.Utils.getTintAppendFloatAlpha
* @since 3.0.0
*
2018-04-25 16:17:33 +00:00
* @param {number} rgb - Uint24 representing RGB components
* @param {number} a - Float32 representing Alpha component
*
2018-04-25 16:17:33 +00:00
* @return {number} Packed RGBA as Uint32
2018-02-12 22:16:18 +00:00
*/
getTintAppendFloatAlpha: function (rgb, a)
2018-01-26 03:55:05 +00:00
{
var ua = ((a * 255.0)|0) & 0xFF;
return ((ua << 24) | rgb) >>> 0;
},
2018-02-12 22:16:18 +00:00
/**
2018-04-25 16:17:33 +00:00
* Packs a Uint24, representing RGB components, with a Float32, representing
* the alpha component, with a range between 0.0 and 1.0 and return a
2018-04-25 16:17:33 +00:00
* swizzled Uint32
2018-02-12 22:16:18 +00:00
*
* @function Phaser.Renderer.WebGL.Utils.getTintAppendFloatAlphaAndSwap
* @since 3.0.0
*
2018-04-25 16:17:33 +00:00
* @param {number} rgb - Uint24 representing RGB components
* @param {number} a - Float32 representing Alpha component
*
2018-04-25 16:17:33 +00:00
* @return {number} Packed RGBA as Uint32
2018-02-12 22:16:18 +00:00
*/
2018-01-26 03:55:05 +00:00
getTintAppendFloatAlphaAndSwap: function (rgb, a)
{
var ur = ((rgb >> 16)|0) & 0xff;
var ug = ((rgb >> 8)|0) & 0xff;
var ub = (rgb|0) & 0xff;
var ua = ((a * 255.0)|0) & 0xFF;
return ((ua << 24) | (ub << 16) | (ug << 8) | ur) >>> 0;
2018-01-22 22:51:15 +00:00
},
2018-02-12 22:16:18 +00:00
/**
2018-04-25 16:17:33 +00:00
* Unpacks a Uint24 RGB into an array of floats of ranges of 0.0 and 1.0
2018-02-12 22:16:18 +00:00
*
* @function Phaser.Renderer.WebGL.Utils.getFloatsFromUintRGB
* @since 3.0.0
*
2018-04-25 16:17:33 +00:00
* @param {number} rgb - RGB packed as a Uint24
*
* @return {array} Array of floats representing each component as a float
2018-02-12 22:16:18 +00:00
*/
2018-01-30 22:46:43 +00:00
getFloatsFromUintRGB: function (rgb)
{
var ur = ((rgb >> 16)|0) & 0xff;
var ug = ((rgb >> 8)|0) & 0xff;
var ub = (rgb|0) & 0xff;
return [ ur / 255.0, ug / 255.0, ub / 255.0 ];
},
2018-02-12 22:16:18 +00:00
/**
2018-04-25 16:17:33 +00:00
* Counts how many attributes of 32 bits a vertex has
2018-02-12 22:16:18 +00:00
*
* @function Phaser.Renderer.WebGL.Utils.getComponentCount
* @since 3.0.0
*
* @param {array} attributes - Array of attributes
2018-04-25 16:17:33 +00:00
* @param {WebGLRenderingContext} glContext - WebGLContext used for check types
*
2018-04-25 16:17:33 +00:00
* @return {number} Count of 32 bit attributes in vertex
2018-02-12 22:16:18 +00:00
*/
getComponentCount: function (attributes, glContext)
2018-01-22 22:51:15 +00:00
{
var count = 0;
for (var index = 0; index < attributes.length; ++index)
{
var element = attributes[index];
if (element.type === glContext.FLOAT)
2018-01-22 22:51:15 +00:00
{
count += element.size;
}
else
{
count += 1; // We'll force any other type to be 32 bit. for now
}
}
return count;
},
/**
* Check to see how many texture units the GPU supports, based on the given config value.
* Then tests this against the maximum number of iterations GLSL can support.
*
* @function Phaser.Renderer.WebGL.Utils.checkShaderMax
2020-07-31 12:41:29 +00:00
* @since 3.50.0
*
* @param {WebGLRenderingContext} gl - The WebGLContext used to create the shaders.
* @param {number} maxTextures - The Game Config maxTextures value.
*
* @return {number} The number of texture units that is supported by this browser and GPU.
*/
checkShaderMax: function (gl, maxTextures)
{
if (!maxTextures || maxTextures === -1)
{
maxTextures = gl.getParameter(gl.MAX_TEXTURE_IMAGE_UNITS);
}
var shader = gl.createShader(gl.FRAGMENT_SHADER);
var fragTemplate = [
'precision mediump float;',
'void main(void){',
'float test = 0.1;',
'%forloop%',
'gl_FragColor = vec4(0.0);',
'}'
].join('\n');
// eslint-disable-next-line no-constant-condition
while (true)
{
var fragmentSrc = fragTemplate.replace(/%forloop%/gi, GenerateSrc(maxTextures));
gl.shaderSource(shader, fragmentSrc);
gl.compileShader(shader);
if (!gl.getShaderParameter(shader, gl.COMPILE_STATUS))
{
maxTextures = (maxTextures / 2) | 0;
}
else
{
// valid!
break;
}
}
return maxTextures;
}
2018-01-09 21:00:56 +00:00
2018-02-12 22:16:18 +00:00
};