Use new LOD approximation rules for OpenGL ES

This change updates OpenGL ES texture LOD approximation bounds to match
Vulkan. Since rules are now same for both APIs the LodPrecision
parameter introduced in 9f0ff9f49ae3359d9b2e50f5d720fc77460d0f4f is
removed.

Affects:

dEQP-GLES2.texture.*
dEQP-GLES3.texture.*
dEQP-GLES31.texture.*

Khronos spec bug: 16179
Google bug: 28200359
Components: AOSP, Vulkan, Framework

Change-Id: I55ff2e6296c7947af7ee5b7cf915d24c260ae374
(cherry picked from commit 0b6dbeb93e83dcf3b55d2eccce7cb1517c2caee5)

diff --git a/external/vulkancts/modules/vulkan/texture/vktTextureFilteringTests.cpp b/external/vulkancts/modules/vulkan/texture/vktTextureFilteringTests.cpp
index 2393c5f..7d1e94f 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::RULE_VULKAN);
+               tcu::LodPrecision               lodPrecision;
                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::RULE_VULKAN);
+                       tcu::LodPrecision               lodPrecision;
                        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::RULE_VULKAN);
+               tcu::LodPrecision               lodPrecision;
                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::RULE_VULKAN);
+               tcu::LodPrecision               lodPrecision;
                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 9bc4c4a..bb5558e 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::RULE_VULKAN);
+               tcu::LodPrecision               lodPrec;
                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::RULE_VULKAN);
+               tcu::LodPrecision               lodPrec;
 
                // 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::RULE_VULKAN);
+               tcu::LodPrecision               lodPrec;
                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::RULE_VULKAN);
+               tcu::LodPrecision               lodPrec;
                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::RULE_VULKAN);
+               tcu::LodPrecision               lodPrec;
 
                // 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::RULE_VULKAN);
+               tcu::LodPrecision               lodPrec;
                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 ab294d8..62874a5 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::RULE_VULKAN);
+               tcu::LodPrecision                       lodPrecision;
                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::RULE_VULKAN);
+                       tcu::LodPrecision                       lodPrecision;
                        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::RULE_VULKAN);
+               tcu::LodPrecision                       lodPrecision;
                tcu::TexComparePrecision        texComparePrecision;
 
                lodPrecision.derivateBits                       = 18;

diff --git a/framework/common/tcuTexLookupVerifier.cpp b/framework/common/tcuTexLookupVerifier.cpp
index 5b4ac5e..134cfd8 100644 (file)
--- a/framework/common/tcuTexLookupVerifier.cpp
+++ b/framework/common/tcuTexLookupVerifier.cpp
@@ -2117,24 +2117,7 @@ Vec4 computeFloatingPointThreshold (const IVec4& bits, const Vec4& value)
        return computeFloatingPointError(value, bits);
 }
 
-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));
-       const float             mw                      = de::max(deFloatAbs(dwdx), deFloatAbs(dwdy));
-       const float             minDBound       = de::max(de::max(mu, mv), mw);
-       const float             maxDBound       = mu + mv + mw;
-       const float             minDErr         = computeFloatingPointError(minDBound, prec.derivateBits);
-       const float             maxDErr         = computeFloatingPointError(maxDBound, prec.derivateBits);
-       const float             minLod          = deFloatLog2(minDBound-minDErr);
-       const float             maxLod          = deFloatLog2(maxDBound+maxDErr);
-       const float             lodErr          = computeFixedPointError(prec.lodBits);
-
-       DE_ASSERT(minLod <= maxLod);
-       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)
+Vec2 computeLodBoundsFromDerivates (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);
@@ -2172,14 +2155,6 @@ Vec2 computeVulkanLodBoundsFromDerivates (const float dudx, const float dvdx, co
        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 192986e..6f6aaec 100644 (file)
--- a/framework/common/tcuTexLookupVerifier.hpp
+++ b/framework/common/tcuTexLookupVerifier.hpp
@@ -77,21 +77,11 @@ 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 (Rule rule_)
-               : rule                  (rule_)
-               , derivateBits  (22)
+       LodPrecision (void)
+               : derivateBits  (22)
                , lodBits               (16)
        {
        }

diff --git a/modules/gles2/functional/es2fTextureFilteringTests.cpp b/modules/gles2/functional/es2fTextureFilteringTests.cpp
index 0a412a0..2e38f7e 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::RULE_OPENGL);
+               tcu::LodPrecision               lodPrecision;
                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::RULE_OPENGL);
