Relax LOD computation bounds

This change updates LOD approximation rules to match proposed spec
language in Vulkan texture filtering and mipmap tests.

This is partial cherry-pick of 9f0ff9f49ae3359d9b2e50f5d720fc77460d0f4f.
Mustpass changes are not included.

Affects: dEQP-VK.texture.*

Change-Id: Ic786bc733913a76d27f0cba31f3a61a10f8144fc
(cherry picked from commit a9a793142c75c8537b3a2229f1e3289278d19fd6)

diff --git a/external/vulkancts/modules/vulkan/texture/vktTextureFilteringTests.cpp b/external/vulkancts/modules/vulkan/texture/vktTextureFilteringTests.cpp
index 7d1e94f..2393c5f 100644 (file)
--- a/external/vulkancts/modules/vulkan/texture/vktTextureFilteringTests.cpp
+++ b/external/vulkancts/modules/vulkan/texture/vktTextureFilteringTests.cpp
@@ -217,7 +217,7 @@ tcu::TestStatus Texture2DFilteringTestInstance::iterate (void)
                const tcu::IVec4                formatBitDepth  = getTextureFormatBitDepth(vk::mapVkFormat(VK_FORMAT_R8G8B8A8_UNORM));
                const tcu::PixelFormat  pixelFormat             (formatBitDepth[0], formatBitDepth[1], formatBitDepth[2], formatBitDepth[3]);
                const tcu::IVec4                colorBits               = max(getBitsVec(pixelFormat) - (isNearestOnly ? 1 : 2), tcu::IVec4(0)); // 1 inaccurate bit if nearest only, 2 otherwise
-               tcu::LodPrecision               lodPrecision;
+               tcu::LodPrecision               lodPrecision    (tcu::LodPrecision::RULE_VULKAN);
                tcu::LookupPrecision    lookupPrecision;
 
                lodPrecision.derivateBits               = 18;
@@ -434,7 +434,7 @@ tcu::TestStatus TextureCubeFilteringTestInstance::iterate (void)
                        const tcu::IVec4                formatBitDepth  = getTextureFormatBitDepth(vk::mapVkFormat(VK_FORMAT_R8G8B8A8_UNORM));
                        const tcu::PixelFormat  pixelFormat             (formatBitDepth[0], formatBitDepth[1], formatBitDepth[2], formatBitDepth[3]);
                        const tcu::IVec4                colorBits               = max(getBitsVec(pixelFormat) - (isNearestOnly ? 1 : 2), tcu::IVec4(0)); // 1 inaccurate bit if nearest only, 2 otherwise
-                       tcu::LodPrecision               lodPrecision;
+                       tcu::LodPrecision               lodPrecision    (tcu::LodPrecision::RULE_VULKAN);
                        tcu::LookupPrecision    lookupPrecision;
 
                        lodPrecision.derivateBits               = 10;
@@ -635,7 +635,7 @@ tcu::TestStatus Texture2DArrayFilteringTestInstance::iterate (void)
                const tcu::IVec4                formatBitDepth  = getTextureFormatBitDepth(vk::mapVkFormat(VK_FORMAT_R8G8B8A8_UNORM));
                const tcu::PixelFormat  pixelFormat             (formatBitDepth[0], formatBitDepth[1], formatBitDepth[2], formatBitDepth[3]);
                const tcu::IVec4                colorBits               = max(getBitsVec(pixelFormat) - (isNearestOnly ? 1 : 2), tcu::IVec4(0)); // 1 inaccurate bit if nearest only, 2 otherwise
-               tcu::LodPrecision               lodPrecision;
+               tcu::LodPrecision               lodPrecision    (tcu::LodPrecision::RULE_VULKAN);
                tcu::LookupPrecision    lookupPrecision;
 
                lodPrecision.derivateBits               = 18;
@@ -813,7 +813,7 @@ tcu::TestStatus Texture3DFilteringTestInstance::iterate (void)
                const tcu::IVec4                formatBitDepth  = getTextureFormatBitDepth(vk::mapVkFormat(VK_FORMAT_R8G8B8A8_UNORM));
                const tcu::PixelFormat  pixelFormat             (formatBitDepth[0], formatBitDepth[1], formatBitDepth[2], formatBitDepth[3]);
                const tcu::IVec4                colorBits               = max(getBitsVec(pixelFormat) - (isNearestOnly ? 1 : 2), tcu::IVec4(0)); // 1 inaccurate bit if nearest only, 2 otherwise
