diff options
author | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-07 19:33:14 +0000 |
---|---|---|
committer | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-07 19:33:14 +0000 |
commit | 36d22d82aa202bb199967e9512281e9a53db42c9 (patch) | |
tree | 105e8c98ddea1c1e4784a60a5a6410fa416be2de /dom/canvas/test/webgl-conf/checkout/deqp/functional/gles3/es3fPixelBufferObjectTest.js | |
parent | Initial commit. (diff) | |
download | firefox-esr-36d22d82aa202bb199967e9512281e9a53db42c9.tar.xz firefox-esr-36d22d82aa202bb199967e9512281e9a53db42c9.zip |
Adding upstream version 115.7.0esr.upstream/115.7.0esrupstream
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'dom/canvas/test/webgl-conf/checkout/deqp/functional/gles3/es3fPixelBufferObjectTest.js')
-rw-r--r-- | dom/canvas/test/webgl-conf/checkout/deqp/functional/gles3/es3fPixelBufferObjectTest.js | 585 |
1 files changed, 585 insertions, 0 deletions
diff --git a/dom/canvas/test/webgl-conf/checkout/deqp/functional/gles3/es3fPixelBufferObjectTest.js b/dom/canvas/test/webgl-conf/checkout/deqp/functional/gles3/es3fPixelBufferObjectTest.js new file mode 100644 index 0000000000..ac577193aa --- /dev/null +++ b/dom/canvas/test/webgl-conf/checkout/deqp/functional/gles3/es3fPixelBufferObjectTest.js @@ -0,0 +1,585 @@ +/*------------------------------------------------------------------------- + * drawElements Quality Program OpenGL ES Utilities + * ------------------------------------------------ + * + * Copyright 2014 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ +'use strict'; +goog.provide('functional.gles3.es3fPixelBufferObjectTest'); +goog.require('framework.common.tcuImageCompare'); +goog.require('framework.common.tcuTestCase'); +goog.require('framework.common.tcuTexture'); +goog.require('framework.common.tcuTextureUtil'); +goog.require('framework.delibs.debase.deRandom'); +goog.require('framework.delibs.debase.deString'); +goog.require('framework.opengl.gluShaderProgram'); +goog.require('framework.opengl.gluTextureUtil'); + +goog.scope(function() { + +var es3fPixelBufferObjectTest = functional.gles3.es3fPixelBufferObjectTest; +var gluShaderProgram = framework.opengl.gluShaderProgram; +var tcuTestCase = framework.common.tcuTestCase; +var deRandom = framework.delibs.debase.deRandom; +var deString = framework.delibs.debase.deString; +var tcuTextureUtil = framework.common.tcuTextureUtil; +var tcuTexture = framework.common.tcuTexture; +var gluTextureUtil = framework.opengl.gluTextureUtil; +var tcuImageCompare = framework.common.tcuImageCompare; + + var DE_ASSERT = function(x) { + if (!x) + throw new Error('Assert failed'); + }; + + es3fPixelBufferObjectTest.DE_STATIC_ASSERT = function(expression) { + if (!expression) throw new Error('Assert failed'); + }; + + /** @enum */ + es3fPixelBufferObjectTest.FramebufferType = { + FRAMEBUFFERTYPE_NATIVE: 0, + FRAMEBUFFERTYPE_RENDERBUFFER: 1 + }; + + /** + * @constructor + * @struct + */ + es3fPixelBufferObjectTest.TestSpec = function() { // This is originaly a struct + this.name = ''; + this.description = ''; + this.useColorClear = false; + this.renderTriangles = false; + /** @type {es3fPixelBufferObjectTest.FramebufferType} */ this.framebufferType; + /** @type {number} */ this.renderbufferFormat; + }; + + /** + * @constructor + * @extends {tcuTestCase.DeqpTest} + * @param {es3fPixelBufferObjectTest.TestSpec} spec + */ + es3fPixelBufferObjectTest.ReadPixelsTest = function(spec) { + tcuTestCase.DeqpTest.call(this, spec.name, spec.description); + this.m_random = new deRandom.Random(deString.deStringHash(spec.name)); + this.m_program = null; + this.m_framebuffeType = spec.framebufferType; + this.m_renderbufferFormat = spec.renderbufferFormat; + this.m_texChannelClass = undefined; + this.m_useColorClears = spec.useColorClear; + this.m_renderTriangles = spec.renderTriangles; + this.m_colorScale = 1.0; + + if (this.m_framebuffeType === es3fPixelBufferObjectTest.FramebufferType.FRAMEBUFFERTYPE_NATIVE) { + this.m_colorScale = 1.0; + } else if (this.m_framebuffeType === es3fPixelBufferObjectTest.FramebufferType.FRAMEBUFFERTYPE_RENDERBUFFER) { + this.m_texChannelClass = tcuTexture.getTextureChannelClass(gluTextureUtil.mapGLInternalFormat(spec.renderbufferFormat).type); + switch (this.m_texChannelClass) { + case tcuTexture.TextureChannelClass.UNSIGNED_FIXED_POINT: + this.m_colorScale = 1.0; + break; + case tcuTexture.TextureChannelClass.SIGNED_INTEGER: + this.m_colorScale = 100.0; + break; + case tcuTexture.TextureChannelClass.UNSIGNED_INTEGER: + this.m_colorScale = 100.0; + break; + case tcuTexture.TextureChannelClass.FLOATING_POINT: + this.m_colorScale = 100.0; + break; + default: + DE_ASSERT(false); + } + } else { + DE_ASSERT(false); + } + }; + + es3fPixelBufferObjectTest.ReadPixelsTest.prototype = Object.create(tcuTestCase.DeqpTest.prototype); + es3fPixelBufferObjectTest.ReadPixelsTest.prototype.constructor = es3fPixelBufferObjectTest.ReadPixelsTest; + + es3fPixelBufferObjectTest.ReadPixelsTest.prototype.init = function() { + var outtype = ''; + + if (this.m_framebuffeType === es3fPixelBufferObjectTest.FramebufferType.FRAMEBUFFERTYPE_NATIVE) + outtype = 'vec4'; + else if (this.m_framebuffeType === es3fPixelBufferObjectTest.FramebufferType.FRAMEBUFFERTYPE_RENDERBUFFER) { + switch (this.m_texChannelClass) { + case tcuTexture.TextureChannelClass.UNSIGNED_FIXED_POINT: + outtype = 'vec4'; + break; + case tcuTexture.TextureChannelClass.SIGNED_INTEGER: + outtype = 'ivec4'; + break; + case tcuTexture.TextureChannelClass.UNSIGNED_INTEGER: + outtype = 'uvec4'; + break; + case tcuTexture.TextureChannelClass.FLOATING_POINT: + outtype = 'vec4'; + break; + default: + DE_ASSERT(false); + } + } else + DE_ASSERT(false); + + /** @type {string} */ var vertexShaderSource = + '#version 300 es\n' + + 'in mediump vec3 a_position;\n' + + 'in mediump vec4 a_color;\n' + + 'uniform mediump float u_colorScale;\n' + + 'out mediump vec4 v_color;\n' + + 'void main(void)\n' + + ' {\n' + + '\tgl_Position = vec4(a_position, 1.0);\n' + + '\tv_color = u_colorScale * a_color;\n' + + '}'; + + /** @type {string} */ var fragmentShaderSource = + '#version 300 es\n' + + 'in mediump vec4 v_color;\n' + + 'layout (location = 0) out mediump ' + + outtype + + ' o_color;\n' + + 'void main(void)\n' + + ' {\n' + + '\to_color = ' + + outtype + + '(v_color);\n' + + '}'; + + this.m_program = new gluShaderProgram.ShaderProgram(gl, gluShaderProgram.makeVtxFragSources(vertexShaderSource, fragmentShaderSource)); + + if (!this.m_program.isOk()) + throw new Error('Compile failed. Program not created'); + + }; + + /** + * @param {Array<number>} a + * @param {Array<number>} b + * @param {Array<number>} c + */ + es3fPixelBufferObjectTest.ReadPixelsTest.prototype.renderTriangle = function(a, b, c) { + + var positions = new Float32Array(36); + + positions[0] = a[0]; + positions[1] = a[1]; + positions[2] = a[2]; + + positions[3] = b[0]; + positions[4] = b[1]; + positions[5] = b[2]; + + positions[6] = c[0]; + positions[7] = c[1]; + positions[8] = c[2]; + + var colors = new Float32Array([ + 1.0, 0.0, 0.0, 1.0, + 0.0, 1.0, 0.0, 1.0, + 0.0, 0.0, 1.0, 1.0]); + + gl.useProgram(this.m_program.getProgram()); + assertMsgOptions(gl.getError() === gl.NO_ERROR, 'useProgram failed ', false, true); + + /** @type {WebGLUniformLocation} */ var colorScaleLoc = gl.getUniformLocation(this.m_program.getProgram(), 'u_colorScale'); + assertMsgOptions(colorScaleLoc != -1, 'Could not find u_colorScale ', false, true); + + gl.uniform1f(colorScaleLoc, this.m_colorScale); + + /** @type {number} */ var coordLoc = gl.getAttribLocation(this.m_program.getProgram(), 'a_position'); + assertMsgOptions(coordLoc != -1, 'Could not find a_position ', false, true); + + /** @type {number} */ var colorLoc = gl.getAttribLocation(this.m_program.getProgram(), 'a_color'); + assertMsgOptions(colorLoc != -1, 'Could not find a_color ', false, true); + + gl.enableVertexAttribArray(colorLoc); + assertMsgOptions(gl.getError() === gl.NO_ERROR, 'enableVertexAttribArray failed ', false, true); + gl.enableVertexAttribArray(coordLoc); + assertMsgOptions(gl.getError() === gl.NO_ERROR, 'enableVertexAttribArray failed ', false, true); + + var pos = gl.createBuffer(); + gl.bindBuffer(gl.ARRAY_BUFFER, pos); + gl.bufferData(gl.ARRAY_BUFFER, positions, gl.STATIC_DRAW); + gl.vertexAttribPointer(coordLoc, 3, gl.FLOAT, false, 0, 0); + + var c = gl.createBuffer(); + gl.bindBuffer(gl.ARRAY_BUFFER, c); + gl.bufferData(gl.ARRAY_BUFFER, colors, gl.STATIC_DRAW); + gl.vertexAttribPointer(colorLoc, 4, gl.FLOAT, false, 0, 0); + + gl.drawArrays(gl.TRIANGLES, 0, 3); + + gl.disableVertexAttribArray(colorLoc); + gl.disableVertexAttribArray(coordLoc); + }; + + /** + * @param {number} r + * @param {number} g + * @param {number} b + * @param {number} a + */ + + es3fPixelBufferObjectTest.ReadPixelsTest.prototype.clearColor = function(r, g, b, a) { + if (this.m_framebuffeType == es3fPixelBufferObjectTest.FramebufferType.FRAMEBUFFERTYPE_NATIVE) { + gl.clearColor(r, g, b, a); + gl.clear(gl.COLOR_BUFFER_BIT); + } else if (this.m_framebuffeType == es3fPixelBufferObjectTest.FramebufferType.FRAMEBUFFERTYPE_RENDERBUFFER) { + switch (this.m_texChannelClass) { + case tcuTexture.TextureChannelClass.UNSIGNED_FIXED_POINT: + gl.clearColor(r, g, b, a); + gl.clear(gl.COLOR_BUFFER_BIT); + break; + case tcuTexture.TextureChannelClass.SIGNED_INTEGER: + gl.clearBufferiv(gl.COLOR, 0, new Int32Array([r, g, b, a])); + break; + case tcuTexture.TextureChannelClass.UNSIGNED_INTEGER: + gl.clearBufferuiv(gl.COLOR, 0, new Uint32Array([r, g, b, a])); + break; + case tcuTexture.TextureChannelClass.FLOATING_POINT: + gl.clearBufferfv(gl.COLOR, 0, new Float32Array([r, g, b, a])); + break; + default: + DE_ASSERT(false); + } + } else + DE_ASSERT(false); + + }; + + es3fPixelBufferObjectTest.ReadPixelsTest.prototype.iterate = function() { + var width = gl.drawingBufferWidth; + var height = gl.drawingBufferHeight; + + var framebuffer = null; + var renderbuffer = null; + + switch (this.m_framebuffeType) { + case es3fPixelBufferObjectTest.FramebufferType.FRAMEBUFFERTYPE_NATIVE: + gl.bindFramebuffer(gl.FRAMEBUFFER, framebuffer); + break; + case es3fPixelBufferObjectTest.FramebufferType.FRAMEBUFFERTYPE_RENDERBUFFER: + framebuffer = gl.createFramebuffer(); + renderbuffer = gl.createRenderbuffer(); + + gl.bindRenderbuffer(gl.RENDERBUFFER, renderbuffer); + gl.renderbufferStorage(gl.RENDERBUFFER, this.m_renderbufferFormat, width, height); + + gl.bindFramebuffer(gl.FRAMEBUFFER, framebuffer); + gl.framebufferRenderbuffer(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.RENDERBUFFER, renderbuffer); + break; + } + + this.clearColor(this.m_colorScale * 0.4, this.m_colorScale * 1.0, this.m_colorScale * 0.5, this.m_colorScale * 1.0); + + if (this.m_useColorClears) { + /** @type {number} */ var maxClearCount = 10; + /** @type {number} */ var minClearCount = 6; + /** @type {number} */ var minClearSize = 15; + + /** @type {number} */ var clearCount = this.m_random.getInt(minClearCount, maxClearCount); + + for (var clearNdx = 0; clearNdx < clearCount; clearNdx++) { + /** @type {number} */ var clearX = this.m_random.getInt(0, width - minClearSize); + /** @type {number} */ var clearY = this.m_random.getInt(0, height - minClearSize); + + /** @type {number} */ var clearWidth = this.m_random.getInt(minClearSize, width - clearX); + /** @type {number} */ var clearHeight = this.m_random.getInt(minClearSize, height - clearY); + + /** @type {number} */ var clearRed = this.m_colorScale * this.m_random.getFloat(); + /** @type {number} */ var clearGreen = this.m_colorScale * this.m_random.getFloat(); + /** @type {number} */ var clearBlue = this.m_colorScale * this.m_random.getFloat(); + /** @type {number} */ var clearAlpha = this.m_colorScale * (0.5 + 0.5 * this.m_random.getFloat()); + + gl.enable(gl.SCISSOR_TEST); + gl.scissor(clearX, clearY, clearWidth, clearHeight); + + this.clearColor(clearRed, clearGreen, clearBlue, clearAlpha); + } + + gl.disable(gl.SCISSOR_TEST); + + } + + if (this.m_renderTriangles) { + /** @type {number} */ var minTriangleCount = 4; + /** @type {number} */ var maxTriangleCount = 10; + + /** @type {number} */ var triangleCount = this.m_random.getInt(minTriangleCount, maxTriangleCount); + + for (var triangleNdx = 0; triangleNdx < triangleCount; triangleNdx++) { + /** @type {number} */ var x1 = 2.0 * this.m_random.getFloat() - 1.0; + /** @type {number} */ var y1 = 2.0 * this.m_random.getFloat() - 1.0; + /** @type {number} */ var z1 = 2.0 * this.m_random.getFloat() - 1.0; + + /** @type {number} */ var x2 = 2.0 * this.m_random.getFloat() - 1.0; + /** @type {number} */ var y2 = 2.0 * this.m_random.getFloat() - 1.0; + /** @type {number} */ var z2 = 2.0 * this.m_random.getFloat() - 1.0; + + /** @type {number} */ var x3 = 2.0 * this.m_random.getFloat() - 1.0; + /** @type {number} */ var y3 = 2.0 * this.m_random.getFloat() - 1.0; + /** @type {number} */ var z3 = 2.0 * this.m_random.getFloat() - 1.0; + + this.renderTriangle([x1, y1, z1], [x2, y2, z2], [x3, y3, z3]); + } + } + + /** @type {tcuTexture.TextureFormat} */ var readFormat; + /** @type {number} */ var readPixelsFormat; + /** @type {number} */ var readPixelsType; + /** @type {boolean} */ var floatCompare; + + if (this.m_framebuffeType == es3fPixelBufferObjectTest.FramebufferType.FRAMEBUFFERTYPE_NATIVE) { + readFormat = gluTextureUtil.mapGLTransferFormat(gl.RGBA, gl.UNSIGNED_BYTE); + readPixelsFormat = gl.RGBA; + readPixelsType = gl.UNSIGNED_BYTE; + floatCompare = false; + } else if (this.m_framebuffeType == es3fPixelBufferObjectTest.FramebufferType.FRAMEBUFFERTYPE_RENDERBUFFER) { + switch (this.m_texChannelClass) { + case tcuTexture.TextureChannelClass.UNSIGNED_FIXED_POINT: + readFormat = gluTextureUtil.mapGLTransferFormat(gl.RGBA, gl.UNSIGNED_BYTE); + readPixelsFormat = gl.RGBA; + readPixelsType = gl.UNSIGNED_BYTE; + floatCompare = true; + break; + case tcuTexture.TextureChannelClass.SIGNED_INTEGER: + readFormat = gluTextureUtil.mapGLTransferFormat(gl.RGBA_INTEGER, gl.INT); + readPixelsFormat = gl.RGBA_INTEGER; + readPixelsType = gl.INT; + floatCompare = false; + break; + case tcuTexture.TextureChannelClass.UNSIGNED_INTEGER: + readFormat = gluTextureUtil.mapGLTransferFormat(gl.RGBA_INTEGER, gl.UNSIGNED_INT); + readPixelsFormat = gl.RGBA_INTEGER; + readPixelsType = gl.UNSIGNED_INT; + floatCompare = false; + break; + case tcuTexture.TextureChannelClass.FLOATING_POINT: + readFormat = gluTextureUtil.mapGLTransferFormat(gl.RGBA, gl.FLOAT); + readPixelsFormat = gl.RGBA; + readPixelsType = gl.FLOAT; + floatCompare = true; + break; + default: + DE_ASSERT(false); + // Silence warning + readFormat = gluTextureUtil.mapGLTransferFormat(gl.RGBA, gl.FLOAT); + readPixelsFormat = gl.RGBA; + readPixelsType = gl.FLOAT; + floatCompare = true; + } + } else { + // Silence warnings + readFormat = gluTextureUtil.mapGLTransferFormat(gl.RGBA, gl.FLOAT); + readPixelsFormat = gl.RGBA; + readPixelsType = gl.FLOAT; + floatCompare = true; + DE_ASSERT(false); + } + + var readReference = new tcuTexture.Texture2D(readFormat, width, height); + readReference.allocLevel(0); + + var pixelBuffer = gl.createBuffer(); + + gl.bindBuffer(gl.PIXEL_PACK_BUFFER, pixelBuffer); + gl.bufferData(gl.PIXEL_PACK_BUFFER, readReference.getLevel(0).getDataSize(), gl.STREAM_READ); + gl.readPixels(0, 0, width, height, readPixelsFormat, readPixelsType, 0); + + var bufferData = new Uint8Array(readReference.getLevel(0).getDataSize()); + + gl.getBufferSubData(gl.PIXEL_PACK_BUFFER, 0, bufferData); + + var readResult = new tcuTexture.ConstPixelBufferAccess({ + width: width, + height: height, + format: readFormat, + data: bufferData.buffer}); + + gl.bindBuffer(gl.PIXEL_PACK_BUFFER, null); + + gl.readPixels(0, 0, width, height, readPixelsFormat, readPixelsType, readReference.getLevel(0).getDataPtr()); + + if (framebuffer) + gl.deleteFramebuffer(framebuffer); + + if (renderbuffer) + gl.deleteRenderbuffer(renderbuffer); + + var isOk = false; + + if (floatCompare) { + // When converting between integers and floats, certain GPUs might have different behaviors + // from javascript in rounding (up vs down). Increase tolerance to allow both behaviors. + // Detailed discussion in Mesa upstream can be found at: + // https://bugs.freedesktop.org/show_bug.cgi?id=89314. + var threshold; + switch (this.m_renderbufferFormat) { + case gl.RGB10_A2: + case gl.RGB5_A1: + case gl.RGB565: + threshold = [0.004, 0.004, 0.004, 0.0]; + break; + default: + threshold = [0.0, 0.0, 0.0, 0.0]; + break; + } + isOk = tcuImageCompare.floatThresholdCompare('Result comparison', 'Result of read pixels to memory compared with result of read pixels to buffer', readReference.getLevel(0), readResult, threshold); + } + else + isOk = tcuImageCompare.intThresholdCompare('Result comparison', 'Result of read pixels to memory compared with result of read pixels to buffer', readReference.getLevel(0), readResult, [0, 0, 0, 0]); + + gl.deleteBuffer(pixelBuffer); + + assertMsgOptions(isOk, this.getDescription(), true, true); + + return tcuTestCase.IterateResult.STOP; + }; + + es3fPixelBufferObjectTest.init = function() { + var state = tcuTestCase.runner; + /** @type {tcuTestCase.DeqpTest} */ var testGroup = state.testCases; + + /** @type {tcuTestCase.DeqpTest} */ var nativeFramebufferGroup = tcuTestCase.newTest('native', 'Tests with reading from native framebuffer'); + + var nativeFramebufferTests = [{ + name: 'clears', + description: 'Simple read pixels test with color clears', + useColorClear: true, + renderTriangles: false, + framebufferType: es3fPixelBufferObjectTest.FramebufferType.FRAMEBUFFERTYPE_NATIVE, + renderbufferFormat: gl.NONE + }, { + name: 'triangles', + description: 'Simple read pixels test rendering triangles', + useColorClear: false, + renderTriangles: true, + framebufferType: es3fPixelBufferObjectTest.FramebufferType.FRAMEBUFFERTYPE_NATIVE, + renderbufferFormat: gl.NONE + } + ]; + + for (var testNdx = 0; testNdx < nativeFramebufferTests.length; testNdx++) + nativeFramebufferGroup.addChild(new es3fPixelBufferObjectTest.ReadPixelsTest(nativeFramebufferTests[testNdx])); + + testGroup.addChild(nativeFramebufferGroup); + + /** @type {tcuTestCase.DeqpTest} */ var renderbufferGroup = tcuTestCase.newTest('renderbuffer', 'Tests with reading from renderbuffer'); + + var renderbufferFormats = [ + gl.RGBA8, + gl.RGBA8I, + gl.RGBA8UI, + gl.RGBA16I, + gl.RGBA16UI, + gl.RGBA32I, + gl.RGBA32UI, + + gl.SRGB8_ALPHA8, + gl.RGB10_A2, + gl.RGB10_A2UI, + gl.RGBA4, + gl.RGB5_A1, + + gl.RGB8, + gl.RGB565, + + gl.RG8, + gl.RG8I, + gl.RG8UI, + gl.RG16I, + gl.RG16UI, + gl.RG32I, + gl.RG32UI + ]; + + var renderbufferFormatsStr = [ + 'rgba8', + 'rgba8i', + 'rgba8ui', + 'rgba16i', + 'rgba16ui', + 'rgba32i', + 'rgba32ui', + + 'srgb8_alpha8', + 'rgb10_a2', + 'rgb10_a2ui', + 'rgba4', + 'rgb5_a1', + + 'rgb8', + 'rgb565', + + 'rg8', + 'rg8i', + 'rg8ui', + 'rg16i', + 'rg16ui', + 'rg32i', + 'rg32ui' + ]; + es3fPixelBufferObjectTest.DE_STATIC_ASSERT(renderbufferFormatsStr.length == renderbufferFormats.length); + + for (var formatNdx = 0; formatNdx < renderbufferFormats.length; formatNdx++) { + for (var trianglesClears = 0; trianglesClears < 2; trianglesClears++) { + var nameDescription = renderbufferFormatsStr[formatNdx] + '_' + (trianglesClears == 0 ? 'triangles' : 'clears'); + var testSpec = new es3fPixelBufferObjectTest.TestSpec(); + testSpec.name = nameDescription; + testSpec.description = nameDescription; + testSpec.useColorClear = trianglesClears == 1; + testSpec.renderTriangles = trianglesClears == 0; + testSpec.framebufferType = es3fPixelBufferObjectTest.FramebufferType.FRAMEBUFFERTYPE_RENDERBUFFER; + testSpec.renderbufferFormat = renderbufferFormats[formatNdx]; + + renderbufferGroup.addChild(new es3fPixelBufferObjectTest.ReadPixelsTest(testSpec)); + } + } + + testGroup.addChild(renderbufferGroup); + }; + + es3fPixelBufferObjectTest.run = function(context) { + gl = context; + //Set up Test Root parameters + var testName = 'pixel_buffer_object'; + var testDescription = 'Pixel Buffer Object Tests'; + var state = tcuTestCase.runner; + + state.testName = testName; + state.testCases = tcuTestCase.newTest(testName, testDescription, null); + + //Set up name and description of this test series. + setCurrentTestName(testName); + description(testDescription); + + try { + //Create test cases + es3fPixelBufferObjectTest.init(); + //Run test cases + tcuTestCase.runTestCases(); + } + catch (err) { + bufferedLogToConsole(err); + tcuTestCase.runner.terminate(); + } + }; + +}); |