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.
-->
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>WebGL 2 Uninitialized GL Resources Tests</title>
<link rel="stylesheet" href="../../resources/js-test-style.css"/>
<script src="../../js/js-test-pre.js"></script>
<script src="../../js/webgl-test-utils.js"></script>
</head>
<body>
<div id="description"></div>
<div id="console"></div>
<canvas id="canvas" width="2" height="2"> </canvas>
<script>
"use strict";
description("Tests to check user code cannot access uninitialized data from GL resources.");
var wtu = WebGLTestUtils;
var gl = wtu.create3DContext("canvas", undefined, 2);
if (!gl)
testFailed("Context created.");
else
testPassed("Context created.");
// This is the maximum size that will end up being allocated with the tests
// currently written as they are. It could need to be increased later.
var scratchBuffer = new ArrayBuffer(1024 * 1024 * 8 * 4);
function zeroArrayBuffer(arr) {
for (var i = 0; i < arr.length; ++i) {
arr[i] = 0;
}
}
function getUint32Array(length) {
var arr = new Uint32Array(scratchBuffer, 0, length);
zeroArrayBuffer(arr);
return arr;
}
function getInt32Array(length) {
var arr = new Int32Array(scratchBuffer, 0, length);
zeroArrayBuffer(arr);
return arr;
}
function getUint8Array(length) {
var arr = new Uint8Array(scratchBuffer, 0, length);
zeroArrayBuffer(arr);
return arr;
}
function getInt8Array(length) {
var arr = new Int8Array(scratchBuffer, 0, length);
zeroArrayBuffer(arr);
return arr;
}
function setupTexture(target, texWidth, texHeight, texDepth) {
var is3d = (target == gl.TEXTURE_3D || target == gl.TEXTURE_2D_ARRAY);
var texture = gl.createTexture();
gl.bindTexture(target, texture);
if (is3d) {
gl.texImage3D(target, 0, gl.RGBA8, texWidth, texHeight, texDepth, 0, gl.RGBA, gl.UNSIGNED_BYTE, null);
} else if (target == gl.TEXTURE_2D) {
gl.texImage2D(target, 0, gl.RGBA8, texWidth, texHeight, 0, gl.RGBA, gl.UNSIGNED_BYTE, null);
} else {
gl.texImage2D(gl.TEXTURE_CUBE_MAP_POSITIVE_X, 0, gl.RGBA8, texWidth, texHeight, 0, gl.RGBA, gl.UNSIGNED_BYTE, null);
gl.texImage2D(gl.TEXTURE_CUBE_MAP_NEGATIVE_X, 0, gl.RGBA8, texWidth, texHeight, 0, gl.RGBA, gl.UNSIGNED_BYTE, null);
gl.texImage2D(gl.TEXTURE_CUBE_MAP_POSITIVE_Y, 0, gl.RGBA8, texWidth, texHeight, 0, gl.RGBA, gl.UNSIGNED_BYTE, null);
gl.texImage2D(gl.TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, gl.RGBA8, texWidth, texHeight, 0, gl.RGBA, gl.UNSIGNED_BYTE, null);
gl.texImage2D(gl.TEXTURE_CUBE_MAP_POSITIVE_Z, 0, gl.RGBA8, texWidth, texHeight, 0, gl.RGBA, gl.UNSIGNED_BYTE, null);
gl.texImage2D(gl.TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, gl.RGBA8, texWidth, texHeight, 0, gl.RGBA, gl.UNSIGNED_BYTE, null);
}
// this can be quite undeterministic so to improve odds of seeing uninitialized data write bits
// into tex then delete texture then re-create one with same characteristics (driver will likely reuse mem)
// with this trick on r59046 WebKit/OSX I get FAIL 100% of the time instead of ~15% of the time.
var badData = getUint8Array(texWidth * texHeight * texDepth * 4);
for (var i = 0; i < badData.length; ++i)
badData[i] = i % 255;
if (is3d) {
gl.texSubImage3D(target, 0, 0, 0, 0, texWidth, texHeight, texDepth, gl.RGBA, gl.UNSIGNED_BYTE, badData);
} else if (target == gl.TEXTURE_2D) {
gl.texSubImage2D(target, 0, 0, 0, texWidth, texHeight, gl.RGBA, gl.UNSIGNED_BYTE, badData);
} else {
gl.texSubImage2D(gl.TEXTURE_CUBE_MAP_POSITIVE_X, 0, 0, 0, texWidth, texHeight, gl.RGBA, gl.UNSIGNED_BYTE, badData);
gl.texSubImage2D(gl.TEXTURE_CUBE_MAP_NEGATIVE_X, 0, 0, 0, texWidth, texHeight, gl.RGBA, gl.UNSIGNED_BYTE, badData);
gl.texSubImage2D(gl.TEXTURE_CUBE_MAP_POSITIVE_Y, 0, 0, 0, texWidth, texHeight, gl.RGBA, gl.UNSIGNED_BYTE, badData);
gl.texSubImage2D(gl.TEXTURE_CUBE_MAP_NEGATIVE_Y, 0, 0, 0, texWidth, texHeight, gl.RGBA, gl.UNSIGNED_BYTE, badData);
gl.texSubImage2D(gl.TEXTURE_CUBE_MAP_POSITIVE_Z, 0, 0, 0, texWidth, texHeight, gl.RGBA, gl.UNSIGNED_BYTE, badData);
gl.texSubImage2D(gl.TEXTURE_CUBE_MAP_NEGATIVE_Z, 0, 0, 0, texWidth, texHeight, gl.RGBA, gl.UNSIGNED_BYTE, badData);
}
gl.finish(); // make sure it has been uploaded
gl.deleteTexture(texture);
gl.finish(); // make sure it has been deleted
var texture = gl.createTexture();
gl.bindTexture(target, texture);
return texture;
}
function checkNonZeroPixels(texture, target, format, type, texWidth, texHeight, level, layer, exceptions) {
var tol = 2;
var is3d = (target == gl.TEXTURE_3D || target == gl.TEXTURE_2D_ARRAY);
switch (target) {
case gl.TEXTURE_CUBE_MAP_POSITIVE_X:
case gl.TEXTURE_CUBE_MAP_NEGATIVE_X:
case gl.TEXTURE_CUBE_MAP_POSITIVE_Y:
case gl.TEXTURE_CUBE_MAP_NEGATIVE_Y:
case gl.TEXTURE_CUBE_MAP_POSITIVE_Z:
case gl.TEXTURE_CUBE_MAP_NEGATIVE_Z:
gl.bindTexture(gl.TEXTURE_CUBE_MAP, null);
break;
default:
gl.bindTexture(target, null);
break;
}
var fb = gl.createFramebuffer();
gl.bindFramebuffer(gl.FRAMEBUFFER, fb);
if (is3d) {
gl.framebufferTextureLayer(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, texture, level, layer);
} else {
gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, target, texture, level);
}
shouldBe("gl.checkFramebufferStatus(gl.FRAMEBUFFER)", "gl.FRAMEBUFFER_COMPLETE");
var data;
switch (type) {
case gl.UNSIGNED_INT:
data = getUint32Array(texWidth * texHeight * 4);
break;
case gl.INT:
data = getInt32Array(texWidth * texHeight * 4);
break;
case gl.UNSIGNED_BYTE:
default:
data = getUint8Array(texWidth * texHeight * 4);
break;
}
gl.readPixels(0, 0, texWidth, texHeight, format, type, data);
var k = 0;
var failed_exceptions = 0;
for (var y = 0; y < texHeight; ++y) {
for (var x = 0; x < texWidth; ++x) {
var index = (y * texWidth + x) * 4;
var is_exception = false;
for (var ii = 0; ii < exceptions.length; ++ii) {
if (exceptions[ii].x == x && exceptions[ii].y == y) {
is_exception = true;
if (Math.abs(data[index] - exceptions[ii].r) > tol ||
Math.abs(data[index + 1] - exceptions[ii].g) > tol ||
Math.abs(data[index + 2] - exceptions[ii].b) > tol ||
Math.abs(data[index + 3] - exceptions[ii].a) > tol) {
failed_exceptions++;
}
}
}
if (is_exception)
continue;
for (var i = 0; i < 4; ++i) {
if (data[index + i] != 0) {
k++;
}
}
}
}
var info = "Level = " + level;
if (is3d)
info += ", layer = " + layer;
info += " : ";
if (k) {
testFailed(info + "found " + k + " non-zero elements");
} else {
testPassed(info + "all data initialized");
}
if (exceptions.length > 0) {
if (failed_exceptions) {
testFailed(info + "found " + failed_exceptions + " elements incorrectly overwritten");
} else {
testPassed(info + "all initialized elements stay untouched");
}
}
}
function testTexImage3D() {
var max_3d_texture_size = Math.min(gl.getParameter(gl.MAX_3D_TEXTURE_SIZE), 1024);
var test_cases = [
// TEXTURE_3D + RGBA8
{
target: "TEXTURE_3D",
internal_format: "RGBA8",
format: gl.RGBA,
type: gl.UNSIGNED_BYTE,
read_type: gl.UNSIGNED_BYTE,
width: 256, // minimum MAX_3D_TEXTURE_SIZE is 256
height: 256,
depth: 8,
exceptions: [ { x: 0, y: 0, r: 108, g: 72, b: 36, a: 9 } ],
},
{
target: "TEXTURE_3D",
internal_format: "RGBA8",
format: gl.RGBA,
type: gl.UNSIGNED_BYTE,
read_type: gl.UNSIGNED_BYTE,
width: 256, // minimum MAX_3D_TEXTURE_SIZE is 256
height: 256,
depth: 8,
exceptions: [],
},
{
target: "TEXTURE_3D",
internal_format: "RGBA8",
format: gl.RGBA,
type: gl.UNSIGNED_BYTE,
read_type: gl.UNSIGNED_BYTE,
width: max_3d_texture_size,
height: max_3d_texture_size,
depth: 4,
exceptions: [ { x: 0, y: 128, r: 108, g: 72, b: 36, a: 9 } ],
},
{
target: "TEXTURE_3D",
internal_format: "RGBA8",
format: gl.RGBA,
type: gl.UNSIGNED_BYTE,
read_type: gl.UNSIGNED_BYTE,
width: max_3d_texture_size,
height: max_3d_texture_size,
depth: 4,
exceptions: [],
},
// TEXTURE_3D + RGBA8UI
{
target: "TEXTURE_3D",
internal_format: "RGBA8UI",
format: gl.RGBA_INTEGER,
type: gl.UNSIGNED_BYTE,
read_type: gl.UNSIGNED_INT,
width: 256, // minimum MAX_3D_TEXTURE_SIZE is 256
height: 256,
depth: 8,
exceptions: [ { x: 0, y: 255, r: 108, g: 72, b: 36, a: 9 } ],
},
{
target: "TEXTURE_3D",
internal_format: "RGBA8UI",
format: gl.RGBA_INTEGER,
type: gl.UNSIGNED_BYTE,
read_type: gl.UNSIGNED_INT,
width: 256, // minimum MAX_3D_TEXTURE_SIZE is 256
height: 256,
depth: 8,
exceptions: [],
},
{
target: "TEXTURE_3D",
internal_format: "RGBA8UI",
format: gl.RGBA_INTEGER,
type: gl.UNSIGNED_BYTE,
read_type: gl.UNSIGNED_INT,
width: max_3d_texture_size,
height: max_3d_texture_size,
depth: 4,
exceptions: [ { x: 128, y: 0, r: 108, g: 72, b: 36, a: 9 } ],
},
{
target: "TEXTURE_3D",
internal_format: "RGBA8UI",
format: gl.RGBA_INTEGER,
type: gl.UNSIGNED_BYTE,
read_type: gl.UNSIGNED_INT,
width: max_3d_texture_size,
height: max_3d_texture_size,
depth: 4,
exceptions: [],
},
// TEXTURE_3D + RGBA8I
{
target: "TEXTURE_3D",
internal_format: "RGBA8I",
format: gl.RGBA_INTEGER,
type: gl.BYTE,
read_type: gl.INT,
width: 256, // minimum MAX_3D_TEXTURE_SIZE is 256
height: 256,
depth: 8,
exceptions: [ { x: 128, y: 255, r: 108, g: 72, b: 36, a: 9 } ],
},
{
target: "TEXTURE_3D",
internal_format: "RGBA8I",
format: gl.RGBA_INTEGER,
type: gl.BYTE,
read_type: gl.INT,
width: 256, // minimum MAX_3D_TEXTURE_SIZE is 256
height: 256,
depth: 8,
exceptions: [],
},
{
target: "TEXTURE_3D",
internal_format: "RGBA8I",
format: gl.RGBA_INTEGER,
type: gl.BYTE,
read_type: gl.INT,
width: max_3d_texture_size,
height: max_3d_texture_size,
depth: 4,
exceptions: [ { x: 128, y: 128, r: 108, g: 72, b: 36, a: 9 } ],
},
{
target: "TEXTURE_3D",
internal_format: "RGBA8I",
format: gl.RGBA_INTEGER,
type: gl.BYTE,
read_type: gl.INT,
width: max_3d_texture_size,
height: max_3d_texture_size,
depth: 4,
exceptions: [],
},
// TEXTURE_2D_ARRAY + RGBA8
{
target: "TEXTURE_2D_ARRAY",
internal_format: "RGBA8",
format: gl.RGBA,
type: gl.UNSIGNED_BYTE,
read_type: gl.UNSIGNED_BYTE,
width: 1024,
height: 1024,
depth: 8,
exceptions: [ { x: 1023, y: 0, r: 108, g: 72, b: 36, a: 9 } ],
},
{
target: "TEXTURE_2D_ARRAY",
internal_format: "RGBA8",
format: gl.RGBA,
type: gl.UNSIGNED_BYTE,
read_type: gl.UNSIGNED_BYTE,
width: 1024,
height: 1024,
depth: 8,
exceptions: [],
},
{
target: "TEXTURE_2D_ARRAY",
internal_format: "RGBA8",
format: gl.RGBA,
type: gl.UNSIGNED_BYTE,
read_type: gl.UNSIGNED_BYTE,
width: 64,
height: 64,
depth: 256, // minimum MAX_ARRAY_TEXTURE_LAYERS is 256
exceptions: [ { x: 63, y: 32, r: 108, g: 72, b: 36, a: 9 } ],
},
{
target: "TEXTURE_2D_ARRAY",
internal_format: "RGBA8",
format: gl.RGBA,
type: gl.UNSIGNED_BYTE,
read_type: gl.UNSIGNED_BYTE,
width: 64,
height: 64,
depth: 256, // minimum MAX_ARRAY_TEXTURE_LAYERS is 256
exceptions: [],
},
// TEXTURE_2D_ARRAY + RGBA8UI
{
target: "TEXTURE_2D_ARRAY",
internal_format: "RGBA8UI",
format: gl.RGBA_INTEGER,
type: gl.UNSIGNED_BYTE,
read_type: gl.UNSIGNED_INT,
width: 1024,
height: 1024,
depth: 8,
exceptions: [ { x: 1023, y: 1023, r: 108, g: 72, b: 36, a: 9 } ],
},
{
target: "TEXTURE_2D_ARRAY",
internal_format: "RGBA8UI",
format: gl.RGBA_INTEGER,
type: gl.UNSIGNED_BYTE,
read_type: gl.UNSIGNED_INT,
width: 1024,
height: 1024,
depth: 8,
exceptions: [],
},
{
target: "TEXTURE_2D_ARRAY",
internal_format: "RGBA8UI",
format: gl.RGBA_INTEGER,
type: gl.UNSIGNED_BYTE,
read_type: gl.UNSIGNED_INT,
width: 64,
height: 64,
depth: 256, // minimum MAX_ARRAY_TEXTURE_LAYERS is 256
exceptions: [ { x: 0, y: 0, r: 108, g: 72, b: 36, a: 9 } ],
},
{
target: "TEXTURE_2D_ARRAY",
internal_format: "RGBA8UI",
format: gl.RGBA_INTEGER,
type: gl.UNSIGNED_BYTE,
read_type: gl.UNSIGNED_INT,
width: 64,
height: 64,
depth: 256, // minimum MAX_ARRAY_TEXTURE_LAYERS is 256
exceptions: [],
},
// TEXTURE_2D_ARRAY + RGBA8I
{
target: "TEXTURE_2D_ARRAY",
internal_format: "RGBA8I",
format: gl.RGBA_INTEGER,
type: gl.BYTE,
read_type: gl.INT,
width: 1024,
height: 1024,
depth: 8,
exceptions: [ { x: 512, y: 1023, r: 108, g: 72, b: 36, a: 9 } ],
},
{
target: "TEXTURE_2D_ARRAY",
internal_format: "RGBA8I",
format: gl.RGBA_INTEGER,
type: gl.BYTE,
read_type: gl.INT,
width: 1024,
height: 1024,
depth: 8,
exceptions: [],
},
{
target: "TEXTURE_2D_ARRAY",
internal_format: "RGBA8I",
format: gl.RGBA_INTEGER,
type: gl.BYTE,
read_type: gl.INT,
width: 64,
height: 64,
depth: 256, // minimum MAX_ARRAY_TEXTURE_LAYERS is 256
exceptions: [ { x: 63, y: 32, r: 108, g: 72, b: 36, a: 9 } ],
},
{
target: "TEXTURE_2D_ARRAY",
internal_format: "RGBA8I",
format: gl.RGBA_INTEGER,
type: gl.BYTE,
read_type: gl.INT,
width: 64,
height: 64,
depth: 256, // minimum MAX_ARRAY_TEXTURE_LAYERS is 256
exceptions: [],
},
// If more tests are added here, make sure to increase the size of
// scratchBuffer above, if needed.
];
for (var ii = 0; ii < test_cases.length; ++ii) {
debug("");
var test = test_cases[ii];
debug("TexImage3D with target = " + test.target + ", internal_format = " + test.internal_format +
", width = " + test.width + ", height = " + test.height + ", depth = " + test.depth);
var tex = setupTexture(gl[test.target], test.width, test.height, test.depth);
gl.texImage3D(gl[test.target], 0, gl[test.internal_format], test.width, test.height, test.depth, 0, test.format, test.type, null);
for (var jj = 0; jj < test.exceptions.length; ++jj) {
var exception = test.exceptions[jj];
var data;
switch (test.type) {
case gl.BYTE:
data = getInt8Array(4 * test.depth);
break;
case gl.UNSIGNED_BYTE:
data = getUint8Array(4 * test.depth);
break;
default:
assert(false);
}
for (var pixel = 0; pixel < test.depth; ++pixel) {
data[pixel * 4] = exception.r;
data[pixel * 4 + 1] = exception.g;
data[pixel * 4 + 2] = exception.b;
data[pixel * 4 + 3] = exception.a;
}
gl.texSubImage3D(gl[test.target], 0, exception.x, exception.y, 0, 1, 1, test.depth, test.format, test.type, data);
}
for (var layer = 0; layer < test.depth; ++layer)
checkNonZeroPixels(tex, gl[test.target], test.format, test.read_type, test.width, test.height, 0, layer, test.exceptions);
gl.deleteTexture(tex);
gl.finish();
wtu.glErrorShouldBe(gl, gl.NO_ERROR);
}
}
function testTexStorage2D() {
var targets = [ "TEXTURE_2D", "TEXTURE_CUBE_MAP" ];
var width = 512;
var height = 512;
var levels = 5;
for (var ii = 0; ii < targets.length; ++ii) {
debug("");
debug("Reading an uninitialized texture (texStorage2D) should succeed with all bytes set to 0 : target = " + targets[ii]);
var tex = setupTexture(gl[targets[ii]], width, height, 1);
gl.texStorage2D(gl[targets[ii]], levels, gl.RGBA8, width, height);
for (var level = 0; level < levels; ++level) {
if (gl[targets[ii]] == gl.TEXTURE_2D) {
checkNonZeroPixels(tex, gl[targets[ii]], gl.RGBA, gl.UNSIGNED_BYTE, width, height, level, 0, []);
} else {
checkNonZeroPixels(tex, gl.TEXTURE_CUBE_MAP_POSITIVE_X, gl.RGBA, gl.UNSIGNED_BYTE, width, height, level, 0, []);
checkNonZeroPixels(tex, gl.TEXTURE_CUBE_MAP_NEGATIVE_X, gl.RGBA, gl.UNSIGNED_BYTE, width, height, level, 0, []);
checkNonZeroPixels(tex, gl.TEXTURE_CUBE_MAP_POSITIVE_Y, gl.RGBA, gl.UNSIGNED_BYTE, width, height, level, 0, []);
checkNonZeroPixels(tex, gl.TEXTURE_CUBE_MAP_NEGATIVE_Y, gl.RGBA, gl.UNSIGNED_BYTE, width, height, level, 0, []);
checkNonZeroPixels(tex, gl.TEXTURE_CUBE_MAP_POSITIVE_Z, gl.RGBA, gl.UNSIGNED_BYTE, width, height, level, 0, []);
checkNonZeroPixels(tex, gl.TEXTURE_CUBE_MAP_NEGATIVE_Z, gl.RGBA, gl.UNSIGNED_BYTE, width, height, level, 0, []);
}
}
gl.deleteTexture(tex);
gl.finish();
wtu.glErrorShouldBe(gl, gl.NO_ERROR);
}
}
function testTexStorage3D() {
var targets = [ "TEXTURE_3D", "TEXTURE_2D_ARRAY" ];
var internal_formats = [ "RGBA8", "RGBA8UI", "RGBA8I" ];
var formats = [ gl.RGBA, gl.RGBA_INTEGER, gl.RGBA_INTEGER ];
var read_types = [ gl.UNSIGNED_BYTE, gl.UNSIGNED_INT, gl.INT ];
var width = 256; // minimum MAX_3D_TEXTURE_SIZE is 256
var height = 256; // minimum MAX_3D_TEXTURE_SIZE is 256
var depth = 8;
var levels = 5;
for (var ii = 0; ii < targets.length; ++ii) {
debug("");
debug("Reading an uninitialized texture (texStorage3D) should succeed with all bytes set to 0 : target = " + targets[ii]);
for (var jj = 0; jj < internal_formats.length; ++jj) {
debug("");
debug("Internal format : " + internal_formats[jj]);
var tex = setupTexture(gl[targets[ii]], width, height, depth);
gl.texStorage3D(gl[targets[ii]], levels, gl[internal_formats[jj]], width, height, depth);
var level_depth = depth;
for (var level = 0; level < levels; ++level) {
for (var layer = 0; layer < level_depth; ++layer) {
checkNonZeroPixels(tex, gl[targets[ii]], formats[jj], read_types[jj], width, height, level, layer, []);
}
if (gl[targets[ii]] == gl.TEXTURE_3D)
level_depth = Math.max(1, level_depth >> 1);
}
gl.deleteTexture(tex);
gl.finish();
wtu.glErrorShouldBe(gl, gl.NO_ERROR);
}
}
}
testTexImage3D();
testTexStorage2D();
testTexStorage3D();
debug("");
var successfullyParsed = true;
</script>
<script src="../../js/js-test-post.js"></script>
</body>
</html>