dom/canvas/test/webgl-conf/checkout/deqp/functional/gles3/es3fTextureShadowTests.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 'use strict';
  21 goog.provide('functional.gles3.es3fTextureShadowTests');
  22 goog.require('framework.common.tcuImageCompare');
  23 goog.require('framework.common.tcuLogImage');
  24 goog.require('framework.common.tcuPixelFormat');
  25 goog.require('framework.common.tcuRGBA');
  26 goog.require('framework.common.tcuSurface');
  27 goog.require('framework.common.tcuTestCase');
  28 goog.require('framework.common.tcuTexCompareVerifier');
  29 goog.require('framework.common.tcuTexLookupVerifier');
  30 goog.require('framework.common.tcuTexture');
  31 goog.require('framework.common.tcuTextureUtil');
  32 goog.require('framework.delibs.debase.deMath');
  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.gluTexture');
  37 goog.require('framework.opengl.gluTextureUtil');
  38 goog.require('framework.referencerenderer.rrMultisamplePixelBufferAccess');
  39 goog.require('modules.shared.glsTextureTestUtil');
  40
  41 goog.scope(function() {
  42
  43 var es3fTextureShadowTests = functional.gles3.es3fTextureShadowTests;
  44 var tcuTestCase = framework.common.tcuTestCase;
  45 var glsTextureTestUtil = modules.shared.glsTextureTestUtil;
  46 var gluShaderUtil = framework.opengl.gluShaderUtil;
  47 var gluTexture = framework.opengl.gluTexture;
  48 var gluTextureUtil = framework.opengl.gluTextureUtil;
  49 var tcuTexture = framework.common.tcuTexture;
  50 var tcuImageCompare = framework.common.tcuImageCompare;
  51 var tcuLogImage = framework.common.tcuLogImage;
  52 var tcuTextureUtil = framework.common.tcuTextureUtil;
  53 var tcuRGBA = framework.common.tcuRGBA;
  54 var deMath = framework.delibs.debase.deMath;
  55 var tcuPixelFormat = framework.common.tcuPixelFormat;
  56 var tcuSurface = framework.common.tcuSurface;
  57 var tcuTexCompareVerifier = framework.common.tcuTexCompareVerifier;
  58 var tcuTexLookupVerifier = framework.common.tcuTexLookupVerifier;
  59 var rrMultisamplePixelBufferAccess = framework.referencerenderer.rrMultisamplePixelBufferAccess;
  60 var deString = framework.delibs.debase.deString;
  61 var deUtil = framework.delibs.debase.deUtil;
  62
  63     es3fTextureShadowTests.version = '300 es';
  64
  65     /** @const */ var VIEWPORT_WIDTH = 64;
  66     /** @const */ var VIEWPORT_HEIGHT = 64;
  67     /** @const */ var MIN_VIEWPORT_WIDTH = 64;
  68     /** @const */ var MIN_VIEWPORT_HEIGHT = 64;
  69
  70     var DE_ASSERT = function(x) {
  71         if (!x)
  72             throw new Error('Assert failed');
  73     };
  74
  75     /**
  76      * @param {tcuTexture.TextureFormat} format
  77      * @return {boolean}
  78      */
  79     es3fTextureShadowTests.isFloatingPointDepthFormat = function(format) {
  80         // Only two depth and depth-stencil formats are floating point
  81         return (format.order == tcuTexture.ChannelOrder.D && format.type == tcuTexture.ChannelType.FLOAT) || (format.order == tcuTexture.ChannelOrder.DS && format.type == tcuTexture.ChannelType.FLOAT_UNSIGNED_INT_24_8_REV);
  82     };
  83
  84     /**
  85      * @param {tcuTexture.PixelBufferAccess} access
  86      */
  87     es3fTextureShadowTests.clampFloatingPointTexture = function(access) {
  88         DE_ASSERT(es3fTextureShadowTests.isFloatingPointDepthFormat(access.getFormat()));
  89         for (var z = 0; z < access.getDepth(); ++z)
  90             for (var y = 0; y < access.getHeight(); ++y)
  91                 for (var x = 0; x < access.getWidth(); ++x)
  92                     access.setPixDepth(deMath.clamp(access.getPixDepth(x, y, z), 0.0, 1.0), x, y, z);
  93     };
  94
  95     /**
  96      * @param {tcuTexture.Texture2D|tcuTexture.Texture2DArray} target
  97      */
  98     es3fTextureShadowTests.clampFloatingPointTexture2D = function(target) {
  99         for (var level = 0; level < target.getNumLevels(); ++level)
 100             if (!target.isLevelEmpty(level))
 101                 es3fTextureShadowTests.clampFloatingPointTexture(target.getLevel(level));
 102     };
 103
 104     /**
 105      * @param {tcuTexture.TextureCube} target
 106      */
 107     es3fTextureShadowTests.clampFloatingPointTextureCube = function(target) {
 108         for (var level = 0; level < target.getNumLevels(); ++level)
 109             for (var face = tcuTexture.CubeFace.CUBEFACE_NEGATIVE_X; face < Object.keys(tcuTexture.CubeFace).length; face++)
 110                 es3fTextureShadowTests.clampFloatingPointTexture(target.getLevelFace(level, face));
 111     };
 112
 113     /**
 114      * @param {?} textureType
 115      * @param {tcuTexture.ConstPixelBufferAccess} result
 116      * @param {tcuTexture.Texture2D|tcuTexture.Texture2DArray|tcuTexture.TextureCube} src
 117      * @param {Array<number>} texCoord
 118      * @param {glsTextureTestUtil.ReferenceParams} sampleParams
 119      * @param {tcuTexCompareVerifier.TexComparePrecision} comparePrec
 120      * @param {tcuTexLookupVerifier.LodPrecision} lodPrecision
 121      * @param {tcuPixelFormat.PixelFormat} pixelFormat
 122      */
 123     es3fTextureShadowTests.verifyTexCompareResult = function(textureType, result, src, texCoord, sampleParams, comparePrec, lodPrecision, pixelFormat) {
 124         var reference = new tcuSurface.Surface(result.getWidth(), result.getHeight());
 125         var errorMask = new tcuSurface.Surface(result.getWidth(), result.getHeight());
 126         var nonShadowThreshold = deMath.swizzle(tcuTexLookupVerifier.computeFixedPointThreshold(deMath.subtract(glsTextureTestUtil.getBitsVec(pixelFormat), [1, 1, 1, 1])), [1, 2, 3]);
 127         var numFailedPixels;
 128
 129         if (es3fTextureShadowTests.isFloatingPointDepthFormat(src.getFormat())) {
 130             var clampedSource = /*deUtil.clone(*/src/*)*/;
 131
 132             if (textureType == tcuTexture.Texture2D) {
 133                 es3fTextureShadowTests.clampFloatingPointTexture2D(/** @type {tcuTexture.Texture2D} */(clampedSource));
 134                 glsTextureTestUtil.sampleTexture2D(new glsTextureTestUtil.SurfaceAccess(reference, pixelFormat), /** @type {tcuTexture.Texture2DView} */ (clampedSource.getView()), texCoord, sampleParams);
 135                 // sample clamped values
 136                 numFailedPixels = glsTextureTestUtil.computeTextureCompareDiff2D(result, reference.getAccess(), errorMask.getAccess(), /** @type {tcuTexture.Texture2DView} */ (clampedSource.getView()), texCoord, sampleParams, comparePrec, lodPrecision, nonShadowThreshold);
 137             } else if (textureType == tcuTexture.Texture2DArray) {
 138                 es3fTextureShadowTests.clampFloatingPointTexture2D(/** @type {tcuTexture.Texture2DArray} */(clampedSource));
 139                 glsTextureTestUtil.sampleTexture2DArray(new glsTextureTestUtil.SurfaceAccess(reference, pixelFormat), /** @type {tcuTexture.Texture2DArrayView} */ (clampedSource.getView()), texCoord, sampleParams);
 140                 // sample clamped values
 141                 numFailedPixels = glsTextureTestUtil.computeTextureCompareDiff2DArray(result, reference.getAccess(), errorMask.getAccess(), /** @type {tcuTexture.Texture2DArrayView} */ (clampedSource.getView()), texCoord, sampleParams, comparePrec, lodPrecision, nonShadowThreshold);
 142             } else if (textureType == tcuTexture.TextureCube) {
 143                 es3fTextureShadowTests.clampFloatingPointTextureCube(/** @type {tcuTexture.TextureCube} */(clampedSource));
 144                 glsTextureTestUtil.sampleTextureCube(new glsTextureTestUtil.SurfaceAccess(reference, pixelFormat), /** @type {tcuTexture.TextureCubeView} */ (clampedSource.getView()), texCoord, sampleParams);
 145                 // sample clamped values
 146                 numFailedPixels = glsTextureTestUtil.computeTextureCompareDiffCube(result, reference.getAccess(), errorMask.getAccess(), /** @type {tcuTexture.TextureCubeView} */ (clampedSource.getView()), texCoord, sampleParams, comparePrec, lodPrecision, nonShadowThreshold);
 147             } else
 148                 throw new Error('Invalid texture type');
 149
 150         } else {
 151             if (textureType == tcuTexture.Texture2D) {
 152                 glsTextureTestUtil.sampleTexture2D(new glsTextureTestUtil.SurfaceAccess(reference, pixelFormat), /** @type {tcuTexture.Texture2DView} */ (src.getView()), texCoord, sampleParams);
 153                 // sample raw values (they are guaranteed to be in [0, 1] range as the format cannot represent any other values)
 154                 numFailedPixels = glsTextureTestUtil.computeTextureCompareDiff2D(result, reference.getAccess(), errorMask.getAccess(), /** @type {tcuTexture.Texture2DView} */ (src.getView()), texCoord, sampleParams, comparePrec, lodPrecision, nonShadowThreshold);
 155             } else if (textureType == tcuTexture.Texture2DArray) {
 156                 glsTextureTestUtil.sampleTexture2DArray(new glsTextureTestUtil.SurfaceAccess(reference, pixelFormat), /** @type {tcuTexture.Texture2DArrayView} */ (src.getView()), texCoord, sampleParams);
 157                 // sample raw values (they are guaranteed to be in [0, 1] range as the format cannot represent any other values)
 158                 numFailedPixels = glsTextureTestUtil.computeTextureCompareDiff2DArray(result, reference.getAccess(), errorMask.getAccess(), /** @type {tcuTexture.Texture2DArrayView} */ (src.getView()), texCoord, sampleParams, comparePrec, lodPrecision, nonShadowThreshold);
 159             } else if (textureType == tcuTexture.TextureCube) {
 160                 glsTextureTestUtil.sampleTextureCube(new glsTextureTestUtil.SurfaceAccess(reference, pixelFormat), /** @type {tcuTexture.TextureCubeView} */ (src.getView()), texCoord, sampleParams);
 161                 // sample raw values (they are guaranteed to be in [0, 1] range as the format cannot represent any other values)
 162                 numFailedPixels = glsTextureTestUtil.computeTextureCompareDiffCube(result, reference.getAccess(), errorMask.getAccess(), /** @type {tcuTexture.TextureCubeView} */ (src.getView()), texCoord, sampleParams, comparePrec, lodPrecision, nonShadowThreshold);
 163             } else
 164                 throw new Error('Invalid texture type');
 165         }
 166
 167         if (numFailedPixels > 0)
 168             bufferedLogToConsole('ERROR: Result verification failed, got ' + numFailedPixels + ' invalid pixels!');
 169
 170         if (numFailedPixels > 0)
 171             tcuImageCompare.displayImages(result, reference.getAccess(), errorMask.getAccess());
 172         else
 173             tcuLogImage.logImageWithInfo(result, 'Result');
 174
 175         return numFailedPixels == 0;
 176
 177     };
 178
 179     /**
 180      * @constructor
 181      * @param {string} name
 182      * @param {number} format
 183      * @struct
 184      */
 185     es3fTextureShadowTests.Format = function(name, format) {
 186         /** @type {string} */ this.name = name;
 187         /** @type {number} */ this.format = format;
 188     };
 189
 190     /**
 191      * @constructor
 192      * @param {string} name
 193      * @param {number} minFilter
 194      * @param {number} magFilter
 195      * @struct
 196      */
 197     es3fTextureShadowTests.Filter = function(name, minFilter, magFilter) {
 198         /** @type {string} */ this.name = name;
 199         /** @type {number} */ this.minFilter = minFilter;
 200         /** @type {number} */ this.magFilter = magFilter;
 201     };
 202
 203     /**
 204      * @constructor
 205      * @param {string} name
 206      * @param {number} func
 207      * @struct
 208      */
 209     es3fTextureShadowTests.CompareFunc = function(name, func) {
 210         /** @type {string} */ this.name = name;
 211         /** @type {number} */ this.func = func;
 212     };
 213
 214     /**
 215      * @constructor
 216      * @param {number} texNdx
 217      * @param {number} ref
 218      * @param {number} lodX
 219      * @param {number} lodY
 220      * @param {number} oX
 221      * @param {number} oY
 222      * @struct
 223      */
 224     es3fTextureShadowTests.TestCase = function(texNdx, ref, lodX, lodY, oX, oY) {
 225         /** @type {number} */ this.texNdx = texNdx;
 226         /** @type {number} */ this.ref = ref;
 227         /** @type {number} */ this.lodX = lodX;
 228         /** @type {number} */ this.lodY = lodY;
 229         /** @type {number} */ this.oX = oX
 230         /** @type {number} */ this.oY = oY;
 231     };
 232
 233     /**
 234      * @constructor
 235      * @param {?gluTexture.Texture2D|?gluTexture.TextureCube|?gluTexture.Texture2DArray} tex
 236      * @param {number} ref
 237      * @param {Array<number>} minCoord
 238      * @param {Array<number>} maxCoord
 239      * @struct
 240      */
 241     es3fTextureShadowTests.FilterCase = function(tex, ref, minCoord, maxCoord) {
 242         /** @type {?gluTexture.Texture2D|?gluTexture.TextureCube|?gluTexture.Texture2DArray} */ this.texture = tex;
 243         /** @type {Array<number>} */ this.minCoord = minCoord;
 244         /** @type {Array<number>} */ this.maxCoord = maxCoord;
 245         /** @type {number} */ this.ref = ref;
 246     };
 247
 248     /**
 249      * @constructor
 250      * @param {string} name
 251      * @param {string} desc
 252      * @param {number} minFilter
 253      * @param {number} magFilter
 254      * @param {number} wrapS
 255      * @param {number} wrapT
 256      * @param {number} format
 257      * @param {number} width
 258      * @param {number} height
 259      * @param {number} compareFunc
 260      * @extends {tcuTestCase.DeqpTest}
 261      */
 262     es3fTextureShadowTests.Texture2DShadowCase = function(name, desc, minFilter, magFilter, wrapS, wrapT, format, width, height, compareFunc) {
 263         tcuTestCase.DeqpTest.call(this, name, desc);
 264         this.m_minFilter = minFilter;
 265         this.m_magFilter = magFilter;
 266         this.m_wrapS = wrapS;
 267         this.m_wrapT = wrapT;
 268         this.m_format = format;
 269         this.m_width = width;
 270         this.m_height = height;
 271         this.m_compareFunc = compareFunc;
 272         this.m_renderer = new glsTextureTestUtil.TextureRenderer(es3fTextureShadowTests.version, gluShaderUtil.precision.PRECISION_HIGHP);
 273         this.m_caseNdx = 0;
 274         this.m_cases = [];
 275     };
 276
 277     es3fTextureShadowTests.Texture2DShadowCase.prototype = Object.create(tcuTestCase.DeqpTest.prototype);
 278     es3fTextureShadowTests.Texture2DShadowCase.prototype.constructor = es3fTextureShadowTests.Texture2DShadowCase;
 279
 280     es3fTextureShadowTests.Texture2DShadowCase.prototype.init = function() {
 281
 282         // Create 2 textures.
 283         this.m_textures = [];
 284         this.m_textures[0] = gluTexture.texture2DFromInternalFormat(gl, this.m_format, this.m_width, this.m_height);
 285         this.m_textures[1] = gluTexture.texture2DFromInternalFormat(gl, this.m_format, this.m_width, this.m_height);
 286
 287         var numLevels = this.m_textures[0].getRefTexture().getNumLevels();
 288
 289         for (var levelNdx = 0; levelNdx < numLevels; levelNdx++) {
 290             this.m_textures[0].getRefTexture().allocLevel(levelNdx);
 291             tcuTextureUtil.fillWithComponentGradients(this.m_textures[0].getRefTexture().getLevel(levelNdx), [-0.5, -0.5, -0.5, 2.0], [1, 1, 1, 0]);
 292         }
 293
 294         for (levelNdx = 0; levelNdx < numLevels; levelNdx++) {
 295             var step = 0x00ffffff / numLevels;
 296             var rgb = step * levelNdx;
 297             var colorA = 0xff000000 | rgb;
 298             var colorB = 0xff000000 | ~rgb;
 299
 300             this.m_textures[1].getRefTexture().allocLevel(levelNdx);
 301             tcuTextureUtil.fillWithGrid(this.m_textures[1].getRefTexture().getLevel(levelNdx), 4, tcuRGBA.newRGBAFromValue(colorA).toVec(), tcuRGBA.newRGBAFromValue(colorB).toVec());
 302         }
 303
 304         for (var i = 0; i < this.m_textures.length; i++)
 305             this.m_textures[i].upload();
 306
 307         var refInRangeUpper = (this.m_compareFunc == gl.EQUAL || this.m_compareFunc == gl.NOTEQUAL) ? 1.0 : 0.5;
 308         var refInRangeLower = (this.m_compareFunc == gl.EQUAL || this.m_compareFunc == gl.NOTEQUAL) ? 0.0 : 0.5;
 309
 310         var refOutOfBoundsUpper = 1.1;
 311         var refOutOfBoundsLower = -0.1;
 312
 313         numLevels = this.m_textures[0].getRefTexture().getNumLevels();
 314
 315         var cases = [];
 316         cases.push(new es3fTextureShadowTests.TestCase(0, refInRangeUpper, 1.6, 2.9, -1.0, -2.7));
 317         cases.push(new es3fTextureShadowTests.TestCase(0, refInRangeLower, -2.0, -1.35, -0.2, 0.7));
 318         cases.push(new es3fTextureShadowTests.TestCase(1, refInRangeUpper, 0.14, 0.275, -1.5, -1.1));
 319         cases.push(new es3fTextureShadowTests.TestCase(1, refInRangeLower, -0.92, -2.64, 0.4, -0.1));
 320         cases.push(new es3fTextureShadowTests.TestCase(1, refOutOfBoundsUpper, -0.39, -0.52, 0.65, 0.87));
 321         cases.push(new es3fTextureShadowTests.TestCase(1, refOutOfBoundsLower, -1.55, 0.65, 0.35, 0.91));
 322
 323         var viewportW = Math.min(VIEWPORT_WIDTH, gl.canvas.width);
 324         var viewportH = Math.min(VIEWPORT_HEIGHT, gl.canvas.height);
 325
 326         for (var caseNdx = 0; caseNdx < cases.length; caseNdx++) {
 327             var texNdx = deMath.clamp(cases[caseNdx].texNdx, 0, this.m_textures.length - 1);
 328             var ref = cases[caseNdx].ref;
 329             var lodX = cases[caseNdx].lodX;
 330             var lodY = cases[caseNdx].lodY;
 331             var oX = cases[caseNdx].oX;
 332             var oY = cases[caseNdx].oY;
 333             var sX = Math.exp(lodX * Math.log(2)) * viewportW / this.m_textures[texNdx].getRefTexture().getWidth();
 334             var sY = Math.exp(lodY * Math.log(2)) * viewportH / this.m_textures[texNdx].getRefTexture().getHeight();
 335
 336             this.m_cases.push(new es3fTextureShadowTests.FilterCase(this.m_textures[texNdx], ref, [oX, oY], [oX + sX, oY + sY]));
 337         }
 338
 339         this.m_caseNdx = 0;
 340     };
 341
 342     es3fTextureShadowTests.Texture2DShadowCase.prototype.iterate = function() {
 343
 344         var viewport = new glsTextureTestUtil.RandomViewport(document.getElementById('canvas'), VIEWPORT_WIDTH, VIEWPORT_HEIGHT);
 345         var curCase = this.m_cases[this.m_caseNdx];
 346         var sampleParams = new glsTextureTestUtil.ReferenceParams(glsTextureTestUtil.textureType.TEXTURETYPE_2D);
 347         var rendered = new tcuSurface.Surface(viewport.width, viewport.height);
 348         var texCoord = [];
 349
 350         if (viewport.width < MIN_VIEWPORT_WIDTH || viewport.height < MIN_VIEWPORT_HEIGHT)
 351             throw new Error('Too small render target');
 352
 353         // Setup params for reference.
 354         sampleParams.sampler = gluTextureUtil.mapGLSampler(this.m_wrapS, this.m_wrapT, gl.CLAMP_TO_EDGE, this.m_minFilter, this.m_magFilter);
 355         sampleParams.sampler.compare = gluTextureUtil.mapGLCompareFunc(this.m_compareFunc);
 356         sampleParams.samplerType = glsTextureTestUtil.samplerType.SAMPLERTYPE_SHADOW;
 357         sampleParams.lodMode = glsTextureTestUtil.lodMode.EXACT;
 358         sampleParams.ref = curCase.ref;
 359
 360         bufferedLogToConsole('Compare reference value = ' + sampleParams.ref);
 361
 362         // Compute texture coordinates.
 363         bufferedLogToConsole('Texture coordinates: ' + curCase.minCoord + ' -> ' + curCase.maxCoord);
 364
 365         texCoord = glsTextureTestUtil.computeQuadTexCoord2D(curCase.minCoord, curCase.maxCoord);
 366
 367         gl.bindTexture(gl.TEXTURE_2D, curCase.texture.getGLTexture());
 368         gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, this.m_minFilter);
 369         gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, this.m_magFilter);
 370         gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, this.m_wrapS);
 371         gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, this.m_wrapT);
 372         gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_COMPARE_MODE, gl.COMPARE_REF_TO_TEXTURE);
 373         gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_COMPARE_FUNC, this.m_compareFunc);
 374
 375         gl.viewport(viewport.x, viewport.y, viewport.width, viewport.height);
 376         this.m_renderer.renderQuad(0, texCoord, sampleParams);
 377         rendered.readViewport(gl, viewport);
 378
 379
 380         var pixelFormat = new tcuPixelFormat.PixelFormat(8, 8, 8, 8);
 381         var lodPrecision = new tcuTexLookupVerifier.LodPrecision(18, 6);
 382         var texComparePrecision = new tcuTexCompareVerifier.TexComparePrecision([20, 20, 0], [7, 7, 0], 5, 16, pixelFormat.redBits - 1);
 383
 384         var isHighQuality = es3fTextureShadowTests.verifyTexCompareResult(tcuTexture.Texture2D, rendered.getAccess(), curCase.texture.getRefTexture(),
 385                                                       texCoord, sampleParams, texComparePrecision, lodPrecision, pixelFormat);
 386
 387         if (!isHighQuality) {
 388             bufferedLogToConsole('Warning: Verification assuming high-quality PCF filtering failed.');
 389
 390             lodPrecision.lodBits = 4;
 391             texComparePrecision.uvwBits = [4, 4, 0];
 392             texComparePrecision.pcfBits = 0;
 393
 394             var isOk = es3fTextureShadowTests.verifyTexCompareResult(tcuTexture.Texture2D, rendered.getAccess(), curCase.texture.getRefTexture(),
 395                                                      texCoord, sampleParams, texComparePrecision, lodPrecision, pixelFormat);
 396
 397             if (!isOk) {
 398                 bufferedLogToConsole('ERROR: Verification against low precision requirements failed, failing test case.');
 399                 testFailedOptions('Image verification failed', false);
 400             } else
 401                 testPassedOptions('Low-quality result', true);
 402         } else
 403             testPassedOptions('High-quality result', true);
 404
 405         this.m_caseNdx += 1;
 406         return this.m_caseNdx < this.m_cases.length ? tcuTestCase.IterateResult.CONTINUE : tcuTestCase.IterateResult.STOP;
 407     };
 408
 409     /**
 410      * @constructor
 411      * @param {string} name
 412      * @param {string} desc
 413      * @param {number} minFilter
 414      * @param {number} magFilter
 415      * @param {number} wrapS
 416      * @param {number} wrapT
 417      * @param {number} format
 418      * @param {number} size
 419      * @param {number} compareFunc
 420      * @extends {tcuTestCase.DeqpTest}
 421      */
 422     es3fTextureShadowTests.TextureCubeShadowCase = function(name, desc, minFilter, magFilter, wrapS, wrapT, format, size, compareFunc) {
 423         tcuTestCase.DeqpTest.call(this, name, desc);
 424         this.m_minFilter = minFilter;
 425         this.m_magFilter = magFilter;
 426         this.m_wrapS = wrapS;
 427         this.m_wrapT = wrapT;
 428         this.m_format = format;
 429         this.m_size = size;
 430         this.m_compareFunc = compareFunc;
 431         this.m_renderer = new glsTextureTestUtil.TextureRenderer(es3fTextureShadowTests.version, gluShaderUtil.precision.PRECISION_HIGHP);
 432         this.m_caseNdx = 0;
 433         this.m_cases = [];
 434     };
 435
 436     es3fTextureShadowTests.TextureCubeShadowCase.prototype = Object.create(tcuTestCase.DeqpTest.prototype);
 437     es3fTextureShadowTests.TextureCubeShadowCase.prototype.constructor = es3fTextureShadowTests.TextureCubeShadowCase;
 438
 439     es3fTextureShadowTests.TextureCubeShadowCase.prototype.init = function() {
 440         DE_ASSERT(!this.m_gradientTex && !this.m_gridTex);
 441
 442         var numLevels = Math.floor(Math.log2(this.m_size)) + 1;
 443         /** @type {tcuTexture.TextureFormat} */ var texFmt = gluTextureUtil.mapGLInternalFormat(this.m_format);
 444         /** @type {tcuTextureUtil.TextureFormatInfo} */ var fmtInfo = tcuTextureUtil.getTextureFormatInfo(texFmt);
 445         /** @type {Array<number>} */ var cBias = fmtInfo.valueMin;
 446         /** @type {Array<number>} */ var cScale = deMath.subtract(fmtInfo.valueMax, fmtInfo.valueMin);
 447
 448         // Create textures.
 449         this.m_gradientTex = gluTexture.cubeFromInternalFormat(gl, this.m_format, this.m_size);
 450         this.m_gridTex = gluTexture.cubeFromInternalFormat(gl, this.m_format, this.m_size);
 451
 452         // Fill first with gradient texture.
 453         var gradients = [[[-1.0, -1.0, -1.0, 2.0], [1.0, 1.0, 1.0, 0.0]], // negative x
 454             [[0.0, -1.0, -1.0, 2.0], [1.0, 1.0, 1.0, 0.0]], // positive x
 455             [[-1.0, 0.0, -1.0, 2.0], [1.0, 1.0, 1.0, 0.0]], // negative y
 456             [[-1.0, -1.0, 0.0, 2.0], [1.0, 1.0, 1.0, 0.0]], // positive y
 457             [[-1.0, -1.0, -1.0, 0.0], [1.0, 1.0, 1.0, 1.0]], // negative z
 458             [[0.0, 0.0, 0.0, 2.0], [1.0, 1.0, 1.0, 0.0]]]; // positive z
 459
 460         for (var face in tcuTexture.CubeFace) {
 461             for (var levelNdx = 0; levelNdx < numLevels; levelNdx++) {
 462                 this.m_gradientTex.getRefTexture().allocLevel(tcuTexture.CubeFace[face], levelNdx);
 463                 tcuTextureUtil.fillWithComponentGradients(this.m_gradientTex.getRefTexture().getLevelFace(levelNdx, tcuTexture.CubeFace[face]), deMath.add(deMath.multiply(gradients[tcuTexture.CubeFace[face]][0], cScale), cBias), deMath.add(deMath.multiply(gradients[tcuTexture.CubeFace[face]][1], cScale), cBias));
 464             }
 465         }
 466
 467         // Fill second with grid texture.
 468         for (var face in tcuTexture.CubeFace) {
 469             for (var levelNdx = 0; levelNdx < numLevels; levelNdx++) {
 470                 var step = 0x00ffffff / (numLevels * Object.keys(tcuTexture.CubeFace).length);
 471                 var rgb = step * levelNdx * face;
 472                 var colorA = 0xff000000 | rgb;
 473                 var colorB = 0xff000000 | ~rgb;
 474
 475                 this.m_gridTex.getRefTexture().allocLevel(tcuTexture.CubeFace[face], levelNdx);
 476                 tcuTextureUtil.fillWithGrid(this.m_gridTex.getRefTexture().getLevelFace(levelNdx, tcuTexture.CubeFace[face]), 4, deMath.add(deMath.multiply(tcuRGBA.newRGBAFromValue(colorA).toVec(), cScale), cBias), deMath.add(deMath.multiply(tcuRGBA.newRGBAFromValue(colorB).toVec(), cScale), cBias));
 477             }
 478         }
 479
 480         // Upload.
 481         this.m_gradientTex.upload();
 482         this.m_gridTex.upload();
 483
 484         var refInRangeUpper = (this.m_compareFunc == gl.EQUAL || this.m_compareFunc == gl.NOTEQUAL) ? 1.0 : 0.5;
 485         var refInRangeLower = (this.m_compareFunc == gl.EQUAL || this.m_compareFunc == gl.NOTEQUAL) ? 0.0 : 0.5;
 486         var refOutOfBoundsUpper = 1.1;
 487         var refOutOfBoundsLower = -0.1;
 488         var singleSample = new rrMultisamplePixelBufferAccess.MultisamplePixelBufferAccess().getNumSamples() == 0;
 489         //var singleSample = this.m_context.getRenderTarget().getNumSamples() == 0;
 490
 491         if (singleSample)
 492             this.m_cases.push(new es3fTextureShadowTests.FilterCase(this.m_gradientTex, refInRangeUpper, [-1.25, -1.2], [1.2, 1.25])); // minification
 493         else
 494             this.m_cases.push(new es3fTextureShadowTests.FilterCase(this.m_gradientTex, refInRangeUpper, [-1.19, -1.3], [1.1, 1.35])); // minification - w/ tuned coordinates to avoid hitting triangle edges
 495
 496         this.m_cases.push(new es3fTextureShadowTests.FilterCase(this.m_gradientTex, refInRangeLower, [0.8, 0.8], [1.25, 1.20])); // magnification
 497         this.m_cases.push(new es3fTextureShadowTests.FilterCase(this.m_gridTex, refInRangeUpper, [-1.19, -1.3], [1.1, 1.35])); // minification
 498         this.m_cases.push(new es3fTextureShadowTests.FilterCase(this.m_gridTex, refInRangeLower, [-1.2, -1.1], [-0.8, -0.8])); // magnification
 499         this.m_cases.push(new es3fTextureShadowTests.FilterCase(this.m_gridTex, refOutOfBoundsUpper, [-0.61, -0.1], [0.9, 1.18])); // reference value clamp, upper
 500
 501         if (singleSample)
 502             this.m_cases.push(new es3fTextureShadowTests.FilterCase(this.m_gridTex, refOutOfBoundsLower, [-0.75, 1.0], [0.05, 0.75])); // reference value clamp, lower
 503         else
 504             this.m_cases.push(new es3fTextureShadowTests.FilterCase(this.m_gridTex, refOutOfBoundsLower, [-0.75, 1.0], [0.25, 0.75])); // reference value clamp, lower
 505
 506         this.m_caseNdx = 0;
 507     };
 508
 509     es3fTextureShadowTests.TextureCubeShadowCase.prototype.iterate = function() {
 510         var viewportSize = 28;
 511         var viewport = new glsTextureTestUtil.RandomViewport(document.getElementById('canvas'), viewportSize, viewportSize, deString.deStringHash(this.fullName()) ^ deMath.deMathHash(this.m_caseNdx));
 512         var curCase = this.m_cases[this.m_caseNdx];
 513         var sampleParams = new glsTextureTestUtil.ReferenceParams(glsTextureTestUtil.textureType.TEXTURETYPE_CUBE);
 514
 515         if (viewport.width < viewportSize || viewport.height < viewportSize)
 516             throw new Error('Too small render target');
 517
 518         // Setup texture
 519         gl.bindTexture(gl.TEXTURE_CUBE_MAP, curCase.texture.getGLTexture());
 520         gl.texParameteri(gl.TEXTURE_CUBE_MAP, gl.TEXTURE_MIN_FILTER, this.m_minFilter);
 521         gl.texParameteri(gl.TEXTURE_CUBE_MAP, gl.TEXTURE_MAG_FILTER, this.m_magFilter);
 522         gl.texParameteri(gl.TEXTURE_CUBE_MAP, gl.TEXTURE_WRAP_S, this.m_wrapS);
 523         gl.texParameteri(gl.TEXTURE_CUBE_MAP, gl.TEXTURE_WRAP_T, this.m_wrapT);
 524         gl.texParameteri(gl.TEXTURE_CUBE_MAP, gl.TEXTURE_COMPARE_MODE, gl.COMPARE_REF_TO_TEXTURE);
 525         gl.texParameteri(gl.TEXTURE_CUBE_MAP, gl.TEXTURE_COMPARE_FUNC, this.m_compareFunc);
 526
 527         // Other state
 528         gl.viewport(viewport.x, viewport.y, viewport.width, viewport.height);
 529
 530         // Params for reference computation.
 531         sampleParams.sampler = gluTextureUtil.mapGLSampler(gl.CLAMP_TO_EDGE, gl.CLAMP_TO_EDGE, gl.CLAMP_TO_EDGE, this.m_minFilter, this.m_magFilter);
 532         sampleParams.sampler.seamlessCubeMap = true;
 533         sampleParams.sampler.compare = gluTextureUtil.mapGLCompareFunc(this.m_compareFunc);
 534         sampleParams.samplerType = glsTextureTestUtil.samplerType.SAMPLERTYPE_SHADOW;
 535         sampleParams.lodMode = glsTextureTestUtil.lodMode.EXACT;
 536         sampleParams.ref = curCase.ref;
 537
 538         bufferedLogToConsole(
 539             'Compare reference value = ' + sampleParams.ref + '\n' +
 540             'Coordinates: ' + curCase.minCoord + ' -> ' + curCase.maxCoord);
 541
 542         for (var faceNdx in tcuTexture.CubeFace) {
 543             var face = tcuTexture.CubeFace[faceNdx];
 544             var result = new tcuSurface.Surface(viewport.width, viewport.height);
 545             var texCoord = [];
 546
 547             texCoord = glsTextureTestUtil.computeQuadTexCoordCubeFace(face, curCase.minCoord, curCase.maxCoord);
 548
 549             this.m_renderer.renderQuad(0, texCoord, sampleParams);
 550
 551             result.readViewport(gl, viewport);
 552
 553             var pixelFormat = new tcuPixelFormat.PixelFormat(8, 8, 8, 8);
 554             /** @type {tcuTexLookupVerifier.LodPrecision} */ var lodPrecision = new tcuTexLookupVerifier.LodPrecision(10, 5);
 555             /** @type {tcuTexCompareVerifier.TexComparePrecision} */ var texComparePrecision = new tcuTexCompareVerifier.TexComparePrecision(
 556                 [10, 10, 10],
 557                 [6, 6, 0],
 558                 5,
 559                 16,
 560                 pixelFormat.redBits - 1
 561             );
 562
 563             var isHighQuality = es3fTextureShadowTests.verifyTexCompareResult(tcuTexture.TextureCube, result.getAccess(), curCase.texture.getRefTexture(),
 564                                                      texCoord, sampleParams, texComparePrecision, lodPrecision, pixelFormat);
 565
 566             if (!isHighQuality) {
 567                 bufferedLogToConsole('Warning: Verification assuming high-quality PCF filtering failed.');
 568
 569                 lodPrecision.lodBits = 4;
 570                 texComparePrecision.uvwBits = [4, 4, 0];
 571                 texComparePrecision.pcfBits = 0;
 572
 573                 var isOk = es3fTextureShadowTests.verifyTexCompareResult(tcuTexture.TextureCube, result.getAccess(), curCase.texture.getRefTexture(),
 574                                                                                                   texCoord, sampleParams, texComparePrecision, lodPrecision, pixelFormat);
 575                 if (!isOk) {
 576                     bufferedLogToConsole('ERROR: Verification against low precision requirements failed, failing test case.');
 577                     testFailedOptions('Image verification failed', false);
 578                 } else
 579                     testPassedOptions('Low-quality result', true);
 580             }
 581             else
 582                 testPassedOptions('High-quality result', true);
 583         }
 584
 585         this.m_caseNdx += 1;
 586         return this.m_caseNdx < this.m_cases.length ? tcuTestCase.IterateResult.CONTINUE : tcuTestCase.IterateResult.STOP;
 587     };
 588
 589     /**
 590      * Testure2DArrayShadowCase
 591      * @constructor
 592      * @extends {tcuTestCase.DeqpTest}
 593      * @param {string} name
 594      * @param {string} desc
 595      * @param {number} minFilter
 596      * @param {number} magFilter
 597      * @param {number} wrapS
 598      * @param {number} wrapT
 599      * @param {number} format
 600      * @param {number} width
 601      * @param {number} height
 602      * @param {number} numLayers
 603      * @param {number} compareFunc
 604      */
 605     es3fTextureShadowTests.Texture2DArrayShadowCase = function(name, desc, minFilter, magFilter, wrapS, wrapT, format, width, height, numLayers, compareFunc) {
 606         tcuTestCase.DeqpTest.call(this, name, desc);
 607         /** @type {number} */ this.m_minFilter = minFilter;
 608         /** @type {number} */ this.m_magFilter = magFilter;
 609         /** @type {number} */ this.m_wrapS = wrapS;
 610         /** @type {number} */ this.m_wrapT = wrapT;
 611         /** @type {number} */ this.m_format = format;
 612         /** @type {number} */ this.m_width = width;
 613         /** @type {number} */ this.m_height = height;
 614         /** @type {number} */ this.m_numLayers = numLayers;
 615         /** @type {number} */ this.m_compareFunc = compareFunc;
 616         /** @type {?gluTexture.Texture2DArray} */ this.m_gradientTex = null;
 617         /** @type {?gluTexture.Texture2DArray} */ this.m_gridTex = null;
 618         /** @type {glsTextureTestUtil.TextureRenderer} */ this.m_renderer = new glsTextureTestUtil.TextureRenderer(es3fTextureShadowTests.version, gluShaderUtil.precision.PRECISION_HIGHP);
 619         /** @type {Array<es3fTextureShadowTests.FilterCase>} */ this.m_cases = [];
 620         /** @type {number} */ this.m_caseNdx = 0;
 621     };
 622
 623     es3fTextureShadowTests.Texture2DArrayShadowCase.prototype = Object.create(tcuTestCase.DeqpTest.prototype);
 624     es3fTextureShadowTests.Texture2DArrayShadowCase.prototype.constructor = es3fTextureShadowTests.Texture2DArrayShadowCase;
 625
 626     /**
 627      * init
 628      */
 629     es3fTextureShadowTests.Texture2DArrayShadowCase.prototype.init = function() {
 630         /** @type {tcuTexture.TextureFormat} */ var texFmt = gluTextureUtil.mapGLInternalFormat(this.m_format);
 631         /** @type {tcuTextureUtil.TextureFormatInfo} */ var fmtInfo = tcuTextureUtil.getTextureFormatInfo(texFmt);
 632         /** @type {Array<number>}*/ var cScale = deMath.subtract(fmtInfo.valueMax, fmtInfo.valueMin);
 633         /** @type {Array<number>}*/ var cBias = fmtInfo.valueMin;
 634         /** @type {number}*/ var numLevels = deMath.logToFloor(Math.max(this.m_width, this.m_height)) + 1;
 635
 636         // Create textures.
 637         this.m_gradientTex = gluTexture.texture2DArrayFromInternalFormat(gl, this.m_format, this.m_width, this.m_height, this.m_numLayers);
 638         this.m_gridTex = gluTexture.texture2DArrayFromInternalFormat(gl, this.m_format, this.m_width, this.m_height, this.m_numLayers);
 639
 640         // Fill first gradient texture.
 641         for (var levelNdx = 0; levelNdx < numLevels; levelNdx++) {
 642             /** @type {Array<number>}*/ var gMin = deMath.add(deMath.multiply([-0.5, -0.5, -0.5, 2.0], cScale), cBias);
 643             /** @type {Array<number>}*/ var gMax = deMath.add(deMath.multiply([1.0, 1.0, 1.0, 0.0], cScale), cBias);
 644
 645             this.m_gradientTex.getRefTexture().allocLevel(levelNdx);
 646             tcuTextureUtil.fillWithComponentGradients(
 647                 /** @type {tcuTexture.PixelBufferAccess} */ (this.m_gradientTex.getRefTexture().getLevel(levelNdx)), gMin, gMax);
 648         }
 649
 650         // Fill second with grid texture.
 651         for (var levelNdx = 0; levelNdx < numLevels; levelNdx++) {
 652             /** @type {number}*/ var step = Math.floor(0x00ffffff / numLevels);
 653             /** @type {number}*/ var rgb = step * levelNdx;
 654             /** @type {number}*/ var colorA = deMath.binaryOp(0xff000000, rgb, deMath.BinaryOp.OR);
 655             /** @type {number}*/ var colorB = deMath.binaryOp(0xff000000, deMath.binaryNot(rgb), deMath.BinaryOp.OR);
 656
 657             this.m_gridTex.getRefTexture().allocLevel(levelNdx);
 658             tcuTextureUtil.fillWithGrid(
 659                 /** @type {tcuTexture.PixelBufferAccess} */ (this.m_gridTex.getRefTexture().getLevel(levelNdx)), 4,
 660                 deMath.add(deMath.multiply(tcuRGBA.newRGBAFromValue(colorA).toVec(), cScale), cBias),
 661                 deMath.add(deMath.multiply(tcuRGBA.newRGBAFromValue(colorB).toVec(), cScale), cBias)
 662             );
 663         }
 664
 665         // Upload.
 666         this.m_gradientTex.upload();
 667         this.m_gridTex.upload();
 668
 669         // Compute cases.
 670         /** @type {number} */ var refInRangeUpper = (this.m_compareFunc == gl.EQUAL || this.m_compareFunc == gl.NOTEQUAL) ? 1.0 : 0.5;
 671         /** @type {number} */ var refInRangeLower = (this.m_compareFunc == gl.EQUAL || this.m_compareFunc == gl.NOTEQUAL) ? 0.0 : 0.5;
 672         /** @type {number} */ var refOutOfBoundsUpper = 1.1; // !< lookup function should clamp values to [0, 1] range
 673         /** @type {number} */ var refOutOfBoundsLower = -0.1;
 674
 675         /** @type {Array<{texNdx: number, ref: number, lodX: number, lodY: number, oX: number, oY: number}>} */
 676         var cases = [{ texNdx: 0, ref: refInRangeUpper, lodX: 1.6, lodY: 2.9, oX: -1.0, oY: -2.7 },{ texNdx: 0, ref: refInRangeLower, lodX: -2.0, lodY: -1.35, oX: -0.2, oY: 0.7 },{ texNdx: 1, ref: refInRangeUpper, lodX: 0.14, lodY: 0.275, oX: -1.5, oY: -1.1 },{ texNdx: 1, ref: refInRangeLower, lodX: -0.92, lodY: -2.64, oX: 0.4, oY: -0.1 },{ texNdx: 1, ref: refOutOfBoundsUpper, lodX: -0.49, lodY: -0.22, oX: 0.45, oY: 0.97 },{ texNdx: 1, ref: refOutOfBoundsLower, lodX: -0.85, lodY: 0.75, oX: 0.25, oY: 0.61 }
 677         ];
 678
 679         var viewportW = Math.min(VIEWPORT_WIDTH, gl.canvas.width);
 680         var viewportH = Math.min(VIEWPORT_HEIGHT, gl.canvas.height);
 681
 682         /** @type {number} */ var minLayer = -0.5;
 683         /** @type {number} */ var maxLayer = this.m_numLayers;
 684
 685         for (var caseNdx = 0; caseNdx < cases.length; caseNdx++) {
 686             var tex = cases[caseNdx].texNdx > 0 ? this.m_gridTex : this.m_gradientTex;
 687             /** @type {number} */ var ref = cases[caseNdx].ref;
 688             /** @type {number} */ var lodX = cases[caseNdx].lodX;
 689             /** @type {number} */ var lodY = cases[caseNdx].lodY;
 690             /** @type {number} */ var oX = cases[caseNdx].oX;
 691             /** @type {number} */ var oY = cases[caseNdx].oY;
 692             /** @type {number} */ var sX = Math.exp(lodX * Math.LN2) * viewportW / tex.getRefTexture().getWidth();
 693             /** @type {number} */ var sY = Math.exp(lodY * Math.LN2) * viewportH / tex.getRefTexture().getHeight();
 694
 695             this.m_cases.push(new es3fTextureShadowTests.FilterCase(tex, ref, [oX, oY, minLayer], [oX + sX, oY + sY, maxLayer]));
 696         }
 697
 698         this.m_caseNdx = 0;
 699     };
 700
 701     /**
 702      * @return {tcuTestCase.IterateResult}
 703      */
 704     es3fTextureShadowTests.Texture2DArrayShadowCase.prototype.iterate = function() {
 705         var viewport = new glsTextureTestUtil.RandomViewport(document.getElementById('canvas'), VIEWPORT_WIDTH, VIEWPORT_HEIGHT, deString.deStringHash(this.fullName()) ^ deMath.deMathHash(this.m_caseNdx));
 706         var curCase = this.m_cases[this.m_caseNdx];
 707         var sampleParams = new glsTextureTestUtil.ReferenceParams(glsTextureTestUtil.textureType.TEXTURETYPE_2D_ARRAY);
 708         var rendered = new tcuSurface.Surface(viewport.width, viewport.height);
 709         var texCoord = [];
 710
 711         texCoord = [curCase.minCoord[0], curCase.minCoord[1], curCase.minCoord[2],
 712             curCase.minCoord[0], curCase.maxCoord[1], (curCase.minCoord[2] + curCase.maxCoord[2]) / 2.0,
 713             curCase.maxCoord[0], curCase.minCoord[1], (curCase.minCoord[2] + curCase.maxCoord[2]) / 2.0,
 714             curCase.maxCoord[0], curCase.maxCoord[1], curCase.maxCoord[2]];
 715
 716         if (viewport.width < MIN_VIEWPORT_WIDTH || viewport.height < MIN_VIEWPORT_HEIGHT)
 717             throw new Error('Too small render target');
 718
 719         sampleParams.sampler = gluTextureUtil.mapGLSamplerWrapST(this.m_wrapS, this.m_wrapT, this.m_minFilter, this.m_magFilter);
 720         sampleParams.sampler.compare = gluTextureUtil.mapGLCompareFunc(this.m_compareFunc);
 721         sampleParams.samplerType = glsTextureTestUtil.samplerType.SAMPLERTYPE_SHADOW;
 722         sampleParams.lodMode = glsTextureTestUtil.lodMode.EXACT;
 723         sampleParams.ref = curCase.ref;
 724
 725         bufferedLogToConsole(
 726             'Compare reference value = ' + sampleParams.ref + '\n' +
 727             'Texture Coordinates: ' + curCase.minCoord + ' -> ' + curCase.maxCoord
 728         );
 729
 730         gl.bindTexture(gl.TEXTURE_2D_ARRAY, curCase.texture.getGLTexture());
 731         gl.texParameteri(gl.TEXTURE_2D_ARRAY, gl.TEXTURE_MIN_FILTER, this.m_minFilter);
 732         gl.texParameteri(gl.TEXTURE_2D_ARRAY, gl.TEXTURE_MAG_FILTER, this.m_magFilter);
 733         gl.texParameteri(gl.TEXTURE_2D_ARRAY, gl.TEXTURE_WRAP_S, this.m_wrapS);
 734         gl.texParameteri(gl.TEXTURE_2D_ARRAY, gl.TEXTURE_WRAP_T, this.m_wrapT);
 735         gl.texParameteri(gl.TEXTURE_2D_ARRAY, gl.TEXTURE_COMPARE_MODE, gl.COMPARE_REF_TO_TEXTURE);
 736         gl.texParameteri(gl.TEXTURE_2D_ARRAY, gl.TEXTURE_COMPARE_FUNC, this.m_compareFunc);
 737
 738         gl.viewport(viewport.x, viewport.y, viewport.width, viewport.height);
 739         this.m_renderer.renderQuad(0, texCoord, sampleParams);
 740         rendered.readViewport(gl, viewport);
 741
 742         var pixelFormat = new tcuPixelFormat.PixelFormat(8, 8, 8, 8);
 743         /** @type {tcuTexLookupVerifier.LodPrecision} */ var lodPrecision = new tcuTexLookupVerifier.LodPrecision(18, 6);
 744         /** @type {tcuTexCompareVerifier.TexComparePrecision} */ var texComparePrecision = new tcuTexCompareVerifier.TexComparePrecision(
 745             [20, 20, 20],
 746             [7, 7, 7],
 747             5,
 748             16,
 749             pixelFormat.redBits - 1
 750         );
 751
 752         var isHighQuality = es3fTextureShadowTests.verifyTexCompareResult(tcuTexture.Texture2DArray, rendered.getAccess(), curCase.texture.getRefTexture(),
 753                                                           texCoord, sampleParams, texComparePrecision, lodPrecision, pixelFormat);
 754
 755         if (!isHighQuality) {
 756             bufferedLogToConsole('Warning: Verification assuming high-quality PCF filtering failed');
 757
 758             lodPrecision.lodBits = 4;
 759             texComparePrecision.uvwBits = [4, 4, 4];
 760             texComparePrecision.pcfBits = 0;
 761
 762             var isOk = es3fTextureShadowTests.verifyTexCompareResult(tcuTexture.Texture2DArray, rendered.getAccess(), curCase.texture.getRefTexture(),
 763                                                                                               texCoord, sampleParams, texComparePrecision, lodPrecision, pixelFormat);
 764
 765             if (!isOk) {
 766                 bufferedLogToConsole('ERROR: Verification against low precision requirements failed, failing test case.');
 767                 testFailedOptions('Image verification failed', false);
 768             } else
 769                 testPassedOptions('Low-quality result', true);
 770         } else
 771             testPassedOptions('High-quality result', true);
 772
 773         this.m_caseNdx += 1;
 774         return this.m_caseNdx < this.m_cases.length ? tcuTestCase.IterateResult.CONTINUE : tcuTestCase.IterateResult.STOP;
 775     };
 776
 777     es3fTextureShadowTests.init = function() {
 778         /** @type {Array<es3fTextureShadowTests.Format>} */ var formats = [];
 779         formats.push(new es3fTextureShadowTests.Format('depth_component16', gl.DEPTH_COMPONENT16));
 780         formats.push(new es3fTextureShadowTests.Format('depth_component32f', gl.DEPTH_COMPONENT32F));
 781         formats.push(new es3fTextureShadowTests.Format('depth24_stencil8', gl.DEPTH24_STENCIL8));
 782
 783         /** @type {Array<es3fTextureShadowTests.Filter>} */ var filters = [];
 784         filters.push(new es3fTextureShadowTests.Filter('nearest', gl.NEAREST, gl.NEAREST));
 785         filters.push(new es3fTextureShadowTests.Filter('linear', gl.LINEAR, gl.LINEAR));
 786         filters.push(new es3fTextureShadowTests.Filter('nearest_mipmap_nearest', gl.NEAREST_MIPMAP_NEAREST, gl.LINEAR));
 787         filters.push(new es3fTextureShadowTests.Filter('linear_mipmap_nearest', gl.LINEAR_MIPMAP_NEAREST, gl.LINEAR));
 788         filters.push(new es3fTextureShadowTests.Filter('nearest_mipmap_linear', gl.NEAREST_MIPMAP_LINEAR, gl.LINEAR));
 789         filters.push(new es3fTextureShadowTests.Filter('linear_mipmap_linear', gl.LINEAR_MIPMAP_LINEAR, gl.LINEAR));
 790
 791         /** @type {Array<es3fTextureShadowTests.CompareFunc>} */ var compareFuncs = [];
 792         compareFuncs.push(new es3fTextureShadowTests.CompareFunc('less_or_equal', gl.LEQUAL));
 793         compareFuncs.push(new es3fTextureShadowTests.CompareFunc('greater_or_equal', gl.GEQUAL));
 794         compareFuncs.push(new es3fTextureShadowTests.CompareFunc('less', gl.LESS));
 795         compareFuncs.push(new es3fTextureShadowTests.CompareFunc('greater', gl.GREATER));
 796         compareFuncs.push(new es3fTextureShadowTests.CompareFunc('equal', gl.EQUAL));
 797         compareFuncs.push(new es3fTextureShadowTests.CompareFunc('not_equal', gl.NOTEQUAL));
 798         compareFuncs.push(new es3fTextureShadowTests.CompareFunc('always', gl.ALWAYS));
 799         compareFuncs.push(new es3fTextureShadowTests.CompareFunc('never', gl.NEVER));
 800
 801         var state = tcuTestCase.runner;
 802         /** @type {tcuTestCase.DeqpTest} */ var testGroup = state.testCases;
 803
 804         for (var filterNdx = 0; filterNdx < filters.length; filterNdx++) {
 805             for (var compareNdx = 0; compareNdx < compareFuncs.length; compareNdx++) {
 806                 var filterGroup = tcuTestCase.newTest(
 807                     '2d.' + filters[filterNdx].name, '2D texture shadow lookup tests');
 808                 testGroup.addChild(filterGroup);
 809
 810                 for (var formatNdx = 0; formatNdx < formats.length; formatNdx++) {
 811                     /** @type {number} */ var minFilter = filters[filterNdx].minFilter;
 812                     /** @type {number} */ var magFilter = filters[filterNdx].magFilter;
 813                     /** @type {number} */ var format = formats[formatNdx].format;
 814                     /** @type {number} */ var compareFunc = compareFuncs[compareNdx].func;
 815                     /** @type {number} */ var wrapS = gl.REPEAT;
 816                     /** @type {number} */ var wrapT = gl.REPEAT;
 817                     /** @type {number} */ var width = 32;
 818                     /** @type {number} */ var height = 64;
 819                     /** @type {string} */ var name = compareFuncs[compareNdx].name + '_' + formats[formatNdx].name;
 820
 821                     filterGroup.addChild(new es3fTextureShadowTests.Texture2DShadowCase(name, '', minFilter, magFilter, wrapS, wrapT, format, width, height, compareFunc));
 822                 }
 823             }
 824         }
 825
 826         for (filterNdx = 0; filterNdx < filters.length; filterNdx++) {
 827             for (compareNdx = 0; compareNdx < compareFuncs.length; compareNdx++) {
 828                 filterGroup = tcuTestCase.newTest(
 829                     'cube.' + filters[filterNdx].name, 'Cube map texture shadow lookup tests');
 830                 testGroup.addChild(filterGroup);
 831
 832                 for (formatNdx = 0; formatNdx < formats.length; formatNdx++) {
 833                     minFilter = filters[filterNdx].minFilter;
 834                     magFilter = filters[filterNdx].magFilter;
 835                     format = formats[formatNdx].format;
 836                     compareFunc = compareFuncs[compareNdx].func;
 837                     wrapS = gl.REPEAT;
 838                     wrapT = gl.REPEAT;
 839                     var size = 32;
 840                     name = compareFuncs[compareNdx].name + '_' + formats[formatNdx].name;
 841
 842                     filterGroup.addChild(new es3fTextureShadowTests.TextureCubeShadowCase(name, '', minFilter, magFilter, wrapS, wrapT, format, size, compareFunc));
 843                 }
 844             }
 845         }
 846
 847         for (var filterNdx = 0; filterNdx < filters.length; filterNdx++) {
 848             for (var compareNdx = 0; compareNdx < compareFuncs.length; compareNdx++) {
 849                 filterGroup = tcuTestCase.newTest(
 850                     '2d_array.' + filters[filterNdx].name, '2D texture array shadow lookup tests');
 851                 testGroup.addChild(filterGroup);
 852
 853                 for (var formatNdx = 0; formatNdx < formats.length; formatNdx++) {
 854                     minFilter = filters[filterNdx].minFilter;
 855                     magFilter = filters[filterNdx].magFilter;
 856                     format = formats[formatNdx].format;
 857                     compareFunc = compareFuncs[compareNdx].func;
 858                     wrapS = gl.REPEAT;
 859                     wrapT = gl.REPEAT;
 860                     width = 32;
 861                     height = 64;
 862                     var numLayers = 8;
 863                     name = compareFuncs[compareNdx].name + '_' + formats[formatNdx].name;
 864
 865                     filterGroup.addChild(new es3fTextureShadowTests.Texture2DArrayShadowCase(name, '', minFilter, magFilter, wrapS, wrapT, format, width, height, numLayers, compareFunc));
 866                 }
 867             }
 868         }
 869     };
 870
 871     es3fTextureShadowTests.run = function(context, range) {
 872         gl = context;
 873         //Set up Test Root parameters
 874         var testName = 'texture_shadow';
 875         var testDescription = 'Texture Shadow Test';
 876         var state = tcuTestCase.runner;
 877
 878         state.testName = testName;
 879         state.testCases = tcuTestCase.newTest(testName, testDescription, null);
 880
 881         //Set up name and description of this test series.
 882         setCurrentTestName(testName);
 883         description(testDescription);
 884
 885         try {
 886             //Create test cases
 887             es3fTextureShadowTests.init();
 888             if (range)
 889                 state.setRange(range);
 890             //Run test cases
 891             tcuTestCase.runTestCases();
 892         }
 893         catch (err) {
 894             bufferedLogToConsole(err);
 895             tcuTestCase.runner.terminate();
 896         }
 897     };
 898 });