865 lines
30 KiB
JavaScript
865 lines
30 KiB
JavaScript
/*
|
|
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
|
|
};
|
|
|
|
}());
|