diff options
Diffstat (limited to '')
| -rw-r--r-- | dom/canvas/test/webgl-conf/checkout/deqp/framework/common/tcuTexLookupVerifier.js | 2225 |
1 files changed, 2225 insertions, 0 deletions
diff --git a/dom/canvas/test/webgl-conf/checkout/deqp/framework/common/tcuTexLookupVerifier.js b/dom/canvas/test/webgl-conf/checkout/deqp/framework/common/tcuTexLookupVerifier.js new file mode 100644 index 0000000000..6b471998aa --- /dev/null +++ b/dom/canvas/test/webgl-conf/checkout/deqp/framework/common/tcuTexLookupVerifier.js @@ -0,0 +1,2225 @@ +/*------------------------------------------------------------------------- + * 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('framework.common.tcuTexLookupVerifier'); +goog.require('framework.common.tcuTexVerifierUtil'); +goog.require('framework.common.tcuTexture'); +goog.require('framework.common.tcuTextureUtil'); +goog.require('framework.delibs.debase.deMath'); + +goog.scope(function() { + + var tcuTexLookupVerifier = framework.common.tcuTexLookupVerifier; + var tcuTexture = framework.common.tcuTexture; + var tcuTextureUtil = framework.common.tcuTextureUtil; + var tcuTexVerifierUtil = framework.common.tcuTexVerifierUtil; + var deMath = framework.delibs.debase.deMath; + + /** @typedef {(tcuTexLookupVerifier.LookupPrecision|{tcuTexLookupVerifier.LookupPrecision})} */ + tcuTexLookupVerifier.PrecType; + + /** + * Generic lookup precision parameters + * @constructor + * @struct + * @param {Array<number>=} coordBits + * @param {Array<number>=} uvwBits + * @param {Array<number>=} colorThreshold + * @param {Array<boolean>=} colorMask + */ + tcuTexLookupVerifier.LookupPrecision = function(coordBits, uvwBits, colorThreshold, colorMask) { + /** @type {Array<number>} */ this.coordBits = coordBits || [22, 22, 22]; + /** @type {Array<number>} */ this.uvwBits = uvwBits || [16, 16, 16]; + /** @type {Array<number>} */ this.colorThreshold = colorThreshold || [0, 0, 0, 0]; + /** @type {Array<boolean>} */ this.colorMask = colorMask || [true, true, true, true]; + }; + + /** + * Lod computation precision parameters + * @constructor + * @struct + * @param {number=} derivateBits + * @param {number=} lodBits + */ + tcuTexLookupVerifier.LodPrecision = function(derivateBits, lodBits) { + /** @type {number} */ this.derivateBits = derivateBits === undefined ? 22 : derivateBits; + /** @type {number} */ this.lodBits = lodBits === undefined ? 16 : lodBits; + }; + + /** + * @enum {number} + */ + tcuTexLookupVerifier.TexLookupScaleMode = { + MINIFY: 0, + MAGNIFY: 1 + }; + + // Generic utilities + + /** + * @param {tcuTexture.Sampler} sampler + * @return {boolean} + */ + tcuTexLookupVerifier.isSamplerSupported = function(sampler) { + return sampler.compare == tcuTexture.CompareMode.COMPAREMODE_NONE && + tcuTexVerifierUtil.isWrapModeSupported(sampler.wrapS) && + tcuTexVerifierUtil.isWrapModeSupported(sampler.wrapT) && + tcuTexVerifierUtil.isWrapModeSupported(sampler.wrapR); + }; + + // Color read & compare utilities + + /** + * @param {tcuTexture.ConstPixelBufferAccess} access + * @param {number} x + * @param {number} y + * @param {number} z + * @return {boolean} + */ + tcuTexLookupVerifier.coordsInBounds = function(access, x, y, z) { + return deMath.deInBounds32(x, 0, access.getWidth()) && deMath.deInBounds32(y, 0, access.getHeight()) && deMath.deInBounds32(z, 0, access.getDepth()); + }; + + /** + * @param {tcuTexture.TextureFormat} format + * @return {boolean} + */ + tcuTexLookupVerifier.isSRGB = function(format) { + return format.order == tcuTexture.ChannelOrder.sRGB || format.order == tcuTexture.ChannelOrder.sRGBA; + }; + + /** + * @param {tcuTexture.ConstPixelBufferAccess} access + * @param {tcuTexture.Sampler} sampler + * @param {number} i + * @param {number} j + * @param {number} k + * @return {Array<number>} + */ + tcuTexLookupVerifier.lookupScalar = function(access, sampler, i, j, k) { + if (tcuTexLookupVerifier.coordsInBounds(access, i, j, k)) + return access.getPixel(i, j, k); + else + return deMath.toIVec(sampler.borderColor); + }; + + /** + * @param {tcuTexture.ConstPixelBufferAccess} access + * @param {tcuTexture.Sampler} sampler + * @param {number} i + * @param {number} j + * @param {number} k + * @return {Array<number>} + */ + tcuTexLookupVerifier.lookupFloat = function(access, sampler, i, j, k) { + // Specialization for float lookups: sRGB conversion is performed as specified in format. + if (tcuTexLookupVerifier.coordsInBounds(access, i, j, k)) { + /** @type {Array<number>} */ var p = access.getPixel(i, j, k); + return tcuTexLookupVerifier.isSRGB(access.getFormat()) ? tcuTextureUtil.sRGBToLinear(p) : p; + } else + return sampler.borderColor; + }; + /** + * @param {tcuTexLookupVerifier.LookupPrecision} prec + * @param {Array<number>} ref + * @param {Array<number>} result + * @return {boolean} + */ + tcuTexLookupVerifier.isColorValid = function(prec, ref, result) { + return deMath.boolAll( + deMath.logicalOrBool( + deMath.lessThanEqual(deMath.absDiff(ref, result), prec.colorThreshold), + deMath.logicalNotBool(prec.colorMask))); + }; + + /** + * @constructor + * @struct + * @param {Array<number>=} p00 + * @param {Array<number>=} p01 + * @param {Array<number>=} p10 + * @param {Array<number>=} p11 + */ + tcuTexLookupVerifier.ColorQuad = function(p00, p01, p10, p11) { + /** @type {Array<number>} */ this.p00 = p00 || null; //!< (0, 0) + /** @type {Array<number>} */ this.p01 = p01 || null; //!< (1, 0) + /** @type {Array<number>} */ this.p10 = p10 || null; //!< (0, 1) + /** @type {Array<number>} */ this.p11 = p11 || null; //!< (1, 1) + }; + + /** + * @param {tcuTexture.ConstPixelBufferAccess} level + * @param {tcuTexture.Sampler} sampler + * @param {number} x0 + * @param {number} x1 + * @param {number} y0 + * @param {number} y1 + * @param {number} z + * @return {tcuTexLookupVerifier.ColorQuad} + */ + tcuTexLookupVerifier.lookupQuad = function(level, sampler, x0, x1, y0, y1, z) { + var p00 = tcuTexLookupVerifier.lookupFloat(level, sampler, x0, y0, z); + var p10 = tcuTexLookupVerifier.lookupFloat(level, sampler, x1, y0, z); + var p01 = tcuTexLookupVerifier.lookupFloat(level, sampler, x0, y1, z); + var p11 = tcuTexLookupVerifier.lookupFloat(level, sampler, x1, y1, z); + return new tcuTexLookupVerifier.ColorQuad(p00, p01, p10, p11); + }; + + /** + * @constructor + * @struct + * @param {Array<number>=} p0 + * @param {Array<number>=} p1 + */ + tcuTexLookupVerifier.ColorLine = function(p0, p1) { + /** @type {Array<number>} */ this.p0 = p0 || null; //!< 0 + /** @type {Array<number>} */ this.p1 = p1 || null; //!< 1 + }; + + /** + * @param {tcuTexture.ConstPixelBufferAccess} level + * @param {tcuTexture.Sampler} sampler + * @param {number} x0 + * @param {number} x1 + * @param {number} y + * @return {tcuTexLookupVerifier.ColorLine} + */ + tcuTexLookupVerifier.lookupLine = function(level, sampler, x0, x1, y) { + return new tcuTexLookupVerifier.ColorLine( + tcuTexLookupVerifier.lookupFloat(level, sampler, x0, y, 0), + tcuTexLookupVerifier.lookupFloat(level, sampler, x1, y, 0) + ); + }; + + /** + * @param {Array<number>} vec + * @return {number} + */ + tcuTexLookupVerifier.minComp = function(vec) { + /** @type {number} */ var minVal = vec[0]; + for (var ndx = 1; ndx < vec.length; ndx++) + minVal = Math.min(minVal, vec[ndx]); + return minVal; + }; + + /** + * @param {Array<number>} vec + * @return {number} + */ + tcuTexLookupVerifier.maxComp = function(vec) { + /** @type {number} */ var maxVal = vec[0]; + for (var ndx = 1; ndx < vec.length; ndx++) + maxVal = Math.max(maxVal, vec[ndx]); + return maxVal; + }; + + /** + * @param {tcuTexLookupVerifier.LookupPrecision} prec + * @param {tcuTexLookupVerifier.ColorLine} line + * @return {number} + */ + tcuTexLookupVerifier.computeBilinearSearchStepFromFloatLine = function(prec, line) { + assertMsgOptions(deMath.boolAll(deMath.greaterThan(prec.colorThreshold, [0, 0, 0, 0])), 'Threshold not greater than 0.', false, true); + + /** @type {number} */ var maxSteps = 1 << 16; + /** @type {Array<number>} */ var d = deMath.absDiff(line.p1, line.p0); + /** @type {Array<number>} */ var stepCount = deMath.divide([d, d, d, d], prec.colorThreshold); + /** @type {Array<number>} */ + var minStep = deMath.divide([1, 1, 1, 1], deMath.add(stepCount, [1, 1, 1, 1])); + /** @type {number} */ var step = Math.max(tcuTexLookupVerifier.minComp(minStep), 1 / maxSteps); + + return step; + }; + + /** + * @param {tcuTexLookupVerifier.LookupPrecision} prec + * @param {tcuTexLookupVerifier.ColorQuad} quad + * @return {number} + */ + tcuTexLookupVerifier.computeBilinearSearchStepFromFloatQuad = function(prec, quad) { + assertMsgOptions(deMath.boolAll(deMath.greaterThan(prec.colorThreshold, [0, 0, 0, 0])), 'Threshold not greater than 0.', false, true); + + /** @type {number} */ var maxSteps = 1 << 16; + /** @type {Array<number>} */ var d0 = deMath.absDiff(quad.p10, quad.p00); + /** @type {Array<number>} */ var d1 = deMath.absDiff(quad.p01, quad.p00); + /** @type {Array<number>} */ var d2 = deMath.absDiff(quad.p11, quad.p10); + /** @type {Array<number>} */ var d3 = deMath.absDiff(quad.p11, quad.p01); + /** @type {Array<number>} */ var maxD = deMath.max(d0, deMath.max(d1, deMath.max(d2, d3))); + /** @type {Array<number>} */ var stepCount = deMath.divide(maxD, prec.colorThreshold); + /** @type {Array<number>} */ var minStep = deMath.divide([1, 1, 1, 1], deMath.add(stepCount, [1, 1, 1, 1])); + /** @type {number} */ var step = Math.max(tcuTexLookupVerifier.minComp(minStep), 1 / maxSteps); + + return step; + }; + + /** + * @param {tcuTexLookupVerifier.LookupPrecision} prec + * @return {number} + */ + tcuTexLookupVerifier.computeBilinearSearchStepForUnorm = function(prec) { + assertMsgOptions(deMath.boolAll(deMath.greaterThan(prec.colorThreshold, [0, 0, 0, 0])), 'Threshold not greater than 0.', false, true); + + /** @type {Array<number>} */ var stepCount = deMath.divide([1, 1, 1, 1], prec.colorThreshold); + /** @type {Array<number>} */ var minStep = deMath.divide([1, 1, 1, 1], (deMath.add(stepCount, [1, 1, 1, 1]))); + /** @type {number} */ var step = tcuTexLookupVerifier.minComp(minStep); + + return step; + }; + + /** + * @param {tcuTexLookupVerifier.LookupPrecision} prec + * @return {number} + */ + tcuTexLookupVerifier.computeBilinearSearchStepForSnorm = function(prec) { + assertMsgOptions(deMath.boolAll(deMath.greaterThan(prec.colorThreshold, [0, 0, 0, 0])), 'Threshold not greater than 0.', false, true); + + /** @type {Array<number>} */ var stepCount = deMath.divide([2.0, 2.0, 2.0, 2.0], prec.colorThreshold); + /** @type {Array<number>} */ var minStep = deMath.divide([1, 1, 1, 1], deMath.add(stepCount, [1, 1, 1, 1])); + /** @type {number} */ var step = tcuTexLookupVerifier.minComp(minStep); + + return step; + }; + + /** + * @param {tcuTexLookupVerifier.ColorLine} line + * @return {Array<number>} + */ + tcuTexLookupVerifier.minLine = function(line) { + return deMath.min(line.p0, line.p1); + }; + + /** + * @param {tcuTexLookupVerifier.ColorLine} line + * @return {Array<number>} + */ + tcuTexLookupVerifier.maxLine = function(line) { + var max = deMath.max; + return max(line.p0, line.p1); + }; + + /** + * @param {tcuTexLookupVerifier.ColorQuad} quad + * @return {Array<number>} + */ + tcuTexLookupVerifier.minQuad = function(quad) { + var min = deMath.min; + return min(quad.p00, min(quad.p10, min(quad.p01, quad.p11))); + }; + + /** + * @param {tcuTexLookupVerifier.ColorQuad} quad + * @return {Array<number>} + */ + tcuTexLookupVerifier.maxQuad = function(quad) { + var max = deMath.max; + return max(quad.p00, max(quad.p10, max(quad.p01, quad.p11))); + }; + + /** + * @param {tcuTexLookupVerifier.LookupPrecision} prec + * @param {tcuTexLookupVerifier.ColorQuad} quad + * @param {Array<number>} result + * @return {boolean} + */ + tcuTexLookupVerifier.isInColorBounds_1Quad = function(prec, quad, result) { + var quadMin = tcuTexLookupVerifier.minQuad; + var quadMax = tcuTexLookupVerifier.maxQuad; + /** @type {Array<number>} */ var minVal = deMath.subtract(quadMin(quad), prec.colorThreshold); + /** @type {Array<number>} */ var maxVal = deMath.add(quadMax(quad), prec.colorThreshold); + return deMath.boolAll( + deMath.logicalOrBool( + deMath.logicalAndBool( + deMath.greaterThanEqual(result, minVal), + deMath.lessThanEqual(result, maxVal)), + deMath.logicalNotBool(prec.colorMask))); + }; + + /** + * @param {tcuTexLookupVerifier.LookupPrecision} prec + * @param {tcuTexLookupVerifier.ColorQuad} quad0 + * @param {tcuTexLookupVerifier.ColorQuad} quad1 + * @param {Array<number>} result + * @return {boolean} + */ + tcuTexLookupVerifier.isInColorBounds_2Quad = function(prec, quad0, quad1, result) { + var min = deMath.min; + var max = deMath.max; + var quadMin = tcuTexLookupVerifier.minQuad; + var quadMax = tcuTexLookupVerifier.maxQuad; + /** @type {Array<number>} */ var minVal = deMath.subtract(min(quadMin(quad0), quadMin(quad1)), prec.colorThreshold); + /** @type {Array<number>} */ var maxVal = deMath.add(max(quadMax(quad0), quadMax(quad1)), prec.colorThreshold); + return deMath.boolAll( + deMath.logicalOrBool( + deMath.logicalAndBool( + deMath.greaterThanEqual(result, minVal), + deMath.lessThanEqual(result, maxVal)), + deMath.logicalNotBool(prec.colorMask))); + }; + + /** + * @param {tcuTexLookupVerifier.LookupPrecision} prec + * @param {tcuTexLookupVerifier.ColorLine} line0 + * @param {tcuTexLookupVerifier.ColorLine} line1 + * @param {Array<number>} result + * @return {boolean} + */ + tcuTexLookupVerifier.isInColorBounds_2Line = function(prec, line0, line1, result) { + var min = deMath.min; + var max = deMath.max; + var lineMin = tcuTexLookupVerifier.minLine; + var lineMax = tcuTexLookupVerifier.maxLine; + /** @type {Array<number>} */ var minVal = deMath.subtract(min(lineMin(line0), lineMin(line1)), prec.colorThreshold); + /** @type {Array<number>} */ var maxVal = deMath.add(max(lineMax(line0), lineMax(line1)), prec.colorThreshold); + return deMath.boolAll( + deMath.logicalOrBool( + deMath.logicalAndBool( + deMath.greaterThanEqual(result, minVal), + deMath.lessThanEqual(result, maxVal)), + deMath.logicalNotBool(prec.colorMask))); + }; + + /** + * @param {tcuTexLookupVerifier.LookupPrecision} prec + * @param {tcuTexLookupVerifier.ColorQuad} quad00 + * @param {tcuTexLookupVerifier.ColorQuad} quad01 + * @param {tcuTexLookupVerifier.ColorQuad} quad10 + * @param {tcuTexLookupVerifier.ColorQuad} quad11 + * @param {Array<number>} result + * @return {boolean} + */ + tcuTexLookupVerifier.isInColorBounds_4Quad = function(prec, quad00, quad01, quad10, quad11, result) { + var min = deMath.min; + var max = deMath.max; + var quadMin = tcuTexLookupVerifier.minQuad; + var quadMax = tcuTexLookupVerifier.maxQuad; + /** @type {Array<number>} */ var minVal = deMath.subtract(min(quadMin(quad00), min(quadMin(quad01), min(quadMin(quad10), quadMin(quad11)))), prec.colorThreshold); + /** @type {Array<number>} */ var maxVal = deMath.add(max(quadMax(quad00), max(quadMax(quad01), max(quadMax(quad10), quadMax(quad11)))), prec.colorThreshold); + return deMath.boolAll( + deMath.logicalOrBool( + deMath.logicalAndBool( + deMath.greaterThanEqual(result, minVal), + deMath.lessThanEqual(result, maxVal)), + deMath.logicalNotBool(prec.colorMask))); + }; + + // Range search utilities + + /** + * @param {tcuTexLookupVerifier.LookupPrecision} prec + * @param {Array<number>} c0 + * @param {Array<number>} c1 + * @param {Array<number>} fBounds + * @param {Array<number>} result + * @return {boolean} + */ + tcuTexLookupVerifier.isLinearRangeValid = function(prec, c0, c1, fBounds, result) { + // This is basically line segment - AABB test. Valid interpolation line is checked + // against result AABB constructed by applying threshold. + + /** @type {Array<number>} */ var rMin = deMath.subtract(result, prec.colorThreshold); + /** @type {Array<number>} */ var rMax = deMath.add(result, prec.colorThreshold); + + // Algorithm: For each component check whether segment endpoints are inside, or intersect with slab. + // If all intersect or are inside, line segment intersects the whole 4D AABB. + for (var compNdx = 0; compNdx < 4; compNdx++) { + if (!prec.colorMask[compNdx]) + continue; + + /** @type {number} */ var i0 = c0[compNdx] * (1 - fBounds[0]) + c1[compNdx] * fBounds[0]; + /** @type {number} */ var i1 = c0[compNdx] * (1 - fBounds[1]) + c1[compNdx] * fBounds[1]; + if ((i0 > rMax[compNdx] && i1 > rMax[compNdx]) || + (i0 < rMin[compNdx] && i1 < rMin[compNdx])) { + return false; + } + } + + return true; + }; + + /** + * @param {tcuTexLookupVerifier.LookupPrecision} prec + * @param {tcuTexLookupVerifier.ColorQuad} quad + * @param {Array<number>} xBounds + * @param {Array<number>} yBounds + * @param {number} searchStep + * @param {Array<number>} result + * @return {boolean} + */ + tcuTexLookupVerifier.isBilinearRangeValid = function(prec, quad, xBounds, yBounds, searchStep, result) { + assertMsgOptions(xBounds[0] <= xBounds[1], 'Out of bounds: X direction.', false, true); + assertMsgOptions(yBounds[0] <= yBounds[1], 'Out of bounds: Y direction.', false, true); + + if (!tcuTexLookupVerifier.isInColorBounds_1Quad(prec, quad, result)) + return false; + + for (var x = xBounds[0]; x < xBounds[1] + searchStep; x += searchStep) { + /** @type {number} */ var a = Math.min(x, xBounds[1]); + /** @type {Array<number>} */ var c0 = deMath.add(deMath.scale(quad.p00, (1 - a)), deMath.scale(quad.p10, a)); + /** @type {Array<number>} */ var c1 = deMath.add(deMath.scale(quad.p01, (1 - a)), deMath.scale(quad.p11, a)); + + if (tcuTexLookupVerifier.isLinearRangeValid(prec, c0, c1, yBounds, result)) + return true; + } + + return false; + }; + + /** + * @param {tcuTexLookupVerifier.LookupPrecision} prec + * @param {tcuTexLookupVerifier.ColorQuad} quad0 + * @param {tcuTexLookupVerifier.ColorQuad} quad1 + * @param {Array<number>} xBounds + * @param {Array<number>} yBounds + * @param {Array<number>} zBounds + * @param {number} searchStep + * @param {Array<number>} result + * @return {boolean} + */ + tcuTexLookupVerifier.isTrilinearRangeValid = function(prec, quad0, quad1, xBounds, yBounds, zBounds, searchStep, result) { + assertMsgOptions(xBounds[0] <= xBounds[1], 'Out of bounds: X direction.', false, true); + assertMsgOptions(yBounds[0] <= yBounds[1], 'Out of bounds: Y direction.', false, true); + assertMsgOptions(zBounds[0] <= zBounds[1], 'Out of bounds: Z direction.', false, true); + + if (!tcuTexLookupVerifier.isInColorBounds_2Quad(prec, quad0, quad1, result)) + return false; + + for (var x = xBounds[0]; x < xBounds[1] + searchStep; x += searchStep) { + for (var y = yBounds[0]; y < yBounds[1] + searchStep; y += searchStep) { + /** @type {number} */ var a = Math.min(x, xBounds[1]); + /** @type {number} */ var b = Math.min(y, yBounds[1]); + /** @type {Array<number>} */ + var c0 = deMath.add( + deMath.add( + deMath.add( + deMath.scale(quad0.p00, (1 - a) * (1 - b)), + deMath.scale(quad0.p10, a * (1 - b))), + deMath.scale(quad0.p01, (1 - a) * b)), + deMath.scale(quad0.p11, a * b)); + /** @type {Array<number>} */ + var c1 = deMath.add( + deMath.add( + deMath.add( + deMath.scale(quad1.p00, (1 - a) * (1 - b)), + deMath.scale(quad1.p10, a * (1 - b))), + deMath.scale(quad1.p01, (1 - a) * b)), + deMath.scale(quad1.p11, a * b)); + + if (tcuTexLookupVerifier.isLinearRangeValid(prec, c0, c1, zBounds, result)) + return true; + } + } + + return false; + }; + + /** + * @param {tcuTexLookupVerifier.LookupPrecision} prec + * @param {tcuTexLookupVerifier.ColorQuad} quad0 + * @param {tcuTexLookupVerifier.ColorQuad} quad1 + * @param {Array<number>} xBounds0 + * @param {Array<number>} yBounds0 + * @param {Array<number>} xBounds1 + * @param {Array<number>} yBounds1 + * @param {Array<number>} zBounds + * @param {number} searchStep + * @param {Array<number>} result + * @return {boolean} + */ + tcuTexLookupVerifier.is2DTrilinearFilterResultValid = function(prec, quad0, quad1, xBounds0, yBounds0, xBounds1, yBounds1, zBounds, searchStep, result) { + assertMsgOptions(xBounds0[0] <= xBounds0[1], 'Out of bounds: X direction.', false, true); + assertMsgOptions(yBounds0[0] <= yBounds0[1], 'Out of bounds: Y direction.', false, true); + assertMsgOptions(xBounds1[0] <= xBounds1[1], 'Out of bounds: X direction.', false, true); + assertMsgOptions(yBounds1[0] <= yBounds1[1], 'Out of bounds: Y direction.', false, true); + + if (!tcuTexLookupVerifier.isInColorBounds_2Quad(prec, quad0, quad1, result)) + return false; + + for (var x0 = xBounds0[0]; x0 < xBounds0[1] + searchStep; x0 += searchStep) { + for (var y0 = yBounds0[0]; y0 < yBounds0[1] + searchStep; y0 += searchStep) { + /** @type {number} */ var a0 = Math.min(x0, xBounds0[1]); + /** @type {number} */ var b0 = Math.min(y0, yBounds0[1]); + /** @type {Array<number>} */ + var c0 = deMath.add( + deMath.add( + deMath.add( + deMath.scale(quad0.p00, (1 - a0) * (1 - b0)), + deMath.scale(quad0.p10, a0 * (1 - b0))), + deMath.scale(quad0.p01, (1 - a0) * b0)), + deMath.scale(quad0.p11, a0 * b0)); + + for (var x1 = xBounds1[0]; x1 <= xBounds1[1]; x1 += searchStep) { + for (var y1 = yBounds1[0]; y1 <= yBounds1[1]; y1 += searchStep) { + /** @type {number} */ var a1 = Math.min(x1, xBounds1[1]); + /** @type {number} */ var b1 = Math.min(y1, yBounds1[1]); + /** @type {Array<number>} */ + var c1 = deMath.add( + deMath.add( + deMath.add( + deMath.scale(quad1.p00, (1 - a1) * (1 - b1)), + deMath.scale(quad1.p10, a1 * (1 - b1))), + deMath.scale(quad1.p01, (1 - a1) * b1)), + deMath.scale(quad1.p11, a1 * b1)); + + if (tcuTexLookupVerifier.isLinearRangeValid(prec, c0, c1, zBounds, result)) + return true; + } + } + } + } + + return false; + }; + + /** + * @param {tcuTexLookupVerifier.LookupPrecision} prec + * @param {tcuTexLookupVerifier.ColorQuad} quad00 + * @param {tcuTexLookupVerifier.ColorQuad} quad01 + * @param {tcuTexLookupVerifier.ColorQuad} quad10 + * @param {tcuTexLookupVerifier.ColorQuad} quad11 + * @param {Array<number>} xBounds0 + * @param {Array<number>} yBounds0 + * @param {Array<number>} zBounds0 + * @param {Array<number>} xBounds1 + * @param {Array<number>} yBounds1 + * @param {Array<number>} zBounds1 + * @param {Array<number>} wBounds + * @param {number} searchStep + * @param {Array<number>} result + * @return {boolean} + */ + tcuTexLookupVerifier.is3DTrilinearFilterResultValid = function(prec, quad00, quad01, quad10, quad11, xBounds0, yBounds0, zBounds0, xBounds1, yBounds1, zBounds1, wBounds, searchStep, result) { + assertMsgOptions(xBounds0[0] <= xBounds0[1], 'Out of bounds: X direction.', false, true); + assertMsgOptions(yBounds0[0] <= yBounds0[1], 'Out of bounds: Y direction.', false, true); + assertMsgOptions(zBounds0[0] <= zBounds0[1], 'Out of bounds: Z direction.', false, true); + assertMsgOptions(xBounds1[0] <= xBounds1[1], 'Out of bounds: X direction.', false, true); + assertMsgOptions(yBounds1[0] <= yBounds1[1], 'Out of bounds: Y direction.', false, true); + assertMsgOptions(zBounds1[0] <= zBounds1[1], 'Out of bounds: Z direction.', false, true); + + if (!tcuTexLookupVerifier.isInColorBounds_4Quad(prec, quad00, quad01, quad10, quad11, result)) + return false; + + function biInterp(result, p00, p01, p10, p11, s00, s01, s10, s11) { + for (var ii = 0; ii < 4; ++ii) { + result[ii] = p00[ii] * s00 + p10[ii] * s10 + p01[ii] * s01 + p11[ii] * s11; + } + } + + function interp(result, p0, p1, s) { + for (var ii = 0; ii < 4; ++ii) { + result[ii] = p0[ii] * (1 - s) + p1[ii] * s; + } + } + + /** @type {Array<number>} */ var c00 = [0, 0, 0, 0]; + /** @type {Array<number>} */ var c01 = [0, 0, 0, 0]; + /** @type {Array<number>} */ var c10 = [0, 0, 0, 0]; + /** @type {Array<number>} */ var c11 = [0, 0, 0, 0]; + /** @type {Array<number>} */ var cz0 = [0, 0, 0, 0]; + /** @type {Array<number>} */ var cz1 = [0, 0, 0, 0]; + + for (var x0 = xBounds0[0]; x0 < xBounds0[1] + searchStep; x0 += searchStep) { + for (var y0 = yBounds0[0]; y0 < yBounds0[1] + searchStep; y0 += searchStep) { + /** @type {number} */ var a0 = Math.min(x0, xBounds0[1]); + /** @type {number} */ var b0 = Math.min(y0, yBounds0[1]); + + /** @type {number} */ var s00 = (1 - a0) * (1 - b0); + /** @type {number} */ var s01 = (1 - a0) * b0; + /** @type {number} */ var s10 = a0 * (1 - b0); + /** @type {number} */ var s11 = a0 * b0; + + biInterp(c00, quad00.p00, quad00.p01, quad00.p10, quad00.p11, s00, s01, s10, s11); + biInterp(c01, quad01.p00, quad01.p01, quad01.p10, quad01.p11, s00, s01, s10, s11); + + for (var z0 = zBounds0[0]; z0 < zBounds0[1] + searchStep; z0 += searchStep) { + /** @type {number} */ var c0 = Math.min(z0, zBounds0[1]); + interp(cz0, c00, c01, c0); + + for (var x1 = xBounds1[0]; x1 < xBounds1[1] + searchStep; x1 += searchStep) { + for (var y1 = yBounds1[0]; y1 < yBounds1[1] + searchStep; y1 += searchStep) { + /** @type {number} */ var a1 = Math.min(x1, xBounds1[1]); + /** @type {number} */ var b1 = Math.min(y1, yBounds1[1]); + + /** @type {number} */ var t00 = (1 - a1) * (1 - b1); + /** @type {number} */ var t01 = (1 - a1) * b1; + /** @type {number} */ var t10 = a1 * (1 - b1); + /** @type {number} */ var t11 = a1 * b1; + + biInterp(c10, quad10.p00, quad10.p01, quad10.p10, quad10.p11, t00, t01, t10, t11); + biInterp(c11, quad11.p00, quad11.p01, quad11.p10, quad11.p11, t00, t01, t10, t11); + + for (var z1 = zBounds1[0]; z1 < zBounds1[1] + searchStep; z1 += searchStep) { + /** @type {number} */ var c1 = Math.min(z1, zBounds1[1]); + interp(cz1, c10, c11, c1); + + if (tcuTexLookupVerifier.isLinearRangeValid(prec, cz0, cz1, wBounds, result)) + return true; + } + } + } + } + } + } + + return false; + }; + + /** + * @param {tcuTexture.ConstPixelBufferAccess} level + * @param {tcuTexture.Sampler} sampler + * @param {tcuTexLookupVerifier.LookupPrecision} prec + * @param {number} coordX + * @param {number} coordY + * @param {Array<number>} result + * @return {boolean} + */ + tcuTexLookupVerifier.isNearestSampleResultValid_CoordXYAsNumber = function(level, sampler, prec, coordX, coordY, result) { + assertMsgOptions(level.getDepth() == 1, 'Depth must be 1.', false, true); + + /** @type {Array<number>} */ + var uBounds = tcuTexVerifierUtil.computeNonNormalizedCoordBounds( + sampler.normalizedCoords, level.getWidth(), coordX, prec.coordBits[0], prec.uvwBits[0]); + + /** @type {number} */ var minI = Math.floor(uBounds[0]); + /** @type {number} */ var maxI = Math.floor(uBounds[1]); + + for (var i = minI; i <= maxI; i++) { + /** @type {number} */ var x = tcuTexVerifierUtil.wrap(sampler.wrapS, i, level.getWidth()); + /** @type {Array<number>} */ var color; + if (tcuTexLookupVerifier.isSRGB(level.getFormat())) { + color = tcuTexLookupVerifier.lookupFloat(level, sampler, x, coordY, 0); + } else { + color = tcuTexLookupVerifier.lookupScalar(level, sampler, x, coordY, 0); + } + + if (tcuTexLookupVerifier.isColorValid(prec, color, result)) + return true; + } + + return false; + }; + + /** + * @param {tcuTexture.ConstPixelBufferAccess} level + * @param {tcuTexture.Sampler} sampler + * @param {tcuTexLookupVerifier.LookupPrecision} prec + * @param {Array<number>} coord vec2 + * @param {number} coordZ int + * @param {Array<number>} result + * @return {boolean} + */ + tcuTexLookupVerifier.isNearestSampleResultValid_CoordAsVec2AndInt = function(level, sampler, prec, coord, coordZ, result) { + /** @type {Array<number>} */ + var uBounds = tcuTexVerifierUtil.computeNonNormalizedCoordBounds( + sampler.normalizedCoords, level.getWidth(), coord[0], prec.coordBits[0], prec.uvwBits[0]); + /** @type {Array<number>} */ + var vBounds = tcuTexVerifierUtil.computeNonNormalizedCoordBounds( + sampler.normalizedCoords, level.getHeight(), coord[1], prec.coordBits[1], prec.uvwBits[1]); + + // Integer coordinates - without wrap mode + /** @type {number} */ var minI = Math.floor(uBounds[0]); + /** @type {number} */ var maxI = Math.floor(uBounds[1]); + /** @type {number} */ var minJ = Math.floor(vBounds[0]); + /** @type {number} */ var maxJ = Math.floor(vBounds[1]); + + // \todo [2013-07-03 pyry] This could be optimized by first computing ranges based on wrap mode. + + for (var j = minJ; j <= maxJ; j++) + for (var i = minI; i <= maxI; i++) { + /** @type {number} */ var x = tcuTexVerifierUtil.wrap(sampler.wrapS, i, level.getWidth()); + /** @type {number} */ var y = tcuTexVerifierUtil.wrap(sampler.wrapT, j, level.getHeight()); + /** @type {Array<number>} */ var color; + if (tcuTexLookupVerifier.isSRGB(level.getFormat())) { + color = tcuTexLookupVerifier.lookupFloat(level, sampler, x, y, coordZ); + } else { + color = tcuTexLookupVerifier.lookupScalar(level, sampler, x, y, coordZ); + } + + if (tcuTexLookupVerifier.isColorValid(prec, color, result)) + return true; + } + + return false; + }; + + /** + * @param {tcuTexture.ConstPixelBufferAccess} level + * @param {tcuTexture.Sampler} sampler + * @param {tcuTexLookupVerifier.LookupPrecision} prec + * @param {Array<number>} coord vec3 + * @param {Array<number>} result + * @return {boolean} + */ + tcuTexLookupVerifier.isNearestSampleResultValid_CoordAsVec3 = function(level, sampler, prec, coord, result) { + /** @type {Array<number>} */ + var uBounds = tcuTexVerifierUtil.computeNonNormalizedCoordBounds( + sampler.normalizedCoords, level.getWidth(), coord[0], prec.coordBits[0], prec.uvwBits[0]); + /** @type {Array<number>} */ + var vBounds = tcuTexVerifierUtil.computeNonNormalizedCoordBounds( + sampler.normalizedCoords, level.getHeight(), coord[1], prec.coordBits[1], prec.uvwBits[1]); + /** @type {Array<number>} */ + var wBounds = tcuTexVerifierUtil.computeNonNormalizedCoordBounds( + sampler.normalizedCoords, level.getDepth(), coord[2], prec.coordBits[2], prec.uvwBits[2]); + + // Integer coordinates - without wrap mode + /** @type {number} */ var minI = Math.floor(uBounds[0]); + /** @type {number} */ var maxI = Math.floor(uBounds[1]); + /** @type {number} */ var minJ = Math.floor(vBounds[0]); + /** @type {number} */ var maxJ = Math.floor(vBounds[1]); + /** @type {number} */ var minK = Math.floor(wBounds[0]); + /** @type {number} */ var maxK = Math.floor(wBounds[1]); + + // \todo [2013-07-03 pyry] This could be optimized by first computing ranges based on wrap mode. + + for (var k = minK; k <= maxK; k++) { + for (var j = minJ; j <= maxJ; j++) { + for (var i = minI; i <= maxI; i++) { + /** @type {number} */ var x = tcuTexVerifierUtil.wrap(sampler.wrapS, i, level.getWidth()); + /** @type {number} */ var y = tcuTexVerifierUtil.wrap(sampler.wrapT, j, level.getHeight()); + /** @type {number} */ var z = tcuTexVerifierUtil.wrap(sampler.wrapR, k, level.getDepth()); + /** @type {Array<number>} */ var color; + if (tcuTexLookupVerifier.isSRGB(level.getFormat())) { + color = tcuTexLookupVerifier.lookupFloat(level, sampler, x, y, z); + } else { + color = tcuTexLookupVerifier.lookupScalar(level, sampler, x, y, z); + } + + if (tcuTexLookupVerifier.isColorValid(prec, color, result)) + return true; + } + } + } + + return false; + }; + + /** + * @param {tcuTexture.ConstPixelBufferAccess} level + * @param {tcuTexture.Sampler} sampler + * @param {tcuTexLookupVerifier.LookupPrecision} prec + * @param {number} coordX + * @param {number} coordY + * @param {Array<number>} result + * @return {boolean} + */ + tcuTexLookupVerifier.isLinearSampleResultValid_CoordXYAsNumber = function(level, sampler, prec, coordX, coordY, result) { + /** @type {Array<number>} */ var uBounds = tcuTexVerifierUtil.computeNonNormalizedCoordBounds(sampler.normalizedCoords, level.getWidth(), coordX, prec.coordBits[0], prec.uvwBits[0]); + + /** @type {number} */ var minI = Math.floor(uBounds[0] - 0.5); + /** @type {number} */ var maxI = Math.floor(uBounds[1] - 0.5); + + /** @type {number} */ var w = level.getWidth(); + + for (var i = minI; i <= maxI; i++) { + // Wrapped coordinates + /** @type {number} */ var x0 = tcuTexVerifierUtil.wrap(sampler.wrapS, i, w); + /** @type {number} */ var x1 = tcuTexVerifierUtil.wrap(sampler.wrapS, i + 1, w); + + // Bounds for filtering factors + /** @type {number} */ var minA = deMath.clamp((uBounds[0] - 0.5) - i, 0, 1); + /** @type {number} */ var maxA = deMath.clamp((uBounds[1] - 0.5) - i, 0, 1); + + /** @type {Array<number>} */ var colorA = tcuTexLookupVerifier.lookupFloat(level, sampler, x0, coordY, 0); + /** @type {Array<number>} */ var colorB = tcuTexLookupVerifier.lookupFloat(level, sampler, x1, coordY, 0); + + if (tcuTexLookupVerifier.isLinearRangeValid(prec, colorA, colorB, [minA, maxA], result)) + return true; + } + + return false; + }; + + /** + * @param {tcuTexture.ConstPixelBufferAccess} level + * @param {tcuTexture.Sampler} sampler + * @param {tcuTexLookupVerifier.LookupPrecision} prec + * @param {Array<number>} coord vec2 + * @param {number} coordZ int + * @param {Array<number>} result + * @return {boolean} + */ + tcuTexLookupVerifier.isLinearSampleResultValid_CoordAsVec2AndInt = function(level, sampler, prec, coord, coordZ, result) { + /** @type {Array<number>} */ var uBounds = tcuTexVerifierUtil.computeNonNormalizedCoordBounds(sampler.normalizedCoords, level.getWidth(), coord[0], prec.coordBits[0], prec.uvwBits[0]); + /** @type {Array<number>} */ var vBounds = tcuTexVerifierUtil.computeNonNormalizedCoordBounds(sampler.normalizedCoords, level.getHeight(), coord[1], prec.coordBits[1], prec.uvwBits[1]); + + // Integer coordinate bounds for (x0,y0) - without wrap mode + /** @type {number} */ var minI = Math.floor(uBounds[0] - 0.5); + /** @type {number} */ var maxI = Math.floor(uBounds[1] - 0.5); + /** @type {number} */ var minJ = Math.floor(vBounds[0] - 0.5); + /** @type {number} */ var maxJ = Math.floor(vBounds[1] - 0.5); + + /** @type {number} */ var w = level.getWidth(); + /** @type {number} */ var h = level.getHeight(); + + /** @type {tcuTexture.TextureChannelClass} */ + var texClass = tcuTexture.getTextureChannelClass(level.getFormat().type); + + /** @type {number} */ + var searchStep = (texClass == tcuTexture.TextureChannelClass.UNSIGNED_FIXED_POINT) ? tcuTexLookupVerifier.computeBilinearSearchStepForUnorm(prec) : + (texClass == tcuTexture.TextureChannelClass.SIGNED_FIXED_POINT) ? tcuTexLookupVerifier.computeBilinearSearchStepForSnorm(prec) : + 0; // Step is computed for floating-point quads based on texel values. + + // \todo [2013-07-03 pyry] This could be optimized by first computing ranges based on wrap mode. + + for (var j = minJ; j <= maxJ; j++) + for (var i = minI; i <= maxI; i++) { + // Wrapped coordinates + /** @type {number} */ var x0 = tcuTexVerifierUtil.wrap(sampler.wrapS, i, w); + /** @type {number} */ var x1 = tcuTexVerifierUtil.wrap(sampler.wrapS, i + 1, w); + /** @type {number} */ var y0 = tcuTexVerifierUtil.wrap(sampler.wrapT, j, h); + /** @type {number} */ var y1 = tcuTexVerifierUtil.wrap(sampler.wrapT, j + 1, h); + + // Bounds for filtering factors + /** @type {number} */ var minA = deMath.clamp((uBounds[0] - 0.5) - i, 0, 1); + /** @type {number} */ var maxA = deMath.clamp((uBounds[1] - 0.5) - i, 0, 1); + /** @type {number} */ var minB = deMath.clamp((vBounds[0] - 0.5) - j, 0, 1); + /** @type {number} */ var maxB = deMath.clamp((vBounds[1] - 0.5) - j, 0, 1); + + /** @type {tcuTexLookupVerifier.ColorQuad} */ + var quad = tcuTexLookupVerifier.lookupQuad(level, sampler, x0, x1, y0, y1, coordZ); + + if (texClass == tcuTexture.TextureChannelClass.FLOATING_POINT) + searchStep = tcuTexLookupVerifier.computeBilinearSearchStepFromFloatQuad(prec, quad); + + if (tcuTexLookupVerifier.isBilinearRangeValid(prec, quad, [minA, maxA], [minB, maxB], searchStep, result)) + return true; + } + + return false; + }; + + /** + * @param {tcuTexture.ConstPixelBufferAccess} level + * @param {tcuTexture.Sampler} sampler + * @param {tcuTexLookupVerifier.LookupPrecision} prec + * @param {Array<number>} coord vec3 + * @param {Array<number>} result + * @return {boolean} + */ + tcuTexLookupVerifier.isLinearSampleResultValid_CoordAsVec3 = function(level, sampler, prec, coord, result) { + /** @type {Array<number>} */ + var uBounds = tcuTexVerifierUtil.computeNonNormalizedCoordBounds( + sampler.normalizedCoords, level.getWidth(), coord[0], prec.coordBits[0], prec.uvwBits[0]); + /** @type {Array<number>} */ + var vBounds = tcuTexVerifierUtil.computeNonNormalizedCoordBounds( + sampler.normalizedCoords, level.getHeight(), coord[1], prec.coordBits[1], prec.uvwBits[1]); + /** @type {Array<number>} */ + var wBounds = tcuTexVerifierUtil.computeNonNormalizedCoordBounds( + sampler.normalizedCoords, level.getDepth(), coord[2], prec.coordBits[2], prec.uvwBits[2]); + + // Integer coordinate bounds for (x0,y0) - without wrap mode + /** @type {number} */ var minI = Math.floor(uBounds[0] - 0.5); + /** @type {number} */ var maxI = Math.floor(uBounds[1] - 0.5); + /** @type {number} */ var minJ = Math.floor(vBounds[0] - 0.5); + /** @type {number} */ var maxJ = Math.floor(vBounds[1] - 0.5); + /** @type {number} */ var minK = Math.floor(wBounds[0] - 0.5); + /** @type {number} */ var maxK = Math.floor(wBounds[1] - 0.5); + + /** @type {number} */ var w = level.getWidth(); + /** @type {number} */ var h = level.getHeight(); + /** @type {number} */ var d = level.getDepth(); + + /** @type {tcuTexture.TextureChannelClass} */ + var texClass = tcuTexture.getTextureChannelClass(level.getFormat().type); + /** @type {number} */ + var searchStep = (texClass == tcuTexture.TextureChannelClass.UNSIGNED_FIXED_POINT) ? tcuTexLookupVerifier.computeBilinearSearchStepForUnorm(prec) : + (texClass == tcuTexture.TextureChannelClass.SIGNED_FIXED_POINT) ? tcuTexLookupVerifier.computeBilinearSearchStepForSnorm(prec) : + 0; // Step is computed for floating-point quads based on texel values. + + // \todo [2013-07-03 pyry] This could be optimized by first computing ranges based on wrap mode. + + for (var k = minK; k <= maxK; k++) { + for (var j = minJ; j <= maxJ; j++) { + for (var i = minI; i <= maxI; i++) { + // Wrapped coordinates + /** @type {number} */ var x0 = tcuTexVerifierUtil.wrap(sampler.wrapS, i, w); + /** @type {number} */ var x1 = tcuTexVerifierUtil.wrap(sampler.wrapS, i + 1, w); + /** @type {number} */ var y0 = tcuTexVerifierUtil.wrap(sampler.wrapT, j, h); + /** @type {number} */ var y1 = tcuTexVerifierUtil.wrap(sampler.wrapT, j + 1, h); + /** @type {number} */ var z0 = tcuTexVerifierUtil.wrap(sampler.wrapR, k, d); + /** @type {number} */ var z1 = tcuTexVerifierUtil.wrap(sampler.wrapR, k + 1, d); + + // Bounds for filtering factors + /** @type {number} */ var minA = deMath.clamp((uBounds[0] - 0.5) - i, 0, 1); + /** @type {number} */ var maxA = deMath.clamp((uBounds[1] - 0.5) - i, 0, 1); + /** @type {number} */ var minB = deMath.clamp((vBounds[0] - 0.5) - j, 0, 1); + /** @type {number} */ var maxB = deMath.clamp((vBounds[1] - 0.5) - j, 0, 1); + /** @type {number} */ var minC = deMath.clamp((wBounds[0] - 0.5) - k, 0, 1); + /** @type {number} */ var maxC = deMath.clamp((wBounds[1] - 0.5) - k, 0, 1); + + /** @type {tcuTexLookupVerifier.ColorQuad} */ + var quad0 = tcuTexLookupVerifier.lookupQuad(level, sampler, x0, x1, y0, y1, z0); + /** @type {tcuTexLookupVerifier.ColorQuad} */ + var quad1 = tcuTexLookupVerifier.lookupQuad(level, sampler, x0, x1, y0, y1, z1); + + if (texClass == tcuTexture.TextureChannelClass.FLOATING_POINT) + searchStep = Math.min(tcuTexLookupVerifier.computeBilinearSearchStepFromFloatQuad(prec, quad0), tcuTexLookupVerifier.computeBilinearSearchStepFromFloatQuad(prec, quad1)); + + if (tcuTexLookupVerifier.isTrilinearRangeValid(prec, quad0, quad1, [minA, maxA], [minB, maxB], [minC, maxC], searchStep, result)) + return true; + } + } + } + + return false; + }; + + /** + * @param {tcuTexture.ConstPixelBufferAccess} level0 + * @param {tcuTexture.ConstPixelBufferAccess} level1 + * @param {tcuTexture.Sampler} sampler + * @param {tcuTexLookupVerifier.LookupPrecision} prec + * @param {number} coord + * @param {number} coordY + * @param {Array<number>} fBounds + * @param {Array<number>} result + * @return {boolean} + */ + tcuTexLookupVerifier.isNearestMipmapLinearSampleResultValid_CoordXYAsNumber = function(level0, level1, sampler, prec, coord, coordY, fBounds, result) { + /** @type {number} */ var w0 = level0.getWidth(); + /** @type {number} */ var w1 = level1.getWidth(); + + /** @type {Array<number>} */ + var uBounds0 = tcuTexVerifierUtil.computeNonNormalizedCoordBounds( + sampler.normalizedCoords, w0, coord, prec.coordBits[0], prec.uvwBits[0]); + /** @type {Array<number>} */ + var uBounds1 = tcuTexVerifierUtil.computeNonNormalizedCoordBounds( + sampler.normalizedCoords, w1, coord, prec.coordBits[0], prec.uvwBits[0]); + + // Integer coordinates - without wrap mode + /** @type {number} */ var minI0 = Math.floor(uBounds0[0]); + /** @type {number} */ var maxI0 = Math.floor(uBounds0[1]); + /** @type {number} */ var minI1 = Math.floor(uBounds1[0]); + /** @type {number} */ var maxI1 = Math.floor(uBounds1[1]); + + for (var i0 = minI0; i0 <= maxI0; i0++) { + for (var i1 = minI1; i1 <= maxI1; i1++) { + /** @type {Array<number>} */ + var c0 = tcuTexLookupVerifier.lookupFloat(level0, sampler, tcuTexVerifierUtil.wrap(sampler.wrapS, i0, w0), coordY, 0); + /** @type {Array<number>} */ + var c1 = tcuTexLookupVerifier.lookupFloat(level1, sampler, tcuTexVerifierUtil.wrap(sampler.wrapS, i1, w1), coordY, 0); + + if (tcuTexLookupVerifier.isLinearRangeValid(prec, c0, c1, fBounds, result)) + return true; + } + } + + return false; + }; + + /** + * @param {tcuTexture.ConstPixelBufferAccess} level0 + * @param {tcuTexture.ConstPixelBufferAccess} level1 + * @param {tcuTexture.Sampler} sampler + * @param {tcuTexLookupVerifier.LookupPrecision} prec + * @param {Array<number>} coord + * @param {number} coordZ + * @param {Array<number>} fBounds + * @param {Array<number>} result + * @return {boolean} + */ + tcuTexLookupVerifier.isNearestMipmapLinearSampleResultValid_CoordAsVec2AndInt = function(level0, level1, sampler, prec, coord, coordZ, fBounds, result) { + /** @type {number} */ var w0 = level0.getWidth(); + /** @type {number} */ var w1 = level1.getWidth(); + /** @type {number} */ var h0 = level0.getHeight(); + /** @type {number} */ var h1 = level1.getHeight(); + + /** @type {Array<number>} */ + var uBounds0 = tcuTexVerifierUtil.computeNonNormalizedCoordBounds( + sampler.normalizedCoords, w0, coord[0], prec.coordBits[0], prec.uvwBits[0]); + /** @type {Array<number>} */ + var uBounds1 = tcuTexVerifierUtil.computeNonNormalizedCoordBounds( + sampler.normalizedCoords, w1, coord[0], prec.coordBits[0], prec.uvwBits[0]); + /** @type {Array<number>} */ + var vBounds0 = tcuTexVerifierUtil.computeNonNormalizedCoordBounds( + sampler.normalizedCoords, h0, coord[1], prec.coordBits[1], prec.uvwBits[1]); + /** @type {Array<number>} */ + var vBounds1 = tcuTexVerifierUtil.computeNonNormalizedCoordBounds( + sampler.normalizedCoords, h1, coord[1], prec.coordBits[1], prec.uvwBits[1]); + + // Integer coordinates - without wrap mode + /** @type {number} */ var minI0 = Math.floor(uBounds0[0]); + /** @type {number} */ var maxI0 = Math.floor(uBounds0[1]); + /** @type {number} */ var minI1 = Math.floor(uBounds1[0]); + /** @type {number} */ var maxI1 = Math.floor(uBounds1[1]); + /** @type {number} */ var minJ0 = Math.floor(vBounds0[0]); + /** @type {number} */ var maxJ0 = Math.floor(vBounds0[1]); + /** @type {number} */ var minJ1 = Math.floor(vBounds1[0]); + /** @type {number} */ var maxJ1 = Math.floor(vBounds1[1]); + + for (var j0 = minJ0; j0 <= maxJ0; j0++) { + for (var i0 = minI0; i0 <= maxI0; i0++) { + for (var j1 = minJ1; j1 <= maxJ1; j1++) { + for (var i1 = minI1; i1 <= maxI1; i1++) { + /** @type {Array<number>} */ var c0 = tcuTexLookupVerifier.lookupFloat(level0, sampler, tcuTexVerifierUtil.wrap(sampler.wrapS, i0, w0), tcuTexVerifierUtil.wrap(sampler.wrapT, j0, h0), coordZ); + /** @type {Array<number>} */ var c1 = tcuTexLookupVerifier.lookupFloat(level1, sampler, tcuTexVerifierUtil.wrap(sampler.wrapS, i1, w1), tcuTexVerifierUtil.wrap(sampler.wrapT, j1, h1), coordZ); + + if (tcuTexLookupVerifier.isLinearRangeValid(prec, c0, c1, fBounds, result)) + return true; + } + } + } + } + + return false; + }; + + /** + * @param {tcuTexture.ConstPixelBufferAccess} level0 + * @param {tcuTexture.ConstPixelBufferAccess} level1 + * @param {tcuTexture.Sampler} sampler + * @param {tcuTexLookupVerifier.LookupPrecision} prec + * @param {Array<number>} coord + * @param {Array<number>} fBounds + * @param {Array<number>} result + * @return {boolean} + */ + tcuTexLookupVerifier.isNearestMipmapLinearSampleResultValid_CoordAsVec3 = function(level0, level1, sampler, prec, coord, fBounds, result) { + /** @type {number} */ var w0 = level0.getWidth(); + /** @type {number} */ var w1 = level1.getWidth(); + /** @type {number} */ var h0 = level0.getHeight(); + /** @type {number} */ var h1 = level1.getHeight(); + /** @type {number} */ var d0 = level0.getDepth(); + /** @type {number} */ var d1 = level1.getDepth(); + + /** @type {Array<number>} */ + var uBounds0 = tcuTexVerifierUtil.computeNonNormalizedCoordBounds( + sampler.normalizedCoords, w0, coord[0], prec.coordBits[0], prec.uvwBits[0]); + /** @type {Array<number>} */ + var uBounds1 = tcuTexVerifierUtil.computeNonNormalizedCoordBounds( + sampler.normalizedCoords, w1, coord[0], prec.coordBits[0], prec.uvwBits[0]); + /** @type {Array<number>} */ + var vBounds0 = tcuTexVerifierUtil.computeNonNormalizedCoordBounds( + sampler.normalizedCoords, h0, coord[1], prec.coordBits[1], prec.uvwBits[1]); + /** @type {Array<number>} */ + var vBounds1 = tcuTexVerifierUtil.computeNonNormalizedCoordBounds( + sampler.normalizedCoords, h1, coord[1], prec.coordBits[1], prec.uvwBits[1]); + /** @type {Array<number>} */ + var wBounds0 = tcuTexVerifierUtil.computeNonNormalizedCoordBounds( + sampler.normalizedCoords, d0, coord[2], prec.coordBits[2], prec.uvwBits[2]); + /** @type {Array<number>} */ + var wBounds1 = tcuTexVerifierUtil.computeNonNormalizedCoordBounds( + sampler.normalizedCoords, d1, coord[2], prec.coordBits[2], prec.uvwBits[2]); + + // Integer coordinates - without wrap mode + /** @type {number} */ var minI0 = Math.floor(uBounds0[0]); + /** @type {number} */ var maxI0 = Math.floor(uBounds0[1]); + /** @type {number} */ var minI1 = Math.floor(uBounds1[0]); + /** @type {number} */ var maxI1 = Math.floor(uBounds1[1]); + /** @type {number} */ var minJ0 = Math.floor(vBounds0[0]); + /** @type {number} */ var maxJ0 = Math.floor(vBounds0[1]); + /** @type {number} */ var minJ1 = Math.floor(vBounds1[0]); + /** @type {number} */ var maxJ1 = Math.floor(vBounds1[1]); + /** @type {number} */ var minK0 = Math.floor(wBounds0[0]); + /** @type {number} */ var maxK0 = Math.floor(wBounds0[1]); + /** @type {number} */ var minK1 = Math.floor(wBounds1[0]); + /** @type {number} */ var maxK1 = Math.floor(wBounds1[1]); + + for (var k0 = minK0; k0 <= maxK0; k0++) { + for (var j0 = minJ0; j0 <= maxJ0; j0++) { + for (var i0 = minI0; i0 <= maxI0; i0++) { + for (var k1 = minK1; k1 <= maxK1; k1++) { + for (var j1 = minJ1; j1 <= maxJ1; j1++) { + for (var i1 = minI1; i1 <= maxI1; i1++) { + /** @type {Array<number>} */ var c0 = tcuTexLookupVerifier.lookupFloat(level0, sampler, tcuTexVerifierUtil.wrap(sampler.wrapS, i0, w0), tcuTexVerifierUtil.wrap(sampler.wrapT, j0, h0), tcuTexVerifierUtil.wrap(sampler.wrapR, k0, d0)); + /** @type {Array<number>} */ var c1 = tcuTexLookupVerifier.lookupFloat(level1, sampler, tcuTexVerifierUtil.wrap(sampler.wrapS, i1, w1), tcuTexVerifierUtil.wrap(sampler.wrapT, j1, h1), tcuTexVerifierUtil.wrap(sampler.wrapR, k1, d1)); + + if (tcuTexLookupVerifier.isLinearRangeValid(prec, c0, c1, fBounds, result)) + return true; + } + } + } + } + } + } + + return false; + }; + + /** + * @param {tcuTexture.ConstPixelBufferAccess} level0 + * @param {tcuTexture.ConstPixelBufferAccess} level1 + * @param {tcuTexture.Sampler} sampler + * @param {tcuTexLookupVerifier.LookupPrecision} prec + * @param {Array<number>} coord + * @param {number} coordZ + * @param {Array<number>} fBounds + * @param {Array<number>} result + * @return {boolean} + */ + tcuTexLookupVerifier.isLinearMipmapLinearSampleResultValid_CoordAsVec2AndInt = function(level0, level1, sampler, prec, coord, coordZ, fBounds, result) { + // \todo [2013-07-04 pyry] This is strictly not correct as coordinates between levels should be dependent. + // Right now this allows pairing any two valid bilinear quads. + + /** @type {number} */ var w0 = level0.getWidth(); + /** @type {number} */ var w1 = level1.getWidth(); + /** @type {number} */ var h0 = level0.getHeight(); + /** @type {number} */ var h1 = level1.getHeight(); + + /** @type {Array<number>} */ + var uBounds0 = tcuTexVerifierUtil.computeNonNormalizedCoordBounds( + sampler.normalizedCoords, w0, coord[0], prec.coordBits[0], prec.uvwBits[0]); + /** @type {Array<number>} */ + var uBounds1 = tcuTexVerifierUtil.computeNonNormalizedCoordBounds( + sampler.normalizedCoords, w1, coord[0], prec.coordBits[0], prec.uvwBits[0]); + /** @type {Array<number>} */ + var vBounds0 = tcuTexVerifierUtil.computeNonNormalizedCoordBounds( + sampler.normalizedCoords, h0, coord[1], prec.coordBits[1], prec.uvwBits[1]); + /** @type {Array<number>} */ + var vBounds1 = tcuTexVerifierUtil.computeNonNormalizedCoordBounds( + sampler.normalizedCoords, h1, coord[1], prec.coordBits[1], prec.uvwBits[1]); + + // Integer coordinates - without wrap mode + /** @type {number} */ var minI0 = Math.floor(uBounds0[0] - 0.5); + /** @type {number} */ var maxI0 = Math.floor(uBounds0[1] - 0.5); + /** @type {number} */ var minI1 = Math.floor(uBounds1[0] - 0.5); + /** @type {number} */ var maxI1 = Math.floor(uBounds1[1] - 0.5); + /** @type {number} */ var minJ0 = Math.floor(vBounds0[0] - 0.5); + /** @type {number} */ var maxJ0 = Math.floor(vBounds0[1] - 0.5); + /** @type {number} */ var minJ1 = Math.floor(vBounds1[0] - 0.5); + /** @type {number} */ var maxJ1 = Math.floor(vBounds1[1] - 0.5); + + /** @type {tcuTexture.TextureChannelClass} */ + var texClass = tcuTexture.getTextureChannelClass(level0.getFormat().type); + /** @type {number} */ var cSearchStep = (texClass == tcuTexture.TextureChannelClass.UNSIGNED_FIXED_POINT) ? tcuTexLookupVerifier.computeBilinearSearchStepForUnorm(prec) : + (texClass == tcuTexture.TextureChannelClass.SIGNED_FIXED_POINT) ? tcuTexLookupVerifier.computeBilinearSearchStepForSnorm(prec) : + 0; // Step is computed for floating-point quads based on texel values. + + /** @type {number} */ var x0; + /** @type {number} */ var x1; + /** @type {number} */ var y0; + /** @type {number} */ var y1; + + for (var j0 = minJ0; j0 <= maxJ0; j0++) { + for (var i0 = minI0; i0 <= maxI0; i0++) { + /** @type {number} */ var searchStep0; + + x0 = tcuTexVerifierUtil.wrap(sampler.wrapS, i0, w0); + x1 = tcuTexVerifierUtil.wrap(sampler.wrapS, i0 + 1, w0); + y0 = tcuTexVerifierUtil.wrap(sampler.wrapT, j0, h0); + y1 = tcuTexVerifierUtil.wrap(sampler.wrapT, j0 + 1, h0); + + /** @type {tcuTexLookupVerifier.ColorQuad} */ + var quad0 = tcuTexLookupVerifier.lookupQuad(level0, sampler, x0, x1, y0, y1, coordZ); + + if (texClass == tcuTexture.TextureChannelClass.FLOATING_POINT) + searchStep0 = tcuTexLookupVerifier.computeBilinearSearchStepFromFloatQuad(prec, quad0); + else + searchStep0 = cSearchStep; + + /** @type {number} */ var minA0 = deMath.clamp((uBounds0[0] - 0.5) - i0, 0, 1); + /** @type {number} */ var maxA0 = deMath.clamp((uBounds0[1] - 0.5) - i0, 0, 1); + /** @type {number} */ var minB0 = deMath.clamp((vBounds0[0] - 0.5) - j0, 0, 1); + /** @type {number} */ var maxB0 = deMath.clamp((vBounds0[1] - 0.5) - j0, 0, 1); + + for (var j1 = minJ1; j1 <= maxJ1; j1++) { + for (var i1 = minI1; i1 <= maxI1; i1++) { + /** @type {number} */ var searchStep1; + + x0 = tcuTexVerifierUtil.wrap(sampler.wrapS, i1, w1); + x1 = tcuTexVerifierUtil.wrap(sampler.wrapS, i1 + 1, w1); + y0 = tcuTexVerifierUtil.wrap(sampler.wrapT, j1, h1); + y1 = tcuTexVerifierUtil.wrap(sampler.wrapT, j1 + 1, h1); + + /** @type {tcuTexLookupVerifier.ColorQuad} */ + var quad1 = tcuTexLookupVerifier.lookupQuad(level1, sampler, x0, x1, y0, y1, coordZ); + + if (texClass == tcuTexture.TextureChannelClass.FLOATING_POINT) + searchStep1 = tcuTexLookupVerifier.computeBilinearSearchStepFromFloatQuad(prec, quad1); + else + searchStep1 = cSearchStep; + + /** @type {number} */ var minA1 = deMath.clamp((uBounds1[0] - 0.5) - i1, 0, 1); + /** @type {number} */ var maxA1 = deMath.clamp((uBounds1[1] - 0.5) - i1, 0, 1); + /** @type {number} */ var minB1 = deMath.clamp((vBounds1[0] - 0.5) - j1, 0, 1); + /** @type {number} */ var maxB1 = deMath.clamp((vBounds1[1] - 0.5) - j1, 0, 1); + + if (tcuTexLookupVerifier.is2DTrilinearFilterResultValid(prec, quad0, quad1, [minA0, maxA0], [minB0, maxB0], [minA1, maxA1], [minB1, maxB1], + fBounds, Math.min(searchStep0, searchStep1), result)) + return true; + } + } + } + } + + return false; + }; + + /** + * @param {tcuTexture.ConstPixelBufferAccess} level0 + * @param {tcuTexture.ConstPixelBufferAccess} level1 + * @param {tcuTexture.Sampler} sampler + * @param {tcuTexLookupVerifier.LookupPrecision} prec + * @param {Array<number>} coord + * @param {Array<number>} fBounds + * @param {Array<number>} result + * @return {boolean} + */ + tcuTexLookupVerifier.isLinearMipmapLinearSampleResultValid_CoordAsVec3 = function(level0, level1, sampler, prec, coord, fBounds, result) { + // \todo [2013-07-04 pyry] This is strictly not correct as coordinates between levels should be dependent. + // Right now this allows pairing any two valid bilinear quads. + + /** @type {number} */ var w0 = level0.getWidth(); + /** @type {number} */ var w1 = level1.getWidth(); + /** @type {number} */ var h0 = level0.getHeight(); + /** @type {number} */ var h1 = level1.getHeight(); + /** @type {number} */ var d0 = level0.getDepth(); + /** @type {number} */ var d1 = level1.getDepth(); + + /** @type {Array<number>} */ + var uBounds0 = tcuTexVerifierUtil.computeNonNormalizedCoordBounds( + sampler.normalizedCoords, w0, coord[0], prec.coordBits[0], prec.uvwBits[0]); + /** @type {Array<number>} */ + var uBounds1 = tcuTexVerifierUtil.computeNonNormalizedCoordBounds( + sampler.normalizedCoords, w1, coord[0], prec.coordBits[0], prec.uvwBits[0]); + /** @type {Array<number>} */ + var vBounds0 = tcuTexVerifierUtil.computeNonNormalizedCoordBounds( + sampler.normalizedCoords, h0, coord[1], prec.coordBits[1], prec.uvwBits[1]); + /** @type {Array<number>} */ + var vBounds1 = tcuTexVerifierUtil.computeNonNormalizedCoordBounds( + sampler.normalizedCoords, h1, coord[1], prec.coordBits[1], prec.uvwBits[1]); + /** @type {Array<number>} */ + var wBounds0 = tcuTexVerifierUtil.computeNonNormalizedCoordBounds( + sampler.normalizedCoords, d0, coord[2], prec.coordBits[2], prec.uvwBits[2]); + /** @type {Array<number>} */ + var wBounds1 = tcuTexVerifierUtil.computeNonNormalizedCoordBounds( + sampler.normalizedCoords, d1, coord[2], prec.coordBits[2], prec.uvwBits[2]); + + // Integer coordinates - without wrap mode + /** @type {number} */ var minI0 = Math.floor(uBounds0[0] - 0.5); + /** @type {number} */ var maxI0 = Math.floor(uBounds0[1] - 0.5); + /** @type {number} */ var minI1 = Math.floor(uBounds1[0] - 0.5); + /** @type {number} */ var maxI1 = Math.floor(uBounds1[1] - 0.5); + /** @type {number} */ var minJ0 = Math.floor(vBounds0[0] - 0.5); + /** @type {number} */ var maxJ0 = Math.floor(vBounds0[1] - 0.5); + /** @type {number} */ var minJ1 = Math.floor(vBounds1[0] - 0.5); + /** @type {number} */ var maxJ1 = Math.floor(vBounds1[1] - 0.5); + /** @type {number} */ var minK0 = Math.floor(wBounds0[0] - 0.5); + /** @type {number} */ var maxK0 = Math.floor(wBounds0[1] - 0.5); + /** @type {number} */ var minK1 = Math.floor(wBounds1[0] - 0.5); + /** @type {number} */ var maxK1 = Math.floor(wBounds1[1] - 0.5); + + /** @type {tcuTexture.TextureChannelClass} */ + var texClass = tcuTexture.getTextureChannelClass(level0.getFormat().type); + /** @type {number} */ var cSearchStep = texClass == tcuTexture.TextureChannelClass.UNSIGNED_FIXED_POINT ? tcuTexLookupVerifier.computeBilinearSearchStepForUnorm(prec) : + texClass == tcuTexture.TextureChannelClass.SIGNED_FIXED_POINT ? tcuTexLookupVerifier.computeBilinearSearchStepForSnorm(prec) : + 0; // Step is computed for floating-point quads based on texel values. + + /** @type {number} */ var x0; + /** @type {number} */ var x1; + /** @type {number} */ var y0; + /** @type {number} */ var y1; + /** @type {number} */ var z0; + /** @type {number} */ var z1; + + for (var k0 = minK0; k0 <= maxK0; k0++) { + for (var j0 = minJ0; j0 <= maxJ0; j0++) { + for (var i0 = minI0; i0 <= maxI0; i0++) { + /** @type {number} */ var searchStep0; + + x0 = tcuTexVerifierUtil.wrap(sampler.wrapS, i0, w0); + x1 = tcuTexVerifierUtil.wrap(sampler.wrapS, i0 + 1, w0); + y0 = tcuTexVerifierUtil.wrap(sampler.wrapT, j0, h0); + y1 = tcuTexVerifierUtil.wrap(sampler.wrapT, j0 + 1, h0); + z0 = tcuTexVerifierUtil.wrap(sampler.wrapR, k0, d0); + z1 = tcuTexVerifierUtil.wrap(sampler.wrapR, k0 + 1, d0); + /** @type {tcuTexLookupVerifier.ColorQuad} */ + var quad00 = tcuTexLookupVerifier.lookupQuad(level0, sampler, x0, x1, y0, y1, z0); + /** @type {tcuTexLookupVerifier.ColorQuad} */ + var quad01 = tcuTexLookupVerifier.lookupQuad(level0, sampler, x0, x1, y0, y1, z1); + + if (texClass == tcuTexture.TextureChannelClass.FLOATING_POINT) + searchStep0 = Math.min(tcuTexLookupVerifier.computeBilinearSearchStepFromFloatQuad(prec, quad00), tcuTexLookupVerifier.computeBilinearSearchStepFromFloatQuad(prec, quad01)); + else + searchStep0 = cSearchStep; + + /** @type {number} */ var minA0 = deMath.clamp((uBounds0[0] - 0.5) - i0, 0, 1); + /** @type {number} */ var maxA0 = deMath.clamp((uBounds0[1] - 0.5) - i0, 0, 1); + /** @type {number} */ var minB0 = deMath.clamp((vBounds0[0] - 0.5) - j0, 0, 1); + /** @type {number} */ var maxB0 = deMath.clamp((vBounds0[1] - 0.5) - j0, 0, 1); + /** @type {number} */ var minC0 = deMath.clamp((wBounds0[0] - 0.5) - k0, 0, 1); + /** @type {number} */ var maxC0 = deMath.clamp((wBounds0[1] - 0.5) - k0, 0, 1); + + for (var k1 = minK1; k1 <= maxK1; k1++) { + for (var j1 = minJ1; j1 <= maxJ1; j1++) { + for (var i1 = minI1; i1 <= maxI1; i1++) { + + /** @type {number} */ var searchStep1; + + x0 = tcuTexVerifierUtil.wrap(sampler.wrapS, i1, w1); + x1 = tcuTexVerifierUtil.wrap(sampler.wrapS, i1 + 1, w1); + y0 = tcuTexVerifierUtil.wrap(sampler.wrapT, j1, h1); + y1 = tcuTexVerifierUtil.wrap(sampler.wrapT, j1 + 1, h1); + z0 = tcuTexVerifierUtil.wrap(sampler.wrapR, k1, d1); + z1 = tcuTexVerifierUtil.wrap(sampler.wrapR, k1 + 1, d1); + /** @type {tcuTexLookupVerifier.ColorQuad} */ + var quad10 = tcuTexLookupVerifier.lookupQuad(level1, sampler, x0, x1, y0, y1, z0); + /** @type {tcuTexLookupVerifier.ColorQuad} */ + var quad11 = tcuTexLookupVerifier.lookupQuad(level1, sampler, x0, x1, y0, y1, z1); + + if (texClass == tcuTexture.TextureChannelClass.FLOATING_POINT) + searchStep1 = Math.min(tcuTexLookupVerifier.computeBilinearSearchStepFromFloatQuad(prec, quad10), tcuTexLookupVerifier.computeBilinearSearchStepFromFloatQuad(prec, quad11)); + else + searchStep1 = cSearchStep; + + /** @type {number} */ var minA1 = deMath.clamp((uBounds1[0] - 0.5) - i1, 0, 1); + /** @type {number} */ var maxA1 = deMath.clamp((uBounds1[1] - 0.5) - i1, 0, 1); + /** @type {number} */ var minB1 = deMath.clamp((vBounds1[0] - 0.5) - j1, 0, 1); + /** @type {number} */ var maxB1 = deMath.clamp((vBounds1[1] - 0.5) - j1, 0, 1); + /** @type {number} */ var minC1 = deMath.clamp((wBounds1[0] - 0.5) - k1, 0, 1); + /** @type {number} */ var maxC1 = deMath.clamp((wBounds1[1] - 0.5) - k1, 0, 1); + + if (tcuTexLookupVerifier.is3DTrilinearFilterResultValid( + prec, quad00, quad01, quad10, quad11, + [minA0, maxA0], [minB0, maxB0], [minC0, maxC0], + [minA1, maxA1], [minB1, maxB1], [minC1, maxC1], + fBounds, Math.min(searchStep0, searchStep1), result)) + return true; + } + } + } + } + } + } + + return false; + }; + + /** + * @param {tcuTexture.ConstPixelBufferAccess} level + * @param {tcuTexture.Sampler} sampler + * @param {tcuTexture.FilterMode} filterMode + * @param {tcuTexLookupVerifier.LookupPrecision} prec + * @param {number} coordX + * @param {number} coordY + * @param {Array<number>} result + * @return {boolean} + */ + tcuTexLookupVerifier.isLevelSampleResultValid_CoordXYAsNumber = function(level, sampler, filterMode, prec, coordX, coordY, result) { + if (filterMode == tcuTexture.FilterMode.LINEAR) + return tcuTexLookupVerifier.isLinearSampleResultValid_CoordXYAsNumber(level, sampler, prec, coordX, coordY, result); + else + return tcuTexLookupVerifier.isNearestSampleResultValid_CoordXYAsNumber(level, sampler, prec, coordX, coordY, result); + }; + + /** + * @param {tcuTexture.ConstPixelBufferAccess} level + * @param {tcuTexture.Sampler} sampler + * @param {tcuTexture.FilterMode} filterMode + * @param {tcuTexLookupVerifier.LookupPrecision} prec + * @param {Array<number>} coord + * @param {number} coordZ + * @param {Array<number>} result + * @return {boolean} + */ + tcuTexLookupVerifier.isLevelSampleResultValid_CoordAsVec2AndInt = function(level, sampler, filterMode, prec, coord, coordZ, result) { + if (filterMode == tcuTexture.FilterMode.LINEAR) + return tcuTexLookupVerifier.isLinearSampleResultValid_CoordAsVec2AndInt(level, sampler, prec, coord, coordZ, result); + else + return tcuTexLookupVerifier.isNearestSampleResultValid_CoordAsVec2AndInt(level, sampler, prec, coord, coordZ, result); + }; + + /** + * @param {tcuTexture.ConstPixelBufferAccess} level + * @param {tcuTexture.Sampler} sampler + * @param {tcuTexture.FilterMode} filterMode + * @param {tcuTexLookupVerifier.LookupPrecision} prec + * @param {Array<number>} coord + * @param {Array<number>} result + * @return {boolean} + */ + tcuTexLookupVerifier.isLevelSampleResultValid_CoordAsVec3 = function(level, sampler, filterMode, prec, coord, result) { + if (filterMode == tcuTexture.FilterMode.LINEAR) + return tcuTexLookupVerifier.isLinearSampleResultValid_CoordAsVec3(level, sampler, prec, coord, result); + else + return tcuTexLookupVerifier.isNearestSampleResultValid_CoordAsVec3(level, sampler, prec, coord, result); + }; + + /** + * @param {tcuTexture.ConstPixelBufferAccess} level0 + * @param {tcuTexture.ConstPixelBufferAccess} level1 + * @param {tcuTexture.Sampler} sampler + * @param {tcuTexture.FilterMode} levelFilter + * @param {tcuTexLookupVerifier.LookupPrecision} prec + * @param {Array<number>} coord + * @param {number} coordZ + * @param {Array<number>} fBounds + * @param {Array<number>} result + * @return {boolean} + */ + tcuTexLookupVerifier.isMipmapLinearSampleResultValid_CoordAsVec2AndInt = function(level0, level1, sampler, levelFilter, prec, coord, coordZ, fBounds, result) { + if (levelFilter == tcuTexture.FilterMode.LINEAR) + return tcuTexLookupVerifier.isLinearMipmapLinearSampleResultValid_CoordAsVec2AndInt(level0, level1, sampler, prec, coord, coordZ, fBounds, result); + else + return tcuTexLookupVerifier.isNearestMipmapLinearSampleResultValid_CoordAsVec2AndInt(level0, level1, sampler, prec, coord, coordZ, fBounds, result); + }; + + /** + * @param {tcuTexture.ConstPixelBufferAccess} level0 + * @param {tcuTexture.ConstPixelBufferAccess} level1 + * @param {tcuTexture.Sampler} sampler + * @param {tcuTexture.FilterMode} levelFilter + * @param {tcuTexLookupVerifier.LookupPrecision} prec + * @param {Array<number>} coord + * @param {Array<number>} fBounds + * @param {Array<number>} result + * @return {boolean} + */ + tcuTexLookupVerifier.isMipmapLinearSampleResultValid_CoordAsVec3 = function(level0, level1, sampler, levelFilter, prec, coord, fBounds, result) { + if (levelFilter == tcuTexture.FilterMode.LINEAR) + return tcuTexLookupVerifier.isLinearMipmapLinearSampleResultValid_CoordAsVec3(level0, level1, sampler, prec, coord, fBounds, result); + else + return tcuTexLookupVerifier.isNearestMipmapLinearSampleResultValid_CoordAsVec3(level0, level1, sampler, prec, coord, fBounds, result); + }; + + /** + * @param {tcuTexture.Texture2DView} texture + * @param {tcuTexture.Sampler} sampler + * @param {tcuTexLookupVerifier.LookupPrecision} prec + * @param {Array<number>} coord + * @param {Array<number>} lodBounds + * @param {Array<number>} result + * @return {boolean} + */ + tcuTexLookupVerifier.isLookupResultValid_Texture2DView = function(texture, sampler, prec, coord, lodBounds, result) { + /** @type {number} */ var minLod = lodBounds[0]; + /** @type {number} */ var maxLod = lodBounds[1]; + /** @type {boolean} */ var canBeMagnified = minLod <= sampler.lodThreshold; + /** @type {boolean} */ var canBeMinified = maxLod > sampler.lodThreshold; + + assertMsgOptions(tcuTexLookupVerifier.isSamplerSupported(sampler), 'Sampler not supported.', false, true); + + /** @type {number} */ var minLevel; + /** @type {number} */ var maxLevel; + + if (canBeMagnified) + if (tcuTexLookupVerifier.isLevelSampleResultValid_CoordAsVec2AndInt(texture.getLevel(0), sampler, sampler.magFilter, prec, coord, 0, result)) + return true; + + if (canBeMinified) { + /** @type {boolean} */ var isNearestMipmap = tcuTexVerifierUtil.isNearestMipmapFilter(sampler.minFilter); + /** @type {boolean} */ var isLinearMipmap = tcuTexVerifierUtil.isLinearMipmapFilter(sampler.minFilter); + /** @type {number} */ var minTexLevel = 0; + /** @type {number} */ var maxTexLevel = texture.getNumLevels() - 1; + + assertMsgOptions(minTexLevel <= maxTexLevel, 'minTexLevel > maxTexLevel', false, true); + + if (isLinearMipmap && minTexLevel < maxTexLevel) { + minLevel = deMath.clamp(Math.floor(minLod), minTexLevel, maxTexLevel - 1); + maxLevel = deMath.clamp(Math.floor(maxLod), minTexLevel, maxTexLevel - 1); + + assertMsgOptions(minLevel <= maxLevel, 'minLevel > maxLevel', false, true); + + for (var level = minLevel; level <= maxLevel; level++) { + /** @type {number} */ var minF = deMath.clamp(minLod - level, 0, 1); + /** @type {number} */ var maxF = deMath.clamp(maxLod - level, 0, 1); + + if (tcuTexLookupVerifier.isMipmapLinearSampleResultValid_CoordAsVec2AndInt(texture.getLevel(level), texture.getLevel(level + 1), sampler, tcuTexVerifierUtil.getLevelFilter(sampler.minFilter), prec, coord, 0, [minF, maxF], result)) + return true; + } + } else if (isNearestMipmap) { + // \note The accurate formula for nearest mipmapping is level = ceil(lod + 0.5) - 1 but Khronos has made + // decision to allow floor(lod + 0.5) as well. + minLevel = deMath.clamp(Math.ceil(minLod + 0.5) - 1, minTexLevel, maxTexLevel); + maxLevel = deMath.clamp(Math.floor(maxLod + 0.5), minTexLevel, maxTexLevel); + + assertMsgOptions(minLevel <= maxLevel, 'minLevel > maxLevel', false, true); + + for (var level = minLevel; level <= maxLevel; level++) { + if (tcuTexLookupVerifier.isLevelSampleResultValid_CoordAsVec2AndInt(texture.getLevel(level), sampler, tcuTexVerifierUtil.getLevelFilter(sampler.minFilter), prec, coord, 0, result)) + return true; + } + } else { + if (tcuTexLookupVerifier.isLevelSampleResultValid_CoordAsVec2AndInt(texture.getLevel(0), sampler, sampler.minFilter, prec, coord, 0, result)) + return true; + } + } + + return false; + }; + + /** + * @param {tcuTexture.TextureCubeView} texture + * @param {tcuTexture.Sampler} sampler + * @param {tcuTexLookupVerifier.LookupPrecision} prec + * @param {Array<number>} coord + * @param {Array<number>} lodBounds + * @param {Array<number>} result + * @return {boolean} + */ + tcuTexLookupVerifier.isLookupResultValid_TextureCubeView = function(texture, sampler, prec, coord, lodBounds, result) { + /** @type {number} */ var numPossibleFaces = 0; + + assertMsgOptions(tcuTexLookupVerifier.isSamplerSupported(sampler), 'Sampler not supported.', false, true); + + /** @type {Array<tcuTexture.CubeFace>} */ var possibleFaces = tcuTexVerifierUtil.getPossibleCubeFaces(coord, prec.coordBits); + + /** @type {number} */ var minLevel; + /** @type {number} */ var maxLevel; + + if (!possibleFaces) + return true; // Result is undefined. + + for (var tryFaceNdx = 0; tryFaceNdx < possibleFaces.length; tryFaceNdx++) { + /** @type {tcuTexture.CubeFaceCoords} */ + var faceCoords = new tcuTexture.CubeFaceCoords(possibleFaces[tryFaceNdx], tcuTexture.projectToFace(possibleFaces[tryFaceNdx], coord)); + /** @type {number} */ var minLod = lodBounds[0]; + /** @type {number} */ var maxLod = lodBounds[1]; + /** @type {boolean} */ var canBeMagnified = minLod <= sampler.lodThreshold; + /** @type {boolean} */ var canBeMinified = maxLod > sampler.lodThreshold; + + /** @type {Array<tcuTexture.ConstPixelBufferAccess>} */ var faces = []; + if (canBeMagnified) { + tcuTexLookupVerifier.getCubeLevelFaces(texture, 0, faces); + + if (tcuTexLookupVerifier.isCubeLevelSampleResultValid(faces, sampler, sampler.magFilter, prec, faceCoords, result)) + return true; + } + + if (canBeMinified) { + /** @type {boolean} */ var isNearestMipmap = tcuTexVerifierUtil.isNearestMipmapFilter(sampler.minFilter); + /** @type {boolean} */ var isLinearMipmap = tcuTexVerifierUtil.isLinearMipmapFilter(sampler.minFilter); + /** @type {number} */ var minTexLevel = 0; + /** @type {number} */ var maxTexLevel = texture.getNumLevels() - 1; + + assertMsgOptions(minTexLevel <= maxTexLevel, 'minTexLevel > maxTexLevel', false, true); + + if (isLinearMipmap && minTexLevel < maxTexLevel) { + minLevel = deMath.clamp(Math.floor(minLod), minTexLevel, maxTexLevel - 1); + maxLevel = deMath.clamp(Math.floor(maxLod), minTexLevel, maxTexLevel - 1); + + assertMsgOptions(minLevel <= maxLevel, 'minLevel > maxLevel', false, true); + + for (var levelNdx = minLevel; levelNdx <= maxLevel; levelNdx++) { + /** @type {number} */ var minF = deMath.clamp(minLod - levelNdx, 0, 1); + /** @type {number} */ var maxF = deMath.clamp(maxLod - levelNdx, 0, 1); + + /** @type {Array<tcuTexture.ConstPixelBufferAccess>} */ var faces0 = []; + /** @type {Array<tcuTexture.ConstPixelBufferAccess>} */ var faces1 = []; + + tcuTexLookupVerifier.getCubeLevelFaces(texture, levelNdx, faces0); + tcuTexLookupVerifier.getCubeLevelFaces(texture, levelNdx + 1, faces1); + + if (tcuTexLookupVerifier.isCubeMipmapLinearSampleResultValid(faces0, faces1, sampler, tcuTexVerifierUtil.getLevelFilter(sampler.minFilter), prec, faceCoords, [minF, maxF], result)) + return true; + } + } else if (isNearestMipmap) { + // \note The accurate formula for nearest mipmapping is level = ceil(lod + 0.5) - 1 but Khronos has made + // decision to allow floor(lod + 0.5) as well. + minLevel = deMath.clamp(Math.ceil(minLod + 0.5) - 1, minTexLevel, maxTexLevel); + maxLevel = deMath.clamp(Math.floor(maxLod + 0.5), minTexLevel, maxTexLevel); + + assertMsgOptions(minLevel <= maxLevel, 'minLevel > maxLevel', false, true); + + for (var levelNdx = minLevel; levelNdx <= maxLevel; levelNdx++) { + tcuTexLookupVerifier.getCubeLevelFaces(texture, levelNdx, faces); + + if (tcuTexLookupVerifier.isCubeLevelSampleResultValid(faces, sampler, tcuTexVerifierUtil.getLevelFilter(sampler.minFilter), prec, faceCoords, result)) + return true; + } + } else { + tcuTexLookupVerifier.getCubeLevelFaces(texture, 0, faces); + + if (tcuTexLookupVerifier.isCubeLevelSampleResultValid(faces, sampler, sampler.minFilter, prec, faceCoords, result)) + return true; + } + } + } + + return false; + }; + + /** + * @param {tcuTexture.Texture2DArrayView} texture + * @param {tcuTexture.Sampler} sampler + * @param {tcuTexLookupVerifier.LookupPrecision} prec + * @param {Array<number>} coord + * @param {Array<number>} lodBounds + * @param {Array<number>} result + * @return {boolean} + */ + tcuTexLookupVerifier.isLookupResultValid_Texture2DArrayView = function(texture, sampler, prec, coord, lodBounds, result) { + /** @type {Array<number>} */ var layerRange = tcuTexLookupVerifier.computeLayerRange(texture.getNumLayers(), prec.coordBits[2], coord[2]); + /** @type {Array<number>} */ var coordXY = deMath.swizzle(coord, [0, 1]); + /** @type {number} */ var minLod = lodBounds[0]; + /** @type {number} */ var maxLod = lodBounds[1]; + /** @type {boolean} */ var canBeMagnified = minLod <= sampler.lodThreshold; + /** @type {boolean} */ var canBeMinified = maxLod > sampler.lodThreshold; + + assertMsgOptions(tcuTexLookupVerifier.isSamplerSupported(sampler), 'Sampler not supported.', false, true); + /** @type {number} */ var minLevel; + /** @type {number} */ var maxLevel; + + for (var layer = layerRange[0]; layer <= layerRange[1]; layer++) { + if (canBeMagnified) { + if (tcuTexLookupVerifier.isLevelSampleResultValid_CoordAsVec2AndInt(texture.getLevel(0), sampler, sampler.magFilter, prec, coordXY, layer, result)) + return true; + } + + if (canBeMinified) { + /** @type {boolean} */ var isNearestMipmap = tcuTexVerifierUtil.isNearestMipmapFilter(sampler.minFilter); + /** @type {boolean} */ var isLinearMipmap = tcuTexVerifierUtil.isLinearMipmapFilter(sampler.minFilter); + /** @type {number} */ var minTexLevel = 0; + /** @type {number} */ var maxTexLevel = texture.getNumLevels() - 1; + + assertMsgOptions(minTexLevel <= maxTexLevel, 'minTexLevel > maxTexLevel', false, true); + + if (isLinearMipmap && minTexLevel < maxTexLevel) { + minLevel = deMath.clamp(Math.floor(minLod), minTexLevel, maxTexLevel - 1); + maxLevel = deMath.clamp(Math.floor(maxLod), minTexLevel, maxTexLevel - 1); + + assertMsgOptions(minLevel <= maxLevel, 'minLevel > maxLevel', false, true); + + for (var level = minLevel; level <= maxLevel; level++) { + /** @type {number} */ var minF = deMath.clamp(minLod - level, 0, 1); + /** @type {number} */ var maxF = deMath.clamp(maxLod - level, 0, 1); + + if (tcuTexLookupVerifier.isMipmapLinearSampleResultValid_CoordAsVec2AndInt(texture.getLevel(level), texture.getLevel(level + 1), sampler, tcuTexVerifierUtil.getLevelFilter(sampler.minFilter), prec, coordXY, layer, [minF, maxF], result)) + return true; + } + } else if (isNearestMipmap) { + // \note The accurate formula for nearest mipmapping is level = ceil(lod + 0.5) - 1 but Khronos has made + // decision to allow floor(lod + 0.5) as well. + minLevel = deMath.clamp(Math.ceil(minLod + 0.5) - 1, minTexLevel, maxTexLevel); + maxLevel = deMath.clamp(Math.floor(maxLod + 0.5), minTexLevel, maxTexLevel); + + assertMsgOptions(minLevel <= maxLevel, 'minLevel > maxLevel', false, true); + + for (var level = minLevel; level <= maxLevel; level++) { + if (tcuTexLookupVerifier.isLevelSampleResultValid_CoordAsVec2AndInt(texture.getLevel(level), sampler, tcuTexVerifierUtil.getLevelFilter(sampler.minFilter), prec, coordXY, layer, result)) + return true; + } + } else { + if (tcuTexLookupVerifier.isLevelSampleResultValid_CoordAsVec2AndInt(texture.getLevel(0), sampler, sampler.minFilter, prec, coordXY, layer, result)) + return true; + } + } + } + + return false; + }; + + /** + * @param {tcuTexture.Texture3DView} texture + * @param {tcuTexture.Sampler} sampler + * @param {tcuTexLookupVerifier.LookupPrecision} prec + * @param {Array<number>} coord + * @param {Array<number>} lodBounds + * @param {Array<number>} result + * @return {boolean} + */ + tcuTexLookupVerifier.isLookupResultValid = function(texture, sampler, prec, coord, lodBounds, result) { + /** @type {number} */ var minLod = lodBounds[0]; + /** @type {number} */ var maxLod = lodBounds[1]; + /** @type {boolean} */ var canBeMagnified = minLod <= sampler.lodThreshold; + /** @type {boolean} */ var canBeMinified = maxLod > sampler.lodThreshold; + + assertMsgOptions(tcuTexLookupVerifier.isSamplerSupported(sampler), 'Sampler not supported.', false, true); + + /** @type {number} */ var minLevel; + /** @type {number} */ var maxLevel; + + if (canBeMagnified) + if (tcuTexLookupVerifier.isLevelSampleResultValid_CoordAsVec3(texture.getLevel(0), sampler, sampler.magFilter, prec, coord, result)) + return true; + + if (canBeMinified) { + /** @type {boolean} */ var isNearestMipmap = tcuTexVerifierUtil.isNearestMipmapFilter(sampler.minFilter); + /** @type {boolean} */ var isLinearMipmap = tcuTexVerifierUtil.isLinearMipmapFilter(sampler.minFilter); + /** @type {number} */ var minTexLevel = 0; + /** @type {number} */ var maxTexLevel = texture.getNumLevels() - 1; + + assertMsgOptions(minTexLevel <= maxTexLevel, 'minTexLevel > maxTexLevel', false, true); + + if (isLinearMipmap && minTexLevel < maxTexLevel) { + minLevel = deMath.clamp(Math.floor(minLod), minTexLevel, maxTexLevel - 1); + maxLevel = deMath.clamp(Math.floor(maxLod), minTexLevel, maxTexLevel - 1); + + assertMsgOptions(minLevel <= maxLevel, 'minLevel > maxLevel', false, true); + + for (var level = minLevel; level <= maxLevel; level++) { + /** @type {number} */ var minF = deMath.clamp(minLod - level, 0, 1); + /** @type {number} */ var maxF = deMath.clamp(maxLod - level, 0, 1); + + if (tcuTexLookupVerifier.isMipmapLinearSampleResultValid_CoordAsVec3(texture.getLevel(level), texture.getLevel(level + 1), sampler, tcuTexVerifierUtil.getLevelFilter(sampler.minFilter), prec, coord, [minF, maxF], result)) + return true; + } + } else if (isNearestMipmap) { + // \note The accurate formula for nearest mipmapping is level = ceil(lod + 0.5) - 1 but Khronos has made + // decision to allow floor(lod + 0.5) as well. + minLevel = deMath.clamp(Math.ceil(minLod + 0.5) - 1, minTexLevel, maxTexLevel); + maxLevel = deMath.clamp(Math.floor(maxLod + 0.5), minTexLevel, maxTexLevel); + + assertMsgOptions(minLevel <= maxLevel, 'minLevel > maxLevel', false, true); + + for (var level = minLevel; level <= maxLevel; level++) { + if (tcuTexLookupVerifier.isLevelSampleResultValid_CoordAsVec3(texture.getLevel(level), sampler, tcuTexVerifierUtil.getLevelFilter(sampler.minFilter), prec, coord, result)) + return true; + } + } else { + if (tcuTexLookupVerifier.isLevelSampleResultValid_CoordAsVec3(texture.getLevel(0), sampler, sampler.minFilter, prec, coord, result)) + return true; + } + } + + return false; + }; + + /** + * @param {Array<tcuTexture.ConstPixelBufferAccess>} faces (&faces)[CUBEFACE_LAST] + * @param {tcuTexture.Sampler} sampler + * @param {tcuTexLookupVerifier.LookupPrecision} prec + * @param {tcuTexture.CubeFaceCoords} coords + * @param {Array<number>} result + * @return {boolean} + */ + tcuTexLookupVerifier.isSeamlessLinearSampleResultValid = function(faces, sampler, prec, coords, result) { + /** @type {number} */ var size = faces[coords.face].getWidth(); + + /** @type {Array<number>} */ var uBounds = tcuTexVerifierUtil.computeNonNormalizedCoordBounds(sampler.normalizedCoords, size, coords.s, prec.coordBits[0], prec.uvwBits[0]); + /** @type {Array<number>} */ var vBounds = tcuTexVerifierUtil.computeNonNormalizedCoordBounds(sampler.normalizedCoords, size, coords.t, prec.coordBits[1], prec.uvwBits[1]); + + // Integer coordinate bounds for (x0,y0) - without wrap mode + /** @type {number} */ var minI = Math.floor(uBounds[0] - 0.5); + /** @type {number} */ var maxI = Math.floor(uBounds[1] - 0.5); + /** @type {number} */ var minJ = Math.floor(vBounds[0] - 0.5); + /** @type {number} */ var maxJ = Math.floor(vBounds[1] - 0.5); + + /** @type {tcuTexture.TextureChannelClass} */ var texClass = tcuTexture.getTextureChannelClass(faces[coords.face].getFormat().type); + /** @type {number} */ var searchStep = (texClass == tcuTexture.TextureChannelClass.UNSIGNED_FIXED_POINT) ? tcuTexLookupVerifier.computeBilinearSearchStepForUnorm(prec) : + (texClass == tcuTexture.TextureChannelClass.SIGNED_FIXED_POINT) ? tcuTexLookupVerifier.computeBilinearSearchStepForSnorm(prec) : + 0; // Step is computed for floating-point quads based on texel values. + + for (var j = minJ; j <= maxJ; j++) { + for (var i = minI; i <= maxI; i++) { + /** @type {tcuTexture.CubeFaceCoords} */ var c00 = tcuTexture.remapCubeEdgeCoords(new tcuTexture.CubeFaceCoords(coords.face, [i + 0, j + 0]), size); + /** @type {tcuTexture.CubeFaceCoords} */ var c10 = tcuTexture.remapCubeEdgeCoords(new tcuTexture.CubeFaceCoords(coords.face, [i + 1, j + 0]), size); + /** @type {tcuTexture.CubeFaceCoords} */ var c01 = tcuTexture.remapCubeEdgeCoords(new tcuTexture.CubeFaceCoords(coords.face, [i + 0, j + 1]), size); + /** @type {tcuTexture.CubeFaceCoords} */ var c11 = tcuTexture.remapCubeEdgeCoords(new tcuTexture.CubeFaceCoords(coords.face, [i + 1, j + 1]), size); + + // If any of samples is out of both edges, implementations can do pretty much anything according to spec. + // \todo [2013-07-08 pyry] Test the special case where all corner pixels have exactly the same color. + if (c00 == null || c01 == null || c10 == null || c11 == null || + c00.face == null || c01.face == null || c10.face == null || c11.face == null) + return true; + + // Bounds for filtering factors + /** @type {number} */ var minA = deMath.clamp((uBounds[0] - 0.5) - i, 0, 1); + /** @type {number} */ var maxA = deMath.clamp((uBounds[1] - 0.5) - i, 0, 1); + /** @type {number} */ var minB = deMath.clamp((vBounds[0] - 0.5) - j, 0, 1); + /** @type {number} */ var maxB = deMath.clamp((vBounds[1] - 0.5) - j, 0, 1); + + /** @type {tcuTexLookupVerifier.ColorQuad} */ + var quad = new tcuTexLookupVerifier.ColorQuad([], [], [], []); + quad.p00 = tcuTexLookupVerifier.lookupFloat(faces[c00.face], sampler, c00.s, c00.t, 0); + quad.p10 = tcuTexLookupVerifier.lookupFloat(faces[c10.face], sampler, c10.s, c10.t, 0); + quad.p01 = tcuTexLookupVerifier.lookupFloat(faces[c01.face], sampler, c01.s, c01.t, 0); + quad.p11 = tcuTexLookupVerifier.lookupFloat(faces[c11.face], sampler, c11.s, c11.t, 0); + + if (texClass == tcuTexture.TextureChannelClass.FLOATING_POINT) + searchStep = tcuTexLookupVerifier.computeBilinearSearchStepFromFloatQuad(prec, quad); + + if (tcuTexLookupVerifier.isBilinearRangeValid(prec, quad, [minA, maxA], [minB, maxB], searchStep, result)) + return true; + } + } + + return false; + }; + + /** + * @param {Array<tcuTexture.ConstPixelBufferAccess>} faces0 (&faces0)[CUBEFACE_LAST] + * @param {Array<tcuTexture.ConstPixelBufferAccess>} faces1 (&faces1)[CUBEFACE_LAST] + * @param {tcuTexture.Sampler} sampler + * @param {tcuTexLookupVerifier.LookupPrecision} prec + * @param {tcuTexture.CubeFaceCoords} coords + * @param {Array<number>} fBounds + * @param {Array<number>} result + * @return {boolean} + */ + tcuTexLookupVerifier.isSeamplessLinearMipmapLinearSampleResultValid = function(faces0, faces1, sampler, prec, coords, fBounds, result) { + // \todo [2013-07-04 pyry] This is strictly not correct as coordinates between levels should be dependent. + // Right now this allows pairing any two valid bilinear quads. + /** @type {number} */ var size0 = faces0[coords.face].getWidth(); + /** @type {number} */ var size1 = faces1[coords.face].getWidth(); + + /** @type {Array<number>} */ var uBounds0 = tcuTexVerifierUtil.computeNonNormalizedCoordBounds(sampler.normalizedCoords, size0, coords.s, prec.coordBits[0], prec.uvwBits[0]); + /** @type {Array<number>} */ var uBounds1 = tcuTexVerifierUtil.computeNonNormalizedCoordBounds(sampler.normalizedCoords, size1, coords.s, prec.coordBits[0], prec.uvwBits[0]); + /** @type {Array<number>} */ var vBounds0 = tcuTexVerifierUtil.computeNonNormalizedCoordBounds(sampler.normalizedCoords, size0, coords.t, prec.coordBits[1], prec.uvwBits[1]); + /** @type {Array<number>} */ var vBounds1 = tcuTexVerifierUtil.computeNonNormalizedCoordBounds(sampler.normalizedCoords, size1, coords.t, prec.coordBits[1], prec.uvwBits[1]); + + // Integer coordinates - without wrap mode + /** @type {number} */ var minI0 = Math.floor(uBounds0[0] - 0.5); + /** @type {number} */ var maxI0 = Math.floor(uBounds0[1] - 0.5); + /** @type {number} */ var minI1 = Math.floor(uBounds1[0] - 0.5); + /** @type {number} */ var maxI1 = Math.floor(uBounds1[1] - 0.5); + /** @type {number} */ var minJ0 = Math.floor(vBounds0[0] - 0.5); + /** @type {number} */ var maxJ0 = Math.floor(vBounds0[1] - 0.5); + /** @type {number} */ var minJ1 = Math.floor(vBounds1[0] - 0.5); + /** @type {number} */ var maxJ1 = Math.floor(vBounds1[1] - 0.5); + + /** @type {tcuTexture.TextureChannelClass} */ var texClass = tcuTexture.getTextureChannelClass(faces0[coords.face].getFormat().type); + /** @type {number} */ var cSearchStep = (texClass == tcuTexture.TextureChannelClass.UNSIGNED_FIXED_POINT) ? tcuTexLookupVerifier.computeBilinearSearchStepForUnorm(prec) : + (texClass == tcuTexture.TextureChannelClass.SIGNED_FIXED_POINT) ? tcuTexLookupVerifier.computeBilinearSearchStepForSnorm(prec) : + 0; // Step is computed for floating-point quads based on texel values. + + /** @type {tcuTexture.CubeFaceCoords} */ var c00; + /** @type {tcuTexture.CubeFaceCoords} */ var c10; + /** @type {tcuTexture.CubeFaceCoords} */ var c01; + /** @type {tcuTexture.CubeFaceCoords} */ var c11; + + for (var j0 = minJ0; j0 <= maxJ0; j0++) { + for (var i0 = minI0; i0 <= maxI0; i0++) { + /** @type {tcuTexLookupVerifier.ColorQuad} */ + var quad0 = new tcuTexLookupVerifier.ColorQuad([], [], [], []); + /** @type {number} */ var searchStep0; + + c00 = tcuTexture.remapCubeEdgeCoords(new tcuTexture.CubeFaceCoords(coords.face, [i0 + 0, j0 + 0]), size0); + c10 = tcuTexture.remapCubeEdgeCoords(new tcuTexture.CubeFaceCoords(coords.face, [i0 + 1, j0 + 0]), size0); + c01 = tcuTexture.remapCubeEdgeCoords(new tcuTexture.CubeFaceCoords(coords.face, [i0 + 0, j0 + 1]), size0); + c11 = tcuTexture.remapCubeEdgeCoords(new tcuTexture.CubeFaceCoords(coords.face, [i0 + 1, j0 + 1]), size0); + + // If any of samples is out of both edges, implementations can do pretty much anything according to spec. + // \todo [2013-07-08 pyry] Test the special case where all corner pixels have exactly the same color. + if (c00 == null || c01 == null || c10 == null || c11 == null || + c00.face == null || c01.face == null || c10.face == null || c11.face == null) + return true; + + quad0.p00 = tcuTexLookupVerifier.lookupFloat(faces0[c00.face], sampler, c00.s, c00.t, 0); + quad0.p10 = tcuTexLookupVerifier.lookupFloat(faces0[c10.face], sampler, c10.s, c10.t, 0); + quad0.p01 = tcuTexLookupVerifier.lookupFloat(faces0[c01.face], sampler, c01.s, c01.t, 0); + quad0.p11 = tcuTexLookupVerifier.lookupFloat(faces0[c11.face], sampler, c11.s, c11.t, 0); + + if (texClass == tcuTexture.TextureChannelClass.FLOATING_POINT) + searchStep0 = tcuTexLookupVerifier.computeBilinearSearchStepFromFloatQuad(prec, quad0); + else + searchStep0 = cSearchStep; + + /** @type {number} */ var minA0 = deMath.clamp((uBounds0[0] - 0.5) - i0, 0, 1); + /** @type {number} */ var maxA0 = deMath.clamp((uBounds0[1] - 0.5) - i0, 0, 1); + /** @type {number} */ var minB0 = deMath.clamp((vBounds0[0] - 0.5) - j0, 0, 1); + /** @type {number} */ var maxB0 = deMath.clamp((vBounds0[1] - 0.5) - j0, 0, 1); + + for (var j1 = minJ1; j1 <= maxJ1; j1++) { + for (var i1 = minI1; i1 <= maxI1; i1++) { + /** @type {tcuTexLookupVerifier.ColorQuad} */ + var quad1 = new tcuTexLookupVerifier.ColorQuad([], [], [], []); + /** @type {number} */ var searchStep1; + + c00 = tcuTexture.remapCubeEdgeCoords(new tcuTexture.CubeFaceCoords(coords.face, [i1 + 0, j1 + 0]), size1); + c10 = tcuTexture.remapCubeEdgeCoords(new tcuTexture.CubeFaceCoords(coords.face, [i1 + 1, j1 + 0]), size1); + c01 = tcuTexture.remapCubeEdgeCoords(new tcuTexture.CubeFaceCoords(coords.face, [i1 + 0, j1 + 1]), size1); + c11 = tcuTexture.remapCubeEdgeCoords(new tcuTexture.CubeFaceCoords(coords.face, [i1 + 1, j1 + 1]), size1); + + if (c00 == null || c01 == null || c10 == null || c11 == null || + c00.face == null || c01.face == null || c10.face == null || c11.face == null) + return true; + + quad1.p00 = tcuTexLookupVerifier.lookupFloat(faces1[c00.face], sampler, c00.s, c00.t, 0); + quad1.p10 = tcuTexLookupVerifier.lookupFloat(faces1[c10.face], sampler, c10.s, c10.t, 0); + quad1.p01 = tcuTexLookupVerifier.lookupFloat(faces1[c01.face], sampler, c01.s, c01.t, 0); + quad1.p11 = tcuTexLookupVerifier.lookupFloat(faces1[c11.face], sampler, c11.s, c11.t, 0); + + if (texClass == tcuTexture.TextureChannelClass.FLOATING_POINT) + searchStep1 = tcuTexLookupVerifier.computeBilinearSearchStepFromFloatQuad(prec, quad1); + else + searchStep1 = cSearchStep; + + /** @type {number} */ var minA1 = deMath.clamp((uBounds1[0] - 0.5) - i1, 0, 1); + /** @type {number} */ var maxA1 = deMath.clamp((uBounds1[1] - 0.5) - i1, 0, 1); + /** @type {number} */ var minB1 = deMath.clamp((vBounds1[0] - 0.5) - j1, 0, 1); + /** @type {number} */ var maxB1 = deMath.clamp((vBounds1[1] - 0.5) - j1, 0, 1); + + if (tcuTexLookupVerifier.is2DTrilinearFilterResultValid(prec, quad0, quad1, [minA0, maxA0], [minB0, maxB0], [minA1, maxA1], [minB1, maxB1], + fBounds, Math.min(searchStep0, searchStep1), result)) + return true; + } + } + } + } + + return false; + }; + + /** + * @param {Array<tcuTexture.ConstPixelBufferAccess>} level (&level)[CUBEFACE_LAST] + * @param {tcuTexture.Sampler} sampler + * @param {tcuTexture.FilterMode} filterMode + * @param {tcuTexLookupVerifier.LookupPrecision} prec + * @param {tcuTexture.CubeFaceCoords} coords + * @param {Array<number>} result + * @return {boolean} + */ + tcuTexLookupVerifier.isCubeLevelSampleResultValid = function(level, sampler, filterMode, prec, coords, result) { + if (filterMode == tcuTexture.FilterMode.LINEAR) { + if (sampler.seamlessCubeMap) + return tcuTexLookupVerifier.isSeamlessLinearSampleResultValid(level, sampler, prec, coords, result); + else + return tcuTexLookupVerifier.isLinearSampleResultValid_CoordAsVec2AndInt(level[coords.face], sampler, prec, [coords.s, coords.t], 0, result); + } else + return tcuTexLookupVerifier.isNearestSampleResultValid_CoordAsVec2AndInt(level[coords.face], sampler, prec, [coords.s, coords.t], 0, result); + }; + + /** + * @param {Array<tcuTexture.ConstPixelBufferAccess>} faces0 (&faces0)[CUBEFACE_LAST] + * @param {Array<tcuTexture.ConstPixelBufferAccess>} faces1 (&faces1)[CUBEFACE_LAST] + * @param {tcuTexture.Sampler} sampler + * @param {tcuTexture.FilterMode} levelFilter + * @param {tcuTexLookupVerifier.LookupPrecision} prec + * @param {tcuTexture.CubeFaceCoords} coords + * @param {Array<number>} fBounds + * @param {Array<number>} result + * @return {boolean} + */ + tcuTexLookupVerifier.isCubeMipmapLinearSampleResultValid = function(faces0, faces1, sampler, levelFilter, prec, coords, fBounds, result) { + if (levelFilter == tcuTexture.FilterMode.LINEAR) { + if (sampler.seamlessCubeMap) + return tcuTexLookupVerifier.isSeamplessLinearMipmapLinearSampleResultValid(faces0, faces1, sampler, prec, coords, fBounds, result); + else + return tcuTexLookupVerifier.isLinearMipmapLinearSampleResultValid_CoordAsVec2AndInt(faces0[coords.face], faces1[coords.face], sampler, prec, [coords.s, coords.t], 0, fBounds, result); + } else + return tcuTexLookupVerifier.isNearestMipmapLinearSampleResultValid_CoordAsVec2AndInt(faces0[coords.face], faces1[coords.face], sampler, prec, [coords.s, coords.t], 0, fBounds, result); + }; + + /** + * @param {tcuTexture.TextureCubeView} texture + * @param {number} levelNdx + * @param {Array<tcuTexture.ConstPixelBufferAccess>} out (&out)[CUBEFACE_LAST] + */ + tcuTexLookupVerifier.getCubeLevelFaces = function(texture, levelNdx, out) { + for (var faceNdx = 0; faceNdx < 6; faceNdx++) + out[faceNdx] = texture.getLevelFace(levelNdx, /** @type {tcuTexture.CubeFace} */ (faceNdx)); + }; + + /** + * @param {number} numLayers + * @param {number} numCoordBits + * @param {number} layerCoord + * @return {Array<number>} + */ + tcuTexLookupVerifier.computeLayerRange = function(numLayers, numCoordBits, layerCoord) { + /** @type {number} */ var err = tcuTexVerifierUtil.computeFloatingPointError(layerCoord, numCoordBits); + /** @type {number} */ var minL = Math.floor(layerCoord - err + 0.5); // Round down + /** @type {number} */ var maxL = Math.ceil(layerCoord + err + 0.5) - 1; // Round up + + assertMsgOptions(minL <= maxL, 'minL > maxL', false, true); + + return [deMath.clamp(minL, 0, numLayers - 1), deMath.clamp(maxL, 0, numLayers - 1)]; + }; + + /** + * @param {Array<number>} bits + * @return {Array<number>} + */ + tcuTexLookupVerifier.computeFixedPointThreshold = function(bits) { + return tcuTexVerifierUtil.computeFixedPointError_Vector(bits); + }; + + /** + * @param {Array<number>} bits + * @param {Array<number>} value + * @return {Array<number>} + */ + tcuTexLookupVerifier.computeFloatingPointThreshold = function(bits, value) { + return tcuTexVerifierUtil.computeFloatingPointError_Vector(value, bits); + }; + + /** + * @param {number} dudx + * @param {number} dvdx + * @param {number} dwdx + * @param {number} dudy + * @param {number} dvdy + * @param {number} dwdy + * @param {tcuTexLookupVerifier.LodPrecision} prec + * @return {Array<number>} + */ + tcuTexLookupVerifier.computeLodBoundsFromDerivates = function(dudx, dvdx, dwdx, dudy, dvdy, dwdy, prec) { + /** @type {number} */ var mu = Math.max(Math.abs(dudx), Math.abs(dudy)); + /** @type {number} */ var mv = Math.max(Math.abs(dvdx), Math.abs(dvdy)); + /** @type {number} */ var mw = Math.max(Math.abs(dwdx), Math.abs(dwdy)); + /** @type {number} */ var minDBound = Math.max(Math.max(mu, mv), mw); + /** @type {number} */ var maxDBound = mu + mv + mw; + /** @type {number} */ var minDErr = tcuTexVerifierUtil.computeFloatingPointError(minDBound, prec.derivateBits); + /** @type {number} */ var maxDErr = tcuTexVerifierUtil.computeFloatingPointError(maxDBound, prec.derivateBits); + /** @type {number} */ var minLod = Math.log2(minDBound - minDErr); + /** @type {number} */ var maxLod = Math.log2(maxDBound + maxDErr); + /** @type {number} */ var lodErr = tcuTexVerifierUtil.computeFixedPointError(prec.lodBits); + + assertMsgOptions(minLod <= maxLod, 'Error: minLod > maxLod', false, true); + return [minLod - lodErr, maxLod + lodErr]; + }; + + /** + * @param {number} dudx + * @param {number} dvdx + * @param {number} dudy + * @param {number} dvdy + * @param {tcuTexLookupVerifier.LodPrecision} prec + * @return {Array<number>} + */ + tcuTexLookupVerifier.computeLodBoundsFromDerivatesUV = function(dudx, dvdx, dudy, dvdy, prec) { + return tcuTexLookupVerifier.computeLodBoundsFromDerivates(dudx, dvdx, 0, dudy, dvdy, 0, prec); + }; + + /** + * @param {number} dudx + * @param {number} dudy + * @param {tcuTexLookupVerifier.LodPrecision} prec + * @return {Array<number>} + */ + tcuTexLookupVerifier.computeLodBoundsFromDerivatesU = function(dudx, dudy, prec) { + return tcuTexLookupVerifier.computeLodBoundsFromDerivates(dudx, 0, 0, dudy, 0, 0, prec); + }; + + /** + * @param {Array<number>} coord + * @param {Array<number>} coordDx + * @param {Array<number>} coordDy + * @param {number} faceSize + * @param {tcuTexLookupVerifier.LodPrecision} prec + * @return {Array<number>} + */ + tcuTexLookupVerifier.computeCubeLodBoundsFromDerivates = function(coord, coordDx, coordDy, faceSize, prec) { + /** @type {boolean} */ var allowBrokenEdgeDerivate = false; + /** @type {tcuTexture.CubeFace} */ var face = tcuTexture.selectCubeFace(coord); + /** @type {number} */ var maNdx = 0; + /** @type {number} */ var sNdx = 0; + /** @type {number} */ var tNdx = 0; + + // \note Derivate signs don't matter when computing lod + switch (face) { + case tcuTexture.CubeFace.CUBEFACE_NEGATIVE_X: + case tcuTexture.CubeFace.CUBEFACE_POSITIVE_X: maNdx = 0; sNdx = 2; tNdx = 1; break; + case tcuTexture.CubeFace.CUBEFACE_NEGATIVE_Y: + case tcuTexture.CubeFace.CUBEFACE_POSITIVE_Y: maNdx = 1; sNdx = 0; tNdx = 2; break; + case tcuTexture.CubeFace.CUBEFACE_NEGATIVE_Z: + case tcuTexture.CubeFace.CUBEFACE_POSITIVE_Z: maNdx = 2; sNdx = 0; tNdx = 1; break; + default: + throw new Error('Invalid CubeFace.'); + } + + /** @type {number} */ var sc = coord[sNdx]; + /** @type {number} */ var tc = coord[tNdx]; + /** @type {number} */ var ma = Math.abs(coord[maNdx]); + /** @type {number} */ var scdx = coordDx[sNdx]; + /** @type {number} */ var tcdx = coordDx[tNdx]; + /** @type {number} */ var madx = Math.abs(coordDx[maNdx]); + /** @type {number} */ var scdy = coordDy[sNdx]; + /** @type {number} */ var tcdy = coordDy[tNdx]; + /** @type {number} */ var mady = Math.abs(coordDy[maNdx]); + /** @type {number} */ var dudx = faceSize * 0.5 * (scdx * ma - sc * madx) / (ma * ma); + /** @type {number} */ var dvdx = faceSize * 0.5 * (tcdx * ma - tc * madx) / (ma * ma); + /** @type {number} */ var dudy = faceSize * 0.5 * (scdy * ma - sc * mady) / (ma * ma); + /** @type {number} */ var dvdy = faceSize * 0.5 * (tcdy * ma - tc * mady) / (ma * ma); + /** @type {Array<number>} */ var bounds = tcuTexLookupVerifier.computeLodBoundsFromDerivatesUV(dudx, dvdx, dudy, dvdy, prec); + + // Implementations may compute derivate from projected (s, t) resulting in incorrect values at edges. + if (allowBrokenEdgeDerivate) { + /** @type {Array<number>} */ var dxErr = tcuTexVerifierUtil.computeFloatingPointError_Vector(coordDx, [prec.derivateBits, prec.derivateBits, prec.derivateBits]); + /** @type {Array<number>} */ var dyErr = tcuTexVerifierUtil.computeFloatingPointError_Vector(coordDy, [prec.derivateBits, prec.derivateBits, prec.derivateBits]); + /** @type {Array<number>} */ var xoffs = deMath.add(deMath.abs(coordDx), dxErr); + /** @type {Array<number>} */ var yoffs = deMath.add(deMath.abs(coordDy), dyErr); + + if (tcuTexture.selectCubeFace(deMath.add(coord, xoffs)) != face || + tcuTexture.selectCubeFace(deMath.subtract(coord, xoffs)) != face || + tcuTexture.selectCubeFace(deMath.add(coord, yoffs)) != face || + tcuTexture.selectCubeFace(deMath.subtract(coord, yoffs)) != face) { + return [bounds[0], 1000]; + } + } + + return bounds; + }; + + /** + * @param {Array<number>} lodBounds + * @param {Array<number>} lodMinMax + * @param {tcuTexLookupVerifier.LodPrecision} prec + * @return {Array<number>} + */ + tcuTexLookupVerifier.clampLodBounds = function(lodBounds, lodMinMax, prec) { + /** @type {number} */ var lodErr = tcuTexVerifierUtil.computeFixedPointError(prec.lodBits); + /** @type {number} */ var a = lodMinMax[0]; + /** @type {number} */ var b = lodMinMax[1]; + return [deMath.clamp(lodBounds[0], a - lodErr, b - lodErr), deMath.clamp(lodBounds[1], a + lodErr, b + lodErr)]; + }; + + /** + * @param {tcuTexture.ConstPixelBufferAccess} access + * @param {tcuTexture.Sampler} sampler + * @param {tcuTexLookupVerifier.TexLookupScaleMode} scaleMode + * @param {tcuTexLookupVerifier.LookupPrecision} prec + * @param {Array<number>} coord + * @param {number} coordZ + * @param {Array<number>} result + * @return {boolean} + */ + tcuTexLookupVerifier.isLevel2DLookupResultValid = function(access, sampler, scaleMode, prec, coord, coordZ, result) { + /** @type {tcuTexture.FilterMode} */ + var filterMode = (scaleMode == tcuTexLookupVerifier.TexLookupScaleMode.MAGNIFY) ? sampler.magFilter : sampler.minFilter; + return tcuTexLookupVerifier.isLevelSampleResultValid_CoordAsVec2AndInt(access, sampler, filterMode, prec, coord, coordZ, result); + }; + + /** + * @param {tcuTexture.ConstPixelBufferAccess} access + * @param {tcuTexture.Sampler} sampler + * @param {tcuTexLookupVerifier.TexLookupScaleMode} scaleMode + * @param {tcuTexLookupVerifier.LookupPrecision} prec + * @param {Array<number>} coord + * @param {number} coordZ + * @param {Array<number>} result + * @return {boolean} + */ + tcuTexLookupVerifier.isLevel2DLookupResultValid_Int = function(access, sampler, scaleMode, prec, coord, coordZ, result) { + assertMsgOptions(sampler.minFilter == tcuTexture.FilterMode.NEAREST && sampler.magFilter == tcuTexture.FilterMode.NEAREST, 'minFilter and magFilter must be NEAREST', false, true); + return tcuTexLookupVerifier.isNearestSampleResultValid_CoordAsVec2AndInt(access, sampler, prec, coord, coordZ, result); + }; + + /** + * @param {tcuTexture.ConstPixelBufferAccess} access + * @param {tcuTexture.Sampler} sampler + * @param {tcuTexLookupVerifier.TexLookupScaleMode} scaleMode + * @param {tcuTexLookupVerifier.LookupPrecision} prec + * @param {Array<number>} coord + * @param {Array<number>} result + * @return {boolean} + */ + tcuTexLookupVerifier.isLevel3DLookupResultValid = function(access, sampler, scaleMode, prec, coord, result) { + /** @type {tcuTexture.FilterMode} */ + var filterMode = (scaleMode == tcuTexLookupVerifier.TexLookupScaleMode.MAGNIFY) ? sampler.magFilter : sampler.minFilter; + return tcuTexLookupVerifier.isLevelSampleResultValid_CoordAsVec3(access, sampler, filterMode, prec, coord, result); + }; + + /** + * @param {tcuTexture.ConstPixelBufferAccess} access + * @param {tcuTexture.Sampler} sampler + * @param {tcuTexLookupVerifier.TexLookupScaleMode} scaleMode + * @param {tcuTexLookupVerifier.LookupPrecision} prec + * @param {Array<number>} coord + * @param {Array<number>} result + * @return {boolean} + */ + tcuTexLookupVerifier.isLevel3DLookupResultValid_Int = function(access, sampler, scaleMode, prec, coord, result) { + assertMsgOptions(sampler.minFilter == tcuTexture.FilterMode.NEAREST && sampler.magFilter == tcuTexture.FilterMode.NEAREST, 'minFilter and magFilter must be NEAREST', false, true); + return tcuTexLookupVerifier.isNearestSampleResultValid_CoordAsVec3(access, sampler, prec, coord, result); + }; + +}); |