blob: ce2a44978818d7cff4d8ba18e5e8a18514777440 [file] [log] [blame]
/*-------------------------------------------------------------------------
* 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 Internal utilities shared between TexLookup and TexCompare verifiers.
*//*--------------------------------------------------------------------*/
#include "tcuTexVerifierUtil.hpp"
#include "tcuFloat.hpp"
namespace tcu
{
namespace TexVerifierUtil
{
float computeFloatingPointError (const float value, const int numAccurateBits)
{
const int numGarbageBits = 23-numAccurateBits;
const deUint32 mask = (1u<<numGarbageBits)-1u;
const int exp = tcu::Float32(value).exponent();
return Float32::construct(+1, exp, (1u<<23) | mask).asFloat() - Float32::construct(+1, exp, 1u<<23).asFloat();
}
float computeFixedPointError (const int numAccurateBits)
{
return computeFloatingPointError(1.0f, numAccurateBits);
}
float computeColorBitsError(const int bits, const int numAccurateBits)
{
// Color bits error is not a generic function, it just for compute the error value that cannot be accurately shown in integer data format.
//
// "bits" is color bit width, "numAccurateBits" is the number of accurate bits in color bits, "1 << (bits - numAccurateBits)" is the threshold in integer.
// "1.0f / 256.0f" is epsilon value, to make sure the threshold use to calculate in float can be a little bigger than the real value.
return (float(1 << (bits - numAccurateBits)) + 1.0f / 256.0f) / float((1 << bits) - 1);
}
Vec2 computeNonNormalizedCoordBounds (const bool normalizedCoords, const int dim, const float coord, const int coordBits, const int uvBits)
{
const float coordErr = computeFloatingPointError(coord, coordBits);
const float minN = coord - coordErr;
const float maxN = coord + coordErr;
const float minA = normalizedCoords ? minN*float(dim) : minN;
const float maxA = normalizedCoords ? maxN*float(dim) : maxN;
const float minC = minA - computeFixedPointError(uvBits);
const float maxC = maxA + computeFixedPointError(uvBits);
DE_ASSERT(minC <= maxC);
return Vec2(minC, maxC);
}
void getPossibleCubeFaces (const Vec3& coord, const IVec3& bits, CubeFace* faces, int& numFaces)
{
const float x = coord.x();
const float y = coord.y();
const float z = coord.z();
const float ax = de::abs(x);
const float ay = de::abs(y);
const float az = de::abs(z);
const float ex = computeFloatingPointError(x, bits.x());
const float ey = computeFloatingPointError(y, bits.y());
const float ez = computeFloatingPointError(z, bits.z());
numFaces = 0;
if (ay+ey < ax-ex && az+ez < ax-ex)
{
if (x >= ex) faces[numFaces++] = CUBEFACE_POSITIVE_X;
if (x <= ex) faces[numFaces++] = CUBEFACE_NEGATIVE_X;
}
else if (ax+ex < ay-ey && az+ez < ay-ey)
{
if (y >= ey) faces[numFaces++] = CUBEFACE_POSITIVE_Y;
if (y <= ey) faces[numFaces++] = CUBEFACE_NEGATIVE_Y;
}
else if (ax+ex < az-ez && ay+ey < az-ez)
{
if (z >= ez) faces[numFaces++] = CUBEFACE_POSITIVE_Z;
if (z <= ez) faces[numFaces++] = CUBEFACE_NEGATIVE_Z;
}
else
{
// One or more components are equal (or within error bounds). Allow all faces where major axis is not zero.
if (ax > ex)
{
faces[numFaces++] = CUBEFACE_NEGATIVE_X;
faces[numFaces++] = CUBEFACE_POSITIVE_X;
}
if (ay > ey)
{
faces[numFaces++] = CUBEFACE_NEGATIVE_Y;
faces[numFaces++] = CUBEFACE_POSITIVE_Y;
}
if (az > ez)
{
faces[numFaces++] = CUBEFACE_NEGATIVE_Z;
faces[numFaces++] = CUBEFACE_POSITIVE_Z;
}
}
}
Sampler getUnnormalizedCoordSampler (const Sampler& sampler)
{
Sampler copy = sampler;
copy.normalizedCoords = false;
return copy;
}
static inline int imod (int a, int b)
{
int m = a % b;
return m < 0 ? m + b : m;
}
static inline int mirror (int a)
{
return a >= 0 ? a : -(1 + a);
}
int wrap (Sampler::WrapMode mode, int c, int size)
{
switch (mode)
{
// \note CL and GL modes are handled identically here, as verification process accounts for
// accuracy differences caused by different methods (wrapping vs. denormalizing first).
case tcu::Sampler::CLAMP_TO_BORDER:
return deClamp32(c, -1, size);
case tcu::Sampler::CLAMP_TO_EDGE:
return deClamp32(c, 0, size-1);
case tcu::Sampler::REPEAT_GL:
case tcu::Sampler::REPEAT_CL:
return imod(c, size);
case tcu::Sampler::MIRRORED_ONCE:
c = deClamp32(c, -size, size);
// Fall-through
case tcu::Sampler::MIRRORED_REPEAT_GL:
case tcu::Sampler::MIRRORED_REPEAT_CL:
return (size - 1) - mirror(imod(c, 2*size) - size);
default:
DE_ASSERT(DE_FALSE);
return 0;
}
}
} // TexVerifierUtil
} // tcu