Source code
Revision control
Copy as Markdown
Other Tools
/*-------------------------------------------------------------------------
* 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
*
*
* 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();
}
};
});