-               tcu::LodPrecision               lodPrecision;
+               tcu::LodPrecision               lodPrecision    (tcu::LodPrecision::RULE_VULKAN);
                tcu::LookupPrecision    lookupPrecision;
 
                lodPrecision.derivateBits               = 18;

diff --git a/external/vulkancts/modules/vulkan/texture/vktTextureMipmapTests.cpp b/external/vulkancts/modules/vulkan/texture/vktTextureMipmapTests.cpp
index bb5558e..9bc4c4a 100644 (file)
--- a/external/vulkancts/modules/vulkan/texture/vktTextureMipmapTests.cpp
+++ b/external/vulkancts/modules/vulkan/texture/vktTextureMipmapTests.cpp
@@ -335,7 +335,7 @@ tcu::TestStatus Texture2DMipmapTestInstance::iterate (void)
                tcu::Surface                    referenceFrame  (viewportWidth, viewportHeight);
                tcu::Surface                    errorMask               (viewportWidth, viewportHeight);
                tcu::LookupPrecision    lookupPrec;
-               tcu::LodPrecision               lodPrec;
+               tcu::LodPrecision               lodPrec                 (tcu::LodPrecision::RULE_VULKAN);
                int                                             numFailedPixels = 0;
 
                lookupPrec.coordBits            = tcu::IVec3(20, 20, 0);
@@ -569,7 +569,7 @@ tcu::TestStatus TextureCubeMipmapTestInstance::iterate (void)
                tcu::Surface                    errorMask                       (viewportWidth, viewportHeight);
                int                                             numFailedPixels         = 0;
                tcu::LookupPrecision    lookupPrec;
-               tcu::LodPrecision               lodPrec;
+               tcu::LodPrecision               lodPrec                         (tcu::LodPrecision::RULE_VULKAN);
 
                // Params for rendering reference
                refParams.sampler                                       = util::createSampler(m_testParameters.wrapS, m_testParameters.wrapT, m_testParameters.minFilter, m_testParameters.magFilter);
@@ -849,7 +849,7 @@ tcu::TestStatus Texture3DMipmapTestInstance::iterate (void)
                tcu::Surface                    referenceFrame  (viewportWidth, viewportHeight);
                tcu::Surface                    errorMask               (viewportWidth, viewportHeight);
                tcu::LookupPrecision    lookupPrec;
-               tcu::LodPrecision               lodPrec;
+               tcu::LodPrecision               lodPrec                 (tcu::LodPrecision::RULE_VULKAN);
                int                                             numFailedPixels = 0;
 
                lookupPrec.coordBits            = tcu::IVec3(20, 20, 20);
@@ -1032,7 +1032,7 @@ tcu::TestStatus Texture2DLodControlTestInstance::iterate (void)
                tcu::Surface                    referenceFrame  (viewportWidth, viewportHeight);
                tcu::Surface                    errorMask               (viewportWidth, viewportHeight);
                tcu::LookupPrecision    lookupPrec;
-               tcu::LodPrecision               lodPrec;
+               tcu::LodPrecision               lodPrec                 (tcu::LodPrecision::RULE_VULKAN);
                int                                             numFailedPixels = 0;
 
                lookupPrec.coordBits            = tcu::IVec3(20, 20, 0);
@@ -1289,7 +1289,7 @@ tcu::TestStatus TextureCubeLodControlTestInstance::iterate (void)
                tcu::Surface                    errorMask                       (viewportWidth, viewportHeight);
                int                                             numFailedPixels         = 0;
                tcu::LookupPrecision    lookupPrec;
-               tcu::LodPrecision               lodPrec;
+               tcu::LodPrecision               lodPrec                         (tcu::LodPrecision::RULE_VULKAN);
 
                // Params for rendering reference
                refParams.sampler                                       = util::createSampler(wrapS, wrapT, m_testParameters.minFilter, magFilter);
@@ -1557,7 +1557,7 @@ tcu::TestStatus Texture3DLodControlTestInstance::iterate (void)
                tcu::Surface                    referenceFrame  (viewportWidth, viewportHeight);
                tcu::Surface                    errorMask               (viewportWidth, viewportHeight);
                tcu::LookupPrecision    lookupPrec;
