modules/gles2/functional/es2fVertexArrayTest.cpp

   1 /*-------------------------------------------------------------------------
   2  * drawElements Quality Program OpenGL ES 2.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 Vertex array and buffer tests
  22  *//*--------------------------------------------------------------------*/
  23
  24 #include "es2fVertexArrayTest.hpp"
  25 #include "glsVertexArrayTests.hpp"
  26
  27 #include "glwEnums.hpp"
  28
  29 using namespace deqp::gls;
  30
  31 namespace deqp
  32 {
  33 namespace gles2
  34 {
  35 namespace Functional
  36 {
  37
  38 template<class T>
  39 static std::string typeToString (T t)
  40 {
  41         std::stringstream strm;
  42         strm << t;
  43         return strm.str();
  44 }
  45
  46
  47 class SingleVertexArrayUsageTests : public TestCaseGroup
  48 {
  49 public:
  50                                                                         SingleVertexArrayUsageTests             (Context& context);
  51         virtual                                                 ~SingleVertexArrayUsageTests    (void);
  52
  53         virtual void                                    init                                                    (void);
  54
  55 private:
  56                                                                         SingleVertexArrayUsageTests             (const SingleVertexArrayUsageTests& other);
  57         SingleVertexArrayUsageTests&    operator=                                               (const SingleVertexArrayUsageTests& other);
  58 };
  59
  60 SingleVertexArrayUsageTests::SingleVertexArrayUsageTests (Context& context)
  61         : TestCaseGroup(context, "usages", "Single vertex atribute, usage")
  62 {
  63 }
  64
  65 SingleVertexArrayUsageTests::~SingleVertexArrayUsageTests (void)
  66 {
  67 }
  68
  69 void SingleVertexArrayUsageTests::init (void)
  70 {
  71         // Test usage
  72         Array::Usage            usages[]                = {Array::USAGE_STATIC_DRAW, Array::USAGE_STREAM_DRAW, Array::USAGE_DYNAMIC_DRAW};
  73         int                                     counts[]                = {1, 256};
  74         int                                     strides[]               = {0, -1, 17, 32}; // Tread negative value as sizeof input. Same as 0, but done outside of GL.
  75         Array::InputType        inputTypes[]    = {Array::INPUTTYPE_FLOAT, Array::INPUTTYPE_FIXED, Array::INPUTTYPE_SHORT, Array::INPUTTYPE_BYTE};
  76
  77         for (int inputTypeNdx = 0; inputTypeNdx < DE_LENGTH_OF_ARRAY(inputTypes); inputTypeNdx++)
  78         {
  79                 for (int countNdx = 0; countNdx < DE_LENGTH_OF_ARRAY(counts); countNdx++)
  80                 {
  81                         for (int strideNdx = 0; strideNdx < DE_LENGTH_OF_ARRAY(strides); strideNdx++)
  82                         {
  83                                 for (int usageNdx = 0; usageNdx < DE_LENGTH_OF_ARRAY(usages); usageNdx++)
  84                                 {
  85                                         const int       componentCount  = 2;
  86                                         const int       stride                  = (strides[strideNdx] < 0 ? Array::inputTypeSize(inputTypes[inputTypeNdx]) * componentCount : strides[strideNdx]);
  87                                         const bool      aligned                 = (stride % Array::inputTypeSize(inputTypes[inputTypeNdx])) == 0;
  88                                         MultiVertexArrayTest::Spec::ArraySpec arraySpec(inputTypes[inputTypeNdx],
  89                                                                                                                                         Array::OUTPUTTYPE_VEC2,
  90                                                                                                                                         Array::STORAGE_BUFFER,
  91                                                                                                                                         usages[usageNdx],
  92                                                                                                                                         componentCount,
  93                                                                                                                                         0,
  94                                                                                                                                         stride,
  95                                                                                                                                         false,
  96                                                                                                                                         GLValue::getMinValue(inputTypes[inputTypeNdx]),
  97                                                                                                                                         GLValue::getMaxValue(inputTypes[inputTypeNdx]));
  98
  99                                         MultiVertexArrayTest::Spec spec;
 100                                         spec.primitive  = Array::PRIMITIVE_TRIANGLES;
 101                                         spec.drawCount  = counts[countNdx];
 102                                         spec.first              = 0;
 103                                         spec.arrays.push_back(arraySpec);
 104
 105                                         std::string name = spec.getName();
 106
 107                                         if (aligned)
 108                                                 addChild(new MultiVertexArrayTest(m_testCtx, m_context.getRenderContext(), spec, name.c_str(), name.c_str()));
 109                                 }
 110                         }
 111                 }
 112         }
 113 }
 114
 115 class SingleVertexArrayStrideTests : public TestCaseGroup
 116 {
 117 public:
 118                                                                         SingleVertexArrayStrideTests    (Context& context);
 119         virtual                                                 ~SingleVertexArrayStrideTests   (void);
 120
 121         virtual void                                    init                                                    (void);
 122
 123 private:
 124                                                                         SingleVertexArrayStrideTests    (const SingleVertexArrayStrideTests& other);
 125         SingleVertexArrayStrideTests&   operator=                                               (const SingleVertexArrayStrideTests& other);
 126 };
 127
 128 SingleVertexArrayStrideTests::SingleVertexArrayStrideTests (Context& context)
 129         : TestCaseGroup(context, "strides", "Single stride vertex atribute")
 130 {
 131 }
 132
 133 SingleVertexArrayStrideTests::~SingleVertexArrayStrideTests (void)
 134 {
 135 }
 136
 137 void SingleVertexArrayStrideTests::init (void)
 138 {
 139         // Test strides with different input types, component counts and storage, Usage(?)
 140         Array::InputType        inputTypes[]    = {Array::INPUTTYPE_FLOAT, Array::INPUTTYPE_SHORT, Array::INPUTTYPE_BYTE, /*Array::INPUTTYPE_UNSIGNED_SHORT, Array::INPUTTYPE_UNSIGNED_BYTE,*/ Array::INPUTTYPE_FIXED};
 141         Array::Storage          storages[]              = {Array::STORAGE_USER, Array::STORAGE_BUFFER};
 142         int                                     counts[]                = {1, 256};
 143         int                                     strides[]               = {/*0,*/ -1, 17, 32}; // Tread negative value as sizeof input. Same as 0, but done outside of GL.
 144
 145         for (int inputTypeNdx = 0; inputTypeNdx < DE_LENGTH_OF_ARRAY(inputTypes); inputTypeNdx++)
 146         {
 147                 for (int storageNdx = 0; storageNdx < DE_LENGTH_OF_ARRAY(storages); storageNdx++)
 148                 {
 149                         for (int componentCount = 2; componentCount < 5; componentCount++)
 150                         {
 151                                 for (int countNdx = 0; countNdx < DE_LENGTH_OF_ARRAY(counts); countNdx++)
 152                                 {
 153                                         for (int strideNdx = 0; strideNdx < DE_LENGTH_OF_ARRAY(strides); strideNdx++)
 154                                         {
 155                                                 const int       stride                  = (strides[strideNdx] < 0 ? Array::inputTypeSize(inputTypes[inputTypeNdx]) * componentCount : strides[strideNdx]);
 156                                                 const bool      bufferAligned   = (storages[storageNdx] == Array::STORAGE_BUFFER) && (stride % Array::inputTypeSize(inputTypes[inputTypeNdx])) == 0;
 157
 158                                                 MultiVertexArrayTest::Spec::ArraySpec arraySpec(inputTypes[inputTypeNdx],
 159                                                                                                                                                 Array::OUTPUTTYPE_VEC4,
 160                                                                                                                                                 storages[storageNdx],
 161                                                                                                                                                 Array::USAGE_DYNAMIC_DRAW,
 162                                                                                                                                                 componentCount,
 163                                                                                                                                                 0,
 164                                                                                                                                                 stride,
 165                                                                                                                                                 false,
 166                                                                                                                                                 GLValue::getMinValue(inputTypes[inputTypeNdx]),
 167                                                                                                                                                 GLValue::getMaxValue(inputTypes[inputTypeNdx]));
 168
 169                                                 MultiVertexArrayTest::Spec spec;
 170                                                 spec.primitive  = Array::PRIMITIVE_TRIANGLES;
 171                                                 spec.drawCount  = counts[countNdx];
 172                                                 spec.first              = 0;
 173                                                 spec.arrays.push_back(arraySpec);
 174
 175                                                 std::string name = spec.getName();
 176                                                 if (bufferAligned)
 177                                                         addChild(new MultiVertexArrayTest(m_testCtx, m_context.getRenderContext(), spec, name.c_str(), name.c_str()));
 178                                         }
 179                                 }
 180                         }
 181                 }
 182         }
 183 }
 184
 185 class SingleVertexArrayFirstTests : public TestCaseGroup
 186 {
 187 public:
 188                                                                         SingleVertexArrayFirstTests     (Context& context);
 189         virtual                                                 ~SingleVertexArrayFirstTests    (void);
 190
 191         virtual void                                    init                                                    (void);
 192
 193 private:
 194                                                                         SingleVertexArrayFirstTests     (const SingleVertexArrayFirstTests& other);
 195         SingleVertexArrayFirstTests&    operator=                                               (const SingleVertexArrayFirstTests& other);
 196 };
 197
 198 SingleVertexArrayFirstTests::SingleVertexArrayFirstTests (Context& context)
 199         : TestCaseGroup(context, "first", "Single vertex atribute different first values")
 200 {
 201 }
 202
 203 SingleVertexArrayFirstTests::~SingleVertexArrayFirstTests (void)
 204 {
 205 }
 206
 207 void SingleVertexArrayFirstTests::init (void)
 208 {
 209         // Test strides with different input types, component counts and storage, Usage(?)
 210         Array::InputType        inputTypes[]    = {Array::INPUTTYPE_FLOAT, Array::INPUTTYPE_BYTE, Array::INPUTTYPE_FIXED};
 211         int                                     counts[]                = {5, 256};
 212         int                                     firsts[]                = {6, 24};
 213         int                                     offsets[]               = {1, 16, 17};
 214         int                                     strides[]               = {/*0,*/ -1, 17, 32}; // Tread negative value as sizeof input. Same as 0, but done outside of GL.
 215
 216         for (int inputTypeNdx = 0; inputTypeNdx < DE_LENGTH_OF_ARRAY(inputTypes); inputTypeNdx++)
 217         {
 218                 for (int offsetNdx = 0; offsetNdx < DE_LENGTH_OF_ARRAY(offsets); offsetNdx++)
 219                 {
 220                         for (int countNdx = 0; countNdx < DE_LENGTH_OF_ARRAY(counts); countNdx++)
 221                         {
 222                                 for (int strideNdx = 0; strideNdx < DE_LENGTH_OF_ARRAY(strides); strideNdx++)
 223                                 {
 224                                         for (int firstNdx = 0; firstNdx < DE_LENGTH_OF_ARRAY(firsts); firstNdx++)
 225                                         {
 226                                                 const int       stride  = (strides[strideNdx] < 0 ? Array::inputTypeSize(inputTypes[inputTypeNdx]) * 2 : strides[strideNdx]);
 227                                                 const bool      aligned = ((stride % Array::inputTypeSize(inputTypes[inputTypeNdx])) == 0) && (offsets[offsetNdx] % Array::inputTypeSize(inputTypes[inputTypeNdx]) == 0);
 228
 229                                                 MultiVertexArrayTest::Spec::ArraySpec arraySpec(inputTypes[inputTypeNdx],
 230                                                                                                                                                 Array::OUTPUTTYPE_VEC2,
 231                                                                                                                                                 Array::STORAGE_BUFFER,
 232                                                                                                                                                 Array::USAGE_DYNAMIC_DRAW,
 233                                                                                                                                                 2,
 234                                                                                                                                                 offsets[offsetNdx],
 235                                                                                                                                                 stride,
 236                                                                                                                                                 false,
 237                                                                                                                                                 GLValue::getMinValue(inputTypes[inputTypeNdx]),
 238                                                                                                                                                 GLValue::getMaxValue(inputTypes[inputTypeNdx]));
 239
 240                                                 MultiVertexArrayTest::Spec spec;
 241                                                 spec.primitive  = Array::PRIMITIVE_TRIANGLES;
 242                                                 spec.drawCount  = counts[countNdx];
 243                                                 spec.first              = firsts[firstNdx];
 244                                                 spec.arrays.push_back(arraySpec);
 245
 246                                                 std::string name = Array::inputTypeToString(inputTypes[inputTypeNdx]) + "_first" + typeToString(firsts[firstNdx]) + "_offset" + typeToString(offsets[offsetNdx]) + "_stride" + typeToString(stride) + "_quads" + typeToString(counts[countNdx]);
 247                                                 if (aligned)
 248                                                         addChild(new MultiVertexArrayTest(m_testCtx, m_context.getRenderContext(), spec, name.c_str(), name.c_str()));
 249                                         }
 250                                 }
 251                         }
 252                 }
 253         }
 254 }
 255
 256 class SingleVertexArrayOffsetTests : public TestCaseGroup
 257 {
 258 public:
 259                                                                         SingleVertexArrayOffsetTests    (Context& context);
 260         virtual                                                 ~SingleVertexArrayOffsetTests   (void);
 261
 262         virtual void                                    init                                                    (void);
 263
 264 private:
 265                                                                         SingleVertexArrayOffsetTests    (const SingleVertexArrayOffsetTests& other);
 266         SingleVertexArrayOffsetTests&   operator=                                               (const SingleVertexArrayOffsetTests& other);
 267 };
 268
 269 SingleVertexArrayOffsetTests::SingleVertexArrayOffsetTests (Context& context)
 270         : TestCaseGroup(context, "offset", "Single vertex atribute offset element")
 271 {
 272 }
 273
 274 SingleVertexArrayOffsetTests::~SingleVertexArrayOffsetTests (void)
 275 {
 276 }
 277
 278 void SingleVertexArrayOffsetTests::init (void)
 279 {
 280         // Test strides with different input types, component counts and storage, Usage(?)
 281         Array::InputType        inputTypes[]    = {Array::INPUTTYPE_FLOAT, Array::INPUTTYPE_BYTE, Array::INPUTTYPE_FIXED};
 282         int                                     counts[]                = {1, 256};
 283         int                                     offsets[]               = {1, 4, 17, 32};
 284         int                                     strides[]               = {/*0,*/ -1, 17, 32}; // Tread negative value as sizeof input. Same as 0, but done outside of GL.
 285
 286         for (int inputTypeNdx = 0; inputTypeNdx < DE_LENGTH_OF_ARRAY(inputTypes); inputTypeNdx++)
 287         {
 288                 for (int offsetNdx = 0; offsetNdx < DE_LENGTH_OF_ARRAY(offsets); offsetNdx++)
 289                 {
 290                         for (int countNdx = 0; countNdx < DE_LENGTH_OF_ARRAY(counts); countNdx++)
 291                         {
 292                                 for (int strideNdx = 0; strideNdx < DE_LENGTH_OF_ARRAY(strides); strideNdx++)
 293                                 {
 294                                         const int       stride  = (strides[strideNdx] < 0 ? Array::inputTypeSize(inputTypes[inputTypeNdx]) * 2 : strides[strideNdx]);
 295                                         const bool      aligned = ((stride % Array::inputTypeSize(inputTypes[inputTypeNdx])) == 0) && ((offsets[offsetNdx] % Array::inputTypeSize(inputTypes[inputTypeNdx])) == 0);
 296
 297                                         MultiVertexArrayTest::Spec::ArraySpec arraySpec(inputTypes[inputTypeNdx],
 298                                                                                                                                         Array::OUTPUTTYPE_VEC2,
 299                                                                                                                                         Array::STORAGE_BUFFER,
 300                                                                                                                                         Array::USAGE_DYNAMIC_DRAW,
 301                                                                                                                                         2,
 302                                                                                                                                         offsets[offsetNdx],
 303                                                                                                                                         stride,
 304                                                                                                                                         false,
 305                                                                                                                                         GLValue::getMinValue(inputTypes[inputTypeNdx]),
 306                                                                                                                                         GLValue::getMaxValue(inputTypes[inputTypeNdx]));
 307
 308                                         MultiVertexArrayTest::Spec spec;
 309                                         spec.primitive  = Array::PRIMITIVE_TRIANGLES;
 310                                         spec.drawCount  = counts[countNdx];
 311                                         spec.first              = 0;
 312                                         spec.arrays.push_back(arraySpec);
 313
 314                                         std::string name = spec.getName();
 315                                         if (aligned)
 316                                                 addChild(new MultiVertexArrayTest(m_testCtx, m_context.getRenderContext(), spec, name.c_str(), name.c_str()));
 317                                 }
 318                         }
 319                 }
 320         }
 321 }
 322
 323 class SingleVertexArrayNormalizeTests : public TestCaseGroup
 324 {
 325 public:
 326                                                                                 SingleVertexArrayNormalizeTests         (Context& context);
 327         virtual                                                         ~SingleVertexArrayNormalizeTests        (void);
 328
 329         virtual void                                            init                                                            (void);
 330
 331 private:
 332                                                                                 SingleVertexArrayNormalizeTests         (const SingleVertexArrayNormalizeTests& other);
 333         SingleVertexArrayNormalizeTests&        operator=                                                       (const SingleVertexArrayNormalizeTests& other);
 334 };
 335
 336 SingleVertexArrayNormalizeTests::SingleVertexArrayNormalizeTests (Context& context)
 337         : TestCaseGroup(context, "normalize", "Single normalize vertex atribute")
 338 {
 339 }
 340
 341 SingleVertexArrayNormalizeTests::~SingleVertexArrayNormalizeTests (void)
 342 {
 343 }
 344
 345 void SingleVertexArrayNormalizeTests::init (void)
 346 {
 347         // Test normalization with different input types, component counts and storage
 348         Array::InputType        inputTypes[]    = {Array::INPUTTYPE_FLOAT, Array::INPUTTYPE_SHORT, Array::INPUTTYPE_BYTE, Array::INPUTTYPE_UNSIGNED_SHORT, Array::INPUTTYPE_UNSIGNED_BYTE, Array::INPUTTYPE_FIXED};
 349         Array::Storage          storages[]              = {Array::STORAGE_USER};
 350         int                                     counts[]                = {1, 256};
 351
 352         for (int inputTypeNdx = 0; inputTypeNdx < DE_LENGTH_OF_ARRAY(inputTypes); inputTypeNdx++)
 353         {
 354                 for (int storageNdx = 0; storageNdx < DE_LENGTH_OF_ARRAY(storages); storageNdx++)
 355                 {
 356                         for (int componentCount = 2; componentCount < 5; componentCount++)
 357                         {
 358                                 for (int countNdx = 0; countNdx < DE_LENGTH_OF_ARRAY(counts); countNdx++)
 359                                 {
 360                                         MultiVertexArrayTest::Spec::ArraySpec arraySpec(inputTypes[inputTypeNdx],
 361                                                                                                                                         Array::OUTPUTTYPE_VEC4,
 362                                                                                                                                         storages[storageNdx],
 363                                                                                                                                         Array::USAGE_DYNAMIC_DRAW,
 364                                                                                                                                         componentCount,
 365                                                                                                                                         0,
 366                                                                                                                                         0,
 367                                                                                                                                         true,
 368                                                                                                                                         GLValue::getMinValue(inputTypes[inputTypeNdx]),
 369                                                                                                                                         GLValue::getMaxValue(inputTypes[inputTypeNdx]));
 370
 371                                         MultiVertexArrayTest::Spec spec;
 372                                         spec.primitive  = Array::PRIMITIVE_TRIANGLES;
 373                                         spec.drawCount  = counts[countNdx];
 374                                         spec.first              = 0;
 375                                         spec.arrays.push_back(arraySpec);
 376
 377                                         std::string name = spec.getName();
 378                                         addChild(new MultiVertexArrayTest(m_testCtx, m_context.getRenderContext(), spec, name.c_str(), name.c_str()));
 379                                 }
 380                         }
 381                 }
 382         }
 383 }
 384
 385 class SingleVertexArrayOutputTypeTests : public TestCaseGroup
 386 {
 387 public:
 388                                                                                         SingleVertexArrayOutputTypeTests        (Context& context);
 389         virtual                                                                 ~SingleVertexArrayOutputTypeTests       (void);
 390
 391         virtual void                                                    init                                                                    (void);
 392
 393 private:
 394                                                                                         SingleVertexArrayOutputTypeTests        (const SingleVertexArrayOutputTypeTests& other);
 395         SingleVertexArrayOutputTypeTests&       operator=                                                               (const SingleVertexArrayOutputTypeTests& other);
 396 };
 397
 398 SingleVertexArrayOutputTypeTests::SingleVertexArrayOutputTypeTests (Context& context)
 399         : TestCaseGroup(context, "output_types", "Single output type vertex atribute")
 400 {
 401 }
 402
 403 SingleVertexArrayOutputTypeTests::~SingleVertexArrayOutputTypeTests (void)
 404 {
 405 }
 406
 407 void SingleVertexArrayOutputTypeTests::init (void)
 408 {
 409         // Test output types with different input types, component counts and storage, Usage?, Precision?, float?
 410         Array::InputType        inputTypes[]    = {Array::INPUTTYPE_FLOAT, Array::INPUTTYPE_SHORT, Array::INPUTTYPE_BYTE, Array::INPUTTYPE_UNSIGNED_SHORT, Array::INPUTTYPE_UNSIGNED_BYTE, Array::INPUTTYPE_FIXED};
 411         Array::OutputType       outputTypes[]   = {Array::OUTPUTTYPE_VEC2, Array::OUTPUTTYPE_VEC3, Array::OUTPUTTYPE_VEC4};
 412         Array::Storage          storages[]              = {Array::STORAGE_USER};
 413         int                                     counts[]                = {1, 256};
 414
 415         for (int inputTypeNdx = 0; inputTypeNdx < DE_LENGTH_OF_ARRAY(inputTypes); inputTypeNdx++)
 416         {
 417                 for (int outputTypeNdx = 0; outputTypeNdx < DE_LENGTH_OF_ARRAY(outputTypes); outputTypeNdx++)
 418                 {
 419                         for (int storageNdx = 0; storageNdx < DE_LENGTH_OF_ARRAY(storages); storageNdx++)
 420                         {
 421                                 for (int componentCount = 2; componentCount < 5; componentCount++)
 422                                 {
 423                                         for (int countNdx = 0; countNdx < DE_LENGTH_OF_ARRAY(counts); countNdx++)
 424                                         {
 425                                                 MultiVertexArrayTest::Spec::ArraySpec arraySpec(inputTypes[inputTypeNdx],
 426                                                                                                                                                 outputTypes[outputTypeNdx],
 427                                                                                                                                                 storages[storageNdx],
 428                                                                                                                                                 Array::USAGE_DYNAMIC_DRAW,
 429                                                                                                                                                 componentCount,
 430                                                                                                                                                 0,
 431                                                                                                                                                 0,
 432                                                                                                                                                 false,
 433                                                                                                                                                 GLValue::getMinValue(inputTypes[inputTypeNdx]),
 434                                                                                                                                                 GLValue::getMaxValue(inputTypes[inputTypeNdx]));
 435
 436                                                 MultiVertexArrayTest::Spec spec;
 437                                                 spec.primitive  = Array::PRIMITIVE_TRIANGLES;
 438                                                 spec.drawCount  = counts[countNdx];
 439                                                 spec.first              = 0;
 440                                                 spec.arrays.push_back(arraySpec);
 441
 442                                                 std::string name = spec.getName();
 443                                                 addChild(new MultiVertexArrayTest(m_testCtx, m_context.getRenderContext(), spec, name.c_str(), name.c_str()));
 444                                         }
 445                                 }
 446                         }
 447                 }
 448         }
 449 }
 450
 451 class SingleVertexArrayTestGroup : public TestCaseGroup
 452 {
 453 public:
 454                                                                         SingleVertexArrayTestGroup      (Context& context);
 455         virtual                                                 ~SingleVertexArrayTestGroup     (void);
 456
 457         virtual void                                    init                                            (void);
 458
 459 private:
 460                                                                         SingleVertexArrayTestGroup      (const SingleVertexArrayTestGroup& other);
 461         SingleVertexArrayTestGroup&             operator=                                       (const SingleVertexArrayTestGroup& other);
 462 };
 463
 464 SingleVertexArrayTestGroup::SingleVertexArrayTestGroup (Context& context)
 465         : TestCaseGroup(context, "single_attribute", "Single vertex atribute")
 466 {
 467 }
 468
 469 SingleVertexArrayTestGroup::~SingleVertexArrayTestGroup (void)
 470 {
 471 }
 472
 473 void SingleVertexArrayTestGroup::init (void)
 474 {
 475         addChild(new SingleVertexArrayStrideTests(m_context));
 476         addChild(new SingleVertexArrayNormalizeTests(m_context));
 477         addChild(new SingleVertexArrayOutputTypeTests(m_context));
 478         addChild(new SingleVertexArrayUsageTests(m_context));
 479         addChild(new SingleVertexArrayOffsetTests(m_context));
 480         addChild(new SingleVertexArrayFirstTests(m_context));
 481 }
 482
 483 class MultiVertexArrayCountTests : public TestCaseGroup
 484 {
 485 public:
 486                                                                         MultiVertexArrayCountTests      (Context& context);
 487         virtual                                                 ~MultiVertexArrayCountTests     (void);
 488
 489         virtual void                                    init                                            (void);
 490
 491 private:
 492                                                                         MultiVertexArrayCountTests      (const MultiVertexArrayCountTests& other);
 493         MultiVertexArrayCountTests&             operator=                                       (const MultiVertexArrayCountTests& other);
 494
 495         std::string                                             getTestName                                     (const MultiVertexArrayTest::Spec& spec);
 496 };
 497
 498 MultiVertexArrayCountTests::MultiVertexArrayCountTests (Context& context)
 499         : TestCaseGroup(context, "attribute_count", "Attribute counts")
 500 {
 501 }
 502
 503 MultiVertexArrayCountTests::~MultiVertexArrayCountTests (void)
 504 {
 505 }
 506
 507 std::string MultiVertexArrayCountTests::getTestName (const MultiVertexArrayTest::Spec& spec)
 508 {
 509         std::stringstream name;
 510         name
 511                 << spec.arrays.size();
 512
 513         return name.str();
 514 }
 515
 516 void MultiVertexArrayCountTests::init (void)
 517 {
 518         // Test attribute counts
 519         int arrayCounts[] = {2, 3, 4, 5, 6, 7, 8};
 520
 521         for (int arrayCountNdx = 0; arrayCountNdx < DE_LENGTH_OF_ARRAY(arrayCounts); arrayCountNdx++)
 522         {
 523                 MultiVertexArrayTest::Spec spec;
 524
 525                 spec.primitive  = Array::PRIMITIVE_TRIANGLES;
 526                 spec.drawCount  = 256;
 527                 spec.first              = 0;
 528
 529                 for (int arrayNdx = 0; arrayNdx < arrayCounts[arrayCountNdx]; arrayNdx++)
 530                 {
 531                         MultiVertexArrayTest::Spec::ArraySpec arraySpec(Array::INPUTTYPE_FLOAT,
 532                                                                                                                         Array::OUTPUTTYPE_VEC2,
 533                                                                                                                         Array::STORAGE_USER,
 534                                                                                                                         Array::USAGE_DYNAMIC_DRAW,
 535                                                                                                                         2,
 536                                                                                                                         0,
 537                                                                                                                         0,
 538                                                                                                                         false,
 539                                                                                                                         GLValue::getMinValue(Array::INPUTTYPE_FLOAT),
 540                                                                                                                         GLValue::getMaxValue(Array::INPUTTYPE_FLOAT));
 541
 542                         spec.arrays.push_back(arraySpec);
 543                 }
 544
 545                 std::string name = getTestName(spec);
 546                 std::string desc = getTestName(spec);
 547
 548                 addChild(new MultiVertexArrayTest(m_testCtx, m_context.getRenderContext(), spec, name.c_str(), desc.c_str()));
 549         }
 550 }
 551
 552 class MultiVertexArrayStorageTests : public TestCaseGroup
 553 {
 554 public:
 555                                                                         MultiVertexArrayStorageTests    (Context& context);
 556         virtual                                                 ~MultiVertexArrayStorageTests   (void);
 557
 558         virtual void                                    init                                                            (void);
 559
 560 private:
 561                                                                         MultiVertexArrayStorageTests    (const MultiVertexArrayStorageTests& other);
 562         MultiVertexArrayStorageTests&   operator=                                                       (const MultiVertexArrayStorageTests& other);
 563
 564         void                                                    addStorageCases                                         (MultiVertexArrayTest::Spec spec, int depth);
 565         std::string                                             getTestName                                                     (const MultiVertexArrayTest::Spec& spec);
 566 };
 567
 568 MultiVertexArrayStorageTests::MultiVertexArrayStorageTests (Context& context)
 569         : TestCaseGroup(context, "storage", "Attribute storages")
 570 {
 571 }
 572
 573 MultiVertexArrayStorageTests::~MultiVertexArrayStorageTests (void)
 574 {
 575 }
 576
 577 std::string MultiVertexArrayStorageTests::getTestName (const MultiVertexArrayTest::Spec& spec)
 578 {
 579         std::stringstream name;
 580         name
 581                 << spec.arrays.size();
 582
 583         for (int arrayNdx = 0; arrayNdx < (int)spec.arrays.size(); arrayNdx++)
 584         {
 585                 name
 586                         << "_"
 587                         << Array::storageToString(spec.arrays[arrayNdx].storage);
 588         }
 589
 590         return name.str();
 591 }
 592
 593 void MultiVertexArrayStorageTests::addStorageCases (MultiVertexArrayTest::Spec spec, int depth)
 594 {
 595         if (depth == 0)
 596         {
 597                 // Skip trivial case, used elsewhere
 598                 bool ok = false;
 599                 for (int arrayNdx = 0; arrayNdx < (int)spec.arrays.size(); arrayNdx++)
 600                 {
 601                         if (spec.arrays[arrayNdx].storage != Array::STORAGE_USER)
 602                         {
 603                                 ok = true;
 604                                 break;
 605                         }
 606                 }
 607
 608                 if (!ok)
 609                         return;
 610
 611                 std::string name = getTestName(spec);
 612                 std::string desc = getTestName(spec);
 613
 614                 addChild(new MultiVertexArrayTest(m_testCtx, m_context.getRenderContext(), spec, name.c_str(), desc.c_str()));
 615                 return;
 616         }
 617
 618         Array::Storage storages[] = {Array::STORAGE_USER, Array::STORAGE_BUFFER};
 619         for (int storageNdx = 0; storageNdx < DE_LENGTH_OF_ARRAY(storages); storageNdx++)
 620         {
 621                 MultiVertexArrayTest::Spec::ArraySpec arraySpec(Array::INPUTTYPE_FLOAT,
 622                                                                                                                 Array::OUTPUTTYPE_VEC2,
 623                                                                                                                 storages[storageNdx],
 624                                                                                                                 Array::USAGE_DYNAMIC_DRAW,
 625                                                                                                                 2,
 626                                                                                                                 0,
 627                                                                                                                 0,
 628                                                                                                                 false,
 629                                                                                                                 GLValue::getMinValue(Array::INPUTTYPE_FLOAT),
 630                                                                                                                 GLValue::getMaxValue(Array::INPUTTYPE_FLOAT));
 631
 632                 MultiVertexArrayTest::Spec _spec = spec;
 633                 _spec.arrays.push_back(arraySpec);
 634                 addStorageCases(_spec, depth-1);
 635         }
 636 }
 637
 638
 639 void MultiVertexArrayStorageTests::init (void)
 640 {
 641         // Test different storages
 642         int arrayCounts[] = {3};
 643
 644         MultiVertexArrayTest::Spec spec;
 645
 646         spec.primitive  = Array::PRIMITIVE_TRIANGLES;
 647         spec.drawCount  = 256;
 648         spec.first              = 0;
 649
 650         for (int arrayCountNdx = 0; arrayCountNdx < DE_LENGTH_OF_ARRAY(arrayCounts); arrayCountNdx++)
 651                 addStorageCases(spec, arrayCounts[arrayCountNdx]);
 652 }
 653
 654 class MultiVertexArrayStrideTests : public TestCaseGroup
 655 {
 656 public:
 657                                                                         MultiVertexArrayStrideTests             (Context& context);
 658         virtual                                                 ~MultiVertexArrayStrideTests    (void);
 659
 660         virtual void                                    init                                                    (void);
 661
 662 private:
 663                                                                         MultiVertexArrayStrideTests             (const MultiVertexArrayStrideTests& other);
 664         MultiVertexArrayStrideTests&    operator=                                               (const MultiVertexArrayStrideTests& other);
 665
 666         void                                                    addStrideCases                                  (MultiVertexArrayTest::Spec spec, int depth);
 667         std::string                                             getTestName                                             (const MultiVertexArrayTest::Spec& spec);
 668 };
 669
 670 MultiVertexArrayStrideTests::MultiVertexArrayStrideTests (Context& context)
 671         : TestCaseGroup(context, "stride", "Strides")
 672 {
 673 }
 674
 675 MultiVertexArrayStrideTests::~MultiVertexArrayStrideTests (void)
 676 {
 677 }
 678
 679 std::string MultiVertexArrayStrideTests::getTestName (const MultiVertexArrayTest::Spec& spec)
 680 {
 681         std::stringstream name;
 682
 683         name
 684                 << spec.arrays.size();
 685
 686         for (int arrayNdx = 0; arrayNdx < (int)spec.arrays.size(); arrayNdx++)
 687         {
 688                 name
 689                         << "_"
 690                         << Array::inputTypeToString(spec.arrays[arrayNdx].inputType)
 691                         << spec.arrays[arrayNdx].componentCount << "_"
 692                         << spec.arrays[arrayNdx].stride;
 693         }
 694
 695         return name.str();
 696 }
 697
 698 void MultiVertexArrayStrideTests::init (void)
 699 {
 700         // Test different strides, with multiple arrays, input types??
 701         int arrayCounts[] = {3};
 702
 703         MultiVertexArrayTest::Spec spec;
 704
 705         spec.primitive  = Array::PRIMITIVE_TRIANGLES;
 706         spec.drawCount  = 256;
 707         spec.first              = 0;
 708
 709         for (int arrayCountNdx = 0; arrayCountNdx < DE_LENGTH_OF_ARRAY(arrayCounts); arrayCountNdx++)
 710                 addStrideCases(spec, arrayCounts[arrayCountNdx]);
 711 }
 712
 713 void MultiVertexArrayStrideTests::addStrideCases (MultiVertexArrayTest::Spec spec, int depth)
 714 {
 715         if (depth == 0)
 716         {
 717                 std::string name = getTestName(spec);
 718                 std::string desc = getTestName(spec);
 719                 addChild(new MultiVertexArrayTest(m_testCtx, m_context.getRenderContext(), spec, name.c_str(), desc.c_str()));
 720                 return;
 721         }
 722
 723         int strides[]   = {0, -1, 17, 32};
 724
 725         for (int strideNdx = 0; strideNdx < DE_LENGTH_OF_ARRAY(strides); strideNdx++)
 726         {
 727                 const int componentCount = 2;
 728                 MultiVertexArrayTest::Spec::ArraySpec arraySpec(Array::INPUTTYPE_FLOAT,
 729                                                                                                                 Array::OUTPUTTYPE_VEC2,
 730                                                                                                                 Array::STORAGE_USER,
 731                                                                                                                 Array::USAGE_DYNAMIC_DRAW,
 732                                                                                                                 componentCount,
 733                                                                                                                 0,
 734                                                                                                                 (strides[strideNdx] >= 0 ? strides[strideNdx] : componentCount * Array::inputTypeSize(Array::INPUTTYPE_FLOAT)),
 735                                                                                                                 false,
 736                                                                                                                 GLValue::getMinValue(Array::INPUTTYPE_FLOAT),
 737                                                                                                                 GLValue::getMaxValue(Array::INPUTTYPE_FLOAT));
 738
 739                 MultiVertexArrayTest::Spec _spec = spec;
 740                 _spec.arrays.push_back(arraySpec);
 741                 addStrideCases(_spec, depth-1);
 742         }
 743 }
 744
 745 class MultiVertexArrayOutputTests : public TestCaseGroup
 746 {
 747 public:
 748                                                                                 MultiVertexArrayOutputTests             (Context& context);
 749         virtual                                                         ~MultiVertexArrayOutputTests    (void);
 750
 751         virtual void                                            init                                                            (void);
 752
 753 private:
 754                                                                                 MultiVertexArrayOutputTests             (const MultiVertexArrayOutputTests& other);
 755         MultiVertexArrayOutputTests&    operator=                                                       (const MultiVertexArrayOutputTests& other);
 756
 757         void                                                            addInputTypeCases                                       (MultiVertexArrayTest::Spec spec, int depth);
 758         std::string                                                     getTestName                                                     (const MultiVertexArrayTest::Spec& spec);
 759 };
 760
 761 MultiVertexArrayOutputTests::MultiVertexArrayOutputTests (Context& context)
 762         : TestCaseGroup(context, "input_types", "input types")
 763 {
 764 }
 765
 766 MultiVertexArrayOutputTests::~MultiVertexArrayOutputTests (void)
 767 {
 768 }
 769
 770 std::string MultiVertexArrayOutputTests::getTestName (const MultiVertexArrayTest::Spec& spec)
 771 {
 772         std::stringstream name;
 773
 774         name
 775                 << spec.arrays.size();
 776
 777         for (int arrayNdx = 0; arrayNdx < (int)spec.arrays.size(); arrayNdx++)
 778         {
 779                 name
 780                         << "_"
 781                         << Array::inputTypeToString(spec.arrays[arrayNdx].inputType)
 782                         << spec.arrays[arrayNdx].componentCount << "_"
 783                         << Array::outputTypeToString(spec.arrays[arrayNdx].outputType);
 784         }
 785
 786         return name.str();
 787 }
 788
 789 void MultiVertexArrayOutputTests::init (void)
 790 {
 791         // Test different input types, with multiple arrays
 792         int arrayCounts[] = {3};
 793
 794         MultiVertexArrayTest::Spec spec;
 795
 796         spec.primitive  = Array::PRIMITIVE_TRIANGLES;
 797         spec.drawCount  = 256;
 798         spec.first              = 0;
 799
 800         for (int arrayCountNdx = 0; arrayCountNdx < DE_LENGTH_OF_ARRAY(arrayCounts); arrayCountNdx++)
 801                 addInputTypeCases(spec, arrayCounts[arrayCountNdx]);
 802 }
 803
 804 void MultiVertexArrayOutputTests::addInputTypeCases (MultiVertexArrayTest::Spec spec, int depth)
 805 {
 806         if (depth == 0)
 807         {
 808                 std::string name = getTestName(spec);
 809                 std::string desc = getTestName(spec);
 810                 addChild(new MultiVertexArrayTest(m_testCtx, m_context.getRenderContext(), spec, name.c_str(), desc.c_str()));
 811                 return;
 812         }
 813
 814         Array::InputType inputTypes[] = {Array::INPUTTYPE_FIXED, Array::INPUTTYPE_BYTE, Array::INPUTTYPE_SHORT, Array::INPUTTYPE_UNSIGNED_BYTE, Array::INPUTTYPE_UNSIGNED_SHORT};
 815         for (int inputTypeNdx = 0; inputTypeNdx < DE_LENGTH_OF_ARRAY(inputTypes); inputTypeNdx++)
 816         {
 817                 MultiVertexArrayTest::Spec::ArraySpec arraySpec(inputTypes[inputTypeNdx],
 818                                                                                                                 Array::OUTPUTTYPE_VEC2,
 819                                                                                                                 Array::STORAGE_USER,
 820                                                                                                                 Array::USAGE_DYNAMIC_DRAW,
 821                                                                                                                 2,
 822                                                                                                                 0,
 823                                                                                                                 0,
 824                                                                                                                 false,
 825                                                                                                                 GLValue::getMinValue(inputTypes[inputTypeNdx]),
 826                                                                                                                 GLValue::getMaxValue(inputTypes[inputTypeNdx]));
 827
 828                 MultiVertexArrayTest::Spec _spec = spec;
 829                 _spec.arrays.push_back(arraySpec);
 830                 addInputTypeCases(_spec, depth-1);
 831         }
 832 }
 833
 834 class MultiVertexArrayTestGroup : public TestCaseGroup
 835 {
 836 public:
 837                                                                         MultiVertexArrayTestGroup       (Context& context);
 838         virtual                                                 ~MultiVertexArrayTestGroup      (void);
 839
 840         virtual void                                    init                                            (void);
 841
 842 private:
 843                                                                         MultiVertexArrayTestGroup       (const MultiVertexArrayTestGroup& other);
 844         MultiVertexArrayTestGroup&              operator=                                       (const MultiVertexArrayTestGroup& other);
 845 };
 846
 847 MultiVertexArrayTestGroup::MultiVertexArrayTestGroup (Context& context)
 848         : TestCaseGroup(context, "multiple_attributes", "Multiple vertex atributes")
 849 {
 850 }
 851
 852 MultiVertexArrayTestGroup::~MultiVertexArrayTestGroup (void)
 853 {
 854 }
 855
 856 void MultiVertexArrayTestGroup::init (void)
 857 {
 858         addChild(new MultiVertexArrayCountTests(m_context));
 859         addChild(new MultiVertexArrayStorageTests(m_context));
 860         addChild(new MultiVertexArrayStrideTests(m_context));
 861         addChild(new MultiVertexArrayOutputTests(m_context));
 862 }
 863
 864 VertexArrayTestGroup::VertexArrayTestGroup (Context& context)
 865         : TestCaseGroup(context, "vertex_arrays", "Vertex array and array tests")
 866 {
 867 }
 868
 869 VertexArrayTestGroup::~VertexArrayTestGroup (void)
 870 {
 871 }
 872
 873 void VertexArrayTestGroup::init (void)
 874 {
 875         addChild(new SingleVertexArrayTestGroup(m_context));
 876         addChild(new MultiVertexArrayTestGroup(m_context));
 877 }
 878
 879 } // Functional
 880 } // gles2
 881 } // deqp
 882