xref: /aosp_15_r20/external/deqp/framework/common/tcuTexCompareVerifier.cpp (revision 35238bce31c2a825756842865a792f8cf7f89930)

/*-------------------------------------------------------------------------
 * drawElements Quality Program Tester Core
 * ----------------------------------------
 *
 * 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.
 *
 *//*!
 * \file
 * \brief Texture compare (shadow) result verifier.
 *//*--------------------------------------------------------------------*/

#include "tcuTexCompareVerifier.hpp"
#include "tcuTexVerifierUtil.hpp"
#include "tcuTextureUtil.hpp"
#include "tcuVectorUtil.hpp"
#include "deMath.h"

namespace tcu
{

using namespace TexVerifierUtil;

// Generic utilities

#if defined(DE_DEBUG)
static bool isSamplerSupported(const Sampler &sampler)
{
    return sampler.compare != Sampler::COMPAREMODE_NONE && isWrapModeSupported(sampler.wrapS) &&
           isWrapModeSupported(sampler.wrapT) && isWrapModeSupported(sampler.wrapR);
}
#endif // DE_DEBUG

struct CmpResultSet
{
    bool isTrue;
    bool isFalse;

    CmpResultSet(void) : isTrue(false), isFalse(false)
    {
    }
};

static CmpResultSet execCompare(const Sampler::CompareMode compareMode, const float cmpValue_,
                                const float cmpReference_, const int referenceBits, const bool isFixedPoint)
{
    const bool clampValues =
        isFixedPoint; // if comparing against a floating point texture, ref (and value) is not clamped
    const float cmpValue     = (clampValues) ? (de::clamp(cmpValue_, 0.0f, 1.0f)) : (cmpValue_);
    const float cmpReference = (clampValues) ? (de::clamp(cmpReference_, 0.0f, 1.0f)) : (cmpReference_);
    const float err          = computeFixedPointError(referenceBits);
    CmpResultSet res;

    switch (compareMode)
    {
    case Sampler::COMPAREMODE_LESS:
        res.isTrue  = cmpReference - err < cmpValue;
        res.isFalse = cmpReference + err >= cmpValue;
        break;

    case Sampler::COMPAREMODE_LESS_OR_EQUAL:
        res.isTrue  = cmpReference - err <= cmpValue;
        res.isFalse = cmpReference + err > cmpValue;
        break;

    case Sampler::COMPAREMODE_GREATER:
        res.isTrue  = cmpReference + err > cmpValue;
        res.isFalse = cmpReference - err <= cmpValue;
        break;

    case Sampler::COMPAREMODE_GREATER_OR_EQUAL:
        res.isTrue  = cmpReference + err >= cmpValue;
        res.isFalse = cmpReference - err < cmpValue;
        break;

    case Sampler::COMPAREMODE_EQUAL:
        res.isTrue  = de::inRange(cmpValue, cmpReference - err, cmpReference + err);
        res.isFalse = err != 0.0f || cmpValue != cmpReference;
        break;

    case Sampler::COMPAREMODE_NOT_EQUAL:
        res.isTrue  = err != 0.0f || cmpValue != cmpReference;
        res.isFalse = de::inRange(cmpValue, cmpReference - err, cmpReference + err);
        break;

    case Sampler::COMPAREMODE_ALWAYS:
        res.isTrue = true;
        break;

    case Sampler::COMPAREMODE_NEVER:
        res.isFalse = true;
        break;

    default:
        DE_ASSERT(false);
    }

    DE_ASSERT(res.isTrue || res.isFalse);
    return res;
}

static inline bool isResultInSet(const CmpResultSet resultSet, const float result, const int resultBits)
{
    const float err  = computeFixedPointError(resultBits);
    const float minR = result - err;
    const float maxR = result + err;

    return (resultSet.isTrue && de::inRange(1.0f, minR, maxR)) || (resultSet.isFalse && de::inRange(0.0f, minR, maxR));
}

static inline bool coordsInBounds(const ConstPixelBufferAccess &access, int x, int y, int z)
{
    return de::inBounds(x, 0, access.getWidth()) && de::inBounds(y, 0, access.getHeight()) &&
           de::inBounds(z, 0, access.getDepth());
}

// lookup depth value at a point that is guaranteed to not sample border such as cube map faces.
static float lookupDepthNoBorder(const tcu::ConstPixelBufferAccess &access, const Sampler &sampler, int i, int j,
                                 int k = 0)
{
    DE_UNREF(sampler);
    DE_ASSERT(coordsInBounds(access, i, j, k));
    DE_ASSERT(access.getFormat().order == TextureFormat::D || access.getFormat().order == TextureFormat::DS ||
              access.getFormat().order == TextureFormat::R);

    if (access.getFormat().order == TextureFormat::R)
        return access.getPixel(i, j, k).x();
    else
        return access.getPixDepth(i, j, k);
}

static float lookupDepth(const tcu::ConstPixelBufferAccess &access, const Sampler &sampler, int i, int j, int k)
{
    if (coordsInBounds(access, i, j, k))
        return lookupDepthNoBorder(access, sampler, i, j, k);
    else
        return sampleTextureBorder<float>(access.getFormat(), sampler).x();
}

// Values are in order (0,0), (1,0), (0,1), (1,1)
static float bilinearInterpolate(const Vec4 &values, const float x, const float y)
{
    const float v00 = values[0];
    const float v10 = values[1];
    const float v01 = values[2];
    const float v11 = values[3];
    const float res = v00 * (1.0f - x) * (1.0f - y) + v10 * x * (1.0f - y) + v01 * (1.0f - x) * y + v11 * x * y;
    return res;
}

static bool isFixedPointDepthTextureFormat(const tcu::TextureFormat &format)
{
    const tcu::TextureChannelClass channelClass = tcu::getTextureChannelClass(format.type);

    if (format.order == TextureFormat::D || format.order == TextureFormat::R)
    {
        // depth internal formats cannot be non-normalized integers
        return channelClass != tcu::TEXTURECHANNELCLASS_FLOATING_POINT;
    }
    else if (format.order == TextureFormat::DS)
    {
        // combined formats have no single channel class, detect format manually
        switch (format.type)
        {
        case tcu::TextureFormat::FLOAT_UNSIGNED_INT_24_8_REV:
            return false;
        case tcu::TextureFormat::UNSIGNED_INT_16_8_8:
            return true;
        case tcu::TextureFormat::UNSIGNED_INT_24_8:
            return true;
        case tcu::TextureFormat::UNSIGNED_INT_24_8_REV:
            return true;

        default:
        {
            // unknown format
            DE_ASSERT(false);
            return true;
        }
        }
    }

    return false;
}

static bool isLinearCompareValid(const Sampler::CompareMode compareMode, const TexComparePrecision &prec,
                                 const Vec2 &depths, const Vec2 &fBounds, const float cmpReference, const float result,
                                 const bool isFixedPointDepth)
{
    DE_ASSERT(0.0f <= fBounds.x() && fBounds.x() <= fBounds.y() && fBounds.y() <= 1.0f);

    const float d0 = depths[0];
    const float d1 = depths[1];

    const CmpResultSet cmp0 = execCompare(compareMode, d0, cmpReference, prec.referenceBits, isFixedPointDepth);
    const CmpResultSet cmp1 = execCompare(compareMode, d1, cmpReference, prec.referenceBits, isFixedPointDepth);

    const uint32_t isTrue  = (uint32_t(cmp0.isTrue) << 0) | (uint32_t(cmp1.isTrue) << 1);
    const uint32_t isFalse = (uint32_t(cmp0.isFalse) << 0) | (uint32_t(cmp1.isFalse) << 1);

    // Interpolation parameters
    const float f0 = fBounds.x();
    const float f1 = fBounds.y();

    // Error parameters
    const float pcfErr   = computeFixedPointError(prec.pcfBits);
    const float resErr   = computeFixedPointError(prec.resultBits);
    const float totalErr = pcfErr + resErr;

    // Iterate over all valid combinations.
    for (uint32_t comb = 0; comb < (1 << 2); comb++)
    {
        // Filter out invalid combinations.
        if (((comb & isTrue) | (~comb & isFalse)) != (1 << 2) - 1)
            continue;

        const bool cmp0True = ((comb >> 0) & 1) != 0;
        const bool cmp1True = ((comb >> 1) & 1) != 0;

        const float ref0 = cmp0True ? 1.0f : 0.0f;
        const float ref1 = cmp1True ? 1.0f : 0.0f;

        const float v0   = ref0 * (1.0f - f0) + ref1 * f0;
        const float v1   = ref0 * (1.0f - f1) + ref1 * f1;
        const float minV = de::min(v0, v1);
        const float maxV = de::max(v0, v1);
        const float minR = minV - totalErr;
        const float maxR = maxV + totalErr;

        if (de::inRange(result, minR, maxR))
            return true;
    }

    return false;
}

static inline BVec4 extractBVec4(const uint32_t val, int offset)
{
    return BVec4(((val >> (offset + 0)) & 1) != 0, ((val >> (offset + 1)) & 1) != 0, ((val >> (offset + 2)) & 1) != 0,
                 ((val >> (offset + 3)) & 1) != 0);
}

static bool isBilinearAnyCompareValid(const Sampler::CompareMode compareMode, const TexComparePrecision &prec,
                                      const Vec4 &depths, const float cmpReference, const float result,
                                      const bool isFixedPointDepth)
{
    DE_ASSERT(prec.pcfBits == 0);

    const float d0 = depths[0];
    const float d1 = depths[1];
    const float d2 = depths[2];
    const float d3 = depths[3];

    const CmpResultSet cmp0 = execCompare(compareMode, d0, cmpReference, prec.referenceBits, isFixedPointDepth);
    const CmpResultSet cmp1 = execCompare(compareMode, d1, cmpReference, prec.referenceBits, isFixedPointDepth);
    const CmpResultSet cmp2 = execCompare(compareMode, d2, cmpReference, prec.referenceBits, isFixedPointDepth);
    const CmpResultSet cmp3 = execCompare(compareMode, d3, cmpReference, prec.referenceBits, isFixedPointDepth);

    const bool canBeTrue  = cmp0.isTrue || cmp1.isTrue || cmp2.isTrue || cmp3.isTrue;
    const bool canBeFalse = cmp0.isFalse || cmp1.isFalse || cmp2.isFalse || cmp3.isFalse;

    const float resErr = computeFixedPointError(prec.resultBits);

    const float minBound = canBeFalse ? 0.0f : 1.0f;
    const float maxBound = canBeTrue ? 1.0f : 0.0f;

    return de::inRange(result, minBound - resErr, maxBound + resErr);
}

static bool isBilinearPCFCompareValid(const Sampler::CompareMode compareMode, const TexComparePrecision &prec,
                                      const Vec4 &depths, const Vec2 &xBounds, const Vec2 &yBounds,
                                      const float cmpReference, const float result, const bool isFixedPointDepth)
{
    DE_ASSERT(0.0f <= xBounds.x() && xBounds.x() <= xBounds.y() && xBounds.y() <= 1.0f);
    DE_ASSERT(0.0f <= yBounds.x() && yBounds.x() <= yBounds.y() && yBounds.y() <= 1.0f);
    DE_ASSERT(prec.pcfBits > 0);

    const float d0 = depths[0];
    const float d1 = depths[1];
    const float d2 = depths[2];
    const float d3 = depths[3];

    const CmpResultSet cmp0 = execCompare(compareMode, d0, cmpReference, prec.referenceBits, isFixedPointDepth);
    const CmpResultSet cmp1 = execCompare(compareMode, d1, cmpReference, prec.referenceBits, isFixedPointDepth);
    const CmpResultSet cmp2 = execCompare(compareMode, d2, cmpReference, prec.referenceBits, isFixedPointDepth);
    const CmpResultSet cmp3 = execCompare(compareMode, d3, cmpReference, prec.referenceBits, isFixedPointDepth);

    const uint32_t isTrue = (uint32_t(cmp0.isTrue) << 0) | (uint32_t(cmp1.isTrue) << 1) | (uint32_t(cmp2.isTrue) << 2) |
                            (uint32_t(cmp3.isTrue) << 3);
    const uint32_t isFalse = (uint32_t(cmp0.isFalse) << 0) | (uint32_t(cmp1.isFalse) << 1) |
                             (uint32_t(cmp2.isFalse) << 2) | (uint32_t(cmp3.isFalse) << 3);

    // Interpolation parameters
    const float x0 = xBounds.x();
    const float x1 = xBounds.y();
    const float y0 = yBounds.x();
    const float y1 = yBounds.y();

    // Error parameters
    const float pcfErr   = computeFixedPointError(prec.pcfBits);
    const float resErr   = computeFixedPointError(prec.resultBits);
    const float totalErr = pcfErr + resErr;

    // Iterate over all valid combinations.
    // \note It is not enough to compute minmax over all possible result sets, as ranges may
    //         not necessarily overlap, i.e. there are gaps between valid ranges.
    for (uint32_t comb = 0; comb < (1 << 4); comb++)
    {
        // Filter out invalid combinations:
        //  1) True bit is set in comb but not in isTrue => sample can not be true
        //  2) True bit is NOT set in comb and not in isFalse => sample can not be false
        if (((comb & isTrue) | (~comb & isFalse)) != (1 << 4) - 1)
            continue;

        const BVec4 cmpTrue = extractBVec4(comb, 0);
        const Vec4 refVal   = select(Vec4(1.0f), Vec4(0.0f), cmpTrue);

        const float v0   = bilinearInterpolate(refVal, x0, y0);
        const float v1   = bilinearInterpolate(refVal, x1, y0);
        const float v2   = bilinearInterpolate(refVal, x0, y1);
        const float v3   = bilinearInterpolate(refVal, x1, y1);
        const float minV = de::min(v0, de::min(v1, de::min(v2, v3)));
        const float maxV = de::max(v0, de::max(v1, de::max(v2, v3)));
        const float minR = minV - totalErr;
        const float maxR = maxV + totalErr;

        if (de::inRange(result, minR, maxR))
            return true;
    }

    return false;
}

static bool isBilinearCompareValid(const Sampler::CompareMode compareMode, const TexComparePrecision &prec,
                                   const Vec4 &depths, const Vec2 &xBounds, const Vec2 &yBounds,
                                   const float cmpReference, const float result, const bool isFixedPointDepth)
{
    if (prec.pcfBits > 0)
        return isBilinearPCFCompareValid(compareMode, prec, depths, xBounds, yBounds, cmpReference, result,
                                         isFixedPointDepth);
    else
        return isBilinearAnyCompareValid(compareMode, prec, depths, cmpReference, result, isFixedPointDepth);
}

static bool isTrilinearAnyCompareValid(const Sampler::CompareMode compareMode, const TexComparePrecision &prec,
                                       const Vec4 &depths0, const Vec4 &depths1, const float cmpReference,
                                       const float result, const bool isFixedPointDepth)
{
    DE_ASSERT(prec.pcfBits == 0);

    const CmpResultSet cmp00 =
        execCompare(compareMode, depths0[0], cmpReference, prec.referenceBits, isFixedPointDepth);
    const CmpResultSet cmp01 =
        execCompare(compareMode, depths0[1], cmpReference, prec.referenceBits, isFixedPointDepth);
    const CmpResultSet cmp02 =
        execCompare(compareMode, depths0[2], cmpReference, prec.referenceBits, isFixedPointDepth);
    const CmpResultSet cmp03 =
        execCompare(compareMode, depths0[3], cmpReference, prec.referenceBits, isFixedPointDepth);

    const CmpResultSet cmp10 =
        execCompare(compareMode, depths1[0], cmpReference, prec.referenceBits, isFixedPointDepth);
    const CmpResultSet cmp11 =
        execCompare(compareMode, depths1[1], cmpReference, prec.referenceBits, isFixedPointDepth);
    const CmpResultSet cmp12 =
        execCompare(compareMode, depths1[2], cmpReference, prec.referenceBits, isFixedPointDepth);
    const CmpResultSet cmp13 =
        execCompare(compareMode, depths1[3], cmpReference, prec.referenceBits, isFixedPointDepth);

    const bool canBeTrue = cmp00.isTrue || cmp01.isTrue || cmp02.isTrue || cmp03.isTrue || cmp10.isTrue ||
                           cmp11.isTrue || cmp12.isTrue || cmp13.isTrue;
    const bool canBeFalse = cmp00.isFalse || cmp01.isFalse || cmp02.isFalse || cmp03.isFalse || cmp10.isFalse ||
                            cmp11.isFalse || cmp12.isFalse || cmp13.isFalse;

    const float resErr = computeFixedPointError(prec.resultBits);

    const float minBound = canBeFalse ? 0.0f : 1.0f;
    const float maxBound = canBeTrue ? 1.0f : 0.0f;

    return de::inRange(result, minBound - resErr, maxBound + resErr);
}

static bool isTrilinearPCFCompareValid(const Sampler::CompareMode compareMode, const TexComparePrecision &prec,
                                       const Vec4 &depths0, const Vec4 &depths1, const Vec2 &xBounds0,
                                       const Vec2 &yBounds0, const Vec2 &xBounds1, const Vec2 &yBounds1,
                                       const Vec2 &fBounds, const float cmpReference, const float result,
                                       const bool isFixedPointDepth)
{
    DE_ASSERT(0.0f <= xBounds0.x() && xBounds0.x() <= xBounds0.y() && xBounds0.y() <= 1.0f);
    DE_ASSERT(0.0f <= yBounds0.x() && yBounds0.x() <= yBounds0.y() && yBounds0.y() <= 1.0f);
    DE_ASSERT(0.0f <= xBounds1.x() && xBounds1.x() <= xBounds1.y() && xBounds1.y() <= 1.0f);
    DE_ASSERT(0.0f <= yBounds1.x() && yBounds1.x() <= yBounds1.y() && yBounds1.y() <= 1.0f);
    DE_ASSERT(0.0f <= fBounds.x() && fBounds.x() <= fBounds.y() && fBounds.y() <= 1.0f);
    DE_ASSERT(prec.pcfBits > 0);

    const CmpResultSet cmp00 =
        execCompare(compareMode, depths0[0], cmpReference, prec.referenceBits, isFixedPointDepth);
    const CmpResultSet cmp01 =
        execCompare(compareMode, depths0[1], cmpReference, prec.referenceBits, isFixedPointDepth);
    const CmpResultSet cmp02 =
        execCompare(compareMode, depths0[2], cmpReference, prec.referenceBits, isFixedPointDepth);
    const CmpResultSet cmp03 =
        execCompare(compareMode, depths0[3], cmpReference, prec.referenceBits, isFixedPointDepth);

    const CmpResultSet cmp10 =
        execCompare(compareMode, depths1[0], cmpReference, prec.referenceBits, isFixedPointDepth);
    const CmpResultSet cmp11 =
        execCompare(compareMode, depths1[1], cmpReference, prec.referenceBits, isFixedPointDepth);
    const CmpResultSet cmp12 =
        execCompare(compareMode, depths1[2], cmpReference, prec.referenceBits, isFixedPointDepth);
    const CmpResultSet cmp13 =
        execCompare(compareMode, depths1[3], cmpReference, prec.referenceBits, isFixedPointDepth);

    const uint32_t isTrue = (uint32_t(cmp00.isTrue) << 0) | (uint32_t(cmp01.isTrue) << 1) |
                            (uint32_t(cmp02.isTrue) << 2) | (uint32_t(cmp03.isTrue) << 3) |
                            (uint32_t(cmp10.isTrue) << 4) | (uint32_t(cmp11.isTrue) << 5) |
                            (uint32_t(cmp12.isTrue) << 6) | (uint32_t(cmp13.isTrue) << 7);
    const uint32_t isFalse = (uint32_t(cmp00.isFalse) << 0) | (uint32_t(cmp01.isFalse) << 1) |
                             (uint32_t(cmp02.isFalse) << 2) | (uint32_t(cmp03.isFalse) << 3) |
                             (uint32_t(cmp10.isFalse) << 4) | (uint32_t(cmp11.isFalse) << 5) |
                             (uint32_t(cmp12.isFalse) << 6) | (uint32_t(cmp13.isFalse) << 7);

    // Error parameters
    const float pcfErr   = computeFixedPointError(prec.pcfBits);
    const float resErr   = computeFixedPointError(prec.resultBits);
    const float totalErr = pcfErr + resErr;

    // Iterate over all valid combinations.
    for (uint32_t comb = 0; comb < (1 << 8); comb++)
    {
        // Filter out invalid combinations.
        if (((comb & isTrue) | (~comb & isFalse)) != (1 << 8) - 1)
            continue;

        const BVec4 cmpTrue0 = extractBVec4(comb, 0);
        const BVec4 cmpTrue1 = extractBVec4(comb, 4);
        const Vec4 refVal0   = select(Vec4(1.0f), Vec4(0.0f), cmpTrue0);
        const Vec4 refVal1   = select(Vec4(1.0f), Vec4(0.0f), cmpTrue1);

        // Bilinear interpolation within levels.
        const float v00   = bilinearInterpolate(refVal0, xBounds0.x(), yBounds0.x());
        const float v01   = bilinearInterpolate(refVal0, xBounds0.y(), yBounds0.x());
        const float v02   = bilinearInterpolate(refVal0, xBounds0.x(), yBounds0.y());
        const float v03   = bilinearInterpolate(refVal0, xBounds0.y(), yBounds0.y());
        const float minV0 = de::min(v00, de::min(v01, de::min(v02, v03)));
        const float maxV0 = de::max(v00, de::max(v01, de::max(v02, v03)));

        const float v10   = bilinearInterpolate(refVal1, xBounds1.x(), yBounds1.x());
        const float v11   = bilinearInterpolate(refVal1, xBounds1.y(), yBounds1.x());
        const float v12   = bilinearInterpolate(refVal1, xBounds1.x(), yBounds1.y());
        const float v13   = bilinearInterpolate(refVal1, xBounds1.y(), yBounds1.y());
        const float minV1 = de::min(v10, de::min(v11, de::min(v12, v13)));
        const float maxV1 = de::max(v10, de::max(v11, de::max(v12, v13)));

        // Compute min-max bounds by filtering between minimum bounds and maximum bounds between levels.
        // HW can end up choosing pretty much any of samples between levels, and thus interpolating
        // between minimums should yield lower bound for range, and same for upper bound.
        // \todo [2013-07-17 pyry] This seems separable? Can this be optimized? At least ranges could be pre-computed and later combined.
        const float minF0 = minV0 * (1.0f - fBounds.x()) + minV1 * fBounds.x();
        const float minF1 = minV0 * (1.0f - fBounds.y()) + minV1 * fBounds.y();
        const float maxF0 = maxV0 * (1.0f - fBounds.x()) + maxV1 * fBounds.x();
        const float maxF1 = maxV0 * (1.0f - fBounds.y()) + maxV1 * fBounds.y();

        const float minF = de::min(minF0, minF1);
        const float maxF = de::max(maxF0, maxF1);

        const float minR = minF - totalErr;
        const float maxR = maxF + totalErr;

        if (de::inRange(result, minR, maxR))
            return true;
    }

    return false;
}

static bool isTrilinearCompareValid(const Sampler::CompareMode compareMode, const TexComparePrecision &prec,
                                    const Vec4 &depths0, const Vec4 &depths1, const Vec2 &xBounds0,
                                    const Vec2 &yBounds0, const Vec2 &xBounds1, const Vec2 &yBounds1,
                                    const Vec2 &fBounds, const float cmpReference, const float result,
                                    const bool isFixedPointDepth)
{
    if (prec.pcfBits > 0)
        return isTrilinearPCFCompareValid(compareMode, prec, depths0, depths1, xBounds0, yBounds0, xBounds1, yBounds1,
                                          fBounds, cmpReference, result, isFixedPointDepth);
    else
        return isTrilinearAnyCompareValid(compareMode, prec, depths0, depths1, cmpReference, result, isFixedPointDepth);
}

static bool isNearestCompareResultValid(const ConstPixelBufferAccess &level, const Sampler &sampler,
                                        const TexComparePrecision &prec, const Vec2 &coord, const int coordZ,
                                        const float cmpReference, const float result)
{
    const bool isFixedPointDepth = isFixedPointDepthTextureFormat(level.getFormat());
    const Vec2 uBounds = computeNonNormalizedCoordBounds(sampler.normalizedCoords, level.getWidth(), coord.x(),
                                                         prec.coordBits.x(), prec.uvwBits.x());
    const Vec2 vBounds = computeNonNormalizedCoordBounds(sampler.normalizedCoords, level.getHeight(), coord.y(),
                                                         prec.coordBits.y(), prec.uvwBits.y());

    // Integer coordinates - without wrap mode
    const int minI = deFloorFloatToInt32(uBounds.x());
    const int maxI = deFloorFloatToInt32(uBounds.y());
    const int minJ = deFloorFloatToInt32(vBounds.x());
    const int maxJ = deFloorFloatToInt32(vBounds.y());

    for (int j = minJ; j <= maxJ; j++)
    {
        for (int i = minI; i <= maxI; i++)
        {
            const int x       = wrap(sampler.wrapS, i, level.getWidth());
            const int y       = wrap(sampler.wrapT, j, level.getHeight());
            const float depth = lookupDepth(level, sampler, x, y, coordZ);
            const CmpResultSet resSet =
                execCompare(sampler.compare, depth, cmpReference, prec.referenceBits, isFixedPointDepth);

            if (isResultInSet(resSet, result, prec.resultBits))
                return true;
        }
    }

    return false;
}

static bool isLinearCompareResultValid(const ConstPixelBufferAccess &level, const Sampler &sampler,
                                       const TexComparePrecision &prec, const Vec2 &coord, const int coordZ,
                                       const float cmpReference, const float result)
{
    const bool isFixedPointDepth = isFixedPointDepthTextureFormat(level.getFormat());
    const Vec2 uBounds = computeNonNormalizedCoordBounds(sampler.normalizedCoords, level.getWidth(), coord.x(),
                                                         prec.coordBits.x(), prec.uvwBits.x());
    const Vec2 vBounds = computeNonNormalizedCoordBounds(sampler.normalizedCoords, level.getHeight(), coord.y(),
                                                         prec.coordBits.y(), prec.uvwBits.y());

    // Integer coordinate bounds for (x0,y0) - without wrap mode
    const int minI = deFloorFloatToInt32(uBounds.x() - 0.5f);
    const int maxI = deFloorFloatToInt32(uBounds.y() - 0.5f);
    const int minJ = deFloorFloatToInt32(vBounds.x() - 0.5f);
    const int maxJ = deFloorFloatToInt32(vBounds.y() - 0.5f);

    const int w = level.getWidth();
    const int h = level.getHeight();

    // \todo [2013-07-03 pyry] This could be optimized by first computing ranges based on wrap mode.

    for (int j = minJ; j <= maxJ; j++)
    {
        for (int i = minI; i <= maxI; i++)
        {
            // Wrapped coordinates
            const int x0 = wrap(sampler.wrapS, i, w);
            const int x1 = wrap(sampler.wrapS, i + 1, w);
            const int y0 = wrap(sampler.wrapT, j, h);
            const int y1 = wrap(sampler.wrapT, j + 1, h);

            // Bounds for filtering factors
            const float minA = de::clamp((uBounds.x() - 0.5f) - float(i), 0.0f, 1.0f);
            const float maxA = de::clamp((uBounds.y() - 0.5f) - float(i), 0.0f, 1.0f);
            const float minB = de::clamp((vBounds.x() - 0.5f) - float(j), 0.0f, 1.0f);
            const float maxB = de::clamp((vBounds.y() - 0.5f) - float(j), 0.0f, 1.0f);

            const Vec4 depths(lookupDepth(level, sampler, x0, y0, coordZ), lookupDepth(level, sampler, x1, y0, coordZ),
                              lookupDepth(level, sampler, x0, y1, coordZ), lookupDepth(level, sampler, x1, y1, coordZ));

            if (isBilinearCompareValid(sampler.compare, prec, depths, Vec2(minA, maxA), Vec2(minB, maxB), cmpReference,
                                       result, isFixedPointDepth))
                return true;
        }
    }

    return false;
}

static bool isLevelCompareResultValid(const ConstPixelBufferAccess &level, const Sampler &sampler,
                                      const Sampler::FilterMode filterMode, const TexComparePrecision &prec,
                                      const Vec2 &coord, const int coordZ, const float cmpReference, const float result)
{
    if (filterMode == Sampler::LINEAR)
        return isLinearCompareResultValid(level, sampler, prec, coord, coordZ, cmpReference, result);
    else
        return isNearestCompareResultValid(level, sampler, prec, coord, coordZ, cmpReference, result);
}

static bool isNearestMipmapLinearCompareResultValid(const ConstPixelBufferAccess &level0,
                                                    const ConstPixelBufferAccess &level1, const Sampler &sampler,
                                                    const TexComparePrecision &prec, const Vec2 &coord,
                                                    const int coordZ, const Vec2 &fBounds, const float cmpReference,
                                                    const float result)
{
    const bool isFixedPointDepth = isFixedPointDepthTextureFormat(level0.getFormat());

    const int w0 = level0.getWidth();
    const int w1 = level1.getWidth();
    const int h0 = level0.getHeight();
    const int h1 = level1.getHeight();

    const Vec2 uBounds0 =
        computeNonNormalizedCoordBounds(sampler.normalizedCoords, w0, coord.x(), prec.coordBits.x(), prec.uvwBits.x());
    const Vec2 uBounds1 =
        computeNonNormalizedCoordBounds(sampler.normalizedCoords, w1, coord.x(), prec.coordBits.x(), prec.uvwBits.x());
    const Vec2 vBounds0 =
        computeNonNormalizedCoordBounds(sampler.normalizedCoords, h0, coord.y(), prec.coordBits.y(), prec.uvwBits.y());
    const Vec2 vBounds1 =
        computeNonNormalizedCoordBounds(sampler.normalizedCoords, h1, coord.y(), prec.coordBits.y(), prec.uvwBits.y());

    // Integer coordinates - without wrap mode
    const int minI0 = deFloorFloatToInt32(uBounds0.x());
    const int maxI0 = deFloorFloatToInt32(uBounds0.y());
    const int minI1 = deFloorFloatToInt32(uBounds1.x());
    const int maxI1 = deFloorFloatToInt32(uBounds1.y());
    const int minJ0 = deFloorFloatToInt32(vBounds0.x());
    const int maxJ0 = deFloorFloatToInt32(vBounds0.y());
    const int minJ1 = deFloorFloatToInt32(vBounds1.x());
    const int maxJ1 = deFloorFloatToInt32(vBounds1.y());

    for (int j0 = minJ0; j0 <= maxJ0; j0++)
    {
        for (int i0 = minI0; i0 <= maxI0; i0++)
        {
            const float depth0 =
                lookupDepth(level0, sampler, wrap(sampler.wrapS, i0, w0), wrap(sampler.wrapT, j0, h0), coordZ);

            for (int j1 = minJ1; j1 <= maxJ1; j1++)
            {
                for (int i1 = minI1; i1 <= maxI1; i1++)
                {
                    const float depth1 =
                        lookupDepth(level1, sampler, wrap(sampler.wrapS, i1, w1), wrap(sampler.wrapT, j1, h1), coordZ);

                    if (isLinearCompareValid(sampler.compare, prec, Vec2(depth0, depth1), fBounds, cmpReference, result,
                                             isFixedPointDepth))
                        return true;
                }
            }
        }
    }

    return false;
}

static bool isLinearMipmapLinearCompareResultValid(const ConstPixelBufferAccess &level0,
                                                   const ConstPixelBufferAccess &level1, const Sampler &sampler,
                                                   const TexComparePrecision &prec, const Vec2 &coord, const int coordZ,
                                                   const Vec2 &fBounds, const float cmpReference, const float result)
{
    const bool isFixedPointDepth = isFixedPointDepthTextureFormat(level0.getFormat());

    // \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.

    const int w0 = level0.getWidth();
    const int w1 = level1.getWidth();
    const int h0 = level0.getHeight();
    const int h1 = level1.getHeight();

    const Vec2 uBounds0 =
        computeNonNormalizedCoordBounds(sampler.normalizedCoords, w0, coord.x(), prec.coordBits.x(), prec.uvwBits.x());
    const Vec2 uBounds1 =
        computeNonNormalizedCoordBounds(sampler.normalizedCoords, w1, coord.x(), prec.coordBits.x(), prec.uvwBits.x());
    const Vec2 vBounds0 =
        computeNonNormalizedCoordBounds(sampler.normalizedCoords, h0, coord.y(), prec.coordBits.y(), prec.uvwBits.y());
    const Vec2 vBounds1 =
        computeNonNormalizedCoordBounds(sampler.normalizedCoords, h1, coord.y(), prec.coordBits.y(), prec.uvwBits.y());

    // Integer coordinates - without wrap mode
    const int minI0 = deFloorFloatToInt32(uBounds0.x() - 0.5f);
    const int maxI0 = deFloorFloatToInt32(uBounds0.y() - 0.5f);
    const int minI1 = deFloorFloatToInt32(uBounds1.x() - 0.5f);
    const int maxI1 = deFloorFloatToInt32(uBounds1.y() - 0.5f);
    const int minJ0 = deFloorFloatToInt32(vBounds0.x() - 0.5f);
    const int maxJ0 = deFloorFloatToInt32(vBounds0.y() - 0.5f);
    const int minJ1 = deFloorFloatToInt32(vBounds1.x() - 0.5f);
    const int maxJ1 = deFloorFloatToInt32(vBounds1.y() - 0.5f);

    for (int j0 = minJ0; j0 <= maxJ0; j0++)
    {
        for (int i0 = minI0; i0 <= maxI0; i0++)
        {
            const float minA0 = de::clamp((uBounds0.x() - 0.5f) - float(i0), 0.0f, 1.0f);
            const float maxA0 = de::clamp((uBounds0.y() - 0.5f) - float(i0), 0.0f, 1.0f);
            const float minB0 = de::clamp((vBounds0.x() - 0.5f) - float(j0), 0.0f, 1.0f);
            const float maxB0 = de::clamp((vBounds0.y() - 0.5f) - float(j0), 0.0f, 1.0f);
            Vec4 depths0;

            {
                const int x0 = wrap(sampler.wrapS, i0, w0);
                const int x1 = wrap(sampler.wrapS, i0 + 1, w0);
                const int y0 = wrap(sampler.wrapT, j0, h0);
                const int y1 = wrap(sampler.wrapT, j0 + 1, h0);

                depths0[0] = lookupDepth(level0, sampler, x0, y0, coordZ);
                depths0[1] = lookupDepth(level0, sampler, x1, y0, coordZ);
                depths0[2] = lookupDepth(level0, sampler, x0, y1, coordZ);
                depths0[3] = lookupDepth(level0, sampler, x1, y1, coordZ);
            }

            for (int j1 = minJ1; j1 <= maxJ1; j1++)
            {
                for (int i1 = minI1; i1 <= maxI1; i1++)
                {
                    const float minA1 = de::clamp((uBounds1.x() - 0.5f) - float(i1), 0.0f, 1.0f);
                    const float maxA1 = de::clamp((uBounds1.y() - 0.5f) - float(i1), 0.0f, 1.0f);
                    const float minB1 = de::clamp((vBounds1.x() - 0.5f) - float(j1), 0.0f, 1.0f);
                    const float maxB1 = de::clamp((vBounds1.y() - 0.5f) - float(j1), 0.0f, 1.0f);
                    Vec4 depths1;

                    {
                        const int x0 = wrap(sampler.wrapS, i1, w1);
                        const int x1 = wrap(sampler.wrapS, i1 + 1, w1);
                        const int y0 = wrap(sampler.wrapT, j1, h1);
                        const int y1 = wrap(sampler.wrapT, j1 + 1, h1);

                        depths1[0] = lookupDepth(level1, sampler, x0, y0, coordZ);
                        depths1[1] = lookupDepth(level1, sampler, x1, y0, coordZ);
                        depths1[2] = lookupDepth(level1, sampler, x0, y1, coordZ);
                        depths1[3] = lookupDepth(level1, sampler, x1, y1, coordZ);
                    }

                    if (isTrilinearCompareValid(sampler.compare, prec, depths0, depths1, Vec2(minA0, maxA0),
                                                Vec2(minB0, maxB0), Vec2(minA1, maxA1), Vec2(minB1, maxB1), fBounds,
                                                cmpReference, result, isFixedPointDepth))
                        return true;
                }
            }
        }
    }

    return false;
}

static bool isMipmapLinearCompareResultValid(const ConstPixelBufferAccess &level0, const ConstPixelBufferAccess &level1,
                                             const Sampler &sampler, const Sampler::FilterMode levelFilter,
                                             const TexComparePrecision &prec, const Vec2 &coord, const int coordZ,
                                             const Vec2 &fBounds, const float cmpReference, const float result)
{
    if (levelFilter == Sampler::LINEAR)
        return isLinearMipmapLinearCompareResultValid(level0, level1, sampler, prec, coord, coordZ, fBounds,
                                                      cmpReference, result);
    else
        return isNearestMipmapLinearCompareResultValid(level0, level1, sampler, prec, coord, coordZ, fBounds,
                                                       cmpReference, result);
}

bool isTexCompareResultValid(const Texture2DView &texture, const Sampler &sampler, const TexComparePrecision &prec,
                             const Vec2 &coord, const Vec2 &lodBounds, const float cmpReference, const float result)
{
    const float minLod        = lodBounds.x();
    const float maxLod        = lodBounds.y();
    const bool canBeMagnified = minLod <= sampler.lodThreshold;
    const bool canBeMinified  = maxLod > sampler.lodThreshold;

    DE_ASSERT(isSamplerSupported(sampler));

    if (canBeMagnified)
    {
        if (isLevelCompareResultValid(texture.getLevel(0), sampler, sampler.magFilter, prec, coord, 0, cmpReference,
                                      result))
            return true;
    }

    if (canBeMinified)
    {
        const bool isNearestMipmap = isNearestMipmapFilter(sampler.minFilter);
        const bool isLinearMipmap  = isLinearMipmapFilter(sampler.minFilter);
        const int minTexLevel      = 0;
        const int maxTexLevel      = texture.getNumLevels() - 1;

        DE_ASSERT(minTexLevel < maxTexLevel);

        if (isLinearMipmap)
        {
            const int minLevel = de::clamp((int)deFloatFloor(minLod), minTexLevel, maxTexLevel - 1);
            const int maxLevel = de::clamp((int)deFloatFloor(maxLod), minTexLevel, maxTexLevel - 1);

            DE_ASSERT(minLevel <= maxLevel);

            for (int level = minLevel; level <= maxLevel; level++)
            {
                const float minF = de::clamp(minLod - float(level), 0.0f, 1.0f);
                const float maxF = de::clamp(maxLod - float(level), 0.0f, 1.0f);

                if (isMipmapLinearCompareResultValid(texture.getLevel(level), texture.getLevel(level + 1), sampler,
                                                     getLevelFilter(sampler.minFilter), prec, coord, 0,
                                                     Vec2(minF, maxF), cmpReference, 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.
            const int minLevel = de::clamp((int)deFloatCeil(minLod + 0.5f) - 1, minTexLevel, maxTexLevel);
            const int maxLevel = de::clamp((int)deFloatFloor(maxLod + 0.5f), minTexLevel, maxTexLevel);

            DE_ASSERT(minLevel <= maxLevel);

            for (int level = minLevel; level <= maxLevel; level++)
            {
                if (isLevelCompareResultValid(texture.getLevel(level), sampler, getLevelFilter(sampler.minFilter), prec,
                                              coord, 0, cmpReference, result))
                    return true;
            }
        }
        else
        {
            if (isLevelCompareResultValid(texture.getLevel(0), sampler, sampler.minFilter, prec, coord, 0, cmpReference,
                                          result))
                return true;
        }
    }

    return false;
}

static bool isSeamplessLinearMipmapLinearCompareResultValid(const TextureCubeView &texture, const int baseLevelNdx,
                                                            const Sampler &sampler, const TexComparePrecision &prec,
                                                            const CubeFaceFloatCoords &coords, const Vec2 &fBounds,
                                                            const float cmpReference, const float result)
{
    const bool isFixedPointDepth =
        isFixedPointDepthTextureFormat(texture.getLevelFace(baseLevelNdx, CUBEFACE_NEGATIVE_X).getFormat());
    const int size0 = texture.getLevelFace(baseLevelNdx, coords.face).getWidth();
    const int size1 = texture.getLevelFace(baseLevelNdx + 1, coords.face).getWidth();

    const Vec2 uBounds0 = computeNonNormalizedCoordBounds(sampler.normalizedCoords, size0, coords.s, prec.coordBits.x(),
                                                          prec.uvwBits.x());
    const Vec2 uBounds1 = computeNonNormalizedCoordBounds(sampler.normalizedCoords, size1, coords.s, prec.coordBits.x(),
                                                          prec.uvwBits.x());
    const Vec2 vBounds0 = computeNonNormalizedCoordBounds(sampler.normalizedCoords, size0, coords.t, prec.coordBits.y(),
                                                          prec.uvwBits.y());
    const Vec2 vBounds1 = computeNonNormalizedCoordBounds(sampler.normalizedCoords, size1, coords.t, prec.coordBits.y(),
                                                          prec.uvwBits.y());

    // Integer coordinates - without wrap mode
    const int minI0 = deFloorFloatToInt32(uBounds0.x() - 0.5f);
    const int maxI0 = deFloorFloatToInt32(uBounds0.y() - 0.5f);
    const int minI1 = deFloorFloatToInt32(uBounds1.x() - 0.5f);
    const int maxI1 = deFloorFloatToInt32(uBounds1.y() - 0.5f);
    const int minJ0 = deFloorFloatToInt32(vBounds0.x() - 0.5f);
    const int maxJ0 = deFloorFloatToInt32(vBounds0.y() - 0.5f);
    const int minJ1 = deFloorFloatToInt32(vBounds1.x() - 0.5f);
    const int maxJ1 = deFloorFloatToInt32(vBounds1.y() - 0.5f);

    tcu::ConstPixelBufferAccess faces0[CUBEFACE_LAST];
    tcu::ConstPixelBufferAccess faces1[CUBEFACE_LAST];

    for (int face = 0; face < CUBEFACE_LAST; face++)
    {
        faces0[face] = texture.getLevelFace(baseLevelNdx, CubeFace(face));
        faces1[face] = texture.getLevelFace(baseLevelNdx + 1, CubeFace(face));
    }

    for (int j0 = minJ0; j0 <= maxJ0; j0++)
    {
        for (int i0 = minI0; i0 <= maxI0; i0++)
        {
            const float minA0 = de::clamp((uBounds0.x() - 0.5f) - float(i0), 0.0f, 1.0f);
            const float maxA0 = de::clamp((uBounds0.y() - 0.5f) - float(i0), 0.0f, 1.0f);
            const float minB0 = de::clamp((vBounds0.x() - 0.5f) - float(j0), 0.0f, 1.0f);
            const float maxB0 = de::clamp((vBounds0.y() - 0.5f) - float(j0), 0.0f, 1.0f);
            Vec4 depths0;

            {
                const CubeFaceIntCoords c00 =
                    remapCubeEdgeCoords(CubeFaceIntCoords(coords.face, IVec2(i0 + 0, j0 + 0)), size0);
                const CubeFaceIntCoords c10 =
                    remapCubeEdgeCoords(CubeFaceIntCoords(coords.face, IVec2(i0 + 1, j0 + 0)), size0);
                const CubeFaceIntCoords c01 =
                    remapCubeEdgeCoords(CubeFaceIntCoords(coords.face, IVec2(i0 + 0, j0 + 1)), size0);
                const CubeFaceIntCoords c11 =
                    remapCubeEdgeCoords(CubeFaceIntCoords(coords.face, IVec2(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.face == CUBEFACE_LAST || c01.face == CUBEFACE_LAST || c10.face == CUBEFACE_LAST ||
                    c11.face == CUBEFACE_LAST)
                    return true;

                depths0[0] = lookupDepthNoBorder(faces0[c00.face], sampler, c00.s, c00.t);
                depths0[1] = lookupDepthNoBorder(faces0[c10.face], sampler, c10.s, c10.t);
                depths0[2] = lookupDepthNoBorder(faces0[c01.face], sampler, c01.s, c01.t);
                depths0[3] = lookupDepthNoBorder(faces0[c11.face], sampler, c11.s, c11.t);
            }

            for (int j1 = minJ1; j1 <= maxJ1; j1++)
            {
                for (int i1 = minI1; i1 <= maxI1; i1++)
                {
                    const float minA1 = de::clamp((uBounds1.x() - 0.5f) - float(i1), 0.0f, 1.0f);
                    const float maxA1 = de::clamp((uBounds1.y() - 0.5f) - float(i1), 0.0f, 1.0f);
                    const float minB1 = de::clamp((vBounds1.x() - 0.5f) - float(j1), 0.0f, 1.0f);
                    const float maxB1 = de::clamp((vBounds1.y() - 0.5f) - float(j1), 0.0f, 1.0f);
                    Vec4 depths1;

                    {
                        const CubeFaceIntCoords c00 =
                            remapCubeEdgeCoords(CubeFaceIntCoords(coords.face, IVec2(i1 + 0, j1 + 0)), size1);
                        const CubeFaceIntCoords c10 =
                            remapCubeEdgeCoords(CubeFaceIntCoords(coords.face, IVec2(i1 + 1, j1 + 0)), size1);
                        const CubeFaceIntCoords c01 =
                            remapCubeEdgeCoords(CubeFaceIntCoords(coords.face, IVec2(i1 + 0, j1 + 1)), size1);
                        const CubeFaceIntCoords c11 =
                            remapCubeEdgeCoords(CubeFaceIntCoords(coords.face, IVec2(i1 + 1, j1 + 1)), size1);

                        if (c00.face == CUBEFACE_LAST || c01.face == CUBEFACE_LAST || c10.face == CUBEFACE_LAST ||
                            c11.face == CUBEFACE_LAST)
                            return true;

                        depths1[0] = lookupDepthNoBorder(faces1[c00.face], sampler, c00.s, c00.t);
                        depths1[1] = lookupDepthNoBorder(faces1[c10.face], sampler, c10.s, c10.t);
                        depths1[2] = lookupDepthNoBorder(faces1[c01.face], sampler, c01.s, c01.t);
                        depths1[3] = lookupDepthNoBorder(faces1[c11.face], sampler, c11.s, c11.t);
                    }

                    if (isTrilinearCompareValid(sampler.compare, prec, depths0, depths1, Vec2(minA0, maxA0),
                                                Vec2(minB0, maxB0), Vec2(minA1, maxA1), Vec2(minB1, maxB1), fBounds,
                                                cmpReference, result, isFixedPointDepth))
                        return true;
                }
            }
        }
    }

    return false;
}

static bool isCubeMipmapLinearCompareResultValid(const TextureCubeView &texture, const int baseLevelNdx,
                                                 const Sampler &sampler, const Sampler::FilterMode levelFilter,
                                                 const TexComparePrecision &prec, const CubeFaceFloatCoords &coords,
                                                 const Vec2 &fBounds, const float cmpReference, const float result)
{
    if (levelFilter == Sampler::LINEAR)
    {
        if (sampler.seamlessCubeMap)
            return isSeamplessLinearMipmapLinearCompareResultValid(texture, baseLevelNdx, sampler, prec, coords,
                                                                   fBounds, cmpReference, result);
        else
            return isLinearMipmapLinearCompareResultValid(
                texture.getLevelFace(baseLevelNdx, coords.face), texture.getLevelFace(baseLevelNdx + 1, coords.face),
                sampler, prec, Vec2(coords.s, coords.t), 0, fBounds, cmpReference, result);
    }
    else
        return isNearestMipmapLinearCompareResultValid(
            texture.getLevelFace(baseLevelNdx, coords.face), texture.getLevelFace(baseLevelNdx + 1, coords.face),
            sampler, prec, Vec2(coords.s, coords.t), 0, fBounds, cmpReference, result);
}

static bool isSeamlessLinearCompareResultValid(const TextureCubeView &texture, const int levelNdx,
                                               const Sampler &sampler, const TexComparePrecision &prec,
                                               const CubeFaceFloatCoords &coords, const float cmpReference,
                                               const float result)
{
    const bool isFixedPointDepth =
        isFixedPointDepthTextureFormat(texture.getLevelFace(levelNdx, CUBEFACE_NEGATIVE_X).getFormat());
    const int size = texture.getLevelFace(levelNdx, coords.face).getWidth();

    const Vec2 uBounds =
        computeNonNormalizedCoordBounds(sampler.normalizedCoords, size, coords.s, prec.coordBits.x(), prec.uvwBits.x());
    const Vec2 vBounds =
        computeNonNormalizedCoordBounds(sampler.normalizedCoords, size, coords.t, prec.coordBits.y(), prec.uvwBits.y());

    // Integer coordinate bounds for (x0,y0) - without wrap mode
    const int minI = deFloorFloatToInt32(uBounds.x() - 0.5f);
    const int maxI = deFloorFloatToInt32(uBounds.y() - 0.5f);
    const int minJ = deFloorFloatToInt32(vBounds.x() - 0.5f);
    const int maxJ = deFloorFloatToInt32(vBounds.y() - 0.5f);

    // Face accesses
    ConstPixelBufferAccess faces[CUBEFACE_LAST];
    for (int face = 0; face < CUBEFACE_LAST; face++)
        faces[face] = texture.getLevelFace(levelNdx, CubeFace(face));

    for (int j = minJ; j <= maxJ; j++)
    {
        for (int i = minI; i <= maxI; i++)
        {
            const CubeFaceIntCoords c00 =
                remapCubeEdgeCoords(CubeFaceIntCoords(coords.face, IVec2(i + 0, j + 0)), size);
            const CubeFaceIntCoords c10 =
                remapCubeEdgeCoords(CubeFaceIntCoords(coords.face, IVec2(i + 1, j + 0)), size);
            const CubeFaceIntCoords c01 =
                remapCubeEdgeCoords(CubeFaceIntCoords(coords.face, IVec2(i + 0, j + 1)), size);
            const CubeFaceIntCoords c11 =
                remapCubeEdgeCoords(CubeFaceIntCoords(coords.face, IVec2(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.face == CUBEFACE_LAST || c01.face == CUBEFACE_LAST || c10.face == CUBEFACE_LAST ||
                c11.face == CUBEFACE_LAST)
                return true;

            // Bounds for filtering factors
            const float minA = de::clamp((uBounds.x() - 0.5f) - float(i), 0.0f, 1.0f);
            const float maxA = de::clamp((uBounds.y() - 0.5f) - float(i), 0.0f, 1.0f);
            const float minB = de::clamp((vBounds.x() - 0.5f) - float(j), 0.0f, 1.0f);
            const float maxB = de::clamp((vBounds.y() - 0.5f) - float(j), 0.0f, 1.0f);

            Vec4 depths;
            depths[0] = lookupDepthNoBorder(faces[c00.face], sampler, c00.s, c00.t);
            depths[1] = lookupDepthNoBorder(faces[c10.face], sampler, c10.s, c10.t);
            depths[2] = lookupDepthNoBorder(faces[c01.face], sampler, c01.s, c01.t);
            depths[3] = lookupDepthNoBorder(faces[c11.face], sampler, c11.s, c11.t);

            if (isBilinearCompareValid(sampler.compare, prec, depths, Vec2(minA, maxA), Vec2(minB, maxB), cmpReference,
                                       result, isFixedPointDepth))
                return true;
        }
    }

    return false;
}

static bool isCubeLevelCompareResultValid(const TextureCubeView &texture, const int levelNdx, const Sampler &sampler,
                                          const Sampler::FilterMode filterMode, const TexComparePrecision &prec,
                                          const CubeFaceFloatCoords &coords, const float cmpReference,
                                          const float result)
{
    if (filterMode == Sampler::LINEAR)
    {
        if (sampler.seamlessCubeMap)
            return isSeamlessLinearCompareResultValid(texture, levelNdx, sampler, prec, coords, cmpReference, result);
        else
            return isLinearCompareResultValid(texture.getLevelFace(levelNdx, coords.face), sampler, prec,
                                              Vec2(coords.s, coords.t), 0, cmpReference, result);
    }
    else
        return isNearestCompareResultValid(texture.getLevelFace(levelNdx, coords.face), sampler, prec,
                                           Vec2(coords.s, coords.t), 0, cmpReference, result);
}

static bool isCubeLevelCompareResultValid(const TextureCubeArrayView &texture, const int baseLevelNdx,
                                          const Sampler &sampler, const Sampler::FilterMode filterMode,
                                          const TexComparePrecision &prec, const CubeFaceFloatCoords &coords,
                                          const float depth, const float cmpReference, const float result)
{
    const float depthErr =
        computeFloatingPointError(depth, prec.coordBits.z()) + computeFixedPointError(prec.uvwBits.z());
    const float minZ    = depth - depthErr;
    const float maxZ    = depth + depthErr;
    const int minLayer  = de::clamp(deFloorFloatToInt32(minZ + 0.5f), 0, texture.getNumLayers() - 1);
    const int maxLayer  = de::clamp(deFloorFloatToInt32(maxZ + 0.5f), 0, texture.getNumLayers() - 1);
    const int numLevels = texture.getNumLevels();

    for (int layer = minLayer; layer <= maxLayer; layer++)
    {
        std::vector<tcu::ConstPixelBufferAccess> levelsAtLayer[CUBEFACE_LAST];

        for (int faceNdx = 0; faceNdx < CUBEFACE_LAST; faceNdx++)
        {
            levelsAtLayer[faceNdx].resize(numLevels);

            for (int levelNdx = 0; levelNdx < numLevels; ++levelNdx)
            {
                const tcu::ConstPixelBufferAccess &level = texture.getLevel(levelNdx);

                levelsAtLayer[faceNdx][levelNdx] =
                    ConstPixelBufferAccess(level.getFormat(), level.getWidth(), level.getHeight(), 1,
                                           level.getPixelPtr(0, 0, CUBEFACE_LAST * layer + faceNdx));
            }
        }

        const tcu::ConstPixelBufferAccess *levels[CUBEFACE_LAST]{
            // Such a strange order due to sampleCompare TextureCubeArrayView uses getCubeArrayFaceIndex while in TextureCubeView does not
            &levelsAtLayer[1][0], &levelsAtLayer[0][0], &levelsAtLayer[3][0],
            &levelsAtLayer[2][0], &levelsAtLayer[5][0], &levelsAtLayer[4][0],
        };

        if (isCubeLevelCompareResultValid(TextureCubeView(numLevels, levels), baseLevelNdx, sampler, filterMode, prec,
                                          coords, cmpReference, result))
            return true;
    }

    return false;
}

static bool isCubeMipmapLinearCompareResultValid(const TextureCubeArrayView &texture, const int baseLevelNdx,
                                                 const Sampler &sampler, const Sampler::FilterMode levelFilter,
                                                 const TexComparePrecision &prec, const CubeFaceFloatCoords &coords,
                                                 const float depth, const Vec2 &fBounds, const float cmpReference,
                                                 const float result)
{
    const float depthErr =
        computeFloatingPointError(depth, prec.coordBits.z()) + computeFixedPointError(prec.uvwBits.z());
    const float minZ    = depth - depthErr;
    const float maxZ    = depth + depthErr;
    const int minLayer  = de::clamp(deFloorFloatToInt32(minZ + 0.5f), 0, texture.getNumLayers() - 1);
    const int maxLayer  = de::clamp(deFloorFloatToInt32(maxZ + 0.5f), 0, texture.getNumLayers() - 1);
    const int numLevels = texture.getNumLevels();

    for (int layer = minLayer; layer <= maxLayer; layer++)
    {
        std::vector<tcu::ConstPixelBufferAccess> levelsAtLayer[CUBEFACE_LAST];

        for (int faceNdx = 0; faceNdx < CUBEFACE_LAST; faceNdx++)
        {
            levelsAtLayer[faceNdx].resize(numLevels);

            for (int levelNdx = 0; levelNdx < numLevels; ++levelNdx)
            {
                const tcu::ConstPixelBufferAccess &level = texture.getLevel(levelNdx);

                levelsAtLayer[faceNdx][levelNdx] =
                    ConstPixelBufferAccess(level.getFormat(), level.getWidth(), level.getHeight(), 1,
                                           level.getPixelPtr(0, 0, CUBEFACE_LAST * layer + faceNdx));
            }
        }

        const tcu::ConstPixelBufferAccess *levels[CUBEFACE_LAST]{
            // Such a strange order due to sampleCompare TextureCubeArrayView uses getCubeArrayFaceIndex while in TextureCubeView does not
            &levelsAtLayer[1][0], &levelsAtLayer[0][0], &levelsAtLayer[3][0],
            &levelsAtLayer[2][0], &levelsAtLayer[5][0], &levelsAtLayer[4][0],
        };

        if (isCubeMipmapLinearCompareResultValid(TextureCubeView(numLevels, levels), baseLevelNdx, sampler, levelFilter,
                                                 prec, coords, fBounds, cmpReference, result))
            return true;
    }

    return false;
}

static bool isNearestCompareResultValid(const ConstPixelBufferAccess &level, const Sampler &sampler,
                                        const TexComparePrecision &prec, const Vec1 &coord, const int coordZ,
                                        const float cmpReference, const float result)
{
    const bool isFixedPointDepth = isFixedPointDepthTextureFormat(level.getFormat());
    const Vec2 uBounds = computeNonNormalizedCoordBounds(sampler.normalizedCoords, level.getWidth(), coord.x(),
                                                         prec.coordBits.x(), prec.uvwBits.x());

    // Integer coordinates - without wrap mode
    const int minI = deFloorFloatToInt32(uBounds.x());
    const int maxI = deFloorFloatToInt32(uBounds.y());

    for (int i = minI; i <= maxI; i++)
    {
        const int x       = wrap(sampler.wrapS, i, level.getWidth());
        const float depth = lookupDepth(level, sampler, x, coordZ, 0);
        const CmpResultSet resSet =
            execCompare(sampler.compare, depth, cmpReference, prec.referenceBits, isFixedPointDepth);

        if (isResultInSet(resSet, result, prec.resultBits))
            return true;
    }

    return false;
}

static bool isLinearCompareResultValid(const ConstPixelBufferAccess &level, const Sampler &sampler,
                                       const TexComparePrecision &prec, const Vec1 &coord, const int coordZ,
                                       const float cmpReference, const float result)
{
    const bool isFixedPointDepth = isFixedPointDepthTextureFormat(level.getFormat());
    const Vec2 uBounds = computeNonNormalizedCoordBounds(sampler.normalizedCoords, level.getWidth(), coord.x(),
                                                         prec.coordBits.x(), prec.uvwBits.x());

    // Integer coordinate bounds for (x0,y0) - without wrap mode
    const int minI = deFloorFloatToInt32(uBounds.x() - 0.5f);
    const int maxI = deFloorFloatToInt32(uBounds.y() - 0.5f);

    const int w = level.getWidth();

    // \todo [2013-07-03 pyry] This could be optimized by first computing ranges based on wrap mode.

    for (int i = minI; i <= maxI; i++)
    {
        // Wrapped coordinates
        const int x0 = wrap(sampler.wrapS, i, w);
        const int x1 = wrap(sampler.wrapS, i + 1, w);

        // Bounds for filtering factors
        const float minA = de::clamp((uBounds.x() - 0.5f) - float(i), 0.0f, 1.0f);
        const float maxA = de::clamp((uBounds.y() - 0.5f) - float(i), 0.0f, 1.0f);

        const Vec2 depths(lookupDepth(level, sampler, x0, coordZ, 0), lookupDepth(level, sampler, x1, coordZ, 0));

        if (isLinearCompareValid(sampler.compare, prec, depths, Vec2(minA, maxA), cmpReference, result,
                                 isFixedPointDepth))
            return true;
    }

    return false;
}

static bool isLevelCompareResultValid(const ConstPixelBufferAccess &level, const Sampler &sampler,
                                      const Sampler::FilterMode filterMode, const TexComparePrecision &prec,
                                      const Vec1 &coord, const int coordZ, const float cmpReference, const float result)
{
    if (filterMode == Sampler::LINEAR)
        return isLinearCompareResultValid(level, sampler, prec, coord, coordZ, cmpReference, result);
    else
        return isNearestCompareResultValid(level, sampler, prec, coord, coordZ, cmpReference, result);
}

static bool isNearestMipmapLinearCompareResultValid(const ConstPixelBufferAccess &level0,
                                                    const ConstPixelBufferAccess &level1, const Sampler &sampler,
                                                    const TexComparePrecision &prec, const Vec1 &coord,
                                                    const int coordZ, const Vec2 &fBounds, const float cmpReference,
                                                    const float result)
{
    DE_UNREF(fBounds);
    const bool isFixedPointDepth = isFixedPointDepthTextureFormat(level0.getFormat());

    const int w0 = level0.getWidth();
    const int w1 = level1.getWidth();

    const Vec2 uBounds0 =
        computeNonNormalizedCoordBounds(sampler.normalizedCoords, w0, coord.x(), prec.coordBits.x(), prec.uvwBits.x());
    const Vec2 uBounds1 =
        computeNonNormalizedCoordBounds(sampler.normalizedCoords, w1, coord.x(), prec.coordBits.x(), prec.uvwBits.x());

    // Integer coordinates - without wrap mode
    const int minI0 = deFloorFloatToInt32(uBounds0.x());
    const int maxI0 = deFloorFloatToInt32(uBounds0.y());
    const int minI1 = deFloorFloatToInt32(uBounds1.x());
    const int maxI1 = deFloorFloatToInt32(uBounds1.y());

    for (int i0 = minI0; i0 <= maxI0; i0++)
    {
        const float depth0 = lookupDepth(level0, sampler, wrap(sampler.wrapS, i0, w0), coordZ, 0);

        for (int i1 = minI1; i1 <= maxI1; i1++)
        {
            const float depth1 = lookupDepth(level1, sampler, wrap(sampler.wrapS, i1, w1), coordZ, 0);

            if (isLinearCompareValid(sampler.compare, prec, Vec2(depth0, depth1), fBounds, cmpReference, result,
                                     isFixedPointDepth))
                return true;
        }
    }

    return false;
}

static bool isLinearMipmapLinearCompareResultValid(const ConstPixelBufferAccess &level0,
                                                   const ConstPixelBufferAccess &level1, const Sampler &sampler,
                                                   const TexComparePrecision &prec, const Vec1 &coord, const int coordZ,
                                                   const Vec2 &fBounds, const float cmpReference, const float result)
{
    DE_UNREF(fBounds);
    const bool isFixedPointDepth = isFixedPointDepthTextureFormat(level0.getFormat());

    // \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.

    const int w0 = level0.getWidth();
    const int w1 = level1.getWidth();

    const Vec2 uBounds0 =
        computeNonNormalizedCoordBounds(sampler.normalizedCoords, w0, coord.x(), prec.coordBits.x(), prec.uvwBits.x());
    const Vec2 uBounds1 =
        computeNonNormalizedCoordBounds(sampler.normalizedCoords, w1, coord.x(), prec.coordBits.x(), prec.uvwBits.x());

    // Integer coordinates - without wrap mode
    const int minI0 = deFloorFloatToInt32(uBounds0.x() - 0.5f);
    const int maxI0 = deFloorFloatToInt32(uBounds0.y() - 0.5f);
    const int minI1 = deFloorFloatToInt32(uBounds1.x() - 0.5f);
    const int maxI1 = deFloorFloatToInt32(uBounds1.y() - 0.5f);

    for (int i0 = minI0; i0 <= maxI0; i0++)
    {
        const float minA0 = de::clamp((uBounds0.x() - 0.5f) - float(i0), 0.0f, 1.0f);
        const float maxA0 = de::clamp((uBounds0.y() - 0.5f) - float(i0), 0.0f, 1.0f);
        const Vec2 ptA0   = Vec2(minA0, maxA0);
        Vec4 depths;

        {
            const int x0 = wrap(sampler.wrapS, i0, w0);
            const int x1 = wrap(sampler.wrapS, i0 + 1, w0);

            depths[0] = lookupDepth(level0, sampler, x0, coordZ, 0);
            depths[1] = lookupDepth(level0, sampler, x1, coordZ, 0);
        }

        for (int i1 = minI1; i1 <= maxI1; i1++)
        {
            const float minA1 = de::clamp((uBounds1.x() - 0.5f) - float(i1), 0.0f, 1.0f);
            const float maxA1 = de::clamp((uBounds1.y() - 0.5f) - float(i1), 0.0f, 1.0f);
            const Vec2 ptA1   = Vec2(minA1, maxA1);

            {
                const int x0 = wrap(sampler.wrapS, i1, w1);
                const int x1 = wrap(sampler.wrapS, i1 + 1, w1);

                depths[2] = lookupDepth(level1, sampler, x0, coordZ, 0);
                depths[3] = lookupDepth(level1, sampler, x1, coordZ, 0);
            }

            if (isBilinearCompareValid(sampler.compare, prec, depths, ptA0, ptA1, cmpReference, result,
                                       isFixedPointDepth))
                return true;
        }
    }

    return false;
}

static bool isMipmapLinearCompareResultValid(const ConstPixelBufferAccess &level0, const ConstPixelBufferAccess &level1,
                                             const Sampler &sampler, const Sampler::FilterMode levelFilter,
                                             const TexComparePrecision &prec, const Vec1 &coord, const int coordZ,
                                             const Vec2 &fBounds, const float cmpReference, const float result)
{
    if (levelFilter == Sampler::LINEAR)
        return isLinearMipmapLinearCompareResultValid(level0, level1, sampler, prec, coord, coordZ, fBounds,
                                                      cmpReference, result);
    else
        return isNearestMipmapLinearCompareResultValid(level0, level1, sampler, prec, coord, coordZ, fBounds,
                                                       cmpReference, result);
}

bool isTexCompareResultValid(const TextureCubeView &texture, const Sampler &sampler, const TexComparePrecision &prec,
                             const Vec3 &coord, const Vec2 &lodBounds, const float cmpReference, const float result)
{
    int numPossibleFaces = 0;
    CubeFace possibleFaces[CUBEFACE_LAST];

    DE_ASSERT(isSamplerSupported(sampler));

    getPossibleCubeFaces(coord, prec.coordBits, &possibleFaces[0], numPossibleFaces);

    if (numPossibleFaces == 0)
        return true; // Result is undefined.

    for (int tryFaceNdx = 0; tryFaceNdx < numPossibleFaces; tryFaceNdx++)
    {
        const CubeFaceFloatCoords faceCoords(possibleFaces[tryFaceNdx],
                                             projectToFace(possibleFaces[tryFaceNdx], coord));
        const float minLod        = lodBounds.x();
        const float maxLod        = lodBounds.y();
        const bool canBeMagnified = minLod <= sampler.lodThreshold;
        const bool canBeMinified  = maxLod > sampler.lodThreshold;

        if (canBeMagnified)
        {
            if (isCubeLevelCompareResultValid(texture, 0, sampler, sampler.magFilter, prec, faceCoords, cmpReference,
                                              result))
                return true;
        }

        if (canBeMinified)
        {
            const bool isNearestMipmap = isNearestMipmapFilter(sampler.minFilter);
            const bool isLinearMipmap  = isLinearMipmapFilter(sampler.minFilter);
            const int minTexLevel      = 0;
            const int maxTexLevel      = texture.getNumLevels() - 1;

            DE_ASSERT(minTexLevel < maxTexLevel);

            if (isLinearMipmap)
            {
                const int minLevel = de::clamp((int)deFloatFloor(minLod), minTexLevel, maxTexLevel - 1);
                const int maxLevel = de::clamp((int)deFloatFloor(maxLod), minTexLevel, maxTexLevel - 1);

                DE_ASSERT(minLevel <= maxLevel);

                for (int level = minLevel; level <= maxLevel; level++)
                {
                    const float minF = de::clamp(minLod - float(level), 0.0f, 1.0f);
                    const float maxF = de::clamp(maxLod - float(level), 0.0f, 1.0f);

                    if (isCubeMipmapLinearCompareResultValid(texture, level, sampler, getLevelFilter(sampler.minFilter),
                                                             prec, faceCoords, Vec2(minF, maxF), cmpReference, 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.
                const int minLevel = de::clamp((int)deFloatCeil(minLod + 0.5f) - 1, minTexLevel, maxTexLevel);
                const int maxLevel = de::clamp((int)deFloatFloor(maxLod + 0.5f), minTexLevel, maxTexLevel);

                DE_ASSERT(minLevel <= maxLevel);

                for (int level = minLevel; level <= maxLevel; level++)
                {
                    if (isCubeLevelCompareResultValid(texture, level, sampler, getLevelFilter(sampler.minFilter), prec,
                                                      faceCoords, cmpReference, result))
                        return true;
                }
            }
            else
            {
                if (isCubeLevelCompareResultValid(texture, 0, sampler, sampler.minFilter, prec, faceCoords,
                                                  cmpReference, result))
                    return true;
            }
        }
    }

    return false;
}

bool isTexCompareResultValid(const Texture2DArrayView &texture, const Sampler &sampler, const TexComparePrecision &prec,
                             const Vec3 &coord, const Vec2 &lodBounds, const float cmpReference, const float result)
{
    const float depthErr =
        computeFloatingPointError(coord.z(), prec.coordBits.z()) + computeFixedPointError(prec.uvwBits.z());
    const float minZ   = coord.z() - depthErr;
    const float maxZ   = coord.z() + depthErr;
    const int minLayer = de::clamp(deFloorFloatToInt32(minZ + 0.5f), 0, texture.getNumLayers() - 1);
    const int maxLayer = de::clamp(deFloorFloatToInt32(maxZ + 0.5f), 0, texture.getNumLayers() - 1);

    DE_ASSERT(isSamplerSupported(sampler));

    for (int layer = minLayer; layer <= maxLayer; layer++)
    {
        const float minLod        = lodBounds.x();
        const float maxLod        = lodBounds.y();
        const bool canBeMagnified = minLod <= sampler.lodThreshold;
        const bool canBeMinified  = maxLod > sampler.lodThreshold;

        if (canBeMagnified)
        {
            if (isLevelCompareResultValid(texture.getLevel(0), sampler, sampler.magFilter, prec, coord.swizzle(0, 1),
                                          layer, cmpReference, result))
                return true;
        }

        if (canBeMinified)
        {
            const bool isNearestMipmap = isNearestMipmapFilter(sampler.minFilter);
            const bool isLinearMipmap  = isLinearMipmapFilter(sampler.minFilter);
            const int minTexLevel      = 0;
            const int maxTexLevel      = texture.getNumLevels() - 1;

            DE_ASSERT(minTexLevel < maxTexLevel);

            if (isLinearMipmap)
            {
                const int minLevel = de::clamp((int)deFloatFloor(minLod), minTexLevel, maxTexLevel - 1);
                const int maxLevel = de::clamp((int)deFloatFloor(maxLod), minTexLevel, maxTexLevel - 1);

                DE_ASSERT(minLevel <= maxLevel);

                for (int level = minLevel; level <= maxLevel; level++)
                {
                    const float minF = de::clamp(minLod - float(level), 0.0f, 1.0f);
                    const float maxF = de::clamp(maxLod - float(level), 0.0f, 1.0f);

                    if (isMipmapLinearCompareResultValid(texture.getLevel(level), texture.getLevel(level + 1), sampler,
                                                         getLevelFilter(sampler.minFilter), prec, coord.swizzle(0, 1),
                                                         layer, Vec2(minF, maxF), cmpReference, 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.
                const int minLevel = de::clamp((int)deFloatCeil(minLod + 0.5f) - 1, minTexLevel, maxTexLevel);
                const int maxLevel = de::clamp((int)deFloatFloor(maxLod + 0.5f), minTexLevel, maxTexLevel);

                DE_ASSERT(minLevel <= maxLevel);

                for (int level = minLevel; level <= maxLevel; level++)
                {
                    if (isLevelCompareResultValid(texture.getLevel(level), sampler, getLevelFilter(sampler.minFilter),
                                                  prec, coord.swizzle(0, 1), layer, cmpReference, result))
                        return true;
                }
            }
            else
            {
                if (isLevelCompareResultValid(texture.getLevel(0), sampler, sampler.minFilter, prec,
                                              coord.swizzle(0, 1), layer, cmpReference, result))
                    return true;
            }
        }
    }

    return false;
}

bool isTexCompareResultValid(const Texture1DView &texture, const Sampler &sampler, const TexComparePrecision &prec,
                             const Vec1 &coord, const Vec2 &lodBounds, const float cmpReference, const float result)
{
    const float minLod        = lodBounds.x();
    const float maxLod        = lodBounds.y();
    const bool canBeMagnified = minLod <= sampler.lodThreshold;
    const bool canBeMinified  = maxLod > sampler.lodThreshold;

    DE_ASSERT(isSamplerSupported(sampler));

    if (canBeMagnified)
    {
        if (isLevelCompareResultValid(texture.getLevel(0), sampler, sampler.magFilter, prec, coord, 0, cmpReference,
                                      result))
            return true;
    }

    if (canBeMinified)
    {
        const bool isNearestMipmap = isNearestMipmapFilter(sampler.minFilter);
        const bool isLinearMipmap  = isLinearMipmapFilter(sampler.minFilter);
        const int minTexLevel      = 0;
        const int maxTexLevel      = texture.getNumLevels() - 1;

        DE_ASSERT(minTexLevel < maxTexLevel);

        if (isLinearMipmap)
        {
            const int minLevel = de::clamp((int)deFloatFloor(minLod), minTexLevel, maxTexLevel - 1);
            const int maxLevel = de::clamp((int)deFloatFloor(maxLod), minTexLevel, maxTexLevel - 1);

            DE_ASSERT(minLevel <= maxLevel);

            for (int level = minLevel; level <= maxLevel; level++)
            {
                const float minF = de::clamp(minLod - float(level), 0.0f, 1.0f);
                const float maxF = de::clamp(maxLod - float(level), 0.0f, 1.0f);

                if (isMipmapLinearCompareResultValid(texture.getLevel(level), texture.getLevel(level + 1), sampler,
                                                     getLevelFilter(sampler.minFilter), prec, coord, 0,
                                                     Vec2(minF, maxF), cmpReference, 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.
            const int minLevel = de::clamp((int)deFloatCeil(minLod + 0.5f) - 1, minTexLevel, maxTexLevel);
            const int maxLevel = de::clamp((int)deFloatFloor(maxLod + 0.5f), minTexLevel, maxTexLevel);

            DE_ASSERT(minLevel <= maxLevel);

            for (int level = minLevel; level <= maxLevel; level++)
            {
                if (isLevelCompareResultValid(texture.getLevel(level), sampler, getLevelFilter(sampler.minFilter), prec,
                                              coord, 0, cmpReference, result))
                    return true;
            }
        }
        else
        {
            if (isLevelCompareResultValid(texture.getLevel(0), sampler, sampler.minFilter, prec, coord, 0, cmpReference,
                                          result))
                return true;
        }
    }

    return false;
}

bool isTexCompareResultValid(const Texture1DArrayView &texture, const Sampler &sampler, const TexComparePrecision &prec,
                             const Vec2 &coord, const Vec2 &lodBounds, const float cmpReference, const float result)
{
    const float depthErr = computeFloatingPointError(coord.y(), prec.coordBits.y()) +
                           computeFixedPointError(prec.uvwBits.y()); //\todo: should we go with y in prec?
    const float minZ   = coord.y() - depthErr;
    const float maxZ   = coord.y() + depthErr;
    const int minLayer = de::clamp(deFloorFloatToInt32(minZ + 0.5f), 0, texture.getNumLayers() - 1);
    const int maxLayer = de::clamp(deFloorFloatToInt32(maxZ + 0.5f), 0, texture.getNumLayers() - 1);

    DE_ASSERT(isSamplerSupported(sampler));

    for (int layer = minLayer; layer <= maxLayer; layer++)
    {
        const float minLod        = lodBounds.x();
        const float maxLod        = lodBounds.y();
        const bool canBeMagnified = minLod <= sampler.lodThreshold;
        const bool canBeMinified  = maxLod > sampler.lodThreshold;

        if (canBeMagnified)
        {
            if (isLevelCompareResultValid(texture.getLevel(0), sampler, sampler.magFilter, prec, Vec1(coord.x()), layer,
                                          cmpReference, result))
                return true;
        }

        if (canBeMinified)
        {
            const bool isNearestMipmap = isNearestMipmapFilter(sampler.minFilter);
            const bool isLinearMipmap  = isLinearMipmapFilter(sampler.minFilter);
            const int minTexLevel      = 0;
            const int maxTexLevel      = texture.getNumLevels() - 1;

            DE_ASSERT(minTexLevel < maxTexLevel);

            if (isLinearMipmap)
            {
                const int minLevel = de::clamp((int)deFloatFloor(minLod), minTexLevel, maxTexLevel - 1);
                const int maxLevel = de::clamp((int)deFloatFloor(maxLod), minTexLevel, maxTexLevel - 1);

                DE_ASSERT(minLevel <= maxLevel);

                for (int level = minLevel; level <= maxLevel; level++)
                {
                    const float minF = de::clamp(minLod - float(level), 0.0f, 1.0f);
                    const float maxF = de::clamp(maxLod - float(level), 0.0f, 1.0f);

                    if (isMipmapLinearCompareResultValid(texture.getLevel(level), texture.getLevel(level + 1), sampler,
                                                         getLevelFilter(sampler.minFilter), prec, Vec1(coord.x()),
                                                         layer, Vec2(minF, maxF), cmpReference, 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.
                const int minLevel = de::clamp((int)deFloatCeil(minLod + 0.5f) - 1, minTexLevel, maxTexLevel);
                const int maxLevel = de::clamp((int)deFloatFloor(maxLod + 0.5f), minTexLevel, maxTexLevel);

                DE_ASSERT(minLevel <= maxLevel);

                for (int level = minLevel; level <= maxLevel; level++)
                {
                    if (isLevelCompareResultValid(texture.getLevel(level), sampler, getLevelFilter(sampler.minFilter),
                                                  prec, Vec1(coord.x()), layer, cmpReference, result))
                        return true;
                }
            }
            else
            {
                if (isLevelCompareResultValid(texture.getLevel(0), sampler, sampler.minFilter, prec, Vec1(coord.x()),
                                              layer, cmpReference, result))
                    return true;
            }
        }
    }

    return false;
}

bool isTexCompareResultValid(const TextureCubeArrayView &texture, const Sampler &sampler,
                             const TexComparePrecision &prec, const Vec4 &coord, const Vec2 &lodBounds,
                             const float cmpReference, const float result)
{
    const Vec3 coord3    = coord.swizzle(0, 1, 2);
    int numPossibleFaces = 0;
    CubeFace possibleFaces[CUBEFACE_LAST];

    DE_ASSERT(isSamplerSupported(sampler));

    getPossibleCubeFaces(coord3, prec.coordBits, &possibleFaces[0], numPossibleFaces);

    if (numPossibleFaces == 0)
        return true; // Result is undefined.

    for (int tryFaceNdx = 0; tryFaceNdx < numPossibleFaces; tryFaceNdx++)
    {
        const CubeFaceFloatCoords faceCoords(possibleFaces[tryFaceNdx],
                                             projectToFace(possibleFaces[tryFaceNdx], coord3));
        const float minLod        = lodBounds.x();
        const float maxLod        = lodBounds.y();
        const bool canBeMagnified = minLod <= sampler.lodThreshold;
        const bool canBeMinified  = maxLod > sampler.lodThreshold;

        if (canBeMagnified)
        {
            if (isCubeLevelCompareResultValid(texture, 0, sampler, sampler.magFilter, prec, faceCoords, coord.w(),
                                              cmpReference, result))
                return true;
        }

        if (canBeMinified)
        {
            const bool isNearestMipmap = isNearestMipmapFilter(sampler.minFilter);
            const bool isLinearMipmap  = isLinearMipmapFilter(sampler.minFilter);
            const int minTexLevel      = 0;
            const int maxTexLevel      = texture.getNumLevels() - 1;

            DE_ASSERT(minTexLevel < maxTexLevel);

            if (isLinearMipmap)
            {
                const int minLevel = de::clamp((int)deFloatFloor(minLod), minTexLevel, maxTexLevel - 1);
                const int maxLevel = de::clamp((int)deFloatFloor(maxLod), minTexLevel, maxTexLevel - 1);

                DE_ASSERT(minLevel <= maxLevel);

                for (int level = minLevel; level <= maxLevel; level++)
                {
                    const float minF = de::clamp(minLod - float(level), 0.0f, 1.0f);
                    const float maxF = de::clamp(maxLod - float(level), 0.0f, 1.0f);

                    if (isCubeMipmapLinearCompareResultValid(texture, level, sampler, getLevelFilter(sampler.minFilter),
                                                             prec, faceCoords, coord.w(), Vec2(minF, maxF),
                                                             cmpReference, 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.
                const int minLevel = de::clamp((int)deFloatCeil(minLod + 0.5f) - 1, minTexLevel, maxTexLevel);
                const int maxLevel = de::clamp((int)deFloatFloor(maxLod + 0.5f), minTexLevel, maxTexLevel);

                DE_ASSERT(minLevel <= maxLevel);

                for (int level = minLevel; level <= maxLevel; level++)
                {
                    if (isCubeLevelCompareResultValid(texture, level, sampler, getLevelFilter(sampler.minFilter), prec,
                                                      faceCoords, coord.w(), cmpReference, result))
                        return true;
                }
            }
            else
            {
                if (isCubeLevelCompareResultValid(texture, 0, sampler, sampler.minFilter, prec, faceCoords, coord.w(),
                                                  cmpReference, result))
                    return true;
            }
        }
    }

    return false;
}

static bool isGatherOffsetsCompareResultValid(const ConstPixelBufferAccess &texture, const Sampler &sampler,
                                              const TexComparePrecision &prec, const Vec2 &coord, int coordZ,
                                              const IVec2 (&offsets)[4], float cmpReference, const Vec4 &result)
{
    const bool isFixedPointDepth = isFixedPointDepthTextureFormat(texture.getFormat());
    const Vec2 uBounds = computeNonNormalizedCoordBounds(sampler.normalizedCoords, texture.getWidth(), coord.x(),
                                                         prec.coordBits.x(), prec.uvwBits.x());
    const Vec2 vBounds = computeNonNormalizedCoordBounds(sampler.normalizedCoords, texture.getHeight(), coord.y(),
                                                         prec.coordBits.y(), prec.uvwBits.y());

    // Integer coordinate bounds for (x0, y0) - without wrap mode
    const int minI = deFloorFloatToInt32(uBounds.x() - 0.5f);
    const int maxI = deFloorFloatToInt32(uBounds.y() - 0.5f);
    const int minJ = deFloorFloatToInt32(vBounds.x() - 0.5f);
    const int maxJ = deFloorFloatToInt32(vBounds.y() - 0.5f);

    const int w = texture.getWidth();
    const int h = texture.getHeight();

    for (int j = minJ; j <= maxJ; j++)
    {
        for (int i = minI; i <= maxI; i++)
        {
            bool isCurrentPixelValid = true;

            for (int offNdx = 0; offNdx < 4 && isCurrentPixelValid; offNdx++)
            {
                // offNdx-th coordinate offset and then wrapped.
                const int x       = wrap(sampler.wrapS, i + offsets[offNdx].x(), w);
                const int y       = wrap(sampler.wrapT, j + offsets[offNdx].y(), h);
                const float depth = lookupDepth(texture, sampler, x, y, coordZ);
                const CmpResultSet resSet =
                    execCompare(sampler.compare, depth, cmpReference, prec.referenceBits, isFixedPointDepth);

                if (!isResultInSet(resSet, result[offNdx], prec.resultBits))
                    isCurrentPixelValid = false;
            }

            if (isCurrentPixelValid)
                return true;
        }
    }

    return false;
}

bool isGatherOffsetsCompareResultValid(const Texture2DView &texture, const Sampler &sampler,
                                       const TexComparePrecision &prec, const Vec2 &coord, const IVec2 (&offsets)[4],
                                       float cmpReference, const Vec4 &result)
{
    DE_ASSERT(isSamplerSupported(sampler));

    return isGatherOffsetsCompareResultValid(texture.getLevel(0), sampler, prec, coord, 0, offsets, cmpReference,
                                             result);
}

bool isGatherOffsetsCompareResultValid(const Texture2DArrayView &texture, const Sampler &sampler,
                                       const TexComparePrecision &prec, const Vec3 &coord, const IVec2 (&offsets)[4],
                                       float cmpReference, const Vec4 &result)
{
    const float depthErr =
        computeFloatingPointError(coord.z(), prec.coordBits.z()) + computeFixedPointError(prec.uvwBits.z());
    const float minZ   = coord.z() - depthErr;
    const float maxZ   = coord.z() + depthErr;
    const int minLayer = de::clamp(deFloorFloatToInt32(minZ + 0.5f), 0, texture.getNumLayers() - 1);
    const int maxLayer = de::clamp(deFloorFloatToInt32(maxZ + 0.5f), 0, texture.getNumLayers() - 1);

    DE_ASSERT(isSamplerSupported(sampler));

    for (int layer = minLayer; layer <= maxLayer; layer++)
    {
        if (isGatherOffsetsCompareResultValid(texture.getLevel(0), sampler, prec, coord.swizzle(0, 1), layer, offsets,
                                              cmpReference, result))
            return true;
    }
    return false;
}

static bool isGatherCompareResultValid(const TextureCubeView &texture, const Sampler &sampler,
                                       const TexComparePrecision &prec, const CubeFaceFloatCoords &coords,
                                       float cmpReference, const Vec4 &result)
{
    const bool isFixedPointDepth = isFixedPointDepthTextureFormat(texture.getLevelFace(0, coords.face).getFormat());
    const int size               = texture.getLevelFace(0, coords.face).getWidth();
    const Vec2 uBounds =
        computeNonNormalizedCoordBounds(sampler.normalizedCoords, size, coords.s, prec.coordBits.x(), prec.uvwBits.x());
    const Vec2 vBounds =
        computeNonNormalizedCoordBounds(sampler.normalizedCoords, size, coords.t, prec.coordBits.y(), prec.uvwBits.y());

    // Integer coordinate bounds for (x0,y0) - without wrap mode
    const int minI = deFloorFloatToInt32(uBounds.x() - 0.5f);
    const int maxI = deFloorFloatToInt32(uBounds.y() - 0.5f);
    const int minJ = deFloorFloatToInt32(vBounds.x() - 0.5f);
    const int maxJ = deFloorFloatToInt32(vBounds.y() - 0.5f);

    // Face accesses
    ConstPixelBufferAccess faces[CUBEFACE_LAST];
    for (int face = 0; face < CUBEFACE_LAST; face++)
        faces[face] = texture.getLevelFace(0, CubeFace(face));

    for (int j = minJ; j <= maxJ; j++)
    {
        for (int i = minI; i <= maxI; i++)
        {
            static const IVec2 offsets[4] = {IVec2(0, 1), IVec2(1, 1), IVec2(1, 0), IVec2(0, 0)};

            bool isCurrentPixelValid = true;

            for (int offNdx = 0; offNdx < 4 && isCurrentPixelValid; offNdx++)
            {
                const CubeFaceIntCoords c = remapCubeEdgeCoords(
                    CubeFaceIntCoords(coords.face, i + offsets[offNdx].x(), j + offsets[offNdx].y()), size);
                // If any of samples is out of both edges, implementations can do pretty much anything according to spec.
                // \todo [2014-06-05 nuutti] Test the special case where all corner pixels have exactly the same color.
                //                             See also isSeamlessLinearCompareResultValid and similar.
                if (c.face == CUBEFACE_LAST)
                    return true;

                const float depth = lookupDepthNoBorder(faces[c.face], sampler, c.s, c.t);
                const CmpResultSet resSet =
                    execCompare(sampler.compare, depth, cmpReference, prec.referenceBits, isFixedPointDepth);

                if (!isResultInSet(resSet, result[offNdx], prec.resultBits))
                    isCurrentPixelValid = false;
            }

            if (isCurrentPixelValid)
                return true;
        }
    }

    return false;
}

bool isGatherCompareResultValid(const TextureCubeView &texture, const Sampler &sampler, const TexComparePrecision &prec,
                                const Vec3 &coord, float cmpReference, const Vec4 &result)
{
    int numPossibleFaces = 0;
    CubeFace possibleFaces[CUBEFACE_LAST];

    DE_ASSERT(isSamplerSupported(sampler));

    getPossibleCubeFaces(coord, prec.coordBits, &possibleFaces[0], numPossibleFaces);

    if (numPossibleFaces == 0)
        return true; // Result is undefined.

    for (int tryFaceNdx = 0; tryFaceNdx < numPossibleFaces; tryFaceNdx++)
    {
        const CubeFaceFloatCoords faceCoords(possibleFaces[tryFaceNdx],
                                             projectToFace(possibleFaces[tryFaceNdx], coord));

        if (isGatherCompareResultValid(texture, sampler, prec, faceCoords, cmpReference, result))
            return true;
    }

    return false;
}

} // namespace tcu