Source code
Revision control
Copy as Markdown
Other Tools
/*
Copyright (c) 2019 The Khronos Group Inc.
Use of this source code is governed by an MIT-style license that can be
found in the LICENSE.txt file.
*/
var TexImageUtils = (function() {
"use strict";
var wtu = WebGLTestUtils;
/**
* A vertex shader for a single texture.
* @type {string}
*/
var simpleTextureVertexShaderES3 = [
'#version 300 es',
'in vec4 vPosition;',
'in vec2 texCoord0;',
'out vec2 texCoord;',
'void main() {',
' gl_Position = vPosition;',
' texCoord = texCoord0;',
'}'].join('\n');
/**
* A fragment shader for a single unsigned integer texture.
* @type {string}
*/
// Note we always output 1.0 for alpha because if the texture does not contain
// alpha channel, sampling returns 1; for RGBA textures, sampling returns [0,255].
var simpleUintTextureFragmentShaderES3 = [
'#version 300 es',
'precision mediump float;',
'uniform mediump usampler2D tex;',
'in vec2 texCoord;',
'out vec4 fragData;',
'void main() {',
' uvec4 data = texture(tex, texCoord);',
' fragData = vec4(float(data[0])/255.0,',
' float(data[1])/255.0,',
' float(data[2])/255.0,',
' 1.0);',
'}'].join('\n');
/**
* A fragment shader for a single signed integer texture.
* @type {string}
*/
// Note we always output 1.0 for alpha because if the texture does not contain
// alpha channel, sampling returns 1; for RGBA textures, sampling returns [0,255].
var simpleIntTextureFragmentShaderES3 = [
'#version 300 es',
'precision mediump float;',
'uniform mediump isampler2D tex;',
'in vec2 texCoord;',
'out vec4 fragData;',
'void main() {',
' ivec4 data = texture(tex, texCoord);',
' fragData = vec4(float(data[0])/255.0,',
' float(data[1])/255.0,',
' float(data[2])/255.0,',
' 1.0);',
'}'].join('\n');
/**
* A fragment shader for a single cube map unsigned integer texture.
* @type {string}
*/
// Note we always output 1.0 for alpha because if the texture does not contain
// alpha channel, sampling returns 1; for RGBA textures, sampling returns [0,255].
var simpleCubeMapUintTextureFragmentShaderES3 = [
'#version 300 es',
'precision mediump float;',
'uniform mediump usamplerCube tex;',
'uniform highp int face;',
'in vec2 texCoord;',
'out vec4 fragData;',
'void main() {',
// Transform [0, 1] -> [-1, 1]
' vec2 texC2 = (texCoord * 2.) - 1.;',
// Transform 2d tex coord. to each face of TEXTURE_CUBE_MAP coord.
' vec3 texCube = vec3(0., 0., 0.);',
' if (face == 34069) {', // TEXTURE_CUBE_MAP_POSITIVE_X
' texCube = vec3(1., -texC2.y, -texC2.x);',
' } else if (face == 34070) {', // TEXTURE_CUBE_MAP_NEGATIVE_X
' texCube = vec3(-1., -texC2.y, texC2.x);',
' } else if (face == 34071) {', // TEXTURE_CUBE_MAP_POSITIVE_Y
' texCube = vec3(texC2.x, 1., texC2.y);',
' } else if (face == 34072) {', // TEXTURE_CUBE_MAP_NEGATIVE_Y
' texCube = vec3(texC2.x, -1., -texC2.y);',
' } else if (face == 34073) {', // TEXTURE_CUBE_MAP_POSITIVE_Z
' texCube = vec3(texC2.x, -texC2.y, 1.);',
' } else if (face == 34074) {', // TEXTURE_CUBE_MAP_NEGATIVE_Z
' texCube = vec3(-texC2.x, -texC2.y, -1.);',
' }',
' uvec4 data = texture(tex, texCube);',
' fragData = vec4(float(data[0])/255.0,',
' float(data[1])/255.0,',
' float(data[2])/255.0,',
' 1.0);',
'}'].join('\n');
/**
* A fragment shader for a single cube map signed integer texture.
* @type {string}
*/
// Note we always output 1.0 for alpha because if the texture does not contain
// alpha channel, sampling returns 1; for RGBA textures, sampling returns [0,255].
var simpleCubeMapIntTextureFragmentShaderES3 = [
'#version 300 es',
'precision mediump float;',
'uniform mediump isamplerCube tex;',
'uniform highp int face;',
'in vec2 texCoord;',
'out vec4 fragData;',
'void main() {',
// Transform [0, 1] -> [-1, 1]
' vec2 texC2 = (texCoord * 2.) - 1.;',
// Transform 2d tex coord. to each face of TEXTURE_CUBE_MAP coord.
' vec3 texCube = vec3(0., 0., 0.);',
' if (face == 34069) {', // TEXTURE_CUBE_MAP_POSITIVE_X
' texCube = vec3(1., -texC2.y, -texC2.x);',
' } else if (face == 34070) {', // TEXTURE_CUBE_MAP_NEGATIVE_X
' texCube = vec3(-1., -texC2.y, texC2.x);',
' } else if (face == 34071) {', // TEXTURE_CUBE_MAP_POSITIVE_Y
' texCube = vec3(texC2.x, 1., texC2.y);',
' } else if (face == 34072) {', // TEXTURE_CUBE_MAP_NEGATIVE_Y
' texCube = vec3(texC2.x, -1., -texC2.y);',
' } else if (face == 34073) {', // TEXTURE_CUBE_MAP_POSITIVE_Z
' texCube = vec3(texC2.x, -texC2.y, 1.);',
' } else if (face == 34074) {', // TEXTURE_CUBE_MAP_NEGATIVE_Z
' texCube = vec3(-texC2.x, -texC2.y, -1.);',
' }',
' ivec4 data = texture(tex, texCube);',
' fragData = vec4(float(data[0])/255.0,',
' float(data[1])/255.0,',
' float(data[2])/255.0,',
' 1.0);',
'}'].join('\n');
/**
* A fragment shader for a single 3D texture.
* @type {string}
*/
// Note that the tex coordinate r (the uniform uRCoord) is set to 0.0 by default.
var simple3DTextureFragmentShaderES3 = [
'#version 300 es',
'precision mediump float;',
'uniform mediump sampler3D tex;',
'in vec2 texCoord;',
'uniform float uRCoord;',
'out vec4 fragData;',
'void main() {',
' fragData = vec4(texture(tex, vec3(texCoord, uRCoord)).rgb, 1.0);',
'}'].join('\n');
/**
* A fragment shader for a single 3D unsigned integer texture.
* @type {string}
*/
// Note that the tex coordinate r (the uniform uRCoord) is set to 0.0 by default.
// Note we always output 1.0 for alpha because if the texture does not contain
// alpha channel, sampling returns 1; for RGBA textures, sampling returns [0,255].
var simple3DUintTextureFragmentShaderES3 = [
'#version 300 es',
'precision mediump float;',
'uniform mediump usampler3D tex;',
'in vec2 texCoord;',
'uniform float uRCoord;',
'out vec4 fragData;',
'void main() {',
' uvec4 data = texture(tex, vec3(texCoord, uRCoord));',
' fragData = vec4(float(data[0])/255.0,',
' float(data[1])/255.0,',
' float(data[2])/255.0,',
' 1.0);',
'}'].join('\n');
/**
* A fragment shader for a single 3D signed integer texture.
* @type {string}
*/
// Note that the tex coordinate r (the uniform uRCoord) is set to 0.0 by default.
// Note we always output 1.0 for alpha because if the texture does not contain
// alpha channel, sampling returns 1; for RGBA textures, sampling returns [0,255].
var simple3DIntTextureFragmentShaderES3 = [
'#version 300 es',
'precision mediump float;',
'uniform mediump isampler3D tex;',
'in vec2 texCoord;',
'uniform float uRCoord;',
'out vec4 fragData;',
'void main() {',
' ivec4 data = texture(tex, vec3(texCoord, uRCoord));',
' fragData = vec4(float(data[0])/255.0,',
' float(data[1])/255.0,',
' float(data[2])/255.0,',
' 1.0);',
'}'].join('\n');
/**
* A fragment shader for a single 2D_ARRAY texture.
* @type {string}
*/
// Note that the first image in the array (selected by the uniform
// uRCoord) is used by default.
var simple2DArrayTextureFragmentShaderES3 = [
'#version 300 es',
'precision mediump float;',
'uniform mediump sampler2DArray tex;',
'in vec2 texCoord;',
'uniform float uRCoord;',
'out vec4 fragData;',
'void main() {',
' fragData = vec4(texture(tex, vec3(texCoord, uRCoord)).rgb, 1.0);',
'}'].join('\n');
/**
* A fragment shader for a single 2D_ARRAY unsigned integer texture.
* @type {string}
*/
// Note that the first image in the array (selected by the uniform
// uRCoord) is used by default.
// Note we always output 1.0 for alpha because if the texture does not contain
// alpha channel, sampling returns 1; for RGBA textures, sampling returns [0,255].
var simple2DArrayUintTextureFragmentShaderES3 = [
'#version 300 es',
'precision mediump float;',
'uniform mediump usampler2DArray tex;',
'in vec2 texCoord;',
'uniform float uRCoord;',
'out vec4 fragData;',
'void main() {',
' uvec4 data = texture(tex, vec3(texCoord, uRCoord));',
' fragData = vec4(float(data[0])/255.0,',
' float(data[1])/255.0,',
' float(data[2])/255.0,',
' 1.0);',
'}'].join('\n');
/**
* A fragment shader for a single 2D_ARRAY signed integer texture.
* @type {string}
*/
// Note that the first image in the array (selected by the uniform
// uRCoord) is used by default.
// Note we always output 1.0 for alpha because if the texture does not contain
// alpha channel, sampling returns 1; for RGBA textures, sampling returns [0,255].
var simple2DArrayIntTextureFragmentShaderES3 = [
'#version 300 es',
'precision mediump float;',
'uniform mediump isampler2DArray tex;',
'in vec2 texCoord;',
'uniform float uRCoord;',
'out vec4 fragData;',
'void main() {',
' ivec4 data = texture(tex, vec3(texCoord, uRCoord));',
' fragData = vec4(float(data[0])/255.0,',
' float(data[1])/255.0,',
' float(data[2])/255.0,',
' 1.0);',
'}'].join('\n');
/**
* Creates a simple texture vertex shader.
* @param {!WebGLRenderingContext} gl The WebGLRenderingContext to use.
* @return {!WebGLShader}
*/
var setupSimpleTextureVertexShader = function(gl) {
return WebGLTestUtils.loadShader(gl, simpleTextureVertexShaderES3, gl.VERTEX_SHADER);
};
/**
* Creates a simple unsigned integer texture fragment shader.
* Output is scaled by 1/255 to bring the result into normalized float range.
* @param {!WebGLRenderingContext} gl The WebGLRenderingContext to use.
* @return {!WebGLShader}
*/
var setupSimpleUintTextureFragmentShader = function(gl) {
return WebGLTestUtils.loadShader(gl, simpleUintTextureFragmentShaderES3, gl.FRAGMENT_SHADER);
};
/**
* Creates a simple signed integer texture fragment shader.
* Output is scaled by 1/255 to bring the result into normalized float range.
* @param {!WebGLRenderingContext} gl The WebGLRenderingContext to use.
* @return {!WebGLShader}
*/
var setupSimpleIntTextureFragmentShader = function(gl) {
return WebGLTestUtils.loadShader(gl, simpleIntTextureFragmentShaderES3, gl.FRAGMENT_SHADER);
};
/**
* Creates a simple cube map unsigned integer texture fragment shader.
* @param {!WebGLRenderingContext} gl The WebGLRenderingContext to use.
* @return {!WebGLShader}
*/
var setupSimpleCubeMapUintTextureFragmentShader = function(gl) {
return WebGLTestUtils.loadShader(gl, simpleCubeMapUintTextureFragmentShaderES3, gl.FRAGMENT_SHADER);
};
/**
* Creates a simple cube map signed integer texture fragment shader.
* @param {!WebGLRenderingContext} gl The WebGLRenderingContext to use.
* @return {!WebGLShader}
*/
var setupSimpleCubeMapIntTextureFragmentShader = function(gl) {
return WebGLTestUtils.loadShader(gl, simpleCubeMapIntTextureFragmentShaderES3, gl.FRAGMENT_SHADER);
};
/**
* Creates a simple 3D texture fragment shader.
* @param {!WebGLRenderingContext} gl The WebGLRenderingContext to use.
* @return {!WebGLShader}
*/
var setupSimple3DTextureFragmentShader = function(gl) {
return WebGLTestUtils.loadShader(gl, simple3DTextureFragmentShaderES3, gl.FRAGMENT_SHADER);
};
/**
* Creates a simple 3D unsigned integer texture fragment shader.
* @param {!WebGLRenderingContext} gl The WebGLRenderingContext to use.
* @return {!WebGLShader}
*/
var setupSimple3DUintTextureFragmentShader = function(gl) {
return WebGLTestUtils.loadShader(gl, simple3DUintTextureFragmentShaderES3, gl.FRAGMENT_SHADER);
};
/**
* Creates a simple 3D signed integer texture fragment shader.
* @param {!WebGLRenderingContext} gl The WebGLRenderingContext to use.
* @return {!WebGLShader}
*/
var setupSimple3DIntTextureFragmentShader = function(gl) {
return WebGLTestUtils.loadShader(gl, simple3DIntTextureFragmentShaderES3, gl.FRAGMENT_SHADER);
};
/**
* Creates a simple 2D_ARRAY texture fragment shader.
* @param {!WebGLRenderingContext} gl The WebGLRenderingContext to use.
* @return {!WebGLShader}
*/
var setupSimple2DArrayTextureFragmentShader = function(gl) {
return WebGLTestUtils.loadShader(gl, simple2DArrayTextureFragmentShaderES3, gl.FRAGMENT_SHADER);
};
/**
* Creates a simple 2D_ARRAY integer texture fragment shader.
* @param {!WebGLRenderingContext} gl The WebGLRenderingContext to use.
* @return {!WebGLShader}
*/
var setupSimple2DArrayUintTextureFragmentShader = function(gl) {
return WebGLTestUtils.loadShader(gl, simple2DArrayUintTextureFragmentShaderES3, gl.FRAGMENT_SHADER);
};
/**
* Creates a simple unsigned integer texture program.
* @param {!WebGLRenderingContext} gl The WebGLRenderingContext to use.
* @param {number} opt_positionLocation The attrib location for position.
* @param {number} opt_texcoordLocation The attrib location for texture coords.
* @return {WebGLProgram}
*/
var setupSimpleUintTextureProgram = function(gl, opt_positionLocation, opt_texcoordLocation)
{
opt_positionLocation = opt_positionLocation || 0;
opt_texcoordLocation = opt_texcoordLocation || 1;
var vs = setupSimpleTextureVertexShader(gl),
fs = setupSimpleUintTextureFragmentShader(gl);
if (!vs || !fs) {
return null;
}
var program = WebGLTestUtils.setupProgram(
gl,
[vs, fs],
['vPosition', 'texCoord0'],
[opt_positionLocation, opt_texcoordLocation]);
if (!program) {
gl.deleteShader(fs);
gl.deleteShader(vs);
}
gl.useProgram(program);
return program;
};
/**
* Creates a simple signed integer texture program.
* @param {!WebGLRenderingContext} gl The WebGLRenderingContext to use.
* @param {number} opt_positionLocation The attrib location for position.
* @param {number} opt_texcoordLocation The attrib location for texture coords.
* @return {WebGLProgram}
*/
var setupSimpleIntTextureProgram = function(gl, opt_positionLocation, opt_texcoordLocation)
{
opt_positionLocation = opt_positionLocation || 0;
opt_texcoordLocation = opt_texcoordLocation || 1;
var vs = setupSimpleTextureVertexShader(gl),
fs = setupSimpleIntTextureFragmentShader(gl);
if (!vs || !fs) {
return null;
}
var program = WebGLTestUtils.setupProgram(
gl,
[vs, fs],
['vPosition', 'texCoord0'],
[opt_positionLocation, opt_texcoordLocation]);
if (!program) {
gl.deleteShader(fs);
gl.deleteShader(vs);
}
gl.useProgram(program);
return program;
};
/**
* Creates a simple cube map unsigned integer texture program.
* @param {!WebGLRenderingContext} gl The WebGLRenderingContext to use.
* @param {number} opt_positionLocation The attrib location for position.
* @param {number} opt_texcoordLocation The attrib location for texture coords.
* @return {WebGLProgram}
*/
var setupSimpleCubeMapUintTextureProgram = function(gl, opt_positionLocation, opt_texcoordLocation) {
opt_positionLocation = opt_positionLocation || 0;
opt_texcoordLocation = opt_texcoordLocation || 1;
var vs = setupSimpleTextureVertexShader(gl);
var fs = setupSimpleCubeMapUintTextureFragmentShader(gl);
if (!vs || !fs) {
return null;
}
var program = WebGLTestUtils.setupProgram(
gl,
[vs, fs],
['vPosition', 'texCoord0'],
[opt_positionLocation, opt_texcoordLocation]);
if (!program) {
gl.deleteShader(fs);
gl.deleteShader(vs);
}
gl.useProgram(program);
return program;
};
/**
* Creates a simple cube map signed integer texture program.
* @param {!WebGLRenderingContext} gl The WebGLRenderingContext to use.
* @param {number} opt_positionLocation The attrib location for position.
* @param {number} opt_texcoordLocation The attrib location for texture coords.
* @return {WebGLProgram}
*/
var setupSimpleCubeMapIntTextureProgram = function(gl, opt_positionLocation, opt_texcoordLocation) {
opt_positionLocation = opt_positionLocation || 0;
opt_texcoordLocation = opt_texcoordLocation || 1;
var vs = setupSimpleTextureVertexShader(gl);
var fs = setupSimpleCubeMapIntTextureFragmentShader(gl);
if (!vs || !fs) {
return null;
}
var program = WebGLTestUtils.setupProgram(
gl,
[vs, fs],
['vPosition', 'texCoord0'],
[opt_positionLocation, opt_texcoordLocation]);
if (!program) {
gl.deleteShader(fs);
gl.deleteShader(vs);
}
gl.useProgram(program);
return program;
};
/**
* Creates a simple 3D texture program.
* @param {!WebGLRenderingContext} gl The WebGLRenderingContext to use.
* @param {number} opt_positionLocation The attrib location for position.
* @param {number} opt_texcoordLocation The attrib location for texture coords.
* @return {WebGLProgram}
*/
var setupSimple3DTextureProgram = function(gl, opt_positionLocation, opt_texcoordLocation)
{
opt_positionLocation = opt_positionLocation || 0;
opt_texcoordLocation = opt_texcoordLocation || 1;
var vs = setupSimpleTextureVertexShader(gl),
fs = setupSimple3DTextureFragmentShader(gl);
if (!vs || !fs) {
return null;
}
var program = WebGLTestUtils.setupProgram(
gl,
[vs, fs],
['vPosition', 'texCoord0'],
[opt_positionLocation, opt_texcoordLocation]);
if (!program) {
gl.deleteShader(fs);
gl.deleteShader(vs);
}
gl.useProgram(program);
return program;
};
/**
* Creates a simple 3D unsigned integer texture program.
* @param {!WebGLRenderingContext} gl The WebGLRenderingContext to use.
* @param {number} opt_positionLocation The attrib location for position.
* @param {number} opt_texcoordLocation The attrib location for texture coords.
* @return {WebGLProgram}
*/
var setupSimple3DUintTextureProgram = function(gl, opt_positionLocation, opt_texcoordLocation)
{
opt_positionLocation = opt_positionLocation || 0;
opt_texcoordLocation = opt_texcoordLocation || 1;
var vs = setupSimpleTextureVertexShader(gl),
fs = setupSimple3DUintTextureFragmentShader(gl);
if (!vs || !fs) {
return null;
}
var program = WebGLTestUtils.setupProgram(
gl,
[vs, fs],
['vPosition', 'texCoord0'],
[opt_positionLocation, opt_texcoordLocation]);
if (!program) {
gl.deleteShader(fs);
gl.deleteShader(vs);
}
gl.useProgram(program);
return program;
};
/**
* Creates a simple 3D signed integer texture program.
* @param {!WebGLRenderingContext} gl The WebGLRenderingContext to use.
* @param {number} opt_positionLocation The attrib location for position.
* @param {number} opt_texcoordLocation The attrib location for texture coords.
* @return {WebGLProgram}
*/
var setupSimple3DIntTextureProgram = function(gl, opt_positionLocation, opt_texcoordLocation)
{
opt_positionLocation = opt_positionLocation || 0;
opt_texcoordLocation = opt_texcoordLocation || 1;
var vs = setupSimpleTextureVertexShader(gl),
fs = setupSimple3DIntTextureFragmentShader(gl);
if (!vs || !fs) {
return null;
}
var program = WebGLTestUtils.setupProgram(
gl,
[vs, fs],
['vPosition', 'texCoord0'],
[opt_positionLocation, opt_texcoordLocation]);
if (!program) {
gl.deleteShader(fs);
gl.deleteShader(vs);
}
gl.useProgram(program);
return program;
};
/**
* Creates a simple 2D_ARRAY texture program.
* @param {!WebGLRenderingContext} gl The WebGLRenderingContext to use.
* @param {number} opt_positionLocation The attrib location for position.
* @param {number} opt_texcoordLocation The attrib location for texture coords.
* @return {WebGLProgram}
*/
var setupSimple2DArrayTextureProgram = function(gl, opt_positionLocation, opt_texcoordLocation)
{
opt_positionLocation = opt_positionLocation || 0;
opt_texcoordLocation = opt_texcoordLocation || 1;
var vs = setupSimpleTextureVertexShader(gl),
fs = setupSimple2DArrayTextureFragmentShader(gl);
if (!vs || !fs) {
return null;
}
var program = WebGLTestUtils.setupProgram(
gl,
[vs, fs],
['vPosition', 'texCoord0'],
[opt_positionLocation, opt_texcoordLocation]);
if (!program) {
gl.deleteShader(fs);
gl.deleteShader(vs);
}
gl.useProgram(program);
return program;
};
/**
* Creates a simple 2D_ARRAY unsigned integer texture program.
* @param {!WebGLRenderingContext} gl The WebGLRenderingContext to use.
* @param {number} opt_positionLocation The attrib location for position.
* @param {number} opt_texcoordLocation The attrib location for texture coords.
* @return {WebGLProgram}
*/
var setupSimple2DArrayUintTextureProgram = function(gl, opt_positionLocation, opt_texcoordLocation)
{
opt_positionLocation = opt_positionLocation || 0;
opt_texcoordLocation = opt_texcoordLocation || 1;
var vs = setupSimpleTextureVertexShader(gl),
fs = setupSimple2DArrayUintTextureFragmentShader(gl);
if (!vs || !fs) {
return null;
}
var program = WebGLTestUtils.setupProgram(
gl,
[vs, fs],
['vPosition', 'texCoord0'],
[opt_positionLocation, opt_texcoordLocation]);
if (!program) {
gl.deleteShader(fs);
gl.deleteShader(vs);
}
gl.useProgram(program);
return program;
};
/**
* Creates a simple 2D_ARRAY signed integer texture program.
* @param {!WebGLRenderingContext} gl The WebGLRenderingContext to use.
* @param {number} opt_positionLocation The attrib location for position.
* @param {number} opt_texcoordLocation The attrib location for texture coords.
* @return {WebGLProgram}
*/
var setupSimple2DArrayIntTextureProgram = function(gl, opt_positionLocation, opt_texcoordLocation)
{
opt_positionLocation = opt_positionLocation || 0;
opt_texcoordLocation = opt_texcoordLocation || 1;
var vs = setupSimpleTextureVertexShader(gl),
fs = setupSimple2DArrayIntTextureFragmentShader(gl);
if (!vs || !fs) {
return null;
}
var program = WebGLTestUtils.setupProgram(
gl,
[vs, fs],
['vPosition', 'texCoord0'],
[opt_positionLocation, opt_texcoordLocation]);
if (!program) {
gl.deleteShader(fs);
gl.deleteShader(vs);
}
gl.useProgram(program);
return program;
};
/**
* Creates a program and buffers for rendering a unsigned integer textured quad.
* @param {!WebGLRenderingContext} gl The WebGLRenderingContext to use.
* @return {!WebGLProgram}
*/
var setupUintTexturedQuad = function(gl) {
var program = setupSimpleUintTextureProgram(gl);
wtu.setupUnitQuad(gl);
return program;
};
/**
* Creates a program and buffers for rendering a signed integer textured quad.
* @param {!WebGLRenderingContext} gl The WebGLRenderingContext to use.
* @return {!WebGLProgram}
*/
var setupIntTexturedQuad = function(gl) {
var program = setupSimpleIntTextureProgram(gl);
wtu.setupUnitQuad(gl);
return program;
};
/**
* Creates a program and buffers for rendering a textured quad with
* a cube map unsigned integer texture.
* @param {!WebGLRenderingContext} gl The WebGLRenderingContext to use.
* @return {!WebGLProgram}
*/
var setupUintTexturedQuadWithCubeMap = function(gl)
{
var program = setupSimpleCubeMapUintTextureProgram(gl);
wtu.setupUnitQuad(gl);
return program;
};
/**
* Creates a program and buffers for rendering a textured quad with
* a cube map signed integer texture.
* @param {!WebGLRenderingContext} gl The WebGLRenderingContext to use.
* @return {!WebGLProgram}
*/
var setupIntTexturedQuadWithCubeMap = function(gl)
{
var program = setupSimpleCubeMapIntTextureProgram(gl);
wtu.setupUnitQuad(gl);
return program;
};
/**
* Does the GL internal format represent an unsigned integer format
* texture?
* @return {boolean}
*/
var isUintFormat = function(internalFormat)
{
return (internalFormat == "R8UI" || internalFormat == "RG8UI" || internalFormat == "RGB8UI" || internalFormat == "RGBA8UI" ||
internalFormat == "R16UI" || internalFormat == "RG16UI" || internalFormat == "RGB16UI" || internalFormat == "RGBA16UI" ||
internalFormat == "R32UI" || internalFormat == "RG32UI" || internalFormat == "RGB32UI" || internalFormat == "RGBA32UI");
};
/**
* Does the GL internal format represent an signed integer format
* texture?
* @return {boolean}
*/
var isIntFormat = function(internalFormat)
{
return (internalFormat == "R8I" || internalFormat == "RG8I" || internalFormat == "RGB8I" || internalFormat == "RGBA8I" ||
internalFormat == "R16I" || internalFormat == "RG16I" || internalFormat == "RGB16I" || internalFormat == "RGBA16I" ||
internalFormat == "R32I" || internalFormat == "RG32I" || internalFormat == "RGB32I" || internalFormat == "RGBA32I");
};
/**
* Createa a program and buffers for rendering a textured quad for
* tex-image-and-sub-image tests. Handle selection of correct
* program to handle texture format.
* @param {!WebGLRenderingContext} gl The WebGLRenderingContext to use.
* @param {string} internalFormat The internal format for texture to be tested.
*/
var setupTexturedQuad = function(gl, internalFormat)
{
if (isUintFormat(internalFormat))
return setupUintTexturedQuad(gl);
if (isIntFormat(internalFormat))
return setupIntTexturedQuad(gl);
return wtu.setupTexturedQuad(gl);
};
/**
* Createa a program and buffers for rendering a textured quad with
* a cube map for tex-image-and-sub-image tests. Handle selection of
* correct program to handle texture format.
* @param {!WebGLRenderingContext} gl The WebGLRenderingContext to use.
* @param {string} internalFormat The internal format for texture to be tested.
*/
function setupTexturedQuadWithCubeMap(gl, internalFormat)
{
if (isUintFormat(internalFormat))
return setupUintTexturedQuadWithCubeMap(gl);
if (isIntFormat(internalFormat))
return setupIntTexturedQuadWithCubeMap(gl);
return wtu.setupTexturedQuadWithCubeMap(gl);
}
/**
* Createa a program and buffers for rendering a textured quad with a 3D texture
* for tex-image-and-sub-image tests. Handle selection of correct
* program to handle texture format.
* @param {!WebGLRenderingContext} gl The WebGLRenderingContext to use.
* @param {string} internalFormat The internal format for texture to be tested.
*/
var setupTexturedQuadWith3D = function(gl, internalFormat)
{
var program;
if (isUintFormat(internalFormat))
program = setupSimple3DUintTextureProgram(gl);
else if (isIntFormat(internalFormat))
program = setupSimple3DIntTextureProgram(gl);
else
program = setupSimple3DTextureProgram(gl);
var uRCoordLoc = gl.getUniformLocation(program, 'uRCoord');
gl.uniform1f(uRCoordLoc, 0.0);
wtu.setupUnitQuad(gl);
return program;
};
/**
* Createa a program and buffers for rendering a textured quad with a 2D_ARRAY
* texture for tex-image-and-sub-image tests. Handle selection of correct
* program to handle texture format.
* @param {!WebGLRenderingContext} gl The WebGLRenderingContext to use.
* @param {string} internalFormat The internal format for texture to be tested.
*/
var setupTexturedQuadWith2DArray = function(gl, internalFormat)
{
var program;
if (isUintFormat(internalFormat))
program = setupSimple2DArrayUintTextureProgram(gl);
else if (isIntFormat(internalFormat))
program = setupSimple2DArrayIntTextureProgram(gl);
else
program = setupSimple2DArrayTextureProgram(gl);
var uRCoordLoc = gl.getUniformLocation(program, 'uRCoord');
gl.uniform1f(uRCoordLoc, 0.0);
wtu.setupUnitQuad(gl);
return program;
};
/**
* Return a list of unpack color spaces to test, supported by the specified
* WebGLRenderingContext.
*/
var unpackColorSpacesToTest = function(gl)
{
if ('unpackColorSpace' in gl)
return ['srgb', 'display-p3'];
else
return [undefined];
}
/**
* For each entry in unpackColorSpaces, duplicate all of cases, adding an
* unpackColorSpace key with its value set to that entry to each case.
*/
var crossProductTestCasesWithUnpackColorSpaces = function(testCaseList, unpackColorSpaces)
{
var testCaseWithUnpackColorSpace = function(testCase, colorSpace)
{
return {...testCase, ...{unpackColorSpace:colorSpace}};
}
var listOfTestCaseLists = unpackColorSpaces.map(colorSpace =>
testCaseList.map(testCase => testCaseWithUnpackColorSpace(testCase, colorSpace)));
return listOfTestCaseLists.flat();
}
/**
* Given given an internalformat, format, and type, return the tolerance
* that should be used when comparing an input 8-bit value to one that has
* been truncated through the specified formats.
*/
var tolerance = function(internalformat, format, type) {
function typeTolerance(type) {
switch(type) {
case 'UNSIGNED_SHORT_5_6_5':
case 'UNSIGNED_SHORT_5_5_5_1':
return 255 / 31;
case 'UNSIGNED_SHORT_4_4_4_4':
return 255 / 15;
break;
default:
return 1;
}
};
function formatTolerance(format) {
switch(format) {
case 'RGB565':
case 'RGB5_A1':
return 255/31;
case 'RGBA4':
return 255/15;
default:
return 1;
}
};
return Math.max(formatTolerance(internalformat),
formatTolerance(format),
typeTolerance(type));
}
return {
setupTexturedQuad: setupTexturedQuad,
setupTexturedQuadWithCubeMap: setupTexturedQuadWithCubeMap,
setupTexturedQuadWith3D: setupTexturedQuadWith3D,
setupTexturedQuadWith2DArray: setupTexturedQuadWith2DArray,
unpackColorSpacesToTest: unpackColorSpacesToTest,
crossProductTestCasesWithUnpackColorSpaces: crossProductTestCasesWithUnpackColorSpaces,
tolerance: tolerance
};
}());