modules/gles3/functional/es3fRandomShaderTests.cpp

   1 /*-------------------------------------------------------------------------
   2  * drawElements Quality Program OpenGL ES 3.0 Module
   3  * -------------------------------------------------
   4  *
   5  * Copyright 2014 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 Random shader tests.
  22  *//*--------------------------------------------------------------------*/
  23
  24 #include "es3fRandomShaderTests.hpp"
  25 #include "glsRandomShaderCase.hpp"
  26 #include "deString.h"
  27 #include "deStringUtil.hpp"
  28
  29 namespace deqp
  30 {
  31 namespace gles3
  32 {
  33 namespace Functional
  34 {
  35
  36 namespace
  37 {
  38
  39 gls::RandomShaderCase* createRandomShaderCase (Context& context, const char* description, const rsg::ProgramParameters& baseParams, deUint32 seed, bool vertex, bool fragment)
  40 {
  41         rsg::ProgramParameters params = baseParams;
  42
  43         params.version                                          = rsg::VERSION_300;
  44         params.seed                                                     = seed;
  45         params.vertexParameters.randomize       = vertex;
  46         params.fragmentParameters.randomize     = fragment;
  47
  48         return new gls::RandomShaderCase(context.getTestContext(), context.getRenderContext(), de::toString(seed).c_str(), description, params);
  49 }
  50
  51 class BasicExpressionGroup : public TestCaseGroup
  52 {
  53 public:
  54         BasicExpressionGroup (Context& context)
  55                 : TestCaseGroup(context, "basic_expression", "Basic arithmetic expressions")
  56         {
  57         }
  58
  59         void init (void)
  60         {
  61                 rsg::ProgramParameters params;
  62
  63                 tcu::TestCaseGroup* vertexGroup = new tcu::TestCaseGroup(m_testCtx, "vertex", "Vertex-only tests");
  64                 addChild(vertexGroup);
  65
  66                 tcu::TestCaseGroup* fragmentGroup = new tcu::TestCaseGroup(m_testCtx, "fragment", "Fragment-only tests");
  67                 addChild(fragmentGroup);
  68
  69                 tcu::TestCaseGroup* combinedGroup = new tcu::TestCaseGroup(m_testCtx, "combined", "Combined tests");
  70                 addChild(combinedGroup);
  71
  72                 for (int seed = 0; seed < 100; seed++)
  73                 {
  74                         vertexGroup->addChild(createRandomShaderCase(m_context,         "Random expressions in vertex shader",                                  params, seed, true, false));
  75                         fragmentGroup->addChild(createRandomShaderCase(m_context,       "Random expressions in fragment shader",                                params, seed, false, true));
  76                         combinedGroup->addChild(createRandomShaderCase(m_context,       "Random expressions in vertex and fragment shaders",    params, seed, true, true));
  77                 }
  78         }
  79 };
  80
  81 class ScalarConversionGroup : public TestCaseGroup
  82 {
  83 public:
  84         ScalarConversionGroup (Context& context)
  85                 : TestCaseGroup(context, "scalar_conversion", "Scalar conversions")
  86         {
  87         }
  88
  89         void init (void)
  90         {
  91                 rsg::ProgramParameters params;
  92                 params.useScalarConversions = true;
  93
  94                 tcu::TestCaseGroup* vertexGroup = new tcu::TestCaseGroup(m_testCtx, "vertex", "Vertex-only tests");
  95                 addChild(vertexGroup);
  96
  97                 tcu::TestCaseGroup* fragmentGroup = new tcu::TestCaseGroup(m_testCtx, "fragment", "Fragment-only tests");
  98                 addChild(fragmentGroup);
  99
 100                 tcu::TestCaseGroup* combinedGroup = new tcu::TestCaseGroup(m_testCtx, "combined", "Combined tests");
 101                 addChild(combinedGroup);
 102
 103                 for (int seed = 0; seed < 100; seed++)
 104                 {
 105                         vertexGroup->addChild(createRandomShaderCase(m_context,         "Scalar conversions in vertex shader",                                  params, seed, true, false));
 106                         fragmentGroup->addChild(createRandomShaderCase(m_context,       "Scalar conversions in fragment shader",                                params, seed, false, true));
 107                         combinedGroup->addChild(createRandomShaderCase(m_context,       "Scalar conversions in vertex and fragment shaders",    params, seed, true, true));
 108                 }
 109         }
 110 };
 111
 112 class SwizzleGroup : public TestCaseGroup
 113 {
 114 public:
 115         SwizzleGroup (Context& context)
 116                 : TestCaseGroup(context, "swizzle", "Vector swizzles")
 117         {
 118         }
 119
 120         void init (void)
 121         {
 122                 rsg::ProgramParameters params;
 123                 params.useScalarConversions = true;
 124                 params.useSwizzle                       = true;
 125
 126                 tcu::TestCaseGroup* vertexGroup = new tcu::TestCaseGroup(m_testCtx, "vertex", "Vertex-only tests");
 127                 addChild(vertexGroup);
 128
 129                 tcu::TestCaseGroup* fragmentGroup = new tcu::TestCaseGroup(m_testCtx, "fragment", "Fragment-only tests");
 130                 addChild(fragmentGroup);
 131
 132                 for (int seed = 0; seed < 50; seed++)
 133                 {
 134                         vertexGroup->addChild(createRandomShaderCase(m_context,         "Vector swizzles in vertex shader",             params, seed, true, false));
 135                         fragmentGroup->addChild(createRandomShaderCase(m_context,       "Vector swizzles in fragment shader",   params, seed, false, true));
 136                 }
 137         }
 138 };
 139
 140 class ComparisonOpsGroup : public TestCaseGroup
 141 {
 142 public:
 143         ComparisonOpsGroup (Context& context)
 144                 : TestCaseGroup(context, "comparison_ops", "Comparison operators")
 145         {
 146         }
 147
 148         void init (void)
 149         {
 150                 rsg::ProgramParameters params;
 151                 params.useScalarConversions = true;
 152                 params.useComparisonOps         = true;
 153
 154                 tcu::TestCaseGroup* vertexGroup = new tcu::TestCaseGroup(m_testCtx, "vertex", "Vertex-only tests");
 155                 addChild(vertexGroup);
 156
 157                 tcu::TestCaseGroup* fragmentGroup = new tcu::TestCaseGroup(m_testCtx, "fragment", "Fragment-only tests");
 158                 addChild(fragmentGroup);
 159
 160                 for (int seed = 0; seed < 50; seed++)
 161                 {
 162                         vertexGroup->addChild(createRandomShaderCase(m_context,         "Comparison operators in vertex shader",                params, seed, true, false));
 163                         fragmentGroup->addChild(createRandomShaderCase(m_context,       "Comparison operators in fragment shader",              params, seed, false, true));
 164                 }
 165         }
 166 };
 167
 168 class ConditionalsGroup : public TestCaseGroup
 169 {
 170 public:
 171         ConditionalsGroup (Context& context)
 172                 : TestCaseGroup(context, "conditionals", "Conditional control flow (if-else)")
 173         {
 174         }
 175
 176         void init (void)
 177         {
 178                 rsg::ProgramParameters params;
 179                 params.useScalarConversions = true;
 180                 params.useSwizzle                       = true;
 181                 params.useComparisonOps         = true;
 182                 params.useConditionals          = true;
 183                 params.vertexParameters.maxStatementDepth               = 4;
 184                 params.vertexParameters.maxStatementsPerBlock   = 5;
 185                 params.fragmentParameters.maxStatementDepth             = 4;
 186                 params.fragmentParameters.maxStatementsPerBlock = 5;
 187
 188                 tcu::TestCaseGroup* vertexGroup = new tcu::TestCaseGroup(m_testCtx, "vertex", "Vertex-only tests");
 189                 addChild(vertexGroup);
 190
 191                 tcu::TestCaseGroup* fragmentGroup = new tcu::TestCaseGroup(m_testCtx, "fragment", "Fragment-only tests");
 192                 addChild(fragmentGroup);
 193
 194                 tcu::TestCaseGroup* combinedGroup = new tcu::TestCaseGroup(m_testCtx, "combined", "Combined tests");
 195                 addChild(combinedGroup);
 196
 197                 for (int seed = 0; seed < 100; seed++)
 198                 {
 199                         vertexGroup->addChild(createRandomShaderCase(m_context,         "Conditional control flow in vertex shader",                            params, seed, true, false));
 200                         fragmentGroup->addChild(createRandomShaderCase(m_context,       "Conditional control flow in fragment shader",                          params, seed, false, true));
 201                         combinedGroup->addChild(createRandomShaderCase(m_context,       "Conditional control flow in vertex and fragment shaders",      params, seed, true, true));
 202                 }
 203         }
 204 };
 205
 206 class TrigonometricGroup : public TestCaseGroup
 207 {
 208 public:
 209         TrigonometricGroup (Context& context)
 210                 : TestCaseGroup(context, "trigonometric", "Trigonometric built-in functions")
 211         {
 212         }
 213
 214         void init (void)
 215         {
 216                 rsg::ProgramParameters params;
 217                 params.useScalarConversions             = true;
 218                 params.useSwizzle                               = true;
 219                 params.trigonometricBaseWeight  = 4.0f;
 220
 221                 tcu::TestCaseGroup* vertexGroup = new tcu::TestCaseGroup(m_testCtx, "vertex", "Vertex-only tests");
 222                 addChild(vertexGroup);
 223
 224                 tcu::TestCaseGroup* fragmentGroup = new tcu::TestCaseGroup(m_testCtx, "fragment", "Fragment-only tests");
 225                 addChild(fragmentGroup);
 226
 227                 for (int seed = 0; seed < 100; seed++)
 228                 {
 229                         vertexGroup->addChild(createRandomShaderCase(m_context,         "Trigonometric ops in vertex shader",   params, seed, true, false));
 230                         fragmentGroup->addChild(createRandomShaderCase(m_context,       "Trigonometric ops in fragment shader", params, seed, false, true));
 231                 }
 232         }
 233 };
 234
 235 class ExponentialGroup : public TestCaseGroup
 236 {
 237 public:
 238         ExponentialGroup (Context& context)
 239                 : TestCaseGroup(context, "exponential", "Exponential built-in functions")
 240         {
 241         }
 242
 243         void init (void)
 244         {
 245                 rsg::ProgramParameters params;
 246                 params.useScalarConversions             = true;
 247                 params.useSwizzle                               = true;
 248                 params.exponentialBaseWeight    = 4.0f;
 249
 250                 tcu::TestCaseGroup* vertexGroup = new tcu::TestCaseGroup(m_testCtx, "vertex", "Vertex-only tests");
 251                 addChild(vertexGroup);
 252
 253                 tcu::TestCaseGroup* fragmentGroup = new tcu::TestCaseGroup(m_testCtx, "fragment", "Fragment-only tests");
 254                 addChild(fragmentGroup);
 255
 256                 for (int seed = 0; seed < 100; seed++)
 257                 {
 258                         vertexGroup->addChild(createRandomShaderCase(m_context,         "Exponential ops in vertex shader",             params, seed, true, false));
 259                         fragmentGroup->addChild(createRandomShaderCase(m_context,       "Exponential ops in fragment shader",   params, seed, false, true));
 260                 }
 261         }
 262 };
 263
 264 class TextureGroup : public TestCaseGroup
 265 {
 266 public:
 267         TextureGroup (Context& context)
 268                 : TestCaseGroup(context, "texture", "Texture lookups")
 269         {
 270         }
 271
 272         void init (void)
 273         {
 274                 rsg::ProgramParameters params;
 275                 params.useScalarConversions                                             = true;
 276                 params.useSwizzle                                                               = true;
 277                 params.vertexParameters.texLookupBaseWeight             = 10.0f;
 278                 params.vertexParameters.useTexture2D                    = true;
 279                 params.vertexParameters.useTextureCube                  = true;
 280                 params.fragmentParameters.texLookupBaseWeight   = 10.0f;
 281                 params.fragmentParameters.useTexture2D                  = true;
 282                 params.fragmentParameters.useTextureCube                = true;
 283
 284                 tcu::TestCaseGroup* vertexGroup = new tcu::TestCaseGroup(m_testCtx, "vertex", "Vertex-only tests");
 285                 addChild(vertexGroup);
 286
 287                 tcu::TestCaseGroup* fragmentGroup = new tcu::TestCaseGroup(m_testCtx, "fragment", "Fragment-only tests");
 288                 addChild(fragmentGroup);
 289
 290                 // Do only 50 vertex cases and 150 fragment cases.
 291                 for (int seed = 0; seed < 50; seed++)
 292                         vertexGroup->addChild(createRandomShaderCase(m_context,         "Texture lookups in vertex shader",             params, seed, true, false));
 293
 294                 for (int seed = 0; seed < 150; seed++)
 295                         fragmentGroup->addChild(createRandomShaderCase(m_context,       "Texture lookups in fragment shader",   params, seed, false, true));
 296         }
 297 };
 298
 299 class AllFeaturesGroup : public TestCaseGroup
 300 {
 301 public:
 302         AllFeaturesGroup (Context& context)
 303                 : TestCaseGroup(context, "all_features", "All features enabled")
 304         {
 305         }
 306
 307         void init (void)
 308         {
 309                 rsg::ProgramParameters params;
 310                 params.useScalarConversions             = true;
 311                 params.useSwizzle                               = true;
 312                 params.useComparisonOps                 = true;
 313                 params.useConditionals                  = true;
 314                 params.trigonometricBaseWeight  = 1.0f;
 315                 params.exponentialBaseWeight    = 1.0f;
 316
 317                 params.vertexParameters.maxStatementDepth                               = 4;
 318                 params.vertexParameters.maxStatementsPerBlock                   = 7;
 319                 params.vertexParameters.maxExpressionDepth                              = 7;
 320                 params.vertexParameters.maxCombinedVariableScalars              = 64;
 321                 params.fragmentParameters.maxStatementDepth                             = 4;
 322                 params.fragmentParameters.maxStatementsPerBlock                 = 7;
 323                 params.fragmentParameters.maxExpressionDepth                    = 7;
 324                 params.fragmentParameters.maxCombinedVariableScalars    = 64;
 325
 326                 params.fragmentParameters.texLookupBaseWeight           = 4.0f; // \note Texture lookups are enabled for fragment shaders only.
 327                 params.fragmentParameters.useTexture2D                          = true;
 328                 params.fragmentParameters.useTextureCube                        = true;
 329
 330                 tcu::TestCaseGroup* vertexGroup = new tcu::TestCaseGroup(m_testCtx, "vertex", "Vertex-only tests");
 331                 addChild(vertexGroup);
 332
 333                 tcu::TestCaseGroup* fragmentGroup = new tcu::TestCaseGroup(m_testCtx, "fragment", "Fragment-only tests");
 334                 addChild(fragmentGroup);
 335
 336                 for (int seed = 0; seed < 100; seed++)
 337                 {
 338                         vertexGroup->addChild(createRandomShaderCase(m_context,         "Texture lookups in vertex shader",             params, seed, true, false));
 339                         fragmentGroup->addChild(createRandomShaderCase(m_context,       "Texture lookups in fragment shader",   params, seed, false, true));
 340                 }
 341         }
 342 };
 343
 344 } // anonymous
 345
 346 RandomShaderTests::RandomShaderTests (Context& context)
 347         : TestCaseGroup(context, "random", "Random shaders")
 348 {
 349 }
 350
 351 RandomShaderTests::~RandomShaderTests (void)
 352 {
 353 }
 354
 355 namespace
 356 {
 357
 358 } // anonymous
 359
 360 void RandomShaderTests::init (void)
 361 {
 362         addChild(new BasicExpressionGroup       (m_context));
 363         addChild(new ScalarConversionGroup      (m_context));
 364         addChild(new SwizzleGroup                       (m_context));
 365         addChild(new ComparisonOpsGroup         (m_context));
 366         addChild(new ConditionalsGroup          (m_context));
 367         addChild(new TrigonometricGroup         (m_context));
 368         addChild(new ExponentialGroup           (m_context));
 369         addChild(new TextureGroup                       (m_context));
 370         addChild(new AllFeaturesGroup           (m_context));
 371 }
 372
 373 } // Functional
 374 } // gles2
 375 } // deqp