Google Git
Sign in
webkit / WebKit / f3ecda48cdde51cb7c8c882d151b56b514c68e28 / . / LayoutTests / webgl / resources / webgl_test_files / deqp / framework / common / tcuTexLookupVerifier.js
blob: 6b471998aa824eddeb123263914dcba83b5acb59 [file] [log] [blame]
/*-------------------------------------------------------------------------
* 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);
};
});