modules/gles2/stress/es2sVertexArrayTests.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 unaligned access stress tests
  22  *//*--------------------------------------------------------------------*/
  23
  24 #include "es2sVertexArrayTests.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 Stress
  36 {
  37 namespace
  38 {
  39
  40 template<class T>
  41 static std::string typeToString (T t)
  42 {
  43         std::stringstream strm;
  44         strm << t;
  45         return strm.str();
  46 }
  47
  48 class SingleVertexArrayUsageTests : public TestCaseGroup
  49 {
  50 public:
  51                                                                         SingleVertexArrayUsageTests             (Context& context);
  52         virtual                                                 ~SingleVertexArrayUsageTests    (void);
  53
  54         virtual void                                    init                                                    (void);
  55
  56 private:
  57                                                                         SingleVertexArrayUsageTests             (const SingleVertexArrayUsageTests& other);
  58         SingleVertexArrayUsageTests&    operator=                                               (const SingleVertexArrayUsageTests& other);
  59 };
  60
  61 SingleVertexArrayUsageTests::SingleVertexArrayUsageTests (Context& context)
  62         : TestCaseGroup(context, "usages", "Single vertex atribute, usage")
  63 {
  64 }
  65
  66 SingleVertexArrayUsageTests::~SingleVertexArrayUsageTests (void)
  67 {
  68 }
  69
  70 void SingleVertexArrayUsageTests::init (void)
  71 {
  72         // Test usage
  73         Array::Usage            usages[]                = {Array::USAGE_STATIC_DRAW, Array::USAGE_STREAM_DRAW, Array::USAGE_DYNAMIC_DRAW};
  74         int                                     counts[]                = {1, 256};
  75         int                                     strides[]               = {17};
  76         Array::InputType        inputTypes[]    = {Array::INPUTTYPE_FLOAT, Array::INPUTTYPE_FIXED, Array::INPUTTYPE_SHORT, Array::INPUTTYPE_BYTE};
  77
  78         for (int inputTypeNdx = 0; inputTypeNdx < DE_LENGTH_OF_ARRAY(inputTypes); inputTypeNdx++)
  79         {
  80                 for (int countNdx = 0; countNdx < DE_LENGTH_OF_ARRAY(counts); countNdx++)
  81                 {
  82                         for (int strideNdx = 0; strideNdx < DE_LENGTH_OF_ARRAY(strides); strideNdx++)
  83                         {
  84                                 for (int usageNdx = 0; usageNdx < DE_LENGTH_OF_ARRAY(usages); usageNdx++)
  85                                 {
  86                                         const int       componentCount  = 2;
  87                                         const int       stride                  = (strides[strideNdx] < 0 ? Array::inputTypeSize(inputTypes[inputTypeNdx]) * componentCount : strides[strideNdx]);
  88                                         const bool      aligned                 = (stride % Array::inputTypeSize(inputTypes[inputTypeNdx])) == 0;
  89                                         MultiVertexArrayTest::Spec::ArraySpec arraySpec(inputTypes[inputTypeNdx],
  90                                                                                                                                         Array::OUTPUTTYPE_VEC2,
  91                                                                                                                                         Array::STORAGE_BUFFER,
  92                                                                                                                                         usages[usageNdx],
  93                                                                                                                                         componentCount,
  94                                                                                                                                         0,
  95                                                                                                                                         stride,
  96                                                                                                                                         false,
  97                                                                                                                                         GLValue::getMinValue(inputTypes[inputTypeNdx]),
  98                                                                                                                                         GLValue::getMaxValue(inputTypes[inputTypeNdx]));
  99
 100                                         MultiVertexArrayTest::Spec spec;
 101                                         spec.primitive  = Array::PRIMITIVE_TRIANGLES;
 102                                         spec.drawCount  = counts[countNdx];
 103                                         spec.first              = 0;
 104                                         spec.arrays.push_back(arraySpec);
 105
 106                                         std::string name = spec.getName();
 107
 108                                         if (!aligned)
 109                                                 addChild(new MultiVertexArrayTest(m_testCtx, m_context.getRenderContext(), spec, name.c_str(), name.c_str()));
 110                                 }
 111                         }
 112                 }
 113         }
 114 }
 115
 116 class SingleVertexArrayStrideTests : public TestCaseGroup
 117 {
 118 public:
 119                                                                         SingleVertexArrayStrideTests    (Context& context);
 120         virtual                                                 ~SingleVertexArrayStrideTests   (void);
 121
 122         virtual void                                    init                                                    (void);
 123
 124 private:
 125                                                                         SingleVertexArrayStrideTests    (const SingleVertexArrayStrideTests& other);
 126         SingleVertexArrayStrideTests&   operator=                                               (const SingleVertexArrayStrideTests& other);
 127 };
 128
 129 SingleVertexArrayStrideTests::SingleVertexArrayStrideTests (Context& context)
 130         : TestCaseGroup(context, "strides", "Single stride vertex atribute")
 131 {
 132 }
 133
 134 SingleVertexArrayStrideTests::~SingleVertexArrayStrideTests (void)
 135 {
 136 }
 137
 138 void SingleVertexArrayStrideTests::init (void)
 139 {
 140         // Test strides with different input types, component counts and storage, Usage(?)
 141         Array::InputType        inputTypes[]    = {Array::INPUTTYPE_FLOAT, Array::INPUTTYPE_SHORT, Array::INPUTTYPE_BYTE, /*Array::INPUTTYPE_UNSIGNED_SHORT, Array::INPUTTYPE_UNSIGNED_BYTE,*/ Array::INPUTTYPE_FIXED};
 142         Array::Storage          storages[]              = {Array::STORAGE_BUFFER};
 143         int                                     counts[]                = {1, 256};
 144         int                                     strides[]               = {17};
 145
 146         for (int inputTypeNdx = 0; inputTypeNdx < DE_LENGTH_OF_ARRAY(inputTypes); inputTypeNdx++)
 147         {
 148                 for (int storageNdx = 0; storageNdx < DE_LENGTH_OF_ARRAY(storages); storageNdx++)
 149                 {
 150                         for (int componentCount = 2; componentCount < 5; componentCount++)
 151                         {
 152                                 for (int countNdx = 0; countNdx < DE_LENGTH_OF_ARRAY(counts); countNdx++)
 153                                 {
 154                                         for (int strideNdx = 0; strideNdx < DE_LENGTH_OF_ARRAY(strides); strideNdx++)
 155                                         {
 156                                                 const int       stride                  = (strides[strideNdx] < 0 ? Array::inputTypeSize(inputTypes[inputTypeNdx]) * componentCount : strides[strideNdx]);
 157                                                 const bool      bufferUnaligned = (storages[storageNdx] == Array::STORAGE_BUFFER) && (stride % Array::inputTypeSize(inputTypes[inputTypeNdx])) != 0;
 158
 159                                                 MultiVertexArrayTest::Spec::ArraySpec arraySpec(inputTypes[inputTypeNdx],
 160                                                                                                                                                 Array::OUTPUTTYPE_VEC4,
 161                                                                                                                                                 storages[storageNdx],
 162                                                                                                                                                 Array::USAGE_DYNAMIC_DRAW,
 163                                                                                                                                                 componentCount,
 164                                                                                                                                                 0,
 165                                                                                                                                                 stride,
 166                                                                                                                                                 false,
 167                                                                                                                                                 GLValue::getMinValue(inputTypes[inputTypeNdx]),
 168                                                                                                                                                 GLValue::getMaxValue(inputTypes[inputTypeNdx]));
 169
 170                                                 MultiVertexArrayTest::Spec spec;
 171                                                 spec.primitive  = Array::PRIMITIVE_TRIANGLES;
 172                                                 spec.drawCount  = counts[countNdx];
 173                                                 spec.first              = 0;
 174                                                 spec.arrays.push_back(arraySpec);
 175
 176                                                 std::string name = spec.getName();
 177                                                 if (bufferUnaligned)
 178                                                         addChild(new MultiVertexArrayTest(m_testCtx, m_context.getRenderContext(), spec, name.c_str(), name.c_str()));
 179                                         }
 180                                 }
 181                         }
 182                 }
 183         }
 184 }
 185
 186 class SingleVertexArrayFirstTests : public TestCaseGroup
 187 {
 188 public:
 189                                                                         SingleVertexArrayFirstTests     (Context& context);
 190         virtual                                                 ~SingleVertexArrayFirstTests    (void);
 191
 192         virtual void                                    init                                                    (void);
 193
 194 private:
 195                                                                         SingleVertexArrayFirstTests     (const SingleVertexArrayFirstTests& other);
 196         SingleVertexArrayFirstTests&    operator=                                               (const SingleVertexArrayFirstTests& other);
 197 };
 198
 199 SingleVertexArrayFirstTests::SingleVertexArrayFirstTests (Context& context)
 200         : TestCaseGroup(context, "first", "Single vertex atribute different first values")
 201 {
 202 }
 203
 204 SingleVertexArrayFirstTests::~SingleVertexArrayFirstTests (void)
 205 {
 206 }
 207
 208 void SingleVertexArrayFirstTests::init (void)
 209 {
 210         // Test strides with different input types, component counts and storage, Usage(?)
 211         Array::InputType        inputTypes[]    = {Array::INPUTTYPE_FLOAT, Array::INPUTTYPE_BYTE, Array::INPUTTYPE_FIXED};
 212         int                                     counts[]                = {5, 256};
 213         int                                     firsts[]                = {6, 24};
 214         int                                     offsets[]               = {1, 17};
 215         int                                     strides[]               = {/*0,*/ -1, 17, 32}; // Tread negative value as sizeof input. Same as 0, but done outside of GL.
 216
 217         for (int inputTypeNdx = 0; inputTypeNdx < DE_LENGTH_OF_ARRAY(inputTypes); inputTypeNdx++)
 218         {
 219                 for (int offsetNdx = 0; offsetNdx < DE_LENGTH_OF_ARRAY(offsets); offsetNdx++)
 220                 {
 221                         for (int countNdx = 0; countNdx < DE_LENGTH_OF_ARRAY(counts); countNdx++)
 222                         {
 223                                 for (int strideNdx = 0; strideNdx < DE_LENGTH_OF_ARRAY(strides); strideNdx++)
 224                                 {
 225                                         for (int firstNdx = 0; firstNdx < DE_LENGTH_OF_ARRAY(firsts); firstNdx++)
 226                                         {
 227                                                 const int       stride  = (strides[strideNdx] < 0 ? Array::inputTypeSize(inputTypes[inputTypeNdx]) * 2 : strides[strideNdx]);
 228                                                 const bool      aligned = ((stride % Array::inputTypeSize(inputTypes[inputTypeNdx])) == 0) && (offsets[offsetNdx] % Array::inputTypeSize(inputTypes[inputTypeNdx]) == 0);
 229
 230                                                 MultiVertexArrayTest::Spec::ArraySpec arraySpec(inputTypes[inputTypeNdx],
 231                                                                                                                                                 Array::OUTPUTTYPE_VEC2,
 232                                                                                                                                                 Array::STORAGE_BUFFER,
 233                                                                                                                                                 Array::USAGE_DYNAMIC_DRAW,
 234                                                                                                                                                 2,
 235                                                                                                                                                 offsets[offsetNdx],
 236                                                                                                                                                 stride,
 237                                                                                                                                                 false,
 238                                                                                                                                                 GLValue::getMinValue(inputTypes[inputTypeNdx]),
 239                                                                                                                                                 GLValue::getMaxValue(inputTypes[inputTypeNdx]));
 240
 241                                                 MultiVertexArrayTest::Spec spec;
 242                                                 spec.primitive  = Array::PRIMITIVE_TRIANGLES;
 243                                                 spec.drawCount  = counts[countNdx];
 244                                                 spec.first              = firsts[firstNdx];
 245                                                 spec.arrays.push_back(arraySpec);
 246
 247                                                 std::string name = Array::inputTypeToString(inputTypes[inputTypeNdx]) + "_first" + typeToString(firsts[firstNdx]) + "_offset" + typeToString(offsets[offsetNdx]) + "_stride" + typeToString(stride) + "_quads" + typeToString(counts[countNdx]);
 248                                                 if (!aligned)
 249                                                         addChild(new MultiVertexArrayTest(m_testCtx, m_context.getRenderContext(), spec, name.c_str(), name.c_str()));
 250                                         }
 251                                 }
 252                         }
 253                 }
 254         }
 255 }
 256
 257 class SingleVertexArrayOffsetTests : public TestCaseGroup
 258 {
 259 public:
 260                                                                         SingleVertexArrayOffsetTests    (Context& context);
 261         virtual                                                 ~SingleVertexArrayOffsetTests   (void);
 262
 263         virtual void                                    init                                                    (void);
 264
 265 private:
 266                                                                         SingleVertexArrayOffsetTests    (const SingleVertexArrayOffsetTests& other);
 267         SingleVertexArrayOffsetTests&   operator=                                               (const SingleVertexArrayOffsetTests& other);
 268 };
 269
 270 SingleVertexArrayOffsetTests::SingleVertexArrayOffsetTests (Context& context)
 271         : TestCaseGroup(context, "offset", "Single vertex atribute offset element")
 272 {
 273 }
 274
 275 SingleVertexArrayOffsetTests::~SingleVertexArrayOffsetTests (void)
 276 {
 277 }
 278
 279 void SingleVertexArrayOffsetTests::init (void)
 280 {
 281         // Test strides with different input types, component counts and storage, Usage(?)
 282         Array::InputType        inputTypes[]    = {Array::INPUTTYPE_FLOAT, Array::INPUTTYPE_BYTE, Array::INPUTTYPE_FIXED};
 283         int                                     counts[]                = {1, 256};
 284         int                                     offsets[]               = {1, 4, 17, 32};
 285         int                                     strides[]               = {/*0,*/ -1, 17, 32}; // Tread negative value as sizeof input. Same as 0, but done outside of GL.
 286
 287         for (int inputTypeNdx = 0; inputTypeNdx < DE_LENGTH_OF_ARRAY(inputTypes); inputTypeNdx++)
 288         {
 289                 for (int offsetNdx = 0; offsetNdx < DE_LENGTH_OF_ARRAY(offsets); offsetNdx++)
 290                 {
 291                         for (int countNdx = 0; countNdx < DE_LENGTH_OF_ARRAY(counts); countNdx++)
 292                         {
 293                                 for (int strideNdx = 0; strideNdx < DE_LENGTH_OF_ARRAY(strides); strideNdx++)
 294                                 {
 295                                         const int       stride  = (strides[strideNdx] < 0 ? Array::inputTypeSize(inputTypes[inputTypeNdx]) * 2 : strides[strideNdx]);
 296                                         const bool      aligned = ((stride % Array::inputTypeSize(inputTypes[inputTypeNdx])) == 0) && ((offsets[offsetNdx] % Array::inputTypeSize(inputTypes[inputTypeNdx])) == 0);
 297
 298                                         MultiVertexArrayTest::Spec::ArraySpec arraySpec(inputTypes[inputTypeNdx],
 299                                                                                                                                         Array::OUTPUTTYPE_VEC2,
 300                                                                                                                                         Array::STORAGE_BUFFER,
 301                                                                                                                                         Array::USAGE_DYNAMIC_DRAW,
 302                                                                                                                                         2,
 303                                                                                                                                         offsets[offsetNdx],
 304                                                                                                                                         stride,
 305                                                                                                                                         false,
 306                                                                                                                                         GLValue::getMinValue(inputTypes[inputTypeNdx]),
 307                                                                                                                                         GLValue::getMaxValue(inputTypes[inputTypeNdx]));
 308
 309                                         MultiVertexArrayTest::Spec spec;
 310                                         spec.primitive  = Array::PRIMITIVE_TRIANGLES;
 311                                         spec.drawCount  = counts[countNdx];
 312                                         spec.first              = 0;
 313                                         spec.arrays.push_back(arraySpec);
 314
 315                                         std::string name = spec.getName();
 316                                         if (!aligned)
 317                                                 addChild(new MultiVertexArrayTest(m_testCtx, m_context.getRenderContext(), spec, name.c_str(), name.c_str()));
 318                                 }
 319                         }
 320                 }
 321         }
 322 }
 323
 324 } // anonymous
 325
 326 VertexArrayTests::VertexArrayTests (Context& context)
 327         : TestCaseGroup(context, "vertex_arrays", "Vertex array and array tests")
 328 {
 329 }
 330
 331 VertexArrayTests::~VertexArrayTests (void)
 332 {
 333 }
 334
 335 void VertexArrayTests::init (void)
 336 {
 337         tcu::TestCaseGroup* const group = new tcu::TestCaseGroup(m_testCtx, "single_attribute", "Single attribute");
 338         addChild(group);
 339
 340         // .single_attribute
 341         {
 342                 group->addChild(new SingleVertexArrayStrideTests(m_context));
 343                 group->addChild(new SingleVertexArrayUsageTests(m_context));
 344                 group->addChild(new SingleVertexArrayOffsetTests(m_context));
 345                 group->addChild(new SingleVertexArrayFirstTests(m_context));
 346         }
 347 }
 348
 349 } // Stress
 350 } // gles2
 351 } // deqp