diff options
Diffstat (limited to 'dom/canvas/test/webgl-conf/checkout/deqp/functional/gles3/es3fFboColorbufferTests.js')
| -rw-r--r-- | dom/canvas/test/webgl-conf/checkout/deqp/functional/gles3/es3fFboColorbufferTests.js | 1049 |
1 files changed, 1049 insertions, 0 deletions
diff --git a/dom/canvas/test/webgl-conf/checkout/deqp/functional/gles3/es3fFboColorbufferTests.js b/dom/canvas/test/webgl-conf/checkout/deqp/functional/gles3/es3fFboColorbufferTests.js new file mode 100644 index 0000000000..deb692a7b6 --- /dev/null +++ b/dom/canvas/test/webgl-conf/checkout/deqp/functional/gles3/es3fFboColorbufferTests.js @@ -0,0 +1,1049 @@ +/*------------------------------------------------------------------------- + * 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.es3fFboColorbufferTests'); +goog.require('framework.common.tcuSurface'); +goog.require('framework.common.tcuTestCase'); +goog.require('framework.common.tcuTexture'); +goog.require('framework.opengl.gluTextureUtil'); +goog.require('functional.gles3.es3fFboTestCase'); +goog.require('functional.gles3.es3fFboTestUtil'); +goog.require('framework.common.tcuRGBA'); +goog.require('framework.delibs.debase.deRandom'); +goog.require('framework.common.tcuImageCompare'); +goog.require('framework.common.tcuTextureUtil'); +goog.require('framework.referencerenderer.rrUtil'); +goog.require('framework.delibs.debase.deMath'); +goog.require('framework.opengl.gluShaderUtil'); + +goog.scope(function() { +var es3fFboColorbufferTests = functional.gles3.es3fFboColorbufferTests; +var es3fFboTestCase = functional.gles3.es3fFboTestCase; +var es3fFboTestUtil = functional.gles3.es3fFboTestUtil; +var tcuTestCase = framework.common.tcuTestCase; +var tcuSurface = framework.common.tcuSurface; +var tcuTexture = framework.common.tcuTexture; +var gluTextureUtil = framework.opengl.gluTextureUtil; +var tcuRGBA = framework.common.tcuRGBA; +var deRandom = framework.delibs.debase.deRandom; +var tcuImageCompare = framework.common.tcuImageCompare; +var tcuTextureUtil = framework.common.tcuTextureUtil; +var rrUtil = framework.referencerenderer.rrUtil; +var deMath = framework.delibs.debase.deMath; +var gluShaderUtil = framework.opengl.gluShaderUtil; + +/** @type {WebGL2RenderingContext} */ var gl; + +/** @const*/ var MIN_THRESHOLD = new tcuRGBA.RGBA([12, 12, 12, 12]); + +let canvasWH = 256; +let texPotSize = [128, 128, 5]; +let texNpotSizeA = [129, 117]; +let texNpotSizeB = [99, 128]; +if (tcuTestCase.isQuickMode()) { + canvasWH = 32; + texPotSize = [16, 16, 5]; + texNpotSizeA = [12, 11]; + texNpotSizeB = [9, 16]; +} +const texW = texPotSize[0]; +const texH = texPotSize[1]; + +var setParentClass = function(child, parent) { + child.prototype = Object.create(parent.prototype); + child.prototype.constructor = child; +}; + +/** + * @param {deRandom.Random} rnd + * @param {Array<number>} minVal + * @param {Array<number>} maxVal + * @return {Array<number>} + */ +es3fFboColorbufferTests.randomVector = function(rnd, minVal, maxVal) { + var res = []; + for (var ndx = 0; ndx < minVal.length; ndx++) + res[ndx] = rnd.getFloat(minVal[ndx], maxVal[ndx]); + return res; +}; + +/** + * @param {deRandom.Random} rnd + * @return {Array<number>} + */ +es3fFboColorbufferTests.generateRandomColor = function(rnd) { + var retVal = []; + + for (var i = 0; i < 3; ++i) + retVal[i] = rnd.getFloat(); + retVal[3] = 1; + + return retVal; +}; + +/** + * @constructor + * @extends {es3fFboTestCase.FboTestCase} + * @param {string} name + * @param {string} desc + * @param {number} format + */ +es3fFboColorbufferTests.FboColorbufferCase = function(name, desc, format) { + es3fFboTestCase.FboTestCase.call(this, name, desc); + this.m_format = format; +}; + +setParentClass(es3fFboColorbufferTests.FboColorbufferCase, es3fFboTestCase.FboTestCase); + +/** + * @param {tcuSurface.Surface} reference + * @param {tcuSurface.Surface} result + * @return {boolean} + */ +es3fFboColorbufferTests.FboColorbufferCase.prototype.compare = function(reference, result) { + /** @type {tcuRGBA.RGBA} */ var threshold = tcuRGBA.max(es3fFboTestUtil.getFormatThreshold(this.m_format), MIN_THRESHOLD); + + bufferedLogToConsole('Comparing images, threshold: ' + threshold); + + return tcuImageCompare.bilinearCompare('Result', 'Image comparison result', reference.getAccess(), result.getAccess(), threshold); + }; + +/** + * Deinit. Clear some GL state variables + */ +es3fFboColorbufferTests.FboColorbufferCase.prototype.deinit = function() { + // Texture state + { + // Only TEXTURE0 and TEXTURE1 are used in this test + var numTexUnits = 2; + + for (var ndx = 0; ndx < numTexUnits; ndx++) { + gl.activeTexture(gl.TEXTURE0 + ndx); + + // Reset 2D texture + gl.bindTexture(gl.TEXTURE_2D, null); + + // Reset cube map texture + gl.bindTexture(gl.TEXTURE_CUBE_MAP, null); + + // Reset 2D array texture + gl.bindTexture(gl.TEXTURE_2D_ARRAY, null); + + // Reset 3D texture + gl.bindTexture(gl.TEXTURE_3D, null); + } + + gl.activeTexture(gl.TEXTURE0); + } + + // Pixel operations + { + gl.disable(gl.SCISSOR_TEST); + gl.disable(gl.BLEND); + } + + // Framebuffer control + { + gl.clearColor(0.0, 0.0, 0.0, 0.0); + } + }; + +/** + * @constructor + * @extends {es3fFboColorbufferTests.FboColorbufferCase} + * @param {string} name + * @param {string} desc + * @param {number} format + * @param {number} width + * @param {number} height + */ +es3fFboColorbufferTests.FboColorClearCase = function(name, desc, format, width, height) { + es3fFboColorbufferTests.FboColorbufferCase.call(this, name, desc, format); + this.m_width = width; + this.m_height = height; +}; + +setParentClass(es3fFboColorbufferTests.FboColorClearCase, es3fFboColorbufferTests.FboColorbufferCase); + +es3fFboColorbufferTests.FboColorClearCase.prototype.preCheck = function() { + this.checkFormatSupport(this.m_format); + return true; // No exception thrown + }; + +es3fFboColorbufferTests.FboColorClearCase.prototype.render = function(dst) { + var ctx = this.getCurrentContext(); + var fboFormat = gluTextureUtil.mapGLInternalFormat(this.m_format); + var fmtClass = tcuTexture.getTextureChannelClass(fboFormat.type); + var fmtInfo = tcuTextureUtil.getTextureFormatInfo(fboFormat); + var rnd = new deRandom.Random(17); + var numClears = 16; + + var fbo = ctx.createFramebuffer(); + var rbo = ctx.createRenderbuffer(); + + ctx.bindRenderbuffer(gl.RENDERBUFFER, rbo); + ctx.renderbufferStorage(gl.RENDERBUFFER, this.m_format, this.m_width, this.m_height); + this.checkError(); + + ctx.bindFramebuffer(gl.FRAMEBUFFER, fbo); + ctx.framebufferRenderbuffer(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.RENDERBUFFER, rbo); + this.checkError(); + this.checkFramebufferStatus(gl.FRAMEBUFFER); + + ctx.viewport(0, 0, this.m_width, this.m_height); + + // Initialize to transparent black. + switch (fmtClass) { + case tcuTexture.TextureChannelClass.FLOATING_POINT: + case tcuTexture.TextureChannelClass.SIGNED_FIXED_POINT: + case tcuTexture.TextureChannelClass.UNSIGNED_FIXED_POINT: + ctx.clearBufferfv(gl.COLOR, 0, new Float32Array(4)); + break; + + case tcuTexture.TextureChannelClass.UNSIGNED_INTEGER: + ctx.clearBufferuiv(gl.COLOR, 0, new Uint32Array(4)); + break; + + case tcuTexture.TextureChannelClass.SIGNED_INTEGER: + ctx.clearBufferiv(gl.COLOR, 0, new Int32Array(4)); + break; + + default: + throw new Error('Invalid channelclass ' + fmtClass); + } + + // Do random scissored clears. + ctx.enable(gl.SCISSOR_TEST); + for (var ndx = 0; ndx < numClears; ndx++) { + var x = rnd.getInt(0, this.m_width - 1); + var y = rnd.getInt(0, this.m_height - 1); + var w = rnd.getInt(1, this.m_width - x); + var h = rnd.getInt(1, this.m_height - y); + var color = es3fFboColorbufferTests.randomVector(rnd, fmtInfo.valueMin, fmtInfo.valueMax); + + ctx.scissor(x, y, w, h); + + switch (fmtClass) { + case tcuTexture.TextureChannelClass.FLOATING_POINT: + case tcuTexture.TextureChannelClass.SIGNED_FIXED_POINT: + case tcuTexture.TextureChannelClass.UNSIGNED_FIXED_POINT: + ctx.clearBufferfv(gl.COLOR, 0, color); + break; + + case tcuTexture.TextureChannelClass.UNSIGNED_INTEGER: + ctx.clearBufferuiv(gl.COLOR, 0, color); + break; + + case tcuTexture.TextureChannelClass.SIGNED_INTEGER: + ctx.clearBufferiv(gl.COLOR, 0, color); + break; + + default: + throw new Error('Invalid channelclass ' + fmtClass); + } + } + + // Read results from renderbuffer. + this.readPixelsUsingFormat(dst, 0, 0, this.m_width, this.m_height, fboFormat, fmtInfo.lookupScale, fmtInfo.lookupBias); + this.checkError(); + }; + +/** + * @constructor + * @extends {es3fFboColorbufferTests.FboColorbufferCase} + * @param {string} name + * @param {string} desc + * @param {number} tex0Fmt + * @param {Array<number>} tex0Size + * @param {number} tex1Fmt + * @param {Array<number>} tex1Size + */ +es3fFboColorbufferTests.FboColorMultiTex2DCase = function(name, desc, tex0Fmt, tex0Size, tex1Fmt, tex1Size) { + es3fFboColorbufferTests.FboColorbufferCase.call(this, name, desc, tex0Fmt); + this.m_tex0Fmt = tex0Fmt; + this.m_tex0Size = tex0Size; + this.m_tex1Fmt = tex1Fmt; + this.m_tex1Size = tex1Size; +}; + +setParentClass(es3fFboColorbufferTests.FboColorMultiTex2DCase, es3fFboColorbufferTests.FboColorbufferCase); + +es3fFboColorbufferTests.FboColorMultiTex2DCase.prototype.preCheck = function() { + this.checkFormatSupport(this.m_tex0Fmt); + this.checkFormatSupport(this.m_tex1Fmt); + return true; // No exception thrown + }; + +es3fFboColorbufferTests.FboColorMultiTex2DCase.prototype.render = function(dst) { + var ctx = this.getCurrentContext(); + var texFmt0 = gluTextureUtil.mapGLInternalFormat(this.m_tex0Fmt); + var texFmt1 = gluTextureUtil.mapGLInternalFormat(this.m_tex1Fmt); + var fmtInfo0 = tcuTextureUtil.getTextureFormatInfo(texFmt0); + var fmtInfo1 = tcuTextureUtil.getTextureFormatInfo(texFmt1); + + /** @type {es3fFboTestUtil.Texture2DShader} */ + var texToFbo0Shader = new es3fFboTestUtil.Texture2DShader( + [gluShaderUtil.DataType.SAMPLER_2D], es3fFboTestUtil.getFragmentOutputType(texFmt0), + deMath.subtract(fmtInfo0.valueMax, fmtInfo0.valueMin), + fmtInfo0.valueMin); + + /** @type {es3fFboTestUtil.Texture2DShader} */ + var texToFbo1Shader = new es3fFboTestUtil.Texture2DShader( + [gluShaderUtil.DataType.SAMPLER_2D], es3fFboTestUtil.getFragmentOutputType(texFmt1), + deMath.subtract(fmtInfo1.valueMax, fmtInfo1.valueMin), + fmtInfo1.valueMin); + + /** @type {es3fFboTestUtil.Texture2DShader} */ + var multiTexShader = new es3fFboTestUtil.Texture2DShader( + [gluTextureUtil.getSampler2DType(texFmt0), gluTextureUtil.getSampler2DType(texFmt1)], + gluShaderUtil.DataType.FLOAT_VEC4); + + var texToFbo0ShaderID = ctx.createProgram(texToFbo0Shader); + var texToFbo1ShaderID = ctx.createProgram(texToFbo1Shader); + var multiTexShaderID = ctx.createProgram(multiTexShader); + + // Setup shaders + multiTexShader.setTexScaleBias(0, deMath.scale(fmtInfo0.lookupScale, 0.5), deMath.scale(fmtInfo0.lookupBias, 0.5)); + multiTexShader.setTexScaleBias(1, deMath.scale(fmtInfo1.lookupScale, 0.5), deMath.scale(fmtInfo1.lookupBias, 0.5)); + texToFbo0Shader.setUniforms(ctx, texToFbo0ShaderID); + texToFbo1Shader.setUniforms(ctx, texToFbo1ShaderID); + multiTexShader.setUniforms(ctx, multiTexShaderID); + + var fbo0 = ctx.createFramebuffer(); + var fbo1 = ctx.createFramebuffer(); + var tex0 = ctx.createTexture(); + var tex1 = ctx.createTexture(); + + for (var ndx = 0; ndx < 2; ndx++) { + var transferFmt = gluTextureUtil.getTransferFormat(ndx ? texFmt1 : texFmt0); + var format = ndx ? this.m_tex1Fmt : this.m_tex0Fmt; + var isFilterable = gluTextureUtil.isGLInternalColorFormatFilterable(format); + var size = ndx ? this.m_tex1Size : this.m_tex0Size; + var fbo = ndx ? fbo1 : fbo0; + var tex = ndx ? tex1 : tex0; + + ctx.bindTexture(gl.TEXTURE_2D, tex); + ctx.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE); + ctx.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE); + ctx.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, isFilterable ? gl.LINEAR : gl.NEAREST); + ctx.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, isFilterable ? gl.LINEAR : gl.NEAREST); + ctx.texImage2D(gl.TEXTURE_2D, 0, format, size[0], size[1], 0, transferFmt.format, transferFmt.dataType, null); + + ctx.bindFramebuffer(gl.FRAMEBUFFER, fbo); + ctx.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, tex, 0); + this.checkError(); + this.checkFramebufferStatus(gl.FRAMEBUFFER); + } + + // Render textures to both framebuffers. + for (var ndx = 0; ndx < 2; ndx++) { + var format = gl.RGBA; + var dataType = gl.UNSIGNED_BYTE; + var tmpTex; + var fbo = ndx ? fbo1 : fbo0; + var viewport = ndx ? this.m_tex1Size : this.m_tex0Size; + var data = new tcuTexture.TextureLevel(gluTextureUtil.mapGLTransferFormat(format, dataType), texW, texH, 1); + + if (ndx == 0) + tcuTextureUtil.fillWithComponentGradients(data.getAccess(), [0, 0, 0, 0], [1, 1, 1, 1]); + else + tcuTextureUtil.fillWithGrid(data.getAccess(), 8, [0.2, 0.7, 0.1, 1.0], [0.7, 0.1, 0.5, 0.8]); + + tmpTex = ctx.createTexture(); + ctx.bindTexture(gl.TEXTURE_2D, tmpTex); + ctx.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE); + ctx.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE); + ctx.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR); + ctx.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR); + ctx.texImage2D(gl.TEXTURE_2D, 0, format, texW, texH, 0, format, dataType, data.getAccess().getDataPtr()); + + ctx.bindFramebuffer(gl.FRAMEBUFFER, fbo); + ctx.viewport(0, 0, viewport[0], viewport[1]); + rrUtil.drawQuad(ctx, ndx ? texToFbo1ShaderID : texToFbo0ShaderID, [-1.0, -1.0, 0.0], [1.0, 1.0, 0.0]); + } + + // Render to framebuffer. + ctx.bindFramebuffer(gl.FRAMEBUFFER, null); + ctx.viewport(0, 0, ctx.getWidth(), ctx.getHeight()); + ctx.activeTexture(gl.TEXTURE0); + ctx.bindTexture(gl.TEXTURE_2D, tex0); + ctx.activeTexture(gl.TEXTURE1); + ctx.bindTexture(gl.TEXTURE_2D, tex1); + rrUtil.drawQuad(ctx, multiTexShaderID, [-1.0, -1.0, 0.0], [1.0, 1.0, 0.0]); + + this.readPixels(dst, 0, 0, ctx.getWidth(), ctx.getHeight()); + }; + +/** + * @constructor + * @extends {es3fFboColorbufferTests.FboColorbufferCase} + * @param {string} name + * @param {string} desc + * @param {number} texFmt + * @param {Array<number>} texSize + */ +es3fFboColorbufferTests.FboColorTexCubeCase = function(name, desc, texFmt, texSize) { + es3fFboColorbufferTests.FboColorbufferCase.call(this, name, desc, texFmt); + this.m_texSize = texSize; +}; + +setParentClass(es3fFboColorbufferTests.FboColorTexCubeCase, es3fFboColorbufferTests.FboColorbufferCase); + +es3fFboColorbufferTests.FboColorTexCubeCase.prototype.preCheck = function() { + this.checkFormatSupport(this.m_format); + return true; // No exception thrown + }; + +es3fFboColorbufferTests.FboColorTexCubeCase.prototype.render = function(dst) { + var ctx = this.getCurrentContext(); + var texFmt = gluTextureUtil.mapGLInternalFormat(this.m_format); + var fmtInfo = tcuTextureUtil.getTextureFormatInfo(texFmt); + + var cubeGLFaces = [ + gl.TEXTURE_CUBE_MAP_POSITIVE_X, + gl.TEXTURE_CUBE_MAP_POSITIVE_Y, + gl.TEXTURE_CUBE_MAP_POSITIVE_Z, + gl.TEXTURE_CUBE_MAP_NEGATIVE_X, + gl.TEXTURE_CUBE_MAP_NEGATIVE_Y, + gl.TEXTURE_CUBE_MAP_NEGATIVE_Z + ]; + + var cubeTexFaces = [ + tcuTexture.CubeFace.CUBEFACE_POSITIVE_X, + tcuTexture.CubeFace.CUBEFACE_POSITIVE_Y, + tcuTexture.CubeFace.CUBEFACE_POSITIVE_Z, + tcuTexture.CubeFace.CUBEFACE_NEGATIVE_X, + tcuTexture.CubeFace.CUBEFACE_NEGATIVE_Y, + tcuTexture.CubeFace.CUBEFACE_NEGATIVE_Z + ]; + + var rnd = new deRandom.Random(21); + + /** @type {es3fFboTestUtil.Texture2DShader} */ + var texToFboShader = new es3fFboTestUtil.Texture2DShader( + [gluShaderUtil.DataType.SAMPLER_2D], es3fFboTestUtil.getFragmentOutputType(texFmt), + deMath.subtract(fmtInfo.valueMax, fmtInfo.valueMin), + fmtInfo.valueMin); + + /** @type {es3fFboTestUtil.TextureCubeShader} */ + var cubeTexShader = new es3fFboTestUtil.TextureCubeShader( + gluTextureUtil.getSamplerCubeType(texFmt), + gluShaderUtil.DataType.FLOAT_VEC4); + + var texToFboShaderID = ctx.createProgram(texToFboShader); + var cubeTexShaderID = ctx.createProgram(cubeTexShader); + + // Setup shaders + texToFboShader.setUniforms(ctx, texToFboShaderID); + cubeTexShader.setTexScaleBias(fmtInfo.lookupScale, fmtInfo.lookupBias); + + // Framebuffers. + var fbos = []; + var tex; + + var transferFmt = gluTextureUtil.getTransferFormat(texFmt); + var isFilterable = gluTextureUtil.isGLInternalColorFormatFilterable(this.m_format); + var size = this.m_texSize; + + tex = ctx.createTexture(); + + ctx.bindTexture(gl.TEXTURE_CUBE_MAP, tex); + ctx.texParameteri(gl.TEXTURE_CUBE_MAP, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE); + ctx.texParameteri(gl.TEXTURE_CUBE_MAP, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE); + ctx.texParameteri(gl.TEXTURE_CUBE_MAP, gl.TEXTURE_MIN_FILTER, isFilterable ? gl.LINEAR : gl.NEAREST); + ctx.texParameteri(gl.TEXTURE_CUBE_MAP, gl.TEXTURE_MAG_FILTER, isFilterable ? gl.LINEAR : gl.NEAREST); + + // Generate an image and FBO for each cube face + for (var ndx = 0; ndx < cubeGLFaces.length; ndx++) + ctx.texImage2D(cubeGLFaces[ndx], 0, this.m_format, size[0], size[1], 0, transferFmt.format, transferFmt.dataType, null); + this.checkError(); + + for (var ndx = 0; ndx < cubeGLFaces.length; ndx++) { + var layerFbo = ctx.createFramebuffer(); + ctx.bindFramebuffer(gl.FRAMEBUFFER, layerFbo); + ctx.framebufferTexture2D(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, cubeGLFaces[ndx], tex, 0); + this.checkError(); + this.checkFramebufferStatus(gl.FRAMEBUFFER); + + fbos.push(layerFbo); + } + + // Render test images to random cube faces + var order = []; + + for (var n = 0; n < fbos.length; n++) + order.push(n); + rnd.shuffle(order); + + for (var ndx = 0; ndx < 4; ndx++) { + var face = order[ndx]; + var format = gl.RGBA; + var dataType = gl.UNSIGNED_BYTE; + var tmpTex; + var fbo = fbos[face]; + var viewport = this.m_texSize; + var data = new tcuTexture.TextureLevel(gluTextureUtil.mapGLTransferFormat(format, dataType), texW, texH, 1); + + tcuTextureUtil.fillWithGrid(data.getAccess(), 8, es3fFboColorbufferTests.generateRandomColor(rnd), [0, 0, 0, 0]); + + tmpTex = ctx.createTexture(); + ctx.bindTexture(gl.TEXTURE_2D, tmpTex); + ctx.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE); + ctx.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE); + ctx.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR); + ctx.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR); + ctx.texImage2D(gl.TEXTURE_2D, 0, format, texW, texH, 0, format, dataType, data.getAccess().getDataPtr()); + + ctx.bindFramebuffer(gl.FRAMEBUFFER, fbo); + ctx.viewport(0, 0, viewport[0], viewport[1]); + rrUtil.drawQuad(ctx, texToFboShaderID, [-1.0, -1.0, 0.0], [1.0, 1.0, 0.0]); + this.checkError(); + + // Render to framebuffer + var p0 = [(ndx % 2) - 1.0, Math.floor(ndx / 2) - 1.0, 0.0]; + var p1 = deMath.add(p0, [1.0, 1.0, 0.0]); + + ctx.bindFramebuffer(gl.FRAMEBUFFER, null); + ctx.viewport(0, 0, ctx.getWidth(), ctx.getHeight()); + + ctx.activeTexture(gl.TEXTURE0); + ctx.bindTexture(gl.TEXTURE_CUBE_MAP, tex); + + cubeTexShader.setFace(cubeTexFaces[face]); + cubeTexShader.setUniforms(ctx, cubeTexShaderID); + + rrUtil.drawQuad(ctx, cubeTexShaderID, p0, p1); + this.checkError(); + } + + this.readPixels(dst, 0, 0, ctx.getWidth(), ctx.getHeight()); + }; + +/** + * @constructor + * @extends {es3fFboColorbufferTests.FboColorbufferCase} + * @param {string} name + * @param {string} desc + * @param {number} texFmt + * @param {Array<number>} texSize + */ +es3fFboColorbufferTests.FboColorTex2DArrayCase = function(name, desc, texFmt, texSize) { + es3fFboColorbufferTests.FboColorbufferCase.call(this, name, desc, texFmt); + this.m_texSize = texSize; +}; + +setParentClass(es3fFboColorbufferTests.FboColorTex2DArrayCase, es3fFboColorbufferTests.FboColorbufferCase); + +es3fFboColorbufferTests.FboColorTex2DArrayCase.prototype.preCheck = function() { + this.checkFormatSupport(this.m_format); + return true; // No exception thrown + }; + + es3fFboColorbufferTests.FboColorTex2DArrayCase.prototype.render = function(dst) { + var ctx = this.getCurrentContext(); + var texFmt = gluTextureUtil.mapGLInternalFormat(this.m_format); + var fmtInfo = tcuTextureUtil.getTextureFormatInfo(texFmt); + var rnd = new deRandom.Random(100); + + /** @type {es3fFboTestUtil.Texture2DShader} */ + var texToFboShader = new es3fFboTestUtil.Texture2DShader( + [gluShaderUtil.DataType.SAMPLER_2D], es3fFboTestUtil.getFragmentOutputType(texFmt), + deMath.subtract(fmtInfo.valueMax, fmtInfo.valueMin), + fmtInfo.valueMin); + + /** @type {es3fFboTestUtil.Texture2DArrayShader} */ + var arrayTexShader = new es3fFboTestUtil.Texture2DArrayShader( + gluTextureUtil.getSampler2DArrayType(texFmt), + gluShaderUtil.DataType.FLOAT_VEC4); + + var texToFboShaderID = ctx.createProgram(texToFboShader); + var arrayTexShaderID = ctx.createProgram(arrayTexShader); + + // Setup textures + texToFboShader.setUniforms(ctx, texToFboShaderID); + arrayTexShader.setTexScaleBias(fmtInfo.lookupScale, fmtInfo.lookupBias); + + // Framebuffers. + var fbos = []; + var tex; + + var transferFmt = gluTextureUtil.getTransferFormat(texFmt); + var isFilterable = gluTextureUtil.isGLInternalColorFormatFilterable(this.m_format); + var size = this.m_texSize; + + tex = ctx.createTexture(); + + ctx.bindTexture(gl.TEXTURE_2D_ARRAY, tex); + ctx.texParameteri(gl.TEXTURE_2D_ARRAY, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE); + ctx.texParameteri(gl.TEXTURE_2D_ARRAY, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE); + ctx.texParameteri(gl.TEXTURE_2D_ARRAY, gl.TEXTURE_WRAP_R, gl.CLAMP_TO_EDGE); + ctx.texParameteri(gl.TEXTURE_2D_ARRAY, gl.TEXTURE_MIN_FILTER, isFilterable ? gl.LINEAR : gl.NEAREST); + ctx.texParameteri(gl.TEXTURE_2D_ARRAY, gl.TEXTURE_MAG_FILTER, isFilterable ? gl.LINEAR : gl.NEAREST); + ctx.texImage3D(gl.TEXTURE_2D_ARRAY, 0, this.m_format, size[0], size[1], size[2], 0, transferFmt.format, transferFmt.dataType, null); + + // Generate an FBO for each layer + for (var ndx = 0; ndx < this.m_texSize[2]; ndx++) { + var layerFbo = ctx.createFramebuffer(); + ctx.bindFramebuffer(gl.FRAMEBUFFER, layerFbo); + ctx.framebufferTextureLayer(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, tex, 0, ndx); + this.checkError(); + this.checkFramebufferStatus(gl.FRAMEBUFFER); + + fbos.push(layerFbo); + } + + // Render test images to random texture layers + var order = []; + + for (var n = 0; n < fbos.length; n++) + order.push(n); + rnd.shuffle(order); + + for (var ndx = 0; ndx < 4; ndx++) { + var layer = order[ndx]; + var format = gl.RGBA; + var dataType = gl.UNSIGNED_BYTE; + var fbo = fbos[layer]; + var viewport = this.m_texSize; + var data = new tcuTexture.TextureLevel(gluTextureUtil.mapGLTransferFormat(format, dataType), texW, texH, 1); + + tcuTextureUtil.fillWithGrid(data.getAccess(), 8, es3fFboColorbufferTests.generateRandomColor(rnd), [0, 0, 0, 0]); + + var tmpTex = ctx.createTexture(); + ctx.bindTexture(gl.TEXTURE_2D, tmpTex); + ctx.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE); + ctx.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE); + ctx.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR); + ctx.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR); + ctx.texImage2D(gl.TEXTURE_2D, 0, format, texW, texH, 0, format, dataType, data.getAccess().getDataPtr()); + + ctx.bindFramebuffer(gl.FRAMEBUFFER, fbo); + ctx.viewport(0, 0, viewport[0], viewport[1]); + rrUtil.drawQuad(ctx, texToFboShaderID, [-1.0, -1.0, 0.0], [1.0, 1.0, 0.0]); + this.checkError(); + + // Render to framebuffer + var p0 = [(ndx % 2) - 1.0, Math.floor(ndx / 2) - 1.0, 0.0]; + var p1 = deMath.add(p0, [1.0, 1.0, 0.0]); + debug('Layer:' + layer + ' rectangle: ' + p0 + ' ' + p1); + + ctx.bindFramebuffer(gl.FRAMEBUFFER, null); + ctx.viewport(0, 0, ctx.getWidth(), ctx.getHeight()); + + ctx.activeTexture(gl.TEXTURE0); + ctx.bindTexture(gl.TEXTURE_2D_ARRAY, tex); + + arrayTexShader.setLayer(layer); + arrayTexShader.setUniforms(ctx, arrayTexShaderID); + + rrUtil.drawQuad(ctx, arrayTexShaderID, p0, p1); + this.checkError(); + } + + this.readPixels(dst, 0, 0, ctx.getWidth(), ctx.getHeight()); + }; + +/** + * @constructor + * @extends {es3fFboColorbufferTests.FboColorbufferCase} + * @param {string} name + * @param {string} desc + * @param {number} texFmt + * @param {Array<number>} texSize + */ +es3fFboColorbufferTests.FboColorTex3DCase = function(name, desc, texFmt, texSize) { + es3fFboColorbufferTests.FboColorbufferCase.call(this, name, desc, texFmt); + this.m_texSize = texSize; +}; + +setParentClass(es3fFboColorbufferTests.FboColorTex3DCase, es3fFboColorbufferTests.FboColorbufferCase); + +es3fFboColorbufferTests.FboColorTex3DCase.prototype.preCheck = function() { + this.checkFormatSupport(this.m_format); + return true; // No exception thrown + }; + + es3fFboColorbufferTests.FboColorTex3DCase.prototype.render = function(dst) { + var ctx = this.getCurrentContext(); + var texFmt = gluTextureUtil.mapGLInternalFormat(this.m_format); + var fmtInfo = tcuTextureUtil.getTextureFormatInfo(texFmt); + var rnd = new deRandom.Random(100); + + /** @type {es3fFboTestUtil.Texture2DShader} */ + var texToFboShader = new es3fFboTestUtil.Texture2DShader( + [gluShaderUtil.DataType.SAMPLER_2D], es3fFboTestUtil.getFragmentOutputType(texFmt), + deMath.subtract(fmtInfo.valueMax, fmtInfo.valueMin), + fmtInfo.valueMin); + + /** @type {es3fFboTestUtil.Texture3DShader} */ + var tdTexShader = new es3fFboTestUtil.Texture3DShader( + gluTextureUtil.getSampler3D(texFmt), + gluShaderUtil.DataType.FLOAT_VEC4); + + var texToFboShaderID = ctx.createProgram(texToFboShader); + var tdTexShaderID = ctx.createProgram(tdTexShader); + + // Setup textures + texToFboShader.setUniforms(ctx, texToFboShaderID); + tdTexShader.setTexScaleBias(fmtInfo.lookupScale, fmtInfo.lookupBias); + + // Framebuffers. + var fbos = []; + var tex;{ + var transferFmt = gluTextureUtil.getTransferFormat(texFmt); + var size = this.m_texSize; + + tex = ctx.createTexture(); + + ctx.bindTexture(gl.TEXTURE_3D, tex); + ctx.texParameteri(gl.TEXTURE_3D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE); + ctx.texParameteri(gl.TEXTURE_3D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE); + ctx.texParameteri(gl.TEXTURE_3D, gl.TEXTURE_WRAP_R, gl.CLAMP_TO_EDGE); + ctx.texParameteri(gl.TEXTURE_3D, gl.TEXTURE_MIN_FILTER, gl.NEAREST); + ctx.texParameteri(gl.TEXTURE_3D, gl.TEXTURE_MAG_FILTER, gl.NEAREST); + ctx.texImage3D(gl.TEXTURE_3D, 0, this.m_format, size[0], size[1], size[2], 0, transferFmt.format, transferFmt.dataType, null); + + // Generate an FBO for each layer + for (var ndx = 0; ndx < this.m_texSize[2]; ndx++) { + var layerFbo = ctx.createFramebuffer(); + ctx.bindFramebuffer(gl.FRAMEBUFFER, layerFbo); + ctx.framebufferTextureLayer(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, tex, 0, ndx); + this.checkError(); + this.checkFramebufferStatus(gl.FRAMEBUFFER); + + fbos.push(layerFbo); + } + } + + // Render test images to random texture layers + var order = []; + + for (var n = 0; n < fbos.length; n++) + order.push(n); + rnd.shuffle(order); + + for (var ndx = 0; ndx < 4; ndx++) { + var layer = order[ndx]; + var format = gl.RGBA; + var dataType = gl.UNSIGNED_BYTE; + var fbo = fbos[layer]; + var viewport = this.m_texSize; + var data = new tcuTexture.TextureLevel(gluTextureUtil.mapGLTransferFormat(format, dataType), texW, texH, 1); + + tcuTextureUtil.fillWithGrid(data.getAccess(), 8, es3fFboColorbufferTests.generateRandomColor(rnd), [0, 0, 0, 0]); + + var tmpTex = ctx.createTexture(); + ctx.bindTexture(gl.TEXTURE_2D, tmpTex); + ctx.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE); + ctx.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE); + ctx.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR); + ctx.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR); + ctx.texImage2D(gl.TEXTURE_2D, 0, format, texW, texH, 0, format, dataType, data.getAccess().getDataPtr()); + + ctx.bindFramebuffer(gl.FRAMEBUFFER, fbo); + ctx.viewport(0, 0, viewport[0], viewport[1]); + rrUtil.drawQuad(ctx, texToFboShaderID, [-1.0, -1.0, 0.0], [1.0, 1.0, 0.0]); + this.checkError(); + + // Render to framebuffer + var p0 = [(ndx % 2) - 1.0, Math.floor(ndx / 2) - 1.0, 0.0]; + var p1 = deMath.add(p0, [1.0, 1.0, 0.0]); + debug('Layer:' + layer + ' rectangle: ' + p0 + ' ' + p1); + + ctx.bindFramebuffer(gl.FRAMEBUFFER, null); + ctx.viewport(0, 0, ctx.getWidth(), ctx.getHeight()); + + ctx.activeTexture(gl.TEXTURE0); + ctx.bindTexture(gl.TEXTURE_3D, tex); + + tdTexShader.setDepth(layer / (this.m_texSize[2] - 1)); + tdTexShader.setUniforms(ctx, tdTexShaderID); + + rrUtil.drawQuad(ctx, tdTexShaderID, p0, p1); + this.checkError(); + } + + this.readPixels(dst, 0, 0, ctx.getWidth(), ctx.getHeight()); +}; + +/** + * @constructor + * @extends {es3fFboColorbufferTests.FboColorbufferCase} + * @param {string} name + * @param {string} desc + * @param {number} format + * @param {Array<number>} size + * @param {number} funcRGB + * @param {number} funcAlpha + * @param {number} srcRGB + * @param {number} dstRGB + * @param {number} srcAlpha + * @param {number} dstAlpha + */ +es3fFboColorbufferTests.FboBlendCase = function(name, desc, format, size, funcRGB, funcAlpha, srcRGB, dstRGB, srcAlpha, dstAlpha) { + es3fFboColorbufferTests.FboColorbufferCase.call(this, name, desc, format); + this.m_size = size; + this.m_funcRGB = funcRGB; + this.m_funcAlpha = funcAlpha; + this.m_srcRGB = srcRGB; + this.m_dstRGB = dstRGB; + this.m_srcAlpha = srcAlpha; + this.m_dstAlpha = dstAlpha +}; + +setParentClass(es3fFboColorbufferTests.FboBlendCase, es3fFboColorbufferTests.FboColorbufferCase); + +es3fFboColorbufferTests.FboBlendCase.prototype.preCheck = function() { + this.checkFormatSupport(this.m_format); + return true; // No exception thrown + } + + es3fFboColorbufferTests.FboBlendCase.prototype.render = function(dst) { + // \note Assumes floating-point or fixed-point format. + var ctx = this.getCurrentContext(); + var fboFmt = gluTextureUtil.mapGLInternalFormat(this.m_format); + var fmtInfo = tcuTextureUtil.getTextureFormatInfo(fboFmt); + + /** @type {es3fFboTestUtil.Texture2DShader} */ + var texShader = new es3fFboTestUtil.Texture2DShader( + [gluShaderUtil.DataType.SAMPLER_2D], gluShaderUtil.DataType.FLOAT_VEC4); + + /** @type {es3fFboTestUtil.GradientShader} */ + var gradShader = new es3fFboTestUtil.GradientShader(gluShaderUtil.DataType.FLOAT_VEC4); + + var texShaderID = ctx.createProgram(texShader); + var gradShaderID = ctx.createProgram(gradShader); + + // Setup shaders + texShader.setUniforms (ctx, texShaderID); + gradShader.setGradient(ctx, gradShaderID, [0, 0, 0, 0], [1, 1, 1, 1]); + + var fbo = ctx.createFramebuffer(); + var rbo = ctx.createRenderbuffer(); + + ctx.bindRenderbuffer(gl.RENDERBUFFER, rbo); + ctx.renderbufferStorage(gl.RENDERBUFFER, this.m_format, this.m_size[0], this.m_size[1]); + this.checkError(); + + ctx.bindFramebuffer(gl.FRAMEBUFFER, fbo); + ctx.framebufferRenderbuffer(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.RENDERBUFFER, rbo); + this.checkError(); + this.checkFramebufferStatus(gl.FRAMEBUFFER); + + ctx.viewport(0, 0, this.m_size[0], this.m_size[1]); + + // Fill framebuffer with grid pattern. + var format = gl.RGBA; + var dataType = gl.UNSIGNED_BYTE; + var data = new tcuTexture.TextureLevel(gluTextureUtil.mapGLTransferFormat(format, dataType), texW, texH, 1); + + tcuTextureUtil.fillWithGrid(data.getAccess(), 8, [0.2, 0.7, 0.1, 1.0], [0.7, 0.1, 0.5, 0.8]); + + var gridTex = ctx.createTexture(); + ctx.bindTexture(gl.TEXTURE_2D, gridTex); + ctx.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE); + ctx.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE); + ctx.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR); + ctx.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR); + ctx.texImage2D(gl.TEXTURE_2D, 0, format, texW, texH, 0, format, dataType, data.getAccess().getDataPtr()); + + rrUtil.drawQuad(ctx, texShaderID, [-1.0, -1.0, 0.0], [1.0, 1.0, 0.0]); + this.checkError(); + + // Setup blend. + ctx.enable(gl.BLEND); + ctx.blendEquationSeparate(this.m_funcRGB, this.m_funcAlpha); + ctx.blendFuncSeparate(this.m_srcRGB, this.m_dstRGB, this.m_srcAlpha, this.m_dstAlpha); + + // Render gradient with blend. + rrUtil.drawQuad(ctx, gradShaderID, [-1.0, -1.0, 0.0], [1.0, 1.0, 0.0]); + + es3fFboTestUtil.readPixels(ctx, dst, 0, 0, this.m_size[0], this.m_size[1], fboFmt, [1, 1, 1, 1], [0, 0, 0, 0]); + }; + +/** + * @constructor + * @extends {tcuTestCase.DeqpTest} + */ +es3fFboColorbufferTests.FboColorbufferTests = function() { + tcuTestCase.DeqpTest.call(this, 'color', 'Colorbuffer tests'); +}; + +setParentClass(es3fFboColorbufferTests.FboColorbufferTests, tcuTestCase.DeqpTest); + +es3fFboColorbufferTests.FboColorbufferTests.prototype.init = function() { + var colorFormats = [ + // RGBA formats + gl.RGBA32I, + gl.RGBA32UI, + gl.RGBA16I, + gl.RGBA16UI, + gl.RGBA8, + gl.RGBA8I, + gl.RGBA8UI, + gl.SRGB8_ALPHA8, + gl.RGB10_A2, + gl.RGB10_A2UI, + gl.RGBA4, + gl.RGB5_A1, + + // RGB formats + gl.RGB8, + gl.RGB565, + + // RG formats + gl.RG32I, + gl.RG32UI, + gl.RG16I, + gl.RG16UI, + gl.RG8, + gl.RG8I, + gl.RG8UI, + + // R formats + gl.R32I, + gl.R32UI, + gl.R16I, + gl.R16UI, + gl.R8, + gl.R8I, + gl.R8UI, + + // gl.EXT_color_buffer_float + gl.RGBA32F, + gl.RGBA16F, + gl.R11F_G11F_B10F, + gl.RG32F, + gl.RG16F, + gl.R32F, + gl.R16F, + + // gl.EXT_color_buffer_half_float is not exposed in WebGL 2.0. + // gl.RGB16F + ]; + + // .clear + var clearGroup = tcuTestCase.newTest("clear", "Color clears"); + this.addChild(clearGroup); + + for (var ndx = 0; ndx < colorFormats.length; ndx++) { + clearGroup.addChild(new es3fFboColorbufferTests.FboColorClearCase( + es3fFboTestUtil.getFormatName(colorFormats[ndx]), "", colorFormats[ndx], texNpotSizeA[0], texNpotSizeA[1])); + } + + var numGroups = 6; + + // .tex2d + var tex2DGroup = []; + for (var ii = 0; ii < numGroups; ++ii) { + tex2DGroup[ii] = tcuTestCase.newTest("tex2d", "Texture 2D tests"); + this.addChild(tex2DGroup[ii]); + } + for (var ndx = 0; ndx < colorFormats.length; ndx++) { + tex2DGroup[ndx % numGroups].addChild(new es3fFboColorbufferTests.FboColorMultiTex2DCase( + es3fFboTestUtil.getFormatName(colorFormats[ndx]), "", colorFormats[ndx], texNpotSizeA, colorFormats[ndx], texNpotSizeB)); + } + + // .texcube + var texCubeGroup = []; + for (var ii = 0; ii < numGroups; ++ii) { + texCubeGroup[ii] = tcuTestCase.newTest("texcube", "Texture cube map tests"); + this.addChild(texCubeGroup[ii]); + } + for (var ndx = 0; ndx < colorFormats.length; ndx++) { + texCubeGroup[ndx % numGroups].addChild(new es3fFboColorbufferTests.FboColorTexCubeCase( + es3fFboTestUtil.getFormatName(colorFormats[ndx]), "", colorFormats[ndx], texPotSize)); + } + + // .tex2darray + var tex2DArrayGroup = []; + for (var ii = 0; ii < numGroups; ++ii) { + tex2DArrayGroup[ii] = tcuTestCase.newTest("tex2darray", "Texture 2D array tests"); + this.addChild(tex2DArrayGroup[ii]); + } + for (var ndx = 0; ndx < colorFormats.length; ndx++) { + tex2DArrayGroup[ndx % numGroups].addChild(new es3fFboColorbufferTests.FboColorTex2DArrayCase( + es3fFboTestUtil.getFormatName(colorFormats[ndx]), "", colorFormats[ndx], texPotSize)); + } + + // .tex3d + var tex3DGroup = []; + for (var ii = 0; ii < numGroups; ++ii) { + tex3DGroup[ii] = tcuTestCase.newTest("tex3d", "Texture 3D tests"); + this.addChild(tex3DGroup[ii]); + } + for (var ndx = 0; ndx < colorFormats.length; ndx++) { + tex3DGroup[ndx % numGroups].addChild(new es3fFboColorbufferTests.FboColorTex3DCase( + es3fFboTestUtil.getFormatName(colorFormats[ndx]), "", colorFormats[ndx], texPotSize)); + } + + // .blend + var blendGroup = tcuTestCase.newTest("blend", "Blending tests"); + this.addChild(blendGroup); + + for (var ndx = 0; ndx < colorFormats.length; ndx++) { + var format = colorFormats[ndx]; + var texFmt = gluTextureUtil.mapGLInternalFormat(format); + var fmtClass = tcuTexture.getTextureChannelClass(texFmt.type); + var fmtName = es3fFboTestUtil.getFormatName(format); + + if (texFmt.type == tcuTexture.ChannelType.FLOAT || + fmtClass == tcuTexture.TextureChannelClass.SIGNED_INTEGER || + fmtClass == tcuTexture.TextureChannelClass.UNSIGNED_INTEGER) + continue; // Blending is not supported. + + blendGroup.addChild(new es3fFboColorbufferTests.FboBlendCase(fmtName + "_src_over", "", format, + texNpotSizeA, gl.FUNC_ADD, gl.FUNC_ADD, gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA, gl.ZERO, gl.ONE)); + } +}; + +/** +* Run test +* @param {WebGL2RenderingContext} context +*/ +es3fFboColorbufferTests.run = function(context, range) { + gl = context; + + const canvas = gl.canvas; + canvas.width = canvasWH; + canvas.height = canvasWH; + + //Set up Test Root parameters + var state = tcuTestCase.runner; + state.setRoot(new es3fFboColorbufferTests.FboColorbufferTests()); + + //Set up name and description of this test series. + setCurrentTestName(state.testCases.fullName()); + description(state.testCases.getDescription()); + + try { + if (range) + state.setRange(range); + //Run test cases + tcuTestCase.runTestCases(); + } + catch (err) { + testFailedOptions('Failed to es3fFboColorbufferTests.run tests', false); + tcuTestCase.runner.terminate(); + } +}; + +}); |