+                       tcu::LodPrecision               lodPrecision;
                        tcu::LookupPrecision    lookupPrecision;
 
                        lodPrecision.derivateBits               = 5;

diff --git a/modules/gles2/functional/es2fTextureMipmapTests.cpp b/modules/gles2/functional/es2fTextureMipmapTests.cpp
index af7f9e8..cc65e5d 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::RULE_OPENGL);
+               tcu::LodPrecision               lodPrec;
                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::RULE_OPENGL);
+               tcu::LodPrecision               lodPrec;
 
                // 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 3c62936..929eb43 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::RULE_OPENGL);
+               tcu::LodPrecision               lodPrecision;
                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::RULE_OPENGL);
+                       tcu::LodPrecision               lodPrecision;
                        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::RULE_OPENGL);
+               tcu::LodPrecision               lodPrecision;
                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::RULE_OPENGL);
+               tcu::LodPrecision               lodPrecision;
                tcu::LookupPrecision    lookupPrecision;
 
                lodPrecision.derivateBits               = 18;

diff --git a/modules/gles3/functional/es3fTextureMipmapTests.cpp b/modules/gles3/functional/es3fTextureMipmapTests.cpp
index 4409631..bbb581f 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::RULE_OPENGL);
+               tcu::LodPrecision               lodPrec;
                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::RULE_OPENGL);
+               tcu::LodPrecision               lodPrec;
 
                // 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::RULE_OPENGL);
+               tcu::LodPrecision               lodPrec;
                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::RULE_OPENGL);
+               tcu::LodPrecision               lodPrec;
                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::RULE_OPENGL);
+               tcu::LodPrecision               lodPrec;
 
                // 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::RULE_OPENGL);
+               tcu::LodPrecision               lodPrec;
                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 8383ece..6eb9985 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::RULE_OPENGL);
+               tcu::LodPrecision                       lodPrecision;
                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::RULE_OPENGL);
+                       tcu::LodPrecision                       lodPrecision;
                        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::RULE_OPENGL);
+               tcu::LodPrecision                       lodPrecision;
                tcu::TexComparePrecision        texComparePrecision;
 
                lodPrecision.derivateBits                       = 18;

diff --git a/modules/gles3/functional/es3fTextureWrapTests.cpp b/modules/gles3/functional/es3fTextureWrapTests.cpp
index da12488..d4edcdd 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::RULE_OPENGL);
+               tcu::LodPrecision                               lodPrecision;
                tcu::LookupPrecision                    lookupPrecision;
 
                lodPrecision.derivateBits               = 18;

diff --git a/modules/gles31/functional/es31fStencilTexturingTests.cpp b/modules/gles31/functional/es31fStencilTexturingTests.cpp
index 92bb9a1..c592288 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::RULE_OPENGL);
+                       tcu::LodPrecision               lodPrec;
                        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 05f383e..0587f5a 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::RULE_OPENGL);
+       tcu::LodPrecision               lodPrecision;
        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::RULE_OPENGL);
+       tcu::LodPrecision                               lodPrecision;
        tcu::LookupPrecision                    lookupPrecision;
        int                                                             numFailedPixels;
 

diff --git a/modules/gles31/functional/es31fTextureFilteringTests.cpp b/modules/gles31/functional/es31fTextureFilteringTests.cpp
index 5784c37..bc26811 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::RULE_OPENGL);
+                       tcu::LodPrecision               lodPrecision;
                        tcu::LookupPrecision    lookupPrecision;
 
                        lodPrecision.derivateBits               = 10;