dom/canvas/test/webgl-conf/checkout/deqp/functional/gles3/es3fFragmentOutputTests.js

   1 /*-------------------------------------------------------------------------
   2  * drawElements Quality Program OpenGL ES Utilities
   3  * ------------------------------------------------
   4  *
   5  * Copyright 2014 The Android Open Source Project
   6  *
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  *
  19  */
  20
  21 'use strict';
  22 goog.provide('functional.gles3.es3fFragmentOutputTests');
  23 goog.require('framework.common.tcuImageCompare');
  24 goog.require('framework.common.tcuTestCase');
  25 goog.require('framework.common.tcuTexture');
  26 goog.require('framework.common.tcuTextureUtil');
  27 goog.require('framework.delibs.debase.deMath');
  28 goog.require('framework.delibs.debase.deRandom');
  29 goog.require('framework.opengl.gluShaderProgram');
  30 goog.require('framework.opengl.gluShaderUtil');
  31 goog.require('framework.opengl.gluTextureUtil');
  32 goog.require('functional.gles3.es3fFboTestUtil');
  33
  34 goog.scope(function() {
  35
  36 var es3fFragmentOutputTests = functional.gles3.es3fFragmentOutputTests;
  37 var gluShaderProgram = framework.opengl.gluShaderProgram;
  38 var es3fFboTestUtil = functional.gles3.es3fFboTestUtil;
  39 var gluShaderUtil = framework.opengl.gluShaderUtil;
  40 var deRandom = framework.delibs.debase.deRandom;
  41 var tcuTestCase = framework.common.tcuTestCase;
  42 var gluTextureUtil = framework.opengl.gluTextureUtil;
  43 var tcuTexture = framework.common.tcuTexture;
  44 var tcuTextureUtil = framework.common.tcuTextureUtil;
  45 var deMath = framework.delibs.debase.deMath;
  46 var tcuImageCompare = framework.common.tcuImageCompare;
  47
  48     /** @type {WebGL2RenderingContext} */ var gl;
  49
  50     var DE_ASSERT = function(x) {
  51         if (!x)
  52             throw new Error('Assert failed');
  53     };
  54
  55     /**
  56      * es3fFragmentOutputTests.BufferSpec. Constructs the es3fFragmentOutputTests.BufferSpec object
  57      * @constructor
  58      * @param {WebGLRenderingContextBase.GLenum} format_
  59      * @param {number} width_
  60      * @param {number} height_
  61      * @param {number} samples_
  62      */
  63     es3fFragmentOutputTests.BufferSpec = function(format_, width_, height_, samples_) {
  64         this.format = format_;
  65         this.width = width_;
  66         this.height = height_;
  67         this.samples = samples_;
  68     };
  69
  70     /**
  71      * es3fFragmentOutputTests.FragmentOutput. Constructs the es3fFragmentOutputTests.FragmentOutput object
  72      * @constructor
  73      * @param {gluShaderUtil.DataType} type_
  74      * @param {gluShaderUtil.precision} precision_
  75      * @param {number} location_
  76      * @param {number=} arrayLength_
  77      */
  78     es3fFragmentOutputTests.FragmentOutput = function(type_, precision_, location_, arrayLength_) {
  79         this.type = type_;
  80         this.precision = precision_;
  81         this.location = location_;
  82         this.arrayLength = arrayLength_ || 0;
  83     };
  84
  85     /**
  86      * es3fFragmentOutputTests.FragmentOutputCase. Constructs the es3fFragmentOutputTests.FragmentOutputCase object
  87      * @constructor
  88      * @extends {tcuTestCase.DeqpTest}
  89      * @param {string} name
  90      * @param {string} description
  91      * @param {Array<es3fFragmentOutputTests.BufferSpec>} fboSpec
  92      * @param {Array<es3fFragmentOutputTests.FragmentOutput>} outputs
  93      * @return {Object} The currently modified object
  94      */
  95     es3fFragmentOutputTests.FragmentOutputCase = function(name, description, fboSpec, outputs) {
  96         tcuTestCase.DeqpTest.call(this, name, description);
  97         /** @type {Array<es3fFragmentOutputTests.BufferSpec>} */ this.m_fboSpec = fboSpec;
  98         /** @type {Array<es3fFragmentOutputTests.FragmentOutput>} */ this.m_outputs = outputs;
  99         /** @type {gluShaderProgram.ShaderProgram} */ this.m_program = null;
 100         /** @type {WebGLFramebuffer} */ this.m_framebuffer = null;
 101
 102         /** @type {WebGLRenderbuffer} */ this.m_renderbuffer = null;
 103     };
 104
 105     es3fFragmentOutputTests.FragmentOutputCase.prototype = Object.create(tcuTestCase.DeqpTest.prototype);
 106     es3fFragmentOutputTests.FragmentOutputCase.prototype.constructor = es3fFragmentOutputTests.FragmentOutputCase;
 107
 108     /**
 109      * es3fFragmentOutputTests.createProgram. Returns a ShaderProgram object
 110      * @param {Array<es3fFragmentOutputTests.FragmentOutput>} outputs
 111      * @return {gluShaderProgram.ShaderProgram} program
 112      */
 113     es3fFragmentOutputTests.createProgram = function(outputs) {
 114
 115         var vtx = '';
 116         var frag = '';
 117
 118         vtx = '#version 300 es\n' + 'in highp vec4 a_position;\n';
 119         frag = '#version 300 es\n';
 120
 121     /** @type {es3fFragmentOutputTests.FragmentOutput} */ var output = null;
 122     /** @type {boolean} */ var isArray = false;
 123      // Input-output declarations.
 124         for (var outNdx = 0; outNdx < outputs.length; outNdx++) {
 125             output = outputs[outNdx];
 126             isArray = output.arrayLength > 0;
 127             /** @type {string} */ var typeName = gluShaderUtil.getDataTypeName(output.type);
 128             /** @type {string} */ var precName = gluShaderUtil.getPrecisionName(output.precision);
 129             /** @type {boolean} */ var isFloat = gluShaderUtil.isDataTypeFloatOrVec(output.type);
 130             /** @type {string} */ var interp = isFloat ? 'smooth' : 'flat';
 131
 132             if (isArray) {
 133                 for (var elemNdx = 0; elemNdx < output.arrayLength; elemNdx++) {
 134                     vtx += 'in ' + precName + ' ' + typeName + ' in' + outNdx + '_' + elemNdx + ';\n' +
 135                     interp + ' out ' + precName + ' ' + typeName + ' var' + outNdx + '_' + elemNdx + ';\n';
 136                     frag += interp + ' in ' + precName + ' ' + typeName + ' var' + outNdx + '_' + elemNdx + ';\n';
 137                 }
 138                 frag += 'layout(location = ' + output.location + ') out ' + precName + ' ' + typeName + ' out' + outNdx + '[' + output.arrayLength + '];\n';
 139             } else {
 140                 vtx += 'in ' + precName + ' ' + typeName + ' in' + outNdx + ';\n' +
 141                 interp + ' out ' + precName + ' ' + typeName + ' var' + outNdx + ';\n';
 142                 frag += interp + ' in ' + precName + ' ' + typeName + ' var' + outNdx + ';\n' +
 143                 'layout(location = ' + output.location + ') out ' + precName + ' ' + typeName + ' out' + outNdx + ';\n';
 144             }
 145         }
 146
 147         vtx += '\nvoid main()\n{\n';
 148         frag += '\nvoid main()\n{\n';
 149
 150         vtx += ' gl_Position = a_position;\n';
 151
 152         // Copy body
 153         for (var outNdx = 0; outNdx < outputs.length; outNdx++) {
 154             output = outputs[outNdx];
 155             isArray = output.arrayLength > 0;
 156
 157             if (isArray) {
 158                 for (var elemNdx = 0; elemNdx < output.arrayLength; elemNdx++) {
 159                     vtx += '\tvar' + outNdx + '_' + elemNdx + ' = in' + outNdx + '_' + elemNdx + ';\n';
 160                     frag += '\tout' + outNdx + '[' + elemNdx + '] = var' + outNdx + '_' + elemNdx + ';\n';
 161                 }
 162             } else {
 163                 vtx += '\tvar' + outNdx + ' = in' + outNdx + ';\n';
 164                 frag += '\tout' + outNdx + ' = var' + outNdx + ';\n';
 165             }
 166         }
 167
 168         vtx += '}\n';
 169         frag += '}\n';
 170
 171         /** @type {gluShaderProgram.ShaderProgram} */
 172         var program = new gluShaderProgram.ShaderProgram(gl, gluShaderProgram.makeVtxFragSources(vtx, frag));
 173         return program;
 174     };
 175
 176     es3fFragmentOutputTests.FragmentOutputCase.prototype.init = function() {
 177         // Check that all attachments are supported
 178         for (var iter = 0; iter < this.m_fboSpec.length; ++iter) {
 179             if (!gluTextureUtil.isSizedFormatColorRenderable(this.m_fboSpec[iter].format))
 180                 throw new Error('Unsupported attachment format');
 181         }
 182
 183         DE_ASSERT(!this.m_program);
 184         this.m_program = es3fFragmentOutputTests.createProgram(this.m_outputs);
 185
 186        // log << *m_program;
 187         if (!this.m_program.isOk())
 188             throw new Error('Compile failed. Program no created');
 189
 190         /*
 191         // Print render target info to log.
 192         log << TestLog::Section("Framebuffer", "Framebuffer configuration");
 193
 194         for (int ndx = 0; ndx < (int)m_fboSpec.size(); ndx++)
 195             log << TestLog::Message << "COLOR_ATTACHMENT" << ndx << ": "
 196                                     << glu::getPixelFormatStr(m_fboSpec[ndx].format) << ", "
 197                                     << m_fboSpec[ndx].width << "x" << m_fboSpec[ndx].height << ", "
 198                                     << m_fboSpec[ndx].samples << " samples"
 199                 << TestLog::EndMessage;
 200
 201         log << TestLog::EndSection;*/
 202
 203         // Create framebuffer.
 204         this.m_framebuffer = gl.createFramebuffer();
 205         gl.bindFramebuffer(gl.FRAMEBUFFER, this.m_framebuffer);
 206
 207         for (var bufNdx = 0; bufNdx < /* m_renderbuffers.size() */ this.m_fboSpec.length; bufNdx++) {
 208             this.m_renderbuffer = gl.createRenderbuffer();
 209             /** @type {es3fFragmentOutputTests.BufferSpec} */ var bufSpec = this.m_fboSpec[bufNdx];
 210             /** @type {number} */ var attachment = gl.COLOR_ATTACHMENT0 + bufNdx;
 211
 212             gl.bindRenderbuffer(gl.RENDERBUFFER, this.m_renderbuffer);
 213
 214             gl.renderbufferStorageMultisample(gl.RENDERBUFFER, bufSpec.samples, bufSpec.format, bufSpec.width, bufSpec.height);
 215             gl.framebufferRenderbuffer(gl.FRAMEBUFFER, attachment, gl.RENDERBUFFER, this.m_renderbuffer);
 216         }
 217         /** @type {number} */ var fboStatus = gl.checkFramebufferStatus(gl.FRAMEBUFFER);
 218
 219         if (fboStatus == gl.FRAMEBUFFER_UNSUPPORTED)
 220             throw new Error('Framebuffer not supported');
 221         else if (fboStatus != gl.FRAMEBUFFER_COMPLETE)
 222             throw new Error('Incomplete framebuffer');
 223             // throw tcu::TestError((string("Incomplete framebuffer: ") + glu::getFramebufferStatusStr(fboStatus), "", __FILE__, __LINE__);
 224
 225         // gl.bindRenderbuffer(gl.RENDERBUFFER, null); // TODO: maybe needed?
 226         gl.bindFramebuffer(gl.FRAMEBUFFER, null);
 227     };
 228
 229     es3fFragmentOutputTests.FragmentOutputCase.prototype.deinit = function() {
 230         // TODO: implement?
 231     };
 232
 233     /**
 234      * es3fFragmentOutputTests.getMinSize.
 235      * @param {Array<es3fFragmentOutputTests.BufferSpec>} fboSpec
 236      * @return {Array<number>} minSize
 237      */
 238     es3fFragmentOutputTests.getMinSize = function(fboSpec) {
 239         /** @type {Array<number>} */ var minSize = [0x7fffffff, 0x7fffffff];
 240         for (var i = 0; i < fboSpec.length; i++) {
 241             minSize[0] = Math.min(minSize[0], fboSpec[i].width);
 242             minSize[1] = Math.min(minSize[1], fboSpec[i].height);
 243         }
 244         return minSize;
 245     };
 246
 247     /**
 248      * es3fFragmentOutputTests.getNumInputVectors. Returns the length of the array of all the outputs (es3fFragmentOutputTests.FragmentOutput object)
 249      * @param {Array<es3fFragmentOutputTests.FragmentOutput>} outputs
 250      * @return {number} numVecs
 251      */
 252     es3fFragmentOutputTests.getNumInputVectors = function(outputs) {
 253         /** @type {number} */ var numVecs = 0;
 254         for (var i = 0; i < outputs.length; i++)
 255             numVecs += (outputs[i].arrayLength > 0 ? outputs[i].arrayLength : 1);
 256         return numVecs;
 257     };
 258
 259     /**
 260      * es3fFragmentOutputTests.getFloatRange
 261      * @param {gluShaderUtil.precision} precision
 262      * @return {Array<number>} Vec2
 263      */
 264     es3fFragmentOutputTests.getFloatRange = function(precision) {
 265         /** @type {Array<Array<number>>} */
 266         var ranges = // Vec2
 267         [
 268             [-2.0, 2.0],
 269             [-16000.0, 16000.0],
 270             [-1e35, 1e35]
 271         ];
 272         // DE_STATIC_ASSERT(DE_LENGTH_OF_ARRAY(ranges) == glu::PRECISION_LAST);
 273         // DE_ASSERT(de::inBounds<int>(precision, 0, DE_LENGTH_OF_ARRAY(ranges)));
 274         return ranges[precision];
 275     };
 276
 277     /**
 278      * es3fFragmentOutputTests.getIntRange
 279      * @param {gluShaderUtil.precision} precision
 280      * @return {Array<number>} IVec2
 281      */
 282     es3fFragmentOutputTests.getIntRange = function(precision) {
 283         /** @type {Array<Array<number>>} */
 284         var ranges = // IVec2
 285         [
 286             [-(1 << 7), (1 << 7) - 1],
 287             [-(1 << 15), (1 << 15) - 1],
 288             [-0x80000000, 0x7fffffff]
 289         ];
 290         // DE_STATIC_ASSERT(DE_LENGTH_OF_ARRAY(ranges) == glu::PRECISION_LAST);
 291         // DE_ASSERT(de::inBounds<int>(precision, 0, DE_LENGTH_OF_ARRAY(ranges)));
 292         return ranges[precision];
 293     };
 294
 295     /**
 296      * es3fFragmentOutputTests.getUintRange
 297      * @param {gluShaderUtil.precision} precision
 298      * @return {Array<number>} UVec2
 299      */
 300     es3fFragmentOutputTests.getUintRange = function(precision) {
 301         /** @type {Array<Array<number>>} */
 302         var ranges = // UVec2
 303         [
 304             [0, (1 << 8) - 1],
 305             [0, (1 << 16) - 1],
 306             [0, 0xffffffff]
 307         ];
 308         // DE_STATIC_ASSERT(DE_LENGTH_OF_ARRAY(ranges) == glu::PRECISION_LAST);
 309         // DE_ASSERT(de::inBounds<int>(precision, 0, DE_LENGTH_OF_ARRAY(ranges)));
 310         return ranges[precision];
 311
 312     };
 313
 314     /**
 315      * es3fFragmentOutputTests.readVec4
 316      * @param {Array<number>} ptr
 317      * @param {number} index
 318      * @param {number} numComponents
 319      * @return {Array<number>} Vec4
 320      */
 321     es3fFragmentOutputTests.readVec4 = function(ptr, index, numComponents) {
 322         DE_ASSERT(numComponents >= 1);
 323         return [
 324                 ptr[index + 0],
 325                 numComponents >= 2 ? ptr[index + 1] : 0.0,
 326                 numComponents >= 3 ? ptr[index + 2] : 0.0,
 327                 numComponents >= 4 ? ptr[index + 3] : 0.0
 328                 ];
 329     };
 330
 331     /**
 332      * es3fFragmentOutputTests.readIVec4
 333      * @param {Array<number>} ptr
 334      * @param {number} numComponents
 335      * @return {Array<number>} IVec4
 336      */
 337     es3fFragmentOutputTests.readIVec4 = function(ptr, index, numComponents) {
 338         DE_ASSERT(numComponents >= 1);
 339         return [
 340                 ptr[index + 0],
 341                 numComponents >= 2 ? ptr[index + 1] : 0,
 342                 numComponents >= 3 ? ptr[index + 2] : 0,
 343                 numComponents >= 4 ? ptr[index + 3] : 0
 344                 ];
 345     };
 346
 347     /**
 348      * es3fFragmentOutputTests.renderFloatReference
 349      * @param {tcuTexture.PixelBufferAccess} dst
 350      * @param {number} gridWidth
 351      * @param {number} gridHeight
 352      * @param {number} numComponents
 353      * @param {Array<number>} vertices
 354      */
 355     es3fFragmentOutputTests.renderFloatReference = function(dst, gridWidth, gridHeight, numComponents, vertices) {
 356
 357         /** @type {boolean} */ var isSRGB = dst.getFormat().order == tcuTexture.ChannelOrder.sRGB || dst.getFormat().order == tcuTexture.ChannelOrder.sRGBA;
 358         /** @type {number} */ var cellW = dst.getWidth() / (gridWidth - 1);
 359         /** @type {number} */ var cellH = dst.getHeight() / (gridHeight - 1);
 360
 361         for (var y = 0; y < dst.getHeight(); y++) {
 362             for (var x = 0; x < dst.getWidth(); x++) {
 363                 /** @type {number} */ var cellX = deMath.clamp(Math.floor(x / cellW), 0, gridWidth - 2);
 364                 /** @type {number} */ var cellY = deMath.clamp(Math.floor(y / cellH), 0, gridHeight - 2);
 365                 /** @type {number} */ var xf = (x - cellX * cellW + 0.5) / cellW;
 366                 /** @type {number} */ var yf = (y - cellY * cellH + 0.5) / cellH;
 367
 368                 /** @type {Array<number>} */ var v00 = es3fFragmentOutputTests.readVec4(vertices, ((cellY + 0) * gridWidth + cellX + 0) * numComponents, numComponents); // Vec4
 369                 /** @type {Array<number>} */ var v01 = es3fFragmentOutputTests.readVec4(vertices, ((cellY + 1) * gridWidth + cellX + 0) * numComponents, numComponents); // Vec4
 370                 /** @type {Array<number>} */ var v10 = es3fFragmentOutputTests.readVec4(vertices, ((cellY + 0) * gridWidth + cellX + 1) * numComponents, numComponents); // Vec4
 371                 /** @type {Array<number>} */ var v11 = es3fFragmentOutputTests.readVec4(vertices, ((cellY + 1) * gridWidth + cellX + 1) * numComponents, numComponents); // Vec4
 372
 373                 /** @type {boolean} */ var tri = xf + yf >= 1.0;
 374                 /** @type {Array<number>} */ var v0 = tri ? v11 : v00; // Vec4&
 375                 /** @type {Array<number>} */ var v1 = tri ? v01 : v10; // Vec4&
 376                 /** @type {Array<number>} */ var v2 = tri ? v10 : v01; // Vec4&
 377                 /** @type {number} */ var s = tri ? 1.0 - xf : xf;
 378                 /** @type {number} */ var t = tri ? 1.0 - yf : yf;
 379                 /** @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
 380
 381                 dst.setPixel(isSRGB ? tcuTextureUtil.linearToSRGB(color) : color, x, y);
 382             }
 383         }
 384     };
 385
 386     /**
 387      * es3fFragmentOutputTests.renderIntReference
 388      * @param {tcuTexture.PixelBufferAccess} dst
 389      * @param {number} gridWidth
 390      * @param {number} gridHeight
 391      * @param {number} numComponents
 392      * @param {Array<number>} vertices
 393      */
 394     es3fFragmentOutputTests.renderIntReference = function(dst, gridWidth, gridHeight, numComponents, vertices) {
 395
 396         /** @type {number} */ var cellW = dst.getWidth() / (gridWidth - 1);
 397         /** @type {number} */ var cellH = dst.getHeight() / (gridHeight - 1);
 398
 399         for (var y = 0; y < dst.getHeight(); y++) {
 400             for (var x = 0; x < dst.getWidth(); x++) {
 401                 /** @type {number} */ var cellX = deMath.clamp(Math.floor(x / cellW), 0, gridWidth - 2);
 402                 /** @type {number} */ var cellY = deMath.clamp(Math.floor(y / cellH), 0, gridHeight - 2);
 403                 /** @type {Array<number>} */ var c = es3fFragmentOutputTests.readIVec4(vertices, (cellY * gridWidth + cellX + 1) * numComponents, numComponents); // IVec4
 404
 405                 dst.setPixelInt(c, x, y);
 406             }
 407         }
 408     };
 409
 410     /**
 411      * es3fFragmentOutputTests.s_swizzles
 412      * @return {Array<Array<number>>}
 413      */
 414     es3fFragmentOutputTests.s_swizzles = function() {
 415         var mat_swizzles = [
 416             [0, 1, 2, 3],
 417             [1, 2, 3, 0],
 418             [2, 3, 0, 1],
 419             [3, 0, 1, 2],
 420             [3, 2, 1, 0],
 421             [2, 1, 0, 3],
 422             [1, 0, 3, 2],
 423             [0, 3, 2, 1]
 424         ];
 425
 426         return mat_swizzles;
 427     };
 428
 429     /**
 430      * es3fFragmentOutputTests.swizzleVec. Returns an Array from a position contained in the Array es3fFragmentOutputTests.s_swizzles []
 431      * @param {Array<number>} vec
 432      * @param {number} swzNdx
 433      * @return {Array<number>} Swizzled array
 434      */
 435     es3fFragmentOutputTests.swizzleVec = function(vec, swzNdx) {
 436     /** @type {Array<number>} */ var swz = es3fFragmentOutputTests.s_swizzles()[swzNdx % es3fFragmentOutputTests.s_swizzles().length];
 437
 438         return deMath.swizzle(vec, swz);
 439     };
 440
 441     /**
 442      * es3fFragmentOutputTests.AttachmentData struct class
 443      * @constructor
 444      * @return {Object}
 445      */
 446     es3fFragmentOutputTests.AttachmentData = function() {
 447         return {
 448         /** @type {tcuTexture.TextureFormat} */ format: null, //!< Actual format of attachment.
 449         /** @type {tcuTexture.TextureFormat} */ referenceFormat: null, //!< Used for reference rendering.
 450         /** @type {tcuTexture.TextureFormat} */ readFormat: null,
 451         /** @type {number} */ numWrittenChannels: 0,
 452         /** @type {gluShaderUtil.precision} */ outPrecision: gluShaderUtil.precision.PRECISION_LOWP,
 453         /** @type {ArrayBuffer} */ renderedData: null,
 454         /** @type {ArrayBuffer} */ referenceData: null
 455         };
 456     };
 457
 458     es3fFragmentOutputTests.FragmentOutputCase.prototype.iterate = function() {
 459         // Compute grid size & index list.
 460         /** @type {number} */ var minCellSize = 8;
 461         /** @type {Array<number>} */ var minBufSize = es3fFragmentOutputTests.getMinSize(this.m_fboSpec); // IVec2
 462         /** @type {number} */ var gridWidth = deMath.clamp(Math.floor(minBufSize[0] / minCellSize), 1, 255) + 1;
 463         /** @type {number} */ var gridHeight = deMath.clamp(Math.floor(minBufSize[1] / minCellSize), 1, 255) + 1;
 464         /** @type {number} */ var numVertices = gridWidth * gridHeight;
 465         /** @type {number} */ var numQuads = (gridWidth - 1) * (gridHeight - 1);
 466         /** @type {number} */ var numIndices = numQuads * 6;
 467
 468         /** @type {number} */ var numInputVecs = es3fFragmentOutputTests.getNumInputVectors(this.m_outputs);
 469         /** @type {Array<Array<number>>} */ var inputs = []; // originally vector<vector<deUint32>
 470
 471         for (var inputNdx = 0; inputNdx < numInputVecs; inputNdx++)
 472             inputs[inputNdx] = []; // inputs.length = numInputVecs;
 473
 474         /** @type {Array<number>} */ var positions = []; // originally vector<float>
 475         /** @type {Array<number>} */ var indices = []; // originally vector<deUint16>
 476
 477         /** @type {number} */ var readAlignment = 4;
 478         /** @type {number} */ var viewportW = minBufSize[0];
 479         /** @type {number} */ var viewportH = minBufSize[1];
 480         /** @type {number} */ var numAttachments = this.m_fboSpec.length;
 481
 482         /** @type {Array<number>} */ var drawBuffers = []; // originally vector<deUint32>
 483         /** @type {Array<es3fFragmentOutputTests.AttachmentData>} */ var attachments = [];
 484         /** @type {number} */ var attachmentW;
 485         /** @type {number} */ var attachmentH;
 486
 487         // Initialize attachment data.
 488         for (var ndx = 0; ndx < numAttachments; ndx++) {
 489             /** @type {tcuTexture.TextureFormat} */ var texFmt = gluTextureUtil.mapGLInternalFormat(this.m_fboSpec[ndx].format);
 490             /** @type {tcuTexture.TextureChannelClass} */ var chnClass = tcuTexture.getTextureChannelClass(texFmt.type);
 491             /** @type {boolean} */ var isFixedPoint = (chnClass == tcuTexture.TextureChannelClass.SIGNED_FIXED_POINT ||
 492                                                               chnClass == tcuTexture.TextureChannelClass.UNSIGNED_FIXED_POINT);
 493
 494             // \note Fixed-point formats use float reference to enable more accurate result verification.
 495             /** @type {tcuTexture.TextureFormat} */ var refFmt = isFixedPoint ? new tcuTexture.TextureFormat(texFmt.order, tcuTexture.ChannelType.FLOAT) : texFmt;
 496             /** @type {tcuTexture.TextureFormat} */ var readFmt = es3fFboTestUtil.getFramebufferReadFormat(texFmt);
 497             attachmentW = this.m_fboSpec[ndx].width;
 498             attachmentH = this.m_fboSpec[ndx].height;
 499
 500             drawBuffers[ndx] = gl.COLOR_ATTACHMENT0 + ndx;
 501             attachments[ndx] = new es3fFragmentOutputTests.AttachmentData();
 502             attachments[ndx].format = texFmt;
 503             attachments[ndx].readFormat = readFmt;
 504             attachments[ndx].referenceFormat = refFmt;
 505             attachments[ndx].renderedData = new ArrayBuffer(readFmt.getPixelSize() * attachmentW * attachmentH);
 506             attachments[ndx].referenceData = new ArrayBuffer(refFmt.getPixelSize() * attachmentW * attachmentH);
 507         }
 508
 509         // Initialize indices.
 510         for (var quadNdx = 0; quadNdx < numQuads; quadNdx++) {
 511             /** @type {number} */ var quadY = Math.floor(quadNdx / (gridWidth - 1));
 512             /** @type {number} */ var quadX = quadNdx - quadY * (gridWidth - 1);
 513
 514             indices[quadNdx * 6 + 0] = quadX + quadY * gridWidth;
 515             indices[quadNdx * 6 + 1] = quadX + (quadY + 1) * gridWidth;
 516             indices[quadNdx * 6 + 2] = quadX + quadY * gridWidth + 1;
 517             indices[quadNdx * 6 + 3] = indices[quadNdx * 6 + 1];
 518             indices[quadNdx * 6 + 4] = quadX + (quadY + 1) * gridWidth + 1;
 519             indices[quadNdx * 6 + 5] = indices[quadNdx * 6 + 2];
 520         }
 521
 522         /** @type {number} */ var xf = 0;
 523         /** @type {number} */ var yf = 0;
 524         for (var y = 0; y < gridHeight; y++) {
 525             for (var x = 0; x < gridWidth; x++) {
 526                 xf = x / (gridWidth - 1);
 527                 yf = y / (gridHeight - 1);
 528
 529                 positions[(y * gridWidth + x) * 4 + 0] = 2.0 * xf - 1.0;
 530                 positions[(y * gridWidth + x) * 4 + 1] = 2.0 * yf - 1.0;
 531                 positions[(y * gridWidth + x) * 4 + 2] = 0.0;
 532                 positions[(y * gridWidth + x) * 4 + 3] = 1.0;
 533             }
 534         }
 535         /** @type {es3fFragmentOutputTests.FragmentOutput} */ var output;
 536         /** @type {boolean} */ var isArray;
 537         /** @type {boolean} */ var isFloat;
 538         /** @type {boolean} */ var isInt;
 539         /** @type {boolean} */ var isUint;
 540         /** @type {number} */ var numVecs;
 541         /** @type {number} */ var numScalars;
 542
 543         var curInVec = 0;
 544         for (var outputNdx = 0; outputNdx < this.m_outputs.length; outputNdx++) {
 545             output = this.m_outputs[outputNdx];
 546             isFloat = gluShaderUtil.isDataTypeFloatOrVec(output.type);
 547             isInt = gluShaderUtil.isDataTypeIntOrIVec(output.type);
 548             isUint = gluShaderUtil.isDataTypeUintOrUVec(output.type);
 549             numVecs = output.arrayLength > 0 ? output.arrayLength : 1;
 550             numScalars = gluShaderUtil.getDataTypeScalarSize(output.type);
 551
 552             for (var vecNdx = 0; vecNdx < numVecs; vecNdx++) {
 553                 inputs[curInVec].length = numVertices * numScalars;
 554
 555                 // Record how many outputs are written in attachment.
 556                 DE_ASSERT(output.location + vecNdx < attachments.length);
 557                 attachments[output.location + vecNdx].numWrittenChannels = numScalars;
 558                 attachments[output.location + vecNdx].outPrecision = output.precision;
 559
 560                 /** @type {Array<number>} */ var range = null;
 561                 /** @type {Array<number>} */ var minVal = null;
 562                 /** @type {Array<number>} */ var maxVal = null;
 563                 /** @type {Array<number>} */ var fmtBits = null;
 564                 /** @type {Array<number>} */ var fmtMaxVal = [];
 565                 /** @type {Array<number>} */ var rangeDiv = null;
 566                 /** @type {Array<number>} */ var step = [];
 567                 /** @type {number} */ var ix = 0;
 568                 /** @type {number} */ var iy = 0;
 569                 /** @type {Array<number>} */ var c = null;
 570                 /** @type {number} */ var pos = 0;
 571                if (isFloat) {
 572                     range = es3fFragmentOutputTests.getFloatRange(output.precision); // Vec2
 573                     minVal = [range[0], range[0], range[0], range[0]]; // Vec4
 574                     maxVal = [range[1], range[1], range[1], range[1]]; // Vec4
 575
 576                     if (deMath.deInBounds32(output.location + vecNdx, 0, attachments.length)) {
 577                     // \note Floating-point precision conversion is not well-defined. For that reason we must
 578                     // limit value range to intersection of both data type and render target value ranges.
 579                     /** @type {tcuTextureUtil.TextureFormatInfo} */ var fmtInfo = tcuTextureUtil.getTextureFormatInfo(attachments[output.location + vecNdx].format);
 580                         minVal = deMath.max(minVal, fmtInfo.valueMin);
 581                         maxVal = deMath.min(maxVal, fmtInfo.valueMax);
 582                     }
 583
 584                     bufferedLogToConsole('out ' + curInVec + ' value range: ' + minVal + ' -> ' + maxVal);
 585
 586                     for (var y = 0; y < gridHeight; y++) {
 587                         for (var x = 0; x < gridWidth; x++) {
 588                             xf = x / (gridWidth - 1);
 589                             yf = y / (gridHeight - 1);
 590                             /** @type {number} */ var f0 = (xf + yf) * 0.5;
 591                             /** @type {number} */ var f1 = 0.5 + (xf - yf) * 0.5;
 592
 593                             /** @type {Array<number>} */ var f = es3fFragmentOutputTests.swizzleVec([f0, f1, 1.0 - f0, 1.0 - f1], curInVec); // Vec4
 594                             c = deMath.add(minVal, deMath.multiply(deMath.subtract(maxVal, minVal), f)); // Vec4
 595
 596                             pos = (y * gridWidth + x) * numScalars;
 597
 598                             for (var ndx = 0; ndx < numScalars; ndx++)
 599                                 inputs[curInVec][pos + ndx] = c[ndx];
 600                         }
 601                     }
 602                 } else if (isInt) {
 603                     range = es3fFragmentOutputTests.getIntRange(output.precision); // IVec2
 604                     minVal = [range[0], range[0], range[0], range[0]]; // IVec4
 605                     maxVal = [range[1], range[1], range[1], range[1]]; // IVec4
 606
 607                     if (deMath.deInBounds32(output.location + vecNdx, 0, attachments.length)) {
 608                         // Limit to range of output format as conversion mode is not specified.
 609                         fmtBits = tcuTextureUtil.getTextureFormatBitDepth(attachments[output.location + vecNdx].format); // IVec4
 610                         /** @type {Array<boolean>} */ var isZero = deMath.lessThanEqual(fmtBits, [0, 0, 0, 0]); // BVec4, array of booleans, size = 4
 611
 612                         /** @type {Array<number>} */ var fmtMinVal = []; // IVec4
 613
 614                         for (var i = 0; i < 4; i++) {
 615
 616                             // const IVec4 fmtMinVal = (-(tcu::Vector<deInt64, 4>(1) << (fmtBits - 1 ).cast<deInt64>())).asInt();
 617                             fmtMinVal[i] = -1 * Math.pow(2, fmtBits[i] - 1); // TODO: check implementation, original above
 618                             // const IVec4 fmtMaxVal = ((tcu::Vector<deInt64, 4>(1) << (fmtBits - 1 ).cast<deInt64>()) - deInt64(1)).asInt();
 619                             fmtMaxVal[i] = Math.pow(2, fmtBits[i] - 1) - 1; // TODO: check implementation, original above
 620                         }
 621
 622                         minVal = tcuTextureUtil.select(minVal, deMath.max(minVal, fmtMinVal), isZero);
 623                         maxVal = tcuTextureUtil.select(maxVal, deMath.min(maxVal, fmtMaxVal), isZero);
 624                     }
 625
 626                     bufferedLogToConsole('out ' + curInVec + ' value range: ' + minVal + ' -> ' + maxVal);
 627
 628                     rangeDiv = es3fFragmentOutputTests.swizzleVec([gridWidth - 1, gridHeight - 1, gridWidth - 1, gridHeight - 1], curInVec); // IVec4
 629                     for (var i = 0; i < 4; i++) {
 630                         // const IVec4 step = ((maxVal.cast<deInt64>() - minVal.cast<deInt64>()) / (rangeDiv.cast<deInt64>())).asInt();
 631                         step[i] = Math.floor((maxVal[i] - minVal[i]) / rangeDiv[i]); // TODO: check with the above line of code
 632                     }
 633
 634                     for (var y = 0; y < gridHeight; y++) {
 635                         for (var x = 0; x < gridWidth; x++) {
 636                             ix = gridWidth - x - 1;
 637                             iy = gridHeight - y - 1;
 638                             c = deMath.add(minVal, deMath.multiply(step, es3fFragmentOutputTests.swizzleVec([x, y, ix, iy], curInVec))); // IVec4
 639
 640                             pos = (y * gridWidth + x) * numScalars;
 641
 642                             for (var ndx = 0; ndx < numScalars; ndx++)
 643                                 inputs[curInVec][pos + ndx] = c[ndx];
 644                         }
 645                     }
 646                 } else if (isUint) {
 647                     range = es3fFragmentOutputTests.getUintRange(output.precision); // UVec2
 648                     maxVal = [range[1], range[1], range[1], range[1]]; // UVec4
 649
 650                     if (deMath.deInBounds32(output.location + vecNdx, 0, attachments.length)) {
 651                         // Limit to range of output format as conversion mode is not specified.
 652                         fmtBits = tcuTextureUtil.getTextureFormatBitDepth(attachments[output.location + vecNdx].format); // IVec4
 653
 654                         for (var i = 0; i < 4; i++) {
 655                             fmtMaxVal[i] = Math.pow(2, fmtBits[i]) - 1;
 656                         }
 657
 658                         maxVal = deMath.min(maxVal, fmtMaxVal);
 659                     }
 660
 661                     bufferedLogToConsole('out ' + curInVec + ' value range: ' + minVal + ' -> ' + maxVal);
 662
 663                     rangeDiv = es3fFragmentOutputTests.swizzleVec([gridWidth - 1, gridHeight - 1, gridWidth - 1, gridHeight - 1], curInVec); // IVec4
 664
 665                     for (var stepPos = 0; stepPos < maxVal.length; stepPos++) {
 666                         step[stepPos] = Math.floor(maxVal[stepPos] / rangeDiv[stepPos]);
 667                     }
 668
 669                     DE_ASSERT(range[0] == 0);
 670
 671                     for (var y = 0; y < gridHeight; y++) {
 672                         for (var x = 0; x < gridWidth; x++) {
 673                             ix = gridWidth - x - 1;
 674                             iy = gridHeight - y - 1;
 675                             c = deMath.multiply(step, es3fFragmentOutputTests.swizzleVec([x, y, ix, iy], curInVec)); // UVec4
 676                             pos = (y * gridWidth + x) * numScalars;
 677
 678                             DE_ASSERT(deMath.boolAll(deMath.lessThanEqual(c, maxVal))); // TODO: sometimes crashes here, condition not asserted
 679
 680                             for (var ndx = 0; ndx < numScalars; ndx++)
 681                                 inputs[curInVec][pos + ndx] = c[ndx];
 682                         }
 683                     }
 684                 } else
 685                     DE_ASSERT(false);
 686
 687                 curInVec += 1;
 688             }
 689         }
 690
 691         // Render using gl.
 692         gl.useProgram(this.m_program.getProgram());
 693         gl.bindFramebuffer(gl.FRAMEBUFFER, this.m_framebuffer);
 694         gl.viewport(0, 0, viewportW, viewportH);
 695         gl.drawBuffers(drawBuffers);
 696         gl.disable(gl.DITHER); // Dithering causes issues with unorm formats. Those issues could be worked around in threshold, but it makes validation less accurate.
 697
 698         /** @type {WebGLBuffer} */ var buffer = null;
 699         /** @type {string} */ var name;
 700         curInVec = 0;
 701         for (var outputNdx = 0; outputNdx < this.m_outputs.length; outputNdx++) {
 702             output = this.m_outputs[outputNdx];
 703             isArray = output.arrayLength > 0;
 704             isFloat = gluShaderUtil.isDataTypeFloatOrVec(output.type);
 705             isInt = gluShaderUtil.isDataTypeIntOrIVec(output.type);
 706             isUint = gluShaderUtil.isDataTypeUintOrUVec(output.type);
 707             /** @type {number} */ var scalarSize = gluShaderUtil.getDataTypeScalarSize(output.type);
 708             /** @type {number} */ var glScalarType = isFloat ? /* gluShaderUtil.DataType.FLOAT */ gl.FLOAT :
 709                                                      isInt ? /* gluShaderUtil.DataType.INT */ gl.INT :
 710                                                      isUint ? /* gluShaderUtil.DataType.UINT */ gl.UNSIGNED_INT : /* gluShaderUtil.DataType.INVALID */ gl.NONE;
 711             numVecs = isArray ? output.arrayLength : 1;
 712
 713             for (var vecNdx = 0; vecNdx < numVecs; vecNdx++) {
 714                 name = 'in' + outputNdx + (isArray ? '_' + vecNdx : '');
 715                 /** @type {number} */ var loc = gl.getAttribLocation(this.m_program.getProgram(), name);
 716
 717                 if (loc >= 0) {
 718                     buffer = gl.createBuffer();
 719                     gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
 720
 721                     gl.enableVertexAttribArray(loc);
 722                     if (isFloat) {
 723                         gl.bufferData(gl.ARRAY_BUFFER, new Float32Array(inputs[curInVec]), gl.STATIC_DRAW);
 724                         // KHRONOS WebGL 1.0 specification:
 725                         // void vertexAttribPointer(GLuint indx, GLint size, GLenum type, GLboolean normalized, GLsizei stride, GLintptr offset);
 726                         gl.vertexAttribPointer(loc, scalarSize, glScalarType, false, 0, 0); // offset = 0
 727                     } else {
 728                         gl.bufferData(gl.ARRAY_BUFFER, new Int32Array(inputs[curInVec]), gl.STATIC_DRAW);
 729                         // KHRONOS WebGL 2.0 specification:
 730                         // void vertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, GLintptr offset)
 731                         gl.vertexAttribIPointer(loc, scalarSize, glScalarType, 0, 0); // offset = 0
 732                     }
 733                 } else
 734                     bufferedLogToConsole('Warning: No location for attribute "' + name + '" found.');
 735
 736                 curInVec += 1;
 737             }
 738         }
 739
 740         /** @type {number} */ var posLoc = gl.getAttribLocation(this.m_program.getProgram(), 'a_position');
 741         // TCU_CHECK(posLoc >= 0);
 742         buffer = gl.createBuffer();
 743         gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
 744         gl.bufferData(gl.ARRAY_BUFFER, new Float32Array(positions), gl.STATIC_DRAW);
 745
 746         gl.enableVertexAttribArray(posLoc);
 747         gl.vertexAttribPointer(posLoc, 4, gl.FLOAT, false, 0, 0); // offset = 0
 748
 749         /** @type {WebGLBuffer} */ var indexObject = gl.createBuffer();
 750         gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, indexObject);
 751         gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, new Uint16Array(indices), gl.STATIC_DRAW);
 752
 753         gl.drawElements(gl.TRIANGLES, numIndices, gl.UNSIGNED_SHORT, 0); // offset = 0
 754
 755         // Render reference images.
 756
 757         var curInNdx = 0;
 758         for (var outputNdx = 0; outputNdx < this.m_outputs.length; outputNdx++) {
 759             output = this.m_outputs[outputNdx];
 760             isArray = output.arrayLength > 0;
 761             isFloat = gluShaderUtil.isDataTypeFloatOrVec(output.type);
 762             isInt = gluShaderUtil.isDataTypeIntOrIVec(output.type);
 763             isUint = gluShaderUtil.isDataTypeUintOrUVec(output.type);
 764             scalarSize = gluShaderUtil.getDataTypeScalarSize(output.type);
 765             numVecs = isArray ? output.arrayLength : 1;
 766
 767             for (var vecNdx = 0; vecNdx < numVecs; vecNdx++) {
 768                 /** @type {number} */ var location = output.location + vecNdx;
 769                 /** @type {Array<number>} */ var inputData = inputs[curInNdx];
 770
 771                 DE_ASSERT(deMath.deInBounds32(location, 0, this.m_fboSpec.length));
 772
 773                 /** @type {number} */ var bufW = this.m_fboSpec[location].width;
 774                 /** @type {number} */ var bufH = this.m_fboSpec[location].height;
 775                 /** @type {Object} */ var descriptor = {
 776                         format: attachments[location].referenceFormat,
 777                         width: bufW,
 778                         height: bufH,
 779                         depth: 1,
 780                         data: attachments[location].referenceData // ArrayBuffer
 781                 };
 782                 /** @type {tcuTexture.PixelBufferAccess} */ var buf = new tcuTexture.PixelBufferAccess(descriptor);
 783                 /** @type {tcuTexture.PixelBufferAccess} */ var viewportBuf = tcuTextureUtil.getSubregion(buf, 0, 0, 0, viewportW, viewportH, 1);
 784
 785                 if (isInt || isUint)
 786                     es3fFragmentOutputTests.renderIntReference(viewportBuf, gridWidth, gridHeight, scalarSize, inputData);
 787                 else if (isFloat)
 788                     es3fFragmentOutputTests.renderFloatReference(viewportBuf, gridWidth, gridHeight, scalarSize, inputData);
 789                 else
 790                     DE_ASSERT(false);
 791
 792                 curInNdx += 1;
 793             }
 794         }
 795
 796         // Compare all images.
 797         /** @type {boolean} */ var allLevelsOk = true;
 798         for (var attachNdx = 0; attachNdx < numAttachments; attachNdx++) {
 799             attachmentW = this.m_fboSpec[attachNdx].width;
 800             attachmentH = this.m_fboSpec[attachNdx].height;
 801             /** @type {number} */ var numValidChannels = attachments[attachNdx].numWrittenChannels;
 802             /** @type {Array<boolean>} */ var cmpMask = [numValidChannels >= 1, numValidChannels >= 2, numValidChannels >= 3, numValidChannels >= 4];
 803             /** @type {gluShaderUtil.precision} */ var outPrecision = attachments[attachNdx].outPrecision;
 804             /** @type {tcuTexture.TextureFormat} */ var format = attachments[attachNdx].format;
 805             /** @type {Object} */
 806             var renderedDescriptor = {
 807                     format: attachments[attachNdx].readFormat,
 808                     width: attachmentW,
 809                     height: attachmentH,
 810                     depth: 1,
 811                     rowPitch: deMath.deAlign32(attachments[attachNdx].readFormat.getPixelSize() * attachmentW, readAlignment),
 812                     slicePitch: 0,
 813                     data: attachments[attachNdx].renderedData // ArrayBuffer
 814             };
 815             /** @type {tcuTexture.PixelBufferAccess} */ var rendered = new tcuTexture.PixelBufferAccess(renderedDescriptor);
 816             /** @type {gluTextureUtil.TransferFormat} */ var transferFmt = gluTextureUtil.getTransferFormat(attachments[attachNdx].readFormat);
 817             gl.readBuffer(gl.COLOR_ATTACHMENT0 + attachNdx);
 818             gl.readPixels(0, 0, attachmentW, attachmentH, transferFmt.format, transferFmt.dataType, rendered.getDataPtr());
 819
 820             /** @type {Object} */
 821             var referenceDescriptor = {
 822                     format: attachments[attachNdx].referenceFormat,
 823                     width: attachmentW,
 824                     height: attachmentH,
 825                     depth: 1,
 826                     data: attachments[attachNdx].referenceData // ArrayBuffer
 827             };
 828             /** @type {tcuTexture.ConstPixelBufferAccess} */ var reference = new tcuTexture.ConstPixelBufferAccess(referenceDescriptor);
 829             /** @type {tcuTexture.TextureChannelClass} */ var texClass = tcuTexture.getTextureChannelClass(format.type);
 830             /** @type {boolean} */ var isOk = true;
 831             name = 'Attachment ' + attachNdx;
 832             /** @type {string} */ var desc = 'Color attachment ' + attachNdx;
 833             /** @type {Array<number>} */ var threshold;
 834
 835             bufferedLogToConsole('Attachment ' + attachNdx + ': ' + numValidChannels + ' channels have defined values and used for comparison');
 836
 837             switch (texClass) {
 838                 case tcuTexture.TextureChannelClass.FLOATING_POINT: {
 839                     /** @type {Array<number>} */ var formatThreshold = []; // UVec4 //!< Threshold computed based on format.
 840                     formatThreshold.length = 4;
 841                     /** @type {number} */ var precThreshold = 0; // deUint32 //!< Threshold computed based on output type precision
 842                     /** @type {Array<number>} */ var finalThreshold = []; // UVec4
 843                     finalThreshold.length = 4;
 844
 845                     switch (format.type) {
 846                         case tcuTexture.ChannelType.FLOAT:
 847                             formatThreshold = [4, 4, 4, 4]; // UVec4
 848                             break;
 849                         case tcuTexture.ChannelType.HALF_FLOAT:
 850                             formatThreshold = [(1 << 13) + 4, (1 << 13) + 4, (1 << 13) + 4, (1 << 13) + 4]; // UVec4
 851                             break;
 852                         case tcuTexture.ChannelType.UNSIGNED_INT_11F_11F_10F_REV:
 853                             formatThreshold = [(1 << 17) + 4, (1 << 17) + 4, (1 << 18) + 4, 4]; // UVec4
 854                             break;
 855                         default:
 856                             DE_ASSERT(false);
 857                             break;
 858                     }
 859
 860                     switch (outPrecision) {
 861                         case gluShaderUtil.precision.PRECISION_LOWP:
 862                             precThreshold = (1 << 21);
 863                             break;
 864                         case gluShaderUtil.precision.PRECISION_MEDIUMP:
 865                             precThreshold = (1 << 13);
 866                             break;
 867                         case gluShaderUtil.precision.PRECISION_HIGHP:
 868                             precThreshold = 0;
 869                             break;
 870                         default:
 871                             DE_ASSERT(false);
 872                     }
 873
 874                     finalThreshold = tcuTextureUtil.select(
 875                                     deMath.max(formatThreshold, [precThreshold, precThreshold, precThreshold, precThreshold]),
 876                                     [0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff], // C++ version: UVec4(~0u) bitwise not, all bits in the integer will be flipped
 877                                     cmpMask);
 878
 879                     isOk = tcuImageCompare.floatUlpThresholdCompare(name, desc, reference, rendered, finalThreshold /*, tcu::COMPARE_LOG_RESULT*/);
 880                     break;
 881                 }
 882
 883                 case tcuTexture.TextureChannelClass.UNSIGNED_FIXED_POINT: {
 884                     // \note glReadPixels() allows only 8 bits to be read. This means that RGB10_A2 will loose some
 885                     // bits in the process and it must be taken into account when computing threshold.
 886                     /** @type {Array<number>} */ var bits = deMath.min([8, 8, 8, 8], tcuTextureUtil.getTextureFormatBitDepth(format)); // IVec4
 887
 888                     /** @type {Array<number>} */ var baseThreshold = []; // Vec4
 889                     baseThreshold.length = 4;
 890                     for (var inc = 0; inc < baseThreshold.length; inc++) {
 891                         // TODO: check the operation below: baseThreshold = 1.0f / ((IVec4(1) << bits)-1).asFloat();
 892                         baseThreshold[inc] = 1.0 / ((1 << bits[inc]) - 1);
 893                     }
 894
 895                     threshold = tcuTextureUtil.select(baseThreshold, [2.0, 2.0, 2.0, 2.0], cmpMask); // Vec4
 896
 897                     isOk = tcuImageCompare.floatThresholdCompare(name, desc, reference, rendered, threshold/*, tcu::COMPARE_LOG_RESULT*/);
 898                     break;
 899                 }
 900
 901                 case tcuTexture.TextureChannelClass.SIGNED_INTEGER:
 902                 case tcuTexture.TextureChannelClass.UNSIGNED_INTEGER: {
 903                     // The C++ dEQP code uses ~0u but ~0 is -1 in Javascript
 904                     var UINT_MAX = Math.pow(2.0, 32.0) - 1;
 905                     threshold = tcuTextureUtil.select(
 906                                     [0, 0, 0, 0],
 907                                     [UINT_MAX, UINT_MAX, UINT_MAX, UINT_MAX],
 908                                     cmpMask
 909                                     ); // UVec4
 910                     isOk = tcuImageCompare.intThresholdCompare(name, desc, reference, rendered, threshold/*, tcu::COMPARE_LOG_RESULT*/);
 911                     break;
 912                 }
 913
 914                 default:
 915                     testFailedOptions('Unsupported comparison', true);
 916                     break;
 917             }
 918
 919             if (!isOk)
 920                 allLevelsOk = false;
 921         }
 922
 923         if (numAttachments > 1) {
 924             if (allLevelsOk)
 925                 testPassed('Image comparison passed for ' +  numAttachments + ' attachments');
 926             else
 927                 testFailed('Image comparison failed for some of ' +  numAttachments + ' attachments');
 928         } else {
 929             if (allLevelsOk)
 930                 testPassed('Image comparison passed');
 931             else
 932                 testFailed('Image comparison failed');
 933         }
 934
 935         return tcuTestCase.IterateResult.STOP;
 936     };
 937
 938     /**
 939      * es3fFragmentOutputTests.createRandomCase. Constructs the es3fFragmentOutputTests.createRandomCase, child class of es3fFragmentOutputTests.FragmentOutputCase
 940      * @constructor
 941      * @param {number} minRenderTargets
 942      * @param {number} maxRenderTargets
 943      * @param {number} seed
 944      * @return {es3fFragmentOutputTests.FragmentOutputCase} The currently modified object
 945      */
 946     es3fFragmentOutputTests.createRandomCase = function(minRenderTargets, maxRenderTargets, seed, colorBufferFloatSupported) {
 947
 948         /** @type {Array<gluShaderUtil.DataType>} */
 949         var outputTypes = [
 950                            gluShaderUtil.DataType.FLOAT,
 951                            gluShaderUtil.DataType.FLOAT_VEC2,
 952                            gluShaderUtil.DataType.FLOAT_VEC3,
 953                            gluShaderUtil.DataType.FLOAT_VEC4,
 954                            gluShaderUtil.DataType.INT,
 955                            gluShaderUtil.DataType.INT_VEC2,
 956                            gluShaderUtil.DataType.INT_VEC3,
 957                            gluShaderUtil.DataType.INT_VEC4,
 958                            gluShaderUtil.DataType.UINT,
 959                            gluShaderUtil.DataType.UINT_VEC2,
 960                            gluShaderUtil.DataType.UINT_VEC3,
 961                            gluShaderUtil.DataType.UINT_VEC4
 962                            ];
 963
 964         /** @type {Array<gluShaderUtil.precision>} */
 965         var precisions = [
 966                           gluShaderUtil.precision.PRECISION_LOWP,
 967                           gluShaderUtil.precision.PRECISION_MEDIUMP,
 968                           gluShaderUtil.precision.PRECISION_HIGHP
 969                           ];
 970
 971         /** @type {Array<WebGLRenderingContextBase.GLenum>} */
 972         var floatFormats = [
 973                             gl.RGBA32F,
 974                             gl.RGBA16F,
 975                             gl.R11F_G11F_B10F,
 976                             gl.RG32F,
 977                             gl.RG16F,
 978                             gl.R32F,
 979                             gl.R16F,
 980                             gl.RGBA8,
 981                             gl.SRGB8_ALPHA8,
 982                             gl.RGB10_A2,
 983                             gl.RGBA4,
 984                             gl.RGB5_A1,
 985                             gl.RGB8,
 986                             gl.RGB565,
 987                             gl.RG8,
 988                             gl.R8
 989                             ];
 990
 991         /** @type {Array<WebGLRenderingContextBase.GLenum>} */
 992         var colorBufferFloatFormats = [
 993                                        gl.RGBA32F,
 994                                        gl.RGBA16F,
 995                                        gl.R11F_G11F_B10F,
 996                                        gl.RG32F,
 997                                        gl.RG16F,
 998                                        gl.R32F,
 999                                        gl.R16F
1000         ];
1001
1002
1003         /** @type {Array<WebGLRenderingContextBase.GLenum>} */
1004         var intFormats = [
1005                             gl.RGBA32I,
1006                             gl.RGBA16I,
1007                             gl.RGBA8I,
1008                             gl.RG32I,
1009                             gl.RG16I,
1010                             gl.RG8I,
1011                             gl.R32I,
1012                             gl.R16I,
1013                             gl.R8I
1014                             ];
1015
1016         /** @type {Array<WebGLRenderingContextBase.GLenum>} */
1017         var uintFormats = [
1018                            gl.RGBA32UI,
1019                            gl.RGBA16UI,
1020                            gl.RGBA8UI,
1021                            gl.RGB10_A2UI,
1022                            gl.RG32UI,
1023                            gl.RG16UI,
1024                            gl.RG8UI,
1025                            gl.R32UI,
1026                            gl.R16UI,
1027                            gl.R8UI
1028                            ];
1029
1030         /** @type {deRandom.Random} */ var rnd = new deRandom.Random(seed);
1031         /** @type {Array<es3fFragmentOutputTests.FragmentOutput>} */ var outputs = [];
1032         /** @type {Array<es3fFragmentOutputTests.BufferSpec>} */ var targets = [];
1033         /** @type {Array<gluShaderUtil.DataType>} */ var outTypes = [];
1034
1035         /** @type {number} */ var numTargets = rnd.getInt(minRenderTargets, maxRenderTargets);
1036         /** @type {number} */ var width = 128; // \todo [2012-04-10 pyry] Separate randomized sizes per target?
1037         /** @type {number} */ var height = 64;
1038         /** @type {number} */ var samples = 0;
1039
1040         // Compute outputs.
1041         /** @type {number} */ var curLoc = 0;
1042         while (curLoc < numTargets) {
1043             /** @type {boolean} */ var useArray = rnd.getFloat() < 0.3;
1044             /** @type {number} */ var maxArrayLen = numTargets - curLoc;
1045             /** @type {number} */ var arrayLen = useArray ? rnd.getInt(1, maxArrayLen) : 0;
1046             /** @type {Array<gluShaderUtil.DataType>} */ var basicTypeArray = rnd.choose(outputTypes, undefined, 1);
1047             /** @type {gluShaderUtil.DataType} */ var basicType = basicTypeArray[0];
1048             /** @type {Array<gluShaderUtil.precision>} */ var precisionArray = rnd.choose(precisions, undefined, 1);
1049             /** @type {gluShaderUtil.precision} */ var precision = precisionArray[0];
1050             /** @type {number} */ var numLocations = useArray ? arrayLen : 1;
1051
1052             outputs.push(new es3fFragmentOutputTests.FragmentOutput(basicType, precision, curLoc, arrayLen));
1053
1054             for (var ndx = 0; ndx < numLocations; ndx++)
1055                 outTypes.push(basicType);
1056
1057             curLoc += numLocations;
1058         }
1059         DE_ASSERT(curLoc == numTargets);
1060         DE_ASSERT(outTypes.length == numTargets);
1061
1062         // Compute buffers.
1063         while (targets.length < numTargets) {
1064             /** @type {gluShaderUtil.DataType} */ var outType = outTypes[targets.length];
1065             /** @type {boolean} */ var isFloat = gluShaderUtil.isDataTypeFloatOrVec(outType);
1066             /** @type {boolean} */ var isInt = gluShaderUtil.isDataTypeIntOrIVec(outType);
1067             /** @type {boolean} */ var isUint = gluShaderUtil.isDataTypeUintOrUVec(outType);
1068             /** @type {Array} */ var formatArray = [];
1069             /** @type {number} */ var format = 0;
1070
1071             if (isFloat) {
1072                 formatArray = rnd.choose(floatFormats, undefined, 1);
1073                 format = formatArray[0];
1074                 if (colorBufferFloatFormats.indexOf(format) >= 0 && !colorBufferFloatSupported)
1075                     return null;
1076             } else if (isInt) {
1077                 formatArray = rnd.choose(intFormats, undefined, 1);
1078                 format = formatArray[0];
1079             } else if (isUint) {
1080                 formatArray = rnd.choose(uintFormats, undefined, 1);
1081                 format = formatArray[0];
1082             } else
1083                 DE_ASSERT(false);
1084
1085             targets.push(new es3fFragmentOutputTests.BufferSpec(format, width, height, samples));
1086         }
1087
1088         return new es3fFragmentOutputTests.FragmentOutputCase(seed.toString(), '', targets, outputs);
1089
1090     };
1091
1092     es3fFragmentOutputTests.init = function(gl) {
1093         var state = tcuTestCase.runner;
1094         state.testCases = tcuTestCase.newTest('fragment_outputs', 'Top level');
1095         /** @const @type {tcuTestCase.DeqpTest} */ var testGroup = state.testCases;
1096
1097         /** @type {Array<WebGLRenderingContextBase.GLenum>} */
1098         var requiredFloatFormats = [
1099             gl.RGBA32F,
1100             gl.RGBA16F,
1101             gl.R11F_G11F_B10F,
1102             gl.RG32F,
1103             gl.RG16F,
1104             gl.R32F,
1105             gl.R16F
1106         ];
1107
1108         /** @type {Array<WebGLRenderingContextBase.GLenum>} */
1109         var requiredFixedFormats = [
1110             gl.RGBA8,
1111             gl.SRGB8_ALPHA8,
1112             gl.RGB10_A2,
1113             gl.RGBA4,
1114             gl.RGB5_A1,
1115             gl.RGB8,
1116             gl.RGB565,
1117             gl.RG8,
1118             gl.R8
1119         ];
1120
1121         /** @type {Array<WebGLRenderingContextBase.GLenum>} */
1122         var requiredIntFormats = [
1123             gl.RGBA32I,
1124             gl.RGBA16I,
1125             gl.RGBA8I,
1126             gl.RG32I,
1127             gl.RG16I,
1128             gl.RG8I,
1129             gl.R32I,
1130             gl.R16I,
1131             gl.R8I
1132         ];
1133
1134         /** @type {Array<WebGLRenderingContextBase.GLenum>} */
1135         var requiredUintFormats = [
1136             gl.RGBA32UI,
1137             gl.RGBA16UI,
1138             gl.RGBA8UI,
1139             gl.RGB10_A2UI,
1140             gl.RG32UI,
1141             gl.RG16UI,
1142             gl.RG8UI,
1143             gl.R32UI,
1144             gl.R16UI,
1145             gl.R8UI
1146         ];
1147
1148         /** @type {Array<gluShaderUtil.precision>} */
1149         var precisions = [
1150
1151             gluShaderUtil.precision.PRECISION_LOWP,
1152             gluShaderUtil.precision.PRECISION_MEDIUMP,
1153             gluShaderUtil.precision.PRECISION_HIGHP
1154
1155         ];
1156
1157      // .basic.
1158
1159         /** @const @type {number} */ var width = 64;
1160         /** @const @type {number} */ var height = 64;
1161         /** @const @type {number} */ var samples = 0;
1162         /** @type {Array<es3fFragmentOutputTests.BufferSpec>} */ var fboSpec = null;
1163         /** @type {gluShaderUtil.precision} */ var prec;
1164         /** @type {string} */ var precName;
1165
1166     // .float
1167         if (gl.getExtension('EXT_color_buffer_float')) {
1168             /** @type {tcuTestCase.DeqpTest} */ var floatGroup = tcuTestCase.newTest('basic.float', 'Floating-point output tests');
1169             testGroup.addChild(floatGroup);
1170
1171             for (var fmtNdx = 0; fmtNdx < requiredFloatFormats.length; fmtNdx++) {
1172                 var format = requiredFloatFormats[fmtNdx];
1173                 var fmtName = es3fFboTestUtil.getFormatName(format);
1174                 fboSpec = [];
1175
1176                 fboSpec.push(new es3fFragmentOutputTests.BufferSpec(format, width, height, samples));
1177
1178                 for (var precNdx = 0; precNdx < precisions.length; precNdx++) {
1179                     prec = precisions[precNdx];
1180                     precName = gluShaderUtil.getPrecisionName(prec);
1181
1182                     // NOTE: Eliminated original OutputVec and toVec(), as it only returned an element of the outputs array in OutputVec
1183                     floatGroup.addChild(new es3fFragmentOutputTests.FragmentOutputCase(fmtName + '_' + precName + '_float', '', fboSpec, [new es3fFragmentOutputTests.FragmentOutput(gluShaderUtil.DataType.FLOAT, prec, 0)]));
1184                     floatGroup.addChild(new es3fFragmentOutputTests.FragmentOutputCase(fmtName + '_' + precName + '_vec2', '', fboSpec, [new es3fFragmentOutputTests.FragmentOutput(gluShaderUtil.DataType.FLOAT_VEC2, prec, 0)]));
1185                     floatGroup.addChild(new es3fFragmentOutputTests.FragmentOutputCase(fmtName + '_' + precName + '_vec3', '', fboSpec, [new es3fFragmentOutputTests.FragmentOutput(gluShaderUtil.DataType.FLOAT_VEC3, prec, 0)]));
1186                     floatGroup.addChild(new es3fFragmentOutputTests.FragmentOutputCase(fmtName + '_' + precName + '_vec4', '', fboSpec, [new es3fFragmentOutputTests.FragmentOutput(gluShaderUtil.DataType.FLOAT_VEC4, prec, 0)]));
1187                 }
1188             }
1189         }
1190
1191         // .fixed
1192         /** @type {tcuTestCase.DeqpTest} */ var fixedGroup = tcuTestCase.newTest('basic.fixed', 'Fixed-point output tests');
1193         testGroup.addChild(fixedGroup);
1194         for (var fmtNdx = 0; fmtNdx < requiredFixedFormats.length; fmtNdx++) {
1195             var format = requiredFixedFormats[fmtNdx];
1196             var fmtName = es3fFboTestUtil.getFormatName(format);
1197             fboSpec = [];
1198
1199             fboSpec.push(new es3fFragmentOutputTests.BufferSpec(format, width, height, samples));
1200
1201             for (var precNdx = 0; precNdx < precisions.length; precNdx++) {
1202                 prec = precisions[precNdx];
1203                 precName = gluShaderUtil.getPrecisionName(prec);
1204
1205                 fixedGroup.addChild(new es3fFragmentOutputTests.FragmentOutputCase(fmtName + '_' + precName + '_float', '', fboSpec, [new es3fFragmentOutputTests.FragmentOutput(gluShaderUtil.DataType.FLOAT, prec, 0)]));
1206                 fixedGroup.addChild(new es3fFragmentOutputTests.FragmentOutputCase(fmtName + '_' + precName + '_vec2', '', fboSpec, [new es3fFragmentOutputTests.FragmentOutput(gluShaderUtil.DataType.FLOAT_VEC2, prec, 0)]));
1207                 fixedGroup.addChild(new es3fFragmentOutputTests.FragmentOutputCase(fmtName + '_' + precName + '_vec3', '', fboSpec, [new es3fFragmentOutputTests.FragmentOutput(gluShaderUtil.DataType.FLOAT_VEC3, prec, 0)]));
1208                 fixedGroup.addChild(new es3fFragmentOutputTests.FragmentOutputCase(fmtName + '_' + precName + '_vec4', '', fboSpec, [new es3fFragmentOutputTests.FragmentOutput(gluShaderUtil.DataType.FLOAT_VEC4, prec, 0)]));
1209             }
1210         }
1211
1212         // .int
1213         /** @type {tcuTestCase.DeqpTest} */ var intGroup = tcuTestCase.newTest('basic.int', 'Integer output tests');
1214         testGroup.addChild(intGroup);
1215         for (var fmtNdx = 0; fmtNdx < requiredIntFormats.length; fmtNdx++) {
1216             var format = requiredIntFormats[fmtNdx];
1217             var fmtName = es3fFboTestUtil.getFormatName(format);
1218             fboSpec = [];
1219
1220             fboSpec.push(new es3fFragmentOutputTests.BufferSpec(format, width, height, samples));
1221
1222             for (var precNdx = 0; precNdx < precisions.length; precNdx++) {
1223                 prec = precisions[precNdx];
1224                 precName = gluShaderUtil.getPrecisionName(prec);
1225
1226                 intGroup.addChild(new es3fFragmentOutputTests.FragmentOutputCase(fmtName + '_' + precName + '_int', '', fboSpec, [new es3fFragmentOutputTests.FragmentOutput(gluShaderUtil.DataType.INT, prec, 0)]));
1227                 intGroup.addChild(new es3fFragmentOutputTests.FragmentOutputCase(fmtName + '_' + precName + '_ivec2', '', fboSpec, [new es3fFragmentOutputTests.FragmentOutput(gluShaderUtil.DataType.INT_VEC2, prec, 0)]));
1228                 intGroup.addChild(new es3fFragmentOutputTests.FragmentOutputCase(fmtName + '_' + precName + '_ivec3', '', fboSpec, [new es3fFragmentOutputTests.FragmentOutput(gluShaderUtil.DataType.INT_VEC3, prec, 0)]));
1229                 intGroup.addChild(new es3fFragmentOutputTests.FragmentOutputCase(fmtName + '_' + precName + '_ivec4', '', fboSpec, [new es3fFragmentOutputTests.FragmentOutput(gluShaderUtil.DataType.INT_VEC4, prec, 0)]));
1230             }
1231         }
1232
1233         // .uint
1234         /** @type {tcuTestCase.DeqpTest} */ var uintGroup = tcuTestCase.newTest('basic.uint', 'Usigned integer output tests');
1235         testGroup.addChild(uintGroup);
1236         for (var fmtNdx = 0; fmtNdx < requiredUintFormats.length; fmtNdx++) {
1237             var format = requiredUintFormats[fmtNdx];
1238             var fmtName = es3fFboTestUtil.getFormatName(format);
1239             fboSpec = [];
1240
1241             fboSpec.push(new es3fFragmentOutputTests.BufferSpec(format, width, height, samples));
1242
1243             for (var precNdx = 0; precNdx < precisions.length; precNdx++) {
1244                 prec = precisions[precNdx];
1245                 precName = gluShaderUtil.getPrecisionName(prec);
1246
1247                 uintGroup.addChild(new es3fFragmentOutputTests.FragmentOutputCase(fmtName + '_' + precName + '_uint', '', fboSpec, [new es3fFragmentOutputTests.FragmentOutput(gluShaderUtil.DataType.UINT, prec, 0)]));
1248                 uintGroup.addChild(new es3fFragmentOutputTests.FragmentOutputCase(fmtName + '_' + precName + '_uvec2', '', fboSpec, [new es3fFragmentOutputTests.FragmentOutput(gluShaderUtil.DataType.UINT_VEC2, prec, 0)]));
1249                 uintGroup.addChild(new es3fFragmentOutputTests.FragmentOutputCase(fmtName + '_' + precName + '_uvec3', '', fboSpec, [new es3fFragmentOutputTests.FragmentOutput(gluShaderUtil.DataType.UINT_VEC3, prec, 0)]));
1250                 uintGroup.addChild(new es3fFragmentOutputTests.FragmentOutputCase(fmtName + '_' + precName + '_uvec4', '', fboSpec, [new es3fFragmentOutputTests.FragmentOutput(gluShaderUtil.DataType.UINT_VEC4, prec, 0)]));
1251
1252             }
1253         }
1254
1255      // .array
1256
1257         /** @type {number} */ var numTargets = 3;
1258
1259         // .float
1260         if (gl.getExtension('EXT_color_buffer_float')) {
1261             /** @type {tcuTestCase.DeqpTest} */ var arrayFloatGroup = tcuTestCase.newTest('array.float', 'Floating-point output tests');
1262             testGroup.addChild(arrayFloatGroup);
1263             for (var fmtNdx = 0; fmtNdx < requiredFloatFormats.length; fmtNdx++) {
1264                 var format = requiredFloatFormats[fmtNdx];
1265                 var fmtName = es3fFboTestUtil.getFormatName(format);
1266                 fboSpec = [];
1267
1268                 for (var ndx = 0; ndx < numTargets; ndx++)
1269                     fboSpec.push(new es3fFragmentOutputTests.BufferSpec(format, width, height, samples));
1270
1271                 for (var precNdx = 0; precNdx < precisions.length; precNdx++) {
1272                     prec = precisions[precNdx];
1273                     precName = gluShaderUtil.getPrecisionName(prec);
1274
1275                     arrayFloatGroup.addChild(new es3fFragmentOutputTests.FragmentOutputCase(fmtName + '_' + precName + '_float', '', fboSpec, [new es3fFragmentOutputTests.FragmentOutput(gluShaderUtil.DataType.FLOAT, prec, 0, numTargets)]));
1276                     arrayFloatGroup.addChild(new es3fFragmentOutputTests.FragmentOutputCase(fmtName + '_' + precName + '_vec2', '', fboSpec, [new es3fFragmentOutputTests.FragmentOutput(gluShaderUtil.DataType.FLOAT_VEC2, prec, 0, numTargets)]));
1277                     arrayFloatGroup.addChild(new es3fFragmentOutputTests.FragmentOutputCase(fmtName + '_' + precName + '_vec3', '', fboSpec, [new es3fFragmentOutputTests.FragmentOutput(gluShaderUtil.DataType.FLOAT_VEC3, prec, 0, numTargets)]));
1278                     arrayFloatGroup.addChild(new es3fFragmentOutputTests.FragmentOutputCase(fmtName + '_' + precName + '_vec4', '', fboSpec, [new es3fFragmentOutputTests.FragmentOutput(gluShaderUtil.DataType.FLOAT_VEC4, prec, 0, numTargets)]));
1279                 }
1280             }
1281         }
1282
1283         // .fixed
1284         /** @type {tcuTestCase.DeqpTest} */ var arrayFixedGroup = tcuTestCase.newTest('array.fixed', 'Fixed-point output tests');
1285         testGroup.addChild(arrayFixedGroup);
1286         for (var fmtNdx = 0; fmtNdx < requiredFixedFormats.length; fmtNdx++) {
1287             var format = requiredFixedFormats[fmtNdx];
1288             var fmtName = es3fFboTestUtil.getFormatName(format);
1289             fboSpec = [];
1290
1291             for (var ndx = 0; ndx < numTargets; ndx++)
1292                 fboSpec.push(new es3fFragmentOutputTests.BufferSpec(format, width, height, samples));
1293
1294             for (var precNdx = 0; precNdx < precisions.length; precNdx++) {
1295                 prec = precisions[precNdx];
1296                 precName = gluShaderUtil.getPrecisionName(prec);
1297
1298                 arrayFixedGroup.addChild(new es3fFragmentOutputTests.FragmentOutputCase(fmtName + '_' + precName + '_float', '', fboSpec, [new es3fFragmentOutputTests.FragmentOutput(gluShaderUtil.DataType.FLOAT, prec, 0, numTargets)]));
1299                 arrayFixedGroup.addChild(new es3fFragmentOutputTests.FragmentOutputCase(fmtName + '_' + precName + '_vec2', '', fboSpec, [new es3fFragmentOutputTests.FragmentOutput(gluShaderUtil.DataType.FLOAT_VEC2, prec, 0, numTargets)]));
1300                 arrayFixedGroup.addChild(new es3fFragmentOutputTests.FragmentOutputCase(fmtName + '_' + precName + '_vec3', '', fboSpec, [new es3fFragmentOutputTests.FragmentOutput(gluShaderUtil.DataType.FLOAT_VEC3, prec, 0, numTargets)]));
1301                 arrayFixedGroup.addChild(new es3fFragmentOutputTests.FragmentOutputCase(fmtName + '_' + precName + '_vec4', '', fboSpec, [new es3fFragmentOutputTests.FragmentOutput(gluShaderUtil.DataType.FLOAT_VEC4, prec, 0, numTargets)]));
1302             }
1303         }
1304
1305         // .int
1306         /** @type {tcuTestCase.DeqpTest} */ var arrayIntGroup = tcuTestCase.newTest('array.int', 'Integer output tests');
1307         testGroup.addChild(arrayIntGroup);
1308         for (var fmtNdx = 0; fmtNdx < requiredIntFormats.length; fmtNdx++) {
1309             var format = requiredIntFormats[fmtNdx];
1310             var fmtName = es3fFboTestUtil.getFormatName(format);
1311             fboSpec = [];
1312
1313             for (var ndx = 0; ndx < numTargets; ndx++)
1314                 fboSpec.push(new es3fFragmentOutputTests.BufferSpec(format, width, height, samples));
1315
1316             for (var precNdx = 0; precNdx < precisions.length; precNdx++) {
1317                 prec = precisions[precNdx];
1318                 precName = gluShaderUtil.getPrecisionName(prec);
1319
1320                 arrayIntGroup.addChild(new es3fFragmentOutputTests.FragmentOutputCase(fmtName + '_' + precName + '_int', '', fboSpec, [new es3fFragmentOutputTests.FragmentOutput(gluShaderUtil.DataType.INT, prec, 0, numTargets)]));
1321                 arrayIntGroup.addChild(new es3fFragmentOutputTests.FragmentOutputCase(fmtName + '_' + precName + '_ivec2', '', fboSpec, [new es3fFragmentOutputTests.FragmentOutput(gluShaderUtil.DataType.INT_VEC2, prec, 0, numTargets)]));
1322                 arrayIntGroup.addChild(new es3fFragmentOutputTests.FragmentOutputCase(fmtName + '_' + precName + '_ivec3', '', fboSpec, [new es3fFragmentOutputTests.FragmentOutput(gluShaderUtil.DataType.INT_VEC3, prec, 0, numTargets)]));
1323                 arrayIntGroup.addChild(new es3fFragmentOutputTests.FragmentOutputCase(fmtName + '_' + precName + '_ivec4', '', fboSpec, [new es3fFragmentOutputTests.FragmentOutput(gluShaderUtil.DataType.INT_VEC4, prec, 0, numTargets)]));
1324             }
1325         }
1326
1327         // .uint
1328         /** @type {tcuTestCase.DeqpTest} */ var arrayUintGroup = tcuTestCase.newTest('array.uint', 'Usigned integer output tests');
1329         testGroup.addChild(arrayUintGroup);
1330         for (var fmtNdx = 0; fmtNdx < requiredUintFormats.length; fmtNdx++) {
1331             var format = requiredUintFormats[fmtNdx];
1332             var fmtName = es3fFboTestUtil.getFormatName(format);
1333             fboSpec = [];
1334
1335             for (var ndx = 0; ndx < numTargets; ndx++)
1336                 fboSpec.push(new es3fFragmentOutputTests.BufferSpec(format, width, height, samples));
1337
1338             for (var precNdx = 0; precNdx < precisions.length; precNdx++) {
1339                 prec = precisions[precNdx];
1340                 precName = gluShaderUtil.getPrecisionName(prec);
1341
1342                 arrayUintGroup.addChild(new es3fFragmentOutputTests.FragmentOutputCase(fmtName + '_' + precName + '_uint', '', fboSpec, [new es3fFragmentOutputTests.FragmentOutput(gluShaderUtil.DataType.UINT, prec, 0, numTargets)]));
1343                 arrayUintGroup.addChild(new es3fFragmentOutputTests.FragmentOutputCase(fmtName + '_' + precName + '_uvec2', '', fboSpec, [new es3fFragmentOutputTests.FragmentOutput(gluShaderUtil.DataType.UINT_VEC2, prec, 0, numTargets)]));
1344                 arrayUintGroup.addChild(new es3fFragmentOutputTests.FragmentOutputCase(fmtName + '_' + precName + '_uvec3', '', fboSpec, [new es3fFragmentOutputTests.FragmentOutput(gluShaderUtil.DataType.UINT_VEC3, prec, 0, numTargets)]));
1345                 arrayUintGroup.addChild(new es3fFragmentOutputTests.FragmentOutputCase(fmtName + '_' + precName + '_uvec4', '', fboSpec, [new es3fFragmentOutputTests.FragmentOutput(gluShaderUtil.DataType.UINT_VEC4, prec, 0, numTargets)]));
1346             }
1347         }
1348
1349     // .random
1350
1351         /** @type {Array<tcuTestCase.DeqpTest>} */ var randomGroup = [];
1352         var numRandomGroups = 3;
1353         for (var ii = 0; ii < numRandomGroups; ++ii) {
1354             randomGroup[ii] = tcuTestCase.newTest('random', 'Random fragment output cases');
1355             testGroup.addChild(randomGroup[ii]);
1356         }
1357
1358         /** @type {boolean} */ var colorBufferFloatSupported = (gl.getExtension('EXT_color_buffer_float') != null);
1359         for (var seed = 0; seed < 100; seed++) {
1360             var test = es3fFragmentOutputTests.createRandomCase(2, 4, seed, colorBufferFloatSupported);
1361             if (test !== null) {
1362                 randomGroup[seed % numRandomGroups].addChild(test);
1363             }
1364         }
1365
1366     };
1367
1368     /**
1369      * Create and execute the test cases
1370      */
1371     es3fFragmentOutputTests.run = function(context, range) {
1372         gl = context;
1373       //Set up Test Root parameters
1374         var testName = 'fragment_output';
1375         var testDescription = 'Fragment Output Tests';
1376         var state = tcuTestCase.runner;
1377
1378         state.testName = testName;
1379         state.testCases = tcuTestCase.newTest(testName, testDescription, null);
1380
1381       //Set up name and description of this test series.
1382         setCurrentTestName(testName);
1383         description(testDescription);
1384
1385         try {
1386             es3fFragmentOutputTests.init(gl);
1387             if (range)
1388                 state.setRange(range);
1389             tcuTestCase.runTestCases();
1390         } catch (err) {
1391             testFailedOptions('Failed to es3fFragmentOutputTests.run tests', false);
1392             bufferedLogToConsole(err);
1393             tcuTestCase.runner.terminate();
1394         }
1395
1396     };
1397
1398 });