diff options
Diffstat (limited to 'dom/canvas/test/webgl-conf/checkout/deqp/functional/gles3/es3fTextureShadowTests.js')
| -rw-r--r-- | dom/canvas/test/webgl-conf/checkout/deqp/functional/gles3/es3fTextureShadowTests.js | 898 |
1 files changed, 898 insertions, 0 deletions
diff --git a/dom/canvas/test/webgl-conf/checkout/deqp/functional/gles3/es3fTextureShadowTests.js b/dom/canvas/test/webgl-conf/checkout/deqp/functional/gles3/es3fTextureShadowTests.js new file mode 100644 index 0000000000..c878228b23 --- /dev/null +++ b/dom/canvas/test/webgl-conf/checkout/deqp/functional/gles3/es3fTextureShadowTests.js @@ -0,0 +1,898 @@ +/*------------------------------------------------------------------------- + * drawElements Quality Program OpenGL ES Utilities + * ------------------------------------------------ + * + * Copyright 2014 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ +'use strict'; +goog.provide('functional.gles3.es3fTextureShadowTests'); +goog.require('framework.common.tcuImageCompare'); +goog.require('framework.common.tcuLogImage'); +goog.require('framework.common.tcuPixelFormat'); +goog.require('framework.common.tcuRGBA'); +goog.require('framework.common.tcuSurface'); +goog.require('framework.common.tcuTestCase'); +goog.require('framework.common.tcuTexCompareVerifier'); +goog.require('framework.common.tcuTexLookupVerifier'); +goog.require('framework.common.tcuTexture'); +goog.require('framework.common.tcuTextureUtil'); +goog.require('framework.delibs.debase.deMath'); +goog.require('framework.delibs.debase.deString'); +goog.require('framework.delibs.debase.deUtil'); +goog.require('framework.opengl.gluShaderUtil'); +goog.require('framework.opengl.gluTexture'); +goog.require('framework.opengl.gluTextureUtil'); +goog.require('framework.referencerenderer.rrMultisamplePixelBufferAccess'); +goog.require('modules.shared.glsTextureTestUtil'); + +goog.scope(function() { + +var es3fTextureShadowTests = functional.gles3.es3fTextureShadowTests; +var tcuTestCase = framework.common.tcuTestCase; +var glsTextureTestUtil = modules.shared.glsTextureTestUtil; +var gluShaderUtil = framework.opengl.gluShaderUtil; +var gluTexture = framework.opengl.gluTexture; +var gluTextureUtil = framework.opengl.gluTextureUtil; +var tcuTexture = framework.common.tcuTexture; +var tcuImageCompare = framework.common.tcuImageCompare; +var tcuLogImage = framework.common.tcuLogImage; +var tcuTextureUtil = framework.common.tcuTextureUtil; +var tcuRGBA = framework.common.tcuRGBA; +var deMath = framework.delibs.debase.deMath; +var tcuPixelFormat = framework.common.tcuPixelFormat; +var tcuSurface = framework.common.tcuSurface; +var tcuTexCompareVerifier = framework.common.tcuTexCompareVerifier; +var tcuTexLookupVerifier = framework.common.tcuTexLookupVerifier; +var rrMultisamplePixelBufferAccess = framework.referencerenderer.rrMultisamplePixelBufferAccess; +var deString = framework.delibs.debase.deString; +var deUtil = framework.delibs.debase.deUtil; + + es3fTextureShadowTests.version = '300 es'; + + /** @const */ var VIEWPORT_WIDTH = 64; + /** @const */ var VIEWPORT_HEIGHT = 64; + /** @const */ var MIN_VIEWPORT_WIDTH = 64; + /** @const */ var MIN_VIEWPORT_HEIGHT = 64; + + var DE_ASSERT = function(x) { + if (!x) + throw new Error('Assert failed'); + }; + + /** + * @param {tcuTexture.TextureFormat} format + * @return {boolean} + */ + es3fTextureShadowTests.isFloatingPointDepthFormat = function(format) { + // Only two depth and depth-stencil formats are floating point + 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); + }; + + /** + * @param {tcuTexture.PixelBufferAccess} access + */ + es3fTextureShadowTests.clampFloatingPointTexture = function(access) { + DE_ASSERT(es3fTextureShadowTests.isFloatingPointDepthFormat(access.getFormat())); + for (var z = 0; z < access.getDepth(); ++z) + for (var y = 0; y < access.getHeight(); ++y) + for (var x = 0; x < access.getWidth(); ++x) + access.setPixDepth(deMath.clamp(access.getPixDepth(x, y, z), 0.0, 1.0), x, y, z); + }; + + /** + * @param {tcuTexture.Texture2D|tcuTexture.Texture2DArray} target + */ + es3fTextureShadowTests.clampFloatingPointTexture2D = function(target) { + for (var level = 0; level < target.getNumLevels(); ++level) + if (!target.isLevelEmpty(level)) + es3fTextureShadowTests.clampFloatingPointTexture(target.getLevel(level)); + }; + + /** + * @param {tcuTexture.TextureCube} target + */ + es3fTextureShadowTests.clampFloatingPointTextureCube = function(target) { + for (var level = 0; level < target.getNumLevels(); ++level) + for (var face = tcuTexture.CubeFace.CUBEFACE_NEGATIVE_X; face < Object.keys(tcuTexture.CubeFace).length; face++) + es3fTextureShadowTests.clampFloatingPointTexture(target.getLevelFace(level, face)); + }; + + /** + * @param {?} textureType + * @param {tcuTexture.ConstPixelBufferAccess} result + * @param {tcuTexture.Texture2D|tcuTexture.Texture2DArray|tcuTexture.TextureCube} src + * @param {Array<number>} texCoord + * @param {glsTextureTestUtil.ReferenceParams} sampleParams + * @param {tcuTexCompareVerifier.TexComparePrecision} comparePrec + * @param {tcuTexLookupVerifier.LodPrecision} lodPrecision + * @param {tcuPixelFormat.PixelFormat} pixelFormat + */ + es3fTextureShadowTests.verifyTexCompareResult = function(textureType, result, src, texCoord, sampleParams, comparePrec, lodPrecision, pixelFormat) { + var reference = new tcuSurface.Surface(result.getWidth(), result.getHeight()); + var errorMask = new tcuSurface.Surface(result.getWidth(), result.getHeight()); + var nonShadowThreshold = deMath.swizzle(tcuTexLookupVerifier.computeFixedPointThreshold(deMath.subtract(glsTextureTestUtil.getBitsVec(pixelFormat), [1, 1, 1, 1])), [1, 2, 3]); + var numFailedPixels; + + if (es3fTextureShadowTests.isFloatingPointDepthFormat(src.getFormat())) { + var clampedSource = /*deUtil.clone(*/src/*)*/; + + if (textureType == tcuTexture.Texture2D) { + es3fTextureShadowTests.clampFloatingPointTexture2D(/** @type {tcuTexture.Texture2D} */(clampedSource)); + glsTextureTestUtil.sampleTexture2D(new glsTextureTestUtil.SurfaceAccess(reference, pixelFormat), /** @type {tcuTexture.Texture2DView} */ (clampedSource.getView()), texCoord, sampleParams); + // sample clamped values + numFailedPixels = glsTextureTestUtil.computeTextureCompareDiff2D(result, reference.getAccess(), errorMask.getAccess(), /** @type {tcuTexture.Texture2DView} */ (clampedSource.getView()), texCoord, sampleParams, comparePrec, lodPrecision, nonShadowThreshold); + } else if (textureType == tcuTexture.Texture2DArray) { + es3fTextureShadowTests.clampFloatingPointTexture2D(/** @type {tcuTexture.Texture2DArray} */(clampedSource)); + glsTextureTestUtil.sampleTexture2DArray(new glsTextureTestUtil.SurfaceAccess(reference, pixelFormat), /** @type {tcuTexture.Texture2DArrayView} */ (clampedSource.getView()), texCoord, sampleParams); + // sample clamped values + numFailedPixels = glsTextureTestUtil.computeTextureCompareDiff2DArray(result, reference.getAccess(), errorMask.getAccess(), /** @type {tcuTexture.Texture2DArrayView} */ (clampedSource.getView()), texCoord, sampleParams, comparePrec, lodPrecision, nonShadowThreshold); + } else if (textureType == tcuTexture.TextureCube) { + es3fTextureShadowTests.clampFloatingPointTextureCube(/** @type {tcuTexture.TextureCube} */(clampedSource)); + glsTextureTestUtil.sampleTextureCube(new glsTextureTestUtil.SurfaceAccess(reference, pixelFormat), /** @type {tcuTexture.TextureCubeView} */ (clampedSource.getView()), texCoord, sampleParams); + // sample clamped values + numFailedPixels = glsTextureTestUtil.computeTextureCompareDiffCube(result, reference.getAccess(), errorMask.getAccess(), /** @type {tcuTexture.TextureCubeView} */ (clampedSource.getView()), texCoord, sampleParams, comparePrec, lodPrecision, nonShadowThreshold); + } else + throw new Error('Invalid texture type'); + + } else { + if (textureType == tcuTexture.Texture2D) { + glsTextureTestUtil.sampleTexture2D(new glsTextureTestUtil.SurfaceAccess(reference, pixelFormat), /** @type {tcuTexture.Texture2DView} */ (src.getView()), texCoord, sampleParams); + // sample raw values (they are guaranteed to be in [0, 1] range as the format cannot represent any other values) + numFailedPixels = glsTextureTestUtil.computeTextureCompareDiff2D(result, reference.getAccess(), errorMask.getAccess(), /** @type {tcuTexture.Texture2DView} */ (src.getView()), texCoord, sampleParams, comparePrec, lodPrecision, nonShadowThreshold); + } else if (textureType == tcuTexture.Texture2DArray) { + glsTextureTestUtil.sampleTexture2DArray(new glsTextureTestUtil.SurfaceAccess(reference, pixelFormat), /** @type {tcuTexture.Texture2DArrayView} */ (src.getView()), texCoord, sampleParams); + // sample raw values (they are guaranteed to be in [0, 1] range as the format cannot represent any other values) + numFailedPixels = glsTextureTestUtil.computeTextureCompareDiff2DArray(result, reference.getAccess(), errorMask.getAccess(), /** @type {tcuTexture.Texture2DArrayView} */ (src.getView()), texCoord, sampleParams, comparePrec, lodPrecision, nonShadowThreshold); + } else if (textureType == tcuTexture.TextureCube) { + glsTextureTestUtil.sampleTextureCube(new glsTextureTestUtil.SurfaceAccess(reference, pixelFormat), /** @type {tcuTexture.TextureCubeView} */ (src.getView()), texCoord, sampleParams); + // sample raw values (they are guaranteed to be in [0, 1] range as the format cannot represent any other values) + numFailedPixels = glsTextureTestUtil.computeTextureCompareDiffCube(result, reference.getAccess(), errorMask.getAccess(), /** @type {tcuTexture.TextureCubeView} */ (src.getView()), texCoord, sampleParams, comparePrec, lodPrecision, nonShadowThreshold); + } else + throw new Error('Invalid texture type'); + } + + if (numFailedPixels > 0) + bufferedLogToConsole('ERROR: Result verification failed, got ' + numFailedPixels + ' invalid pixels!'); + + if (numFailedPixels > 0) + tcuImageCompare.displayImages(result, reference.getAccess(), errorMask.getAccess()); + else + tcuLogImage.logImageWithInfo(result, 'Result'); + + return numFailedPixels == 0; + + }; + + /** + * @constructor + * @param {string} name + * @param {number} format + * @struct + */ + es3fTextureShadowTests.Format = function(name, format) { + /** @type {string} */ this.name = name; + /** @type {number} */ this.format = format; + }; + + /** + * @constructor + * @param {string} name + * @param {number} minFilter + * @param {number} magFilter + * @struct + */ + es3fTextureShadowTests.Filter = function(name, minFilter, magFilter) { + /** @type {string} */ this.name = name; + /** @type {number} */ this.minFilter = minFilter; + /** @type {number} */ this.magFilter = magFilter; + }; + + /** + * @constructor + * @param {string} name + * @param {number} func + * @struct + */ + es3fTextureShadowTests.CompareFunc = function(name, func) { + /** @type {string} */ this.name = name; + /** @type {number} */ this.func = func; + }; + + /** + * @constructor + * @param {number} texNdx + * @param {number} ref + * @param {number} lodX + * @param {number} lodY + * @param {number} oX + * @param {number} oY + * @struct + */ + es3fTextureShadowTests.TestCase = function(texNdx, ref, lodX, lodY, oX, oY) { + /** @type {number} */ this.texNdx = texNdx; + /** @type {number} */ this.ref = ref; + /** @type {number} */ this.lodX = lodX; + /** @type {number} */ this.lodY = lodY; + /** @type {number} */ this.oX = oX + /** @type {number} */ this.oY = oY; + }; + + /** + * @constructor + * @param {?gluTexture.Texture2D|?gluTexture.TextureCube|?gluTexture.Texture2DArray} tex + * @param {number} ref + * @param {Array<number>} minCoord + * @param {Array<number>} maxCoord + * @struct + */ + es3fTextureShadowTests.FilterCase = function(tex, ref, minCoord, maxCoord) { + /** @type {?gluTexture.Texture2D|?gluTexture.TextureCube|?gluTexture.Texture2DArray} */ this.texture = tex; + /** @type {Array<number>} */ this.minCoord = minCoord; + /** @type {Array<number>} */ this.maxCoord = maxCoord; + /** @type {number} */ this.ref = ref; + }; + + /** + * @constructor + * @param {string} name + * @param {string} desc + * @param {number} minFilter + * @param {number} magFilter + * @param {number} wrapS + * @param {number} wrapT + * @param {number} format + * @param {number} width + * @param {number} height + * @param {number} compareFunc + * @extends {tcuTestCase.DeqpTest} + */ + es3fTextureShadowTests.Texture2DShadowCase = function(name, desc, minFilter, magFilter, wrapS, wrapT, format, width, height, compareFunc) { + tcuTestCase.DeqpTest.call(this, name, desc); + this.m_minFilter = minFilter; + this.m_magFilter = magFilter; + this.m_wrapS = wrapS; + this.m_wrapT = wrapT; + this.m_format = format; + this.m_width = width; + this.m_height = height; + this.m_compareFunc = compareFunc; + this.m_renderer = new glsTextureTestUtil.TextureRenderer(es3fTextureShadowTests.version, gluShaderUtil.precision.PRECISION_HIGHP); + this.m_caseNdx = 0; + this.m_cases = []; + }; + + es3fTextureShadowTests.Texture2DShadowCase.prototype = Object.create(tcuTestCase.DeqpTest.prototype); + es3fTextureShadowTests.Texture2DShadowCase.prototype.constructor = es3fTextureShadowTests.Texture2DShadowCase; + + es3fTextureShadowTests.Texture2DShadowCase.prototype.init = function() { + + // Create 2 textures. + this.m_textures = []; + this.m_textures[0] = gluTexture.texture2DFromInternalFormat(gl, this.m_format, this.m_width, this.m_height); + this.m_textures[1] = gluTexture.texture2DFromInternalFormat(gl, this.m_format, this.m_width, this.m_height); + + var numLevels = this.m_textures[0].getRefTexture().getNumLevels(); + + for (var levelNdx = 0; levelNdx < numLevels; levelNdx++) { + this.m_textures[0].getRefTexture().allocLevel(levelNdx); + tcuTextureUtil.fillWithComponentGradients(this.m_textures[0].getRefTexture().getLevel(levelNdx), [-0.5, -0.5, -0.5, 2.0], [1, 1, 1, 0]); + } + + for (levelNdx = 0; levelNdx < numLevels; levelNdx++) { + var step = 0x00ffffff / numLevels; + var rgb = step * levelNdx; + var colorA = 0xff000000 | rgb; + var colorB = 0xff000000 | ~rgb; + + this.m_textures[1].getRefTexture().allocLevel(levelNdx); + tcuTextureUtil.fillWithGrid(this.m_textures[1].getRefTexture().getLevel(levelNdx), 4, tcuRGBA.newRGBAFromValue(colorA).toVec(), tcuRGBA.newRGBAFromValue(colorB).toVec()); + } + + for (var i = 0; i < this.m_textures.length; i++) + this.m_textures[i].upload(); + + var refInRangeUpper = (this.m_compareFunc == gl.EQUAL || this.m_compareFunc == gl.NOTEQUAL) ? 1.0 : 0.5; + var refInRangeLower = (this.m_compareFunc == gl.EQUAL || this.m_compareFunc == gl.NOTEQUAL) ? 0.0 : 0.5; + + var refOutOfBoundsUpper = 1.1; + var refOutOfBoundsLower = -0.1; + + numLevels = this.m_textures[0].getRefTexture().getNumLevels(); + + var cases = []; + cases.push(new es3fTextureShadowTests.TestCase(0, refInRangeUpper, 1.6, 2.9, -1.0, -2.7)); + cases.push(new es3fTextureShadowTests.TestCase(0, refInRangeLower, -2.0, -1.35, -0.2, 0.7)); + cases.push(new es3fTextureShadowTests.TestCase(1, refInRangeUpper, 0.14, 0.275, -1.5, -1.1)); + cases.push(new es3fTextureShadowTests.TestCase(1, refInRangeLower, -0.92, -2.64, 0.4, -0.1)); + cases.push(new es3fTextureShadowTests.TestCase(1, refOutOfBoundsUpper, -0.39, -0.52, 0.65, 0.87)); + cases.push(new es3fTextureShadowTests.TestCase(1, refOutOfBoundsLower, -1.55, 0.65, 0.35, 0.91)); + + var viewportW = Math.min(VIEWPORT_WIDTH, gl.canvas.width); + var viewportH = Math.min(VIEWPORT_HEIGHT, gl.canvas.height); + + for (var caseNdx = 0; caseNdx < cases.length; caseNdx++) { + var texNdx = deMath.clamp(cases[caseNdx].texNdx, 0, this.m_textures.length - 1); + var ref = cases[caseNdx].ref; + var lodX = cases[caseNdx].lodX; + var lodY = cases[caseNdx].lodY; + var oX = cases[caseNdx].oX; + var oY = cases[caseNdx].oY; + var sX = Math.exp(lodX * Math.log(2)) * viewportW / this.m_textures[texNdx].getRefTexture().getWidth(); + var sY = Math.exp(lodY * Math.log(2)) * viewportH / this.m_textures[texNdx].getRefTexture().getHeight(); + + this.m_cases.push(new es3fTextureShadowTests.FilterCase(this.m_textures[texNdx], ref, [oX, oY], [oX + sX, oY + sY])); + } + + this.m_caseNdx = 0; + }; + + es3fTextureShadowTests.Texture2DShadowCase.prototype.iterate = function() { + + var viewport = new glsTextureTestUtil.RandomViewport(document.getElementById('canvas'), VIEWPORT_WIDTH, VIEWPORT_HEIGHT); + var curCase = this.m_cases[this.m_caseNdx]; + var sampleParams = new glsTextureTestUtil.ReferenceParams(glsTextureTestUtil.textureType.TEXTURETYPE_2D); + var rendered = new tcuSurface.Surface(viewport.width, viewport.height); + var texCoord = []; + + if (viewport.width < MIN_VIEWPORT_WIDTH || viewport.height < MIN_VIEWPORT_HEIGHT) + throw new Error('Too small render target'); + + // Setup params for reference. + sampleParams.sampler = gluTextureUtil.mapGLSampler(this.m_wrapS, this.m_wrapT, gl.CLAMP_TO_EDGE, this.m_minFilter, this.m_magFilter); + sampleParams.sampler.compare = gluTextureUtil.mapGLCompareFunc(this.m_compareFunc); + sampleParams.samplerType = glsTextureTestUtil.samplerType.SAMPLERTYPE_SHADOW; + sampleParams.lodMode = glsTextureTestUtil.lodMode.EXACT; + sampleParams.ref = curCase.ref; + + bufferedLogToConsole('Compare reference value = ' + sampleParams.ref); + + // Compute texture coordinates. + bufferedLogToConsole('Texture coordinates: ' + curCase.minCoord + ' -> ' + curCase.maxCoord); + + texCoord = glsTextureTestUtil.computeQuadTexCoord2D(curCase.minCoord, curCase.maxCoord); + + gl.bindTexture(gl.TEXTURE_2D, curCase.texture.getGLTexture()); + gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, this.m_minFilter); + gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, this.m_magFilter); + gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, this.m_wrapS); + gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, this.m_wrapT); + gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_COMPARE_MODE, gl.COMPARE_REF_TO_TEXTURE); + gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_COMPARE_FUNC, this.m_compareFunc); + + gl.viewport(viewport.x, viewport.y, viewport.width, viewport.height); + this.m_renderer.renderQuad(0, texCoord, sampleParams); + rendered.readViewport(gl, viewport); + + + var pixelFormat = new tcuPixelFormat.PixelFormat(8, 8, 8, 8); + var lodPrecision = new tcuTexLookupVerifier.LodPrecision(18, 6); + var texComparePrecision = new tcuTexCompareVerifier.TexComparePrecision([20, 20, 0], [7, 7, 0], 5, 16, pixelFormat.redBits - 1); + + var isHighQuality = es3fTextureShadowTests.verifyTexCompareResult(tcuTexture.Texture2D, rendered.getAccess(), curCase.texture.getRefTexture(), + texCoord, sampleParams, texComparePrecision, lodPrecision, pixelFormat); + + if (!isHighQuality) { + bufferedLogToConsole('Warning: Verification assuming high-quality PCF filtering failed.'); + + lodPrecision.lodBits = 4; + texComparePrecision.uvwBits = [4, 4, 0]; + texComparePrecision.pcfBits = 0; + + var isOk = es3fTextureShadowTests.verifyTexCompareResult(tcuTexture.Texture2D, rendered.getAccess(), curCase.texture.getRefTexture(), + texCoord, sampleParams, texComparePrecision, lodPrecision, pixelFormat); + + if (!isOk) { + bufferedLogToConsole('ERROR: Verification against low precision requirements failed, failing test case.'); + testFailedOptions('Image verification failed', false); + } else + testPassedOptions('Low-quality result', true); + } else + testPassedOptions('High-quality result', true); + + this.m_caseNdx += 1; + return this.m_caseNdx < this.m_cases.length ? tcuTestCase.IterateResult.CONTINUE : tcuTestCase.IterateResult.STOP; + }; + + /** + * @constructor + * @param {string} name + * @param {string} desc + * @param {number} minFilter + * @param {number} magFilter + * @param {number} wrapS + * @param {number} wrapT + * @param {number} format + * @param {number} size + * @param {number} compareFunc + * @extends {tcuTestCase.DeqpTest} + */ + es3fTextureShadowTests.TextureCubeShadowCase = function(name, desc, minFilter, magFilter, wrapS, wrapT, format, size, compareFunc) { + tcuTestCase.DeqpTest.call(this, name, desc); + this.m_minFilter = minFilter; + this.m_magFilter = magFilter; + this.m_wrapS = wrapS; + this.m_wrapT = wrapT; + this.m_format = format; + this.m_size = size; + this.m_compareFunc = compareFunc; + this.m_renderer = new glsTextureTestUtil.TextureRenderer(es3fTextureShadowTests.version, gluShaderUtil.precision.PRECISION_HIGHP); + this.m_caseNdx = 0; + this.m_cases = []; + }; + + es3fTextureShadowTests.TextureCubeShadowCase.prototype = Object.create(tcuTestCase.DeqpTest.prototype); + es3fTextureShadowTests.TextureCubeShadowCase.prototype.constructor = es3fTextureShadowTests.TextureCubeShadowCase; + + es3fTextureShadowTests.TextureCubeShadowCase.prototype.init = function() { + DE_ASSERT(!this.m_gradientTex && !this.m_gridTex); + + var numLevels = Math.floor(Math.log2(this.m_size)) + 1; + /** @type {tcuTexture.TextureFormat} */ var texFmt = gluTextureUtil.mapGLInternalFormat(this.m_format); + /** @type {tcuTextureUtil.TextureFormatInfo} */ var fmtInfo = tcuTextureUtil.getTextureFormatInfo(texFmt); + /** @type {Array<number>} */ var cBias = fmtInfo.valueMin; + /** @type {Array<number>} */ var cScale = deMath.subtract(fmtInfo.valueMax, fmtInfo.valueMin); + + // Create textures. + this.m_gradientTex = gluTexture.cubeFromInternalFormat(gl, this.m_format, this.m_size); + this.m_gridTex = gluTexture.cubeFromInternalFormat(gl, this.m_format, this.m_size); + + // Fill first with gradient texture. + var gradients = [[[-1.0, -1.0, -1.0, 2.0], [1.0, 1.0, 1.0, 0.0]], // negative x + [[0.0, -1.0, -1.0, 2.0], [1.0, 1.0, 1.0, 0.0]], // positive x + [[-1.0, 0.0, -1.0, 2.0], [1.0, 1.0, 1.0, 0.0]], // negative y + [[-1.0, -1.0, 0.0, 2.0], [1.0, 1.0, 1.0, 0.0]], // positive y + [[-1.0, -1.0, -1.0, 0.0], [1.0, 1.0, 1.0, 1.0]], // negative z + [[0.0, 0.0, 0.0, 2.0], [1.0, 1.0, 1.0, 0.0]]]; // positive z + + for (var face in tcuTexture.CubeFace) { + for (var levelNdx = 0; levelNdx < numLevels; levelNdx++) { + this.m_gradientTex.getRefTexture().allocLevel(tcuTexture.CubeFace[face], levelNdx); + 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)); + } + } + + // Fill second with grid texture. + for (var face in tcuTexture.CubeFace) { + for (var levelNdx = 0; levelNdx < numLevels; levelNdx++) { + var step = 0x00ffffff / (numLevels * Object.keys(tcuTexture.CubeFace).length); + var rgb = step * levelNdx * face; + var colorA = 0xff000000 | rgb; + var colorB = 0xff000000 | ~rgb; + + this.m_gridTex.getRefTexture().allocLevel(tcuTexture.CubeFace[face], levelNdx); + 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)); + } + } + + // Upload. + this.m_gradientTex.upload(); + this.m_gridTex.upload(); + + var refInRangeUpper = (this.m_compareFunc == gl.EQUAL || this.m_compareFunc == gl.NOTEQUAL) ? 1.0 : 0.5; + var refInRangeLower = (this.m_compareFunc == gl.EQUAL || this.m_compareFunc == gl.NOTEQUAL) ? 0.0 : 0.5; + var refOutOfBoundsUpper = 1.1; + var refOutOfBoundsLower = -0.1; + var singleSample = new rrMultisamplePixelBufferAccess.MultisamplePixelBufferAccess().getNumSamples() == 0; + //var singleSample = this.m_context.getRenderTarget().getNumSamples() == 0; + + if (singleSample) + this.m_cases.push(new es3fTextureShadowTests.FilterCase(this.m_gradientTex, refInRangeUpper, [-1.25, -1.2], [1.2, 1.25])); // minification + else + 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 + + this.m_cases.push(new es3fTextureShadowTests.FilterCase(this.m_gradientTex, refInRangeLower, [0.8, 0.8], [1.25, 1.20])); // magnification + this.m_cases.push(new es3fTextureShadowTests.FilterCase(this.m_gridTex, refInRangeUpper, [-1.19, -1.3], [1.1, 1.35])); // minification + this.m_cases.push(new es3fTextureShadowTests.FilterCase(this.m_gridTex, refInRangeLower, [-1.2, -1.1], [-0.8, -0.8])); // magnification + this.m_cases.push(new es3fTextureShadowTests.FilterCase(this.m_gridTex, refOutOfBoundsUpper, [-0.61, -0.1], [0.9, 1.18])); // reference value clamp, upper + + if (singleSample) + this.m_cases.push(new es3fTextureShadowTests.FilterCase(this.m_gridTex, refOutOfBoundsLower, [-0.75, 1.0], [0.05, 0.75])); // reference value clamp, lower + else + this.m_cases.push(new es3fTextureShadowTests.FilterCase(this.m_gridTex, refOutOfBoundsLower, [-0.75, 1.0], [0.25, 0.75])); // reference value clamp, lower + + this.m_caseNdx = 0; + }; + + es3fTextureShadowTests.TextureCubeShadowCase.prototype.iterate = function() { + var viewportSize = 28; + var viewport = new glsTextureTestUtil.RandomViewport(document.getElementById('canvas'), viewportSize, viewportSize, deString.deStringHash(this.fullName()) ^ deMath.deMathHash(this.m_caseNdx)); + var curCase = this.m_cases[this.m_caseNdx]; + var sampleParams = new glsTextureTestUtil.ReferenceParams(glsTextureTestUtil.textureType.TEXTURETYPE_CUBE); + + if (viewport.width < viewportSize || viewport.height < viewportSize) + throw new Error('Too small render target'); + + // Setup texture + gl.bindTexture(gl.TEXTURE_CUBE_MAP, curCase.texture.getGLTexture()); + gl.texParameteri(gl.TEXTURE_CUBE_MAP, gl.TEXTURE_MIN_FILTER, this.m_minFilter); + gl.texParameteri(gl.TEXTURE_CUBE_MAP, gl.TEXTURE_MAG_FILTER, this.m_magFilter); + gl.texParameteri(gl.TEXTURE_CUBE_MAP, gl.TEXTURE_WRAP_S, this.m_wrapS); + gl.texParameteri(gl.TEXTURE_CUBE_MAP, gl.TEXTURE_WRAP_T, this.m_wrapT); + gl.texParameteri(gl.TEXTURE_CUBE_MAP, gl.TEXTURE_COMPARE_MODE, gl.COMPARE_REF_TO_TEXTURE); + gl.texParameteri(gl.TEXTURE_CUBE_MAP, gl.TEXTURE_COMPARE_FUNC, this.m_compareFunc); + + // Other state + gl.viewport(viewport.x, viewport.y, viewport.width, viewport.height); + + // Params for reference computation. + sampleParams.sampler = gluTextureUtil.mapGLSampler(gl.CLAMP_TO_EDGE, gl.CLAMP_TO_EDGE, gl.CLAMP_TO_EDGE, this.m_minFilter, this.m_magFilter); + sampleParams.sampler.seamlessCubeMap = true; + sampleParams.sampler.compare = gluTextureUtil.mapGLCompareFunc(this.m_compareFunc); + sampleParams.samplerType = glsTextureTestUtil.samplerType.SAMPLERTYPE_SHADOW; + sampleParams.lodMode = glsTextureTestUtil.lodMode.EXACT; + sampleParams.ref = curCase.ref; + + bufferedLogToConsole( + 'Compare reference value = ' + sampleParams.ref + '\n' + + 'Coordinates: ' + curCase.minCoord + ' -> ' + curCase.maxCoord); + + for (var faceNdx in tcuTexture.CubeFace) { + var face = tcuTexture.CubeFace[faceNdx]; + var result = new tcuSurface.Surface(viewport.width, viewport.height); + var texCoord = []; + + texCoord = glsTextureTestUtil.computeQuadTexCoordCubeFace(face, curCase.minCoord, curCase.maxCoord); + + this.m_renderer.renderQuad(0, texCoord, sampleParams); + + result.readViewport(gl, viewport); + + var pixelFormat = new tcuPixelFormat.PixelFormat(8, 8, 8, 8); + /** @type {tcuTexLookupVerifier.LodPrecision} */ var lodPrecision = new tcuTexLookupVerifier.LodPrecision(10, 5); + /** @type {tcuTexCompareVerifier.TexComparePrecision} */ var texComparePrecision = new tcuTexCompareVerifier.TexComparePrecision( + [10, 10, 10], + [6, 6, 0], + 5, + 16, + pixelFormat.redBits - 1 + ); + + var isHighQuality = es3fTextureShadowTests.verifyTexCompareResult(tcuTexture.TextureCube, result.getAccess(), curCase.texture.getRefTexture(), + texCoord, sampleParams, texComparePrecision, lodPrecision, pixelFormat); + + if (!isHighQuality) { + bufferedLogToConsole('Warning: Verification assuming high-quality PCF filtering failed.'); + + lodPrecision.lodBits = 4; + texComparePrecision.uvwBits = [4, 4, 0]; + texComparePrecision.pcfBits = 0; + + var isOk = es3fTextureShadowTests.verifyTexCompareResult(tcuTexture.TextureCube, result.getAccess(), curCase.texture.getRefTexture(), + texCoord, sampleParams, texComparePrecision, lodPrecision, pixelFormat); + if (!isOk) { + bufferedLogToConsole('ERROR: Verification against low precision requirements failed, failing test case.'); + testFailedOptions('Image verification failed', false); + } else + testPassedOptions('Low-quality result', true); + } + else + testPassedOptions('High-quality result', true); + } + + this.m_caseNdx += 1; + return this.m_caseNdx < this.m_cases.length ? tcuTestCase.IterateResult.CONTINUE : tcuTestCase.IterateResult.STOP; + }; + + /** + * Testure2DArrayShadowCase + * @constructor + * @extends {tcuTestCase.DeqpTest} + * @param {string} name + * @param {string} desc + * @param {number} minFilter + * @param {number} magFilter + * @param {number} wrapS + * @param {number} wrapT + * @param {number} format + * @param {number} width + * @param {number} height + * @param {number} numLayers + * @param {number} compareFunc + */ + es3fTextureShadowTests.Texture2DArrayShadowCase = function(name, desc, minFilter, magFilter, wrapS, wrapT, format, width, height, numLayers, compareFunc) { + tcuTestCase.DeqpTest.call(this, name, desc); + /** @type {number} */ this.m_minFilter = minFilter; + /** @type {number} */ this.m_magFilter = magFilter; + /** @type {number} */ this.m_wrapS = wrapS; + /** @type {number} */ this.m_wrapT = wrapT; + /** @type {number} */ this.m_format = format; + /** @type {number} */ this.m_width = width; + /** @type {number} */ this.m_height = height; + /** @type {number} */ this.m_numLayers = numLayers; + /** @type {number} */ this.m_compareFunc = compareFunc; + /** @type {?gluTexture.Texture2DArray} */ this.m_gradientTex = null; + /** @type {?gluTexture.Texture2DArray} */ this.m_gridTex = null; + /** @type {glsTextureTestUtil.TextureRenderer} */ this.m_renderer = new glsTextureTestUtil.TextureRenderer(es3fTextureShadowTests.version, gluShaderUtil.precision.PRECISION_HIGHP); + /** @type {Array<es3fTextureShadowTests.FilterCase>} */ this.m_cases = []; + /** @type {number} */ this.m_caseNdx = 0; + }; + + es3fTextureShadowTests.Texture2DArrayShadowCase.prototype = Object.create(tcuTestCase.DeqpTest.prototype); + es3fTextureShadowTests.Texture2DArrayShadowCase.prototype.constructor = es3fTextureShadowTests.Texture2DArrayShadowCase; + + /** + * init + */ + es3fTextureShadowTests.Texture2DArrayShadowCase.prototype.init = function() { + /** @type {tcuTexture.TextureFormat} */ var texFmt = gluTextureUtil.mapGLInternalFormat(this.m_format); + /** @type {tcuTextureUtil.TextureFormatInfo} */ var fmtInfo = tcuTextureUtil.getTextureFormatInfo(texFmt); + /** @type {Array<number>}*/ var cScale = deMath.subtract(fmtInfo.valueMax, fmtInfo.valueMin); + /** @type {Array<number>}*/ var cBias = fmtInfo.valueMin; + /** @type {number}*/ var numLevels = deMath.logToFloor(Math.max(this.m_width, this.m_height)) + 1; + + // Create textures. + this.m_gradientTex = gluTexture.texture2DArrayFromInternalFormat(gl, this.m_format, this.m_width, this.m_height, this.m_numLayers); + this.m_gridTex = gluTexture.texture2DArrayFromInternalFormat(gl, this.m_format, this.m_width, this.m_height, this.m_numLayers); + + // Fill first gradient texture. + for (var levelNdx = 0; levelNdx < numLevels; levelNdx++) { + /** @type {Array<number>}*/ var gMin = deMath.add(deMath.multiply([-0.5, -0.5, -0.5, 2.0], cScale), cBias); + /** @type {Array<number>}*/ var gMax = deMath.add(deMath.multiply([1.0, 1.0, 1.0, 0.0], cScale), cBias); + + this.m_gradientTex.getRefTexture().allocLevel(levelNdx); + tcuTextureUtil.fillWithComponentGradients( + /** @type {tcuTexture.PixelBufferAccess} */ (this.m_gradientTex.getRefTexture().getLevel(levelNdx)), gMin, gMax); + } + + // Fill second with grid texture. + for (var levelNdx = 0; levelNdx < numLevels; levelNdx++) { + /** @type {number}*/ var step = Math.floor(0x00ffffff / numLevels); + /** @type {number}*/ var rgb = step * levelNdx; + /** @type {number}*/ var colorA = deMath.binaryOp(0xff000000, rgb, deMath.BinaryOp.OR); + /** @type {number}*/ var colorB = deMath.binaryOp(0xff000000, deMath.binaryNot(rgb), deMath.BinaryOp.OR); + + this.m_gridTex.getRefTexture().allocLevel(levelNdx); + tcuTextureUtil.fillWithGrid( + /** @type {tcuTexture.PixelBufferAccess} */ (this.m_gridTex.getRefTexture().getLevel(levelNdx)), 4, + deMath.add(deMath.multiply(tcuRGBA.newRGBAFromValue(colorA).toVec(), cScale), cBias), + deMath.add(deMath.multiply(tcuRGBA.newRGBAFromValue(colorB).toVec(), cScale), cBias) + ); + } + + // Upload. + this.m_gradientTex.upload(); + this.m_gridTex.upload(); + + // Compute cases. + /** @type {number} */ var refInRangeUpper = (this.m_compareFunc == gl.EQUAL || this.m_compareFunc == gl.NOTEQUAL) ? 1.0 : 0.5; + /** @type {number} */ var refInRangeLower = (this.m_compareFunc == gl.EQUAL || this.m_compareFunc == gl.NOTEQUAL) ? 0.0 : 0.5; + /** @type {number} */ var refOutOfBoundsUpper = 1.1; // !< lookup function should clamp values to [0, 1] range + /** @type {number} */ var refOutOfBoundsLower = -0.1; + + /** @type {Array<{texNdx: number, ref: number, lodX: number, lodY: number, oX: number, oY: number}>} */ + 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 } + ]; + + var viewportW = Math.min(VIEWPORT_WIDTH, gl.canvas.width); + var viewportH = Math.min(VIEWPORT_HEIGHT, gl.canvas.height); + + /** @type {number} */ var minLayer = -0.5; + /** @type {number} */ var maxLayer = this.m_numLayers; + + for (var caseNdx = 0; caseNdx < cases.length; caseNdx++) { + var tex = cases[caseNdx].texNdx > 0 ? this.m_gridTex : this.m_gradientTex; + /** @type {number} */ var ref = cases[caseNdx].ref; + /** @type {number} */ var lodX = cases[caseNdx].lodX; + /** @type {number} */ var lodY = cases[caseNdx].lodY; + /** @type {number} */ var oX = cases[caseNdx].oX; + /** @type {number} */ var oY = cases[caseNdx].oY; + /** @type {number} */ var sX = Math.exp(lodX * Math.LN2) * viewportW / tex.getRefTexture().getWidth(); + /** @type {number} */ var sY = Math.exp(lodY * Math.LN2) * viewportH / tex.getRefTexture().getHeight(); + + this.m_cases.push(new es3fTextureShadowTests.FilterCase(tex, ref, [oX, oY, minLayer], [oX + sX, oY + sY, maxLayer])); + } + + this.m_caseNdx = 0; + }; + + /** + * @return {tcuTestCase.IterateResult} + */ + es3fTextureShadowTests.Texture2DArrayShadowCase.prototype.iterate = function() { + var viewport = new glsTextureTestUtil.RandomViewport(document.getElementById('canvas'), VIEWPORT_WIDTH, VIEWPORT_HEIGHT, deString.deStringHash(this.fullName()) ^ deMath.deMathHash(this.m_caseNdx)); + var curCase = this.m_cases[this.m_caseNdx]; + var sampleParams = new glsTextureTestUtil.ReferenceParams(glsTextureTestUtil.textureType.TEXTURETYPE_2D_ARRAY); + var rendered = new tcuSurface.Surface(viewport.width, viewport.height); + var texCoord = []; + + texCoord = [curCase.minCoord[0], curCase.minCoord[1], curCase.minCoord[2], + curCase.minCoord[0], curCase.maxCoord[1], (curCase.minCoord[2] + curCase.maxCoord[2]) / 2.0, + curCase.maxCoord[0], curCase.minCoord[1], (curCase.minCoord[2] + curCase.maxCoord[2]) / 2.0, + curCase.maxCoord[0], curCase.maxCoord[1], curCase.maxCoord[2]]; + + if (viewport.width < MIN_VIEWPORT_WIDTH || viewport.height < MIN_VIEWPORT_HEIGHT) + throw new Error('Too small render target'); + + sampleParams.sampler = gluTextureUtil.mapGLSamplerWrapST(this.m_wrapS, this.m_wrapT, this.m_minFilter, this.m_magFilter); + sampleParams.sampler.compare = gluTextureUtil.mapGLCompareFunc(this.m_compareFunc); + sampleParams.samplerType = glsTextureTestUtil.samplerType.SAMPLERTYPE_SHADOW; + sampleParams.lodMode = glsTextureTestUtil.lodMode.EXACT; + sampleParams.ref = curCase.ref; + + bufferedLogToConsole( + 'Compare reference value = ' + sampleParams.ref + '\n' + + 'Texture Coordinates: ' + curCase.minCoord + ' -> ' + curCase.maxCoord + ); + + gl.bindTexture(gl.TEXTURE_2D_ARRAY, curCase.texture.getGLTexture()); + gl.texParameteri(gl.TEXTURE_2D_ARRAY, gl.TEXTURE_MIN_FILTER, this.m_minFilter); + gl.texParameteri(gl.TEXTURE_2D_ARRAY, gl.TEXTURE_MAG_FILTER, this.m_magFilter); + gl.texParameteri(gl.TEXTURE_2D_ARRAY, gl.TEXTURE_WRAP_S, this.m_wrapS); + gl.texParameteri(gl.TEXTURE_2D_ARRAY, gl.TEXTURE_WRAP_T, this.m_wrapT); + gl.texParameteri(gl.TEXTURE_2D_ARRAY, gl.TEXTURE_COMPARE_MODE, gl.COMPARE_REF_TO_TEXTURE); + gl.texParameteri(gl.TEXTURE_2D_ARRAY, gl.TEXTURE_COMPARE_FUNC, this.m_compareFunc); + + gl.viewport(viewport.x, viewport.y, viewport.width, viewport.height); + this.m_renderer.renderQuad(0, texCoord, sampleParams); + rendered.readViewport(gl, viewport); + + var pixelFormat = new tcuPixelFormat.PixelFormat(8, 8, 8, 8); + /** @type {tcuTexLookupVerifier.LodPrecision} */ var lodPrecision = new tcuTexLookupVerifier.LodPrecision(18, 6); + /** @type {tcuTexCompareVerifier.TexComparePrecision} */ var texComparePrecision = new tcuTexCompareVerifier.TexComparePrecision( + [20, 20, 20], + [7, 7, 7], + 5, + 16, + pixelFormat.redBits - 1 + ); + + var isHighQuality = es3fTextureShadowTests.verifyTexCompareResult(tcuTexture.Texture2DArray, rendered.getAccess(), curCase.texture.getRefTexture(), + texCoord, sampleParams, texComparePrecision, lodPrecision, pixelFormat); + + if (!isHighQuality) { + bufferedLogToConsole('Warning: Verification assuming high-quality PCF filtering failed'); + + lodPrecision.lodBits = 4; + texComparePrecision.uvwBits = [4, 4, 4]; + texComparePrecision.pcfBits = 0; + + var isOk = es3fTextureShadowTests.verifyTexCompareResult(tcuTexture.Texture2DArray, rendered.getAccess(), curCase.texture.getRefTexture(), + texCoord, sampleParams, texComparePrecision, lodPrecision, pixelFormat); + + if (!isOk) { + bufferedLogToConsole('ERROR: Verification against low precision requirements failed, failing test case.'); + testFailedOptions('Image verification failed', false); + } else + testPassedOptions('Low-quality result', true); + } else + testPassedOptions('High-quality result', true); + + this.m_caseNdx += 1; + return this.m_caseNdx < this.m_cases.length ? tcuTestCase.IterateResult.CONTINUE : tcuTestCase.IterateResult.STOP; + }; + + es3fTextureShadowTests.init = function() { + /** @type {Array<es3fTextureShadowTests.Format>} */ var formats = []; + formats.push(new es3fTextureShadowTests.Format('depth_component16', gl.DEPTH_COMPONENT16)); + formats.push(new es3fTextureShadowTests.Format('depth_component32f', gl.DEPTH_COMPONENT32F)); + formats.push(new es3fTextureShadowTests.Format('depth24_stencil8', gl.DEPTH24_STENCIL8)); + + /** @type {Array<es3fTextureShadowTests.Filter>} */ var filters = []; + filters.push(new es3fTextureShadowTests.Filter('nearest', gl.NEAREST, gl.NEAREST)); + filters.push(new es3fTextureShadowTests.Filter('linear', gl.LINEAR, gl.LINEAR)); + filters.push(new es3fTextureShadowTests.Filter('nearest_mipmap_nearest', gl.NEAREST_MIPMAP_NEAREST, gl.LINEAR)); + filters.push(new es3fTextureShadowTests.Filter('linear_mipmap_nearest', gl.LINEAR_MIPMAP_NEAREST, gl.LINEAR)); + filters.push(new es3fTextureShadowTests.Filter('nearest_mipmap_linear', gl.NEAREST_MIPMAP_LINEAR, gl.LINEAR)); + filters.push(new es3fTextureShadowTests.Filter('linear_mipmap_linear', gl.LINEAR_MIPMAP_LINEAR, gl.LINEAR)); + + /** @type {Array<es3fTextureShadowTests.CompareFunc>} */ var compareFuncs = []; + compareFuncs.push(new es3fTextureShadowTests.CompareFunc('less_or_equal', gl.LEQUAL)); + compareFuncs.push(new es3fTextureShadowTests.CompareFunc('greater_or_equal', gl.GEQUAL)); + compareFuncs.push(new es3fTextureShadowTests.CompareFunc('less', gl.LESS)); + compareFuncs.push(new es3fTextureShadowTests.CompareFunc('greater', gl.GREATER)); + compareFuncs.push(new es3fTextureShadowTests.CompareFunc('equal', gl.EQUAL)); + compareFuncs.push(new es3fTextureShadowTests.CompareFunc('not_equal', gl.NOTEQUAL)); + compareFuncs.push(new es3fTextureShadowTests.CompareFunc('always', gl.ALWAYS)); + compareFuncs.push(new es3fTextureShadowTests.CompareFunc('never', gl.NEVER)); + + var state = tcuTestCase.runner; + /** @type {tcuTestCase.DeqpTest} */ var testGroup = state.testCases; + + for (var filterNdx = 0; filterNdx < filters.length; filterNdx++) { + for (var compareNdx = 0; compareNdx < compareFuncs.length; compareNdx++) { + var filterGroup = tcuTestCase.newTest( + '2d.' + filters[filterNdx].name, '2D texture shadow lookup tests'); + testGroup.addChild(filterGroup); + + for (var formatNdx = 0; formatNdx < formats.length; formatNdx++) { + /** @type {number} */ var minFilter = filters[filterNdx].minFilter; + /** @type {number} */ var magFilter = filters[filterNdx].magFilter; + /** @type {number} */ var format = formats[formatNdx].format; + /** @type {number} */ var compareFunc = compareFuncs[compareNdx].func; + /** @type {number} */ var wrapS = gl.REPEAT; + /** @type {number} */ var wrapT = gl.REPEAT; + /** @type {number} */ var width = 32; + /** @type {number} */ var height = 64; + /** @type {string} */ var name = compareFuncs[compareNdx].name + '_' + formats[formatNdx].name; + + filterGroup.addChild(new es3fTextureShadowTests.Texture2DShadowCase(name, '', minFilter, magFilter, wrapS, wrapT, format, width, height, compareFunc)); + } + } + } + + for (filterNdx = 0; filterNdx < filters.length; filterNdx++) { + for (compareNdx = 0; compareNdx < compareFuncs.length; compareNdx++) { + filterGroup = tcuTestCase.newTest( + 'cube.' + filters[filterNdx].name, 'Cube map texture shadow lookup tests'); + testGroup.addChild(filterGroup); + + for (formatNdx = 0; formatNdx < formats.length; formatNdx++) { + minFilter = filters[filterNdx].minFilter; + magFilter = filters[filterNdx].magFilter; + format = formats[formatNdx].format; + compareFunc = compareFuncs[compareNdx].func; + wrapS = gl.REPEAT; + wrapT = gl.REPEAT; + var size = 32; + name = compareFuncs[compareNdx].name + '_' + formats[formatNdx].name; + + filterGroup.addChild(new es3fTextureShadowTests.TextureCubeShadowCase(name, '', minFilter, magFilter, wrapS, wrapT, format, size, compareFunc)); + } + } + } + + for (var filterNdx = 0; filterNdx < filters.length; filterNdx++) { + for (var compareNdx = 0; compareNdx < compareFuncs.length; compareNdx++) { + filterGroup = tcuTestCase.newTest( + '2d_array.' + filters[filterNdx].name, '2D texture array shadow lookup tests'); + testGroup.addChild(filterGroup); + + for (var formatNdx = 0; formatNdx < formats.length; formatNdx++) { + minFilter = filters[filterNdx].minFilter; + magFilter = filters[filterNdx].magFilter; + format = formats[formatNdx].format; + compareFunc = compareFuncs[compareNdx].func; + wrapS = gl.REPEAT; + wrapT = gl.REPEAT; + width = 32; + height = 64; + var numLayers = 8; + name = compareFuncs[compareNdx].name + '_' + formats[formatNdx].name; + + filterGroup.addChild(new es3fTextureShadowTests.Texture2DArrayShadowCase(name, '', minFilter, magFilter, wrapS, wrapT, format, width, height, numLayers, compareFunc)); + } + } + } + }; + + es3fTextureShadowTests.run = function(context, range) { + gl = context; + //Set up Test Root parameters + var testName = 'texture_shadow'; + var testDescription = 'Texture Shadow Test'; + var state = tcuTestCase.runner; + + state.testName = testName; + state.testCases = tcuTestCase.newTest(testName, testDescription, null); + + //Set up name and description of this test series. + setCurrentTestName(testName); + description(testDescription); + + try { + //Create test cases + es3fTextureShadowTests.init(); + if (range) + state.setRange(range); + //Run test cases + tcuTestCase.runTestCases(); + } + catch (err) { + bufferedLogToConsole(err); + tcuTestCase.runner.terminate(); + } + }; +}); |