| <!-- |
| 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 ReadPixels 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> |
| <div id="description"></div> |
| <div id="console"></div> |
| <script> |
| "use strict"; |
| description("Checks that ReadPixels from a fbo works as expected."); |
| |
| var wtu = WebGLTestUtils; |
| var gl = wtu.create3DContext(undefined, undefined, 2); |
| gl.pixelStorei(gl.PACK_ALIGNMENT, 1); |
| |
| function getChannelCount(format) { |
| switch (format) { |
| case gl.RED: |
| case gl.RED_INTEGER: |
| case gl.ALPHA: |
| case gl.LUMINANCE: |
| return 1; |
| case gl.RB: |
| case gl.RB_INTEGER: |
| case gl.LUMINANCE_ALPHA: |
| return 2; |
| case gl.RGB: |
| case gl.RGB_INTEGER: |
| return 3; |
| case gl.RGBA: |
| case gl.RGBA_INTEGER: |
| return 4; |
| default: |
| return 0; |
| } |
| } |
| |
| function getUnpackInfo(type) { |
| switch (type) { |
| case gl.UNSIGNED_SHORT_5_6_5: |
| return {bitsCount: [5, 6, 5], isReverse: false}; |
| case gl.UNSIGNED_SHORT_4_4_4_4: |
| return {bitsCount: [4, 4, 4, 4], isReverse: false}; |
| case gl.UNSIGNED_SHORT_5_5_5_1: |
| return {bitsCount: [5, 5, 5, 1], isReverse: false}; |
| case gl.UNSIGNED_INT_2_10_10_10_REV: |
| return {bitsCount: [2, 10, 10, 10], isReverse: true}; |
| case gl.UNSIGNED_INT_10F_11F_11F_REV: |
| return {bitsCount: [10, 11, 11], isReverse: true}; |
| case gl.UNSIGNED_INT_5_9_9_9_REV: |
| return {bitsCount: [5, 9, 9, 9], isReverse: true}; |
| default: |
| return null; |
| } |
| } |
| |
| // bitsCount is an array contains bit count for each component. |
| function unpack(value, channelCount, bitsCount, isReverse) { |
| var result = new Array(channelCount); |
| |
| var accumBitsCount = 0; |
| for (var i = channelCount - 1; i >= 0; --i) { |
| var currentChannel = isReverse ? (channelCount - i - 1) : i; |
| var mask = 0xFFFFFFFF >>> (32 - bitsCount[i]); |
| result[currentChannel] = ((value >> accumBitsCount) & mask); |
| accumBitsCount += bitsCount[i]; |
| } |
| |
| return result; |
| } |
| |
| function getColor(buf, index, readFormat, readType) { |
| var channelCount = getChannelCount(readFormat); |
| var result = new Array(channelCount); |
| |
| var unpackInfo = getUnpackInfo(readType); |
| if (unpackInfo) { |
| result = unpack(buf[index], channelCount, unpackInfo.bitsCount, unpackInfo.isReverse); |
| } else { |
| for (var i = 0; i < channelCount; ++i) { |
| result[i] = buf[index + i]; |
| } |
| } |
| |
| return result; |
| } |
| |
| function convertToSRGB(val) { |
| if (val <= 0) { |
| return 0; |
| } else if (val < 0.0031308) { |
| return 12.92 * val; |
| } else if (val < 1) { |
| return 1.055 * Math.pow(val, 0.41666) - 0.055; |
| } else { |
| return 1; |
| } |
| } |
| |
| function denormalizeColor(srcInternalFormat, destType, color) { |
| var result = color.slice(); |
| var tol = 0; |
| |
| var srcIsNormalized = false; |
| |
| switch (srcInternalFormat) { |
| case gl.R8: |
| case gl.RG8: |
| case gl.RGB8: |
| case gl.RGBA8: |
| case gl.RGB5_A1: |
| case gl.SRGB8_ALPHA8: |
| case gl.RGB10_A2: |
| srcIsNormalized = true; |
| tol = 6; |
| break; |
| case gl.RGB565: |
| // RGB565 needs slightly extra tolerance, at least on Google Pixel. crbug.com/682753 |
| srcIsNormalized = true; |
| tol = 7; |
| break; |
| case gl.RGBA4: |
| srcIsNormalized = true; |
| tol = 10; |
| break; |
| } |
| |
| if (!srcIsNormalized) { |
| return { color: result, tol: tol }; |
| } |
| |
| if (srcInternalFormat == gl.SRGB8_ALPHA8) { |
| for (var i = 0; i < 3; ++i) { |
| result[i] = convertToSRGB(result[i]); |
| } |
| } |
| |
| switch (destType) { |
| case gl.UNSIGNED_BYTE: |
| result = result.map(val => { return val * 0xFF}); |
| break; |
| case gl.UNSIGNED_SHORT: |
| // On Linux NVIDIA, tol of 33 is necessary to pass the test. |
| tol = 40; |
| result = result.map(val => { return val * 0xFFFF}); |
| break; |
| case gl.UNSIGNED_INT: |
| tol = 40; |
| result = result.map(val => { return val * 0xFFFFFFFF}); |
| break; |
| case gl.UNSIGNED_SHORT_4_4_4_4: |
| result = result.map(val => { return val * 0xF}); |
| break; |
| case gl.UNSIGNED_SHORT_5_5_5_1: |
| result[0] = result[0] * 0x1F; |
| result[1] = result[1] * 0x1F; |
| result[2] = result[2] * 0x1F; |
| result[3] = result[3] * 0x1; |
| break; |
| case gl.UNSIGNED_SHORT_5_6_5: |
| result[0] = result[0] * 0x1F; |
| result[1] = result[1] * 0x3F; |
| result[2] = result[2] * 0x1F; |
| break; |
| case gl.UNSIGNED_INT_2_10_10_10_REV: |
| tol = 25; |
| result[0] = result[0] * 0x3FF; |
| result[1] = result[1] * 0x3FF; |
| result[2] = result[2] * 0x3FF; |
| result[3] = result[3] * 0x3; |
| break; |
| case gl.UNSIGNED_INT_5_9_9_9_REV: |
| result[0] = result[0] * 0x1FF; |
| result[1] = result[1] * 0x1FF; |
| result[2] = result[2] * 0x1FF; |
| result[3] = result[3] * 0x1F; |
| break; |
| } |
| |
| return { color: result, tol: tol }; |
| } |
| |
| function compareColor(buf, index, expectedColor, srcInternalFormat, |
| srcFormat, srcType, readFormat, readType) { |
| var srcChannelCount = getChannelCount(srcFormat); |
| var readChannelCount = getChannelCount(readFormat); |
| |
| var color = getColor(buf, index, readFormat, readType); |
| expectedColor = denormalizeColor(srcInternalFormat, readType, expectedColor); |
| |
| var minChannel = Math.min(srcChannelCount, readChannelCount); |
| for (var i = 0; i < minChannel; ++i) { |
| if (Math.abs(expectedColor.color[i] - color[i]) > expectedColor.tol) { |
| testFailed("Expected color = " + expectedColor.color + ", was = " + color); |
| return false; |
| } |
| } |
| |
| return true; |
| } |
| |
| var textureTestCases = [ |
| { |
| texInternalFormat: 'R8', texFormat: 'RED', texType: 'UNSIGNED_BYTE', |
| readFormat: 'RGBA', readType: 'UNSIGNED_BYTE', |
| clearColor: [0.5, 0.0, 0.0, 0], |
| }, |
| { |
| texInternalFormat: 'R8UI', texFormat: 'RED_INTEGER', texType: 'UNSIGNED_BYTE', |
| readFormat: 'RGBA_INTEGER', readType: 'UNSIGNED_INT', |
| clearColor: [250, 0, 0, 0], |
| }, |
| { |
| texInternalFormat: 'R8I', texFormat: 'RED_INTEGER', texType: 'BYTE', |
| readFormat: 'RGBA_INTEGER', readType: 'INT', |
| clearColor: [-126, 0, 0, 0], |
| }, |
| { |
| texInternalFormat: 'R16UI', texFormat: 'RED_INTEGER', texType: 'UNSIGNED_SHORT', |
| readFormat: 'RGBA_INTEGER', readType: 'UNSIGNED_INT', |
| clearColor: [30001, 0, 0, 0], |
| }, |
| { |
| texInternalFormat: 'R16I', texFormat: 'RED_INTEGER', texType: 'SHORT', |
| readFormat: 'RGBA_INTEGER', readType: 'INT', |
| clearColor: [-14189, 0, 0, 0], |
| }, |
| { |
| texInternalFormat: 'R32UI', texFormat: 'RED_INTEGER', texType: 'UNSIGNED_INT', |
| readFormat: 'RGBA_INTEGER', readType: 'UNSIGNED_INT', |
| clearColor: [126726, 0, 0, 0], |
| }, |
| { |
| texInternalFormat: 'R32I', texFormat: 'RED_INTEGER', texType: 'INT', |
| readFormat: 'RGBA_INTEGER', readType: 'INT', |
| clearColor: [-126726, 0, 0, 0], |
| }, |
| |
| { |
| texInternalFormat: 'RG8', texFormat: 'RG', texType: 'UNSIGNED_BYTE', |
| readFormat: 'RGBA', readType: 'UNSIGNED_BYTE', |
| clearColor: [0.5, 0.7, 0.0, 0], |
| }, |
| { |
| texInternalFormat: 'RG8UI', texFormat: 'RG_INTEGER', texType: 'UNSIGNED_BYTE', |
| readFormat: 'RGBA_INTEGER', readType: 'UNSIGNED_INT', |
| clearColor: [250, 124, 0, 0], |
| }, |
| { |
| texInternalFormat: 'RG8I', texFormat: 'RG_INTEGER', texType: 'BYTE', |
| readFormat: 'RGBA_INTEGER', readType: 'INT', |
| clearColor: [-55, 124, 0, 0], |
| }, |
| { |
| texInternalFormat: 'RG16UI', texFormat: 'RG_INTEGER', texType: 'UNSIGNED_SHORT', |
| readFormat: 'RGBA_INTEGER', readType: 'UNSIGNED_INT', |
| clearColor: [30001, 18, 0, 0], |
| }, |
| { |
| texInternalFormat: 'RG16I', texFormat: 'RG_INTEGER', texType: 'SHORT', |
| readFormat: 'RGBA_INTEGER', readType: 'INT', |
| clearColor: [-14189, 6735, 0, 0], |
| }, |
| { |
| texInternalFormat: 'RG32UI', texFormat: 'RG_INTEGER', texType: 'UNSIGNED_INT', |
| readFormat: 'RGBA_INTEGER', readType: 'UNSIGNED_INT', |
| clearColor: [126726, 1976, 0, 0], |
| }, |
| { |
| texInternalFormat: 'RG32I', texFormat: 'RG_INTEGER', texType: 'INT', |
| readFormat: 'RGBA_INTEGER', readType: 'INT', |
| clearColor: [-126726, 126726, 0, 0], |
| }, |
| |
| { |
| texInternalFormat: 'RGB8', texFormat: 'RGB', texType: 'UNSIGNED_BYTE', |
| readFormat: 'RGBA', readType: 'UNSIGNED_BYTE', |
| clearColor: [0.5, 1, 0, 0], |
| }, |
| { |
| texInternalFormat: 'RGB565', texFormat: 'RGB', texType: 'UNSIGNED_BYTE', |
| readFormat: 'RGBA', readType: 'UNSIGNED_BYTE', |
| clearColor: [0.5, 0.7, 0.2, 0], |
| }, |
| { |
| texInternalFormat: 'RGB565', texFormat: 'RGB', texType: 'UNSIGNED_SHORT_5_6_5', |
| readFormat: 'RGBA', readType: 'UNSIGNED_BYTE', |
| clearColor: [0.5, 0.7, 0.2, 0], |
| }, |
| |
| { |
| texInternalFormat: 'RGBA8', texFormat: 'RGBA', texType: 'UNSIGNED_BYTE', |
| readFormat: 'RGBA', readType: 'UNSIGNED_BYTE', |
| clearColor: [0.5, 0, 1, 0.7], |
| }, |
| { |
| texInternalFormat: 'SRGB8_ALPHA8', texFormat: 'RGBA', texType: 'UNSIGNED_BYTE', |
| readFormat: 'RGBA', readType: 'UNSIGNED_BYTE', |
| clearColor: [0.5, 0, 1, 0.7], |
| }, |
| { |
| texInternalFormat: 'RGB5_A1', texFormat: 'RGBA', texType: 'UNSIGNED_BYTE', |
| readFormat: 'RGBA', readType: 'UNSIGNED_BYTE', |
| clearColor: [0.5, 0, 0.7, 1], |
| }, |
| { |
| texInternalFormat: 'RGB5_A1', texFormat: 'RGBA', texType: 'UNSIGNED_SHORT_5_5_5_1', |
| readFormat: 'RGBA', readType: 'UNSIGNED_BYTE', |
| clearColor: [0.5, 0.7, 1, 0], |
| }, |
| { |
| texInternalFormat: 'RGB5_A1', texFormat: 'RGBA', texType: 'UNSIGNED_INT_2_10_10_10_REV', |
| readFormat: 'RGBA', readType: 'UNSIGNED_BYTE', |
| clearColor: [0.5, 0.7, 0, 1], |
| }, |
| { |
| texInternalFormat: 'RGBA4', texFormat: 'RGBA', texType: 'UNSIGNED_BYTE', |
| readFormat: 'RGBA', readType: 'UNSIGNED_BYTE', |
| clearColor: [0.5, 0.7, 1, 0], |
| }, |
| { |
| texInternalFormat: 'RGBA4', texFormat: 'RGBA', texType: 'UNSIGNED_SHORT_4_4_4_4', |
| readFormat: 'RGBA', readType: 'UNSIGNED_BYTE', |
| clearColor: [1, 0, 0.5, 0.7], |
| }, |
| { |
| texInternalFormat: 'RGBA8UI', texFormat: 'RGBA_INTEGER', texType: 'UNSIGNED_BYTE', |
| readFormat: 'RGBA_INTEGER', readType: 'UNSIGNED_INT', |
| clearColor: [127, 0, 255, 178], |
| }, |
| { |
| texInternalFormat: 'RGBA8I', texFormat: 'RGBA_INTEGER', texType: 'BYTE', |
| readFormat: 'RGBA_INTEGER', readType: 'INT', |
| clearColor: [-55, 56, 80, 127], |
| }, |
| { |
| texInternalFormat: 'RGB10_A2UI', texFormat: 'RGBA_INTEGER', texType: 'UNSIGNED_INT_2_10_10_10_REV', |
| readFormat: 'RGBA_INTEGER', readType: 'UNSIGNED_INT', |
| clearColor: [178, 0, 127, 3], |
| }, |
| { |
| texInternalFormat: 'RGBA16UI', texFormat: 'RGBA_INTEGER', texType: 'UNSIGNED_SHORT', |
| readFormat: 'RGBA_INTEGER', readType: 'UNSIGNED_INT', |
| clearColor: [14189, 6735, 0, 19], |
| }, |
| { |
| texInternalFormat: 'RGBA16I', texFormat: 'RGBA_INTEGER', texType: 'SHORT', |
| readFormat: 'RGBA_INTEGER', readType: 'INT', |
| clearColor: [14189, -6735, 0, 19], |
| }, |
| { |
| texInternalFormat: 'RGBA32UI', texFormat: 'RGBA_INTEGER', texType: 'UNSIGNED_INT', |
| readFormat: 'RGBA_INTEGER', readType: 'UNSIGNED_INT', |
| clearColor: [126726, 6726, 98765, 2015], |
| }, |
| { |
| texInternalFormat: 'RGBA32I', texFormat: 'RGBA_INTEGER', texType: 'INT', |
| readFormat: 'RGBA_INTEGER', readType: 'INT', |
| clearColor: [126726, -6726, -98765, 2015], |
| }, |
| |
| { |
| texInternalFormat: 'RGB10_A2', texFormat: 'RGBA', texType: 'UNSIGNED_INT_2_10_10_10_REV', |
| readFormat: 'RGBA', readType: 'UNSIGNED_BYTE', |
| clearColor: [0.7, 0, 0.5, 1], |
| }, |
| |
| // TODO(zmo): add float/half_float test cases with extension supports. |
| ]; |
| |
| function getArrayTypeFromReadPixelsType(gl, type) { |
| switch (type) { |
| case gl.UNSIGNED_BYTE: |
| return Uint8Array; |
| case gl.BYTE: |
| return Int8Array; |
| case gl.UNSIGNED_SHORT: |
| case gl.UNSIGNED_SHORT_5_6_5: |
| case gl.UNSIGNED_SHORT_4_4_4_4: |
| case gl.UNSIGNED_SHORT_5_5_5_1: |
| return Uint16Array; |
| case gl.SHORT: |
| return Int16Array; |
| case gl.UNSIGNED_INT: |
| case gl.UNSIGNED_INT_2_10_10_10_REV: |
| case gl.UNSIGNED_INT_10F_11F_11F_REV: |
| case gl.UNSIGNED_INT_5_9_9_9_REV: |
| return Uint32Array; |
| case gl.INT: |
| return Int32Array; |
| case gl.HALF_FLOAT: |
| return Uint16Array; |
| case gl.FLOAT: |
| return Float32Array; |
| default: |
| return null; |
| } |
| } |
| |
| function getFormatString(gl, format) { |
| switch (format) { |
| case gl.RED: |
| return 'RED'; |
| case gl.RED_INTEGER: |
| return 'RED_INTEGER'; |
| case gl.RG: |
| return 'RG'; |
| case gl.RG_INTEGER: |
| return 'RG_INTEGER'; |
| case gl.RGB: |
| return 'RGB'; |
| case gl.RGB_INTEGER: |
| return 'RGB_INTEGER'; |
| case gl.RGBA: |
| return 'RGBA'; |
| case gl.RGBA_INTEGER: |
| return 'RGBA_INTEGER'; |
| case gl.LUMINANCE: |
| return 'LUMINANCE'; |
| case gl.LUMINANCE_ALPHA: |
| return 'LUMINANCE_ALPHA'; |
| case gl.ALPHA: |
| return 'ALPHA'; |
| default: |
| return ''; |
| }; |
| } |
| |
| function getTypeString(gl, type) { |
| switch (type) { |
| case gl.UNSIGNED_BYTE: |
| return 'UNSIGNED_BYTE'; |
| case gl.BYTE: |
| return 'BYTE'; |
| case gl.UNSIGNED_SHORT: |
| return 'UNSIGNED_SHORT'; |
| case gl.SHORT: |
| return 'SHORT'; |
| case gl.UNSIGNED_INT: |
| return 'UNSIGNED_INT'; |
| case gl.INT: |
| return 'INT'; |
| case gl.UNSIGNED_SHORT_5_6_5: |
| return 'UNSIGNED_SHORT_5_6_5'; |
| case gl.UNSIGNED_SHORT_5_5_5_1: |
| return 'UNSIGNED_SHORT_5_5_5_1'; |
| case gl.UNSIGNED_INT_2_10_10_10_REV: |
| return 'UNSIGNED_INT_2_10_10_10_REV'; |
| case gl.UNSIGNED_SHORT_4_4_4_4: |
| return 'UNSIGNED_SHORT_4_4_4_4'; |
| case gl.UNSIGNED_INT_10F_11F_11F_REV: |
| return 'UNSIGNED_INT_10F_11F_11F_REV'; |
| case gl.UNSIGNED_INT_5_9_9_9_REV: |
| return 'UNSIGNED_INT_5_9_9_9_REV'; |
| default: |
| return ''; |
| }; |
| } |
| |
| function elementCountPerPixel(gl, readFormat, readType) { |
| switch (readFormat) { |
| case gl.RED: |
| case gl.RED_INTEGER: |
| case gl.ALPHA: |
| case gl.LUMINANCE: |
| return 1; |
| case gl.RG: |
| case gl.RG_INTEGER: |
| case gl.LUMINANCE_ALPHA: |
| return 2; |
| case gl.RGB: |
| case gl.RGB_INTEGER: |
| switch (readType) { |
| case gl.UNSIGNED_SHORT_5_6_5: |
| return 1; |
| default: |
| return 3; |
| } |
| case gl.RGBA: |
| case gl.RGBA_INTEGER: |
| switch (readType) { |
| case gl.UNSIGNED_SHORT_4_4_4_4: |
| case gl.UNSIGNED_SHORT_5_5_5_1: |
| case gl.UNSIGNED_INT_2_10_10_10_REV: |
| case gl.UNSIGNED_INT_10F_11F_11F_REV: |
| case gl.UNSIGNED_INT_5_9_9_9_REV: |
| return 1; |
| default: |
| return 4; |
| } |
| default: |
| testFailed("Unexpected read format/type = " + readFormat + "/" + readType); |
| return 0; |
| } |
| } |
| |
| function testReadPixels(gl, srcInternalFormat, srcFormat, srcType, |
| readFormat, readType, expectedColor) { |
| var arrayType = getArrayTypeFromReadPixelsType(gl, readType); |
| var buf = new arrayType(width * height * 4); |
| gl.readPixels(0, 0, width, height, readFormat, readType, buf); |
| wtu.glErrorShouldBe( |
| gl, gl.NO_ERROR, "readPixels should generate no error"); |
| var diffFound = false; |
| for (var ii = 0; ii < width * height; ++ii) { |
| var offset = ii * elementCountPerPixel(gl, readFormat, readType); |
| if (!compareColor(buf, offset, expectedColor, srcInternalFormat, srcFormat, srcType, |
| readFormat, readType)) { |
| diffFound = true; |
| break; |
| } |
| } |
| if (!diffFound) { |
| testPassed("Color read back as expected"); |
| } |
| } |
| |
| function clearBuffer(gl, texInternalFormat, clearColor) { |
| var value; |
| switch (texInternalFormat) { |
| case gl.R8UI: |
| case gl.R16UI: |
| case gl.R32UI: |
| case gl.RG8UI: |
| case gl.RG16UI: |
| case gl.RG32UI: |
| case gl.RGBA8UI: |
| case gl.RGBA16UI: |
| case gl.RGBA32UI: |
| case gl.RGB10_A2UI: |
| value = new Uint32Array(4); |
| for (var ii = 0; ii < 4; ++ii) |
| value[ii] = clearColor[ii]; |
| gl.clearBufferuiv(gl.COLOR, 0, value); |
| break; |
| case gl.R8I: |
| case gl.R16I: |
| case gl.R32I: |
| case gl.RG8I: |
| case gl.RG16I: |
| case gl.RG32I: |
| case gl.RGBA8I: |
| case gl.RGBA16I: |
| case gl.RGBA32I: |
| value = new Int32Array(4); |
| for (var ii = 0; ii < 4; ++ii) |
| value[ii] = clearColor[ii]; |
| gl.clearBufferiv(gl.COLOR, 0, value); |
| break; |
| default: |
| gl.clearColor(clearColor[0], clearColor[1], clearColor[2], clearColor[3]); |
| gl.clear(gl.COLOR_BUFFER_BIT); |
| break; |
| } |
| } |
| |
| for (var tt = 0; tt < textureTestCases.length; ++tt) { |
| var test = textureTestCases[tt]; |
| debug(""); |
| debug("ReadPixels from fbo with texture = (" + test.texInternalFormat + |
| ", " + test.texFormat + ", " + test.texType + |
| "), format = " + test.readFormat + ", type = " + test.readType); |
| var width = 2; |
| var height = 2; |
| var fbo = gl.createFramebuffer(); |
| gl.bindFramebuffer(gl.FRAMEBUFFER, fbo); |
| var colorImage = gl.createTexture(); |
| gl.bindTexture(gl.TEXTURE_2D, colorImage); |
| gl.texImage2D(gl.TEXTURE_2D, 0, gl[test.texInternalFormat], width, height, 0, |
| gl[test.texFormat], gl[test.texType], null); |
| gl.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, |
| gl.TEXTURE_2D, colorImage, 0); |
| wtu.glErrorShouldBe( |
| gl, gl.NO_ERROR, "Setting up fbo should generate no error"); |
| if (gl.checkFramebufferStatus(gl.FRAMEBUFFER) != gl.FRAMEBUFFER_COMPLETE) { |
| debug("fbo is not complete, skip"); |
| continue; |
| } |
| clearBuffer(gl, gl[test.texInternalFormat], test.clearColor); |
| wtu.glErrorShouldBe( |
| gl, gl.NO_ERROR, "Clear color should generate no error"); |
| |
| var implFormat = gl.getParameter(gl.IMPLEMENTATION_COLOR_READ_FORMAT); |
| var implType = gl.getParameter(gl.IMPLEMENTATION_COLOR_READ_TYPE); |
| var implFormatString = getFormatString(gl, implFormat); |
| var implTypeString = getTypeString(gl, implType); |
| |
| if (gl[test.texInternalFormat] == gl.RGB10_A2) { |
| // This is a special case where three read format/type are supported. |
| var readTypes = [gl.UNSIGNED_BYTE, gl.UNSIGNED_INT_2_10_10_10_REV]; |
| var readTypeStrings = ['UNSIGNED_BYTE', 'UNSIGNED_INT_2_10_10_10_REV']; |
| if (implFormat == gl.RGBA && implTypeString != '') { |
| readTypes.push(implType); |
| readTypeStrings.push(implTypeString); |
| } else { |
| testFailed("Unimplemented Implementation dependent color read format/type = " + |
| implFormat + "/" + implType); |
| } |
| for (var rr = 0; rr < readTypes.length; ++rr) { |
| debug("Special case RGB10_A2, format = RGBA, type = " + readTypeStrings[rr]); |
| testReadPixels(gl, gl[test.texInternalFormat], gl[test.texFormat], gl[test.texType], |
| gl.RGBA, readTypes[rr], test.clearColor); |
| } |
| } else { |
| testReadPixels(gl, gl[test.texInternalFormat], gl[test.texFormat], gl[test.texType], |
| gl[test.readFormat], gl[test.readType], test.clearColor); |
| |
| debug("Testing implementation dependent color read format = " + implFormatString + |
| ", type = " + implTypeString); |
| if (implFormatString == '') { |
| testFailed("Invalid IMPLEMENTATION_COLOR_READ_FORMAT = " + implFormat); |
| continue; |
| } |
| if (implTypeString == '') { |
| testFailed("Invalid IMPLEMENTATION_COLOR_READ_TYPE = " + implType); |
| continue; |
| } |
| testReadPixels(gl, gl[test.texInternalFormat], gl[test.texFormat], gl[test.texType], |
| implFormat, implType, test.clearColor); |
| |
| gl.deleteTexture(colorImage); |
| gl.deleteFramebuffer(fbo); |
| } |
| } |
| |
| debug("") |
| var successfullyParsed = true; |
| </script> |
| <script src="../../js/js-test-post.js"></script> |
| </body> |
| </html> |
