| /*------------------------------------------------------------------------- |
| * 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 Texture wrap mode tests. |
| *//*--------------------------------------------------------------------*/ |
| |
| #include "es3fTextureWrapTests.hpp" |
| #include "glsTextureTestUtil.hpp" |
| #include "gluTexture.hpp" |
| #include "gluStrUtil.hpp" |
| #include "gluTextureUtil.hpp" |
| #include "gluPixelTransfer.hpp" |
| #include "tcuTestLog.hpp" |
| #include "tcuTextureUtil.hpp" |
| #include "tcuCompressedTexture.hpp" |
| #include "tcuVectorUtil.hpp" |
| #include "tcuTexLookupVerifier.hpp" |
| #include "deRandom.hpp" |
| #include "deStringUtil.hpp" |
| #include "deMemory.h" |
| |
| #include "glwEnums.hpp" |
| #include "glwFunctions.hpp" |
| |
| namespace deqp |
| { |
| namespace gles3 |
| { |
| namespace Functional |
| { |
| |
| using std::string; |
| using std::vector; |
| using tcu::CompressedTexFormat; |
| using tcu::CompressedTexture; |
| using tcu::Sampler; |
| using tcu::TestLog; |
| using namespace glu; |
| using namespace gls::TextureTestUtil; |
| using namespace glu::TextureTestUtil; |
| |
| //! Checks whether any ASTC version (LDR, HDR, full) is supported. |
| static inline bool isASTCSupported(const glu::ContextInfo &contextInfo) |
| { |
| const vector<string> &extensions = contextInfo.getExtensions(); |
| |
| for (int extNdx = 0; extNdx < (int)extensions.size(); extNdx++) |
| { |
| const string &ext = extensions[extNdx]; |
| |
| if (ext == "GL_KHR_texture_compression_astc_ldr" || ext == "GL_KHR_texture_compression_astc_hdr" || |
| ext == "GL_OES_texture_compression_astc") |
| return true; |
| } |
| |
| return false; |
| } |
| |
| enum |
| { |
| VIEWPORT_WIDTH = 256, |
| VIEWPORT_HEIGHT = 256 |
| }; |
| |
| class TextureWrapCase : public tcu::TestCase |
| { |
| public: |
| TextureWrapCase(tcu::TestContext &testCtx, glu::RenderContext &renderCtx, const glu::ContextInfo &ctxInfo, |
| const char *name, const char *description, uint32_t format, uint32_t dataType, uint32_t wrapS, |
| uint32_t wrapT, uint32_t minFilter, uint32_t magFilter, int width, int height, |
| bool enableRelaxedRef = false); |
| TextureWrapCase(tcu::TestContext &testCtx, glu::RenderContext &renderCtx, const glu::ContextInfo &ctxInfo, |
| const char *name, const char *description, uint32_t wrapS, uint32_t wrapT, uint32_t minFilter, |
| uint32_t magFilter, const std::vector<std::string> &filenames, bool enableRelaxedRef = false); |
| TextureWrapCase(tcu::TestContext &testCtx, glu::RenderContext &renderCtx, const glu::ContextInfo &ctxInfo, |
| const char *name, const char *description, CompressedTexFormat compressedFormat, uint32_t wrapS, |
| uint32_t wrapT, uint32_t minFilter, uint32_t magFilter, int width, int height, |
| bool enableRelaxedRef = false); |
| ~TextureWrapCase(void); |
| |
| void init(void); |
| void deinit(void); |
| IterateResult iterate(void); |
| |
| private: |
| TextureWrapCase(const TextureWrapCase &other); |
| TextureWrapCase &operator=(const TextureWrapCase &other); |
| |
| struct Case |
| { |
| tcu::Vec2 bottomLeft; |
| tcu::Vec2 topRight; |
| |
| Case(void) |
| { |
| } |
| Case(const tcu::Vec2 &bl, const tcu::Vec2 &tr) : bottomLeft(bl), topRight(tr) |
| { |
| } |
| }; |
| |
| glu::RenderContext &m_renderCtx; |
| const glu::ContextInfo &m_renderCtxInfo; |
| |
| const uint32_t m_format; |
| const uint32_t m_dataType; |
| const CompressedTexFormat m_compressedFormat; |
| const uint32_t m_wrapS; |
| const uint32_t m_wrapT; |
| const uint32_t m_minFilter; |
| const uint32_t m_magFilter; |
| |
| int m_width; |
| int m_height; |
| const std::vector<std::string> m_filenames; |
| |
| vector<Case> m_cases; |
| int m_caseNdx; |
| |
| glu::Texture2D *m_texture; |
| TextureRenderer m_renderer; |
| |
| bool m_enableRelaxedRef; |
| }; |
| |
| TextureWrapCase::TextureWrapCase(tcu::TestContext &testCtx, glu::RenderContext &renderCtx, |
| const glu::ContextInfo &ctxInfo, const char *name, const char *description, |
| uint32_t format, uint32_t dataType, uint32_t wrapS, uint32_t wrapT, uint32_t minFilter, |
| uint32_t magFilter, int width, int height, bool enableRelaxedRef) |
| : TestCase(testCtx, name, description) |
| , m_renderCtx(renderCtx) |
| , m_renderCtxInfo(ctxInfo) |
| , m_format(format) |
| , m_dataType(dataType) |
| , m_compressedFormat(tcu::COMPRESSEDTEXFORMAT_LAST) |
| , m_wrapS(wrapS) |
| , m_wrapT(wrapT) |
| , m_minFilter(minFilter) |
| , m_magFilter(magFilter) |
| , m_width(width) |
| , m_height(height) |
| , m_caseNdx(0) |
| , m_texture(DE_NULL) |
| , m_renderer(renderCtx, testCtx.getLog(), glu::GLSL_VERSION_300_ES, glu::PRECISION_MEDIUMP) |
| , m_enableRelaxedRef(enableRelaxedRef) |
| { |
| } |
| |
| TextureWrapCase::TextureWrapCase(tcu::TestContext &testCtx, glu::RenderContext &renderCtx, |
| const glu::ContextInfo &ctxInfo, const char *name, const char *description, |
| uint32_t wrapS, uint32_t wrapT, uint32_t minFilter, uint32_t magFilter, |
| const std::vector<std::string> &filenames, bool enableRelaxedRef) |
| : TestCase(testCtx, name, description) |
| , m_renderCtx(renderCtx) |
| , m_renderCtxInfo(ctxInfo) |
| , m_format(GL_NONE) |
| , m_dataType(GL_NONE) |
| , m_compressedFormat(tcu::COMPRESSEDTEXFORMAT_LAST) |
| , m_wrapS(wrapS) |
| , m_wrapT(wrapT) |
| , m_minFilter(minFilter) |
| , m_magFilter(magFilter) |
| , m_width(0) |
| , m_height(0) |
| , m_filenames(filenames) |
| , m_caseNdx(0) |
| , m_texture(DE_NULL) |
| , m_renderer(renderCtx, testCtx.getLog(), glu::GLSL_VERSION_300_ES, glu::PRECISION_MEDIUMP) |
| , m_enableRelaxedRef(enableRelaxedRef) |
| { |
| } |
| |
| TextureWrapCase::TextureWrapCase(tcu::TestContext &testCtx, glu::RenderContext &renderCtx, |
| const glu::ContextInfo &ctxInfo, const char *name, const char *description, |
| CompressedTexFormat compressedFormat, uint32_t wrapS, uint32_t wrapT, |
| uint32_t minFilter, uint32_t magFilter, int width, int height, bool enableRelaxedRef) |
| : TestCase(testCtx, name, description) |
| , m_renderCtx(renderCtx) |
| , m_renderCtxInfo(ctxInfo) |
| , m_format(GL_NONE) |
| , m_dataType(GL_NONE) |
| , m_compressedFormat(compressedFormat) |
| , m_wrapS(wrapS) |
| , m_wrapT(wrapT) |
| , m_minFilter(minFilter) |
| , m_magFilter(magFilter) |
| , m_width(width) |
| , m_height(height) |
| , m_caseNdx(0) |
| , m_texture(DE_NULL) |
| , m_renderer(renderCtx, testCtx.getLog(), glu::GLSL_VERSION_300_ES, glu::PRECISION_MEDIUMP) |
| , m_enableRelaxedRef(enableRelaxedRef) |
| { |
| } |
| |
| TextureWrapCase::~TextureWrapCase(void) |
| { |
| deinit(); |
| } |
| |
| void TextureWrapCase::init(void) |
| { |
| // Load or generate texture. |
| |
| if (!m_filenames.empty()) |
| { |
| // Load compressed texture from file. |
| |
| DE_ASSERT(m_width == 0 && m_height == 0 && m_format == GL_NONE && m_dataType == GL_NONE); |
| |
| m_texture = glu::Texture2D::create(m_renderCtx, m_renderCtxInfo, m_testCtx.getArchive(), |
| (int)m_filenames.size(), m_filenames); |
| m_width = m_texture->getRefTexture().getWidth(); |
| m_height = m_texture->getRefTexture().getHeight(); |
| } |
| else if (m_compressedFormat != tcu::COMPRESSEDTEXFORMAT_LAST) |
| { |
| // Generate compressed texture. |
| |
| DE_ASSERT(m_format == GL_NONE && m_dataType == GL_NONE); |
| |
| if (tcu::isEtcFormat(m_compressedFormat)) |
| { |
| // Create ETC texture. Any content is valid. |
| |
| tcu::CompressedTexture compressedTexture(m_compressedFormat, m_width, m_height); |
| const int dataSize = compressedTexture.getDataSize(); |
| uint8_t *const data = (uint8_t *)compressedTexture.getData(); |
| de::Random rnd(deStringHash(getName())); |
| |
| for (int i = 0; i < dataSize; i++) |
| data[i] = rnd.getUint32() & 0xff; |
| |
| m_texture = new glu::Texture2D(m_renderCtx, m_renderCtxInfo, 1, &compressedTexture); |
| } |
| else if (tcu::isAstcFormat(m_compressedFormat)) |
| { |
| // Create ASTC texture by picking from a set of pre-generated blocks. |
| |
| static const int BLOCK_SIZE = 16; |
| static const uint8_t blocks[][BLOCK_SIZE] = { |
| // \note All of the following blocks are valid in LDR mode. |
| { |
| 252, |
| 253, |
| 255, |
| 255, |
| 255, |
| 255, |
| 255, |
| 255, |
| 8, |
| 71, |
| 90, |
| 78, |
| 22, |
| 17, |
| 26, |
| 66, |
| }, |
| {252, 253, 255, 255, 255, 255, 255, 255, 220, 74, 139, 235, 249, 6, 145, 125}, |
| {252, 253, 255, 255, 255, 255, 255, 255, 223, 251, 28, 206, 54, 251, 160, 174}, |
| {252, 253, 255, 255, 255, 255, 255, 255, 39, 4, 153, 219, 180, 61, 51, 37}, |
| {67, 2, 0, 254, 1, 0, 64, 215, 83, 211, 159, 105, 41, 140, 50, 2}, |
| {67, 130, 0, 170, 84, 255, 65, 215, 83, 211, 159, 105, 41, 140, 50, 2}, |
| {67, 2, 129, 38, 51, 229, 95, 215, 83, 211, 159, 105, 41, 140, 50, 2}, |
| {67, 130, 193, 56, 213, 144, 95, 215, 83, 211, 159, 105, 41, 140, 50, 2}}; |
| |
| if (!isASTCSupported( |
| m_renderCtxInfo)) // \note Any level of ASTC support is enough, since we're only using LDR blocks. |
| throw tcu::NotSupportedError("ASTC not supported"); |
| |
| tcu::CompressedTexture compressedTexture(m_compressedFormat, m_width, m_height); |
| const int dataSize = compressedTexture.getDataSize(); |
| uint8_t *const data = (uint8_t *)compressedTexture.getData(); |
| de::Random rnd(deStringHash(getName())); |
| DE_ASSERT(dataSize % BLOCK_SIZE == 0); |
| |
| for (int i = 0; i < dataSize / BLOCK_SIZE; i++) |
| deMemcpy(&data[i * BLOCK_SIZE], &blocks[rnd.getInt(0, DE_LENGTH_OF_ARRAY(blocks) - 1)][0], BLOCK_SIZE); |
| |
| // \note All blocks are valid LDR blocks so ASTCMODE_* doesn't change anything |
| m_texture = new glu::Texture2D(m_renderCtx, m_renderCtxInfo, 1, &compressedTexture, |
| tcu::TexDecompressionParams(tcu::TexDecompressionParams::ASTCMODE_LDR)); |
| } |
| else |
| DE_ASSERT(false); |
| } |
| else |
| { |
| m_texture = new Texture2D(m_renderCtx, m_format, m_dataType, m_width, m_height); |
| |
| // Fill level 0. |
| m_texture->getRefTexture().allocLevel(0); |
| if (m_wrapS == GL_REPEAT || m_wrapT == GL_REPEAT) |
| { |
| // If run in repeat mode, use conical style texture to avoid edge sample result have a huge difference when coordinate offset in allow range. |
| tcu::fillWithComponentGradients3(m_texture->getRefTexture().getLevel(0), |
| tcu::Vec4(-0.5f, -0.5f, -0.5f, 1.5f), tcu::Vec4(1.0f, 1.0f, 1.0f, 0.0f)); |
| } |
| else |
| { |
| tcu::fillWithComponentGradients(m_texture->getRefTexture().getLevel(0), |
| tcu::Vec4(-0.5f, -0.5f, -0.5f, 1.5f), tcu::Vec4(1.0f, 1.0f, 1.0f, 0.0f)); |
| } |
| |
| m_texture->upload(); |
| } |
| |
| // Sub-cases. |
| |
| m_cases.push_back(Case(tcu::Vec2(-1.5f, -3.0f), tcu::Vec2(1.5f, 2.5f))); |
| m_cases.push_back(Case(tcu::Vec2(-0.5f, 0.75f), tcu::Vec2(0.25f, 1.25f))); |
| DE_ASSERT(m_caseNdx == 0); |
| |
| // Initialize to success, set to failure later if needed. |
| |
| m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); |
| } |
| |
| void TextureWrapCase::deinit(void) |
| { |
| delete m_texture; |
| m_texture = DE_NULL; |
| |
| m_renderer.clear(); |
| } |
| |
| TextureWrapCase::IterateResult TextureWrapCase::iterate(void) |
| { |
| const glw::Functions &gl = m_renderCtx.getFunctions(); |
| TestLog &log = m_testCtx.getLog(); |
| const RandomViewport viewport(m_renderCtx.getRenderTarget(), VIEWPORT_WIDTH, VIEWPORT_HEIGHT, |
| deStringHash(getName()) + m_caseNdx); |
| tcu::Surface renderedFrame(viewport.width, viewport.height); |
| ReferenceParams refParams(TEXTURETYPE_2D); |
| const tcu::TextureFormat texFormat = m_texture->getRefTexture().getFormat(); |
| vector<float> texCoord; |
| const tcu::TextureFormatInfo texFormatInfo = tcu::getTextureFormatInfo(texFormat); |
| // \note For non-sRGB ASTC formats, the values are fp16 in range [0..1], not the range assumed given by tcu::getTextureFormatInfo(). |
| const bool useDefaultColorScaleAndBias = |
| !tcu::isAstcFormat(m_compressedFormat) || tcu::isAstcSRGBFormat(m_compressedFormat); |
| |
| // Bind to unit 0. |
| gl.activeTexture(GL_TEXTURE0); |
| gl.bindTexture(GL_TEXTURE_2D, m_texture->getGLTexture()); |
| |
| // Setup filtering and wrap modes. |
| 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_MIN_FILTER, m_minFilter); |
| gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, m_magFilter); |
| |
| GLU_EXPECT_NO_ERROR(gl.getError(), "Set texturing state"); |
| |
| // Parameters for reference images. |
| refParams.sampler = mapGLSampler(m_wrapS, m_wrapT, m_minFilter, m_magFilter); |
| refParams.lodMode = LODMODE_EXACT; |
| refParams.samplerType = getSamplerType(m_texture->getRefTexture().getFormat()); |
| refParams.colorScale = useDefaultColorScaleAndBias ? texFormatInfo.lookupScale : tcu::Vec4(1.0f); |
| refParams.colorBias = useDefaultColorScaleAndBias ? texFormatInfo.lookupBias : tcu::Vec4(0.0f); |
| |
| gl.viewport(viewport.x, viewport.y, viewport.width, viewport.height); |
| computeQuadTexCoord2D(texCoord, m_cases[m_caseNdx].bottomLeft, m_cases[m_caseNdx].topRight); |
| m_renderer.renderQuad(0, &texCoord[0], refParams); |
| glu::readPixels(m_renderCtx, viewport.x, viewport.y, renderedFrame.getAccess()); |
| |
| { |
| const tcu::ScopedLogSection section(log, string("Test") + de::toString(m_caseNdx), |
| string("Test ") + de::toString(m_caseNdx)); |
| const bool isNearestOnly = m_minFilter == GL_NEAREST && m_magFilter == GL_NEAREST; |
| 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::LookupPrecision lookupPrecision; |
| |
| lodPrecision.derivateBits = 18; |
| lodPrecision.lodBits = 5; |
| lookupPrecision.colorThreshold = |
| tcu::computeColorBitsThreshold(getBitsVec(pixelFormat), colorBits) / refParams.colorScale; |
| lookupPrecision.coordBits = tcu::IVec3(20, 20, 0); |
| lookupPrecision.uvwBits = tcu::IVec3(5, 5, 0); |
| lookupPrecision.colorMask = getCompareMask(pixelFormat); |
| |
| log << TestLog::Message << "Note: lookup coordinates: bottom-left " << m_cases[m_caseNdx].bottomLeft |
| << ", top-right " << m_cases[m_caseNdx].topRight << TestLog::EndMessage; |
| |
| bool isOk = verifyTextureResult(m_testCtx, renderedFrame.getAccess(), m_texture->getRefTexture(), &texCoord[0], |
| refParams, lookupPrecision, lodPrecision, pixelFormat); |
| |
| if ((isOk == false) && m_enableRelaxedRef && m_renderer.getTexCoordPrecision() != PRECISION_HIGHP) |
| { |
| refParams.float16TexCoord = true; |
| isOk |= verifyTextureResult(m_testCtx, renderedFrame.getAccess(), m_texture->getRefTexture(), &texCoord[0], |
| refParams, lookupPrecision, lodPrecision, pixelFormat); |
| } |
| |
| if (!isOk) |
| m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Image verification failed"); |
| } |
| |
| m_caseNdx++; |
| return m_caseNdx < (int)m_cases.size() ? CONTINUE : STOP; |
| } |
| |
| TextureWrapTests::TextureWrapTests(Context &context) : TestCaseGroup(context, "wrap", "Wrap Mode Tests") |
| { |
| } |
| |
| TextureWrapTests::~TextureWrapTests(void) |
| { |
| } |
| |
| void TextureWrapTests::init(void) |
| { |
| static const struct |
| { |
| const char *name; |
| uint32_t mode; |
| } wrapModes[] = {{"clamp", GL_CLAMP_TO_EDGE}, {"repeat", GL_REPEAT}, {"mirror", GL_MIRRORED_REPEAT}}; |
| |
| static const struct |
| { |
| const char *name; |
| uint32_t mode; |
| } filteringModes[] = {{"nearest", GL_NEAREST}, {"linear", GL_LINEAR}}; |
| |
| #define FOR_EACH(ITERATOR, ARRAY, BODY) \ |
| for (int ITERATOR = 0; ITERATOR < DE_LENGTH_OF_ARRAY(ARRAY); ITERATOR++) \ |
| BODY |
| |
| // RGBA8 cases. |
| { |
| static const struct |
| { |
| const char *name; |
| int width; |
| int height; |
| } rgba8Sizes[] = {{"pot", 64, 128}, {"npot", 63, 112}}; |
| |
| { |
| TestCaseGroup *const rgba8Group = new TestCaseGroup(m_context, "rgba8", ""); |
| addChild(rgba8Group); |
| |
| FOR_EACH(size, rgba8Sizes, |
| FOR_EACH(wrapS, wrapModes, |
| FOR_EACH(wrapT, wrapModes, FOR_EACH(filter, filteringModes, { |
| const string name = |
| string("") + wrapModes[wrapS].name + "_" + wrapModes[wrapT].name + "_" + |
| filteringModes[filter].name + "_" + rgba8Sizes[size].name; |
| rgba8Group->addChild(new TextureWrapCase( |
| m_testCtx, m_context.getRenderContext(), m_context.getContextInfo(), |
| name.c_str(), "", GL_RGBA, GL_UNSIGNED_BYTE, wrapModes[wrapS].mode, |
| wrapModes[wrapT].mode, filteringModes[filter].mode, |
| filteringModes[filter].mode, rgba8Sizes[size].width, |
| rgba8Sizes[size].height)); |
| })))) |
| } |
| } |
| |
| // ETC1 cases. |
| { |
| TestCaseGroup *const etc1Group = new TestCaseGroup(m_context, "etc1", ""); |
| addChild(etc1Group); |
| |
| // Power-of-two ETC1 texture |
| std::vector<std::string> potFilenames; |
| potFilenames.push_back("data/etc1/photo_helsinki_mip_0.pkm"); |
| |
| FOR_EACH(wrapS, wrapModes, |
| FOR_EACH(wrapT, wrapModes, FOR_EACH(filter, filteringModes, { |
| const string name = string("") + wrapModes[wrapS].name + "_" + wrapModes[wrapT].name + |
| "_" + filteringModes[filter].name + "_pot"; |
| |
| bool enableRelaxedPrecisionRef = wrapModes[wrapS].mode == GL_REPEAT || |
| wrapModes[wrapT].mode == GL_REPEAT || |
| wrapModes[wrapS].mode == GL_MIRRORED_REPEAT || |
| wrapModes[wrapT].mode == GL_MIRRORED_REPEAT; |
| |
| etc1Group->addChild(new TextureWrapCase( |
| m_testCtx, m_context.getRenderContext(), m_context.getContextInfo(), name.c_str(), "", |
| wrapModes[wrapS].mode, wrapModes[wrapT].mode, filteringModes[filter].mode, |
| filteringModes[filter].mode, potFilenames, enableRelaxedPrecisionRef)); |
| }))) |
| |
| std::vector<std::string> npotFilenames; |
| npotFilenames.push_back("data/etc1/photo_helsinki_113x89.pkm"); |
| |
| // NPOT ETC1 texture |
| FOR_EACH(wrapS, wrapModes, |
| FOR_EACH(wrapT, wrapModes, FOR_EACH(filter, filteringModes, { |
| const string name = string("") + wrapModes[wrapS].name + "_" + wrapModes[wrapT].name + |
| "_" + filteringModes[filter].name + "_npot"; |
| |
| bool enableRelaxedPrecisionRef = wrapModes[wrapS].mode == GL_REPEAT || |
| wrapModes[wrapT].mode == GL_REPEAT || |
| wrapModes[wrapS].mode == GL_MIRRORED_REPEAT || |
| wrapModes[wrapT].mode == GL_MIRRORED_REPEAT; |
| |
| etc1Group->addChild(new TextureWrapCase( |
| m_testCtx, m_context.getRenderContext(), m_context.getContextInfo(), name.c_str(), "", |
| wrapModes[wrapS].mode, wrapModes[wrapT].mode, filteringModes[filter].mode, |
| filteringModes[filter].mode, npotFilenames, enableRelaxedPrecisionRef)); |
| }))) |
| } |
| |
| // ETC-2 (and EAC) cases. |
| { |
| static const struct |
| { |
| const char *name; |
| CompressedTexFormat format; |
| } etc2Formats[] = {{ |
| "eac_r11", |
| tcu::COMPRESSEDTEXFORMAT_EAC_R11, |
| }, |
| { |
| "eac_signed_r11", |
| tcu::COMPRESSEDTEXFORMAT_EAC_SIGNED_R11, |
| }, |
| { |
| "eac_rg11", |
| tcu::COMPRESSEDTEXFORMAT_EAC_RG11, |
| }, |
| { |
| "eac_signed_rg11", |
| tcu::COMPRESSEDTEXFORMAT_EAC_SIGNED_RG11, |
| }, |
| { |
| "etc2_rgb8", |
| tcu::COMPRESSEDTEXFORMAT_ETC2_RGB8, |
| }, |
| { |
| "etc2_srgb8", |
| tcu::COMPRESSEDTEXFORMAT_ETC2_SRGB8, |
| }, |
| { |
| "etc2_rgb8_punchthrough_alpha1", |
| tcu::COMPRESSEDTEXFORMAT_ETC2_RGB8_PUNCHTHROUGH_ALPHA1, |
| }, |
| { |
| "etc2_srgb8_punchthrough_alpha1", |
| tcu::COMPRESSEDTEXFORMAT_ETC2_SRGB8_PUNCHTHROUGH_ALPHA1, |
| }, |
| { |
| "etc2_eac_rgba8", |
| tcu::COMPRESSEDTEXFORMAT_ETC2_EAC_RGBA8, |
| }, |
| { |
| "etc2_eac_srgb8_alpha8", |
| tcu::COMPRESSEDTEXFORMAT_ETC2_EAC_SRGB8_ALPHA8, |
| }}; |
| |
| static const struct |
| { |
| const char *name; |
| int width; |
| int height; |
| } etc2Sizes[] = {{"pot", 64, 128}, {"npot", 123, 107}}; |
| |
| for (int formatNdx = 0; formatNdx < DE_LENGTH_OF_ARRAY(etc2Formats); formatNdx++) |
| { |
| TestCaseGroup *const formatGroup = new TestCaseGroup(m_context, etc2Formats[formatNdx].name, ""); |
| addChild(formatGroup); |
| |
| FOR_EACH(size, etc2Sizes, |
| FOR_EACH(wrapS, wrapModes, |
| FOR_EACH(wrapT, wrapModes, FOR_EACH(filter, filteringModes, { |
| const string name = string("") + wrapModes[wrapS].name + "_" + |
| wrapModes[wrapT].name + "_" + |
| filteringModes[filter].name + "_" + etc2Sizes[size].name; |
| |
| bool enableRelaxedPrecisionRef = |
| wrapModes[wrapS].mode == GL_REPEAT || |
| wrapModes[wrapT].mode == GL_REPEAT || |
| wrapModes[wrapS].mode == GL_MIRRORED_REPEAT || |
| wrapModes[wrapT].mode == GL_MIRRORED_REPEAT; |
| |
| formatGroup->addChild(new TextureWrapCase( |
| m_testCtx, m_context.getRenderContext(), m_context.getContextInfo(), |
| name.c_str(), "", etc2Formats[formatNdx].format, wrapModes[wrapS].mode, |
| wrapModes[wrapT].mode, filteringModes[filter].mode, |
| filteringModes[filter].mode, etc2Sizes[size].width, |
| etc2Sizes[size].height, enableRelaxedPrecisionRef)); |
| })))) |
| } |
| } |
| |
| // ASTC cases. |
| { |
| for (int formatI = 0; formatI < tcu::COMPRESSEDTEXFORMAT_LAST; formatI++) |
| { |
| const CompressedTexFormat format = (CompressedTexFormat)formatI; |
| |
| if (!tcu::isAstcFormat(format)) |
| continue; |
| |
| { |
| const tcu::IVec3 blockSize = tcu::getBlockPixelSize(format); |
| const string formatName = "astc_" + de::toString(blockSize.x()) + "x" + de::toString(blockSize.y()) + |
| (tcu::isAstcSRGBFormat(format) ? "_srgb" : ""); |
| TestCaseGroup *const formatGroup = new TestCaseGroup(m_context, formatName.c_str(), ""); |
| addChild(formatGroup); |
| |
| DE_ASSERT(blockSize.z() == 1); |
| |
| // \note This array is NOT static. |
| const struct |
| { |
| const char *name; |
| int width; |
| int height; |
| } formatSizes[] = { |
| {"divisible", blockSize.x() * 10, blockSize.y() * 10}, |
| {"not_divisible", blockSize.x() * 10 + 1, blockSize.y() * 10 + 1}, |
| }; |
| |
| FOR_EACH(size, formatSizes, |
| FOR_EACH(wrapS, wrapModes, |
| FOR_EACH(wrapT, wrapModes, FOR_EACH(filter, filteringModes, { |
| string name = string("") + wrapModes[wrapS].name + "_" + |
| wrapModes[wrapT].name + "_" + filteringModes[filter].name + |
| "_" + formatSizes[size].name; |
| |
| bool enableRelaxedPrecisionRef = |
| wrapModes[wrapS].mode == GL_REPEAT || |
| wrapModes[wrapT].mode == GL_REPEAT || |
| wrapModes[wrapS].mode == GL_MIRRORED_REPEAT || |
| wrapModes[wrapT].mode == GL_MIRRORED_REPEAT; |
| |
| formatGroup->addChild(new TextureWrapCase( |
| m_testCtx, m_context.getRenderContext(), m_context.getContextInfo(), |
| name.c_str(), "", format, wrapModes[wrapS].mode, |
| wrapModes[wrapT].mode, filteringModes[filter].mode, |
| filteringModes[filter].mode, formatSizes[size].width, |
| formatSizes[size].height, enableRelaxedPrecisionRef)); |
| })))) |
| } |
| } |
| } |
| } |
| |
| } // namespace Functional |
| } // namespace gles3 |
| } // namespace deqp |
