tor-browser

tex-image-and-sub-image-utils.js (31237B)

---

/*
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
 };

}());