-               tcu::LodPrecision               lodPrec;
+               tcu::LodPrecision               lodPrec                 (tcu::LodPrecision::RULE_VULKAN);
                int                                             numFailedPixels = 0;
 
                lookupPrec.coordBits            = tcu::IVec3(20, 20, 20);

diff --git a/external/vulkancts/modules/vulkan/texture/vktTextureShadowTests.cpp b/external/vulkancts/modules/vulkan/texture/vktTextureShadowTests.cpp
index 62874a5..ab294d8 100644 (file)
--- a/external/vulkancts/modules/vulkan/texture/vktTextureShadowTests.cpp
+++ b/external/vulkancts/modules/vulkan/texture/vktTextureShadowTests.cpp
@@ -346,7 +346,7 @@ tcu::TestStatus Texture2DShadowTestInstance::iterate (void)
 
        {
                const tcu::PixelFormat          pixelFormat                     = getPixelFormat(vk::mapVkFormat(VK_FORMAT_R8G8B8A8_UNORM));
-               tcu::LodPrecision                       lodPrecision;
+               tcu::LodPrecision                       lodPrecision            (tcu::LodPrecision::RULE_VULKAN);
                tcu::TexComparePrecision        texComparePrecision;
 
                lodPrecision.derivateBits                       = 18;
@@ -562,7 +562,7 @@ tcu::TestStatus TextureCubeShadowTestInstance::iterate (void)
 
                {
                        const tcu::PixelFormat          pixelFormat                     = getPixelFormat(vk::mapVkFormat(VK_FORMAT_R8G8B8A8_UNORM));
-                       tcu::LodPrecision                       lodPrecision;
+                       tcu::LodPrecision                       lodPrecision            (tcu::LodPrecision::RULE_VULKAN);
                        tcu::TexComparePrecision        texComparePrecision;
 
                        lodPrecision.derivateBits                       = 10;
@@ -774,7 +774,7 @@ tcu::TestStatus Texture2DArrayShadowTestInstance::iterate (void)
 
        {
                const tcu::PixelFormat          pixelFormat                     = getPixelFormat(vk::mapVkFormat(VK_FORMAT_R8G8B8A8_UNORM));
-               tcu::LodPrecision                       lodPrecision;
+               tcu::LodPrecision                       lodPrecision            (tcu::LodPrecision::RULE_VULKAN);
                tcu::TexComparePrecision        texComparePrecision;
 
                lodPrecision.derivateBits                       = 18;

diff --git a/framework/common/tcuTexLookupVerifier.cpp b/framework/common/tcuTexLookupVerifier.cpp
index 7f3e277..5b4ac5e 100644 (file)
--- a/framework/common/tcuTexLookupVerifier.cpp
+++ b/framework/common/tcuTexLookupVerifier.cpp
@@ -2117,7 +2117,7 @@ Vec4 computeFloatingPointThreshold (const IVec4& bits, const Vec4& value)
        return computeFloatingPointError(value, bits);
 }
 
-Vec2 computeLodBoundsFromDerivates (const float dudx, const float dvdx, const float dwdx, const float dudy, const float dvdy, const float dwdy, const LodPrecision& prec)
+Vec2 computeOpenGLLodBoundsFromDerivates (const float dudx, const float dvdx, const float dwdx, const float dudy, const float dvdy, const float dwdy, const LodPrecision& prec)
 {
        const float             mu                      = de::max(deFloatAbs(dudx), deFloatAbs(dudy));
        const float             mv                      = de::max(deFloatAbs(dvdx), deFloatAbs(dvdy));
@@ -2134,6 +2134,52 @@ Vec2 computeLodBoundsFromDerivates (const float dudx, const float dvdx, const fl
        return Vec2(minLod-lodErr, maxLod+lodErr);
 }
 
+Vec2 computeVulkanLodBoundsFromDerivates (const float dudx, const float dvdx, const float dwdx, const float dudy, const float dvdy, const float dwdy, const LodPrecision& prec)
+{
+       const float             mux                     = deFloatAbs(dudx);
+       const float             mvx                     = deFloatAbs(dvdx);
+       const float             mwx                     = deFloatAbs(dwdx);
+       const float             muy                     = deFloatAbs(dudy);
+       const float             mvy                     = deFloatAbs(dvdy);
+       const float             mwy                     = deFloatAbs(dwdy);
+
+       // Ideal:
+       // px = deFloatSqrt2(mux*mux + mvx*mvx + mwx*mwx);
+       // py = deFloatSqrt2(muy*muy + mvy*mvy + mwy*mwy);
+
+       // fx, fy estimate lower bounds
+       const float             fxMin           = de::max(de::max(mux, mvx), mwx);
+       const float             fyMin           = de::max(de::max(muy, mvy), mwy);
+
+       // fx, fy estimate upper bounds
+       const float             sqrt2           = deFloatSqrt(2.0f);
+       const float             fxMax           = sqrt2 * (mux + mvx + mwx);
+       const float             fyMax           = sqrt2 * (muy + mvy + mwy);
+
+       // p = max(px, py) (isotropic filtering)
+       const float             pMin            = de::max(fxMin, fyMin);
+       const float             pMax            = de::max(fxMax, fyMax);
+
+       // error terms
+       const float             pMinErr         = computeFloatingPointError(pMin, prec.derivateBits);
+       const float             pMaxErr         = computeFloatingPointError(pMax, prec.derivateBits);
+
+       const float             minLod          = deFloatLog2(pMin-pMinErr);
+       const float             maxLod          = deFloatLog2(pMax+pMaxErr);
+       const float             lodErr          = computeFixedPointError(prec.lodBits);
+
+       DE_ASSERT(minLod <= maxLod);
+       return Vec2(minLod-lodErr, maxLod+lodErr);
+}
+
+Vec2 computeLodBoundsFromDerivates (const float dudx, const float dvdx, const float dwdx, const float dudy, const float dvdy, const float dwdy, const LodPrecision& prec)
+{
+       if (prec.rule == LodPrecision::RULE_VULKAN)
+               return computeVulkanLodBoundsFromDerivates(dudx, dvdx, dwdx, dudy, dvdy, dwdy, prec);
+       else
+               return computeOpenGLLodBoundsFromDerivates(dudx, dvdx, dwdx, dudy, dvdy, dwdy, prec);
+}
+
 Vec2 computeLodBoundsFromDerivates (const float dudx, const float dvdx, const float dudy, const float dvdy, const LodPrecision& prec)
 {
        return computeLodBoundsFromDerivates(dudx, dvdx, 0.0f, dudy, dvdy, 0.0f, prec);

diff --git a/framework/common/tcuTexLookupVerifier.hpp b/framework/common/tcuTexLookupVerifier.hpp
index 6f6aaec..192986e 100644 (file)
--- a/framework/common/tcuTexLookupVerifier.hpp
+++ b/framework/common/tcuTexLookupVerifier.hpp
@@ -77,11 +77,21 @@ struct IntLookupPrecision
  *//*--------------------------------------------------------------------*/
 struct LodPrecision
 {
+       enum Rule
+       {
+               RULE_OPENGL             = 0,    //!< OpenGL LOD
+               RULE_VULKAN,                    //!< Vulkan LOD
+
+               RULE_LAST
+       };
+
+       Rule            rule;                   //!< LOD computation rule (Vulkan or OpenGL)
        int                     derivateBits;   //!< Number of bits in derivates. (Floating-point)
        int                     lodBits;                //!< Number of bits in final lod (accuracy of log2()). (Fixed-point)
 
-       LodPrecision (void)
-               : derivateBits  (22)
+       LodPrecision (Rule rule_)
+               : rule                  (rule_)
+               , derivateBits  (22)
                , lodBits               (16)
        {
        }

diff --git a/modules/gles2/functional/es2fTextureFilteringTests.cpp b/modules/gles2/functional/es2fTextureFilteringTests.cpp
index 2e38f7e..0a412a0 100644 (file)
--- a/modules/gles2/functional/es2fTextureFilteringTests.cpp
+++ b/modules/gles2/functional/es2fTextureFilteringTests.cpp
@@ -299,7 +299,7 @@ Texture2DFilteringCase::IterateResult Texture2DFilteringCase::iterate (void)
                const bool                              isNearestOnly   = m_minFilter == GL_NEAREST && m_magFilter == GL_NEAREST;
                const tcu::PixelFormat  pixelFormat             = m_renderCtx.getRenderTarget().getPixelFormat();
                const tcu::IVec4                colorBits               = max(getBitsVec(pixelFormat) - (isNearestOnly ? 1 : 2), tcu::IVec4(0)); // 1 inaccurate bit if nearest only, 2 otherwise
-               tcu::LodPrecision               lodPrecision;
+               tcu::LodPrecision               lodPrecision    (tcu::LodPrecision::RULE_OPENGL);
                tcu::LookupPrecision    lookupPrecision;
 
                lodPrecision.derivateBits               = 7;
@@ -585,7 +585,7 @@ TextureCubeFilteringCase::IterateResult TextureCubeFilteringCase::iterate (void)
                        const bool                              isNearestOnly   = m_minFilter == GL_NEAREST && m_magFilter == GL_NEAREST;
                        const tcu::PixelFormat  pixelFormat             = m_renderCtx.getRenderTarget().getPixelFormat();
                        const tcu::IVec4                colorBits               = max(getBitsVec(pixelFormat) - (isNearestOnly ? 1 : 2), tcu::IVec4(0)); // 1 inaccurate bit if nearest only, 2 otherwise
-                       tcu::LodPrecision               lodPrecision;
+                       tcu::LodPrecision               lodPrecision    (tcu::LodPrecision::RULE_OPENGL);
                        tcu::LookupPrecision    lookupPrecision;
 
                        lodPrecision.derivateBits               = 5;

diff --git a/modules/gles2/functional/es2fTextureMipmapTests.cpp b/modules/gles2/functional/es2fTextureMipmapTests.cpp
index cc65e5d..af7f9e8 100644 (file)
--- a/modules/gles2/functional/es2fTextureMipmapTests.cpp
+++ b/modules/gles2/functional/es2fTextureMipmapTests.cpp
@@ -350,7 +350,7 @@ Texture2DMipmapCase::IterateResult Texture2DMipmapCase::iterate (void)
                tcu::Surface                    referenceFrame  (viewport.width, viewport.height);
                tcu::Surface                    errorMask               (viewport.width, viewport.height);
                tcu::LookupPrecision    lookupPrec;
-               tcu::LodPrecision               lodPrec;
+               tcu::LodPrecision               lodPrec                 (tcu::LodPrecision::RULE_OPENGL);
                int                                             numFailedPixels = 0;
 
                lookupPrec.coordBits            = tcu::IVec3(20, 20, 0);
@@ -670,7 +670,7 @@ TextureCubeMipmapCase::IterateResult TextureCubeMipmapCase::iterate (void)
                int                                             numFailedPixels         = 0;
                ReferenceParams                 params                          (TEXTURETYPE_CUBE);
                tcu::LookupPrecision    lookupPrec;
-               tcu::LodPrecision               lodPrec;
+               tcu::LodPrecision               lodPrec                         (tcu::LodPrecision::RULE_OPENGL);
 
                // Params for rendering reference
                params.sampler                                  = glu::mapGLSampler(m_wrapS, m_wrapT, m_minFilter, magFilter);

diff --git a/modules/gles3/functional/es3fTextureFilteringTests.cpp b/modules/gles3/functional/es3fTextureFilteringTests.cpp
index 929eb43..3c62936 100644 (file)
--- a/modules/gles3/functional/es3fTextureFilteringTests.cpp
+++ b/modules/gles3/functional/es3fTextureFilteringTests.cpp
@@ -299,7 +299,7 @@ Texture2DFilteringCase::IterateResult Texture2DFilteringCase::iterate (void)
                const bool                              isNearestOnly   = m_minFilter == GL_NEAREST && m_magFilter == GL_NEAREST;
                const tcu::PixelFormat  pixelFormat             = m_renderCtx.getRenderTarget().getPixelFormat();
                const tcu::IVec4                colorBits               = max(getBitsVec(pixelFormat) - (isNearestOnly ? 1 : 2), tcu::IVec4(0)); // 1 inaccurate bit if nearest only, 2 otherwise
-               tcu::LodPrecision               lodPrecision;
+               tcu::LodPrecision               lodPrecision    (tcu::LodPrecision::RULE_OPENGL);
                tcu::LookupPrecision    lookupPrecision;
 
                lodPrecision.derivateBits               = 18;
@@ -612,7 +612,7 @@ TextureCubeFilteringCase::IterateResult TextureCubeFilteringCase::iterate (void)
                        const bool                              isNearestOnly   = m_minFilter == GL_NEAREST && m_magFilter == GL_NEAREST;
                        const tcu::PixelFormat  pixelFormat             = m_renderCtx.getRenderTarget().getPixelFormat();
                        const tcu::IVec4                colorBits               = max(getBitsVec(pixelFormat) - (isNearestOnly ? 1 : 2), tcu::IVec4(0)); // 1 inaccurate bit if nearest only, 2 otherwise
-                       tcu::LodPrecision               lodPrecision;
+                       tcu::LodPrecision               lodPrecision    (tcu::LodPrecision::RULE_OPENGL);
                        tcu::LookupPrecision    lookupPrecision;
 
                        lodPrecision.derivateBits               = 10;
@@ -878,7 +878,7 @@ Texture2DArrayFilteringCase::IterateResult Texture2DArrayFilteringCase::iterate
                const bool                              isNearestOnly   = m_minFilter == GL_NEAREST && m_magFilter == GL_NEAREST;
                const tcu::PixelFormat  pixelFormat             = m_context.getRenderTarget().getPixelFormat();
                const tcu::IVec4                colorBits               = max(getBitsVec(pixelFormat) - (isNearestOnly ? 1 : 2), tcu::IVec4(0)); // 1 inaccurate bit if nearest only, 2 otherwise
-               tcu::LodPrecision               lodPrecision;
+               tcu::LodPrecision               lodPrecision    (tcu::LodPrecision::RULE_OPENGL);
                tcu::LookupPrecision    lookupPrecision;
 
                lodPrecision.derivateBits               = 18;
@@ -1120,7 +1120,7 @@ Texture3DFilteringCase::IterateResult Texture3DFilteringCase::iterate (void)
                const bool                              isNearestOnly   = m_minFilter == GL_NEAREST && m_magFilter == GL_NEAREST;
                const tcu::PixelFormat  pixelFormat             = m_context.getRenderTarget().getPixelFormat();
                const tcu::IVec4                colorBits               = max(getBitsVec(pixelFormat) - (isNearestOnly ? 1 : 2), tcu::IVec4(0)); // 1 inaccurate bit if nearest only, 2 otherwise
-               tcu::LodPrecision               lodPrecision;
+               tcu::LodPrecision               lodPrecision    (tcu::LodPrecision::RULE_OPENGL);
                tcu::LookupPrecision    lookupPrecision;
 
                lodPrecision.derivateBits               = 18;

diff --git a/modules/gles3/functional/es3fTextureMipmapTests.cpp b/modules/gles3/functional/es3fTextureMipmapTests.cpp
index bbb581f..4409631 100644 (file)
--- a/modules/gles3/functional/es3fTextureMipmapTests.cpp
+++ b/modules/gles3/functional/es3fTextureMipmapTests.cpp
@@ -394,7 +394,7 @@ Texture2DMipmapCase::IterateResult Texture2DMipmapCase::iterate (void)
                tcu::Surface                    referenceFrame  (viewport.width, viewport.height);
                tcu::Surface                    errorMask               (viewport.width, viewport.height);
                tcu::LookupPrecision    lookupPrec;
-               tcu::LodPrecision               lodPrec;
+               tcu::LodPrecision               lodPrec                 (tcu::LodPrecision::RULE_OPENGL);
                int                                             numFailedPixels = 0;
 
                lookupPrec.coordBits            = tcu::IVec3(20, 20, 0);
@@ -709,7 +709,7 @@ TextureCubeMipmapCase::IterateResult TextureCubeMipmapCase::iterate (void)
                int                                             numFailedPixels         = 0;
                ReferenceParams                 params                          (TEXTURETYPE_CUBE);
                tcu::LookupPrecision    lookupPrec;
-               tcu::LodPrecision               lodPrec;
+               tcu::LodPrecision               lodPrec                         (tcu::LodPrecision::RULE_OPENGL);
 
                // Params for rendering reference
                params.sampler                                  = glu::mapGLSampler(m_wrapS, m_wrapT, m_minFilter, magFilter);
@@ -1341,7 +1341,7 @@ Texture3DMipmapCase::IterateResult Texture3DMipmapCase::iterate (void)
                tcu::Surface                    referenceFrame  (viewport.width, viewport.height);
                tcu::Surface                    errorMask               (viewport.width, viewport.height);
                tcu::LookupPrecision    lookupPrec;
-               tcu::LodPrecision               lodPrec;
+               tcu::LodPrecision               lodPrec                 (tcu::LodPrecision::RULE_OPENGL);
                int                                             numFailedPixels = 0;
 
                lookupPrec.coordBits            = tcu::IVec3(20, 20, 20);
@@ -1555,7 +1555,7 @@ Texture2DLodControlCase::IterateResult Texture2DLodControlCase::iterate (void)
                tcu::Surface                    referenceFrame  (viewport.width, viewport.height);
                tcu::Surface                    errorMask               (viewport.width, viewport.height);
                tcu::LookupPrecision    lookupPrec;
-               tcu::LodPrecision               lodPrec;
+               tcu::LodPrecision               lodPrec                 (tcu::LodPrecision::RULE_OPENGL);
                int                                             numFailedPixels = 0;
 
                lookupPrec.coordBits            = tcu::IVec3(20, 20, 0);
@@ -1866,7 +1866,7 @@ TextureCubeLodControlCase::IterateResult TextureCubeLodControlCase::iterate (voi
                int                                             numFailedPixels         = 0;
                ReferenceParams                 params                          (TEXTURETYPE_CUBE);
                tcu::LookupPrecision    lookupPrec;
-               tcu::LodPrecision               lodPrec;
+               tcu::LodPrecision               lodPrec                         (tcu::LodPrecision::RULE_OPENGL);
 
                // Params for rendering reference
                params.sampler                                  = glu::mapGLSampler(wrapS, wrapT, m_minFilter, magFilter);
@@ -2187,7 +2187,7 @@ Texture3DLodControlCase::IterateResult Texture3DLodControlCase::iterate (void)
                tcu::Surface                    referenceFrame  (viewport.width, viewport.height);
                tcu::Surface                    errorMask               (viewport.width, viewport.height);
                tcu::LookupPrecision    lookupPrec;
-               tcu::LodPrecision               lodPrec;
+               tcu::LodPrecision               lodPrec                 (tcu::LodPrecision::RULE_OPENGL);
                int                                             numFailedPixels = 0;
 
                lookupPrec.coordBits            = tcu::IVec3(20, 20, 20);

diff --git a/modules/gles3/functional/es3fTextureShadowTests.cpp b/modules/gles3/functional/es3fTextureShadowTests.cpp
index 6eb9985..8383ece 100644 (file)
--- a/modules/gles3/functional/es3fTextureShadowTests.cpp
+++ b/modules/gles3/functional/es3fTextureShadowTests.cpp
@@ -362,7 +362,7 @@ Texture2DShadowCase::IterateResult Texture2DShadowCase::iterate (void)
 
        {
                const tcu::PixelFormat          pixelFormat             = m_context.getRenderTarget().getPixelFormat();
-               tcu::LodPrecision                       lodPrecision;
+               tcu::LodPrecision                       lodPrecision    (tcu::LodPrecision::RULE_OPENGL);
                tcu::TexComparePrecision        texComparePrecision;
 
                lodPrecision.derivateBits                       = 18;
@@ -652,7 +652,7 @@ TextureCubeShadowCase::IterateResult TextureCubeShadowCase::iterate (void)
 
                {
                        const tcu::PixelFormat          pixelFormat             = m_context.getRenderTarget().getPixelFormat();
-                       tcu::LodPrecision                       lodPrecision;
+                       tcu::LodPrecision                       lodPrecision    (tcu::LodPrecision::RULE_OPENGL);
                        tcu::TexComparePrecision        texComparePrecision;
 
                        lodPrecision.derivateBits                       = 10;
@@ -928,7 +928,7 @@ Texture2DArrayShadowCase::IterateResult Texture2DArrayShadowCase::iterate (void)
 
        {
                const tcu::PixelFormat          pixelFormat             = m_context.getRenderTarget().getPixelFormat();
-               tcu::LodPrecision                       lodPrecision;
+               tcu::LodPrecision                       lodPrecision    (tcu::LodPrecision::RULE_OPENGL);
                tcu::TexComparePrecision        texComparePrecision;
 
                lodPrecision.derivateBits                       = 18;

diff --git a/modules/gles3/functional/es3fTextureWrapTests.cpp b/modules/gles3/functional/es3fTextureWrapTests.cpp
index d4edcdd..da12488 100644 (file)
--- a/modules/gles3/functional/es3fTextureWrapTests.cpp
+++ b/modules/gles3/functional/es3fTextureWrapTests.cpp
@@ -334,7 +334,7 @@ TextureWrapCase::IterateResult TextureWrapCase::iterate (void)
                const bool                                              isSRGB                  = tcu::isSRGB(texFormat);
                const tcu::PixelFormat                  pixelFormat             = m_renderCtx.getRenderTarget().getPixelFormat();
                const tcu::IVec4                                colorBits               = tcu::max(getBitsVec(pixelFormat) - (isNearestOnly && !isSRGB ? 1 : 2), tcu::IVec4(0));
-               tcu::LodPrecision                               lodPrecision;
+               tcu::LodPrecision                               lodPrecision    (tcu::LodPrecision::RULE_OPENGL);
                tcu::LookupPrecision                    lookupPrecision;
 
                lodPrecision.derivateBits               = 18;

diff --git a/modules/gles31/functional/es31fStencilTexturingTests.cpp b/modules/gles31/functional/es31fStencilTexturingTests.cpp
index c592288..92bb9a1 100644 (file)
--- a/modules/gles31/functional/es31fStencilTexturingTests.cpp
+++ b/modules/gles31/functional/es31fStencilTexturingTests.cpp
@@ -716,7 +716,7 @@ public:
                                                                                                                                                                        tcu::Sampler::NEAREST,
                                                                                                                                                                        tcu::Sampler::NEAREST));
                        tcu::LookupPrecision    lookupPrec;
-                       tcu::LodPrecision               lodPrec;
+                       tcu::LodPrecision               lodPrec                 (tcu::LodPrecision::RULE_OPENGL);
                        bool                                    compareOk;
 
                        lookupPrec.colorMask            = tcu::BVec4(true, true, true, true);

diff --git a/modules/gles31/functional/es31fTextureBorderClampTests.cpp b/modules/gles31/functional/es31fTextureBorderClampTests.cpp
index 0587f5a..05f383e 100644 (file)
--- a/modules/gles31/functional/es31fTextureBorderClampTests.cpp
+++ b/modules/gles31/functional/es31fTextureBorderClampTests.cpp
@@ -912,7 +912,7 @@ void TextureBorderClampTest::verifyImage (const tcu::Surface&                                                       renderedFram
 {
        const tcu::PixelFormat  pixelFormat             = m_context.getRenderTarget().getPixelFormat();
 
-       tcu::LodPrecision               lodPrecision;
+       tcu::LodPrecision               lodPrecision    (tcu::LodPrecision::RULE_OPENGL);
        std::vector<float>              texCoord;
        bool                                    verificationOk;
 
@@ -2211,7 +2211,7 @@ void TextureBorderClampPerAxisCase3D::verifyImage (const tcu::Surface&                                                    ren
        const tcu::IVec4                                colorBits                       = tcu::max(glu::TextureTestUtil::getBitsVec(pixelFormat) - tcu::IVec4(colorErrorBits), tcu::IVec4(0));
        tcu::Surface                                    reference                       (renderedFrame.getWidth(), renderedFrame.getHeight());
        tcu::Surface                                    errorMask                       (renderedFrame.getWidth(), renderedFrame.getHeight());
-       tcu::LodPrecision                               lodPrecision;
+       tcu::LodPrecision                               lodPrecision            (tcu::LodPrecision::RULE_OPENGL);
        tcu::LookupPrecision                    lookupPrecision;
        int                                                             numFailedPixels;
 

diff --git a/modules/gles31/functional/es31fTextureFilteringTests.cpp b/modules/gles31/functional/es31fTextureFilteringTests.cpp
index bc26811..5784c37 100644 (file)
--- a/modules/gles31/functional/es31fTextureFilteringTests.cpp
+++ b/modules/gles31/functional/es31fTextureFilteringTests.cpp
@@ -376,7 +376,7 @@ TextureCubeArrayFilteringCase::IterateResult TextureCubeArrayFilteringCase::iter
                        const tcu::PixelFormat  pixelFormat             = renderCtx.getRenderTarget().getPixelFormat();
                        const tcu::IVec4                coordBits               = tcu::IVec4(10);
                        const tcu::IVec4                colorBits               = max(getBitsVec(pixelFormat) - (isNearestOnly ? 1 : 2), tcu::IVec4(0)); // 1 inaccurate bit if nearest only, 2 otherwise
-                       tcu::LodPrecision               lodPrecision;
+                       tcu::LodPrecision               lodPrecision    (tcu::LodPrecision::RULE_OPENGL);
                        tcu::LookupPrecision    lookupPrecision;
 
                        lodPrecision.derivateBits               = 10;