/*-------------------------------------------------------------------------
|
* 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());
|
}
|
|
static float lookupDepth (const tcu::ConstPixelBufferAccess& access, const Sampler& sampler, int i, int j, int k)
|
{
|
if (coordsInBounds(access, i, j, k))
|
return access.getPixDepth(i, j, k);
|
else
|
return sampleTextureBorder<float>(access.getFormat(), sampler).x();
|
}
|
|
// 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));
|
return access.getPixDepth(i, j, k);
|
}
|
|
// 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)
|
{
|
// 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 deUint32 isTrue = (deUint32(cmp0.isTrue)<<0)
|
| (deUint32(cmp1.isTrue)<<1);
|
const deUint32 isFalse = (deUint32(cmp0.isFalse)<<0)
|
| (deUint32(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 (deUint32 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 deUint32 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 deUint32 isTrue = (deUint32(cmp0.isTrue)<<0)
|
| (deUint32(cmp1.isTrue)<<1)
|
| (deUint32(cmp2.isTrue)<<2)
|
| (deUint32(cmp3.isTrue)<<3);
|
const deUint32 isFalse = (deUint32(cmp0.isFalse)<<0)
|
| (deUint32(cmp1.isFalse)<<1)
|
| (deUint32(cmp2.isFalse)<<2)
|
| (deUint32(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 (deUint32 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 deUint32 isTrue = (deUint32(cmp00.isTrue)<<0)
|
| (deUint32(cmp01.isTrue)<<1)
|
| (deUint32(cmp02.isTrue)<<2)
|
| (deUint32(cmp03.isTrue)<<3)
|
| (deUint32(cmp10.isTrue)<<4)
|
| (deUint32(cmp11.isTrue)<<5)
|
| (deUint32(cmp12.isTrue)<<6)
|
| (deUint32(cmp13.isTrue)<<7);
|
const deUint32 isFalse = (deUint32(cmp00.isFalse)<<0)
|
| (deUint32(cmp01.isFalse)<<1)
|
| (deUint32(cmp02.isFalse)<<2)
|
| (deUint32(cmp03.isFalse)<<3)
|
| (deUint32(cmp10.isFalse)<<4)
|
| (deUint32(cmp11.isFalse)<<5)
|
| (deUint32(cmp12.isFalse)<<6)
|
| (deUint32(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 (deUint32 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);
|
}
|
|
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;
|
}
|
|
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;
|
}
|
|
} // tcu
|
