dom/canvas/test/webgl-conf/checkout/deqp/functional/gles3/es3fFboRenderTest.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.es3fFboRenderTest');
  23 goog.require('framework.common.tcuImageCompare');
  24 goog.require('framework.common.tcuLogImage');
  25 goog.require('framework.common.tcuPixelFormat');
  26 goog.require('framework.common.tcuRGBA');
  27 goog.require('framework.common.tcuSurface');
  28 goog.require('framework.common.tcuTestCase');
  29 goog.require('framework.common.tcuTexture');
  30 goog.require('framework.common.tcuTextureUtil');
  31 goog.require('framework.delibs.debase.deMath');
  32 goog.require('framework.delibs.debase.deRandom');
  33 goog.require('framework.delibs.debase.deString');
  34 goog.require('framework.delibs.debase.deUtil');
  35 goog.require('framework.opengl.gluShaderUtil');
  36 goog.require('framework.opengl.gluTextureUtil');
  37 goog.require('framework.opengl.simplereference.sglrGLContext');
  38 goog.require('framework.opengl.simplereference.sglrReferenceContext');
  39 goog.require('framework.referencerenderer.rrUtil');
  40 goog.require('functional.gles3.es3fFboTestUtil');
  41
  42 goog.scope(function() {
  43
  44     var es3fFboRenderTest = functional.gles3.es3fFboRenderTest;
  45     var es3fFboTestUtil = functional.gles3.es3fFboTestUtil;
  46     var gluShaderUtil = framework.opengl.gluShaderUtil;
  47     var gluTextureUtil = framework.opengl.gluTextureUtil;
  48     var tcuImageCompare = framework.common.tcuImageCompare;
  49     var tcuLogImage = framework.common.tcuLogImage;
  50     var tcuPixelFormat = framework.common.tcuPixelFormat;
  51     var tcuRGBA = framework.common.tcuRGBA;
  52     var tcuTestCase = framework.common.tcuTestCase;
  53     var tcuSurface = framework.common.tcuSurface;
  54     var tcuTexture = framework.common.tcuTexture;
  55     var tcuTextureUtil = framework.common.tcuTextureUtil;
  56     var deMath = framework.delibs.debase.deMath;
  57     var deRandom = framework.delibs.debase.deRandom;
  58     var deString = framework.delibs.debase.deString;
  59     var deUtil = framework.delibs.debase.deUtil;
  60     var sglrGLContext = framework.opengl.simplereference.sglrGLContext;
  61     var sglrReferenceContext =
  62         framework.opengl.simplereference.sglrReferenceContext;
  63     var rrUtil = framework.referencerenderer.rrUtil;
  64
  65     /** @type {WebGL2RenderingContext} */ var gl;
  66
  67     /**
  68      * @constructor
  69      * @param {number=} buffers_
  70      * @param {number=} colorType_
  71      * @param {number=} colorFormat_
  72      * @param {number=} depthStencilType_
  73      * @param {number=} depthStencilFormat_
  74      * @param {number=} width_
  75      * @param {number=} height_
  76      * @param {number=} samples_
  77      */
  78     es3fFboRenderTest.FboConfig = function(
  79         buffers_, colorType_, colorFormat_, depthStencilType_,
  80         depthStencilFormat_, width_, height_, samples_
  81     ) {
  82         // Buffer bit mask (gl.COLOR_BUFFER_BIT|gl.DEPTH_BUFFER_BIT|...)
  83         this.buffers = buffers_ ? buffers_ : 0;
  84         // gl.TEXTURE_2D, gl.TEXTURE_CUBE_MAP, gl.RENDERBUFFER
  85         this.colorType = colorType_ ? colorType_ : gl.NONE;
  86         // Internal format for color buffer texture or renderbuffer
  87         this.colorFormat = colorFormat_ ? colorFormat_ : gl.NONE;
  88         this.depthStencilType = depthStencilType_?
  89             depthStencilType_ : gl.NONE;
  90         this.depthStencilFormat = depthStencilFormat_ ?
  91             depthStencilFormat_ : gl.NONE;
  92         this.width = width_ ? width_ : 0;
  93         this.height = height_ ? height_ : 0;
  94         this.samples = samples_? samples_ : 0;
  95     };
  96
  97     /**
  98      * @param {number} type
  99      * @return {string}
 100      */
 101      es3fFboRenderTest.getTypeName = function(type) {
 102         switch (type) {
 103             case gl.TEXTURE_2D: return 'tex2d';
 104             case gl.RENDERBUFFER: return 'rbo';
 105             default:
 106                 testFailed('Unknown type');
 107         }
 108         return 'Should not get to this point';
 109     };
 110
 111     /**
 112      * @return {string}
 113      */
 114     es3fFboRenderTest.FboConfig.prototype.getName = function() {
 115         var name = '';
 116
 117         assertMsgOptions((this.buffers & gl.COLOR_BUFFER_BIT) != 0,
 118             'Color buffer is not specified', false, true);
 119
 120         name += es3fFboRenderTest.getTypeName(this.colorType) + '_' +
 121                 es3fFboTestUtil.getFormatName(this.colorFormat);
 122
 123         if (this.buffers & gl.DEPTH_BUFFER_BIT)
 124             name += '_depth';
 125         if (this.buffers & gl.STENCIL_BUFFER_BIT)
 126             name += '_stencil';
 127
 128         if (this.buffers & (gl.DEPTH_BUFFER_BIT | gl.STENCIL_BUFFER_BIT))
 129             name += '_' + es3fFboRenderTest.getTypeName(this.depthStencilType) +
 130                    '_' + es3fFboTestUtil.getFormatName(this.depthStencilFormat);
 131
 132         return name;
 133     };
 134
 135     /**
 136      * @param {number} format
 137      * @return {Array<string>}
 138      */
 139     es3fFboRenderTest.getEnablingExtensions = function(format) {
 140         /** @type {Array<string>} */ var out = [];
 141
 142         switch (format) {
 143             case gl.RGB16F:
 144                 assertMsgOptions(false, "Not part of the tested formats", false, true);
 145                 break;
 146
 147             case gl.RGBA16F:
 148             case gl.RG16F:
 149             case gl.R16F:
 150             case gl.RGBA32F:
 151             case gl.RGB32F:
 152             case gl.R11F_G11F_B10F:
 153             case gl.RG32F:
 154             case gl.R32F:
 155                 out.push('EXT_color_buffer_float');
 156
 157             default:
 158                 break;
 159         }
 160
 161         return out;
 162     };
 163
 164     /**
 165      * @param {?sglrGLContext.GLContext|sglrReferenceContext.ReferenceContext}
 166      * context
 167      * @param {string} name
 168      * @return {*}
 169      */
 170     es3fFboRenderTest.isExtensionSupported = function(context, name) {
 171         return context.getExtension(name);
 172     };
 173
 174     /**
 175      * @param {?sglrGLContext.GLContext|sglrReferenceContext.ReferenceContext}
 176      * context
 177      * @param {Array<string>} requiredExts
 178      * @return {boolean}
 179      */
 180     es3fFboRenderTest.isAnyExtensionSupported = function(
 181         context, requiredExts) {
 182
 183         if (!requiredExts || requiredExts.length == 0)
 184             return true;
 185
 186         for (var extNdx = 0; extNdx < requiredExts.length; extNdx++) {
 187             var extension = requiredExts[extNdx];
 188
 189             if (es3fFboRenderTest.isExtensionSupported(context, extension))
 190                 return true;
 191         }
 192
 193         return false;
 194     };
 195
 196     /**
 197      * @param {Array} list
 198      * @param {string} sep
 199      * @return {string}
 200      */
 201     es3fFboRenderTest.join = function(list, sep) {
 202         var out = '';
 203
 204         for (var elemNdx = 0; elemNdx < list.length; elemNdx++) {
 205             if (elemNdx != 0)
 206                 out += sep;
 207             out += list[elemNdx];
 208         }
 209
 210         return out;
 211     };
 212
 213     /**
 214      * @param {?sglrGLContext.GLContext|sglrReferenceContext.ReferenceContext}
 215      * context
 216      * @param {number} sizedFormat
 217      */
 218     es3fFboRenderTest.checkColorFormatSupport = function(context, sizedFormat) {
 219         /** @type {Array<string>} */ var requiredExts =
 220             es3fFboRenderTest.getEnablingExtensions(sizedFormat);
 221
 222         if (!es3fFboRenderTest.isAnyExtensionSupported(context, requiredExts)) {
 223             var errMsg = 'Format not supported, requires ' + (
 224                 (requiredExts.length == 1) ? requiredExts[0] :
 225                 ' one of the following: ' +
 226                 requiredExts.join(', ')
 227             );
 228             checkMessage(false, errMsg);
 229
 230             throw new TestFailedException(errMsg);
 231         }
 232     };
 233
 234     /**
 235      * @constructor
 236      * @param {?sglrGLContext.GLContext|sglrReferenceContext.ReferenceContext}
 237      * context
 238      * @param {es3fFboRenderTest.FboConfig} config
 239      * @param {number} width
 240      * @param {number} height
 241      * @param {sglrReferenceContext.AnyFramebuffer=} fbo
 242      * @param {sglrReferenceContext.AnyRenderbuffer=} colorBufferName
 243      * @param {sglrReferenceContext.AnyRenderbuffer=} depthStencilBufferName
 244      */
 245     es3fFboRenderTest.Framebuffer = function(
 246         context, config, width, height, fbo,
 247         colorBufferName, depthStencilBufferName) {
 248
 249         this.m_config = config;
 250         this.m_context = context;
 251         this.m_framebuffer = fbo ? fbo : null;
 252         this.m_colorBuffer = colorBufferName ? colorBufferName : null;
 253         this.m_depthStencilBuffer = depthStencilBufferName ?
 254             depthStencilBufferName : null;
 255
 256         // Verify that color format is supported
 257         es3fFboRenderTest.checkColorFormatSupport(context, config.colorFormat);
 258
 259         if (!this.m_framebuffer)
 260             this.m_framebuffer = context.createFramebuffer();
 261         context.bindFramebuffer(gl.FRAMEBUFFER, this.m_framebuffer);
 262
 263         if (this.m_config.buffers & (gl.COLOR_BUFFER_BIT)) {
 264             switch (this.m_config.colorType) {
 265                 case gl.TEXTURE_2D:
 266                     this.m_colorBuffer = this.createTex2D(
 267                         /** @type {WebGLTexture} */ (colorBufferName),
 268                         this.m_config.colorFormat, width, height
 269                     );
 270
 271                     context.framebufferTexture2D(
 272                         gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0,
 273                         gl.TEXTURE_2D, this.m_colorBuffer, 0
 274                     );
 275
 276                     break;
 277
 278                 case gl.RENDERBUFFER:
 279                     this.m_colorBuffer = this.createRbo(
 280                         /** @type {WebGLRenderbuffer} */ (colorBufferName),
 281                         this.m_config.colorFormat, width, height
 282                     );
 283
 284                     context.framebufferRenderbuffer(
 285                         gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0,
 286                         gl.RENDERBUFFER, this.m_colorBuffer
 287                     );
 288
 289                     break;
 290
 291                 default:
 292                     testFailed('Unsupported type');
 293             }
 294         }
 295
 296         if (this.m_config.buffers &
 297             (gl.DEPTH_BUFFER_BIT | gl.STENCIL_BUFFER_BIT)) {
 298
 299             switch (this.m_config.depthStencilType) {
 300                 case gl.TEXTURE_2D:
 301                     this.m_depthStencilBuffer = this.createTex2D(
 302                         /** @type {WebGLTexture} */
 303                         (depthStencilBufferName),
 304                         this.m_config.depthStencilFormat, width, height
 305                     );
 306                     break;
 307                 case gl.RENDERBUFFER:
 308                     this.m_depthStencilBuffer = this.createRbo(
 309                         /** @type {WebGLRenderbuffer} */
 310                         (depthStencilBufferName),
 311                         this.m_config.depthStencilFormat, width, height
 312                     );
 313                     break;
 314
 315                 default:
 316                     testFailed('Unsupported type');
 317             }
 318         }
 319
 320         for (var ndx = 0; ndx < 2; ndx++) {
 321             var bit = ndx ? gl.STENCIL_BUFFER_BIT : gl.DEPTH_BUFFER_BIT;
 322             var point = ndx ? gl.STENCIL_ATTACHMENT : gl.DEPTH_ATTACHMENT;
 323
 324             if ((this.m_config.buffers & bit) == 0)
 325                 continue; /* Not used. */
 326
 327             switch (this.m_config.depthStencilType) {
 328                 case gl.TEXTURE_2D:
 329                     context.framebufferTexture2D(
 330                         gl.FRAMEBUFFER, point, gl.TEXTURE_2D,
 331                         this.m_depthStencilBuffer, 0
 332                     );
 333                     break;
 334                 case gl.RENDERBUFFER:
 335                     context.framebufferRenderbuffer(
 336                         gl.FRAMEBUFFER, point,
 337                         gl.RENDERBUFFER, this.m_depthStencilBuffer
 338                     );
 339                     break;
 340                 default:
 341                     throw new Error('Invalid depth stencil type');
 342             }
 343         }
 344
 345         context.bindFramebuffer(gl.FRAMEBUFFER, null);
 346     };
 347
 348     /**
 349      * @return {es3fFboRenderTest.FboConfig}
 350      */
 351     es3fFboRenderTest.Framebuffer.prototype.getConfig = function() {
 352         return this.m_config;
 353     };
 354
 355     /**
 356      * @return {?sglrReferenceContext.AnyFramebuffer}
 357      */
 358     es3fFboRenderTest.Framebuffer.prototype.getFramebuffer = function() {
 359         return this.m_framebuffer;
 360     };
 361
 362     /**
 363      * @return {?sglrReferenceContext.AnyRenderbuffer}
 364      */
 365     es3fFboRenderTest.Framebuffer.prototype.getColorBuffer = function() {
 366         return this.m_colorBuffer;
 367     };
 368
 369     /**
 370      * @return {?sglrReferenceContext.AnyRenderbuffer}
 371      */
 372     es3fFboRenderTest.Framebuffer.prototype.getDepthStencilBuffer = function() {
 373         return this.m_depthStencilBuffer;
 374     };
 375
 376     /**
 377      * deinit
 378      */
 379     es3fFboRenderTest.Framebuffer.prototype.deinit = function() {
 380         this.m_context.deleteFramebuffer(
 381             /** @type {WebGLFramebuffer} */ (this.m_framebuffer)
 382         );
 383         this.destroyBuffer(this.m_colorBuffer, this.m_config.colorType);
 384         this.destroyBuffer(
 385             this.m_depthStencilBuffer, this.m_config.depthStencilType
 386         );
 387     };
 388
 389     /**
 390      * checkCompleteness
 391      */
 392     es3fFboRenderTest.Framebuffer.prototype.checkCompleteness = function() {
 393         this.m_context.bindFramebuffer(gl.FRAMEBUFFER, this.m_framebuffer);
 394         var status = this.m_context.checkFramebufferStatus(gl.FRAMEBUFFER);
 395         this.m_context.bindFramebuffer(gl.FRAMEBUFFER, null);
 396         if (status != gl.FRAMEBUFFER_COMPLETE)
 397             throw new es3fFboTestUtil.FboIncompleteException(status);
 398     };
 399
 400     /**
 401      * @param {?WebGLTexture|sglrReferenceContext.TextureContainer} name
 402      * @param {number} format
 403      * @param {number} width
 404      * @param {number} height
 405      * @return {?WebGLTexture|sglrReferenceContext.TextureContainer}
 406      */
 407     es3fFboRenderTest.Framebuffer.prototype.createTex2D = function(
 408         name, format, width, height) {
 409
 410         if (!name)
 411             name = this.m_context.createTexture();
 412
 413         this.m_context.bindTexture(gl.TEXTURE_2D, name);
 414         this.m_context.texImage2DDelegate(
 415             gl.TEXTURE_2D, 0, format, width, height
 416         );
 417
 418         if (!deMath.deIsPowerOfTwo32(width) ||
 419             !deMath.deIsPowerOfTwo32(height)) {
 420
 421             // Set wrap mode to clamp for NPOT FBOs
 422             this.m_context.texParameteri(
 423                 gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE
 424             );
 425             this.m_context.texParameteri(
 426                 gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE
 427             );
 428         }
 429
 430         this.m_context.texParameteri(
 431             gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST
 432         );
 433         this.m_context.texParameteri(
 434             gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST
 435         );
 436
 437         return name;
 438     };
 439
 440     /**
 441      * @param {?WebGLRenderbuffer|sglrReferenceContext.Renderbuffer} name
 442      * @param {number} format
 443      * @param {number} width
 444      * @param {number} height
 445      * @return {?WebGLRenderbuffer|sglrReferenceContext.Renderbuffer}
 446      */
 447     es3fFboRenderTest.Framebuffer.prototype.createRbo = function(
 448         name, format, width, height) {
 449
 450         if (!name)
 451             name = this.m_context.createRenderbuffer();
 452
 453         this.m_context.bindRenderbuffer(gl.RENDERBUFFER, name);
 454         this.m_context.renderbufferStorage(
 455             gl.RENDERBUFFER, format, width, height
 456         );
 457
 458         return name;
 459     };
 460
 461     /**
 462      * @param {?sglrReferenceContext.AnyRenderbuffer} name
 463      * @param {number} type
 464      */
 465     es3fFboRenderTest.Framebuffer.prototype.destroyBuffer = function(
 466         name, type) {
 467
 468         if (type == gl.TEXTURE_2D || type == gl.TEXTURE_CUBE_MAP)
 469             this.m_context.deleteTexture(/** @type {?WebGLTexture} */ (name));
 470         else if (type == gl.RENDERBUFFER)
 471             this.m_context.deleteRenderbuffer(
 472                 /** @type {?WebGLRenderbuffer} */ (name)
 473             );
 474         else
 475             assertMsgOptions(
 476                 type == gl.NONE, 'Invalid buffer type', false, true
 477             );
 478     };
 479
 480     /**
 481      * @param {?sglrGLContext.GLContext|sglrReferenceContext.ReferenceContext}
 482      * context
 483      * @param {WebGLTexture|sglrReferenceContext.TextureContainer} name
 484      * @param {number} format
 485      * @param {number} dataType
 486      * @param {number} width
 487      * @param {number} height
 488      */
 489     es3fFboRenderTest.createMetaballsTex2D = function(
 490         context, name, format, dataType, width, height) {
 491
 492         /** @type {tcuTexture.TextureFormat} */ var texFormat =
 493             gluTextureUtil.mapGLTransferFormat(format, dataType);
 494         /** @type {tcuTexture.TextureLevel} */ var level =
 495             new tcuTexture.TextureLevel(texFormat, width, height);
 496
 497         tcuTextureUtil.fillWithMetaballs(
 498             level.getAccess(), 5, /*name ^*/ width ^ height
 499         );
 500
 501         context.bindTexture(gl.TEXTURE_2D, name);
 502         context.texImage2D(
 503             gl.TEXTURE_2D, 0, format, width, height, 0, format,
 504             dataType, level.getAccess().getDataPtr()
 505         );
 506         context.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
 507     };
 508
 509     /**
 510      * @param {?sglrGLContext.GLContext|sglrReferenceContext.ReferenceContext}
 511      * context
 512      * @param {WebGLTexture|sglrReferenceContext.TextureContainer} name
 513      * @param {number} format
 514      * @param {number} dataType
 515      * @param {number} width
 516      * @param {number} height
 517      */
 518     es3fFboRenderTest.createQuadsTex2D = function(
 519         context, name, format, dataType, width, height) {
 520
 521         /** @type {tcuTexture.TextureFormat} */
 522         var texFormat = gluTextureUtil.mapGLTransferFormat(format, dataType);
 523         /** @type {tcuTexture.TextureLevel} */
 524         var level = new tcuTexture.TextureLevel(texFormat, width, height);
 525
 526         tcuTextureUtil.fillWithRGBAQuads(level.getAccess());
 527
 528         context.bindTexture(gl.TEXTURE_2D, name);
 529         context.texImage2D(
 530             gl.TEXTURE_2D, 0, format, width, height, 0,
 531             format, dataType, level.getAccess().getDataPtr()
 532         );
 533         context.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
 534     };
 535
 536     /**
 537      * @constructor
 538      * @extends {tcuTestCase.DeqpTest}
 539      * @param {string} name
 540      * @param {string} description
 541      * @param {es3fFboRenderTest.FboConfig} config
 542      */
 543     es3fFboRenderTest.FboRenderCase = function(name, description, config) {
 544         tcuTestCase.DeqpTest.call(this, name, description);
 545         this.m_config = config;
 546     };
 547
 548     es3fFboRenderTest.FboRenderCase.prototype =
 549         Object.create(tcuTestCase.DeqpTest.prototype);
 550
 551     es3fFboRenderTest.FboRenderCase.prototype.constructor =
 552         es3fFboRenderTest.FboRenderCase;
 553
 554     /**
 555      * Must be overridden
 556      * @param {?sglrGLContext.GLContext|sglrReferenceContext.ReferenceContext}
 557      *      fboContext
 558      * @param {tcuSurface.Surface} dst
 559      */
 560     es3fFboRenderTest.FboRenderCase.prototype.render = function(
 561         fboContext, dst) {
 562             throw new Error('Must override');
 563     };
 564
 565     /**
 566      * @return {tcuTestCase.IterateResult}
 567      */
 568     es3fFboRenderTest.FboRenderCase.prototype.iterate = function() {
 569         var clearColor = [0.125, 0.25, 0.5, 1.0];
 570         /** @type {?string} */ var failReason = "";
 571
 572         // Position & size for context
 573         var rnd = new deRandom.deRandom();
 574         deRandom.deRandom_init(rnd, deString.deStringHash(this.fullName()));
 575
 576         var width = Math.min(gl.canvas.width, 128);
 577         var height = Math.min(gl.canvas.height, 128);
 578         var xMax = gl.canvas.width - width + 1;
 579         var yMax = gl.canvas.height - height + 1;
 580         var x = Math.abs(deRandom.deRandom_getInt(rnd)) % xMax;
 581         var y = Math.abs(deRandom.deRandom_getInt(rnd)) % yMax;
 582
 583         /** @type {tcuSurface.Surface} */
 584         var gles3Frame = new tcuSurface.Surface(width, height);
 585         /** @type {tcuSurface.Surface} */
 586         var refFrame = new tcuSurface.Surface(width, height);
 587
 588         /** @type {number} */ var gles3Error = 0;
 589         /** @type {number} */ var refError = 0;
 590
 591         // Render using GLES3
 592         /**
 593          * @type {sglrGLContext.GLContext|
 594          * sglrReferenceContext.ReferenceContext}
 595          */
 596         var context;
 597
 598         try {
 599             context = new sglrGLContext.GLContext(gl, [x, y, width, height]);
 600
 601             context.clearColor(
 602                 clearColor[0], clearColor[1], clearColor[2], clearColor[3]
 603             );
 604
 605             context.clear(
 606                 gl.COLOR_BUFFER_BIT |
 607                 gl.DEPTH_BUFFER_BIT |
 608                 gl.STENCIL_BUFFER_BIT
 609             );
 610
 611             this.render(context, gles3Frame); // Call actual render func
 612             gles3Error = context.getError();
 613         }
 614         catch (e) {
 615             if (e instanceof es3fFboTestUtil.FboIncompleteException) {
 616                 e.message = WebGLTestUtils.glEnumToString(gl, e.getReason());
 617                 if(e.getReason() == gl.FRAMEBUFFER_UNSUPPORTED) {
 618                     // Mark test case as unsupported
 619                     bufferedLogToConsole(e + ': ' + e.message);
 620                     testFailed('Not supported');
 621                     return tcuTestCase.IterateResult.STOP;
 622                 }
 623             }
 624
 625             // Propagate error
 626             throw e;
 627         }
 628
 629         // Render reference image
 630
 631         /** @type {sglrReferenceContext.ReferenceContextBuffers} */
 632         var buffers = new sglrReferenceContext.ReferenceContextBuffers(
 633             new tcuPixelFormat.PixelFormat(
 634                 8, 8, 8,
 635                 gl.getParameter(gl.ALPHA_BITS) ? 8 : 0
 636             ),
 637             /** @type {number} */ (gl.getParameter(gl.DEPTH_BITS)),
 638             /** @type {number} */ (gl.getParameter(gl.STENCIL_BITS)),
 639             width,
 640             height
 641         );
 642         context = new sglrReferenceContext.ReferenceContext(
 643             new sglrReferenceContext.ReferenceContextLimits(gl),
 644             buffers.getColorbuffer(),
 645             buffers.getDepthbuffer(),
 646             buffers.getStencilbuffer()
 647         );
 648
 649         context.clearColor(
 650             clearColor[0], clearColor[1], clearColor[2], clearColor[3]
 651         );
 652
 653         context.clear(
 654             gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT | gl.STENCIL_BUFFER_BIT
 655         );
 656
 657         this.render(context, refFrame);
 658         refError = context.getError();
 659
 660         // Compare error codes
 661         var errorCodesOk = (gles3Error == refError);
 662
 663         if (!errorCodesOk) {
 664             bufferedLogToConsole (
 665                 'Error code mismatch: got ' +
 666                 WebGLTestUtils.glEnumToString(gl, gles3Error) + ', expected ' +
 667                 WebGLTestUtils.glEnumToString(gl, refError)
 668             );
 669             failReason = 'Got unexpected error';
 670         }
 671
 672         // Compare images
 673         var imagesOk = this.compare(refFrame, gles3Frame);
 674
 675         if (!imagesOk && !failReason)
 676             failReason = 'Image comparison failed';
 677
 678         // Store test result
 679         var isOk = errorCodesOk && imagesOk;
 680         assertMsgOptions(isOk, failReason, true, true);
 681
 682         return tcuTestCase.IterateResult.STOP;
 683     };
 684
 685     /**
 686      * @param {tcuSurface.Surface} reference
 687      * @param {tcuSurface.Surface} result
 688      * @return {boolean}
 689      */
 690     es3fFboRenderTest.FboRenderCase.prototype.compare = function(
 691         reference, result) {
 692
 693         var threshold = new tcuRGBA.RGBA(
 694             /* TODO: tcu::max(getFormatThreshold(this.m_config.colorFormat),*/
 695             [12, 12, 12, 12]
 696         );
 697
 698         return tcuImageCompare.bilinearCompare(
 699             'ComparisonResult', 'Image comparison result',
 700             reference.getAccess(), result.getAccess(),
 701             threshold, tcuImageCompare.CompareLogMode.RESULT
 702         );
 703     };
 704
 705     /**
 706      * deinit
 707      */
 708     es3fFboRenderTest.FboRenderCase.prototype.deinit = function() {
 709         gl.clearColor(0.0, 0.0, 0.0, 0.0);
 710         gl.clearDepth(1.0);
 711         gl.clearStencil(0);
 712
 713         gl.disable(gl.STENCIL_TEST);
 714         gl.disable(gl.DEPTH_TEST);
 715         gl.disable(gl.BLEND);
 716
 717         gl.bindFramebuffer(gl.FRAMEBUFFER, null);
 718         gl.bindRenderbuffer(gl.RENDERBUFFER, null);
 719     };
 720
 721     // FboCases
 722
 723     /**
 724      * @constructor
 725      * @extends {es3fFboRenderTest.FboRenderCase}
 726      * @param {es3fFboRenderTest.FboConfig} config
 727      */
 728     es3fFboRenderTest.StencilClearsTest = function(config) {
 729         es3fFboRenderTest.FboRenderCase.call(
 730             this, config.getName(), 'Stencil clears', config
 731         );
 732     };
 733
 734     es3fFboRenderTest.StencilClearsTest.prototype =
 735         Object.create(es3fFboRenderTest.FboRenderCase.prototype);
 736
 737     es3fFboRenderTest.StencilClearsTest.prototype.constructor =
 738         es3fFboRenderTest.StencilClearsTest;
 739
 740     /**
 741      * @param {?sglrGLContext.GLContext|sglrReferenceContext.ReferenceContext}
 742      * context
 743      * @param {tcuSurface.Surface} dst
 744      */
 745     es3fFboRenderTest.StencilClearsTest.prototype.render = function(
 746         context, dst) {
 747
 748         /** @type {tcuTexture.TextureFormat} */
 749         var colorFormat = gluTextureUtil.mapGLInternalFormat(
 750             this.m_config.colorFormat
 751         );
 752
 753         /** @type {gluShaderUtil.DataType} */
 754         var fboSamplerType = /** @type {gluShaderUtil.DataType} */ (
 755             gluTextureUtil.getSampler2DType(colorFormat)
 756         );
 757
 758         /** @type {gluShaderUtil.DataType} */
 759         var fboOutputType = es3fFboTestUtil.getFragmentOutputType(colorFormat);
 760
 761         /** @type {tcuTextureUtil.TextureFormatInfo} */
 762         var fboRangeInfo = tcuTextureUtil.getTextureFormatInfo(colorFormat);
 763
 764         var fboOutScale = deMath.subtract(
 765             fboRangeInfo.valueMax, fboRangeInfo.valueMin
 766         );
 767
 768         var fboOutBias = fboRangeInfo.valueMin;
 769
 770         /** @type {es3fFboTestUtil.Texture2DShader} */
 771         var texToFboShader = new es3fFboTestUtil.Texture2DShader(
 772             [gluShaderUtil.DataType.SAMPLER_2D], fboOutputType
 773         );
 774
 775         /** @type {es3fFboTestUtil.Texture2DShader} */
 776         var texFromFboShader = new es3fFboTestUtil.Texture2DShader(
 777             [fboSamplerType], gluShaderUtil.DataType.FLOAT_VEC4);
 778
 779         /** @type {number} */ var texToFboShaderID =
 780             context.createProgram(texToFboShader);
 781
 782         /** @type {number} */ var texFromFboShaderID =
 783             context.createProgram(texFromFboShader);
 784
 785         /** @type {?WebGLTexture|sglrReferenceContext.TextureContainer} */
 786         var metaballsTex = context.createTexture();
 787
 788         /** @type {?WebGLTexture|sglrReferenceContext.TextureContainer} */
 789         var quadsTex = context.createTexture();
 790
 791         /** @type {number} */ var width = 128;
 792         /** @type {number} */ var height = 128;
 793
 794         texToFboShader.setOutScaleBias(fboOutScale, fboOutBias);
 795         texFromFboShader.setTexScaleBias(
 796             0, fboRangeInfo.lookupScale, fboRangeInfo.lookupBias
 797         );
 798
 799         es3fFboRenderTest.createQuadsTex2D(
 800             context, quadsTex, gl.RGBA, gl.UNSIGNED_BYTE, width, height
 801         );
 802
 803         es3fFboRenderTest.createMetaballsTex2D(
 804             context, metaballsTex, gl.RGBA, gl.UNSIGNED_BYTE, width, height
 805         );
 806
 807         /** @type {es3fFboRenderTest.Framebuffer} */
 808         var fbo = new es3fFboRenderTest.Framebuffer(
 809             context, this.m_config, width, height
 810         );
 811         fbo.checkCompleteness();
 812
 813         // Bind framebuffer and clear
 814         context.bindFramebuffer(gl.FRAMEBUFFER, fbo.getFramebuffer());
 815         context.viewport(0, 0, width, height);
 816         context.clearColor(0.0, 0.0, 0.0, 1.0);
 817         context.clear(
 818             gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT | gl.STENCIL_BUFFER_BIT
 819         );
 820
 821         // Do stencil clears
 822         context.enable(gl.SCISSOR_TEST);
 823         context.scissor(10, 16, 32, 120);
 824         context.clearStencil(1);
 825         context.clear(gl.STENCIL_BUFFER_BIT);
 826         context.scissor(16, 32, 100, 64);
 827         context.clearStencil(2);
 828         context.clear(gl.STENCIL_BUFFER_BIT);
 829         context.disable(gl.SCISSOR_TEST);
 830
 831         // Draw 2 textures with stecil tests
 832         context.enable(gl.STENCIL_TEST);
 833
 834         context.bindTexture(gl.TEXTURE_2D, quadsTex);
 835         context.stencilFunc(gl.EQUAL, 1, 0xff);
 836
 837         texToFboShader.setUniforms(context, texToFboShaderID);
 838         rrUtil.drawQuad(
 839             context, texToFboShaderID, [-1.0, -1.0, 0.0], [1.0, 1.0, 0.0]
 840         );
 841
 842         context.bindTexture(gl.TEXTURE_2D, metaballsTex);
 843         context.stencilFunc(gl.EQUAL, 2, 0xff);
 844
 845         texToFboShader.setUniforms(context, texToFboShaderID);
 846         rrUtil.drawQuad(
 847             context, texToFboShaderID, [-1.0, -1.0, 0.0], [1.0, 1.0, 0.0]
 848         );
 849
 850         context.disable(gl.STENCIL_TEST);
 851
 852         if (fbo.getConfig().colorType == gl.TEXTURE_2D) {
 853             context.bindFramebuffer(gl.FRAMEBUFFER, null);
 854             context.bindTexture(gl.TEXTURE_2D, fbo.getColorBuffer());
 855             context.viewport(0, 0, context.getWidth(), context.getHeight());
 856
 857             texFromFboShader.setUniforms(context, texFromFboShaderID);
 858             rrUtil.drawQuad(
 859                 context, texFromFboShaderID, [-1.0, -1.0, 0.0], [1.0, 1.0, 0.0]
 860             );
 861
 862             dst.readViewport(
 863                 context, [0, 0, context.getWidth(), context.getHeight()]
 864             );
 865         } else
 866             es3fFboTestUtil.readPixels(
 867                 context, dst, 0, 0, width, height, colorFormat,
 868                 fboRangeInfo.lookupScale, fboRangeInfo.lookupBias
 869             );
 870     };
 871
 872     /**
 873      * @constructor
 874      * @extends {es3fFboRenderTest.FboRenderCase}
 875      * @param {es3fFboRenderTest.FboConfig} config
 876      */
 877     es3fFboRenderTest.SharedColorbufferTest = function(config) {
 878         es3fFboRenderTest.FboRenderCase.call(
 879             this, config.getName(), 'Shared colorbuffer', config
 880         );
 881     };
 882
 883     es3fFboRenderTest.SharedColorbufferTest.prototype =
 884         Object.create(es3fFboRenderTest.FboRenderCase.prototype);
 885
 886     es3fFboRenderTest.SharedColorbufferTest.prototype.constructor =
 887         es3fFboRenderTest.SharedColorbufferTest;
 888
 889     /**
 890      * @param {?sglrGLContext.GLContext|sglrReferenceContext.ReferenceContext}
 891      * context
 892      * @param {tcuSurface.Surface} dst
 893      */
 894     es3fFboRenderTest.SharedColorbufferTest.prototype.render = function(
 895         context, dst) {
 896
 897         /** @type {es3fFboTestUtil.Texture2DShader} */
 898         var texShader = new es3fFboTestUtil.Texture2DShader(
 899             [gluShaderUtil.DataType.SAMPLER_2D],
 900             gluShaderUtil.DataType.FLOAT_VEC4
 901         );
 902
 903         /** @type {es3fFboTestUtil.FlatColorShader} */
 904         var flatShader = new es3fFboTestUtil.FlatColorShader(
 905             gluShaderUtil.DataType.FLOAT_VEC4
 906         );
 907
 908         /** @type {number} */
 909         var texShaderID = context.createProgram(texShader);
 910         /** @type {number} */
 911         var flatShaderID = context.createProgram(flatShader);
 912
 913         /** @type {number} */ var width = 128;
 914         /** @type {number} */ var height = 128;
 915
 916         /** @type {?WebGLTexture|sglrReferenceContext.TextureContainer} */
 917         var quadsTex = context.createTexture();
 918
 919         /** @type {?WebGLTexture|sglrReferenceContext.TextureContainer} */
 920         var metaballsTex = context.createTexture();
 921
 922         /** @type {boolean} */ var stencil =
 923             (this.m_config.buffers & gl.STENCIL_BUFFER_BIT) != 0;
 924
 925         context.disable(gl.DITHER);
 926
 927         // Textures
 928         es3fFboRenderTest.createQuadsTex2D(
 929             context, quadsTex, gl.RGB, gl.UNSIGNED_BYTE, 64, 64
 930         );
 931         es3fFboRenderTest.createMetaballsTex2D(
 932             context, metaballsTex, gl.RGBA, gl.UNSIGNED_BYTE, 64, 64
 933         );
 934
 935         context.viewport(0, 0, width, height);
 936
 937         // Fbo A
 938         /** @type {es3fFboRenderTest.Framebuffer} */
 939         var fboA = new es3fFboRenderTest.Framebuffer(
 940                 context, this.m_config, width, height
 941         );
 942         fboA.checkCompleteness();
 943
 944         // Fbo B - don't create colorbuffer
 945
 946         /** @type {es3fFboRenderTest.FboConfig} */
 947         var cfg = /** @type {es3fFboRenderTest.FboConfig} */
 948             (deUtil.clone(this.m_config));
 949
 950         cfg.buffers = deMath.binaryOp(
 951             cfg.buffers,
 952             deMath.binaryNot(gl.COLOR_BUFFER_BIT),
 953             deMath.BinaryOp.AND
 954         );
 955         cfg.colorType = gl.NONE;
 956         cfg.colorFormat = gl.NONE;
 957
 958         /** @type {es3fFboRenderTest.Framebuffer} */
 959         var fboB = new es3fFboRenderTest.Framebuffer(
 960             context, cfg, width, height
 961         );
 962
 963         // Attach color buffer from fbo A
 964         context.bindFramebuffer(gl.FRAMEBUFFER, fboB.getFramebuffer());
 965         switch (this.m_config.colorType) {
 966             case gl.TEXTURE_2D:
 967                 context.framebufferTexture2D(
 968                     gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0,
 969                     gl.TEXTURE_2D, fboA.getColorBuffer(), 0
 970                 );
 971                 break;
 972
 973             case gl.RENDERBUFFER:
 974                 context.framebufferRenderbuffer(
 975                     gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0,
 976                     gl.RENDERBUFFER, fboA.getColorBuffer()
 977                 );
 978                 break;
 979
 980             default:
 981                 throw new Error('Invalid color type');
 982         }
 983
 984         // Clear depth and stencil in fbo B
 985         context.clear(gl.DEPTH_BUFFER_BIT | gl.STENCIL_BUFFER_BIT);
 986
 987         // Render quads to fbo 1, with depth 0.0
 988         context.bindFramebuffer(gl.FRAMEBUFFER, fboA.getFramebuffer());
 989         context.bindTexture(gl.TEXTURE_2D, quadsTex);
 990         context.clearColor(0.0, 0.0, 0.0, 1.0);
 991         context.clear(
 992             gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT | gl.STENCIL_BUFFER_BIT
 993         );
 994
 995         if (stencil) {
 996             // Stencil to 1 in fbo A
 997             context.clearStencil(1);
 998             context.clear(gl.STENCIL_BUFFER_BIT);
 999         }
1000
1001         texShader.setUniforms(context, texShaderID);
1002
1003         context.enable(gl.DEPTH_TEST);
1004         rrUtil.drawQuad(
1005             context, texShaderID, [-1.0, -1.0, 0.0], [1.0, 1.0, 0.0]
1006         );
1007         context.disable(gl.DEPTH_TEST);
1008
1009         // Blend metaballs to fbo 2
1010         context.bindFramebuffer(gl.FRAMEBUFFER, fboB.getFramebuffer());
1011         context.bindTexture(gl.TEXTURE_2D, metaballsTex);
1012         context.enable(gl.BLEND);
1013         context.blendFuncSeparate(
1014             gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA, gl.ZERO, gl.ONE
1015         );
1016         rrUtil.drawQuad(
1017             context, texShaderID, [-1.0, -1.0, 0.0], [1.0, 1.0, 0.0]
1018         );
1019
1020         // Render small quad that is only visible if depth buffer
1021         // is not shared with fbo A - or there is no depth bits
1022         context.bindTexture(gl.TEXTURE_2D, quadsTex);
1023         context.enable(gl.DEPTH_TEST);
1024         rrUtil.drawQuad(context, texShaderID, [0.5, 0.5, 0.5], [1.0, 1.0, 0.5]);
1025         context.disable(gl.DEPTH_TEST);
1026
1027         if (stencil) {
1028             flatShader.setColor(context, flatShaderID, [0.0, 1.0, 0.0, 1.0]);
1029
1030             // Clear subset of stencil buffer to 1
1031             context.enable(gl.SCISSOR_TEST);
1032             context.scissor(10, 10, 12, 25);
1033             context.clearStencil(1);
1034             context.clear(gl.STENCIL_BUFFER_BIT);
1035             context.disable(gl.SCISSOR_TEST);
1036
1037             // Render quad with stencil mask == 1
1038             context.enable(gl.STENCIL_TEST);
1039             context.stencilFunc(gl.EQUAL, 1, 0xff);
1040             rrUtil.drawQuad(
1041                 context, flatShaderID, [-1.0, -1.0, 0.0], [1.0, 1.0, 0.0]
1042             );
1043             context.disable(gl.STENCIL_TEST);
1044         }
1045
1046         // Get results
1047         if (fboA.getConfig().colorType == gl.TEXTURE_2D) {
1048             texShader.setUniforms(context, texShaderID);
1049
1050             context.bindFramebuffer(gl.FRAMEBUFFER, null);
1051             context.bindTexture(gl.TEXTURE_2D, fboA.getColorBuffer());
1052             context.viewport(0, 0, context.getWidth(), context.getHeight());
1053             rrUtil.drawQuad(
1054                 context, texShaderID, [-1.0, -1.0, 0.0], [1.0, 1.0, 0.0]
1055             );
1056             dst.readViewport(
1057                 context, [0, 0, context.getWidth(), context.getHeight()]
1058             );
1059         } else
1060             es3fFboTestUtil.readPixels(
1061                 context, dst, 0, 0, width, height,
1062                 gluTextureUtil.mapGLInternalFormat(
1063                     fboA.getConfig().colorFormat
1064                 ), [1.0, 1.0, 1.0, 1.0], [0.0, 0.0, 0.0, 0.0]
1065             );
1066     };
1067
1068     /**
1069      * @constructor
1070      * @extends {es3fFboRenderTest.FboRenderCase}
1071      * @param {es3fFboRenderTest.FboConfig} config
1072      */
1073     es3fFboRenderTest.SharedColorbufferClearsTest = function(config) {
1074         es3fFboRenderTest.FboRenderCase.call(
1075             this, config.getName(), 'Shared colorbuffer clears', config
1076         );
1077     };
1078
1079     es3fFboRenderTest.SharedColorbufferClearsTest.prototype =
1080         Object.create(es3fFboRenderTest.FboRenderCase.prototype);
1081
1082     es3fFboRenderTest.SharedColorbufferClearsTest.prototype.constructor =
1083         es3fFboRenderTest.SharedColorbufferClearsTest;
1084
1085     /**
1086      * @param {?sglrGLContext.GLContext|sglrReferenceContext.ReferenceContext}
1087      * context
1088      * @param {tcuSurface.Surface} dst
1089      */
1090     es3fFboRenderTest.SharedColorbufferClearsTest.prototype.render = function(
1091         context, dst) {
1092
1093         /** @type {tcuTexture.TextureFormat} */
1094         var colorFormat = gluTextureUtil.mapGLInternalFormat(
1095             this.m_config.colorFormat
1096         );
1097
1098         /** @type {gluShaderUtil.DataType} */
1099         var fboSamplerType = gluTextureUtil.getSampler2DType(colorFormat);
1100
1101         var width = 128;
1102         var height = 128;
1103         var colorbuffer = this.m_config.colorType == gl.TEXTURE_2D?
1104             context.createTexture() :
1105             context.createRenderbuffer();
1106
1107         // Check for format support.
1108         es3fFboRenderTest.checkColorFormatSupport(
1109             context, this.m_config.colorFormat
1110         );
1111
1112         // Single colorbuffer
1113         if (this.m_config.colorType == gl.TEXTURE_2D) {
1114             context.bindTexture(gl.TEXTURE_2D, colorbuffer);
1115             context.texImage2DDelegate(
1116                 gl.TEXTURE_2D, 0, this.m_config.colorFormat, width, height
1117             );
1118             context.texParameteri(
1119                 gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST
1120             );
1121             context.texParameteri(
1122                 gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST
1123             );
1124         } else {
1125             assertMsgOptions(
1126                 this.m_config.colorType == gl.RENDERBUFFER,
1127                 'Not a render buffer type', false, true
1128             );
1129             context.bindRenderbuffer(gl.RENDERBUFFER, colorbuffer);
1130             context.renderbufferStorage(
1131                 gl.RENDERBUFFER, this.m_config.colorFormat, width, height
1132             );
1133         }
1134
1135         // Multiple framebuffers sharing the colorbuffer
1136         var fbo = [
1137             context.createFramebuffer(),
1138             context.createFramebuffer(),
1139             context.createFramebuffer()
1140         ];
1141
1142         for (var fboi = 0; fboi < fbo.length; fboi++) {
1143             context.bindFramebuffer(gl.FRAMEBUFFER, fbo[fboi]);
1144
1145             if (this.m_config.colorType == gl.TEXTURE_2D)
1146                 context.framebufferTexture2D(
1147                     gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0,
1148                     gl.TEXTURE_2D, colorbuffer, 0
1149                 );
1150             else
1151                 context.framebufferRenderbuffer(
1152                     gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0,
1153                     gl.RENDERBUFFER, colorbuffer
1154                 );
1155         }
1156
1157         context.bindFramebuffer(gl.FRAMEBUFFER, fbo[0]);
1158
1159         // Check completeness
1160
1161         var status = context.checkFramebufferStatus(gl.FRAMEBUFFER);
1162         if (status != gl.FRAMEBUFFER_COMPLETE)
1163             throw new es3fFboTestUtil.FboIncompleteException(status);
1164
1165         // Render to them
1166         context.viewport(0, 0, width, height);
1167         context.clearColor(0.0, 0.0, 1.0, 1.0);
1168         context.clear(gl.COLOR_BUFFER_BIT);
1169
1170         context.enable(gl.SCISSOR_TEST);
1171
1172         context.bindFramebuffer(gl.FRAMEBUFFER, fbo[1]);
1173         context.clearColor(0.6, 0.0, 0.0, 1.0);
1174         context.scissor(10, 10, 64, 64);
1175         context.clear(gl.COLOR_BUFFER_BIT);
1176         context.clearColor(0.0, 0.6, 0.0, 1.0);
1177         context.scissor(60, 60, 40, 20);
1178         context.clear(gl.COLOR_BUFFER_BIT);
1179
1180         context.bindFramebuffer(gl.FRAMEBUFFER, fbo[2]);
1181         context.clearColor(0.0, 0.0, 0.6, 1.0);
1182         context.scissor(20, 20, 100, 10);
1183         context.clear(gl.COLOR_BUFFER_BIT);
1184
1185         context.bindFramebuffer(gl.FRAMEBUFFER, fbo[0]);
1186         context.clearColor(0.6, 0.0, 0.6, 1.0);
1187         context.scissor(20, 20, 5, 100);
1188         context.clear(gl.COLOR_BUFFER_BIT);
1189
1190         context.disable(gl.SCISSOR_TEST);
1191
1192         if (this.m_config.colorType == gl.TEXTURE_2D) {
1193             /** @type {es3fFboTestUtil.Texture2DShader} */
1194             var shader = new es3fFboTestUtil.Texture2DShader(
1195                 [fboSamplerType], gluShaderUtil.DataType.FLOAT_VEC4
1196             );
1197             var shaderID = context.createProgram(shader);
1198
1199             shader.setUniforms(context, shaderID);
1200
1201             context.bindFramebuffer(gl.FRAMEBUFFER, null);
1202             context.viewport(0, 0, context.getWidth(), context.getHeight());
1203             rrUtil.drawQuad(
1204                 context, shaderID, [-0.9, -0.9, 0.0], [0.9, 0.9, 0.0]
1205             );
1206             dst.readViewport(
1207                 context, [0, 0, context.getWidth(), context.getHeight()]
1208             );
1209         } else
1210             es3fFboTestUtil.readPixels(
1211                 context, dst, 0, 0, width, height, colorFormat,
1212                 [1.0, 1.0, 1.0, 1.0], [0.0, 0.0, 0.0, 0.0]
1213             );
1214
1215         //delete FBOs
1216         for (fboi = 0; fboi < fbo.length; fboi++)
1217             context.deleteFramebuffer(fbo[fboi]);
1218
1219         //delete Texture/Renderbuffer
1220         if (this.m_config.colorType == gl.TEXTURE_2D)
1221             context.deleteTexture(colorbuffer);
1222         else
1223             context.deleteRenderbuffer(colorbuffer);
1224     };
1225
1226     /**
1227      * @constructor
1228      * @extends {es3fFboRenderTest.FboRenderCase}
1229      * @param {es3fFboRenderTest.FboConfig} config
1230      */
1231     es3fFboRenderTest.SharedDepthStencilTest = function(config) {
1232         es3fFboRenderTest.FboRenderCase.call(
1233             this, config.getName(), 'Shared depth/stencilbuffer', config
1234         );
1235     };
1236
1237     es3fFboRenderTest.SharedDepthStencilTest.prototype =
1238         Object.create(es3fFboRenderTest.FboRenderCase.prototype);
1239
1240     es3fFboRenderTest.SharedDepthStencilTest.prototype.constructor =
1241         es3fFboRenderTest.SharedDepthStencilTest;
1242
1243     /**
1244      * @param {es3fFboRenderTest.FboConfig} config
1245      * @return {boolean}
1246      */
1247     es3fFboRenderTest.SharedDepthStencilTest.prototype.isConfigSupported =
1248     function(config) {
1249         return deMath.binaryOp(
1250             config.buffers,
1251             deMath.binaryOp(
1252                 gl.DEPTH_BUFFER_BIT, gl.STENCIL_BUFFER_BIT, deMath.BinaryOp.OR
1253             ), deMath.BinaryOp.AND
1254         ) != 0;
1255     };
1256
1257     /**
1258      * @param {?sglrGLContext.GLContext|sglrReferenceContext.ReferenceContext}
1259      * context
1260      * @param {tcuSurface.Surface} dst
1261      */
1262     es3fFboRenderTest.SharedDepthStencilTest.prototype.render = function(
1263         context, dst) {
1264
1265         /** @type {es3fFboTestUtil.Texture2DShader} */
1266         var texShader = new es3fFboTestUtil.Texture2DShader(
1267             [gluShaderUtil.DataType.SAMPLER_2D],
1268             gluShaderUtil.DataType.FLOAT_VEC4
1269         );
1270
1271         /** @type {es3fFboTestUtil.FlatColorShader} */
1272         var flatShader = new es3fFboTestUtil.FlatColorShader(
1273             gluShaderUtil.DataType.FLOAT_VEC4
1274         );
1275
1276         var texShaderID = context.createProgram(texShader);
1277         var flatShaderID = context.createProgram(flatShader);
1278         var width = 128;
1279         var height = 128;
1280         // bool depth = (this.m_config.buffers & gl.DEPTH_BUFFER_BIT) != 0;
1281         /**@type {boolean} */ var stencil =
1282             (this.m_config.buffers & gl.STENCIL_BUFFER_BIT) != 0;
1283
1284         // Textures
1285         var metaballsTex = context.createTexture();
1286         var quadsTex = context.createTexture();
1287         es3fFboRenderTest.createMetaballsTex2D(
1288             context, metaballsTex, gl.RGB, gl.UNSIGNED_BYTE, 64, 64
1289         );
1290         es3fFboRenderTest.createQuadsTex2D(
1291             context, quadsTex, gl.RGB, gl.UNSIGNED_BYTE, 64, 64
1292         );
1293
1294         context.viewport(0, 0, width, height);
1295
1296         // Fbo A
1297         /** @type {es3fFboRenderTest.Framebuffer} */
1298         var fboA = new es3fFboRenderTest.Framebuffer(
1299             context, this.m_config, width, height
1300         );
1301
1302         fboA.checkCompleteness();
1303
1304         // Fbo B
1305         /** @type {es3fFboRenderTest.FboConfig} */
1306         var cfg = /** @type {es3fFboRenderTest.FboConfig} */
1307             (deUtil.clone(this.m_config));
1308
1309         cfg.buffers = deMath.binaryOp(
1310             cfg.buffers,
1311             deMath.binaryNot(gl.DEPTH_BUFFER_BIT | gl.STENCIL_BUFFER_BIT),
1312             deMath.BinaryOp.AND
1313         );
1314         cfg.depthStencilType = gl.NONE;
1315         cfg.depthStencilFormat = gl.NONE;
1316
1317         /** @type {es3fFboRenderTest.Framebuffer} */
1318         var fboB = new es3fFboRenderTest.Framebuffer(
1319             context, cfg, width, height
1320         );
1321
1322         // Bind depth/stencil buffers from fbo A to fbo B
1323         context.bindFramebuffer(gl.FRAMEBUFFER, fboB.getFramebuffer());
1324         for (var ndx = 0; ndx < 2; ndx++) {
1325             var bit = ndx ? gl.STENCIL_BUFFER_BIT : gl.DEPTH_BUFFER_BIT;
1326             var point = ndx ? gl.STENCIL_ATTACHMENT : gl.DEPTH_ATTACHMENT;
1327
1328             if (
1329                 deMath.binaryOp(
1330                     this.m_config.buffers, bit, deMath.BinaryOp.AND
1331                 ) == 0
1332             )
1333                 continue;
1334
1335             switch (this.m_config.depthStencilType) {
1336                 case gl.TEXTURE_2D:
1337                     context.framebufferTexture2D(
1338                         gl.FRAMEBUFFER, point, gl.TEXTURE_2D,
1339                         fboA.getDepthStencilBuffer(), 0
1340                     );
1341                     break;
1342                 case gl.RENDERBUFFER:
1343                     context.framebufferRenderbuffer(
1344                         gl.FRAMEBUFFER, point, gl.RENDERBUFFER,
1345                         fboA.getDepthStencilBuffer()
1346                     );
1347                     break;
1348                 default:
1349                     testFailed('Not implemented');
1350             }
1351         }
1352
1353         // Setup uniforms
1354         texShader.setUniforms(context, texShaderID);
1355
1356         // Clear color to red and stencil to 1 in fbo B.
1357         context.clearColor(1.0, 0.0, 0.0, 1.0);
1358         context.clearStencil(1);
1359         context.clear(
1360             gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT | gl.STENCIL_BUFFER_BIT
1361         );
1362
1363         context.enable(gl.DEPTH_TEST);
1364
1365         // Render quad to fbo A
1366         context.bindFramebuffer(gl.FRAMEBUFFER, fboA.getFramebuffer());
1367         context.bindTexture(gl.TEXTURE_2D, quadsTex);
1368         rrUtil.drawQuad(
1369             context, texShaderID, [-1.0, -1.0, 0.0], [1.0, 1.0, 0.0]
1370         );
1371
1372         if (stencil) {
1373             // Clear subset of stencil buffer to 0 in fbo A
1374             context.enable(gl.SCISSOR_TEST);
1375             context.scissor(10, 10, 12, 25);
1376             context.clearStencil(0);
1377             context.clear(gl.STENCIL_BUFFER_BIT);
1378             context.disable(gl.SCISSOR_TEST);
1379         }
1380
1381         // Render metaballs to fbo B
1382         context.bindFramebuffer(gl.FRAMEBUFFER, fboB.getFramebuffer());
1383         context.bindTexture(gl.TEXTURE_2D, metaballsTex);
1384         rrUtil.drawQuad(
1385             context, texShaderID, [-1.0, -1.0, -1.0], [1.0, 1.0, 1.0]
1386         );
1387
1388         context.disable(gl.DEPTH_TEST);
1389
1390         if (stencil) {
1391             // Render quad with stencil mask == 0
1392             context.enable(gl.STENCIL_TEST);
1393             context.stencilFunc(gl.EQUAL, 0, 0xff);
1394             context.useProgram(flatShaderID);
1395             flatShader.setColor(context, flatShaderID, [0.0, 1.0, 0.0, 1.0]);
1396             rrUtil.drawQuad(
1397                 context, flatShaderID, [-1.0, -1.0, 0.0], [1.0, 1.0, 0.0]
1398             );
1399             context.disable(gl.STENCIL_TEST);
1400         }
1401
1402         if (this.m_config.colorType == gl.TEXTURE_2D) {
1403             // Render both to screen
1404             context.bindFramebuffer(gl.FRAMEBUFFER, null);
1405             context.viewport(0, 0, context.getWidth(), context.getHeight());
1406             context.bindTexture(gl.TEXTURE_2D, fboA.getColorBuffer());
1407             rrUtil.drawQuad(
1408                 context, texShaderID, [-1.0, -1.0, 0.0], [0.0, 1.0, 0.0]
1409             );
1410             context.bindTexture(gl.TEXTURE_2D, fboB.getColorBuffer());
1411             rrUtil.drawQuad(
1412                 context, texShaderID, [0.0, -1.0, 0.0], [1.0, 1.0, 0.0]
1413             );
1414
1415             dst.readViewport(
1416                 context, [0, 0, context.getWidth(), context.getHeight()]
1417             );
1418         } else {
1419             // Read results from fbo B
1420             es3fFboTestUtil.readPixels(
1421                 context, dst, 0, 0, width, height,
1422                 gluTextureUtil.mapGLInternalFormat(this.m_config.colorFormat),
1423                 [1.0, 1.0, 1.0, 1.0], [0.0, 0.0, 0.0, 0.0]
1424             );
1425         }
1426     };
1427
1428     /**
1429      * @constructor
1430      * @extends {es3fFboRenderTest.FboRenderCase}
1431      * @param {es3fFboRenderTest.FboConfig} config
1432      */
1433     es3fFboRenderTest.ResizeTest = function(config) {
1434         es3fFboRenderTest.FboRenderCase.call(
1435             this, config.getName(), 'Resize framebuffer', config
1436         );
1437     };
1438
1439     es3fFboRenderTest.ResizeTest.prototype =
1440         Object.create(es3fFboRenderTest.FboRenderCase.prototype);
1441
1442     es3fFboRenderTest.ResizeTest.prototype.constructor =
1443         es3fFboRenderTest.ResizeTest;
1444
1445     /**
1446      * @param {?sglrGLContext.GLContext|sglrReferenceContext.ReferenceContext}
1447      * context
1448      * @param {tcuSurface.Surface} dst
1449      */
1450     es3fFboRenderTest.ResizeTest.prototype.render = function(context, dst) {
1451         /** @type {tcuTexture.TextureFormat} */
1452         var colorFormat = gluTextureUtil.mapGLInternalFormat(
1453             this.m_config.colorFormat
1454         );
1455         /** @type {gluShaderUtil.DataType} */
1456         var fboSamplerType = gluTextureUtil.getSampler2DType(colorFormat);
1457         /** @type {gluShaderUtil.DataType} */
1458         var fboOutputType = es3fFboTestUtil.getFragmentOutputType(colorFormat);
1459         /** @type {tcuTextureUtil.TextureFormatInfo} */
1460         var fboRangeInfo = tcuTextureUtil.getTextureFormatInfo(colorFormat);
1461         var fboOutScale = deMath.subtract(
1462             fboRangeInfo.valueMax, fboRangeInfo.valueMin
1463         );
1464         var fboOutBias = fboRangeInfo.valueMin;
1465
1466         /** @type {es3fFboTestUtil.Texture2DShader} */
1467         var texToFboShader = new es3fFboTestUtil.Texture2DShader(
1468             [gluShaderUtil.DataType.SAMPLER_2D], fboOutputType
1469         );
1470
1471         /** @type {es3fFboTestUtil.Texture2DShader} */
1472         var texFromFboShader = new es3fFboTestUtil.Texture2DShader(
1473             [fboSamplerType], gluShaderUtil.DataType.FLOAT_VEC4
1474         );
1475
1476         /** @type {es3fFboTestUtil.FlatColorShader} */
1477         var flatShader = new es3fFboTestUtil.FlatColorShader(fboOutputType);
1478         /** @type {WebGLProgram} */
1479         var texToFboShaderID = context.createProgram(texToFboShader);
1480         /** @type {WebGLProgram} */
1481         var texFromFboShaderID = context.createProgram(texFromFboShader);
1482         /** @type {WebGLProgram} */
1483         var flatShaderID = context.createProgram(flatShader);
1484
1485         var quadsTex = context.createTexture();
1486         var metaballsTex = context.createTexture();
1487
1488         var depth = deMath.binaryOp(
1489             this.m_config.buffers, gl.DEPTH_BUFFER_BIT, deMath.BinaryOp.AND
1490         ) != 0;
1491         var stencil = deMath.binaryOp(
1492             this.m_config.buffers, gl.STENCIL_BUFFER_BIT, deMath.BinaryOp.AND
1493         ) != 0;
1494
1495         var initialWidth = 128;
1496         var initialHeight = 128;
1497         var newWidth = 64;
1498         var newHeight = 32;
1499
1500         texToFboShader.setOutScaleBias(fboOutScale, fboOutBias);
1501         texFromFboShader.setTexScaleBias(
1502             0, fboRangeInfo.lookupScale, fboRangeInfo.lookupBias
1503         );
1504
1505         es3fFboRenderTest.createQuadsTex2D(
1506             context, quadsTex, gl.RGB, gl.UNSIGNED_BYTE, 64, 64
1507         );
1508         es3fFboRenderTest.createMetaballsTex2D(
1509             context, metaballsTex, gl.RGB, gl.UNSIGNED_BYTE, 32, 32
1510         );
1511
1512         /** @type {es3fFboRenderTest.Framebuffer} */
1513         var fbo = new es3fFboRenderTest.Framebuffer(
1514             context, this.m_config, initialWidth, initialHeight
1515         );
1516         fbo.checkCompleteness();
1517
1518         // Setup shaders
1519         texToFboShader.setUniforms(context, texToFboShaderID);
1520         texFromFboShader.setUniforms(context, texFromFboShaderID);
1521         flatShader.setColor(
1522             context, flatShaderID, deMath.add(
1523                 deMath.multiply([0.0, 1.0, 0.0, 1.0], fboOutScale), fboOutBias
1524             )
1525         );
1526
1527         // Render quads
1528         context.bindFramebuffer(gl.FRAMEBUFFER, fbo.getFramebuffer());
1529         context.viewport(0, 0, initialWidth, initialHeight);
1530         es3fFboTestUtil.clearColorBuffer(
1531             context, colorFormat, [0.0, 0.0, 0.0, 1.0]
1532         );
1533         context.clear(gl.DEPTH_BUFFER_BIT | gl.STENCIL_BUFFER_BIT);
1534         context.bindTexture(gl.TEXTURE_2D, quadsTex);
1535         rrUtil.drawQuad(
1536             context, texToFboShaderID, [-1.0, -1.0, 0.0], [1.0, 1.0, 0.0]
1537         );
1538
1539         if (fbo.getConfig().colorType == gl.TEXTURE_2D) {
1540             // Render fbo to screen
1541             context.bindFramebuffer(gl.FRAMEBUFFER, null);
1542             context.viewport(0, 0, context.getWidth(), context.getHeight());
1543             context.bindTexture(gl.TEXTURE_2D, fbo.getColorBuffer());
1544             rrUtil.drawQuad(
1545                 context, texFromFboShaderID, [-1.0, -1.0, 0.0], [1.0, 1.0, 0.0]
1546             );
1547             // Restore binding
1548             context.bindFramebuffer(gl.FRAMEBUFFER, fbo.getFramebuffer());
1549         }
1550
1551         // Resize buffers
1552         switch (fbo.getConfig().colorType) {
1553             case gl.TEXTURE_2D:
1554                 context.bindTexture(gl.TEXTURE_2D, fbo.getColorBuffer());
1555                 context.texImage2DDelegate(
1556                     gl.TEXTURE_2D, 0, fbo.getConfig().colorFormat,
1557                     newWidth, newHeight
1558                 );
1559                 break;
1560
1561             case gl.RENDERBUFFER:
1562                 context.bindRenderbuffer(gl.RENDERBUFFER, fbo.getColorBuffer());
1563                 context.renderbufferStorage(
1564                     gl.RENDERBUFFER, fbo.getConfig().colorFormat,
1565                     newWidth, newHeight
1566                 );
1567                 break;
1568
1569             default:
1570                 throw new Error('Color type unsupported');
1571         }
1572
1573         if (depth || stencil) {
1574             switch (fbo.getConfig().depthStencilType) {
1575                 case gl.TEXTURE_2D:
1576                     context.bindTexture(
1577                         gl.TEXTURE_2D, fbo.getDepthStencilBuffer()
1578                     );
1579                     context.texImage2DDelegate(
1580                         gl.TEXTURE_2D, 0, fbo.getConfig().depthStencilFormat,
1581                         newWidth, newHeight
1582                     );
1583                     break;
1584
1585                 case gl.RENDERBUFFER:
1586                     context.bindRenderbuffer(
1587                         gl.RENDERBUFFER, fbo.getDepthStencilBuffer()
1588                     );
1589                     context.renderbufferStorage(
1590                         gl.RENDERBUFFER, fbo.getConfig().depthStencilFormat,
1591                         newWidth, newHeight
1592                     );
1593                     break;
1594
1595                 default:
1596                     throw new Error('Depth / stencil type unsupported');
1597             }
1598         }
1599
1600         // Render to resized fbo
1601         context.viewport(0, 0, newWidth, newHeight);
1602         es3fFboTestUtil.clearColorBuffer(
1603             context, colorFormat, [1.0, 0.0, 0.0, 1.0]
1604         );
1605         context.clear(gl.DEPTH_BUFFER_BIT | gl.STENCIL_BUFFER_BIT);
1606
1607         context.enable(gl.DEPTH_TEST);
1608
1609         context.bindTexture(gl.TEXTURE_2D, metaballsTex);
1610         rrUtil.drawQuad(
1611             context, texToFboShaderID, [-1.0, -1.0, 0.0], [1.0, 1.0, 0.0]
1612         );
1613
1614         context.bindTexture(gl.TEXTURE_2D, quadsTex);
1615         rrUtil.drawQuad(
1616             context, texToFboShaderID, [0.0, 0.0, -1.0], [1.0, 1.0, 1.0]
1617         );
1618
1619         context.disable(gl.DEPTH_TEST);
1620
1621         if (stencil) {
1622             context.enable(gl.SCISSOR_TEST);
1623             context.clearStencil(1);
1624             context.scissor(10, 10, 5, 15);
1625             context.clear(gl.STENCIL_BUFFER_BIT);
1626             context.disable(gl.SCISSOR_TEST);
1627
1628             context.enable(gl.STENCIL_TEST);
1629             context.stencilFunc(gl.EQUAL, 1, 0xff);
1630             rrUtil.drawQuad(
1631                 context, flatShaderID, [-1.0, -1.0, 0.0], [1.0, 1.0, 0.0]
1632             );
1633             context.disable(gl.STENCIL_TEST);
1634         }
1635
1636         if (this.m_config.colorType == gl.TEXTURE_2D) {
1637             context.bindFramebuffer(gl.FRAMEBUFFER, null);
1638             context.viewport(0, 0, context.getWidth(), context.getHeight());
1639             context.bindTexture(gl.TEXTURE_2D, fbo.getColorBuffer());
1640             rrUtil.drawQuad(
1641                 context, texFromFboShaderID, [-0.5, -0.5, 0.0], [0.5, 0.5, 0.0]
1642             );
1643             dst.readViewport(
1644                 context, [0, 0, context.getWidth(), context.getHeight()]
1645             );
1646         } else
1647             es3fFboTestUtil.readPixels(
1648                 context, dst, 0, 0, newWidth, newHeight, colorFormat,
1649                 fboRangeInfo.lookupScale, fboRangeInfo.lookupBias
1650             );
1651     };
1652
1653     /**
1654      * @constructor
1655      * @extends {es3fFboRenderTest.FboRenderCase}
1656      * @param {es3fFboRenderTest.FboConfig} config
1657      * @param {number} buffers
1658      * @param {boolean} rebind
1659      */
1660     es3fFboRenderTest.RecreateBuffersTest = function(config, buffers, rebind) {
1661         es3fFboRenderTest.FboRenderCase.call(
1662             this, config.getName() +
1663             (rebind ? '' : '_no_rebind'),
1664             'Recreate buffers', config
1665         );
1666         this.m_buffers = buffers;
1667         this.m_rebind = rebind;
1668     };
1669
1670     es3fFboRenderTest.RecreateBuffersTest.prototype =
1671         Object.create(es3fFboRenderTest.FboRenderCase.prototype);
1672
1673     es3fFboRenderTest.RecreateBuffersTest.prototype.construtor =
1674         es3fFboRenderTest.RecreateBuffersTest;
1675
1676     /**
1677      * @param {?sglrGLContext.GLContext|sglrReferenceContext.ReferenceContext}
1678      * ctx
1679      * @param {tcuSurface.Surface} dst
1680      */
1681     es3fFboRenderTest.RecreateBuffersTest.prototype.render = function(
1682         ctx, dst) {
1683
1684         /** @type {tcuTexture.TextureFormat} */
1685         var colorFormat = gluTextureUtil.mapGLInternalFormat(
1686             this.m_config.colorFormat
1687         );
1688         /** @type {gluShaderUtil.DataType} */
1689         var fboSamplerType = gluTextureUtil.getSampler2DType(colorFormat);
1690         /** @type {gluShaderUtil.DataType} */
1691         var fboOutputType = es3fFboTestUtil.getFragmentOutputType(colorFormat);
1692         /** @type {tcuTextureUtil.TextureFormatInfo} */
1693         var fboRangeInfo = tcuTextureUtil.getTextureFormatInfo(colorFormat);
1694         var fboOutScale = deMath.subtract(
1695             fboRangeInfo.valueMax, fboRangeInfo.valueMin
1696         );
1697         var fboOutBias = fboRangeInfo.valueMin;
1698
1699         /** @type {es3fFboTestUtil.Texture2DShader} */
1700         var texToFboShader = new es3fFboTestUtil.Texture2DShader(
1701             [gluShaderUtil.DataType.SAMPLER_2D], fboOutputType
1702         );
1703         /** @type {es3fFboTestUtil.Texture2DShader} */
1704         var texFromFboShader = new es3fFboTestUtil.Texture2DShader(
1705             [fboSamplerType], gluShaderUtil.DataType.FLOAT_VEC4
1706         );
1707
1708         /** @type {es3fFboTestUtil.FlatColorShader} */
1709         var flatShader = new es3fFboTestUtil.FlatColorShader(fboOutputType);
1710         /** @type {number} */
1711         var texToFboShaderID = ctx.createProgram(texToFboShader);
1712         /** @type {number} */
1713         var texFromFboShaderID = ctx.createProgram(texFromFboShader);
1714         /** @type {number} */
1715         var flatShaderID = ctx.createProgram(flatShader);
1716
1717         var width = 128;
1718         var height = 128;
1719         var metaballsTex = ctx.createTexture();
1720         var quadsTex = ctx.createTexture();
1721         var stencil = deMath.binaryOp(
1722             this.m_config.buffers, gl.STENCIL_BUFFER_BIT, deMath.BinaryOp.AND
1723         ) != 0;
1724
1725         es3fFboRenderTest.createQuadsTex2D(
1726             ctx, quadsTex, gl.RGB, gl.UNSIGNED_BYTE, 64, 64
1727         );
1728         es3fFboRenderTest.createMetaballsTex2D(
1729             ctx, metaballsTex, gl.RGB, gl.UNSIGNED_BYTE, 64, 64
1730         );
1731
1732         /** @type {es3fFboRenderTest.Framebuffer} */
1733         var fbo = new es3fFboRenderTest.Framebuffer(
1734             ctx, this.m_config, width, height
1735         );
1736         fbo.checkCompleteness();
1737
1738         // Setup shaders
1739         texToFboShader.setOutScaleBias(fboOutScale, fboOutBias);
1740         texFromFboShader.setTexScaleBias(
1741             0, fboRangeInfo.lookupScale, fboRangeInfo.lookupBias
1742         );
1743         texToFboShader.setUniforms(ctx, texToFboShaderID);
1744         texFromFboShader.setUniforms(ctx, texFromFboShaderID);
1745         flatShader.setColor(
1746             ctx, flatShaderID, deMath.add(
1747                 deMath.multiply([0.0, 0.0, 1.0, 1.0], fboOutScale
1748             ), fboOutBias)
1749         );
1750
1751         // Draw scene
1752         ctx.bindFramebuffer(gl.FRAMEBUFFER, fbo.getFramebuffer());
1753         ctx.viewport(0, 0, width, height);
1754         es3fFboTestUtil.clearColorBuffer(
1755             ctx, colorFormat, [1.0, 0.0, 0.0, 1.0]
1756         );
1757         ctx.clear(gl.DEPTH_BUFFER_BIT | gl.STENCIL_BUFFER_BIT);
1758
1759         ctx.enable(gl.DEPTH_TEST);
1760
1761         ctx.bindTexture(gl.TEXTURE_2D, quadsTex);
1762         rrUtil.drawQuad(
1763             ctx, texToFboShaderID, [-1.0, -1.0, 0.0], [1.0, 1.0, 0.0]
1764         );
1765
1766         ctx.disable(gl.DEPTH_TEST);
1767
1768         if (stencil) {
1769             ctx.enable(gl.SCISSOR_TEST);
1770             ctx.scissor(
1771                 Math.floor(width / 4), Math.floor(height / 4),
1772                 Math.floor(width / 2), Math.floor(height / 2)
1773             );
1774             ctx.clearStencil(1);
1775             ctx.clear(gl.STENCIL_BUFFER_BIT);
1776             ctx.disable(gl.SCISSOR_TEST);
1777         }
1778
1779         // Recreate buffers
1780         if (!this.m_rebind)
1781             ctx.bindFramebuffer(gl.FRAMEBUFFER, null);
1782
1783         assertMsgOptions(
1784             deMath.binaryOp(
1785                 this.m_buffers, deMath.binaryOp(
1786                     gl.DEPTH_BUFFER_BIT,
1787                     gl.STENCIL_BUFFER_BIT,
1788                     deMath.BinaryOp.OR
1789                 ), deMath.BinaryOp.AND
1790             ) == 0 || deMath.binaryOp(
1791                 this.m_buffers, deMath.binaryOp(
1792                     gl.DEPTH_BUFFER_BIT,
1793                     gl.STENCIL_BUFFER_BIT,
1794                     deMath.BinaryOp.OR
1795                 ), deMath.BinaryOp.AND
1796             ) == deMath.binaryOp(
1797                     this.m_config.buffers, deMath.binaryOp(
1798                         gl.DEPTH_BUFFER_BIT,
1799                         gl.STENCIL_BUFFER_BIT,
1800                         deMath.BinaryOp.OR
1801                     ), deMath.BinaryOp.AND
1802             ), 'Depth/stencil buffers are not disabled or not ' +
1803             'equal to the config\'s depth/stencil buffer state',
1804             false, true
1805         );
1806
1807         // Recreate.
1808         for (var ndx = 0; ndx < 2; ndx++) {
1809             var bit = ndx == 0 ? gl.COLOR_BUFFER_BIT :
1810                 (gl.DEPTH_BUFFER_BIT | gl.STENCIL_BUFFER_BIT);
1811             var type = ndx == 0 ? fbo.getConfig().colorType :
1812                 fbo.getConfig().depthStencilType;
1813             var format = ndx == 0 ? fbo.getConfig().colorFormat :
1814                 fbo.getConfig().depthStencilFormat;
1815             var buf = ndx == 0 ? fbo.getColorBuffer() :
1816                 fbo.getDepthStencilBuffer();
1817
1818             if (deMath.binaryOp(this.m_buffers, bit, deMath.BinaryOp.AND) == 0)
1819                 continue;
1820
1821             switch (type) {
1822                 case gl.TEXTURE_2D:
1823                     ctx.deleteTexture(/** @type {WebGLTexture} */ (buf));
1824                     buf = ctx.createTexture();
1825                     ctx.bindTexture(gl.TEXTURE_2D, buf);
1826                     ctx.texImage2DDelegate(
1827                         gl.TEXTURE_2D, 0, format, width, height
1828                     );
1829                     ctx.texParameteri(
1830                         gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST
1831                     );
1832                     ctx.texParameteri(
1833                         gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST
1834                     );
1835                     break;
1836
1837                 case gl.RENDERBUFFER:
1838                     ctx.deleteRenderbuffer(
1839                         /** @type {WebGLRenderbuffer} */ (buf)
1840                     );
1841                     buf = ctx.createRenderbuffer();
1842                     ctx.bindRenderbuffer(gl.RENDERBUFFER, buf);
1843                     ctx.renderbufferStorage(
1844                         gl.RENDERBUFFER, format, width, height
1845                     );
1846                     break;
1847
1848                 default:
1849                     throw new Error('Unsupported buffer type');
1850             }
1851
1852             if (ndx == 0) {
1853                 fbo.m_colorBuffer = buf;
1854             } else {
1855                 fbo.m_depthStencilBuffer = buf;
1856             }
1857         }
1858
1859         // Rebind.
1860         if (this.m_rebind) {
1861             for (var ndx = 0; ndx < 3; ndx++) {
1862                 var bit = ndx == 0 ? gl.COLOR_BUFFER_BIT :
1863                     ndx == 1 ? gl.DEPTH_BUFFER_BIT :
1864                     ndx == 2 ? gl.STENCIL_BUFFER_BIT : 0;
1865                 var point = ndx == 0 ? gl.COLOR_ATTACHMENT0 :
1866                     ndx == 1 ? gl.DEPTH_ATTACHMENT :
1867                     ndx == 2 ? gl.STENCIL_ATTACHMENT : 0;
1868                 var type = ndx == 0 ? fbo.getConfig().colorType :
1869                     fbo.getConfig().depthStencilType;
1870                 var buf = ndx == 0 ? fbo.getColorBuffer() :
1871                     fbo.getDepthStencilBuffer();
1872
1873                 if (deMath.binaryOp(
1874                         this.m_buffers, bit, deMath.BinaryOp.AND) == 0)
1875                     continue;
1876
1877                 switch (type) {
1878                     case gl.TEXTURE_2D:
1879                         ctx.framebufferTexture2D(
1880                             gl.FRAMEBUFFER, point, gl.TEXTURE_2D, buf, 0
1881                         );
1882                         break;
1883
1884                     case gl.RENDERBUFFER:
1885                         ctx.framebufferRenderbuffer(
1886                             gl.FRAMEBUFFER, point, gl.RENDERBUFFER, buf
1887                         );
1888                         break;
1889
1890                     default:
1891                         throw new Error('Invalid buffer type');
1892                 }
1893             }
1894         }
1895
1896         if (!this.m_rebind)
1897             ctx.bindFramebuffer(gl.FRAMEBUFFER, fbo.getFramebuffer());
1898
1899         ctx.clearStencil(0);
1900
1901         // \note Clear only buffers that were re-created
1902         ctx.clear(
1903             deMath.binaryOp(
1904                 this.m_buffers,
1905                 deMath.binaryOp(
1906                     gl.DEPTH_BUFFER_BIT,
1907                     gl.STENCIL_BUFFER_BIT,
1908                     deMath.BinaryOp.OR
1909                 ), deMath.BinaryOp.AND
1910             )
1911         );
1912
1913         if (deMath.binaryOp(
1914             this.m_buffers, gl.COLOR_BUFFER_BIT, deMath.BinaryOp.AND)) {
1915             // Clearing of integer buffers is undefined
1916             // so do clearing by rendering flat color.
1917             rrUtil.drawQuad(
1918                 ctx, flatShaderID, [-1.0, -1.0, 0.0], [1.0, 1.0, 0.0]
1919             );
1920         }
1921
1922         ctx.enable(gl.DEPTH_TEST);
1923
1924         if (stencil) {
1925             // \note Stencil test enabled only if we have stencil buffer
1926             ctx.enable(gl.STENCIL_TEST);
1927             ctx.stencilFunc(gl.EQUAL, 0, 0xff);
1928         }
1929         ctx.bindTexture(gl.TEXTURE_2D, metaballsTex);
1930         rrUtil.drawQuad(
1931             ctx, texToFboShaderID, [-1.0, -1.0, 1.0], [1.0, 1.0, -1.0]
1932         );
1933         if (stencil)
1934             ctx.disable(gl.STENCIL_TEST);
1935
1936         ctx.disable(gl.DEPTH_TEST);
1937
1938         if (fbo.getConfig().colorType == gl.TEXTURE_2D) {
1939             // Unbind fbo
1940             ctx.bindFramebuffer(gl.FRAMEBUFFER, null);
1941
1942             // Draw to screen
1943             ctx.bindTexture(gl.TEXTURE_2D, fbo.getColorBuffer());
1944             ctx.viewport(0, 0, ctx.getWidth(), ctx.getHeight());
1945             rrUtil.drawQuad(
1946                 ctx, texFromFboShaderID, [-1.0, -1.0, 0.0], [1.0, 1.0, 0.0]
1947             );
1948
1949             // Read from screen
1950             dst.readViewport(ctx, [0, 0, ctx.getWidth(), ctx.getHeight()]);
1951         } else {
1952             // Read from fbo
1953             es3fFboTestUtil.readPixels(
1954                 ctx, dst, 0, 0, width, height, colorFormat,
1955                 fboRangeInfo.lookupScale, fboRangeInfo.lookupBias
1956             );
1957         }
1958     };
1959
1960     // FboGroups
1961
1962     /**
1963      * @constructor
1964      * @extends {tcuTestCase.DeqpTest}
1965      */
1966     es3fFboRenderTest.FboRenderTestGroup = function() {
1967         tcuTestCase.DeqpTest.call(this, 'render', 'Rendering Tests');
1968     };
1969
1970     es3fFboRenderTest.FboRenderTestGroup.prototype =
1971         Object.create(tcuTestCase.DeqpTest.prototype);
1972
1973     es3fFboRenderTest.FboRenderTestGroup.prototype.constructor =
1974         es3fFboRenderTest.FboRenderTestGroup;
1975
1976     /**
1977      * @enum {number}
1978      */
1979     var FormatType = {
1980         FLOAT: 0,
1981         INT: 1,
1982         UINT: 2
1983     };
1984
1985     // Required by specification.
1986     /**
1987      * @typedef {{format: number, type: FormatType}}
1988      */
1989     var ColorFormatStruct;
1990
1991     /**
1992      * @typedef {{format: number, depth: boolean, stencil: boolean}}
1993      */
1994     var DepthStencilFormatStruct;
1995
1996     /**
1997      * init
1998      */
1999     es3fFboRenderTest.FboRenderTestGroup.prototype.init = function() {
2000         var objectTypes = [
2001             gl.TEXTURE_2D,
2002             gl.RENDERBUFFER
2003         ];
2004
2005         /** @type {Array<ColorFormatStruct>} */ var colorFormats = [{
2006                 format: gl.RGBA32F, type: FormatType.FLOAT
2007             },{
2008                 format: gl.RGBA32I, type: FormatType.INT
2009             },{
2010                 format: gl.RGBA32UI, type: FormatType.UINT
2011             },{
2012                 format: gl.RGBA16F, type: FormatType.FLOAT
2013             },{
2014                 format: gl.RGBA16I, type: FormatType.INT
2015             },{
2016                 format: gl.RGBA16UI, type: FormatType.UINT
2017             },/*{
2018                 // RGB16F isn't made color-renderable through WebGL's EXT_color_buffer_float
2019                 format: gl.RGB16F, type: FormatType.FLOAT
2020             },*/{
2021                 format: gl.RGBA8I, type: FormatType.INT
2022             },{
2023                 format: gl.RGBA8UI, type: FormatType.UINT
2024             },{
2025                 format: gl.RGB10_A2UI, type: FormatType.UINT
2026             },{
2027                 format: gl.R11F_G11F_B10F, type: FormatType.FLOAT
2028             },{
2029                 format: gl.RG32F, type: FormatType.FLOAT
2030             },{
2031                 format: gl.RG32I, type: FormatType.INT
2032             },{
2033                 format: gl.RG32UI, type: FormatType.UINT
2034             },{
2035                 format: gl.RG16F, type: FormatType.FLOAT
2036             },{
2037                 format: gl.RG16I, type: FormatType.INT
2038             },{
2039                 format: gl.RG16UI, type: FormatType.UINT
2040             },{
2041                 format: gl.RG8, type: FormatType.FLOAT
2042             },{
2043                 format: gl.RG8I, type: FormatType.INT
2044             },{
2045                 format: gl.RG8UI, type: FormatType.UINT
2046             },{
2047                 format: gl.R32F, type: FormatType.FLOAT
2048             },{
2049                 format: gl.R32I, type: FormatType.INT
2050             },{
2051                 format: gl.R32UI, type: FormatType.UINT
2052             },{
2053                 format: gl.R16F, type: FormatType.FLOAT
2054             },{
2055                 format: gl.R16I, type: FormatType.INT
2056             },{
2057                 format: gl.R16UI, type: FormatType.UINT
2058             },{
2059                 format: gl.R8, type: FormatType.FLOAT
2060             },{
2061                 format: gl.R8I, type: FormatType.INT
2062             },{
2063                 format: gl.R8UI, type: FormatType.UINT
2064         }];
2065
2066         /** @type {Array<DepthStencilFormatStruct>} */
2067         var depthStencilFormats = [{
2068                 format: gl.DEPTH_COMPONENT32F, depth: true, stencil: false
2069             },{
2070                 format: gl.DEPTH_COMPONENT24, depth: true, stencil: false
2071             },{
2072                 format: gl.DEPTH_COMPONENT16, depth: true, stencil: false
2073             },{
2074                 format: gl.DEPTH32F_STENCIL8, depth: true, stencil: true
2075             },{
2076                 format: gl.DEPTH24_STENCIL8, depth: true, stencil: true
2077             },{
2078                 format: gl.STENCIL_INDEX8, depth: false, stencil: true
2079         }];
2080
2081         /** @type {es3fFboRenderTest.FboConfig} */ var config;
2082         var colorType;
2083         var stencilType;
2084         var colorFmt;
2085         var depth;
2086         var stencil;
2087         var depthStencilType;
2088         var depthStencilFormat;
2089
2090         // .stencil_clear
2091         /** @type {tcuTestCase.DeqpTest} */
2092         var stencilClearGroup = new tcuTestCase.DeqpTest(
2093             'stencil_clear', 'Stencil buffer clears'
2094         );
2095
2096         this.addChild(stencilClearGroup);
2097
2098         for (var fmtNdx = 0; fmtNdx < depthStencilFormats.length; fmtNdx++) {
2099             colorType = gl.TEXTURE_2D;
2100             stencilType = gl.RENDERBUFFER;
2101             colorFmt = gl.RGBA8;
2102
2103             if (!depthStencilFormats[fmtNdx].stencil)
2104                 continue;
2105
2106             config = new es3fFboRenderTest.FboConfig(
2107                 gl.COLOR_BUFFER_BIT | gl.STENCIL_BUFFER_BIT,
2108                 colorType, colorFmt, stencilType,
2109                 depthStencilFormats[fmtNdx].format
2110             );
2111             stencilClearGroup.addChild(
2112                 new es3fFboRenderTest.StencilClearsTest(config)
2113             );
2114         }
2115
2116         // .shared_colorbuffer_clear
2117         /** @type {tcuTestCase.DeqpTest} */
2118         var sharedColorbufferClearGroup = new tcuTestCase.DeqpTest(
2119             'shared_colorbuffer_clear', 'Shader colorbuffer clears'
2120         );
2121
2122         this.addChild(sharedColorbufferClearGroup);
2123
2124         for (var colorFmtNdx = 0;
2125             colorFmtNdx < colorFormats.length;
2126             colorFmtNdx++) {
2127
2128             // Clearing of integer buffers is undefined.
2129             if (colorFormats[colorFmtNdx].type == FormatType.INT ||
2130                 colorFormats[colorFmtNdx].type == FormatType.UINT)
2131                 continue;
2132
2133             for (var typeNdx = 0; typeNdx < objectTypes.length; typeNdx++) {
2134                 config = new es3fFboRenderTest.FboConfig(
2135                     gl.COLOR_BUFFER_BIT, objectTypes[typeNdx],
2136                     colorFormats[colorFmtNdx].format, gl.NONE, gl.NONE
2137                 );
2138                 sharedColorbufferClearGroup.addChild(
2139                     new es3fFboRenderTest.SharedColorbufferClearsTest(config)
2140                 );
2141             }
2142         }
2143
2144         // .shared_colorbuffer
2145         /** @type {Array<tcuTestCase.DeqpTest>} */ var sharedColorbufferGroup = [];
2146         var numSharedColorbufferGroups = 3;
2147         for (var ii = 0; ii < numSharedColorbufferGroups; ++ii) {
2148             sharedColorbufferGroup[ii] = new tcuTestCase.DeqpTest(
2149                 'shared_colorbuffer', 'Shared colorbuffer tests'
2150             );
2151             this.addChild(sharedColorbufferGroup[ii]);
2152         }
2153
2154         for (var colorFmtNdx = 0; colorFmtNdx < colorFormats.length; colorFmtNdx++) {
2155
2156             depthStencilType = gl.RENDERBUFFER;
2157             depthStencilFormat = gl.DEPTH24_STENCIL8;
2158
2159             // Blending with integer buffers and fp32 targets is not supported.
2160             if (colorFormats[colorFmtNdx].type == FormatType.INT ||
2161                 colorFormats[colorFmtNdx].type == FormatType.UINT ||
2162                 colorFormats[colorFmtNdx].format == gl.RGBA32F ||
2163                 colorFormats[colorFmtNdx].format == gl.RGB32F ||
2164                 colorFormats[colorFmtNdx].format == gl.RG32F ||
2165                 colorFormats[colorFmtNdx].format == gl.R32F)
2166                 continue;
2167
2168             for (var typeNdx = 0; typeNdx < objectTypes.length; typeNdx++) {
2169                 /** @type {es3fFboRenderTest.FboConfig} */
2170                 var colorOnlyConfig = new es3fFboRenderTest.FboConfig(
2171                     gl.COLOR_BUFFER_BIT, objectTypes[typeNdx],
2172                     colorFormats[colorFmtNdx].format, gl.NONE, gl.NONE
2173                 );
2174                 /** @type {es3fFboRenderTest.FboConfig} */
2175                 var colorDepthConfig = new es3fFboRenderTest.FboConfig(
2176                     gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT,
2177                     objectTypes[typeNdx], colorFormats[colorFmtNdx].format,
2178                     depthStencilType, depthStencilFormat
2179                 );
2180                 /** @type {es3fFboRenderTest.FboConfig} */
2181                 var colorDepthStencilConfig =
2182                     new es3fFboRenderTest.FboConfig(
2183                         gl.COLOR_BUFFER_BIT |
2184                         gl.DEPTH_BUFFER_BIT |
2185                         gl.STENCIL_BUFFER_BIT,
2186                         objectTypes[typeNdx], colorFormats[colorFmtNdx].format,
2187                         depthStencilType, depthStencilFormat
2188                 );
2189
2190                 sharedColorbufferGroup[0].addChild(
2191                     new es3fFboRenderTest.SharedColorbufferTest(colorOnlyConfig)
2192                 );
2193
2194                 sharedColorbufferGroup[1].addChild(
2195                     new es3fFboRenderTest.SharedColorbufferTest(
2196                         colorDepthConfig
2197                     )
2198                 );
2199
2200                 sharedColorbufferGroup[2].addChild(
2201                     new es3fFboRenderTest.SharedColorbufferTest(
2202                         colorDepthStencilConfig
2203                     )
2204                 );
2205             }
2206         }
2207
2208         // .shared_depth_stencil
2209         /** @type {tcuTestCase.DeqpTest} */
2210         var sharedDepthStencilGroup = new tcuTestCase.DeqpTest(
2211             'shared_depth_stencil', 'Shared depth and stencil buffers'
2212         );
2213
2214         this.addChild(sharedDepthStencilGroup);
2215
2216         for (var fmtNdx = 0; fmtNdx < depthStencilFormats.length; fmtNdx++) {
2217             colorType = gl.TEXTURE_2D;
2218             colorFmt = gl.RGBA8;
2219             depth = depthStencilFormats[fmtNdx].depth;
2220             stencil = depthStencilFormats[fmtNdx].stencil;
2221
2222             if (!depth)
2223                 continue; // Not verified.
2224
2225             // Depth and stencil: both rbo and textures
2226             for (var typeNdx = 0; typeNdx < objectTypes.length; typeNdx++) {
2227                 config = new es3fFboRenderTest.FboConfig(
2228                     gl.COLOR_BUFFER_BIT |
2229                     (depth ? gl.DEPTH_BUFFER_BIT : 0) |
2230                     (stencil ? gl.STENCIL_BUFFER_BIT : 0),
2231                     colorType, colorFmt, objectTypes[typeNdx],
2232                     depthStencilFormats[fmtNdx].format
2233                 );
2234
2235                 sharedDepthStencilGroup.addChild(
2236                     new es3fFboRenderTest.SharedDepthStencilTest(config)
2237                 );
2238             }
2239         }
2240
2241         // .resize
2242         /** @type {Array<tcuTestCase.DeqpTest>} */ var resizeGroup = [];
2243         var numResizeGroups = 4;
2244         for (var ii = 0; ii < numResizeGroups; ++ii) {
2245             resizeGroup[ii] = new tcuTestCase.DeqpTest('resize', 'FBO resize tests');
2246             this.addChild(resizeGroup[ii]);
2247         }
2248
2249         for (var colorFmtNdx = 0; colorFmtNdx < colorFormats.length; colorFmtNdx++) {
2250
2251             var colorFormat = colorFormats[colorFmtNdx].format;
2252
2253             // Color-only.
2254             for (var typeNdx = 0; typeNdx < objectTypes.length; typeNdx++) {
2255                 config = new es3fFboRenderTest.FboConfig(
2256                     gl.COLOR_BUFFER_BIT, objectTypes[typeNdx],
2257                     colorFormat, gl.NONE, gl.NONE
2258                 );
2259                 resizeGroup[colorFmtNdx % numResizeGroups].addChild(new es3fFboRenderTest.ResizeTest(config));
2260             }
2261
2262             // For selected color formats tests depth & stencil variants.
2263             if (colorFormat == gl.RGBA8 || colorFormat == gl.RGBA16F) {
2264                 for (var depthStencilFmtNdx = 0; depthStencilFmtNdx < depthStencilFormats.length; depthStencilFmtNdx++) {
2265
2266                     colorType = gl.TEXTURE_2D;
2267                     depth = depthStencilFormats[depthStencilFmtNdx].depth;
2268                     stencil = depthStencilFormats[depthStencilFmtNdx].stencil;
2269
2270                     // Depth and stencil: both rbo and textures
2271                     for (var typeNdx = 0; typeNdx < objectTypes.length; typeNdx++) {
2272
2273                         if (!depth && objectTypes[typeNdx] != gl.RENDERBUFFER)
2274                             continue; // Not supported.
2275
2276                         config = new es3fFboRenderTest.FboConfig(
2277                             gl.COLOR_BUFFER_BIT |
2278                             (depth ? gl.DEPTH_BUFFER_BIT : 0) |
2279                             (stencil ? gl.STENCIL_BUFFER_BIT : 0),
2280                             colorType, colorFormat, objectTypes[typeNdx],
2281                             depthStencilFormats[depthStencilFmtNdx].format
2282                         );
2283
2284                         resizeGroup[colorFmtNdx % numResizeGroups].addChild(
2285                             new es3fFboRenderTest.ResizeTest(config)
2286                         );
2287                     }
2288                 }
2289             }
2290         }
2291
2292         // .recreate_color
2293         /** @type {Array<tcuTestCase.DeqpTest>} */ var recreateColorGroup = [];
2294         var numRecreateColorGroups = 7;
2295         for (var ii = 0; ii < numRecreateColorGroups; ++ii) {
2296             recreateColorGroup[ii] = new tcuTestCase.DeqpTest('recreate_color', 'Recreate colorbuffer tests');
2297             this.addChild(recreateColorGroup[ii]);
2298         }
2299
2300         for (var colorFmtNdx = 0; colorFmtNdx < colorFormats.length; colorFmtNdx++) {
2301
2302             colorFormat = colorFormats[colorFmtNdx].format;
2303             depthStencilFormat = gl.DEPTH24_STENCIL8;
2304             depthStencilType = gl.RENDERBUFFER;
2305
2306             // Color-only.
2307             for (var typeNdx = 0; typeNdx < objectTypes.length; typeNdx++) {
2308                 config = new es3fFboRenderTest.FboConfig(
2309                     gl.COLOR_BUFFER_BIT |
2310                     gl.DEPTH_BUFFER_BIT |
2311                     gl.STENCIL_BUFFER_BIT,
2312                     objectTypes[typeNdx], colorFormat,
2313                     depthStencilType, depthStencilFormat
2314                 );
2315
2316                 recreateColorGroup[colorFmtNdx % numRecreateColorGroups].addChild(
2317                     new es3fFboRenderTest.RecreateBuffersTest(
2318                         config, gl.COLOR_BUFFER_BIT, true /* rebind */
2319                     )
2320                 );
2321             }
2322         }
2323
2324         // .recreate_depth_stencil
2325         /** @type {tcuTestCase.DeqpTest} */
2326         var recreateDepthStencilGroup = new tcuTestCase.DeqpTest(
2327             'recreate_depth_stencil', 'Recreate depth and stencil buffers'
2328         );
2329
2330         this.addChild(recreateDepthStencilGroup);
2331
2332         for (var fmtNdx = 0; fmtNdx < depthStencilFormats.length; fmtNdx++) {
2333             colorType = gl.TEXTURE_2D;
2334             colorFmt = gl.RGBA8;
2335             depth = depthStencilFormats[fmtNdx].depth;
2336             stencil = depthStencilFormats[fmtNdx].stencil;
2337
2338             // Depth and stencil: both rbo and textures
2339             for (var typeNdx = 0; typeNdx < objectTypes.length; typeNdx++) {
2340                 if (!depth && objectTypes[typeNdx] != gl.RENDERBUFFER)
2341                     continue;
2342
2343                 config = new es3fFboRenderTest.FboConfig(
2344                     gl.COLOR_BUFFER_BIT |
2345                     (depth ? gl.DEPTH_BUFFER_BIT : 0) |
2346                     (stencil ? gl.STENCIL_BUFFER_BIT : 0),
2347                     colorType, colorFmt, objectTypes[typeNdx],
2348                     depthStencilFormats[fmtNdx].format
2349                 );
2350
2351                 recreateDepthStencilGroup.addChild(
2352                     new es3fFboRenderTest.RecreateBuffersTest(
2353                         config,
2354                         (depth ? gl.DEPTH_BUFFER_BIT : 0) |
2355                         (stencil ? gl.STENCIL_BUFFER_BIT : 0),
2356                         true /* rebind */
2357                     )
2358                 );
2359             }
2360         }
2361     };
2362
2363     /**
2364      * Create and execute the test cases
2365      * @param {WebGL2RenderingContext} context
2366      */
2367     es3fFboRenderTest.run = function(context, range) {
2368         gl = context;
2369         //Set up Test Root parameters
2370         var state = tcuTestCase.runner;
2371
2372         state.setRoot(new es3fFboRenderTest.FboRenderTestGroup());
2373
2374         //Set up name and description of this test series.
2375         setCurrentTestName(state.testCases.fullName());
2376         description(state.testCases.getDescription());
2377
2378         try {
2379             if (range)
2380                 state.setRange(range);
2381             //Run test cases
2382             tcuTestCase.runTestCases();
2383         }
2384         catch (err) {
2385             testFailedOptions('Failed to run tests', false);
2386             tcuTestCase.runner.terminate();
2387         }
2388     };
2389 });