| /*------------------------------------------------------------------------- |
| * drawElements Quality Program OpenGL ES 3.0 Module |
| * ------------------------------------------------- |
| * |
| * 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 Shadow texture lookup tests. |
| *//*--------------------------------------------------------------------*/ |
| |
| #include "es3fTextureShadowTests.hpp" |
| #include "gluTexture.hpp" |
| #include "gluPixelTransfer.hpp" |
| #include "gluTextureUtil.hpp" |
| #include "glsTextureTestUtil.hpp" |
| #include "tcuTextureUtil.hpp" |
| #include "tcuRenderTarget.hpp" |
| #include "tcuTexCompareVerifier.hpp" |
| #include "tcuVectorUtil.hpp" |
| #include "deString.h" |
| #include "deMath.h" |
| #include "deStringUtil.hpp" |
| #include "glwFunctions.hpp" |
| #include "glwEnums.hpp" |
| |
| namespace deqp |
| { |
| namespace gles3 |
| { |
| namespace Functional |
| { |
| |
| using std::string; |
| using std::vector; |
| using tcu::TestLog; |
| using namespace deqp::gls::TextureTestUtil; |
| using namespace glu::TextureTestUtil; |
| |
| enum |
| { |
| TEX2D_VIEWPORT_WIDTH = 64, |
| TEX2D_VIEWPORT_HEIGHT = 64, |
| TEX2D_MIN_VIEWPORT_WIDTH = 64, |
| TEX2D_MIN_VIEWPORT_HEIGHT = 64 |
| }; |
| |
| static bool isFloatingPointDepthFormat(const tcu::TextureFormat &format) |
| { |
| // Only two depth and depth-stencil formats are floating point |
| return (format.order == tcu::TextureFormat::D && format.type == tcu::TextureFormat::FLOAT) || |
| (format.order == tcu::TextureFormat::DS && format.type == tcu::TextureFormat::FLOAT_UNSIGNED_INT_24_8_REV); |
| } |
| |
| static void clampFloatingPointTexture(const tcu::PixelBufferAccess &access) |
| { |
| DE_ASSERT(isFloatingPointDepthFormat(access.getFormat())); |
| |
| for (int z = 0; z < access.getDepth(); ++z) |
| for (int y = 0; y < access.getHeight(); ++y) |
| for (int x = 0; x < access.getWidth(); ++x) |
| access.setPixDepth(de::clamp(access.getPixDepth(x, y, z), 0.0f, 1.0f), x, y, z); |
| } |
| |
| static void clampFloatingPointTexture(tcu::Texture2D &target) |
| { |
| for (int level = 0; level < target.getNumLevels(); ++level) |
| if (!target.isLevelEmpty(level)) |
| clampFloatingPointTexture(target.getLevel(level)); |
| } |
| |
| static void clampFloatingPointTexture(tcu::Texture2DArray &target) |
| { |
| for (int level = 0; level < target.getNumLevels(); ++level) |
| if (!target.isLevelEmpty(level)) |
| clampFloatingPointTexture(target.getLevel(level)); |
| } |
| |
| static void clampFloatingPointTexture(tcu::TextureCube &target) |
| { |
| for (int level = 0; level < target.getNumLevels(); ++level) |
| for (int face = tcu::CUBEFACE_NEGATIVE_X; face < tcu::CUBEFACE_LAST; ++face) |
| clampFloatingPointTexture(target.getLevelFace(level, (tcu::CubeFace)face)); |
| } |
| |
| template <typename TextureType> |
| bool verifyTexCompareResult(tcu::TestContext &testCtx, const tcu::ConstPixelBufferAccess &result, |
| const TextureType &src, const float *texCoord, const ReferenceParams &sampleParams, |
| const tcu::TexComparePrecision &comparePrec, const tcu::LodPrecision &lodPrec, |
| const tcu::PixelFormat &pixelFormat) |
| { |
| tcu::TestLog &log = testCtx.getLog(); |
| tcu::Surface reference(result.getWidth(), result.getHeight()); |
| tcu::Surface errorMask(result.getWidth(), result.getHeight()); |
| const tcu::IVec4 nonShadowBits = tcu::max(getBitsVec(pixelFormat) - 1, tcu::IVec4(0)); |
| const tcu::Vec3 nonShadowThreshold = tcu::computeFixedPointThreshold(nonShadowBits).swizzle(1, 2, 3); |
| int numFailedPixels; |
| |
| // sampleTexture() expects source image to be the same state as it would be in a GL implementation, that is |
| // the floating point depth values should be in [0, 1] range as data is clamped during texture upload. Since |
| // we don't have a separate "uploading" phase and just reuse the buffer we used for GL-upload, do the clamping |
| // here if necessary. |
| |
| if (isFloatingPointDepthFormat(src.getFormat())) |
| { |
| TextureType clampedSource(src); |
| |
| clampFloatingPointTexture(clampedSource); |
| |
| // sample clamped values |
| |
| sampleTexture(tcu::SurfaceAccess(reference, pixelFormat), clampedSource, texCoord, sampleParams); |
| numFailedPixels = computeTextureCompareDiff(result, reference.getAccess(), errorMask.getAccess(), clampedSource, |
| texCoord, sampleParams, comparePrec, lodPrec, nonShadowThreshold); |
| } |
| else |
| { |
| // sample raw values (they are guaranteed to be in [0, 1] range as the format cannot represent any other values) |
| |
| sampleTexture(tcu::SurfaceAccess(reference, pixelFormat), src, texCoord, sampleParams); |
| numFailedPixels = computeTextureCompareDiff(result, reference.getAccess(), errorMask.getAccess(), src, texCoord, |
| sampleParams, comparePrec, lodPrec, nonShadowThreshold); |
| } |
| |
| if (numFailedPixels > 0) |
| log << TestLog::Message << "ERROR: Result verification failed, got " << numFailedPixels << " invalid pixels!" |
| << TestLog::EndMessage; |
| |
| log << TestLog::ImageSet("VerifyResult", "Verification result") |
| << TestLog::Image("Rendered", "Rendered image", result); |
| |
| if (numFailedPixels > 0) |
| { |
| log << TestLog::Image("Reference", "Ideal reference image", reference) |
| << TestLog::Image("ErrorMask", "Error mask", errorMask); |
| } |
| |
| log << TestLog::EndImageSet; |
| |
| return numFailedPixels == 0; |
| } |
| |
| class Texture2DShadowCase : public TestCase |
| { |
| public: |
| Texture2DShadowCase(Context &context, const char *name, const char *desc, uint32_t minFilter, uint32_t magFilter, |
| uint32_t wrapS, uint32_t wrapT, uint32_t format, int width, int height, uint32_t compareFunc); |
| ~Texture2DShadowCase(void); |
| |
| void init(void); |
| void deinit(void); |
| IterateResult iterate(void); |
| |
| private: |
| Texture2DShadowCase(const Texture2DShadowCase &other); |
| Texture2DShadowCase &operator=(const Texture2DShadowCase &other); |
| |
| const uint32_t m_minFilter; |
| const uint32_t m_magFilter; |
| const uint32_t m_wrapS; |
| const uint32_t m_wrapT; |
| const uint32_t m_format; |
| const int m_width; |
| const int m_height; |
| const uint32_t m_compareFunc; |
| |
| struct FilterCase |
| { |
| const glu::Texture2D *texture; |
| tcu::Vec2 minCoord; |
| tcu::Vec2 maxCoord; |
| float ref; |
| |
| FilterCase(void) : texture(DE_NULL), ref(0.0f) |
| { |
| } |
| |
| FilterCase(const glu::Texture2D *tex_, const float ref_, const tcu::Vec2 &minCoord_, const tcu::Vec2 &maxCoord_) |
| : texture(tex_) |
| , minCoord(minCoord_) |
| , maxCoord(maxCoord_) |
| , ref(ref_) |
| { |
| } |
| }; |
| |
| std::vector<glu::Texture2D *> m_textures; |
| std::vector<FilterCase> m_cases; |
| |
| TextureRenderer m_renderer; |
| |
| int m_caseNdx; |
| }; |
| |
| Texture2DShadowCase::Texture2DShadowCase(Context &context, const char *name, const char *desc, uint32_t minFilter, |
| uint32_t magFilter, uint32_t wrapS, uint32_t wrapT, uint32_t format, int width, |
| int height, uint32_t compareFunc) |
| : TestCase(context, name, desc) |
| , m_minFilter(minFilter) |
| , m_magFilter(magFilter) |
| , m_wrapS(wrapS) |
| , m_wrapT(wrapT) |
| , m_format(format) |
| , m_width(width) |
| , m_height(height) |
| , m_compareFunc(compareFunc) |
| , m_renderer(context.getRenderContext(), context.getTestContext().getLog(), glu::GLSL_VERSION_300_ES, |
| glu::PRECISION_HIGHP) |
| , m_caseNdx(0) |
| { |
| } |
| |
| Texture2DShadowCase::~Texture2DShadowCase(void) |
| { |
| deinit(); |
| } |
| |
| void Texture2DShadowCase::init(void) |
| { |
| try |
| { |
| // Create 2 textures. |
| m_textures.reserve(2); |
| m_textures.push_back(new glu::Texture2D(m_context.getRenderContext(), m_format, m_width, m_height)); |
| m_textures.push_back(new glu::Texture2D(m_context.getRenderContext(), m_format, m_width, m_height)); |
| |
| int numLevels = m_textures[0]->getRefTexture().getNumLevels(); |
| |
| // Fill first gradient texture. |
| for (int levelNdx = 0; levelNdx < numLevels; levelNdx++) |
| { |
| m_textures[0]->getRefTexture().allocLevel(levelNdx); |
| tcu::fillWithComponentGradients(m_textures[0]->getRefTexture().getLevel(levelNdx), |
| tcu::Vec4(-0.5f, -0.5f, -0.5f, 2.0f), tcu::Vec4(1.0f, 1.0f, 1.0f, 0.0f)); |
| } |
| |
| // Fill second with grid texture. |
| for (int levelNdx = 0; levelNdx < numLevels; levelNdx++) |
| { |
| uint32_t step = 0x00ffffff / numLevels; |
| uint32_t rgb = step * levelNdx; |
| uint32_t colorA = 0xff000000 | rgb; |
| uint32_t colorB = 0xff000000 | ~rgb; |
| |
| m_textures[1]->getRefTexture().allocLevel(levelNdx); |
| tcu::fillWithGrid(m_textures[1]->getRefTexture().getLevel(levelNdx), 4, tcu::RGBA(colorA).toVec(), |
| tcu::RGBA(colorB).toVec()); |
| } |
| |
| // Upload. |
| for (std::vector<glu::Texture2D *>::iterator i = m_textures.begin(); i != m_textures.end(); i++) |
| (*i)->upload(); |
| } |
| catch (const std::exception &) |
| { |
| // Clean up to save memory. |
| Texture2DShadowCase::deinit(); |
| throw; |
| } |
| |
| // Compute cases. |
| { |
| const float refInRangeUpper = (m_compareFunc == GL_EQUAL || m_compareFunc == GL_NOTEQUAL) ? 1.0f : 0.5f; |
| const float refInRangeLower = (m_compareFunc == GL_EQUAL || m_compareFunc == GL_NOTEQUAL) ? 0.0f : 0.5f; |
| const float refOutOfBoundsUpper = 1.1f; // !< lookup function should clamp values to [0, 1] range |
| const float refOutOfBoundsLower = -0.1f; |
| |
| const struct |
| { |
| int texNdx; |
| float ref; |
| float lodX; |
| float lodY; |
| float oX; |
| float oY; |
| } cases[] = { |
| {0, refInRangeUpper, 1.6f, 2.9f, -1.0f, -2.7f}, |
| {0, refInRangeLower, -2.0f, -1.35f, -0.2f, 0.7f}, |
| {1, refInRangeUpper, 0.14f, 0.275f, -1.5f, -1.1f}, |
| {1, refInRangeLower, -0.92f, -2.64f, 0.4f, -0.1f}, |
| {1, refOutOfBoundsUpper, -0.39f, -0.52f, 0.65f, 0.87f}, |
| {1, refOutOfBoundsLower, -1.55f, 0.65f, 0.35f, 0.91f}, |
| }; |
| |
| const float viewportW = (float)de::min<int>(TEX2D_VIEWPORT_WIDTH, m_context.getRenderTarget().getWidth()); |
| const float viewportH = (float)de::min<int>(TEX2D_VIEWPORT_HEIGHT, m_context.getRenderTarget().getHeight()); |
| |
| for (int caseNdx = 0; caseNdx < DE_LENGTH_OF_ARRAY(cases); caseNdx++) |
| { |
| const int texNdx = de::clamp(cases[caseNdx].texNdx, 0, (int)m_textures.size() - 1); |
| const float ref = cases[caseNdx].ref; |
| const float lodX = cases[caseNdx].lodX; |
| const float lodY = cases[caseNdx].lodY; |
| const float oX = cases[caseNdx].oX; |
| const float oY = cases[caseNdx].oY; |
| const float sX = deFloatExp2(lodX) * viewportW / float(m_textures[texNdx]->getRefTexture().getWidth()); |
| const float sY = deFloatExp2(lodY) * viewportH / float(m_textures[texNdx]->getRefTexture().getHeight()); |
| |
| m_cases.push_back(FilterCase(m_textures[texNdx], ref, tcu::Vec2(oX, oY), tcu::Vec2(oX + sX, oY + sY))); |
| } |
| } |
| |
| m_caseNdx = 0; |
| m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); |
| } |
| |
| void Texture2DShadowCase::deinit(void) |
| { |
| for (std::vector<glu::Texture2D *>::iterator i = m_textures.begin(); i != m_textures.end(); i++) |
| delete *i; |
| m_textures.clear(); |
| |
| m_renderer.clear(); |
| m_cases.clear(); |
| } |
| |
| Texture2DShadowCase::IterateResult Texture2DShadowCase::iterate(void) |
| { |
| const glw::Functions &gl = m_context.getRenderContext().getFunctions(); |
| const RandomViewport viewport(m_context.getRenderTarget(), TEX2D_VIEWPORT_WIDTH, TEX2D_VIEWPORT_HEIGHT, |
| deStringHash(getName()) ^ deInt32Hash(m_caseNdx)); |
| const FilterCase &curCase = m_cases[m_caseNdx]; |
| const tcu::ScopedLogSection section(m_testCtx.getLog(), string("Test") + de::toString(m_caseNdx), |
| string("Test ") + de::toString(m_caseNdx)); |
| ReferenceParams sampleParams(TEXTURETYPE_2D); |
| tcu::Surface rendered(viewport.width, viewport.height); |
| vector<float> texCoord; |
| |
| if (viewport.width < TEX2D_MIN_VIEWPORT_WIDTH || viewport.height < TEX2D_MIN_VIEWPORT_HEIGHT) |
| throw tcu::NotSupportedError("Too small render target", "", __FILE__, __LINE__); |
| |
| // Setup params for reference. |
| sampleParams.sampler = glu::mapGLSampler(m_wrapS, m_wrapT, m_minFilter, m_magFilter); |
| sampleParams.sampler.compare = glu::mapGLCompareFunc(m_compareFunc); |
| sampleParams.samplerType = SAMPLERTYPE_SHADOW; |
| sampleParams.lodMode = LODMODE_EXACT; |
| sampleParams.ref = curCase.ref; |
| |
| m_testCtx.getLog() << TestLog::Message << "Compare reference value = " << sampleParams.ref << TestLog::EndMessage; |
| |
| // Compute texture coordinates. |
| m_testCtx.getLog() << TestLog::Message << "Texture coordinates: " << curCase.minCoord << " -> " << curCase.maxCoord |
| << TestLog::EndMessage; |
| computeQuadTexCoord2D(texCoord, curCase.minCoord, curCase.maxCoord); |
| |
| gl.bindTexture(GL_TEXTURE_2D, curCase.texture->getGLTexture()); |
| gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, m_minFilter); |
| gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, m_magFilter); |
| gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, m_wrapS); |
| gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, m_wrapT); |
| gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE, GL_COMPARE_REF_TO_TEXTURE); |
| gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_FUNC, m_compareFunc); |
| |
| gl.viewport(viewport.x, viewport.y, viewport.width, viewport.height); |
| m_renderer.renderQuad(0, &texCoord[0], sampleParams); |
| glu::readPixels(m_context.getRenderContext(), viewport.x, viewport.y, rendered.getAccess()); |
| |
| { |
| const tcu::PixelFormat pixelFormat = m_context.getRenderTarget().getPixelFormat(); |
| tcu::LodPrecision lodPrecision; |
| tcu::TexComparePrecision texComparePrecision; |
| |
| lodPrecision.derivateBits = 18; |
| lodPrecision.lodBits = 6; |
| texComparePrecision.coordBits = tcu::IVec3(20, 20, 0); |
| texComparePrecision.uvwBits = tcu::IVec3(7, 7, 0); |
| texComparePrecision.pcfBits = 5; |
| texComparePrecision.referenceBits = 16; |
| texComparePrecision.resultBits = pixelFormat.redBits - 1; |
| |
| const bool isHighQuality = |
| verifyTexCompareResult(m_testCtx, rendered.getAccess(), curCase.texture->getRefTexture(), &texCoord[0], |
| sampleParams, texComparePrecision, lodPrecision, pixelFormat); |
| |
| if (!isHighQuality) |
| { |
| m_testCtx.getLog() << TestLog::Message |
| << "Warning: Verification assuming high-quality PCF filtering failed." |
| << TestLog::EndMessage; |
| |
| lodPrecision.lodBits = 4; |
| texComparePrecision.uvwBits = tcu::IVec3(4, 4, 0); |
| texComparePrecision.pcfBits = 0; |
| |
| const bool isOk = |
| verifyTexCompareResult(m_testCtx, rendered.getAccess(), curCase.texture->getRefTexture(), &texCoord[0], |
| sampleParams, texComparePrecision, lodPrecision, pixelFormat); |
| |
| if (!isOk) |
| { |
| m_testCtx.getLog() |
| << TestLog::Message |
| << "ERROR: Verification against low precision requirements failed, failing test case." |
| << TestLog::EndMessage; |
| m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Image verification failed"); |
| } |
| else if (m_testCtx.getTestResult() == QP_TEST_RESULT_PASS) |
| m_testCtx.setTestResult(QP_TEST_RESULT_QUALITY_WARNING, "Low-quality result"); |
| } |
| } |
| |
| m_caseNdx += 1; |
| return m_caseNdx < (int)m_cases.size() ? CONTINUE : STOP; |
| } |
| |
| class TextureCubeShadowCase : public TestCase |
| { |
| public: |
| TextureCubeShadowCase(Context &context, const char *name, const char *desc, uint32_t minFilter, uint32_t magFilter, |
| uint32_t wrapS, uint32_t wrapT, uint32_t format, int size, uint32_t compareFunc); |
| ~TextureCubeShadowCase(void); |
| |
| void init(void); |
| void deinit(void); |
| IterateResult iterate(void); |
| |
| private: |
| TextureCubeShadowCase(const TextureCubeShadowCase &other); |
| TextureCubeShadowCase &operator=(const TextureCubeShadowCase &other); |
| |
| const uint32_t m_minFilter; |
| const uint32_t m_magFilter; |
| const uint32_t m_wrapS; |
| const uint32_t m_wrapT; |
| |
| const uint32_t m_format; |
| const int m_size; |
| |
| const uint32_t m_compareFunc; |
| |
| struct FilterCase |
| { |
| const glu::TextureCube *texture; |
| tcu::Vec2 bottomLeft; |
| tcu::Vec2 topRight; |
| float ref; |
| |
| FilterCase(void) : texture(DE_NULL), ref(0.0f) |
| { |
| } |
| |
| FilterCase(const glu::TextureCube *tex_, const float ref_, const tcu::Vec2 &bottomLeft_, |
| const tcu::Vec2 &topRight_) |
| : texture(tex_) |
| , bottomLeft(bottomLeft_) |
| , topRight(topRight_) |
| , ref(ref_) |
| { |
| } |
| }; |
| |
| glu::TextureCube *m_gradientTex; |
| glu::TextureCube *m_gridTex; |
| std::vector<FilterCase> m_cases; |
| |
| TextureRenderer m_renderer; |
| |
| int m_caseNdx; |
| }; |
| |
| TextureCubeShadowCase::TextureCubeShadowCase(Context &context, const char *name, const char *desc, uint32_t minFilter, |
| uint32_t magFilter, uint32_t wrapS, uint32_t wrapT, uint32_t format, |
| int size, uint32_t compareFunc) |
| : TestCase(context, name, desc) |
| , m_minFilter(minFilter) |
| , m_magFilter(magFilter) |
| , m_wrapS(wrapS) |
| , m_wrapT(wrapT) |
| , m_format(format) |
| , m_size(size) |
| , m_compareFunc(compareFunc) |
| , m_gradientTex(DE_NULL) |
| , m_gridTex(DE_NULL) |
| , m_renderer(context.getRenderContext(), context.getTestContext().getLog(), glu::GLSL_VERSION_300_ES, |
| glu::PRECISION_HIGHP) |
| , m_caseNdx(0) |
| { |
| } |
| |
| TextureCubeShadowCase::~TextureCubeShadowCase(void) |
| { |
| TextureCubeShadowCase::deinit(); |
| } |
| |
| void TextureCubeShadowCase::init(void) |
| { |
| try |
| { |
| DE_ASSERT(!m_gradientTex && !m_gridTex); |
| |
| int numLevels = deLog2Floor32(m_size) + 1; |
| tcu::TextureFormat texFmt = glu::mapGLInternalFormat(m_format); |
| tcu::TextureFormatInfo fmtInfo = tcu::getTextureFormatInfo(texFmt); |
| tcu::Vec4 cBias = fmtInfo.valueMin; |
| tcu::Vec4 cScale = fmtInfo.valueMax - fmtInfo.valueMin; |
| |
| // Create textures. |
| m_gradientTex = new glu::TextureCube(m_context.getRenderContext(), m_format, m_size); |
| m_gridTex = new glu::TextureCube(m_context.getRenderContext(), m_format, m_size); |
| |
| // Fill first with gradient texture. |
| static const tcu::Vec4 gradients[tcu::CUBEFACE_LAST][2] = { |
| {tcu::Vec4(-1.0f, -1.0f, -1.0f, 2.0f), tcu::Vec4(1.0f, 1.0f, 1.0f, 0.0f)}, // negative x |
| {tcu::Vec4(0.0f, -1.0f, -1.0f, 2.0f), tcu::Vec4(1.0f, 1.0f, 1.0f, 0.0f)}, // positive x |
| {tcu::Vec4(-1.0f, 0.0f, -1.0f, 2.0f), tcu::Vec4(1.0f, 1.0f, 1.0f, 0.0f)}, // negative y |
| {tcu::Vec4(-1.0f, -1.0f, 0.0f, 2.0f), tcu::Vec4(1.0f, 1.0f, 1.0f, 0.0f)}, // positive y |
| {tcu::Vec4(-1.0f, -1.0f, -1.0f, 0.0f), tcu::Vec4(1.0f, 1.0f, 1.0f, 1.0f)}, // negative z |
| {tcu::Vec4(0.0f, 0.0f, 0.0f, 2.0f), tcu::Vec4(1.0f, 1.0f, 1.0f, 0.0f)} // positive z |
| }; |
| for (int face = 0; face < tcu::CUBEFACE_LAST; face++) |
| { |
| for (int levelNdx = 0; levelNdx < numLevels; levelNdx++) |
| { |
| m_gradientTex->getRefTexture().allocLevel((tcu::CubeFace)face, levelNdx); |
| tcu::fillWithComponentGradients( |
| m_gradientTex->getRefTexture().getLevelFace(levelNdx, (tcu::CubeFace)face), |
| gradients[face][0] * cScale + cBias, gradients[face][1] * cScale + cBias); |
| } |
| } |
| |
| // Fill second with grid texture. |
| for (int face = 0; face < tcu::CUBEFACE_LAST; face++) |
| { |
| for (int levelNdx = 0; levelNdx < numLevels; levelNdx++) |
| { |
| uint32_t step = 0x00ffffff / (numLevels * tcu::CUBEFACE_LAST); |
| uint32_t rgb = step * levelNdx * face; |
| uint32_t colorA = 0xff000000 | rgb; |
| uint32_t colorB = 0xff000000 | ~rgb; |
| |
| m_gridTex->getRefTexture().allocLevel((tcu::CubeFace)face, levelNdx); |
| tcu::fillWithGrid(m_gridTex->getRefTexture().getLevelFace(levelNdx, (tcu::CubeFace)face), 4, |
| tcu::RGBA(colorA).toVec() * cScale + cBias, |
| tcu::RGBA(colorB).toVec() * cScale + cBias); |
| } |
| } |
| |
| // Upload. |
| m_gradientTex->upload(); |
| m_gridTex->upload(); |
| } |
| catch (const std::exception &) |
| { |
| // Clean up to save memory. |
| TextureCubeShadowCase::deinit(); |
| throw; |
| } |
| |
| // Compute cases |
| { |
| const float refInRangeUpper = (m_compareFunc == GL_EQUAL || m_compareFunc == GL_NOTEQUAL) ? 1.0f : 0.5f; |
| const float refInRangeLower = (m_compareFunc == GL_EQUAL || m_compareFunc == GL_NOTEQUAL) ? 0.0f : 0.5f; |
| const float refOutOfBoundsUpper = 1.1f; |
| const float refOutOfBoundsLower = -0.1f; |
| const bool singleSample = m_context.getRenderTarget().getNumSamples() == 0; |
| |
| if (singleSample) |
| m_cases.push_back(FilterCase(m_gradientTex, refInRangeUpper, tcu::Vec2(-1.25f, -1.2f), |
| tcu::Vec2(1.2f, 1.25f))); // minification |
| else |
| m_cases.push_back(FilterCase( |
| m_gradientTex, refInRangeUpper, tcu::Vec2(-1.19f, -1.3f), |
| tcu::Vec2(1.1f, 1.35f))); // minification - w/ tuned coordinates to avoid hitting triangle edges |
| |
| m_cases.push_back(FilterCase(m_gradientTex, refInRangeLower, tcu::Vec2(0.8f, 0.8f), |
| tcu::Vec2(1.25f, 1.20f))); // magnification |
| m_cases.push_back( |
| FilterCase(m_gridTex, refInRangeUpper, tcu::Vec2(-1.19f, -1.3f), tcu::Vec2(1.1f, 1.35f))); // minification |
| m_cases.push_back( |
| FilterCase(m_gridTex, refInRangeLower, tcu::Vec2(-1.2f, -1.1f), tcu::Vec2(-0.8f, -0.8f))); // magnification |
| m_cases.push_back(FilterCase(m_gridTex, refOutOfBoundsUpper, tcu::Vec2(-0.61f, -0.1f), |
| tcu::Vec2(0.9f, 1.18f))); // reference value clamp, upper |
| |
| if (singleSample) |
| m_cases.push_back(FilterCase(m_gridTex, refOutOfBoundsLower, tcu::Vec2(-0.75f, 1.0f), |
| tcu::Vec2(0.05f, 0.75f))); // reference value clamp, lower |
| else |
| m_cases.push_back(FilterCase(m_gridTex, refOutOfBoundsLower, tcu::Vec2(-0.75f, 1.0f), |
| tcu::Vec2(0.25f, 0.75f))); // reference value clamp, lower |
| } |
| |
| m_caseNdx = 0; |
| m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); |
| } |
| |
| void TextureCubeShadowCase::deinit(void) |
| { |
| delete m_gradientTex; |
| delete m_gridTex; |
| |
| m_gradientTex = DE_NULL; |
| m_gridTex = DE_NULL; |
| |
| m_renderer.clear(); |
| m_cases.clear(); |
| } |
| |
| static const char *getFaceDesc(const tcu::CubeFace face) |
| { |
| switch (face) |
| { |
| case tcu::CUBEFACE_NEGATIVE_X: |
| return "-X"; |
| case tcu::CUBEFACE_POSITIVE_X: |
| return "+X"; |
| case tcu::CUBEFACE_NEGATIVE_Y: |
| return "-Y"; |
| case tcu::CUBEFACE_POSITIVE_Y: |
| return "+Y"; |
| case tcu::CUBEFACE_NEGATIVE_Z: |
| return "-Z"; |
| case tcu::CUBEFACE_POSITIVE_Z: |
| return "+Z"; |
| default: |
| DE_ASSERT(false); |
| return DE_NULL; |
| } |
| } |
| |
| TextureCubeShadowCase::IterateResult TextureCubeShadowCase::iterate(void) |
| { |
| const glw::Functions &gl = m_context.getRenderContext().getFunctions(); |
| const int viewportSize = 28; |
| const RandomViewport viewport(m_context.getRenderTarget(), viewportSize, viewportSize, |
| deStringHash(getName()) ^ deInt32Hash(m_caseNdx)); |
| const tcu::ScopedLogSection iterSection(m_testCtx.getLog(), string("Test") + de::toString(m_caseNdx), |
| string("Test ") + de::toString(m_caseNdx)); |
| const FilterCase &curCase = m_cases[m_caseNdx]; |
| ReferenceParams sampleParams(TEXTURETYPE_CUBE); |
| |
| if (viewport.width < viewportSize || viewport.height < viewportSize) |
| throw tcu::NotSupportedError("Too small render target", DE_NULL, __FILE__, __LINE__); |
| |
| // Setup texture |
| gl.bindTexture(GL_TEXTURE_CUBE_MAP, curCase.texture->getGLTexture()); |
| gl.texParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, m_minFilter); |
| gl.texParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, m_magFilter); |
| gl.texParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, m_wrapS); |
| gl.texParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, m_wrapT); |
| gl.texParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_COMPARE_MODE, GL_COMPARE_REF_TO_TEXTURE); |
| gl.texParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_COMPARE_FUNC, m_compareFunc); |
| |
| // Other state |
| gl.viewport(viewport.x, viewport.y, viewport.width, viewport.height); |
| |
| // Params for reference computation. |
| sampleParams.sampler = glu::mapGLSampler(GL_CLAMP_TO_EDGE, GL_CLAMP_TO_EDGE, m_minFilter, m_magFilter); |
| sampleParams.sampler.seamlessCubeMap = true; |
| sampleParams.sampler.compare = glu::mapGLCompareFunc(m_compareFunc); |
| sampleParams.samplerType = SAMPLERTYPE_SHADOW; |
| sampleParams.lodMode = LODMODE_EXACT; |
| sampleParams.ref = curCase.ref; |
| |
| m_testCtx.getLog() << TestLog::Message << "Compare reference value = " << sampleParams.ref << "\n" |
| << "Coordinates: " << curCase.bottomLeft << " -> " << curCase.topRight << TestLog::EndMessage; |
| |
| for (int faceNdx = 0; faceNdx < tcu::CUBEFACE_LAST; faceNdx++) |
| { |
| const tcu::CubeFace face = tcu::CubeFace(faceNdx); |
| tcu::Surface result(viewport.width, viewport.height); |
| vector<float> texCoord; |
| |
| computeQuadTexCoordCube(texCoord, face, curCase.bottomLeft, curCase.topRight); |
| |
| m_testCtx.getLog() << TestLog::Message << "Face " << getFaceDesc(face) << TestLog::EndMessage; |
| |
| // \todo Log texture coordinates. |
| |
| m_renderer.renderQuad(0, &texCoord[0], sampleParams); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "Draw"); |
| |
| glu::readPixels(m_context.getRenderContext(), viewport.x, viewport.y, result.getAccess()); |
| GLU_EXPECT_NO_ERROR(gl.getError(), "Read pixels"); |
| |
| { |
| const tcu::PixelFormat pixelFormat = m_context.getRenderTarget().getPixelFormat(); |
| tcu::LodPrecision lodPrecision; |
| tcu::TexComparePrecision texComparePrecision; |
| |
| lodPrecision.derivateBits = 10; |
| lodPrecision.lodBits = 5; |
| texComparePrecision.coordBits = tcu::IVec3(10, 10, 10); |
| texComparePrecision.uvwBits = tcu::IVec3(6, 6, 0); |
| texComparePrecision.pcfBits = 5; |
| texComparePrecision.referenceBits = 16; |
| texComparePrecision.resultBits = pixelFormat.redBits - 1; |
| |
| const bool isHighQuality = |
| verifyTexCompareResult(m_testCtx, result.getAccess(), curCase.texture->getRefTexture(), &texCoord[0], |
| sampleParams, texComparePrecision, lodPrecision, pixelFormat); |
| |
| if (!isHighQuality) |
| { |
| m_testCtx.getLog() << TestLog::Message |
| << "Warning: Verification assuming high-quality PCF filtering failed." |
| << TestLog::EndMessage; |
| |
| lodPrecision.lodBits = 4; |
| texComparePrecision.uvwBits = tcu::IVec3(4, 4, 0); |
| texComparePrecision.pcfBits = 0; |
| |
| const bool isOk = |
| verifyTexCompareResult(m_testCtx, result.getAccess(), curCase.texture->getRefTexture(), |
| &texCoord[0], sampleParams, texComparePrecision, lodPrecision, pixelFormat); |
| |
| if (!isOk) |
| { |
| m_testCtx.getLog() |
| << TestLog::Message |
| << "ERROR: Verification against low precision requirements failed, failing test case." |
| << TestLog::EndMessage; |
| m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Image verification failed"); |
| } |
| else if (m_testCtx.getTestResult() == QP_TEST_RESULT_PASS) |
| m_testCtx.setTestResult(QP_TEST_RESULT_QUALITY_WARNING, "Low-quality result"); |
| } |
| } |
| } |
| |
| m_caseNdx += 1; |
| return m_caseNdx < (int)m_cases.size() ? CONTINUE : STOP; |
| } |
| |
| class Texture2DArrayShadowCase : public TestCase |
| { |
| public: |
| Texture2DArrayShadowCase(Context &context, const char *name, const char *desc, uint32_t minFilter, |
| uint32_t magFilter, uint32_t wrapS, uint32_t wrapT, uint32_t format, int width, int height, |
| int numLayers, uint32_t compareFunc); |
| ~Texture2DArrayShadowCase(void); |
| |
| void init(void); |
| void deinit(void); |
| IterateResult iterate(void); |
| |
| private: |
| Texture2DArrayShadowCase(const Texture2DArrayShadowCase &other); |
| Texture2DArrayShadowCase &operator=(const Texture2DArrayShadowCase &other); |
| |
| const uint32_t m_minFilter; |
| const uint32_t m_magFilter; |
| const uint32_t m_wrapS; |
| const uint32_t m_wrapT; |
| |
| const uint32_t m_format; |
| const int m_width; |
| const int m_height; |
| const int m_numLayers; |
| |
| const uint32_t m_compareFunc; |
| |
| struct FilterCase |
| { |
| const glu::Texture2DArray *texture; |
| tcu::Vec3 minCoord; |
| tcu::Vec3 maxCoord; |
| float ref; |
| |
| FilterCase(void) : texture(DE_NULL), ref(0.0f) |
| { |
| } |
| |
| FilterCase(const glu::Texture2DArray *tex_, float ref_, const tcu::Vec3 &minCoord_, const tcu::Vec3 &maxCoord_) |
| : texture(tex_) |
| , minCoord(minCoord_) |
| , maxCoord(maxCoord_) |
| , ref(ref_) |
| { |
| } |
| }; |
| |
| glu::Texture2DArray *m_gradientTex; |
| glu::Texture2DArray *m_gridTex; |
| std::vector<FilterCase> m_cases; |
| |
| TextureRenderer m_renderer; |
| |
| int m_caseNdx; |
| }; |
| |
| Texture2DArrayShadowCase::Texture2DArrayShadowCase(Context &context, const char *name, const char *desc, |
| uint32_t minFilter, uint32_t magFilter, uint32_t wrapS, |
| uint32_t wrapT, uint32_t format, int width, int height, |
| int numLayers, uint32_t compareFunc) |
| : TestCase(context, name, desc) |
| , m_minFilter(minFilter) |
| , m_magFilter(magFilter) |
| , m_wrapS(wrapS) |
| , m_wrapT(wrapT) |
| , m_format(format) |
| , m_width(width) |
| , m_height(height) |
| , m_numLayers(numLayers) |
| , m_compareFunc(compareFunc) |
| , m_gradientTex(DE_NULL) |
| , m_gridTex(DE_NULL) |
| , m_renderer(context.getRenderContext(), context.getTestContext().getLog(), glu::GLSL_VERSION_300_ES, |
| glu::PRECISION_HIGHP) |
| , m_caseNdx(0) |
| { |
| } |
| |
| Texture2DArrayShadowCase::~Texture2DArrayShadowCase(void) |
| { |
| Texture2DArrayShadowCase::deinit(); |
| } |
| |
| void Texture2DArrayShadowCase::init(void) |
| { |
| try |
| { |
| tcu::TextureFormat texFmt = glu::mapGLInternalFormat(m_format); |
| tcu::TextureFormatInfo fmtInfo = tcu::getTextureFormatInfo(texFmt); |
| tcu::Vec4 cScale = fmtInfo.valueMax - fmtInfo.valueMin; |
| tcu::Vec4 cBias = fmtInfo.valueMin; |
| int numLevels = deLog2Floor32(de::max(m_width, m_height)) + 1; |
| |
| // Create textures. |
| m_gradientTex = new glu::Texture2DArray(m_context.getRenderContext(), m_format, m_width, m_height, m_numLayers); |
| m_gridTex = new glu::Texture2DArray(m_context.getRenderContext(), m_format, m_width, m_height, m_numLayers); |
| |
| // Fill first gradient texture. |
| for (int levelNdx = 0; levelNdx < numLevels; levelNdx++) |
| { |
| tcu::Vec4 gMin = tcu::Vec4(-0.5f, -0.5f, -0.5f, 2.0f) * cScale + cBias; |
| tcu::Vec4 gMax = tcu::Vec4(1.0f, 1.0f, 1.0f, 0.0f) * cScale + cBias; |
| |
| m_gradientTex->getRefTexture().allocLevel(levelNdx); |
| tcu::fillWithComponentGradients(m_gradientTex->getRefTexture().getLevel(levelNdx), gMin, gMax); |
| } |
| |
| // Fill second with grid texture. |
| for (int levelNdx = 0; levelNdx < numLevels; levelNdx++) |
| { |
| uint32_t step = 0x00ffffff / numLevels; |
| uint32_t rgb = step * levelNdx; |
| uint32_t colorA = 0xff000000 | rgb; |
| uint32_t colorB = 0xff000000 | ~rgb; |
| |
| m_gridTex->getRefTexture().allocLevel(levelNdx); |
| tcu::fillWithGrid(m_gridTex->getRefTexture().getLevel(levelNdx), 4, |
| tcu::RGBA(colorA).toVec() * cScale + cBias, tcu::RGBA(colorB).toVec() * cScale + cBias); |
| } |
| |
| // Upload. |
| m_gradientTex->upload(); |
| m_gridTex->upload(); |
| } |
| catch (...) |
| { |
| // Clean up to save memory. |
| Texture2DArrayShadowCase::deinit(); |
| throw; |
| } |
| |
| // Compute cases. |
| { |
| const float refInRangeUpper = (m_compareFunc == GL_EQUAL || m_compareFunc == GL_NOTEQUAL) ? 1.0f : 0.5f; |
| const float refInRangeLower = (m_compareFunc == GL_EQUAL || m_compareFunc == GL_NOTEQUAL) ? 0.0f : 0.5f; |
| const float refOutOfBoundsUpper = 1.1f; // !< lookup function should clamp values to [0, 1] range |
| const float refOutOfBoundsLower = -0.1f; |
| |
| const struct |
| { |
| int texNdx; |
| float ref; |
| float lodX; |
| float lodY; |
| float oX; |
| float oY; |
| } cases[] = { |
| {0, refInRangeUpper, 1.6f, 2.9f, -1.0f, -2.7f}, |
| {0, refInRangeLower, -2.0f, -1.35f, -0.2f, 0.7f}, |
| {1, refInRangeUpper, 0.14f, 0.275f, -1.5f, -1.1f}, |
| {1, refInRangeLower, -0.92f, -2.64f, 0.4f, -0.1f}, |
| {1, refOutOfBoundsUpper, -0.49f, -0.22f, 0.45f, 0.97f}, |
| {1, refOutOfBoundsLower, -0.85f, 0.75f, 0.25f, 0.61f}, |
| }; |
| |
| const float viewportW = (float)de::min<int>(TEX2D_VIEWPORT_WIDTH, m_context.getRenderTarget().getWidth()); |
| const float viewportH = (float)de::min<int>(TEX2D_VIEWPORT_HEIGHT, m_context.getRenderTarget().getHeight()); |
| |
| const float minLayer = -0.5f; |
| const float maxLayer = (float)m_numLayers; |
| |
| for (int caseNdx = 0; caseNdx < DE_LENGTH_OF_ARRAY(cases); caseNdx++) |
| { |
| const glu::Texture2DArray *tex = cases[caseNdx].texNdx > 0 ? m_gridTex : m_gradientTex; |
| const float ref = cases[caseNdx].ref; |
| const float lodX = cases[caseNdx].lodX; |
| const float lodY = cases[caseNdx].lodY; |
| const float oX = cases[caseNdx].oX; |
| const float oY = cases[caseNdx].oY; |
| const float sX = deFloatExp2(lodX) * viewportW / float(tex->getRefTexture().getWidth()); |
| const float sY = deFloatExp2(lodY) * viewportH / float(tex->getRefTexture().getHeight()); |
| |
| m_cases.push_back(FilterCase(tex, ref, tcu::Vec3(oX, oY, minLayer), tcu::Vec3(oX + sX, oY + sY, maxLayer))); |
| } |
| } |
| |
| m_caseNdx = 0; |
| m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); |
| } |
| |
| void Texture2DArrayShadowCase::deinit(void) |
| { |
| delete m_gradientTex; |
| delete m_gridTex; |
| |
| m_gradientTex = DE_NULL; |
| m_gridTex = DE_NULL; |
| |
| m_renderer.clear(); |
| m_cases.clear(); |
| } |
| |
| Texture2DArrayShadowCase::IterateResult Texture2DArrayShadowCase::iterate(void) |
| { |
| const glw::Functions &gl = m_context.getRenderContext().getFunctions(); |
| const RandomViewport viewport(m_context.getRenderTarget(), TEX2D_VIEWPORT_WIDTH, TEX2D_VIEWPORT_HEIGHT, |
| deStringHash(getName()) ^ deInt32Hash(m_caseNdx)); |
| const FilterCase &curCase = m_cases[m_caseNdx]; |
| const tcu::ScopedLogSection section(m_testCtx.getLog(), string("Test") + de::toString(m_caseNdx), |
| string("Test ") + de::toString(m_caseNdx)); |
| ReferenceParams sampleParams(TEXTURETYPE_2D_ARRAY); |
| tcu::Surface rendered(viewport.width, viewport.height); |
| |
| const float texCoord[] = { |
| curCase.minCoord.x(), curCase.minCoord.y(), curCase.minCoord.z(), |
| curCase.minCoord.x(), curCase.maxCoord.y(), (curCase.minCoord.z() + curCase.maxCoord.z()) / 2.0f, |
| curCase.maxCoord.x(), curCase.minCoord.y(), (curCase.minCoord.z() + curCase.maxCoord.z()) / 2.0f, |
| curCase.maxCoord.x(), curCase.maxCoord.y(), curCase.maxCoord.z()}; |
| |
| if (viewport.width < TEX2D_MIN_VIEWPORT_WIDTH || viewport.height < TEX2D_MIN_VIEWPORT_HEIGHT) |
| throw tcu::NotSupportedError("Too small render target", "", __FILE__, __LINE__); |
| |
| // Setup params for reference. |
| sampleParams.sampler = glu::mapGLSampler(m_wrapS, m_wrapT, m_minFilter, m_magFilter); |
| sampleParams.sampler.compare = glu::mapGLCompareFunc(m_compareFunc); |
| sampleParams.samplerType = SAMPLERTYPE_SHADOW; |
| sampleParams.lodMode = LODMODE_EXACT; |
| sampleParams.ref = curCase.ref; |
| |
| m_testCtx.getLog() << TestLog::Message << "Compare reference value = " << sampleParams.ref << "\n" |
| << "Texture coordinates: " << curCase.minCoord << " -> " << curCase.maxCoord |
| << TestLog::EndMessage; |
| |
| gl.bindTexture(GL_TEXTURE_2D_ARRAY, curCase.texture->getGLTexture()); |
| gl.texParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MIN_FILTER, m_minFilter); |
| gl.texParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MAG_FILTER, m_magFilter); |
| gl.texParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_WRAP_S, m_wrapS); |
| gl.texParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_WRAP_T, m_wrapT); |
| gl.texParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_COMPARE_MODE, GL_COMPARE_REF_TO_TEXTURE); |
| gl.texParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_COMPARE_FUNC, m_compareFunc); |
| |
| gl.viewport(viewport.x, viewport.y, viewport.width, viewport.height); |
| m_renderer.renderQuad(0, &texCoord[0], sampleParams); |
| glu::readPixels(m_context.getRenderContext(), viewport.x, viewport.y, rendered.getAccess()); |
| |
| { |
| const tcu::PixelFormat pixelFormat = m_context.getRenderTarget().getPixelFormat(); |
| tcu::LodPrecision lodPrecision; |
| tcu::TexComparePrecision texComparePrecision; |
| |
| lodPrecision.derivateBits = 18; |
| lodPrecision.lodBits = 6; |
| texComparePrecision.coordBits = tcu::IVec3(20, 20, 20); |
| texComparePrecision.uvwBits = tcu::IVec3(7, 7, 7); |
| texComparePrecision.pcfBits = 5; |
| texComparePrecision.referenceBits = 16; |
| texComparePrecision.resultBits = pixelFormat.redBits - 1; |
| |
| const bool isHighQuality = |
| verifyTexCompareResult(m_testCtx, rendered.getAccess(), curCase.texture->getRefTexture(), &texCoord[0], |
| sampleParams, texComparePrecision, lodPrecision, pixelFormat); |
| |
| if (!isHighQuality) |
| { |
| m_testCtx.getLog() << TestLog::Message |
| << "Warning: Verification assuming high-quality PCF filtering failed." |
| << TestLog::EndMessage; |
| |
| lodPrecision.lodBits = 4; |
| texComparePrecision.uvwBits = tcu::IVec3(4, 4, 4); |
| texComparePrecision.pcfBits = 0; |
| |
| const bool isOk = |
| verifyTexCompareResult(m_testCtx, rendered.getAccess(), curCase.texture->getRefTexture(), &texCoord[0], |
| sampleParams, texComparePrecision, lodPrecision, pixelFormat); |
| |
| if (!isOk) |
| { |
| m_testCtx.getLog() |
| << TestLog::Message |
| << "ERROR: Verification against low precision requirements failed, failing test case." |
| << TestLog::EndMessage; |
| m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Image verification failed"); |
| } |
| else if (m_testCtx.getTestResult() == QP_TEST_RESULT_PASS) |
| m_testCtx.setTestResult(QP_TEST_RESULT_QUALITY_WARNING, "Low-quality result"); |
| } |
| } |
| |
| m_caseNdx += 1; |
| return m_caseNdx < (int)m_cases.size() ? CONTINUE : STOP; |
| } |
| |
| TextureShadowTests::TextureShadowTests(Context &context) |
| : TestCaseGroup(context, "shadow", "Shadow texture lookup tests") |
| { |
| } |
| |
| TextureShadowTests::~TextureShadowTests(void) |
| { |
| } |
| |
| void TextureShadowTests::init(void) |
| { |
| static const struct |
| { |
| const char *name; |
| uint32_t format; |
| } formats[] = {{"depth_component16", GL_DEPTH_COMPONENT16}, |
| {"depth_component32f", GL_DEPTH_COMPONENT32F}, |
| {"depth24_stencil8", GL_DEPTH24_STENCIL8}}; |
| |
| static const struct |
| { |
| const char *name; |
| uint32_t minFilter; |
| uint32_t magFilter; |
| } filters[] = {{"nearest", GL_NEAREST, GL_NEAREST}, |
| {"linear", GL_LINEAR, GL_LINEAR}, |
| {"nearest_mipmap_nearest", GL_NEAREST_MIPMAP_NEAREST, GL_LINEAR}, |
| {"linear_mipmap_nearest", GL_LINEAR_MIPMAP_NEAREST, GL_LINEAR}, |
| {"nearest_mipmap_linear", GL_NEAREST_MIPMAP_LINEAR, GL_LINEAR}, |
| {"linear_mipmap_linear", GL_LINEAR_MIPMAP_LINEAR, GL_LINEAR}}; |
| |
| static const struct |
| { |
| const char *name; |
| uint32_t func; |
| } compareFuncs[] = { |
| {"less_or_equal", GL_LEQUAL}, {"greater_or_equal", GL_GEQUAL}, {"less", GL_LESS}, {"greater", GL_GREATER}, |
| {"equal", GL_EQUAL}, {"not_equal", GL_NOTEQUAL}, {"always", GL_ALWAYS}, {"never", GL_NEVER}}; |
| |
| // 2D cases. |
| { |
| tcu::TestCaseGroup *group2D = new tcu::TestCaseGroup(m_testCtx, "2d", "2D texture shadow lookup tests"); |
| addChild(group2D); |
| |
| for (int filterNdx = 0; filterNdx < DE_LENGTH_OF_ARRAY(filters); filterNdx++) |
| { |
| tcu::TestCaseGroup *filterGroup = new tcu::TestCaseGroup(m_testCtx, filters[filterNdx].name, ""); |
| group2D->addChild(filterGroup); |
| |
| for (int compareNdx = 0; compareNdx < DE_LENGTH_OF_ARRAY(compareFuncs); compareNdx++) |
| { |
| for (int formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(formats); formatNdx++) |
| { |
| uint32_t minFilter = filters[filterNdx].minFilter; |
| uint32_t magFilter = filters[filterNdx].magFilter; |
| uint32_t format = formats[formatNdx].format; |
| uint32_t compareFunc = compareFuncs[compareNdx].func; |
| const uint32_t wrapS = GL_REPEAT; |
| const uint32_t wrapT = GL_REPEAT; |
| const int width = 32; |
| const int height = 64; |
| string name = string(compareFuncs[compareNdx].name) + "_" + formats[formatNdx].name; |
| |
| filterGroup->addChild(new Texture2DShadowCase(m_context, name.c_str(), "", minFilter, magFilter, |
| wrapS, wrapT, format, width, height, compareFunc)); |
| } |
| } |
| } |
| } |
| |
| // Cubemap cases. |
| { |
| tcu::TestCaseGroup *groupCube = |
| new tcu::TestCaseGroup(m_testCtx, "cube", "Cube map texture shadow lookup tests"); |
| addChild(groupCube); |
| |
| for (int filterNdx = 0; filterNdx < DE_LENGTH_OF_ARRAY(filters); filterNdx++) |
| { |
| tcu::TestCaseGroup *filterGroup = new tcu::TestCaseGroup(m_testCtx, filters[filterNdx].name, ""); |
| groupCube->addChild(filterGroup); |
| |
| for (int compareNdx = 0; compareNdx < DE_LENGTH_OF_ARRAY(compareFuncs); compareNdx++) |
| { |
| for (int formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(formats); formatNdx++) |
| { |
| uint32_t minFilter = filters[filterNdx].minFilter; |
| uint32_t magFilter = filters[filterNdx].magFilter; |
| uint32_t format = formats[formatNdx].format; |
| uint32_t compareFunc = compareFuncs[compareNdx].func; |
| const uint32_t wrapS = GL_REPEAT; |
| const uint32_t wrapT = GL_REPEAT; |
| const int size = 32; |
| string name = string(compareFuncs[compareNdx].name) + "_" + formats[formatNdx].name; |
| |
| filterGroup->addChild(new TextureCubeShadowCase(m_context, name.c_str(), "", minFilter, magFilter, |
| wrapS, wrapT, format, size, compareFunc)); |
| } |
| } |
| } |
| } |
| |
| // 2D array cases. |
| { |
| tcu::TestCaseGroup *group2DArray = |
| new tcu::TestCaseGroup(m_testCtx, "2d_array", "2D texture array shadow lookup tests"); |
| addChild(group2DArray); |
| |
| for (int filterNdx = 0; filterNdx < DE_LENGTH_OF_ARRAY(filters); filterNdx++) |
| { |
| tcu::TestCaseGroup *filterGroup = new tcu::TestCaseGroup(m_testCtx, filters[filterNdx].name, ""); |
| group2DArray->addChild(filterGroup); |
| |
| for (int compareNdx = 0; compareNdx < DE_LENGTH_OF_ARRAY(compareFuncs); compareNdx++) |
| { |
| for (int formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(formats); formatNdx++) |
| { |
| uint32_t minFilter = filters[filterNdx].minFilter; |
| uint32_t magFilter = filters[filterNdx].magFilter; |
| uint32_t format = formats[formatNdx].format; |
| uint32_t compareFunc = compareFuncs[compareNdx].func; |
| const uint32_t wrapS = GL_REPEAT; |
| const uint32_t wrapT = GL_REPEAT; |
| const int width = 32; |
| const int height = 64; |
| const int numLayers = 8; |
| string name = string(compareFuncs[compareNdx].name) + "_" + formats[formatNdx].name; |
| |
| filterGroup->addChild(new Texture2DArrayShadowCase(m_context, name.c_str(), "", minFilter, |
| magFilter, wrapS, wrapT, format, width, height, |
| numLayers, compareFunc)); |
| } |
| } |
| } |
| } |
| } |
| |
| } // namespace Functional |
| } // namespace gles3 |
| } // namespace deqp |
