| /*------------------------------------------------------------------------- |
| * drawElements Quality Program OpenGL ES 3.1 Module |
| * ------------------------------------------------- |
| * |
| * Copyright 2015 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 Param State Query tests. |
| *//*--------------------------------------------------------------------*/ |
| |
| #include "es31fTextureStateQueryTests.hpp" |
| #include "glsTextureStateQueryTests.hpp" |
| #include "glsStateQueryUtil.hpp" |
| #include "glwEnums.hpp" |
| |
| namespace deqp |
| { |
| namespace gles31 |
| { |
| namespace Functional |
| { |
| |
| using namespace gls::StateQueryUtil; |
| using namespace gls::TextureStateQueryTests; |
| |
| static const char* getVerifierSuffix (QueryType type) |
| { |
| switch (type) |
| { |
| case QUERY_TEXTURE_PARAM_FLOAT: |
| case QUERY_TEXTURE_PARAM_FLOAT_VEC4: return "_float"; |
| |
| case QUERY_TEXTURE_PARAM_INTEGER: |
| case QUERY_TEXTURE_PARAM_INTEGER_VEC4: return "_integer"; |
| |
| case QUERY_TEXTURE_PARAM_PURE_INTEGER: |
| case QUERY_TEXTURE_PARAM_PURE_INTEGER_VEC4: return "_pure_int"; |
| |
| case QUERY_TEXTURE_PARAM_PURE_UNSIGNED_INTEGER: |
| case QUERY_TEXTURE_PARAM_PURE_UNSIGNED_INTEGER_VEC4: return "_pure_uint"; |
| |
| default: |
| DE_ASSERT(DE_FALSE); |
| return DE_NULL; |
| } |
| } |
| |
| static bool isIsVectorQuery (TesterType tester) |
| { |
| return tester == TESTER_TEXTURE_BORDER_COLOR; |
| } |
| |
| static bool isExtendedParamQuery (TesterType tester) |
| { |
| return tester == TESTER_TEXTURE_WRAP_S_CLAMP_TO_BORDER || |
| tester == TESTER_TEXTURE_WRAP_T_CLAMP_TO_BORDER || |
| tester == TESTER_TEXTURE_WRAP_R_CLAMP_TO_BORDER; |
| } |
| |
| TextureStateQueryTests::TextureStateQueryTests (Context& context) |
| : TestCaseGroup(context, "texture", "Texture State Query tests") |
| { |
| } |
| |
| TextureStateQueryTests::~TextureStateQueryTests (void) |
| { |
| } |
| |
| void TextureStateQueryTests::init (void) |
| { |
| static const QueryType scalarVerifiers[] = |
| { |
| QUERY_TEXTURE_PARAM_INTEGER, |
| QUERY_TEXTURE_PARAM_FLOAT, |
| QUERY_TEXTURE_PARAM_PURE_INTEGER, |
| QUERY_TEXTURE_PARAM_PURE_UNSIGNED_INTEGER, |
| }; |
| static const QueryType nonPureVerifiers[] = |
| { |
| QUERY_TEXTURE_PARAM_INTEGER, |
| QUERY_TEXTURE_PARAM_FLOAT, |
| }; |
| static const QueryType vec4Verifiers[] = |
| { |
| QUERY_TEXTURE_PARAM_INTEGER_VEC4, |
| QUERY_TEXTURE_PARAM_FLOAT_VEC4, |
| QUERY_TEXTURE_PARAM_PURE_INTEGER_VEC4, |
| QUERY_TEXTURE_PARAM_PURE_UNSIGNED_INTEGER_VEC4, |
| }; |
| |
| #define FOR_EACH_VERIFIER(VERIFIERS, X) \ |
| for (int verifierNdx = 0; verifierNdx < DE_LENGTH_OF_ARRAY(VERIFIERS); ++verifierNdx) \ |
| { \ |
| const char* verifierSuffix = getVerifierSuffix((VERIFIERS)[verifierNdx]); \ |
| const QueryType verifier = (VERIFIERS)[verifierNdx]; \ |
| targetGroup->addChild(X); \ |
| } |
| |
| static const struct |
| { |
| const char* name; |
| glw::GLenum target; |
| bool newInGLES31; |
| } textureTargets[] = |
| { |
| { "texture_2d", GL_TEXTURE_2D, false, }, |
| { "texture_3d", GL_TEXTURE_3D, false, }, |
| { "texture_2d_array", GL_TEXTURE_2D_ARRAY, false, }, |
| { "texture_cube_map", GL_TEXTURE_CUBE_MAP, false, }, |
| { "texture_2d_multisample", GL_TEXTURE_2D_MULTISAMPLE, true, }, |
| { "texture_2d_multisample_array", GL_TEXTURE_2D_MULTISAMPLE_ARRAY, true, }, // GL_OES_texture_storage_multisample_2d_array |
| { "texture_buffer", GL_TEXTURE_BUFFER, true, }, // GL_EXT_texture_buffer |
| { "texture_cube_array", GL_TEXTURE_CUBE_MAP_ARRAY, true, }, // GL_EXT_texture_cube_map_array |
| }; |
| static const struct |
| { |
| const char* name; |
| const char* desc; |
| TesterType tester; |
| bool newInGLES31; |
| } states[] = |
| { |
| { "texture_swizzle_r", "TEXTURE_SWIZZLE_R", TESTER_TEXTURE_SWIZZLE_R, false }, |
| { "texture_swizzle_g", "TEXTURE_SWIZZLE_G", TESTER_TEXTURE_SWIZZLE_G, false }, |
| { "texture_swizzle_b", "TEXTURE_SWIZZLE_B", TESTER_TEXTURE_SWIZZLE_B, false }, |
| { "texture_swizzle_a", "TEXTURE_SWIZZLE_A", TESTER_TEXTURE_SWIZZLE_A, false }, |
| { "texture_wrap_s", "TEXTURE_WRAP_S", TESTER_TEXTURE_WRAP_S, false }, |
| { "texture_wrap_t", "TEXTURE_WRAP_T", TESTER_TEXTURE_WRAP_T, false }, |
| { "texture_wrap_r", "TEXTURE_WRAP_R", TESTER_TEXTURE_WRAP_R, false }, |
| { "texture_mag_filter", "TEXTURE_MAG_FILTER", TESTER_TEXTURE_MAG_FILTER, false }, |
| { "texture_min_filter", "TEXTURE_MIN_FILTER", TESTER_TEXTURE_MIN_FILTER, false }, |
| { "texture_min_lod", "TEXTURE_MIN_LOD", TESTER_TEXTURE_MIN_LOD, false }, |
| { "texture_max_lod", "TEXTURE_MAX_LOD", TESTER_TEXTURE_MAX_LOD, false }, |
| { "texture_base_level", "TEXTURE_BASE_LEVEL", TESTER_TEXTURE_BASE_LEVEL, false }, |
| { "texture_max_level", "TEXTURE_MAX_LEVEL", TESTER_TEXTURE_MAX_LEVEL, false }, |
| { "texture_compare_mode", "TEXTURE_COMPARE_MODE", TESTER_TEXTURE_COMPARE_MODE, false }, |
| { "texture_compare_func", "TEXTURE_COMPARE_FUNC", TESTER_TEXTURE_COMPARE_FUNC, false }, |
| { "texture_immutable_levels", "TEXTURE_IMMUTABLE_LEVELS", TESTER_TEXTURE_IMMUTABLE_LEVELS, false }, |
| { "texture_immutable_format", "TEXTURE_IMMUTABLE_FORMAT", TESTER_TEXTURE_IMMUTABLE_FORMAT, false }, |
| { "depth_stencil_mode", "DEPTH_STENCIL_TEXTURE_MODE", TESTER_DEPTH_STENCIL_TEXTURE_MODE, true }, |
| { "texture_srgb_decode", "TEXTURE_SRGB_DECODE_EXT", TESTER_TEXTURE_SRGB_DECODE_EXT, true }, |
| { "texture_border_color", "TEXTURE_BORDER_COLOR", TESTER_TEXTURE_BORDER_COLOR, true }, |
| { "texture_wrap_s_clamp_to_border", "TEXTURE_WRAP_S_CLAMP_TO_BORDER", TESTER_TEXTURE_WRAP_S_CLAMP_TO_BORDER, true }, |
| { "texture_wrap_t_clamp_to_border", "TEXTURE_WRAP_T_CLAMP_TO_BORDER", TESTER_TEXTURE_WRAP_T_CLAMP_TO_BORDER, true }, |
| { "texture_wrap_r_clamp_to_border", "TEXTURE_WRAP_R_CLAMP_TO_BORDER", TESTER_TEXTURE_WRAP_R_CLAMP_TO_BORDER, true }, |
| }; |
| static const struct |
| { |
| const char* name; |
| const char* desc; |
| QueryType verifier; |
| } pureSetters[] = |
| { |
| { "set_pure_int", "Set state with pure int", QUERY_TEXTURE_PARAM_PURE_INTEGER }, |
| { "set_pure_uint", "Set state with pure unsigned int", QUERY_TEXTURE_PARAM_PURE_UNSIGNED_INTEGER }, |
| }; |
| static const struct |
| { |
| const char* name; |
| const char* desc; |
| TesterType intTester; |
| TesterType uintTester; |
| } pureStates[] = |
| { |
| { "texture_swizzle_r", "TEXTURE_SWIZZLE_R", TESTER_TEXTURE_SWIZZLE_R_SET_PURE_INT, TESTER_TEXTURE_SWIZZLE_R_SET_PURE_UINT }, |
| { "texture_swizzle_g", "TEXTURE_SWIZZLE_G", TESTER_TEXTURE_SWIZZLE_G_SET_PURE_INT, TESTER_TEXTURE_SWIZZLE_G_SET_PURE_UINT }, |
| { "texture_swizzle_b", "TEXTURE_SWIZZLE_B", TESTER_TEXTURE_SWIZZLE_B_SET_PURE_INT, TESTER_TEXTURE_SWIZZLE_B_SET_PURE_UINT }, |
| { "texture_swizzle_a", "TEXTURE_SWIZZLE_A", TESTER_TEXTURE_SWIZZLE_A_SET_PURE_INT, TESTER_TEXTURE_SWIZZLE_A_SET_PURE_UINT }, |
| { "texture_wrap_s", "TEXTURE_WRAP_S", TESTER_TEXTURE_WRAP_S_SET_PURE_INT, TESTER_TEXTURE_WRAP_S_SET_PURE_UINT }, |
| { "texture_wrap_t", "TEXTURE_WRAP_T", TESTER_TEXTURE_WRAP_T_SET_PURE_INT, TESTER_TEXTURE_WRAP_T_SET_PURE_UINT }, |
| { "texture_wrap_r", "TEXTURE_WRAP_R", TESTER_TEXTURE_WRAP_R_SET_PURE_INT, TESTER_TEXTURE_WRAP_R_SET_PURE_UINT }, |
| { "texture_mag_filter", "TEXTURE_MAG_FILTER", TESTER_TEXTURE_MAG_FILTER_SET_PURE_INT, TESTER_TEXTURE_MAG_FILTER_SET_PURE_UINT }, |
| { "texture_min_filter", "TEXTURE_MIN_FILTER", TESTER_TEXTURE_MIN_FILTER_SET_PURE_INT, TESTER_TEXTURE_MIN_FILTER_SET_PURE_UINT }, |
| { "texture_min_lod", "TEXTURE_MIN_LOD", TESTER_TEXTURE_MIN_LOD_SET_PURE_INT, TESTER_TEXTURE_MIN_LOD_SET_PURE_UINT }, |
| { "texture_max_lod", "TEXTURE_MAX_LOD", TESTER_TEXTURE_MAX_LOD_SET_PURE_INT, TESTER_TEXTURE_MAX_LOD_SET_PURE_UINT }, |
| { "texture_base_level", "TEXTURE_BASE_LEVEL", TESTER_TEXTURE_BASE_LEVEL_SET_PURE_INT, TESTER_TEXTURE_BASE_LEVEL_SET_PURE_UINT }, |
| { "texture_max_level", "TEXTURE_MAX_LEVEL", TESTER_TEXTURE_MAX_LEVEL_SET_PURE_INT, TESTER_TEXTURE_MAX_LEVEL_SET_PURE_UINT }, |
| { "texture_compare_mode", "TEXTURE_COMPARE_MODE", TESTER_TEXTURE_COMPARE_MODE_SET_PURE_INT, TESTER_TEXTURE_COMPARE_MODE_SET_PURE_UINT }, |
| { "texture_compare_func", "TEXTURE_COMPARE_FUNC", TESTER_TEXTURE_COMPARE_FUNC_SET_PURE_INT, TESTER_TEXTURE_COMPARE_FUNC_SET_PURE_UINT }, |
| // \note texture_immutable_levels is not settable |
| // \note texture_immutable_format is not settable |
| { "depth_stencil_mode", "DEPTH_STENCIL_TEXTURE_MODE", TESTER_DEPTH_STENCIL_TEXTURE_MODE_SET_PURE_INT, TESTER_DEPTH_STENCIL_TEXTURE_MODE_SET_PURE_UINT }, |
| { "texture_srgb_decode", "TEXTURE_SRGB_DECODE_EXT", TESTER_TEXTURE_SRGB_DECODE_EXT_SET_PURE_INT, TESTER_TEXTURE_SRGB_DECODE_EXT_SET_PURE_UINT }, |
| // \note texture_border_color is already checked |
| // \note texture_wrap_*_clamp_to_border brings no additional coverage |
| }; |
| |
| for (int targetNdx = 0; targetNdx < DE_LENGTH_OF_ARRAY(textureTargets); ++targetNdx) |
| { |
| tcu::TestCaseGroup* const targetGroup = new tcu::TestCaseGroup(m_testCtx, textureTargets[targetNdx].name, textureTargets[targetNdx].name); |
| addChild(targetGroup); |
| |
| if (textureTargets[targetNdx].newInGLES31) |
| { |
| targetGroup->addChild(createIsTextureTest(m_testCtx, |
| m_context.getRenderContext(), |
| "is_texture", |
| "IsTexture", |
| textureTargets[targetNdx].target)); |
| } |
| |
| for (int stateNdx = 0; stateNdx < DE_LENGTH_OF_ARRAY(states); ++stateNdx) |
| { |
| if (!isLegalTesterForTarget(textureTargets[targetNdx].target, states[stateNdx].tester)) |
| continue; |
| |
| // for old targets, check only new states |
| if (!textureTargets[targetNdx].newInGLES31 && !states[stateNdx].newInGLES31) |
| continue; |
| |
| if (isExtendedParamQuery(states[stateNdx].tester)) |
| { |
| // no need to cover for all getters if the only thing new is the param name |
| FOR_EACH_VERIFIER(nonPureVerifiers, createTexParamTest(m_testCtx, |
| m_context.getRenderContext(), |
| std::string() + states[stateNdx].name + verifierSuffix, |
| states[stateNdx].desc, |
| verifier, |
| textureTargets[targetNdx].target, |
| states[stateNdx].tester)); |
| } |
| else if (isIsVectorQuery(states[stateNdx].tester)) |
| { |
| FOR_EACH_VERIFIER(vec4Verifiers, createTexParamTest(m_testCtx, |
| m_context.getRenderContext(), |
| std::string() + states[stateNdx].name + verifierSuffix, |
| states[stateNdx].desc, |
| verifier, |
| textureTargets[targetNdx].target, |
| states[stateNdx].tester)); |
| } |
| else |
| { |
| FOR_EACH_VERIFIER(scalarVerifiers, createTexParamTest(m_testCtx, |
| m_context.getRenderContext(), |
| std::string() + states[stateNdx].name + verifierSuffix, |
| states[stateNdx].desc, |
| verifier, |
| textureTargets[targetNdx].target, |
| states[stateNdx].tester)); |
| } |
| } |
| } |
| |
| #undef FOR_EACH_VERIFIER |
| |
| // set_pure_uint |
| // set_pure_int |
| for (int setterNdx = 0; setterNdx < DE_LENGTH_OF_ARRAY(pureSetters); ++setterNdx) |
| { |
| tcu::TestCaseGroup* const targetGroup = new tcu::TestCaseGroup(m_testCtx, pureSetters[setterNdx].name, pureSetters[setterNdx].desc); |
| addChild(targetGroup); |
| |
| for (int stateNdx = 0; stateNdx < DE_LENGTH_OF_ARRAY(pureStates); ++stateNdx) |
| { |
| const TesterType tester = (pureSetters[setterNdx].verifier == QUERY_TEXTURE_PARAM_PURE_INTEGER) ? (pureStates[stateNdx].intTester) |
| : (pureSetters[setterNdx].verifier == QUERY_TEXTURE_PARAM_PURE_UNSIGNED_INTEGER) ? (pureStates[stateNdx].uintTester) |
| : (TESTER_LAST); |
| // need 3d texture to test R wrap |
| const glw::GLenum target = (pureStates[stateNdx].intTester == TESTER_TEXTURE_WRAP_R_SET_PURE_INT) ? (GL_TEXTURE_3D) : (GL_TEXTURE_2D); |
| |
| targetGroup->addChild(createTexParamTest(m_testCtx, |
| m_context.getRenderContext(), |
| std::string() + pureStates[stateNdx].name, |
| pureStates[stateNdx].desc, |
| pureSetters[setterNdx].verifier, |
| target, |
| tester)); |
| } |
| } |
| } |
| |
| } // Functional |
| } // gles31 |
| } // deqp |
