modules/gles31/functional/es31fTextureStateQueryTests.cpp

   1 /*-------------------------------------------------------------------------
   2  * drawElements Quality Program OpenGL ES 3.1 Module
   3  * -------------------------------------------------
   4  *
   5  * Copyright 2015 The Android Open Source Project
   6  *
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  *
  19  *//*!
  20  * \file
  21  * \brief Texture Param State Query tests.
  22  *//*--------------------------------------------------------------------*/
  23
  24 #include "es31fTextureStateQueryTests.hpp"
  25 #include "glsTextureStateQueryTests.hpp"
  26 #include "glsStateQueryUtil.hpp"
  27 #include "glwEnums.hpp"
  28
  29 namespace deqp
  30 {
  31 namespace gles31
  32 {
  33 namespace Functional
  34 {
  35
  36 using namespace gls::StateQueryUtil;
  37 using namespace gls::TextureStateQueryTests;
  38
  39 static const char* getVerifierSuffix (QueryType type)
  40 {
  41         switch (type)
  42         {
  43                 case QUERY_TEXTURE_PARAM_FLOAT:
  44                 case QUERY_TEXTURE_PARAM_FLOAT_VEC4:                                    return "_float";
  45
  46                 case QUERY_TEXTURE_PARAM_INTEGER:
  47                 case QUERY_TEXTURE_PARAM_INTEGER_VEC4:                                  return "_integer";
  48
  49                 case QUERY_TEXTURE_PARAM_PURE_INTEGER:
  50                 case QUERY_TEXTURE_PARAM_PURE_INTEGER_VEC4:                             return "_pure_int";
  51
  52                 case QUERY_TEXTURE_PARAM_PURE_UNSIGNED_INTEGER:
  53                 case QUERY_TEXTURE_PARAM_PURE_UNSIGNED_INTEGER_VEC4:    return "_pure_uint";
  54
  55                 default:
  56                         DE_ASSERT(DE_FALSE);
  57                         return DE_NULL;
  58         }
  59 }
  60
  61 static bool isIsVectorQuery (TesterType tester)
  62 {
  63         return tester == TESTER_TEXTURE_BORDER_COLOR;
  64 }
  65
  66 static bool isExtendedParamQuery (TesterType tester)
  67 {
  68         return  tester == TESTER_TEXTURE_WRAP_S_CLAMP_TO_BORDER ||
  69                         tester == TESTER_TEXTURE_WRAP_T_CLAMP_TO_BORDER ||
  70                         tester == TESTER_TEXTURE_WRAP_R_CLAMP_TO_BORDER;
  71 }
  72
  73 TextureStateQueryTests::TextureStateQueryTests (Context& context)
  74         : TestCaseGroup(context, "texture", "Texture State Query tests")
  75 {
  76 }
  77
  78 TextureStateQueryTests::~TextureStateQueryTests (void)
  79 {
  80 }
  81
  82 void TextureStateQueryTests::init (void)
  83 {
  84         static const QueryType scalarVerifiers[] =
  85         {
  86                 QUERY_TEXTURE_PARAM_INTEGER,
  87                 QUERY_TEXTURE_PARAM_FLOAT,
  88                 QUERY_TEXTURE_PARAM_PURE_INTEGER,
  89                 QUERY_TEXTURE_PARAM_PURE_UNSIGNED_INTEGER,
  90         };
  91         static const QueryType nonPureVerifiers[] =
  92         {
  93                 QUERY_TEXTURE_PARAM_INTEGER,
  94                 QUERY_TEXTURE_PARAM_FLOAT,
  95         };
  96         static const QueryType vec4Verifiers[] =
  97         {
  98                 QUERY_TEXTURE_PARAM_INTEGER_VEC4,
  99                 QUERY_TEXTURE_PARAM_FLOAT_VEC4,
 100                 QUERY_TEXTURE_PARAM_PURE_INTEGER_VEC4,
 101                 QUERY_TEXTURE_PARAM_PURE_UNSIGNED_INTEGER_VEC4,
 102         };
 103
 104 #define FOR_EACH_VERIFIER(VERIFIERS, X) \
 105         for (int verifierNdx = 0; verifierNdx < DE_LENGTH_OF_ARRAY(VERIFIERS); ++verifierNdx)   \
 106         {                                                                                                                                                                               \
 107                 const char* verifierSuffix = getVerifierSuffix((VERIFIERS)[verifierNdx]);                       \
 108                 const QueryType verifier = (VERIFIERS)[verifierNdx];                                                            \
 109                 targetGroup->addChild(X);                                                                                                                       \
 110         }
 111
 112         static const struct
 113         {
 114                 const char*     name;
 115                 glw::GLenum     target;
 116                 bool            newInGLES31;
 117         } textureTargets[] =
 118         {
 119                 { "texture_2d",                                         GL_TEXTURE_2D,                                          false,  },
 120                 { "texture_3d",                                         GL_TEXTURE_3D,                                          false,  },
 121                 { "texture_2d_array",                           GL_TEXTURE_2D_ARRAY,                            false,  },
 122                 { "texture_cube_map",                           GL_TEXTURE_CUBE_MAP,                            false,  },
 123                 { "texture_2d_multisample",                     GL_TEXTURE_2D_MULTISAMPLE,                      true,   },
 124                 { "texture_2d_multisample_array",       GL_TEXTURE_2D_MULTISAMPLE_ARRAY,        true,   }, // GL_OES_texture_storage_multisample_2d_array
 125                 { "texture_buffer",                                     GL_TEXTURE_BUFFER,                                      true,   }, // GL_EXT_texture_buffer
 126                 { "texture_cube_array",                         GL_TEXTURE_CUBE_MAP_ARRAY,                      true,   }, // GL_EXT_texture_cube_map_array
 127         };
 128         static const struct
 129         {
 130                 const char*     name;
 131                 const char*     desc;
 132                 TesterType      tester;
 133                 bool            newInGLES31;
 134         } states[] =
 135         {
 136                 { "texture_swizzle_r",                          "TEXTURE_SWIZZLE_R",                            TESTER_TEXTURE_SWIZZLE_R,                               false   },
 137                 { "texture_swizzle_g",                          "TEXTURE_SWIZZLE_G",                            TESTER_TEXTURE_SWIZZLE_G,                               false   },
 138                 { "texture_swizzle_b",                          "TEXTURE_SWIZZLE_B",                            TESTER_TEXTURE_SWIZZLE_B,                               false   },
 139                 { "texture_swizzle_a",                          "TEXTURE_SWIZZLE_A",                            TESTER_TEXTURE_SWIZZLE_A,                               false   },
 140                 { "texture_wrap_s",                                     "TEXTURE_WRAP_S",                                       TESTER_TEXTURE_WRAP_S,                                  false   },
 141                 { "texture_wrap_t",                                     "TEXTURE_WRAP_T",                                       TESTER_TEXTURE_WRAP_T,                                  false   },
 142                 { "texture_wrap_r",                                     "TEXTURE_WRAP_R",                                       TESTER_TEXTURE_WRAP_R,                                  false   },
 143                 { "texture_mag_filter",                         "TEXTURE_MAG_FILTER",                           TESTER_TEXTURE_MAG_FILTER,                              false   },
 144                 { "texture_min_filter",                         "TEXTURE_MIN_FILTER",                           TESTER_TEXTURE_MIN_FILTER,                              false   },
 145                 { "texture_min_lod",                            "TEXTURE_MIN_LOD",                                      TESTER_TEXTURE_MIN_LOD,                                 false   },
 146                 { "texture_max_lod",                            "TEXTURE_MAX_LOD",                                      TESTER_TEXTURE_MAX_LOD,                                 false   },
 147                 { "texture_base_level",                         "TEXTURE_BASE_LEVEL",                           TESTER_TEXTURE_BASE_LEVEL,                              false   },
 148                 { "texture_max_level",                          "TEXTURE_MAX_LEVEL",                            TESTER_TEXTURE_MAX_LEVEL,                               false   },
 149                 { "texture_compare_mode",                       "TEXTURE_COMPARE_MODE",                         TESTER_TEXTURE_COMPARE_MODE,                    false   },
 150                 { "texture_compare_func",                       "TEXTURE_COMPARE_FUNC",                         TESTER_TEXTURE_COMPARE_FUNC,                    false   },
 151                 { "texture_immutable_levels",           "TEXTURE_IMMUTABLE_LEVELS",                     TESTER_TEXTURE_IMMUTABLE_LEVELS,                false   },
 152                 { "texture_immutable_format",           "TEXTURE_IMMUTABLE_FORMAT",                     TESTER_TEXTURE_IMMUTABLE_FORMAT,                false   },
 153                 { "depth_stencil_mode",                         "DEPTH_STENCIL_TEXTURE_MODE",           TESTER_DEPTH_STENCIL_TEXTURE_MODE,              true    },
 154                 { "texture_srgb_decode",                        "TEXTURE_SRGB_DECODE_EXT",                      TESTER_TEXTURE_SRGB_DECODE_EXT,                 true    },
 155                 { "texture_border_color",                       "TEXTURE_BORDER_COLOR",                         TESTER_TEXTURE_BORDER_COLOR,                    true    },
 156                 { "texture_wrap_s_clamp_to_border",     "TEXTURE_WRAP_S_CLAMP_TO_BORDER",       TESTER_TEXTURE_WRAP_S_CLAMP_TO_BORDER,  true    },
 157                 { "texture_wrap_t_clamp_to_border",     "TEXTURE_WRAP_T_CLAMP_TO_BORDER",       TESTER_TEXTURE_WRAP_T_CLAMP_TO_BORDER,  true    },
 158                 { "texture_wrap_r_clamp_to_border",     "TEXTURE_WRAP_R_CLAMP_TO_BORDER",       TESTER_TEXTURE_WRAP_R_CLAMP_TO_BORDER,  true    },
 159         };
 160         static const struct
 161         {
 162                 const char* name;
 163                 const char* desc;
 164                 QueryType       verifier;
 165         } pureSetters[] =
 166         {
 167                 { "set_pure_int",       "Set state with pure int",                      QUERY_TEXTURE_PARAM_PURE_INTEGER                        },
 168                 { "set_pure_uint",      "Set state with pure unsigned int",     QUERY_TEXTURE_PARAM_PURE_UNSIGNED_INTEGER       },
 169         };
 170         static const struct
 171         {
 172                 const char*     name;
 173                 const char*     desc;
 174                 TesterType      intTester;
 175                 TesterType      uintTester;
 176         } pureStates[] =
 177         {
 178                 { "texture_swizzle_r",                          "TEXTURE_SWIZZLE_R",                            TESTER_TEXTURE_SWIZZLE_R_SET_PURE_INT,                  TESTER_TEXTURE_SWIZZLE_R_SET_PURE_UINT                          },
 179                 { "texture_swizzle_g",                          "TEXTURE_SWIZZLE_G",                            TESTER_TEXTURE_SWIZZLE_G_SET_PURE_INT,                  TESTER_TEXTURE_SWIZZLE_G_SET_PURE_UINT                          },
 180                 { "texture_swizzle_b",                          "TEXTURE_SWIZZLE_B",                            TESTER_TEXTURE_SWIZZLE_B_SET_PURE_INT,                  TESTER_TEXTURE_SWIZZLE_B_SET_PURE_UINT                          },
 181                 { "texture_swizzle_a",                          "TEXTURE_SWIZZLE_A",                            TESTER_TEXTURE_SWIZZLE_A_SET_PURE_INT,                  TESTER_TEXTURE_SWIZZLE_A_SET_PURE_UINT                          },
 182                 { "texture_wrap_s",                                     "TEXTURE_WRAP_S",                                       TESTER_TEXTURE_WRAP_S_SET_PURE_INT,                             TESTER_TEXTURE_WRAP_S_SET_PURE_UINT                                     },
 183                 { "texture_wrap_t",                                     "TEXTURE_WRAP_T",                                       TESTER_TEXTURE_WRAP_T_SET_PURE_INT,                             TESTER_TEXTURE_WRAP_T_SET_PURE_UINT                                     },
 184                 { "texture_wrap_r",                                     "TEXTURE_WRAP_R",                                       TESTER_TEXTURE_WRAP_R_SET_PURE_INT,                             TESTER_TEXTURE_WRAP_R_SET_PURE_UINT                                     },
 185                 { "texture_mag_filter",                         "TEXTURE_MAG_FILTER",                           TESTER_TEXTURE_MAG_FILTER_SET_PURE_INT,                 TESTER_TEXTURE_MAG_FILTER_SET_PURE_UINT                         },
 186                 { "texture_min_filter",                         "TEXTURE_MIN_FILTER",                           TESTER_TEXTURE_MIN_FILTER_SET_PURE_INT,                 TESTER_TEXTURE_MIN_FILTER_SET_PURE_UINT                         },
 187                 { "texture_min_lod",                            "TEXTURE_MIN_LOD",                                      TESTER_TEXTURE_MIN_LOD_SET_PURE_INT,                    TESTER_TEXTURE_MIN_LOD_SET_PURE_UINT                            },
 188                 { "texture_max_lod",                            "TEXTURE_MAX_LOD",                                      TESTER_TEXTURE_MAX_LOD_SET_PURE_INT,                    TESTER_TEXTURE_MAX_LOD_SET_PURE_UINT                            },
 189                 { "texture_base_level",                         "TEXTURE_BASE_LEVEL",                           TESTER_TEXTURE_BASE_LEVEL_SET_PURE_INT,                 TESTER_TEXTURE_BASE_LEVEL_SET_PURE_UINT                         },
 190                 { "texture_max_level",                          "TEXTURE_MAX_LEVEL",                            TESTER_TEXTURE_MAX_LEVEL_SET_PURE_INT,                  TESTER_TEXTURE_MAX_LEVEL_SET_PURE_UINT                          },
 191                 { "texture_compare_mode",                       "TEXTURE_COMPARE_MODE",                         TESTER_TEXTURE_COMPARE_MODE_SET_PURE_INT,               TESTER_TEXTURE_COMPARE_MODE_SET_PURE_UINT                       },
 192                 { "texture_compare_func",                       "TEXTURE_COMPARE_FUNC",                         TESTER_TEXTURE_COMPARE_FUNC_SET_PURE_INT,               TESTER_TEXTURE_COMPARE_FUNC_SET_PURE_UINT                       },
 193                 // \note texture_immutable_levels is not settable
 194                 // \note texture_immutable_format is not settable
 195                 { "depth_stencil_mode",                         "DEPTH_STENCIL_TEXTURE_MODE",           TESTER_DEPTH_STENCIL_TEXTURE_MODE_SET_PURE_INT, TESTER_DEPTH_STENCIL_TEXTURE_MODE_SET_PURE_UINT         },
 196                 { "texture_srgb_decode",                        "TEXTURE_SRGB_DECODE_EXT",                      TESTER_TEXTURE_SRGB_DECODE_EXT_SET_PURE_INT,    TESTER_TEXTURE_SRGB_DECODE_EXT_SET_PURE_UINT            },
 197                 // \note texture_border_color is already checked
 198                 // \note texture_wrap_*_clamp_to_border brings no additional coverage
 199         };
 200
 201         for (int targetNdx = 0; targetNdx < DE_LENGTH_OF_ARRAY(textureTargets); ++targetNdx)
 202         {
 203                 tcu::TestCaseGroup* const targetGroup = new tcu::TestCaseGroup(m_testCtx, textureTargets[targetNdx].name, textureTargets[targetNdx].name);
 204                 addChild(targetGroup);
 205
 206                 if (textureTargets[targetNdx].newInGLES31)
 207                 {
 208                         targetGroup->addChild(createIsTextureTest(m_testCtx,
 209                                                                                                           m_context.getRenderContext(),
 210                                                                                                           "is_texture",
 211                                                                                                           "IsTexture",
 212                                                                                                           textureTargets[targetNdx].target));
 213                 }
 214
 215                 for (int stateNdx = 0; stateNdx < DE_LENGTH_OF_ARRAY(states); ++stateNdx)
 216                 {
 217                         if (!isLegalTesterForTarget(textureTargets[targetNdx].target, states[stateNdx].tester))
 218                                 continue;
 219
 220                         // for old targets, check only new states
 221                         if (!textureTargets[targetNdx].newInGLES31 && !states[stateNdx].newInGLES31)
 222                                 continue;
 223
 224                         if (isExtendedParamQuery(states[stateNdx].tester))
 225                         {
 226                                 // no need to cover for all getters if the only thing new is the param name
 227                                 FOR_EACH_VERIFIER(nonPureVerifiers, createTexParamTest(m_testCtx,
 228                                                                                                                                            m_context.getRenderContext(),
 229                                                                                                                                            std::string() + states[stateNdx].name + verifierSuffix,
 230                                                                                                                                            states[stateNdx].desc,
 231                                                                                                                                            verifier,
 232                                                                                                                                            textureTargets[targetNdx].target,
 233                                                                                                                                            states[stateNdx].tester));
 234                         }
 235                         else if (isIsVectorQuery(states[stateNdx].tester))
 236                         {
 237                                 FOR_EACH_VERIFIER(vec4Verifiers, createTexParamTest(m_testCtx,
 238                                                                                                                                         m_context.getRenderContext(),
 239                                                                                                                                         std::string() + states[stateNdx].name + verifierSuffix,
 240                                                                                                                                         states[stateNdx].desc,
 241                                                                                                                                         verifier,
 242                                                                                                                                         textureTargets[targetNdx].target,
 243                                                                                                                                         states[stateNdx].tester));
 244                         }
 245                         else
 246                         {
 247                                 FOR_EACH_VERIFIER(scalarVerifiers, createTexParamTest(m_testCtx,
 248                                                                                                                                           m_context.getRenderContext(),
 249                                                                                                                                           std::string() + states[stateNdx].name + verifierSuffix,
 250                                                                                                                                           states[stateNdx].desc,
 251                                                                                                                                           verifier,
 252                                                                                                                                           textureTargets[targetNdx].target,
 253                                                                                                                                           states[stateNdx].tester));
 254                         }
 255                 }
 256         }
 257
 258 #undef FOR_EACH_VERIFIER
 259
 260         // set_pure_uint
 261         // set_pure_int
 262         for (int setterNdx = 0; setterNdx < DE_LENGTH_OF_ARRAY(pureSetters); ++setterNdx)
 263         {
 264                 tcu::TestCaseGroup* const targetGroup = new tcu::TestCaseGroup(m_testCtx, pureSetters[setterNdx].name, pureSetters[setterNdx].desc);
 265                 addChild(targetGroup);
 266
 267                 for (int stateNdx = 0; stateNdx < DE_LENGTH_OF_ARRAY(pureStates); ++stateNdx)
 268                 {
 269                         const TesterType        tester  = (pureSetters[setterNdx].verifier == QUERY_TEXTURE_PARAM_PURE_INTEGER)                         ? (pureStates[stateNdx].intTester)
 270                                                                                 : (pureSetters[setterNdx].verifier == QUERY_TEXTURE_PARAM_PURE_UNSIGNED_INTEGER)        ? (pureStates[stateNdx].uintTester)
 271                                                                                 : (TESTER_LAST);
 272                         // need 3d texture to test R wrap
 273                         const glw::GLenum       target  = (pureStates[stateNdx].intTester == TESTER_TEXTURE_WRAP_R_SET_PURE_INT) ? (GL_TEXTURE_3D) : (GL_TEXTURE_2D);
 274
 275                         targetGroup->addChild(createTexParamTest(m_testCtx,
 276                                                                                                          m_context.getRenderContext(),
 277                                                                                                          std::string() + pureStates[stateNdx].name,
 278                                                                                                          pureStates[stateNdx].desc,
 279                                                                                                          pureSetters[setterNdx].verifier,
 280                                                                                                          target,
 281                                                                                                          tester));
 282                 }
 283         }
 284 }
 285
 286 } // Functional
 287 } // gles31
 288 } // deqp