diff options
Diffstat (limited to 'dom/canvas/test/webgl-conf/checkout/deqp/functional/gles3/es3fFragmentOutputTests.js')
| -rw-r--r-- | dom/canvas/test/webgl-conf/checkout/deqp/functional/gles3/es3fFragmentOutputTests.js | 1398 |
1 files changed, 1398 insertions, 0 deletions
diff --git a/dom/canvas/test/webgl-conf/checkout/deqp/functional/gles3/es3fFragmentOutputTests.js b/dom/canvas/test/webgl-conf/checkout/deqp/functional/gles3/es3fFragmentOutputTests.js new file mode 100644 index 0000000000..b27eee7a6e --- /dev/null +++ b/dom/canvas/test/webgl-conf/checkout/deqp/functional/gles3/es3fFragmentOutputTests.js @@ -0,0 +1,1398 @@ +/*------------------------------------------------------------------------- + * 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.es3fFragmentOutputTests'); +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.deMath'); +goog.require('framework.delibs.debase.deRandom'); +goog.require('framework.opengl.gluShaderProgram'); +goog.require('framework.opengl.gluShaderUtil'); +goog.require('framework.opengl.gluTextureUtil'); +goog.require('functional.gles3.es3fFboTestUtil'); + +goog.scope(function() { + +var es3fFragmentOutputTests = functional.gles3.es3fFragmentOutputTests; +var gluShaderProgram = framework.opengl.gluShaderProgram; +var es3fFboTestUtil = functional.gles3.es3fFboTestUtil; +var gluShaderUtil = framework.opengl.gluShaderUtil; +var deRandom = framework.delibs.debase.deRandom; +var tcuTestCase = framework.common.tcuTestCase; +var gluTextureUtil = framework.opengl.gluTextureUtil; +var tcuTexture = framework.common.tcuTexture; +var tcuTextureUtil = framework.common.tcuTextureUtil; +var deMath = framework.delibs.debase.deMath; +var tcuImageCompare = framework.common.tcuImageCompare; + + /** @type {WebGL2RenderingContext} */ var gl; + + var DE_ASSERT = function(x) { + if (!x) + throw new Error('Assert failed'); + }; + + /** + * es3fFragmentOutputTests.BufferSpec. Constructs the es3fFragmentOutputTests.BufferSpec object + * @constructor + * @param {WebGLRenderingContextBase.GLenum} format_ + * @param {number} width_ + * @param {number} height_ + * @param {number} samples_ + */ + es3fFragmentOutputTests.BufferSpec = function(format_, width_, height_, samples_) { + this.format = format_; + this.width = width_; + this.height = height_; + this.samples = samples_; + }; + + /** + * es3fFragmentOutputTests.FragmentOutput. Constructs the es3fFragmentOutputTests.FragmentOutput object + * @constructor + * @param {gluShaderUtil.DataType} type_ + * @param {gluShaderUtil.precision} precision_ + * @param {number} location_ + * @param {number=} arrayLength_ + */ + es3fFragmentOutputTests.FragmentOutput = function(type_, precision_, location_, arrayLength_) { + this.type = type_; + this.precision = precision_; + this.location = location_; + this.arrayLength = arrayLength_ || 0; + }; + + /** + * es3fFragmentOutputTests.FragmentOutputCase. Constructs the es3fFragmentOutputTests.FragmentOutputCase object + * @constructor + * @extends {tcuTestCase.DeqpTest} + * @param {string} name + * @param {string} description + * @param {Array<es3fFragmentOutputTests.BufferSpec>} fboSpec + * @param {Array<es3fFragmentOutputTests.FragmentOutput>} outputs + * @return {Object} The currently modified object + */ + es3fFragmentOutputTests.FragmentOutputCase = function(name, description, fboSpec, outputs) { + tcuTestCase.DeqpTest.call(this, name, description); + /** @type {Array<es3fFragmentOutputTests.BufferSpec>} */ this.m_fboSpec = fboSpec; + /** @type {Array<es3fFragmentOutputTests.FragmentOutput>} */ this.m_outputs = outputs; + /** @type {gluShaderProgram.ShaderProgram} */ this.m_program = null; + /** @type {WebGLFramebuffer} */ this.m_framebuffer = null; + + /** @type {WebGLRenderbuffer} */ this.m_renderbuffer = null; + }; + + es3fFragmentOutputTests.FragmentOutputCase.prototype = Object.create(tcuTestCase.DeqpTest.prototype); + es3fFragmentOutputTests.FragmentOutputCase.prototype.constructor = es3fFragmentOutputTests.FragmentOutputCase; + + /** + * es3fFragmentOutputTests.createProgram. Returns a ShaderProgram object + * @param {Array<es3fFragmentOutputTests.FragmentOutput>} outputs + * @return {gluShaderProgram.ShaderProgram} program + */ + es3fFragmentOutputTests.createProgram = function(outputs) { + + var vtx = ''; + var frag = ''; + + vtx = '#version 300 es\n' + 'in highp vec4 a_position;\n'; + frag = '#version 300 es\n'; + + /** @type {es3fFragmentOutputTests.FragmentOutput} */ var output = null; + /** @type {boolean} */ var isArray = false; + // Input-output declarations. + for (var outNdx = 0; outNdx < outputs.length; outNdx++) { + output = outputs[outNdx]; + isArray = output.arrayLength > 0; + /** @type {string} */ var typeName = gluShaderUtil.getDataTypeName(output.type); + /** @type {string} */ var precName = gluShaderUtil.getPrecisionName(output.precision); + /** @type {boolean} */ var isFloat = gluShaderUtil.isDataTypeFloatOrVec(output.type); + /** @type {string} */ var interp = isFloat ? 'smooth' : 'flat'; + + if (isArray) { + for (var elemNdx = 0; elemNdx < output.arrayLength; elemNdx++) { + vtx += 'in ' + precName + ' ' + typeName + ' in' + outNdx + '_' + elemNdx + ';\n' + + interp + ' out ' + precName + ' ' + typeName + ' var' + outNdx + '_' + elemNdx + ';\n'; + frag += interp + ' in ' + precName + ' ' + typeName + ' var' + outNdx + '_' + elemNdx + ';\n'; + } + frag += 'layout(location = ' + output.location + ') out ' + precName + ' ' + typeName + ' out' + outNdx + '[' + output.arrayLength + '];\n'; + } else { + vtx += 'in ' + precName + ' ' + typeName + ' in' + outNdx + ';\n' + + interp + ' out ' + precName + ' ' + typeName + ' var' + outNdx + ';\n'; + frag += interp + ' in ' + precName + ' ' + typeName + ' var' + outNdx + ';\n' + + 'layout(location = ' + output.location + ') out ' + precName + ' ' + typeName + ' out' + outNdx + ';\n'; + } + } + + vtx += '\nvoid main()\n{\n'; + frag += '\nvoid main()\n{\n'; + + vtx += ' gl_Position = a_position;\n'; + + // Copy body + for (var outNdx = 0; outNdx < outputs.length; outNdx++) { + output = outputs[outNdx]; + isArray = output.arrayLength > 0; + + if (isArray) { + for (var elemNdx = 0; elemNdx < output.arrayLength; elemNdx++) { + vtx += '\tvar' + outNdx + '_' + elemNdx + ' = in' + outNdx + '_' + elemNdx + ';\n'; + frag += '\tout' + outNdx + '[' + elemNdx + '] = var' + outNdx + '_' + elemNdx + ';\n'; + } + } else { + vtx += '\tvar' + outNdx + ' = in' + outNdx + ';\n'; + frag += '\tout' + outNdx + ' = var' + outNdx + ';\n'; + } + } + + vtx += '}\n'; + frag += '}\n'; + + /** @type {gluShaderProgram.ShaderProgram} */ + var program = new gluShaderProgram.ShaderProgram(gl, gluShaderProgram.makeVtxFragSources(vtx, frag)); + return program; + }; + + es3fFragmentOutputTests.FragmentOutputCase.prototype.init = function() { + // Check that all attachments are supported + for (var iter = 0; iter < this.m_fboSpec.length; ++iter) { + if (!gluTextureUtil.isSizedFormatColorRenderable(this.m_fboSpec[iter].format)) + throw new Error('Unsupported attachment format'); + } + + DE_ASSERT(!this.m_program); + this.m_program = es3fFragmentOutputTests.createProgram(this.m_outputs); + + // log << *m_program; + if (!this.m_program.isOk()) + throw new Error('Compile failed. Program no created'); + + /* + // Print render target info to log. + log << TestLog::Section("Framebuffer", "Framebuffer configuration"); + + for (int ndx = 0; ndx < (int)m_fboSpec.size(); ndx++) + log << TestLog::Message << "COLOR_ATTACHMENT" << ndx << ": " + << glu::getPixelFormatStr(m_fboSpec[ndx].format) << ", " + << m_fboSpec[ndx].width << "x" << m_fboSpec[ndx].height << ", " + << m_fboSpec[ndx].samples << " samples" + << TestLog::EndMessage; + + log << TestLog::EndSection;*/ + + // Create framebuffer. + this.m_framebuffer = gl.createFramebuffer(); + gl.bindFramebuffer(gl.FRAMEBUFFER, this.m_framebuffer); + + for (var bufNdx = 0; bufNdx < /* m_renderbuffers.size() */ this.m_fboSpec.length; bufNdx++) { + this.m_renderbuffer = gl.createRenderbuffer(); + /** @type {es3fFragmentOutputTests.BufferSpec} */ var bufSpec = this.m_fboSpec[bufNdx]; + /** @type {number} */ var attachment = gl.COLOR_ATTACHMENT0 + bufNdx; + + gl.bindRenderbuffer(gl.RENDERBUFFER, this.m_renderbuffer); + + gl.renderbufferStorageMultisample(gl.RENDERBUFFER, bufSpec.samples, bufSpec.format, bufSpec.width, bufSpec.height); + gl.framebufferRenderbuffer(gl.FRAMEBUFFER, attachment, gl.RENDERBUFFER, this.m_renderbuffer); + } + /** @type {number} */ var fboStatus = gl.checkFramebufferStatus(gl.FRAMEBUFFER); + + if (fboStatus == gl.FRAMEBUFFER_UNSUPPORTED) + throw new Error('Framebuffer not supported'); + else if (fboStatus != gl.FRAMEBUFFER_COMPLETE) + throw new Error('Incomplete framebuffer'); + // throw tcu::TestError((string("Incomplete framebuffer: ") + glu::getFramebufferStatusStr(fboStatus), "", __FILE__, __LINE__); + + // gl.bindRenderbuffer(gl.RENDERBUFFER, null); // TODO: maybe needed? + gl.bindFramebuffer(gl.FRAMEBUFFER, null); + }; + + es3fFragmentOutputTests.FragmentOutputCase.prototype.deinit = function() { + // TODO: implement? + }; + + /** + * es3fFragmentOutputTests.getMinSize. + * @param {Array<es3fFragmentOutputTests.BufferSpec>} fboSpec + * @return {Array<number>} minSize + */ + es3fFragmentOutputTests.getMinSize = function(fboSpec) { + /** @type {Array<number>} */ var minSize = [0x7fffffff, 0x7fffffff]; + for (var i = 0; i < fboSpec.length; i++) { + minSize[0] = Math.min(minSize[0], fboSpec[i].width); + minSize[1] = Math.min(minSize[1], fboSpec[i].height); + } + return minSize; + }; + + /** + * es3fFragmentOutputTests.getNumInputVectors. Returns the length of the array of all the outputs (es3fFragmentOutputTests.FragmentOutput object) + * @param {Array<es3fFragmentOutputTests.FragmentOutput>} outputs + * @return {number} numVecs + */ + es3fFragmentOutputTests.getNumInputVectors = function(outputs) { + /** @type {number} */ var numVecs = 0; + for (var i = 0; i < outputs.length; i++) + numVecs += (outputs[i].arrayLength > 0 ? outputs[i].arrayLength : 1); + return numVecs; + }; + + /** + * es3fFragmentOutputTests.getFloatRange + * @param {gluShaderUtil.precision} precision + * @return {Array<number>} Vec2 + */ + es3fFragmentOutputTests.getFloatRange = function(precision) { + /** @type {Array<Array<number>>} */ + var ranges = // Vec2 + [ + [-2.0, 2.0], + [-16000.0, 16000.0], + [-1e35, 1e35] + ]; + // DE_STATIC_ASSERT(DE_LENGTH_OF_ARRAY(ranges) == glu::PRECISION_LAST); + // DE_ASSERT(de::inBounds<int>(precision, 0, DE_LENGTH_OF_ARRAY(ranges))); + return ranges[precision]; + }; + + /** + * es3fFragmentOutputTests.getIntRange + * @param {gluShaderUtil.precision} precision + * @return {Array<number>} IVec2 + */ + es3fFragmentOutputTests.getIntRange = function(precision) { + /** @type {Array<Array<number>>} */ + var ranges = // IVec2 + [ + [-(1 << 7), (1 << 7) - 1], + [-(1 << 15), (1 << 15) - 1], + [-0x80000000, 0x7fffffff] + ]; + // DE_STATIC_ASSERT(DE_LENGTH_OF_ARRAY(ranges) == glu::PRECISION_LAST); + // DE_ASSERT(de::inBounds<int>(precision, 0, DE_LENGTH_OF_ARRAY(ranges))); + return ranges[precision]; + }; + + /** + * es3fFragmentOutputTests.getUintRange + * @param {gluShaderUtil.precision} precision + * @return {Array<number>} UVec2 + */ + es3fFragmentOutputTests.getUintRange = function(precision) { + /** @type {Array<Array<number>>} */ + var ranges = // UVec2 + [ + [0, (1 << 8) - 1], + [0, (1 << 16) - 1], + [0, 0xffffffff] + ]; + // DE_STATIC_ASSERT(DE_LENGTH_OF_ARRAY(ranges) == glu::PRECISION_LAST); + // DE_ASSERT(de::inBounds<int>(precision, 0, DE_LENGTH_OF_ARRAY(ranges))); + return ranges[precision]; + + }; + + /** + * es3fFragmentOutputTests.readVec4 + * @param {Array<number>} ptr + * @param {number} index + * @param {number} numComponents + * @return {Array<number>} Vec4 + */ + es3fFragmentOutputTests.readVec4 = function(ptr, index, numComponents) { + DE_ASSERT(numComponents >= 1); + return [ + ptr[index + 0], + numComponents >= 2 ? ptr[index + 1] : 0.0, + numComponents >= 3 ? ptr[index + 2] : 0.0, + numComponents >= 4 ? ptr[index + 3] : 0.0 + ]; + }; + + /** + * es3fFragmentOutputTests.readIVec4 + * @param {Array<number>} ptr + * @param {number} numComponents + * @return {Array<number>} IVec4 + */ + es3fFragmentOutputTests.readIVec4 = function(ptr, index, numComponents) { + DE_ASSERT(numComponents >= 1); + return [ + ptr[index + 0], + numComponents >= 2 ? ptr[index + 1] : 0, + numComponents >= 3 ? ptr[index + 2] : 0, + numComponents >= 4 ? ptr[index + 3] : 0 + ]; + }; + + /** + * es3fFragmentOutputTests.renderFloatReference + * @param {tcuTexture.PixelBufferAccess} dst + * @param {number} gridWidth + * @param {number} gridHeight + * @param {number} numComponents + * @param {Array<number>} vertices + */ + es3fFragmentOutputTests.renderFloatReference = function(dst, gridWidth, gridHeight, numComponents, vertices) { + + /** @type {boolean} */ var isSRGB = dst.getFormat().order == tcuTexture.ChannelOrder.sRGB || dst.getFormat().order == tcuTexture.ChannelOrder.sRGBA; + /** @type {number} */ var cellW = dst.getWidth() / (gridWidth - 1); + /** @type {number} */ var cellH = dst.getHeight() / (gridHeight - 1); + + for (var y = 0; y < dst.getHeight(); y++) { + for (var x = 0; x < dst.getWidth(); x++) { + /** @type {number} */ var cellX = deMath.clamp(Math.floor(x / cellW), 0, gridWidth - 2); + /** @type {number} */ var cellY = deMath.clamp(Math.floor(y / cellH), 0, gridHeight - 2); + /** @type {number} */ var xf = (x - cellX * cellW + 0.5) / cellW; + /** @type {number} */ var yf = (y - cellY * cellH + 0.5) / cellH; + + /** @type {Array<number>} */ var v00 = es3fFragmentOutputTests.readVec4(vertices, ((cellY + 0) * gridWidth + cellX + 0) * numComponents, numComponents); // Vec4 + /** @type {Array<number>} */ var v01 = es3fFragmentOutputTests.readVec4(vertices, ((cellY + 1) * gridWidth + cellX + 0) * numComponents, numComponents); // Vec4 + /** @type {Array<number>} */ var v10 = es3fFragmentOutputTests.readVec4(vertices, ((cellY + 0) * gridWidth + cellX + 1) * numComponents, numComponents); // Vec4 + /** @type {Array<number>} */ var v11 = es3fFragmentOutputTests.readVec4(vertices, ((cellY + 1) * gridWidth + cellX + 1) * numComponents, numComponents); // Vec4 + + /** @type {boolean} */ var tri = xf + yf >= 1.0; + /** @type {Array<number>} */ var v0 = tri ? v11 : v00; // Vec4& + /** @type {Array<number>} */ var v1 = tri ? v01 : v10; // Vec4& + /** @type {Array<number>} */ var v2 = tri ? v10 : v01; // Vec4& + /** @type {number} */ var s = tri ? 1.0 - xf : xf; + /** @type {number} */ var t = tri ? 1.0 - yf : yf; + /** @type {Array<number>} */ var color = deMath.add(v0, deMath.add(deMath.multiply((deMath.subtract(v1, v0)), [s, s, s, s]), deMath.multiply((deMath.subtract(v2, v0)), [t, t, t, t]))); // Vec4 + + dst.setPixel(isSRGB ? tcuTextureUtil.linearToSRGB(color) : color, x, y); + } + } + }; + + /** + * es3fFragmentOutputTests.renderIntReference + * @param {tcuTexture.PixelBufferAccess} dst + * @param {number} gridWidth + * @param {number} gridHeight + * @param {number} numComponents + * @param {Array<number>} vertices + */ + es3fFragmentOutputTests.renderIntReference = function(dst, gridWidth, gridHeight, numComponents, vertices) { + + /** @type {number} */ var cellW = dst.getWidth() / (gridWidth - 1); + /** @type {number} */ var cellH = dst.getHeight() / (gridHeight - 1); + + for (var y = 0; y < dst.getHeight(); y++) { + for (var x = 0; x < dst.getWidth(); x++) { + /** @type {number} */ var cellX = deMath.clamp(Math.floor(x / cellW), 0, gridWidth - 2); + /** @type {number} */ var cellY = deMath.clamp(Math.floor(y / cellH), 0, gridHeight - 2); + /** @type {Array<number>} */ var c = es3fFragmentOutputTests.readIVec4(vertices, (cellY * gridWidth + cellX + 1) * numComponents, numComponents); // IVec4 + + dst.setPixelInt(c, x, y); + } + } + }; + + /** + * es3fFragmentOutputTests.s_swizzles + * @return {Array<Array<number>>} + */ + es3fFragmentOutputTests.s_swizzles = function() { + var mat_swizzles = [ + [0, 1, 2, 3], + [1, 2, 3, 0], + [2, 3, 0, 1], + [3, 0, 1, 2], + [3, 2, 1, 0], + [2, 1, 0, 3], + [1, 0, 3, 2], + [0, 3, 2, 1] + ]; + + return mat_swizzles; + }; + + /** + * es3fFragmentOutputTests.swizzleVec. Returns an Array from a position contained in the Array es3fFragmentOutputTests.s_swizzles [] + * @param {Array<number>} vec + * @param {number} swzNdx + * @return {Array<number>} Swizzled array + */ + es3fFragmentOutputTests.swizzleVec = function(vec, swzNdx) { + /** @type {Array<number>} */ var swz = es3fFragmentOutputTests.s_swizzles()[swzNdx % es3fFragmentOutputTests.s_swizzles().length]; + + return deMath.swizzle(vec, swz); + }; + + /** + * es3fFragmentOutputTests.AttachmentData struct class + * @constructor + * @return {Object} + */ + es3fFragmentOutputTests.AttachmentData = function() { + return { + /** @type {tcuTexture.TextureFormat} */ format: null, //!< Actual format of attachment. + /** @type {tcuTexture.TextureFormat} */ referenceFormat: null, //!< Used for reference rendering. + /** @type {tcuTexture.TextureFormat} */ readFormat: null, + /** @type {number} */ numWrittenChannels: 0, + /** @type {gluShaderUtil.precision} */ outPrecision: gluShaderUtil.precision.PRECISION_LOWP, + /** @type {ArrayBuffer} */ renderedData: null, + /** @type {ArrayBuffer} */ referenceData: null + }; + }; + + es3fFragmentOutputTests.FragmentOutputCase.prototype.iterate = function() { + // Compute grid size & index list. + /** @type {number} */ var minCellSize = 8; + /** @type {Array<number>} */ var minBufSize = es3fFragmentOutputTests.getMinSize(this.m_fboSpec); // IVec2 + /** @type {number} */ var gridWidth = deMath.clamp(Math.floor(minBufSize[0] / minCellSize), 1, 255) + 1; + /** @type {number} */ var gridHeight = deMath.clamp(Math.floor(minBufSize[1] / minCellSize), 1, 255) + 1; + /** @type {number} */ var numVertices = gridWidth * gridHeight; + /** @type {number} */ var numQuads = (gridWidth - 1) * (gridHeight - 1); + /** @type {number} */ var numIndices = numQuads * 6; + + /** @type {number} */ var numInputVecs = es3fFragmentOutputTests.getNumInputVectors(this.m_outputs); + /** @type {Array<Array<number>>} */ var inputs = []; // originally vector<vector<deUint32> + + for (var inputNdx = 0; inputNdx < numInputVecs; inputNdx++) + inputs[inputNdx] = []; // inputs.length = numInputVecs; + + /** @type {Array<number>} */ var positions = []; // originally vector<float> + /** @type {Array<number>} */ var indices = []; // originally vector<deUint16> + + /** @type {number} */ var readAlignment = 4; + /** @type {number} */ var viewportW = minBufSize[0]; + /** @type {number} */ var viewportH = minBufSize[1]; + /** @type {number} */ var numAttachments = this.m_fboSpec.length; + + /** @type {Array<number>} */ var drawBuffers = []; // originally vector<deUint32> + /** @type {Array<es3fFragmentOutputTests.AttachmentData>} */ var attachments = []; + /** @type {number} */ var attachmentW; + /** @type {number} */ var attachmentH; + + // Initialize attachment data. + for (var ndx = 0; ndx < numAttachments; ndx++) { + /** @type {tcuTexture.TextureFormat} */ var texFmt = gluTextureUtil.mapGLInternalFormat(this.m_fboSpec[ndx].format); + /** @type {tcuTexture.TextureChannelClass} */ var chnClass = tcuTexture.getTextureChannelClass(texFmt.type); + /** @type {boolean} */ var isFixedPoint = (chnClass == tcuTexture.TextureChannelClass.SIGNED_FIXED_POINT || + chnClass == tcuTexture.TextureChannelClass.UNSIGNED_FIXED_POINT); + + // \note Fixed-point formats use float reference to enable more accurate result verification. + /** @type {tcuTexture.TextureFormat} */ var refFmt = isFixedPoint ? new tcuTexture.TextureFormat(texFmt.order, tcuTexture.ChannelType.FLOAT) : texFmt; + /** @type {tcuTexture.TextureFormat} */ var readFmt = es3fFboTestUtil.getFramebufferReadFormat(texFmt); + attachmentW = this.m_fboSpec[ndx].width; + attachmentH = this.m_fboSpec[ndx].height; + + drawBuffers[ndx] = gl.COLOR_ATTACHMENT0 + ndx; + attachments[ndx] = new es3fFragmentOutputTests.AttachmentData(); + attachments[ndx].format = texFmt; + attachments[ndx].readFormat = readFmt; + attachments[ndx].referenceFormat = refFmt; + attachments[ndx].renderedData = new ArrayBuffer(readFmt.getPixelSize() * attachmentW * attachmentH); + attachments[ndx].referenceData = new ArrayBuffer(refFmt.getPixelSize() * attachmentW * attachmentH); + } + + // Initialize indices. + for (var quadNdx = 0; quadNdx < numQuads; quadNdx++) { + /** @type {number} */ var quadY = Math.floor(quadNdx / (gridWidth - 1)); + /** @type {number} */ var quadX = quadNdx - quadY * (gridWidth - 1); + + indices[quadNdx * 6 + 0] = quadX + quadY * gridWidth; + indices[quadNdx * 6 + 1] = quadX + (quadY + 1) * gridWidth; + indices[quadNdx * 6 + 2] = quadX + quadY * gridWidth + 1; + indices[quadNdx * 6 + 3] = indices[quadNdx * 6 + 1]; + indices[quadNdx * 6 + 4] = quadX + (quadY + 1) * gridWidth + 1; + indices[quadNdx * 6 + 5] = indices[quadNdx * 6 + 2]; + } + + /** @type {number} */ var xf = 0; + /** @type {number} */ var yf = 0; + for (var y = 0; y < gridHeight; y++) { + for (var x = 0; x < gridWidth; x++) { + xf = x / (gridWidth - 1); + yf = y / (gridHeight - 1); + + positions[(y * gridWidth + x) * 4 + 0] = 2.0 * xf - 1.0; + positions[(y * gridWidth + x) * 4 + 1] = 2.0 * yf - 1.0; + positions[(y * gridWidth + x) * 4 + 2] = 0.0; + positions[(y * gridWidth + x) * 4 + 3] = 1.0; + } + } + /** @type {es3fFragmentOutputTests.FragmentOutput} */ var output; + /** @type {boolean} */ var isArray; + /** @type {boolean} */ var isFloat; + /** @type {boolean} */ var isInt; + /** @type {boolean} */ var isUint; + /** @type {number} */ var numVecs; + /** @type {number} */ var numScalars; + + var curInVec = 0; + for (var outputNdx = 0; outputNdx < this.m_outputs.length; outputNdx++) { + output = this.m_outputs[outputNdx]; + isFloat = gluShaderUtil.isDataTypeFloatOrVec(output.type); + isInt = gluShaderUtil.isDataTypeIntOrIVec(output.type); + isUint = gluShaderUtil.isDataTypeUintOrUVec(output.type); + numVecs = output.arrayLength > 0 ? output.arrayLength : 1; + numScalars = gluShaderUtil.getDataTypeScalarSize(output.type); + + for (var vecNdx = 0; vecNdx < numVecs; vecNdx++) { + inputs[curInVec].length = numVertices * numScalars; + + // Record how many outputs are written in attachment. + DE_ASSERT(output.location + vecNdx < attachments.length); + attachments[output.location + vecNdx].numWrittenChannels = numScalars; + attachments[output.location + vecNdx].outPrecision = output.precision; + + /** @type {Array<number>} */ var range = null; + /** @type {Array<number>} */ var minVal = null; + /** @type {Array<number>} */ var maxVal = null; + /** @type {Array<number>} */ var fmtBits = null; + /** @type {Array<number>} */ var fmtMaxVal = []; + /** @type {Array<number>} */ var rangeDiv = null; + /** @type {Array<number>} */ var step = []; + /** @type {number} */ var ix = 0; + /** @type {number} */ var iy = 0; + /** @type {Array<number>} */ var c = null; + /** @type {number} */ var pos = 0; + if (isFloat) { + range = es3fFragmentOutputTests.getFloatRange(output.precision); // Vec2 + minVal = [range[0], range[0], range[0], range[0]]; // Vec4 + maxVal = [range[1], range[1], range[1], range[1]]; // Vec4 + + if (deMath.deInBounds32(output.location + vecNdx, 0, attachments.length)) { + // \note Floating-point precision conversion is not well-defined. For that reason we must + // limit value range to intersection of both data type and render target value ranges. + /** @type {tcuTextureUtil.TextureFormatInfo} */ var fmtInfo = tcuTextureUtil.getTextureFormatInfo(attachments[output.location + vecNdx].format); + minVal = deMath.max(minVal, fmtInfo.valueMin); + maxVal = deMath.min(maxVal, fmtInfo.valueMax); + } + + bufferedLogToConsole('out ' + curInVec + ' value range: ' + minVal + ' -> ' + maxVal); + + for (var y = 0; y < gridHeight; y++) { + for (var x = 0; x < gridWidth; x++) { + xf = x / (gridWidth - 1); + yf = y / (gridHeight - 1); + /** @type {number} */ var f0 = (xf + yf) * 0.5; + /** @type {number} */ var f1 = 0.5 + (xf - yf) * 0.5; + + /** @type {Array<number>} */ var f = es3fFragmentOutputTests.swizzleVec([f0, f1, 1.0 - f0, 1.0 - f1], curInVec); // Vec4 + c = deMath.add(minVal, deMath.multiply(deMath.subtract(maxVal, minVal), f)); // Vec4 + + pos = (y * gridWidth + x) * numScalars; + + for (var ndx = 0; ndx < numScalars; ndx++) + inputs[curInVec][pos + ndx] = c[ndx]; + } + } + } else if (isInt) { + range = es3fFragmentOutputTests.getIntRange(output.precision); // IVec2 + minVal = [range[0], range[0], range[0], range[0]]; // IVec4 + maxVal = [range[1], range[1], range[1], range[1]]; // IVec4 + + if (deMath.deInBounds32(output.location + vecNdx, 0, attachments.length)) { + // Limit to range of output format as conversion mode is not specified. + fmtBits = tcuTextureUtil.getTextureFormatBitDepth(attachments[output.location + vecNdx].format); // IVec4 + /** @type {Array<boolean>} */ var isZero = deMath.lessThanEqual(fmtBits, [0, 0, 0, 0]); // BVec4, array of booleans, size = 4 + + /** @type {Array<number>} */ var fmtMinVal = []; // IVec4 + + for (var i = 0; i < 4; i++) { + + // const IVec4 fmtMinVal = (-(tcu::Vector<deInt64, 4>(1) << (fmtBits - 1 ).cast<deInt64>())).asInt(); + fmtMinVal[i] = -1 * Math.pow(2, fmtBits[i] - 1); // TODO: check implementation, original above + // const IVec4 fmtMaxVal = ((tcu::Vector<deInt64, 4>(1) << (fmtBits - 1 ).cast<deInt64>()) - deInt64(1)).asInt(); + fmtMaxVal[i] = Math.pow(2, fmtBits[i] - 1) - 1; // TODO: check implementation, original above + } + + minVal = tcuTextureUtil.select(minVal, deMath.max(minVal, fmtMinVal), isZero); + maxVal = tcuTextureUtil.select(maxVal, deMath.min(maxVal, fmtMaxVal), isZero); + } + + bufferedLogToConsole('out ' + curInVec + ' value range: ' + minVal + ' -> ' + maxVal); + + rangeDiv = es3fFragmentOutputTests.swizzleVec([gridWidth - 1, gridHeight - 1, gridWidth - 1, gridHeight - 1], curInVec); // IVec4 + for (var i = 0; i < 4; i++) { + // const IVec4 step = ((maxVal.cast<deInt64>() - minVal.cast<deInt64>()) / (rangeDiv.cast<deInt64>())).asInt(); + step[i] = Math.floor((maxVal[i] - minVal[i]) / rangeDiv[i]); // TODO: check with the above line of code + } + + for (var y = 0; y < gridHeight; y++) { + for (var x = 0; x < gridWidth; x++) { + ix = gridWidth - x - 1; + iy = gridHeight - y - 1; + c = deMath.add(minVal, deMath.multiply(step, es3fFragmentOutputTests.swizzleVec([x, y, ix, iy], curInVec))); // IVec4 + + pos = (y * gridWidth + x) * numScalars; + + for (var ndx = 0; ndx < numScalars; ndx++) + inputs[curInVec][pos + ndx] = c[ndx]; + } + } + } else if (isUint) { + range = es3fFragmentOutputTests.getUintRange(output.precision); // UVec2 + maxVal = [range[1], range[1], range[1], range[1]]; // UVec4 + + if (deMath.deInBounds32(output.location + vecNdx, 0, attachments.length)) { + // Limit to range of output format as conversion mode is not specified. + fmtBits = tcuTextureUtil.getTextureFormatBitDepth(attachments[output.location + vecNdx].format); // IVec4 + + for (var i = 0; i < 4; i++) { + fmtMaxVal[i] = Math.pow(2, fmtBits[i]) - 1; + } + + maxVal = deMath.min(maxVal, fmtMaxVal); + } + + bufferedLogToConsole('out ' + curInVec + ' value range: ' + minVal + ' -> ' + maxVal); + + rangeDiv = es3fFragmentOutputTests.swizzleVec([gridWidth - 1, gridHeight - 1, gridWidth - 1, gridHeight - 1], curInVec); // IVec4 + + for (var stepPos = 0; stepPos < maxVal.length; stepPos++) { + step[stepPos] = Math.floor(maxVal[stepPos] / rangeDiv[stepPos]); + } + + DE_ASSERT(range[0] == 0); + + for (var y = 0; y < gridHeight; y++) { + for (var x = 0; x < gridWidth; x++) { + ix = gridWidth - x - 1; + iy = gridHeight - y - 1; + c = deMath.multiply(step, es3fFragmentOutputTests.swizzleVec([x, y, ix, iy], curInVec)); // UVec4 + pos = (y * gridWidth + x) * numScalars; + + DE_ASSERT(deMath.boolAll(deMath.lessThanEqual(c, maxVal))); // TODO: sometimes crashes here, condition not asserted + + for (var ndx = 0; ndx < numScalars; ndx++) + inputs[curInVec][pos + ndx] = c[ndx]; + } + } + } else + DE_ASSERT(false); + + curInVec += 1; + } + } + + // Render using gl. + gl.useProgram(this.m_program.getProgram()); + gl.bindFramebuffer(gl.FRAMEBUFFER, this.m_framebuffer); + gl.viewport(0, 0, viewportW, viewportH); + gl.drawBuffers(drawBuffers); + gl.disable(gl.DITHER); // Dithering causes issues with unorm formats. Those issues could be worked around in threshold, but it makes validation less accurate. + + /** @type {WebGLBuffer} */ var buffer = null; + /** @type {string} */ var name; + curInVec = 0; + for (var outputNdx = 0; outputNdx < this.m_outputs.length; outputNdx++) { + output = this.m_outputs[outputNdx]; + isArray = output.arrayLength > 0; + isFloat = gluShaderUtil.isDataTypeFloatOrVec(output.type); + isInt = gluShaderUtil.isDataTypeIntOrIVec(output.type); + isUint = gluShaderUtil.isDataTypeUintOrUVec(output.type); + /** @type {number} */ var scalarSize = gluShaderUtil.getDataTypeScalarSize(output.type); + /** @type {number} */ var glScalarType = isFloat ? /* gluShaderUtil.DataType.FLOAT */ gl.FLOAT : + isInt ? /* gluShaderUtil.DataType.INT */ gl.INT : + isUint ? /* gluShaderUtil.DataType.UINT */ gl.UNSIGNED_INT : /* gluShaderUtil.DataType.INVALID */ gl.NONE; + numVecs = isArray ? output.arrayLength : 1; + + for (var vecNdx = 0; vecNdx < numVecs; vecNdx++) { + name = 'in' + outputNdx + (isArray ? '_' + vecNdx : ''); + /** @type {number} */ var loc = gl.getAttribLocation(this.m_program.getProgram(), name); + + if (loc >= 0) { + buffer = gl.createBuffer(); + gl.bindBuffer(gl.ARRAY_BUFFER, buffer); + + gl.enableVertexAttribArray(loc); + if (isFloat) { + gl.bufferData(gl.ARRAY_BUFFER, new Float32Array(inputs[curInVec]), gl.STATIC_DRAW); + // KHRONOS WebGL 1.0 specification: + // void vertexAttribPointer(GLuint indx, GLint size, GLenum type, GLboolean normalized, GLsizei stride, GLintptr offset); + gl.vertexAttribPointer(loc, scalarSize, glScalarType, false, 0, 0); // offset = 0 + } else { + gl.bufferData(gl.ARRAY_BUFFER, new Int32Array(inputs[curInVec]), gl.STATIC_DRAW); + // KHRONOS WebGL 2.0 specification: + // void vertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, GLintptr offset) + gl.vertexAttribIPointer(loc, scalarSize, glScalarType, 0, 0); // offset = 0 + } + } else + bufferedLogToConsole('Warning: No location for attribute "' + name + '" found.'); + + curInVec += 1; + } + } + + /** @type {number} */ var posLoc = gl.getAttribLocation(this.m_program.getProgram(), 'a_position'); + // TCU_CHECK(posLoc >= 0); + buffer = gl.createBuffer(); + gl.bindBuffer(gl.ARRAY_BUFFER, buffer); + gl.bufferData(gl.ARRAY_BUFFER, new Float32Array(positions), gl.STATIC_DRAW); + + gl.enableVertexAttribArray(posLoc); + gl.vertexAttribPointer(posLoc, 4, gl.FLOAT, false, 0, 0); // offset = 0 + + /** @type {WebGLBuffer} */ var indexObject = gl.createBuffer(); + gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, indexObject); + gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, new Uint16Array(indices), gl.STATIC_DRAW); + + gl.drawElements(gl.TRIANGLES, numIndices, gl.UNSIGNED_SHORT, 0); // offset = 0 + + // Render reference images. + + var curInNdx = 0; + for (var outputNdx = 0; outputNdx < this.m_outputs.length; outputNdx++) { + output = this.m_outputs[outputNdx]; + isArray = output.arrayLength > 0; + isFloat = gluShaderUtil.isDataTypeFloatOrVec(output.type); + isInt = gluShaderUtil.isDataTypeIntOrIVec(output.type); + isUint = gluShaderUtil.isDataTypeUintOrUVec(output.type); + scalarSize = gluShaderUtil.getDataTypeScalarSize(output.type); + numVecs = isArray ? output.arrayLength : 1; + + for (var vecNdx = 0; vecNdx < numVecs; vecNdx++) { + /** @type {number} */ var location = output.location + vecNdx; + /** @type {Array<number>} */ var inputData = inputs[curInNdx]; + + DE_ASSERT(deMath.deInBounds32(location, 0, this.m_fboSpec.length)); + + /** @type {number} */ var bufW = this.m_fboSpec[location].width; + /** @type {number} */ var bufH = this.m_fboSpec[location].height; + /** @type {Object} */ var descriptor = { + format: attachments[location].referenceFormat, + width: bufW, + height: bufH, + depth: 1, + data: attachments[location].referenceData // ArrayBuffer + }; + /** @type {tcuTexture.PixelBufferAccess} */ var buf = new tcuTexture.PixelBufferAccess(descriptor); + /** @type {tcuTexture.PixelBufferAccess} */ var viewportBuf = tcuTextureUtil.getSubregion(buf, 0, 0, 0, viewportW, viewportH, 1); + + if (isInt || isUint) + es3fFragmentOutputTests.renderIntReference(viewportBuf, gridWidth, gridHeight, scalarSize, inputData); + else if (isFloat) + es3fFragmentOutputTests.renderFloatReference(viewportBuf, gridWidth, gridHeight, scalarSize, inputData); + else + DE_ASSERT(false); + + curInNdx += 1; + } + } + + // Compare all images. + /** @type {boolean} */ var allLevelsOk = true; + for (var attachNdx = 0; attachNdx < numAttachments; attachNdx++) { + attachmentW = this.m_fboSpec[attachNdx].width; + attachmentH = this.m_fboSpec[attachNdx].height; + /** @type {number} */ var numValidChannels = attachments[attachNdx].numWrittenChannels; + /** @type {Array<boolean>} */ var cmpMask = [numValidChannels >= 1, numValidChannels >= 2, numValidChannels >= 3, numValidChannels >= 4]; + /** @type {gluShaderUtil.precision} */ var outPrecision = attachments[attachNdx].outPrecision; + /** @type {tcuTexture.TextureFormat} */ var format = attachments[attachNdx].format; + /** @type {Object} */ + var renderedDescriptor = { + format: attachments[attachNdx].readFormat, + width: attachmentW, + height: attachmentH, + depth: 1, + rowPitch: deMath.deAlign32(attachments[attachNdx].readFormat.getPixelSize() * attachmentW, readAlignment), + slicePitch: 0, + data: attachments[attachNdx].renderedData // ArrayBuffer + }; + /** @type {tcuTexture.PixelBufferAccess} */ var rendered = new tcuTexture.PixelBufferAccess(renderedDescriptor); + /** @type {gluTextureUtil.TransferFormat} */ var transferFmt = gluTextureUtil.getTransferFormat(attachments[attachNdx].readFormat); + gl.readBuffer(gl.COLOR_ATTACHMENT0 + attachNdx); + gl.readPixels(0, 0, attachmentW, attachmentH, transferFmt.format, transferFmt.dataType, rendered.getDataPtr()); + + /** @type {Object} */ + var referenceDescriptor = { + format: attachments[attachNdx].referenceFormat, + width: attachmentW, + height: attachmentH, + depth: 1, + data: attachments[attachNdx].referenceData // ArrayBuffer + }; + /** @type {tcuTexture.ConstPixelBufferAccess} */ var reference = new tcuTexture.ConstPixelBufferAccess(referenceDescriptor); + /** @type {tcuTexture.TextureChannelClass} */ var texClass = tcuTexture.getTextureChannelClass(format.type); + /** @type {boolean} */ var isOk = true; + name = 'Attachment ' + attachNdx; + /** @type {string} */ var desc = 'Color attachment ' + attachNdx; + /** @type {Array<number>} */ var threshold; + + bufferedLogToConsole('Attachment ' + attachNdx + ': ' + numValidChannels + ' channels have defined values and used for comparison'); + + switch (texClass) { + case tcuTexture.TextureChannelClass.FLOATING_POINT: { + /** @type {Array<number>} */ var formatThreshold = []; // UVec4 //!< Threshold computed based on format. + formatThreshold.length = 4; + /** @type {number} */ var precThreshold = 0; // deUint32 //!< Threshold computed based on output type precision + /** @type {Array<number>} */ var finalThreshold = []; // UVec4 + finalThreshold.length = 4; + + switch (format.type) { + case tcuTexture.ChannelType.FLOAT: + formatThreshold = [4, 4, 4, 4]; // UVec4 + break; + case tcuTexture.ChannelType.HALF_FLOAT: + formatThreshold = [(1 << 13) + 4, (1 << 13) + 4, (1 << 13) + 4, (1 << 13) + 4]; // UVec4 + break; + case tcuTexture.ChannelType.UNSIGNED_INT_11F_11F_10F_REV: + formatThreshold = [(1 << 17) + 4, (1 << 17) + 4, (1 << 18) + 4, 4]; // UVec4 + break; + default: + DE_ASSERT(false); + break; + } + + switch (outPrecision) { + case gluShaderUtil.precision.PRECISION_LOWP: + precThreshold = (1 << 21); + break; + case gluShaderUtil.precision.PRECISION_MEDIUMP: + precThreshold = (1 << 13); + break; + case gluShaderUtil.precision.PRECISION_HIGHP: + precThreshold = 0; + break; + default: + DE_ASSERT(false); + } + + finalThreshold = tcuTextureUtil.select( + deMath.max(formatThreshold, [precThreshold, precThreshold, precThreshold, precThreshold]), + [0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff], // C++ version: UVec4(~0u) bitwise not, all bits in the integer will be flipped + cmpMask); + + isOk = tcuImageCompare.floatUlpThresholdCompare(name, desc, reference, rendered, finalThreshold /*, tcu::COMPARE_LOG_RESULT*/); + break; + } + + case tcuTexture.TextureChannelClass.UNSIGNED_FIXED_POINT: { + // \note glReadPixels() allows only 8 bits to be read. This means that RGB10_A2 will loose some + // bits in the process and it must be taken into account when computing threshold. + /** @type {Array<number>} */ var bits = deMath.min([8, 8, 8, 8], tcuTextureUtil.getTextureFormatBitDepth(format)); // IVec4 + + /** @type {Array<number>} */ var baseThreshold = []; // Vec4 + baseThreshold.length = 4; + for (var inc = 0; inc < baseThreshold.length; inc++) { + // TODO: check the operation below: baseThreshold = 1.0f / ((IVec4(1) << bits)-1).asFloat(); + baseThreshold[inc] = 1.0 / ((1 << bits[inc]) - 1); + } + + threshold = tcuTextureUtil.select(baseThreshold, [2.0, 2.0, 2.0, 2.0], cmpMask); // Vec4 + + isOk = tcuImageCompare.floatThresholdCompare(name, desc, reference, rendered, threshold/*, tcu::COMPARE_LOG_RESULT*/); + break; + } + + case tcuTexture.TextureChannelClass.SIGNED_INTEGER: + case tcuTexture.TextureChannelClass.UNSIGNED_INTEGER: { + // The C++ dEQP code uses ~0u but ~0 is -1 in Javascript + var UINT_MAX = Math.pow(2.0, 32.0) - 1; + threshold = tcuTextureUtil.select( + [0, 0, 0, 0], + [UINT_MAX, UINT_MAX, UINT_MAX, UINT_MAX], + cmpMask + ); // UVec4 + isOk = tcuImageCompare.intThresholdCompare(name, desc, reference, rendered, threshold/*, tcu::COMPARE_LOG_RESULT*/); + break; + } + + default: + testFailedOptions('Unsupported comparison', true); + break; + } + + if (!isOk) + allLevelsOk = false; + } + + if (numAttachments > 1) { + if (allLevelsOk) + testPassed('Image comparison passed for ' + numAttachments + ' attachments'); + else + testFailed('Image comparison failed for some of ' + numAttachments + ' attachments'); + } else { + if (allLevelsOk) + testPassed('Image comparison passed'); + else + testFailed('Image comparison failed'); + } + + return tcuTestCase.IterateResult.STOP; + }; + + /** + * es3fFragmentOutputTests.createRandomCase. Constructs the es3fFragmentOutputTests.createRandomCase, child class of es3fFragmentOutputTests.FragmentOutputCase + * @constructor + * @param {number} minRenderTargets + * @param {number} maxRenderTargets + * @param {number} seed + * @return {es3fFragmentOutputTests.FragmentOutputCase} The currently modified object + */ + es3fFragmentOutputTests.createRandomCase = function(minRenderTargets, maxRenderTargets, seed, colorBufferFloatSupported) { + + /** @type {Array<gluShaderUtil.DataType>} */ + var outputTypes = [ + gluShaderUtil.DataType.FLOAT, + gluShaderUtil.DataType.FLOAT_VEC2, + gluShaderUtil.DataType.FLOAT_VEC3, + gluShaderUtil.DataType.FLOAT_VEC4, + gluShaderUtil.DataType.INT, + gluShaderUtil.DataType.INT_VEC2, + gluShaderUtil.DataType.INT_VEC3, + gluShaderUtil.DataType.INT_VEC4, + gluShaderUtil.DataType.UINT, + gluShaderUtil.DataType.UINT_VEC2, + gluShaderUtil.DataType.UINT_VEC3, + gluShaderUtil.DataType.UINT_VEC4 + ]; + + /** @type {Array<gluShaderUtil.precision>} */ + var precisions = [ + gluShaderUtil.precision.PRECISION_LOWP, + gluShaderUtil.precision.PRECISION_MEDIUMP, + gluShaderUtil.precision.PRECISION_HIGHP + ]; + + /** @type {Array<WebGLRenderingContextBase.GLenum>} */ + var floatFormats = [ + gl.RGBA32F, + gl.RGBA16F, + gl.R11F_G11F_B10F, + gl.RG32F, + gl.RG16F, + gl.R32F, + gl.R16F, + gl.RGBA8, + gl.SRGB8_ALPHA8, + gl.RGB10_A2, + gl.RGBA4, + gl.RGB5_A1, + gl.RGB8, + gl.RGB565, + gl.RG8, + gl.R8 + ]; + + /** @type {Array<WebGLRenderingContextBase.GLenum>} */ + var colorBufferFloatFormats = [ + gl.RGBA32F, + gl.RGBA16F, + gl.R11F_G11F_B10F, + gl.RG32F, + gl.RG16F, + gl.R32F, + gl.R16F + ]; + + + /** @type {Array<WebGLRenderingContextBase.GLenum>} */ + var intFormats = [ + gl.RGBA32I, + gl.RGBA16I, + gl.RGBA8I, + gl.RG32I, + gl.RG16I, + gl.RG8I, + gl.R32I, + gl.R16I, + gl.R8I + ]; + + /** @type {Array<WebGLRenderingContextBase.GLenum>} */ + var uintFormats = [ + gl.RGBA32UI, + gl.RGBA16UI, + gl.RGBA8UI, + gl.RGB10_A2UI, + gl.RG32UI, + gl.RG16UI, + gl.RG8UI, + gl.R32UI, + gl.R16UI, + gl.R8UI + ]; + + /** @type {deRandom.Random} */ var rnd = new deRandom.Random(seed); + /** @type {Array<es3fFragmentOutputTests.FragmentOutput>} */ var outputs = []; + /** @type {Array<es3fFragmentOutputTests.BufferSpec>} */ var targets = []; + /** @type {Array<gluShaderUtil.DataType>} */ var outTypes = []; + + /** @type {number} */ var numTargets = rnd.getInt(minRenderTargets, maxRenderTargets); + /** @type {number} */ var width = 128; // \todo [2012-04-10 pyry] Separate randomized sizes per target? + /** @type {number} */ var height = 64; + /** @type {number} */ var samples = 0; + + // Compute outputs. + /** @type {number} */ var curLoc = 0; + while (curLoc < numTargets) { + /** @type {boolean} */ var useArray = rnd.getFloat() < 0.3; + /** @type {number} */ var maxArrayLen = numTargets - curLoc; + /** @type {number} */ var arrayLen = useArray ? rnd.getInt(1, maxArrayLen) : 0; + /** @type {Array<gluShaderUtil.DataType>} */ var basicTypeArray = rnd.choose(outputTypes, undefined, 1); + /** @type {gluShaderUtil.DataType} */ var basicType = basicTypeArray[0]; + /** @type {Array<gluShaderUtil.precision>} */ var precisionArray = rnd.choose(precisions, undefined, 1); + /** @type {gluShaderUtil.precision} */ var precision = precisionArray[0]; + /** @type {number} */ var numLocations = useArray ? arrayLen : 1; + + outputs.push(new es3fFragmentOutputTests.FragmentOutput(basicType, precision, curLoc, arrayLen)); + + for (var ndx = 0; ndx < numLocations; ndx++) + outTypes.push(basicType); + + curLoc += numLocations; + } + DE_ASSERT(curLoc == numTargets); + DE_ASSERT(outTypes.length == numTargets); + + // Compute buffers. + while (targets.length < numTargets) { + /** @type {gluShaderUtil.DataType} */ var outType = outTypes[targets.length]; + /** @type {boolean} */ var isFloat = gluShaderUtil.isDataTypeFloatOrVec(outType); + /** @type {boolean} */ var isInt = gluShaderUtil.isDataTypeIntOrIVec(outType); + /** @type {boolean} */ var isUint = gluShaderUtil.isDataTypeUintOrUVec(outType); + /** @type {Array} */ var formatArray = []; + /** @type {number} */ var format = 0; + + if (isFloat) { + formatArray = rnd.choose(floatFormats, undefined, 1); + format = formatArray[0]; + if (colorBufferFloatFormats.indexOf(format) >= 0 && !colorBufferFloatSupported) + return null; + } else if (isInt) { + formatArray = rnd.choose(intFormats, undefined, 1); + format = formatArray[0]; + } else if (isUint) { + formatArray = rnd.choose(uintFormats, undefined, 1); + format = formatArray[0]; + } else + DE_ASSERT(false); + + targets.push(new es3fFragmentOutputTests.BufferSpec(format, width, height, samples)); + } + + return new es3fFragmentOutputTests.FragmentOutputCase(seed.toString(), '', targets, outputs); + + }; + + es3fFragmentOutputTests.init = function(gl) { + var state = tcuTestCase.runner; + state.testCases = tcuTestCase.newTest('fragment_outputs', 'Top level'); + /** @const @type {tcuTestCase.DeqpTest} */ var testGroup = state.testCases; + + /** @type {Array<WebGLRenderingContextBase.GLenum>} */ + var requiredFloatFormats = [ + gl.RGBA32F, + gl.RGBA16F, + gl.R11F_G11F_B10F, + gl.RG32F, + gl.RG16F, + gl.R32F, + gl.R16F + ]; + + /** @type {Array<WebGLRenderingContextBase.GLenum>} */ + var requiredFixedFormats = [ + gl.RGBA8, + gl.SRGB8_ALPHA8, + gl.RGB10_A2, + gl.RGBA4, + gl.RGB5_A1, + gl.RGB8, + gl.RGB565, + gl.RG8, + gl.R8 + ]; + + /** @type {Array<WebGLRenderingContextBase.GLenum>} */ + var requiredIntFormats = [ + gl.RGBA32I, + gl.RGBA16I, + gl.RGBA8I, + gl.RG32I, + gl.RG16I, + gl.RG8I, + gl.R32I, + gl.R16I, + gl.R8I + ]; + + /** @type {Array<WebGLRenderingContextBase.GLenum>} */ + var requiredUintFormats = [ + gl.RGBA32UI, + gl.RGBA16UI, + gl.RGBA8UI, + gl.RGB10_A2UI, + gl.RG32UI, + gl.RG16UI, + gl.RG8UI, + gl.R32UI, + gl.R16UI, + gl.R8UI + ]; + + /** @type {Array<gluShaderUtil.precision>} */ + var precisions = [ + + gluShaderUtil.precision.PRECISION_LOWP, + gluShaderUtil.precision.PRECISION_MEDIUMP, + gluShaderUtil.precision.PRECISION_HIGHP + + ]; + + // .basic. + + /** @const @type {number} */ var width = 64; + /** @const @type {number} */ var height = 64; + /** @const @type {number} */ var samples = 0; + /** @type {Array<es3fFragmentOutputTests.BufferSpec>} */ var fboSpec = null; + /** @type {gluShaderUtil.precision} */ var prec; + /** @type {string} */ var precName; + + // .float + if (gl.getExtension('EXT_color_buffer_float')) { + /** @type {tcuTestCase.DeqpTest} */ var floatGroup = tcuTestCase.newTest('basic.float', 'Floating-point output tests'); + testGroup.addChild(floatGroup); + + for (var fmtNdx = 0; fmtNdx < requiredFloatFormats.length; fmtNdx++) { + var format = requiredFloatFormats[fmtNdx]; + var fmtName = es3fFboTestUtil.getFormatName(format); + fboSpec = []; + + fboSpec.push(new es3fFragmentOutputTests.BufferSpec(format, width, height, samples)); + + for (var precNdx = 0; precNdx < precisions.length; precNdx++) { + prec = precisions[precNdx]; + precName = gluShaderUtil.getPrecisionName(prec); + + // NOTE: Eliminated original OutputVec and toVec(), as it only returned an element of the outputs array in OutputVec + floatGroup.addChild(new es3fFragmentOutputTests.FragmentOutputCase(fmtName + '_' + precName + '_float', '', fboSpec, [new es3fFragmentOutputTests.FragmentOutput(gluShaderUtil.DataType.FLOAT, prec, 0)])); + floatGroup.addChild(new es3fFragmentOutputTests.FragmentOutputCase(fmtName + '_' + precName + '_vec2', '', fboSpec, [new es3fFragmentOutputTests.FragmentOutput(gluShaderUtil.DataType.FLOAT_VEC2, prec, 0)])); + floatGroup.addChild(new es3fFragmentOutputTests.FragmentOutputCase(fmtName + '_' + precName + '_vec3', '', fboSpec, [new es3fFragmentOutputTests.FragmentOutput(gluShaderUtil.DataType.FLOAT_VEC3, prec, 0)])); + floatGroup.addChild(new es3fFragmentOutputTests.FragmentOutputCase(fmtName + '_' + precName + '_vec4', '', fboSpec, [new es3fFragmentOutputTests.FragmentOutput(gluShaderUtil.DataType.FLOAT_VEC4, prec, 0)])); + } + } + } + + // .fixed + /** @type {tcuTestCase.DeqpTest} */ var fixedGroup = tcuTestCase.newTest('basic.fixed', 'Fixed-point output tests'); + testGroup.addChild(fixedGroup); + for (var fmtNdx = 0; fmtNdx < requiredFixedFormats.length; fmtNdx++) { + var format = requiredFixedFormats[fmtNdx]; + var fmtName = es3fFboTestUtil.getFormatName(format); + fboSpec = []; + + fboSpec.push(new es3fFragmentOutputTests.BufferSpec(format, width, height, samples)); + + for (var precNdx = 0; precNdx < precisions.length; precNdx++) { + prec = precisions[precNdx]; + precName = gluShaderUtil.getPrecisionName(prec); + + fixedGroup.addChild(new es3fFragmentOutputTests.FragmentOutputCase(fmtName + '_' + precName + '_float', '', fboSpec, [new es3fFragmentOutputTests.FragmentOutput(gluShaderUtil.DataType.FLOAT, prec, 0)])); + fixedGroup.addChild(new es3fFragmentOutputTests.FragmentOutputCase(fmtName + '_' + precName + '_vec2', '', fboSpec, [new es3fFragmentOutputTests.FragmentOutput(gluShaderUtil.DataType.FLOAT_VEC2, prec, 0)])); + fixedGroup.addChild(new es3fFragmentOutputTests.FragmentOutputCase(fmtName + '_' + precName + '_vec3', '', fboSpec, [new es3fFragmentOutputTests.FragmentOutput(gluShaderUtil.DataType.FLOAT_VEC3, prec, 0)])); + fixedGroup.addChild(new es3fFragmentOutputTests.FragmentOutputCase(fmtName + '_' + precName + '_vec4', '', fboSpec, [new es3fFragmentOutputTests.FragmentOutput(gluShaderUtil.DataType.FLOAT_VEC4, prec, 0)])); + } + } + + // .int + /** @type {tcuTestCase.DeqpTest} */ var intGroup = tcuTestCase.newTest('basic.int', 'Integer output tests'); + testGroup.addChild(intGroup); + for (var fmtNdx = 0; fmtNdx < requiredIntFormats.length; fmtNdx++) { + var format = requiredIntFormats[fmtNdx]; + var fmtName = es3fFboTestUtil.getFormatName(format); + fboSpec = []; + + fboSpec.push(new es3fFragmentOutputTests.BufferSpec(format, width, height, samples)); + + for (var precNdx = 0; precNdx < precisions.length; precNdx++) { + prec = precisions[precNdx]; + precName = gluShaderUtil.getPrecisionName(prec); + + intGroup.addChild(new es3fFragmentOutputTests.FragmentOutputCase(fmtName + '_' + precName + '_int', '', fboSpec, [new es3fFragmentOutputTests.FragmentOutput(gluShaderUtil.DataType.INT, prec, 0)])); + intGroup.addChild(new es3fFragmentOutputTests.FragmentOutputCase(fmtName + '_' + precName + '_ivec2', '', fboSpec, [new es3fFragmentOutputTests.FragmentOutput(gluShaderUtil.DataType.INT_VEC2, prec, 0)])); + intGroup.addChild(new es3fFragmentOutputTests.FragmentOutputCase(fmtName + '_' + precName + '_ivec3', '', fboSpec, [new es3fFragmentOutputTests.FragmentOutput(gluShaderUtil.DataType.INT_VEC3, prec, 0)])); + intGroup.addChild(new es3fFragmentOutputTests.FragmentOutputCase(fmtName + '_' + precName + '_ivec4', '', fboSpec, [new es3fFragmentOutputTests.FragmentOutput(gluShaderUtil.DataType.INT_VEC4, prec, 0)])); + } + } + + // .uint + /** @type {tcuTestCase.DeqpTest} */ var uintGroup = tcuTestCase.newTest('basic.uint', 'Usigned integer output tests'); + testGroup.addChild(uintGroup); + for (var fmtNdx = 0; fmtNdx < requiredUintFormats.length; fmtNdx++) { + var format = requiredUintFormats[fmtNdx]; + var fmtName = es3fFboTestUtil.getFormatName(format); + fboSpec = []; + + fboSpec.push(new es3fFragmentOutputTests.BufferSpec(format, width, height, samples)); + + for (var precNdx = 0; precNdx < precisions.length; precNdx++) { + prec = precisions[precNdx]; + precName = gluShaderUtil.getPrecisionName(prec); + + uintGroup.addChild(new es3fFragmentOutputTests.FragmentOutputCase(fmtName + '_' + precName + '_uint', '', fboSpec, [new es3fFragmentOutputTests.FragmentOutput(gluShaderUtil.DataType.UINT, prec, 0)])); + uintGroup.addChild(new es3fFragmentOutputTests.FragmentOutputCase(fmtName + '_' + precName + '_uvec2', '', fboSpec, [new es3fFragmentOutputTests.FragmentOutput(gluShaderUtil.DataType.UINT_VEC2, prec, 0)])); + uintGroup.addChild(new es3fFragmentOutputTests.FragmentOutputCase(fmtName + '_' + precName + '_uvec3', '', fboSpec, [new es3fFragmentOutputTests.FragmentOutput(gluShaderUtil.DataType.UINT_VEC3, prec, 0)])); + uintGroup.addChild(new es3fFragmentOutputTests.FragmentOutputCase(fmtName + '_' + precName + '_uvec4', '', fboSpec, [new es3fFragmentOutputTests.FragmentOutput(gluShaderUtil.DataType.UINT_VEC4, prec, 0)])); + + } + } + + // .array + + /** @type {number} */ var numTargets = 3; + + // .float + if (gl.getExtension('EXT_color_buffer_float')) { + /** @type {tcuTestCase.DeqpTest} */ var arrayFloatGroup = tcuTestCase.newTest('array.float', 'Floating-point output tests'); + testGroup.addChild(arrayFloatGroup); + for (var fmtNdx = 0; fmtNdx < requiredFloatFormats.length; fmtNdx++) { + var format = requiredFloatFormats[fmtNdx]; + var fmtName = es3fFboTestUtil.getFormatName(format); + fboSpec = []; + + for (var ndx = 0; ndx < numTargets; ndx++) + fboSpec.push(new es3fFragmentOutputTests.BufferSpec(format, width, height, samples)); + + for (var precNdx = 0; precNdx < precisions.length; precNdx++) { + prec = precisions[precNdx]; + precName = gluShaderUtil.getPrecisionName(prec); + + arrayFloatGroup.addChild(new es3fFragmentOutputTests.FragmentOutputCase(fmtName + '_' + precName + '_float', '', fboSpec, [new es3fFragmentOutputTests.FragmentOutput(gluShaderUtil.DataType.FLOAT, prec, 0, numTargets)])); + arrayFloatGroup.addChild(new es3fFragmentOutputTests.FragmentOutputCase(fmtName + '_' + precName + '_vec2', '', fboSpec, [new es3fFragmentOutputTests.FragmentOutput(gluShaderUtil.DataType.FLOAT_VEC2, prec, 0, numTargets)])); + arrayFloatGroup.addChild(new es3fFragmentOutputTests.FragmentOutputCase(fmtName + '_' + precName + '_vec3', '', fboSpec, [new es3fFragmentOutputTests.FragmentOutput(gluShaderUtil.DataType.FLOAT_VEC3, prec, 0, numTargets)])); + arrayFloatGroup.addChild(new es3fFragmentOutputTests.FragmentOutputCase(fmtName + '_' + precName + '_vec4', '', fboSpec, [new es3fFragmentOutputTests.FragmentOutput(gluShaderUtil.DataType.FLOAT_VEC4, prec, 0, numTargets)])); + } + } + } + + // .fixed + /** @type {tcuTestCase.DeqpTest} */ var arrayFixedGroup = tcuTestCase.newTest('array.fixed', 'Fixed-point output tests'); + testGroup.addChild(arrayFixedGroup); + for (var fmtNdx = 0; fmtNdx < requiredFixedFormats.length; fmtNdx++) { + var format = requiredFixedFormats[fmtNdx]; + var fmtName = es3fFboTestUtil.getFormatName(format); + fboSpec = []; + + for (var ndx = 0; ndx < numTargets; ndx++) + fboSpec.push(new es3fFragmentOutputTests.BufferSpec(format, width, height, samples)); + + for (var precNdx = 0; precNdx < precisions.length; precNdx++) { + prec = precisions[precNdx]; + precName = gluShaderUtil.getPrecisionName(prec); + + arrayFixedGroup.addChild(new es3fFragmentOutputTests.FragmentOutputCase(fmtName + '_' + precName + '_float', '', fboSpec, [new es3fFragmentOutputTests.FragmentOutput(gluShaderUtil.DataType.FLOAT, prec, 0, numTargets)])); + arrayFixedGroup.addChild(new es3fFragmentOutputTests.FragmentOutputCase(fmtName + '_' + precName + '_vec2', '', fboSpec, [new es3fFragmentOutputTests.FragmentOutput(gluShaderUtil.DataType.FLOAT_VEC2, prec, 0, numTargets)])); + arrayFixedGroup.addChild(new es3fFragmentOutputTests.FragmentOutputCase(fmtName + '_' + precName + '_vec3', '', fboSpec, [new es3fFragmentOutputTests.FragmentOutput(gluShaderUtil.DataType.FLOAT_VEC3, prec, 0, numTargets)])); + arrayFixedGroup.addChild(new es3fFragmentOutputTests.FragmentOutputCase(fmtName + '_' + precName + '_vec4', '', fboSpec, [new es3fFragmentOutputTests.FragmentOutput(gluShaderUtil.DataType.FLOAT_VEC4, prec, 0, numTargets)])); + } + } + + // .int + /** @type {tcuTestCase.DeqpTest} */ var arrayIntGroup = tcuTestCase.newTest('array.int', 'Integer output tests'); + testGroup.addChild(arrayIntGroup); + for (var fmtNdx = 0; fmtNdx < requiredIntFormats.length; fmtNdx++) { + var format = requiredIntFormats[fmtNdx]; + var fmtName = es3fFboTestUtil.getFormatName(format); + fboSpec = []; + + for (var ndx = 0; ndx < numTargets; ndx++) + fboSpec.push(new es3fFragmentOutputTests.BufferSpec(format, width, height, samples)); + + for (var precNdx = 0; precNdx < precisions.length; precNdx++) { + prec = precisions[precNdx]; + precName = gluShaderUtil.getPrecisionName(prec); + + arrayIntGroup.addChild(new es3fFragmentOutputTests.FragmentOutputCase(fmtName + '_' + precName + '_int', '', fboSpec, [new es3fFragmentOutputTests.FragmentOutput(gluShaderUtil.DataType.INT, prec, 0, numTargets)])); + arrayIntGroup.addChild(new es3fFragmentOutputTests.FragmentOutputCase(fmtName + '_' + precName + '_ivec2', '', fboSpec, [new es3fFragmentOutputTests.FragmentOutput(gluShaderUtil.DataType.INT_VEC2, prec, 0, numTargets)])); + arrayIntGroup.addChild(new es3fFragmentOutputTests.FragmentOutputCase(fmtName + '_' + precName + '_ivec3', '', fboSpec, [new es3fFragmentOutputTests.FragmentOutput(gluShaderUtil.DataType.INT_VEC3, prec, 0, numTargets)])); + arrayIntGroup.addChild(new es3fFragmentOutputTests.FragmentOutputCase(fmtName + '_' + precName + '_ivec4', '', fboSpec, [new es3fFragmentOutputTests.FragmentOutput(gluShaderUtil.DataType.INT_VEC4, prec, 0, numTargets)])); + } + } + + // .uint + /** @type {tcuTestCase.DeqpTest} */ var arrayUintGroup = tcuTestCase.newTest('array.uint', 'Usigned integer output tests'); + testGroup.addChild(arrayUintGroup); + for (var fmtNdx = 0; fmtNdx < requiredUintFormats.length; fmtNdx++) { + var format = requiredUintFormats[fmtNdx]; + var fmtName = es3fFboTestUtil.getFormatName(format); + fboSpec = []; + + for (var ndx = 0; ndx < numTargets; ndx++) + fboSpec.push(new es3fFragmentOutputTests.BufferSpec(format, width, height, samples)); + + for (var precNdx = 0; precNdx < precisions.length; precNdx++) { + prec = precisions[precNdx]; + precName = gluShaderUtil.getPrecisionName(prec); + + arrayUintGroup.addChild(new es3fFragmentOutputTests.FragmentOutputCase(fmtName + '_' + precName + '_uint', '', fboSpec, [new es3fFragmentOutputTests.FragmentOutput(gluShaderUtil.DataType.UINT, prec, 0, numTargets)])); + arrayUintGroup.addChild(new es3fFragmentOutputTests.FragmentOutputCase(fmtName + '_' + precName + '_uvec2', '', fboSpec, [new es3fFragmentOutputTests.FragmentOutput(gluShaderUtil.DataType.UINT_VEC2, prec, 0, numTargets)])); + arrayUintGroup.addChild(new es3fFragmentOutputTests.FragmentOutputCase(fmtName + '_' + precName + '_uvec3', '', fboSpec, [new es3fFragmentOutputTests.FragmentOutput(gluShaderUtil.DataType.UINT_VEC3, prec, 0, numTargets)])); + arrayUintGroup.addChild(new es3fFragmentOutputTests.FragmentOutputCase(fmtName + '_' + precName + '_uvec4', '', fboSpec, [new es3fFragmentOutputTests.FragmentOutput(gluShaderUtil.DataType.UINT_VEC4, prec, 0, numTargets)])); + } + } + + // .random + + /** @type {Array<tcuTestCase.DeqpTest>} */ var randomGroup = []; + var numRandomGroups = 3; + for (var ii = 0; ii < numRandomGroups; ++ii) { + randomGroup[ii] = tcuTestCase.newTest('random', 'Random fragment output cases'); + testGroup.addChild(randomGroup[ii]); + } + + /** @type {boolean} */ var colorBufferFloatSupported = (gl.getExtension('EXT_color_buffer_float') != null); + for (var seed = 0; seed < 100; seed++) { + var test = es3fFragmentOutputTests.createRandomCase(2, 4, seed, colorBufferFloatSupported); + if (test !== null) { + randomGroup[seed % numRandomGroups].addChild(test); + } + } + + }; + + /** + * Create and execute the test cases + */ + es3fFragmentOutputTests.run = function(context, range) { + gl = context; + //Set up Test Root parameters + var testName = 'fragment_output'; + var testDescription = 'Fragment Output 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 { + es3fFragmentOutputTests.init(gl); + if (range) + state.setRange(range); + tcuTestCase.runTestCases(); + } catch (err) { + testFailedOptions('Failed to es3fFragmentOutputTests.run tests', false); + bufferedLogToConsole(err); + tcuTestCase.runner.terminate(); + } + + }; + +}); |