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.
*/
function generateTest(internalFormat, pixelFormat, pixelType, prologue, resourcePath, defaultContextVersion) {
var wtu = WebGLTestUtils;
var tiu = TexImageUtils;
var gl = null;
var successfullyParsed = false;
var imageData = null;
var blackColor = [0, 0, 0];
var originalPixels = (function() {
// (red|green|blue|cyan)(opaque|transparent)
var ro = [255, 0, 0, 255]; var rt = [255, 0, 0, 0];
var go = [0, 255, 0, 255]; var gt = [0, 255, 0, 0];
var bo = [0, 0, 255, 255]; var bt = [0, 0, 255, 0];
var co = [0, 255, 255, 255]; var ct = [0, 255, 255, 0];
return [ro, rt, go, gt,
ro, rt, go, gt,
bo, bt, co, ct,
bo, bt, co, ct];
})();
function init()
{
description('Verify texImage3D and texSubImage3D code paths taking ImageData (' + internalFormat + '/' + pixelFormat + '/' + pixelType + ')');
// Set the default context version while still allowing the webglVersion URL query string to override it.
wtu.setDefault3DContextVersion(defaultContextVersion);
gl = wtu.create3DContext("example");
if (!prologue(gl)) {
finishTest();
return;
}
gl.clearColor(0,0,0,1);
gl.clearDepth(1);
gl.disable(gl.BLEND);
var canvas2d = document.getElementById("texcanvas");
var context2d = canvas2d.getContext("2d");
imageData = context2d.createImageData(4, 4);
var data = imageData.data;
for (var i = 0; i < originalPixels.length; i++) {
data.set(originalPixels[i], 4 * i);
}
runTest();
}
function runOneIteration(useTexSubImage3D, flipY, premultiplyAlpha, bindingTarget,
depth, sourceSubRectangle, rTexCoord, program)
{
var expected = simulate(flipY, premultiplyAlpha, depth, sourceSubRectangle, rTexCoord);
var sourceSubRectangleString = '';
if (sourceSubRectangle) {
sourceSubRectangleString = ', sourceSubRectangle=' + sourceSubRectangle;
sourceSubRectangleString += ', rTexCoord=' + rTexCoord;
}
debug('');
debug('Testing ' + (useTexSubImage3D ? 'texSubImage3D' : 'texImage3D') +
' with flipY=' + flipY + ', premultiplyAlpha=' + premultiplyAlpha +
', bindingTarget=' + (bindingTarget == gl.TEXTURE_3D ? 'TEXTURE_3D' : 'TEXTURE_2D_ARRAY') +
sourceSubRectangleString);
gl.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT);
// Enable writes to the RGBA channels
gl.colorMask(1, 1, 1, 0);
var texture = gl.createTexture();
// Bind the texture to texture unit 0
gl.bindTexture(bindingTarget, texture);
// Set up texture parameters
gl.texParameteri(bindingTarget, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
gl.texParameteri(bindingTarget, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
gl.texParameteri(bindingTarget, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
gl.texParameteri(bindingTarget, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
gl.texParameteri(bindingTarget, gl.TEXTURE_WRAP_R, gl.CLAMP_TO_EDGE);
// Set up pixel store parameters
gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, flipY);
gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, premultiplyAlpha);
gl.pixelStorei(gl.UNPACK_COLORSPACE_CONVERSION_WEBGL, gl.NONE);
var uploadWidth = imageData.width;
var uploadHeight = imageData.height;
if (sourceSubRectangle) {
gl.pixelStorei(gl.UNPACK_SKIP_PIXELS, sourceSubRectangle[0]);
gl.pixelStorei(gl.UNPACK_SKIP_ROWS, sourceSubRectangle[1]);
uploadWidth = sourceSubRectangle[2];
uploadHeight = sourceSubRectangle[3];
}
// Upload the image into the texture
if (useTexSubImage3D) {
// Initialize the texture to black first
gl.texImage3D(bindingTarget, 0, gl[internalFormat], uploadWidth, uploadHeight, depth, 0,
gl[pixelFormat], gl[pixelType], null);
gl.texSubImage3D(bindingTarget, 0, 0, 0, 0, uploadWidth, uploadHeight, depth,
gl[pixelFormat], gl[pixelType], imageData);
} else {
gl.texImage3D(bindingTarget, 0, gl[internalFormat], uploadWidth, uploadHeight, depth, 0,
gl[pixelFormat], gl[pixelType], imageData);
}
gl.pixelStorei(gl.UNPACK_SKIP_PIXELS, 0);
gl.pixelStorei(gl.UNPACK_SKIP_ROWS, 0);
wtu.glErrorShouldBe(gl, gl.NO_ERROR, "should be no errors from texture upload");
var tl = expected[0][0];
var tr = expected[0][1];
var bl = expected[1][0];
var br = expected[1][1];
var rCoordLocation = gl.getUniformLocation(program, 'uRCoord');
if (!rCoordLocation) {
testFailed("Shader incorrectly set up; couldn't find uRCoord uniform");
return;
}
gl.uniform1f(rCoordLocation, rTexCoord);
// Draw the triangles
wtu.clearAndDrawUnitQuad(gl, [0, 0, 0, 255]);
var width = gl.canvas.width;
var halfWidth = Math.floor(width / 2);
var height = gl.canvas.height;
var halfHeight = Math.floor(height / 2);
var top = 0;
var bottom = height - halfHeight;
var left = 0;
var right = width - halfWidth;
debug("Checking pixel values");
debug("Expecting: " + expected);
var expectedH = expected.length;
var expectedW = expected[0].length;
var texelH = Math.floor(gl.canvas.height / expectedH);
var texelW = Math.floor(gl.canvas.width / expectedW);
// For each entry of the expected[][] array, check the appropriate
// canvas rectangle for correctness.
for (var row = 0; row < expectedH; row++) {
var y = row * texelH;
for (var col = 0; col < expectedW; col++) {
var x = col * texelW;
var val = expected[row][col];
wtu.checkCanvasRect(gl, x, y, texelW, texelH, val, "should be " + val);
}
}
}
function runTest()
{
var program = tiu.setupTexturedQuadWith3D(gl, internalFormat);
runTestOnBindingTarget(gl.TEXTURE_3D, program);
program = tiu.setupTexturedQuadWith2DArray(gl, internalFormat);
runTestOnBindingTarget(gl.TEXTURE_2D_ARRAY, program);
debug("");
wtu.glErrorShouldBe(gl, gl.NO_ERROR, "should be no errors");
finishTest();
}
function simulate(flipY, premultiplyAlpha, depth, sourceSubRectangle, rTexCoord) {
var ro = [255, 0, 0]; var rt = premultiplyAlpha ? [0, 0, 0] : [255, 0, 0];
var go = [0, 255, 0]; var gt = premultiplyAlpha ? [0, 0, 0] : [0, 255, 0];
var bo = [0, 0, 255]; var bt = premultiplyAlpha ? [0, 0, 0] : [0, 0, 255];
var co = [0, 255, 255]; var ct = premultiplyAlpha ? [0, 0, 0] : [0, 255, 255];
var expected = [[ro, rt, go, gt],
[ro, rt, go, gt],
[bo, bt, co, ct],
[bo, bt, co, ct]];
switch (gl[pixelFormat]) {
case gl.RED:
case gl.RED_INTEGER:
for (var row = 0; row < 4; row++) {
for (var col = 0; col < 4; col++) {
expected[row][col][1] = 0; // zero the green channel
}
}
// fall-through
case gl.RG:
case gl.RG_INTEGER:
for (var row = 0; row < 4; row++) {
for (var col = 0; col < 4; col++) {
expected[row][col][2] = 0; // zero the blue channel
}
}
break;
default:
break;
}
if (flipY) {
expected.reverse();
}
if (sourceSubRectangle) {
let expected2 = [];
for (var row = 0; row < sourceSubRectangle[3]; row++) {
expected2[row] = [];
for (var col = 0; col < sourceSubRectangle[2]; col++) {
expected2[row][col] =
expected[sourceSubRectangle[1] + row + rTexCoord * sourceSubRectangle[3]][sourceSubRectangle[0] + col];
}
}
expected = expected2;
}
return expected;
}
function runTestOnBindingTarget(bindingTarget, program) {
var rects = [
undefined,
[0, 0, 2, 2],
[2, 0, 2, 2],
];
var dbg = false; // Set to true for debug output images
if (dbg) {
(function() {
debug("");
debug("Original ImageData (transparent pixels appear black):");
var cvs = document.createElement("canvas");
cvs.width = 4;
cvs.height = 4;
cvs.style.width = "32px";
cvs.style.height = "32px";
cvs.style.imageRendering = "pixelated";
cvs.style.background = "#000";
var ctx = cvs.getContext("2d");
ctx.putImageData(imageData, 0, 0);
var output = document.getElementById("console");
output.appendChild(cvs);
})();
}
for (const sub of [false, true]) {
for (const flipY of [false, true]) {
for (const premul of [false, true]) {
for (let irect = 0; irect < rects.length; irect++) {
var rect = rects[irect];
let depth = rect ? 2 : 1;
for (let rTexCoord = 0; rTexCoord < depth; rTexCoord++) {
// TODO: add tests for UNPACK_IMAGE_HEIGHT.
runOneIteration(sub, flipY, premul, bindingTarget,
depth, rect, rTexCoord, program);
if (dbg) {
debug("Actual:");
var img = document.createElement("img");
img.src = gl.canvas.toDataURL("image/png");
var output = document.getElementById("console");
output.appendChild(img);
}
}
}
}
}
}
}
return init;
}