Press n or j to go to the next uncovered block, b, p or k for the previous block.
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 | 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x 1x 392x 1x 392x | /**
* Even when the EXT_texture_norm16 extension is present, linear filtering
* might not be supported for normalized fixed point textures.
*
* This is a driver bug. See https://github.com/KhronosGroup/WebGL/issues/3706
* @return {boolean}
*/
function supportsNorm16Linear() {
try {
const canvasSize = 4;
const texWidth = 2;
const texHeight = 1;
const texData = new Int16Array([0, 2 ** 15 - 1]);
const pixelToCheck = [1, 1];
const canvas = document.createElement('canvas');
canvas.width = canvasSize;
canvas.height = canvasSize;
const gl = canvas.getContext('webgl2');
Iif (!gl) {
return false;
}
const ext = gl.getExtension('EXT_texture_norm16');
if (!ext) {
return false;
}
const vs = `#version 300 es
void main() {
gl_PointSize = ${canvasSize.toFixed(1)};
gl_Position = vec4(0, 0, 0, 1);
}
`;
const fs = `#version 300 es
precision highp float;
precision highp int;
precision highp sampler2D;
uniform sampler2D u_image;
out vec4 color;
void main() {
vec4 intColor = texture(u_image, gl_PointCoord.xy);
color = vec4(vec3(intColor.rrr), 1);
}
`;
const vertexShader = gl.createShader(gl.VERTEX_SHADER);
gl.shaderSource(vertexShader, vs);
gl.compileShader(vertexShader);
if (!gl.getShaderParameter(vertexShader, gl.COMPILE_STATUS)) {
return false;
}
const fragmentShader = gl.createShader(gl.FRAGMENT_SHADER);
gl.shaderSource(fragmentShader, fs);
gl.compileShader(fragmentShader);
if (!gl.getShaderParameter(fragmentShader, gl.COMPILE_STATUS)) {
return false;
}
const program = gl.createProgram();
gl.attachShader(program, vertexShader);
gl.attachShader(program, fragmentShader);
gl.linkProgram(program);
if (!gl.getProgramParameter(program, gl.LINK_STATUS)) {
return false;
}
const tex = gl.createTexture();
gl.bindTexture(gl.TEXTURE_2D, tex);
gl.texImage2D(
gl.TEXTURE_2D,
0,
ext.R16_SNORM_EXT,
texWidth,
texHeight,
0,
gl.RED,
gl.SHORT,
texData
);
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
gl.useProgram(program);
gl.drawArrays(gl.POINTS, 0, 1);
const pixel = new Uint8Array(4);
gl.readPixels(
pixelToCheck[0],
pixelToCheck[1],
1,
1,
gl.RGBA,
gl.UNSIGNED_BYTE,
pixel
);
const [r, g, b] = pixel;
const webglLoseContext = gl.getExtension('WEBGL_lose_context');
if (webglLoseContext) {
webglLoseContext.loseContext();
}
return r === g && g === b && r !== 0;
} catch (e) {
return false;
}
}
/**
* @type {boolean | undefined}
*/
let supportsNorm16LinearCache;
function supportsNorm16LinearCached() {
// Only create a canvas+texture+shaders the first time
if (supportsNorm16LinearCache === undefined) {
supportsNorm16LinearCache = supportsNorm16Linear();
}
return supportsNorm16LinearCache;
}
export default supportsNorm16LinearCached;
|