diff options
Diffstat (limited to '')
| -rw-r--r-- | dom/canvas/test/webgl-conf/checkout/conformance2/textures/misc/tex-unpack-params.html | 591 |
1 files changed, 591 insertions, 0 deletions
diff --git a/dom/canvas/test/webgl-conf/checkout/conformance2/textures/misc/tex-unpack-params.html b/dom/canvas/test/webgl-conf/checkout/conformance2/textures/misc/tex-unpack-params.html new file mode 100644 index 0000000000..2cdfd4bd7d --- /dev/null +++ b/dom/canvas/test/webgl-conf/checkout/conformance2/textures/misc/tex-unpack-params.html @@ -0,0 +1,591 @@ +<!-- +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>WebGL2 texture unpack parameters conformance test.</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> +<canvas id="example" width="4" height="4"></canvas> +<div id="description"></div> +<div id="console"></div> +<script> +"use strict"; + +var wtu = WebGLTestUtils; +var __verbose__ = false; + +// Some drivers (for example, NVIDIA Linux) incorrectly require padding for +// the last row. The below flag is only for testing convenience. Browsers should +// work around the bug. +var __apply_alignment_workaround__ = false; + +function setupArrayBuffer(size, initData) { + var array = new Uint8Array(size); + if (initData) { + for (var ii = 0; ii < size; ++ii) { + array[ii] = ii % 255; + } + } + return array; +} + +function calculatePaddingBytes(bytesPerPixel, alignment, width) { + var padding = 0; + switch (alignment) { + case 1: + case 2: + case 4: + case 8: + padding = (bytesPerPixel * width) % alignment; + if (padding > 0) + padding = alignment - padding; + return padding; + default: + testFailed("should not reach here"); + return; + } +} + +function computeImageSizes2D(width, height, testCase) { + // Assume RGB8/UNSIGNED_BYTE + var bytesPerPixel = 3; + var actualWidth = testCase.rowLength == 0 ? width : testCase.rowLength; + var padding = calculatePaddingBytes(bytesPerPixel, testCase.alignment, actualWidth); + var bytesPerRow = actualWidth * bytesPerPixel + padding; + var bytesLastRow = bytesPerPixel * width; + var size = bytesPerRow * (height - 1) + bytesLastRow; + var skipSize = 0; + if (testCase.skipPixels > 0) + skipSize += bytesPerPixel * testCase.skipPixels; + if (testCase.skipRows > 0) + skipSize += bytesPerRow * testCase.skipRows; + return {size: size, + bytesPerRow: bytesPerRow, + bytesLastRow: bytesLastRow, + padding: padding, + skipSize: skipSize, + totalSize: size + skipSize}; +} + +function computeImageSizes3D(width, height, depth, testCase) { + // Assume RGB8/UNSIGNED_BYTE + var bytesPerPixel = 3; + var actualWidth = testCase.rowLength == 0 ? width : testCase.rowLength; + var actualHeight = testCase.imageHeight == 0 ? height : testCase.imageHeight; + var padding = calculatePaddingBytes(bytesPerPixel, testCase.alignment, actualWidth); + var bytesPerRow = actualWidth * bytesPerPixel + padding; + var bytesLastRow = bytesPerPixel * width; + var bytesPerImage = bytesPerRow * actualHeight; + var bytesLastImage = bytesPerRow * (height - 1) + bytesLastRow; + var size = bytesPerImage * (depth - 1) + bytesLastImage; + var skipSize = 0; + if (testCase.skipPixels > 0) + skipSize += bytesPerPixel * testCase.skipPixels; + if (testCase.skipRows > 0) + skipSize += bytesPerRow * testCase.skipRows; + if (testCase.skipImages > 0) + skipSize += bytesPerImage * testCase.skipImages; + return {size: size, + bytesPerRow: bytesPerRow, + bytesLastRow: bytesLastRow, + bytesPerImage: bytesPerImage, + bytesLastImage: bytesLastImage, + padding: padding, + skipSize: skipSize, + totalSize: size + skipSize}; +} + +function copyData(srcData, srcIndex, dstData, dstIndex, size) { + for (var ii = 0; ii < size; ++ii) + dstData[dstIndex + ii] = srcData[srcIndex + ii]; +} + +function unpackPixels(srcData, width, height, depth, imageSizes) { + var bytesPerPixel = 3; + var unpackedSize = width * height * depth * bytesPerPixel; + var dstData = setupArrayBuffer(unpackedSize, false); + var srcIndex = imageSizes.skipSize; + var dstIndex = 0; + for (var z = 0; z < depth; ++z) { + var srcIndexPerImage = srcIndex; + for (var y = 0; y < height; ++y) { + copyData(srcData, srcIndexPerImage, dstData, dstIndex, width * 3); + srcIndexPerImage += imageSizes.bytesPerRow; + dstIndex += width * 3; + } + if (depth > 1) + srcIndex += imageSizes.bytesPerImage; + } + return dstData; +} + +function getPixelsFromTexture2D(gl, tex, xoffset, yoffset, width, height) { + var fbo = gl.createFramebuffer(); + gl.bindFramebuffer(gl.FRAMEBUFFER, fbo); + gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, tex, 0); + var bytesPerReadbackPixel = 4; + var readbackBuffer = setupArrayBuffer(width * height * bytesPerReadbackPixel, false); + gl.readPixels(xoffset, yoffset, width, height, gl.RGBA, gl.UNSIGNED_BYTE, readbackBuffer); + wtu.glErrorShouldBe(gl, gl.NO_ERROR, "read back texture pixels should succeed"); + var bytesPerPixel = 3; + var buffer = setupArrayBuffer(width * height * bytesPerPixel, false); + var srcIndex = 0; + var dstIndex = 0; + for (var y = 0; y < height; ++y) { + for (var x = 0; x < width; ++x) { + buffer[dstIndex++] = readbackBuffer[srcIndex++]; // R + buffer[dstIndex++] = readbackBuffer[srcIndex++]; // G + buffer[dstIndex++] = readbackBuffer[srcIndex++]; // B + srcIndex++; // A + } + } + gl.bindFramebuffer(gl.FRAMEBUFFER, null); + gl.deleteFramebuffer(fbo); + return buffer; +} + +function getPixelsFromTexture3D(gl, tex, xoffset, yoffset, zoffset, width, height, depth) { + var fbo = gl.createFramebuffer(); + gl.bindFramebuffer(gl.FRAMEBUFFER, fbo); + var bytesPerReadbackPixel = 4; + var readbackBuffer = setupArrayBuffer(width * height * bytesPerReadbackPixel, false); + var bytesPerPixel = 3; + var buffer = setupArrayBuffer(width * height * depth * bytesPerPixel, false); + var dstIndex = 0; + for (var zz = 0; zz < depth; ++zz) { + gl.framebufferTextureLayer(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, tex, 0, zz + zoffset); + gl.readPixels(xoffset, yoffset, width, height, gl.RGBA, gl.UNSIGNED_BYTE, readbackBuffer); + wtu.glErrorShouldBe(gl, gl.NO_ERROR, "read back texture pixels should succeed"); + var srcIndex = 0; + for (var y = 0; y < height; ++y) { + for (var x = 0; x < width; ++x) { + buffer[dstIndex++] = readbackBuffer[srcIndex++]; // R + buffer[dstIndex++] = readbackBuffer[srcIndex++]; // G + buffer[dstIndex++] = readbackBuffer[srcIndex++]; // B + srcIndex++; // A + } + } + } + gl.bindFramebuffer(gl.FRAMEBUFFER, null); + gl.deleteFramebuffer(fbo); + return buffer; +} + +function comparePixels(buffer1, buffer2) { + if (buffer1.length != buffer2.length || buffer1.length % 3 != 0) { + testFailed("compare pixels: invalid buffer size"); + return; + } + var count = 0; + for (var ii = 0; ii < buffer1.length / 3; ++ii) { + if (buffer1[ii * 3] != buffer2[ii * 3] || + buffer1[ii * 3 + 1] != buffer2[ii * 3 + 1] || + buffer1[ii * 3 + 2] != buffer2[ii * 3 + 2]) { + if (__verbose__) { + debug("Pixel " + ii + ": expected (" + + [buffer1[ii * 3], buffer1[ii * 3 + 1], buffer1[ii * 3 + 2]] + "), got (" + + [buffer2[ii * 3], buffer2[ii * 3 + 1], buffer2[ii * 3 + 2]] + ")"); + } + count++; + } + } + if (count > 0) { + testFailed("compare pixels: " + count + " pixels differ"); + } else { + testPassed("compare pixels: as expected"); + } +} + +function runTestIteration2D(gl, testCase, useUnpackBuffer) { + debug(""); + debug("Texture upload from " + (useUnpackBuffer ? "unpack buffer" : "client data") + + " : alignment = " + testCase.alignment + ", rowLength = " + testCase.rowLength + + ", skipPixels = " + testCase.skipPixels + ", skipRows = " + testCase.skipRows); + debug("TexImage2D : size = (" + testCase.width + ", " + testCase.height + ")"); + gl.pixelStorei(gl.UNPACK_ALIGNMENT, testCase.alignment); + gl.pixelStorei(gl.UNPACK_ROW_LENGTH, testCase.rowLength); + gl.pixelStorei(gl.UNPACK_SKIP_PIXELS, testCase.skipPixels); + gl.pixelStorei(gl.UNPACK_SKIP_ROWS, testCase.skipRows); + wtu.glErrorShouldBe(gl, gl.NO_ERROR, "Set up pixel store parameters should succeed"); + + var tex = gl.createTexture(); + gl.bindTexture(gl.TEXTURE_2D, tex); + + var imageSizes = computeImageSizes2D(testCase.width, testCase.height, testCase); + var bufferSize = imageSizes.totalSize; + var buffer = null; + var array; + + // Verify buffer with less than enough size will fail. + if (useUnpackBuffer) { + buffer = gl.createBuffer(); + gl.bindBuffer(gl.PIXEL_UNPACK_BUFFER, buffer); + gl.bufferData(gl.PIXEL_UNPACK_BUFFER, bufferSize - 1, gl.DYNAMIC_DRAW); + gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGB8, testCase.width, testCase.height, 0, + gl.RGB, gl.UNSIGNED_BYTE, 0); + } else { + array = setupArrayBuffer(bufferSize - 1, false); + gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGB8, testCase.width, testCase.height, 0, + gl.RGB, gl.UNSIGNED_BYTE, array); + } + wtu.glErrorShouldBe(gl, gl.INVALID_OPERATION, "buffer too small"); + + if (__apply_alignment_workaround__) + bufferSize += imageSizes.padding; + array = setupArrayBuffer(bufferSize, true); + if (useUnpackBuffer) { + gl.bufferData(gl.PIXEL_UNPACK_BUFFER, array, gl.DYNAMIC_DRAW); + } + gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGB8, testCase.width, testCase.height, 0, + gl.RGB, gl.UNSIGNED_BYTE, useUnpackBuffer ? 0 : array); + if (testCase.validUnpackParams2D) { + wtu.glErrorShouldBe(gl, gl.NO_ERROR, "texImage2D with correct buffer size should succeed"); + } else { + wtu.glErrorShouldBe(gl, gl.INVALID_OPERATION, "invalid unpack params combination"); + if (!useUnpackBuffer) { + gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGB8, testCase.width, testCase.height, 0, + gl.RGB, gl.UNSIGNED_BYTE, null); + wtu.glErrorShouldBe(gl, gl.NO_ERROR, "unpack param constraints do not apply if no data are uploaded."); + } + return; + } + + var buffer1 = unpackPixels(array, testCase.width, testCase.height, 1, imageSizes); + var buffer2 = getPixelsFromTexture2D(gl, tex, 0, 0, testCase.width, testCase.height); + comparePixels(buffer1, buffer2); + + var subWidth = testCase.width - testCase.xoffset; + var subHeight = testCase.height - testCase.yoffset; + debug("TexSubImage2D : offset = (" + testCase.xoffset + ", " + testCase.yoffset + + "), size = (" + subWidth + ", " + subHeight + ")"); + imageSizes = computeImageSizes2D(subWidth, subHeight, testCase); + bufferSize = imageSizes.totalSize; + + if (useUnpackBuffer) { + gl.bufferData(gl.PIXEL_UNPACK_BUFFER, bufferSize - 1, gl.DYNAMIC_DRAW); + gl.texSubImage2D(gl.TEXTURE_2D, 0, testCase.xoffset, testCase.yoffset, + subWidth, subHeight, gl.RGB, gl.UNSIGNED_BYTE, 0); + } else { + array = setupArrayBuffer(bufferSize - 1, false); + gl.texSubImage2D(gl.TEXTURE_2D, 0, testCase.xoffset, testCase.yoffset, + subWidth, subHeight, gl.RGB, gl.UNSIGNED_BYTE, array); + } + wtu.glErrorShouldBe(gl, gl.INVALID_OPERATION, "buffer too small"); + + if (__apply_alignment_workaround__) + bufferSize += imageSizes.padding; + array = setupArrayBuffer(bufferSize, true); + if (useUnpackBuffer) { + gl.bufferData(gl.PIXEL_UNPACK_BUFFER, array, gl.DYNAMIC_DRAW); + } + gl.texSubImage2D(gl.TEXTURE_2D, 0, testCase.xoffset, testCase.yoffset, subWidth, subHeight, + gl.RGB, gl.UNSIGNED_BYTE, useUnpackBuffer ? 0 : array); + if (testCase.validUnpackParamsForSub2D) { + wtu.glErrorShouldBe(gl, gl.NO_ERROR, "texSubImage2D with correct buffer size should succeed"); + } else { + wtu.glErrorShouldBe(gl, gl.INVALID_OPERATION, "invalid unpack params combination"); + return; + } + + var buffer1 = unpackPixels(array, subWidth, subHeight, 1, imageSizes); + var buffer2 = getPixelsFromTexture2D( + gl, tex, testCase.xoffset, testCase.yoffset, subWidth, subHeight); + comparePixels(buffer1, buffer2); + + if (buffer) { + gl.bindBuffer(gl.PIXEL_UNPACK_BUFFER, null); + gl.deleteBuffer(buffer); + } + gl.bindTexture(gl.TEXTURE_2D, null); + gl.deleteTexture(tex); + wtu.glErrorShouldBe(gl, gl.NO_ERROR, "no error"); +} + +function runTestIteration3D(gl, testCase, useUnpackBuffer) { + debug(""); + debug("Texture upload from " + (useUnpackBuffer ? "unpack buffer" : "client data") + + " : alignment = " + testCase.alignment + ", rowLength = " + testCase.rowLength + + ", imageHeight = " + testCase.imageHeight + ", skipPixels = " + testCase.skipPixels + + ", skipRows = " + testCase.skipRows + ", skipImages = " + testCase.skipImages); + debug("TexImage3D : size = (" + testCase.width + ", " + testCase.height + ", " + testCase.depth + ")"); + gl.pixelStorei(gl.UNPACK_ALIGNMENT, testCase.alignment); + gl.pixelStorei(gl.UNPACK_ROW_LENGTH, testCase.rowLength); + gl.pixelStorei(gl.UNPACK_IMAGE_HEIGHT, testCase.imageHeight); + gl.pixelStorei(gl.UNPACK_SKIP_PIXELS, testCase.skipPixels); + gl.pixelStorei(gl.UNPACK_SKIP_ROWS, testCase.skipRows); + gl.pixelStorei(gl.UNPACK_SKIP_IMAGES, testCase.skipImages); + wtu.glErrorShouldBe(gl, gl.NO_ERROR, "Set up pixel store parameters should succeed"); + + var tex = gl.createTexture(); + gl.bindTexture(gl.TEXTURE_3D, tex); + + var imageSizes = computeImageSizes3D(testCase.width, testCase.height, testCase.depth, testCase); + var buffer = null; + var array; + var bufferSize = imageSizes.totalSize; + + // Verify buffer with less than enough size will fail. + if (useUnpackBuffer) { + buffer = gl.createBuffer(); + gl.bindBuffer(gl.PIXEL_UNPACK_BUFFER, buffer); + gl.bufferData(gl.PIXEL_UNPACK_BUFFER, bufferSize - 1, gl.DYNAMIC_DRAW); + gl.texImage3D(gl.TEXTURE_3D, 0, gl.RGB8, testCase.width, testCase.height, testCase.depth, 0, + gl.RGB, gl.UNSIGNED_BYTE, 0); + } else { + array = setupArrayBuffer(bufferSize - 1, false); + gl.texImage3D(gl.TEXTURE_3D, 0, gl.RGB8, testCase.width, testCase.height, testCase.depth, 0, + gl.RGB, gl.UNSIGNED_BYTE, array); + } + wtu.glErrorShouldBe(gl, gl.INVALID_OPERATION, "buffer too small"); + + if (__apply_alignment_workaround__) + bufferSize += imageSizes.padding; + array = setupArrayBuffer(bufferSize, true); + if (useUnpackBuffer) { + gl.bufferData(gl.PIXEL_UNPACK_BUFFER, array, gl.DYNAMIC_DRAW); + } + gl.texImage3D(gl.TEXTURE_3D, 0, gl.RGB8, testCase.width, testCase.height, testCase.depth, 0, + gl.RGB, gl.UNSIGNED_BYTE, useUnpackBuffer ? 0 : array); + if (testCase.validUnpackParams3D) { + wtu.glErrorShouldBe(gl, gl.NO_ERROR, "texImage3D with correct buffer size should succeed"); + } else { + wtu.glErrorShouldBe(gl, gl.INVALID_OPERATION, "invalid unpack params combination"); + if (!useUnpackBuffer) { + gl.texImage3D(gl.TEXTURE_3D, 0, gl.RGB8, testCase.width, testCase.height, testCase.depth, 0, + gl.RGB, gl.UNSIGNED_BYTE, null); + wtu.glErrorShouldBe(gl, gl.NO_ERROR, "unpack param constraints do not apply if no data are uploaded."); + } + return; + } + + var buffer1 = unpackPixels(array, testCase.width, testCase.height, testCase.depth, imageSizes); + var buffer2 = getPixelsFromTexture3D( + gl, tex, 0, 0, 0, testCase.width, testCase.height, testCase.depth); + comparePixels(buffer1, buffer2); + + var subWidth = testCase.width - testCase.xoffset; + var subHeight = testCase.height - testCase.yoffset; + var subDepth = testCase.depth - testCase.zoffset; + debug("TexSubImage3D : offset = (" + testCase.xoffset + ", " + testCase.yoffset + ", " + + testCase.zoffset + "), size = (" + subWidth + ", " + subHeight + ", " + subDepth + ")"); + imageSizes = computeImageSizes3D(subWidth, subHeight, subDepth, testCase); + bufferSize = imageSizes.totalSize; + + if (useUnpackBuffer) { + gl.bufferData(gl.PIXEL_UNPACK_BUFFER, bufferSize - 1, gl.DYNAMIC_DRAW); + gl.texSubImage3D(gl.TEXTURE_3D, 0, testCase.xoffset, testCase.yoffset, testCase.zoffset, + subWidth, subHeight, subDepth, gl.RGB, gl.UNSIGNED_BYTE, 0); + } else { + array = setupArrayBuffer(bufferSize - 1, false); + gl.texSubImage3D(gl.TEXTURE_3D, 0, testCase.xoffset, testCase.yoffset, testCase.zoffset, + subWidth, subHeight, subDepth, gl.RGB, gl.UNSIGNED_BYTE, array); + } + wtu.glErrorShouldBe(gl, gl.INVALID_OPERATION, "buffer too small"); + + if (__apply_alignment_workaround__) + bufferSize += imageSizes.padding; + array = setupArrayBuffer(bufferSize, true); + if (useUnpackBuffer) { + gl.bufferData(gl.PIXEL_UNPACK_BUFFER, array, gl.DYNAMIC_DRAW); + } + gl.texSubImage3D(gl.TEXTURE_3D, 0, testCase.xoffset, testCase.yoffset, testCase.zoffset, + subWidth, subHeight, subDepth, + gl.RGB, gl.UNSIGNED_BYTE, useUnpackBuffer ? 0 : array); + if (testCase.validUnpackParamsForSub3D) { + wtu.glErrorShouldBe(gl, gl.NO_ERROR, "texSubImage3D with correct buffer size should succeed"); + } else { + wtu.glErrorShouldBe(gl, gl.INVALID_OPERATION, "invalid unpack params combination"); + return; + } + + buffer1 = unpackPixels(array, subWidth, subHeight, subDepth, imageSizes); + buffer2 = getPixelsFromTexture3D(gl, tex, testCase.xoffset, testCase.yoffset, testCase.zoffset, + subWidth, subHeight, subDepth); + comparePixels(buffer1, buffer2); + + if (buffer) { + gl.bindBuffer(gl.PIXEL_UNPACK_BUFFER, null); + gl.deleteBuffer(buffer); + } + gl.bindTexture(gl.TEXTURE_3D, null); + gl.deleteTexture(tex); + wtu.glErrorShouldBe(gl, gl.NO_ERROR, "no error"); +} + +function runTests() { + var gl = wtu.create3DContext("example", undefined, 2); + if (!gl) { + testFailed("Fail to get a WebGL context"); + return; + } + + // For 2D cases, depth, zoffset, imageHeight, skipImages are ignored. + var testCases = [ + { width: 5, height: 7, depth: 3, xoffset: 2, yoffset: 3, zoffset: 1, + alignment: 1, rowLength: 0, imageHeight: 0, skipPixels: 0, skipRows: 0, skipImages: 0, + validUnpackParams2D: true, validUnpackParamsForSub2D: true, + validUnpackParams3D: true, validUnpackParamsForSub3D: true }, + { width: 5, height: 7, depth: 4, xoffset: 2, yoffset: 3, zoffset: 1, + alignment: 2, rowLength: 0, imageHeight: 0, skipPixels: 0, skipRows: 0, skipImages: 0, + validUnpackParams2D: true, validUnpackParamsForSub2D: true, + validUnpackParams3D: true, validUnpackParamsForSub3D: true }, + { width: 6, height: 7, depth: 3, xoffset: 2, yoffset: 3, zoffset: 1, + alignment: 4, rowLength: 0, imageHeight: 0, skipPixels: 0, skipRows: 0, skipImages: 0, + validUnpackParams2D: true, validUnpackParamsForSub2D: true, + validUnpackParams3D: true, validUnpackParamsForSub3D: true }, + { width: 5, height: 8, depth: 3, xoffset: 2, yoffset: 3, zoffset: 1, + alignment: 8, rowLength: 0, imageHeight: 0, skipPixels: 0, skipRows: 0, skipImages: 0, + validUnpackParams2D: true, validUnpackParamsForSub2D: true, + validUnpackParams3D: true, validUnpackParamsForSub3D: true }, + + // ROW_LENGTH == width + { width: 10, height: 9, depth: 2, xoffset: 2, yoffset: 3, zoffset: 1, + alignment: 4, rowLength: 10, imageHeight: 0, skipPixels: 0, skipRows: 0, skipImages: 0, + validUnpackParams2D: true, validUnpackParamsForSub2D: true, + validUnpackParams3D: true, validUnpackParamsForSub3D: true }, + + // ROW_LENGTH < width + { width: 5, height: 7, depth: 3, xoffset: 2, yoffset: 3, zoffset: 1, + alignment: 1, rowLength: 4, imageHeight: 0, skipPixels: 0, skipRows: 0, skipImages: 0, + validUnpackParams2D: false, validUnpackParams3D: false }, + { width: 5, height: 7, depth: 3, xoffset: 2, yoffset: 3, zoffset: 1, + alignment: 2, rowLength: 4, imageHeight: 0, skipPixels: 0, skipRows: 0, skipImages: 0, + validUnpackParams2D: false, validUnpackParams3D: false }, + { width: 5, height: 7, depth: 3, xoffset: 2, yoffset: 3, zoffset: 1, + alignment: 4, rowLength: 4, imageHeight: 0, skipPixels: 0, skipRows: 0, skipImages: 0, + validUnpackParams2D: false, validUnpackParams3D: false }, + { width: 5, height: 7, depth: 3, xoffset: 2, yoffset: 3, zoffset: 1, + alignment: 8, rowLength: 4, imageHeight: 0, skipPixels: 0, skipRows: 0, skipImages: 0, + validUnpackParams2D: false, validUnpackParams3D: false }, + + // ROW_LENGTH > width + { width: 5, height: 7, depth: 3, xoffset: 2, yoffset: 3, zoffset: 1, + alignment: 1, rowLength: 6, imageHeight: 0, skipPixels: 0, skipRows: 0, skipImages: 0, + validUnpackParams2D: true, validUnpackParamsForSub2D: true, + validUnpackParams3D: true, validUnpackParamsForSub3D: true }, + { width: 5, height: 7, depth: 3, xoffset: 2, yoffset: 3, zoffset: 1, + alignment: 2, rowLength: 7, imageHeight: 0, skipPixels: 0, skipRows: 0, skipImages: 0, + validUnpackParams2D: true, validUnpackParamsForSub2D: true, + validUnpackParams3D: true, validUnpackParamsForSub3D: true }, + { width: 5, height: 7, depth: 3, xoffset: 2, yoffset: 3, zoffset: 1, + alignment: 4, rowLength: 8, imageHeight: 0, skipPixels: 0, skipRows: 0, skipImages: 0, + validUnpackParams2D: true, validUnpackParamsForSub2D: true, + validUnpackParams3D: true, validUnpackParamsForSub3D: true }, + { width: 5, height: 7, depth: 5, xoffset: 2, yoffset: 3, zoffset: 2, + alignment: 8, rowLength: 9, imageHeight: 0, skipPixels: 0, skipRows: 0, skipImages: 0, + validUnpackParams2D: true, validUnpackParamsForSub2D: true, + validUnpackParams3D: true, validUnpackParamsForSub3D: true }, + + // IMAGE_HEIGHT == height + { width: 6, height: 7, depth: 4, xoffset: 2, yoffset: 3, zoffset: 1, + alignment: 8, rowLength: 0, imageHeight: 7, skipPixels: 0, skipRows: 0, skipImages: 0, + validUnpackParams2D: true, validUnpackParamsForSub2D: true, + validUnpackParams3D: true, validUnpackParamsForSub3D: true }, + + // IMAGE_HEIGHT < height + { width: 5, height: 7, depth: 3, xoffset: 2, yoffset: 3, zoffset: 1, + alignment: 1, rowLength: 0, imageHeight: 6, skipPixels: 0, skipRows: 0, skipImages: 0, + validUnpackParams2D: true, validUnpackParamsForSub2D: true, + validUnpackParams3D: false }, + { width: 5, height: 7, depth: 3, xoffset: 2, yoffset: 3, zoffset: 1, + alignment: 2, rowLength: 0, imageHeight: 6, skipPixels: 0, skipRows: 0, skipImages: 0, + validUnpackParams2D: true, validUnpackParamsForSub2D: true, + validUnpackParams3D: false }, + { width: 5, height: 7, depth: 3, xoffset: 2, yoffset: 3, zoffset: 1, + alignment: 4, rowLength: 0, imageHeight: 6, skipPixels: 0, skipRows: 0, skipImages: 0, + validUnpackParams2D: true, validUnpackParamsForSub2D: true, + validUnpackParams3D: false }, + { width: 5, height: 7, depth: 3, xoffset: 2, yoffset: 3, zoffset: 1, + alignment: 8, rowLength: 0, imageHeight: 6, skipPixels: 0, skipRows: 0, skipImages: 0, + validUnpackParams2D: true, validUnpackParamsForSub2D: true, + validUnpackParams3D: false }, + + // IMAGE_HEIGHT > height + { width: 5, height: 7, depth: 3, xoffset: 2, yoffset: 3, zoffset: 1, + alignment: 1, rowLength: 0, imageHeight: 8, skipPixels: 0, skipRows: 0, skipImages: 0, + validUnpackParams2D: true, validUnpackParamsForSub2D: true, + validUnpackParams3D: true, validUnpackParamsForSub3D: true }, + { width: 6, height: 7, depth: 3, xoffset: 2, yoffset: 2, zoffset: 1, + alignment: 2, rowLength: 0, imageHeight: 9, skipPixels: 0, skipRows: 0, skipImages: 0, + validUnpackParams2D: true, validUnpackParamsForSub2D: true, + validUnpackParams3D: true, validUnpackParamsForSub3D: true }, + { width: 7, height: 7, depth: 3, xoffset: 2, yoffset: 4, zoffset: 1, + alignment: 4, rowLength: 0, imageHeight: 10, skipPixels: 0, skipRows: 0, skipImages: 0, + validUnpackParams2D: true, validUnpackParamsForSub2D: true, + validUnpackParams3D: true, validUnpackParamsForSub3D: true }, + { width: 8, height: 7, depth: 3, xoffset: 2, yoffset: 3, zoffset: 1, + alignment: 8, rowLength: 0, imageHeight: 11, skipPixels: 0, skipRows: 0, skipImages: 0, + validUnpackParams2D: true, validUnpackParamsForSub2D: true, + validUnpackParams3D: true, validUnpackParamsForSub3D: true }, + + // SKIP parameters + { width: 5, height: 7, depth: 3, xoffset: 2, yoffset: 3, zoffset: 1, + alignment: 1, rowLength: 0, imageHeight: 0, skipPixels: 10, skipRows: 0, skipImages: 0, + validUnpackParams2D: false, validUnpackParams3D: false }, + { width: 5, height: 7, depth: 3, xoffset: 2, yoffset: 3, zoffset: 1, + alignment: 2, rowLength: 0, imageHeight: 0, skipPixels: 2, skipRows: 8, skipImages: 0, + validUnpackParams2D: false, validUnpackParams3D: false }, + { width: 5, height: 7, depth: 3, xoffset: 2, yoffset: 3, zoffset: 1, + alignment: 4, rowLength: 0, imageHeight: 0, skipPixels: 3, skipRows: 5, skipImages: 1, + validUnpackParams2D: false, validUnpackParams3D: false }, + { width: 5, height: 7, depth: 3, xoffset: 2, yoffset: 3, zoffset: 1, + alignment: 8, rowLength: 0, imageHeight: 0, skipPixels: 7, skipRows: 0, skipImages: 2, + validUnpackParams2D: false, validUnpackParams3D: false }, + + // all mixed. + { width: 5, height: 7, depth: 3, xoffset: 2, yoffset: 3, zoffset: 1, + alignment: 1, rowLength: 6, imageHeight: 6, skipPixels: 3, skipRows: 5, skipImages: 1, + validUnpackParams2D: false, validUnpackParams3D: false }, + { width: 5, height: 7, depth: 3, xoffset: 2, yoffset: 3, zoffset: 1, + alignment: 2, rowLength: 4, imageHeight: 8, skipPixels: 7, skipRows: 2, skipImages: 2, + validUnpackParams2D: false, validUnpackParams3D: false }, + { width: 5, height: 7, depth: 3, xoffset: 2, yoffset: 3, zoffset: 1, + alignment: 4, rowLength: 10, imageHeight: 2, skipPixels: 0, skipRows: 3, skipImages: 1, + validUnpackParams2D: true, validUnpackParamsForSub2D: true, + validUnpackParams3D: false }, + { width: 1, height: 1, depth: 1, xoffset: 0, yoffset: 0, zoffset: 0, + alignment: 2, rowLength: 3, imageHeight: 2, skipPixels: 3, skipRows: 5, skipImages: 1, + validUnpackParams2D: false, validUnpackParams3D: false }, + { width: 17, height: 6, depth: 4, xoffset: 12, yoffset: 3, zoffset: 2, + alignment: 2, rowLength: 4, imageHeight: 8, skipPixels: 1, skipRows: 4, skipImages: 2, + validUnpackParams2D: false, validUnpackParams3D: false }, + { width: 8, height: 17, depth: 3, xoffset: 2, yoffset: 13, zoffset: 1, + alignment: 4, rowLength: 9, imageHeight: 2, skipPixels: 0, skipRows: 3, skipImages: 1, + validUnpackParams2D: true, validUnpackParamsForSub2D: true, + validUnpackParams3D: false }, + ]; + + // Upload textures from client data + var useUnpackBuffer = false; + for (var ii = 0; ii < testCases.length; ++ii) { + var testCase = testCases[ii]; + runTestIteration2D(gl, testCase, useUnpackBuffer); + runTestIteration3D(gl, testCase, useUnpackBuffer); + } + + // Upload textures from unpack buffer + useUnpackBuffer = true; + for (var ii = 0; ii < testCases.length; ++ii) { + var testCase = testCases[ii]; + runTestIteration2D(gl, testCase, useUnpackBuffer); + runTestIteration3D(gl, testCase, useUnpackBuffer); + } +} + +runTests(); + +debug(""); +var successfullyParsed = true; +</script> +<script src="../../../js/js-test-post.js"></script> +</body> +</html> |